diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md
index 63928ab40..438584ded 100644
--- a/.claude/CLAUDE.md
+++ b/.claude/CLAUDE.md
@@ -25,7 +25,7 @@ These repo-local skills live under `.claude/skills/*/SKILL.md`.
 - [review-quality](skills/review-quality/SKILL.md) -- Generic code quality review: DRY, KISS, cohesion/coupling, test quality, HCI. Read-only, no code changes. Called by `review-pipeline`.
 - [fix-pr](skills/fix-pr/SKILL.md) -- Resolve PR review comments, fix CI failures, and address codecov coverage gaps. Uses `gh api` for codecov (not local `cargo-llvm-cov`).
 - [write-model-in-paper](skills/write-model-in-paper/SKILL.md) -- Write or improve a problem-def entry in the Typst paper (standalone, for improving existing entries). Core instructions are inlined in `add-model` Step 6.
-- [write-rule-in-paper](skills/write-rule-in-paper/SKILL.md) -- Write or improve a reduction-rule entry in the Typst paper (standalone, for improving existing entries). Core instructions are inlined in `add-rule` Step 5.
+- [write-rule-in-paper](skills/write-rule-in-paper/SKILL.md) -- Write or improve a reduction-rule entry in the Typst paper (standalone, for improving existing entries). Core instructions are inlined in `add-rule` Step 6.
 - [release](skills/release/SKILL.md) -- Create a new crate release. Determines version bump from diff, verifies tests/clippy, then runs `make release`.
 - [check-issue](skills/check-issue/SKILL.md) -- Quality gate for `[Rule]` and `[Model]` issues. Checks usefulness, non-triviality, correctness of literature, and writing quality. Posts structured report and adds failure labels.
 - [fix-issue](skills/fix-issue/SKILL.md) -- Fix quality issues found by check-issue — auto-fixes mechanical problems, brainstorms substantive issues with human, then re-checks and moves to Ready.
@@ -59,7 +59,7 @@ make fmt-check      # Check code formatting
 make clippy         # Run clippy lints
 make doc            # Build mdBook documentation (includes reduction graph export)
 make mdbook         # Build and serve mdBook with live reload
-make paper          # Build Typst paper from checked-in example fixtures
+make paper          # Generate example data and build the Typst paper
 make coverage       # Generate coverage report (>95% required)
 make check          # Quick pre-commit check (fmt + clippy + test)
 make rust-export    # Generate Julia parity test data (mapping stages)
@@ -107,7 +107,7 @@ make papers-pull   # Pull PDFs from shared remote
   - Run `pred list` for the full catalog of problems, variants, and reductions; `pred show <name>` for details on a specific problem
 - `src/rules/` - Reduction rules + inventory registration
 - `src/models/decision.rs` - Generic `Decision<P>` wrapper converting optimization problems to decision problems
-- `src/solvers/` - BruteForce solver for aggregate values plus witness recovery when supported, ILP solver (feature-gated, witness-only), decision search (binary search via Decision queries). To check if a problem supports ILP solving via a witness-capable reduction path, run `pred path <ProblemName> ILP`
+- `src/solvers/` - BruteForce reference solver returning problem solutions, ILP solver (feature-gated), decision search (binary search via Decision queries), and the exact-variant solver capability registry. Solver dispatch uses only registered customized implementations and fixed ILP pipelines; reduction-graph reachability does not imply solver availability. Run `pred inspect <instance>` to see the registered capabilities for that instance.
 - `src/traits.rs` - `Problem` trait
 - `src/rules/traits.rs` - `ReduceTo<T>`, `ReduceToAggregate<T>`, `ReductionResult`, `AggregateReductionResult` traits
 - `src/registry/` - Compile-time reduction metadata collection
@@ -124,19 +124,26 @@ make papers-pull   # Pull PDFs from shared remote
 Problem (core trait — all problems must implement)
 │
 ├── const NAME: &'static str           // e.g., "MaximumIndependentSet"
-├── type Value: Clone                  // aggregate value: Max/Min/Sum/Or/And/Extremum/...
-├── fn dims(&self) -> Vec<usize>       // config space: [2, 2, 2] for 3 binary variables
-├── fn evaluate(&self, config) -> Value
-├── fn variant() -> Vec<(&str, &str)>  // e.g., [("graph","SimpleGraph"), ("weight","i32")]
-├── fn num_variables(&self) -> usize   // default: dims().len()
+├── type Solution                      // mathematical witness representation
+├── type Value: Clone                  // per-solution evaluation value
+├── fn parameter_names()               // canonical problem-owned parameter schema
+├── fn parameters(&self) -> ProblemParameters // concrete instance parameter values
+├── fn evaluate(&self, solution) -> Result<Value, EvaluationError>
+├── fn variant() -> Vec<(&str, &str)>  // e.g., [("graph","SimpleGraph"), ("weight","i64")]
 └── fn problem_type() -> ProblemType   // catalog bridge: registry lookup by NAME
 ```
 
-**Witness-capable objective problems** (e.g., `MaximumIndependentSet`) typically use `Value = Max<W::Sum>`, `Min<W::Sum>`, or `Extremum<W::Sum>`.
+`BruteForceProblem` is a separate reference-solver capability. Its
+`dimensions()` method describes only the finite Cartesian coordinate space used
+by the registered brute-force implementation.
 
-**Witness-capable feasibility problems** (e.g., `Satisfiability`) typically use `Value = Or`.
+**Objective problems** (e.g., `MaximumIndependentSet`) typically use `Value = Max<W::Sum>`, `Min<W::Sum>`, or `Extremum<W::Sum>`.
 
-**Aggregate-only problems** use fold values such as `Sum<W>` or `And`; these solve to a value but have no representative witness configuration.
+**Feasibility problems** (e.g., `Satisfiability`) typically use `Value = Or`.
+
+A successful `Problem` solve always returns `Problem::Solution`. Global counting
+or statistics without a representative solution are not modeled as `Problem`
+solves.
 
 **Decision problems** wrap an optimization problem with a bound: `Decision<P>` where `P::Value: OptimizationValue`. Evaluates to `Or(true)` when the inner objective meets the bound (≤ for Min, ≥ for Max).
 
@@ -150,36 +157,40 @@ Max<V>, Min<V>, Sum<W>, Or, And, Extremum<V>, ExtremumSense
 - `Max<V>`: meets bound when value ≥ bound
 
 ### Key Patterns
+- Keep failure phases typed and separate: public construction paths return `ConstructionError`, `Problem::evaluate()` returns `EvaluationError`, and reduction paths return `ReductionError`. A reduction preserves target construction failures as `ReductionError::Construction`; none of these paths returns or creates an error as a bare `String`.
 - `variant_params!` macro implements `Problem::variant()` — e.g., `crate::variant_params![G, W]` for two type params, `crate::variant_params![]` for none (see `src/variant.rs`)
-- `declare_variants!` proc macro registers concrete type instantiations with best-known complexity and registry-backed load/serialize/value-solve/witness-solve metadata. One entry per problem may be marked `default`, and variable names in complexity strings are validated at compile time against actual getter methods.
+- `declare_variants!` proc macro registers concrete type instantiations with best-known complexity and registry-backed load/serialize/solution-solve metadata. One entry per problem may be marked `default`, and variable names in complexity strings are validated against the problem-owned parameter schema. Ordinary models are constructed directly from their construction schema. When user-facing construction differs from persisted JSON, define a model-local `#[derive(CreateSpec)]` DTO plus `TryFrom<CreateSpec>`, use its generated `FIELDS` in `ProblemSchemaEntry`, and register it with `create LocalSpec`; never add model-name branches in CLI or MCP code.
 - `decision_problem_meta!` macro registers `DecisionProblemMeta` for a concrete inner type, providing the `DECISION_NAME` constant.
-- `register_decision_variant!` macro generates `declare_variants!`, `ProblemSchemaEntry`, and both `ReductionEntry` submissions (aggregate Decision→Opt + Turing Opt→Decision) for a `Decision<P>` variant. Callers must define inherent getters (`num_vertices()`, `num_edges()`, `k()`) on `Decision<P>` before invoking. Accepts `dims`, `fields`, and `size_getters` parameters for problem-specific size fields.
+- `register_decision_variant!` macro generates `declare_variants!`, `ProblemSchemaEntry`, and both `ReductionEntry` submissions (aggregate Decision→Opt + Turing Opt→Decision) for a `Decision<P>` variant. Callers must define inherent getters (`num_vertices()`, `num_edges()`, `k()`) on `Decision<P>` before invoking. Accepts an explicit structural `category` plus `dims`, `fields`, and `parameter_getters` parameters for problem-specific parameters.
 - Problems parameterized by graph type `G` and optionally weight type `W` (problem-dependent)
-- `Solver::solve()` computes the aggregate value for any `Problem` whose `Value` implements `Aggregate`
-- `BruteForce::find_witness()` / `find_all_witnesses()` recover witnesses only when `P::Value::supports_witnesses()`
+- `BruteForce::solve()` returns `Result<Option<P::Solution>, SolveError>`; `None` means exhaustive search proved infeasibility
+- `BruteForce::find_all_witnesses()` is a reference-testing helper for collecting every optimal or satisfying solution
 - `ReductionResult` provides `target_problem()` and `extract_solution()` for witness/config workflows; `AggregateReductionResult` provides `extract_value()` for aggregate/value workflows
+- Every direct `extract_solution()` must call `validate_target_solution()` once before decoding; composed extractors delegate validation to the first direct decoder.
+- Decode only the reduction's defined mathematical mapping. Reject malformed structure with `ExtractionError`; never panic, truncate, clamp, invent defaults, or add recovery branches. Explicit mathematical alternatives and sentinels are allowed. Test successful decoding and every rejected representation.
 - CLI-facing dynamic formatting uses aggregate wrapper names directly (for example `Max(2)`, `Min(None)`, `Or(true)`, or `Sum(56)`)
 - Graph types: SimpleGraph, PlanarGraph, BipartiteGraph, UnitDiskGraph, KingsSubgraph, TriangularSubgraph
-- Weight types: `One` (unit weight marker), `i32`, `f64` — all implement `WeightElement` trait
+- Weight types: `One` (unit weight marker), `i64`, `f64` — all implement `WeightElement` trait
 - `WeightElement` trait: `type Sum: NumericSize` + `fn to_sum(&self)` — converts weight to a summable numeric type
 - Weight management via inherent methods (`weights()`, `set_weights()`, `is_weighted()`), not traits
 - `NumericSize` supertrait bundles common numeric bounds (`Clone + Default + PartialOrd + Num + Zero + Bounded + AddAssign + 'static`)
 
-### Overhead System
-Reduction overhead is expressed using `Expr` AST (in `src/expr.rs`) with the `#[reduction]` macro. The `overhead` attribute is **required** — omitting it is a compile error:
+### Parameter Relations
+Each reduction declares one rule-level parameter relation using the `Expr` AST in `src/expr.rs`. The `transform` declaration is required:
 ```rust
-#[reduction(overhead = {
+#[reduction(transform = upper_bound {
     num_vertices = "num_vertices + num_clauses",
     num_edges = "3 * num_clauses",
 })]
 impl ReduceTo<Target> for Source { ... }
 ```
 - Expression strings are parsed at compile time by a Pratt parser in the proc macro crate
-- Variable names are validated against actual getter methods on the source type — typos cause compile errors
-- Each problem type provides inherent getter methods (e.g., `num_vertices()`, `num_edges()`) that the overhead expressions reference
-- **Overhead expressions describe scaling (asymptotic upper bounds), not exact sizes.** To determine the actual target problem size for a specific instance, read the `reduce_to()` construction code and count the actual variables/constraints/vertices built.
-- `ReductionOverhead` stores `Vec<(&'static str, Expr)>` — field name to symbolic expression mappings
-- `ReductionEntry` has both symbolic (`overhead_fn`) and compiled (`overhead_eval_fn`) evaluation — the compiled version calls getters directly
+- Variable names are validated against the source problem's canonical parameter schema
+- Use `transform = exact { ... }` when every formula is an equality and `transform = upper_bound { ... }` when every formula is only an upper bound. One expression block cannot mix relations.
+- Use `transform = unavailable { ... }` when no formula is representable, or an auxiliary `unavailable = { ... }` block for omitted target parameters.
+- Every target parameter must appear exactly once as a formula or as unavailable with a non-empty reason.
+- `ParameterTransform` evaluates and composes formulas with exact rational and arbitrary-precision integer arithmetic. Unsafe upper-bound composition becomes unavailable; it never performs budget pruning or path ranking.
+- Concrete instance parameters come from each endpoint instance's `Problem::parameters()` implementation; `ReductionEntry` stores only the symbolic parameter relation.
 - `VariantEntry` has both a complexity string and compiled `complexity_eval_fn` — same pattern
 - Expressions support: constants, variables, `+`, `-`, `*`, `/`, `^`, `exp()`, `log()`, `sqrt()`, `factorial()`
 - Complexity strings must use **concrete numeric values only** (e.g., `"2^(2.372 * num_vertices / 3)"`, not `"2^(omega * num_vertices / 3)"`)
@@ -190,32 +201,53 @@ Problem types use explicit optimization prefixes (`Maximum...`, `Minimum...`) or
 
 ### Problem Variants
 Reduction graph nodes use variant key-value pairs from `Problem::variant()`:
-- Base: `MaximumIndependentSet` (empty variant = defaults)
+- Default: `MaximumIndependentSet {graph: "SimpleGraph", weight: "One"}`
 - Graph variant: `MaximumIndependentSet {graph: "KingsSubgraph", weight: "One"}`
-- Weight variant: `MaximumIndependentSet {graph: "SimpleGraph", weight: "f64"}`
-- Default variant ranking: `SimpleGraph`, `One`, `KN` are considered default values; variants with the most default values sort first
-- Nodes come exclusively from `#[reduction]` registrations; natural edges between same-name variants are inferred from the graph/weight subtype partial order
+- Weight variant: `MaximumIndependentSet {graph: "SimpleGraph", weight: "i64"}`
+- Each problem declares one default concrete variant through `declare_variants!`; variant listings place that declaration first
+- Nodes come from concrete `declare_variants!` registrations
+- Same-name variant relations are explicit `#[reduction]` registrations
 - Each primitive reduction is determined by the exact `(source_variant, target_variant)` endpoint pair
 - Reduction edges carry `EdgeCapabilities { witness, aggregate, turing }`; graph search defaults to witness mode, aggregate mode is available through `ReductionMode::Aggregate`, and Turing (multi-query) mode via `ReductionMode::Turing`
-- `#[reduction]` accepts only `overhead = { ... }` and currently registers witness/config reductions; aggregate-only and Turing edges require manual `ReductionEntry` registration
+- `#[reduction]` requires one `transform = exact`, `transform = upper_bound`, or `transform = unavailable` declaration and currently registers witness/config reductions; aggregate-only and Turing edges require manual `ReductionEntry` registration
 - `Decision<P> → P` is an aggregate-only edge (solve optimization, compare to bound); `P → Decision<P>` is a Turing edge (binary search over decision bound)
 
 ### Extension Points
-- New models register dynamic load/serialize/brute-force dispatch through `declare_variants!` in the model file, not by adding manual match arms in the CLI
-- **CLI creation is schema-driven:** `pred create` automatically maps `ProblemSchemaEntry` fields to CLI flags via `snake_case → kebab-case` convention. New models need only: (1) matching CLI flags in `CreateArgs` + `flag_map()`, and (2) type parser support in `parse_field_value()` if using a new field type. No match arm in `create.rs` is needed.
-- **CLI flag names must match schema field names.** The canonical name for a CLI flag is the schema field name in kebab-case (e.g., schema field `universe_size` → `--universe-size`, field `subsets` → `--subsets`). Old aliases (e.g., `--universe`, `--sets`) may exist as clap `alias` for backward compatibility at the clap level, but `flag_map()`, help text, error messages, and documentation must use the schema-derived name. Do not add new backward-compat aliases; if a field is renamed in the schema, update the CLI flag name to match.
-- **Decision variants** of optimization problems use `Decision<P>` wrapper. Add via: (1) `decision_problem_meta!` for the inner type, (2) inherent methods on `Decision<Inner>`, (3) `register_decision_variant!` with `dims`, `fields`, `size_getters`. Schema-driven CLI creation auto-restructures flat JSON into `{inner: {...}, bound}`.
-- Aggregate-only models are first-class in `declare_variants!`; aggregate-only and Turing reduction edges still need manual `ReductionEntry` wiring because `#[reduction]` only registers witness/config reductions today
+- New models register dynamic load/serialize metadata through `declare_variants!` and, when finite enumeration exists, register it separately through `register_brute_force!`; neither belongs in CLI match arms
+- **Model category is explicit registry metadata.** Every `ProblemSchemaEntry` declares exactly one of `Algebraic`, `Formula`, `Graph`, `Misc`, or `Set`; catalog behavior never derives it from `module_path!()` or source location.
+- **CLI creation is registry-driven and two-stage:** the static parser discovers the requested problem spec without registering model subcommands, then a second parse adds flags only for the selected concrete variant. Ordinary models use `ProblemSchemaEntry.fields` directly. Models whose construction differs from persisted JSON own a typed `CreateSpec` and fallible conversion beside the model; CLI and MCP only normalize transport values and invoke the registered constructor.
+- **Each construction input has one name and one concrete type per variant.** Do not add compatibility aliases or infer types from flag names. `CreateSpec` field names render as `snake_case → kebab-case` in CLI and remain `snake_case` in MCP. Add a reusable codec only for a genuinely new transport representation, never a model-name parser branch.
+- **Random generation is optional and variant-owned.** Not every model has a useful, well-defined random-instance distribution. Add `RandomGenerate` only when the generator has clear semantics and a concrete use (for example, testing or examples); never invent arbitrary bounds or distributions merely to make every model support `--random`. Implement it beside the model (normally through `impl_random_generate!` and a typed `CreateSpec` input DTO), then add `random` only to the applicable `declare_variants!` entries. CLI and MCP discover the exact variant's inputs and callback; never add a model-name random dispatch or advertise random generation on an unsupported variant.
+- **Decision variants** of optimization problems use `Decision<P>` wrapper. Add via: (1) `decision_problem_meta!` for the inner type, (2) inherent methods on `Decision<Inner>`, (3) `register_decision_variant!` with `dims`, `fields`, `parameter_getters`. The generated construction spec accepts flat inner fields plus `bound`; persisted JSON remains `{inner: {...}, bound}`. `Decision<P>` delegates canonical parameters to `P`; its objective bound is semantic instance data, not a problem parameter.
+- Aggregate-only and Turing reduction edges still need manual `ReductionEntry` wiring because `#[reduction]` only registers solution-mapping reductions today; this edge capability does not imply that a problem may solve successfully without a `Solution`
 - Exact registry dispatch lives in `src/registry/`; alias resolution and partial/default variant resolution live in `problemreductions-cli/src/problem_name.rs`
 - `pred create` schema-driven dispatch lives in `problemreductions-cli/src/commands/create.rs` (`create_schema_driven()`)
-- Canonical paper and CLI examples live in `src/example_db/model_builders.rs` and `src/example_db/rule_builders.rs`
+- Canonical model examples live in `src/example_db/model_builders.rs`; rule examples live beside their rules and are collected by `src/rules/mod.rs`
 
 ## Conventions
 
+### Numeric Contract
+
+Follow the [numeric types and arithmetic standard](../docs/src/design.md#numeric-types-and-arithmetic)
+for every model and reduction. `usize` is reserved for in-memory indices,
+collection lengths, and brute-force dimensions; canonical problem parameters
+are `u64`; signed mathematical integers use `i64`; and approximate
+real values use finite `f64`. Before implementation, identify each numeric
+input and domain, each computed total and result type, the largest supported
+value, every range/sign-changing conversion, overflow behavior, and whether
+arithmetic is exact or approximate. Use `TryFrom` at range boundaries and
+checked arithmetic for derived values that may overflow. Rust construction,
+serde, CLI, and MCP must enforce the same range.
+
+Issue contributors provide the mathematical definition, domains, and
+constraints; implementers derive the Rust representation. Do not require issue
+authors to choose implementation types or add implementation-specific numeric
+fields to issue templates. Changes to issue templates require user approval.
+
 ### File Naming
 - Reduction files: `src/rules/<source>_<target>.rs` (e.g., `maximumindependentset_qubo.rs`)
 - Model files: `src/models/<category>/<name>.rs` — category is by input structure: `graph/` (graph input), `formula/` (boolean formula/circuit), `set/` (universe + subsets), `algebraic/` (matrix/linear system/lattice), `misc/` (other)
-- Canonical examples: builder functions in `src/example_db/rule_builders.rs` and `src/example_db/model_builders.rs`
+- Canonical examples: model builders in `src/example_db/model_builders.rs`; rule-local `canonical_rule_example_specs()` functions collected by `src/rules/mod.rs`
 - Example binaries in `examples/`: utility/export tools and pedagogical demos only (not per-reduction files)
 - Test naming: `test_<source>_to_<target>_closed_loop`
 
@@ -233,8 +265,8 @@ Reduction graph nodes use variant key-value pairs from `Problem::variant()`:
 **Reference implementations — read these first:**
 - **Reduction test:** `src/unit_tests/rules/minimumvertexcover_maximumindependentset.rs` — closed-loop pattern
 - **Model test:** `src/unit_tests/models/graph/maximum_independent_set.rs` — evaluation, serialization
-- **Solver test:** `src/unit_tests/solvers/brute_force.rs` — aggregate `solve()` plus witness recovery helpers
-- **Trait definitions:** `src/traits.rs` (`Problem`), `src/solvers/mod.rs` (`Solver`)
+- **Solver test:** `src/unit_tests/solvers/brute_force.rs` — solution-returning `solve()` plus all-solution helpers
+- **Core definitions:** `src/traits.rs` (`Problem`), `src/solvers/brute_force.rs` (`BruteForce`)
 
 ### Coverage
 
@@ -261,7 +293,7 @@ Model review automation checks for a dedicated test file under `src/unit_tests/m
 - `.claude/` — Claude Code instructions and skills
 - `docs/book/` — mdBook user documentation (built with `make doc`)
 - `docs/paper/reductions.typ` — Typst paper with problem definitions and reduction theorems
-- `src/example_db/` — Canonical model/rule examples: `model_builders.rs`, `rule_builders.rs` (in-memory builders), `specs.rs` (per-module invariant specs), consumed by `pred create --example` and paper exports
+- `src/example_db/` — Model builders, shared example specs, and rule-example aggregation consumed by `pred create --example` and paper exports
 - `examples/` — Export utilities, graph-analysis helpers, and pedagogical demos
 
 ## Documentation Requirements
@@ -309,10 +341,10 @@ The complexity string represents the **worst-case time complexity of the best kn
 5. Use only concrete numeric values — no symbolic constants (epsilon, omega); inline the actual numbers with citations
 6. Variable names must match getter methods on the problem type (enforced at compile time)
 
-### Reduction Overhead (`#[reduction(overhead = {...})]`)
-Overhead expressions describe how target problem size relates to source problem size. To verify correctness:
+### Reduction Parameter Relation (`#[reduction(transform = exact|upper_bound {...})]`)
+Parameter expressions describe how target problem parameters relate to source problem parameters. To verify correctness:
 1. Read the `reduce_to()` implementation and count the actual output sizes
 2. Check that each field (e.g., `num_vertices`, `num_edges`, `num_sets`) matches the constructed target problem
 3. Watch for common errors: universe elements mismatch (edge indices vs vertex indices), worst-case edge counts in intersection graphs (quadratic, not linear), constant factors in circuit constructions
-4. Test with concrete small instances: construct a source problem, run the reduction, and compare target sizes against the formula
+4. Test with concrete small instances: construct a source problem, run the reduction, and compare target parameters against the formula
 5. Ensure there is only one primitive reduction registration for each exact source/target variant pair; wrap shared helpers instead of registering duplicate endpoints
diff --git a/.claude/skills/add-model/SKILL.md b/.claude/skills/add-model/SKILL.md
index 54f4c2292..6cf14b947 100644
--- a/.claude/skills/add-model/SKILL.md
+++ b/.claude/skills/add-model/SKILL.md
@@ -68,14 +68,16 @@ Read these first to understand the patterns:
 - **Model tests:** `src/unit_tests/models/graph/maximum_independent_set.rs`
 - **Trait definitions / aggregate types:** `src/traits.rs` (`Problem`), `src/types.rs` (`Aggregate`, `Max`, `Min`, `Sum`, `Or`, `And`, `Extremum`)
 - **Registry dispatch boundary:** `src/registry/mod.rs`, `src/registry/variant.rs`
-- **CLI aliases:** `problemreductions-cli/src/problem_name.rs`
-- **CLI creation:** `problemreductions-cli/src/commands/create.rs`
+- **CLI and MCP construction:** discovered from the model's registry entry; no frontend model-name dispatch
 - **Canonical model examples:** `src/example_db/model_builders.rs`
 
 ## Pre-review Checklist
 
 Before implementing, make sure the plan explicitly covers these items that structural review checks later:
-- `ProblemSchemaEntry` metadata is complete for the current schema shape (`display_name`, `aliases`, `dimensions`, and constructor-facing `fields`)
+- Follow `docs/src/design.md#numeric-types-and-arithmetic`: `usize` is for in-memory indices, collection lengths, and brute-force dimensions; registered problem size parameters use `u64`; signed mathematical integers use `i64`; Boolean data uses `bool`; and approximate real or rational data uses finite `f64`. Use another format only when required by the mathematical problem or schema, such as `BigUint` for arbitrary-precision problems or `One` for unit weights; implementation convenience is not sufficient, and there is no `i32` model or I/O format. Implementation-local values are outside this contract.
+- Keep failure phases explicit: fallible constructors, create specs, serde-facing validation, and random generation return `ConstructionError`; `evaluate()` returns `EvaluationError`; no public model path returns `Result<_, String>`. Stored-field arithmetic and evaluation arithmetic are checked and reported in their own phase.
+- Serde/CLI construction uses the same validation as `new`/`try_new`, and boundary tests cover the supported maximum without requiring impractical allocation.
+- `ProblemSchemaEntry` metadata is complete (`display_name`, `aliases`, `dimensions`, explicit `category`, and construction `fields`)
 - `Problem::Value` uses the correct aggregate wrapper and witness support is intentional
 - `declare_variants!` is present with exactly one `default` variant when multiple concrete variants exist
 - CLI discovery and `pred create <ProblemName>` support are included where applicable
@@ -92,6 +94,8 @@ Choose the appropriate sub-module under `src/models/`:
 - `algebraic/` -- matrices, linear systems, lattices (QUBO, ILP, CVP, BMF)
 - `misc/` -- unique input structures that don't fit other categories (BinPacking, PaintShop, Factoring)
 
+Declare the same structural choice explicitly in `ProblemSchemaEntry.category`. This is required metadata and is never inferred from `module_path!()` or the file location.
+
 ## Step 1.5: Infer problem size getters
 
 From the **best known exact algorithm** complexity (item 9), infer what problem size getter methods the struct should expose. The variables used in the complexity expression define the natural size metrics.
@@ -122,14 +126,14 @@ Create `src/models/<category>/<name>.rs`:
 ```
 
 Key decisions:
-- **Schema metadata:** `ProblemSchemaEntry` must reflect the current registry schema shape, including `display_name`, `aliases`, `dimensions`, and constructor-facing `fields`
+- **Schema metadata:** `ProblemSchemaEntry` must include the explicit structural `category` and reflect the construction interface through `display_name`, `aliases`, `dimensions`, and `fields`
 - **Objective problems:** use `type Value = Max<_>`, `Min<_>`, or `Extremum<_>` when the model should expose optimization-style witness helpers
 - **Witness problems:** use `type Value = Or` for existential feasibility problems
 - **Aggregate-only problems:** use a value-only aggregate such as `Sum<_>`, `And`, or a custom `Aggregate` when witnesses are not meaningful
 - **Weight management:** use inherent methods (`weights()`, `set_weights()`, `is_weighted()`), NOT traits
 - **`dims()`:** returns the configuration space dimensions (e.g., `vec![2; n]` for binary variables)
-- **`evaluate()`:** must return the per-configuration aggregate value. For models with invalid configs, check feasibility first and return the appropriate invalid/false contribution
-- **`variant()`:** use the `variant_params!` macro — e.g., `crate::variant_params![G, W]` for `Problem<G, W>`, or `crate::variant_params![]` for problems with no type parameters. Each type parameter must implement `VariantParam` (already done for standard types like `SimpleGraph`, `i32`, `One`). See `src/variant.rs`.
+- **`evaluate()`:** must return `Result<Value, EvaluationError>`. Invalid configurations remain the aggregate's invalid/false contribution; arithmetic overflow and non-finite computed values are errors.
+- **`variant()`:** use the `variant_params!` macro — e.g., `crate::variant_params![G, W]` for `Problem<G, W>`, or `crate::variant_params![]` for problems with no type parameters. Each type parameter must implement `VariantParam` (already done for standard types like `SimpleGraph`, `i64`, `One`). See `src/variant.rs`.
 - **Solve surface:** `Solver::solve()` always computes the aggregate value. `pred solve problem.json` prints a `Solution` only when a witness exists; `pred solve bundle.json` and `--solver ilp` remain witness-only workflows
 
 ## Step 2.5: Register variant complexity
@@ -138,7 +142,7 @@ Add `declare_variants!` at the bottom of the model file (after the trait impls,
 
 ```rust
 crate::declare_variants! {
-    ProblemName<SimpleGraph, i32> => "1.1996^num_vertices",
+    ProblemName<SimpleGraph, i64> => "1.1996^num_vertices",
     default ProblemName<SimpleGraph, One> => "1.1996^num_vertices",
 }
 ```
@@ -168,22 +172,32 @@ The CLI now loads, serializes, and brute-force solves problems through the core
 1. **Registry-backed dispatch comes from `declare_variants!`:**
    - Make sure every concrete variant you want the CLI to load is listed in `declare_variants!`
    - Mark the intended default variant with `default` when applicable
+   - Declare well-established problem aliases in `ProblemSchemaEntry.aliases` and variant-specific aliases in `declare_variants!`; CLI and MCP discover both from the registry
+
+## Step 4.5: Add construction support
+
+CLI and MCP construction are registry-driven. Do not edit either frontend to recognize a model name.
+
+1. If user-facing inputs exactly match persisted JSON fields, do nothing. The ordinary `declare_variants!` entry uses `ProblemSchemaEntry.fields` as required construction inputs and deserializes the model directly.
+
+2. If construction has derived fields, renamed inputs, defaults depending on other inputs, or a composite value assembled from multiple inputs, define a model-local DTO with `#[derive(Deserialize, CreateSpec)]`. Its named fields are the complete public construction contract. Use `Option<T>` only for genuinely optional inputs, doc comments for help text, and `#[create(codec = "...")]` when the transport syntax cannot be inferred from the Rust type. Set `ProblemSchemaEntry.fields` to `LocalCreateSpec::FIELDS` so the catalog and executable constructor share the derived metadata.
 
-2. **`problemreductions-cli/src/problem_name.rs`:**
-   - Add a lowercase alias mapping in `resolve_alias()` (e.g., `"newproblem" => "NewProblem".to_string()`)
-   - Only add short aliases to the `ALIASES` array if the abbreviation is **well-established in the literature** (e.g., MIS, MVC, SAT, TSP, CVP are standard; "KS" for Knapsack or "BP" for BinPacking are NOT — do not invent new abbreviations)
+3. Implement `TryFrom<LocalCreateSpec> for Model` with `ConstructionError`. The direct constructor and serde path must share validation. Use `Conversion` for contract violations, `IntegerOverflow` for stored integer arithmetic, and `NonFiniteFloat` for stored non-finite values; do not call a panicking constructor.
 
-## Step 4.5: Add CLI creation support
+4. Register the spec on each applicable variant: `default Model => "..." create LocalCreateSpec`. Both frontends then discover the inputs automatically and serialize the constructed typed model back to canonical persisted JSON.
 
-CLI creation is **schema-driven** — `pred create <ProblemName>` automatically maps `ProblemSchemaEntry` fields to CLI flags via `snake_case → kebab-case` convention. No match arm in `create.rs` is needed.
+5. A new reusable external syntax may add one transport codec. It must dispatch by codec/type, never by canonical model name. Unknown or missing inputs are rejected by the core construction contract.
 
-1. **Ensure CLI flags exist** in `problemreductions-cli/src/cli.rs` (`CreateArgs` struct) for each field in your `ProblemSchemaEntry`. The flag name must match the field name via `snake_case → kebab-case` (e.g., field `edge_weights` → flag `--edge-weights`). If a flag already exists with the right name, you're done.
+### Optional random generation
 
-2. **Add new CLI flags** only if the problem needs flags not already present. Add them to `CreateArgs` and update `all_data_flags_empty()` accordingly. Also add entries to the `flag_map()` method on `CreateArgs`.
+Random generation is an optional model capability, not a model-completeness requirement. Many models do not have a natural or useful probability distribution over instances; leave random generation unregistered for those models. Do not invent arbitrary size limits, value ranges, or distributions merely to make `--random` available.
 
-3. **Add type parser support** if the field uses a type not yet handled by `parse_field_value()` in `create.rs`. Check the existing type dispatch table — most standard types (`Vec<i32>`, `Vec<usize>`, `Vec<(usize, usize)>`, graph types, etc.) are already covered. Only add a new parser for genuinely new types.
+When the model does have a well-defined generator with a concrete testing or example use, random generation is registry-driven and belongs beside the model. Do not edit CLI or MCP dispatch code.
 
-4. **Schema alignment**: The `ProblemSchemaEntry` fields should list **constructor parameters** (what the user provides), not internal derived fields. For example, if `m` and `n` are derived from a matrix, only list `matrix` and `k` in the schema. Field names must match the struct field names exactly (used for JSON serialization and CLI flag mapping).
+1. Define a typed random input DTO with `#[derive(Deserialize, CreateSpec)]`, or reuse a matching shared spec from `crate::random`.
+2. Implement `RandomGenerate` with `crate::impl_random_generate!(ConcreteModel, RandomSpec, |spec| { ... })`. Validate values and return `Result`; do not round, clamp, or silently replace invalid inputs.
+3. Add `random` only to the exact `declare_variants!` entries that implement the trait: `default Model => "..." create LocalCreateSpec random`.
+4. The generated problem must have the same canonical name and variant as the selected registry entry. Use the concrete variant's actual graph and numeric types instead of attaching requested metadata to a different concrete instance.
 
 ## Step 4.6: Add canonical model example to example_db
 
@@ -303,6 +317,7 @@ Structural and quality review is handled by the `review-pipeline` stage, not her
 |---------|-----|
 | Implementing weight management as a trait | Use inherent methods: `weights()`, `set_weights()`, `is_weighted()` |
 | Forgetting `inventory::submit!` | Every problem needs a `ProblemSchemaEntry` registration |
+| Omitting or inferring the model category | Set the required `ProblemSchemaEntry.category` explicitly to one of `Algebraic`, `Formula`, `Graph`, `Misc`, or `Set`; never parse `module_path!()`. |
 | Missing `#[path]` test link | Add `#[cfg(test)] #[path = "..."] mod tests;` at file bottom |
 | Wrong `dims()` | Must match the actual configuration space (e.g., `vec![2; n]` for binary) |
 | Using the wrong aggregate wrapper | Objective models use `Max` / `Min` / `Extremum`, witness models use `bool`, aggregate-only models use a fold value like `Sum` / `And` |
@@ -310,12 +325,12 @@ Structural and quality review is handled by the `review-pipeline` stage, not her
 | Forgetting `declare_variants!` | Required for variant complexity metadata and registry-backed load/serialize/solve dispatch |
 | Wrong aggregate wrapper | Use `Max` / `Min` / `Extremum` for objective problems, `Or` for existential witness problems, and `Sum` / `And` (or a custom aggregate) for value-only folds |
 | Wrong `declare_variants!` syntax | Entries no longer use `opt` / `sat`; one entry per problem may be marked `default` |
-| Forgetting CLI alias | Must add lowercase entry in `problem_name.rs` `resolve_alias()` |
+| Adding aliases in CLI code | Declare problem aliases in `ProblemSchemaEntry.aliases` and variant aliases in `declare_variants!` |
 | Adding a hand-written decision model | Use `Decision<P>` wrapper instead — see `decision_problem_meta!` + `register_decision_variant!` in `src/models/graph/minimum_vertex_cover.rs` for the pattern |
 | Inventing short aliases | Only use well-established literature abbreviations (MIS, SAT, TSP); do NOT invent new ones |
-| Forgetting CLI flags | Schema-driven create needs matching CLI flags in `CreateArgs` for each `ProblemSchemaEntry` field (snake_case → kebab-case). Also add to `flag_map()`. |
-| Missing type parser | If the problem uses a new field type, add a handler in `parse_field_value()` in `create.rs` |
-| Schema lists derived fields | Schema should list constructor params, not internal fields (e.g., `matrix, k` not `matrix, m, n, k`) |
+| Adding frontend model-name branches | Construction is model-owned. Use a local `CreateSpec` and register it with `declare_variants!`; CLI and MCP must discover it. |
+| Hand-maintaining custom construction fields twice | Derive `CreateSpec`, use `LocalCreateSpec::FIELDS` in `ProblemSchemaEntry`, and register the same type in `declare_variants!`. |
+| Calling a panicking constructor from `TryFrom<CreateSpec>` | Share a fallible constructor and preserve its `ConstructionError`. |
 | Missing canonical model example | Add a builder in `src/example_db/model_builders.rs` and keep it aligned with paper/example workflows |
 | Paper example not tested | Must include `test_<name>_paper_example` that verifies the exact instance, solution, and solution count shown in the paper |
 | Claiming direct ILP solving but leaving `<Problem> -> ILP` for later | If the issue promises a direct ILP path, implement that rule in the same PR with exact overhead metadata and production-level ILP tests |
diff --git a/.claude/skills/add-rule/SKILL.md b/.claude/skills/add-rule/SKILL.md
index 33a303af6..3097be526 100644
--- a/.claude/skills/add-rule/SKILL.md
+++ b/.claude/skills/add-rule/SKILL.md
@@ -24,12 +24,12 @@ Before any implementation, collect all required information. If called from `iss
 
 | # | Item | Description | Example |
 |---|------|-------------|---------|
-| 1 | **Source problem** | The problem being reduced FROM (must already exist) | `MinimumVertexCover<SimpleGraph, i32>` |
-| 2 | **Target problem** | The problem being reduced TO (must already exist) | `MaximumIndependentSet<SimpleGraph, i32>` |
+| 1 | **Source problem** | The problem being reduced FROM (must already exist) | `MinimumVertexCover<SimpleGraph, i64>` |
+| 2 | **Target problem** | The problem being reduced TO (must already exist) | `MaximumIndependentSet<SimpleGraph, i64>` |
 | 3 | **Reduction algorithm** | How to transform source instance to target | "Copy graph and weights; IS on same graph as VC" |
 | 4 | **Solution extraction** | How to map target solution back to source | "Complement: `1 - x` for each variable" |
 | 5 | **Correctness argument** | Why the reduction preserves optimality | "S is independent set iff V\S is vertex cover" |
-| 6 | **Size overhead** | How target size relates to source size | `num_vertices = "num_vertices", num_edges = "num_edges"` |
+| 6 | **Parameter transform** | How target size relates to source size | `num_vertices = "num_vertices", num_edges = "num_edges"` |
 | 7 | **Concrete example** | A small worked-out instance (tutorial style, clear intuition) | "Triangle graph: VC={0,1} -> IS={2}" |
 | 8 | **Solving strategy** | How to solve the target problem | "BruteForce, or existing ILP reduction" |
 | 9 | **Reference** | Paper, textbook, or URL for the reduction | URL or citation |
@@ -56,6 +56,28 @@ grep "type Value = " src/models/*/<source_file>.rs src/models/*/<target_file>.rs
 
 If incompatible, STOP and comment on the issue explaining the type mismatch and options. Do NOT proceed.
 
+## Numeric Safety Gate
+
+Read `docs/src/design.md#numeric-types-and-arithmetic`. Derive implementation
+types, supported ranges, and checked conversions from the mathematical source,
+target, and reduction algorithm. Use `usize` for in-memory indices, collection
+lengths, and brute-force dimensions; `u64` for registered problem size
+parameters; `i64` for signed mathematical integers; `bool` for Boolean data;
+and finite `f64` for real or rational data. Another format needs mathematical
+or target-schema justification; there is no `i32` boundary format.
+Temporary reduction calculations are outside this format contract, but fields
+written into the target must use the target model's format.
+
+Ask the contributor only when a mathematical domain or constraint is ambiguous;
+do not ask them to choose Rust types. Do not use `as` for range/sign changes.
+Check target-size arithmetic and auxiliary identifiers before constructing the
+target, verify serde/CLI uses the same ranges, and add focused boundary tests.
+The public reduction returns `ReductionError`: preserve a target constructor's
+`ConstructionError` as `ReductionError::Construction`, and report reduction
+arithmetic directly as the corresponding `ReductionError`; do not stringify or
+silently handle either error. Convert model-derived `i64` values to `f64` only
+through `i64_to_exact_f64`.
+
 ## Reference Implementations
 
 Read these first to understand the patterns:
@@ -106,13 +128,19 @@ impl ReductionResult for ReductionXToY {
     type Source = SourceType;
     type Target = TargetType;
     fn target_problem(&self) -> &Self::Target { &self.target }
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Map target solution back to source solution
-        // If Step 1 ran: translate the verified Python extract_solution() logic
+    fn extract_solution(
+        &self,
+        target_solution: &[usize],
+    ) -> crate::rules::ExtractionResult<Vec<usize>> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        let source_solution = /* translate the verified mathematical mapping exactly */;
+        Ok(source_solution)
     }
 }
 ```
 
+Every direct extractor must call `validate_target_solution()` once before decoding. It checks only length and value domains, not feasibility, optimality, or rule-specific structure; reject malformed structure with `ExtractionError`.
+
 **ReduceTo with `#[reduction]` macro** (overhead is **required**):
 ```rust
 #[reduction(overhead = {
@@ -156,6 +184,8 @@ Additional recommended tests:
 - Edge cases (empty graph, single vertex, etc.)
 - Weight preservation (if applicable)
 
+Test every malformed representation distinguished by the decoder (for example, zero or multiple one-hot selections, or duplicate permutation entries). The canonical example supplies shared wrong-length and out-of-domain tests.
+
 For aggregate-only reductions, replace the closed-loop witness test with value-chain tests:
 - Solve the target with `Solver::solve()`
 - Map the aggregate value back with `extract_value()`
@@ -163,9 +193,9 @@ For aggregate-only reductions, replace the closed-loop witness test with value-c
 
 Link via `#[cfg(test)] #[path = "..."] mod tests;` at the bottom of the rule file.
 
-## Step 5: Add canonical example to example_db
+## Step 5: Add canonical example
 
-Add a builder function in `src/example_db/rule_builders.rs` that constructs a small, canonical instance for this reduction. Follow the existing patterns in that file. Register the builder in `build_rule_examples()`.
+Define `canonical_rule_example_specs()` in the rule module and include it from `src/rules/mod.rs::canonical_rule_example_specs()`. This enrolls the rule in shared round-trip, wrong-length, and out-of-domain extraction tests.
 
 ## Step 6: Document in paper (MANDATORY — DO NOT SKIP)
 
@@ -231,11 +261,11 @@ Checklist: notation self-contained, complexity cited, overhead consistent, examp
 ```bash
 cargo run --example export_graph    # Generate reduction_graph.json for docs/paper builds
 cargo run --example export_schemas  # Generate problem schemas for docs/paper builds
-make regenerate-fixtures            # Regenerate example_db/fixtures/examples.json (slow, needs ILP)
+cargo run --features "example-db" --example export_examples
 make test clippy                    # Must pass
 ```
 
-`make regenerate-fixtures` is required so the paper can load the new rule's example data from `src/example_db/fixtures/examples.json`. Without it, the `reduction-rule` entry in Step 6 will reference missing fixture data.
+`export_examples` refreshes the gitignored `docs/paper/data/examples.json` used by the paper.
 
 Structural and quality review is handled by the `review-pipeline` stage, not here. The run stage just needs to produce working code.
 
@@ -249,7 +279,9 @@ Structural and quality review is handled by the `review-pipeline` stage, not her
 
 ## CLI Impact
 
-Adding a witness-preserving reduction rule does NOT require CLI changes -- the reduction graph is auto-generated from `#[reduction]` macros and the CLI discovers paths dynamically. However, both source and target models must already be fully registered through their model files (`declare_variants!`), aliases as needed in `problem_name.rs`, and `pred create` support where applicable (see `add-model` skill).
+Adding a witness-preserving reduction rule does NOT require CLI changes -- the reduction graph is auto-generated from `#[reduction]` macros and the CLI discovers paths dynamically. However, both source and target models must already be fully registered through their model files (`ProblemSchemaEntry` and `declare_variants!`), including any aliases and `pred create` construction contract (see `add-model` skill).
+
+`ExtractionError` already propagates through `pred extract` and bundle `pred solve`; add a rule-specific CLI test only when the CLI surface changes.
 
 Aggregate-only reductions currently have a narrower CLI surface:
 - `pred solve <problem.json>` can still compute direct aggregate values for aggregate-only problems
@@ -261,7 +293,7 @@ Aggregate-only reductions currently have a narrower CLI surface:
 - Rule file: `src/rules/<sourcelower>_<targetlower>.rs` -- no underscores within a problem name
   - e.g., `maximumindependentset_qubo.rs`, `minimumvertexcover_maximumindependentset.rs`
 - Test file: `src/unit_tests/rules/<sourcelower>_<targetlower>.rs`
-- Canonical example: builder function in `src/example_db/rule_builders.rs`
+- Canonical example: `canonical_rule_example_specs()` in the rule module, included from `src/rules/mod.rs`
 
 ## Common Mistakes
 
@@ -272,9 +304,10 @@ Aggregate-only reductions currently have a narrower CLI surface:
 | Wrong overhead expression | Must accurately reflect the size relationship |
 | Adding extra reduction metadata or duplicate primitive endpoint registration | Keep one primitive registration per endpoint pair and use only the `overhead` form of `#[reduction]` |
 | Missing `extract_solution` mapping state | Store any index maps needed in the ReductionResult struct |
-| Not adding canonical example to `example_db` | Add builder in `src/example_db/rule_builders.rs` |
+| Permissive extraction | Validate first, then map exactly or return `ExtractionError` |
+| Not adding a canonical example | Add the rule-local spec and include it from `src/rules/mod.rs` |
 | Not regenerating reduction graph | Run `cargo run --example export_graph` after adding a rule |
-| Skipping Step 5 (paper documentation) | **Every rule MUST have a `reduction-rule` entry in the paper. This is mandatory, not optional. PRs without documentation will be rejected.** |
-| Source/target model not fully registered | Both problems must already have `declare_variants!`, aliases as needed, and CLI create support -- use `add-model` skill first |
+| Skipping Step 6 (paper documentation) | **Every rule MUST have a `reduction-rule` entry in the paper. This is mandatory, not optional. PRs without documentation will be rejected.** |
+| Source/target model not fully registered | Both problems must already have `ProblemSchemaEntry`, `declare_variants!`, registry aliases as needed, and a construction contract -- use `add-model` skill first |
 | Treating a direct-to-ILP rule as a toy stub | Direct ILP reductions need exact overhead metadata and strong semantic regression tests, just like other production ILP rules |
 | Skipping verification for complex reductions | Verification is default for a reason — `--no-verify` is for trivial identity/complement reductions only |
diff --git a/.claude/skills/check-issue/SKILL.md b/.claude/skills/check-issue/SKILL.md
index 983e6fee0..e63957476 100644
--- a/.claude/skills/check-issue/SKILL.md
+++ b/.claude/skills/check-issue/SKILL.md
@@ -102,7 +102,7 @@ Read the "Reduction Algorithm" section and flag as **Fail** if:
 
 - **Variable substitution only:** The mapping is a 1-to-1 relabeling (e.g., `x_i → 1 - x_i` for complement problems). A valid reduction must construct new constraints, objectives, or graph structure.
 - **Subtype coercion:** The reduction merely casts to a more general type within an existing variant hierarchy (e.g., UnitDiskGraph → SimpleGraph) with no structural change to the problem instance.
-- **Same-problem identity:** Reducing between variants of the same problem with no insight (e.g., `MIS<SimpleGraph, One>` → `MIS<SimpleGraph, i32>` by setting all weights to 1).
+- **Same-problem identity:** Reducing between variants of the same problem with no insight (e.g., `MIS<SimpleGraph, One>` → `MIS<SimpleGraph, i64>` by setting all weights to 1).
 - **Insufficient detail:** The algorithm is a hand-wave ("map variables accordingly", "follows from the definition") — not a step-by-step procedure a programmer could implement. This is also a **Fail**.
 
 If the construction involves gadgets, penalty terms, auxiliary variables, or non-trivial structural transformation → **Pass**.
diff --git a/.claude/skills/final-review/SKILL.md b/.claude/skills/final-review/SKILL.md
index 633d86ad8..ced146b7d 100644
--- a/.claude/skills/final-review/SKILL.md
+++ b/.claude/skills/final-review/SKILL.md
@@ -168,12 +168,12 @@ Use `AskUserQuestion` with your recommendation:
 
 Scan the PR diff for dangerous actions:
 
-- **Blacklisted files**: If the diff touches `docs/src/reductions/reduction_graph.json`, `docs/src/reductions/problem_schemas.json`, or `src/example_db/fixtures/examples.json` (legacy, no longer exists), **block merge**. These files are auto-generated and must not be committed in PRs — they are rebuilt by CI/`make doc`/`make paper`. Flag immediately and recommend OnHold.
+- **Blacklisted files**: If the diff touches `docs/src/reductions/reduction_graph.json` or `docs/src/reductions/problem_schemas.json`, **block merge**. These files are auto-generated and must not be committed in PRs — they are rebuilt by CI/`make doc`/`make paper`. Flag immediately and recommend OnHold.
 - **Removed features**: Any existing model, rule, test, or example deleted?
 - **Unrelated changes**: Files modified that don't belong to this PR (e.g., changes to unrelated models/rules, CI config, Cargo.toml dependency changes not needed for this PR)
 - **Force push indicators**: Any sign of history rewriting
 - **Broad modifications**: Changes to core traits, macros, or shared infrastructure that could affect other features
-- **No committed `examples.json`**: The example database is generated on demand by `make paper` (via `export_examples`). PRs should not commit `src/example_db/fixtures/examples.json` (legacy path, deleted) or `docs/paper/data/examples.json` (current output path) — both are gitignored build artifacts.
+- **No committed `examples.json`**: The example database is generated on demand by `make paper` (via `export_examples`). Do not commit the gitignored `docs/paper/data/examples.json` build artifact.
 
 Report findings with fix options for each concern:
 
diff --git a/.claude/skills/find-problem/SKILL.md b/.claude/skills/find-problem/SKILL.md
index 3bcd9953e..d1695524a 100644
--- a/.claude/skills/find-problem/SKILL.md
+++ b/.claude/skills/find-problem/SKILL.md
@@ -54,16 +54,16 @@ Never skip step 1 or 3.
 
 **Goal:** Get the user's model name and solver complexity.
 
-**If invoked as `/find-problem <ModelName>`:** validate with `pred show <ModelName>`. If it exists, show the output (including size fields), then ask for solver complexity.
+**If invoked as `/find-problem <ModelName>`:** validate with `pred show <ModelName>`. If it exists, show the output (including parameters), then ask for solver complexity.
 
 **If invoked as `/find-problem`:** ask using `AskUserQuestion`: "Which problem model does your solver handle?" Validate the answer with `pred show`.
 
 **Ask for complexity** using `AskUserQuestion`: "What is your solver's time complexity? Use the size field names from the output above (e.g., `O(1.1996^num_vertices)`, `O(2^(num_variables/3))`)."
 
-- Variable names should match the model's size fields shown in `pred show` output
+- Variable names should match the model's parameters shown in `pred show` output
 - If the user gives informal notation (e.g., "exponential in n"), help them formalize it using the model's actual size field names
 
-**Exit condition:** Validated model name + complexity expression with variables matching the model's size fields. Proceed to Step 2.
+**Exit condition:** Validated model name + complexity expression with variables matching the model's parameters. Proceed to Step 2.
 
 ---
 
@@ -91,7 +91,7 @@ Never skip step 1 or 3.
    - **Better** — effective complexity has a smaller base or exponent than best-known
    - **Similar** — comparable asymptotic behavior
    - **Worse** — effective complexity exceeds best-known (reduction overhead makes it impractical)
-   - **When effective and best-known use different variables** (e.g., `O(1.5^num_subsets)` vs `O(2^universe_size)`): this happens when a problem has multiple independent size fields and the best-known algorithm's dominant variable differs from the reduction overhead's. In this case, use `pred-sym eval` at representative concrete values to determine the comparison. State the result conditionally: "Better when num_subsets ≤ c·universe_size" with the crossover ratio.
+   - **When effective and best-known use different variables** (e.g., `O(1.5^num_subsets)` vs `O(2^universe_size)`): this happens when a problem has multiple independent parameters and the best-known algorithm's dominant variable differs from the reduction overhead's. In this case, use `pred-sym eval` at representative concrete values to determine the comparison. State the result conditionally: "Better when num_subsets ≤ c·universe_size" with the crossover ratio.
 
 5. **Web search** only the **Better** and **Similar** candidates for real-world applications (not the Worse ones). Use `WebSearch` tool with query "<problem name> real-world applications".
 
@@ -194,5 +194,5 @@ pred solve bundle.json --solver ilp --timeout 60
 - **Conversational tone.** Guided consultation, not a lecture.
 - **Live execution.** Every `pred` command runs for real. No fake output.
 - **Graceful fallbacks.** If `pred to` returns no results (no incoming reductions), suggest trying with more hops or a different model. If `pred path` fails for a specific source, skip it and note it in the table.
-- **Help with complexity notation.** If the user gives informal complexity, show `pred show <model>` size fields and help them write a formal expression.
+- **Help with complexity notation.** If the user gives informal complexity, show `pred show <model>` parameters and help them write a formal expression.
 - **Cap results at 10.** If discovery returns many problems, show top 10 by effective complexity and offer to show more.
diff --git a/.claude/skills/find-solver/SKILL.md b/.claude/skills/find-solver/SKILL.md
index c9d221e36..704c76ced 100644
--- a/.claude/skills/find-solver/SKILL.md
+++ b/.claude/skills/find-solver/SKILL.md
@@ -86,9 +86,9 @@ Use `AskUserQuestion` for each question. Format options as **(a)**/**(b)**/**(c)
 
 1. **Web search** the clarified problem description together with terms like "NP-hard", "computational complexity", or "reduction" to find formal problem names and known relationships in the literature. Use `WebSearch` tool.
 
-2. **Run `pred list`** to get the full catalog of available models. Copy-paste the full output into your response.
+2. **Search the catalog** with `pred list <formal-name-or-keyword>`. Use `pred list --json` when exhaustive machine-readable discovery is needed. Do not paste the full catalog into the response.
 
-3. **Cross-reference** the web search results against the `pred list` catalog. For each candidate model that exists in the library (3-5 max), present a table:
+3. **Cross-reference** the web search results against the catalog. For each candidate model that exists in the library (3-5 max), present a table:
 
 | # | Model | Why it might match | Caveat |
 |---|-------|--------------------|--------|
diff --git a/.claude/skills/issue-to-pr/SKILL.md b/.claude/skills/issue-to-pr/SKILL.md
index 2573bedd5..87734784e 100644
--- a/.claude/skills/issue-to-pr/SKILL.md
+++ b/.claude/skills/issue-to-pr/SKILL.md
@@ -92,12 +92,12 @@ Write implementation plan to `docs/plans/YYYY-MM-DD-<slug>.md` using `superpower
 The plan MUST reference the appropriate implementation skill and follow its steps:
 
 - **For ordinary `[Model]` issues:** Follow [add-model](../add-model/SKILL.md) Steps 1-7 as the action pipeline
-- **For `[Model]` issues that explicitly claim direct ILP solving:** Follow [add-model](../add-model/SKILL.md) Steps 1-7 **and** [add-rule](../add-rule/SKILL.md) Steps 1-6 for the direct `<Problem> -> ILP` rule in the same plan / PR
+- **For `[Model]` issues that explicitly claim direct ILP solving:** Follow [add-model](../add-model/SKILL.md) Steps 1-7 **and** [add-rule](../add-rule/SKILL.md) Steps 1-7 for the direct `<Problem> -> ILP` rule in the same plan / PR
 - **For `[Rule]` issues:** Follow [add-rule](../add-rule/SKILL.md) Steps 1-7 as the action pipeline. By default, `/add-rule` runs mathematical verification (Step 1) before implementation. If `--no-verify` was passed, include `--no-verify` when invoking `/add-rule` to skip verification.
 
 Include the concrete details from the issue (problem definition, reduction algorithm, example, etc.) mapped onto each step.
 
-**Plan batching:** The paper writing step (add-model Step 6 / add-rule Step 5) MUST be in a **separate batch** from the implementation steps, so it gets its own subagent with fresh context. It depends on the implementation being complete (needs exports). Example batch structure for a `[Model]` plan:
+**Plan batching:** The paper writing step (add-model Step 6 / add-rule Step 6) MUST be in a **separate batch** from the implementation steps, so it gets its own subagent with fresh context. It depends on the implementation being complete (needs exports). Example batch structure for a `[Model]` plan:
 - Batch 1: Steps 1-5.5 (implement model, register, CLI, tests)
 - Batch 2: Step 6 (write paper entry — depends on batch 1 for exports)
 
@@ -112,8 +112,8 @@ For a `[Model]` issue with an explicit direct ILP claim, use:
 - Otherwise, ensure the information provided is enough to implement a solver.
 
 **Example rules:**
-- Implement the user-provided example instance in the canonical `example_db` path for the issue (`src/example_db/model_builders.rs` or `src/example_db/rule_builders.rs`, as appropriate).
-- Run the relevant export and fixture regeneration steps; verify the generated example data against the user-provided information.
+- Implement the user-provided example in `src/example_db/model_builders.rs` for a model, or in the rule-local `canonical_rule_example_specs()` for a rule.
+- Run the relevant exports and verify the generated example data against the user-provided information.
 - Present in `docs/paper/reductions.typ` in tutorial style with clear intuition (see KColoring->QUBO section for reference).
 
 ### 6. Create PR (or Resume Existing)
diff --git a/.claude/skills/propose/SKILL.md b/.claude/skills/propose/SKILL.md
index bc392dadb..5024e0af5 100644
--- a/.claude/skills/propose/SKILL.md
+++ b/.claude/skills/propose/SKILL.md
@@ -117,7 +117,7 @@ Right after the user picks model or rule, **study at least one existing case** i
    If no keyword match, just read the most recent closed model issue to see the template conventions.
 
 3. **Note internally** (do not dump raw output to the user):
-   - What fields / size fields the similar problem has
+   - What fields / parameters the similar problem has
    - How the issue defines variables, schema, complexity
    - What level of mathematical detail is expected in examples
    - How the "Reduction Rule Crossref" section is structured
@@ -176,7 +176,7 @@ Right after the user picks model or rule, **study at least one existing case** i
 
 3. **Note internally**:
    - How the reduction algorithm is structured (numbered steps, symbol definitions)
-   - How the size overhead table is formatted (field names, formulas)
+   - How the parameter transform table is formatted (field names, formulas)
    - How the example is worked through (source → construction → target → solution)
    - What references and validation methods are used
 
@@ -567,8 +567,8 @@ If the reduction is well-known, use the literature to **pre-fill** answers in St
    ```
    If the user asks for more or less detail, revise and re-present.
 
-4. **Size overhead** — Compute overhead from the algorithm using the target's size fields from `pred show <target> --json`. Present the overhead table and ask for confirmation:
-   > "Based on the algorithm, the size overhead is: [table]. Does this look correct?"
+4. **Parameter transform** — Compute overhead from the algorithm using the target's parameters from `pred show <target> --json`. Present the overhead table and ask for confirmation:
+   > "Based on the algorithm, the parameter transform is: [table]. Does this look correct?"
 
 5. **Example** — Generate **at least 3** candidate examples yourself (varying in size and structure), then present via `AskUserQuestion`. **3 options is the minimum — never fewer.** Always include a "Generate new batch" escape hatch:
 
@@ -830,7 +830,7 @@ Print all issue URLs when done.
 - **Don't skip confirmation for textbook reductions.** Even if SubsetSum → Knapsack is in Garey & Johnson, still present each brainstorming step with pre-filled answers for the user to confirm or revise. Never jump straight to the draft.
 - **Don't rebuild `pred` unnecessarily.** Use `command -v pred` to check if it's installed before running `make cli` (which takes >1 minute).
 - **Don't ask all questions at once.** One `AskUserQuestion` call per message.
-- **Don't use programming jargon.** Say "list of weights" not "Vec<W>". Say "graph" not "SimpleGraph". Say "integer" not "i32".
+- **Don't use programming jargon.** Say "list of weights" not "Vec<W>". Say "graph" not "SimpleGraph". Say "integer" not "i64".
 - **Don't skip the reduction crossref.** An orphan model will be rejected.
 - **Don't file without user approval.** Always show the draft first.
 - **Don't implement anything.** The output is issues, not code.
diff --git a/.claude/skills/review-paper/SKILL.md b/.claude/skills/review-paper/SKILL.md
index d1c98cdf6..e5a8e2378 100644
--- a/.claude/skills/review-paper/SKILL.md
+++ b/.claude/skills/review-paper/SKILL.md
@@ -46,7 +46,7 @@ For each of the 10 entries, read the full entry text and evaluate against the ch
 | M3. Self-contained notation | Every symbol in `def` is defined before first use |
 | M4. Background text | Body contains at least 2 sentences of background/motivation |
 | M5. Example present | Body contains `*Example.*` or `Example.` |
-| M6. Example from fixture | Example data matches `src/example_db/fixtures/examples.json` (not invented) — check by loading the JSON and comparing |
+| M6. Example from fixture | Example data matches `docs/paper/data/examples.json` (not invented) — check by loading the JSON and comparing |
 | M7. Figure present | Body contains `#figure(` |
 | M8. Pred commands | Body contains `pred-commands(` or `pred create` |
 | M9. Algorithm citation | Complexity claims have `@citation` or a footnote explaining absence |
@@ -72,7 +72,7 @@ For each of the 10 entries, read the full entry text and evaluate against the ch
 | M3. Proof length | Proof is at least 3 sentences (not just "trivial" or a one-liner) |
 | M4. Overhead documented | Overhead is auto-generated from JSON (verify edge exists in `reduction_graph.json`) |
 | M5. Example present | `example: true` and example renders correctly |
-| M6. Example from fixture | Example data matches `src/example_db/fixtures/examples.json` |
+| M6. Example from fixture | Example data matches `docs/paper/data/examples.json` |
 | M7. Pred commands | Example section contains `pred-commands(` with create/reduce/evaluate pipeline |
 | M8. Both directions | If the reverse rule also exists in the graph, check it has its own entry |
 
diff --git a/.claude/skills/review-pipeline/SKILL.md b/.claude/skills/review-pipeline/SKILL.md
index 9849a5432..51930ca79 100644
--- a/.claude/skills/review-pipeline/SKILL.md
+++ b/.claude/skills/review-pipeline/SKILL.md
@@ -175,7 +175,7 @@ Invoke `/review-quality` (file: `.claude/skills/review-quality/SKILL.md`) with t
 2. **Invoke `/agentic-tests:test-feature`** (file: `~/.claude/commands/agentic-tests:test-feature.md`) with the identified feature. This simulates a downstream user exercising the feature from docs and examples.
 
    **Minimum test checklist** for the agentic tester:
-   - `pred list` — verify the new model/rule appears in the catalog
+   - For models, `pred list <Name>`; for rules, `pred list --rules <Source>` — verify the new catalog entry appears
    - `pred show <Name>` — verify details display correctly
    - `pred create --example <Name>` — verify example instance creation works
    - `pred solve <instance>` — verify solving works on the example
diff --git a/.claude/skills/review-structural/SKILL.md b/.claude/skills/review-structural/SKILL.md
index 5c30e15b6..d291a7e02 100644
--- a/.claude/skills/review-structural/SKILL.md
+++ b/.claude/skills/review-structural/SKILL.md
@@ -61,11 +61,12 @@ Only run if review type includes "model". Given: problem name `P`, category `C`,
 | 9 | Registered in `{C}/mod.rs` | `Grep("mod {F}", "src/models/{C}/mod.rs")` |
 | 10 | Re-exported in `models/mod.rs` | `Grep("{P}", "src/models/mod.rs")` |
 | 11 | Variant registration exists | `Grep("declare_variants!|VariantEntry", file)` |
-| 12 | CLI `resolve_alias` entry | `Grep("{P}", "problemreductions-cli/src/problem_name.rs")` |
-| 13 | CLI `create` support | Schema-driven: verify each `ProblemSchemaEntry` field has a matching CLI flag in `CreateArgs` (field `snake_case` → flag `kebab-case`). Check `flag_map()` includes the flag. If the field type is unusual, verify `parse_field_value()` handles it. |
+| 12 | Alias registration | If aliases are claimed, verify problem aliases are in `ProblemSchemaEntry.aliases` and variant aliases are in `declare_variants!`; no frontend alias branch |
+| 13 | CLI `create` support | Run `pred create <problem-spec> --help` for the concrete variant. Verify its flags and types come from the registered construction inputs (`ProblemSchemaEntry.fields` or the model-local `CreateSpec`), with a reusable codec for any unusual transport syntax. |
 | 14 | Canonical model example registered | `Grep("{P}", "src/example_db/model_builders.rs")` |
 | 15 | Paper `display-name` entry | `Grep('"{P}"', "docs/paper/reductions.typ")` |
 | 16 | Paper `problem-def` block | `Grep('problem-def.*"{P}"', "docs/paper/reductions.typ")` |
+| 17 | Numeric and error contracts | Derive the expected boundary representation from the mathematical definition, then compare schema types, Rust fields, aggregate/total type, constructor and serde validation, conversions, overflow behavior, and boundary tests against `docs/src/design.md#numeric-types-and-arithmetic`. Verify construction paths return `ConstructionError`, `evaluate()` returns `EvaluationError`, and no public model path returns `Result<_, String>`. |
 
 ### Rule Checklist
 
@@ -81,16 +82,17 @@ Only run if review type includes "rule". Given: source `S`, target `T`, rule fil
 | 6 | Test file exists | `Glob("src/unit_tests/rules/{R}.rs")` |
 | 7 | Closed-loop test present | `Grep("fn test_.*closed_loop\|fn test_.*to_.*basic", test_file)` |
 | 8 | Registered in `rules/mod.rs` | `Grep("mod {R}", "src/rules/mod.rs")` |
-| 9 | Canonical rule example registered | `Grep("{S}|{T}|{R}", "src/example_db/rule_builders.rs")` |
+| 9 | Canonical rule example registered | `Grep("canonical_rule_example_specs", rule file)` and verify it is included by `src/rules/mod.rs` |
 | 10 | Example-db lookup tests exist | `Grep("find_rule_example|build_rule_db", "src/unit_tests/example_db.rs")` |
 | 11 | Paper `reduction-rule` entry | `Grep('reduction-rule.*"{S}".*"{T}"', "docs/paper/reductions.typ")` |
+| 12 | Extraction contract | Direct decoders call `validate_target_solution()`, enforce rule-specific structure, and test malformed cases; the helper does not establish feasibility or optimality. Composed extractors may delegate. |
+| 13 | Numeric and error contracts | Compare source/target boundary types, size arithmetic, coefficients, bounds, auxiliary IDs, conversions, overflow behavior, and boundary tests against `docs/src/design.md#numeric-types-and-arithmetic`. Verify public reduction paths return `ReductionError`, preserve target `ConstructionError` as its construction cause, and never stringify or silently handle either failure. |
 
 ## Step 2b: Blacklisted File Check
 
 Scan the PR's changed files for auto-generated files that must never be committed:
 - `docs/src/reductions/reduction_graph.json`
 - `docs/src/reductions/problem_schemas.json`
-- `src/example_db/fixtures/examples.json` (legacy path, deleted on main)
 - `docs/paper/data/examples.json` (current output path, gitignored)
 
 If any of these files appear in the diff, report **FAIL — blacklisted auto-generated file committed**. These files are rebuilt by CI/`make doc`/`make paper` and must not be in PRs.
@@ -111,12 +113,14 @@ Report pass/fail. If tests fail, identify which tests. **Do NOT fix anything** 
 2. **`dims()` correctness** — Does it return the actual configuration space? (e.g., `vec![2; n]` for binary)
 3. **Size getter consistency** — Do inherent getter methods (e.g., `num_vertices()`, `num_edges()`) match names used in overhead expressions?
 4. **Weight handling** — Are weights managed via inherent methods, not traits?
+5. **Numeric safety** — Are element and total types distinct where required, do serde and constructors enforce the same range, and are overflow and non-finite values rejected explicitly?
 
 ### For Rules:
-1. **`extract_solution` correctness** — Does it correctly invert the reduction? Does the returned solution have the right length (source dimensions)?
+1. **`extract_solution` correctness** — Does it implement the mathematical inverse? Is every branch either a defined mathematical case or an `ExtractionError`, with no defaulting, truncation, clamping, panic, or recovery?
 2. **Overhead accuracy** — Does `overhead = { field = "expr" }` reflect the actual size relationship?
 3. **Example quality** — Is it tutorial-style? Does the JSON export include both source and target data?
 4. **Paper quality** — Is the reduction-rule statement precise? Is the proof sketch sound?
+5. **Numeric safety** — Are target sizes and auxiliary IDs checked before construction, with no unchecked narrowing or exact-to-`f64` shortcut?
 
 ## Step 5: Issue Compliance Review
 
diff --git a/.claude/skills/run-pipeline/SKILL.md b/.claude/skills/run-pipeline/SKILL.md
index 1a0229a66..731b7e550 100644
--- a/.claude/skills/run-pipeline/SKILL.md
+++ b/.claude/skills/run-pipeline/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: run-pipeline
-description: Pick a Ready issue from the GitHub Project board, move it through In Progress -> issue-to-pr -> Review pool
+description: Pick a Ready issue from the GitHub Project board, move it from In Progress through issue-to-pr into Review pool
 ---
 
 # Run Pipeline
@@ -79,7 +79,7 @@ Score only **eligible** issues on three criteria. For `[Model]` issues, extract
 | Criterion | Weight | How to Assess |
 |-----------|--------|---------------|
 | **C1: Industrial/Theoretical Importance** | 3 | Read the report's issue summary for each eligible issue. Score 0-2: **2** = widely used in industry or foundational in complexity theory (e.g., ILP, SAT, MaxFlow, TSP, GraphColoring); **1** = moderately important or well-studied (e.g., SubsetSum, SetCover, Knapsack); **0** = niche or primarily academic |
-| **C2: Related to Existing Problems** | 2 | Use the report's Ready/In-progress context plus `pred list` if needed. Score 0-2: **2** = directly related (shares input structure or has known reductions to/from ≥2 existing problems, but is NOT a trivial variant of an existing one); **1** = loosely related (same domain, connects to 1 existing problem); **0** = isolated or is essentially a variant/renaming of an existing problem |
+| **C2: Related to Existing Problems** | 2 | Use the report's Ready/In-progress context plus `pred list <candidate>` or `pred list --json` if needed. Score 0-2: **2** = directly related (shares input structure or has known reductions to/from ≥2 existing problems, but is NOT a trivial variant of an existing one); **1** = loosely related (same domain, connects to 1 existing problem); **0** = isolated or is essentially a variant/renaming of an existing problem |
 | **C3: Unblocks Pending Rules** | 2 | Read the `Pending rules unblocked` count already printed in the report for each eligible issue. Score 0-2: **2** = unblocks ≥2 pending rules; **1** = unblocks 1 pending rule; **0** = does not unblock any pending rule |
 
 **Final score** = C1 × 3 + C2 × 2 + C3 × 2 (max = 12)
diff --git a/.claude/skills/topology-sanity-check/SKILL.md b/.claude/skills/topology-sanity-check/SKILL.md
index ba160ce0c..12c405ede 100644
--- a/.claude/skills/topology-sanity-check/SKILL.md
+++ b/.claude/skills/topology-sanity-check/SKILL.md
@@ -53,7 +53,7 @@ Parse the output and produce:
 
 | # | Problem | Variants | Category |
 |---|---------|----------|----------|
-| 1 | ProblemName | 2 (f64, i32) | algebraic |
+| 1 | ProblemName | 2 (f64, i64) | algebraic |
 
 ### Existing Issues
 
@@ -144,7 +144,7 @@ This runs the analysis from `src/rules/analysis.rs` which:
 
 Always report rules with full variant-qualified endpoints, not just base names.
 Use the same display style as `ReductionStep`, e.g.
-`MaximumIndependentSet {graph: "SimpleGraph", weight: "One"} -> MaximumIndependentSet {graph: "KingsSubgraph", weight: "i32"}`.
+`MaximumIndependentSet {graph: "SimpleGraph", weight: "One"} -> MaximumIndependentSet {graph: "KingsSubgraph", weight: "i64"}`.
 Base-name-only summaries are ambiguous and can hide cast-only paths.
 
 Parse the test output and report:
diff --git a/.claude/skills/verify-reduction/SKILL.md b/.claude/skills/verify-reduction/SKILL.md
index 76f1246f6..91765ce3f 100644
--- a/.claude/skills/verify-reduction/SKILL.md
+++ b/.claude/skills/verify-reduction/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: verify-reduction
-description: Standalone mathematical verification of a reduction rule — generates Typst proof, constructor Python script (>=5000 checks), and adversary Python script (>=5000 independent checks). Reports verdict. No artifacts saved.
+description: Standalone mathematical verification of a reduction rule — generates a Typst proof plus constructor and independent adversary scripts with at least 5000 checks each. Reports a verdict without saving artifacts.
 ---
 
 # Verify Reduction
@@ -36,22 +36,61 @@ pred show <Target> --json
 
 ### Type compatibility gate — MANDATORY
 
-Check source/target `Value` types before any work:
+Check source/target `Value` types before any work. The `grep` only locates the definitions; it does
+not resolve generic parameters or associated types:
 
 ```bash
 grep "type Value = " src/models/*/<source_file>.rs src/models/*/<target_file>.rs
 ```
 
+Resolve both concrete types completely before declaring compatibility:
+
+1. Substitute every concrete generic argument from the proposed rule.
+2. Follow every type alias and associated type to its defining `impl`.
+3. Record the substitution chain and the source file evidence in the verification report.
+4. If any generic or associated type remains unresolved, run a compile-backed temporary Rust probe
+   using `std::any::type_name::<<ConcreteProblem as Problem>::Value>()`. Build the probe from `/tmp`
+   with a path dependency on this repository; do not modify the repository.
+
+Never infer a Rust value type from the mathematical problem name, from unit-weight terminology, or
+from the Python verifier's integer representation. In particular, arbitrary-precision Python
+integers do not establish that a Rust objective type is `usize` or that it is closed under all
+legal source instances.
+
+Required report format:
+
+```text
+TYPE RESOLUTION:
+  Source syntax:   Min<W::Sum>
+  Substitutions:   W = One; <One as WeightElement>::Sum = i64
+  Source resolved: Min<i64>
+  Target syntax:   Min<usize>
+  Target resolved: Min<usize>
+  Full-domain compatibility: FAILED
+```
+
 **Compatible pairs for `ReduceTo` (witness-capable):**
-- `Or`->`Or`, `Min`->`Min`, `Max`->`Max` (same type)
+- `Or`->`Or`
+- `Min<V>`->`Min<V>`, `Max<V>`->`Max<V>` (identical resolved inner type)
 - `Or`->`Min`, `Or`->`Max` (feasibility embeds into optimization)
 
+`Min<S>`->`Min<T>` or `Max<S>`->`Max<T>` with `S != T` is not automatically compatible. Proceed
+only if the rule or source model declares a bound covering every legal source instance and the
+verification proves a total, order-preserving conversion over that full declared domain. Otherwise
+STOP and report a value-domain mismatch.
+
 **Incompatible — STOP if any of these:**
 - `Min`->`Or` or `Max`->`Or` — optimization source has no threshold K; needs a decision-variant source model
 - `Max`->`Min` or `Min`->`Max` — opposite optimization directions; needs `ReduceToAggregate` or a decision-variant wrapper
 - `Or`->`Sum` or `Min`->`Sum` — Sum is aggregate-only; needs `ReduceToAggregate`
 - Any pair involving `And` or `Sum` on the target side
 
+**Regression case:** `MinimumDominatingSet<SimpleGraph, One>` resolves to `Min<i64>` because
+`<One as WeightElement>::Sum = i64`; `MinimumHittingSet` resolves to `Min<usize>`. Report
+`Min<i64> -> Min<usize>`, not `Min<usize> -> Min<usize>`. Without an explicit source-size bound,
+the full-domain type gate fails even though the classical cardinality reduction is mathematically
+correct and exhaustive small-instance checks pass.
+
 If incompatible, STOP and report the type mismatch and options. Do NOT proceed.
 
 ### If compatible
@@ -199,6 +238,10 @@ Every item must be YES. If any is NO, go back and fix.
 - [ ] Zero hand-waving language
 - [ ] Zero scratch work
 
+### Type gate
+- [ ] Concrete Rust `Value` types fully resolved with substitution evidence
+- [ ] Different numeric domains either rejected or covered by an explicit full-domain range proof
+
 ### Constructor Python
 - [ ] 0 failures, >=5,000 total checks
 - [ ] All 7 sections present and non-empty
diff --git a/.claude/skills/write-model-in-paper/SKILL.md b/.claude/skills/write-model-in-paper/SKILL.md
index 9ded09507..d8ca47ba2 100644
--- a/.claude/skills/write-model-in-paper/SKILL.md
+++ b/.claude/skills/write-model-in-paper/SKILL.md
@@ -126,16 +126,16 @@ achieves $O^*(2^n)$ @bjorklund2009.
 
 ### 3c. Example with Visualization
 
-A concrete small instance that illustrates the problem. **The example must use data from the checked-in canonical fixture DB**, not an independently invented instance.
+A concrete small instance that illustrates the problem. **Use the generated canonical example data**, not an independently invented instance.
 
 #### Sourcing example data
 
-1. If you changed example builders/specs, run `make regenerate-fixtures` to refresh `src/example_db/fixtures/examples.json`.
-2. Find the problem's entry in `src/example_db/fixtures/examples.json` under `models` — it contains the canonical `instance`, `samples`, and `optimal` fields.
+1. If you changed example builders/specs, run `cargo run --features "example-db" --example export_examples`.
+2. Find the problem's entry in `docs/paper/data/examples.json` under `models` — it contains the canonical `instance`, `samples`, and `optimal` fields.
 3. Use the values from `instance` in the paper example (translating 0-indexed code values to 1-indexed math notation where conventional, e.g., vertices {0,...,n-1} → {1,...,n}).
 4. Use `optimal` configurations to show the solution.
 
-**Do not invent a different instance.** If the canonical example is too large or not pedagogically ideal, fix it in `canonical_model_example_specs()` first, re-run `make regenerate-fixtures`, then write the paper entry from the updated JSON.
+**Do not invent a different instance.** If the canonical example is unsuitable, fix it in `canonical_model_example_specs()`, re-run `export_examples`, then use the updated JSON.
 
 #### Requirements
 
@@ -176,8 +176,6 @@ Add a `pred-commands()` block after the `*Example.*` paragraph and before the `#
 
 If `docs/paper/reductions.typ` already defines a shared `problem-spec()` helper, reuse it instead of reintroducing it locally. Do **not** guess whether the default variant matches the canonical example; canonical fixtures may live on non-default variants, and handwritten bare aliases can silently produce broken commands.
 
-For satisfaction problems, replace `pred solve` with `pred solve <name>.json --solver brute-force` if the problem has no ILP reduction path.
-
 **For graph problems**, use the paper's existing graph helpers:
 - `petersen-graph()`, `house-graph()` or define custom vertex/edge lists
 - `canvas(length: ..., { ... })` with `g-node()` and `g-edge()`
@@ -206,7 +204,7 @@ make paper
 - [ ] **Notation self-contained**: every symbol in `def` is defined before first use
 - [ ] **Background present**: historical context, applications, or structural properties
 - [ ] **Algorithms cited**: every complexity claim has `@citation` or footnote warning
-- [ ] **Example from JSON**: instance data matches `src/example_db/fixtures/examples.json` canonical example (not independently invented)
+- [ ] **Example from JSON**: instance data matches the canonical entry in `docs/paper/data/examples.json`
 - [ ] **Evaluation shown**: objective/verifier computed on the example solution
 - [ ] **Diagram included**: figure with caption and label for graph/matrix/set visualization
 - [ ] **Paper compiles**: `make paper` succeeds without errors
diff --git a/.claude/skills/write-rule-in-paper/SKILL.md b/.claude/skills/write-rule-in-paper/SKILL.md
index 0d9755b1b..e7d3c884b 100644
--- a/.claude/skills/write-rule-in-paper/SKILL.md
+++ b/.claude/skills/write-rule-in-paper/SKILL.md
@@ -7,7 +7,7 @@ description: Use when writing or improving a reduction-rule entry in the Typst p
 
 Full authoring guide for writing a `reduction-rule` entry in `docs/paper/reductions.typ`. Covers Typst mechanics, writing quality, and verification.
 
-> **Note:** This content is also inlined in `add-rule` Step 5 (condensed form). This standalone version has more detail and is useful for improving existing entries.
+> **Note:** This content is also inlined in `add-rule` Step 6 (condensed form). This standalone version has more detail and is useful for improving existing entries.
 
 ## Reference Example
 
@@ -17,14 +17,14 @@ Full authoring guide for writing a `reduction-rule` entry in `docs/paper/reducti
 
 Before using this skill, ensure:
 - The reduction is implemented and tested (`src/rules/<source>_<target>.rs`)
-- A canonical example exists in `src/example_db/rule_builders.rs`
-- If the canonical example changed, fixtures are regenerated (`make regenerate-fixtures`)
+- A rule-local `canonical_rule_example_specs()` exists and is included by `src/rules/mod.rs`
+- If the canonical example changed, regenerate the paper data with `cargo run --features "example-db" --example export_examples`
 - The reduction graph and schemas are up to date (`cargo run --example export_graph && cargo run --example export_schemas`)
 
 ## Source Material
 
 For mathematical content (theorems, proofs, examples), consult these sources in priority order:
-1. **GitHub issue** for the rule (`gh issue view <number>`): contains the verified reduction algorithm, correctness proof, size overhead, and worked examples written during issue creation
+1. **GitHub issue** for the rule (`gh issue view <number>`): contains the verified reduction algorithm, correctness proof, parameter transform, and worked examples written during issue creation
 2. **Derivation documents** (if available): e.g., `~/Downloads/reduction_derivations_*.typ` — these contain batch-verified proofs with explicit theorem/proof blocks
 3. **The implementation** (`src/rules/<source>_<target>.rs`): the code is the ground truth for the construction
 
@@ -38,7 +38,7 @@ Do NOT invent proofs — always cross-check against the issue and derivation sou
 ```
 
 Where:
-- `load-example(source, target, ...)` looks up the canonical rule entry from `src/example_db/fixtures/examples.json`
+- `load-example(source, target, ...)` looks up the canonical rule entry from `docs/paper/data/examples.json`
 - The returned record contains `source`, `target`, and `solutions`
 - Access fields: `src_tgt.source.instance`, `src_tgt.target.instance`, `src_tgt_sol.source_config`, `src_tgt_sol.target_config`
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e703c4fcd..3ef1a9fd8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -49,16 +49,65 @@ jobs:
           components: clippy
       - uses: Swatinem/rust-cache@v2
       - name: Run clippy
-        run: cargo clippy --all-targets --features ilp-highs -- -D warnings
+        run: cargo clippy --all-targets --features example-db -- -D warnings
 
-  # Cross-compile the portable Rust surface to RISC-V Linux, then execute the
-  # CLI under QEMU user-mode emulation to verify runtime behavior (not just
-  # that the binary links).
+  # Build and exercise the HiGHS-backed CLI natively on Apple Silicon.
+  macos-arm64:
+    name: macOS ARM64 build & run
+    runs-on: macos-15
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Verify ARM64 host
+        run: "rustc -vV | grep 'host: aarch64-apple-darwin'"
+      - name: Build workspace
+        run: cargo build --workspace
+      - name: Run CLI and ILP smoke test
+        run: |
+          target/debug/pred list | head -5
+          target/debug/pred create MaximumIndependentSet --graph 0-1,1-2,2-3,3-4,4-0 -o mis.json
+          target/debug/pred solve mis.json --solver ilp | tee solve.out
+          grep -q '"kind": "ilp"' solve.out
+          grep -q '"evaluation": "Max(2)"' solve.out
+
+  # Build and exercise the HiGHS-backed CLI natively on 64-bit Windows.
+  windows-x86_64:
+    name: Windows x86_64 build & run
+    runs-on: windows-2025
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Verify x86_64 host
+        shell: pwsh
+        run: |
+          $hostInfo = rustc -vV | Out-String
+          if ($hostInfo -notmatch 'host: x86_64-pc-windows-msvc') {
+            throw "Unexpected Rust host:`n$hostInfo"
+          }
+      - name: Build workspace
+        run: cargo build --workspace
+      - name: Run CLI and ILP smoke test
+        shell: pwsh
+        run: |
+          $pred = 'target/debug/pred.exe'
+          & $pred list | Select-Object -First 5
+          & $pred create MaximumIndependentSet --graph 0-1,1-2,2-3,3-4,4-0 -o mis.json
+          & $pred solve mis.json --solver ilp | Tee-Object -FilePath solve.out
+          $solveOutput = Get-Content solve.out -Raw
+          if ($solveOutput -notmatch '"kind": "ilp"') {
+            throw 'Expected the ILP solver to run'
+          }
+          if ($solveOutput -notmatch '"evaluation": "Max\(2\)"') {
+            throw 'Expected the maximum independent set value to be 2'
+          }
+
+  # Cross-compile the full HiGHS-backed CLI to RISC-V Linux, then execute an
+  # ILP solve under QEMU user-mode emulation (not just a link check).
   riscv:
     name: RISC-V build & run
     runs-on: ubuntu-latest
-    env:
-      FEATURES: "ilp-lp-solvers"
     steps:
       - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@stable
@@ -68,11 +117,13 @@ jobs:
       - name: Install RISC-V cross tools and QEMU
         run: |
           sudo apt-get update
-          sudo apt-get install -y gcc-riscv64-linux-gnu binutils-riscv64-linux-gnu qemu-user
+          sudo apt-get install -y gcc-riscv64-linux-gnu g++-riscv64-linux-gnu binutils-riscv64-linux-gnu qemu-user
       - name: Build workspace for RISC-V
         env:
           CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER: riscv64-linux-gnu-gcc
-        run: cargo build --workspace --no-default-features --features "$FEATURES" --target riscv64gc-unknown-linux-gnu
+          CC_riscv64gc_unknown_linux_gnu: riscv64-linux-gnu-gcc
+          CXX_riscv64gc_unknown_linux_gnu: riscv64-linux-gnu-g++
+        run: cargo build --workspace --target riscv64gc-unknown-linux-gnu
       - name: Verify RISC-V executable
         run: |
           riscv64-linux-gnu-readelf -h target/riscv64gc-unknown-linux-gnu/debug/pred \
@@ -83,9 +134,10 @@ jobs:
         run: |
           # Registry loads and the catalog renders on RISC-V.
           $PRED list | head -5
-          # End-to-end create + brute-force solve: MIS of a 5-cycle is 2.
+          # End-to-end reduction and HiGHS solve: MIS of a 5-cycle is 2.
           $PRED create MaximumIndependentSet --graph 0-1,1-2,2-3,3-4,4-0 -o mis.json
-          $PRED solve mis.json --solver brute-force | tee solve.out
+          $PRED solve mis.json --solver ilp | tee solve.out
+          grep -q '"kind": "ilp"' solve.out
           grep -q '"evaluation": "Max(2)"' solve.out
 
   # Build, test (nextest), doc tests, and paper.
@@ -95,7 +147,7 @@ jobs:
     # Single feature set across compile + test + doctest so artifacts are reused
     # (no redundant full recompile between steps).
     env:
-      FEATURES: "ilp-highs example-db"
+      FEATURES: "example-db"
     steps:
       - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@stable
@@ -109,14 +161,6 @@ jobs:
       - name: Compile tests
         run: cargo nextest run --no-run --workspace --features "$FEATURES"
 
-      # The subprocess example tests (tests/suites/examples.rs) shell out to
-      # `cargo run --example … --features ilp-highs`. Pre-build those example
-      # binaries with that exact feature set so the subprocess reuses artifacts
-      # instead of recompiling the whole crate mid-test (which otherwise adds
-      # 60s+ to a single test's wall-clock and would trip the nextest timeout).
-      - name: Build examples (for subprocess tests)
-        run: cargo build --examples --features ilp-highs
-
       - name: Run tests
         run: cargo nextest run --workspace --features "$FEATURES"
 
@@ -127,8 +171,8 @@ jobs:
       - name: Build paper
         run: make paper
 
-  # Coverage. Feature set intentionally matches the historical coverage gate
-  # (ilp-highs only) to keep the codecov baseline stable.
+  # Coverage intentionally excludes the optional example database to keep the
+  # historical codecov baseline stable.
   coverage:
     name: Code Coverage
     runs-on: ubuntu-latest
@@ -142,7 +186,7 @@ jobs:
           tool: cargo-llvm-cov,nextest
       - uses: Swatinem/rust-cache@v2
       - name: Generate coverage
-        run: cargo llvm-cov nextest --features ilp-highs --workspace --lcov --output-path lcov.info
+        run: cargo llvm-cov nextest --workspace --lcov --output-path lcov.info
       - name: Upload to codecov.io
         uses: codecov/codecov-action@v5
         with:
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index a262a1d0a..60aa9272e 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -61,7 +61,7 @@ jobs:
         run: typst compile --root . docs/paper/reductions.typ book/reductions.pdf
 
       - name: Build rustdoc
-        run: RUSTDOCFLAGS="--default-theme=dark" cargo doc --features ilp-highs --no-deps
+        run: RUSTDOCFLAGS="--default-theme=dark" cargo doc --no-deps
 
       - name: Combine documentation
         run: |
diff --git a/Cargo.toml b/Cargo.toml
index 3b0066232..1fa1906fa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,10 @@
 [workspace]
-members = [".", "problemreductions-macros", "problemreductions-cli"]
+members = [
+    ".",
+    "problemreductions-expr",
+    "problemreductions-macros",
+    "problemreductions-cli",
+]
 
 [package]
 name = "problemreductions"
@@ -12,41 +17,47 @@ keywords = ["np-hard", "optimization", "reduction", "sat", "graph"]
 categories = ["algorithms", "science"]
 
 [features]
-default = ["ilp-highs"]
 example-db = []
-ilp = ["ilp-highs"]  # backward compat shorthand
-ilp-solver = []      # marker: enables ILP solver code
-ilp-highs = ["ilp-solver", "dep:good_lp", "good_lp/highs"]
-ilp-cplex = ["ilp-solver", "dep:good_lp", "good_lp/cplex-rs"]
-ilp-lp-solvers = ["ilp-solver", "dep:good_lp", "good_lp/lp-solvers"]
+benchmarks = ["dep:criterion"]
 
 [dependencies]
 petgraph = { version = "0.8", features = ["serde-1"] }
 bitvec = "1.0"
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
+# Persisted problem and reduction data must preserve every finite f64 on replay.
+serde_json = { version = "1.0", features = ["float_roundtrip"] }
 thiserror = "2.0"
 num-bigint = "0.4"
+num-rational = "0.4"
 num-traits = "0.2"
-good_lp = { version = "=1.14.2", default-features = false, optional = true }
+good_lp = { version = "=1.14.2", default-features = false, features = ["highs"] }
 inventory = "0.3"
 ordered-float = "5.0"
 rand = "0.10"
+criterion = { version = "0.8", optional = true }
 problemreductions-macros = { version = "0.6.0", path = "problemreductions-macros" }
+problemreductions-expr = { version = "0.6.0", path = "problemreductions-expr" }
 
 [dev-dependencies]
 proptest = "1.0"
-criterion = "0.8"
 
 [[bench]]
 name = "solver_benchmarks"
 harness = false
+required-features = ["benchmarks"]
 
 [[example]]
 name = "export_examples"
 path = "examples/export_examples.rs"
 required-features = ["example-db"]
 
+[profile.dev]
+debug = "line-tables-only"
+
+[profile.debug-dev]
+inherits = "dev"
+debug = "full"
+
 [profile.release]
 lto = true
 codegen-units = 1
diff --git a/Makefile b/Makefile
index c18221e67..1cb637f32 100644
--- a/Makefile
+++ b/Makefile
@@ -1,10 +1,11 @@
 # Makefile for problemreductions
 
-.PHONY: help build test mcp-test fmt clippy doc mdbook website paper clean coverage rust-export compare qubo-testdata export-schemas release run-plan run-issue run-pipeline run-pipeline-forever run-review run-review-forever board-next board-claim board-ack board-move issue-context issue-guards pr-context pr-wait-ci worktree-issue worktree-pr diagrams jl-testdata cli cli-demo copilot-review papers papers-lookup papers-download papers-scihub papers-status papers-push papers-pull papers-index
+.PHONY: help build test bench mcp-test fmt clippy doc mdbook website paper clean coverage rust-export compare qubo-testdata export-schemas release run-plan run-issue run-pipeline run-pipeline-forever run-review run-review-forever board-next board-claim board-ack board-move issue-context issue-guards pr-context pr-wait-ci worktree-issue worktree-pr diagrams jl-testdata cli cli-demo copilot-review papers papers-lookup papers-download papers-scihub papers-status papers-push papers-pull papers-index
 
 RUNNER ?= codex
 CLAUDE_MODEL ?= opus
 CODEX_MODEL ?= gpt-5.4
+TEST_FEATURES := example-db
 
 # Cross-platform sed in-place: macOS needs -i '', Linux needs -i
 SED_I := sed -i$(shell if [ "$$(uname)" = "Darwin" ]; then echo " ''"; fi)
@@ -14,6 +15,7 @@ help:
 	@echo "Available targets:"
 	@echo "  build        - Build the project"
 	@echo "  test         - Run all tests"
+	@echo "  bench        - Run solver benchmarks"
 	@echo "  mcp-test     - Run MCP server tests"
 	@echo "  fmt          - Format code with rustfmt"
 	@echo "  fmt-check    - Check code formatting"
@@ -22,7 +24,7 @@ help:
 	@echo "  diagrams     - Generate SVG diagrams from Typst (light + dark)"
 	@echo "  mdbook       - Build and serve mdBook (with live reload)"
 	@echo "  website      - Build the research website and documentation"
-	@echo "  paper        - Build Typst paper from checked-in fixtures (requires typst)"
+	@echo "  paper        - Generate example data and build the Typst paper (requires typst)"
 	@echo "  coverage     - Generate coverage report (requires cargo-llvm-cov)"
 	@echo "  clean        - Clean build artifacts"
 	@echo "  check        - Quick check (fmt + clippy + test)"
@@ -63,11 +65,15 @@ help:
 
 # Build the project
 build:
-	cargo build --features ilp-highs
+	cargo build
 
 # Run all workspace tests (including ignored tests)
 test:
-	cargo test --features "ilp-highs example-db" --workspace -- --include-ignored
+	cargo test --features "$(TEST_FEATURES)" --workspace -- --include-ignored
+
+# Compile Criterion only when benchmarks are requested
+bench:
+	cargo bench --features benchmarks
 
 # Run MCP server tests
 mcp-test:  ## Run MCP server tests
@@ -83,7 +89,7 @@ fmt-check:
 
 # Run clippy
 clippy:
-	cargo clippy --all-targets --features ilp-highs -- -D warnings
+	cargo clippy --all-targets --features "$(TEST_FEATURES)" -- -D warnings
 
 node_modules/elkjs/package.json: package.json package-lock.json
 	npm ci
@@ -97,7 +103,7 @@ doc: node_modules/elkjs/package.json
 	bash scripts/generate_doc_snippets.sh target/debug/pred
 	mdbook build
 	python3 scripts/build_website.py
-	RUSTDOCFLAGS="--default-theme=dark" cargo doc --features ilp-highs --no-deps
+	RUSTDOCFLAGS="--default-theme=dark" cargo doc --no-deps
 	rm -rf book/api
 	cp -r target/doc book/api
 
@@ -133,7 +139,7 @@ mdbook: node_modules/elkjs/package.json
 	@cargo build -p problemreductions-cli --bin pred
 	@bash scripts/generate_doc_snippets.sh target/debug/pred
 	@echo "Building API docs..."
-	@RUSTDOCFLAGS="--default-theme=dark" cargo doc --features ilp-highs --no-deps 2>&1 | tail -1
+	@RUSTDOCFLAGS="--default-theme=dark" cargo doc --no-deps 2>&1 | tail -1
 	@echo "Building mdBook..."
 	@mdbook build
 	@python3 scripts/build_website.py
@@ -151,16 +157,16 @@ export-schemas:
 
 # Build Typst paper (generates example data on demand)
 paper:
-	cargo run --features "example-db" --example export_examples
-	cargo run --example export_petersen_mapping
-	cargo run --example export_graph
-	cargo run --example export_schemas
+	cargo run --features "$(TEST_FEATURES)" --example export_examples
+	cargo run --features "$(TEST_FEATURES)" --example export_petersen_mapping
+	cargo run --features "$(TEST_FEATURES)" --example export_graph
+	cargo run --features "$(TEST_FEATURES)" --example export_schemas
 	typst compile --root . docs/paper/reductions.typ docs/paper/reductions.pdf
 
 # Generate coverage report (requires: cargo install cargo-llvm-cov)
 coverage:
 	@command -v cargo-llvm-cov >/dev/null 2>&1 || { echo "Installing cargo-llvm-cov..."; cargo install cargo-llvm-cov; }
-	cargo llvm-cov --features ilp-highs --workspace --html --open
+	cargo llvm-cov --workspace --html --open
 
 # Clean build artifacts
 clean:
@@ -223,14 +229,17 @@ compare: rust-export
 		echo ""; \
 		echo "=== $$graph ==="; \
 		echo "-- unweighted --"; \
-		echo "Julia: $$(jq '{nodes: .num_grid_nodes, overhead: .mis_overhead, tape: .num_tape_entries}' tests/data/$${graph}_unweighted_trace.json)"; \
-		echo "Rust:  $$(jq '{nodes: .stages[3].num_nodes, overhead: .total_overhead, tape: ((.crossing_tape | length) + (.simplifier_tape | length))}' tests/data/$${graph}_rust_unweighted.json)"; \
+		julia=$$(jq -c '{nodes: .num_grid_nodes, overhead: .mis_overhead, tape: (.tape | length)}' tests/data/$${graph}_unweighted_trace.json); \
+		rust=$$(jq -c '{nodes: .stages[3].num_nodes, overhead: .total_overhead, tape: ((.crossing_tape | length) + (.simplifier_tape | length))}' tests/julia/$${graph}_rust_unweighted.json); \
+		echo "Julia: $$julia"; echo "Rust:  $$rust"; test "$$julia" = "$$rust" || exit 1; \
 		echo "-- weighted --"; \
-		echo "Julia: $$(jq '{nodes: .num_grid_nodes, overhead: .mis_overhead, tape: .num_tape_entries}' tests/data/$${graph}_weighted_trace.json)"; \
-		echo "Rust:  $$(jq '{nodes: .stages[3].num_nodes, overhead: .total_overhead, tape: ((.crossing_tape | length) + (.simplifier_tape | length))}' tests/data/$${graph}_rust_weighted.json)"; \
+		julia=$$(jq -c '{nodes: .num_grid_nodes, overhead: .mis_overhead, tape: (.tape | length)}' tests/data/$${graph}_weighted_trace.json); \
+		rust=$$(jq -c '{nodes: .stages[3].num_nodes, overhead: .total_overhead, tape: ((.crossing_tape | length) + (.simplifier_tape | length))}' tests/julia/$${graph}_rust_weighted.json); \
+		echo "Julia: $$julia"; echo "Rust:  $$rust"; test "$$julia" = "$$rust" || exit 1; \
 		echo "-- triangular --"; \
-		echo "Julia: $$(jq '{nodes: .num_grid_nodes, overhead: .mis_overhead, tape: .num_tape_entries}' tests/data/$${graph}_triangular_trace.json)"; \
-		echo "Rust:  $$(jq '{nodes: .stages[3].num_nodes, overhead: .total_overhead, tape: ((.crossing_tape | length) + (.simplifier_tape | length))}' tests/data/$${graph}_rust_triangular.json)"; \
+		julia=$$(jq -c '{nodes: .num_grid_nodes, overhead: .mis_overhead, tape: (.tape | length)}' tests/data/$${graph}_triangular_trace.json); \
+		rust=$$(jq -c '{nodes: .stages[3].num_nodes, overhead: .total_overhead, tape: ((.crossing_tape | length) + (.simplifier_tape | length))}' tests/julia/$${graph}_rust_triangular.json); \
+		echo "Julia: $$julia"; echo "Rust:  $$rust"; test "$$julia" = "$$rust" || exit 1; \
 	done
 
 # Run a plan with Codex or Claude
@@ -300,16 +309,12 @@ cli-demo: cli
 	$$PRED from QUBO --hops 1; \
 	\
 	echo ""; \
-	echo "--- 5. path: find reduction paths ---"; \
+	echo "--- 5. path: symbolic path enumeration ---"; \
 	$$PRED path MIS QUBO; \
-	$$PRED path MIS QUBO -o $(CLI_DEMO_DIR)/path_mis_qubo.json; \
 	$$PRED path Factoring SpinGlass; \
-	$$PRED path MIS QUBO --cost minimize:num_variables; \
-	\
-	echo ""; \
-	echo "--- 6. path --all: enumerate all paths ---"; \
-	$$PRED path MIS QUBO --all; \
-	$$PRED path MIS QUBO --all -o $(CLI_DEMO_DIR)/all_paths/; \
+	echo "--- 5b. explicitly choose one route from the path set ---"; \
+	$$PRED path MIS QUBO -o $(CLI_DEMO_DIR)/paths_mis_qubo.json; \
+	jq -e 'first(.paths[] | select(([.path[0].from.name] + [.path[].to.name]) == ["MaximumIndependentSet", "MaximumIndependentSet", "MaximumSetPacking", "MaximumSetPacking", "QUBO"]))' $(CLI_DEMO_DIR)/paths_mis_qubo.json > $(CLI_DEMO_DIR)/path_mis_qubo.json; \
 	\
 	echo ""; \
 	echo "--- 7. export-graph: full reduction graph ---"; \
@@ -318,7 +323,7 @@ cli-demo: cli
 	echo ""; \
 	echo "--- 8. create: build problem instances ---"; \
 	$$PRED create MIS --graph 0-1,1-2,2-3,3-4,4-0 -o $(CLI_DEMO_DIR)/mis.json; \
-	$$PRED create MIS --graph 0-1,1-2,2-3 --weights 2,1,3,1 -o $(CLI_DEMO_DIR)/mis_weighted.json; \
+	$$PRED create MaximumIndependentSet/SimpleGraph/i64 --graph 0-1,1-2,2-3 --weights 2,1,3,1 -o $(CLI_DEMO_DIR)/mis_weighted.json; \
 	$$PRED create SAT --num-vars 3 --clauses "1,2;-1,3;2,-3" -o $(CLI_DEMO_DIR)/sat.json; \
 	$$PRED create 3SAT --num-vars 4 --clauses "1,2,3;-1,2,-3;1,-2,3" -o $(CLI_DEMO_DIR)/3sat.json; \
 	$$PRED create QUBO --matrix "1,-0.5;-0.5,2" -o $(CLI_DEMO_DIR)/qubo.json; \
@@ -351,8 +356,8 @@ cli-demo: cli
 	$$PRED solve $(CLI_DEMO_DIR)/mis_weighted.json; \
 	\
 	echo ""; \
-	echo "--- 13. reduce: MIS → QUBO (auto-discover path) ---"; \
-	$$PRED reduce $(CLI_DEMO_DIR)/mis.json --to QUBO -o $(CLI_DEMO_DIR)/bundle_qubo.json; \
+	echo "--- 13. reduce: MIS → QUBO along the explicitly chosen route ---"; \
+	$$PRED reduce $(CLI_DEMO_DIR)/mis.json --via $(CLI_DEMO_DIR)/path_mis_qubo.json -o $(CLI_DEMO_DIR)/bundle_qubo.json; \
 	\
 	echo ""; \
 	echo "--- 14. solve bundle: brute-force on reduced QUBO ---"; \
@@ -364,7 +369,9 @@ cli-demo: cli
 	\
 	echo ""; \
 	echo "--- 16. solve bundle with ILP: MIS → MVC → ILP ---"; \
-	$$PRED reduce $(CLI_DEMO_DIR)/mis.json --to MVC -o $(CLI_DEMO_DIR)/bundle_mvc.json; \
+	$$PRED path MIS MVC -o $(CLI_DEMO_DIR)/paths_mis_mvc.json; \
+	jq -e 'first(.paths[] | select(([.path[0].from.name] + [.path[].to.name]) == ["MaximumIndependentSet", "MaximumIndependentSet", "MinimumVertexCover"]))' $(CLI_DEMO_DIR)/paths_mis_mvc.json > $(CLI_DEMO_DIR)/path_mis_mvc.json; \
+	$$PRED reduce $(CLI_DEMO_DIR)/mis.json --via $(CLI_DEMO_DIR)/path_mis_mvc.json -o $(CLI_DEMO_DIR)/bundle_mvc.json; \
 	$$PRED solve $(CLI_DEMO_DIR)/bundle_mvc.json --solver ilp; \
 	\
 	echo ""; \
@@ -381,7 +388,7 @@ cli-demo: cli
 	echo "Solving with ILP..."; \
 	$$PRED solve $(CLI_DEMO_DIR)/big.json -o $(CLI_DEMO_DIR)/big_sol.json; \
 	echo "Reducing to QUBO and solving with brute-force..."; \
-	$$PRED reduce $(CLI_DEMO_DIR)/big.json --to QUBO -o $(CLI_DEMO_DIR)/big_qubo.json; \
+	$$PRED reduce $(CLI_DEMO_DIR)/big.json --via $(CLI_DEMO_DIR)/path_mis_qubo.json -o $(CLI_DEMO_DIR)/big_qubo.json; \
 	$$PRED solve $(CLI_DEMO_DIR)/big_qubo.json --solver brute-force -o $(CLI_DEMO_DIR)/big_qubo_sol.json; \
 	echo "Verifying both solutions have the same evaluation..."; \
 	ILP_EVAL=$$(jq -r '.evaluation' $(CLI_DEMO_DIR)/big_sol.json); \
diff --git a/benches/solver_benchmarks.rs b/benches/solver_benchmarks.rs
index 69572e1d5..72dffb2e4 100644
--- a/benches/solver_benchmarks.rs
+++ b/benches/solver_benchmarks.rs
@@ -17,11 +17,11 @@ fn bench_independent_set(c: &mut Criterion) {
     for n in [4, 6, 8, 10].iter() {
         // Create a path graph with n vertices
         let edges: Vec<(usize, usize)> = (0..*n - 1).map(|i| (i, i + 1)).collect();
-        let problem = MaximumIndependentSet::new(SimpleGraph::new(*n, edges), vec![1i32; *n]);
+        let problem = MaximumIndependentSet::new(SimpleGraph::new(*n, edges), vec![1i64; *n]);
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("path", n), n, |b, _| {
-            b.iter(|| solver.find_witness(black_box(&problem)))
+            b.iter(|| solver.solve(black_box(&problem)))
         });
     }
 
@@ -34,11 +34,11 @@ fn bench_vertex_covering(c: &mut Criterion) {
 
     for n in [4, 6, 8, 10].iter() {
         let edges: Vec<(usize, usize)> = (0..*n - 1).map(|i| (i, i + 1)).collect();
-        let problem = MinimumVertexCover::new(SimpleGraph::new(*n, edges), vec![1i32; *n]);
+        let problem = MinimumVertexCover::new(SimpleGraph::new(*n, edges), vec![1i64; *n]);
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("path", n), n, |b, _| {
-            b.iter(|| solver.find_witness(black_box(&problem)))
+            b.iter(|| solver.solve(black_box(&problem)))
         });
     }
 
@@ -51,12 +51,12 @@ fn bench_max_cut(c: &mut Criterion) {
 
     for n in [4, 6, 8, 10].iter() {
         let edges: Vec<(usize, usize)> = (0..*n - 1).map(|i| (i, i + 1)).collect();
-        let weights = vec![1i32; edges.len()];
+        let weights = vec![1i64; edges.len()];
         let problem = MaxCut::new(SimpleGraph::new(*n, edges), weights);
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("path", n), n, |b, _| {
-            b.iter(|| solver.find_witness(black_box(&problem)))
+            b.iter(|| solver.solve(black_box(&problem)))
         });
     }
 
@@ -72,9 +72,9 @@ fn bench_satisfiability(c: &mut Criterion) {
         let clauses: Vec<CNFClause> = (0..*num_vars)
             .map(|i| {
                 CNFClause::new(vec![
-                    (i as i32 + 1),
-                    -((i + 1) as i32 % *num_vars as i32 + 1),
-                    ((i + 2) as i32 % *num_vars as i32 + 1),
+                    (i as i64 + 1),
+                    -((i + 1) as i64 % *num_vars as i64 + 1),
+                    ((i + 2) as i64 % *num_vars as i64 + 1),
                 ])
             })
             .collect();
@@ -100,11 +100,11 @@ fn bench_spin_glass(c: &mut Criterion) {
             .map(|i| ((i, i + 1), if i % 2 == 0 { 1.0 } else { -1.0 }))
             .collect();
         let onsite: Vec<f64> = vec![0.1; *n];
-        let problem = SpinGlass::new(*n, interactions, onsite);
+        let problem = SpinGlass::new(*n, interactions, onsite).unwrap();
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("chain", n), n, |b, _| {
-            b.iter(|| solver.find_witness(black_box(&problem)))
+            b.iter(|| solver.solve(black_box(&problem)))
         });
     }
 
@@ -120,13 +120,13 @@ fn bench_set_covering(c: &mut Criterion) {
         let sets: Vec<Vec<usize>> = (0..*num_sets)
             .map(|i| vec![i, (i + 1) % *num_sets, (i + 2) % *num_sets])
             .collect();
-        let problem = MinimumSetCovering::<i32>::new(*num_sets, sets);
+        let problem = MinimumSetCovering::<i64>::new(*num_sets, sets);
         let solver = BruteForce::new();
 
         group.bench_with_input(
             BenchmarkId::new("overlapping", num_sets),
             num_sets,
-            |b, _| b.iter(|| solver.find_witness(black_box(&problem))),
+            |b, _| b.iter(|| solver.solve(black_box(&problem))),
         );
     }
 
@@ -156,12 +156,12 @@ fn bench_matching(c: &mut Criterion) {
 
     for n in [4, 6, 8, 10].iter() {
         let edges: Vec<(usize, usize)> = (0..*n - 1).map(|i| (i, i + 1)).collect();
-        let weights = vec![1i32; edges.len()];
+        let weights = vec![1i64; edges.len()];
         let problem = MaximumMatching::new(SimpleGraph::new(*n, edges), weights);
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("path", n), n, |b, _| {
-            b.iter(|| solver.find_witness(black_box(&problem)))
+            b.iter(|| solver.solve(black_box(&problem)))
         });
     }
 
@@ -182,7 +182,7 @@ fn bench_paintshop(c: &mut Criterion) {
         let solver = BruteForce::new();
 
         group.bench_with_input(BenchmarkId::new("sequential", n), n, |b, _| {
-            b.iter(|| solver.find_witness(black_box(&problem)))
+            b.iter(|| solver.solve(black_box(&problem)))
         });
     }
 
@@ -198,10 +198,10 @@ fn bench_comparison(c: &mut Criterion) {
     // MaximumIndependentSet with 8 vertices
     let is_problem = MaximumIndependentSet::new(
         SimpleGraph::new(8, vec![(0, 1), (2, 3), (4, 5), (6, 7)]),
-        vec![1i32; 8],
+        vec![1i64; 8],
     );
     group.bench_function("MaximumIndependentSet", |b| {
-        b.iter(|| solver.find_witness(black_box(&is_problem)))
+        b.iter(|| solver.solve(black_box(&is_problem)))
     });
 
     // SAT with 8 variables
@@ -223,9 +223,10 @@ fn bench_comparison(c: &mut Criterion) {
         8,
         vec![((0, 1), 1.0), ((2, 3), -1.0), ((4, 5), 1.0), ((6, 7), -1.0)],
         vec![0.0; 8],
-    );
+    )
+    .unwrap();
     group.bench_function("SpinGlass", |b| {
-        b.iter(|| solver.find_witness(black_box(&sg_problem)))
+        b.iter(|| solver.solve(black_box(&sg_problem)))
     });
 
     // MaxCut with 8 vertices
@@ -234,7 +235,7 @@ fn bench_comparison(c: &mut Criterion) {
         vec![1, 1, 1, 1],
     );
     group.bench_function("MaxCut", |b| {
-        b.iter(|| solver.find_witness(black_box(&mc_problem)))
+        b.iter(|| solver.solve(black_box(&mc_problem)))
     });
 
     group.finish();
diff --git a/docs/agent-profiles/FEATURES.md b/docs/agent-profiles/FEATURES.md
index 7980ec62f..c4a03956e 100644
--- a/docs/agent-profiles/FEATURES.md
+++ b/docs/agent-profiles/FEATURES.md
@@ -6,5 +6,5 @@
 - [Reduction Graph] — Automatic shortest-path search through registered reductions between problem types
 - [BruteForce Solver] — Enumerate all configurations to find optimal or satisfying solutions
 - [Variant System] — Graph/weight type parameterization with compile-time complexity registration
-- [Overhead System] — Symbolic expressions describing how target problem size relates to source after reduction
+- [Parameter Analysis] — Explain how canonical problem parameters transform along a path and measure complete instances
 - [Serialization] — JSON schema export and serde-based serialization for all problem types
diff --git a/docs/agent-profiles/SKILLS.md b/docs/agent-profiles/SKILLS.md
index b7c7a6e3a..df3ffde16 100644
--- a/docs/agent-profiles/SKILLS.md
+++ b/docs/agent-profiles/SKILLS.md
@@ -1,20 +1,20 @@
 # Skills
 
-Example generation now goes through the example catalog and checked-in fixture DB.
+Example generation goes through the example catalog and generated paper data.
 When a workflow needs a paper/example instance, prefer the catalog path over ad hoc `examples/reduction_*.rs` binaries:
 
-- use `src/example_db/fixtures/examples.json` directly for paper/example data
-- use `make regenerate-fixtures` when canonical examples change
+- use `docs/paper/data/examples.json` directly for paper/example data
+- run `cargo run --features "example-db" --example export_examples` when canonical examples change
 - use `pred create --example <PROBLEM_SPEC>` to materialize a canonical model example as normal problem JSON
 - use `pred create --example <SOURCE_SPEC> --to <TARGET_SPEC>` to materialize a canonical rule example as normal problem JSON
 - when adding new example coverage, register a catalog entry instead of creating a new standalone reduction example file
 
 Post-refactor extension points:
 
-- new model load/serialize/brute-force dispatch comes from `declare_variants!` in the model file, with explicit `opt` or `sat` markers and an optional `default`
+- new model load/serialize/brute-force dispatch comes from `declare_variants!` in the model file, with an optional `default`
 - alias resolution lives in `problemreductions-cli/src/problem_name.rs`
 - `pred create` UX lives in `problemreductions-cli/src/commands/create.rs`
-- canonical examples live in `src/example_db/model_builders.rs` and `src/example_db/rule_builders.rs`
+- model examples live in `src/example_db/model_builders.rs`; rule examples live beside their rules and are collected by `src/rules/mod.rs`
 
 - [issue-to-pr] — Convert a GitHub issue into a PR with an implementation plan
 - [add-model] — Add a new problem model to the codebase
diff --git a/docs/agent-profiles/pred-sym-prof-yuki-tanaka.md b/docs/agent-profiles/pred-sym-prof-yuki-tanaka.md
index 10ad103ed..bb0dccce7 100644
--- a/docs/agent-profiles/pred-sym-prof-yuki-tanaka.md
+++ b/docs/agent-profiles/pred-sym-prof-yuki-tanaka.md
@@ -6,7 +6,7 @@ pred-sym (symbolic expression CLI)
 ## Use Case
 Three combined scenarios:
 1. **Complexity comparison** — Compare algorithm complexity expressions to determine asymptotic equivalence (e.g., O(n^2 + n) == O(n^2), O(n log n) != O(n^2)).
-2. **Reduction overhead audit** — Parse and simplify overhead expressions from reduction rules to verify they match expected growth (e.g., '3*num_vertices + num_edges^2').
+2. **Reduction size-contract audit** — Parse and simplify each rule's exact or upper-bound size relation, and verify it against constructed examples.
 3. **Teaching complexity notation** — Use pred-sym as a learning/demonstration tool to explore how expressions simplify, evaluate at concrete sizes, and compare growth rates.
 
 ## Expected Outcome
diff --git a/docs/paper/reductions.typ b/docs/paper/reductions.typ
index 88cd07556..ee531965e 100644
--- a/docs/paper/reductions.typ
+++ b/docs/paper/reductions.typ
@@ -8,7 +8,8 @@
   target: e.target,
   source-name: graph-data.nodes.at(e.source).name,
   target-name: graph-data.nodes.at(e.target).name,
-  overhead: e.overhead,
+  parameters: e.parameters,
+  parameter-contract-error: e.parameter_contract_error,
 ))
 
 #let _edges-by-source-name = {
@@ -65,7 +66,7 @@
 #show: thmrules.with(qed-symbol: $square$)
 
 // === Example JSON helpers ===
-// Load canonical example database directly from the checked-in fixture file.
+// Load the generated canonical example database.
 #let example-db = json("data/examples.json")
 
 // Pre-index rules by (source, target) and models by name so lookups are O(bucket)
@@ -139,6 +140,21 @@
   }
 }
 
+#let cli-config(solution) = "'" + json.encode(solution) + "'"
+#let bool-bit(value) = if value { 1 } else { 0 }
+#let display-value(value) = {
+  if value == none {
+    "none"
+  } else if type(value) == bool {
+    str(bool-bit(value))
+  } else if type(value) == array {
+    "[" + value.map(display-value).join(", ") + "]"
+  } else {
+    str(value)
+  }
+}
+#let fmt-values(values) = values.map(display-value).join(", ")
+
 #let graph-instance(instance) = {
   if "graph" in instance {
     instance
@@ -169,6 +185,7 @@
   "CyclicOrdering": [Cyclic Ordering],
   "AcyclicPartition": [Acyclic Partition],
   "MaximumIndependentSet": [Maximum Independent Set],
+  "DecisionMaximumIndependentSet": [Decision Maximum Independent Set],
   "MaximumLeafSpanningTree": [Maximum Leaf Spanning Tree],
   "MinimumVertexCover": [Minimum Vertex Cover],
   "MaxCut": [Max-Cut],
@@ -262,7 +279,6 @@
   "ClosestSubstring": [Closest Substring],
   "ExactCoverBy3Sets": [Exact Cover by 3-Sets],
   "ThreeDimensionalMatching": [Three-Dimensional Matching],
-  "ThreeMatroidIntersection": [Three-Matroid Intersection],
   "SubsetProduct": [Subset Product],
   "SubsetSum": [Subset Sum],
   "CosineProductIntegration": [Cosine Product Integration],
@@ -496,12 +512,6 @@
   ]
 }
 
-// Format target problem spec for pred reduce --to (handles empty variant dicts)
-#let target-spec(data) = {
-  if data.target.variant.len() == 0 { data.target.problem }
-  else { data.target.problem + "/" + data.target.variant.values().join("/") }
-}
-
 // Format a canonical example's problem spec for pred create --example
 #let problem-spec(data) = {
   if data.variant.len() == 0 { data.problem }
@@ -551,17 +561,21 @@
     parts.push(node.variant.graph)
   }
   if "weight" in node.variant {
-    if node.variant.weight == "i32" { parts.push("weighted") }
+    if node.variant.weight == "i64" { parts.push("weighted") }
     else if node.variant.weight == "f64" { parts.push("real-weighted") }
   }
   if "k" in node.variant { parts.push[$k$-ary] }
   if parts.len() > 0 { [#base (#parts.join(", "))] } else { base }
 }
 
-// Format overhead fields as inline text
-#let format-overhead(overhead) = {
-  let parts = overhead.map(o => raw(o.field + " = " + o.formula))
-  [_Overhead:_ #parts.join(", ").]
+// Format explicitly classified parameters as inline text.
+#let format-parameter-contract(fields) = {
+  let parts = fields.map(o => {
+    if o.contract == "exact" { raw(o.field + " = " + o.formula) }
+    else if o.contract == "bound-only" { raw(o.field + " <= " + o.formula) }
+    else { raw(o.field + " unavailable: " + o.reason) }
+  })
+  [_Parameter contract:_ #parts.join(", ").]
 }
 
 // Unified function for reduction rules: theorem + proof + optional example
@@ -582,7 +596,7 @@
                  else { display-name.at(target) }
   let src-lbl = label("def:" + source)
   let tgt-lbl = label("def:" + target)
-  let overhead = if edge != none and edge.overhead.len() > 0 { edge.overhead } else { none }
+  let parameters = if edge != none and edge.parameters.len() > 0 { edge.parameters } else { none }
   let thm-lbl = label("thm:" + source + "-to-" + target)
   covered-rules.update(old => old + ((source, target),))
 
@@ -590,7 +604,7 @@
     #v(1em)
     #theorem[
     *(*#context { if query(src-lbl).len() > 0 { link(src-lbl)[#src-disp] } else [#src-disp] }* #arrow *#context { if query(tgt-lbl).len() > 0 { link(tgt-lbl)[#tgt-disp] } else [#tgt-disp] }*)* #theorem-body
-    #if overhead != none { linebreak(); format-overhead(overhead) }
+    #if parameters != none { linebreak(); format-parameter-contract(parameters) }
   ] #thm-lbl]
 
   proof[#proof-body]
@@ -767,7 +781,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let ne = graph-num-edges(x.instance)
   // Pick optimal config = {v1, v3, v5, v9} to match figure
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let S = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let S = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let alpha = metric-value(sol.metric)
   [
     #problem-def("MaximumIndependentSet")[
@@ -780,7 +794,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MIS -o mis.json",
       "pred solve mis.json",
-      "pred evaluate mis.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate mis.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -801,7 +815,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let weights = x.instance.weights
   let k = x.instance.bound_k
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let S = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let S = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let wS = metric-value(sol.metric)
   [
     #problem-def("MaximumCoKPlex")[
@@ -814,7 +828,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example " + problem-spec(x) + " -o co-k-plex.json",
       "pred solve co-k-plex.json",
-      "pred evaluate co-k-plex.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate co-k-plex.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -885,7 +899,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MaximumCommonEdgeSubgraph -o mces.json",
       "pred solve mces.json --solver brute-force",
-      "pred evaluate mces.json --config " + f.map(str).join(","),
+      "pred evaluate mces.json --config " + cli-config(f),
     )
 
     #figure({
@@ -988,7 +1002,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MaximumContactMapOverlap -o cmo.json",
       "pred solve cmo.json --solver brute-force",
-      "pred evaluate cmo.json --config " + config.map(str).join(","),
+      "pred evaluate cmo.json --config " + cli-config(config),
     )
 
     #figure({
@@ -1059,7 +1073,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let edge-weights = x.instance.edge_weights
   let k = x.instance.k
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let S = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let S = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let wS = metric-value(sol.metric)
   let edge-strs = edges.zip(edge-weights).map(((e, w)) => [$w_(#e.at(0)#e.at(1)) = #w$]).join(", ")
   [
@@ -1075,7 +1089,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example " + problem-spec(x) + " -o k-clique.json",
       "pred solve k-clique.json",
-      "pred evaluate k-clique.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate k-clique.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -1100,9 +1114,9 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let nv = 4
   let edges = ((0, 1), (0, 2), (1, 2), (2, 3))
   let ne = edges.len()
-  let config = (0, 0, 0, 1)
-  let deleted = edges.zip(config).filter(((e, b)) => b == 1).map(((e, _)) => e)
-  let surviving = edges.zip(config).filter(((e, b)) => b == 0).map(((e, _)) => e)
+  let config = (false, false, false, true)
+  let deleted = edges.zip(config).filter(((e, deleted)) => deleted).map(((e, _)) => e)
+  let surviving = edges.zip(config).filter(((e, deleted)) => not deleted).map(((e, _)) => e)
   let cluster = (0, 1, 2)
   let opt-val = deleted.len()
   [
@@ -1118,7 +1132,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example HighlyConnectedDeletion -o hcd.json",
       "pred solve hcd.json",
-      "pred evaluate hcd.json --config " + config.map(str).join(","),
+      "pred evaluate hcd.json --config " + cli-config(config),
     )
 
     #figure({
@@ -1154,7 +1168,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example EulerianPath -o eulerian.json",
         "pred solve eulerian.json",
-        "pred evaluate eulerian.json --config " + pi.map(str).join(","),
+        "pred evaluate eulerian.json --config " + cli-config(pi),
       )
 
       #figure(
@@ -1231,10 +1245,11 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let beta = x.instance.beta
   let omega = x.instance.omega
   let config = x.optimal_config
-  // Configuration layout: first nv bits are vertex selectors x_v, next ne bits are y_e.
-  let selected-verts = range(nv).filter(v => config.at(v) == 1)
-  let omitted-verts = range(nv).filter(v => config.at(v) == 0)
-  let selected-edge-indices = range(ne).filter(i => config.at(nv + i) == 1)
+  let vertex-config = config.at(0)
+  let edge-config = config.at(1)
+  let selected-verts = range(nv).filter(v => vertex-config.at(v))
+  let omitted-verts = range(nv).filter(v => not vertex-config.at(v))
+  let selected-edge-indices = range(ne).filter(i => edge-config.at(i))
   let selected-edges = selected-edge-indices.map(i => edges.at(i))
   let omitted-prize-sum = omitted-verts.map(v => vertex-prizes.at(v)).fold(0, (a, b) => a + b)
   let edge-cost-sum = selected-edge-indices.map(i => edge-costs.at(i)).fold(0, (a, b) => a + b)
@@ -1253,7 +1268,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example PrizeCollectingSteinerForest -o pcsf.json",
       "pred solve pcsf.json --solver brute-force",
-      "pred evaluate pcsf.json --config " + config.map(str).join(","),
+      "pred evaluate pcsf.json --config " + cli-config(config),
     )
 
     #figure({
@@ -1295,9 +1310,9 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let edges = x.instance.graph.edges
   // Pick optimal config = {v0, v3, v4} to match figure
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let cover = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let cover = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let wS = metric-value(sol.metric)
-  let complement = sol.config.enumerate().filter(((i, v)) => v == 0).map(((i, _)) => i)
+  let complement = sol.config.enumerate().filter(((i, v)) => not v).map(((i, _)) => i)
   let alpha = complement.len()
   [
     #problem-def("MinimumVertexCover")[
@@ -1313,7 +1328,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MVC -o mvc.json",
       "pred solve mvc.json",
-      "pred evaluate mvc.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate mvc.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -1333,7 +1348,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let ne = graph-num-edges(x.instance)
   let k = x.instance.bound
   let sol = x.optimal_config
-  let cover = sol.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let cover = sol.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   [
     #problem-def("DecisionMinimumVertexCover")[
       Given an undirected graph $G = (V, E)$ with vertex weights $w: V -> RR_(gt.eq 0)$ and an integer bound $k$, determine whether there exists a vertex cover $S subset.eq V$ with $sum_(v in S) w(v) <= k$ such that every edge has at least one endpoint in $S$.
@@ -1345,7 +1360,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example DecisionMinimumVertexCover -o vc.json",
       "pred solve vc.json",
-      "pred evaluate vc.json --config " + sol.map(str).join(","),
+      "pred evaluate vc.json --config " + cli-config(sol),
     )
 
     #figure({
@@ -1360,14 +1375,14 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 }
 
 #{
-  let x = load-model-example("MaxCut", variant: (graph: "SimpleGraph", weight: "i32"))
+  let x = load-model-example("MaxCut", variant: (graph: "SimpleGraph", weight: "i64"))
   let nv = graph-num-vertices(x.instance)
   let ne = graph-num-edges(x.instance)
   let edges = x.instance.graph.edges
   // Pick optimal config = S={v0, v3} to match figure
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let side-s = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
-  let side-sbar = sol.config.enumerate().filter(((i, v)) => v == 0).map(((i, _)) => i)
+  let side-s = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
+  let side-sbar = sol.config.enumerate().filter(((i, v)) => not v).map(((i, _)) => i)
   let cut-val = metric-value(sol.metric)
   let cut-edges = edges.filter(e => side-s.contains(e.at(0)) != side-s.contains(e.at(1)))
   let uncut-edges = edges.filter(e => side-s.contains(e.at(0)) == side-s.contains(e.at(1)))
@@ -1382,7 +1397,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MaxCut -o maxcut.json",
       "pred solve maxcut.json",
-      "pred evaluate maxcut.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate maxcut.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(canvas(length: 1cm, {
@@ -1417,8 +1432,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let nv = graph-num-vertices(x.instance)
   let ne = graph-num-edges(x.instance)
   let edges = x.instance.graph.edges
-  let side-a = x.optimal_config.enumerate().filter(((i, v)) => v == 0).map(((i, _)) => i)
-  let side-b = x.optimal_config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let side-a = x.optimal_config.enumerate().filter(((i, v)) => not v).map(((i, _)) => i)
+  let side-b = x.optimal_config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let cut-edges = edges.filter(e => x.optimal_config.at(e.at(0)) != x.optimal_config.at(e.at(1)))
   let cut-val = metric-value(x.optimal_value)
   [
@@ -1434,7 +1449,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example GraphPartitioning -o gp.json",
       "pred solve gp.json",
-      "pred evaluate gp.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate gp.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -1450,7 +1465,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   ]
 }
 #{
-  let x = load-model-example("MinimumCutIntoBoundedSets", variant: (graph: "SimpleGraph", weight: "i32"))
+  let x = load-model-example("MinimumCutIntoBoundedSets", variant: (graph: "SimpleGraph", weight: "i64"))
   let nv = graph-num-vertices(x.instance)
   let edges = x.instance.graph.edges
   let ew = x.instance.edge_weights
@@ -1458,8 +1473,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let snk = x.instance.sink
   let B = x.instance.size_bound
   let config = x.optimal_config
-  let V1 = range(nv).filter(i => config.at(i) == 0)
-  let V2 = range(nv).filter(i => config.at(i) == 1)
+  let V1 = range(nv).filter(i => not config.at(i))
+  let V2 = range(nv).filter(i => config.at(i))
   let cut-idx = edges.enumerate().filter(((i, e)) => config.at(e.at(0)) != config.at(e.at(1))).map(((i, _)) => i)
   let cut-weight = metric-value(x.optimal_value)
   [
@@ -1476,7 +1491,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumCutIntoBoundedSets -o mcibs.json",
         "pred solve mcibs.json",
-        "pred evaluate mcibs.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mcibs.json --config " + cli-config(x.optimal_config),
       )
 
       // Layout matches the checked-in canonical instance (8 vertices, 12 edges); see
@@ -1513,7 +1528,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
           content((mx, my), text(6.5pt, fill: rgb("#333333"))[#str(int(ew.at(i)))])
         }
         for (k, pos) in vpos.enumerate() {
-          let in-v1 = config.at(k) == 0
+          let in-v1 = not config.at(k)
           g-node(pos, name: "v" + str(k),
             fill: if in-v1 { graph-colors.at(0) } else { graph-colors.at(1) },
             label: text(fill: white)[$v_#k$])
@@ -1525,13 +1540,13 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   ]
 }
 #{
-  let x = load-model-example("BiconnectivityAugmentation", variant: (graph: "SimpleGraph", weight: "i32"))
+  let x = load-model-example("BiconnectivityAugmentation", variant: (graph: "SimpleGraph", weight: "i64"))
   let nv = x.instance.graph.num_vertices
   let path-edges-j = x.instance.graph.edges.map(e => (e.at(0), e.at(1)))
   let candidates = x.instance.potential_weights.map(c => (u: c.at(0), v: c.at(1), w: c.at(2)))
   let budget = x.instance.budget
   let config = x.optimal_config
-  let sel-idx = range(candidates.len()).filter(i => config.at(i) == 1)
+  let sel-idx = range(candidates.len()).filter(i => config.at(i))
   let sel-weight = sel-idx.map(i => candidates.at(i).w).sum(default: 0)
   [
     #problem-def("BiconnectivityAugmentation")[
@@ -1544,7 +1559,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example BiconnectivityAugmentation -o biaug.json",
         "pred solve biaug.json",
-        "pred evaluate biaug.json --config " + config.map(str).join(","),
+        "pred evaluate biaug.json --config " + cli-config(config),
       )
 
       #figure(
@@ -1604,7 +1619,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example HC -o hc.json",
         "pred solve hc.json",
-        "pred evaluate hc.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate hc.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -1646,7 +1661,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let ne = edges.len()
   let edge-lengths = x.instance.edge_lengths
   let config = x.optimal_config
-  let selected = range(ne).filter(i => config.at(i) == 1)
+  let selected = range(ne).filter(i => config.at(i))
   let total-length = selected.map(i => edge-lengths.at(i)).sum()
   let cycle-order = (0, 1, 4, 5, 2, 3)
   [
@@ -1662,7 +1677,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o longest-circuit.json",
         "pred solve longest-circuit.json",
-        "pred evaluate longest-circuit.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate longest-circuit.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -1679,7 +1694,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
           })
 
           for (ei, (u, v)) in edges.enumerate() {
-            let is-selected = config.at(ei) == 1
+            let is-selected = config.at(ei)
             let col = if is-selected { colors.selected } else { colors.unused }
             let thickness = if is-selected { 1.3pt } else { 0.5pt }
             let dash = if is-selected { "solid" } else { "dashed" }
@@ -1720,7 +1735,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
 
 #{
-  let x = load-model-example("BoundedComponentSpanningForest", variant: (graph: "SimpleGraph", weight: "i32"))
+  let x = load-model-example("BoundedComponentSpanningForest", variant: (graph: "SimpleGraph", weight: "i64"))
   let nv = x.instance.graph.num_vertices
   let edges-j = x.instance.graph.edges.map(e => (e.at(0), e.at(1)))
   let weights = x.instance.weights
@@ -1736,12 +1751,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Bounded Component Spanning Forest appears as ND10 in Garey and Johnson @garey1979. It asks for a decomposition into a bounded number of connected pieces, each with bounded total weight, so it naturally captures contiguous districting and redistricting-style constraints where each district must remain connected while respecting a population cap. A direct exhaustive search over component labels gives an $O^*(K^n)$ baseline, but subset-DP techniques via inclusion-exclusion improve the exact running time to $O^*(3^n)$ @bjorklund2009.
 
-      *Example.* Consider the graph on $n = #nv$ vertices ${v_0, dots, v_#(nv - 1)}$ with $|E| = #{edges-j.len()}$ edges, vertex weights $(#weights.map(str).join(", "))$, component limit $K = #K$, and bound $B = #B$. The partition #range(num-parts).map(p => $V_#(p + 1) = {#parts.at(p).map(i => $v_#i$).join(", ")}$).join(", ") is feasible: each set induces a connected subgraph, and the component weights #range(num-parts).map(p => $#{parts.at(p).map(i => str(weights.at(i))).join(" + ")} = #part-weights.at(p)$).join(", ") all respect $B = #B$. Therefore this instance is a YES instance.
+      *Example.* Consider the graph on $n = #nv$ vertices ${v_0, dots, v_#(nv - 1)}$ with $|E| = #{edges-j.len()}$ edges, vertex weights $(#fmt-values(weights))$, component limit $K = #K$, and bound $B = #B$. The partition #range(num-parts).map(p => $V_#(p + 1) = {#parts.at(p).map(i => $v_#i$).join(", ")}$).join(", ") is feasible: each set induces a connected subgraph, and the component weights #range(num-parts).map(p => $#{parts.at(p).map(i => str(weights.at(i))).join(" + ")} = #part-weights.at(p)$).join(", ") all respect $B = #B$. Therefore this instance is a YES instance.
 
       #pred-commands(
         "pred create --example BoundedComponentSpanningForest -o bcsf.json",
         "pred solve bcsf.json",
-        "pred evaluate bcsf.json --config " + partition.map(str).join(","),
+        "pred evaluate bcsf.json --config " + cli-config(partition),
       )
 
       #figure(
@@ -1772,7 +1787,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
             content(lpos, text(7pt)[$w = #(weights.at(k))$])
           }
         }),
-        caption: [Bounded Component Spanning Forest on #nv vertices with $K = #K$ and $B = #B$. The partition #range(num-parts).map(p => $V_#(p+1) = {#parts.at(p).map(i => $v_#i$).join(", ")}$).join(", ") (weights #part-weights.map(str).join(", ")) is feasible. Bold colored edges are intra-component; gray edges cross components.],
+        caption: [Bounded Component Spanning Forest on #nv vertices with $K = #K$ and $B = #B$. The partition #range(num-parts).map(p => $V_#(p+1) = {#parts.at(p).map(i => $v_#i$).join(", ")}$).join(", ") (weights #fmt-values(part-weights)) is feasible. Bold colored edges are intra-component; gray edges cross components.],
       ) <fig:bcsf>
     ]
   ]
@@ -1790,14 +1805,14 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #problem-def("LengthBoundedDisjointPaths")[
       Given an undirected graph $G = (V, E)$, distinct terminals $s, t in V$, and a positive integer $K$, maximize the number of pairwise internally vertex-disjoint paths from $s$ to $t$, each using at most $K$ edges.
     ][
-      Length-Bounded Disjoint Paths is the bounded-routing version of the classical disjoint-path problem, with applications in network routing and VLSI where multiple connections must fit simultaneously under quality-of-service limits. Garey & Johnson list it as ND41 and summarize the sharp threshold proved by Itai, Perl, and Shiloach: the problem is NP-complete for every fixed $K >= 5$, polynomial-time solvable for $K <= 4$, and becomes polynomial again when the length bound is removed entirely @garey1979. The implementation here uses $M dot |V|$ binary variables where $M = min(deg(s), deg(t))$ is an upper bound on the number of vertex-disjoint $s$-$t$ paths, so brute-force search over configurations runs in $O^*(2^(M dot |V|))$.
+      Length-Bounded Disjoint Paths is the bounded-routing version of the classical disjoint-path problem, with applications in network routing and VLSI where multiple connections must fit simultaneously under quality-of-service limits. Garey & Johnson list it as ND41 and summarize the sharp threshold proved by Itai, Perl, and Shiloach: the problem is NP-complete for every fixed $K >= 5$, polynomial-time solvable for $K <= 4$, and becomes polynomial again when the length bound is removed entirely @garey1979. The implementation here uses $M dot |E|$ binary variables where $M = min(deg(s), deg(t))$ is an upper bound on the number of vertex-disjoint $s$-$t$ paths, so brute-force search over configurations runs in $O^*(2^(M dot |E|))$. Each row selects the edges of one path in the input graph's edge order; an all-zero row is unused.
 
       *Example.* Consider the graph $G$ with $n = #nv$ vertices, $|E| = #ne$ edges, terminals $s = v_#s$, $t = v_#t$, and $K = #K$. Here $M = #M$ path slots are available. The three paths $P_1 = v_0 arrow v_1 arrow v_4$, $P_2 = v_0 arrow v_2 arrow v_4$, and $P_3 = v_0 arrow v_3 arrow v_4$ are each of length 2 (at most $K = 3$), and their internal vertex sets ${v_1}$, ${v_2}$, and ${v_3}$ are pairwise disjoint. The optimal value is therefore $3$.
 
       #pred-commands(
         "pred create --example LengthBoundedDisjointPaths -o length-bounded-disjoint-paths.json",
         "pred solve length-bounded-disjoint-paths.json",
-        "pred evaluate length-bounded-disjoint-paths.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate length-bounded-disjoint-paths.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -1874,7 +1889,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example DisjointConnectingPaths -o disjoint-connecting-paths.json",
         "pred solve disjoint-connecting-paths.json",
-        "pred evaluate disjoint-connecting-paths.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate disjoint-connecting-paths.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -1944,7 +1959,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example GeneralizedHex -o generalized-hex.json",
         "pred solve generalized-hex.json",
-        "pred evaluate generalized-hex.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate generalized-hex.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -2014,7 +2029,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example HamiltonianPath -o hamiltonian-path.json",
         "pred solve hamiltonian-path.json",
-        "pred evaluate hamiltonian-path.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate hamiltonian-path.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -2063,7 +2078,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example HamiltonianPathBetweenTwoVertices -o hpbtv.json",
         "pred solve hpbtv.json",
-        "pred evaluate hpbtv.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate hpbtv.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -2118,7 +2133,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example DirectedHamiltonianPath -o dhp.json",
         "pred solve dhp.json",
-        "pred evaluate dhp.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate dhp.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -2166,7 +2181,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let x = load-model-example("Kernel")
   let nv = x.instance.graph.num_vertices
   let arcs = x.instance.graph.arcs
-  let in-kernel(k) = x.optimal_config.at(k) == 1
+  let in-kernel(k) = x.optimal_config.at(k)
   [
     #problem-def("Kernel")[
       Given a directed graph $G = (V, A)$, find a _kernel_ $V' subset.eq V$ such that (1) $V'$ is _independent_ — no arc joins any two vertices in $V'$ — and (2) $V'$ is _absorbing_ — every vertex $u in.not V'$ has an arc $(u, v) in A$ for some $v in V'$.
@@ -2180,7 +2195,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example Kernel -o kernel.json",
         "pred solve kernel.json",
-        "pred evaluate kernel.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate kernel.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -2257,7 +2272,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let t = x.instance.target_vertex
   let path-config = x.optimal_config
   let path-order = (0, 1, 3, 2, 4, 5, 6)
-  let path-edges = edges.enumerate().filter(((idx, _)) => path-config.at(idx) == 1).map(((idx, e)) => e)
+  let path-edges = edges.enumerate().filter(((idx, _)) => path-config.at(idx)).map(((idx, e)) => e)
   [
     #problem-def("LongestPath")[
       Given an undirected graph $G = (V, E)$ with positive edge lengths $l: E -> ZZ^+$ and designated vertices $s, t in V$, find a simple path $P$ from $s$ to $t$ maximizing $sum_(e in P) l(e)$.
@@ -2269,7 +2284,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example LongestPath -o longest-path.json",
         "pred solve longest-path.json",
-        "pred evaluate longest-path.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate longest-path.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -2282,7 +2297,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
           // so route them as quadratic Bezier arcs (below / above the main layout).
           let arc-ctrl = ("7": (3.75, -0.35), "9": (3.1, 2.85))
           for (idx, (u, v)) in edges.enumerate() {
-            let on-path = path-config.at(idx) == 1
+            let on-path = path-config.at(idx)
             let st = if on-path { 2pt + blue } else { 1pt + gray }
             let key = str(idx)
             if key in arc-ctrl {
@@ -2339,12 +2354,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Undirected Flow with Lower Bounds appears as ND37 in Garey and Johnson's catalog @garey1979. Itai proved that even this single-commodity undirected feasibility problem is NP-complete, contrasting sharply with the directed lower-bounded case, which reduces to ordinary max-flow machinery @itai1978.
 
-      *Example.* The canonical fixture uses source $s = v_#s$, sink $t = v_#t$, requirement $R = #R$, edges ${#edges.map(((u, v)) => $(v_#u, v_#v)$).join(", ")}$, and lower/upper pairs ${#range(edges.len()).map(i => $(#lower.at(i), #caps.at(i))$).join(", ")}$ in that order. Under the all-zero orientation config, a feasible witness sends flows $(#witness.map(str).join(", "))$ along those edges respectively: $2$ on $(v_0, v_1)$, $1$ on $(v_0, v_2)$, $1$ on $(v_1, v_3)$, $1$ on $(v_2, v_3)$, $1$ on $(v_1, v_4)$, $2$ on $(v_3, v_5)$, and $1$ on $(v_4, v_5)$. Every lower bound is satisfied, each nonterminal vertex has equal inflow and outflow, and the sink receives $2 + 1 = 3 >= R$, so the instance evaluates to true.
+      *Example.* The canonical fixture uses source $s = v_#s$, sink $t = v_#t$, requirement $R = #R$, edges ${#edges.map(((u, v)) => $(v_#u, v_#v)$).join(", ")}$, and lower/upper pairs ${#range(edges.len()).map(i => $(#lower.at(i), #caps.at(i))$).join(", ")}$ in that order. Under the all-zero orientation config, a feasible witness sends flows $(#fmt-values(witness))$ along those edges respectively: $2$ on $(v_0, v_1)$, $1$ on $(v_0, v_2)$, $1$ on $(v_1, v_3)$, $1$ on $(v_2, v_3)$, $1$ on $(v_1, v_4)$, $2$ on $(v_3, v_5)$, and $1$ on $(v_4, v_5)$. Every lower bound is satisfied, each nonterminal vertex has equal inflow and outflow, and the sink receives $2 + 1 = 3 >= R$, so the instance evaluates to true.
 
       #pred-commands(
         "pred create --example UndirectedFlowLowerBounds -o undirected-flow-lower-bounds.json",
         "pred solve undirected-flow-lower-bounds.json",
-        "pred evaluate undirected-flow-lower-bounds.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate undirected-flow-lower-bounds.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -2419,7 +2434,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example UndirectedTwoCommodityIntegralFlow -o undirected-two-commodity-integral-flow.json",
         "pred solve undirected-two-commodity-integral-flow.json",
-        "pred evaluate undirected-two-commodity-integral-flow.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate undirected-two-commodity-integral-flow.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -2483,7 +2498,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o path-constrained-network-flow.json",
         "pred solve path-constrained-network-flow.json --solver brute-force",
-        "pred evaluate path-constrained-network-flow.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate path-constrained-network-flow.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -2601,7 +2616,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example IsomorphicSpanningTree -o isomorphic-spanning-tree.json",
         "pred solve isomorphic-spanning-tree.json",
-        "pred evaluate isomorphic-spanning-tree.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate isomorphic-spanning-tree.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -2649,7 +2664,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let t = x.instance.target_vertex
   let W = x.instance.weight_bound
   let path-config = x.optimal_config
-  let path-edges = edges.enumerate().filter(((idx, _)) => path-config.at(idx) == 1).map(((idx, e)) => e)
+  let path-edges = edges.enumerate().filter(((idx, _)) => path-config.at(idx)).map(((idx, e)) => e)
   let path-order = (0, 2, 3, 5)
   [
     #problem-def("ShortestWeightConstrainedPath")[
@@ -2664,7 +2679,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ShortestWeightConstrainedPath -o shortest-weight-constrained-path.json",
         "pred solve shortest-weight-constrained-path.json",
-        "pred evaluate shortest-weight-constrained-path.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate shortest-weight-constrained-path.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -2677,7 +2692,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
           // labels toward opposite ends of each edge so they don't collide.
           let label-t = ("3": 0.3, "7": 0.7)
           for (idx, (u, v)) in edges.enumerate() {
-            let on-path = path-config.at(idx) == 1
+            let on-path = path-config.at(idx)
             g-edge(verts.at(u), verts.at(v), stroke: if on-path { 2pt + blue } else { 1pt + gray })
             let pu = verts.at(u)
             let pv = verts.at(v)
@@ -2721,6 +2736,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #problem-def("KColoring")[
       Given $G = (V, E)$ and a positive integer $k$, determine whether there exists a proper $k$-coloring $c: V -> {1, ..., k}$ such that $c(u) eq.not c(v)$ for every $(u, v) in E$.
     ][
+    Fixed variants derive their color count from the type parameter; a serialized `num_colors` that disagrees with that fixed count is rejected. The `KN` variant stores its color count at runtime.
+
     Graph coloring arises in register allocation, frequency assignment, and scheduling @garey1979. Deciding $k$-colorability is NP-complete for $k >= 3$ but solvable in $O(n+m)$ for $k=2$ via bipartiteness testing. For $k = 3$, the best known algorithm runs in $O^*(1.3289^n)$ @beigel2005; for $k = 4$ in $O^*(1.7159^n)$ @wu2024; for $k = 5$ in $O^*((2-epsilon)^n)$ @zamir2021. In general, inclusion-exclusion achieves $O^*(2^n)$ @bjorklund2009.
 
     *Example.* Consider the house graph $G$ with $k = #k$ colors. The coloring #range(nv).map(i => $c(v_#i) = #(coloring.at(i) + 1)$).join(", ") is proper: no adjacent pair shares a color, so the number of conflicts is 0. The house graph has chromatic number $chi(G) = #k$ because the triangle $(v_2, v_3, v_4)$ requires #k colors.
@@ -2728,7 +2745,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example " + problem-spec(x) + " -o kcoloring.json",
       "pred solve kcoloring.json",
-      "pred evaluate kcoloring.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate kcoloring.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -2760,7 +2777,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MaximumAchromaticNumber -o achromatic.json",
         "pred solve achromatic.json",
-        "pred evaluate achromatic.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate achromatic.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -2782,7 +2799,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let edges = x.instance.graph.edges
   // Pick optimal config = {v2, v3} to match figure
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let S = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let S = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let wS = metric-value(sol.metric)
   // Compute neighbors dominated by each vertex in S
   let dominated = S.map(s => {
@@ -2804,7 +2821,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumDominatingSet -o minimum-dominating-set.json",
       "pred solve minimum-dominating-set.json",
-      "pred evaluate minimum-dominating-set.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate minimum-dominating-set.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -2821,7 +2838,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let n = x.instance.points.len()
   let B = x.instance.radius
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let S = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let S = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let wS = metric-value(sol.metric)
   [
     #problem-def("MinimumGeometricConnectedDominatingSet")[
@@ -2834,7 +2851,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumGeometricConnectedDominatingSet -o mgcds.json",
       "pred solve mgcds.json",
-      "pred evaluate mgcds.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate mgcds.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -2905,7 +2922,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumCoveringByCliques -o covering-by-cliques.json",
         "pred solve covering-by-cliques.json",
-        "pred evaluate covering-by-cliques.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate covering-by-cliques.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -2949,7 +2966,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumIntersectionGraphBasis -o intersection-basis.json",
         "pred solve intersection-basis.json",
-        "pred evaluate intersection-basis.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate intersection-basis.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -2986,7 +3003,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let edges = x.instance.graph.edges
   // Pick optimal config [1,0,0,0,1,0] = edges {(0,1),(2,4)} to match figure
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let matched-edges = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => edges.at(i))
+  let matched-edges = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => edges.at(i))
   let wM = metric-value(sol.metric)
   // Collect matched vertices
   let matched-verts = ()
@@ -3006,7 +3023,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MaximumMatching -o maximum-matching.json",
       "pred solve maximum-matching.json",
-      "pred evaluate maximum-matching.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate maximum-matching.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3025,7 +3042,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let edges = x.instance.graph.edges
   let ew = x.instance.edge_weights
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let tour-edges = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => edges.at(i))
+  let tour-edges = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => edges.at(i))
   let bottleneck = metric-value(sol.metric)
   let tour-weights = tour-edges.map(((u, v)) => {
     let idx = edges.position(e => e == (u, v) or e == (v, u))
@@ -3059,7 +3076,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example BottleneckTravelingSalesman -o btsp.json",
       "pred solve btsp.json",
-      "pred evaluate btsp.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate btsp.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3121,7 +3138,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let edges = x.instance.graph.edges
   let ew = x.instance.edge_weights
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let tour-edges = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => edges.at(i))
+  let tour-edges = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => edges.at(i))
   let tour-cost = metric-value(sol.metric)
   // Build ordered tour from tour-edges starting at vertex 0
   let tour-order = (0,)
@@ -3152,7 +3169,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example TSP -o tsp.json",
       "pred solve tsp.json",
-      "pred evaluate tsp.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate tsp.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3190,7 +3207,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let weights = x.instance.edge_weights
   let terminals = x.instance.terminals
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let tree-edge-indices = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let tree-edge-indices = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let tree-edges = tree-edge-indices.map(i => edges.at(i))
   let cost = metric-value(sol.metric)
   // Steiner vertices: in tree but not terminals
@@ -3223,7 +3240,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example SteinerTree -o steiner-tree.json",
       "pred solve steiner-tree.json",
-      "pred evaluate steiner-tree.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate steiner-tree.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3262,7 +3279,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let candidates = x.instance.candidate_arcs
   let bound = x.instance.bound
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let chosen = candidates.enumerate().filter(((i, _)) => sol.config.at(i) == 1).map(((i, arc)) => arc)
+  let chosen = candidates.enumerate().filter(((i, _)) => sol.config.at(i)).map(((i, arc)) => arc)
   let total-weight = chosen.map(a => a.at(2)).sum()
   let blue = graph-colors.at(0)
   [
@@ -3276,7 +3293,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example StrongConnectivityAugmentation -o strong-connectivity-augmentation.json",
       "pred solve strong-connectivity-augmentation.json",
-      "pred evaluate strong-connectivity-augmentation.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate strong-connectivity-augmentation.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3338,7 +3355,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let weights = x.instance.edge_weights
   let terminals = x.instance.terminals
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let cut-edge-indices = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let cut-edge-indices = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let cut-edges = cut-edge-indices.map(i => edges.at(i))
   let cost = metric-value(sol.metric)
   [
@@ -3352,7 +3369,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumMultiwayCut -o minimum-multiway-cut.json",
       "pred solve minimum-multiway-cut.json",
-      "pred evaluate minimum-multiway-cut.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate minimum-multiway-cut.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3401,7 +3418,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example OptimalLinearArrangement -o optimal-linear-arrangement.json",
         "pred solve optimal-linear-arrangement.json",
-        "pred evaluate optimal-linear-arrangement.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate optimal-linear-arrangement.json --config " + cli-config(x.optimal_config),
       )
 
       // Build inverse mapping: pos[p] = vertex placed at position p
@@ -3466,7 +3483,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example RootedTreeArrangement -o rooted-tree-arrangement.json",
         "pred solve rooted-tree-arrangement.json --solver brute-force",
-        "pred evaluate rooted-tree-arrangement.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate rooted-tree-arrangement.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -3520,7 +3537,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let edges = x.instance.graph.edges
   let k = x.instance.k
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let K = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let K = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let clique-edges = edges.filter(e => K.contains(e.at(0)) and K.contains(e.at(1)))
   [
     #problem-def("KClique")[
@@ -3533,7 +3550,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example KClique -o kclique.json",
       "pred solve kclique.json",
-      "pred evaluate kclique.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate kclique.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3552,7 +3569,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let edges = x.instance.graph.edges
   // optimal config = {v2, v3, v4}
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let K = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let K = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let omega = metric-value(sol.metric)
   // Edges within the clique
   let clique-edges = edges.filter(e => K.contains(e.at(0)) and K.contains(e.at(1)))
@@ -3567,7 +3584,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MaximumClique -o maximum-clique.json",
       "pred solve maximum-clique.json",
-      "pred evaluate maximum-clique.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate maximum-clique.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3586,7 +3603,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let edges = x.instance.graph.edges
   // optimal config = {v0,v2,v4} with w=3 (maximum-weight maximal IS)
   let opt = (config: x.optimal_config, metric: x.optimal_value)
-  let S-opt = opt.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let S-opt = opt.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let w-opt = metric-value(opt.metric)
   // Suboptimal maximal IS {v1,v3} with w=2 (hardcoded — no longer in fixture)
   let S-sub = (1, 3)
@@ -3602,7 +3619,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MaximalIS -o maximal-is.json",
       "pred solve maximal-is.json",
-      "pred evaluate maximal-is.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate maximal-is.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3620,7 +3637,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let ne = graph-num-edges(x.instance)
   let edges = x.instance.graph.edges
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let matched-edges = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => edges.at(i))
+  let matched-edges = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => edges.at(i))
   let sz = metric-value(sol.metric)
   [
     #problem-def("MinimumMaximalMatching")[
@@ -3633,7 +3650,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumMaximalMatching -o mmm.json",
       "pred solve mmm.json",
-      "pred evaluate mmm.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate mmm.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3658,8 +3675,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let arcs = x.instance.graph.arcs
   let ne = arcs.len()
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let merged = arcs.enumerate().filter(((i, _)) => sol.config.at(i) == 1).map(((i, arc)) => arc)
-  let dummy = arcs.enumerate().filter(((i, _)) => sol.config.at(i) == 0).map(((i, arc)) => arc)
+  let merged = arcs.enumerate().filter(((i, _)) => sol.config.at(i)).map(((i, arc)) => arc)
+  let dummy = arcs.enumerate().filter(((i, _)) => not sol.config.at(i)).map(((i, arc)) => arc)
   let opt = metric-value(sol.metric)
   let blue = graph-colors.at(0)
   [
@@ -3673,7 +3690,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example " + problem-spec(x) + " -o minimum-dummy-activities-pert.json",
       "pred solve minimum-dummy-activities-pert.json --solver brute-force",
-      "pred evaluate minimum-dummy-activities-pert.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate minimum-dummy-activities-pert.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3705,13 +3722,13 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 }
 
 #{
-  let x = load-model-example("MinimumFeedbackVertexSet")
+  let x = load-model-example("MinimumFeedbackVertexSet", variant: (weight: "i64"))
   let nv = graph-num-vertices(x.instance)
   let ne = x.instance.graph.arcs.len()
   let arcs = x.instance.graph.arcs
   // Pick optimal config = {v0} to match figure
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let S = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let S = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let wS = metric-value(sol.metric)
   [
     #problem-def("MinimumFeedbackVertexSet")[
@@ -3724,7 +3741,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumFeedbackVertexSet -o minimum-feedback-vertex-set.json",
       "pred solve minimum-feedback-vertex-set.json",
-      "pred evaluate minimum-feedback-vertex-set.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate minimum-feedback-vertex-set.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3778,7 +3795,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example PartitionIntoPathsOfLength2 -o partition-paths2.json",
       "pred solve partition-paths2.json",
-      "pred evaluate partition-paths2.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate partition-paths2.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3802,7 +3819,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let sol = (config: x.optimal_config, metric: x.optimal_value)
   let opt-weight = metric-value(sol.metric)
   // Derive tree edges from optimal config
-  let tree-edge-indices = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let tree-edge-indices = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let tree-edges = tree-edge-indices.map(i => edges.at(i))
   // Steiner vertices: non-terminal vertices that appear in tree edges
   let steiner-verts = range(nv).filter(v => not terminals.contains(v) and tree-edges.any(e => e.at(0) == v or e.at(1) == v))
@@ -3817,7 +3834,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example SteinerTreeInGraphs -o steiner-tree-in-graphs.json",
       "pred solve steiner-tree-in-graphs.json",
-      "pred evaluate steiner-tree-in-graphs.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate steiner-tree-in-graphs.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3869,7 +3886,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let opt-cost = metric-value(x.optimal_value)
   // Pick optimal config = {v2, v5} to match figure
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let centers = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let centers = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   [
     #problem-def("MinimumSumMulticenter")[
       Given a graph $G = (V, E)$ with vertex weights $w: V -> ZZ_(>= 0)$, edge lengths $l: E -> ZZ_(>= 0)$, and a positive integer $K <= |V|$, find a set $P subset.eq V$ of $K$ vertices (centers) that minimizes the total weighted distance $sum_(v in V) w(v) dot d(v, P)$, where $d(v, P) = min_(p in P) d(v, p)$ is the shortest-path distance from $v$ to the nearest center in $P$.
@@ -3883,7 +3900,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumSumMulticenter -o minimum-sum-multicenter.json",
       "pred solve minimum-sum-multicenter.json",
-      "pred evaluate minimum-sum-multicenter.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate minimum-sum-multicenter.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3916,7 +3933,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let K = x.instance.k
   let opt = x.optimal_value
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let centers = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let centers = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   [
     #problem-def("MinMaxMulticenter")[
       Given a graph $G = (V, E)$ with vertex weights $w: V -> ZZ_(>= 0)$, edge lengths $l: E -> ZZ_(>= 0)$, and a positive integer $K <= |V|$, find $S subset.eq V$ with $|S| = K$ that minimizes $max_(v in V) w(v) dot d(v, S)$, where $d(v, S) = min_(s in S) d(v, s)$ is the shortest weighted-path distance from $v$ to the nearest vertex in $S$.
@@ -3930,7 +3947,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinMaxMulticenter -o min-max-multicenter.json",
       "pred solve min-max-multicenter.json",
-      "pred evaluate min-max-multicenter.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate min-max-multicenter.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -3963,7 +3980,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let usage = x.instance.usage
   let storage = x.instance.storage
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let copies = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let copies = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let opt = metric-value(sol.metric)
   let s-cost = copies.map(i => storage.at(i)).sum()
   let a-cost = opt - s-cost
@@ -3975,12 +3992,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
     Multiple Copy File Allocation appears in the storage-and-retrieval section of Garey and Johnson (SR6) @garey1979. The model combines two competing costs: each chosen copy vertex incurs a storage charge, while every vertex pays an access cost weighted by its demand and graph distance to the nearest copy. Applications include content distribution networks (placing cache servers), database replication across data centers, and distributed file systems. Garey and Johnson record the problem as NP-hard in the strong sense, even when usage and storage costs are uniform @garey1979. It generalizes Uncapacitated Facility Location when the network topology is arbitrary.
 
-    *Example.* Consider the path $P_#nv$ with usage $u = (#usage.map(str).join(", "))$ and storage costs $s = (#storage.map(str).join(", "))$. The endpoints $v_0, v_5$ have high demand ($u = 5$) but expensive storage ($s = 6$), while $v_1, v_4$ are cheap server locations ($s = 2$). Placing copies at $V' = {#copies.map(i => $v_#i$).join(", ")}$ gives storage cost $#copies.map(i => str(storage.at(i))).join(" + ") = #s-cost$ and access cost $5 dot 1 + 1 dot 0 + 1 dot 1 + 1 dot 1 + 1 dot 0 + 5 dot 1 = #a-cost$, for a total of $#opt$. Adding a copy at $v_0$ would save $5 dot 1 = 5$ in access but cost $6$ in storage — a net loss. This tradeoff between placement cost and proximity drives the problem's NP-hardness.
+    *Example.* Consider the path $P_#nv$ with usage $u = (#fmt-values(usage))$ and storage costs $s = (#fmt-values(storage))$. The endpoints $v_0, v_5$ have high demand ($u = 5$) but expensive storage ($s = 6$), while $v_1, v_4$ are cheap server locations ($s = 2$). Placing copies at $V' = {#copies.map(i => $v_#i$).join(", ")}$ gives storage cost $#copies.map(i => str(storage.at(i))).join(" + ") = #s-cost$ and access cost $5 dot 1 + 1 dot 0 + 1 dot 1 + 1 dot 1 + 1 dot 0 + 5 dot 1 = #a-cost$, for a total of $#opt$. Adding a copy at $v_0$ would save $5 dot 1 = 5$ in access but cost $6$ in storage — a net loss. This tradeoff between placement cost and proximity drives the problem's NP-hardness.
 
     #pred-commands(
       "pred create --example MultipleCopyFileAllocation -o multiple-copy-file-allocation.json",
       "pred solve multiple-copy-file-allocation.json",
-      "pred evaluate multiple-copy-file-allocation.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate multiple-copy-file-allocation.json --config " + cli-config(x.optimal_config),
     )
 
     #figure({
@@ -4022,7 +4039,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let U-size = all-elems.len()
   // Pick optimal config = {S1, S3} (0-indexed: sets 0, 2) to match figure
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let selected = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let selected = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let wP = metric-value(sol.metric)
   // Format a set as {e1+1, e2+1, ...} (1-indexed)
   let fmt-set(s) = "{" + s.map(e => str(e + 1)).join(", ") + "}"
@@ -4037,7 +4054,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example " + problem-spec(x) + " -o maximum-set-packing.json",
       "pred solve maximum-set-packing.json",
-      "pred evaluate maximum-set-packing.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate maximum-set-packing.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -4065,7 +4082,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let m = sets.len()
   let U-size = x.instance.universe_size
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let selected = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let selected = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let wC = metric-value(sol.metric)
   let fmt-set(s) = "{" + s.map(e => str(e + 1)).join(", ") + "}"
   [
@@ -4079,7 +4096,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumSetCovering -o minimum-set-covering.json",
       "pred solve minimum-set-covering.json",
-      "pred evaluate minimum-set-covering.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate minimum-set-covering.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -4110,7 +4127,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let m = sets.len()
   let U-size = x.instance.universe_size
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let selected = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let selected = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let hit-size = metric-value(sol.metric)
   let fmt-set(s) = if s.len() == 0 {
     $emptyset$
@@ -4130,7 +4147,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumHittingSet -o minimum-hitting-set.json",
       "pred solve minimum-hitting-set.json",
-      "pred evaluate minimum-hitting-set.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate minimum-hitting-set.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -4173,8 +4190,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let m = subsets.len()
   let n = x.instance.universe_size
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let part0 = sol.config.enumerate().filter(((i, v)) => v == 0).map(((i, _)) => i)
-  let part1 = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let part0 = sol.config.enumerate().filter(((i, v)) => not v).map(((i, _)) => i)
+  let part1 = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let fmt-set(s) = "{" + s.map(e => str(e + 1)).join(", ") + "}"
   [
     #problem-def("SetSplitting")[
@@ -4187,7 +4204,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example SetSplitting -o set-splitting.json",
       "pred solve set-splitting.json",
-      "pred evaluate set-splitting.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate set-splitting.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -4243,7 +4260,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ConsecutiveSets -o consecutive-sets.json",
         "pred solve consecutive-sets.json",
-        "pred evaluate consecutive-sets.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate consecutive-sets.json --config " + cli-config(x.optimal_config),
       )
 
       // Subset span data: (start_pos, end_pos) in the solution string
@@ -4276,7 +4293,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
             content((x1 + 0.45, y), text(7pt, fill: color, $Sigma_#(si + 1)$))
           }
         }),
-        caption: [Consecutive Sets: the string $w = (#sol.map(str).join(", "))$ with each subset $Sigma_i$ occupying a contiguous block. Colored bars below indicate the span of each subset.]
+        caption: [Consecutive Sets: the string $w = (#fmt-values(sol))$ with each subset $Sigma_i$ occupying a contiguous block. Colored bars below indicate the span of each subset.]
       ) <fig:consecutive-sets>
     ]
   ]
@@ -4292,7 +4309,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   // Format a 0-indexed triple as 1-indexed set notation: {a+1, b+1, c+1}
   let fmt-triple(t) = "{" + t.map(e => str(e + 1)).join(", ") + "}"
   // Collect indices of selected subsets (1-indexed)
-  let selected = sol.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let selected = sol.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
 
   [
     #problem-def("ExactCoverBy3Sets")[
@@ -4305,7 +4322,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example ExactCoverBy3Sets -o exact-cover-by-3-sets.json",
       "pred solve exact-cover-by-3-sets.json",
-      "pred evaluate exact-cover-by-3-sets.json --config " + x3c.optimal_config.map(str).join(","),
+      "pred evaluate exact-cover-by-3-sets.json --config " + cli-config(x3c.optimal_config),
     )
 
     #figure(
@@ -4357,7 +4374,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   // Format a triple as (w+1, x+1, y+1) using 1-indexed notation
   let fmt-triple(t) = $(#(t.at(0) + 1), #(t.at(1) + 1), #(t.at(2) + 1))$
   // Collect indices of selected triples (0-indexed)
-  let selected = sol.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let selected = sol.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
 
   [
     #problem-def("ThreeDimensionalMatching")[
@@ -4370,7 +4387,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example ThreeDimensionalMatching -o three-dimensional-matching.json",
       "pred solve three-dimensional-matching.json",
-      "pred evaluate three-dimensional-matching.json --config " + tdm.optimal_config.map(str).join(","),
+      "pred evaluate three-dimensional-matching.json --config " + cli-config(tdm.optimal_config),
     )
 
     // Tripartite layout: W (left), X (center), Y (right) with triples as hyperedges
@@ -4413,71 +4430,6 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   ]
 }
 
-#{
-  let tmi = load-model-example("ThreeMatroidIntersection")
-  let n = tmi.instance.ground_set_size
-  let parts = tmi.instance.partitions
-  let K = tmi.instance.bound
-  let sol = tmi.optimal_config
-  let selected = sol.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
-  let fmt-set(items) = if items.len() == 0 {
-    $emptyset$
-  } else {
-    "{" + items.map(e => str(e)).join(", ") + "}"
-  }
-  let fmt-group(g) = $#("{" + g.map(e => str(e)).join(", ") + "}")$
-  [
-    #problem-def("ThreeMatroidIntersection")[
-      Given three partition matroids $(E, cal(F)_1)$, $(E, cal(F)_2)$, $(E, cal(F)_3)$ on a common ground set $E$ with $|E| = n$, and a positive integer $K <= n$, does there exist a subset $E' subset.eq E$ with $|E'| = K$ that is independent in all three matroids? A partition matroid partitions $E$ into groups; a set $S$ is independent if $|S inter G| <= 1$ for every group $G$.
-    ][
-    Three-Matroid Intersection is problem SP11 in Garey & Johnson @garey1979 (section A3). While 2-matroid intersection is solvable in polynomial time (Edmonds, 1970) @edmonds1970, the jump to three matroids captures NP-hardness. NP-completeness is established by transformation from Three-Dimensional Matching, where each dimension induces a partition matroid. The restriction to partition matroids suffices for NP-completeness.
-
-    Doron-Arad, Kulik, and Shachnai (2024) @doron2024 showed that brute force essentially cannot be beaten: any algorithm requires $Omega(2^(n - 5 sqrt(n) log n))$ oracle queries. A marginal improvement to $2^(n - Omega(log^2 n))$ exists via Monotone Local Search @fomin2019. The direct brute-force algorithm runs in $O^*(2^n)$ time where $n = |E|$.
-
-    *Example.* Let $E = {0, 1, dots, #(n - 1)}$ with $K = #K$. The three partition matroids have groups: $cal(F)_1$: #parts.at(0).map(fmt-group).join(", "); $cal(F)_2$: #parts.at(1).map(fmt-group).join(", "); $cal(F)_3$: #parts.at(2).map(fmt-group).join(", "). The subset $E' = #fmt-set(selected)$ is a valid common independent set of size $#K$: each matroid has at most one selected element per group.
-
-    #pred-commands(
-      "pred create --example ThreeMatroidIntersection -o three-matroid-intersection.json",
-      "pred solve three-matroid-intersection.json",
-      "pred evaluate three-matroid-intersection.json --config " + tmi.optimal_config.map(str).join(","),
-    )
-
-    // Three rows of partition groups, elements shown in each
-    #figure(
-      canvas(length: 1cm, {
-        import draw: *
-        let matroid-labels = ($cal(F)_1$, $cal(F)_2$, $cal(F)_3$)
-        let row-y = (1.6, 0.0, -1.6)
-        let group-colors = (rgb("#4e79a7"), rgb("#e15759"), rgb("#59a14f"))
-        for (mi, partition) in parts.enumerate() {
-          let y = row-y.at(mi)
-          let total-groups = partition.len()
-          // Label
-          content((-3.2, y), text(9pt, matroid-labels.at(mi)), anchor: "east")
-          // Draw each group as a rounded rectangle with elements inside
-          for (gi, group) in partition.enumerate() {
-            let gx = (gi - (total-groups - 1) / 2) * 2.2
-            let w = group.len() * 0.55 + 0.3
-            rect((gx - w / 2, y - 0.35), (gx + w / 2, y + 0.35),
-              stroke: 0.8pt + group-colors.at(mi), radius: 4pt)
-            // Elements inside the group
-            for (ei, elem) in group.enumerate() {
-              let ex = gx + (ei - (group.len() - 1) / 2) * 0.5
-              let is-sel = selected.contains(elem)
-              circle((ex, y), radius: 0.18,
-                fill: if is-sel { graph-colors.at(0) } else { white },
-                stroke: 0.6pt + black)
-              content((ex, y), text(7pt, fill: if is-sel { white } else { black }, str(elem)))
-            }
-          }
-        }
-      }),
-      caption: [Three-Matroid Intersection: each row shows one partition matroid's groups (rounded boxes). The selected elements $E' = #fmt-set(selected)$ (blue) place at most one element per group in all three matroids.]
-    ) <fig:three-matroid-intersection>
-    ]
-  ]
-}
-
 #{
   let x = load-model-example("ComparativeContainment")
   let n = x.instance.universe_size
@@ -4485,8 +4437,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let S = x.instance.s_sets
   let r-weights = x.instance.r_weights
   let s-weights = x.instance.s_weights
-  let selected = x.optimal_config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
-  let satisfiers = ((config: x.optimal_config, metric: x.optimal_value),).map(sol => sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i))
+  let selected = x.optimal_config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
+  let satisfiers = ((config: x.optimal_config, metric: x.optimal_value),).map(sol => sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i))
   let contains-selected(family-set) = selected.all(i => family-set.contains(i))
   let r-active = range(R.len()).filter(i => contains-selected(R.at(i)))
   let s-active = range(S.len()).filter(i => contains-selected(S.at(i)))
@@ -4511,7 +4463,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example ComparativeContainment -o comparative-containment.json",
       "pred solve comparative-containment.json",
-      "pred evaluate comparative-containment.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate comparative-containment.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -4580,7 +4532,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let k = x.instance.k
   let sat-count = 1
   let basis = range(k).map(i =>
-    range(U-size).filter(j => x.optimal_config.at(i * U-size + j) == 1)
+    range(U-size).filter(j => x.optimal_config.at(i).at(j))
   )
   let fmt-set(s) = "{" + s.map(e => str(e + 1)).join(", ") + "}"
   [
@@ -4594,7 +4546,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example SetBasis -o set-basis.json",
       "pred solve set-basis.json",
-      "pred evaluate set-basis.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate set-basis.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -4636,7 +4588,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let n = x.instance.num_attributes
   let deps = x.instance.dependencies
   let q = x.instance.query_attribute
-  let key = x.optimal_config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let key = x.optimal_config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let num-sat = 2  // candidate keys containing query attribute: {2,3} and {0,3}
   // Format a set as {e0, e1, ...} (0-indexed); no `$` — embed inside `$...$` or use `fmt-set-math` alias.
   let fmt-set(s) = "{" + s.map(e => str(e)).join(", ") + "}"
@@ -4662,7 +4614,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example PrimeAttributeName -o prime-attribute-name.json",
       "pred solve prime-attribute-name.json",
-      "pred evaluate prime-attribute-name.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate prime-attribute-name.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -4719,7 +4671,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let n = x.instance.num_attributes
   let deps = x.instance.dependencies
   let m = deps.len()
-  let key-attrs = range(n).filter(i => x.optimal_config.at(i) == 1)
+  let key-attrs = range(n).filter(i => x.optimal_config.at(i))
   let fmt-set(s) = "{" + s.map(e => str(e)).join(", ") + "}"
   let fmt-fd(d) = $#fmt-set(d.at(0)) arrow #fmt-set(d.at(1))$
   [
@@ -4734,7 +4686,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumCardinalityKey -o minimum-cardinality-key.json",
       "pred solve minimum-cardinality-key.json",
-      "pred evaluate minimum-cardinality-key.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate minimum-cardinality-key.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -4798,12 +4750,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
     Rooted Tree Storage Assignment is the storage-and-retrieval problem SR5 in Garey and Johnson @garey1979. Their catalog credits a reduction from Rooted Tree Arrangement, framing the problem as hierarchical file organization: pick a rooted tree on the records so every request set can be completed to a single root-to-leaf path using only a limited number of extra records. The implementation here uses one parent variable per element of $X$, so the direct exhaustive bound is $|X|^(|X|)$ candidate parent arrays, filtered down to valid rooted trees#footnote[No exact algorithm improving on the direct parent-array search bound is claimed here for the general formulation.].
 
-    *Example.* Let $X = {0, 1, dots, #(n - 1)}$, $K = #K$, and $cal(C) = {#range(m).map(i => $X_#(i + 1)$).join(", ")}$ with #subsets.enumerate().map(((i, s)) => $X_#(i + 1) = #fmt-set(s)$).join(", "). The satisfying parent array $p = (#config.map(str).join(", "))$ encodes the rooted tree with arcs #edges.map(((u, v)) => $(#u, #v)$).join(", "). In this tree, $X_1 = {0, 2}$, $X_2 = {1, 3}$, and $X_4 = {2, 4}$ are already directed paths. The only extension is $X_3 = {0, 4}$, which becomes $X_3' = {0, 2, 4}$ along the path $0 -> 2 -> 4$, so the total extension cost is exactly $1 = K$.
+    *Example.* Let $X = {0, 1, dots, #(n - 1)}$, $K = #K$, and $cal(C) = {#range(m).map(i => $X_#(i + 1)$).join(", ")}$ with #subsets.enumerate().map(((i, s)) => $X_#(i + 1) = #fmt-set(s)$).join(", "). The satisfying parent array $p = (#fmt-values(config))$ encodes the rooted tree with arcs #edges.map(((u, v)) => $(#u, #v)$).join(", "). In this tree, $X_1 = {0, 2}$, $X_2 = {1, 3}$, and $X_4 = {2, 4}$ are already directed paths. The only extension is $X_3 = {0, 4}$, which becomes $X_3' = {0, 2, 4}$ along the path $0 -> 2 -> 4$, so the total extension cost is exactly $1 = K$.
 
     #pred-commands(
       "pred create --example " + problem-spec(x) + " -o rooted-tree-storage-assignment.json",
       "pred solve rooted-tree-storage-assignment.json --solver brute-force",
-      "pred evaluate rooted-tree-storage-assignment.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate rooted-tree-storage-assignment.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -4839,7 +4791,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
           content(pos, if highlighted { text(fill: white)[$#vertex$] } else { [$#vertex$] })
         }
       }),
-      caption: [Rooted Tree Storage Assignment example. The rooted tree encoded by $p = (#config.map(str).join(", "))$ is shown; the blue path $0 -> 2 -> 4$ is the unique extension needed to realize $X_3 = {0, 4}$ within total cost $K = #K$.],
+      caption: [Rooted Tree Storage Assignment example. The rooted tree encoded by $p = (#fmt-values(config))$ is shown; the blue path $0 -> 2 -> 4$ is the unique extension needed to realize $X_3 = {0, 4}$ within total cost $K = #K$.],
     ) <fig:rooted-tree-storage-assignment>
     ]
   ]
@@ -4869,7 +4821,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example TwoDimensionalConsecutiveSets -o two-dimensional-consecutive-sets.json",
       "pred solve two-dimensional-consecutive-sets.json",
-      "pred evaluate two-dimensional-consecutive-sets.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate two-dimensional-consecutive-sets.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -4950,10 +4902,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let n = spin-num-spins(x.instance)
   let edges = x.instance.graph.edges
   let ne = edges.len()
-  // Pick optimal config = (+,-,+,+,-) to match figure
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  // Convert config (0=+1, 1=-1) to spin values
-  let spins = sol.config.map(v => if v == 0 { 1 } else { -1 })
+  let spins = sol.config
   let H = metric-value(sol.metric)
   let spin-str = spins.map(s => if s > 0 { "+" } else { "-" }).join(", ")
   // Count satisfied and frustrated edges
@@ -4970,7 +4920,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example SpinGlass -o spinglass.json",
       "pred solve spinglass.json",
-      "pred evaluate spinglass.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate spinglass.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -5008,27 +4958,27 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     if v == vi { str(vi) } else { str(v) }
   }).join(", ")).join("; ")
   // Collect indices where x*_i = 1 (1-indexed)
-  let selected = xstar.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => $x_#(i + 1)$)
+  let selected = xstar.enumerate().filter(((i, v)) => v).map(((i, _)) => $x_#(i + 1)$)
   let unselected-pairs = ()
   for i in range(n) {
     for j in range(i + 1, n) {
-      if Q.at(i).at(j) != 0 and (xstar.at(i) == 0 or xstar.at(j) == 0) {
+      if Q.at(i).at(j) != 0 and (not xstar.at(i) or not xstar.at(j)) {
         unselected-pairs.push($#(int(Q.at(i).at(j))) x_#(i + 1) x_#(j + 1)$)
       }
     }
   }
   [
     #problem-def("QUBO")[
-      Given $n$ binary variables $x_i in {0, 1}$, upper-triangular matrix $Q in RR^(n times n)$, minimize $f(bold(x)) = sum_(i=1)^n Q_(i i) x_i + sum_(i < j) Q_(i j) x_i x_j$ (using $x_i^2 = x_i$ for binary variables).
+      Given $n$ binary variables $x_i in {0, 1}$ and an upper-triangular matrix $Q$, minimize $f(bold(x)) = sum_(i=1)^n Q_(i i) x_i + sum_(i < j) Q_(i j) x_i x_j$ (using $x_i^2 = x_i$ for binary variables). The registered variants use either exact integer coefficients $Q in ZZ^(n times n)$ (the default) or finite floating-point coefficients $Q in RR^(n times n)$.
     ][
-    Equivalent to the Ising model via the linear substitution $s_i = 2x_i - 1$. The native formulation for quantum annealing hardware (e.g., D-Wave) and a standard target for penalty-method reductions @glover2019. QUBO unifies many combinatorial problems into a single unconstrained binary framework, making it a universal intermediate representation for quantum and classical optimization. The best known general algorithm runs in $O^*(2^n)$ by brute-force enumeration#footnote[QUBO inherits the Ising model's complexity; no algorithm improving on brute-force is known for the general case.].
+    Equivalent to the Ising model via the linear substitution $s_i = 2x_i - 1$. The native formulation for quantum annealing hardware (e.g., D-Wave) and a standard target for penalty-method reductions @glover2019. QUBO unifies many combinatorial problems into a single unconstrained binary framework, making it a universal intermediate representation for quantum and classical optimization. The integer variant stores exact coefficients, the floating-point variant stores finite real coefficients, and their explicit reduction converts exactly representable integers through `i64_to_exact_f64`. The best known general algorithm runs in $O^*(2^n)$ by brute-force enumeration#footnote[QUBO inherits the Ising model's complexity; no algorithm improving on brute-force is known for the general case.].
 
-    *Example.* Consider $n = #n$ with $Q = mat(#mat-rows)$. The objective is $f(bold(x)) = -x_1 - x_2 - x_3 + 2x_1 x_2 + 2x_2 x_3$. Evaluating all $2^#n$ assignments: $f(0,0,0) = 0$, $f(1,0,0) = -1$, $f(0,1,0) = -1$, $f(0,0,1) = -1$, $f(1,1,0) = 0$, $f(0,1,1) = 0$, $f(1,0,1) = -2$, $f(1,1,1) = 1$. The minimum is $f^* = #fstar$ at $bold(x)^* = (#xstar.map(v => str(v)).join(", "))$: selecting #selected.join(" and ") avoids the penalty terms #unselected-pairs.join(" and ").
+    *Example.* Consider $n = #n$ with $Q = mat(#mat-rows)$. The objective is $f(bold(x)) = -x_1 - x_2 - x_3 + 2x_1 x_2 + 2x_2 x_3$. Evaluating all $2^#n$ assignments: $f(0,0,0) = 0$, $f(1,0,0) = -1$, $f(0,1,0) = -1$, $f(0,0,1) = -1$, $f(1,1,0) = 0$, $f(0,1,1) = 0$, $f(1,0,1) = -2$, $f(1,1,1) = 1$. The minimum is $f^* = #fstar$ at $bold(x)^* = (#fmt-values(xstar))$: selecting #selected.join(" and ") avoids the penalty terms #unselected-pairs.join(" and ").
 
     #pred-commands(
       "pred create --example QUBO -o qubo.json",
       "pred solve qubo.json",
-      "pred evaluate qubo.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate qubo.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -5036,7 +4986,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
 #{
   let x = load-model-example("ILP")
-  let nv = x.instance.num_vars
+  let nv = x.instance.variables.len()
   let obj = x.instance.objective
   let constraints = x.instance.constraints
   let sol = (config: x.optimal_config, metric: x.optimal_value)
@@ -5074,7 +5024,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example " + problem-spec(x) + " -o ilp.json",
       "pred solve ilp.json",
-      "pred evaluate ilp.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate ilp.json --config " + cli-config(x.optimal_config),
     )
 
 #figure(
@@ -5178,7 +5128,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example QuadraticAssignment -o quadratic-assignment.json",
       "pred solve quadratic-assignment.json",
-      "pred evaluate quadratic-assignment.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate quadratic-assignment.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -5246,12 +5196,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
       *Example.* Consider $n = #n$ variables and #(eqs.len()) equations over $"GF"(2)$:
       $ #eqs.enumerate().map(((i, eq)) => $p_#(i+1): #render-eq(eq)$).join($, quad$) $
-      The assignment $(x_0, x_1, x_2) = (#(config.map(str).join(", ")))$ satisfies all equations:
+      The assignment $(x_0, x_1, x_2) = (#fmt-values(config))$ satisfies all equations:
       #eqs.enumerate().map(((i, eq)) => {
         // Evaluate each monomial under the assignment
         let vals = eq.map(mono => {
           if mono.len() == 0 { 1 }
-          else { mono.fold(1, (acc, j) => acc * config.at(j)) }
+          else { mono.fold(1, (acc, j) => acc * bool-bit(config.at(j))) }
         })
         let xor-sum = vals.fold(0, (acc, v) => calc.rem(acc + v, 2))
         let lhs = eq.zip(vals).map(((mono, v)) => {
@@ -5265,7 +5215,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example AlgebraicEquationsOverGF2 -o agf2.json",
         "pred solve agf2.json --solver brute-force",
-        "pred evaluate agf2.json --config " + config.map(str).join(","),
+        "pred evaluate agf2.json --config " + cli-config(config),
       )
     ]
   ]
@@ -5296,7 +5246,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example QuadraticCongruences -o qc.json",
         "pred solve qc.json --solver brute-force",
-        "pred evaluate qc.json --config " + config.map(str).join(","),
+        "pred evaluate qc.json --config " + cli-config(config),
       )
 
       #align(center, table(
@@ -5343,7 +5293,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example QuadraticDiophantineEquations -o qde.json",
         "pred solve qde.json --solver brute-force",
-        "pred evaluate qde.json --config " + config.map(str).join(","),
+        "pred evaluate qde.json --config " + cli-config(config),
       )
 
       #align(center, table(
@@ -5367,7 +5317,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let x = load-model-example("SimultaneousIncongruences")
   let pairs = x.instance.pairs
   let config = x.optimal_config
-  let xval = config.at(0)
+  let xval = config
   // Build table rows: for each pair (a, b), compute x mod b and check ≠ a mod b
   let rows = pairs.map(pair => {
     let a = pair.at(0)
@@ -5396,12 +5346,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Simultaneous Incongruences is an NP-complete problem @garey1979. It asks whether the complement of a system of congruences — a _covering system_ — can be simultaneously avoided. A _covering system_ is a finite collection of congruences $\{a_i space (op("mod") space b_i)\}$ that covers every integer; when the system is a covering system there is no valid $x$ and the instance is a "no" instance. The problem generalises checking whether a given set of congruences is a covering system, which has connections to Erdős's covering conjecture and sieve methods in analytic number theory.
 
-      *Example.* Let $n = #pairs.len()$ with pairs #pairs.map(p => $(#p.at(0), #p.at(1))$).join(", "). The full period is $L = op("lcm")(#moduli.map(str).join(", ")) = #lcm-val$. We test $x = #xval$:
+      *Example.* Let $n = #pairs.len()$ with pairs #pairs.map(p => $(#p.at(0), #p.at(1))$).join(", "). The full period is $L = op("lcm")(#fmt-values(moduli)) = #lcm-val$. We test $x = #xval$:
 
       #pred-commands(
         "pred create --example SimultaneousIncongruences -o si.json",
         "pred solve si.json --solver brute-force",
-        "pred evaluate si.json --config " + config.map(str).join(","),
+        "pred evaluate si.json --config " + cli-config(config),
       )
 
       #align(center, table(
@@ -5470,12 +5420,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
         F_2 = #fmt-payoff(polynomials.at(1)), quad
         F_3 = #fmt-payoff(polynomials.at(2)) $
 
-      The assignment $bold(y) = (#assignment.map(str).join(", "))$ is a Nash equilibrium: #range(n).map(i => {let v = eval-payoff(i); let ii = i + 1; $F_#ii (bold(y)) = #v$}).join(", "), and no player can strictly improve their payoff by deviating.
+      The assignment $bold(y) = (#fmt-values(assignment))$ is a Nash equilibrium: #range(n).map(i => {let v = eval-payoff(i); let ii = i + 1; $F_#ii (bold(y)) = #v$}).join(", "), and no player can strictly improve their payoff by deviating.
 
       #pred-commands(
         "pred create --example EquilibriumPoint -o ep.json",
         "pred solve ep.json --solver brute-force",
-        "pred evaluate ep.json --config " + config.map(str).join(","),
+        "pred evaluate ep.json --config " + cli-config(config),
       )
     ]
   ]
@@ -5485,11 +5435,9 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let x = load-model-example("ClosestVectorProblem")
   let basis = x.instance.basis
   let target = x.instance.target
-  let bounds = x.instance.bounds
   let sol = (config: x.optimal_config, metric: x.optimal_value)
   let dist = metric-value(sol.metric)
-  // Config encodes offset from lower bound; recover actual integer coordinates
-  let coords = sol.config.enumerate().map(((i, v)) => v + bounds.at(i).lower)
+  let coords = sol.config
   // Compute B*x: sum over j of coords[j] * basis[j]
   let dim = basis.at(0).len()
   let bx = range(dim).map(d => coords.enumerate().fold(0.0, (acc, (j, c)) => acc + c * basis.at(j).at(d)))
@@ -5498,16 +5446,16 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let dist-rounded = calc.round(dist, digits: 3)
   [
     #problem-def("ClosestVectorProblem")[
-      Given a lattice basis $bold(B) in RR^(m times n)$ (columns $bold(b)_1, dots, bold(b)_n in RR^m$ spanning lattice $cal(L)(bold(B)) = {bold(B) bold(x) : bold(x) in ZZ^n}$) and target $bold(t) in RR^m$, find $bold(x) in ZZ^n$ minimizing $norm(bold(B) bold(x) - bold(t))_2$.
+      Given a full-column-rank integer lattice basis $bold(B) in ZZ^(m times n)$, whose columns span $cal(L)(bold(B)) = {bold(B) bold(x) : bold(x) in ZZ^n}$, and target $bold(t) in RR^m$, find $bold(x) in ZZ^n$ minimizing $norm(bold(B) bold(x) - bold(t))_2$.
     ][
-      The Closest Vector Problem is a fundamental lattice problem, proven NP-hard by van Emde Boas @vanemde1981. CVP appears in lattice-based cryptography, coding theory, and integer programming @lenstra1983. Kannan's enumeration algorithm @kannan1987 solves CVP in $n^(O(n))$ time; Micciancio and Voulgaris @micciancio2010 improved this to deterministic $O^*(4^n)$ using Voronoi cell computations, and Aggarwal, Dadush, and Stephens-Davidowitz @aggarwal2015 achieved randomized $O^*(2^n)$.
+      The Closest Vector Problem is a fundamental lattice problem @micciancio2002 and is NP-hard @vanemde1981. The implementation provides an integer-target variant for exact reduction data and a finite-`f64` target variant for real input; both keep the lattice basis integral and place no bounds on $bold(x)$. Its reference solver uses exact rational Gram--Schmidt projections and sphere-enumeration bounds following the recursive enumeration structure of Fincke and Pohst @fincke1985. Finite `f64` targets are interpreted as their exact binary rational values. The solver is intended for small instances. Kannan's enumeration algorithm @kannan1987 solves CVP in $n^(O(n))$ time; Micciancio and Voulgaris @micciancio2010 improved this to deterministic $O^*(4^n)$, and Aggarwal, Dadush, and Stephens-Davidowitz @aggarwal2015 achieved randomized $O^*(2^n)$.
 
-      *Example.* Consider the 2D lattice with basis #range(basis.len()).map(j => $bold(b)_#(j + 1) = #fmt-vec(basis.at(j))$).join(", ") and target $bold(t) = #fmt-vec(target)$. The lattice points near $bold(t)$ include $bold(B)(1, 0)^top = (2, 0)^top$, $bold(B)(0, 1)^top = (1, 2)^top$, and $bold(B)(#coords.map(c => str(c)).join(","))^top = (#bx.map(v => str(int(v))).join(", "))^top$. The closest is $bold(B)(#coords.map(c => str(c)).join(","))^top = (#bx.map(v => str(int(v))).join(", "))^top$ with distance $norm(bold(B)(#coords.map(c => str(c)).join(","))^top - bold(t))_2 approx #dist-rounded$.
+      *Example.* Consider the 2D lattice with basis #range(basis.len()).map(j => $bold(b)_#(j + 1) = #fmt-vec(basis.at(j))$).join(", ") and target $bold(t) = #fmt-vec(target)$. The point $bold(B)(#coords.map(c => str(c)).join(","))^top = (#bx.map(v => str(int(v))).join(", "))^top$ equals the target, so it is a closest lattice point with distance #dist-rounded.
 
       #pred-commands(
         "pred create --example ClosestVectorProblem -o closest-vector-problem.json",
         "pred solve closest-vector-problem.json",
-        "pred evaluate closest-vector-problem.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate closest-vector-problem.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -5556,20 +5504,20 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let fmt-lit(l) = if l > 0 { $x_#l$ } else { $not x_#(-l)$ }
   // Format a clause as (l1 or l2 or ...)
   let fmt-clause(c) = $paren.l #c.literals.map(fmt-lit).join($or$) paren.r$
-  // Evaluate a literal under assignment: positive l -> assign[l-1], negative l -> 1-assign[|l|-1]
-  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { 1 - assign.at(-l - 1) }
+  // Evaluate a literal under the Boolean assignment.
+  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { not assign.at(-l - 1) }
   [
     #problem-def("Satisfiability")[
       Given a CNF formula $phi = and.big_(j=1)^m C_j$ with $m$ clauses over $n$ Boolean variables, where each clause $C_j = or.big_i ell_(j i)$ is a disjunction of literals, find an assignment $bold(x) in {0, 1}^n$ such that $phi(bold(x)) = 1$ (all clauses satisfied).
     ][
     The Boolean Satisfiability Problem (SAT) is the first problem proven NP-complete @cook1971. SAT serves as the foundation of NP-completeness theory: showing a new problem NP-hard typically proceeds by reduction from SAT or one of its variants. Despite worst-case hardness, conflict-driven clause learning (CDCL) solvers handle industrial instances with millions of variables. The Strong Exponential Time Hypothesis (SETH) @impagliazzo2001 conjectures that no $O^*((2-epsilon)^n)$ algorithm exists for general CNF-SAT, and the best known algorithm runs in $O^*(2^n)$ by brute-force enumeration#footnote[SETH conjectures this is optimal; no $O^*((2-epsilon)^n)$ algorithm is known.].
 
-    *Example.* Consider $phi = #clauses.map(fmt-clause).join($and$)$ with $n = #n$ variables and $m = #m$ clauses. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",") ) = (#assign.map(v => str(v)).join(", "))$ satisfies all clauses: #clauses.enumerate().map(((j, c)) => $C_#(j + 1) = paren.l #c.literals.map(l => str(eval-lit(l))).join($or$) paren.r = 1$).join(", "). Hence $phi(#assign.map(v => str(v)).join(", ")) = 1$.
+    *Example.* Consider $phi = #clauses.map(fmt-clause).join($and$)$ with $n = #n$ variables and $m = #m$ clauses. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",") ) = (#fmt-values(assign))$ satisfies all clauses: #clauses.enumerate().map(((j, c)) => $C_#(j + 1) = paren.l #c.literals.map(l => str(bool-bit(eval-lit(l)))).join($or$) paren.r = 1$).join(", "). Hence $phi(#fmt-values(assign)) = 1$.
 
     #pred-commands(
       "pred create --example SAT -o sat.json",
       "pred solve sat.json",
-      "pred evaluate sat.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate sat.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -5582,23 +5530,23 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let clauses = x.instance.clauses
   let sol = (config: x.optimal_config, metric: x.optimal_value)
   let assign = sol.config
-  let complement = assign.map(v => 1 - v)
+  let complement = assign.map(v => not v)
   let fmt-lit(l) = if l > 0 { $x_#l$ } else { $not x_#(-l)$ }
   let fmt-clause(c) = $paren.l #c.literals.map(fmt-lit).join($or$) paren.r$
-  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { 1 - assign.at(-l - 1) }
-  let clause-values(c) = c.literals.map(l => str(eval-lit(l)))
+  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { not assign.at(-l - 1) }
+  let clause-values(c) = c.literals.map(l => str(bool-bit(eval-lit(l))))
   [
     #problem-def("NAESatisfiability")[
       Given a CNF formula $phi = and.big_(j=1)^m C_j$ with $m$ clauses over $n$ Boolean variables, where each clause $C_j = or.big_i ell_(j i)$ is a disjunction of literals, find an assignment $bold(x) in {0, 1}^n$ such that every clause contains at least one true literal and at least one false literal.
     ][
     Not-All-Equal Satisfiability (NAE-SAT) is a canonical variant in Schaefer's dichotomy theorem @schaefer1978. Unlike ordinary SAT, each clause forbids the all-true and all-false patterns, giving the problem a complement symmetry: if an assignment is NAE-satisfying, then flipping every bit is also NAE-satisfying. This makes NAE-SAT a natural intermediate for cut and partition reductions such as Max-Cut. A straightforward exact algorithm enumerates all $2^n$ assignments; complement symmetry can halve the search space in practice by fixing one variable, but the asymptotic worst-case bound remains $O^*(2^n)$.
 
-    *Example.* Consider $phi = #clauses.map(fmt-clause).join($and$)$ with $n = #n$ variables and $m = #m$ clauses. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#assign.map(v => str(v)).join(", "))$ is NAE-satisfying because each clause evaluates to a tuple containing both $0$ and $1$: #clauses.enumerate().map(((j, c)) => $C_#(j + 1) = paren.l #clause-values(c).join(", ") paren.r$).join(", "). The complementary assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#complement.map(v => str(v)).join(", "))$ is therefore also NAE-satisfying, illustrating the paired-solution structure characteristic of NAE-SAT.
+    *Example.* Consider $phi = #clauses.map(fmt-clause).join($and$)$ with $n = #n$ variables and $m = #m$ clauses. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#fmt-values(assign))$ is NAE-satisfying because each clause evaluates to a tuple containing both $0$ and $1$: #clauses.enumerate().map(((j, c)) => $C_#(j + 1) = paren.l #clause-values(c).join(", ") paren.r$).join(", "). The complementary assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#fmt-values(complement))$ is therefore also NAE-satisfying, illustrating the paired-solution structure characteristic of NAE-SAT.
 
     #pred-commands(
       "pred create --example NAESatisfiability -o nae-satisfiability.json",
       "pred solve nae-satisfiability.json",
-      "pred evaluate nae-satisfiability.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate nae-satisfiability.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -5615,19 +5563,19 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let assign = sol.config
   let fmt-lit(l) = if l > 0 { $x_#l$ } else { $not x_#(-l)$ }
   let fmt-clause(c) = $paren.l #c.literals.map(fmt-lit).join($or$) paren.r$
-  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { 1 - assign.at(-l - 1) }
+  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { not assign.at(-l - 1) }
   [
     #problem-def("KSatisfiability")[
       SAT with exactly $k$ literals per clause.
     ][
     The restriction of SAT to exactly $k$ literals per clause reveals a sharp complexity transition: 2-SAT is polynomial-time solvable via implication graph SCC decomposition @aspvall1979 in $O(n+m)$, while $k$-SAT for $k >= 3$ is NP-complete. Random $k$-SAT exhibits a satisfiability threshold at clause density $m slash n approx 2^k ln 2$, a key phenomenon in computational phase transitions. The best known algorithm for 3-SAT runs in $O^*(1.307^n)$ via biased-PPSZ @hansen2019. Under SETH, $k$-SAT requires time $O^*(c_k^n)$ with $c_k -> 2$ as $k -> infinity$.
 
-    *Example.* Consider the #{k}-SAT formula $phi = #clauses.map(fmt-clause).join($and$)$ with $n = #n$ variables and $m = #m$ clauses, each containing exactly #k literals. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#assign.map(v => str(v)).join(", "))$ satisfies all clauses: #clauses.enumerate().map(((j, c)) => $C_#(j + 1) = paren.l #c.literals.map(l => str(eval-lit(l))).join($or$) paren.r = 1$).join(", ").
+    *Example.* Consider the #{k}-SAT formula $phi = #clauses.map(fmt-clause).join($and$)$ with $n = #n$ variables and $m = #m$ clauses, each containing exactly #k literals. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#fmt-values(assign))$ satisfies all clauses: #clauses.enumerate().map(((j, c)) => $C_#(j + 1) = paren.l #c.literals.map(l => str(bool-bit(eval-lit(l)))).join($or$) paren.r = 1$).join(", ").
 
     #pred-commands(
       "pred create --example " + problem-spec(x) + " -o ksat.json",
       "pred solve ksat.json",
-      "pred evaluate ksat.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -5642,19 +5590,19 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let assign = sol.config
   let fmt-lit(l) = if l > 0 { $x_#l$ } else { $not x_#(-l)$ }
   let fmt-clause(c) = $paren.l #c.literals.map(fmt-lit).join($or$) paren.r$
-  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { 1 - assign.at(-l - 1) }
+  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { not assign.at(-l - 1) }
   [
     #problem-def("Planar3Satisfiability")[
       Given a 3-CNF formula $phi = and.big_(j=1)^m C_j$ with $m$ clauses over $n$ Boolean variables, where each clause $C_j$ contains exactly 3 literals, and the variable-clause incidence graph $H(phi)$ is planar, find a satisfying assignment $bold(x) in {0, 1}^n$.
     ][
     Planar 3-SAT is a restricted variant of 3-SAT introduced by Lichtenstein @lichtenstein1982, who proved it NP-complete. The incidence graph $H(phi)$ is bipartite with variable nodes and clause nodes, connected by edges when a variable appears in a clause. Requiring $H(phi)$ to be planar is a strong structural constraint that enables reductions to geometric and planar problems (e.g., rectilinear Steiner tree, planar vertex cover). The best known algorithm shares the 3-SAT bound of $O^*(1.307^n)$ via biased-PPSZ @hansen2019, since any Planar 3-SAT instance is also a valid 3-SAT instance.
 
-    *Example.* Consider $phi = #clauses.map(fmt-clause).join($and$)$ with $n = #n$ variables and $m = #m$ clauses. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#assign.map(v => str(v)).join(", "))$ satisfies all clauses: #clauses.enumerate().map(((j, c)) => $C_#(j + 1) = paren.l #c.literals.map(l => str(eval-lit(l))).join($or$) paren.r = 1$).join(", ").
+    *Example.* Consider $phi = #clauses.map(fmt-clause).join($and$)$ with $n = #n$ variables and $m = #m$ clauses. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#fmt-values(assign))$ satisfies all clauses: #clauses.enumerate().map(((j, c)) => $C_#(j + 1) = paren.l #c.literals.map(l => str(bool-bit(eval-lit(l)))).join($or$) paren.r = 1$).join(", ").
 
     #pred-commands(
       "pred create --example Planar3Satisfiability -o planar3sat.json",
       "pred solve planar3sat.json",
-      "pred evaluate planar3sat.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate planar3sat.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -5669,20 +5617,20 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let assign = sol.config
   let fmt-lit(l) = if l > 0 { $x_#l$ } else { $not x_#(-l)$ }
   let fmt-clause(c) = $paren.l #c.literals.map(fmt-lit).join($or$) paren.r$
-  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { 1 - assign.at(-l - 1) }
-  let count-true(c) = c.literals.map(eval-lit).sum()
+  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { not assign.at(-l - 1) }
+  let count-true(c) = c.literals.map(l => bool-bit(eval-lit(l))).sum()
   [
     #problem-def("OneInThreeSatisfiability")[
       Given a CNF formula $phi = and.big_(j=1)^m C_j$ with $m$ clauses over $n$ Boolean variables, where each clause $C_j$ contains exactly 3 literals, find a truth assignment $bold(x) in {0, 1}^n$ such that each clause has _exactly one_ true literal.
     ][
     One-in-Three Satisfiability (1-in-3 SAT) was introduced by Schaefer @schaefer1978 as part of his dichotomy theorem for generalized satisfiability. Unlike standard 3-SAT which requires at least one true literal per clause, 1-in-3 SAT requires exactly one. The problem is NP-complete even for monotone instances (no negations). The best known algorithm runs in $O^*(1.307^n)$ time via biased-PPSZ @hansen2019, since every 1-in-3 SAT instance reduces trivially to 3-SAT.
 
-    *Example.* Consider $phi = #clauses.map(fmt-clause).join($and$)$ with $n = #n$ variables and $m = #m$ clauses. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#assign.map(v => str(v)).join(", "))$ satisfies the 1-in-3 condition: #clauses.enumerate().map(((j, c)) => $C_#(j + 1)$+ " has " + str(count-true(c)) + " true literal").join(", ").
+    *Example.* Consider $phi = #clauses.map(fmt-clause).join($and$)$ with $n = #n$ variables and $m = #m$ clauses. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#fmt-values(assign))$ satisfies the 1-in-3 condition: #clauses.enumerate().map(((j, c)) => $C_#(j + 1)$+ " has " + str(count-true(c)) + " true literal").join(", ").
 
     #pred-commands(
       "pred create --example OneInThreeSatisfiability -o 1in3sat.json",
       "pred solve 1in3sat.json",
-      "pred evaluate 1in3sat.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate 1in3sat.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -5697,8 +5645,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let assign = sol.config
   let fmt-lit(l) = if l > 0 { $x_#l$ } else { $not x_#(-l)$ }
   let fmt-clause(c) = $paren.l #c.literals.map(fmt-lit).join($or$) paren.r$
-  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { 1 - assign.at(-l - 1) }
-  let clause-sat(c) = c.literals.map(eval-lit).any(v => v == 1)
+  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { not assign.at(-l - 1) }
+  let clause-sat(c) = c.literals.map(eval-lit).any(v => v)
   let sat-count = clauses.filter(clause-sat).len()
   [
     #problem-def("Maximum2Satisfiability")[
@@ -5706,12 +5654,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
     Maximum 2-Satisfiability (MAX-2-SAT) is one of the fundamental NP-hard optimization problems. While the decision version of 2-SAT is solvable in linear time by implication-graph analysis, the optimization variant---maximizing the number of satisfied clauses---is NP-hard @garey1979. The best known exact algorithm by Williams @williams2005 runs in $O^*(2^(0.7905n))$ time by reducing to a maximum-weight triangle problem and applying fast matrix multiplication.
 
-    *Example.* Consider $m = #m$ clauses over $n = #n$ variables: $#clauses.map(fmt-clause).join($and$)$. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#assign.map(v => str(v)).join(", "))$ satisfies #sat-count out of #m clauses.
+    *Example.* Consider $m = #m$ clauses over $n = #n$ variables: $#clauses.map(fmt-clause).join($and$)$. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#fmt-values(assign))$ satisfies #sat-count out of #m clauses.
 
     #pred-commands(
       "pred create --example Maximum2Satisfiability -o max2sat.json",
       "pred solve max2sat.json",
-      "pred evaluate max2sat.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate max2sat.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -5725,20 +5673,20 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let assign = sol.config
   let fmt-lit(l) = if l > 0 { $x_#l$ } else { $not x_#(-l)$ }
   let fmt-disjunct(d) = $paren.l #d.map(fmt-lit).join($and$) paren.r$
-  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { 1 - assign.at(-l - 1) }
-  let disjunct-true(d) = d.map(eval-lit).all(v => v == 1)
+  let eval-lit(l) = if l > 0 { assign.at(l - 1) } else { not assign.at(-l - 1) }
+  let disjunct-true(d) = d.map(eval-lit).all(v => v)
   [
     #problem-def("NonTautology")[
       Given a Boolean formula in DNF $phi = or.big_(j=1)^m D_j$ with $m$ disjuncts over $n$ Boolean variables, where each disjunct $D_j$ is a conjunction of literals, find a truth assignment $bold(x) in {0, 1}^n$ such that $phi(bold(x)) = 0$ (i.e., every disjunct is false).
     ][
     The Non-Tautology problem asks whether a given DNF formula is _not_ a tautology, by finding a falsifying assignment. A disjunct $D_j = ell_1 and dots and ell_k$ is false when at least one of its literals evaluates to false; the formula is false when all disjuncts are false. The problem is coNP-complete in general and closely related to SAT through De Morgan duality: a DNF formula $phi$ is a tautology iff $not phi$ (a CNF formula) is unsatisfiable.
 
-    *Example.* Consider $phi = #disjuncts.map(fmt-disjunct).join($or$)$ with $n = #n$ variables and $m = #m$ disjuncts. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#assign.map(v => str(v)).join(", "))$ falsifies the formula: #disjuncts.enumerate().map(((j, d)) => $D_#(j + 1)$+ " is " + if disjunct-true(d) { "true" } else { "false" }).join(", ").
+    *Example.* Consider $phi = #disjuncts.map(fmt-disjunct).join($or$)$ with $n = #n$ variables and $m = #m$ disjuncts. The assignment $(#range(n).map(i => $x_#(i + 1)$).join(",")) = (#fmt-values(assign))$ falsifies the formula: #disjuncts.enumerate().map(((j, d)) => $D_#(j + 1)$+ " is " + if disjunct-true(d) { "true" } else { "false" }).join(", ").
 
     #pred-commands(
       "pred create --example NonTautology -o nontaut.json",
       "pred solve nontaut.json",
-      "pred evaluate nontaut.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate nontaut.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -5814,7 +5762,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     }
     // Build initial env from satisfying assignment
     #let init-env = inputs.enumerate().fold((:), (env, pair) => {
-      let (i, v) = pair; env.insert(v, sat-assigns.at(0).at(i)); env
+      let (i, v) = pair; env.insert(v, bool-bit(sat-assigns.at(0).at(i))); env
     })
     // Evaluate gates in order, accumulating (env, steps)
     #let result = gates.fold((env: init-env, steps: ()), (acc, a) => {
@@ -5829,12 +5777,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #let final-val = eval-expr(output-gate.expr, result.env)
 
     *Example.* Consider the circuit with $n = #n$ inputs and $g = #g$ gates: #gate-defs.join(", "), giving $C(#inputs.map(fmt-input).join(", ")) = #circuit-expr$.
-    The assignment $(#inputs.map(fmt-input).join(", ")) = (#sat-assigns.at(0).map(str).join(", "))$ is satisfying: #result.steps.join(", "), so $C = #final-val$.
+    The assignment $(#inputs.map(fmt-input).join(", ")) = (#fmt-values(sat-assigns.at(0)))$ is satisfying: #result.steps.join(", "), so $C = #final-val$.
 
     #pred-commands(
       "pred create --example CircuitSAT -o circuitsat.json",
       "pred solve circuitsat.json",
-      "pred evaluate circuitsat.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate circuitsat.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -5855,7 +5803,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
         draw.content((-0.3, 0.975), text(8pt)[$x_1$])
         draw.content((-0.3, -0.975), text(8pt)[$x_2$])
       }),
-      caption: [Circuit $C(#inputs.map(fmt-input).join(", ")) = #circuit-expr$. Junction dots mark where inputs fork to both gates. Satisfying assignments: #sat-assigns.map(a => $paren.l #a.map(v => str(v)).join(", ") paren.r$).join(" and ").],
+      caption: [Circuit $C(#inputs.map(fmt-input).join(", ")) = #circuit-expr$. Junction dots mark where inputs fork to both gates. Satisfying assignments: #sat-assigns.map(a => $paren.l #fmt-values(a) paren.r$).join(" and ").],
     ) <fig:circuit-sat>
     ]
   ]
@@ -5896,7 +5844,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ConjunctiveQueryFoldability -o cqf.json",
         "pred solve cqf.json",
-        "pred evaluate cqf.json --config " + config.map(str).join(","),
+        "pred evaluate cqf.json --config " + cli-config(config),
       )
 
       #figure(
@@ -5984,7 +5932,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     let yset = if yop.kind == "elem" { (yop.val,) } else { z-sets.at(yop.val) }
     z-sets.push((xset + yset).dedup().sorted())
   }
-  let fmt-elem-set(s) = "{" + s.map(str).join(", ") + "}"
+  let fmt-elem-set(s) = "{" + fmt-values(s) + "}"
   let fmt-op(op) = if op.kind == "elem" {
     "{" + str(op.val) + "}"
   } else {
@@ -6002,7 +5950,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example EnsembleComputation -o ensemble.json",
         "pred solve ensemble.json",
-        "pred evaluate ensemble.json --config " + config.map(str).join(","),
+        "pred evaluate ensemble.json --config " + cli-config(config),
       )
     ]
   ]
@@ -6014,21 +5962,20 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let mb = x.instance.m
   let nb = x.instance.n
   let sol = x.optimal_config
-  // First mb bits encode p, next nb bits encode q
-  let p = range(mb).fold(0, (acc, i) => acc + sol.at(i) * calc.pow(2, i)) + 2
-  let q = range(nb).fold(0, (acc, i) => acc + sol.at(mb + i) * calc.pow(2, i)) + 2
+  let p = sol.at(0).at(0)
+  let q = sol.at(1).at(0)
   [
     #problem-def("Factoring")[
-      Given a composite integer $N$ and bit sizes $m, n$, find integers $p in [2, 2^m - 1]$ and $q in [2, 2^n - 1]$ such that $p times q = N$. Here $p$ has $m$ bits and $q$ has $n$ bits.
+      Given an integer $N >= 2$ and optional maximum factor widths $m <= n$, find integers $p in [0, 2^m - 1]$ and $q in [0, 2^n - 1]$ such that $p <= q$ and $p times q = N$. If the widths are omitted, let $b$ be the bit length of $N$ and use $m = ceil(b slash 2)$ and $n = b - 1$.
     ][
     The hardness of integer factorization underpins RSA cryptography and other public-key systems. Unlike most problems in this collection, Factoring is not known to be NP-complete; it lies in NP $inter$ co-NP, suggesting it may be of intermediate complexity. The best classical algorithm is the General Number Field Sieve @lenstra1993 running in sub-exponential time $e^(O(b^(1 slash 3)(log b)^(2 slash 3)))$ where $b$ is the bit length. Shor's algorithm @shor1994 solves Factoring in polynomial time on a quantum computer.
 
-    *Example.* Let $N = #N$ with $m = #mb$ bits and $n = #nb$ bits, so $p in [2, #(calc.pow(2, mb) - 1)]$ and $q in [2, #(calc.pow(2, nb) - 1)]$. The solution is $p = #p$, $q = #q$, since $#p times #q = #N = N$. Note $p = #p$ fits in #mb bits and $q = #q$ fits in #nb bits. The alternative factorization $#q times #p$ requires $m = #nb$, $n = #mb$.
+    *Example.* Let $N = #N$. Its bit length is 4, so the default bounds are $m = #mb$ and $n = #nb$. The canonical solution is $p = #p$, $q = #q$, since $#p <= #q$ and $#p times #q = #N = N$. Explicit wider bounds may also admit a trivial factorization such as $1 times N$.
 
     #pred-commands(
       "pred create --example Factoring -o factoring.json",
       "pred solve factoring.json",
-      "pred evaluate factoring.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate factoring.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -6054,7 +6001,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example QuantifiedBooleanFormulas -o quantified-boolean-formulas.json",
       "pred solve quantified-boolean-formulas.json",
-      "pred evaluate quantified-boolean-formulas.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate quantified-boolean-formulas.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -6081,7 +6028,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example ExpectedRetrievalCost -o expected-retrieval-cost.json",
       "pred solve expected-retrieval-cost.json --solver brute-force",
-      "pred evaluate expected-retrieval-cost.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate expected-retrieval-cost.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -6114,7 +6061,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumDiscretePlanarInverseKinematics -o ik.json",
       "pred solve ik.json --solver brute-force",
-      "pred evaluate ik.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate ik.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -6141,12 +6088,9 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let k = x.instance.k
   let A = x.instance.matrix
   let fs = metric-value(x.optimal_value)
-  // Decode B and C from optimal config
-  // Config layout: B is m*k values, then C is k*n values
   let cfg = x.optimal_config
-  let B = range(mr).map(i => range(k).map(j => cfg.at(i * k + j)))
-  let C = range(k).map(i => range(nc).map(j => cfg.at(mr * k + i * nc + j)))
-  // Convert A from bool to int for display
+  let B = cfg.at(0).map(row => row.map(bool-bit))
+  let C = cfg.at(1).map(row => row.map(bool-bit))
   let A-int = A.map(row => row.map(v => if v { 1 } else { 0 }))
   // Format matrix as math.mat with proper rows
   let fmt-mat(m) = math.mat(..m.map(row => row.map(v => $#v$)))
@@ -6161,7 +6105,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example BMF -o bmf.json",
       "pred solve bmf.json",
-      "pred evaluate bmf.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate bmf.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -6244,7 +6188,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example ConsecutiveBlockMinimization -o consecutive-block-minimization.json",
       "pred solve consecutive-block-minimization.json",
-      "pred evaluate consecutive-block-minimization.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate consecutive-block-minimization.json --config " + cli-config(x.optimal_config),
     )
     ]
   ]
@@ -6261,10 +6205,10 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let num-changes = metric-value(sol.metric)
   // Build the full sequence of car labels
   let seq-labels = seq-indices.map(i => labels.at(i))
-  // Build color sequence: for each position, if is_first[pos] then color = assign[car], else 1-assign[car]
+  // Build the color sequence, flipping the second occurrence of each car.
   let color-seq = range(seq-indices.len()).map(pos => {
     let car = seq-indices.at(pos)
-    if is-first.at(pos) { assign.at(car) } else { 1 - assign.at(car) }
+    if is-first.at(pos) { assign.at(car) } else { not assign.at(car) }
   })
   [
     #problem-def("PaintShop")[
@@ -6272,12 +6216,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
     NP-hard and APX-hard @epping2004. Arises in automotive manufacturing where color changes between consecutive cars on an assembly line require costly purging of paint nozzles. Each car appears twice in the sequence (two coats), and each car's two occurrences must receive opposite colors (one per side). A natural benchmark for quantum annealing due to its binary structure and industrial relevance. The best known algorithm runs in $O^*(2^n)$ by brute-force enumeration#footnote[No algorithm improving on brute-force is known for general Paint Shop.].
 
-    *Example.* Consider $n = #n-cars$ cars with sequence $(#seq-labels.join(", "))$. Each car gets one occurrence colored 0 and the other colored 1. The assignment #labels.zip(assign).map(((l, c)) => [#l: #c\/#(1 - c)]).join(", ") yields color sequence $(#color-seq.map(c => str(c)).join(", "))$ with #num-changes color changes. The minimum is #num-changes changes.
+    *Example.* Consider $n = #n-cars$ cars with sequence $(#seq-labels.join(", "))$. Each car gets one occurrence colored 0 and the other colored 1. The assignment #labels.zip(assign).map(((l, c)) => [#l: #bool-bit(c)\/#bool-bit(not c)]).join(", ") yields color sequence $(#fmt-values(color-seq))$ with #num-changes color changes. The minimum is #num-changes changes.
 
     #pred-commands(
       "pred create --example PaintShop -o paint-shop.json",
       "pred solve paint-shop.json",
-      "pred evaluate paint-shop.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate paint-shop.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -6295,11 +6239,11 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
               items.push(box(width: 0.15cm))  // spacer
             }
           }
-          let fill = if c == 0 { white } else { blue.transparentize(40%) }
+          let fill = if not c { white } else { blue.transparentize(40%) }
           items.push(stack(dir: ttb, spacing: 0.08cm,
             box(width: 0.55cm, height: 0.55cm, fill: fill, stroke: 0.5pt + luma(120),
               align(center + horizon, text(8pt, weight: "bold", car))),
-            text(6pt, fill: luma(100), str(c)),
+            text(6pt, fill: luma(100), str(bool-bit(c))),
           ))
         }
         align(center, stack(dir: ltr, spacing: 0pt, ..items))
@@ -6330,7 +6274,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example BicliqueCover -o biclique-cover.json",
       "pred solve biclique-cover.json",
-      "pred evaluate biclique-cover.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate biclique-cover.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -6363,8 +6307,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let k = x.instance.k
   let bip-edges = x.instance.graph.edges
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let left-selected = range(left-size).filter(i => sol.config.at(i) == 1)
-  let right-selected = range(right-size).filter(i => sol.config.at(left-size + i) == 1)
+  let left-selected = range(left-size).filter(i => sol.config.at(i))
+  let right-selected = range(right-size).filter(i => sol.config.at(left-size + i))
   let selected-edges = bip-edges.filter(e =>
     left-selected.contains(e.at(0)) and right-selected.contains(e.at(1))
   )
@@ -6380,7 +6324,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example BalancedCompleteBipartiteSubgraph -o balanced-complete-bipartite-subgraph.json",
       "pred solve balanced-complete-bipartite-subgraph.json",
-      "pred evaluate balanced-complete-bipartite-subgraph.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate balanced-complete-bipartite-subgraph.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -6450,7 +6394,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example PartitionIntoTriangles -o partition-into-triangles.json",
         "pred solve partition-into-triangles.json",
-        "pred evaluate partition-into-triangles.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate partition-into-triangles.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -6494,7 +6438,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example PartitionIntoForests -o partition-into-forests.json",
         "pred solve partition-into-forests.json",
-        "pred evaluate partition-into-forests.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate partition-into-forests.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6507,7 +6451,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let edges = x.instance.graph.edges
   let K = x.instance.max_degree
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let selected-edges = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let selected-edges = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   [
     #problem-def("DegreeConstrainedSpanningTree")[
       Given an undirected graph $G = (V, E)$ and a positive integer $K$, determine whether $G$ contains a spanning tree $T$ in which every vertex has degree at most $K$.
@@ -6519,7 +6463,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example DegreeConstrainedSpanningTree -o dcst.json",
         "pred solve dcst.json",
-        "pred evaluate dcst.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate dcst.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6534,7 +6478,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let D = x.instance.diameter_bound
   let ew = x.instance.edge_weights
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let selected-edges = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let selected-edges = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let total-weight = selected-edges.map(i => ew.at(i)).sum()
   [
     #problem-def("BoundedDiameterSpanningTree")[
@@ -6547,7 +6491,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example BoundedDiameterSpanningTree -o bdst.json",
         "pred solve bdst.json",
-        "pred evaluate bdst.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate bdst.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6559,7 +6503,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let ne = graph-num-edges(x.instance)
   let edges = x.instance.graph.edges
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let tree-edges = sol.config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let tree-edges = sol.config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let leaf-count = sol.metric
   // compute degrees in the tree
   let degrees = range(nv).map(v => tree-edges.map(i => edges.at(i)).filter(((u, w)) => u == v or w == v).len())
@@ -6575,7 +6519,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MaximumLeafSpanningTree -o mlst.json",
         "pred solve mlst.json",
-        "pred evaluate mlst.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mlst.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6597,7 +6541,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MonochromaticTriangle -o monochromatic-triangle.json",
         "pred solve monochromatic-triangle.json",
-        "pred evaluate monochromatic-triangle.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate monochromatic-triangle.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6622,7 +6566,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example PartitionIntoCliques -o partition-into-cliques.json",
         "pred solve partition-into-cliques.json",
-        "pred evaluate partition-into-cliques.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate partition-into-cliques.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6647,7 +6591,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example PartitionIntoPerfectMatchings -o partition-into-perfect-matchings.json",
         "pred solve partition-into-perfect-matchings.json",
-        "pred evaluate partition-into-perfect-matchings.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate partition-into-perfect-matchings.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6676,7 +6620,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example BinPacking -o bin-packing.json",
         "pred solve bin-packing.json",
-        "pred evaluate bin-packing.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate bin-packing.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -6718,7 +6662,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let n = weights.len()
   let config = x.optimal_config
   let opt-val = metric-value(x.optimal_value)
-  let selected = range(n).filter(i => config.at(i) == 1)
+  let selected = range(n).filter(i => config.at(i))
   let total-w = selected.map(i => weights.at(i)).sum()
   let total-v = selected.map(i => values.at(i)).sum()
   [
@@ -6732,7 +6676,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example Knapsack -o knapsack.json",
         "pred solve knapsack.json",
-        "pred evaluate knapsack.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate knapsack.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6759,7 +6703,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example IntegerKnapsack -o ik.json",
         "pred solve ik.json",
-        "pred evaluate ik.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate ik.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6797,7 +6741,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example RectilinearPictureCompression -o rectilinear-picture-compression.json",
       "pred solve rectilinear-picture-compression.json",
-      "pred evaluate rectilinear-picture-compression.json --config " + x.optimal_config.map(str).join(","),
+      "pred evaluate rectilinear-picture-compression.json --config " + cli-config(x.optimal_config),
     )
 
     #figure(
@@ -6854,7 +6798,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example FeasibleRegisterAssignment -o feasible-register-assignment.json",
         "pred solve feasible-register-assignment.json --solver brute-force",
-        "pred evaluate feasible-register-assignment.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate feasible-register-assignment.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6873,12 +6817,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Minimum Register Sufficiency for Loops is problem SS20 in Garey & Johnson @garey1979. It is equivalent to minimum coloring of circular arc graphs. NP-complete via reduction from Chromatic Number. No algorithm improving on brute-force $O(n^n)$ enumeration is known for arbitrary circular arc instances.
 
-      *Example.* Let $N = #N$ timesteps and $n = #nv$ variables with arcs: #vars.enumerate().map(((i, v)) => $x_#i: [#(v.at(0)), #(v.at(0)) + #(v.at(1)))$).join(", ") mod $#N$. All pairs of arcs overlap (each arc covers half the circle and any two arcs share at least one timestep), forming a complete conflict graph $K_#nv$. The assignment $(#config.map(str).join(", "))$ uses #num-regs distinct registers, which is optimal.
+      *Example.* Let $N = #N$ timesteps and $n = #nv$ variables with arcs: #vars.enumerate().map(((i, v)) => $x_#i: [#(v.at(0)), #(v.at(0)) + #(v.at(1)))$).join(", ") mod $#N$. All pairs of arcs overlap (each arc covers half the circle and any two arcs share at least one timestep), forming a complete conflict graph $K_#nv$. The assignment $(#fmt-values(config))$ uses #num-regs distinct registers, which is optimal.
 
       #pred-commands(
         "pred create --example MinimumRegisterSufficiencyForLoops -o mrsfl.json",
         "pred solve mrsfl.json --solver brute-force",
-        "pred evaluate mrsfl.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mrsfl.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6905,7 +6849,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example RegisterSufficiency -o register-sufficiency.json",
         "pred solve register-sufficiency.json --solver brute-force",
-        "pred evaluate register-sufficiency.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate register-sufficiency.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6937,7 +6881,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumCodeGenerationOneRegister -o mcgor.json",
         "pred solve mcgor.json --solver brute-force",
-        "pred evaluate mcgor.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mcgor.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -6970,7 +6914,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumCodeGenerationUnlimitedRegisters -o mcgur.json",
         "pred solve mcgur.json --solver brute-force",
-        "pred evaluate mcgur.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mcgur.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -7003,7 +6947,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumCodeGenerationParallelAssignments -o mcgpa.json",
         "pred solve mcgpa.json --solver brute-force",
-        "pred evaluate mcgpa.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mcgpa.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -7057,7 +7001,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     #pred-commands(
       "pred create --example MinimumDecisionTree -o mdt.json",
       "pred solve mdt.json",
-      "pred evaluate mdt.json --config " + sol.map(str).join(","),
+      "pred evaluate mdt.json --config " + cli-config(sol),
     )
     ]
   ]
@@ -7086,7 +7030,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     $paren.l #bits.join(",") paren.r$
   }
   // Selected prime implicants
-  let selected = cfg.enumerate().filter(((_, v)) => v == 1).map(((i, _)) => i)
+  let selected = cfg.enumerate().filter(((_, selected)) => selected).map(((i, _)) => i)
   [
     #problem-def("MinimumDisjunctiveNormalForm")[
       Given $n$ Boolean variables and a Boolean function $f: {0,1}^n -> {0,1}$ specified by its truth table, find a disjunctive normal form (DNF) formula with the minimum number of terms (disjuncts) that is equivalent to $f$.
@@ -7136,7 +7080,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example RuralPostman -o rural-postman.json",
         "pred solve rural-postman.json",
-        "pred evaluate rural-postman.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate rural-postman.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -7180,14 +7124,14 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 }
 
 #{
-  let x = load-model-example("MixedChinesePostman", variant: (weight: "i32"))
+  let x = load-model-example("MixedChinesePostman", variant: (weight: "i64"))
   let nv = x.instance.graph.num_vertices
   let arcs = x.instance.graph.arcs
   let edges = x.instance.graph.edges
   let arc-weights = x.instance.arc_weights
   let edge-weights = x.instance.edge_weights
   let config = x.optimal_config
-  let oriented = edges.enumerate().map(((i, e)) => if config.at(i) == 0 { e } else { (e.at(1), e.at(0)) })
+  let oriented = edges.enumerate().map(((i, e)) => if not config.at(i) { e } else { (e.at(1), e.at(0)) })
   let base-cost = arc-weights.sum() + edge-weights.sum()
   let total-cost = x.optimal_value
   [
@@ -7196,12 +7140,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Mixed Chinese Postman is the mixed-graph arc-routing problem ND25 in Garey and Johnson @garey1979. Papadimitriou proved the mixed case NP-complete even when all lengths are 1, the graph is planar, and the maximum degree is 3 @papadimitriou1976edge. In contrast, the pure undirected and pure directed cases are polynomial-time solvable via matching / circulation machinery @edmondsjohnson1973. The implementation here uses one binary variable per undirected edge orientation, so the search space contributes the $2^|E|$ factor visible in the registered exact bound.
 
-      *Example.* Consider the instance on #nv vertices with directed arcs $(v_0, v_1)$, $(v_1, v_2)$, $(v_2, v_3)$, $(v_3, v_0)$ of lengths $2, 3, 1, 4$ and undirected edges $\{v_0, v_2\}$, $\{v_1, v_3\}$, $\{v_0, v_4\}$, $\{v_4, v_2\}$ of lengths $2, 3, 1, 2$. The config $(#config.map(str).join(", "))$ orients those edges as $(v_2, v_0)$, $(v_3, v_1)$, $(v_0, v_4)$, and $(v_4, v_2)$, producing a strongly connected digraph. The base traversal cost is #base-cost, and the minimum balancing cost brings the total to #total-cost.
+      *Example.* Consider the instance on #nv vertices with directed arcs $(v_0, v_1)$, $(v_1, v_2)$, $(v_2, v_3)$, $(v_3, v_0)$ of lengths $2, 3, 1, 4$ and undirected edges $\{v_0, v_2\}$, $\{v_1, v_3\}$, $\{v_0, v_4\}$, $\{v_4, v_2\}$ of lengths $2, 3, 1, 2$. The config $(#fmt-values(config))$ orients those edges as $(v_2, v_0)$, $(v_3, v_1)$, $(v_0, v_4)$, and $(v_4, v_2)$, producing a strongly connected digraph. The base traversal cost is #base-cost, and the minimum balancing cost brings the total to #total-cost.
 
       #pred-commands(
-        "pred create --example MixedChinesePostman/i32 -o mixed-chinese-postman.json",
+        "pred create --example MixedChinesePostman/i64 -o mixed-chinese-postman.json",
         "pred solve mixed-chinese-postman.json --solver brute-force",
-        "pred evaluate mixed-chinese-postman.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mixed-chinese-postman.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -7325,12 +7269,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
       A configuration is a permutation of the required arcs, interpreted as the order in which those arcs are forced into the tour. The verifier traverses each chosen arc, then inserts the shortest available connector path from that arc's head to the tail of the next arc, wrapping around at the end to close the walk.
 
-      *Example.* The canonical instance has 6 vertices, 5 required arcs, and 7 undirected edges. The optimal configuration $[#config.map(str).join(", ")]$ orders the required arcs as $a_0, a_2, a_1, a_4, a_3$. Traversing those arcs contributes 17 units of required-arc length, and the shortest connector paths contribute $1 + 1 + 1 + 0 + 0 = 3$, so the resulting closed walk has minimum total length $20$.
+      *Example.* The canonical instance has 6 vertices, 5 required arcs, and 7 undirected edges. The optimal configuration $[#fmt-values(config)]$ orders the required arcs as $a_0, a_2, a_1, a_4, a_3$. Traversing those arcs contributes 17 units of required-arc length, and the shortest connector paths contribute $1 + 1 + 1 + 0 + 0 = 3$, so the resulting closed walk has minimum total length $20$.
 
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o stacker-crane.json",
         "pred solve stacker-crane.json --solver brute-force",
-        "pred evaluate stacker-crane.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate stacker-crane.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -7389,7 +7333,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SubgraphIsomorphism -o subgraph-isomorphism.json",
         "pred solve subgraph-isomorphism.json",
-        "pred evaluate subgraph-isomorphism.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate subgraph-isomorphism.json --config " + cli-config(x.optimal_config),
       )
 
       #{
@@ -7488,12 +7432,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Grouping by Swapping is the storage-and-retrieval problem SR21 in Garey and Johnson @garey1979. It asks whether a string can be locally reorganized, using only adjacent transpositions, until equal symbols coalesce into blocks. The implementation in this crate uses a fixed-length swap program with one slot per allowed operation, so the direct brute-force search explores $O(|x|^K)$ configurations.#footnote[This is the exact search bound induced by the fixed-length witness encoding implemented in the codebase; no sharper exact worst-case bound is claimed here.]
 
-      *Example.* Let $Sigma = {#alpha-map.join(", ")}$, $x = #source-str$, and $K = #budget$. The configuration $p = (#config.map(str).join(", "))$ performs adjacent swaps at positions $(2, 3)$, $(1, 2)$, and $(3, 4)$, then uses two trailing no-op slots. The resulting string is $y = #step3-str$, so every symbol now appears in one contiguous block and the verifier returns YES.
+      *Example.* Let $Sigma = {#alpha-map.join(", ")}$, $x = #source-str$, and $K = #budget$. The configuration $p = (#fmt-values(config))$ performs adjacent swaps at positions $(2, 3)$, $(1, 2)$, and $(3, 4)$, then uses two trailing no-op slots. The resulting string is $y = #step3-str$, so every symbol now appears in one contiguous block and the verifier returns YES.
 
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o grouping-by-swapping.json",
         "pred solve grouping-by-swapping.json --solver brute-force",
-        "pred evaluate grouping-by-swapping.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate grouping-by-swapping.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -7522,7 +7466,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
           ),
         ))
       },
-      caption: [Grouping by Swapping on $x = #source-str$: three effective adjacent swaps turn the alternating string into $y = #step3-str$. The remaining two slots in $p = (#config.map(str).join(", "))$ are no-ops at position 5.],
+      caption: [Grouping by Swapping on $x = #source-str$: three effective adjacent swaps turn the alternating string into $y = #step3-str$. The remaining two slots in $p = (#fmt-values(config))$ are no-ops at position 5.],
       ) <fig:grouping-by-swapping>
 
       The final row has exactly one block of $a$, one block of $b$, and one block of $c$, so it satisfies the grouping constraint within the allotted budget.
@@ -7534,8 +7478,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let x = load-model-example("LongestCommonSubsequence")
   let strings = x.instance.strings
   let alphabet-size = x.instance.alphabet_size
-  // optimal_config includes padding symbols; extract the non-padding prefix
-  let witness = x.optimal_config.filter(c => c < alphabet-size)
+  let witness = x.optimal_config.filter(c => c != none)
   let fmt-str(s) = "\"" + s.map(c => str(c)).join("") + "\""
   let string-list = strings.map(fmt-str).join(", ")
   let find-embed(target, candidate) = {
@@ -7561,7 +7504,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example LongestCommonSubsequence -o longest-common-subsequence.json",
         "pred solve longest-common-subsequence.json",
-        "pred evaluate longest-common-subsequence.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate longest-common-subsequence.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -7629,7 +7572,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ClosestString -o closest-string.json",
         "pred solve closest-string.json --solver brute-force",
-        "pred evaluate closest-string.json --config " + center.map(str).join(","),
+        "pred evaluate closest-string.json --config " + cli-config(center),
       )
     ]
   ]
@@ -7674,7 +7617,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ClosestSubstring -o closest-substring.json",
         "pred solve closest-substring.json --solver brute-force",
-        "pred evaluate closest-substring.json --config " + config.map(str).join(","),
+        "pred evaluate closest-substring.json --config " + cli-config(config),
       )
     ]
   ]
@@ -7686,7 +7629,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let target = x.instance.target
   let n = sizes.len()
   let config = x.optimal_config
-  let selected = range(n).filter(i => config.at(i) == 1)
+  let selected = range(n).filter(i => config.at(i))
   let sel-sizes = selected.map(i => sizes.at(i))
   [
     #problem-def("SubsetSum")[
@@ -7699,7 +7642,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SubsetSum -o subset-sum.json",
         "pred solve subset-sum.json",
-        "pred evaluate subset-sum.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate subset-sum.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -7711,7 +7654,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let target = x.instance.target
   let n = sizes.len()
   let config = x.optimal_config
-  let selected = range(n).filter(i => config.at(i) == 1)
+  let selected = range(n).filter(i => config.at(i))
   let sel-sizes = selected.map(i => sizes.at(i))
   [
     #problem-def("SubsetProduct")[
@@ -7724,7 +7667,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SubsetProduct -o subset-product.json",
         "pred solve subset-product.json",
-        "pred evaluate subset-product.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate subset-product.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -7752,7 +7695,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ResourceConstrainedScheduling -o rcs.json",
         "pred solve rcs.json",
-        "pred evaluate rcs.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate rcs.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -7764,7 +7707,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let fds = x.instance.functional_deps
   let target = x.instance.target_subset
   let config = x.optimal_config
-  let X = range(num-attrs).filter(i => config.at(i) == 1)
+  let X = range(num-attrs).filter(i => config.at(i))
   // Compute closure of X under fds
   let closure = {
     let cur = X
@@ -7805,7 +7748,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example BoyceCoddNormalFormViolation -o bcnf.json",
         "pred solve bcnf.json",
-        "pred evaluate bcnf.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate bcnf.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -7866,7 +7809,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ConsistencyOfDatabaseFrequencyTables -o consistency-of-database-frequency-tables.json",
         "pred solve consistency-of-database-frequency-tables.json",
-        "pred evaluate consistency-of-database-frequency-tables.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate consistency-of-database-frequency-tables.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -7890,15 +7833,15 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Problem SP19 in Garey and Johnson @garey1979. NP-complete in the strong sense, so no pseudo-polynomial time algorithm exists unless $P = "NP"$. For fixed $K$, a dynamic-programming algorithm runs in $O(n S^(K-1))$ pseudo-polynomial time, where $S = sum s(a)$. The problem remains NP-complete when the exponent 2 is replaced by any fixed rational $alpha > 1$. #footnote[No algorithm improving on brute-force $O(K^n)$ enumeration is known for the general case.] The squared objective penalizes imbalanced partitions, connecting it to variance minimization, load balancing, and $k$-means clustering. Sum of Squares Partition generalizes Partition ($K = 2$, $J = S^2 slash 2$).
 
-      *Example.* Let $A = {#sizes.map(str).join(", ")}$ ($n = #n-elem$) and $K = #K$ groups. The optimal partition is #groups.enumerate().map(((g, idxs)) => {
+      *Example.* Let $A = {#fmt-values(sizes)}$ ($n = #n-elem$) and $K = #K$ groups. The optimal partition is #groups.enumerate().map(((g, idxs)) => {
         let elems = idxs.map(i => str(sizes.at(i)))
         [$A_#(g+1) = {#elems.join(", ")}$]
-      }).join(", ") with group sums #group-sums.map(str).join(", ") and sum of squares $#group-sq.map(str).join(" + ") = #opt-val$.
+      }).join(", ") with group sums #fmt-values(group-sums) and sum of squares $#group-sq.map(str).join(" + ") = #opt-val$.
 
       #pred-commands(
         "pred create --example SumOfSquaresPartition -o sosp.json",
         "pred solve sosp.json --solver brute-force",
-        "pred evaluate sosp.json --config " + config.map(str).join(","),
+        "pred evaluate sosp.json --config " + cli-config(config),
       )
     ]
   ]
@@ -7921,12 +7864,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       3-Partition is Garey and Johnson's strongly NP-complete benchmark SP15 @garey1979. Unlike ordinary Partition, the strict size window forces every feasible block to contain exactly three elements, making the problem the canonical source for strong NP-completeness reductions to scheduling, packing, and layout models. The implementation in this repository uses one group-assignment variable per element, so the exported exact-search baseline is $O^*(3^n)$#footnote[This is the direct worst-case bound induced by the implementation's configuration space and matches the registered catalog expression `3^num_elements`; no sharper general exact bound was independently verified while preparing this entry.].
 
-      *Example.* Let $B = #bound$ and consider the #(sizes.len())-element instance with sizes $(#sizes.map(str).join(", "))$. The witness triples #groups.enumerate().map(((i, g)) => [$A_#(i+1) = {#g.map(str).join(", ")}$]).join([ and ]) both sum to $#bound$, so this instance is satisfiable.
+      *Example.* Let $B = #bound$ and consider the #(sizes.len())-element instance with sizes $(#fmt-values(sizes))$. The witness triples #groups.enumerate().map(((i, g)) => [$A_#(i+1) = {#fmt-values(g)}$]).join([ and ]) both sum to $#bound$, so this instance is satisfiable.
 
       #pred-commands(
         "pred create --example ThreePartition -o three-partition.json",
         "pred solve three-partition.json",
-        "pred evaluate three-partition.json --config " + config.map(str).join(","),
+        "pred evaluate three-partition.json --config " + cli-config(config),
       )
 
       #align(center, table(
@@ -7934,7 +7877,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
         align: center,
         table.header([Triple], [Elements], [Sum]),
         ..groups.enumerate().map(((i, g)) => (
-          [$A_#(i+1)$], [$#(g.map(str).join(", "))$], [$#bound$],
+          [$A_#(i+1)$], [$#(fmt-values(g))$], [$#bound$],
         )).flatten(),
       ))
     ]
@@ -7953,16 +7896,16 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let y-perm = config.slice(m)
   [
     #problem-def("Numerical3DimensionalMatching")[
-      Given disjoint sets $W$, $X$, $Y$ each with $m$ elements, positive integer sizes $s(a)$ with $B\/4 < s(a) < B\/2$ for every element, and a bound $B in ZZ^+$ such that $sum s(a) = m B$, determine whether $W union X union Y$ can be partitioned into $m$ triples, each containing one element from $W$, $X$, and $Y$, with each triple summing to exactly $B$.
+      Given disjoint sets $W$, $X$, $Y$ each with $m >= 1$ elements, positive integer sizes $s(a)$, and a bound $B in ZZ^+$ such that $sum s(a) = m B$, determine whether $W union X union Y$ can be partitioned into $m$ triples, each containing one element from $W$, $X$, and $Y$, with each triple summing to exactly $B$.
     ][
-      Numerical 3-Dimensional Matching is strongly NP-complete (SP16 in Garey and Johnson @garey1979). The strict size window $B\/4 < s(a) < B\/2$ forces every feasible triple to contain exactly one element from each set. The problem is a key intermediate in strong NP-completeness reductions to bin packing, scheduling, and layout problems. Brute-force enumeration runs in $O^*(m^(2m))$ time.
+      Numerical 3-Dimensional Matching is strongly NP-complete (SP16 in Garey and Johnson @garey1979). This model requires the necessary total-sum equality as an input precondition; membership in $W$, $X$, and $Y$ determines the three elements of each triple. The problem is a key intermediate in strong NP-completeness reductions to bin packing, scheduling, and layout problems. Brute-force enumeration runs in $O^*(m^(2m))$ time.
 
-      *Example.* Let $m = #m$ and $B = #bound$. The sizes are $W = (#sw.map(str).join(", "))$, $X = (#sx.map(str).join(", "))$, $Y = (#sy.map(str).join(", "))$. The matching pairs each $w_i$ with $x_(pi(i))$ and $y_(sigma(i))$: #range(m).map(i => [$w_#i + x_#(x-perm.at(i)) + y_#(y-perm.at(i)) = #(sw.at(i) + sx.at(x-perm.at(i)) + sy.at(y-perm.at(i)))$]).join(", "), all equal to $B$.
+      *Example.* Let $m = #m$ and $B = #bound$. The sizes are $W = (#fmt-values(sw))$, $X = (#fmt-values(sx))$, $Y = (#fmt-values(sy))$. The matching pairs each $w_i$ with $x_(pi(i))$ and $y_(sigma(i))$: #range(m).map(i => [$w_#i + x_#(x-perm.at(i)) + y_#(y-perm.at(i)) = #(sw.at(i) + sx.at(x-perm.at(i)) + sy.at(y-perm.at(i)))$]).join(", "), all equal to $B$.
 
       #pred-commands(
         "pred create --example Numerical3DimensionalMatching -o n3dm.json",
         "pred solve n3dm.json",
-        "pred evaluate n3dm.json --config " + config.map(str).join(","),
+        "pred evaluate n3dm.json --config " + cli-config(config),
       )
     ]
   ]
@@ -7980,12 +7923,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Numerical Matching with Target Sums is NP-complete in the strong sense (SP17 in Garey and Johnson @garey1979). It generalizes bipartite perfect matching by imposing sum constraints on each pair. Brute-force enumeration runs in $O^*(2^m)$ time by trying all $m!$ permutations.
 
-      *Example.* Let $m = #m$, $X = (#sx.map(str).join(", "))$, $Y = (#sy.map(str).join(", "))$, targets $= (#targets.map(str).join(", "))$. The matching $pi = (#config.map(str).join(", "))$ yields sums #range(m).map(i => [$#(sx.at(i)) + #(sy.at(config.at(i))) = #(sx.at(i) + sy.at(config.at(i)))$]).join(", "), which as a multiset equals the targets.
+      *Example.* Let $m = #m$, $X = (#fmt-values(sx))$, $Y = (#fmt-values(sy))$, targets $= (#fmt-values(targets))$. The matching $pi = (#fmt-values(config))$ yields sums #range(m).map(i => [$#(sx.at(i)) + #(sy.at(config.at(i))) = #(sx.at(i) + sy.at(config.at(i)))$]).join(", "), which as a multiset equals the targets.
 
       #pred-commands(
         "pred create --example NumericalMatchingWithTargetSums -o nmts.json",
         "pred solve nmts.json",
-        "pred evaluate nmts.json --config " + config.map(str).join(","),
+        "pred evaluate nmts.json --config " + cli-config(config),
       )
     ]
   ]
@@ -8001,12 +7944,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Non-Liveness of free-choice Petri nets is NP-complete (Garey and Johnson @garey1979). A Petri net is _free-choice_ if every two transitions sharing an input place have identical presets. The implementation explores the bounded reachability graph (capped at the initial token sum per place) and checks whether any transition becomes permanently dead.
 
-      *Example.* A chain net with $#np$ places and $#nt$ transitions: $t_0$ moves a token from $s_0$ to $s_1$, $t_1$ from $s_1$ to $s_2$, $t_2$ from $s_2$ to $s_3$. Starting from $M_0 = (1, 0, 0, 0)$, after all transitions fire once the net reaches deadlock at $(0, 0, 0, 1)$ and all transitions are permanently dead. The witness configuration $(#config.map(str).join(", "))$ confirms all transitions are globally dead.
+      *Example.* A chain net with $#np$ places and $#nt$ transitions: $t_0$ moves a token from $s_0$ to $s_1$, $t_1$ from $s_1$ to $s_2$, $t_2$ from $s_2$ to $s_3$. Starting from $M_0 = (1, 0, 0, 0)$, after all transitions fire once the net reaches deadlock at $(0, 0, 0, 1)$ and all transitions are permanently dead. The witness configuration $(#fmt-values(config))$ confirms all transitions are globally dead.
 
       #pred-commands(
         "pred create --example NonLivenessFreePetriNet -o petri.json",
         "pred solve petri.json --solver brute-force",
-        "pred evaluate petri.json --config " + config.map(str).join(","),
+        "pred evaluate petri.json --config " + cli-config(config),
       )
     ]
   ]
@@ -8019,7 +7962,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let nt = ts.len()
   let imps = x.instance.implications
   let config = x.optimal_config
-  let selected = range(nt).filter(i => config.at(i) == 1)
+  let selected = range(nt).filter(i => config.at(i))
   let sel-labels = selected.map(i => str(ts.at(i)))
   [
     #problem-def("MinimumAxiomSet")[
@@ -8037,7 +7980,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumAxiomSet -o axiom.json",
         "pred solve axiom.json --solver brute-force",
-        "pred evaluate axiom.json --config " + config.map(str).join(","),
+        "pred evaluate axiom.json --config " + cli-config(config),
       )
     ]
   ]
@@ -8054,12 +7997,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Betweenness is problem MS1 in Garey and Johnson @garey1979. It arises in seriation, archaeological sequencing, and DNA physical mapping. The problem is NP-complete even when restricted to dense constraint sets. The implementation represents a solution as a permutation $f$ where $f(i)$ is the position assigned to element $i$.
 
-      *Example.* Consider $n = #n$ elements with triples #triples.map(t => [$(#t.at(0), #t.at(1), #t.at(2))$]).join(", "). The witness ordering $f = (#config.map(str).join(", "))$ (the identity permutation) satisfies all constraints: each middle element of every triple lies between the other two in the ordering.
+      *Example.* Consider $n = #n$ elements with triples #triples.map(t => [$(#t.at(0), #t.at(1), #t.at(2))$]).join(", "). The witness ordering $f = (#fmt-values(config))$ (the identity permutation) satisfies all constraints: each middle element of every triple lies between the other two in the ordering.
 
       #pred-commands(
         "pred create --example Betweenness -o betweenness.json",
         "pred solve betweenness.json",
-        "pred evaluate betweenness.json --config " + config.map(str).join(","),
+        "pred evaluate betweenness.json --config " + cli-config(config),
       )
     ]
   ]
@@ -8076,12 +8019,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Cyclic Ordering is problem MS2 in Garey and Johnson @garey1979. It is closely related to Betweenness (MS1) but enforces a cyclic rather than linear ordering constraint. The problem is NP-complete. The implementation represents a solution as a permutation $f$ where $f(i)$ is the position assigned to element $i$.
 
-      *Example.* Consider $n = #n$ elements with triples #triples.map(t => [$(#t.at(0), #t.at(1), #t.at(2))$]).join(", "). The witness ordering $f = (#config.map(str).join(", "))$ satisfies all constraints: each triple's elements appear in cyclic order under $f$.
+      *Example.* Consider $n = #n$ elements with triples #triples.map(t => [$(#t.at(0), #t.at(1), #t.at(2))$]).join(", "). The witness ordering $f = (#fmt-values(config))$ satisfies all constraints: each triple's elements appear in cyclic order under $f$.
 
       #pred-commands(
         "pred create --example CyclicOrdering -o cyclic_ordering.json",
         "pred solve cyclic_ordering.json",
-        "pred evaluate cyclic_ordering.json --config " + config.map(str).join(","),
+        "pred evaluate cyclic_ordering.json --config " + cli-config(config),
       )
     ]
   ]
@@ -8099,12 +8042,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Clustering is a fundamental problem in unsupervised learning and data analysis. The variant considered here is the diameter-bounded formulation, which is NP-complete. No algorithm improving on brute-force ($K^n$ enumeration) is known for the general case.#footnote[No algorithm improving on brute-force is known for general diameter-bounded clustering.]
 
-      *Example.* Consider $n = #n$ elements with $K = #K$ clusters and diameter bound $B = #B$. The distance matrix has two tight groups ${0,1,2}$ and ${3,4,5}$ with intra-group distance 1 and inter-group distance 3. The witness assignment $(#config.map(str).join(", "))$ partitions elements into clusters ${0,1,2}$ and ${3,4,5}$; each cluster has maximum pairwise distance $1 <= #B$.
+      *Example.* Consider $n = #n$ elements with $K = #K$ clusters and diameter bound $B = #B$. The distance matrix has two tight groups ${0,1,2}$ and ${3,4,5}$ with intra-group distance 1 and inter-group distance 3. The witness assignment $(#fmt-values(config))$ partitions elements into clusters ${0,1,2}$ and ${3,4,5}$; each cluster has maximum pairwise distance $1 <= #B$.
 
       #pred-commands(
         "pred create --example Clustering -o clustering.json",
         "pred solve clustering.json",
-        "pred evaluate clustering.json --config " + config.map(str).join(","),
+        "pred evaluate clustering.json --config " + cli-config(config),
       )
     ]
   ]
@@ -8122,12 +8065,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Dynamic Storage Allocation is Garey and Johnson's SR2 @garey1979 and models memory allocation for processes with known lifetimes. It generalises strip-packing and bin-packing with time constraints. The implementation encodes each item's starting address as a single variable with domain $D - s(a) + 1$.
 
-      *Example.* Let $D = #D$ and consider #n items with $(r, d, s)$ tuples #items.map(t => $(#t.at(0), #t.at(1), #t.at(2))$).join(", "). The witness assignment $sigma = (#config.map(str).join(", "))$ places every item within $[0, #(D - 1)]$ and ensures no two time-overlapping items share memory cells.
+      *Example.* Let $D = #D$ and consider #n items with $(r, d, s)$ tuples #items.map(t => $(#t.at(0), #t.at(1), #t.at(2))$).join(", "). The witness assignment $sigma = (#fmt-values(config))$ places every item within $[0, #(D - 1)]$ and ensures no two time-overlapping items share memory cells.
 
       #pred-commands(
         "pred create --example DynamicStorageAllocation -o dynamic-storage-allocation.json",
         "pred solve dynamic-storage-allocation.json",
-        "pred evaluate dynamic-storage-allocation.json --config " + config.map(str).join(","),
+        "pred evaluate dynamic-storage-allocation.json --config " + cli-config(config),
       )
 
       #align(center, table(
@@ -8147,7 +8090,6 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let sets = x.instance.sets
   let k = x.instance.k
   let bound = x.instance.bound
-  let config = x.optimal_config
   let m = sets.len()
   // Count qualifying tuples by enumerating the Cartesian product
   let total = sets.fold(1, (acc, s) => acc * s.len())
@@ -8157,12 +8099,11 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       The $K$th Largest $m$-Tuple problem is MP10 in Garey and Johnson's appendix @garey1979. It is _not known to be in NP_, because a "yes" certificate may need to exhibit $K$ qualifying tuples and $K$ can be exponentially large. The problem is PP-complete under polynomial-time Turing reductions @haase2016, though the special case $m = 2$, $K = 1$ is NP-complete via reduction from Subset Sum. In the general case, the only known exact approach is brute-force enumeration of all $product_(i=1)^m |X_i|$ tuples, so the registered catalog complexity is `total_tuples * num_sets`#footnote[No algorithm improving on brute-force is known for the general $K$th Largest $m$-Tuple problem.].
 
-      *Example.* Let $m = #m$, $B = #bound$, and $K = #k$ with sets #sets.enumerate().map(((i, s)) => [$X_#(i+1) = {#s.map(str).join(", ")}$]).join([, ]). The Cartesian product has $#total$ tuples. For instance, the tuple $(#config.enumerate().map(((i, c)) => str(sets.at(i).at(c))).join(", "))$ has sum $#config.enumerate().map(((i, c)) => sets.at(i).at(c)).sum() >= #bound$, contributing 1 to the count. In total, #k of the #total tuples satisfy the bound, so the answer is _yes_ (count $= K$).
+      *Example.* Let $m = #m$, $B = #bound$, and $K = #k$ with sets #sets.enumerate().map(((i, s)) => [$X_#(i+1) = {#fmt-values(s)}$]).join([, ]). The Cartesian product has $#total$ tuples. Exactly #k tuples have sum at least #bound, so the answer is _yes_ (count $= K$). The evaluator enumerates the Cartesian product internally and stops once it has found $K$ qualifying tuples.
 
       #pred-commands(
         "pred create --example KthLargestMTuple -o kth-largest-m-tuple.json",
         "pred solve kth-largest-m-tuple.json --solver brute-force",
-        "pred evaluate kth-largest-m-tuple.json --config " + config.map(str).join(","),
       )
     ]
   ]
@@ -8175,13 +8116,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let release = x.instance.release_times
   let deadline = x.instance.deadlines
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  // Decode Lehmer code to permutation
-  let available = range(n)
-  let perm = ()
-  for c in sol.config {
-    perm = perm + (available.at(c),)
-    available = available.slice(0, c) + available.slice(c + 1)
-  }
+  let perm = sol.config
   // Compute start times by simulating the schedule (build (task_idx, start) pairs)
   let current = 0
   let schedule = ()
@@ -8210,7 +8145,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SequencingWithReleaseTimesAndDeadlines -o sequencing-with-release-times-and-deadlines.json",
         "pred solve sequencing-with-release-times-and-deadlines.json",
-        "pred evaluate sequencing-with-release-times-and-deadlines.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate sequencing-with-release-times-and-deadlines.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -8222,8 +8157,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let n = sizes.len()
   let total = sizes.sum()
   let config = x.optimal_config
-  let sel = range(n).filter(i => config.at(i) == 1)
-  let unsel = range(n).filter(i => config.at(i) == 0)
+  let sel = range(n).filter(i => config.at(i))
+  let unsel = range(n).filter(i => not config.at(i))
   let sel-sum = sel.map(i => sizes.at(i)).sum(default: 0)
   let unsel-sum = unsel.map(i => sizes.at(i)).sum(default: 0)
   [
@@ -8232,12 +8167,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       One of Karp's 21 NP-complete problems @karp1972, listed as SP12 in Garey & Johnson @garey1979. Partition is the special case of Subset Sum where the target equals half the total sum. Though NP-complete, it is only _weakly_ NP-hard: a dynamic-programming algorithm runs in $O(n dot B_"total")$ pseudo-polynomial time, where $B_"total" = sum_i s(a_i)$. The best known exact algorithm is the $O^*(2^(n slash 2))$ meet-in-the-middle approach of Schroeppel and Shamir (1981).
 
-      *Example.* Let $A = {#sizes.map(s => str(s)).join(", ")}$ ($n = #n$, total sum $= #total$). Setting $A' = {#sel.map(i => str(sizes.at(i))).join(", ")}$ (indices #sel.map(str).join(", ")) gives sum $#sel.map(i => str(sizes.at(i))).join(" + ") = #sel-sum = #total slash 2$, and $A without A' = {#unsel.map(i => str(sizes.at(i))).join(", ")}$ also sums to $#unsel-sum$. Hence a balanced partition exists.
+      *Example.* Let $A = {#sizes.map(s => str(s)).join(", ")}$ ($n = #n$, total sum $= #total$). Setting $A' = {#sel.map(i => str(sizes.at(i))).join(", ")}$ (indices #fmt-values(sel)) gives sum $#sel.map(i => str(sizes.at(i))).join(" + ") = #sel-sum = #total slash 2$, and $A without A' = {#unsel.map(i => str(sizes.at(i))).join(", ")}$ also sums to $#unsel-sum$. Hence a balanced partition exists.
 
       #pred-commands(
         "pred create --example Partition -o partition.json",
         "pred solve partition.json",
-        "pred evaluate partition.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate partition.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -8260,9 +8195,9 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   // Alphabet mapping: 0->a, 1->b, 2->c, ...
   let alpha-map = range(alpha-size).map(i => str.from-unicode(97 + i))
   let fmt-str(s) = "\"" + s.map(c => alpha-map.at(c)).join("") + "\""
-  // Optimal config includes padding; extract non-padding prefix
+  // The optional entries after the witness are padding.
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let w-cfg = sol.config.filter(c => c < alpha-size)
+  let w-cfg = sol.config.filter(c => c != none)
   let w = w-cfg.map(c => alpha-map.at(c))
   let w-str = fmt-str(w-cfg)
   let w-len = w.len()
@@ -8295,7 +8230,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ShortestCommonSupersequence -o shortest-common-supersequence.json",
         "pred solve shortest-common-supersequence.json",
-        "pred evaluate shortest-common-supersequence.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate shortest-common-supersequence.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -8346,7 +8281,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let fmt-str(s) = "\"" + s.map(c => alpha-map.at(c)).join("") + "\""
   // Optimal config includes padding; extract non-padding prefix
   let sol = (config: x.optimal_config, metric: x.optimal_value)
-  let w-cfg = sol.config.filter(c => c < alpha-size)
+  let w-cfg = sol.config.filter(c => c != none)
   let w = w-cfg.map(c => alpha-map.at(c))
   let w-str = fmt-str(w-cfg)
   let w-len = w.len()
@@ -8383,7 +8318,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ShortestCommonSuperstring -o shortest-common-superstring.json",
         "pred solve shortest-common-superstring.json",
-        "pred evaluate shortest-common-superstring.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate shortest-common-superstring.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -8455,7 +8390,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example StringToStringCorrection -o string-to-string-correction.json",
         "pred solve string-to-string-correction.json",
-        "pred evaluate string-to-string-correction.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate string-to-string-correction.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -8558,7 +8493,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
           #pred-commands(
             "pred create --example MinimumExternalMacroDataCompression -o min-emdc.json",
             "pred solve min-emdc.json",
-            "pred evaluate min-emdc.json --config " + x.optimal_config.map(str).join(","),
+            "pred evaluate min-emdc.json --config " + cli-config(x.optimal_config),
           )
         ]
       }
@@ -8585,7 +8520,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumInternalMacroDataCompression -o min-imdc.json",
         "pred solve min-imdc.json",
-        "pred evaluate min-imdc.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate min-imdc.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -8632,7 +8567,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let gates = x.instance.gate_types
   let ws = x.instance.arc_weights
   let cfg = x.optimal_config
-  let sel-arcs = range(arcs.len()).filter(i => cfg.at(i) == 1)
+  let sel-arcs = range(arcs.len()).filter(i => cfg.at(i))
   let total = sel-arcs.map(i => ws.at(i)).sum()
   [
     #problem-def("MinimumWeightAndOrGraph")[
@@ -8648,7 +8583,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumWeightAndOrGraph -o mwaog.json",
         "pred solve mwaog.json --solver brute-force",
-        "pred evaluate mwaog.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mwaog.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -8663,7 +8598,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let ni = inputs.len()
   let no = outputs.len()
   let cfg = x.optimal_config
-  let sel-pairs = range(cfg.len()).filter(i => cfg.at(i) == 1)
+  let sel-pairs = cfg.flatten().enumerate().filter(((i, selected)) => selected).map(((i, _)) => i)
   let count = sel-pairs.len()
   [
     #problem-def("MinimumFaultDetectionTestSet")[
@@ -8671,12 +8606,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Fault detection test sets arise in hardware testing: each input-output path through a circuit's DAG representation exercises the internal components it traverses, while the boundary pins themselves are fixed sources and sinks. The problem therefore asks for the fewest test pairs whose induced paths cover all internal vertices. It generalises Set Cover over a structured family of subsets induced by DAG reachability.#footnote[No algorithm improving on brute-force enumeration of all $2^(|I| dot |O|)$ input-output pair subsets is known for the general case.]
 
-      *Example.* Consider $n = #n$ vertices with inputs $I = {#inputs.map(str).join(", ")}$ and outputs $O = {#outputs.map(str).join(", ")}$. The internal vertices are ${2, 3, 4}$. Arcs: #{arcs.map(a => $#(a.at(0)) arrow.r #(a.at(1))$).join(", ")}. Selecting pair $(#(inputs.at(0)), #(outputs.at(0)))$ covers internal vertices ${2, 3}$, and pair $(#(inputs.at(1)), #(outputs.at(1)))$ covers internal vertices ${3, 4}$. Their union is all internal vertices, giving an optimal count of $#count$.
+      *Example.* Consider $n = #n$ vertices with inputs $I = {#fmt-values(inputs)}$ and outputs $O = {#fmt-values(outputs)}$. The internal vertices are ${2, 3, 4}$. Arcs: #{arcs.map(a => $#(a.at(0)) arrow.r #(a.at(1))$).join(", ")}. Selecting pair $(#(inputs.at(0)), #(outputs.at(0)))$ covers internal vertices ${2, 3}$, and pair $(#(inputs.at(1)), #(outputs.at(1)))$ covers internal vertices ${3, 4}$. Their union is all internal vertices, giving an optimal count of $#count$.
 
       #pred-commands(
         "pred create --example MinimumFaultDetectionTestSet -o mfdts.json",
         "pred solve mfdts.json --solver brute-force",
-        "pred evaluate mfdts.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mfdts.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -8690,7 +8625,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let weights = x.instance.weights
   let config = x.optimal_config
   let opt-val = metric-value(x.optimal_value)
-  let removed = range(na).filter(i => config.at(i) == 1)
+  let removed = range(na).filter(i => config.at(i))
   [
     #problem-def("MinimumFeedbackArcSet")[
       Given a directed graph $G = (V, A)$, find a minimum-size subset $A' subset.eq A$ such that $G - A'$ is a directed acyclic graph (DAG). Equivalently, $A'$ must contain at least one arc from every directed cycle in $G$.
@@ -8702,7 +8637,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumFeedbackArcSet -o minimum-feedback-arc-set.json",
         "pred solve minimum-feedback-arc-set.json",
-        "pred evaluate minimum-feedback-arc-set.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate minimum-feedback-arc-set.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -8716,7 +8651,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let K = x.instance.budget
   let L = x.instance.max_cycle_length
   let config = x.optimal_config
-  let removed-indices = config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let removed-indices = config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   let removed-edges = removed-indices.map(i => edges.at(i))
   let blue = graph-colors.at(0)
   let gray = luma(180)
@@ -8733,7 +8668,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example PartialFeedbackEdgeSet -o partial-feedback-edge-set.json",
         "pred solve partial-feedback-edge-set.json",
-        "pred evaluate partial-feedback-edge-set.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate partial-feedback-edge-set.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -8771,7 +8706,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let x = load-model-example("MultipleChoiceBranching")
   let nv = graph-num-vertices(x.instance)
   let arcs = x.instance.graph.arcs
-  let chosen = x.optimal_config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+  let chosen = x.optimal_config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
   [
     #problem-def("MultipleChoiceBranching")[
       Given a directed graph $G = (V, A)$, arc weights $w: A -> ZZ^+$, a partition $A_1, A_2, dots, A_m$ of $A$, and a threshold $K in ZZ^+$, determine whether there exists a subset $A' subset.eq A$ with $sum_(a in A') w(a) >= K$ such that every vertex has in-degree at most one in $(V, A')$, the selected subgraph $(V, A')$ is acyclic, and $|A' inter A_i| <= 1$ for every partition group.
@@ -8785,7 +8720,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MultipleChoiceBranching -o multiple-choice-branching.json",
         "pred solve multiple-choice-branching.json",
-        "pred evaluate multiple-choice-branching.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate multiple-choice-branching.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -8840,7 +8775,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example AcyclicPartition -o acyclic-partition.json",
         "pred solve acyclic-partition.json",
-        "pred evaluate acyclic-partition.json --config " + config.map(str).join(","),
+        "pred evaluate acyclic-partition.json --config " + cli-config(config),
       )
 
       #figure({
@@ -8879,17 +8814,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let task-lengths = x.instance.task_lengths
   let n = task-lengths.len()
   let D = x.instance.deadline
-  let lehmer = x.optimal_config
-  // Decode Lehmer code to job permutation
-  let job-order = {
-    let avail = range(n)
-    let result = ()
-    for c in lehmer {
-      result.push(avail.at(c))
-      avail = avail.enumerate().filter(((i, v)) => i != c).map(((i, v)) => v)
-    }
-    result
-  }
+  let job-order = x.optimal_config
   // Compute Gantt schedule greedily
   let machine-end = range(m).map(_ => 0)
   let job-end = range(n).map(_ => 0)
@@ -8918,7 +8843,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example FlowShopScheduling -o flow-shop-scheduling.json",
         "pred solve flow-shop-scheduling.json",
-        "pred evaluate flow-shop-scheduling.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate flow-shop-scheduling.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -9081,7 +9006,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o job-shop-scheduling.json",
         "pred solve job-shop-scheduling.json --solver brute-force",
-        "pred evaluate job-shop-scheduling.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate job-shop-scheduling.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -9137,43 +9062,8 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let m = x.instance.num_machines
   let n = p.len()
   let cfg = x.optimal_config
-  // Decode per-machine orderings: cfg[i*n..(i+1)*n] is machine i's job order
-  let orders = range(m).map(i => cfg.slice(i * n, (i + 1) * n))
-
-  // Greedy simulation to compute start times
-  let machine-avail = range(m).map(_ => 0)
-  let job-avail = range(n).map(_ => 0)
-  let next-on = range(m).map(_ => 0)
-  let start-times = range(n).map(_ => range(m).map(_ => 0))
-  let finish-times = range(n).map(_ => range(m).map(_ => 0))
-
-  let total-tasks = n * m
-  let scheduled = 0
-  while scheduled < total-tasks {
-    // Find machine with earliest next start
-    let best-start = 999999
-    let best-machine = -1
-    for i in range(m) {
-      if next-on.at(i) < n {
-        let j = orders.at(i).at(next-on.at(i))
-        let s = calc.max(machine-avail.at(i), job-avail.at(j))
-        if s < best-start or (s == best-start and (best-machine == -1 or i < best-machine)) {
-          best-start = s
-          best-machine = i
-        }
-      }
-    }
-    let i = best-machine
-    let j = orders.at(i).at(next-on.at(i))
-    let s = calc.max(machine-avail.at(i), job-avail.at(j))
-    let f = s + p.at(j).at(i)
-    start-times.at(j).at(i) = s
-    finish-times.at(j).at(i) = f
-    machine-avail.at(i) = f
-    job-avail.at(j) = f
-    next-on.at(i) += 1
-    scheduled += 1
-  }
+  let start-times = range(n).map(j => cfg.slice(j * m, (j + 1) * m))
+  let finish-times = range(n).map(j => range(m).map(i => start-times.at(j).at(i) + p.at(j).at(i)))
 
   let makespan = calc.max(..range(n).map(j => calc.max(..range(m).map(i => finish-times.at(j).at(i)))))
 
@@ -9184,23 +9074,23 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       2. *Job constraint:* Each job occupies at most one machine at a time.
       Unlike flow-shop or job-shop scheduling, there is no prescribed order for a job's tasks across machines.
     ][
-      Open Shop Scheduling is problem SS14 in Garey and Johnson's catalog @garey1979 (decision version: does a schedule exist with makespan $<= D$?). NP-completeness for $m >= 3$ machines was established by Gonzalez and Sahni via reduction from Partition @gonzalez1976. The problem is solvable in polynomial time for $m = 2$ and also for the preemptive variant with any $m$ @gonzalez1976. This codebase evaluates a candidate schedule by simulating a greedy active schedule: for each step, the machine with the earliest feasible next-job start is processed next. The configuration encodes one permutation of jobs per machine (direct indices), giving $(n!)^m$ candidate orderings.
+      Open Shop Scheduling is problem SS14 in Garey and Johnson's catalog @garey1979 (decision version: does a schedule exist with makespan $<= D$?). NP-completeness for $m >= 3$ machines was established by Gonzalez and Sahni via reduction from Partition @gonzalez1976. The problem is solvable in polynomial time for $m = 2$ and also for the preemptive variant with any $m$ @gonzalez1976. A configuration directly records the nonnegative start time $sigma(j,i)$ of every operation in job-major order. This represents both machine-side and job-side ordering decisions without requiring a greedy reconstruction.
 
       *Example.* Let $m = #m$ machines and $n = #n$ jobs with processing times
       #align(center, math.equation([$P = #math.mat(..p.map(row => row.map(v => [#v])))$]))
-      The canonical optimal orderings are:
+      The canonical optimal start-time matrix is:
       #align(center, table(
-        columns: 2,
-        align: (left, left),
-        table.header([Machine], [Job order]),
-        ..range(m).map(i => ([M#(i+1)], orders.at(i).map(j => [$J_#(j+1)$]).join[$,$])).flatten()
+        columns: m + 1,
+        align: center,
+        table.header([Job], ..range(m).map(i => [M#(i+1)])),
+        ..range(n).map(j => ([J#(j+1)], ..start-times.at(j).map(s => [#s]))).flatten()
       ))
       giving the Gantt chart in @fig:openshop and makespan *#makespan*.
 
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o open-shop-scheduling.json",
         "pred solve open-shop-scheduling.json",
-        "pred evaluate open-shop-scheduling.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate open-shop-scheduling.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -9272,12 +9162,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
           ([$c_#(i+1)$],) + schedules.at(i).map(b => [#bit(b)]) + ([#config.at(i)],)
         }) + (([$overline(R)$],) + reqs.map(r => [*#r*]) + ([],),)).flatten(),
       ))
-      This uses $sum f = #total-workers <= #n-workers$ workers. The coverage $(#coverage.map(str).join(", "))$ meets $overline(R)$ component-wise, so the instance is feasible.
+      This uses $sum f = #total-workers <= #n-workers$ workers. The coverage $(#fmt-values(coverage))$ meets $overline(R)$ component-wise, so the instance is feasible.
 
       #pred-commands(
         "pred create --example StaffScheduling -o staff.json",
         "pred solve staff.json",
-        "pred evaluate staff.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate staff.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -9301,7 +9191,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
 #{
   let x = load-model-example("TimetableDesign")
-  let assignments = x.optimal_config.enumerate().filter(((idx, value)) => value == 1).map(((idx, value)) => (
+  let assignments = x.optimal_config.flatten().enumerate().filter(((idx, selected)) => selected).map(((idx, _)) => (
     calc.floor(idx / (x.instance.num_tasks * x.instance.num_periods)),
     calc.floor(calc.rem(idx, x.instance.num_tasks * x.instance.num_periods) / x.instance.num_periods),
     calc.rem(idx, x.instance.num_periods),
@@ -9373,7 +9263,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MultiprocessorScheduling -o multiprocessor-scheduling.json",
         "pred solve multiprocessor-scheduling.json",
-        "pred evaluate multiprocessor-scheduling.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate multiprocessor-scheduling.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -9448,12 +9338,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Production Planning is the lot-sizing feasibility problem SS21 in Garey & Johnson @garey1979. Florian, Lenstra, and Rinnooy Kan show that the general problem is NP-complete even under strong restrictions, while also giving pseudo-polynomial dynamic-programming algorithms for capacitated variants @florianLenstraRinnooyKan1980. The implementation in this repository uses one bounded integer variable per period, so the registered exact baseline explores the direct witness space $product_i (c_i + 1)$; under the uniform-capacity bound $C = max_i c_i$, this becomes $O^*((C + 1)^n)$#footnote[This is the search bound induced by the configuration space exposed by the implementation, not a literature-best exact algorithm claim.].
 
-      *Example.* Consider the canonical instance with #n periods, demands $(#demands.map(str).join(", "))$, capacities $(#capacities.map(str).join(", "))$, setup costs $(#setup-costs.map(str).join(", "))$, production costs $(#production-costs.map(str).join(", "))$, inventory costs $(#inventory-costs.map(str).join(", "))$, and budget $B = #bound$. The satisfying production plan $x = (#plan.map(str).join(", "))$ yields prefix inventories $(#inventory.map(str).join(", "))$. The verifier therefore accepts, and its cost breakdown is $#production-total + #inventory-total + #setup-total = #(production-total + inventory-total + setup-total) <= #bound$.
+      *Example.* Consider the canonical instance with #n periods, demands $(#fmt-values(demands))$, capacities $(#fmt-values(capacities))$, setup costs $(#fmt-values(setup-costs))$, production costs $(#fmt-values(production-costs))$, inventory costs $(#fmt-values(inventory-costs))$, and budget $B = #bound$. The satisfying production plan $x = (#fmt-values(plan))$ yields prefix inventories $(#fmt-values(inventory))$. The verifier therefore accepts, and its cost breakdown is $#production-total + #inventory-total + #setup-total = #(production-total + inventory-total + setup-total) <= #bound$.
 
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o production-planning.json",
         "pred solve production-planning.json --solver brute-force",
-        "pred evaluate production-planning.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate production-planning.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -9490,7 +9380,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o capacity-assignment.json",
         "pred solve capacity-assignment.json --solver brute-force",
-        "pred evaluate capacity-assignment.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate capacity-assignment.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -9532,7 +9422,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example PrecedenceConstrainedScheduling -o precedence-constrained-scheduling.json",
         "pred solve precedence-constrained-scheduling.json",
-        "pred evaluate precedence-constrained-scheduling.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate precedence-constrained-scheduling.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -9565,7 +9455,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SchedulingWithIndividualDeadlines -o scheduling-with-individual-deadlines.json",
         "pred solve scheduling-with-individual-deadlines.json",
-        "pred evaluate scheduling-with-individual-deadlines.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate scheduling-with-individual-deadlines.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -9627,9 +9517,9 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let precs = x.instance.precedences
   let d_max = lengths.fold(0, (acc, l) => acc + l)
   let cfg = x.optimal_config
-  // For each task t, collect active time slots from the flat binary config
+  // For each task, collect its active time slots.
   let active-slots = range(n).map(t =>
-    range(d_max).filter(u => cfg.at(t * d_max + u) == 1)
+    range(d_max).filter(u => cfg.at(t).at(u))
   )
   let makespan = x.optimal_value
   [
@@ -9640,14 +9530,14 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
       The makespan is $max_{t in T} (max S(t) + 1)$.
     ][
-      Preemptive Scheduling is problem A5 SS6 in Garey & Johnson @garey1979. NP-complete in general; the special case without precedences ($m$ arbitrary) is solvable in polynomial time (McNaughton's wrap-around algorithm), and the preemptive open-shop variant is also polynomial. The configuration representation is a binary vector of length $n dot D_"max"$ encoding per-slot assignments.
+      Preemptive Scheduling is problem A5 SS6 in Garey & Johnson @garey1979. NP-complete in general; the special case without precedences ($m$ arbitrary) is solvable in polynomial time (McNaughton's wrap-around algorithm), and the preemptive open-shop variant is also polynomial. The configuration is an $n times D_"max"$ Boolean matrix encoding per-slot assignments.
 
-      *Example.* Let $n = #n$ tasks with lengths $(#lengths.map(str).join(", "))$, $m = #m$ processors, and precedences #{precs.map(p => $t_#(p.at(0)) prec t_#(p.at(1))$).join(", ")}. Optimal makespan: $#makespan$. Schedule: #range(n).map(t => [$t_#t$ at slots $[#active-slots.at(t).map(str).join(", ")]$]).join("; ").
+      *Example.* Let $n = #n$ tasks with lengths $(#fmt-values(lengths))$, $m = #m$ processors, and precedences #{precs.map(p => $t_#(p.at(0)) prec t_#(p.at(1))$).join(", ")}. Optimal makespan: $#makespan$. Schedule: #range(n).map(t => [$t_#t$ at slots $[#active-slots.at(t).map(str).join(", ")]$]).join("; ").
 
       #pred-commands(
         "pred create --example PreemptiveScheduling -o preemptive-scheduling.json",
         "pred solve preemptive-scheduling.json",
-        "pred evaluate preemptive-scheduling.json --config " + cfg.map(str).join(","),
+        "pred evaluate preemptive-scheduling.json --config " + cli-config(cfg),
       )
     ]
   ]
@@ -9669,7 +9559,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Scheduling to Minimize Weighted Completion Time is problem A5 SS13 in Garey & Johnson @garey1979. NP-complete for $m = 2$ by reduction from Partition @lenstra1977, and NP-complete in the strong sense for arbitrary $m$. For a fixed assignment of tasks to processors, Smith's rule gives the optimal ordering on each processor, reducing the search space to $m^n$ processor assignments @smith1956. The problem is solvable in polynomial time when all lengths are equal or when all weights are equal @conway1967 @horn1973.
 
-      *Example.* Let $T = {t_1, dots, t_#ntasks}$ with lengths $(#lengths.map(str).join(", "))$, weights $(#weights.map(str).join(", "))$, and $m = #m$ processors. The optimal assignment $(#sigma.map(v => str(v + 1)).join(", "))$ achieves total weighted completion time #x.optimal_value:
+      *Example.* Let $T = {t_1, dots, t_#ntasks}$ with lengths $(#fmt-values(lengths))$, weights $(#fmt-values(weights))$, and $m = #m$ processors. The optimal assignment $(#sigma.map(v => str(v + 1)).join(", "))$ achieves total weighted completion time #x.optimal_value:
       #for p in range(m) [
         - Processor #(p + 1): ${#tasks-by-proc.at(p).map(i => $t_#(i + 1)$).join(", ")}$#if tasks-by-proc.at(p).len() > 0 {
           let proc-tasks = tasks-by-proc.at(p)
@@ -9686,7 +9576,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o scheduling-wct.json",
         "pred solve scheduling-wct.json --solver brute-force",
-        "pred evaluate scheduling-wct.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate scheduling-wct.json --config " + cli-config(x.optimal_config),
       )
 
       #figure({
@@ -9744,7 +9634,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let max-t = calc.max(..range(ntasks).map(i => deadline.at(i)))
   [
     #problem-def("SequencingWithinIntervals")[
-      Given a finite set $T$ of tasks and, for each $t in T$, a release time $r(t) >= 0$, a deadline $d(t) >= 0$, and a processing length $ell(t) in ZZ^+$ satisfying $r(t) + ell(t) <= d(t)$, determine whether there exists a feasible schedule $sigma: T -> ZZ_(>= 0)$ such that for each $t in T$: (1) $sigma(t) >= r(t)$, (2) $sigma(t) + ell(t) <= d(t)$, and (3) for all $t' in T backslash {t}$, either $sigma(t') + ell(t') <= sigma(t)$ or $sigma(t') >= sigma(t) + ell(t)$.
+      Given a finite set $T$ of tasks and, for each $t in T$, a release time $r(t) >= 0$, a deadline $d(t) >= 0$, and a processing length $ell(t) in ZZ^+$, determine whether there exists a feasible schedule $sigma: T -> ZZ_(>= 0)$ such that for each $t in T$: (1) $sigma(t) >= r(t)$, (2) $sigma(t) + ell(t) <= d(t)$, and (3) for all $t' in T backslash {t}$, either $sigma(t') + ell(t') <= sigma(t)$ or $sigma(t') >= sigma(t) + ell(t)$.
     ][
       Sequencing Within Intervals is problem SS1 in Garey & Johnson @garey1979, proved NP-complete via reduction from Partition (Theorem 3.8). Each task $t$ must execute non-preemptively during the interval $[r(t), d(t))$, occupying $ell(t)$ consecutive time units on a single machine, and no two tasks may overlap.
 
@@ -9761,7 +9651,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SequencingWithinIntervals -o sequencing-within-intervals.json",
         "pred solve sequencing-within-intervals.json",
-        "pred evaluate sequencing-within-intervals.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate sequencing-within-intervals.json --config " + cli-config(x.optimal_config),
       )
 
       Each task can only start within its window $[r(t), d(t) - ell(t)]$, and the windows overlap, so finding a non-overlapping assignment is non-trivial. One feasible schedule places the tasks at #range(ntasks).map(i => $[#starts.at(i), #(starts.at(i) + lengths.at(i)))$).join($,$):
@@ -9821,17 +9711,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let precs = x.instance.precedences
   let sol = (config: x.optimal_config, metric: x.optimal_value)
   let tardy-count = metric-value(sol.metric)
-  // Decode Lehmer code to permutation (schedule order)
-  let lehmer = sol.config
-  let schedule = {
-    let avail = range(ntasks)
-    let result = ()
-    for c in lehmer {
-      result.push(avail.at(c))
-      avail = avail.enumerate().filter(((i, v)) => i != c).map(((i, v)) => v)
-    }
-    result
-  }
+  let schedule = sol.config
   // Compute inverse: task-pos[task] = position
   let task-pos = range(ntasks).map(task => {
     schedule.enumerate().filter(((p, t)) => t == task).at(0).at(0)
@@ -9851,7 +9731,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example MinimumTardinessSequencing -o minimum-tardiness-sequencing.json",
         "pred solve minimum-tardiness-sequencing.json",
-        "pred evaluate minimum-tardiness-sequencing.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate minimum-tardiness-sequencing.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -9904,16 +9784,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let ntasks = lengths.len()
   let sol = (config: x.optimal_config, metric: x.optimal_value)
   let opt = metric-value(sol.metric)
-  let lehmer = sol.config
-  let schedule = {
-    let avail = range(ntasks)
-    let result = ()
-    for c in lehmer {
-      result.push(avail.at(c))
-      avail = avail.enumerate().filter(((i, v)) => i != c).map(((i, v)) => v)
-    }
-    result
-  }
+  let schedule = sol.config
   let starts = ()
   let finishes = ()
   let elapsed = 0
@@ -9934,7 +9805,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SequencingToMinimizeWeightedCompletionTime -o sequencing-to-minimize-weighted-completion-time.json",
         "pred solve sequencing-to-minimize-weighted-completion-time.json",
-        "pred evaluate sequencing-to-minimize-weighted-completion-time.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate sequencing-to-minimize-weighted-completion-time.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -9975,16 +9846,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let deadlines = x.instance.deadlines
   let bound = x.instance.bound
   let njobs = lengths.len()
-  let lehmer = x.optimal_config
-  let schedule = {
-    let avail = range(njobs)
-    let result = ()
-    for c in lehmer {
-      result.push(avail.at(c))
-      avail = avail.enumerate().filter(((i, v)) => i != c).map(((i, v)) => v)
-    }
-    result
-  }
+  let schedule = x.optimal_config
   let completions = {
     let t = 0
     let result = ()
@@ -10013,7 +9875,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SequencingToMinimizeWeightedTardiness -o sequencing-to-minimize-weighted-tardiness.json",
         "pred solve sequencing-to-minimize-weighted-tardiness.json",
-        "pred evaluate sequencing-to-minimize-weighted-tardiness.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate sequencing-to-minimize-weighted-tardiness.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -10059,16 +9921,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let costs = x.instance.costs
   let precs = x.instance.precedences
   let ntasks = costs.len()
-  let lehmer = x.optimal_config
-  let schedule = {
-    let avail = range(ntasks)
-    let result = ()
-    for c in lehmer {
-      result.push(avail.at(c))
-      avail = avail.enumerate().filter(((i, v)) => i != c).map(((i, v)) => v)
-    }
-    result
-  }
+  let schedule = x.optimal_config
   let prefix-sums = {
     let running = 0
     let result = ()
@@ -10092,7 +9945,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SequencingToMinimizeMaximumCumulativeCost -o sequencing-to-minimize-maximum-cumulative-cost.json",
         "pred solve sequencing-to-minimize-maximum-cumulative-cost.json",
-        "pred evaluate sequencing-to-minimize-maximum-cumulative-cost.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate sequencing-to-minimize-maximum-cumulative-cost.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -10166,7 +10019,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SequencingToMinimizeTardyTaskWeight -o sequencing-to-minimize-tardy-task-weight.json",
         "pred solve sequencing-to-minimize-tardy-task-weight.json",
-        "pred evaluate sequencing-to-minimize-tardy-task-weight.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate sequencing-to-minimize-tardy-task-weight.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -10207,7 +10060,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example SequencingWithDeadlinesAndSetUpTimes -o sequencing-with-deadlines-and-set-up-times.json",
         "pred solve sequencing-with-deadlines-and-set-up-times.json",
-        "pred evaluate sequencing-with-deadlines-and-set-up-times.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate sequencing-with-deadlines-and-set-up-times.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -10233,7 +10086,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o integral-flow-homologous-arcs.json",
         "pred solve integral-flow-homologous-arcs.json --solver brute-force",
-        "pred evaluate integral-flow-homologous-arcs.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate integral-flow-homologous-arcs.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -10345,12 +10198,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
       NP-completeness was proved by Even, Itai, and Shamir via reduction from 3-SAT @even1976. The problem remains NP-complete even when all arc capacities are 1 and $R_1 = 1$. No sub-exponential exact algorithm is known; brute-force enumeration over $(C + 1)^(2|A|)$ flow assignments dominates, where $C = max_(a in A) c(a)$.#footnote[No algorithm improving on brute-force is known for Directed Two-Commodity Integral Flow.]
 
-      *Example.* Consider a directed graph with $n = #nv$ vertices and $|A| = #m$ arcs with capacities $(#caps.map(str).join(", "))$, sources $s_1 = v_#s1$, $s_2 = v_#s2$, sinks $t_1 = v_#t1$, $t_2 = v_#t2$, and requirements $R_1 = #R1$, $R_2 = #R2$. Commodity 1 routes along #c1-arcs.map(i => $(v_#(arcs-j.at(i).at(0)), v_#(arcs-j.at(i).at(1)))$).join(", ") and commodity 2 along #c2-arcs.map(i => $(v_#(arcs-j.at(i).at(0)), v_#(arcs-j.at(i).at(1)))$).join(", "), satisfying all capacity and conservation constraints.
+      *Example.* Consider a directed graph with $n = #nv$ vertices and $|A| = #m$ arcs with capacities $(#fmt-values(caps))$, sources $s_1 = v_#s1$, $s_2 = v_#s2$, sinks $t_1 = v_#t1$, $t_2 = v_#t2$, and requirements $R_1 = #R1$, $R_2 = #R2$. Commodity 1 routes along #c1-arcs.map(i => $(v_#(arcs-j.at(i).at(0)), v_#(arcs-j.at(i).at(1)))$).join(", ") and commodity 2 along #c2-arcs.map(i => $(v_#(arcs-j.at(i).at(0)), v_#(arcs-j.at(i).at(1)))$).join(", "), satisfying all capacity and conservation constraints.
 
       #pred-commands(
         "pred create --example DirectedTwoCommodityIntegralFlow -o d2cif.json",
         "pred solve d2cif.json",
-        "pred evaluate d2cif.json --config " + config.map(str).join(","),
+        "pred evaluate d2cif.json --config " + cli-config(config),
       )
 
       #figure(
@@ -10414,12 +10267,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
       The brute-force bound $(C + 1)^(|A|)$ arises from enumerating all possible integral flow vectors, where $C = max_(a in A) c(a)$.#footnote[No sub-exponential exact algorithm is known for Minimum Edge-Cost Flow.]
 
-      *Example.* Consider a directed graph with $n = #nv$ vertices, source $s = v_#src$, sink $t = v_#snk$, requirement $R = #R$, and $|A| = #{arcs-j.len()}$ arcs with capacities $(#caps.map(str).join(", "))$ and prices $(#prices-j.map(str).join(", "))$. The optimal flow $f = (#flow.map(str).join(", "))$ activates the arcs #opt-arc-idx.map(i => $(v_#(arcs-j.at(i).at(0)), v_#(arcs-j.at(i).at(1)))$).join(", ") for a total edge cost of $#opt-arc-idx.map(i => str(prices-j.at(i))).join(" + ") = #cost$.
+      *Example.* Consider a directed graph with $n = #nv$ vertices, source $s = v_#src$, sink $t = v_#snk$, requirement $R = #R$, and $|A| = #{arcs-j.len()}$ arcs with capacities $(#fmt-values(caps))$ and prices $(#fmt-values(prices-j))$. The optimal flow $f = (#fmt-values(flow))$ activates the arcs #opt-arc-idx.map(i => $(v_#(arcs-j.at(i).at(0)), v_#(arcs-j.at(i).at(1)))$).join(", ") for a total edge cost of $#opt-arc-idx.map(i => str(prices-j.at(i))).join(" + ") = #cost$.
 
       #pred-commands(
         "pred create --example MinimumEdgeCostFlow -o mecf.json",
         "pred solve mecf.json",
-        "pred evaluate mecf.json --config " + flow.map(str).join(","),
+        "pred evaluate mecf.json --config " + cli-config(flow),
       )
 
       #figure(
@@ -10501,12 +10354,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
       The registered polynomial bound $(|V| + |A|)^6$ is a conservative placeholder honoring the polynomial-time solvability via the linear-programming formulation; sharper strongly-polynomial bounds are available for specific algorithms (e.g., Orlin's enhanced capacity-scaling minimum-cost flow algorithm).
 
-      *Example.* On the canonical instance ($n = 4$ vertices, source $s = v_#src$, sink $t = v_#snk$, $|A| = #{arcs-j.len()}$ arcs with capacities $(#caps.map(str).join(", "))$ and costs $(#costs-j.map(str).join(", "))$), the source out-capacity bounds the flow value at $|f| <= 2 + 1 = 3$, and this is achievable: routing 2 units along $v_0 -> v_1$ and 1 unit along $v_0 -> v_2$, balanced by 1 unit through the lateral $v_1 -> v_2$ and 1 unit on $v_1 -> v_3$, gives $f = (#flow.map(str).join(", "))$ with $|f| = 3$ and total cost $2 dot 1 + 1 dot 0 + 1 dot 0 + 1 dot 1 + 2 dot 2 = 7$. The scalar score is $M dot (B - 3) + 7 = 8 dot 4 + 7 = 39$ where $B = 7$ and $M = 8$.
+      *Example.* On the canonical instance ($n = 4$ vertices, source $s = v_#src$, sink $t = v_#snk$, $|A| = #{arcs-j.len()}$ arcs with capacities $(#fmt-values(caps))$ and costs $(#fmt-values(costs-j))$), the source out-capacity bounds the flow value at $|f| <= 2 + 1 = 3$, and this is achievable: routing 2 units along $v_0 -> v_1$ and 1 unit along $v_0 -> v_2$, balanced by 1 unit through the lateral $v_1 -> v_2$ and 1 unit on $v_1 -> v_3$, gives $f = (#fmt-values(flow))$ with $|f| = 3$ and total cost $2 dot 1 + 1 dot 0 + 1 dot 0 + 1 dot 1 + 2 dot 2 = 7$. The scalar score is $M dot (B - 3) + 7 = 8 dot 4 + 7 = 39$ where $B = 7$ and $M = 8$.
 
       #pred-commands(
         "pred create --example MinimumCostMaximumFlow -o mcmf.json",
         "pred solve mcmf.json",
-        "pred evaluate mcmf.json --config " + flow.map(str).join(","),
+        "pred evaluate mcmf.json --config " + cli-config(flow),
       )
     ]
   ]
@@ -10528,12 +10381,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
       The registered polynomial bound $(|V| + |A|)^6$ is a conservative placeholder honoring polynomial-time solvability via the linear-programming formulation; sharper strongly-polynomial bounds are available for specific min-cost-flow algorithms.
 
-      *Example.* On the canonical instance ($n = #{arcs-j.fold(0, (acc, a) => calc.max(acc, a.at(0), a.at(1))) + 1}$ vertices, $|A| = #{arcs-j.len()}$ arcs with capacities $(#caps.map(str).join(", "))$ and signed costs $(#costs-j.map(str).join(", "))$) there are two competing cycles through vertex $v_0$: cycle $A = (v_0 -> v_1 -> v_0)$ has per-unit cost $2 + (-3) = -1$ and capacity $2$, while cycle $B = (v_0 -> v_2 -> v_0)$ has per-unit cost $1 + (-4) = -3$ and capacity $1$. Cycle $B$ is cheaper per unit but smaller; cycle $A$ is more expensive per unit but larger. Both reduce cost, so the optimum pushes each cycle to capacity, giving $g = (#circ.map(str).join(", "))$ with total cost $2 dot 2 + 2 dot (-3) + 1 dot 1 + 1 dot (-4) = -5$. By comparison, running only cycle $A$ gives cost $-2$, only cycle $B$ gives $-3$, and the zero circulation gives $0$, so the optimum $-5$ strictly beats every alternative.
+      *Example.* On the canonical instance ($n = #{arcs-j.fold(0, (acc, a) => calc.max(acc, a.at(0), a.at(1))) + 1}$ vertices, $|A| = #{arcs-j.len()}$ arcs with capacities $(#fmt-values(caps))$ and signed costs $(#fmt-values(costs-j))$) there are two competing cycles through vertex $v_0$: cycle $A = (v_0 -> v_1 -> v_0)$ has per-unit cost $2 + (-3) = -1$ and capacity $2$, while cycle $B = (v_0 -> v_2 -> v_0)$ has per-unit cost $1 + (-4) = -3$ and capacity $1$. Cycle $B$ is cheaper per unit but smaller; cycle $A$ is more expensive per unit but larger. Both reduce cost, so the optimum pushes each cycle to capacity, giving $g = (#fmt-values(circ))$ with total cost $2 dot 2 + 2 dot (-3) + 1 dot 1 + 1 dot (-4) = -5$. By comparison, running only cycle $A$ gives cost $-2$, only cycle $B$ gives $-3$, and the zero circulation gives $0$, so the optimum $-5$ strictly beats every alternative.
 
       #pred-commands(
         "pred create --example MinimumCostCirculation -o mcc.json",
         "pred solve mcc.json",
-        "pred evaluate mcc.json --config " + circ.map(str).join(","),
+        "pred evaluate mcc.json --config " + cli-config(circ),
       )
     ]
   ]
@@ -10556,7 +10409,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example IntegralFlowBundles -o integral-flow-bundles.json",
         "pred solve integral-flow-bundles.json",
-        "pred evaluate integral-flow-bundles.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate integral-flow-bundles.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -10637,7 +10490,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example IntegralFlowWithMultipliers -o integral-flow-with-multipliers.json",
         "pred solve integral-flow-with-multipliers.json --solver brute-force",
-        "pred evaluate integral-flow-with-multipliers.json --config " + config.map(str).join(","),
+        "pred evaluate integral-flow-with-multipliers.json --config " + cli-config(config),
       )
 
       #figure(
@@ -10705,7 +10558,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let relation = x.instance.relation_attrs
   let known = x.instance.known_keys
   let config = x.optimal_config
-  let Rprime = range(num-attrs).filter(i => config.at(i) == 1)
+  let Rprime = range(num-attrs).filter(i => config.at(i))
   let fmt-set(s) = ${#s.map(i => $#i$).join($,$)}$
   let fmt-fd(fd) = {
     let lhs = fmt-set(fd.at(0))
@@ -10731,7 +10584,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example AdditionalKey -o additional-key.json",
         "pred solve additional-key.json",
-        "pred evaluate additional-key.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate additional-key.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -10799,7 +10652,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ConjunctiveBooleanQuery -o conjunctive-boolean-query.json",
         "pred solve conjunctive-boolean-query.json",
-        "pred evaluate conjunctive-boolean-query.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate conjunctive-boolean-query.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -10843,7 +10696,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ConsecutiveOnesMatrixAugmentation -o consecutive-ones-matrix-augmentation.json",
         "pred solve consecutive-ones-matrix-augmentation.json --solver brute-force",
-        "pred evaluate consecutive-ones-matrix-augmentation.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate consecutive-ones-matrix-augmentation.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -10865,7 +10718,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   // Use the canonical witness {0, 1, 3}
   let cfg = x.optimal_config
   // Selected column indices
-  let selected = cfg.enumerate().filter(((i, v)) => v == 1).map(((i, v)) => i)
+  let selected = cfg.enumerate().filter(((i, v)) => v).map(((i, v)) => i)
   [
     #problem-def("ConsecutiveOnesSubmatrix")[
       Given an $m times n$ binary matrix $A$ and an integer $K$ with $0 <= K <= n$, determine whether there exists a subset of $K$ columns of $A$ whose columns can be permuted so that in each row all 1's occur consecutively (the _consecutive ones property_).
@@ -10877,7 +10730,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example ConsecutiveOnesSubmatrix -o consecutive-ones-submatrix.json",
         "pred solve consecutive-ones-submatrix.json",
-        "pred evaluate consecutive-ones-submatrix.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate consecutive-ones-submatrix.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -10889,7 +10742,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
           for i in range(m) {
             for j in range(n) {
               let val = A-int.at(i).at(j)
-              let is-selected = cfg.at(j) == 1
+              let is-selected = cfg.at(j)
               let f = if val == 1 {
                 if is-selected { graph-colors.at(0).transparentize(30%) } else { luma(200) }
               } else { white }
@@ -10948,12 +10801,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Sparse Matrix Compression appears as problem SR13 in Garey and Johnson @garey1979. It models row-overlay compression for sparse lookup tables: rows may share storage positions only when their shifted 1-entries never demand different row labels from the same slot. The implementation in this crate searches over row shifts only, then reconstructs the implied storage vector internally. This yields the direct exact bound $O(K^m dot m dot n)$ for $m$ rows and $n$ columns.#footnote[The storage vector is not enumerated as part of the configuration space. Once the shifts are fixed, every occupied slot is forced by the 1-entries of the shifted rows.]
 
-      *Example.* Let $A = #math.mat(..A-int.map(row => row.map(v => $#v$)))$ and $K = #K$. The stored config $(#cfg.map(str).join(", "))$ encodes the one-based shifts $s = (#shifts.map(str).join(", "))$. These shifts place the four row supports at positions $\{2, 5\}$, $\{3\}$, $\{4\}$, and $\{1\}$ respectively, so the supports are pairwise disjoint. The implied overlay vector is therefore $b = (#storage.map(str).join(", "))$, and this is the unique satisfying shift assignment among the $2^4 = 16$ configs in the canonical fixture.
+      *Example.* Let $A = #math.mat(..A-int.map(row => row.map(v => $#v$)))$ and $K = #K$. The stored config $(#fmt-values(cfg))$ encodes the one-based shifts $s = (#fmt-values(shifts))$. These shifts place the four row supports at positions $\{2, 5\}$, $\{3\}$, $\{4\}$, and $\{1\}$ respectively, so the supports are pairwise disjoint. The implied overlay vector is therefore $b = (#fmt-values(storage))$, and this is the unique satisfying shift assignment among the $2^4 = 16$ configs in the canonical fixture.
 
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o sparse-matrix-compression.json",
         "pred solve sparse-matrix-compression.json",
-        "pred evaluate sparse-matrix-compression.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate sparse-matrix-compression.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -11032,19 +10885,19 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let A = x.instance.matrix
   let n = A.len()
   let cfg = x.optimal_config
-  let signs = cfg.map(v => if v == 0 { $-1$ } else { $+1$ })
+  let signs = cfg.map(v => if not v { $-1$ } else { $+1$ })
   [
     #problem-def("MinimumMatrixCover")[
       Given an $n times n$ nonnegative integer matrix $A$, find a function $f: \{1, dots, n\} -> \{-1, +1\}$ minimizing $sum_(i,j) a_(i j) dot f(i) dot f(j)$.
     ][
       Minimum Matrix Cover asks for a sign assignment to rows (equivalently columns) of a square matrix that minimizes the resulting quadratic form. Each binary variable $x_i in \{0, 1\}$ encodes a sign $f(i) = 2 x_i - 1$. Since $f(i)^2 = 1$, diagonal entries contribute a constant $sum_i a_(i i)$; the optimization depends only on off-diagonal structure. The brute-force complexity is $O(2^n)$ where $n$ is the matrix dimension.#footnote[No algorithm improving on brute-force enumeration of all $2^n$ sign assignments is known for the general case.]
 
-      *Example.* Let $A$ be the #(n)$times$#(n) symmetric matrix with zero diagonal shown below. The optimal config $(#cfg.map(str).join(", "))$ assigns signs $(#signs.join(", "))$, yielding value $= #x.optimal_value$.
+      *Example.* Let $A$ be the #(n)$times$#(n) symmetric matrix with zero diagonal shown below. The optimal config $(#fmt-values(cfg))$ assigns signs $(#signs.join(", "))$, yielding value $= #x.optimal_value$.
 
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o mmc.json",
         "pred solve mmc.json",
-        "pred evaluate mmc.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mmc.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -11057,19 +10910,19 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let n = if m > 0 { M.at(0).len() } else { 0 }
   let ones = x.instance.ones
   let cfg = x.optimal_config
-  let selected-ones = ones.enumerate().filter(((k, _)) => cfg.at(k) == 1).map(((_, pos)) => pos)
+  let selected-ones = ones.enumerate().filter(((k, _)) => cfg.at(k)).map(((_, pos)) => pos)
   [
     #problem-def("MinimumMatrixDomination")[
       Given an $m times n$ binary matrix $M$, find a minimum-cardinality subset $C$ of 1-entries such that every 1-entry not in $C$ shares a row or column with some entry in $C$.
     ][
       Minimum Matrix Domination is a matrix analogue of the dominating set problem. Each binary variable corresponds to a 1-entry in row-major order; the evaluator checks that every unselected 1-entry shares a row or column with at least one selected entry. The brute-force complexity is $O(2^k)$ where $k$ is the number of 1-entries.
 
-      *Example.* Let $M$ be the #(m)$times$#(n) adjacency matrix of $P_6$ (the path on 6 vertices), which has #(ones.len()) non-zero entries. The optimal config $(#cfg.map(str).join(", "))$ selects entries at positions #selected-ones.map(((r, c)) => [(#r, #c)]).join(", "), yielding value $= #x.optimal_value$.
+      *Example.* Let $M$ be the #(m)$times$#(n) adjacency matrix of $P_6$ (the path on 6 vertices), which has #(ones.len()) non-zero entries. The optimal config $(#fmt-values(cfg))$ selects entries at positions #selected-ones.map(((r, c)) => [(#r, #c)]).join(", "), yielding value $= #x.optimal_value$.
 
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o mmd.json",
         "pred solve mmd.json",
-        "pred evaluate mmd.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mmd.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -11091,12 +10944,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
       The best known algorithms for general instances use information set decoding techniques, achieving $O(2^(0.0494 n))$ where $n$ is the block length.
 
-      *Example.* Let $H$ be the #(n)$times$#(m) binary matrix and $s = (#s.map(v => if v { "1" } else { "0" }).join(", "))$. The optimal config $(#cfg.map(str).join(", "))$ has Hamming weight $#wt$.
+      *Example.* Let $H$ be the #(n)$times$#(m) binary matrix and $s = (#fmt-values(s))$. The optimal config $(#fmt-values(cfg))$ has Hamming weight $#wt$.
 
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o mwd.json",
         "pred solve mwd.json",
-        "pred evaluate mwd.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mwd.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -11108,19 +10961,19 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   let n = A.len()
   let m = if n > 0 { A.at(0).len() } else { 0 }
   let cfg = x.optimal_config
-  let selected-cols = cfg.enumerate().filter(((_, v)) => v == 1).map(((j, _)) => j)
+  let selected-cols = cfg.enumerate().filter(((_, v)) => v).map(((j, _)) => j)
   [
     #problem-def("MinimumWeightSolutionToLinearEquations")[
       Given an $n times m$ integer matrix $A$ and an integer vector $b in ZZ^n$, find a rational vector $y in QQ^m$ satisfying $A y = b$ that minimizes $||y||_0$ (the number of non-zero entries of $y$).
     ][
       Minimum Weight Solution to Linear Equations is a sparsity-seeking variant of solving linear systems. Each binary variable $x_j$ indicates whether the $j$-th component of $y$ may be non-zero; the evaluator forms the restricted submatrix $A'$ from the selected columns and checks whether $b$ lies in its column space via integer Gaussian elimination (using i128 arithmetic for exact rational consistency). If the restricted system $A' y' = b$ is consistent, the value is the number of selected columns; otherwise the configuration is infeasible.
 
-      *Example.* Let $A$ be the $#n times #m$ matrix $A = #math.mat(..A.map(row => row.map(v => $#v$)))$ with $b = (#b.map(str).join(", "))$. The optimal config $(#cfg.map(str).join(", "))$ selects columns #selected-cols.map(str).join(", "), yielding value $= #x.optimal_value$.
+      *Example.* Let $A$ be the $#n times #m$ matrix $A = #math.mat(..A.map(row => row.map(v => $#v$)))$ with $b = (#fmt-values(b))$. The optimal config $(#fmt-values(cfg))$ selects columns #fmt-values(selected-cols), yielding value $= #x.optimal_value$.
 
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o mwsle.json",
         "pred solve mwsle.json",
-        "pred evaluate mwsle.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mwsle.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -11139,7 +10992,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o iem.json",
         "pred solve iem.json --solver brute-force",
-        "pred evaluate iem.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate iem.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -11200,7 +11053,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
   // Free column indices (those not in S)
   let free-cols = range(n).filter(j => j not in S)
   // Selected free columns from config
-  let selected = cfg.enumerate().filter(((i, v)) => v == 1).map(((i, v)) => free-cols.at(i))
+  let selected = cfg.enumerate().filter(((i, v)) => v).map(((i, v)) => free-cols.at(i))
   // Full basis: required + selected
   let basis = S + selected
   [
@@ -11209,12 +11062,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       The Feasible Basis Extension problem arises in linear programming theory and the study of simplex method pivoting rules. It was shown NP-complete by Murty @Murty1972 via a reduction from Hamiltonian Circuit, establishing that determining whether a partial basis can be extended to a feasible one is computationally intractable in general. The problem is closely related to the question of whether a given linear program has a feasible basic solution containing specified variables. The best known exact algorithm is brute-force enumeration of all $binom(n - |S|, m - |S|)$ candidate extensions, testing each for nonsingularity and non-negativity of the solution in $O(m^3)$ time.#footnote[No algorithm improving on brute-force enumeration is known for the general Feasible Basis Extension problem.]
 
-      *Example.* Consider the $#m times #n$ matrix $A = #math.mat(..A.map(row => row.map(v => $#v$)))$ with $overline(a) = (#rhs.map(str).join(", "))^top$ and required columns $S = \{#S.map(str).join(", ")\}$. We need $#(m - S.len())$ additional column from the free set $\{#free-cols.map(str).join(", ")\}$. Selecting column #selected.at(0) gives basis $B = \{#basis.map(str).join(", ")\}$, which yields $A_B^(-1) overline(a) = (4, 5, 3)^top >= 0$. Column 4 makes $A_B$ singular, and column 5 produces a negative component.
+      *Example.* Consider the $#m times #n$ matrix $A = #math.mat(..A.map(row => row.map(v => $#v$)))$ with $overline(a) = (#fmt-values(rhs))^top$ and required columns $S = \{#fmt-values(S)\}$. We need $#(m - S.len())$ additional column from the free set $\{#fmt-values(free-cols)\}$. Selecting column #selected.at(0) gives basis $B = \{#fmt-values(basis)\}$, which yields $A_B^(-1) overline(a) = (4, 5, 3)^top >= 0$. Column 4 makes $A_B$ singular, and column 5 produces a negative component.
 
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o feasible-basis-extension.json",
         "pred solve feasible-basis-extension.json --solver brute-force",
-        "pred evaluate feasible-basis-extension.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate feasible-basis-extension.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -11278,7 +11131,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
             )
           }
         }),
-        caption: [Feasible Basis Extension instance ($#m times #n$). Orange columns are required ($S = \{#S.map(str).join(", ")\}$), blue column is the selected extension. Together they form a nonsingular basis with non-negative solution.],
+        caption: [Feasible Basis Extension instance ($#m times #n$). Orange columns are required ($S = \{#fmt-values(S)\}$), blue column is the selected extension. Together they form a nonsingular basis with non-negative solution.],
       ) <fig:feasible-basis-extension>
     ]
   ]
@@ -11311,7 +11164,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o mlr.json",
         "pred solve mlr.json --solver brute-force",
-        "pred evaluate mlr.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate mlr.json --config " + cli-config(x.optimal_config),
       )
 
       #figure(
@@ -11385,7 +11238,7 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
       #pred-commands(
         "pred create --example " + problem-spec(x) + " -o ocst.json",
         "pred solve ocst.json --solver brute-force",
-        "pred evaluate ocst.json --config " + x.optimal_config.map(str).join(","),
+        "pred evaluate ocst.json --config " + cli-config(x.optimal_config),
       )
     ]
   ]
@@ -11403,12 +11256,12 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
     ][
       Square Tiling (also known as Bounded Wang Tiling) is problem GP13 in Garey and Johnson @garey1979. It was shown NP-complete via transformation from Directed Hamiltonian Path. The infinite variant (tiling the entire plane) is famously undecidable (Berger, 1966). The best known exact approach enumerates all $|T|^(N^2)$ assignments.
 
-      *Example.* Consider $|C| = #nc$ colors, $|T| = #tiles.len()$ tiles, and grid size $N = #n$. The tiles are #tiles.enumerate().map(((i, t)) => [$t_#i = chevron.l #t.at(0), #t.at(1), #t.at(2), #t.at(3) chevron.r$]).join(", "). The witness assignment $(#config.map(str).join(", "))$ places $t_#config.at(0), t_#config.at(1)$ in row 0 and $t_#config.at(2), t_#config.at(3)$ in row 1, satisfying all edge-color constraints.
+      *Example.* Consider $|C| = #nc$ colors, $|T| = #tiles.len()$ tiles, and grid size $N = #n$. The tiles are #tiles.enumerate().map(((i, t)) => [$t_#i = chevron.l #t.at(0), #t.at(1), #t.at(2), #t.at(3) chevron.r$]).join(", "). The witness assignment $(#fmt-values(config))$ places $t_#config.at(0), t_#config.at(1)$ in row 0 and $t_#config.at(2), t_#config.at(3)$ in row 1, satisfying all edge-color constraints.
 
       #pred-commands(
         "pred create --example SquareTiling -o square_tiling.json",
         "pred solve square_tiling.json",
-        "pred evaluate square_tiling.json --config " + config.map(str).join(","),
+        "pred evaluate square_tiling.json --config " + cli-config(config),
       )
     ]
   ]
@@ -11434,7 +11287,10 @@ In all graph problems below, $G = (V, E)$ denotes an undirected graph with $|V|
 
 = Reductions <sec:reductions>
 
-Each reduction is presented as a *Rule* (with linked problem names and overhead from the graph data), followed by a *Proof* (construction, correctness, variable mapping, solution extraction), and optionally a *Concrete Example* (a small instance with verified solution). Problem names in the rule title link back to their definitions in @sec:problems.
+Each reduction is presented as a *Rule* (with linked problem names and explicit parameter contracts from the graph data), followed by a *Proof* (construction, correctness, variable mapping, solution extraction), and optionally a *Concrete Example* (a small instance with verified solution). Problem names in the rule title link back to their definitions in @sec:problems.
+
+The command blocks assume `route.json` contains the explicitly chosen direct route for
+the displayed rule, extracted from the corresponding `pred path` entry.
 
 
 #let max2sat_mc = load-example("Maximum2Satisfiability", "MaxCut")
@@ -11445,16 +11301,16 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(max2sat_mc.source) + " -o max2sat.json",
-      "pred reduce max2sat.json --to " + target-spec(max2sat_mc) + " -o bundle.json",
+      "pred reduce max2sat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate max2sat.json --config " + max2sat_mc_sol.source_config.map(str).join(","),
+      "pred evaluate max2sat.json --config " + cli-config(max2sat_mc_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical source has $n = #max2sat_mc.source.instance.num_vars$ variables and #max2sat_mc.source.instance.clauses.len() two-literal clauses. The stored optimal assignment is $(#max2sat_mc_sol.source_config.map(str).join(", "))$, which satisfies all five clauses.
+    *Step 1 -- Source instance.* The canonical source has $n = #max2sat_mc.source.instance.num_vars$ variables and #max2sat_mc.source.instance.clauses.len() two-literal clauses. The stored optimal assignment is $(#fmt-values(max2sat_mc_sol.source_config))$, which satisfies all five clauses.
 
     *Step 2 -- Accumulate the cut weights.* Introduce the reference vertex $s = v_0$ and variable vertices $v_1, v_2, v_3$. After summing the per-clause contributions and deleting zero-weight edges, the target graph has the four signed edges $(s, v_2)$ with weight $-1$, $(s, v_3)$ with weight $-1$, $(v_1, v_2)$ with weight $2$, and $(v_2, v_3)$ with weight $-1$.
 
-    *Step 3 -- Verify the witness.* The target witness $(#max2sat_mc_sol.target_config.map(str).join(", "))$ puts $v_2$ and $v_3$ on the same side as $s$ and $v_1$ on the opposite side, so extraction recovers $(#max2sat_mc_sol.source_config.map(str).join(", "))$. Only edge $(v_1, v_2)$ crosses, so the cut value is $2$ and the affine objective identity certifies optimality #sym.checkmark.
+    *Step 3 -- Verify the witness.* The target witness $(#fmt-values(max2sat_mc_sol.target_config))$ puts $v_2$ and $v_3$ on the same side as $s$ and $v_1$ on the opposite side, so extraction recovers $(#fmt-values(max2sat_mc_sol.source_config))$. Only edge $(v_1, v_2)$ crosses, so the cut value is $2$ and the affine objective identity certifies optimality #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness. Flipping every target bit yields the complementary cut partition but extracts the same source assignment because extraction compares each variable vertex to $s$.
   ],
@@ -11496,15 +11352,15 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
   extra: [
     #pred-commands(
       "pred create --example Maximum2Satisfiability -o max2sat.json",
-      "pred reduce max2sat.json --to " + target-spec(max2sat_ilp) + " -o bundle.json",
+      "pred reduce max2sat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate max2sat.json --config " + max2sat_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate max2sat.json --config " + cli-config(max2sat_ilp_sol.source_config),
     )
     *Step 1 -- Source instance.* The canonical MAX-2-SAT instance has $n = #max2sat_ilp.source.instance.num_vars$ Boolean variables and $m = #max2sat_ilp.source.instance.clauses.len()$ clauses.
 
     *Step 2 -- Build the binary ILP.* Introduce $n$ binary truth variables $y_0, dots, y_(n-1) in {0,1}$ and $m$ binary clause-indicator variables $z_0, dots, z_(m-1) in {0,1}$. The objective is $ max sum_(j=0)^(m-1) z_j $ subject to one constraint per clause $j$: $z_j <= l_1' + l_2'$ where $l_i' = y_i$ for a positive literal and $l_i' = 1 - y_i$ for a negated literal. The resulting ILP has $n + m = #(max2sat_ilp.source.instance.num_vars + max2sat_ilp.source.instance.clauses.len())$ variables and $m = #max2sat_ilp.source.instance.clauses.len()$ constraints.
 
-    *Step 3 -- Verify a solution.* The ILP optimum extracts the first $n$ variables as the truth assignment $bold(y)^* = (#max2sat_ilp_sol.source_config.map(str).join(", "))$, satisfying #max2sat_ilp_sol.source_config.len() source variables #sym.checkmark.
+    *Step 3 -- Verify a solution.* The ILP optimum extracts the first $n$ variables as the truth assignment $bold(y)^* = (#fmt-values(max2sat_ilp_sol.source_config))$, satisfying #max2sat_ilp_sol.source_config.len() source variables #sym.checkmark.
   ],
 )[
   A MAX-2-SAT instance maps directly to a binary ILP @garey1979: each Boolean variable becomes a binary decision variable, each clause gets a binary indicator variable, and a single linear inequality per clause links the indicator to its literals. The objective maximizes the sum of clause indicators, so the ILP optimum equals the maximum number of satisfiable clauses.
@@ -11658,12 +11514,12 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
   extra: [
     #pred-commands(
       "pred create --example MVC -o mvc.json",
-      "pred reduce mvc.json --to " + target-spec(mvc_mis) + " -o bundle.json",
+      "pred reduce mvc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate mvc.json --config " + mvc_mis_sol.source_config.map(str).join(","),
+      "pred evaluate mvc.json --config " + cli-config(mvc_mis_sol.source_config),
     )
-    Source VC: $C = {#mvc_mis_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", ")}$ (size #mvc_mis_sol.source_config.filter(x => x == 1).len()) #h(1em)
-    Target IS: $S = {#mvc_mis_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", ")}$ (size #mvc_mis_sol.target_config.filter(x => x == 1).len()) \
+    Source VC: $C = {#mvc_mis_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", ")}$ (size #mvc_mis_sol.source_config.filter(x => x).len()) #h(1em)
+    Target IS: $S = {#mvc_mis_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", ")}$ (size #mvc_mis_sol.target_config.filter(x => x).len()) \
     $|"VC"| + |"IS"| = #graph-num-vertices(mvc_mis.source.instance) = |V|$ #sym.checkmark
   ],
 )[
@@ -11687,65 +11543,69 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
   example: true,
   example-source-variant: (graph: "SimpleGraph", weight: "One"),
   example-target-variant: (graph: "SimpleGraph", weight: "One"),
-  example-caption: [6-vertex unit graph: dominating set of size 2 equals a 2-center of radius 1],
+  example-caption: [6-vertex source: two auxiliary centers encode the domination threshold],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(dmds_mmmc.source) + " -o dmds.json",
-      "pred reduce dmds.json --to " + target-spec(dmds_mmmc) + " -o bundle.json",
+      "pred reduce dmds.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate dmds.json --config " + dmds_mmmc_sol.source_config.map(str).join(","),
+      "pred evaluate dmds.json --config " + cli-config(dmds_mmmc_sol.source_config),
     )
-    *Step 1 -- Source instance.* The source graph has vertices ${0, 1, 2, 3, 4, 5}$, edges #{dmds_mmmc.source.instance.inner.graph.edges.map(e => $(#e.at(0), #e.at(1))$).join(", ")}, and bound $K = #dmds_mmmc.source.instance.bound$. The stored dominating-set witness is $D = {#dmds_mmmc_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, _)) => str(i)).join(", ")}$.
+    *Step 1 -- Source instance.* The source graph has vertices ${0, 1, 2, 3, 4, 5}$, edges #{dmds_mmmc.source.instance.inner.graph.edges.map(e => $(#e.at(0), #e.at(1))$).join(", ")}, and bound $K = #dmds_mmmc.source.instance.bound$. The stored dominating-set witness is $D = {#dmds_mmmc_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, _)) => str(i)).join(", ")}$.
 
-    *Step 2 -- Build the target instance.* Keep the graph unchanged, assign weight $1$ to every vertex, assign length $1$ to every edge, and set the number of centers to $k = #dmds_mmmc.target.instance.k$. The target therefore still has $#graph-num-vertices(dmds_mmmc.target.instance)$ vertices and $#graph-num-edges(dmds_mmmc.target.instance)$ edges.
+    *Step 2 -- Build the target instance.* Append two isolated vertices, assign weight $1$ to every vertex and length $1$ to every edge, and set the number of centers to $k = #dmds_mmmc.target.instance.k$. The target therefore has $#graph-num-vertices(dmds_mmmc.target.instance)$ vertices and $#graph-num-edges(dmds_mmmc.target.instance)$ edges.
 
-    *Step 3 -- Verify a witness.* Choosing centers $P = {#dmds_mmmc_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, _)) => str(i)).join(", ")}$ yields distances $(0, 1, 1, 0, 1, 1)$ to the nearest center, so the maximum weighted distance is $1$. The extracted source witness is the same indicator vector, hence a dominating set of size $2$ #sym.checkmark
+    *Step 3 -- Verify a witness.* Choosing centers $P = {#dmds_mmmc_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, _)) => str(i)).join(", ")}$ yields distances $(0, 1, 1, 0, 1, 1, 0, 0)$ to the nearest center, so the maximum weighted distance is $1$. Discarding the two auxiliary center bits recovers a dominating set of size $2$ #sym.checkmark
   ],
 )[
-  This $O(n + m)$ parameter-setting reduction @garey1979[ND50] keeps the graph unchanged, replaces all vertex weights and edge lengths by $1$, and copies the decision budget $K$ into the target center count $k$. On such unit graphs, a $k$-center solution of radius at most $1$ exists exactly when every vertex is itself chosen or adjacent to a chosen vertex, which is the dominating-set condition.
+  The radius-threshold relation between centers and dominating sets @hochbaumshmoys1985 is extended here to all signed source bounds using two mandatory isolated centers. This $O(n+m+1)$ construction preserves the existing endpoint variants.
 ][
-  _Construction._ Given a unit-weight decision dominating-set instance $(G = (V, E), K)$, build a Min-Max Multicenter instance on the same graph $G$. Set $w(v) = 1$ for every vertex, set $l(e) = 1$ for every edge, and set the number of centers to $k = K$.
+  _Construction._ For source graph $G=(V,E)$ with $n$ vertices and integer bound $K$, set $q=max(-1,min(K,n))$. Add isolated vertices $a=n$ and $b=n+1$, leaving every original edge record unchanged. Give all vertices and edges unit weights and lengths, and require exactly $k=q+2$ centers. Then $1<=k<=n+2$ for every input, including an empty graph.
 
-  _Correctness._ ($arrow.r.double$) If $D subset.eq V$ is a dominating set with $|D| <= K$, pad $D$ with arbitrary additional vertices until exactly $K$ centers are chosen. Every vertex is then either a center (distance $0$) or adjacent to one (distance $1$), so the target maximum weighted distance is at most $1$. ($arrow.l.double$) If a set $P subset.eq V$ of exactly $K$ centers has maximum weighted distance at most $1$, then every vertex lies at graph distance $0$ or $1$ from some vertex of $P$. Hence every vertex is either in $P$ or adjacent to a vertex of $P$, so $P$ is a dominating set of size $K$.
+  _Correctness._ Every finite target placement must select both isolated vertices. If a source dominating set $D$ has $|D|<=K$, then $q>=0$ and $|D|<=q<=n$. Extend $D$ to $q$ original vertices and add $a,b$. This placement has $k$ centers and radius at most $1$, proving the forward direction. Conversely, a target placement of radius at most $1$ selects both isolates and exactly $q$ original vertices. Each original vertex is within one original edge of a selected vertex, so those $q<=K$ vertices dominate $G$. For $K<0$, $k=1$ cannot cover both isolates and the target has no finite placement. For $n=0,K>=0$, the two isolates form a radius-zero placement. Loops and repeated edges preserve this reasoning.
 
-  _Solution extraction._ Return the same indicator vector: every chosen target center becomes a chosen source dominating-set vertex.
+  _Solution extraction and NO instances._ Evaluate the full target indicator first. A finite radius at most $1$ permits extraction of its first $n$ bits. Any larger radius or infeasible placement is rejected. The formal aggregate map sends an optimum $r<=1$ to true, and an optimum $r>1$ or infeasibility to false. In particular, a four-vertex path with $K=1$ produces optimum radius $2$, not an infeasible target. Checked parameter arithmetic precedes allocation; unrepresentable counts return the formal numeric error. Target sizes are exactly $n+2$ vertices and $m$ edge records.
 ]
 
 #let dmds_msmc = load-example(
   "DecisionMinimumDominatingSet",
   "MinimumSumMulticenter",
   source-variant: (graph: "SimpleGraph", weight: "One"),
-  target-variant: (graph: "SimpleGraph", weight: "i32"),
+  target-variant: (graph: "SimpleGraph", weight: "i64"),
 )
 #let dmds_msmc_sol = dmds_msmc.solutions.at(0)
 #reduction-rule("DecisionMinimumDominatingSet", "MinimumSumMulticenter",
   example: true,
   example-source-variant: (graph: "SimpleGraph", weight: "One"),
-  example-target-variant: (graph: "SimpleGraph", weight: "i32"),
+  example-target-variant: (graph: "SimpleGraph", weight: "i64"),
   example-caption: [6-vertex unit graph: dominating set of size 2 gives total distance 4],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(dmds_msmc.source) + " -o dmds.json",
-      "pred reduce dmds.json --to " + target-spec(dmds_msmc) + " -o bundle.json",
+      "pred reduce dmds.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate dmds.json --config " + dmds_msmc_sol.source_config.map(str).join(","),
+      "pred evaluate dmds.json --config " + cli-config(dmds_msmc_sol.source_config),
     )
-    *Step 1 -- Source instance.* The source graph has vertices ${0, 1, 2, 3, 4, 5}$, edges #{dmds_msmc.source.instance.inner.graph.edges.map(e => $(#e.at(0), #e.at(1))$).join(", ")}, and decision bound $K = #dmds_msmc.source.instance.bound$. The stored dominating-set witness is $D = {#dmds_msmc_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, _)) => str(i)).join(", ")}$.
+    *Step 1 -- Source instance.* The source graph has vertices ${0, 1, 2, 3, 4, 5}$, edges #{dmds_msmc.source.instance.inner.graph.edges.map(e => $(#e.at(0), #e.at(1))$).join(", ")}, and decision bound $K = #dmds_msmc.source.instance.bound$. The stored dominating-set witness is $D = {#dmds_msmc_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, _)) => str(i)).join(", ")}$.
 
-    *Step 2 -- Build the target instance.* Keep the graph unchanged, assign vertex weight $1$ everywhere, assign edge length $1$ everywhere, and set the target center count to $k = #dmds_msmc.target.instance.k$. The comparison threshold is $B = |V| - K = 6 - 2 = 4$.
+    *Step 2 -- Build the target instance.* Add one isolated vertex $z$, assign vertex weight $1$ everywhere, assign edge length $1$ everywhere, and set the target center count to $k = #dmds_msmc.target.instance.k$. The comparison threshold is $B = |V| - K = 6 - 2 = 4$.
 
-    *Step 3 -- Verify a witness.* Choosing centers $P = {#dmds_msmc_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, _)) => str(i)).join(", ")}$ yields distances $(0, 1, 1, 0, 1, 1)$ to the nearest center, so the total weighted distance is $4 = B$. The extracted source witness is the same indicator vector, hence a valid YES witness for the original decision instance #sym.checkmark
+    *Step 3 -- Verify a witness.* Choosing centers $P = {#dmds_msmc_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, _)) => str(i)).join(", ")}$ yields distances $(0, 1, 1, 0, 1, 1, 0)$ to the nearest center, so the total weighted distance is $4 = B$. The extracted source witness removes the coordinate of $z$, hence a valid YES witness for the original decision instance #sym.checkmark
   ],
 )[
-  This $O(n + m)$ parameter-setting reduction @garey1979[ND51] keeps the graph unchanged, sets every vertex weight and edge length to $1$, copies the decision budget $K$ into the target center count $k$, and compares the target optimum against $B = |V| - K$. On such unit graphs, every exact-$K$ center placement has total distance at least $n - K$, with equality exactly when every non-center vertex is adjacent to a center.
+  This $O(n + m)$ reduction uses unit vertex weights and edge lengths. For $K >= 0$, let $q = min(K, n)$, add one isolated vertex $z$, and request exactly $q + 1$ centers. The source answer is YES exactly when the target optimum is $B = n - q$. For $K < 0$, add two isolated vertices and request one center, producing an infeasible target.
 ][
-  _Construction._ Given a decision dominating-set instance $(G = (V, E), K)$ with unit vertex weights, build a Minimum Sum Multicenter instance on the same graph $G$. Set $w(v) = 1$ for every vertex, set $l(e) = 1$ for every edge, and set the number of centers to $k = K$. Let $n = |V|$, and define the decision threshold $B = n - K$ for the target optimum.
+  _Construction and domain._ Let $n = |V|$. For nonnegative $K$, replacing $K$ by $q = min(K, n)$ preserves the decision problem because every vertex subset has size at most $n$. The auxiliary isolate makes $1 <= q + 1 <= n + 1$, so the target is defined even for $K = 0$ and the empty source graph. All original edges are retained. For negative $K$, no source subset can satisfy the bound, and two auxiliary isolates cannot both be served by one center. The target has at most $n + 2$ vertices and exactly $m$ edges.
+
+  _Correctness for nonnegative bounds._ Every finite-cost placement must select $z$, leaving exactly $q$ original centers. Each of the $n - q$ original non-centers has distance at least one, so every finite target cost is at least $B = n - q$.
+
+  ($arrow.r.double$) A source dominating set of size at most $K$ also has size at most $q$. Pad it to size $q$ and add $z$. Each original non-center has distance exactly one; the resulting target cost equals $B$ and is optimal.
 
-  _Correctness._ ($arrow.r.double$) If $D subset.eq V$ is a dominating set with $|D| <= K$, pad $D$ with arbitrary additional vertices until exactly $K$ centers are chosen. Every chosen center contributes distance $0$, and every non-center vertex is adjacent to at least one chosen center, so every non-center contributes distance $1$. Hence the total weighted distance is exactly $n - K = B$.
+  ($arrow.l.double$) A target placement of cost $B$ must select $z$. Equality in the distance lower bound forces every original non-center to have distance one from an original center. Removing $z$ therefore gives a dominating set of size $q <= K$.
 
-  ($arrow.l.double$) Suppose a set $P subset.eq V$ of exactly $K$ centers has total weighted distance at most $B = n - K$. Every non-center vertex has distance at least $1$ from $P$, so any exact-$K$ center placement has total distance at least $n - K$. Therefore total distance at most $n - K$ forces equality, meaning every non-center contributes exactly $1$. Thus every non-center vertex is adjacent to some center in $P$, so $P$ is a dominating set of size $K$.
+  _Boundary cases._ If $K = 0 < n$, one center cannot serve both the isolate and the original graph, so the target is infeasible. If $n = 0$ and $K >= 0$, the sole vertex $z$ is selected and the cost is zero, correctly certifying the empty dominating set. If $K >= n$, selecting all target vertices gives cost zero and extracts all original vertices. Negative bounds give infeasibility as shown above.
 
-  _Solution extraction._ Return the same indicator vector: every chosen target center becomes a chosen source dominating-set vertex.
+  _Value and solution extraction._ Map a finite target optimum equal to $B$ to YES; map any other optimum or infeasibility to NO. For negative bounds use comparison value $-1$, which no finite nonnegative target cost can equal. Extract a source witness only from a placement whose cost equals the comparison value, by removing the auxiliary coordinates. Reject every other placement; an optimal target solution with cost greater than $B$ is not a source YES witness.
 ]
 
 #let mvc_mmm = load-example("MinimumVertexCover", "MinimumMaximalMatching")
@@ -11756,8 +11616,8 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
   extra: [
     #{
       let target-edges = mvc_mmm.target.instance.graph.edges
-      let source-cover = mvc_mmm_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
-      let matching = mvc_mmm_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => target-edges.at(i))
+      let source-cover = mvc_mmm_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
+      let matching = mvc_mmm_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => target-edges.at(i))
       let fmt-edge(e) = "(" + str(e.at(0)) + ", " + str(e.at(1)) + ")"
       [
         #pred-commands(
@@ -11769,7 +11629,7 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
 
         *Step 1 -- Shared instance.* Both problems use the same 5-cycle, so $n = #graph-num-vertices(mvc_mmm.source.instance)$ and $|E| = #graph-num-edges(mvc_mmm.source.instance)$.
 
-        *Step 2 -- Source optimum.* The canonical minimum vertex cover is $C = {#source-cover.map(str).join(", ")}$, so $"mvc"(C_5) = #source-cover.len() = 3$.
+        *Step 2 -- Source optimum.* The canonical minimum vertex cover is $C = {#fmt-values(source-cover)}$, so $"mvc"(C_5) = #source-cover.len() = 3$.
 
         *Step 3 -- Target optimum.* The canonical minimum maximal matching is $M = {#matching.map(fmt-edge).join(", ")}$, so $"mmm"(C_5) = #matching.len() = 2$.
 
@@ -11782,7 +11642,7 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
 )[
   This size-preserving identity map records the forward implication used in the classical NP-hardness proof for Minimum Maximal Matching (equivalently, Minimum Edge Dominating Set) on bounded-degree graphs: every unit-weight vertex cover of $G$ can be greedily converted into a maximal matching of size at most the cover size. The converse loses a factor of two in general, so the edge is documented but intentionally disabled for runtime reduction search.
 ][
-  _Construction._ Given a unit-weight Minimum Vertex Cover instance $(G = (V, E), K)$, build the Minimum Maximal Matching instance on the same graph $G$. The target uses one binary variable per source edge, so the graph structure and size fields are unchanged.
+  _Construction._ Given a unit-weight Minimum Vertex Cover instance $(G = (V, E), K)$, build the Minimum Maximal Matching instance on the same graph $G$. The target uses one binary variable per source edge, so the graph structure and parameters are unchanged.
 
   _Correctness._ ($arrow.r.double$) Let $C subset.eq V$ be a vertex cover with $|C| lt.eq K$. Start with $M = emptyset$ and process the vertices of $C$ in arbitrary order. Whenever $v in C$ is unmatched, choose any edge $\{v, u\} in E$ whose other endpoint $u$ is also unmatched, add that edge to $M$, and mark both endpoints matched. Because only unmatched endpoints are paired, $M$ is a matching. If some edge $\{x, y\} in E$ were disjoint from every edge of $M$ at the end, then both $x$ and $y$ would still be unmatched. Since $C$ covers every edge, at least one endpoint, say $x$, lies in $C$, and when the algorithm processed $x$ it could have added $\{x, y\}$, a contradiction. Hence $M$ is maximal and $|M| lt.eq |C| lt.eq K$.
 
@@ -11798,25 +11658,25 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
   example-caption: [Path graph $P_4$: VC $arrow.r$ LCS via vertex symbols],
   extra: [
     #{
-      let source-cover = mvc_lcs_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+      let source-cover = mvc_lcs_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
       let target-config = mvc_lcs_sol.target_config
-      let witness = target-config.filter(x => x < mvc_lcs.target.instance.alphabet_size)
+      let witness = target-config.filter(x => x != none)
       let num-strings = mvc_lcs.target.instance.strings.len()
       let total-length = mvc_lcs.target.instance.strings.map(s => s.len()).fold(0, (acc, n) => acc + n)
-      let fmt-seq(xs) = "(" + xs.map(str).join(", ") + ")"
+      let fmt-seq(xs) = "(" + fmt-values(xs) + ")"
       [
         #pred-commands(
           "pred create --example " + problem-spec(mvc_lcs.source) + " -o mvc.json",
-          "pred reduce mvc.json --to " + target-spec(mvc_lcs) + " -o bundle.json",
+          "pred reduce mvc.json --via route.json -o bundle.json",
           "pred solve bundle.json",
-          "pred evaluate mvc.json --config " + mvc_lcs_sol.source_config.map(str).join(","),
+          "pred evaluate mvc.json --config " + cli-config(mvc_lcs_sol.source_config),
         )
 
-        *Step 1 -- Source instance.* Path graph $P_4$ with $n = #graph-num-vertices(mvc_lcs.source.instance)$ vertices and $|E| = #graph-num-edges(mvc_lcs.source.instance)$ edges. The canonical minimum vertex cover is $C = {#source-cover.map(str).join(", ")}$.
+        *Step 1 -- Source instance.* Path graph $P_4$ with $n = #graph-num-vertices(mvc_lcs.source.instance)$ vertices and $|E| = #graph-num-edges(mvc_lcs.source.instance)$ edges. The canonical minimum vertex cover is $C = {#fmt-values(source-cover)}$.
 
         *Step 2 -- Construct the LCS instance.* Alphabet $Sigma = {0, dots, #((mvc_lcs.target.instance.alphabet_size) - 1)}$ and $#num-strings$ strings: $S_0 = #fmt-seq(mvc_lcs.target.instance.strings.at(0))$, $S_1 = #fmt-seq(mvc_lcs.target.instance.strings.at(1))$, $S_2 = #fmt-seq(mvc_lcs.target.instance.strings.at(2))$, $S_3 = #fmt-seq(mvc_lcs.target.instance.strings.at(3))$. The target has `max_length` $#mvc_lcs.target.instance.max_length$ and total input length $#total-length$.
 
-        *Step 3 -- Verify the witness.* The stored target config is #fmt-seq(target-config), so the non-padding common subsequence is $w = #fmt-seq(witness)$ and the corresponding independent set is ${#witness.map(str).join(", ")}$. Taking the complement gives $V backslash w = {#source-cover.map(str).join(", ")} = C$ #sym.checkmark.
+        *Step 3 -- Verify the witness.* The stored target config is #fmt-seq(target-config), so the non-padding common subsequence is $w = #fmt-seq(witness)$ and the corresponding independent set is ${#fmt-values(witness)}$. Taking the complement gives $V backslash w = {#fmt-values(source-cover)} = C$ #sym.checkmark.
 
         *Multiplicity:* The fixture stores one canonical witness.
       ]
@@ -11840,20 +11700,20 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
 
 #let mvc_fvs = load-example("MinimumVertexCover", "MinimumFeedbackVertexSet")
 #let mvc_fvs_sol = mvc_fvs.solutions.at(0)
-#let mvc_fvs_cover = mvc_fvs_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
-#let mvc_fvs_fvs = mvc_fvs_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let mvc_fvs_cover = mvc_fvs_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
+#let mvc_fvs_fvs = mvc_fvs_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #reduction-rule("MinimumVertexCover", "MinimumFeedbackVertexSet",
   example: true,
   example-caption: [7-vertex graph: each source edge becomes a directed 2-cycle],
   extra: [
     #pred-commands(
       "pred create --example MVC -o mvc.json",
-      "pred reduce mvc.json --to " + target-spec(mvc_fvs) + " -o bundle.json",
+      "pred reduce mvc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate mvc.json --config " + mvc_fvs_sol.source_config.map(str).join(","),
+      "pred evaluate mvc.json --config " + cli-config(mvc_fvs_sol.source_config),
     )
-    Source VC: $C = {#mvc_fvs_cover.map(str).join(", ")}$ (size #mvc_fvs_cover.len()) on a graph with $n = #graph-num-vertices(mvc_fvs.source.instance)$ vertices and $|E| = #graph-num-edges(mvc_fvs.source.instance)$ edges \
-    Target FVS: $F = {#mvc_fvs_fvs.map(str).join(", ")}$ (size #mvc_fvs_fvs.len()) on a digraph with the same $n = #graph-num-vertices(mvc_fvs.target.instance)$ vertices and $|A| = #mvc_fvs.target.instance.graph.arcs.len() = 2 |E|$ arcs \
+    Source VC: $C = {#fmt-values(mvc_fvs_cover)}$ (size #mvc_fvs_cover.len()) on a graph with $n = #graph-num-vertices(mvc_fvs.source.instance)$ vertices and $|E| = #graph-num-edges(mvc_fvs.source.instance)$ edges \
+    Target FVS: $F = {#fmt-values(mvc_fvs_fvs)}$ (size #mvc_fvs_fvs.len()) on a digraph with the same $n = #graph-num-vertices(mvc_fvs.target.instance)$ vertices and $|A| = #mvc_fvs.target.instance.graph.arcs.len() = 2 |E|$ arcs \
     Canonical witness is preserved exactly: $C = F$ #sym.checkmark
   ],
 )[
@@ -11880,24 +11740,24 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
 #let mis_clique = load-example(
   "MaximumIndependentSet",
   "MaximumClique",
-  source-variant: (graph: "SimpleGraph", weight: "i32"),
-  target-variant: (graph: "SimpleGraph", weight: "i32"),
+  source-variant: (graph: "SimpleGraph", weight: "i64"),
+  target-variant: (graph: "SimpleGraph", weight: "i64"),
 )
 #let mis_clique_sol = mis_clique.solutions.at(0)
 #reduction-rule("MaximumIndependentSet", "MaximumClique",
   example: true,
-  example-source-variant: (graph: "SimpleGraph", weight: "i32"),
-  example-target-variant: (graph: "SimpleGraph", weight: "i32"),
+  example-source-variant: (graph: "SimpleGraph", weight: "i64"),
+  example-target-variant: (graph: "SimpleGraph", weight: "i64"),
   example-caption: [Path graph $P_5$: IS $arrow.r$ Clique via complement],
   extra: [
     #pred-commands(
       "pred create --example MIS -o mis.json",
-      "pred reduce mis.json --to " + target-spec(mis_clique) + " -o bundle.json",
+      "pred reduce mis.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate mis.json --config " + mis_clique_sol.source_config.map(str).join(","),
+      "pred evaluate mis.json --config " + cli-config(mis_clique_sol.source_config),
     )
-    Source IS: $S = {#mis_clique_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", ")}$ (size #mis_clique_sol.source_config.filter(x => x == 1).len()) #h(1em)
-    Target Clique: $C = {#mis_clique_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", ")}$ (size #mis_clique_sol.target_config.filter(x => x == 1).len()) \
+    Source IS: $S = {#mis_clique_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", ")}$ (size #mis_clique_sol.source_config.filter(x => x).len()) #h(1em)
+    Target Clique: $C = {#mis_clique_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", ")}$ (size #mis_clique_sol.target_config.filter(x => x).len()) \
     Source $|E| = #graph-num-edges(mis_clique.source.instance)$, complement $|overline(E)| = #graph-num-edges(mis_clique.target.instance)$ #sym.checkmark
   ],
 )[
@@ -11948,54 +11808,94 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(dmvc_cc.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(dmvc_cc) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + dmvc_cc_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(dmvc_cc_sol.source_config),
     )
-    Source VC witness $(#dmvc_cc_sol.source_config.map(str).join(", "))$, target containment indicator $(#dmvc_cc_sol.target_config.map(str).join(", "))$.
+    Source VC witness $(#fmt-values(dmvc_cc_sol.source_config))$, target containment indicator $(#fmt-values(dmvc_cc_sol.target_config))$.
   ],
 )[
-  Plaisted's reduction @plaisted1976 encodes a unit-weight Decision Vertex Cover instance $(G = (V, E), K)$ as a Comparative Containment instance on universe $X = V$. Each vertex contributes a complement set with unit reward; each edge contributes a complement-of-edge penalty set with weight $|V| + 1$ that dominates the total reward whenever the edge is uncovered; and a single budget set with weight $|V| - K$ enforces the cardinality bound.
+  This signed-weight extension of the complement-set encoding for Comparative Containment (Garey--Johnson SP10 @garey1979, credited there to @plaisted1976) preserves the existing `i64` Decision Vertex Cover endpoint. It handles negative and zero vertex weights without changing the target's positive-weight definition.
 ][
-  _Construction._ Given a unit-weight VC instance $(G = (V, E), K)$ with $n = |V|$, set the universe $X = V$ and define:
-  - For each vertex $v in V$, the reward set $R_v = V without {v}$ with weight $w(R_v) = 1$. Then $Y subset.eq R_v$ iff $v in.not Y$, so $sum_(Y subset.eq R_v) w(R_v) = n - |Y|$.
-  - For each edge $e = {u, v} in E$, the edge-penalty set $S_e = V without {u, v}$ with weight $w(S_e) = n + 1$. Then $Y subset.eq S_e$ iff neither $u$ nor $v$ lies in $Y$, i.e.\ iff $e$ is uncovered.
-  - A budget set $S_0 = V$ with weight $w(S_0) = n - K$. Since $Y subset.eq V$ always holds, this set contributes the constant penalty $n - K$.
+  _Construction._ For vertex weights $w_v$ and threshold $K$, define $U=sum_v max(w_v,0)$, $L=sum_v min(w_v,0)$, $W=U+L$, $B=min(K,U)$, $C=B-W$, and $P=U-L+1$. Use universe $X=V$. Process the signed terms $(V without {v},w_v)$ in vertex order and then $(V,C)$: put positive terms in $R$, negative terms in $S$ with their negated coefficients, and omit zero terms. Finally, for each edge record $(u,v)$, append $(V without {u,v},P)$ to $S$ in edge order.
 
-  The containment inequality becomes $n - |Y| >= (n + 1) dot (\#"uncovered edges") + (n - K)$, which simplifies to
-  $ K - |Y| >= (n + 1) dot (\#"uncovered edges"). $
+  _Correctness._ For subset $Y$, let $q(Y)$ count uncovered edge records and $w(Y)=sum_(v in Y)w_v$. The difference between the two containment totals is
+  $ D(Y)=C+sum_(v in.not Y)w_v-P q(Y)=B-w(Y)-P q(Y). $
+  Every subset has $L<=w(Y)<=U$, so the thresholds $K$ and $B$ are equivalent. A cover meeting the source bound has $q(Y)=0$ and $D(Y)>=0$, proving the forward direction. Conversely, an uncovered edge would imply $D(Y)<=U-L-P=-1$, contradicting target feasibility. Thus any feasible target subset covers all edges and satisfies $w(Y)<=B<=K$. This also forces selection of looped vertices; repeated edges repeat the same constraint. Empty graphs use the same construction.
 
-  _Correctness._ ($arrow.r.double$) If $Y$ is a vertex cover with $|Y| <= K$, the right-hand side equals $0$ and the inequality $K - |Y| >= 0$ holds. ($arrow.l.double$) Suppose the inequality holds for some $Y$. If $Y$ leaves an edge uncovered, the right-hand side is at least $n + 1 > n >= K - |Y|$, a contradiction. Hence $Y$ is a vertex cover and $K - |Y| >= 0$, i.e.\ $|Y| <= K$.
+  _Solution extraction and arithmetic._ Validate target feasibility through the target API and return the identical indicator vector. All derived coefficients and both complete target-family sums use checked `i64` arithmetic; an unrepresentable construction returns the formal numeric error. Positive family weights ensure that checking their complete sums bounds every target evaluation. No source solve or replacement witness is used. There are exactly $n$ universe elements, at most $n+1$ R-sets, and at most $n+m+1$ S-sets; explicit complement construction takes $O(n(n+m+1))$ time and space.
+]
 
-  _Solution extraction._ The indicator vector of $Y subset.eq X$ over the universe $X = V$ is read off as the source vertex-cover indicator. Two corner cases are emitted as trivial instances: when $K >= n$ every cover satisfies the bound, so the target is the empty Comparative Containment instance whose unique configuration is trivially feasible; when $K < 0$ the bound is unattainable, and the target is a fixed unsatisfiable instance with a single penalty set.
+#let ec_ilp = load-example("EnsembleComputation", "ILP")
+#let ec_ilp_sol = ec_ilp.solutions.at(0)
+#reduction-rule("EnsembleComputation", "ILP",
+  example: true,
+  example-caption: [Three-slot disjoint-union circuit on four atoms],
+  extra: [
+    #pred-commands(
+      "pred create --example " + problem-spec(ec_ilp.source) + " -o ensemble.json",
+      "pred reduce ensemble.json --via route.json -o bundle.json",
+      "pred solve bundle.json",
+      "pred evaluate ensemble.json --config " + cli-config(ec_ilp_sol.source_config),
+    )
+    The source has universe size #ec_ilp.source.instance.universe_size, budget #ec_ilp.source.instance.budget, and targets #ec_ilp.source.instance.subsets. Its stored witness uses #(ec_ilp_sol.source_config.len() / 2) union operations. The ILP selector variables recover the same ordered operand pairs, and evaluating the extracted source configuration gives #(ec_ilp_sol.source_config.len() / 2) #sym.checkmark.
+  ],
+)[
+  This polynomial-size slot encoding follows the circuit viewpoint used by Järvisalo, Kaski, Koivisto, and Korhonen @jarvisaloEtAl2012. It represents at most $J$ ordered disjoint-union gates without enumerating the $2^|A|$ possible sets.
+][
+  _Construction._ Let $A={0,dots,u-1}$, let $cal(C)=(C_1,dots,C_t)$, and number operation slots $k=0,dots,J-1$. Binary $a_k$ activates slot $k$, with $a_k >= a_(k+1)$. Two one-hot selector families choose each active slot's left and right operands from the $u$ singleton atoms and results of earlier active slots; because union is commutative, require the left operand index to be smaller than the right operand index. For a selector $s$ and earlier result bit $r_(h,e)$, a binary auxiliary $v=s r_(h,e)$ is enforced by $v<=s$, $v<=r_(h,e)$, and $v>=s+r_(h,e)-1$. Thus the selected operand-membership bits $lambda_(k,e)$ and $rho_(k,e)$ are linear expressions. Impose
+  $
+    lambda_(k,e)+rho_(k,e) <= 1, quad
+    r_(k,e)=lambda_(k,e)+rho_(k,e)
+  $
+  for every $k,e$. Match variable $m_(c,k)$ may equal one only if $a_k=1$ and every result bit $r_(k,e)$ equals the membership of $e$ in $C_c$; require $sum_k m_(c,k)>=1$. Minimize $sum_k a_k$. The construction uses
+  $
+    3 J u + J(J-1)(u+1) + t J + J
+  $
+  variables and
+  $
+    (5 J-1)+J(J-1)(1+3 u)+2 J u+t J(u+2)+t
+  $
+  constraints.
+
+  _Correctness._ ($arrow.r.double$) A valid $K<=J$ operation program activates its first $K$ slots, copies each operand reference into the corresponding selector, and assigns the computed membership and match bits; all constraints hold with objective $K$. ($arrow.l.double$) In any feasible ILP solution the active slots form a prefix, each operand is either an atom or an earlier active result, the McCormick constraints recover its exact membership, and the disjointness and union equations make every active slot a legal operation. Match constraints ensure that every required set occurs as a result. Therefore the optimum is the minimum feasible operation count within budget $J$. Empty and singleton targets remain infeasible because atoms are operands, not computed results.
+
+  _Solution extraction._ Read the two one-hot operand selectors from active slots in increasing order. Preserve atom indices and encode earlier result $h$ as operand index $u+h$; fill unused suffix slots with a harmless disjoint atom pair because source evaluation stops once all targets have appeared.
 ]
 
 #reduction-rule("MinimumVertexCover", "EnsembleComputation")[
-  This $O(|V| + |E|)$ reduction @garey1979 encodes the unit-weight vertex-cover problem as an ensemble-computation minimization over disjoint unions. A fresh element $a_0$ is introduced, and each edge becomes a 3-element target subset. The minimum sequence length equals $K^* + |E|$, where $K^*$ is the minimum vertex cover size.
+  This reduction @garey1979 (Theorem 3.6, pp. 66--68) maps unit-weight vertex cover to disjoint-union ensemble computation. If $tau$ is the minimum cover size and $m$ the number of edges, the target optimum is $m+tau$. The extraction below applies to every optimal target program, without assuming that the solver returns a normalized program.
 ][
-  _Construction._ Given a unit-weight VC instance $G = (V, E)$, let $a_0$ be a fresh element not in $V$. Set the universe $A = V union {a_0}$ with $|A| = |V| + 1$. For each edge ${u, v} in E$, add the subset ${a_0, u, v}$ to the collection $C$. Set the search-space bound $J = |V| + |E|$.
+  _Construction._ For a simple graph $G=(V,E)$ with $n=|V|$ and $m=|E|$, give the original vertices indices $0,dots,n-1$ and introduce a fresh atom $a_0$ with index $n$. Set $A=V union {a_0}$ and require the $m$ distinct triples ${a_0,u,v}$ for ${u,v} in E$. Use operation budget $J=max(1,n+m)$, including the positive-budget representation of an empty computation. Thus the universe size is $n+1$, the number of required sets is $m$, and $J<=n+m+1$.
+
+  _Forward bound._ For a vertex cover $C$, first compute ${a_0,v}$ for each $v in C$. For each edge, choose an endpoint $v in C$ and unite ${a_0,v}$ with its other endpoint singleton. The resulting program computes every required triple with at most $|C|+m$ operations, within budget $J$. In particular the optimum $L^*$ satisfies $L^*<=tau+m$.
 
-  _Correctness._ ($arrow.r.double$) If $C'$ is a vertex cover of size $K$, label its elements $v_1, dots, v_K$ and the edges $e_1, dots, e_m$. Since $C'$ covers every edge, each $e_j = {u_j, v_(r[j])}$ where $v_(r[j]) in C'$. The sequence of $K + m$ operations $z_i = {a_0} union {v_i}$ for $i = 1, dots, K$ followed by $z_(K+j) = {u_j} union z_(r[j])$ for $j = 1, dots, m$ produces every target subset in exactly $K + |E|$ steps. ($arrow.l.double$) An exchange argument (Garey & Johnson, PO9) shows that any minimum-length sequence can be normalized to use only ${a_0} union {u}$ and ${v} union z_k$ forms. Each edge contributes exactly one operation of the second form, so the number of first-form operations equals the sequence length minus $|E|$. Since the first-form vertices must cover all edges, the minimum sequence length is $K^* + |E|$.
+  _Backward bound._ Let $L$ be the evaluated prefix length of any valid target program. Every computed set has at least two elements, because all initial operands are singletons and every union is disjoint. Therefore a two-element set is produced exactly by two singleton operands. Each required triple must be formed using an earlier two-element set and a singleton. For its edge ${u,v}$, this pair is one of ${a_0,u}$, ${a_0,v}$, or ${u,v}$. Select respectively $u$, $v$, or $min(u,v)$ from the operation producing that pair. Each selection covers the corresponding edge. Applying this selection to every pair-producing operation in the prefix gives a vertex cover $S$.
+
+  At least $m$ distinct operations produce the required triples; none of these produces a pair. Consequently $|S|<=L-m$, even if the program repeats intermediate sets or contains unused operations and larger sets. At an optimum, $tau<=|S|<=L^*-m<=tau$, proving both $L^*=m+tau$ and optimality of the extracted cover.
+
+  _Solution extraction._ Use the existing target validation API's evaluated prefix length and ignore padding after that prefix. Whenever both operands are singleton indices, select their smaller index. The fresh atom has the largest singleton index, so this implements all three mathematical choices above. Operations with a computed operand contribute no selected vertex. Extraction takes $O(n+L)$ time after target validation and does not perform normalization or source optimization. With no required sets the evaluated prefix is empty and the extracted cover is empty.
+
+  The same extraction also covers native graph representations with loops or repeated edges. A loop at $u$ requires the pair ${a_0,u}$ and therefore forces selection of $u$. Repeated required sets need only be computed once. With $d$ distinct non-loop edges, the preceding bounds become $|S|<=L-d$ and $L^*=tau+d$; the unchanged budget based on all edge records remains sufficient.
 
-  _Solution extraction._ From an optimal witness, collect all vertices appearing as singleton operands (indices $< |V|$). In a minimum-length normalized sequence, exactly the $K^*$ cover vertices appear as ${a_0}$-paired singletons.
 ]
 
 #let mvc_aog = load-example("MinimumVertexCover", "MinimumWeightAndOrGraph")
 #let mvc_aog_sol = mvc_aog.solutions.at(0)
-#let mvc_aog_cover = mvc_aog_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let mvc_aog_cover = mvc_aog_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #reduction-rule("MinimumVertexCover", "MinimumWeightAndOrGraph",
   example: true,
   example-caption: [Path $P_3$: vertex cover ${1}$ maps to an AND/OR graph of weight 5],
   extra: [
     #pred-commands(
       "pred create --example MVC -o mvc.json",
-      "pred reduce mvc.json --to " + target-spec(mvc_aog) + " -o bundle.json",
+      "pred reduce mvc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate mvc.json --config " + mvc_aog_sol.source_config.map(str).join(","),
+      "pred evaluate mvc.json --config " + cli-config(mvc_aog_sol.source_config),
     )
-    Source VC: $C = {#mvc_aog_cover.map(str).join(", ")}$ (size #mvc_aog_cover.len()) on graph with $n = #graph-num-vertices(mvc_aog.source.instance)$ vertices, $m = #graph-num-edges(mvc_aog.source.instance)$ edges \
+    Source VC: $C = {#fmt-values(mvc_aog_cover)}$ (size #mvc_aog_cover.len()) on graph with $n = #graph-num-vertices(mvc_aog.source.instance)$ vertices, $m = #graph-num-edges(mvc_aog.source.instance)$ edges \
     Target AND/OR graph: #mvc_aog.target.instance.num_vertices vertices, source $v_#mvc_aog.target.instance.source$ (AND), arcs: #{range(mvc_aog.target.instance.arcs.len()).map(i => {let a = mvc_aog.target.instance.arcs.at(i); $v_#(a.at(0)) arrow.r v_#(a.at(1))$}).join(", ")} \
-    Selected arcs: #{mvc_aog_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, _)) => {let a = mvc_aog.target.instance.arcs.at(i); $v_#(a.at(0)) arrow.r v_#(a.at(1))$}).join(", ")} (weight #{mvc_aog_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, _)) => mvc_aog.target.instance.arc_weights.at(i)).sum()}) #sym.checkmark
+    Selected arcs: #{mvc_aog_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, _)) => {let a = mvc_aog.target.instance.arcs.at(i); $v_#(a.at(0)) arrow.r v_#(a.at(1))$}).join(", ")} (weight #{mvc_aog_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, _)) => mvc_aog.target.instance.arc_weights.at(i)).sum()}) #sym.checkmark
   ],
 )[
   This reduction encodes vertex cover as a minimum-weight solution subgraph problem on a three-layer AND/OR DAG. The root AND gate requires all edges to be covered; each edge becomes an OR gate selecting which endpoint covers it; and each vertex becomes a sink whose arc weight equals the vertex weight. The minimum-weight solution subgraph selects exactly the arcs corresponding to a minimum vertex cover.
@@ -12035,21 +11935,28 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
   _Solution extraction._ Convert spins to binary: $x_i = (s_i + 1) \/ 2$, i.e.\ $s_i = +1 arrow.r x_i = 1$, $s_i = -1 arrow.r x_i = 0$.
 ]
 
-#let sg_qubo = load-example("SpinGlass", "QUBO")
+#let sg_qubo = load-example(
+  "SpinGlass",
+  "QUBO",
+  source-variant: (graph: "SimpleGraph", weight: "f64"),
+  target-variant: (weight: "f64"),
+)
 #let sg_qubo_sol = sg_qubo.solutions.at(0)
 #reduction-rule("SpinGlass", "QUBO",
   example: true,
+  example-source-variant: (graph: "SimpleGraph", weight: "f64"),
+  example-target-variant: (weight: "f64"),
   example-caption: [10-spin Ising model on Petersen graph],
   extra: [
     #pred-commands(
       "pred create --example SpinGlass -o spinglass.json",
-      "pred reduce spinglass.json --to " + target-spec(sg_qubo) + " -o bundle.json",
+      "pred reduce spinglass.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate spinglass.json --config " + sg_qubo_sol.source_config.map(str).join(","),
+      "pred evaluate spinglass.json --config " + cli-config(sg_qubo_sol.source_config),
     )
     Source: $n = #spin-num-spins(sg_qubo.source.instance)$ spins, $h_i = 0$, couplings $J_(i j) in {plus.minus 1}$ \
     Mapping: $s_i = 2x_i - 1$ converts spins ${-1, +1}$ to binary ${0, 1}$ \
-    Canonical ground-state witness: $bold(x) = (#sg_qubo_sol.target_config.map(str).join(", "))$ #sym.checkmark
+    Canonical ground-state witness: $bold(x) = (#fmt-values(sg_qubo_sol.target_config))$ #sym.checkmark
   ],
 )[
   The Ising model and QUBO are both quadratic functions over finite domains: spins ${-1,+1}$ and binary variables ${0,1}$, respectively. The affine map $s_i = 2x_i - 1$ establishes a bijection between the two domains and preserves the quadratic structure. Substituting into the Ising Hamiltonian yields a QUBO objective that differs from the original energy by a constant, so ground states correspond exactly.
@@ -12069,17 +11976,15 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
 #let cvp_qubo_sol = cvp_qubo.solutions.at(0)
 #{
   let basis = cvp_qubo.source.instance.basis
-  let bounds = cvp_qubo.source.instance.bounds
   let target = cvp_qubo.source.instance.target
-  let offsets = cvp_qubo_sol.source_config
-  let coords = offsets.enumerate().map(((i, off)) => off + bounds.at(i).lower)
+  let coords = cvp_qubo_sol.source_config
   let matrix = cvp_qubo.target.instance.matrix
   let bits = cvp_qubo_sol.target_config
-  let lo = bounds.map(b => b.lower)
-  let anchor = range(target.len()).map(d => lo.enumerate().fold(0.0, (acc, (i, x)) => acc + x * basis.at(i).at(d)))
+  let lower = (-23, -14)
+  let anchor = range(target.len()).map(d => lower.enumerate().fold(0.0, (acc, (i, x)) => acc + x * basis.at(i).at(d)))
   let constant = range(target.len()).fold(0.0, (acc, d) => acc + calc.pow(anchor.at(d) - target.at(d), 2))
-  let qubo-value = range(bits.len()).fold(0.0, (acc, i) => acc + if bits.at(i) == 0 { 0.0 } else {
-    range(bits.len() - i).fold(0.0, (row-acc, delta) => row-acc + if bits.at(i + delta) == 0 { 0.0 } else { matrix.at(i).at(i + delta) })
+  let qubo-value = range(bits.len()).fold(0.0, (acc, i) => acc + if bits.at(i) == false { 0.0 } else {
+    range(bits.len() - i).fold(0.0, (row-acc, delta) => row-acc + if bits.at(i + delta) == false { 0.0 } else { matrix.at(i).at(i + delta) })
   })
   let fmt-vec(v) = $paren.l #v.map(e => str(e)).join(", ") paren.r^top$
   let rounded-constant = calc.round(constant, digits: 2)
@@ -12088,44 +11993,38 @@ Each reduction is presented as a *Rule* (with linked problem names and overhead
   [
     #reduction-rule("ClosestVectorProblem", "QUBO",
       example: true,
-      example-caption: [2D bounded CVP with two 3-bit exact-range encodings],
+      example-caption: [2D standard CVP with a coefficient box derived by the reduction],
       extra: [
         #pred-commands(
           "pred create --example CVP -o cvp.json",
-          "pred reduce cvp.json --to " + target-spec(cvp_qubo) + " -o bundle.json",
+          "pred reduce cvp.json --via route.json -o bundle.json",
           "pred solve bundle.json",
-          "pred evaluate cvp.json --config " + cvp_qubo_sol.source_config.map(str).join(","),
+          "pred evaluate cvp.json --config " + cli-config(cvp_qubo_sol.source_config),
         )
-        *Step 1 -- Source instance.* The canonical CVP example uses basis columns $bold(b)_1 = #fmt-vec(basis.at(0))$ and $bold(b)_2 = #fmt-vec(basis.at(1))$, target $bold(t) = #fmt-vec(target)$, and bounds $x_1, x_2 in [#bounds.at(0).lower, #bounds.at(0).upper]$.
+        *Step 1 -- Source instance.* The canonical CVP example has basis columns $bold(b)_1=#fmt-vec(basis.at(0))$ and $bold(b)_2=#fmt-vec(basis.at(1))$ and target $bold(t)=#fmt-vec(target)$. The source model supplies no coefficient bounds.
 
-        *Step 2 -- Exact bounded encoding.* Each variable has #bounds.at(0).upper - bounds.at(0).lower + 1 admissible values, so the implementation uses the capped binary basis $(1, 2, 3)$ rather than $(1, 2, 4)$: the first two bits are powers of two, and the last weight is capped so every bit pattern reconstructs an offset in ${0, dots, 6}$. Thus
-        $ x_1 = #bounds.at(0).lower + z_0 + 2 z_1 + 3 z_2, quad x_2 = #bounds.at(1).lower + z_3 + 2 z_4 + 3 z_5 $
-        giving #cvp_qubo.target.instance.num_vars QUBO variables in total.
+        *Step 2 -- Derive a safe box.* Here $A=((2,1),(0,2))$, $norm(bold(t))_1=5$, and the selected-row bounds are $bold(C)=(8,7)$. Since $op("adj")(A)=((2,-1),(0,2))$, the reduction obtains $M_1=23$ and $M_2=14$.
 
-        *Step 3 -- Build the QUBO.* For this instance, $G = A^top A = ((4, 2), (2, 5))$ and $h = A^top bold(t) = (5.6, 5.8)^top$. Expanding the shifted quadratic form yields the exported upper-triangular matrix with representative entries $Q_(0,0) = #matrix.at(0).at(0)$, $Q_(0,1) = #matrix.at(0).at(1)$, $Q_(0,2) = #matrix.at(0).at(2)$, $Q_(2,5) = #matrix.at(2).at(5)$, and $Q_(5,5) = #matrix.at(5).at(5)$.
+        *Step 3 -- Encode and expand.* The exact-range weights are $(1,2,4,8,16,15)$ for $x_1+23 in [0,46]$ and $(1,2,4,8,13)$ for $x_2+14 in [0,28]$, giving #cvp_qubo.target.instance.num_vars variables. With $G=B^top B=((4,2),(2,5))$ and $h=B^top bold(t)=(6,7)^top$, representative coefficients are $Q_(0,0)=#matrix.at(0).at(0)$, $Q_(0,1)=#matrix.at(0).at(1)$, $Q_(0,6)=#matrix.at(0).at(6)$, and $Q_(6,6)=#matrix.at(6).at(6)$.
 
-        *Step 4 -- Verify a solution.* The fixture stores the canonical witness $bold(z) = (#bits.map(str).join(", "))$, which extracts to source offsets $bold(c) = (#offsets.map(str).join(", "))$ and actual lattice coordinates $bold(x) = (#coords.map(str).join(", "))$. The QUBO value is $bold(z)^top Q bold(z) = #rounded-qubo$; adding back the dropped constant #rounded-constant yields the original squared distance #(rounded-distance-sq), so the extracted point is the closest lattice vector #sym.checkmark.
+        *Step 4 -- Verify a solution.* The fixture stores $bold(z)=(#fmt-values(bits))$, which decodes to $bold(x)=(#fmt-values(coords))$. The QUBO value is #rounded-qubo; adding the dropped constant #rounded-constant gives squared CVP distance #rounded-distance-sq, so $B bold(x)=bold(t)$ #sym.checkmark.
 
-        *Multiplicity.* Offset $3$ has two bit encodings ($(0, 0, 1)$ and $(1, 1, 0)$), so the fixture stores one canonical witness even though the QUBO has multiple optimal binary assignments representing the same CVP solution.
+        *Multiplicity.* Residual final weights make some offsets have multiple encodings, so the fixture stores one canonical bit vector although other optimal QUBO witnesses can decode to the same $bold(x)$.
       ],
     )[
-      A bounded Closest Vector Problem instance already supplies a finite integer box $x_i in [ell_i, u_i]$ for each coefficient. Following the direct quadratic-form reduction of Canale, Qureshi, and Viola @canale2023qubo, encoding each offset $c_i = x_i - ell_i$ with an exact in-range binary basis turns the squared-distance objective into an unconstrained quadratic over binary variables. Unlike penalty-method encodings, no auxiliary feasibility penalty is needed: every bit pattern decodes to a legal coefficient vector by construction.
+      Following the quadratic formulation of Canale, Qureshi, and Viola @canale2023qubo, this rule derives a finite box containing a global minimizer of standard CVP, then encodes that box and expands the squared-distance objective.
     ][
-      _Construction._ Let $A in ZZ^(m times n)$ be the basis matrix with columns $bold(a)_1, dots, bold(a)_n$, let $bold(t) in RR^m$ be the target, and let $x_i in [ell_i, u_i]$ with range $r_i = u_i - ell_i$. Define $L_i = ceil(log_2(r_i + 1))$ when $r_i > 0$ and omit bits when $r_i = 0$. For each variable, introduce binary variables $z_(i,0), dots, z_(i,L_i-1)$ with exact-range weights
-      $ w_(i,p) = 2^p quad (0 <= p < L_i - 1), quad w_(i,L_i-1) = r_i + 1 - 2^(L_i - 1) $
-      so that every bit vector represents an offset in ${0, dots, r_i}$. Then
-      $ x_i = ell_i + sum_(p=0)^(L_i-1) w_(i,p) z_(i,p) $
-      and the total number of QUBO variables is $N = sum_i L_i$, exactly the exported overhead `num_vars = num_encoding_bits`.
+      _Construction._ Let $B in ZZ^(m times n)$ have full column rank and $bold(t) in ZZ^m$. Select $n$ rows forming an invertible matrix $A$, with source row indices $r_j$. Since zero is a candidate, every minimizer $bold(x)^*$ satisfies $norm(B bold(x)^*-bold(t))_2 <= norm(bold(t))_2$. For $bold(y)=A bold(x)^*$, define $C_j=abs(t_(r_j))+norm(bold(t))_1$. Then $abs(y_j)<=C_j$, and $bold(x)^*=op("adj")(A)bold(y)/det(A)$ gives
+      $ abs(x_i^*) <= M_i = sum_j abs(op("adj")(A)_(i,j)) C_j $
+      because the nonzero integer determinant has magnitude at least one.
 
-      Let $G = A^top A$ and $h = A^top bold(t)$. Writing $bold(x) = bold(ell) + B bold(z)$ for the encoding matrix $B in RR^(n times N)$ gives
-      $ norm(A bold(x) - bold(t))_2^2 = bold(z)^top (B^top G B) bold(z) + 2 bold(z)^top B^top (G bold(ell) - h) + "const" $
-      where the constant $norm(A bold(ell) - bold(t))_2^2$ is dropped. Therefore the QUBO coefficients are
-      $ Q_(u,u) = (B^top G B)_(u,u) + 2 (B^top (G bold(ell) - h))_u, quad Q_(u,v) = 2 (B^top G B)_(u,v) quad (u < v) $
-      using the usual upper-triangular convention.
+      Encode $x_i+M_i in [0,2M_i]$ with powers of two and one capped final weight. If $W$ maps the resulting bits to coefficient offsets, $G=B^top B$, $h=B^top bold(t)$, and $bold(ell)=-bold(M)$, then
+      $ norm(B bold(x)-bold(t))_2^2 = bold(z)^top(W^top G W)bold(z) + 2 bold(z)^top W^top(G bold(ell)-h) + "const". $
+      The constant is dropped. The exact bit count depends on concrete entries, so its symbolic transform is unavailable.
 
-      _Correctness._ ($arrow.r.double$) Every binary vector $bold(z) in {0,1}^N$ decodes to a coefficient vector $bold(x)$ inside the prescribed bounds because each exact-range basis reaches only offsets in ${0, dots, r_i}$. Substituting this decoding into the CVP objective yields $bold(z)^top Q bold(z) + "const"$, so any QUBO minimizer maps to a bounded CVP minimizer. ($arrow.l.double$) Every bounded CVP solution $bold(x)$ has at least one bit encoding for each coordinate offset, hence at least one binary vector $bold(z)$ with the same objective value up to the dropped constant. Thus the minimizers correspond exactly, although several binary witnesses may decode to the same CVP solution.
+      _Correctness._ ($arrow.r.double$) Every bit vector decodes inside the derived box and has QUBO value equal to its CVP squared distance minus one common constant, so a QUBO minimizer is best within the box. ($arrow.l.double$) The derived box contains a global CVP minimizer, and every point in the box has an exact-range encoding. Therefore the best encoded point is globally optimal for CVP.
 
-      _Solution extraction._ For each source variable, sum its selected encoding weights to recover the source configuration offset $c_i = x_i - ell_i$. This is exactly the configuration format expected by the `ClosestVectorProblem` model.
+      _Solution extraction._ Sum the selected weights for each coefficient and subtract $M_i$.
     ]
   ]
 }
@@ -12144,9 +12043,9 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(kc_qubo.source) + " -o kcoloring.json",
-      "pred reduce kcoloring.json --to " + target-spec(kc_qubo) + " -o bundle.json",
+      "pred reduce kcoloring.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate kcoloring.json --config " + kc_qubo_sol.source_config.map(str).join(","),
+      "pred evaluate kcoloring.json --config " + cli-config(kc_qubo_sol.source_config),
     )
     #{
       let hg = house-graph()
@@ -12162,76 +12061,63 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
     *Step 1 -- Encode each color choice as a binary variable.* A coloring assigns each vertex one of $k$ colors. To express this in binary, introduce $k$ indicator variables per vertex: $x_(v,c) = 1$ means "vertex $v$ gets color $c$." For the house graph with $k = 3$, this gives $n k = 5 times 3 = 15$ QUBO variables:
     $ underbrace(x_(0,0) x_(0,1) x_(0,2), "vertex 0") #h(4pt) underbrace(x_(1,0) x_(1,1) x_(1,2), "vertex 1") #h(4pt) dots.c #h(4pt) underbrace(x_(4,0) x_(4,1) x_(4,2), "vertex 4") $
 
-    *Step 2 -- Penalize invalid color assignments (one-hot constraint).* A valid coloring requires each vertex to have _exactly one_ color, i.e.\ $sum_c x_(v,c) = 1$. The penalty $(1 - sum_c x_(v,c))^2$ equals zero when exactly one variable is 1, and is positive otherwise. Weighted by $P_1 = 1 + n = 6$, this contributes diagonal entries $Q_(v k+c, v k+c) = -6$ and off-diagonal entries $Q_(v k+c_1, v k+c_2) = 12$ between colors of the same vertex. These form the $5 times 5$ diagonal blocks of $Q$.\
+    *Step 2 -- Penalize invalid color assignments (one-hot constraint).* A valid coloring requires each vertex to have _exactly one_ color, i.e.\ $sum_c x_(v,c) = 1$. The penalty $(1 - sum_c x_(v,c))^2$ equals zero when exactly one variable is 1, and is positive otherwise. We multiply the entire former half-integral objective by 2. With $P = 1 + n = 6$, the one-hot term $2P(1 - sum_c x_(v,c))^2$ contributes diagonal entries $Q_(v k+c, v k+c) = -12$ and off-diagonal entries $Q_(v k+c_1, v k+c_2) = 24$ between colors of the same vertex. These form the $5 times 5$ diagonal blocks of $Q$.\
 
-    *Step 3 -- Penalize same-color neighbors (edge conflict).* For each edge $(u,v) in E$ and each color $c$, the product $x_(u,c) x_(v,c) = 1$ iff both endpoints receive color $c$ — exactly the coloring conflict we want to forbid. The penalty $P_2 dot x_(u,c) x_(v,c)$ with $P_2 = P_1 slash 2 = 3$ makes such conflicts costly. The house has 6 edges, each contributing 3 color-conflict penalties $arrow.r$ 18 off-diagonal entries of value $3$ in $Q$.\
+    *Step 3 -- Penalize same-color neighbors (edge conflict).* For each edge $(u,v) in E$ and each color $c$, the product $x_(u,c) x_(v,c) = 1$ iff both endpoints receive color $c$ — exactly the coloring conflict we want to forbid. In the scaled integer objective, each conflict has coefficient $P = 6$. The house has 6 edges, each contributing 3 color-conflict penalties $arrow.r$ 18 off-diagonal entries of value $6$ in $Q$.\
 
-    *Step 4 -- Verify a solution.* The first valid 3-coloring is $(c_0, ..., c_4) = (#kc_qubo_sol.source_config.map(str).join(", "))$, shown in the figure above. The one-hot encoding is $bold(x) = (#kc_qubo_sol.target_config.map(str).join(", "))$. Check: each 3-bit group has exactly one 1 (valid one-hot #sym.checkmark), and for every edge the two endpoints have different colors (e.g.\ edge $0 dash 1$: colors $#kc_qubo_sol.source_config.at(0), #kc_qubo_sol.source_config.at(1)$ #sym.checkmark).\
+    *Step 4 -- Verify a solution.* The first valid 3-coloring is $(c_0, ..., c_4) = (#fmt-values(kc_qubo_sol.source_config))$, shown in the figure above. The one-hot encoding is $bold(x) = (#fmt-values(kc_qubo_sol.target_config))$. Check: each 3-bit group has exactly one 1 (valid one-hot #sym.checkmark), and for every edge the two endpoints have different colors (e.g.\ edge $0 dash 1$: colors $#kc_qubo_sol.source_config.at(0), #kc_qubo_sol.source_config.at(1)$ #sym.checkmark).\
 
     *Multiplicity:* The fixture stores one canonical coloring witness. The house graph has $3! times 3 = 18$ valid colorings overall: the triangle $2 dash 3 dash 4$ forces 3 distinct colors ($3! = 6$ permutations), and for each, the base vertices $0, 1$ have exactly $3$ compatible ordered pairs.
   ],
 )[
-  The $k$-coloring problem has two requirements: each vertex gets exactly one color, and adjacent vertices get different colors. Both can be expressed as quadratic penalties over binary variables. Introduce $n k$ binary variables $x_(v,c) in {0,1}$ (indexed by $v dot k + c$), where $x_(v,c) = 1$ means vertex $v$ receives color $c$. The first requirement becomes a _one-hot constraint_ penalizing vertices with zero or multiple colors; the second becomes an _edge conflict penalty_ penalizing same-color neighbors. The combined QUBO matrix $Q in RR^(n k times n k)$ encodes both penalties.
+  The $k$-coloring problem has two requirements: each vertex gets exactly one color, and adjacent vertices get different colors. Both can be expressed as quadratic penalties over binary variables. Introduce $n k$ binary variables $x_(v,c) in {0,1}$ (indexed by $v dot k + c$), where $x_(v,c) = 1$ means vertex $v$ receives color $c$. The first requirement becomes a _one-hot constraint_ penalizing vertices with zero or multiple colors; the second becomes an _edge conflict penalty_ penalizing same-color neighbors. The combined integer QUBO matrix $Q in ZZ^(n k times n k)$ encodes both penalties.
 ][
   _Construction._ Applying the penalty method (@sec:penalty-method), the two requirements translate into two penalty terms:
-  $ f(bold(x)) = underbrace(P_1 sum_(v in V) (1 - sum_(c=1)^k x_(v,c))^2, "one-hot: exactly one color per vertex") + underbrace(P_2 sum_((u,v) in E) sum_(c=1)^k x_(u,c) x_(v,c), "edge conflict: neighbors differ") $
+  $ f(bold(x)) = underbrace(2P sum_(v in V) (1 - sum_(c=1)^k x_(v,c))^2, "one-hot: exactly one color per vertex") + underbrace(P sum_((u,v) in E) sum_(c=1)^k x_(u,c) x_(v,c), "edge conflict: neighbors differ") $
 
   _One-hot expansion._ The constraint $(1 - sum_c x_(v,c))^2$ penalizes any vertex with $!= 1$ active color. Expanding using $x_(v,c)^2 = x_(v,c)$ (binary variables):
   $ (1 - sum_c x_(v,c))^2 = 1 - sum_c x_(v,c) + 2 sum_(c_1 < c_2) x_(v,c_1) x_(v,c_2) $
-  Reading off the QUBO coefficients: diagonal $Q_(v k+c, v k+c) = -P_1$ (favors assigning a color) and intra-vertex off-diagonal $Q_(v k+c_1, v k+c_2) = 2 P_1$ for $c_1 < c_2$ (discourages multiple colors).
+  Reading off the QUBO coefficients: diagonal $Q_(v k+c, v k+c) = -2P$ (favors assigning a color) and intra-vertex off-diagonal $Q_(v k+c_1, v k+c_2) = 4P$ for $c_1 < c_2$ (discourages multiple colors).
 
-  _Edge conflict._ For each edge $(u,v)$ and color $c$, the product $x_(u,c) x_(v,c)$ equals 1 iff both endpoints share color $c$. The penalty $P_2 x_(u,c) x_(v,c)$ adds $P_2$ to $Q_(u k+c, v k+c)$ (with appropriate index ordering).
+  _Edge conflict._ For each edge $(u,v)$ and color $c$, the product $x_(u,c) x_(v,c)$ equals 1 iff both endpoints share color $c$. The penalty $P x_(u,c) x_(v,c)$ adds $P$ to $Q_(u k+c, v k+c)$ (with appropriate index ordering).
 
-  In our implementation, $P_1 = P = 1 + n$ and $P_2 = P\/2$. The penalty $P_1$ exceeds the number of vertices, ensuring that any constraint violation outweighs any objective gain.
+  In our implementation, $P = 1 + n$ and the stored integer objective is twice the equivalent half-integral formulation: one-hot coefficients are scaled from $(-P, 2P)$ to $(-2P, 4P)$ and edge-conflict coefficients from $P\/2$ to $P$. Multiplication by the positive constant 2 preserves the complete argmin set.
 
-  _Correctness._ ($arrow.r.double$) If $bold(x)$ violates any one-hot constraint (some vertex has 0 or $>= 2$ colors), the penalty $P_1 > n$ exceeds the objective range, so $bold(x)$ is not a minimizer. ($arrow.l.double$) Among valid one-hot encodings, $f$ reduces to the edge conflict term, minimized when no two adjacent vertices share a color — exactly the $k$-coloring objective.
+  _Correctness._ The stored QUBO energy is $E(bold(x)) = f(bold(x)) - 2P n$. Every term of $f$ is nonnegative, so $E(bold(x)) >= -2P n$, with equality precisely when every vertex has one color and every edge has differently colored endpoints (@lucas2014, Section 6.1).
+  ($arrow.r.double$) Given a proper coloring, set exactly its indicated color bit at each vertex. Both penalty sums vanish, so its QUBO energy is $-2P n$, attaining the global lower bound.
+  ($arrow.l.double$) If a target configuration has energy $-2P n$, each nonnegative penalty vanishes. Every vertex therefore has a unique selected color, and the edge penalties imply a proper source coloring. If the graph has no proper coloring, every target configuration has energy strictly greater than $-2P n$; an optimal target configuration alone is not a coloring certificate.
 
-  _Solution extraction._ For each vertex $v$, find $c$ with $x_(v,c) = 1$.
+  _Aggregation and extraction._ Map a finite target optimum equal to $-2P n$ to true, and every other target value to false. Validate a target configuration once and apply this same equality test before reading its unique selected color in each row. In particular, reject one-hot configurations with monochromatic edges, as well as rows with zero or multiple selected colors. The omitted constant and matrix dimensions are computed with checked integer arithmetic before allocation. For $n = 0$ the empty coloring attains energy zero, including $k = 0$; for $n > 0$, $k = 0$, the empty target configuration has energy zero greater than the negative threshold and certifies no coloring.
 ]
 
 #reduction-rule("MaximumSetPacking", "QUBO")[
-  Set packing selects mutually disjoint sets of maximum total weight. Two sets conflict if and only if they share a universe element — the same adjacency structure as an independent set on the _intersection graph_. This reduction builds the intersection graph implicitly and applies the IS penalty method directly: each set becomes a QUBO variable, diagonal entries reward selection, and off-diagonal entries penalize pairs of overlapping sets with a penalty large enough to forbid any overlap.
+  Encode set selection with one binary variable per set and penalize overlapping pairs. The construction supports positive, zero, and negative weights.
 ][
-  _Construction._ Given sets $S_1, ..., S_m$ with weights $w_1, ..., w_m$, introduce binary variables $x_i in {0,1}$ for each set. Two sets $S_i, S_j$ _conflict_ iff $S_i inter S_j != emptyset$. The packing objective is: maximize $sum_i w_i x_i$ subject to $x_i x_j = 0$ for every conflicting pair. Applying the penalty method (@sec:penalty-method):
-  $ f(bold(x)) = -sum_i w_i x_i + P sum_(S_i inter S_j != emptyset, thin i < j) x_i x_j $
-  with $P = 1 + sum_i w_i$. The QUBO coefficients are: diagonal $Q_(i i) = -w_i$ (reward for selecting set $S_i$), off-diagonal $Q_(i j) = P$ for each conflicting pair $i < j$ (penalty for overlap).
+  _Construction._ Given sets $S_1, ..., S_m$ with finite real weights $w_1, ..., w_m$, let $M = max({1} union {w_i : 1 <= i <= m})$ and $P = 2M$. Introduce binary variables $x_i$ and minimize
+  $ f(bold(x)) = -sum_i w_i x_i + P sum_(i < j, thin S_i inter S_j != emptyset) x_i x_j. $
+  Thus $Q_(i i) = -w_i$ and $Q_(i j) = P$ for conflicting pairs $i < j$, with all other entries zero. The floating-point implementation rejects a non-finite computed penalty; it never emits an infinite coefficient. As with the source and target real-weight models, numerical evaluation uses finite approximate arithmetic.
+
+  _Correctness._ First suppose an assignment selects a set $S_i$ that conflicts with $d >= 1$ other selected sets. Removing $S_i$ changes the energy by $w_i - P d < 0$, since $P > max(0, w_i)$. Therefore every minimizer is a packing, including when some weights are zero or negative. Repeating such removals turns any conflicting assignment into a packing of strictly lower energy.
 
-  _Correctness._ ($arrow.r.double$) If $bold(x)$ encodes a maximum-weight packing, all selected sets are mutually disjoint, so all penalty terms vanish and $f(bold(x)) = -sum_(i in cal(P)) w_i$. Any assignment selecting overlapping sets incurs penalty $P > sum_i w_i$, making it suboptimal. ($arrow.l.double$) Among feasible assignments (no overlapping sets selected), the penalty terms vanish and $f(bold(x)) = -sum_(i in cal(P)) w_i$, minimized exactly when $cal(P)$ is a maximum-weight packing.
+  ($arrow.r.double$) A maximum-weight packing has energy equal to the negative optimum packing weight. Every other packing has at least this energy, and every conflicting assignment has higher energy than some packing. Hence every maximum-weight packing minimizes $f$.
 
-  _Solution extraction._ Return $bold(x)$ directly — each $x_i = 1$ indicates set $S_i$ is in the packing.
+  ($arrow.l.double$) Every minimizer is conflict-free by the deletion argument. On conflict-free assignments $f(bold(x)) = -sum_i w_i x_i$, so a minimizer must maximize the packing weight. This holds for every target minimizer, not just one choice among ties. Empty sets and an empty family require no special construction.
+
+  _Solution extraction._ Return $bold(x)$ directly. There are exactly $m$ target variables.
 ]
 
 #reduction-rule("KSatisfiability", "QUBO")[
-  Each clause in a $k$-SAT formula is falsified by exactly one assignment to its literals. For $k = 2$, this falsifying pattern is a product of two (possibly complemented) binary variables — already quadratic, so each clause maps directly to QUBO terms. For $k = 3$, the falsifying pattern $y_1 y_2 y_3$ is cubic; Rosenberg quadratization replaces the product $y_1 y_2$ with an auxiliary variable $a$, enforced by a penalty that makes $a != y_1 y_2$ suboptimal. The total QUBO counts unsatisfied clauses, so minimizers maximize satisfiability.
+  Clause falsification penalties become a quadratic objective using Rosenberg quadratization. Retain its omitted constant to decode the SAT decision, rather than interpreting an arbitrary QUBO configuration as a satisfying assignment.
 ][
-  *Case $k = 2$.*
-
-  _Construction._ Each 2-literal clause has exactly one falsifying assignment (both literals false). The penalty for that assignment is a quadratic function of $x_i, x_j$:
+  _Construction._ Let $n$ be the number of source variables and $m$ the clause count. For each literal let $y$ be its falsity indicator: $y=1-x$ for a positive literal and $y=x$ for a negative one. For widths zero, one and two, the clause penalty is respectively $1$, $y_1$, and $y_1 y_2$. For width three use
+  $ H = a y_3 + 2(y_1 y_2 - 2 y_1 a - 2 y_2 a + 3a). $
+  Rosenberg's penalty is zero when $a=y_1 y_2$ and positive otherwise @borosgruber2014quadratization. Its multiplier 2 strictly exceeds the possible unit gain from the $a y_3$ term. Thus minimizing over each independent auxiliary gives exactly the clause falsification indicator, including repeated or complementary literals. Expand with $x^2=x$ into an upper-triangular QUBO matrix, and retain the omitted constant $C$.
 
-  #table(
-    columns: (auto, auto, auto, auto),
-    inset: 4pt,
-    align: left,
-    table.header([*Clause*], [*Falsified when*], [*Penalty*], [*QUBO contributions*]),
-    [$x_i or x_j$], [$x_i=0, x_j=0$], [$(1-x_i)(1-x_j)$], [$Q_(i i) -= 1, Q_(j j) -= 1, Q_(i j) += 1$],
-    [$overline(x_i) or x_j$], [$x_i=1, x_j=0$], [$x_i(1-x_j)$], [$Q_(i i) += 1, Q_(i j) -= 1$],
-    [$x_i or overline(x_j)$], [$x_i=0, x_j=1$], [$(1-x_i)x_j$], [$Q_(j j) += 1, Q_(i j) -= 1$],
-    [$overline(x_i) or overline(x_j)$], [$x_i=1, x_j=1$], [$x_i x_j$], [$Q_(i j) += 1$],
-  )
+  _Correctness._ For every source assignment, the minimum target energy over auxiliaries is the number of falsified clauses minus $C$. Every clause expression is nonnegative before subtracting $C$. Hence the formula is satisfiable iff the global target minimum is exactly $-C$. A satisfying assignment lifts by setting each cubic auxiliary to $y_1 y_2$; every zero-penalty target configuration projects to a satisfying source assignment. If an empty clause occurs, its constant penalty 1 prevents the threshold from being attained. Empty formulas have $C=0$ and every source assignment satisfies them.
 
-  Summing over all clauses, $f(bold(x)) = sum_j "penalty"_j (bold(x))$ counts falsified clauses.
+  _Extraction._ Formal target validation precedes decoding. The registered aggregate decoder maps `Min(E)` to `Or(E == Some(-C))`; direct witness extraction rejects other energies and reads the first $n$ coordinates only at the threshold. It does not solve SAT or repair auxiliary assignments. Target optimality must be established before interpreting an aggregate result as the source decision.
 
-  _Correctness._ ($arrow.r.double$) Each penalty term is non-negative and equals 1 exactly when its clause is falsified. If $bold(x)$ satisfies all clauses, $f(bold(x)) = 0$. ($arrow.l.double$) Any minimizer of $f$ achieves the fewest falsified clauses, hence maximizes satisfiability.
-
-  *Case $k = 3$ (Rosenberg quadratization).*
-
-  _Construction._ For each clause $(ell_1 or ell_2 or ell_3)$, define complement variables $y_i = overline(ell_i)$ (so $y_i = x_i$ if the literal is negated, $y_i = 1 - x_i$ if positive). The clause is violated when $y_1 y_2 y_3 = 1$. This cubic penalty is reduced to quadratic form by introducing an auxiliary variable $a$ and the substitution $a = y_1 y_2$, enforced via a Rosenberg penalty with weight $M$:
-  $ H = a dot y_3 + M (y_1 y_2 - 2 y_1 a - 2 y_2 a + 3a) $
-  where $M = 2$ suffices. Each clause adds one auxiliary variable (indices $n, n+1, ..., n+m-1$), so the total QUBO has $n + m$ variables.
-
-  _Correctness._ ($arrow.r.double$) If $a = y_1 y_2$, the Rosenberg penalty term vanishes and $H = y_1 y_2 y_3$ counts the clause violation faithfully. ($arrow.l.double$) If $a != y_1 y_2$, the penalty $M(dots.c) >= 1$ strictly exceeds the clause-counting contribution (at most 1), so any minimizer must have $a = y_1 y_2$ for every clause. Among such assignments, $H$ counts unsatisfied clauses, and minimizers maximize satisfiability.
-
-  _Solution extraction._ Discard auxiliary variables: return $bold(x)[0..n]$.
+  _Domain and overhead._ The K2 variant has $n$ variables; K3 reserves $n+m$, with unused auxiliaries mathematically free for short clauses. Native `new_allow_less` permits widths up to K; CLI and serde still require exactly K per actual clause. Source `Or` maps to target `Min<i64>` with an explicitly stored signed threshold. Matrix and constant accumulation use checked arithmetic; literal indices come from the formal `CNFClause::variables` API. Neither endpoint nor variant changes.
 ]
 
 #let ksat_qc = load-example("KSatisfiability", "QuadraticCongruences")
@@ -12242,8 +12128,8 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_qc.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_qc) + " -o bundle.json",
-      "pred evaluate ksat.json --config " + ksat_qc_sol.source_config.map(str).join(","),
+      "pred reduce ksat.json --via route.json -o bundle.json",
+      "pred evaluate ksat.json --config " + cli-config(ksat_qc_sol.source_config),
     )
 
     #{
@@ -12252,49 +12138,58 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
       let c = ksat_qc.target.instance.c
       let witness-bits = ksat_qc_sol.target_config.len()
       [
-        *Step 1 -- Source instance.* The canonical formula is the single clause $(x_1 or x_2 or x_3)$, witnessed by the satisfying assignment $(#ksat_qc_sol.source_config.map(str).join(", "))$.
+        *Step 1 -- Source instance.* The canonical formula is the single clause $(x_1 or x_2 or x_3)$, witnessed by the satisfying assignment $(#fmt-values(ksat_qc_sol.source_config))$.
 
         *Step 2 -- Enumerate standard clauses.* With $l = 3$ active variables, the construction lists all $M = 8$ signed 3-clauses on ${x_1, x_2, x_3}$. This yields $N = 2M + l = 19$ lifted coefficients in the doubled knapsack encoding.
 
         *Step 3 -- Lift by CRT.* Using $N+1 = 20$ odd primes starting at 13, the reduction builds the CRT gadgets $theta_0, dots, theta_N$ and outputs $(a, b, c)$. In the canonical fixture these numbers have $#a.len()$, $#b.len()$, and $#c.len()$ decimal digits respectively, so the paper reports their sizes rather than expanding them inline.
 
-        *Step 4 -- Verify the stored witness.* The example DB keeps the target witness in binary using $#witness-bits$ bits. Evaluating that witness satisfies $x^2 equiv a mod b$ with $1 <= x < c$, and extraction recovers the original source assignment $(#ksat_qc_sol.source_config.map(str).join(", "))$ #sym.checkmark.
+        *Step 4 -- Verify the stored witness.* The example DB keeps the target witness in binary using $#witness-bits$ bits. Evaluating that witness satisfies $x^2 equiv a mod b$ with $1 <= x < c$, and extraction recovers the original source assignment $(#fmt-values(ksat_qc_sol.source_config))$ #sym.checkmark.
       ]
     }
 
     *Multiplicity:* The fixture stores one canonical satisfying witness.
   ],
 )[
-  Manders and Adleman's number-theoretic reduction encodes a 3-SAT assignment as a pattern of signs $alpha_j in {-1, +1}$ in a bounded knapsack-style congruence, then uses carefully chosen prime powers and the Chinese Remainder Theorem to realize those signs as divisibility conditions on $H - x$ and $H + x$. Squaring removes the sign ambiguity and yields one quadratic congruence $x^2 equiv a mod b$ together with an explicit bound $x < c$. The bound is essential: without it, the composite-modulus quadratic residuosity problem becomes much easier once the factorization of $b$ is known.
+  The bounded quadratic-congruence construction of Manders and Adleman @mandersAdleman1976 converts an odd signed-knapsack target into a square congruence using prime powers and the Chinese Remainder Theorem. We give base-eight positions only to the actual normalized clauses. The same slack equation handles every native clause width from zero through three.
 ][
-  _Construction._ Given a 3-CNF formula $phi$ with $n$ variables, first deduplicate clauses and restrict to the active variables. Enumerate all signed 3-clauses over those variables as $sigma_1, dots, sigma_M$. Define the base-8 clause weight $8^j$ for $sigma_j$, form $tau_phi = -sum_(sigma_j in phi) 8^j$, and for each variable compute the positive and negative occurrence sums $f_i^+$ and $f_i^-$. In doubled form, set $N = 2M + l$ and coefficients
-  $ d_0 = 2, quad d_(2k-1) = -8^k, quad d_(2k) = -2 dot 8^k, quad d_(2M+i) = f_i^+ - f_i^- $
-  together with
-  $ tau_2 = 2 tau_phi + sum_(j=0)^N d_j + 2 sum_(i=1)^l f_i^- $
-  modulo $2 dot 8^(M+1)$.
+  _Construction._ Delete tautologies and duplicate literals and clauses, retaining empty clauses. Compact the $l$ occurring variables, recording their original positions. Let $C_1, dots, C_m$ be the remaining clauses, $r_j = |C_j|$, $N = 2m+l+1$, and $D=8^(m+1)$. Let $f_i^+$ and $f_i^-$ be the sums of $8^j$ over clauses containing variable $i$ positively and negatively. Define $N$ integer coefficients and an odd target:
+  $ c_0=1, quad c_(2j-1)=-8^j/2, quad c_(2j)=-8^j, quad c_(2m+i)=(f_i^+-f_i^-)/2, $
+  $ tau=1+sum_(j=1)^m (r_j-5)8^j/2. $
+  Take the first $N$ primes starting at $13$, indexed from zero, and put $q_i=p_i^N$ and $K=product_i q_i$. Let $theta_i$ be the least positive integer satisfying $theta_i equiv c_i mod D$, $theta_i equiv 0 mod (K/q_i)$, and $p_i$ not dividing $theta_i$. CRT gives a residue modulo $D K/q_i$; choosing the first positive representative and, if necessary, adding that modulus once gives $theta_i$. Set $H=sum_i theta_i$ and
+  $ b=2D K, quad a=(2D+K)^(-1)(K tau^2+2D H^2) mod b, quad c=H+1. $
+  The target's formal domain is $0<x<c$, equivalently $1<=x<=H$.
+
+  _Clause encoding._ For signs $alpha_i in {-1,+1}$, put $t_i=(1-alpha_(2m+i))/2$ and $y_j=(3-alpha_(2j-1)-2alpha_(2j))/2 in {0,1,2,3}$. Let $T_j$ count true literals in $C_j$ and $R_j=y_j-T_j+1$. Direct expansion gives
+  $ sum_i c_i alpha_i-tau=alpha_0-1+sum_(j=1)^m R_j 8^j. $
+  Here $-2<=R_j<=4$ and $alpha_0-1 in {-2,0}$. The right side has absolute value less than $D$. Taking successive residues modulo eight shows that it vanishes exactly when $alpha_0=1$ and all $R_j=0$. Thus the linear congruence modulo $D$ encodes precisely the satisfying assignments. An empty clause has $T_j=0$ and cannot have $R_j=0$; it requires no exceptional construction.
 
-  Choose distinct odd primes $p_0, dots, p_N >= 13$ and let $K = product_(j=0)^N p_j^(N+1)$. For each $j$, construct $theta_j$ so that
-  $ theta_j equiv d_j mod 2 dot 8^(M+1), quad theta_j equiv 0 mod product_(i != j) p_i^(N+1) $
-  and $p_j$ does not divide $theta_j$. Set $H = sum_j theta_j$, $b = 2 dot 8^(M+1) dot K$, and
-  $ a = (2 dot 8^(M+1) + K)^(-1) (K tau_2^2 + 2 dot 8^(M+1) H^2) mod b, quad c = H + 1. $
+  _Magnitude and square-root lemmas._ Each $theta_i<=2D K/q_i$. For $m>=1$, $N>=2m+1>=3$ and $13^N>4N D$, giving $2H<K$. When $m=0$, no variable occurs, and $N=1$, $theta_0=1$, $K=13$ give the same inequality. Also $tau equiv 1 mod 4$ and $D$ is a power of two divisible by eight. For odd $tau$, $x^2 equiv tau^2 mod (2D)$ holds exactly when $x equiv tau$ or $x equiv -tau mod D$: among $x-tau$ and $x+tau$, one has exactly one factor of two and the other must contain all the remaining factors. This is the odd-target hypothesis of the original square-root lemma; doubling the coefficients without increasing the square modulus does not preserve it.
 
-  _Correctness._ ($arrow.r.double$) A satisfying assignment determines signs $alpha_j in {-1, +1}$ for the lifted knapsack system so that $x = sum_j alpha_j theta_j$ obeys both $x equiv tau_2 mod 2 dot 8^(M+1)$ and $(H+x)(H-x) equiv 0 mod K$. These together imply $x^2 equiv a mod b$ with $0 <= x <= H < c$. ($arrow.l.double$) Any witness $x < c$ with $x^2 equiv a mod b$ yields, for each $j$, a unique sign from whether $p_j^(N+1)$ divides $H-x$ or $H+x$. Those signs recover an exact knapsack solution and hence a satisfying assignment of the original 3-SAT instance.
+  _Forward direction._ A satisfying assignment chooses $alpha_0=1$ and $y_j=T_j-1 in {0,1,2}$. With $z=sum_i alpha_i theta_i$, the linear congruence gives $z equiv tau mod D$, hence $z$ is odd and $z^2 equiv tau^2 mod (2D)$. For every $i$, $z equiv alpha_i H mod q_i$, so $z^2 equiv H^2 mod K$. Therefore $x=|z|$ is positive, at most $H$, and satisfies the target congruence by CRT.
 
-  _Solution extraction._ Recover each sign $alpha_j$ from the divisibility of $H - x$ and $H + x$ by $p_j^(N+1)$. For variable coordinates $j = 2M+i$, interpret $alpha_j = -1$ as $x_i = 1$ and $alpha_j = +1$ as $x_i = 0$.
+  _Backward direction and extraction._ A target witness satisfies both square congruences. Since $p_i$ does not divide $H$, exactly one of $H-x$ and $H+x$ is divisible by $q_i$; write the corresponding sign as $epsilon_i$. The signed sum $z=sum_i epsilon_i theta_i$ is congruent to $x$ modulo $K$. The inequality $|z-x|<=2H<K$ implies $z=x$. The square-root lemma gives $x equiv plus.minus tau mod D$. Since $theta_0 equiv 1 mod 4$ and every other $theta_i equiv 0 mod 4$, the sign $epsilon_0$ chooses the orientation: $alpha_i=epsilon_0 epsilon_i$ has $alpha_0=1$ and its signed sum is congruent to $tau$ modulo $D$. The clause encoding then proves source feasibility. The extractor validates the target once, rejects `Or(false)`, and returns $t_i=1$ exactly when $epsilon_i != epsilon_0$ at a variable coordinate. Restore original variable positions and set free, absent coordinates to false.
+
+  _Domain and overhead._ Both endpoints have value type `Or`; the target witness and arithmetic use arbitrary-precision integers. Literal and clause normalization is valid for native widths zero through three, while CLI/serde retain their existing exact-K contract. For original counts $s$ variables and $c_s$ clauses, let $U=2c_s+s+1$. The implementation uses checked coordinate counts and `u64` primes, so each target bit length is at most $64U^2+3c_s+4$: $K<2^(64N^2)$, $b=2D K$, and $H+1<=K$. No endpoint or variant changes.
 ]
 
 #reduction-rule("KSatisfiability", "QuadraticDiophantineEquations")[
-  This reduction chains through the Manders--Adleman quadratic congruence construction. Given a 3-SAT instance $phi$, first reduce to a Quadratic Congruences instance $(a, b, c)$ with $x^2 equiv a mod b$ and $x < c$, then convert the bounded congruence into a Diophantine equation $x^2 + b' y = c'$ with $a' = 1$. The conversion exploits the fact that $x < c$ implies $x^2$ is bounded, so the residue $c' - x^2$ is always positive and divisible by $b'$ precisely when the congruence holds.
+  Compose the preceding Manders--Adleman bounded-congruence construction with an exact conversion to $x^2 + B y = C$ in positive integers. Both native solution types are `BigUint`, representing $x$; both value types are `Or`. The target model recovers the unique $y$ from $x$.
 ][
-  _Construction._ Given a 3-CNF formula $phi$ with $n$ variables and $m$ clauses:
+  _Construction._ First obtain the formal congruence instance $(a,b,c)$ with $0<=a<b$, $b,c>0$, and witnesses $0<x<c$. Let $h=c-1$. If $c=1$ or $h^2<a$, output $x^2+y=1$, which has no positive solution. Otherwise put
+  $ p=floor((h^2-a)/b)+1, quad C=a+b p, quad B=b. $
+  Output the native equation instance $(1,B,C)$. Its parameters are positive and obey
+  $ h^2<C<=h^2+b, quad C-b<=h^2. $
 
-  *Step 1.* Apply the Manders--Adleman reduction (KSatisfiability $arrow.r$ QuadraticCongruences) to obtain $(a, b, c)$ such that $phi$ is satisfiable iff $exists x < c: x^2 equiv a mod b$.
+  _Forward direction._ A congruence witness has $1<=x<=h$ and $x^2=a+b k$ for an integer $k>=0$. In particular $h^2>=a$, so neither NO branch applies. Since $x^2<=h^2<C$, the integer $y=(C-x^2)/b=p-k$ is positive and satisfies the equation. The source SAT assignment lifts through the preceding congruence theorem.
 
-  *Step 2.* Convert to a Diophantine equation. Let $h = c - 1$. Compute a padding value $p = floor((h^2 - a) \/ b) + 1$ and set $c' = a + b dot p$. Output the Diophantine equation $x^2 + b y = c'$ (i.e., $a' = 1$, $b' = b$). A positive integer $x$ with $x^2 + b y = c'$ must satisfy $y = (c' - x^2) \/ b > 0$, which requires $1 <= x <= h = c - 1$.
+  _Backward direction._ For a positive solution of the nonconstant target, $x^2=C-b y equiv a mod b$ and
+  $ x^2<=C-b<=h^2, $
+  hence $1<=x<=h<c$. Thus the same native integer $x$ is a valid congruence witness and its established extractor returns a satisfying SAT assignment. If the fixed NO target was selected, no positive solution exists; the congruence also has no witness because its positive interval is empty or every allowed square is less than its least nonnegative residue $a$.
 
-  _Correctness._ ($arrow.r.double$) If $phi$ is satisfiable, the congruence has a witness $x_0 < c$ with $x_0^2 equiv a mod b$. Then $x_0^2 - a = b k$ for some non-negative integer $k$. Since $c' = a + b p$ and $x_0 <= c - 1 = h$, we have $c' - x_0^2 = b(p - k) > 0$, and $y = p - k$ is a positive integer. So $(x_0, y)$ is a solution to $x^2 + b y = c'$. ($arrow.l.double$) If $(x, y)$ satisfies $x^2 + b y = c'$ with $x, y >= 1$, then $x^2 = c' - b y equiv c' mod b equiv a mod b$ (since $c' = a + b p$). Also $x^2 < c' = a + b p <= h^2 + b$, and since $y >= 1$ we have $x^2 = c' - b y <= c' - b < h^2 + b - b = h^2$, so $x <= h < c$. Thus $x$ is a valid congruence witness, and the original formula is satisfiable.
+  _Endpoint equality._ The inequality $C-b<=h^2$ can be equality and must not be replaced by a strict inequality. For the empty source formula, the upstream instance is $(a,b,c)=(1,208,2)$; the equation is $x^2+208y=209$. Its solution $x=y=1$ has $x=h$ and is valid at both endpoints.
 
-  _Solution extraction._ Decode the Diophantine witness $x$ from its little-endian binary encoding. Then extract a 3-SAT assignment by passing $x$ through the congruence-to-SAT extraction (sign recovery from divisibility by prime powers).
+  _Solution extraction and bounds._ Pass the native `BigUint` witness directly to the validated congruence extractor; no binary-vector conversion is part of the reduction. Its positive-$y$ check and the displayed inequalities cover arbitrary target witnesses, including $x=h$, zero, and out-of-bound integers. If the preceding common bit-length bound is $L=64(2c_s+s+1)^2+3c_s+4$, the new coefficient bit lengths are bounded by $1$, $L$, and $2L+1$, since $C<=h^2+b$; the fixed NO instance obeys the same bounds. Here $s,c_s$ are the original variable and clause counts. All computed integers have arbitrary precision, and no endpoint or variant changes.
 ]
 
 #let ksat_ss = load-example("KSatisfiability", "SubsetSum")
@@ -12305,9 +12200,9 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_ss.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_ss) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_ss_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_ss_sol.source_config),
     )
     Source: $n = #ksat_ss.source.instance.num_vars$ variables, $m = #sat-num-clauses(ksat_ss.source.instance)$ clauses \
     Target: #subsetsum-num-elements(ksat_ss.target.instance) elements, target $= #ksat_ss.target.instance.target$ \
@@ -12346,35 +12241,35 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
       extra: [
         #pred-commands(
           "pred create --example SubsetSum -o subsetsum.json",
-          "pred reduce subsetsum.json --to " + target-spec(ss-cvp) + " -o bundle.json",
+          "pred reduce subsetsum.json --via route.json -o bundle.json",
           "pred solve bundle.json",
-          "pred evaluate subsetsum.json --config " + ss-cvp-sol.source_config.map(str).join(","),
+          "pred evaluate subsetsum.json --config " + cli-config(ss-cvp-sol.source_config),
         )
-        *Step 1 -- Source instance.* The canonical Subset Sum instance has sizes $(#ss-cvp-sizes.map(str).join(", "))$ and target $B = #ss-cvp-target$.
+        *Step 1 -- Source instance.* The canonical Subset Sum instance has sizes $(#fmt-values(ss-cvp-sizes))$ and target $B = #ss-cvp-target$.
 
         *Step 2 -- Build the lattice.* The reduction creates the basis
-        $ bold(B) = #to-mat(ss-cvp-basis) $
-        together with target $ bold(t) = (#ss-cvp-target-vec.map(str).join(", "))^top $
-        and binary bounds $x_i in {0,1}$ for all $#ss-cvp-n$ coordinates.
+        $ bold(B)^top = #to-mat(ss-cvp-basis) $
+        together with target $ bold(t) = (#fmt-values(ss-cvp-target-vec))^top $
+        in the standard CVP model, with no coefficient bounds.
 
-        *Step 3 -- Verify the canonical witness.* The fixture stores $bold(x) = (#ss-cvp-x.map(str).join(", "))$, which selects sizes $3$ and $8$ and therefore satisfies $3 + 8 = #ss-cvp-target$. Since $bold(B) bold(x) = (1, 0, 0, 1, #ss-cvp-target)^top$, the difference vector is $(0.5, -0.5, -0.5, 0.5, 0)^top$ and the Euclidean distance is $sqrt(#ss-cvp-n / 4) = 1$.
+        *Step 3 -- Verify the canonical witness.* The fixture stores coefficients $(#fmt-values(ss-cvp-x))$. Its first four entries select sizes $3$ and $8$, and the final three are carry coefficients. The first coordinate block has residual $(1,0,0,1)$, the second has $(0,-1,-1,0)$, and all bit-equation residuals are zero. Thus the Euclidean distance is $sqrt(4) = 2$.
 
         *Witness semantics.* The example DB stores one canonical minimizer. This source instance also has another satisfying subset, $(1, 1, 1, 0)$, so the reduction has multiple optimal CVP witnesses even though only one is serialized.
       ],
     )[
-      Classical lattice embedding for Subset Sum following Lagarias and Odlyzko @lagarias1985, with the $1/2$-target CVP formulation in the style of Coster et al. @coster1992. For an instance with $n$ elements, the reduction produces $n$ basis vectors in ambient dimension $n + 1$: the first $n$ coordinates enforce binary structure and the last coordinate records the subset sum error.
+      The classical exact-distance embedding @micciancio2001 enforces binary coefficients through a minimum squared-distance threshold. To retain arbitrary-precision source integers in the existing integer-basis CVP model, this construction uses paired coordinates and binary carry equations. Its basis entries are only $-2$, $0$, and $1$.
     ][
-      _Construction._ Given sizes $s_0, dots, s_(n-1) in ZZ^+$ and target $B in ZZ^+$, define one basis vector per element:
-      $ bold(b)_i = bold(e)_i + s_i bold(e)_(n+1) $
-      for $i in {0, dots, n-1}$. Equivalently, the basis matrix has columns $bold(b)_0, dots, bold(b)_(n-1)$, so its first $n$ rows form the identity matrix and its last row is $(s_0, dots, s_(n-1))$. Set the target vector to
-      $ bold(t) = (1/2, dots, 1/2, B)^top $
-      and restrict every CVP variable to $x_i in {0, 1}$.
+      _Construction._ Let $n$ be the number of items, and let $b >= 1$ be the maximum bit length of their nonnegative sizes and target $T$. Write $s_(i,j), t_j in {0,1}$ for bit $j$ of size $s_i$ and target $T$. Introduce integer coefficients $x_0, dots, x_(n-1)$ and carries $c_1, dots, c_(b-1)$, with fixed boundary values $c_0=c_b=0$. The displacement vector consists of $x_i$ for all items, then $x_i-1$ for all items, then residuals
+      $ r_j = sum_(i=0)^(n-1) s_(i,j) x_i + c_j - 2 c_(j+1) - t_j $
+      in descending bit order. These linear expressions define the integer basis columns and a target containing only zeros and ones. Carry columns are also ordered by descending bit index. The first $n$ coordinate rows form an identity on item columns; the remaining carry block has unit pivots in this order. Consequently the full-column-rank check has no exponentially growing pivots.
+
+      _Correctness._ Every integer vector satisfies
+      $ norm(bold(B) bold(z)-bold(t))_2^2 = sum_i (x_i^2 + (x_i-1)^2) + sum_j r_j^2 >= n. $
+      ($arrow.r.double$) For a binary subset summing to $T$, ordinary integer addition gives carries $0 <= c_j <= n$ satisfying all bit equations and both boundaries. Its squared distance equals $n$. ($arrow.l.double$) Squared distance at most $n$ forces each $x_i in {0,1}$ and each $r_j=0$. Multiplying the bit equations by $2^j$ and summing cancels the internal carries, yielding $sum_i s_i x_i=T$. Thus the optimum is $sqrt(n)$ exactly for YES instances. Empty item lists and target zero use the same construction.
 
-      _Correctness._ ($arrow.r.double$) If $bold(x) in {0,1}^n$ is a satisfying Subset Sum solution, then $sum_i s_i x_i = B$ and
-      $ norm(bold(B) bold(x) - bold(t))_2^2 = sum_(i=0)^(n-1) (x_i - 1/2)^2 + (sum_i s_i x_i - B)^2 = n/4. $
-      Hence every satisfying subset becomes a CVP solution at distance $sqrt(n / 4)$. ($arrow.l.double$) Conversely, binary bounds force every CVP candidate to lie in ${0,1}^n$. The first $n$ coordinates always contribute exactly $n/4$ to the squared distance, so a CVP minimizer attains distance $sqrt(n/4)$ if and only if the last coordinate contributes $0$, i.e. $sum_i s_i x_i = B$. When the Subset Sum instance is unsatisfiable, every binary vector has strictly larger distance.
+      _Solution extraction._ Validate the target configuration once and require a finite distance exactly $sqrt(n)$ through the formal aggregate certificate. Return the first $n$ coefficients as Boolean selections, accepting one as true; the remaining coefficients are the specified carries. A larger optimal distance proves NO and provides no source witness.
 
-      _Solution extraction._ Return the binary CVP vector unchanged.
+      _Representation._ The target has $2n+b$ coordinates and $n+b-1$ basis columns. Since bit length is not a registered Subset Sum parameter, the symbolic relations are marked unavailable with that reason. Dimensions and the total dense basis byte count are checked before allocation. On a 64-bit platform this bounds $n < 2^30$; the threshold and the unit squared-distance gap remain distinguishable in the target's floating-point evaluation. The paired coordinates and boundary carry equations also ensure every threshold witness has exactly evaluated small integer residuals. The solver uses exact rational sphere-enumeration bounds; runtime limitations are separate from the mathematical equivalence.
     ]
   ]
 }
@@ -12382,21 +12277,19 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 // Removed: SubsetSum → CapacityAssignment (unsound reduction, #1006)
 
 #reduction-rule("ILP", "QUBO")[
-  A binary ILP optimizes a linear objective over binary variables subject to linear constraints. The penalty method converts each equality constraint $bold(a)_k^top bold(x) = b_k$ into the quadratic penalty $(bold(a)_k^top bold(x) - b_k)^2$, which is zero if and only if the constraint is satisfied. Inequality constraints are first converted to equalities using binary slack variables with powers-of-two coefficients. The resulting unconstrained quadratic over binary variables is a QUBO whose matrix $Q$ combines the negated objective (as diagonal terms) with the expanded constraint penalties (as a Gram matrix $A^top A$).
+  Binary ILP constraints are encoded by squared integer residuals with binary slack variables, following the penalty construction discussed by Lucas @lucas2014[Section 3]. The rule retains the omitted constant and uses a certified energy interval to recover the original objective direction or report infeasibility. No assumption that the ILP is feasible is needed.
 ][
-  _Construction._ First, normalize all constraints to equalities. Inequalities $bold(a)_k^top bold(x) <= b_k$ become $bold(a)_k^top bold(x) + sum_(s=0)^(S_k - 1) 2^s y_(k,s) = b_k$ where $S_k = ceil(log_2 (b_k + 1))$ binary slack bits. For $>=$ constraints, the slack has a negative sign. The extended system is $A' bold(x)' = bold(b)$ with $bold(x)' = (bold(x), bold(y)) in {0,1}^(n')$. For minimization, negate $bold(c)$ to convert to maximization.
+  _Construction._ Let the normalized source have $n$ binary variables, rows $a_k x diamond_k b_k$, and original objective coefficients $g_i$. Define the minimization-oriented objective $d=g$ for a minimizing source and $d=-g$ for a maximizing source. For a $<=$ row set $R_k=b_k-sum_i min(a_(k i),0)$, and for a $>=$ row set $R_k=sum_i max(a_(k i),0)-b_k$. Use $S_k=ceil(log_2(R_k+1))$ bits if $R_k>0$, and zero bits otherwise; equality rows have zero slack bits. Add powers-of-two slack with positive sign for $<=$ and negative sign for $>=$. A negative range means the row is impossible on binary assignments; leaving it as an equality still has no zero-residual assignment. A zero range makes equality equivalent to the inequality. A positive range represents every slack needed by a feasible source assignment. Larger representable slacks cannot create spurious zero-residual assignments.
+
+  Write the extended rows as $A' z=b$, where the first $n$ bits of $z$ are $x$ and the remaining bits are row-specific slack. Set $P=1+sum_i |d_i|+sum_k |b_k|$, $C=P sum_k b_k^2$, $L=sum_i min(d_i,0)$, and $U=sum_i max(d_i,0)$. The upper-triangular QUBO matrix has diagonal $Q_(i i)=d_i+P sum_k ((a'_(k i))^2-2 b_k a'_(k i))$ and off-diagonal $Q_(i j)=2P sum_k a'_(k i)a'_(k j)$ for $i<j$; extend $d$ by zeros on slack coordinates. Its energy satisfies
+  $ E(z)+C=d^top x+P sum_k (a'_k z-b_k)^2. $
+  Store the energy interval $[L-C,U-C]$, the constant $C$, and the source sense in the reduction result. Dimensions, matrix arithmetic, constant and interval endpoints are checked before use. The target has $n+sum_k S_k$ variables; its registered overhead remains unavailable because the source parameter vector omits coefficient magnitudes and right-hand sides.
 
-  Applying the penalty method (@sec:penalty-method), combine the negated objective with quadratic constraint penalties:
-  $ f(bold(x)') = -bold(c')^top bold(x)' + P sum_(k=1)^m (bold(a)'_k^(top) bold(x)' - b_k)^2 $
-  where $bold(c)' = (bold(c), bold(0))$ and $P = 1 + ||bold(c)||_1 + ||bold(b)||_1$. Expanding the quadratic penalty:
-  $ sum_k (bold(a)'_k^(top) bold(x)' - b_k)^2 = bold(x)'^(top) A'^(top) A' bold(x)' - 2 bold(b)^top A' bold(x)' + ||bold(b)||_2^2 $
-  Combining with $-bold(c')^top bold(x)'$ and dropping the constant $||bold(b)||_2^2$:
-  $ Q = -"diag"(bold(c)' + 2P bold(b)^top A') + P A'^(top) A' $
-  The diagonal contains linear terms (objective plus constraint); the upper triangle of $A'^(top) A'$ gives quadratic cross-terms.
+  _Forward direction._ Every feasible source assignment has a slack extension satisfying every row, with $E+C=d^top x$ in $[L,U]$. Hence its target energy lies in the stored interval. For positive slack range the powers-of-two encoding represents the exact required slack; for zero range no slack is needed.
 
-  _Correctness._ ($arrow.r.double$) If $bold(x)'^*$ is an optimal ILP solution, then $A' bold(x)'^* = bold(b)$ and all penalty terms vanish, so $f(bold(x)'^*) = -bold(c')^top bold(x)'^*$. ($arrow.l.double$) If any constraint is violated, $(bold(a)'_k^(top) bold(x)' - b_k)^2 >= 1$ and the penalty $P > ||bold(c)||_1$ exceeds the entire objective range, so $bold(x)'$ cannot be a QUBO minimizer. Among feasible assignments (all penalties zero), $f$ reduces to $-bold(c')^top bold(x)'$, minimized at the ILP optimum.
+  _Backward direction and optimization._ For any configuration with nonzero residual, integrality gives a squared-residual sum at least one. Thus $E+C>=L+P>U$, since $P>U-L=sum_i |d_i|$. Such a configuration cannot lie in the stored interval or beat a zero-residual configuration. An energy in the interval therefore has zero residual and projects to a feasible source assignment. When a feasible source exists, minimizing target energy minimizes $d^top x$, which gives the original optimum after reversing the sign for a maximizing source. When no feasible source exists, every target configuration lies above the interval; a finite QUBO optimum is then correctly mapped to an absent source value.
 
-  _Solution extraction._ Discard slack variables: return $bold(x)' [0..n]$.
+  _Aggregate and solution extraction._ The concrete source value is `Extremum<i64>` and the target is `Min<i64>`. The custom aggregate accepts only energies in $[L-C,U-C]$, adds $C$, and reverses the sign for a maximizing source; it returns the corresponding absent `Extremum` otherwise. Checked interval construction guarantees the addition is representable; the strict objective-magnitude penalty bound also makes sign reversal safe. The direct extractor evaluates the target exactly once, reuses this predicate, and returns the first $n$ bits as integer zero/one values only for a zero-residual certificate. Wrong slack choices and infeasible source projections are rejected with a formal extraction error. Target evaluation errors remain errors, not infeasibility claims.
 ]
 
 #let part_cpi = load-example("Partition", "CosineProductIntegration")
@@ -12423,7 +12316,7 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 #let part_ks_n = part_ks_sizes.len()
 #let part_ks_total = part_ks_sizes.fold(0, (a, b) => a + b)
 #let part_ks_capacity = part_ks.target.instance.capacity
-#let part_ks_selected = part_ks_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let part_ks_selected = part_ks_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #let part_ks_selected_sizes = part_ks_selected.map(i => part_ks_sizes.at(i))
 #let part_ks_selected_sum = part_ks_selected_sizes.fold(0, (a, b) => a + b)
 #reduction-rule("Partition", "Knapsack",
@@ -12432,16 +12325,16 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(part_ks.source) + " -o partition.json",
-      "pred reduce partition.json --to " + target-spec(part_ks) + " -o bundle.json",
+      "pred reduce partition.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate partition.json --config " + part_ks_sol.source_config.map(str).join(","),
+      "pred evaluate partition.json --config " + cli-config(part_ks_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical Partition instance has sizes $(#part_ks_sizes.map(str).join(", "))$ with total sum $S = #part_ks_total$, so a balanced witness must hit exactly $S / 2 = #part_ks_capacity$.
+    *Step 1 -- Source instance.* The canonical Partition instance has sizes $(#fmt-values(part_ks_sizes))$ with total sum $S = #part_ks_total$, so a balanced witness must hit exactly $S / 2 = #part_ks_capacity$.
 
-    *Step 2 -- Build the knapsack instance.* The reduction copies each size into both the weight and the value list, producing weights $(#part_ks.target.instance.weights.map(str).join(", "))$, values $(#part_ks.target.instance.values.map(str).join(", "))$, and capacity $C = #part_ks_capacity$. No auxiliary variables are introduced, so the target has the same $#part_ks_n$ binary coordinates as the source.
+    *Step 2 -- Build the knapsack instance.* The reduction copies each size into both the weight and the value list, producing weights $(#fmt-values(part_ks.target.instance.weights))$, values $(#fmt-values(part_ks.target.instance.values))$, and capacity $C = #part_ks_capacity$. No auxiliary variables are introduced, so the target has the same $#part_ks_n$ binary coordinates as the source.
 
-    *Step 3 -- Verify the canonical witness.* The serialized witness uses the same binary vector on both sides, $bold(x) = (#part_ks_sol.source_config.map(str).join(", "))$. It selects elements at indices $\{#part_ks_selected.map(str).join(", ")\}$ with sizes $(#part_ks_selected_sizes.map(str).join(", "))$, so the chosen subset has total weight and value $#part_ks_selected_sum = #part_ks_capacity$. Hence the knapsack solution saturates the capacity and certifies a balanced partition.
+    *Step 3 -- Verify the canonical witness.* The serialized witness uses the same binary vector on both sides, $bold(x) = (#fmt-values(part_ks_sol.source_config))$. It selects elements at indices $\{#fmt-values(part_ks_selected)\}$ with sizes $(#fmt-values(part_ks_selected_sizes))$, so the chosen subset has total weight and value $#part_ks_selected_sum = #part_ks_capacity$. Hence the knapsack solution saturates the capacity and certifies a balanced partition.
 
     *Witness semantics.* The example DB stores one canonical balanced subset. This instance has multiple balanced partitions because several different subsets sum to $#part_ks_capacity$, but one witness is enough to demonstrate the reduction.
   ],
@@ -12465,7 +12358,7 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 #let part_ss_n = part_ss_sizes.len()
 #let part_ss_total = part_ss_sizes.fold(0, (a, b) => a + b)
 #let part_ss_target = part_ss_total / 2
-#let part_ss_selected = part_ss_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let part_ss_selected = part_ss_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #let part_ss_selected_sizes = part_ss_selected.map(i => part_ss_sizes.at(i))
 #let part_ss_selected_sum = part_ss_selected_sizes.fold(0, (a, b) => a + b)
 #reduction-rule("Partition", "SubsetSum",
@@ -12474,16 +12367,16 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(part_ss.source) + " -o partition.json",
-      "pred reduce partition.json --to " + target-spec(part_ss) + " -o bundle.json",
+      "pred reduce partition.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate partition.json --config " + part_ss_sol.source_config.map(str).join(","),
+      "pred evaluate partition.json --config " + cli-config(part_ss_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical Partition instance has sizes $(#part_ss_sizes.map(str).join(", "))$ with total sum $S = #part_ss_total$, so a balanced witness must hit exactly $S / 2 = #part_ss_target$.
+    *Step 1 -- Source instance.* The canonical Partition instance has sizes $(#fmt-values(part_ss_sizes))$ with total sum $S = #part_ss_total$, so a balanced witness must hit exactly $S / 2 = #part_ss_target$.
 
-    *Step 2 -- Build the Subset Sum instance.* The reduction copies the sizes directly: $(#part_ss_sizes.map(str).join(", "))$, and sets the target $B = S / 2 = #part_ss_target$. The number of binary variables is unchanged ($n = #part_ss_n$).
+    *Step 2 -- Build the Subset Sum instance.* The reduction copies the sizes directly: $(#fmt-values(part_ss_sizes))$, and sets the target $B = S / 2 = #part_ss_target$. The number of binary variables is unchanged ($n = #part_ss_n$).
 
-    *Step 3 -- Verify the canonical witness.* The serialized witness uses the same binary vector on both sides, $bold(x) = (#part_ss_sol.source_config.map(str).join(", "))$. It selects elements at indices $\{#part_ss_selected.map(str).join(", ")\}$ with sizes $(#part_ss_selected_sizes.map(str).join(", "))$, so the chosen subset sums to $#part_ss_selected_sum = #part_ss_target = B$ #sym.checkmark.
+    *Step 3 -- Verify the canonical witness.* The serialized witness uses the same binary vector on both sides, $bold(x) = (#fmt-values(part_ss_sol.source_config))$. It selects elements at indices $\{#fmt-values(part_ss_selected)\}$ with sizes $(#fmt-values(part_ss_selected_sizes))$, so the chosen subset sums to $#part_ss_selected_sum = #part_ss_target = B$ #sym.checkmark.
 
     *Witness semantics.* The example DB stores one canonical balanced subset. Multiple subsets may sum to $B$, but one witness suffices to demonstrate the reduction.
   ],
@@ -12505,7 +12398,7 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 #let part_ifwm_n = part_ifwm_sizes.len()
 #let part_ifwm_total = part_ifwm_sizes.fold(0, (a, b) => a + b)
 #let part_ifwm_half = part_ifwm_total / 2
-#let part_ifwm_selected = part_ifwm_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let part_ifwm_selected = part_ifwm_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #let part_ifwm_selected_sizes = part_ifwm_selected.map(i => part_ifwm_sizes.at(i))
 #let part_ifwm_source_arcs = part_ifwm_sol.target_config.slice(0, part_ifwm_n)
 #let part_ifwm_relay_arcs = part_ifwm_sol.target_config.slice(part_ifwm_n, 2 * part_ifwm_n)
@@ -12516,16 +12409,16 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(part_ifwm.source) + " -o partition.json",
-      "pred reduce partition.json --to " + target-spec(part_ifwm) + " -o bundle.json",
+      "pred reduce partition.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate partition.json --config " + part_ifwm_sol.source_config.map(str).join(","),
+      "pred evaluate partition.json --config " + cli-config(part_ifwm_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical Partition multiset is $(#part_ifwm_sizes.map(str).join(", "))$, so the total is $S = #part_ifwm_total$ and any balanced witness must sum to $S / 2 = #part_ifwm_half$.
+    *Step 1 -- Source instance.* The canonical Partition multiset is $(#fmt-values(part_ifwm_sizes))$, so the total is $S = #part_ifwm_total$ and any balanced witness must sum to $S / 2 = #part_ifwm_half$.
 
-    *Step 2 -- Build the relay network.* The reduction creates vertices $s$, one item vertex $v_i$ per element, a relay vertex $w$, and sink $t$. It adds unit-capacity arcs $(s, v_i)$, item arcs $(v_i, w)$ with capacities $(#part_ifwm_sizes.map(str).join(", "))$, and one bottleneck arc $(w, t)$ with capacity $#part_ifwm_half$. The target witness therefore has $#part_ifwm_sol.target_config.len()$ arc-flow coordinates ordered as source arcs, relay arcs, then the bottleneck arc.
+    *Step 2 -- Build the relay network.* The reduction creates vertices $s$, one item vertex $v_i$ per element, a relay vertex $w$, and sink $t$. It adds unit-capacity arcs $(s, v_i)$, item arcs $(v_i, w)$ with capacities $(#fmt-values(part_ifwm_sizes))$, and one bottleneck arc $(w, t)$ with capacity $#part_ifwm_half$. The target witness therefore has $#part_ifwm_sol.target_config.len()$ arc-flow coordinates ordered as source arcs, relay arcs, then the bottleneck arc.
 
-    *Step 3 -- Verify the canonical witness.* The source witness $bold(x) = (#part_ifwm_sol.source_config.map(str).join(", "))$ selects item indices $\{#part_ifwm_selected.map(str).join(", ")\}$ with sizes $(#part_ifwm_selected_sizes.map(str).join(", "))$, summing to $#part_ifwm_half$. On the target side, the source arcs carry $(#part_ifwm_source_arcs.map(str).join(", "))$, the relay arcs carry $(#part_ifwm_relay_arcs.map(str).join(", "))$, and the bottleneck arc carries $#part_ifwm_bottleneck$. Thus the relay receives $#part_ifwm_selected_sizes.map(str).join(" + ") = #part_ifwm_half$ units and the sink inflow equals the requirement #sym.checkmark.
+    *Step 3 -- Verify the canonical witness.* The source witness $bold(x) = (#fmt-values(part_ifwm_sol.source_config))$ selects item indices $\{#fmt-values(part_ifwm_selected)\}$ with sizes $(#fmt-values(part_ifwm_selected_sizes))$, summing to $#part_ifwm_half$. On the target side, the source arcs carry $(#fmt-values(part_ifwm_source_arcs))$, the relay arcs carry $(#fmt-values(part_ifwm_relay_arcs))$, and the bottleneck arc carries $#part_ifwm_bottleneck$. Thus the relay receives $#part_ifwm_selected_sizes.map(str).join(" + ") = #part_ifwm_half$ units and the sink inflow equals the requirement #sym.checkmark.
 
     *Witness semantics.* The fixture stores one canonical balanced subset. Other balanced subsets may exist, but every feasible target witness still extracts by reading the first $n$ unit-capacity source arcs.
   ],
@@ -12550,7 +12443,7 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 #let ks_qubo_num_items = ks_qubo.source.instance.weights.len()
 #let ks_qubo_num_slack = ks_qubo.target.instance.num_vars - ks_qubo_num_items
 #let ks_qubo_penalty = 1 + ks_qubo.source.instance.values.fold(0, (a, b) => a + b)
-#let ks_qubo_selected = ks_qubo_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let ks_qubo_selected = ks_qubo_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #let ks_qubo_sel_weight = ks_qubo_selected.fold(0, (a, i) => a + ks_qubo.source.instance.weights.at(i))
 #let ks_qubo_sel_value = ks_qubo_selected.fold(0, (a, i) => a + ks_qubo.source.instance.values.at(i))
 #reduction-rule("Knapsack", "QUBO",
@@ -12559,11 +12452,11 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example Knapsack -o knapsack.json",
-      "pred reduce knapsack.json --to " + target-spec(ks_qubo) + " -o bundle.json",
+      "pred reduce knapsack.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate knapsack.json --config " + ks_qubo_sol.source_config.map(str).join(","),
+      "pred evaluate knapsack.json --config " + cli-config(ks_qubo_sol.source_config),
     )
-    *Step 1 -- Source instance.* The canonical knapsack instance has weights $(#ks_qubo.source.instance.weights.map(str).join(", "))$, values $(#ks_qubo.source.instance.values.map(str).join(", "))$, and capacity $C = #ks_qubo.source.instance.capacity$.
+    *Step 1 -- Source instance.* The canonical knapsack instance has weights $(#fmt-values(ks_qubo.source.instance.weights))$, values $(#fmt-values(ks_qubo.source.instance.values))$, and capacity $C = #ks_qubo.source.instance.capacity$.
 
     *Step 2 -- Introduce slack variables.* The inequality $sum_i w_i x_i lt.eq C$ becomes an equality by adding $B = #ks_qubo_num_slack$ binary slack bits that encode unused capacity:
     $ #ks_qubo.source.instance.weights.enumerate().map(((i, w)) => $#w x_#i$).join($+$) + #range(ks_qubo_num_slack).map(j => $#calc.pow(2, j) s_#j$).join($+$) = #ks_qubo.source.instance.capacity $
@@ -12573,9 +12466,9 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
     $ H = -(#ks_qubo.source.instance.values.enumerate().map(((i, v)) => $#v x_#i$).join($+$)) + #ks_qubo_penalty (#ks_qubo.source.instance.weights.enumerate().map(((i, w)) => $#w x_#i$).join($+$) + #range(ks_qubo_num_slack).map(j => $#calc.pow(2, j) s_#j$).join($+$) - #ks_qubo.source.instance.capacity)^2 $
     so any violation of the equality is more expensive than the entire knapsack value range.
 
-    *Step 4 -- Verify a solution.* The QUBO ground state $bold(z) = (#ks_qubo_sol.target_config.map(str).join(", "))$ extracts to the knapsack choice $bold(x) = (#ks_qubo_sol.source_config.map(str).join(", "))$. This selects items $\{#ks_qubo_selected.map(str).join(", ")\}$ with total weight $#ks_qubo_selected.map(i => str(ks_qubo.source.instance.weights.at(i))).join(" + ") = #ks_qubo_sel_weight$ and total value $#ks_qubo_selected.map(i => str(ks_qubo.source.instance.values.at(i))).join(" + ") = #ks_qubo_sel_value$, so the slack bits are all zero and the penalty term vanishes #sym.checkmark.
+    *Step 4 -- Verify a solution.* The QUBO ground state $bold(z) = (#fmt-values(ks_qubo_sol.target_config))$ extracts to the knapsack choice $bold(x) = (#fmt-values(ks_qubo_sol.source_config))$. This selects items $\{#fmt-values(ks_qubo_selected)\}$ with total weight $#ks_qubo_selected.map(i => str(ks_qubo.source.instance.weights.at(i))).join(" + ") = #ks_qubo_sel_weight$ and total value $#ks_qubo_selected.map(i => str(ks_qubo.source.instance.values.at(i))).join(" + ") = #ks_qubo_sel_value$, so the slack bits are all zero and the penalty term vanishes #sym.checkmark.
 
-    *Uniqueness:* The fixture stores one canonical optimal witness. The source optimum is unique because items $\{#ks_qubo_selected.map(str).join(", ")\}$ are the only feasible selection achieving value #ks_qubo_sel_value.
+    *Uniqueness:* The fixture stores one canonical optimal witness. The source optimum is unique because items $\{#fmt-values(ks_qubo_selected)\}$ are the only feasible selection achieving value #ks_qubo_sel_value.
   ],
 )[
   For a standard 0-1 Knapsack instance with nonnegative weights, nonnegative values, and nonnegative capacity, the inequality $sum_i w_i x_i lt.eq C$ is converted to equality using binary slack variables that encode the unused capacity. When $C > 0$, one can take $B = floor(log_2 C) + 1$ slack bits; when $C = 0$, a single slack bit also suffices. The penalty method (@sec:penalty-method) combines the negated value objective with a quadratic constraint penalty, producing a QUBO with $n + B$ binary variables.
@@ -12600,9 +12493,9 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example MinimumDiscretePlanarInverseKinematics -o ik.json",
-      "pred reduce ik.json --to " + target-spec(mdpik_qubo) + " -o bundle.json",
+      "pred reduce ik.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ik.json --config " + mdpik_qubo_sol.source_config.map(str).join(","),
+      "pred evaluate ik.json --config " + cli-config(mdpik_qubo_sol.source_config),
     )
     *Step 1 -- Source instance.* The canonical instance has link lengths $(2, 1)$, target $g = (2, 1)$, sampled orientations $Phi_1 = Phi_2 = {0, pi / 2}$, and admissible pair set $A_2 = {(0,0), (0,1), (1,1)}$.
 
@@ -12614,7 +12507,7 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
     $ (2 y_(1,0) + y_(2,0) - 2)^2 + (2 y_(1,1) + y_(2,1) - 1)^2. $
     The implementation adds the same safe penalty to every one-hot violation and every forbidden pair, here penalizing the single forbidden adjacency $(1, 0)$ between the two blocks.
 
-    *Step 4 -- Verify a solution.* The QUBO ground state $bold(y) = (#mdpik_qubo_sol.target_config.map(str).join(", "))$ decodes to source configuration $(#mdpik_qubo_sol.source_config.map(str).join(", "))$, i.e. link 1 uses angle $0$ and link 2 uses angle $pi / 2$. The end-effector reaches $(2, 1)$ exactly, so the squared distance is $0$ #sym.checkmark.
+    *Step 4 -- Verify a solution.* The QUBO ground state $bold(y) = (#fmt-values(mdpik_qubo_sol.target_config))$ decodes to source configuration $(#fmt-values(mdpik_qubo_sol.source_config))$, i.e. link 1 uses angle $0$ and link 2 uses angle $pi / 2$. The end-effector reaches $(2, 1)$ exactly, so the squared distance is $0$ #sym.checkmark.
   ],
 )[
   Discrete planar inverse kinematics is already close to QUBO form: once each sampled orientation is lifted to a binary selector, both end-effector coordinates become linear functions of those selectors, and the squared Euclidean error expands to a quadratic polynomial. Adding quadratic one-hot penalties and quadratic penalties for forbidden consecutive orientation pairs yields a QUBO with $sum_(j=1)^n m_j$ variables @salloum2025ikqubo.
@@ -12645,19 +12538,19 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 #let mwc_qubo_k = mwc_qubo_terminals.len()
 #let mwc_qubo_nq = mwc_qubo_n * mwc_qubo_k
 #let mwc_qubo_alpha = mwc_qubo_weights.fold(0, (a, w) => a + w) + 1
-#let mwc_qubo_cut_indices = mwc_qubo_sol.source_config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
+#let mwc_qubo_cut_indices = mwc_qubo_sol.source_config.enumerate().filter(((i, v)) => v).map(((i, _)) => i)
 #let mwc_qubo_cut_cost = mwc_qubo_cut_indices.fold(0, (a, i) => a + mwc_qubo_weights.at(i))
 #reduction-rule("MinimumMultiwayCut", "QUBO",
   example: true,
-  example-caption: [$n = #mwc_qubo_n$ vertices, $k = #mwc_qubo_k$ terminals $T = {#mwc_qubo_terminals.map(str).join(", ")}$, $|E| = #mwc_qubo_edges.len()$ edges],
+  example-caption: [$n = #mwc_qubo_n$ vertices, $k = #mwc_qubo_k$ terminals $T = {#fmt-values(mwc_qubo_terminals)}$, $|E| = #mwc_qubo_edges.len()$ edges],
   extra: [
     #pred-commands(
       "pred create --example MinimumMultiwayCut -o minimummultiwaycut.json",
-      "pred reduce minimummultiwaycut.json --to " + target-spec(mwc_qubo) + " -o bundle.json",
+      "pred reduce minimummultiwaycut.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate minimummultiwaycut.json --config " + mwc_qubo_sol.source_config.map(str).join(","),
+      "pred evaluate minimummultiwaycut.json --config " + cli-config(mwc_qubo_sol.source_config),
     )
-    *Step 1 -- Source instance.* The canonical graph has $n = #mwc_qubo_n$ vertices, $m = #mwc_qubo_edges.len()$ edges with weights $(#mwc_qubo_weights.map(str).join(", "))$, and $k = #mwc_qubo_k$ terminals $T = {#mwc_qubo_terminals.map(str).join(", ")}$.
+    *Step 1 -- Source instance.* The canonical graph has $n = #mwc_qubo_n$ vertices, $m = #mwc_qubo_edges.len()$ edges with weights $(#fmt-values(mwc_qubo_weights))$, and $k = #mwc_qubo_k$ terminals $T = {#fmt-values(mwc_qubo_terminals)}$.
 
     *Step 2 -- Introduce binary variables.* Assign $k = #mwc_qubo_k$ indicator variables per vertex: $x_(u,t) = 1$ means vertex $u$ belongs to terminal $t$'s component. This gives $n k = #mwc_qubo_n times #mwc_qubo_k = #mwc_qubo_nq$ QUBO variables:
     $ underbrace(x_(0,0) x_(0,1) x_(0,2), "vertex 0") #h(4pt) underbrace(x_(1,0) x_(1,1) x_(1,2), "vertex 1") #h(4pt) dots.c #h(4pt) underbrace(x_(4,0) x_(4,1) x_(4,2), "vertex 4") $
@@ -12668,7 +12561,7 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 
     *Step 5 -- Build $H_B$ (cut cost).* For each edge $(u,v)$ with weight $w$ and each pair $s != t$, add $w$ to $Q_(u k+s, v k+t)$. For example, edge $(0,1)$ with weight $2$ contributes $2$ to positions $(x_(0,0), x_(1,1))$, $(x_(0,0), x_(1,2))$, $(x_(0,1), x_(1,0))$, $(x_(0,1), x_(1,2))$, $(x_(0,2), x_(1,0))$, and $(x_(0,2), x_(1,1))$.\
 
-    *Step 6 -- Verify a solution.* The QUBO ground state $bold(x) = (#mwc_qubo_sol.target_config.map(str).join(", "))$ decodes to the partition: vertex 0 in component 0, vertices 1--3 in component 1, vertex 4 in component 2. Cut edges: $\{#mwc_qubo_cut_indices.map(i => "(" + str(mwc_qubo_edges.at(i).at(0)) + "," + str(mwc_qubo_edges.at(i).at(1)) + ")").join(", ")\}$ with total weight #mwc_qubo_cut_indices.map(i => str(mwc_qubo_weights.at(i))).join(" + ") $= #mwc_qubo_cut_cost$ #sym.checkmark.
+    *Step 6 -- Verify a solution.* The QUBO ground state $bold(x) = (#fmt-values(mwc_qubo_sol.target_config))$ decodes to the partition: vertex 0 in component 0, vertices 1--3 in component 1, vertex 4 in component 2. Cut edges: $\{#mwc_qubo_cut_indices.map(i => "(" + str(mwc_qubo_edges.at(i).at(0)) + "," + str(mwc_qubo_edges.at(i).at(1)) + ")").join(", ")\}$ with total weight #mwc_qubo_cut_indices.map(i => str(mwc_qubo_weights.at(i))).join(" + ") $= #mwc_qubo_cut_cost$ #sym.checkmark.
   ],
 )[
   The multiway cut problem requires a partition of vertices into $k$ components — one per terminal — minimizing the total weight of edges crossing components. The penalty method (@sec:penalty-method) encodes two constraints as QUBO penalties: (1) each vertex belongs to exactly one component (one-hot), and (2) each terminal is pinned to its own component. The cut-cost Hamiltonian counts edge weight across distinct components. Reference: @Heidari2022.
@@ -12704,21 +12597,28 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   _Solution extraction._ The $n$-variable QUBO assignment directly encodes the vertex-side assignment: $x_v = 0$ means side $A$, $x_v = 1$ means side $B$.
 ]
 
-#let qubo_ilp = load-example("QUBO", "ILP")
+#let qubo_ilp = load-example(
+  "QUBO",
+  "ILP",
+  source-variant: (weight: "f64"),
+  target-variant: (coefficient: "f64", variable: "bool"),
+)
 #let qubo_ilp_sol = qubo_ilp.solutions.at(0)
 #reduction-rule("QUBO", "ILP",
   example: true,
+  example-source-variant: (weight: "f64"),
+  example-target-variant: (coefficient: "f64", variable: "bool"),
   example-caption: [4-variable QUBO with 3 quadratic terms],
   extra: [
     #pred-commands(
-      "pred create --example QUBO -o qubo.json",
-      "pred reduce qubo.json --to " + target-spec(qubo_ilp) + " -o bundle.json",
+      "pred create --example QUBO/f64 -o qubo.json",
+      "pred reduce qubo.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate qubo.json --config " + qubo_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate qubo.json --config " + cli-config(qubo_ilp_sol.source_config),
     )
     Source: $n = #qubo_ilp.source.instance.num_vars$ binary variables, 3 off-diagonal terms \
-    Target: #qubo_ilp.target.instance.num_vars ILP variables ($#qubo_ilp.source.instance.num_vars$ original $+ #(qubo_ilp.target.instance.num_vars - qubo_ilp.source.instance.num_vars)$ auxiliary), #qubo_ilp.target.instance.constraints.len() McCormick constraints \
-    Canonical optimal witness: $bold(x) = (#qubo_ilp_sol.source_config.map(str).join(", "))$ #sym.checkmark
+    Target: #qubo_ilp.target.instance.variables.len() ILP variables ($#qubo_ilp.source.instance.num_vars$ original $+ #(qubo_ilp.target.instance.variables.len() - qubo_ilp.source.instance.num_vars)$ auxiliary), #qubo_ilp.target.instance.constraints.len() McCormick constraints \
+    Canonical optimal witness: $bold(x) = (#fmt-values(qubo_ilp_sol.source_config))$ #sym.checkmark
   ],
 )[
   QUBO minimizes a quadratic form $bold(x)^top Q bold(x)$ over binary variables. Every quadratic term $Q_(i j) x_i x_j$ can be _linearized_ by introducing an auxiliary variable $y_(i j)$ constrained to equal the product $x_i x_j$ via three McCormick inequalities. Diagonal terms $Q_(i i) x_i^2 = Q_(i i) x_i$ are already linear for binary $x_i$. The result is a binary ILP with a linear objective and $3 m$ constraints (where $m$ is the number of non-zero off-diagonal entries), whose minimizer corresponds exactly to the QUBO minimizer.
@@ -12754,23 +12654,24 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example CircuitSAT -o circuitsat.json",
-      "pred reduce circuitsat.json --to " + target-spec(cs_ilp) + " -o bundle.json",
+      "pred reduce circuitsat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate circuitsat.json --config " + cs_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate circuitsat.json --config " + cli-config(cs_ilp_sol.source_config),
     )
     Circuit: #circuit-num-gates(cs_ilp.source.instance) gates (2 XOR, 2 AND, 1 OR), #circuit-num-variables(cs_ilp.source.instance) variables \
-    Target: #cs_ilp.target.instance.num_vars ILP variables (circuit vars $+$ auxiliary), trivial objective \
+    Target: #cs_ilp.target.instance.variables.len() ILP variables (circuit vars $+$ auxiliary), trivial objective \
     Canonical feasible witness shown ($2^3$ valid input combinations exist for the full adder) #sym.checkmark
   ],
 )[
-  Each boolean gate (AND, OR, NOT, XOR) has a truth table that can be captured exactly by a small set of linear inequalities over binary variables. By Tseitin-style flattening, each internal expression node gets an auxiliary ILP variable constrained to match its gate's output, so the conjunction of all gate constraints is feasible if and only if the circuit is satisfiable. The ILP has a trivial objective (minimize 0), making it a pure feasibility problem.
+  Each boolean gate (AND, OR, NOT, XOR) has a truth table that can be captured exactly by a small set of linear inequalities over binary variables. By Tseitin-style flattening, expression outputs and binary XOR fold steps get auxiliary ILP variables constrained to match their values, so the conjunction of all gate constraints is feasible if and only if the circuit is satisfiable. The ILP has a trivial objective (minimize 0), making it a pure feasibility problem.
 ][
-  _Construction._ Recursively assign an ILP variable to each expression node. Named circuit variables keep their identity; internal nodes get auxiliary variables.
+  _Construction._ Pre-register named circuit variables in the source order. Recursively lower expression trees, allocating outputs for constants, NOT, AND and OR, and one output per binary XOR fold step. Multi-input XOR is a left fold; a single input is unchanged and an empty XOR uses the existing constant-false encoding. All variable allocations use checked index arithmetic.
 
   _Gate encodings_ (output $c$, inputs $a_1, ..., a_k$, all binary):
   - NOT: $c + a = 1$
   - AND: $c <= a_i$ ($forall i$), $c >= sum a_i - (k - 1)$
   - OR: $c >= a_i$ ($forall i$), $c <= sum a_i$
+  - Constants: $c=0$ or $c=1$. Empty AND and OR are already covered by their formulas: $c>=1$ and $c<=0$, respectively.
   - XOR (binary, chained pairwise): $c <= a + b$, $c >= a - b$, $c >= b - a$, $c <= 2 - a - b$
 
   _Objective._ Minimize $0$ (feasibility problem): any feasible solution satisfies the circuit.
@@ -12790,9 +12691,13 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
     & "all gate and input variables are binary".
   $
 
-  _Correctness._ ($arrow.r.double$) Each gate encoding is the convex hull of the gate's truth table rows (viewed as binary vectors), so a satisfying circuit assignment satisfies all constraints. ($arrow.l.double$) Any binary feasible solution respects every gate's input-output relation, and since gates are composed in topological order, the full circuit evaluates to true.
+  For each named output $y$ of an assignment with expression result $c$, add $y=c$ unless the two already share a variable. No output is implicitly forced true. The standard AND, OR and NOT linearizations are documented in the MOSEK Modeling Cookbook, Section 9.1.9; the four XOR inequalities can be checked on the four input pairs.
+
+  _Correctness._ ($arrow.r.double$) Fix a satisfying assignment of all source names, evaluate each expression tree, and give every auxiliary its expression or partial XOR value. Every gate row holds, and the named-output equalities hold by source feasibility. ($arrow.l.double$) With binary inputs, the gate rows determine their outputs exactly: AND is one precisely when every input is one, OR is zero precisely when every input is zero, and the four XOR rows force output zero on equal inputs and one on unequal inputs. Structural induction on each expression tree, followed by the named-output equalities, proves every source assignment constraint. Named assignments may form cycles; no topological ordering of them is assumed.
+
+  _Solution extraction._ Validate the target assignment once and reject it if the ILP evaluation is infeasible. Otherwise read all named source variables in their original order. Since the objective is zero, every feasible ILP assignment is an admissible witness.
 
-  _Solution extraction._ Return values of the named circuit variables.
+  _Overhead._ For $v$ named variables, $t$ expression nodes and $o$ named outputs, the target has at most $v+2t$ variables and $5t+o$ constraints. Non-XOR outputs and empty XOR outputs contribute at most $t$ auxiliaries. Binary XOR steps contribute at most the number of expression-tree edges, hence at most $t$. Base gate rows contribute at most $t$, while input inequalities and binary XOR rows contribute at most four times the number of tree edges. Output equalities add at most $o$ rows. This accounts for arbitrarily many constant inputs: three constants under one XOR use five auxiliaries, exceeding the former one-auxiliary-per-node bound of four.
 ]
 
 == Non-Trivial Reductions
@@ -12805,16 +12710,16 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example SAT -o sat.json",
-      "pred reduce sat.json --to " + target-spec(sat_mis) + " -o bundle.json",
+      "pred reduce sat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate sat.json --config " + sat_mis_sol.source_config.map(str).join(","),
+      "pred evaluate sat.json --config " + cli-config(sat_mis_sol.source_config),
     )
-    SAT assignment: $(x_1, ..., x_5) = (#sat_mis_sol.source_config.map(str).join(", "))$ \
+    SAT assignment: $(x_1, ..., x_5) = (#fmt-values(sat_mis_sol.source_config))$ \
     IS graph: #graph-num-vertices(sat_mis.target.instance) vertices ($= 3 times #sat-num-clauses(sat_mis.source.instance)$ literals), #graph-num-edges(sat_mis.target.instance) edges \
     IS of size #sat-num-clauses(sat_mis.source.instance) $= m$: one vertex per clause $arrow.r$ satisfying assignment #sym.checkmark
   ],
 )[
-  @karp1972 A satisfying assignment must make at least one literal true in every clause, and different clauses cannot assign contradictory values to the same variable. These two requirements map naturally to an independent set problem: _intra-clause cliques_ force exactly one literal per clause to be selected, while _conflict edges_ between complementary literals across clauses enforce consistency. The target IS size equals the number of clauses $m$, so an IS of size $m$ exists iff the formula is satisfiable.
+  @karp1972 A satisfying assignment must make at least one literal true in every clause, and different clauses cannot assign contradictory values to the same variable. These two requirements map naturally to an independent set problem: _intra-clause cliques_ allow at most one literal per clause to be selected, while _conflict edges_ between complementary literals across clauses enforce consistency. The target IS size equals the number of clauses $m$, so an IS of size $m$ exists iff the formula is satisfiable.
 ][
   _Construction._ For $phi = and.big_(j=1)^m C_j$ with $C_j = (ell_(j,1) or ... or ell_(j,k_j))$:
 
@@ -12824,7 +12729,9 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 
   _Correctness._ ($arrow.r.double$) A satisfying assignment selects one true literal per clause; these vertices form an IS of size $m$ (no clause edges by selection, no conflict edges by consistency). ($arrow.l.double$) An IS of size $m$ must contain exactly one vertex per clause (by clause cliques); the corresponding literals are consistent (by conflict edges) and satisfy $phi$.
 
-  _Solution extraction._ For $v_(j,i) in S$ with literal $x_k$: set $x_k = 1$; for $overline(x_k)$: set $x_k = 0$.
+  _Solution extraction._ Validate the target configuration and require a finite independent-set value exactly $m$ before decoding. For $v_(j,i) in S$ with literal $x_k$, set $x_k = 1$; for $overline(x_k)$, set $x_k = 0$. Unselected variables may be set to false. The aggregate map returns true precisely at value $m$. An optimal value below $m$ proves that the source formula is unsatisfiable; it does not provide a satisfying assignment. An empty formula has threshold zero; any empty clause makes the threshold unattainable.
+
+  _Representation and size._ The implementation checks that $m$ fits the exact target score type. Every feasible independent set has size at most $m$, so all partial sums of its unit weights also fit. Repeated literals remain distinct vertices. Complementary occurrences within a clause may add a duplicate edge; this does not affect feasibility. With $L = sum_j k_j$, the stored edge count is at most $2 binom(L, 2) <= L^2$, and the vertex count is exactly $L$.
 ]
 
 #let sat_kc = load-example("Satisfiability", "KColoring")
@@ -12835,11 +12742,11 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example SAT -o sat.json",
-      "pred reduce sat.json --to " + target-spec(sat_kc) + " -o bundle.json",
+      "pred reduce sat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate sat.json --config " + sat_kc_sol.source_config.map(str).join(","),
+      "pred evaluate sat.json --config " + cli-config(sat_kc_sol.source_config),
     )
-    SAT assignment: $(x_1, ..., x_5) = (#sat_kc_sol.source_config.map(str).join(", "))$ \
+    SAT assignment: $(x_1, ..., x_5) = (#fmt-values(sat_kc_sol.source_config))$ \
     Construction: 3 base + $2 times #sat_kc.source.instance.num_vars$ variable gadgets + OR-gadgets $arrow.r$ #graph-num-vertices(sat_kc.target.instance) vertices, #graph-num-edges(sat_kc.target.instance) edges \
     Canonical 3-coloring witness shown (the construction also has the expected color-symmetry multiplicity for satisfying assignments) #sym.checkmark
   ],
@@ -12863,22 +12770,24 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example SAT -o sat.json",
-      "pred reduce sat.json --to " + target-spec(sat_ds) + " -o bundle.json",
+      "pred reduce sat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate sat.json --config " + sat_ds_sol.source_config.map(str).join(","),
+      "pred evaluate sat.json --config " + cli-config(sat_ds_sol.source_config),
     )
-    SAT assignment: $(x_1, ..., x_5) = (#sat_ds_sol.source_config.map(str).join(", "))$ \
+    SAT assignment: $(x_1, ..., x_5) = (#fmt-values(sat_ds_sol.source_config))$ \
     Vertex structure: $#graph-num-vertices(sat_ds.target.instance) = 3 times #sat_ds.source.instance.num_vars + #sat-num-clauses(sat_ds.source.instance)$ (variable triangles + clause vertices) \
     Dominating set of size $n = #sat_ds.source.instance.num_vars$: one vertex per variable triangle #sym.checkmark
   ],
 )[
-  @garey1979 Each variable is represented by a triangle whose three vertices correspond to the positive literal, negative literal, and a dummy. Any dominating set must include at least one vertex from each triangle to dominate the dummy. The clause vertices are connected only to the literal vertices that appear in the clause, so a dominating set of minimum size $n$ (one vertex per triangle) dominates all clause vertices iff the chosen literals satisfy every clause.
+  @garey1979 Each variable that occurs in the formula is represented by a triangle with positive, negative, and dummy vertices. Let $q$ be the number of occurring variables. Every dominating set needs at least one vertex from each triangle to dominate its dummy. A dominating set of size $q$ exists exactly when the formula is satisfiable.
 ][
-  _Construction._ (1) _Variable triangle_ for $x_i$: vertices $"pos"_i = 3i$, $"neg"_i = 3i+1$, $"dum"_i = 3i+2$ forming a triangle. The dummy vertex $"dum"_i$ is adjacent only to $"pos"_i$ and $"neg"_i$, so it can only be dominated by a vertex from its own triangle. (2) _Clause vertex_ $c_j = 3n+j$ connected to $"pos"_i$ if $x_i in C_j$, to $"neg"_i$ if $overline(x_i) in C_j$.
+  _Construction._ List the occurring source variable indices in increasing order as $u_0, dots, u_(q-1)$. Variables absent from every clause require no gadget. For each dense index $i$, create $"pos"_i = 3i$, $"neg"_i = 3i+1$, and $"dum"_i = 3i+2$, joining them as a triangle. For clause $C_j$, create $c_j = 3q+j$ and join it to the positive or negative vertex of each literal occurrence in the clause. All vertex weights are one; repeated occurrences retain duplicate edge entries.
+
+  _Correctness._ ($arrow.r.double$) Given a satisfying assignment, select one literal vertex per occurring variable according to its truth value. Each triangle is dominated, and every clause vertex has a selected true-literal neighbor. The set has size $q$. ($arrow.l.double$) To dominate the private dummy of each triangle, any dominating set must select at least one vertex from that triangle. A set of size $q$ therefore selects exactly one per triangle and no clause vertices. Every clause must consequently have a selected literal neighbor. Set a variable true precisely when its positive vertex is selected, and false when its negative or dummy vertex is selected. Every selected literal remains true, so all clauses are satisfied. Absent variables may also be set false because no clause refers to them.
 
-  _Correctness._ ($arrow.r.double$) Given a satisfying assignment, select $"pos"_i$ if $x_i = 1$, else $"neg"_i$. This dominates all triangle vertices (each triangle has one selected vertex adjacent to both others). Each clause $C_j$ has at least one true literal, so $c_j$ is adjacent to at least one selected vertex. Total size: $n$. ($arrow.l.double$) Any dominating set needs $>= 1$ vertex per triangle (to dominate $"dum"_i$). A set of size $n$ has exactly one per triangle. If $"dum"_i$ is selected, it does not dominate any clause vertex; but it does dominate $"pos"_i$ and $"neg"_i$, which still need to cover clauses. Since $"dum"_i$ has no clause neighbors, we can swap it for $"pos"_i$ or $"neg"_i$ without losing domination of the triangle. After swapping, each clause vertex $c_j$ must be dominated by some $"pos"_i$ or $"neg"_i$, defining a consistent satisfying assignment.
+  _Solution extraction._ Evaluate the target configuration once and require a finite value equal to $q$, using the same certificate as the aggregate map. Decode through the stored map from source indices to dense gadget indices. Invalid dominating configurations and values above $q$ provide no satisfying witness and are rejected. The empty formula has $q=m=0$ and an empty target; an empty clause creates an isolated clause vertex, forcing the optimum above $q$.
 
-  _Solution extraction._ Set $x_i = 1$ if $"pos"_i$ selected; $x_i = 0$ if $"neg"_i$ selected.
+  _Size and arithmetic._ For $n$ declared variables, $m$ clauses, and $L$ literal occurrences, the actual target has $3q+m <= 3n+m$ vertices and $3q+L <= 3n+L$ stored edges. Thus the registered formulas are upper bounds. Checked arithmetic computes the vertex count and verifies that every possible sum of unit weights fits #raw("i64"), including the all-selected configuration. Construction depends on occurring variables, so a large declared index alone does not allocate unused triangles. Producing the source assignment still requires its declared length.
 ]
 
 #let sat_ifha = load-example("Satisfiability", "IntegralFlowHomologousArcs")
@@ -12889,11 +12798,11 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(sat_ifha.source) + " -o sat.json",
-      "pred reduce sat.json --to " + target-spec(sat_ifha) + " -o bundle.json",
+      "pred reduce sat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate sat.json --config " + sat_ifha_sol.source_config.map(str).join(","),
+      "pred evaluate sat.json --config " + cli-config(sat_ifha_sol.source_config),
     )
-    SAT assignment: $(x_1, x_2, x_3) = (#sat_ifha_sol.source_config.map(str).join(", "))$ \
+    SAT assignment: $(x_1, x_2, x_3) = (#fmt-values(sat_ifha_sol.source_config))$ \
     Target network: $#sat_ifha.target.instance.graph.num_vertices$ vertices, $#sat_ifha.target.instance.graph.arcs.len()$ arcs, #sat_ifha.target.instance.homologous_pairs.len() homologous pairs, and $R = #sat_ifha.target.instance.requirement$ \
     The stored flow witness gives bottleneck loads $1, 1, 1, 0$ across the four clause stages, so every stage respects its unit capacity #sym.checkmark
 
@@ -12945,13 +12854,13 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example SAT -o sat.json",
-      "pred reduce sat.json --to " + target-spec(sat_ksat) + " -o bundle.json",
+      "pred reduce sat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate sat.json --config " + sat_ksat_sol.source_config.map(str).join(","),
+      "pred evaluate sat.json --config " + cli-config(sat_ksat_sol.source_config),
     )
     Source: #sat_ksat.source.instance.num_vars variables, #sat-num-clauses(sat_ksat.source.instance) clauses (sizes 1, 2, 3, 3, 4, 5) \
     Target 3-SAT: $#sat_ksat.target.instance.num_vars = #sat_ksat.source.instance.num_vars + 7$ variables, #sat-num-clauses(sat_ksat.target.instance) clauses (small padded, large split) \
-    First solution: $(x_1, ..., x_5) = (#sat_ksat_sol.source_config.map(str).join(", "))$, auxiliary vars are don't-cares #sym.checkmark
+    First solution: $(x_1, ..., x_5) = (#fmt-values(sat_ksat_sol.source_config))$, auxiliary vars are don't-cares #sym.checkmark
   ],
 )[
   @cook1971 @garey1979 Clauses shorter than $k$ can be padded with a complementary pair $y, overline(y)$ that is always satisfiable; clauses longer than $k$ can be split into a chain of width-$k$ clauses linked by auxiliary variables that propagate truth values. Both transformations preserve satisfiability while enforcing uniform clause width.
@@ -12976,16 +12885,16 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(sat_max2sat.source) + " -o sat.json",
-      "pred reduce sat.json --to " + target-spec(sat_max2sat) + " -o bundle.json",
+      "pred reduce sat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate sat.json --config " + sat_max2sat_sol.source_config.map(str).join(","),
+      "pred evaluate sat.json --config " + cli-config(sat_max2sat_sol.source_config),
     )
     *Step 1 -- Source instance.* The canonical SAT formula has $n = #sat_max2sat.source.instance.num_vars$ variables and $m = #sat-num-clauses(sat_max2sat.source.instance)$ clauses:
     $
       C_1 = (x_1 or overline(x_2) or x_3), quad
       C_2 = (overline(x_1) or x_2).
     $
-    The stored satisfying assignment is $(x_1, x_2, x_3) = (#sat_max2sat_sol.source_config.map(str).join(", "))$.
+    The stored satisfying assignment is $(x_1, x_2, x_3) = (#fmt-values(sat_max2sat_sol.source_config))$.
 
     *Step 2 -- Normalize to 3-CNF.* Clause $C_1$ already has width $3$. Clause $C_2$ introduces one auxiliary variable $y_1$ and becomes
     $
@@ -12994,7 +12903,7 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
     $
     The normalized formula therefore has $4$ variables and $3$ clauses.
 
-    *Step 3 -- Build the MAX-2-SAT gadgets.* Introduce one gadget variable per normalized clause, so the target has $#sat_max2sat.target.instance.num_vars$ variables and #sat_max2sat.target.instance.clauses.len() clauses. The stored witness is $(x_1, x_2, x_3, y_1, w_1, w_2, w_3) = (#sat_max2sat_sol.target_config.map(str).join(", "))$. With $(y_1, w_1, w_2, w_3) = (0, 1, 0, 1)$, each of the three gadgets satisfies exactly $7$ clauses, so the target objective reaches $21 = 7 times 3$ #sym.checkmark.
+    *Step 3 -- Build the MAX-2-SAT gadgets.* Introduce one gadget variable per normalized clause, so the target has $#sat_max2sat.target.instance.num_vars$ variables and #sat_max2sat.target.instance.clauses.len() clauses. The stored witness is $(x_1, x_2, x_3, y_1, w_1, w_2, w_3) = (#fmt-values(sat_max2sat_sol.target_config))$. With $(y_1, w_1, w_2, w_3) = (0, 1, 0, 1)$, each of the three gadgets satisfies exactly $7$ clauses, so the target objective reaches $21 = 7 times 3$ #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical optimum. Auxiliary variables such as $y_1$ can vary across optimal witnesses, but truncating any optimal target assignment to the first $3$ coordinates still yields a satisfying assignment of the original SAT formula.
   ],
@@ -13030,7 +12939,9 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   $
   ($arrow.r.double$) If $phi$ is satisfiable, then the normalized formula $psi$ is satisfiable by Step 1. Every normalized clause is true, so each gadget attains value $7$ and the target optimum is $7 m'$. ($arrow.l.double$) If the target optimum is $7 m'$, then every gadget must contribute $7$, so every normalized clause $D_t$ is true. Hence $psi$ is satisfiable, and the normalization in Step 1 implies that the restriction to the original variables satisfies $phi$. If $phi$ is unsatisfiable, then $psi$ is unsatisfiable, so every assignment leaves at least one normalized clause false and the target optimum is strictly less than $7 m'$.
 
-  _Solution extraction._ Discard all auxiliary normalization variables and all gadget variables $w_t$; return only the first $n$ Boolean variables $(x_1, dots, x_n)$.
+  _Solution extraction._ Evaluate the target assignment exactly once through the formal validator. Accept only the exact score $7m'$, then return its prefix on the original variables. Since every gadget contributes at most seven, this score forces every normalized clause to hold, and the normalization proof guarantees that the prefix satisfies the original formula. An optimal score below $7m'$ represents source infeasibility and is rejected as a witness. The custom aggregate maps exactly $7m'$ to true and every other value, including an infeasible value, to false. The empty formula has $m'=0$ and accepts its zero-score assignments; an empty source clause creates a contradictory normalized pair and prevents attaining the threshold.
+
+  _Arithmetic._ Checked construction bounds the complete target clause count $10m'$ in `i64`, so every satisfied-clause count is representable. The exact score is computed as $(10m' / 10) dot 7$, dividing first to stay within that bound. The existing variable allocator validates literal indices, and the target is constructed through its fallible public API.
 ]
 
 #let sat_cs = load-example("Satisfiability", "CircuitSAT")
@@ -13041,9 +12952,9 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example SAT -o sat.json",
-      "pred reduce sat.json --to " + target-spec(sat_cs) + " -o bundle.json",
+      "pred reduce sat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate sat.json --config " + sat_cs_sol.source_config.map(str).join(","),
+      "pred evaluate sat.json --config " + cli-config(sat_cs_sol.source_config),
     )
   ],
 )[
@@ -13074,9 +12985,9 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(cs_sat.source) + " -o circuitsat.json",
-      "pred reduce circuitsat.json --to " + target-spec(cs_sat) + " -o bundle.json",
+      "pred reduce circuitsat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate circuitsat.json --config " + cs_sat_sol.source_config.map(str).join(","),
+      "pred evaluate circuitsat.json --config " + cli-config(cs_sat_sol.source_config),
     )
     Circuit: #circuit-num-gates(cs_sat.source.instance) assignment, #circuit-num-variables(cs_sat.source.instance) named variables \
     Target: #cs_sat.target.instance.num_vars SAT variables, #cs_sat.target.instance.clauses.len() clauses \
@@ -13085,7 +12996,7 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 
     *Step 2 -- Emit clauses.* Add three clauses for $a = x_1 and x_2$, two for $b = not x_3$, three for $c = b and x_4$, three for $d = a or c$, and two clauses for the output identity $r equiv d$. The CNF therefore has #cs_sat.target.instance.clauses.len() clauses.
 
-    *Step 3 -- Verify a witness.* The fixture stores source config #cs_sat_sol.source_config.map(str).join(", "), meaning $(r, x_1, x_2, x_3, x_4) = (1, 1, 1, 0, 1)$. Extending with $(a, b, c, d) = (1, 1, 1, 1)$ gives the SAT witness #cs_sat_sol.target_config.map(str).join(", "), which satisfies every gate-definition clause and the two clauses enforcing $r equiv d$.
+    *Step 3 -- Verify a witness.* The fixture stores source config #fmt-values(cs_sat_sol.source_config), meaning $(r, x_1, x_2, x_3, x_4) = (1, 1, 1, 0, 1)$. Extending with $(a, b, c, d) = (1, 1, 1, 1)$ gives the SAT witness #fmt-values(cs_sat_sol.target_config), which satisfies every gate-definition clause and the two clauses enforcing $r equiv d$.
 
     *Multiplicity:* The fixture stores one canonical consistent assignment. Other satisfying assignments may exist whenever the circuit equations leave some named variables unconstrained.
   ],
@@ -13114,26 +13025,31 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example CircuitSAT -o circuitsat.json",
-      "pred reduce circuitsat.json --to " + target-spec(cs_sg) + " -o bundle.json",
+      "pred reduce circuitsat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate circuitsat.json --config " + cs_sg_sol.source_config.map(str).join(","),
+      "pred evaluate circuitsat.json --config " + cli-config(cs_sg_sol.source_config),
     )
     Circuit: #circuit-num-gates(cs_sg.source.instance) gates (2 XOR, 2 AND, 1 OR), #circuit-num-variables(cs_sg.source.instance) variables \
     Target: #spin-num-spins(cs_sg.target.instance) spins (each gate allocates I/O + auxiliary spins) \
     Canonical ground-state witness shown ($2^3$ valid input combinations exist for the full adder) #sym.checkmark
   ],
 )[
-  @whitfield2012 @lucas2014 Each logic gate can be represented as an Ising gadget --- a small set of spins with couplings $J_(i j)$ and fields $h_i$ chosen so that the gadget's ground states correspond exactly to the gate's truth table rows. Composing gadgets for all gates in the circuit yields a spin glass whose ground states encode precisely the satisfying assignments of the circuit. The energy gap between valid and invalid I/O patterns ensures that any global ground state respects every gate's logic.
+  Each gate contributes a Hamiltonian bounded below by a known constant. The circuit is satisfiable exactly when the target optimum attains the sum of those constants. A ground state above this threshold is not a satisfying witness. This uses the nonnegative-penalty principle described by @bian2010ising.
 ][
-  _Construction._
+  _Construction._ Boolean bits $x$ use spins $s=2x-1$. The repository energy convention is $H=sum_((i,j)) J_(i j)s_i s_j + sum_i h_i s_i$, including any diagonal terms created by identified inputs. Use the gadgets in @tab:gadgets; a new expression output is tied to each named assignment output by a coupling $-4 s_u s_v$ whenever the two spins differ. Constants use fields $+1$ for false and $-1$ for true. Multi-input gates are binary folds; a single input is unchanged. Empty AND is true, while empty OR and XOR are false, as in the source evaluator. No final output is implicitly forced true: the source asks that every named assignment equal its expression.
+
+  _Local bounds._ In bits $x,y$ with output $z$, the AND and OR energies are respectively $4(x y-2x z-2y z+3z)-3$ and $4(x+y+z+x y-2x z-2y z)-3$. Their minima are $-3$, attained exactly on valid truth-table rows. The XOR gadget with auxiliary bit $a$ has energy $2(x+y-z-2a)^2-4$, with minimum $-4$ exactly when $z=x " XOR " y$ and the auxiliary is consistent. NOT has energy $2(x+z-1)^2-1$, with minimum $-1$. Each constant has minimum $-1$; each equality coupling has minimum $-4$ exactly on equal spins.
+
+  Let $b$ be the sum of these local minima over the gadgets and equality constraints actually emitted. Store $b$ using checked signed integer arithmetic. Then $H-b$ is a sum of nonnegative local penalties, even when expressions share variables, inputs repeat, or named assignments form cycles.
+
+  _Forward direction._ Given a satisfying source assignment, evaluate each finite expression tree under that assignment, set its fresh output spins accordingly, and choose each XOR auxiliary to satisfy $x+y=z+2a$. Every equality to a named output holds because the source assignment satisfies all constraints. Thus every local term attains its lower bound and $H=b$.
 
-  _Spin mapping:_ Boolean variables $sigma in {0,1}$ map to Ising spins $s = 2sigma - 1 in {-1, +1}$. Each circuit variable is assigned a unique spin index; gate gadgets reference these indices for their inputs and outputs.
+  _Backward direction._ A target state with $H=b$ has zero total penalty, so every nonnegative local penalty is zero. Induction on each expression tree gives its correct output; the equality terms identify it with all corresponding named output variables. Reading named spins therefore satisfies every source assignment constraint. This proof does not assume that an inconsistent circuit can simultaneously minimize its local terms.
 
-  _Gate gadgets_ (inputs 0,1; output 2; auxiliary 3 for XOR) are listed in @tab:gadgets. For each gate, instantiate the gadget's couplings and fields. The total Hamiltonian is the sum over all gadgets: $H = -sum_(i < j) J_(i j) s_i s_j - sum_i h_i s_i$.
+  _Value and witness extraction._ Convert the proved target minimum $E$ to source feasibility by $E=b$. The witness extractor validates the target once, rejects states whose energy differs from $b$, and returns every source variable in the model's canonical order using $x=(s+1)/2$. The empty circuit has $b=0$ and the empty witness.
 
-  _Correctness._ ($arrow.r.double$) A satisfying circuit assignment maps to a spin configuration where every gadget is in a ground state (valid I/O), so the total energy is minimized. ($arrow.l.double$) Any global ground state must minimize each gadget's contribution. Since each gadget's ground states match its gate's truth table, the spin configuration encodes a valid circuit evaluation. The output spin is constrained to $+1$ (true), so the circuit is satisfied.
+  _Overhead._ For $v$ source variables, $t$ expression-tree nodes, and $o$ assignment outputs, there are at most $v+3t$ spins and $6t+o$ stored interactions. There are at most $t$ constant and NOT output spins, and binary folds allocate at most two spins per expression-tree edge, of which there are at most $t$. Merging interactions can only reduce the latter count. All coefficient accumulation and threshold addition use checked integer arithmetic.
 
-  _Solution extraction._ Map spins back to Boolean: $sigma_i = (s_i + 1) / 2$. Return the circuit input variables.
 ]
 
 #figure(
@@ -13151,30 +13067,26 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 ) <tab:gadgets>
 
 #let fact_cs = load-example("Factoring", "CircuitSAT")
-#let fact-decode(config, start, count) = {
-  let pow2 = (1, 2, 4, 8, 16, 32)
-  range(count).fold(0, (acc, i) => acc + config.at(start + i) * pow2.at(i))
-}
 #let fact_cs_sol = fact_cs.solutions.at(0)
 #let fact-nbf = fact_cs.source.instance.m
 #let fact-nbs = fact_cs.source.instance.n
-#let fact-p = fact-decode(fact_cs_sol.source_config, 0, fact-nbf)
-#let fact-q = fact-decode(fact_cs_sol.source_config, fact-nbf, fact-nbs)
+#let fact-p = fact_cs_sol.source_config.at(0).at(0)
+#let fact-q = fact_cs_sol.source_config.at(1).at(0)
 #reduction-rule("Factoring", "CircuitSAT",
   example: true,
   example-caption: [Factor $N = #fact_cs.source.instance.target$],
   extra: [
     #pred-commands(
       "pred create --example Factoring -o factoring.json",
-      "pred reduce factoring.json --to " + target-spec(fact_cs) + " -o bundle.json",
+      "pred reduce factoring.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate factoring.json --config " + fact_cs_sol.source_config.map(str).join(","),
+      "pred evaluate factoring.json --config " + cli-config(fact_cs_sol.source_config),
     )
     Circuit: $#fact-nbf times #fact-nbs$ array multiplier with #circuit-num-gates(fact_cs.target.instance) gates, #circuit-num-variables(fact_cs.target.instance) variables \
     Canonical witness: $#fact-p times #fact-q = #fact_cs.source.instance.target$ #sym.checkmark
   ],
 )[
-  Integer multiplication can be implemented as a boolean circuit: an $m times n$ array multiplier computes $p times q$ using only AND, XOR, and OR gates arranged in a grid of full adders. Constraining the output bits to match $N$ turns the circuit into a satisfiability problem --- the circuit is satisfiable iff $N = p times q$ for some $p, q$ within the given bit widths. _(Folklore; no canonical reference.)_
+  Integer multiplication can be implemented as a boolean circuit: an $m times n$ array multiplier computes $p times q$ using only AND, XOR, and OR gates arranged in a grid of full adders. Constraining the output bits to match $N$ turns the circuit into a satisfiability problem --- the circuit is satisfiable iff $N = p times q$ for some $p, q$ within the given bit widths. The partial-product and array-adder construction follows @dally2006ee108[Section 10.4, Figures 10.15–10.16]; the zero-width extension is justified below.
 ][
   _Construction._ Build $m times n$ array multiplier for $p times q$:
 
@@ -13182,11 +13094,18 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   $ a := p_i and q_j, quad t_1 := a xor s_"prev", quad s_(i,j) := t_1 xor c_"prev" $
   $ t_2 := t_1 and c_"prev", quad t_3 := a and s_"prev", quad c_(i,j) := t_2 or t_3 $
 
-  _Output constraint:_ Fix output wires to the binary representation of $N$: $M_k := "bit"_k(N)$ for $k = 1, dots, m+n$.
+  _Accumulator and output:_ Start with a zero accumulator, expressing its $n$ retained bits as $q_j and 0$. These expressions retain every second-factor input even when $m = 0$. Each row emits its low sum bit; after all rows, the remaining accumulator bits give the high product bits. Define $m+n$ named output wires by these actual expressions, then fix output wires to the binary representation of $N$: $M_k := "bit"_k(N)$ for $k = 1, dots, m+n$. If $N$ has a set bit beyond this width, add two contradictory assignments to one wire. If both widths are zero, there are no product wires and this same overflow check rejects every nonzero target.
+
+  _Correctness._ Let $Q$ be the second factor, $p_i$ the zero-indexed first-factor bits, $R_i$ the integer represented by row $i$'s sum and final carry, and $L_i$ the integer encoded by its first $i$ emitted low bits. Set $R_0 = L_0 = 0$. Full-adder equations give $R_i = p_(i-1) Q + floor(R_(i-1)/2)$. Induction gives
+  $L_i + 2^i floor(R_i/2) = Q sum_(j=0)^(i-1) p_j 2^j.$
+  Thus the emitted bits followed by the residual bits represent exactly $P Q$, including the empty sum when $m = 0$.
+
+  ($arrow.r.double$) For any source factorization, assign the factor inputs and evaluate the acyclic arithmetic assignments in order. The invariant makes all output equalities hold, and a representable product cannot trigger the overflow contradiction. ($arrow.l.double$) Every satisfying assignment obeys each full-adder equation, so induction forces its named product bits to equal the actual input product. The output constants and high-bit rejection then force $P Q = N$.
 
-  _Correctness._ ($arrow.r.double$) If $N = p times q$ with $p < 2^m$ and $q < 2^n$, setting the input bits to the binary representations of $p$ and $q$ produces output bits matching $N$, satisfying all constraints. ($arrow.l.double$) Any satisfying assignment to the circuit computes a valid multiplication (the gates enforce arithmetic correctness), and the output constraint ensures the product equals $N$.
+  _Solution extraction._ Evaluate the target certificate once and reject it unless all equations hold. Read off factor bits $p = sum_i p_i 2^(i-1)$ and $q = sum_j q_j 2^(j-1)$, then return $(min(p,q), max(p,q))$. The source requires $m <= n$. Sorting preserves the asymmetric bounds: if inputs are exchanged, the new smaller factor is below the old first factor, while both inputs fit the larger width.
+
+  _Size and arithmetic._ Product width and assignment capacity are checked before allocation. At most $6 m n + 2(m+n) + 2$ assignments and $6 m n + 2(m+n) + 1$ variables are generated. Factors and products use exact arbitrary-precision integers; the circuit enforces bit arithmetic without floating-point conversions. The cell and output assignments use only the existing Boolean expression API.
 
-  _Solution extraction._ Read off factor bits: $p = sum_i p_i 2^(i-1)$, $q = sum_j q_j 2^(j-1)$.
 ]
 
 #let mc_sg = load-example("MaxCut", "SpinGlass")
@@ -13198,12 +13117,12 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example MaxCut -o maxcut.json",
-      "pred reduce maxcut.json --to " + target-spec(mc_sg) + " -o bundle.json",
+      "pred reduce maxcut.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate maxcut.json --config " + mc_sg_sol.source_config.map(str).join(","),
+      "pred evaluate maxcut.json --config " + cli-config(mc_sg_sol.source_config),
     )
     Direct 1:1 mapping: vertices $arrow.r$ spins, $J_(i j) = w_(i j) = 1$, $h_i = 0$ \
-    Partition: $S = {#mc_sg_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", ")}$ vs $overline(S) = {#mc_sg_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => str(i)).join(", ")}$ \
+    Partition: $S = {#mc_sg_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", ")}$ vs $overline(S) = {#mc_sg_sol.source_config.enumerate().filter(((i, x)) => not x).map(((i, x)) => str(i)).join(", ")}$ \
     Cut value $= #mc_sg_cut$ (canonical witness shown) #sym.checkmark
   ],
 )[
@@ -13224,9 +13143,9 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
   extra: [
     #pred-commands(
       "pred create --example SpinGlass -o spinglass.json",
-      "pred reduce spinglass.json --to " + target-spec(sg_mc) + " -o bundle.json",
+      "pred reduce spinglass.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate spinglass.json --config " + sg_mc_sol.source_config.map(str).join(","),
+      "pred evaluate spinglass.json --config " + cli-config(sg_mc_sol.source_config),
     )
     All $h_i = 0$: no ancilla needed, direct 1:1 vertex mapping \
     Edge weights $w_(i j) = J_(i j) in {plus.minus 1}$ (alternating couplings) \
@@ -13267,13 +13186,17 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 ]
 
 #reduction-rule("KColoring", "TwoDimensionalConsecutiveSets")[
-  @lipski1977fct A graph 3-coloring can be encoded as a partition problem on an alphabet. Each edge becomes a size-3 subset containing the two endpoint symbols plus a unique dummy symbol, and a valid 3-coloring corresponds to partitioning the alphabet into 3 groups where each edge-subset spans exactly 3 consecutive groups with one element per group. The reduction uses $n + m$ alphabet symbols and $m$ subsets for a graph with $n$ vertices and $m$ edges.
+  A fixed three-coloring problem reduces to the ordered-partition problem of @lipski1978consecutive (Problem 5). For a nonempty loopless graph with $n$ vertices and $m$ stored edges, use one vertex symbol and one private symbol per edge; every edge becomes a three-element subset. The construction and decoding below also cover empty graphs and native self-loops.
 ][
-  _Construction._ Given $G = (V, E)$ with $|V| = n$ and $|E| = m$, build alphabet $Sigma = V union {d_e : e in E}$ of size $n + m$. For each edge $e = {u, v} in E$, define subset $Sigma_e = {u, v, d_e}$. The collection is $cal(C) = {Sigma_e : e in E}$ with $|cal(C)| = m$ subsets, each of size 3.
+  _Construction._ The source is `KColoring<K3, SimpleGraph>`: the fixed type requires exactly three available colors, and persisted `num_colors` must agree. If any source edge is a self-loop, return alphabet ${0,1,2}$ and subsets ${0,1},{1,2},{0,2}$. Otherwise label vertices $0,...,n-1$ and stored edges $e_0,...,e_(m-1)$. Use alphabet size $max(1,n+m)$ and, for $e_i={u,v}$, subset ${u,v,n+i}$. Construct through the target's fallible constructor. Repeated source edges receive distinct private symbols.
+
+  _Forward direction._ For a loopless graph, a proper coloring assigns adjacent vertices distinct colors from ${0,1,2}$. Assign each edge's private symbol the remaining third color. Each triple occupies all three consecutive nonempty color groups, one symbol per group. If there are no edges, all group assignments satisfy the empty family of constraints; in particular the empty source maps to one unconstrained symbol. A looped source has no proper coloring.
 
-  _Correctness._ ($arrow.r.double$) Given a valid 3-coloring $chi: V arrow {1, 2, 3}$, define partition groups $X_c = {v in V : chi(v) = c}$ for $c in {1, 2, 3}$. For each edge $e = {u, v}$, assign dummy $d_e$ to the unique third color $c^* in {1, 2, 3} backslash {chi(u), chi(v)}$ (which exists since $chi(u) != chi(v)$). Then $Sigma_e = {u, v, d_e}$ has its three elements in three distinct groups ${X_(chi(u)), X_(chi(v)), X_(c^*)} = {X_1, X_2, X_3}$, which are consecutive with one element per group. ($arrow.l.double$) If a valid partition into $k$ groups exists, each size-3 subset ${u, v, d_e}$ must occupy 3 distinct consecutive groups. In particular, $u$ and $v$ are in different groups. Mapping groups to colors gives a valid 3-coloring.
+  _Backward direction._ In any feasible target partition for an ordinary graph, an edge triple occupies three distinct consecutive nonempty groups. Its endpoint groups are therefore distinct and differ by at most two in the ordered partition. Remove groups containing only private symbols and rank the remaining vertex groups starting at zero. Deleting groups cannot increase the distance between endpoint ranks, so every edge has rank difference 1 or 2. Assigning each vertex its group rank modulo 3 gives different colors on every edge, regardless of the total number of groups. For the loop sentinel, all three symbols would have to be pairwise distinct and every pair consecutive. The first and last groups cannot be adjacent, proving target infeasibility.
 
-  _Solution extraction._ The first $n$ symbols in the target configuration correspond to the graph vertices. Their group assignments, compressed to $0, 1, 2$, yield the 3-coloring.
+  _Solution extraction._ Validate the target once, require `Or(true)`, and then return the ranks modulo 3 of the first $n$ symbols. Infeasible and malformed certificates are rejected. The loop sentinel never reaches prefix decoding, even when its alphabet is smaller than $n$. The empty-source prefix is empty and is a valid coloring.
+
+  _Domain and overhead._ The actual alphabet and subset counts are bounded by $n+m+3$ and $m+3$. Source graph storage contains nonzero-sized petgraph node and edge records. With $I=$ `isize::MAX`, their vector allocation bounds imply $n<=floor(I/8)$ and $m<=floor(I/16)$ for the native unit-weight, `u32`-indexed graph, so $n+m$ and every private-symbol index fit `usize`. Group ranks are at most the alphabet size minus one; modulo 3 yields exactly the source color domain. Target allocation failures remain errors. This proof uses the ordered-set definition; it does not assume that every target witness uses only three groups.
 ]
 
 #reduction-rule("Factoring", "ILP")[
@@ -13305,13 +13228,33 @@ where $P$ is a penalty weight large enough that any constraint violation costs m
 
   _Correctness._ The McCormick constraints enforce $z_(i j) = p_i dot q_j$ for binary variables. The bit equations encode $p times q = N$ via carry propagation, matching array multiplier semantics.
 
-  _Solution extraction._ Read $p = sum_i p_i 2^i$ and $q = sum_j q_j 2^j$ from the binary variables.
+  _Solution extraction._ Read $p = sum_i p_i 2^i$ and $q = sum_j q_j 2^j$ from the binary variables, then return $(min(p,q), max(p,q))$.
 ]
 
 == ILP Formulations
 
 The following reductions to Integer Linear Programming are straightforward formulations where problem constraints map directly to linear inequalities.
 
+#reduction-rule("MultipleChoiceBranching", "ILP")[
+  A topological-order formulation makes the branching acyclicity condition linear while retaining the source indegree, partition, and weight inequalities directly.
+][
+  _Construction._ For every arc $a$ introduce a nonnegative integer $x_a <= 1$, and for every vertex $v$ introduce an integer order $0 <= p_v <= n-1$. Add $sum_(a in A_i)x_a <= 1$ for each partition group, $sum_(a in delta^-(v))x_a <= 1$ for each vertex, and $sum_a w_a x_a >= K$. For every arc $a=(u,v)$ add $p_u-p_v+n x_a <= n-1$. The target has exactly $m+n$ variables and $2m+2n+g+1$ constraints for $g$ partition groups.
+
+  _Correctness._ A source branching admits a topological order, which satisfies the order rows. Conversely, selecting $(u,v)$ forces $p_v >= p_u+1$, so selected arcs cannot contain a directed cycle. All remaining source conditions are represented verbatim by their corresponding rows.
+
+  _Solution extraction._ Return arc $a$ exactly when $x_a=1$.
+]
+
+#reduction-rule("PartitionIntoCliques", "ILP")[
+  The standard one-hot coloring formulation applied to the complement graph assigns every source vertex to one of the available clique labels and forbids non-adjacent vertices from sharing a label.
+][
+  _Construction._ Introduce $x_(v,c) in {0,1}$ for every vertex $v$ and clique label $c$. Require $sum_c x_(v,c)=1$ for every vertex. For every source non-edge ${u,v}$ and label $c$, require $x_(u,c)+x_(v,c) <= 1$. Use the zero objective. Since $K <= n$, the target has at most $n^2$ variables and $n+n^3$ constraints.
+
+  _Correctness._ A clique partition satisfies all one-hot rows, and no non-edge has both endpoints in one part. Conversely, the unique selected label of each vertex defines a partition; every two vertices sharing a label must be adjacent, so each part is a clique.
+
+  _Solution extraction._ For each vertex $v$, return the unique label $c$ with $x_(v,c)=1$.
+]
+
 #reduction-rule("MaximumSetPacking", "ILP")[
   Each set is either selected or not, and every universe element may belong to at most one selected set -- an element-based constraint that is directly linear in binary indicator variables.
 ][
@@ -13380,9 +13323,9 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(mfdts_ilp.source) + " -o mfdts.json",
-      "pred reduce mfdts.json --to " + target-spec(mfdts_ilp) + " -o bundle.json",
+      "pred reduce mfdts.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate mfdts.json --config " + mfdts_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate mfdts.json --config " + cli-config(mfdts_ilp_sol.source_config),
     )
 
     #{
@@ -13391,11 +13334,11 @@ The following reductions to Integer Linear Programming are straightforward formu
       let source-config = mfdts_ilp_sol.source_config
       let target-config = mfdts_ilp_sol.target_config
       [
-        *Step 1 -- Source instance.* The canonical DAG has $#source.num_vertices$ vertices and arcs #source.arcs.map(((u, v)) => [$(#u, #v)$]).join(", "). Inputs are ${#source.inputs.map(str).join(", ")}$, outputs are ${#source.outputs.map(str).join(", ")}$, so the internal vertices are ${2, 3, 4}$. The source configuration therefore has $#source.inputs.len() dot #source.outputs.len() = #target.num_vars$ input-output pair bits.
+        *Step 1 -- Source instance.* The canonical DAG has $#source.num_vertices$ vertices and arcs #source.arcs.map(((u, v)) => [$(#u, #v)$]).join(", "). Inputs are ${#fmt-values(source.inputs)}$, outputs are ${#fmt-values(source.outputs)}$, so the internal vertices are ${2, 3, 4}$. The source configuration therefore has $#source.inputs.len() dot #source.outputs.len() = #target.variables.len()$ input-output pair bits.
 
-        *Step 2 -- Build the covering ILP.* Order the pair variables as $(#source.inputs.at(0), #source.outputs.at(0))$, $(#source.inputs.at(0), #source.outputs.at(1))$, $(#source.inputs.at(1), #source.outputs.at(0))$, and $(#source.inputs.at(1), #source.outputs.at(1))$. Their internal coverage sets are ${2, 3}$, ${3}$, ${3}$, and ${3, 4}$, so the target has #target.num_vars binary variables, #target.constraints.len() covering constraints, and objective $min (x_0 + x_1 + x_2 + x_3)$. The exported constraints are exactly $x_0 >= 1$, $x_0 + x_1 + x_2 + x_3 >= 1$, and $x_3 >= 1$.
+        *Step 2 -- Build the covering ILP.* Order the pair variables as $(#source.inputs.at(0), #source.outputs.at(0))$, $(#source.inputs.at(0), #source.outputs.at(1))$, $(#source.inputs.at(1), #source.outputs.at(0))$, and $(#source.inputs.at(1), #source.outputs.at(1))$. Their internal coverage sets are ${2, 3}$, ${3}$, ${3}$, and ${3, 4}$, so the target has #target.variables.len() binary variables, #target.constraints.len() covering constraints, and objective $min (x_0 + x_1 + x_2 + x_3)$. The exported constraints are exactly $x_0 >= 1$, $x_0 + x_1 + x_2 + x_3 >= 1$, and $x_3 >= 1$.
 
-        *Step 3 -- Verify the canonical witness.* The stored ILP witness is $(#target-config.map(str).join(", "))$. Because extraction is identity, the source witness is the same vector $(#source-config.map(str).join(", "))$, which selects pairs $(#source.inputs.at(0), #source.outputs.at(0))$ and $(#source.inputs.at(1), #source.outputs.at(1))$. These two pairs cover internal vertices ${2, 3}$ and ${3, 4}$ respectively, so their union covers every internal vertex and the optimum value is $2$ #sym.checkmark.
+        *Step 3 -- Verify the canonical witness.* The stored ILP witness is $(#fmt-values(target-config))$. Because extraction is identity, the source witness is the same vector $(#fmt-values(source-config))$, which selects pairs $(#source.inputs.at(0), #source.outputs.at(0))$ and $(#source.inputs.at(1), #source.outputs.at(1))$. These two pairs cover internal vertices ${2, 3}$ and ${3, 4}$ respectively, so their union covers every internal vertex and the optimum value is $2$ #sym.checkmark.
 
         *Multiplicity:* The fixture stores one canonical witness. Any feasible solution must include $x_0 = 1$ to cover internal vertex 2 and $x_3 = 1$ to cover internal vertex 4, so the unique optimum is $(1, 0, 0, 1)$.
       ]
@@ -13446,34 +13389,32 @@ The following reductions to Integer Linear Programming are straightforward formu
   _Solution extraction._ $S = {v : x_v = 1}$.
 ]
 
-#let fvs_cg = load-example("MinimumFeedbackVertexSet", "MinimumCodeGenerationUnlimitedRegisters")
+#let fvs_cg = load-example("MinimumFeedbackVertexSet", "MinimumCodeGenerationUnlimitedRegisters", source-variant: (weight: "One"))
 #let fvs_cg_sol = fvs_cg.solutions.at(0)
-#let fvs_cg_fvs = fvs_cg_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let fvs_cg_fvs = fvs_cg_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #reduction-rule("MinimumFeedbackVertexSet", "MinimumCodeGenerationUnlimitedRegisters",
   example: true,
+  example-source-variant: (weight: "One"),
   example-caption: [3-cycle digraph: FVS of size 1 maps to an expression DAG needing 1 LOAD],
   extra: [
     #pred-commands(
-      "pred create --example MinimumFeedbackVertexSet -o fvs.json",
-      "pred reduce fvs.json --to " + target-spec(fvs_cg) + " -o bundle.json",
+      "pred create --example MinimumFeedbackVertexSet/One -o fvs.json",
+      "pred reduce fvs.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate fvs.json --config " + fvs_cg_sol.source_config.map(str).join(","),
+      "pred evaluate fvs.json --config " + cli-config(fvs_cg_sol.source_config),
     )
-    Source FVS: $F = {#fvs_cg_fvs.map(str).join(", ")}$ (size #fvs_cg_fvs.len()) on a digraph with $n = #fvs_cg.source.instance.graph.num_vertices$ vertices and $m = #fvs_cg.source.instance.graph.arcs.len()$ arcs \
+    Source FVS: $F = {#fmt-values(fvs_cg_fvs)}$ (size #fvs_cg_fvs.len()) on a digraph with $n = #fvs_cg.source.instance.graph.num_vertices$ vertices and $m = #fvs_cg.source.instance.graph.arcs.len()$ arcs \
     Target DAG: #fvs_cg.target.instance.num_vertices vertices, left arcs $L$: #{fvs_cg.target.instance.left_arcs.map(a => $#(a.at(0)) arrow.r #(a.at(1))$).join(", ")}, right arcs $R$: #{fvs_cg.target.instance.right_arcs.map(a => $#(a.at(0)) arrow.r #(a.at(1))$).join(", ")} \
-    Target evaluation order: $(#fvs_cg_sol.target_config.map(str).join(", "))$ with #fvs_cg_sol.target_config.len() instructions #sym.checkmark
+    Target evaluation order: $(#fmt-values(fvs_cg_sol.target_config))$ with #(fvs_cg_sol.target_config.len() + fvs_cg_fvs.len()) instructions #sym.checkmark
   ],
 )[
-  The Aho--Johnson--Ullman chain gadget construction @ahoJohnsonUllman1977 encodes a feedback vertex set problem as a code generation problem on an expression DAG with unlimited registers and 2-address instructions. Each source vertex becomes a leaf (input register), and each outgoing arc becomes an internal chain node. The number of LOAD (copy) instructions needed in an optimal program equals the size of a minimum feedback vertex set.
+  For the unit-weight variant, minimum feedback vertex set reduces to code generation on a leaf-sharing expression DAG with unlimited registers and 2-address instructions. The cardinality reduction of Aho--Johnson--Ullman @ahoJohnsonUllman1977 motivates the construction; separate start operations below extend it uniformly to self-loops. Arbitrary vertex weights are not represented by unit-cost copies and are excluded from this rule. If the source has $n$ vertices, $m$ arc records, and minimum feedback vertex set size $tau$, the target optimum is $n + m + tau$.
 ][
-  _Construction._ Given a directed graph $G = (V, A)$ with $n = |V|$ vertices and $m = |A|$ arcs, build an expression DAG $D$ with $n + m$ vertices as follows. Vertices $0, dots, n-1$ are _leaves_ (one per source vertex), each stored in its own register. For each source vertex $x$ with outgoing arcs $(x, y_1), dots, (x, y_d)$, create a chain of $d$ internal nodes $x^1, dots, x^d$ where:
-  - $x^1$ has left child $x^0$ (the leaf for $x$) and right child $y_1^0$ (the leaf for $y_1$),
-  - $x^i$ ($i >= 2$) has left child $x^(i-1)$ (previous chain node) and right child $y_i^0$ (the leaf for $y_i$).
-  The left operand's register is destroyed by the OP instruction; a LOAD (copy) is needed whenever a leaf register must survive past its destruction.
+  _Construction._ Introduce one leaf $x^0$ per source vertex and a right-only dummy leaf $q$. For every vertex $x$, including sinks and isolated vertices, create a start operation $s_x$ with operands $(x^0, q)$. For each outgoing arc $(x, y_i)$, append an operation $c_(x,i)$ with the preceding operation in this chain as left operand and $y_i^0$ as right operand. Preserve the source arc order within each chain. There are $n + 1$ leaves and $N = n + m$ operations, hence $2n + m + 1$ vertices and $N$ operand arcs of each kind. The construction is linear in $n + m + 1$ and always yields a binary expression DAG.
 
-  _Correctness._ ($arrow.r.double$) If $F subset.eq V$ is a feedback vertex set of size $k$, then $G[V backslash F]$ is a DAG. The topological order of $G[V backslash F]$ induces an evaluation order of the chain nodes such that each leaf $x^0$ with $x in.not F$ is consumed (as a left child) only after all chain nodes that reference it as a right child have been evaluated. Only leaves corresponding to vertices in $F$ need a LOAD instruction (their register is destroyed before some right-child usage). Hence the program uses exactly $n + m - n + k = m + k$ instructions, of which $k$ are LOADs. ($arrow.l.double$) If an optimal program uses $k$ LOAD instructions, the $k$ leaves that require LOADs form a set $F$: removing $F$ from $G$ leaves a DAG (otherwise a directed cycle $v_1 -> dots -> v_l -> v_1$ would require each $v_i^0$ to be consumed before $v_(i+1)^0$, creating a circular register dependency that demands at least one additional LOAD for each cycle). Thus $F$ is a feedback vertex set of size $k$.
+  _Extraction and backward direction._ In any valid evaluation order, select $x$ exactly when some right-use of $x^0$ occurs after $s_x$. Each original leaf is overwritten only at its start, the dummy leaf is never overwritten, and each internal result has at most one use. Therefore the instruction count is exactly $N + |F|$ for the extracted set $F$. For every source arc $(x,y)$ with $y in.not F$, the order satisfies $s_x < c_(x,i) < s_y$. Thus start positions strictly increase on every arc induced by $V backslash F$, which is acyclic. A self-loop forces its vertex into $F$ by the same inequality. This argument covers arbitrary interleavings and parallel arcs.
 
-  _Solution extraction._ Given a target evaluation order (permutation of internal nodes), identify which leaves require a LOAD: leaf $x^0$ needs a LOAD iff the chain-start node $x^1$ is evaluated before some other internal node that uses $x^0$ as a right child. Set $c_x = 1$ for such vertices and $c_x = 0$ otherwise.
+  _Forward direction and optimality._ Given a feedback vertex set $F$, execute complete chains for its vertices first, then complete chains for the remaining vertices in a topological order of $G[V backslash F]$. Every right-use of an unselected leaf precedes its start, so this order costs at most $N + |F|$. Combined with the backward bound, this proves that the target optimum is $N + tau$ and that every optimal target order extracts a minimum feedback vertex set. The empty source produces one dummy leaf and an empty order of cost zero.
 ]
 
 #reduction-rule("MaximumClique", "ILP")[
@@ -13494,23 +13435,23 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let mckp_ilp = load-example(
   "MaximumCoKPlex",
   "ILP",
-  source-variant: (graph: "SimpleGraph", k: "KN", weight: "i32"),
-  target-variant: (variable: "bool"),
+  source-variant: (graph: "SimpleGraph", k: "KN", weight: "i64"),
+  target-variant: (coefficient: "i64", variable: "bool"),
 )
 #let mckp_ilp_sol = mckp_ilp.solutions.at(0)
 #reduction-rule("MaximumCoKPlex", "ILP",
   example: true,
-  example-source-variant: (graph: "SimpleGraph", k: "KN", weight: "i32"),
-  example-target-variant: (variable: "bool"),
+  example-source-variant: (graph: "SimpleGraph", k: "KN", weight: "i64"),
+  example-target-variant: (coefficient: "i64", variable: "bool"),
   example-caption: [Weighted 5-cycle ($n = 5$), $k = 2$],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(mckp_ilp.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(mckp_ilp) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + mckp_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(mckp_ilp_sol.source_config),
     )
-    Source co-$k$-plex witness $(#mckp_ilp_sol.source_config.map(str).join(", "))$, target ILP witness $(#mckp_ilp_sol.target_config.map(str).join(", "))$.
+    Source co-$k$-plex witness $(#fmt-values(mckp_ilp_sol.source_config))$, target ILP witness $(#fmt-values(mckp_ilp_sol.target_config))$.
   ],
 )[
   This direct binary ILP formulation introduces one variable per source vertex and one induced-degree cap per source vertex @Hernandez2016MolecularSimilarity.
@@ -13530,21 +13471,21 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let mces_ilp = load-example(
   "MaximumCommonEdgeSubgraph",
   "ILP",
-  target-variant: (variable: "bool"),
+  target-variant: (coefficient: "i64", variable: "bool"),
 )
 #let mces_ilp_sol = mces_ilp.solutions.at(0)
 #reduction-rule("MaximumCommonEdgeSubgraph", "ILP",
   example: true,
-  example-target-variant: (variable: "bool"),
+  example-target-variant: (coefficient: "i64", variable: "bool"),
   example-caption: [Two labelled 3-vertex digraphs with 2 arcs each],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(mces_ilp.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(mces_ilp) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + mces_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(mces_ilp_sol.source_config),
     )
-    Source mapping witness $(#mces_ilp_sol.source_config.map(str).join(", "))$, target ILP witness $(#mces_ilp_sol.target_config.map(str).join(", "))$.
+    Source mapping witness $(#fmt-values(mces_ilp_sol.source_config))$, target ILP witness $(#fmt-values(mces_ilp_sol.target_config))$.
   ],
 )[
   Encode a partial injective vertex map with row and column inequalities and linearize each label-compatible source/target arc pair with a McCormick product variable @Bahiense2012MCES.
@@ -13568,21 +13509,21 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let cmo_ilp = load-example(
   "MaximumContactMapOverlap",
   "ILP",
-  target-variant: (variable: "bool"),
+  target-variant: (coefficient: "i64", variable: "bool"),
 )
 #let cmo_ilp_sol = cmo_ilp.solutions.at(0)
 #reduction-rule("MaximumContactMapOverlap", "ILP",
   example: true,
-  example-target-variant: (variable: "bool"),
+  example-target-variant: (coefficient: "i64", variable: "bool"),
   example-caption: [$|V_1| = #cmo_ilp.source.instance.num_vertices_1$, $|E_1| = #cmo_ilp.source.instance.contacts_1.len()$, $|V_2| = #cmo_ilp.source.instance.num_vertices_2$, $|E_2| = #cmo_ilp.source.instance.contacts_2.len()$],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(cmo_ilp.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(cmo_ilp) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + cmo_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(cmo_ilp_sol.source_config),
     )
-    Source alignment witness $(#cmo_ilp_sol.source_config.map(str).join(", "))$ (each entry is the matched index in $V_2$ shifted by $1$, with $0$ meaning unmatched), target ILP witness $(#cmo_ilp_sol.target_config.map(str).join(", "))$.
+    Source alignment witness $(#fmt-values(cmo_ilp_sol.source_config))$ (each entry is the matched index in $V_2$ shifted by $1$, with $0$ meaning unmatched), target ILP witness $(#fmt-values(cmo_ilp_sol.target_config))$.
   ],
 )[
   Encode the order-preserving partial injective alignment $V_1 -> V_2$ by binary match variables $x_(i,j)$ with row, column, and crossing-forbidding inequalities, then linearize each pair of source/target contacts with a binary product variable $y_(i,k,j,l)$ to count preserved contacts @AndonovMalodDogninYanev2011CMO @XieSahinidis2007CMO.
@@ -13606,23 +13547,23 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let mewkc_ilp = load-example(
   "MaximumEdgeWeightedKClique",
   "ILP",
-  source-variant: (weight: "i32"),
-  target-variant: (variable: "bool"),
+  source-variant: (weight: "i64"),
+  target-variant: (coefficient: "i64", variable: "bool"),
 )
 #let mewkc_ilp_sol = mewkc_ilp.solutions.at(0)
 #reduction-rule("MaximumEdgeWeightedKClique", "ILP",
   example: true,
-  example-source-variant: (weight: "i32"),
-  example-target-variant: (variable: "bool"),
+  example-source-variant: (weight: "i64"),
+  example-target-variant: (coefficient: "i64", variable: "bool"),
   example-caption: [$n = 4$ vertices, $m = 5$ edges, $k = 3$],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(mewkc_ilp.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(mewkc_ilp) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + mewkc_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(mewkc_ilp_sol.source_config),
     )
-    Source $k$-clique witness $(#mewkc_ilp_sol.source_config.map(str).join(", "))$, target ILP witness $(#mewkc_ilp_sol.target_config.map(str).join(", "))$.
+    Source $k$-clique witness $(#fmt-values(mewkc_ilp_sol.source_config))$, target ILP witness $(#fmt-values(mewkc_ilp_sol.target_config))$.
   ],
 )[
   Binary vertex selectors with an exact-cardinality constraint, non-edge clique constraints, and McCormick edge-product variables linearize the induced edge-weight sum @ParkLeePark1996EWClique @GouveiaMartins2015EWClique.
@@ -13645,7 +13586,7 @@ The following reductions to Integer Linear Programming are straightforward formu
 
 #let ks_ilp = load-example("Knapsack", "ILP")
 #let ks_ilp_sol = ks_ilp.solutions.at(0)
-#let ks_ilp_selected = ks_ilp_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let ks_ilp_selected = ks_ilp_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #let ks_ilp_sel_weight = ks_ilp_selected.fold(0, (a, i) => a + ks_ilp.source.instance.weights.at(i))
 #let ks_ilp_sel_value = ks_ilp_selected.fold(0, (a, i) => a + ks_ilp.source.instance.values.at(i))
 #reduction-rule("Knapsack", "ILP",
@@ -13654,11 +13595,11 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example Knapsack -o knapsack.json",
-      "pred reduce knapsack.json --to " + target-spec(ks_ilp) + " -o bundle.json",
+      "pred reduce knapsack.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate knapsack.json --config " + ks_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate knapsack.json --config " + cli-config(ks_ilp_sol.source_config),
     )
-    *Step 1 -- Source instance.* The canonical knapsack instance has weights $(#ks_ilp.source.instance.weights.map(str).join(", "))$, values $(#ks_ilp.source.instance.values.map(str).join(", "))$, and capacity $C = #ks_ilp.source.instance.capacity$.
+    *Step 1 -- Source instance.* The canonical knapsack instance has weights $(#fmt-values(ks_ilp.source.instance.weights))$, values $(#fmt-values(ks_ilp.source.instance.values))$, and capacity $C = #ks_ilp.source.instance.capacity$.
 
     *Step 2 -- Build the binary ILP.* Introduce one binary variable per item:
     $#range(ks_ilp.source.instance.weights.len()).map(i => $x_#i$).join(", ") in {0,1}$.
@@ -13667,9 +13608,9 @@ The following reductions to Integer Linear Programming are straightforward formu
     subject to the single capacity inequality
     $ #ks_ilp.source.instance.weights.enumerate().map(((i, w)) => $#w x_#i$).join($+$) <= #ks_ilp.source.instance.capacity. $
 
-    *Step 3 -- Verify a solution.* The ILP optimum $bold(x)^* = (#ks_ilp_sol.target_config.map(str).join(", "))$ extracts directly to the knapsack selection $bold(x)^* = (#ks_ilp_sol.source_config.map(str).join(", "))$, choosing items $\{#ks_ilp_selected.map(str).join(", ")\}$. Their total weight is $#ks_ilp_selected.map(i => str(ks_ilp.source.instance.weights.at(i))).join(" + ") = #ks_ilp_sel_weight$ and their total value is $#ks_ilp_selected.map(i => str(ks_ilp.source.instance.values.at(i))).join(" + ") = #ks_ilp_sel_value$ #sym.checkmark.
+    *Step 3 -- Verify a solution.* The ILP optimum $bold(x)^* = (#fmt-values(ks_ilp_sol.target_config))$ extracts directly to the knapsack selection $bold(x)^* = (#fmt-values(ks_ilp_sol.source_config))$, choosing items $\{#fmt-values(ks_ilp_selected)\}$. Their total weight is $#ks_ilp_selected.map(i => str(ks_ilp.source.instance.weights.at(i))).join(" + ") = #ks_ilp_sel_weight$ and their total value is $#ks_ilp_selected.map(i => str(ks_ilp.source.instance.values.at(i))).join(" + ") = #ks_ilp_sel_value$ #sym.checkmark.
 
-    *Uniqueness:* The fixture stores one canonical optimal witness. For this instance the optimum is unique: items $\{#ks_ilp_selected.map(str).join(", ")\}$ are the only feasible choice achieving value #ks_ilp_sel_value.
+    *Uniqueness:* The fixture stores one canonical optimal witness. For this instance the optimum is unique: items $\{#fmt-values(ks_ilp_selected)\}$ are the only feasible choice achieving value #ks_ilp_sel_value.
   ],
 )[
   A 0-1 Knapsack instance is already a binary Integer Linear Program @papadimitriou-steiglitz1982: each item-selection bit becomes a binary variable, the capacity condition is a single linear inequality, and the value objective is linear. The reduction preserves the number of decision variables exactly, producing an ILP with $n$ variables and one constraint.
@@ -13704,20 +13645,20 @@ The following reductions to Integer Linear Programming are straightforward formu
       [
         #pred-commands(
           "pred create --example " + problem-spec(ik_ilp.source) + " -o integer-knapsack.json",
-          "pred reduce integer-knapsack.json --to " + target-spec(ik_ilp) + " -o bundle.json",
+          "pred reduce integer-knapsack.json --via route.json -o bundle.json",
           "pred solve bundle.json",
-          "pred evaluate integer-knapsack.json --config " + ik_ilp_sol.source_config.map(str).join(","),
+          "pred evaluate integer-knapsack.json --config " + cli-config(ik_ilp_sol.source_config),
         )
 
-        *Step 1 -- Source instance.* The canonical Integer Knapsack instance has sizes $(#sizes.map(str).join(", "))$, values $(#values.map(str).join(", "))$, and capacity $B = #B$.
+        *Step 1 -- Source instance.* The canonical Integer Knapsack instance has sizes $(#fmt-values(sizes))$, values $(#fmt-values(values))$, and capacity $B = #B$.
 
         *Step 2 -- Build the ILP.* Introduce one integer variable per item multiplicity:
         $#range(sizes.len()).map(i => $c_#i$).join(", ") in NN$.
         The capacity constraint is
         $ #sizes.enumerate().map(((i, s)) => $#s c_#i$).join($+$) <= #B, $
-        and the explicit upper bounds are $(#upper.map(str).join(", "))$, i.e. $c_i <= floor.l B / s_i floor.r$ for every item.
+        and the explicit upper bounds are $(#fmt-values(upper))$, i.e. $c_i <= floor.l B / s_i floor.r$ for every item.
 
-        *Step 3 -- Verify the canonical witness.* The ILP optimum is $(#ik_ilp_sol.target_config.map(str).join(", "))$, which extracts identically to the source multiplicities $(#ik_ilp_sol.source_config.map(str).join(", "))$. The selected terms contribute total size $#total_size <= B$ and total value $#total_value$ #sym.checkmark.
+        *Step 3 -- Verify the canonical witness.* The ILP optimum is $(#fmt-values(ik_ilp_sol.target_config))$, which extracts identically to the source multiplicities $(#fmt-values(ik_ilp_sol.source_config))$. The selected terms contribute total size $#total_size <= B$ and total value $#total_value$ #sym.checkmark.
 
         *Uniqueness:* The fixture stores one canonical optimum, here $(0, 0, 2)$.
       ]
@@ -13747,21 +13688,21 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let clique_mis = load-example(
   "MaximumClique",
   "MaximumIndependentSet",
-  source-variant: (graph: "SimpleGraph", weight: "i32"),
-  target-variant: (graph: "SimpleGraph", weight: "i32"),
+  source-variant: (graph: "SimpleGraph", weight: "i64"),
+  target-variant: (graph: "SimpleGraph", weight: "i64"),
 )
 #let clique_mis_sol = clique_mis.solutions.at(0)
 #reduction-rule("MaximumClique", "MaximumIndependentSet",
   example: true,
-  example-source-variant: (graph: "SimpleGraph", weight: "i32"),
-  example-target-variant: (graph: "SimpleGraph", weight: "i32"),
+  example-source-variant: (graph: "SimpleGraph", weight: "i64"),
+  example-target-variant: (graph: "SimpleGraph", weight: "i64"),
   example-caption: [Path graph $P_4$: clique in $G$ maps to independent set in complement $overline(G)$.],
   extra: [
     #pred-commands(
       "pred create --example MaximumClique -o maximumclique.json",
-      "pred reduce maximumclique.json --to " + target-spec(clique_mis) + " -o bundle.json",
+      "pred reduce maximumclique.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate maximumclique.json --config " + clique_mis_sol.source_config.map(str).join(","),
+      "pred evaluate maximumclique.json --config " + cli-config(clique_mis_sol.source_config),
     )
   ],
 )[
@@ -13836,11 +13777,11 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ola_seqmwct.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(ola_seqmwct) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + ola_seqmwct_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(ola_seqmwct_sol.source_config),
     )
-    Source arrangement $pi = (#ola_seqmwct_sol.source_config.map(str).join(", "))$, target schedule $(#ola_seqmwct_sol.target_config.map(str).join(", "))$.
+    Source arrangement $pi = (#fmt-values(ola_seqmwct_sol.source_config))$, target schedule $(#fmt-values(ola_seqmwct_sol.target_config))$.
   ],
 )[
   @lawler1978 This $O(n + m)$ reduction turns each vertex into a unit-length job, each edge into a zero-length job, and uses precedences so that every edge job completes exactly when its later endpoint does. The weighted completion-time objective then equals the linear-arrangement objective plus the fixed shift $d_"max" n (n + 1) / 2$.
@@ -13872,22 +13813,23 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(dola_c1ma.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(dola_c1ma) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + dola_c1ma_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(dola_c1ma_sol.source_config),
     )
-    The source decision bound is $K = #dola_c1ma.source.instance.bound$, so the target augmentation bound is $K - m = #dola_c1ma.source.instance.bound - #dola_c1ma.target.instance.matrix.len() = #dola_c1ma.target.instance.bound$. Source arrangement $f = (#dola_c1ma_sol.source_config.map(str).join(", "))$ corresponds to target column permutation $(#dola_c1ma_sol.target_config.map(str).join(", "))$.
+    The source decision bound is $K = #dola_c1ma.source.instance.bound$, so the target augmentation bound is $K - m = #dola_c1ma.source.instance.bound - #dola_c1ma.target.instance.matrix.len() = #dola_c1ma.target.instance.bound$. Source arrangement $f = (#fmt-values(dola_c1ma_sol.source_config))$ corresponds to target column permutation $(#fmt-values(dola_c1ma_sol.target_config))$.
   ],
 )[
-  @garey1979[SR16] @booth1987 This $O(n m)$ reduction maps a decision Optimal Linear Arrangement instance $(G, K)$ to the edge-vertex incidence matrix of $G$ with augmentation bound $K - |E|$. A column permutation is exactly a vertex ordering; making each edge row consecutive costs one flip per interior gap, so the cheapest augmentation under a fixed ordering equals (total edge length) $- |E|$.
+  The incidence construction of @booth1975[Theorem 4.19, pp. 106–108], transposed to use edge rows and vertex columns, gives an $O(1 + n (m + 1))$ reduction. Let $ell$ count non-loop edges, including multiplicity. The augmentation cost for any vertex ordering equals its total edge length minus $ell$.
 ][
-  _Construction._ Let $G = (V, E)$ with $n = |V|$, $m = |E|$, and decision bound $K$. Build the $m times n$ binary matrix $A$ with rows indexed by edges and columns by vertices: for edge $e_i = {u, v}$ set $A[i][u] = A[i][v] = 1$ and all other entries of row $i$ to $0$. Each row has exactly two $1$'s. Set the augmentation bound to $"bound" = K - m$.
+  _Construction._ If $K < ell$, emit the fixed matrix $[[1,1,0],[0,1,1],[1,0,1]]$ with bound zero. Otherwise, form the edge-vertex incidence matrix and use augmentation bound $K - ell$. Retain duplicate edge rows and single-one loop rows. When there are no edges, use one all-zero row of length $n$ to retain all vertex columns; this row is empty when $n = 0$.
+
+  _Correctness._ Every non-loop edge contributes at least one to arrangement length, so $K < ell$ implies NO, including negative bounds. The fixed matrix is NO because among three column pairs at least one pair is not adjacent. In the incidence case, each non-loop row requires exactly $|f(u) - f(v)| - 1$ flips, each loop row requires zero flips, and the additional zero row requires zero flips. Thus $A(f) = S(f) - ell$, where $S$ is arrangement length. Consequently $A(f) <= K - ell$ holds exactly when $S(f) <= K$. The column permutation and the source arrangement are inverse bijections, proving both directions, including empty graphs and repeated edges. The extension to loops and empty graphs follows from this identity; these cases are not premises of the cited two-ones-per-edge proof.
 
-  _Correctness._ A column permutation is a bijection $f : V -> {1, dots, n}$. In the row for edge ${u, v}$ the two $1$'s sit at positions $f(u)$ and $f(v)$; making the row consecutive forces filling every zero strictly between them, i.e.\ $|f(u) - f(v)| - 1$ flips. Summed over all rows the total augmentation cost is $sum_({u,v} in E) (|f(u) - f(v)| - 1) = (sum_({u,v} in E) |f(u) - f(v)|) - m$. ($arrow.r.double$) If $G$ admits an arrangement of total length at most $K$, using it as the column permutation costs at most $K - m = "bound"$ flips, so the target is YES. ($arrow.l.double$) If $A$ can be made C1P with at most $"bound"$ flips, the witnessing column permutation gives an arrangement of total length at most $"bound" + m = K$, so the source is YES.
+  _Solution extraction._ Evaluate the target certificate once and reject it unless it is a permutation meeting the augmentation budget. Return its inverse permutation. No certificate passes for the NO matrix, so there is no source representative to invent in that branch.
 
-  _Edge inputs._ If $m = 0$ every arrangement has length $0 <= K$, so emit the always-YES $1 times 1$ matrix $[[0]]$ with bound $max(0, K)$. If $K < m$ the source is NO (every arrangement costs at least $m$), so emit the fixed $3 times 3$ cyclic-overlap matrix $[[1,1,0],[0,1,1],[1,0,1]]$ with bound $0$, which is NO under all $6$ column permutations.
+  _Arithmetic and size._ The non-loop edge count is converted to an exact signed integer. In the incidence branch $0 <= ell <= K <= 2^63 - 1$, so $K - ell$ is representable. Any accepted certificate has $S(f) <= K$, and its nonnegative edge-length partial sums are also representable. The target has at most $m + 3$ rows and $n + 3$ columns, covering both the incidence representation and the fixed NO matrix.
 
-  _Solution extraction._ Read the C1P column permutation $sigma$ (column $sigma(p)$ sits at position $p$) and return the inverse: vertex $v$ receives arrangement position $sigma^(-1)(v)$.
 ]
 
 #reduction-rule("SequencingToMinimizeWeightedCompletionTime", "ILP")[
@@ -13930,23 +13872,23 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let hc_tsp_target_weights = hc_tsp.target.instance.edge_weights
 #let hc_tsp_weight_one = hc_tsp_target_edges.enumerate().filter(((i, _)) => hc_tsp_target_weights.at(i) == 1).map(((i, e)) => (e.at(0), e.at(1)))
 #let hc_tsp_weight_two = hc_tsp_target_edges.enumerate().filter(((i, _)) => hc_tsp_target_weights.at(i) == 2).map(((i, e)) => (e.at(0), e.at(1)))
-#let hc_tsp_selected_edges = hc_tsp_target_edges.enumerate().filter(((i, _)) => hc_tsp_sol.target_config.at(i) == 1).map(((i, e)) => (e.at(0), e.at(1)))
+#let hc_tsp_selected_edges = hc_tsp_target_edges.enumerate().filter(((i, _)) => hc_tsp_sol.target_config.at(i)).map(((i, e)) => (e.at(0), e.at(1)))
 #reduction-rule("HamiltonianCircuit", "TravelingSalesman",
   example: true,
   example-caption: [Cycle graph on $#hc_tsp_n$ vertices to weighted $K_#hc_tsp_n$],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hc_tsp.source) + " -o hc.json",
-      "pred reduce hc.json --to " + target-spec(hc_tsp) + " -o bundle.json",
+      "pred reduce hc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hc.json --config " + hc_tsp_sol.source_config.map(str).join(","),
+      "pred evaluate hc.json --config " + cli-config(hc_tsp_sol.source_config),
     )
 
-    *Step 1 -- Start from the source graph.* The canonical source fixture is the cycle on vertices ${0, 1, 2, 3}$ with edges #hc_tsp_source_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The stored Hamiltonian-circuit witness is the permutation $[#hc_tsp_sol.source_config.map(str).join(", ")]$.\ 
+    *Step 1 -- Start from the source graph.* The canonical source fixture is the cycle on vertices ${0, 1, 2, 3}$ with edges #hc_tsp_source_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The stored Hamiltonian-circuit witness is the permutation $[#fmt-values(hc_tsp_sol.source_config)]$.\
 
     *Step 2 -- Complete the graph and encode adjacency by weights.* The target keeps the same $#hc_tsp_n$ vertices but adds the missing diagonals, so it becomes $K_#hc_tsp_n$ with $#graph-num-edges(hc_tsp.target.instance)$ undirected edges. The original cycle edges #hc_tsp_weight_one.map(e => $(#e.at(0), #e.at(1))$).join(", ") receive weight 1, while the diagonals #hc_tsp_weight_two.map(e => $(#e.at(0), #e.at(1))$).join(", ") receive weight 2.\ 
 
-    *Step 3 -- Verify the canonical witness.* The stored target configuration $[#hc_tsp_sol.target_config.map(str).join(", ")]$ selects the tour edges #hc_tsp_selected_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). Its total cost is $1 + 1 + 1 + 1 = #hc_tsp_n$, so every chosen edge is a weight-1 source edge, and traversing the selected cycle recovers the Hamiltonian circuit $[#hc_tsp_sol.source_config.map(str).join(", ")]$.\ 
+    *Step 3 -- Verify the canonical witness.* The stored target configuration $[#fmt-values(hc_tsp_sol.target_config)]$ selects the tour edges #hc_tsp_selected_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). Its total cost is $1 + 1 + 1 + 1 = #hc_tsp_n$, so every chosen edge is a weight-1 source edge, and traversing the selected cycle recovers the Hamiltonian circuit $[#fmt-values(hc_tsp_sol.source_config)]$.\
 
     *Multiplicity:* The fixture stores one canonical witness. For the 4-cycle there are $4 times 2 = 8$ Hamiltonian-circuit permutations (choice of start vertex and direction), but they all induce the same undirected target edge set.
   ],
@@ -13968,9 +13910,9 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example TSP -o tsp.json",
-      "pred reduce tsp.json --to " + target-spec(tsp_ilp) + " -o bundle.json",
+      "pred reduce tsp.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate tsp.json --config " + tsp_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate tsp.json --config " + cli-config(tsp_ilp_sol.source_config),
     )
   ],
 )[
@@ -14014,15 +13956,15 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example LongestPath -o longest-path.json",
-      "pred reduce longest-path.json --to " + target-spec(lp_ilp) + " -o bundle.json",
+      "pred reduce longest-path.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate longest-path.json --config " + lp_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate longest-path.json --config " + cli-config(lp_ilp_sol.source_config),
     )
     *Step 1 -- Orient each undirected edge.* The canonical witness has two source edges, so the reduction creates four directed-arc variables. The optimal witness sets $x_(0,1) = 1$ and $x_(1,2) = 1$, leaving the reverse directions at 0.\ 
 
-    *Step 2 -- Add order variables.* The target has #lp_ilp.target.instance.num_vars variables and #lp_ilp.target.instance.constraints.len() constraints in total. The order block $bold(o) = (#lp_ilp_sol.target_config.slice(4, 7).map(str).join(", "))$ certifies the increasing path positions $0 < 1 < 2$.\ 
+    *Step 2 -- Add order variables.* The target has #lp_ilp.target.instance.variables.len() variables and #lp_ilp.target.instance.constraints.len() constraints in total. The order block $bold(o) = (#lp_ilp_sol.target_config.slice(4, 7).map(str).join(", "))$ certifies the increasing path positions $0 < 1 < 2$.\
 
-    *Step 3 -- Check the objective.* The target witness $bold(z) = (#lp_ilp_sol.target_config.map(str).join(", "))$ selects lengths $2$ and $3$, so the ILP objective is $5$, matching the source optimum. #sym.checkmark
+    *Step 3 -- Check the objective.* The target witness $bold(z) = (#fmt-values(lp_ilp_sol.target_config))$ selects lengths $2$ and $3$, so the ILP objective is $5$, matching the source optimum. #sym.checkmark
   ],
 )[
   A simple $s$-$t$ path can be represented as one unit of directed flow from $s$ to $t$ on oriented copies of the undirected edges. Integer order variables then force the selected arcs to move strictly forward, which forbids detached directed cycles.
@@ -14059,9 +14001,9 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example TSP -o tsp.json",
-      "pred reduce tsp.json --to " + target-spec(tsp_qubo) + " -o bundle.json",
+      "pred reduce tsp.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate tsp.json --config " + tsp_qubo_sol.source_config.map(str).join(","),
+      "pred evaluate tsp.json --config " + cli-config(tsp_qubo_sol.source_config),
     )
     *Step 1 -- Encode each tour position as a binary variable.* A tour is a permutation of $n$ vertices. Introduce $n^2 = #tsp_qubo.target.instance.num_vars$ binary variables $x_(v,p)$: vertex $v$ is at position $p$.
     $ underbrace(x_(0,0) x_(0,1) x_(0,2), "vertex 0") #h(4pt) underbrace(x_(1,0) x_(1,1) x_(1,2), "vertex 1") #h(4pt) underbrace(x_(2,0) x_(2,1) x_(2,2), "vertex 2") $
@@ -14070,7 +14012,7 @@ The following reductions to Integer Linear Programming are straightforward formu
 
     *Step 3 -- Encode edge costs.* For each edge $(u,v)$ and position $p$, the products $x_(u,p) x_(v,(p+1) mod 3)$ and $x_(v,p) x_(u,(p+1) mod 3)$ add the edge weight $w_(u v)$ when vertices $u,v$ are consecutive in the tour. Since $K_3$ is complete, all pairs are edges with their actual weights.\
 
-    *Step 4 -- Verify a solution.* The QUBO ground state $bold(x) = (#tsp_qubo_sol.target_config.map(str).join(", "))$ encodes a valid tour. Reading the permutation: each 3-bit group has exactly one 1 (valid permutation #sym.checkmark). The tour cost equals $w_(01) + w_(02) + w_(12) = 1 + 2 + 3 = 6$.\
+    *Step 4 -- Verify a solution.* The QUBO ground state $bold(x) = (#fmt-values(tsp_qubo_sol.target_config))$ encodes a valid tour. Reading the permutation: each 3-bit group has exactly one 1 (valid permutation #sym.checkmark). The tour cost equals $w_(01) + w_(02) + w_(12) = 1 + 2 + 3 = 6$.\
 
     *Multiplicity:* The fixture stores one canonical optimal witness. On $K_3$ with distinct edge weights $1, 2, 3$, every Hamiltonian cycle has cost $1 + 2 + 3 = 6$ (all edges used), and 3 cyclic tours $times$ 2 directions yield $6$ permutation matrices overall.
   ],
@@ -14096,13 +14038,13 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example LCS -o lcs.json",
-      "pred reduce lcs.json --to " + target-spec(lcs_mis) + " -o bundle.json",
+      "pred reduce lcs.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate lcs.json --config " + lcs_mis_sol.source_config.map(str).join(","),
+      "pred evaluate lcs.json --config " + cli-config(lcs_mis_sol.source_config),
     )
-    Source LCS: config $(#lcs_mis_sol.source_config.map(str).join(", "))$ \
-    Target MIS: $S = {#lcs_mis_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", ")}$ (size #lcs_mis_sol.target_config.filter(x => x == 1).len()) \
-    MIS size $=$ LCS length $= #lcs_mis_sol.target_config.filter(x => x == 1).len()$ #sym.checkmark
+    Source LCS: config $(#fmt-values(lcs_mis_sol.source_config))$ \
+    Target MIS: $S = {#lcs_mis_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", ")}$ (size #lcs_mis_sol.target_config.filter(x => x).len()) \
+    MIS size $=$ LCS length $= #lcs_mis_sol.target_config.filter(x => x).len()$ #sym.checkmark
   ],
 )[
   A match-node construction transforms a $k$-string LCS instance into a Maximum Independent Set problem on a conflict graph. Each vertex represents a $k$-tuple of positions (one per string) that all share the same character, and edges connect pairs that cannot coexist in any valid common subsequence. The MIS of this graph equals the LCS length.
@@ -14121,21 +14063,21 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let cs_ilp_str = load-example(
   "ClosestString",
   "ILP",
-  target-variant: (variable: "i32"),
+  target-variant: (coefficient: "i64", variable: "i64"),
 )
 #let cs_ilp_str_sol = cs_ilp_str.solutions.at(0)
 #reduction-rule("ClosestString", "ILP",
   example: true,
-  example-target-variant: (variable: "i32"),
+  example-target-variant: (coefficient: "i64", variable: "i64"),
   example-caption: [Binary alphabet, 4 length-3 strings],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(cs_ilp_str.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(cs_ilp_str) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + cs_ilp_str_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(cs_ilp_str_sol.source_config),
     )
-    Source center witness $(#cs_ilp_str_sol.source_config.map(str).join(", "))$, target ILP witness $(#cs_ilp_str_sol.target_config.map(str).join(", "))$.
+    Source center witness $(#fmt-values(cs_ilp_str_sol.source_config))$, target ILP witness $(#fmt-values(cs_ilp_str_sol.target_config))$.
   ],
 )[
   Binary variables select one alphabet symbol at each center position. An auxiliary radius variable upper-bounds the Hamming distance from the chosen center to every input string and is minimized.
@@ -14164,21 +14106,21 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let css_ilp = load-example(
   "ClosestSubstring",
   "ILP",
-  target-variant: (variable: "i32"),
+  target-variant: (coefficient: "i64", variable: "i64"),
 )
 #let css_ilp_sol = css_ilp.solutions.at(0)
 #reduction-rule("ClosestSubstring", "ILP",
   example: true,
-  example-target-variant: (variable: "i32"),
+  example-target-variant: (coefficient: "i64", variable: "i64"),
   example-caption: [Binary alphabet, 3 length-5 strings, length-3 windows],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(css_ilp.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(css_ilp) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + css_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(css_ilp_sol.source_config),
     )
-    Source center+windows witness $(#css_ilp_sol.source_config.map(str).join(", "))$, target ILP witness $(#css_ilp_sol.target_config.map(str).join(", "))$.
+    Source center+windows witness $(#fmt-values(css_ilp_sol.source_config))$, target ILP witness $(#fmt-values(css_ilp_sol.target_config))$.
   ],
 )[
   Integer variables select one alphabet symbol at each center position and one window start per input string. A conditional radius constraint is activated by the window-choice indicator and upper-bounds the Hamming distance between the center and the selected window of each string.
@@ -14261,82 +14203,45 @@ The following reductions to Integer Linear Programming are straightforward formu
 
 #let st_ilp = load-example("SteinerTree", "ILP")
 #let st_ilp_sol = st_ilp.solutions.at(0)
-#let st_edges = st_ilp.source.instance.graph.edges
-#let st_weights = st_ilp.source.instance.edge_weights
-#let st_terminals = st_ilp.source.instance.terminals
-#let st_root = st_terminals.at(0)
-#let st_non_root_terminals = range(1, st_terminals.len()).map(i => st_terminals.at(i))
-#let st_selected_edge_indices = st_ilp_sol.source_config.enumerate().filter(((i, v)) => v == 1).map(((i, _)) => i)
-#let st_selected_edges = st_selected_edge_indices.map(i => st_edges.at(i))
-#let st_cost = st_selected_edge_indices.map(i => st_weights.at(i)).sum()
-
 #reduction-rule("SteinerTree", "ILP",
   example: true,
-  example-caption: [Canonical Steiner tree instance ($n = #st_ilp.source.instance.graph.num_vertices$, $m = #st_edges.len()$, $|T| = #st_terminals.len()$)],
+  example-caption: [Signed-weight exact tree formulation],
   extra: [
     #pred-commands(
       "pred create --example SteinerTree -o steinertree.json",
-      "pred reduce steinertree.json --to " + target-spec(st_ilp) + " -o bundle.json",
+      "pred reduce steinertree.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate steinertree.json --config " + st_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate steinertree.json --config " + cli-config(st_ilp_sol.source_config),
     )
-    *Step 1 -- Choose a root and one commodity per remaining terminal.* The canonical source instance has terminals $T = {#st_terminals.map(t => $v_#t$).join(", ")}$. The reduction fixes the first terminal as root $r = v_#st_root$ and creates one flow commodity for each remaining terminal: $v_#st_non_root_terminals.at(0)$ and $v_#st_non_root_terminals.at(1)$.
-
-    *Step 2 -- Count the variables from the source edge order.* The first #st_edges.len() target variables are the edge selectors $bold(y) = (#st_ilp_sol.target_config.slice(0, st_edges.len()).map(str).join(", "))$, one per source edge in the order #st_edges.enumerate().map(((i, e)) => [$e_#i = (#(e.at(0)), #(e.at(1)))$]).join(", "). The remaining #(st_ilp.target.instance.num_vars - st_edges.len()) variables are directed flow indicators: $2 m (|T| - 1) = 2 times #st_edges.len() times #st_non_root_terminals.len() = #(st_ilp.target.instance.num_vars - st_edges.len())$.
-
-    *Step 3 -- Count the constraints commodity-by-commodity.* Each non-root terminal contributes one flow-conservation equality per vertex and two capacity inequalities per source edge. For this fixture that is $#st_ilp.source.instance.graph.num_vertices times #st_non_root_terminals.len() = #(st_ilp.source.instance.graph.num_vertices * st_non_root_terminals.len())$ equalities plus $#(2 * st_edges.len()) times #st_non_root_terminals.len() = #(2 * st_edges.len() * st_non_root_terminals.len())$ inequalities, totaling #st_ilp.target.instance.constraints.len() constraints.
-
-    *Step 4 -- Read the canonical witness pair.* The source witness selects edges ${#st_selected_edges.map(e => $(v_#(e.at(0)), v_#(e.at(1)))$).join(", ")}$, so $bold(y)$ already encodes the Steiner tree. In the target witness, the commodity for $v_2$ routes along $v_0 arrow v_1 arrow v_2$, while the commodity for $v_4$ routes along $v_0 arrow v_1 arrow v_3 arrow v_4$. Every flow 1-entry therefore sits under a selected edge variable #sym.checkmark
-
-    *Step 5 -- Verify the objective end-to-end.* The selected-edge prefix is $bold(y) = (#st_ilp_sol.target_config.slice(0, st_edges.len()).map(str).join(", "))$, matching the source witness $(#st_ilp_sol.source_config.map(str).join(", "))$. The ILP objective is #st_selected_edge_indices.map(i => $#(st_weights.at(i))$).join($+$) $= #st_cost$, exactly the Steiner tree optimum stored in the fixture.
-
-    *Multiplicity:* The fixture stores one canonical witness. Other optimal Steiner trees could yield different feasible ILP witnesses, but every valid witness still exposes the source solution in the first $m$ variables.
+    *Source.* The canonical instance has five vertices, seven edges, and terminals $T={0,2,4}$.
+    *Target.* Seven edge selectors, five vertex selectors, and four commodities with fourteen directed flow variables each give 68 binary variables and 94 constraints. Every selected vertex receives its own root flow. The edge prefix $(#fmt-values(st_ilp_sol.source_config))$ selects the tree of cost 6; the vertex selectors and flows certify connectivity, while the cardinality equality excludes cycles.
   ],
 )[
-  The rooted multi-commodity flow formulation @wong1984steiner @kochmartin1998steiner introduces one binary selector $y_e$ for each source edge and, for every non-root terminal $t$, one binary flow variable on each directed source edge. Flow conservation sends one unit from the root to each terminal, while the linking inequalities $f^t_(u,v) <= y_e$ ensure that every used flow arc is backed by a selected source edge. The resulting binary ILP has $m + 2 m (k - 1)$ variables and $n (k - 1) + 2 m (k - 1)$ constraints.
+  Terminal-only flow formulations rely on nonnegative costs @goemansmyung1993catalog. To support signed weights and direct extraction of every feasible witness, use a commodity for every selected vertex and explicitly impose the tree cardinality identity.
 ][
-  _Construction._ Given an undirected weighted graph $G = (V, E, w)$ with strictly positive edge weights, terminals $T = {t_0, dots, t_(k-1)}$, and root $r = t_0$, introduce binary edge selectors $y_e in {0,1}$ for every $e in E$. For each non-root terminal $t in T backslash {r}$ and each directed copy of an undirected edge $(u, v) in E$, introduce a binary flow variable $f^t_(u,v) in {0,1}$. The target objective is
-  $ min sum_(e in E) w_e y_e. $
-  For every commodity $t$ and vertex $v$, enforce flow conservation:
-  $ sum_(u : (u, v) in A) f^t_(u,v) - sum_(u : (v, u) in A) f^t_(v,u) = b_(t,v), $
-  where $A$ contains both orientations of every undirected edge, $b_(t,v) = -1$ at the root $v = r$, $b_(t,v) = 1$ at the sink $v = t$, and $b_(t,v) = 0$ otherwise. For every commodity $t$ and undirected edge $e = {u, v}$, add the capacity-linking inequalities
-  $ f^t_(u,v) <= y_e quad "and" quad f^t_(v,u) <= y_e. $
-  Binary flow variables suffice because any Steiner tree yields a unique simple root-to-terminal path for each commodity, so every commodity can be realized as a 0/1 path indicator.
-
-  The ILP is:
-  $
-    min quad & sum_(e in E) w_e y_e \
-    "subject to" quad & sum_(u : (u, v) in A) f^t_(u,v) - sum_(u : (v, u) in A) f^t_(v,u) = b_(t,v) quad forall t in T backslash {r}, v in V \
-    & f^t_(u,v) <= y_e quad forall t in T backslash {r}, e = {u, v} in E \
-    & f^t_(v,u) <= y_e quad forall t in T backslash {r}, e = {u, v} in E \
-    & y_e, f^t_(u,v) in {0, 1}.
-  $
-
-  _Correctness._ ($arrow.r.double$) If $S subset.eq E$ is a Steiner tree, set $y_e = 1$ exactly for $e in S$. For each non-root terminal $t$, the unique path from $r$ to $t$ inside the tree defines a binary flow assignment satisfying the conservation equations, and every used arc lies on a selected edge, so all linking inequalities hold. The ILP objective equals $sum_(e in S) w_e$. ($arrow.l.double$) Any feasible ILP solution with edge selector set $Y = {e in E : y_e = 1}$ supports one unit of flow from $r$ to every non-root terminal, so the selected edges contain a connected subgraph spanning all terminals. Because all edge weights are strictly positive, any cycle in the selected subgraph has positive total cost; the optimizer therefore never includes redundant edges, so the selected subgraph is already a Steiner tree. Therefore an optimal ILP solution induces a minimum-cost Steiner tree.
+  _Construction._ Let $n=|V|$, $m=|E|$, $k=|T|$, and let $r$ be the first terminal. Binary $y_e$ selects edges, binary $z_v$ selects vertices, and binary $f^s_a$ carries a commodity for every $s in V backslash {r}$ on the bidirected source graph. Require $y_e<=z_u,z_v$ for each $e={u,v}$, $z_t=1$ for all terminals, and $sum_e y_e-sum_v z_v=-1$. For each sink $s$, inflow minus outflow equals $z_s$ at $s$, $-z_s$ at $r$, and zero elsewhere, with $f^s_a<=y_e$ for both orientations of edge $e$. Minimize $sum_e w_e y_e$ without changing weights. There are $m+n+2m(n-1)$ variables and $n(n-1)+2m n+k+1$ constraints.
 
-  _Variable mapping._ The first $m$ ILP variables are the source-edge indicators $y_0, dots, y_(m-1)$ in source edge order. For terminal $t_p$ with $p in {1, dots, k-1}$, the next block of $2 m$ variables stores the directed arc indicators $f^(t_p)_(u,v)$ and $f^(t_p)_(v,u)$ for each source edge $(u, v)$.
+  _Correctness._ Any source tree lifts by selecting its incident vertices and routing one unit along the unique root path to each selected sink; unselected sinks use zero flows. Conversely, a selected vertex outside the root component contradicts flow conservation summed over its component: all crossing flows vanish, but net demand is one. Thus all selected vertices are connected. Endpoint linking and the equality $|E'|=|V'|-1$ imply that the selected graph is a tree spanning all terminals. Both directions preserve the exact edge cost for positive, zero and negative weights; no optimality-based pruning is used.
 
-  _Solution extraction._ Read the first $m$ target variables as the source edge-selection vector. Since those coordinates are exactly the $y_e$ variables, the extracted source configuration is valid whenever the selected subgraph is pruned to its Steiner tree witness.
-
-  _Remark._ Zero-weight edges are excluded because they allow degenerate optimal ILP solutions containing redundant cycles at no cost; following the convention of practical solvers (e.g., SCIP-Jack @kochmartin1998steiner), such edges should be contracted before applying the reduction.
+  _Extraction and numeric domain._ Validate the full target assignment and reject infeasibility, then return its first $m$ edge-selector coordinates. Source `Min<i64>` and target `Extremum<i64>` with minimization sense use identical objective sums. Checked counts precede allocation; structural coefficients are only $-1,0,1$. Existing typed objective-overflow checks remain in force. The endpoints and source tree definition are unchanged.
 ]
 
 #let mvc_hs = load-example("MinimumVertexCover", "MinimumHittingSet")
 #let mvc_hs_sol = mvc_hs.solutions.at(0)
-#let mvc_hs_cover = mvc_hs_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
-#let mvc_hs_hit = mvc_hs_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let mvc_hs_cover = mvc_hs_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
+#let mvc_hs_hit = mvc_hs_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #reduction-rule("MinimumVertexCover", "MinimumHittingSet",
   example: true,
   example-caption: [Unit-weight VC to Hitting Set ($n = #graph-num-vertices(mvc_hs.source.instance)$, $|E| = #graph-num-edges(mvc_hs.source.instance)$)],
   extra: [
     #pred-commands(
       "pred create --example 'MVC {weight: One}' -o mvc.json",
-      "pred reduce mvc.json --to " + target-spec(mvc_hs) + " -o bundle.json",
+      "pred reduce mvc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate mvc.json --config " + mvc_hs_sol.source_config.map(str).join(","),
+      "pred evaluate mvc.json --config " + cli-config(mvc_hs_sol.source_config),
     )
-    Source VC: $C = {#mvc_hs_cover.map(str).join(", ")}$ (size #mvc_hs_cover.len()) #h(1em)
-    Target HS: $H = {#mvc_hs_hit.map(str).join(", ")}$ (size #mvc_hs_hit.len()) \
+    Source VC: $C = {#fmt-values(mvc_hs_cover)}$ (size #mvc_hs_cover.len()) #h(1em)
+    Target HS: $H = {#fmt-values(mvc_hs_hit)}$ (size #mvc_hs_hit.len()) \
     The hitting set $H$ is identical to the vertex cover $C$ because the universe elements are the vertices and the subsets are the edges.
   ],
 )[
@@ -14426,21 +14331,21 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(mono_ilp.source) + " -o monochromatic-triangle.json",
-      "pred reduce monochromatic-triangle.json --to " + target-spec(mono_ilp) + " -o bundle.json",
+      "pred reduce monochromatic-triangle.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate monochromatic-triangle.json --config " + mono_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate monochromatic-triangle.json --config " + cli-config(mono_ilp_sol.source_config),
     )
 
     *Step 1 -- Source instance.* The canonical Monochromatic Triangle fixture is $K_4$ on vertices $0, 1, 2, 3$ with edges #{mono_ilp.source.instance.graph.edges.map(((u, v)) => [${#u, #v}$]).join(", ")}. It has $#mono_ilp.source.instance.triangles.len()$ triangles, so the reduction creates one pair of inequalities for each of those four triangles.
 
-    *Step 2 -- Build the ILP.* Introduce one binary variable per edge, so the target has $m = #mono_ilp.target.instance.num_vars$ variables. For each triangle, add the lower bound $x_a + x_b + x_c >= 1$ and the upper bound $x_a + x_b + x_c <= 2$, giving $#mono_ilp.target.instance.constraints.len()$ total constraints.
+    *Step 2 -- Build the ILP.* Introduce one binary variable per edge, so the target has $m = #mono_ilp.target.instance.variables.len()$ variables. For each triangle, add the lower bound $x_a + x_b + x_c >= 1$ and the upper bound $x_a + x_b + x_c <= 2$, giving $#mono_ilp.target.instance.constraints.len()$ total constraints.
 
-    *Step 3 -- Verify a witness.* The stored ILP witness is $(#mono_ilp_sol.target_config.map(str).join(", "))$. Because extraction is identity, it immediately yields the edge coloring $(#mono_ilp_sol.source_config.map(str).join(", "))$, and evaluating that coloring on the source returns `true` #sym.checkmark. Every triangle therefore uses both colors.
+    *Step 3 -- Verify a witness.* The stored ILP witness is $(#fmt-values(mono_ilp_sol.target_config))$. Because extraction is identity, it immediately yields the edge coloring $(#fmt-values(mono_ilp_sol.source_config))$, and evaluating that coloring on the source returns `true` #sym.checkmark. Every triangle therefore uses both colors.
 
     *Multiplicity:* The fixture stores one canonical edge coloring. Any binary ILP solution satisfying all triangle pairs is a valid Monochromatic Triangle witness.
   ],
 )[
-  This $O(m + t)$ reduction uses one binary variable per edge and two linear inequalities per triangle, where $m = |E|$ and $t$ is the number of triangles in the source graph. The target ILP is a pure feasibility problem with $m$ variables and $2t$ constraints.
+  Use one binary variable per edge, two inequalities per triangle, and valid degree equalities in every five-vertex clique. The latter strengthen the linear relaxation without changing the set of feasible edge colourings. If $m=|E|$, $t$ is the triangle count and $h$ is the number of five-vertex cliques, the target has $m$ variables and at most $2t+15h$ constraints. Since $15h <= |V|^5/8$, enumeration and target size remain polynomial.
 ][
   _Construction._ Let the source graph edges be indexed as $e_0, dots, e_(m-1)$. Introduce binary variables $x_0, dots, x_(m-1)$, where $x_i = 0$ or $1$ is the color assigned to edge $e_i$. For every triangle $T = {e_a, e_b, e_c}$ in the source graph, add the pair of inequalities
   $
@@ -14448,7 +14353,9 @@ The following reductions to Integer Linear Programming are straightforward formu
     quad "and" quad
     x_a + x_b + x_c <= 2.
   $
-  The objective is empty, so the ILP asks only for feasibility.
+  For each five-vertex clique $C$ and every $v in C$, also impose $sum_(u in C backslash {v}) x_({u,v}) = 2$. For each triangle, enumerate edges between its common neighbours; each such edge completes a $K_5$. Any two edges opposite the same triangle must also have equal colours, so add equality constraints linking them to the first such edge. Add the degree equalities once per clique, when the base triangle consists of its three smallest vertices. The objective is empty, so the ILP asks only for feasibility.
+
+  _Validity of the added equalities._ In any colouring of $K_5$ without monochromatic triangles, a vertex cannot have three neighbours joined to it by the same colour: all three edges between those neighbours would have to use the opposite colour, producing a monochromatic triangle. Every vertex has degree four inside the clique, so it has exactly two edges of each colour. Thus every valid source colouring satisfies the degree equalities. For a fixed colour, write $r$ for its edge count inside a triangle of the clique and $t'$ for the colour of the complementary edge. The same degree count gives $5=r+(6-2r)+t'$, so $t'=r-1$: every edge opposite the same triangle has the same colour. Hence all added equalities apply to any input graph, independently of its origin, and exclude no legal colouring. If $k_T$ cliques contain triangle $T$, at most $k_T$ linking equalities are added there; $sum_T k_T=10h$. Together with $5h$ degree equalities this gives the stated constraint bound. These explicit linking rows let ILP presolve eliminate colour copies.
 
   _Correctness._ ($arrow.r.double$) Any triangle-free 2-edge-coloring assigns each triangle at least one edge of color 0 and at least one edge of color 1, so the corresponding sum is either $1$ or $2$ and both inequalities hold. ($arrow.l.double$) Any feasible ILP assignment gives a 0/1 color to every edge, and the triangle bounds forbid sums $0$ and $3$, so no triangle is monochromatic.
 
@@ -14463,9 +14370,9 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ss_bt.source) + " -o set-splitting.json",
-      "pred reduce set-splitting.json --to " + target-spec(ss_bt) + " -o bundle.json",
+      "pred reduce set-splitting.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate set-splitting.json --config " + ss_bt_sol.source_config.map(str).join(","),
+      "pred evaluate set-splitting.json --config " + cli-config(ss_bt_sol.source_config),
     )
 
     #{
@@ -14475,13 +14382,13 @@ The following reductions to Integer Linear Programming are straightforward formu
       let target_config = ss_bt_sol.target_config
       let pole = source.universe_size
       [
-        *Step 1 -- Source instance.* The canonical Set Splitting fixture has universe $U = {0, 1, 2, 3, 4}$ and subsets $S_1 = {#source.subsets.at(0).map(str).join(", ")}$, $S_2 = {#source.subsets.at(1).map(str).join(", ")}$, $S_3 = {#source.subsets.at(2).map(str).join(", ")}$, and $S_4 = {#source.subsets.at(3).map(str).join(", ")}$. The stored splitting is $(#source_config.map(str).join(", "))$, so colors 0 and 1 both appear in every subset.
+        *Step 1 -- Source instance.* The canonical Set Splitting fixture has universe $U = {0, 1, 2, 3, 4}$ and subsets $S_1 = {#source.subsets.at(0).map(str).join(", ")}$, $S_2 = {#source.subsets.at(1).map(str).join(", ")}$, $S_3 = {#source.subsets.at(2).map(str).join(", ")}$, and $S_4 = {#source.subsets.at(3).map(str).join(", ")}$. The stored splitting is $(#fmt-values(source_config))$, so colors 0 and 1 both appear in every subset.
 
         *Step 2 -- Add the pole and clause auxiliaries.* Because every subset already has size 3, normalization adds no universe elements. The target therefore uses pole $p = a_#pole$ together with one auxiliary element for each subset, namely $d_1 = 6$, $d_2 = 7$, $d_3 = 8$, and $d_4 = 9$, for a total of $#target.num_elements$ elements.
 
         *Step 3 -- Form the betweenness triples.* The four subsets become the triple pairs $(#target.triples.at(0).map(str).join(", "))$, $(#target.triples.at(1).map(str).join(", "))$; $(#target.triples.at(2).map(str).join(", "))$, $(#target.triples.at(3).map(str).join(", "))$; $(#target.triples.at(4).map(str).join(", "))$, $(#target.triples.at(5).map(str).join(", "))$; and $(#target.triples.at(6).map(str).join(", "))$, $(#target.triples.at(7).map(str).join(", "))$. Each pair uses one auxiliary $d_j$ to force the corresponding 3-set to place at least one element on each side of the pole.
 
-        *Step 4 -- Verify the ordering and extraction.* The stored Betweenness witness is $f = (#target_config.map(str).join(", "))$, so the pole $p = 5$ sits at position $f(p) = #target_config.at(pole)$. Original elements $1, 3, 4$ lie to the left of the pole, while $0, 2$ lie to the right, so extraction returns $(#source_config.map(str).join(", "))$ exactly. For example, $(0, 6, 1)$ holds because $f(1) = #target_config.at(1) < f(6) = #target_config.at(6) < f(0) = #target_config.at(0)$, and $(6, 5, 2)$ holds because $f(6) = #target_config.at(6) < f(5) = #target_config.at(5) < f(2) = #target_config.at(2)$ #sym.checkmark.
+        *Step 4 -- Verify the ordering and extraction.* The stored Betweenness witness is $f = (#fmt-values(target_config))$, so the pole $p = 5$ sits at position $f(p) = #target_config.at(pole)$. Original elements $1, 3, 4$ lie to the left of the pole, while $0, 2$ lie to the right, so extraction returns $(#fmt-values(source_config))$ exactly. For example, $(0, 6, 1)$ holds because $f(1) = #target_config.at(1) < f(6) = #target_config.at(6) < f(0) = #target_config.at(0)$, and $(6, 5, 2)$ holds because $f(6) = #target_config.at(6) < f(5) = #target_config.at(5) < f(2) = #target_config.at(2)$ #sym.checkmark.
 
         *Multiplicity:* The fixture stores one canonical witness.
       ]
@@ -14538,9 +14445,9 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(kc_bcbs.source) + " -o kclique.json",
-      "pred reduce kclique.json --to " + target-spec(kc_bcbs) + " -o bundle.json",
+      "pred reduce kclique.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate kclique.json --config " + kc_bcbs_sol.source_config.map(str).join(","),
+      "pred evaluate kclique.json --config " + cli-config(kc_bcbs_sol.source_config),
     )
 
     *Step 1 -- Pad the vertex set.* $C(#k, 2) = #ck2$ padding vertices are added, giving $n' = #n + #ck2 = #n_prime$ left vertices (Part $A$).
@@ -14551,7 +14458,7 @@ The following reductions to Integer Linear Programming are straightforward formu
 
     *Step 4 -- Set target parameter.* $K' = n' - k = #n_prime - #k = #target_k$.
 
-    *Step 5 -- Verify a solution.* The #k\-clique is $S = {#kc_bcbs_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, _)) => str(i)).join(", ")}$. The #target_k left vertices NOT in $S$ plus the #ck2 padding vertices form the left side $A'$. The right side $B'$ contains the #ck2 intra-clique edge elements plus #{n - k} padding elements ($|B'| = #target_k$). All $#target_k times #target_k$ cross-edges are present because no $v in A'$ is an endpoint of any selected edge element.
+    *Step 5 -- Verify a solution.* The #k\-clique is $S = {#kc_bcbs_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, _)) => str(i)).join(", ")}$. The #target_k left vertices NOT in $S$ plus the #ck2 padding vertices form the left side $A'$. The right side $B'$ contains the #ck2 intra-clique edge elements plus #{n - k} padding elements ($|B'| = #target_k$). All $#target_k times #target_k$ cross-edges are present because no $v in A'$ is an endpoint of any selected edge element.
 
     *Multiplicity:* The fixture stores one canonical witness.
   ],
@@ -14598,14 +14505,14 @@ The following reductions to Integer Linear Programming are straightforward formu
       let m-target = mmm_ach.target.instance.graph.edges.len()
       let color-of = mmm_ach_sol.target_config
       let matched = mmm_ach_sol.source_config.enumerate()
-        .filter(((i, x)) => x == 1)
+        .filter(((i, x)) => x)
         .map(((i, _)) => i)
       [
         #pred-commands(
           "pred create --example " + problem-spec(mmm_ach.source) + " -o mmm.json",
-          "pred reduce mmm.json --to " + target-spec(mmm_ach) + " -o bundle.json",
+          "pred reduce mmm.json --via route.json -o bundle.json",
           "pred solve bundle.json",
-          "pred evaluate mmm.json --config " + mmm_ach_sol.source_config.map(str).join(","),
+          "pred evaluate mmm.json --config " + cli-config(mmm_ach_sol.source_config),
         )
 
         *Step 1 -- Source instance.* The T-tree on $5$ vertices is the spider graph with centre $v_1$ and legs to $v_0$, $v_2$, $v_4$, plus the pendant edge $v_2 - v_3$. It is bipartite with $A = {v_0, v_2, v_4}$ and $B = {v_1, v_3}$. In unified indices the vertex set is ${0, 1, 2, 3, 4}$ (left vertices first, mapping $v_0 mapsto 0$, $v_2 mapsto 1$, $v_4 mapsto 2$, $v_1 mapsto 3$, $v_3 mapsto 4$), so $n = #n-source$ and the $m = #m-source$ edges are #source-edges.map(e => $(#e.at(0), #e.at(1))$).join(", ").
@@ -14614,7 +14521,7 @@ The following reductions to Integer Linear Programming are straightforward formu
 
         *Step 3 -- Source optimum.* The minimum maximal matching uses the central edge $(v_1, v_2)$, so $"mm"(G) = #matched.len() = 1$ (source index $#matched.at(0)$). The T-tree also admits two strictly larger maximal matchings $\{(v_0, v_1), (v_2, v_3)\}$ and $\{(v_1, v_4), (v_2, v_3)\}$, both of size $2$ -- this richness is the reason for choosing the T-tree over the path $P_4$ as the canonical example.
 
-        *Step 4 -- Target optimum.* The achromatic coloring stored in the fixture is $#color-of.map(str).join(", ")$. The size-$2$ color class corresponds to the source edge selected in Step 3, and the singletons contribute the remaining $n - 2$ classes, so the achromatic number is $psi(H) = n - "mm"(G) = #n-source - 1 = #(n-source - 1) #sym.checkmark$.
+        *Step 4 -- Target optimum.* The achromatic coloring stored in the fixture is $#fmt-values(color-of)$. The size-$2$ color class corresponds to the source edge selected in Step 3, and the singletons contribute the remaining $n - 2$ classes, so the achromatic number is $psi(H) = n - "mm"(G) = #n-source - 1 = #(n-source - 1) #sym.checkmark$.
 
         *Multiplicity:* The fixture stores one canonical witness; other valid achromatic $4$-colorings exist and would extract to the same minimum maximal matching after relabelling colors.
       ]
@@ -14656,17 +14563,17 @@ The following reductions to Integer Linear Programming are straightforward formu
       let s-cfg = mmm_mmd_sol.source_config
       let t-cfg = mmm_mmd_sol.target_config
       let matched-source = s-cfg.enumerate()
-        .filter(((i, x)) => x == 1)
+        .filter(((i, x)) => x)
         .map(((i, _)) => i)
       let selected-target = t-cfg.enumerate()
-        .filter(((i, x)) => x == 1)
+        .filter(((i, x)) => x)
         .map(((i, _)) => i)
       [
         #pred-commands(
           "pred create --example " + problem-spec(mmm_mmd.source) + " -o mmm.json",
-          "pred reduce mmm.json --to " + target-spec(mmm_mmd) + " -o bundle.json",
+          "pred reduce mmm.json --via route.json -o bundle.json",
           "pred solve bundle.json",
-          "pred evaluate mmm.json --config " + s-cfg.map(str).join(","),
+          "pred evaluate mmm.json --config " + cli-config(s-cfg),
         )
 
         *Step 1 -- Source instance.* Bipartite graph $B$ with $|L| = #m-left$, $|R| = #n-right$ and $#local-edges.len()$ bipartite-local edges #local-edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The decision threshold is $K = 2$.
@@ -14807,11 +14714,12 @@ The following reductions to Integer Linear Programming are straightforward formu
   $
     "minimize" quad & sum_v s_v x_v + sum_(v,u) "usage"_v d(v, u) y_(v,u) \
     "subject to" quad & sum_u y_(v,u) = 1 quad forall v \
-    & y_(v,u) <= x_u quad forall v, u \
+    & y_(v,u) <= x_u quad forall v, u " with " d(v,u) < infinity \
+    & y_(v,u) = 0 quad forall v, u " with " d(v,u) = infinity \
     & x_v, y_(v,u) in {0, 1}.
   $
 
-  _Correctness._ Assignment constraints ensure each vertex is served by exactly one copy; capacity links prevent assignment to non-copy vertices; the objective linearizes the total cost.
+  _Correctness._ Assignment constraints ensure each vertex is served by exactly one reachable copy; unreachable pairs are explicitly forbidden, as required by the shortest-path distance in the problem definition @garey1979. Capacity links prevent assignment to non-copy vertices, and the objective linearizes the total cost.
 
   _Solution extraction._ Copy placement: ${v : x_v = 1}$.
 ]
@@ -14946,12 +14854,12 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example PartitionIntoPathsOfLength2 -o ppl2.json",
-      "pred reduce ppl2.json --to " + target-spec(ppl2_bcsf) + " -o bundle.json",
+      "pred reduce ppl2.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ppl2.json --config " + ppl2_bcsf_sol.source_config.map(str).join(","),
+      "pred evaluate ppl2.json --config " + cli-config(ppl2_bcsf_sol.source_config),
     )
-    Source PPL2: groups $= {#ppl2_bcsf_sol.source_config.map(str).join(", ")}$ on a graph with $n = #graph-num-vertices(ppl2_bcsf.source.instance)$ vertices and $|E| = #graph-num-edges(ppl2_bcsf.source.instance)$ edges \
-    Target BCSF: components $= {#ppl2_bcsf_sol.target_config.map(str).join(", ")}$, $K = #ppl2_bcsf.target.instance.max_components$, $B = #ppl2_bcsf.target.instance.max_weight$ \
+    Source PPL2: groups $= {#fmt-values(ppl2_bcsf_sol.source_config)}$ on a graph with $n = #graph-num-vertices(ppl2_bcsf.source.instance)$ vertices and $|E| = #graph-num-edges(ppl2_bcsf.source.instance)$ edges \
+    Target BCSF: components $= {#fmt-values(ppl2_bcsf_sol.target_config)}$, $K = #ppl2_bcsf.target.instance.max_components$, $B = #ppl2_bcsf.target.instance.max_weight$ \
     Identity mapping: source and target configs coincide #sym.checkmark
   ],
 )[
@@ -15015,7 +14923,7 @@ The following reductions to Integer Linear Programming are straightforward formu
     & x_(j,t) in {0, 1}.
   $
 
-  _Correctness._ Per-task deadline is enforced by restricting the time domain of each task's indicator variables.
+  _Correctness._ Per-task deadline is enforced by restricting the time domain of each task's indicator variables. The implementation allocates a common horizon $max_j d_j$ and adds one zero-sum equality fixing all indicators outside individual deadlines to zero.
 
   _Solution extraction._ Task $j$ is scheduled at time $arg max_t x_(j,t)$.
 ]
@@ -15049,7 +14957,7 @@ The following reductions to Integer Linear Programming are straightforward formu
     & x_(j,t) in {0, 1}.
   $
 
-  _Correctness._ One-hot ensures each task starts once within its feasible window; non-overlap prevents simultaneous execution.
+  _Correctness._ One-hot ensures each task starts once within its feasible window; non-overlap prevents simultaneous execution. If a task has no feasible start time, its one-hot constraint is $0 = 1$, making the ILP infeasible.
 
   _Solution extraction._ Task $j$ starts at time $arg max_t x_(j,t)$; config$[j] = t - r_j$.
 ]
@@ -15083,7 +14991,9 @@ The following reductions to Integer Linear Programming are straightforward formu
     & d^k_e in {0, 1}, f^k_(u,v) in ZZ_(>=0).
   $
 
-  _Correctness._ Direction indicators linearize the capacity-sharing constraint; flow conservation and demand constraints ensure valid multi-commodity flow.
+  Here $b^k_v = 0$ at every vertex other than commodity $k$'s own source and sink; the sink receives at least its requirement and the source supplies that flow.
+
+  _Correctness._ Direction indicators linearize the capacity-sharing constraint. Per-commodity conservation prevents flow from being created or destroyed at another commodity's terminals, as required by the standard multicommodity-flow formulation @garey1979.
 
   _Solution extraction._ Flow variables (first $4|E|$ variables).
 ]
@@ -15179,45 +15089,48 @@ The following reductions to Integer Linear Programming are straightforward formu
 ]
 
 #reduction-rule("DisjointConnectingPaths", "ILP")[
-  Route one unit of flow for each terminal pair on an oriented copy of the graph, and forbid internal vertices from carrying more than one commodity.
+  Use a binary multicommodity flow with one commodity per terminal pair and unit capacity on every vertex. The construction has $2 k |E|$ variables and $k |V| + |V|$ constraints.
 ][
-  _Construction._ For terminal pairs $(s_k, t_k)$, variables: binary $f^k_(u,v)$ on each orientation of each edge and integer order variables $h^k_v$. The ILP is:
+  _Construction._ Let $A$ contain both orientations of every edge, and let $S = {s_1, dots, s_k}$. For each pair $(s_i,t_i)$ and arc $(u,v) in A$, introduce a binary variable $f^i_(u,v)$. Write $delta^+(v)$ and $delta^-(v)$ for the arcs leaving and entering $v$. Add
   $
-    "find" quad & bold(x) \
-    "subject to" quad & sum_(w) f^k_(s_k,w) - sum_(u) f^k_(u,s_k) = 1 quad forall k \
-    & sum_(u) f^k_(u,t_k) - sum_(w) f^k_(t_k,w) = 1 quad forall k \
-    & sum_(w) f^k_(v,w) - sum_(u) f^k_(u,v) = 0 quad forall k, v in V backslash {s_k, t_k} \
-    & f^k_(u,v) + f^k_(v,u) <= 1 quad forall {u, v} in E, k \
-    & sum_k sum_(w in N(v)) f^k_(v,w) <= 1 quad forall "non-terminal" v \
-    & h^k_v >= h^k_u + 1 - M (1 - f^k_(u,v)) quad forall k, u -> v \
-    & f^k_(u,v) in {0, 1}, h^k_v in ZZ_(>=0).
+    sum_(a in delta^+(v)) f^i_a - sum_(a in delta^-(v)) f^i_a
+    = cases(1 & "if " v=s_i, -1 & "if " v=t_i, 0 & "otherwise")
+    quad forall i,v,
+  $
+  and the vertex-capacity constraints
+  $
+    sum_i sum_(a in delta^-(v)) f^i_a + bb(1)[v in S] <= 1
+    quad forall v in V.
   $
+  The source model requires all $2k$ terminal vertices to be pairwise distinct.
 
-  _Correctness._ ($arrow.r.double$) A family of pairwise internally vertex-disjoint connecting paths orients each path from its source to its sink and satisfies all constraints. ($arrow.l.double$) The conservation, disjointness, and ordering constraints force each commodity to trace one simple path, and different commodities can intersect only at terminals.
+  _Correctness._ ($arrow.r.double$) Given pairwise vertex-disjoint paths, orient path $i$ from $s_i$ to $t_i$ and set precisely its arc variables to one. Flow conservation holds. Every non-source path vertex has one incoming arc, each source contributes its indicator term, and disjointness therefore gives every vertex load at most one.
 
-  _Solution extraction._ Mark an edge selected in the source config iff some orientation of that edge carries flow for some commodity.
+  ($arrow.l.double$) Consider a feasible binary flow. At $s_i$, the capacity constraint permits no incoming arc, so conservation gives exactly one outgoing arc. At every reached nonterminal vertex, the single incoming arc and conservation give exactly one outgoing arc. The walk cannot revisit a vertex, because the first entry and the later entry would violate its unit incoming capacity; since the graph is finite, it reaches $t_i$. The same capacity constraints prevent paths of different commodities from sharing any vertex. Positive-flow components not reached from a source are circulations disjoint from these paths and do not affect the extracted witness.
+
+  _Solution extraction._ For every commodity, search its positive-flow arcs from $s_i$ to $t_i$ and mark only the undirected edges on that path. Discard disconnected circulations. The union of the extracted paths is the source edge-selection vector.
 ]
 
+
 #reduction-rule("LengthBoundedDisjointPaths", "ILP")[
-  Use one unit-flow commodity for each requested path and add hop variables so every chosen path has at most the source bound $K$ edges.
+  Maximize the number of active unit-flow commodities, each using at most $K$ edges, with shared internal-vertex capacities.
 ][
-  _Construction._ Variables: binary $f^k_(u,v)$ on each orientation of each edge for each path slot $k$, plus integer hop variables $h^k_v in {0, dots, K}$, where $K$ is the path-length bound and $M = K + 1$. The ILP is:
+  _Construction._ Let $A$ contain both orientations of every edge. Use binary $f^k_(u,v)$ for each arc and path slot $k$, together with binary activation variables $a_k$. The ILP is:
   $
-    "find" quad & bold(x) \
-    "subject to" quad & sum_(w) f^k_(s,w) - sum_(u) f^k_(u,s) = 1 quad forall k \
-    & sum_(u) f^k_(u,t) - sum_(w) f^k_(t,w) = 1 quad forall k \
+    max quad & sum_k a_k \
+    "subject to" quad & sum_(w) f^k_(s,w) - sum_(u) f^k_(u,s) = a_k quad forall k \
+    & sum_(u) f^k_(u,t) - sum_(w) f^k_(t,w) = a_k quad forall k \
     & sum_(w) f^k_(v,w) - sum_(u) f^k_(u,v) = 0 quad forall k, v in V backslash {s, t} \
     & f^k_(u,v) + f^k_(v,u) <= 1 quad forall {u, v} in E, k \
+    & sum_k (f^k_(u,v) + f^k_(v,u)) <= 1 quad forall {u, v} in E \
     & sum_k sum_(w in N(v)) f^k_(v,w) <= 1 quad forall v in V backslash {s, t} \
-    & h^k_s = 0 quad forall k \
-    & h^k_v >= h^k_u + 1 - M (1 - f^k_(u,v)) quad forall k, u -> v \
-    & h^k_t <= K quad forall k \
-    & f^k_(u,v) in {0, 1}, h^k_v in {0, dots, K}.
+    & sum_((u,v) in A) f^k_(u,v) <= K a_k quad forall k \
+    & f^k_(u,v), a_k in {0, 1}.
   $
 
-  _Correctness._ ($arrow.r.double$) A collection of $J$ internally disjoint $s$-$t$ paths of length at most $K$ yields feasible commodity flows and consistent hop labels. ($arrow.l.double$) The flow and hop constraints force each commodity to be a simple $s$-$t$ path, while the vertex-disjointness inequalities match the source requirement.
+  _Correctness._ ($arrow.r.double$) Orient each source path from $s$ to $t$ and activate its slot. The resulting flows satisfy all constraints and have objective equal to the number of paths. ($arrow.l.double$) Each active commodity has a unit net flow from $s$ to $t$, so its positive-flow arcs contain a simple $s$-$t$ path. Extracting one such path discards any extra circulation and cannot increase its length beyond $K$. Shared internal-vertex capacities prevent different extracted paths from sharing internal vertices, and edge capacities prevent repeated use of the direct $s$-$t$ edge. Inactive slots have zero flow. Thus extraction preserves the number of active paths and the objective value.
 
-  _Solution extraction._ For each path slot $k$, set the source vertex-indicator block to 1 exactly on the vertices incident to the commodity-$k$ path, including $s$ and $t$.
+  _Solution extraction._ For each active slot, run breadth-first search on its positive-flow arcs and mark the edges of the resulting simple $s$-$t$ path in the source graph's edge order. Return an all-zero edge-selection row for each inactive slot.
 ]
 
 #reduction-rule("MixedChinesePostman", "ILP")[
@@ -15226,7 +15139,7 @@ The following reductions to Integer Linear Programming are straightforward formu
   _Construction._ Let $n = |V|$, let the original directed arcs be $A = {a_0, dots, a_(m-1)}$ with $a_i = (alpha_i, beta_i)$, and let the undirected edges be $E = {e_0, dots, e_(q-1)}$ with $e_k = {u_k, v_k}$. Set $R = m + q$. If $R = 0$, return the empty feasible ILP: the empty walk already has length 0. Otherwise form the available directed-arc list
   $A^* = {b_0, dots, b_(L-1)}$ with $L = m + 2 q$,
   where $b_i = a_i$ for $0 <= i < m$, $b_(m + 2 k) = (u_k, v_k)$, and $b_(m + 2 k + 1) = (v_k, u_k)$.
-  Write $b_j = ("tail"_j, "head"_j)$ and let $ell_j$ be the corresponding length. Use `ILP<i32>` with binary variables encoded by bounds $0 <= x <= 1$. Order the variables as
+  Write $b_j = ("tail"_j, "head"_j)$ and let $ell_j$ be the corresponding length. Use `ILP<i64>` with binary variables encoded by bounds $0 <= x <= 1$. Order the variables as
   $(d_0, dots, d_(q-1), g_0, dots, g_(L-1), y_0, dots, y_(L-1), z_0, dots, z_(n-1), rho_0, dots, rho_(n-1), s, b_0, dots, b_(n-1), f_0, dots, f_(L-1), h_0, dots, h_(L-1))$,
   so $d_k$ has index $k$, $g_j$ has index $q + j$, $y_j$ has index $q + L + j$, $z_v$ has index $q + 2 L + v$, $rho_v$ has index $q + 2 L + n + v$, $s$ has index $q + 2 L + 2 n$, $b_v$ has index $q + 2 L + 2 n + 1 + v$, $f_j$ has index $q + 2 L + 3 n + 1 + j$, and $h_j$ has index $q + 3 L + 3 n + 1 + j$. There are $q + 4 L + 3 n + 1$ variables in total.
 
@@ -15296,44 +15209,28 @@ The following reductions to Integer Linear Programming are straightforward formu
 ]
 
 #reduction-rule("StackerCrane", "ILP")[
-  Encode the required-arc order by a one-hot position assignment and charge the shortest connector distance between each consecutive pair of required arcs.
+  Encode the required-arc order by a one-hot position assignment and minimize the shortest connector distances between consecutive required arcs.
 ][
-  _Construction._ Let the required arcs be $A = {a_0, dots, a_(m-1)}$ with $a_i = ("tail"_i, "head"_i)$. Build the mixed connector graph
-  $H = (V, A union {(u, v), (v, u) : {u, v} in E})$,
-  where the original required arcs keep their given lengths and each undirected edge contributes both orientations with the same length. Because all lengths are nonnegative, compute the all-pairs connector distances
-  $D[u, v] = "dist"_H(u, v)$
-  either by running Dijkstra from every source vertex or by Floyd--Warshall on the $n$-vertex graph $H$; this is exactly the graph queried by `mixed_graph_adjacency()` and `shortest_path_length()` in the model. If $D[u, v] = oo$, the pair is impossible and will be forbidden explicitly.
+  _Construction._ Let $a_i = ("tail"_i, "head"_i)$ for $0 <= i < m$ be the required arcs, with lengths $ell_i >= 0$. In the mixed graph, retain every directed required arc and replace every undirected edge by both orientations of the same length. Compute shortest-path distances $D[u,v]$ in this graph; an unreachable pair has distance $oo$.
 
-  Use `ILP<bool>`. The binary position variables are $x_(i,p)$ for $i, p in {0, dots, m - 1}$, with index
-  $"idx"_x(i, p) = i m + p$.
-  The binary McCormick variables are $z_(i,j,p)$ for $i, j, p in {0, dots, m - 1}$, where position $p + 1$ is interpreted cyclically as $(p + 1) mod m$; their indices are
-  $"idx"_z(i, j, p) = m^2 + p m^2 + i m + j$.
-  There are $m^2 + m^3$ binary variables.
+  Introduce binary variables $x_(i,p)$ indicating that arc $i$ occupies position $p$, and $z_(i,j,p)$ indicating consecutive arcs $i,j$ at positions $p,p+1$. Positions are cyclic modulo $m$. Enforce
+  $ sum_p x_(i,p) = 1 quad forall i, quad sum_i x_(i,p) = 1 quad forall p, $
+  and, for *every* triple $(i,j,p)$, impose all three product constraints
+  $ z_(i,j,p) <= x_(i,p), quad z_(i,j,p) <= x_(j,(p+1) mod m), $
+  $ z_(i,j,p) >= x_(i,p) + x_(j,(p+1) mod m) - 1. $
+  Additionally impose $z_(i,j,p) = 0$ whenever $D["head"_i,"tail"_j] = oo$. This additional constraint does not replace the product constraints: together they forbid the unreachable adjacency.
 
-  The constraints are:
-  $sum_(p = 0)^(m - 1) x_(i,p) = 1$ for each required arc $i$;
-  $sum_(i = 0)^(m - 1) x_(i,p) = 1$ for each position $p$;
-  $z_(i,j,p) <= x_(i,p)$, $z_(i,j,p) <= x_(j,(p + 1) mod m)$, and $z_(i,j,p) >= x_(i,p) + x_(j,(p + 1) mod m) - 1$ for all $i, j, p$;
-  if $D["head"_i, "tail"_j] = oo$, then either set $z_(i,j,p) = 0$ for all $p$ or, equivalently, impose $x_(i,p) + x_(j,(p + 1) mod m) <= 1$ for all $p$;
-  and finally
-  $sum_(i = 0)^(m - 1) ell_i + sum_(p = 0)^(m - 1) sum_(i = 0)^(m - 1) sum_(j = 0)^(m - 1) D["head"_i, "tail"_j] z_(i,j,p) <= B$.
-  The first term is the total length of the required traversals, and the second term charges exactly one connector distance for each consecutive pair in the cyclic order.
+  Minimize
+  $ sum_p sum_(i,j: D["head"_i,"tail"_j] < oo) D["head"_i,"tail"_j] z_(i,j,p). $
+  The sum of required arc lengths $L = sum_i ell_i$ is constant and is omitted from the ILP objective. No decision threshold is introduced.
 
-  The ILP is:
-  $
-    "find" quad & bold(x) \
-    "subject to" quad & sum_(p = 0)^(m - 1) x_(i,p) = 1 quad forall i in {0, dots, m - 1} \
-    & sum_(i = 0)^(m - 1) x_(i,p) = 1 quad forall p in {0, dots, m - 1} \
-    & z_(i,j,p) <= x_(i,p), z_(i,j,p) <= x_(j,(p + 1) mod m) quad forall i, j, p \
-    & z_(i,j,p) >= x_(i,p) + x_(j,(p + 1) mod m) - 1 quad forall i, j, p \
-    & z_(i,j,p) = 0 quad "whenever" D["head"_i, "tail"_j] = oo \
-    & sum_(i = 0)^(m - 1) ell_i + sum_(p = 0)^(m - 1) sum_(i = 0)^(m - 1) sum_(j = 0)^(m - 1) D["head"_i, "tail"_j] z_(i,j,p) <= B \
-    & x_(i,p), z_(i,j,p) in {0, 1}.
-  $
+  _Correctness._ ($arrow.r.double$) Every feasible source permutation defines a one-hot matrix $x$. Set each $z$ to its indicated product. All connectors used by the permutation are reachable, so the zero constraints also hold. The objective equals the source route length minus $L$.
 
-  _Correctness._ ($arrow.r.double$) Any feasible Stacker Crane permutation determines a one-hot assignment and consecutive-pair indicators whose connector costs equal the route length. ($arrow.l.double$) Any feasible ILP solution yields a permutation of the required arcs, and the linearized connector term is exactly the sum of shortest paths between consecutive arcs.
+  ($arrow.l.double$) The two assignment constraints make every feasible $x$ a permutation. The three product constraints force $z = x x$ for binary variables. If an adjacency were unreachable, its product would be one while its zero constraint required zero, a contradiction. Therefore the decoded permutation has a feasible closed walk, whose shortest connector lengths sum to the ILP objective. Its source value is exactly that objective plus $L$.
 
-  _Solution extraction._ Decode the permutation by taking, for each position $p$, the unique arc $a$ with $x_(a,p) = 1$.
+  Thus feasibility is equivalent in both directions and the constant offset preserves every optimum. Zero lengths and repeated or self-loop required arcs do not alter the argument. When $m=1$, the product is $x_(0,0)^2=x_(0,0)$ and still enforces a reachable return. When $m=0$, both models have the empty solution with value zero.
+
+  _Solution extraction._ For each position $p$, return the unique $i$ with $x_(i,p)=1$, using the existing one-hot decoder. There are $m^2+m^3$ binary variables and $2m+3m^3+m r$ constraints, where $r$ is the number of unreachable ordered required-arc pairs; hence at most $2m+4m^3$ constraints.
 ]
 
 #reduction-rule("SteinerTreeInGraphs", "ILP")[
@@ -15392,7 +15289,7 @@ The following reductions to Integer Linear Programming are straightforward formu
 
   _Correctness._ ($arrow.r.double$) Any feasible open-shop schedule with the given permutations $sigma_i$ induces valid ordering bits $x_{j k i}$ and $y_{j i i'}$ and start times satisfying all non-overlap constraints. ($arrow.l.double$) Any feasible ILP solution defines non-overlapping start times for all tasks, respecting both machine and job constraints.
 
-  _Solution extraction._ For each machine $i$, sort jobs by their ILP start times $s_{j,i}$ to recover the per-machine permutation; output the concatenation of these $m$ direct-index permutations.
+  _Solution extraction._ Return the $n m$ start-time variables $s_{j,i}$ directly in job-major order.
 ]
 
 #reduction-rule("MinimumTardinessSequencing", "ILP")[
@@ -15449,21 +15346,23 @@ The following reductions to Integer Linear Programming are straightforward formu
 ]
 
 #reduction-rule("SequencingToMinimizeTardyTaskWeight", "ILP")[
-  Place each task in exactly one schedule position with a binary tardy indicator forced on whenever the completion time at that position exceeds the task's deadline.
+  Use position assignments and exact tardiness indicators, with both implications of each deadline comparison. Prefix bounds supply valid constants for the bounded-disjunction construction @vielma2015, including the signed lengths, signed weights, and arbitrary deadlines accepted by the source model.
 ][
-  _Construction._ Variables: binary $x_(j,p)$ with $x_(j,p) = 1$ iff task $j$ occupies position $p$, and binary tardy indicator $u_j$. Let $M = sum_j ell_j$. The ILP is:
+  _Construction._ For $n$ tasks introduce binary $x_(j,p)$ (task $j$ occupies position $p$) and binary $u_j$ (task $j$ is tardy), with the two families of assignment equations. Let $P_p = sum_(q<p) sum_j ell_j x_(j,q)$. Define $L_p$ and $U_p$ as the sums of the $p$ smallest and $p$ largest lengths respectively; both are zero for $p=0$. Any permutation satisfies $L_p <= P_p <= U_p$.
+
+  For each task and position put
+  $ c_(j,p)=min(U_p,max(L_p-1,d_j-ell_j)), quad A_(j,p)=U_p-c_(j,p), quad F_(j,p)=c_(j,p)+1-L_p. $
+  The clipped integer cutoff preserves the comparison on the entire prefix interval: $P_p>d_j-ell_j$ iff $P_p>c_(j,p)$. Thus this bound transformation does not alter source semantics. Add
   $
-    "minimize" quad & sum_j w_j u_j \
-    "subject to" quad & sum_p x_(j,p) = 1 quad forall j \
-    & sum_j x_(j,p) = 1 quad forall p \
-    & M x_(j,p) + sum_(p' < p) sum_(j') ell_(j') x_(j',p') - M u_j <= d_j - ell_j + M quad forall j, p \
-    & x_(j,p) in {0, 1}, u_j in {0, 1}.
+    P_p + A_(j,p)x_(j,p)-A_(j,p)u_j &<= U_p, \
+    P_p - F_(j,p)x_(j,p)-F_(j,p)u_j &>= L_p-F_(j,p).
   $
-  The third family of constraints enforces: if task $j$ is at position $p$ (so $x_(j,p) = 1$), then its completion time $ell_j + sum_(p' < p) sum_(j') ell_(j') x_(j',p')$ exceeds $d_j$ only when $u_j = 1$.
+  Minimize $sum_j w_j u_j$. There are exactly $n^2+n$ variables and $2n^2+2n$ constraints, with at most $n^4-n^3+6n^2$ nonzero coefficients. The formal ILP constructor normalizes the emitted constraints.
 
-  _Correctness._ ($arrow.r.double$) Any schedule induces completion times; for each tardy task the big-$M$ constraint forces $u_j = 1$, so the objective counts exactly the total tardy weight. ($arrow.l.double$) Any feasible ILP assignment is a valid permutation (by the assignment constraints) and the tardy indicators agree with the actual completion times.
+  _Correctness._ When $x_(j,p)=0$, both inequalities are redundant under the prefix bounds. At the occupied position, $u_j=0$ enforces $P_p<=c_(j,p)$, while $u_j=1$ enforces $P_p>=c_(j,p)+1$. Therefore $u_j$ equals the actual integer tardiness predicate, rather than merely being forced on for late tasks.
+  ($arrow.r.double$) Every source permutation and its true tardiness indicators satisfy all assignment and prefix constraints with exactly its source objective. ($arrow.l.double$) Every feasible target assignment determines a permutation and, by the occupied-position constraints, its unique correct tardiness indicators. Objective values agree for every feasible target witness, even with negative weights; optimum values consequently agree. Empty source arrays give the empty ILP and objective zero.
 
-  _Solution extraction._ Read the unique position $p$ with $x_(j,p) = 1$ for each task $j$ to recover the schedule permutation.
+  _Numeric domain and extraction._ Counts, coefficients, right-hand sides, and sparse-evaluation partial-sum bounds are checked before target construction. Signed subset-sum bounds ensure all source time and weight accumulations are representable on successful reduction. For each position, minima/maxima of the sorted prefix sums bound partial sums using at most $p$ lengths; adding the indicator coefficients gives bounds for every target evaluation after the assignment equations. Unrepresentable construction returns a typed reduction error, never an infeasibility claim. The target is `ILP<bool,i64>` with fixed minimization sense. Validate it once, reject a nonfinite/infeasible evaluation, and use the existing one-hot decoder to recover the permutation. No source endpoint or model domain is changed.
 ]
 
 #reduction-rule("SequencingWithDeadlinesAndSetUpTimes", "ILP")[
@@ -15582,21 +15481,21 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let hcd_ilp = load-example(
   "HighlyConnectedDeletion",
   "ILP",
-  target-variant: (variable: "bool"),
+  target-variant: (coefficient: "i64", variable: "bool"),
 )
 #let hcd_ilp_sol = hcd_ilp.solutions.at(0)
 #reduction-rule("HighlyConnectedDeletion", "ILP",
   example: true,
-  example-target-variant: (variable: "bool"),
+  example-target-variant: (coefficient: "i64", variable: "bool"),
   example-caption: [Triangle plus pendant: $n = 4$ vertices, $m = 4$ edges],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hcd_ilp.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(hcd_ilp) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + hcd_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(hcd_ilp_sol.source_config),
     )
-    Source deletion witness $(#hcd_ilp_sol.source_config.map(str).join(", "))$, target ILP witness $(#hcd_ilp_sol.target_config.map(str).join(", "))$.
+    Source deletion witness $(#fmt-values(hcd_ilp_sol.source_config))$, target ILP witness $(#fmt-values(hcd_ilp_sol.target_config))$.
   ],
 )[
   Enumerate the family of feasible clusters of $G$ and pick a partition of $V$ into feasible clusters maximizing the kept internal edge count; since $|E|$ is fixed, this is equivalent to minimizing deleted edges @HueffnerKomusiewiczLiebtrauNiedermeier2014.
@@ -15616,21 +15515,21 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let ep_ilp = load-example(
   "EulerianPath",
   "ILP",
-  target-variant: (variable: "i32"),
+  target-variant: (coefficient: "i64", variable: "i64"),
 )
 #let ep_ilp_sol = ep_ilp.solutions.at(0)
 #reduction-rule("EulerianPath", "ILP",
   example: true,
-  example-target-variant: (variable: "i32"),
+  example-target-variant: (coefficient: "i64", variable: "i64"),
   example-caption: [3-vertex digraph with 4 arcs (parallel edges)],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ep_ilp.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(ep_ilp) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + ep_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(ep_ilp_sol.source_config),
     )
-    Source trail witness $(#ep_ilp_sol.source_config.map(str).join(", "))$, target ILP witness $(#ep_ilp_sol.target_config.map(str).join(", "))$.
+    Source trail witness $(#fmt-values(ep_ilp_sol.source_config))$, target ILP witness $(#fmt-values(ep_ilp_sol.target_config))$.
   ],
 )[
   Encode the directed Eulerian-trail witness structure as an integer feasibility program: successor variables on compatible arc pairs, start / end indicators, and Miller--Tucker--Zemlin-style position variables eliminate spurious sub-cycles @Ebert1988ComputingEulerianTrails @BangJensenGutin2009Digraphs.
@@ -15655,24 +15554,27 @@ The following reductions to Integer Linear Programming are straightforward formu
 ]
 
 #reduction-rule("BottleneckTravelingSalesman", "ILP")[
-  Use a cyclic position assignment for the tour and a bottleneck variable that dominates the weight of every chosen tour edge.
+  Use cyclic positions, explicit edge-use choices, and a selected maximum-weight edge. The objective preserves signed edge weights without a big-$M$ constant.
 ][
-  _Construction._ Variables: binary $x_(v,p)$ for city-position assignment, binary $z_((u,v),p)$ for consecutive tour edges, and integer bottleneck variable $b$. The ILP is:
+  _Construction._ Let $n$ be the vertex count and $m$ the number of stored edges, counting parallel edges separately. Binary $x_(v,p)$ assigns vertex $v$ to position $p$. Binary $z_(e,p,d)$ chooses source edge $e$ at cyclic step $p$ in direction $d in {0,1}$. Binary $q_e$ selects one used maximum-weight edge. Define $y_e = sum_(p,d) z_(e,p,d)$ as an expression, not another variable. All variables retain the nonnegative integer ILP variant, with explicit upper bounds of one.
+
+  Each vertex and position has exactly one assignment. For edge $e=(u,v)$, impose $z_(e,p,0) <= x_(u,p)$ and $z_(e,p,0) <= x_(v,(p+1) mod n)$, with reversed endpoints for direction one. Then impose
   $
-    min quad & b \
-    "subject to" quad & sum_p x_(v,p) = 1 quad forall v \
-    & sum_v x_(v,p) = 1 quad forall p \
-    & z_((u,v),p) <= x_(u,p) quad forall (u, v), p \
-    & z_((u,v),p) <= x_(v,(p+1) mod n) quad forall (u, v), p \
-    & z_((u,v),p) >= x_(u,p) + x_(v,(p+1) mod n) - 1 quad forall (u, v), p \
-    & sum_((u,v) in E) z_((u,v),p) = 1 quad forall p \
-    & b >= w_(u,v) z_((u,v),p) quad forall (u, v), p \
-    & x_(v,p), z_((u,v),p) in {0, 1}, b in ZZ_(>=0).
+    sum_(e,d) z_(e,p,d) = 1 quad forall p, quad y_e <= 1 quad forall e,
+  $
+  and the exact maximum selector
   $
+    sum_e q_e = 1, quad q_e <= y_e, quad
+    y_e <= sum_(f: w_f >= w_e) q_f quad forall e.
+  $
+  Minimize $sum_e w_e q_e$. The threshold principle selects among edge weights @larusic2010; the explicit maximum selector and stored-edge treatment here give a direct ILP construction.
+
+  _Correctness._ ($arrow.r.double$) A connected degree-two spanning edge selection supplies a cyclic vertex order and distinct edge uses. This includes a one-vertex self-loop or a two-vertex cycle with two parallel edges when present in the native graph. Choose a used maximum-weight edge for $q$. All constraints hold and the objective is the source bottleneck.
+  ($arrow.l.double$) The position equalities give a permutation. Exactly one edge connects each consecutive pair, and no stored edge is used twice, so the decoded selection is connected, spans all vertices, and has degree two. The selected $q$ edge is used and dominates every used edge. Thus every feasible target witness has exactly the source value, not merely an upper bound. An empty graph has no selector and is infeasible.
 
-  _Correctness._ ($arrow.r.double$) Any Hamiltonian tour yields a feasible assignment and sets $b$ to the maximum selected edge weight. ($arrow.l.double$) Any feasible ILP solution encodes a Hamiltonian cycle, and the minimax constraints force $b$ to equal its bottleneck edge weight.
+  _Numeric contract._ Constraints use only coefficients of magnitude one; weights are compared without subtraction or negation. Exactly one objective coefficient contributes, so even the minimum signed integer is preserved without overflowing an intermediate sum. Checked dimensions bound binary constraint accumulation. The target has $n^2+2 m n+m$ variables and $n^2+6 m n+4m+3n+1$ constraints. The default floating solver's transport range is a separate limitation.
 
-  _Solution extraction._ Mark an edge selected in the source config iff it appears between two consecutive positions in the decoded cycle.
+  _Solution extraction._ Evaluate the target once, reject an infeasible assignment, and select precisely the stored edges whose edge-use block contains a one. Parallel edges keep their individual identities.
 ]
 
 #let hc_lc = load-example("HamiltonianCircuit", "LongestCircuit")
@@ -15681,23 +15583,23 @@ The following reductions to Integer Linear Programming are straightforward formu
 #let hc_lc_source_edges = hc_lc.source.instance.graph.edges
 #let hc_lc_target_edges = hc_lc.target.instance.graph.edges
 #let hc_lc_target_weights = hc_lc.target.instance.edge_lengths
-#let hc_lc_selected_edges = hc_lc_target_edges.enumerate().filter(((i, _)) => hc_lc_sol.target_config.at(i) == 1).map(((i, e)) => (e.at(0), e.at(1)))
+#let hc_lc_selected_edges = hc_lc_target_edges.enumerate().filter(((i, _)) => hc_lc_sol.target_config.at(i)).map(((i, e)) => (e.at(0), e.at(1)))
 #reduction-rule("HamiltonianCircuit", "LongestCircuit",
   example: true,
   example-caption: [Cycle graph on $#hc_lc_n$ vertices with unit edge lengths],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hc_lc.source) + " -o hc.json",
-      "pred reduce hc.json --to " + target-spec(hc_lc) + " -o bundle.json",
+      "pred reduce hc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hc.json --config " + hc_lc_sol.source_config.map(str).join(","),
+      "pred evaluate hc.json --config " + cli-config(hc_lc_sol.source_config),
     )
 
-    *Step 1 -- Start from the source graph.* The canonical source fixture is the cycle on vertices ${0, 1, dots, #(hc_lc_n - 1)}$ with $#hc_lc_source_edges.len()$ edges. The stored Hamiltonian-circuit witness is the permutation $[#hc_lc_sol.source_config.map(str).join(", ")]$.\
+    *Step 1 -- Start from the source graph.* The canonical source fixture is the cycle on vertices ${0, 1, dots, #(hc_lc_n - 1)}$ with $#hc_lc_source_edges.len()$ edges. The stored Hamiltonian-circuit witness is the permutation $[#fmt-values(hc_lc_sol.source_config)]$.\
 
-    *Step 2 -- Assign unit edge lengths.* The target keeps the same $#hc_lc_n$ vertices and $#hc_lc_target_edges.len()$ edges. Every edge receives length $1$, so the edge-length vector is $[#hc_lc_target_weights.map(str).join(", ")]$.\
+    *Step 2 -- Assign unit edge lengths.* The target keeps the same $#hc_lc_n$ vertices and $#hc_lc_target_edges.len()$ edges. Every edge receives length $1$, so the edge-length vector is $[#fmt-values(hc_lc_target_weights)]$.\
 
-    *Step 3 -- Verify the canonical witness.* The stored target configuration $[#hc_lc_sol.target_config.map(str).join(", ")]$ selects the edges #hc_lc_selected_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The total circuit length is $#hc_lc_selected_edges.len() times 1 = #hc_lc_n = n$, confirming a Hamiltonian circuit. Traversing the selected edges recovers the vertex permutation $[#hc_lc_sol.source_config.map(str).join(", ")]$.\
+    *Step 3 -- Verify the canonical witness.* The stored target configuration $[#fmt-values(hc_lc_sol.target_config)]$ selects the edges #hc_lc_selected_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The total circuit length is $#hc_lc_selected_edges.len() times 1 = #hc_lc_n = n$, confirming a Hamiltonian circuit. Traversing the selected edges recovers the vertex permutation $[#fmt-values(hc_lc_sol.source_config)]$.\
 
     *Multiplicity:* The fixture stores one canonical witness. For the $#hc_lc_n$-cycle there are $#hc_lc_n times 2 = #(hc_lc_n * 2)$ directed Hamiltonian circuits (choice of start vertex and direction), but they all select the same undirected edge set.
   ],
@@ -15708,23 +15610,25 @@ The following reductions to Integer Linear Programming are straightforward formu
 
   _Correctness._ ($arrow.r.double$) If $G$ has a Hamiltonian circuit $v_0, v_1, dots, v_(n-1), v_0$, then this circuit uses $n$ edges each of length 1, giving total length $n$. Since a simple circuit on $n$ vertices can use at most $n$ edges, this is optimal. ($arrow.l.double$) If the longest circuit in $G'$ has length $n$, it uses $n$ unit-weight edges and therefore visits $n$ distinct vertices, i.e., every vertex exactly once. This circuit is therefore a Hamiltonian circuit in $G$.
 
-  _Solution extraction._ Read the selected target edges, traverse the unique degree-2 cycle they form, and return the resulting vertex permutation as the source Hamiltonian-circuit witness.
+  _Solution extraction._ Evaluate the target selection once and require a feasible circuit of length $n$. Reject infeasible selections and shorter circuits before decoding. Then traverse the selected cycle and return its vertex permutation. This criterion applies to every target configuration, without requiring an optimality claim from the caller. If the target has no feasible circuit, or its proven optimum is less than $n$, the source answer is NO. In particular, simple graphs with fewer than three vertices have no circuit; an empty edge selection is not a witness, including on the empty graph.
 ]
 
 #reduction-rule("LongestCircuit", "ILP")[
-  A direct cycle-selection ILP uses binary edge variables, degree constraints, and a connectivity witness to force exactly one simple circuit of length at least the bound.
+  A direct cycle-selection ILP maximizes total edge length, using degree constraints and binary multi-commodity flows from a root chosen on the circuit. For $n$ vertices and $m$ edges, it uses $m + 2n + 2m n$ binary variables.
 ][
-  _Construction._ Variables: binary $y_e$ for edges, binary $s_v$ indicating whether vertex $v$ lies on the circuit, and root-flow variables on selected edges. The ILP is:
+  _Construction._ Let $G = (V, E)$ have $n = |V|$ vertices, $m = |E|$ edges, and positive edge lengths $l_e$. Introduce binary edge selections $y_e$, vertex selections $s_v$, root selections $r_v$, and a binary directed flow $f^t_(u v)$ in each direction of each edge for every destination $t in V$. Define the flow divergence $D^t_v = sum_(u : {v,u} in E) (f^t_(v u) - f^t_(u v))$. The ILP is:
   $
-    "find" quad & bold(x) \
+    max quad & sum_(e in E) l_e y_e \
     "subject to" quad & sum_(e : v in e) y_e = 2 s_v quad forall v \
     & sum_e y_e >= 3 \
-    & sum_e l_e y_e >= K \
-    & "root-flow connectivity constraints hold on the selected edges" \
-    & y_e, s_v in {0, 1}.
+    & sum_v r_v = 1, quad r_v <= s_v quad forall v \
+    & D^t_t = r_t - s_t quad forall t \
+    & 0 <= D^t_v <= r_v quad forall t, v != t \
+    & f^t_(u v) <= y_({u,v}) quad forall t, {u,v} in E " (both directions)" \
+    & y_e, s_v, r_v, f^t_(u v) in {0, 1}.
   $
 
-  _Correctness._ ($arrow.r.double$) A simple circuit has degree 2 at each used vertex, is connected, and meets the length bound $K$. ($arrow.l.double$) The degree and connectivity constraints force the selected edges to form exactly one simple circuit, and the final inequality enforces the required total length.
+  _Correctness._ ($arrow.r.double$) Given any simple circuit, select its edges and vertices and choose any of its vertices as root. For each selected non-root destination, send one unit along a simple path on the circuit from the root to that destination; set all other commodity flows to zero. Every constraint holds, and the objective equals the circuit length. ($arrow.l.double$) Degree constraints make the nonempty selected subgraph a disjoint union of simple circuits. If a selected destination $t$ were outside the root's component, summing its commodity's divergence over its component would give $-1$: the destination consumes one unit and every other vertex there has zero divergence. But no flow can cross that component's boundary, a contradiction. Thus all selected vertices lie in the root's component, giving exactly one simple circuit. The objective is preserved in both directions.
 
   _Solution extraction._ Output the binary edge-selection vector $(y_e)_(e in E)$.
 ]
@@ -15805,19 +15709,17 @@ The following reductions to Integer Linear Programming are straightforward formu
 ]
 
 #reduction-rule("AcyclicPartition", "ILP")[
-  Assign every vertex to one partition class, bound the weight and crossing cost of those classes, and impose a topological order on the quotient digraph.
+  Assign every vertex to a topologically numbered partition class and directly require every arc to have nondecreasing class labels, following the upper-triangular formulation of @ozkayaCatalyurek2022.
 ][
-  _Construction._ Let $n = |V|$ and let the directed arcs be $A = {a_0, dots, a_(m-1)}$ with $a_t = (u_t -> v_t)$. The source witness already allows every vertex to choose one label in ${0, dots, n - 1}$, so the ILP uses exactly the same label range. Use `ILP<i32>` with variable order
-  $(x_(v,c))_(v,c), (s_(t,c))_(t,c), (y_t)_t, (o_c)_c, (p_v)_v$.
+  _Construction._ Let $n = |V|$ and let the directed arcs be $A = {a_0, dots, a_(m-1)}$ with $a_t = (u_t -> v_t)$. The source witness already allows every vertex to choose one label in ${0, dots, n - 1}$, so the ILP uses exactly the same label range. Use `ILP<i64>` with variable order
+  $(x_(v,c))_(v,c), (s_(t,c))_(t,c), (y_t)_t$.
   The indices are
   $"idx"_x(v,c) = v n + c$,
   $"idx"_s(t,c) = n^2 + t n + c$,
-  $"idx"_y(t) = n^2 + m n + t$,
-  $"idx"_o(c) = n^2 + m n + m + c$,
-  and $ "idx"_p(v) = n^2 + m n + m + n + v$.
-  There are $n^2 + m n + m + 2 n$ variables.
+  and $"idx"_y(t) = n^2 + m n + t$.
+  There are $n^2 + m n + m$ variables.
 
-  Here $x_(v,c) in {0, 1}$ means vertex $v$ is assigned to class $c$, $s_(t,c) in {0, 1}$ means both endpoints of arc $a_t$ lie in class $c$, $y_t in {0, 1}$ marks that arc $a_t$ crosses between two different classes, $o_c in {0, dots, n - 1}$ is the order assigned to class $c$, and $p_v in {0, dots, n - 1}$ copies the order of the class chosen by vertex $v$.
+  Here $x_(v,c) in {0, 1}$ means vertex $v$ is assigned to topological class label $c$, $s_(t,c) in {0, 1}$ means both endpoints of arc $a_t$ lie in class $c$, and $y_t in {0, 1}$ marks that arc $a_t$ crosses between two different classes.
 
   The constraints are:
   $sum_(c = 0)^(n - 1) x_(v,c) = 1$ for every vertex $v$;
@@ -15825,12 +15727,8 @@ The following reductions to Integer Linear Programming are straightforward formu
   $s_(t,c) <= x_(u_t,c)$, $s_(t,c) <= x_(v_t,c)$, and $s_(t,c) >= x_(u_t,c) + x_(v_t,c) - 1$ for every arc $a_t$ and class $c$;
   $y_t + sum_(c = 0)^(n - 1) s_(t,c) = 1$ for every arc $a_t$, so $y_t = 1$ exactly for crossing arcs;
   $sum_(t = 0)^(m - 1) "cost"(a_t) y_t <= K$;
-  $0 <= o_c <= n - 1$ and $0 <= p_v <= n - 1$ for all classes $c$ and vertices $v$;
-  $p_v - o_c <= (n - 1) (1 - x_(v,c))$ and $o_c - p_v <= (n - 1) (1 - x_(v,c))$ for all $v, c$, so $p_v = o_c$ whenever $x_(v,c) = 1$;
-  and for every arc $a_t = (u_t -> v_t)$,
-  $p_(v_t) - p_(u_t) >= 1 - n sum_(c = 0)^(n - 1) s_(t,c)$.
-  The exact big-$M$ here is $M = n$: if $u_t$ and $v_t$ lie in the same class, then $sum_c s_(t,c) = 1$ and the right-hand side is $1 - n = -(n - 1)$, which is precisely the smallest possible difference between two order variables in ${0, dots, n - 1}$. If the arc crosses between two distinct classes, then $sum_c s_(t,c) = 0$ and the inequality becomes $p_(v_t) - p_(u_t) >= 1$. For the realized classes $c$ and $d$ of the endpoints, this is exactly the requested form
-  $o_d - o_c >= 1 - M sum_h s_(t,h)$.
+  and $sum_(c = 0)^(n - 1) c x_(u_t,c) <= sum_(c = 0)^(n - 1) c x_(v_t,c)$ for every arc $a_t = (u_t -> v_t)$.
+  The last inequality directly requires every original arc to go from a lower or equal class label to a higher or equal label. Equality represents an internal arc; a crossing arc has distinct labels and therefore strictly increases along the corresponding quotient arc.
 
   The ILP is:
   $
@@ -15841,12 +15739,11 @@ The following reductions to Integer Linear Programming are straightforward formu
     & s_(t,c) >= x_(u_t,c) + x_(v_t,c) - 1 quad forall t, c \
     & y_t + sum_(c = 0)^(n - 1) s_(t,c) = 1 quad forall t in {0, dots, m - 1} \
     & sum_(t = 0)^(m - 1) "cost"(a_t) y_t <= K \
-    & p_v - o_c <= (n - 1) (1 - x_(v,c)), o_c - p_v <= (n - 1) (1 - x_(v,c)) quad forall v, c \
-    & p_(v_t) - p_(u_t) >= 1 - n sum_(c = 0)^(n - 1) s_(t,c) quad forall t in {0, dots, m - 1} \
-    & x_(v,c), s_(t,c), y_t in {0, 1}; o_c, p_v in {0, dots, n - 1}.
+    & sum_(c = 0)^(n - 1) c x_(u_t,c) <= sum_(c = 0)^(n - 1) c x_(v_t,c) quad forall t in {0, dots, m - 1} \
+    & x_(v,c), s_(t,c), y_t in {0, 1}.
   $
 
-  _Correctness._ ($arrow.r.double$) Any valid acyclic partition gives a class assignment whose quotient arcs respect some topological ordering, with the same class weights and crossing cost. ($arrow.l.double$) Any feasible ILP solution partitions the vertices, keeps every class within the weight bound, charges exactly the inter-class arcs, and the order variables force the quotient digraph to be acyclic.
+  _Correctness._ ($arrow.r.double$) Given a valid acyclic partition, choose a topological ordering of its quotient digraph and relabel each used class by its position in that ordering. This relabeling preserves class membership, class weights, and crossing cost. Every internal arc has equal endpoint labels, while every quotient arc goes to a strictly larger label, so the direct ordering inequalities hold. ($arrow.l.double$) Any feasible ILP solution partitions the vertices, keeps every class within the weight bound, and charges exactly the inter-class arcs. Along every quotient arc the endpoint classes have distinct, nondecreasing labels and hence the label strictly increases. A directed quotient cycle would require a strict increase around the cycle back to its starting label, which is impossible; therefore the quotient digraph is acyclic.
 
   _Solution extraction._ For each vertex $v$, output the unique class label $c$ with $x_(v,c) = 1$.
 ]
@@ -15869,51 +15766,28 @@ The following reductions to Integer Linear Programming are straightforward formu
 ]
 
 #reduction-rule("BiconnectivityAugmentation", "ILP")[
-  Select candidate edges under the budget and, for every deleted vertex, certify that the remaining augmented graph stays connected by a flow witness.
+  Select candidate edges under the total budget and certify connectivity of both the original augmented graph and every vertex-deleted graph using bounded integral flow witnesses.
 ][
-  _Construction._ Let the base graph edges be $E = {e_0, dots, e_(m-1)}$ with $e_i = {u_i, v_i}$, and let the candidate edges be $F = {f_0, dots, f_(p-1)}$ with $f_j = {s_j, t_j}$. If $n = |V| <= 1$, return the empty feasible ILP, since every 0- or 1-vertex graph is already biconnected in the model. Otherwise fix, for each deleted vertex $q$, the surviving root
-  $r_q = 0$ if $q != 0$, and $r_0 = 1$.
-  This choice is explicit and valid because $n >= 2$.
+  _Construction._ Let $n$ be the vertex count, $m$ the number of base edges, and $p$ the number of candidate edges. Candidate $j$ has cost $w_j$, and the budget is $B$. Use `ILP<i64>` with an empty minimization objective and every variable bounded to $[0,1]$ through `IntegerVariable::binary()`.
 
-  Use `ILP<i32>`. The candidate-selection bits are $y_j in {0, 1}$ with index $j$. For the connectivity witnesses, allocate the full $(q, t)$ commodity grid with $q, t in {0, dots, n - 1}$, even though the commodities with $t = q$ or $t = r_q$ will be pinned to 0. For each base edge $e_i$ and orientation flag $eta in {0, 1}$, let $eta = 0$ mean $u_i -> v_i$ and $eta = 1$ mean $v_i -> u_i$; define binary flow variables $f^(q,t)_(i,eta)$ with index
-  $p + (((q n + t) m + i) 2 + eta)$.
-  For each candidate edge $f_j$ and orientation flag $eta in {0, 1}$, let $eta = 0$ mean $s_j -> t_j$ and $eta = 1$ mean $t_j -> s_j$; define binary flow variables $g^(q,t)_(j,eta)$ with index
-  $p + 2 m n^2 + (((q n + t) p + j) 2 + eta)$.
-  There are $p + 2 n^2 (m + p)$ variables in total.
+  Selection variable $y_j$ has index $j$. Connectivity scenarios are $q in {0, dots, n}$: $q<n$ deletes vertex $q$, whereas $q=n$ deletes nothing. For each scenario and destination $t in {0, dots, n-1}$, reserve two directed flow variables per base edge and per candidate edge. Orientation $eta=0$ follows the stored endpoint order, and $eta=1$ reverses it. The indices are
+  $"idx"_f(q,t,i,eta)=p+2((q n+t)m+i)+eta$ and
+  $"idx"_g(q,t,j,eta)=p+2 m n(n+1)+2((q n+t)p+j)+eta$.
+  Thus the variable count is $p+2 n(n+1)(m+p)$.
 
-  The constraints are:
-  $sum_(j = 0)^(p - 1) w_j y_j <= B$;
-  for every deleted vertex $q$ and target $t$, if $t = q$ or $t = r_q$, set all $f^(q,t)_(i,eta)$ and $g^(q,t)_(j,eta)$ equal to 0;
-  if the deleted vertex $q$ is incident to base edge $e_i$ or candidate edge $f_j$, set the corresponding directed flow variables for that $(q,t)$ to 0, because they do not exist in $G - q$;
-  for each candidate edge variable, the exact activation big-$M$ is 1:
-  $g^(q,t)_(j,eta) <= y_j$ for every $q, t, j, eta$;
-  and for every valid pair $(q,t)$ with $t in.not {q, r_q}$ and every surviving vertex $v != q$, impose flow conservation
-  $sum_"out of v" (f^(q,t) + g^(q,t)) - sum_"into v" (f^(q,t) + g^(q,t)) = 1$
-  when $v = r_q$,
-  $= -1$ when $v = t$,
-  and $= 0$ otherwise.
-  The sums range over both orientations of all base and candidate edges that avoid $q$. Since every commodity carries exactly one unit, binary flows are sufficient.
+  Include the total-budget row $sum_(j=0)^(p-1) w_j y_j <= B$, even for an empty graph. In each scenario with surviving vertices, the root is $r_q=0$ unless vertex 0 is deleted, in which case $r_0=1$. If $t=q$ or $t=r_q$, pin that commodity's entire flow to zero. When no vertices survive, all commodities are pinned and no root is used. For other commodities, pin both orientations of edges incident to the deleted vertex to zero. Bound every surviving candidate flow by its selection bit, $g^(q,t)_(j,eta)<=y_j$. At each surviving vertex impose outgoing flow minus incoming flow equal to 1 at $r_q$, -1 at $t$, and 0 elsewhere. The scenario $q=n$ uses the same equations without deleting any edge or vertex.
 
-  The ILP is:
-  $
-    "find" quad & bold(x) \
-    "subject to" quad & sum_(j = 0)^(p - 1) w_j y_j <= B \
-    & f^(q,t)_(i,eta) = 0 quad "whenever" t in {q, r_q} "or" e_i "is incident to" q \
-    & g^(q,t)_(j,eta) = 0 quad "whenever" t in {q, r_q} "or" f_j "is incident to" q \
-    & g^(q,t)_(j,eta) <= y_j quad forall q, t in {0, dots, n - 1}, j in {0, dots, p - 1}, eta in {0, 1} \
-    & "for each valid pair" (q,t) ", unit-flow conservation from" r_q "to" t "holds in" G - q \
-    & y_j, f^(q,t)_(i,eta), g^(q,t)_(j,eta) in {0, 1}.
-  $
+  _Correctness._ Unit paths satisfy flow conservation, and a nonzero feasible flow implies a source-to-destination path by flow decomposition or a cut argument @karger2021flow. In the forward direction, a feasible augmentation is connected before and after every vertex deletion; choose one simple path from each scenario root to each other surviving vertex. Their separate binary flow vectors satisfy all constraints, and the selected costs satisfy the budget. In the reverse direction, each unit-flow commodity forces its destination into the root's connected component. Scenario $q=n$ proves original connectivity; the other scenarios prove connectivity after each deletion. Both conditions are necessary, including on two vertices. Therefore the selected augmentation is biconnected. Zero- and one-vertex graphs satisfy the connectivity conditions by the model's convention; their empty selection still has cost zero and must meet $B$.
 
-  _Correctness._ ($arrow.r.double$) If the chosen augmentation makes the graph biconnected, then every vertex-deleted graph is connected and therefore supports the required flows. ($arrow.l.double$) If the ILP is feasible, then removing any single vertex leaves a connected graph, which is exactly the definition of biconnectivity for the augmented graph.
+  _Signed costs and arithmetic._ Costs need not be nonnegative. The source checks the final selected total against $B$, rather than rejecting a temporary excess that later negative costs may cancel. The budget row retains candidate order, so source and target perform the same checked i64 accumulation. Overflow remains an evaluation error; the implementation does not widen or reinterpret it as infeasibility. Connectivity coefficients and right-hand sides are in ${-1,0,1}$, and flow variables are bounded to $[0,1]$. Variable-layout arithmetic is checked before allocation.
 
-  _Solution extraction._ Output the binary selection vector of candidate edges.
+  _Solution extraction._ Validate the target assignment once and require a finite feasible objective value; then decode its first $p$ binary integers as candidate-selection bits. The empty objective equals zero on every feasible target. The constraint count is at most $1+n(n+1)(2m+4p+n)$.
 ]
 
 #reduction-rule("BoundedComponentSpanningForest", "ILP")[
   Assign every vertex to one of at most $K$ components, bound each component's total weight, and certify connectivity inside each used component by a flow witness.
 ][
-  _Construction._ Let $n = |V|$, let the graph edges be $E = {e_0, dots, e_(m-1)}$ with $e_i = {u_i, v_i}$, and let the allowed component labels be $c in {0, dots, K - 1}$. Use `ILP<i32>` with variables ordered as
+  _Construction._ Let $n = |V|$, let the graph edges be $E = {e_0, dots, e_(m-1)}$ with $e_i = {u_i, v_i}$, and let the allowed component labels be $c in {0, dots, K - 1}$. Use `ILP<i64>` with variables ordered as
   $(x_(v,c))_(v,c), (u_c)_c, (r_(v,c))_(v,c), (s_c)_c, (b_(v,c))_(v,c), (f_(i,eta,c))_(i,eta,c)$.
   Their indices are
   $"idx"_x(v,c) = v K + c$,
@@ -15984,7 +15858,7 @@ The following reductions to Integer Linear Programming are straightforward formu
 #reduction-rule("StrongConnectivityAugmentation", "ILP")[
   Select candidate arcs under the budget and certify strong connectivity by sending flow both from a root to every vertex and back again.
 ][
-  _Construction._ Let the base arcs be $A = {a_0, dots, a_(m-1)}$ with $a_i = (u_i, v_i)$, let the candidate arcs be $C = {c_0, dots, c_(p-1)}$ with $c_j = (s_j, t_j)$, and, when $n = |V| >= 1$, fix the root to be vertex $r = 0$. If $n <= 1$, return the empty feasible ILP. Use `ILP<i32>` with variables ordered as
+  _Construction._ Let the base arcs be $A = {a_0, dots, a_(m-1)}$ with $a_i = (u_i, v_i)$, let the candidate arcs be $C = {c_0, dots, c_(p-1)}$ with $c_j = (s_j, t_j)$, and, when $n = |V| >= 1$, fix the root to be vertex $r = 0$. If $n <= 1$, return the empty feasible ILP. Use `ILP<i64>` with variables ordered as
   $(y_j)_j, (f^t_i)_(t,i), (bar(f)^t_j)_(t,j), (g^t_i)_(t,i), (bar(g)^t_j)_(t,j)$,
   where $f^t$ is the forward root-to-$t$ flow on base arcs, $bar(f)^t$ is the forward flow on candidate arcs, $g^t$ is the backward $t$-to-root flow on base arcs, and $bar(g)^t$ is the backward flow on candidate arcs.
   The indices are
@@ -16283,9 +16157,9 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ps_qubo.source) + " -o paintshop.json",
-      "pred reduce paintshop.json --to " + target-spec(ps_qubo) + " -o bundle.json",
+      "pred reduce paintshop.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate paintshop.json --config " + ps_qubo_sol.source_config.map(str).join(","),
+      "pred evaluate paintshop.json --config " + cli-config(ps_qubo_sol.source_config),
     )
     #{
       let n = ps_qubo.source.instance.num_cars
@@ -16295,13 +16169,13 @@ The following reductions to Integer Linear Programming are straightforward formu
       let seq-labels = seq.map(i => labels.at(i))
       let coloring = seq.enumerate().map(((pos, car)) => {
         let first-color = ps_qubo_sol.source_config.at(car)
-        if is-first.at(pos) { first-color } else { 1 - first-color }
+        if is-first.at(pos) { first-color } else { not first-color }
       })
       [*Source:* $n = #n$ cars, sequence $(#seq-labels.join(", "))$. \
       *Parity:* #seq.enumerate().map(((pos, _)) => if is-first.at(pos) { "1st" } else { "2nd" }).join(", ") \
       *Step 1 -- One QUBO variable per car.* Binary variable $x_i in {0,1}$ for each car $i$: $x_i = 0$ means "first occurrence gets color 0, second gets color 1"; $x_i = 1$ reverses. \
       *Step 2 -- Build the $Q$ matrix from adjacent pairs.* For each adjacent pair $(j, j+1)$ in the sequence with distinct cars $a, b$: if both positions have the _same_ parity (both first or both second occurrence), a color switch occurs when $x_a != x_b$, contributing $+1$ to $Q_(a a)$, $+1$ to $Q_(b b)$, and $-2$ to $Q_(a b)$. If they have _different_ parity, a switch occurs when $x_a = x_b$, contributing $-1$ to $Q_(a a)$, $-1$ to $Q_(b b)$, and $+2$ to $Q_(a b)$. \
-      *Step 3 -- Verify.* The QUBO solution $bold(x) = (#ps_qubo_sol.target_config.map(str).join(", "))$ yields coloring $(#coloring.map(str).join(", "))$ with #{coloring.windows(2).filter(w => w.at(0) != w.at(1)).len()} color switches #sym.checkmark ]
+      *Step 3 -- Verify.* The QUBO solution $bold(x) = (#fmt-values(ps_qubo_sol.target_config))$ yields coloring $(#fmt-values(coloring))$ with #{coloring.windows(2).filter(w => w.at(0) != w.at(1)).len()} color switches #sym.checkmark ]
     }
   ],
 )[
@@ -16363,9 +16237,9 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(rta_rtsa.source) + " -o rta.json",
-      "pred reduce rta.json --to " + target-spec(rta_rtsa) + " -o bundle.json",
+      "pred reduce rta.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate rta.json --config " + rta_rtsa_sol.source_config.map(str).join(","),
+      "pred evaluate rta.json --config " + cli-config(rta_rtsa_sol.source_config),
     )
     Source: path graph $P_4$ with vertices ${0, 1, 2, 3}$, edges $\{0,1\}, \{1,2\}, \{2,3\}$, and bound $K = 5$. \
     Target: universe $X = {0, 1, 2, 3}$, subsets $\{0,1\}, \{1,2\}, \{2,3\}$, bound $K' = 5 - 3 = 2$. \
@@ -16388,7 +16262,7 @@ The following reductions to Integer Linear Programming are straightforward formu
 ][
   _Construction._ Let $X = {0, dots, n - 1}$ and let the subset family be $cal(C) = {S_0, dots, S_(m-1)}$. For every subset of size 0 or 1 the model charges extension cost 0 automatically, so only the nontrivial subsets matter. Enumerate them as
   $I = {k_0 < dots < k_(r-1)} = {k : |S_k| >= 2}$.
-  Use `ILP<i32>`. The variable blocks are:
+  Use `ILP<i64>`. The variable blocks are:
   parent indicators $p_(v,u) in {0, 1}$ for all $v, u in X$;
   depths $d_v in {0, dots, n - 1}$;
   ancestor indicators $a_(u,v) in {0, 1}$, where $a_(u,v) = 1$ means $u$ is an ancestor of $v$ (allowing $u = v$);
@@ -16486,11 +16360,11 @@ The following reductions to Integer Linear Programming are straightforward formu
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(mcmf_mcc.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(mcmf_mcc) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + mcmf_mcc_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(mcmf_mcc_sol.source_config),
     )
-    Source flow $(#mcmf_mcc_sol.source_config.map(str).join(", "))$; target circulation $(#mcmf_mcc_sol.target_config.map(str).join(", "))$ appends the return arc.
+    Source flow $(#fmt-values(mcmf_mcc_sol.source_config))$; target circulation $(#fmt-values(mcmf_mcc_sol.target_config))$ appends the return arc.
   ],
 )[
   Augment the flow network with a single return arc from the sink to the source. Give it capacity equal to a feasible-flow upper bound and a sufficiently negative cost so that the resulting min-cost circulation lex-orders the original (max value, min cost) objective. Recover the source flow by deleting the return arc.
@@ -16514,7 +16388,7 @@ The following reductions to Integer Linear Programming are straightforward formu
 #reduction-rule("MinimumEdgeCostFlow", "ILP")[
   Introduce integer flow variables and binary arc-activation indicators, link them so that an indicator is forced to 1 whenever the corresponding arc carries positive flow, and minimize the total price of activated arcs.
 ][
-  _Construction._ Let $m = |A|$ and $n = |V|$. Use `ILP<i32>` with $2m$ variables: integer flow variables $f_a in {0, dots, c(a)}$ for $a in {0, dots, m - 1}$ and binary activation indicators $y_a in {0, 1}$ for $a in {m, dots, 2m - 1}$.
+  _Construction._ Let $m = |A|$ and $n = |V|$. Use `ILP<i64>` with $2m$ variables: integer flow variables $f_a in {0, dots, c(a)}$ for $a in {0, dots, m - 1}$ and binary activation indicators $y_a in {0, 1}$ for $a in {m, dots, 2m - 1}$.
 
   Constraints:
   - _Linking:_ $f_a - c(a) dot y_a <= 0$ for each arc $a$ — forces $y_a = 1$ when $f_a > 0$ ($m$ constraints).
@@ -16531,74 +16405,11 @@ The following reductions to Integer Linear Programming are straightforward formu
   _Solution extraction._ Output the first $m$ variables $(f_0, dots, f_(m-1))$ as the flow assignment.
 ]
 
-#{
-  let mfas_mlr = load-example("MinimumFeedbackArcSet", "MaximumLikelihoodRanking")
-  let mfas_mlr_sol = mfas_mlr.solutions.at(0)
-  let source-arcs = mfas_mlr.source.instance.graph.arcs
-  let target-matrix = mfas_mlr.target.instance.matrix
-  let ranking = mfas_mlr_sol.target_config
-  let removed-indices = mfas_mlr_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, _)) => i)
-  let removed-arcs = removed-indices.map(i => source-arcs.at(i))
-  let target-cost = 0
-  for a in range(target-matrix.len()) {
-    for b in range(target-matrix.len()) {
-      if a != b and ranking.at(a) > ranking.at(b) {
-        target-cost += target-matrix.at(a).at(b)
-      }
-    }
-  }
-  let fmt-mat(m) = m.map(row => row.map(v => str(v)).join(", ")).join("; ")
-  [
-    #reduction-rule("MinimumFeedbackArcSet", "MaximumLikelihoodRanking",
-      example: true,
-      example-caption: [5-vertex digraph ($n = #mfas_mlr.source.instance.graph.num_vertices$, $|A| = #source-arcs.len()$, unit weights) mapped to a skew-symmetric ranking matrix],
-      extra: [
-        #pred-commands(
-          "pred create --example " + problem-spec(mfas_mlr.source) + " -o mfas.json",
-          "pred reduce mfas.json --to " + target-spec(mfas_mlr) + " -o bundle.json",
-          "pred solve bundle.json",
-          "pred evaluate mfas.json --config " + mfas_mlr_sol.source_config.map(str).join(","),
-        )
-
-        *Step 1 -- Source instance.* The source digraph has vertices ${#range(mfas_mlr.source.instance.graph.num_vertices).map(str).join(", ")}$ and arcs #{source-arcs.map(a => $(#(a.at(0)) arrow #(a.at(1)))$).join(", ")}, all with unit weight. The extracted optimal feedback arc set removes #{removed-arcs.map(a => $(#(a.at(0)) arrow #(a.at(1)))$).join(" and ")}, so $|F| = #removed-arcs.len()$.
-
-        *Step 2 -- Build the comparison matrix.* The reduction keeps the same item set and writes $M_(i j) = 1$ when only $i arrow j$ exists, $M_(i j) = -1$ when only $j arrow i$ exists, and $M_(i j) = 0$ otherwise. For this instance,
-        $ M = mat(#fmt-mat(target-matrix)). $
-        Every off-diagonal pair sums to $0$, so the target is a valid Maximum Likelihood Ranking instance with $c = 0$.
-
-        *Step 3 -- Verify a solution.* The stored ranking vector is $(#ranking.map(str).join(", "))$, interpreted as the map from items to ranks. The target disagreement cost is $#target-cost = 2 dot #removed-arcs.len() - #source-arcs.len()$, and the extracted source witness is exactly the backward-arc set #{removed-arcs.map(a => $(#(a.at(0)) arrow #(a.at(1)))$).join(" and ")} #sym.checkmark
-
-        *Multiplicity:* The fixture stores one canonical optimum. Other optimal rankings exist because the DAG obtained after removing the two backward arcs has multiple valid topological orders.
-      ],
-    )[
-      This $O(n^2)$ reduction @garey1979 applies to unit-weight feedback arc set instances. It keeps the same vertex set as ranking items and encodes each unordered pair by a skew-symmetric entry in $\{-1, 0, 1\}$ with comparison count $c = 0$.
-    ][
-      _Construction._ Given a unit-weight Minimum Feedback Arc Set instance $(G = (V, A), bold(1))$ with $V = \{0, dots, n - 1\}$, construct the matrix $M in ZZ^(n times n)$ by setting $M_(i i) = 0$ and, for every distinct pair $i, j$,
-      $
-        M_(i j) = cases(
-          1 & "if" (i arrow j) in A and (j arrow i) not in A,
-          -1 & "if" (j arrow i) in A and (i arrow j) not in A,
-          0 & "otherwise"
-        ).
-      $
-      Then $M_(i j) + M_(j i) = 0$ for all $i != j$, so the target is a valid Maximum Likelihood Ranking instance with $n$ items.
-
-      _Correctness._ ($arrow.r.double$) Let $pi$ be any ranking and let $B(pi) = \{(u arrow v) in A : pi(u) > pi(v)\}$ be its backward arcs. Removing $B(pi)$ leaves only forward arcs, hence a DAG, so $B(pi)$ is a feedback arc set. Partition unordered vertex pairs into one-directional pairs $A_1$ and bidirectional pairs $A_2$. Every one-directional backward arc contributes $+1$ to the MLR objective, every one-directional forward arc contributes $-1$, and bidirectional or absent pairs contribute $0$. Therefore
-      $
-        "cost"(pi) = 2 |B(pi)| - (|A_1| + 2|A_2|) = 2 |B(pi)| - |A|.
-      $
-      The target objective is thus the source objective shifted by the constant $-|A|$, so minimizing disagreement cost minimizes feedback arc set size. ($arrow.l.double$) Let $F subset.eq A$ be a minimum feedback arc set, and take a topological order $pi$ of the DAG $G - F$. Every arc in $A backslash F$ is forward in $pi$, hence every backward arc under $pi$ lies in $F$, so $B(pi) subset.eq F$. Since $B(pi)$ is itself a feedback arc set by the previous argument, minimality of $F$ forces $|B(pi)| = |F|$. Therefore an optimal source solution yields an optimal target ranking.
-
-      _Solution extraction._ Given the target rank vector, output one source bit per source arc $(u arrow v)$ in source-arc order: set the bit to $1$ iff item $u$ is ranked after item $v$, and to $0$ otherwise.
-    ]
-  ]
-}
-
 #{
   let mlr_ilp = load-example("MaximumLikelihoodRanking", "ILP")
   let mlr_ilp_sol = mlr_ilp.solutions.at(0)
   let mlr_n = mlr_ilp.source.instance.matrix.len()
-  let mlr_nv = mlr_ilp.target.instance.num_vars
+  let mlr_nv = mlr_ilp.target.instance.variables.len()
   let mlr_nc = mlr_ilp.target.instance.constraints.len()
   [
     #reduction-rule("MaximumLikelihoodRanking", "ILP",
@@ -16607,15 +16418,15 @@ The following reductions to Integer Linear Programming are straightforward formu
       extra: [
         #pred-commands(
           "pred create --example MaximumLikelihoodRanking -o mlr.json",
-          "pred reduce mlr.json --to " + target-spec(mlr_ilp) + " -o bundle.json",
+          "pred reduce mlr.json --via route.json -o bundle.json",
           "pred solve bundle.json",
-          "pred evaluate mlr.json --config " + mlr_ilp_sol.source_config.map(str).join(","),
+          "pred evaluate mlr.json --config " + cli-config(mlr_ilp_sol.source_config),
         )
         *Step 1 -- Source instance.* A ranking instance with $n = #mlr_n$ items and comparison matrix $A$.
 
         *Step 2 -- Build the ILP.* Introduce $binom(#str(mlr_n), 2) = #mlr_nv$ binary variables $x_(i j)$ for each pair $i < j$. Add $#mlr_nc$ transitivity constraints from all $binom(#str(mlr_n), 3)$ triples. The ILP has #mlr_nv variables and #mlr_nc constraints.
 
-        *Step 3 -- Verify.* The ILP optimum extracts to ranking $(#mlr_ilp_sol.source_config.map(str).join(", "))$, which matches the source optimum #sym.checkmark.
+        *Step 3 -- Verify.* The ILP optimum extracts to ranking $(#fmt-values(mlr_ilp_sol.source_config))$, which matches the source optimum #sym.checkmark.
       ],
     )[
       Each pair of items $(i, j)$ with $i < j$ gets a binary variable $x_(i j)$ indicating whether $i$ is ranked before $j$. Transitivity constraints enforce a valid linear order, and the objective minimizes the total disagreement cost.
@@ -16642,7 +16453,7 @@ The following reductions to Integer Linear Programming are straightforward formu
   let ocst_ilp = load-example("OptimumCommunicationSpanningTree", "ILP")
   let ocst_ilp_sol = ocst_ilp.solutions.at(0)
   let ocst_n = ocst_ilp.source.instance.num_vertices
-  let ocst_nv = ocst_ilp.target.instance.num_vars
+  let ocst_nv = ocst_ilp.target.instance.variables.len()
   let ocst_nc = ocst_ilp.target.instance.constraints.len()
   [
     #reduction-rule("OptimumCommunicationSpanningTree", "ILP",
@@ -16651,27 +16462,27 @@ The following reductions to Integer Linear Programming are straightforward formu
       extra: [
         #pred-commands(
           "pred create --example OptimumCommunicationSpanningTree -o ocst.json",
-          "pred reduce ocst.json --to " + target-spec(ocst_ilp) + " -o bundle.json",
+          "pred reduce ocst.json --via route.json -o bundle.json",
           "pred solve bundle.json",
-          "pred evaluate ocst.json --config " + ocst_ilp_sol.source_config.map(str).join(","),
+          "pred evaluate ocst.json --config " + cli-config(ocst_ilp_sol.source_config),
         )
         *Step 1 -- Source instance.* $K_#ocst_n$ with edge weight and requirement matrices.
 
         *Step 2 -- Build the ILP.* Introduce edge selectors and multi-commodity flow variables. The ILP has #ocst_nv variables and #ocst_nc constraints.
 
-        *Step 3 -- Verify.* The ILP optimum extracts to edge selection $(#ocst_ilp_sol.source_config.map(str).join(", "))$, which matches the source optimum #sym.checkmark.
+        *Step 3 -- Verify.* The ILP optimum extracts to edge selection $(#fmt-values(ocst_ilp_sol.source_config))$, which matches the source optimum #sym.checkmark.
       ],
     )[
-      Binary edge selectors determine the spanning tree. Multi-commodity flow variables route one unit of flow for each vertex pair with positive requirement, and the objective minimizes the total weighted communication cost.
+      Binary edge selectors determine the spanning tree. Multi-commodity flow variables route one unit for every vertex pair, including zero-requirement pairs, and the objective minimizes the total weighted communication cost @hu1974ocst.
     ][
-      _Construction._ Given $K_n$ with weights $w(e)$ and requirements $r(u, v)$, let $m = n(n-1)/2$. Introduce binary edge variables $x_e$ for each edge. For each pair $(s, t)$ with $r(s, t) > 0$, add directed flow variables $f^(s t)_(e, "fwd")$ and $f^(s t)_(e, "bwd")$ for each edge $e$.
+      _Construction._ Given $K_n$ with weights $w(e)$ and requirements $r(u, v)$, let $m = n(n-1)/2$. Introduce binary edge variables $x_e$ for each edge. For every pair $(s, t)$ with $s < t$, add directed flow variables $f^(s t)_(e, "fwd")$ and $f^(s t)_(e, "bwd")$ for each edge $e$. Zero-requirement commodities have zero objective coefficient but are retained to certify that every vertex belongs to the spanning tree.
 
       Constraints:
       - Tree size: $sum_e x_e = n - 1$
       - Flow conservation: for each commodity $(s, t)$ and each vertex $v$, net inflow equals $-1$ at source $s$, $+1$ at sink $t$, and $0$ elsewhere.
       - Capacity linking: $f^(s t)_(e, "dir") <= x_e$ for each commodity and direction.
 
-      Objective: $min sum_((s,t): r > 0) r(s,t) dot sum_e w(e) dot (f^(s t)_(e, "fwd") + f^(s t)_(e, "bwd")))$
+      Objective: $min sum_(s<t) r(s,t) dot sum_e w(e) dot (f^(s t)_(e, "fwd") + f^(s t)_(e, "bwd")))$
 
       _Correctness._ ($arrow.r.double$) Any spanning tree defines edge selectors and unique path flows. The objective equals the communication cost. ($arrow.l.double$) Any feasible ILP solution with $n - 1$ selected edges and valid flows corresponds to a connected spanning subgraph (tree), and the flow cost equals the path-weighted communication cost.
 
@@ -16760,29 +16571,28 @@ The following reductions to Integer Linear Programming are straightforward formu
 
 See #link("https://github.com/CodingThrust/problem-reductions/blob/main/examples/export_petersen_mapping.rs")[`export_petersen_mapping.rs`].
 
-== Variant Cast Reductions
+== Variant Reductions
 
-Problems parameterized by graph type, weight type, or clause-width ($k$) admit identity reductions between specialised and general variants. Each cast preserves the problem structure exactly (same number of vertices/variables, same constraints), converting only the type parameter to a more general one. These are registered as self-edges in the reduction graph with identity overhead.
+Problems parameterized by graph type, weight type, target type, or clause width ($k$) use explicit reductions between registered variants. Each rule constructs the target representation, registers an exact size map, and preserves the witness representation.
 
 #reduction-rule("MaximumIndependentSet", "MaximumIndependentSet")[
-  The graph hierarchy $"KingsSubgraph" subset "UnitDiskGraph" subset "SimpleGraph"$ and weight hierarchy $"One" subset ZZ subset RR$ induce identity-overhead casts between MIS variants. Graph casts discard geometric information (grid coordinates $arrow.r$ Euclidean coordinates $arrow.r$ adjacency list); weight casts embed unit weights into integers ($1 arrow.r 1_ZZ$) or integers into floats ($w arrow.r w_RR$). All edges and weights are preserved verbatim.
+  Explicit MIS variant reductions convert King's and triangular lattice graphs to unit-disk graphs, unit-disk graphs to simple adjacency graphs, and unit weights to integer weights. Every rule preserves the vertex indices and has an exact identity size map.
 ][
-  _Construction._ Given $"MIS"(G, bold(w))$ with graph type $G_"sub"$ and weight type $W_"sub"$, construct $"MIS"(G', bold(w)')$ where $G' = "cast"(G_"sub")$ lifts the graph to its parent type and $bold(w)' = "cast"(bold(w))$ lifts each weight. The `CastToParent` trait defines the concrete maps:
+  _Construction._ The registered rules use these concrete maps:
   - _KingsSubgraph $arrow.r$ UnitDiskGraph:_ integer grid positions $(i, j)$ map to float coordinates with radius $r = 1.5$.
   - _TriangularSubgraph $arrow.r$ UnitDiskGraph:_ triangular lattice positions map to float coordinates with radius $r = 1.1$.
   - _UnitDiskGraph $arrow.r$ SimpleGraph:_ discard coordinates, retain only the adjacency edge list.
-  - _One $arrow.r$ i32:_ each unit weight maps to $1_ZZ$.
-  - _i32 $arrow.r$ f64:_ each integer weight maps to its float representation.
+  - _One $arrow.r$ i64:_ each unit weight maps to $1_ZZ$.
 
-  _Correctness._ The cast preserves the vertex set, edge set, and weight values (up to type embedding). Since the MIS objective $max sum_(v in S) w(v)$ depends only on adjacency and weights, any independent set in $G_"sub"$ is independent in $G'$, and the objective is unchanged. Optimality is preserved in both directions.
+  _Correctness._ Each graph conversion preserves the adjacency relation, and the weight conversion preserves every unit objective contribution as the integer one. Since the MIS objective $max sum_(v in S) w(v)$ depends only on adjacency and weights, feasible sets and their objective values are preserved.
 
   _Solution extraction._ Return the target configuration unchanged (identity map on vertices).
 ]
 
 #reduction-rule("KColoring", "KColoring")[
-  A $k$-Coloring instance with fixed $k = 3$ casts to generic $k$-Coloring ($k in NN$) by promoting the clause-width parameter from the specialised $K_3$ variant to the general $K_N$ variant. The graph and number of colors are preserved verbatim.
+  A $k$-Coloring instance with fixed $k = 3$ converts to generic $k$-Coloring ($k in NN$) by constructing the registered $K_N$ variant with the same graph and color count.
 ][
-  _Construction._ Given $"KColoring"_(K_3)(G, k)$, construct $"KColoring"_(K_N)(G, k)$ with the same graph $G$ and the same number of colors $k$. The $K_3 arrow.r K_N$ cast simply relabels the variant parameter.
+  _Construction._ Given $"KColoring"_(K_3)(G, k)$, construct $"KColoring"_(K_N)(G, k)$ with the same graph $G$ and the same number of colors $k$.
 
   _Correctness._ The coloring constraint (no two adjacent vertices share a color, using $k$ colors) is identical in both variants. The only difference is that $K_3$ statically guarantees $k = 3$, while $K_N$ allows arbitrary $k$. Since the graph and color count are unchanged, feasibility, optimality, and the solution space are preserved.
 
@@ -16790,7 +16600,7 @@ Problems parameterized by graph type, weight type, or clause-width ($k$) admit i
 ]
 
 #reduction-rule("KSatisfiability", "KSatisfiability")[
-  A $k$-SAT instance with fixed clause width ($k = 2$ or $k = 3$) casts to generic $k$-SAT by promoting the $K_2$ or $K_3$ variant to $K_N$. The clauses and variables are preserved verbatim; the target uses `new_allow_less` to accept clauses with fewer than $k$ literals.
+  A $k$-SAT instance with fixed clause width ($k = 2$ or $k = 3$) converts to generic $k$-SAT by constructing the registered $K_N$ variant. The clauses and variables are preserved verbatim; the target uses `new_allow_less` to accept clauses with fewer than $k$ literals.
 ][
   _Construction._ Given $"KSat"_(K_j)(n, cal(C))$ with $j in {2, 3}$, construct $"KSat"_(K_N)(n, cal(C))$ with the same $n$ variables and clause set $cal(C)$.
 
@@ -16800,7 +16610,7 @@ Problems parameterized by graph type, weight type, or clause-width ($k$) admit i
 ]
 
 #reduction-rule("SpinGlass", "SpinGlass")[
-  An Ising spin-glass instance with integer couplings and fields ($J_(i j), h_i in ZZ$) casts to the floating-point variant ($J_(i j), h_i in RR$) by embedding each integer as its float representation. The graph topology is unchanged.
+  An Ising spin-glass instance with integer couplings and fields ($J_(i j), h_i in ZZ$) converts to the floating-point variant ($J_(i j), h_i in RR$) through exact `i64_to_exact_f64` embeddings. The graph topology is preserved.
 ][
   _Construction._ Given $"SpinGlass"(G, bold(J), bold(h))$ with $J_(i j) in ZZ$ and $h_i in ZZ$, construct $"SpinGlass"(G, bold(J)', bold(h)')$ with $J'_(i j) = J_(i j) in RR$ and $h'_i = h_i in RR$.
 
@@ -16810,17 +16620,37 @@ Problems parameterized by graph type, weight type, or clause-width ($k$) admit i
 ]
 
 #reduction-rule("MaximumSetPacking", "MaximumSetPacking")[
-  A Maximum Set Packing instance with unit weights casts to integer weights ($"One" arrow.r ZZ$) or integer weights cast to float weights ($ZZ arrow.r RR$). The set family and universe are preserved; only the weight type changes.
+  A Maximum Set Packing instance converts unit weights to integer weights ($"One" arrow.r ZZ$) and integer weights to exactly represented floating weights ($ZZ arrow.r RR$). The set family and universe are preserved.
 ][
-  _Construction._ Given $"MSP"(cal(S), bold(w))$ with weights $w_i$ of type $W_"sub"$, construct $"MSP"(cal(S), bold(w)')$ with $w'_i = "cast"(w_i)$:
-  - _One $arrow.r$ i32:_ each unit weight maps to $1_ZZ$.
-  - _i32 $arrow.r$ f64:_ each integer weight maps to its float representation.
+  _Construction._ Given $"MSP"(cal(S), bold(w))$, construct $"MSP"(cal(S), bold(w)')$ using:
+  - _One $arrow.r$ i64:_ each unit weight maps to $1_ZZ$.
+  - _i64 $arrow.r$ f64:_ each integer weight maps through `i64_to_exact_f64`.
 
   _Correctness._ The packing constraint (no two selected sets share a universe element) depends only on set membership, not on weights. The objective $max sum_(i in P) w_i$ is preserved under the type embedding. Optimality is unchanged.
 
   _Solution extraction._ Return the target configuration unchanged.
 ]
 
+#reduction-rule("ClosestVectorProblem", "ClosestVectorProblem")[
+  An integer-target CVP instance converts to the floating-target variant by embedding every target coordinate with `i64_to_exact_f64`. The integer lattice basis is copied unchanged.
+][
+  _Construction._ Given $(B, bold(t))$ with $B in ZZ^(m times n)$ and $bold(t) in ZZ^m$, construct $(B, bold(t)')$ with $t'_i = "f64"(t_i)$ for every exactly representable coordinate $|t_i| lt.eq 2^53 - 1$.
+
+  _Correctness._ Exact coordinate conversion gives $bold(t)' = bold(t)$ in $RR^m$. Therefore $norm(B bold(x) - bold(t)')_2 = norm(B bold(x) - bold(t))_2$ for every $bold(x) in ZZ^n$, so the minimizers coincide.
+
+  _Solution extraction._ Return the integer coefficient vector unchanged.
+]
+
+#reduction-rule("QUBO", "QUBO")[
+  An integer QUBO converts to the floating-coefficient variant by embedding every matrix coefficient with `i64_to_exact_f64`.
+][
+  _Construction._ Given $Q in ZZ^(n times n)$, construct $Q' in RR^(n times n)$ with $Q'_(i j) = "f64"(Q_(i j))$ for every exactly representable coefficient $|Q_(i j)| lt.eq 2^53 - 1$.
+
+  _Correctness._ For every binary vector $bold(x)$, exact coefficient conversion gives $bold(x)^top Q' bold(x) = bold(x)^top Q bold(x)$. The objective ordering and minimizers are preserved.
+
+  _Solution extraction._ Return the binary vector unchanged.
+]
+
 // Completeness check: warn about reduction rules in JSON but missing from paper
 #context {
   let covered = covered-rules.final()
@@ -16854,7 +16684,7 @@ Problems parameterized by graph type, weight type, or clause-width ($k$) admit i
 
 == Resource Estimation from Examples
 
-The following table shows concrete variable overhead for example instances, taken directly from the canonical fixture examples.
+The following table shows concrete target-variable counts for example instances, taken directly from the canonical fixture examples.
 
 #let example-files = (
   (source: "MaximumIndependentSet", target: "MinimumVertexCover"),
@@ -16869,7 +16699,12 @@ The following table shows concrete variable overhead for example instances, take
   (source: "MinimumVertexCover", target: "MinimumSetCovering"),
   (source: "MaxCut", target: "SpinGlass"),
   (source: "SpinGlass", target: "MaxCut"),
-  (source: "SpinGlass", target: "QUBO"),
+  (
+    source: "SpinGlass",
+    target: "QUBO",
+    source-variant: (graph: "SimpleGraph", weight: "f64"),
+    target-variant: (weight: "f64"),
+  ),
   (source: "QUBO", target: "SpinGlass"),
   (source: "ClosestVectorProblem", target: "QUBO"),
   (source: "KColoring", target: "QUBO"),
@@ -16878,7 +16713,7 @@ The following table shows concrete variable overhead for example instances, take
     source: "KSatisfiability",
     target: "QUBO",
     source-variant: (k: "K3"),
-    target-variant: (weight: "f64"),
+    target-variant: (weight: "i64"),
   ),
   (source: "ILP", target: "QUBO"),
   (source: "Satisfiability", target: "MaximumIndependentSet"),
@@ -16932,7 +16767,7 @@ The following table shows concrete variable overhead for example instances, take
       #pred-commands(
         "pred create --example MaximumDomaticNumber -o mdn.json",
         "pred solve mdn.json",
-        "pred evaluate mdn.json --config " + config.map(str).join(","),
+        "pred evaluate mdn.json --config " + cli-config(config),
       )
     ]
   ]
@@ -16953,7 +16788,7 @@ The following table shows concrete variable overhead for example instances, take
   let nv = x.instance.graph.num_vertices
   let edges-j = x.instance.graph.edges.map(e => (e.at(0), e.at(1)))
   let config = x.optimal_config
-  let resolving = range(nv).filter(v => config.at(v) == 1)
+  let resolving = range(nv).filter(v => config.at(v))
   let size = metric-value(x.optimal_value)
   [
     #problem-def("MinimumMetricDimension")[
@@ -16968,7 +16803,7 @@ The following table shows concrete variable overhead for example instances, take
       #pred-commands(
         "pred create --example MinimumMetricDimension -o mmd.json",
         "pred solve mmd.json",
-        "pred evaluate mmd.json --config " + config.map(str).join(","),
+        "pred evaluate mmd.json --config " + cli-config(config),
       )
     ]
   ]
@@ -17002,7 +16837,7 @@ The following table shows concrete variable overhead for example instances, take
       #pred-commands(
         "pred create --example MinimumGraphBandwidth -o mgb.json",
         "pred solve mgb.json",
-        "pred evaluate mgb.json --config " + config.map(str).join(","),
+        "pred evaluate mgb.json --config " + cli-config(config),
       )
     ]
   ]
@@ -17019,7 +16854,7 @@ The following table shows concrete variable overhead for example instances, take
 ]
 
 #{
-  let x = load-model-example("MinimumCapacitatedSpanningTree", variant: (graph: "SimpleGraph", weight: "i32"))
+  let x = load-model-example("MinimumCapacitatedSpanningTree", variant: (graph: "SimpleGraph", weight: "i64"))
   let nv = x.instance.graph.num_vertices
   let edges-j = x.instance.graph.edges.map(e => (e.at(0), e.at(1)))
   let ew = x.instance.weights
@@ -17027,7 +16862,7 @@ The following table shows concrete variable overhead for example instances, take
   let reqs = x.instance.requirements
   let root = x.instance.root
   let config = x.optimal_config
-  let sel-idx = range(edges-j.len()).filter(i => config.at(i) == 1)
+  let sel-idx = range(edges-j.len()).filter(i => config.at(i))
   let total-weight = metric-value(x.optimal_value)
   [
     #problem-def("MinimumCapacitatedSpanningTree")[
@@ -17035,23 +16870,23 @@ The following table shows concrete variable overhead for example instances, take
     ][
       Minimum Capacitated Spanning Tree (ND5) @garey1979. NP-hard in the strong sense, even with unit requirements and capacity 3.
 
-      *Example.* Consider $G$ with $n = #nv$ vertices, $|E| = #{edges-j.len()}$ edges, root $v_#root$, capacity $c = #cap$, vertex requirements $r = (#reqs.map(str).join(", "))$, and edge weights $w = (#ew.map(str).join(", "))$. The optimal tree selects edges #sel-idx.map(i => $(v_#(edges-j.at(i).at(0)), v_#(edges-j.at(i).at(1)))$).join(", ") with total weight $#sel-idx.map(i => str(ew.at(i))).join(" + ") = #total-weight$. Every subtree rooted away from $v_#root$ has total requirement at most $c = #cap$.
+      *Example.* Consider $G$ with $n = #nv$ vertices, $|E| = #{edges-j.len()}$ edges, root $v_#root$, capacity $c = #cap$, vertex requirements $r = (#fmt-values(reqs))$, and edge weights $w = (#fmt-values(ew))$. The optimal tree selects edges #sel-idx.map(i => $(v_#(edges-j.at(i).at(0)), v_#(edges-j.at(i).at(1)))$).join(", ") with total weight $#sel-idx.map(i => str(ew.at(i))).join(" + ") = #total-weight$. Every subtree rooted away from $v_#root$ has total requirement at most $c = #cap$.
 
       #pred-commands(
         "pred create --example MinimumCapacitatedSpanningTree -o mcst.json",
         "pred solve mcst.json",
-        "pred evaluate mcst.json --config " + config.map(str).join(","),
+        "pred evaluate mcst.json --config " + cli-config(config),
       )
     ]
   ]
 }
 
 #reduction-rule("MinimumCapacitatedSpanningTree", "ILP")[
-  Binary edge selectors $y_e$ plus directed requirement-flow variables. Flow conservation routes each vertex's requirement to the root; capacity constraints bound flow per edge.
+  Binary edge selectors $y_e$, directed requirement-flow variables $f$, and directed unit-demand connectivity variables $g$. The first flow enforces subtree capacities; the second connects even zero-requirement vertices.
 ][
-  _Construction._ $3m$ variables: $m$ edge selectors + $2m$ directed flow. Tree cardinality, binary bounds, flow conservation (each non-root vertex generates $r(v)$ flow toward root), flow-edge linking, and per-edge capacity bounds ($<= c$). Minimize $sum_e w(e) dot y_e$.
+  _Construction._ $5m$ variables: $m$ edge selectors and two directed flows of $2m$ variables each. Requirement flow sends $r(v)$ units from each non-root vertex to the root and is bounded by capacity $c$. Connectivity flow sends one unit from every non-root vertex to the root and satisfies $g_(u v)+g_(v u) <= (n-1)y_e$. Also impose $sum_e y_e=n-1$ and minimize $sum_e w(e) dot y_e$. This combines the standard non-unit-demand flow model @gouveiaLopes2000 with the standard unit-demand spanning-tree flow.
 
-  _Correctness._ ($arrow.r.double$) A feasible capacitated spanning tree induces a valid flow. ($arrow.l.double$) A feasible ILP solution encodes a spanning tree satisfying capacity constraints.
+  _Correctness._ ($arrow.r.double$) A feasible capacitated spanning tree induces both flows along its unique root paths. ($arrow.l.double$) Unit-demand flow makes every vertex reachable from the root; together with $n-1$ selected edges this gives a spanning tree. Requirement flow on that tree equals each rooted subtree's total requirement, so its capacity bounds are exactly the source constraints.
 
   _Solution extraction._ First $m$ variables (edge selectors) give the source configuration.
 ]
@@ -17070,16 +16905,13 @@ The following table shows concrete variable overhead for example instances, take
 // === Non-ILP reduction rules (issue #974) ===
 
 #reduction-rule("ILP", "ILP")[
-  Integer variables with finite upper bounds are replaced by groups of binary variables using truncated binary encoding. Feasibility-Based Bound Tightening (FBBT) first infers per-variable upper bounds $U_i$ from the constraint system; each integer variable $x_i in {0, dots, U_i}$ is then encoded as $x_i = sum_(j=0)^(K_i - 1) w_(i j) y_(i j)$ where $y_(i j) in {0, 1}$ and the weights are powers of two with a truncated final weight ensuring $sum w_(i j) = U_i$.
+  ILP variants convert between binary and bounded integer variable domains and between exact-integer and floating-point coefficients. Binary variables embed directly into integer variables. A finitely bounded integer variable is encoded by binary variables with truncated positional weights. Integer coefficients are embedded only when every stored coefficient and right-hand side has an exact `f64` representation.
 ][
-  _Construction._ Given an ILP over $n$ non-negative integer variables with constraints $A x <= b$ (and/or $>=, =$) and objective $c^top x$:
-  (1) Run FBBT to infer upper bounds $U_1, dots, U_n$. If infeasible, return a trivially infeasible binary ILP. If unbounded, fall back to $U_i = 2^(31) - 1$.
-  (2) For each $x_i$, compute $K_i = ceil(log_2(U_i + 1))$ and weights $w_(i 0) = 1, w_(i 1) = 2, dots, w_(i, K_i - 2) = 2^(K_i - 2), w_(i, K_i - 1) = U_i - (2^(K_i - 1) - 1)$.
-  (3) Substitute $x_i = sum_j w_(i j) y_(i j)$ into every constraint and objective term, expanding each integer coefficient into a sum over binary coefficients.
+  _Construction._ For the binary-to-integer edge, copy the variables, constraints, objective, and optimization direction unchanged. For an integer variable $x_i in [L_i, U_i]$, let $D_i = U_i - L_i$ and choose positive truncated binary weights $w_(i j)$ whose subset sums represent every integer from $0$ through $D_i$; substitute $x_i = L_i + sum_j w_(i j)y_(i j)$ into every constraint and objective term. This edge rejects variables without two finite bounds. For the coefficient edge, copy the variable bounds and optimization direction and convert each entry of the constraint matrix, right-hand side, and objective independently; reject the instance if any integer lies outside the exactly representable `f64` integer range.
 
-  _Correctness._ ($arrow.r.double$) Any integer assignment $x_i in {0, dots, U_i}$ has a unique truncated binary representation $y_(i j)$ with $sum w_(i j) y_(i j) = x_i$, preserving all constraints and the objective value. ($arrow.l.double$) Any binary assignment $y_(i j) in {0,1}$ yields $x_i = sum w_(i j) y_(i j) in {0, dots, U_i}$, so the decoded integer assignment satisfies the original constraints.
+  _Correctness._ The binary-to-integer embedding changes no mathematical expression. For bounded integer variables, every $x_i in [L_i,U_i]$ has a truncated binary representation, and every binary assignment decodes inside that interval; substitution preserves all constraints and objective values. Exact conversion preserves every stored coefficient, so it constructs the same formal linear objective and constraints over the same integer variables.
 
-  _Solution extraction._ For each source variable $x_i$, compute $x_i = sum_(j=0)^(K_i - 1) w_(i j) y_(i j)$ from the binary solution.
+  _Solution extraction._ Binary-to-integer and coefficient conversions preserve the assignment; coefficient conversion additionally checks the assignment against the source integer ILP. Binary encoding returns $x_i = L_i + sum_j w_(i j)y_(i j)$.
 ]
 
 #let hc_hp = load-example("HamiltonianCircuit", "HamiltonianPath")
@@ -17094,16 +16926,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hc_hp.source) + " -o hc.json",
-      "pred reduce hc.json --to " + target-spec(hc_hp) + " -o bundle.json",
+      "pred reduce hc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hc.json --config " + hc_hp_sol.source_config.map(str).join(","),
+      "pred evaluate hc.json --config " + cli-config(hc_hp_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical source fixture is the cycle $C_#hc_hp_n$ on vertices ${0, dots, #(hc_hp_n - 1)}$ with #hc_hp_source_edges.len() edges: #hc_hp_source_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The stored Hamiltonian-circuit witness is the permutation $[#hc_hp_sol.source_config.map(str).join(", ")]$.\
+    *Step 1 -- Source instance.* The canonical source fixture is the cycle $C_#hc_hp_n$ on vertices ${0, dots, #(hc_hp_n - 1)}$ with #hc_hp_source_edges.len() edges: #hc_hp_source_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The stored Hamiltonian-circuit witness is the permutation $[#fmt-values(hc_hp_sol.source_config)]$.\
 
     *Step 2 -- Construction.* Fix $v_0 = 0$. Its neighbors in the source are ${1, 3}$ ($deg = 2$). Introduce $v' = #hc_hp_n$, $s = #(hc_hp_n + 1)$, $t = #(hc_hp_n + 2)$. The target graph $G'$ has $#hc_hp_target_n = #hc_hp_n + 3$ vertices and #hc_hp_target_edges.len() edges: #hc_hp_target_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The $#(hc_hp_target_edges.len() - hc_hp_source_edges.len())$ new edges are the duplicated adjacencies of $v'$ plus the two pendant edges.\
 
-    *Step 3 -- Verify a solution.* The stored target Hamiltonian-path permutation is $[#hc_hp_sol.target_config.map(str).join(", ")]$, visiting every vertex of $G'$ exactly once. The path starts at pendant $s = #hc_hp_sol.target_config.at(0)$ and ends at pendant $t = #hc_hp_sol.target_config.at(hc_hp_target_n - 1)$. Dropping $s$ at the front and the last two vertices $v', t$ at the back gives $[#hc_hp_sol.target_config.slice(1, hc_hp_target_n - 2).map(str).join(", ")]$, which is the source Hamiltonian circuit $[#hc_hp_sol.source_config.map(str).join(", ")]$.\
+    *Step 3 -- Verify a solution.* The stored target Hamiltonian-path permutation is $[#fmt-values(hc_hp_sol.target_config)]$, visiting every vertex of $G'$ exactly once. The path starts at pendant $s = #hc_hp_sol.target_config.at(0)$ and ends at pendant $t = #hc_hp_sol.target_config.at(hc_hp_target_n - 1)$. Dropping $s$ at the front and the last two vertices $v', t$ at the back gives $[#hc_hp_sol.target_config.slice(1, hc_hp_target_n - 2).map(str).join(", ")]$, which is the source Hamiltonian circuit $[#fmt-values(hc_hp_sol.source_config)]$.\
 
     *Multiplicity:* The fixture stores one canonical witness. For $C_#hc_hp_n$ there are $#hc_hp_n times 2 = #(hc_hp_n * 2)$ directed Hamiltonian circuits (choice of start vertex and direction), each yielding a distinct target path.
   ],
@@ -17125,16 +16957,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(kc_si.source) + " -o kclique.json",
-      "pred reduce kclique.json --to " + target-spec(kc_si) + " -o bundle.json",
+      "pred reduce kclique.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate kclique.json --config " + kc_si_sol.source_config.map(str).join(","),
+      "pred evaluate kclique.json --config " + cli-config(kc_si_sol.source_config),
     )
 
     #{
       let n = kc_si.source.instance.graph.num_vertices
       let k = kc_si.source.instance.k
-      let clique-verts = kc_si_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
-      let fills = kc_si_sol.source_config.map(c => if c == 1 { graph-colors.at(0) } else { white })
+      let clique-verts = kc_si_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
+      let fills = kc_si_sol.source_config.map(selected => if selected { graph-colors.at(0) } else { white })
       // Simple circular layout for the source graph
       let angle-step = 360deg / n
       let radius = 2.0
@@ -17158,7 +16990,7 @@ The following table shows concrete variable overhead for example instances, take
 
     *Step 3 -- Variable semantics.* The source uses $n = #kc_si.source.instance.graph.num_vertices$ binary indicator variables ($x_v = 1$ iff vertex $v$ is in the clique). The target uses $k = #kc_si.source.instance.k$ variables, each ranging over ${0, dots, n - 1}$, specifying which host vertex each pattern vertex maps to.
 
-    *Step 4 -- Verify a solution.* The canonical witness has source config $bold(x) = (#kc_si_sol.source_config.map(str).join(", "))$, selecting vertices ${#kc_si_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", ")}$. The target config is $(#kc_si_sol.target_config.map(str).join(", "))$, mapping pattern vertex $i$ to host vertex $c_i$. The image vertices ${#kc_si_sol.target_config.map(str).join(", ")}$ are pairwise adjacent in $G$ (they form a triangle), confirming the isomorphism #sym.checkmark
+    *Step 4 -- Verify a solution.* The canonical witness has source config $bold(x) = (#fmt-values(kc_si_sol.source_config))$, selecting vertices ${#kc_si_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", ")}$. The target config is $(#fmt-values(kc_si_sol.target_config))$, mapping pattern vertex $i$ to host vertex $c_i$. The image vertices ${#fmt-values(kc_si_sol.target_config)}$ are pairwise adjacent in $G$ (they form a triangle), confirming the isomorphism #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical witness. The $k!$ permutations of the clique vertices each give a valid subgraph isomorphism, so the target side has $#kc_si.source.instance.k ! = #calc.fact(kc_si.source.instance.k)$ witnesses for this single source clique.
   ],
@@ -17179,8 +17011,8 @@ The following table shows concrete variable overhead for example instances, take
 #let part_mps_total = part_mps_sizes.fold(0, (a, b) => a + b)
 #let part_mps_deadline = part_mps.target.instance.deadline
 #let part_mps_nproc = part_mps.target.instance.num_processors
-#let part_mps_proc0 = part_mps_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => i)
-#let part_mps_proc1 = part_mps_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let part_mps_proc0 = part_mps_sol.source_config.enumerate().filter(((i, x)) => not x).map(((i, x)) => i)
+#let part_mps_proc1 = part_mps_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #let part_mps_load0 = part_mps_proc0.map(i => part_mps_sizes.at(i)).fold(0, (a, b) => a + b)
 #let part_mps_load1 = part_mps_proc1.map(i => part_mps_sizes.at(i)).fold(0, (a, b) => a + b)
 #reduction-rule("Partition", "MultiprocessorScheduling",
@@ -17189,16 +17021,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(part_mps.source) + " -o partition.json",
-      "pred reduce partition.json --to " + target-spec(part_mps) + " -o bundle.json",
+      "pred reduce partition.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate partition.json --config " + part_mps_sol.source_config.map(str).join(","),
+      "pred evaluate partition.json --config " + cli-config(part_mps_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical Partition instance has sizes $(#part_mps_sizes.map(str).join(", "))$ with total sum $S = #part_mps_total$. A balanced partition requires each subset to sum to $S / 2 = #part_mps_deadline$.
+    *Step 1 -- Source instance.* The canonical Partition instance has sizes $(#fmt-values(part_mps_sizes))$ with total sum $S = #part_mps_total$. A balanced partition requires each subset to sum to $S / 2 = #part_mps_deadline$.
 
-    *Step 2 -- Construction.* The reduction creates #part_mps_n tasks with lengths $(#part_mps.target.instance.lengths.map(str).join(", "))$, sets the number of processors to $m = #part_mps_nproc$, and the deadline to $D = floor(S / 2) = #part_mps_deadline$. No auxiliary variables are introduced: the target has the same #part_mps_n binary coordinates as the source.
+    *Step 2 -- Construction.* The reduction creates #part_mps_n tasks with lengths $(#fmt-values(part_mps.target.instance.lengths))$, sets the number of processors to $m = #part_mps_nproc$, and the deadline to $D = floor(S / 2) = #part_mps_deadline$. No auxiliary variables are introduced: the target has the same #part_mps_n binary coordinates as the source.
 
-    *Step 3 -- Verify a solution.* The canonical witness is $bold(x) = (#part_mps_sol.source_config.map(str).join(", "))$, which is the same binary vector on both sides. Processor 0 receives tasks at indices $\{#part_mps_proc0.map(str).join(", ")\}$ with sizes $(#part_mps_proc0.map(i => str(part_mps_sizes.at(i))).join(", "))$, giving load $#part_mps_load0 <= #part_mps_deadline = D$. Processor 1 receives tasks at indices $\{#part_mps_proc1.map(str).join(", ")\}$ with sizes $(#part_mps_proc1.map(i => str(part_mps_sizes.at(i))).join(", "))$, giving load $#part_mps_load1 <= #part_mps_deadline = D$. Total: $#part_mps_load0 + #part_mps_load1 = #part_mps_total = S$ #sym.checkmark
+    *Step 3 -- Verify a solution.* The canonical witness is $bold(x) = (#fmt-values(part_mps_sol.source_config))$, which is the same binary vector on both sides. Processor 0 receives tasks at indices $\{#fmt-values(part_mps_proc0)\}$ with sizes $(#part_mps_proc0.map(i => str(part_mps_sizes.at(i))).join(", "))$, giving load $#part_mps_load0 <= #part_mps_deadline = D$. Processor 1 receives tasks at indices $\{#fmt-values(part_mps_proc1)\}$ with sizes $(#part_mps_proc1.map(i => str(part_mps_sizes.at(i))).join(", "))$, giving load $#part_mps_load1 <= #part_mps_deadline = D$. Total: $#part_mps_load0 + #part_mps_load1 = #part_mps_total = S$ #sym.checkmark
 
     *Multiplicity:* The example DB stores one canonical witness. This instance admits other balanced partitions (e.g., swapping the two subsets), but one witness suffices to demonstrate the reduction.
   ],
@@ -17219,8 +17051,8 @@ The following table shows concrete variable overhead for example instances, take
 #let part_sosp_total = part_sosp_sizes.fold(0, (a, b) => a + b)
 #let part_sosp_half = part_sosp_total / 2
 #let part_sosp_opt = part_sosp_half * part_sosp_half * 2
-#let part_sosp_group0 = part_sosp_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => i)
-#let part_sosp_group1 = part_sosp_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let part_sosp_group0 = part_sosp_sol.source_config.enumerate().filter(((i, x)) => not x).map(((i, x)) => i)
+#let part_sosp_group1 = part_sosp_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #let part_sosp_load0 = part_sosp_group0.map(i => part_sosp_sizes.at(i)).fold(0, (a, b) => a + b)
 #let part_sosp_load1 = part_sosp_group1.map(i => part_sosp_sizes.at(i)).fold(0, (a, b) => a + b)
 #reduction-rule("Partition", "SumOfSquaresPartition",
@@ -17229,16 +17061,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(part_sosp.source) + " -o partition.json",
-      "pred reduce partition.json --to " + target-spec(part_sosp) + " -o bundle.json",
+      "pred reduce partition.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate partition.json --config " + part_sosp_sol.source_config.map(str).join(","),
+      "pred evaluate partition.json --config " + cli-config(part_sosp_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical Partition instance has sizes $(#part_sosp_sizes.map(str).join(", "))$ with total sum $S = #part_sosp_total$. A balanced 2-partition splits the elements into subsets summing to $S / 2 = #part_sosp_half$ each.
+    *Step 1 -- Source instance.* The canonical Partition instance has sizes $(#fmt-values(part_sosp_sizes))$ with total sum $S = #part_sosp_total$. A balanced 2-partition splits the elements into subsets summing to $S / 2 = #part_sosp_half$ each.
 
     *Step 2 -- Construction.* The reduction copies the element sizes verbatim (cast to signed integers) into a SumOfSquaresPartition instance with $K = 2$ groups; no auxiliary variables are introduced. The same #part_sosp_n binary coordinates serve as both source subset assignments and target group assignments.
 
-    *Step 3 -- Verify a solution.* The canonical witness is $bold(x) = (#part_sosp_sol.source_config.map(str).join(", "))$. Group 0 contains indices $\{#part_sosp_group0.map(str).join(", ")\}$ with sizes $(#part_sosp_group0.map(i => str(part_sosp_sizes.at(i))).join(", "))$, summing to $#part_sosp_load0$. Group 1 contains indices $\{#part_sosp_group1.map(str).join(", ")\}$ with sizes $(#part_sosp_group1.map(i => str(part_sosp_sizes.at(i))).join(", "))$, summing to $#part_sosp_load1$. The sum of squared group sums is $#part_sosp_load0^2 + #part_sosp_load1^2 = #part_sosp_opt = S^2 / 2$ #sym.checkmark
+    *Step 3 -- Verify a solution.* The canonical witness is $bold(x) = (#fmt-values(part_sosp_sol.source_config))$. Group 0 contains indices $\{#fmt-values(part_sosp_group0)\}$ with sizes $(#part_sosp_group0.map(i => str(part_sosp_sizes.at(i))).join(", "))$, summing to $#part_sosp_load0$. Group 1 contains indices $\{#fmt-values(part_sosp_group1)\}$ with sizes $(#part_sosp_group1.map(i => str(part_sosp_sizes.at(i))).join(", "))$, summing to $#part_sosp_load1$. The sum of squared group sums is $#part_sosp_load0^2 + #part_sosp_load1^2 = #part_sosp_opt = S^2 / 2$ #sym.checkmark
 
     *Multiplicity:* The example DB stores one canonical balanced witness; other balanced splits of this instance also attain the optimum.
   ],
@@ -17262,16 +17094,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hc_btsp.source) + " -o hc.json",
-      "pred reduce hc.json --to " + target-spec(hc_btsp) + " -o bundle.json",
+      "pred reduce hc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hc.json --config " + hc_btsp_sol.source_config.map(str).join(","),
+      "pred evaluate hc.json --config " + cli-config(hc_btsp_sol.source_config),
     )
 
     *Step 1 -- Source instance.* The canonical HC instance is a graph with $n = #graph-num-vertices(hc_btsp.source.instance)$ vertices and $|E| = #graph-num-edges(hc_btsp.source.instance)$ edges.
 
-    *Step 2 -- Construction.* Build the complete graph $K_#graph-num-vertices(hc_btsp.target.instance)$ with #graph-num-edges(hc_btsp.target.instance) edges. Each original edge gets weight 1 and each non-edge gets weight 2. The target edge weights are $(#hc_btsp.target.instance.edge_weights.map(str).join(", "))$, where the #hc_btsp.target.instance.edge_weights.filter(w => w == 1).len() entries equal to 1 correspond to the $|E| = #graph-num-edges(hc_btsp.source.instance)$ source edges and the #hc_btsp.target.instance.edge_weights.filter(w => w == 2).len() entries equal to 2 correspond to the non-edges.
+    *Step 2 -- Construction.* Build the complete graph $K_#graph-num-vertices(hc_btsp.target.instance)$ with #graph-num-edges(hc_btsp.target.instance) edges. Each original edge gets weight 1 and each non-edge gets weight 2. The target edge weights are $(#fmt-values(hc_btsp.target.instance.edge_weights))$, where the #hc_btsp.target.instance.edge_weights.filter(w => w == 1).len() entries equal to 1 correspond to the $|E| = #graph-num-edges(hc_btsp.source.instance)$ source edges and the #hc_btsp.target.instance.edge_weights.filter(w => w == 2).len() entries equal to 2 correspond to the non-edges.
 
-    *Step 3 -- Verify a solution.* The source tour visits vertices in order $(#hc_btsp_sol.source_config.map(str).join(", "))$. In the target, the selected edges are those with indicator 1 in $(#hc_btsp_sol.target_config.map(str).join(", "))$, all of which have weight 1, giving bottleneck cost $= 1$ #sym.checkmark.
+    *Step 3 -- Verify a solution.* The source tour visits vertices in order $(#fmt-values(hc_btsp_sol.source_config))$. In the target, the selected edges are those with indicator 1 in $(#fmt-values(hc_btsp_sol.target_config))$, all of which have weight 1, giving bottleneck cost $= 1$ #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness. The $#graph-num-vertices(hc_btsp.source.instance)$-cycle has $#graph-num-vertices(hc_btsp.source.instance)$ rotations $times$ 2 reflections $= #(2 * graph-num-vertices(hc_btsp.source.instance))$ Hamiltonian circuits in total.
   ],
@@ -17293,15 +17125,15 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(kc_cbq.source) + " -o kclique.json",
-      "pred reduce kclique.json --to " + target-spec(kc_cbq) + " -o bundle.json",
+      "pred reduce kclique.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate kclique.json --config " + kc_cbq_sol.source_config.map(str).join(","),
+      "pred evaluate kclique.json --config " + cli-config(kc_cbq_sol.source_config),
     )
 
     #{
       let verts = ((0, 1.5), (1.5, 2.5), (3, 1.5), (1.5, 0), (4.5, 0))
       let edges = kc_cbq.source.instance.graph.edges
-      let clique-verts = kc_cbq_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+      let clique-verts = kc_cbq_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
       align(center, canvas(length: 0.8cm, {
         for (u, v) in edges {
           let in-clique = clique-verts.contains(u) and clique-verts.contains(v)
@@ -17320,7 +17152,7 @@ The following table shows concrete variable overhead for example instances, take
 
     *Step 3 -- Form the conjunctive query.* Introduce $k = #kc_cbq.target.instance.num_variables$ existential variables $y_0, y_1, y_2$ over $D$. The conjunction has $binom(k, 2) = #kc_cbq.target.instance.conjuncts.len()$ conjuncts: $R(y_0, y_1) and R(y_0, y_2) and R(y_1, y_2)$.
 
-    *Step 4 -- Verify a solution.* The satisfying assignment $(y_0, y_1, y_2) = (#kc_cbq_sol.target_config.map(str).join(", "))$ maps to vertices ${#kc_cbq_sol.target_config.map(str).join(", ")}$. Check each conjunct: $(#kc_cbq_sol.target_config.at(0), #kc_cbq_sol.target_config.at(1)) in R$ #sym.checkmark, $(#kc_cbq_sol.target_config.at(0), #kc_cbq_sol.target_config.at(2)) in R$ #sym.checkmark, $(#kc_cbq_sol.target_config.at(1), #kc_cbq_sol.target_config.at(2)) in R$ #sym.checkmark --- all pairs are adjacent, confirming the 3-clique. The source indicator is $(#kc_cbq_sol.source_config.map(str).join(", "))$, marking exactly vertices ${0, 1, 2}$.
+    *Step 4 -- Verify a solution.* The satisfying assignment $(y_0, y_1, y_2) = (#fmt-values(kc_cbq_sol.target_config))$ maps to vertices ${#fmt-values(kc_cbq_sol.target_config)}$. Check each conjunct: $(#kc_cbq_sol.target_config.at(0), #kc_cbq_sol.target_config.at(1)) in R$ #sym.checkmark, $(#kc_cbq_sol.target_config.at(0), #kc_cbq_sol.target_config.at(2)) in R$ #sym.checkmark, $(#kc_cbq_sol.target_config.at(1), #kc_cbq_sol.target_config.at(2)) in R$ #sym.checkmark --- all pairs are adjacent, confirming the 3-clique. The source indicator is $(#fmt-values(kc_cbq_sol.source_config))$, marking exactly vertices ${0, 1, 2}$.
 
     *Multiplicity:* The fixture stores one canonical witness. The triangle ${0, 1, 2}$ is the unique 3-clique in this graph, but the CBQ query has $3! = 6$ satisfying tuples (one per permutation of the three vertices); the canonical witness selects the sorted order $(0, 1, 2)$.
   ],
@@ -17342,23 +17174,23 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(x3c_ss.source) + " -o x3c.json",
-      "pred reduce x3c.json --to " + target-spec(x3c_ss) + " -o bundle.json",
+      "pred reduce x3c.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate x3c.json --config " + x3c_ss_sol.source_config.map(str).join(","),
+      "pred evaluate x3c.json --config " + cli-config(x3c_ss_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The X3C instance has universe $X = {0, dots, #(x3c_ss.source.instance.universe_size - 1)}$ ($|X| = #x3c_ss.source.instance.universe_size = 3q$, so $q = #(x3c_ss.source.instance.universe_size / 3)$) and $|cal(C)| = #x3c_ss.source.instance.subsets.len()$ subsets: #x3c_ss.source.instance.subsets.enumerate().map(((j, s)) => $S_#j = {#s.map(str).join(", ")}$).join(", ").
+    *Step 1 -- Source instance.* The X3C instance has universe $X = {0, dots, #(x3c_ss.source.instance.universe_size - 1)}$ ($|X| = #x3c_ss.source.instance.universe_size = 3q$, so $q = #(x3c_ss.source.instance.universe_size / 3)$) and $|cal(C)| = #x3c_ss.source.instance.subsets.len()$ subsets: #x3c_ss.source.instance.subsets.enumerate().map(((j, s)) => $S_#j = {#fmt-values(s)}$).join(", ").
 
     *Step 2 -- Construct StaffScheduling instance.* The reduction creates $#x3c_ss.target.instance.requirements.len()$ periods (one per universe element), each with requirement $r[i] = 1$. Each subset $S_j$ becomes a schedule $sigma_j$ with $sigma_j [i] = 1$ iff $i in S_j$, giving shifts_per_schedule $= #x3c_ss.target.instance.shifts_per_schedule$. The worker budget is $W = q = #x3c_ss.target.instance.num_workers$.
 
-    *Step 3 -- Verify a solution.* The canonical cover selects subsets via $(#x3c_ss_sol.source_config.map(str).join(", "))$: #{
-      let selected = x3c_ss_sol.source_config.enumerate().filter(((j, x)) => x == 1).map(((j, x)) => {
+    *Step 3 -- Verify a solution.* The canonical cover selects subsets via $(#fmt-values(x3c_ss_sol.source_config))$: #{
+      let selected = x3c_ss_sol.source_config.enumerate().filter(((j, x)) => x).map(((j, x)) => {
         let s = x3c_ss.source.instance.subsets.at(j)
-        $S_#j = {#s.map(str).join(", ")}$
+        $S_#j = {#fmt-values(s)}$
       })
       selected.join(", ")
-    }. These $#x3c_ss_sol.source_config.filter(x => x == 1).len()$ subsets are pairwise disjoint and cover all $#x3c_ss.source.instance.universe_size$ elements #sym.checkmark \
-    The target config $(#x3c_ss_sol.target_config.map(str).join(", "))$ assigns $w[j]$ workers to schedule $j$: total workers $= #x3c_ss_sol.target_config.sum() = q$ #sym.checkmark. Each period is covered by exactly one worker #sym.checkmark
+    }. These $#x3c_ss_sol.source_config.filter(x => x).len()$ subsets are pairwise disjoint and cover all $#x3c_ss.source.instance.universe_size$ elements #sym.checkmark \
+    The target config $(#fmt-values(x3c_ss_sol.target_config))$ assigns $w[j]$ workers to schedule $j$: total workers $= #x3c_ss_sol.target_config.sum() = q$ #sym.checkmark. Each period is covered by exactly one worker #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical witness. The instance admits a second exact cover ${S_2, S_3}$, but the fixture records only the first found.
   ],
@@ -17381,21 +17213,21 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_dmvc.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_dmvc) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_dmvc_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_dmvc_sol.source_config),
     )
 
     *Step 1 -- Source instance.* The 3-SAT formula has $n = #ksat_dmvc.source.instance.num_vars$ variables and $m = #sat-num-clauses(ksat_dmvc.source.instance)$ clauses: #{ksat_dmvc.source.instance.clauses.enumerate().map(((j, c)) => {
       let lits = c.literals.map(l => if l > 0 { $x_#l$ } else { $overline(x)_#calc.abs(l)$ })
       [$c_#j = (#lits.join($or$))$]
-    }).join(", ")}. A satisfying assignment is $(#ksat_dmvc_sol.source_config.map(str).join(", "))$.
+    }).join(", ")}. A satisfying assignment is $(#fmt-values(ksat_dmvc_sol.source_config))$.
 
     *Step 2 -- Build the vertex-cover graph.* Create one truth-setting edge $(u_i, overline(u)_i)$ per variable and one clause triangle per clause. Each triangle vertex is connected to the literal vertex of its clause position by a communication edge. The resulting graph has $|V| = 2n + 3m = #graph-num-vertices(ksat_dmvc.target.instance)$ vertices and $|E| = n + 6m = #graph-num-edges(ksat_dmvc.target.instance)$ edges.
 
     *Step 3 -- Add the decision threshold.* Wrap the constructed Minimum Vertex Cover instance in the decision predicate with bound $k = n + 2m = #ksat_dmvc.target.instance.bound$. For this example, $k = 3 + 2 dot 2 = 7$.
 
-    *Step 4 -- Verify a witness.* The target configuration $(#ksat_dmvc_sol.target_config.map(str).join(", "))$ selects #ksat_dmvc_sol.target_config.filter(x => x == 1).len() vertices, so it meets the bound exactly. Each truth-setting edge has one selected endpoint #sym.checkmark. Each clause triangle has two selected vertices #sym.checkmark. Each communication edge is covered either by its literal endpoint or by its triangle endpoint #sym.checkmark. Extracting the truth-setting choices returns $(#ksat_dmvc_sol.source_config.map(str).join(", "))$, which satisfies every clause #sym.checkmark
+    *Step 4 -- Verify a witness.* The target configuration $(#fmt-values(ksat_dmvc_sol.target_config))$ selects #ksat_dmvc_sol.target_config.filter(x => x).len() vertices, so it meets the bound exactly. Each truth-setting edge has one selected endpoint #sym.checkmark. Each clause triangle has two selected vertices #sym.checkmark. Each communication edge is covered either by its literal endpoint or by its triangle endpoint #sym.checkmark. Extracting the truth-setting choices returns $(#fmt-values(ksat_dmvc_sol.source_config))$, which satisfies every clause #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical decision witness. Different satisfying assignments may yield different size-$k$ covers of the same graph.
   ],
@@ -17417,16 +17249,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(dmvc_hc.source) + " -o dmvc.json",
-      "pred reduce dmvc.json --to " + target-spec(dmvc_hc) + " -o bundle.json",
+      "pred reduce dmvc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate dmvc.json --config " + dmvc_hc_sol.source_config.map(str).join(","),
+      "pred evaluate dmvc.json --config " + cli-config(dmvc_hc_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical Decision Minimum Vertex Cover fixture has inner graph $G$ on vertices ${0, 1, 2}$ with edges #{dmvc_hc.source.instance.inner.graph.edges.map(e => $(#e.at(0), #e.at(1))$).join(", ")} and unit weights. The bound is $k = #dmvc_hc.source.instance.bound$, and the stored cover witness is $(#dmvc_hc_sol.source_config.map(str).join(", "))$, i.e.\ $C = {1}$.
+    *Step 1 -- Source instance.* The canonical Decision Minimum Vertex Cover fixture has inner graph $G$ on vertices ${0, 1, 2}$ with edges #{dmvc_hc.source.instance.inner.graph.edges.map(e => $(#e.at(0), #e.at(1))$).join(", ")} and unit weights. The bound is $k = #dmvc_hc.source.instance.bound$, and the stored cover witness is $(#fmt-values(dmvc_hc_sol.source_config))$, i.e.\ $C = {1}$.
 
     *Step 2 -- Build the Hamiltonian graph.* There is one selector vertex $a_1$ and one 12-vertex gadget for each source edge, so the target graph has $1 + 2 dot 12 = #graph-num-vertices(dmvc_hc.target.instance)$ vertices. The path for source vertex $1$ chains the two gadgets through the connector from $(1, e_0, 6)$ to $(1, e_1, 1)$. The completed target has #graph-num-edges(dmvc_hc.target.instance) edges.
 
-    *Step 3 -- Verify a witness.* The stored Hamiltonian circuit is $(#dmvc_hc_sol.target_config.map(str).join(", "))$. Reading the cycle between selector contacts shows that the unique selector traverses first the gadget for edge $(0,1)$ in the "only vertex 1 chosen" mode and then the gadget for edge $(1,2)$ in the same mode, visiting every one of the 25 target vertices exactly once. Extracting the selector-adjacent path endpoints returns the source cover $(#dmvc_hc_sol.source_config.map(str).join(", ")) = {1}$, which indeed covers both source edges #sym.checkmark
+    *Step 3 -- Verify a witness.* The stored Hamiltonian circuit is $(#fmt-values(dmvc_hc_sol.target_config))$. Reading the cycle between selector contacts shows that the unique selector traverses first the gadget for edge $(0,1)$ in the "only vertex 1 chosen" mode and then the gadget for edge $(1,2)$ in the same mode, visiting every one of the 25 target vertices exactly once. Extracting the selector-adjacent path endpoints returns the source cover $(#fmt-values(dmvc_hc_sol.source_config)) = {1}$, which indeed covers both source edges #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical Hamiltonian circuit. Rotating or reversing that same cycle yields equivalent target witnesses with the same extracted cover.
   ],
@@ -17448,17 +17280,17 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_mvc.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_mvc) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_mvc_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_mvc_sol.source_config),
     )
 
     *Step 1 -- Source instance.* The 3-SAT formula has $n = #ksat_mvc.source.instance.num_vars$ variables and $m = #sat-num-clauses(ksat_mvc.source.instance)$ clauses: #{ksat_mvc.source.instance.clauses.enumerate().map(((j, c)) => {
       let lits = c.literals.map(l => if l > 0 { $x_#l$ } else { $overline(x)_#calc.abs(l)$ })
       [$c_#j = (#lits.join($or$))$]
-    }).join(", ")}. A satisfying assignment is $(#ksat_mvc_sol.source_config.map(str).join(", "))$, i.e.\ #{range(ksat_mvc.source.instance.num_vars).map(i => {
+    }).join(", ")}. A satisfying assignment is $(#fmt-values(ksat_mvc_sol.source_config))$, i.e.\ #{range(ksat_mvc.source.instance.num_vars).map(i => {
       let v = ksat_mvc_sol.source_config.at(i)
-      if v == 1 { $x_#(i+1) = 1$ } else { $x_#(i+1) = 0$ }
+      if v { $x_#(i+1) = 1$ } else { $x_#(i+1) = 0$ }
     }).join(", ")}.
 
     *Step 2 -- Truth-setting edges.* For each variable $x_i$, create vertices $u_i$ (index $2(i-1)$) and $overline(u)_i$ (index $2(i-1)+1$) connected by a truth-setting edge. This gives $2n = #(2 * ksat_mvc.source.instance.num_vars)$ literal vertices and $n = #ksat_mvc.source.instance.num_vars$ edges.
@@ -17467,7 +17299,7 @@ The following table shows concrete variable overhead for example instances, take
 
     *Step 4 -- Target graph dimensions.* The resulting graph has $|V| = 2n + 3m = #ksat_mvc.target.instance.graph.num_vertices$ vertices and $|E| = n + 6m = #ksat_mvc.target.instance.graph.edges.len()$ edges, with unit weights.
 
-    *Step 5 -- Verify a solution.* The satisfying assignment $(#ksat_mvc_sol.source_config.map(str).join(", "))$ maps to a vertex cover of size $n + 2m = #(ksat_mvc.source.instance.num_vars + 2 * sat-num-clauses(ksat_mvc.source.instance))$. The target configuration is $(#ksat_mvc_sol.target_config.map(str).join(", "))$: the cover selects #ksat_mvc_sol.target_config.filter(x => x == 1).len() vertices. For each truth-setting edge, exactly one endpoint is in the cover #sym.checkmark. For each clause triangle, exactly two of three vertices are covered #sym.checkmark. Each communication edge has at least one endpoint in the cover #sym.checkmark.
+    *Step 5 -- Verify a solution.* The satisfying assignment $(#fmt-values(ksat_mvc_sol.source_config))$ maps to a vertex cover of size $n + 2m = #(ksat_mvc.source.instance.num_vars + 2 * sat-num-clauses(ksat_mvc.source.instance))$. The target configuration is $(#fmt-values(ksat_mvc_sol.target_config))$: the cover selects #ksat_mvc_sol.target_config.filter(x => x).len() vertices. For each truth-setting edge, exactly one endpoint is in the cover #sym.checkmark. For each clause triangle, exactly two of three vertices are covered #sym.checkmark. Each communication edge has at least one endpoint in the cover #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness. Other valid covers correspond to different satisfying assignments of the formula.
   ],
@@ -17485,31 +17317,41 @@ The following table shows concrete variable overhead for example instances, take
 #let ksat_mono_sol = ksat_mono.solutions.at(0)
 #reduction-rule("KSatisfiability", "MonochromaticTriangle",
   example: true,
-  example-caption: [Single-clause 3-SAT instance ($n = #ksat_mono.source.instance.num_vars$, $m = #sat-num-clauses(ksat_mono.source.instance)$) reduced to a 4-triangle graph],
+  example-caption: [3-SAT encoded by NAE triangles and equality senders],
   extra: [
-    #pred-commands(
-      "pred create --example " + problem-spec(ksat_mono.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_mono) + " -o bundle.json",
-      "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_mono_sol.source_config.map(str).join(","),
-    )
+    The single-clause example has $n=3$, $m=1$, five logical variables including the sentinel and splitting variable, and seven NAE triples. Its graph has $#graph-num-vertices(ksat_mono.target.instance)$ vertices, $#graph-num-edges(ksat_mono.target.instance)$ edges and $#ksat_mono.target.instance.triangles.len()$ triangles. The stored target witness decodes to $(#fmt-values(ksat_mono_sol.source_config))$ by normalizing variable-signal colours against the sentinel colour.
+  ],
+)[
+  Use the signal-sender framework of @burrErdosLovasz1976Ramsey with the explicit seven-vertex equality sender proved below. The construction has linear graph size and preserves satisfiability in both directions. Its extraction works for every valid target colouring.
+][
+  _Equality sender._ Take two disjoint signal edges $(a,b)$ and $(c,d)$ and three private vertices $u,v,w$. Form the union of the two complete graphs on ${a,b,u,v,w}$ and ${c,d,u,v,w}$. The sender has seven vertices, seventeen edges and nineteen triangles. It contains no edge between the two signal edges.
 
-    *Step 1 -- Source instance.* The fixture uses the single clause $c_1 = (x_1 or x_2 or x_3)$. The extracted satisfying assignment is $(#ksat_mono_sol.source_config.map(str).join(", "))$.
+  In every colouring of $K_5$ without a monochromatic triangle, each vertex has exactly two incident edges of each colour: three neighbours of one colour would have all three mutual edges of the other colour. Each colour graph is consequently a five-cycle. For either colour, let $r$ be its edge count in the private triangle and $t$ its edge count in the complementary signal edge. The private vertices have total degree six in that colour, so the number of crossing edges is $6-2r$. Counting the five edges of that colour gives $5=r+(6-2r)+t$, hence $t=r-1$. Thus the signal edge has the majority colour of the private triangle. Applied to both cliques, this forces the signal edges to have equal colours.
 
-    *Step 2 -- Build the clause gadget.* Create literal vertices $p_1, p_2, p_3, n_1, n_2, n_3$ together with negation edges $(p_1, n_1)$, $(p_2, n_2)$, and $(p_3, n_3)$. For the clause, add intermediates $m_12, m_13, m_23$ and the six fan edges $(p_1, m_12)$, $(p_2, m_12)$, $(p_1, m_13)$, $(p_3, m_13)$, $(p_2, m_23)$, $(p_3, m_23)$, plus the clause triangle on $(m_12, m_13, m_23)$. The target therefore has $|V| = #graph-num-vertices(ksat_mono.target.instance)$ vertices, $|E| = #graph-num-edges(ksat_mono.target.instance)$ edges, and $#ksat_mono.target.instance.triangles.len()$ triangles.
+  Conversely, either equal signal colouring extends: make that colour the cycles $u,v,w,a,b,u$ and $u,v,w,c,d,u$ in the two cliques, and give all remaining edges the other colour. Both cycles agree on the private triangle, and each clique has no monochromatic triangle. No triangle crosses between the two signal edges.
 
-    *Step 3 -- Verify a witness.* The stored target coloring is $(#ksat_mono_sol.target_config.map(str).join(", "))$. Its first $n = #ksat_mono.source.instance.num_vars$ entries color the negation edges; reading those colors and applying the global color-swap symmetry fix yields the source assignment $(#ksat_mono_sol.source_config.map(str).join(", "))$, which satisfies $c_1$ #sym.checkmark. The same target coloring makes all four target triangles non-monochromatic #sym.checkmark.
+  _Construction._ Let the source have $n$ variables and $m$ clauses of length at most three; the typed API also admits shorter clauses. Let $q$ count its length-three clauses.
 
-    *Multiplicity:* The fixture stores one canonical target coloring. Swapping the two edge colors gives another valid witness and may flip the decoded assignment to its complement.
-  ],
-)[
-  This $O(n + m)$ reduction @garey1979[GT6] uses one positive/negative literal pair per variable and one three-vertex clause gadget per clause. The target graph has $2n + 3m$ vertices and $n + 9m$ edges.
-][
-  _Construction._ Let $phi = and_(j=1)^m (ell_1^j or ell_2^j or ell_3^j)$ be a 3-CNF formula on variables $x_1, dots, x_n$. For each variable $x_i$, create literal vertices $p_i$ and $n_i$ and add the negation edge $(p_i, n_i)$. For each clause $C_j$, map each literal $ell_r^j$ to its literal vertex $v_r^j$ ($x_i mapsto p_i$, $overline(x)_i mapsto n_i$). Introduce fresh intermediate vertices $m_12^j$, $m_13^j$, and $m_23^j$. Add fan edges $(v_1^j, m_12^j)$, $(v_2^j, m_12^j)$, $(v_1^j, m_13^j)$, $(v_3^j, m_13^j)$, $(v_2^j, m_23^j)$, and $(v_3^j, m_23^j)$, then connect the intermediates into the clause triangle $(m_12^j, m_13^j)$, $(m_12^j, m_23^j)$, $(m_13^j, m_23^j)$. Each clause gadget therefore contributes exactly four triangles: the clause triangle itself and the three fan triangles rooted at $v_1^j$, $v_2^j$, and $v_3^j$.
+  1. Apply the existing typed embedding into Satisfiability and the existing SAT-to-NAE reduction. It adds a sentinel $s$, replacing each nonempty clause $C$ by $"NAE"(C,s)$ and an empty clause by $"NAE"(s,s)$.
+  2. Replace $"NAE"(a,b)$ by $"NAE"(a,b,b)$; keep triples unchanged; replace $"NAE"(a,b,c,d)$ by $"NAE"(a,b,z)$ and $"NAE"(overline(z),c,d)$ with a fresh variable $z$. There are $N=n+1+q$ logical variables and $m+q$ resulting triples.
+  3. Give every logical variable $i$ two disjoint signal edges $P_i,M_i$. Their $4N$ vertices are disjoint from all subsequent clause vertices. For each variable include the sign-consistency triple $"NAE"(P_i,P_i,M_i)$, followed by the logical triples, using $P_i$ for a positive literal and $M_i$ for a negative one. There are $T=N+m+q$ triples in total.
+  4. Give every triple its own triangle. Connect its three edges to the three literal signals using three equality senders, each with fresh private vertices. The terminal edges already exist, so a sender adds three vertices and fifteen edges. Repeated literals use separate senders; no endpoint identification or case-specific repair is performed.
+
+  _NAE identities._ The length-two identity holds because duplicating a value does not change whether all values agree. For the length-four identity, if $a=b$ the first triple forces $z=overline(a)$; if $c=d$ the second forces $z=c$. These requirements conflict exactly when all four values agree. If either pair differs, its corresponding triple imposes no condition on $z$. This proves the identity in both directions for all input patterns.
+
+  _Triangle isolation._ Private vertices from different senders are nonadjacent. Any triangle containing a private sender vertex must lie in that sender: both other vertices belong to it, and the only edges among its four boundary vertices are its two terminal edges. This remains true after assembly because all variable signals and clause triangles have disjoint vertex sets, and senders add no boundary-to-boundary edges. A triangle containing no sender-private vertex is one of the clause triangles. Hence the target contains exactly the intended clause triangles and the nineteen triangles inside each sender, even with repeated or complementary literals and repeated variable occurrences.
+
+  _Correctness._ ($arrow.r.double$) Extend a satisfying source assignment with sentinel false using the formal SAT-to-NAE construction, and select each auxiliary value by the NAE identity. Give $P_i$ the variable value and $M_i$ its complement. All sign-consistency and logical triples are not-all-equal. Colour each clause edge with its literal signal colour, and extend every equality sender as above. Triangle isolation proves that the complete graph has no monochromatic triangle.
+
+  ($arrow.l.double$) In every valid target colouring, the sender forces each clause edge to equal its literal signal. Each sign-consistency triangle therefore enforces $"NAE"(P_i,P_i,M_i)$, so the negative signal is the complement of the positive one. Every logical triple satisfies its NAE relation. Eliminating the fresh splitting variables yields a valid assignment to the formal SAT-to-NAE target. Its extraction, which XORs the original variable values with the sentinel, satisfies the source formula. No trial assignment or source solve is needed. In particular, an empty source clause gives $"NAE"(s,s,s)$ and makes the target infeasible.
 
-  _Correctness._ ($arrow.r.double$) Fix a satisfying assignment of $phi$. Color each negation edge $(p_i, n_i)$ by the truth value of $x_i$, using color $0$ for true and color $1$ for false. For any clause, at least one of its literals is satisfied, and the four-triangle gadget has a 2-edge-coloring extending those literal choices with no monochromatic triangle; the implementation follows the verified local construction from issue #884 and colors each clause independently because the intermediates are clause-local. ($arrow.l.double$) Given a triangle-free coloring of the target graph, inspect the negation-edge colors. Either those colors, or their global complement after swapping the two colors, yields a satisfying assignment of the source formula under the same verified gadget analysis.
+  _Solution extraction._ Validate the target colouring and read the positive signal colours for the original variables and sentinel. Pass this assignment to the existing SAT-to-NAE extraction API. A global colour swap leaves the normalized source assignment unchanged.
 
-  _Solution extraction._ Read the negation-edge colors in variable order, setting $x_i = 1$ when $(p_i, n_i)$ has color $0$ and $x_i = 0$ otherwise. If that assignment does not satisfy $phi$, complement all bits; this accounts for the global color-swap symmetry of the target witness.
+  _Overhead._ The exact counts are $4N+12T$ vertices, $2N+48T$ edges and $58T$ triangles. Since $q<=m$, these are bounded by $16n+40m+16$, $50n+146m+50$ and $58n+174m+58$, respectively. All graph-size arithmetic is checked before allocation. With exactly three literals per clause the bounds are equalities.
+
+  _YES example._ For the clause $(x_1 or x_2 or x_3)$, choose values $(1,0,0)$, sentinel $0$ and splitting variable $0$. Both logical triples evaluate to $"NAE"(1,0,0)$. Here $N=5$, $T=7$, giving 104 vertices, 346 edges and 406 triangles. The signal colours extend by the sender construction.
+
+  _NO example._ On three variables, take all eight clauses obtained by choosing every combination of literal signs. Every assignment falsifies one clause. Here $N=12$, $T=28$, giving 384 vertices, 1368 edges and 1624 triangles. Any target colouring would decode to an assignment satisfying all eight clauses, a contradiction. For the empty formula on zero variables, the same uniform construction has $N=T=1$ and a valid colouring that decodes to the empty assignment.
 ]
 
 #let ksat_1in3 = load-example("KSatisfiability", "OneInThreeSatisfiability")
@@ -17520,12 +17362,12 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_1in3.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_1in3) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_1in3_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_1in3_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The source formula has one clause $c_1 = (x_1 or x_2 or x_3)$. The canonical satisfying assignment is $(#ksat_1in3_sol.source_config.map(str).join(", "))$, i.e.\ $x_1 = 0$, $x_2 = 0$, $x_3 = 1$.
+    *Step 1 -- Source instance.* The source formula has one clause $c_1 = (x_1 or x_2 or x_3)$. The canonical satisfying assignment is $(#fmt-values(ksat_1in3_sol.source_config))$, i.e.\ $x_1 = 0$, $x_2 = 0$, $x_3 = 1$.
 
     *Step 2 -- Add the global false literal.* Introduce $z_0$ (index 4) and $z_T$ (index 5), then add the forcing clause $R(z_0, z_0, z_T)$, where $R(u, v, w)$ means "exactly one of $u, v, w$ is true." In the stored witness, $(z_0, z_T) = (0, 1)$, which is the unique satisfying pattern of that clause.
 
@@ -17540,28 +17382,28 @@ The following table shows concrete variable overhead for example instances, take
     In the exported target instance these become exactly the six clauses
     $(4, 4, 5)$, $(1, 6, 9)$, $(2, 7, 9)$, $(6, 7, 10)$, $(8, 9, 11)$, $(3, 8, 4)$.
 
-    *Step 4 -- Verify a witness.* The canonical target witness is $(#ksat_1in3_sol.target_config.map(str).join(", "))$. Reading off the auxiliaries gives $(a_1, b_1, c_1, d_1, e_1, f_1) = (0, 0, 0, 1, 1, 0)$. Every target clause has exactly one true literal #sym.checkmark, and restricting to the first three coordinates recovers $(0, 0, 1)$, which satisfies the original clause #sym.checkmark.
+    *Step 4 -- Verify a witness.* The canonical target witness is $(#fmt-values(ksat_1in3_sol.target_config))$. Reading off the auxiliaries gives $(a_1, b_1, c_1, d_1, e_1, f_1) = (0, 0, 0, 1, 1, 0)$. Every target clause has exactly one true literal #sym.checkmark, and restricting to the first three coordinates recovers $(0, 0, 1)$, which satisfies the original clause #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness. This single-clause source formula has 7 satisfying assignments, and each satisfying literal pattern extends to at least one target witness by the gadget construction.
   ],
 )[
-  This $O(n + m)$ reduction @schaefer1978 @garey1979[LO4] preserves the original variables, adds two global variables $z_0$ and $z_T$, and introduces six fresh auxiliaries per clause. Each 3-SAT clause $(ell_1 or ell_2 or ell_3)$ is replaced by a five-clause gadget of exact-one constraints. The target therefore has $n + 2 + 6m$ variables and $1 + 5m$ clauses.
+  Schaefer's Lemma 3.5 @schaefer1978 expresses a three-input disjunction by five exact-one constraints. The implementation compacts the $a$ appearing source variables, adds two global constant variables and six auxiliaries per clause. A source with $m$ clauses produces $a + 2 + 6m$ target variables and $1 + 5m$ target clauses, bounded by $n + 2 + 6m$ and $1 + 5m$ in the declared source parameters.
 ][
-  _Construction._ Let $phi = and_(j=1)^m (ell_1^j or ell_2^j or ell_3^j)$ be a 3-CNF formula on variables $x_1, dots, x_n$. Introduce global variables $z_0$ and $z_T$, and add the clause $R(z_0, z_0, z_T)$, where $R(u, v, w)$ means that exactly one of the three literals is true. This forces $z_0 = 0$ and $z_T = 1$. For every source clause $C_j = (ell_1^j or ell_2^j or ell_3^j)$, introduce six fresh auxiliaries $a_j, b_j, c_j, d_j, e_j, f_j$ and append the five target clauses
+  _Construction._ Let $J$ be the sorted original indices of the appearing variables. Replace each actual source literal by the corresponding compact variable with its sign preserved. Use the existing SAT variable allocator to allocate $z_0$ and $z_T$, followed by six fresh variables $a_j, b_j, c_j, d_j, e_j, f_j$ for each source clause. The global exact-one constraint $R(z_0,z_0,z_T)$ forces $(z_0,z_T)=(0,1)$. Each native source clause has zero through three positions; fill missing positions with $z_0$. This preserves its disjunction, including the empty clause's false value. For the resulting three literals $ell_1^j,ell_2^j,ell_3^j$, append
   $
-    R(ell_1^j, a_j, d_j), quad
-    R(ell_2^j, b_j, d_j), quad
-    R(a_j, b_j, e_j), quad
-    R(c_j, d_j, f_j), quad
-    R(ell_3^j, c_j, z_0).
+    R(ell_1^j,a_j,d_j), quad R(ell_2^j,b_j,d_j), quad
+    R(a_j,b_j,e_j), quad R(c_j,d_j,f_j), quad R(ell_3^j,c_j,z_0).
   $
-  Negated source literals are copied directly; no complement variables are needed because 1-in-3 SAT clauses in this codebase may contain negated literals.
+  Here $R$ counts literal occurrences, so its repeated $z_0$ in the global constraint is intentional. Negative literals remain permitted by the target model. Every clause uses this same construction; no empty-clause target case is needed.
+
+  _Correctness._ ($arrow.r.double$) Given a satisfying source assignment, assign its appearing coordinates to the compact target variables and set the constants as above. Let $(x,y,z)$ be one padded clause's literal truth values. Set $d=(1-x)(1-y)$, $a=1-x-d$, $b=1-y-d$, $c=1-z$, $e=1-a-b$ and $f=z-d$. If $x=y=0$, satisfaction forces $z=1$, giving $(a,b,c,d,e,f)=(0,0,0,1,1,0)$. Otherwise $d=0$, $a=1-x$, $b=1-y$, $e=x+y-1$, and $f=z$; these and $c=1-z$ are Boolean because $x+y>=1$. Substitution gives $x+a+d=y+b+d=a+b+e=c+d+f=z+c=1$, satisfying all five constraints. Auxiliary variables are disjoint across clauses, so the assignments combine.
 
-  _Correctness._ ($arrow.r.double$) Suppose $phi$ is satisfiable. Set the first $n$ target variables according to any satisfying source assignment, and set $(z_0, z_T) = (0, 1)$. Consider one clause gadget. Because $ell_1^j or ell_2^j or ell_3^j = 1$, the truth triple $(ell_1^j, ell_2^j, ell_3^j)$ is one of the seven nonzero 0/1 patterns. For each such pattern there is a choice of $(a_j, b_j, c_j, d_j, e_j, f_j)$ satisfying all five exact-one clauses; the implementation uses the gadget directly and the worked example shows one such extension. Doing this independently for every clause yields a satisfying 1-in-3 assignment.
+  ($arrow.l.double$) Every target solution forces $z_0=0$. If a padded clause had $x=y=z=0$, the final constraint would force $c=1$; the fourth would then force $d=f=0$. The first two would force $a=b=1$, contradicting the third. Thus every padded disjunction is true, which implies every original clause is true. Repetition, opposite signs and missing positions do not change this argument.
 
-  ($arrow.l.double$) Suppose the target instance is satisfiable. The global clause forces $z_0 = 0$. Fix any clause gadget, and assume for contradiction that $ell_1^j = ell_2^j = ell_3^j = 0$. Then $R(ell_3^j, c_j, z_0)$ forces $c_j = 1$. Next $R(c_j, d_j, f_j)$ forces $d_j = f_j = 0$. Then $R(ell_1^j, a_j, d_j)$ and $R(ell_2^j, b_j, d_j)$ force $a_j = b_j = 1$. But now $R(a_j, b_j, e_j)$ has two true literals, impossible. Therefore every source clause has at least one true literal, so the restriction to the original variables satisfies $phi$.
+  _Solution extraction._ Validate the target assignment once using the formal evaluator and reject $"Or(false)"$. Initialize a length-$n$ false vector, then restore the compact source coordinates to their original positions in $J$. Unused source variables stay false. The resolved value types are $"Or" arrow.r "Or"$.
+
+  _Native bounds._ Since $a<=3m$, at most $9m+2$ target variables are allocated. The size of a successfully allocated native clause vector bounds $m$; with 24-byte clauses on 64-bit Rust (at least 12 bytes on 32-bit), this count stays within the signed literal domain and the native index domain. Sparse original indices never determine auxiliary allocation positions. Clause capacity is checked, allocator failures retain the formal construction error type, and the target is built through its fallible constructor. Resource exhaustion is not mathematical infeasibility.
 
-  _Solution extraction._ Return the first $n$ target coordinates unchanged, discarding $z_0$, $z_T$, and all clause auxiliaries.
 ]
 
 #let ksat_d2cif = load-example("KSatisfiability", "DirectedTwoCommodityIntegralFlow")
@@ -17572,16 +17414,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_d2cif.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_d2cif) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_d2cif_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_d2cif_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The source formula has clauses $c_1 = (x_1 or overline(x)_2 or x_3)$ and $c_2 = (overline(x)_1 or x_2 or overline(x)_3)$. The canonical satisfying assignment is $(#ksat_d2cif_sol.source_config.map(str).join(", "))$, i.e.\ $x_1 = 1$, $x_2 = 1$, $x_3 = 0$.
+    *Step 1 -- Source instance.* The source formula has clauses $c_1 = (x_1 or overline(x)_2 or x_3)$ and $c_2 = (overline(x)_1 or x_2 or overline(x)_3)$. The canonical satisfying assignment is $(#fmt-values(ksat_d2cif_sol.source_config))$, i.e.\ $x_1 = 1$, $x_2 = 1$, $x_3 = 0$.
 
     *Step 2 -- Build the lobes and clause sinks.* Each variable appears once positively and once negatively, so each lobe contains an entry vertex, an exit vertex, one dummy segment on each branch, and one literal-occurrence segment on each branch. That is $10$ vertices and $14$ arcs per variable. Adding the $4$ terminals and $2$ clause vertices gives $|V| = #ksat_d2cif.target.instance.graph.num_vertices = 36$; adding the $4$ commodity-1 chain arcs and $2$ clause-to-sink arcs gives $|A| = #ksat_d2cif.target.instance.graph.arcs.len() = 48$.
 
-    *Step 3 -- Verify a witness.* Commodity 1 uses the lower branch in the lobes of $x_1$ and $x_2$ and the upper branch in the lobe of $x_3$, exactly matching the assignment $(1, 1, 0)$. Clause $c_1$ is satisfied by $x_1$, so commodity 2 routes one unit through the positive occurrence segment of $x_1$ into $d_1$. Clause $c_2$ is satisfied by $x_2$, so a second unit routes through the positive occurrence segment of $x_2$ into $d_2$. Both clause-to-sink arcs carry one unit, so the target meets $R_2 = #ksat_d2cif.target.instance.requirement_2 = 2$ #sym.checkmark. Reading back which lower-branch entry arcs commodity 1 used recovers $(#ksat_d2cif_sol.source_config.map(str).join(", "))$ #sym.checkmark
+    *Step 3 -- Verify a witness.* Commodity 1 uses the lower branch in the lobes of $x_1$ and $x_2$ and the upper branch in the lobe of $x_3$, exactly matching the assignment $(1, 1, 0)$. Clause $c_1$ is satisfied by $x_1$, so commodity 2 routes one unit through the positive occurrence segment of $x_1$ into $d_1$. Clause $c_2$ is satisfied by $x_2$, so a second unit routes through the positive occurrence segment of $x_2$ into $d_2$. Both clause-to-sink arcs carry one unit, so the target meets $R_2 = #ksat_d2cif.target.instance.requirement_2 = 2$ #sym.checkmark. Reading back which lower-branch entry arcs commodity 1 used recovers $(#fmt-values(ksat_d2cif_sol.source_config))$ #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical witness. This source formula has multiple satisfying assignments, and each satisfying clause can choose any satisfied literal occurrence when routing commodity 2.
   ],
@@ -17600,13 +17442,19 @@ The following table shows concrete variable overhead for example instances, take
 #reduction-rule("KSatisfiability", "FeasibleRegisterAssignment",
   example: false,
 )[
-  Sethi's Reduction 3 @sethi1975 @garey1979[PO2] builds a DAG with shared-register variable leaf pairs and $p\/q\/r\/overline(r)$ clause gadgets with cyclic links, plus a preassigned register allocation. The target has $2n + 12m$ vertices, $15m$ arcs, and $K = n + 9m$ registers.
+  Sethi's Reduction 3 @sethi1973 builds a DAG with shared-register variable leaf pairs and $p\/q\/r\/overline(r)$ clause gadgets. Nonempty short clauses are padded by repeating a literal; occurring variables are compacted. For $s$ declared source variables and $c$ clauses, the target has at most $2s+12c$ vertices, $15c$ arcs, $s+9c$ registers, and $s+3c$ pairs of vertices sharing a register.
 ][
-  _Construction._ For each variable $x_k$, create two leaf nodes $s_k^+, s_k^-$ sharing register $S_k$. For each literal occurrence $Y_(i,j)$ in clause $C_i$, create four nodes $p_(i,j), q_(i,j), r_(i,j), overline(r)_(i,j)$ with internal arcs $q_(i,j) -> p_(i,j) -> r_(i,j)$ and cyclic links $q_(i,1) -> overline(r)_(i,2)$, $q_(i,2) -> overline(r)_(i,3)$, $q_(i,3) -> overline(r)_(i,1)$. Nodes $r_(i,j)$ and $overline(r)_(i,j)$ share register $R_(i,j)$. If $Y_(i,j) = x_k$: $r_(i,j) -> s_k^+$ and $overline(r)_(i,j) -> s_k^-$; if $Y_(i,j) = overline(x)_k$: swap the attachments.
+  _Native normalization._ If any clause is empty, return the three-vertex DAG with dependencies $(2,0),(2,1)$ and register assignment $(0,0,1)$. Both predecessors must stay live until vertex 2, so neither can overwrite the other's register; this target is infeasible. Otherwise collect appearing source indices in increasing order and store their inverse map. Pad each nonempty clause to three literal occurrences by repeating its first literal. Repetition preserves a disjunction, and each occurrence has its own gadget and register pair, so no distinct-variable assumption is needed. An empty conjunction yields the empty DAG and empty realization.
+
+  _Construction._ Let $a$ be the number of appearing variables. For each compact variable $x_k$, create leaves $s_k^+,s_k^-$ sharing register $S_k$. For every clause position $(i,j)$ create $p_(i,j),q_(i,j),r_(i,j),overline(r)_(i,j)$. The $p$ and $q$ registers are unique, while $r$ and $overline(r)$ share a fresh register $R_(i,j)$. Arcs point from a consumer to its dependency: $q_(i,j) -> p_(i,j) -> r_(i,j)$ and $q_(i,j) -> overline(r)_(i,j+1)$, with positions cyclic modulo three. For positive literal $x_k$, add $r_(i,j) -> s_k^+$ and $overline(r)_(i,j) -> s_k^-$; reverse these attachments for a negative literal. This DAG has four levels: leaves, $r/overline(r)$, $p$, and $q$.
+
+  _Forward correctness._ Follow Sethi's Lemma 5.5 @sethi1973. For each variable, execute its true-literal leaf, all direct consumers of that leaf, and then its opposite leaf. Every old leaf value is consumed before the shared register is overwritten; exactly one of each $r/overline(r)$ pair has executed. For every occurrence whose $r$ has executed, execute its $p$ and then $overline(r)$, consuming $r$ before overwriting its register. Now all $overline(r)$ vertices are available. In each clause choose a true occurrence $j$. Its $p_j$ is available, so execute $q_j$. This consumes $overline(r)_(j+1)$ and releases that register; if $r_(j+1)$ is missing, execute it and its $p$, then execute $q_(j+1)$. Continue around all three positions. Every dependency is met and every register overwrite follows the last use of its former value. Occurrence registers are disjoint across clauses, so these schedules combine.
 
-  _Correctness._ ($arrow.r.double$) If $phi$ is satisfiable, place the truth-selected leaf first for each variable, then unlock each clause gadget starting from a satisfied literal. ($arrow.l.double$) The cyclic links force at least one position $j$ per clause where $r_(i,j)$ appears before $overline(r)_(i,j)$; shared-register order transfer forces the corresponding literal leaf to appear first, encoding a true literal.
+  _Backward correctness._ Lemma 5.7 transfers relative order between two shared-register pairs: if $u_1$ depends on $v_1$, $u_2$ on $v_2$, and each pair shares a register, then $u_1 < u_2$ iff $v_1 < v_2$ in every realization. A reversed order would overwrite a predecessor while its consumer is still pending. Apply this with $u_1=r$, $u_2=overline(r)$, and the two attached literal leaves. If every position in a clause had $overline(r)_j < r_j$, its register conflict would force $q_(j-1) < r_j$, whereas dependencies force $r_j < p_j < q_j$. Combining these inequalities cyclically is impossible. Thus at least one $r_j < overline(r)_j$, and order transfer makes its literal true. Every source clause is satisfied after undoing repetition and compaction.
 
-  _Solution extraction._ For each variable $x_k$, set $tau(x_k) = 1$ iff $s_k^+$ appears before $s_k^-$ in the realization.
+  _Extraction._ Validate the complete position vector and reject $"Or(false)"$. Set each appearing source variable true iff its compact positive leaf occurs before its negative leaf. Restore original indices through the inverse map and assign false to unused variables. The target model's permitted last-use overwrite does not weaken the order-transfer proof: neither member of a shared pair is the other member's consumer in this construction.
+
+  _Bounds and native arithmetic._ For the ordinary construction $a <= min(s,3c)$, so the displayed upper bounds follow from the exact counts $2a+12c$, $15c$, $a+9c$, and $a+3c$. The fixed NO target has counts $(3,2,2,1)$ and also satisfies the bounds whenever an empty clause exists; the empty YES target has all counts zero. Let $I="isize::MAX"$. A native source clause stores a vector object of 24 bytes on 64-bit or 12 bytes on 32-bit, so successful allocation of its outer vector bounds $c$ by $I/24$ or $I/12$. Therefore $2a+12c <= 18c$, $a+9c <= 12c$, and $15c$ fit $"usize"$ before target allocation on both architectures. Once the target register-assignment vector is allocated, every indexed vertex is within that vector. All same-register groups have size two except the fixed target's singleton, so pair counting introduces no large product. Checked construction arithmetic is retained; allocation and solver limits are not infeasibility proofs.
 ]
 
 #let ksat_rs = load-example("KSatisfiability", "RegisterSufficiency")
@@ -17617,29 +17465,38 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_rs.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_rs) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_rs_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_rs_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical source formula is $phi = (x_1 or overline(x)_2 or x_3) and (overline(x)_1 or x_2 or overline(x)_3)$. The stored satisfying assignment is $(#ksat_rs_sol.source_config.map(str).join(", "))$.
+    *Step 1 -- Source instance.* The canonical source formula is $phi = (x_1 or overline(x)_2 or x_3) and (overline(x)_1 or x_2 or overline(x)_3)$. The stored satisfying assignment is $(#fmt-values(ksat_rs_sol.source_config))$.
 
     *Step 2 -- Build Sethi's DAG.* Here $n = #ksat_rs.source.instance.num_vars$, $m = #sat-num-clauses(ksat_rs.source.instance)$, and $b = max(0, 2n - m) = 4$. The construction creates $|A| = 2n + 1 = 7$, $|B| = b = 4$, $|C| = m = 2$, $|F| = 3m = 6$, $|M| = 3$, $|R| = n(n+1) = 12$, $|S| = |T| = n^2 = 9$, $|U| = 2n = 6$, $|W| = |Z| = n = 3$, and $|X| = 2n = 6$, for a total of $|V| = #ksat_rs.target.instance.num_vertices = 70$ vertices. The target bound is $K = #ksat_rs.target.instance.bound = 23$, and the construction emits $|A| = #ksat_rs.target.instance.arcs.len() = 152$ arcs. For clause $C_1$, the six literal-lock arcs are $(x_1^+, f_(1,1))$, $(x_2^-, f_(1,2))$, $(x_3^+, f_(1,3))$, $(x_1^-, f_(1,2))$, $(x_1^-, f_(1,3))$, and $(x_2^+, f_(1,3))$.
 
-    *Step 3 -- Verify extraction at $w_n$.* The target witness is a computation ordering on $70$ vertices. Reading the prefix ending at $w_3$ marks exactly those variables whose $x_k^+$ node has already been computed, which reconstructs $(#ksat_rs_sol.source_config.map(str).join(", "))$ #sym.checkmark. Evaluating the original 3-SAT formula under that assignment returns true #sym.checkmark
+    *Step 3 -- Verify extraction at $w_n$.* The target witness is a computation ordering on $70$ vertices. Reading the prefix ending at $w_3$ marks exactly those variables whose $x_k^+$ node has already been computed, which reconstructs $(#fmt-values(ksat_rs_sol.source_config))$ #sym.checkmark. Evaluating the original 3-SAT formula under that assignment returns true #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical satisfying assignment. Different satisfying assignments can induce different valid computation orders in the target DAG.
   ],
 )[
-  Sethi's Reduction I / Theorem 3.11 @sethi1975 @garey1979[PO1] builds a dependency DAG whose register pressure mirrors a literal-assignment phase followed by a clause-verification phase. For a 3-CNF formula with $n$ variables, $m$ clauses, and $b = max(0, 2n - m)$, the target has $3n^2 + 9n + 4m + b + 4$ vertices, $6n^2 + 19n + 16m + 2b + 1$ arcs, and register bound $K = 3m + 4n + 1 + b$.
+  Sethi's Reduction 1 and Theorem 3.11 @sethi1973 encode literal choices through register pressure. We extend the construction to the native zero-to-three-literal clause domain by truth-preserving normalization and explicit empty-formula boundaries. The original padding $b=max(2n-m,0)$ is retained.
 ][
-  _Construction._ Let $phi = and_(i=1)^m C_i$ be a 3-CNF formula over variables $x_1, dots, x_n$, where $C_i = (Y_(i,1) or Y_(i,2) or Y_(i,3))$. Define $b = max(0, 2n - m)$. Create node families $A = {a_j : 1 <= j <= 2n+1}$, $B = {b_j : 1 <= j <= b}$, $C = {c_i : 1 <= i <= m}$, $F = {f_(i,j) : 1 <= i <= m, 1 <= j <= 3}$, $M = {"initial", d, "final"}$, $R = {r_(k,j) : 1 <= k <= n, 1 <= j <= 2n-2k+2}$, $S = {s_(k,j) : 1 <= k <= n, 1 <= j <= 2n-2k+1}$, $T = {t_(k,j) : 1 <= k <= n, 1 <= j <= 2n-2k+1}$, $U = {u_(k,1), u_(k,2) : 1 <= k <= n}$, $W = {w_k : 1 <= k <= n}$, $X = {x_k^+, x_k^- : 1 <= k <= n}$, and $Z = {z_k : 1 <= k <= n}$. Add the ten arc families from Sethi's theorem exactly as stated in the issue: $"initial"$ depends on every node in $A union B union F union U$, every node in $C union R union S union T union W$ depends on $"initial"$, $"final"$ depends on $W union X union Z union {"initial", d}$, each variable gadget links $x_k^+$ and $x_k^-$ to $z_k$, $u_(k,1)$, $u_(k,2)$, $s_(k,*)$, $t_(k,*)$, $r_(k,*)$, and each clause gadget links $c_i$ to $w_n$, $z_n$, its three $f_(i,j)$ nodes, and the literal-lock edges determined by whether $Y_(i,j)$ is positive or negative.
+  _Normalization._ A formula containing an empty clause is false; output a single output vertex with register bound zero. An empty conjunction is true; output the empty graph with bound zero. In every other case collect the appearing variables in increasing original-index order, map them to $1,dots,n$, and retain the inverse map. Keep the original clause order and literal occurrences. Repeat the first literal of each nonempty short clause until it has three positions. This preserves disjunction truth, gives $n,m>=1$, and never introduces a fictitious vertex for a missing literal. Let $Y_(i,j)$ denote the literal at position $j$ of clause $i$, allowing repeated literals.
+
+  _DAG construction._ Put $b=max(2n-m,0)$ and $K=3m+4n+1+b$. Arcs $(v,u)$ mean that $v$ depends on $u$. Create the following disjoint families, with one-based subscripts:
+  $ |A|=2n+1, quad |B|=b, quad |C|=m, quad F={f_(i,j):1<=i<=m,1<=j<=3}, $
+  $ M={"initial",d,"final"}, quad R_k={r_(k,j):1<=j<=2n-2k+2}, $
+  $ S_k={s_(k,j):1<=j<=2n-2k+1}, quad T_k={t_(k,j):1<=j<=2n-2k+1}, $
+  $ U_k={u_(k,1),u_(k,2)}, quad W={w_k}, quad X={x_k^+,x_k^-}, quad Z={z_k}, quad 1<=k<=n. $
+  Add arcs from `initial` to $A union B union F union U$, from every $C,R,S,T,W$ vertex to `initial`, and from `final` to $W union X union Z union {"initial",d}$. For each $k$, $x_k^+$ depends on $z_k,u_(k,1),S_k$; $x_k^-$ depends on $z_k,u_(k,2),T_k$; $w_k$ depends on both $U_k$ vertices; and $z_k$ depends on $R_k$. For $k>=2$, $z_k$ also depends on $w_(k-1),z_(k-1)$. Each $c_i$ depends on $w_n,z_n$ and all three $f_(i,j)$; $d$ depends on $B union C$. Finally, $Y_(i,j)$ denotes its corresponding positive or negative $X$ vertex: add $(Y_(i,j),f_(i,j))$ for every position and $(overline(Y)_(i,j),f_(i,l))$ whenever $j<l$. These are the original literal-lock arcs, interpreted per occurrence even when literals repeat.
+
+  _Forward schedule._ Compute the leaves $A,B,F,U$, then `initial`. For each $k$ in order, compute $R_k,z_k$, then $S_k,x_k^+$ if variable $k$ is true or $T_k,x_k^-$ if false, then $w_k$. Compute all $c_i$, then $d$, then the unused $S_k$ or $T_k$ groups and their corresponding literal vertices, and finally `final`. All dependencies are respected. The initial leaves occupy exactly $K$ registers; `initial` replaces one $A$ leaf and releases the other $2n$. The variable stages fit because $R_k$ needs $2n-2k+2$ temporary registers and the chosen literal group needs $2n-2k+1$. In a satisfied clause, its first true occurrence releases its $F$ register when $c_i$ is computed: all earlier opposite literals and that true literal have already executed. No extra register is required. Computing $d$ releases $m+b-1>=2n-1$ registers, enough to finish all remaining auxiliary groups. The last-use overwrite rule agrees with Sethi's Game 1.
 
-  _Correctness._ ($arrow.r.double$) Suppose $phi$ is satisfiable under assignment $tau$. Execute Sethi's eight-stage schedule. In the variable phase, the chain gadgets force a choice between the positive and negative side of each variable, and the schedule can be arranged so that by the moment $w_n$ is computed, $x_k^+$ has appeared iff $tau(x_k) = 1$. Because every clause has a satisfied literal, the corresponding $f_(i,j)$ node is unlocked during the clause phase, and the lock edges from the opposite literals prevent incompatible clause traversals. Sethi proves that this entire computation uses at most $K$ registers, so the target Register Sufficiency instance is feasible.
+  _Arbitrary-order variable invariant._ Auxiliary vertices in $R_k,S_k,T_k$ have the held `initial` value as their only predecessor and their designated parent as their only consumer. Delaying such a vertex until immediately before its parent preserves all parent orders and cannot increase the peak live set. Thus arbitrary bounded computations admit this grouped form for the counting argument. Before any clause executes, all $F,B$ values and `initial` remain held. Just after `initial`, $2n$ registers are free. The $R_1$ group needs all of them, preventing any premature $w$ vertex. Inductively, just after $z_k$, there are $2n-2k+1$ free registers. Computing one of $x_k^+,x_k^-$ consumes one permanently until its $U$ value can be released; the opposite auxiliary group then no longer fits. Computing $w_k$ first also consumes that one free register and permits neither literal. After $w_k$, exactly $2n-2k$ registers are free, all needed by $R_(k+1)$; older unchosen literal groups require more. Therefore, at the snapshot immediately after $w_n$, at most one literal per variable has executed and no register is free. This does not require every variable to have a selected literal.
 
-  ($arrow.l.double$) Suppose the target instance has a computation using at most $K$ registers. Stop immediately after $w_n$ is computed. At that snapshot, for each variable gadget, at most one of $x_k^+$ and $x_k^-$ has been computed. Define $tau(x_k) = 1$ iff $x_k^+$ has already been computed. Now assume some clause $C_i$ is false under $tau$. Then every literal $Y_(i,j)$ is false, so the corresponding literal node has not yet been computed by the $w_n$ snapshot. Consequently each $f_(i,j)$ still has an uncomputed literal predecessor. Sethi's clause-phase invariant leaves no free register between the computation of $w_n$ and the later computation of $d$, so such a clause node $c_i$ could not be discharged without exceeding $K$, contradiction. Therefore every clause contains a true literal under $tau$, and $phi$ is satisfiable.
+  _Clause locks and backward direction._ Before $d$, a completed $c_i$ retains its value. Its $F$ value at position $j$ can be released only if $Y_(i,j)$ and all earlier opposite literals have executed. Two released positions $j<l$ would require both $Y_(i,j)$ and its opposite to have executed, contradicting the variable invariant. This argument allows repetitions and complementary occurrences. Each $c_i$ thus releases at most one $F$ value, consumed immediately by its own output. No first free register can appear between $w_n$ and $d$, so unchosen literal groups remain impossible during the clause phase. Every computed $c_i$ must release exactly one $F$ value, whose literal has executed. Assign each appearing source variable true exactly when its positive literal preceded $w_n$; an executed negative literal then makes that variable false. Every clause has a true literal, proving source feasibility for every bounded target computation. The fixed boundary targets have the stated truth values because an output needs one register and the empty graph needs none.
 
-  _Solution extraction._ Given a target computation ordering, let $t(w_n)$ be the position of $w_n$. Output $x_k = 1$ exactly when $t(x_k^+) < t(w_n)$. This is the corrected extraction rule: the snapshot is taken at $w_n$, not $z_n$, and the sign test uses $x_k^+$, not $x_k^-$.
+  _Extraction and native bounds._ Call the formal target validator once and reject `Or(false)`. For the empty-graph YES target return an all-false vector of the original source length. Otherwise use the $w_n$ snapshot, reject two executed opposite literals, restore original positions, and set unused variables false. The native value types are `Or` on both sides, with `Vec<bool>` source and vertex-to-position `Vec<usize>` target solutions. The ordinary target has $3n^2+9n+4m+b+4$ vertices, $6n^2+19n+16m+2b+1$ arcs, and one sink. For original counts $s,c$, upper bounds are $3s^2+11s+4c+4$, $6s^2+23s+16c+1$, $6s+3c+1$ registers, and one sink; both fixed targets also obey them. Layout squares, totals, register bound and arc capacity are checked before allocation; subsequent nonnegative offsets are bounded by those totals. Allocation and solver limits are reported as resource failures, not infeasibility. No endpoint or variant changes.
 ]
 
 #reduction-rule("FeasibleRegisterAssignment", "ILP",
@@ -17670,20 +17527,20 @@ The following table shows concrete variable overhead for example instances, take
 
 #let mvc_mfas = load-example("MinimumVertexCover", "MinimumFeedbackArcSet")
 #let mvc_mfas_sol = mvc_mfas.solutions.at(0)
-#let mvc_mfas_cover = mvc_mfas_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
-#let mvc_mfas_fas = mvc_mfas_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let mvc_mfas_cover = mvc_mfas_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
+#let mvc_mfas_fas = mvc_mfas_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #reduction-rule("MinimumVertexCover", "MinimumFeedbackArcSet",
   example: true,
   example-caption: [Triangle graph ($n = #graph-num-vertices(mvc_mfas.source.instance)$, $|E| = #graph-num-edges(mvc_mfas.source.instance)$): VC $arrow.r$ FAS via vertex splitting],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(mvc_mfas.source) + " -o mvc.json",
-      "pred reduce mvc.json --to " + target-spec(mvc_mfas) + " -o bundle.json",
+      "pred reduce mvc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate mvc.json --config " + mvc_mfas_sol.source_config.map(str).join(","),
+      "pred evaluate mvc.json --config " + cli-config(mvc_mfas_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The source graph $G$ has $n = #graph-num-vertices(mvc_mfas.source.instance)$ vertices and $|E| = #graph-num-edges(mvc_mfas.source.instance)$ edges: $E = {#mvc_mfas.source.instance.graph.edges.map(e => "(" + e.map(str).join(", ") + ")").join(", ")}$ with weights $bold(w) = (#mvc_mfas.source.instance.weights.map(str).join(", "))$.
+    *Step 1 -- Source instance.* The source graph $G$ has $n = #graph-num-vertices(mvc_mfas.source.instance)$ vertices and $|E| = #graph-num-edges(mvc_mfas.source.instance)$ edges: $E = {#mvc_mfas.source.instance.graph.edges.map(e => "(" + fmt-values(e) + ")").join(", ")}$ with weights $bold(w) = (#fmt-values(mvc_mfas.source.instance.weights))$.
 
     *Step 2 -- Construction.* Each vertex $v$ splits into $v^"in"$ and $v^"out"$, yielding $2n = #mvc_mfas.target.instance.graph.num_vertices$ nodes in the target digraph $H$. Internal arcs $(v^"in", v^"out")$ carry weight $w(v)$: #{
       let arcs = mvc_mfas.target.instance.graph.arcs
@@ -17697,7 +17554,7 @@ The following table shows concrete variable overhead for example instances, take
       arcs.enumerate().filter(((i, a)) => i >= n).map(((i, a)) => "(" + str(a.at(0)) + ", " + str(a.at(1)) + ") w=" + str(ws.at(i))).join(", ")
     }. Total: #mvc_mfas.target.instance.graph.arcs.len() arcs ($#mvc_mfas.source.instance.graph.num_vertices$ internal + $#(mvc_mfas.target.instance.graph.arcs.len() - mvc_mfas.source.instance.graph.num_vertices)$ crossing).
 
-    *Step 3 -- Verify a solution.* The source cover is $C = {#mvc_mfas_cover.map(str).join(", ")}$ (size #mvc_mfas_cover.len()). The target FAS selects arcs at indices ${#mvc_mfas_fas.map(str).join(", ")}$, which are the internal arcs #{
+    *Step 3 -- Verify a solution.* The source cover is $C = {#fmt-values(mvc_mfas_cover)}$ (size #mvc_mfas_cover.len()). The target FAS selects arcs at indices ${#fmt-values(mvc_mfas_fas)}$, which are the internal arcs #{
       let arcs = mvc_mfas.target.instance.graph.arcs
       mvc_mfas_fas.map(i => "(" + str(arcs.at(i).at(0)) + ", " + str(arcs.at(i).at(1)) + ")").join(", ")
     } -- exactly the internal arcs of cover vertices $v^"in" arrow.r v^"out"$ for $v in C$. No crossing arc (weight $M = #mvc_mfas.target.instance.weights.slice(mvc_mfas.source.instance.graph.num_vertices).at(0)$) is selected, confirming the optimal FAS uses only internal arcs #sym.checkmark
@@ -17722,9 +17579,9 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_kc.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_kc) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_kc_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_kc_sol.source_config),
     )
 
     *Step 1 -- Source instance.* The 3-CNF formula $phi$ has $m = #ksat_kc.source.instance.clauses.len()$ clauses over $n = #ksat_kc.source.instance.num_vars$ variables:
@@ -17735,22 +17592,20 @@ The following table shows concrete variable overhead for example instances, take
       lits.join($or$)
     }).join($) and ($)) $
 
-    *Step 2 -- Construct the conflict graph.* Create one vertex per literal position: vertex $3j + p$ represents position $p$ ($0$-indexed) in clause $j$, giving $|V| = 3 dot #ksat_kc.source.instance.clauses.len() = #ksat_kc.target.instance.graph.num_vertices$ vertices. Connect $(j_1, p_1)$ and $(j_2, p_2)$ whenever $j_1 != j_2$ and the two literals are not contradictory. The resulting graph has $|E| = #ksat_kc.target.instance.graph.edges.len()$ edges: $E = {#ksat_kc.target.instance.graph.edges.map(e => "(" + e.map(str).join(", ") + ")").join(", ")}$. Set $k = m = #ksat_kc.target.instance.k$.
+    *Step 2 -- Construct the compatibility graph.* Enumerate actual literal occurrences in clause order. For this fixture there are six occurrence vertices and anchor $6$. Connect compatible occurrences from different clauses, then connect the anchor to all six occurrences. The target has $#ksat_kc.target.instance.graph.num_vertices$ vertices, $#ksat_kc.target.instance.graph.edges.len()$ edges, and threshold $k=m+1=#ksat_kc.target.instance.k$.
 
-    *Step 3 -- Verify a solution.* The satisfying assignment $(x_1, x_2, x_3) = (#ksat_kc_sol.source_config.map(str).join(", "))$ makes literal $x_3$ true in clause 0 (position 2, vertex 2) and literal $overline(x_1)$ true in clause 1 (position 0, vertex 3). The target configuration $bold(x) = (#ksat_kc_sol.target_config.map(str).join(", "))$ selects vertices #{
-      ksat_kc_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(" and ")
-    }, which form a clique (edge $(2, 3) in E$ #sym.checkmark) of size $k = #ksat_kc.target.instance.k$ spanning both clause groups #sym.checkmark
+    *Step 3 -- Verify a solution.* The assignment $(#fmt-values(ksat_kc_sol.source_config))$ makes occurrence $2$ ($x_3$) and occurrence $3$ ($overline(x_1)$) true. Together with anchor $6$, these form a triangle. The stored target vector is $(#fmt-values(ksat_kc_sol.target_config))$; decoding its literal vertices returns the stored source assignment #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical witness. The formula has multiple satisfying assignments; each induces at least one $k$-clique by choosing one true literal per clause.
   ],
 )[
-  Assign one vertex per literal position $(j, p)$; connect vertices from different clauses whose literals are not contradictory. A $k$-clique selects one consistent true literal per clause.
+  Karp's literal-compatibility construction @karp1972 is extended with an anchor and, when needed, isolated padding. This keeps the same endpoint and handles both empty formulas and the shorter clauses accepted by the native `new_allow_less` API.
 ][
-  _Construction._ Given 3-CNF $phi = C_1 and dots.c and C_m$ over $n$ variables, construct $G = (V, E)$ with $V = {(j, p) : 1 <= j <= m, 1 <= p <= 3}$, $|V| = 3m$. Edge between $(j_1, p_1)$ and $(j_2, p_2)$ iff $j_1 != j_2$ and $ell_(j_1, p_1) != not ell_(j_2, p_2)$. Set $k = m$.
+  _Construction._ Let $m$ be the clause count and $t=sum_j |C_j|$ the actual occurrence count. Number literal vertices in clause/position order, with stored variable indices and polarities. Set $N=max(t,m)+1$, $k=m+1$, and anchor $a=t$. Connect two literal vertices iff they come from different clauses and are not opposite polarities of the same variable; then connect $a$ to all literal vertices. Any remaining vertices are isolated. Thus $1<=k<=N$, $N<=3m+1$, and the edge count is at most $9m^2+3m$.
 
-  _Correctness._ ($arrow.r.double$) A satisfying assignment picks one true literal per clause; these vertices form a clique since they span all clauses without contradiction. ($arrow.l.double$) A $k$-clique has exactly one vertex per clause group; the selected literals are pairwise non-contradictory, defining a satisfying assignment.
+  _Correctness._ A satisfying assignment selects a true occurrence from each clause; these mutually compatible vertices and the anchor form a $k$-clique. Conversely, the literal subgraph contains at most one vertex per clause in a clique, hence has clique number at most $m$. For $m>0$, any clique of size at least $k>=2$ excludes padding isolates and must contain the anchor plus one occurrence from every clause. Their polarities consistently satisfy all clauses. An empty clause prevents such a clique. For $m=0$, the target is a single anchor with $k=1$, and every source assignment satisfies the empty conjunction.
 
-  _Solution extraction._ For selected vertex $v$: clause $j = floor(v / 3)$, position $p = v mod 3$. If literal $ell_(j,p) = x_i$ set $x_i = 1$; if $ell_(j,p) = not x_i$ set $x_i = 0$.
+  _Solution extraction._ Validate the complete target selection and its true clique predicate first. Decode the literal vertices via their stored source indices and signs, leaving unselected variables false; ignore the nonliteral anchor and padding by the defined mapping. Checked occurrence and output counts precede allocation. Formal `CNFClause::variables` supplies validated indices. Normal CLI/serde still requires exactly three literals per actual clause; native short-clause support does not change variants or serialization.
 ]
 
 #let ksat_co = load-example("KSatisfiability", "CyclicOrdering")
@@ -17761,35 +17616,40 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_co.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_co) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_co_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_co_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical formula is $phi = (x_1 or x_2 or x_3)$ with $n = #ksat_co.source.instance.num_vars$ variables and $m = #ksat_co.source.instance.clauses.len()$ clause. The stored satisfying assignment is $(#ksat_co_sol.source_config.map(str).join(", "))$, so every literal in the clause is true.
+    *Step 1 -- Source instance.* The canonical formula is $phi = (x_1 or x_2 or x_3)$ with $n = #ksat_co.source.instance.num_vars$ variables and $m = #ksat_co.source.instance.clauses.len()$ clause. The stored satisfying assignment is $(#fmt-values(ksat_co_sol.source_config))$, so every literal in the clause is true.
 
     *Step 2 -- Create variable and clause elements.* The reduction introduces three variable elements per Boolean variable, giving variable triples $(alpha_1, beta_1, gamma_1) = (0, 1, 2)$, $(alpha_2, beta_2, gamma_2) = (3, 4, 5)$, and $(alpha_3, beta_3, gamma_3) = (6, 7, 8)$. The single clause adds five auxiliary elements $(j, k, l, m, n) = (9, 10, 11, 12, 13)$, so the target has $3n + 5m = #ksat_co.target.instance.num_elements$ elements total.
 
-    *Step 3 -- Emit the ten cyclic-ordering triples.* Because the clause literals are $(x_1, x_2, x_3)$, the literal-orientation triples are the forward variable triples. The target constraints are exactly #{ksat_co.target.instance.triples.map(t => "(" + t.map(str).join(", ") + ")").join(", ")}, so $|Delta| = #ksat_co.target.instance.triples.len() = 10m$.
+    *Step 3 -- Emit the ten cyclic-ordering triples.* Because the clause literals are $(x_1, x_2, x_3)$, the literal-orientation triples are the forward variable triples. The target constraints are exactly #{ksat_co.target.instance.triples.map(t => "(" + fmt-values(t) + ")").join(", ")}, so $|Delta| = #ksat_co.target.instance.triples.len() = 10m$.
 
-    *Step 4 -- Verify a solution.* The target witness permutation is $(#ksat_co_sol.target_config.map(str).join(", "))$. It satisfies all ten cyclic-order constraints #sym.checkmark. For each variable triple, the forward orientation $(alpha_i, beta_i, gamma_i)$ is _not_ derived by this permutation, so extraction returns $(#ksat_co_sol.source_config.map(str).join(", "))$, which satisfies $phi$ #sym.checkmark
+    *Step 4 -- Verify a solution.* The target witness permutation is $(#fmt-values(ksat_co_sol.target_config))$. It satisfies all ten cyclic-order constraints #sym.checkmark. For each variable triple, the forward orientation $(alpha_i, beta_i, gamma_i)$ is _not_ derived by this permutation, so extraction returns $(#fmt-values(ksat_co_sol.source_config))$, which satisfies $phi$ #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical witness. Any cyclic permutation of the target order is also valid, and other satisfying assignments of $phi$ induce additional valid cyclic orders.
   ],
 )[
-  This $O(n + m)$ reduction @garey1979 @galilMegiddo1977 represents each variable by a three-element orientation gadget and each clause by five auxiliary elements linked through ten cyclic-ordering triples. For $n$ variables and $m$ clauses it produces $3n + 5m$ target elements and $10m$ triples.
+  This reduction @galilMegiddo1977 first normalizes clauses to three distinct, globally ordered variables. With $s$ declared source variables and $c$ source clauses it produces at most $3s + 26c + 3$ elements and $40c + 2$ cyclic-order constraints. The original ten-constraint gadget is applied to the normalized formula.
 ][
-  _Construction._ Let $phi$ be a 3-CNF formula with variables $x_1, dots, x_n$ and clauses $C_1, dots, C_m$. For each variable $x_i$, create three target elements $alpha_i, beta_i, gamma_i$. For a positive literal $x_i$, define its associated cyclically ordered triple as $(alpha_i, beta_i, gamma_i)$; for a negative literal $not x_i$, define it as $(alpha_i, gamma_i, beta_i)$. For each clause $C_nu = (ell_1 or ell_2 or ell_3)$, write the three associated literal triples as $(a, b, c)$, $(d, e, f)$, and $(g, h, i)$. Add five fresh auxiliary elements $j_nu, k_nu, l_nu, m_nu, n_nu$ and the ten cyclic-ordering triples
+  _Normalization._ An empty clause maps to the fixed NO target on three elements with constraints $(0,1,2)$ and $(0,2,1)$. Otherwise remove repeated literals within each clause and discard clauses containing both signs of a variable. Compact the remaining appearing variables in increasing original-index order, retaining the inverse map. Replace a two-literal clause $(a or b)$ by $(a or b or u) and (a or b or not u)$ with fresh $u$. Replace a unit clause $a$ by the four clauses $(a or (plus.minus u) or (plus.minus v))$ over both independent signs, with fresh $u,v$. These conjunctions are true for every auxiliary assignment when the original clause is true and false for at least one constituent clause under every auxiliary assignment when the original clause is false. Every resulting clause has three distinct variables; order its literals by increasing variable index. If no clauses remain, use the one-element unconstrained YES target.
+
+  _Construction._ Let the normalized formula have $N$ variables and $M$ clauses. For each variable $x_i$, create three target elements $alpha_i, beta_i, gamma_i$. A positive literal has associated triple $(alpha_i,beta_i,gamma_i)$; a negative literal has $(alpha_i,gamma_i,beta_i)$. For each normalized clause, let its three literal triples be $(a,b,c)$, $(d,e,f)$, $(g,h,i)$ in increasing variable order. Add five fresh elements $j,k,l,m,n$ and the ten constraints
   $
-  (a, c, j_nu), (b, j_nu, k_nu), (c, k_nu, l_nu), (d, f, j_nu), (e, j_nu, l_nu),
-  (f, l_nu, m_nu), (g, i, k_nu), (h, k_nu, m_nu), (i, m_nu, n_nu), (n_nu, m_nu, l_nu).
+  (a,c,j), (b,j,k), (c,k,l), (d,f,j), (e,j,l),
+  (f,l,m), (g,i,k), (h,k,m), (i,m,n), (n,m,l).
   $
+  There are $3N+5M$ elements and $10M$ constraints before the fixed boundary targets.
+
+  _Correctness._ ($arrow.r.double$) Extend a satisfying source assignment to the fresh Boolean variables. Order all normalized variables by index, using the consecutive element block $(alpha_i,gamma_i,beta_i)$ for a true variable and $(alpha_i,beta_i,gamma_i)$ for a false one. For each clause, Lemma 1's seven explicit local orders @galilMegiddo1977 satisfy its gadget. Deleting their five auxiliary elements gives exactly the restriction of this common variable-block order; this is where distinct and consistently ordered variables are essential. Insert each local auxiliary sequence after its preceding variable element in the common order. When several clauses use the same gap, concatenate their sequences in clause-index order. Each local order remains the restriction of the resulting global order because no constraint connects auxiliary elements from different clauses. Thus every target constraint holds, as formalized by Corollary 2 of the paper.
 
-  _Correctness._ ($arrow.r.double$) Let $S$ be a satisfying assignment of $phi$. For each variable, exactly one of the two opposite orientations $(alpha_i, beta_i, gamma_i)$ and $(alpha_i, gamma_i, beta_i)$ is derived by any cyclic order; interpret the literal made true by $S$ as the one whose associated orientation is _not_ derived. In every clause at least one literal is true, and Galil--Megiddo's clause gadget lemma shows that the ten triples above are then consistent with the three literal orientations for that clause @galilMegiddo1977. Because different clauses use disjoint auxiliary element sets, the per-clause cyclic orders combine into one global cyclic order satisfying all target triples. ($arrow.l.double$) Conversely, let a cyclic ordering satisfy every target triple. For each variable $x_i$, put $x_i = 1$ iff $(alpha_i, beta_i, gamma_i)$ is _not_ derived. If some clause had all three literals false under this rule, then all three associated literal orientations would be derived. The same clause gadget lemma implies that the ten triples for that clause would then be inconsistent, contradicting feasibility. Hence every clause contains a true literal, so the extracted assignment satisfies $phi$.
+  ($arrow.l.double$) Any valid target permutation determines a unique orientation for each variable triple. Assign $x_i$ true precisely when its positive triple is not derived. If all literals of a normalized clause were false, the ten gadget constraints together with its three forward literal orientations would be inconsistent by Lemma 1. Hence every normalized clause is satisfied. The short-clause equivalences imply the original clauses are satisfied by restriction to original variables; removed tautologies hold under every assignment.
 
-  _Variable mapping._ Positive literal $x_i$ is read through the orientation $(alpha_i, beta_i, gamma_i)$, while negative literal $not x_i$ is read through the reversed orientation $(alpha_i, gamma_i, beta_i)$.
+  _Solution extraction._ Validate the complete target configuration through the formal API and reject $"Or(false)"$. Read the reverse orientation of each compact original variable triple, restore its original index through the saved inverse map, and set unused source variables false. Fresh Boolean variables do not occur in the extracted vector. Cyclic rotations preserve every extracted truth value.
 
-  _Solution extraction._ Given a target permutation $f$, set $x_i = 1$ iff $(f(alpha_i), f(beta_i), f(gamma_i))$ is _not_ in cyclic order; otherwise set $x_i = 0$.
+  _Overhead and numeric domain._ If $a$ original variables occur in retained clauses, then $a <= min(s,3c)$, $N <= a+2c$, and $M <= 4c$. This gives the registered upper bounds including the boundary targets. The native normalized clause representation is an array of three $"i64"$ values, occupying 24 bytes. A successfully allocated outer vector therefore has $24M <= I$, where $I="isize::MAX"$. Every normalized variable appears in at least one clause, so $N <= 3M$, $3N+5M <= 14M < I$, and $10M < I$. All element indices and dimension products fit $"usize"$. Before this allocation, the original clause vector bounds fresh-variable counts by $N <= 5c$; its 24-byte object layout on 64-bit and 12-byte layout on 32-bit ensure fresh signed literals fit $"i64"$. Original large sparse indices are compacted before arithmetic. Allocation or default-solver limits remain resource outcomes, not infeasibility certificates.
 ]
 
 #let ksat_ps = load-example("KSatisfiability", "PreemptiveScheduling")
@@ -17800,9 +17660,9 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_ps.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_ps) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_ps_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_ps_sol.source_config),
     )
 
     #{
@@ -17814,18 +17674,18 @@ The following table shows concrete variable overhead for example instances, take
       let original-jobs = 2 * n * (n + 1) + 2 * n + 7 * m
       let filler-jobs = num-jobs - original-jobs
       let sigma = range(num-jobs).map(job =>
-        range(num-jobs).filter(slot => ksat_ps_sol.target_config.at(job * num-jobs + slot) == 1).at(0)
+        range(num-jobs).filter(slot => ksat_ps_sol.target_config.at(job).at(slot)).at(0)
       )
       let slot-counts = range(t).map(slot =>
         range(num-jobs).filter(job => sigma.at(job) == slot).len()
       )
       let clause-slots = range(7).map(i => sigma.at(30 + i))
       [
-        *Step 1 -- Source instance.* The formula is $phi = (x_1 or x_2 or x_3)$ with satisfying assignment $(x_1, x_2, x_3) = (#ksat_ps_sol.source_config.map(str).join(", "))$.
+        *Step 1 -- Source instance.* The formula is $phi = (x_1 or x_2 or x_3)$ with satisfying assignment $(x_1, x_2, x_3) = (#fmt-values(ksat_ps_sol.source_config))$.
 
         *Step 2 -- Build Ullman's unit-task gadgets.* For $n = #n$, the reduction creates $2 n (n + 1) = #(2 * n * (n + 1))$ chain jobs $x_(i,j), overline(x)_(i,j)$, $2n = #(2 * n)$ forcing jobs $y_i, overline(y)_i$, and $7m = #(7 * m)$ clause jobs $D_(r,s)$. The slot capacities are $(#(n), #(2 * n + 1), #(2 * n + 2), #(2 * n + 2), #(m + n + 1), #(6 * m)) = (3, 7, 8, 8, 5, 6)$. We realize these capacities with $p = max(2n + 2, 6m) = #p$ processors and $F = #filler-jobs$ filler jobs, giving $#num-jobs$ total unit jobs. In this example the filler counts are $(5, 1, 0, 0, 3, 2)$.
 
-        *Step 3 -- Verify a schedule.* The witness schedule has exactly $p = #p$ jobs in each of the $T = #t$ slots: $(#slot-counts.map(str).join(", "))$. The positive chain starters $x_(1,0), x_(2,0), x_(3,0)$ are jobs $0, 8, 16$, placed at slots $(#sigma.at(0), #sigma.at(8), #sigma.at(16)) = (1, 1, 0)$, so extraction reads $(0, 0, 1)$ back from slot 0. The clause-pattern jobs are indices $30, dots, 36$; their slots are $(#clause-slots.map(str).join(", "))$, so exactly one clause job is promoted to slot $n + 1 = 4$ and the remaining six sit at slot $n + 2 = 5$.
+        *Step 3 -- Verify a schedule.* The witness schedule has exactly $p = #p$ jobs in each of the $T = #t$ slots: $(#fmt-values(slot-counts))$. The positive chain starters $x_(1,0), x_(2,0), x_(3,0)$ are jobs $0, 8, 16$, placed at slots $(#sigma.at(0), #sigma.at(8), #sigma.at(16)) = (1, 1, 0)$, so extraction reads $(0, 0, 1)$ back from slot 0. The clause-pattern jobs are indices $30, dots, 36$; their slots are $(#fmt-values(clause-slots))$, so exactly one clause job is promoted to slot $n + 1 = 4$ and the remaining six sit at slot $n + 2 = 5$.
 
         *Multiplicity:* The fixture stores one canonical witness. Other satisfying assignments induce different slot-0 choices for the variable chains and therefore different valid schedules meeting the same threshold.
       ]
@@ -17853,22 +17713,22 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_td.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_td) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_td_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_td_sol.source_config),
     )
 
     *Step 1 -- Source instance.* The canonical formula has $n = #ksat_td.source.instance.num_vars$ variables and $m = #ksat_td.source.instance.clauses.len()$ clauses:
     $ phi = (#ksat_td.source.instance.clauses.map(c => {
       c.literals.map(l => if l > 0 { $x_#l$ } else { $overline(x)_#calc.abs(l)$ }).join($or$)
     }).join($) and ($)) $
-    The stored satisfying assignment is $(x_1, x_2, x_3) = (#ksat_td_sol.source_config.map(str).join(", "))$.
+    The stored satisfying assignment is $(x_1, x_2, x_3) = (#fmt-values(ksat_td_sol.source_config))$.
 
     *Step 2 -- Normalize and assign periods.* The source has $L = #ksat_td.source.instance.clauses.map(c => c.literals.len()).sum()$ literal occurrences. Each variable appears at most three times, so no bounded-occurrence cloning is needed. The normalized instance uses $#(ksat_td.target.instance.num_periods / 4)$ transformed variables and therefore $4q = #ksat_td.target.instance.num_periods$ timetable periods/colors.
 
     *Step 3 -- Compile the gadget graph.* The list-edge-coloring gadget becomes a timetable with $#ksat_td.target.instance.num_craftsmen$ craftsmen, $#ksat_td.target.instance.num_tasks$ tasks, and #ksat_td_req binary requirements. Each blocked color on a core-graph vertex is encoded directly by removing that period from the corresponding craftsman/task availability row, so no dummy "blocker" craftsmen or tasks are needed.
 
-    *Step 4 -- Verify a solution.* The target witness has #ksat_td_sol.target_config.filter(x => x == 1).len() scheduled pairs, exactly matching the #ksat_td_req nonzero requirements. Each required craftsman-task pair is scheduled in a period allowed by both availability rows, and `pred evaluate` accepts the timetable. Reading back the distinguished variable-gadget periods recovers $(#ksat_td_sol.source_config.map(str).join(", "))$, which satisfies both clauses #sym.checkmark
+    *Step 4 -- Verify a solution.* The target witness has #ksat_td_sol.target_config.flatten().filter(x => x).len() scheduled pairs, exactly matching the #ksat_td_req nonzero requirements. Each required craftsman-task pair is scheduled in a period allowed by both availability rows, and `pred evaluate` accepts the timetable. Reading back the distinguished variable-gadget periods recovers $(#fmt-values(ksat_td_sol.source_config))$, which satisfies both clauses #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical witness. Different satisfying assignments, or different satisfying choices for the clause-edge colors, can induce distinct feasible timetables for the same formula.
   ],
@@ -17892,44 +17752,28 @@ The following table shows concrete variable overhead for example instances, take
 #let ksat_ap_sol = ksat_ap.solutions.at(0)
 #reduction-rule("KSatisfiability", "AcyclicPartition",
   example: true,
-  example-caption: [3-SAT with $n = #ksat_ap.source.instance.num_vars$ variables, $m = #ksat_ap.source.instance.clauses.len()$ clause $arrow.r$ acyclic partition on #ksat_ap.target.instance.graph.num_vertices vertices],
+  example-caption: [3-SAT to a partition with two heavy anchors and unit incidence items],
   extra: [
-    #pred-commands(
-      "pred create --example " + problem-spec(ksat_ap.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_ap) + " -o bundle.json",
-      "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_ap_sol.source_config.map(str).join(","),
-    )
-
-    #{
-      let n = ksat_ap.source.instance.num_vars
-      let m = ksat_ap.source.instance.clauses.len()
-      let tgt = ksat_ap.target.instance
-      [
-        *Step 1 -- Source instance.* The canonical formula has $n = #n$ variable and $m = #m$ clause. The stored satisfying assignment is $(#ksat_ap_sol.source_config.map(str).join(", "))$.
-
-        *Step 2 -- Compose the three-stage chain.* The reduction composes 3-SAT $arrow.r$ Subset Sum $arrow.r$ Partition $arrow.r$ Acyclic Partition. First, the Sipser digit-encoding produces a Subset Sum instance with $2n + 2m$ elements. Second, the Subset Sum $arrow.r$ Partition padding appends at most one element. Third, the Partition $arrow.r$ Acyclic Partition gadget builds a bipartite digraph: for each of the Partition elements, create one item vertex; add a source vertex and a sink vertex, with arcs from source to every item vertex and from every item vertex to sink. The resulting digraph has #tgt.graph.num_vertices vertices and #tgt.graph.arcs.len() arcs. Vertex weights are doubled element sizes for items and $(Sigma + 1)$ for the two endpoints; the weight bound is $Sigma + 1 + Sigma - (Sigma mod 2)$ where $Sigma$ is the Partition total, and the arc-cost bound equals the number of items.
-
-        *Step 3 -- Verify a solution.* The target witness $(#ksat_ap_sol.target_config.map(str).join(", "))$ partitions the #tgt.graph.num_vertices vertices into two blocks. The source and sink land in different blocks, ensuring the quotient digraph is acyclic. The item vertices split so that the doubled sizes on each side, together with the endpoint weight, respect the weight cap. Extracting back through Partition and Subset Sum recovers $(#ksat_ap_sol.source_config.map(str).join(", "))$, which satisfies the formula #sym.checkmark
-
-        *Multiplicity:* The fixture stores one canonical witness. Other satisfying assignments of the source formula induce different balanced partitions of the item vertices.
-      ]
-    }
+    The canonical formula $(x_1 or x_1 or x_1)$ gives a clique graph with four vertices, three edges, and threshold two. The incidence construction has seven items and two anchors, capacity $c=3$, magnitude $M=15$, weight bound $B=21$, and cost bound $K=101$. Anchor weights are 18 and 14. The stored partition $(#fmt-values(ksat_ap_sol.target_config))$ puts two clique vertices and their edge item with the source anchor. Its cut cost is $105-2-2=101$. Formal extraction gives $(#fmt-values(ksat_ap_sol.source_config))$.
   ],
 )[
-  This composed reduction realizes 3-SAT $arrow.r$ Acyclic Partition via the witness-preserving chain 3-SAT $arrow.r$ Subset Sum $arrow.r$ Partition $arrow.r$ Acyclic Partition. The first two stages are the classical Sipser digit encoding @sipser2012 and Garey--Johnson padding @garey1979; the final stage embeds the balanced partition into a bipartite source--sink digraph whose two-block quotient is automatically acyclic. For $n$ variables and $m$ clauses, the target has $2n + 2m + 3$ vertices and $4n + 4m + 2$ arcs.
+  Compose the literal-compatibility clique construction @karp1972 with the incidence construction below. All weights and arc costs are positive integers of polynomial magnitude. This incidence lemma is proved here; it does not use the digit-encoded Subset Sum chain.
 ][
-  _Construction._ Given a 3-CNF formula $phi$ with $n$ variables and $m$ clauses:
+  _Construction._ First obtain a clique instance $H=(V,E)$ with threshold $k$ from the formal 3-SAT-to-KClique rule, including its universal vertex and padding. Write $h=|V|$, $e=|E|$, and $L=h+e$. Here $1 <= k <= h$.
+
+  1. Create one unit-weight item per vertex and edge of $H$. Set $c=k(k+1)/2$, $M=2L+1$, and $B=2(L+c)+1$.
+  2. Add anchors $s,t$ with weights $B-c$ and $B-L$. For every item $i$, add $(s,i)$ of cost $M$ and $(i,t)$ of cost $M-d_i$, where $d_i=deg_H(i)+1$ for vertex items and zero for edge items.
+  3. For every edge $a={u,v}$ add $(u,a)$ and $(v,a)$, each of cost one. Set the weight bound to $B$ and cut-cost bound to $K=M L-k^2$.
 
-  (i) Apply the Sipser digit-encoding reduction (see KSatisfiability $arrow.r$ SubsetSum) to obtain a Subset Sum instance with $2n + 2m$ elements and target $T$.
+  _Forward direction._ Given a clique of at least $k$ vertices, choose exactly $k$ of them. Put these vertex items and their $k(k-1)/2$ edge items with $s$, and all remaining items with $t$. The source block contains exactly $c$ unit items; the sink block contains at most $L$. No dependency arc goes from the sink block to the source block, so the quotient is acyclic. Spoke costs are $M L-sum_(v " selected")(deg_H(v)+1)$, and dependency costs are $sum_(v " selected") deg_H(v)-k(k-1)$. Their sum is $M L-k^2=K$.
 
-  (ii) Apply the Subset Sum $arrow.r$ Partition reduction (see SubsetSum $arrow.r$ Partition) to obtain a Partition instance with at most $2n + 2m + 1$ elements and total $Sigma$.
+  _Backward direction._ Each anchor weighs more than $B/2$, so they occupy distinct blocks. If $r>=1$ items lie outside those blocks, spoke costs alone are at least $M(L+r)-(h+2e)>M L>K$, since $h+2e<=2L<M$. Thus every item is in an anchor block. Some spoke induces a source-to-sink quotient arc because $L>=1$. A dependency in the opposite direction would create a cycle, so an edge item in the source block has both endpoints there.
 
-  (iii) For each Partition element $a_i$, create one item vertex with weight $2 a_i$. Add a source vertex $s$ and a sink vertex $t$, each with weight $Sigma + 1$. Create arcs $(s, v_i)$ and $(v_i, t)$ for every item vertex $v_i$, all with unit cost. Set the weight bound $B = Sigma + 1 + Sigma - (Sigma mod 2)$ and the arc-cost bound $K =$ number of items.
+  Let $p$ and $q$ count vertex and edge items in the source block. Capacity gives $p+q<=c$ and closure gives $q<=p(p-1)/2$. The exact cut cost is $M L-p-2q$, hence $p+2q>=k^2$. If $p<k$, then $p+2q<=p^2<k^2$. If $p>k$, then $p+2q<=2c-p<k^2$. Therefore $p=k$ and $q=k(k-1)/2$: the selected vertices form a clique.
 
-  _Correctness._ ($arrow.r.double$) A satisfying assignment of $phi$ yields a Subset Sum solution, which yields a balanced Partition, which splits the item vertices into two groups of equal total size. Placing one group with $s$ and the other with $t$ gives a two-block partition. Each block's weight is $Sigma + 1 + Sigma <= B$. The arcs from $s$ to the opposite group and from the opposite group to $t$ form the cut, and the quotient digraph $s$-block $arrow$ $t$-block is acyclic. ($arrow.l.double$) Any feasible acyclic partition must separate $s$ and $t$ (otherwise the digon $s arrow v arrow t$ and $s arrow v' arrow t$ would create a quotient cycle). The weight bound forces the doubled item sizes in each block to be nearly balanced, recovering a balanced Partition. Reversing the Subset Sum and 3-SAT stages then yields a satisfying assignment.
+  _Solution extraction._ Validate the target partition, select precisely those vertex items sharing the label of $s$, and invoke the formal clique-to-SAT extractor. This mapping is independent of the numerical names of partition blocks.
 
-  _Solution extraction._ Identify the block containing $s$ and the block containing $t$. Assign each item vertex to Partition side 0 or 1 according to whether it shares a block with $t$. Reverse the Subset Sum $arrow.r$ Partition extraction, then reverse the 3-SAT $arrow.r$ Subset Sum extraction.
+  _Overhead._ There are exactly $h+e+2$ vertices and $2h+4e$ arcs. With $m$ source clauses, $h<=3m+1$ and $e<=9m(m-1)/2+3m$, including native short or empty clauses. Thus target sizes are at most $(9m^2+3m+6)/2$ vertices and $18m^2+2$ arcs. The construction checks representability of counts and signed integer coefficients before allocating its incidence graph.
 ]
 
 #let hc_bicon = load-example("HamiltonianCircuit", "BiconnectivityAugmentation")
@@ -17940,44 +17784,40 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hc_bicon.source) + " -o hc.json",
-      "pred reduce hc.json --to " + target-spec(hc_bicon) + " -o bundle.json",
+      "pred reduce hc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hc.json --config " + hc_bicon_sol.source_config.map(str).join(","),
+      "pred evaluate hc.json --config " + cli-config(hc_bicon_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The source graph $G$ has $n = #graph-num-vertices(hc_bicon.source.instance)$ vertices and $|E| = #graph-num-edges(hc_bicon.source.instance)$ edges: $E = {#hc_bicon.source.instance.graph.edges.map(e => "(" + e.map(str).join(", ") + ")").join(", ")}$. This is a 4-cycle, which admits a Hamiltonian circuit.
+    *Step 1 -- Source instance.* The source graph $G$ has $n = #graph-num-vertices(hc_bicon.source.instance)$ vertices and $|E| = #graph-num-edges(hc_bicon.source.instance)$ edges: $E = {#hc_bicon.source.instance.graph.edges.map(e => "(" + fmt-values(e) + ")").join(", ")}$. This is a 4-cycle, which admits a Hamiltonian circuit.
 
     *Step 2 -- Construction.* Start with the edgeless graph $H = (V, emptyset)$ on $n = #graph-num-vertices(hc_bicon.target.instance)$ vertices. For each pair ${u, v}$, create a potential edge with weight 1 if ${u,v} in E$ and weight 2 otherwise. This yields #hc_bicon.target.instance.potential_weights.len() potential edges: #hc_bicon.target.instance.potential_weights.map(pw => "{" + str(pw.at(0)) + ", " + str(pw.at(1)) + "} (w=" + str(pw.at(2)) + ")").join(", "). The budget is $B = #hc_bicon.target.instance.budget = n$.
 
-    *Step 3 -- Verify a solution.* The canonical Hamiltonian circuit visits vertices in order $(#hc_bicon_sol.source_config.map(str).join(", "))$. The target configuration $bold(x) = (#hc_bicon_sol.target_config.map(str).join(", "))$ selects potential edges #{
-      let selected = hc_bicon_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => {
+    *Step 3 -- Verify a solution.* The canonical Hamiltonian circuit visits vertices in order $(#fmt-values(hc_bicon_sol.source_config))$. The target configuration $bold(x) = (#fmt-values(hc_bicon_sol.target_config))$ selects potential edges #{
+      let selected = hc_bicon_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => {
         let pw = hc_bicon.target.instance.potential_weights.at(i)
         "{" + str(pw.at(0)) + ", " + str(pw.at(1)) + "}"
       })
       selected.join(", ")
-    } — exactly the $n = #graph-num-vertices(hc_bicon.source.instance)$ cycle edges, each of weight 1, for a total cost of #hc_bicon_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => hc_bicon.target.instance.potential_weights.at(i).at(2)).sum() $= n = B$ #sym.checkmark
+    } — exactly the $n = #graph-num-vertices(hc_bicon.source.instance)$ cycle edges, each of weight 1, for a total cost of #hc_bicon_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => hc_bicon.target.instance.potential_weights.at(i).at(2)).sum() $= n = B$ #sym.checkmark
 
-    *Multiplicity:* The fixture stores one canonical witness. The 4-cycle has $#{
-      let n = graph-num-vertices(hc_bicon.source.instance)
-      let fac = range(1, n).fold(1, (acc, x) => acc * x)
-      str(int(fac / 2))
-    }$ distinct Hamiltonian circuits ($(n-1)! slash 2$ directed cycles up to reversal).
+    *Multiplicity:* The 4-cycle has one undirected Hamiltonian cycle up to rotation and reversal, represented by eight vertex permutations. All eight permutations select the same four undirected target edges.
   ],
 )[
-  Start with the edgeless graph on $n$ vertices. Price original edges at cost 1 and non-edges at cost 2. A budget-$n$ augmentation is achievable iff $G$ has a Hamiltonian circuit (the only way to biconnect with $n$ weight-1 edges is a Hamiltonian cycle).
+  For $n < 3$, output three isolated vertices, no candidate edges, and budget zero. For $n >= 3$, start with the edgeless graph on $n$ vertices. Price original edges at cost 1 and non-edges at cost 2, and set budget $n$. The resulting augmentation is feasible iff $G$ has a Hamiltonian circuit.
 ][
-  _Construction._ Given $G = (V, E)$ with $n = |V|$, let $H = (V, emptyset)$. For every pair ${u, v}$: potential edge with weight 1 if ${u,v} in E$, else weight 2. Budget $B = n$.
+  _Construction._ The weighted construction is due to Eswaran and Tarjan @eswarantarjan1976 (also Theorems 7–8 of their January 1974 technical report ERL-M441). The source requires at least three vertices. If $n < 3$, map this necessarily negative instance to the disconnected three-vertex graph with no candidates and budget zero. Otherwise, let $H = (V, emptyset)$ and give every unordered pair of distinct vertices cost 1 if it is a source edge and 2 otherwise, with $B = n$. Source loops are irrelevant to a Hamiltonian circuit on at least three vertices; repeated source edges do not change adjacency or candidate costs.
 
-  _Correctness._ ($arrow.r.double$) A Hamiltonian circuit selects $n$ weight-1 edges forming a 2-connected cycle, cost $= n$. ($arrow.l.double$) Budget $n$ with $>= n$ edges required (degree $>= 2$) forces exactly $n$ weight-1 edges (all from $E$), which must form a Hamiltonian cycle.
+  _Correctness._ For $n < 3$, both instances are infeasible. For $n >= 3$, a source Hamiltonian circuit selects $n$ weight-1 edges forming a biconnected cycle of cost $n$. Conversely, a feasible target is connected and every vertex has degree at least two: a degree-zero vertex contradicts connectivity, and a degree-one vertex would be separated from the other surviving vertices by deleting its neighbor. The degree sum therefore forces at least $n$ selected edges. Positive costs and budget $n$ force exactly $n$ edges, all of cost 1. Every degree is exactly two, so connectivity makes these edges a single spanning cycle of the source. All partial selected-weight sums are at most the final sum for feasible targets; evaluation therefore preserves the budget test with exact integer arithmetic.
 
-  _Solution extraction._ Walk the unique cycle from vertex 0 through selected edges to recover the circuit order.
+  _Solution extraction._ Validate the target certificate and require its evaluation to be `Or(true)` before decoding. Walk the selected cycle from vertex 0 to recover the circuit order. The negative sentinel has no feasible certificate. The target has at most $n+3$ vertices, no initial edges, and at most $n(n-1)/2$ candidates.
 ]
 
 #let hc_sca = load-example("HamiltonianCircuit", "StrongConnectivityAugmentation")
 #let hc_sca_sol = hc_sca.solutions.at(0)
 #let hc_sca_n = graph-num-vertices(hc_sca.source.instance)
 #let hc_sca_candidate_arcs = hc_sca.target.instance.candidate_arcs
-#let hc_sca_selected = hc_sca_candidate_arcs.enumerate().filter(((i, _)) => hc_sca_sol.target_config.at(i) == 1).map(((i, a)) => a)
+#let hc_sca_selected = hc_sca_candidate_arcs.enumerate().filter(((i, _)) => hc_sca_sol.target_config.at(i)).map(((i, a)) => a)
 #let hc_sca_w1 = hc_sca_candidate_arcs.filter(a => a.at(2) == 1)
 #let hc_sca_w2 = hc_sca_candidate_arcs.filter(a => a.at(2) == 2)
 #reduction-rule("HamiltonianCircuit", "StrongConnectivityAugmentation",
@@ -17986,16 +17826,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hc_sca.source) + " -o hc.json",
-      "pred reduce hc.json --to " + target-spec(hc_sca) + " -o bundle.json",
+      "pred reduce hc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hc.json --config " + hc_sca_sol.source_config.map(str).join(","),
+      "pred evaluate hc.json --config " + cli-config(hc_sca_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The source graph is the cycle on $#hc_sca_n$ vertices with edges #hc_sca.source.instance.graph.edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The canonical Hamiltonian-circuit witness is the vertex permutation $[#hc_sca_sol.source_config.map(str).join(", ")]$.
+    *Step 1 -- Source instance.* The source graph is the cycle on $#hc_sca_n$ vertices with edges #hc_sca.source.instance.graph.edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The canonical Hamiltonian-circuit witness is the vertex permutation $[#fmt-values(hc_sca_sol.source_config)]$.
 
     *Step 2 -- Construction.* Start with the empty digraph $D = (V, emptyset)$ on $#hc_sca_n$ vertices. Generate all $#hc_sca_candidate_arcs.len()$ ordered pairs as candidate arcs: #hc_sca_w1.len() weight-1 arcs #hc_sca_w1.map(a => $(#a.at(0) arrow #a.at(1))$).join(", ") corresponding to source edges (both orientations), and #hc_sca_w2.len() weight-2 arcs #hc_sca_w2.map(a => $(#a.at(0) arrow #a.at(1))$).join(", ") for non-edges. Budget $B = #hc_sca.target.instance.bound$.
 
-    *Step 3 -- Verify a solution.* The target configuration $[#hc_sca_sol.target_config.map(str).join(", ")]$ selects arcs #hc_sca_selected.map(a => $(#a.at(0) arrow #a.at(1))$).join(", "), all weight 1. Total cost $= #hc_sca_selected.len() times 1 = #hc_sca_n = B$ #sym.checkmark. These $#hc_sca_n$ arcs form a single directed cycle visiting every vertex, so the augmented digraph is strongly connected. Extracting the circuit: follow successors from vertex 0 to recover $[#hc_sca_sol.source_config.map(str).join(", ")]$ #sym.checkmark
+    *Step 3 -- Verify a solution.* The target configuration $[#fmt-values(hc_sca_sol.target_config)]$ selects arcs #hc_sca_selected.map(a => $(#a.at(0) arrow #a.at(1))$).join(", "), all weight 1. Total cost $= #hc_sca_selected.len() times 1 = #hc_sca_n = B$ #sym.checkmark. These $#hc_sca_n$ arcs form a single directed cycle visiting every vertex, so the augmented digraph is strongly connected. Extracting the circuit: follow successors from vertex 0 to recover $[#fmt-values(hc_sca_sol.source_config)]$ #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical witness. For the 4-cycle there are $#hc_sca_n times 2 = #{hc_sca_n * 2}$ Hamiltonian-circuit permutations (choice of start vertex and direction), each yielding a distinct set of directed arcs.
   ],
@@ -18021,27 +17861,31 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hc_sc.source) + " -o hc.json",
-      "pred reduce hc.json --to " + target-spec(hc_sc) + " -o bundle.json",
+      "pred reduce hc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hc.json --config " + hc_sc_sol.source_config.map(str).join(","),
+      "pred evaluate hc.json --config " + cli-config(hc_sc_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical source fixture is the cycle $C_#hc_sc_n$ on vertices ${0, dots, #(hc_sc_n - 1)}$ with #hc_sc_source_edges.len() edges: #hc_sc_source_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The stored Hamiltonian-circuit witness is the permutation $[#hc_sc_sol.source_config.map(str).join(", ")]$.\
+    *Step 1 -- Source instance.* The canonical source fixture is the cycle $C_#hc_sc_n$ on vertices ${0, dots, #(hc_sc_n - 1)}$ with #hc_sc_source_edges.len() edges: #hc_sc_source_edges.map(e => $(#e.at(0), #e.at(1))$).join(", "). The stored Hamiltonian-circuit witness is the permutation $[#fmt-values(hc_sc_sol.source_config)]$.\
 
     *Step 2 -- Construction.* Each vertex $v_i$ splits into $v_i^"in" = 2i$ and $v_i^"out" = 2i + 1$, giving $2 dot #hc_sc_n = #hc_sc.target.instance.num_vertices$ vertices. The reduction creates #hc_sc_target_arcs.len() mandatory arcs: #hc_sc_target_arcs.map(a => $(#a.at(0) arrow #a.at(1))$).join(", "), each of length 1. For each source edge, two undirected connector edges of length 1 are added, giving $2 dot #hc_sc_source_edges.len() = #hc_sc_target_edges.len()$ connector edges: #hc_sc_target_edges.map(e => ${#e.at(0), #e.at(1)}$).join(", ").\
 
-    *Step 3 -- Verify a solution.* The stored target configuration $[#hc_sc_sol.target_config.map(str).join(", ")]$ is a permutation of arcs. Following this order: arc #hc_sc_sol.target_config.at(0) serves $(#hc_sc_target_arcs.at(hc_sc_sol.target_config.at(0)).at(0) arrow #hc_sc_target_arcs.at(hc_sc_sol.target_config.at(0)).at(1))$, then a connector edge leads to the next arc, and so on. The tour traverses $#hc_sc_target_arcs.len()$ arcs (cost $#hc_sc_target_arcs.len()$) and $#hc_sc_target_arcs.len()$ connector edges (cost $#hc_sc_target_arcs.len()$), for total cost $2 dot #hc_sc_n = #(hc_sc_n * 2)$. Recovering the source witness: arc $i$ corresponds to vertex $i$, so the permutation $[#hc_sc_sol.source_config.map(str).join(", ")]$ is the Hamiltonian circuit #sym.checkmark\
+    *Step 3 -- Verify a solution.* The stored target configuration $[#fmt-values(hc_sc_sol.target_config)]$ is a permutation of arcs. Following this order: arc #hc_sc_sol.target_config.at(0) serves $(#hc_sc_target_arcs.at(hc_sc_sol.target_config.at(0)).at(0) arrow #hc_sc_target_arcs.at(hc_sc_sol.target_config.at(0)).at(1))$, then a connector edge leads to the next arc, and so on. The tour traverses $#hc_sc_target_arcs.len()$ arcs (cost $#hc_sc_target_arcs.len()$) and $#hc_sc_target_arcs.len()$ connector edges (cost $#hc_sc_target_arcs.len()$), for total cost $2 dot #hc_sc_n = #(hc_sc_n * 2)$. Recovering the source witness: arc $i$ corresponds to vertex $i$, so the permutation $[#fmt-values(hc_sc_sol.source_config)]$ is the Hamiltonian circuit #sym.checkmark\
 
     *Multiplicity:* The fixture stores one canonical witness. For $C_#hc_sc_n$ there are $#hc_sc_n times 2 = #(hc_sc_n * 2)$ directed Hamiltonian circuits (choice of start vertex and direction), each yielding a distinct arc-service permutation.
   ],
 )[
-  Each vertex $v_i$ splits into $(v_i^"in", v_i^"out")$ with a mandatory directed arc of length 1. Undirected connector edges of length 1 encode original graph edges. A tour of cost $2n$ exists iff a Hamiltonian circuit exists.
+  Each vertex $v_i$ splits into $(v_i^"in", v_i^"out")$ with a mandatory directed arc of length 1. Undirected connector edges of length 1 encode original graph edges. For $n>=3$, a tour of cost $2n$ exists iff a Hamiltonian circuit exists; smaller source graphs have answer NO.
 ][
-  _Construction._ Given $G = (V, E)$ with $n = |V|$. Create $2n$ vertices: $v_i^"in" = 2i$, $v_i^"out" = 2i + 1$. Add $n$ mandatory arcs $(v_i^"in", v_i^"out")$ of length 1. For each ${v_i, v_j} in E$: connector edges $(v_i^"out", v_j^"in")$ and $(v_j^"out", v_i^"in")$ of length 1.
+  _Construction._ Let the source simple graph $G=(V,E)$ have $n=|V|$ vertices and $m=|E|$ edges. Replace vertex $i$ by $i^"in"=2i$ and $i^"out"=2i+1$, with a unit service arc from the former to the latter. For each source edge ${i,j}$, add unit undirected connectors ${i^"out",j^"in"}$ and ${j^"out",i^"in"}$. The target has exactly $2n$ vertices, $n$ service arcs, and $2m$ edges. The source answer is YES exactly when $n>=3$ and the target minimum exists and equals $2n$.
+
+  _Forward direction._ A Hamiltonian ordering gives the same service ordering. Each of its $n$ services costs one and each consecutive pair, including the closing pair, has a direct unit connector. Its cost is $2n$. Every connector links distinct split endpoints and has cost at least one, so this cost is optimal.
 
-  _Correctness._ ($arrow.r.double$) A Hamiltonian circuit gives a tour serving arcs in circuit order, each inter-arc hop using one connector edge, total cost $2n$. ($arrow.l.double$) Cost $2n$ with $n$ arcs of cost 1 leaves exactly $n$ connector hops of cost 1 each; single-hop connections correspond to edges of $G$.
+  _Backward direction._ Suppose $n>=3$ and a service permutation has cost $2n$. Its $n$ services cost $n$, leaving exactly $n$ for the $n$ connectors. Each connector must therefore cost one. An outgoing split vertex has no outgoing service arc; a one-step connector to an incoming split vertex exists precisely for an original graph edge. Thus consecutive service indices, including the last and first, are adjacent in $G$. The permutation visits every vertex once and is a Hamiltonian circuit. Longer finite tours are not certificates.
 
-  _Solution extraction._ The arc service permutation directly encodes the Hamiltonian circuit vertex order.
+  _Boundaries and numeric domain._ Simple Hamiltonian circuits require at least three vertices. In particular, a two-vertex single-edge graph has target optimum four but no source circuit; the empty target has cost zero but the empty source has no circuit. The condition $n>=3$ handles this domain explicitly. A finite shortest connector can be chosen simple and uses at most $2n-1$ unit steps. Hence every finite service-order cost is at most $2n^2$. Split dimensions and this bound are checked for representability before allocation; a failure returns a typed reduction error. Target construction uses its fallible API.
+
+  _Solution extraction._ Evaluate once, apply the same aggregate certificate predicate, and reject non-certifying tours with an extraction error. Otherwise the service permutation is the source vertex order. The target evaluator permits service arcs on connector paths; the proof remains valid because equality forces each connector to be a single undirected edge. No target-definition change is required.
 ]
 
 #let hc_rp = load-example("HamiltonianCircuit", "RuralPostman")
@@ -18053,16 +17897,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hc_rp.source) + " -o hc.json",
-      "pred reduce hc.json --to " + target-spec(hc_rp) + " -o bundle.json",
+      "pred reduce hc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hc.json --config " + hc_rp_sol.source_config.map(str).join(","),
+      "pred evaluate hc.json --config " + cli-config(hc_rp_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical HC instance is a cycle $C_#hc_rp_n$ with $n = #hc_rp_n$ vertices and $|E| = #graph-num-edges(hc_rp.source.instance)$ edges. The stored witness is the permutation $(#hc_rp_sol.source_config.map(str).join(", "))$.
+    *Step 1 -- Source instance.* The canonical HC instance is a cycle $C_#hc_rp_n$ with $n = #hc_rp_n$ vertices and $|E| = #graph-num-edges(hc_rp.source.instance)$ edges. The stored witness is the permutation $(#fmt-values(hc_rp_sol.source_config))$.
 
     *Step 2 -- Construction.* Each vertex splits into $(v_i^a, v_i^b)$, producing $2n = #graph-num-vertices(hc_rp.target.instance)$ vertices. The target graph has #graph-num-edges(hc_rp.target.instance) edges: #hc_rp.target.instance.required_edges.len() required edges (one per source vertex) and #(graph-num-edges(hc_rp.target.instance) - hc_rp.target.instance.required_edges.len()) connector edges (two per source edge). All edge lengths are 1.
 
-    *Step 3 -- Verify a solution.* The target solution assigns edge multiplicities $(#hc_rp_sol.target_config.map(str).join(", "))$. The tour traverses all #hc_rp.target.instance.required_edges.len() required edges plus #hc_rp_n connector edges, for total cost $= #(2 * hc_rp_n) = 2n$ #sym.checkmark.
+    *Step 3 -- Verify a solution.* The target solution assigns edge multiplicities $(#fmt-values(hc_rp_sol.target_config))$. The tour traverses all #hc_rp.target.instance.required_edges.len() required edges plus #hc_rp_n connector edges, for total cost $= #(2 * hc_rp_n) = 2n$ #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness. The $#hc_rp_n$-cycle has $#hc_rp_n$ rotations $times$ 2 reflections $= #(2 * hc_rp_n)$ directed Hamiltonian circuits.
   ],
@@ -18076,56 +17920,33 @@ The following table shows concrete variable overhead for example instances, take
   _Solution extraction._ Identify used connector edges and follow the successor map from vertex 0.
 ]
 
-#let mis_ifb = load-example("MaximumIndependentSet", "IntegralFlowBundles")
+#let mis_ifb = load-example("DecisionMaximumIndependentSet", "IntegralFlowBundles", source-variant: (graph: "SimpleGraph", weight: "One"))
 #let mis_ifb_sol = mis_ifb.solutions.at(0)
-#reduction-rule("MaximumIndependentSet", "IntegralFlowBundles",
+#reduction-rule("DecisionMaximumIndependentSet", "IntegralFlowBundles",
   example: true,
-  example-caption: [Path graph $P_#mis_ifb.source.instance.graph.num_vertices$ ($n = #mis_ifb.source.instance.graph.num_vertices$, $|E| = #mis_ifb.source.instance.graph.edges.len()$)],
+  example-source-variant: (graph: "SimpleGraph", weight: "One"),
+  example-caption: [The three-vertex path has an independent set of size at least two],
   extra: [
     #pred-commands(
-      "pred create --example " + problem-spec(mis_ifb.source) + " -o mis.json",
-      "pred reduce mis.json --to " + target-spec(mis_ifb) + " -o bundle.json",
+      "pred create --example DecisionMaximumIndependentSet/One -o independent-set.json",
+      "pred reduce independent-set.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate mis.json --config " + mis_ifb_sol.source_config.map(str).join(","),
+      "pred extract bundle.json --config " + cli-config(mis_ifb_sol.target_config),
     )
-
-    #{
-      let graph = mis_ifb.source.instance.graph
-      let n = graph.num_vertices
-      let verts = range(n).map(k => (k * 1.5, 0))
-      let is-in-set = mis_ifb_sol.source_config.map(c => c > 0)
-      let blue = graph-colors.at(0)
-      align(center, canvas(length: 0.8cm, {
-        import draw: *
-        for (u, v) in graph.edges {
-          g-edge(verts.at(u), verts.at(v))
-        }
-        for (k, pos) in verts.enumerate() {
-          g-node(pos, name: str(k),
-            fill: if is-in-set.at(k) { blue } else { white },
-            label: [$v_#k$])
-        }
-      }))
-    }
-
-    *Step 1 -- Source instance.* The path graph $P_#mis_ifb.source.instance.graph.num_vertices$ has $n = #mis_ifb.source.instance.graph.num_vertices$ vertices and edges ${#mis_ifb.source.instance.graph.edges.map(e => "(" + str(e.at(0)) + "," + str(e.at(1)) + ")").join(", ")}$, with unit weights $(#mis_ifb.source.instance.weights.map(str).join(", "))$.
-
-    *Step 2 -- Build the flow network.* The reduction creates a directed graph with $#mis_ifb.target.instance.graph.num_vertices$ nodes: source $s = #mis_ifb.target.instance.source$, intermediates $w_0, dots, w_(#(mis_ifb.source.instance.graph.num_vertices - 1))$, and sink $t = #mis_ifb.target.instance.sink$. There are $#mis_ifb.target.instance.graph.arcs.len()$ arcs ($2n = #(2 * mis_ifb.source.instance.graph.num_vertices)$): for each vertex $v_i$, arc $a_i^"in" = (s, w_i)$ at index $2i$ and $a_i^"out" = (w_i, t)$ at index $2i+1$.
-
-    *Step 3 -- Create bundles.* There are $#mis_ifb.target.instance.bundles.len()$ bundles total. For each original edge ${v_i, v_j} in E$, an edge bundle ${a_i^"out", a_j^"out"}$ with capacity 1 enforces that at most one endpoint is selected (#mis_ifb.source.instance.graph.edges.len() edge bundles). For each vertex $v_i$, a vertex bundle ${a_i^"in", a_i^"out"}$ with capacity 2 links the in/out arcs (#mis_ifb.source.instance.graph.num_vertices vertex bundles). Bundle capacities: $(#mis_ifb.target.instance.bundle_capacities.map(str).join(", "))$. Flow requirement $R = #mis_ifb.target.instance.requirement$.
-
-    *Step 4 -- Verify a solution.* The canonical IS selects vertices ${#mis_ifb_sol.source_config.enumerate().filter(((i, x)) => x > 0).map(((i, x)) => $v_#i$).join(", ")}$ (config $(#mis_ifb_sol.source_config.map(str).join(", "))$). Each selected vertex $v_i$ contributes flow 1 on arcs $a_i^"in"$ and $a_i^"out"$, giving target config $(#mis_ifb_sol.target_config.map(str).join(", "))$. The total flow equals the IS size (#mis_ifb_sol.source_config.fold(0, (a, b) => a + b)). Every edge bundle is satisfied because no two adjacent vertices are both selected, and vertex bundles are satisfied with capacity 2 $>=$ individual flow of 1.
-
-    *Multiplicity:* The fixture stores one canonical witness. The path $P_#mis_ifb.source.instance.graph.num_vertices$ admits larger independent sets (e.g., ${v_0, v_2}$ or ${v_0, v_3}$), but the canonical witness suffices to demonstrate the reduction.
+    Source bound: #mis_ifb.source.instance.bound; selected vertices: #fmt-values(mis_ifb_sol.source_config) \
+    Target: #mis_ifb.target.instance.graph.num_vertices vertices, #mis_ifb.target.instance.graph.arcs.len() arcs, #mis_ifb.target.instance.bundles.len() bundles; requirement #mis_ifb.target.instance.requirement \
+    Feasible flow: #fmt-values(mis_ifb_sol.target_config)
   ],
 )[
-  Each vertex $v_i$ maps to a flow unit through an intermediate node; edge-bundle constraints cap combined outflow of adjacent pairs at 1, so feasible flow of value $k$ exists iff an independent set of size $>= k$ exists.
+  The unit-weight decision independent-set problem reduces to integral flow with bundles. Sahni's original construction @sahni1974[Theorem 2.2(b)(iv), p. 270] represents cardinality and recovers a maximum by repeated flow-threshold queries. The direct rule here preserves one explicit decision threshold; it does not claim that an arbitrary feasible flow solves weighted maximum independent set.
 ][
-  _Construction._ Directed graph on $n + 2$ nodes: source $s$, intermediates $w_0, dots, w_(n-1)$, sink $t$. Arcs $a_i^"in" = (s, w_i)$ (index $2i$) and $a_i^"out" = (w_i, t)$ (index $2i+1$). Edge bundles ${a_i^"out", a_j^"out"}$ with capacity 1 for each ${v_i, v_j} in E$. Vertex bundles ${a_i^"in", a_i^"out"}$ with capacity 2. Flow requirement $R = 1$.
+  _Construction._ Let $G$ have $n$ vertices, $m$ edge records, and integer bound $k$. Set $q = min(max(k,0),n+1)$ and $R=q+1$. Introduce a source $s$, a sink $t$, and intermediate vertices $w_0, dots, w_n$. For each $i$, add arcs $a_i=(s,w_i)$ and $b_i=(w_i,t)$, and the capacity-2 bundle ${a_i,b_i}$. Paths $0, dots, n-1$ represent source vertices; path $n$ is auxiliary. For each edge record $(u,v)$ add the capacity-1 bundle ${a_u,b_v}$. There are $n+3$ vertices, $2n+2$ arcs, and $m+n+1$ bundles. Every arc belongs to a bundle, and both arcs of each bundle are distinct even for a source self-loop.
+
+  _Backward direction._ Flow conservation and the path bundles imply that both arcs on path $i$ carry the same binary flow $x_i$. The edge bundles impose $x_u+x_v <= 1$, so $S={i<n:x_i=1}$ is independent. A self-loop imposes $2x_u <= 1$, forcing $x_u=0$ without a separate construction. The sink receives $|S|+x_n >= R$, hence $|S| >= q$. For $0<k<=n$ this is the required bound. Bounds $k<=0$ accept every independent set; bounds $k>n$ force $|S|>=n+1$ and make the target infeasible.
 
-  _Correctness._ ($arrow.r.double$) An independent set $S$ gives flow $f_i = 1$ for $v_i in S$; edge bundles satisfied since $S$ is independent. ($arrow.l.double$) Feasible flow gives $f_i in {0,1}$; edge bundles force ${v_i : f_i = 1}$ to be independent.
+  _Forward direction._ Given any independent set $S$ meeting $k$, send one unit through each selected path and the auxiliary path, and zero through all others. Every capacity and conservation constraint holds, and the inflow $|S|+1$ meets $R$. Thus the source and target are equivalent for every integer bound. Even the empty graph produces one auxiliary path: it is feasible for $k<=0$ and infeasible for $k>0$.
 
-  _Solution extraction._ Vertex $v_i$ in independent set iff target solution at arc index $2i+1$ is positive.
+  _Solution extraction._ After validating target feasibility, select original vertex $i$ exactly when its outgoing arc has flow 1. The auxiliary path is omitted. Repeated source edges add repeated constraints and do not change the proof. Allocation counts and the shifted threshold are checked before construction; no source solver is invoked during construction or extraction.
 ]
 
 #let hc_qa = load-example("HamiltonianCircuit", "QuadraticAssignment")
@@ -18136,27 +17957,33 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hc_qa.source) + " -o hc.json",
-      "pred reduce hc.json --to " + target-spec(hc_qa) + " -o bundle.json",
+      "pred reduce hc.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hc.json --config " + hc_qa_sol.source_config.map(str).join(","),
+      "pred evaluate hc.json --config " + cli-config(hc_qa_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The graph $G$ has $n = #hc_qa.source.instance.graph.num_vertices$ vertices and edges ${#hc_qa.source.instance.graph.edges.map(e => "(" + str(e.at(0)) + "," + str(e.at(1)) + ")").join(", ")}$, forming a cycle $C_#hc_qa.source.instance.graph.num_vertices$. The penalty weight is $omega = n + 1 = #(hc_qa.source.instance.graph.num_vertices + 1)$.
+    *Step 1 -- Source instance.* The graph $G$ has $n = #hc_qa.source.instance.graph.num_vertices$ vertices and edges ${#hc_qa.source.instance.graph.edges.map(e => "(" + str(e.at(0)) + "," + str(e.at(1)) + ")").join(", ")}$, forming a cycle $C_#hc_qa.source.instance.graph.num_vertices$.
 
-    *Step 2 -- Construction.* The cost matrix $C$ encodes a directed cycle on positions: $c[i][(i+1) mod #hc_qa.source.instance.graph.num_vertices] = 1$, all other entries 0. The distance matrix $D$ encodes graph adjacency: $d[k][l] = 1$ if ${k,l} in E$, $d[k][l] = #(hc_qa.source.instance.graph.num_vertices + 1)$ for non-edges, $d[k][k] = 0$. Both matrices are $#hc_qa.source.instance.graph.num_vertices times #hc_qa.source.instance.graph.num_vertices$, so the QAP has $n = #hc_qa.target.instance.cost_matrix.len()$ facilities and $n = #hc_qa.target.instance.distance_matrix.len()$ locations.
+    *Step 2 -- Construction.* The cost matrix $C$ encodes a directed cycle on positions: $c[i][(i+1) mod #hc_qa.source.instance.graph.num_vertices] = 1$, all other entries 0. The distance matrix $D$ encodes graph adjacency: $d[k][l] = 0$ if ${k,l} in E$, $d[k][l] = 1$ for distinct non-edges, $d[k][k] = 0$. Both matrices are $#hc_qa.source.instance.graph.num_vertices times #hc_qa.source.instance.graph.num_vertices$, so the QAP has $n = #hc_qa.target.instance.cost_matrix.len()$ facilities and $n = #hc_qa.target.instance.distance_matrix.len()$ locations.
 
-    *Step 3 -- Verify a solution.* The canonical Hamiltonian circuit visits vertices in order $gamma = (#hc_qa_sol.source_config.map(str).join(", "))$. The QAP permutation is the same: $(#hc_qa_sol.target_config.map(str).join(", "))$. The QAP cost is $sum_(i=0)^(n-1) c[i][(i+1) mod n] dot d[gamma(i)][gamma((i+1) mod n)]$. Since $gamma$ maps each position $i$ to vertex $i$, each consecutive pair $(gamma(i), gamma(i+1 mod n))$ is an edge in $G$, contributing $1 dot 1 = 1$. Total cost $= #hc_qa.source.instance.graph.num_vertices = n$ #sym.checkmark
+    *Step 3 -- Verify a solution.* The canonical Hamiltonian circuit visits vertices in order $gamma = (#fmt-values(hc_qa_sol.source_config))$. The QAP permutation is the same: $(#fmt-values(hc_qa_sol.target_config))$. The QAP cost is $sum_(i=0)^(n-1) c[i][(i+1) mod n] dot d[gamma(i)][gamma((i+1) mod n)]$. Since $gamma$ maps each position $i$ to vertex $i$, each consecutive pair $(gamma(i), gamma(i+1 mod n))$ is an edge in $G$, contributing $1 dot 0 = 0$. Total cost $= 0$ #sym.checkmark
 
-    *Multiplicity:* The fixture stores one canonical witness. The cycle $C_#hc_qa.source.instance.graph.num_vertices$ has $#hc_qa.source.instance.graph.num_vertices$ rotations and 2 reflections, giving $2n = #(2 * hc_qa.source.instance.graph.num_vertices)$ distinct Hamiltonian circuits; the canonical one is the identity permutation.
+    *Multiplicity:* The fixture stores one canonical witness. The cycle $C_#hc_qa.source.instance.graph.num_vertices$ has $#hc_qa.source.instance.graph.num_vertices$ rotations and 2 reflections, giving $2n = #(2 * hc_qa.source.instance.graph.num_vertices)$ distinct visit-order permutations of the same undirected Hamiltonian circuit; the canonical one is the identity permutation.
   ],
 )[
-  Position-adjacency encoded in cost matrix $C$ (directed cycle on positions), graph-adjacency in distance matrix $D$ (1 for edges, $omega = n+1$ for non-edges). QAP optimum equals $n$ iff a Hamiltonian circuit exists.
+  Encode a cycle of positions in $C$ and missing source edges in the binary distance matrix $D$. The QAP optimum is zero iff the source has a Hamiltonian circuit. Sources with fewer than three vertices map to a fixed positive-cost target.
 ][
-  _Construction._ Let $G = (V, E)$ with $n = |V|$ and $omega = n + 1$. Cost matrix: $c[i][j] = 1$ if $j equiv i+1 space (mod n)$, else 0. Distance matrix: $d[k][l] = 0$ if $k = l$; 1 if ${k,l} in E$; $omega$ otherwise.
+  _Construction._ Let $n$ be the source vertex count and $N=max(n,3)$. Set $c[i][j]=1$ exactly when $j=(i+1) mod N$. Set diagonal entries of $D$ to zero. For $n>=3$, set $d[k][l]=1$ exactly when distinct vertices $k,l$ are not adjacent. For $n<3$, set every off-diagonal entry to 1. Both matrices have order $N$.
+
+  _Relation to the literature._ The cycle-position construction is due to @sahni-gonzalez1976, Theorem 2.1(viii), p. 561. For $n>=3$, replacing their edge/non-edge costs 1 and $n+1$ by 0 and 1 changes the assignment cost from $n+n q$ to $q$, where $q$ counts missing cyclic edges. This preserves exact decision equivalence; no preservation of multiplicative approximation ratios is claimed.
+
+  _Forward direction._ If a source Hamiltonian circuit has visit order $gamma$, then $n>=3$ and $gamma$ is a permutation. The only nonzero entries of $C$ connect consecutive cyclic positions, all of whose images are source edges. Each corresponding distance is zero, so the QAP cost is zero.
+
+  _Backward direction._ A valid target assignment is a permutation because the two matrix orders agree. For $n>=3$, its cost is the sum of the $n$ nonnegative indicators of missing cyclic edges. Zero cost forces every indicator to vanish, yielding a Hamiltonian circuit. For $n<3$, the source is NO by definition; the target has three positions and every permutation costs 3, so it has no zero-cost certificate.
 
-  _Correctness._ ($arrow.r.double$) A Hamiltonian circuit $v_0, dots, v_(n-1)$ with $gamma(i) = v_i$ gives cost $n$ (each consecutive pair is an edge). ($arrow.l.double$) Cost $n$ forces $d[gamma(i), gamma((i+1) mod n)] = 1$ for all $i$, meaning all consecutive pairs are edges.
+  _Solution and value extraction._ Validate the target configuration once and require its value to be `Min(Some(0))` before returning the same permutation. Invalid assignments and positive-cost assignments are rejected. The aggregate value map is `Or(value == Min(Some(0)))`; apply it to a proved optimum to decide the source. A timeout or unproved incumbent cannot certify NO.
 
-  _Solution extraction._ The QAP permutation $gamma$ is the Hamiltonian circuit visit order directly.
+  _Domain and overhead._ Loops and repeated edges do not change adjacency between distinct vertices. Matrix entries are 0 or 1, with only $N$ nonzero cost entries, so every objective product and every partial sum lies between 0 and $N$. Native `SimpleGraph` vertex indices are bounded by the underlying `u32` graph representation, so these sums fit `i64`. Both target dimensions are $N<=n+3$; allocation failure is not a NO certificate.
 ]
 
 // Removed: HamiltonianPath → ConsecutiveOnesSubmatrix (unsound reduction, #1006)
@@ -18167,8 +17994,8 @@ The following table shows concrete variable overhead for example instances, take
 #let part_bp_n = part_bp_sizes.len()
 #let part_bp_total = part_bp_sizes.fold(0, (a, b) => a + b)
 #let part_bp_capacity = part_bp.target.instance.capacity
-#let part_bp_bin0 = part_bp_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => i)
-#let part_bp_bin1 = part_bp_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+#let part_bp_bin0 = part_bp_sol.source_config.enumerate().filter(((i, x)) => not x).map(((i, x)) => i)
+#let part_bp_bin1 = part_bp_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
 #let part_bp_bin0_sizes = part_bp_bin0.map(i => part_bp_sizes.at(i))
 #let part_bp_bin1_sizes = part_bp_bin1.map(i => part_bp_sizes.at(i))
 #let part_bp_bin0_sum = part_bp_bin0_sizes.fold(0, (a, b) => a + b)
@@ -18179,16 +18006,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(part_bp.source) + " -o partition.json",
-      "pred reduce partition.json --to " + target-spec(part_bp) + " -o bundle.json",
+      "pred reduce partition.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate partition.json --config " + part_bp_sol.source_config.map(str).join(","),
+      "pred evaluate partition.json --config " + cli-config(part_bp_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical Partition instance has sizes $(#part_bp_sizes.map(str).join(", "))$ with total sum $S = #part_bp_total$, so a balanced partition requires each half to sum to $S / 2 = #part_bp_capacity$.
+    *Step 1 -- Source instance.* The canonical Partition instance has sizes $(#fmt-values(part_bp_sizes))$ with total sum $S = #part_bp_total$, so a balanced partition requires each half to sum to $S / 2 = #part_bp_capacity$.
 
-    *Step 2 -- Build the bin-packing instance.* The reduction copies each size into the item-size list and sets the bin capacity to $C = floor(S / 2) = #part_bp_capacity$ with $k = 2$ bins. The target instance has sizes $(#part_bp.target.instance.sizes.map(str).join(", "))$ and capacity $#part_bp_capacity$. No auxiliary variables are introduced, so the target has the same $#part_bp_n$ assignment coordinates as the source.
+    *Step 2 -- Build the bin-packing instance.* The reduction copies each size into the item-size list and sets the bin capacity to $C = floor(S / 2) = #part_bp_capacity$ with $k = 2$ bins. The target instance has sizes $(#fmt-values(part_bp.target.instance.sizes))$ and capacity $#part_bp_capacity$. No auxiliary variables are introduced, so the target has the same $#part_bp_n$ assignment coordinates as the source.
 
-    *Step 3 -- Verify the canonical witness.* The witness assigns each element to bin 0 or bin 1 via the binary vector $bold(b) = (#part_bp_sol.source_config.map(str).join(", "))$, which equals the target config $(#part_bp_sol.target_config.map(str).join(", "))$. Bin 0 receives elements $\{#part_bp_bin0.map(str).join(", ")\}$ with sizes $(#part_bp_bin0_sizes.map(str).join(", "))$ summing to $#part_bp_bin0_sum <= #part_bp_capacity$ #sym.checkmark. Bin 1 receives elements $\{#part_bp_bin1.map(str).join(", ")\}$ with sizes $(#part_bp_bin1_sizes.map(str).join(", "))$ summing to $#part_bp_bin1_sum <= #part_bp_capacity$ #sym.checkmark. Both bins fit within the capacity, and the total $#part_bp_bin0_sum + #part_bp_bin1_sum = #part_bp_total$ accounts for all items.
+    *Step 3 -- Verify the canonical witness.* The witness assigns each element to bin 0 or bin 1 via the binary vector $bold(b) = (#fmt-values(part_bp_sol.source_config))$, which equals the target config $(#fmt-values(part_bp_sol.target_config))$. Bin 0 receives elements $\{#fmt-values(part_bp_bin0)\}$ with sizes $(#fmt-values(part_bp_bin0_sizes))$ summing to $#part_bp_bin0_sum <= #part_bp_capacity$ #sym.checkmark. Bin 1 receives elements $\{#fmt-values(part_bp_bin1)\}$ with sizes $(#fmt-values(part_bp_bin1_sizes))$ summing to $#part_bp_bin1_sum <= #part_bp_capacity$ #sym.checkmark. Both bins fit within the capacity, and the total $#part_bp_bin0_sum + #part_bp_bin1_sum = #part_bp_total$ accounts for all items.
 
     *Multiplicity:* The fixture stores one canonical witness. This instance may admit other balanced partitions, but one witness suffices to demonstrate the reduction.
   ],
@@ -18210,25 +18037,25 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(x3c_msp.source) + " -o x3c.json",
-      "pred reduce x3c.json --to " + target-spec(x3c_msp) + " -o bundle.json",
+      "pred reduce x3c.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate x3c.json --config " + x3c_msp_sol.source_config.map(str).join(","),
+      "pred evaluate x3c.json --config " + cli-config(x3c_msp_sol.source_config),
     )
 
     *Step 1 -- Source instance.* The X3C instance has universe $X = {0, dots, #(x3c_msp.source.instance.universe_size - 1)}$ with $q = #(x3c_msp.source.instance.universe_size / 3)$ and $#x3c_msp.source.instance.subsets.len()$ candidate triples:
     #for (i, s) in x3c_msp.source.instance.subsets.enumerate() [
-      $S_#i = {#s.map(str).join(", ")}$#if i < x3c_msp.source.instance.subsets.len() - 1 [, ] else [.]
+      $S_#i = {#fmt-values(s)}$#if i < x3c_msp.source.instance.subsets.len() - 1 [, ] else [.]
     ]
 
-    *Step 2 -- Construct the target.* The identity map copies each triple as a unit-weight set: $#x3c_msp.target.instance.sets.len()$ sets with weights $(#x3c_msp.target.instance.weights.map(str).join(", "))$. The target asks for a maximum packing of pairwise-disjoint sets.
+    *Step 2 -- Construct the target.* The identity map copies each triple as a unit-weight set: $#x3c_msp.target.instance.sets.len()$ sets with weights $(#fmt-values(x3c_msp.target.instance.weights))$. The target asks for a maximum packing of pairwise-disjoint sets.
 
-    *Step 3 -- Verify the canonical witness.* Source config $(#x3c_msp_sol.source_config.map(str).join(", "))$ selects subsets ${#x3c_msp_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", ")}$:
-    #let selected = x3c_msp_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+    *Step 3 -- Verify the canonical witness.* Source config $(#fmt-values(x3c_msp_sol.source_config))$ selects subsets ${#x3c_msp_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", ")}$:
+    #let selected = x3c_msp_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
     #for idx in selected [
       - $S_#idx = {#x3c_msp.source.instance.subsets.at(idx).map(str).join(", ")}$
     ]
     These $#selected.len()$ triples are pairwise disjoint and cover all $#x3c_msp.source.instance.universe_size = 3 dot #(x3c_msp.source.instance.universe_size / 3)$ elements #sym.checkmark \\
-    Target config is identical: $(#x3c_msp_sol.target_config.map(str).join(", "))$ — packing value $= #selected.len() = q$ #sym.checkmark
+    Target config is identical: $(#fmt-values(x3c_msp_sol.target_config))$ — packing value $= #selected.len() = q$ #sym.checkmark
 
     *Multiplicity:* The fixture stores one canonical witness. For this instance there are no other exact covers since every pair of triples that covers all 6 elements is unique.
   ],
@@ -18250,20 +18077,20 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(x3c_mfdts.source) + " -o x3c.json",
-      "pred reduce x3c.json --to " + target-spec(x3c_mfdts) + " -o bundle.json",
+      "pred reduce x3c.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate x3c.json --config " + x3c_mfdts_sol.source_config.map(str).join(","),
+      "pred evaluate x3c.json --config " + cli-config(x3c_mfdts_sol.source_config),
     )
 
     #let q = x3c_mfdts.source.instance.universe_size / 3
     *Step 1 -- Source instance.* The X3C fixture has universe $U = {0, dots, #(x3c_mfdts.source.instance.universe_size - 1)}$ with $q = #q$ and triples
     #for (i, s) in x3c_mfdts.source.instance.subsets.enumerate() [
-      $C_#i = {#s.map(str).join(", ")}$#if i < x3c_mfdts.source.instance.subsets.len() - 1 [, ] else [.]
+      $C_#i = {#fmt-values(s)}$#if i < x3c_mfdts.source.instance.subsets.len() - 1 [, ] else [.]
     ]
 
-    *Step 2 -- Build the fault-detection DAG.* Create one input vertex for each triple, one internal vertex for each universe element, and one shared output. The target therefore has $#x3c_mfdts.target.instance.num_vertices$ vertices, $#x3c_mfdts.target.instance.arcs.len()$ arcs, inputs ${#x3c_mfdts.target.instance.inputs.map(str).join(", ")}$, and output ${#x3c_mfdts.target.instance.outputs.map(str).join(", ")}$. Input $i_j$ connects to exactly the three internal vertices for elements in $C_j$, and every internal vertex connects to the shared output.
+    *Step 2 -- Build the fault-detection DAG.* Create one input vertex for each triple, one internal vertex for each universe element, and one shared output. The target therefore has $#x3c_mfdts.target.instance.num_vertices$ vertices, $#x3c_mfdts.target.instance.arcs.len()$ arcs, inputs ${#fmt-values(x3c_mfdts.target.instance.inputs)}$, and output ${#fmt-values(x3c_mfdts.target.instance.outputs)}$. Input $i_j$ connects to exactly the three internal vertices for elements in $C_j$, and every internal vertex connects to the shared output.
 
-    *Step 3 -- Verify the canonical witness.* The stored source configuration $(#x3c_mfdts_sol.source_config.map(str).join(", "))$ selects $C_0 = {#x3c_mfdts.source.instance.subsets.at(0).map(str).join(", ")}$ and $C_1 = {#x3c_mfdts.source.instance.subsets.at(1).map(str).join(", ")}$, which are disjoint and cover all six universe elements. The target configuration is identical: $(#x3c_mfdts_sol.target_config.map(str).join(", "))$. Pair $(0, #(x3c_mfdts.target.instance.outputs.at(0)))$ covers internal vertices ${0, 1, 2}$, pair $(1, #(x3c_mfdts.target.instance.outputs.at(0)))$ covers ${3, 4, 5}$, and together they cover every internal vertex with value $#q$ #sym.checkmark.
+    *Step 3 -- Verify the canonical witness.* The stored source configuration $(#fmt-values(x3c_mfdts_sol.source_config))$ selects $C_0 = {#x3c_mfdts.source.instance.subsets.at(0).map(str).join(", ")}$ and $C_1 = {#x3c_mfdts.source.instance.subsets.at(1).map(str).join(", ")}$, which are disjoint and cover all six universe elements. The target configuration is identical: $(#fmt-values(x3c_mfdts_sol.target_config))$. Pair $(0, #(x3c_mfdts.target.instance.outputs.at(0)))$ covers internal vertices ${0, 1, 2}$, pair $(1, #(x3c_mfdts.target.instance.outputs.at(0)))$ covers ${3, 4, 5}$, and together they cover every internal vertex with value $#q$ #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness. Any target witness of value $q$ selects exactly $q$ inputs, and since each selected pair covers only 3 internal vertices while there are $3q$ internal vertices overall, those $q$ neighborhoods must be pairwise disjoint and form an exact cover.
   ],
@@ -18285,20 +18112,20 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(x3c_mas.source) + " -o x3c.json",
-      "pred reduce x3c.json --to " + target-spec(x3c_mas) + " -o bundle.json",
+      "pred reduce x3c.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate x3c.json --config " + x3c_mas_sol.source_config.map(str).join(","),
+      "pred evaluate x3c.json --config " + cli-config(x3c_mas_sol.source_config),
     )
 
     #let x3c_mas_q = x3c_mas.source.instance.universe_size / 3
     *Step 1 -- Source instance.* The X3C fixture has universe $U = {0, dots, #(x3c_mas.source.instance.universe_size - 1)}$ with $q = #x3c_mas_q$ and candidate triples
     #for (i, s) in x3c_mas.source.instance.subsets.enumerate() [
-      $C_#i = {#s.map(str).join(", ")}$#if i < x3c_mas.source.instance.subsets.len() - 1 [, ] else [.]
+      $C_#i = {#fmt-values(s)}$#if i < x3c_mas.source.instance.subsets.len() - 1 [, ] else [.]
     ]
 
     *Step 2 -- Build the axiom system.* Create one element-sentence for each universe element and one set-sentence for each triple, so the target has $#x3c_mas.target.instance.num_sentences$ sentences and $#x3c_mas.target.instance.true_sentences.len()$ true sentences. Each triple contributes three forward implications and one backward implication, giving $#x3c_mas.target.instance.implications.len()$ implications total. The optimization instance itself stores only the axiom-system data; the X3C bound $q = #x3c_mas_q$ is checked externally against the optimum target value.
 
-    *Step 3 -- Verify the canonical witness.* The stored source config $(#x3c_mas_sol.source_config.map(str).join(", "))$ selects $C_3 = {#x3c_mas.source.instance.subsets.at(3).map(str).join(", ")}$ and $C_4 = {#x3c_mas.source.instance.subsets.at(4).map(str).join(", ")}$. These two triples are disjoint and cover all six universe elements #sym.checkmark. The target axiom vector $(#x3c_mas_sol.target_config.map(str).join(", "))$ selects exactly the set-sentence coordinates $#(x3c_mas.source.instance.universe_size + 3)$ and $#(x3c_mas.source.instance.universe_size + 4)$, namely $z_3$ and $z_4$. One closure round derives every element-sentence $e_0, dots, e_5$; then the backward rules derive the remaining set-sentences $z_0, z_1, z_2$, so the closure equals all $#x3c_mas.target.instance.true_sentences.len()$ true sentences. This witness therefore attains value $#x3c_mas_q$ #sym.checkmark, and extracting the chosen set-sentence coordinates recovers the exact cover.
+    *Step 3 -- Verify the canonical witness.* The stored source config $(#fmt-values(x3c_mas_sol.source_config))$ selects $C_3 = {#x3c_mas.source.instance.subsets.at(3).map(str).join(", ")}$ and $C_4 = {#x3c_mas.source.instance.subsets.at(4).map(str).join(", ")}$. These two triples are disjoint and cover all six universe elements #sym.checkmark. The target axiom vector $(#fmt-values(x3c_mas_sol.target_config))$ selects exactly the set-sentence coordinates $#(x3c_mas.source.instance.universe_size + 3)$ and $#(x3c_mas.source.instance.universe_size + 4)$, namely $z_3$ and $z_4$. One closure round derives every element-sentence $e_0, dots, e_5$; then the backward rules derive the remaining set-sentences $z_0, z_1, z_2$, so the closure equals all $#x3c_mas.target.instance.true_sentences.len()$ true sentences. This witness therefore attains value $#x3c_mas_q$ #sym.checkmark, and extracting the chosen set-sentence coordinates recovers the exact cover.
 
     *Multiplicity:* The fixture stores one canonical witness. Any target witness of value $q$ must select exactly $q$ set-sentences and no element-sentences, because each direct element axiom lowers the maximum possible element coverage by two.
   ],
@@ -18334,9 +18161,9 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ss_part.source) + " -o subsetsum.json",
-      "pred reduce subsetsum.json --to " + target-spec(ss_part) + " -o bundle.json",
+      "pred reduce subsetsum.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate subsetsum.json --config " + ss_part_sol.source_config.map(str).join(","),
+      "pred evaluate subsetsum.json --config " + cli-config(ss_part_sol.source_config),
     )
 
     #{
@@ -18345,11 +18172,11 @@ The following table shows concrete variable overhead for example instances, take
       let T = int(ss_part.source.instance.target)
       let d = calc.abs(sigma - 2 * T)
       [
-        *Step 1 -- Source instance.* Subset Sum with sizes $(#sizes.map(str).join(", "))$ and target $T = #T$. Total $Sigma = #sigma$.
+        *Step 1 -- Source instance.* Subset Sum with sizes $(#fmt-values(sizes))$ and target $T = #T$. Total $Sigma = #sigma$.
 
-        *Step 2 -- Compute padding.* $Sigma = #sigma$, $2T = #(2 * T)$. Since $Sigma < 2T$, we have $d = 2T - Sigma = #d$. The Partition instance is $S union {d} = (#ss_part.target.instance.sizes.map(str).join(", "))$ with #ss_part.target.instance.sizes.len() elements.
+        *Step 2 -- Compute padding.* $Sigma = #sigma$, $2T = #(2 * T)$. Since $Sigma < 2T$, we have $d = 2T - Sigma = #d$. The Partition instance is $S union {d} = (#fmt-values(ss_part.target.instance.sizes))$ with #ss_part.target.instance.sizes.len() elements.
 
-        *Step 3 -- Verify a solution.* Source config $(#ss_part_sol.source_config.map(str).join(", "))$: selected elements $= {#ss_part_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(sizes.at(i))).join(", ")}$ sum to $#T = T$ #sym.checkmark. Target config $(#ss_part_sol.target_config.map(str).join(", "))$: side-0 sum $= #ss_part_sol.target_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => ss_part.target.instance.sizes.at(i)).sum()$, side-1 sum $= #ss_part_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => ss_part.target.instance.sizes.at(i)).sum()$ -- balanced #sym.checkmark.
+        *Step 3 -- Verify a solution.* Source config $(#fmt-values(ss_part_sol.source_config))$: selected elements $= {#ss_part_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(sizes.at(i))).join(", ")}$ sum to $#T = T$ #sym.checkmark. Target config $(#fmt-values(ss_part_sol.target_config))$: side-0 sum $= #ss_part_sol.target_config.enumerate().filter(((i, x)) => not x).map(((i, x)) => ss_part.target.instance.sizes.at(i)).sum()$, side-1 sum $= #ss_part_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => ss_part.target.instance.sizes.at(i)).sum()$ -- balanced #sym.checkmark.
       ]
     }
 
@@ -18382,7 +18209,7 @@ The following table shows concrete variable overhead for example instances, take
     #{
       let sizes = ss_ik.source.instance.sizes.map(s => int(s))
       let B = int(ss_ik.source.instance.target)
-      let chosen = ss_ik_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+      let chosen = ss_ik_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
       let chosen_sum = chosen.map(i => sizes.at(i)).sum()
       [
         #pred-commands(
@@ -18392,11 +18219,11 @@ The following table shows concrete variable overhead for example instances, take
           "pred solve integer-knapsack.json",
         )
 
-        *Step 1 -- Source instance.* The canonical Subset Sum instance has sizes $(#sizes.map(str).join(", "))$ and target $B = #B$. The stored witness $(#ss_ik_sol.source_config.map(str).join(", "))$ selects elements ${#chosen.map(str).join(", ")}$, whose values sum to $#chosen_sum = B$ #sym.checkmark.
+        *Step 1 -- Source instance.* The canonical Subset Sum instance has sizes $(#fmt-values(sizes))$ and target $B = #B$. The stored witness $(#fmt-values(ss_ik_sol.source_config))$ selects elements ${#fmt-values(chosen)}$, whose values sum to $#chosen_sum = B$ #sym.checkmark.
 
-        *Step 2 -- Build the target.* Copy each source size into both the size and value lists. The Integer Knapsack instance therefore has sizes $(#ss_ik.target.instance.sizes.map(str).join(", "))$, values $(#ss_ik.target.instance.values.map(str).join(", "))$, and the same capacity $B = #ss_ik.target.instance.capacity$.
+        *Step 2 -- Build the target.* Copy each source size into both the size and value lists. The Integer Knapsack instance therefore has sizes $(#fmt-values(ss_ik.target.instance.sizes))$, values $(#fmt-values(ss_ik.target.instance.values))$, and the same capacity $B = #ss_ik.target.instance.capacity$.
 
-        *Step 3 -- Verify the forward witness.* Reuse the same 0-1 vector as multiplicities: $(#ss_ik_sol.target_config.map(str).join(", "))$. Its total size is $#chosen_sum <= #ss_ik.target.instance.capacity$, and because size equals value coordinate-wise, its total value is also $#chosen_sum = B$ #sym.checkmark.
+        *Step 3 -- Verify the forward witness.* Reuse the same 0-1 vector as multiplicities: $(#fmt-values(ss_ik_sol.target_config))$. Its total size is $#chosen_sum <= #ss_ik.target.instance.capacity$, and because size equals value coordinate-wise, its total value is also $#chosen_sum = B$ #sym.checkmark.
 
         *Step 4 -- Backward gap.* For the source instance $A = {3}$ with target $B = 6$, Subset Sum is NO, but Integer Knapsack can set multiplicity $c_0 = 2$ and achieve total size/value $6$. This is why the catalog records the edge for proof topology only and disables all runtime reduction modes.
       ]
@@ -18435,16 +18262,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(sat_nt.source) + " -o sat.json",
-      "pred reduce sat.json --to " + target-spec(sat_nt) + " -o bundle.json",
+      "pred reduce sat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate sat.json --config " + sat_nt_sol.source_config.map(str).join(","),
+      "pred evaluate sat.json --config " + cli-config(sat_nt_sol.source_config),
     )
 
     *Step 1 -- Source instance.* CNF with $n = #sat_nt.source.instance.num_vars$ variables and $m = #sat-num-clauses(sat_nt.source.instance)$ clauses.
 
     *Step 2 -- Apply De Morgan.* Each clause $C_j = (l_1 or dots or l_k)$ becomes disjunct $D_j = (overline(l_1) and dots and overline(l_k))$. The Non-Tautology instance has #sat_nt.target.instance.disjuncts.len() disjuncts over #sat_nt.target.instance.num_vars variables.
 
-    *Step 3 -- Verify a solution.* Source config $(#sat_nt_sol.source_config.map(str).join(", "))$ satisfies the CNF. Target config $(#sat_nt_sol.target_config.map(str).join(", "))$ falsifies the DNF (same assignment). Variables are identical #sym.checkmark.
+    *Step 3 -- Verify a solution.* Source config $(#fmt-values(sat_nt_sol.source_config))$ satisfies the CNF. Target config $(#fmt-values(sat_nt_sol.target_config))$ falsifies the DNF (same assignment). Variables are identical #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness.
   ],
@@ -18467,16 +18294,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(kc_pic.source) + " -o kcoloring.json",
-      "pred reduce kcoloring.json --to " + target-spec(kc_pic) + " -o bundle.json",
+      "pred reduce kcoloring.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate kcoloring.json --config " + kc_pic_sol.source_config.map(str).join(","),
+      "pred evaluate kcoloring.json --config " + cli-config(kc_pic_sol.source_config),
     )
 
     *Step 1 -- Source instance.* Graph $G$ with $n = #graph-num-vertices(kc_pic.source.instance)$ vertices, $|E| = #graph-num-edges(kc_pic.source.instance)$ edges, $k = #kc_pic.source.instance.num_colors$ colors.
 
     *Step 2 -- Complement graph.* $overline(G)$ has the same $n = #graph-num-vertices(kc_pic.target.instance)$ vertices and $|overline(E)| = #graph-num-edges(kc_pic.target.instance)$ edges. Clique bound $K' = #kc_pic.target.instance.num_cliques$.
 
-    *Step 3 -- Verify a solution.* Source coloring $(#kc_pic_sol.source_config.map(str).join(", "))$. Target partition $(#kc_pic_sol.target_config.map(str).join(", "))$ -- each color class is a clique in $overline(G)$ #sym.checkmark.
+    *Step 3 -- Verify a solution.* Source coloring $(#fmt-values(kc_pic_sol.source_config))$. Target partition $(#fmt-values(kc_pic_sol.target_config))$ -- each color class is a clique in $overline(G)$ #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness.
   ],
@@ -18503,29 +18330,28 @@ The following table shows concrete variable overhead for example instances, take
 
 // 5. KColoring → BicliqueCover (#1058)
 #reduction-rule("KColoring", "BicliqueCover")[
-  Self-contained gadget @karp1972 @garey1979 @orlin1977 building a bipartite graph $H$ on $4 n$ vertices with rank $n + q$. Each source vertex $v$ contributes two left vertices $a_v, g_v$ and two right vertices $b_v, h_v$. Guard-anchor edges $(g_v, h_v)$ force $n$ bicliques to be spent on per-vertex guards, leaving at most $q$ remaining bicliques to cover the diagonal edges $(a_v, b_v)$, which behave as color classes under the classical sub-biclique semantics of BicliqueCover.
+  A guard construction embeds coloring feasibility into the finite-feasibility of BicliqueCover. The target uses the classical sub-biclique semantics described by @chandran_et_al:LIPIcs.IPEC.2016.11; the construction and proof below are self-contained. The source value is #raw("Or"), and the target value is #raw("Min<i64>"): any feasible target cover suffices, regardless of its total membership cost.
 ][
-  _Construction._ Let $(G = (V, E), q)$ be the source instance with $n = |V|$. Build $H = (L union.sq R, F)$ with $L = {a_v, g_v : v in V}$ and $R = {b_v, h_v : v in V}$ (so $|L| = |R| = 2 n$). Set the BicliqueCover rank to $k = n + q$. The edge set $F$ consists of:
-  $
-    "diagonal:"      quad & (a_v, b_v) && quad forall v in V \
-    "compatibility:" quad & (a_u, b_v) && quad forall u != v "with" {u, v} in.not E \
-    "guard-anchor:"  quad & (a_v, h_v), (g_v, h_v) && quad forall v in V \
-    "guard-compat:"  quad & (g_v, b_w) && quad forall v != w "with" {v, w} in.not E.
-  $
-  The total edge count is $n + 2(n(n-1) - 2m) + 2n = 2 n (n - 1) - 4 m + 3 n$ where $m = |E|$.
+  _Construction._ Let the source be $(G=(V,E),q)$ with $n=|V|$, and set $q'=min(q,n)$. A coloring uses at most $n$ distinct labels, so relabeling used colors preserves feasibility with $q'$ colors, including $n=0$ and $q=0$. If $G$ has a self-loop, return a target with one vertex on each side, one edge, and rank zero. This is a fixed NO instance.
+
+  Otherwise introduce left vertices $a_v,g_v$ and right vertices $b_v,h_v$ for every $v in V$. Set rank $k=n+q'$. Include the diagonal edges $(a_v,b_v)$, the guard edges $(a_v,h_v),(g_v,h_v)$, and, for every ordered pair of distinct nonadjacent vertices $u,v$, both $(a_u,b_v)$ and $(g_u,b_v)$. Repeated and reversed source edges express the same adjacency constraint. With $d$ distinct source edges, the target has $2n$ vertices per side and $2n^2+n-4d$ edges. The empty source produces an empty target of rank zero, a YES instance. Uniform upper bounds, including the loop sentinel, are $2n+1$ vertices per side, $4n+2$ total vertices, $2n^2+n+1$ edges, and rank $2n$.
+
+  _Correctness._ ($arrow.r.double$) Relabel a proper source coloring to use at most $q'$ labels. For each vertex $v$, use the guard biclique with left side ${a_v,g_v}$ and right side ${h_v} union {b_w: w != v, {v,w} in.not E}$. For each used color class $C$, use the biclique with left side ${a_v:v in C}$ and right side ${b_v:v in C}$. Color classes are independent, so these are sub-bicliques. The guard bicliques cover both kinds of compatibility edges and all guard edges; the color bicliques cover every diagonal edge. Pad with empty rows to obtain exactly $k$ rows.
+
+  ($arrow.l.double$) Distinct guard-anchor edges $(g_v,h_v)$ cannot share a biclique, since $(g_u,h_v)$ is absent for $u != v$. A biclique containing an anchor cannot cover any diagonal $(a_u,b_u)$: when $u=v$, $(g_v,b_v)$ is absent; when $u != v$, $(a_u,h_v)$ is absent. Thus at least $n$ rows are occupied by anchors, leaving at most $q'$ rows covering diagonals. For each vertex choose the first row covering its diagonal, and compact these row identifiers into colors. Distinct source vertices assigned the same row require both cross edges in the target, hence are nonadjacent. This yields a proper coloring using at most $q'<=q$ colors. A self-loop makes the source infeasible for every $q$, agreeing with the fixed NO target.
 
-  _Correctness._ ($arrow.r.double$) Given a proper $q$-coloring of $G$, emit $n$ guard bicliques $G_v = ({a_v, g_v}, {h_v} union {b_w : w != v, {v, w} in.not E})$ and one color biclique $C_(c) = ({a_v : v "has color" c}, {b_v : v "has color" c})$ per color $c$. Each color class is an independent set, so all required compatibility edges exist and the color bicliques are valid sub-bicliques. Guard bicliques cover all guard-anchor and guard-compat edges; color bicliques cover the diagonal edges. ($arrow.l.double$) In any biclique cover, each guard-anchor edge $(g_v, h_v)$ must lie in its own biclique because no cross edge $(g_u, h_v)$ exists for $u != v$. A biclique containing $(g_v, h_v)$ cannot cover any diagonal edge $(a_u, b_u)$: if $u = v$ then $(g_v, b_v) in.not F$, and if $u != v$ then $(a_u, h_v) in.not F$. Hence at least $n$ bicliques are spent on guards and at most $q$ remain to cover all $n$ diagonal edges $(a_v, b_v)$. Vertices $u, v$ sharing such a diagonal-covering biclique require both $(a_u, b_v)$ and $(a_v, b_u)$ in $F$, which forces $u != v$ and ${u, v} in.not E$. Compacting the at most $q$ diagonal bicliques into colors $0, dots, q - 1$ gives a proper $q$-coloring of $G$.
+  _Solution extraction._ Validate the complete target configuration once and reject #raw("Min(None)") before decoding. Apply the diagonal-row mapping above to every feasible cover, including nonoptimal covers. The empty source yields an empty coloring.
 
-  _Solution extraction._ For each source vertex $v$, locate any biclique $r$ that contains both $a_v$ and $b_v$. Compact the distinct diagonal-covering biclique indices into colors $0, dots, q - 1$ in first-seen order and assign each $v$ its compacted color.
+  _Native numeric domain._ Normalizing $q$ ensures $k<=2n$, even for the largest runtime color count. Native source node allocation bounds make $4n$ and all vertex indices fit #raw("usize"). On a 64-bit target let $I$ be #raw("isize::MAX"), $m$ the number of stored source edges, and $F$ the number of target edges. Each edge record occupies 16 bytes, so successful native allocations imply $F+4m<=5I/16$. Since $d<=m$ and $F=2n^2+n-4d$, this bounds $2n^2+n<=5I/16$. For $n>=2$, each valid target biclique has at most $2n$ members: a row with two $h$ vertices has no left vertices; one $h_v$ restricts the left side to ${a_v,g_v}$; and a row with no $h$ cannot contain both $g_v$ and $b_v$. Therefore every feasible cover has at most $4n^2<I$ members, within #raw("i64"). The cases $n=0,1$ have bounds zero and six. On 32-bit targets the edge-pair size is eight bytes, yielding $2n^2+n<=3I/8$ and an even smaller membership count relative to #raw("i64"). In both cases the binary dimension count $4n k<=8n^2$ fits #raw("usize"); allocating or solving a large target may still fail for resource reasons.
 ]
 
 // 6. KSatisfiability/K3 → BicliqueCover (#1057)
 #reduction-rule("KSatisfiability", "BicliqueCover")[
-  Polynomial reduction (Chandran, Issac, and Karrenbauer, IPEC 2016 @chandran_et_al:LIPIcs.IPEC.2016.11) from 3-SAT to BicliqueCover with logarithmic rank. Each source variable is split into a positive/negative pair $(t_i, f_i)$, exactly-one clauses tie them to opposite truth values, and the formula is padded so that $n = 2^ell$ normalized variables admit a balanced satisfying assignment with exactly $n / 2$ true variables. The construction then assembles a bipartite gadget whose biclique cover rank equals $k_f + 2 ell + 2$ iff the (normalized) formula is satisfiable.
+  Polynomial reduction (Chandran, Issac, and Karrenbauer, IPEC 2016 @chandran_et_al:LIPIcs.IPEC.2016.11) from 3-SAT to BicliqueCover with logarithmic rank. Each appearing source variable is split into a positive/negative pair $(t_i, f_i)$, exactly-one clauses tie them to opposite truth values, and the formula is padded so that $n = 2^ell$ normalized variables admit a balanced satisfying assignment with exactly $n / 2$ true variables. The construction then assembles a bipartite gadget whose biclique cover rank equals $k_f + 2 ell + 2$ iff the (normalized) formula is satisfiable.
 ][
-  _Construction._ Let $psi$ be a 3-CNF formula with source variables $x_1, dots, x_(n_s)$ and clauses $C_1, dots, C_(m_s)$. *Normalize* $psi$:
+  _Construction._ Let $psi$ have $n_s$ declared variables and $m_s$ clauses. The native Rust API also permits clauses of at most three literals. An empty clause maps to a single-edge, rank-zero NO target. A formula with no clauses maps to an empty, rank-zero YES target. Otherwise compact the $a$ variables that actually appear, recording their original indices, and repeat one literal in each nonempty short clause to obtain exactly three positions. Repetition preserves disjunction, and absent variables may be assigned false in the inverse map. *Normalize* this compact formula:
   $
-    "vars:" quad     & "introduce" t_i, f_i "for each" x_i "and pad to" n = 2^ell "variables" \
+    "vars:" quad     & "introduce" t_i, f_i "for each appearing" x_i "and pad to" n = 2^ell "variables" \
     "clauses:" quad  & "replace literal" x_i "by" t_i ";" not x_i "by" f_i \
                      & "add" (t_i or f_i or f_i) "and" (not t_i or not f_i or not f_i) "per pair."
   $
@@ -18547,19 +18373,26 @@ The following table shows concrete variable overhead for example instances, take
   _Correctness._ ($arrow.r.double$) A balanced satisfying assignment fixes one duplex pair $(B_1, overline(B)_1)$ in the crown graph (Lemma 13). Extend $B_1$ through $S_1$ and into one selected satisfied literal edge per clause; the omitted $H$-$P$ edges block extension by unsatisfied literals. Two guard bicliques absorb the remaining two literal edges of each clause and the $Q$ edges. Together with $B_1, overline(B)_1$ and $2 (ell - 1)$ more domino-extension pairs we obtain $2 ell + 2$ important-edge bicliques. Adding $k_f$ free-edge bicliques (Lemma 16) yields a cover of rank exactly $k_f + 2 ell + 2$. ($arrow.l.double$) Any rank-$k$ cover must spend $k_f$ bicliques on the $Y$ matching (Lemma 17) and leaves an induced matching of $2 ell + 2$ important edges, each in its own biclique. The constraints on $S_1$ force the literal-edge biclique to lie in $B_1$, and the omitted $H$-$P$ edges force the selected literals to agree with the assignment $x_i = (h_i^u in B_1)$. Mapping normalized variables back to source variables yields a satisfying assignment.
 
   _Solution extraction._ Identify the unique biclique $B_1$ that covers $s_(1, 1)^u s_(1, 1)^v$ and contains no $y_r^u$ or $y_r^v$. Read the normalized assignment $t_i = (h_i^u in B_1)$ and copy each source $x_i$ from its normalized $t_i$.
+
+  _Native normalization and decoding._ The power-of-two padding depends on the number $a$ of appearing variables, not on $n_s$. Thus even a huge declared variable index is relabeled before constructing $t_i,f_i$; the original index is used only in the inverse map. In any feasible target cover, the $k_f$ forcing edges and $2ell+2$ important matching edges require all available rows. Consequently exactly one row covers the first domino anchor. Validate the target once, reject #raw("Min(None)"), read the left crown vertices in this row, and map each $t_i$ to the corresponding original variable. All absent variables are assigned false. This defines the mapping for arbitrary row permutations and nonoptimal feasible covers; it does not require an extra assumption excluding single $Y$ vertices from a row.
+
+  _Parameter bounds._ For $s=n_s$ and $c=m_s$, normalization gives $n<=4(s+1)$, $m<=c+4(s+1)$, $ell<=s+1$, and $ceil(log_2 m)<=m$. Thus each target side has at most $31s+5c+39$ vertices and rank at most $14s+2c+22$. The registered upper bounds $32s+8c+48$ per side, $64s+16c+96$ total vertices, $(32s+8c+48)^2$ edges, and $16s+4c+32$ rank also include both sentinels; these are not exact equalities.
+
+  _Native arithmetic._ Let $I$ be #raw("isize::MAX") and let $m$ now denote the number of normalized clauses in a successfully allocated ordinary target. Since $m>=n>=2$, $ell<=m/2$ and $ceil(log_2 m)<=(m+1)/2$. Hence rank is at most $4m+9$ and each side has at most $17m/2+9$ vertices. The Boolean cell count is at most $68m^2+225m+162$. The target contains $9m(m-1)$ edges between distinct clause gadgets. Its edge-vector allocation therefore bounds this cell count by $I$ for $m>=6$ on 64-bit targets and $m>=75$ on 32-bit targets; the remaining small cases have bounds 2987 and 389180. All indices, dimensions, and membership counts consequently fit the native #raw("usize") and #raw("i64") types. Appearing-variable compaction also bounds new literal indices by actual clause storage. Allocation and solver failures remain execution or resource failures, not proofs of infeasibility.
+
 ]
 
 #let clustering_ilp = load-example("Clustering", "ILP")
 #let clustering_ilp_sol = clustering_ilp.solutions.at(0)
 #reduction-rule("Clustering", "ILP",
   example: true,
-  example-caption: [4 elements, $K = 2$, $B = 1$ $arrow.r$ ILP with #clustering_ilp.target.instance.num_vars variables and #clustering_ilp.target.instance.constraints.len() constraints],
+  example-caption: [4 elements, $K = 2$, $B = 1$ $arrow.r$ ILP with #clustering_ilp.target.instance.variables.len() variables and #clustering_ilp.target.instance.constraints.len() constraints],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(clustering_ilp.source) + " -o clustering.json",
-      "pred reduce clustering.json --to " + target-spec(clustering_ilp) + " -o bundle.json",
+      "pred reduce clustering.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate clustering.json --config " + clustering_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate clustering.json --config " + cli-config(clustering_ilp_sol.source_config),
     )
 
     #{
@@ -18569,11 +18402,11 @@ The following table shows concrete variable overhead for example instances, take
       let distances = clustering_ilp.source.instance.distances
       let source-config = clustering_ilp_sol.source_config
       [
-        *Step 1 -- Source instance.* The canonical source has $n = #n$ elements, cluster bound $K = #k$, and diameter bound $B = #b$. Its distance rows are #distances.map(row => "(" + row.map(str).join(", ") + ")").join("; "), so the only pairs above the bound are $(0, 2)$, $(0, 3)$, $(1, 2)$, and $(1, 3)$.
+        *Step 1 -- Source instance.* The canonical source has $n = #n$ elements, cluster bound $K = #k$, and diameter bound $B = #b$. Its distance rows are #distances.map(row => "(" + fmt-values(row) + ")").join("; "), so the only pairs above the bound are $(0, 2)$, $(0, 3)$, $(1, 2)$, and $(1, 3)$.
 
-        *Step 2 -- Build the ILP.* Introduce one binary variable $x_(i,c)$ for each element-cluster pair, giving $n K = #(n * k)$ variables. The $n = #n$ assignment equalities $sum_c x_(i,c) = 1$ force every element into exactly one cluster, and the four violating pairs contribute $4 dot K = #(4 * k)$ conflict inequalities. The stored target therefore has #clustering_ilp.target.instance.num_vars variables and #clustering_ilp.target.instance.constraints.len() constraints.
+        *Step 2 -- Build the ILP.* Introduce one binary variable $x_(i,c)$ for each element-cluster pair, giving $n K = #(n * k)$ variables. The $n = #n$ assignment equalities $sum_c x_(i,c) = 1$ force every element into exactly one cluster, and the four violating pairs contribute $4 dot K = #(4 * k)$ conflict inequalities. The stored target therefore has #clustering_ilp.target.instance.variables.len() variables and #clustering_ilp.target.instance.constraints.len() constraints.
 
-        *Step 3 -- Verify the canonical witness.* The stored ILP vector is $(#clustering_ilp_sol.target_config.map(str).join(", "))$. Reading each block of $K = #k$ variables yields the clustering $(#source-config.map(str).join(", "))$, so cluster 0 contains elements ${#source-config.enumerate().filter(((i, c)) => c == 0).map(((i, c)) => str(i)).join(", ")}$ and cluster 1 contains elements ${#source-config.enumerate().filter(((i, c)) => c == 1).map(((i, c)) => str(i)).join(", ")}$. The only within-cluster distances are $d(0,1) = #distances.at(0).at(1)$ and $d(2,3) = #distances.at(2).at(3)$, both at most $B$ #sym.checkmark.
+        *Step 3 -- Verify the canonical witness.* The stored ILP vector is $(#fmt-values(clustering_ilp_sol.target_config))$. Reading each block of $K = #k$ variables yields the clustering $(#fmt-values(source-config))$, so cluster 0 contains elements ${#source-config.enumerate().filter(((i, c)) => c == 0).map(((i, c)) => str(i)).join(", ")}$ and cluster 1 contains elements ${#source-config.enumerate().filter(((i, c)) => c == 1).map(((i, c)) => str(i)).join(", ")}$. The only within-cluster distances are $d(0,1) = #distances.at(0).at(1)$ and $d(2,3) = #distances.at(2).at(3)$, both at most $B$ #sym.checkmark.
 
         *Multiplicity:* The fixture stores one canonical witness. Swapping the two cluster labels gives an equivalent second witness because the ILP distinguishes clusters only by index.
       ]
@@ -18602,35 +18435,31 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(pic_mcbc.source) + " -o partition-into-cliques.json",
-      "pred reduce partition-into-cliques.json --to " + target-spec(pic_mcbc) + " -o bundle.json",
+      "pred reduce partition-into-cliques.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate partition-into-cliques.json --config " + pic_mcbc_sol.source_config.map(str).join(","),
+      "pred evaluate partition-into-cliques.json --config " + cli-config(pic_mcbc_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* Graph $G$ with $n = #graph-num-vertices(pic_mcbc.source.instance)$ vertices, $m = #graph-num-edges(pic_mcbc.source.instance)$ edge, and clique bound $K = #pic_mcbc.source.instance.num_cliques$. The stored partition witness is $(#pic_mcbc_sol.source_config.map(str).join(", "))$, namely the cliques ${0,1}$ and ${2}$.
+    *Step 1 -- Source instance.* Graph $G$ with $n = #graph-num-vertices(pic_mcbc.source.instance)$ vertices, $m = #graph-num-edges(pic_mcbc.source.instance)$ edge, and clique bound $K = #pic_mcbc.source.instance.num_cliques$. The stored partition witness is $(#fmt-values(pic_mcbc_sol.source_config))$, namely the cliques ${0,1}$ and ${2}$.
 
     *Step 2 -- Orlin construction.* The target graph has $#graph-num-vertices(pic_mcbc.target.instance)$ vertices and $#graph-num-edges(pic_mcbc.target.instance)$ edges. Because the source has two directed edge copies, the construction adds the gadgets $Q_(0,1)$ and $Q_(1,0)$, plus the side cliques $L^*$ and $R^*$. The threshold is $K' = K + 2m + 2 = #(pic_mcbc.source.instance.num_cliques + 2 * graph-num-edges(pic_mcbc.source.instance) + 2)$.
 
-    *Step 3 -- Verify the witness.* The target witness labels $#pic_mcbc_sol.target_config.len()$ target edges with 6 clique IDs, corresponding to $D_1 = {x_0, x_1, y_0, y_1}$, $D_2 = {x_2, y_2}$, $Q_(0,1)$, $Q_(1,0)$, $L^*$, and $R^*$. Reading only the labels on the matching edges $x_i y_i$ recovers the source partition $(#pic_mcbc_sol.source_config.map(str).join(", "))$ #sym.checkmark.
+    *Step 3 -- Verify the witness.* The target witness labels $#pic_mcbc_sol.target_config.len()$ target edges with 6 clique IDs, corresponding to $D_1 = {x_0, x_1, y_0, y_1}$, $D_2 = {x_2, y_2}$, $Q_(0,1)$, $Q_(1,0)$, $L^*$, and $R^*$. Reading only the labels on the matching edges $x_i y_i$ recovers the source partition $(#fmt-values(pic_mcbc_sol.source_config))$ #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness. Any permutation of the six target clique labels is equivalent.
   ],
 )[
-  This $O((n + 2m)^2)$ reduction @garey1979[GT17] @orlin1977 @kouStockmeyerWong1978 inlines Orlin's vertex-clique-cover to edge-clique-cover construction. Each source vertex $v_i$ becomes left/right copies $x_i$ and $y_i$, each directed source edge contributes a 4-vertex gadget, and two side cliques account for the additive $2m + 2$ slack. The target graph has an edge-clique cover of size at most $K + 2m + 2$ if and only if the source graph admits a partition into at most $K$ cliques.
+  This reduction @garey1979[GT17] @orlin1977 @kouStockmeyerWong1978 converts vertex clique partition to edge clique cover. It uses the actual distinct non-loop adjacency pairs, and includes a private vertex on each side so that the two forced side cliques also exist for an empty source. No source endpoint restriction is added.
 ][
-  _Construction._ Let $(G = (V, E), K)$ be a Partition Into Cliques instance with $V = {v_1, dots, v_n}$ and $m = |E|$. Define the directed-edge index set $A = {(i,j) : i != j and {v_i,v_j} in E}$, so $|A| = 2m$. Create vertices $x_i, y_i$ for each source vertex $v_i$, gadget vertices $a_(i,j), b_(i,j)$ for each $(i,j) in A$, and two special vertices $z_L, z_R$. Let $L = {x_i : 1 <= i <= n} union {a_(i,j) : (i,j) in A}$ and $R = {y_i : 1 <= i <= n} union {b_(i,j) : (i,j) in A}$. Make $L$ a clique and $R$ a clique, join $z_L$ to every vertex of $L$ and $z_R$ to every vertex of $R$, add each matching edge $x_i y_i$, and for every $(i,j) in A$ add the four cross edges $x_i y_j$, $x_i b_(i,j)$, $a_(i,j) y_j$, and $a_(i,j) b_(i,j)$. Output the resulting Minimum Covering by Cliques instance. It has
-  $
-    |V(H)| = 2n + 4m + 2, quad |E(H)| = (n + 2m)^2 + 2n + 10m,
-  $
-  and threshold $K' = K + 2m + 2$.
+  _Construction._ Let $n$ be the source vertex count, $m$ its stored edge count, and $K$ its clique bound. Let $A = {(i,j) : i != j and {i,j} in E}$ and $q = |A|$. Source self-loops and repeated edges do not change $A$ or source clique feasibility; $q <= 2m$. Create copies $x_i,y_i$, gadget vertices $a_t,b_t$ for each pair $t=(i,j)$, anchors $z_L,z_R$, and private vertices $d_L,d_R$. Set $L={x_i} union {a_t} union {d_L}$ and $R={y_i} union {b_t} union {d_R}$. Make $L$ and $R$ cliques. Connect each anchor to its entire side. Add matching edges $x_i y_i$ and, for every $t=(i,j)$, the cross edges $x_i y_j$, $x_i b_t$, $a_t y_j$, and $a_t b_t$. The threshold is $B=min(K,n)+q+2$.
 
-  _Correctness._ ($arrow.r.double$) Suppose $G$ is partitioned into cliques $C_1, dots, C_t$ with $t <= K$. For each source clique $C_r$, define $D_r = {x_i, y_i : v_i in C_r}$. For each $(i,j) in A$, define $Q_(i,j) = {x_i, a_(i,j), b_(i,j), y_j}$. Also define $L^* = L union {z_L}$ and $R^* = R union {z_R}$. Every $D_r$ is a clique: if $v_i, v_j in C_r$ with $i != j$, then ${v_i,v_j} in E$, so the construction includes both cross edges $x_i y_j$ and $x_j y_i$. The family ${D_1, dots, D_t} union {Q_(i,j) : (i,j) in A} union {L^*, R^*}$ therefore covers every target edge, using at most $K + 2m + 2$ cliques.
+  _Correctness, forward._ Given a source partition into $c$ cliques $C$, cover the target with $D_C={x_i,y_i : i in C}$ for each block, $Q_t={x_i,a_t,b_t,y_j}$ for each pair $t=(i,j)$, and the two cliques $L union {z_L}$, $R union {z_R}$. Source adjacency supplies the cross edges in every $D_C$. This family covers every target edge using $c+q+2$ cliques, including when $n=0$.
 
-  ($arrow.l.double$) Conversely, suppose $H$ has an edge-clique cover with at most $K + 2m + 2$ cliques. Each gadget edge $a_(i,j) b_(i,j)$ belongs to the unique maximal clique $Q_(i,j)$, so covering all $2m$ such edges requires at least $2m$ distinct cliques. Likewise, some clique must contain $z_L$ and some clique must contain $z_R$, and neither of those cliques can contain a matching edge $x_i y_i$. Hence at most $K$ cliques remain available for the matching edges. If two matching edges $x_i y_i$ and $x_j y_j$ lie in the same target clique, that clique contains the four vertices $x_i, y_i, x_j, y_j$, so in particular $x_i y_j$ is an edge of $H$; by construction this implies ${v_i,v_j} in E$. Therefore the source vertices whose matching edges share one target-clique label form a clique of $G$. Grouping each $v_i$ by the label used on $x_i y_i$ yields a partition of $V$ into at most $K$ cliques.
+  _Correctness, backward._ The edge $a_t b_t$ belongs to the unique maximal clique $Q_t$, since $a_t$ has only $b_t,y_j$ as right neighbors and $b_t$ only $a_t,x_i$ as left neighbors. No two such forced edges share a cover label, and none can share a label with a matching edge because $i != j$. The edges $z_L d_L$ and $z_R d_R$ force two further labels unavailable to gadget or matching edges. Thus $q+2$ labels are reserved in every feasible cover. Matching edges sharing a remaining label imply pairwise source adjacency, giving a source clique partition. Consequently the exact target optimum is $q+2+c$, where $c$ is the minimum source clique partition size and $c=0$ for the empty graph. Source satisfaction is therefore equivalent to target optimum at most $B$.
 
-  _Variable mapping._ The source witness labels source vertices by clique. The target witness labels target edges by the covering clique that contains them.
+  _Extraction._ Evaluate the target once through the formal validator, and reject infeasibility or a value exceeding $B$. Read matching-edge labels in source vertex order and compress their equality classes. The backward proof guarantees at most $min(K,n)$ source cliques. Aggregate extraction applies the same finite-value threshold. This also handles serialized bounds $K=0$ or $K>n$ without reconstructing a more restrictive source constructor.
 
-  _Solution extraction._ Inspect the label assigned to each matching edge $x_i y_i$. Compress the distinct matching-edge labels to $0, dots, k-1$ and assign source vertex $v_i$ to the compressed label of its matching edge. The previous paragraph proves that these label classes are source cliques, and the forced gadget/side cliques guarantee $k <= K$ whenever the target cover has size at most $K + 2m + 2$.
+  _Size and arithmetic._ The exact counts are $|V(H)|=2n+2q+4$ and $|E(H)|=(n+q)^2+4n+7q+2$. Substituting $q<=2m$ gives the registered upper bounds. Checked layout counts and conversion of the edge count to `i64` ensure finite cover values are representable; the threshold is checked separately. Such representation failures are errors, not source NO answers.
 ]
 
 #let mcbc_migb = load-example("MinimumCoveringByCliques", "MinimumIntersectionGraphBasis")
@@ -18641,11 +18470,11 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(mcbc_migb.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(mcbc_migb) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + mcbc_migb_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(mcbc_migb_sol.source_config),
     )
-    Source clique labels $(#mcbc_migb_sol.source_config.map(str).join(", "))$, target intersection witness $(#mcbc_migb_sol.target_config.map(str).join(", "))$.
+    Source clique labels $(#fmt-values(mcbc_migb_sol.source_config))$, target intersection witness $(#fmt-values(mcbc_migb_sol.target_config))$.
   ],
 )[
   This $O(n + m)$ identity reduction @garey1979[GT59] @erdosgoodmanposa1966 @kouStockmeyerWong1978 keeps the graph unchanged and reinterprets the objective. The minimum number of cliques covering all edges of $G$ equals the minimum universe size of an intersection representation of $G$, so the two optimization problems are equivalent reformulations.
@@ -18668,40 +18497,43 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_ker.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_ker) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_ker_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_ker_sol.source_config),
     )
 
     #{
       let n = ksat_ker.source.instance.num_vars
       let m = sat-num-clauses(ksat_ker.source.instance)
-      let selected = ksat_ker_sol.target_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+      let selected = ksat_ker_sol.target_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
       let literal-selected = selected.filter(v => v < 2 * n)
       let clause-selected = selected.filter(v => v >= 2 * n)
       let second-clause-base = 2 * n + 3
       let last-literal-vertex = literal-selected.at(literal-selected.len() - 1)
       [
-        *Step 1 -- Source instance.* 3-SAT with $n = #n$ variables and $m = #m$ clauses. The canonical satisfying assignment is $(#ksat_ker_sol.source_config.map(str).join(", "))$.
+        *Step 1 -- Source instance.* 3-SAT with $n = #n$ variables and $m = #m$ clauses. The canonical satisfying assignment is $(#fmt-values(ksat_ker_sol.source_config))$.
 
         *Step 2 -- Construct the digraph.* Variable gadgets contribute $2n = #(2 * n)$ literal vertices and $2n = #(2 * n)$ digon arcs. Clause gadgets contribute $3m = #(3 * m)$ clause vertices, $3m = #(3 * m)$ cycle arcs, and $3m = #(3 * m)$ literal arcs. Total: $#ksat_ker.target.instance.graph.num_vertices$ vertices and $#ksat_ker.target.instance.graph.arcs.len()$ arcs $= 2n + 6m$.
 
-        *Step 3 -- Verify the canonical witness.* The target kernel selects literal vertices ${#literal-selected.map(str).join(", ")}$ and clause vertices ${#clause-selected.map(str).join(", ")}$. Here ${#literal-selected.map(str).join(", ")}$ encode $(x_1, x_2, x_3) = (#ksat_ker_sol.source_config.map(str).join(", "))$, and the extra clause vertex $#(second-clause-base + 1)$ is needed in the second clause gadget: vertex $#second-clause-base$ is absorbed by arc $(#second-clause-base, #(second-clause-base + 1))$, while vertex $#(second-clause-base + 2)$ is absorbed by its literal arc to vertex $#last-literal-vertex$ #sym.checkmark.
+        *Step 3 -- Verify the canonical witness.* The target kernel selects literal vertices ${#fmt-values(literal-selected)}$ and clause vertices ${#fmt-values(clause-selected)}$. Here ${#fmt-values(literal-selected)}$ encode $(x_1, x_2, x_3) = (#fmt-values(ksat_ker_sol.source_config))$, and the extra clause vertex $#(second-clause-base + 1)$ is needed in the second clause gadget: vertex $#second-clause-base$ is absorbed by arc $(#second-clause-base, #(second-clause-base + 1))$, while vertex $#(second-clause-base + 2)$ is absorbed by its literal arc to vertex $#last-literal-vertex$ #sym.checkmark.
       ]
     }
 
     *Multiplicity:* The fixture stores one canonical witness.
   ],
 )[
-  This $O(n + m)$ reduction @garey1979 constructs a directed graph with $2n + 3m$ vertices and $2n + 6m$ arcs. Each variable contributes a digon on its positive and negative literal vertices, and each 3-clause contributes a directed 3-cycle whose three clause vertices point to the corresponding literal vertices. The implemented kernels may contain clause vertices as well as literal vertices.
+  This reduction uses variable digons and clause three-cycles, following the kernel hardness approach of @chvatal1973. With $a$ appearing variables, $m$ clauses and $L$ literal occurrences, the target has $2a + 3m$ vertices and $2a + 3m + L$ arcs. These are bounded by $2n + 3m$ and $2n + 6m$ on the native source domain. Each occurrence has its own clause vertex; kernels may include clause vertices as well as literals.
 ][
-  _Construction._ Let $phi = C_1 and dots and C_m$ be a 3-SAT instance on variables $x_1, dots, x_n$. For each variable $x_i$, create two literal vertices $p_i$ and $n_i$ with arcs $(p_i, n_i)$ and $(n_i, p_i)$. For each clause $C_j = (ell_(j,0) or ell_(j,1) or ell_(j,2))$, create clause vertices $c_(j,0), c_(j,1), c_(j,2)$ with cycle arcs $(c_(j,0), c_(j,1))$, $(c_(j,1), c_(j,2))$, and $(c_(j,2), c_(j,0))$. Add one literal arc $(c_(j,t), v(ell_(j,t)))$ from each clause vertex to the literal vertex representing its own literal. Thus each clause contributes 3 cycle arcs and 3 literal arcs, for a total of $2n + 6m$ arcs.
+  _Construction._ Collect the sorted original indices $J$ of appearing variables, with $a = |J|$. For each compact variable $i$, create literal vertices $p_i, n_i$ and both digon arcs. Each native clause has zero through three literals. Create three vertices $c_(j,0), c_(j,1), c_(j,2)$ and the directed cycle in that order, then add $(c_(j,t), v(ell_(j,t)))$ only for its actual literal positions. Repeated literals keep separate occurrence vertices. An empty clause therefore produces a three-cycle with no outgoing literal arcs, which has no kernel; an empty formula produces an empty graph, whose empty selection is a kernel. No padding is needed.
+
+  _Correctness._ ($arrow.r.double$) Given a satisfying source assignment, choose its true literal in each digon. Let $t_r$ indicate whether the literal at clause position $r$ is selected, with missing positions set to false. Select clause vertex $r$ exactly when $not t_r and t_((r+1) mod 3)$. A selected vertex points to no selected literal, and its successor cannot be selected, so independence holds. An unselected vertex with $t_r$ true is absorbed through its literal arc. Otherwise both $t_r$ and $t_((r+1) mod 3)$ are false. Since the clause is satisfied, $t_((r+2) mod 3)$ is true; its cycle successor is therefore selected and absorbs it. Unselected literal vertices are absorbed by their digon partners.
+
+  ($arrow.l.double$) Each literal vertex has only its digon partner as an outgoing neighbor. Independence and absorption force exactly one selected endpoint per variable. If a clause has no selected literal, absorption must occur entirely within its directed three-cycle. Independence permits at most one selected cycle vertex, which cannot absorb both others. This contradiction proves that every clause is satisfied, including the native short-clause semantics. This proof does not require distinct variables or a particular literal order.
 
-  _Correctness._ ($arrow.r.double$) Let $alpha$ be a satisfying assignment. Put into $K$ exactly one literal vertex from each digon: $p_i$ if $alpha(x_i) = "true"$ and $n_i$ otherwise. For each clause $C_j$, additionally put $c_(j,t)$ into $K$ exactly when $ell_(j,t)$ is false and $ell_(j,(t+1) mod 3)$ is true. This never creates an arc inside $K$: each selected clause vertex points to a false literal vertex, and two adjacent clause vertices cannot both satisfy the selection rule. Every unselected literal vertex is absorbed by its digon partner. For an unselected clause vertex $c_(j,t)$, either $ell_(j,t)$ is true, so its literal arc hits the selected literal vertex, or $ell_(j,t)$ is false. In the latter case $c_(j,t)$ was not selected, so $ell_(j,(t+1) mod 3)$ is also false; because the clause is satisfied, $ell_(j,(t+2) mod 3)$ is true, hence $c_(j,(t+1) mod 3)$ was selected and absorbs $c_(j,t)$ along the cycle.
+  _Solution extraction._ Validate the target selection once using the formal target evaluator and reject $"Or(false)"$. Initialize a length-$n$ false vector and restore each original position $J_i$ from the selection of $p_i$. Unused variables remain false; selected clause vertices are ignored. The concrete value types are $"Or" arrow.r "Or"$.
 
-  ($arrow.l.double$) Let $K$ be a kernel of the constructed digraph. In each variable digon, at most one literal vertex can lie in $K$ by independence, and at least one must lie in $K$ to absorb the other endpoint; so each digon contributes exactly one selected literal vertex. Set $alpha(x_i) = "true"$ iff $p_i in K$. Now fix a clause gadget with cycle $(c_(j,0), c_(j,1), c_(j,2))$. If none of its three literal vertices were selected, then the only possible absorbers for $c_(j,0), c_(j,1), c_(j,2)$ would be the cycle successors. Independence allows at most one clause vertex in $K$, but one selected vertex on a directed 3-cycle cannot absorb the other two, contradiction. Therefore every clause has at least one selected literal vertex, so $alpha$ satisfies every clause.
+  _Bounds and native arithmetic._ Since $a <= L <= 3m$, the target has at most $9m$ vertices and $12m$ arcs. The registered relations use upper bounds in the declared source parameters, covering sparse variables and short clauses. Counts are checked before allocation, and every vertex index is bounded by the checked total. A successfully allocated native clause vector also bounds $m$ by its element layout and the address space; original sparse indices are never doubled. Allocation limits do not represent mathematical infeasibility.
 
-  _Solution extraction._ Read only the positive literal vertices: $alpha(x_i) = 1$ iff the even-indexed vertex for $x_i$ is in the kernel. Any selected clause vertices are ignored during extraction.
 ]
 
 // 7. HamiltonianPath → DegreeConstrainedSpanningTree (#911)
@@ -18713,16 +18545,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hp_dcst.source) + " -o hampath.json",
-      "pred reduce hampath.json --to " + target-spec(hp_dcst) + " -o bundle.json",
+      "pred reduce hampath.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hampath.json --config " + hp_dcst_sol.source_config.map(str).join(","),
+      "pred evaluate hampath.json --config " + cli-config(hp_dcst_sol.source_config),
     )
 
     *Step 1 -- Source instance.* Graph $G$ with $n = #graph-num-vertices(hp_dcst.source.instance)$ vertices and $|E| = #graph-num-edges(hp_dcst.source.instance)$ edges.
 
     *Step 2 -- Identity reduction.* Target graph is identical: $n = #graph-num-vertices(hp_dcst.target.instance)$ vertices, $|E| = #graph-num-edges(hp_dcst.target.instance)$ edges, degree bound $K = #hp_dcst.target.instance.max_degree$.
 
-    *Step 3 -- Verify a solution.* Hamiltonian path visits vertices in order $(#hp_dcst_sol.source_config.map(str).join(", "))$. The corresponding spanning tree selects #hp_dcst_sol.target_config.filter(x => x == 1).len() edges (all with max degree $<= 2$) #sym.checkmark.
+    *Step 3 -- Verify a solution.* Hamiltonian path visits vertices in order $(#fmt-values(hp_dcst_sol.source_config))$. The corresponding spanning tree selects #hp_dcst_sol.target_config.filter(x => x).len() edges (all with max degree $<= 2$) #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness.
   ],
@@ -18745,21 +18577,21 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(nae_ss.source) + " -o naesat.json",
-      "pred reduce naesat.json --to " + target-spec(nae_ss) + " -o bundle.json",
+      "pred reduce naesat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate naesat.json --config " + nae_ss_sol.source_config.map(str).join(","),
+      "pred evaluate naesat.json --config " + cli-config(nae_ss_sol.source_config),
     )
 
     #{
       let colors = nae_ss_sol.target_config
       [
-        *Step 1 -- Source instance.* The fixture has clauses $C_1 = (x_1 or overline(x_2) or x_3)$ and $C_2 = (overline(x_1) or x_2 or overline(x_3))$. The canonical NAE assignment is $(#nae_ss_sol.source_config.map(str).join(", "))$, so the two clauses evaluate to $(1, 0, 1)$ and $(0, 1, 0)$ respectively.
+        *Step 1 -- Source instance.* The fixture has clauses $C_1 = (x_1 or overline(x_2) or x_3)$ and $C_2 = (overline(x_1) or x_2 or overline(x_3))$. The canonical NAE assignment is $(#fmt-values(nae_ss_sol.source_config))$, so the two clauses evaluate to $(1, 0, 1)$ and $(0, 1, 0)$ respectively.
 
         *Step 2 -- Build the universe and complementarity subsets.* The reduction creates $U = {0, dots, #(nae_ss.target.instance.universe_size - 1)}$ with positive literals on $\{0, 1, 2\}$ and negative literals on $\{3, 4, 5\}$. The first three target subsets are $R_1 = {#nae_ss.target.instance.subsets.at(0).map(str).join(", ")}$, $R_2 = {#nae_ss.target.instance.subsets.at(1).map(str).join(", ")}$, and $R_3 = {#nae_ss.target.instance.subsets.at(2).map(str).join(", ")}$.
 
-        *Step 3 -- Encode the clauses as set-splitting constraints.* Clause $C_1$ becomes $T_1 = {#nae_ss.target.instance.subsets.at(3).map(str).join(", ")}$, and clause $C_2$ becomes $T_2 = {#nae_ss.target.instance.subsets.at(4).map(str).join(", ")}$. Under the target coloring $(#colors.map(str).join(", "))$, $T_1$ receives colors $(#colors.at(0), #colors.at(4), #colors.at(2))$ and $T_2$ receives $(#colors.at(3), #colors.at(1), #colors.at(5))$, so both subsets are non-monochromatic.
+        *Step 3 -- Encode the clauses as set-splitting constraints.* Clause $C_1$ becomes $T_1 = {#nae_ss.target.instance.subsets.at(3).map(str).join(", ")}$, and clause $C_2$ becomes $T_2 = {#nae_ss.target.instance.subsets.at(4).map(str).join(", ")}$. Under the target coloring $(#fmt-values(colors))$, $T_1$ receives colors $(#colors.at(0), #colors.at(4), #colors.at(2))$ and $T_2$ receives $(#colors.at(3), #colors.at(1), #colors.at(5))$, so both subsets are non-monochromatic.
 
-        *Step 4 -- Verify the witness pair.* Every complementarity pair has opposite colors: $(0, 3)$ gives $(#colors.at(0), #colors.at(3))$, $(1, 4)$ gives $(#colors.at(1), #colors.at(4))$, and $(2, 5)$ gives $(#colors.at(2), #colors.at(5))$. Reading the positive-literal colors $(#colors.at(0), #colors.at(1), #colors.at(2))$ recovers the source assignment $(#nae_ss_sol.source_config.map(str).join(", "))$ #sym.checkmark.
+        *Step 4 -- Verify the witness pair.* Every complementarity pair has opposite colors: $(0, 3)$ gives $(#colors.at(0), #colors.at(3))$, $(1, 4)$ gives $(#colors.at(1), #colors.at(4))$, and $(2, 5)$ gives $(#colors.at(2), #colors.at(5))$. Reading the positive-literal colors $(#colors.at(0), #colors.at(1), #colors.at(2))$ recovers the source assignment $(#fmt-values(nae_ss_sol.source_config))$ #sym.checkmark.
       ]
     }
 
@@ -18784,22 +18616,22 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(nae_ppm.source) + " -o naesat.json",
-      "pred reduce naesat.json --to " + target-spec(nae_ppm) + " -o bundle.json",
+      "pred reduce naesat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate naesat.json --config " + nae_ppm_sol.source_config.map(str).join(","),
+      "pred evaluate naesat.json --config " + cli-config(nae_ppm_sol.source_config),
     )
 
     #{
       let target = nae_ppm.target.instance
       let config = nae_ppm_sol.target_config
       [
-        *Step 1 -- Source instance.* The canonical NAE-SAT fixture has clauses $C_1 = (x_1 or x_2 or x_3)$ and $C_2 = (overline(x_1) or x_2 or overline(x_3))$. The stored source witness is $(#nae_ppm_sol.source_config.map(str).join(", "))$, so the clause truth patterns are $(1, 1, 0)$ and $(0, 1, 1)$, hence both clauses satisfy the NAE condition.
+        *Step 1 -- Source instance.* The canonical NAE-SAT fixture has clauses $C_1 = (x_1 or x_2 or x_3)$ and $C_2 = (overline(x_1) or x_2 or overline(x_3))$. The stored source witness is $(#fmt-values(nae_ppm_sol.source_config))$, so the clause truth patterns are $(1, 1, 0)$ and $(0, 1, 1)$, hence both clauses satisfy the NAE condition.
 
         *Step 2 -- Lay out the gadgets.* Each variable contributes 4 vertices, each clause contributes 6 signal vertices and 4 clause-gadget vertices, and each literal occurrence contributes one 2-vertex equality-chain pair. Concretely the target has $#target.graph.num_vertices$ vertices and $#target.graph.edges.len()$ edges: variable gadgets occupy vertices $0, dots, 11$, signal pairs occupy $12, dots, 23$, the two $K_4$ clause gadgets occupy $24, dots, 31$, and the equality-chain pairs occupy $32, dots, 43$.
 
         *Step 3 -- Propagate the literal values.* Because $x_1 = x_2 = 1$ and $x_3 = 0$, the three signal vertices for clause $C_1$ are in groups $(#config.at(12), #config.at(14), #config.at(16)) = (0, 0, 1)$, while the three signal vertices for clause $C_2$ are in groups $(#config.at(18), #config.at(20), #config.at(22)) = (1, 0, 0)$. The equality-chain pairs at $(32, 33), dots, (42, 43)$ carry the complementary groups needed to keep each copied signal synchronized with the appropriate $t_i$ or $f_i$.
 
-        *Step 4 -- Verify the clause gadgets and extraction.* The first $K_4$ gadget uses groups $(#config.at(24), #config.at(25), #config.at(26), #config.at(27)) = (1, 1, 0, 0)$, and the second uses $(#config.at(28), #config.at(29), #config.at(30), #config.at(31)) = (0, 1, 1, 0)$. Each gadget therefore splits $2 + 2$, so every clause gadget induces a perfect matching inside each group. Reading the truth assignment back from the variable vertices $(0, 4, 8)$ gives groups $(#config.at(0), #config.at(4), #config.at(8)) = (0, 0, 1)$, which extracts to $(#nae_ppm_sol.source_config.map(str).join(", "))$ #sym.checkmark.
+        *Step 4 -- Verify the clause gadgets and extraction.* The first $K_4$ gadget uses groups $(#config.at(24), #config.at(25), #config.at(26), #config.at(27)) = (1, 1, 0, 0)$, and the second uses $(#config.at(28), #config.at(29), #config.at(30), #config.at(31)) = (0, 1, 1, 0)$. Each gadget therefore splits $2 + 2$, so every clause gadget induces a perfect matching inside each group. Reading the truth assignment back from the variable vertices $(0, 4, 8)$ gives groups $(#config.at(0), #config.at(4), #config.at(8)) = (0, 0, 1)$, which extracts to $(#fmt-values(nae_ppm_sol.source_config))$ #sym.checkmark.
 
         *Multiplicity:* The fixture stores one canonical witness.
       ]
@@ -18828,21 +18660,21 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(x3c_sp.source) + " -o x3c.json",
-      "pred reduce x3c.json --to " + target-spec(x3c_sp) + " -o bundle.json",
+      "pred reduce x3c.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate x3c.json --config " + x3c_sp_sol.source_config.map(str).join(","),
+      "pred evaluate x3c.json --config " + cli-config(x3c_sp_sol.source_config),
     )
 
     #{
       let sizes = x3c_sp.target.instance.sizes
       [
-        *Step 1 -- Source instance.* The fixture has $U = {0, dots, #(x3c_sp.source.instance.universe_size - 1)}$ and three 3-sets: $C_0 = {#x3c_sp.source.instance.subsets.at(0).map(str).join(", ")}$, $C_1 = {#x3c_sp.source.instance.subsets.at(1).map(str).join(", ")}$, and $C_2 = {#x3c_sp.source.instance.subsets.at(2).map(str).join(", ")}$. The witness $(#x3c_sp_sol.source_config.map(str).join(", "))$ selects $C_0$ and $C_1$.
+        *Step 1 -- Source instance.* The fixture has $U = {0, dots, #(x3c_sp.source.instance.universe_size - 1)}$ and three 3-sets: $C_0 = {#x3c_sp.source.instance.subsets.at(0).map(str).join(", ")}$, $C_1 = {#x3c_sp.source.instance.subsets.at(1).map(str).join(", ")}$, and $C_2 = {#x3c_sp.source.instance.subsets.at(2).map(str).join(", ")}$. The witness $(#fmt-values(x3c_sp_sol.source_config))$ selects $C_0$ and $C_1$.
 
         *Step 2 -- Recover the prime assignment from the concrete products.* The target numbers are $s_0 = #sizes.at(0) = 2 dot 3 dot 5$, $s_1 = #sizes.at(1) = 7 dot 11 dot 13$, and $s_2 = #sizes.at(2) = 2 dot 7 dot 11$. Thus the six universe elements are concretely labeled by the primes $(2, 3, 5, 7, 11, 13)$.
 
         *Step 3 -- Form the Subset Product instance.* The target product is $B = #x3c_sp.target.instance.target = 2 dot 3 dot 5 dot 7 dot 11 dot 13$. Selecting the first two source subsets therefore means selecting target numbers $(#sizes.at(0), #sizes.at(1))$.
 
-        *Step 4 -- Verify the witness pair.* The selected sets $C_0$ and $C_1$ are disjoint and cover all six elements exactly once, and on the target side $#sizes.at(0) dot #sizes.at(1) = #x3c_sp.target.instance.target$ while $#sizes.at(2)$ is omitted. Because the configuration is unchanged, the target witness $(#x3c_sp_sol.target_config.map(str).join(", "))$ extracts back to the same exact cover #sym.checkmark.
+        *Step 4 -- Verify the witness pair.* The selected sets $C_0$ and $C_1$ are disjoint and cover all six elements exactly once, and on the target side $#sizes.at(0) dot #sizes.at(1) = #x3c_sp.target.instance.target$ while $#sizes.at(2)$ is omitted. Because the configuration is unchanged, the target witness $(#fmt-values(x3c_sp_sol.target_config))$ extracts back to the same exact cover #sym.checkmark.
       ]
     }
 
@@ -18869,28 +18701,28 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(x3c_bdst.source) + " -o x3c.json",
-      "pred reduce x3c.json --to " + target-spec(x3c_bdst) + " -o bundle.json",
+      "pred reduce x3c.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate x3c.json --config " + x3c_bdst_sol.source_config.map(str).join(","),
+      "pred evaluate x3c.json --config " + cli-config(x3c_bdst_sol.source_config),
     )
 
     #let q = x3c_bdst.source.instance.universe_size / 3
     #let m = x3c_bdst.source.instance.subsets.len()
     *Step 1 -- Source instance.* The X3C fixture has universe $U = {0, dots, #(x3c_bdst.source.instance.universe_size - 1)}$ with $q = #q$ and candidate triples
     #for (i, s) in x3c_bdst.source.instance.subsets.enumerate() [
-      $C_#i = {#s.map(str).join(", ")}$#if i < m - 1 [, ] else [.]
+      $C_#i = {#fmt-values(s)}$#if i < m - 1 [, ] else [.]
     ]
 
     *Step 2 -- Build the spanning-tree gadget.* Create a root $r$, two forced-path vertices $v_1, v_2$, one set vertex $s_i$ per triple, and one element vertex $e_j$ per universe element. The target therefore has $#x3c_bdst_nv = 3 + #m + #(x3c_bdst.source.instance.universe_size)$ vertices and $#x3c_bdst_ne$ weighted edges: the forced path $(r, v_1), (v_1, v_2)$ at weight $1$, the root-to-set edges $(r, s_i)$ at weight $2$, the set-to-element edges $(s_i, e_j)$ for $j in C_i$ at weight $1$, and the set clique $(s_i, s_(i'))$ at weight $1$. The bounds are $D = #x3c_bdst.target.instance.diameter_bound$ and $B = 4q + m + 2 = #x3c_bdst.target.instance.weight_bound$.
 
-    *Step 3 -- Verify the canonical witness.* The stored source configuration $(#x3c_bdst_sol.source_config.map(str).join(", "))$ selects subsets ${#x3c_bdst_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => "C_" + str(i)).join(", ")}$. The corresponding tree keeps the forced path, every root-to-set edge for a selected $s_i$, every $(s_i, e_j)$ for $j in C_i$, and one clique edge to attach each remaining set vertex. With $q = #q$ selected sets it has total weight $2 + 2q + 3q + (m - q) = #(2 + 2 * q + 3 * q + m - q) = B$ and every vertex sits within distance $2$ of $r$, so the diameter is at most $4$ #sym.checkmark.
+    *Step 3 -- Verify the canonical witness.* The stored source configuration $(#fmt-values(x3c_bdst_sol.source_config))$ selects subsets ${#x3c_bdst_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => "C_" + str(i)).join(", ")}$. The corresponding tree keeps the forced path, every root-to-set edge for a selected $s_i$, every $(s_i, e_j)$ for $j in C_i$, and one clique edge to attach each remaining set vertex. With $q = #q$ selected sets it has total weight $2 + 2q + 3q + (m - q) = #(2 + 2 * q + 3 * q + m - q) = B$ and every vertex sits within distance $2$ of $r$, so the diameter is at most $4$ #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness. Any feasible spanning tree of weight $B$ and diameter $D = 4$ corresponds to an exact cover via the same extractor, so additional witnesses, when they exist, just enumerate other exact covers.
   ],
 )[
-  This $O(m^2 + q)$ reduction @garey1979[ND4] embeds X3C into the spanning-tree gadget of Bounded Diameter Spanning Tree. The constructed graph has $3 + m + 3q$ vertices and $2 + 4m + binom(m, 2)$ edges with weights in ${1, 2}$. Setting $D = 4$ and $B = 4q + m + 2$, the BDST instance is feasible if and only if the X3C instance has an exact cover.
+  The X3C hardness route is catalogued in @garey1979[ND4]. The following $O(1 + m^2 + q)$ construction and proof embed X3C into the spanning-tree gadget of Bounded Diameter Spanning Tree. The constructed graph has $3 + m + 3q$ vertices and $2 + 4m + binom(m, 2)$ edges with weights in ${1, 2}$. Setting $D = 4$ and $B = 4q + m + 2$, the BDST instance is feasible if and only if the X3C instance has an exact cover.
 ][
-  _Construction._ Let the X3C instance be $(U, cal(C))$ with $|U| = 3q$ and $cal(C) = {C_0, dots, C_(m-1)}$. Introduce a root vertex $r$, two forced-path vertices $v_1, v_2$, set vertices $s_0, dots, s_(m-1)$, and element vertices $e_0, dots, e_(3q-1)$. Add the edges
+  _Construction._ Let the X3C instance be $(U, cal(C))$ with $|U| = 3q$ and $cal(C) = {C_0, dots, C_(m-1)}$. First compute the union of all triples. If it omits any universe element, return two isolated vertices with weight bound $1$ and diameter bound $4$: both problems are NO. Otherwise introduce a root vertex $r$, two forced-path vertices $v_1, v_2$, set vertices $s_0, dots, s_(m-1)$, and element vertices $e_0, dots, e_(3q-1)$. Add the edges
   $
     (r, v_1) " and " (v_1, v_2) " of weight " 1, quad (r, s_i) " of weight " 2 " for every " i,
   $
@@ -18899,11 +18731,14 @@ The following table shows concrete variable overhead for example instances, take
   $
   Set the diameter bound $D = 4$ and the weight bound $B = 4q + m + 2$.
 
-  _Correctness._ ($arrow.r.double$) Let $cal(C)' = {C_(i_1), dots, C_(i_q)}$ be an exact cover. Pick the forced-path edges, the $q$ root-to-set edges for the chosen indices, the $3q$ set-to-element edges that match the cover, and for every unselected set $C_i$ a single clique edge to some chosen set. This is a spanning tree of weight $2 + 2q + 3q + (m - q) = 4q + m + 2 = B$, and every vertex lies within distance $2$ of $r$, so the diameter is at most $4 = D$.
+  _Correctness._ ($arrow.r.double$) Let $cal(C)' = {C_(i_1), dots, C_(i_q)}$ be an exact cover. The coverage test cannot reject it. If $q = 0$, the legal collection is empty and the forced two-edge path is already a feasible tree. Otherwise $q >= 1$. Pick the forced-path edges, the $q$ root-to-set edges for the chosen indices, the $3q$ set-to-element edges that match the cover, and for every unselected set $C_i$ a single clique edge to some chosen set. This is a spanning tree of weight $2 + 2q + 3q + (m - q) = 4q + m + 2 = B$, and every vertex lies within distance $2$ of $r$, so the diameter is at most $4 = D$.
+
+  ($arrow.l.double$) Suppose $T$ is a spanning tree of weight at most $B$ and diameter at most $4$. Because $"dist"_T(r, v_2) = 2$ in any tree containing the forced edges, every other vertex must sit within distance $2$ of $r$; otherwise its distance to $v_2$ would exceed $4$. Element vertices $e_j$ have neighbors only among set vertices, so each $e_j$ is at depth $2$ and connects through some $s_i$ that is directly attached to $r$. Let $k$ be the number of root-to-set edges in $T$. Every spanning tree has exactly $m + 3q + 2$ edges, and exactly the $k$ root-to-set edges have weight $2$ rather than $1$. Its weight is therefore exactly $k + m + 3q + 2$. Feasibility forces $k <= q$. Each chosen set covers at most three element vertices, so covering all $3q$ elements requires $k >= q$, hence $k = q$. The $q$ chosen sets contribute exactly $3q$ element attachments, so they must be pairwise disjoint and form an exact cover.
+
+  _Solution extraction._ First evaluate the target once and reject every configuration that is not a feasible bounded-diameter spanning tree. The fixed disconnected target has no accepted certificates. The target configuration has one coordinate per edge in the order produced by the construction. The $m$ coordinates indexing the root-to-set edges $(r, s_i)$ are the X3C selection vector: $x_i = 1$ iff $(r, s_i) in T$.
 
-  ($arrow.l.double$) Suppose $T$ is a spanning tree of weight at most $B$ and diameter at most $4$. Because $"dist"_T(r, v_2) = 2$ in any tree containing the forced edges, every other vertex must sit within distance $2$ of $r$; otherwise its distance to $v_2$ would exceed $4$. Element vertices $e_j$ have neighbors only among set vertices, so each $e_j$ is at depth $2$ and connects through some $s_i$ that is directly attached to $r$. Let $k$ be the number of root-to-set edges in $T$. The cheapest way to spawn the remaining $m - k$ set vertices uses clique edges of weight $1$, so the minimum tree weight is $k dot 2 + (m - k) dot 1 + 3q dot 1 + 2 dot 1 = k + m + 3q + 2$. Feasibility forces $k <= q$. Each chosen set covers at most three element vertices, so covering all $3q$ elements requires $k >= q$, hence $k = q$. The $q$ chosen sets contribute exactly $3q$ element attachments, so they must be pairwise disjoint and form an exact cover.
+  _Range and size._ Compute the union from the triples, without allocating an array indexed by the universe. Thus a large universe with no possible cover is handled before graph allocation. In the incidence branch the union test gives $3q <= 3m$. Vertex and edge counts and the weight bound are checked before allocation; all generated weights are positive. The target has at most $3 + m + 3q$ vertices and $2 + 4m + binom(m, 2)$ edges, including the disconnected NO target. Repeated triples remain separate set vertices; the exact-cover counting proof still applies.
 
-  _Solution extraction._ The target configuration has one coordinate per edge in the order produced by the construction. The $m$ coordinates indexing the root-to-set edges $(r, s_i)$ are the X3C selection vector: $x_i = 1$ iff $(r, s_i) in T$.
 ]
 
 // 8. SubsetSum → IntegerExpressionMembership (#569)
@@ -18915,19 +18750,19 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ss_iem.source) + " -o subsetsum.json",
-      "pred reduce subsetsum.json --to " + target-spec(ss_iem) + " -o bundle.json",
+      "pred reduce subsetsum.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate subsetsum.json --config " + ss_iem_sol.source_config.map(str).join(","),
+      "pred evaluate subsetsum.json --config " + cli-config(ss_iem_sol.source_config),
     )
 
     #{
       let sizes = ss_iem.source.instance.sizes
       [
-        *Step 1 -- Source instance.* The Subset Sum fixture has sizes $(#sizes.join(", "))$ and target $B = #ss_iem.source.instance.target$. The canonical source configuration $(#ss_iem_sol.source_config.map(str).join(", "))$ selects the second and third items, so the source sum is $5 + 6 = #ss_iem.source.instance.target$.
+        *Step 1 -- Source instance.* The Subset Sum fixture has sizes $(#sizes.join(", "))$ and target $B = #ss_iem.source.instance.target$. The canonical source configuration $(#fmt-values(ss_iem_sol.source_config))$ selects the second and third items, so the source sum is $5 + 6 = #ss_iem.source.instance.target$.
 
         *Step 2 -- Build the choice sets inside the expression.* Each source item contributes one union node $(1 union (s_i + 1))$, so the concrete choices are $(1 union 2)$, $(1 union 6)$, $(1 union 7)$, and $(1 union 9)$. With $n = #ss_iem_sol.target_config.len()$ union nodes, the target is shifted to $K = B + n = #ss_iem.target.instance.target$.
 
-        *Step 3 -- Follow the canonical branch choices.* The target configuration $(#ss_iem_sol.target_config.map(str).join(", "))$ means left, right, right, left, so the chosen branch values are $1$, $6$, $7$, and $1$.
+        *Step 3 -- Follow the canonical branch choices.* The target configuration $(#fmt-values(ss_iem_sol.target_config))$ means left, right, right, left, so the chosen branch values are $1$, $6$, $7$, and $1$.
 
         *Step 4 -- Verify the equality.* The target-side sum is $1 + 6 + 7 + 1 = #ss_iem.target.instance.target$, exactly matching $K$. The right branches occur in the same two positions as the chosen source elements, so extracting the target witness returns the original Subset Sum solution #sym.checkmark.
       ]
@@ -18956,16 +18791,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(ksat_si.source) + " -o ksat.json",
-      "pred reduce ksat.json --to " + target-spec(ksat_si) + " -o bundle.json",
+      "pred reduce ksat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate ksat.json --config " + ksat_si_sol.source_config.map(str).join(","),
+      "pred evaluate ksat.json --config " + cli-config(ksat_si_sol.source_config),
     )
 
     #{
       let pairs = ksat_si.target.instance.pairs
-      let x = ksat_si_sol.target_config.at(0)
+      let x = ksat_si_sol.target_config
       [
-        *Step 1 -- Source instance.* The two clauses are $C_1 = (x_1 or x_2 or x_2)$ and $C_2 = (overline(x_1) or x_2 or x_2)$. The canonical satisfying assignment is $(#ksat_si_sol.source_config.map(str).join(", "))$.
+        *Step 1 -- Source instance.* The two clauses are $C_1 = (x_1 or x_2 or x_2)$ and $C_2 = (overline(x_1) or x_2 or x_2)$. The canonical satisfying assignment is $(#fmt-values(ksat_si_sol.source_config))$.
 
         *Step 2 -- Assign primes and variable residue constraints.* With two variables, the reduction uses primes $3$ and $5$. The variable-generated forbidden pairs are $(#pairs.at(0).at(0), #pairs.at(0).at(1))$, $(#pairs.at(1).at(0), #pairs.at(1).at(1))$, $(#pairs.at(2).at(0), #pairs.at(2).at(1))$, and $(#pairs.at(3).at(0), #pairs.at(3).at(1))$, leaving only residues $1$ and $2$ modulo $3$ and modulo $5$.
 
@@ -18995,11 +18830,11 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(n3dm_nmts.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(n3dm_nmts) + " -o bundle.json",
+      "pred reduce source.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate source.json --config " + n3dm_nmts_sol.source_config.map(str).join(","),
+      "pred evaluate source.json --config " + cli-config(n3dm_nmts_sol.source_config),
     )
-    Source N3DM witness $(#n3dm_nmts_sol.source_config.map(str).join(", "))$, target NMTS pairing $(#n3dm_nmts_sol.target_config.map(str).join(", "))$.
+    Source N3DM witness $(#fmt-values(n3dm_nmts_sol.source_config))$, target NMTS pairing $(#fmt-values(n3dm_nmts_sol.target_config))$.
   ],
 )[
   This linear-time reduction @garey1979 keeps the $X$ and $Y$ sets unchanged and replaces each $w_i in W$ by a target complement $B_i = B - s(w_i)$. For an instance with $m$ triples, the target has $m$ pairs.
@@ -19020,19 +18855,19 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(part_stw.source) + " -o partition.json",
-      "pred reduce partition.json --to " + target-spec(part_stw) + " -o bundle.json",
+      "pred reduce partition.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate partition.json --config " + part_stw_sol.source_config.map(str).join(","),
+      "pred evaluate partition.json --config " + cli-config(part_stw_sol.source_config),
     )
 
     #{
       let lengths = part_stw.target.instance.lengths
       let weights = part_stw.target.instance.weights
       let deadline = part_stw.target.instance.deadlines.at(0)
-      let on-time-sum = part_stw_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => part_stw.source.instance.sizes.at(i)).sum()
-      let tardy-sum = part_stw_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => part_stw.source.instance.sizes.at(i)).sum()
+      let on-time-sum = part_stw_sol.source_config.enumerate().filter(((i, x)) => not x).map(((i, x)) => part_stw.source.instance.sizes.at(i)).sum()
+      let tardy-sum = part_stw_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => part_stw.source.instance.sizes.at(i)).sum()
       [
-        *Step 1 -- Source instance.* The Partition fixture has sizes $(#part_stw.source.instance.sizes.map(str).join(", "))$ with total $#part_stw.source.instance.sizes.sum()$, so the target deadline is $T = #deadline$. The canonical source vector $(#part_stw_sol.source_config.map(str).join(", "))$ splits the multiset into sums $#on-time-sum$ and $#tardy-sum$.
+        *Step 1 -- Source instance.* The Partition fixture has sizes $(#fmt-values(part_stw.source.instance.sizes))$ with total $#part_stw.source.instance.sizes.sum()$, so the target deadline is $T = #deadline$. The canonical source vector $(#fmt-values(part_stw_sol.source_config))$ splits the multiset into sums $#on-time-sum$ and $#tardy-sum$.
 
         *Step 2 -- Build the task table.* #table(
           columns: (auto, auto, auto, auto),
@@ -19047,22 +18882,25 @@ The following table shows concrete variable overhead for example instances, take
           [$t_5$], [#lengths.at(5)], [#weights.at(5)], [#deadline],
         )
 
-        *Step 3 -- Follow the canonical schedule.* The target permutation $(#part_stw_sol.target_config.map(str).join(", "))$ schedules tasks in the order $t_1, t_2, t_4, t_5, t_0, t_3$. The completion times are $1, 2, 4, 5, 8, 10$, so $t_1, t_2, t_4, t_5$ are on time and $t_0, t_3$ are tardy.
+        *Step 3 -- Follow the canonical schedule.* The target permutation $(#fmt-values(part_stw_sol.target_config))$ schedules tasks in the order $t_1, t_2, t_4, t_5, t_0, t_3$. The completion times are $1, 2, 4, 5, 8, 10$, so $t_1, t_2, t_4, t_5$ are on time and $t_0, t_3$ are tardy.
 
-        *Step 4 -- Compute tardy weight and recover the partition.* Because weights equal lengths here, the tardy weight is $w_0 + w_3 = 3 + 2 = #deadline$, and the on-time tasks have total size $#on-time-sum$ while the tardy tasks have total size #tardy-sum. Extracting the schedule therefore returns the balanced partition $(#part_stw_sol.source_config.map(str).join(", "))$ #sym.checkmark.
+        *Step 4 -- Compute tardy weight and recover the partition.* Because weights equal lengths here, the tardy weight is $w_0 + w_3 = 3 + 2 = #deadline$, and the on-time tasks have total size $#on-time-sum$ while the tardy tasks have total size #tardy-sum. Extracting the schedule therefore returns the balanced partition $(#fmt-values(part_stw_sol.source_config))$ #sym.checkmark.
       ]
     }
 
     *Multiplicity:* The fixture stores one canonical witness.
   ],
 )[
-  This $O(n)$ reduction @karp1972 maps each element $a_i$ to a task with length $l(t_i) = a_i$, weight $w(t_i) = a_i$, and common deadline $T = B\/2$. The tardiness bound is $K = T$. Tasks scheduled before $T$ are on-time; those after are tardy. A balanced partition exists iff total tardy weight can be at most $K$.
+  This $O(n)$ specialization of Karp's common-deadline sequencing construction @karp1972 maps each element $a_i$ to a task with processing time and tardy weight $a_i$. For total $S$, use common deadline $B = floor(S / 2)$. A balanced partition exists exactly when the minimum tardy weight is $B$; other optimum values map to false through the formal aggregate reduction.
 ][
-  _Construction._ Given Partition instance $A = {a_1, dots, a_n}$ with total $B$. If $B$ is odd, output a trivially infeasible instance (all deadlines 0, $K = 0$). If $B$ is even, set $T = B\/2$. For each $a_i$, create task $t_i$ with $l(t_i) = w(t_i) = a_i$ and deadline $d(t_i) = T$. Set bound $K = T$.
+  _Construction._ The source has $n >= 1$ positive sizes with checked total $S$. Create $n$ tasks in source order, each with length and weight $a_i$, and deadline $B = floor(S / 2)$. The construction is identical for odd and even totals. Karp's original paper gives Knapsack to Job Sequencing (p. 100), with equal processing times and penalties and a common deadline; the Partition specialization and its optimization certificate are proved here.
 
-  _Correctness._ ($arrow.r.double$) A balanced partition $A', A''$ with sums $T$ each: schedule $A'$ first (on-time, total time $T$), then $A''$ (tardy, weight $T = K$). ($arrow.l.double$) If tardy weight $<= K = T$, then on-time tasks fit before $T$ and sum to $<= T$, while tardy tasks have weight $B - sum_("on-time") <= T$, forcing on-time sum $= T$. This yields a balanced partition.
+  _Correctness._ Let $E$ be the total size of tasks completing by $B$ in any valid permutation. Positive processing times make these tasks a prefix, so $E <= B$. Because weights equal processing times, tardy weight is $W = S - E >= S - B >= B$.
+  ($arrow.r.double$) For a balanced partition, schedule one half first, then the other. Their sizes are $B$ each; the first half finishes by $B$, and every remaining task finishes after $B$. Thus $W = B$, attaining the lower bound.
+  ($arrow.l.double$) If $W = B$, then $E = S - B <= B$. Together with $S >= 2B$ this forces $S = 2B$ and $E = B$. Hence the on-time and tardy tasks form a balanced partition. For odd $S$, every schedule instead has $W >= B + 1$, so no separate odd-input construction is needed.
+
+  _Solution extraction._ Validate the target with the formal API once and require finite tardy weight exactly $B$. Return false for tasks completing by $B$ and true for tardy tasks; reject all other configurations as noncertifying. The aggregate maps `Min(Some(B))` to `Or(true)` and all other values to `Or(false)`. Every permutation is a feasible target schedule, so source infeasibility is represented by an optimum above $B$, not target infeasibility. Every completion sum and tardy-weight sum is at most the source's checked $S$, establishing full `i64` arithmetic safety without changing either endpoint.
 
-  _Solution extraction._ On-time tasks (completing by $T$) form one partition half ($x_i = 0$), tardy tasks the other ($x_i = 1$).
 ]
 
 // 12. Partition → OpenShopScheduling (#481)
@@ -19074,18 +18912,18 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(part_oss.source) + " -o partition.json",
-      "pred reduce partition.json --to " + target-spec(part_oss) + " -o bundle.json",
+      "pred reduce partition.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate partition.json --config " + part_oss_sol.source_config.map(str).join(","),
+      "pred evaluate partition.json --config " + cli-config(part_oss_sol.source_config),
     )
 
     #{
       let q = part_oss.source.instance.sizes.sum() / 2
       let p = part_oss.target.instance.processing_times
-      let left-sum = part_oss_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => part_oss.source.instance.sizes.at(i)).sum()
-      let right-sum = part_oss_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => part_oss.source.instance.sizes.at(i)).sum()
+      let left-sum = part_oss_sol.source_config.enumerate().filter(((i, x)) => not x).map(((i, x)) => part_oss.source.instance.sizes.at(i)).sum()
+      let right-sum = part_oss_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => part_oss.source.instance.sizes.at(i)).sum()
       [
-        *Step 1 -- Source instance.* The Partition fixture has sizes $(#part_oss.source.instance.sizes.map(str).join(", "))$, total $#part_oss.source.instance.sizes.sum()$, and half-sum $Q = #q$. The canonical source vector $(#part_oss_sol.source_config.map(str).join(", "))$ gives subset sums $#left-sum$ and $#right-sum$.
+        *Step 1 -- Source instance.* The Partition fixture has sizes $(#fmt-values(part_oss.source.instance.sizes))$, total $#part_oss.source.instance.sizes.sum()$, and half-sum $Q = #q$. The canonical source vector $(#fmt-values(part_oss_sol.source_config))$ gives subset sums $#left-sum$ and $#right-sum$.
 
         *Step 2 -- Build the open-shop job table.* #table(
           columns: (auto, auto, auto, auto),
@@ -19098,24 +18936,27 @@ The following table shows concrete variable overhead for example instances, take
           [$J_3$], [#p.at(3).at(0)], [#p.at(3).at(1)], [#p.at(3).at(2)],
         ) The first three jobs come from the partition elements, and the special job $J_3$ has processing time $Q = #q$ on every machine.
 
-        *Step 3 -- Decode the canonical machine orders.* The target configuration $(#part_oss_sol.target_config.map(str).join(", "))$ splits into $M_1 = (0, 1, 2, 3)$, $M_2 = (0, 1, 2, 3)$, and $M_3 = (2, 3, 0, 1)$. On machine $M_3$, job $J_2$ occupies $[0, 3)$ and the special job $J_3$ starts exactly at time $Q = 3$, so the prefix before the special job contains precisely job $J_2$.
+        *Step 3 -- Decode the canonical start times.* The target configuration $(#fmt-values(part_oss_sol.target_config))$ is job-major. On machine $M_1$, jobs $J_0$ and $J_1$ occupy $[0,1)$ and $[1,3)$, and the special job $J_3$ starts exactly at time $Q = 3$.
 
-        *Step 4 -- Verify extraction and makespan.* Because only $J_2$ finishes on $M_3$ by time $Q$, the extracted source vector is $(#part_oss_sol.source_config.map(str).join(", "))$, i.e.\ subset sum #right-sum versus #left-sum. Evaluating the stored machine orders gives a concrete makespan of $12$, so the `load-example()` fixture shows both the machine assignment and the middle-machine split used for extraction #sym.checkmark.
+        *Step 4 -- Verify extraction and makespan.* The element jobs completing on $M_1$ by time $Q$ are exactly $J_0,J_1$, so the extracted source vector is $(#fmt-values(part_oss_sol.source_config))$, i.e.\ subset sum #right-sum versus #left-sum. Evaluating the explicit schedule gives the optimal makespan $9 = 3Q$ #sym.checkmark.
       ]
     }
 
     *Multiplicity:* The fixture stores one canonical witness.
   ],
 )[
-  This $O(k)$ reduction @gonzalez1976 creates $k + 1$ jobs on 3 machines: $k$ element jobs with $p_(j,i) = a_j$ on all machines, plus one special job with $p = Q = S\/2$. The target makespan is $3Q$. A balanced partition exists iff the open shop can achieve makespan $<= 3Q$.
+  This $O(k)$ construction follows the special-job scheduling argument of Gonzalez and Sahni @gonzalez1976[Lemma 4.1]. Their published construction uses $3k+1$ jobs with one nonzero operation per element copy; the implemented construction instead groups each element's three operations into one job and uses $k+1$ jobs. The independent schedule below proves this grouping preserves the reduction. A balanced partition exists exactly when the target achieves the makespan certificate $3Q$, where $Q=floor(S/2)$ and $S$ is the sum of the input sizes.
 ][
-  _Construction._ Given Partition instance $A = {a_1, dots, a_k}$ with total $S$ and $Q = S\/2$. Set $m = 3$ machines. For each $a_j$, create element job $J_j$ with $p_(j,1) = p_(j,2) = p_(j,3) = a_j$. Create special job $J_(k+1)$ with $p_(k+1,i) = Q$ on all machines. Deadline $D = 3Q$.
+  _Construction._ The source is a nonempty list of positive integers $a_1,...,a_k$, with $S=sum_j a_j$. Set $Q=floor(S/2)$. Use three machines, one job $(a_j,a_j,a_j)$ per element, and one special job $(Q,Q,Q)$. Let $D=3Q$.
 
-  _Correctness._ ($arrow.r.double$) With a balanced partition $I_1, I_2$, schedule the special job consecutively on machines 1, 2, 3 during $[0,Q), [Q,2Q), [2Q,3Q)$. Use a rotated assignment for $I_1$ and $I_2$ jobs to fill the remaining idle blocks, each of length $Q$. ($arrow.l.double$) With makespan $<= 3Q$, the special job alone needs $3Q$ elapsed time, so it tiles $[0,3Q)$ exactly. On each machine, element jobs fill two idle blocks of length $Q$ each. The jobs in one block sum to $Q$, giving a balanced partition.
+  _Forward correctness._ Given a balanced partition into groups $A,B$, each group has total size $Q$ and $S=2Q$. Divide time into three phases $[r Q,(r+1)Q)$, $r=0,1,2$. In phase $r$, run the special job on machine $r$, all jobs of $A$ consecutively on machine $(r+1) mod 3$, and all jobs of $B$ consecutively on machine $(r+2) mod 3$. Each group exactly fills its phase, each element job has one operation per phase, and the machine rotation processes it once on every machine. This is a feasible nonpreemptive schedule of makespan $D$.
 
-  _Solution extraction._ Identify the special job's position on machine 1. Element jobs in one idle block form a subset summing to $Q$.
-]
+  _Backward correctness._ Every schedule has makespan at least $3Q$ by the special job's total processing time, and at least $S+Q$ by each machine's load. If a feasible schedule attains $D$, these bounds give $S+Q<=3Q$; together with $S>=2Q$ this forces $S=2Q$. Since the source sizes are positive, $Q>0$. The special job must run without gaps and start its three operations at $0,Q,2Q$, in some machine order. Select the unique machine on which it starts at $Q$. Element operations on that machine fit before $Q$ or after $2Q$, each interval having capacity $Q$. Their total load is $2Q$, so the jobs completing by $Q$ have total size exactly $Q$ and define a balanced partition. It is the middle machine that supplies these two separate intervals, not an arbitrary fixed machine.
+
+  _Odd sums and zero duration._ If $S$ is odd, each machine's load is $S+Q=3Q+1>D$, so the threshold cannot be attained. The only legal source with $Q=0$ is the singleton size one; the special job then has zero duration, but the positive element job prevents makespan zero. Thus no alternate endpoint or parity-specific construction is required.
 
+  _Aggregation and extraction._ Map a finite optimum equal to $D$ to true and all other values to false. Validate a target configuration once, apply this same certificate, then identify the middle machine and select its element jobs completing by $Q$. Reject invalid schedules and feasible schedules that do not attain the certificate. The existing checked target constructor validates its total horizon $3(S+Q)$ before computing $D$, so the smaller nonnegative certificate is representable. Target construction failures retain their formal error type.
+]
 // 13. NAESatisfiability → MaxCut (#166)
 #let nae_mc = load-example("NAESatisfiability", "MaxCut")
 #let nae_mc_sol = nae_mc.solutions.at(0)
@@ -19125,9 +18966,9 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(nae_mc.source) + " -o naesat.json",
-      "pred reduce naesat.json --to " + target-spec(nae_mc) + " -o bundle.json",
+      "pred reduce naesat.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate naesat.json --config " + nae_mc_sol.source_config.map(str).join(","),
+      "pred evaluate naesat.json --config " + cli-config(nae_mc_sol.source_config),
     )
 
     #{
@@ -19141,57 +18982,35 @@ The following table shows concrete variable overhead for example instances, take
 
         *Step 2 -- Construct the weighted graph.* Variable gadgets contribute #n heavy edges of weight $M$. Because the canonical fixture has 3 literals per clause, each clause contributes one unit-weight triangle, so the target has #clause-edge-count unit-weight clause edges and $#graph-num-edges(nae_mc.target.instance)$ edges total on $#graph-num-vertices(nae_mc.target.instance)$ vertices.
 
-        *Step 3 -- Verify the canonical witness.* Source assignment $(#nae_mc_sol.source_config.map(str).join(", "))$ induces target cut $(#nae_mc_sol.target_config.map(str).join(", "))$. All #n heavy edges are cut, and each of the #m clause triangles has a 1-2 split contributing 2, so the total cut weight is $#cut-value$ #sym.checkmark.
+        *Step 3 -- Verify the canonical witness.* Source assignment $(#fmt-values(nae_mc_sol.source_config))$ induces target cut $(#fmt-values(nae_mc_sol.target_config))$. All #n heavy edges are cut, and each of the #m clause triangles has a 1-2 split contributing 2, so the total cut weight is $#cut-value$ #sym.checkmark.
       ]
     }
 
     *Multiplicity:* The fixture stores one canonical witness.
   ],
 )[
-  This implemented reduction sets $M = m + 1$, creates two literal vertices per variable, and adds one unit-weight edge for every literal pair inside a clause. When every clause has 3 literals, each clause gadget is a triangle, so the construction is the usual NAE-SAT-to-Max-Cut graph on $2n$ vertices with $n + 3m$ edges.
+  Reduce arbitrary NAE clauses of length at least two to binary edges and ternary triangles. Long clauses use fresh auxiliary variables in the standard NAE clause chain @jackson2025. Every satisfying source assignment extends to a cut attaining an explicit componentwise upper bound; a target cut is decoded only when it attains that bound.
 ][
-  _Construction._ Let $phi$ have $n$ variables and $m$ clauses, and set $M = m + 1$. For each variable $x_i$, create a positive literal vertex $p_i = 2i$ and a negative literal vertex $n_i = 2i + 1$, joined by one weight-$M$ edge. For each clause $C_j$, add a unit-weight edge between every pair of literal vertices appearing in $C_j$. In particular, if every clause has three literals, each clause becomes a unit-weight triangle.
-
-  _Correctness._ Assume from here on that each clause has exactly three literals, matching the canonical fixture. Then every clause gadget is a triangle.
+  _Clause expansion._ Let the source have $n$ variables, $m$ clauses of lengths $ell_j >= 2$, and $L = sum_j ell_j$ literal occurrences. Keep binary and ternary clauses. For a clause $(l_1,...,l_r)$ of length $r >= 4$, introduce $r-3$ fresh variables $z_1,...,z_(r-3)$ and replace it by
+  $ "NAE"(l_1,l_2,z_1), quad "NAE"(not z_1,l_3,z_2), quad dots.c, quad "NAE"(not z_(r-3),l_(r-1),l_r). $
+  For $r=4$ the chain consists of its first and last clauses. Auxiliary variables are private to each source clause.
 
-  ($arrow.r.double$) Let $alpha$ be a NAE-satisfying assignment. Put $p_i$ and $n_i$ on opposite sides of the cut according to $alpha$, so every variable edge is cut and contributes $M$. In each clause triangle, at least one literal is true and at least one is false, so the three vertices split $1$-$2$ across the cut and contribute exactly 2. Therefore the cut weight is $n M + 2m = n (m + 1) + 2m$.
+  _Chain equivalence._ For a list $R$ of at least two remaining literal values,
+  $ "NAE"(a,b,R) equiv exists z: "NAE"(a,b,z) and "NAE"(not z,R). $
+  If $a=b=c$ and the original clause is NAE-satisfied, $R$ contains a value different from $c$; choosing $z=not c$ satisfies both new clauses. If $a != b$, the first clause is satisfied for either $z$; if $R$ is constant $c$, choose $z=c$, and if $R$ is mixed either choice works. Conversely, if every original value were $c$, the first clause would force $z=not c$, making the second clause constant $c$. Repeated application proves both extension and restriction for the complete chain, including repeated and complementary literals (@jackson2025, Section 4, describes this chain).
 
-  ($arrow.l.double$) Suppose a cut has weight at least $n (m + 1) + 2m$. The $m$ clause triangles contribute at most $2m$ in total, so the variable edges must contribute at least $n (m + 1)$. Since each variable edge contributes at most $M = m + 1$, all $n$ variable edges are cut. Thus $p_i$ and $n_i$ lie on opposite sides for every variable, and the cut defines a consistent Boolean assignment by reading the side of $p_i$. The remaining $2m$ weight must come from the clause triangles, so each triangle contributes exactly 2 and therefore has vertices on both sides of the cut. Hence every clause contains both a true and a false literal, and the extracted assignment NAE-satisfies $phi$. Because a satisfying instance attains $n (m + 1) + 2m$, every optimal cut of the target has this form.
-
-  _Solution extraction._ Read the positive literal vertices: $x_i = 1$ iff vertex $2i$ lies on side 1 of the cut.
-]
-
-#let tdm_tp = load-example("ThreeDimensionalMatching", "ThreePartition")
-#let tdm_tp_sol = tdm_tp.solutions.at(0)
-#let tdm_tmi = load-example("ThreeDimensionalMatching", "ThreeMatroidIntersection")
-#let tdm_tmi_sol = tdm_tmi.solutions.at(0)
-#reduction-rule("ThreeDimensionalMatching", "ThreeMatroidIntersection",
-  example: true,
-  example-caption: [$q = 3$, $t = 5$ triples],
-  extra: [
-    #pred-commands(
-      "pred create --example " + problem-spec(tdm_tmi.source) + " -o source.json",
-      "pred reduce source.json --to " + target-spec(tdm_tmi) + " -o bundle.json",
-      "pred solve bundle.json",
-      "pred evaluate source.json --config " + tdm_tmi_sol.source_config.map(str).join(","),
-    )
-    Source 3DM witness $(#tdm_tmi_sol.source_config.map(str).join(", "))$, target common-independent witness $(#tdm_tmi_sol.target_config.map(str).join(", "))$.
-  ],
-)[
-  This $O(t + q)$ direct embedding @garey1979[SP11] takes the triple set itself as the common ground set and builds three partition matroids, one per coordinate family. The target has $t = |T|$ ground-set elements, $3 q$ groups in total, and bound $K = q$.
-][
-  _Construction._ Let the 3DM instance have universe size $q$ and triples $T = {t_0, dots, t_(t - 1)} subset.eq W times X times Y$, where $t_l = (w_(a_l), x_(b_l), y_(c_l))$. Create a Three-Matroid Intersection instance whose ground set is $E = {0, dots, t - 1}$, with element $l$ representing triple $t_l$.
+  _Cut construction._ Write $a = sum_j max(ell_j-3,0)$, $q=n+a$, $b=|{j:ell_j=2}|$, and $t=sum_(j:ell_j>=3)(ell_j-2)$. There are $q$ variables, $b$ binary clauses and $t$ ternary clauses after expansion. Set $M=m+1$. For each original or auxiliary variable, create positive and negative literal vertices joined by a weight-$M$ edge. A binary clause contributes one unit edge between its literal vertices; a ternary clause contributes all three unit edges between its literal occurrences. Preserve repeated edges and self-loops as supported by the graph representation. Define the certificate $K=q M+b+2t$.
 
-  Build three partition matroids on $E$. For each $i in {0, dots, q - 1}$, let
-  $ G_i^W = {l in E : a_l = i}, quad G_i^X = {l in E : b_l = i}, quad G_i^Y = {l in E : c_l = i}. $
-  A subset $S subset.eq E$ is independent in the first matroid iff $|S inter G_i^W| <= 1$ for every $i$; define the second and third matroids analogously using the $X$- and $Y$-coordinate groups. Set the target bound to $K = q$.
+  _Forward correctness._ A satisfying original assignment extends to satisfy all expanded clauses by chain equivalence. Put each literal vertex on its literal's truth side. All $q$ variable edges cross, each binary edge crosses, and every ternary triangle has exactly two crossing occurrence-pairs. The cut therefore attains $K$.
 
-  _Correctness._ ($arrow.r.double$) If $M subset.eq T$ is a perfect 3-dimensional matching, let $S subset.eq E$ contain exactly the indices of the triples in $M$. Because no two triples in $M$ share a $W$-, $X$-, or $Y$-coordinate, $S$ meets every group $G_i^W$, $G_i^X$, and $G_i^Y$ in at most one element, so $S$ is independent in all three matroids. Also $|S| = |M| = q$, hence $S$ is a feasible Three-Matroid Intersection solution.
+  _Backward correctness._ Every cut has weight at most $K$: each variable edge contributes at most $M$, each binary edge at most one, and each triangle at most two. This holds even with coincident literal vertices or repeated edges. Equality forces all individual bounds to be attained. Because $M>0$, each variable and its negation lie on opposite sides; the binary and ternary gadgets then certify all expanded NAE clauses. Restricting their satisfying assignment to the original variables satisfies the original formula by chain equivalence. Thus a feasible source has target optimum exactly $K$, while an infeasible source has optimum strictly below $K$.
 
-  ($arrow.l.double$) Let $S subset.eq E$ be a common independent set of size $q$. Independence in the first matroid implies that the selected triples use $q$ distinct $W$-coordinates; since only $q$ such coordinates exist, they use each element of $W$ exactly once. The same argument applies to $X$ and $Y$. Therefore the triples indexed by $S$ form a perfect 3-dimensional matching.
+  _Aggregation and extraction._ Return true precisely for a finite target optimum equal to $K$. Validate a target configuration once, apply this same certificate, and only then read the positive literal vertex of each original variable. Reject every configuration below the bound instead of returning an invalid source assignment. No assumption that an arbitrary optimum satisfies the formula is needed.
 
-  _Solution extraction._ Return the same binary indicator vector: target element $l$ is selected iff source triple $t_l$ is selected.
+  _Size and arithmetic._ The exact target has $2q$ vertices and $q+b+3t$ edges. Since $a=L-3m+b$, $t=L-2m$, and $b<=m$, the registered upper bounds are $2(n+L-2m)$ vertices and $n+4L-7m$ edges. All size totals, weights, the certificate, and the sum of all nonnegative target weights are checked before graph construction, including the graph's actual index domain. Consequently every successfully constructed cut sum is representable; arithmetic failures remain typed reduction errors.
 ]
+#let tdm_tp = load-example("ThreeDimensionalMatching", "ThreePartition")
+#let tdm_tp_sol = tdm_tp.solutions.at(0)
 
 #reduction-rule("ThreeDimensionalMatching", "ThreePartition",
   example: true,
@@ -19199,9 +19018,9 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(tdm_tp.source) + " -o three-dimensional-matching.json",
-      "pred reduce three-dimensional-matching.json --to " + target-spec(tdm_tp) + " -o bundle.json",
+      "pred reduce three-dimensional-matching.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate three-dimensional-matching.json --config " + tdm_tp_sol.source_config.map(str).join(","),
+      "pred evaluate three-dimensional-matching.json --config " + cli-config(tdm_tp_sol.source_config),
     )
 
     #{
@@ -19219,13 +19038,13 @@ The following table shows concrete variable overhead for example instances, take
       let target = tdm_tp.target.instance
 
       [
-        *Step 1 -- Source instance.* The canonical source has $q = #q$ and a single triple $M = {(0, 0, 0)}$, so the witness $(#tdm_tp_sol.source_config.map(str).join(", "))$ selects the only available triple and is therefore a perfect 3-dimensional matching #sym.checkmark.
+        *Step 1 -- Source instance.* The canonical source has $q = #q$ and a single triple $M = {(0, 0, 0)}$, so the witness $(#fmt-values(tdm_tp_sol.source_config))$ selects the only available triple and is therefore a perfect 3-dimensional matching #sym.checkmark.
 
         *Step 2 -- Encode the ABCD and tagged 4-partition numbers.* Here $r = 32 q = #r$ and $T_1 = 40 r^4 = #T1$. Because every coordinate is 0 and occurs once, the ABCD numbers are all $10 r^4 = #(10 * r4)$. After the mod-16 tags, the 4-partition numbers become $(#a0, #b0, #c0, #d0)$ and sum to $T_2 = 16 T_1 + 15 = #T2$.
 
-        *Step 3 -- Build the 3-partition gadget.* From the 4 tagged numbers the construction creates #target.sizes.len() target numbers: 4 regular numbers, 12 pairing numbers, and 5 fillers. The target bound is $B = 64 T_2 + 4 = #B$, matching the exported instance's bound $#target.bound$. The canonical target witness is $(#tdm_tp_sol.target_config.map(str).join(", "))$: groups 0 and 1 are the non-filler triples, and the remaining 5 groups each contain one filler together with one unused pairing pair.
+        *Step 3 -- Build the 3-partition gadget.* From the 4 tagged numbers the construction creates #target.sizes.len() target numbers: 4 regular numbers, 12 pairing numbers, and 5 fillers. The target bound is $B = 64 T_2 + 4 = #B$, matching the exported instance's bound $#target.bound$. The canonical target witness is $(#fmt-values(tdm_tp_sol.target_config))$: groups 0 and 1 are the non-filler triples, and the remaining 5 groups each contain one filler together with one unused pairing pair.
 
-        *Step 4 -- Verify the witness.* The target configuration partitions all #target.sizes.len() numbers into $#(target.sizes.len() / 3)$ triples summing to $B = #B$ #sym.checkmark. Reversing the gadget recovers the unique tagged 4-set, whose $B$, $C$, and $D$ members are all first occurrences, so the extracted source witness is again $(#tdm_tp_sol.source_config.map(str).join(", "))$ #sym.checkmark.
+        *Step 4 -- Verify the witness.* The target configuration partitions all #target.sizes.len() numbers into $#(target.sizes.len() / 3)$ triples summing to $B = #B$ #sym.checkmark. Reversing the gadget recovers the unique tagged 4-set, whose $B$, $C$, and $D$ members are all first occurrences, so the extracted source witness is again $(#fmt-values(tdm_tp_sol.source_config))$ #sym.checkmark.
 
         *Multiplicity:* The fixture stores one canonical witness. In this $q = 1$ instance there is only one source matching, but the target still admits multiple equivalent 3-partition witnesses because any choice of one pairing gadget to split the unique 4-set yields a valid solution.
       ]
@@ -19265,13 +19084,13 @@ The following table shows concrete variable overhead for example instances, take
 #let tdm_ilp_sol = tdm_ilp.solutions.at(0)
 #reduction-rule("ThreeDimensionalMatching", "ILP",
   example: true,
-  example-caption: [$q = #tdm_ilp.source.instance.universe_size$, $t = #tdm_ilp.source.instance.triples.len()$ triples $arrow.r$ ILP with #tdm_ilp.target.instance.num_vars variables and #tdm_ilp.target.instance.constraints.len() constraints],
+  example-caption: [$q = #tdm_ilp.source.instance.universe_size$, $t = #tdm_ilp.source.instance.triples.len()$ triples $arrow.r$ ILP with #tdm_ilp.target.instance.variables.len() variables and #tdm_ilp.target.instance.constraints.len() constraints],
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(tdm_ilp.source) + " -o three-dimensional-matching.json",
-      "pred reduce three-dimensional-matching.json --to " + target-spec(tdm_ilp) + " -o bundle.json",
+      "pred reduce three-dimensional-matching.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate three-dimensional-matching.json --config " + tdm_ilp_sol.source_config.map(str).join(","),
+      "pred evaluate three-dimensional-matching.json --config " + cli-config(tdm_ilp_sol.source_config),
     )
 
     #{
@@ -19279,11 +19098,11 @@ The following table shows concrete variable overhead for example instances, take
       let t = tdm_ilp.source.instance.triples.len()
       let triples = tdm_ilp.source.instance.triples
       [
-        *Step 1 -- Source instance.* The canonical source has universe size $q = #q$ and $t = #t$ triples: #triples.map(tr => "(" + tr.map(str).join(", ") + ")").join(", "). The stored witness $(#tdm_ilp_sol.source_config.map(str).join(", "))$ selects triples #tdm_ilp_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", "), which cover every element of $W$, $X$, and $Y$ exactly once #sym.checkmark.
+        *Step 1 -- Source instance.* The canonical source has universe size $q = #q$ and $t = #t$ triples: #triples.map(tr => "(" + fmt-values(tr) + ")").join(", "). The stored witness $(#fmt-values(tdm_ilp_sol.source_config))$ selects triples #tdm_ilp_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", "), which cover every element of $W$, $X$, and $Y$ exactly once #sym.checkmark.
 
-        *Step 2 -- Build the ILP.* One binary variable $x_j$ per triple ($j = 0, dots, #(t - 1)$). For each of the $3q = #(3 * q)$ elements across the three sets $W$, $X$, $Y$, add an equality constraint requiring that the sum of $x_j$ over all triples containing that element equals 1. This yields #tdm_ilp.target.instance.constraints.len() constraints and #tdm_ilp.target.instance.num_vars variables.
+        *Step 2 -- Build the ILP.* One binary variable $x_j$ per triple ($j = 0, dots, #(t - 1)$). For each of the $3q = #(3 * q)$ elements across the three sets $W$, $X$, $Y$, add an equality constraint requiring that the sum of $x_j$ over all triples containing that element equals 1. This yields #tdm_ilp.target.instance.constraints.len() constraints and #tdm_ilp.target.instance.variables.len() variables.
 
-        *Step 3 -- Verify a solution.* The target configuration $(#tdm_ilp_sol.target_config.map(str).join(", "))$ is identical to the source configuration because the mapping is one variable per triple with identity extraction. Each element-coverage constraint sums to exactly 1 #sym.checkmark.
+        *Step 3 -- Verify a solution.* The target configuration $(#fmt-values(tdm_ilp_sol.target_config))$ is identical to the source configuration because the mapping is one variable per triple with identity extraction. Each element-coverage constraint sums to exactly 1 #sym.checkmark.
 
         *Multiplicity:* The fixture stores one canonical witness.
       ]
@@ -19314,9 +19133,9 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(tdm_mwd.source) + " -o three-dimensional-matching.json",
-      "pred reduce three-dimensional-matching.json --to " + target-spec(tdm_mwd) + " -o bundle.json",
+      "pred reduce three-dimensional-matching.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate three-dimensional-matching.json --config " + tdm_mwd_sol.source_config.map(str).join(","),
+      "pred evaluate three-dimensional-matching.json --config " + cli-config(tdm_mwd_sol.source_config),
     )
 
     #{
@@ -19325,11 +19144,11 @@ The following table shows concrete variable overhead for example instances, take
       let triples = tdm_mwd.source.instance.triples
       let target = tdm_mwd.target.instance
       [
-        *Step 1 -- Source instance.* The canonical source has universe size $q = #q$ and $m = #m$ triples: #triples.map(tr => "(" + tr.map(str).join(", ") + ")").join(", "). The stored witness $(#tdm_mwd_sol.source_config.map(str).join(", "))$ selects triples #tdm_mwd_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", "), covering every element of $W$, $X$, $Y$ exactly once #sym.checkmark.
+        *Step 1 -- Source instance.* The canonical source has universe size $q = #q$ and $m = #m$ triples: #triples.map(tr => "(" + fmt-values(tr) + ")").join(", "). The stored witness $(#fmt-values(tdm_mwd_sol.source_config))$ selects triples #tdm_mwd_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", "), covering every element of $W$, $X$, $Y$ exactly once #sym.checkmark.
 
         *Step 2 -- Build the parity-check matrix.* Allocate a #target.matrix.len() $times$ #target.matrix.at(0).len() binary matrix $H$ with row blocks $W$ (rows $0, dots, #(q - 1)$), $X$ (rows $#q, dots, #(2 * q - 1)$), and $Y$ (rows $#(2 * q), dots, #(3 * q - 1)$). For each triple $t_j = (a_j, b_j, c_j)$, set $H[a_j, j] = H[q + b_j, j] = H[2q + c_j, j] = 1$. Every column has exactly three 1s. Set the syndrome to the all-ones vector $bold(s) = 1^(3q)$ of length #target.target.len().
 
-        *Step 3 -- Verify a solution.* The target codeword $(#tdm_mwd_sol.target_config.map(str).join(", "))$ has Hamming weight #tdm_mwd_sol.target_config.filter(x => x == 1).len() $= q$. Multiplying $H$ by this vector over $bold(F)_2$ recovers the all-ones syndrome, so each element of $W union X union Y$ is covered an odd number of times -- exactly once #sym.checkmark.
+        *Step 3 -- Verify a solution.* The target codeword $(#fmt-values(tdm_mwd_sol.target_config))$ has Hamming weight #tdm_mwd_sol.target_config.filter(x => x).len() $= q$. Multiplying $H$ by this vector over $bold(F)_2$ recovers the all-ones syndrome, so each element of $W union X union Y$ is covered an odd number of times -- exactly once #sym.checkmark.
 
         *Multiplicity:* The fixture stores one canonical witness; the instance admits a second perfect matching $\{t_2, t_3\}$ with codeword $(0, 0, 1, 1)$ of the same weight.
       ]
@@ -19361,20 +19180,20 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(tp_rcs.source) + " -o threepartition.json",
-      "pred reduce threepartition.json --to " + target-spec(tp_rcs) + " -o bundle.json",
+      "pred reduce threepartition.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate threepartition.json --config " + tp_rcs_sol.source_config.map(str).join(","),
+      "pred evaluate threepartition.json --config " + cli-config(tp_rcs_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical Three-Partition instance has $3m = #tp_rcs.source.instance.sizes.len()$ elements with sizes $(#tp_rcs.source.instance.sizes.map(str).join(", "))$ and bound $B = #tp_rcs.source.instance.bound$, so $m = #(tp_rcs.source.instance.sizes.len() / 3)$ groups are required.
+    *Step 1 -- Source instance.* The canonical Three-Partition instance has $3m = #tp_rcs.source.instance.sizes.len()$ elements with sizes $(#fmt-values(tp_rcs.source.instance.sizes))$ and bound $B = #tp_rcs.source.instance.bound$, so $m = #(tp_rcs.source.instance.sizes.len() / 3)$ groups are required.
 
     *Step 2 -- Build the Resource-Constrained Scheduling instance.* Each element $a_i$ becomes a unit-length task with resource requirement $r_i = a_i$. The reduction sets $p = #tp_rcs.target.instance.num_processors$ processors, a single resource with bound $#tp_rcs.target.instance.resource_bounds.at(0)$, and deadline $D = #tp_rcs.target.instance.deadline$. The target has #tp_rcs.target.instance.resource_requirements.len() tasks with resource requirements $(#tp_rcs.target.instance.resource_requirements.map(r => str(r.at(0))).join(", "))$.
 
-    *Step 3 -- Verify the canonical witness.* The source config $(#tp_rcs_sol.source_config.map(str).join(", "))$ assigns elements to groups:
+    *Step 3 -- Verify the canonical witness.* The source config $(#fmt-values(tp_rcs_sol.source_config))$ assigns elements to groups:
     #for g in range(tp_rcs.target.instance.deadline) [
       - Slot #g: elements ${#tp_rcs_sol.source_config.enumerate().filter(((i, x)) => x == g).map(((i, x)) => str(i)).join(", ")}$ with sizes $#tp_rcs_sol.source_config.enumerate().filter(((i, x)) => x == g).map(((i, x)) => str(tp_rcs.source.instance.sizes.at(i))).join(" + ") = #tp_rcs.source.instance.bound = B$ #sym.checkmark
     ]
-    Each slot has exactly 3 tasks and each slot's resource usage sums to $B$. The target config is $(#tp_rcs_sol.target_config.map(str).join(", "))$, matching the source config since task $t_i$ is assigned to the same slot as element $a_i$.
+    Each slot has exactly 3 tasks and each slot's resource usage sums to $B$. The target config is $(#fmt-values(tp_rcs_sol.target_config))$, matching the source config since task $t_i$ is assigned to the same slot as element $a_i$.
 
     *Multiplicity:* The fixture stores one canonical witness. Other valid 3-partitions (if any) would yield equally valid schedules.
   ],
@@ -19396,18 +19215,18 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(tp_srd.source) + " -o tp.json",
-      "pred reduce tp.json --to " + target-spec(tp_srd) + " -o bundle.json",
+      "pred reduce tp.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate tp.json --config " + tp_srd_sol.source_config.map(str).join(","),
+      "pred evaluate tp.json --config " + cli-config(tp_srd_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The canonical 3-Partition instance has $3m = #tp_srd.source.instance.sizes.len()$ elements with sizes $(#tp_srd.source.instance.sizes.map(str).join(", "))$ and bound $B = #tp_srd.source.instance.bound$. Since $m = #(tp_srd.source.instance.sizes.len() / 3)$, we must partition the elements into $#(tp_srd.source.instance.sizes.len() / 3)$ groups, each summing to $B$.
+    *Step 1 -- Source instance.* The canonical 3-Partition instance has $3m = #tp_srd.source.instance.sizes.len()$ elements with sizes $(#fmt-values(tp_srd.source.instance.sizes))$ and bound $B = #tp_srd.source.instance.bound$. Since $m = #(tp_srd.source.instance.sizes.len() / 3)$, we must partition the elements into $#(tp_srd.source.instance.sizes.len() / 3)$ groups, each summing to $B$.
 
     *Step 2 -- Construct element tasks.* Each element $a_i$ becomes a task with processing time $p_i = a_i$, release time $r_i = 0$, and deadline $d_i = H$ where $H = m(B+1) - 1 = #(tp_srd.source.instance.sizes.len() / 3) dot (#tp_srd.source.instance.bound + 1) - 1 = #(tp_srd.source.instance.sizes.len() / 3 * (tp_srd.source.instance.bound + 1) - 1)$. This gives #tp_srd.source.instance.sizes.len() element tasks with lengths $(#tp_srd.target.instance.lengths.slice(0, tp_srd.source.instance.sizes.len()).map(str).join(", "))$.
 
     *Step 3 -- Construct filler tasks.* Add $m - 1 = #(tp_srd.source.instance.sizes.len() / 3 - 1)$ filler task(s). Filler $j$ has length $1$, release time $r_j = (j+1)B + j = #tp_srd.target.instance.release_times.at(tp_srd.source.instance.sizes.len())$, and deadline $d_j = r_j + 1 = #tp_srd.target.instance.deadlines.at(tp_srd.source.instance.sizes.len())$. This tight window pins each filler to a single time unit, splitting the timeline into $m$ slots of width $B = #tp_srd.source.instance.bound$.
 
-    *Step 4 -- Verify a solution.* The source witness assigns elements to groups: $[#tp_srd_sol.source_config.map(str).join(", ")]$. Group 0 contains elements with sizes $(#{ let s = tp_srd.source.instance.sizes; tp_srd_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => str(s.at(i))).join(", ")})$, summing to $#{ let s = tp_srd.source.instance.sizes; tp_srd_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => s.at(i)).sum() } = B$ #sym.checkmark. Group 1 contains sizes $(#{ let s = tp_srd.source.instance.sizes; tp_srd_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(s.at(i))).join(", ")})$, summing to $#{ let s = tp_srd.source.instance.sizes; tp_srd_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => s.at(i)).sum() } = B$ #sym.checkmark. The target Lehmer code is $[#tp_srd_sol.target_config.map(str).join(", ")]$: element tasks fill slot $[0, B)$, the filler occupies its tight window $[B, B+1)$, and remaining elements fill slot $[B+1, 2B+1)$.
+    *Step 4 -- Verify a solution.* The source witness assigns elements to groups: $[#fmt-values(tp_srd_sol.source_config)]$. Group 0 contains elements with sizes $(#{ let s = tp_srd.source.instance.sizes; tp_srd_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => str(s.at(i))).join(", ")})$, summing to $#{ let s = tp_srd.source.instance.sizes; tp_srd_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => s.at(i)).sum() } = B$ #sym.checkmark. Group 1 contains sizes $(#{ let s = tp_srd.source.instance.sizes; tp_srd_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(s.at(i))).join(", ")})$, summing to $#{ let s = tp_srd.source.instance.sizes; tp_srd_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => s.at(i)).sum() } = B$ #sym.checkmark. The target task order is $[#fmt-values(tp_srd_sol.target_config)]$: element tasks fill slot $[0, B)$, the filler occupies its tight window $[B, B+1)$, and remaining elements fill slot $[B+1, 2B+1)$.
 
     *Multiplicity:* The fixture stores one canonical witness. A second valid partition (swapping groups) exists, but both map to distinct Lehmer codes.
   ],
@@ -19435,18 +19254,18 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(mc_mcbs.source) + " -o maxcut.json",
-      "pred reduce maxcut.json --to " + target-spec(mc_mcbs) + " -o bundle.json",
+      "pred reduce maxcut.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate maxcut.json --config " + mc_mcbs_sol.source_config.map(str).join(","),
+      "pred evaluate maxcut.json --config " + cli-config(mc_mcbs_sol.source_config),
     )
 
-    *Step 1 -- Source instance.* The source MaxCut instance is a triangle $G = (V, E)$ with $n = #mc_mcbs.source.instance.graph.num_vertices$ vertices, $|E| = #mc_mcbs.source.instance.graph.edges.len()$ edges, and unit weights $w = (#mc_mcbs.source.instance.edge_weights.map(str).join(", "))$. A maximum cut partitions vertices into two sides to maximize crossing-edge weight; here the optimum is $2$ (any single vertex versus the other two).
+    *Step 1 -- Source instance.* The source MaxCut instance is a triangle $G = (V, E)$ with $n = #mc_mcbs.source.instance.graph.num_vertices$ vertices, $|E| = #mc_mcbs.source.instance.graph.edges.len()$ edges, and unit weights $w = (#fmt-values(mc_mcbs.source.instance.edge_weights))$. A maximum cut partitions vertices into two sides to maximize crossing-edge weight; here the optimum is $2$ (any single vertex versus the other two).
 
     *Step 2 -- Pad to even vertex count.* Since $n = 3$ is odd, set $n' = n + 1 = 4$. The target complete graph has $N = 2 n' = #mc_mcbs.target.instance.graph.num_vertices$ vertices, giving $#mc_mcbs.target.instance.graph.num_vertices dot (#mc_mcbs.target.instance.graph.num_vertices - 1) slash 2 = #mc_mcbs.target.instance.graph.edges.len()$ edges.
 
-    *Step 3 -- Invert weights on $K_#mc_mcbs.target.instance.graph.num_vertices$.* Compute $w_"max" = 1 + max w(e) = 2$. For each original edge $(i, j) in E$, the inverted weight is $tilde(w)(i,j) = w_"max" - w(i,j) = 2 - 1 = 1$. All other edges (including those to padding vertices) receive weight $w_"max" = 2$. Designate source $s = #mc_mcbs.target.instance.source$, sink $t = #mc_mcbs.target.instance.sink$, size bound $b = #mc_mcbs.target.instance.size_bound$. The target edge weights are $(#mc_mcbs.target.instance.edge_weights.map(str).join(", "))$.
+    *Step 3 -- Invert weights on $K_#mc_mcbs.target.instance.graph.num_vertices$.* Compute $w_"max" = 1 + max w(e) = 2$. For each original edge $(i, j) in E$, the inverted weight is $tilde(w)(i,j) = w_"max" - w(i,j) = 2 - 1 = 1$. All other edges (including those to padding vertices) receive weight $w_"max" = 2$. Designate source $s = #mc_mcbs.target.instance.source$, sink $t = #mc_mcbs.target.instance.sink$, size bound $b = #mc_mcbs.target.instance.size_bound$. The target edge weights are $(#fmt-values(mc_mcbs.target.instance.edge_weights))$.
 
-    *Step 4 -- Verify a solution.* The canonical source witness is $(#mc_mcbs_sol.source_config.map(str).join(", "))$: vertices $0, 1$ on side $0$ and vertex $2$ on side $1$, cutting $2$ of $3$ edges (max cut value $= 2$). The target witness is $(#mc_mcbs_sol.target_config.map(str).join(", "))$. Check: (1) the first $n = #mc_mcbs.source.instance.graph.num_vertices$ entries match the source partition #sym.checkmark; (2) source vertex $s = #mc_mcbs.target.instance.source$ and sink vertex $t = #mc_mcbs.target.instance.sink$ are on opposite sides #sym.checkmark; (3) each side has exactly $b = #mc_mcbs.target.instance.size_bound$ vertices (balanced bisection) #sym.checkmark.
+    *Step 4 -- Verify a solution.* The canonical source witness is $(#fmt-values(mc_mcbs_sol.source_config))$: vertices $0, 1$ on side $0$ and vertex $2$ on side $1$, cutting $2$ of $3$ edges (max cut value $= 2$). The target witness is $(#fmt-values(mc_mcbs_sol.target_config))$. Check: (1) the first $n = #mc_mcbs.source.instance.graph.num_vertices$ entries match the source partition #sym.checkmark; (2) source vertex $s = #mc_mcbs.target.instance.source$ and sink vertex $t = #mc_mcbs.target.instance.sink$ are on opposite sides #sym.checkmark; (3) each side has exactly $b = #mc_mcbs.target.instance.size_bound$ vertices (balanced bisection) #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness. The triangle has $3$ maximum cuts of value $2$ (isolate any one vertex); padding vertices can be assigned to balance both sides, yielding multiple valid target configurations.
   ],
@@ -19465,8 +19284,8 @@ The following table shows concrete variable overhead for example instances, take
 #let mc_mmc_sol = mc_mmc.solutions.at(0)
 #let mc_mmc_n = mc_mmc.source.instance.graph.num_vertices
 #let mc_mmc_W = mc_mmc.source.instance.edge_weights.fold(0, (a, b) => a + b)
-#let mc_mmc_S = mc_mmc_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => str(i)).join(", ")
-#let mc_mmc_Sbar = mc_mmc_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => str(i)).join(", ")
+#let mc_mmc_S = mc_mmc_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => str(i)).join(", ")
+#let mc_mmc_Sbar = mc_mmc_sol.source_config.enumerate().filter(((i, x)) => not x).map(((i, x)) => str(i)).join(", ")
 #let mc_mmc_cut = mc_mmc.source.instance.graph.edges.filter(e => mc_mmc_sol.source_config.at(e.at(0)) != mc_mmc_sol.source_config.at(e.at(1))).len()
 #reduction-rule("MaxCut", "MinimumMatrixCover",
   example: true,
@@ -19474,9 +19293,9 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(mc_mmc.source) + " -o maxcut.json",
-      "pred reduce maxcut.json --to " + target-spec(mc_mmc) + " -o bundle.json",
+      "pred reduce maxcut.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate maxcut.json --config " + mc_mmc_sol.source_config.map(str).join(","),
+      "pred evaluate maxcut.json --config " + cli-config(mc_mmc_sol.source_config),
     )
 
     *Step 1 -- Source instance.* The source MaxCut instance is the 4-cycle $C_#mc_mmc_n$ with $n = #mc_mmc_n$ vertices, edges $E = {(0,1), (1,2), (2,3), (0,3)}$, and unit weights, so the total weight is $W = #mc_mmc_W$.
@@ -19487,7 +19306,7 @@ The following table shows concrete variable overhead for example instances, take
     $
     which is a valid MinimumMatrixCover instance (nonnegative integer entries).
 
-    *Step 3 -- Verify the witness.* The canonical witness is the sign assignment $f = (+1, -1, +1, -1)$, encoded as the binary config $(#mc_mmc_sol.source_config.map(str).join(", "))$. The partition is $S = {#mc_mmc_S}$ versus $overline(S) = {#mc_mmc_Sbar}$, cutting all #mc_mmc_cut edges. The quadratic form evaluates to $sum_(i, j) a_(i j) f(i) f(j) = 2 W - 4 dot #mc_mmc_cut = #(2 * mc_mmc_W) - #(4 * mc_mmc_cut) = #(2 * mc_mmc_W - 4 * mc_mmc_cut)$, which matches the MinimumMatrixCover optimum and is consistent with #raw("MaxCut") $= (2 W - "min" Q F) / 4 = #mc_mmc_cut$ #sym.checkmark.
+    *Step 3 -- Verify the witness.* The canonical witness is the sign assignment $f = (+1, -1, +1, -1)$, encoded as the binary config $(#fmt-values(mc_mmc_sol.source_config))$. The partition is $S = {#mc_mmc_S}$ versus $overline(S) = {#mc_mmc_Sbar}$, cutting all #mc_mmc_cut edges. The quadratic form evaluates to $sum_(i, j) a_(i j) f(i) f(j) = 2 W - 4 dot #mc_mmc_cut = #(2 * mc_mmc_W) - #(4 * mc_mmc_cut) = #(2 * mc_mmc_W - 4 * mc_mmc_cut)$, which matches the MinimumMatrixCover optimum and is consistent with #raw("MaxCut") $= (2 W - "min" Q F) / 4 = #mc_mmc_cut$ #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness. The form is invariant under $f arrow.r -f$, so the complementary assignment $(-1, +1, -1, +1)$ (config $(0, 1, 0, 1)$) is equally optimal.
   ],
@@ -19512,16 +19331,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hp_ist.source) + " -o hampath.json",
-      "pred reduce hampath.json --to " + target-spec(hp_ist) + " -o bundle.json",
+      "pred reduce hampath.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hampath.json --config " + hp_ist_sol.source_config.map(str).join(","),
+      "pred evaluate hampath.json --config " + cli-config(hp_ist_sol.source_config),
     )
 
     *Step 1 -- Source instance.* Graph $G$ with $n = #graph-num-vertices(hp_ist.source.instance)$ vertices and $|E| = #graph-num-edges(hp_ist.source.instance)$ edges.
 
     *Step 2 -- Identity reduction.* Target host graph is identical. Target tree $T = P_#graph-num-vertices(hp_ist.target.instance)$ with #hp_ist.target.instance.tree.edges.len() edges.
 
-    *Step 3 -- Verify a solution.* Hamiltonian path visits vertices in order $(#hp_ist_sol.source_config.map(str).join(", "))$. The isomorphism maps $P_n$ to this path in $G$ #sym.checkmark.
+    *Step 3 -- Verify a solution.* Hamiltonian path visits vertices in order $(#fmt-values(hp_ist_sol.source_config))$. The isomorphism maps $P_n$ to this path in $G$ #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness.
   ],
@@ -19544,9 +19363,9 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(x3c_gf2.source) + " -o x3c.json",
-      "pred reduce x3c.json --to " + target-spec(x3c_gf2) + " -o bundle.json",
+      "pred reduce x3c.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate x3c.json --config " + x3c_gf2_sol.source_config.map(str).join(","),
+      "pred evaluate x3c.json --config " + cli-config(x3c_gf2_sol.source_config),
     )
 
     #{
@@ -19560,9 +19379,9 @@ The following table shows concrete variable overhead for example instances, take
         for elements 3 and 4, $x_1 + x_2 + 1 = 0$ and $x_1 x_2 = 0$;
         for element 5, $x_1 + 1 = 0$.
 
-        *Step 3 -- Evaluate the canonical target witness.* The target assignment is $x = (#x.map(str).join(", ")) = (1, 1, 0)$. Substituting gives $1 + 0 + 1 = 0$ mod 2, $1 dot 0 = 0$, and $1 + 1 = 0$ mod 2, which are exactly the three polynomial patterns appearing in the fixture.
+        *Step 3 -- Evaluate the canonical target witness.* The target assignment is $x = (#fmt-values(x)) = (1, 1, 0)$. Substituting gives $1 + 0 + 1 = 0$ mod 2, $1 dot 0 = 0$, and $1 + 1 = 0$ mod 2, which are exactly the three polynomial patterns appearing in the fixture.
 
-        *Step 4 -- Verify the witness pair.* The two 1-entries in $x$ select $C_0$ and $C_1$, while $x_2 = 0$ omits $C_2$. Thus the target witness encodes the same exact cover as the source configuration $(#x3c_gf2_sol.source_config.map(str).join(", "))$ #sym.checkmark.
+        *Step 4 -- Verify the witness pair.* The two 1-entries in $x$ select $C_0$ and $C_1$, while $x_2 = 0$ omits $C_2$. Thus the target witness encodes the same exact cover as the source configuration $(#fmt-values(x3c_gf2_sol.source_config))$ #sym.checkmark.
       ]
     }
 
@@ -19587,17 +19406,17 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(part_pp.source) + " -o partition.json",
-      "pred reduce partition.json --to " + target-spec(part_pp) + " -o bundle.json",
+      "pred reduce partition.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate partition.json --config " + part_pp_sol.source_config.map(str).join(","),
+      "pred evaluate partition.json --config " + cli-config(part_pp_sol.source_config),
     )
 
     #{
-      let left-sum = part_pp_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => part_pp.source.instance.sizes.at(i)).sum()
-      let right-sum = part_pp_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => part_pp.source.instance.sizes.at(i)).sum()
+      let left-sum = part_pp_sol.source_config.enumerate().filter(((i, x)) => not x).map(((i, x)) => part_pp.source.instance.sizes.at(i)).sum()
+      let right-sum = part_pp_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => part_pp.source.instance.sizes.at(i)).sum()
       let prod = part_pp_sol.target_config
       [
-        *Step 1 -- Source instance.* The Partition fixture has sizes $(#part_pp.source.instance.sizes.map(str).join(", "))$ with total $#part_pp.source.instance.sizes.sum()$, so $Q = #(part_pp.source.instance.sizes.sum() / 2)$. The canonical source vector $(#part_pp_sol.source_config.map(str).join(", "))$ splits the instance into sums $#left-sum$ and $#right-sum$.
+        *Step 1 -- Source instance.* The Partition fixture has sizes $(#fmt-values(part_pp.source.instance.sizes))$ with total $#part_pp.source.instance.sizes.sum()$, so $Q = #(part_pp.source.instance.sizes.sum() / 2)$. The canonical source vector $(#fmt-values(part_pp_sol.source_config))$ splits the instance into sums $#left-sum$ and $#right-sum$.
 
         *Step 2 -- Build the period table.* #table(
           columns: (auto, auto, auto, auto, auto),
@@ -19612,9 +19431,9 @@ The following table shows concrete variable overhead for example instances, take
           [$P_5$], [#part_pp.target.instance.capacities.at(5)], [#part_pp.target.instance.setup_costs.at(5)], [#part_pp.target.instance.demands.at(5)], [#prod.at(5)],
         ) The first five periods encode the partition elements, and the last period carries the demand of $10$ units.
 
-        *Step 3 -- Track cumulative production and inventory.* The stored plan $(#prod.map(str).join(", "))$ gives cumulative production $0, 0, 0, 4, 10, 10$ against cumulative demand $0, 0, 0, 0, 0, 10$. Hence the inventory levels are $0, 0, 0, 4, 10, 0$, so every prefix remains feasible.
+        *Step 3 -- Track cumulative production and inventory.* The stored plan $(#fmt-values(prod))$ gives cumulative production $0, 0, 0, 4, 10, 10$ against cumulative demand $0, 0, 0, 0, 0, 10$. Hence the inventory levels are $0, 0, 0, 4, 10, 0$, so every prefix remains feasible.
 
-        *Step 4 -- Check the cost and recover the partition.* Only periods $P_3$ and $P_4$ are active, so the total cost is just the setup cost $4 + 6 = #part_pp.target.instance.cost_bound$; production and inventory costs are all zero in the fixture. The active periods therefore recover the source vector $(#part_pp_sol.source_config.map(str).join(", "))$, selecting the subset of size #right-sum #sym.checkmark.
+        *Step 4 -- Check the cost and recover the partition.* Only periods $P_3$ and $P_4$ are active, so the total cost is just the setup cost $4 + 6 = #part_pp.target.instance.cost_bound$; production and inventory costs are all zero in the fixture. The active periods therefore recover the source vector $(#fmt-values(part_pp_sol.source_config))$, selecting the subset of size #right-sum #sym.checkmark.
       ]
     }
 
@@ -19639,16 +19458,16 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(hpbtv_lp.source) + " -o hampath2v.json",
-      "pred reduce hampath2v.json --to " + target-spec(hpbtv_lp) + " -o bundle.json",
+      "pred reduce hampath2v.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate hampath2v.json --config " + hpbtv_lp_sol.source_config.map(str).join(","),
+      "pred evaluate hampath2v.json --config " + cli-config(hpbtv_lp_sol.source_config),
     )
 
     *Step 1 -- Source instance.* Graph $G$ with $n = #graph-num-vertices(hpbtv_lp.source.instance)$ vertices, $|E| = #graph-num-edges(hpbtv_lp.source.instance)$ edges, $s = #hpbtv_lp.source.instance.source_vertex$, $t = #hpbtv_lp.source.instance.target_vertex$.
 
     *Step 2 -- Identity reduction.* Target graph is identical with unit edge lengths. $K = n - 1 = #(graph-num-vertices(hpbtv_lp.source.instance) - 1)$, same $s$ and $t$.
 
-    *Step 3 -- Verify a solution.* Source Hamiltonian path visits vertices $(#hpbtv_lp_sol.source_config.map(str).join(", "))$ from $s = #hpbtv_lp.source.instance.source_vertex$ to $t = #hpbtv_lp.source.instance.target_vertex$. Target selects #hpbtv_lp_sol.target_config.filter(x => x == 1).len() edges, total length $= n - 1 = K$ #sym.checkmark.
+    *Step 3 -- Verify a solution.* Source Hamiltonian path visits vertices $(#fmt-values(hpbtv_lp_sol.source_config))$ from $s = #hpbtv_lp.source.instance.source_vertex$ to $t = #hpbtv_lp.source.instance.target_vertex$. Target selects #hpbtv_lp_sol.target_config.filter(x => x).len() edges, total length $= n - 1 = K$ #sym.checkmark.
 
     *Multiplicity:* The fixture stores one canonical witness.
   ],
@@ -19659,7 +19478,7 @@ The following table shows concrete variable overhead for example instances, take
 
   _Correctness._ ($arrow.r.double$) A Hamiltonian $s$-$t$ path has $n - 1$ edges of length 1 each, giving total length $n - 1 = K$. ($arrow.l.double$) A simple $s'$-$t'$ path of length $>= K = n - 1$ has $>= n - 1$ edges. Since a simple path on $n$ vertices can have at most $n - 1$ edges, it has exactly $n - 1$ edges and visits all vertices -- it is a Hamiltonian $s$-$t$ path.
 
-  _Solution extraction._ From the edge-selection vector, trace the path from $s$ following selected edges to reconstruct the vertex permutation.
+  _Solution extraction._ Evaluate the target configuration once and apply the aggregate predicate: the value must be finite and equal to $n-1$. Reject infeasible selections and shorter paths before traversing any edges. The target feasibility check guarantees a single connected simple path from $s$ to $t$; its $n-1$ edges visit all $n$ vertices. Start at $s$ and repeatedly take the neighbor other than the preceding vertex. This terminates at $t$ and yields the source permutation without repetitions. The same argument applies to every supplied target configuration, independently of any caller claim of optimality. An absent target maximum or a proven maximum below $n-1$ certifies a NO source instance. The source requires distinct valid endpoints, so $n>=2$; no empty-graph or equal-endpoint convention is introduced. The target value resolves to `Max<i64>` because unit weight `One` has sum type `i64`. Checked evaluation errors are propagated, and the threshold comparison uses exact integer conversion.
 ]
 
 // 18. GraphPartitioning → MaxCut (from main codebase)
@@ -19671,17 +19490,17 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example " + problem-spec(gp_mc.source) + " -o graphpart.json",
-      "pred reduce graphpart.json --to " + target-spec(gp_mc) + " -o bundle.json",
+      "pred reduce graphpart.json --via route.json -o bundle.json",
       "pred solve bundle.json",
-      "pred evaluate graphpart.json --config " + gp_mc_sol.source_config.map(str).join(","),
+      "pred evaluate graphpart.json --config " + cli-config(gp_mc_sol.source_config),
     )
 
     #{
       let n = graph-num-vertices(gp_mc.source.instance)
       let m = graph-num-edges(gp_mc.source.instance)
       let penalty = m + 1
-      let side-a = gp_mc_sol.source_config.enumerate().filter(((i, x)) => x == 0).map(((i, x)) => i)
-      let side-b = gp_mc_sol.source_config.enumerate().filter(((i, x)) => x == 1).map(((i, x)) => i)
+      let side-a = gp_mc_sol.source_config.enumerate().filter(((i, x)) => not x).map(((i, x)) => i)
+      let side-b = gp_mc_sol.source_config.enumerate().filter(((i, x)) => x).map(((i, x)) => i)
       let source-cut = gp_mc.source.instance.graph.edges.filter(e => gp_mc_sol.source_config.at(e.at(0)) != gp_mc_sol.source_config.at(e.at(1))).len()
       let target-weight = gp_mc.target.instance.graph.edges.enumerate().filter(((i, e)) => gp_mc_sol.target_config.at(e.at(0)) != gp_mc_sol.target_config.at(e.at(1))).map(((i, e)) => gp_mc.target.instance.edge_weights.at(i)).sum()
       let unbalanced-pairs = (n / 2 - 1) * (n / 2 + 1)
@@ -19691,7 +19510,7 @@ The following table shows concrete variable overhead for example instances, take
 
         *Step 2 -- Build the weighted complete graph.* The target has $#graph-num-vertices(gp_mc.target.instance)$ vertices and $#graph-num-edges(gp_mc.target.instance)$ edges. Original edges receive weight $P - 1 = #(penalty - 1)$, while non-edges receive weight $P = #penalty$.
 
-        *Step 3 -- Verify the canonical witness.* The balanced partition $(#gp_mc_sol.source_config.map(str).join(", "))$ gives sides $A = {#side-a.map(str).join(", ")}$ and $B = {#side-b.map(str).join(", ")}$ with $#(side-a.len() * side-b.len())$ crossing pairs. It cuts #source-cut source edges, so the identical Max-Cut partition has weight $#target-weight = #penalty dot #(side-a.len() * side-b.len()) - #source-cut$. Any unbalanced $2$-$4$ split has at most #unbalanced-pairs crossing pairs and therefore weight at most $#unbalanced-upper < #target-weight$, so the optimum is forced to be balanced #sym.checkmark.
+        *Step 3 -- Verify the canonical witness.* The balanced partition $(#fmt-values(gp_mc_sol.source_config))$ gives sides $A = {#fmt-values(side-a)}$ and $B = {#fmt-values(side-b)}$ with $#(side-a.len() * side-b.len())$ crossing pairs. It cuts #source-cut source edges, so the identical Max-Cut partition has weight $#target-weight = #penalty dot #(side-a.len() * side-b.len()) - #source-cut$. Any unbalanced $2$-$4$ split has at most #unbalanced-pairs crossing pairs and therefore weight at most $#unbalanced-upper < #target-weight$, so the optimum is forced to be balanced #sym.checkmark.
       ]
     }
 
@@ -19729,10 +19548,10 @@ The following table shows concrete variable overhead for example instances, take
   extra: [
     #pred-commands(
       "pred create --example PrizeCollectingSteinerForest -o pcsf.json",
-      "pred reduce pcsf.json --to " + target-spec(pcsf_st) + " -o bundle.json",
+      "pred reduce pcsf.json --via route.json -o bundle.json",
       "pred solve bundle.json",
     )
-    The canonical PCSF source has $beta = #pcsf_st.source.instance.beta$, $omega = #pcsf_st.source.instance.omega$, and prizes $p = (#pcsf_st_prizes.at(0), #pcsf_st_prizes.at(1), #pcsf_st_prizes.at(2))$. The target SteinerTree has $|V_H| = n + k + 1 = #(pcsf_st_n + pcsf_st_k + 1)$ vertices, $|E_H| = m + n + 2 k = #(pcsf_st_m + pcsf_st_n + 2 * pcsf_st_k)$ edges, and $|T_H| = k + 1 = #(pcsf_st_k + 1)$ terminals, matching the registered overhead formulas.
+    The canonical PCSF source has $beta = #pcsf_st.source.instance.beta$, $omega = #pcsf_st.source.instance.omega$, and prizes $p = (#pcsf_st_prizes.at(0), #pcsf_st_prizes.at(1), #pcsf_st_prizes.at(2))$. The target SteinerTree has $|V_H| = n + k + 1 = #(pcsf_st_n + pcsf_st_k + 1)$ vertices, $|E_H| = m + n + 2 k = #(pcsf_st_m + pcsf_st_n + 2 * pcsf_st_k)$ edges, and $|T_H| = k + 1 = #(pcsf_st_k + 1)$ terminals, matching the registered exact size formulas.
   ],
 )[
   Bienstock, Goemans, Simchi-Levi, Williamson @BienstockGoemansSimchiLeviWilliamson1993 introduced the prize/penalty framework for prize-collecting network design; Tuncbag and coauthors @TuncbagEtAl2013PCSF @TuncbagEtAl2012RECOMB used the same artificial-root idea to translate PCSF into a rooted prize-collecting Steiner tree on biological networks. The combined construction recorded here adds a per-vertex auxiliary-terminal gadget that compiles the remaining omitted-prize term `beta * p(v)` into ordinary Steiner-tree edge costs, so the target is a plain (unweighted-prize) Steiner Tree instance.
diff --git a/docs/paper/references.bib b/docs/paper/references.bib
index 186f70de2..369d309f0 100644
--- a/docs/paper/references.bib
+++ b/docs/paper/references.bib
@@ -1,3 +1,13 @@
+@misc{ozkayaCatalyurek2022,
+  author       = {M. Yusuf {\"O}zkaya and {\"U}mit V. {{\c C}}ataly{\"u}rek},
+  title        = {A Simple and Elegant Mathematical Formulation for the Acyclic {DAG} Partitioning Problem},
+  year         = {2022},
+  eprint       = {2207.13638},
+  archiveprefix = {arXiv},
+  primaryclass = {cs.DS},
+  doi          = {10.48550/arXiv.2207.13638}
+}
+
 @inproceedings{bouchez2006,
   author    = {Florent Bouchez and Alain Darte and Christophe Guillon and Fabrice Rastello},
   title     = {Register Allocation: What Does the {NP}-Completeness Proof of {Chaitin} et al. Really Prove?},
@@ -31,6 +41,14 @@ @article{brunoSethi1976
   doi     = {10.1145/321958.321974}
 }
 
+@inproceedings{sethi1973,
+  author = {Ravi Sethi},
+  title = {Complete Register Allocation Problems},
+  booktitle = {Proceedings of the Fifth Annual ACM Symposium on Theory of Computing},
+  year = {1973},
+  doi = {10.1145/800125.804049}
+}
+
 @article{sethi1975,
   author  = {Ravi Sethi},
   title   = {Complete Register Allocation Problems},
@@ -216,6 +234,27 @@ @inproceedings{karp1972
   pages     = {85--103}
 }
 
+@book{micciancio2002,
+  author    = {Daniele Micciancio and Shafi Goldwasser},
+  title     = {Complexity of Lattice Problems: A Cryptographic Perspective},
+  publisher = {Springer New York},
+  series    = {The Springer International Series in Engineering and Computer Science},
+  volume    = {671},
+  year      = {2002},
+  doi       = {10.1007/978-1-4615-0897-7}
+}
+
+@article{fincke1985,
+  author  = {Ulrich Fincke and Michael Pohst},
+  title   = {Improved Methods for Calculating Vectors of Short Length in a Lattice, Including a Complexity Analysis},
+  journal = {Mathematics of Computation},
+  volume  = {44},
+  number  = {170},
+  pages   = {463--471},
+  year    = {1985},
+  doi     = {10.2307/2007966}
+}
+
 @article{lagarias1985,
   author  = {Jeffrey C. Lagarias and Andrew M. Odlyzko},
   title   = {Solving Low-Density Subset Sum Problems},
@@ -283,7 +322,7 @@ @article{galilMegiddo1977
   number  = {2},
   pages   = {179--182},
   year    = {1977},
-  doi     = {10.1016/0304-3975(77)90005-1}
+  doi     = {10.1016/0304-3975(77)90005-6}
 }
 
 @article{florianLenstraRinnooyKan1980,
@@ -449,7 +488,8 @@ @article{sahni1974
   volume  = {3},
   number  = {4},
   pages   = {262--279},
-  year    = {1974}
+  year    = {1974},
+  doi     = {10.1137/0203021}
 }
 
 @article{abdelWahabKameda1978,
@@ -1454,6 +1494,17 @@ @article{hu1961
   doi     = {10.1287/opre.9.6.841}
 }
 
+@article{hu1974ocst,
+  author  = {Te Chiang Hu},
+  title   = {Optimum Communication Spanning Trees},
+  journal = {SIAM Journal on Computing},
+  volume  = {3},
+  number  = {3},
+  pages   = {188--195},
+  year    = {1974},
+  doi     = {10.1137/0203015}
+}
+
 @article{adolphsonHu1973,
   author  = {Donald Adolphson and Te Chiang Hu},
   title   = {Optimal Linear Ordering},
@@ -1695,12 +1746,13 @@ @article{horn1973
   year    = {1973}
 }
 
-@techreport{plaisted1976,
-  author      = {David A. Plaisted},
-  title       = {Some Polynomial and Integer Divisibility Problems Are {NP}-Hard},
-  institution = {Stanford University, Department of Computer Science},
-  number      = {STAN-CS-76-583},
-  year        = {1976}
+@inproceedings{plaisted1976,
+  author    = {David A. Plaisted},
+  title     = {Some Polynomial and Integer Divisibility Problems Are {NP}-Hard},
+  booktitle = {17th Annual Symposium on Foundations of Computer Science},
+  pages     = {264--267},
+  year      = {1976},
+  doi       = {10.1109/SFCS.1976.29}
 }
 
 @article{Streif2021,
@@ -1775,33 +1827,6 @@ @article{yannakakis1980
   doi     = {10.1137/0138030}
 }
 
-@inproceedings{edmonds1970,
-  author    = {Jack Edmonds},
-  title     = {Submodular functions, matroids, and certain polyhedra},
-  booktitle = {Combinatorial Structures and Their Applications},
-  pages     = {69--87},
-  year      = {1970},
-  publisher = {Gordon and Breach}
-}
-
-@article{doron2024,
-  author  = {Ilan Doron-Arad and Ariel Kulik and Hadas Shachnai},
-  title   = {You (Almost) Can't Beat Brute Force for 3-Matroid Intersection},
-  journal = {arXiv preprint arXiv:2412.02217},
-  year    = {2024}
-}
-
-@article{fomin2019,
-  author  = {Fedor V. Fomin and Daniel Lokshtanov and Fahad Panolan and Saket Saurabh},
-  title   = {Exact Algorithms via Monotone Local Search},
-  journal = {Journal of the ACM},
-  volume  = {66},
-  number  = {2},
-  pages   = {1--23},
-  year    = {2019},
-  doi     = {10.1145/3277568}
-}
-
 @book{vonNeumannMorgenstern1944,
   author    = {John von Neumann and Oskar Morgenstern},
   title     = {Theory of Games and Economic Behavior},
@@ -2143,3 +2168,156 @@ @article{berlekampMcElieceTilborg1978
   doi     = {10.1109/TIT.1978.1055873}
 }
 
+
+@article{gouveiaLopes2000,
+  author  = {Luis Gouveia and Maria Joao Lopes},
+  title   = {Valid Inequalities for Non-Unit Demand Capacitated Spanning Tree Problems with Flow Costs},
+  journal = {European Journal of Operational Research},
+  volume  = {121},
+  number  = {2},
+  pages   = {394--411},
+  year    = {2000},
+  doi     = {10.1016/S0377-2217(99)00043-0}
+}
+
+
+@inproceedings{jarvisaloEtAl2012,
+  author    = {Matti J{"a}rvisalo and Petteri Kaski and Mikko Koivisto and Janne H. Korhonen},
+  title     = {Finding Efficient Circuits for Ensemble Computation},
+  booktitle = {Theory and Applications of Satisfiability Testing -- SAT 2012},
+  series    = {Lecture Notes in Computer Science},
+  volume    = {7317},
+  pages     = {369--382},
+  year      = {2012},
+  publisher = {Springer},
+  doi       = {10.1007/978-3-642-31612-8_28}
+}
+
+@article{burrErdosLovasz1976Ramsey,
+  author = {Stefan A. Burr and Paul Erdős and László Lovász},
+  title = {On graphs of {Ramsey} type},
+  journal = {Ars Combinatoria},
+  volume = {1},
+  year = {1976},
+  pages = {167--190},
+  url = {https://users.renyi.hu/~p_erdos/1976-23.pdf}
+}
+
+@article{goemansmyung1993catalog,
+  author = {Goemans, Michel X. and Myung, Young-soo},
+  title = {A Catalog of Steiner Tree Formulations},
+  journal = {Networks},
+  year = {1993},
+  volume = {23},
+  number = {1},
+  pages = {19--28},
+  doi = {10.1002/net.3230230104},
+}
+
+@misc{borosgruber2014quadratization,
+  author = {Boros, Endre and Gruber, Aritanan},
+  title = {On Quadratization of Pseudo-Boolean Functions},
+  year = {2014},
+  eprint = {1404.6538},
+  archivePrefix = {arXiv},
+  primaryClass = {math.OC},
+  note = {Paper presented at ISAIM 2012; arXiv version 2014},
+}
+
+@techreport{bian2010ising,
+  author = {Bian, Zhengbing and Chudak, Fabian and Macready, William G. and Rose, Geordie},
+  title = {The Ising Model: Teaching an Old Problem New Tricks},
+  institution = {D-Wave Systems},
+  year = {2010},
+  url = {https://www.dwavequantum.com/media/vbklsvbh/weightedmaxsat_v2.pdf}
+}
+
+@article{jackson2025,
+  author = {Marcel Jackson},
+  title = {Flexible constraint satisfiability and a problem in semigroup theory},
+  journal = {International Journal of Algebra and Computation},
+  year = {2025},
+  doi = {10.1142/S0218196725500225},
+  url = {https://arxiv.org/abs/1512.03127}
+}
+
+@article{vielma2015,
+  author = {Juan Pablo Vielma},
+  title = {Mixed Integer Linear Programming Formulation Techniques},
+  journal = {SIAM Review},
+  volume = {57},
+  number = {1},
+  pages = {3--57},
+  year = {2015},
+  doi = {10.1137/130915303},
+  url = {https://juan-pablo-vielma.github.io/publications/Mixed-Integer-Linear-Programming-Formulation-Techniques.pdf}
+}
+
+@article{micciancio2001,
+  author = {Daniele Micciancio},
+  title = {The Hardness of the Closest Vector Problem with Preprocessing},
+  journal = {IEEE Transactions on Information Theory},
+  volume = {47},
+  number = {3},
+  pages = {1212--1215},
+  year = {2001},
+  url = {https://cseweb.ucsd.edu/~daniele/papers/CVPP.pdf}
+}
+
+@misc{larusic2010,
+  author = {Larusic, John and Punnen, Abraham P. and Aubanel, Eric},
+  title = {Experimental Analysis of Heuristics for the Bottleneck Traveling Salesman Problem},
+  year = {2010},
+  howpublished = {Optimization Online preprint},
+  url = {https://optimization-online.org/wp-content/uploads/2010/01/2516.pdf},
+}
+
+@misc{dally2006ee108,
+  author = {William J. Dally},
+  title = {{EE108 Class Notes}},
+  year = {2006},
+  howpublished = {Stanford University, Section 10.4},
+  url = {https://web.stanford.edu/class/archive/ee/ee108a/ee108a.1082/reader/ch1to12.pdf},
+  note = {Copyright 2002--2006; Figures 10.15 and 10.16}
+}
+
+@misc{karger2021flow,
+  author = {David Karger},
+  title = {Flow: 6.854 Notes 6},
+  year = {2021},
+  howpublished = {MIT Advanced Algorithms lecture notes},
+  url = {https://courses.csail.mit.edu/6.854/21/Notes/n06-flow.html},
+  note = {Section 1.1: flow decomposition and cuts}
+}
+
+@article{sahni-gonzalez1976,
+  author = {Sahni, Sartaj and Gonzalez, Teofilo},
+  title = {P-Complete Approximation Problems},
+  journal = {Journal of the ACM},
+  volume = {23},
+  number = {3},
+  pages = {555--565},
+  year = {1976},
+  doi = {10.1145/321958.321975},
+  url = {https://sites.cs.ucsb.edu/~teo/papers/JACM-PCom.pdf}
+}
+
+@techreport{lipski1978consecutive,
+  author = {Witold Lipski Jr.},
+  title = {Generalizations of the Consecutive Ones Property and Related {NP}-Complete Problems},
+  institution = {Coordinated Science Laboratory, University of Illinois at Urbana-Champaign},
+  number = {T-67},
+  year = {1978},
+  month = {October},
+  url = {https://www.ideals.illinois.edu/items/99870/bitstreams/319087/data.pdf}
+}
+
+@techreport{mandersAdleman1976,
+  author = {Kenneth L. Manders and Leonard Adleman},
+  title = {{NP}-Complete Decision Problems for Binary Quadratics},
+  institution = {Electronics Research Laboratory, University of California, Berkeley},
+  number = {ERL-M615},
+  year = {1976},
+  month = {November},
+  url = {https://digicoll.lib.berkeley.edu/record/134974/files/ERL-m-615.pdf}
+}
diff --git a/docs/src/cli-commands.md b/docs/src/cli-commands.md
index 0232d9de3..97eb52217 100644
--- a/docs/src/cli-commands.md
+++ b/docs/src/cli-commands.md
@@ -10,7 +10,7 @@ pred show MIS
 pred list --rules
 ```
 
-`list` reports every problem with its aliases, variants, and reduction counts. `show` describes the resolved variant, its size fields, input schema, and incoming and outgoing reductions. Read that schema before constructing an instance.
+`list` reports every problem with its aliases, variants, and reduction counts. `show` describes the resolved variant, its parameter fields, input schema, and incoming and outgoing reductions. Read that schema before constructing an instance.
 
 <details>
 <summary>Example: <code>pred show MIS</code></summary>
@@ -24,11 +24,11 @@ pred list --rules
 ## Names and variants
 
 ```bash
-pred show MIS/SimpleGraph/i32
-pred path MIS/SimpleGraph/i32 ILP/bool
+pred show MIS/SimpleGraph/i64
+pred path MIS/SimpleGraph/i64 ILP/bool
 ```
 
-Aliases such as `MIS` resolve to full names, and a bare name selects the declared default variant: `MIS` is `MaximumIndependentSet/SimpleGraph/One`. Slash-separated parameters select graph, weight, or other variant values. `One` means unit weights; passing non-unit `--weights` to `create` upgrades a default instance to `i32`. Name the exact variant when a reproducible endpoint matters.
+Aliases such as `MIS` resolve to full names, and a bare name selects the declared default variant: `MIS` is `MaximumIndependentSet/SimpleGraph/One`. Slash-separated parameters select graph, weight, or other variant values. `One` means unit weights; passing non-unit `--weights` to `create` upgrades a default instance to `i64`. Name the exact variant when a reproducible endpoint matters.
 
 {{#include generated/pred-aliases.txt}}
 
@@ -36,13 +36,13 @@ Aliases such as `MIS` resolve to full names, and a bare name selects the declare
 
 ```bash
 pred path MIS ILP
-pred path MIS QUBO --all --max-paths 50
-pred path MIS QUBO --cost minimize:num_variables -o path.json
+pred path MIS QUBO --limit 50
+pred path MIS QUBO --json -o paths.json
 pred from MIS --hops 2
 pred to QUBO
 ```
 
-`path` finds the cheapest route between two endpoints; `--all` enumerates alternatives up to `--max-paths`. The default cost minimizes steps; `minimize:<field>` uses the overhead metadata of a size field from `pred show`. `from` and `to` explore outgoing and incoming neighbors. Search defaults to reductions that can map a solution back.
+`path` enumerates witness-capable simple routes between exact endpoints, without ranking. `--limit` accepts 1 through 999, or `all` for 999; the default is 20. JSON output contains `paths` and `truncated`. `from` and `to` explore outgoing and incoming neighbors.
 
 <details>
 <summary>Example: a multi-step path from <code>Factoring</code> to <code>SpinGlass</code></summary>
@@ -53,14 +53,14 @@ pred to QUBO
 
 </details>
 
-Overhead formulas describe scaling bounds, not exact target sizes. A discovered route does not imply the target is cheap to solve; inspect the constructed target on representative instances.
+Parameter transforms declare exact equalities, upper bounds, or unavailable relations. A discovered route does not imply the target is cheap to solve; inspect the constructed target on representative instances.
 
 ## Create
 
 ```bash
 pred create MIS --graph 0-1,1-2,2-3 -o problem.json
-pred create MIS/SimpleGraph/i32 --graph 0-1,1-2,2-3 --weights 2,1,3,1 -o weighted.json
-pred create --example MVC/SimpleGraph/i32 --to MIS/SimpleGraph/i32 -o source.json
+pred create MIS/SimpleGraph/i64 --graph 0-1,1-2,2-3 --weights 2,1,3,1 -o weighted.json
+pred create --example MVC/SimpleGraph/i64 --to MIS/SimpleGraph/i64 -o source.json
 pred create MIS --random --num-vertices 10 --edge-prob 0.3 --seed 42 -o random.json
 ```
 
@@ -79,21 +79,24 @@ pred create Factoring --target 6 --m 2 --n 2 -o factoring.json
 
 ```bash
 pred inspect problem.json
-pred evaluate problem.json --config 1,0,1,0
-pred create MIS --graph 0-1,1-2,2-3 | pred evaluate - --config 1,0,1,0
+pred evaluate problem.json --config '[true,false,true,false]'
+pred create MIS --graph 0-1,1-2,2-3 | pred evaluate - --config '[true,false,true,false]'
 ```
 
 `inspect` reports the resolved variant and sizes of a problem file or reduction bundle. `evaluate` scores one configuration: selecting vertices 0 and 2 returns `Max(2)`, while selecting adjacent vertices returns `Max(None)`. Configurations follow each problem's variable domains and are not always binary. `-` reads from stdin.
 
+For a problem file, JSON inspection includes `parameter_values`, the model's actual named instance parameters. These are separate from the `parameters` list of parameter names.
+
 ## Reduce
 
 ```bash
-pred reduce problem.json --to QUBO -o reduced.json
+pred path MIS QUBO --json -o paths.json
+python3 -c 'import json; print(json.dumps(json.load(open("paths.json"))["paths"][0]))' > path.json
 pred reduce problem.json --via path.json -o reduced.json
-pred extract reduced.json --config 1,0,1,0
+pred extract reduced.json --config '[1,0,1,0]'
 ```
 
-The bundle contains the source instance, the target instance, and the variant-level path; keep it whole to preserve solution recovery. `--via` replays a path saved by `pred path -o`, whose source variant must match the input. `extract` maps a target-space configuration back to the source.
+The bundle contains the source instance, the target instance, and the variant-level path; keep it whole to preserve solution recovery. `--via` replays one route extracted from the `paths` envelope, whose source variant must match the input. `extract` maps a target-space configuration back to the source.
 
 ## Solve
 
@@ -105,16 +108,16 @@ pred solve reduced.json --timeout 30 --json
 
 | Solver | Behavior |
 |---|---|
-| `ilp` (default) | Finds a route to ILP, solves the target, and recovers a source configuration |
+| `ilp` | Executes the exact variant’s registered fixed ILP pipeline and recovers its source solution |
 | `brute-force` | Enumerates all configurations; for tiny instances and cross-checks |
 | `customized` | Exact structure-exploiting backends for selected models; see `pred solve --help` |
 
-Solving a bundle solves the target and maps the result back; JSON output records the target result under `intermediate`. If the ILP solver reports no route, check `pred path <exact-variant> ILP`. Aggregate-only problems return a value without a configuration. To verify a result, evaluate the returned configuration on the original instance, or compare the value with an exhaustive solve on a small example.
+Default dispatch tries registered customized, ILP, then brute-force capabilities in that order. `pred inspect` lists the capabilities available for the exact variant. Solving a bundle solves its target and maps the result back; every successful solve returns a solution. A discovered path does not by itself provide a registered solver. Evaluate the returned solution on the original instance to verify its value.
 
 ## JSON and pipes
 
 ```bash
-pred create MIS --graph 0-1,1-2,2-3 | pred reduce - --to QUBO | pred solve - --json
+pred create MIS --graph 0-1,1-2,2-3 | pred reduce - --via path.json | pred solve - --json
 pred export-graph -o reduction_graph.json
 ```
 
diff --git a/docs/src/cli.md b/docs/src/cli.md
index 22198cf3c..a5e337609 100644
--- a/docs/src/cli.md
+++ b/docs/src/cli.md
@@ -7,7 +7,7 @@ cargo install problemreductions-cli
 pred --version
 ```
 
-Rust and a native build toolchain are required. The default ILP backend is HiGHS; the `cplex` and `lp-solvers` features enable separately installed backends listed in the [CLI manifest](https://github.com/CodingThrust/problem-reductions/blob/main/problemreductions-cli/Cargo.toml).
+Rust and a native build toolchain are required. ILP solving uses the bundled HiGHS backend.
 
 The published crate may lag behind the catalog on this site. To build the current checkout:
 
@@ -22,10 +22,10 @@ cargo install --path problemreductions-cli
 ```bash
 pred create MIS --graph 0-1,1-2,2-3,3-4,4-0 -o cycle.json
 pred solve cycle.json
-pred evaluate cycle.json --config 1,0,1,0,0
+pred evaluate cycle.json --config '[true,false,true,false,false]'
 ```
 
-`MIS` is Maximum Independent Set: select as many pairwise non-adjacent vertices as possible. The graph is a cycle on five vertices. `solve` discovers a route to ILP, solves the target, and maps the solution back, reporting `Max(2)` with a configuration such as `[1, 0, 1, 0, 0]`. `evaluate` scores a configuration of your own against the same instance. Several optimal configurations exist, so the solver's choice may differ from yours.
+`MIS` is Maximum Independent Set: select as many pairwise non-adjacent vertices as possible. The graph is a cycle on five vertices. `solve` executes the registered ILP pipeline and maps the solution back, reporting `Max(2)` with a configuration such as `[true, false, true, false, false]`. `evaluate` scores a configuration of your own against the same instance. Several optimal configurations exist, so the solver's choice may differ from yours.
 
 ## Terminal session
 
@@ -36,18 +36,13 @@ A recording of the real CLI: discover a route, transform the instance, solve, an
 [Open the player](static/cli-demo.html) · [Download the cast](static/cli-demo.cast)
 
 ```bash
-pred path MIS ILP
+pred path MIS ILP --json -o paths.json
+python3 -c 'import json; print(json.dumps(json.load(open("paths.json"))["paths"][0]))' > path.json
 pred create MIS --graph 0-1,1-2,2-3,3-4,4-0 -o cycle.json
-pred reduce cycle.json --to ILP -o reduced.json
+pred reduce cycle.json --via path.json -o reduced.json
 pred solve reduced.json
-pred evaluate cycle.json --config 1,0,1,0,0
+pred evaluate cycle.json --config '[true,false,true,false,false]'
 pred solve cycle.json
 ```
 
-The route passes through Maximum Set Packing and a weight cast before reaching binary ILP. `reduced.json` keeps the source instance and the path, so solving the bundle recovers a source solution. The final command solves the original file directly and discovers the same route on its own.
-
-| Check | Recorded result |
-|---|---|
-| Solve the reduction bundle | `Max(2)`, configuration `[1, 0, 1, 0, 0]` |
-| Evaluate that configuration on the source | `Max(2)` |
-| Solve the original instance directly | `Max(2)`, solver `ilp (via ILP)` |
+`path.json` contains one explicitly selected route from the returned path set. `reduced.json` keeps the source instance and that route, so solving the bundle recovers a source solution. The final command solves the original file through its registered ILP pipeline. Both solves and the independent evaluation return `Max(2)`; optimal solutions may differ.
diff --git a/docs/src/design.md b/docs/src/design.md
index 32bdccb3c..54ed4f47f 100644
--- a/docs/src/design.md
+++ b/docs/src/design.md
@@ -1,8 +1,11 @@
 # Design
 
-The Rust library holds problem definitions, executable reductions, and their registry metadata. The CLI exposes that core to tools and agents.
+This guide covers the library internals for contributors.
 
-Each layer depends only on the layers above it.
+See [Numeric types and arithmetic](#numeric-types-and-arithmetic) before
+choosing numeric fields or implementing arithmetic in a model or reduction.
+
+## Module Architecture
 
 | Location | Responsibility | Depends on |
 |---|---|---|
@@ -16,40 +19,137 @@ Each layer depends only on the layers above it.
 | `src/unit_tests/` | Tests mirroring the source tree | Everything |
 | `problemreductions-cli/` | The `pred` CLI | The library |
 
-## Problem contract
+## Problem Model
 
-Every problem implements `Problem`. `evaluate()` returns the associated `Value` for one configuration; solvers fold those values across the configuration space defined by `dims()`.
+Every problem implements `Problem`. The associated `Value` type is the per-configuration aggregate returned by `evaluate()`. Solvers fold these values across the configuration space, and witness-capable aggregates can also recover representative configurations.
 
 ```rust,ignore
-trait Problem {
+trait Problem: Clone {
     const NAME: &'static str;              // e.g., "MaximumIndependentSet"
-    type Value: Clone;                     // e.g., Max<i32>, Or, Sum<i32>
-    fn dims(&self) -> Vec<usize>;          // configuration space per variable
-    fn evaluate(&self, config: &[usize]) -> Self::Value;
-    fn variant() -> Vec<(&'static str, &'static str)>; // e.g., [("graph", "SimpleGraph"), ("weight", "i32")]
-    fn num_variables(&self) -> usize;      // default: dims().len()
+    type Solution;                         // e.g., Vec<bool>, permutation, tuple
+    type Value: Clone;                     // e.g., Max<i64>, Or, Sum<i64>
+    fn parameter_names() -> &'static [&'static str];
+    fn parameters(&self) -> ProblemParameters;
+    fn evaluate(&self, solution: &Self::Solution) -> Result<Self::Value, EvaluationError>;
+    fn variant() -> Vec<(&'static str, &'static str)>; // e.g., [("graph", "SimpleGraph"), ("weight", "i64")]
     fn problem_type() -> ProblemType;      // default: registry lookup by NAME
 }
 ```
 
-A four-vertex independent set problem has `dims() = [2, 2, 2, 2]`; `evaluate(&[1, 0, 1, 0])` returns `Max(Some(2))` if vertices 0 and 2 are non-adjacent and `Max(None)` otherwise. Witness-capable objective problems use `Max<V>`, `Min<V>`, or `Extremum<V>`; feasibility problems use `Or`; aggregate-only problems such as counting use `Sum<W>` or `And` and solve to a value without a representative configuration. Each problem also provides inherent getters such as `num_vertices()` that reduction overhead expressions reference.
-
-## Variants
-
-One problem name can have several **variants**: weights on vertices, or a restricted topology such as a king's subgraph. Variants form a subtype hierarchy, and the reduction from a more specific variant to a less specific one is a **variant cast**, an identity mapping that preserves indices.
+- **`Problem`** — the base trait. Every problem declares a mathematical `Solution` type, evaluates that type directly, and reports its canonical instance parameters. For example, a 4-vertex MIS uses `Vec<bool>`; `evaluate(&[true, false, true, false])` returns `Ok(Max(Some(2)))` if vertices 0 and 2 form an independent set, or `Ok(Max(None))` if they share an edge. Inherent getters such as `num_vertices()` and `num_edges()` supply the named parameters used by reduction expressions.
+- **`BruteForceProblem`** — the reference-solver capability for registered variants with a finite Cartesian coordinate space. Its `dimensions()` method and the Cartesian iterator belong to the brute-force solver, not to the mathematical `Problem` contract.
+- **Objective problems** — typically use `Max<V>`, `Min<V>`, or `Extremum<V>` as `Value`.
+- **Feasibility problems** — typically use `Or`.
+- **Solve contract** — a successful solve always returns the problem's `Solution`; a global count or statistic without a representative solution is not a `Problem` solve.
+- **Common aggregate wrappers** — `Max<V>`, `Min<V>`, `Sum<W>`, `Or`, `And`, `Extremum<V>`, `ExtremumSense`.
+
+## Construction inputs
+
+`VariantEntry::inputs()` describes the values a concrete constructor accepts.
+Models with a separate construction specification supply `CreateSpec::inputs()`;
+direct constructors use their declared fields. CLI creation, MCP creation, and
+`pred show` use this contract. Model-level
+catalog fields describe the model family; they are not a concrete variant's input
+schema. `show` exposes concrete `inputs` in JSON and labels them **Inputs** in text.
+
+Unit-valued data are implicit in `One` variants. For example, `MVC/One` accepts a
+graph, while `MVC/i64` also accepts vertex weights. Constructors derive unit-vector
+lengths from the graph, set family, or task deadlines. Internal `Vec<One>` storage
+and persisted instance JSON remain independent of construction inputs. Supplying
+an undeclared weight or length input is an error, even when every value is one.
+
+`Decision<P>` composes the registered inputs of `P` with an objective `bound` and
+calls `P`'s registered constructor before wrapping the result. It does not repeat
+the inner input schema or deserialize construction inputs as persisted model JSON.
+
+## Numeric types and arithmetic
+
+Numeric formats are selected by semantic role:
+
+- `usize` represents in-memory indices, collection lengths, and brute-force
+  dimensions;
+- `u64` represents public problem parameters and the input/output values
+  of reduction parameter expressions;
+- `i64` represents signed mathematical integers;
+- `bool` represents Boolean variables; and
+- finite `f64` represents real or rational values when an approximate
+  representation is part of the model contract.
+
+`usize` is not a portable serialized parameter format, and `u64` is not an index or
+general-purpose replacement for a model's mathematical integer domain.
+
+Another numeric format requires sufficient justification from the mathematical
+problem or target schema. Required exceptions include `BigUint` in `Factoring`,
+`SubsetSum`, `SubsetProduct`, `QuadraticCongruences`, and
+`QuadraticDiophantineEquations`, where arbitrary precision is part of the
+problem, and `One` in unweighted variants, where the type represents the
+unit-weight domain. Implementation convenience is not sufficient justification.
+There is no `i32` model or I/O numeric format.
+
+This contract applies only at model, result, reduction-target, and external I/O
+boundaries; implementation-local values are outside its scope. For example,
+SpinGlass couplings and its objective result use `i64`, while the temporary
+`{−1, +1}` spin values used inside `evaluate()` need not. A reduction's
+temporary calculations are also outside the contract, but numeric fields
+written into its target model must follow the target model's numeric format.
+
+Weight variants are `One`, `i64`, and `f64`, with `One ⊂ i64 ⊂ f64`.
+`i64 → f64` is a fallible reduction using a checked conversion in
+`±(2^53-1)`, not `as f64`.
+
+### Arithmetic
+
+- Keep arithmetic in the declared type. Exact values use checked `i64`
+  operations; approximate values use finite `f64` operations.
+- Constructors and reductions reject an arithmetic step that would overflow
+  `i64` when producing a stored field. They do not cap every magnitude at
+  `2^53-1`. `evaluate()` never widens, wraps, saturates, or silently
+  approximates.
+- Do not promote an `i64` calculation to `i128`, `BigInt`, or `BigUint` to
+  accept a larger instance.
+
+### Boundaries
+
+- Use `From` only for value-preserving conversions and `TryFrom` when range,
+  sign, or domain can change. Do not use `as` for model-derived values.
+- Converting a registered parameter getter from `usize` to `u64` is an internal
+  invariant of `Problem::parameters()`, not a recoverable construction error. A valid
+  instance's registered parameters must already fit `u64`; the
+  implementation checks this conversion to prevent silent truncation.
+- Symbolic parameter evaluation may use arbitrary-precision integers for local
+  intermediate arithmetic, but a materialized `ProblemParameters` must fit `u64`.
+- An `i64` to `f64` conversion is explicit and fallible: it succeeds only
+  for `|value| ≤ 2^53-1`. Use one shared helper at weight casts, solver
+  adapters, and other exact-to-float hubs.
+- A lattice-to-`UnitDiskGraph` reduction converts coordinates fallibly and
+  rejects a stored `f64` geometry that would change source adjacency.
+- Rust constructors keep `i64` fields as `i64`. CLI and MCP JSON encoding
+  of an `i64` with `|value| > 2^53-1` errors; there is no string encoding
+  and no clamping.
+
+## Variant System
+
+A single problem name like `MaximumIndependentSet` can have multiple
+**variants**. Each variant is identified by dimension-value pairs such as
+`{graph: "SimpleGraph", weight: "i64"}`. Concrete variants are registered
+nodes in the reduction graph, and explicit reduction rules connect them.
 
 <div class="theme-light-only">
 
-![Variant Hierarchy](static/variant-hierarchy.svg)
+![Variant Dimensions](static/variant-hierarchy.svg)
 
 </div>
 <div class="theme-dark-only">
 
-![Variant Hierarchy](static/variant-hierarchy-dark.svg)
+![Variant Dimensions](static/variant-hierarchy-dark.svg)
 
 </div>
 
-Variant parameters fall into three categories: graph type (`SimpleGraph` at the root, then `PlanarGraph`, `BipartiteGraph`, `UnitDiskGraph`, `KingsSubgraph`, `TriangularSubgraph`), weight type (`One`, `i32`, `f64`), and K value (`K3` for 3-SAT, `KN` for arbitrary K).
+Variant types fall into three categories:
+
+- **Graph type** — `SimpleGraph`, `PlanarGraph`, `BipartiteGraph`, `UnitDiskGraph`, `KingsSubgraph`, `TriangularSubgraph`.
+- **Weight type** — `One` (unweighted), `i64`, `f64`.
+- **K value** — e.g., `K3` for 3-SAT, `KN` for arbitrary K.
 
 <div class="theme-light-only">
 
@@ -62,58 +162,279 @@ Variant parameters fall into three categories: graph type (`SimpleGraph` at the
 
 </div>
 
-Each parameter type implements `VariantParam`, declaring its category, value, and optional parent; types with a parent also implement `CastToParent` for the runtime conversion. `Problem::variant()` is composed from the type parameters with `variant_params![G, W]`. The macros `impl_variant_param!`, `impl_variant_reduction!`, and `declare_variants!` register parameter types, explicit variant casts, and concrete variants with their load, serialize, and solve metadata. Their current contract is documented in the [repository instructions](https://github.com/CodingThrust/problem-reductions/blob/main/.claude/CLAUDE.md) and visible in any model file.
+<details>
+<summary>Implementation details: VariantParam trait and macros</summary>
 
-## Reductions
+### VariantParam trait
 
-A reduction connects exact source and target variants. Its capability determines how a result is recovered:
+Each reusable variant parameter type implements `VariantParam`, which declares
+its category and value:
 
-| Capability | Contract | Example |
-|---|---|---|
-| Witness | `ReduceTo<T>` and `ReductionResult::extract_solution` | Solve a target, recover a source configuration |
-| Aggregate | `ReduceToAggregate<T>` and `AggregateReductionResult::extract_value` | Solve a target value, recover a source value |
-| Turing | Multiple target queries | Optimize by querying a decision problem at several bounds |
+```rust,ignore
+pub trait VariantParam: 'static {
+    const CATEGORY: &'static str;     // e.g., "graph", "weight", "k"
+    const VALUE: &'static str;        // e.g., "SimpleGraph", "i64"
+}
+```
+
+### Registration with `impl_variant_param!`
+
+The `impl_variant_param!` macro implements `VariantParam` and optionally
+`KValue` for a type:
+
+```rust,ignore
+impl_variant_param!(SimpleGraph, "graph");
+
+impl_variant_param!(KN, "k", k: None);
+
+impl_variant_param!(K3, "k", k: Some(3));
+```
+
+### Explicit variant reductions
+
+`impl_variant_reduction!` registers a concrete same-model conversion with an
+exact parameter transform and identity witness extraction:
+
+```rust,ignore
+impl_variant_reduction!(
+    MaximumIndependentSet,
+    <UnitDiskGraph, i64> => <SimpleGraph, i64>,
+    fields: [num_vertices, num_edges],
+    |src| MaximumIndependentSet::new(
+        SimpleGraph::new(
+            src.num_vertices(),
+            Graph::edges(src.graph()),
+        ),
+        src.weights().to_vec())
+);
+```
+
+### Composing `Problem::variant()`
 
-Graph search defaults to witness mode; `ReductionMode::Aggregate` and `ReductionMode::Turing` select the others. A witness reduction is registered with the `#[reduction]` attribute, whose `overhead` block is required:
+The `variant_params!` macro composes the `Problem::variant()` body from type parameter names:
 
 ```rust,ignore
-#[reduction(overhead = {
+// MaximumIndependentSet<G: VariantParam, W: VariantParam>
+fn variant() -> Vec<(&'static str, &'static str)> {
+    crate::variant_params![G, W]
+    // e.g., MaximumIndependentSet<UnitDiskGraph, One>
+    //     -> vec![("graph", "UnitDiskGraph"), ("weight", "One")]
+}
+```
+
+### Querying one variant family
+
+`ReductionGraph::variants_for(name)` returns every registered concrete variant
+of a problem. `ReductionGraph::outgoing_reductions(name)` returns their outgoing
+edges. Filtering those edges by `target_name == name` produces the directed
+relations within that variant family.
+
+</details>
+
+## Reduction Rules
+
+A reduction requires two pieces: a **result struct** and a **`ReduceTo<T>` impl**.
+
+The result struct holds the target problem and the logic to map solutions back:
+
+```rust,ignore
+#[derive(Debug, Clone)]
+pub struct ReductionISToVC<W> {
+    target: MinimumVertexCover<SimpleGraph, W>,
+}
+
+impl<W: WeightElement + VariantParam> ReductionResult for ReductionISToVC<W> {
+    type Source = MaximumIndependentSet<SimpleGraph, W>;
+    type Target = MinimumVertexCover<SimpleGraph, W>;
+
+    fn target_problem(&self) -> &Self::Target { &self.target }
+    fn extract_solution(
+        &self,
+        target_sol: &Vec<bool>,
+    ) -> crate::rules::ExtractionResult<Vec<bool>> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_sol)?;
+        Ok(target_sol.iter().map(|&x| !x).collect())
+    }
+}
+```
+
+### Solution extraction contract
+
+`ReductionResult::extract_solution` accepts one complete target configuration
+and returns the source configuration defined by the reduction. Extraction is a
+fallible boundary, not a recovery mechanism:
+
+1. In every direct extractor, call `validate_target_solution()` once before
+   indexing or decoding. Composed extractors delegate this check.
+2. Validate any structure required by the inverse mapping, such as exactly-one
+   blocks, permutations, paths, flows, or schedules.
+3. Apply the reduction's mathematical inverse once and return a source
+   configuration with the required length and domains.
+4. Return `ExtractionError` when a precondition is not satisfied.
+
+Do not truncate or pad input, substitute zero for missing data, select the
+first of several invalid candidates, retry with another mapping, or panic on
+caller-provided configuration data. Empty and singleton instances should flow
+through the same mathematical mapping unless the reduction itself has a
+genuine mathematical case distinction.
+
+Zero and sentinel values remain valid when the source model explicitly gives
+them meaning. For example, `MaximumCommonEdgeSubgraph` includes an "unmapped"
+sentinel in its source dimensions. Missing target data must never be
+interpreted as that sentinel.
+
+Each conditional in an extractor should therefore either reject a named
+invariant violation or implement a case in the reduction's mathematics. A
+normal extractor has one validation phase followed by one decoding phase; it
+does not accumulate compatibility or fallback branches.
+
+The `#[reduction]` attribute on the `ReduceTo<T>` impl registers the reduction in the global registry (via `inventory`):
+
+```rust,ignore
+#[reduction(transform = exact {
     num_vertices = "num_vertices",
     num_edges = "num_edges",
 })]
-impl ReduceTo<MinimumVertexCover<SimpleGraph, i32>>
-    for MaximumIndependentSet<SimpleGraph, i32>
+impl ReduceTo<MinimumVertexCover<SimpleGraph, i64>>
+    for MaximumIndependentSet<SimpleGraph, i64>
 {
-    // Provide Result and reduce_to(); the result owns the target
-    // and maps a vertex-cover witness to its independent-set complement.
+    type Result = ReductionISToVC<i64>;
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> { /* ... */ }
 }
 ```
 
-See a [complete implementation](https://github.com/CodingThrust/problem-reductions/blob/main/src/rules/maximumindependentset_minimumvertexcover.rs) for the result type. Aggregate and Turing edges use manual `ReductionEntry` registration. Keep one primitive registration per exact endpoint pair. Correctness needs a proof that construction and extraction preserve the required result; a closed-loop test on a small example is evidence, not proof.
+## Reduction Graph
+
+`ReductionGraph::new()` iterates all registered `ReductionEntry` items (via `inventory`) and builds a variant-level directed graph:
+
+- **Nodes** are unique `(problem_name, variant)` pairs — e.g., `("MaximumIndependentSet", {graph: "KingsSubgraph", weight: "i64"})`.
+- **Edges** come from explicit `#[reduction]` registrations, including
+  cross-problem and same-problem variant reductions.
+
+Exported files:
+
+- [reduction_graph.json](reductions/reduction_graph.json) — all problem variants and reduction edges
+- [problem_schemas.json](reductions/problem_schemas.json) — field definitions for each problem type
 
-## Path costs and overhead
+These JSON assets are generated during `make doc`, `make mdbook`, and `make paper`; they are build artifacts, not committed source files.
+Generate them manually with `cargo run --example export_graph` and `cargo run --example export_schemas` when you need the raw exports locally.
 
-`ReductionGraph` searches a directed graph of exact `(name, variant)` pairs. Registered reductions carry capabilities; natural variant connections follow the graph and weight subtype relations.
+### Path finding
 
-| Cost | Purpose |
-|---|---|
-| `MinimizeSteps` | Fewest reduction steps |
-| `Minimize("field")` | Cost based on an output size field |
-| `CustomCost(closure)` | User-defined edge cost from overhead and current size |
+All path-finding operates on **exact variant nodes**. Use `ReductionGraph::variant_to_map(&T::variant())` to convert a `Problem::variant()` into the required `BTreeMap<String, String>`.
 
-`find_cheapest_path` takes source and target variant maps, an input `ProblemSize`, and a cost; `find_all_paths` enumerates simple paths with a bound. Overhead expressions refer to getters on the source type and are validated at compile time. They describe scaling bounds, not exact target counts: for a concrete instance inspect the constructed target, and for a chain use `path_overheads` and `compose_path_overhead` for an end-to-end bound. A shorter route can produce a harder target, so compare target sizes and solver measurements as well as hop counts.
+| Method | Algorithm | Use case |
+|--------|-----------|----------|
+| `find_all_paths(src, src_var, dst, dst_var)` | All simple paths | Enumerate every route |
+| `compose_path_parameter_transform(path)` | Symbolic composition | Compose each rule's exact or upper-bound parameter relation while preserving its promise |
+
+A rule has one relation for all of its formulas: either an exact equality or an upper
+bound. Composition keeps exact formulas exact only when every step is exact; every other
+combination is an upper bound. Concrete-instance measurement remains a separate execution
+API.
+
+**Example:** Finding a path from `MIS{KingsSubgraph, i64}` to `VC{SimpleGraph, i64}`:
+
+```
+MIS{KingsSubgraph,i64} -> MIS{UnitDiskGraph,i64} -> MIS{SimpleGraph,i64} -> VC{SimpleGraph,i64}
+    variant reduction        variant reduction              reduction
+```
 
-## JSON serialization
+### Executable paths
+
+Execute an explicitly selected path with `ReductionGraph::reduce_along_path`:
+
+```rust,ignore
+let reduction = graph.reduce_along_path(rpath, &factoring_instance)?.unwrap();
+let target: &SpinGlass<SimpleGraph, f64> = reduction.target_problem();
+let source_solution = reduction.extract_solution(&target_solution)?;
+```
+
+The returned `ReductionChain` stores each intermediate reduction and extracts the source solution by applying the inverse mappings in reverse order. Construction returns `ReductionError`; extraction returns `ExtractionError`.
+
+<details>
+<summary>Parameter contracts</summary>
+
+Each reduction declares one relation for all represented target-parameter fields and may mark
+other fields unavailable with a reason. The `#[reduction]` macro parses every formula into
+the canonical `Expr` DAG at compile time:
+
+```rust,ignore
+#[reduction(
+transform = upper_bound {
+    num_vars = "num_vertices + num_edges",
+    num_clauses = "3 * num_edges",
+},
+unavailable = {
+    encoding_bits = "coefficient magnitudes are not tracked",
+},
+})]
+impl ReduceTo<Target> for Source { ... }
+```
+
+`ParameterTransform` uses exact rational and arbitrary-precision integer arithmetic. Exact
+relations must evaluate to non-negative integers, while upper-bound results round rational
+values upward. Missing fields, negative or non-integral exact results, division by zero,
+and explicit conversion outside `u64` are errors.
+
+Transforms can be evaluated with explicit source parameters:
+
+```
+Input:  ProblemParameters { num_vertices: 10, num_edges: 15 }
+Output: ProblemParameters { num_vars: 25 }
+```
+
+For multi-step paths, `compose_path_parameter_transform` substitutes each step into the next.
+When only upper bounds are known for the intermediate fields, a downstream polynomial is
+first fully expanded and like monomials are combined; terms with non-positive coefficients
+are then removed before substitution. For example, `m <= n^2` followed by `k = 10 - m`
+produces the sound bound `k <= 10`, while
+`e' = v(v - 1)/2 - e` produces `e' <= v^2/2`. A non-polynomial downstream formula cannot
+propagate symbolic upper bounds and reports an error. Projection to `Growth` is a separate descriptive terminal operation used for
+Big-O display; it does not rank or filter paths.
+
+</details>
+
+## Solvers
+
+The reference solver exposes a direct typed operation:
+
+```rust,ignore
+BruteForce::solve(&problem) -> Result<Option<P::Solution>, SolveError>
+```
+
+`Some(solution)` is a successful exact solve, `None` means exhaustive search
+proved infeasibility, and `Err` reports an operational failure.
+
+| Solver | Description |
+|--------|-------------|
+| **BruteForce** | Enumerates a registered finite search space and returns an optimal or satisfying solution. Used for testing and verification. |
+| **ILPSolver** | Executes a problem's registered ILP pipeline. Each pipeline terminates at `ILP<bool, f64>` or `ILP<i64, f64>`, which is solved by HiGHS via `good_lp`. |
+
+ILP results are optimal or infeasible according to HiGHS numerical tolerances;
+zero MIP gaps do not imply mathematical exactness. Integer extraction rounds
+variable assignments, validates the original constraints, and recomputes the
+source objective with checked integer arithmetic. Floating-point objective
+comparisons in numerical regression tests use an explicit acceptance policy
+in source units (absolute and relative tolerances of `1e-7` for the QUBO solver
+regression), separate from the `1e-6` variable-rounding tolerance. This test
+policy is not a universal bound on backend objective error.
+
+When an ILP target witness misses a source decision threshold, the solver
+returns `ILPSolveError::UnresolvedDecision`, not infeasibility: the witness
+alone cannot prove that no qualifying source solution exists.
+
+## JSON Serialization
+
+All problem types support JSON serialization via serde:
 
 ```rust,ignore
 use problemreductions::io::{to_json, from_json};
 
 let json: String = to_json(&problem)?;
-let restored: MaximumIndependentSet<SimpleGraph, i32> = from_json(&json)?;
+let restored: MaximumIndependentSet<SimpleGraph, i64> = from_json(&json)?;
 ```
 
-These helpers serialize typed problem data. The CLI additionally wraps data with `type` and `variant` for dynamic loading; keep that wrapper when passing files between commands.
-
 ## Contributing
 
-Propose a model or reduction through the `propose` [skill](skills.md) or the [issue templates](https://github.com/CodingThrust/problem-reductions/issues/new/choose). A useful rule includes exact endpoint variants, a construction, solution or value extraction, a correctness argument, and overhead metadata. The `add-model` and `add-rule` skills list the required code, tests, examples, and paper changes; `.claude/CLAUDE.md` holds the conventions.
+See [Call for Contributions](./open-problems.md) for the recommended issue-based workflow (no coding required).
diff --git a/docs/src/getting-started.md b/docs/src/getting-started.md
index 90f238f6d..872b4e900 100644
--- a/docs/src/getting-started.md
+++ b/docs/src/getting-started.md
@@ -4,7 +4,7 @@
 cargo add problemreductions
 ```
 
-HiGHS is enabled by default through the `ilp-highs` feature. Add `--no-default-features` to use the library without an ILP backend.
+The library includes the HiGHS ILP backend.
 
 ## Solve a small instance
 
@@ -12,16 +12,16 @@ HiGHS is enabled by default through the `ilp-highs` feature. Add `--no-default-f
 use problemreductions::prelude::*;
 
 fn main() {
-    let problem = MaximumSetPacking::<i32>::new(vec![
+    let problem = MaximumSetPacking::<i64>::new(vec![
         vec![0, 1], vec![1, 2], vec![2, 3], vec![4, 5],
     ]);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    println!("{:?}: {}", solution, problem.evaluate(&solution));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    println!("{:?}: {}", solution, problem.evaluate(&solution).unwrap());
 }
 ```
 
-The optimal packing selects sets 0, 2, and 3: the witness is `[1, 0, 1, 1]` and evaluates to `Max(3)`. `Problem::evaluate` scores a configuration; `BruteForce` enumerates the configuration space, so keep exhaustive examples small.
+The optimal packing selects sets 0, 2, and 3: the witness is `[true, false, true, true]` and evaluates to `Max(3)`. `Problem::evaluate` scores a configuration; `BruteForce` enumerates the configuration space, so keep exhaustive examples small.
 
 ## Apply a reduction
 
@@ -33,39 +33,35 @@ use problemreductions::models::algebraic::ILP;
 use problemreductions::solvers::ILPSolver;
 
 fn main() {
-    let problem = MaximumSetPacking::<i32>::new(vec![
+    let problem = MaximumSetPacking::<i64>::new(vec![
         vec![0, 1], vec![1, 2], vec![2, 3], vec![4, 5],
     ]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
     let target = reduction.target_problem();
     assert_eq!(target.num_vars(), 4);
     assert_eq!(target.num_constraints(), 2);
 
     let target_solution = ILPSolver::new().solve(target).unwrap();
-    let solution = reduction.extract_solution(&target_solution);
-    assert_eq!(solution, vec![1, 0, 1, 1]);
-    println!("{}", problem.evaluate(&solution)); // Max(3)
+    let solution = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(solution, vec![true, false, true, true]);
+    println!("{}", problem.evaluate(&solution).unwrap()); // Max(3)
 }
 ```
 
-The target has one binary variable per set and one constraint per overlapping pair. `extract_solution` maps a target witness back to the source configuration space. For any type implementing `ReduceTo<ILP<bool>>`, `ILPSolver::new().solve_reduced(&problem)` combines these steps and returns an optional source configuration.
+The target has one binary variable per set and a constraint for each element shared by multiple sets. `extract_solution` maps a target solution back to the source solution type. `ILPSolver::new().solve(&problem)` executes the exact variant’s registered ILP pipeline and returns its source solution.
 
 ## Discover and run a path
 
 Search uses exact variants. This discovers a route from `Factoring` to `SpinGlass` and executes it:
 
 ```rust,ignore
-use problemreductions::prelude::*;
-use problemreductions::rules::{MinimizeSteps, ReductionGraph};
-use problemreductions::topology::SimpleGraph;
-use problemreductions::types::ProblemSize;
+{{#include ../../examples/chained_reduction_factoring_to_spinglass.rs:imports}}
 {{#include ../../examples/chained_reduction_factoring_to_spinglass.rs:step1}}
+{{#include ../../examples/chained_reduction_factoring_to_spinglass.rs:step2}}
 
-let factoring = Factoring::new(2, 2, 6);
-let reduction = graph.reduce_along_path(&rpath, &factoring).unwrap();
+let reduction = graph.reduce_along_path(rpath, &factoring).unwrap().unwrap();
 let target: &SpinGlass<SimpleGraph, f64> = reduction.target_problem();
-// Solve `target` with a compatible solver, then recover source bits:
-// let source_config = reduction.extract_solution(&target_config);
+// Solve `target`, then call reduction.extract_solution(&target_solution).
 ```
 
 `extract_solution` walks the intermediate mappings in reverse. The full [example](https://github.com/CodingThrust/problem-reductions/blob/main/examples/chained_reduction_factoring_to_spinglass.rs) also solves factoring through a direct ILP reduction and checks that the recovered factors multiply to 6:
@@ -78,10 +74,7 @@ cargo run --example chained_reduction_factoring_to_spinglass
 
 | API | Result | Scope |
 |---|---|---|
-| `Solver::solve` with `BruteForce` | Aggregate value | Any problem whose value implements `Aggregate` |
-| `BruteForce::find_witness` | Optional configuration | Values supporting representative witnesses |
-| `ILPSolver::solve` | Optional ILP configuration | ILP instances; requires an ILP backend |
-| `ILPSolver::solve_reduced` | Optional source configuration | Problems implementing `ReduceTo<ILP<bool>>` |
-| `CustomizedSolver` | Model-specific exact solving | Selected models with specialized implementations |
+| `BruteForce::solve` | `Result<Option<P::Solution>, SolveError>` | Registered finite search spaces; `None` proves infeasibility |
+| `ILPSolver::solve` | `Result<P::Solution, ILPSolveError>` | Exact variants with registered ILP pipelines |
 
-Counting and other aggregate-only problems produce a value, not a representative configuration. For witness results, evaluate the recovered configuration against the source; for aggregate results, compare values through the reduction's extraction contract. Method signatures are in the [solver API](api/problemreductions/solvers/index.html).
+Every successful solve returns the problem's `Solution`. Evaluate it against the source with `Problem::evaluate`, which returns `Result<P::Value, EvaluationError>`. Path discovery enumerates routes; it does not rank them or register a solver capability. See the [solver API](api/problemreductions/solvers/index.html).
diff --git a/docs/src/static/cli-demo.cast b/docs/src/static/cli-demo.cast
index 0a10f372d..92ebaaf3b 100644
--- a/docs/src/static/cli-demo.cast
+++ b/docs/src/static/cli-demo.cast
@@ -20,232 +20,389 @@
 [0.899218, "o", "I"]
 [0.943438, "o", "L"]
 [0.977069, "o", "P"]
-[1.277069, "o", "\r\n"]
-[1.427069, "o", "Path (3 steps): \u001b[1mMaximumIndependentSet/SimpleGraph/One\u001b[0m \u001b[32m\u2192\u001b[39m \u001b[1mMaximumSetPacking/One\u001b[0m \u001b[32m\u2192\u001b[39m \u001b[1mILP/bool\u001b[0m\r\n\r\n  \u001b[36mStep 1\u001b[39m: \u001b[1mMaximumIndependentSet/SimpleGraph/One\u001b[0m \u001b[32m\u2192\u001b[39m \u001b[1mMaximumSetPacking/One\u001b[0m\r\n    num_sets = O(num_vertices)\r\n    universe_size = O(num_edges)\r\n\r\n  \u001b[36mStep 2\u001b[39m: \u001b[1mMaximumSetPacking/One\u001b[0m \u001b[32m\u2192\u001b[39m \u001b[1mMaximumSetPacking/i32\u001b[0m\r\n    num_sets = O(num_sets)\r\n    universe_size = O(universe_size)\r\n\r\n  \u001b[36mStep 3\u001b[39m: \u001b[1mMaximumSetPacking/i32\u001b[0m \u001b[32m\u2192\u001b[39m \u001b[1mILP/bool\u001b[0m\r\n    num_vars = O(num_sets)\r\n    num_constraints = O(universe_size)\r\n\r\n  \u001b[36mOverall\u001b[39m:\r\n    num_vars = O(num_vertices)\r\n    num_constraints = O(num_edges)\r\n"]
-[4.127069, "o", "\r\n"]
-[4.127069, "o", "\u001b[90m# Create a five-vertex cycle\u001b[0m\r\n"]
-[4.577069, "o", "$ "]
-[4.605546, "o", "."]
-[4.650582, "o", "/"]
-[4.669056, "o", "p"]
-[4.710726, "o", "r"]
-[4.736143, "o", "e"]
-[4.757408, "o", "d"]
-[4.777916, "o", " "]
-[4.803873, "o", "c"]
-[4.844334, "o", "r"]
-[4.86664, "o", "e"]
-[4.9004, "o", "a"]
-[4.935798, "o", "t"]
-[4.96358, "o", "e"]
-[4.996373, "o", " "]
-[5.01531, "o", "M"]
-[5.034156, "o", "I"]
-[5.057183, "o", "S"]
-[5.093766, "o", " "]
-[5.123126, "o", "-"]
-[5.149244, "o", "-"]
-[5.183117, "o", "g"]
-[5.213208, "o", "r"]
-[5.238916, "o", "a"]
-[5.278755, "o", "p"]
+[1.005546, "o", " "]
+[1.050582, "o", "-"]
+[1.069056, "o", "-"]
+[1.110726, "o", "j"]
+[1.136143, "o", "s"]
+[1.157408, "o", "o"]
+[1.177916, "o", "n"]
+[1.203873, "o", " "]
+[1.244334, "o", "-"]
+[1.26664, "o", "o"]
+[1.3004, "o", " "]
+[1.335798, "o", "p"]
+[1.36358, "o", "a"]
+[1.396373, "o", "t"]
+[1.41531, "o", "h"]
+[1.434156, "o", "s"]
+[1.457183, "o", "."]
+[1.493766, "o", "j"]
+[1.523126, "o", "s"]
+[1.549244, "o", "o"]
+[1.583117, "o", "n"]
+[1.883117, "o", "\r\n"]
+[2.033117, "o", "Wrote paths.json\r\n"]
+[4.733117, "o", "\r\n"]
+[4.733117, "o", "\u001b[90m# Select the first returned route\u001b[0m\r\n"]
+[5.183117, "o", "$ "]
+[5.213208, "o", "p"]
+[5.238916, "o", "y"]
+[5.278755, "o", "t"]
 [5.31587, "o", "h"]
-[5.339987, "o", " "]
-[5.373542, "o", "0"]
-[5.40569, "o", "-"]
-[5.447837, "o", "1"]
-[5.485821, "o", ","]
-[5.511191, "o", "1"]
-[5.556338, "o", "-"]
-[5.576855, "o", "2"]
-[5.605944, "o", ","]
-[5.644719, "o", "2"]
-[5.666205, "o", "-"]
-[5.697318, "o", "3"]
-[5.715581, "o", ","]
-[5.751816, "o", "3"]
-[5.790803, "o", "-"]
-[5.824318, "o", "4"]
-[5.866475, "o", ","]
-[5.892582, "o", "4"]
-[5.92959, "o", "-"]
-[5.963715, "o", "0"]
+[5.339987, "o", "o"]
+[5.373542, "o", "n"]
+[5.40569, "o", "3"]
+[5.447837, "o", " "]
+[5.485821, "o", "-"]
+[5.511191, "o", "c"]
+[5.556338, "o", " "]
+[5.576855, "o", "'"]
+[5.605944, "o", "i"]
+[5.644719, "o", "m"]
+[5.666205, "o", "p"]
+[5.697318, "o", "o"]
+[5.715581, "o", "r"]
+[5.751816, "o", "t"]
+[5.790803, "o", " "]
+[5.824318, "o", "j"]
+[5.866475, "o", "s"]
+[5.892582, "o", "o"]
+[5.92959, "o", "n"]
+[5.963715, "o", ";"]
 [5.997427, "o", " "]
-[6.027604, "o", "-"]
-[6.068746, "o", "o"]
-[6.11288, "o", " "]
-[6.143568, "o", "c"]
-[6.179687, "o", "y"]
-[6.198563, "o", "c"]
-[6.235748, "o", "l"]
-[6.271381, "o", "e"]
-[6.316898, "o", "."]
-[6.357524, "o", "j"]
-[6.382798, "o", "s"]
-[6.410964, "o", "o"]
-[6.447211, "o", "n"]
-[6.747211, "o", "\r\n"]
-[6.897211, "o", "Wrote cycle.json\r\n"]
-[9.597211, "o", "\r\n"]
-[9.597211, "o", "\u001b[90m# Transform the instance and preserve the way back\u001b[0m\r\n"]
-[10.047211, "o", "$ "]
-[10.064999, "o", "."]
-[10.095333, "o", "/"]
-[10.117277, "o", "p"]
-[10.137765, "o", "r"]
-[10.156593, "o", "e"]
-[10.195685, "o", "d"]
-[10.216523, "o", " "]
-[10.240741, "o", "r"]
-[10.269054, "o", "e"]
-[10.311094, "o", "d"]
-[10.33054, "o", "u"]
-[10.360516, "o", "c"]
-[10.393357, "o", "e"]
-[10.43574, "o", " "]
-[10.476291, "o", "c"]
-[10.518119, "o", "y"]
-[10.543217, "o", "c"]
-[10.572225, "o", "l"]
-[10.599618, "o", "e"]
-[10.642024, "o", "."]
-[10.686531, "o", "j"]
-[10.707985, "o", "s"]
-[10.730163, "o", "o"]
-[10.753933, "o", "n"]
-[10.777743, "o", " "]
-[10.808742, "o", "-"]
-[10.842717, "o", "-"]
-[10.867367, "o", "t"]
-[10.884627, "o", "o"]
-[10.913739, "o", " "]
-[10.941432, "o", "I"]
-[10.974756, "o", "L"]
-[11.019131, "o", "P"]
-[11.056002, "o", " "]
-[11.087873, "o", "-"]
-[11.122661, "o", "o"]
-[11.159124, "o", " "]
-[11.17781, "o", "r"]
-[11.220653, "o", "e"]
-[11.260081, "o", "d"]
-[11.30221, "o", "u"]
-[11.342149, "o", "c"]
-[11.370503, "o", "e"]
-[11.399045, "o", "d"]
-[11.419146, "o", "."]
-[11.454412, "o", "j"]
-[11.473333, "o", "s"]
-[11.4924, "o", "o"]
-[11.515508, "o", "n"]
-[11.815508, "o", "\r\n"]
-[11.965508, "o", "Wrote reduced.json\r\n"]
-[14.665508, "o", "\r\n"]
-[14.665508, "o", "\u001b[90m# Solve the target and recover a source solution\u001b[0m\r\n"]
-[15.115508, "o", "$ "]
-[15.137288, "o", "."]
-[15.164147, "o", "/"]
-[15.182792, "o", "p"]
-[15.199941, "o", "r"]
-[15.221406, "o", "e"]
-[15.241448, "o", "d"]
-[15.268979, "o", " "]
-[15.286851, "o", "s"]
-[15.328975, "o", "o"]
-[15.363662, "o", "l"]
-[15.385049, "o", "v"]
-[15.4094, "o", "e"]
-[15.436468, "o", " "]
-[15.464015, "o", "r"]
-[15.484668, "o", "e"]
-[15.526066, "o", "d"]
-[15.571583, "o", "u"]
-[15.60204, "o", "c"]
-[15.633007, "o", "e"]
-[15.652604, "o", "d"]
-[15.672666, "o", "."]
-[15.699599, "o", "j"]
-[15.724306, "o", "s"]
-[15.76513, "o", "o"]
-[15.786886, "o", "n"]
-[16.086886, "o", "\r\n"]
-[16.236886, "o", "Problem: MaximumIndependentSet\r\nSolver: ilp (via ILP)\r\nSolution: [1, 0, 1, 0, 0]\r\nEvaluation: Max(2)\r\n\r\nHint: use -o to save full solution details (including intermediate results) as JSON.\r\n"]
-[18.936886, "o", "\r\n"]
-[18.936886, "o", "\u001b[90m# Check an independent set of size two\u001b[0m\r\n"]
-[19.386886, "o", "$ "]
-[19.404689, "o", "."]
-[19.449002, "o", "/"]
-[19.481238, "o", "p"]
-[19.50257, "o", "r"]
-[19.535232, "o", "e"]
-[19.553147, "o", "d"]
-[19.585379, "o", " "]
-[19.630479, "o", "e"]
-[19.672288, "o", "v"]
-[19.709323, "o", "a"]
-[19.733926, "o", "l"]
-[19.761546, "o", "u"]
-[19.783461, "o", "a"]
-[19.82266, "o", "t"]
-[19.855019, "o", "e"]
-[19.894421, "o", " "]
-[19.920983, "o", "c"]
-[19.944498, "o", "y"]
-[19.984827, "o", "c"]
-[20.030111, "o", "l"]
-[20.071615, "o", "e"]
-[20.111788, "o", "."]
-[20.152312, "o", "j"]
-[20.190594, "o", "s"]
-[20.214215, "o", "o"]
-[20.246148, "o", "n"]
-[20.27345, "o", " "]
-[20.29142, "o", "-"]
-[20.309361, "o", "-"]
-[20.334488, "o", "c"]
-[20.359036, "o", "o"]
-[20.395965, "o", "n"]
-[20.440437, "o", "f"]
-[20.470357, "o", "i"]
-[20.514272, "o", "g"]
-[20.559645, "o", " "]
-[20.604073, "o", "1"]
-[20.631634, "o", ","]
-[20.655076, "o", "0"]
-[20.6787, "o", ","]
-[20.701463, "o", "1"]
-[20.724445, "o", ","]
-[20.759419, "o", "0"]
-[20.802285, "o", ","]
-[20.84344, "o", "0"]
-[21.14344, "o", "\r\n"]
-[21.29344, "o", "Max(2)\r\n"]
-[23.99344, "o", "\r\n"]
-[23.99344, "o", "\u001b[90m# Solve the original instance with the default solver\u001b[0m\r\n"]
-[24.44344, "o", "$ "]
-[24.474282, "o", "."]
-[24.510082, "o", "/"]
-[24.550071, "o", "p"]
-[24.569636, "o", "r"]
-[24.605653, "o", "e"]
-[24.64879, "o", "d"]
-[24.688284, "o", " "]
-[24.726859, "o", "s"]
-[24.75766, "o", "o"]
-[24.779904, "o", "l"]
-[24.819593, "o", "v"]
-[24.846237, "o", "e"]
-[24.88626, "o", " "]
-[24.931165, "o", "c"]
-[24.959617, "o", "y"]
-[24.988228, "o", "c"]
-[25.032423, "o", "l"]
-[25.070274, "o", "e"]
-[25.092274, "o", "."]
-[25.113047, "o", "j"]
-[25.134508, "o", "s"]
-[25.177504, "o", "o"]
-[25.21769, "o", "n"]
-[25.51769, "o", "\r\n"]
-[25.66769, "o", "Problem: MaximumIndependentSet\r\nSolver: ilp (via ILP)\r\nSolution: [1, 0, 1, 0, 0]\r\nEvaluation: Max(2)\r\n\r\nHint: use -o to save full solution details as JSON.\r\n"]
-[28.36769, "o", "$ "]
+[6.027604, "o", "j"]
+[6.068746, "o", "s"]
+[6.11288, "o", "o"]
+[6.143568, "o", "n"]
+[6.179687, "o", "."]
+[6.198563, "o", "d"]
+[6.235748, "o", "u"]
+[6.271381, "o", "m"]
+[6.316898, "o", "p"]
+[6.357524, "o", "("]
+[6.382798, "o", "j"]
+[6.410964, "o", "s"]
+[6.447211, "o", "o"]
+[6.464999, "o", "n"]
+[6.495333, "o", "."]
+[6.517277, "o", "l"]
+[6.537765, "o", "o"]
+[6.556593, "o", "a"]
+[6.595685, "o", "d"]
+[6.616523, "o", "("]
+[6.640741, "o", "o"]
+[6.669054, "o", "p"]
+[6.711094, "o", "e"]
+[6.73054, "o", "n"]
+[6.760516, "o", "("]
+[6.793357, "o", "\""]
+[6.83574, "o", "p"]
+[6.876291, "o", "a"]
+[6.918119, "o", "t"]
+[6.943217, "o", "h"]
+[6.972225, "o", "s"]
+[6.999618, "o", "."]
+[7.042024, "o", "j"]
+[7.086531, "o", "s"]
+[7.107985, "o", "o"]
+[7.130163, "o", "n"]
+[7.153933, "o", "\""]
+[7.177743, "o", ")"]
+[7.208742, "o", ")"]
+[7.242717, "o", "["]
+[7.267367, "o", "\""]
+[7.284627, "o", "p"]
+[7.313739, "o", "a"]
+[7.341432, "o", "t"]
+[7.374756, "o", "h"]
+[7.419131, "o", "s"]
+[7.456002, "o", "\""]
+[7.487873, "o", "]"]
+[7.522661, "o", "["]
+[7.559124, "o", "0"]
+[7.57781, "o", "]"]
+[7.620653, "o", ","]
+[7.660081, "o", " "]
+[7.70221, "o", "o"]
+[7.742149, "o", "p"]
+[7.770503, "o", "e"]
+[7.799045, "o", "n"]
+[7.819146, "o", "("]
+[7.854412, "o", "\""]
+[7.873333, "o", "p"]
+[7.8924, "o", "a"]
+[7.915508, "o", "t"]
+[7.937288, "o", "h"]
+[7.964147, "o", "."]
+[7.982792, "o", "j"]
+[7.999941, "o", "s"]
+[8.021406, "o", "o"]
+[8.041448, "o", "n"]
+[8.068979, "o", "\""]
+[8.086851, "o", ","]
+[8.128975, "o", " "]
+[8.163662, "o", "\""]
+[8.185049, "o", "w"]
+[8.2094, "o", "\""]
+[8.236468, "o", ")"]
+[8.264015, "o", ")"]
+[8.284668, "o", "'"]
+[8.584668, "o", "\r\n"]
+[8.734668, "o", "\r\n"]
+[11.434668, "o", "\r\n"]
+[11.434668, "o", "\u001b[90m# Create a five-vertex cycle\u001b[0m\r\n"]
+[11.884668, "o", "$ "]
+[11.926066, "o", "."]
+[11.971583, "o", "/"]
+[12.00204, "o", "p"]
+[12.033007, "o", "r"]
+[12.052604, "o", "e"]
+[12.072666, "o", "d"]
+[12.099599, "o", " "]
+[12.124306, "o", "c"]
+[12.16513, "o", "r"]
+[12.186886, "o", "e"]
+[12.204689, "o", "a"]
+[12.249002, "o", "t"]
+[12.281238, "o", "e"]
+[12.30257, "o", " "]
+[12.335232, "o", "M"]
+[12.353147, "o", "I"]
+[12.385379, "o", "S"]
+[12.430479, "o", " "]
+[12.472288, "o", "-"]
+[12.509323, "o", "-"]
+[12.533926, "o", "g"]
+[12.561546, "o", "r"]
+[12.583461, "o", "a"]
+[12.62266, "o", "p"]
+[12.655019, "o", "h"]
+[12.694421, "o", " "]
+[12.720983, "o", "0"]
+[12.744498, "o", "-"]
+[12.784827, "o", "1"]
+[12.830111, "o", ","]
+[12.871615, "o", "1"]
+[12.911788, "o", "-"]
+[12.952312, "o", "2"]
+[12.990594, "o", ","]
+[13.014215, "o", "2"]
+[13.046148, "o", "-"]
+[13.07345, "o", "3"]
+[13.09142, "o", ","]
+[13.109361, "o", "3"]
+[13.134488, "o", "-"]
+[13.159036, "o", "4"]
+[13.195965, "o", ","]
+[13.240437, "o", "4"]
+[13.270357, "o", "-"]
+[13.314272, "o", "0"]
+[13.359645, "o", " "]
+[13.404073, "o", "-"]
+[13.431634, "o", "o"]
+[13.455076, "o", " "]
+[13.4787, "o", "c"]
+[13.501463, "o", "y"]
+[13.524445, "o", "c"]
+[13.559419, "o", "l"]
+[13.602285, "o", "e"]
+[13.64344, "o", "."]
+[13.674282, "o", "j"]
+[13.710082, "o", "s"]
+[13.750071, "o", "o"]
+[13.769636, "o", "n"]
+[14.069636, "o", "\r\n"]
+[14.219636, "o", "Wrote cycle.json\r\n"]
+[16.919636, "o", "\r\n"]
+[16.919636, "o", "\u001b[90m# Transform the instance and preserve the way back\u001b[0m\r\n"]
+[17.369636, "o", "$ "]
+[17.405653, "o", "."]
+[17.44879, "o", "/"]
+[17.488284, "o", "p"]
+[17.526859, "o", "r"]
+[17.55766, "o", "e"]
+[17.579904, "o", "d"]
+[17.619593, "o", " "]
+[17.646237, "o", "r"]
+[17.68626, "o", "e"]
+[17.731165, "o", "d"]
+[17.759617, "o", "u"]
+[17.788228, "o", "c"]
+[17.832423, "o", "e"]
+[17.870274, "o", " "]
+[17.892274, "o", "c"]
+[17.913047, "o", "y"]
+[17.934508, "o", "c"]
+[17.977504, "o", "l"]
+[18.01769, "o", "e"]
+[18.039009, "o", "."]
+[18.079766, "o", "j"]
+[18.124918, "o", "s"]
+[18.16084, "o", "o"]
+[18.187994, "o", "n"]
+[18.220813, "o", " "]
+[18.241699, "o", "-"]
+[18.259248, "o", "-"]
+[18.304131, "o", "v"]
+[18.339836, "o", "i"]
+[18.372024, "o", "a"]
+[18.415842, "o", " "]
+[18.445379, "o", "p"]
+[18.487429, "o", "a"]
+[18.528176, "o", "t"]
+[18.551349, "o", "h"]
+[18.575687, "o", "."]
+[18.6012, "o", "j"]
+[18.625216, "o", "s"]
+[18.659114, "o", "o"]
+[18.683667, "o", "n"]
+[18.712782, "o", " "]
+[18.73367, "o", "-"]
+[18.776813, "o", "o"]
+[18.804064, "o", " "]
+[18.834297, "o", "r"]
+[18.868107, "o", "e"]
+[18.911087, "o", "d"]
+[18.940248, "o", "u"]
+[18.983611, "o", "c"]
+[19.015087, "o", "e"]
+[19.047425, "o", "d"]
+[19.079525, "o", "."]
+[19.097202, "o", "j"]
+[19.12692, "o", "s"]
+[19.149295, "o", "o"]
+[19.16655, "o", "n"]
+[19.46655, "o", "\r\n"]
+[19.61655, "o", "Wrote reduced.json\r\n"]
+[22.31655, "o", "\r\n"]
+[22.31655, "o", "\u001b[90m# Solve the target and recover a source solution\u001b[0m\r\n"]
+[22.76655, "o", "$ "]
+[22.806526, "o", "."]
+[22.828593, "o", "/"]
+[22.859265, "o", "p"]
+[22.897127, "o", "r"]
+[22.930169, "o", "e"]
+[22.956626, "o", "d"]
+[22.988579, "o", " "]
+[23.021591, "o", "s"]
+[23.061142, "o", "o"]
+[23.081317, "o", "l"]
+[23.114468, "o", "v"]
+[23.138711, "o", "e"]
+[23.163765, "o", " "]
+[23.202973, "o", "r"]
+[23.234622, "o", "e"]
+[23.267814, "o", "d"]
+[23.306671, "o", "u"]
+[23.349885, "o", "c"]
+[23.379692, "o", "e"]
+[23.414336, "o", "d"]
+[23.445923, "o", "."]
+[23.477699, "o", "j"]
+[23.514634, "o", "s"]
+[23.544701, "o", "o"]
+[23.577081, "o", "n"]
+[23.877081, "o", "\r\n"]
+[24.027081, "o", "Problem: MaximumIndependentSet\r\nSolver: ilp (ILP<i64, bool> -> ILP<f64, bool>) (via ILP)\r\nStatus: optimal\r\nSolution: Array [Bool(true), Bool(false), Bool(false), Bool(true), Bool(false)]\r\nEvaluation: Max(2)\r\n\r\nHint: use -o to save full solution details (including intermediate results) as JSON.\r\n"]
+[26.727081, "o", "\r\n"]
+[26.727081, "o", "\u001b[90m# Check an independent set of size two\u001b[0m\r\n"]
+[27.177081, "o", "$ "]
+[27.207882, "o", "."]
+[27.251925, "o", "/"]
+[27.289045, "o", "p"]
+[27.331232, "o", "r"]
+[27.375294, "o", "e"]
+[27.399854, "o", "d"]
+[27.432983, "o", " "]
+[27.477076, "o", "e"]
+[27.518219, "o", "v"]
+[27.53928, "o", "a"]
+[27.559898, "o", "l"]
+[27.589673, "o", "u"]
+[27.608888, "o", "a"]
+[27.632907, "o", "t"]
+[27.652139, "o", "e"]
+[27.688409, "o", " "]
+[27.72795, "o", "c"]
+[27.770722, "o", "y"]
+[27.792278, "o", "c"]
+[27.829882, "o", "l"]
+[27.865889, "o", "e"]
+[27.887117, "o", "."]
+[27.929483, "o", "j"]
+[27.97427, "o", "s"]
+[27.997687, "o", "o"]
+[28.042045, "o", "n"]
+[28.070566, "o", " "]
+[28.101631, "o", "-"]
+[28.147056, "o", "-"]
+[28.187983, "o", "c"]
+[28.209739, "o", "o"]
+[28.239211, "o", "n"]
+[28.271085, "o", "f"]
+[28.297917, "o", "i"]
+[28.320653, "o", "g"]
+[28.346896, "o", " "]
+[28.384672, "o", "'"]
+[28.402372, "o", "["]
+[28.435344, "o", "t"]
+[28.465072, "o", "r"]
+[28.482731, "o", "u"]
+[28.509346, "o", "e"]
+[28.544315, "o", ","]
+[28.576094, "o", "f"]
+[28.595074, "o", "a"]
+[28.640362, "o", "l"]
+[28.680029, "o", "s"]
+[28.724935, "o", "e"]
+[28.745071, "o", ","]
+[28.769802, "o", "t"]
+[28.788076, "o", "r"]
+[28.827476, "o", "u"]
+[28.852345, "o", "e"]
+[28.87319, "o", ","]
+[28.902397, "o", "f"]
+[28.94558, "o", "a"]
+[28.986123, "o", "l"]
+[29.010654, "o", "s"]
+[29.032065, "o", "e"]
+[29.07547, "o", ","]
+[29.108915, "o", "f"]
+[29.14607, "o", "a"]
+[29.165769, "o", "l"]
+[29.184556, "o", "s"]
+[29.221361, "o", "e"]
+[29.250656, "o", "]"]
+[29.269868, "o", "'"]
+[29.569868, "o", "\r\n"]
+[29.719868, "o", "Max(2)\r\n"]
+[32.419868, "o", "\r\n"]
+[32.419868, "o", "\u001b[90m# Solve the original instance with the default solver\u001b[0m\r\n"]
+[32.869868, "o", "$ "]
+[32.913821, "o", "."]
+[32.949091, "o", "/"]
+[32.989137, "o", "p"]
+[33.008673, "o", "r"]
+[33.050279, "o", "e"]
+[33.069325, "o", "d"]
+[33.111119, "o", " "]
+[33.141227, "o", "s"]
+[33.16806, "o", "o"]
+[33.201004, "o", "l"]
+[33.244624, "o", "v"]
+[33.26942, "o", "e"]
+[33.290255, "o", " "]
+[33.322452, "o", "c"]
+[33.346407, "o", "y"]
+[33.366678, "o", "c"]
+[33.388433, "o", "l"]
+[33.407015, "o", "e"]
+[33.429923, "o", "."]
+[33.45598, "o", "j"]
+[33.481837, "o", "s"]
+[33.52068, "o", "o"]
+[33.546108, "o", "n"]
+[33.846108, "o", "\r\n"]
+[33.996108, "o", "Problem: MaximumIndependentSet\r\nSolver: ilp (MaximumIndependentSet<SimpleGraph, One> -> MaximumIndependentSet<SimpleGraph, i64> -> MaximumSetPacking<i64> -> ILP<i64, bool> -> ILP<f64, bool>)\r\nStatus: optimal\r\nSolution: Array [Bool(true), Bool(false), Bool(false), Bool(true), Bool(false)]\r\nEvaluation: Max(2)\r\n\r\nHint: use -o to save full solution details as JSON.\r\n"]
+[36.696108, "o", "$ "]
diff --git a/docs/src/static/cli-demo.html b/docs/src/static/cli-demo.html
index 185580188..129dc6d66 100644
--- a/docs/src/static/cli-demo.html
+++ b/docs/src/static/cli-demo.html
@@ -2396,7 +2396,7 @@ <h1>From a graph to a verified solution</h1>
 
 </script>
 <script>
-  var castData = "{\"version\": 2, \"width\": 88, \"height\": 22, \"title\": \"From a graph to a verified solution\", \"env\": {\"TERM\": \"xterm-256color\", \"SHELL\": \"/bin/bash\"}}\n[0.0, \"o\", \"\\u001b[90m# Discover a route to an available solver\\u001b[0m\\r\\n\"]\n[0.45, \"o\", \"$ \"]\n[0.476395, \"o\", \".\"]\n[0.497848, \"o\", \"/\"]\n[0.533589, \"o\", \"p\"]\n[0.552802, \"o\", \"r\"]\n[0.585255, \"o\", \"e\"]\n[0.612846, \"o\", \"d\"]\n[0.631646, \"o\", \" \"]\n[0.663287, \"o\", \"p\"]\n[0.681502, \"o\", \"a\"]\n[0.711034, \"o\", \"t\"]\n[0.730173, \"o\", \"h\"]\n[0.749908, \"o\", \" \"]\n[0.77918, \"o\", \"M\"]\n[0.819947, \"o\", \"I\"]\n[0.840627, \"o\", \"S\"]\n[0.864148, \"o\", \" \"]\n[0.899218, \"o\", \"I\"]\n[0.943438, \"o\", \"L\"]\n[0.977069, \"o\", \"P\"]\n[1.277069, \"o\", \"\\r\\n\"]\n[1.427069, \"o\", \"Path (3 steps): \\u001b[1mMaximumIndependentSet/SimpleGraph/One\\u001b[0m \\u001b[32m\\u2192\\u001b[39m \\u001b[1mMaximumSetPacking/One\\u001b[0m \\u001b[32m\\u2192\\u001b[39m \\u001b[1mILP/bool\\u001b[0m\\r\\n\\r\\n  \\u001b[36mStep 1\\u001b[39m: \\u001b[1mMaximumIndependentSet/SimpleGraph/One\\u001b[0m \\u001b[32m\\u2192\\u001b[39m \\u001b[1mMaximumSetPacking/One\\u001b[0m\\r\\n    num_sets = O(num_vertices)\\r\\n    universe_size = O(num_edges)\\r\\n\\r\\n  \\u001b[36mStep 2\\u001b[39m: \\u001b[1mMaximumSetPacking/One\\u001b[0m \\u001b[32m\\u2192\\u001b[39m \\u001b[1mMaximumSetPacking/i32\\u001b[0m\\r\\n    num_sets = O(num_sets)\\r\\n    universe_size = O(universe_size)\\r\\n\\r\\n  \\u001b[36mStep 3\\u001b[39m: \\u001b[1mMaximumSetPacking/i32\\u001b[0m \\u001b[32m\\u2192\\u001b[39m \\u001b[1mILP/bool\\u001b[0m\\r\\n    num_vars = O(num_sets)\\r\\n    num_constraints = O(universe_size)\\r\\n\\r\\n  \\u001b[36mOverall\\u001b[39m:\\r\\n    num_vars = O(num_vertices)\\r\\n    num_constraints = O(num_edges)\\r\\n\"]\n[4.127069, \"o\", \"\\r\\n\"]\n[4.127069, \"o\", \"\\u001b[90m# Create a five-vertex cycle\\u001b[0m\\r\\n\"]\n[4.577069, \"o\", \"$ \"]\n[4.605546, \"o\", \".\"]\n[4.650582, \"o\", \"/\"]\n[4.669056, \"o\", \"p\"]\n[4.710726, \"o\", \"r\"]\n[4.736143, \"o\", \"e\"]\n[4.757408, \"o\", \"d\"]\n[4.777916, \"o\", \" \"]\n[4.803873, \"o\", \"c\"]\n[4.844334, \"o\", \"r\"]\n[4.86664, \"o\", \"e\"]\n[4.9004, \"o\", \"a\"]\n[4.935798, \"o\", \"t\"]\n[4.96358, \"o\", \"e\"]\n[4.996373, \"o\", \" \"]\n[5.01531, \"o\", \"M\"]\n[5.034156, \"o\", \"I\"]\n[5.057183, \"o\", \"S\"]\n[5.093766, \"o\", \" \"]\n[5.123126, \"o\", \"-\"]\n[5.149244, \"o\", \"-\"]\n[5.183117, \"o\", \"g\"]\n[5.213208, \"o\", \"r\"]\n[5.238916, \"o\", \"a\"]\n[5.278755, \"o\", \"p\"]\n[5.31587, \"o\", \"h\"]\n[5.339987, \"o\", \" \"]\n[5.373542, \"o\", \"0\"]\n[5.40569, \"o\", \"-\"]\n[5.447837, \"o\", \"1\"]\n[5.485821, \"o\", \",\"]\n[5.511191, \"o\", \"1\"]\n[5.556338, \"o\", \"-\"]\n[5.576855, \"o\", \"2\"]\n[5.605944, \"o\", \",\"]\n[5.644719, \"o\", \"2\"]\n[5.666205, \"o\", \"-\"]\n[5.697318, \"o\", \"3\"]\n[5.715581, \"o\", \",\"]\n[5.751816, \"o\", \"3\"]\n[5.790803, \"o\", \"-\"]\n[5.824318, \"o\", \"4\"]\n[5.866475, \"o\", \",\"]\n[5.892582, \"o\", \"4\"]\n[5.92959, \"o\", \"-\"]\n[5.963715, \"o\", \"0\"]\n[5.997427, \"o\", \" \"]\n[6.027604, \"o\", \"-\"]\n[6.068746, \"o\", \"o\"]\n[6.11288, \"o\", \" \"]\n[6.143568, \"o\", \"c\"]\n[6.179687, \"o\", \"y\"]\n[6.198563, \"o\", \"c\"]\n[6.235748, \"o\", \"l\"]\n[6.271381, \"o\", \"e\"]\n[6.316898, \"o\", \".\"]\n[6.357524, \"o\", \"j\"]\n[6.382798, \"o\", \"s\"]\n[6.410964, \"o\", \"o\"]\n[6.447211, \"o\", \"n\"]\n[6.747211, \"o\", \"\\r\\n\"]\n[6.897211, \"o\", \"Wrote cycle.json\\r\\n\"]\n[9.597211, \"o\", \"\\r\\n\"]\n[9.597211, \"o\", \"\\u001b[90m# Transform the instance and preserve the way back\\u001b[0m\\r\\n\"]\n[10.047211, \"o\", \"$ \"]\n[10.064999, \"o\", \".\"]\n[10.095333, \"o\", \"/\"]\n[10.117277, \"o\", \"p\"]\n[10.137765, \"o\", \"r\"]\n[10.156593, \"o\", \"e\"]\n[10.195685, \"o\", \"d\"]\n[10.216523, \"o\", \" \"]\n[10.240741, \"o\", \"r\"]\n[10.269054, \"o\", \"e\"]\n[10.311094, \"o\", \"d\"]\n[10.33054, \"o\", \"u\"]\n[10.360516, \"o\", \"c\"]\n[10.393357, \"o\", \"e\"]\n[10.43574, \"o\", \" \"]\n[10.476291, \"o\", \"c\"]\n[10.518119, \"o\", \"y\"]\n[10.543217, \"o\", \"c\"]\n[10.572225, \"o\", \"l\"]\n[10.599618, \"o\", \"e\"]\n[10.642024, \"o\", \".\"]\n[10.686531, \"o\", \"j\"]\n[10.707985, \"o\", \"s\"]\n[10.730163, \"o\", \"o\"]\n[10.753933, \"o\", \"n\"]\n[10.777743, \"o\", \" \"]\n[10.808742, \"o\", \"-\"]\n[10.842717, \"o\", \"-\"]\n[10.867367, \"o\", \"t\"]\n[10.884627, \"o\", \"o\"]\n[10.913739, \"o\", \" \"]\n[10.941432, \"o\", \"I\"]\n[10.974756, \"o\", \"L\"]\n[11.019131, \"o\", \"P\"]\n[11.056002, \"o\", \" \"]\n[11.087873, \"o\", \"-\"]\n[11.122661, \"o\", \"o\"]\n[11.159124, \"o\", \" \"]\n[11.17781, \"o\", \"r\"]\n[11.220653, \"o\", \"e\"]\n[11.260081, \"o\", \"d\"]\n[11.30221, \"o\", \"u\"]\n[11.342149, \"o\", \"c\"]\n[11.370503, \"o\", \"e\"]\n[11.399045, \"o\", \"d\"]\n[11.419146, \"o\", \".\"]\n[11.454412, \"o\", \"j\"]\n[11.473333, \"o\", \"s\"]\n[11.4924, \"o\", \"o\"]\n[11.515508, \"o\", \"n\"]\n[11.815508, \"o\", \"\\r\\n\"]\n[11.965508, \"o\", \"Wrote reduced.json\\r\\n\"]\n[14.665508, \"o\", \"\\r\\n\"]\n[14.665508, \"o\", \"\\u001b[90m# Solve the target and recover a source solution\\u001b[0m\\r\\n\"]\n[15.115508, \"o\", \"$ \"]\n[15.137288, \"o\", \".\"]\n[15.164147, \"o\", \"/\"]\n[15.182792, \"o\", \"p\"]\n[15.199941, \"o\", \"r\"]\n[15.221406, \"o\", \"e\"]\n[15.241448, \"o\", \"d\"]\n[15.268979, \"o\", \" \"]\n[15.286851, \"o\", \"s\"]\n[15.328975, \"o\", \"o\"]\n[15.363662, \"o\", \"l\"]\n[15.385049, \"o\", \"v\"]\n[15.4094, \"o\", \"e\"]\n[15.436468, \"o\", \" \"]\n[15.464015, \"o\", \"r\"]\n[15.484668, \"o\", \"e\"]\n[15.526066, \"o\", \"d\"]\n[15.571583, \"o\", \"u\"]\n[15.60204, \"o\", \"c\"]\n[15.633007, \"o\", \"e\"]\n[15.652604, \"o\", \"d\"]\n[15.672666, \"o\", \".\"]\n[15.699599, \"o\", \"j\"]\n[15.724306, \"o\", \"s\"]\n[15.76513, \"o\", \"o\"]\n[15.786886, \"o\", \"n\"]\n[16.086886, \"o\", \"\\r\\n\"]\n[16.236886, \"o\", \"Problem: MaximumIndependentSet\\r\\nSolver: ilp (via ILP)\\r\\nSolution: [1, 0, 1, 0, 0]\\r\\nEvaluation: Max(2)\\r\\n\\r\\nHint: use -o to save full solution details (including intermediate results) as JSON.\\r\\n\"]\n[18.936886, \"o\", \"\\r\\n\"]\n[18.936886, \"o\", \"\\u001b[90m# Check an independent set of size two\\u001b[0m\\r\\n\"]\n[19.386886, \"o\", \"$ \"]\n[19.404689, \"o\", \".\"]\n[19.449002, \"o\", \"/\"]\n[19.481238, \"o\", \"p\"]\n[19.50257, \"o\", \"r\"]\n[19.535232, \"o\", \"e\"]\n[19.553147, \"o\", \"d\"]\n[19.585379, \"o\", \" \"]\n[19.630479, \"o\", \"e\"]\n[19.672288, \"o\", \"v\"]\n[19.709323, \"o\", \"a\"]\n[19.733926, \"o\", \"l\"]\n[19.761546, \"o\", \"u\"]\n[19.783461, \"o\", \"a\"]\n[19.82266, \"o\", \"t\"]\n[19.855019, \"o\", \"e\"]\n[19.894421, \"o\", \" \"]\n[19.920983, \"o\", \"c\"]\n[19.944498, \"o\", \"y\"]\n[19.984827, \"o\", \"c\"]\n[20.030111, \"o\", \"l\"]\n[20.071615, \"o\", \"e\"]\n[20.111788, \"o\", \".\"]\n[20.152312, \"o\", \"j\"]\n[20.190594, \"o\", \"s\"]\n[20.214215, \"o\", \"o\"]\n[20.246148, \"o\", \"n\"]\n[20.27345, \"o\", \" \"]\n[20.29142, \"o\", \"-\"]\n[20.309361, \"o\", \"-\"]\n[20.334488, \"o\", \"c\"]\n[20.359036, \"o\", \"o\"]\n[20.395965, \"o\", \"n\"]\n[20.440437, \"o\", \"f\"]\n[20.470357, \"o\", \"i\"]\n[20.514272, \"o\", \"g\"]\n[20.559645, \"o\", \" \"]\n[20.604073, \"o\", \"1\"]\n[20.631634, \"o\", \",\"]\n[20.655076, \"o\", \"0\"]\n[20.6787, \"o\", \",\"]\n[20.701463, \"o\", \"1\"]\n[20.724445, \"o\", \",\"]\n[20.759419, \"o\", \"0\"]\n[20.802285, \"o\", \",\"]\n[20.84344, \"o\", \"0\"]\n[21.14344, \"o\", \"\\r\\n\"]\n[21.29344, \"o\", \"Max(2)\\r\\n\"]\n[23.99344, \"o\", \"\\r\\n\"]\n[23.99344, \"o\", \"\\u001b[90m# Solve the original instance with the default solver\\u001b[0m\\r\\n\"]\n[24.44344, \"o\", \"$ \"]\n[24.474282, \"o\", \".\"]\n[24.510082, \"o\", \"/\"]\n[24.550071, \"o\", \"p\"]\n[24.569636, \"o\", \"r\"]\n[24.605653, \"o\", \"e\"]\n[24.64879, \"o\", \"d\"]\n[24.688284, \"o\", \" \"]\n[24.726859, \"o\", \"s\"]\n[24.75766, \"o\", \"o\"]\n[24.779904, \"o\", \"l\"]\n[24.819593, \"o\", \"v\"]\n[24.846237, \"o\", \"e\"]\n[24.88626, \"o\", \" \"]\n[24.931165, \"o\", \"c\"]\n[24.959617, \"o\", \"y\"]\n[24.988228, \"o\", \"c\"]\n[25.032423, \"o\", \"l\"]\n[25.070274, \"o\", \"e\"]\n[25.092274, \"o\", \".\"]\n[25.113047, \"o\", \"j\"]\n[25.134508, \"o\", \"s\"]\n[25.177504, \"o\", \"o\"]\n[25.21769, \"o\", \"n\"]\n[25.51769, \"o\", \"\\r\\n\"]\n[25.66769, \"o\", \"Problem: MaximumIndependentSet\\r\\nSolver: ilp (via ILP)\\r\\nSolution: [1, 0, 1, 0, 0]\\r\\nEvaluation: Max(2)\\r\\n\\r\\nHint: use -o to save full solution details as JSON.\\r\\n\"]\n[28.36769, \"o\", \"$ \"]\n";
+  var castData = "{\"version\": 2, \"width\": 88, \"height\": 22, \"title\": \"From a graph to a verified solution\", \"env\": {\"TERM\": \"xterm-256color\", \"SHELL\": \"/bin/bash\"}}\n[0.0, \"o\", \"\\u001b[90m# Discover a route to an available solver\\u001b[0m\\r\\n\"]\n[0.45, \"o\", \"$ \"]\n[0.476395, \"o\", \".\"]\n[0.497848, \"o\", \"/\"]\n[0.533589, \"o\", \"p\"]\n[0.552802, \"o\", \"r\"]\n[0.585255, \"o\", \"e\"]\n[0.612846, \"o\", \"d\"]\n[0.631646, \"o\", \" \"]\n[0.663287, \"o\", \"p\"]\n[0.681502, \"o\", \"a\"]\n[0.711034, \"o\", \"t\"]\n[0.730173, \"o\", \"h\"]\n[0.749908, \"o\", \" \"]\n[0.77918, \"o\", \"M\"]\n[0.819947, \"o\", \"I\"]\n[0.840627, \"o\", \"S\"]\n[0.864148, \"o\", \" \"]\n[0.899218, \"o\", \"I\"]\n[0.943438, \"o\", \"L\"]\n[0.977069, \"o\", \"P\"]\n[1.005546, \"o\", \" \"]\n[1.050582, \"o\", \"-\"]\n[1.069056, \"o\", \"-\"]\n[1.110726, \"o\", \"j\"]\n[1.136143, \"o\", \"s\"]\n[1.157408, \"o\", \"o\"]\n[1.177916, \"o\", \"n\"]\n[1.203873, \"o\", \" \"]\n[1.244334, \"o\", \"-\"]\n[1.26664, \"o\", \"o\"]\n[1.3004, \"o\", \" \"]\n[1.335798, \"o\", \"p\"]\n[1.36358, \"o\", \"a\"]\n[1.396373, \"o\", \"t\"]\n[1.41531, \"o\", \"h\"]\n[1.434156, \"o\", \"s\"]\n[1.457183, \"o\", \".\"]\n[1.493766, \"o\", \"j\"]\n[1.523126, \"o\", \"s\"]\n[1.549244, \"o\", \"o\"]\n[1.583117, \"o\", \"n\"]\n[1.883117, \"o\", \"\\r\\n\"]\n[2.033117, \"o\", \"Wrote paths.json\\r\\n\"]\n[4.733117, \"o\", \"\\r\\n\"]\n[4.733117, \"o\", \"\\u001b[90m# Select the first returned route\\u001b[0m\\r\\n\"]\n[5.183117, \"o\", \"$ \"]\n[5.213208, \"o\", \"p\"]\n[5.238916, \"o\", \"y\"]\n[5.278755, \"o\", \"t\"]\n[5.31587, \"o\", \"h\"]\n[5.339987, \"o\", \"o\"]\n[5.373542, \"o\", \"n\"]\n[5.40569, \"o\", \"3\"]\n[5.447837, \"o\", \" \"]\n[5.485821, \"o\", \"-\"]\n[5.511191, \"o\", \"c\"]\n[5.556338, \"o\", \" \"]\n[5.576855, \"o\", \"'\"]\n[5.605944, \"o\", \"i\"]\n[5.644719, \"o\", \"m\"]\n[5.666205, \"o\", \"p\"]\n[5.697318, \"o\", \"o\"]\n[5.715581, \"o\", \"r\"]\n[5.751816, \"o\", \"t\"]\n[5.790803, \"o\", \" \"]\n[5.824318, \"o\", \"j\"]\n[5.866475, \"o\", \"s\"]\n[5.892582, \"o\", \"o\"]\n[5.92959, \"o\", \"n\"]\n[5.963715, \"o\", \";\"]\n[5.997427, \"o\", \" \"]\n[6.027604, \"o\", \"j\"]\n[6.068746, \"o\", \"s\"]\n[6.11288, \"o\", \"o\"]\n[6.143568, \"o\", \"n\"]\n[6.179687, \"o\", \".\"]\n[6.198563, \"o\", \"d\"]\n[6.235748, \"o\", \"u\"]\n[6.271381, \"o\", \"m\"]\n[6.316898, \"o\", \"p\"]\n[6.357524, \"o\", \"(\"]\n[6.382798, \"o\", \"j\"]\n[6.410964, \"o\", \"s\"]\n[6.447211, \"o\", \"o\"]\n[6.464999, \"o\", \"n\"]\n[6.495333, \"o\", \".\"]\n[6.517277, \"o\", \"l\"]\n[6.537765, \"o\", \"o\"]\n[6.556593, \"o\", \"a\"]\n[6.595685, \"o\", \"d\"]\n[6.616523, \"o\", \"(\"]\n[6.640741, \"o\", \"o\"]\n[6.669054, \"o\", \"p\"]\n[6.711094, \"o\", \"e\"]\n[6.73054, \"o\", \"n\"]\n[6.760516, \"o\", \"(\"]\n[6.793357, \"o\", \"\\\"\"]\n[6.83574, \"o\", \"p\"]\n[6.876291, \"o\", \"a\"]\n[6.918119, \"o\", \"t\"]\n[6.943217, \"o\", \"h\"]\n[6.972225, \"o\", \"s\"]\n[6.999618, \"o\", \".\"]\n[7.042024, \"o\", \"j\"]\n[7.086531, \"o\", \"s\"]\n[7.107985, \"o\", \"o\"]\n[7.130163, \"o\", \"n\"]\n[7.153933, \"o\", \"\\\"\"]\n[7.177743, \"o\", \")\"]\n[7.208742, \"o\", \")\"]\n[7.242717, \"o\", \"[\"]\n[7.267367, \"o\", \"\\\"\"]\n[7.284627, \"o\", \"p\"]\n[7.313739, \"o\", \"a\"]\n[7.341432, \"o\", \"t\"]\n[7.374756, \"o\", \"h\"]\n[7.419131, \"o\", \"s\"]\n[7.456002, \"o\", \"\\\"\"]\n[7.487873, \"o\", \"]\"]\n[7.522661, \"o\", \"[\"]\n[7.559124, \"o\", \"0\"]\n[7.57781, \"o\", \"]\"]\n[7.620653, \"o\", \",\"]\n[7.660081, \"o\", \" \"]\n[7.70221, \"o\", \"o\"]\n[7.742149, \"o\", \"p\"]\n[7.770503, \"o\", \"e\"]\n[7.799045, \"o\", \"n\"]\n[7.819146, \"o\", \"(\"]\n[7.854412, \"o\", \"\\\"\"]\n[7.873333, \"o\", \"p\"]\n[7.8924, \"o\", \"a\"]\n[7.915508, \"o\", \"t\"]\n[7.937288, \"o\", \"h\"]\n[7.964147, \"o\", \".\"]\n[7.982792, \"o\", \"j\"]\n[7.999941, \"o\", \"s\"]\n[8.021406, \"o\", \"o\"]\n[8.041448, \"o\", \"n\"]\n[8.068979, \"o\", \"\\\"\"]\n[8.086851, \"o\", \",\"]\n[8.128975, \"o\", \" \"]\n[8.163662, \"o\", \"\\\"\"]\n[8.185049, \"o\", \"w\"]\n[8.2094, \"o\", \"\\\"\"]\n[8.236468, \"o\", \")\"]\n[8.264015, \"o\", \")\"]\n[8.284668, \"o\", \"'\"]\n[8.584668, \"o\", \"\\r\\n\"]\n[8.734668, \"o\", \"\\r\\n\"]\n[11.434668, \"o\", \"\\r\\n\"]\n[11.434668, \"o\", \"\\u001b[90m# Create a five-vertex cycle\\u001b[0m\\r\\n\"]\n[11.884668, \"o\", \"$ \"]\n[11.926066, \"o\", \".\"]\n[11.971583, \"o\", \"/\"]\n[12.00204, \"o\", \"p\"]\n[12.033007, \"o\", \"r\"]\n[12.052604, \"o\", \"e\"]\n[12.072666, \"o\", \"d\"]\n[12.099599, \"o\", \" \"]\n[12.124306, \"o\", \"c\"]\n[12.16513, \"o\", \"r\"]\n[12.186886, \"o\", \"e\"]\n[12.204689, \"o\", \"a\"]\n[12.249002, \"o\", \"t\"]\n[12.281238, \"o\", \"e\"]\n[12.30257, \"o\", \" \"]\n[12.335232, \"o\", \"M\"]\n[12.353147, \"o\", \"I\"]\n[12.385379, \"o\", \"S\"]\n[12.430479, \"o\", \" \"]\n[12.472288, \"o\", \"-\"]\n[12.509323, \"o\", \"-\"]\n[12.533926, \"o\", \"g\"]\n[12.561546, \"o\", \"r\"]\n[12.583461, \"o\", \"a\"]\n[12.62266, \"o\", \"p\"]\n[12.655019, \"o\", \"h\"]\n[12.694421, \"o\", \" \"]\n[12.720983, \"o\", \"0\"]\n[12.744498, \"o\", \"-\"]\n[12.784827, \"o\", \"1\"]\n[12.830111, \"o\", \",\"]\n[12.871615, \"o\", \"1\"]\n[12.911788, \"o\", \"-\"]\n[12.952312, \"o\", \"2\"]\n[12.990594, \"o\", \",\"]\n[13.014215, \"o\", \"2\"]\n[13.046148, \"o\", \"-\"]\n[13.07345, \"o\", \"3\"]\n[13.09142, \"o\", \",\"]\n[13.109361, \"o\", \"3\"]\n[13.134488, \"o\", \"-\"]\n[13.159036, \"o\", \"4\"]\n[13.195965, \"o\", \",\"]\n[13.240437, \"o\", \"4\"]\n[13.270357, \"o\", \"-\"]\n[13.314272, \"o\", \"0\"]\n[13.359645, \"o\", \" \"]\n[13.404073, \"o\", \"-\"]\n[13.431634, \"o\", \"o\"]\n[13.455076, \"o\", \" \"]\n[13.4787, \"o\", \"c\"]\n[13.501463, \"o\", \"y\"]\n[13.524445, \"o\", \"c\"]\n[13.559419, \"o\", \"l\"]\n[13.602285, \"o\", \"e\"]\n[13.64344, \"o\", \".\"]\n[13.674282, \"o\", \"j\"]\n[13.710082, \"o\", \"s\"]\n[13.750071, \"o\", \"o\"]\n[13.769636, \"o\", \"n\"]\n[14.069636, \"o\", \"\\r\\n\"]\n[14.219636, \"o\", \"Wrote cycle.json\\r\\n\"]\n[16.919636, \"o\", \"\\r\\n\"]\n[16.919636, \"o\", \"\\u001b[90m# Transform the instance and preserve the way back\\u001b[0m\\r\\n\"]\n[17.369636, \"o\", \"$ \"]\n[17.405653, \"o\", \".\"]\n[17.44879, \"o\", \"/\"]\n[17.488284, \"o\", \"p\"]\n[17.526859, \"o\", \"r\"]\n[17.55766, \"o\", \"e\"]\n[17.579904, \"o\", \"d\"]\n[17.619593, \"o\", \" \"]\n[17.646237, \"o\", \"r\"]\n[17.68626, \"o\", \"e\"]\n[17.731165, \"o\", \"d\"]\n[17.759617, \"o\", \"u\"]\n[17.788228, \"o\", \"c\"]\n[17.832423, \"o\", \"e\"]\n[17.870274, \"o\", \" \"]\n[17.892274, \"o\", \"c\"]\n[17.913047, \"o\", \"y\"]\n[17.934508, \"o\", \"c\"]\n[17.977504, \"o\", \"l\"]\n[18.01769, \"o\", \"e\"]\n[18.039009, \"o\", \".\"]\n[18.079766, \"o\", \"j\"]\n[18.124918, \"o\", \"s\"]\n[18.16084, \"o\", \"o\"]\n[18.187994, \"o\", \"n\"]\n[18.220813, \"o\", \" \"]\n[18.241699, \"o\", \"-\"]\n[18.259248, \"o\", \"-\"]\n[18.304131, \"o\", \"v\"]\n[18.339836, \"o\", \"i\"]\n[18.372024, \"o\", \"a\"]\n[18.415842, \"o\", \" \"]\n[18.445379, \"o\", \"p\"]\n[18.487429, \"o\", \"a\"]\n[18.528176, \"o\", \"t\"]\n[18.551349, \"o\", \"h\"]\n[18.575687, \"o\", \".\"]\n[18.6012, \"o\", \"j\"]\n[18.625216, \"o\", \"s\"]\n[18.659114, \"o\", \"o\"]\n[18.683667, \"o\", \"n\"]\n[18.712782, \"o\", \" \"]\n[18.73367, \"o\", \"-\"]\n[18.776813, \"o\", \"o\"]\n[18.804064, \"o\", \" \"]\n[18.834297, \"o\", \"r\"]\n[18.868107, \"o\", \"e\"]\n[18.911087, \"o\", \"d\"]\n[18.940248, \"o\", \"u\"]\n[18.983611, \"o\", \"c\"]\n[19.015087, \"o\", \"e\"]\n[19.047425, \"o\", \"d\"]\n[19.079525, \"o\", \".\"]\n[19.097202, \"o\", \"j\"]\n[19.12692, \"o\", \"s\"]\n[19.149295, \"o\", \"o\"]\n[19.16655, \"o\", \"n\"]\n[19.46655, \"o\", \"\\r\\n\"]\n[19.61655, \"o\", \"Wrote reduced.json\\r\\n\"]\n[22.31655, \"o\", \"\\r\\n\"]\n[22.31655, \"o\", \"\\u001b[90m# Solve the target and recover a source solution\\u001b[0m\\r\\n\"]\n[22.76655, \"o\", \"$ \"]\n[22.806526, \"o\", \".\"]\n[22.828593, \"o\", \"/\"]\n[22.859265, \"o\", \"p\"]\n[22.897127, \"o\", \"r\"]\n[22.930169, \"o\", \"e\"]\n[22.956626, \"o\", \"d\"]\n[22.988579, \"o\", \" \"]\n[23.021591, \"o\", \"s\"]\n[23.061142, \"o\", \"o\"]\n[23.081317, \"o\", \"l\"]\n[23.114468, \"o\", \"v\"]\n[23.138711, \"o\", \"e\"]\n[23.163765, \"o\", \" \"]\n[23.202973, \"o\", \"r\"]\n[23.234622, \"o\", \"e\"]\n[23.267814, \"o\", \"d\"]\n[23.306671, \"o\", \"u\"]\n[23.349885, \"o\", \"c\"]\n[23.379692, \"o\", \"e\"]\n[23.414336, \"o\", \"d\"]\n[23.445923, \"o\", \".\"]\n[23.477699, \"o\", \"j\"]\n[23.514634, \"o\", \"s\"]\n[23.544701, \"o\", \"o\"]\n[23.577081, \"o\", \"n\"]\n[23.877081, \"o\", \"\\r\\n\"]\n[24.027081, \"o\", \"Problem: MaximumIndependentSet\\r\\nSolver: ilp (ILP<i64, bool> -> ILP<f64, bool>) (via ILP)\\r\\nStatus: optimal\\r\\nSolution: Array [Bool(true), Bool(false), Bool(false), Bool(true), Bool(false)]\\r\\nEvaluation: Max(2)\\r\\n\\r\\nHint: use -o to save full solution details (including intermediate results) as JSON.\\r\\n\"]\n[26.727081, \"o\", \"\\r\\n\"]\n[26.727081, \"o\", \"\\u001b[90m# Check an independent set of size two\\u001b[0m\\r\\n\"]\n[27.177081, \"o\", \"$ \"]\n[27.207882, \"o\", \".\"]\n[27.251925, \"o\", \"/\"]\n[27.289045, \"o\", \"p\"]\n[27.331232, \"o\", \"r\"]\n[27.375294, \"o\", \"e\"]\n[27.399854, \"o\", \"d\"]\n[27.432983, \"o\", \" \"]\n[27.477076, \"o\", \"e\"]\n[27.518219, \"o\", \"v\"]\n[27.53928, \"o\", \"a\"]\n[27.559898, \"o\", \"l\"]\n[27.589673, \"o\", \"u\"]\n[27.608888, \"o\", \"a\"]\n[27.632907, \"o\", \"t\"]\n[27.652139, \"o\", \"e\"]\n[27.688409, \"o\", \" \"]\n[27.72795, \"o\", \"c\"]\n[27.770722, \"o\", \"y\"]\n[27.792278, \"o\", \"c\"]\n[27.829882, \"o\", \"l\"]\n[27.865889, \"o\", \"e\"]\n[27.887117, \"o\", \".\"]\n[27.929483, \"o\", \"j\"]\n[27.97427, \"o\", \"s\"]\n[27.997687, \"o\", \"o\"]\n[28.042045, \"o\", \"n\"]\n[28.070566, \"o\", \" \"]\n[28.101631, \"o\", \"-\"]\n[28.147056, \"o\", \"-\"]\n[28.187983, \"o\", \"c\"]\n[28.209739, \"o\", \"o\"]\n[28.239211, \"o\", \"n\"]\n[28.271085, \"o\", \"f\"]\n[28.297917, \"o\", \"i\"]\n[28.320653, \"o\", \"g\"]\n[28.346896, \"o\", \" \"]\n[28.384672, \"o\", \"'\"]\n[28.402372, \"o\", \"[\"]\n[28.435344, \"o\", \"t\"]\n[28.465072, \"o\", \"r\"]\n[28.482731, \"o\", \"u\"]\n[28.509346, \"o\", \"e\"]\n[28.544315, \"o\", \",\"]\n[28.576094, \"o\", \"f\"]\n[28.595074, \"o\", \"a\"]\n[28.640362, \"o\", \"l\"]\n[28.680029, \"o\", \"s\"]\n[28.724935, \"o\", \"e\"]\n[28.745071, \"o\", \",\"]\n[28.769802, \"o\", \"t\"]\n[28.788076, \"o\", \"r\"]\n[28.827476, \"o\", \"u\"]\n[28.852345, \"o\", \"e\"]\n[28.87319, \"o\", \",\"]\n[28.902397, \"o\", \"f\"]\n[28.94558, \"o\", \"a\"]\n[28.986123, \"o\", \"l\"]\n[29.010654, \"o\", \"s\"]\n[29.032065, \"o\", \"e\"]\n[29.07547, \"o\", \",\"]\n[29.108915, \"o\", \"f\"]\n[29.14607, \"o\", \"a\"]\n[29.165769, \"o\", \"l\"]\n[29.184556, \"o\", \"s\"]\n[29.221361, \"o\", \"e\"]\n[29.250656, \"o\", \"]\"]\n[29.269868, \"o\", \"'\"]\n[29.569868, \"o\", \"\\r\\n\"]\n[29.719868, \"o\", \"Max(2)\\r\\n\"]\n[32.419868, \"o\", \"\\r\\n\"]\n[32.419868, \"o\", \"\\u001b[90m# Solve the original instance with the default solver\\u001b[0m\\r\\n\"]\n[32.869868, \"o\", \"$ \"]\n[32.913821, \"o\", \".\"]\n[32.949091, \"o\", \"/\"]\n[32.989137, \"o\", \"p\"]\n[33.008673, \"o\", \"r\"]\n[33.050279, \"o\", \"e\"]\n[33.069325, \"o\", \"d\"]\n[33.111119, \"o\", \" \"]\n[33.141227, \"o\", \"s\"]\n[33.16806, \"o\", \"o\"]\n[33.201004, \"o\", \"l\"]\n[33.244624, \"o\", \"v\"]\n[33.26942, \"o\", \"e\"]\n[33.290255, \"o\", \" \"]\n[33.322452, \"o\", \"c\"]\n[33.346407, \"o\", \"y\"]\n[33.366678, \"o\", \"c\"]\n[33.388433, \"o\", \"l\"]\n[33.407015, \"o\", \"e\"]\n[33.429923, \"o\", \".\"]\n[33.45598, \"o\", \"j\"]\n[33.481837, \"o\", \"s\"]\n[33.52068, \"o\", \"o\"]\n[33.546108, \"o\", \"n\"]\n[33.846108, \"o\", \"\\r\\n\"]\n[33.996108, \"o\", \"Problem: MaximumIndependentSet\\r\\nSolver: ilp (MaximumIndependentSet<SimpleGraph, One> -> MaximumIndependentSet<SimpleGraph, i64> -> MaximumSetPacking<i64> -> ILP<i64, bool> -> ILP<f64, bool>)\\r\\nStatus: optimal\\r\\nSolution: Array [Bool(true), Bool(false), Bool(false), Bool(true), Bool(false)]\\r\\nEvaluation: Max(2)\\r\\n\\r\\nHint: use -o to save full solution details as JSON.\\r\\n\"]\n[36.696108, \"o\", \"$ \"]\n";
   AsciinemaPlayer.create({ data: castData }, document.getElementById("player"), {"cols": 88, "rows": 22, "theme": "nord", "autoPlay": false, "loop": false, "controls": true, "poster": "npt:1.75"});
 </script>
 </body>
diff --git a/docs/src/static/reduction-graph.js b/docs/src/static/reduction-graph.js
index 3e2c0d0b9..8132f6c43 100644
--- a/docs/src/static/reduction-graph.js
+++ b/docs/src/static/reduction-graph.js
@@ -176,7 +176,7 @@
       if (srcName === dstName) return;
       var key = srcName + '->' + dstName;
       if (!nameLevelEdges[key]) {
-        nameLevelEdges[key] = { count: 0, overhead: e.overhead, doc_path: e.doc_path };
+        nameLevelEdges[key] = { count: 0, parameters: e.parameters, doc_path: e.doc_path };
       }
       nameLevelEdges[key].count++;
     });
@@ -191,7 +191,7 @@
           target: problemNodeIds[parts[1]],
           label: info.count > 1 ? '\u00d7' + info.count : '',
           edgeLevel: 'collapsed',
-          overhead: info.overhead,
+          parameters: info.parameters,
           doc_path: info.doc_path
         }
       });
@@ -208,7 +208,7 @@
         edgeMap[key] = {
           source: srcId,
           target: dstId,
-          overhead: e.overhead || [],
+          parameters: e.parameters || [],
           doc_path: e.doc_path || ''
         };
       }
@@ -219,16 +219,18 @@
       var srcName = e.source.split('/')[0];
       var dstName = e.target.split('/')[0];
       var isVariantCast = srcName === dstName &&
-        e.overhead &&
-        e.overhead.length > 0 &&
-        e.overhead.every(function(o) { return o.field === o.formula; });
+        e.parameters &&
+        e.parameters.length > 0 &&
+        e.parameters.every(function(o) {
+          return o.contract === 'exact' && o.field === o.formula;
+        });
       return {
         data: {
           id: 'variant_' + key,
           source: e.source,
           target: e.target,
           edgeLevel: 'variant',
-          overhead: e.overhead,
+          parameters: e.parameters,
           doc_path: e.doc_path,
           isVariantCast: isVariantCast
         }
@@ -531,8 +533,12 @@
         cy.on('mouseover', 'edge', function(evt) {
           var d = evt.target.data();
           var html = '<strong>' + evt.target.source().data('label') + ' \u2192 ' + evt.target.target().data('label') + '</strong>';
-          if (d.overhead && d.overhead.length > 0) {
-            html += '<br>' + d.overhead.map(function(o) { return '<code>' + o.field + '</code> = <code>' + o.formula + '</code>'; }).join('<br>');
+          if (d.parameters && d.parameters.length > 0) {
+            html += '<br>' + d.parameters.map(function(o) {
+              if (o.contract === 'exact') return '<code>' + o.field + '</code> = <code>' + o.formula + '</code> (exact)';
+              if (o.contract === 'upper_bound') return '<code>' + o.field + '</code> &le; <code>' + o.formula + '</code> (upper bound)';
+              return '<code>' + o.field + '</code> unavailable: ' + o.reason;
+            }).join('<br>');
           }
           html += '<br><em>Click to highlight, double-click for source code</em>';
           tooltip.innerHTML = html;
@@ -642,8 +648,12 @@
           edge.source().addClass('highlighted');
           edge.target().addClass('highlighted');
           var text = edge.source().data('label') + ' \u2192 ' + edge.target().data('label');
-          if (d.overhead && d.overhead.length > 0) {
-            text += '  |  ' + d.overhead.map(function(o) { return o.field + ' = ' + o.formula; }).join(', ');
+          if (d.parameters && d.parameters.length > 0) {
+            text += '  |  ' + d.parameters.map(function(o) {
+              if (o.contract === 'exact') return o.field + ' = ' + o.formula + ' (exact)';
+              if (o.contract === 'upper_bound') return o.field + ' <= ' + o.formula + ' (upper bound)';
+              return o.field + ' unavailable: ' + o.reason;
+            }).join(', ');
           }
           instructions.textContent = text;
           clearBtn.style.display = 'inline';
diff --git a/docs/src/static/trait-hierarchy.typ b/docs/src/static/trait-hierarchy.typ
index c23dd50dc..b6c167ffd 100644
--- a/docs/src/static/trait-hierarchy.typ
+++ b/docs/src/static/trait-hierarchy.typ
@@ -28,9 +28,10 @@
       #strong[trait Problem]\
       #text(size: 8pt, fill: secondary)[
         `const NAME: &str`\
+        `type Solution`\
         `type Value: Clone`\
-        `fn dims() -> Vec<usize>`\
-        `fn evaluate(&config) -> Value`\
+        `fn size() -> ProblemParameters`\
+        `fn evaluate(&solution) -> Value`\
         `fn variant() -> Vec<(&str, &str)>`
       ]
     ]), fill: trait-fill, corner-radius: 6pt, inset: 10pt, name: <problem>),
@@ -41,23 +42,35 @@
       #text(size: 8pt, fill: secondary)[
         `fn identity() -> Self`\
         `fn combine(self, other) -> Self`\
-        `fn supports_witnesses() -> bool`\
-        `fn contributes_to_witnesses(...)`
+        `fn is_absorbing(&self) -> bool`\
+        #strong[trait SolutionAggregate: Aggregate]\
+        `fn contributes_to_solution(...)`
       ]
     ]), fill: trait-fill, corner-radius: 6pt, inset: 10pt, name: <aggregate>),
 
+    // Brute-force capability (bottom center)
+    node((0.7, 1), box(width: 48mm, align(left)[
+      #strong[trait BruteForceProblem]\
+      #text(size: 8pt, fill: secondary)[
+        `extends Problem`\
+        `fn dimensions() -> Vec<usize>`\
+        #text(style: "italic")[reference solver only]
+      ]
+    ]), fill: trait-fill, corner-radius: 6pt, inset: 10pt, name: <brute-force>),
+
     // Common value types (bottom right)
-    node((1.25, 1), box(width: 48mm, align(left)[
+    node((1.4, 1), box(width: 48mm, align(left)[
       #strong[Common Value Types]\
       #text(size: 8pt, fill: secondary)[
         `Max<V> | Min<V> | Extremum<V>`\
         `Or | Sum<W> | And`\
-        #text(style: "italic")[used as `Problem::Value`]
+        #text(style: "italic")[only selecting values implement `SolutionAggregate`]
       ]
     ]), fill: type-fill, corner-radius: 6pt, inset: 10pt, name: <values>),
 
     // Conceptual relationships
     edge(<aggregate>, <problem>, "->", label: text(size: 8pt)[solver-bound on `Value`], label-side: left, label-fill: none),
+    edge(<brute-force>, <problem>, "->", label: text(size: 8pt)[extends], label-fill: none),
     edge(<values>, <aggregate>, "->", label: text(size: 8pt)[implements], label-side: right, label-fill: none),
   )
 }
diff --git a/docs/src/static/variant-hierarchy-dark.svg b/docs/src/static/variant-hierarchy-dark.svg
index fe8394aad..b6b7d8a8a 100644
--- a/docs/src/static/variant-hierarchy-dark.svg
+++ b/docs/src/static/variant-hierarchy-dark.svg
@@ -1,766 +1 @@
-<svg class="typst-doc" viewBox="0 0 580.113245511811 189.44601565354327" width="580.113245511811pt" height="189.44601565354327pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h5="http://www.w3.org/1999/xhtml">
-    <g>
-        <g class="typst-group" transform="matrix(1 0 0 1 5 5)">
-            <g>
-                <g class="typst-group">
-                    <g>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 127.12545659842516 31.62058258267711)" d="M 0 0m 0.000000000000025176711 22.177166 l -0.000000000000025176711 -22.177166 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 127.12545656692915 31.620582708661402)" d="M 0 0c 0.9273351 2.016171 2.7557724 3.4731827 4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 122.19737137670406 31.620582708661402)" d="M 0 0m 4.9280853 0 c -0.92733526 2.016171 -2.7557724 3.4731827 -4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 57.91810381041723 72.46169497785961)" d="M 0 0m 0 22.473097 l 41.5327 -22.473097 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 98.0498252823698 72.4616948976378)" d="M 0 0m 1.40098 0 c -1.3319149 1.7750765 -1.7432189 4.0765743 -1.1085647 6.2030993 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 93.65175203524791 69.9962664173967)" d="M 0 0m 5.799053 2.4654286 c -2.2145405 0.14388919 -4.3661275 -0.7708436 -5.799053 -2.4654286 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 127.12545659842517 72.72374812598423)" d="M 0 0m 0 22.177166 v -22.177166 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 127.12545656692915 72.72374825196849)" d="M 0 0c 0.9273351 2.016171 2.7557724 3.4731827 4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 122.19737137670406 72.72374825196849)" d="M 0 0m 4.9280853 0 c -0.92733526 2.016171 -2.7557724 3.4731827 -4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 155.27871129505246 72.42663009434959)" d="M 0 0m 42.676 22.474283 l -42.676 -22.474283 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 155.27871118110235 69.89606623238521)" d="M 0 0m 0 2.5305638 c 2.2160206 0.11894679 4.357173 -0.8199527 5.770929 -2.5305638 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 155.27871118110235 72.42663004724409)" d="M 0 0c 1.3518162 1.7599685 1.7890066 4.05669 1.1783348 6.190226 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 194.279381036 113.73183748194954)" d="M 0 0m 0 22.272242 l 16.133612 -22.272242 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 210.27914614473883 113.73183751181101)" d="M 0 0m 0.1338468 0 c -0.43176514 2.1768036 0.19425048 4.429395 1.6872652 6.071285 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 204.1182581089316 113.73183751181101)" d="M 0 0m 6.294735 0 c -1.9337664 1.0887808 -4.2692633 1.1961051 -6.294735 0.2892656 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 241.31203312502686 113.77178312710771)" d="M 0 0m 11.405975 22.232296 l -11.405975 -22.232296 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 241.31203303937008 113.77178305511808)" d="M 0 0c 1.7454053 1.3705674 4.037318 1.8323038 6.1772647 1.2444924 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 238.71987503206995 113.77178305511808)" d="M 0 0m 2.592158 0 c 0.09523225 2.2171662 -0.8665203 4.3481507 -2.592158 5.743525 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 396.466878015748 72.72374812598427)" d="M 0 0m 0 22.177166 v -22.177166 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 396.4668779527559 72.72374825196849)" d="M 0 0c 0.9273351 2.016171 2.7557724 3.4731827 4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 391.5387927625309 72.72374825196849)" d="M 0 0m 4.9280853 0 c -0.92733526 2.016171 -2.7557724 3.4731827 -4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 396.4668780157482 31.62058258267734)" d="M 0 0m 0 22.177166 v -22.177166 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 396.4668779527559 31.620582708661402)" d="M 0 0c 0.9273351 2.016171 2.7557724 3.4731827 4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 391.5387927625309 31.620582708661402)" d="M 0 0m 4.9280853 0 c -0.92733526 2.016171 -2.7557724 3.4731827 -4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 465.71997526463826 30.09404852216683)" d="M 0 0m 0 25.26112 l 30.355688 -25.26112 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 495.3919826049906 30.094048346456674)" d="M 0 0m 0.6836814 0 c -0.95657516 2.0024633 -0.90695035 4.339898 0.13375086 6.2999587 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 489.9048489771738 28.817956977625926)" d="M 0 0m 6.170815 1.2760913 c -2.1429272 0.5768515 -4.432447 0.10339117 -6.170815 -1.2760913 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 487.4285842483744 31.550909461319364)" d="M 0 0m 0 22.24684 l 13.16195 -22.24684 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 500.5532774195091 31.55090938582677)" d="M 0 0m 0.037257448 0 c -0.22850081 2.207415 0.6032539 4.3924203 2.2417822 5.889123 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 494.3495680831244 31.55090938582677)" d="M 0 0m 6.240967 0 c -1.8247294 1.2630347 -4.140277 1.5859942 -6.240967 0.8704549 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 507.10634006299205 31.62058258267711)" d="M 0 0m 0 22.177166 l 0.000000000000100706844 -22.177166 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 507.1063401259842 31.620582708661402)" d="M 0 0c 0.9273351 2.016171 2.7557724 3.4731827 4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 502.1782549357592 31.620582708661402)" d="M 0 0m 4.9280853 0 c -0.92733526 2.016171 -2.7557724 3.4731827 -4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 513.6221454765276 31.550909461319364)" d="M 0 0m 13.16195 22.24684 l -13.16195 -22.24684 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 513.6221453858268 31.55090938582677)" d="M 0 0c 1.8247294 1.2630347 4.140277 1.5859942 6.240967 0.8704549 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 511.3803631896651 31.55090938582677)" d="M 0 0m 2.2417822 0 c 0.22850084 2.207415 -0.60325384 4.3924203 -2.2417822 5.889123 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 518.1370161038857 30.094048575397373)" d="M 0 0m 30.355688 25.26112 l -30.355688 -25.26112 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 518.1370162204723 28.817956977625926)" d="M 0 0m 0 1.2760913 c 2.1429274 0.5768515 4.432447 0.10339117 6.170815 -1.2760913 "/>
-                        <path class="typst-shape" fill="none" stroke="#94a3b8" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 518.0032653902913 30.094048346456674)" d="M 0 0m 0.13375083 0 c 0.95657516 2.0024633 0.9069505 4.339898 -0.13375083 6.2999587 "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 96.84545659837518 0)" d="M 0 0h 60.56 v 7.14 h -60.56 v -7.14 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 96.84545648818894 -0.00000009448818426195845)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000004999714378289526 7.139999999999999)">
-                                                    <use xlink:href="#g669BD235869889BDF946F7D74B43299F" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g6039E9718934F8358AFBA066AB1E1D34" x="7.590000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g708E1061457335A9700D72CAC4F879A3" x="11.48" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gAC6E804F15E6999EE71F805512F26550" x="17.22" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g6D32D2D4BF1DD877D4B5269BD6400D6B" x="23.33" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gCA1CBF0434CFDD20D754D66658D3AF1F" x="32.04" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g5976208ADE7B9F7852981FBD3C9164A" x="38.15" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gAC6E804F15E6999EE71F805512F26550" x="43.339999999999996" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g769AC14B8720B1A4D53E0E7BB92AAAC0" x="49.449999999999996" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g55B6FC3B395E7CA8B028D87603BB0605" x="55.19" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 377.1218780156981 0)" d="M 0 0h 38.69 v 7.14 h -38.69 v -7.14 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 377.12187790551184 -0.00000009448818426195845)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 7.139999999999999)">
-                                                    <use xlink:href="#gC84EDC6FBAC0CE2EFC24569B0177ECD5" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g769AC14B8720B1A4D53E0E7BB92AAAC0" x="9.44" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g4F32DCC5CEA421B0EDD79EB9B8B18787" x="15.18" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g53CE0EDC53D4ECE2FFD9259C5CC1AE51" x="17.759999999999998" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g6D32D2D4BF1DD877D4B5269BD6400D6B" x="23.869999999999997" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g709986D1AD07B5D6C62F4F10C982F993" x="29.799999999999997" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g55B6FC3B395E7CA8B028D87603BB0605" x="33.31999999999999" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 486.27634006294204 0)" d="M 0 0h 41.66 v 7.14 h -41.66 v -7.14 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 486.27633995275585 -0.00000009448818426195845)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 7.139999999999999)">
-                                                    <use xlink:href="#g62F0E2E5CCBA1EC061CCCA42BF03BD67" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gC82E65AC956B3FEDC3323A1DF128185D" x="10" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g708E1061457335A9700D72CAC4F879A3" x="16.3" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gF87923E104CC15BE09B4120335A8FEC4" x="22.04" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g879D08C569DBB924818BD3C3C3D32E4E" x="24.619999999999997" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g769AC14B8720B1A4D53E0E7BB92AAAC0" x="30.549999999999997" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g55B6FC3B395E7CA8B028D87603BB0605" x="36.29" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 96.54195656692913 12.694582582677151)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 51.167 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -51.167 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 102.54195659837518 18.694582677165354)" d="M 0 0h 49.167 v 6.426 h -49.167 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 102.54195645669289 18.694582677165346)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 6.425999999999999)">
-                                                    <use xlink:href="#g641F1DE27A4B048908B0028DB805B317" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g124215DF7EB2152435C4CCD8DC3AEA76" x="6.498" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="10.998000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g4B31B8CEB3E48D08D063331B59F6BBAB" x="16.335" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="21.168" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g9ED3C7BE04AE098F91DCEB215E1CAC9A" x="24.165" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="30.996" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="33.993" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="38.826" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="44.163" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 94.78695656692913 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 54.677 c 2.7589226 0 5.000004 -2.2410812 5.000004 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5.000004 -5 h -54.677 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 100.78695659837518 59.79774803149605)" d="M 0 0h 52.677 v 6.426 h -52.677 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 100.78695645669289 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000004999714378289526 6.425999999999999)">
-                                                    <use xlink:href="#g813F0103BE3CE7D676D52F9A0F5776CD" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="5.832" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD978DC9CC0B9AE918886416C8F39495D" x="7.83" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="15.507" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE14823C6D5887C5946C79D53BC50B1DF" x="20.844" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g4B31B8CEB3E48D08D063331B59F6BBAB" x="22.842000000000002" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g9ED3C7BE04AE098F91DCEB215E1CAC9A" x="27.675000000000004" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="34.50600000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="37.50300000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="42.336000000000006" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="47.673" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 0 94.90091338582677)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 52.499 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -52.499 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 5.999999905461805 100.90091338582675)" d="M 0 0h 50.499 v 6.426 h -50.499 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 5.999999763779523 100.90091338582677)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 6.425999999999999)">
-                                                    <use xlink:href="#gCCF6F62EDE72A2783EDD776715FF2521" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE14823C6D5887C5946C79D53BC50B1DF" x="5.832" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="7.83" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBF6C7CC99FD9658A0BCA7C9307EFE887" x="12.663" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="17.667" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="22.5" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g9ED3C7BE04AE098F91DCEB215E1CAC9A" x="25.497" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="32.328" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="35.325" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="40.158" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="45.495000000000005" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 91.70895656692913 94.90091338582677)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 60.833 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -60.833 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 97.70895659837517 100.90091338582675)" d="M 0 0h 58.833 v 6.426 h -58.833 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 97.70895645669289 100.90091338582677)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000430515849977 6.425999999999999)">
-                                                    <use xlink:href="#g4C14CF88950BA583FF1F70F2AC32556F" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="6.165" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="8.163" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="13.5" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="18.333" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g87DCE9BAA18E83AE0AA9F4A317AAF534" x="21.33" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="24.165" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g87DCE9BAA18E83AE0AA9F4A317AAF534" x="26.163" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g4B31B8CEB3E48D08D063331B59F6BBAB" x="28.998" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g9ED3C7BE04AE098F91DCEB215E1CAC9A" x="33.831" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="40.662000000000006" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="43.659000000000006" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="48.492000000000004" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="53.82900000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 191.75191341732284 94.90091338582677)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 60.842003 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -60.842003 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 197.7519132912886 100.90091338582675)" d="M 0 0h 58.842 v 6.426 h -58.842 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 197.75191314960628 100.90091338582677)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000430515849977 6.425999999999999)">
-                                                    <use xlink:href="#g3EEFA5F67AA62934351B04ACAD7700B7" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBF6C7CC99FD9658A0BCA7C9307EFE887" x="6.498" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="11.502" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g87DCE9BAA18E83AE0AA9F4A317AAF534" x="13.5" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gC4452AF47A66FE705AB14D2AB364C607" x="16.335" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="22.671" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD46906E080E9F801E0E94D1932E8451F" x="24.669" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gFB59D557F363E86096A9F4459DDFD8F3" x="29.169" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g9ED3C7BE04AE098F91DCEB215E1CAC9A" x="33.84" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="40.67100000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="43.668000000000006" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="48.501000000000005" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="53.83800000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 140.05868485039372 136.0040786456693)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 64.181 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -64.181 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 146.05868494483187 142.00407874015747)" d="M 0 0h 62.181 v 6.426 h -62.181 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 146.0586848031496 142.00407874015747)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000430515849977 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="6.003000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBF6C7CC99FD9658A0BCA7C9307EFE887" x="8.001000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g7691E6040D648DC4C509121677FE43B4" x="13.005000000000003" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD46906E080E9F801E0E94D1932E8451F" x="18.171000000000003" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g813F0103BE3CE7D676D52F9A0F5776CD" x="22.671000000000003" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g70A5EED08A4892697C9F8AF4CED29F38" x="28.503000000000004" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g81941A84CFD7B2E6E64D490082E56BB7" x="33.507000000000005" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g7691E6040D648DC4C509121677FE43B4" x="38.84400000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="44.010000000000005" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="47.007000000000005" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="51.84" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="57.17700000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 225.05239162204725 136.0040786456693)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 80.678 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -80.678 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 231.05239163774525 142.00407874015747)" d="M 0 0h 78.678 v 6.426 h -78.678 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 231.05239149606294 142.00407874015747)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 6.425999999999999)">
-                                                    <use xlink:href="#g5E7F3EDE6694ACAB83B07765FD7C88CC" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="4.338" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="7.335" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="9.333" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBF6C7CC99FD9658A0BCA7C9307EFE887" x="14.166" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g7691E6040D648DC4C509121677FE43B4" x="19.17" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g70A5EED08A4892697C9F8AF4CED29F38" x="24.336000000000002" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE14823C6D5887C5946C79D53BC50B1DF" x="29.340000000000003" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="31.338000000000005" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="36.17100000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g813F0103BE3CE7D676D52F9A0F5776CD" x="39.168000000000006" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g70A5EED08A4892697C9F8AF4CED29F38" x="45.00000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g81941A84CFD7B2E6E64D490082E56BB7" x="50.004000000000005" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g7691E6040D648DC4C509121677FE43B4" x="55.34100000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="60.507000000000005" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="63.504000000000005" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="68.337" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="73.674" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#3b1f2b" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 384.1308779527559 12.694582582677151)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 14.672001 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -14.672001 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 390.13087801569804 18.694582677165354)" d="M 0 0h 12.672 v 6.426 h -12.672 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 390.13087787401577 18.694582677165346)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g73CBF4CE1C6B6F76004C71E0D960877F" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gAA9BA5DCE3B7BAD11A37A99523970BA1" x="2.6639999999999997" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g170E3DF111F34A5B640D30A3D024062D" x="7.668" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#3b1f2b" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 384.4638779527559 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 14.0060005 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -14.0060005 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 390.46387801569807 59.79774803149605)" d="M 0 0h 12.006 v 6.426 h -12.006 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 390.4638778740158 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g825BFEEBA88E24CB932EEEE0C5250EC" x="1.998" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g48F95159F05E08FF24029F09E94D9EBD" x="7.002000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#3b1f2b" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 382.1283779527559 94.90091338582677)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 18.677 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -18.677 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 388.1283780156981 100.90091338582675)" d="M 0 0h 16.677 v 6.426 h -16.677 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 388.12837787401577 100.90091338582677)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 6.425999999999999)">
-                                                    <use xlink:href="#gF70B1EB6DF5EEB5418258DA74EF6450A" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBF6C7CC99FD9658A0BCA7C9307EFE887" x="6.840000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g4B31B8CEB3E48D08D063331B59F6BBAB" x="11.844000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 494.8558401259843 12.694582582677151)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 14.500999 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -14.500999 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 500.8558400629421 18.694582677165354)" d="M 0 0h 12.501 v 6.426 h -12.501 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 500.8558399212598 18.694582677165346)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gCE9C5FDCB0FB9D903B0471E1194A86FD" x="6.003000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 444.09943474015745 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 13.007 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -13.007 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 450.09943470861134 59.79774803149605)" d="M 0 0h 11.007 v 6.426 h -11.007 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 450.0994345669291 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g59D5A1C590864C9D7659EE9E44D8B385" x="6.003000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 469.8511372913386 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 13.007 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -13.007 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 475.8511373857768 59.79774803149605)" d="M 0 0h 11.007 v 6.426 h -11.007 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 475.8511372440945 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g48F95159F05E08FF24029F09E94D9EBD" x="6.003000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 495.60284012598424 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 13.007 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -13.007 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 501.60284006294216 59.79774803149605)" d="M 0 0h 11.007 v 6.426 h -11.007 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 501.60283992125983 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g825BFEEBA88E24CB932EEEE0C5250EC" x="6.003000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 521.3545426771652 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 13.007 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -13.007 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 527.3545427401075 59.79774803149605)" d="M 0 0h 11.007 v 6.426 h -11.007 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 527.354542598425 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g170E3DF111F34A5B640D30A3D024062D" x="6.003000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 547.106245511811 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 13.007 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -13.007 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 553.1062454172728 59.79774803149605)" d="M 0 0h 11.007 v 6.426 h -11.007 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 553.1062452755904 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBB143EC3C95E2D7D22714C2C87E91ED" x="6.003000000000001" y="0" fill="#e2e8f0" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                    </g>
-                </g>
-            </g>
-        </g>
-        <g class="typst-text" transform="matrix(1 0 0 -1 5 184.44601565354327)">
-            <use xlink:href="#gA590B7DC033E470D6BAF5CDFC85B2050" x="0" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g8B593199FA06CCE05316E9DE69A76C04" x="5.184" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g8B593199FA06CCE05316E9DE69A76C04" x="7.848000000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g77DE0CDDDA90F97D0E6338DF2ADA2B05" x="10.368000000000002" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gDAB705390D499B70C1CEEA1CADFAB46C" x="14.96" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g5BA2C50E2FB253176C23A29D28811B37" x="21.024" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g900615605685504312176826BFAA7CD0" x="27.248" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g77DE0CDDDA90F97D0E6338DF2ADA2B05" x="31.992" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g924EAF2D52C629B054774FEED87B1A3" x="36.584" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g140CE90B08CDC407F2943E5829DFF5DD" x="38.36000000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gFC264C0FD775885BC630DFC00D9E2FE7" x="42.80800000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gEF2A2A1EFDC1817766F824B6B7E6A1" x="47.55200000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g8B593199FA06CCE05316E9DE69A76C04" x="49.92000000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g77DE0CDDDA90F97D0E6338DF2ADA2B05" x="52.440000000000005" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gA5BD779142255ABB4257B527699904C3" x="57.03200000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g5BA2C50E2FB253176C23A29D28811B37" x="66.08000000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g900615605685504312176826BFAA7CD0" x="70.08000000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gE037EFFB7D6AFF5A7E0FD7AFE38271D9" x="74.82400000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gEBC5194FC1C7A48F06C53C940408D757" x="79.12000000000002" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g924EAF2D52C629B054774FEED87B1A3" x="83.41600000000003" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gAD3C9196DFD8002DD8AD647251EA8E6" x="85.19200000000002" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gEBC5194FC1C7A48F06C53C940408D757" x="89.33600000000003" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gFC264C0FD775885BC630DFC00D9E2FE7" x="95.85600000000004" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g77DE0CDDDA90F97D0E6338DF2ADA2B05" x="98.37600000000003" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g403726A1DBA9CA6272A92801D756F7C" x="105.19200000000004" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gE037EFFB7D6AFF5A7E0FD7AFE38271D9" x="109.78400000000003" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g140CE90B08CDC407F2943E5829DFF5DD" x="114.08000000000004" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gE037EFFB7D6AFF5A7E0FD7AFE38271D9" x="118.52800000000005" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g8B593199FA06CCE05316E9DE69A76C04" x="122.82400000000005" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gFFA01FEE3974FB44A414D4377DF74C95" x="125.48800000000006" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g8C3B87D37300021CAF28AE99C6A53743" x="129.78400000000005" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gEA2E7995284F078BE317DAED71DE81DC" x="133.78400000000005" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g5BA2C50E2FB253176C23A29D28811B37" x="135.85600000000005" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g8F6718057B0E3514573AA9B4A2FC38A1" x="139.85600000000005" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g11B4CFF4C9AF9181ECD6A36A02010591" x="144.30400000000006" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gFC264C0FD775885BC630DFC00D9E2FE7" x="149.04800000000006" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gB6FD75F5298B86FC5D51AC6F195ECA25" x="151.56800000000007" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g900615605685504312176826BFAA7CD0" x="155.56800000000007" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gE037EFFB7D6AFF5A7E0FD7AFE38271D9" x="160.31200000000007" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gF6E6E618EB7A8A012445F280241D7C98" x="166.83200000000005" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g924EAF2D52C629B054774FEED87B1A3" x="171.57600000000005" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g8B593199FA06CCE05316E9DE69A76C04" x="173.35200000000006" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gE037EFFB7D6AFF5A7E0FD7AFE38271D9" x="175.87200000000007" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gEBC5194FC1C7A48F06C53C940408D757" x="180.16800000000006" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#gFC264C0FD775885BC630DFC00D9E2FE7" x="184.46400000000006" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g924EAF2D52C629B054774FEED87B1A3" x="186.98400000000007" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g77DE0CDDDA90F97D0E6338DF2ADA2B05" x="188.76000000000008" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g140CE90B08CDC407F2943E5829DFF5DD" x="193.3520000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g38385C688BB0F21A935DCB07A45652A7" x="197.8000000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-            <use xlink:href="#g9A3A3A35D6C54D3285C5E0F1A91F795E" x="199.8720000000001" y="0" fill="#94a3b8" fill-rule="nonzero"/>
-        </g>
-    </g>
-    <defs id="glyph">
-        <symbol id="g669BD235869889BDF946F7D74B43299F" overflow="visible">
-            <path d="M 0 0m 5.85 0.81 l 0.15999985 -0.81 h 1 v 3.86 h -3 v -1.1699998 h 1.5799999 q -0.069999695 -0.7500001 -0.4949999 -1.1450001 q -0.4249997 -0.39499998 -1.2049999 -0.39499998 q -0.53 0 -0.89999986 0.20500004 q -0.37000012 0.20499992 -0.60000014 0.54499996 q -0.23000002 0.34000003 -0.3349998 0.765 q -0.10500014 0.42499995 -0.10500014 0.875 q 0 0.4699998 0.10500014 0.90999985 q 0.10499978 0.44000006 0.3349998 0.78499985 q 0.23000002 0.34500027 0.60000014 0.5500002 q 0.3699999 0.20499992 0.89999986 0.20499992 q 0.5700002 0 0.9699998 -0.2999997 q 0.4000001 -0.3000002 0.54000044 -0.9000001 h 1.4999995 q -0.059999943 0.61000013 -0.32999992 1.0799999 q -0.26999998 0.4699998 -0.68499994 0.78999996 q -0.41499996 0.32000017 -0.9299998 0.48500013 q -0.51499987 0.16499996 -1.065 0.16499996 q -0.81999993 0 -1.4749999 -0.28999996 q -0.655 -0.28999996 -1.105 -0.8000002 q -0.45 -0.50999975 -0.68999994 -1.1949997 q -0.24000001 -0.6850004 -0.24000001 -1.4850001 q 0 -0.78 0.24000001 -1.4549999 q 0.23999995 -0.6750001 0.68999994 -1.1750001 q 0.45000005 -0.49999997 1.105 -0.78499997 q 0.655 -0.285 1.4749999 -0.285 q 0.52 0 1.0300002 0.215 q 0.50999975 0.21499997 0.9299998 0.755 Z "/>
-        </symbol>
-        <symbol id="g6039E9718934F8358AFBA066AB1E1D34" overflow="visible">
-            <path d="M 0 0m 0.53999996 5.17 v -5.17 h 1.42 v 2.33 q 0 0.3499999 0.07000005 0.6500001 q 0.06999993 0.29999995 0.2349999 0.52499986 q 0.16499996 0.22500014 0.43500018 0.35500002 q 0.26999998 0.13000011 0.65999985 0.13000011 q 0.13000011 0 0.26999998 -0.015000105 q 0.1400001 -0.015000105 0.24000001 -0.035000086 v 1.3199999 q -0.17000008 0.05000019 -0.30999994 0.05000019 q -0.26999998 0 -0.52 -0.07999992 q -0.25 -0.07999992 -0.47000003 -0.2249999 q -0.22000003 -0.14500046 -0.38999987 -0.35000038 q -0.17000008 -0.20499992 -0.2700001 -0.4449997 h -0.01999998 v 0.96000004 h -1.35 Z "/>
-        </symbol>
-        <symbol id="g708E1061457335A9700D72CAC4F879A3" overflow="visible">
-            <path d="M 0 0m 0.48 3.58 q 0.030000001 0.5 0.24999997 0.8299999 q 0.22000003 0.32999992 0.56 0.5300002 q 0.34000003 0.19999981 0.7650001 0.28499985 q 0.42499995 0.08500004 0.8549998 0.08500004 q 0.3900001 0 0.78999996 -0.05499983 q 0.4000001 -0.055000305 0.73 -0.21500015 q 0.32999992 -0.15999985 0.53999996 -0.44500017 q 0.21000004 -0.28499985 0.21000004 -0.7549999 v -2.69 q 0 -0.35000002 0.03999996 -0.66999996 q 0.03999996 -0.32 0.13999987 -0.48 h -1.4399998 q -0.03999996 0.12 -0.06499982 0.24499999 q -0.025000095 0.12500001 -0.035000086 0.255 q -0.3399999 -0.35000002 -0.79999995 -0.49 q -0.46000004 -0.14 -0.94000006 -0.14 q -0.37 0 -0.68999994 0.089999996 q -0.32000005 0.089999996 -0.56 0.28 q -0.24000001 0.18999998 -0.375 0.47999996 q -0.13499999 0.29000002 -0.13499999 0.69 q 0 0.43999994 0.155 0.725 q 0.155 0.28499985 0.4 0.45499992 q 0.245 0.17000008 0.55999994 0.2550001 q 0.31500006 0.0849998 0.635 0.13499999 q 0.31999993 0.049999952 0.6300001 0.07999992 q 0.30999994 0.029999971 0.54999995 0.089999914 q 0.24000001 0.06000018 0.37999988 0.17499995 q 0.1400001 0.11500001 0.13000011 0.33500004 q 0 0.23000002 -0.07500005 0.36500025 q -0.07500005 0.13499975 -0.20000005 0.21000004 q -0.125 0.07499981 -0.28999996 0.099999905 q -0.16499996 0.025000095 -0.35500002 0.025000095 q -0.42000008 0 -0.65999985 -0.1800003 q -0.24000013 -0.17999983 -0.2800001 -0.5999999 h -1.42 Z m 3.28 -1.05 q -0.09000015 -0.07999992 -0.22500014 -0.125 q -0.13499999 -0.045000076 -0.28999996 -0.07500005 q -0.15499997 -0.029999971 -0.32500005 -0.049999952 q -0.16999984 -0.01999998 -0.3399999 -0.049999952 q -0.16000009 -0.029999971 -0.31500006 -0.08000016 q -0.15499997 -0.049999952 -0.26999986 -0.13499999 q -0.11500001 -0.08499992 -0.18500006 -0.21499991 q -0.06999993 -0.13 -0.06999993 -0.33000004 q 0 -0.18999994 0.06999993 -0.31999993 q 0.07000005 -0.13 0.19000006 -0.20499998 q 0.119999886 -0.07499999 0.27999997 -0.10500002 q 0.16000009 -0.029999971 0.32999992 -0.029999971 q 0.42000008 0 0.6500001 0.13999999 q 0.23000002 0.14000005 0.3399999 0.33499998 q 0.109999895 0.19500005 0.13499999 0.39499998 q 0.025000095 0.20000005 0.025000095 0.32000005 v 0.53 Z "/>
-        </symbol>
-        <symbol id="gAC6E804F15E6999EE71F805512F26550" overflow="visible">
-            <path d="M 0 0m 3.1499999 0.93 q -0.3399999 0 -0.5799999 0.13999993 q -0.24000001 0.13999999 -0.385 0.365 q -0.14499998 0.22500002 -0.21000004 0.525 q -0.06499994 0.30000007 -0.06499994 0.61 q 0 0.31999993 0.059999943 0.6199999 q 0.060000062 0.3000002 0.20500004 0.5300002 q 0.14499998 0.22999978 0.37999988 0.37499976 q 0.23500013 0.14499998 0.58500004 0.14499998 q 0.34000015 0 0.57500005 -0.14499998 q 0.2349999 -0.14499998 0.385 -0.37999988 q 0.1500001 -0.2349999 0.21500015 -0.5350001 q 0.06500006 -0.29999995 0.06500006 -0.6099999 q 0 -0.30999994 -0.06000042 -0.61 q -0.059999943 -0.29999995 -0.20499992 -0.525 q -0.14499974 -0.22500002 -0.37999988 -0.365 q -0.2349999 -0.13999993 -0.58500004 -0.13999993 Z m -2.61 4.2400002 v -6.98 h 1.42 v 2.4499998 h 0.01999998 q 0.2600001 -0.38 0.6650001 -0.575 q 0.40499997 -0.195 0.885 -0.195 q 0.56999993 0 0.9950001 0.22 q 0.4249997 0.22 0.70999956 0.59000003 q 0.28500032 0.36999995 0.4250002 0.84999996 q 0.13999987 0.48000002 0.13999987 1 q 0 0.54999995 -0.13999987 1.0550001 q -0.13999987 0.50499964 -0.42999983 0.88499975 q -0.28999996 0.3800001 -0.73 0.61000013 q -0.44000006 0.23000002 -1.0500002 0.23000002 q -0.47999978 0 -0.8799999 -0.19000006 q -0.4000001 -0.19000006 -0.65999997 -0.61000013 h -0.01999998 v 0.6600003 h -1.35 Z "/>
-        </symbol>
-        <symbol id="g6D32D2D4BF1DD877D4B5269BD6400D6B" overflow="visible">
-            <path d="M 0 0m 0.53999996 7.14 v -7.14 h 1.42 v 2.71 q 0 0.78999996 0.2600001 1.135 q 0.26 0.34500003 0.8399999 0.34500003 q 0.51 0 0.71000004 -0.31500006 q 0.20000005 -0.31500006 0.20000005 -0.95500016 v -2.9199998 h 1.4199998 v 3.1799998 q 0 0.48000002 -0.08500004 0.875 q -0.08500004 0.39499998 -0.29500008 0.6700001 q -0.21000004 0.2750001 -0.5749998 0.42999983 q -0.36500025 0.15500021 -0.93499994 0.15500021 q -0.4000001 0 -0.8200002 -0.20499992 q -0.41999984 -0.20499992 -0.6899998 -0.6550002 h -0.03000009 v 2.69 h -1.42 Z "/>
-        </symbol>
-        <symbol id="gCA1CBF0434CFDD20D754D66658D3AF1F" overflow="visible">
-            <path d="M 0 0m 2.27 5.8199997 v -5.8199997 h 1.5699999 v 5.8199997 h 2.14 v 1.3200002 h -5.85 v -1.3200002 h 2.1399999 Z "/>
-        </symbol>
-        <symbol id="g5976208ADE7B9F7852981FBD3C9164A" overflow="visible">
-            <path d="M 0 0m 3.09 -0.64 l 2.16 5.81 h -1.47 l -1.1300001 -3.54 h -0.01999998 l -1.17 3.54 h -1.5099999 l 1.81 -4.85 q 0.059999943 -0.14999999 0.059999943 -0.32 q 0 -0.22999999 -0.13499999 -0.42 q -0.13499999 -0.19000003 -0.41499996 -0.22 q -0.21000004 -0.00999999 -0.42000002 0.00999999 q -0.20999998 0.01999998 -0.40999997 0.04000002 v -1.1700001 q 0.21999997 -0.01999998 0.435 -0.034999967 q 0.21500003 -0.014999986 0.43499994 -0.014999986 q 0.73 0 1.1400001 0.26999998 q 0.40999985 0.26999998 0.63999987 0.9 Z "/>
-        </symbol>
-        <symbol id="g769AC14B8720B1A4D53E0E7BB92AAAC0" overflow="visible">
-            <path d="M 0 0m 4.02 3.1399999 h -2.31 q 0.00999999 0.1500001 0.06500006 0.34000015 q 0.054999948 0.18999982 0.18999994 0.3599999 q 0.13499999 0.16999984 0.36000013 0.2850001 q 0.2249999 0.11499977 0.5649998 0.11499977 q 0.52 0 0.7750001 -0.27999997 q 0.25499988 -0.27999997 0.35500002 -0.81999993 Z m -2.31 -0.89999986 h 3.73 q 0.03999996 0.5999999 -0.10000038 1.1499999 q -0.13999987 0.54999995 -0.45499992 0.98 q -0.31500006 0.42999983 -0.8049998 0.68499994 q -0.49 0.2550001 -1.1500001 0.2550001 q -0.5899999 0 -1.0749999 -0.21000004 q -0.4849999 -0.21000004 -0.8349999 -0.5749998 q -0.35000002 -0.36500025 -0.53999996 -0.86500025 q -0.19 -0.5 -0.19 -1.0799999 q 0 -0.6 0.185 -1.0999999 q 0.18499997 -0.50000006 0.525 -0.86 q 0.3399999 -0.36 0.8299999 -0.555 q 0.49 -0.195 1.0999999 -0.195 q 0.8800001 0 1.5 0.39999998 q 0.6199999 0.39999998 0.9200001 1.3299999 h -1.25 q -0.07000017 -0.23999989 -0.37999988 -0.45499992 q -0.31000018 -0.21499997 -0.74 -0.21499997 q -0.60000014 0 -0.9200001 0.31 q -0.31999993 0.30999994 -0.35000002 1 Z "/>
-        </symbol>
-        <symbol id="g55B6FC3B395E7CA8B028D87603BB0605" overflow="visible">
-            <path d="M 0 0m 1.64 1.68 h -1.35 q 0.02000001 -0.52 0.23499998 -0.86499995 q 0.21500003 -0.345 0.54999995 -0.555 q 0.33500004 -0.21 0.765 -0.29999998 q 0.43000007 -0.089999996 0.8800001 -0.089999996 q 0.43999982 0 0.865 0.08499999 q 0.4249997 0.08499999 0.75499964 0.295 q 0.3300004 0.20999998 0.5350003 0.555 q 0.20499992 0.34499997 0.20499992 0.85499996 q 0 0.36 -0.13999987 0.6049999 q -0.14000034 0.24500012 -0.37000036 0.4100001 q -0.23000002 0.16499996 -0.5249996 0.26499987 q -0.29500008 0.10000014 -0.60500026 0.17000008 q -0.29999995 0.06999993 -0.5899999 0.13000011 q -0.28999996 0.059999943 -0.51499987 0.13499999 q -0.22500014 0.07499981 -0.36500013 0.19499993 q -0.13999999 0.119999886 -0.13999999 0.30999994 q 0 0.16000009 0.08000004 0.25499988 q 0.08000004 0.09500027 0.19500005 0.14499998 q 0.11500001 0.05000019 0.25499988 0.06500006 q 0.1400001 0.015000343 0.26 0.015000343 q 0.3800001 0 0.6600001 -0.14500046 q 0.27999997 -0.14499998 0.30999994 -0.5549998 h 1.3500001 q -0.03999996 0.48000002 -0.24500036 0.7950001 q -0.20499992 0.31500006 -0.51499987 0.5050001 q -0.30999994 0.19000006 -0.7049999 0.26999998 q -0.39499998 0.07999992 -0.81500006 0.07999992 q -0.41999984 0 -0.81999993 -0.075000286 q -0.39999998 -0.07499981 -0.7199999 -0.25999975 q -0.32000005 -0.18499994 -0.51500005 -0.5050001 q -0.19499996 -0.3199997 -0.19499996 -0.81999993 q 0 -0.3399999 0.14000002 -0.5749998 q 0.13999999 -0.23500013 0.36999995 -0.3900001 q 0.23000002 -0.15499997 0.525 -0.25 q 0.29500008 -0.09500003 0.605 -0.16499996 q 0.76 -0.16000009 1.185 -0.32000005 q 0.42499995 -0.15999997 0.42499995 -0.48000002 q 0 -0.18999994 -0.089999914 -0.31499994 q -0.089999914 -0.125 -0.2249999 -0.19999999 q -0.13499999 -0.07499999 -0.3000002 -0.110000014 q -0.16499996 -0.034999967 -0.31499982 -0.034999967 q -0.21000004 0 -0.40499997 0.049999952 q -0.19500017 0.050000012 -0.34500015 0.15500003 q -0.14999998 0.10500002 -0.24499989 0.26999998 q -0.09500003 0.16499996 -0.09500003 0.39499998 Z "/>
-        </symbol>
-        <symbol id="gC84EDC6FBAC0CE2EFC24569B0177ECD5" overflow="visible">
-            <path d="M 0 0m 7.49 0 l 1.9200001 7.14 h -1.54 l -1.1700001 -4.92 h -0.01999998 l -1.2199998 4.92 h -1.47 l -1.24 -4.8599997 h -0.01999998 l -1.1300001 4.8599997 h -1.5699999 l 1.89 -7.14 h 1.59 l 1.1899998 4.8599997 h 0.01999998 l 1.21 -4.8599997 h 1.56 Z "/>
-        </symbol>
-        <symbol id="g4F32DCC5CEA421B0EDD79EB9B8B18787" overflow="visible">
-            <path d="M 0 0m 2 5.97 v 1.1700001 h -1.4200001 v -1.1700001 h 1.4200001 Z m -1.4200001 -0.7999997 v -5.17 h 1.4200001 v 5.17 h -1.4200001 Z "/>
-        </symbol>
-        <symbol id="g53CE0EDC53D4ECE2FFD9259C5CC1AE51" overflow="visible">
-            <path d="M 0 0m 2.95 1.22 q -0.33000016 0 -0.5500002 0.13999999 q -0.21999979 0.13999999 -0.35500002 0.3599999 q -0.13499987 0.22000003 -0.18999994 0.495 q -0.054999948 0.2750001 -0.054999948 0.55500007 q 0 0.28999996 0.06500006 0.5549998 q 0.06499994 0.2650001 0.21000004 0.47000003 q 0.14499998 0.20500016 0.3599999 0.32500005 q 0.21499991 0.119999886 0.5150001 0.119999886 q 0.3499999 0 0.5799999 -0.12999964 q 0.23000002 -0.13000011 0.3699999 -0.35000014 q 0.1400001 -0.22000003 0.20000005 -0.5050001 q 0.059999943 -0.28499985 0.059999943 -0.605 q 0 -0.27999997 -0.07499981 -0.53499985 q -0.075000286 -0.255 -0.22500014 -0.45500004 q -0.1500001 -0.20000005 -0.37999988 -0.32000005 q -0.23000002 -0.119999886 -0.53 -0.119999886 Z m 2.5599997 -0.89000005 v 4.84 h -1.3499999 v -0.69000006 h -0.01999998 q -0.26 0.4499998 -0.645 0.63999987 q -0.385 0.19000006 -0.895 0.19000006 q -0.53999996 0 -0.9549999 -0.21000004 q -0.41499996 -0.21000004 -0.695 -0.56500006 q -0.28000003 -0.35500002 -0.425 -0.81999993 q -0.14499998 -0.4649999 -0.14499998 -0.9649999 q 0 -0.53 0.125 -1.005 q 0.125 -0.47500002 0.39499998 -0.83000004 q 0.26999998 -0.35499996 0.68999994 -0.55999994 q 0.42000008 -0.205 1 -0.205 q 0.47000003 0 0.895 0.19500001 q 0.42499995 0.19499996 0.655 0.605 h 0.01999998 v -0.68 q 0.010000229 -0.54999995 -0.26499987 -0.90999997 q -0.2750001 -0.36 -0.875 -0.36 q -0.3800001 0 -0.6700001 0.15500003 q -0.28999996 0.15499997 -0.39 0.55499995 h -1.4099998 q 0.029999971 -0.43999997 0.24499995 -0.755 q 0.21500003 -0.31500006 0.53999996 -0.515 q 0.32500005 -0.20000005 0.72000015 -0.29499996 q 0.39499998 -0.09500003 0.77499986 -0.09500003 q 0.8900001 0 1.4200001 0.24000001 q 0.52999973 0.24000001 0.80999994 0.5849999 q 0.27999973 0.34500003 0.36499977 0.745 q 0.08500004 0.4 0.08500004 0.71 Z "/>
-        </symbol>
-        <symbol id="g709986D1AD07B5D6C62F4F10C982F993" overflow="visible">
-            <path d="M 0 0m 2.34 5.17 v 1.5499997 h -1.42 v -1.5499997 h -0.85999995 v -0.9500003 h 0.85999995 v -3.0499997 q 0 -0.39 0.13 -0.63 q 0.13 -0.23999998 0.35500002 -0.36999995 q 0.22500002 -0.13 0.52 -0.175 q 0.29500008 -0.044999998 0.625 -0.044999998 q 0.21000004 0 0.43000007 0.009999998 q 0.21999979 0.01 0.39999986 0.04 v 1.1 q -0.099999905 -0.0200001 -0.21000004 -0.03000009 q -0.109999895 -0.00999999 -0.23000002 -0.00999999 q -0.3599999 0 -0.47999978 0.120000005 q -0.120000124 0.120000005 -0.120000124 0.48000002 v 2.56 h 1.04 v 0.9500003 h -1.04 Z "/>
-        </symbol>
-        <symbol id="g62F0E2E5CCBA1EC061CCCA42BF03BD67" overflow="visible">
-            <path d="M 0 0m 0.69 7.14 v -7.14 h 1.5699999 v 2.3 l 0.89999986 0.9100001 l 2.15 -3.21 h 1.9699998 l -3.06 4.3199997 l 2.79 2.8200002 h -1.96 l -2.7899997 -2.96 v 2.96 h -1.5699999 Z "/>
-        </symbol>
-        <symbol id="gC82E65AC956B3FEDC3323A1DF128185D" overflow="visible">
-            <path d="M 0 0m 4.0099998 0 l 2.37 7.14 h -1.6199999 l -1.6099999 -5.02 h -0.01999998 l -1.5899999 5.02 h -1.61 l 2.31 -7.14 h 1.7699997 Z "/>
-        </symbol>
-        <symbol id="gF87923E104CC15BE09B4120335A8FEC4" overflow="visible">
-            <path d="M 0 0m 0.58 7.14 v -7.14 h 1.4200001 v 7.14 h -1.4200001 Z "/>
-        </symbol>
-        <symbol id="g879D08C569DBB924818BD3C3C3D32E4E" overflow="visible">
-            <path d="M 0 0m 5.39 0 v 5.17 h -1.4199998 v -2.71 q 0 -0.7900001 -0.26000023 -1.1350001 q -0.26 -0.34499997 -0.8399999 -0.34499997 q -0.51 0 -0.71000004 0.315 q -0.19999993 0.31500006 -0.19999993 0.95500004 v 2.92 h -1.42 v -3.18 q 0 -0.48000002 0.08500004 -0.875 q 0.08499998 -0.39500004 0.29499996 -0.67 q 0.21000004 -0.27499998 0.57500005 -0.42499998 q 0.365 -0.14999999 0.9349998 -0.14999999 q 0.45000005 0 0.8800001 0.19999999 q 0.43000007 0.19999999 0.6999998 0.65 h 0.03000021 v -0.71999997 h 1.3499999 Z "/>
-        </symbol>
-        <symbol id="g641F1DE27A4B048908B0028DB805B317" overflow="visible">
-            <path d="M 0 0m 0.70199996 6.4259996 v -6.4259996 h 0.85499996 v 2.9429998 h 3.384 v -2.9429998 h 0.85499954 v 6.4259996 h -0.85499954 v -2.7629998 h -3.384 v 2.7629998 h -0.85499996 Z "/>
-        </symbol>
-        <symbol id="g124215DF7EB2152435C4CCD8DC3AEA76" overflow="visible">
-            <path d="M 0 0m 2.4029999 -0.621 q -0.13499999 -0.34199995 -0.26550007 -0.5759999 q -0.13049984 -0.23400009 -0.28799987 -0.38250005 q -0.15750003 -0.14849997 -0.35099995 -0.21599996 q -0.19350004 -0.067499995 -0.44550002 -0.067499995 q -0.13499999 0 -0.26999998 0.018000007 q -0.13499999 0.018000007 -0.26100004 0.062999964 v 0.702 q 0.09900004 -0.045000076 0.2295 -0.07650006 q 0.13050002 -0.031499982 0.22049999 -0.031499982 q 0.23400003 0 0.39150006 0.11249995 q 0.15749991 0.11250007 0.23849988 0.31950003 l 0.31500006 0.783 l -1.8449999 4.626 h 0.86399996 l 1.3589998 -3.807 h 0.018000126 l 1.3049998 3.807 h 0.8100002 l -2.025 -5.2739997 Z "/>
-        </symbol>
-        <symbol id="g2801BEF568718ADDC2ABAF998D0A388F" overflow="visible">
-            <path d="M 0 0m 0.603 4.653 v -6.4259996 h 0.7649999 v 2.3939998 h 0.018000007 q 0.12600005 -0.20700002 0.31050003 -0.3465 q 0.18449998 -0.13949999 0.39149988 -0.22049999 q 0.20700002 -0.081 0.41850019 -0.11699999 q 0.21149993 -0.036 0.38249993 -0.036 q 0.5309999 0 0.93149996 0.18899998 q 0.40049982 0.18899998 0.6659999 0.5175 q 0.26550007 0.32850003 0.3959999 0.7695 q 0.13050032 0.44099998 0.13050032 0.936 q 0 0.4949999 -0.13500023 0.9359999 q -0.13499975 0.44099998 -0.40049982 0.77849984 q -0.26550007 0.3375001 -0.6660001 0.53550005 q -0.40050006 0.19799995 -0.9405 0.19799995 q -0.48599982 0 -0.8909999 -0.17549992 q -0.40499997 -0.17549992 -0.594 -0.5625 h -0.018000007 v 0.6300001 h -0.7649999 Z m 3.5999997 -2.286 q 0 -0.342 -0.07199955 -0.6659999 q -0.07200003 -0.324 -0.2340002 -0.576 q -0.16199994 -0.25200003 -0.4275 -0.40500003 q -0.26550007 -0.153 -0.6615 -0.153 q -0.3959999 0 -0.67499995 0.14850003 q -0.27899992 0.14849997 -0.45449996 0.3915 q -0.17550004 0.24299991 -0.2565 0.5624999 q -0.08099997 0.3195001 -0.08099997 0.6615 q 0 0.32400012 0.07649994 0.63899994 q 0.07650006 0.31500006 0.24750006 0.5625 q 0.171 0.24749994 0.44099998 0.40050006 q 0.26999998 0.15300012 0.6569998 0.15300012 q 0.3690002 0 0.6435001 -0.14400005 q 0.2744999 -0.14400005 0.45000005 -0.38700008 q 0.17549968 -0.24300003 0.26099992 -0.55349994 q 0.08549976 -0.3104999 0.08549976 -0.6345 Z "/>
-        </symbol>
-        <symbol id="g4B31B8CEB3E48D08D063331B59F6BBAB" overflow="visible">
-            <path d="M 0 0m 3.807 2.7719998 h -2.6729999 q 0.018000007 0.26999998 0.116999984 0.5085001 q 0.09899998 0.23849988 0.26999998 0.41849995 q 0.171 0.18000007 0.4095 0.28349996 q 0.2385 0.10350013 0.53549993 0.10350013 q 0.2880001 0 0.5265 -0.10350013 q 0.23850012 -0.10349989 0.41400003 -0.27900004 q 0.17549992 -0.17549992 0.27900004 -0.41849995 q 0.10349989 -0.24300003 0.121500015 -0.513 Z m 0.7379997 -1.2959999 h -0.7559998 q -0.09899998 -0.459 -0.40949988 -0.684 q -0.31050014 -0.22499996 -0.79649997 -0.22499996 q -0.37800002 0 -0.65700006 0.12599999 q -0.27899992 0.12599999 -0.459 0.33749998 q -0.17999995 0.21150005 -0.26099992 0.48599994 q -0.08099997 0.2745 -0.07200003 0.5805 h 3.4829998 q 0.018000126 0.4230001 -0.07649994 0.89100003 q -0.094500065 0.46799994 -0.342 0.86399984 q -0.24749994 0.3959999 -0.6569998 0.65250015 q -0.40949988 0.25649977 -1.0304999 0.25649977 q -0.477 0 -0.87749994 -0.17999983 q -0.40050006 -0.17999983 -0.693 -0.5040002 q -0.29249996 -0.32399988 -0.4545 -0.76499987 q -0.16199997 -0.44099998 -0.16199997 -0.9719999 q 0.017999977 -0.531 0.15749997 -0.98099995 q 0.13950002 -0.45 0.4185 -0.774 q 0.27899992 -0.324 0.6884999 -0.50399995 q 0.4095 -0.17999999 0.9675001 -0.17999999 q 0.7919998 0 1.3139999 0.39599997 q 0.52199984 0.39599997 0.6749997 1.1789999 Z "/>
-        </symbol>
-        <symbol id="gE596B299A30367997DC94AB9B8B72FA7" overflow="visible">
-            <path d="M 0 0m 0.54899997 4.653 v -4.653 h 0.7649999 v 2.07 q 0 0.45000005 0.09000003 0.79649997 q 0.09000003 0.34649992 0.288 0.58949995 q 0.19799995 0.24300003 0.5220001 0.36899996 q 0.32399988 0.12599993 0.783 0.12599993 v 0.80999994 q -0.62100005 0.018000126 -1.026 -0.25199986 q -0.40499997 -0.26999998 -0.684 -0.8369999 h -0.018000007 v 0.98099995 h -0.71999997 Z "/>
-        </symbol>
-        <symbol id="g9ED3C7BE04AE098F91DCEB215E1CAC9A" overflow="visible">
-            <path d="M 0 0m 5.508 0.80099994 l 0.2249999 -0.80099994 h 0.53999996 v 3.3839998 h -2.817 v -0.72 h 2.052 q 0.017999649 -0.44099998 -0.1170001 -0.8234999 q -0.13500023 -0.38249993 -0.40049982 -0.6659999 q -0.26550007 -0.28350002 -0.65250015 -0.44550002 q -0.38700008 -0.162 -0.89100003 -0.162 q -0.53999996 0 -0.94949985 0.21149999 q -0.40950012 0.21149999 -0.68850005 0.56700003 q -0.27899992 0.35549998 -0.42299998 0.819 q -0.14399993 0.46349978 -0.14399993 0.9675 q 0 0.5129998 0.12599993 1.0035 q 0.12600005 0.49049997 0.3915 0.87299967 q 0.26549995 0.38250017 0.6839999 0.6164999 q 0.41850019 0.2340002 1.0035 0.2340002 q 0.36000013 0 0.67949986 -0.08549976 q 0.31949997 -0.08550024 0.5715003 -0.25650024 q 0.25199986 -0.171 0.42299986 -0.43650007 q 0.171 -0.26550007 0.23399973 -0.6345 h 0.855 q -0.089999676 0.5670004 -0.33749962 0.9675002 q -0.24750042 0.40049982 -0.612 0.6615 q -0.36450005 0.26099968 -0.82800007 0.3824997 q -0.46350002 0.121500015 -0.9855001 0.121500015 q -0.76499987 0 -1.3364999 -0.28349972 q -0.57149994 -0.2835002 -0.9539999 -0.76049995 q -0.3825 -0.47700024 -0.57600003 -1.1115003 q -0.19349995 -0.6344998 -0.19349995 -1.3364997 q 0 -0.6300001 0.20699999 -1.2149999 q 0.20699996 -0.58500004 0.6029999 -1.0350001 q 0.39600003 -0.44999996 0.96299994 -0.71549994 q 0.56700015 -0.26549998 1.287 -0.26549998 q 0.56700015 0 1.1250002 0.22049999 q 0.5579996 0.22049999 0.9359999 0.72449994 Z "/>
-        </symbol>
-        <symbol id="g3302C695557CE7E554F0836D2CDF4B83" overflow="visible">
-            <path d="M 0 0m 4.698 0.018 q -0.19799995 -0.11699999 -0.54900026 -0.11699999 q -0.29699993 0 -0.47249985 0.16649999 q -0.17549992 0.1665 -0.17549992 0.5445 q -0.31500006 -0.378 -0.7335 -0.5445 q -0.41849995 -0.16649999 -0.9045 -0.16649999 q -0.31499994 0 -0.5985 0.072 q -0.28349996 0.072 -0.4904999 0.22499998 q -0.20700002 0.153 -0.3285 0.40049997 q -0.121499985 0.2475 -0.121499985 0.59849995 q 0 0.39600003 0.13499999 0.648 q 0.13499999 0.25199997 0.35549998 0.4095 q 0.22049999 0.15750003 0.50399995 0.23849988 q 0.28349996 0.08100009 0.5805 0.13499999 q 0.31500006 0.0630002 0.5985 0.094500065 q 0.28349996 0.0315001 0.49950004 0.089999914 q 0.21599984 0.05850005 0.34199977 0.171 q 0.12600017 0.11250019 0.12600017 0.32850003 q 0 0.2520001 -0.094500065 0.40499997 q -0.094500065 0.15300012 -0.24300003 0.23399997 q -0.14849997 0.08099985 -0.33299994 0.10800028 q -0.18449998 0.02699995 -0.36450005 0.02699995 q -0.48599994 0 -0.80999994 -0.18450022 q -0.32399988 -0.18449998 -0.35099995 -0.6975 h -0.765 q 0.018000007 0.43200016 0.18 0.7290001 q 0.162 0.29700017 0.43199998 0.4814999 q 0.26999998 0.18450022 0.6165 0.26550007 q 0.34650004 0.08099985 0.74249995 0.08099985 q 0.31500006 0 0.62549996 -0.045000076 q 0.3104999 -0.0449996 0.5625 -0.18449974 q 0.25199986 -0.13950014 0.40499997 -0.3915 q 0.15299988 -0.2520001 0.15299988 -0.65700006 v -2.3939998 q 0 -0.27000004 0.031499863 -0.39600003 q 0.03150034 -0.12599999 0.21150017 -0.12599999 q 0.09899998 0 0.2340002 0.045000017 v -0.594 Z m -1.2420001 2.385 q -0.14400005 -0.10800004 -0.37800002 -0.15750003 q -0.23399997 -0.04949999 -0.49049997 -0.08099985 q -0.2565 -0.0315001 -0.5174999 -0.07200003 q -0.26100004 -0.040500164 -0.46800005 -0.13050008 q -0.2069999 -0.089999914 -0.33749998 -0.2565 q -0.13049996 -0.16649997 -0.13049996 -0.45449996 q 0 -0.18900001 0.07650006 -0.31949997 q 0.07649994 -0.13050002 0.19799995 -0.21149999 q 0.121500015 -0.08099997 0.28349996 -0.116999984 q 0.16200006 -0.036000013 0.342 -0.036000013 q 0.37800002 0 0.648 0.10350001 q 0.26999998 0.10350001 0.44099998 0.26099998 q 0.171 0.15750003 0.25199986 0.342 q 0.08100009 0.18449998 0.08100009 0.34649992 v 0.783 Z "/>
-        </symbol>
-        <symbol id="gD1A2B325D26318856C7583CB173E0EF5" overflow="visible">
-            <path d="M 0 0m 0.576 6.4259996 v -6.4259996 h 0.765 v 2.6279998 q 0 0.31500006 0.0855 0.5805001 q 0.0855 0.26549983 0.2565 0.46350002 q 0.171 0.19799995 0.4274999 0.306 q 0.2565 0.10800004 0.6075001 0.10800004 q 0.44099998 0 0.69299984 -0.2520001 q 0.2520001 -0.2520001 0.2520001 -0.684 v -3.1499999 h 0.7650001 v 3.06 q 0 0.37800002 -0.07649994 0.6884999 q -0.076500416 0.31050014 -0.26550007 0.53550005 q -0.18900013 0.2249999 -0.49500012 0.35099983 q -0.306 0.12599993 -0.76499987 0.12599993 q -0.20700002 0 -0.4275 -0.045000076 q -0.22049999 -0.0449996 -0.4230001 -0.13949966 q -0.20249999 -0.094500065 -0.36449993 -0.24300003 q -0.16200006 -0.14849997 -0.25199997 -0.36450005 h -0.018000007 v 2.4569998 h -0.765 Z "/>
-        </symbol>
-        <symbol id="g813F0103BE3CE7D676D52F9A0F5776CD" overflow="visible">
-            <path d="M 0 0m 4.4189997 4.5449996 h 0.80999994 q -0.017999649 0.53100014 -0.20249987 0.9135003 q -0.18449974 0.3824997 -0.5039997 0.6345 q -0.31950045 0.25199986 -0.7425003 0.36899996 q -0.42299986 0.116999626 -0.91799974 0.116999626 q -0.44099998 0 -0.85950017 -0.112499714 q -0.41849995 -0.11250019 -0.74699986 -0.342 q -0.32849997 -0.22949982 -0.5265 -0.58500004 q -0.19800001 -0.35549974 -0.19800001 -0.8414998 q 0 -0.44099998 0.17550004 -0.73350024 q 0.17549998 -0.29249978 0.468 -0.47699976 q 0.2924999 -0.18449998 0.6615 -0.29700017 q 0.36899996 -0.11249995 0.7514999 -0.19799995 q 0.38249993 -0.0855 0.7514999 -0.16649985 q 0.3690002 -0.08100009 0.6615 -0.21150017 q 0.29250002 -0.13049984 0.46799994 -0.33749986 q 0.17549992 -0.20700002 0.17549992 -0.5400001 q 0 -0.35099995 -0.14399958 -0.576 q -0.14400005 -0.2249999 -0.37800026 -0.35549992 q -0.23399997 -0.13050002 -0.5265 -0.18449998 q -0.29249978 -0.05400002 -0.5804999 -0.05400002 q -0.3599999 0 -0.7019999 0.089999974 q -0.342 0.09000003 -0.5985 0.27900004 q -0.2565 0.18900001 -0.41400003 0.4814999 q -0.15749991 0.29250002 -0.15749991 0.6975001 h -0.81000006 q 0 -0.58500004 0.21150002 -1.0125 q 0.21149999 -0.4275 0.576 -0.702 q 0.36449993 -0.27449998 0.84599996 -0.40949997 q 0.48150003 -0.13499999 1.0215 -0.13499999 q 0.44099998 0 0.8864999 0.10349999 q 0.4454999 0.10349999 0.80550003 0.333 q 0.36000013 0.22949997 0.58949995 0.594 q 0.22949982 0.3645 0.22949982 0.8775 q 0 0.477 -0.17549992 0.79200006 q -0.17549992 0.31499982 -0.46799994 0.52199984 q -0.29250002 0.20700002 -0.6615 0.32850003 q -0.36899996 0.121500015 -0.7514999 0.21149993 q -0.38249993 0.09000015 -0.7514999 0.16650009 q -0.3690002 0.07649994 -0.6615 0.19350004 q -0.29250014 0.116999865 -0.46800005 0.30150008 q -0.17550004 0.18449974 -0.17550004 0.48149967 q 0 0.31500006 0.121500015 0.5265002 q 0.121500015 0.21149969 0.324 0.33749962 q 0.20249999 0.1260004 0.4634999 0.1800003 q 0.26100016 0.0539999 0.53100014 0.0539999 q 0.6659999 0 1.0934999 -0.31050014 q 0.42749977 -0.31049967 0.4994998 -1.0035 Z "/>
-        </symbol>
-        <symbol id="g43FC2516192D0F251704B273D511AB8" overflow="visible">
-            <path d="M 0 0m 1.3859999 5.49 v 0.9359999 h -0.7649999 v -0.9359999 h 0.7649999 Z m -0.7649999 -0.8369999 v -4.653 h 0.7649999 v 4.653 h -0.7649999 Z "/>
-        </symbol>
-        <symbol id="gD978DC9CC0B9AE918886416C8F39495D" overflow="visible">
-            <path d="M 0 0m 0.576 4.653 v -4.653 h 0.765 v 2.8979998 q 0 0.13499999 0.067499995 0.3375001 q 0.067499995 0.2025001 0.21599996 0.3915 q 0.14849997 0.18899989 0.38699996 0.32399988 q 0.23850012 0.13500023 0.57150006 0.13500023 q 0.26099992 0 0.4275 -0.07649994 q 0.16649985 -0.07650018 0.26549983 -0.21600008 q 0.09899998 -0.13950014 0.13950014 -0.32850003 q 0.040499926 -0.18900013 0.040499926 -0.41400003 v -3.0509999 h 0.76499987 v 2.8979998 q 0 0.5400002 0.32399988 0.8640001 q 0.32400036 0.32400012 0.8910003 0.32400012 q 0.2789998 0 0.45449972 -0.08100033 q 0.17549992 -0.08099985 0.27450037 -0.22049975 q 0.09899998 -0.13950014 0.13499975 -0.32850003 q 0.035999775 -0.18899989 0.035999775 -0.40499997 v -3.0509999 h 0.76500034 v 3.4109998 q 0 0.36000013 -0.11250019 0.6164999 q -0.112499714 0.25650024 -0.31500006 0.41849995 q -0.20249987 0.16200018 -0.48600006 0.23850012 q -0.28349972 0.07649994 -0.63449955 0.07649994 q -0.4590001 0 -0.8415003 -0.20699978 q -0.3824997 -0.20700026 -0.6164999 -0.58500004 q -0.14400005 0.43200016 -0.4949999 0.612 q -0.35100007 0.17999983 -0.783 0.17999983 q -0.98099995 0 -1.503 -0.7919998 h -0.017999887 v 0.684 h -0.72 Z "/>
-        </symbol>
-        <symbol id="gE14823C6D5887C5946C79D53BC50B1DF" overflow="visible">
-            <path d="M 0 0m 0.621 6.4259996 v -6.4259996 h 0.7649999 v 6.4259996 h -0.7649999 Z "/>
-        </symbol>
-        <symbol id="gCCF6F62EDE72A2783EDD776715FF2521" overflow="visible">
-            <path d="M 0 0m 1.5569999 3.3479998 v 2.358 h 1.674 q 0.72899985 0 1.0664997 -0.30150032 q 0.3375001 -0.30149984 0.3375001 -0.8774996 q 0 -0.5760002 -0.3375001 -0.8820002 q -0.33749986 -0.306 -1.0664997 -0.29699993 h -1.674 Z m -0.85499996 3.0779998 v -6.4259996 h 0.85499996 v 2.6279998 h 1.9619999 q 0.9719999 -0.0089998245 1.4715002 0.49500012 q 0.4994998 0.50399995 0.4994998 1.404 q 0 0.8999996 -0.4994998 1.3994999 q -0.49950027 0.4994998 -1.4715002 0.4994998 h -2.817 Z "/>
-        </symbol>
-        <symbol id="gBF6C7CC99FD9658A0BCA7C9307EFE887" overflow="visible">
-            <path d="M 0 0m 0.576 4.653 v -4.653 h 0.765 v 2.6279998 q 0 0.31500006 0.0855 0.5805001 q 0.0855 0.26549983 0.2565 0.46350002 q 0.171 0.19799995 0.4274999 0.306 q 0.2565 0.10800004 0.6075001 0.10800004 q 0.44099998 0 0.69299984 -0.2520001 q 0.2520001 -0.2520001 0.2520001 -0.684 v -3.1499999 h 0.7650001 v 3.06 q 0 0.37800002 -0.07649994 0.6884999 q -0.076500416 0.31050014 -0.26550007 0.53550005 q -0.18900013 0.2249999 -0.49500012 0.35099983 q -0.306 0.12599993 -0.76499987 0.12599993 q -1.0350001 0 -1.5120001 -0.84599996 h -0.017999887 v 0.73800015 h -0.72 Z "/>
-        </symbol>
-        <symbol id="g4C14CF88950BA583FF1F70F2AC32556F" overflow="visible">
-            <path d="M 0 0m 1.5569999 3.6629999 v 2.043 h 1.71 q 0.2789998 0 0.5265 -0.031499863 q 0.24749994 -0.03150034 0.43650007 -0.13950014 q 0.18899965 -0.10800028 0.29699993 -0.30600023 q 0.1079998 -0.19799995 0.1079998 -0.53999996 q 0 -0.513 -0.31949997 -0.7694998 q -0.31949997 -0.2565 -1.0484998 -0.2565 h -1.71 Z m -0.85499996 2.7629998 v -6.4259996 h 3.105 q 0.477 0 0.84150004 0.1575 q 0.36450005 0.1575 0.612 0.414 q 0.24749994 0.25649995 0.37349987 0.5894999 q 0.12599993 0.33300006 0.12599993 0.684 q 0 0.594 -0.31500006 1.008 q -0.31500006 0.41400003 -0.9089999 0.53999996 v 0.017999887 q 0.4590001 0.18000007 0.70650005 0.55349994 q 0.24749994 0.3735001 0.24749994 0.8865001 q 0 0.48600006 -0.22049999 0.81899977 q -0.22049999 0.33300018 -0.53550005 0.5220003 q -0.14400005 0.089999676 -0.34649992 0.13499975 q -0.20249987 0.045000076 -0.43650007 0.067500114 q -0.23399997 0.022500038 -0.47249985 0.02699995 q -0.23850012 0.0044999123 -0.44550014 0.0044999123 h -2.3309999 Z m 0.85499996 -5.706 v 2.2229998 h 1.9529998 q 0.26999998 0 0.52199984 -0.04949999 q 0.25200033 -0.04949999 0.44550037 -0.171 q 0.19350004 -0.121500015 0.31049967 -0.32850003 q 0.1170001 -0.20700002 0.1170001 -0.52199984 q 0 -0.5400001 -0.31949997 -0.8460001 q -0.31949997 -0.30599993 -0.8864999 -0.30599993 h -2.142 Z "/>
-        </symbol>
-        <symbol id="g87DCE9BAA18E83AE0AA9F4A317AAF534" overflow="visible">
-            <path d="M 0 0m 1.6379999 4.653 v 1.395 h -0.7649999 v -1.395 h -0.79199994 v -0.67499995 h 0.79199994 v -2.961 q 0 -0.324 0.06300002 -0.52199996 q 0.062999964 -0.19799998 0.19349992 -0.306 q 0.13050008 -0.107999995 0.342 -0.1485 q 0.21150005 -0.0405 0.5085 -0.0405 h 0.5849999 v 0.67499995 h -0.35099983 q -0.18000007 0 -0.29250002 0.013500035 q -0.11250007 0.013499975 -0.17550004 0.058499992 q -0.062999964 0.044999957 -0.0855 0.12599999 q -0.022500038 0.08099997 -0.022500038 0.21600002 v 2.889 h 0.9269999 v 0.67499995 h -0.9269999 Z "/>
-        </symbol>
-        <symbol id="g3EEFA5F67AA62934351B04ACAD7700B7" overflow="visible">
-            <path d="M 0 0m 5.832 2.3219998 v 4.104 h -0.855 v -4.104 q 0 -0.86399984 -0.42749977 -1.3094999 q -0.42750025 -0.44549996 -1.2465 -0.44549996 q -0.8640001 0 -1.3230001 0.44549996 q -0.459 0.44550002 -0.459 1.3094999 v 4.104 h -0.85499996 v -4.104 q 0 -1.2869998 0.69750005 -1.8764998 q 0.6974999 -0.58949995 1.9395 -0.58949995 q 1.2149997 0 1.8719997 0.61649996 q 0.65700006 0.6165 0.65700006 1.8494998 Z "/>
-        </symbol>
-        <symbol id="gC4452AF47A66FE705AB14D2AB364C607" overflow="visible">
-            <path d="M 0 0m 1.5569999 0.71999997 v 4.986 h 1.44 q 0.59399986 0 0.99899983 -0.16650009 q 0.4050002 -0.16650009 0.6615 -0.48600006 q 0.25649977 -0.31949997 0.36899996 -0.7739997 q 0.11250019 -0.4545002 0.11250019 -1.0305002 q 0 -0.59399986 -0.121500015 -1.0125 q -0.121500015 -0.41849983 -0.31050014 -0.6974999 q -0.18900013 -0.27899992 -0.42749977 -0.44099998 q -0.23850012 -0.16199994 -0.48150015 -0.24749994 q -0.24300003 -0.0855 -0.4590001 -0.10800004 q -0.21599984 -0.022499979 -0.3599999 -0.022499979 h -1.4219999 Z m -0.85499996 5.706 v -6.4259996 h 2.205 q 0.8010001 0 1.3859999 0.225 q 0.58500004 0.225 0.9629998 0.6524999 q 0.37800026 0.4275 0.5580001 1.053 q 0.1800003 0.6255001 0.1800003 1.4355 q 0 1.5479996 -0.8010001 2.3039997 q -0.8010001 0.75600004 -2.286 0.75600004 h -2.205 Z "/>
-        </symbol>
-        <symbol id="gD46906E080E9F801E0E94D1932E8451F" overflow="visible">
-            <path d="M 0 0m 1.0439999 1.4669999 h -0.7649999 q 0.018000007 -0.43199992 0.18 -0.73349994 q 0.162 -0.30149996 0.43199998 -0.48599994 q 0.26999992 -0.1845 0.621 -0.26549998 q 0.35099995 -0.08099999 0.73800004 -0.08099999 q 0.35099983 0 0.7064998 0.067499995 q 0.35549998 0.067499995 0.63899994 0.23849998 q 0.2835002 0.171 0.45899987 0.44999996 q 0.1755004 0.27900004 0.1755004 0.702 q 0 0.33299994 -0.13050032 0.55799997 q -0.13049984 0.22500002 -0.34199977 0.3735 q -0.21150017 0.14849997 -0.48600006 0.23849988 q -0.2744999 0.09000015 -0.5625 0.15300012 q -0.26999998 0.062999964 -0.53999996 0.121500015 q -0.26999998 0.05850005 -0.48599994 0.14400005 q -0.21600008 0.08549976 -0.35549998 0.21599984 q -0.13950002 0.13050008 -0.13950002 0.32850003 q 0 0.18000007 0.09000003 0.29250002 q 0.089999914 0.11249995 0.23399997 0.17999983 q 0.14399993 0.067499876 0.31949997 0.0945003 q 0.17550004 0.02699995 0.34650004 0.02699995 q 0.18899989 0 0.37349987 -0.040500164 q 0.18449998 -0.040500164 0.3375001 -0.13050008 q 0.15299988 -0.089999914 0.25199986 -0.23849988 q 0.09899998 -0.14849997 0.1170001 -0.37349987 h 0.76499987 q -0.02699995 0.42299986 -0.17999983 0.70650005 q -0.15300012 0.28349972 -0.40950012 0.4499998 q -0.2565 0.16650009 -0.58949995 0.23399973 q -0.33299994 0.067500114 -0.72899985 0.067500114 q -0.3060001 0 -0.6165 -0.07649994 q -0.31050003 -0.07649994 -0.558 -0.23399973 q -0.2475 -0.15750027 -0.40499997 -0.40950012 q -0.1575 -0.2520001 -0.1575 -0.6029999 q 0 -0.45000005 0.225 -0.70200014 q 0.22499996 -0.25199986 0.56249994 -0.3915 q 0.33749998 -0.1394999 0.7335 -0.21599984 q 0.3959999 -0.07650018 0.7335 -0.17100012 q 0.33749986 -0.094499946 0.5625 -0.24749994 q 0.2249999 -0.153 0.2249999 -0.44999993 q 0 -0.21600008 -0.10800004 -0.35550004 q -0.10800004 -0.13949996 -0.2744999 -0.21149999 q -0.16650009 -0.07199997 -0.36450005 -0.09899998 q -0.19799995 -0.02700001 -0.37800002 -0.02700001 q -0.23399997 0 -0.45449996 0.045000017 q -0.22049999 0.044999957 -0.3959999 0.14849997 q -0.17550004 0.10350001 -0.28350008 0.27900004 q -0.10799992 0.17549992 -0.116999984 0.4274999 Z "/>
-        </symbol>
-        <symbol id="gFB59D557F363E86096A9F4459DDFD8F3" overflow="visible">
-            <path d="M 0 0m 0.621 6.4259996 v -6.4259996 h 0.7649999 v 1.7639999 l 0.72 0.6659999 l 1.5929999 -2.4299998 h 0.9720001 l -1.98 2.961 l 1.8449998 1.6919999 h -1.026 l -2.1239998 -2.034 v 3.8069997 h -0.7649999 Z "/>
-        </symbol>
-        <symbol id="g75C1983CA166B2AED4C5CCCA97BF3B6A" overflow="visible">
-            <path d="M 0 0m 0.70199996 6.4259996 v -6.4259996 h 0.85499996 v 2.25 l 1.0709999 0.99899983 l 2.322 -3.2489998 h 1.0799999 l -2.817 3.8339999 l 2.709 2.5919998 h -1.1070004 l -3.2579997 -3.2039998 v 3.2039998 h -0.85499996 Z "/>
-        </symbol>
-        <symbol id="g7691E6040D648DC4C509121677FE43B4" overflow="visible">
-            <path d="M 0 0m 4.5899997 0.39599997 v 4.257 h -0.7199998 v -0.6660001 h -0.009000063 q -0.20700002 0.38699985 -0.576 0.5804999 q -0.36899996 0.19350004 -0.80999994 0.19350004 q -0.6029999 0 -1.017 -0.22949982 q -0.41400003 -0.22949982 -0.666 -0.58500004 q -0.25199997 -0.35549998 -0.35999995 -0.79200006 q -0.10799998 -0.43649983 -0.10799998 -0.85049987 q 0 -0.477 0.13049999 -0.9045 q 0.13049999 -0.42749995 0.39149997 -0.7469999 q 0.26100004 -0.3195 0.648 -0.5085 q 0.38699996 -0.189 0.9089999 -0.189 q 0.45000005 0 0.85049987 0.2025 q 0.40050006 0.20249999 0.5985 0.6344999 h 0.018000126 v -0.30599996 q 0 -0.38699996 -0.07649994 -0.71099997 q -0.07650018 -0.32399997 -0.24750018 -0.55349994 q -0.171 -0.22949994 -0.43199992 -0.36 q -0.26099992 -0.13049996 -0.63899994 -0.13049996 q -0.18899989 0 -0.3959999 0.040500045 q -0.20700002 0.040499926 -0.38250005 0.13049996 q -0.17550004 0.09000003 -0.29700005 0.23399997 q -0.121499896 0.144 -0.13049996 0.351 h -0.765 q 0.018000007 -0.37800002 0.19800001 -0.639 q 0.18 -0.26100004 0.45450002 -0.42299998 q 0.2745 -0.16199994 0.612 -0.23399997 q 0.33749998 -0.07200003 0.66149986 -0.07200003 q 1.1159999 0 1.638 0.56700003 q 0.52199984 0.5669999 0.52199984 1.7099998 Z m -2.1419997 0.22500002 q -0.37800002 0 -0.63 0.15749997 q -0.25199997 0.15750003 -0.40499997 0.41400003 q -0.153 0.2564999 -0.21600008 0.57149994 q -0.062999964 0.31500006 -0.062999964 0.6299999 q 0 0.33300018 0.07650006 0.63899994 q 0.07649994 0.306 0.24299991 0.5400002 q 0.16649997 0.23399997 0.4275 0.37349987 q 0.26100004 0.13950014 0.63 0.13950014 q 0.3599999 0 0.612 -0.14400005 q 0.25199986 -0.14400005 0.40949988 -0.38250017 q 0.15750003 -0.23849988 0.22950006 -0.5354998 q 0.07200003 -0.29699993 0.07200003 -0.6029999 q 0 -0.32400012 -0.07649994 -0.6480001 q -0.07650018 -0.324 -0.23850012 -0.5804999 q -0.16199994 -0.2565 -0.4275 -0.41400003 q -0.26549983 -0.15749997 -0.64349985 -0.15749997 Z "/>
-        </symbol>
-        <symbol id="g70A5EED08A4892697C9F8AF4CED29F38" overflow="visible">
-            <path d="M 0 0m 4.428 0 v 4.653 h -0.7650001 v -2.628 q 0 -0.31499994 -0.0855 -0.5804999 q -0.0855 -0.26550007 -0.2565 -0.46350002 q -0.171 -0.19799995 -0.4275 -0.306 q -0.2565 -0.10799998 -0.60749984 -0.10799998 q -0.4410001 0 -0.6930001 0.25199997 q -0.25199997 0.25200003 -0.25199997 0.68399996 v 3.15 h -0.765 v -3.06 q 0 -0.37800002 0.0765 -0.6885 q 0.0765 -0.31049997 0.2655 -0.53549993 q 0.18900001 -0.225 0.495 -0.34649998 q 0.306 -0.12149999 0.765 -0.12149999 q 0.513 0 0.8909998 0.20249999 q 0.37800002 0.2025 0.62100005 0.63449997 h 0.018000126 v -0.738 h 0.72 Z "/>
-        </symbol>
-        <symbol id="g81941A84CFD7B2E6E64D490082E56BB7" overflow="visible">
-            <path d="M 0 0m 0.603 6.4259996 v -6.4259996 h 0.7649999 v 0.621 h 0.018000007 q 0.12600005 -0.20700002 0.31050003 -0.3465 q 0.18449998 -0.13949999 0.39149988 -0.22049999 q 0.20700002 -0.081 0.41850019 -0.11699999 q 0.21149993 -0.036 0.38249993 -0.036 q 0.5309999 0 0.93149996 0.18899998 q 0.40049982 0.18899998 0.6659999 0.5175 q 0.26550007 0.32850003 0.3959999 0.7695 q 0.13050032 0.44099998 0.13050032 0.936 q 0 0.4949999 -0.13500023 0.9359999 q -0.13499975 0.44099998 -0.40049982 0.77849984 q -0.26550007 0.3375001 -0.6660001 0.53550005 q -0.40050006 0.19799995 -0.9405 0.19799995 q -0.48599982 0 -0.8909999 -0.17549992 q -0.40499997 -0.17549992 -0.594 -0.5625 h -0.018000007 v 2.4029999 h -0.7649999 Z m 3.5999997 -4.059 q 0 -0.342 -0.07199955 -0.6659999 q -0.07200003 -0.324 -0.2340002 -0.576 q -0.16199994 -0.25200003 -0.4275 -0.40500003 q -0.26550007 -0.153 -0.6615 -0.153 q -0.3959999 0 -0.67499995 0.14850003 q -0.27899992 0.14849997 -0.45449996 0.3915 q -0.17550004 0.24299991 -0.2565 0.5624999 q -0.08099997 0.3195001 -0.08099997 0.6615 q 0 0.32400012 0.07649994 0.63899994 q 0.07650006 0.31500006 0.24750006 0.5625 q 0.171 0.24749994 0.44099998 0.40050006 q 0.26999998 0.15300012 0.6569998 0.15300012 q 0.3690002 0 0.6435001 -0.14400005 q 0.2744999 -0.14400005 0.45000005 -0.38700008 q 0.17549968 -0.24300003 0.26099992 -0.55349994 q 0.08549976 -0.3104999 0.08549976 -0.6345 Z "/>
-        </symbol>
-        <symbol id="g5E7F3EDE6694ACAB83B07765FD7C88CC" overflow="visible">
-            <path d="M 0 0m 2.1599998 5.706 v -5.706 h 0.855 v 5.706 h 2.1419997 v 0.7199998 h -5.1389995 v -0.7199998 h 2.142 Z "/>
-        </symbol>
-        <symbol id="g73CBF4CE1C6B6F76004C71E0D960877F" overflow="visible">
-            <path d="M 0 0m 0.891 3.978 v -3.978 h 0.7649999 v 3.978 h 0.9000001 v 0.67499995 h -0.9000001 v 0.64799976 q 0 0.30600023 0.153 0.41400003 q 0.153 0.10800028 0.43200004 0.10800028 q 0.09899998 0 0.21599984 -0.013500214 q 0.1170001 -0.013500214 0.21600008 -0.04949999 v 0.6659999 q -0.10800004 0.03600025 -0.24749994 0.0539999 q -0.1394999 0.018000126 -0.24749994 0.018000126 q -0.63 0 -0.9585 -0.29250002 q -0.32849997 -0.29250002 -0.32849997 -0.85949993 v -0.69299984 h -0.783 v -0.67499995 h 0.783 Z "/>
-        </symbol>
-        <symbol id="gAA9BA5DCE3B7BAD11A37A99523970BA1" overflow="visible">
-            <path d="M 0 0m 3.7259998 4.752 h 0.76499987 q -0.07200003 0.7919998 -0.53999996 1.2104998 q -0.46799994 0.41849995 -1.2599998 0.41849995 q -0.684 0 -1.1340001 -0.28799963 q -0.44999993 -0.2880001 -0.71999997 -0.76500034 q -0.26999998 -0.47699976 -0.38249996 -1.0934997 q -0.11250001 -0.61650014 -0.11250001 -1.2735 q 0 -0.5040002 0.0765 -1.044 q 0.0765 -0.53999996 0.3105 -0.98999995 q 0.23399997 -0.45000002 0.666 -0.738 q 0.43199992 -0.288 1.1429999 -0.288 q 0.6029999 0 1.0125 0.20249999 q 0.40949988 0.2025 0.65700006 0.51299995 q 0.24749994 0.31050003 0.35549974 0.6885 q 0.10800028 0.37800002 0.10800028 0.729 q 0 0.44099998 -0.13500023 0.819 q -0.13499975 0.37800002 -0.38250017 0.6569998 q -0.2474997 0.27900004 -0.61199975 0.43650007 q -0.36450005 0.15749979 -0.8234999 0.15749979 q -0.5220001 0 -0.9225 -0.19799972 q -0.40049994 -0.19799995 -0.6704999 -0.63899994 l -0.018000007 0.017999887 q 0.008999944 0.36899996 0.07199991 0.7919998 q 0.06300008 0.42300034 0.22950006 0.7874999 q 0.16649997 0.36450005 0.46350002 0.60300016 q 0.29699993 0.23850012 0.783 0.23850012 q 0.45899987 0 0.7379999 -0.26100016 q 0.27900004 -0.26099968 0.33299994 -0.69299984 Z m -1.152 -1.323 q 0.32399988 0 0.5669999 -0.1170001 q 0.24300003 -0.116999865 0.40499997 -0.3104999 q 0.16200018 -0.19350004 0.23850012 -0.4590001 q 0.07649994 -0.26549983 0.07649994 -0.5624999 q 0 -0.27899992 -0.0855 -0.53549993 q -0.0855 -0.2565 -0.24749994 -0.45450002 q -0.16199994 -0.19800001 -0.40050006 -0.31049997 q -0.23849988 -0.11250001 -0.55349994 -0.11250001 q -0.31500006 0 -0.5625 0.11250001 q -0.24749994 0.11249995 -0.41399992 0.30149996 q -0.16649997 0.18900001 -0.2565 0.45000005 q -0.09000003 0.26099992 -0.09000003 0.55799997 q 0 0.29700005 0.0855 0.5624999 q 0.0855 0.26550007 0.2565 0.4590001 q 0.171 0.1934998 0.41400003 0.306 q 0.24300003 0.11249995 0.5669999 0.11249995 Z "/>
-        </symbol>
-        <symbol id="g170E3DF111F34A5B640D30A3D024062D" overflow="visible">
-            <path d="M 0 0m 3.0509999 2.169 h -2.142 l 2.1239998 3.123 h 0.018000126 v -3.123 Z m 0.72 0 v 4.212 h -0.612 l -2.907 -4.1489997 v -0.7379999 h 2.7989998 v -1.494 h 0.72 v 1.494 h 0.86399984 v 0.67499995 h -0.86399984 Z "/>
-        </symbol>
-        <symbol id="g825BFEEBA88E24CB932EEEE0C5250EC" overflow="visible">
-            <path d="M 0 0m 1.9619999 3.6449997 v -0.64799976 q 0.21600008 0.02699995 0.4590001 0.02699995 q 0.28799987 0 0.5354998 -0.07649994 q 0.24749994 -0.07650018 0.4275 -0.2340002 q 0.18000007 -0.15749979 0.2880001 -0.38699985 q 0.1079998 -0.22950006 0.1079998 -0.5265 q 0 -0.288 -0.11249995 -0.51750004 q -0.11249995 -0.22949994 -0.30149984 -0.38699996 q -0.18900013 -0.15749997 -0.44099998 -0.24299997 q -0.2520001 -0.0855 -0.53100014 -0.0855 q -0.65699995 0 -0.99899983 0.3915 q -0.342 0.39149994 -0.36 1.0125 h -0.765 q -0.009000003 -0.495 0.13949999 -0.88199997 q 0.1485 -0.38700002 0.42749998 -0.65250003 q 0.27899998 -0.2655 0.675 -0.4005 q 0.3959999 -0.13499999 0.88199985 -0.13499999 q 0.45000005 0 0.8505001 0.12149999 q 0.40049982 0.12149999 0.6975 0.3645 q 0.29699993 0.243 0.47249985 0.60749996 q 0.17549992 0.3645 0.17549992 0.8415 q 0 0.576 -0.28349972 0.99899983 q -0.2835002 0.4230001 -0.8685 0.549 v 0.018000126 q 0.37799978 0.171 0.6299999 0.50399995 q 0.25199986 0.33299994 0.25199986 0.7650001 q 0 0.44099998 -0.14849997 0.76499987 q -0.14849997 0.32399988 -0.40949988 0.53099966 q -0.26099992 0.20700026 -0.6164999 0.31050014 q -0.35549998 0.10349989 -0.7695 0.10349989 q -0.477 0 -0.84150004 -0.15299988 q -0.36449993 -0.15299988 -0.6074999 -0.42299986 q -0.24300003 -0.26999998 -0.3735 -0.64800024 q -0.13050002 -0.37799978 -0.14850003 -0.8369999 h 0.765 q 0 0.27900028 0.07200003 0.53100014 q 0.07199991 0.25199986 0.22049999 0.44099998 q 0.14849997 0.18900013 0.3779999 0.30149984 q 0.22950006 0.11250019 0.53550005 0.11250019 q 0.48600006 0 0.80999994 -0.25650024 q 0.32399988 -0.25649977 0.32399988 -0.7694998 q 0 -0.25199986 -0.09899998 -0.4499998 q -0.09899998 -0.19800043 -0.26549983 -0.32850027 q -0.16650009 -0.13049984 -0.38700008 -0.19799995 q -0.22049999 -0.067499876 -0.46350002 -0.067499876 h -0.16199994 q -0.045000076 0 -0.089999914 0 q -0.036000013 0 -0.08100009 0.0089998245 Z "/>
-        </symbol>
-        <symbol id="g48F95159F05E08FF24029F09E94D9EBD" overflow="visible">
-            <path d="M 0 0m 0.39599997 4.1219997 h 0.7649999 q -0.008999944 0.2880001 0.05850005 0.5714998 q 0.067499995 0.2835002 0.22049999 0.5085001 q 0.153 0.2249999 0.3915 0.36450005 q 0.2385 0.13950014 0.57149994 0.13950014 q 0.2520001 0 0.477 -0.08100033 q 0.2249999 -0.08099985 0.3915 -0.23399973 q 0.16650009 -0.15299988 0.26550007 -0.36450005 q 0.09899998 -0.21150017 0.09899998 -0.47249985 q 0 -0.33300018 -0.10350013 -0.58500004 q -0.10349989 -0.2520001 -0.306 -0.46799994 q -0.20249987 -0.21600008 -0.50849986 -0.4275 q -0.306 -0.21149993 -0.71099997 -0.46350002 q -0.33300006 -0.19799995 -0.63900006 -0.4230001 q -0.306 -0.2249999 -0.54899997 -0.52199984 q -0.24299997 -0.29700005 -0.40049997 -0.6975 q -0.1575 -0.4005 -0.20249999 -0.9675 h 4.167 v 0.67499995 h -3.276 q 0.0539999 0.297 0.22949994 0.5265 q 0.17550004 0.22950006 0.42299998 0.4275 q 0.24750006 0.19799995 0.5445 0.37349987 q 0.29699993 0.17550015 0.59399986 0.35549998 q 0.29700017 0.18900013 0.576 0.39600015 q 0.27900004 0.20700002 0.49500012 0.46350002 q 0.21600008 0.25649977 0.34649992 0.5804999 q 0.13049984 0.32399988 0.13049984 0.74699974 q 0 0.4500003 -0.15749979 0.7920003 q -0.15749979 0.342 -0.4275 0.5714998 q -0.26999998 0.22949982 -0.6345 0.35099983 q -0.3644998 0.121500015 -0.77849984 0.121500015 q -0.50400007 0 -0.9 -0.171 q -0.39600003 -0.171 -0.66150004 -0.47249985 q -0.26549995 -0.30149984 -0.39149997 -0.7154999 q -0.12599999 -0.41400003 -0.09900001 -0.9000001 Z "/>
-        </symbol>
-        <symbol id="gF70B1EB6DF5EEB5418258DA74EF6450A" overflow="visible">
-            <path d="M 0 0m 1.1969999 3.2129998 q 0 0.48600006 0.12600005 0.9584999 q 0.12599993 0.47249985 0.39600003 0.8505001 q 0.26999998 0.37799978 0.69299996 0.6075001 q 0.42299986 0.22949982 1.0079999 0.22949982 q 0.5849998 0 1.0080001 -0.22949982 q 0.42299986 -0.2295003 0.69299984 -0.6075001 q 0.26999998 -0.37800026 0.3959999 -0.8505001 q 0.12599993 -0.47249985 0.12599993 -0.9584999 q 0 -0.48599982 -0.12599993 -0.9584999 q -0.12599993 -0.47249997 -0.3959999 -0.8505 q -0.26999998 -0.37800002 -0.69299984 -0.60749996 q -0.42300034 -0.2295 -1.0080001 -0.2295 q -0.58500004 0 -1.0079999 0.2295 q -0.42299998 0.22949994 -0.69299996 0.60749996 q -0.2700001 0.37800002 -0.39600003 0.8505 q -0.12600005 0.4725001 -0.12600005 0.9584999 Z m -0.8549999 0 q 0 -0.6569998 0.19350001 -1.2644999 q 0.19349998 -0.60749996 0.58049995 -1.0755 q 0.38699996 -0.468 0.96300006 -0.74249995 q 0.576 -0.27449998 1.3409998 -0.27449998 q 0.7650001 0 1.3409998 0.27449998 q 0.5760002 0.27449998 0.9630003 0.74249995 q 0.3869996 0.468 0.58049965 1.0755 q 0.19350004 0.6075001 0.19350004 1.2644999 q 0 0.65700006 -0.19350004 1.2645001 q -0.19350004 0.6074996 -0.58049965 1.0755 q -0.38700008 0.46799994 -0.9630003 0.74699974 q -0.57599974 0.2789998 -1.3409998 0.2789998 q -0.76499987 0 -1.3409998 -0.2789998 q -0.5760001 -0.2789998 -0.96300006 -0.74699974 q -0.38699996 -0.4680004 -0.58049995 -1.0755 q -0.19350001 -0.6075001 -0.19350001 -1.2645001 Z "/>
-        </symbol>
-        <symbol id="gCE9C5FDCB0FB9D903B0471E1194A86FD" overflow="visible">
-            <path d="M 0 0m 0.69299996 6.4259996 v -6.4259996 h 0.80999994 v 5.1569996 h 0.018000007 l 3.3569999 -5.1569996 h 0.9359999 v 6.4259996 h -0.80999994 v -5.2109995 h -0.018000126 l -3.3839998 5.2109995 h -0.9089999 Z "/>
-        </symbol>
-        <symbol id="g59D5A1C590864C9D7659EE9E44D8B385" overflow="visible">
-            <path d="M 0 0m 3.2039998 0 v 6.3809996 h -0.5849998 q -0.062999964 -0.35999966 -0.23399997 -0.59399986 q -0.171 -0.23399973 -0.41850007 -0.36899996 q -0.24749994 -0.13499975 -0.55349994 -0.18449974 q -0.306 -0.04949999 -0.63 -0.04949999 v -0.612 h 1.6559999 v -4.572 h 0.76499987 Z "/>
-        </symbol>
-        <symbol id="gBB143EC3C95E2D7D22714C2C87E91ED" overflow="visible">
-            <path d="M 0 0m 4.23 5.5979996 v 0.6750002 h -3.15 l -0.594 -3.3119998 l 0.65700006 -0.036000013 q 0.2249999 0.26999998 0.5174999 0.43649983 q 0.29250002 0.16650009 0.6704999 0.16650009 q 0.32400012 0 0.58949995 -0.10800004 q 0.26550007 -0.10800004 0.45449996 -0.30150008 q 0.18900013 -0.1934998 0.29250002 -0.45899987 q 0.10350013 -0.26550007 0.10350013 -0.5804999 q 0 -0.37800002 -0.10800004 -0.6615001 q -0.10800004 -0.28349996 -0.29250002 -0.47249997 q -0.18449998 -0.18899995 -0.43199992 -0.28349996 q -0.24749994 -0.094500005 -0.5174999 -0.094500005 q -0.2880001 0 -0.5265001 0.0855 q -0.2385 0.0855 -0.41399992 0.24299997 q -0.17550004 0.15750003 -0.27900004 0.36899996 q -0.10350001 0.21150005 -0.121500015 0.45450008 h -0.7649999 q 0.009000003 -0.43200004 0.17099997 -0.77400005 q 0.16200003 -0.34199995 0.441 -0.57149994 q 0.27899998 -0.2295 0.6434999 -0.35099998 q 0.36450005 -0.12149999 0.7785001 -0.12149999 q 0.55799985 0 0.9764998 0.17549999 q 0.41850019 0.17549998 0.6975 0.47249997 q 0.27900028 0.297 0.41849995 0.6794999 q 0.13950014 0.38250005 0.13950014 0.7874999 q 0 0.549 -0.16200018 0.95850015 q -0.1619997 0.40949988 -0.44099975 0.684 q -0.27900004 0.2744999 -0.65700006 0.40949988 q -0.37800002 0.13499975 -0.8009999 0.13499975 q -0.32400012 0 -0.65250003 -0.112499714 q -0.32850003 -0.11249995 -0.53550005 -0.34649992 l -0.018000007 0.017999887 l 0.342 1.8359997 h 2.5740001 Z "/>
-        </symbol>
-        <symbol id="gA590B7DC033E470D6BAF5CDFC85B2050" overflow="visible">
-            <path d="M 0 0m 1.608 2.3600001 l 0.9680002 2.664 h 0.015999794 l 0.95200014 -2.664 h -1.9360001 Z m 0.5680001 3.3520002 l -2.2240002 -5.7120004 h 0.776 l 0.64 1.72 h 2.4160001 l 0.62399983 -1.72 h 0.84000015 l -2.232 5.7120004 h -0.8399999 Z "/>
-        </symbol>
-        <symbol id="g8B593199FA06CCE05316E9DE69A76C04" overflow="visible">
-            <path d="M 0 0m 0.48800004 4.136 v -4.136 h 0.68000007 v 1.84 q 0 0.39999998 0.07999992 0.70800006 q 0.08000004 0.3080001 0.25600004 0.5239999 q 0.176 0.21600008 0.464 0.32800007 q 0.288 0.11199999 0.696 0.11199999 v 0.72000027 q -0.55200005 0.015999794 -0.91199994 -0.22399998 q -0.36 -0.24000025 -0.60800004 -0.7440002 h -0.016000032 v 0.872 h -0.64 Z "/>
-        </symbol>
-        <symbol id="g77DE0CDDDA90F97D0E6338DF2ADA2B05" overflow="visible">
-            <path d="M 0 0m 1.008 2.0640001 q 0 0.37599993 0.100000024 0.668 q 0.100000024 0.29200006 0.27600002 0.4920001 q 0.176 0.20000005 0.41200006 0.3039999 q 0.23599994 0.10400009 0.49999988 0.10400009 q 0.26400018 0 0.50000024 -0.10400009 q 0.23599982 -0.10399985 0.41199994 -0.3039999 q 0.17599988 -0.20000005 0.27600002 -0.4920001 q 0.099999905 -0.29200006 0.099999905 -0.668 q 0 -0.37600005 -0.099999905 -0.6680001 q -0.10000014 -0.29199994 -0.27600002 -0.48799998 q -0.17600012 -0.19600004 -0.41199994 -0.3 q -0.23600006 -0.10400003 -0.50000024 -0.10400003 q -0.26399994 0 -0.49999988 0.10400003 q -0.23600006 0.10399997 -0.41200006 0.3 q -0.176 0.19600004 -0.27600002 0.48799998 q -0.100000024 0.29200006 -0.100000024 0.6680001 Z m -0.72 0 q 0 -0.4560001 0.12799999 -0.84800005 q 0.12800002 -0.39200002 0.384 -0.6840001 q 0.25599998 -0.292 0.632 -0.456 q 0.37600005 -0.164 0.86399996 -0.164 q 0.49600005 0 0.86800003 0.164 q 0.37200022 0.164 0.62800026 0.456 q 0.25600004 0.29200006 0.38399982 0.6840001 q 0.12800026 0.39199996 0.12800026 0.84800005 q 0 0.4560001 -0.12800026 0.852 q -0.12799978 0.39600015 -0.38399982 0.68799996 q -0.25600004 0.29200006 -0.62800026 0.46000004 q -0.37199998 0.16800022 -0.86800003 0.16800022 q -0.48799992 0 -0.86399996 -0.16800022 q -0.37600005 -0.16799998 -0.632 -0.46000004 q -0.25599998 -0.29199982 -0.384 -0.68799996 q -0.12799999 -0.3959999 -0.12799999 -0.852 Z "/>
-        </symbol>
-        <symbol id="gDAB705390D499B70C1CEEA1CADFAB46C" overflow="visible">
-            <path d="M 0 0m 4.6080003 0 l 1.3200002 4.136 h -0.704 l -0.92800045 -3.384 h -0.015999794 l -0.8640001 3.384 h -0.74399996 l -0.83200014 -3.384 h -0.015999913 l -0.93600005 3.384 h -0.7520001 l 1.3280001 -4.136 h 0.73599994 l 0.832 3.288 h 0.016000032 l 0.84000015 -3.288 h 0.72 Z "/>
-        </symbol>
-        <symbol id="g5BA2C50E2FB253176C23A29D28811B37" overflow="visible">
-            <path d="M 0 0m 0.92800003 1.304 h -0.68 q 0.015999988 -0.384 0.16000001 -0.652 q 0.14400002 -0.268 0.38400003 -0.43199998 q 0.24000001 -0.164 0.55200005 -0.23600002 q 0.31200004 -0.072000004 0.6559999 -0.072000004 q 0.31200004 0 0.628 0.060000006 q 0.31600022 0.060000002 0.5680001 0.21200001 q 0.2520001 0.15200001 0.408 0.40000004 q 0.15600014 0.24799997 0.15600014 0.624 q 0 0.296 -0.11599994 0.49600005 q -0.116000175 0.19999993 -0.30400014 0.3319999 q -0.18799996 0.13200021 -0.43199992 0.21200013 q -0.2440002 0.07999992 -0.5 0.13599992 q -0.24000001 0.055999994 -0.48000014 0.10800004 q -0.24000001 0.052000046 -0.43200004 0.12800002 q -0.19200003 0.075999975 -0.31599998 0.19199991 q -0.12400007 0.116000175 -0.12400007 0.29200006 q 0 0.16000009 0.08000004 0.26 q 0.08000004 0.10000014 0.20800006 0.16000009 q 0.12800002 0.059999943 0.28399992 0.08400011 q 0.15600002 0.02399993 0.3080001 0.02399993 q 0.16799998 0 0.33200002 -0.036000013 q 0.16400003 -0.036000013 0.29999995 -0.11599994 q 0.13600016 -0.08000016 0.22399998 -0.21200013 q 0.08800006 -0.13199997 0.10400009 -0.33200002 h 0.68000007 q -0.02399993 0.37600017 -0.16000009 0.628 q -0.13599992 0.2520001 -0.36400008 0.4000001 q -0.22799993 0.14799976 -0.5239999 0.20800018 q -0.296 0.059999943 -0.648 0.059999943 q -0.27200007 0 -0.5480001 -0.06800032 q -0.27600002 -0.06799984 -0.496 -0.20799994 q -0.21999997 -0.13999987 -0.36 -0.36399984 q -0.13999999 -0.22399998 -0.13999999 -0.536 q 0 -0.4000001 0.19999999 -0.6240001 q 0.20000005 -0.22399998 0.5 -0.34800005 q 0.30000007 -0.12400007 0.65200007 -0.19200003 q 0.35200012 -0.06799996 0.65200007 -0.15199995 q 0.29999995 -0.08399999 0.5 -0.22000003 q 0.20000005 -0.13600004 0.20000005 -0.4000001 q 0 -0.19199997 -0.095999956 -0.31599998 q -0.096000195 -0.12400001 -0.2440002 -0.18799996 q -0.148 -0.06400001 -0.32399988 -0.08800006 q -0.17600012 -0.023999989 -0.33599997 -0.023999989 q -0.20800006 0 -0.40400016 0.04000002 q -0.19599998 0.04000002 -0.352 0.13200003 q -0.15600002 0.09199995 -0.25199997 0.24799997 q -0.096000016 0.15600002 -0.10400003 0.38 Z "/>
-        </symbol>
-        <symbol id="g900615605685504312176826BFAA7CD0" overflow="visible">
-            <path d="M 0 0m 0.536 4.136 v -5.7120004 h 0.68000007 v 2.1280003 h 0.016000032 q 0.11199999 -0.18400002 0.2759999 -0.30800003 q 0.16400003 -0.12400001 0.34800005 -0.19600001 q 0.18400013 -0.072 0.3720001 -0.104 q 0.18799996 -0.032000005 0.3399999 -0.032000005 q 0.47200012 0 0.82800007 0.16800001 q 0.35599995 0.16800001 0.592 0.46 q 0.23599982 0.292 0.352 0.6840001 q 0.116000175 0.39199996 0.116000175 0.8319999 q 0 0.44000006 -0.119999886 0.83200026 q -0.12000036 0.39199996 -0.35600019 0.6919999 q -0.23600006 0.29999995 -0.592 0.47600007 q -0.35600019 0.17600012 -0.8360002 0.17600012 q -0.43199992 0 -0.79199994 -0.15600014 q -0.36 -0.15600014 -0.528 -0.5 h -0.016000032 v 0.55999994 h -0.68000007 Z m 3.2 -2.032 q 0 -0.30400002 -0.06399989 -0.592 q -0.06399989 -0.288 -0.20799994 -0.5120001 q -0.14400005 -0.22399998 -0.3800001 -0.35999995 q -0.23600006 -0.13600004 -0.58800006 -0.13600004 q -0.352 0 -0.5999999 0.13200003 q -0.24800003 0.13199997 -0.40400004 0.348 q -0.15600002 0.21600002 -0.22800004 0.50000006 q -0.07200003 0.28400004 -0.07200003 0.58799994 q 0 0.2880001 0.06800008 0.5680001 q 0.06799996 0.27999997 0.21999991 0.5 q 0.15200007 0.22000003 0.39200008 0.35599995 q 0.23999989 0.13600016 0.584 0.13600016 q 0.32800007 0 0.572 -0.12800002 q 0.24399996 -0.12800002 0.4000001 -0.3440001 q 0.1559999 -0.21599984 0.23199987 -0.49199986 q 0.075999975 -0.27600002 0.075999975 -0.5640001 Z "/>
-        </symbol>
-        <symbol id="g924EAF2D52C629B054774FEED87B1A3" overflow="visible">
-            <path d="M 0 0m 1.2320001 4.88 v 0.83200026 h -0.68000007 v -0.83200026 h 0.68000007 Z m -0.68000007 -0.74399996 v -4.136 h 0.68000007 v 4.136 h -0.68000007 Z "/>
-        </symbol>
-        <symbol id="g140CE90B08CDC407F2943E5829DFF5DD" overflow="visible">
-            <path d="M 0 0m 0.512 4.136 v -4.136 h 0.68 v 2.3360002 q 0 0.27999997 0.075999975 0.51600003 q 0.076000094 0.23599982 0.22800004 0.41199994 q 0.15200007 0.17599988 0.38 0.27200007 q 0.22800004 0.095999956 0.5400001 0.095999956 q 0.39199996 0 0.61599994 -0.22399998 q 0.22399998 -0.22399998 0.22399998 -0.60800004 v -2.8000002 h 0.68000007 v 2.72 q 0 0.3360002 -0.06799984 0.6120002 q -0.06800008 0.27600002 -0.23600006 0.47599983 q -0.16799998 0.20000029 -0.44000006 0.31200027 q -0.27200007 0.11199999 -0.68000007 0.11199999 q -0.91999996 0 -1.344 -0.7520001 h -0.016000032 v 0.6559999 h -0.64000005 Z "/>
-        </symbol>
-        <symbol id="gFC264C0FD775885BC630DFC00D9E2FE7" overflow="visible">
-            <path d="M 0 0m 1.4560001 4.136 v 1.2400002 h -0.68000007 v -1.2400002 h -0.704 v -0.5999999 h 0.704 v -2.6320002 q 0 -0.288 0.055999994 -0.46400002 q 0.056000054 -0.17600003 0.17200005 -0.272 q 0.11599994 -0.09600001 0.30400002 -0.13200001 q 0.18799996 -0.036000002 0.45200002 -0.036000002 h 0.5200001 v 0.6 h -0.31200016 q -0.15999997 0 -0.26 0.012000024 q -0.100000024 0.011999965 -0.15600002 0.051999986 q -0.055999994 0.04000002 -0.075999975 0.11199999 q -0.01999998 0.07200003 -0.01999998 0.19200003 v 2.5680003 h 0.8240001 v 0.5999999 h -0.8240001 Z "/>
-        </symbol>
-        <symbol id="gEF2A2A1EFDC1817766F824B6B7E6A1" overflow="visible">
-            <path d="M 0 0m 0.79200006 3.5360003 v -3.5360003 h 0.68000007 v 3.5360003 h 0.79999995 v 0.5999999 h -0.79999995 v 0.5760002 q 0 0.27199984 0.13599992 0.36800003 q 0.13600004 0.09599972 0.38400006 0.09599972 q 0.08800006 0 0.19199991 -0.012000084 q 0.10400009 -0.011999607 0.19200015 -0.043999672 v 0.592 q -0.095999956 0.032000065 -0.22000003 0.04799986 q -0.12400007 0.01600027 -0.22000003 0.01600027 q -0.56000006 0 -0.852 -0.26000023 q -0.29200006 -0.26000023 -0.29200006 -0.76399994 v -0.6160002 h -0.69600004 v -0.5999999 h 0.69600004 Z "/>
-        </symbol>
-        <symbol id="gA5BD779142255ABB4257B527699904C3" overflow="visible">
-            <path d="M 0 0m 0.512 4.136 v -4.136 h 0.68 v 2.5760002 q 0 0.119999886 0.060000062 0.29999995 q 0.059999943 0.18000007 0.19200003 0.34800005 q 0.13199997 0.16799998 0.34399998 0.28799987 q 0.2119999 0.120000124 0.5079999 0.120000124 q 0.23200011 0 0.3800001 -0.06800008 q 0.148 -0.06800008 0.23600006 -0.19199991 q 0.08800006 -0.12400007 0.12400007 -0.29200006 q 0.035999775 -0.16799998 0.035999775 -0.36800003 v -2.7120001 h 0.68000007 v 2.5760002 q 0 0.48000002 0.28799987 0.7679999 q 0.2880001 0.2880001 0.7920003 0.2880001 q 0.24800014 0 0.4039998 -0.07200003 q 0.15600014 -0.07200003 0.24400043 -0.1960001 q 0.08799982 -0.123999834 0.119999886 -0.29200006 q 0.032000065 -0.16799998 0.032000065 -0.3599999 v -2.7120001 h 0.6799998 v 3.032 q 0 0.32000017 -0.099999905 0.5480001 q -0.099999905 0.22799993 -0.2800002 0.37199998 q -0.17999983 0.14400005 -0.43199968 0.2119999 q -0.25200033 0.06800032 -0.5640001 0.06800032 q -0.408 0 -0.74800014 -0.18400002 q -0.3399999 -0.18400025 -0.5480001 -0.5200002 q -0.12800002 0.38400006 -0.44000006 0.5439999 q -0.3119998 0.16000032 -0.69599986 0.16000032 q -0.8720001 0 -1.3360001 -0.70400023 h -0.016000032 v 0.60800004 h -0.64000005 Z "/>
-        </symbol>
-        <symbol id="gE037EFFB7D6AFF5A7E0FD7AFE38271D9" overflow="visible">
-            <path d="M 0 0m 3.384 2.4640002 h -2.376 q 0.016000032 0.24000001 0.10400009 0.4519999 q 0.08799994 0.21200013 0.24000001 0.37199998 q 0.15199995 0.16000009 0.36399996 0.2520001 q 0.21200001 0.09200001 0.47600007 0.09200001 q 0.25600004 0 0.46799994 -0.09200001 q 0.21200013 -0.09200001 0.36800003 -0.24800014 q 0.15600014 -0.1559999 0.24800014 -0.37199998 q 0.09200001 -0.21599984 0.1079998 -0.45599985 Z m 0.6559999 -1.1520002 h -0.6719997 q -0.08800006 -0.408 -0.36400008 -0.608 q -0.27600002 -0.20000005 -0.7080002 -0.20000005 q -0.33599997 0 -0.5839999 0.11200005 q -0.24800003 0.11199999 -0.4080001 0.3 q -0.15999997 0.18800002 -0.232 0.43199998 q -0.07200003 0.24400008 -0.06400001 0.51600003 h 3.0960002 q 0.01600027 0.37599993 -0.06799984 0.79200006 q -0.08400011 0.4159999 -0.30400014 0.7680001 q -0.22000003 0.352 -0.5839999 0.5799999 q -0.36400008 0.22800016 -0.9160001 0.22800016 q -0.42400002 0 -0.7800001 -0.16000032 q -0.35599995 -0.15999985 -0.616 -0.44799995 q -0.26 -0.28799987 -0.404 -0.6799998 q -0.144 -0.3920002 -0.144 -0.8640001 q 0.016000003 -0.47200012 0.14000002 -0.8720001 q 0.12400001 -0.40000004 0.37199998 -0.688 q 0.24800009 -0.28800005 0.61200005 -0.44800004 q 0.36400008 -0.16000001 0.86 -0.16000001 q 0.704 0 1.168 0.352 q 0.46400023 0.35200006 0.5999999 1.0480001 Z "/>
-        </symbol>
-        <symbol id="gEBC5194FC1C7A48F06C53C940408D757" overflow="visible">
-            <path d="M 0 0m 3.3200002 2.808 h 0.704 q -0.03999996 0.36800003 -0.19199991 0.63600016 q -0.15200019 0.2679999 -0.388 0.444 q -0.23600006 0.17599988 -0.54400015 0.26 q -0.3080001 0.08400011 -0.6600001 0.08400011 q -0.48799992 0 -0.85599995 -0.17199993 q -0.36800003 -0.17200017 -0.61200005 -0.47200036 q -0.24400002 -0.29999995 -0.364 -0.704 q -0.120000005 -0.40400004 -0.120000005 -0.86800003 q 0 -0.464 0.12400001 -0.852 q 0.12399998 -0.388 0.368 -0.668 q 0.24400002 -0.28000003 0.608 -0.432 q 0.36400008 -0.15200001 0.8360002 -0.15200001 q 0.7919998 0 1.2519999 0.416 q 0.46000004 0.416 0.57200027 1.184 h -0.6960001 q -0.06400013 -0.48000002 -0.34800005 -0.7440001 q -0.28400016 -0.264 -0.7880001 -0.264 q -0.31999993 0 -0.55200005 0.12800002 q -0.232 0.12800002 -0.37599993 0.34000003 q -0.14400005 0.21199995 -0.21200001 0.48400003 q -0.06800008 0.27199996 -0.06800008 0.55999994 q 0 0.31200004 0.06400001 0.6040001 q 0.06400001 0.29200006 0.21200001 0.51600003 q 0.148 0.22399998 0.39600003 0.3599999 q 0.24800003 0.13600016 0.61599994 0.13600016 q 0.43200016 0 0.6880002 -0.21600008 q 0.25600004 -0.21600008 0.33599997 -0.60800004 Z "/>
-        </symbol>
-        <symbol id="gAD3C9196DFD8002DD8AD647251EA8E6" overflow="visible">
-            <path d="M 0 0m 2.92 0 h 0.68000007 v 4.136 h -0.68000007 v -4.136 Z m 0 4.88 h 0.68000007 v 0.83200026 h -0.68000007 v -0.83200026 Z m -2.128 -1.3439999 v -3.5360003 h 0.68000007 v 3.5360003 h 0.79999995 v 0.5999999 h -0.79999995 v 0.5760002 q 0 0.27199984 0.13599992 0.36800003 q 0.13600004 0.09599972 0.38400006 0.09599972 q 0.08800006 0 0.19199991 -0.012000084 q 0.10400009 -0.011999607 0.19200015 -0.043999672 v 0.592 q -0.095999956 0.032000065 -0.22000003 0.04799986 q -0.12400007 0.01600027 -0.22000003 0.01600027 q -0.56000006 0 -0.852 -0.26000023 q -0.29200006 -0.26000023 -0.29200006 -0.76399994 v -0.6160002 h -0.69600004 v -0.5999999 h 0.69600004 Z "/>
-        </symbol>
-        <symbol id="g403726A1DBA9CA6272A92801D756F7C" overflow="visible">
-            <path d="M 0 0m 4.0800004 0.35200003 v 3.7840002 h -0.64000034 v -0.592 h -0.007999897 q -0.18400002 0.3440001 -0.5120001 0.5160003 q -0.32800007 0.17199993 -0.72 0.17199993 q -0.536 0 -0.90400004 -0.204 q -0.36799997 -0.20400023 -0.59199995 -0.5200002 q -0.22400004 -0.31599998 -0.32000005 -0.704 q -0.095999986 -0.388 -0.095999986 -0.75600004 q 0 -0.42400002 0.116 -0.804 q 0.11600003 -0.38000005 0.34800002 -0.66400003 q 0.232 -0.28400004 0.57600003 -0.45200002 q 0.34399998 -0.16800001 0.8080001 -0.16800001 q 0.39999986 0 0.75600004 0.18 q 0.35599995 0.18000002 0.53200006 0.56400007 h 0.015999794 v -0.27200004 q 0 -0.344 -0.06799984 -0.632 q -0.06800008 -0.28800005 -0.22000003 -0.49200004 q -0.15199995 -0.204 -0.38400006 -0.32000005 q -0.23200011 -0.11599994 -0.5680001 -0.11599994 q -0.16799998 0 -0.352 0.036000013 q -0.18400002 0.036000013 -0.34000003 0.11599994 q -0.1559999 0.08000004 -0.26399994 0.20800006 q -0.10800004 0.12799996 -0.116000056 0.31199998 h -0.68 q 0.016000003 -0.33600003 0.176 -0.568 q 0.16000003 -0.232 0.40399998 -0.37600005 q 0.24400008 -0.14399993 0.544 -0.20799994 q 0.30000007 -0.06400001 0.58800006 -0.06400001 q 0.9920001 0 1.4560001 0.50399995 q 0.46400023 0.50400007 0.46400023 1.5200001 Z m -1.9040003 0.20000002 q -0.33600008 0 -0.56000006 0.13999999 q -0.22399998 0.13999999 -0.36 0.36800003 q -0.13600004 0.22800004 -0.19200003 0.508 q -0.055999994 0.27999997 -0.055999994 0.55999994 q 0 0.296 0.06800008 0.5680001 q 0.06799996 0.27200007 0.21599996 0.48000002 q 0.148 0.20799994 0.38 0.33200002 q 0.232 0.12400007 0.56000006 0.12400007 q 0.31999993 0 0.5439999 -0.12800002 q 0.22400022 -0.12800002 0.36400008 -0.34000015 q 0.1400001 -0.2119999 0.204 -0.47599983 q 0.06400013 -0.26400018 0.06400013 -0.536 q 0 -0.2880001 -0.06800008 -0.5760001 q -0.06800008 -0.288 -0.2119999 -0.51600003 q -0.14400005 -0.22800004 -0.3800001 -0.36800003 q -0.23600006 -0.13999999 -0.572 -0.13999999 Z "/>
-        </symbol>
-        <symbol id="gFFA01FEE3974FB44A414D4377DF74C95" overflow="visible">
-            <path d="M 0 0m 4.176 0.016 q -0.17600012 -0.10400001 -0.48799992 -0.10400001 q -0.26399994 0 -0.42000008 0.148 q -0.1559999 0.148 -0.1559999 0.48400003 q -0.2800002 -0.33600003 -0.6520002 -0.48400003 q -0.37199998 -0.148 -0.8039999 -0.148 q -0.2800001 0 -0.53200006 0.06400001 q -0.25200003 0.064 -0.43600005 0.20000002 q -0.18400002 0.13599999 -0.292 0.356 q -0.10800001 0.22000003 -0.10800001 0.532 q 0 0.352 0.120000005 0.5760001 q 0.119999975 0.22399998 0.316 0.36400008 q 0.19599998 0.13999987 0.448 0.2119999 q 0.25199997 0.07200003 0.51600003 0.120000124 q 0.27999997 0.055999994 0.53199995 0.08399987 q 0.2520001 0.028000116 0.444 0.07999992 q 0.19200015 0.052000046 0.30400014 0.15200019 q 0.11199999 0.099999905 0.11199999 0.29200006 q 0 0.22399998 -0.08400011 0.3599999 q -0.08399987 0.13599992 -0.21599984 0.20799994 q -0.13199997 0.07200003 -0.296 0.096000195 q -0.16400003 0.02399993 -0.32400012 0.02399993 q -0.43200004 0 -0.72 -0.16400003 q -0.288 -0.16400003 -0.31200004 -0.6200001 h -0.68 q 0.016000003 0.38400006 0.16000003 0.648 q 0.144 0.26400018 0.384 0.4280002 q 0.24000007 0.16400003 0.54800004 0.23600006 q 0.30799997 0.07200003 0.65999997 0.07200003 q 0.27999997 0 0.556 -0.03999996 q 0.27600002 -0.03999996 0.5 -0.16400003 q 0.22400022 -0.12400007 0.36000013 -0.3480003 q 0.13599992 -0.22399998 0.13599992 -0.5839999 v -2.1280003 q 0 -0.24000001 0.028000116 -0.352 q 0.027999878 -0.11200005 0.18799996 -0.11200005 q 0.08800006 0 0.20799994 0.04000002 v -0.52800006 Z m -1.1040001 2.1200001 q -0.12799978 -0.095999956 -0.33599997 -0.1400001 q -0.20799994 -0.04399991 -0.43599987 -0.07199991 q -0.22800016 -0.027999997 -0.46000016 -0.06400001 q -0.232 -0.036000013 -0.416 -0.116000056 q -0.18400002 -0.08000004 -0.29999995 -0.22800004 q -0.116000056 -0.148 -0.116000056 -0.40399992 q 0 -0.16800004 0.06800008 -0.28400004 q 0.06799996 -0.116000056 0.176 -0.18800002 q 0.10799992 -0.07200003 0.25199997 -0.10400003 q 0.14400005 -0.032000005 0.30400002 -0.032000005 q 0.33599997 0 0.576 0.09200001 q 0.24000001 0.09200001 0.39199996 0.23200005 q 0.15200019 0.13999999 0.22400022 0.30400002 q 0.07199979 0.16399992 0.07199979 0.30799997 v 0.6960001 Z "/>
-        </symbol>
-        <symbol id="g8C3B87D37300021CAF28AE99C6A53743" overflow="visible">
-            <path d="M 0 0m 0.55200005 5.7120004 v -5.7120004 h 0.68000007 v 5.7120004 h -0.68000007 Z "/>
-        </symbol>
-        <symbol id="gEA2E7995284F078BE317DAED71DE81DC" overflow="visible">
-            <path d="M 0 0m 1.6320001 -1.5760001 h 0.5200001 q -0.5680001 0.9200001 -0.81200016 1.8240001 q -0.24399996 0.90400004 -0.24399996 1.9120001 q 0 0.98399997 0.24000001 1.8799999 q 0.24000001 0.8960004 0.8160001 1.8080001 h -0.5200001 q -0.6240001 -0.8239999 -0.94000006 -1.7839999 q -0.316 -0.96000004 -0.316 -1.904 q 0 -0.528 0.088 -1.008 q 0.08800003 -0.48000002 0.252 -0.93600005 q 0.16400003 -0.45600003 0.3960001 -0.90000004 q 0.232 -0.444 0.52 -0.8920001 Z "/>
-        </symbol>
-        <symbol id="g8F6718057B0E3514573AA9B4A2FC38A1" overflow="visible">
-            <path d="M 0 0m 3.936 0 v 4.136 h -0.68000007 v -2.336 q 0 -0.27999997 -0.075999975 -0.51600003 q -0.075999975 -0.23599994 -0.22799993 -0.412 q -0.15199995 -0.176 -0.3800001 -0.272 q -0.22799993 -0.096000016 -0.53999996 -0.096000016 q -0.39199996 0 -0.61600006 0.22400004 q -0.22399998 0.22399998 -0.22399998 0.60800004 v 2.8000002 h -0.68 v -2.7200003 q 0 -0.33599997 0.06800002 -0.612 q 0.06799996 -0.27600002 0.236 -0.476 q 0.16799998 -0.2 0.44 -0.308 q 0.27200007 -0.10800001 0.68000007 -0.10800001 q 0.4560001 0 0.79200006 0.18 q 0.33599997 0.18 0.55200005 0.564 h 0.016000032 v -0.656 h 0.63999987 Z "/>
-        </symbol>
-        <symbol id="g11B4CFF4C9AF9181ECD6A36A02010591" overflow="visible">
-            <path d="M 0 0m 0.536 5.7120004 v -5.7120004 h 0.68000007 v 0.55200005 h 0.016000032 q 0.11199999 -0.18400002 0.2759999 -0.30800003 q 0.16400003 -0.12400001 0.34800005 -0.19600001 q 0.18400013 -0.072 0.3720001 -0.104 q 0.18799996 -0.032000005 0.3399999 -0.032000005 q 0.47200012 0 0.82800007 0.16800001 q 0.35599995 0.16800001 0.592 0.46 q 0.23599982 0.292 0.352 0.6840001 q 0.116000175 0.39199996 0.116000175 0.8319999 q 0 0.44000006 -0.119999886 0.83200026 q -0.12000036 0.39199996 -0.35600019 0.6919999 q -0.23600006 0.29999995 -0.592 0.47600007 q -0.35600019 0.17600012 -0.8360002 0.17600012 q -0.43199992 0 -0.79199994 -0.15600014 q -0.36 -0.15600014 -0.528 -0.5 h -0.016000032 v 2.1360002 h -0.68000007 Z m 3.2 -3.6080003 q 0 -0.30400002 -0.06399989 -0.592 q -0.06399989 -0.288 -0.20799994 -0.5120001 q -0.14400005 -0.22399998 -0.3800001 -0.35999995 q -0.23600006 -0.13600004 -0.58800006 -0.13600004 q -0.352 0 -0.5999999 0.13200003 q -0.24800003 0.13199997 -0.40400004 0.348 q -0.15600002 0.21600002 -0.22800004 0.50000006 q -0.07200003 0.28400004 -0.07200003 0.58799994 q 0 0.2880001 0.06800008 0.5680001 q 0.06799996 0.27999997 0.21999991 0.5 q 0.15200007 0.22000003 0.39200008 0.35599995 q 0.23999989 0.13600016 0.584 0.13600016 q 0.32800007 0 0.572 -0.12800002 q 0.24399996 -0.12800002 0.4000001 -0.3440001 q 0.1559999 -0.21599984 0.23199987 -0.49199986 q 0.075999975 -0.27600002 0.075999975 -0.5640001 Z "/>
-        </symbol>
-        <symbol id="gB6FD75F5298B86FC5D51AC6F195ECA25" overflow="visible">
-            <path d="M 0 0m 2.1360002 -0.55200005 q -0.120000124 -0.30400002 -0.23600006 -0.51199996 q -0.116000056 -0.20800006 -0.25600004 -0.34000003 q -0.13999999 -0.13199997 -0.31200004 -0.19200003 q -0.17199993 -0.060000062 -0.39599997 -0.060000062 q -0.120000005 0 -0.24000001 0.016000032 q -0.120000005 0.016000032 -0.23200002 0.055999994 v 0.6240001 q 0.08800003 -0.03999996 0.20400003 -0.06799996 q 0.116 -0.027999997 0.19599998 -0.027999997 q 0.208 0 0.348 0.099999964 q 0.1400001 0.099999964 0.21200001 0.28399998 l 0.2800001 0.69600004 l -1.6400001 4.112 h 0.768 l 1.2080002 -3.384 h 0.015999794 l 1.1600001 3.384 h 0.72 l -1.8 -4.688 Z "/>
-        </symbol>
-        <symbol id="gF6E6E618EB7A8A012445F280241D7C98" overflow="visible">
-            <path d="M 0 0m 1.008 2.032 q 0 0.30400014 0.06400001 0.592 q 0.06400001 0.2880001 0.20800006 0.5120001 q 0.14399993 0.22399998 0.38399994 0.3599999 q 0.24000001 0.13600016 0.5840001 0.13600016 q 0.352 0 0.5999999 -0.13199997 q 0.24800014 -0.13199997 0.40400004 -0.34800005 q 0.15600014 -0.21600008 0.22800016 -0.5 q 0.07200003 -0.28400016 0.07200003 -0.58800006 q 0 -0.288 -0.06800008 -0.5680001 q -0.06800008 -0.27999997 -0.22000003 -0.5 q -0.15199995 -0.22000003 -0.39199996 -0.356 q -0.24000001 -0.13600004 -0.5840001 -0.13600004 q -0.32800007 0 -0.572 0.12800002 q -0.24399996 0.12800002 -0.39999998 0.34400004 q -0.15600002 0.21599996 -0.232 0.49199998 q -0.076000094 0.27600002 -0.076000094 0.564 Z m 3.2000003 -2.032 v 5.7120004 h -0.68000007 v -2.1280003 h -0.016000032 q -0.11199999 0.18400002 -0.27600002 0.3080001 q -0.16400003 0.12400007 -0.3479998 0.19999981 q -0.18400002 0.07600021 -0.36800003 0.10800028 q -0.18400002 0.032000065 -0.3440001 0.032000065 q -0.472 0 -0.82800007 -0.17199993 q -0.356 -0.17200017 -0.592 -0.46400023 q -0.236 -0.29200006 -0.35200003 -0.684 q -0.116 -0.39199996 -0.116 -0.832 q 0 -0.44000006 0.120000005 -0.83200014 q 0.119999975 -0.39199996 0.35600004 -0.688 q 0.23599994 -0.296 0.592 -0.472 q 0.35600007 -0.17600001 0.8360001 -0.17600001 q 0.43199992 0 0.79200006 0.15200001 q 0.3599999 0.15200001 0.5279999 0.496 h 0.016000032 v -0.56 h 0.68000007 Z "/>
-        </symbol>
-        <symbol id="g38385C688BB0F21A935DCB07A45652A7" overflow="visible">
-            <path d="M 0 0m -0.072000004 -1.5760001 h 0.512 q 0.62399995 0.82400006 0.94000006 1.7800001 q 0.31599998 0.9560001 0.31599998 1.9000001 q 0 0.5280001 -0.08800006 1.0080001 q -0.08799994 0.48000002 -0.25199997 0.9399998 q -0.16400003 0.46000004 -0.39600003 0.9040003 q -0.232 0.44399977 -0.52 0.8919997 h -0.512 q 0.56000006 -0.9199996 0.8040001 -1.8280001 q 0.24400002 -0.90799975 0.24400002 -1.9159999 q 0 -0.9760001 -0.24000001 -1.876 q -0.24000004 -0.9000001 -0.8080001 -1.8040001 Z "/>
-        </symbol>
-        <symbol id="g9A3A3A35D6C54D3285C5E0F1A91F795E" overflow="visible">
-            <path d="M 0 0m 0.66400003 0.8880001 v -0.8880001 h 0.888 v 0.8880001 h -0.888 Z "/>
-        </symbol>
-    </defs>
-</svg>
+<svg viewBox="0 0 580.113245512 189.446015654" width="580.113245512pt" height="189.446015654pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h5="http://www.w3.org/1999/xhtml"><g transform="translate(5 5)"><g><path fill="none" transform="translate(96.845456598)" d="M 0 0h 60.56v 7.14h -60.56v -7.14Z "/><g transform="translate(96.845456488 -9.4e-8)"><g><g transform="matrix(1 0 0 -1 0 7.14)"><use xlink:href="#gFF1D6FE0FCEFE59EC272C893571781D4" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gBE46CFB3EBAB215C63CA4E5DC5C3824E" x="7.59" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76DBFC4FA93EE2DE8BA6DB7B8CF9007" x="11.48" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gA7EC01E9D99E89B77E57F8F2E702D511" x="17.22" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g7FB0EDCAB970990EA555F2D3E23D2BD3" x="23.33" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gD7F3AA0CF2239D4DE6F87820275D4542" x="32.04" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gAF6679426DD77E90F0A155C1B3331519" x="38.15" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gA7EC01E9D99E89B77E57F8F2E702D511" x="43.34" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g34C6A7BC17D0AF2BD816D9B656C21B9A" x="49.45" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g3BDD167888FE9297E5CBBF14977DDF81" x="55.19" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="none" transform="translate(377.121878016)" d="M 0 0h 38.69v 7.14h -38.69v -7.14Z "/><g transform="translate(377.121877906 -9.4e-8)"><g><g transform="matrix(1 0 0 -1 0 7.14)"><use xlink:href="#g5B82351F2E16F62A295346CE3CBF2A80" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g34C6A7BC17D0AF2BD816D9B656C21B9A" x="9.44" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g466B6B17946BCB398180A2A732955F46" x="15.18" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g2744CAB5F00DFFC307CCED82D504DAFF" x="17.76" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g7FB0EDCAB970990EA555F2D3E23D2BD3" x="23.87" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g1E821005B4B7EF2FE058D447671C18D3" x="29.8" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g3BDD167888FE9297E5CBBF14977DDF81" x="33.32" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="none" transform="translate(486.276340063)" d="M 0 0h 41.66v 7.14h -41.66v -7.14Z "/><g transform="translate(486.276339953 -9.4e-8)"><g><g transform="matrix(1 0 0 -1 0 7.14)"><use xlink:href="#g6E719F786D7B1141CA8C4512E00A2E0D" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF615D1769D4A065C3B81AFF62715CD4A" x="10" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76DBFC4FA93EE2DE8BA6DB7B8CF9007" x="16.3" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g2A097BC7EEE91105D52B352EA84246F0" x="22.04" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g69D4CD72297CC97098F7E4B54BF2CCDC" x="24.62" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g34C6A7BC17D0AF2BD816D9B656C21B9A" x="30.55" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g3BDD167888FE9297E5CBBF14977DDF81" x="36.29" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(96.541956567 12.694582583)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 51.167c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -51.167Z "/><path fill="none" transform="translate(102.541956598 18.694582677)" d="M 0 0h 49.167v 6.426h -49.167v -6.426Z "/><g transform="translate(102.541956457 18.694582677)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g358648C530966537EABEBBEC18198CC8" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gC31F60C8C41E19EEB1D25990511789A" x="6.498" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="10.998" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gBD650B5058F0646EBF236D8F6940AC70" x="16.335" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="21.168" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g80102705FF5D893D49AAE39B792F523C" x="24.165" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="30.996" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="33.993" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="38.826" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="44.163" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(94.786956567 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 54.677c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -54.677Z "/><path fill="none" transform="translate(100.786956598 59.797748031)" d="M 0 0h 52.677v 6.426h -52.677v -6.426Z "/><g transform="translate(100.786956457 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g998BE4B087A0C386337E1CB97229E76" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="5.832" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gA3FF480C19AEB1E21DC8A39262BFE6C2" x="7.83" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="15.507" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gD2DA7E685FECD9D284DE6F57724955B7" x="20.844" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gBD650B5058F0646EBF236D8F6940AC70" x="22.842" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g80102705FF5D893D49AAE39B792F523C" x="27.675" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="34.506" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="37.503" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="42.336" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="47.673" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(0 94.900913386)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 52.499c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -52.499Z "/><path fill="none" transform="translate(5.999999905 100.900913386)" d="M 0 0h 50.499v 6.426h -50.499v -6.426Z "/><g transform="translate(5.999999764 100.900913386)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g8FFCFCF85AD85C5A925A226166F30EA1" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gD2DA7E685FECD9D284DE6F57724955B7" x="5.832" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="7.83" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g526F8306ACF9617F153930C15CD2A475" x="12.663" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="17.667" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="22.5" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g80102705FF5D893D49AAE39B792F523C" x="25.497" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="32.328" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="35.325" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="40.158" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="45.495" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(91.708956567 94.900913386)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 60.833c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -60.833Z "/><path fill="none" transform="translate(97.708956598 100.900913386)" d="M 0 0h 58.833v 6.426h -58.833v -6.426Z "/><g transform="translate(97.708956457 100.900913386)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g2FED6C3E674805F999833164ADE443B8" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="6.165" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="8.163" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="13.5" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="18.333" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g68A669F51D3D2BE053B24A40387EF06E" x="21.33" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="24.165" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g68A669F51D3D2BE053B24A40387EF06E" x="26.163" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gBD650B5058F0646EBF236D8F6940AC70" x="28.998" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g80102705FF5D893D49AAE39B792F523C" x="33.831" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="40.662" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="43.659" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="48.492" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="53.829" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(191.751913417 94.900913386)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 60.842c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -60.842Z "/><path fill="none" transform="translate(197.751913291 100.900913386)" d="M 0 0h 58.842v 6.426h -58.842v -6.426Z "/><g transform="translate(197.75191315 100.900913386)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#gCF81F3250CEF5E439BD9A17D4140A583" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g526F8306ACF9617F153930C15CD2A475" x="6.498" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="11.502" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g68A669F51D3D2BE053B24A40387EF06E" x="13.5" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gFF05D2CF6EC42551B1D130F991FB542F" x="16.335" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="22.671" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g3A4677DDBC586D308BB969EA3D409F2B" x="24.669" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g8211C3A926ABA11A1787DD12A5629A11" x="29.169" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g80102705FF5D893D49AAE39B792F523C" x="33.84" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="40.671" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="43.668" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="48.501" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="53.838" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(140.05868485 136.004078646)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 64.181c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -64.181Z "/><path fill="none" transform="translate(146.058684945 142.00407874)" d="M 0 0h 62.181v 6.426h -62.181v -6.426Z "/><g transform="translate(146.058684803 142.00407874)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="6.003" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g526F8306ACF9617F153930C15CD2A475" x="8.001" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gDF33ECC6A9229D1279F3C3F8743962FF" x="13.005" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g3A4677DDBC586D308BB969EA3D409F2B" x="18.171" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g998BE4B087A0C386337E1CB97229E76" x="22.671" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF6ECA5CBE62F1294F74D902B5E4CD26E" x="28.503" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4924820D7208E420C95C1F6ADAAF48E" x="33.507" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gDF33ECC6A9229D1279F3C3F8743962FF" x="38.844" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="44.01" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="47.007" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="51.84" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="57.177" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1e3a5f" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(225.052391622 136.004078646)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 80.678c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -80.678Z "/><path fill="none" transform="translate(231.052391638 142.00407874)" d="M 0 0h 78.678v 6.426h -78.678v -6.426Z "/><g transform="translate(231.052391496 142.00407874)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g17E1EDF03D20F92C5D9A1C646E2F3F53" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="4.338" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="7.335" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="9.333" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g526F8306ACF9617F153930C15CD2A475" x="14.166" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gDF33ECC6A9229D1279F3C3F8743962FF" x="19.17" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF6ECA5CBE62F1294F74D902B5E4CD26E" x="24.336" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gD2DA7E685FECD9D284DE6F57724955B7" x="29.34" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="31.338" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="36.171" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g998BE4B087A0C386337E1CB97229E76" x="39.168" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF6ECA5CBE62F1294F74D902B5E4CD26E" x="45" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4924820D7208E420C95C1F6ADAAF48E" x="50.004" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gDF33ECC6A9229D1279F3C3F8743962FF" x="55.341" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="60.507" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="63.504" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="68.337" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="73.674" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#3b1f2b" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(384.130877953 12.694582583)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 14.672c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -14.672Z "/><path fill="none" transform="translate(390.130878016 18.694582677)" d="M 0 0h 12.672v 6.426h -12.672v -6.426Z "/><g transform="translate(390.130877874 18.694582677)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g706DBDF2AFA18A24933A6A647147C19C" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g28654F3BE91BBF146A05420E9B69B910" x="2.664" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gB6C1C9281F1479B90715012C930C0F89" x="7.668" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#3b1f2b" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(384.463877953 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 14.006c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -14.006Z "/><path fill="none" transform="translate(390.463878016 59.797748031)" d="M 0 0h 12.006v 6.426h -12.006v -6.426Z "/><g transform="translate(390.463877874 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g28654F3BE91BBF146A05420E9B69B910" x="1.998" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gB6C1C9281F1479B90715012C930C0F89" x="7.002" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#3b1f2b" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(382.128377953 94.900913386)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 18.677c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -18.677Z "/><path fill="none" transform="translate(388.128378016 100.900913386)" d="M 0 0h 16.677v 6.426h -16.677v -6.426Z "/><g transform="translate(388.128377874 100.900913386)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g4BF2C94D2014A0FD17E6C8283E7BF557" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g526F8306ACF9617F153930C15CD2A475" x="6.84" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gBD650B5058F0646EBF236D8F6940AC70" x="11.844" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(494.855840126 12.694582583)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 14.501c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -14.501Z "/><path fill="none" transform="translate(500.855840063 18.694582677)" d="M 0 0h 12.501v 6.426h -12.501v -6.426Z "/><g transform="translate(500.855839921 18.694582677)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gE7B19A31542CA9616E8E9C203DE80E3B" x="6.003" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(444.09943474 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 13.007c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -13.007Z "/><path fill="none" transform="translate(450.099434709 59.797748031)" d="M 0 0h 11.007v 6.426h -11.007v -6.426Z "/><g transform="translate(450.099434567 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g79CC640AF8FDC181F546B16B9C037F2D" x="6.003" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(469.851137291 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 13.007c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -13.007Z "/><path fill="none" transform="translate(475.851137386 59.797748031)" d="M 0 0h 11.007v 6.426h -11.007v -6.426Z "/><g transform="translate(475.851137244 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#g144781C0177D7CE205CAE9D9D2ABC7A1" x="6.003" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(495.602840126 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 13.007c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -13.007Z "/><path fill="none" transform="translate(501.602840063 59.797748031)" d="M 0 0h 11.007v 6.426h -11.007v -6.426Z "/><g transform="translate(501.602839921 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gBCC2E373F8E1DF1573A99001CD4735AE" x="6.003" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(521.354542677 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 13.007c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -13.007Z "/><path fill="none" transform="translate(527.35454274 59.797748031)" d="M 0 0h 11.007v 6.426h -11.007v -6.426Z "/><g transform="translate(527.354542598 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gB6C1C9281F1479B90715012C930C0F89" x="6.003" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g><path fill="#1a3b2a" fill-rule="nonzero" stroke="#94a3b8" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(547.106245512 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 13.007c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -13.007Z "/><path fill="none" transform="translate(553.106245417 59.797748031)" d="M 0 0h 11.007v 6.426h -11.007v -6.426Z "/><g transform="translate(553.106245276 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#e2e8f0" fill-rule="nonzero"/><use xlink:href="#gF8E599750D79A27F88B7064C5092ABD6" x="6.003" y="0" fill="#e2e8f0" fill-rule="nonzero"/></g></g></g></g></g><g transform="matrix(1 0 0 -1 5 184.446015654)"><use xlink:href="#g81DFD15D696831D3AEDE372C6840E29B" x="0" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gC76F11DAD52FAC92E5F6681E1F3A8E24" x="5.776" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gFC762F034065CB92308F77DA50904636" x="10.368" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g9524DB2AB7AD3B578280EC160D005BAC" x="14.816" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gDE0960E94F350358A27A95EE3692B6C6" x="19.112" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g6B217B44DBEC65D521E4D6C450891318" x="21.632" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g786D0DA605A095191D5C33A5BB968848" x="25.928" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g6B217B44DBEC65D521E4D6C450891318" x="28.448" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g6C0EF9DFF594A5A60F31076377FDB72A" x="34.968" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gB9D4D6D822821FBD03112B321A4F5F37" x="38.968" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g8F816F4F6B3A797165B922832E440B5A" x="43.264" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g9186BB761FCB61E50F26CCCFD81F00F6" x="45.04" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g6B217B44DBEC65D521E4D6C450891318" x="49.488" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g3633D5EF187E794EAF4ED06368BFDFCF" x="53.784" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g33AE866EDA811CB59C344F15280DE76E" x="60.008" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gDE0960E94F350358A27A95EE3692B6C6" x="64.6" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gC76F11DAD52FAC92E5F6681E1F3A8E24" x="67.12" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g9186BB761FCB61E50F26CCCFD81F00F6" x="71.712" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g97071A2893B0C7191AEDE27EAE655EFE" x="76.16" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g6B217B44DBEC65D521E4D6C450891318" x="80.904" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g56F73A9DDE7688229227FB61E73B22EB" x="85.2" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gA140E16CF1ABF13007304C5857587282" x="92.168" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g9DE8B4E528C361BFE10E18BF85136915" x="96.912" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g6C0EF9DFF594A5A60F31076377FDB72A" x="103.136" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gB9D4D6D822821FBD03112B321A4F5F37" x="107.136" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gDE0960E94F350358A27A95EE3692B6C6" x="111.432" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g32B342CADBF6914BAE52C992C70E94C0" x="114.096" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gB9D4D6D822821FBD03112B321A4F5F37" x="115.872" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gFC762F034065CB92308F77DA50904636" x="120.168" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g786D0DA605A095191D5C33A5BB968848" x="124.616" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g56F73A9DDE7688229227FB61E73B22EB" x="129.36" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g32B342CADBF6914BAE52C992C70E94C0" x="134.104" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g53D2D7990B1448118A03E4A23C44B622" x="135.88" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g6B217B44DBEC65D521E4D6C450891318" x="142.704" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gFC762F034065CB92308F77DA50904636" x="147" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g3633D5EF187E794EAF4ED06368BFDFCF" x="151.448" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g32B342CADBF6914BAE52C992C70E94C0" x="155.448" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gC76F11DAD52FAC92E5F6681E1F3A8E24" x="157.224" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#gFC762F034065CB92308F77DA50904636" x="161.816" y="0" fill="#94a3b8" fill-rule="nonzero"/><use xlink:href="#g39FF3551F1CB57B29C5CAADE5C30FA34" x="166.264" y="0" fill="#94a3b8" fill-rule="nonzero"/></g><defs><symbol id="gFF1D6FE0FCEFE59EC272C893571781D4" overflow="visible"><path d="M 0 0m 5.85 0.81l 0.16 -0.81h 1v 3.86h -3v -1.17h 1.58q -0.07 -0.75 -0.495 -1.145q -0.425 -0.395 -1.205 -0.395q -0.53 0 -0.9 0.205q -0.37 0.205 -0.6 0.545q -0.23 0.34 -0.335 0.765q -0.105 0.425 -0.105 0.875q 0 0.47 0.105 0.91q 0.105 0.44 0.335 0.785q 0.23 0.345 0.6 0.55q 0.37 0.205 0.9 0.205q 0.57 0 0.97 -0.3q 0.4 -0.3 0.54 -0.9h 1.5q -0.06 0.61 -0.33 1.08q -0.27 0.47 -0.685 0.79q -0.415 0.32 -0.93 0.485q -0.515 0.165 -1.065 0.165q -0.82 0 -1.475 -0.29q -0.655 -0.29 -1.105 -0.8q -0.45 -0.51 -0.69 -1.195q -0.24 -0.685 -0.24 -1.485q 0 -0.78 0.24 -1.455q 0.24 -0.675 0.69 -1.175q 0.45 -0.5 1.105 -0.785q 0.655 -0.285 1.475 -0.285q 0.52 0 1.03 0.215q 0.51 0.215 0.93 0.755Z "/></symbol><symbol id="gBE46CFB3EBAB215C63CA4E5DC5C3824E" overflow="visible"><path d="M 0 0m 0.54 5.17v -5.17h 1.42v 2.33q 0 0.35 0.07 0.65q 0.07 0.3 0.235 0.525q 0.165 0.225 0.435 0.355q 0.27 0.13 0.66 0.13q 0.13 0 0.27 -0.015q 0.14 -0.015 0.24 -0.035v 1.32q -0.17 0.05 -0.31 0.05q -0.27 0 -0.52 -0.08q -0.25 -0.08 -0.47 -0.225q -0.22 -0.145 -0.39 -0.35q -0.17 -0.205 -0.27 -0.445h -0.02v 0.96h -1.35Z "/></symbol><symbol id="g76DBFC4FA93EE2DE8BA6DB7B8CF9007" overflow="visible"><path d="M 0 0m 0.48 3.58q 0.03 0.5 0.25 0.83q 0.22 0.33 0.56 0.53q 0.34 0.2 0.765 0.285q 0.425 0.085 0.855 0.085q 0.39 0 0.79 -0.055q 0.4 -0.055 0.73 -0.215q 0.33 -0.16 0.54 -0.445q 0.21 -0.285 0.21 -0.755v -2.69q 0 -0.35 0.04 -0.67q 0.04 -0.32 0.14 -0.48h -1.44q -0.04 0.12 -0.065 0.245q -0.025 0.125 -0.035 0.255q -0.34 -0.35 -0.8 -0.49q -0.46 -0.14 -0.94 -0.14q -0.37 0 -0.69 0.09q -0.32 0.09 -0.56 0.28q -0.24 0.19 -0.375 0.48q -0.135 0.29 -0.135 0.69q 0 0.44 0.155 0.725q 0.155 0.285 0.4 0.455q 0.245 0.17 0.56 0.255q 0.315 0.085 0.635 0.135q 0.32 0.05 0.63 0.08q 0.31 0.03 0.55 0.09q 0.24 0.06 0.38 0.175q 0.14 0.115 0.13 0.335q 0 0.23 -0.075 0.365q -0.075 0.135 -0.2 0.21q -0.125 0.075 -0.29 0.1q -0.165 0.025 -0.355 0.025q -0.42 0 -0.66 -0.18q -0.24 -0.18 -0.28 -0.6h -1.42Z m 3.28 -1.05q -0.09 -0.08 -0.225 -0.125q -0.135 -0.045 -0.29 -0.075q -0.155 -0.03 -0.325 -0.05q -0.17 -0.02 -0.34 -0.05q -0.16 -0.03 -0.315 -0.08q -0.155 -0.05 -0.27 -0.135q -0.115 -0.085 -0.185 -0.215q -0.07 -0.13 -0.07 -0.33q 0 -0.19 0.07 -0.32q 0.07 -0.13 0.19 -0.205q 0.12 -0.075 0.28 -0.105q 0.16 -0.03 0.33 -0.03q 0.42 0 0.65 0.14q 0.23 0.14 0.34 0.335q 0.11 0.195 0.135 0.395q 0.025 0.2 0.025 0.32v 0.53Z "/></symbol><symbol id="gA7EC01E9D99E89B77E57F8F2E702D511" overflow="visible"><path d="M 0 0m 3.15 0.93q -0.34 0 -0.58 0.14q -0.24 0.14 -0.385 0.365q -0.145 0.225 -0.21 0.525q -0.065 0.3 -0.065 0.61q 0 0.32 0.06 0.62q 0.06 0.3 0.205 0.53q 0.145 0.23 0.38 0.375q 0.235 0.145 0.585 0.145q 0.34 0 0.575 -0.145q 0.235 -0.145 0.385 -0.38q 0.15 -0.235 0.215 -0.535q 0.065 -0.3 0.065 -0.61q 0 -0.31 -0.06 -0.61q -0.06 -0.3 -0.205 -0.525q -0.145 -0.225 -0.38 -0.365q -0.235 -0.14 -0.585 -0.14Z m -2.61 4.24v -6.98h 1.42v 2.45h 0.02q 0.26 -0.38 0.665 -0.575q 0.405 -0.195 0.885 -0.195q 0.57 0 0.995 0.22q 0.425 0.22 0.71 0.59q 0.285 0.37 0.425 0.85q 0.14 0.48 0.14 1q 0 0.55 -0.14 1.055q -0.14 0.505 -0.43 0.885q -0.29 0.38 -0.73 0.61q -0.44 0.23 -1.05 0.23q -0.48 0 -0.88 -0.19q -0.4 -0.19 -0.66 -0.61h -0.02v 0.66h -1.35Z "/></symbol><symbol id="g7FB0EDCAB970990EA555F2D3E23D2BD3" overflow="visible"><path d="M 0 0m 0.54 7.14v -7.14h 1.42v 2.71q 0 0.79 0.26 1.135q 0.26 0.345 0.84 0.345q 0.51 0 0.71 -0.315q 0.2 -0.315 0.2 -0.955v -2.92h 1.42v 3.18q 0 0.48 -0.085 0.875q -0.085 0.395 -0.295 0.67q -0.21 0.275 -0.575 0.43q -0.365 0.155 -0.935 0.155q -0.4 0 -0.82 -0.205q -0.42 -0.205 -0.69 -0.655h -0.03v 2.69h -1.42Z "/></symbol><symbol id="gD7F3AA0CF2239D4DE6F87820275D4542" overflow="visible"><path d="M 0 0m 2.27 5.82v -5.82h 1.57v 5.82h 2.14v 1.32h -5.85v -1.32h 2.14Z "/></symbol><symbol id="gAF6679426DD77E90F0A155C1B3331519" overflow="visible"><path d="M 0 0m 3.09 -0.64l 2.16 5.81h -1.47l -1.13 -3.54h -0.02l -1.17 3.54h -1.51l 1.81 -4.85q 0.06 -0.15 0.06 -0.32q 0 -0.23 -0.135 -0.42q -0.135 -0.19 -0.415 -0.22q -0.21 -0.01 -0.42 0.01q -0.21 0.02 -0.41 0.04v -1.17q 0.22 -0.02 0.435 -0.035q 0.215 -0.015 0.435 -0.015q 0.73 0 1.14 0.27q 0.41 0.27 0.64 0.9Z "/></symbol><symbol id="g34C6A7BC17D0AF2BD816D9B656C21B9A" overflow="visible"><path d="M 0 0m 4.02 3.14h -2.31q 0.01 0.15 0.065 0.34q 0.055 0.19 0.19 0.36q 0.135 0.17 0.36 0.285q 0.225 0.115 0.565 0.115q 0.52 0 0.775 -0.28q 0.255 -0.28 0.355 -0.82Z m -2.31 -0.9h 3.73q 0.04 0.6 -0.1 1.15q -0.14 0.55 -0.455 0.98q -0.315 0.43 -0.805 0.685q -0.49 0.255 -1.15 0.255q -0.59 0 -1.075 -0.21q -0.485 -0.21 -0.835 -0.575q -0.35 -0.365 -0.54 -0.865q -0.19 -0.5 -0.19 -1.08q 0 -0.6 0.185 -1.1q 0.185 -0.5 0.525 -0.86q 0.34 -0.36 0.83 -0.555q 0.49 -0.195 1.1 -0.195q 0.88 0 1.5 0.4q 0.62 0.4 0.92 1.33h -1.25q -0.07 -0.24 -0.38 -0.455q -0.31 -0.215 -0.74 -0.215q -0.6 0 -0.92 0.31q -0.32 0.31 -0.35 1Z "/></symbol><symbol id="g3BDD167888FE9297E5CBBF14977DDF81" overflow="visible"><path d="M 0 0m 1.64 1.68h -1.35q 0.02 -0.52 0.235 -0.865q 0.215 -0.345 0.55 -0.555q 0.335 -0.21 0.765 -0.3q 0.43 -0.09 0.88 -0.09q 0.44 0 0.865 0.085q 0.425 0.085 0.755 0.295q 0.33 0.21 0.535 0.555q 0.205 0.345 0.205 0.855q 0 0.36 -0.14 0.605q -0.14 0.245 -0.37 0.41q -0.23 0.165 -0.525 0.265q -0.295 0.1 -0.605 0.17q -0.3 0.07 -0.59 0.13q -0.29 0.06 -0.515 0.135q -0.225 0.075 -0.365 0.195q -0.14 0.12 -0.14 0.31q 0 0.16 0.08 0.255q 0.08 0.095 0.195 0.145q 0.115 0.05 0.255 0.065q 0.14 0.015 0.26 0.015q 0.38 0 0.66 -0.145q 0.28 -0.145 0.31 -0.555h 1.35q -0.04 0.48 -0.245 0.795q -0.205 0.315 -0.515 0.505q -0.31 0.19 -0.705 0.27q -0.395 0.08 -0.815 0.08q -0.42 0 -0.82 -0.075q -0.4 -0.075 -0.72 -0.26q -0.32 -0.185 -0.515 -0.505q -0.195 -0.32 -0.195 -0.82q 0 -0.34 0.14 -0.575q 0.14 -0.235 0.37 -0.39q 0.23 -0.155 0.525 -0.25q 0.295 -0.095 0.605 -0.165q 0.76 -0.16 1.185 -0.32q 0.425 -0.16 0.425 -0.48q 0 -0.19 -0.09 -0.315q -0.09 -0.125 -0.225 -0.2q -0.135 -0.075 -0.3 -0.11q -0.165 -0.035 -0.315 -0.035q -0.21 0 -0.405 0.05q -0.195 0.05 -0.345 0.155q -0.15 0.105 -0.245 0.27q -0.095 0.165 -0.095 0.395Z "/></symbol><symbol id="g5B82351F2E16F62A295346CE3CBF2A80" overflow="visible"><path d="M 0 0m 7.49 0l 1.92 7.14h -1.54l -1.17 -4.92h -0.02l -1.22 4.92h -1.47l -1.24 -4.86h -0.02l -1.13 4.86h -1.57l 1.89 -7.14h 1.59l 1.19 4.86h 0.02l 1.21 -4.86h 1.56Z "/></symbol><symbol id="g466B6B17946BCB398180A2A732955F46" overflow="visible"><path d="M 0 0m 2 5.97v 1.17h -1.42v -1.17h 1.42Z m -1.42 -0.8v -5.17h 1.42v 5.17h -1.42Z "/></symbol><symbol id="g2744CAB5F00DFFC307CCED82D504DAFF" overflow="visible"><path d="M 0 0m 2.95 1.22q -0.33 0 -0.55 0.14q -0.22 0.14 -0.355 0.36q -0.135 0.22 -0.19 0.495q -0.055 0.275 -0.055 0.555q 0 0.29 0.065 0.555q 0.065 0.265 0.21 0.47q 0.145 0.205 0.36 0.325q 0.215 0.12 0.515 0.12q 0.35 0 0.58 -0.13q 0.23 -0.13 0.37 -0.35q 0.14 -0.22 0.2 -0.505q 0.06 -0.285 0.06 -0.605q 0 -0.28 -0.075 -0.535q -0.075 -0.255 -0.225 -0.455q -0.15 -0.2 -0.38 -0.32q -0.23 -0.12 -0.53 -0.12Z m 2.56 -0.89v 4.84h -1.35v -0.69h -0.02q -0.26 0.45 -0.645 0.64q -0.385 0.19 -0.895 0.19q -0.54 0 -0.955 -0.21q -0.415 -0.21 -0.695 -0.565q -0.28 -0.355 -0.425 -0.82q -0.145 -0.465 -0.145 -0.965q 0 -0.53 0.125 -1.005q 0.125 -0.475 0.395 -0.83q 0.27 -0.355 0.69 -0.56q 0.42 -0.205 1 -0.205q 0.47 0 0.895 0.195q 0.425 0.195 0.655 0.605h 0.02v -0.68q 0.01 -0.55 -0.265 -0.91q -0.275 -0.36 -0.875 -0.36q -0.38 0 -0.67 0.155q -0.29 0.155 -0.39 0.555h -1.41q 0.03 -0.44 0.245 -0.755q 0.215 -0.315 0.54 -0.515q 0.325 -0.2 0.72 -0.295q 0.395 -0.095 0.775 -0.095q 0.89 0 1.42 0.24q 0.53 0.24 0.81 0.585q 0.28 0.345 0.365 0.745q 0.085 0.4 0.085 0.71Z "/></symbol><symbol id="g1E821005B4B7EF2FE058D447671C18D3" overflow="visible"><path d="M 0 0m 2.34 5.17v 1.55h -1.42v -1.55h -0.86v -0.95h 0.86v -3.05q 0 -0.39 0.13 -0.63q 0.13 -0.24 0.355 -0.37q 0.225 -0.13 0.52 -0.175q 0.295 -0.045 0.625 -0.045q 0.21 0 0.43 0.01q 0.22 0.01 0.4 0.04v 1.1q -0.1 -0.02 -0.21 -0.03q -0.11 -0.01 -0.23 -0.01q -0.36 0 -0.48 0.12q -0.12 0.12 -0.12 0.48v 2.56h 1.04v 0.95h -1.04Z "/></symbol><symbol id="g6E719F786D7B1141CA8C4512E00A2E0D" overflow="visible"><path d="M 0 0m 0.69 7.14v -7.14h 1.57v 2.3l 0.9 0.91l 2.15 -3.21h 1.97l -3.06 4.32l 2.79 2.82h -1.96l -2.79 -2.96v 2.96h -1.57Z "/></symbol><symbol id="gF615D1769D4A065C3B81AFF62715CD4A" overflow="visible"><path d="M 0 0m 4.01 0l 2.37 7.14h -1.62l -1.61 -5.02h -0.02l -1.59 5.02h -1.61l 2.31 -7.14h 1.77Z "/></symbol><symbol id="g2A097BC7EEE91105D52B352EA84246F0" overflow="visible"><path d="M 0 0m 0.58 7.14v -7.14h 1.42v 7.14h -1.42Z "/></symbol><symbol id="g69D4CD72297CC97098F7E4B54BF2CCDC" overflow="visible"><path d="M 0 0m 5.39 0v 5.17h -1.42v -2.71q 0 -0.79 -0.26 -1.135q -0.26 -0.345 -0.84 -0.345q -0.51 0 -0.71 0.315q -0.2 0.315 -0.2 0.955v 2.92h -1.42v -3.18q 0 -0.48 0.085 -0.875q 0.085 -0.395 0.295 -0.67q 0.21 -0.275 0.575 -0.425q 0.365 -0.15 0.935 -0.15q 0.45 0 0.88 0.2q 0.43 0.2 0.7 0.65h 0.03v -0.72h 1.35Z "/></symbol><symbol id="g358648C530966537EABEBBEC18198CC8" overflow="visible"><path d="M 0 0m 0.702 6.426v -6.426h 0.855v 2.943h 3.384v -2.943h 0.855v 6.426h -0.855v -2.763h -3.384v 2.763h -0.855Z "/></symbol><symbol id="gC31F60C8C41E19EEB1D25990511789A" overflow="visible"><path d="M 0 0m 2.403 -0.621q -0.135 -0.342 -0.2655 -0.576q -0.1305 -0.234 -0.288 -0.3825q -0.1575 -0.1485 -0.351 -0.216q -0.1935 -0.0675 -0.4455 -0.0675q -0.135 0 -0.27 0.018q -0.135 0.018 -0.261 0.063v 0.702q 0.099 -0.045 0.2295 -0.0765q 0.1305 -0.0315 0.2205 -0.0315q 0.234 0 0.3915 0.1125q 0.1575 0.1125 0.2385 0.3195l 0.315 0.783l -1.845 4.626h 0.864l 1.359 -3.807h 0.018l 1.305 3.807h 0.81l -2.025 -5.274Z "/></symbol><symbol id="g4BF6675A1F6A6F6A675D8BE7B8863BAB" overflow="visible"><path d="M 0 0m 0.603 4.653v -6.426h 0.765v 2.394h 0.018q 0.126 -0.207 0.3105 -0.3465q 0.1845 -0.1395 0.3915 -0.2205q 0.207 -0.081 0.4185 -0.117q 0.2115 -0.036 0.3825 -0.036q 0.531 0 0.9315 0.189q 0.4005 0.189 0.666 0.5175q 0.2655 0.3285 0.396 0.7695q 0.1305 0.441 0.1305 0.936q 0 0.495 -0.135 0.936q -0.135 0.441 -0.4005 0.7785q -0.2655 0.3375 -0.666 0.5355q -0.4005 0.198 -0.9405 0.198q -0.486 0 -0.891 -0.1755q -0.405 -0.1755 -0.594 -0.5625h -0.018v 0.63h -0.765Z m 3.6 -2.286q 0 -0.342 -0.072 -0.666q -0.072 -0.324 -0.234 -0.576q -0.162 -0.252 -0.4275 -0.405q -0.2655 -0.153 -0.6615 -0.153q -0.396 0 -0.675 0.1485q -0.279 0.1485 -0.4545 0.3915q -0.1755 0.243 -0.2565 0.5625q -0.081 0.3195 -0.081 0.6615q 0 0.324 0.0765 0.639q 0.0765 0.315 0.2475 0.5625q 0.171 0.2475 0.441 0.4005q 0.27 0.153 0.657 0.153q 0.369 0 0.6435 -0.144q 0.2745 -0.144 0.45 -0.387q 0.1755 -0.243 0.261 -0.5535q 0.0855 -0.3105 0.0855 -0.6345Z "/></symbol><symbol id="gBD650B5058F0646EBF236D8F6940AC70" overflow="visible"><path d="M 0 0m 3.807 2.772h -2.673q 0.018 0.27 0.117 0.5085q 0.099 0.2385 0.27 0.4185q 0.171 0.18 0.4095 0.2835q 0.2385 0.1035 0.5355 0.1035q 0.288 0 0.5265 -0.1035q 0.2385 -0.1035 0.414 -0.279q 0.1755 -0.1755 0.279 -0.4185q 0.1035 -0.243 0.1215 -0.513Z m 0.738 -1.296h -0.756q -0.099 -0.459 -0.4095 -0.684q -0.3105 -0.225 -0.7965 -0.225q -0.378 0 -0.657 0.126q -0.279 0.126 -0.459 0.3375q -0.18 0.2115 -0.261 0.486q -0.081 0.2745 -0.072 0.5805h 3.483q 0.018 0.423 -0.0765 0.891q -0.0945 0.468 -0.342 0.864q -0.2475 0.396 -0.657 0.6525q -0.4095 0.2565 -1.0305 0.2565q -0.477 0 -0.8775 -0.18q -0.4005 -0.18 -0.693 -0.504q -0.2925 -0.324 -0.4545 -0.765q -0.162 -0.441 -0.162 -0.972q 0.018 -0.531 0.1575 -0.981q 0.1395 -0.45 0.4185 -0.774q 0.279 -0.324 0.6885 -0.504q 0.4095 -0.18 0.9675 -0.18q 0.792 0 1.314 0.396q 0.522 0.396 0.675 1.179Z "/></symbol><symbol id="g51AEC211C4B4ABC5D9D55D5612BCFCD6" overflow="visible"><path d="M 0 0m 0.549 4.653v -4.653h 0.765v 2.07q 0 0.45 0.09 0.7965q 0.09 0.3465 0.288 0.5895q 0.198 0.243 0.522 0.369q 0.324 0.126 0.783 0.126v 0.81q -0.621 0.018 -1.026 -0.252q -0.405 -0.27 -0.684 -0.837h -0.018v 0.981h -0.72Z "/></symbol><symbol id="g80102705FF5D893D49AAE39B792F523C" overflow="visible"><path d="M 0 0m 5.508 0.801l 0.225 -0.801h 0.54v 3.384h -2.817v -0.72h 2.052q 0.018 -0.441 -0.117 -0.8235q -0.135 -0.3825 -0.4005 -0.666q -0.2655 -0.2835 -0.6525 -0.4455q -0.387 -0.162 -0.891 -0.162q -0.54 0 -0.9495 0.2115q -0.4095 0.2115 -0.6885 0.567q -0.279 0.3555 -0.423 0.819q -0.144 0.4635 -0.144 0.9675q 0 0.513 0.126 1.0035q 0.126 0.4905 0.3915 0.873q 0.2655 0.3825 0.684 0.6165q 0.4185 0.234 1.0035 0.234q 0.36 0 0.6795 -0.0855q 0.3195 -0.0855 0.5715 -0.2565q 0.252 -0.171 0.423 -0.4365q 0.171 -0.2655 0.234 -0.6345h 0.855q -0.09 0.567 -0.3375 0.9675q -0.2475 0.4005 -0.612 0.6615q -0.3645 0.261 -0.828 0.3825q -0.4635 0.1215 -0.9855 0.1215q -0.765 0 -1.3365 -0.2835q -0.5715 -0.2835 -0.954 -0.7605q -0.3825 -0.477 -0.576 -1.1115q -0.1935 -0.6345 -0.1935 -1.3365q 0 -0.63 0.207 -1.215q 0.207 -0.585 0.603 -1.035q 0.396 -0.45 0.963 -0.7155q 0.567 -0.2655 1.287 -0.2655q 0.567 0 1.125 0.2205q 0.558 0.2205 0.936 0.7245Z "/></symbol><symbol id="g76AD9D48F7250D6C3EDAA0782F20ADD4" overflow="visible"><path d="M 0 0m 4.698 0.018q -0.198 -0.117 -0.549 -0.117q -0.297 0 -0.4725 0.1665q -0.1755 0.1665 -0.1755 0.5445q -0.315 -0.378 -0.7335 -0.5445q -0.4185 -0.1665 -0.9045 -0.1665q -0.315 0 -0.5985 0.072q -0.2835 0.072 -0.4905 0.225q -0.207 0.153 -0.3285 0.4005q -0.1215 0.2475 -0.1215 0.5985q 0 0.396 0.135 0.648q 0.135 0.252 0.3555 0.4095q 0.2205 0.1575 0.504 0.2385q 0.2835 0.081 0.5805 0.135q 0.315 0.063 0.5985 0.0945q 0.2835 0.0315 0.4995 0.09q 0.216 0.0585 0.342 0.171q 0.126 0.1125 0.126 0.3285q 0 0.252 -0.0945 0.405q -0.0945 0.153 -0.243 0.234q -0.1485 0.081 -0.333 0.108q -0.1845 0.027 -0.3645 0.027q -0.486 0 -0.81 -0.1845q -0.324 -0.1845 -0.351 -0.6975h -0.765q 0.018 0.432 0.18 0.729q 0.162 0.297 0.432 0.4815q 0.27 0.1845 0.6165 0.2655q 0.3465 0.081 0.7425 0.081q 0.315 0 0.6255 -0.045q 0.3105 -0.045 0.5625 -0.1845q 0.252 -0.1395 0.405 -0.3915q 0.153 -0.252 0.153 -0.657v -2.394q 0 -0.27 0.0315 -0.396q 0.0315 -0.126 0.2115 -0.126q 0.099 0 0.234 0.045v -0.594Z m -1.242 2.385q -0.144 -0.108 -0.378 -0.1575q -0.234 -0.0495 -0.4905 -0.081q -0.2565 -0.0315 -0.5175 -0.072q -0.261 -0.0405 -0.468 -0.1305q -0.207 -0.09 -0.3375 -0.2565q -0.1305 -0.1665 -0.1305 -0.4545q 0 -0.189 0.0765 -0.3195q 0.0765 -0.1305 0.198 -0.2115q 0.1215 -0.081 0.2835 -0.117q 0.162 -0.036 0.342 -0.036q 0.378 0 0.648 0.1035q 0.27 0.1035 0.441 0.261q 0.171 0.1575 0.252 0.342q 0.081 0.1845 0.081 0.3465v 0.783Z "/></symbol><symbol id="g9F69CFB5E12EEFE787A8731335FF6501" overflow="visible"><path d="M 0 0m 0.576 6.426v -6.426h 0.765v 2.628q 0 0.315 0.0855 0.5805q 0.0855 0.2655 0.2565 0.4635q 0.171 0.198 0.4275 0.306q 0.2565 0.108 0.6075 0.108q 0.441 0 0.693 -0.252q 0.252 -0.252 0.252 -0.684v -3.15h 0.765v 3.06q 0 0.378 -0.0765 0.6885q -0.0765 0.3105 -0.2655 0.5355q -0.189 0.225 -0.495 0.351q -0.306 0.126 -0.765 0.126q -0.207 0 -0.4275 -0.045q -0.2205 -0.045 -0.423 -0.1395q -0.2025 -0.0945 -0.3645 -0.243q -0.162 -0.1485 -0.252 -0.3645h -0.018v 2.457h -0.765Z "/></symbol><symbol id="g998BE4B087A0C386337E1CB97229E76" overflow="visible"><path d="M 0 0m 4.419 4.545h 0.81q -0.018 0.531 -0.2025 0.9135q -0.1845 0.3825 -0.504 0.6345q -0.3195 0.252 -0.7425 0.369q -0.423 0.117 -0.918 0.117q -0.441 0 -0.8595 -0.1125q -0.4185 -0.1125 -0.747 -0.342q -0.3285 -0.2295 -0.5265 -0.585q -0.198 -0.3555 -0.198 -0.8415q 0 -0.441 0.1755 -0.7335q 0.1755 -0.2925 0.468 -0.477q 0.2925 -0.1845 0.6615 -0.297q 0.369 -0.1125 0.7515 -0.198q 0.3825 -0.0855 0.7515 -0.1665q 0.369 -0.081 0.6615 -0.2115q 0.2925 -0.1305 0.468 -0.3375q 0.1755 -0.207 0.1755 -0.54q 0 -0.351 -0.144 -0.576q -0.144 -0.225 -0.378 -0.3555q -0.234 -0.1305 -0.5265 -0.1845q -0.2925 -0.054 -0.5805 -0.054q -0.36 0 -0.702 0.09q -0.342 0.09 -0.5985 0.279q -0.2565 0.189 -0.414 0.4815q -0.1575 0.2925 -0.1575 0.6975h -0.81q 0 -0.585 0.2115 -1.0125q 0.2115 -0.4275 0.576 -0.702q 0.3645 -0.2745 0.846 -0.4095q 0.4815 -0.135 1.0215 -0.135q 0.441 0 0.8865 0.1035q 0.4455 0.1035 0.8055 0.333q 0.36 0.2295 0.5895 0.594q 0.2295 0.3645 0.2295 0.8775q 0 0.477 -0.1755 0.792q -0.1755 0.315 -0.468 0.522q -0.2925 0.207 -0.6615 0.3285q -0.369 0.1215 -0.7515 0.2115q -0.3825 0.09 -0.7515 0.1665q -0.369 0.0765 -0.6615 0.1935q -0.2925 0.117 -0.468 0.3015q -0.1755 0.1845 -0.1755 0.4815q 0 0.315 0.1215 0.5265q 0.1215 0.2115 0.324 0.3375q 0.2025 0.126 0.4635 0.18q 0.261 0.054 0.531 0.054q 0.666 0 1.0935 -0.3105q 0.4275 -0.3105 0.4995 -1.0035Z "/></symbol><symbol id="gF7F3FC75D830406F7324CCD66FBDC70F" overflow="visible"><path d="M 0 0m 1.386 5.49v 0.936h -0.765v -0.936h 0.765Z m -0.765 -0.837v -4.653h 0.765v 4.653h -0.765Z "/></symbol><symbol id="gA3FF480C19AEB1E21DC8A39262BFE6C2" overflow="visible"><path d="M 0 0m 0.576 4.653v -4.653h 0.765v 2.898q 0 0.135 0.0675 0.3375q 0.0675 0.2025 0.216 0.3915q 0.1485 0.189 0.387 0.324q 0.2385 0.135 0.5715 0.135q 0.261 0 0.4275 -0.0765q 0.1665 -0.0765 0.2655 -0.216q 0.099 -0.1395 0.1395 -0.3285q 0.0405 -0.189 0.0405 -0.414v -3.051h 0.765v 2.898q 0 0.54 0.324 0.864q 0.324 0.324 0.891 0.324q 0.279 0 0.4545 -0.081q 0.1755 -0.081 0.2745 -0.2205q 0.099 -0.1395 0.135 -0.3285q 0.036 -0.189 0.036 -0.405v -3.051h 0.765v 3.411q 0 0.36 -0.1125 0.6165q -0.1125 0.2565 -0.315 0.4185q -0.2025 0.162 -0.486 0.2385q -0.2835 0.0765 -0.6345 0.0765q -0.459 0 -0.8415 -0.207q -0.3825 -0.207 -0.6165 -0.585q -0.144 0.432 -0.495 0.612q -0.351 0.18 -0.783 0.18q -0.981 0 -1.503 -0.792h -0.018v 0.684h -0.72Z "/></symbol><symbol id="gD2DA7E685FECD9D284DE6F57724955B7" overflow="visible"><path d="M 0 0m 0.621 6.426v -6.426h 0.765v 6.426h -0.765Z "/></symbol><symbol id="g8FFCFCF85AD85C5A925A226166F30EA1" overflow="visible"><path d="M 0 0m 1.557 3.348v 2.358h 1.674q 0.729 0 1.0665 -0.3015q 0.3375 -0.3015 0.3375 -0.8775q 0 -0.576 -0.3375 -0.882q -0.3375 -0.306 -1.0665 -0.297h -1.674Z m -0.855 3.078v -6.426h 0.855v 2.628h 1.962q 0.972 -0.009 1.4715 0.495q 0.4995 0.504 0.4995 1.404q 0 0.9 -0.4995 1.3995q -0.4995 0.4995 -1.4715 0.4995h -2.817Z "/></symbol><symbol id="g526F8306ACF9617F153930C15CD2A475" overflow="visible"><path d="M 0 0m 0.576 4.653v -4.653h 0.765v 2.628q 0 0.315 0.0855 0.5805q 0.0855 0.2655 0.2565 0.4635q 0.171 0.198 0.4275 0.306q 0.2565 0.108 0.6075 0.108q 0.441 0 0.693 -0.252q 0.252 -0.252 0.252 -0.684v -3.15h 0.765v 3.06q 0 0.378 -0.0765 0.6885q -0.0765 0.3105 -0.2655 0.5355q -0.189 0.225 -0.495 0.351q -0.306 0.126 -0.765 0.126q -1.035 0 -1.512 -0.846h -0.018v 0.738h -0.72Z "/></symbol><symbol id="g2FED6C3E674805F999833164ADE443B8" overflow="visible"><path d="M 0 0m 1.557 3.663v 2.043h 1.71q 0.279 0 0.5265 -0.0315q 0.2475 -0.0315 0.4365 -0.1395q 0.189 -0.108 0.297 -0.306q 0.108 -0.198 0.108 -0.54q 0 -0.513 -0.3195 -0.7695q -0.3195 -0.2565 -1.0485 -0.2565h -1.71Z m -0.855 2.763v -6.426h 3.105q 0.477 0 0.8415 0.1575q 0.3645 0.1575 0.612 0.414q 0.2475 0.2565 0.3735 0.5895q 0.126 0.333 0.126 0.684q 0 0.594 -0.315 1.008q -0.315 0.414 -0.909 0.54v 0.018q 0.459 0.18 0.7065 0.5535q 0.2475 0.3735 0.2475 0.8865q 0 0.486 -0.2205 0.819q -0.2205 0.333 -0.5355 0.522q -0.144 0.09 -0.3465 0.135q -0.2025 0.045 -0.4365 0.0675q -0.234 0.0225 -0.4725 0.027q -0.2385 0.0045 -0.4455 0.0045h -2.331Z m 0.855 -5.706v 2.223h 1.953q 0.27 0 0.522 -0.0495q 0.252 -0.0495 0.4455 -0.171q 0.1935 -0.1215 0.3105 -0.3285q 0.117 -0.207 0.117 -0.522q 0 -0.54 -0.3195 -0.846q -0.3195 -0.306 -0.8865 -0.306h -2.142Z "/></symbol><symbol id="g68A669F51D3D2BE053B24A40387EF06E" overflow="visible"><path d="M 0 0m 1.638 4.653v 1.395h -0.765v -1.395h -0.792v -0.675h 0.792v -2.961q 0 -0.324 0.063 -0.522q 0.063 -0.198 0.1935 -0.306q 0.1305 -0.108 0.342 -0.1485q 0.2115 -0.0405 0.5085 -0.0405h 0.585v 0.675h -0.351q -0.18 0 -0.2925 0.0135q -0.1125 0.0135 -0.1755 0.0585q -0.063 0.045 -0.0855 0.126q -0.0225 0.081 -0.0225 0.216v 2.889h 0.927v 0.675h -0.927Z "/></symbol><symbol id="gCF81F3250CEF5E439BD9A17D4140A583" overflow="visible"><path d="M 0 0m 5.832 2.322v 4.104h -0.855v -4.104q 0 -0.864 -0.4275 -1.3095q -0.4275 -0.4455 -1.2465 -0.4455q -0.864 0 -1.323 0.4455q -0.459 0.4455 -0.459 1.3095v 4.104h -0.855v -4.104q 0 -1.287 0.6975 -1.8765q 0.6975 -0.5895 1.9395 -0.5895q 1.215 0 1.872 0.6165q 0.657 0.6165 0.657 1.8495Z "/></symbol><symbol id="gFF05D2CF6EC42551B1D130F991FB542F" overflow="visible"><path d="M 0 0m 1.557 0.72v 4.986h 1.44q 0.594 0 0.999 -0.1665q 0.405 -0.1665 0.6615 -0.486q 0.2565 -0.3195 0.369 -0.774q 0.1125 -0.4545 0.1125 -1.0305q 0 -0.594 -0.1215 -1.0125q -0.1215 -0.4185 -0.3105 -0.6975q -0.189 -0.279 -0.4275 -0.441q -0.2385 -0.162 -0.4815 -0.2475q -0.243 -0.0855 -0.459 -0.108q -0.216 -0.0225 -0.36 -0.0225h -1.422Z m -0.855 5.706v -6.426h 2.205q 0.801 0 1.386 0.225q 0.585 0.225 0.963 0.6525q 0.378 0.4275 0.558 1.053q 0.18 0.6255 0.18 1.4355q 0 1.548 -0.801 2.304q -0.801 0.756 -2.286 0.756h -2.205Z "/></symbol><symbol id="g3A4677DDBC586D308BB969EA3D409F2B" overflow="visible"><path d="M 0 0m 1.044 1.467h -0.765q 0.018 -0.432 0.18 -0.7335q 0.162 -0.3015 0.432 -0.486q 0.27 -0.1845 0.621 -0.2655q 0.351 -0.081 0.738 -0.081q 0.351 0 0.7065 0.0675q 0.3555 0.0675 0.639 0.2385q 0.2835 0.171 0.459 0.45q 0.1755 0.279 0.1755 0.702q 0 0.333 -0.1305 0.558q -0.1305 0.225 -0.342 0.3735q -0.2115 0.1485 -0.486 0.2385q -0.2745 0.09 -0.5625 0.153q -0.27 0.063 -0.54 0.1215q -0.27 0.0585 -0.486 0.144q -0.216 0.0855 -0.3555 0.216q -0.1395 0.1305 -0.1395 0.3285q 0 0.18 0.09 0.2925q 0.09 0.1125 0.234 0.18q 0.144 0.0675 0.3195 0.0945q 0.1755 0.027 0.3465 0.027q 0.189 0 0.3735 -0.0405q 0.1845 -0.0405 0.3375 -0.1305q 0.153 -0.09 0.252 -0.2385q 0.099 -0.1485 0.117 -0.3735h 0.765q -0.027 0.423 -0.18 0.7065q -0.153 0.2835 -0.4095 0.45q -0.2565 0.1665 -0.5895 0.234q -0.333 0.0675 -0.729 0.0675q -0.306 0 -0.6165 -0.0765q -0.3105 -0.0765 -0.558 -0.234q -0.2475 -0.1575 -0.405 -0.4095q -0.1575 -0.252 -0.1575 -0.603q 0 -0.45 0.225 -0.702q 0.225 -0.252 0.5625 -0.3915q 0.3375 -0.1395 0.7335 -0.216q 0.396 -0.0765 0.7335 -0.171q 0.3375 -0.0945 0.5625 -0.2475q 0.225 -0.153 0.225 -0.45q 0 -0.216 -0.108 -0.3555q -0.108 -0.1395 -0.2745 -0.2115q -0.1665 -0.072 -0.3645 -0.099q -0.198 -0.027 -0.378 -0.027q -0.234 0 -0.4545 0.045q -0.2205 0.045 -0.396 0.1485q -0.1755 0.1035 -0.2835 0.279q -0.108 0.1755 -0.117 0.4275Z "/></symbol><symbol id="g8211C3A926ABA11A1787DD12A5629A11" overflow="visible"><path d="M 0 0m 0.621 6.426v -6.426h 0.765v 1.764l 0.72 0.666l 1.593 -2.43h 0.972l -1.98 2.961l 1.845 1.692h -1.026l -2.124 -2.034v 3.807h -0.765Z "/></symbol><symbol id="g643259D216747AA812B6855D4BA0DE42" overflow="visible"><path d="M 0 0m 0.702 6.426v -6.426h 0.855v 2.25l 1.071 0.999l 2.322 -3.249h 1.08l -2.817 3.834l 2.709 2.592h -1.107l -3.258 -3.204v 3.204h -0.855Z "/></symbol><symbol id="gDF33ECC6A9229D1279F3C3F8743962FF" overflow="visible"><path d="M 0 0m 4.59 0.396v 4.257h -0.72v -0.666h -0.009q -0.207 0.387 -0.576 0.5805q -0.369 0.1935 -0.81 0.1935q -0.603 0 -1.017 -0.2295q -0.414 -0.2295 -0.666 -0.585q -0.252 -0.3555 -0.36 -0.792q -0.108 -0.4365 -0.108 -0.8505q 0 -0.477 0.1305 -0.9045q 0.1305 -0.4275 0.3915 -0.747q 0.261 -0.3195 0.648 -0.5085q 0.387 -0.189 0.909 -0.189q 0.45 0 0.8505 0.2025q 0.4005 0.2025 0.5985 0.6345h 0.018v -0.306q 0 -0.387 -0.0765 -0.711q -0.0765 -0.324 -0.2475 -0.5535q -0.171 -0.2295 -0.432 -0.36q -0.261 -0.1305 -0.639 -0.1305q -0.189 0 -0.396 0.0405q -0.207 0.0405 -0.3825 0.1305q -0.1755 0.09 -0.297 0.234q -0.1215 0.144 -0.1305 0.351h -0.765q 0.018 -0.378 0.198 -0.639q 0.18 -0.261 0.4545 -0.423q 0.2745 -0.162 0.612 -0.234q 0.3375 -0.072 0.6615 -0.072q 1.116 0 1.638 0.567q 0.522 0.567 0.522 1.71Z m -2.142 0.225q -0.378 0 -0.63 0.1575q -0.252 0.1575 -0.405 0.414q -0.153 0.2565 -0.216 0.5715q -0.063 0.315 -0.063 0.63q 0 0.333 0.0765 0.639q 0.0765 0.306 0.243 0.54q 0.1665 0.234 0.4275 0.3735q 0.261 0.1395 0.63 0.1395q 0.36 0 0.612 -0.144q 0.252 -0.144 0.4095 -0.3825q 0.1575 -0.2385 0.2295 -0.5355q 0.072 -0.297 0.072 -0.603q 0 -0.324 -0.0765 -0.648q -0.0765 -0.324 -0.2385 -0.5805q -0.162 -0.2565 -0.4275 -0.414q -0.2655 -0.1575 -0.6435 -0.1575Z "/></symbol><symbol id="gF6ECA5CBE62F1294F74D902B5E4CD26E" overflow="visible"><path d="M 0 0m 4.428 0v 4.653h -0.765v -2.628q 0 -0.315 -0.0855 -0.5805q -0.0855 -0.2655 -0.2565 -0.4635q -0.171 -0.198 -0.4275 -0.306q -0.2565 -0.108 -0.6075 -0.108q -0.441 0 -0.693 0.252q -0.252 0.252 -0.252 0.684v 3.15h -0.765v -3.06q 0 -0.378 0.0765 -0.6885q 0.0765 -0.3105 0.2655 -0.5355q 0.189 -0.225 0.495 -0.3465q 0.306 -0.1215 0.765 -0.1215q 0.513 0 0.891 0.2025q 0.378 0.2025 0.621 0.6345h 0.018v -0.738h 0.72Z "/></symbol><symbol id="g4924820D7208E420C95C1F6ADAAF48E" overflow="visible"><path d="M 0 0m 0.603 6.426v -6.426h 0.765v 0.621h 0.018q 0.126 -0.207 0.3105 -0.3465q 0.1845 -0.1395 0.3915 -0.2205q 0.207 -0.081 0.4185 -0.117q 0.2115 -0.036 0.3825 -0.036q 0.531 0 0.9315 0.189q 0.4005 0.189 0.666 0.5175q 0.2655 0.3285 0.396 0.7695q 0.1305 0.441 0.1305 0.936q 0 0.495 -0.135 0.936q -0.135 0.441 -0.4005 0.7785q -0.2655 0.3375 -0.666 0.5355q -0.4005 0.198 -0.9405 0.198q -0.486 0 -0.891 -0.1755q -0.405 -0.1755 -0.594 -0.5625h -0.018v 2.403h -0.765Z m 3.6 -4.059q 0 -0.342 -0.072 -0.666q -0.072 -0.324 -0.234 -0.576q -0.162 -0.252 -0.4275 -0.405q -0.2655 -0.153 -0.6615 -0.153q -0.396 0 -0.675 0.1485q -0.279 0.1485 -0.4545 0.3915q -0.1755 0.243 -0.2565 0.5625q -0.081 0.3195 -0.081 0.6615q 0 0.324 0.0765 0.639q 0.0765 0.315 0.2475 0.5625q 0.171 0.2475 0.441 0.4005q 0.27 0.153 0.657 0.153q 0.369 0 0.6435 -0.144q 0.2745 -0.144 0.45 -0.387q 0.1755 -0.243 0.261 -0.5535q 0.0855 -0.3105 0.0855 -0.6345Z "/></symbol><symbol id="g17E1EDF03D20F92C5D9A1C646E2F3F53" overflow="visible"><path d="M 0 0m 2.16 5.706v -5.706h 0.855v 5.706h 2.142v 0.72h -5.139v -0.72h 2.142Z "/></symbol><symbol id="g706DBDF2AFA18A24933A6A647147C19C" overflow="visible"><path d="M 0 0m 0.891 3.978v -3.978h 0.765v 3.978h 0.9v 0.675h -0.9v 0.648q 0 0.306 0.153 0.414q 0.153 0.108 0.432 0.108q 0.099 0 0.216 -0.0135q 0.117 -0.0135 0.216 -0.0495v 0.666q -0.108 0.036 -0.2475 0.054q -0.1395 0.018 -0.2475 0.018q -0.63 0 -0.9585 -0.2925q -0.3285 -0.2925 -0.3285 -0.8595v -0.693h -0.783v -0.675h 0.783Z "/></symbol><symbol id="g28654F3BE91BBF146A05420E9B69B910" overflow="visible"><path d="M 0 0m 3.726 4.752h 0.765q -0.072 0.792 -0.54 1.2105q -0.468 0.4185 -1.26 0.4185q -0.684 0 -1.134 -0.288q -0.45 -0.288 -0.72 -0.765q -0.27 -0.477 -0.3825 -1.0935q -0.1125 -0.6165 -0.1125 -1.2735q 0 -0.504 0.0765 -1.044q 0.0765 -0.54 0.3105 -0.99q 0.234 -0.45 0.666 -0.738q 0.432 -0.288 1.143 -0.288q 0.603 0 1.0125 0.2025q 0.4095 0.2025 0.657 0.513q 0.2475 0.3105 0.3555 0.6885q 0.108 0.378 0.108 0.729q 0 0.441 -0.135 0.819q -0.135 0.378 -0.3825 0.657q -0.2475 0.279 -0.612 0.4365q -0.3645 0.1575 -0.8235 0.1575q -0.522 0 -0.9225 -0.198q -0.4005 -0.198 -0.6705 -0.639l -0.018 0.018q 0.009 0.369 0.072 0.792q 0.063 0.423 0.2295 0.7875q 0.1665 0.3645 0.4635 0.603q 0.297 0.2385 0.783 0.2385q 0.459 0 0.738 -0.261q 0.279 -0.261 0.333 -0.693Z m -1.152 -1.323q 0.324 0 0.567 -0.117q 0.243 -0.117 0.405 -0.3105q 0.162 -0.1935 0.2385 -0.459q 0.0765 -0.2655 0.0765 -0.5625q 0 -0.279 -0.0855 -0.5355q -0.0855 -0.2565 -0.2475 -0.4545q -0.162 -0.198 -0.4005 -0.3105q -0.2385 -0.1125 -0.5535 -0.1125q -0.315 0 -0.5625 0.1125q -0.2475 0.1125 -0.414 0.3015q -0.1665 0.189 -0.2565 0.45q -0.09 0.261 -0.09 0.558q 0 0.297 0.0855 0.5625q 0.0855 0.2655 0.2565 0.459q 0.171 0.1935 0.414 0.306q 0.243 0.1125 0.567 0.1125Z "/></symbol><symbol id="gB6C1C9281F1479B90715012C930C0F89" overflow="visible"><path d="M 0 0m 3.051 2.169h -2.142l 2.124 3.123h 0.018v -3.123Z m 0.72 0v 4.212h -0.612l -2.907 -4.149v -0.738h 2.799v -1.494h 0.72v 1.494h 0.864v 0.675h -0.864Z "/></symbol><symbol id="g4BF2C94D2014A0FD17E6C8283E7BF557" overflow="visible"><path d="M 0 0m 1.197 3.213q 0 0.486 0.126 0.9585q 0.126 0.4725 0.396 0.8505q 0.27 0.378 0.693 0.6075q 0.423 0.2295 1.008 0.2295q 0.585 0 1.008 -0.2295q 0.423 -0.2295 0.693 -0.6075q 0.27 -0.378 0.396 -0.8505q 0.126 -0.4725 0.126 -0.9585q 0 -0.486 -0.126 -0.9585q -0.126 -0.4725 -0.396 -0.8505q -0.27 -0.378 -0.693 -0.6075q -0.423 -0.2295 -1.008 -0.2295q -0.585 0 -1.008 0.2295q -0.423 0.2295 -0.693 0.6075q -0.27 0.378 -0.396 0.8505q -0.126 0.4725 -0.126 0.9585Z m -0.855 0q 0 -0.657 0.1935 -1.2645q 0.1935 -0.6075 0.5805 -1.0755q 0.387 -0.468 0.963 -0.7425q 0.576 -0.2745 1.341 -0.2745q 0.765 0 1.341 0.2745q 0.576 0.2745 0.963 0.7425q 0.387 0.468 0.5805 1.0755q 0.1935 0.6075 0.1935 1.2645q 0 0.657 -0.1935 1.2645q -0.1935 0.6075 -0.5805 1.0755q -0.387 0.468 -0.963 0.747q -0.576 0.279 -1.341 0.279q -0.765 0 -1.341 -0.279q -0.576 -0.279 -0.963 -0.747q -0.387 -0.468 -0.5805 -1.0755q -0.1935 -0.6075 -0.1935 -1.2645Z "/></symbol><symbol id="gE7B19A31542CA9616E8E9C203DE80E3B" overflow="visible"><path d="M 0 0m 0.693 6.426v -6.426h 0.81v 5.157h 0.018l 3.357 -5.157h 0.936v 6.426h -0.81v -5.211h -0.018l -3.384 5.211h -0.909Z "/></symbol><symbol id="g79CC640AF8FDC181F546B16B9C037F2D" overflow="visible"><path d="M 0 0m 3.204 0v 6.381h -0.585q -0.063 -0.36 -0.234 -0.594q -0.171 -0.234 -0.4185 -0.369q -0.2475 -0.135 -0.5535 -0.1845q -0.306 -0.0495 -0.63 -0.0495v -0.612h 1.656v -4.572h 0.765Z "/></symbol><symbol id="g144781C0177D7CE205CAE9D9D2ABC7A1" overflow="visible"><path d="M 0 0m 0.396 4.122h 0.765q -0.009 0.288 0.0585 0.5715q 0.0675 0.2835 0.2205 0.5085q 0.153 0.225 0.3915 0.3645q 0.2385 0.1395 0.5715 0.1395q 0.252 0 0.477 -0.081q 0.225 -0.081 0.3915 -0.234q 0.1665 -0.153 0.2655 -0.3645q 0.099 -0.2115 0.099 -0.4725q 0 -0.333 -0.1035 -0.585q -0.1035 -0.252 -0.306 -0.468q -0.2025 -0.216 -0.5085 -0.4275q -0.306 -0.2115 -0.711 -0.4635q -0.333 -0.198 -0.639 -0.423q -0.306 -0.225 -0.549 -0.522q -0.243 -0.297 -0.4005 -0.6975q -0.1575 -0.4005 -0.2025 -0.9675h 4.167v 0.675h -3.276q 0.054 0.297 0.2295 0.5265q 0.1755 0.2295 0.423 0.4275q 0.2475 0.198 0.5445 0.3735q 0.297 0.1755 0.594 0.3555q 0.297 0.189 0.576 0.396q 0.279 0.207 0.495 0.4635q 0.216 0.2565 0.3465 0.5805q 0.1305 0.324 0.1305 0.747q 0 0.45 -0.1575 0.792q -0.1575 0.342 -0.4275 0.5715q -0.27 0.2295 -0.6345 0.351q -0.3645 0.1215 -0.7785 0.1215q -0.504 0 -0.9 -0.171q -0.396 -0.171 -0.6615 -0.4725q -0.2655 -0.3015 -0.3915 -0.7155q -0.126 -0.414 -0.099 -0.9Z "/></symbol><symbol id="gBCC2E373F8E1DF1573A99001CD4735AE" overflow="visible"><path d="M 0 0m 1.962 3.645v -0.648q 0.216 0.027 0.459 0.027q 0.288 0 0.5355 -0.0765q 0.2475 -0.0765 0.4275 -0.234q 0.18 -0.1575 0.288 -0.387q 0.108 -0.2295 0.108 -0.5265q 0 -0.288 -0.1125 -0.5175q -0.1125 -0.2295 -0.3015 -0.387q -0.189 -0.1575 -0.441 -0.243q -0.252 -0.0855 -0.531 -0.0855q -0.657 0 -0.999 0.3915q -0.342 0.3915 -0.36 1.0125h -0.765q -0.009 -0.495 0.1395 -0.882q 0.1485 -0.387 0.4275 -0.6525q 0.279 -0.2655 0.675 -0.4005q 0.396 -0.135 0.882 -0.135q 0.45 0 0.8505 0.1215q 0.4005 0.1215 0.6975 0.3645q 0.297 0.243 0.4725 0.6075q 0.1755 0.3645 0.1755 0.8415q 0 0.576 -0.2835 0.999q -0.2835 0.423 -0.8685 0.549v 0.018q 0.378 0.171 0.63 0.504q 0.252 0.333 0.252 0.765q 0 0.441 -0.1485 0.765q -0.1485 0.324 -0.4095 0.531q -0.261 0.207 -0.6165 0.3105q -0.3555 0.1035 -0.7695 0.1035q -0.477 0 -0.8415 -0.153q -0.3645 -0.153 -0.6075 -0.423q -0.243 -0.27 -0.3735 -0.648q -0.1305 -0.378 -0.1485 -0.837h 0.765q 0 0.279 0.072 0.531q 0.072 0.252 0.2205 0.441q 0.1485 0.189 0.378 0.3015q 0.2295 0.1125 0.5355 0.1125q 0.486 0 0.81 -0.2565q 0.324 -0.2565 0.324 -0.7695q 0 -0.252 -0.099 -0.45q -0.099 -0.198 -0.2655 -0.3285q -0.1665 -0.1305 -0.387 -0.198q -0.2205 -0.0675 -0.4635 -0.0675h -0.162q -0.045 0 -0.09 0q -0.036 0 -0.081 0.009Z "/></symbol><symbol id="gF8E599750D79A27F88B7064C5092ABD6" overflow="visible"><path d="M 0 0m 4.23 5.598v 0.675h -3.15l -0.594 -3.312l 0.657 -0.036q 0.225 0.27 0.5175 0.4365q 0.2925 0.1665 0.6705 0.1665q 0.324 0 0.5895 -0.108q 0.2655 -0.108 0.4545 -0.3015q 0.189 -0.1935 0.2925 -0.459q 0.1035 -0.2655 0.1035 -0.5805q 0 -0.378 -0.108 -0.6615q -0.108 -0.2835 -0.2925 -0.4725q -0.1845 -0.189 -0.432 -0.2835q -0.2475 -0.0945 -0.5175 -0.0945q -0.288 0 -0.5265 0.0855q -0.2385 0.0855 -0.414 0.243q -0.1755 0.1575 -0.279 0.369q -0.1035 0.2115 -0.1215 0.4545h -0.765q 0.009 -0.432 0.171 -0.774q 0.162 -0.342 0.441 -0.5715q 0.279 -0.2295 0.6435 -0.351q 0.3645 -0.1215 0.7785 -0.1215q 0.558 0 0.9765 0.1755q 0.4185 0.1755 0.6975 0.4725q 0.279 0.297 0.4185 0.6795q 0.1395 0.3825 0.1395 0.7875q 0 0.549 -0.162 0.9585q -0.162 0.4095 -0.441 0.684q -0.279 0.2745 -0.657 0.4095q -0.378 0.135 -0.801 0.135q -0.324 0 -0.6525 -0.1125q -0.3285 -0.1125 -0.5355 -0.3465l -0.018 0.018l 0.342 1.836h 2.574Z "/></symbol><symbol id="g81DFD15D696831D3AEDE372C6840E29B" overflow="visible"><path d="M 0 0m 4.64 3.992h 0.76q -0.064 0.456 -0.272 0.804q -0.208 0.348 -0.52 0.58q -0.312 0.232 -0.712 0.352q -0.4 0.12 -0.848 0.12q -0.656 0 -1.164 -0.236q -0.508 -0.236 -0.848 -0.644q -0.34 -0.408 -0.516 -0.956q -0.176 -0.548 -0.176 -1.172q 0 -0.624 0.164 -1.168q 0.164 -0.544 0.492 -0.944q 0.328 -0.4 0.824 -0.628q 0.496 -0.228 1.16 -0.228q 1.096 0 1.728 0.6q 0.632 0.6 0.744 1.68h -0.76q -0.024 -0.352 -0.144 -0.656q -0.12 -0.304 -0.332 -0.524q -0.212 -0.22 -0.504 -0.344q -0.292 -0.124 -0.668 -0.124q -0.512 0 -0.88 0.192q -0.368 0.192 -0.604 0.516q -0.236 0.324 -0.348 0.76q -0.112 0.436 -0.112 0.924q 0 0.448 0.112 0.864q 0.112 0.416 0.348 0.74q 0.236 0.324 0.6 0.516q 0.364 0.192 0.876 0.192q 0.6 0 1.036 -0.304q 0.436 -0.304 0.564 -0.912Z "/></symbol><symbol id="gC76F11DAD52FAC92E5F6681E1F3A8E24" overflow="visible"><path d="M 0 0m 1.008 2.064q 0 0.376 0.1 0.668q 0.1 0.292 0.276 0.492q 0.176 0.2 0.412 0.304q 0.236 0.104 0.5 0.104q 0.264 0 0.5 -0.104q 0.236 -0.104 0.412 -0.304q 0.176 -0.2 0.276 -0.492q 0.1 -0.292 0.1 -0.668q 0 -0.376 -0.1 -0.668q -0.1 -0.292 -0.276 -0.488q -0.176 -0.196 -0.412 -0.3q -0.236 -0.104 -0.5 -0.104q -0.264 0 -0.5 0.104q -0.236 0.104 -0.412 0.3q -0.176 0.196 -0.276 0.488q -0.1 0.292 -0.1 0.668Z m -0.72 0q 0 -0.456 0.128 -0.848q 0.128 -0.392 0.384 -0.684q 0.256 -0.292 0.632 -0.456q 0.376 -0.164 0.864 -0.164q 0.496 0 0.868 0.164q 0.372 0.164 0.628 0.456q 0.256 0.292 0.384 0.684q 0.128 0.392 0.128 0.848q 0 0.456 -0.128 0.852q -0.128 0.396 -0.384 0.688q -0.256 0.292 -0.628 0.46q -0.372 0.168 -0.868 0.168q -0.488 0 -0.864 -0.168q -0.376 -0.168 -0.632 -0.46q -0.256 -0.292 -0.384 -0.688q -0.128 -0.396 -0.128 -0.852Z "/></symbol><symbol id="gFC762F034065CB92308F77DA50904636" overflow="visible"><path d="M 0 0m 0.512 4.136v -4.136h 0.68v 2.336q 0 0.28 0.076 0.516q 0.076 0.236 0.228 0.412q 0.152 0.176 0.38 0.272q 0.228 0.096 0.54 0.096q 0.392 0 0.616 -0.224q 0.224 -0.224 0.224 -0.608v -2.8h 0.68v 2.72q 0 0.336 -0.068 0.612q -0.068 0.276 -0.236 0.476q -0.168 0.2 -0.44 0.312q -0.272 0.112 -0.68 0.112q -0.92 0 -1.344 -0.752h -0.016v 0.656h -0.64Z "/></symbol><symbol id="g9524DB2AB7AD3B578280EC160D005BAC" overflow="visible"><path d="M 0 0m 3.32 2.808h 0.704q -0.04 0.368 -0.192 0.636q -0.152 0.268 -0.388 0.444q -0.236 0.176 -0.544 0.26q -0.308 0.084 -0.66 0.084q -0.488 0 -0.856 -0.172q -0.368 -0.172 -0.612 -0.472q -0.244 -0.3 -0.364 -0.704q -0.12 -0.404 -0.12 -0.868q 0 -0.464 0.124 -0.852q 0.124 -0.388 0.368 -0.668q 0.244 -0.28 0.608 -0.432q 0.364 -0.152 0.836 -0.152q 0.792 0 1.252 0.416q 0.46 0.416 0.572 1.184h -0.696q -0.064 -0.48 -0.348 -0.744q -0.284 -0.264 -0.788 -0.264q -0.32 0 -0.552 0.128q -0.232 0.128 -0.376 0.34q -0.144 0.212 -0.212 0.484q -0.068 0.272 -0.068 0.56q 0 0.312 0.064 0.604q 0.064 0.292 0.212 0.516q 0.148 0.224 0.396 0.36q 0.248 0.136 0.616 0.136q 0.432 0 0.688 -0.216q 0.256 -0.216 0.336 -0.608Z "/></symbol><symbol id="gDE0960E94F350358A27A95EE3692B6C6" overflow="visible"><path d="M 0 0m 0.488 4.136v -4.136h 0.68v 1.84q 0 0.4 0.08 0.708q 0.08 0.308 0.256 0.524q 0.176 0.216 0.464 0.328q 0.288 0.112 0.696 0.112v 0.72q -0.552 0.016 -0.912 -0.224q -0.36 -0.24 -0.608 -0.744h -0.016v 0.872h -0.64Z "/></symbol><symbol id="g6B217B44DBEC65D521E4D6C450891318" overflow="visible"><path d="M 0 0m 3.384 2.464h -2.376q 0.016 0.24 0.104 0.452q 0.088 0.212 0.24 0.372q 0.152 0.16 0.364 0.252q 0.212 0.092 0.476 0.092q 0.256 0 0.468 -0.092q 0.212 -0.092 0.368 -0.248q 0.156 -0.156 0.248 -0.372q 0.092 -0.216 0.108 -0.456Z m 0.656 -1.152h -0.672q -0.088 -0.408 -0.364 -0.608q -0.276 -0.2 -0.708 -0.2q -0.336 0 -0.584 0.112q -0.248 0.112 -0.408 0.3q -0.16 0.188 -0.232 0.432q -0.072 0.244 -0.064 0.516h 3.096q 0.016 0.376 -0.068 0.792q -0.084 0.416 -0.304 0.768q -0.22 0.352 -0.584 0.58q -0.364 0.228 -0.916 0.228q -0.424 0 -0.78 -0.16q -0.356 -0.16 -0.616 -0.448q -0.26 -0.288 -0.404 -0.68q -0.144 -0.392 -0.144 -0.864q 0.016 -0.472 0.14 -0.872q 0.124 -0.4 0.372 -0.688q 0.248 -0.288 0.612 -0.448q 0.364 -0.16 0.86 -0.16q 0.704 0 1.168 0.352q 0.464 0.352 0.6 1.048Z "/></symbol><symbol id="g786D0DA605A095191D5C33A5BB968848" overflow="visible"><path d="M 0 0m 1.456 4.136v 1.24h -0.68v -1.24h -0.704v -0.6h 0.704v -2.632q 0 -0.288 0.056 -0.464q 0.056 -0.176 0.172 -0.272q 0.116 -0.096 0.304 -0.132q 0.188 -0.036 0.452 -0.036h 0.52v 0.6h -0.312q -0.16 0 -0.26 0.012q -0.1 0.012 -0.156 0.052q -0.056 0.04 -0.076 0.112q -0.02 0.072 -0.02 0.192v 2.568h 0.824v 0.6h -0.824Z "/></symbol><symbol id="g6C0EF9DFF594A5A60F31076377FDB72A" overflow="visible"><path d="M 0 0m 2.376 0l 1.512 4.136h -0.712l -1.128 -3.448h -0.016l -1.16 3.448h -0.76l 1.536 -4.136h 0.728Z "/></symbol><symbol id="gB9D4D6D822821FBD03112B321A4F5F37" overflow="visible"><path d="M 0 0m 4.176 0.016q -0.176 -0.104 -0.488 -0.104q -0.264 0 -0.42 0.148q -0.156 0.148 -0.156 0.484q -0.28 -0.336 -0.652 -0.484q -0.372 -0.148 -0.804 -0.148q -0.28 0 -0.532 0.064q -0.252 0.064 -0.436 0.2q -0.184 0.136 -0.292 0.356q -0.108 0.22 -0.108 0.532q 0 0.352 0.12 0.576q 0.12 0.224 0.316 0.364q 0.196 0.14 0.448 0.212q 0.252 0.072 0.516 0.12q 0.28 0.056 0.532 0.084q 0.252 0.028 0.444 0.08q 0.192 0.052 0.304 0.152q 0.112 0.1 0.112 0.292q 0 0.224 -0.084 0.36q -0.084 0.136 -0.216 0.208q -0.132 0.072 -0.296 0.096q -0.164 0.024 -0.324 0.024q -0.432 0 -0.72 -0.164q -0.288 -0.164 -0.312 -0.62h -0.68q 0.016 0.384 0.16 0.648q 0.144 0.264 0.384 0.428q 0.24 0.164 0.548 0.236q 0.308 0.072 0.66 0.072q 0.28 0 0.556 -0.04q 0.276 -0.04 0.5 -0.164q 0.224 -0.124 0.36 -0.348q 0.136 -0.224 0.136 -0.584v -2.128q 0 -0.24 0.028 -0.352q 0.028 -0.112 0.188 -0.112q 0.088 0 0.208 0.04v -0.528Z m -1.104 2.12q -0.128 -0.096 -0.336 -0.14q -0.208 -0.044 -0.436 -0.072q -0.228 -0.028 -0.46 -0.064q -0.232 -0.036 -0.416 -0.116q -0.184 -0.08 -0.3 -0.228q -0.116 -0.148 -0.116 -0.404q 0 -0.168 0.068 -0.284q 0.068 -0.116 0.176 -0.188q 0.108 -0.072 0.252 -0.104q 0.144 -0.032 0.304 -0.032q 0.336 0 0.576 0.092q 0.24 0.092 0.392 0.232q 0.152 0.14 0.224 0.304q 0.072 0.164 0.072 0.308v 0.696Z "/></symbol><symbol id="g8F816F4F6B3A797165B922832E440B5A" overflow="visible"><path d="M 0 0m 0.552 5.712v -5.712h 0.68v 5.712h -0.68Z "/></symbol><symbol id="g9186BB761FCB61E50F26CCCFD81F00F6" overflow="visible"><path d="M 0 0m 3.936 0v 4.136h -0.68v -2.336q 0 -0.28 -0.076 -0.516q -0.076 -0.236 -0.228 -0.412q -0.152 -0.176 -0.38 -0.272q -0.228 -0.096 -0.54 -0.096q -0.392 0 -0.616 0.224q -0.224 0.224 -0.224 0.608v 2.8h -0.68v -2.72q 0 -0.336 0.068 -0.612q 0.068 -0.276 0.236 -0.476q 0.168 -0.2 0.44 -0.308q 0.272 -0.108 0.68 -0.108q 0.456 0 0.792 0.18q 0.336 0.18 0.552 0.564h 0.016v -0.656h 0.64Z "/></symbol><symbol id="g3633D5EF187E794EAF4ED06368BFDFCF" overflow="visible"><path d="M 0 0m 0.928 1.304h -0.68q 0.016 -0.384 0.16 -0.652q 0.144 -0.268 0.384 -0.432q 0.24 -0.164 0.552 -0.236q 0.312 -0.072 0.656 -0.072q 0.312 0 0.628 0.06q 0.316 0.06 0.568 0.212q 0.252 0.152 0.408 0.4q 0.156 0.248 0.156 0.624q 0 0.296 -0.116 0.496q -0.116 0.2 -0.304 0.332q -0.188 0.132 -0.432 0.212q -0.244 0.08 -0.5 0.136q -0.24 0.056 -0.48 0.108q -0.24 0.052 -0.432 0.128q -0.192 0.076 -0.316 0.192q -0.124 0.116 -0.124 0.292q 0 0.16 0.08 0.26q 0.08 0.1 0.208 0.16q 0.128 0.06 0.284 0.084q 0.156 0.024 0.308 0.024q 0.168 0 0.332 -0.036q 0.164 -0.036 0.3 -0.116q 0.136 -0.08 0.224 -0.212q 0.088 -0.132 0.104 -0.332h 0.68q -0.024 0.376 -0.16 0.628q -0.136 0.252 -0.364 0.4q -0.228 0.148 -0.524 0.208q -0.296 0.06 -0.648 0.06q -0.272 0 -0.548 -0.068q -0.276 -0.068 -0.496 -0.208q -0.22 -0.14 -0.36 -0.364q -0.14 -0.224 -0.14 -0.536q 0 -0.4 0.2 -0.624q 0.2 -0.224 0.5 -0.348q 0.3 -0.124 0.652 -0.192q 0.352 -0.068 0.652 -0.152q 0.3 -0.084 0.5 -0.22q 0.2 -0.136 0.2 -0.4q 0 -0.192 -0.096 -0.316q -0.096 -0.124 -0.244 -0.188q -0.148 -0.064 -0.324 -0.088q -0.176 -0.024 -0.336 -0.024q -0.208 0 -0.404 0.04q -0.196 0.04 -0.352 0.132q -0.156 0.092 -0.252 0.248q -0.096 0.156 -0.104 0.38Z "/></symbol><symbol id="g33AE866EDA811CB59C344F15280DE76E" overflow="visible"><path d="M 0 0m 4.08 0.352v 3.784h -0.64v -0.592h -0.008q -0.184 0.344 -0.512 0.516q -0.328 0.172 -0.72 0.172q -0.536 0 -0.904 -0.204q -0.368 -0.204 -0.592 -0.52q -0.224 -0.316 -0.32 -0.704q -0.096 -0.388 -0.096 -0.756q 0 -0.424 0.116 -0.804q 0.116 -0.38 0.348 -0.664q 0.232 -0.284 0.576 -0.452q 0.344 -0.168 0.808 -0.168q 0.4 0 0.756 0.18q 0.356 0.18 0.532 0.564h 0.016v -0.272q 0 -0.344 -0.068 -0.632q -0.068 -0.288 -0.22 -0.492q -0.152 -0.204 -0.384 -0.32q -0.232 -0.116 -0.568 -0.116q -0.168 0 -0.352 0.036q -0.184 0.036 -0.34 0.116q -0.156 0.08 -0.264 0.208q -0.108 0.128 -0.116 0.312h -0.68q 0.016 -0.336 0.176 -0.568q 0.16 -0.232 0.404 -0.376q 0.244 -0.144 0.544 -0.208q 0.3 -0.064 0.588 -0.064q 0.992 0 1.456 0.504q 0.464 0.504 0.464 1.52Z m -1.904 0.2q -0.336 0 -0.56 0.14q -0.224 0.14 -0.36 0.368q -0.136 0.228 -0.192 0.508q -0.056 0.28 -0.056 0.56q 0 0.296 0.068 0.568q 0.068 0.272 0.216 0.48q 0.148 0.208 0.38 0.332q 0.232 0.124 0.56 0.124q 0.32 0 0.544 -0.128q 0.224 -0.128 0.364 -0.34q 0.14 -0.212 0.204 -0.476q 0.064 -0.264 0.064 -0.536q 0 -0.288 -0.068 -0.576q -0.068 -0.288 -0.212 -0.516q -0.144 -0.228 -0.38 -0.368q -0.236 -0.14 -0.572 -0.14Z "/></symbol><symbol id="g97071A2893B0C7191AEDE27EAE655EFE" overflow="visible"><path d="M 0 0m 0.536 4.136v -5.712h 0.68v 2.128h 0.016q 0.112 -0.184 0.276 -0.308q 0.164 -0.124 0.348 -0.196q 0.184 -0.072 0.372 -0.104q 0.188 -0.032 0.34 -0.032q 0.472 0 0.828 0.168q 0.356 0.168 0.592 0.46q 0.236 0.292 0.352 0.684q 0.116 0.392 0.116 0.832q 0 0.44 -0.12 0.832q -0.12 0.392 -0.356 0.692q -0.236 0.3 -0.592 0.476q -0.356 0.176 -0.836 0.176q -0.432 0 -0.792 -0.156q -0.36 -0.156 -0.528 -0.5h -0.016v 0.56h -0.68Z m 3.2 -2.032q 0 -0.304 -0.064 -0.592q -0.064 -0.288 -0.208 -0.512q -0.144 -0.224 -0.38 -0.36q -0.236 -0.136 -0.588 -0.136q -0.352 0 -0.6 0.132q -0.248 0.132 -0.404 0.348q -0.156 0.216 -0.228 0.5q -0.072 0.284 -0.072 0.588q 0 0.288 0.068 0.568q 0.068 0.28 0.22 0.5q 0.152 0.22 0.392 0.356q 0.24 0.136 0.584 0.136q 0.328 0 0.572 -0.128q 0.244 -0.128 0.4 -0.344q 0.156 -0.216 0.232 -0.492q 0.076 -0.276 0.076 -0.564Z "/></symbol><symbol id="g56F73A9DDE7688229227FB61E73B22EB" overflow="visible"><path d="M 0 0m 1.008 2.032q 0 0.304 0.064 0.592q 0.064 0.288 0.208 0.512q 0.144 0.224 0.384 0.36q 0.24 0.136 0.584 0.136q 0.352 0 0.6 -0.132q 0.248 -0.132 0.404 -0.348q 0.156 -0.216 0.228 -0.5q 0.072 -0.284 0.072 -0.588q 0 -0.288 -0.068 -0.568q -0.068 -0.28 -0.22 -0.5q -0.152 -0.22 -0.392 -0.356q -0.24 -0.136 -0.584 -0.136q -0.328 0 -0.572 0.128q -0.244 0.128 -0.4 0.344q -0.156 0.216 -0.232 0.492q -0.076 0.276 -0.076 0.564Z m 3.2 -2.032v 5.712h -0.68v -2.128h -0.016q -0.112 0.184 -0.276 0.308q -0.164 0.124 -0.348 0.2q -0.184 0.076 -0.368 0.108q -0.184 0.032 -0.344 0.032q -0.472 0 -0.828 -0.172q -0.356 -0.172 -0.592 -0.464q -0.236 -0.292 -0.352 -0.684q -0.116 -0.392 -0.116 -0.832q 0 -0.44 0.12 -0.832q 0.12 -0.392 0.356 -0.688q 0.236 -0.296 0.592 -0.472q 0.356 -0.176 0.836 -0.176q 0.432 0 0.792 0.152q 0.36 0.152 0.528 0.496h 0.016v -0.56h 0.68Z "/></symbol><symbol id="gA140E16CF1ABF13007304C5857587282" overflow="visible"><path d="M 0 0m 0.536 5.712v -5.712h 0.68v 0.552h 0.016q 0.112 -0.184 0.276 -0.308q 0.164 -0.124 0.348 -0.196q 0.184 -0.072 0.372 -0.104q 0.188 -0.032 0.34 -0.032q 0.472 0 0.828 0.168q 0.356 0.168 0.592 0.46q 0.236 0.292 0.352 0.684q 0.116 0.392 0.116 0.832q 0 0.44 -0.12 0.832q -0.12 0.392 -0.356 0.692q -0.236 0.3 -0.592 0.476q -0.356 0.176 -0.836 0.176q -0.432 0 -0.792 -0.156q -0.36 -0.156 -0.528 -0.5h -0.016v 2.136h -0.68Z m 3.2 -3.608q 0 -0.304 -0.064 -0.592q -0.064 -0.288 -0.208 -0.512q -0.144 -0.224 -0.38 -0.36q -0.236 -0.136 -0.588 -0.136q -0.352 0 -0.6 0.132q -0.248 0.132 -0.404 0.348q -0.156 0.216 -0.228 0.5q -0.072 0.284 -0.072 0.588q 0 0.288 0.068 0.568q 0.068 0.28 0.22 0.5q 0.152 0.22 0.392 0.356q 0.24 0.136 0.584 0.136q 0.328 0 0.572 -0.128q 0.244 -0.128 0.4 -0.344q 0.156 -0.216 0.232 -0.492q 0.076 -0.276 0.076 -0.564Z "/></symbol><symbol id="g9DE8B4E528C361BFE10E18BF85136915" overflow="visible"><path d="M 0 0m 2.136 -0.552q -0.12 -0.304 -0.236 -0.512q -0.116 -0.208 -0.256 -0.34q -0.14 -0.132 -0.312 -0.192q -0.172 -0.06 -0.396 -0.06q -0.12 0 -0.24 0.016q -0.12 0.016 -0.232 0.056v 0.624q 0.088 -0.04 0.204 -0.068q 0.116 -0.028 0.196 -0.028q 0.208 0 0.348 0.1q 0.14 0.1 0.212 0.284l 0.28 0.696l -1.64 4.112h 0.768l 1.208 -3.384h 0.016l 1.16 3.384h 0.72l -1.8 -4.688Z "/></symbol><symbol id="g32B342CADBF6914BAE52C992C70E94C0" overflow="visible"><path d="M 0 0m 1.232 4.88v 0.832h -0.68v -0.832h 0.68Z m -0.68 -0.744v -4.136h 0.68v 4.136h -0.68Z "/></symbol><symbol id="g53D2D7990B1448118A03E4A23C44B622" overflow="visible"><path d="M 0 0m 0.512 4.136v -4.136h 0.68v 2.576q 0 0.12 0.06 0.3q 0.06 0.18 0.192 0.348q 0.132 0.168 0.344 0.288q 0.212 0.12 0.508 0.12q 0.232 0 0.38 -0.068q 0.148 -0.068 0.236 -0.192q 0.088 -0.124 0.124 -0.292q 0.036 -0.168 0.036 -0.368v -2.712h 0.68v 2.576q 0 0.48 0.288 0.768q 0.288 0.288 0.792 0.288q 0.248 0 0.404 -0.072q 0.156 -0.072 0.244 -0.196q 0.088 -0.124 0.12 -0.292q 0.032 -0.168 0.032 -0.36v -2.712h 0.68v 3.032q 0 0.32 -0.1 0.548q -0.1 0.228 -0.28 0.372q -0.18 0.144 -0.432 0.212q -0.252 0.068 -0.564 0.068q -0.408 0 -0.748 -0.184q -0.34 -0.184 -0.548 -0.52q -0.128 0.384 -0.44 0.544q -0.312 0.16 -0.696 0.16q -0.872 0 -1.336 -0.704h -0.016v 0.608h -0.64Z "/></symbol><symbol id="g39FF3551F1CB57B29C5CAADE5C30FA34" overflow="visible"><path d="M 0 0m 0.664 0.888v -0.888h 0.888v 0.888h -0.888Z "/></symbol></defs></svg>
\ No newline at end of file
diff --git a/docs/src/static/variant-hierarchy.svg b/docs/src/static/variant-hierarchy.svg
index 9a466eec3..04252bf5b 100644
--- a/docs/src/static/variant-hierarchy.svg
+++ b/docs/src/static/variant-hierarchy.svg
@@ -1,766 +1 @@
-<svg class="typst-doc" viewBox="0 0 580.113245511811 189.44601565354327" width="580.113245511811pt" height="189.44601565354327pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h5="http://www.w3.org/1999/xhtml">
-    <g>
-        <g class="typst-group" transform="matrix(1 0 0 1 5 5)">
-            <g>
-                <g class="typst-group">
-                    <g>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 127.12545659842516 31.62058258267711)" d="M 0 0m 0.000000000000025176711 22.177166 l -0.000000000000025176711 -22.177166 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 127.12545656692915 31.620582708661402)" d="M 0 0c 0.9273351 2.016171 2.7557724 3.4731827 4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 122.19737137670406 31.620582708661402)" d="M 0 0m 4.9280853 0 c -0.92733526 2.016171 -2.7557724 3.4731827 -4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 57.91810381041723 72.46169497785961)" d="M 0 0m 0 22.473097 l 41.5327 -22.473097 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 98.0498252823698 72.4616948976378)" d="M 0 0m 1.40098 0 c -1.3319149 1.7750765 -1.7432189 4.0765743 -1.1085647 6.2030993 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 93.65175203524791 69.9962664173967)" d="M 0 0m 5.799053 2.4654286 c -2.2145405 0.14388919 -4.3661275 -0.7708436 -5.799053 -2.4654286 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 127.12545659842517 72.72374812598423)" d="M 0 0m 0 22.177166 v -22.177166 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 127.12545656692915 72.72374825196849)" d="M 0 0c 0.9273351 2.016171 2.7557724 3.4731827 4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 122.19737137670406 72.72374825196849)" d="M 0 0m 4.9280853 0 c -0.92733526 2.016171 -2.7557724 3.4731827 -4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 155.27871129505246 72.42663009434959)" d="M 0 0m 42.676 22.474283 l -42.676 -22.474283 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 155.27871118110235 69.89606623238521)" d="M 0 0m 0 2.5305638 c 2.2160206 0.11894679 4.357173 -0.8199527 5.770929 -2.5305638 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 155.27871118110235 72.42663004724409)" d="M 0 0c 1.3518162 1.7599685 1.7890066 4.05669 1.1783348 6.190226 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 194.279381036 113.73183748194954)" d="M 0 0m 0 22.272242 l 16.133612 -22.272242 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 210.27914614473883 113.73183751181101)" d="M 0 0m 0.1338468 0 c -0.43176514 2.1768036 0.19425048 4.429395 1.6872652 6.071285 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 204.1182581089316 113.73183751181101)" d="M 0 0m 6.294735 0 c -1.9337664 1.0887808 -4.2692633 1.1961051 -6.294735 0.2892656 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 241.31203312502686 113.77178312710771)" d="M 0 0m 11.405975 22.232296 l -11.405975 -22.232296 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 241.31203303937008 113.77178305511808)" d="M 0 0c 1.7454053 1.3705674 4.037318 1.8323038 6.1772647 1.2444924 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 238.71987503206995 113.77178305511808)" d="M 0 0m 2.592158 0 c 0.09523225 2.2171662 -0.8665203 4.3481507 -2.592158 5.743525 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 396.466878015748 72.72374812598427)" d="M 0 0m 0 22.177166 v -22.177166 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 396.4668779527559 72.72374825196849)" d="M 0 0c 0.9273351 2.016171 2.7557724 3.4731827 4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 391.5387927625309 72.72374825196849)" d="M 0 0m 4.9280853 0 c -0.92733526 2.016171 -2.7557724 3.4731827 -4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 396.4668780157482 31.62058258267734)" d="M 0 0m 0 22.177166 v -22.177166 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 396.4668779527559 31.620582708661402)" d="M 0 0c 0.9273351 2.016171 2.7557724 3.4731827 4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 391.5387927625309 31.620582708661402)" d="M 0 0m 4.9280853 0 c -0.92733526 2.016171 -2.7557724 3.4731827 -4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 465.71997526463826 30.09404852216683)" d="M 0 0m 0 25.26112 l 30.355688 -25.26112 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 495.3919826049906 30.094048346456674)" d="M 0 0m 0.6836814 0 c -0.95657516 2.0024633 -0.90695035 4.339898 0.13375086 6.2999587 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 489.9048489771738 28.817956977625926)" d="M 0 0m 6.170815 1.2760913 c -2.1429272 0.5768515 -4.432447 0.10339117 -6.170815 -1.2760913 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 487.4285842483744 31.550909461319364)" d="M 0 0m 0 22.24684 l 13.16195 -22.24684 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 500.5532774195091 31.55090938582677)" d="M 0 0m 0.037257448 0 c -0.22850081 2.207415 0.6032539 4.3924203 2.2417822 5.889123 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 494.3495680831244 31.55090938582677)" d="M 0 0m 6.240967 0 c -1.8247294 1.2630347 -4.140277 1.5859942 -6.240967 0.8704549 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 507.10634006299205 31.62058258267711)" d="M 0 0m 0 22.177166 l 0.000000000000100706844 -22.177166 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 507.1063401259842 31.620582708661402)" d="M 0 0c 0.9273351 2.016171 2.7557724 3.4731827 4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 502.1782549357592 31.620582708661402)" d="M 0 0m 4.9280853 0 c -0.92733526 2.016171 -2.7557724 3.4731827 -4.9280853 3.9270024 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 513.6221454765276 31.550909461319364)" d="M 0 0m 13.16195 22.24684 l -13.16195 -22.24684 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 513.6221453858268 31.55090938582677)" d="M 0 0c 1.8247294 1.2630347 4.140277 1.5859942 6.240967 0.8704549 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 511.3803631896651 31.55090938582677)" d="M 0 0m 2.2417822 0 c 0.22850084 2.207415 -0.60325384 4.3924203 -2.2417822 5.889123 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 518.1370161038857 30.094048575397373)" d="M 0 0m 30.355688 25.26112 l -30.355688 -25.26112 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 518.1370162204723 28.817956977625926)" d="M 0 0m 0 1.2760913 c 2.1429274 0.5768515 4.432447 0.10339117 6.170815 -1.2760913 "/>
-                        <path class="typst-shape" fill="none" stroke="#64748b" stroke-width="1" stroke-linecap="round" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 518.0032653902913 30.094048346456674)" d="M 0 0m 0.13375083 0 c 0.95657516 2.0024633 0.9069505 4.339898 -0.13375083 6.2999587 "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 96.84545659837518 0)" d="M 0 0h 60.56 v 7.14 h -60.56 v -7.14 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 96.84545648818894 -0.00000009448818426195845)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000004999714378289526 7.139999999999999)">
-                                                    <use xlink:href="#g669BD235869889BDF946F7D74B43299F" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g6039E9718934F8358AFBA066AB1E1D34" x="7.590000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g708E1061457335A9700D72CAC4F879A3" x="11.48" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gAC6E804F15E6999EE71F805512F26550" x="17.22" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g6D32D2D4BF1DD877D4B5269BD6400D6B" x="23.33" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gCA1CBF0434CFDD20D754D66658D3AF1F" x="32.04" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g5976208ADE7B9F7852981FBD3C9164A" x="38.15" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gAC6E804F15E6999EE71F805512F26550" x="43.339999999999996" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g769AC14B8720B1A4D53E0E7BB92AAAC0" x="49.449999999999996" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g55B6FC3B395E7CA8B028D87603BB0605" x="55.19" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 377.1218780156981 0)" d="M 0 0h 38.69 v 7.14 h -38.69 v -7.14 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 377.12187790551184 -0.00000009448818426195845)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 7.139999999999999)">
-                                                    <use xlink:href="#gC84EDC6FBAC0CE2EFC24569B0177ECD5" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g769AC14B8720B1A4D53E0E7BB92AAAC0" x="9.44" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g4F32DCC5CEA421B0EDD79EB9B8B18787" x="15.18" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g53CE0EDC53D4ECE2FFD9259C5CC1AE51" x="17.759999999999998" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g6D32D2D4BF1DD877D4B5269BD6400D6B" x="23.869999999999997" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g709986D1AD07B5D6C62F4F10C982F993" x="29.799999999999997" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g55B6FC3B395E7CA8B028D87603BB0605" x="33.31999999999999" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 486.27634006294204 0)" d="M 0 0h 41.66 v 7.14 h -41.66 v -7.14 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 486.27633995275585 -0.00000009448818426195845)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 7.139999999999999)">
-                                                    <use xlink:href="#g62F0E2E5CCBA1EC061CCCA42BF03BD67" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gC82E65AC956B3FEDC3323A1DF128185D" x="10" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g708E1061457335A9700D72CAC4F879A3" x="16.3" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gF87923E104CC15BE09B4120335A8FEC4" x="22.04" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g879D08C569DBB924818BD3C3C3D32E4E" x="24.619999999999997" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g769AC14B8720B1A4D53E0E7BB92AAAC0" x="30.549999999999997" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g55B6FC3B395E7CA8B028D87603BB0605" x="36.29" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 96.54195656692913 12.694582582677151)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 51.167 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -51.167 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 102.54195659837518 18.694582677165354)" d="M 0 0h 49.167 v 6.426 h -49.167 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 102.54195645669289 18.694582677165346)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 6.425999999999999)">
-                                                    <use xlink:href="#g641F1DE27A4B048908B0028DB805B317" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g124215DF7EB2152435C4CCD8DC3AEA76" x="6.498" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="10.998000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g4B31B8CEB3E48D08D063331B59F6BBAB" x="16.335" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="21.168" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g9ED3C7BE04AE098F91DCEB215E1CAC9A" x="24.165" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="30.996" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="33.993" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="38.826" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="44.163" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 94.78695656692913 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 54.677 c 2.7589226 0 5.000004 -2.2410812 5.000004 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5.000004 -5 h -54.677 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 100.78695659837518 59.79774803149605)" d="M 0 0h 52.677 v 6.426 h -52.677 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 100.78695645669289 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000004999714378289526 6.425999999999999)">
-                                                    <use xlink:href="#g813F0103BE3CE7D676D52F9A0F5776CD" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="5.832" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD978DC9CC0B9AE918886416C8F39495D" x="7.83" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="15.507" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE14823C6D5887C5946C79D53BC50B1DF" x="20.844" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g4B31B8CEB3E48D08D063331B59F6BBAB" x="22.842000000000002" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g9ED3C7BE04AE098F91DCEB215E1CAC9A" x="27.675000000000004" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="34.50600000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="37.50300000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="42.336000000000006" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="47.673" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 0 94.90091338582677)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 52.499 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -52.499 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 5.999999905461805 100.90091338582675)" d="M 0 0h 50.499 v 6.426 h -50.499 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 5.999999763779523 100.90091338582677)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 6.425999999999999)">
-                                                    <use xlink:href="#gCCF6F62EDE72A2783EDD776715FF2521" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE14823C6D5887C5946C79D53BC50B1DF" x="5.832" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="7.83" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBF6C7CC99FD9658A0BCA7C9307EFE887" x="12.663" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="17.667" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="22.5" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g9ED3C7BE04AE098F91DCEB215E1CAC9A" x="25.497" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="32.328" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="35.325" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="40.158" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="45.495000000000005" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 91.70895656692913 94.90091338582677)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 60.833 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -60.833 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 97.70895659837517 100.90091338582675)" d="M 0 0h 58.833 v 6.426 h -58.833 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 97.70895645669289 100.90091338582677)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000430515849977 6.425999999999999)">
-                                                    <use xlink:href="#g4C14CF88950BA583FF1F70F2AC32556F" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="6.165" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="8.163" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="13.5" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="18.333" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g87DCE9BAA18E83AE0AA9F4A317AAF534" x="21.33" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="24.165" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g87DCE9BAA18E83AE0AA9F4A317AAF534" x="26.163" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g4B31B8CEB3E48D08D063331B59F6BBAB" x="28.998" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g9ED3C7BE04AE098F91DCEB215E1CAC9A" x="33.831" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="40.662000000000006" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="43.659000000000006" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="48.492000000000004" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="53.82900000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 191.75191341732284 94.90091338582677)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 60.842003 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -60.842003 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 197.7519132912886 100.90091338582675)" d="M 0 0h 58.842 v 6.426 h -58.842 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 197.75191314960628 100.90091338582677)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000430515849977 6.425999999999999)">
-                                                    <use xlink:href="#g3EEFA5F67AA62934351B04ACAD7700B7" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBF6C7CC99FD9658A0BCA7C9307EFE887" x="6.498" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="11.502" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g87DCE9BAA18E83AE0AA9F4A317AAF534" x="13.5" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gC4452AF47A66FE705AB14D2AB364C607" x="16.335" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="22.671" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD46906E080E9F801E0E94D1932E8451F" x="24.669" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gFB59D557F363E86096A9F4459DDFD8F3" x="29.169" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g9ED3C7BE04AE098F91DCEB215E1CAC9A" x="33.84" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="40.67100000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="43.668000000000006" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="48.501000000000005" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="53.83800000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 140.05868485039372 136.0040786456693)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 64.181 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -64.181 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 146.05868494483187 142.00407874015747)" d="M 0 0h 62.181 v 6.426 h -62.181 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 146.0586848031496 142.00407874015747)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000430515849977 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="6.003000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBF6C7CC99FD9658A0BCA7C9307EFE887" x="8.001000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g7691E6040D648DC4C509121677FE43B4" x="13.005000000000003" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD46906E080E9F801E0E94D1932E8451F" x="18.171000000000003" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g813F0103BE3CE7D676D52F9A0F5776CD" x="22.671000000000003" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g70A5EED08A4892697C9F8AF4CED29F38" x="28.503000000000004" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g81941A84CFD7B2E6E64D490082E56BB7" x="33.507000000000005" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g7691E6040D648DC4C509121677FE43B4" x="38.84400000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="44.010000000000005" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="47.007000000000005" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="51.84" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="57.17700000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 225.05239162204725 136.0040786456693)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 80.678 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -80.678 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 231.05239163774525 142.00407874015747)" d="M 0 0h 78.678 v 6.426 h -78.678 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 231.05239149606294 142.00407874015747)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 6.425999999999999)">
-                                                    <use xlink:href="#g5E7F3EDE6694ACAB83B07765FD7C88CC" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="4.338" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="7.335" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="9.333" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBF6C7CC99FD9658A0BCA7C9307EFE887" x="14.166" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g7691E6040D648DC4C509121677FE43B4" x="19.17" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g70A5EED08A4892697C9F8AF4CED29F38" x="24.336000000000002" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE14823C6D5887C5946C79D53BC50B1DF" x="29.340000000000003" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="31.338000000000005" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="36.17100000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g813F0103BE3CE7D676D52F9A0F5776CD" x="39.168000000000006" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g70A5EED08A4892697C9F8AF4CED29F38" x="45.00000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g81941A84CFD7B2E6E64D490082E56BB7" x="50.004000000000005" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g7691E6040D648DC4C509121677FE43B4" x="55.34100000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gE596B299A30367997DC94AB9B8B72FA7" x="60.507000000000005" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g3302C695557CE7E554F0836D2CDF4B83" x="63.504000000000005" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g2801BEF568718ADDC2ABAF998D0A388F" x="68.337" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gD1A2B325D26318856C7583CB173E0EF5" x="73.674" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#fce7f3" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 384.1308779527559 12.694582582677151)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 14.672001 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -14.672001 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 390.13087801569804 18.694582677165354)" d="M 0 0h 12.672 v 6.426 h -12.672 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 390.13087787401577 18.694582677165346)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g73CBF4CE1C6B6F76004C71E0D960877F" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gAA9BA5DCE3B7BAD11A37A99523970BA1" x="2.6639999999999997" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g170E3DF111F34A5B640D30A3D024062D" x="7.668" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#fce7f3" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 384.4638779527559 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 14.0060005 c 2.7589188 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410812 -5 -5 -5 h -14.0060005 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 390.46387801569807 59.79774803149605)" d="M 0 0h 12.006 v 6.426 h -12.006 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 390.4638778740158 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g43FC2516192D0F251704B273D511AB8" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g825BFEEBA88E24CB932EEEE0C5250EC" x="1.998" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g48F95159F05E08FF24029F09E94D9EBD" x="7.002000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#fce7f3" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 382.1283779527559 94.90091338582677)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 18.677 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -18.677 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 388.1283780156981 100.90091338582675)" d="M 0 0h 16.677 v 6.426 h -16.677 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 388.12837787401577 100.90091338582677)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.00000000005000072447069752 6.425999999999999)">
-                                                    <use xlink:href="#gF70B1EB6DF5EEB5418258DA74EF6450A" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBF6C7CC99FD9658A0BCA7C9307EFE887" x="6.840000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g4B31B8CEB3E48D08D063331B59F6BBAB" x="11.844000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 494.8558401259843 12.694582582677151)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 14.500999 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -14.500999 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 500.8558400629421 18.694582677165354)" d="M 0 0h 12.501 v 6.426 h -12.501 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 500.8558399212598 18.694582677165346)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gCE9C5FDCB0FB9D903B0471E1194A86FD" x="6.003000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 444.09943474015745 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 13.007 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -13.007 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 450.09943470861134 59.79774803149605)" d="M 0 0h 11.007 v 6.426 h -11.007 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 450.0994345669291 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g59D5A1C590864C9D7659EE9E44D8B385" x="6.003000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 469.8511372913386 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 13.007 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -13.007 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 475.8511373857768 59.79774803149605)" d="M 0 0h 11.007 v 6.426 h -11.007 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 475.8511372440945 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g48F95159F05E08FF24029F09E94D9EBD" x="6.003000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 495.60284012598424 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 13.007 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -13.007 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 501.60284006294216 59.79774803149605)" d="M 0 0h 11.007 v 6.426 h -11.007 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 501.60283992125983 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g825BFEEBA88E24CB932EEEE0C5250EC" x="6.003000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 521.3545426771652 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 13.007 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -13.007 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 527.3545427401075 59.79774803149605)" d="M 0 0h 11.007 v 6.426 h -11.007 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 527.354542598425 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#g170E3DF111F34A5B640D30A3D024062D" x="6.003000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                        <path class="typst-shape" fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="matrix(1 0 0 1 547.106245511811 53.79774812598424)" d="M 0 0m 5 0 c -2.75892 0 -5 2.24108 -5 5 v 8.426 c 0 2.7589197 2.24108 5.000001 5 5.000001 h 13.007 c 2.7589207 0 5 -2.2410812 5 -5.000001 v -8.426 c 0 -2.75892 -2.2410793 -5 -5 -5 h -13.007 Z "/>
-                        <path class="typst-shape" fill="none" transform="matrix(1 0 0 1 553.1062454172728 59.79774803149605)" d="M 0 0h 11.007 v 6.426 h -11.007 v -6.426 Z "/>
-                        <g class="typst-group">
-                            <g>
-                                <g class="typst-group" transform="matrix(1 0 0 1 553.1062452755904 59.797748031496056)">
-                                    <g>
-                                        <g class="typst-group">
-                                            <g>
-                                                <g class="typst-text" transform="matrix(1 0 0 -1 0.000000000049999829298746954 6.425999999999999)">
-                                                    <use xlink:href="#g75C1983CA166B2AED4C5CCCA97BF3B6A" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                    <use xlink:href="#gBB143EC3C95E2D7D22714C2C87E91ED" x="6.003000000000001" y="0" fill="#1e293b" fill-rule="nonzero"/>
-                                                </g>
-                                            </g>
-                                        </g>
-                                    </g>
-                                </g>
-                            </g>
-                        </g>
-                    </g>
-                </g>
-            </g>
-        </g>
-        <g class="typst-text" transform="matrix(1 0 0 -1 5 184.44601565354327)">
-            <use xlink:href="#gA590B7DC033E470D6BAF5CDFC85B2050" x="0" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g8B593199FA06CCE05316E9DE69A76C04" x="5.184" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g8B593199FA06CCE05316E9DE69A76C04" x="7.848000000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g77DE0CDDDA90F97D0E6338DF2ADA2B05" x="10.368000000000002" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gDAB705390D499B70C1CEEA1CADFAB46C" x="14.96" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g5BA2C50E2FB253176C23A29D28811B37" x="21.024" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g900615605685504312176826BFAA7CD0" x="27.248" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g77DE0CDDDA90F97D0E6338DF2ADA2B05" x="31.992" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g924EAF2D52C629B054774FEED87B1A3" x="36.584" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g140CE90B08CDC407F2943E5829DFF5DD" x="38.36000000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gFC264C0FD775885BC630DFC00D9E2FE7" x="42.80800000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gEF2A2A1EFDC1817766F824B6B7E6A1" x="47.55200000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g8B593199FA06CCE05316E9DE69A76C04" x="49.92000000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g77DE0CDDDA90F97D0E6338DF2ADA2B05" x="52.440000000000005" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gA5BD779142255ABB4257B527699904C3" x="57.03200000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g5BA2C50E2FB253176C23A29D28811B37" x="66.08000000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g900615605685504312176826BFAA7CD0" x="70.08000000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gE037EFFB7D6AFF5A7E0FD7AFE38271D9" x="74.82400000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gEBC5194FC1C7A48F06C53C940408D757" x="79.12000000000002" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g924EAF2D52C629B054774FEED87B1A3" x="83.41600000000003" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gAD3C9196DFD8002DD8AD647251EA8E6" x="85.19200000000002" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gEBC5194FC1C7A48F06C53C940408D757" x="89.33600000000003" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gFC264C0FD775885BC630DFC00D9E2FE7" x="95.85600000000004" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g77DE0CDDDA90F97D0E6338DF2ADA2B05" x="98.37600000000003" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g403726A1DBA9CA6272A92801D756F7C" x="105.19200000000004" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gE037EFFB7D6AFF5A7E0FD7AFE38271D9" x="109.78400000000003" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g140CE90B08CDC407F2943E5829DFF5DD" x="114.08000000000004" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gE037EFFB7D6AFF5A7E0FD7AFE38271D9" x="118.52800000000005" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g8B593199FA06CCE05316E9DE69A76C04" x="122.82400000000005" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gFFA01FEE3974FB44A414D4377DF74C95" x="125.48800000000006" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g8C3B87D37300021CAF28AE99C6A53743" x="129.78400000000005" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gEA2E7995284F078BE317DAED71DE81DC" x="133.78400000000005" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g5BA2C50E2FB253176C23A29D28811B37" x="135.85600000000005" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g8F6718057B0E3514573AA9B4A2FC38A1" x="139.85600000000005" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g11B4CFF4C9AF9181ECD6A36A02010591" x="144.30400000000006" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gFC264C0FD775885BC630DFC00D9E2FE7" x="149.04800000000006" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gB6FD75F5298B86FC5D51AC6F195ECA25" x="151.56800000000007" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g900615605685504312176826BFAA7CD0" x="155.56800000000007" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gE037EFFB7D6AFF5A7E0FD7AFE38271D9" x="160.31200000000007" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gF6E6E618EB7A8A012445F280241D7C98" x="166.83200000000005" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g924EAF2D52C629B054774FEED87B1A3" x="171.57600000000005" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g8B593199FA06CCE05316E9DE69A76C04" x="173.35200000000006" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gE037EFFB7D6AFF5A7E0FD7AFE38271D9" x="175.87200000000007" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gEBC5194FC1C7A48F06C53C940408D757" x="180.16800000000006" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#gFC264C0FD775885BC630DFC00D9E2FE7" x="184.46400000000006" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g924EAF2D52C629B054774FEED87B1A3" x="186.98400000000007" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g77DE0CDDDA90F97D0E6338DF2ADA2B05" x="188.76000000000008" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g140CE90B08CDC407F2943E5829DFF5DD" x="193.3520000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g38385C688BB0F21A935DCB07A45652A7" x="197.8000000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-            <use xlink:href="#g9A3A3A35D6C54D3285C5E0F1A91F795E" x="199.8720000000001" y="0" fill="#6b7280" fill-rule="nonzero"/>
-        </g>
-    </g>
-    <defs id="glyph">
-        <symbol id="g669BD235869889BDF946F7D74B43299F" overflow="visible">
-            <path d="M 0 0m 5.85 0.81 l 0.15999985 -0.81 h 1 v 3.86 h -3 v -1.1699998 h 1.5799999 q -0.069999695 -0.7500001 -0.4949999 -1.1450001 q -0.4249997 -0.39499998 -1.2049999 -0.39499998 q -0.53 0 -0.89999986 0.20500004 q -0.37000012 0.20499992 -0.60000014 0.54499996 q -0.23000002 0.34000003 -0.3349998 0.765 q -0.10500014 0.42499995 -0.10500014 0.875 q 0 0.4699998 0.10500014 0.90999985 q 0.10499978 0.44000006 0.3349998 0.78499985 q 0.23000002 0.34500027 0.60000014 0.5500002 q 0.3699999 0.20499992 0.89999986 0.20499992 q 0.5700002 0 0.9699998 -0.2999997 q 0.4000001 -0.3000002 0.54000044 -0.9000001 h 1.4999995 q -0.059999943 0.61000013 -0.32999992 1.0799999 q -0.26999998 0.4699998 -0.68499994 0.78999996 q -0.41499996 0.32000017 -0.9299998 0.48500013 q -0.51499987 0.16499996 -1.065 0.16499996 q -0.81999993 0 -1.4749999 -0.28999996 q -0.655 -0.28999996 -1.105 -0.8000002 q -0.45 -0.50999975 -0.68999994 -1.1949997 q -0.24000001 -0.6850004 -0.24000001 -1.4850001 q 0 -0.78 0.24000001 -1.4549999 q 0.23999995 -0.6750001 0.68999994 -1.1750001 q 0.45000005 -0.49999997 1.105 -0.78499997 q 0.655 -0.285 1.4749999 -0.285 q 0.52 0 1.0300002 0.215 q 0.50999975 0.21499997 0.9299998 0.755 Z "/>
-        </symbol>
-        <symbol id="g6039E9718934F8358AFBA066AB1E1D34" overflow="visible">
-            <path d="M 0 0m 0.53999996 5.17 v -5.17 h 1.42 v 2.33 q 0 0.3499999 0.07000005 0.6500001 q 0.06999993 0.29999995 0.2349999 0.52499986 q 0.16499996 0.22500014 0.43500018 0.35500002 q 0.26999998 0.13000011 0.65999985 0.13000011 q 0.13000011 0 0.26999998 -0.015000105 q 0.1400001 -0.015000105 0.24000001 -0.035000086 v 1.3199999 q -0.17000008 0.05000019 -0.30999994 0.05000019 q -0.26999998 0 -0.52 -0.07999992 q -0.25 -0.07999992 -0.47000003 -0.2249999 q -0.22000003 -0.14500046 -0.38999987 -0.35000038 q -0.17000008 -0.20499992 -0.2700001 -0.4449997 h -0.01999998 v 0.96000004 h -1.35 Z "/>
-        </symbol>
-        <symbol id="g708E1061457335A9700D72CAC4F879A3" overflow="visible">
-            <path d="M 0 0m 0.48 3.58 q 0.030000001 0.5 0.24999997 0.8299999 q 0.22000003 0.32999992 0.56 0.5300002 q 0.34000003 0.19999981 0.7650001 0.28499985 q 0.42499995 0.08500004 0.8549998 0.08500004 q 0.3900001 0 0.78999996 -0.05499983 q 0.4000001 -0.055000305 0.73 -0.21500015 q 0.32999992 -0.15999985 0.53999996 -0.44500017 q 0.21000004 -0.28499985 0.21000004 -0.7549999 v -2.69 q 0 -0.35000002 0.03999996 -0.66999996 q 0.03999996 -0.32 0.13999987 -0.48 h -1.4399998 q -0.03999996 0.12 -0.06499982 0.24499999 q -0.025000095 0.12500001 -0.035000086 0.255 q -0.3399999 -0.35000002 -0.79999995 -0.49 q -0.46000004 -0.14 -0.94000006 -0.14 q -0.37 0 -0.68999994 0.089999996 q -0.32000005 0.089999996 -0.56 0.28 q -0.24000001 0.18999998 -0.375 0.47999996 q -0.13499999 0.29000002 -0.13499999 0.69 q 0 0.43999994 0.155 0.725 q 0.155 0.28499985 0.4 0.45499992 q 0.245 0.17000008 0.55999994 0.2550001 q 0.31500006 0.0849998 0.635 0.13499999 q 0.31999993 0.049999952 0.6300001 0.07999992 q 0.30999994 0.029999971 0.54999995 0.089999914 q 0.24000001 0.06000018 0.37999988 0.17499995 q 0.1400001 0.11500001 0.13000011 0.33500004 q 0 0.23000002 -0.07500005 0.36500025 q -0.07500005 0.13499975 -0.20000005 0.21000004 q -0.125 0.07499981 -0.28999996 0.099999905 q -0.16499996 0.025000095 -0.35500002 0.025000095 q -0.42000008 0 -0.65999985 -0.1800003 q -0.24000013 -0.17999983 -0.2800001 -0.5999999 h -1.42 Z m 3.28 -1.05 q -0.09000015 -0.07999992 -0.22500014 -0.125 q -0.13499999 -0.045000076 -0.28999996 -0.07500005 q -0.15499997 -0.029999971 -0.32500005 -0.049999952 q -0.16999984 -0.01999998 -0.3399999 -0.049999952 q -0.16000009 -0.029999971 -0.31500006 -0.08000016 q -0.15499997 -0.049999952 -0.26999986 -0.13499999 q -0.11500001 -0.08499992 -0.18500006 -0.21499991 q -0.06999993 -0.13 -0.06999993 -0.33000004 q 0 -0.18999994 0.06999993 -0.31999993 q 0.07000005 -0.13 0.19000006 -0.20499998 q 0.119999886 -0.07499999 0.27999997 -0.10500002 q 0.16000009 -0.029999971 0.32999992 -0.029999971 q 0.42000008 0 0.6500001 0.13999999 q 0.23000002 0.14000005 0.3399999 0.33499998 q 0.109999895 0.19500005 0.13499999 0.39499998 q 0.025000095 0.20000005 0.025000095 0.32000005 v 0.53 Z "/>
-        </symbol>
-        <symbol id="gAC6E804F15E6999EE71F805512F26550" overflow="visible">
-            <path d="M 0 0m 3.1499999 0.93 q -0.3399999 0 -0.5799999 0.13999993 q -0.24000001 0.13999999 -0.385 0.365 q -0.14499998 0.22500002 -0.21000004 0.525 q -0.06499994 0.30000007 -0.06499994 0.61 q 0 0.31999993 0.059999943 0.6199999 q 0.060000062 0.3000002 0.20500004 0.5300002 q 0.14499998 0.22999978 0.37999988 0.37499976 q 0.23500013 0.14499998 0.58500004 0.14499998 q 0.34000015 0 0.57500005 -0.14499998 q 0.2349999 -0.14499998 0.385 -0.37999988 q 0.1500001 -0.2349999 0.21500015 -0.5350001 q 0.06500006 -0.29999995 0.06500006 -0.6099999 q 0 -0.30999994 -0.06000042 -0.61 q -0.059999943 -0.29999995 -0.20499992 -0.525 q -0.14499974 -0.22500002 -0.37999988 -0.365 q -0.2349999 -0.13999993 -0.58500004 -0.13999993 Z m -2.61 4.2400002 v -6.98 h 1.42 v 2.4499998 h 0.01999998 q 0.2600001 -0.38 0.6650001 -0.575 q 0.40499997 -0.195 0.885 -0.195 q 0.56999993 0 0.9950001 0.22 q 0.4249997 0.22 0.70999956 0.59000003 q 0.28500032 0.36999995 0.4250002 0.84999996 q 0.13999987 0.48000002 0.13999987 1 q 0 0.54999995 -0.13999987 1.0550001 q -0.13999987 0.50499964 -0.42999983 0.88499975 q -0.28999996 0.3800001 -0.73 0.61000013 q -0.44000006 0.23000002 -1.0500002 0.23000002 q -0.47999978 0 -0.8799999 -0.19000006 q -0.4000001 -0.19000006 -0.65999997 -0.61000013 h -0.01999998 v 0.6600003 h -1.35 Z "/>
-        </symbol>
-        <symbol id="g6D32D2D4BF1DD877D4B5269BD6400D6B" overflow="visible">
-            <path d="M 0 0m 0.53999996 7.14 v -7.14 h 1.42 v 2.71 q 0 0.78999996 0.2600001 1.135 q 0.26 0.34500003 0.8399999 0.34500003 q 0.51 0 0.71000004 -0.31500006 q 0.20000005 -0.31500006 0.20000005 -0.95500016 v -2.9199998 h 1.4199998 v 3.1799998 q 0 0.48000002 -0.08500004 0.875 q -0.08500004 0.39499998 -0.29500008 0.6700001 q -0.21000004 0.2750001 -0.5749998 0.42999983 q -0.36500025 0.15500021 -0.93499994 0.15500021 q -0.4000001 0 -0.8200002 -0.20499992 q -0.41999984 -0.20499992 -0.6899998 -0.6550002 h -0.03000009 v 2.69 h -1.42 Z "/>
-        </symbol>
-        <symbol id="gCA1CBF0434CFDD20D754D66658D3AF1F" overflow="visible">
-            <path d="M 0 0m 2.27 5.8199997 v -5.8199997 h 1.5699999 v 5.8199997 h 2.14 v 1.3200002 h -5.85 v -1.3200002 h 2.1399999 Z "/>
-        </symbol>
-        <symbol id="g5976208ADE7B9F7852981FBD3C9164A" overflow="visible">
-            <path d="M 0 0m 3.09 -0.64 l 2.16 5.81 h -1.47 l -1.1300001 -3.54 h -0.01999998 l -1.17 3.54 h -1.5099999 l 1.81 -4.85 q 0.059999943 -0.14999999 0.059999943 -0.32 q 0 -0.22999999 -0.13499999 -0.42 q -0.13499999 -0.19000003 -0.41499996 -0.22 q -0.21000004 -0.00999999 -0.42000002 0.00999999 q -0.20999998 0.01999998 -0.40999997 0.04000002 v -1.1700001 q 0.21999997 -0.01999998 0.435 -0.034999967 q 0.21500003 -0.014999986 0.43499994 -0.014999986 q 0.73 0 1.1400001 0.26999998 q 0.40999985 0.26999998 0.63999987 0.9 Z "/>
-        </symbol>
-        <symbol id="g769AC14B8720B1A4D53E0E7BB92AAAC0" overflow="visible">
-            <path d="M 0 0m 4.02 3.1399999 h -2.31 q 0.00999999 0.1500001 0.06500006 0.34000015 q 0.054999948 0.18999982 0.18999994 0.3599999 q 0.13499999 0.16999984 0.36000013 0.2850001 q 0.2249999 0.11499977 0.5649998 0.11499977 q 0.52 0 0.7750001 -0.27999997 q 0.25499988 -0.27999997 0.35500002 -0.81999993 Z m -2.31 -0.89999986 h 3.73 q 0.03999996 0.5999999 -0.10000038 1.1499999 q -0.13999987 0.54999995 -0.45499992 0.98 q -0.31500006 0.42999983 -0.8049998 0.68499994 q -0.49 0.2550001 -1.1500001 0.2550001 q -0.5899999 0 -1.0749999 -0.21000004 q -0.4849999 -0.21000004 -0.8349999 -0.5749998 q -0.35000002 -0.36500025 -0.53999996 -0.86500025 q -0.19 -0.5 -0.19 -1.0799999 q 0 -0.6 0.185 -1.0999999 q 0.18499997 -0.50000006 0.525 -0.86 q 0.3399999 -0.36 0.8299999 -0.555 q 0.49 -0.195 1.0999999 -0.195 q 0.8800001 0 1.5 0.39999998 q 0.6199999 0.39999998 0.9200001 1.3299999 h -1.25 q -0.07000017 -0.23999989 -0.37999988 -0.45499992 q -0.31000018 -0.21499997 -0.74 -0.21499997 q -0.60000014 0 -0.9200001 0.31 q -0.31999993 0.30999994 -0.35000002 1 Z "/>
-        </symbol>
-        <symbol id="g55B6FC3B395E7CA8B028D87603BB0605" overflow="visible">
-            <path d="M 0 0m 1.64 1.68 h -1.35 q 0.02000001 -0.52 0.23499998 -0.86499995 q 0.21500003 -0.345 0.54999995 -0.555 q 0.33500004 -0.21 0.765 -0.29999998 q 0.43000007 -0.089999996 0.8800001 -0.089999996 q 0.43999982 0 0.865 0.08499999 q 0.4249997 0.08499999 0.75499964 0.295 q 0.3300004 0.20999998 0.5350003 0.555 q 0.20499992 0.34499997 0.20499992 0.85499996 q 0 0.36 -0.13999987 0.6049999 q -0.14000034 0.24500012 -0.37000036 0.4100001 q -0.23000002 0.16499996 -0.5249996 0.26499987 q -0.29500008 0.10000014 -0.60500026 0.17000008 q -0.29999995 0.06999993 -0.5899999 0.13000011 q -0.28999996 0.059999943 -0.51499987 0.13499999 q -0.22500014 0.07499981 -0.36500013 0.19499993 q -0.13999999 0.119999886 -0.13999999 0.30999994 q 0 0.16000009 0.08000004 0.25499988 q 0.08000004 0.09500027 0.19500005 0.14499998 q 0.11500001 0.05000019 0.25499988 0.06500006 q 0.1400001 0.015000343 0.26 0.015000343 q 0.3800001 0 0.6600001 -0.14500046 q 0.27999997 -0.14499998 0.30999994 -0.5549998 h 1.3500001 q -0.03999996 0.48000002 -0.24500036 0.7950001 q -0.20499992 0.31500006 -0.51499987 0.5050001 q -0.30999994 0.19000006 -0.7049999 0.26999998 q -0.39499998 0.07999992 -0.81500006 0.07999992 q -0.41999984 0 -0.81999993 -0.075000286 q -0.39999998 -0.07499981 -0.7199999 -0.25999975 q -0.32000005 -0.18499994 -0.51500005 -0.5050001 q -0.19499996 -0.3199997 -0.19499996 -0.81999993 q 0 -0.3399999 0.14000002 -0.5749998 q 0.13999999 -0.23500013 0.36999995 -0.3900001 q 0.23000002 -0.15499997 0.525 -0.25 q 0.29500008 -0.09500003 0.605 -0.16499996 q 0.76 -0.16000009 1.185 -0.32000005 q 0.42499995 -0.15999997 0.42499995 -0.48000002 q 0 -0.18999994 -0.089999914 -0.31499994 q -0.089999914 -0.125 -0.2249999 -0.19999999 q -0.13499999 -0.07499999 -0.3000002 -0.110000014 q -0.16499996 -0.034999967 -0.31499982 -0.034999967 q -0.21000004 0 -0.40499997 0.049999952 q -0.19500017 0.050000012 -0.34500015 0.15500003 q -0.14999998 0.10500002 -0.24499989 0.26999998 q -0.09500003 0.16499996 -0.09500003 0.39499998 Z "/>
-        </symbol>
-        <symbol id="gC84EDC6FBAC0CE2EFC24569B0177ECD5" overflow="visible">
-            <path d="M 0 0m 7.49 0 l 1.9200001 7.14 h -1.54 l -1.1700001 -4.92 h -0.01999998 l -1.2199998 4.92 h -1.47 l -1.24 -4.8599997 h -0.01999998 l -1.1300001 4.8599997 h -1.5699999 l 1.89 -7.14 h 1.59 l 1.1899998 4.8599997 h 0.01999998 l 1.21 -4.8599997 h 1.56 Z "/>
-        </symbol>
-        <symbol id="g4F32DCC5CEA421B0EDD79EB9B8B18787" overflow="visible">
-            <path d="M 0 0m 2 5.97 v 1.1700001 h -1.4200001 v -1.1700001 h 1.4200001 Z m -1.4200001 -0.7999997 v -5.17 h 1.4200001 v 5.17 h -1.4200001 Z "/>
-        </symbol>
-        <symbol id="g53CE0EDC53D4ECE2FFD9259C5CC1AE51" overflow="visible">
-            <path d="M 0 0m 2.95 1.22 q -0.33000016 0 -0.5500002 0.13999999 q -0.21999979 0.13999999 -0.35500002 0.3599999 q -0.13499987 0.22000003 -0.18999994 0.495 q -0.054999948 0.2750001 -0.054999948 0.55500007 q 0 0.28999996 0.06500006 0.5549998 q 0.06499994 0.2650001 0.21000004 0.47000003 q 0.14499998 0.20500016 0.3599999 0.32500005 q 0.21499991 0.119999886 0.5150001 0.119999886 q 0.3499999 0 0.5799999 -0.12999964 q 0.23000002 -0.13000011 0.3699999 -0.35000014 q 0.1400001 -0.22000003 0.20000005 -0.5050001 q 0.059999943 -0.28499985 0.059999943 -0.605 q 0 -0.27999997 -0.07499981 -0.53499985 q -0.075000286 -0.255 -0.22500014 -0.45500004 q -0.1500001 -0.20000005 -0.37999988 -0.32000005 q -0.23000002 -0.119999886 -0.53 -0.119999886 Z m 2.5599997 -0.89000005 v 4.84 h -1.3499999 v -0.69000006 h -0.01999998 q -0.26 0.4499998 -0.645 0.63999987 q -0.385 0.19000006 -0.895 0.19000006 q -0.53999996 0 -0.9549999 -0.21000004 q -0.41499996 -0.21000004 -0.695 -0.56500006 q -0.28000003 -0.35500002 -0.425 -0.81999993 q -0.14499998 -0.4649999 -0.14499998 -0.9649999 q 0 -0.53 0.125 -1.005 q 0.125 -0.47500002 0.39499998 -0.83000004 q 0.26999998 -0.35499996 0.68999994 -0.55999994 q 0.42000008 -0.205 1 -0.205 q 0.47000003 0 0.895 0.19500001 q 0.42499995 0.19499996 0.655 0.605 h 0.01999998 v -0.68 q 0.010000229 -0.54999995 -0.26499987 -0.90999997 q -0.2750001 -0.36 -0.875 -0.36 q -0.3800001 0 -0.6700001 0.15500003 q -0.28999996 0.15499997 -0.39 0.55499995 h -1.4099998 q 0.029999971 -0.43999997 0.24499995 -0.755 q 0.21500003 -0.31500006 0.53999996 -0.515 q 0.32500005 -0.20000005 0.72000015 -0.29499996 q 0.39499998 -0.09500003 0.77499986 -0.09500003 q 0.8900001 0 1.4200001 0.24000001 q 0.52999973 0.24000001 0.80999994 0.5849999 q 0.27999973 0.34500003 0.36499977 0.745 q 0.08500004 0.4 0.08500004 0.71 Z "/>
-        </symbol>
-        <symbol id="g709986D1AD07B5D6C62F4F10C982F993" overflow="visible">
-            <path d="M 0 0m 2.34 5.17 v 1.5499997 h -1.42 v -1.5499997 h -0.85999995 v -0.9500003 h 0.85999995 v -3.0499997 q 0 -0.39 0.13 -0.63 q 0.13 -0.23999998 0.35500002 -0.36999995 q 0.22500002 -0.13 0.52 -0.175 q 0.29500008 -0.044999998 0.625 -0.044999998 q 0.21000004 0 0.43000007 0.009999998 q 0.21999979 0.01 0.39999986 0.04 v 1.1 q -0.099999905 -0.0200001 -0.21000004 -0.03000009 q -0.109999895 -0.00999999 -0.23000002 -0.00999999 q -0.3599999 0 -0.47999978 0.120000005 q -0.120000124 0.120000005 -0.120000124 0.48000002 v 2.56 h 1.04 v 0.9500003 h -1.04 Z "/>
-        </symbol>
-        <symbol id="g62F0E2E5CCBA1EC061CCCA42BF03BD67" overflow="visible">
-            <path d="M 0 0m 0.69 7.14 v -7.14 h 1.5699999 v 2.3 l 0.89999986 0.9100001 l 2.15 -3.21 h 1.9699998 l -3.06 4.3199997 l 2.79 2.8200002 h -1.96 l -2.7899997 -2.96 v 2.96 h -1.5699999 Z "/>
-        </symbol>
-        <symbol id="gC82E65AC956B3FEDC3323A1DF128185D" overflow="visible">
-            <path d="M 0 0m 4.0099998 0 l 2.37 7.14 h -1.6199999 l -1.6099999 -5.02 h -0.01999998 l -1.5899999 5.02 h -1.61 l 2.31 -7.14 h 1.7699997 Z "/>
-        </symbol>
-        <symbol id="gF87923E104CC15BE09B4120335A8FEC4" overflow="visible">
-            <path d="M 0 0m 0.58 7.14 v -7.14 h 1.4200001 v 7.14 h -1.4200001 Z "/>
-        </symbol>
-        <symbol id="g879D08C569DBB924818BD3C3C3D32E4E" overflow="visible">
-            <path d="M 0 0m 5.39 0 v 5.17 h -1.4199998 v -2.71 q 0 -0.7900001 -0.26000023 -1.1350001 q -0.26 -0.34499997 -0.8399999 -0.34499997 q -0.51 0 -0.71000004 0.315 q -0.19999993 0.31500006 -0.19999993 0.95500004 v 2.92 h -1.42 v -3.18 q 0 -0.48000002 0.08500004 -0.875 q 0.08499998 -0.39500004 0.29499996 -0.67 q 0.21000004 -0.27499998 0.57500005 -0.42499998 q 0.365 -0.14999999 0.9349998 -0.14999999 q 0.45000005 0 0.8800001 0.19999999 q 0.43000007 0.19999999 0.6999998 0.65 h 0.03000021 v -0.71999997 h 1.3499999 Z "/>
-        </symbol>
-        <symbol id="g641F1DE27A4B048908B0028DB805B317" overflow="visible">
-            <path d="M 0 0m 0.70199996 6.4259996 v -6.4259996 h 0.85499996 v 2.9429998 h 3.384 v -2.9429998 h 0.85499954 v 6.4259996 h -0.85499954 v -2.7629998 h -3.384 v 2.7629998 h -0.85499996 Z "/>
-        </symbol>
-        <symbol id="g124215DF7EB2152435C4CCD8DC3AEA76" overflow="visible">
-            <path d="M 0 0m 2.4029999 -0.621 q -0.13499999 -0.34199995 -0.26550007 -0.5759999 q -0.13049984 -0.23400009 -0.28799987 -0.38250005 q -0.15750003 -0.14849997 -0.35099995 -0.21599996 q -0.19350004 -0.067499995 -0.44550002 -0.067499995 q -0.13499999 0 -0.26999998 0.018000007 q -0.13499999 0.018000007 -0.26100004 0.062999964 v 0.702 q 0.09900004 -0.045000076 0.2295 -0.07650006 q 0.13050002 -0.031499982 0.22049999 -0.031499982 q 0.23400003 0 0.39150006 0.11249995 q 0.15749991 0.11250007 0.23849988 0.31950003 l 0.31500006 0.783 l -1.8449999 4.626 h 0.86399996 l 1.3589998 -3.807 h 0.018000126 l 1.3049998 3.807 h 0.8100002 l -2.025 -5.2739997 Z "/>
-        </symbol>
-        <symbol id="g2801BEF568718ADDC2ABAF998D0A388F" overflow="visible">
-            <path d="M 0 0m 0.603 4.653 v -6.4259996 h 0.7649999 v 2.3939998 h 0.018000007 q 0.12600005 -0.20700002 0.31050003 -0.3465 q 0.18449998 -0.13949999 0.39149988 -0.22049999 q 0.20700002 -0.081 0.41850019 -0.11699999 q 0.21149993 -0.036 0.38249993 -0.036 q 0.5309999 0 0.93149996 0.18899998 q 0.40049982 0.18899998 0.6659999 0.5175 q 0.26550007 0.32850003 0.3959999 0.7695 q 0.13050032 0.44099998 0.13050032 0.936 q 0 0.4949999 -0.13500023 0.9359999 q -0.13499975 0.44099998 -0.40049982 0.77849984 q -0.26550007 0.3375001 -0.6660001 0.53550005 q -0.40050006 0.19799995 -0.9405 0.19799995 q -0.48599982 0 -0.8909999 -0.17549992 q -0.40499997 -0.17549992 -0.594 -0.5625 h -0.018000007 v 0.6300001 h -0.7649999 Z m 3.5999997 -2.286 q 0 -0.342 -0.07199955 -0.6659999 q -0.07200003 -0.324 -0.2340002 -0.576 q -0.16199994 -0.25200003 -0.4275 -0.40500003 q -0.26550007 -0.153 -0.6615 -0.153 q -0.3959999 0 -0.67499995 0.14850003 q -0.27899992 0.14849997 -0.45449996 0.3915 q -0.17550004 0.24299991 -0.2565 0.5624999 q -0.08099997 0.3195001 -0.08099997 0.6615 q 0 0.32400012 0.07649994 0.63899994 q 0.07650006 0.31500006 0.24750006 0.5625 q 0.171 0.24749994 0.44099998 0.40050006 q 0.26999998 0.15300012 0.6569998 0.15300012 q 0.3690002 0 0.6435001 -0.14400005 q 0.2744999 -0.14400005 0.45000005 -0.38700008 q 0.17549968 -0.24300003 0.26099992 -0.55349994 q 0.08549976 -0.3104999 0.08549976 -0.6345 Z "/>
-        </symbol>
-        <symbol id="g4B31B8CEB3E48D08D063331B59F6BBAB" overflow="visible">
-            <path d="M 0 0m 3.807 2.7719998 h -2.6729999 q 0.018000007 0.26999998 0.116999984 0.5085001 q 0.09899998 0.23849988 0.26999998 0.41849995 q 0.171 0.18000007 0.4095 0.28349996 q 0.2385 0.10350013 0.53549993 0.10350013 q 0.2880001 0 0.5265 -0.10350013 q 0.23850012 -0.10349989 0.41400003 -0.27900004 q 0.17549992 -0.17549992 0.27900004 -0.41849995 q 0.10349989 -0.24300003 0.121500015 -0.513 Z m 0.7379997 -1.2959999 h -0.7559998 q -0.09899998 -0.459 -0.40949988 -0.684 q -0.31050014 -0.22499996 -0.79649997 -0.22499996 q -0.37800002 0 -0.65700006 0.12599999 q -0.27899992 0.12599999 -0.459 0.33749998 q -0.17999995 0.21150005 -0.26099992 0.48599994 q -0.08099997 0.2745 -0.07200003 0.5805 h 3.4829998 q 0.018000126 0.4230001 -0.07649994 0.89100003 q -0.094500065 0.46799994 -0.342 0.86399984 q -0.24749994 0.3959999 -0.6569998 0.65250015 q -0.40949988 0.25649977 -1.0304999 0.25649977 q -0.477 0 -0.87749994 -0.17999983 q -0.40050006 -0.17999983 -0.693 -0.5040002 q -0.29249996 -0.32399988 -0.4545 -0.76499987 q -0.16199997 -0.44099998 -0.16199997 -0.9719999 q 0.017999977 -0.531 0.15749997 -0.98099995 q 0.13950002 -0.45 0.4185 -0.774 q 0.27899992 -0.324 0.6884999 -0.50399995 q 0.4095 -0.17999999 0.9675001 -0.17999999 q 0.7919998 0 1.3139999 0.39599997 q 0.52199984 0.39599997 0.6749997 1.1789999 Z "/>
-        </symbol>
-        <symbol id="gE596B299A30367997DC94AB9B8B72FA7" overflow="visible">
-            <path d="M 0 0m 0.54899997 4.653 v -4.653 h 0.7649999 v 2.07 q 0 0.45000005 0.09000003 0.79649997 q 0.09000003 0.34649992 0.288 0.58949995 q 0.19799995 0.24300003 0.5220001 0.36899996 q 0.32399988 0.12599993 0.783 0.12599993 v 0.80999994 q -0.62100005 0.018000126 -1.026 -0.25199986 q -0.40499997 -0.26999998 -0.684 -0.8369999 h -0.018000007 v 0.98099995 h -0.71999997 Z "/>
-        </symbol>
-        <symbol id="g9ED3C7BE04AE098F91DCEB215E1CAC9A" overflow="visible">
-            <path d="M 0 0m 5.508 0.80099994 l 0.2249999 -0.80099994 h 0.53999996 v 3.3839998 h -2.817 v -0.72 h 2.052 q 0.017999649 -0.44099998 -0.1170001 -0.8234999 q -0.13500023 -0.38249993 -0.40049982 -0.6659999 q -0.26550007 -0.28350002 -0.65250015 -0.44550002 q -0.38700008 -0.162 -0.89100003 -0.162 q -0.53999996 0 -0.94949985 0.21149999 q -0.40950012 0.21149999 -0.68850005 0.56700003 q -0.27899992 0.35549998 -0.42299998 0.819 q -0.14399993 0.46349978 -0.14399993 0.9675 q 0 0.5129998 0.12599993 1.0035 q 0.12600005 0.49049997 0.3915 0.87299967 q 0.26549995 0.38250017 0.6839999 0.6164999 q 0.41850019 0.2340002 1.0035 0.2340002 q 0.36000013 0 0.67949986 -0.08549976 q 0.31949997 -0.08550024 0.5715003 -0.25650024 q 0.25199986 -0.171 0.42299986 -0.43650007 q 0.171 -0.26550007 0.23399973 -0.6345 h 0.855 q -0.089999676 0.5670004 -0.33749962 0.9675002 q -0.24750042 0.40049982 -0.612 0.6615 q -0.36450005 0.26099968 -0.82800007 0.3824997 q -0.46350002 0.121500015 -0.9855001 0.121500015 q -0.76499987 0 -1.3364999 -0.28349972 q -0.57149994 -0.2835002 -0.9539999 -0.76049995 q -0.3825 -0.47700024 -0.57600003 -1.1115003 q -0.19349995 -0.6344998 -0.19349995 -1.3364997 q 0 -0.6300001 0.20699999 -1.2149999 q 0.20699996 -0.58500004 0.6029999 -1.0350001 q 0.39600003 -0.44999996 0.96299994 -0.71549994 q 0.56700015 -0.26549998 1.287 -0.26549998 q 0.56700015 0 1.1250002 0.22049999 q 0.5579996 0.22049999 0.9359999 0.72449994 Z "/>
-        </symbol>
-        <symbol id="g3302C695557CE7E554F0836D2CDF4B83" overflow="visible">
-            <path d="M 0 0m 4.698 0.018 q -0.19799995 -0.11699999 -0.54900026 -0.11699999 q -0.29699993 0 -0.47249985 0.16649999 q -0.17549992 0.1665 -0.17549992 0.5445 q -0.31500006 -0.378 -0.7335 -0.5445 q -0.41849995 -0.16649999 -0.9045 -0.16649999 q -0.31499994 0 -0.5985 0.072 q -0.28349996 0.072 -0.4904999 0.22499998 q -0.20700002 0.153 -0.3285 0.40049997 q -0.121499985 0.2475 -0.121499985 0.59849995 q 0 0.39600003 0.13499999 0.648 q 0.13499999 0.25199997 0.35549998 0.4095 q 0.22049999 0.15750003 0.50399995 0.23849988 q 0.28349996 0.08100009 0.5805 0.13499999 q 0.31500006 0.0630002 0.5985 0.094500065 q 0.28349996 0.0315001 0.49950004 0.089999914 q 0.21599984 0.05850005 0.34199977 0.171 q 0.12600017 0.11250019 0.12600017 0.32850003 q 0 0.2520001 -0.094500065 0.40499997 q -0.094500065 0.15300012 -0.24300003 0.23399997 q -0.14849997 0.08099985 -0.33299994 0.10800028 q -0.18449998 0.02699995 -0.36450005 0.02699995 q -0.48599994 0 -0.80999994 -0.18450022 q -0.32399988 -0.18449998 -0.35099995 -0.6975 h -0.765 q 0.018000007 0.43200016 0.18 0.7290001 q 0.162 0.29700017 0.43199998 0.4814999 q 0.26999998 0.18450022 0.6165 0.26550007 q 0.34650004 0.08099985 0.74249995 0.08099985 q 0.31500006 0 0.62549996 -0.045000076 q 0.3104999 -0.0449996 0.5625 -0.18449974 q 0.25199986 -0.13950014 0.40499997 -0.3915 q 0.15299988 -0.2520001 0.15299988 -0.65700006 v -2.3939998 q 0 -0.27000004 0.031499863 -0.39600003 q 0.03150034 -0.12599999 0.21150017 -0.12599999 q 0.09899998 0 0.2340002 0.045000017 v -0.594 Z m -1.2420001 2.385 q -0.14400005 -0.10800004 -0.37800002 -0.15750003 q -0.23399997 -0.04949999 -0.49049997 -0.08099985 q -0.2565 -0.0315001 -0.5174999 -0.07200003 q -0.26100004 -0.040500164 -0.46800005 -0.13050008 q -0.2069999 -0.089999914 -0.33749998 -0.2565 q -0.13049996 -0.16649997 -0.13049996 -0.45449996 q 0 -0.18900001 0.07650006 -0.31949997 q 0.07649994 -0.13050002 0.19799995 -0.21149999 q 0.121500015 -0.08099997 0.28349996 -0.116999984 q 0.16200006 -0.036000013 0.342 -0.036000013 q 0.37800002 0 0.648 0.10350001 q 0.26999998 0.10350001 0.44099998 0.26099998 q 0.171 0.15750003 0.25199986 0.342 q 0.08100009 0.18449998 0.08100009 0.34649992 v 0.783 Z "/>
-        </symbol>
-        <symbol id="gD1A2B325D26318856C7583CB173E0EF5" overflow="visible">
-            <path d="M 0 0m 0.576 6.4259996 v -6.4259996 h 0.765 v 2.6279998 q 0 0.31500006 0.0855 0.5805001 q 0.0855 0.26549983 0.2565 0.46350002 q 0.171 0.19799995 0.4274999 0.306 q 0.2565 0.10800004 0.6075001 0.10800004 q 0.44099998 0 0.69299984 -0.2520001 q 0.2520001 -0.2520001 0.2520001 -0.684 v -3.1499999 h 0.7650001 v 3.06 q 0 0.37800002 -0.07649994 0.6884999 q -0.076500416 0.31050014 -0.26550007 0.53550005 q -0.18900013 0.2249999 -0.49500012 0.35099983 q -0.306 0.12599993 -0.76499987 0.12599993 q -0.20700002 0 -0.4275 -0.045000076 q -0.22049999 -0.0449996 -0.4230001 -0.13949966 q -0.20249999 -0.094500065 -0.36449993 -0.24300003 q -0.16200006 -0.14849997 -0.25199997 -0.36450005 h -0.018000007 v 2.4569998 h -0.765 Z "/>
-        </symbol>
-        <symbol id="g813F0103BE3CE7D676D52F9A0F5776CD" overflow="visible">
-            <path d="M 0 0m 4.4189997 4.5449996 h 0.80999994 q -0.017999649 0.53100014 -0.20249987 0.9135003 q -0.18449974 0.3824997 -0.5039997 0.6345 q -0.31950045 0.25199986 -0.7425003 0.36899996 q -0.42299986 0.116999626 -0.91799974 0.116999626 q -0.44099998 0 -0.85950017 -0.112499714 q -0.41849995 -0.11250019 -0.74699986 -0.342 q -0.32849997 -0.22949982 -0.5265 -0.58500004 q -0.19800001 -0.35549974 -0.19800001 -0.8414998 q 0 -0.44099998 0.17550004 -0.73350024 q 0.17549998 -0.29249978 0.468 -0.47699976 q 0.2924999 -0.18449998 0.6615 -0.29700017 q 0.36899996 -0.11249995 0.7514999 -0.19799995 q 0.38249993 -0.0855 0.7514999 -0.16649985 q 0.3690002 -0.08100009 0.6615 -0.21150017 q 0.29250002 -0.13049984 0.46799994 -0.33749986 q 0.17549992 -0.20700002 0.17549992 -0.5400001 q 0 -0.35099995 -0.14399958 -0.576 q -0.14400005 -0.2249999 -0.37800026 -0.35549992 q -0.23399997 -0.13050002 -0.5265 -0.18449998 q -0.29249978 -0.05400002 -0.5804999 -0.05400002 q -0.3599999 0 -0.7019999 0.089999974 q -0.342 0.09000003 -0.5985 0.27900004 q -0.2565 0.18900001 -0.41400003 0.4814999 q -0.15749991 0.29250002 -0.15749991 0.6975001 h -0.81000006 q 0 -0.58500004 0.21150002 -1.0125 q 0.21149999 -0.4275 0.576 -0.702 q 0.36449993 -0.27449998 0.84599996 -0.40949997 q 0.48150003 -0.13499999 1.0215 -0.13499999 q 0.44099998 0 0.8864999 0.10349999 q 0.4454999 0.10349999 0.80550003 0.333 q 0.36000013 0.22949997 0.58949995 0.594 q 0.22949982 0.3645 0.22949982 0.8775 q 0 0.477 -0.17549992 0.79200006 q -0.17549992 0.31499982 -0.46799994 0.52199984 q -0.29250002 0.20700002 -0.6615 0.32850003 q -0.36899996 0.121500015 -0.7514999 0.21149993 q -0.38249993 0.09000015 -0.7514999 0.16650009 q -0.3690002 0.07649994 -0.6615 0.19350004 q -0.29250014 0.116999865 -0.46800005 0.30150008 q -0.17550004 0.18449974 -0.17550004 0.48149967 q 0 0.31500006 0.121500015 0.5265002 q 0.121500015 0.21149969 0.324 0.33749962 q 0.20249999 0.1260004 0.4634999 0.1800003 q 0.26100016 0.0539999 0.53100014 0.0539999 q 0.6659999 0 1.0934999 -0.31050014 q 0.42749977 -0.31049967 0.4994998 -1.0035 Z "/>
-        </symbol>
-        <symbol id="g43FC2516192D0F251704B273D511AB8" overflow="visible">
-            <path d="M 0 0m 1.3859999 5.49 v 0.9359999 h -0.7649999 v -0.9359999 h 0.7649999 Z m -0.7649999 -0.8369999 v -4.653 h 0.7649999 v 4.653 h -0.7649999 Z "/>
-        </symbol>
-        <symbol id="gD978DC9CC0B9AE918886416C8F39495D" overflow="visible">
-            <path d="M 0 0m 0.576 4.653 v -4.653 h 0.765 v 2.8979998 q 0 0.13499999 0.067499995 0.3375001 q 0.067499995 0.2025001 0.21599996 0.3915 q 0.14849997 0.18899989 0.38699996 0.32399988 q 0.23850012 0.13500023 0.57150006 0.13500023 q 0.26099992 0 0.4275 -0.07649994 q 0.16649985 -0.07650018 0.26549983 -0.21600008 q 0.09899998 -0.13950014 0.13950014 -0.32850003 q 0.040499926 -0.18900013 0.040499926 -0.41400003 v -3.0509999 h 0.76499987 v 2.8979998 q 0 0.5400002 0.32399988 0.8640001 q 0.32400036 0.32400012 0.8910003 0.32400012 q 0.2789998 0 0.45449972 -0.08100033 q 0.17549992 -0.08099985 0.27450037 -0.22049975 q 0.09899998 -0.13950014 0.13499975 -0.32850003 q 0.035999775 -0.18899989 0.035999775 -0.40499997 v -3.0509999 h 0.76500034 v 3.4109998 q 0 0.36000013 -0.11250019 0.6164999 q -0.112499714 0.25650024 -0.31500006 0.41849995 q -0.20249987 0.16200018 -0.48600006 0.23850012 q -0.28349972 0.07649994 -0.63449955 0.07649994 q -0.4590001 0 -0.8415003 -0.20699978 q -0.3824997 -0.20700026 -0.6164999 -0.58500004 q -0.14400005 0.43200016 -0.4949999 0.612 q -0.35100007 0.17999983 -0.783 0.17999983 q -0.98099995 0 -1.503 -0.7919998 h -0.017999887 v 0.684 h -0.72 Z "/>
-        </symbol>
-        <symbol id="gE14823C6D5887C5946C79D53BC50B1DF" overflow="visible">
-            <path d="M 0 0m 0.621 6.4259996 v -6.4259996 h 0.7649999 v 6.4259996 h -0.7649999 Z "/>
-        </symbol>
-        <symbol id="gCCF6F62EDE72A2783EDD776715FF2521" overflow="visible">
-            <path d="M 0 0m 1.5569999 3.3479998 v 2.358 h 1.674 q 0.72899985 0 1.0664997 -0.30150032 q 0.3375001 -0.30149984 0.3375001 -0.8774996 q 0 -0.5760002 -0.3375001 -0.8820002 q -0.33749986 -0.306 -1.0664997 -0.29699993 h -1.674 Z m -0.85499996 3.0779998 v -6.4259996 h 0.85499996 v 2.6279998 h 1.9619999 q 0.9719999 -0.0089998245 1.4715002 0.49500012 q 0.4994998 0.50399995 0.4994998 1.404 q 0 0.8999996 -0.4994998 1.3994999 q -0.49950027 0.4994998 -1.4715002 0.4994998 h -2.817 Z "/>
-        </symbol>
-        <symbol id="gBF6C7CC99FD9658A0BCA7C9307EFE887" overflow="visible">
-            <path d="M 0 0m 0.576 4.653 v -4.653 h 0.765 v 2.6279998 q 0 0.31500006 0.0855 0.5805001 q 0.0855 0.26549983 0.2565 0.46350002 q 0.171 0.19799995 0.4274999 0.306 q 0.2565 0.10800004 0.6075001 0.10800004 q 0.44099998 0 0.69299984 -0.2520001 q 0.2520001 -0.2520001 0.2520001 -0.684 v -3.1499999 h 0.7650001 v 3.06 q 0 0.37800002 -0.07649994 0.6884999 q -0.076500416 0.31050014 -0.26550007 0.53550005 q -0.18900013 0.2249999 -0.49500012 0.35099983 q -0.306 0.12599993 -0.76499987 0.12599993 q -1.0350001 0 -1.5120001 -0.84599996 h -0.017999887 v 0.73800015 h -0.72 Z "/>
-        </symbol>
-        <symbol id="g4C14CF88950BA583FF1F70F2AC32556F" overflow="visible">
-            <path d="M 0 0m 1.5569999 3.6629999 v 2.043 h 1.71 q 0.2789998 0 0.5265 -0.031499863 q 0.24749994 -0.03150034 0.43650007 -0.13950014 q 0.18899965 -0.10800028 0.29699993 -0.30600023 q 0.1079998 -0.19799995 0.1079998 -0.53999996 q 0 -0.513 -0.31949997 -0.7694998 q -0.31949997 -0.2565 -1.0484998 -0.2565 h -1.71 Z m -0.85499996 2.7629998 v -6.4259996 h 3.105 q 0.477 0 0.84150004 0.1575 q 0.36450005 0.1575 0.612 0.414 q 0.24749994 0.25649995 0.37349987 0.5894999 q 0.12599993 0.33300006 0.12599993 0.684 q 0 0.594 -0.31500006 1.008 q -0.31500006 0.41400003 -0.9089999 0.53999996 v 0.017999887 q 0.4590001 0.18000007 0.70650005 0.55349994 q 0.24749994 0.3735001 0.24749994 0.8865001 q 0 0.48600006 -0.22049999 0.81899977 q -0.22049999 0.33300018 -0.53550005 0.5220003 q -0.14400005 0.089999676 -0.34649992 0.13499975 q -0.20249987 0.045000076 -0.43650007 0.067500114 q -0.23399997 0.022500038 -0.47249985 0.02699995 q -0.23850012 0.0044999123 -0.44550014 0.0044999123 h -2.3309999 Z m 0.85499996 -5.706 v 2.2229998 h 1.9529998 q 0.26999998 0 0.52199984 -0.04949999 q 0.25200033 -0.04949999 0.44550037 -0.171 q 0.19350004 -0.121500015 0.31049967 -0.32850003 q 0.1170001 -0.20700002 0.1170001 -0.52199984 q 0 -0.5400001 -0.31949997 -0.8460001 q -0.31949997 -0.30599993 -0.8864999 -0.30599993 h -2.142 Z "/>
-        </symbol>
-        <symbol id="g87DCE9BAA18E83AE0AA9F4A317AAF534" overflow="visible">
-            <path d="M 0 0m 1.6379999 4.653 v 1.395 h -0.7649999 v -1.395 h -0.79199994 v -0.67499995 h 0.79199994 v -2.961 q 0 -0.324 0.06300002 -0.52199996 q 0.062999964 -0.19799998 0.19349992 -0.306 q 0.13050008 -0.107999995 0.342 -0.1485 q 0.21150005 -0.0405 0.5085 -0.0405 h 0.5849999 v 0.67499995 h -0.35099983 q -0.18000007 0 -0.29250002 0.013500035 q -0.11250007 0.013499975 -0.17550004 0.058499992 q -0.062999964 0.044999957 -0.0855 0.12599999 q -0.022500038 0.08099997 -0.022500038 0.21600002 v 2.889 h 0.9269999 v 0.67499995 h -0.9269999 Z "/>
-        </symbol>
-        <symbol id="g3EEFA5F67AA62934351B04ACAD7700B7" overflow="visible">
-            <path d="M 0 0m 5.832 2.3219998 v 4.104 h -0.855 v -4.104 q 0 -0.86399984 -0.42749977 -1.3094999 q -0.42750025 -0.44549996 -1.2465 -0.44549996 q -0.8640001 0 -1.3230001 0.44549996 q -0.459 0.44550002 -0.459 1.3094999 v 4.104 h -0.85499996 v -4.104 q 0 -1.2869998 0.69750005 -1.8764998 q 0.6974999 -0.58949995 1.9395 -0.58949995 q 1.2149997 0 1.8719997 0.61649996 q 0.65700006 0.6165 0.65700006 1.8494998 Z "/>
-        </symbol>
-        <symbol id="gC4452AF47A66FE705AB14D2AB364C607" overflow="visible">
-            <path d="M 0 0m 1.5569999 0.71999997 v 4.986 h 1.44 q 0.59399986 0 0.99899983 -0.16650009 q 0.4050002 -0.16650009 0.6615 -0.48600006 q 0.25649977 -0.31949997 0.36899996 -0.7739997 q 0.11250019 -0.4545002 0.11250019 -1.0305002 q 0 -0.59399986 -0.121500015 -1.0125 q -0.121500015 -0.41849983 -0.31050014 -0.6974999 q -0.18900013 -0.27899992 -0.42749977 -0.44099998 q -0.23850012 -0.16199994 -0.48150015 -0.24749994 q -0.24300003 -0.0855 -0.4590001 -0.10800004 q -0.21599984 -0.022499979 -0.3599999 -0.022499979 h -1.4219999 Z m -0.85499996 5.706 v -6.4259996 h 2.205 q 0.8010001 0 1.3859999 0.225 q 0.58500004 0.225 0.9629998 0.6524999 q 0.37800026 0.4275 0.5580001 1.053 q 0.1800003 0.6255001 0.1800003 1.4355 q 0 1.5479996 -0.8010001 2.3039997 q -0.8010001 0.75600004 -2.286 0.75600004 h -2.205 Z "/>
-        </symbol>
-        <symbol id="gD46906E080E9F801E0E94D1932E8451F" overflow="visible">
-            <path d="M 0 0m 1.0439999 1.4669999 h -0.7649999 q 0.018000007 -0.43199992 0.18 -0.73349994 q 0.162 -0.30149996 0.43199998 -0.48599994 q 0.26999992 -0.1845 0.621 -0.26549998 q 0.35099995 -0.08099999 0.73800004 -0.08099999 q 0.35099983 0 0.7064998 0.067499995 q 0.35549998 0.067499995 0.63899994 0.23849998 q 0.2835002 0.171 0.45899987 0.44999996 q 0.1755004 0.27900004 0.1755004 0.702 q 0 0.33299994 -0.13050032 0.55799997 q -0.13049984 0.22500002 -0.34199977 0.3735 q -0.21150017 0.14849997 -0.48600006 0.23849988 q -0.2744999 0.09000015 -0.5625 0.15300012 q -0.26999998 0.062999964 -0.53999996 0.121500015 q -0.26999998 0.05850005 -0.48599994 0.14400005 q -0.21600008 0.08549976 -0.35549998 0.21599984 q -0.13950002 0.13050008 -0.13950002 0.32850003 q 0 0.18000007 0.09000003 0.29250002 q 0.089999914 0.11249995 0.23399997 0.17999983 q 0.14399993 0.067499876 0.31949997 0.0945003 q 0.17550004 0.02699995 0.34650004 0.02699995 q 0.18899989 0 0.37349987 -0.040500164 q 0.18449998 -0.040500164 0.3375001 -0.13050008 q 0.15299988 -0.089999914 0.25199986 -0.23849988 q 0.09899998 -0.14849997 0.1170001 -0.37349987 h 0.76499987 q -0.02699995 0.42299986 -0.17999983 0.70650005 q -0.15300012 0.28349972 -0.40950012 0.4499998 q -0.2565 0.16650009 -0.58949995 0.23399973 q -0.33299994 0.067500114 -0.72899985 0.067500114 q -0.3060001 0 -0.6165 -0.07649994 q -0.31050003 -0.07649994 -0.558 -0.23399973 q -0.2475 -0.15750027 -0.40499997 -0.40950012 q -0.1575 -0.2520001 -0.1575 -0.6029999 q 0 -0.45000005 0.225 -0.70200014 q 0.22499996 -0.25199986 0.56249994 -0.3915 q 0.33749998 -0.1394999 0.7335 -0.21599984 q 0.3959999 -0.07650018 0.7335 -0.17100012 q 0.33749986 -0.094499946 0.5625 -0.24749994 q 0.2249999 -0.153 0.2249999 -0.44999993 q 0 -0.21600008 -0.10800004 -0.35550004 q -0.10800004 -0.13949996 -0.2744999 -0.21149999 q -0.16650009 -0.07199997 -0.36450005 -0.09899998 q -0.19799995 -0.02700001 -0.37800002 -0.02700001 q -0.23399997 0 -0.45449996 0.045000017 q -0.22049999 0.044999957 -0.3959999 0.14849997 q -0.17550004 0.10350001 -0.28350008 0.27900004 q -0.10799992 0.17549992 -0.116999984 0.4274999 Z "/>
-        </symbol>
-        <symbol id="gFB59D557F363E86096A9F4459DDFD8F3" overflow="visible">
-            <path d="M 0 0m 0.621 6.4259996 v -6.4259996 h 0.7649999 v 1.7639999 l 0.72 0.6659999 l 1.5929999 -2.4299998 h 0.9720001 l -1.98 2.961 l 1.8449998 1.6919999 h -1.026 l -2.1239998 -2.034 v 3.8069997 h -0.7649999 Z "/>
-        </symbol>
-        <symbol id="g75C1983CA166B2AED4C5CCCA97BF3B6A" overflow="visible">
-            <path d="M 0 0m 0.70199996 6.4259996 v -6.4259996 h 0.85499996 v 2.25 l 1.0709999 0.99899983 l 2.322 -3.2489998 h 1.0799999 l -2.817 3.8339999 l 2.709 2.5919998 h -1.1070004 l -3.2579997 -3.2039998 v 3.2039998 h -0.85499996 Z "/>
-        </symbol>
-        <symbol id="g7691E6040D648DC4C509121677FE43B4" overflow="visible">
-            <path d="M 0 0m 4.5899997 0.39599997 v 4.257 h -0.7199998 v -0.6660001 h -0.009000063 q -0.20700002 0.38699985 -0.576 0.5804999 q -0.36899996 0.19350004 -0.80999994 0.19350004 q -0.6029999 0 -1.017 -0.22949982 q -0.41400003 -0.22949982 -0.666 -0.58500004 q -0.25199997 -0.35549998 -0.35999995 -0.79200006 q -0.10799998 -0.43649983 -0.10799998 -0.85049987 q 0 -0.477 0.13049999 -0.9045 q 0.13049999 -0.42749995 0.39149997 -0.7469999 q 0.26100004 -0.3195 0.648 -0.5085 q 0.38699996 -0.189 0.9089999 -0.189 q 0.45000005 0 0.85049987 0.2025 q 0.40050006 0.20249999 0.5985 0.6344999 h 0.018000126 v -0.30599996 q 0 -0.38699996 -0.07649994 -0.71099997 q -0.07650018 -0.32399997 -0.24750018 -0.55349994 q -0.171 -0.22949994 -0.43199992 -0.36 q -0.26099992 -0.13049996 -0.63899994 -0.13049996 q -0.18899989 0 -0.3959999 0.040500045 q -0.20700002 0.040499926 -0.38250005 0.13049996 q -0.17550004 0.09000003 -0.29700005 0.23399997 q -0.121499896 0.144 -0.13049996 0.351 h -0.765 q 0.018000007 -0.37800002 0.19800001 -0.639 q 0.18 -0.26100004 0.45450002 -0.42299998 q 0.2745 -0.16199994 0.612 -0.23399997 q 0.33749998 -0.07200003 0.66149986 -0.07200003 q 1.1159999 0 1.638 0.56700003 q 0.52199984 0.5669999 0.52199984 1.7099998 Z m -2.1419997 0.22500002 q -0.37800002 0 -0.63 0.15749997 q -0.25199997 0.15750003 -0.40499997 0.41400003 q -0.153 0.2564999 -0.21600008 0.57149994 q -0.062999964 0.31500006 -0.062999964 0.6299999 q 0 0.33300018 0.07650006 0.63899994 q 0.07649994 0.306 0.24299991 0.5400002 q 0.16649997 0.23399997 0.4275 0.37349987 q 0.26100004 0.13950014 0.63 0.13950014 q 0.3599999 0 0.612 -0.14400005 q 0.25199986 -0.14400005 0.40949988 -0.38250017 q 0.15750003 -0.23849988 0.22950006 -0.5354998 q 0.07200003 -0.29699993 0.07200003 -0.6029999 q 0 -0.32400012 -0.07649994 -0.6480001 q -0.07650018 -0.324 -0.23850012 -0.5804999 q -0.16199994 -0.2565 -0.4275 -0.41400003 q -0.26549983 -0.15749997 -0.64349985 -0.15749997 Z "/>
-        </symbol>
-        <symbol id="g70A5EED08A4892697C9F8AF4CED29F38" overflow="visible">
-            <path d="M 0 0m 4.428 0 v 4.653 h -0.7650001 v -2.628 q 0 -0.31499994 -0.0855 -0.5804999 q -0.0855 -0.26550007 -0.2565 -0.46350002 q -0.171 -0.19799995 -0.4275 -0.306 q -0.2565 -0.10799998 -0.60749984 -0.10799998 q -0.4410001 0 -0.6930001 0.25199997 q -0.25199997 0.25200003 -0.25199997 0.68399996 v 3.15 h -0.765 v -3.06 q 0 -0.37800002 0.0765 -0.6885 q 0.0765 -0.31049997 0.2655 -0.53549993 q 0.18900001 -0.225 0.495 -0.34649998 q 0.306 -0.12149999 0.765 -0.12149999 q 0.513 0 0.8909998 0.20249999 q 0.37800002 0.2025 0.62100005 0.63449997 h 0.018000126 v -0.738 h 0.72 Z "/>
-        </symbol>
-        <symbol id="g81941A84CFD7B2E6E64D490082E56BB7" overflow="visible">
-            <path d="M 0 0m 0.603 6.4259996 v -6.4259996 h 0.7649999 v 0.621 h 0.018000007 q 0.12600005 -0.20700002 0.31050003 -0.3465 q 0.18449998 -0.13949999 0.39149988 -0.22049999 q 0.20700002 -0.081 0.41850019 -0.11699999 q 0.21149993 -0.036 0.38249993 -0.036 q 0.5309999 0 0.93149996 0.18899998 q 0.40049982 0.18899998 0.6659999 0.5175 q 0.26550007 0.32850003 0.3959999 0.7695 q 0.13050032 0.44099998 0.13050032 0.936 q 0 0.4949999 -0.13500023 0.9359999 q -0.13499975 0.44099998 -0.40049982 0.77849984 q -0.26550007 0.3375001 -0.6660001 0.53550005 q -0.40050006 0.19799995 -0.9405 0.19799995 q -0.48599982 0 -0.8909999 -0.17549992 q -0.40499997 -0.17549992 -0.594 -0.5625 h -0.018000007 v 2.4029999 h -0.7649999 Z m 3.5999997 -4.059 q 0 -0.342 -0.07199955 -0.6659999 q -0.07200003 -0.324 -0.2340002 -0.576 q -0.16199994 -0.25200003 -0.4275 -0.40500003 q -0.26550007 -0.153 -0.6615 -0.153 q -0.3959999 0 -0.67499995 0.14850003 q -0.27899992 0.14849997 -0.45449996 0.3915 q -0.17550004 0.24299991 -0.2565 0.5624999 q -0.08099997 0.3195001 -0.08099997 0.6615 q 0 0.32400012 0.07649994 0.63899994 q 0.07650006 0.31500006 0.24750006 0.5625 q 0.171 0.24749994 0.44099998 0.40050006 q 0.26999998 0.15300012 0.6569998 0.15300012 q 0.3690002 0 0.6435001 -0.14400005 q 0.2744999 -0.14400005 0.45000005 -0.38700008 q 0.17549968 -0.24300003 0.26099992 -0.55349994 q 0.08549976 -0.3104999 0.08549976 -0.6345 Z "/>
-        </symbol>
-        <symbol id="g5E7F3EDE6694ACAB83B07765FD7C88CC" overflow="visible">
-            <path d="M 0 0m 2.1599998 5.706 v -5.706 h 0.855 v 5.706 h 2.1419997 v 0.7199998 h -5.1389995 v -0.7199998 h 2.142 Z "/>
-        </symbol>
-        <symbol id="g73CBF4CE1C6B6F76004C71E0D960877F" overflow="visible">
-            <path d="M 0 0m 0.891 3.978 v -3.978 h 0.7649999 v 3.978 h 0.9000001 v 0.67499995 h -0.9000001 v 0.64799976 q 0 0.30600023 0.153 0.41400003 q 0.153 0.10800028 0.43200004 0.10800028 q 0.09899998 0 0.21599984 -0.013500214 q 0.1170001 -0.013500214 0.21600008 -0.04949999 v 0.6659999 q -0.10800004 0.03600025 -0.24749994 0.0539999 q -0.1394999 0.018000126 -0.24749994 0.018000126 q -0.63 0 -0.9585 -0.29250002 q -0.32849997 -0.29250002 -0.32849997 -0.85949993 v -0.69299984 h -0.783 v -0.67499995 h 0.783 Z "/>
-        </symbol>
-        <symbol id="gAA9BA5DCE3B7BAD11A37A99523970BA1" overflow="visible">
-            <path d="M 0 0m 3.7259998 4.752 h 0.76499987 q -0.07200003 0.7919998 -0.53999996 1.2104998 q -0.46799994 0.41849995 -1.2599998 0.41849995 q -0.684 0 -1.1340001 -0.28799963 q -0.44999993 -0.2880001 -0.71999997 -0.76500034 q -0.26999998 -0.47699976 -0.38249996 -1.0934997 q -0.11250001 -0.61650014 -0.11250001 -1.2735 q 0 -0.5040002 0.0765 -1.044 q 0.0765 -0.53999996 0.3105 -0.98999995 q 0.23399997 -0.45000002 0.666 -0.738 q 0.43199992 -0.288 1.1429999 -0.288 q 0.6029999 0 1.0125 0.20249999 q 0.40949988 0.2025 0.65700006 0.51299995 q 0.24749994 0.31050003 0.35549974 0.6885 q 0.10800028 0.37800002 0.10800028 0.729 q 0 0.44099998 -0.13500023 0.819 q -0.13499975 0.37800002 -0.38250017 0.6569998 q -0.2474997 0.27900004 -0.61199975 0.43650007 q -0.36450005 0.15749979 -0.8234999 0.15749979 q -0.5220001 0 -0.9225 -0.19799972 q -0.40049994 -0.19799995 -0.6704999 -0.63899994 l -0.018000007 0.017999887 q 0.008999944 0.36899996 0.07199991 0.7919998 q 0.06300008 0.42300034 0.22950006 0.7874999 q 0.16649997 0.36450005 0.46350002 0.60300016 q 0.29699993 0.23850012 0.783 0.23850012 q 0.45899987 0 0.7379999 -0.26100016 q 0.27900004 -0.26099968 0.33299994 -0.69299984 Z m -1.152 -1.323 q 0.32399988 0 0.5669999 -0.1170001 q 0.24300003 -0.116999865 0.40499997 -0.3104999 q 0.16200018 -0.19350004 0.23850012 -0.4590001 q 0.07649994 -0.26549983 0.07649994 -0.5624999 q 0 -0.27899992 -0.0855 -0.53549993 q -0.0855 -0.2565 -0.24749994 -0.45450002 q -0.16199994 -0.19800001 -0.40050006 -0.31049997 q -0.23849988 -0.11250001 -0.55349994 -0.11250001 q -0.31500006 0 -0.5625 0.11250001 q -0.24749994 0.11249995 -0.41399992 0.30149996 q -0.16649997 0.18900001 -0.2565 0.45000005 q -0.09000003 0.26099992 -0.09000003 0.55799997 q 0 0.29700005 0.0855 0.5624999 q 0.0855 0.26550007 0.2565 0.4590001 q 0.171 0.1934998 0.41400003 0.306 q 0.24300003 0.11249995 0.5669999 0.11249995 Z "/>
-        </symbol>
-        <symbol id="g170E3DF111F34A5B640D30A3D024062D" overflow="visible">
-            <path d="M 0 0m 3.0509999 2.169 h -2.142 l 2.1239998 3.123 h 0.018000126 v -3.123 Z m 0.72 0 v 4.212 h -0.612 l -2.907 -4.1489997 v -0.7379999 h 2.7989998 v -1.494 h 0.72 v 1.494 h 0.86399984 v 0.67499995 h -0.86399984 Z "/>
-        </symbol>
-        <symbol id="g825BFEEBA88E24CB932EEEE0C5250EC" overflow="visible">
-            <path d="M 0 0m 1.9619999 3.6449997 v -0.64799976 q 0.21600008 0.02699995 0.4590001 0.02699995 q 0.28799987 0 0.5354998 -0.07649994 q 0.24749994 -0.07650018 0.4275 -0.2340002 q 0.18000007 -0.15749979 0.2880001 -0.38699985 q 0.1079998 -0.22950006 0.1079998 -0.5265 q 0 -0.288 -0.11249995 -0.51750004 q -0.11249995 -0.22949994 -0.30149984 -0.38699996 q -0.18900013 -0.15749997 -0.44099998 -0.24299997 q -0.2520001 -0.0855 -0.53100014 -0.0855 q -0.65699995 0 -0.99899983 0.3915 q -0.342 0.39149994 -0.36 1.0125 h -0.765 q -0.009000003 -0.495 0.13949999 -0.88199997 q 0.1485 -0.38700002 0.42749998 -0.65250003 q 0.27899998 -0.2655 0.675 -0.4005 q 0.3959999 -0.13499999 0.88199985 -0.13499999 q 0.45000005 0 0.8505001 0.12149999 q 0.40049982 0.12149999 0.6975 0.3645 q 0.29699993 0.243 0.47249985 0.60749996 q 0.17549992 0.3645 0.17549992 0.8415 q 0 0.576 -0.28349972 0.99899983 q -0.2835002 0.4230001 -0.8685 0.549 v 0.018000126 q 0.37799978 0.171 0.6299999 0.50399995 q 0.25199986 0.33299994 0.25199986 0.7650001 q 0 0.44099998 -0.14849997 0.76499987 q -0.14849997 0.32399988 -0.40949988 0.53099966 q -0.26099992 0.20700026 -0.6164999 0.31050014 q -0.35549998 0.10349989 -0.7695 0.10349989 q -0.477 0 -0.84150004 -0.15299988 q -0.36449993 -0.15299988 -0.6074999 -0.42299986 q -0.24300003 -0.26999998 -0.3735 -0.64800024 q -0.13050002 -0.37799978 -0.14850003 -0.8369999 h 0.765 q 0 0.27900028 0.07200003 0.53100014 q 0.07199991 0.25199986 0.22049999 0.44099998 q 0.14849997 0.18900013 0.3779999 0.30149984 q 0.22950006 0.11250019 0.53550005 0.11250019 q 0.48600006 0 0.80999994 -0.25650024 q 0.32399988 -0.25649977 0.32399988 -0.7694998 q 0 -0.25199986 -0.09899998 -0.4499998 q -0.09899998 -0.19800043 -0.26549983 -0.32850027 q -0.16650009 -0.13049984 -0.38700008 -0.19799995 q -0.22049999 -0.067499876 -0.46350002 -0.067499876 h -0.16199994 q -0.045000076 0 -0.089999914 0 q -0.036000013 0 -0.08100009 0.0089998245 Z "/>
-        </symbol>
-        <symbol id="g48F95159F05E08FF24029F09E94D9EBD" overflow="visible">
-            <path d="M 0 0m 0.39599997 4.1219997 h 0.7649999 q -0.008999944 0.2880001 0.05850005 0.5714998 q 0.067499995 0.2835002 0.22049999 0.5085001 q 0.153 0.2249999 0.3915 0.36450005 q 0.2385 0.13950014 0.57149994 0.13950014 q 0.2520001 0 0.477 -0.08100033 q 0.2249999 -0.08099985 0.3915 -0.23399973 q 0.16650009 -0.15299988 0.26550007 -0.36450005 q 0.09899998 -0.21150017 0.09899998 -0.47249985 q 0 -0.33300018 -0.10350013 -0.58500004 q -0.10349989 -0.2520001 -0.306 -0.46799994 q -0.20249987 -0.21600008 -0.50849986 -0.4275 q -0.306 -0.21149993 -0.71099997 -0.46350002 q -0.33300006 -0.19799995 -0.63900006 -0.4230001 q -0.306 -0.2249999 -0.54899997 -0.52199984 q -0.24299997 -0.29700005 -0.40049997 -0.6975 q -0.1575 -0.4005 -0.20249999 -0.9675 h 4.167 v 0.67499995 h -3.276 q 0.0539999 0.297 0.22949994 0.5265 q 0.17550004 0.22950006 0.42299998 0.4275 q 0.24750006 0.19799995 0.5445 0.37349987 q 0.29699993 0.17550015 0.59399986 0.35549998 q 0.29700017 0.18900013 0.576 0.39600015 q 0.27900004 0.20700002 0.49500012 0.46350002 q 0.21600008 0.25649977 0.34649992 0.5804999 q 0.13049984 0.32399988 0.13049984 0.74699974 q 0 0.4500003 -0.15749979 0.7920003 q -0.15749979 0.342 -0.4275 0.5714998 q -0.26999998 0.22949982 -0.6345 0.35099983 q -0.3644998 0.121500015 -0.77849984 0.121500015 q -0.50400007 0 -0.9 -0.171 q -0.39600003 -0.171 -0.66150004 -0.47249985 q -0.26549995 -0.30149984 -0.39149997 -0.7154999 q -0.12599999 -0.41400003 -0.09900001 -0.9000001 Z "/>
-        </symbol>
-        <symbol id="gF70B1EB6DF5EEB5418258DA74EF6450A" overflow="visible">
-            <path d="M 0 0m 1.1969999 3.2129998 q 0 0.48600006 0.12600005 0.9584999 q 0.12599993 0.47249985 0.39600003 0.8505001 q 0.26999998 0.37799978 0.69299996 0.6075001 q 0.42299986 0.22949982 1.0079999 0.22949982 q 0.5849998 0 1.0080001 -0.22949982 q 0.42299986 -0.2295003 0.69299984 -0.6075001 q 0.26999998 -0.37800026 0.3959999 -0.8505001 q 0.12599993 -0.47249985 0.12599993 -0.9584999 q 0 -0.48599982 -0.12599993 -0.9584999 q -0.12599993 -0.47249997 -0.3959999 -0.8505 q -0.26999998 -0.37800002 -0.69299984 -0.60749996 q -0.42300034 -0.2295 -1.0080001 -0.2295 q -0.58500004 0 -1.0079999 0.2295 q -0.42299998 0.22949994 -0.69299996 0.60749996 q -0.2700001 0.37800002 -0.39600003 0.8505 q -0.12600005 0.4725001 -0.12600005 0.9584999 Z m -0.8549999 0 q 0 -0.6569998 0.19350001 -1.2644999 q 0.19349998 -0.60749996 0.58049995 -1.0755 q 0.38699996 -0.468 0.96300006 -0.74249995 q 0.576 -0.27449998 1.3409998 -0.27449998 q 0.7650001 0 1.3409998 0.27449998 q 0.5760002 0.27449998 0.9630003 0.74249995 q 0.3869996 0.468 0.58049965 1.0755 q 0.19350004 0.6075001 0.19350004 1.2644999 q 0 0.65700006 -0.19350004 1.2645001 q -0.19350004 0.6074996 -0.58049965 1.0755 q -0.38700008 0.46799994 -0.9630003 0.74699974 q -0.57599974 0.2789998 -1.3409998 0.2789998 q -0.76499987 0 -1.3409998 -0.2789998 q -0.5760001 -0.2789998 -0.96300006 -0.74699974 q -0.38699996 -0.4680004 -0.58049995 -1.0755 q -0.19350001 -0.6075001 -0.19350001 -1.2645001 Z "/>
-        </symbol>
-        <symbol id="gCE9C5FDCB0FB9D903B0471E1194A86FD" overflow="visible">
-            <path d="M 0 0m 0.69299996 6.4259996 v -6.4259996 h 0.80999994 v 5.1569996 h 0.018000007 l 3.3569999 -5.1569996 h 0.9359999 v 6.4259996 h -0.80999994 v -5.2109995 h -0.018000126 l -3.3839998 5.2109995 h -0.9089999 Z "/>
-        </symbol>
-        <symbol id="g59D5A1C590864C9D7659EE9E44D8B385" overflow="visible">
-            <path d="M 0 0m 3.2039998 0 v 6.3809996 h -0.5849998 q -0.062999964 -0.35999966 -0.23399997 -0.59399986 q -0.171 -0.23399973 -0.41850007 -0.36899996 q -0.24749994 -0.13499975 -0.55349994 -0.18449974 q -0.306 -0.04949999 -0.63 -0.04949999 v -0.612 h 1.6559999 v -4.572 h 0.76499987 Z "/>
-        </symbol>
-        <symbol id="gBB143EC3C95E2D7D22714C2C87E91ED" overflow="visible">
-            <path d="M 0 0m 4.23 5.5979996 v 0.6750002 h -3.15 l -0.594 -3.3119998 l 0.65700006 -0.036000013 q 0.2249999 0.26999998 0.5174999 0.43649983 q 0.29250002 0.16650009 0.6704999 0.16650009 q 0.32400012 0 0.58949995 -0.10800004 q 0.26550007 -0.10800004 0.45449996 -0.30150008 q 0.18900013 -0.1934998 0.29250002 -0.45899987 q 0.10350013 -0.26550007 0.10350013 -0.5804999 q 0 -0.37800002 -0.10800004 -0.6615001 q -0.10800004 -0.28349996 -0.29250002 -0.47249997 q -0.18449998 -0.18899995 -0.43199992 -0.28349996 q -0.24749994 -0.094500005 -0.5174999 -0.094500005 q -0.2880001 0 -0.5265001 0.0855 q -0.2385 0.0855 -0.41399992 0.24299997 q -0.17550004 0.15750003 -0.27900004 0.36899996 q -0.10350001 0.21150005 -0.121500015 0.45450008 h -0.7649999 q 0.009000003 -0.43200004 0.17099997 -0.77400005 q 0.16200003 -0.34199995 0.441 -0.57149994 q 0.27899998 -0.2295 0.6434999 -0.35099998 q 0.36450005 -0.12149999 0.7785001 -0.12149999 q 0.55799985 0 0.9764998 0.17549999 q 0.41850019 0.17549998 0.6975 0.47249997 q 0.27900028 0.297 0.41849995 0.6794999 q 0.13950014 0.38250005 0.13950014 0.7874999 q 0 0.549 -0.16200018 0.95850015 q -0.1619997 0.40949988 -0.44099975 0.684 q -0.27900004 0.2744999 -0.65700006 0.40949988 q -0.37800002 0.13499975 -0.8009999 0.13499975 q -0.32400012 0 -0.65250003 -0.112499714 q -0.32850003 -0.11249995 -0.53550005 -0.34649992 l -0.018000007 0.017999887 l 0.342 1.8359997 h 2.5740001 Z "/>
-        </symbol>
-        <symbol id="gA590B7DC033E470D6BAF5CDFC85B2050" overflow="visible">
-            <path d="M 0 0m 1.608 2.3600001 l 0.9680002 2.664 h 0.015999794 l 0.95200014 -2.664 h -1.9360001 Z m 0.5680001 3.3520002 l -2.2240002 -5.7120004 h 0.776 l 0.64 1.72 h 2.4160001 l 0.62399983 -1.72 h 0.84000015 l -2.232 5.7120004 h -0.8399999 Z "/>
-        </symbol>
-        <symbol id="g8B593199FA06CCE05316E9DE69A76C04" overflow="visible">
-            <path d="M 0 0m 0.48800004 4.136 v -4.136 h 0.68000007 v 1.84 q 0 0.39999998 0.07999992 0.70800006 q 0.08000004 0.3080001 0.25600004 0.5239999 q 0.176 0.21600008 0.464 0.32800007 q 0.288 0.11199999 0.696 0.11199999 v 0.72000027 q -0.55200005 0.015999794 -0.91199994 -0.22399998 q -0.36 -0.24000025 -0.60800004 -0.7440002 h -0.016000032 v 0.872 h -0.64 Z "/>
-        </symbol>
-        <symbol id="g77DE0CDDDA90F97D0E6338DF2ADA2B05" overflow="visible">
-            <path d="M 0 0m 1.008 2.0640001 q 0 0.37599993 0.100000024 0.668 q 0.100000024 0.29200006 0.27600002 0.4920001 q 0.176 0.20000005 0.41200006 0.3039999 q 0.23599994 0.10400009 0.49999988 0.10400009 q 0.26400018 0 0.50000024 -0.10400009 q 0.23599982 -0.10399985 0.41199994 -0.3039999 q 0.17599988 -0.20000005 0.27600002 -0.4920001 q 0.099999905 -0.29200006 0.099999905 -0.668 q 0 -0.37600005 -0.099999905 -0.6680001 q -0.10000014 -0.29199994 -0.27600002 -0.48799998 q -0.17600012 -0.19600004 -0.41199994 -0.3 q -0.23600006 -0.10400003 -0.50000024 -0.10400003 q -0.26399994 0 -0.49999988 0.10400003 q -0.23600006 0.10399997 -0.41200006 0.3 q -0.176 0.19600004 -0.27600002 0.48799998 q -0.100000024 0.29200006 -0.100000024 0.6680001 Z m -0.72 0 q 0 -0.4560001 0.12799999 -0.84800005 q 0.12800002 -0.39200002 0.384 -0.6840001 q 0.25599998 -0.292 0.632 -0.456 q 0.37600005 -0.164 0.86399996 -0.164 q 0.49600005 0 0.86800003 0.164 q 0.37200022 0.164 0.62800026 0.456 q 0.25600004 0.29200006 0.38399982 0.6840001 q 0.12800026 0.39199996 0.12800026 0.84800005 q 0 0.4560001 -0.12800026 0.852 q -0.12799978 0.39600015 -0.38399982 0.68799996 q -0.25600004 0.29200006 -0.62800026 0.46000004 q -0.37199998 0.16800022 -0.86800003 0.16800022 q -0.48799992 0 -0.86399996 -0.16800022 q -0.37600005 -0.16799998 -0.632 -0.46000004 q -0.25599998 -0.29199982 -0.384 -0.68799996 q -0.12799999 -0.3959999 -0.12799999 -0.852 Z "/>
-        </symbol>
-        <symbol id="gDAB705390D499B70C1CEEA1CADFAB46C" overflow="visible">
-            <path d="M 0 0m 4.6080003 0 l 1.3200002 4.136 h -0.704 l -0.92800045 -3.384 h -0.015999794 l -0.8640001 3.384 h -0.74399996 l -0.83200014 -3.384 h -0.015999913 l -0.93600005 3.384 h -0.7520001 l 1.3280001 -4.136 h 0.73599994 l 0.832 3.288 h 0.016000032 l 0.84000015 -3.288 h 0.72 Z "/>
-        </symbol>
-        <symbol id="g5BA2C50E2FB253176C23A29D28811B37" overflow="visible">
-            <path d="M 0 0m 0.92800003 1.304 h -0.68 q 0.015999988 -0.384 0.16000001 -0.652 q 0.14400002 -0.268 0.38400003 -0.43199998 q 0.24000001 -0.164 0.55200005 -0.23600002 q 0.31200004 -0.072000004 0.6559999 -0.072000004 q 0.31200004 0 0.628 0.060000006 q 0.31600022 0.060000002 0.5680001 0.21200001 q 0.2520001 0.15200001 0.408 0.40000004 q 0.15600014 0.24799997 0.15600014 0.624 q 0 0.296 -0.11599994 0.49600005 q -0.116000175 0.19999993 -0.30400014 0.3319999 q -0.18799996 0.13200021 -0.43199992 0.21200013 q -0.2440002 0.07999992 -0.5 0.13599992 q -0.24000001 0.055999994 -0.48000014 0.10800004 q -0.24000001 0.052000046 -0.43200004 0.12800002 q -0.19200003 0.075999975 -0.31599998 0.19199991 q -0.12400007 0.116000175 -0.12400007 0.29200006 q 0 0.16000009 0.08000004 0.26 q 0.08000004 0.10000014 0.20800006 0.16000009 q 0.12800002 0.059999943 0.28399992 0.08400011 q 0.15600002 0.02399993 0.3080001 0.02399993 q 0.16799998 0 0.33200002 -0.036000013 q 0.16400003 -0.036000013 0.29999995 -0.11599994 q 0.13600016 -0.08000016 0.22399998 -0.21200013 q 0.08800006 -0.13199997 0.10400009 -0.33200002 h 0.68000007 q -0.02399993 0.37600017 -0.16000009 0.628 q -0.13599992 0.2520001 -0.36400008 0.4000001 q -0.22799993 0.14799976 -0.5239999 0.20800018 q -0.296 0.059999943 -0.648 0.059999943 q -0.27200007 0 -0.5480001 -0.06800032 q -0.27600002 -0.06799984 -0.496 -0.20799994 q -0.21999997 -0.13999987 -0.36 -0.36399984 q -0.13999999 -0.22399998 -0.13999999 -0.536 q 0 -0.4000001 0.19999999 -0.6240001 q 0.20000005 -0.22399998 0.5 -0.34800005 q 0.30000007 -0.12400007 0.65200007 -0.19200003 q 0.35200012 -0.06799996 0.65200007 -0.15199995 q 0.29999995 -0.08399999 0.5 -0.22000003 q 0.20000005 -0.13600004 0.20000005 -0.4000001 q 0 -0.19199997 -0.095999956 -0.31599998 q -0.096000195 -0.12400001 -0.2440002 -0.18799996 q -0.148 -0.06400001 -0.32399988 -0.08800006 q -0.17600012 -0.023999989 -0.33599997 -0.023999989 q -0.20800006 0 -0.40400016 0.04000002 q -0.19599998 0.04000002 -0.352 0.13200003 q -0.15600002 0.09199995 -0.25199997 0.24799997 q -0.096000016 0.15600002 -0.10400003 0.38 Z "/>
-        </symbol>
-        <symbol id="g900615605685504312176826BFAA7CD0" overflow="visible">
-            <path d="M 0 0m 0.536 4.136 v -5.7120004 h 0.68000007 v 2.1280003 h 0.016000032 q 0.11199999 -0.18400002 0.2759999 -0.30800003 q 0.16400003 -0.12400001 0.34800005 -0.19600001 q 0.18400013 -0.072 0.3720001 -0.104 q 0.18799996 -0.032000005 0.3399999 -0.032000005 q 0.47200012 0 0.82800007 0.16800001 q 0.35599995 0.16800001 0.592 0.46 q 0.23599982 0.292 0.352 0.6840001 q 0.116000175 0.39199996 0.116000175 0.8319999 q 0 0.44000006 -0.119999886 0.83200026 q -0.12000036 0.39199996 -0.35600019 0.6919999 q -0.23600006 0.29999995 -0.592 0.47600007 q -0.35600019 0.17600012 -0.8360002 0.17600012 q -0.43199992 0 -0.79199994 -0.15600014 q -0.36 -0.15600014 -0.528 -0.5 h -0.016000032 v 0.55999994 h -0.68000007 Z m 3.2 -2.032 q 0 -0.30400002 -0.06399989 -0.592 q -0.06399989 -0.288 -0.20799994 -0.5120001 q -0.14400005 -0.22399998 -0.3800001 -0.35999995 q -0.23600006 -0.13600004 -0.58800006 -0.13600004 q -0.352 0 -0.5999999 0.13200003 q -0.24800003 0.13199997 -0.40400004 0.348 q -0.15600002 0.21600002 -0.22800004 0.50000006 q -0.07200003 0.28400004 -0.07200003 0.58799994 q 0 0.2880001 0.06800008 0.5680001 q 0.06799996 0.27999997 0.21999991 0.5 q 0.15200007 0.22000003 0.39200008 0.35599995 q 0.23999989 0.13600016 0.584 0.13600016 q 0.32800007 0 0.572 -0.12800002 q 0.24399996 -0.12800002 0.4000001 -0.3440001 q 0.1559999 -0.21599984 0.23199987 -0.49199986 q 0.075999975 -0.27600002 0.075999975 -0.5640001 Z "/>
-        </symbol>
-        <symbol id="g924EAF2D52C629B054774FEED87B1A3" overflow="visible">
-            <path d="M 0 0m 1.2320001 4.88 v 0.83200026 h -0.68000007 v -0.83200026 h 0.68000007 Z m -0.68000007 -0.74399996 v -4.136 h 0.68000007 v 4.136 h -0.68000007 Z "/>
-        </symbol>
-        <symbol id="g140CE90B08CDC407F2943E5829DFF5DD" overflow="visible">
-            <path d="M 0 0m 0.512 4.136 v -4.136 h 0.68 v 2.3360002 q 0 0.27999997 0.075999975 0.51600003 q 0.076000094 0.23599982 0.22800004 0.41199994 q 0.15200007 0.17599988 0.38 0.27200007 q 0.22800004 0.095999956 0.5400001 0.095999956 q 0.39199996 0 0.61599994 -0.22399998 q 0.22399998 -0.22399998 0.22399998 -0.60800004 v -2.8000002 h 0.68000007 v 2.72 q 0 0.3360002 -0.06799984 0.6120002 q -0.06800008 0.27600002 -0.23600006 0.47599983 q -0.16799998 0.20000029 -0.44000006 0.31200027 q -0.27200007 0.11199999 -0.68000007 0.11199999 q -0.91999996 0 -1.344 -0.7520001 h -0.016000032 v 0.6559999 h -0.64000005 Z "/>
-        </symbol>
-        <symbol id="gFC264C0FD775885BC630DFC00D9E2FE7" overflow="visible">
-            <path d="M 0 0m 1.4560001 4.136 v 1.2400002 h -0.68000007 v -1.2400002 h -0.704 v -0.5999999 h 0.704 v -2.6320002 q 0 -0.288 0.055999994 -0.46400002 q 0.056000054 -0.17600003 0.17200005 -0.272 q 0.11599994 -0.09600001 0.30400002 -0.13200001 q 0.18799996 -0.036000002 0.45200002 -0.036000002 h 0.5200001 v 0.6 h -0.31200016 q -0.15999997 0 -0.26 0.012000024 q -0.100000024 0.011999965 -0.15600002 0.051999986 q -0.055999994 0.04000002 -0.075999975 0.11199999 q -0.01999998 0.07200003 -0.01999998 0.19200003 v 2.5680003 h 0.8240001 v 0.5999999 h -0.8240001 Z "/>
-        </symbol>
-        <symbol id="gEF2A2A1EFDC1817766F824B6B7E6A1" overflow="visible">
-            <path d="M 0 0m 0.79200006 3.5360003 v -3.5360003 h 0.68000007 v 3.5360003 h 0.79999995 v 0.5999999 h -0.79999995 v 0.5760002 q 0 0.27199984 0.13599992 0.36800003 q 0.13600004 0.09599972 0.38400006 0.09599972 q 0.08800006 0 0.19199991 -0.012000084 q 0.10400009 -0.011999607 0.19200015 -0.043999672 v 0.592 q -0.095999956 0.032000065 -0.22000003 0.04799986 q -0.12400007 0.01600027 -0.22000003 0.01600027 q -0.56000006 0 -0.852 -0.26000023 q -0.29200006 -0.26000023 -0.29200006 -0.76399994 v -0.6160002 h -0.69600004 v -0.5999999 h 0.69600004 Z "/>
-        </symbol>
-        <symbol id="gA5BD779142255ABB4257B527699904C3" overflow="visible">
-            <path d="M 0 0m 0.512 4.136 v -4.136 h 0.68 v 2.5760002 q 0 0.119999886 0.060000062 0.29999995 q 0.059999943 0.18000007 0.19200003 0.34800005 q 0.13199997 0.16799998 0.34399998 0.28799987 q 0.2119999 0.120000124 0.5079999 0.120000124 q 0.23200011 0 0.3800001 -0.06800008 q 0.148 -0.06800008 0.23600006 -0.19199991 q 0.08800006 -0.12400007 0.12400007 -0.29200006 q 0.035999775 -0.16799998 0.035999775 -0.36800003 v -2.7120001 h 0.68000007 v 2.5760002 q 0 0.48000002 0.28799987 0.7679999 q 0.2880001 0.2880001 0.7920003 0.2880001 q 0.24800014 0 0.4039998 -0.07200003 q 0.15600014 -0.07200003 0.24400043 -0.1960001 q 0.08799982 -0.123999834 0.119999886 -0.29200006 q 0.032000065 -0.16799998 0.032000065 -0.3599999 v -2.7120001 h 0.6799998 v 3.032 q 0 0.32000017 -0.099999905 0.5480001 q -0.099999905 0.22799993 -0.2800002 0.37199998 q -0.17999983 0.14400005 -0.43199968 0.2119999 q -0.25200033 0.06800032 -0.5640001 0.06800032 q -0.408 0 -0.74800014 -0.18400002 q -0.3399999 -0.18400025 -0.5480001 -0.5200002 q -0.12800002 0.38400006 -0.44000006 0.5439999 q -0.3119998 0.16000032 -0.69599986 0.16000032 q -0.8720001 0 -1.3360001 -0.70400023 h -0.016000032 v 0.60800004 h -0.64000005 Z "/>
-        </symbol>
-        <symbol id="gE037EFFB7D6AFF5A7E0FD7AFE38271D9" overflow="visible">
-            <path d="M 0 0m 3.384 2.4640002 h -2.376 q 0.016000032 0.24000001 0.10400009 0.4519999 q 0.08799994 0.21200013 0.24000001 0.37199998 q 0.15199995 0.16000009 0.36399996 0.2520001 q 0.21200001 0.09200001 0.47600007 0.09200001 q 0.25600004 0 0.46799994 -0.09200001 q 0.21200013 -0.09200001 0.36800003 -0.24800014 q 0.15600014 -0.1559999 0.24800014 -0.37199998 q 0.09200001 -0.21599984 0.1079998 -0.45599985 Z m 0.6559999 -1.1520002 h -0.6719997 q -0.08800006 -0.408 -0.36400008 -0.608 q -0.27600002 -0.20000005 -0.7080002 -0.20000005 q -0.33599997 0 -0.5839999 0.11200005 q -0.24800003 0.11199999 -0.4080001 0.3 q -0.15999997 0.18800002 -0.232 0.43199998 q -0.07200003 0.24400008 -0.06400001 0.51600003 h 3.0960002 q 0.01600027 0.37599993 -0.06799984 0.79200006 q -0.08400011 0.4159999 -0.30400014 0.7680001 q -0.22000003 0.352 -0.5839999 0.5799999 q -0.36400008 0.22800016 -0.9160001 0.22800016 q -0.42400002 0 -0.7800001 -0.16000032 q -0.35599995 -0.15999985 -0.616 -0.44799995 q -0.26 -0.28799987 -0.404 -0.6799998 q -0.144 -0.3920002 -0.144 -0.8640001 q 0.016000003 -0.47200012 0.14000002 -0.8720001 q 0.12400001 -0.40000004 0.37199998 -0.688 q 0.24800009 -0.28800005 0.61200005 -0.44800004 q 0.36400008 -0.16000001 0.86 -0.16000001 q 0.704 0 1.168 0.352 q 0.46400023 0.35200006 0.5999999 1.0480001 Z "/>
-        </symbol>
-        <symbol id="gEBC5194FC1C7A48F06C53C940408D757" overflow="visible">
-            <path d="M 0 0m 3.3200002 2.808 h 0.704 q -0.03999996 0.36800003 -0.19199991 0.63600016 q -0.15200019 0.2679999 -0.388 0.444 q -0.23600006 0.17599988 -0.54400015 0.26 q -0.3080001 0.08400011 -0.6600001 0.08400011 q -0.48799992 0 -0.85599995 -0.17199993 q -0.36800003 -0.17200017 -0.61200005 -0.47200036 q -0.24400002 -0.29999995 -0.364 -0.704 q -0.120000005 -0.40400004 -0.120000005 -0.86800003 q 0 -0.464 0.12400001 -0.852 q 0.12399998 -0.388 0.368 -0.668 q 0.24400002 -0.28000003 0.608 -0.432 q 0.36400008 -0.15200001 0.8360002 -0.15200001 q 0.7919998 0 1.2519999 0.416 q 0.46000004 0.416 0.57200027 1.184 h -0.6960001 q -0.06400013 -0.48000002 -0.34800005 -0.7440001 q -0.28400016 -0.264 -0.7880001 -0.264 q -0.31999993 0 -0.55200005 0.12800002 q -0.232 0.12800002 -0.37599993 0.34000003 q -0.14400005 0.21199995 -0.21200001 0.48400003 q -0.06800008 0.27199996 -0.06800008 0.55999994 q 0 0.31200004 0.06400001 0.6040001 q 0.06400001 0.29200006 0.21200001 0.51600003 q 0.148 0.22399998 0.39600003 0.3599999 q 0.24800003 0.13600016 0.61599994 0.13600016 q 0.43200016 0 0.6880002 -0.21600008 q 0.25600004 -0.21600008 0.33599997 -0.60800004 Z "/>
-        </symbol>
-        <symbol id="gAD3C9196DFD8002DD8AD647251EA8E6" overflow="visible">
-            <path d="M 0 0m 2.92 0 h 0.68000007 v 4.136 h -0.68000007 v -4.136 Z m 0 4.88 h 0.68000007 v 0.83200026 h -0.68000007 v -0.83200026 Z m -2.128 -1.3439999 v -3.5360003 h 0.68000007 v 3.5360003 h 0.79999995 v 0.5999999 h -0.79999995 v 0.5760002 q 0 0.27199984 0.13599992 0.36800003 q 0.13600004 0.09599972 0.38400006 0.09599972 q 0.08800006 0 0.19199991 -0.012000084 q 0.10400009 -0.011999607 0.19200015 -0.043999672 v 0.592 q -0.095999956 0.032000065 -0.22000003 0.04799986 q -0.12400007 0.01600027 -0.22000003 0.01600027 q -0.56000006 0 -0.852 -0.26000023 q -0.29200006 -0.26000023 -0.29200006 -0.76399994 v -0.6160002 h -0.69600004 v -0.5999999 h 0.69600004 Z "/>
-        </symbol>
-        <symbol id="g403726A1DBA9CA6272A92801D756F7C" overflow="visible">
-            <path d="M 0 0m 4.0800004 0.35200003 v 3.7840002 h -0.64000034 v -0.592 h -0.007999897 q -0.18400002 0.3440001 -0.5120001 0.5160003 q -0.32800007 0.17199993 -0.72 0.17199993 q -0.536 0 -0.90400004 -0.204 q -0.36799997 -0.20400023 -0.59199995 -0.5200002 q -0.22400004 -0.31599998 -0.32000005 -0.704 q -0.095999986 -0.388 -0.095999986 -0.75600004 q 0 -0.42400002 0.116 -0.804 q 0.11600003 -0.38000005 0.34800002 -0.66400003 q 0.232 -0.28400004 0.57600003 -0.45200002 q 0.34399998 -0.16800001 0.8080001 -0.16800001 q 0.39999986 0 0.75600004 0.18 q 0.35599995 0.18000002 0.53200006 0.56400007 h 0.015999794 v -0.27200004 q 0 -0.344 -0.06799984 -0.632 q -0.06800008 -0.28800005 -0.22000003 -0.49200004 q -0.15199995 -0.204 -0.38400006 -0.32000005 q -0.23200011 -0.11599994 -0.5680001 -0.11599994 q -0.16799998 0 -0.352 0.036000013 q -0.18400002 0.036000013 -0.34000003 0.11599994 q -0.1559999 0.08000004 -0.26399994 0.20800006 q -0.10800004 0.12799996 -0.116000056 0.31199998 h -0.68 q 0.016000003 -0.33600003 0.176 -0.568 q 0.16000003 -0.232 0.40399998 -0.37600005 q 0.24400008 -0.14399993 0.544 -0.20799994 q 0.30000007 -0.06400001 0.58800006 -0.06400001 q 0.9920001 0 1.4560001 0.50399995 q 0.46400023 0.50400007 0.46400023 1.5200001 Z m -1.9040003 0.20000002 q -0.33600008 0 -0.56000006 0.13999999 q -0.22399998 0.13999999 -0.36 0.36800003 q -0.13600004 0.22800004 -0.19200003 0.508 q -0.055999994 0.27999997 -0.055999994 0.55999994 q 0 0.296 0.06800008 0.5680001 q 0.06799996 0.27200007 0.21599996 0.48000002 q 0.148 0.20799994 0.38 0.33200002 q 0.232 0.12400007 0.56000006 0.12400007 q 0.31999993 0 0.5439999 -0.12800002 q 0.22400022 -0.12800002 0.36400008 -0.34000015 q 0.1400001 -0.2119999 0.204 -0.47599983 q 0.06400013 -0.26400018 0.06400013 -0.536 q 0 -0.2880001 -0.06800008 -0.5760001 q -0.06800008 -0.288 -0.2119999 -0.51600003 q -0.14400005 -0.22800004 -0.3800001 -0.36800003 q -0.23600006 -0.13999999 -0.572 -0.13999999 Z "/>
-        </symbol>
-        <symbol id="gFFA01FEE3974FB44A414D4377DF74C95" overflow="visible">
-            <path d="M 0 0m 4.176 0.016 q -0.17600012 -0.10400001 -0.48799992 -0.10400001 q -0.26399994 0 -0.42000008 0.148 q -0.1559999 0.148 -0.1559999 0.48400003 q -0.2800002 -0.33600003 -0.6520002 -0.48400003 q -0.37199998 -0.148 -0.8039999 -0.148 q -0.2800001 0 -0.53200006 0.06400001 q -0.25200003 0.064 -0.43600005 0.20000002 q -0.18400002 0.13599999 -0.292 0.356 q -0.10800001 0.22000003 -0.10800001 0.532 q 0 0.352 0.120000005 0.5760001 q 0.119999975 0.22399998 0.316 0.36400008 q 0.19599998 0.13999987 0.448 0.2119999 q 0.25199997 0.07200003 0.51600003 0.120000124 q 0.27999997 0.055999994 0.53199995 0.08399987 q 0.2520001 0.028000116 0.444 0.07999992 q 0.19200015 0.052000046 0.30400014 0.15200019 q 0.11199999 0.099999905 0.11199999 0.29200006 q 0 0.22399998 -0.08400011 0.3599999 q -0.08399987 0.13599992 -0.21599984 0.20799994 q -0.13199997 0.07200003 -0.296 0.096000195 q -0.16400003 0.02399993 -0.32400012 0.02399993 q -0.43200004 0 -0.72 -0.16400003 q -0.288 -0.16400003 -0.31200004 -0.6200001 h -0.68 q 0.016000003 0.38400006 0.16000003 0.648 q 0.144 0.26400018 0.384 0.4280002 q 0.24000007 0.16400003 0.54800004 0.23600006 q 0.30799997 0.07200003 0.65999997 0.07200003 q 0.27999997 0 0.556 -0.03999996 q 0.27600002 -0.03999996 0.5 -0.16400003 q 0.22400022 -0.12400007 0.36000013 -0.3480003 q 0.13599992 -0.22399998 0.13599992 -0.5839999 v -2.1280003 q 0 -0.24000001 0.028000116 -0.352 q 0.027999878 -0.11200005 0.18799996 -0.11200005 q 0.08800006 0 0.20799994 0.04000002 v -0.52800006 Z m -1.1040001 2.1200001 q -0.12799978 -0.095999956 -0.33599997 -0.1400001 q -0.20799994 -0.04399991 -0.43599987 -0.07199991 q -0.22800016 -0.027999997 -0.46000016 -0.06400001 q -0.232 -0.036000013 -0.416 -0.116000056 q -0.18400002 -0.08000004 -0.29999995 -0.22800004 q -0.116000056 -0.148 -0.116000056 -0.40399992 q 0 -0.16800004 0.06800008 -0.28400004 q 0.06799996 -0.116000056 0.176 -0.18800002 q 0.10799992 -0.07200003 0.25199997 -0.10400003 q 0.14400005 -0.032000005 0.30400002 -0.032000005 q 0.33599997 0 0.576 0.09200001 q 0.24000001 0.09200001 0.39199996 0.23200005 q 0.15200019 0.13999999 0.22400022 0.30400002 q 0.07199979 0.16399992 0.07199979 0.30799997 v 0.6960001 Z "/>
-        </symbol>
-        <symbol id="g8C3B87D37300021CAF28AE99C6A53743" overflow="visible">
-            <path d="M 0 0m 0.55200005 5.7120004 v -5.7120004 h 0.68000007 v 5.7120004 h -0.68000007 Z "/>
-        </symbol>
-        <symbol id="gEA2E7995284F078BE317DAED71DE81DC" overflow="visible">
-            <path d="M 0 0m 1.6320001 -1.5760001 h 0.5200001 q -0.5680001 0.9200001 -0.81200016 1.8240001 q -0.24399996 0.90400004 -0.24399996 1.9120001 q 0 0.98399997 0.24000001 1.8799999 q 0.24000001 0.8960004 0.8160001 1.8080001 h -0.5200001 q -0.6240001 -0.8239999 -0.94000006 -1.7839999 q -0.316 -0.96000004 -0.316 -1.904 q 0 -0.528 0.088 -1.008 q 0.08800003 -0.48000002 0.252 -0.93600005 q 0.16400003 -0.45600003 0.3960001 -0.90000004 q 0.232 -0.444 0.52 -0.8920001 Z "/>
-        </symbol>
-        <symbol id="g8F6718057B0E3514573AA9B4A2FC38A1" overflow="visible">
-            <path d="M 0 0m 3.936 0 v 4.136 h -0.68000007 v -2.336 q 0 -0.27999997 -0.075999975 -0.51600003 q -0.075999975 -0.23599994 -0.22799993 -0.412 q -0.15199995 -0.176 -0.3800001 -0.272 q -0.22799993 -0.096000016 -0.53999996 -0.096000016 q -0.39199996 0 -0.61600006 0.22400004 q -0.22399998 0.22399998 -0.22399998 0.60800004 v 2.8000002 h -0.68 v -2.7200003 q 0 -0.33599997 0.06800002 -0.612 q 0.06799996 -0.27600002 0.236 -0.476 q 0.16799998 -0.2 0.44 -0.308 q 0.27200007 -0.10800001 0.68000007 -0.10800001 q 0.4560001 0 0.79200006 0.18 q 0.33599997 0.18 0.55200005 0.564 h 0.016000032 v -0.656 h 0.63999987 Z "/>
-        </symbol>
-        <symbol id="g11B4CFF4C9AF9181ECD6A36A02010591" overflow="visible">
-            <path d="M 0 0m 0.536 5.7120004 v -5.7120004 h 0.68000007 v 0.55200005 h 0.016000032 q 0.11199999 -0.18400002 0.2759999 -0.30800003 q 0.16400003 -0.12400001 0.34800005 -0.19600001 q 0.18400013 -0.072 0.3720001 -0.104 q 0.18799996 -0.032000005 0.3399999 -0.032000005 q 0.47200012 0 0.82800007 0.16800001 q 0.35599995 0.16800001 0.592 0.46 q 0.23599982 0.292 0.352 0.6840001 q 0.116000175 0.39199996 0.116000175 0.8319999 q 0 0.44000006 -0.119999886 0.83200026 q -0.12000036 0.39199996 -0.35600019 0.6919999 q -0.23600006 0.29999995 -0.592 0.47600007 q -0.35600019 0.17600012 -0.8360002 0.17600012 q -0.43199992 0 -0.79199994 -0.15600014 q -0.36 -0.15600014 -0.528 -0.5 h -0.016000032 v 2.1360002 h -0.68000007 Z m 3.2 -3.6080003 q 0 -0.30400002 -0.06399989 -0.592 q -0.06399989 -0.288 -0.20799994 -0.5120001 q -0.14400005 -0.22399998 -0.3800001 -0.35999995 q -0.23600006 -0.13600004 -0.58800006 -0.13600004 q -0.352 0 -0.5999999 0.13200003 q -0.24800003 0.13199997 -0.40400004 0.348 q -0.15600002 0.21600002 -0.22800004 0.50000006 q -0.07200003 0.28400004 -0.07200003 0.58799994 q 0 0.2880001 0.06800008 0.5680001 q 0.06799996 0.27999997 0.21999991 0.5 q 0.15200007 0.22000003 0.39200008 0.35599995 q 0.23999989 0.13600016 0.584 0.13600016 q 0.32800007 0 0.572 -0.12800002 q 0.24399996 -0.12800002 0.4000001 -0.3440001 q 0.1559999 -0.21599984 0.23199987 -0.49199986 q 0.075999975 -0.27600002 0.075999975 -0.5640001 Z "/>
-        </symbol>
-        <symbol id="gB6FD75F5298B86FC5D51AC6F195ECA25" overflow="visible">
-            <path d="M 0 0m 2.1360002 -0.55200005 q -0.120000124 -0.30400002 -0.23600006 -0.51199996 q -0.116000056 -0.20800006 -0.25600004 -0.34000003 q -0.13999999 -0.13199997 -0.31200004 -0.19200003 q -0.17199993 -0.060000062 -0.39599997 -0.060000062 q -0.120000005 0 -0.24000001 0.016000032 q -0.120000005 0.016000032 -0.23200002 0.055999994 v 0.6240001 q 0.08800003 -0.03999996 0.20400003 -0.06799996 q 0.116 -0.027999997 0.19599998 -0.027999997 q 0.208 0 0.348 0.099999964 q 0.1400001 0.099999964 0.21200001 0.28399998 l 0.2800001 0.69600004 l -1.6400001 4.112 h 0.768 l 1.2080002 -3.384 h 0.015999794 l 1.1600001 3.384 h 0.72 l -1.8 -4.688 Z "/>
-        </symbol>
-        <symbol id="gF6E6E618EB7A8A012445F280241D7C98" overflow="visible">
-            <path d="M 0 0m 1.008 2.032 q 0 0.30400014 0.06400001 0.592 q 0.06400001 0.2880001 0.20800006 0.5120001 q 0.14399993 0.22399998 0.38399994 0.3599999 q 0.24000001 0.13600016 0.5840001 0.13600016 q 0.352 0 0.5999999 -0.13199997 q 0.24800014 -0.13199997 0.40400004 -0.34800005 q 0.15600014 -0.21600008 0.22800016 -0.5 q 0.07200003 -0.28400016 0.07200003 -0.58800006 q 0 -0.288 -0.06800008 -0.5680001 q -0.06800008 -0.27999997 -0.22000003 -0.5 q -0.15199995 -0.22000003 -0.39199996 -0.356 q -0.24000001 -0.13600004 -0.5840001 -0.13600004 q -0.32800007 0 -0.572 0.12800002 q -0.24399996 0.12800002 -0.39999998 0.34400004 q -0.15600002 0.21599996 -0.232 0.49199998 q -0.076000094 0.27600002 -0.076000094 0.564 Z m 3.2000003 -2.032 v 5.7120004 h -0.68000007 v -2.1280003 h -0.016000032 q -0.11199999 0.18400002 -0.27600002 0.3080001 q -0.16400003 0.12400007 -0.3479998 0.19999981 q -0.18400002 0.07600021 -0.36800003 0.10800028 q -0.18400002 0.032000065 -0.3440001 0.032000065 q -0.472 0 -0.82800007 -0.17199993 q -0.356 -0.17200017 -0.592 -0.46400023 q -0.236 -0.29200006 -0.35200003 -0.684 q -0.116 -0.39199996 -0.116 -0.832 q 0 -0.44000006 0.120000005 -0.83200014 q 0.119999975 -0.39199996 0.35600004 -0.688 q 0.23599994 -0.296 0.592 -0.472 q 0.35600007 -0.17600001 0.8360001 -0.17600001 q 0.43199992 0 0.79200006 0.15200001 q 0.3599999 0.15200001 0.5279999 0.496 h 0.016000032 v -0.56 h 0.68000007 Z "/>
-        </symbol>
-        <symbol id="g38385C688BB0F21A935DCB07A45652A7" overflow="visible">
-            <path d="M 0 0m -0.072000004 -1.5760001 h 0.512 q 0.62399995 0.82400006 0.94000006 1.7800001 q 0.31599998 0.9560001 0.31599998 1.9000001 q 0 0.5280001 -0.08800006 1.0080001 q -0.08799994 0.48000002 -0.25199997 0.9399998 q -0.16400003 0.46000004 -0.39600003 0.9040003 q -0.232 0.44399977 -0.52 0.8919997 h -0.512 q 0.56000006 -0.9199996 0.8040001 -1.8280001 q 0.24400002 -0.90799975 0.24400002 -1.9159999 q 0 -0.9760001 -0.24000001 -1.876 q -0.24000004 -0.9000001 -0.8080001 -1.8040001 Z "/>
-        </symbol>
-        <symbol id="g9A3A3A35D6C54D3285C5E0F1A91F795E" overflow="visible">
-            <path d="M 0 0m 0.66400003 0.8880001 v -0.8880001 h 0.888 v 0.8880001 h -0.888 Z "/>
-        </symbol>
-    </defs>
-</svg>
+<svg viewBox="0 0 580.113245512 189.446015654" width="580.113245512pt" height="189.446015654pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h5="http://www.w3.org/1999/xhtml"><g transform="translate(5 5)"><g><path fill="none" transform="translate(96.845456598)" d="M 0 0h 60.56v 7.14h -60.56v -7.14Z "/><g transform="translate(96.845456488 -9.4e-8)"><g><g transform="matrix(1 0 0 -1 0 7.14)"><use xlink:href="#gFF1D6FE0FCEFE59EC272C893571781D4" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gBE46CFB3EBAB215C63CA4E5DC5C3824E" x="7.59" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76DBFC4FA93EE2DE8BA6DB7B8CF9007" x="11.48" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gA7EC01E9D99E89B77E57F8F2E702D511" x="17.22" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g7FB0EDCAB970990EA555F2D3E23D2BD3" x="23.33" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gD7F3AA0CF2239D4DE6F87820275D4542" x="32.04" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gAF6679426DD77E90F0A155C1B3331519" x="38.15" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gA7EC01E9D99E89B77E57F8F2E702D511" x="43.34" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g34C6A7BC17D0AF2BD816D9B656C21B9A" x="49.45" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g3BDD167888FE9297E5CBBF14977DDF81" x="55.19" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="none" transform="translate(377.121878016)" d="M 0 0h 38.69v 7.14h -38.69v -7.14Z "/><g transform="translate(377.121877906 -9.4e-8)"><g><g transform="matrix(1 0 0 -1 0 7.14)"><use xlink:href="#g5B82351F2E16F62A295346CE3CBF2A80" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g34C6A7BC17D0AF2BD816D9B656C21B9A" x="9.44" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g466B6B17946BCB398180A2A732955F46" x="15.18" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g2744CAB5F00DFFC307CCED82D504DAFF" x="17.76" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g7FB0EDCAB970990EA555F2D3E23D2BD3" x="23.87" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g1E821005B4B7EF2FE058D447671C18D3" x="29.8" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g3BDD167888FE9297E5CBBF14977DDF81" x="33.32" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="none" transform="translate(486.276340063)" d="M 0 0h 41.66v 7.14h -41.66v -7.14Z "/><g transform="translate(486.276339953 -9.4e-8)"><g><g transform="matrix(1 0 0 -1 0 7.14)"><use xlink:href="#g6E719F786D7B1141CA8C4512E00A2E0D" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF615D1769D4A065C3B81AFF62715CD4A" x="10" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76DBFC4FA93EE2DE8BA6DB7B8CF9007" x="16.3" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g2A097BC7EEE91105D52B352EA84246F0" x="22.04" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g69D4CD72297CC97098F7E4B54BF2CCDC" x="24.62" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g34C6A7BC17D0AF2BD816D9B656C21B9A" x="30.55" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g3BDD167888FE9297E5CBBF14977DDF81" x="36.29" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(96.541956567 12.694582583)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 51.167c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -51.167Z "/><path fill="none" transform="translate(102.541956598 18.694582677)" d="M 0 0h 49.167v 6.426h -49.167v -6.426Z "/><g transform="translate(102.541956457 18.694582677)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g358648C530966537EABEBBEC18198CC8" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gC31F60C8C41E19EEB1D25990511789A" x="6.498" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="10.998" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gBD650B5058F0646EBF236D8F6940AC70" x="16.335" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="21.168" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g80102705FF5D893D49AAE39B792F523C" x="24.165" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="30.996" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="33.993" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="38.826" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="44.163" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(94.786956567 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 54.677c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -54.677Z "/><path fill="none" transform="translate(100.786956598 59.797748031)" d="M 0 0h 52.677v 6.426h -52.677v -6.426Z "/><g transform="translate(100.786956457 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g998BE4B087A0C386337E1CB97229E76" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="5.832" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gA3FF480C19AEB1E21DC8A39262BFE6C2" x="7.83" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="15.507" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gD2DA7E685FECD9D284DE6F57724955B7" x="20.844" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gBD650B5058F0646EBF236D8F6940AC70" x="22.842" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g80102705FF5D893D49AAE39B792F523C" x="27.675" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="34.506" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="37.503" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="42.336" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="47.673" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(0 94.900913386)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 52.499c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -52.499Z "/><path fill="none" transform="translate(5.999999905 100.900913386)" d="M 0 0h 50.499v 6.426h -50.499v -6.426Z "/><g transform="translate(5.999999764 100.900913386)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g8FFCFCF85AD85C5A925A226166F30EA1" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gD2DA7E685FECD9D284DE6F57724955B7" x="5.832" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="7.83" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g526F8306ACF9617F153930C15CD2A475" x="12.663" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="17.667" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="22.5" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g80102705FF5D893D49AAE39B792F523C" x="25.497" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="32.328" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="35.325" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="40.158" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="45.495" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(91.708956567 94.900913386)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 60.833c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -60.833Z "/><path fill="none" transform="translate(97.708956598 100.900913386)" d="M 0 0h 58.833v 6.426h -58.833v -6.426Z "/><g transform="translate(97.708956457 100.900913386)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g2FED6C3E674805F999833164ADE443B8" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="6.165" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="8.163" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="13.5" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="18.333" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g68A669F51D3D2BE053B24A40387EF06E" x="21.33" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="24.165" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g68A669F51D3D2BE053B24A40387EF06E" x="26.163" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gBD650B5058F0646EBF236D8F6940AC70" x="28.998" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g80102705FF5D893D49AAE39B792F523C" x="33.831" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="40.662" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="43.659" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="48.492" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="53.829" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(191.751913417 94.900913386)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 60.842c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -60.842Z "/><path fill="none" transform="translate(197.751913291 100.900913386)" d="M 0 0h 58.842v 6.426h -58.842v -6.426Z "/><g transform="translate(197.75191315 100.900913386)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#gCF81F3250CEF5E439BD9A17D4140A583" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g526F8306ACF9617F153930C15CD2A475" x="6.498" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="11.502" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g68A669F51D3D2BE053B24A40387EF06E" x="13.5" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gFF05D2CF6EC42551B1D130F991FB542F" x="16.335" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="22.671" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g3A4677DDBC586D308BB969EA3D409F2B" x="24.669" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g8211C3A926ABA11A1787DD12A5629A11" x="29.169" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g80102705FF5D893D49AAE39B792F523C" x="33.84" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="40.671" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="43.668" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="48.501" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="53.838" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(140.05868485 136.004078646)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 64.181c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -64.181Z "/><path fill="none" transform="translate(146.058684945 142.00407874)" d="M 0 0h 62.181v 6.426h -62.181v -6.426Z "/><g transform="translate(146.058684803 142.00407874)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="6.003" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g526F8306ACF9617F153930C15CD2A475" x="8.001" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gDF33ECC6A9229D1279F3C3F8743962FF" x="13.005" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g3A4677DDBC586D308BB969EA3D409F2B" x="18.171" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g998BE4B087A0C386337E1CB97229E76" x="22.671" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF6ECA5CBE62F1294F74D902B5E4CD26E" x="28.503" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4924820D7208E420C95C1F6ADAAF48E" x="33.507" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gDF33ECC6A9229D1279F3C3F8743962FF" x="38.844" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="44.01" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="47.007" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="51.84" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="57.177" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dbeafe" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(225.052391622 136.004078646)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 80.678c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -80.678Z "/><path fill="none" transform="translate(231.052391638 142.00407874)" d="M 0 0h 78.678v 6.426h -78.678v -6.426Z "/><g transform="translate(231.052391496 142.00407874)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g17E1EDF03D20F92C5D9A1C646E2F3F53" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="4.338" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="7.335" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="9.333" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g526F8306ACF9617F153930C15CD2A475" x="14.166" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gDF33ECC6A9229D1279F3C3F8743962FF" x="19.17" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF6ECA5CBE62F1294F74D902B5E4CD26E" x="24.336" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gD2DA7E685FECD9D284DE6F57724955B7" x="29.34" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="31.338" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="36.171" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g998BE4B087A0C386337E1CB97229E76" x="39.168" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF6ECA5CBE62F1294F74D902B5E4CD26E" x="45" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4924820D7208E420C95C1F6ADAAF48E" x="50.004" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gDF33ECC6A9229D1279F3C3F8743962FF" x="55.341" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g51AEC211C4B4ABC5D9D55D5612BCFCD6" x="60.507" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g76AD9D48F7250D6C3EDAA0782F20ADD4" x="63.504" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g4BF6675A1F6A6F6A675D8BE7B8863BAB" x="68.337" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g9F69CFB5E12EEFE787A8731335FF6501" x="73.674" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#fce7f3" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(384.130877953 12.694582583)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 14.672c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -14.672Z "/><path fill="none" transform="translate(390.130878016 18.694582677)" d="M 0 0h 12.672v 6.426h -12.672v -6.426Z "/><g transform="translate(390.130877874 18.694582677)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g706DBDF2AFA18A24933A6A647147C19C" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g28654F3BE91BBF146A05420E9B69B910" x="2.664" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gB6C1C9281F1479B90715012C930C0F89" x="7.668" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#fce7f3" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(384.463877953 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 14.006c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -14.006Z "/><path fill="none" transform="translate(390.463878016 59.797748031)" d="M 0 0h 12.006v 6.426h -12.006v -6.426Z "/><g transform="translate(390.463877874 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#gF7F3FC75D830406F7324CCD66FBDC70F" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g28654F3BE91BBF146A05420E9B69B910" x="1.998" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gB6C1C9281F1479B90715012C930C0F89" x="7.002" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#fce7f3" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(382.128377953 94.900913386)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 18.677c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -18.677Z "/><path fill="none" transform="translate(388.128378016 100.900913386)" d="M 0 0h 16.677v 6.426h -16.677v -6.426Z "/><g transform="translate(388.128377874 100.900913386)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g4BF2C94D2014A0FD17E6C8283E7BF557" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g526F8306ACF9617F153930C15CD2A475" x="6.84" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gBD650B5058F0646EBF236D8F6940AC70" x="11.844" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(494.855840126 12.694582583)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 14.501c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -14.501Z "/><path fill="none" transform="translate(500.855840063 18.694582677)" d="M 0 0h 12.501v 6.426h -12.501v -6.426Z "/><g transform="translate(500.855839921 18.694582677)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gE7B19A31542CA9616E8E9C203DE80E3B" x="6.003" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(444.09943474 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 13.007c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -13.007Z "/><path fill="none" transform="translate(450.099434709 59.797748031)" d="M 0 0h 11.007v 6.426h -11.007v -6.426Z "/><g transform="translate(450.099434567 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g79CC640AF8FDC181F546B16B9C037F2D" x="6.003" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(469.851137291 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 13.007c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -13.007Z "/><path fill="none" transform="translate(475.851137386 59.797748031)" d="M 0 0h 11.007v 6.426h -11.007v -6.426Z "/><g transform="translate(475.851137244 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#g144781C0177D7CE205CAE9D9D2ABC7A1" x="6.003" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(495.602840126 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 13.007c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -13.007Z "/><path fill="none" transform="translate(501.602840063 59.797748031)" d="M 0 0h 11.007v 6.426h -11.007v -6.426Z "/><g transform="translate(501.602839921 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gBCC2E373F8E1DF1573A99001CD4735AE" x="6.003" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(521.354542677 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 13.007c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -13.007Z "/><path fill="none" transform="translate(527.35454274 59.797748031)" d="M 0 0h 11.007v 6.426h -11.007v -6.426Z "/><g transform="translate(527.354542598 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gB6C1C9281F1479B90715012C930C0F89" x="6.003" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g><path fill="#dcfce7" fill-rule="nonzero" stroke="#64748b" stroke-width="1.5" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" transform="translate(547.106245512 53.797748126)" d="M 0 0m 5 0c -2.75892 0 -5 2.24108 -5 5v 8.426c 0 2.75892 2.24108 5 5 5h 13.007c 2.75892 0 5 -2.24108 5 -5v -8.426c 0 -2.75892 -2.24108 -5 -5 -5h -13.007Z "/><path fill="none" transform="translate(553.106245417 59.797748031)" d="M 0 0h 11.007v 6.426h -11.007v -6.426Z "/><g transform="translate(553.106245276 59.797748031)"><g><g transform="matrix(1 0 0 -1 0 6.426)"><use xlink:href="#g643259D216747AA812B6855D4BA0DE42" x="0" y="0" fill="#1e293b" fill-rule="nonzero"/><use xlink:href="#gF8E599750D79A27F88B7064C5092ABD6" x="6.003" y="0" fill="#1e293b" fill-rule="nonzero"/></g></g></g></g></g><g transform="matrix(1 0 0 -1 5 184.446015654)"><use xlink:href="#g81DFD15D696831D3AEDE372C6840E29B" x="0" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gC76F11DAD52FAC92E5F6681E1F3A8E24" x="5.776" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gFC762F034065CB92308F77DA50904636" x="10.368" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g9524DB2AB7AD3B578280EC160D005BAC" x="14.816" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gDE0960E94F350358A27A95EE3692B6C6" x="19.112" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g6B217B44DBEC65D521E4D6C450891318" x="21.632" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g786D0DA605A095191D5C33A5BB968848" x="25.928" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g6B217B44DBEC65D521E4D6C450891318" x="28.448" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g6C0EF9DFF594A5A60F31076377FDB72A" x="34.968" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gB9D4D6D822821FBD03112B321A4F5F37" x="38.968" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g8F816F4F6B3A797165B922832E440B5A" x="43.264" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g9186BB761FCB61E50F26CCCFD81F00F6" x="45.04" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g6B217B44DBEC65D521E4D6C450891318" x="49.488" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g3633D5EF187E794EAF4ED06368BFDFCF" x="53.784" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g33AE866EDA811CB59C344F15280DE76E" x="60.008" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gDE0960E94F350358A27A95EE3692B6C6" x="64.6" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gC76F11DAD52FAC92E5F6681E1F3A8E24" x="67.12" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g9186BB761FCB61E50F26CCCFD81F00F6" x="71.712" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g97071A2893B0C7191AEDE27EAE655EFE" x="76.16" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g6B217B44DBEC65D521E4D6C450891318" x="80.904" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g56F73A9DDE7688229227FB61E73B22EB" x="85.2" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gA140E16CF1ABF13007304C5857587282" x="92.168" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g9DE8B4E528C361BFE10E18BF85136915" x="96.912" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g6C0EF9DFF594A5A60F31076377FDB72A" x="103.136" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gB9D4D6D822821FBD03112B321A4F5F37" x="107.136" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gDE0960E94F350358A27A95EE3692B6C6" x="111.432" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g32B342CADBF6914BAE52C992C70E94C0" x="114.096" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gB9D4D6D822821FBD03112B321A4F5F37" x="115.872" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gFC762F034065CB92308F77DA50904636" x="120.168" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g786D0DA605A095191D5C33A5BB968848" x="124.616" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g56F73A9DDE7688229227FB61E73B22EB" x="129.36" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g32B342CADBF6914BAE52C992C70E94C0" x="134.104" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g53D2D7990B1448118A03E4A23C44B622" x="135.88" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g6B217B44DBEC65D521E4D6C450891318" x="142.704" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gFC762F034065CB92308F77DA50904636" x="147" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g3633D5EF187E794EAF4ED06368BFDFCF" x="151.448" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g32B342CADBF6914BAE52C992C70E94C0" x="155.448" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gC76F11DAD52FAC92E5F6681E1F3A8E24" x="157.224" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#gFC762F034065CB92308F77DA50904636" x="161.816" y="0" fill="#6b7280" fill-rule="nonzero"/><use xlink:href="#g39FF3551F1CB57B29C5CAADE5C30FA34" x="166.264" y="0" fill="#6b7280" fill-rule="nonzero"/></g><defs><symbol id="gFF1D6FE0FCEFE59EC272C893571781D4" overflow="visible"><path d="M 0 0m 5.85 0.81l 0.16 -0.81h 1v 3.86h -3v -1.17h 1.58q -0.07 -0.75 -0.495 -1.145q -0.425 -0.395 -1.205 -0.395q -0.53 0 -0.9 0.205q -0.37 0.205 -0.6 0.545q -0.23 0.34 -0.335 0.765q -0.105 0.425 -0.105 0.875q 0 0.47 0.105 0.91q 0.105 0.44 0.335 0.785q 0.23 0.345 0.6 0.55q 0.37 0.205 0.9 0.205q 0.57 0 0.97 -0.3q 0.4 -0.3 0.54 -0.9h 1.5q -0.06 0.61 -0.33 1.08q -0.27 0.47 -0.685 0.79q -0.415 0.32 -0.93 0.485q -0.515 0.165 -1.065 0.165q -0.82 0 -1.475 -0.29q -0.655 -0.29 -1.105 -0.8q -0.45 -0.51 -0.69 -1.195q -0.24 -0.685 -0.24 -1.485q 0 -0.78 0.24 -1.455q 0.24 -0.675 0.69 -1.175q 0.45 -0.5 1.105 -0.785q 0.655 -0.285 1.475 -0.285q 0.52 0 1.03 0.215q 0.51 0.215 0.93 0.755Z "/></symbol><symbol id="gBE46CFB3EBAB215C63CA4E5DC5C3824E" overflow="visible"><path d="M 0 0m 0.54 5.17v -5.17h 1.42v 2.33q 0 0.35 0.07 0.65q 0.07 0.3 0.235 0.525q 0.165 0.225 0.435 0.355q 0.27 0.13 0.66 0.13q 0.13 0 0.27 -0.015q 0.14 -0.015 0.24 -0.035v 1.32q -0.17 0.05 -0.31 0.05q -0.27 0 -0.52 -0.08q -0.25 -0.08 -0.47 -0.225q -0.22 -0.145 -0.39 -0.35q -0.17 -0.205 -0.27 -0.445h -0.02v 0.96h -1.35Z "/></symbol><symbol id="g76DBFC4FA93EE2DE8BA6DB7B8CF9007" overflow="visible"><path d="M 0 0m 0.48 3.58q 0.03 0.5 0.25 0.83q 0.22 0.33 0.56 0.53q 0.34 0.2 0.765 0.285q 0.425 0.085 0.855 0.085q 0.39 0 0.79 -0.055q 0.4 -0.055 0.73 -0.215q 0.33 -0.16 0.54 -0.445q 0.21 -0.285 0.21 -0.755v -2.69q 0 -0.35 0.04 -0.67q 0.04 -0.32 0.14 -0.48h -1.44q -0.04 0.12 -0.065 0.245q -0.025 0.125 -0.035 0.255q -0.34 -0.35 -0.8 -0.49q -0.46 -0.14 -0.94 -0.14q -0.37 0 -0.69 0.09q -0.32 0.09 -0.56 0.28q -0.24 0.19 -0.375 0.48q -0.135 0.29 -0.135 0.69q 0 0.44 0.155 0.725q 0.155 0.285 0.4 0.455q 0.245 0.17 0.56 0.255q 0.315 0.085 0.635 0.135q 0.32 0.05 0.63 0.08q 0.31 0.03 0.55 0.09q 0.24 0.06 0.38 0.175q 0.14 0.115 0.13 0.335q 0 0.23 -0.075 0.365q -0.075 0.135 -0.2 0.21q -0.125 0.075 -0.29 0.1q -0.165 0.025 -0.355 0.025q -0.42 0 -0.66 -0.18q -0.24 -0.18 -0.28 -0.6h -1.42Z m 3.28 -1.05q -0.09 -0.08 -0.225 -0.125q -0.135 -0.045 -0.29 -0.075q -0.155 -0.03 -0.325 -0.05q -0.17 -0.02 -0.34 -0.05q -0.16 -0.03 -0.315 -0.08q -0.155 -0.05 -0.27 -0.135q -0.115 -0.085 -0.185 -0.215q -0.07 -0.13 -0.07 -0.33q 0 -0.19 0.07 -0.32q 0.07 -0.13 0.19 -0.205q 0.12 -0.075 0.28 -0.105q 0.16 -0.03 0.33 -0.03q 0.42 0 0.65 0.14q 0.23 0.14 0.34 0.335q 0.11 0.195 0.135 0.395q 0.025 0.2 0.025 0.32v 0.53Z "/></symbol><symbol id="gA7EC01E9D99E89B77E57F8F2E702D511" overflow="visible"><path d="M 0 0m 3.15 0.93q -0.34 0 -0.58 0.14q -0.24 0.14 -0.385 0.365q -0.145 0.225 -0.21 0.525q -0.065 0.3 -0.065 0.61q 0 0.32 0.06 0.62q 0.06 0.3 0.205 0.53q 0.145 0.23 0.38 0.375q 0.235 0.145 0.585 0.145q 0.34 0 0.575 -0.145q 0.235 -0.145 0.385 -0.38q 0.15 -0.235 0.215 -0.535q 0.065 -0.3 0.065 -0.61q 0 -0.31 -0.06 -0.61q -0.06 -0.3 -0.205 -0.525q -0.145 -0.225 -0.38 -0.365q -0.235 -0.14 -0.585 -0.14Z m -2.61 4.24v -6.98h 1.42v 2.45h 0.02q 0.26 -0.38 0.665 -0.575q 0.405 -0.195 0.885 -0.195q 0.57 0 0.995 0.22q 0.425 0.22 0.71 0.59q 0.285 0.37 0.425 0.85q 0.14 0.48 0.14 1q 0 0.55 -0.14 1.055q -0.14 0.505 -0.43 0.885q -0.29 0.38 -0.73 0.61q -0.44 0.23 -1.05 0.23q -0.48 0 -0.88 -0.19q -0.4 -0.19 -0.66 -0.61h -0.02v 0.66h -1.35Z "/></symbol><symbol id="g7FB0EDCAB970990EA555F2D3E23D2BD3" overflow="visible"><path d="M 0 0m 0.54 7.14v -7.14h 1.42v 2.71q 0 0.79 0.26 1.135q 0.26 0.345 0.84 0.345q 0.51 0 0.71 -0.315q 0.2 -0.315 0.2 -0.955v -2.92h 1.42v 3.18q 0 0.48 -0.085 0.875q -0.085 0.395 -0.295 0.67q -0.21 0.275 -0.575 0.43q -0.365 0.155 -0.935 0.155q -0.4 0 -0.82 -0.205q -0.42 -0.205 -0.69 -0.655h -0.03v 2.69h -1.42Z "/></symbol><symbol id="gD7F3AA0CF2239D4DE6F87820275D4542" overflow="visible"><path d="M 0 0m 2.27 5.82v -5.82h 1.57v 5.82h 2.14v 1.32h -5.85v -1.32h 2.14Z "/></symbol><symbol id="gAF6679426DD77E90F0A155C1B3331519" overflow="visible"><path d="M 0 0m 3.09 -0.64l 2.16 5.81h -1.47l -1.13 -3.54h -0.02l -1.17 3.54h -1.51l 1.81 -4.85q 0.06 -0.15 0.06 -0.32q 0 -0.23 -0.135 -0.42q -0.135 -0.19 -0.415 -0.22q -0.21 -0.01 -0.42 0.01q -0.21 0.02 -0.41 0.04v -1.17q 0.22 -0.02 0.435 -0.035q 0.215 -0.015 0.435 -0.015q 0.73 0 1.14 0.27q 0.41 0.27 0.64 0.9Z "/></symbol><symbol id="g34C6A7BC17D0AF2BD816D9B656C21B9A" overflow="visible"><path d="M 0 0m 4.02 3.14h -2.31q 0.01 0.15 0.065 0.34q 0.055 0.19 0.19 0.36q 0.135 0.17 0.36 0.285q 0.225 0.115 0.565 0.115q 0.52 0 0.775 -0.28q 0.255 -0.28 0.355 -0.82Z m -2.31 -0.9h 3.73q 0.04 0.6 -0.1 1.15q -0.14 0.55 -0.455 0.98q -0.315 0.43 -0.805 0.685q -0.49 0.255 -1.15 0.255q -0.59 0 -1.075 -0.21q -0.485 -0.21 -0.835 -0.575q -0.35 -0.365 -0.54 -0.865q -0.19 -0.5 -0.19 -1.08q 0 -0.6 0.185 -1.1q 0.185 -0.5 0.525 -0.86q 0.34 -0.36 0.83 -0.555q 0.49 -0.195 1.1 -0.195q 0.88 0 1.5 0.4q 0.62 0.4 0.92 1.33h -1.25q -0.07 -0.24 -0.38 -0.455q -0.31 -0.215 -0.74 -0.215q -0.6 0 -0.92 0.31q -0.32 0.31 -0.35 1Z "/></symbol><symbol id="g3BDD167888FE9297E5CBBF14977DDF81" overflow="visible"><path d="M 0 0m 1.64 1.68h -1.35q 0.02 -0.52 0.235 -0.865q 0.215 -0.345 0.55 -0.555q 0.335 -0.21 0.765 -0.3q 0.43 -0.09 0.88 -0.09q 0.44 0 0.865 0.085q 0.425 0.085 0.755 0.295q 0.33 0.21 0.535 0.555q 0.205 0.345 0.205 0.855q 0 0.36 -0.14 0.605q -0.14 0.245 -0.37 0.41q -0.23 0.165 -0.525 0.265q -0.295 0.1 -0.605 0.17q -0.3 0.07 -0.59 0.13q -0.29 0.06 -0.515 0.135q -0.225 0.075 -0.365 0.195q -0.14 0.12 -0.14 0.31q 0 0.16 0.08 0.255q 0.08 0.095 0.195 0.145q 0.115 0.05 0.255 0.065q 0.14 0.015 0.26 0.015q 0.38 0 0.66 -0.145q 0.28 -0.145 0.31 -0.555h 1.35q -0.04 0.48 -0.245 0.795q -0.205 0.315 -0.515 0.505q -0.31 0.19 -0.705 0.27q -0.395 0.08 -0.815 0.08q -0.42 0 -0.82 -0.075q -0.4 -0.075 -0.72 -0.26q -0.32 -0.185 -0.515 -0.505q -0.195 -0.32 -0.195 -0.82q 0 -0.34 0.14 -0.575q 0.14 -0.235 0.37 -0.39q 0.23 -0.155 0.525 -0.25q 0.295 -0.095 0.605 -0.165q 0.76 -0.16 1.185 -0.32q 0.425 -0.16 0.425 -0.48q 0 -0.19 -0.09 -0.315q -0.09 -0.125 -0.225 -0.2q -0.135 -0.075 -0.3 -0.11q -0.165 -0.035 -0.315 -0.035q -0.21 0 -0.405 0.05q -0.195 0.05 -0.345 0.155q -0.15 0.105 -0.245 0.27q -0.095 0.165 -0.095 0.395Z "/></symbol><symbol id="g5B82351F2E16F62A295346CE3CBF2A80" overflow="visible"><path d="M 0 0m 7.49 0l 1.92 7.14h -1.54l -1.17 -4.92h -0.02l -1.22 4.92h -1.47l -1.24 -4.86h -0.02l -1.13 4.86h -1.57l 1.89 -7.14h 1.59l 1.19 4.86h 0.02l 1.21 -4.86h 1.56Z "/></symbol><symbol id="g466B6B17946BCB398180A2A732955F46" overflow="visible"><path d="M 0 0m 2 5.97v 1.17h -1.42v -1.17h 1.42Z m -1.42 -0.8v -5.17h 1.42v 5.17h -1.42Z "/></symbol><symbol id="g2744CAB5F00DFFC307CCED82D504DAFF" overflow="visible"><path d="M 0 0m 2.95 1.22q -0.33 0 -0.55 0.14q -0.22 0.14 -0.355 0.36q -0.135 0.22 -0.19 0.495q -0.055 0.275 -0.055 0.555q 0 0.29 0.065 0.555q 0.065 0.265 0.21 0.47q 0.145 0.205 0.36 0.325q 0.215 0.12 0.515 0.12q 0.35 0 0.58 -0.13q 0.23 -0.13 0.37 -0.35q 0.14 -0.22 0.2 -0.505q 0.06 -0.285 0.06 -0.605q 0 -0.28 -0.075 -0.535q -0.075 -0.255 -0.225 -0.455q -0.15 -0.2 -0.38 -0.32q -0.23 -0.12 -0.53 -0.12Z m 2.56 -0.89v 4.84h -1.35v -0.69h -0.02q -0.26 0.45 -0.645 0.64q -0.385 0.19 -0.895 0.19q -0.54 0 -0.955 -0.21q -0.415 -0.21 -0.695 -0.565q -0.28 -0.355 -0.425 -0.82q -0.145 -0.465 -0.145 -0.965q 0 -0.53 0.125 -1.005q 0.125 -0.475 0.395 -0.83q 0.27 -0.355 0.69 -0.56q 0.42 -0.205 1 -0.205q 0.47 0 0.895 0.195q 0.425 0.195 0.655 0.605h 0.02v -0.68q 0.01 -0.55 -0.265 -0.91q -0.275 -0.36 -0.875 -0.36q -0.38 0 -0.67 0.155q -0.29 0.155 -0.39 0.555h -1.41q 0.03 -0.44 0.245 -0.755q 0.215 -0.315 0.54 -0.515q 0.325 -0.2 0.72 -0.295q 0.395 -0.095 0.775 -0.095q 0.89 0 1.42 0.24q 0.53 0.24 0.81 0.585q 0.28 0.345 0.365 0.745q 0.085 0.4 0.085 0.71Z "/></symbol><symbol id="g1E821005B4B7EF2FE058D447671C18D3" overflow="visible"><path d="M 0 0m 2.34 5.17v 1.55h -1.42v -1.55h -0.86v -0.95h 0.86v -3.05q 0 -0.39 0.13 -0.63q 0.13 -0.24 0.355 -0.37q 0.225 -0.13 0.52 -0.175q 0.295 -0.045 0.625 -0.045q 0.21 0 0.43 0.01q 0.22 0.01 0.4 0.04v 1.1q -0.1 -0.02 -0.21 -0.03q -0.11 -0.01 -0.23 -0.01q -0.36 0 -0.48 0.12q -0.12 0.12 -0.12 0.48v 2.56h 1.04v 0.95h -1.04Z "/></symbol><symbol id="g6E719F786D7B1141CA8C4512E00A2E0D" overflow="visible"><path d="M 0 0m 0.69 7.14v -7.14h 1.57v 2.3l 0.9 0.91l 2.15 -3.21h 1.97l -3.06 4.32l 2.79 2.82h -1.96l -2.79 -2.96v 2.96h -1.57Z "/></symbol><symbol id="gF615D1769D4A065C3B81AFF62715CD4A" overflow="visible"><path d="M 0 0m 4.01 0l 2.37 7.14h -1.62l -1.61 -5.02h -0.02l -1.59 5.02h -1.61l 2.31 -7.14h 1.77Z "/></symbol><symbol id="g2A097BC7EEE91105D52B352EA84246F0" overflow="visible"><path d="M 0 0m 0.58 7.14v -7.14h 1.42v 7.14h -1.42Z "/></symbol><symbol id="g69D4CD72297CC97098F7E4B54BF2CCDC" overflow="visible"><path d="M 0 0m 5.39 0v 5.17h -1.42v -2.71q 0 -0.79 -0.26 -1.135q -0.26 -0.345 -0.84 -0.345q -0.51 0 -0.71 0.315q -0.2 0.315 -0.2 0.955v 2.92h -1.42v -3.18q 0 -0.48 0.085 -0.875q 0.085 -0.395 0.295 -0.67q 0.21 -0.275 0.575 -0.425q 0.365 -0.15 0.935 -0.15q 0.45 0 0.88 0.2q 0.43 0.2 0.7 0.65h 0.03v -0.72h 1.35Z "/></symbol><symbol id="g358648C530966537EABEBBEC18198CC8" overflow="visible"><path d="M 0 0m 0.702 6.426v -6.426h 0.855v 2.943h 3.384v -2.943h 0.855v 6.426h -0.855v -2.763h -3.384v 2.763h -0.855Z "/></symbol><symbol id="gC31F60C8C41E19EEB1D25990511789A" overflow="visible"><path d="M 0 0m 2.403 -0.621q -0.135 -0.342 -0.2655 -0.576q -0.1305 -0.234 -0.288 -0.3825q -0.1575 -0.1485 -0.351 -0.216q -0.1935 -0.0675 -0.4455 -0.0675q -0.135 0 -0.27 0.018q -0.135 0.018 -0.261 0.063v 0.702q 0.099 -0.045 0.2295 -0.0765q 0.1305 -0.0315 0.2205 -0.0315q 0.234 0 0.3915 0.1125q 0.1575 0.1125 0.2385 0.3195l 0.315 0.783l -1.845 4.626h 0.864l 1.359 -3.807h 0.018l 1.305 3.807h 0.81l -2.025 -5.274Z "/></symbol><symbol id="g4BF6675A1F6A6F6A675D8BE7B8863BAB" overflow="visible"><path d="M 0 0m 0.603 4.653v -6.426h 0.765v 2.394h 0.018q 0.126 -0.207 0.3105 -0.3465q 0.1845 -0.1395 0.3915 -0.2205q 0.207 -0.081 0.4185 -0.117q 0.2115 -0.036 0.3825 -0.036q 0.531 0 0.9315 0.189q 0.4005 0.189 0.666 0.5175q 0.2655 0.3285 0.396 0.7695q 0.1305 0.441 0.1305 0.936q 0 0.495 -0.135 0.936q -0.135 0.441 -0.4005 0.7785q -0.2655 0.3375 -0.666 0.5355q -0.4005 0.198 -0.9405 0.198q -0.486 0 -0.891 -0.1755q -0.405 -0.1755 -0.594 -0.5625h -0.018v 0.63h -0.765Z m 3.6 -2.286q 0 -0.342 -0.072 -0.666q -0.072 -0.324 -0.234 -0.576q -0.162 -0.252 -0.4275 -0.405q -0.2655 -0.153 -0.6615 -0.153q -0.396 0 -0.675 0.1485q -0.279 0.1485 -0.4545 0.3915q -0.1755 0.243 -0.2565 0.5625q -0.081 0.3195 -0.081 0.6615q 0 0.324 0.0765 0.639q 0.0765 0.315 0.2475 0.5625q 0.171 0.2475 0.441 0.4005q 0.27 0.153 0.657 0.153q 0.369 0 0.6435 -0.144q 0.2745 -0.144 0.45 -0.387q 0.1755 -0.243 0.261 -0.5535q 0.0855 -0.3105 0.0855 -0.6345Z "/></symbol><symbol id="gBD650B5058F0646EBF236D8F6940AC70" overflow="visible"><path d="M 0 0m 3.807 2.772h -2.673q 0.018 0.27 0.117 0.5085q 0.099 0.2385 0.27 0.4185q 0.171 0.18 0.4095 0.2835q 0.2385 0.1035 0.5355 0.1035q 0.288 0 0.5265 -0.1035q 0.2385 -0.1035 0.414 -0.279q 0.1755 -0.1755 0.279 -0.4185q 0.1035 -0.243 0.1215 -0.513Z m 0.738 -1.296h -0.756q -0.099 -0.459 -0.4095 -0.684q -0.3105 -0.225 -0.7965 -0.225q -0.378 0 -0.657 0.126q -0.279 0.126 -0.459 0.3375q -0.18 0.2115 -0.261 0.486q -0.081 0.2745 -0.072 0.5805h 3.483q 0.018 0.423 -0.0765 0.891q -0.0945 0.468 -0.342 0.864q -0.2475 0.396 -0.657 0.6525q -0.4095 0.2565 -1.0305 0.2565q -0.477 0 -0.8775 -0.18q -0.4005 -0.18 -0.693 -0.504q -0.2925 -0.324 -0.4545 -0.765q -0.162 -0.441 -0.162 -0.972q 0.018 -0.531 0.1575 -0.981q 0.1395 -0.45 0.4185 -0.774q 0.279 -0.324 0.6885 -0.504q 0.4095 -0.18 0.9675 -0.18q 0.792 0 1.314 0.396q 0.522 0.396 0.675 1.179Z "/></symbol><symbol id="g51AEC211C4B4ABC5D9D55D5612BCFCD6" overflow="visible"><path d="M 0 0m 0.549 4.653v -4.653h 0.765v 2.07q 0 0.45 0.09 0.7965q 0.09 0.3465 0.288 0.5895q 0.198 0.243 0.522 0.369q 0.324 0.126 0.783 0.126v 0.81q -0.621 0.018 -1.026 -0.252q -0.405 -0.27 -0.684 -0.837h -0.018v 0.981h -0.72Z "/></symbol><symbol id="g80102705FF5D893D49AAE39B792F523C" overflow="visible"><path d="M 0 0m 5.508 0.801l 0.225 -0.801h 0.54v 3.384h -2.817v -0.72h 2.052q 0.018 -0.441 -0.117 -0.8235q -0.135 -0.3825 -0.4005 -0.666q -0.2655 -0.2835 -0.6525 -0.4455q -0.387 -0.162 -0.891 -0.162q -0.54 0 -0.9495 0.2115q -0.4095 0.2115 -0.6885 0.567q -0.279 0.3555 -0.423 0.819q -0.144 0.4635 -0.144 0.9675q 0 0.513 0.126 1.0035q 0.126 0.4905 0.3915 0.873q 0.2655 0.3825 0.684 0.6165q 0.4185 0.234 1.0035 0.234q 0.36 0 0.6795 -0.0855q 0.3195 -0.0855 0.5715 -0.2565q 0.252 -0.171 0.423 -0.4365q 0.171 -0.2655 0.234 -0.6345h 0.855q -0.09 0.567 -0.3375 0.9675q -0.2475 0.4005 -0.612 0.6615q -0.3645 0.261 -0.828 0.3825q -0.4635 0.1215 -0.9855 0.1215q -0.765 0 -1.3365 -0.2835q -0.5715 -0.2835 -0.954 -0.7605q -0.3825 -0.477 -0.576 -1.1115q -0.1935 -0.6345 -0.1935 -1.3365q 0 -0.63 0.207 -1.215q 0.207 -0.585 0.603 -1.035q 0.396 -0.45 0.963 -0.7155q 0.567 -0.2655 1.287 -0.2655q 0.567 0 1.125 0.2205q 0.558 0.2205 0.936 0.7245Z "/></symbol><symbol id="g76AD9D48F7250D6C3EDAA0782F20ADD4" overflow="visible"><path d="M 0 0m 4.698 0.018q -0.198 -0.117 -0.549 -0.117q -0.297 0 -0.4725 0.1665q -0.1755 0.1665 -0.1755 0.5445q -0.315 -0.378 -0.7335 -0.5445q -0.4185 -0.1665 -0.9045 -0.1665q -0.315 0 -0.5985 0.072q -0.2835 0.072 -0.4905 0.225q -0.207 0.153 -0.3285 0.4005q -0.1215 0.2475 -0.1215 0.5985q 0 0.396 0.135 0.648q 0.135 0.252 0.3555 0.4095q 0.2205 0.1575 0.504 0.2385q 0.2835 0.081 0.5805 0.135q 0.315 0.063 0.5985 0.0945q 0.2835 0.0315 0.4995 0.09q 0.216 0.0585 0.342 0.171q 0.126 0.1125 0.126 0.3285q 0 0.252 -0.0945 0.405q -0.0945 0.153 -0.243 0.234q -0.1485 0.081 -0.333 0.108q -0.1845 0.027 -0.3645 0.027q -0.486 0 -0.81 -0.1845q -0.324 -0.1845 -0.351 -0.6975h -0.765q 0.018 0.432 0.18 0.729q 0.162 0.297 0.432 0.4815q 0.27 0.1845 0.6165 0.2655q 0.3465 0.081 0.7425 0.081q 0.315 0 0.6255 -0.045q 0.3105 -0.045 0.5625 -0.1845q 0.252 -0.1395 0.405 -0.3915q 0.153 -0.252 0.153 -0.657v -2.394q 0 -0.27 0.0315 -0.396q 0.0315 -0.126 0.2115 -0.126q 0.099 0 0.234 0.045v -0.594Z m -1.242 2.385q -0.144 -0.108 -0.378 -0.1575q -0.234 -0.0495 -0.4905 -0.081q -0.2565 -0.0315 -0.5175 -0.072q -0.261 -0.0405 -0.468 -0.1305q -0.207 -0.09 -0.3375 -0.2565q -0.1305 -0.1665 -0.1305 -0.4545q 0 -0.189 0.0765 -0.3195q 0.0765 -0.1305 0.198 -0.2115q 0.1215 -0.081 0.2835 -0.117q 0.162 -0.036 0.342 -0.036q 0.378 0 0.648 0.1035q 0.27 0.1035 0.441 0.261q 0.171 0.1575 0.252 0.342q 0.081 0.1845 0.081 0.3465v 0.783Z "/></symbol><symbol id="g9F69CFB5E12EEFE787A8731335FF6501" overflow="visible"><path d="M 0 0m 0.576 6.426v -6.426h 0.765v 2.628q 0 0.315 0.0855 0.5805q 0.0855 0.2655 0.2565 0.4635q 0.171 0.198 0.4275 0.306q 0.2565 0.108 0.6075 0.108q 0.441 0 0.693 -0.252q 0.252 -0.252 0.252 -0.684v -3.15h 0.765v 3.06q 0 0.378 -0.0765 0.6885q -0.0765 0.3105 -0.2655 0.5355q -0.189 0.225 -0.495 0.351q -0.306 0.126 -0.765 0.126q -0.207 0 -0.4275 -0.045q -0.2205 -0.045 -0.423 -0.1395q -0.2025 -0.0945 -0.3645 -0.243q -0.162 -0.1485 -0.252 -0.3645h -0.018v 2.457h -0.765Z "/></symbol><symbol id="g998BE4B087A0C386337E1CB97229E76" overflow="visible"><path d="M 0 0m 4.419 4.545h 0.81q -0.018 0.531 -0.2025 0.9135q -0.1845 0.3825 -0.504 0.6345q -0.3195 0.252 -0.7425 0.369q -0.423 0.117 -0.918 0.117q -0.441 0 -0.8595 -0.1125q -0.4185 -0.1125 -0.747 -0.342q -0.3285 -0.2295 -0.5265 -0.585q -0.198 -0.3555 -0.198 -0.8415q 0 -0.441 0.1755 -0.7335q 0.1755 -0.2925 0.468 -0.477q 0.2925 -0.1845 0.6615 -0.297q 0.369 -0.1125 0.7515 -0.198q 0.3825 -0.0855 0.7515 -0.1665q 0.369 -0.081 0.6615 -0.2115q 0.2925 -0.1305 0.468 -0.3375q 0.1755 -0.207 0.1755 -0.54q 0 -0.351 -0.144 -0.576q -0.144 -0.225 -0.378 -0.3555q -0.234 -0.1305 -0.5265 -0.1845q -0.2925 -0.054 -0.5805 -0.054q -0.36 0 -0.702 0.09q -0.342 0.09 -0.5985 0.279q -0.2565 0.189 -0.414 0.4815q -0.1575 0.2925 -0.1575 0.6975h -0.81q 0 -0.585 0.2115 -1.0125q 0.2115 -0.4275 0.576 -0.702q 0.3645 -0.2745 0.846 -0.4095q 0.4815 -0.135 1.0215 -0.135q 0.441 0 0.8865 0.1035q 0.4455 0.1035 0.8055 0.333q 0.36 0.2295 0.5895 0.594q 0.2295 0.3645 0.2295 0.8775q 0 0.477 -0.1755 0.792q -0.1755 0.315 -0.468 0.522q -0.2925 0.207 -0.6615 0.3285q -0.369 0.1215 -0.7515 0.2115q -0.3825 0.09 -0.7515 0.1665q -0.369 0.0765 -0.6615 0.1935q -0.2925 0.117 -0.468 0.3015q -0.1755 0.1845 -0.1755 0.4815q 0 0.315 0.1215 0.5265q 0.1215 0.2115 0.324 0.3375q 0.2025 0.126 0.4635 0.18q 0.261 0.054 0.531 0.054q 0.666 0 1.0935 -0.3105q 0.4275 -0.3105 0.4995 -1.0035Z "/></symbol><symbol id="gF7F3FC75D830406F7324CCD66FBDC70F" overflow="visible"><path d="M 0 0m 1.386 5.49v 0.936h -0.765v -0.936h 0.765Z m -0.765 -0.837v -4.653h 0.765v 4.653h -0.765Z "/></symbol><symbol id="gA3FF480C19AEB1E21DC8A39262BFE6C2" overflow="visible"><path d="M 0 0m 0.576 4.653v -4.653h 0.765v 2.898q 0 0.135 0.0675 0.3375q 0.0675 0.2025 0.216 0.3915q 0.1485 0.189 0.387 0.324q 0.2385 0.135 0.5715 0.135q 0.261 0 0.4275 -0.0765q 0.1665 -0.0765 0.2655 -0.216q 0.099 -0.1395 0.1395 -0.3285q 0.0405 -0.189 0.0405 -0.414v -3.051h 0.765v 2.898q 0 0.54 0.324 0.864q 0.324 0.324 0.891 0.324q 0.279 0 0.4545 -0.081q 0.1755 -0.081 0.2745 -0.2205q 0.099 -0.1395 0.135 -0.3285q 0.036 -0.189 0.036 -0.405v -3.051h 0.765v 3.411q 0 0.36 -0.1125 0.6165q -0.1125 0.2565 -0.315 0.4185q -0.2025 0.162 -0.486 0.2385q -0.2835 0.0765 -0.6345 0.0765q -0.459 0 -0.8415 -0.207q -0.3825 -0.207 -0.6165 -0.585q -0.144 0.432 -0.495 0.612q -0.351 0.18 -0.783 0.18q -0.981 0 -1.503 -0.792h -0.018v 0.684h -0.72Z "/></symbol><symbol id="gD2DA7E685FECD9D284DE6F57724955B7" overflow="visible"><path d="M 0 0m 0.621 6.426v -6.426h 0.765v 6.426h -0.765Z "/></symbol><symbol id="g8FFCFCF85AD85C5A925A226166F30EA1" overflow="visible"><path d="M 0 0m 1.557 3.348v 2.358h 1.674q 0.729 0 1.0665 -0.3015q 0.3375 -0.3015 0.3375 -0.8775q 0 -0.576 -0.3375 -0.882q -0.3375 -0.306 -1.0665 -0.297h -1.674Z m -0.855 3.078v -6.426h 0.855v 2.628h 1.962q 0.972 -0.009 1.4715 0.495q 0.4995 0.504 0.4995 1.404q 0 0.9 -0.4995 1.3995q -0.4995 0.4995 -1.4715 0.4995h -2.817Z "/></symbol><symbol id="g526F8306ACF9617F153930C15CD2A475" overflow="visible"><path d="M 0 0m 0.576 4.653v -4.653h 0.765v 2.628q 0 0.315 0.0855 0.5805q 0.0855 0.2655 0.2565 0.4635q 0.171 0.198 0.4275 0.306q 0.2565 0.108 0.6075 0.108q 0.441 0 0.693 -0.252q 0.252 -0.252 0.252 -0.684v -3.15h 0.765v 3.06q 0 0.378 -0.0765 0.6885q -0.0765 0.3105 -0.2655 0.5355q -0.189 0.225 -0.495 0.351q -0.306 0.126 -0.765 0.126q -1.035 0 -1.512 -0.846h -0.018v 0.738h -0.72Z "/></symbol><symbol id="g2FED6C3E674805F999833164ADE443B8" overflow="visible"><path d="M 0 0m 1.557 3.663v 2.043h 1.71q 0.279 0 0.5265 -0.0315q 0.2475 -0.0315 0.4365 -0.1395q 0.189 -0.108 0.297 -0.306q 0.108 -0.198 0.108 -0.54q 0 -0.513 -0.3195 -0.7695q -0.3195 -0.2565 -1.0485 -0.2565h -1.71Z m -0.855 2.763v -6.426h 3.105q 0.477 0 0.8415 0.1575q 0.3645 0.1575 0.612 0.414q 0.2475 0.2565 0.3735 0.5895q 0.126 0.333 0.126 0.684q 0 0.594 -0.315 1.008q -0.315 0.414 -0.909 0.54v 0.018q 0.459 0.18 0.7065 0.5535q 0.2475 0.3735 0.2475 0.8865q 0 0.486 -0.2205 0.819q -0.2205 0.333 -0.5355 0.522q -0.144 0.09 -0.3465 0.135q -0.2025 0.045 -0.4365 0.0675q -0.234 0.0225 -0.4725 0.027q -0.2385 0.0045 -0.4455 0.0045h -2.331Z m 0.855 -5.706v 2.223h 1.953q 0.27 0 0.522 -0.0495q 0.252 -0.0495 0.4455 -0.171q 0.1935 -0.1215 0.3105 -0.3285q 0.117 -0.207 0.117 -0.522q 0 -0.54 -0.3195 -0.846q -0.3195 -0.306 -0.8865 -0.306h -2.142Z "/></symbol><symbol id="g68A669F51D3D2BE053B24A40387EF06E" overflow="visible"><path d="M 0 0m 1.638 4.653v 1.395h -0.765v -1.395h -0.792v -0.675h 0.792v -2.961q 0 -0.324 0.063 -0.522q 0.063 -0.198 0.1935 -0.306q 0.1305 -0.108 0.342 -0.1485q 0.2115 -0.0405 0.5085 -0.0405h 0.585v 0.675h -0.351q -0.18 0 -0.2925 0.0135q -0.1125 0.0135 -0.1755 0.0585q -0.063 0.045 -0.0855 0.126q -0.0225 0.081 -0.0225 0.216v 2.889h 0.927v 0.675h -0.927Z "/></symbol><symbol id="gCF81F3250CEF5E439BD9A17D4140A583" overflow="visible"><path d="M 0 0m 5.832 2.322v 4.104h -0.855v -4.104q 0 -0.864 -0.4275 -1.3095q -0.4275 -0.4455 -1.2465 -0.4455q -0.864 0 -1.323 0.4455q -0.459 0.4455 -0.459 1.3095v 4.104h -0.855v -4.104q 0 -1.287 0.6975 -1.8765q 0.6975 -0.5895 1.9395 -0.5895q 1.215 0 1.872 0.6165q 0.657 0.6165 0.657 1.8495Z "/></symbol><symbol id="gFF05D2CF6EC42551B1D130F991FB542F" overflow="visible"><path d="M 0 0m 1.557 0.72v 4.986h 1.44q 0.594 0 0.999 -0.1665q 0.405 -0.1665 0.6615 -0.486q 0.2565 -0.3195 0.369 -0.774q 0.1125 -0.4545 0.1125 -1.0305q 0 -0.594 -0.1215 -1.0125q -0.1215 -0.4185 -0.3105 -0.6975q -0.189 -0.279 -0.4275 -0.441q -0.2385 -0.162 -0.4815 -0.2475q -0.243 -0.0855 -0.459 -0.108q -0.216 -0.0225 -0.36 -0.0225h -1.422Z m -0.855 5.706v -6.426h 2.205q 0.801 0 1.386 0.225q 0.585 0.225 0.963 0.6525q 0.378 0.4275 0.558 1.053q 0.18 0.6255 0.18 1.4355q 0 1.548 -0.801 2.304q -0.801 0.756 -2.286 0.756h -2.205Z "/></symbol><symbol id="g3A4677DDBC586D308BB969EA3D409F2B" overflow="visible"><path d="M 0 0m 1.044 1.467h -0.765q 0.018 -0.432 0.18 -0.7335q 0.162 -0.3015 0.432 -0.486q 0.27 -0.1845 0.621 -0.2655q 0.351 -0.081 0.738 -0.081q 0.351 0 0.7065 0.0675q 0.3555 0.0675 0.639 0.2385q 0.2835 0.171 0.459 0.45q 0.1755 0.279 0.1755 0.702q 0 0.333 -0.1305 0.558q -0.1305 0.225 -0.342 0.3735q -0.2115 0.1485 -0.486 0.2385q -0.2745 0.09 -0.5625 0.153q -0.27 0.063 -0.54 0.1215q -0.27 0.0585 -0.486 0.144q -0.216 0.0855 -0.3555 0.216q -0.1395 0.1305 -0.1395 0.3285q 0 0.18 0.09 0.2925q 0.09 0.1125 0.234 0.18q 0.144 0.0675 0.3195 0.0945q 0.1755 0.027 0.3465 0.027q 0.189 0 0.3735 -0.0405q 0.1845 -0.0405 0.3375 -0.1305q 0.153 -0.09 0.252 -0.2385q 0.099 -0.1485 0.117 -0.3735h 0.765q -0.027 0.423 -0.18 0.7065q -0.153 0.2835 -0.4095 0.45q -0.2565 0.1665 -0.5895 0.234q -0.333 0.0675 -0.729 0.0675q -0.306 0 -0.6165 -0.0765q -0.3105 -0.0765 -0.558 -0.234q -0.2475 -0.1575 -0.405 -0.4095q -0.1575 -0.252 -0.1575 -0.603q 0 -0.45 0.225 -0.702q 0.225 -0.252 0.5625 -0.3915q 0.3375 -0.1395 0.7335 -0.216q 0.396 -0.0765 0.7335 -0.171q 0.3375 -0.0945 0.5625 -0.2475q 0.225 -0.153 0.225 -0.45q 0 -0.216 -0.108 -0.3555q -0.108 -0.1395 -0.2745 -0.2115q -0.1665 -0.072 -0.3645 -0.099q -0.198 -0.027 -0.378 -0.027q -0.234 0 -0.4545 0.045q -0.2205 0.045 -0.396 0.1485q -0.1755 0.1035 -0.2835 0.279q -0.108 0.1755 -0.117 0.4275Z "/></symbol><symbol id="g8211C3A926ABA11A1787DD12A5629A11" overflow="visible"><path d="M 0 0m 0.621 6.426v -6.426h 0.765v 1.764l 0.72 0.666l 1.593 -2.43h 0.972l -1.98 2.961l 1.845 1.692h -1.026l -2.124 -2.034v 3.807h -0.765Z "/></symbol><symbol id="g643259D216747AA812B6855D4BA0DE42" overflow="visible"><path d="M 0 0m 0.702 6.426v -6.426h 0.855v 2.25l 1.071 0.999l 2.322 -3.249h 1.08l -2.817 3.834l 2.709 2.592h -1.107l -3.258 -3.204v 3.204h -0.855Z "/></symbol><symbol id="gDF33ECC6A9229D1279F3C3F8743962FF" overflow="visible"><path d="M 0 0m 4.59 0.396v 4.257h -0.72v -0.666h -0.009q -0.207 0.387 -0.576 0.5805q -0.369 0.1935 -0.81 0.1935q -0.603 0 -1.017 -0.2295q -0.414 -0.2295 -0.666 -0.585q -0.252 -0.3555 -0.36 -0.792q -0.108 -0.4365 -0.108 -0.8505q 0 -0.477 0.1305 -0.9045q 0.1305 -0.4275 0.3915 -0.747q 0.261 -0.3195 0.648 -0.5085q 0.387 -0.189 0.909 -0.189q 0.45 0 0.8505 0.2025q 0.4005 0.2025 0.5985 0.6345h 0.018v -0.306q 0 -0.387 -0.0765 -0.711q -0.0765 -0.324 -0.2475 -0.5535q -0.171 -0.2295 -0.432 -0.36q -0.261 -0.1305 -0.639 -0.1305q -0.189 0 -0.396 0.0405q -0.207 0.0405 -0.3825 0.1305q -0.1755 0.09 -0.297 0.234q -0.1215 0.144 -0.1305 0.351h -0.765q 0.018 -0.378 0.198 -0.639q 0.18 -0.261 0.4545 -0.423q 0.2745 -0.162 0.612 -0.234q 0.3375 -0.072 0.6615 -0.072q 1.116 0 1.638 0.567q 0.522 0.567 0.522 1.71Z m -2.142 0.225q -0.378 0 -0.63 0.1575q -0.252 0.1575 -0.405 0.414q -0.153 0.2565 -0.216 0.5715q -0.063 0.315 -0.063 0.63q 0 0.333 0.0765 0.639q 0.0765 0.306 0.243 0.54q 0.1665 0.234 0.4275 0.3735q 0.261 0.1395 0.63 0.1395q 0.36 0 0.612 -0.144q 0.252 -0.144 0.4095 -0.3825q 0.1575 -0.2385 0.2295 -0.5355q 0.072 -0.297 0.072 -0.603q 0 -0.324 -0.0765 -0.648q -0.0765 -0.324 -0.2385 -0.5805q -0.162 -0.2565 -0.4275 -0.414q -0.2655 -0.1575 -0.6435 -0.1575Z "/></symbol><symbol id="gF6ECA5CBE62F1294F74D902B5E4CD26E" overflow="visible"><path d="M 0 0m 4.428 0v 4.653h -0.765v -2.628q 0 -0.315 -0.0855 -0.5805q -0.0855 -0.2655 -0.2565 -0.4635q -0.171 -0.198 -0.4275 -0.306q -0.2565 -0.108 -0.6075 -0.108q -0.441 0 -0.693 0.252q -0.252 0.252 -0.252 0.684v 3.15h -0.765v -3.06q 0 -0.378 0.0765 -0.6885q 0.0765 -0.3105 0.2655 -0.5355q 0.189 -0.225 0.495 -0.3465q 0.306 -0.1215 0.765 -0.1215q 0.513 0 0.891 0.2025q 0.378 0.2025 0.621 0.6345h 0.018v -0.738h 0.72Z "/></symbol><symbol id="g4924820D7208E420C95C1F6ADAAF48E" overflow="visible"><path d="M 0 0m 0.603 6.426v -6.426h 0.765v 0.621h 0.018q 0.126 -0.207 0.3105 -0.3465q 0.1845 -0.1395 0.3915 -0.2205q 0.207 -0.081 0.4185 -0.117q 0.2115 -0.036 0.3825 -0.036q 0.531 0 0.9315 0.189q 0.4005 0.189 0.666 0.5175q 0.2655 0.3285 0.396 0.7695q 0.1305 0.441 0.1305 0.936q 0 0.495 -0.135 0.936q -0.135 0.441 -0.4005 0.7785q -0.2655 0.3375 -0.666 0.5355q -0.4005 0.198 -0.9405 0.198q -0.486 0 -0.891 -0.1755q -0.405 -0.1755 -0.594 -0.5625h -0.018v 2.403h -0.765Z m 3.6 -4.059q 0 -0.342 -0.072 -0.666q -0.072 -0.324 -0.234 -0.576q -0.162 -0.252 -0.4275 -0.405q -0.2655 -0.153 -0.6615 -0.153q -0.396 0 -0.675 0.1485q -0.279 0.1485 -0.4545 0.3915q -0.1755 0.243 -0.2565 0.5625q -0.081 0.3195 -0.081 0.6615q 0 0.324 0.0765 0.639q 0.0765 0.315 0.2475 0.5625q 0.171 0.2475 0.441 0.4005q 0.27 0.153 0.657 0.153q 0.369 0 0.6435 -0.144q 0.2745 -0.144 0.45 -0.387q 0.1755 -0.243 0.261 -0.5535q 0.0855 -0.3105 0.0855 -0.6345Z "/></symbol><symbol id="g17E1EDF03D20F92C5D9A1C646E2F3F53" overflow="visible"><path d="M 0 0m 2.16 5.706v -5.706h 0.855v 5.706h 2.142v 0.72h -5.139v -0.72h 2.142Z "/></symbol><symbol id="g706DBDF2AFA18A24933A6A647147C19C" overflow="visible"><path d="M 0 0m 0.891 3.978v -3.978h 0.765v 3.978h 0.9v 0.675h -0.9v 0.648q 0 0.306 0.153 0.414q 0.153 0.108 0.432 0.108q 0.099 0 0.216 -0.0135q 0.117 -0.0135 0.216 -0.0495v 0.666q -0.108 0.036 -0.2475 0.054q -0.1395 0.018 -0.2475 0.018q -0.63 0 -0.9585 -0.2925q -0.3285 -0.2925 -0.3285 -0.8595v -0.693h -0.783v -0.675h 0.783Z "/></symbol><symbol id="g28654F3BE91BBF146A05420E9B69B910" overflow="visible"><path d="M 0 0m 3.726 4.752h 0.765q -0.072 0.792 -0.54 1.2105q -0.468 0.4185 -1.26 0.4185q -0.684 0 -1.134 -0.288q -0.45 -0.288 -0.72 -0.765q -0.27 -0.477 -0.3825 -1.0935q -0.1125 -0.6165 -0.1125 -1.2735q 0 -0.504 0.0765 -1.044q 0.0765 -0.54 0.3105 -0.99q 0.234 -0.45 0.666 -0.738q 0.432 -0.288 1.143 -0.288q 0.603 0 1.0125 0.2025q 0.4095 0.2025 0.657 0.513q 0.2475 0.3105 0.3555 0.6885q 0.108 0.378 0.108 0.729q 0 0.441 -0.135 0.819q -0.135 0.378 -0.3825 0.657q -0.2475 0.279 -0.612 0.4365q -0.3645 0.1575 -0.8235 0.1575q -0.522 0 -0.9225 -0.198q -0.4005 -0.198 -0.6705 -0.639l -0.018 0.018q 0.009 0.369 0.072 0.792q 0.063 0.423 0.2295 0.7875q 0.1665 0.3645 0.4635 0.603q 0.297 0.2385 0.783 0.2385q 0.459 0 0.738 -0.261q 0.279 -0.261 0.333 -0.693Z m -1.152 -1.323q 0.324 0 0.567 -0.117q 0.243 -0.117 0.405 -0.3105q 0.162 -0.1935 0.2385 -0.459q 0.0765 -0.2655 0.0765 -0.5625q 0 -0.279 -0.0855 -0.5355q -0.0855 -0.2565 -0.2475 -0.4545q -0.162 -0.198 -0.4005 -0.3105q -0.2385 -0.1125 -0.5535 -0.1125q -0.315 0 -0.5625 0.1125q -0.2475 0.1125 -0.414 0.3015q -0.1665 0.189 -0.2565 0.45q -0.09 0.261 -0.09 0.558q 0 0.297 0.0855 0.5625q 0.0855 0.2655 0.2565 0.459q 0.171 0.1935 0.414 0.306q 0.243 0.1125 0.567 0.1125Z "/></symbol><symbol id="gB6C1C9281F1479B90715012C930C0F89" overflow="visible"><path d="M 0 0m 3.051 2.169h -2.142l 2.124 3.123h 0.018v -3.123Z m 0.72 0v 4.212h -0.612l -2.907 -4.149v -0.738h 2.799v -1.494h 0.72v 1.494h 0.864v 0.675h -0.864Z "/></symbol><symbol id="g4BF2C94D2014A0FD17E6C8283E7BF557" overflow="visible"><path d="M 0 0m 1.197 3.213q 0 0.486 0.126 0.9585q 0.126 0.4725 0.396 0.8505q 0.27 0.378 0.693 0.6075q 0.423 0.2295 1.008 0.2295q 0.585 0 1.008 -0.2295q 0.423 -0.2295 0.693 -0.6075q 0.27 -0.378 0.396 -0.8505q 0.126 -0.4725 0.126 -0.9585q 0 -0.486 -0.126 -0.9585q -0.126 -0.4725 -0.396 -0.8505q -0.27 -0.378 -0.693 -0.6075q -0.423 -0.2295 -1.008 -0.2295q -0.585 0 -1.008 0.2295q -0.423 0.2295 -0.693 0.6075q -0.27 0.378 -0.396 0.8505q -0.126 0.4725 -0.126 0.9585Z m -0.855 0q 0 -0.657 0.1935 -1.2645q 0.1935 -0.6075 0.5805 -1.0755q 0.387 -0.468 0.963 -0.7425q 0.576 -0.2745 1.341 -0.2745q 0.765 0 1.341 0.2745q 0.576 0.2745 0.963 0.7425q 0.387 0.468 0.5805 1.0755q 0.1935 0.6075 0.1935 1.2645q 0 0.657 -0.1935 1.2645q -0.1935 0.6075 -0.5805 1.0755q -0.387 0.468 -0.963 0.747q -0.576 0.279 -1.341 0.279q -0.765 0 -1.341 -0.279q -0.576 -0.279 -0.963 -0.747q -0.387 -0.468 -0.5805 -1.0755q -0.1935 -0.6075 -0.1935 -1.2645Z "/></symbol><symbol id="gE7B19A31542CA9616E8E9C203DE80E3B" overflow="visible"><path d="M 0 0m 0.693 6.426v -6.426h 0.81v 5.157h 0.018l 3.357 -5.157h 0.936v 6.426h -0.81v -5.211h -0.018l -3.384 5.211h -0.909Z "/></symbol><symbol id="g79CC640AF8FDC181F546B16B9C037F2D" overflow="visible"><path d="M 0 0m 3.204 0v 6.381h -0.585q -0.063 -0.36 -0.234 -0.594q -0.171 -0.234 -0.4185 -0.369q -0.2475 -0.135 -0.5535 -0.1845q -0.306 -0.0495 -0.63 -0.0495v -0.612h 1.656v -4.572h 0.765Z "/></symbol><symbol id="g144781C0177D7CE205CAE9D9D2ABC7A1" overflow="visible"><path d="M 0 0m 0.396 4.122h 0.765q -0.009 0.288 0.0585 0.5715q 0.0675 0.2835 0.2205 0.5085q 0.153 0.225 0.3915 0.3645q 0.2385 0.1395 0.5715 0.1395q 0.252 0 0.477 -0.081q 0.225 -0.081 0.3915 -0.234q 0.1665 -0.153 0.2655 -0.3645q 0.099 -0.2115 0.099 -0.4725q 0 -0.333 -0.1035 -0.585q -0.1035 -0.252 -0.306 -0.468q -0.2025 -0.216 -0.5085 -0.4275q -0.306 -0.2115 -0.711 -0.4635q -0.333 -0.198 -0.639 -0.423q -0.306 -0.225 -0.549 -0.522q -0.243 -0.297 -0.4005 -0.6975q -0.1575 -0.4005 -0.2025 -0.9675h 4.167v 0.675h -3.276q 0.054 0.297 0.2295 0.5265q 0.1755 0.2295 0.423 0.4275q 0.2475 0.198 0.5445 0.3735q 0.297 0.1755 0.594 0.3555q 0.297 0.189 0.576 0.396q 0.279 0.207 0.495 0.4635q 0.216 0.2565 0.3465 0.5805q 0.1305 0.324 0.1305 0.747q 0 0.45 -0.1575 0.792q -0.1575 0.342 -0.4275 0.5715q -0.27 0.2295 -0.6345 0.351q -0.3645 0.1215 -0.7785 0.1215q -0.504 0 -0.9 -0.171q -0.396 -0.171 -0.6615 -0.4725q -0.2655 -0.3015 -0.3915 -0.7155q -0.126 -0.414 -0.099 -0.9Z "/></symbol><symbol id="gBCC2E373F8E1DF1573A99001CD4735AE" overflow="visible"><path d="M 0 0m 1.962 3.645v -0.648q 0.216 0.027 0.459 0.027q 0.288 0 0.5355 -0.0765q 0.2475 -0.0765 0.4275 -0.234q 0.18 -0.1575 0.288 -0.387q 0.108 -0.2295 0.108 -0.5265q 0 -0.288 -0.1125 -0.5175q -0.1125 -0.2295 -0.3015 -0.387q -0.189 -0.1575 -0.441 -0.243q -0.252 -0.0855 -0.531 -0.0855q -0.657 0 -0.999 0.3915q -0.342 0.3915 -0.36 1.0125h -0.765q -0.009 -0.495 0.1395 -0.882q 0.1485 -0.387 0.4275 -0.6525q 0.279 -0.2655 0.675 -0.4005q 0.396 -0.135 0.882 -0.135q 0.45 0 0.8505 0.1215q 0.4005 0.1215 0.6975 0.3645q 0.297 0.243 0.4725 0.6075q 0.1755 0.3645 0.1755 0.8415q 0 0.576 -0.2835 0.999q -0.2835 0.423 -0.8685 0.549v 0.018q 0.378 0.171 0.63 0.504q 0.252 0.333 0.252 0.765q 0 0.441 -0.1485 0.765q -0.1485 0.324 -0.4095 0.531q -0.261 0.207 -0.6165 0.3105q -0.3555 0.1035 -0.7695 0.1035q -0.477 0 -0.8415 -0.153q -0.3645 -0.153 -0.6075 -0.423q -0.243 -0.27 -0.3735 -0.648q -0.1305 -0.378 -0.1485 -0.837h 0.765q 0 0.279 0.072 0.531q 0.072 0.252 0.2205 0.441q 0.1485 0.189 0.378 0.3015q 0.2295 0.1125 0.5355 0.1125q 0.486 0 0.81 -0.2565q 0.324 -0.2565 0.324 -0.7695q 0 -0.252 -0.099 -0.45q -0.099 -0.198 -0.2655 -0.3285q -0.1665 -0.1305 -0.387 -0.198q -0.2205 -0.0675 -0.4635 -0.0675h -0.162q -0.045 0 -0.09 0q -0.036 0 -0.081 0.009Z "/></symbol><symbol id="gF8E599750D79A27F88B7064C5092ABD6" overflow="visible"><path d="M 0 0m 4.23 5.598v 0.675h -3.15l -0.594 -3.312l 0.657 -0.036q 0.225 0.27 0.5175 0.4365q 0.2925 0.1665 0.6705 0.1665q 0.324 0 0.5895 -0.108q 0.2655 -0.108 0.4545 -0.3015q 0.189 -0.1935 0.2925 -0.459q 0.1035 -0.2655 0.1035 -0.5805q 0 -0.378 -0.108 -0.6615q -0.108 -0.2835 -0.2925 -0.4725q -0.1845 -0.189 -0.432 -0.2835q -0.2475 -0.0945 -0.5175 -0.0945q -0.288 0 -0.5265 0.0855q -0.2385 0.0855 -0.414 0.243q -0.1755 0.1575 -0.279 0.369q -0.1035 0.2115 -0.1215 0.4545h -0.765q 0.009 -0.432 0.171 -0.774q 0.162 -0.342 0.441 -0.5715q 0.279 -0.2295 0.6435 -0.351q 0.3645 -0.1215 0.7785 -0.1215q 0.558 0 0.9765 0.1755q 0.4185 0.1755 0.6975 0.4725q 0.279 0.297 0.4185 0.6795q 0.1395 0.3825 0.1395 0.7875q 0 0.549 -0.162 0.9585q -0.162 0.4095 -0.441 0.684q -0.279 0.2745 -0.657 0.4095q -0.378 0.135 -0.801 0.135q -0.324 0 -0.6525 -0.1125q -0.3285 -0.1125 -0.5355 -0.3465l -0.018 0.018l 0.342 1.836h 2.574Z "/></symbol><symbol id="g81DFD15D696831D3AEDE372C6840E29B" overflow="visible"><path d="M 0 0m 4.64 3.992h 0.76q -0.064 0.456 -0.272 0.804q -0.208 0.348 -0.52 0.58q -0.312 0.232 -0.712 0.352q -0.4 0.12 -0.848 0.12q -0.656 0 -1.164 -0.236q -0.508 -0.236 -0.848 -0.644q -0.34 -0.408 -0.516 -0.956q -0.176 -0.548 -0.176 -1.172q 0 -0.624 0.164 -1.168q 0.164 -0.544 0.492 -0.944q 0.328 -0.4 0.824 -0.628q 0.496 -0.228 1.16 -0.228q 1.096 0 1.728 0.6q 0.632 0.6 0.744 1.68h -0.76q -0.024 -0.352 -0.144 -0.656q -0.12 -0.304 -0.332 -0.524q -0.212 -0.22 -0.504 -0.344q -0.292 -0.124 -0.668 -0.124q -0.512 0 -0.88 0.192q -0.368 0.192 -0.604 0.516q -0.236 0.324 -0.348 0.76q -0.112 0.436 -0.112 0.924q 0 0.448 0.112 0.864q 0.112 0.416 0.348 0.74q 0.236 0.324 0.6 0.516q 0.364 0.192 0.876 0.192q 0.6 0 1.036 -0.304q 0.436 -0.304 0.564 -0.912Z "/></symbol><symbol id="gC76F11DAD52FAC92E5F6681E1F3A8E24" overflow="visible"><path d="M 0 0m 1.008 2.064q 0 0.376 0.1 0.668q 0.1 0.292 0.276 0.492q 0.176 0.2 0.412 0.304q 0.236 0.104 0.5 0.104q 0.264 0 0.5 -0.104q 0.236 -0.104 0.412 -0.304q 0.176 -0.2 0.276 -0.492q 0.1 -0.292 0.1 -0.668q 0 -0.376 -0.1 -0.668q -0.1 -0.292 -0.276 -0.488q -0.176 -0.196 -0.412 -0.3q -0.236 -0.104 -0.5 -0.104q -0.264 0 -0.5 0.104q -0.236 0.104 -0.412 0.3q -0.176 0.196 -0.276 0.488q -0.1 0.292 -0.1 0.668Z m -0.72 0q 0 -0.456 0.128 -0.848q 0.128 -0.392 0.384 -0.684q 0.256 -0.292 0.632 -0.456q 0.376 -0.164 0.864 -0.164q 0.496 0 0.868 0.164q 0.372 0.164 0.628 0.456q 0.256 0.292 0.384 0.684q 0.128 0.392 0.128 0.848q 0 0.456 -0.128 0.852q -0.128 0.396 -0.384 0.688q -0.256 0.292 -0.628 0.46q -0.372 0.168 -0.868 0.168q -0.488 0 -0.864 -0.168q -0.376 -0.168 -0.632 -0.46q -0.256 -0.292 -0.384 -0.688q -0.128 -0.396 -0.128 -0.852Z "/></symbol><symbol id="gFC762F034065CB92308F77DA50904636" overflow="visible"><path d="M 0 0m 0.512 4.136v -4.136h 0.68v 2.336q 0 0.28 0.076 0.516q 0.076 0.236 0.228 0.412q 0.152 0.176 0.38 0.272q 0.228 0.096 0.54 0.096q 0.392 0 0.616 -0.224q 0.224 -0.224 0.224 -0.608v -2.8h 0.68v 2.72q 0 0.336 -0.068 0.612q -0.068 0.276 -0.236 0.476q -0.168 0.2 -0.44 0.312q -0.272 0.112 -0.68 0.112q -0.92 0 -1.344 -0.752h -0.016v 0.656h -0.64Z "/></symbol><symbol id="g9524DB2AB7AD3B578280EC160D005BAC" overflow="visible"><path d="M 0 0m 3.32 2.808h 0.704q -0.04 0.368 -0.192 0.636q -0.152 0.268 -0.388 0.444q -0.236 0.176 -0.544 0.26q -0.308 0.084 -0.66 0.084q -0.488 0 -0.856 -0.172q -0.368 -0.172 -0.612 -0.472q -0.244 -0.3 -0.364 -0.704q -0.12 -0.404 -0.12 -0.868q 0 -0.464 0.124 -0.852q 0.124 -0.388 0.368 -0.668q 0.244 -0.28 0.608 -0.432q 0.364 -0.152 0.836 -0.152q 0.792 0 1.252 0.416q 0.46 0.416 0.572 1.184h -0.696q -0.064 -0.48 -0.348 -0.744q -0.284 -0.264 -0.788 -0.264q -0.32 0 -0.552 0.128q -0.232 0.128 -0.376 0.34q -0.144 0.212 -0.212 0.484q -0.068 0.272 -0.068 0.56q 0 0.312 0.064 0.604q 0.064 0.292 0.212 0.516q 0.148 0.224 0.396 0.36q 0.248 0.136 0.616 0.136q 0.432 0 0.688 -0.216q 0.256 -0.216 0.336 -0.608Z "/></symbol><symbol id="gDE0960E94F350358A27A95EE3692B6C6" overflow="visible"><path d="M 0 0m 0.488 4.136v -4.136h 0.68v 1.84q 0 0.4 0.08 0.708q 0.08 0.308 0.256 0.524q 0.176 0.216 0.464 0.328q 0.288 0.112 0.696 0.112v 0.72q -0.552 0.016 -0.912 -0.224q -0.36 -0.24 -0.608 -0.744h -0.016v 0.872h -0.64Z "/></symbol><symbol id="g6B217B44DBEC65D521E4D6C450891318" overflow="visible"><path d="M 0 0m 3.384 2.464h -2.376q 0.016 0.24 0.104 0.452q 0.088 0.212 0.24 0.372q 0.152 0.16 0.364 0.252q 0.212 0.092 0.476 0.092q 0.256 0 0.468 -0.092q 0.212 -0.092 0.368 -0.248q 0.156 -0.156 0.248 -0.372q 0.092 -0.216 0.108 -0.456Z m 0.656 -1.152h -0.672q -0.088 -0.408 -0.364 -0.608q -0.276 -0.2 -0.708 -0.2q -0.336 0 -0.584 0.112q -0.248 0.112 -0.408 0.3q -0.16 0.188 -0.232 0.432q -0.072 0.244 -0.064 0.516h 3.096q 0.016 0.376 -0.068 0.792q -0.084 0.416 -0.304 0.768q -0.22 0.352 -0.584 0.58q -0.364 0.228 -0.916 0.228q -0.424 0 -0.78 -0.16q -0.356 -0.16 -0.616 -0.448q -0.26 -0.288 -0.404 -0.68q -0.144 -0.392 -0.144 -0.864q 0.016 -0.472 0.14 -0.872q 0.124 -0.4 0.372 -0.688q 0.248 -0.288 0.612 -0.448q 0.364 -0.16 0.86 -0.16q 0.704 0 1.168 0.352q 0.464 0.352 0.6 1.048Z "/></symbol><symbol id="g786D0DA605A095191D5C33A5BB968848" overflow="visible"><path d="M 0 0m 1.456 4.136v 1.24h -0.68v -1.24h -0.704v -0.6h 0.704v -2.632q 0 -0.288 0.056 -0.464q 0.056 -0.176 0.172 -0.272q 0.116 -0.096 0.304 -0.132q 0.188 -0.036 0.452 -0.036h 0.52v 0.6h -0.312q -0.16 0 -0.26 0.012q -0.1 0.012 -0.156 0.052q -0.056 0.04 -0.076 0.112q -0.02 0.072 -0.02 0.192v 2.568h 0.824v 0.6h -0.824Z "/></symbol><symbol id="g6C0EF9DFF594A5A60F31076377FDB72A" overflow="visible"><path d="M 0 0m 2.376 0l 1.512 4.136h -0.712l -1.128 -3.448h -0.016l -1.16 3.448h -0.76l 1.536 -4.136h 0.728Z "/></symbol><symbol id="gB9D4D6D822821FBD03112B321A4F5F37" overflow="visible"><path d="M 0 0m 4.176 0.016q -0.176 -0.104 -0.488 -0.104q -0.264 0 -0.42 0.148q -0.156 0.148 -0.156 0.484q -0.28 -0.336 -0.652 -0.484q -0.372 -0.148 -0.804 -0.148q -0.28 0 -0.532 0.064q -0.252 0.064 -0.436 0.2q -0.184 0.136 -0.292 0.356q -0.108 0.22 -0.108 0.532q 0 0.352 0.12 0.576q 0.12 0.224 0.316 0.364q 0.196 0.14 0.448 0.212q 0.252 0.072 0.516 0.12q 0.28 0.056 0.532 0.084q 0.252 0.028 0.444 0.08q 0.192 0.052 0.304 0.152q 0.112 0.1 0.112 0.292q 0 0.224 -0.084 0.36q -0.084 0.136 -0.216 0.208q -0.132 0.072 -0.296 0.096q -0.164 0.024 -0.324 0.024q -0.432 0 -0.72 -0.164q -0.288 -0.164 -0.312 -0.62h -0.68q 0.016 0.384 0.16 0.648q 0.144 0.264 0.384 0.428q 0.24 0.164 0.548 0.236q 0.308 0.072 0.66 0.072q 0.28 0 0.556 -0.04q 0.276 -0.04 0.5 -0.164q 0.224 -0.124 0.36 -0.348q 0.136 -0.224 0.136 -0.584v -2.128q 0 -0.24 0.028 -0.352q 0.028 -0.112 0.188 -0.112q 0.088 0 0.208 0.04v -0.528Z m -1.104 2.12q -0.128 -0.096 -0.336 -0.14q -0.208 -0.044 -0.436 -0.072q -0.228 -0.028 -0.46 -0.064q -0.232 -0.036 -0.416 -0.116q -0.184 -0.08 -0.3 -0.228q -0.116 -0.148 -0.116 -0.404q 0 -0.168 0.068 -0.284q 0.068 -0.116 0.176 -0.188q 0.108 -0.072 0.252 -0.104q 0.144 -0.032 0.304 -0.032q 0.336 0 0.576 0.092q 0.24 0.092 0.392 0.232q 0.152 0.14 0.224 0.304q 0.072 0.164 0.072 0.308v 0.696Z "/></symbol><symbol id="g8F816F4F6B3A797165B922832E440B5A" overflow="visible"><path d="M 0 0m 0.552 5.712v -5.712h 0.68v 5.712h -0.68Z "/></symbol><symbol id="g9186BB761FCB61E50F26CCCFD81F00F6" overflow="visible"><path d="M 0 0m 3.936 0v 4.136h -0.68v -2.336q 0 -0.28 -0.076 -0.516q -0.076 -0.236 -0.228 -0.412q -0.152 -0.176 -0.38 -0.272q -0.228 -0.096 -0.54 -0.096q -0.392 0 -0.616 0.224q -0.224 0.224 -0.224 0.608v 2.8h -0.68v -2.72q 0 -0.336 0.068 -0.612q 0.068 -0.276 0.236 -0.476q 0.168 -0.2 0.44 -0.308q 0.272 -0.108 0.68 -0.108q 0.456 0 0.792 0.18q 0.336 0.18 0.552 0.564h 0.016v -0.656h 0.64Z "/></symbol><symbol id="g3633D5EF187E794EAF4ED06368BFDFCF" overflow="visible"><path d="M 0 0m 0.928 1.304h -0.68q 0.016 -0.384 0.16 -0.652q 0.144 -0.268 0.384 -0.432q 0.24 -0.164 0.552 -0.236q 0.312 -0.072 0.656 -0.072q 0.312 0 0.628 0.06q 0.316 0.06 0.568 0.212q 0.252 0.152 0.408 0.4q 0.156 0.248 0.156 0.624q 0 0.296 -0.116 0.496q -0.116 0.2 -0.304 0.332q -0.188 0.132 -0.432 0.212q -0.244 0.08 -0.5 0.136q -0.24 0.056 -0.48 0.108q -0.24 0.052 -0.432 0.128q -0.192 0.076 -0.316 0.192q -0.124 0.116 -0.124 0.292q 0 0.16 0.08 0.26q 0.08 0.1 0.208 0.16q 0.128 0.06 0.284 0.084q 0.156 0.024 0.308 0.024q 0.168 0 0.332 -0.036q 0.164 -0.036 0.3 -0.116q 0.136 -0.08 0.224 -0.212q 0.088 -0.132 0.104 -0.332h 0.68q -0.024 0.376 -0.16 0.628q -0.136 0.252 -0.364 0.4q -0.228 0.148 -0.524 0.208q -0.296 0.06 -0.648 0.06q -0.272 0 -0.548 -0.068q -0.276 -0.068 -0.496 -0.208q -0.22 -0.14 -0.36 -0.364q -0.14 -0.224 -0.14 -0.536q 0 -0.4 0.2 -0.624q 0.2 -0.224 0.5 -0.348q 0.3 -0.124 0.652 -0.192q 0.352 -0.068 0.652 -0.152q 0.3 -0.084 0.5 -0.22q 0.2 -0.136 0.2 -0.4q 0 -0.192 -0.096 -0.316q -0.096 -0.124 -0.244 -0.188q -0.148 -0.064 -0.324 -0.088q -0.176 -0.024 -0.336 -0.024q -0.208 0 -0.404 0.04q -0.196 0.04 -0.352 0.132q -0.156 0.092 -0.252 0.248q -0.096 0.156 -0.104 0.38Z "/></symbol><symbol id="g33AE866EDA811CB59C344F15280DE76E" overflow="visible"><path d="M 0 0m 4.08 0.352v 3.784h -0.64v -0.592h -0.008q -0.184 0.344 -0.512 0.516q -0.328 0.172 -0.72 0.172q -0.536 0 -0.904 -0.204q -0.368 -0.204 -0.592 -0.52q -0.224 -0.316 -0.32 -0.704q -0.096 -0.388 -0.096 -0.756q 0 -0.424 0.116 -0.804q 0.116 -0.38 0.348 -0.664q 0.232 -0.284 0.576 -0.452q 0.344 -0.168 0.808 -0.168q 0.4 0 0.756 0.18q 0.356 0.18 0.532 0.564h 0.016v -0.272q 0 -0.344 -0.068 -0.632q -0.068 -0.288 -0.22 -0.492q -0.152 -0.204 -0.384 -0.32q -0.232 -0.116 -0.568 -0.116q -0.168 0 -0.352 0.036q -0.184 0.036 -0.34 0.116q -0.156 0.08 -0.264 0.208q -0.108 0.128 -0.116 0.312h -0.68q 0.016 -0.336 0.176 -0.568q 0.16 -0.232 0.404 -0.376q 0.244 -0.144 0.544 -0.208q 0.3 -0.064 0.588 -0.064q 0.992 0 1.456 0.504q 0.464 0.504 0.464 1.52Z m -1.904 0.2q -0.336 0 -0.56 0.14q -0.224 0.14 -0.36 0.368q -0.136 0.228 -0.192 0.508q -0.056 0.28 -0.056 0.56q 0 0.296 0.068 0.568q 0.068 0.272 0.216 0.48q 0.148 0.208 0.38 0.332q 0.232 0.124 0.56 0.124q 0.32 0 0.544 -0.128q 0.224 -0.128 0.364 -0.34q 0.14 -0.212 0.204 -0.476q 0.064 -0.264 0.064 -0.536q 0 -0.288 -0.068 -0.576q -0.068 -0.288 -0.212 -0.516q -0.144 -0.228 -0.38 -0.368q -0.236 -0.14 -0.572 -0.14Z "/></symbol><symbol id="g97071A2893B0C7191AEDE27EAE655EFE" overflow="visible"><path d="M 0 0m 0.536 4.136v -5.712h 0.68v 2.128h 0.016q 0.112 -0.184 0.276 -0.308q 0.164 -0.124 0.348 -0.196q 0.184 -0.072 0.372 -0.104q 0.188 -0.032 0.34 -0.032q 0.472 0 0.828 0.168q 0.356 0.168 0.592 0.46q 0.236 0.292 0.352 0.684q 0.116 0.392 0.116 0.832q 0 0.44 -0.12 0.832q -0.12 0.392 -0.356 0.692q -0.236 0.3 -0.592 0.476q -0.356 0.176 -0.836 0.176q -0.432 0 -0.792 -0.156q -0.36 -0.156 -0.528 -0.5h -0.016v 0.56h -0.68Z m 3.2 -2.032q 0 -0.304 -0.064 -0.592q -0.064 -0.288 -0.208 -0.512q -0.144 -0.224 -0.38 -0.36q -0.236 -0.136 -0.588 -0.136q -0.352 0 -0.6 0.132q -0.248 0.132 -0.404 0.348q -0.156 0.216 -0.228 0.5q -0.072 0.284 -0.072 0.588q 0 0.288 0.068 0.568q 0.068 0.28 0.22 0.5q 0.152 0.22 0.392 0.356q 0.24 0.136 0.584 0.136q 0.328 0 0.572 -0.128q 0.244 -0.128 0.4 -0.344q 0.156 -0.216 0.232 -0.492q 0.076 -0.276 0.076 -0.564Z "/></symbol><symbol id="g56F73A9DDE7688229227FB61E73B22EB" overflow="visible"><path d="M 0 0m 1.008 2.032q 0 0.304 0.064 0.592q 0.064 0.288 0.208 0.512q 0.144 0.224 0.384 0.36q 0.24 0.136 0.584 0.136q 0.352 0 0.6 -0.132q 0.248 -0.132 0.404 -0.348q 0.156 -0.216 0.228 -0.5q 0.072 -0.284 0.072 -0.588q 0 -0.288 -0.068 -0.568q -0.068 -0.28 -0.22 -0.5q -0.152 -0.22 -0.392 -0.356q -0.24 -0.136 -0.584 -0.136q -0.328 0 -0.572 0.128q -0.244 0.128 -0.4 0.344q -0.156 0.216 -0.232 0.492q -0.076 0.276 -0.076 0.564Z m 3.2 -2.032v 5.712h -0.68v -2.128h -0.016q -0.112 0.184 -0.276 0.308q -0.164 0.124 -0.348 0.2q -0.184 0.076 -0.368 0.108q -0.184 0.032 -0.344 0.032q -0.472 0 -0.828 -0.172q -0.356 -0.172 -0.592 -0.464q -0.236 -0.292 -0.352 -0.684q -0.116 -0.392 -0.116 -0.832q 0 -0.44 0.12 -0.832q 0.12 -0.392 0.356 -0.688q 0.236 -0.296 0.592 -0.472q 0.356 -0.176 0.836 -0.176q 0.432 0 0.792 0.152q 0.36 0.152 0.528 0.496h 0.016v -0.56h 0.68Z "/></symbol><symbol id="gA140E16CF1ABF13007304C5857587282" overflow="visible"><path d="M 0 0m 0.536 5.712v -5.712h 0.68v 0.552h 0.016q 0.112 -0.184 0.276 -0.308q 0.164 -0.124 0.348 -0.196q 0.184 -0.072 0.372 -0.104q 0.188 -0.032 0.34 -0.032q 0.472 0 0.828 0.168q 0.356 0.168 0.592 0.46q 0.236 0.292 0.352 0.684q 0.116 0.392 0.116 0.832q 0 0.44 -0.12 0.832q -0.12 0.392 -0.356 0.692q -0.236 0.3 -0.592 0.476q -0.356 0.176 -0.836 0.176q -0.432 0 -0.792 -0.156q -0.36 -0.156 -0.528 -0.5h -0.016v 2.136h -0.68Z m 3.2 -3.608q 0 -0.304 -0.064 -0.592q -0.064 -0.288 -0.208 -0.512q -0.144 -0.224 -0.38 -0.36q -0.236 -0.136 -0.588 -0.136q -0.352 0 -0.6 0.132q -0.248 0.132 -0.404 0.348q -0.156 0.216 -0.228 0.5q -0.072 0.284 -0.072 0.588q 0 0.288 0.068 0.568q 0.068 0.28 0.22 0.5q 0.152 0.22 0.392 0.356q 0.24 0.136 0.584 0.136q 0.328 0 0.572 -0.128q 0.244 -0.128 0.4 -0.344q 0.156 -0.216 0.232 -0.492q 0.076 -0.276 0.076 -0.564Z "/></symbol><symbol id="g9DE8B4E528C361BFE10E18BF85136915" overflow="visible"><path d="M 0 0m 2.136 -0.552q -0.12 -0.304 -0.236 -0.512q -0.116 -0.208 -0.256 -0.34q -0.14 -0.132 -0.312 -0.192q -0.172 -0.06 -0.396 -0.06q -0.12 0 -0.24 0.016q -0.12 0.016 -0.232 0.056v 0.624q 0.088 -0.04 0.204 -0.068q 0.116 -0.028 0.196 -0.028q 0.208 0 0.348 0.1q 0.14 0.1 0.212 0.284l 0.28 0.696l -1.64 4.112h 0.768l 1.208 -3.384h 0.016l 1.16 3.384h 0.72l -1.8 -4.688Z "/></symbol><symbol id="g32B342CADBF6914BAE52C992C70E94C0" overflow="visible"><path d="M 0 0m 1.232 4.88v 0.832h -0.68v -0.832h 0.68Z m -0.68 -0.744v -4.136h 0.68v 4.136h -0.68Z "/></symbol><symbol id="g53D2D7990B1448118A03E4A23C44B622" overflow="visible"><path d="M 0 0m 0.512 4.136v -4.136h 0.68v 2.576q 0 0.12 0.06 0.3q 0.06 0.18 0.192 0.348q 0.132 0.168 0.344 0.288q 0.212 0.12 0.508 0.12q 0.232 0 0.38 -0.068q 0.148 -0.068 0.236 -0.192q 0.088 -0.124 0.124 -0.292q 0.036 -0.168 0.036 -0.368v -2.712h 0.68v 2.576q 0 0.48 0.288 0.768q 0.288 0.288 0.792 0.288q 0.248 0 0.404 -0.072q 0.156 -0.072 0.244 -0.196q 0.088 -0.124 0.12 -0.292q 0.032 -0.168 0.032 -0.36v -2.712h 0.68v 3.032q 0 0.32 -0.1 0.548q -0.1 0.228 -0.28 0.372q -0.18 0.144 -0.432 0.212q -0.252 0.068 -0.564 0.068q -0.408 0 -0.748 -0.184q -0.34 -0.184 -0.548 -0.52q -0.128 0.384 -0.44 0.544q -0.312 0.16 -0.696 0.16q -0.872 0 -1.336 -0.704h -0.016v 0.608h -0.64Z "/></symbol><symbol id="g39FF3551F1CB57B29C5CAADE5C30FA34" overflow="visible"><path d="M 0 0m 0.664 0.888v -0.888h 0.888v 0.888h -0.888Z "/></symbol></defs></svg>
\ No newline at end of file
diff --git a/docs/src/static/variant-hierarchy.typ b/docs/src/static/variant-hierarchy.typ
index e1df29872..9db5aadca 100644
--- a/docs/src/static/variant-hierarchy.typ
+++ b/docs/src/static/variant-hierarchy.typ
@@ -1,4 +1,4 @@
-#import "@preview/fletcher:0.5.8" as fletcher: diagram, node, edge
+#import "@preview/fletcher:0.5.8" as fletcher: diagram, node
 #set page(width: auto, height: auto, margin: (top: 5pt, bottom: 5pt, left: 5pt, right: 5pt), fill: none)
 #set text(font: "Helvetica Neue")
 
@@ -28,47 +28,31 @@
     node((3.2, -0.5), text(size: 10pt, weight: "bold")[Weights], stroke: none, fill: none),
     node((5, -0.5), text(size: 10pt, weight: "bold")[K Values], stroke: none, fill: none),
 
-    // Graph hierarchy (tree)
-    node((0, 0), [HyperGraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt, name: <hg>),
-    node((0, 1), [SimpleGraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt, name: <sg>),
-    node((-1, 2), [PlanarGraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt, name: <pg>),
-    node((0, 2), [BipartiteGraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt, name: <bg>),
-    node((1, 2), [UnitDiskGraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt, name: <udg>),
-    node((0.5, 3), [KingsSubgraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt, name: <ksg>),
-    node((1.5, 3), [TriangularSubgraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt, name: <tri>),
-
-    edge(<sg>, <hg>, "->"),
-    edge(<pg>, <sg>, "->"),
-    edge(<bg>, <sg>, "->"),
-    edge(<udg>, <sg>, "->"),
-    edge(<ksg>, <udg>, "->"),
-    edge(<tri>, <udg>, "->"),
-
-    // Weight hierarchy (chain: One → i32 → f64)
-    node((3.2, 0), [f64], fill: weight-fill, corner-radius: 5pt, inset: 6pt, name: <w-f64>),
-    node((3.2, 1), [i32], fill: weight-fill, corner-radius: 5pt, inset: 6pt, name: <w-i32>),
-    node((3.2, 2), [One], fill: weight-fill, corner-radius: 5pt, inset: 6pt, name: <w-one>),
-
-    edge(<w-one>, <w-i32>, "->"),
-    edge(<w-i32>, <w-f64>, "->"),
-
-    // K value hierarchy (flat star)
-    node((5, 0), [KN], fill: k-fill, corner-radius: 5pt, inset: 6pt, name: <kn>),
-    node((4.2, 1), [K1], fill: k-fill, corner-radius: 5pt, inset: 6pt, name: <k1>),
-    node((4.6, 1), [K2], fill: k-fill, corner-radius: 5pt, inset: 6pt, name: <k2>),
-    node((5, 1), [K3], fill: k-fill, corner-radius: 5pt, inset: 6pt, name: <k3>),
-    node((5.4, 1), [K4], fill: k-fill, corner-radius: 5pt, inset: 6pt, name: <k4>),
-    node((5.8, 1), [K5], fill: k-fill, corner-radius: 5pt, inset: 6pt, name: <k5>),
-
-    edge(<k1>, <kn>, "->"),
-    edge(<k2>, <kn>, "->"),
-    edge(<k3>, <kn>, "->"),
-    edge(<k4>, <kn>, "->"),
-    edge(<k5>, <kn>, "->"),
+    // Registered graph values
+    node((0, 0), [HyperGraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt),
+    node((0, 1), [SimpleGraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt),
+    node((-1, 2), [PlanarGraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt),
+    node((0, 2), [BipartiteGraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt),
+    node((1, 2), [UnitDiskGraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt),
+    node((0.5, 3), [KingsSubgraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt),
+    node((1.5, 3), [TriangularSubgraph], fill: graph-fill, corner-radius: 5pt, inset: 6pt),
+
+    // Registered weight values
+    node((3.2, 0), [f64], fill: weight-fill, corner-radius: 5pt, inset: 6pt),
+    node((3.2, 1), [i64], fill: weight-fill, corner-radius: 5pt, inset: 6pt),
+    node((3.2, 2), [One], fill: weight-fill, corner-radius: 5pt, inset: 6pt),
+
+    // Registered K values
+    node((5, 0), [KN], fill: k-fill, corner-radius: 5pt, inset: 6pt),
+    node((4.2, 1), [K1], fill: k-fill, corner-radius: 5pt, inset: 6pt),
+    node((4.6, 1), [K2], fill: k-fill, corner-radius: 5pt, inset: 6pt),
+    node((5, 1), [K3], fill: k-fill, corner-radius: 5pt, inset: 6pt),
+    node((5.4, 1), [K4], fill: k-fill, corner-radius: 5pt, inset: 6pt),
+    node((5.8, 1), [K5], fill: k-fill, corner-radius: 5pt, inset: 6pt),
   )
 
   v(3mm)
-  text(size: 8pt, fill: secondary)[Arrows point from specific to general (subtype direction).]
+  text(size: 8pt, fill: secondary)[Concrete values grouped by variant dimension.]
 }
 
 #let standalone-dark = sys.inputs.at("dark", default: "false") == "true"
diff --git a/docs/website/assets/site.css b/docs/website/assets/site.css
index 383f04e97..d98daa52b 100644
--- a/docs/website/assets/site.css
+++ b/docs/website/assets/site.css
@@ -910,6 +910,27 @@ pre {
   color: var(--green);
   line-height: 1.5;
   margin-block: 23px;
+  overflow-x: auto;
+}
+.formula math {
+  font-family: math;
+}
+.formula math[display="block"] {
+  margin: 0;
+  text-align: left;
+}
+.formula-constraint {
+  margin-top: 14px;
+  font-size: 18px;
+}
+.math-expression {
+  overflow-x: auto;
+  max-width: 100%;
+  padding-block: 8px;
+}
+.math-expression math {
+  font-family: math;
+  font-size: 1.05em;
 }
 .formula small {
   display: block;
diff --git a/docs/website/assets/site.js b/docs/website/assets/site.js
index 743c32e1c..7d09f9def 100644
--- a/docs/website/assets/site.js
+++ b/docs/website/assets/site.js
@@ -353,7 +353,7 @@
             <h2>
               ${mis ? "A simple question. A rich search space." : "The problem"}
             </h2>
-            ${mis ? '<p>Given a graph G = (V, E), choose a set of vertices such that no two chosen vertices are adjacent. Maximize the total weight of the chosen vertices. With unit weights, this is the largest independent set.</p><div class="formula">maximize ∑ wᵥ xᵥ<small>subject to xᵤ + xᵥ ≤ 1 for every edge (u, v), with xᵥ ∈ {0, 1}.</small></div>' : `<p>${escape(description(name))}. The fields below define the instance accepted by the implementation. Consult the paper for its mathematical definition and the API for its full contract.</p>`}${mis && node.variant.graph === "SimpleGraph" ? demoPanel() : ""}
+            ${mis ? '<p>Given a graph G = (V, E), choose a set of vertices such that no two chosen vertices are adjacent. Maximize the total weight of the chosen vertices. With unit weights, this is the largest independent set.</p><div class="formula"><math display="block" aria-label="Maximize the sum over vertices v in V of w_v times x_v"><mrow><mo>max</mo><mspace width="0.6em"/><munder><mo>∑</mo><mrow><mi>v</mi><mo>∈</mo><mi>V</mi></mrow></munder><msub><mi>w</mi><mi>v</mi></msub><msub><mi>x</mi><mi>v</mi></msub></mrow></math><div class="formula-constraint"><math aria-label="x_u plus x_v is at most one for each edge"><mrow><msub><mi>x</mi><mi>u</mi></msub><mo>+</mo><msub><mi>x</mi><mi>v</mi></msub><mo>≤</mo><mn>1</mn><mo>,</mo><mspace width="0.5em"/><mo>∀</mo><mo>(</mo><mi>u</mi><mo>,</mo><mi>v</mi><mo>)</mo><mo>∈</mo><mi>E</mi></mrow></math></div><div class="formula-constraint"><math aria-label="x_v is zero or one for each vertex"><mrow><msub><mi>x</mi><mi>v</mi></msub><mo>∈</mo><mo>{</mo><mn>0</mn><mo>,</mo><mn>1</mn><mo>}</mo><mo>,</mo><mspace width="0.5em"/><mo>∀</mo><mi>v</mi><mo>∈</mo><mi>V</mi></mrow></math></div></div>' : `<p>${escape(description(name))}. The fields below define the instance accepted by the implementation. Consult the paper for its mathematical definition and the API for its full contract.</p>`}${mis && node.variant.graph === "SimpleGraph" ? demoPanel() : ""}
           </section>
           <section class="reading-section">
             <h2>Connections for this variant</h2>
@@ -400,7 +400,7 @@
             </div>
             <div>
               <dt>Registered complexity</dt>
-              <dd><code>${escape(node.complexity || "See API")}</code></dd>
+              <dd class="math-expression">${node.complexity_mathml}</dd>
             </div>
             <div>
               <dt>Direct connections</dt>
@@ -475,7 +475,7 @@
         <div class="reading-content">
           <section class="reading-section">
             <h2>The construction</h2>
-            ${complement ? `<p>The target uses the same graph and vertex weights. ${vcToMis ? "Solve Maximum Independent Set on that graph, then take the complement of its vertex selection to recover a minimum vertex cover." : "Solve Minimum Vertex Cover on that graph, then take the complement of its vertex selection to recover a maximum independent set."}</p><div class="formula">S ↔ V ∖ S<small>A set is independent exactly when its complement is a vertex cover.</small></div><p>For weighted instances, the two objective values sum to the total vertex weight. Maximizing the independent-set weight therefore minimizes the complementary cover weight.</p>${demoPanel()}` : `<p>This rule maps <a class="text-link" href="${problemHref(sourceName, source)}">${escape(nameOf(sourceName))}</a> to <a class="text-link" href="${problemHref(targetName, target)}">${escape(nameOf(targetName))}</a>. The implementation and paper describe the mapping, its preconditions, and solution extraction.</p><a class="button secondary" href="${sourceHref(edge)}">Read the construction <span>↗</span></a>`}
+            ${complement ? `<p>The target uses the same graph and vertex weights. ${vcToMis ? "Solve Maximum Independent Set on that graph, then take the complement of its vertex selection to recover a minimum vertex cover." : "Solve Minimum Vertex Cover on that graph, then take the complement of its vertex selection to recover a maximum independent set."}</p><div class="formula"><math display="block" aria-label="S corresponds to V minus S"><mrow><mi>S</mi><mo>↔</mo><mi>V</mi><mo>∖</mo><mi>S</mi></mrow></math><small>A set is independent exactly when its complement is a vertex cover.</small></div><p>For weighted instances, the two objective values sum to the total vertex weight. Maximizing the independent-set weight therefore minimizes the complementary cover weight.</p>${demoPanel()}` : `<p>This rule maps <a class="text-link" href="${problemHref(sourceName, source)}">${escape(nameOf(sourceName))}</a> to <a class="text-link" href="${problemHref(targetName, target)}">${escape(nameOf(targetName))}</a>. The implementation and paper describe the mapping, its preconditions, and solution extraction.</p><a class="button secondary" href="${sourceHref(edge)}">Read the construction <span>↗</span></a>`}
           </section>
           <section class="reading-section">
             <h2>What the rule guarantees</h2>
@@ -497,24 +497,23 @@
                 >
               </div>
             </div>
-            <h3>Target size bounds</h3>
+            <h3>Target parameter relations</h3>
             <div class="table-scroll">
               <table class="schema-table">
                 <thead>
                   <tr>
                     <th>Target parameter</th>
-                    <th>Bound in source parameters</th>
+                    <th>Relation</th>
+                    <th>Formula or reason</th>
                   </tr>
                 </thead>
                 <tbody>
-                  ${(edge.overhead || []).map((o) => `<tr><td><code>${escape(o.field)}</code></td><td><code>${escape(o.formula)}</code></td></tr>`).join("")}
+                  ${edge.parameters.map((p) => `<tr><td><code>${escape(p.field)}</code></td><td>${escape(p.contract)}</td><td class="math-expression">${p.mathml ?? escape(p.reason)}</td></tr>`).join("")}
                 </tbody>
               </table>
             </div>
             <p class="notice">
-              Registry overheads are asymptotic upper bounds. Read the
-              constructor for exact instance
-              sizes.${complement ? " This construction preserves the number of vertices and edges exactly." : ""}
+              Each relation is an exact equality, an upper bound, or unavailable with a reason. Read the constructor for concrete instance parameters.${complement ? " This construction preserves the number of vertices and edges exactly." : ""}
             </p>
           </section>
           <section class="reading-section">
diff --git a/examples/chained_reduction_factoring_to_spinglass.rs b/examples/chained_reduction_factoring_to_spinglass.rs
index 8374906e7..48067cd3a 100644
--- a/examples/chained_reduction_factoring_to_spinglass.rs
+++ b/examples/chained_reduction_factoring_to_spinglass.rs
@@ -7,73 +7,57 @@
 // ANCHOR: imports
 use problemreductions::models::algebraic::ILP;
 use problemreductions::prelude::*;
-use problemreductions::rules::{MinimizeSteps, ReductionGraph};
+use problemreductions::rules::{ReductionGraph, ReductionMode};
 use problemreductions::solvers::ILPSolver;
 use problemreductions::topology::SimpleGraph;
-use problemreductions::types::ProblemSize;
 // ANCHOR_END: imports
 
-pub fn run() {
+pub fn run() -> std::result::Result<(), Box<dyn std::error::Error>> {
     // ANCHOR: example
     // ANCHOR: step1
     let graph = ReductionGraph::new(); // all registered reductions
     let src_var = ReductionGraph::variant_to_map(&Factoring::variant()); // {} (no variant params)
     let dst_var = ReductionGraph::variant_to_map(&SpinGlass::<SimpleGraph, f64>::variant()); // {graph: "SimpleGraph", weight: "f64"}
-    let rpath = graph
-        .find_cheapest_path(
-            "Factoring",               // source problem name
-            &src_var,                  // source variant map
-            "SpinGlass",               // target problem name
-            &dst_var,                  // target variant map
-            &ProblemSize::new(vec![]), // input size (empty = unknown)
-            &MinimizeSteps,            // cost function: fewest hops
-        )
-        .unwrap();
+    let paths = graph.find_all_paths_mode(
+        "Factoring",
+        &src_var,
+        "SpinGlass",
+        &dst_var,
+        ReductionMode::Witness,
+    );
+    let rpath = paths
+        .iter()
+        .find(|path| path.type_names() == ["Factoring", "CircuitSAT", "SpinGlass"])
+        .expect("explicit Factoring -> CircuitSAT -> SpinGlass route");
     println!("  {}", rpath);
     // ANCHOR_END: step1
 
     // ANCHOR: step2
-    let factoring = Factoring::new(
+    let factoring = Factoring::with_factor_bits(
+        6, // target_product:  find p × q = 6
         2, // num_bits_first:  p is a 2-bit factor
         2, // num_bits_second: q is a 2-bit factor
-        6, // target_product:  find p × q = 6
     );
     // ANCHOR_END: step2
 
     // ANCHOR: step3
-    // Factoring reduces to ILP<i32>, so we manually reduce, solve, and extract
+    // Factoring reduces to ILP<i64>, so we manually reduce, solve, and extract
     let solver = ILPSolver::new();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&factoring);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&factoring).expect("reduction should succeed");
     let ilp_solution = solver.solve(reduction.target_problem()).unwrap();
-    let solution = reduction.extract_solution(&ilp_solution);
+    let solution = reduction.extract_solution(&ilp_solution).unwrap();
     // ANCHOR_END: step3
 
     // ANCHOR: step4
-    let (p, q) = factoring.read_factors(&solution); // decode bit assignments → integers
+    let (p, q) = solution;
     println!("{} = {} × {}", factoring.target(), p, q);
-    assert_eq!(p * q, 6, "Factors should multiply to 6");
+    assert_eq!(p * q, 6u32.into(), "Factors should multiply to 6");
     // ANCHOR_END: step4
 
-    // ANCHOR: overhead
-    // Print per-edge overhead polynomials
-    let edge_overheads = graph.path_overheads(&rpath);
-    for (i, overhead) in edge_overheads.iter().enumerate() {
-        println!("{} → {}:", rpath.steps[i], rpath.steps[i + 1]);
-        for (field, poly) in &overhead.output_size {
-            println!("  {} = {}", field, poly);
-        }
-    }
-
-    // Compose overheads symbolically along the full path
-    let composed = graph.compose_path_overhead(&rpath);
-    println!("Composed (source → target):");
-    for (field, poly) in &composed.output_size {
-        println!("  {} = {}", field, poly);
-    }
-    // ANCHOR_END: overhead
     // ANCHOR_END: example
+    Ok(())
 }
 
-fn main() {
+fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
     run()
 }
diff --git a/examples/export_graph.rs b/examples/export_graph.rs
index 2b1b6e4dc..5a1ef241d 100644
--- a/examples/export_graph.rs
+++ b/examples/export_graph.rs
@@ -3,9 +3,9 @@
 //! Run with: `cargo run --example export_graph [output_path]`
 
 use problemreductions::rules::ReductionGraph;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
-fn main() {
+pub fn run(output_path: &Path) {
     let graph = ReductionGraph::new();
 
     // Print statistics
@@ -13,19 +13,13 @@ fn main() {
     println!("  Problem types: {}", graph.num_types());
     println!("  Reductions: {}", graph.num_reductions());
 
-    // Export to JSON (single source for both mdBook and paper)
-    let output_path = std::env::args()
-        .nth(1)
-        .map(PathBuf::from)
-        .unwrap_or_else(|| PathBuf::from("docs/src/reductions/reduction_graph.json"));
-
     // Create parent directories if needed
     if let Some(parent) = output_path.parent() {
         std::fs::create_dir_all(parent).expect("Failed to create output directory");
     }
 
     graph
-        .to_json_file(&output_path)
+        .to_json_file(output_path)
         .expect("Failed to write JSON file");
 
     println!("\nExported to: {}", output_path.display());
@@ -34,3 +28,11 @@ fn main() {
     println!("\nJSON content:");
     println!("{}", graph.to_json_string().unwrap());
 }
+
+fn main() {
+    let output_path = std::env::args()
+        .nth(1)
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from("docs/src/reductions/reduction_graph.json"));
+    run(&output_path);
+}
diff --git a/examples/export_mapping_stages.rs b/examples/export_mapping_stages.rs
index 3caf8cdec..884ac242c 100644
--- a/examples/export_mapping_stages.rs
+++ b/examples/export_mapping_stages.rs
@@ -20,9 +20,9 @@ use std::fs;
 
 #[derive(Serialize)]
 struct GridNodeExport {
-    row: i32,
-    col: i32,
-    weight: i32,
+    row: i64,
+    col: i64,
+    weight: i64,
     state: String, // "O" = Occupied, "D" = Doubled, "C" = Connected
 }
 
@@ -39,8 +39,8 @@ struct CopyLineExport {
 
 #[derive(Serialize)]
 struct LocationExport {
-    row: i32,
-    col: i32,
+    row: i64,
+    col: i64,
 }
 
 #[derive(Serialize)]
@@ -50,7 +50,7 @@ struct TapeEntryExport {
     gadget_idx: usize,
     row: usize,
     col: usize,
-    overhead: i32,
+    overhead: i64,
 }
 
 #[derive(Serialize)]
@@ -75,10 +75,10 @@ struct MappingExport {
     stages: Vec<StageExport>,
     crossing_tape: Vec<TapeEntryExport>,
     simplifier_tape: Vec<TapeEntryExport>,
-    copyline_overhead: i32,
-    crossing_overhead: i32,
-    simplifier_overhead: i32,
-    total_overhead: i32,
+    copyline_overhead: i64,
+    crossing_overhead: i64,
+    simplifier_overhead: i64,
+    total_overhead: i64,
 }
 
 fn gadget_name(idx: usize) -> String {
@@ -119,8 +119,8 @@ fn extract_grid_nodes(grid: &MappingGrid) -> Vec<GridNodeExport> {
                         CellState::Empty => ".",
                     };
                     nodes.push(GridNodeExport {
-                        row: r as i32, // 0-indexed - DO NOT change!
-                        col: c as i32, // 0-indexed - DO NOT change!
+                        row: r as i64, // 0-indexed - DO NOT change!
+                        col: c as i64, // 0-indexed - DO NOT change!
                         weight: cell.weight(),
                         state: state.to_string(),
                     });
@@ -158,7 +158,7 @@ fn crossat_triangular(
 }
 
 fn get_vertex_order_from_julia(graph_name: &str) -> Option<Vec<usize>> {
-    let path = format!("tests/julia/{}_triangular_trace.json", graph_name);
+    let path = format!("tests/data/{}_triangular_trace.json", graph_name);
     if let Ok(content) = fs::read_to_string(&path) {
         if let Ok(data) = serde_json::from_str::<serde_json::Value>(&content) {
             if let Some(copy_lines) = data["copy_lines"].as_array() {
@@ -229,7 +229,7 @@ fn export_triangular(
     let spacing = triangular::SPACING;
     let padding = triangular::PADDING;
 
-    let copylines = create_copylines(n, edges, vertex_order);
+    let copylines = create_copylines(n, edges, vertex_order).unwrap();
 
     let max_hslot = copylines.iter().map(|l| l.hslot).max().unwrap_or(1);
     let max_vstop = copylines.iter().map(|l| l.vstop).max().unwrap_or(1);
@@ -239,7 +239,7 @@ fn export_triangular(
     let mut grid = MappingGrid::with_padding(rows, cols, spacing, padding);
     for line in &copylines {
         for (row, col, weight) in line.copyline_locations_triangular(padding, spacing) {
-            grid.add_node(row, col, weight as i32);
+            grid.add_node(row, col, weight as i64);
         }
     }
     let stage1_nodes = extract_grid_nodes(&grid);
@@ -276,17 +276,23 @@ fn export_triangular(
     let simplifier_tape = triangular::apply_simplifier_gadgets(&mut grid, 10);
     let stage4_nodes = extract_grid_nodes(&grid);
 
-    let copyline_overhead: i32 = copylines
+    let copyline_overhead: i64 = copylines
         .iter()
-        .map(|line| mis_overhead_copyline_triangular(line, spacing))
+        .map(|line| mis_overhead_copyline_triangular(line, spacing).unwrap())
         .sum();
-    let crossing_overhead: i32 = crossing_tape
+    let crossing_overhead: i64 = crossing_tape
         .iter()
-        .map(triangular::tape_entry_mis_overhead)
+        .map(|entry| {
+            triangular::tape_entry_mis_overhead(entry)
+                .expect("generated triangular crossing tape must contain known gadgets")
+        })
         .sum();
-    let simplifier_overhead: i32 = simplifier_tape
+    let simplifier_overhead: i64 = simplifier_tape
         .iter()
-        .map(triangular::tape_entry_mis_overhead)
+        .map(|entry| {
+            triangular::tape_entry_mis_overhead(entry)
+                .expect("generated triangular simplifier tape must contain known gadgets")
+        })
         .sum();
 
     let copy_lines_export = export_copylines_triangular(&copylines, padding, spacing);
@@ -325,7 +331,7 @@ fn export_square(
     let spacing = ksg::SPACING;
     let padding = ksg::PADDING;
 
-    let copylines = create_copylines(n, edges, vertex_order);
+    let copylines = create_copylines(n, edges, vertex_order).unwrap();
 
     let max_hslot = copylines.iter().map(|l| l.hslot).max().unwrap_or(1);
     let max_vstop = copylines.iter().map(|l| l.vstop).max().unwrap_or(1);
@@ -375,14 +381,23 @@ fn export_square(
     let simplifier_tape = ksg::apply_simplifier_gadgets(&mut grid, 2);
     let stage4_nodes = extract_grid_nodes(&grid);
 
-    let copyline_overhead: i32 = copylines
+    let copyline_overhead: i64 = copylines
+        .iter()
+        .map(|line| mis_overhead_copyline(line, spacing, padding).unwrap())
+        .sum();
+    let crossing_overhead: i64 = crossing_tape
         .iter()
-        .map(|line| mis_overhead_copyline(line, spacing, padding) as i32)
+        .map(|entry| {
+            ksg::tape_entry_mis_overhead(entry)
+                .expect("generated KSG crossing tape must contain known gadgets")
+        })
         .sum();
-    let crossing_overhead: i32 = crossing_tape.iter().map(ksg::tape_entry_mis_overhead).sum();
-    let simplifier_overhead: i32 = simplifier_tape
+    let simplifier_overhead: i64 = simplifier_tape
         .iter()
-        .map(ksg::tape_entry_mis_overhead)
+        .map(|entry| {
+            ksg::tape_entry_mis_overhead(entry)
+                .expect("generated KSG simplifier tape must contain known gadgets")
+        })
         .sum();
 
     let copy_lines_export = export_copylines_square(&copylines, padding, spacing);
@@ -421,7 +436,7 @@ fn export_weighted(
     let spacing = ksg::SPACING;
     let padding = ksg::PADDING;
 
-    let copylines = create_copylines(n, edges, vertex_order);
+    let copylines = create_copylines(n, edges, vertex_order).unwrap();
 
     let max_hslot = copylines.iter().map(|l| l.hslot).max().unwrap_or(1);
     let max_vstop = copylines.iter().map(|l| l.vstop).max().unwrap_or(1);
@@ -431,7 +446,7 @@ fn export_weighted(
     let mut grid = MappingGrid::with_padding(rows, cols, spacing, padding);
     for line in &copylines {
         for (row, col, weight) in line.copyline_locations(padding, spacing) {
-            grid.add_node(row, col, weight as i32); // Use actual weights from copyline (1 at endpoints, 2 elsewhere)
+            grid.add_node(row, col, weight as i64); // Use actual weights from copyline (1 at endpoints, 2 elsewhere)
         }
     }
     let stage1_nodes = extract_grid_nodes(&grid);
@@ -469,17 +484,23 @@ fn export_weighted(
     let stage4_nodes = extract_grid_nodes(&grid);
 
     // Weighted mode: overhead = unweighted_overhead * 2
-    let copyline_overhead: i32 = copylines
+    let copyline_overhead: i64 = copylines
         .iter()
-        .map(|line| mis_overhead_copyline(line, spacing, padding) as i32 * 2)
+        .map(|line| mis_overhead_copyline(line, spacing, padding).unwrap() * 2)
         .sum();
-    let crossing_overhead: i32 = crossing_tape
+    let crossing_overhead: i64 = crossing_tape
         .iter()
-        .map(ksg::weighted_tape_entry_mis_overhead)
+        .map(|entry| {
+            ksg::weighted_tape_entry_mis_overhead(entry)
+                .expect("generated weighted KSG crossing tape must contain known gadgets")
+        })
         .sum();
-    let simplifier_overhead: i32 = simplifier_tape
+    let simplifier_overhead: i64 = simplifier_tape
         .iter()
-        .map(ksg::weighted_tape_entry_mis_overhead)
+        .map(|entry| {
+            ksg::weighted_tape_entry_mis_overhead(entry)
+                .expect("generated weighted KSG simplifier tape must contain known gadgets")
+        })
         .sum();
 
     let copy_lines_export = export_copylines_square(&copylines, padding, spacing);
@@ -555,8 +576,8 @@ fn export_copylines_triangular(
                 locations: locs
                     .iter()
                     .map(|(r, c, _)| LocationExport {
-                        row: *r as i32, // 0-indexed - DO NOT change!
-                        col: *c as i32, // 0-indexed - DO NOT change!
+                        row: *r as i64, // 0-indexed - DO NOT change!
+                        col: *c as i64, // 0-indexed - DO NOT change!
                     })
                     .collect(),
             }
@@ -584,8 +605,8 @@ fn export_copylines_square(
                 locations: locs
                     .iter()
                     .map(|(r, c, _)| LocationExport {
-                        row: *r as i32, // 0-indexed - DO NOT change!
-                        col: *c as i32, // 0-indexed - DO NOT change!
+                        row: *r as i64, // 0-indexed - DO NOT change!
+                        col: *c as i64, // 0-indexed - DO NOT change!
                     })
                     .collect(),
             }
@@ -606,7 +627,8 @@ fn export_triangular_tape(
             gadget_idx: e.gadget_idx,
             row: e.row, // 0-indexed - DO NOT change!
             col: e.col, // 0-indexed - DO NOT change!
-            overhead: triangular::tape_entry_mis_overhead(e),
+            overhead: triangular::tape_entry_mis_overhead(e)
+                .expect("generated triangular tape must contain known gadgets"),
         })
         .collect()
 }
@@ -621,7 +643,8 @@ fn export_square_tape(tape: &[ksg::KsgTapeEntry], offset: usize) -> Vec<TapeEntr
             gadget_idx: e.pattern_idx,
             row: e.row, // 0-indexed - DO NOT change!
             col: e.col, // 0-indexed - DO NOT change!
-            overhead: ksg::tape_entry_mis_overhead(e),
+            overhead: ksg::tape_entry_mis_overhead(e)
+                .expect("generated KSG tape must contain known gadgets"),
         })
         .collect()
 }
@@ -639,7 +662,8 @@ fn export_weighted_square_tape(
             gadget_idx: e.pattern_idx,
             row: e.row, // 0-indexed - DO NOT change!
             col: e.col, // 0-indexed - DO NOT change!
-            overhead: ksg::weighted_tape_entry_mis_overhead(e),
+            overhead: ksg::weighted_tape_entry_mis_overhead(e)
+                .expect("generated weighted KSG tape must contain known gadgets"),
         })
         .collect()
 }
@@ -662,9 +686,9 @@ fn create_export(
     stage4: Vec<GridNodeExport>,
     crossing_tape: Vec<TapeEntryExport>,
     simplifier_tape: Vec<TapeEntryExport>,
-    copyline_overhead: i32,
-    crossing_overhead: i32,
-    simplifier_overhead: i32,
+    copyline_overhead: i64,
+    crossing_overhead: i64,
+    simplifier_overhead: i64,
 ) -> MappingExport {
     let mut export = MappingExport {
         graph_name: graph_name.to_string(),
diff --git a/examples/export_petersen_mapping.rs b/examples/export_petersen_mapping.rs
index d8a9ec56f..87753371e 100644
--- a/examples/export_petersen_mapping.rs
+++ b/examples/export_petersen_mapping.rs
@@ -47,7 +47,7 @@ struct SourceGraph {
 struct GridVisualization {
     nodes: Vec<NodeData>,
     edges: Vec<(usize, usize)>,
-    mis_overhead: i32,
+    mis_overhead: i64,
     padding: usize,
     spacing: usize,
     weighted: bool,
@@ -55,9 +55,9 @@ struct GridVisualization {
 
 #[derive(Serialize)]
 struct NodeData {
-    row: i32,
-    col: i32,
-    weight: i32,
+    row: i64,
+    col: i64,
+    weight: i64,
 }
 
 impl GridVisualization {
@@ -90,7 +90,7 @@ fn write_json<T: Serialize>(data: &T, path: &Path) {
     println!("  Wrote: {}", path.display());
 }
 
-fn main() {
+pub fn run(output_dir: &Path) {
     println!("\n=== Independent Set to Grid Graph IS (Unit Disk Mapping) ===\n");
 
     // Petersen graph: n=10, MIS=4
@@ -133,13 +133,13 @@ fn main() {
         edges: petersen_edges.clone(),
         mis: petersen_mis,
     };
-    write_json(&source, Path::new("docs/paper/static/petersen_source.json"));
+    write_json(&source, &output_dir.join("petersen_source.json"));
 
     println!("\n=== Mapping to Grid Graphs ===\n");
 
     // Map to weighted King's subgraph (square lattice)
     println!("1. King's Subgraph (Weighted)");
-    let square_weighted_result = ksg::map_weighted(num_vertices, &petersen_edges);
+    let square_weighted_result = ksg::map_weighted(num_vertices, &petersen_edges).unwrap();
     let square_weighted_viz = GridVisualization::from_result(&square_weighted_result, true);
     println!(
         "   Vertices: {}, Edges: {}",
@@ -151,16 +151,16 @@ fn main() {
         "   MIS(grid) = MIS(source) + Δ = {} + {} = {}",
         petersen_mis,
         square_weighted_result.mis_overhead,
-        petersen_mis as i32 + square_weighted_result.mis_overhead
+        petersen_mis as i64 + square_weighted_result.mis_overhead
     );
     write_json(
         &square_weighted_viz,
-        Path::new("docs/paper/static/petersen_square_weighted.json"),
+        &output_dir.join("petersen_square_weighted.json"),
     );
 
     // Map to unweighted King's subgraph (square lattice)
     println!("\n2. King's Subgraph (Unweighted)");
-    let square_unweighted_result = ksg::map_unweighted(num_vertices, &petersen_edges);
+    let square_unweighted_result = ksg::map_unweighted(num_vertices, &petersen_edges).unwrap();
     let square_unweighted_viz = GridVisualization::from_result(&square_unweighted_result, false);
     println!(
         "   Vertices: {}, Edges: {}",
@@ -175,16 +175,16 @@ fn main() {
         "   MIS(grid) = MIS(source) + Δ = {} + {} = {}",
         petersen_mis,
         square_unweighted_result.mis_overhead,
-        petersen_mis as i32 + square_unweighted_result.mis_overhead
+        petersen_mis as i64 + square_unweighted_result.mis_overhead
     );
     write_json(
         &square_unweighted_viz,
-        Path::new("docs/paper/static/petersen_square_unweighted.json"),
+        &output_dir.join("petersen_square_unweighted.json"),
     );
 
     // Map to weighted triangular lattice
     println!("\n3. Triangular Lattice (Weighted)");
-    let triangular_result = triangular::map_weighted(num_vertices, &petersen_edges);
+    let triangular_result = triangular::map_weighted(num_vertices, &petersen_edges).unwrap();
     let triangular_viz = GridVisualization::from_result(&triangular_result, true);
     println!(
         "   Vertices: {}, Edges: {}",
@@ -196,11 +196,11 @@ fn main() {
         "   MIS(grid) = MIS(source) + Δ = {} + {} = {}",
         petersen_mis,
         triangular_result.mis_overhead,
-        petersen_mis as i32 + triangular_result.mis_overhead
+        petersen_mis as i64 + triangular_result.mis_overhead
     );
     write_json(
         &triangular_viz,
-        Path::new("docs/paper/static/petersen_triangular.json"),
+        &output_dir.join("petersen_triangular.json"),
     );
 
     println!("\n=== Summary ===\n");
@@ -209,22 +209,26 @@ fn main() {
     println!(
         "King's subgraph (weighted):   {} vertices, MIS = {} (overhead Δ = {})",
         square_weighted_viz.nodes.len(),
-        petersen_mis as i32 + square_weighted_result.mis_overhead,
+        petersen_mis as i64 + square_weighted_result.mis_overhead,
         square_weighted_result.mis_overhead
     );
     println!(
         "King's subgraph (unweighted): {} vertices, MIS = {} (overhead Δ = {})",
         square_unweighted_viz.nodes.len(),
-        petersen_mis as i32 + square_unweighted_result.mis_overhead,
+        petersen_mis as i64 + square_unweighted_result.mis_overhead,
         square_unweighted_result.mis_overhead
     );
     println!(
         "Triangular lattice (weighted): {} vertices, MIS = {} (overhead Δ = {})",
         triangular_viz.nodes.len(),
-        petersen_mis as i32 + triangular_result.mis_overhead,
+        petersen_mis as i64 + triangular_result.mis_overhead,
         triangular_result.mis_overhead
     );
 
     println!("\n✓ Unit disk mapping demonstrated successfully");
     println!("  JSON files exported for paper visualization");
 }
+
+fn main() {
+    run(Path::new("docs/paper/static"));
+}
diff --git a/examples/export_schemas.rs b/examples/export_schemas.rs
index 19024dbb7..427386ca3 100644
--- a/examples/export_schemas.rs
+++ b/examples/export_schemas.rs
@@ -3,22 +3,25 @@
 //! Run with: `cargo run --example export_schemas [output_path]`
 
 use problemreductions::registry::collect_schemas;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
-fn main() {
+pub fn run(output_path: &Path) {
     let schemas = collect_schemas();
     println!("Collected {} problem schemas", schemas.len());
 
-    // Single source for both mdBook and paper
-    let output_path = std::env::args()
-        .nth(1)
-        .map(PathBuf::from)
-        .unwrap_or_else(|| PathBuf::from("docs/src/reductions/problem_schemas.json"));
     if let Some(parent) = output_path.parent() {
         std::fs::create_dir_all(parent).expect("Failed to create output directory");
     }
 
     let json = serde_json::to_string_pretty(&schemas).expect("Failed to serialize");
-    std::fs::write(&output_path, &json).expect("Failed to write file");
+    std::fs::write(output_path, &json).expect("Failed to write file");
     println!("Exported to: {}", output_path.display());
 }
+
+fn main() {
+    let output_path = std::env::args()
+        .nth(1)
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from("docs/src/reductions/problem_schemas.json"));
+    run(&output_path);
+}
diff --git a/problemreductions-cli/Cargo.toml b/problemreductions-cli/Cargo.toml
index 234f607fd..be37a9085 100644
--- a/problemreductions-cli/Cargo.toml
+++ b/problemreductions-cli/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2021"
 description = "CLI tool for exploring NP-hard problem reductions"
 license = "MIT"
 repository = "https://github.com/CodingThrust/problem-reductions"
+default-run = "pred"
 
 [[bin]]
 name = "pred"
@@ -15,16 +16,12 @@ name = "pred-sym"
 path = "src/bin/pred_sym.rs"
 
 [features]
-default = ["highs"]
-all = ["highs", "mcp"]
-highs = ["problemreductions/ilp-highs"]
+all = ["mcp"]
 mcp = ["dep:rmcp", "dep:tokio", "dep:schemars", "dep:tracing", "dep:tracing-subscriber"]
-cplex = ["problemreductions/ilp-cplex"]
-lp-solvers = ["problemreductions/ilp-lp-solvers"]
 
 [dependencies]
-problemreductions = { version = "0.6.0", path = "..", default-features = false, features = ["example-db"] }
-clap = { version = "4", features = ["derive"] }
+problemreductions = { version = "0.6.0", path = "..", features = ["example-db"] }
+clap = { version = "4", features = ["derive", "string"] }
 anyhow = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
diff --git a/problemreductions-cli/src/bin/pred_sym.rs b/problemreductions-cli/src/bin/pred_sym.rs
index daa28bf7a..28f7bdadb 100644
--- a/problemreductions-cli/src/bin/pred_sym.rs
+++ b/problemreductions-cli/src/bin/pred_sym.rs
@@ -1,5 +1,5 @@
 use clap::{Parser, Subcommand};
-use problemreductions::{big_o_normal_form, canonical_form, Expr, ProblemSize};
+use problemreductions::{big_o_normal_form, evaluate_approximate, Expr, ProblemParameters};
 
 #[derive(Parser)]
 #[command(
@@ -19,11 +19,6 @@ enum Commands {
         /// Expression string
         expr: String,
     },
-    /// Compute exact canonical form
-    Canon {
-        /// Expression string
-        expr: String,
-    },
     /// Compute Big-O normal form
     BigO {
         /// Expression string
@@ -33,7 +28,7 @@ enum Commands {
         #[arg(long)]
         raw: bool,
     },
-    /// Compare two expressions (exits with code 1 if neither exact nor Big-O equal)
+    /// Compare two expressions for Big-O equivalence (exits 1 if not equal)
     Compare {
         /// First expression
         a: String,
@@ -69,16 +64,6 @@ fn main() {
             let parsed = parse_expr_or_exit(&expr);
             println!("{parsed}");
         }
-        Commands::Canon { expr } => {
-            let parsed = parse_expr_or_exit(&expr);
-            match canonical_form(&parsed) {
-                Ok(result) => println!("{result}"),
-                Err(e) => {
-                    eprintln!("Error: {e}");
-                    std::process::exit(1);
-                }
-            }
-        }
         Commands::BigO { expr, raw } => {
             let parsed = parse_expr_or_exit(&expr);
             match big_o_normal_form(&parsed) {
@@ -98,49 +83,49 @@ fn main() {
         Commands::Compare { a, b } => {
             let expr_a = parse_expr_or_exit(&a);
             let expr_b = parse_expr_or_exit(&b);
-            let canon_a = canonical_form(&expr_a);
-            let canon_b = canonical_form(&expr_b);
             let big_o_a = big_o_normal_form(&expr_a);
             let big_o_b = big_o_normal_form(&expr_b);
 
             println!("Expression A: {a}");
             println!("Expression B: {b}");
-            let mut exact_equal = false;
-            let mut big_o_equal = false;
-            if let (Ok(ca), Ok(cb)) = (&canon_a, &canon_b) {
-                exact_equal = ca == cb;
-                println!("Canonical A:  {ca}");
-                println!("Canonical B:  {cb}");
-                println!("Exact equal:  {exact_equal}");
-            }
-            if let (Ok(ba), Ok(bb)) = (&big_o_a, &big_o_b) {
-                big_o_equal = ba == bb;
-                println!("Big-O A:      O({ba})");
-                println!("Big-O B:      O({bb})");
-                println!("Big-O equal:  {big_o_equal}");
-            }
-            if !exact_equal && !big_o_equal {
-                std::process::exit(1);
+            match (&big_o_a, &big_o_b) {
+                (Ok(ba), Ok(bb)) => {
+                    // Rendering is canonical, so equal growth ⇒ equal Big-O expr.
+                    let big_o_equal = ba == bb;
+                    println!("Big-O A:      O({ba})");
+                    println!("Big-O B:      O({bb})");
+                    println!("Big-O equal:  {big_o_equal}");
+                    if !big_o_equal {
+                        std::process::exit(1);
+                    }
+                }
+                _ => {
+                    if let Err(e) = &big_o_a {
+                        println!("Big-O A:      <unsupported: {e}>");
+                    }
+                    if let Err(e) = &big_o_b {
+                        println!("Big-O B:      <unsupported: {e}>");
+                    }
+                    std::process::exit(1);
+                }
             }
         }
         Commands::Eval { expr, vars } => {
             let parsed = parse_expr_or_exit(&expr);
-            let bindings: Vec<(&str, usize)> = vars
+            let bindings: Vec<(String, u64)> = vars
                 .split(',')
                 .filter_map(|pair| {
                     let mut parts = pair.splitn(2, '=');
                     let name = parts.next()?.trim();
-                    let value: usize = parts.next()?.trim().parse().ok()?;
-                    // Leak the name for &'static str compatibility
-                    let leaked: &'static str = Box::leak(name.to_string().into_boxed_str());
-                    Some((leaked, value))
+                    let value: u64 = parts.next()?.trim().parse().ok()?;
+                    Some((name.to_string(), value))
                 })
                 .collect();
 
             // Check for unbound variables
             let expr_vars = parsed.variables();
             let bound_vars: std::collections::HashSet<&str> =
-                bindings.iter().map(|(k, _)| *k).collect();
+                bindings.iter().map(|(name, _)| name.as_str()).collect();
             let mut unbound: Vec<&str> = expr_vars
                 .iter()
                 .filter(|v| !bound_vars.contains(*v))
@@ -156,8 +141,11 @@ fn main() {
                 std::process::exit(1);
             }
 
-            let size = ProblemSize::new(bindings);
-            let result = parsed.eval(&size);
+            let parameters = ProblemParameters::from_owned(bindings);
+            let result = evaluate_approximate(&parsed, &parameters).unwrap_or_else(|error| {
+                eprintln!("Error: {error}");
+                std::process::exit(1);
+            });
 
             // Format as integer if it's a whole number
             if (result - result.round()).abs() < 1e-10 {
diff --git a/problemreductions-cli/src/cli.rs b/problemreductions-cli/src/cli.rs
index 70fa1e5af..dd1518a1b 100644
--- a/problemreductions-cli/src/cli.rs
+++ b/problemreductions-cli/src/cli.rs
@@ -1,7 +1,10 @@
-use clap::{CommandFactory, Parser, Subcommand, ValueEnum};
-use std::collections::HashMap;
+use clap::{CommandFactory, FromArgMatches, Parser, Subcommand, ValueEnum};
+use problemreductions::registry::ProblemCategory;
+use std::ffi::OsString;
 use std::path::PathBuf;
 
+pub use crate::create_args::CreateArgs;
+
 #[derive(Parser)]
 #[command(
     name = "pred",
@@ -11,13 +14,13 @@ use std::path::PathBuf;
 Typical workflow:
   pred create MIS --graph 0-1,1-2,2-3 -o problem.json
   pred solve problem.json
-  pred evaluate problem.json --config 1,0,1,0
+  pred evaluate problem.json --config '[true,false,true,false]'
 
 Piping (use - to read from stdin):
-  pred create MIS --graph 0-1,1-2 | pred solve -                    # when an ILP reduction path exists
+  pred create MIS --graph 0-1,1-2 | pred solve -
   pred create StringToStringCorrection --source-string \"0,1,2,3,1,0\" --target-string \"0,1,3,2,1\" --bound 2 | pred solve - --solver brute-force
-  pred create MIS --graph 0-1,1-2 | pred evaluate - --config 1,0,1
-  pred create MIS --graph 0-1,1-2 | pred reduce - --to QUBO
+  pred create MIS --graph 0-1,1-2 | pred evaluate - --config '[true,false,true]'
+  pred create MIS --graph 0-1,1-2 | pred reduce - --via route.json
 
 JSON output (any command):
   pred list --json                 # JSON to stdout
@@ -46,18 +49,65 @@ pub struct Cli {
     pub command: Commands,
 }
 
+impl Cli {
+    pub fn try_parse() -> Result<Self, clap::Error> {
+        Self::try_parse_from(std::env::args_os())
+    }
+
+    pub fn try_parse_from<I, T>(args: I) -> Result<Self, clap::Error>
+    where
+        I: IntoIterator<Item = T>,
+        T: Into<OsString>,
+    {
+        // The discovery command treats the problem spec as an external subcommand,
+        // so it can capture the selected model without registering the whole catalog.
+        let args = args.into_iter().map(Into::into).collect::<Vec<_>>();
+        let command = <Self as CommandFactory>::command();
+        let discovery_matches = command.clone().try_get_matches_from(args.clone())?;
+        let selected = discovery_matches
+            .subcommand_matches("create")
+            .and_then(|matches| matches.subcommand_name());
+
+        let mut matches = if let Some(selected) = selected {
+            crate::create_args::command_for_selected_problem(command, selected)?
+                .try_get_matches_from(args)?
+        } else {
+            discovery_matches
+        };
+        Self::from_arg_matches_mut(&mut matches)
+    }
+}
+
 #[derive(Subcommand)]
 pub enum Commands {
-    /// List all registered problem types (or reduction rules with --rules)
+    /// Browse registered problem types (or reduction rules with --rules)
     #[command(after_help = "\
 Examples:
-  pred list                   # list problem types
-  pred list --rules           # list all reduction rules
+  pred list                   # show catalog summary and categories
+  pred list matching          # search names and aliases
+  pred list --category graph  # list graph problems
+  pred list --all             # list every problem compactly
+  pred list --rules --all     # list every reduction rule
   pred list -o problems.json  # save as JSON")]
     List {
+        /// Case-insensitive substring to search in names and aliases
+        query: Option<String>,
+
         /// List reduction rules instead of problem types
         #[arg(long)]
         rules: bool,
+
+        /// Restrict problems to a model category such as graph, set, or misc
+        #[arg(long, conflicts_with = "rules")]
+        category: Option<ProblemCategory>,
+
+        /// List the complete catalog instead of the summary
+        #[arg(long)]
+        all: bool,
+
+        /// Include per-variant complexity, rule counts, or rule parameter contracts
+        #[arg(long)]
+        verbose: bool,
     },
 
     /// Show details for a problem type or variant (fields, reductions, complexity)
@@ -65,7 +115,7 @@ Examples:
 Examples:
   pred show MIS                   # all variants for MIS
   pred show MIS/UnitDiskGraph     # specific variant
-  pred show MIS/UnitDiskGraph/i32 # fully qualified variant
+  pred show MIS/UnitDiskGraph/i64 # fully qualified variant
   pred show KSAT/K3               # KSatisfiability with K=3
 
 Use `pred list` to see all available problem types and variants.")]
@@ -109,14 +159,14 @@ Use `pred to <problem>` for incoming neighbors (what reduces to this).")]
         hops: usize,
     },
 
-    /// Find the cheapest reduction path between two problems
+    /// Find reduction paths between two problems
     #[command(after_help = "\
 Examples:
-  pred path MIS QUBO                              # cheapest path
-  pred path MIS QUBO --all                        # all paths
-  pred path MIS QUBO -o path.json                 # save for `pred reduce --via`
-  pred path MIS QUBO --all -o paths/              # save all paths to a folder
-  pred path MIS QUBO --cost minimize:num_variables
+  pred path MIS QUBO                              # inspect reduction paths
+  pred path MIS Clique mis.json                   # execute paths on an instance
+  pred path MIS QUBO --limit 50                  # inspect the first 50 paths
+  pred path MIS QUBO --limit all                 # inspect up to 999 paths
+  pred path MIS QUBO -o paths.json               # save the path set
 
 Use `pred list` to see available problems.")]
     Path {
@@ -126,15 +176,15 @@ Use `pred list` to see available problems.")]
         /// Target problem (e.g., QUBO)
         #[arg(value_parser = crate::problem_name::ProblemNameParser)]
         target: String,
-        /// Cost function [default: minimize-steps]
-        #[arg(long, default_value = "minimize-steps")]
-        cost: String,
-        /// Show all paths instead of just the cheapest
-        #[arg(long)]
-        all: bool,
-        /// Maximum paths to return in --all mode
-        #[arg(long, default_value_t = 20)]
-        max_paths: usize,
+        /// Number of paths to inspect (1-999, or "all" as an alias for 999)
+        #[arg(
+            long,
+            default_value = "20",
+            value_parser = crate::commands::graph::parse_path_limit
+        )]
+        limit: usize,
+        /// Source problem instance JSON. When present, execute every returned path and measure each constructed problem.
+        instance: Option<std::path::PathBuf>,
     },
 
     /// Export the reduction graph to JSON
@@ -162,9 +212,9 @@ Examples:
     /// Extract a source-space solution from a reduction bundle and a target-space config
     #[command(after_help = "\
 Examples:
-  pred extract bundle.json --config 1,0,1,0
-  pred extract bundle.json --config 1,0,1,0 -o source.json
-  cat bundle.json | pred extract - --config 1,0,1,0
+  pred extract bundle.json --config '[1,0,1,0]'
+  pred extract bundle.json --config '[1,0,1,0]' -o source.json
+  cat bundle.json | pred extract - --config '[1,0,1,0]'
 
 Use this when an external solver has solved the bundle's target problem
 (e.g. a QUBO sampler, a neutral-atom platform, a QAOA runtime) and you want
@@ -172,7 +222,7 @@ the corresponding solution in the original source problem space without
 having to shell back into `pred solve`.
 
 Input: a reduction bundle JSON (from `pred reduce`). Use - to read from stdin.
---config is the target-space configuration (comma-separated, e.g. 1,0,1,0).")]
+--config is the target problem's solution encoded as JSON (e.g. '[1,0,1,0]').")]
     Extract(ExtractArgs),
     /// Start MCP (Model Context Protocol) server for AI assistant integration
     #[cfg(feature = "mcp")]
@@ -227,1008 +277,17 @@ pub enum ExampleSide {
 
 #[derive(clap::Args)]
 #[command(after_help = "\
-TIP: Run `pred create <PROBLEM>` (no other flags) to see problem-specific help.
-     Not every flag applies to every problem — the above list shows ALL flags.
-
-Flags by problem type:
-  MIS, MVC, MaxClique, MinDomSet  --graph, --weights
-  MaxCut, MaxMatching, TSP, BottleneckTravelingSalesman --graph, --edge-weights
-  LongestPath                     --graph, --edge-lengths, --source-vertex, --target-vertex
-  HamiltonianPathBetweenTwoVertices --graph, --source-vertex, --target-vertex
-  ShortestWeightConstrainedPath   --graph, --edge-lengths, --edge-weights, --source-vertex, --target-vertex, --weight-bound
-  GraphPartitioning               --graph, --num-partitions
-  MaximalIS                       --graph, --weights
-  SAT, NAESAT                     --num-vars, --clauses
-  KSAT                            --num-vars, --clauses [--k]
-  NonTautology                    --num-vars, --disjuncts
-  QUBO                            --matrix
-  SpinGlass                       --graph, --couplings, --fields
-  KColoring                       --graph, --k
-  KClique                         --graph, --k
-  DecisionMinimumVertexCover      --graph, --weights, --bound
-  MinimumMultiwayCut              --graph, --terminals, --edge-weights
-  MonochromaticTriangle           --graph
-  PartitionIntoTriangles          --graph
-  GeneralizedHex                  --graph, --source, --sink
-  IntegralFlowWithMultipliers     --arcs, --capacities, --source, --sink, --multipliers, --requirement
-  MinimumEdgeCostFlow             --arcs, --edge-weights (prices), --capacities, --source, --sink, --requirement
-  MinimumCostMaximumFlow          --arcs, --capacities, --costs, --source, --sink
-  MinimumCostCirculation, MCC     --arcs, --capacities, --costs
-  MinimumCutIntoBoundedSets       --graph, --edge-weights, --source, --sink, --size-bound
-  HamiltonianCircuit, HC          --graph
-  MaximumLeafSpanningTree         --graph
-  LongestCircuit                  --graph, --edge-weights
-  BoundedComponentSpanningForest  --graph, --weights, --k, --max-weight
-  UndirectedFlowLowerBounds       --graph, --capacities, --lower-bounds, --source, --sink, --requirement
-  IntegralFlowBundles             --arcs, --bundles, --bundle-capacities, --source, --sink, --requirement [--num-vertices]
-  UndirectedTwoCommodityIntegralFlow --graph, --capacities, --source-1, --sink-1, --source-2, --sink-2, --requirement-1, --requirement-2
-  DisjointConnectingPaths         --graph, --terminal-pairs
-  IntegralFlowHomologousArcs      --arcs, --capacities, --source, --sink, --requirement, --homologous-pairs
-  IsomorphicSpanningTree          --graph, --tree
-  KthBestSpanningTree             --graph, --edge-weights, --k, --bound
-  LengthBoundedDisjointPaths      --graph, --source, --sink, --max-length
-  PathConstrainedNetworkFlow      --arcs, --capacities, --source, --sink, --paths, --requirement
-  Factoring                       --target, --m, --n
-  BinPacking                      --sizes, --capacity
-  Clustering                      --distance-matrix, --k, --diameter-bound
-  CapacityAssignment              --capacities, --cost-matrix, --delay-matrix, --cost-budget, --delay-budget
-  ProductionPlanning             --num-periods, --demands, --capacities, --setup-costs, --production-costs, --inventory-costs, --cost-bound
-  SubsetProduct                    --sizes, --target
-  SubsetSum                       --sizes, --target
-  MinimumAxiomSet                 --n, --true-sentences, --implications
-  Numerical3DimensionalMatching    --w-sizes, --x-sizes, --y-sizes, --bound
-  Betweenness                     --n, --sets (triples a,b,c)
-  CyclicOrdering                  --n, --sets (triples a,b,c)
-  ThreePartition                  --sizes, --bound
-  DynamicStorageAllocation        --release-times, --deadlines, --sizes, --capacity
-  KthLargestMTuple                --sets, --k, --bound
-  QuadraticCongruences             --coeff-a, --coeff-b, --coeff-c
-  QuadraticDiophantineEquations    --coeff-a, --coeff-b, --coeff-c
-  SimultaneousIncongruences        --pairs (semicolon-separated a,b pairs)
-  SumOfSquaresPartition           --sizes, --num-groups
-  ExpectedRetrievalCost           --probabilities, --num-sectors
-  PaintShop                       --sequence
-  MaximumSetPacking               --subsets [--weights]
-  MinimumHittingSet               --universe-size, --subsets
-  MinimumSetCovering              --universe-size, --subsets [--weights]
-  EnsembleComputation             --universe-size, --subsets, --budget
-  ComparativeContainment          --universe-size, --r-sets, --s-sets [--r-weights] [--s-weights]
-  X3C (ExactCoverBy3Sets)         --universe-size, --subsets (3 elements each)
-  3DM (ThreeDimensionalMatching)  --universe-size, --subsets (triples w,x,y)
-  ThreeMatroidIntersection        --universe-size, --partitions, --bound
-  SetBasis                        --universe-size, --subsets, --k
-  MinimumCardinalityKey           --num-attributes, --dependencies
-  PrimeAttributeName              --universe-size, --dependencies, --query-attribute
-  RootedTreeStorageAssignment     --universe-size, --subsets, --bound
-  TwoDimensionalConsecutiveSets   --alphabet-size, --subsets
-  BicliqueCover                   --left, --right, --biedges, --k
-  BalancedCompleteBipartiteSubgraph --left, --right, --biedges, --k
-  BiconnectivityAugmentation      --graph, --potential-weights, --budget [--num-vertices]
-  PartialFeedbackEdgeSet          --graph, --budget, --max-cycle-length [--num-vertices]
-  BMF                             --matrix (0/1), --rank
-  ConsecutiveBlockMinimization    --matrix (JSON 2D bool), --bound-k
-  ConsecutiveOnesMatrixAugmentation --matrix (0/1), --bound
-  ConsecutiveOnesSubmatrix        --matrix (0/1), --k
-  SparseMatrixCompression         --matrix (0/1), --bound
-  MaximumLikelihoodRanking        --matrix (i32 rows, semicolon-separated)
-  MinimumMatrixCover              --matrix (i64 rows, semicolon-separated)
-  MinimumWeightDecoding           --matrix (JSON 2D bool), --rhs (comma-separated booleans)
-  FeasibleBasisExtension          --matrix (JSON 2D i64), --rhs, --required-columns
-  SteinerTree                     --graph, --edge-weights, --terminals
-  MultipleCopyFileAllocation      --graph, --usage, --storage
-  AcyclicPartition                --arcs [--weights] [--arc-weights] --weight-bound --cost-bound [--num-vertices]
-  CVP                             --basis, --target-vec [--bounds]
-  MultiprocessorScheduling        --lengths, --num-processors, --deadline
-  SchedulingToMinimizeWeightedCompletionTime  --lengths, --weights, --num-processors
-  SequencingWithinIntervals       --release-times, --deadlines, --lengths
-  OptimalLinearArrangement        --graph
-  RootedTreeArrangement           --graph, --bound
-  MinMaxMulticenter (pCenter)     --graph, --weights, --edge-weights, --k
-  MixedChinesePostman (MCPP)      --graph, --arcs, --edge-weights, --arc-weights [--num-vertices]
-  RuralPostman (RPP)              --graph, --edge-weights, --required-edges
-  StackerCrane                    --arcs, --graph, --arc-lengths, --edge-lengths [--num-vertices]
-  MultipleChoiceBranching         --arcs [--weights] --partition --threshold [--num-vertices]
-  AdditionalKey                   --num-attributes, --dependencies, --relation-attrs [--known-keys]
-  ConsistencyOfDatabaseFrequencyTables --num-objects, --attribute-domains, --frequency-tables [--known-values]
-  SubgraphIsomorphism             --graph (host), --pattern (pattern)
-  GroupingBySwapping             --string, --bound [--alphabet-size]
-  LCS                             --strings [--alphabet-size]
-  ClosestString                   --alphabet-size, --strings
-  ClosestSubstring                --alphabet-size, --strings, --substring-length
-  FAS                             --arcs [--weights] [--num-vertices]
-  FVS                             --arcs [--weights] [--num-vertices]
-  QBF                             --num-vars, --clauses, --quantifiers
-  SteinerTreeInGraphs             --graph, --edge-weights, --terminals
-  PartitionIntoPathsOfLength2     --graph
-  ResourceConstrainedScheduling   --num-processors, --resource-bounds, --resource-requirements, --deadline
-  IntegerKnapsack                 --sizes, --values, --capacity
-  PartiallyOrderedKnapsack        --sizes, --values, --capacity, --precedences
-  QAP                             --matrix (cost), --distance-matrix
-  StrongConnectivityAugmentation  --arcs, --candidate-arcs, --bound [--num-vertices]
-  JobShopScheduling               --jobs [--num-processors]
-  FlowShopScheduling              --task-lengths, --deadline [--num-processors]
-  StaffScheduling                 --schedules, --requirements, --num-workers, --k
-  TimetableDesign                 --num-periods, --num-craftsmen, --num-tasks, --craftsman-avail, --task-avail, --requirements
-  MinimumTardinessSequencing      --num-tasks, --deadlines [--precedences]
-  RectilinearPictureCompression   --matrix (0/1), --k
-  SchedulingWithIndividualDeadlines --num-tasks, --num-processors/--m, --deadlines [--precedences]
-  SequencingToMinimizeMaximumCumulativeCost --costs [--precedences]
-  SequencingToMinimizeTardyTaskWeight --lengths, --weights, --deadlines
-  SequencingToMinimizeWeightedCompletionTime --lengths, --weights [--precedences]
-  SequencingToMinimizeWeightedTardiness --lengths, --weights, --deadlines, --bound
-  SequencingWithDeadlinesAndSetUpTimes --lengths, --deadlines, --compilers, --setup-times
-  MinimumExternalMacroDataCompression --string, --pointer-cost [--alphabet-size]
-  MinimumInternalMacroDataCompression --string, --pointer-cost [--alphabet-size]
-  SCS                             --strings [--alphabet-size]
-  StringToStringCorrection         --source-string, --target-string, --bound [--alphabet-size]
-  D2CIF                           --arcs, --capacities, --source-1, --sink-1, --source-2, --sink-2, --requirement-1, --requirement-2
-  MinimumDummyActivitiesPert      --arcs [--num-vertices]
-  FeasibleRegisterAssignment      --arcs, --assignment, --k [--num-vertices]
-  MinimumFaultDetectionTestSet    --arcs, --inputs, --outputs [--num-vertices]
-  MinimumWeightAndOrGraph         --arcs, --source, --gate-types, --weights [--num-vertices]
-  MinimumCodeGenerationOneRegister --arcs [--num-vertices]
-  MinimumCodeGenerationParallelAssignments --num-variables, --assignments
-  MinimumCodeGenerationUnlimitedRegisters --left-arcs, --right-arcs [--num-vertices]
-  MinimumRegisterSufficiencyForLoops --loop-length, --loop-variables
-  RegisterSufficiency             --arcs, --bound [--num-vertices]
-  CBQ                              --domain-size, --relations, --conjuncts-spec
-  IntegerExpressionMembership     --expression (JSON), --target
-  MinimumGeometricConnectedDominatingSet --positions (float x,y pairs), --radius
-  MinimumDecisionTree             --test-matrix (JSON 2D bool), --num-objects, --num-tests
-  MinimumDisjunctiveNormalForm (MinDNF) --num-vars, --truth-table
-  SquareTiling (WangTiling)       --num-colors, --tiles, --grid-size
-  ILP, CircuitSAT                 (via reduction only)
-
-Geometry graph variants (use slash notation, e.g., MIS/KingsSubgraph):
-  KingsSubgraph, TriangularSubgraph   --positions (integer x,y pairs)
-  UnitDiskGraph                        --positions (float x,y pairs) [--radius]
-
-Random generation:
-  --random --num-vertices N [--edge-prob 0.5] [--seed 42]
-
 Examples:
-  pred create --example MIS/SimpleGraph/i32
-  pred create --example MVC/SimpleGraph/i32 --to MIS/SimpleGraph/i32
-  pred create --example MVC/SimpleGraph/i32 --to MIS/SimpleGraph/i32 --example-side target
-  pred create MIS --graph 0-1,1-2,2-3 --weights 1,1,1
-  pred create SAT --num-vars 3 --clauses \"1,2;-1,3\"
-  pred create NonTautology --num-vars 3 --disjuncts \"1,2,3;-1,-2,-3\"
-  pred create QUBO --matrix \"1,0.5;0.5,2\"
-  pred create CapacityAssignment --capacities 1,2,3 --cost-matrix \"1,3,6;2,4,7;1,2,5\" --delay-matrix \"8,4,1;7,3,1;6,3,1\" --cost-budget 10 --delay-budget 12
-  pred create ProductionPlanning --num-periods 6 --demands 5,3,7,2,8,5 --capacities 12,12,12,12,12,12 --setup-costs 10,10,10,10,10,10 --production-costs 1,1,1,1,1,1 --inventory-costs 1,1,1,1,1,1 --cost-bound 80
-  pred create GeneralizedHex --graph 0-1,0-2,0-3,1-4,2-4,3-4,4-5 --source 0 --sink 5
-  pred create IntegralFlowWithMultipliers --arcs \"0>1,0>2,1>3,2>3\" --capacities 1,1,2,2 --source 0 --sink 3 --multipliers 1,2,3,1 --requirement 2
-  pred create MultipleChoiceBranching/i32 --arcs \"0>1,0>2,1>3,2>3,1>4,3>5,4>5,2>4\" --weights 3,2,4,1,2,3,1,3 --partition \"0,1;2,3;4,7;5,6\" --bound 10
-  pred create GroupingBySwapping --string \"0,1,2,0,1,2\" --bound 5 | pred solve - --solver brute-force
-  pred create StringToStringCorrection --source-string \"0,1,2,3,1,0\" --target-string \"0,1,3,2,1\" --bound 2 | pred solve - --solver brute-force
-  pred create MIS/KingsSubgraph --positions \"0,0;1,0;1,1;0,1\"
-  pred create MIS/UnitDiskGraph --positions \"0,0;1,0;0.5,0.8\" --radius 1.5
-  pred create MIS --random --num-vertices 10 --edge-prob 0.3
-  pred create MultiprocessorScheduling --lengths 4,5,3,2,6 --num-processors 2 --deadline 10
-  pred create SchedulingToMinimizeWeightedCompletionTime --lengths 1,2,3,4,5 --weights 6,4,3,2,1 --num-processors 2
-  pred create UndirectedFlowLowerBounds --graph 0-1,0-2,1-3,2-3,1-4,3-5,4-5 --capacities 2,2,2,2,1,3,2 --lower-bounds 1,1,0,0,1,0,1 --source 0 --sink 5 --requirement 3
-  pred create ConsistencyOfDatabaseFrequencyTables --num-objects 6 --attribute-domains \"2,3,2\" --frequency-tables \"0,1:1,1,1|1,1,1;1,2:1,1|0,2|1,1\" --known-values \"0,0,0;3,0,1;1,2,1\"
-  pred create BiconnectivityAugmentation --graph 0-1,1-2,2-3 --potential-weights 0-2:3,0-3:4,1-3:2 --budget 5
-  pred create FVS --arcs \"0>1,1>2,2>0\" --weights 1,1,1
-  pred create MinimumDummyActivitiesPert --arcs \"0>2,0>3,1>3,1>4,2>5\" --num-vertices 6
-  pred create UndirectedTwoCommodityIntegralFlow --graph 0-2,1-2,2-3 --capacities 1,1,2 --source-1 0 --sink-1 3 --source-2 1 --sink-2 3 --requirement-1 1 --requirement-2 1
-  pred create IntegralFlowHomologousArcs --arcs \"0>1,0>2,1>3,2>3,1>4,2>4,3>5,4>5\" --capacities 1,1,1,1,1,1,1,1 --source 0 --sink 5 --requirement 2 --homologous-pairs \"2=5;4=3\"
-  pred create X3C --universe 9 --subsets \"0,1,2;0,2,4;3,4,5;3,5,7;6,7,8;1,4,6;2,5,8\"
-  pred create SetBasis --universe 4 --subsets \"0,1;1,2;0,2;0,1,2\" --k 3
-  pred create MinimumCardinalityKey --num-attributes 6 --dependencies \"0,1>2;0,2>3;1,3>4;2,4>5\"
-  pred create PrimeAttributeName --universe 6 --dependencies \"0,1>2,3,4,5;2,3>0,1,4,5\" --query-attribute 3
-  pred create TwoDimensionalConsecutiveSets --alphabet-size 6 --subsets \"0,1,2;3,4,5;1,3;2,4;0,5\"")]
-pub struct CreateArgs {
-    /// Problem type (e.g., MIS, QUBO, SAT). Omit when using --example.
-    #[arg(value_parser = crate::problem_name::ProblemNameParser)]
-    pub problem: Option<String>,
-    /// Build a problem from the canonical example database using a structural problem spec.
-    #[arg(long, value_parser = crate::problem_name::ProblemNameParser)]
-    pub example: Option<String>,
-    /// Target problem spec for canonical rule example lookup.
-    #[arg(long = "to", value_parser = crate::problem_name::ProblemNameParser)]
-    pub example_target: Option<String>,
-    /// Which side of a rule example to emit [default: source].
-    #[arg(long, value_enum, default_value = "source")]
-    pub example_side: ExampleSide,
-    /// Graph edge list (e.g., 0-1,1-2,2-3)
-    #[arg(long)]
-    pub graph: Option<String>,
-    /// Vertex weights (e.g., 1,1,1,1) [default: all 1s]
-    #[arg(long)]
-    pub weights: Option<String>,
-    /// Edge weights (e.g., 2,3,1) [default: all 1s]
-    #[arg(long)]
-    pub edge_weights: Option<String>,
-    /// Edge lengths (e.g., 2,3,1) [default: all 1s]
-    #[arg(long)]
-    pub edge_lengths: Option<String>,
-    /// Capacities (edge capacities for flow problems, capacity levels for CapacityAssignment)
-    #[arg(long)]
-    pub capacities: Option<String>,
-    /// Demands for ProductionPlanning (comma-separated, e.g., "5,3,7,2,8,5")
-    #[arg(long)]
-    pub demands: Option<String>,
-    /// Setup costs for ProductionPlanning (comma-separated, e.g., "10,10,10,10,10,10")
-    #[arg(long)]
-    pub setup_costs: Option<String>,
-    /// Per-unit production costs for ProductionPlanning (comma-separated, e.g., "1,1,1,1,1,1")
-    #[arg(long)]
-    pub production_costs: Option<String>,
-    /// Per-unit inventory costs for ProductionPlanning (comma-separated, e.g., "1,1,1,1,1,1")
-    #[arg(long)]
-    pub inventory_costs: Option<String>,
-    /// Bundle capacities for IntegralFlowBundles (e.g., 1,1,1)
-    #[arg(long)]
-    pub bundle_capacities: Option<String>,
-    /// Cost matrix for CapacityAssignment (semicolon-separated rows, e.g., "1,3,6;2,4,7")
-    #[arg(long)]
-    pub cost_matrix: Option<String>,
-    /// Delay matrix for CapacityAssignment (semicolon-separated rows, e.g., "8,4,1;7,3,1")
-    #[arg(long)]
-    pub delay_matrix: Option<String>,
-    /// Edge lower bounds for lower-bounded flow problems (e.g., 1,1,0,0,1,0,1)
-    #[arg(long)]
-    pub lower_bounds: Option<String>,
-    /// Vertex multipliers in vertex order (e.g., 1,2,3,1)
-    #[arg(long)]
-    pub multipliers: Option<String>,
-    /// Source vertex for path-based graph problems and MinimumCutIntoBoundedSets
-    #[arg(long)]
-    pub source: Option<usize>,
-    /// Sink vertex for path-based graph problems and MinimumCutIntoBoundedSets
-    #[arg(long)]
-    pub sink: Option<usize>,
-    /// Required total flow R for IntegralFlowBundles, IntegralFlowHomologousArcs, IntegralFlowWithMultipliers, PathConstrainedNetworkFlow, and UndirectedFlowLowerBounds
-    #[arg(long)]
-    pub requirement: Option<u64>,
-    /// Required number of paths for LengthBoundedDisjointPaths
-    #[arg(long)]
-    pub num_paths_required: Option<usize>,
-    /// Prescribed directed s-t paths as semicolon-separated arc-index sequences (e.g., "0,2,5;1,4,6")
-    #[arg(long)]
-    pub paths: Option<String>,
-    /// Pairwise couplings J_ij for SpinGlass (e.g., 1,-1,1) [default: all 1s]
-    #[arg(long)]
-    pub couplings: Option<String>,
-    /// On-site fields h_i for SpinGlass (e.g., 0,0,1) [default: all 0s]
-    #[arg(long)]
-    pub fields: Option<String>,
-    /// Clauses for SAT problems (semicolon-separated, e.g., "1,2;-1,3")
-    #[arg(long)]
-    pub clauses: Option<String>,
-    /// Disjuncts for NonTautology (semicolon-separated, e.g., "1,2;-1,3")
-    #[arg(long)]
-    pub disjuncts: Option<String>,
-    /// Number of variables (for SAT/KSAT)
-    #[arg(long)]
-    pub num_vars: Option<usize>,
-    /// Matrix input. QUBO uses semicolon-separated numeric rows ("1,0.5;0.5,2");
-    /// ConsecutiveBlockMinimization uses a JSON 2D bool array ('[[true,false],[false,true]]')
-    #[arg(long)]
-    pub matrix: Option<String>,
-    /// Shared integer parameter (use `pred create <PROBLEM>` for the problem-specific meaning)
-    #[arg(long)]
-    pub k: Option<usize>,
-    /// Number of partitions for GraphPartitioning (currently must be 2)
-    #[arg(long)]
-    pub num_partitions: Option<usize>,
-    /// Generate a random instance (graph-based problems only)
-    #[arg(long)]
-    pub random: bool,
-    /// Number of vertices for random graph generation
-    #[arg(long)]
-    pub num_vertices: Option<usize>,
-    /// Source vertex for path problems
-    #[arg(long)]
-    pub source_vertex: Option<usize>,
-    /// Target vertex for path problems
-    #[arg(long)]
-    pub target_vertex: Option<usize>,
-    /// Edge probability for random graph generation (0.0 to 1.0) [default: 0.5]
-    #[arg(long)]
-    pub edge_prob: Option<f64>,
-    /// Random seed for reproducibility
-    #[arg(long)]
-    pub seed: Option<u64>,
-    /// Target value (for Factoring, SubsetSum, and SubsetProduct)
-    #[arg(long)]
-    pub target: Option<String>,
-    /// Bits for first factor (for Factoring); also accepted as a processor-count alias for scheduling create commands
-    #[arg(long)]
-    pub m: Option<usize>,
-    /// Bits for second factor (for Factoring)
-    #[arg(long)]
-    pub n: Option<usize>,
-    /// Vertex positions for geometry-based graphs (semicolon-separated x,y pairs, e.g., "0,0;1,0;1,1")
-    #[arg(long)]
-    pub positions: Option<String>,
-    /// Radius for UnitDiskGraph [default: 1.0]
-    #[arg(long)]
-    pub radius: Option<f64>,
-    /// Source vertex s_1 for commodity 1
-    #[arg(long)]
-    pub source_1: Option<usize>,
-    /// Sink vertex t_1 for commodity 1
-    #[arg(long)]
-    pub sink_1: Option<usize>,
-    /// Source vertex s_2 for commodity 2
-    #[arg(long)]
-    pub source_2: Option<usize>,
-    /// Sink vertex t_2 for commodity 2
-    #[arg(long)]
-    pub sink_2: Option<usize>,
-    /// Required flow R_1 for commodity 1
-    #[arg(long)]
-    pub requirement_1: Option<u64>,
-    /// Required flow R_2 for commodity 2
-    #[arg(long)]
-    pub requirement_2: Option<u64>,
-    /// Item sizes for BinPacking (comma-separated, e.g., "3,3,2,2")
-    #[arg(long)]
-    pub sizes: Option<String>,
-    /// Record access probabilities for ExpectedRetrievalCost (comma-separated, e.g., "0.2,0.15,0.15,0.2,0.1,0.2")
-    #[arg(long)]
-    pub probabilities: Option<String>,
-    /// Link lengths for MinimumDiscretePlanarInverseKinematics (comma-separated positive reals, e.g., "2.0,1.0")
-    #[arg(long)]
-    pub link_lengths: Option<String>,
-    /// Target point (x,y) for MinimumDiscretePlanarInverseKinematics (e.g., "2.0,1.0")
-    #[arg(long)]
-    pub target_point: Option<String>,
-    /// Sampled absolute orientations per link for MinimumDiscretePlanarInverseKinematics (semicolon-separated angle lists, e.g., "0.0,1.5707963267948966;0.0,1.5707963267948966")
-    #[arg(long)]
-    pub orientation_samples: Option<String>,
-    /// Admissible (a_{j-1}, a_j) pair sets per junction for MinimumDiscretePlanarInverseKinematics (pipe-separated junctions, each comma-separated "i-j" pairs, e.g., "0-0,0-1,1-1")
-    #[arg(long)]
-    pub allowed_pairs: Option<String>,
-    /// Source labelled digraph G1 for MaximumCommonEdgeSubgraph. Format: "<num_vertices>:<arc1>,<arc2>,..." with each arc "<src>-<label>-<dst>" (e.g., "5:0-0-1,1-1-2,0-2-2,2-0-3,1-3-3,3-1-4")
-    #[arg(long = "graph-1")]
-    pub graph_1: Option<String>,
-    /// Target labelled digraph G2 for MaximumCommonEdgeSubgraph. Same format as --graph-1 (e.g., "4:0-0-1,1-1-2,0-2-2,2-0-3,1-3-3,0-1-3")
-    #[arg(long = "graph-2")]
-    pub graph_2: Option<String>,
-    /// Number of ordered vertices in the first contact map G_1 for MaximumContactMapOverlap
-    #[arg(long = "num-vertices-1")]
-    pub num_vertices_1: Option<usize>,
-    /// Number of ordered vertices in the second contact map G_2 for MaximumContactMapOverlap
-    #[arg(long = "num-vertices-2")]
-    pub num_vertices_2: Option<usize>,
-    /// Contacts of G_1 for MaximumContactMapOverlap as comma-separated unordered pairs (e.g., "0-2,1-3")
-    #[arg(long = "contacts-1")]
-    pub contacts_1: Option<String>,
-    /// Contacts of G_2 for MaximumContactMapOverlap as comma-separated unordered pairs (e.g., "0-3,1-4,0-2")
-    #[arg(long = "contacts-2")]
-    pub contacts_2: Option<String>,
-    /// Bin capacity for BinPacking
-    #[arg(long)]
-    pub capacity: Option<String>,
-    /// Car paint sequence for PaintShop (comma-separated, each label appears exactly twice, e.g., "a,b,a,c,c,b")
-    #[arg(long)]
-    pub sequence: Option<String>,
-    /// Subsets for set-system problems such as SetPacking, MinimumHittingSet, and SetCovering (semicolon-separated, e.g., "0,1;1,2;0,2")
-    #[arg(long = "subsets", alias = "sets")]
-    pub sets: Option<String>,
-    /// R-family sets for ComparativeContainment (semicolon-separated, e.g., "0,1;1,2")
-    #[arg(long)]
-    pub r_sets: Option<String>,
-    /// S-family sets for ComparativeContainment (semicolon-separated, e.g., "0,1;1,2")
-    #[arg(long)]
-    pub s_sets: Option<String>,
-    /// R-family weights for ComparativeContainment (comma-separated, e.g., "2,5")
-    #[arg(long)]
-    pub r_weights: Option<String>,
-    /// S-family weights for ComparativeContainment (comma-separated, e.g., "3,6")
-    #[arg(long)]
-    pub s_weights: Option<String>,
-    /// Partition groups for arc-index partitions (semicolon-separated, e.g., "0,1;2,3")
-    #[arg(long)]
-    pub partition: Option<String>,
-    /// Three partition matroids for ThreeMatroidIntersection (pipe-separated matroids, semicolon-separated groups, e.g., "0,1,2;3,4,5|0,3;1,4;2,5|0,4;1,5;2,3")
-    #[arg(long)]
-    pub partitions: Option<String>,
-    /// Arc bundles for IntegralFlowBundles (semicolon-separated groups of arc indices, e.g., "0,1;2,5;3,4")
-    #[arg(long)]
-    pub bundles: Option<String>,
-    /// Universe size for set-system problems such as MinimumHittingSet, MinimumSetCovering, and ComparativeContainment
-    #[arg(long = "universe-size", alias = "universe")]
-    pub universe: Option<usize>,
-    /// Bipartite graph edges for BicliqueCover / BalancedCompleteBipartiteSubgraph (e.g., "0-0,0-1,1-2" for left-right pairs)
-    #[arg(long)]
-    pub biedges: Option<String>,
-    /// Left partition size for BicliqueCover / BalancedCompleteBipartiteSubgraph
-    #[arg(long)]
-    pub left: Option<usize>,
-    /// Right partition size for BicliqueCover / BalancedCompleteBipartiteSubgraph
-    #[arg(long)]
-    pub right: Option<usize>,
-    /// Rank for BMF
-    #[arg(long)]
-    pub rank: Option<usize>,
-    /// Lattice basis for CVP (semicolon-separated column vectors, e.g., "1,0;0,1")
-    #[arg(long)]
-    pub basis: Option<String>,
-    /// Target vector for CVP (comma-separated, e.g., "0.5,0.5")
-    #[arg(long)]
-    pub target_vec: Option<String>,
-    /// Variable bounds for CVP as "lower,upper" (e.g., "-10,10") [default: -10,10]
-    #[arg(long, allow_hyphen_values = true)]
-    pub bounds: Option<String>,
-    /// Release times for SequencingWithinIntervals (comma-separated, e.g., "0,0,5")
-    #[arg(long)]
-    pub release_times: Option<String>,
-    /// Processing lengths (comma-separated, e.g., "4,5,3,2,6")
-    #[arg(long)]
-    pub lengths: Option<String>,
-    /// Terminal vertices for SteinerTree or MinimumMultiwayCut (comma-separated indices, e.g., "0,2,4")
-    #[arg(long)]
-    pub terminals: Option<String>,
-    /// Terminal pairs for DisjointConnectingPaths (comma-separated pairs, e.g., "0-3,2-5")
-    #[arg(long = "terminal-pairs")]
-    pub terminal_pairs: Option<String>,
-    /// Tree edge list for IsomorphicSpanningTree (e.g., 0-1,1-2,2-3)
-    #[arg(long)]
-    pub tree: Option<String>,
-    /// Required edge indices for RuralPostman (comma-separated, e.g., "0,2,4")
-    #[arg(long)]
-    pub required_edges: Option<String>,
-    /// Bound parameter (upper or length bound for BoundedComponentSpanningForest, GroupingBySwapping, LengthBoundedDisjointPaths, MultipleChoiceBranching, RootedTreeArrangement, or StringToStringCorrection)
-    #[arg(
-        long,
-        alias = "max-length",
-        alias = "max-weight",
-        alias = "bound-k",
-        alias = "threshold",
-        allow_hyphen_values = true
-    )]
-    pub bound: Option<i64>,
-    /// Upper bound on expected retrieval latency for ExpectedRetrievalCost
-    #[arg(long)]
-    pub latency_bound: Option<f64>,
-    /// Upper bound on total path length
-    #[arg(long)]
-    pub length_bound: Option<i32>,
-    /// Upper bound on total path weight
-    #[arg(long)]
-    pub weight_bound: Option<i32>,
-    /// Upper bound on tree diameter (in edges) for BoundedDiameterSpanningTree
-    #[arg(long)]
-    pub diameter_bound: Option<usize>,
-    /// Upper bound on total inter-partition arc cost
-    #[arg(long)]
-    pub cost_bound: Option<i32>,
-    /// Budget on total delay penalty for CapacityAssignment
-    #[arg(long)]
-    pub delay_budget: Option<u64>,
-    /// Pattern graph edge list for SubgraphIsomorphism (e.g., 0-1,1-2,2-0)
-    #[arg(long)]
-    pub pattern: Option<String>,
-    /// Input strings for LCS (e.g., "ABAC;BACA" or "0,1,0;1,0,1") or SCS (e.g., "0,1,2;1,2,0")
-    #[arg(long)]
-    pub strings: Option<String>,
-    /// Input string for GroupingBySwapping (comma-separated symbol indices, e.g., "0,1,2,0,1,2")
-    #[arg(long)]
-    pub string: Option<String>,
-    /// Task costs for SequencingToMinimizeMaximumCumulativeCost (comma-separated, e.g., "2,-1,3,-2,1,-3")
-    #[arg(long, allow_hyphen_values = true)]
-    pub costs: Option<String>,
-    /// Arc weights/lengths for directed graph problems with per-arc costs (comma-separated, e.g., "1,1,2,3")
-    #[arg(long = "arc-weights", alias = "arc-costs", alias = "arc-lengths")]
-    pub arc_costs: Option<String>,
-    /// Directed arcs for directed graph problems (e.g., 0>1,1>2,2>0)
-    #[arg(long)]
-    pub arcs: Option<String>,
-    /// Left operand arcs for MinimumCodeGenerationUnlimitedRegisters (e.g., 1>3,2>3,0>1)
-    #[arg(long)]
-    pub left_arcs: Option<String>,
-    /// Right operand arcs for MinimumCodeGenerationUnlimitedRegisters (e.g., 1>4,2>4,0>2)
-    #[arg(long)]
-    pub right_arcs: Option<String>,
-    /// Arc-index equality constraints for IntegralFlowHomologousArcs (semicolon-separated, e.g., "2=5;4=3")
-    #[arg(long)]
-    pub homologous_pairs: Option<String>,
-    /// Quantifiers for QBF (comma-separated, E=Exists, A=ForAll, e.g., "E,A,E")
-    #[arg(long)]
-    pub quantifiers: Option<String>,
-    /// Size bound for partition sets (for MinimumCutIntoBoundedSets)
-    #[arg(long)]
-    pub size_bound: Option<usize>,
-    /// Cut weight bound (for MinimumCutIntoBoundedSets)
-    #[arg(long)]
-    pub cut_bound: Option<i32>,
-    /// Item values (e.g., 3,4,5,7) for PartiallyOrderedKnapsack
-    #[arg(long)]
-    pub values: Option<String>,
-    /// Precedence pairs (e.g., "0>2,0>3,1>4") for PartiallyOrderedKnapsack
-    #[arg(long, alias = "item-precedences")]
-    pub precedences: Option<String>,
-    /// Distance matrix for QuadraticAssignment (semicolon-separated rows, e.g., "0,1,2;1,0,1;2,1,0")
-    #[arg(long)]
-    pub distance_matrix: Option<String>,
-    /// Weighted potential augmentation edges (e.g., 0-2:3,1-3:5)
-    #[arg(long = "potential-weights", alias = "potential-edges")]
-    pub potential_edges: Option<String>,
-    /// Total budget for selected potential edges
-    #[arg(long)]
-    pub budget: Option<String>,
-    /// Maximum cycle length L for PartialFeedbackEdgeSet
-    #[arg(long)]
-    pub max_cycle_length: Option<usize>,
-    /// Candidate weighted arcs for StrongConnectivityAugmentation (e.g., 2>0:1,2>1:3)
-    #[arg(long)]
-    pub candidate_arcs: Option<String>,
-    /// Usage frequencies for MultipleCopyFileAllocation (comma-separated, e.g., "5,4,3,2")
-    #[arg(long)]
-    pub usage: Option<String>,
-    /// Storage costs for MultipleCopyFileAllocation (comma-separated, e.g., "1,1,1,1")
-    #[arg(long)]
-    pub storage: Option<String>,
-    /// Deadlines for MinimumTardinessSequencing or SchedulingWithIndividualDeadlines (comma-separated, e.g., "5,5,5,3,3")
-    #[arg(long)]
-    pub deadlines: Option<String>,
-    /// Precedence pairs for MinimumTardinessSequencing, SchedulingWithIndividualDeadlines, or SequencingToMinimizeWeightedCompletionTime (e.g., "0>3,1>3,1>4,2>4")
-    #[arg(long)]
-    pub precedence_pairs: Option<String>,
-    /// Resource bounds for ResourceConstrainedScheduling (comma-separated, e.g., "20,15")
-    #[arg(long)]
-    pub resource_bounds: Option<String>,
-    /// Resource requirements for ResourceConstrainedScheduling (semicolon-separated rows, each row comma-separated, e.g., "6,3;7,4;5,2")
-    #[arg(long)]
-    pub resource_requirements: Option<String>,
-    /// Task lengths for FlowShopScheduling (semicolon-separated rows: "3,4,2;2,3,5;4,1,3")
-    #[arg(long)]
-    pub task_lengths: Option<String>,
-    /// Job tasks for JobShopScheduling (semicolon-separated jobs, comma-separated processor:length tasks, e.g., "0:3,1:4;1:2,0:3,1:2")
-    #[arg(long = "jobs", alias = "job-tasks")]
-    pub job_tasks: Option<String>,
-    /// Deadline for FlowShopScheduling, MultiprocessorScheduling, or ResourceConstrainedScheduling
-    #[arg(long)]
-    pub deadline: Option<u64>,
-    /// Number of processors/machines for FlowShopScheduling, JobShopScheduling, MultiprocessorScheduling, ResourceConstrainedScheduling, SchedulingToMinimizeWeightedCompletionTime, or SchedulingWithIndividualDeadlines
-    #[arg(long)]
-    pub num_processors: Option<usize>,
-    /// Binary schedule patterns for StaffScheduling (semicolon-separated rows, e.g., "1,1,0;0,1,1")
-    #[arg(long)]
-    pub schedules: Option<String>,
-    /// Requirements for StaffScheduling (comma-separated) or TimetableDesign (semicolon-separated rows)
-    #[arg(long)]
-    pub requirements: Option<String>,
-    /// Number of available workers for StaffScheduling
-    #[arg(long)]
-    pub num_workers: Option<u64>,
-    /// Number of work periods for TimetableDesign
-    #[arg(long)]
-    pub num_periods: Option<usize>,
-    /// Number of craftsmen for TimetableDesign
-    #[arg(long)]
-    pub num_craftsmen: Option<usize>,
-    /// Number of tasks for TimetableDesign
-    #[arg(long)]
-    pub num_tasks: Option<usize>,
-    /// Craftsman availability rows for TimetableDesign (semicolon-separated 0/1 rows)
-    #[arg(long)]
-    pub craftsman_avail: Option<String>,
-    /// Task availability rows for TimetableDesign (semicolon-separated 0/1 rows)
-    #[arg(long)]
-    pub task_avail: Option<String>,
-    /// Alphabet size for GroupingBySwapping, LCS, SCS, StringToStringCorrection, or TwoDimensionalConsecutiveSets (optional; inferred from the input strings if omitted)
-    #[arg(long)]
-    pub alphabet_size: Option<usize>,
-    /// Common window length ell for ClosestSubstring
-    #[arg(long)]
-    pub substring_length: Option<usize>,
-
-    /// Number of attributes for AdditionalKey or MinimumCardinalityKey
-    #[arg(long)]
-    pub num_attributes: Option<usize>,
-    /// Functional dependencies for AdditionalKey (e.g., "0,1:2,3;2,3:4,5") or MinimumCardinalityKey (semicolon-separated "lhs>rhs" pairs, e.g., "0,1>2;0,2>3")
-    #[arg(long)]
-    pub dependencies: Option<String>,
-    /// Relation scheme attributes for AdditionalKey (comma-separated, e.g., "0,1,2,3,4,5")
-    #[arg(long)]
-    pub relation_attrs: Option<String>,
-    /// Known candidate keys for AdditionalKey (e.g., "0,1;2,3")
-    #[arg(long)]
-    pub known_keys: Option<String>,
-    /// Number of objects for ConsistencyOfDatabaseFrequencyTables
-    #[arg(long)]
-    pub num_objects: Option<usize>,
-    /// Attribute-domain sizes for ConsistencyOfDatabaseFrequencyTables (comma-separated, e.g., "2,3,2")
-    #[arg(long)]
-    pub attribute_domains: Option<String>,
-    /// Pairwise frequency tables for ConsistencyOfDatabaseFrequencyTables (e.g., "0,1:1,1|0,1;1,2:1,0|0,1")
-    #[arg(long)]
-    pub frequency_tables: Option<String>,
-    /// Known value triples for ConsistencyOfDatabaseFrequencyTables (e.g., "0,0,0;3,1,2")
-    #[arg(long)]
-    pub known_values: Option<String>,
-    /// Domain size for ConjunctiveBooleanQuery
-    #[arg(long)]
-    pub domain_size: Option<usize>,
-    /// Relations for ConjunctiveBooleanQuery (format: "arity:tuple1|tuple2;arity:tuple1|tuple2")
-    #[arg(long)]
-    pub relations: Option<String>,
-    /// Conjuncts for ConjunctiveBooleanQuery (format: "rel:args;rel:args" where args use v0,v1 for variables, c0,c1 for constants)
-    #[arg(long)]
-    pub conjuncts_spec: Option<String>,
-    /// Functional dependencies (semicolon-separated, each dep is lhs>rhs with comma-separated indices, e.g., "0,1>2,3;2,3>0,1")
-    #[arg(long)]
-    pub deps: Option<String>,
-    /// Query attribute index for PrimeAttributeName
-    #[arg(long = "query-attribute", alias = "query")]
-    pub query: Option<usize>,
-    /// Right-hand side vector for FeasibleBasisExtension (comma-separated, e.g., "7,5,3")
-    #[arg(long)]
-    pub rhs: Option<String>,
-    /// Required column indices for FeasibleBasisExtension (comma-separated, e.g., "0,1")
-    #[arg(long)]
-    pub required_columns: Option<String>,
-    /// Number of groups for SumOfSquaresPartition
-    #[arg(long)]
-    pub num_groups: Option<usize>,
-    /// Number of sectors for ExpectedRetrievalCost
-    #[arg(long)]
-    pub num_sectors: Option<usize>,
-    /// Compiler index for each task in SequencingWithDeadlinesAndSetUpTimes (comma-separated, e.g., "0,1,0,1,0")
-    #[arg(long)]
-    pub compilers: Option<String>,
-    /// Setup times per compiler for SequencingWithDeadlinesAndSetUpTimes (comma-separated, e.g., "1,2")
-    #[arg(long)]
-    pub setup_times: Option<String>,
-    /// Source string for StringToStringCorrection (comma-separated symbol indices, e.g., "0,1,2,3")
-    #[arg(long)]
-    pub source_string: Option<String>,
-    /// Target string for StringToStringCorrection (comma-separated symbol indices, e.g., "0,1,3,2")
-    #[arg(long)]
-    pub target_string: Option<String>,
-    /// Pointer cost for MinimumExternalMacroDataCompression (positive integer)
-    #[arg(long)]
-    pub pointer_cost: Option<usize>,
-    /// Expression tree for IntegerExpressionMembership (JSON, e.g., '{"Sum":[{"Atom":1},{"Atom":2}]}')
-    #[arg(long)]
-    pub expression: Option<String>,
-    /// Equations for AlgebraicEquationsOverGF2 (semicolon-separated polynomials, each a colon-separated list of monomials, each a comma-separated list of variable indices; empty monomial = constant 1; e.g., "0,1:2;1,2:0:;0:1:2:")
-    #[arg(long)]
-    pub equations: Option<String>,
-    /// Register assignment for FeasibleRegisterAssignment (comma-separated register indices, e.g., "0,1,0,0")
-    #[arg(long)]
-    pub assignment: Option<String>,
-    /// Coefficient/parameter a for QuadraticCongruences (residue target) or QuadraticDiophantineEquations (coefficient of x²)
-    #[arg(long)]
-    pub coeff_a: Option<String>,
-    /// Coefficient/parameter b for QuadraticCongruences (modulus) or QuadraticDiophantineEquations (coefficient of y)
-    #[arg(long)]
-    pub coeff_b: Option<String>,
-    /// Constant c for QuadraticCongruences (search-space bound) or QuadraticDiophantineEquations (right-hand side of ax² + by = c)
-    #[arg(long)]
-    pub coeff_c: Option<String>,
-    /// Incongruence pairs for SimultaneousIncongruences (semicolon-separated "a,b" pairs, e.g., "2,2;1,3;2,5;3,7")
-    #[arg(long)]
-    pub pairs: Option<String>,
-    /// W-set sizes for Numerical3DimensionalMatching (comma-separated, e.g., "4,5")
-    #[arg(long)]
-    pub w_sizes: Option<String>,
-    /// X-set sizes for Numerical3DimensionalMatching (comma-separated, e.g., "4,5")
-    #[arg(long)]
-    pub x_sizes: Option<String>,
-    /// Y-set sizes for Numerical3DimensionalMatching (comma-separated, e.g., "5,7")
-    #[arg(long)]
-    pub y_sizes: Option<String>,
-    /// Initial marking for NonLivenessFreePetriNet (comma-separated tokens per place, e.g., "1,0,0,0")
-    #[arg(long)]
-    pub initial_marking: Option<String>,
-    /// Output arcs (transition-to-place) for NonLivenessFreePetriNet (e.g., "0>1,1>2,2>3")
-    #[arg(long)]
-    pub output_arcs: Option<String>,
-    /// Gate types for MinimumWeightAndOrGraph (comma-separated: AND, OR, or L for leaf, e.g., "AND,OR,OR,L,L,L,L")
-    #[arg(long)]
-    pub gate_types: Option<String>,
-    /// Input vertex indices (comma-separated, e.g., "0,1")
-    #[arg(long)]
-    pub inputs: Option<String>,
-    /// Output vertex indices (comma-separated, e.g., "5,6")
-    #[arg(long)]
-    pub outputs: Option<String>,
-    /// True sentence indices for MinimumAxiomSet (comma-separated, e.g., "0,1,2,3,4,5,6,7")
-    #[arg(long)]
-    pub true_sentences: Option<String>,
-    /// Implications for MinimumAxiomSet (semicolon-separated "antecedents>consequent", e.g., "0>2;0>3;1>4;2,4>6")
-    #[arg(long)]
-    pub implications: Option<String>,
-    /// Loop length N for MinimumRegisterSufficiencyForLoops
-    #[arg(long)]
-    pub loop_length: Option<usize>,
-    /// Variables as semicolon-separated start,duration pairs for MinimumRegisterSufficiencyForLoops (e.g., "0,3;2,3;4,3")
-    #[arg(long)]
-    pub loop_variables: Option<String>,
-    /// Parallel assignments for MinimumCodeGenerationParallelAssignments (semicolon-separated "target:read1,read2" entries, e.g., "0:1,2;1:0;2:3;3:1,2")
-    #[arg(long)]
-    pub assignments: Option<String>,
-    /// Number of variables for MinimumCodeGenerationParallelAssignments
-    #[arg(long)]
-    pub num_variables: Option<usize>,
-    /// Truth table for MinimumDisjunctiveNormalForm (comma-separated 0/1, e.g., "0,1,1,1,1,1,1,0")
-    #[arg(long)]
-    pub truth_table: Option<String>,
-    /// Test matrix for MinimumDecisionTree (JSON 2D bool array, e.g., '[[true,true,false],[true,false,false]]')
-    #[arg(long)]
-    pub test_matrix: Option<String>,
-    /// Number of tests for MinimumDecisionTree
-    #[arg(long)]
-    pub num_tests: Option<usize>,
-    /// Tiles for SquareTiling (semicolon-separated top,right,bottom,left tuples, e.g., "0,1,2,0;0,0,2,1;2,1,0,0;2,0,0,1")
-    #[arg(long)]
-    pub tiles: Option<String>,
-    /// Grid size N for SquareTiling (N x N grid)
-    #[arg(long)]
-    pub grid_size: Option<usize>,
-    /// Number of colors for SquareTiling
-    #[arg(long)]
-    pub num_colors: Option<usize>,
-    /// Vertex prizes for PrizeCollectingSteinerForest (comma-separated nonnegative weights, e.g., "5,2,5")
-    #[arg(long)]
-    pub vertex_prizes: Option<String>,
-    /// Edge costs for PrizeCollectingSteinerForest (comma-separated nonnegative weights in graph.edges() order, e.g., "1,6")
-    #[arg(long)]
-    pub edge_costs: Option<String>,
-    /// Tradeoff coefficient beta >= 0 on the omitted-prize term for PrizeCollectingSteinerForest
-    #[arg(long)]
-    pub beta: Option<String>,
-    /// Per-component penalty omega >= 0 for PrizeCollectingSteinerForest
-    #[arg(long)]
-    pub omega: Option<String>,
-}
-
-impl CreateArgs {
-    #[allow(dead_code)]
-    pub fn flag_map(&self) -> HashMap<&'static str, Option<String>> {
-        let mut flags = HashMap::new();
-
-        macro_rules! insert {
-            ($key:literal, $expr:expr) => {
-                flags.insert($key, ($expr).map(|value| value.to_string()));
-            };
-        }
-
-        insert!("example", self.example.as_deref());
-        insert!("to", self.example_target.as_deref());
-        insert!("graph", self.graph.as_deref());
-        insert!("weights", self.weights.as_deref());
-        insert!("edge-weights", self.edge_weights.as_deref());
-        insert!("edge-lengths", self.edge_lengths.as_deref());
-        insert!("capacities", self.capacities.as_deref());
-        insert!("demands", self.demands.as_deref());
-        insert!("setup-costs", self.setup_costs.as_deref());
-        insert!("production-costs", self.production_costs.as_deref());
-        insert!("inventory-costs", self.inventory_costs.as_deref());
-        insert!("bundle-capacities", self.bundle_capacities.as_deref());
-        insert!("cost-matrix", self.cost_matrix.as_deref());
-        insert!("delay-matrix", self.delay_matrix.as_deref());
-        insert!("lower-bounds", self.lower_bounds.as_deref());
-        insert!("multipliers", self.multipliers.as_deref());
-        insert!("sink", self.sink);
-        insert!("requirement", self.requirement);
-        insert!("num-paths-required", self.num_paths_required);
-        insert!("paths", self.paths.as_deref());
-        insert!("couplings", self.couplings.as_deref());
-        insert!("fields", self.fields.as_deref());
-        insert!("clauses", self.clauses.as_deref());
-        insert!("disjuncts", self.disjuncts.as_deref());
-        insert!("num-vars", self.num_vars);
-        insert!("matrix", self.matrix.as_deref());
-        insert!("k", self.k);
-        insert!("num-partitions", self.num_partitions);
-        flags.insert("random", self.random.then(|| "true".to_string()));
-        insert!("num-vertices", self.num_vertices);
-        insert!("source-vertex", self.source_vertex);
-        insert!("target-vertex", self.target_vertex);
-        insert!("edge-prob", self.edge_prob);
-        insert!("seed", self.seed);
-        insert!("target", self.target.as_deref());
-        insert!("m", self.m);
-        insert!("n", self.n);
-        insert!("positions", self.positions.as_deref());
-        insert!("radius", self.radius);
-        insert!("source-1", self.source_1);
-        insert!("sink-1", self.sink_1);
-        insert!("source-2", self.source_2);
-        insert!("sink-2", self.sink_2);
-        insert!("requirement-1", self.requirement_1);
-        insert!("requirement-2", self.requirement_2);
-        insert!("sizes", self.sizes.as_deref());
-        insert!("probabilities", self.probabilities.as_deref());
-        insert!("link-lengths", self.link_lengths.as_deref());
-        insert!("target-point", self.target_point.as_deref());
-        insert!("orientation-samples", self.orientation_samples.as_deref());
-        insert!("allowed-pairs", self.allowed_pairs.as_deref());
-        insert!("graph-1", self.graph_1.as_deref());
-        insert!("graph-2", self.graph_2.as_deref());
-        insert!("num-vertices-1", self.num_vertices_1);
-        insert!("num-vertices-2", self.num_vertices_2);
-        insert!("contacts-1", self.contacts_1.as_deref());
-        insert!("contacts-2", self.contacts_2.as_deref());
-        insert!("capacity", self.capacity.as_deref());
-        insert!("sequence", self.sequence.as_deref());
-        insert!("subsets", self.sets.as_deref());
-        insert!("r-sets", self.r_sets.as_deref());
-        insert!("s-sets", self.s_sets.as_deref());
-        insert!("r-weights", self.r_weights.as_deref());
-        insert!("s-weights", self.s_weights.as_deref());
-        insert!("partition", self.partition.as_deref());
-        insert!("partitions", self.partitions.as_deref());
-        insert!("bundles", self.bundles.as_deref());
-        insert!("universe-size", self.universe);
-        insert!("universe", self.universe); // PrimeAttributeName maps num_attributes → --universe
-        insert!("biedges", self.biedges.as_deref());
-        insert!("left", self.left);
-        insert!("right", self.right);
-        insert!("rank", self.rank);
-        insert!("basis", self.basis.as_deref());
-        insert!("target-vec", self.target_vec.as_deref());
-        insert!("bounds", self.bounds.as_deref());
-        insert!("release-times", self.release_times.as_deref());
-        insert!("lengths", self.lengths.as_deref().or(self.sizes.as_deref()));
-        insert!("terminals", self.terminals.as_deref());
-        insert!("terminal-pairs", self.terminal_pairs.as_deref());
-        insert!("tree", self.tree.as_deref());
-        insert!("required-edges", self.required_edges.as_deref());
-        insert!("bound", self.bound);
-        insert!("max-length", self.bound);
-        insert!("max-weight", self.bound);
-        insert!("bound-k", self.bound);
-        insert!("threshold", self.bound);
-        insert!("latency-bound", self.latency_bound);
-        insert!("length-bound", self.length_bound);
-        insert!("weight-bound", self.weight_bound);
-        insert!("diameter-bound", self.diameter_bound);
-        insert!("cost-bound", self.cost_bound);
-        insert!("delay-budget", self.delay_budget);
-        insert!("pattern", self.pattern.as_deref());
-        insert!("strings", self.strings.as_deref());
-        insert!("string", self.string.as_deref());
-        insert!("costs", self.costs.as_deref());
-        insert!("arc-weights", self.arc_costs.as_deref());
-        insert!("arc-costs", self.arc_costs.as_deref());
-        insert!("arc-lengths", self.arc_costs.as_deref());
-        insert!("arcs", self.arcs.as_deref());
-        insert!("left-arcs", self.left_arcs.as_deref());
-        insert!("right-arcs", self.right_arcs.as_deref());
-        insert!("homologous-pairs", self.homologous_pairs.as_deref());
-        insert!("quantifiers", self.quantifiers.as_deref());
-        insert!("size-bound", self.size_bound);
-        insert!("cut-bound", self.cut_bound);
-        insert!("values", self.values.as_deref());
-        insert!(
-            "precedences",
-            self.precedences
-                .as_deref()
-                .or(self.precedence_pairs.as_deref())
-        );
-        insert!(
-            "precedence-pairs",
-            self.precedences
-                .as_deref()
-                .or(self.precedence_pairs.as_deref())
-        );
-        insert!("distance-matrix", self.distance_matrix.as_deref());
-        insert!("potential-weights", self.potential_edges.as_deref());
-        insert!("potential-edges", self.potential_edges.as_deref());
-        insert!("budget", self.budget.as_deref());
-        insert!("max-cycle-length", self.max_cycle_length);
-        insert!("candidate-arcs", self.candidate_arcs.as_deref());
-        insert!("usage", self.usage.as_deref());
-        insert!("storage", self.storage.as_deref());
-        insert!("deadlines", self.deadlines.as_deref());
-        insert!("resource-bounds", self.resource_bounds.as_deref());
-        insert!(
-            "resource-requirements",
-            self.resource_requirements.as_deref()
-        );
-        insert!("task-lengths", self.task_lengths.as_deref());
-        insert!("jobs", self.job_tasks.as_deref());
-        insert!("job-tasks", self.job_tasks.as_deref());
-        insert!("deadline", self.deadline);
-        insert!("num-processors", self.num_processors);
-        insert!("schedules", self.schedules.as_deref());
-        insert!("requirements", self.requirements.as_deref());
-        insert!("num-workers", self.num_workers);
-        insert!("num-periods", self.num_periods);
-        insert!("num-craftsmen", self.num_craftsmen);
-        insert!("num-tasks", self.num_tasks.or(self.n));
-        insert!("craftsman-avail", self.craftsman_avail.as_deref());
-        insert!("task-avail", self.task_avail.as_deref());
-        insert!("alphabet-size", self.alphabet_size);
-        insert!("substring-length", self.substring_length);
-        insert!("num-attributes", self.num_attributes);
-        insert!(
-            "dependencies",
-            self.dependencies.as_deref().or(self.deps.as_deref())
-        );
-        insert!(
-            "deps",
-            self.dependencies.as_deref().or(self.deps.as_deref())
-        );
-        insert!("relation-attrs", self.relation_attrs.as_deref());
-        insert!("known-keys", self.known_keys.as_deref());
-        insert!("num-objects", self.num_objects);
-        insert!("attribute-domains", self.attribute_domains.as_deref());
-        insert!("frequency-tables", self.frequency_tables.as_deref());
-        insert!("known-values", self.known_values.as_deref());
-        insert!("domain-size", self.domain_size);
-        insert!("relations", self.relations.as_deref());
-        insert!("conjuncts-spec", self.conjuncts_spec.as_deref());
-        insert!("query-attribute", self.query);
-        insert!("rhs", self.rhs.as_deref());
-        insert!("required-columns", self.required_columns.as_deref());
-        insert!("num-groups", self.num_groups);
-        insert!("num-sectors", self.num_sectors);
-        insert!("compilers", self.compilers.as_deref());
-        insert!("setup-times", self.setup_times.as_deref());
-        insert!("source-string", self.source_string.as_deref());
-        insert!("target-string", self.target_string.as_deref());
-        insert!("pointer-cost", self.pointer_cost);
-        insert!("expression", self.expression.as_deref());
-        insert!("equations", self.equations.as_deref());
-        insert!("assignment", self.assignment.as_deref());
-        insert!("coeff-a", self.coeff_a.as_deref());
-        insert!("coeff-b", self.coeff_b.as_deref());
-        insert!("coeff-c", self.coeff_c.as_deref());
-        insert!("pairs", self.pairs.as_deref());
-        insert!("w-sizes", self.w_sizes.as_deref());
-        insert!("x-sizes", self.x_sizes.as_deref());
-        insert!("y-sizes", self.y_sizes.as_deref());
-        insert!("initial-marking", self.initial_marking.as_deref());
-        insert!("output-arcs", self.output_arcs.as_deref());
-        insert!("gate-types", self.gate_types.as_deref());
-        insert!("inputs", self.inputs.as_deref());
-        insert!("outputs", self.outputs.as_deref());
-        insert!("true-sentences", self.true_sentences.as_deref());
-        insert!("implications", self.implications.as_deref());
-        insert!("loop-length", self.loop_length);
-        insert!("loop-variables", self.loop_variables.as_deref());
-        insert!("assignments", self.assignments.as_deref());
-        insert!("num-variables", self.num_variables);
-        insert!("truth-table", self.truth_table.as_deref());
-        insert!("test-matrix", self.test_matrix.as_deref());
-        insert!("num-tests", self.num_tests);
-        insert!("tiles", self.tiles.as_deref());
-        insert!("grid-size", self.grid_size);
-        insert!("num-colors", self.num_colors);
-        insert!("vertex-prizes", self.vertex_prizes.as_deref());
-        insert!("edge-costs", self.edge_costs.as_deref());
-        insert!("beta", self.beta.as_deref());
-        insert!("omega", self.omega.as_deref());
-
-        flags.insert(
-            "source",
-            self.source_string
-                .clone()
-                .or_else(|| self.source.map(|value| value.to_string())),
-        );
-        flags.insert(
-            "target",
-            self.target_string
-                .clone()
-                .or_else(|| self.target.clone())
-                .or_else(|| self.sink.map(|value| value.to_string())),
-        );
-
-        flags
-    }
-}
-
-#[derive(clap::Args)]
-#[command(after_help = "\
-Examples:
-  pred solve problem.json                        # ILP solver (default, auto-reduces to ILP)
+  pred solve problem.json                        # deterministic registered backend or fallback
+  pred solve problem.json --solver customized    # require a problem-specific solver
   pred solve problem.json --solver brute-force   # brute-force (exhaustive search)
-  pred solve problem.json --solver customized    # customized (structure-exploiting exact solver)
+  pred solve problem.json --solver ilp           # require the registered fixed ILP pipeline
   pred solve reduced.json                        # solve a reduction bundle
   pred solve reduced.json -o solution.json       # save result to file
-  pred create MIS --graph 0-1,1-2 | pred solve - # read from stdin when an ILP path exists
+  pred create MIS --graph 0-1,1-2 | pred solve - # read from stdin
   pred create GroupingBySwapping --string \"0,1,2,0,1,2\" --bound 5 | pred solve - --solver brute-force
   pred create StringToStringCorrection --source-string \"0,1,2,3,1,0\" --target-string \"0,1,3,2,1\" --bound 2 | pred solve - --solver brute-force
-  pred create TwoDimensionalConsecutiveSets --alphabet-size 6 --sets \"0,1,2;3,4,5;1,3;2,4;0,5\" | pred solve - --solver brute-force
+  pred create TwoDimensionalConsecutiveSets --alphabet-size 6 --subsets \"0,1,2;3,4,5;1,3;2,4;0,5\" | pred solve - --solver brute-force
   pred solve problem.json --timeout 10           # abort after 10 seconds
 
 Typical workflow:
@@ -1236,63 +295,49 @@ Typical workflow:
   pred solve problem.json
 
 Solve via explicit reduction:
-  pred reduce problem.json --to QUBO -o reduced.json
+  pred reduce problem.json --via route.json -o reduced.json
   pred solve reduced.json
 
 Input: a problem JSON from `pred create`, or a reduction bundle from `pred reduce`.
 When given a bundle, the target is solved and the solution is mapped back to the source.
-The ILP solver auto-reduces non-ILP problems before solving.
-Problems without an ILP reduction path, such as `GroupingBySwapping`,
-`LengthBoundedDisjointPaths`, `MinMaxMulticenter`, and `StringToStringCorrection`,
-currently need `--solver brute-force`.
-
-Customized solver: exact witness recovery for select problems via structure-exploiting
-backends. Currently supports MinimumCardinalityKey, AdditionalKey, PrimeAttributeName,
-BoyceCoddNormalFormViolation, PartialFeedbackEdgeSet, and RootedTreeArrangement.
-
-ILP backend (default: HiGHS). To use CPLEX instead:
-  cargo install problemreductions-cli --features cplex
-(Requires CPLEX to be installed on your system.)")]
+By default, solve deterministically selects the exact variant's registered customized
+backend, then its fixed ILP pipeline, and otherwise brute force. `--solver ilp`
+requires a registered ILP pipeline; it never searches the reduction graph.
+ILP problems are solved with HiGHS.")]
 pub struct SolveArgs {
     /// Problem JSON file (from `pred create`) or reduction bundle (from `pred reduce`). Use - for stdin.
     pub input: PathBuf,
-    /// Solver: ilp (default), brute-force, or customized
-    #[arg(long, default_value = "ilp")]
-    pub solver: String,
+    /// Solver override: customized, ilp, or brute-force. Omit for deterministic default dispatch.
+    #[arg(long)]
+    pub solver: Option<String>,
     /// Timeout in seconds (0 = no limit)
     #[arg(long, default_value = "0")]
-    pub timeout: u64,
+    pub timeout: i64,
 }
 
 #[derive(clap::Args)]
 #[command(after_help = "\
 Examples:
-  pred reduce problem.json --to QUBO -o reduced.json
-  pred reduce problem.json --to ILP -o reduced.json
   pred reduce problem.json --via path.json -o reduced.json
-  pred create MIS --graph 0-1,1-2 | pred reduce - --to QUBO  # read from stdin
+  pred create MIS --graph 0-1,1-2 | pred reduce - --via path.json  # read from stdin
 
 Input: a problem JSON from `pred create`. Use - to read from stdin.
-The --via path file is from `pred path <SRC> <DST> -o path.json`.
-When --via is given, --to is inferred from the path file.
+The --via file must be one explicit entry selected by the caller from `pred path` output.
 Output is a reduction bundle with source, target, and path.
 Use `pred solve reduced.json` to solve and map the solution back.")]
 pub struct ReduceArgs {
     /// Problem JSON file (from `pred create`). Use - for stdin.
     pub input: PathBuf,
-    /// Target problem type (e.g., QUBO, SpinGlass). Inferred from --via if omitted.
-    #[arg(long, value_parser = crate::problem_name::ProblemNameParser)]
-    pub to: Option<String>,
-    /// Reduction route file (from `pred path ... -o`)
-    #[arg(long)]
-    pub via: Option<PathBuf>,
+    /// Explicit reduction route selected from a path-set entry.
+    #[arg(long, required = true)]
+    pub via: PathBuf,
 }
 
 #[derive(clap::Args)]
 pub struct ExtractArgs {
     /// Reduction bundle JSON (from `pred reduce`). Use - for stdin.
     pub input: PathBuf,
-    /// Target-space configuration to map back (comma-separated, e.g. 1,0,1,0)
+    /// Target problem solution encoded as JSON (for example, [1,0,1,0])
     #[arg(long)]
     pub config: String,
 }
@@ -1306,15 +351,15 @@ pub struct InspectArgs {
 #[derive(clap::Args)]
 #[command(after_help = "\
 Examples:
-  pred evaluate problem.json --config 1,0,1,0
-  pred evaluate problem.json --config 1,0,1,0 -o result.json
-  pred create MIS --graph 0-1,1-2 | pred evaluate - --config 1,0,1  # read from stdin
+  pred evaluate problem.json --config '[true,false,true,false]'
+  pred evaluate problem.json --config '[true,false,true,false]' -o result.json
+  pred create MIS --graph 0-1,1-2 | pred evaluate - --config '[true,false,true]'  # read from stdin
 
 Input: a problem JSON from `pred create`. Use - to read from stdin.")]
 pub struct EvaluateArgs {
     /// Problem JSON file (from `pred create`). Use - for stdin.
     pub input: PathBuf,
-    /// Configuration to evaluate (comma-separated, e.g., 1,0,1,0)
+    /// Problem solution encoded as JSON (for example, [true,false,true,false])
     #[arg(long)]
     pub config: String,
 }
@@ -1355,276 +400,164 @@ pub fn print_subcommand_help_hint(error_msg: &str) {
 
 #[cfg(test)]
 mod tests {
-    use super::Cli;
     use super::*;
-    use clap::CommandFactory;
+    use clap::error::ErrorKind;
 
     #[test]
-    fn test_create_help_mentions_scheduling_with_individual_deadlines_shared_flags() {
-        let mut cmd = Cli::command();
-        let create = cmd
-            .find_subcommand_mut("create")
-            .expect("create subcommand");
-        let mut help = Vec::new();
-        create
-            .write_long_help(&mut help)
-            .expect("render create help");
-        let help = String::from_utf8(help).expect("utf8 help");
-
-        assert!(help.contains(
-            "Deadlines for MinimumTardinessSequencing or SchedulingWithIndividualDeadlines"
-        ));
-        assert!(help.contains(
-            "Precedence pairs for MinimumTardinessSequencing, SchedulingWithIndividualDeadlines, or SequencingToMinimizeWeightedCompletionTime"
-        ));
-        assert!(
-            help.contains(
-                "Number of processors/machines for FlowShopScheduling, JobShopScheduling, MultiprocessorScheduling, ResourceConstrainedScheduling, SchedulingToMinimizeWeightedCompletionTime, or SchedulingWithIndividualDeadlines"
-            ),
-            "create help should describe --num-processors for both scheduling models"
-        );
-        assert!(help.contains(
-            "SchedulingWithIndividualDeadlines --num-tasks, --num-processors/--m, --deadlines [--precedences]"
-        ));
+    fn two_stage_create_parser_uses_bounded_stack() {
+        std::thread::Builder::new()
+            .stack_size(1024 * 1024)
+            .spawn(|| {
+                assert_eq!(
+                    Cli::try_parse_from(["pred", "--version"])
+                        .err()
+                        .expect("version exits")
+                        .kind(),
+                    ErrorKind::DisplayVersion
+                );
+                Cli::try_parse_from(["pred", "list"]).expect("list parses");
+                Cli::try_parse_from(["pred", "create", "MIS", "--graph", "0-1"])
+                    .expect("MIS parses");
+                Cli::try_parse_from([
+                    "pred",
+                    "create",
+                    "SAT",
+                    "--num-vars",
+                    "2",
+                    "--clauses",
+                    "1,2",
+                ])
+                .expect("SAT parses");
+                assert_eq!(
+                    Cli::try_parse_from(["pred", "create", "MIS", "--clauses", "1,2"])
+                        .err()
+                        .expect("unrelated flag is rejected")
+                        .kind(),
+                    ErrorKind::UnknownArgument
+                );
+                assert_eq!(
+                    Cli::try_parse_from([
+                        "pred", "create", "KClique", "--graph", "0-1", "--k", "nope"
+                    ])
+                    .err()
+                    .expect("invalid numeric value is rejected by Clap")
+                    .kind(),
+                    ErrorKind::ValueValidation
+                );
+                Cli::try_parse_from([
+                    "pred",
+                    "create",
+                    "ShortestCommonSupersequence",
+                    "--strings",
+                    "0,1;1,2",
+                ])
+                .expect("derived SCS fields are not required as inputs");
+                assert_eq!(
+                    Cli::try_parse_from([
+                        "pred",
+                        "create",
+                        "LCS",
+                        "--strings",
+                        "0,1;1,2",
+                        "--max-length",
+                        "99",
+                    ])
+                    .err()
+                    .expect("derived LCS max_length is not exposed")
+                    .kind(),
+                    ErrorKind::UnknownArgument
+                );
+                assert!(Cli::try_parse_from([
+                    "pred",
+                    "create",
+                    "ThreePartition",
+                    "--sizes",
+                    "1,1,1",
+                    "--bound",
+                    "9223372036854775808",
+                ])
+                .is_err());
+                Cli::try_parse_from([
+                    "pred",
+                    "create",
+                    "MinimumCodeGenerationOneRegister",
+                    "--edges",
+                    "0>1",
+                ])
+                .expect("ordinary edges fields keep their schema-derived name");
+                Cli::command().debug_assert();
+            })
+            .expect("spawn parser thread")
+            .join()
+            .expect("parser thread completes");
     }
 
     #[test]
-    fn test_create_parses_biconnectivity_augmentation_flags() {
-        let cli = Cli::parse_from([
+    fn two_stage_create_parser_preserves_problem_and_variant_aliases() {
+        let cli = Cli::try_parse_from([
             "pred",
             "create",
-            "BiconnectivityAugmentation",
-            "--graph",
-            "0-1,1-2",
-            "--potential-weights",
-            "0-2:3,1-3:5",
-            "--budget",
-            "7",
-        ]);
-
-        let Commands::Create(args) = cli.command else {
-            panic!("expected create command");
-        };
-
-        assert_eq!(args.problem.as_deref(), Some("BiconnectivityAugmentation"));
-        assert_eq!(args.graph.as_deref(), Some("0-1,1-2"));
-        assert_eq!(args.potential_edges.as_deref(), Some("0-2:3,1-3:5"));
-        assert_eq!(args.budget.as_deref(), Some("7"));
-    }
-
-    #[test]
-    fn test_create_parses_biconnectivity_augmentation_legacy_flag_alias() {
-        let cli = Cli::parse_from([
-            "pred",
-            "create",
-            "BiconnectivityAugmentation",
-            "--graph",
-            "0-1,1-2",
-            "--potential-edges",
-            "0-2:3,1-3:5",
-            "--budget",
-            "7",
-        ]);
-
-        let Commands::Create(args) = cli.command else {
-            panic!("expected create command");
-        };
-
-        assert_eq!(args.potential_edges.as_deref(), Some("0-2:3,1-3:5"));
-    }
-
-    #[test]
-    fn test_create_help_mentions_biconnectivity_augmentation_flags() {
-        let cmd = Cli::command();
-        let create = cmd.find_subcommand("create").expect("create subcommand");
-        let help = create
-            .get_after_help()
-            .expect("create after_help")
-            .to_string();
-
-        assert!(help.contains("BiconnectivityAugmentation"));
-        assert!(help.contains("--potential-weights"));
-        assert!(help.contains("--budget"));
-    }
-
-    #[test]
-    fn test_create_parses_job_shop_scheduling_jobs_flag() {
-        let cli = Cli::parse_from([
-            "pred",
-            "create",
-            "JobShopScheduling",
-            "--jobs",
-            "0:3,1:4;1:2,0:3,1:2",
-            "--num-processors",
-            "2",
-        ]);
-
-        let Commands::Create(args) = cli.command else {
-            panic!("expected create command");
-        };
-
-        assert_eq!(args.problem.as_deref(), Some("JobShopScheduling"));
-        assert_eq!(args.job_tasks.as_deref(), Some("0:3,1:4;1:2,0:3,1:2"));
-        assert_eq!(args.num_processors, Some(2));
-    }
-
-    #[test]
-    fn test_create_parses_prime_attribute_name_canonical_flags() {
-        let cli = Cli::parse_from([
-            "pred",
-            "create",
-            "PrimeAttributeName",
-            "--universe",
-            "6",
-            "--dependencies",
-            "0,1>2,3,4,5;2,3>0,1,4,5",
-            "--query-attribute",
+            "3SAT",
+            "--num-vars",
             "3",
-        ]);
-
+            "--clauses",
+            "1,2,3",
+        ])
+        .expect("variant alias parses");
         let Commands::Create(args) = cli.command else {
             panic!("expected create command");
         };
-
-        assert_eq!(args.problem.as_deref(), Some("PrimeAttributeName"));
-        assert_eq!(args.universe, Some(6));
-        assert_eq!(
-            args.dependencies.as_deref(),
-            Some("0,1>2,3,4,5;2,3>0,1,4,5")
-        );
-        assert_eq!(args.query, Some(3));
+        assert_eq!(args.problem.as_deref(), Some("KSatisfiability/K3"));
+        assert_eq!(args.raw("num-vars"), Some("3"));
     }
 
     #[test]
-    fn test_create_args_flag_map_prefers_canonical_prime_attribute_keys() {
-        let cli = Cli::parse_from([
-            "pred",
-            "create",
-            "PrimeAttributeName",
-            "--universe",
-            "6",
-            "--dependencies",
-            "0,1>2,3,4,5;2,3>0,1,4,5",
-            "--query-attribute",
-            "3",
-        ]);
-
+    fn canonical_problem_name_is_not_treated_as_an_alias() {
+        let cli =
+            Cli::try_parse_from(["pred", "create", "GraphPartitioning", "--graph", "0-1,2-3"])
+                .expect("canonical problem name parses");
         let Commands::Create(args) = cli.command else {
             panic!("expected create command");
         };
-
-        let flags = args.flag_map();
-        assert_eq!(flags.get("universe-size"), Some(&Some("6".to_string())));
-        assert_eq!(
-            flags.get("dependencies"),
-            Some(&Some("0,1>2,3,4,5;2,3>0,1,4,5".to_string()))
-        );
-        assert_eq!(flags.get("query-attribute"), Some(&Some("3".to_string())));
+        assert_eq!(args.problem.as_deref(), Some("GraphPartitioning"));
     }
 
     #[test]
-    fn test_create_args_flag_map_converts_numeric_and_alias_backed_values() {
-        let cli = Cli::parse_from([
+    fn selected_create_parser_preserves_trailing_global_arguments() {
+        let cli = Cli::try_parse_from([
             "pred",
             "create",
-            "LengthBoundedDisjointPaths",
+            "MIS",
             "--graph",
-            "0-1,1-2,2-3",
-            "--source",
-            "0",
-            "--sink",
-            "3",
-            "--max-length",
-            "4",
-        ]);
-
-        let Commands::Create(args) = cli.command else {
-            panic!("expected create command");
-        };
-
-        let flags = args.flag_map();
-        assert_eq!(flags.get("source"), Some(&Some("0".to_string())));
-        assert_eq!(flags.get("sink"), Some(&Some("3".to_string())));
-        assert_eq!(flags.get("max-length"), Some(&Some("4".to_string())));
-        assert_eq!(flags.get("bound"), Some(&Some("4".to_string())));
-    }
-
-    #[test]
-    fn test_create_args_flag_map_promotes_legacy_jobs_alias_to_canonical_key() {
-        let cli = Cli::parse_from([
-            "pred",
-            "create",
-            "JobShopScheduling",
-            "--job-tasks",
-            "0:3,1:4;1:2,0:3,1:2",
-            "--num-processors",
-            "2",
-        ]);
-
-        let Commands::Create(args) = cli.command else {
-            panic!("expected create command");
-        };
-
-        let flags = args.flag_map();
-        assert_eq!(
-            flags.get("jobs"),
-            Some(&Some("0:3,1:4;1:2,0:3,1:2".to_string()))
-        );
+            "0-1",
+            "--output",
+            "problem.json",
+            "--json",
+        ])
+        .expect("global arguments parse after the selected model");
+        assert_eq!(cli.output, Some(PathBuf::from("problem.json")));
+        assert!(cli.json);
     }
 
     #[test]
-    fn test_create_parses_partial_feedback_edge_set_flags() {
-        let cli = Cli::parse_from([
-            "pred",
-            "create",
-            "PartialFeedbackEdgeSet",
-            "--graph",
-            "0-1,1-2,2-0",
-            "--budget",
-            "1",
-            "--max-cycle-length",
-            "3",
-        ]);
-
-        let Commands::Create(args) = cli.command else {
-            panic!("expected create command");
+    fn selected_create_parser_renders_model_help() {
+        let error = match Cli::try_parse_from(["pred", "create", "MIS", "--help"]) {
+            Ok(_) => panic!("help should exit after rendering the selected model command"),
+            Err(error) => error,
         };
-
-        assert_eq!(args.problem.as_deref(), Some("PartialFeedbackEdgeSet"));
-        assert_eq!(args.graph.as_deref(), Some("0-1,1-2,2-0"));
-        assert_eq!(args.budget.as_deref(), Some("1"));
-        assert_eq!(args.max_cycle_length, Some(3));
-    }
-
-    #[test]
-    fn test_create_help_mentions_partial_feedback_edge_set_flags() {
-        let cmd = Cli::command();
-        let create = cmd.find_subcommand("create").expect("create subcommand");
-        let help = create
-            .get_after_help()
-            .expect("create after_help")
-            .to_string();
-
-        assert!(help.contains("PartialFeedbackEdgeSet"));
-        assert!(help.contains("--budget"));
-        assert!(help.contains("--max-cycle-length"));
+        assert_eq!(error.kind(), ErrorKind::DisplayHelp);
+        let help = error.to_string();
+        assert!(help.contains("--graph"));
+        assert!(!help.contains("--clauses"));
     }
 
     #[test]
-    fn test_create_help_mentions_stacker_crane_flags() {
-        let cmd = Cli::command();
-        let create = cmd.find_subcommand("create").expect("create subcommand");
-        let help = create
-            .get_after_help()
-            .expect("create after_help")
-            .to_string();
-
-        assert!(help.contains("StackerCrane"));
-        assert!(help.contains("--arcs"));
-        assert!(help.contains("--graph"));
-        assert!(help.contains("--arc-lengths"));
-        assert!(help.contains("--edge-lengths"));
-        assert!(help.contains("--bound"));
-        assert!(help.contains("--num-vertices"));
+    fn static_create_parser_has_no_registered_model_subcommands() {
+        let command = Cli::command();
+        let create = command
+            .find_subcommand("create")
+            .expect("create subcommand");
+        assert_eq!(create.get_subcommands().count(), 0);
+        assert!(create.is_allow_external_subcommands_set());
     }
 }
diff --git a/problemreductions-cli/src/commands/create.rs b/problemreductions-cli/src/commands/create.rs
index 588eb7fda..0f5cc3834 100644
--- a/problemreductions-cli/src/commands/create.rs
+++ b/problemreductions-cli/src/commands/create.rs
@@ -1,229 +1,29 @@
 use crate::cli::{CreateArgs, ExampleSide};
 use crate::dispatch::ProblemJsonOutput;
 use crate::output::OutputConfig;
-use crate::problem_name::{
-    parse_problem_spec, resolve_catalog_problem_ref, resolve_problem_ref, unknown_problem_error,
-};
+use crate::problem_name::{resolve_problem_ref, unknown_problem_error};
 use crate::util;
 use anyhow::{bail, Context, Result};
 use num_bigint::BigUint;
 use problemreductions::export::{ModelExample, ProblemRef, ProblemSide, RuleExample};
-use problemreductions::models::algebraic::{
-    ClosestVectorProblem, ConsecutiveBlockMinimization, ConsecutiveOnesMatrixAugmentation,
-    SparseMatrixCompression,
-};
 use problemreductions::models::formula::Quantifier;
-use problemreductions::models::graph::{
-    GeneralizedHex, HamiltonianCircuit, HamiltonianPath, HamiltonianPathBetweenTwoVertices,
-    LabelledArc, LabelledDigraph, LengthBoundedDisjointPaths, LongestCircuit,
-    MinimumCutIntoBoundedSets, MinimumDummyActivitiesPert, MinimumMaximalMatching,
-    RootedTreeArrangement, SteinerTree, SteinerTreeInGraphs,
-};
-use problemreductions::models::misc::{
-    CbqRelation, FrequencyTable, KnownValue, QueryArg, SchedulingWithIndividualDeadlines,
-    ThreePartition,
-};
-use problemreductions::models::Decision;
+use problemreductions::models::graph::{LabelledArc, LabelledDigraph};
+use problemreductions::models::misc::{CbqRelation, FrequencyTable, KnownValue, QueryArg};
 use problemreductions::prelude::*;
-use problemreductions::registry::collect_schemas;
 use problemreductions::topology::{
-    BipartiteGraph, DirectedGraph, Graph, KingsSubgraph, MixedGraph, SimpleGraph,
-    TriangularSubgraph, UnitDiskGraph,
+    DirectedGraph, KingsSubgraph, SimpleGraph, TriangularSubgraph, UnitDiskGraph,
 };
 use serde::Serialize;
 use std::collections::{BTreeMap, BTreeSet};
 
-mod schema_semantics;
-use self::schema_semantics::validate_schema_driven_semantics;
 mod schema_support;
 use self::schema_support::*;
+pub(crate) use self::schema_support::{
+    create_inputs_for, resolve_schema_field_type, InputValueKind,
+};
 
-const MULTIPLE_COPY_FILE_ALLOCATION_EXAMPLE_ARGS: &str =
-    "--graph 0-1,1-2,2-3 --usage 5,4,3,2 --storage 1,1,1,1";
-const MULTIPLE_COPY_FILE_ALLOCATION_USAGE: &str =
-    "Usage: pred create MultipleCopyFileAllocation --graph 0-1,1-2,2-3 --usage 5,4,3,2 --storage 1,1,1,1";
-const EXPECTED_RETRIEVAL_COST_EXAMPLE_ARGS: &str =
-    "--probabilities 0.2,0.15,0.15,0.2,0.1,0.2 --num-sectors 3";
-
-/// Check if all data flags are None (no problem-specific input provided).
 fn all_data_flags_empty(args: &CreateArgs) -> bool {
-    args.graph.is_none()
-        && args.weights.is_none()
-        && args.edge_weights.is_none()
-        && args.edge_lengths.is_none()
-        && args.capacities.is_none()
-        && args.demands.is_none()
-        && args.setup_costs.is_none()
-        && args.production_costs.is_none()
-        && args.inventory_costs.is_none()
-        && args.bundle_capacities.is_none()
-        && args.cost_matrix.is_none()
-        && args.delay_matrix.is_none()
-        && args.lower_bounds.is_none()
-        && args.multipliers.is_none()
-        && args.source.is_none()
-        && args.sink.is_none()
-        && args.requirement.is_none()
-        && args.num_paths_required.is_none()
-        && args.paths.is_none()
-        && args.couplings.is_none()
-        && args.fields.is_none()
-        && args.clauses.is_none()
-        && args.disjuncts.is_none()
-        && args.num_vars.is_none()
-        && args.matrix.is_none()
-        && args.k.is_none()
-        && args.num_partitions.is_none()
-        && args.target.is_none()
-        && args.m.is_none()
-        && args.n.is_none()
-        && args.num_vertices.is_none()
-        && args.source_vertex.is_none()
-        && args.target_vertex.is_none()
-        && args.edge_prob.is_none()
-        && args.seed.is_none()
-        && args.positions.is_none()
-        && args.radius.is_none()
-        && args.source_1.is_none()
-        && args.sink_1.is_none()
-        && args.source_2.is_none()
-        && args.sink_2.is_none()
-        && args.requirement_1.is_none()
-        && args.requirement_2.is_none()
-        && args.sizes.is_none()
-        && args.probabilities.is_none()
-        && args.capacity.is_none()
-        && args.sequence.is_none()
-        && args.sets.is_none()
-        && args.r_sets.is_none()
-        && args.s_sets.is_none()
-        && args.r_weights.is_none()
-        && args.s_weights.is_none()
-        && args.partition.is_none()
-        && args.partitions.is_none()
-        && args.bundles.is_none()
-        && args.universe.is_none()
-        && args.biedges.is_none()
-        && args.left.is_none()
-        && args.right.is_none()
-        && args.rank.is_none()
-        && args.basis.is_none()
-        && args.target_vec.is_none()
-        && args.bounds.is_none()
-        && args.release_times.is_none()
-        && args.deadlines.is_none()
-        && args.lengths.is_none()
-        && args.terminals.is_none()
-        && args.terminal_pairs.is_none()
-        && args.tree.is_none()
-        && args.required_edges.is_none()
-        && args.bound.is_none()
-        && args.latency_bound.is_none()
-        && args.length_bound.is_none()
-        && args.weight_bound.is_none()
-        && args.diameter_bound.is_none()
-        && args.cost_bound.is_none()
-        && args.delay_budget.is_none()
-        && args.pattern.is_none()
-        && args.strings.is_none()
-        && args.string.is_none()
-        && args.costs.is_none()
-        && args.arc_costs.is_none()
-        && args.arcs.is_none()
-        && args.left_arcs.is_none()
-        && args.right_arcs.is_none()
-        && args.homologous_pairs.is_none()
-        && args.quantifiers.is_none()
-        && args.usage.is_none()
-        && args.storage.is_none()
-        && args.size_bound.is_none()
-        && args.cut_bound.is_none()
-        && args.values.is_none()
-        && args.precedences.is_none()
-        && args.distance_matrix.is_none()
-        && args.candidate_arcs.is_none()
-        && args.potential_edges.is_none()
-        && args.budget.is_none()
-        && args.max_cycle_length.is_none()
-        && args.precedence_pairs.is_none()
-        && args.resource_bounds.is_none()
-        && args.resource_requirements.is_none()
-        && args.task_lengths.is_none()
-        && args.job_tasks.is_none()
-        && args.deadline.is_none()
-        && args.num_processors.is_none()
-        && args.schedules.is_none()
-        && args.requirements.is_none()
-        && args.num_workers.is_none()
-        && args.num_periods.is_none()
-        && args.num_craftsmen.is_none()
-        && args.num_tasks.is_none()
-        && args.craftsman_avail.is_none()
-        && args.task_avail.is_none()
-        && args.alphabet_size.is_none()
-        && args.num_groups.is_none()
-        && args.num_sectors.is_none()
-        && args.link_lengths.is_none()
-        && args.target_point.is_none()
-        && args.orientation_samples.is_none()
-        && args.allowed_pairs.is_none()
-        && args.graph_1.is_none()
-        && args.graph_2.is_none()
-        && args.num_vertices_1.is_none()
-        && args.num_vertices_2.is_none()
-        && args.contacts_1.is_none()
-        && args.contacts_2.is_none()
-        && args.dependencies.is_none()
-        && args.num_attributes.is_none()
-        && args.source_string.is_none()
-        && args.target_string.is_none()
-        && args.pointer_cost.is_none()
-        && args.relation_attrs.is_none()
-        && args.known_keys.is_none()
-        && args.num_objects.is_none()
-        && args.attribute_domains.is_none()
-        && args.frequency_tables.is_none()
-        && args.known_values.is_none()
-        && args.domain_size.is_none()
-        && args.relations.is_none()
-        && args.conjuncts_spec.is_none()
-        && args.expression.is_none()
-        && args.deps.is_none()
-        && args.query.is_none()
-        && args.equations.is_none()
-        && args.coeff_a.is_none()
-        && args.coeff_b.is_none()
-        && args.rhs.is_none()
-        && args.coeff_c.is_none()
-        && args.pairs.is_none()
-        && args.required_columns.is_none()
-        && args.compilers.is_none()
-        && args.setup_times.is_none()
-        && args.w_sizes.is_none()
-        && args.x_sizes.is_none()
-        && args.y_sizes.is_none()
-        && args.assignment.is_none()
-        && args.initial_marking.is_none()
-        && args.output_arcs.is_none()
-        && args.gate_types.is_none()
-        && args.inputs.is_none()
-        && args.outputs.is_none()
-        && args.true_sentences.is_none()
-        && args.implications.is_none()
-        && args.loop_length.is_none()
-        && args.loop_variables.is_none()
-        && args.assignments.is_none()
-        && args.num_variables.is_none()
-        && args.truth_table.is_none()
-        && args.test_matrix.is_none()
-        && args.num_tests.is_none()
-        && args.tiles.is_none()
-        && args.grid_size.is_none()
-        && args.num_colors.is_none()
-        && args.vertex_prizes.is_none()
-        && args.edge_costs.is_none()
-        && args.beta.is_none()
-        && args.omega.is_none()
+    args.is_empty()
 }
 
 fn emit_problem_output(output: &ProblemJsonOutput, out: &OutputConfig) -> Result<()> {
@@ -240,17 +40,11 @@ fn emit_problem_output(output: &ProblemJsonOutput, out: &OutputConfig) -> Result
 }
 
 fn format_problem_ref(problem: &ProblemRef) -> String {
-    if problem.variant.is_empty() {
-        return problem.name.clone();
-    }
-
-    let values = problem
-        .variant
-        .values()
-        .cloned()
-        .collect::<Vec<_>>()
-        .join("/");
-    format!("{}/{}", problem.name, values)
+    format!(
+        "{}{}",
+        problem.name,
+        super::graph::variant_to_full_slash(&problem.name, &problem.variant)
+    )
 }
 
 fn ensure_attribute_indices_in_range(
@@ -313,7 +107,7 @@ fn parse_cdft_frequency_tables(
                 pair_key.1
             );
 
-            let rows: Vec<Vec<usize>> = counts_str
+            let rows: Vec<Vec<i64>> = counts_str
                 .split('|')
                 .map(|row| util::parse_comma_list(row.trim()))
                 .collect::<Result<_>>()?;
@@ -334,9 +128,15 @@ fn parse_cdft_frequency_tables(
                 );
             }
 
-            let total: usize = rows.iter().flatten().copied().sum();
+            let total = rows.iter().flatten().try_fold(0_i64, |sum, &count| {
+                anyhow::ensure!(count >= 0, "Frequency table counts must be nonnegative");
+                sum.checked_add(count)
+                    .ok_or_else(|| anyhow::anyhow!("Frequency table count total overflows i64"))
+            })?;
+            let expected_total = i64::try_from(num_objects)
+                .map_err(|_| anyhow::anyhow!("num_objects cannot be represented as i64"))?;
             anyhow::ensure!(
-                total == num_objects,
+                total == expected_total,
                 "Frequency table '{entry}' sums to {total}, expected num_objects={num_objects}"
             );
 
@@ -453,38 +253,7 @@ fn resolve_rule_example(
         })
 }
 
-fn parse_precedence_pairs(raw: Option<&str>) -> Result<Vec<(usize, usize)>> {
-    raw.filter(|s| !s.is_empty())
-        .map(|s| {
-            s.split(',')
-                .map(|pair| {
-                    let pair = pair.trim();
-                    let (pred, succ) = pair.split_once('>').ok_or_else(|| {
-                        anyhow::anyhow!(
-                            "Invalid --precedences value '{}': expected 'u>v'",
-                            pair
-                        )
-                    })?;
-                    let pred = pred.trim().parse::<usize>().map_err(|_| {
-                        anyhow::anyhow!(
-                            "Invalid --precedences value '{}': expected 'u>v' with nonnegative integer indices",
-                            pair
-                        )
-                    })?;
-                    let succ = succ.trim().parse::<usize>().map_err(|_| {
-                        anyhow::anyhow!(
-                            "Invalid --precedences value '{}': expected 'u>v' with nonnegative integer indices",
-                            pair
-                        )
-                    })?;
-                    Ok((pred, succ))
-                })
-                .collect()
-        })
-        .unwrap_or_else(|| Ok(vec![]))
-}
-
-fn parse_job_shop_jobs(raw: &str) -> Result<Vec<Vec<(usize, u64)>>> {
+fn parse_job_shop_jobs(raw: &str) -> Result<Vec<Vec<(usize, i64)>>> {
     let raw = raw.trim();
     if raw.is_empty() {
         return Ok(vec![]);
@@ -516,9 +285,9 @@ fn parse_job_shop_jobs(raw: &str) -> Result<Vec<Vec<(usize, u64)>>> {
                             task_str
                         )
                     })?;
-                    let length = length.trim().parse::<u64>().map_err(|_| {
+                    let length = length.trim().parse::<i64>().map_err(|_| {
                         anyhow::anyhow!(
-                            "Invalid --jobs operation '{}': length must be a nonnegative integer",
+                            "Invalid --jobs operation '{}': length must be an integer",
                             task_str
                         )
                     })?;
@@ -529,19 +298,6 @@ fn parse_job_shop_jobs(raw: &str) -> Result<Vec<Vec<(usize, u64)>>> {
         .collect()
 }
 
-fn validate_precedence_pairs(precedences: &[(usize, usize)], num_tasks: usize) -> Result<()> {
-    for &(pred, succ) in precedences {
-        anyhow::ensure!(
-            pred < num_tasks && succ < num_tasks,
-            "precedence index out of range: ({}, {}) but num_tasks = {}",
-            pred,
-            succ,
-            num_tasks
-        );
-    }
-    Ok(())
-}
-
 fn create_from_example(args: &CreateArgs, out: &OutputConfig) -> Result<()> {
     let example_spec = args
         .example
@@ -553,7 +309,7 @@ fn create_from_example(args: &CreateArgs, out: &OutputConfig) -> Result<()> {
             "Use either `pred create <PROBLEM>` or `pred create --example <PROBLEM_SPEC>`, not both"
         );
     }
-    if args.random || !all_data_flags_empty(args) {
+    if args.has("random") || !all_data_flags_empty(args) {
         bail!("`pred create --example` does not accept problem-construction flags");
     }
     let rgraph = problemreductions::rules::ReductionGraph::new();
@@ -590,34 +346,11 @@ pub fn create(args: &CreateArgs, out: &OutputConfig) -> Result<()> {
     let problem = args.problem.as_ref().ok_or_else(|| {
         anyhow::anyhow!("Missing problem type.\n\nUsage: pred create <PROBLEM> [FLAGS]")
     })?;
-    let rgraph = problemreductions::rules::ReductionGraph::new();
-    let resolved = match resolve_problem_ref(problem, &rgraph) {
-        Ok(resolved) => resolved,
-        Err(graph_err) => match resolve_catalog_problem_ref(problem) {
-            Ok(catalog_resolved) => {
-                if rgraph.variants_for(catalog_resolved.name()).is_empty() {
-                    ProblemRef {
-                        name: catalog_resolved.name().to_string(),
-                        variant: catalog_resolved.variant().clone(),
-                    }
-                } else {
-                    return Err(graph_err);
-                }
-            }
-            Err(catalog_err) => {
-                let spec = parse_problem_spec(problem)?;
-                if rgraph.variants_for(&spec.name).is_empty() {
-                    return Err(catalog_err);
-                }
-                return Err(graph_err);
-            }
-        },
-    };
-    let canonical = resolved.name.as_str();
-    let resolved_variant = resolved.variant.clone();
+    let (canonical, resolved_variant) =
+        crate::create_args::resolve_registered_create_variant(problem);
 
-    if args.random {
-        return create_random(args, canonical, &resolved_variant, out);
+    if args.has("random") {
+        return create_registered_random(args, canonical, &resolved_variant, out);
     }
 
     // ILP and CircuitSAT have complex input structures
@@ -627,23 +360,12 @@ pub fn create(args: &CreateArgs, out: &OutputConfig) -> Result<()> {
         bail!(
             "CLI creation is not yet supported for {canonical}.\n\n\
              {canonical} instances are typically created via reduction:\n\
-               pred create MIS --graph 0-1,1-2 | pred reduce - --to {canonical}\n\n\
+               pred create MIS --graph 0-1,1-2 | pred reduce - --via route.json\n\n\
              Or use the Rust API for direct construction."
         );
     }
 
-    // Show schema-driven help when no data flags are provided
-    if all_data_flags_empty(args) {
-        print_problem_help(canonical, &resolved_variant)?;
-        std::process::exit(2);
-    }
-
-    let (data, variant) = create_schema_driven(args, canonical, &resolved_variant)?
-        .ok_or_else(|| {
-            anyhow::anyhow!(
-                "Schema-driven creation unexpectedly returned no instance for {canonical}. This indicates a missing parser, flag mapping, derived field, or schema/factory mismatch in create.rs."
-            )
-        })?;
+    let (data, variant) = create_schema_driven(args, canonical, &resolved_variant)?;
 
     let output = ProblemJsonOutput {
         problem_type: canonical.to_string(),
@@ -654,514 +376,46 @@ pub fn create(args: &CreateArgs, out: &OutputConfig) -> Result<()> {
     emit_problem_output(&output, out)
 }
 
-/// Reject non-unit weights when the resolved variant uses `weight=One`.
-fn reject_nonunit_weights_for_one_variant(
-    canonical: &str,
-    graph_type: &str,
-    variant: &BTreeMap<String, String>,
-    weights: &[i32],
-) -> Result<()> {
-    if variant.get("weight").map(|w| w.as_str()) == Some("One") && weights.iter().any(|&w| w != 1) {
-        bail!(
-            "Non-unit weights are not supported for the default unit-weight variant.\n\n\
-             Use the weighted variant instead:\n  \
-             pred create {canonical}/{graph_type}/i32 --graph ... --weights ..."
-        );
-    }
-    Ok(())
-}
-
-/// Create a vertex-weight problem dispatching on geometry graph type.
-/// Serialize a vertex-weight problem with a generic graph type.
-fn ser_vertex_weight_problem_with<G: Graph + Serialize>(
-    canonical: &str,
-    graph: G,
-    weights: Vec<i32>,
-) -> Result<serde_json::Value> {
-    match canonical {
-        "MaximumIndependentSet" => ser(MaximumIndependentSet::new(graph, weights)),
-        "MinimumVertexCover" => ser(MinimumVertexCover::new(graph, weights)),
-        "MaximumClique" => ser(MaximumClique::new(graph, weights)),
-        "MinimumDominatingSet" => ser(MinimumDominatingSet::new(graph, weights)),
-        "MaximalIS" => ser(MaximalIS::new(graph, weights)),
-        _ => unreachable!(),
-    }
-}
-
-fn ser_decision_minimum_vertex_cover_with<
-    G: Graph + Serialize + problemreductions::variant::VariantParam,
->(
-    graph: G,
-    weights: Vec<i32>,
-    bound: i32,
-) -> Result<serde_json::Value> {
-    ser(Decision::new(
-        MinimumVertexCover::new(graph, weights),
-        bound,
-    ))
-}
-
-fn ser<T: Serialize>(problem: T) -> Result<serde_json::Value> {
-    util::ser(problem)
-}
-
-fn parse_kclique_threshold(
-    k_flag: Option<usize>,
-    num_vertices: usize,
-    usage: &str,
-) -> Result<usize> {
-    let k = k_flag.ok_or_else(|| anyhow::anyhow!("KClique requires --k\n\n{usage}"))?;
-    if k == 0 {
-        bail!("KClique: --k must be positive");
-    }
-    if k > num_vertices {
-        bail!("KClique: k must be <= graph num_vertices");
-    }
-    Ok(k)
-}
-
-fn variant_map(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
-    util::variant_map(pairs)
-}
-
-fn parse_bipartite_problem_input(
+fn create_registered_random(
     args: &CreateArgs,
     canonical: &str,
-    k_description: &str,
-    usage: &str,
-) -> Result<(BipartiteGraph, usize)> {
-    let left = args.left.ok_or_else(|| {
-        anyhow::anyhow!(
-            "{canonical} requires --left, --right, --biedges, and --k\n\nUsage: {usage}"
-        )
-    })?;
-    let right = args.right.ok_or_else(|| {
-        anyhow::anyhow!("{canonical} requires --right (right partition size)\n\nUsage: {usage}")
-    })?;
-    let k = args.k.ok_or_else(|| {
-        anyhow::anyhow!("{canonical} requires --k ({k_description})\n\nUsage: {usage}")
-    })?;
-    let edges_str = args.biedges.as_deref().ok_or_else(|| {
-        anyhow::anyhow!("{canonical} requires --biedges (e.g., 0-0,0-1,1-1)\n\nUsage: {usage}")
-    })?;
-    let edges = util::parse_edge_pairs(edges_str)?;
-    validate_bipartite_edges(canonical, left, right, &edges)?;
-    Ok((BipartiteGraph::new(left, right, edges), k))
-}
-
-fn validate_bipartite_edges(
-    canonical: &str,
-    left: usize,
-    right: usize,
-    edges: &[(usize, usize)],
+    resolved_variant: &BTreeMap<String, String>,
+    out: &OutputConfig,
 ) -> Result<()> {
-    for &(u, v) in edges {
-        if u >= left {
-            bail!("{canonical} edge {u}-{v} is out of bounds for left partition size {left}");
-        }
-        if v >= right {
-            bail!("{canonical} edge {u}-{v} is out of bounds for right partition size {right}");
-        }
-    }
-    Ok(())
-}
-
-/// Parse `--graph` into a SimpleGraph, optionally preserving isolated vertices
-/// via `--num-vertices`.
-fn parse_graph(args: &CreateArgs) -> Result<(SimpleGraph, usize)> {
-    let edges_str = args
-        .graph
-        .as_deref()
-        .ok_or_else(|| anyhow::anyhow!("This problem requires --graph (e.g., 0-1,1-2,2-3)"))?;
-
-    if edges_str.trim().is_empty() {
-        let num_vertices = args.num_vertices.ok_or_else(|| {
+    let entry = problemreductions::registry::find_variant_entry(canonical, resolved_variant)
+        .ok_or_else(|| {
             anyhow::anyhow!(
-                "Empty graph string. To create a graph with isolated vertices, pass --num-vertices N as well."
+                "No concrete variant is registered for {canonical} with {resolved_variant:?}"
             )
         })?;
-        return Ok((SimpleGraph::empty(num_vertices), num_vertices));
-    }
-
-    let edges: Vec<(usize, usize)> = edges_str
-        .split(',')
-        .map(|pair| {
-            let parts: Vec<&str> = pair.trim().split('-').collect();
-            if parts.len() != 2 {
-                bail!("Invalid edge '{}': expected format u-v", pair.trim());
-            }
-            let u: usize = parts[0].parse()?;
-            let v: usize = parts[1].parse()?;
-            if u == v {
-                bail!(
-                    "Self-loop detected: edge {}-{}. Simple graphs do not allow self-loops",
-                    u,
-                    v
-                );
-            }
-            Ok((u, v))
-        })
-        .collect::<Result<Vec<_>>>()?;
-
-    let inferred_num_vertices = edges
-        .iter()
-        .flat_map(|(u, v)| [*u, *v])
-        .max()
-        .map(|m| m + 1)
-        .unwrap_or(0);
-    let num_vertices = match args.num_vertices {
-        Some(explicit) if explicit < inferred_num_vertices => {
-            bail!(
-                "--num-vertices {} is too small for the provided graph; need at least {}",
-                explicit,
-                inferred_num_vertices
-            );
-        }
-        Some(explicit) => explicit,
-        None => inferred_num_vertices,
-    };
-
-    Ok((SimpleGraph::new(num_vertices, edges), num_vertices))
-}
-
-/// Parse `--positions` as integer grid positions.
-fn parse_int_positions(args: &CreateArgs) -> Result<Vec<(i32, i32)>> {
-    let pos_str = args.positions.as_deref().ok_or_else(|| {
-        anyhow::anyhow!("This variant requires --positions (e.g., \"0,0;1,0;1,1\")")
-    })?;
-    util::parse_positions(pos_str, "0,0")
-}
-
-/// Parse `--positions` as float positions.
-fn parse_float_positions(args: &CreateArgs) -> Result<Vec<(f64, f64)>> {
-    let pos_str = args.positions.as_deref().ok_or_else(|| {
-        anyhow::anyhow!("This variant requires --positions (e.g., \"0.0,0.0;1.0,0.0;0.5,0.87\")")
-    })?;
-    util::parse_positions(pos_str, "0.0,0.0")
-}
-
-/// Parse `--weights` as vertex weights (i32), defaulting to all 1s.
-fn parse_vertex_weights(args: &CreateArgs, num_vertices: usize) -> Result<Vec<i32>> {
-    match &args.weights {
-        Some(w) => {
-            let weights: Vec<i32> = w
-                .split(',')
-                .map(|s| s.trim().parse::<i32>())
-                .collect::<std::result::Result<Vec<_>, _>>()?;
-            if weights.len() != num_vertices {
-                bail!(
-                    "Expected {} weights but got {}",
-                    num_vertices,
-                    weights.len()
-                );
-            }
-            Ok(weights)
-        }
-        None => Ok(vec![1i32; num_vertices]),
-    }
-}
-
-fn parse_i32_edge_values(
-    values: Option<&String>,
-    num_edges: usize,
-    value_label: &str,
-) -> Result<Vec<i32>> {
-    match values {
-        Some(raw) => {
-            let parsed: Vec<i32> = raw
-                .split(',')
-                .map(|s| s.trim().parse::<i32>())
-                .collect::<std::result::Result<Vec<_>, _>>()?;
-            if parsed.len() != num_edges {
-                bail!(
-                    "Expected {} {} values but got {}",
-                    num_edges,
-                    value_label,
-                    parsed.len()
-                );
-            }
-            Ok(parsed)
-        }
-        None => Ok(vec![1i32; num_edges]),
-    }
-}
-
-fn parse_vertex_i64_values(
-    raw: Option<&str>,
-    field_name: &str,
-    num_vertices: usize,
-    problem_name: &str,
-    usage: &str,
-) -> Result<Vec<i64>> {
-    let raw =
-        raw.ok_or_else(|| anyhow::anyhow!("{problem_name} requires --{field_name}\n\n{usage}"))?;
-    let values: Vec<i64> = util::parse_comma_list(raw)
-        .map_err(|e| anyhow::anyhow!("invalid {field_name} list: {e}\n\n{usage}"))?;
-    if values.len() != num_vertices {
-        bail!(
-            "Expected {} {} values but got {}\n\n{}",
-            num_vertices,
-            field_name,
-            values.len(),
-            usage
-        );
-    }
-    Ok(values)
-}
-
-/// Parse `--terminals` as comma-separated vertex indices.
-fn parse_terminals(args: &CreateArgs, num_vertices: usize) -> Result<Vec<usize>> {
-    let s = args
-        .terminals
-        .as_deref()
-        .ok_or_else(|| anyhow::anyhow!("--terminals required (e.g., \"0,2,4\")"))?;
-    let terminals: Vec<usize> = s
-        .split(',')
-        .map(|t| t.trim().parse::<usize>())
-        .collect::<std::result::Result<Vec<_>, _>>()
-        .context("invalid terminal index")?;
-    for &t in &terminals {
-        anyhow::ensure!(
-            t < num_vertices,
-            "terminal {t} >= num_vertices ({num_vertices})"
-        );
-    }
-    let distinct_terminals: BTreeSet<_> = terminals.iter().copied().collect();
-    anyhow::ensure!(
-        distinct_terminals.len() == terminals.len(),
-        "terminals must be distinct"
-    );
-    anyhow::ensure!(terminals.len() >= 2, "at least 2 terminals required");
-    Ok(terminals)
-}
-
-/// Parse `--terminal-pairs` as comma-separated `u-v` vertex pairs.
-fn parse_terminal_pairs(args: &CreateArgs, num_vertices: usize) -> Result<Vec<(usize, usize)>> {
-    let raw = args
-        .terminal_pairs
-        .as_deref()
-        .ok_or_else(|| anyhow::anyhow!("--terminal-pairs required (e.g., \"0-3,2-5\")"))?;
-    let terminal_pairs = util::parse_edge_pairs(raw)?;
-    anyhow::ensure!(
-        !terminal_pairs.is_empty(),
-        "at least 1 terminal pair required"
-    );
-
-    let mut used = BTreeSet::new();
-    for &(source, sink) in &terminal_pairs {
-        anyhow::ensure!(
-            source < num_vertices,
-            "terminal pair source {source} >= num_vertices ({num_vertices})"
-        );
-        anyhow::ensure!(
-            sink < num_vertices,
-            "terminal pair sink {sink} >= num_vertices ({num_vertices})"
-        );
-        anyhow::ensure!(source != sink, "terminal pair endpoints must be distinct");
-        anyhow::ensure!(
-            used.insert(source) && used.insert(sink),
-            "terminal vertices must be pairwise disjoint across terminal pairs"
-        );
-    }
-
-    Ok(terminal_pairs)
-}
-
-fn ensure_positive_i32_values(values: &[i32], label: &str) -> Result<()> {
-    if values.iter().any(|&value| value <= 0) {
-        bail!("All {label} must be positive (> 0)");
-    }
-    Ok(())
-}
-
-fn ensure_positive_i32(value: i32, label: &str) -> Result<()> {
-    if value <= 0 {
-        bail!("{label} must be positive (> 0)");
-    }
-    Ok(())
-}
-
-fn ensure_vertex_in_bounds(vertex: usize, num_vertices: usize, label: &str) -> Result<()> {
-    if vertex >= num_vertices {
-        bail!("{label} {vertex} out of bounds (graph has {num_vertices} vertices)");
-    }
-    Ok(())
-}
-
-/// Parse `--edge-weights` as per-edge numeric values (i32), defaulting to all 1s.
-fn parse_edge_weights(args: &CreateArgs, num_edges: usize) -> Result<Vec<i32>> {
-    parse_i32_edge_values(args.edge_weights.as_ref(), num_edges, "edge weight")
-}
-
-fn validate_vertex_index(
-    label: &str,
-    vertex: usize,
-    num_vertices: usize,
-    usage: &str,
-) -> Result<()> {
-    if vertex < num_vertices {
-        return Ok(());
-    }
-
-    bail!("{label} must be less than num_vertices ({num_vertices})\n\n{usage}");
-}
-
-/// Parse `--capacities` as edge capacities (u64).
-fn parse_capacities(args: &CreateArgs, num_edges: usize, usage: &str) -> Result<Vec<u64>> {
-    let capacities = args
-        .capacities
-        .as_deref()
-        .ok_or_else(|| anyhow::anyhow!("This problem requires --capacities\n\n{usage}"))?;
-    let capacities: Vec<u64> = capacities
-        .split(',')
-        .map(|s| {
-            let trimmed = s.trim();
-            trimmed
-                .parse::<u64>()
-                .with_context(|| format!("Invalid capacity `{trimmed}`\n\n{usage}"))
-        })
-        .collect::<Result<Vec<_>>>()?;
-    if capacities.len() != num_edges {
-        bail!(
-            "Expected {} capacities but got {}\n\n{}",
-            num_edges,
-            capacities.len(),
-            usage
-        );
-    }
-    Ok(capacities)
-}
-
-/// Parse `--lower-bounds` as edge lower bounds (u64).
-fn parse_lower_bounds(args: &CreateArgs, num_edges: usize, usage: &str) -> Result<Vec<u64>> {
-    let lower_bounds = args.lower_bounds.as_deref().ok_or_else(|| {
-        anyhow::anyhow!("UndirectedFlowLowerBounds requires --lower-bounds\n\n{usage}")
-    })?;
-    let lower_bounds: Vec<u64> = lower_bounds
-        .split(',')
-        .map(|s| {
-            let trimmed = s.trim();
-            trimmed
-                .parse::<u64>()
-                .with_context(|| format!("Invalid lower bound `{trimmed}`\n\n{usage}"))
-        })
-        .collect::<Result<Vec<_>>>()?;
-    if lower_bounds.len() != num_edges {
-        bail!(
-            "Expected {} lower bounds but got {}\n\n{}",
-            num_edges,
-            lower_bounds.len(),
-            usage
-        );
-    }
-    Ok(lower_bounds)
-}
-
-fn parse_bundle_capacities(args: &CreateArgs, num_bundles: usize, usage: &str) -> Result<Vec<u64>> {
-    let capacities = args.bundle_capacities.as_deref().ok_or_else(|| {
-        anyhow::anyhow!("IntegralFlowBundles requires --bundle-capacities\n\n{usage}")
-    })?;
-    let capacities: Vec<u64> = capacities
-        .split(',')
-        .map(|s| {
-            let trimmed = s.trim();
-            trimmed
-                .parse::<u64>()
-                .with_context(|| format!("Invalid bundle capacity `{trimmed}`\n\n{usage}"))
-        })
-        .collect::<Result<Vec<_>>>()?;
-    anyhow::ensure!(
-        capacities.len() == num_bundles,
-        "Expected {} bundle capacities but got {}\n\n{}",
-        num_bundles,
-        capacities.len(),
-        usage
-    );
-    for (bundle_index, &capacity) in capacities.iter().enumerate() {
-        let fits = usize::try_from(capacity)
-            .ok()
-            .and_then(|value| value.checked_add(1))
-            .is_some();
-        anyhow::ensure!(
-            fits,
-            "bundle capacity {} at bundle index {} is too large for this platform\n\n{}",
-            capacity,
-            bundle_index,
-            usage
-        );
-        anyhow::ensure!(
-            capacity > 0,
-            "bundle capacity at bundle index {} must be positive\n\n{}",
-            bundle_index,
-            usage
-        );
-    }
-    Ok(capacities)
-}
-
-/// Parse `--couplings` as SpinGlass pairwise couplings (i32), defaulting to all 1s.
-/// Parse `--fields` as SpinGlass on-site fields (i32), defaulting to all 0s.
-/// Check if a CLI string value contains float syntax (a decimal point).
-/// Parse `--couplings` as SpinGlass pairwise couplings (f64), defaulting to all 1.0.
-/// Parse `--fields` as SpinGlass on-site fields (f64), defaulting to all 0.0.
-/// Parse `--clauses` as semicolon-separated clauses of comma-separated literals.
-/// E.g., "1,2;-1,3;2,-3"
-/// Parse `--subsets` as semicolon-separated sets of comma-separated usize.
-/// E.g., "0,1;1,2;0,2"
-fn parse_sets(args: &CreateArgs) -> Result<Vec<Vec<usize>>> {
-    parse_named_sets(args.sets.as_deref(), "--subsets")
-}
-
-fn parse_named_sets(sets_str: Option<&str>, flag: &str) -> Result<Vec<Vec<usize>>> {
-    let sets_str = sets_str
-        .ok_or_else(|| anyhow::anyhow!("This problem requires {flag} (e.g., \"0,1;1,2;0,2\")"))?;
-    sets_str
-        .split(';')
-        .map(|set| {
-            set.trim()
-                .split(',')
-                .map(|s| {
-                    s.trim()
-                        .parse::<usize>()
-                        .map_err(|e| anyhow::anyhow!("Invalid set element: {}", e))
-                })
-                .collect()
-        })
-        .collect()
-}
-
-fn parse_homologous_pairs(args: &CreateArgs) -> Result<Vec<(usize, usize)>> {
-    let pairs = args.homologous_pairs.as_deref().ok_or_else(|| {
+    let random = entry.random.ok_or_else(|| {
         anyhow::anyhow!(
-            "IntegralFlowHomologousArcs requires --homologous-pairs (e.g., \"2=5;4=3\")"
+            "Random generation is not registered for {}",
+            problemreductions::registry::variant::variant_label(entry)
         )
     })?;
-
-    pairs
-        .split(';')
-        .filter(|entry| !entry.trim().is_empty())
-        .map(|entry| {
-            let entry = entry.trim();
-            let (left, right) = entry.split_once('=').ok_or_else(|| {
-                anyhow::anyhow!(
-                    "Invalid homologous pair '{}': expected format u=v (e.g., 2=5)",
-                    entry
-                )
-            })?;
-            let left = left.trim().parse::<usize>().with_context(|| {
-                format!("Invalid homologous pair '{}': expected format u=v", entry)
-            })?;
-            let right = right.trim().parse::<usize>().with_context(|| {
-                format!("Invalid homologous pair '{}': expected format u=v", entry)
-            })?;
-            Ok((left, right))
-        })
-        .collect()
+    let inputs = (random.inputs)();
+    let inputs = inputs.as_slice();
+    let data = normalize_registered_create_inputs(args, inputs, resolved_variant)
+        .map_err(|error| with_registered_usage(error, canonical, inputs))?;
+    let problem = (random.generate)(data)
+        .map_err(|error| with_registered_usage(error.into(), canonical, inputs))?;
+    let variant = problem.variant_map();
+    anyhow::ensure!(
+        problem.problem_name() == canonical && variant == *resolved_variant,
+        "registered random generator for {canonical} {resolved_variant:?} returned {} {variant:?}",
+        problem.problem_name(),
+    );
+    emit_problem_output(
+        &ProblemJsonOutput {
+            problem_type: canonical.to_string(),
+            variant,
+            data: problem.serialize_json(),
+        },
+        out,
+    )
 }
 
-/// Parse a dependency string as semicolon-separated `lhs>rhs` pairs.
-/// E.g., "0,1>2,3;2,3>0,1"
-/// Parse a comma-separated list of usize indices.
 /// Parse `--dependencies` as semicolon-separated "lhs>rhs" pairs.
 /// E.g., "0,1>2;0,2>3;1,3>4;2,4>5" means {0,1}->{2}, {0,2}->{3}, etc.
 fn parse_dependencies(input: &str) -> Result<Vec<(Vec<usize>, Vec<usize>)>> {
@@ -1195,228 +449,20 @@ fn parse_dependencies(input: &str) -> Result<Vec<(Vec<usize>, Vec<usize>)>> {
         .collect()
 }
 
-fn validate_comparative_containment_sets(
-    family_name: &str,
-    flag: &str,
-    universe_size: usize,
-    sets: &[Vec<usize>],
-) -> Result<()> {
-    for (set_index, set) in sets.iter().enumerate() {
-        for &element in set {
-            anyhow::ensure!(
-                element < universe_size,
-                "{family_name} set {set_index} from {flag} contains element {element} outside universe of size {universe_size}"
-            );
-        }
-    }
-    Ok(())
-}
-
-/// Parse `--partition` as semicolon-separated groups of comma-separated arc indices.
-/// E.g., "0,1;2,3;4,7;5,6"
-fn parse_partition_groups(args: &CreateArgs, num_arcs: usize) -> Result<Vec<Vec<usize>>> {
-    let partition_str = args.partition.as_deref().ok_or_else(|| {
-        anyhow::anyhow!("MultipleChoiceBranching requires --partition (e.g., \"0,1;2,3;4,7;5,6\")")
-    })?;
-
-    let partition: Vec<Vec<usize>> = partition_str
+/// Parse `--matrix` as semicolon-separated rows of comma-separated bool values (0/1).
+/// E.g., "1,0;0,1;1,1"
+fn parse_bool_rows(rows_str: &str) -> Result<Vec<Vec<bool>>> {
+    let matrix: Vec<Vec<bool>> = rows_str
         .split(';')
-        .map(|group| {
-            group
-                .trim()
+        .map(|row| {
+            row.trim()
                 .split(',')
-                .map(|s| {
-                    s.trim()
-                        .parse::<usize>()
-                        .map_err(|e| anyhow::anyhow!("Invalid partition index: {}", e))
-                })
-                .collect()
-        })
-        .collect::<Result<_>>()?;
-
-    let mut seen = vec![false; num_arcs];
-    for group in &partition {
-        for &arc_index in group {
-            anyhow::ensure!(
-                arc_index < num_arcs,
-                "partition arc index {} out of range for {} arcs",
-                arc_index,
-                num_arcs
-            );
-            anyhow::ensure!(
-                !seen[arc_index],
-                "partition arc index {} appears more than once",
-                arc_index
-            );
-            seen[arc_index] = true;
-        }
-    }
-    anyhow::ensure!(
-        seen.iter().all(|present| *present),
-        "partition must cover every arc exactly once"
-    );
-
-    Ok(partition)
-}
-
-fn parse_bundles(args: &CreateArgs, num_arcs: usize, usage: &str) -> Result<Vec<Vec<usize>>> {
-    let bundles_str = args
-        .bundles
-        .as_deref()
-        .ok_or_else(|| anyhow::anyhow!("IntegralFlowBundles requires --bundles\n\n{usage}"))?;
-
-    let bundles: Vec<Vec<usize>> = bundles_str
-        .split(';')
-        .map(|bundle| {
-            let bundle = bundle.trim();
-            anyhow::ensure!(
-                !bundle.is_empty(),
-                "IntegralFlowBundles does not allow empty bundle entries\n\n{usage}"
-            );
-            bundle
-                .split(',')
-                .map(|s| {
-                    s.trim().parse::<usize>().with_context(|| {
-                        format!("Invalid bundle arc index `{}`\n\n{usage}", s.trim())
-                    })
-                })
-                .collect::<Result<Vec<_>>>()
-        })
-        .collect::<Result<_>>()?;
-
-    let mut seen_overall = vec![false; num_arcs];
-    for (bundle_index, bundle) in bundles.iter().enumerate() {
-        let mut seen_in_bundle = BTreeSet::new();
-        for &arc_index in bundle {
-            anyhow::ensure!(
-                arc_index < num_arcs,
-                "bundle {bundle_index} references arc {arc_index}, but num_arcs is {num_arcs}\n\n{usage}"
-            );
-            anyhow::ensure!(
-                seen_in_bundle.insert(arc_index),
-                "bundle {bundle_index} contains duplicate arc index {arc_index}\n\n{usage}"
-            );
-            seen_overall[arc_index] = true;
-        }
-    }
-    anyhow::ensure!(
-        seen_overall.iter().all(|covered| *covered),
-        "bundles must cover every arc at least once\n\n{usage}"
-    );
-
-    Ok(bundles)
-}
-
-fn parse_multiple_choice_branching_threshold(args: &CreateArgs, usage: &str) -> Result<i32> {
-    let raw_bound = args.bound.ok_or_else(|| {
-        anyhow::anyhow!("MultipleChoiceBranching requires --threshold\n\n{usage}")
-    })?;
-    anyhow::ensure!(
-        raw_bound >= 0,
-        "MultipleChoiceBranching threshold must be non-negative, got {raw_bound}"
-    );
-    i32::try_from(raw_bound).map_err(|_| {
-        anyhow::anyhow!(
-            "MultipleChoiceBranching threshold must fit in a 32-bit signed integer, got {raw_bound}"
-        )
-    })
-}
-
-/// Parse `--weights` for set-based problems (i32), defaulting to all 1s.
-fn parse_named_set_weights(
-    weights_str: Option<&str>,
-    num_sets: usize,
-    flag: &str,
-) -> Result<Vec<i32>> {
-    match weights_str {
-        Some(w) => {
-            let weights: Vec<i32> = util::parse_comma_list(w)?;
-            if weights.len() != num_sets {
-                bail!(
-                    "Expected {} values for {} but got {}",
-                    num_sets,
-                    flag,
-                    weights.len()
-                );
-            }
-            Ok(weights)
-        }
-        None => Ok(vec![1i32; num_sets]),
-    }
-}
-
-fn parse_named_set_weights_f64(
-    weights_str: Option<&str>,
-    num_sets: usize,
-    flag: &str,
-) -> Result<Vec<f64>> {
-    match weights_str {
-        Some(w) => {
-            let weights: Vec<f64> = util::parse_comma_list(w)?;
-            if weights.len() != num_sets {
-                bail!(
-                    "Expected {} values for {} but got {}",
-                    num_sets,
-                    flag,
-                    weights.len()
-                );
-            }
-            Ok(weights)
-        }
-        None => Ok(vec![1.0f64; num_sets]),
-    }
-}
-
-fn validate_comparative_containment_i32_weights(
-    family_name: &str,
-    flag: &str,
-    weights: &[i32],
-) -> Result<()> {
-    for (index, weight) in weights.iter().enumerate() {
-        anyhow::ensure!(
-            *weight > 0,
-            "{family_name} weights from {flag} must be positive; found {weight} at index {index}"
-        );
-    }
-    Ok(())
-}
-
-fn validate_comparative_containment_f64_weights(
-    family_name: &str,
-    flag: &str,
-    weights: &[f64],
-) -> Result<()> {
-    for (index, weight) in weights.iter().enumerate() {
-        anyhow::ensure!(
-            weight.is_finite() && *weight > 0.0,
-            "{family_name} weights from {flag} must be finite and positive; found {weight} at index {index}"
-        );
-    }
-    Ok(())
-}
-
-/// Parse `--matrix` as semicolon-separated rows of comma-separated bool values (0/1).
-/// E.g., "1,0;0,1;1,1"
-fn parse_bool_matrix(args: &CreateArgs) -> Result<Vec<Vec<bool>>> {
-    let matrix_str = args
-        .matrix
-        .as_deref()
-        .ok_or_else(|| anyhow::anyhow!("This problem requires --matrix (e.g., \"1,0;0,1;1,1\")"))?;
-    parse_bool_rows(matrix_str)
-}
-
-fn parse_bool_rows(rows_str: &str) -> Result<Vec<Vec<bool>>> {
-    let matrix: Vec<Vec<bool>> = rows_str
-        .split(';')
-        .map(|row| {
-            row.trim()
-                .split(',')
-                .map(|entry| match entry.trim() {
-                    "1" | "true" => Ok(true),
-                    "0" | "false" => Ok(false),
-                    other => Err(anyhow::anyhow!(
-                        "Invalid boolean entry '{other}': expected 0/1 or true/false"
-                    )),
+                .map(|entry| match entry.trim() {
+                    "1" | "true" => Ok(true),
+                    "0" | "false" => Ok(false),
+                    other => Err(anyhow::anyhow!(
+                        "Invalid boolean entry '{other}': expected 0/1 or true/false"
+                    )),
                 })
                 .collect()
         })
@@ -1432,236 +478,6 @@ fn parse_bool_rows(rows_str: &str) -> Result<Vec<Vec<bool>>> {
     Ok(matrix)
 }
 
-fn parse_named_u64_list(
-    raw: Option<&str>,
-    problem: &str,
-    flag: &str,
-    usage: &str,
-) -> Result<Vec<u64>> {
-    let raw = raw.ok_or_else(|| anyhow::anyhow!("{problem} requires {flag}\n\n{usage}"))?;
-    util::parse_comma_list(raw).map_err(|err| anyhow::anyhow!("{err}\n\n{usage}"))
-}
-
-fn ensure_named_len(len: usize, expected: usize, flag: &str, usage: &str) -> Result<()> {
-    anyhow::ensure!(
-        len == expected,
-        "{flag} must contain exactly {expected} entries\n\n{usage}"
-    );
-    Ok(())
-}
-
-fn parse_named_bool_rows(rows: Option<&str>, flag: &str, usage: &str) -> Result<Vec<Vec<bool>>> {
-    let rows = rows.ok_or_else(|| anyhow::anyhow!("TimetableDesign requires {flag}\n\n{usage}"))?;
-    parse_bool_rows(rows).map_err(|err| {
-        let message = err.to_string().replace("--matrix", flag);
-        anyhow::anyhow!("{message}\n\n{usage}")
-    })
-}
-
-fn parse_timetable_requirements(requirements: Option<&str>, usage: &str) -> Result<Vec<Vec<u64>>> {
-    let requirements = requirements
-        .ok_or_else(|| anyhow::anyhow!("TimetableDesign requires --requirements\n\n{usage}"))?;
-    let matrix: Vec<Vec<u64>> = requirements
-        .split(';')
-        .map(|row| util::parse_comma_list(row.trim()))
-        .collect::<Result<_>>()?;
-
-    if let Some(expected_width) = matrix.first().map(Vec::len) {
-        anyhow::ensure!(
-            matrix.iter().all(|row| row.len() == expected_width),
-            "All rows in --requirements must have the same length"
-        );
-    }
-
-    Ok(matrix)
-}
-
-fn validate_timetable_design_args(
-    num_periods: usize,
-    num_craftsmen: usize,
-    num_tasks: usize,
-    craftsman_avail: &[Vec<bool>],
-    task_avail: &[Vec<bool>],
-    requirements: &[Vec<u64>],
-    usage: &str,
-) -> Result<()> {
-    anyhow::ensure!(
-        craftsman_avail.len() == num_craftsmen,
-        "craftsman availability row count ({}) must equal num_craftsmen ({})\n\n{}",
-        craftsman_avail.len(),
-        num_craftsmen,
-        usage
-    );
-    anyhow::ensure!(
-        task_avail.len() == num_tasks,
-        "task availability row count ({}) must equal num_tasks ({})\n\n{}",
-        task_avail.len(),
-        num_tasks,
-        usage
-    );
-    anyhow::ensure!(
-        requirements.len() == num_craftsmen,
-        "requirements row count ({}) must equal num_craftsmen ({})\n\n{}",
-        requirements.len(),
-        num_craftsmen,
-        usage
-    );
-
-    for (index, row) in craftsman_avail.iter().enumerate() {
-        anyhow::ensure!(
-            row.len() == num_periods,
-            "craftsman availability row {} has {} periods, expected {}\n\n{}",
-            index,
-            row.len(),
-            num_periods,
-            usage
-        );
-    }
-    for (index, row) in task_avail.iter().enumerate() {
-        anyhow::ensure!(
-            row.len() == num_periods,
-            "task availability row {} has {} periods, expected {}\n\n{}",
-            index,
-            row.len(),
-            num_periods,
-            usage
-        );
-    }
-    for (index, row) in requirements.iter().enumerate() {
-        anyhow::ensure!(
-            row.len() == num_tasks,
-            "requirements row {} has {} tasks, expected {}\n\n{}",
-            index,
-            row.len(),
-            num_tasks,
-            usage
-        );
-    }
-
-    Ok(())
-}
-
-/// Parse `--matrix` as semicolon-separated rows of comma-separated f64 values.
-/// E.g., "1,0.5;0.5,2"
-fn parse_matrix(args: &CreateArgs) -> Result<Vec<Vec<f64>>> {
-    let matrix_str = args
-        .matrix
-        .as_deref()
-        .ok_or_else(|| anyhow::anyhow!("QUBO requires --matrix (e.g., \"1,0.5;0.5,2\")"))?;
-
-    matrix_str
-        .split(';')
-        .map(|row| {
-            row.trim()
-                .split(',')
-                .map(|s| {
-                    s.trim()
-                        .parse::<f64>()
-                        .map_err(|e| anyhow::anyhow!("Invalid matrix value: {}", e))
-                })
-                .collect()
-        })
-        .collect()
-}
-
-fn parse_u64_matrix_rows(matrix_str: &str, matrix_name: &str) -> Result<Vec<Vec<u64>>> {
-    matrix_str
-        .split(';')
-        .enumerate()
-        .map(|(row_index, row)| {
-            let row = row.trim();
-            anyhow::ensure!(
-                !row.is_empty(),
-                "{matrix_name} row {row_index} must not be empty"
-            );
-            row.split(',')
-                .map(|value| {
-                    value.trim().parse::<u64>().map_err(|error| {
-                        anyhow::anyhow!(
-                            "Invalid {matrix_name} row {row_index} value {:?}: {}",
-                            value.trim(),
-                            error
-                        )
-                    })
-                })
-                .collect()
-        })
-        .collect()
-}
-
-/// Parse `--quantifiers` as comma-separated quantifier labels (E/A or Exists/ForAll).
-/// E.g., "E,A,E" or "Exists,ForAll,Exists"
-/// Parse a semicolon-separated matrix of i64 values.
-/// E.g., "0,5;5,0"
-fn parse_potential_edges(args: &CreateArgs) -> Result<Vec<(usize, usize, i32)>> {
-    let edges_str = args.potential_edges.as_deref().ok_or_else(|| {
-        anyhow::anyhow!(
-            "BiconnectivityAugmentation requires --potential-weights (e.g., 0-2:3,1-3:5)"
-        )
-    })?;
-
-    edges_str
-        .split(',')
-        .map(|entry| {
-            let entry = entry.trim();
-            let (edge_part, weight_part) = entry.split_once(':').ok_or_else(|| {
-                anyhow::anyhow!("Invalid potential edge '{entry}': expected u-v:w")
-            })?;
-            let (u_str, v_str) = edge_part.split_once('-').ok_or_else(|| {
-                anyhow::anyhow!("Invalid potential edge '{entry}': expected u-v:w")
-            })?;
-            let u = u_str.trim().parse::<usize>()?;
-            let v = v_str.trim().parse::<usize>()?;
-            if u == v {
-                bail!("Self-loop detected in potential edge {u}-{v}");
-            }
-            let weight = weight_part.trim().parse::<i32>()?;
-            Ok((u, v, weight))
-        })
-        .collect()
-}
-
-fn validate_potential_edges(
-    graph: &SimpleGraph,
-    potential_edges: &[(usize, usize, i32)],
-) -> Result<()> {
-    let num_vertices = graph.num_vertices();
-    let mut seen_potential_edges = BTreeSet::new();
-    for &(u, v, _) in potential_edges {
-        if u >= num_vertices || v >= num_vertices {
-            bail!(
-                "Potential edge {u}-{v} references a vertex outside the graph (num_vertices = {num_vertices})"
-            );
-        }
-        let edge = if u <= v { (u, v) } else { (v, u) };
-        if graph.has_edge(edge.0, edge.1) {
-            bail!(
-                "Potential edge {}-{} already exists in the graph",
-                edge.0,
-                edge.1
-            );
-        }
-        if !seen_potential_edges.insert(edge) {
-            bail!(
-                "Duplicate potential edge {}-{} is not allowed",
-                edge.0,
-                edge.1
-            );
-        }
-    }
-    Ok(())
-}
-
-fn parse_budget(args: &CreateArgs) -> Result<i32> {
-    let budget = args
-        .budget
-        .as_deref()
-        .ok_or_else(|| anyhow::anyhow!("BiconnectivityAugmentation requires --budget (e.g., 5)"))?;
-    budget
-        .parse::<i32>()
-        .map_err(|e| anyhow::anyhow!("Invalid budget '{budget}': {e}"))
-}
-
 /// Parse `--arcs` as directed arc pairs and build a `DirectedGraph`.
 ///
 /// Returns `(graph, num_arcs)`. Infers vertex count from arc endpoints
@@ -1709,607 +525,6 @@ fn parse_directed_graph(
     Ok((DirectedGraph::new(num_v, arcs), num_arcs))
 }
 
-fn parse_prescribed_paths(
-    args: &CreateArgs,
-    num_arcs: usize,
-    usage: &str,
-) -> Result<Vec<Vec<usize>>> {
-    let paths_str = args
-        .paths
-        .as_deref()
-        .ok_or_else(|| anyhow::anyhow!("PathConstrainedNetworkFlow requires --paths\n\n{usage}"))?;
-
-    paths_str
-        .split(';')
-        .map(|path_str| {
-            let trimmed = path_str.trim();
-            anyhow::ensure!(
-                !trimmed.is_empty(),
-                "PathConstrainedNetworkFlow paths must be non-empty\n\n{usage}"
-            );
-            let path: Vec<usize> = util::parse_comma_list(trimmed)?;
-            anyhow::ensure!(
-                !path.is_empty(),
-                "PathConstrainedNetworkFlow paths must be non-empty\n\n{usage}"
-            );
-            for &arc_idx in &path {
-                anyhow::ensure!(
-                    arc_idx < num_arcs,
-                    "Path arc index {arc_idx} out of bounds for {num_arcs} arcs\n\n{usage}"
-                );
-            }
-            Ok(path)
-        })
-        .collect()
-}
-
-fn parse_mixed_graph(args: &CreateArgs, usage: &str) -> Result<MixedGraph> {
-    let (undirected_graph, num_vertices) =
-        parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-    let arcs_str = args
-        .arcs
-        .as_deref()
-        .ok_or_else(|| anyhow::anyhow!("MixedChinesePostman requires --arcs\n\n{usage}"))?;
-    let (directed_graph, _) = parse_directed_graph(arcs_str, Some(num_vertices))
-        .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-    Ok(MixedGraph::new(
-        num_vertices,
-        directed_graph.arcs(),
-        undirected_graph.edges(),
-    ))
-}
-
-/// Parse `--weights` as arc weights (i32), defaulting to all 1s.
-fn parse_arc_weights(args: &CreateArgs, num_arcs: usize) -> Result<Vec<i32>> {
-    match &args.weights {
-        Some(w) => {
-            let weights: Vec<i32> = w
-                .split(',')
-                .map(|s| s.trim().parse::<i32>())
-                .collect::<std::result::Result<Vec<_>, _>>()?;
-            if weights.len() != num_arcs {
-                bail!(
-                    "Expected {} arc weights but got {}",
-                    num_arcs,
-                    weights.len()
-                );
-            }
-            Ok(weights)
-        }
-        None => Ok(vec![1i32; num_arcs]),
-    }
-}
-
-/// Parse `--arc-weights` / `--arc-lengths` as per-arc costs (i32), defaulting to all 1s.
-fn parse_arc_costs(args: &CreateArgs, num_arcs: usize) -> Result<Vec<i32>> {
-    match &args.arc_costs {
-        Some(costs) => {
-            let parsed: Vec<i32> = costs
-                .split(',')
-                .map(|s| s.trim().parse::<i32>())
-                .collect::<std::result::Result<Vec<_>, _>>()?;
-            if parsed.len() != num_arcs {
-                bail!("Expected {} arc costs but got {}", num_arcs, parsed.len());
-            }
-            Ok(parsed)
-        }
-        None => Ok(vec![1i32; num_arcs]),
-    }
-}
-
-/// Parse `--candidate-arcs` as `u>v:w` entries for StrongConnectivityAugmentation.
-/// Handle `pred create <PROBLEM> --random ...`
-fn create_random(
-    args: &CreateArgs,
-    canonical: &str,
-    resolved_variant: &BTreeMap<String, String>,
-    out: &OutputConfig,
-) -> Result<()> {
-    let num_vertices = args.num_vertices.ok_or_else(|| {
-        anyhow::anyhow!(
-            "--random requires --num-vertices\n\n\
-             Usage: pred create {} --random --num-vertices 10 [--edge-prob 0.3] [--seed 42]",
-            canonical
-        )
-    })?;
-
-    let graph_type = resolved_graph_type(resolved_variant);
-
-    let (data, variant) = match canonical {
-        "DecisionMinimumVertexCover" => {
-            let raw_bound = args.bound.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "DecisionMinimumVertexCover requires --bound\n\n\
-                     Usage: pred create DecisionMinimumVertexCover --random --num-vertices 5 [--edge-prob 0.5] [--seed 42] --bound 3"
-                )
-            })?;
-            anyhow::ensure!(
-                raw_bound >= 0,
-                "DecisionMinimumVertexCover: --bound must be non-negative"
-            );
-            let bound = i32::try_from(raw_bound).map_err(|_| {
-                anyhow::anyhow!(
-                    "DecisionMinimumVertexCover: --bound must fit in a 32-bit signed integer, got {raw_bound}"
-                )
-            })?;
-            let weights = vec![1i32; num_vertices];
-            match graph_type {
-                "KingsSubgraph" => {
-                    let positions = util::create_random_int_positions(num_vertices, args.seed);
-                    let graph = KingsSubgraph::new(positions);
-                    (
-                        ser_decision_minimum_vertex_cover_with(graph, weights, bound)?,
-                        resolved_variant.clone(),
-                    )
-                }
-                "TriangularSubgraph" => {
-                    let positions = util::create_random_int_positions(num_vertices, args.seed);
-                    let graph = TriangularSubgraph::new(positions);
-                    (
-                        ser_decision_minimum_vertex_cover_with(graph, weights, bound)?,
-                        resolved_variant.clone(),
-                    )
-                }
-                "UnitDiskGraph" => {
-                    let positions = util::create_random_float_positions(num_vertices, args.seed);
-                    let radius = args.radius.unwrap_or(1.5);
-                    let graph = UnitDiskGraph::new(positions, radius);
-                    (
-                        ser_decision_minimum_vertex_cover_with(graph, weights, bound)?,
-                        resolved_variant.clone(),
-                    )
-                }
-                _ => {
-                    let edge_prob = args.edge_prob.unwrap_or(0.5);
-                    if !(0.0..=1.0).contains(&edge_prob) {
-                        bail!("--edge-prob must be between 0.0 and 1.0");
-                    }
-                    let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-                    (
-                        ser_decision_minimum_vertex_cover_with(graph, weights, bound)?,
-                        resolved_variant.clone(),
-                    )
-                }
-            }
-        }
-
-        // Graph problems with vertex weights
-        "MaximumIndependentSet"
-        | "MinimumVertexCover"
-        | "MaximumClique"
-        | "MinimumDominatingSet"
-        | "MaximalIS" => {
-            let weights = vec![1i32; num_vertices];
-            match graph_type {
-                "KingsSubgraph" => {
-                    let positions = util::create_random_int_positions(num_vertices, args.seed);
-                    let graph = KingsSubgraph::new(positions);
-                    (
-                        ser_vertex_weight_problem_with(canonical, graph, weights)?,
-                        resolved_variant.clone(),
-                    )
-                }
-                "TriangularSubgraph" => {
-                    let positions = util::create_random_int_positions(num_vertices, args.seed);
-                    let graph = TriangularSubgraph::new(positions);
-                    (
-                        ser_vertex_weight_problem_with(canonical, graph, weights)?,
-                        resolved_variant.clone(),
-                    )
-                }
-                "UnitDiskGraph" => {
-                    let radius = args.radius.unwrap_or(1.0);
-                    let positions = util::create_random_float_positions(num_vertices, args.seed);
-                    let graph = UnitDiskGraph::new(positions, radius);
-                    (
-                        ser_vertex_weight_problem_with(canonical, graph, weights)?,
-                        resolved_variant.clone(),
-                    )
-                }
-                _ => {
-                    let edge_prob = args.edge_prob.unwrap_or(0.5);
-                    if !(0.0..=1.0).contains(&edge_prob) {
-                        bail!("--edge-prob must be between 0.0 and 1.0");
-                    }
-                    let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-                    let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-                    let data = ser_vertex_weight_problem_with(canonical, graph, weights)?;
-                    (data, variant)
-                }
-            }
-        }
-
-        "KClique" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let usage =
-                "Usage: pred create KClique --random --num-vertices 5 [--edge-prob 0.5] [--seed 42] --k 3";
-            let k = parse_kclique_threshold(args.k, graph.num_vertices(), usage)?;
-            (
-                ser(KClique::new(graph, k))?,
-                variant_map(&[("graph", "SimpleGraph")]),
-            )
-        }
-
-        // MinimumCutIntoBoundedSets (graph + edge weights + s/t/B/K)
-        "MinimumCutIntoBoundedSets" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let num_edges = graph.num_edges();
-            let edge_weights = vec![1i32; num_edges];
-            let source = 0;
-            let sink = num_vertices.saturating_sub(1);
-            let size_bound = num_vertices; // no effective size constraint
-            let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-            (
-                ser(MinimumCutIntoBoundedSets::new(
-                    graph,
-                    edge_weights,
-                    source,
-                    sink,
-                    size_bound,
-                ))?,
-                variant,
-            )
-        }
-
-        // MaximumAchromaticNumber (graph only, no weights)
-        "MaximumAchromaticNumber" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (
-                ser(problemreductions::models::graph::MaximumAchromaticNumber::new(graph))?,
-                variant,
-            )
-        }
-
-        // MaximumDomaticNumber (graph only, no weights)
-        "MaximumDomaticNumber" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (
-                ser(problemreductions::models::graph::MaximumDomaticNumber::new(graph))?,
-                variant,
-            )
-        }
-
-        // MinimumCoveringByCliques (graph only, no weights)
-        "MinimumCoveringByCliques" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (
-                ser(problemreductions::models::graph::MinimumCoveringByCliques::new(graph))?,
-                variant,
-            )
-        }
-
-        // MinimumIntersectionGraphBasis (graph only, no weights)
-        "MinimumIntersectionGraphBasis" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (
-                ser(problemreductions::models::graph::MinimumIntersectionGraphBasis::new(graph))?,
-                variant,
-            )
-        }
-
-        // MinimumMaximalMatching (graph only, no weights)
-        "MinimumMaximalMatching" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (ser(MinimumMaximalMatching::new(graph))?, variant)
-        }
-
-        // Hamiltonian Circuit (graph only, no weights)
-        "HamiltonianCircuit" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (ser(HamiltonianCircuit::new(graph))?, variant)
-        }
-
-        // Maximum Leaf Spanning Tree (graph only, no weights)
-        "MaximumLeafSpanningTree" => {
-            let num_vertices = num_vertices.max(2);
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (
-                ser(problemreductions::models::graph::MaximumLeafSpanningTree::new(graph))?,
-                variant,
-            )
-        }
-
-        // HamiltonianPath (graph only, no weights)
-        "HamiltonianPath" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (ser(HamiltonianPath::new(graph))?, variant)
-        }
-
-        // HamiltonianPathBetweenTwoVertices (graph + source/target)
-        "HamiltonianPathBetweenTwoVertices" => {
-            let num_vertices = num_vertices.max(2);
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let source_vertex = args.source_vertex.unwrap_or(0);
-            let target_vertex = args
-                .target_vertex
-                .unwrap_or_else(|| num_vertices.saturating_sub(1));
-            ensure_vertex_in_bounds(source_vertex, graph.num_vertices(), "source_vertex")?;
-            ensure_vertex_in_bounds(target_vertex, graph.num_vertices(), "target_vertex")?;
-            anyhow::ensure!(
-                source_vertex != target_vertex,
-                "source_vertex and target_vertex must be distinct"
-            );
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (
-                ser(HamiltonianPathBetweenTwoVertices::new(
-                    graph,
-                    source_vertex,
-                    target_vertex,
-                ))?,
-                variant,
-            )
-        }
-
-        // LongestCircuit (graph + unit edge lengths)
-        "LongestCircuit" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let edge_lengths = vec![1i32; graph.num_edges()];
-            let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-            (ser(LongestCircuit::new(graph, edge_lengths))?, variant)
-        }
-
-        // GeneralizedHex (graph only, with source/sink defaults)
-        "GeneralizedHex" => {
-            let num_vertices = num_vertices.max(2);
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let source = args.source.unwrap_or(0);
-            let sink = args.sink.unwrap_or(num_vertices - 1);
-            let usage = "Usage: pred create GeneralizedHex --random --num-vertices 6 [--edge-prob 0.5] [--seed 42] [--source 0] [--sink 5]";
-            validate_vertex_index("source", source, num_vertices, usage)?;
-            validate_vertex_index("sink", sink, num_vertices, usage)?;
-            if source == sink {
-                bail!("GeneralizedHex requires distinct --source and --sink\n\n{usage}");
-            }
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (ser(GeneralizedHex::new(graph, source, sink))?, variant)
-        }
-
-        // LengthBoundedDisjointPaths (graph only, with path defaults)
-        "LengthBoundedDisjointPaths" => {
-            let num_vertices = if num_vertices < 2 {
-                eprintln!(
-                    "Warning: LengthBoundedDisjointPaths requires at least 2 vertices; rounding {} up to 2",
-                    num_vertices
-                );
-                2
-            } else {
-                num_vertices
-            };
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let source = args.source.unwrap_or(0);
-            let sink = args.sink.unwrap_or(num_vertices - 1);
-            let bound = args.bound.unwrap_or((num_vertices - 1) as i64);
-            let max_length = validate_length_bounded_disjoint_paths_args(
-                num_vertices,
-                source,
-                sink,
-                bound,
-                None,
-            )?;
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (
-                ser(LengthBoundedDisjointPaths::new(
-                    graph,
-                    source,
-                    sink,
-                    max_length,
-                ))?,
-                variant,
-            )
-        }
-
-        // Graph problems with edge weights
-        "BottleneckTravelingSalesman" | "MaxCut" | "MaximumMatching" | "TravelingSalesman" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let num_edges = graph.num_edges();
-            let edge_weights = vec![1i32; num_edges];
-            let variant = match canonical {
-                "BottleneckTravelingSalesman" => variant_map(&[]),
-                _ => variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]),
-            };
-            let data = match canonical {
-                "BottleneckTravelingSalesman" => {
-                    ser(BottleneckTravelingSalesman::new(graph, edge_weights))?
-                }
-                "MaxCut" => ser(MaxCut::new(graph, edge_weights))?,
-                "MaximumMatching" => ser(MaximumMatching::new(graph, edge_weights))?,
-                "TravelingSalesman" => ser(TravelingSalesman::new(graph, edge_weights))?,
-                _ => unreachable!(),
-            };
-            (data, variant)
-        }
-
-        // SteinerTreeInGraphs
-        "SteinerTreeInGraphs" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let num_edges = graph.num_edges();
-            let edge_weights = vec![1i32; num_edges];
-            // Use first half of vertices as terminals (at least 2)
-            let num_terminals = std::cmp::max(2, num_vertices / 2);
-            let terminals: Vec<usize> = (0..num_terminals).collect();
-            let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-            (
-                ser(SteinerTreeInGraphs::new(graph, terminals, edge_weights))?,
-                variant,
-            )
-        }
-
-        // SteinerTree
-        "SteinerTree" => {
-            anyhow::ensure!(
-                num_vertices >= 2,
-                "SteinerTree random generation requires --num-vertices >= 2"
-            );
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let mut state = util::lcg_init(args.seed);
-            let graph = util::create_random_graph(num_vertices, edge_prob, Some(state));
-            // Advance state past the graph generation
-            for _ in 0..num_vertices * num_vertices {
-                util::lcg_step(&mut state);
-            }
-            let edge_weights: Vec<i32> = (0..graph.num_edges())
-                .map(|_| (util::lcg_step(&mut state) * 9.0) as i32 + 1)
-                .collect();
-            let num_terminals = std::cmp::max(2, num_vertices * 2 / 5);
-            let terminals = util::lcg_choose(&mut state, num_vertices, num_terminals);
-            let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-            (
-                ser(SteinerTree::new(graph, edge_weights, terminals))?,
-                variant,
-            )
-        }
-
-        // SpinGlass
-        "SpinGlass" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let num_edges = graph.num_edges();
-            let couplings = vec![1i32; num_edges];
-            let fields = vec![0i32; num_vertices];
-            let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-            (
-                ser(SpinGlass::from_graph(graph, couplings, fields))?,
-                variant,
-            )
-        }
-
-        // KColoring
-        "KColoring" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let (k, _variant) =
-                util::validate_k_param(resolved_variant, args.k, Some(3), "KColoring")?;
-            util::ser_kcoloring(graph, k)?
-        }
-
-        // OptimalLinearArrangement — graph only (optimization)
-        "OptimalLinearArrangement" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (ser(OptimalLinearArrangement::new(graph))?, variant)
-        }
-
-        // RootedTreeArrangement — graph + bound
-        "RootedTreeArrangement" => {
-            let edge_prob = args.edge_prob.unwrap_or(0.5);
-            if !(0.0..=1.0).contains(&edge_prob) {
-                bail!("--edge-prob must be between 0.0 and 1.0");
-            }
-            let graph = util::create_random_graph(num_vertices, edge_prob, args.seed);
-            let n = graph.num_vertices();
-            let usage = "Usage: pred create RootedTreeArrangement --random --num-vertices 5 [--edge-prob 0.5] [--seed 42] [--bound 10]";
-            let bound = args
-                .bound
-                .map(|b| parse_nonnegative_usize_bound(b, "RootedTreeArrangement", usage))
-                .transpose()?
-                .unwrap_or((n.saturating_sub(1)) * graph.num_edges());
-            let variant = variant_map(&[("graph", "SimpleGraph")]);
-            (ser(RootedTreeArrangement::new(graph, bound))?, variant)
-        }
-
-        _ => bail!(
-            "Random generation is not supported for {canonical}. \
-             Supported: graph-based problems (MIS, MVC, MaxCut, MaxClique, \
-             MaximumMatching, MinimumDominatingSet, SpinGlass, KColoring, KClique, DecisionMinimumVertexCover, TravelingSalesman, \
-             BottleneckTravelingSalesman, SteinerTreeInGraphs, HamiltonianCircuit, MaximumLeafSpanningTree, SteinerTree, \
-             OptimalLinearArrangement, RootedTreeArrangement, HamiltonianPath, LongestCircuit, GeneralizedHex)"
-        ),
-    };
-
-    let output = ProblemJsonOutput {
-        problem_type: canonical.to_string(),
-        variant,
-        data,
-    };
-
-    emit_problem_output(&output, out)
-}
-
 /// Parse implication rules from semicolon-separated "antecedents>consequent" strings.
 ///
 /// Format: "0,1>2;3>4;5,6,7>0" where antecedents are comma-separated indices
diff --git a/problemreductions-cli/src/commands/create/schema_semantics.rs b/problemreductions-cli/src/commands/create/schema_semantics.rs
deleted file mode 100644
index c07ee4d35..000000000
--- a/problemreductions-cli/src/commands/create/schema_semantics.rs
+++ /dev/null
@@ -1,1327 +0,0 @@
-use super::schema_support::*;
-use super::*;
-
-pub(super) fn validate_schema_driven_semantics(
-    args: &CreateArgs,
-    canonical: &str,
-    resolved_variant: &BTreeMap<String, String>,
-    _data: &serde_json::Value,
-) -> Result<()> {
-    match canonical {
-        "BalancedCompleteBipartiteSubgraph" => {
-            let usage = "pred create BalancedCompleteBipartiteSubgraph --left 4 --right 4 --biedges 0-0,0-1,0-2,1-0,1-1,1-2,2-0,2-1,2-2,3-0,3-1,3-3 --k 3";
-            let _ = parse_bipartite_problem_input(
-                args,
-                "BalancedCompleteBipartiteSubgraph",
-                "balanced biclique size",
-                usage,
-            )?;
-        }
-        "BiconnectivityAugmentation" => {
-            let usage = "Usage: pred create BiconnectivityAugmentation --graph 0-1,1-2,2-3 --potential-weights 0-2:3,0-3:4,1-3:2 --budget 5";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let potential_edges = parse_potential_edges(args)?;
-            validate_potential_edges(&graph, &potential_edges)?;
-            let _ = parse_budget(args)?;
-        }
-        "BoundedComponentSpanningForest" => {
-            let usage = "Usage: pred create BoundedComponentSpanningForest --graph 0-1,1-2,2-3,3-4,4-5,5-6,6-7,0-7,1-5,2-6 --weights 2,3,1,2,3,1,2,1 --k 3 --max-weight 6";
-            let (_, n) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            args.weights.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("BoundedComponentSpanningForest requires --weights\n\n{usage}")
-            })?;
-            let weights = parse_vertex_weights(args, n)?;
-            if weights.iter().any(|&weight| weight < 0) {
-                bail!("BoundedComponentSpanningForest requires nonnegative --weights\n\n{usage}");
-            }
-            let max_components = args.k.ok_or_else(|| {
-                anyhow::anyhow!("BoundedComponentSpanningForest requires --k\n\n{usage}")
-            })?;
-            if max_components == 0 {
-                bail!("BoundedComponentSpanningForest requires --k >= 1\n\n{usage}");
-            }
-            let bound_raw = args.bound.ok_or_else(|| {
-                anyhow::anyhow!("BoundedComponentSpanningForest requires --max-weight\n\n{usage}")
-            })?;
-            if bound_raw <= 0 {
-                bail!("BoundedComponentSpanningForest requires positive --max-weight\n\n{usage}");
-            }
-            let _ = i32::try_from(bound_raw).map_err(|_| {
-                anyhow::anyhow!(
-                    "BoundedComponentSpanningForest requires --max-weight within i32 range\n\n{usage}"
-                )
-            })?;
-        }
-        "CapacityAssignment" => {
-            let usage = "Usage: pred create CapacityAssignment --capacities 1,2,3 --cost-matrix \"1,3,6;2,4,7;1,2,5\" --delay-matrix \"8,4,1;7,3,1;6,3,1\" --delay-budget 12";
-            let capacities_str = args.capacities.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "CapacityAssignment requires --capacities, --cost-matrix, --delay-matrix, and --delay-budget\n\n{usage}"
-                )
-            })?;
-            let cost_matrix_str = args.cost_matrix.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("CapacityAssignment requires --cost-matrix\n\n{usage}")
-            })?;
-            let delay_matrix_str = args.delay_matrix.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("CapacityAssignment requires --delay-matrix\n\n{usage}")
-            })?;
-            let _ = args.delay_budget.ok_or_else(|| {
-                anyhow::anyhow!("CapacityAssignment requires --delay-budget\n\n{usage}")
-            })?;
-
-            let capacities: Vec<u64> = util::parse_comma_list(capacities_str)?;
-            anyhow::ensure!(
-                !capacities.is_empty(),
-                "CapacityAssignment requires at least one capacity value\n\n{usage}"
-            );
-            anyhow::ensure!(
-                capacities.iter().all(|&capacity| capacity > 0),
-                "CapacityAssignment capacities must be positive\n\n{usage}"
-            );
-            anyhow::ensure!(
-                capacities.windows(2).all(|w| w[0] < w[1]),
-                "CapacityAssignment capacities must be strictly increasing\n\n{usage}"
-            );
-
-            let cost = parse_u64_matrix_rows(cost_matrix_str, "cost")?;
-            let delay = parse_u64_matrix_rows(delay_matrix_str, "delay")?;
-            anyhow::ensure!(
-                cost.len() == delay.len(),
-                "cost matrix row count ({}) must match delay matrix row count ({})\n\n{usage}",
-                cost.len(),
-                delay.len()
-            );
-
-            for (index, row) in cost.iter().enumerate() {
-                anyhow::ensure!(
-                    row.len() == capacities.len(),
-                    "cost row {} length ({}) must match capacities length ({})\n\n{usage}",
-                    index,
-                    row.len(),
-                    capacities.len()
-                );
-                anyhow::ensure!(
-                    row.windows(2).all(|w| w[0] <= w[1]),
-                    "cost row {} must be non-decreasing\n\n{usage}",
-                    index
-                );
-            }
-            for (index, row) in delay.iter().enumerate() {
-                anyhow::ensure!(
-                    row.len() == capacities.len(),
-                    "delay row {} length ({}) must match capacities length ({})\n\n{usage}",
-                    index,
-                    row.len(),
-                    capacities.len()
-                );
-                anyhow::ensure!(
-                    row.windows(2).all(|w| w[0] >= w[1]),
-                    "delay row {} must be non-increasing\n\n{usage}",
-                    index
-                );
-            }
-        }
-        "BoyceCoddNormalFormViolation" => {
-            let n = args.n.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "BoyceCoddNormalFormViolation requires --n, --sets, and --target\n\n\
-                     Usage: pred create BoyceCoddNormalFormViolation --n 6 --sets \"0,1:2;2:3;3,4:5\" --target 0,1,2,3,4,5"
-                )
-            })?;
-            let sets_str = args.sets.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "BoyceCoddNormalFormViolation requires --sets (functional deps as lhs:rhs;...)\n\n\
-                     Usage: pred create BoyceCoddNormalFormViolation --n 6 --sets \"0,1:2;2:3;3,4:5\" --target 0,1,2,3,4,5"
-                )
-            })?;
-            let target_str = args.target.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "BoyceCoddNormalFormViolation requires --target (comma-separated attribute indices)\n\n\
-                     Usage: pred create BoyceCoddNormalFormViolation --n 6 --sets \"0,1:2;2:3;3,4:5\" --target 0,1,2,3,4,5"
-                )
-            })?;
-            let _ = parse_bcnf_functional_deps(sets_str, n)?;
-            let target: Vec<usize> = util::parse_comma_list(target_str)?;
-            ensure_attribute_indices_in_range(&target, n, "Target subset")?;
-        }
-        "ClosestVectorProblem" => {
-            let basis_str = args.basis.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "CVP requires --basis, --target-vec\n\n\
-                     Usage: pred create CVP --basis \"1,0;0,1\" --target-vec \"0.5,0.5\""
-                )
-            })?;
-            let target_str = args
-                .target_vec
-                .as_deref()
-                .ok_or_else(|| anyhow::anyhow!("CVP requires --target-vec (e.g., \"0.5,0.5\")"))?;
-            let basis: Vec<Vec<f64>> = basis_str
-                .split(';')
-                .map(|row| util::parse_comma_list(row.trim()))
-                .collect::<Result<Vec<_>>>()?;
-            let target: Vec<f64> = util::parse_comma_list(target_str)?;
-            let n = basis.len();
-            let bounds = serde_json::from_value(parse_cvp_bounds_value(
-                args.bounds.as_deref(),
-                &CreateContext::default()
-                    .with_field("basis", serde_json::json!(vec![serde_json::json!([0]); n])),
-            )?)?;
-            let _ = ClosestVectorProblem::new(basis, target, bounds);
-        }
-        "ConsecutiveOnesMatrixAugmentation" => {
-            let matrix = parse_bool_matrix(args)?;
-            let bound = args.bound.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ConsecutiveOnesMatrixAugmentation requires --matrix and --bound\n\n\
-                     Usage: pred create ConsecutiveOnesMatrixAugmentation --matrix \"1,0,0,1,1;1,1,0,0,0;0,1,1,0,1;0,0,1,1,0\" --bound 2"
-                )
-            })?;
-            ConsecutiveOnesMatrixAugmentation::try_new(matrix, bound)
-                .map_err(anyhow::Error::msg)?;
-        }
-        "ConsecutiveBlockMinimization" => {
-            let usage = "Usage: pred create ConsecutiveBlockMinimization --matrix '[[true,false,true],[false,true,true]]' --bound-k 2";
-            let matrix_str = args.matrix.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ConsecutiveBlockMinimization requires --matrix as a JSON 2D bool array and --bound-k\n\n{usage}"
-                )
-            })?;
-            let bound = args.bound.ok_or_else(|| {
-                anyhow::anyhow!("ConsecutiveBlockMinimization requires --bound-k\n\n{usage}")
-            })?;
-            let matrix: Vec<Vec<bool>> = serde_json::from_str(matrix_str).map_err(|err| {
-                anyhow::anyhow!(
-                    "ConsecutiveBlockMinimization requires --matrix as a JSON 2D bool array (e.g., '[[true,false,true],[false,true,true]]')\n\n{usage}\n\nFailed to parse --matrix: {err}"
-                )
-            })?;
-            ConsecutiveBlockMinimization::try_new(matrix, bound)
-                .map_err(|err| anyhow::anyhow!("{err}\n\n{usage}"))?;
-        }
-        "ComparativeContainment" => {
-            let universe = args.universe.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ComparativeContainment requires --universe, --r-sets, and --s-sets\n\n\
-                     Usage: pred create ComparativeContainment --universe 4 --r-sets \"0,1,2,3;0,1\" --s-sets \"0,1,2,3;2,3\" [--r-weights 2,5] [--s-weights 3,6]"
-                )
-            })?;
-            let r_sets = parse_named_sets(args.r_sets.as_deref(), "--r-sets")?;
-            let s_sets = parse_named_sets(args.s_sets.as_deref(), "--s-sets")?;
-            validate_comparative_containment_sets("R", "--r-sets", universe, &r_sets)?;
-            validate_comparative_containment_sets("S", "--s-sets", universe, &s_sets)?;
-            match resolved_variant.get("weight").map(|value| value.as_str()) {
-                Some("One") => {
-                    let r_weights = parse_named_set_weights(
-                        args.r_weights.as_deref(),
-                        r_sets.len(),
-                        "--r-weights",
-                    )?;
-                    let s_weights = parse_named_set_weights(
-                        args.s_weights.as_deref(),
-                        s_sets.len(),
-                        "--s-weights",
-                    )?;
-                    anyhow::ensure!(
-                        r_weights.iter().all(|&w| w == 1) && s_weights.iter().all(|&w| w == 1),
-                        "Non-unit weights are not supported for ComparativeContainment/One.\n\n\
-                         Use `pred create ComparativeContainment/i32 ... --r-weights ... --s-weights ...` for weighted instances."
-                    );
-                }
-                Some("f64") => {
-                    let r_weights = parse_named_set_weights_f64(
-                        args.r_weights.as_deref(),
-                        r_sets.len(),
-                        "--r-weights",
-                    )?;
-                    validate_comparative_containment_f64_weights("R", "--r-weights", &r_weights)?;
-                    let s_weights = parse_named_set_weights_f64(
-                        args.s_weights.as_deref(),
-                        s_sets.len(),
-                        "--s-weights",
-                    )?;
-                    validate_comparative_containment_f64_weights("S", "--s-weights", &s_weights)?;
-                }
-                Some("i32") | None => {
-                    let r_weights = parse_named_set_weights(
-                        args.r_weights.as_deref(),
-                        r_sets.len(),
-                        "--r-weights",
-                    )?;
-                    validate_comparative_containment_i32_weights("R", "--r-weights", &r_weights)?;
-                    let s_weights = parse_named_set_weights(
-                        args.s_weights.as_deref(),
-                        s_sets.len(),
-                        "--s-weights",
-                    )?;
-                    validate_comparative_containment_i32_weights("S", "--s-weights", &s_weights)?;
-                }
-                Some(other) => bail!(
-                    "Unsupported ComparativeContainment weight variant: {}",
-                    other
-                ),
-            }
-        }
-        "DisjointConnectingPaths" => {
-            let usage =
-                "Usage: pred create DisjointConnectingPaths --graph 0-1,1-3,0-2,1-4,2-4,3-5,4-5 --terminal-pairs 0-3,2-5";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let _ = parse_terminal_pairs(args, graph.num_vertices())
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-        }
-        "ExactCoverBy3Sets" => {
-            let universe = args.universe.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ExactCoverBy3Sets requires --universe and --sets\n\n\
-                     Usage: pred create X3C --universe 6 --sets \"0,1,2;3,4,5\""
-                )
-            })?;
-            if universe % 3 != 0 {
-                bail!("Universe size must be divisible by 3, got {}", universe);
-            }
-            let sets = parse_sets(args)?;
-            for (i, set) in sets.iter().enumerate() {
-                if set.len() != 3 {
-                    bail!(
-                        "Subset {} has {} elements, but X3C requires exactly 3 elements per subset",
-                        i,
-                        set.len()
-                    );
-                }
-                if set[0] == set[1] || set[0] == set[2] || set[1] == set[2] {
-                    bail!("Subset {} contains duplicate elements: {:?}", i, set);
-                }
-                for &elem in set {
-                    if elem >= universe {
-                        bail!(
-                            "Subset {} contains element {} which is outside universe of size {}",
-                            i,
-                            elem,
-                            universe
-                        );
-                    }
-                }
-            }
-        }
-        "GeneralizedHex" => {
-            let usage =
-                "Usage: pred create GeneralizedHex --graph 0-1,0-2,0-3,1-4,2-4,3-4,4-5 --source 0 --sink 5";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let num_vertices = graph.num_vertices();
-            let source = args
-                .source
-                .ok_or_else(|| anyhow::anyhow!("GeneralizedHex requires --source\n\n{usage}"))?;
-            let sink = args
-                .sink
-                .ok_or_else(|| anyhow::anyhow!("GeneralizedHex requires --sink\n\n{usage}"))?;
-            validate_vertex_index("source", source, num_vertices, usage)?;
-            validate_vertex_index("sink", sink, num_vertices, usage)?;
-            anyhow::ensure!(
-                source != sink,
-                "GeneralizedHex requires distinct --source and --sink\n\n{usage}"
-            );
-        }
-        "GroupingBySwapping" => {
-            let usage =
-                "Usage: pred create GroupingBySwapping --string \"0,1,2,0,1,2\" --bound 5 [--alphabet-size 3]";
-            let string_str = args.string.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("GroupingBySwapping requires --string\n\n{usage}")
-            })?;
-            let bound = parse_nonnegative_usize_bound(
-                args.bound.ok_or_else(|| {
-                    anyhow::anyhow!("GroupingBySwapping requires --bound\n\n{usage}")
-                })?,
-                "GroupingBySwapping",
-                usage,
-            )?;
-            let string = parse_symbol_list_allow_empty(string_str)?;
-            let inferred = string.iter().copied().max().map_or(0, |value| value + 1);
-            let alphabet_size = args.alphabet_size.unwrap_or(inferred);
-            anyhow::ensure!(
-                alphabet_size >= inferred,
-                "--alphabet-size {} is smaller than max symbol + 1 ({}) in the input string",
-                alphabet_size,
-                inferred
-            );
-            anyhow::ensure!(
-                alphabet_size > 0 || string.is_empty(),
-                "GroupingBySwapping requires a positive alphabet for non-empty strings.\n\n{usage}"
-            );
-            anyhow::ensure!(
-                !string.is_empty() || bound == 0,
-                "GroupingBySwapping requires --bound 0 when --string is empty.\n\n{usage}"
-            );
-        }
-        "IntegralFlowBundles" => {
-            let usage = "Usage: pred create IntegralFlowBundles --arcs \"0>1,0>2,1>3,2>3,1>2,2>1\" --bundles \"0,1;2,5;3,4\" --bundle-capacities 1,1,1 --source 0 --sink 3 --requirement 1 --num-vertices 4";
-            let arcs_str = args
-                .arcs
-                .as_deref()
-                .ok_or_else(|| anyhow::anyhow!("IntegralFlowBundles requires --arcs\n\n{usage}"))?;
-            let (graph, num_arcs) = parse_directed_graph(arcs_str, args.num_vertices)
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let bundles = parse_bundles(args, num_arcs, usage)?;
-            let _ = parse_bundle_capacities(args, bundles.len(), usage)?;
-            let source = args.source.ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowBundles requires --source\n\n{usage}")
-            })?;
-            let sink = args
-                .sink
-                .ok_or_else(|| anyhow::anyhow!("IntegralFlowBundles requires --sink\n\n{usage}"))?;
-            let _ = args.requirement.ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowBundles requires --requirement\n\n{usage}")
-            })?;
-            validate_vertex_index("source", source, graph.num_vertices(), usage)?;
-            validate_vertex_index("sink", sink, graph.num_vertices(), usage)?;
-            anyhow::ensure!(
-                source != sink,
-                "IntegralFlowBundles requires distinct --source and --sink\n\n{usage}"
-            );
-        }
-        "IntegralFlowHomologousArcs" => {
-            let usage = "Usage: pred create IntegralFlowHomologousArcs --arcs \"0>1,0>2,1>3,2>3,1>4,2>4,3>5,4>5\" --capacities 1,1,1,1,1,1,1,1 --source 0 --sink 5 --requirement 2 --homologous-pairs \"2=5;4=3\"";
-            let arcs_str = args.arcs.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowHomologousArcs requires --arcs\n\n{usage}")
-            })?;
-            let (graph, num_arcs) = parse_directed_graph(arcs_str, args.num_vertices)
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let capacities: Vec<u64> = if let Some(ref s) = args.capacities {
-                s.split(',')
-                    .map(|token| {
-                        let trimmed = token.trim();
-                        trimmed
-                            .parse::<u64>()
-                            .with_context(|| format!("Invalid capacity `{trimmed}`\n\n{usage}"))
-                    })
-                    .collect::<Result<Vec<_>>>()?
-            } else {
-                vec![1; num_arcs]
-            };
-            anyhow::ensure!(
-                capacities.len() == num_arcs,
-                "Expected {} capacities but got {}\n\n{}",
-                num_arcs,
-                capacities.len(),
-                usage
-            );
-            for (arc_index, &capacity) in capacities.iter().enumerate() {
-                let fits = usize::try_from(capacity)
-                    .ok()
-                    .and_then(|value| value.checked_add(1))
-                    .is_some();
-                anyhow::ensure!(
-                    fits,
-                    "capacity {} at arc index {} is too large for this platform\n\n{}",
-                    capacity,
-                    arc_index,
-                    usage
-                );
-            }
-            let num_vertices = graph.num_vertices();
-            let source = args.source.ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowHomologousArcs requires --source\n\n{usage}")
-            })?;
-            let sink = args.sink.ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowHomologousArcs requires --sink\n\n{usage}")
-            })?;
-            let _ = args.requirement.ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowHomologousArcs requires --requirement\n\n{usage}")
-            })?;
-            validate_vertex_index("source", source, num_vertices, usage)?;
-            validate_vertex_index("sink", sink, num_vertices, usage)?;
-            let homologous_pairs =
-                parse_homologous_pairs(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            for &(a, b) in &homologous_pairs {
-                anyhow::ensure!(
-                    a < num_arcs && b < num_arcs,
-                    "homologous pair ({}, {}) references arc >= num_arcs ({})\n\n{}",
-                    a,
-                    b,
-                    num_arcs,
-                    usage
-                );
-            }
-        }
-        "IntegralFlowWithMultipliers" => {
-            let usage = "Usage: pred create IntegralFlowWithMultipliers --arcs \"0>1,0>2,1>3,2>3\" --capacities 1,1,2,2 --source 0 --sink 3 --multipliers 1,2,3,1 --requirement 2";
-            let arcs_str = args.arcs.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowWithMultipliers requires --arcs\n\n{usage}")
-            })?;
-            let (graph, num_arcs) = parse_directed_graph(arcs_str, args.num_vertices)
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let capacities_str = args.capacities.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowWithMultipliers requires --capacities\n\n{usage}")
-            })?;
-            let capacities: Vec<u64> = util::parse_comma_list(capacities_str)
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            if capacities.len() != num_arcs {
-                bail!(
-                    "Expected {} capacities but got {}\n\n{}",
-                    num_arcs,
-                    capacities.len(),
-                    usage
-                );
-            }
-            for (arc_index, &capacity) in capacities.iter().enumerate() {
-                let fits = usize::try_from(capacity)
-                    .ok()
-                    .and_then(|value| value.checked_add(1))
-                    .is_some();
-                if !fits {
-                    bail!(
-                        "capacity {} at arc index {} is too large for this platform\n\n{}",
-                        capacity,
-                        arc_index,
-                        usage
-                    );
-                }
-            }
-            let num_vertices = graph.num_vertices();
-            let source = args.source.ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowWithMultipliers requires --source\n\n{usage}")
-            })?;
-            let sink = args.sink.ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowWithMultipliers requires --sink\n\n{usage}")
-            })?;
-            validate_vertex_index("source", source, num_vertices, usage)?;
-            validate_vertex_index("sink", sink, num_vertices, usage)?;
-            if source == sink {
-                bail!(
-                    "IntegralFlowWithMultipliers requires distinct --source and --sink\n\n{}",
-                    usage
-                );
-            }
-            let multipliers_str = args.multipliers.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowWithMultipliers requires --multipliers\n\n{usage}")
-            })?;
-            let multipliers: Vec<u64> = util::parse_comma_list(multipliers_str)
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            if multipliers.len() != num_vertices {
-                bail!(
-                    "Expected {} multipliers but got {}\n\n{}",
-                    num_vertices,
-                    multipliers.len(),
-                    usage
-                );
-            }
-            if multipliers
-                .iter()
-                .enumerate()
-                .any(|(vertex, &multiplier)| vertex != source && vertex != sink && multiplier == 0)
-            {
-                bail!("non-terminal multipliers must be positive\n\n{usage}");
-            }
-            let _ = args.requirement.ok_or_else(|| {
-                anyhow::anyhow!("IntegralFlowWithMultipliers requires --requirement\n\n{usage}")
-            })?;
-        }
-        "JobShopScheduling" => {
-            let usage = "Usage: pred create JobShopScheduling --jobs \"0:3,1:4;1:2,0:3,1:2;0:4,1:3\" --num-processors 2";
-            let job_tasks = args
-                .job_tasks
-                .as_deref()
-                .ok_or_else(|| anyhow::anyhow!("JobShopScheduling requires --jobs\n\n{usage}"))?;
-            let jobs = parse_job_shop_jobs(job_tasks)?;
-            let inferred_processors = jobs
-                .iter()
-                .flat_map(|job| job.iter().map(|(processor, _)| *processor))
-                .max()
-                .map(|processor| processor + 1);
-            let num_processors = resolve_processor_count_flags(
-                "JobShopScheduling",
-                usage,
-                args.num_processors,
-                args.m,
-            )?
-            .or(inferred_processors)
-            .ok_or_else(|| {
-                anyhow::anyhow!(
-                    "Cannot infer num_processors from empty job list; use --num-processors"
-                )
-            })?;
-            anyhow::ensure!(
-                num_processors > 0,
-                "JobShopScheduling requires --num-processors > 0\n\n{usage}"
-            );
-            for (job_index, job) in jobs.iter().enumerate() {
-                for (task_index, &(processor, _)) in job.iter().enumerate() {
-                    anyhow::ensure!(
-                        processor < num_processors,
-                        "job {job_index} task {task_index} uses processor {processor}, but num_processors = {num_processors}"
-                    );
-                }
-                for (task_index, pair) in job.windows(2).enumerate() {
-                    anyhow::ensure!(
-                        pair[0].0 != pair[1].0,
-                        "job {job_index} tasks {task_index} and {} must use different processors\n\n{usage}",
-                        task_index + 1
-                    );
-                }
-            }
-        }
-        "KClique" => {
-            let usage = "Usage: pred create KClique --graph 0-1,0-2,1-3,2-3,2-4,3-4 --k 3";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let _ = parse_kclique_threshold(args.k, graph.num_vertices(), usage)?;
-        }
-        "KColoring" => {
-            let usage = "Usage: pred create KColoring --graph 0-1,1-2,2-0 --k 3";
-            let _ = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let _ = util::validate_k_param(resolved_variant, args.k, None, "KColoring")
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-        }
-        "KthBestSpanningTree" => {
-            reject_vertex_weights_for_edge_weight_problem(args, canonical, None)?;
-            let usage =
-                "Usage: pred create KthBestSpanningTree --graph 0-1,0-2,1-2 --edge-weights 2,3,1 --k 1 --bound 3";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let _ = parse_edge_weights(args, graph.num_edges())?;
-            let _ = util::validate_k_param(resolved_variant, args.k, None, "KthBestSpanningTree")
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let _ = args
-                .bound
-                .ok_or_else(|| anyhow::anyhow!("KthBestSpanningTree requires --bound\n\n{usage}"))?
-                as i32;
-        }
-        "LengthBoundedDisjointPaths" => {
-            let usage = "Usage: pred create LengthBoundedDisjointPaths --graph 0-1,1-6,0-2,2-3,3-6,0-4,4-5,5-6 --source 0 --sink 6 --max-length 3";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let source = args.source.ok_or_else(|| {
-                anyhow::anyhow!("LengthBoundedDisjointPaths requires --source\n\n{usage}")
-            })?;
-            let sink = args.sink.ok_or_else(|| {
-                anyhow::anyhow!("LengthBoundedDisjointPaths requires --sink\n\n{usage}")
-            })?;
-            let bound = args.bound.ok_or_else(|| {
-                anyhow::anyhow!("LengthBoundedDisjointPaths requires --max-length\n\n{usage}")
-            })?;
-            let _ = validate_length_bounded_disjoint_paths_args(
-                graph.num_vertices(),
-                source,
-                sink,
-                bound,
-                Some(usage),
-            )?;
-        }
-        "LongestCommonSubsequence" => {
-            let usage =
-                "Usage: pred create LCS --strings \"010110;100101;001011\" [--alphabet-size 2]";
-            let strings_str = args.strings.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("LongestCommonSubsequence requires --strings\n\n{usage}")
-            })?;
-            let (strings, inferred_alphabet_size) = parse_lcs_strings(strings_str)?;
-            let alphabet_size = args.alphabet_size.unwrap_or(inferred_alphabet_size);
-            anyhow::ensure!(
-                alphabet_size >= inferred_alphabet_size,
-                "--alphabet-size {} is smaller than the inferred alphabet size ({})",
-                alphabet_size,
-                inferred_alphabet_size
-            );
-            anyhow::ensure!(
-                strings.iter().any(|string| !string.is_empty()),
-                "LongestCommonSubsequence requires at least one non-empty string.\n\n{usage}"
-            );
-            anyhow::ensure!(
-                alphabet_size > 0,
-                "LongestCommonSubsequence requires a positive alphabet. Provide --alphabet-size when all strings are empty.\n\n{usage}"
-            );
-        }
-        "LongestPath" => {
-            let usage = "pred create LongestPath --graph 0-1,0-2,1-3,2-3,2-4,3-5,4-5,4-6,5-6,1-6 --edge-lengths 3,2,4,1,5,2,3,2,4,1 --source-vertex 0 --target-vertex 6";
-            let (graph, _) =
-                parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\nUsage: {usage}"))?;
-            if args.weights.is_some() {
-                bail!("LongestPath uses --edge-lengths, not --weights\n\nUsage: {usage}");
-            }
-            let edge_lengths_raw = args.edge_lengths.as_ref().ok_or_else(|| {
-                anyhow::anyhow!("LongestPath requires --edge-lengths\n\nUsage: {usage}")
-            })?;
-            let edge_lengths =
-                parse_i32_edge_values(Some(edge_lengths_raw), graph.num_edges(), "edge length")?;
-            ensure_positive_i32_values(&edge_lengths, "edge lengths")?;
-            let source_vertex = args.source_vertex.ok_or_else(|| {
-                anyhow::anyhow!("LongestPath requires --source-vertex\n\nUsage: {usage}")
-            })?;
-            let target_vertex = args.target_vertex.ok_or_else(|| {
-                anyhow::anyhow!("LongestPath requires --target-vertex\n\nUsage: {usage}")
-            })?;
-            ensure_vertex_in_bounds(source_vertex, graph.num_vertices(), "source_vertex")?;
-            ensure_vertex_in_bounds(target_vertex, graph.num_vertices(), "target_vertex")?;
-        }
-        "MixedChinesePostman" => {
-            let usage = "Usage: pred create MixedChinesePostman --graph 0-2,1-3,0-4,4-2 --arcs \"0>1,1>2,2>3,3>0\" --edge-weights 2,3,1,2 --arc-weights 2,3,1,4 [--num-vertices N]";
-            let graph = parse_mixed_graph(args, usage)?;
-            let arc_costs = parse_arc_costs(args, graph.num_arcs())?;
-            let edge_weights = parse_edge_weights(args, graph.num_edges())?;
-            if arc_costs.iter().any(|&cost| cost < 0) {
-                bail!("MixedChinesePostman --arc-weights must be non-negative\n\n{usage}");
-            }
-            if edge_weights.iter().any(|&weight| weight < 0) {
-                bail!("MixedChinesePostman --edge-weights must be non-negative\n\n{usage}");
-            }
-            if resolved_variant.get("weight").map(String::as_str) == Some("One")
-                && (arc_costs.iter().any(|&cost| cost != 1)
-                    || edge_weights.iter().any(|&weight| weight != 1))
-            {
-                bail!(
-                    "Non-unit lengths are not supported for MixedChinesePostman/One.\n\n\
-                     Use the weighted variant instead:\n  pred create MixedChinesePostman/i32 --graph ... --arcs ... --edge-weights ... --arc-weights ..."
-                );
-            }
-        }
-        "MinMaxMulticenter" => {
-            let usage = "Usage: pred create MinMaxMulticenter --graph 0-1,1-2,2-3 [--weights 1,1,1,1] [--edge-weights 1,1,1] --k 2";
-            let (graph, n) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let vertex_weights = parse_vertex_weights(args, n)?;
-            let edge_lengths = parse_edge_weights(args, graph.num_edges())?;
-            let _ = args.k.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "MinMaxMulticenter requires --k (number of centers)\n\n\
-                     Usage: pred create MinMaxMulticenter --graph 0-1,1-2,2-3 --k 2"
-                )
-            })?;
-            if vertex_weights.iter().any(|&weight| weight < 0) {
-                bail!("MinMaxMulticenter --weights must be non-negative");
-            }
-            if edge_lengths.iter().any(|&length| length < 0) {
-                bail!("MinMaxMulticenter --edge-weights must be non-negative");
-            }
-        }
-        "MaximumIndependentSet"
-        | "MinimumVertexCover"
-        | "MaximumClique"
-        | "MinimumDominatingSet"
-        | "MaximalIS" => {
-            let graph_type = resolved_graph_type(resolved_variant);
-            let num_vertices = match graph_type {
-                "KingsSubgraph" | "TriangularSubgraph" => parse_int_positions(args)?.len(),
-                "UnitDiskGraph" => parse_float_positions(args)?.len(),
-                _ => {
-                    parse_graph(args)
-                        .map_err(|e| {
-                            anyhow::anyhow!(
-                            "{e}\n\nUsage: pred create {} --graph 0-1,1-2,2-3 [--weights 1,1,1,1]",
-                            canonical
-                        )
-                        })?
-                        .1
-                }
-            };
-            let weights = parse_vertex_weights(args, num_vertices)?;
-            reject_nonunit_weights_for_one_variant(
-                canonical,
-                graph_type,
-                resolved_variant,
-                &weights,
-            )?;
-        }
-        "MaximumCoKPlex" => {
-            let usage = "Usage: pred create MaximumCoKPlex/i32 --graph 0-1,1-2,2-3,3-4,4-0 --weights 5,1,4,1,3 --k 2";
-            let (_, num_vertices) =
-                parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let weights = parse_vertex_weights(args, num_vertices)?;
-            let graph_type = resolved_graph_type(resolved_variant);
-            reject_nonunit_weights_for_one_variant(
-                canonical,
-                graph_type,
-                resolved_variant,
-                &weights,
-            )?;
-            let k = args
-                .k
-                .ok_or_else(|| anyhow::anyhow!("MaximumCoKPlex requires --k\n\n{usage}"))?;
-            if k == 0 {
-                bail!("MaximumCoKPlex: --k must be at least 1\n\n{usage}");
-            }
-        }
-        "MinimumHittingSet" => {
-            let universe = args.universe.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "MinimumHittingSet requires --universe and --sets\n\n\
-                     Usage: pred create MinimumHittingSet --universe 6 --sets \"0,1,2;0,3,4;1,3,5;2,4,5;0,1,5;2,3;1,4\""
-                )
-            })?;
-            let sets = parse_sets(args)?;
-            for (i, set) in sets.iter().enumerate() {
-                for &element in set {
-                    if element >= universe {
-                        bail!(
-                            "Set {} contains element {} which is outside universe of size {}",
-                            i,
-                            element,
-                            universe
-                        );
-                    }
-                }
-            }
-        }
-        "MinimumDummyActivitiesPert" => {
-            let usage = "Usage: pred create MinimumDummyActivitiesPert --arcs \"0>2,0>3,1>3,1>4,2>5\" [--num-vertices N]";
-            let arcs_str = args.arcs.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("MinimumDummyActivitiesPert requires --arcs\n\n{usage}")
-            })?;
-            let (graph, _) = parse_directed_graph(arcs_str, args.num_vertices)?;
-            let _ = MinimumDummyActivitiesPert::try_new(graph).map_err(anyhow::Error::msg)?;
-        }
-        "MinimumMultiwayCut" => {
-            let usage =
-                "Usage: pred create MinimumMultiwayCut --graph 0-1,1-2,2-3 --terminals 0,2 [--edge-weights 1,1,1]";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let _ = parse_terminals(args, graph.num_vertices())?;
-            let _ = parse_edge_weights(args, graph.num_edges())?;
-        }
-        "MultipleChoiceBranching" => {
-            let usage = "Usage: pred create MultipleChoiceBranching/i32 --arcs \"0>1,0>2,1>3,2>3,1>4,3>5,4>5,2>4\" --weights 3,2,4,1,2,3,1,3 --partition \"0,1;2,3;4,7;5,6\" --threshold 10";
-            let arcs_str = args.arcs.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("MultipleChoiceBranching requires --arcs\n\n{usage}")
-            })?;
-            let (_, num_arcs) = parse_directed_graph(arcs_str, args.num_vertices)?;
-            let _ = parse_arc_weights(args, num_arcs)?;
-            let _ = parse_partition_groups(args, num_arcs)?;
-            let _ = parse_multiple_choice_branching_threshold(args, usage)?;
-        }
-        "MultipleCopyFileAllocation" => {
-            let (_, num_vertices) = parse_graph(args)
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{MULTIPLE_COPY_FILE_ALLOCATION_USAGE}"))?;
-            let _ = parse_vertex_i64_values(
-                args.usage.as_deref(),
-                "usage",
-                num_vertices,
-                "MultipleCopyFileAllocation",
-                MULTIPLE_COPY_FILE_ALLOCATION_USAGE,
-            )?;
-            let _ = parse_vertex_i64_values(
-                args.storage.as_deref(),
-                "storage",
-                num_vertices,
-                "MultipleCopyFileAllocation",
-                MULTIPLE_COPY_FILE_ALLOCATION_USAGE,
-            )?;
-        }
-        "MultiprocessorScheduling" => {
-            let usage = "Usage: pred create MultiprocessorScheduling --lengths 4,5,3,2,6 --num-processors 2 --deadline 10";
-            let lengths_str = args.lengths.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "MultiprocessorScheduling requires --lengths, --num-processors, and --deadline\n\n{usage}"
-                )
-            })?;
-            let num_processors = args.num_processors.ok_or_else(|| {
-                anyhow::anyhow!("MultiprocessorScheduling requires --num-processors\n\n{usage}")
-            })?;
-            anyhow::ensure!(
-                num_processors > 0,
-                "MultiprocessorScheduling requires --num-processors > 0\n\n{usage}"
-            );
-            let _ = args.deadline.ok_or_else(|| {
-                anyhow::anyhow!("MultiprocessorScheduling requires --deadline\n\n{usage}")
-            })?;
-            let _: Vec<u64> = util::parse_comma_list(lengths_str)?;
-        }
-        "PartialFeedbackEdgeSet" => {
-            let usage = "Usage: pred create PartialFeedbackEdgeSet --graph 0-1,1-2,2-0,2-3,3-4,4-2,3-5,5-4,0-3 --budget 3 --max-cycle-length 4";
-            let _ = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let _ = args
-                .budget
-                .as_deref()
-                .ok_or_else(|| {
-                    anyhow::anyhow!("PartialFeedbackEdgeSet requires --budget\n\n{usage}")
-                })?
-                .parse::<usize>()
-                .map_err(|e| {
-                    anyhow::anyhow!(
-                        "Invalid --budget value for PartialFeedbackEdgeSet: {e}\n\n{usage}"
-                    )
-                })?;
-            let _ = args.max_cycle_length.ok_or_else(|| {
-                anyhow::anyhow!("PartialFeedbackEdgeSet requires --max-cycle-length\n\n{usage}")
-            })?;
-        }
-        "PathConstrainedNetworkFlow" => {
-            let usage = "Usage: pred create PathConstrainedNetworkFlow --arcs \"0>1,0>2,1>3,1>4,2>4,3>5,4>5,4>6,5>7,6>7\" --capacities 2,1,1,1,1,1,1,1,2,1 --source 0 --sink 7 --paths \"0,2,5,8;0,3,6,8;0,3,7,9;1,4,6,8;1,4,7,9\" --requirement 3";
-            let arcs_str = args.arcs.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("PathConstrainedNetworkFlow requires --arcs\n\n{usage}")
-            })?;
-            let (graph, num_arcs) = parse_directed_graph(arcs_str, args.num_vertices)
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let capacities: Vec<u64> = if let Some(ref s) = args.capacities {
-                util::parse_comma_list(s)?
-            } else {
-                vec![1; num_arcs]
-            };
-            anyhow::ensure!(
-                capacities.len() == num_arcs,
-                "capacities length ({}) must match number of arcs ({num_arcs})",
-                capacities.len()
-            );
-            let source = args.source.ok_or_else(|| {
-                anyhow::anyhow!("PathConstrainedNetworkFlow requires --source\n\n{usage}")
-            })?;
-            let sink = args.sink.ok_or_else(|| {
-                anyhow::anyhow!("PathConstrainedNetworkFlow requires --sink\n\n{usage}")
-            })?;
-            let _ = args.requirement.ok_or_else(|| {
-                anyhow::anyhow!("PathConstrainedNetworkFlow requires --requirement\n\n{usage}")
-            })?;
-            let paths = parse_prescribed_paths(args, num_arcs, usage)?;
-            validate_prescribed_paths_against_graph(&graph, &paths, source, sink, usage)?;
-        }
-        "ProductionPlanning" => {
-            let usage = "Usage: pred create ProductionPlanning --num-periods 6 --demands 5,3,7,2,8,5 --capacities 12,12,12,12,12,12 --setup-costs 10,10,10,10,10,10 --production-costs 1,1,1,1,1,1 --inventory-costs 1,1,1,1,1,1 --cost-bound 80";
-            let num_periods = args.num_periods.ok_or_else(|| {
-                anyhow::anyhow!("ProductionPlanning requires --num-periods\n\n{usage}")
-            })?;
-            let demands = parse_named_u64_list(
-                args.demands.as_deref(),
-                "ProductionPlanning",
-                "--demands",
-                usage,
-            )?;
-            let capacities = parse_named_u64_list(
-                args.capacities.as_deref(),
-                "ProductionPlanning",
-                "--capacities",
-                usage,
-            )?;
-            let setup_costs = parse_named_u64_list(
-                args.setup_costs.as_deref(),
-                "ProductionPlanning",
-                "--setup-costs",
-                usage,
-            )?;
-            let production_costs = parse_named_u64_list(
-                args.production_costs.as_deref(),
-                "ProductionPlanning",
-                "--production-costs",
-                usage,
-            )?;
-            let inventory_costs = parse_named_u64_list(
-                args.inventory_costs.as_deref(),
-                "ProductionPlanning",
-                "--inventory-costs",
-                usage,
-            )?;
-            let _ = args.cost_bound.ok_or_else(|| {
-                anyhow::anyhow!("ProductionPlanning requires --cost-bound\n\n{usage}")
-            })?;
-
-            for (flag, len) in [
-                ("--demands", demands.len()),
-                ("--capacities", capacities.len()),
-                ("--setup-costs", setup_costs.len()),
-                ("--production-costs", production_costs.len()),
-                ("--inventory-costs", inventory_costs.len()),
-            ] {
-                ensure_named_len(len, num_periods, flag, usage)?;
-            }
-        }
-        "SchedulingWithIndividualDeadlines" => {
-            let usage = "Usage: pred create SchedulingWithIndividualDeadlines --num-tasks 7 --deadlines 2,1,2,2,3,3,2 [--num-processors 3 | --m 3] [--precedences \"0>3,1>3,1>4,2>4,2>5\"]";
-            let deadlines_str = args.deadlines.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SchedulingWithIndividualDeadlines requires --deadlines, --num-tasks, and a processor count (--num-processors or --m)\n\n{usage}"
-                )
-            })?;
-            let num_tasks = args.num_tasks.or(args.n).ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SchedulingWithIndividualDeadlines requires --num-tasks (number of tasks)\n\n{usage}"
-                )
-            })?;
-            let num_processors = resolve_processor_count_flags(
-                "SchedulingWithIndividualDeadlines",
-                usage,
-                args.num_processors,
-                args.m,
-            )?
-            .ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SchedulingWithIndividualDeadlines requires --num-processors or --m\n\n{usage}"
-                )
-            })?;
-            let deadlines: Vec<usize> = util::parse_comma_list(deadlines_str)?;
-            let precedences = parse_precedence_pairs(
-                args.precedences
-                    .as_deref()
-                    .or(args.precedence_pairs.as_deref()),
-            )?;
-            anyhow::ensure!(
-                deadlines.len() == num_tasks,
-                "deadlines length ({}) must equal num_tasks ({})",
-                deadlines.len(),
-                num_tasks
-            );
-            for &(pred, succ) in &precedences {
-                anyhow::ensure!(
-                    pred < num_tasks && succ < num_tasks,
-                    "precedence index out of range: ({}, {}) but num_tasks = {}",
-                    pred,
-                    succ,
-                    num_tasks
-                );
-            }
-            let _ = SchedulingWithIndividualDeadlines::new(
-                num_tasks,
-                num_processors,
-                deadlines,
-                precedences,
-            );
-        }
-        "StringToStringCorrection" => {
-            let usage = "Usage: pred create StringToStringCorrection --source-string \"0,1,2,3,1,0\" --target-string \"0,1,3,2,1\" --bound 2";
-            let source_str = args.source_string.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("StringToStringCorrection requires --source-string\n\n{usage}")
-            })?;
-            let target_str = args.target_string.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("StringToStringCorrection requires --target-string\n\n{usage}")
-            })?;
-            let _ = parse_nonnegative_usize_bound(
-                args.bound.ok_or_else(|| {
-                    anyhow::anyhow!("StringToStringCorrection requires --bound\n\n{usage}")
-                })?,
-                "StringToStringCorrection",
-                usage,
-            )?;
-            let source = parse_symbol_list_allow_empty(source_str)?;
-            let target = parse_symbol_list_allow_empty(target_str)?;
-            let inferred = source
-                .iter()
-                .chain(target.iter())
-                .copied()
-                .max()
-                .map_or(0, |m| m + 1);
-            let alphabet_size = args.alphabet_size.unwrap_or(inferred);
-            anyhow::ensure!(
-                alphabet_size >= inferred,
-                "--alphabet-size {} is smaller than max symbol + 1 ({}) in the strings",
-                alphabet_size,
-                inferred
-            );
-        }
-        "SparseMatrixCompression" => {
-            let matrix = parse_bool_matrix(args)?;
-            let usage = "Usage: pred create SparseMatrixCompression --matrix \"1,0,0,1;0,1,0,0;0,0,1,0;1,0,0,0\" --bound-k 2";
-            let bound = args.bound.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SparseMatrixCompression requires --matrix and --bound-k\n\n{usage}"
-                )
-            })?;
-            let bound = parse_nonnegative_usize_bound(bound, "SparseMatrixCompression", usage)?;
-            if bound == 0 {
-                anyhow::bail!("SparseMatrixCompression requires bound >= 1\n\n{usage}");
-            }
-            let _ = SparseMatrixCompression::new(matrix, bound);
-        }
-        "StackerCrane" => {
-            let usage = "Usage: pred create StackerCrane --arcs \"0>4,2>5,5>1,3>0,4>3\" --graph \"0-1,1-2,2-3,3-5,4-5,0-3,1-5\" --arc-lengths 3,4,2,5,3 --edge-lengths 2,1,3,2,1,4,3 --num-vertices 6";
-            let arcs_str = args
-                .arcs
-                .as_deref()
-                .ok_or_else(|| anyhow::anyhow!("StackerCrane requires --arcs\n\n{usage}"))?;
-            let (arcs_graph, num_arcs) = parse_directed_graph(arcs_str, args.num_vertices)?;
-            let (edges_graph, num_vertices) =
-                parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            anyhow::ensure!(
-                edges_graph.num_vertices() == num_vertices,
-                "internal error: inconsistent graph vertex count"
-            );
-            anyhow::ensure!(
-                num_vertices == arcs_graph.num_vertices(),
-                "StackerCrane requires the directed and undirected inputs to agree on --num-vertices\n\n{usage}"
-            );
-            let arc_lengths = parse_arc_costs(args, num_arcs)?;
-            let edge_lengths = parse_i32_edge_values(
-                args.edge_lengths.as_ref(),
-                edges_graph.num_edges(),
-                "edge length",
-            )?;
-            let _ = problemreductions::models::misc::StackerCrane::try_new(
-                num_vertices,
-                arcs_graph.arcs(),
-                edges_graph.edges(),
-                arc_lengths,
-                edge_lengths,
-            )
-            .map_err(|e| anyhow::anyhow!(e))?;
-        }
-        "ThreePartition" => {
-            let sizes_str = args.sizes.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ThreePartition requires --sizes and --bound\n\n\
-                     Usage: pred create ThreePartition --sizes 4,5,6,4,6,5 --bound 15"
-                )
-            })?;
-            let bound = args.bound.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ThreePartition requires --bound\n\n\
-                     Usage: pred create ThreePartition --sizes 4,5,6,4,6,5 --bound 15"
-                )
-            })?;
-            let bound = u64::try_from(bound).map_err(|_| {
-                anyhow::anyhow!(
-                    "ThreePartition requires a positive integer --bound\n\n\
-                     Usage: pred create ThreePartition --sizes 4,5,6,4,6,5 --bound 15"
-                )
-            })?;
-            let sizes: Vec<u64> = util::parse_comma_list(sizes_str)?;
-            let _ = ThreePartition::try_new(sizes, bound).map_err(anyhow::Error::msg)?;
-        }
-        "UndirectedFlowLowerBounds" => {
-            let usage = "Usage: pred create UndirectedFlowLowerBounds --graph 0-1,0-2,1-3,2-3,1-4,3-5,4-5 --capacities 2,2,2,2,1,3,2 --lower-bounds 1,1,0,0,1,0,1 --source 0 --sink 5 --requirement 3";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let capacities = parse_capacities(args, graph.num_edges(), usage)?;
-            let lower_bounds = parse_lower_bounds(args, graph.num_edges(), usage)?;
-            let num_vertices = graph.num_vertices();
-            let source = args.source.ok_or_else(|| {
-                anyhow::anyhow!("UndirectedFlowLowerBounds requires --source\n\n{usage}")
-            })?;
-            let sink = args.sink.ok_or_else(|| {
-                anyhow::anyhow!("UndirectedFlowLowerBounds requires --sink\n\n{usage}")
-            })?;
-            let requirement = args.requirement.ok_or_else(|| {
-                anyhow::anyhow!("UndirectedFlowLowerBounds requires --requirement\n\n{usage}")
-            })?;
-            validate_vertex_index("source", source, num_vertices, usage)?;
-            validate_vertex_index("sink", sink, num_vertices, usage)?;
-            let _ = UndirectedFlowLowerBounds::new(
-                graph,
-                capacities,
-                lower_bounds,
-                source,
-                sink,
-                requirement,
-            );
-        }
-        "SequencingToMinimizeMaximumCumulativeCost" => {
-            let costs_str = args.costs.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SequencingToMinimizeMaximumCumulativeCost requires --costs\n\n\
-                     Usage: pred create SequencingToMinimizeMaximumCumulativeCost --costs 2,-1,3,-2,1,-3 --precedences \"0>2,1>2,1>3,2>4,3>5,4>5\""
-                )
-            })?;
-            let costs: Vec<i64> = util::parse_comma_list(costs_str)?;
-            let precedences = parse_precedence_pairs(
-                args.precedences
-                    .as_deref()
-                    .or(args.precedence_pairs.as_deref()),
-            )?;
-            validate_precedence_pairs(&precedences, costs.len())?;
-        }
-        "SequencingToMinimizeWeightedTardiness" => {
-            let lengths_str = args.lengths.as_deref().or(args.sizes.as_deref()).ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SequencingToMinimizeWeightedTardiness requires --lengths, --weights, --deadlines, and --bound\n\n\
-                     Usage: pred create SequencingToMinimizeWeightedTardiness --lengths 3,4,2,5,3 --weights 2,3,1,4,2 --deadlines 5,8,4,15,10 --bound 13"
-                )
-            })?;
-            let weights_str = args.weights.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SequencingToMinimizeWeightedTardiness requires --weights (comma-separated tardiness weights)\n\n\
-                     Usage: pred create SequencingToMinimizeWeightedTardiness --lengths 3,4,2,5,3 --weights 2,3,1,4,2 --deadlines 5,8,4,15,10 --bound 13"
-                )
-            })?;
-            let deadlines_str = args.deadlines.as_deref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SequencingToMinimizeWeightedTardiness requires --deadlines (comma-separated job deadlines)\n\n\
-                     Usage: pred create SequencingToMinimizeWeightedTardiness --lengths 3,4,2,5,3 --weights 2,3,1,4,2 --deadlines 5,8,4,15,10 --bound 13"
-                )
-            })?;
-            let bound = args.bound.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SequencingToMinimizeWeightedTardiness requires --bound\n\n\
-                     Usage: pred create SequencingToMinimizeWeightedTardiness --lengths 3,4,2,5,3 --weights 2,3,1,4,2 --deadlines 5,8,4,15,10 --bound 13"
-                )
-            })?;
-            anyhow::ensure!(bound >= 0, "--bound must be non-negative");
-            let lengths: Vec<u64> = util::parse_comma_list(lengths_str)?;
-            let weights: Vec<u64> = util::parse_comma_list(weights_str)?;
-            let deadlines: Vec<u64> = util::parse_comma_list(deadlines_str)?;
-            anyhow::ensure!(
-                lengths.len() == weights.len(),
-                "lengths length ({}) must equal weights length ({})",
-                lengths.len(),
-                weights.len()
-            );
-            anyhow::ensure!(
-                lengths.len() == deadlines.len(),
-                "lengths length ({}) must equal deadlines length ({})",
-                lengths.len(),
-                deadlines.len()
-            );
-        }
-        "SequencingWithinIntervals" => {
-            let usage =
-                "Usage: pred create SequencingWithinIntervals --release-times 0,0,5 --deadlines 11,11,6 --lengths 3,1,1";
-            let rt_str = args.release_times.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("SequencingWithinIntervals requires --release-times\n\n{usage}")
-            })?;
-            let dl_str = args.deadlines.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("SequencingWithinIntervals requires --deadlines\n\n{usage}")
-            })?;
-            let len_str = args.lengths.as_deref().ok_or_else(|| {
-                anyhow::anyhow!("SequencingWithinIntervals requires --lengths\n\n{usage}")
-            })?;
-            let release_times: Vec<u64> = util::parse_comma_list(rt_str)?;
-            let deadlines: Vec<u64> = util::parse_comma_list(dl_str)?;
-            let lengths: Vec<u64> = util::parse_comma_list(len_str)?;
-            validate_sequencing_within_intervals_inputs(
-                &release_times,
-                &deadlines,
-                &lengths,
-                usage,
-            )?;
-        }
-        "SetBasis" => {
-            let universe = args.universe.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SetBasis requires --universe, --sets, and --k\n\n\
-                     Usage: pred create SetBasis --universe 4 --sets \"0,1;1,2;0,2;0,1,2\" --k 3"
-                )
-            })?;
-            let _ = args.k.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "SetBasis requires --k\n\n\
-                     Usage: pred create SetBasis --universe 4 --sets \"0,1;1,2;0,2;0,1,2\" --k 3"
-                )
-            })?;
-            let sets = parse_sets(args)?;
-            for (i, set) in sets.iter().enumerate() {
-                for &element in set {
-                    if element >= universe {
-                        bail!(
-                            "Set {} contains element {} which is outside universe of size {}",
-                            i,
-                            element,
-                            universe
-                        );
-                    }
-                }
-            }
-        }
-        "ShortestWeightConstrainedPath" => {
-            let usage = "Usage: pred create ShortestWeightConstrainedPath --graph 0-1,0-2,1-3,2-3,2-4,3-5,4-5,1-4 --edge-lengths 2,4,3,1,5,4,2,6 --edge-weights 5,1,2,3,2,3,1,1 --source-vertex 0 --target-vertex 5 --weight-bound 8";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            if args.weights.is_some() {
-                bail!(
-                    "ShortestWeightConstrainedPath uses --edge-weights, not --weights\n\nUsage: {usage}"
-                );
-            }
-            let edge_lengths_raw = args.edge_lengths.as_ref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ShortestWeightConstrainedPath requires --edge-lengths\n\nUsage: {usage}"
-                )
-            })?;
-            let edge_weights_raw = args.edge_weights.as_ref().ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ShortestWeightConstrainedPath requires --edge-weights\n\nUsage: {usage}"
-                )
-            })?;
-            let edge_lengths =
-                parse_i32_edge_values(Some(edge_lengths_raw), graph.num_edges(), "edge length")?;
-            let edge_weights =
-                parse_i32_edge_values(Some(edge_weights_raw), graph.num_edges(), "edge weight")?;
-            ensure_positive_i32_values(&edge_lengths, "edge lengths")?;
-            ensure_positive_i32_values(&edge_weights, "edge weights")?;
-            let source_vertex = args.source_vertex.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ShortestWeightConstrainedPath requires --source-vertex\n\nUsage: {usage}"
-                )
-            })?;
-            let target_vertex = args.target_vertex.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ShortestWeightConstrainedPath requires --target-vertex\n\nUsage: {usage}"
-                )
-            })?;
-            let weight_bound = args.weight_bound.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "ShortestWeightConstrainedPath requires --weight-bound\n\nUsage: {usage}"
-                )
-            })?;
-            ensure_vertex_in_bounds(source_vertex, graph.num_vertices(), "source_vertex")?;
-            ensure_vertex_in_bounds(target_vertex, graph.num_vertices(), "target_vertex")?;
-            ensure_positive_i32(weight_bound, "weight_bound")?;
-        }
-        "SteinerTree" => {
-            let usage = "Usage: pred create SteinerTree --graph 0-1,1-2,1-3,3-4 --edge-weights 2,2,1,1 --terminals 0,2,4";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let _ = parse_edge_weights(args, graph.num_edges())?;
-            let _ = parse_terminals(args, graph.num_vertices())
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-        }
-        "TimetableDesign" => {
-            let usage = "Usage: pred create TimetableDesign --num-periods 3 --num-craftsmen 5 --num-tasks 5 --craftsman-avail \"1,1,1;1,1,0;0,1,1;1,0,1;1,1,1\" --task-avail \"1,1,0;0,1,1;1,0,1;1,1,1;1,1,1\" --requirements \"1,0,1,0,0;0,1,0,0,1;0,0,0,1,0;0,0,0,0,1;0,1,0,0,0\"";
-            let num_periods = args.num_periods.ok_or_else(|| {
-                anyhow::anyhow!("TimetableDesign requires --num-periods\n\n{usage}")
-            })?;
-            let num_craftsmen = args.num_craftsmen.ok_or_else(|| {
-                anyhow::anyhow!("TimetableDesign requires --num-craftsmen\n\n{usage}")
-            })?;
-            let num_tasks = args.num_tasks.ok_or_else(|| {
-                anyhow::anyhow!("TimetableDesign requires --num-tasks\n\n{usage}")
-            })?;
-            let craftsman_avail =
-                parse_named_bool_rows(args.craftsman_avail.as_deref(), "--craftsman-avail", usage)?;
-            let task_avail =
-                parse_named_bool_rows(args.task_avail.as_deref(), "--task-avail", usage)?;
-            let requirements = parse_timetable_requirements(args.requirements.as_deref(), usage)?;
-            validate_timetable_design_args(
-                num_periods,
-                num_craftsmen,
-                num_tasks,
-                &craftsman_avail,
-                &task_avail,
-                &requirements,
-                usage,
-            )?;
-        }
-        "UndirectedTwoCommodityIntegralFlow" => {
-            let usage = "Usage: pred create UndirectedTwoCommodityIntegralFlow --graph 0-2,1-2,2-3 --capacities 1,1,2 --source-1 0 --sink-1 3 --source-2 1 --sink-2 3 --requirement-1 1 --requirement-2 1";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let capacities = parse_capacities(args, graph.num_edges(), usage)?;
-            for (edge_index, &capacity) in capacities.iter().enumerate() {
-                let fits = usize::try_from(capacity)
-                    .ok()
-                    .and_then(|value| value.checked_add(1))
-                    .is_some();
-                if !fits {
-                    bail!(
-                        "capacity {} at edge index {} is too large for this platform\n\n{}",
-                        capacity,
-                        edge_index,
-                        usage
-                    );
-                }
-            }
-            let num_vertices = graph.num_vertices();
-            let source_1 = args.source_1.ok_or_else(|| {
-                anyhow::anyhow!("UndirectedTwoCommodityIntegralFlow requires --source-1\n\n{usage}")
-            })?;
-            let sink_1 = args.sink_1.ok_or_else(|| {
-                anyhow::anyhow!("UndirectedTwoCommodityIntegralFlow requires --sink-1\n\n{usage}")
-            })?;
-            let source_2 = args.source_2.ok_or_else(|| {
-                anyhow::anyhow!("UndirectedTwoCommodityIntegralFlow requires --source-2\n\n{usage}")
-            })?;
-            let sink_2 = args.sink_2.ok_or_else(|| {
-                anyhow::anyhow!("UndirectedTwoCommodityIntegralFlow requires --sink-2\n\n{usage}")
-            })?;
-            let _ = args.requirement_1.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "UndirectedTwoCommodityIntegralFlow requires --requirement-1\n\n{usage}"
-                )
-            })?;
-            let _ = args.requirement_2.ok_or_else(|| {
-                anyhow::anyhow!(
-                    "UndirectedTwoCommodityIntegralFlow requires --requirement-2\n\n{usage}"
-                )
-            })?;
-            for (label, vertex) in [
-                ("source-1", source_1),
-                ("sink-1", sink_1),
-                ("source-2", source_2),
-                ("sink-2", sink_2),
-            ] {
-                validate_vertex_index(label, vertex, num_vertices, usage)?;
-            }
-        }
-        _ => {}
-    }
-
-    Ok(())
-}
diff --git a/problemreductions-cli/src/commands/create/schema_support.rs b/problemreductions-cli/src/commands/create/schema_support.rs
index d7ecb3497..42d0e5fd5 100644
--- a/problemreductions-cli/src/commands/create/schema_support.rs
+++ b/problemreductions-cli/src/commands/create/schema_support.rs
@@ -8,12 +8,22 @@ pub(super) struct CreateContext {
     parsed_fields: BTreeMap<String, serde_json::Value>,
 }
 
-impl CreateContext {
-    pub(super) fn with_field(mut self, name: &str, value: serde_json::Value) -> Self {
-        self.parsed_fields.insert(name.to_string(), value);
-        self
-    }
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum InputValueKind {
+    Text,
+    Usize,
+    I64,
+    F64,
+    Bool,
+}
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct CreateInput {
+    pub name: String,
+    pub kind: InputValueKind,
+}
+
+impl CreateContext {
     fn seed_field<T: Serialize>(&mut self, name: &str, value: T) -> Result<()> {
         let value = serde_json::to_value(value)?;
         if name == "num_vertices" {
@@ -85,134 +95,180 @@ pub(super) fn create_schema_driven(
     args: &CreateArgs,
     canonical: &str,
     resolved_variant: &BTreeMap<String, String>,
-) -> Result<Option<(serde_json::Value, BTreeMap<String, String>)>> {
-    if !schema_driven_supported_problem(canonical) {
-        return Ok(None);
-    }
+) -> Result<(serde_json::Value, BTreeMap<String, String>)> {
+    let schema = problemreductions::registry::find_problem_type(canonical)
+        .ok_or_else(|| anyhow::anyhow!("No schema is registered for {canonical}"))?;
+    let variant_entry =
+        problemreductions::registry::find_variant_entry(canonical, resolved_variant).ok_or_else(
+            || {
+                anyhow::anyhow!(
+                    "No concrete variant is registered for {canonical} with {resolved_variant:?}"
+                )
+            },
+        )?;
 
-    let Some(schema) = collect_schemas()
-        .into_iter()
-        .find(|schema| schema.name == canonical)
-    else {
-        return Ok(None);
-    };
-    let Some(variant_entry) =
-        problemreductions::registry::find_variant_entry(canonical, resolved_variant)
-    else {
-        return Ok(None);
-    };
+    if let Some(inputs) = variant_entry.create_inputs {
+        let inputs = inputs();
+        let inputs = inputs.as_slice();
+        let data = normalize_registered_create_inputs(args, inputs, resolved_variant)
+            .map_err(|error| with_registered_usage(error, canonical, inputs))?;
+        return construct_canonical(variant_entry, canonical, resolved_variant, data)
+            .map_err(|error| with_registered_usage(error, canonical, inputs));
+    }
 
     let graph_type = resolved_graph_type(resolved_variant);
     let is_geometry = matches!(
         graph_type,
         "KingsSubgraph" | "TriangularSubgraph" | "UnitDiskGraph"
     );
-    let flag_map = args.flag_map();
     let mut context = CreateContext::default();
     seed_schema_context_from_cli(args, graph_type, &mut context)?;
-    validate_schema_driven_semantics(args, canonical, resolved_variant, &serde_json::Value::Null)
-        .map_err(|error| with_schema_usage(error, canonical, resolved_variant))?;
     let mut json_map = serde_json::Map::new();
 
-    for field in &schema.fields {
-        let concrete_type = resolve_schema_field_type(&field.type_name, resolved_variant);
-        let flag_keys =
-            schema_field_flag_keys(canonical, &field.name, &field.type_name, is_geometry);
-        let raw_value = get_schema_flag_value(&flag_map, &flag_keys);
-        let value = if !schema_field_requires_derived_input(&field.name, &concrete_type) {
-            if let Some(raw_value) = raw_value.clone() {
-                match parse_schema_field_value(
-                    args,
-                    canonical,
-                    &concrete_type,
-                    &field.name,
-                    &raw_value,
-                    &context,
-                ) {
-                    Ok(value) => value,
-                    Err(error) => {
-                        return Err(with_schema_usage(error, canonical, resolved_variant))
-                    }
-                }
-            } else if let Some(derived) =
-                derive_schema_field_value(args, canonical, &field.name, &concrete_type, &context)?
-            {
-                derived
-            } else {
-                return Err(with_schema_usage(
-                    missing_schema_field_error(
-                        canonical,
-                        &field.name,
-                        &field.type_name,
-                        is_geometry,
-                    ),
-                    canonical,
-                    resolved_variant,
-                ));
-            }
-        } else if let Some(derived) =
-            derive_schema_field_value(args, canonical, &field.name, &concrete_type, &context)?
-        {
-            derived
-        } else if let Some(raw_value) = raw_value {
-            match parse_schema_field_value(
-                args,
-                canonical,
-                &concrete_type,
-                &field.name,
-                &raw_value,
-                &context,
-            ) {
-                Ok(value) => value,
-                Err(error) => return Err(with_schema_usage(error, canonical, resolved_variant)),
-            }
-        } else {
-            return Err(with_schema_usage(
-                missing_schema_field_error(canonical, &field.name, &field.type_name, is_geometry),
+    for field in schema.fields {
+        let concrete_type = resolve_schema_field_type(field.type_name, resolved_variant);
+        let flag_name = problem_help_flag_name(field.name, field.type_name, is_geometry);
+        let raw_value = args.raw(&flag_name).ok_or_else(|| {
+            with_schema_usage(
+                missing_schema_field_error(canonical, field.name, field.type_name, is_geometry),
                 canonical,
                 resolved_variant,
-            ));
-        };
+            )
+        })?;
+        let value = parse_schema_field_value(&concrete_type, field.name, raw_value, &context)
+            .map_err(|error| with_schema_usage(error, canonical, resolved_variant))?;
 
-        context.remember(&field.name, &concrete_type, &value);
-        json_map.insert(field.name.clone(), value);
+        context.remember(field.name, &concrete_type, &value);
+        json_map.insert(field.name.to_string(), value);
     }
 
-    // KColoring/KN stores the number of colors at runtime in `num_colors`.
-    // The schema only declares `graph`, so inject `num_colors` from --k for KN.
-    if canonical == "KColoring" && resolved_variant.get("k").map(|s| s.as_str()) == Some("KN") {
-        if let Some(k) = args.k {
-            json_map.insert("num_colors".to_string(), serde_json::json!(k));
+    let data = serde_json::Value::Object(json_map);
+    construct_canonical(variant_entry, canonical, resolved_variant, data)
+}
+
+fn construct_canonical(
+    entry: &problemreductions::registry::VariantEntry,
+    canonical: &str,
+    resolved_variant: &BTreeMap<String, String>,
+    data: serde_json::Value,
+) -> Result<(serde_json::Value, BTreeMap<String, String>)> {
+    let problem = (entry.construct_fn)(data)?;
+    let constructed_variant = problem.variant_map();
+    anyhow::ensure!(
+        problem.problem_name() == canonical && constructed_variant == *resolved_variant,
+        "registered constructor for {canonical} {resolved_variant:?} returned {} {constructed_variant:?}",
+        problem.problem_name(),
+    );
+    Ok((problem.serialize_json(), constructed_variant))
+}
+
+pub(super) fn normalize_registered_create_inputs(
+    args: &CreateArgs,
+    inputs: &[problemreductions::registry::CreateInputInfo],
+    resolved_variant: &BTreeMap<String, String>,
+) -> Result<serde_json::Value> {
+    let mut values = serde_json::Map::new();
+    for input in inputs {
+        let flag_name = input.name.replace('_', "-");
+        if let Some(raw) = args.raw(&flag_name) {
+            let concrete_type = resolve_schema_field_type(input.type_name, resolved_variant);
+            values.insert(
+                input.name.to_string(),
+                normalize_registered_input(input, &concrete_type, raw)?,
+            );
         }
     }
+    Ok(serde_json::Value::Object(values))
+}
 
-    // Decision<P> types serialize as {inner: {graph, weights, ...}, bound} but schema
-    // fields are flat (graph, weights, bound).  Restructure when the canonical name
-    // indicates a Decision wrapper.
-    let data = if canonical.starts_with("Decision") {
-        let bound = json_map
-            .remove("bound")
-            .expect("Decision types require a bound field");
-        let mut outer = serde_json::Map::new();
-        outer.insert("inner".to_string(), serde_json::Value::Object(json_map));
-        outer.insert("bound".to_string(), bound);
-        serde_json::Value::Object(outer)
-    } else {
-        serde_json::Value::Object(json_map)
-    };
-    validate_schema_driven_semantics(args, canonical, resolved_variant, &data)
-        .map_err(|error| with_schema_usage(error, canonical, resolved_variant))?;
-    (variant_entry.factory)(data.clone()).map_err(|error| {
-        with_schema_usage(
+fn normalize_registered_input(
+    input: &problemreductions::registry::CreateInputInfo,
+    concrete_type: &str,
+    raw: &str,
+) -> Result<serde_json::Value> {
+    use problemreductions::registry::CreateInputCodec;
+
+    let value = match input.codec {
+        CreateInputCodec::Json => serde_json::from_str(raw).map_err(|error| {
             anyhow::anyhow!(
-                "Schema-driven factory rejected generated data for {canonical}: {error}"
-            ),
-            canonical,
-            resolved_variant,
-        )
-    })?;
+                "Invalid JSON for --{}: {error}",
+                input.name.replace('_', "-")
+            )
+        })?,
+        CreateInputCodec::EdgeList | CreateInputCodec::BipartiteEdgeList => {
+            serde_json::to_value(util::parse_edge_pairs(raw)?)?
+        }
+        CreateInputCodec::ArcList => serde_json::to_value(parse_registered_arcs(raw)?)?,
+        CreateInputCodec::EqualityPairList => {
+            serde_json::to_value(parse_registered_equality_pairs(raw)?)?
+        }
+        CreateInputCodec::FunctionalDependencyList => {
+            serde_json::to_value(parse_registered_functional_dependencies(raw)?)?
+        }
+        CreateInputCodec::CharacterRows => {
+            serde_json::to_value(parse_registered_character_rows(raw))?
+        }
+        CreateInputCodec::Auto
+        | CreateInputCodec::Scalar
+        | CreateInputCodec::CommaSeparated
+        | CreateInputCodec::SemicolonSeparated => {
+            parse_field_value(concrete_type, input.name, raw, &CreateContext::default())?
+        }
+    };
+    Ok(value)
+}
+
+fn parse_registered_character_rows(raw: &str) -> Vec<Vec<usize>> {
+    let mut alphabet = BTreeMap::new();
+    raw.split(';')
+        .map(|row| {
+            row.chars()
+                .map(|symbol| {
+                    let next = alphabet.len();
+                    *alphabet.entry(symbol).or_insert(next)
+                })
+                .collect()
+        })
+        .collect()
+}
+
+fn parse_registered_arcs(raw: &str) -> Result<Vec<(usize, usize)>> {
+    raw.split(',')
+        .map(|arc| {
+            let (source, target) = arc.trim().split_once('>').ok_or_else(|| {
+                anyhow::anyhow!("Invalid arc '{}': expected format u>v", arc.trim())
+            })?;
+            Ok((source.trim().parse()?, target.trim().parse()?))
+        })
+        .collect()
+}
+
+fn parse_registered_equality_pairs(raw: &str) -> Result<Vec<(usize, usize)>> {
+    raw.split(';')
+        .map(|pair| {
+            let (left, right) = pair.trim().split_once('=').ok_or_else(|| {
+                anyhow::anyhow!("Invalid pair '{}': expected format left=right", pair.trim())
+            })?;
+            Ok((left.trim().parse()?, right.trim().parse()?))
+        })
+        .collect()
+}
 
-    Ok(Some((data, resolved_variant.clone())))
+fn parse_registered_functional_dependencies(raw: &str) -> Result<Vec<(Vec<usize>, Vec<usize>)>> {
+    raw.split(';')
+        .map(|dependency| {
+            let (left, right) = dependency.trim().split_once(':').ok_or_else(|| {
+                anyhow::anyhow!(
+                    "Invalid functional dependency '{}': expected format lhs:rhs",
+                    dependency.trim()
+                )
+            })?;
+            Ok((
+                util::parse_comma_list(left)?,
+                util::parse_comma_list(right)?,
+            ))
+        })
+        .collect()
 }
 
 pub(super) fn missing_schema_field_error(
@@ -221,214 +277,137 @@ pub(super) fn missing_schema_field_error(
     field_type: &str,
     is_geometry: bool,
 ) -> anyhow::Error {
-    let display = problem_help_flag_name(canonical, field_name, field_type, is_geometry);
-    let flags: Vec<String> = display
-        .split('/')
-        .filter_map(|part| {
-            let trimmed = part.trim().trim_start_matches("--");
-            (!trimmed.is_empty()).then(|| format!("--{trimmed}"))
-        })
-        .collect();
-    let requirement = match flags.as_slice() {
-        [] => format!("--{}", field_name.replace('_', "-")),
-        [flag] => flag.clone(),
-        [first, second] => format!("{first} or {second}"),
-        _ => {
-            let last = flags.last().cloned().unwrap_or_default();
-            format!("{}, or {}", flags[..flags.len() - 1].join(", "), last)
-        }
-    };
+    let flag = problem_help_flag_name(field_name, field_type, is_geometry);
+    let requirement = format!("--{flag}");
     anyhow::anyhow!("{canonical} requires {requirement}")
 }
 
 pub(super) fn parse_schema_field_value(
-    args: &CreateArgs,
-    canonical: &str,
     concrete_type: &str,
     field_name: &str,
     raw: &str,
     context: &CreateContext,
 ) -> Result<serde_json::Value> {
-    match (canonical, field_name) {
-        ("BoyceCoddNormalFormViolation", "functional_deps") => {
-            let num_attributes = args.n.ok_or_else(|| {
-                anyhow::anyhow!("BoyceCoddNormalFormViolation requires --n, --sets, and --target")
-            })?;
-            Ok(serde_json::to_value(parse_bcnf_functional_deps(
-                raw,
-                num_attributes,
-            )?)?)
-        }
-        ("BoundedComponentSpanningForest", "max_weight") => {
-            let usage = "Usage: pred create BoundedComponentSpanningForest --graph 0-1,1-2,2-3,3-4,4-5,5-6,6-7,0-7,1-5,2-6 --weights 2,3,1,2,3,1,2,1 --k 3 --max-weight 6";
-            let bound_raw = args.bound.ok_or_else(|| {
-                anyhow::anyhow!("BoundedComponentSpanningForest requires --max-weight\n\n{usage}")
-            })?;
-            let max_weight = i32::try_from(bound_raw).map_err(|_| {
-                anyhow::anyhow!(
-                    "BoundedComponentSpanningForest requires --max-weight within i32 range\n\n{usage}"
-                )
-            })?;
-            Ok(serde_json::json!(max_weight))
-        }
-        ("ConsecutiveBlockMinimization", "matrix") => {
-            let usage = "Usage: pred create ConsecutiveBlockMinimization --matrix '[[true,false,true],[false,true,true]]' --bound-k 2";
-            let matrix: Vec<Vec<bool>> = serde_json::from_str(raw).map_err(|err| {
-                anyhow::anyhow!(
-                    "ConsecutiveBlockMinimization requires --matrix as a JSON 2D bool array (e.g., '[[true,false,true],[false,true,true]]')\n\n{usage}\n\nFailed to parse --matrix: {err}"
-                )
-            })?;
-            Ok(serde_json::to_value(matrix)?)
-        }
-        ("FeasibleBasisExtension", "matrix") => {
-            let usage = "Usage: pred create FeasibleBasisExtension --matrix '[[1,0,1],[0,1,0]]' --rhs '7,5' --required-columns '0'";
-            let matrix: Vec<Vec<i64>> = serde_json::from_str(raw).map_err(|err| {
-                anyhow::anyhow!(
-                    "FeasibleBasisExtension requires --matrix as a JSON 2D integer array (e.g., '[[1,0,1],[0,1,0]]')\n\n{usage}\n\nFailed to parse --matrix: {err}"
-                )
-            })?;
-            Ok(serde_json::to_value(matrix)?)
-        }
-        ("IntegralFlowBundles", "bundle_capacities") => {
-            let usage = "Usage: pred create IntegralFlowBundles --arcs \"0>1,0>2,1>3,2>3,1>2,2>1\" --bundles \"0,1;2,5;3,4\" --bundle-capacities 1,1,1 --source 0 --sink 3 --requirement 1 --num-vertices 4";
-            let arcs_str = args
-                .arcs
-                .as_deref()
-                .ok_or_else(|| anyhow::anyhow!("IntegralFlowBundles requires --arcs\n\n{usage}"))?;
-            let (_, num_arcs) = parse_directed_graph(arcs_str, args.num_vertices)
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            let bundles = parse_bundles(args, num_arcs, usage)?;
-            Ok(serde_json::to_value(parse_bundle_capacities(
-                args,
-                bundles.len(),
-                usage,
-            )?)?)
-        }
-        ("IntegralFlowHomologousArcs", "homologous_pairs") => {
-            Ok(serde_json::to_value(parse_homologous_pairs(args)?)?)
-        }
-        ("LengthBoundedDisjointPaths", "max_length") => {
-            let usage = "Usage: pred create LengthBoundedDisjointPaths --graph 0-1,1-6,0-2,2-3,3-6,0-4,4-5,5-6 --source 0 --sink 6 --max-length 3";
-            let bound = args.bound.ok_or_else(|| {
-                anyhow::anyhow!("LengthBoundedDisjointPaths requires --max-length\n\n{usage}")
-            })?;
-            let max_length = usize::try_from(bound).map_err(|_| {
-                anyhow::anyhow!(
-                    "--max-length must be a nonnegative integer for LengthBoundedDisjointPaths\n\n{usage}"
-                )
-            })?;
-            Ok(serde_json::json!(max_length))
-        }
-        ("LongestCommonSubsequence", "strings") => {
-            let (strings, _) = parse_lcs_strings(raw)?;
-            Ok(serde_json::to_value(strings)?)
-        }
-        ("MinimumDecisionTree", "test_matrix") => {
-            let usage = "Usage: pred create MinimumDecisionTree --test-matrix '[[true,true,false,false],[true,false,false,false],[false,true,false,true]]' --num-objects 4 --num-tests 3";
-            let matrix: Vec<Vec<bool>> = serde_json::from_str(raw).map_err(|err| {
-                anyhow::anyhow!(
-                    "MinimumDecisionTree requires --test-matrix as a JSON 2D bool array\n\n{usage}\n\nFailed to parse --test-matrix: {err}"
-                )
-            })?;
-            Ok(serde_json::to_value(matrix)?)
-        }
-        ("MinimumWeightDecoding", "matrix") => {
-            let usage = "Usage: pred create MinimumWeightDecoding --matrix '[[true,false,true],[false,true,true]]' --rhs 'true,true'";
-            let matrix: Vec<Vec<bool>> = serde_json::from_str(raw).map_err(|err| {
-                anyhow::anyhow!(
-                    "MinimumWeightDecoding requires --matrix as a JSON 2D bool array (e.g., '[[true,false],[false,true]]')\n\n{usage}\n\nFailed to parse --matrix: {err}"
-                )
-            })?;
-            Ok(serde_json::to_value(matrix)?)
-        }
-        ("MinimumWeightSolutionToLinearEquations", "matrix") => {
-            let usage = "Usage: pred create MinimumWeightSolutionToLinearEquations --matrix '[[1,2,3,1],[2,1,1,3]]' --rhs '5,4'";
-            let matrix: Vec<Vec<i64>> = serde_json::from_str(raw).map_err(|err| {
-                anyhow::anyhow!(
-                    "MinimumWeightSolutionToLinearEquations requires --matrix as a JSON 2D integer array (e.g., '[[1,2,3],[4,5,6]]')\n\n{usage}\n\nFailed to parse --matrix: {err}"
-                )
-            })?;
-            Ok(serde_json::to_value(matrix)?)
-        }
-        ("GroupingBySwapping", "string")
-        | ("StringToStringCorrection", "source")
-        | ("StringToStringCorrection", "target") => {
-            Ok(serde_json::to_value(parse_symbol_list_allow_empty(raw)?)?)
+    parse_field_value(concrete_type, field_name, raw, context)
+}
+
+pub(crate) fn create_inputs_for(
+    canonical: &str,
+    resolved_variant: &BTreeMap<String, String>,
+) -> Vec<CreateInput> {
+    let variant_entry =
+        problemreductions::registry::find_variant_entry(canonical, resolved_variant)
+            .unwrap_or_else(|| {
+                panic!("missing registered variant for `{canonical}` with {resolved_variant:?}")
+            });
+    let mut inputs = BTreeMap::<String, (InputValueKind, String)>::new();
+
+    if let Some(custom_inputs) = variant_entry.create_inputs {
+        for input in custom_inputs() {
+            let concrete_type = resolve_schema_field_type(input.type_name, resolved_variant);
+            insert_create_input(
+                &mut inputs,
+                &input.name.replace('_', "-"),
+                input_value_kind(&concrete_type),
+                input.name,
+            );
         }
-        ("MultipleCopyFileAllocation", "usage") => {
-            let (_, num_vertices) = parse_graph(args)
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{MULTIPLE_COPY_FILE_ALLOCATION_USAGE}"))?;
-            Ok(serde_json::to_value(parse_vertex_i64_values(
-                args.usage.as_deref(),
-                "usage",
-                num_vertices,
-                "MultipleCopyFileAllocation",
-                MULTIPLE_COPY_FILE_ALLOCATION_USAGE,
-            )?)?)
+    } else {
+        let schema = problemreductions::registry::find_problem_type(canonical)
+            .unwrap_or_else(|| panic!("missing schema for `{canonical}`"));
+        let graph_type = resolved_graph_type(resolved_variant);
+        let is_geometry = matches!(
+            graph_type,
+            "KingsSubgraph" | "TriangularSubgraph" | "UnitDiskGraph"
+        );
+        for field in schema.fields {
+            let concrete_type = resolve_schema_field_type(field.type_name, resolved_variant);
+            match concrete_type.as_str() {
+                "DirectedGraph" => {
+                    insert_create_input(&mut inputs, "arcs", InputValueKind::Text, field.name);
+                }
+                _ => {
+                    let name = problem_help_flag_name(field.name, field.type_name, is_geometry);
+                    insert_create_input(
+                        &mut inputs,
+                        &name,
+                        input_value_kind(&concrete_type),
+                        field.name,
+                    );
+                }
+            }
         }
-        ("MultipleCopyFileAllocation", "storage") => {
-            let (_, num_vertices) = parse_graph(args)
-                .map_err(|e| anyhow::anyhow!("{e}\n\n{MULTIPLE_COPY_FILE_ALLOCATION_USAGE}"))?;
-            Ok(serde_json::to_value(parse_vertex_i64_values(
-                args.storage.as_deref(),
-                "storage",
-                num_vertices,
-                "MultipleCopyFileAllocation",
-                MULTIPLE_COPY_FILE_ALLOCATION_USAGE,
-            )?)?)
+        if schema.fields.iter().any(|field| {
+            let concrete_type = resolve_schema_field_type(field.type_name, resolved_variant);
+            matches!(concrete_type.as_str(), "SimpleGraph" | "DirectedGraph")
+        }) {
+            insert_create_input(
+                &mut inputs,
+                "num-vertices",
+                InputValueKind::Usize,
+                "graph vertex count",
+            );
         }
-        ("SequencingToMinimizeMaximumCumulativeCost", "precedences") => {
-            Ok(serde_json::to_value(parse_precedence_pairs(
-                args.precedences
-                    .as_deref()
-                    .or(args.precedence_pairs.as_deref()),
-            )?)?)
+        if graph_type == "UnitDiskGraph" {
+            insert_create_input(
+                &mut inputs,
+                "radius",
+                InputValueKind::F64,
+                "unit-disk graph radius",
+            );
         }
-        ("UndirectedTwoCommodityIntegralFlow", "capacities") => {
-            let usage = "Usage: pred create UndirectedTwoCommodityIntegralFlow --graph 0-2,1-2,2-3 --capacities 1,1,2 --source-1 0 --sink-1 3 --source-2 1 --sink-2 3 --requirement-1 1 --requirement-2 1";
-            let (graph, _) = parse_graph(args).map_err(|e| anyhow::anyhow!("{e}\n\n{usage}"))?;
-            Ok(serde_json::to_value(parse_capacities(
-                args,
-                graph.num_edges(),
-                usage,
-            )?)?)
+    }
+    if let Some(random) = variant_entry.random {
+        insert_create_input(
+            &mut inputs,
+            "random",
+            InputValueKind::Bool,
+            "random generation",
+        );
+        for input in (random.inputs)() {
+            let concrete_type = resolve_schema_field_type(input.type_name, resolved_variant);
+            insert_create_input(
+                &mut inputs,
+                &input.name.replace('_', "-"),
+                input_value_kind(&concrete_type),
+                input.name,
+            );
         }
-        _ => parse_field_value(concrete_type, field_name, raw, context),
     }
-}
 
-pub(super) fn schema_driven_supported_problem(canonical: &str) -> bool {
-    canonical != "ILP" && canonical != "CircuitSAT"
+    inputs
+        .into_iter()
+        .map(|(name, (kind, _))| CreateInput { name, kind })
+        .collect()
 }
 
-pub(super) fn schema_field_flag_keys(
-    canonical: &str,
-    field_name: &str,
-    field_type: &str,
-    is_geometry: bool,
-) -> Vec<String> {
-    let mut keys = vec![field_name.replace('_', "-")];
-    for display_key in problem_help_flag_name(canonical, field_name, field_type, is_geometry)
-        .split('/')
-        .map(|key| key.trim().trim_start_matches("--").to_string())
-        .filter(|key| !key.is_empty())
-    {
-        if !keys.contains(&display_key) {
-            keys.push(display_key);
-        }
+fn insert_create_input(
+    inputs: &mut BTreeMap<String, (InputValueKind, String)>,
+    name: &str,
+    kind: InputValueKind,
+    source: &str,
+) {
+    if let Some((existing_kind, existing_source)) = inputs.get(name) {
+        assert_eq!(
+            *existing_kind, kind,
+            "create input --{name} has conflicting types from `{existing_source}` and `{source}`"
+        );
+        return;
     }
-    keys
+    inputs.insert(name.to_string(), (kind, source.to_string()));
 }
 
-pub(super) fn get_schema_flag_value(
-    flag_map: &std::collections::HashMap<&'static str, Option<String>>,
-    keys: &[String],
-) -> Option<String> {
-    keys.iter()
-        .find_map(|key| flag_map.get(key.as_str()).cloned().flatten())
+fn input_value_kind(concrete_type: &str) -> InputValueKind {
+    match normalize_type_name(concrete_type).as_str() {
+        "usize" => InputValueKind::Usize,
+        "i64" => InputValueKind::I64,
+        "f64" => InputValueKind::F64,
+        "bool" => InputValueKind::Bool,
+        _ => InputValueKind::Text,
+    }
 }
 
-pub(super) fn resolve_schema_field_type(
+pub(crate) fn resolve_schema_field_type(
     type_name: &str,
     resolved_variant: &BTreeMap<String, String>,
 ) -> String {
@@ -456,9 +435,9 @@ pub(super) fn resolve_schema_field_type(
 
 pub(super) fn weight_sum_type(weight_type: &str) -> &'static str {
     match weight_type {
-        "One" | "i32" => "i32",
+        "One" | "i64" => "i64",
         "f64" => "f64",
-        _ => "i32",
+        _ => "i64",
     }
 }
 
@@ -467,277 +446,15 @@ pub(super) fn seed_schema_context_from_cli(
     graph_type: &str,
     context: &mut CreateContext,
 ) -> Result<()> {
-    if let Some(num_vertices) = args.num_vertices {
+    if let Some(num_vertices) = args.value::<usize>("num-vertices") {
         context.seed_field("num_vertices", num_vertices)?;
     }
     if graph_type == "UnitDiskGraph" {
-        context.seed_field("radius", args.radius.unwrap_or(1.0))?;
+        context.seed_field("radius", args.value::<f64>("radius").unwrap_or(1.0))?;
     }
     Ok(())
 }
 
-pub(super) fn derive_schema_field_value(
-    args: &CreateArgs,
-    canonical: &str,
-    field_name: &str,
-    concrete_type: &str,
-    context: &CreateContext,
-) -> Result<Option<serde_json::Value>> {
-    if let Some(defaulted) =
-        derive_schema_default_value(canonical, field_name, concrete_type, context)?
-    {
-        return Ok(Some(defaulted));
-    }
-
-    if field_name == "graph" && concrete_type == "MixedGraph" {
-        let usage = format!(
-            "Usage: pred create {canonical} {}",
-            example_for(canonical, None)
-        );
-        return Ok(Some(serde_json::to_value(parse_mixed_graph(
-            args, &usage,
-        )?)?));
-    }
-
-    if field_name == "graph" && concrete_type == "BipartiteGraph" {
-        let left = args
-            .left
-            .ok_or_else(|| anyhow::anyhow!("{canonical} requires --left"))?;
-        let right = args
-            .right
-            .ok_or_else(|| anyhow::anyhow!("{canonical} requires --right"))?;
-        let edges_raw = args
-            .biedges
-            .as_deref()
-            .ok_or_else(|| anyhow::anyhow!("{canonical} requires --biedges"))?;
-        let edges = util::parse_edge_pairs(edges_raw)?;
-        validate_bipartite_edges(canonical, left, right, &edges)?;
-        return Ok(Some(serde_json::to_value(BipartiteGraph::new(
-            left, right, edges,
-        ))?));
-    }
-
-    if canonical == "ClosestVectorProblem"
-        && field_name == "bounds"
-        && normalize_type_name(concrete_type) == "Vec<VarBounds>"
-    {
-        return Ok(Some(parse_cvp_bounds_value(
-            args.bounds.as_deref(),
-            context,
-        )?));
-    }
-
-    if canonical == "ConjunctiveBooleanQuery"
-        && field_name == "num_variables"
-        && normalize_type_name(concrete_type) == "usize"
-    {
-        let raw = args
-            .conjuncts_spec
-            .as_deref()
-            .ok_or_else(|| anyhow::anyhow!("ConjunctiveBooleanQuery requires --conjuncts-spec"))?;
-        return Ok(Some(serde_json::json!(infer_cbq_num_variables(raw)?)));
-    }
-
-    if canonical == "GroupingBySwapping"
-        && field_name == "alphabet_size"
-        && normalize_type_name(concrete_type) == "usize"
-    {
-        let raw = args
-            .string
-            .as_deref()
-            .ok_or_else(|| anyhow::anyhow!("GroupingBySwapping requires --string"))?;
-        let string = parse_symbol_list_allow_empty(raw)?;
-        let inferred = string.iter().copied().max().map_or(0, |value| value + 1);
-        return Ok(Some(serde_json::json!(args
-            .alphabet_size
-            .unwrap_or(inferred))));
-    }
-
-    if canonical == "JobShopScheduling"
-        && field_name == "num_processors"
-        && normalize_type_name(concrete_type) == "usize"
-    {
-        let usage = "Usage: pred create JobShopScheduling --jobs \"0:3,1:4;1:2,0:3,1:2;0:4,1:3\" --num-processors 2";
-        let inferred_processors = match args.job_tasks.as_deref() {
-            Some(job_tasks) => {
-                let jobs = parse_job_shop_jobs(job_tasks)?;
-                jobs.iter()
-                    .flat_map(|job| job.iter().map(|(processor, _)| *processor))
-                    .max()
-                    .map(|processor| processor + 1)
-            }
-            None => None,
-        };
-        let num_processors =
-            resolve_processor_count_flags("JobShopScheduling", usage, args.num_processors, args.m)?
-                .or(inferred_processors)
-                .ok_or_else(|| {
-                    anyhow::anyhow!(
-                        "Cannot infer num_processors from empty job list; use --num-processors"
-                    )
-                })?;
-        return Ok(Some(serde_json::json!(num_processors)));
-    }
-
-    if canonical == "LongestCommonSubsequence"
-        && field_name == "alphabet_size"
-        && normalize_type_name(concrete_type) == "usize"
-    {
-        let raw = args
-            .strings
-            .as_deref()
-            .ok_or_else(|| anyhow::anyhow!("LongestCommonSubsequence requires --strings"))?;
-        let (_, inferred_alphabet_size) = parse_lcs_strings(raw)?;
-        return Ok(Some(serde_json::json!(args
-            .alphabet_size
-            .unwrap_or(inferred_alphabet_size))));
-    }
-
-    if canonical == "LongestCommonSubsequence"
-        && field_name == "max_length"
-        && normalize_type_name(concrete_type) == "usize"
-    {
-        let strings: Vec<Vec<usize>> =
-            serde_json::from_value(context.parsed_fields.get("strings").cloned().ok_or_else(
-                || anyhow::anyhow!("LCS max_length derivation requires parsed strings"),
-            )?)?;
-        let max_length = strings.iter().map(Vec::len).min().unwrap_or(0);
-        return Ok(Some(serde_json::json!(max_length)));
-    }
-
-    if canonical == "QUBO"
-        && field_name == "num_vars"
-        && normalize_type_name(concrete_type) == "usize"
-    {
-        let matrix = parse_matrix(args)?;
-        return Ok(Some(serde_json::json!(matrix.len())));
-    }
-
-    if canonical == "StringToStringCorrection"
-        && field_name == "alphabet_size"
-        && normalize_type_name(concrete_type) == "usize"
-    {
-        let source = parse_symbol_list_allow_empty(args.source_string.as_deref().unwrap_or(""))?;
-        let target = parse_symbol_list_allow_empty(args.target_string.as_deref().unwrap_or(""))?;
-        let inferred = source
-            .iter()
-            .chain(target.iter())
-            .copied()
-            .max()
-            .map_or(0, |value| value + 1);
-        return Ok(Some(serde_json::json!(args
-            .alphabet_size
-            .unwrap_or(inferred))));
-    }
-
-    if field_name == "precedences"
-        && normalize_type_name(concrete_type) == "Vec<(usize,usize)>"
-        && args.precedences.is_none()
-        && args.precedence_pairs.is_none()
-    {
-        return Ok(Some(serde_json::json!([])));
-    }
-
-    if canonical == "ComparativeContainment"
-        && matches!(field_name, "r_weights" | "s_weights")
-        && matches!(
-            normalize_type_name(concrete_type).as_str(),
-            "Vec<One>" | "Vec<i32>" | "Vec<f64>"
-        )
-    {
-        let sets_len = context
-            .parsed_fields
-            .get(match field_name {
-                "r_weights" => "r_sets",
-                _ => "s_sets",
-            })
-            .and_then(serde_json::Value::as_array)
-            .map(Vec::len);
-        if let Some(len) = sets_len {
-            let value = match normalize_type_name(concrete_type).as_str() {
-                "Vec<One>" | "Vec<i32>" => serde_json::json!(vec![1_i32; len]),
-                "Vec<f64>" => serde_json::json!(vec![1.0_f64; len]),
-                _ => unreachable!(),
-            };
-            return Ok(Some(value));
-        }
-    }
-
-    if canonical == "ConsistencyOfDatabaseFrequencyTables"
-        && field_name == "known_values"
-        && normalize_type_name(concrete_type) == "Vec<KnownValue>"
-        && args.known_values.is_none()
-    {
-        return Ok(Some(serde_json::json!([])));
-    }
-
-    if canonical == "LengthBoundedDisjointPaths"
-        && field_name == "max_paths"
-        && normalize_type_name(concrete_type) == "usize"
-    {
-        let graph_value = context.parsed_fields.get("graph").cloned();
-        let source = context.usize_field("source");
-        let sink = context.usize_field("sink");
-        if let (Some(graph_value), Some(source), Some(sink)) = (graph_value, source, sink) {
-            let graph: SimpleGraph =
-                serde_json::from_value(graph_value).context("Failed to deserialize graph")?;
-            let max_paths = graph
-                .neighbors(source)
-                .len()
-                .min(graph.neighbors(sink).len());
-            return Ok(Some(serde_json::json!(max_paths)));
-        }
-    }
-
-    Ok(None)
-}
-
-pub(super) fn derive_schema_default_value(
-    canonical: &str,
-    field_name: &str,
-    concrete_type: &str,
-    context: &CreateContext,
-) -> Result<Option<serde_json::Value>> {
-    let normalized = normalize_type_name(concrete_type);
-
-    let one_list = |len: usize| match normalized.as_str() {
-        "Vec<One>" | "Vec<i32>" => Some(serde_json::json!(vec![1_i32; len])),
-        "Vec<u64>" => Some(serde_json::json!(vec![1_u64; len])),
-        "Vec<i64>" => Some(serde_json::json!(vec![1_i64; len])),
-        "Vec<usize>" => Some(serde_json::json!(vec![1_usize; len])),
-        "Vec<f64>" => Some(serde_json::json!(vec![1.0_f64; len])),
-        _ => None,
-    };
-
-    let derived = match field_name {
-        "weights" | "vertex_weights" => context.num_vertices.and_then(one_list),
-        "edge_weights" | "edge_lengths" => context.num_edges.and_then(one_list),
-        "arc_weights" | "arc_lengths" if context.num_arcs.is_some() => {
-            context.num_arcs.and_then(one_list)
-        }
-        "capacities" if canonical == "PathConstrainedNetworkFlow" => {
-            context.num_arcs.and_then(one_list)
-        }
-        "couplings" if canonical == "SpinGlass" => context.num_edges.and_then(one_list),
-        "fields" if canonical == "SpinGlass" => match normalized.as_str() {
-            "Vec<i32>" => context
-                .num_vertices
-                .map(|len| serde_json::json!(vec![0_i32; len])),
-            "Vec<f64>" => context
-                .num_vertices
-                .map(|len| serde_json::json!(vec![0.0_f64; len])),
-            _ => None,
-        },
-        _ => None,
-    };
-
-    Ok(derived)
-}
-
-pub(super) fn schema_field_requires_derived_input(field_name: &str, concrete_type: &str) -> bool {
-    field_name == "graph" && matches!(concrete_type, "MixedGraph" | "BipartiteGraph")
-}
-
 pub(super) fn with_schema_usage(
     error: anyhow::Error,
     canonical: &str,
@@ -747,11 +464,38 @@ pub(super) fn with_schema_usage(
     if message.contains("Usage: pred create") {
         return error;
     }
-    let graph_type = resolved_variant.get("graph").map(String::as_str);
-    anyhow::anyhow!(
-        "{message}\n\nUsage: pred create {canonical} {}",
-        example_for(canonical, graph_type)
-    )
+    let flags = create_inputs_for(canonical, resolved_variant)
+        .into_iter()
+        .map(|input| {
+            if input.kind == InputValueKind::Bool {
+                format!("[--{}]", input.name)
+            } else {
+                format!("--{} <VALUE>", input.name)
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(" ");
+    anyhow::anyhow!("{message}\n\nUsage: pred create {canonical} {flags}",)
+}
+
+pub(super) fn with_registered_usage(
+    error: anyhow::Error,
+    canonical: &str,
+    inputs: &[problemreductions::registry::CreateInputInfo],
+) -> anyhow::Error {
+    let flags = inputs
+        .iter()
+        .map(|input| {
+            let flag = format!("--{} <VALUE>", input.name.replace('_', "-"));
+            if input.required {
+                flag
+            } else {
+                format!("[{flag}]")
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(" ");
+    anyhow::anyhow!("{error}\n\nUsage: pred create {canonical} {flags}")
 }
 
 pub(super) fn parse_field_value(
@@ -768,40 +512,34 @@ pub(super) fn parse_field_value(
         "KingsSubgraph" => parse_grid_subgraph_value(raw, true)?,
         "TriangularSubgraph" => parse_grid_subgraph_value(raw, false)?,
         "UnitDiskGraph" => parse_unit_disk_graph_value(raw, context)?,
-        "Vec<i32>" => parse_numeric_list_value::<i32>(raw)?,
-        "Vec<f64>" => parse_numeric_list_value::<f64>(raw)?,
-        "Vec<u64>" => parse_numeric_list_value::<u64>(raw)?,
         "Vec<i64>" => parse_numeric_list_value::<i64>(raw)?,
+        "Vec<f64>" => parse_numeric_list_value::<f64>(raw)?,
         "Vec<usize>" => parse_numeric_list_value::<usize>(raw)?,
-        "Vec<One>" => parse_numeric_list_value::<i32>(raw)?,
+        "Vec<One>" => parse_numeric_list_value::<i64>(raw)?,
         "Vec<bool>" => parse_bool_list_value(raw)?,
         "Vec<Vec<usize>>" => parse_nested_numeric_list_value::<usize>(raw)?,
-        "Vec<Vec<u64>>" => parse_nested_numeric_list_value::<u64>(raw)?,
-        "Vec<Vec<i32>>" => parse_nested_numeric_list_value::<i32>(raw)?,
         "Vec<Vec<i64>>" => parse_nested_numeric_list_value::<i64>(raw)?,
         "Vec<Vec<f64>>" => parse_nested_numeric_list_value::<f64>(raw)?,
-        "Vec<Vec<One>>" => parse_nested_numeric_list_value::<i32>(raw)?,
+        "Vec<Vec<One>>" => parse_nested_numeric_list_value::<i64>(raw)?,
         "Vec<Vec<bool>>" => parse_bool_rows_value(raw, field_name)?,
         "Vec<Vec<Vec<usize>>>" => parse_3d_numeric_list_value::<usize>(raw)?,
         "Vec<Vec<Vec<i64>>>" => parse_3d_numeric_list_value::<i64>(raw)?,
         "Vec<[usize;3]>" => parse_triple_array_list_value(raw)?,
         "Vec<CNFClause>" => serde_json::to_value(parse_clauses_raw(raw)?)?,
         "Vec<(usize,usize)>" => parse_pair_list_value(raw)?,
-        "Vec<(u64,u64)>" => parse_semicolon_tuple_list_value::<u64, 2>(raw)?,
         "Vec<(usize,f64)>" => parse_indexed_numeric_pairs_value::<f64>(raw)?,
         "Vec<(usize,usize,usize)>" => parse_semicolon_tuple_list_value::<usize, 3>(raw)?,
         "Vec<(usize,usize,usize,usize)>" => parse_semicolon_tuple_list_value::<usize, 4>(raw)?,
-        "Vec<(usize,usize,One)>" => parse_weighted_edge_list_value::<i32>(raw)?,
-        "Vec<(usize,usize,i32)>" => parse_weighted_edge_list_value::<i32>(raw)?,
+        "Vec<(usize,usize,One)>" => parse_weighted_edge_list_value::<i64>(raw)?,
         "Vec<(usize,usize,i64)>" => parse_weighted_edge_list_value::<i64>(raw)?,
-        "Vec<(usize,usize,u64)>" => parse_weighted_edge_list_value::<u64>(raw)?,
         "Vec<(usize,usize,f64)>" => parse_weighted_edge_list_value::<f64>(raw)?,
         "Vec<(Vec<usize>,Vec<usize>)>" => serde_json::to_value(parse_dependencies(raw)?)?,
         "Vec<(Vec<usize>,usize)>" => serde_json::to_value(parse_implications(raw)?)?,
         "Vec<(usize,Vec<QueryArg>)>" => serde_json::to_value(parse_cbq_conjuncts(raw, context)?)?,
         "Vec<(usize,Vec<usize>)>" => parse_indexed_usize_lists_value(raw)?,
-        "Vec<Vec<(usize,u64)>>" => serde_json::to_value(parse_job_shop_jobs(raw)?)?,
+        "Vec<Vec<(usize,i64)>>" => serde_json::to_value(parse_job_shop_jobs(raw)?)?,
         "Vec<(f64,f64)>" => serde_json::to_value(util::parse_positions::<f64>(raw, "0.0,0.0")?)?,
+        "Vec<(i64,i64)>" => serde_json::to_value(util::parse_positions::<i64>(raw, "0,0")?)?,
         "(f64,f64)" => parse_f64_pair_value(raw)?,
         "Vec<Vec<(usize,usize)>>" => parse_nested_pair_list_value(raw)?,
         "Vec<FrequencyTable>" => {
@@ -810,7 +548,6 @@ pub(super) fn parse_field_value(
         "Vec<KnownValue>" => serde_json::to_value(parse_cdft_known_values_value(raw, context)?)?,
         "Vec<Relation>" => serde_json::to_value(parse_cbq_relations(raw, context)?)?,
         "Vec<String>" => parse_string_list_value(raw)?,
-        "Vec<VarBounds>" => parse_cvp_bounds_value(Some(raw), context)?,
         "Vec<BigUint>" => parse_biguint_list_value(raw)?,
         "BigUint" => parse_biguint_value(raw)?,
         "Vec<Option<bool>>" => parse_optional_bool_list_value(raw)?,
@@ -819,8 +556,6 @@ pub(super) fn parse_field_value(
         "bool" => serde_json::to_value(parse_bool_token(raw.trim())?)?,
         "One" => serde_json::json!(1),
         "usize" => parse_scalar_value::<usize>(raw)?,
-        "u64" => parse_scalar_value::<u64>(raw)?,
-        "i32" => parse_scalar_value::<i32>(raw)?,
         "i64" => parse_scalar_value::<i64>(raw)?,
         "f64" => parse_scalar_value::<f64>(raw)?,
         other => bail!("Unsupported schema parser for field '{field_name}' with type '{other}'"),
@@ -914,10 +649,10 @@ pub(super) fn parse_triple_array_list_value(raw: &str) -> Result<serde_json::Val
 pub(super) fn parse_clauses_raw(raw: &str) -> Result<Vec<CNFClause>> {
     raw.split(';')
         .map(|clause| {
-            let literals: Vec<i32> = clause
+            let literals: Vec<i64> = clause
                 .trim()
                 .split(',')
-                .map(|value| value.trim().parse::<i32>())
+                .map(|value| value.trim().parse::<i64>())
                 .collect::<std::result::Result<Vec<_>, _>>()?;
             Ok(CNFClause::new(literals))
         })
@@ -993,31 +728,6 @@ pub(super) fn parse_nested_pair_list_value(raw: &str) -> Result<serde_json::Valu
     Ok(serde_json::to_value(groups)?)
 }
 
-pub(super) fn infer_cbq_num_variables(raw: &str) -> Result<usize> {
-    let mut num_vars = 0usize;
-    for conjunct in raw.split(';').filter(|entry| !entry.trim().is_empty()) {
-        let (_, args_str) = conjunct.trim().split_once(':').ok_or_else(|| {
-            anyhow::anyhow!(
-                "Invalid conjunct format: expected 'rel_idx:args', got '{}'",
-                conjunct.trim()
-            )
-        })?;
-        for arg in args_str
-            .split(',')
-            .map(str::trim)
-            .filter(|arg| !arg.is_empty())
-        {
-            if let Some(rest) = arg.strip_prefix('v') {
-                let index: usize = rest
-                    .parse()
-                    .map_err(|err| anyhow::anyhow!("Invalid variable index '{rest}': {err}"))?;
-                num_vars = num_vars.max(index + 1);
-            }
-        }
-    }
-    Ok(num_vars)
-}
-
 pub(super) fn parse_cbq_relations(raw: &str, context: &CreateContext) -> Result<Vec<CbqRelation>> {
     let domain_size = context.usize_field("domain_size").ok_or_else(|| {
         anyhow::anyhow!("CBQ relation parsing requires a prior domain_size field")
@@ -1245,91 +955,6 @@ pub(super) fn parse_string_list_value(raw: &str) -> Result<serde_json::Value> {
     Ok(serde_json::to_value(values)?)
 }
 
-pub(super) fn parse_symbol_list_allow_empty(raw: &str) -> Result<Vec<usize>> {
-    let raw = raw.trim();
-    if raw.is_empty() {
-        return Ok(Vec::new());
-    }
-    raw.split(',')
-        .map(|value| {
-            value
-                .trim()
-                .parse::<usize>()
-                .context("invalid symbol index")
-        })
-        .collect()
-}
-
-pub(super) fn parse_lcs_strings(raw: &str) -> Result<(Vec<Vec<usize>>, usize)> {
-    let segments: Vec<&str> = raw.split(';').map(str::trim).collect();
-    let comma_mode = segments.iter().any(|segment| segment.contains(','));
-
-    if comma_mode {
-        let strings = segments
-            .iter()
-            .map(|segment| parse_symbol_list_allow_empty(segment))
-            .collect::<Result<Vec<_>>>()?;
-        let inferred_alphabet_size = strings
-            .iter()
-            .flat_map(|string| string.iter())
-            .copied()
-            .max()
-            .map(|value| value + 1)
-            .unwrap_or(0);
-        return Ok((strings, inferred_alphabet_size));
-    }
-
-    let mut encoding = BTreeMap::new();
-    let mut next_symbol = 0usize;
-    let strings = segments
-        .iter()
-        .map(|segment| {
-            segment
-                .as_bytes()
-                .iter()
-                .map(|byte| {
-                    let entry = encoding.entry(*byte).or_insert_with(|| {
-                        let current = next_symbol;
-                        next_symbol += 1;
-                        current
-                    });
-                    *entry
-                })
-                .collect::<Vec<_>>()
-        })
-        .collect::<Vec<_>>();
-    Ok((strings, next_symbol))
-}
-
-pub(super) fn parse_bcnf_functional_deps(
-    raw: &str,
-    num_attributes: usize,
-) -> Result<Vec<(Vec<usize>, Vec<usize>)>> {
-    raw.split(';')
-        .map(|fd_str| {
-            let parts: Vec<&str> = fd_str.split(':').collect();
-            anyhow::ensure!(
-                parts.len() == 2,
-                "Each FD must be lhs:rhs, got '{}'",
-                fd_str
-            );
-            let lhs: Vec<usize> = util::parse_comma_list(parts[0])?;
-            let rhs: Vec<usize> = util::parse_comma_list(parts[1])?;
-            ensure_attribute_indices_in_range(
-                &lhs,
-                num_attributes,
-                &format!("Functional dependency '{fd_str}' lhs"),
-            )?;
-            ensure_attribute_indices_in_range(
-                &rhs,
-                num_attributes,
-                &format!("Functional dependency '{fd_str}' rhs"),
-            )?;
-            Ok((lhs, rhs))
-        })
-        .collect()
-}
-
 pub(super) fn parse_cdft_frequency_tables_value(
     raw: &str,
     context: &CreateContext,
@@ -1372,33 +997,6 @@ pub(super) fn parse_cdft_known_values_value(
     parse_cdft_known_values(Some(raw), num_objects, &attribute_domains)
 }
 
-pub(super) fn parse_cvp_bounds_value(
-    raw: Option<&str>,
-    context: &CreateContext,
-) -> Result<serde_json::Value> {
-    let basis_len = context
-        .parsed_fields
-        .get("basis")
-        .and_then(serde_json::Value::as_array)
-        .map(Vec::len)
-        .ok_or_else(|| anyhow::anyhow!("CVP bounds parsing requires a prior basis field"))?;
-
-    let (lower, upper) = match raw {
-        Some(raw) => {
-            let parts: Vec<i64> = util::parse_comma_list(raw)?;
-            anyhow::ensure!(
-                parts.len() == 2,
-                "--bounds expects \"lower,upper\" (e.g., \"-10,10\")"
-            );
-            (parts[0], parts[1])
-        }
-        None => (-10, 10),
-    };
-    let bounds =
-        vec![problemreductions::models::algebraic::VarBounds::bounded(lower, upper); basis_len];
-    Ok(serde_json::to_value(bounds)?)
-}
-
 pub(super) fn parse_biguint_list_value(raw: &str) -> Result<serde_json::Value> {
     let values: Vec<String> = util::parse_biguint_list(raw)?
         .into_iter()
@@ -1536,7 +1134,7 @@ pub(super) fn parse_labelled_digraph_value(
             let src: usize = parts[0].trim().parse().map_err(|err| {
                 anyhow::anyhow!("{flag}: invalid arc source '{}': {err}", parts[0].trim())
             })?;
-            let label: u32 = parts[1].trim().parse().map_err(|err| {
+            let label: usize = parts[1].trim().parse().map_err(|err| {
                 anyhow::anyhow!("{flag}: invalid arc label '{}': {err}", parts[1].trim())
             })?;
             let dst: usize = parts[2].trim().parse().map_err(|err| {
@@ -1561,7 +1159,7 @@ pub(super) fn parse_labelled_digraph_value(
 }
 
 pub(super) fn parse_grid_subgraph_value(raw: &str, kings: bool) -> Result<serde_json::Value> {
-    let positions = util::parse_positions::<i32>(raw, "0,0")?;
+    let positions = util::parse_positions::<i64>(raw, "0,0")?;
     if kings {
         Ok(serde_json::to_value(KingsSubgraph::new(positions))?)
     } else {
@@ -1577,1119 +1175,25 @@ pub(super) fn parse_unit_disk_graph_value(
     let radius = context
         .f64_field("radius")
         .ok_or_else(|| anyhow::anyhow!("UnitDiskGraph parsing requires a prior radius field"))?;
-    Ok(serde_json::to_value(UnitDiskGraph::new(positions, radius))?)
-}
-
-pub(super) fn type_format_hint(type_name: &str, graph_type: Option<&str>) -> &'static str {
-    match type_name {
-        "SimpleGraph" => "edge list: 0-1,1-2,2-3",
-        "G" => match graph_type {
-            Some("KingsSubgraph" | "TriangularSubgraph") => "integer positions: \"0,0;1,0;1,1\"",
-            Some("UnitDiskGraph") => "float positions: \"0.0,0.0;1.0,0.0\"",
-            _ => "edge list: 0-1,1-2,2-3",
-        },
-        "Vec<(Vec<usize>, Vec<usize>)>" => "semicolon-separated dependencies: \"0,1>2;0,2>3\"",
-        "Vec<u64>" => "comma-separated integers: 4,5,3,2,6",
-        "Vec<W>" => "comma-separated: 1,2,3",
-        "W" | "N" | "W::Sum" | "N::Sum" => "numeric value: 10",
-        "Vec<usize>" => "comma-separated indices: 0,2,4",
-        "Vec<(usize, usize, W)>" | "Vec<(usize,usize,W)>" => {
-            "comma-separated weighted edges: 0-2:3,1-3:5"
-        }
-        "Vec<Vec<usize>>" => "semicolon-separated sets: \"0,1;1,2;0,2\"",
-        "Vec<CNFClause>" => "semicolon-separated clauses: \"1,2;-1,3\"",
-        "Vec<Vec<bool>>" => "JSON 2D bool array: '[[true,false],[false,true]]'",
-        "Vec<Vec<W>>" => "semicolon-separated rows: \"1,0.5;0.5,2\"",
-        "usize" => "integer",
-        "u64" => "integer",
-        "i64" => "integer",
-        "BigUint" => "nonnegative decimal integer",
-        "Vec<BigUint>" => "comma-separated nonnegative decimal integers: 3,7,1,8",
-        "Vec<i64>" => "comma-separated integers: 3,7,1,8",
-        "DirectedGraph" => "directed arcs: 0>1,1>2,2>0",
-        "LabelledDigraph" => {
-            "labelled digraph \"<num_vertices>:<src>-<label>-<dst>,...\": 5:0-0-1,1-1-2,0-2-2"
-        }
-        _ => "value",
-    }
-}
-
-pub(super) fn example_for(canonical: &str, graph_type: Option<&str>) -> &'static str {
-    match canonical {
-        "MaximumIndependentSet"
-        | "MinimumVertexCover"
-        | "MaximumClique"
-        | "MinimumDominatingSet" => match graph_type {
-            Some("KingsSubgraph") => "--positions \"0,0;1,0;1,1;0,1\"",
-            Some("TriangularSubgraph") => "--positions \"0,0;0,1;1,0;1,1\"",
-            Some("UnitDiskGraph") => "--positions \"0,0;1,0;0.5,0.8\" --radius 1.5",
-            _ => "--graph 0-1,1-2,2-3 --weights 1,1,1,1",
-        },
-        "DecisionMinimumVertexCover" => match graph_type {
-            Some("KingsSubgraph") => {
-                "--positions \"0,0;1,0;1,1;0,1\" --weights 1,1,1,1 --bound 2"
-            }
-            Some("TriangularSubgraph") => {
-                "--positions \"0,0;0,1;1,0;1,1\" --weights 1,1,1,1 --bound 2"
-            }
-            Some("UnitDiskGraph") => {
-                "--positions \"0,0;1,0;0.5,0.8\" --radius 1.5 --weights 1,1,1 --bound 2"
-            }
-            _ => "--graph 0-1,1-2,0-2,2-3 --weights 1,1,1,1 --bound 2",
-        },
-        "KClique" => "--graph 0-1,0-2,1-3,2-3,2-4,3-4 --k 3",
-        "GeneralizedHex" => "--graph 0-1,0-2,0-3,1-4,2-4,3-4,4-5 --source 0 --sink 5",
-        "IntegralFlowBundles" => {
-            "--arcs \"0>1,0>2,1>3,2>3,1>2,2>1\" --bundles \"0,1;2,5;3,4\" --bundle-capacities 1,1,1 --source 0 --sink 3 --requirement 1 --num-vertices 4"
-        }
-        "IntegralFlowWithMultipliers" => {
-            "--arcs \"0>1,0>2,1>3,2>3\" --capacities 1,1,2,2 --source 0 --sink 3 --multipliers 1,2,3,1 --requirement 2"
-        }
-        "MinimumCutIntoBoundedSets" => {
-            "--graph 0-1,1-2,2-3 --edge-weights 1,1,1 --source 0 --sink 3 --size-bound 3"
-        }
-        "BoundedComponentSpanningForest" => {
-            "--graph 0-1,1-2,2-3,3-4,4-5,5-6,6-7,0-7,1-5,2-6 --weights 2,3,1,2,3,1,2,1 --k 3 --max-weight 6"
-        }
-        "HamiltonianPath" => "--graph 0-1,1-2,2-3",
-        "HamiltonianPathBetweenTwoVertices" => {
-            "--graph 0-1,0-3,1-2,1-4,2-5,3-4,4-5,2-3 --source-vertex 0 --target-vertex 5"
-        }
-        "GraphPartitioning" => "--graph 0-1,1-2,2-3,3-0 --num-partitions 2",
-        "LongestPath" => {
-            "--graph 0-1,0-2,1-3,2-3,2-4,3-5,4-5,4-6,5-6,1-6 --edge-lengths 3,2,4,1,5,2,3,2,4,1 --source-vertex 0 --target-vertex 6"
-        }
-        "UndirectedFlowLowerBounds" => {
-            "--graph 0-1,0-2,1-3,2-3,1-4,3-5,4-5 --capacities 2,2,2,2,1,3,2 --lower-bounds 1,1,0,0,1,0,1 --source 0 --sink 5 --requirement 3"
-        }
-        "UndirectedTwoCommodityIntegralFlow" => {
-            "--graph 0-2,1-2,2-3 --capacities 1,1,2 --source-1 0 --sink-1 3 --source-2 1 --sink-2 3 --requirement-1 1 --requirement-2 1"
-        },
-        "DisjointConnectingPaths" => {
-            "--graph 0-1,1-3,0-2,1-4,2-4,3-5,4-5 --terminal-pairs 0-3,2-5"
-        }
-        "IntegralFlowHomologousArcs" => {
-            "--arcs \"0>1,0>2,1>3,2>3,1>4,2>4,3>5,4>5\" --capacities 1,1,1,1,1,1,1,1 --source 0 --sink 5 --requirement 2 --homologous-pairs \"2=5;4=3\""
-        }
-        "LengthBoundedDisjointPaths" => {
-            "--graph 0-1,1-6,0-2,2-3,3-6,0-4,4-5,5-6 --source 0 --sink 6 --max-length 4"
-        }
-        "PathConstrainedNetworkFlow" => {
-            "--arcs \"0>1,0>2,1>3,1>4,2>4,3>5,4>5,4>6,5>7,6>7\" --capacities 2,1,1,1,1,1,1,1,2,1 --source 0 --sink 7 --paths \"0,2,5,8;0,3,6,8;0,3,7,9;1,4,6,8;1,4,7,9\" --requirement 3"
-        }
-        "IsomorphicSpanningTree" => "--graph 0-1,1-2,0-2 --tree 0-1,1-2",
-        "BoundedDiameterSpanningTree" => {
-            "--graph 0-1,0-2,0-3,1-2,1-4,2-3,3-4 --edge-weights 1,2,1,1,2,1,1 --weight-bound 5 --diameter-bound 3"
-        }
-        "KthBestSpanningTree" => "--graph 0-1,0-2,1-2 --edge-weights 2,3,1 --k 1 --bound 3",
-        "LongestCircuit" => {
-            "--graph 0-1,1-2,2-3,3-4,4-5,5-0,0-3,1-4,2-5,3-5 --edge-weights 3,2,4,1,5,2,3,2,1,2"
-        }
-        "BottleneckTravelingSalesman" | "MaxCut" | "MaximumMatching" | "TravelingSalesman" => {
-            "--graph 0-1,1-2,2-3 --edge-weights 1,1,1"
-        }
-        "ShortestWeightConstrainedPath" => {
-            "--graph 0-1,0-2,1-3,2-3,2-4,3-5,4-5,1-4 --edge-lengths 2,4,3,1,5,4,2,6 --edge-weights 5,1,2,3,2,3,1,1 --source-vertex 0 --target-vertex 5 --weight-bound 8"
-        }
-        "SteinerTreeInGraphs" => "--graph 0-1,1-2,2-3 --edge-weights 1,1,1 --terminals 0,3",
-        "BiconnectivityAugmentation" => {
-            "--graph 0-1,1-2,2-3 --potential-weights 0-2:3,0-3:4,1-3:2 --budget 5"
-        }
-        "PartialFeedbackEdgeSet" => {
-            "--graph 0-1,1-2,2-0,2-3,3-4,4-2,3-5,5-4,0-3 --budget 3 --max-cycle-length 4"
-        }
-        "Satisfiability" => "--num-vars 3 --clauses \"1,2;-1,3\"",
-        "NAESatisfiability" => "--num-vars 3 --clauses \"1,2,-3;-1,2,3\"",
-        "QuantifiedBooleanFormulas" => {
-            "--num-vars 3 --clauses \"1,2;-1,3\" --quantifiers \"E,A,E\""
-        }
-        "KSatisfiability" => "--num-vars 3 --clauses \"1,2,3;-1,2,-3\" --k 3",
-        "Maximum2Satisfiability" => "--num-vars 4 --clauses \"1,2;1,-2;-1,3;-1,-3;2,4;-3,-4;3,4\"",
-        "NonTautology" => {
-            "--num-vars 3 --disjuncts \"1,2,3;-1,-2,-3\""
-        }
-        "OneInThreeSatisfiability" => {
-            "--num-vars 4 --clauses \"1,2,3;-1,3,4;2,-3,-4\""
-        }
-        "Planar3Satisfiability" => {
-            "--num-vars 4 --clauses \"1,2,3;-1,2,4;1,-3,4;-2,3,-4\""
-        }
-        "QUBO" => "--matrix \"1,0.5;0.5,2\"",
-        "QuadraticAssignment" => "--matrix \"0,5;5,0\" --distance-matrix \"0,1;1,0\"",
-        "SpinGlass" => "--graph 0-1,1-2 --couplings 1,1",
-        "KColoring" => "--graph 0-1,1-2,2-0 --k 3",
-        "HamiltonianCircuit" => "--graph 0-1,1-2,2-3,3-0",
-        "MaximumLeafSpanningTree" => "--graph 0-1,0-2,0-3,1-4,2-4,2-5,3-5,4-5,1-3",
-        "EnsembleComputation" => "--universe-size 4 --subsets \"0,1,2;0,1,3\"",
-        "RootedTreeStorageAssignment" => {
-            "--universe-size 5 --subsets \"0,2;1,3;0,4;2,4\" --bound 1"
-        }
-        "MinMaxMulticenter" => {
-            "--graph 0-1,1-2,2-3 --weights 1,1,1,1 --edge-weights 1,1,1 --k 2"
-        }
-        "MinimumSumMulticenter" => {
-            "--graph 0-1,1-2,2-3 --weights 1,1,1,1 --edge-weights 1,1,1 --k 2"
-        }
-        "BalancedCompleteBipartiteSubgraph" => {
-            "--left 4 --right 4 --biedges 0-0,0-1,0-2,1-0,1-1,1-2,2-0,2-1,2-2,3-0,3-1,3-3 --k 3"
-        }
-        "MaximumAchromaticNumber" => "--graph 0-1,1-2,2-3,3-4,4-5,5-0",
-        "MaximumDomaticNumber" => "--graph 0-1,1-2,0-2",
-        "MinimumCoveringByCliques" => "--graph 0-1,1-2,0-2,2-3",
-        "MinimumIntersectionGraphBasis" => "--graph 0-1,1-2",
-        "MinimumMaximalMatching" => "--graph 0-1,1-2,2-3,3-4,4-5",
-        "DegreeConstrainedSpanningTree" => "--graph 0-1,0-2,0-3,1-2,1-4,2-3,3-4 --k 2",
-        "MonochromaticTriangle" => "--graph 0-1,0-2,0-3,1-2,1-3,2-3",
-        "PartitionIntoTriangles" => "--graph 0-1,1-2,0-2",
-        "PartitionIntoCliques" => "--graph 0-1,0-2,1-2,3-4,3-5,4-5 --k 3",
-        "PartitionIntoForests" => "--graph 0-1,1-2,2-0,3-4,4-5,5-3 --k 2",
-        "PartitionIntoPerfectMatchings" => "--graph 0-1,2-3,0-2,1-3 --k 2",
-        "Factoring" => "--target 15 --m 4 --n 4",
-        "CapacityAssignment" => {
-            "--capacities 1,2,3 --cost-matrix \"1,3,6;2,4,7;1,2,5\" --delay-matrix \"8,4,1;7,3,1;6,3,1\" --delay-budget 12"
-        }
-        "ProductionPlanning" => {
-            "--num-periods 6 --demands 5,3,7,2,8,5 --capacities 12,12,12,12,12,12 --setup-costs 10,10,10,10,10,10 --production-costs 1,1,1,1,1,1 --inventory-costs 1,1,1,1,1,1 --cost-bound 80"
-        }
-        "MultiprocessorScheduling" => "--lengths 4,5,3,2,6 --num-processors 2 --deadline 10",
-        "PreemptiveScheduling" => {
-            "--lengths 2,1,3,2,1 --num-processors 2 --precedences \"0>2,1>3\""
-        }
-        "SchedulingToMinimizeWeightedCompletionTime" => {
-            "--lengths 1,2,3,4,5 --weights 6,4,3,2,1 --num-processors 2"
-        }
-        "JobShopScheduling" => {
-            "--jobs \"0:3,1:4;1:2,0:3,1:2;0:4,1:3;1:5,0:2;0:2,1:3,0:1\" --num-processors 2"
-        }
-        "MinimumMultiwayCut" => "--graph 0-1,1-2,2-3 --terminals 0,2 --edge-weights 1,1,1",
-        "ExpectedRetrievalCost" => EXPECTED_RETRIEVAL_COST_EXAMPLE_ARGS,
-        "SequencingWithinIntervals" => "--release-times 0,0,5 --deadlines 11,11,6 --lengths 3,1,1",
-        "StaffScheduling" => {
-            "--schedules \"1,1,1,1,1,0,0;0,1,1,1,1,1,0;0,0,1,1,1,1,1;1,0,0,1,1,1,1;1,1,0,0,1,1,1\" --requirements 2,2,2,3,3,2,1 --num-workers 4 --k 5"
-        }
-        "TimetableDesign" => {
-            "--num-periods 3 --num-craftsmen 5 --num-tasks 5 --craftsman-avail \"1,1,1;1,1,0;0,1,1;1,0,1;1,1,1\" --task-avail \"1,1,0;0,1,1;1,0,1;1,1,1;1,1,1\" --requirements \"1,0,1,0,0;0,1,0,0,1;0,0,0,1,0;0,0,0,0,1;0,1,0,0,0\""
-        }
-        "SteinerTree" => "--graph 0-1,1-2,1-3,3-4 --edge-weights 2,2,1,1 --terminals 0,2,4",
-        "MultipleCopyFileAllocation" => {
-            MULTIPLE_COPY_FILE_ALLOCATION_EXAMPLE_ARGS
-        }
-        "AcyclicPartition" => {
-            "--arcs \"0>1,0>2,1>3,1>4,2>4,2>5,3>5,4>5\" --weights 2,3,2,1,3,1 --arc-weights 1,1,1,1,1,1,1,1 --weight-bound 5 --cost-bound 5"
-        }
-        "OptimalLinearArrangement" => "--graph 0-1,1-2,2-3",
-        "RootedTreeArrangement" => "--graph 0-1,0-2,1-2,2-3,3-4 --bound 7",
-        "DirectedTwoCommodityIntegralFlow" => {
-            "--arcs \"0>2,0>3,1>2,1>3,2>4,2>5,3>4,3>5\" --capacities 1,1,1,1,1,1,1,1 --source-1 0 --sink-1 4 --source-2 1 --sink-2 5 --requirement-1 1 --requirement-2 1"
-        }
-        "MinimumEdgeCostFlow" => {
-            "--arcs \"0>1,0>2,0>3,1>4,2>4,3>4\" --edge-weights 3,1,2,0,0,0 --capacities 2,2,2,2,2,2 --source 0 --sink 4 --requirement 3"
-        }
-        "MinimumCostMaximumFlow" => {
-            "--arcs \"0>1,0>2,1>2,1>3,2>3\" --capacities 2,1,1,1,2 --costs 1,0,0,1,2 --source 0 --sink 3"
-        }
-        "MinimumCostCirculation" => {
-            "--arcs \"0>1,1>0,0>2,2>0\" --capacities 2,2,1,1 --costs 2,-3,1,-4"
-        }
-        "MinimumFeedbackArcSet" => "--arcs \"0>1,1>2,2>0\"",
-        "DirectedHamiltonianPath" => {
-            "--arcs \"0>1,0>3,1>3,1>4,2>0,2>4,3>2,3>5,4>5,5>1\" --num-vertices 6"
-        }
-        "EulerianPath" => "--arcs \"0>1,0>1,1>2,2>0\" --num-vertices 3",
-        "Kernel" => "--arcs \"0>1,0>2,1>3,2>3,3>4,4>0,4>1\"",
-        "MinimumGeometricConnectedDominatingSet" => {
-            "--positions \"0,0;3,0;6,0;9,0;0,3;3,3;6,3;9,3\" --radius 3.5"
-        }
-        "MinimumDummyActivitiesPert" => "--arcs \"0>2,0>3,1>3,1>4,2>5\" --num-vertices 6",
-        "FeasibleRegisterAssignment" => {
-            "--arcs \"0>1,0>2,1>3\" --assignment 0,1,0,0 --k 2 --num-vertices 4"
-        }
-        "MinimumFaultDetectionTestSet" => {
-            "--arcs \"0>2,0>3,1>3,1>4,2>5,3>5,3>6,4>6\" --inputs 0,1 --outputs 5,6 --num-vertices 7"
-        }
-        "MinimumWeightAndOrGraph" => {
-            "--arcs \"0>1,0>2,1>3,1>4,2>5,2>6\" --source 0 --gate-types \"AND,OR,OR,L,L,L,L\" --weights 1,2,3,1,4,2 --num-vertices 7"
-        }
-        "MinimumRegisterSufficiencyForLoops" => {
-            "--loop-length 6 --loop-variables \"0,3;2,3;4,3\""
-        }
-        "RegisterSufficiency" => {
-            "--arcs \"2>0,2>1,3>1,4>2,4>3,5>0,6>4,6>5\" --bound 3 --num-vertices 7"
-        }
-        "StrongConnectivityAugmentation" => {
-            "--arcs \"0>1,1>2\" --candidate-arcs \"2>0:1\" --bound 1"
-        }
-        "MixedChinesePostman" => {
-            "--graph 0-2,1-3,0-4,4-2 --arcs \"0>1,1>2,2>3,3>0\" --edge-weights 2,3,1,2 --arc-weights 2,3,1,4"
-        }
-        "RuralPostman" => {
-            "--graph 0-1,1-2,2-3,3-0 --edge-weights 1,1,1,1 --required-edges 0,2"
-        }
-        "StackerCrane" => {
-            "--arcs \"0>4,2>5,5>1,3>0,4>3\" --graph \"0-1,1-2,2-3,3-5,4-5,0-3,1-5\" --arc-lengths 3,4,2,5,3 --edge-lengths 2,1,3,2,1,4,3 --num-vertices 6"
-        }
-        "MultipleChoiceBranching" => {
-            "--arcs \"0>1,0>2,1>3,2>3,1>4,3>5,4>5,2>4\" --weights 3,2,4,1,2,3,1,3 --partition \"0,1;2,3;4,7;5,6\" --threshold 10"
-        }
-        "AdditionalKey" => "--num-attributes 6 --dependencies \"0,1:2,3;2,3:4,5;4,5:0,1\" --relation-attrs 0,1,2,3,4,5 --known-keys \"0,1;2,3;4,5\"",
-        "ConsistencyOfDatabaseFrequencyTables" => {
-            "--num-objects 6 --attribute-domains \"2,3,2\" --frequency-tables \"0,1:1,1,1|1,1,1;1,2:1,1|0,2|1,1\" --known-values \"0,0,0;3,0,1;1,2,1\""
-        }
-        "SubgraphIsomorphism" => "--graph 0-1,1-2,2-0 --pattern 0-1",
-        "RectilinearPictureCompression" => {
-            "--matrix \"1,1,0,0;1,1,0,0;0,0,1,1;0,0,1,1\" --bound 2"
-        }
-        "SequencingToMinimizeWeightedTardiness" => {
-            "--lengths 3,4,2,5,3 --weights 2,3,1,4,2 --deadlines 5,8,4,15,10 --bound 13"
-        }
-        "IntegerKnapsack" => "--sizes 3,4,5,2,7 --values 4,5,7,3,9 --capacity 15",
-        "SubsetProduct" => "--sizes 2,3,5,7,6,10 --target 210",
-        "SubsetSum" => "--sizes 3,7,1,8,2,4 --target 11",
-        "MinimumAxiomSet" => {
-            "--n 8 --true-sentences 0,1,2,3,4,5,6,7 --implications \"0>2;0>3;1>4;1>5;2,4>6;3,5>7;6,7>0;6,7>1\""
-        }
-        "IntegerExpressionMembership" => {
-            "--expression '{\"Sum\":[{\"Sum\":[{\"Union\":[{\"Atom\":1},{\"Atom\":4}]},{\"Union\":[{\"Atom\":3},{\"Atom\":6}]}]},{\"Union\":[{\"Atom\":2},{\"Atom\":5}]}]}' --target 12"
-        }
-        "NonLivenessFreePetriNet" => {
-            "--n 4 --m 3 --arcs \"0>0,1>1,2>2\" --output-arcs \"0>1,1>2,2>3\" --initial-marking 1,0,0,0"
-        }
-        "Betweenness" => "--n 5 --sets \"0,1,2;2,3,4;0,2,4;1,3,4\"",
-        "CyclicOrdering" => "--n 5 --sets \"0,1,2;2,3,0;1,3,4\"",
-        "Numerical3DimensionalMatching" => "--w-sizes 4,5 --x-sizes 4,5 --y-sizes 5,7 --bound 15",
-        "ThreePartition" => "--sizes 4,5,6,4,6,5 --bound 15",
-        "DynamicStorageAllocation" => "--release-times 0,0,1,2,3 --deadlines 3,2,4,5,5 --sizes 2,3,1,3,2 --capacity 6",
-        "KthLargestMTuple" => "--sets \"2,5,8;3,6;1,4,7\" --k 14 --bound 12",
-        "AlgebraicEquationsOverGF2" => "--num-vars 3 --equations \"0,1:2;1,2:0:;0:1:2:\"",
-        "QuadraticCongruences" => "--coeff-a 4 --coeff-b 15 --coeff-c 10",
-        "QuadraticDiophantineEquations" => "--coeff-a 3 --coeff-b 5 --coeff-c 53",
-        "SimultaneousIncongruences" => "--pairs \"2,2;1,3;2,5;3,7\"",
-        "BoyceCoddNormalFormViolation" => {
-            "--n 6 --sets \"0,1:2;2:3;3,4:5\" --target 0,1,2,3,4,5"
-        }
-        "Clustering" => {
-            "--distance-matrix \"0,1,1,3;1,0,1,3;1,1,0,3;3,3,3,0\" --k 2 --diameter-bound 1"
-        }
-        "SumOfSquaresPartition" => "--sizes 5,3,8,2,7,1 --num-groups 3",
-        "ComparativeContainment" => {
-            "--universe-size 4 --r-sets \"0,1,2,3;0,1\" --s-sets \"0,1,2,3;2,3\" --r-weights 2,5 --s-weights 3,6"
-        }
-        "SetBasis" => "--universe-size 4 --subsets \"0,1;1,2;0,2;0,1,2\" --k 3",
-        "SetSplitting" => "--universe-size 6 --subsets \"0,1,2;2,3,4;0,4,5;1,3,5\"",
-        "LongestCommonSubsequence" => {
-            "--strings \"010110;100101;001011\" --alphabet-size 2"
-        }
-        "ClosestString" => {
-            "--alphabet-size 2 --strings \"0,0,0;0,1,1;1,0,1;1,1,0\""
-        }
-        "ClosestSubstring" => {
-            "--alphabet-size 2 --strings \"0,0,0,1,1;1,0,1,0,0;1,1,0,0,1\" --substring-length 3"
-        }
-        "GroupingBySwapping" => "--string \"0,1,2,0,1,2\" --bound 5",
-        "MinimumExternalMacroDataCompression" | "MinimumInternalMacroDataCompression" => {
-            "--string \"0,1,0,1\" --pointer-cost 2 --alphabet-size 2"
-        }
-        "MinimumCardinalityKey" => {
-            "--num-attributes 6 --dependencies \"0,1>2;0,2>3;1,3>4;2,4>5\""
-        }
-        "PrimeAttributeName" => {
-            "--universe 6 --dependencies \"0,1>2,3,4,5;2,3>0,1,4,5\" --query-attribute 3"
-        }
-        "TwoDimensionalConsecutiveSets" => {
-            "--alphabet-size 6 --subsets \"0,1,2;3,4,5;1,3;2,4;0,5\""
-        }
-        "ShortestCommonSupersequence" => "--strings \"0,1,2;1,2,0\"",
-        "ConsecutiveBlockMinimization" => "--matrix '[[true,false,true],[false,true,true]]' --bound-k 2",
-        "ConsecutiveOnesMatrixAugmentation" => {
-            "--matrix \"1,0,0,1,1;1,1,0,0,0;0,1,1,0,1;0,0,1,1,0\" --bound 2"
-        }
-        "SparseMatrixCompression" => "--matrix \"1,0,0,1;0,1,0,0;0,0,1,0;1,0,0,0\" --bound-k 2",
-        "MaximumLikelihoodRanking" => "--matrix \"0,4,3,5;1,0,4,3;2,1,0,4;0,2,1,0\"",
-        "MinimumMatrixCover" => "--matrix \"0,3,1,0;3,0,0,2;1,0,0,4;0,2,4,0\"",
-        "MinimumMatrixDomination" => "--matrix \"0,1,0;1,0,1;0,1,0\"",
-        "MinimumWeightDecoding" => {
-            "--matrix '[[true,false,true,true],[false,true,true,false],[true,true,false,true]]' --rhs 'true,true,false'"
-        }
-        "MinimumWeightSolutionToLinearEquations" => {
-            "--matrix '[[1,2,3,1],[2,1,1,3]]' --rhs '5,4'"
-        }
-        "ConjunctiveBooleanQuery" => {
-            "--domain-size 6 --relations \"2:0,3|1,3|2,4;3:0,1,5|1,2,5\" --conjuncts-spec \"0:v0,c3;0:v1,c3;1:v0,v1,c5\""
-        }
-        "ConjunctiveQueryFoldability" => "(use --example ConjunctiveQueryFoldability)",
-        "EquilibriumPoint" => "(use --example EquilibriumPoint)",
-        "SequencingToMinimizeMaximumCumulativeCost" => {
-            "--costs 2,-1,3,-2,1,-3 --precedence-pairs \"0>2,1>2,1>3,2>4,3>5,4>5\""
-        }
-        "StringToStringCorrection" => {
-            "--source-string \"0,1,2,3,1,0\" --target-string \"0,1,3,2,1\" --bound 2"
-        }
-        "FeasibleBasisExtension" => {
-            "--matrix '[[1,0,1,2,-1,0],[0,1,0,1,1,2],[0,0,1,1,0,1]]' --rhs '7,5,3' --required-columns '0,1'"
-        }
-        "MinimumCodeGenerationParallelAssignments" => {
-            "--num-variables 4 --assignments \"0:1,2;1:0;2:3;3:1,2\""
-        }
-        "MinimumDecisionTree" => {
-            "--test-matrix '[[true,true,false,false],[true,false,false,false],[false,true,false,true]]' --num-objects 4 --num-tests 3"
-        }
-        "MinimumDisjunctiveNormalForm" => {
-            "--num-vars 3 --truth-table 0,1,1,1,1,1,1,0"
-        }
-        "SquareTiling" => {
-            "--num-colors 3 --tiles \"0,1,2,0;0,0,2,1;2,1,0,0;2,0,0,1\" --grid-size 2"
-        }
-        _ => "",
-    }
+    Ok(serde_json::to_value(
+        UnitDiskGraph::new(positions, radius).map_err(anyhow::Error::msg)?,
+    )?)
 }
 
-pub(super) fn uses_edge_weights_flag(canonical: &str) -> bool {
-    matches!(
-        canonical,
-        "BottleneckTravelingSalesman"
-            | "BoundedDiameterSpanningTree"
-            | "KthBestSpanningTree"
-            | "LongestCircuit"
-            | "MaxCut"
-            | "MaximumMatching"
-            | "MixedChinesePostman"
-            | "RuralPostman"
-            | "TravelingSalesman"
-    )
-}
-
-pub(super) fn uses_edge_weights_flag_for_edge_lengths(canonical: &str) -> bool {
-    matches!(
-        canonical,
-        "LongestCircuit" | "MinMaxMulticenter" | "MinimumSumMulticenter"
-    )
-}
-
-pub(super) fn help_flag_name(canonical: &str, field_name: &str) -> String {
-    // Problem-specific overrides first
-    match (canonical, field_name) {
-        ("BoundedComponentSpanningForest", "max_components") => return "k".to_string(),
-        ("BoundedComponentSpanningForest", "max_weight") => return "max-weight".to_string(),
-        ("BoyceCoddNormalFormViolation", "num_attributes") => return "n".to_string(),
-        ("BoyceCoddNormalFormViolation", "functional_deps") => return "sets".to_string(),
-        ("BoyceCoddNormalFormViolation", "target_subset") => return "target".to_string(),
-        ("CapacityAssignment", "cost") => return "cost-matrix".to_string(),
-        ("CapacityAssignment", "delay") => return "delay-matrix".to_string(),
-        ("FlowShopScheduling", "num_processors")
-        | ("JobShopScheduling", "num_processors")
-        | ("OpenShopScheduling", "num_machines")
-        | ("SchedulingWithIndividualDeadlines", "num_processors") => {
-            return "num-processors/--m".to_string();
-        }
-        ("JobShopScheduling", "jobs") => return "jobs".to_string(),
-        ("LengthBoundedDisjointPaths", "max_length") => return "max-length".to_string(),
-        ("ConsecutiveBlockMinimization", "bound") => return "bound-k".to_string(),
-        ("GroupingBySwapping", "budget") => return "bound".to_string(),
-        ("RectilinearPictureCompression", "bound") => return "bound".to_string(),
-        ("PrimeAttributeName", "num_attributes") => return "universe".to_string(),
-        ("PrimeAttributeName", "dependencies") => return "dependencies".to_string(),
-        ("PrimeAttributeName", "query_attribute") => return "query-attribute".to_string(),
-        ("ClosestVectorProblem", "target") => return "target-vec".to_string(),
-        ("ConjunctiveBooleanQuery", "conjuncts") => return "conjuncts-spec".to_string(),
-        ("MixedChinesePostman", "arc_weights") => return "arc-weights".to_string(),
-        ("ConsecutiveOnesMatrixAugmentation", "bound") => return "bound".to_string(),
-        ("ConsecutiveOnesSubmatrix", "bound") => return "bound".to_string(),
-        ("SparseMatrixCompression", "bound_k") => return "bound-k".to_string(),
-        ("MinimumCodeGenerationParallelAssignments", "num_variables") => {
-            return "num-variables".to_string();
-        }
-        ("MinimumCodeGenerationParallelAssignments", "assignments") => {
-            return "assignments".to_string();
-        }
-        ("StackerCrane", "edges") => return "graph".to_string(),
-        ("StackerCrane", "arc_lengths") => return "arc-lengths".to_string(),
-        ("StackerCrane", "edge_lengths") => return "edge-lengths".to_string(),
-        ("StaffScheduling", "shifts_per_schedule") => return "k".to_string(),
-        ("MaximumCoKPlex", "bound_k") => return "k".to_string(),
-        ("TimetableDesign", "num_tasks") => return "num-tasks".to_string(),
-        _ => {}
-    }
-    // Edge-weight problems use --edge-weights instead of --weights
-    if field_name == "weights" && uses_edge_weights_flag(canonical) {
-        return "edge-weights".to_string();
-    }
-    if field_name == "edge_lengths" && uses_edge_weights_flag_for_edge_lengths(canonical) {
-        return "edge-weights".to_string();
-    }
-    // General field-name overrides (previously in cli_flag_name)
-    match field_name {
-        "universe_size" => "universe-size".to_string(),
-        "collection" | "subsets" | "sets" => "subsets".to_string(),
-        "left_size" => "left".to_string(),
-        "right_size" => "right".to_string(),
-        "edges" => "biedges".to_string(),
-        "vertex_weights" => "weights".to_string(),
-        "potential_weights" => "potential-weights".to_string(),
-        "num_tasks" => "num-tasks".to_string(),
-        "precedences" => "precedences".to_string(),
-        "threshold" => "threshold".to_string(),
-        "lengths" => "lengths".to_string(),
-        _ => field_name.replace('_', "-"),
-    }
-}
-
-pub(super) fn reject_vertex_weights_for_edge_weight_problem(
-    args: &CreateArgs,
-    canonical: &str,
-    graph_type: Option<&str>,
-) -> Result<()> {
-    if args.weights.is_some() && uses_edge_weights_flag(canonical) {
-        bail!(
-            "{canonical} uses --edge-weights, not --weights.\n\n\
-             Usage: pred create {} {}",
-            match graph_type {
-                Some(g) => format!("{canonical}/{g}"),
-                None => canonical.to_string(),
-            },
-            example_for(canonical, graph_type)
-        );
-    }
-    Ok(())
-}
-
-pub(super) fn help_flag_hint(
-    canonical: &str,
-    field_name: &str,
-    type_name: &str,
-    graph_type: Option<&str>,
-) -> &'static str {
-    match (canonical, field_name) {
-        ("BoundedComponentSpanningForest", "max_weight") => "integer",
-        ("SequencingWithinIntervals", "release_times") => "comma-separated integers: 0,0,5",
-        ("DynamicStorageAllocation", "release_times") => "comma-separated arrival times: 0,0,1,2,3",
-        ("DynamicStorageAllocation", "deadlines") => "comma-separated departure times: 3,2,4,5,5",
-        ("DynamicStorageAllocation", "sizes") => "comma-separated item sizes: 2,3,1,3,2",
-        ("DynamicStorageAllocation", "capacity") => "memory size D: 6",
-        ("DisjointConnectingPaths", "terminal_pairs") => "comma-separated pairs: 0-3,2-5",
-        ("PrimeAttributeName", "dependencies") => {
-            "semicolon-separated dependencies: \"0,1>2,3;2,3>0,1\""
-        }
-        ("LongestCommonSubsequence", "strings") => {
-            "raw strings: \"ABAC;BACA\" or symbol lists: \"0,1,0;1,0,1\""
-        }
-        ("ClosestString", "strings") => {
-            "semicolon-separated equal-length symbol lists: \"0,0,0;0,1,1;1,0,1;1,1,0\""
-        }
-        ("ClosestSubstring", "strings") => {
-            "semicolon-separated symbol lists (one per input string): \"0,0,0,1,1;1,0,1,0,0;1,1,0,0,1\""
-        }
-        ("ClosestSubstring", "substring_length") => "common window length ell: 3",
-        ("GroupingBySwapping", "string") => "symbol list: \"0,1,2,0,1,2\"",
-        ("MinimumExternalMacroDataCompression", "string")
-        | ("MinimumInternalMacroDataCompression", "string") => "symbol list: \"0,1,0,1\"",
-        ("MinimumExternalMacroDataCompression", "pointer_cost")
-        | ("MinimumInternalMacroDataCompression", "pointer_cost") => "positive integer: 2",
-        ("MinimumAxiomSet", "num_sentences") => "total number of sentences: 8",
-        ("MinimumAxiomSet", "true_sentences") => "comma-separated indices: 0,1,2,3,4,5,6,7",
-        ("MinimumAxiomSet", "implications") => "semicolon-separated rules: \"0>2;0>3;1>4;2,4>6\"",
-        ("ShortestCommonSupersequence", "strings") => "symbol lists: \"0,1,2;1,2,0\"",
-        ("MultipleChoiceBranching", "partition") => "semicolon-separated groups: \"0,1;2,3\"",
-        ("IntegralFlowHomologousArcs", "homologous_pairs") => {
-            "semicolon-separated arc-index equalities: \"2=5;4=3\""
-        }
-        ("ConsistencyOfDatabaseFrequencyTables", "attribute_domains") => {
-            "comma-separated domain sizes: 2,3,2"
-        }
-        ("ConsistencyOfDatabaseFrequencyTables", "frequency_tables") => {
-            "semicolon-separated tables: \"0,1:1,1,1|1,1,1;1,2:1,1|0,2|1,1\""
-        }
-        ("ConsistencyOfDatabaseFrequencyTables", "known_values") => {
-            "semicolon-separated triples: \"0,0,0;3,0,1;1,2,1\""
-        }
-        ("IntegralFlowBundles", "bundles") => "semicolon-separated groups: \"0,1;2,5;3,4\"",
-        ("IntegralFlowBundles", "bundle_capacities") => "comma-separated capacities: 1,1,1",
-        ("PathConstrainedNetworkFlow", "paths") => {
-            "semicolon-separated arc-index paths: \"0,2,5,8;1,4,7,9\""
-        }
-        ("ConsecutiveBlockMinimization", "matrix") => {
-            "JSON 2D bool array: '[[true,false,true],[false,true,true]]'"
-        }
-        ("ConsecutiveOnesMatrixAugmentation", "matrix") => {
-            "semicolon-separated 0/1 rows: \"1,0;0,1\""
-        }
-        ("ConsecutiveOnesSubmatrix", "matrix") => "semicolon-separated 0/1 rows: \"1,0;0,1\"",
-        ("SparseMatrixCompression", "matrix") => "semicolon-separated 0/1 rows: \"1,0;0,1\"",
-        ("MaximumLikelihoodRanking", "matrix") => {
-            "semicolon-separated i32 rows: \"0,4,3,5;1,0,4,3;2,1,0,4;0,2,1,0\""
-        }
-        ("MinimumMatrixCover", "matrix") => "semicolon-separated i64 rows: \"0,3,1;3,0,2;1,2,0\"",
-        ("MinimumMatrixDomination", "matrix") => "semicolon-separated 0/1 rows: \"1,0;0,1\"",
-        ("MinimumWeightDecoding", "matrix") => "JSON 2D bool array: '[[true,false],[false,true]]'",
-        ("MinimumWeightDecoding", "target") => "comma-separated booleans: \"true,true,false\"",
-        ("MinimumWeightSolutionToLinearEquations", "matrix") => {
-            "JSON 2D integer array: '[[1,2,3],[4,5,6]]'"
-        }
-        ("MinimumWeightSolutionToLinearEquations", "rhs") => "comma-separated integers: \"5,4\"",
-        ("FeasibleBasisExtension", "matrix") => "JSON 2D integer array: '[[1,0,1],[0,1,0]]'",
-        ("FeasibleBasisExtension", "rhs") => "comma-separated integers: \"7,5,3\"",
-        ("FeasibleBasisExtension", "required_columns") => "comma-separated column indices: \"0,1\"",
-        ("MinimumCodeGenerationParallelAssignments", "assignments") => {
-            "semicolon-separated target:reads entries: \"0:1,2;1:0;2:3;3:1,2\""
-        }
-        ("NonTautology", "disjuncts") => "semicolon-separated disjuncts: \"1,2,3;-1,-2,-3\"",
-        ("TimetableDesign", "craftsman_avail") | ("TimetableDesign", "task_avail") => {
-            "semicolon-separated 0/1 rows: \"1,1,0;0,1,1\""
-        }
-        ("TimetableDesign", "requirements") => "semicolon-separated rows: \"1,0,1;0,1,0\"",
-        _ => type_format_hint(type_name, graph_type),
-    }
-}
-
-pub(super) fn parse_nonnegative_usize_bound(
-    bound: i64,
-    problem_name: &str,
-    usage: &str,
-) -> Result<usize> {
-    usize::try_from(bound)
-        .map_err(|_| anyhow::anyhow!("{problem_name} requires nonnegative --bound\n\n{usage}"))
-}
-
-pub(super) fn validate_prescribed_paths_against_graph(
-    graph: &DirectedGraph,
-    paths: &[Vec<usize>],
-    source: usize,
-    sink: usize,
-    usage: &str,
-) -> Result<()> {
-    let arcs = graph.arcs();
-    for path in paths {
-        anyhow::ensure!(
-            !path.is_empty(),
-            "PathConstrainedNetworkFlow paths must be non-empty\n\n{usage}"
-        );
-        let mut visited_vertices = BTreeSet::from([source]);
-        let mut current = source;
-        for &arc_index in path {
-            let &(tail, head) = arcs.get(arc_index).ok_or_else(|| {
-                anyhow::anyhow!(
-                    "Path arc index {arc_index} out of bounds for {} arcs\n\n{usage}",
-                    arcs.len()
-                )
-            })?;
-            anyhow::ensure!(
-                tail == current,
-                "prescribed path is not contiguous: expected arc leaving vertex {current}, got {tail}->{head}\n\n{usage}"
-            );
-            anyhow::ensure!(
-                visited_vertices.insert(head),
-                "prescribed path repeats vertex {head}, so it is not a simple path\n\n{usage}"
-            );
-            current = head;
-        }
-        anyhow::ensure!(
-            current == sink,
-            "prescribed path must end at sink {sink}, ended at {current}\n\n{usage}"
-        );
-    }
-    Ok(())
-}
-
-pub(super) fn resolve_processor_count_flags(
-    problem_name: &str,
-    usage: &str,
-    num_processors: Option<usize>,
-    m_alias: Option<usize>,
-) -> Result<Option<usize>> {
-    match (num_processors, m_alias) {
-        (Some(num_processors), Some(m_alias)) => {
-            anyhow::ensure!(
-                num_processors == m_alias,
-                "{problem_name} received conflicting processor counts: --num-processors={num_processors} but --m={m_alias}\n\n{usage}"
-            );
-            Ok(Some(num_processors))
-        }
-        (Some(num_processors), None) => Ok(Some(num_processors)),
-        (None, Some(m_alias)) => Ok(Some(m_alias)),
-        (None, None) => Ok(None),
-    }
-}
-
-pub(super) fn validate_sequencing_within_intervals_inputs(
-    release_times: &[u64],
-    deadlines: &[u64],
-    lengths: &[u64],
-    usage: &str,
-) -> Result<()> {
-    if release_times.len() != deadlines.len() {
-        bail!("release_times and deadlines must have the same length\n\n{usage}");
-    }
-    if release_times.len() != lengths.len() {
-        bail!("release_times and lengths must have the same length\n\n{usage}");
-    }
-
-    for (i, ((&release_time, &deadline), &length)) in release_times
-        .iter()
-        .zip(deadlines.iter())
-        .zip(lengths.iter())
-        .enumerate()
-    {
-        let end = release_time.checked_add(length).ok_or_else(|| {
-            anyhow::anyhow!("Task {i}: overflow computing r(i) + l(i)\n\n{usage}")
-        })?;
-        if end > deadline {
-            bail!(
-                "Task {i}: r({}) + l({}) > d({}), time window is empty\n\n{usage}",
-                release_time,
-                length,
-                deadline
-            );
-        }
-    }
-
-    Ok(())
-}
-
-pub(super) fn print_problem_help(
-    canonical: &str,
-    resolved_variant: &BTreeMap<String, String>,
-) -> Result<()> {
-    let graph_type = resolved_variant
-        .get("graph")
-        .map(String::as_str)
-        .filter(|graph_type| *graph_type != "SimpleGraph");
-    let is_geometry = matches!(
-        graph_type,
-        Some("KingsSubgraph" | "TriangularSubgraph" | "UnitDiskGraph")
-    );
-    let schemas = collect_schemas();
-    let schema = schemas.iter().find(|s| s.name == canonical);
-
-    if let Some(s) = schema {
-        eprintln!("{}\n  {}\n", canonical, s.description);
-        eprintln!("Parameters:");
-        for field in &s.fields {
-            let flag_name =
-                problem_help_flag_name(canonical, &field.name, &field.type_name, is_geometry);
-            // For geometry variants, show --positions instead of --graph
-            if field.type_name == "G" && is_geometry {
-                let hint = type_format_hint(&field.type_name, graph_type);
-                eprintln!("  --{:<16} {} ({hint})", flag_name, field.description);
-                if graph_type == Some("UnitDiskGraph") {
-                    eprintln!("  --{:<16} Distance threshold [default: 1.0]", "radius");
-                }
-            } else if field.type_name == "DirectedGraph" {
-                // DirectedGraph fields use --arcs, not --graph
-                let hint = type_format_hint(&field.type_name, graph_type);
-                eprintln!("  --{:<16} {} ({})", "arcs", field.description, hint);
-            } else if field.type_name == "MixedGraph" {
-                eprintln!(
-                    "  --{:<16} Undirected edges E of the mixed graph (edge list: 0-1,1-2,2-3)",
-                    "graph"
-                );
-                eprintln!(
-                    "  --{:<16} Directed arcs A of the mixed graph (directed arcs: 0>1,1>2,2>0)",
-                    "arcs"
-                );
-            } else if field.type_name == "BipartiteGraph" {
-                eprintln!(
-                    "  --{:<16} Vertices in the left partition (integer)",
-                    "left"
-                );
-                eprintln!(
-                    "  --{:<16} Vertices in the right partition (integer)",
-                    "right"
-                );
-                eprintln!(
-                    "  --{:<16} Bipartite edges as left-right pairs (edge list: 0-0,0-1,1-2)",
-                    "biedges"
-                );
-            } else {
-                let hint = help_flag_hint(canonical, &field.name, &field.type_name, graph_type);
-                eprintln!("  --{:<16} {} ({})", flag_name, field.description, hint);
-            }
-        }
-        if canonical == "GraphPartitioning" {
-            eprintln!(
-                "  --{:<16} Number of partitions in the balanced partitioning model (must be 2) (integer)",
-                "num-partitions"
-            );
-        }
-    } else {
-        bail!("{}", crate::problem_name::unknown_problem_error(canonical));
-    }
-
-    let example = schema_help_example_for(canonical, resolved_variant).or_else(|| {
-        let fallback = example_for(canonical, graph_type);
-        (!fallback.is_empty()).then(|| fallback.to_string())
-    });
-    if let Some(example) = example {
-        eprintln!("\nExample:");
-        eprintln!(
-            "  pred create {} {}",
-            match graph_type {
-                Some(g) => format!("{canonical}/{g}"),
-                None => canonical.to_string(),
-            },
-            example
-        );
-    }
-    Ok(())
-}
-
-pub(super) fn schema_help_example_for(
-    canonical: &str,
-    resolved_variant: &BTreeMap<String, String>,
-) -> Option<String> {
-    let schema = collect_schemas()
-        .into_iter()
-        .find(|schema| schema.name == canonical)?;
-    let example = problemreductions::example_db::find_model_example(&ProblemRef {
-        name: canonical.to_string(),
-        variant: resolved_variant.clone(),
-    })
-    .ok()?;
-    let instance = example.instance.as_object()?;
-    let graph_type = resolved_variant
-        .get("graph")
-        .map(String::as_str)
-        .filter(|graph_type| *graph_type != "SimpleGraph");
-    let is_geometry = matches!(
-        graph_type,
-        Some("KingsSubgraph" | "TriangularSubgraph" | "UnitDiskGraph")
-    );
-
-    let mut args = Vec::new();
-    for field in &schema.fields {
-        let value = instance.get(&field.name)?;
-        let concrete_type = resolve_schema_field_type(&field.type_name, resolved_variant);
-        let flag_name =
-            schema_example_flag_name(canonical, &field.name, &field.type_name, is_geometry);
-        let rendered =
-            format_schema_help_example_value(canonical, &field.name, &concrete_type, value)?;
-        args.push(format!("--{flag_name} {}", quote_cli_arg(&rendered)));
-    }
-    Some(args.join(" "))
-}
-
-pub(super) fn schema_example_flag_name(
-    canonical: &str,
-    field_name: &str,
-    field_type: &str,
-    is_geometry: bool,
-) -> String {
-    problem_help_flag_name(canonical, field_name, field_type, is_geometry)
-        .split('/')
-        .next()
-        .unwrap_or(field_name)
-        .trim_start_matches("--")
-        .to_string()
-}
-
-pub(super) fn quote_cli_arg(raw: &str) -> String {
-    if raw.is_empty()
-        || raw.chars().any(|ch| {
-            ch.is_whitespace()
-                || matches!(
-                    ch,
-                    ';' | '>' | '|' | '[' | ']' | '{' | '}' | '(' | ')' | '"' | '\''
-                )
-        })
-    {
-        format!("\"{}\"", raw.replace('\\', "\\\\").replace('"', "\\\""))
-    } else {
-        raw.to_string()
-    }
-}
-
-pub(super) fn format_schema_help_example_value(
-    canonical: &str,
-    field_name: &str,
-    concrete_type: &str,
-    value: &serde_json::Value,
-) -> Option<String> {
-    match (canonical, field_name) {
-        ("ConsecutiveBlockMinimization", "matrix")
-        | ("FeasibleBasisExtension", "matrix")
-        | ("MinimumWeightDecoding", "matrix")
-        | ("MinimumWeightSolutionToLinearEquations", "matrix") => {
-            return serde_json::to_string(value).ok();
-        }
-        _ => {}
-    }
-    match normalize_type_name(concrete_type).as_str() {
-        "SimpleGraph" => format_simple_graph_example(value),
-        "DirectedGraph" => format_directed_graph_example(value),
-        "LabelledDigraph" => format_labelled_digraph_example(value),
-        "Vec<CNFClause>" => format_cnf_clause_list_example(value),
-        "Vec<Quantifier>" => format_quantifier_list_example(value),
-        "Vec<Vec<(usize,u64)>>" => format_job_shop_example(value),
-        "Vec<(Vec<usize>,Vec<usize>)>" => format_dependency_example(value),
-        "Vec<usize>" | "Vec<u64>" | "Vec<i32>" | "Vec<i64>" | "Vec<f64>" | "Vec<BigUint>" => {
-            format_scalar_array_example(value)
-        }
-        "Vec<bool>" => format_bool_array_example(value),
-        "Vec<Vec<usize>>" | "Vec<Vec<u64>>" | "Vec<Vec<i32>>" | "Vec<Vec<i64>>"
-        | "Vec<Vec<f64>>" => format_nested_numeric_rows(value),
-        "Vec<Vec<bool>>" => format_bool_matrix_example(value),
-        "Vec<String>" => Some(
-            value
-                .as_array()?
-                .iter()
-                .map(|entry| entry.as_str().map(str::to_string))
-                .collect::<Option<Vec<_>>>()?
-                .join(";"),
-        ),
-        "usize" | "u64" | "i32" | "i64" | "f64" | "BigUint" => format_scalar_example(value),
-        _ => None,
-    }
-}
-
-pub(super) fn format_scalar_example(value: &serde_json::Value) -> Option<String> {
-    match value {
-        serde_json::Value::Number(number) => Some(number.to_string()),
-        serde_json::Value::String(string) => Some(string.clone()),
-        serde_json::Value::Bool(boolean) => Some(boolean.to_string()),
-        _ => None,
-    }
-}
-
-pub(super) fn format_scalar_array_example(value: &serde_json::Value) -> Option<String> {
-    Some(
-        value
-            .as_array()?
-            .iter()
-            .map(format_scalar_example)
-            .collect::<Option<Vec<_>>>()?
-            .join(","),
-    )
-}
-
-pub(super) fn format_bool_array_example(value: &serde_json::Value) -> Option<String> {
-    Some(
-        value
-            .as_array()?
-            .iter()
-            .map(|entry| {
-                entry
-                    .as_bool()
-                    .map(|boolean| if boolean { "1" } else { "0" }.to_string())
-            })
-            .collect::<Option<Vec<_>>>()?
-            .join(","),
-    )
-}
-
-pub(super) fn format_nested_numeric_rows(value: &serde_json::Value) -> Option<String> {
-    Some(
-        value
-            .as_array()?
-            .iter()
-            .map(format_scalar_array_example)
-            .collect::<Option<Vec<_>>>()?
-            .join(";"),
-    )
-}
-
-pub(super) fn format_cnf_clause_list_example(value: &serde_json::Value) -> Option<String> {
-    Some(
-        value
-            .as_array()?
-            .iter()
-            .map(|clause| format_scalar_array_example(clause.get("literals")?))
-            .collect::<Option<Vec<_>>>()?
-            .join(";"),
-    )
-}
-
-pub(super) fn format_bool_matrix_example(value: &serde_json::Value) -> Option<String> {
-    Some(
-        value
-            .as_array()?
-            .iter()
-            .map(format_bool_array_example)
-            .collect::<Option<Vec<_>>>()?
-            .join(";"),
-    )
-}
-
-pub(super) fn format_simple_graph_example(value: &serde_json::Value) -> Option<String> {
-    Some(
-        value
-            .get("edges")?
-            .as_array()?
-            .iter()
-            .map(|edge| {
-                let pair = edge.as_array()?;
-                Some(format!(
-                    "{}-{}",
-                    pair.first()?.as_u64()?,
-                    pair.get(1)?.as_u64()?
-                ))
-            })
-            .collect::<Option<Vec<_>>>()?
-            .join(","),
-    )
-}
-
-pub(super) fn format_directed_graph_example(value: &serde_json::Value) -> Option<String> {
-    Some(
-        value
-            .get("arcs")?
-            .as_array()?
-            .iter()
-            .map(|arc| {
-                let pair = arc.as_array()?;
-                Some(format!(
-                    "{}>{}",
-                    pair.first()?.as_u64()?,
-                    pair.get(1)?.as_u64()?
-                ))
-            })
-            .collect::<Option<Vec<_>>>()?
-            .join(","),
-    )
-}
-
-pub(super) fn format_labelled_digraph_example(value: &serde_json::Value) -> Option<String> {
-    let num_vertices = value.get("num_vertices")?.as_u64()?;
-    let arcs_str: Vec<String> = value
-        .get("arcs")?
-        .as_array()?
-        .iter()
-        .map(|arc| {
-            let obj = arc.as_object()?;
-            Some(format!(
-                "{}-{}-{}",
-                obj.get("src")?.as_u64()?,
-                obj.get("label")?.as_u64()?,
-                obj.get("dst")?.as_u64()?
-            ))
-        })
-        .collect::<Option<Vec<_>>>()?;
-    Some(format!("{num_vertices}:{}", arcs_str.join(",")))
-}
-
-pub(super) fn format_quantifier_list_example(value: &serde_json::Value) -> Option<String> {
-    Some(
-        value
-            .as_array()?
-            .iter()
-            .map(|entry| match entry.as_str()? {
-                "Exists" => Some("E".to_string()),
-                "ForAll" => Some("A".to_string()),
-                _ => None,
-            })
-            .collect::<Option<Vec<_>>>()?
-            .join(","),
-    )
-}
-
-pub(super) fn format_job_shop_example(value: &serde_json::Value) -> Option<String> {
-    Some(
-        value
-            .as_array()?
-            .iter()
-            .map(|job| {
-                Some(
-                    job.as_array()?
-                        .iter()
-                        .map(|task| {
-                            let task = task.as_array()?;
-                            Some(format!(
-                                "{}:{}",
-                                task.first()?.as_u64()?,
-                                task.get(1)?.as_u64()?
-                            ))
-                        })
-                        .collect::<Option<Vec<_>>>()?
-                        .join(","),
-                )
-            })
-            .collect::<Option<Vec<_>>>()?
-            .join(";"),
-    )
-}
-
-pub(super) fn format_dependency_example(value: &serde_json::Value) -> Option<String> {
-    Some(
-        value
-            .as_array()?
-            .iter()
-            .map(|dependency| {
-                let dependency = dependency.as_array()?;
-                let lhs = format_scalar_array_example(dependency.first()?)?;
-                let rhs = format_scalar_array_example(dependency.get(1)?)?;
-                Some(format!("{lhs}>{rhs}"))
-            })
-            .collect::<Option<Vec<_>>>()?
-            .join(";"),
-    )
+pub(super) fn help_flag_name(field_name: &str) -> String {
+    field_name.replace("_", "-")
 }
 
 pub(super) fn problem_help_flag_name(
-    canonical: &str,
     field_name: &str,
     field_type: &str,
     is_geometry: bool,
 ) -> String {
     if field_type == "G" && is_geometry {
-        return "positions".to_string();
-    }
-    if field_type == "DirectedGraph" {
-        return "arcs".to_string();
-    }
-    if field_type == "MixedGraph" {
-        return "graph".to_string();
-    }
-    if canonical == "LengthBoundedDisjointPaths" && field_name == "max_length" {
-        return "max-length".to_string();
-    }
-    if canonical == "GeneralizedHex" && field_name == "target" {
-        return "sink".to_string();
-    }
-    if canonical == "StringToStringCorrection" {
-        return match field_name {
-            "source" => "source-string".to_string(),
-            "target" => "target-string".to_string(),
-            "bound" => "bound".to_string(),
-            _ => help_flag_name(canonical, field_name),
-        };
-    }
-    help_flag_name(canonical, field_name)
-}
-
-pub(super) fn lbdp_validation_error(message: &str, usage: Option<&str>) -> anyhow::Error {
-    match usage {
-        Some(usage) => anyhow::anyhow!("{message}\n\n{usage}"),
-        None => anyhow::anyhow!("{message}"),
-    }
-}
-
-pub(super) fn validate_length_bounded_disjoint_paths_args(
-    num_vertices: usize,
-    source: usize,
-    sink: usize,
-    bound: i64,
-    usage: Option<&str>,
-) -> Result<usize> {
-    let max_length = usize::try_from(bound).map_err(|_| {
-        lbdp_validation_error(
-            "--max-length must be a nonnegative integer for LengthBoundedDisjointPaths",
-            usage,
-        )
-    })?;
-    if source >= num_vertices || sink >= num_vertices {
-        return Err(lbdp_validation_error(
-            "--source and --sink must be valid graph vertices",
-            usage,
-        ));
-    }
-    if source == sink {
-        return Err(lbdp_validation_error(
-            "--source and --sink must be distinct",
-            usage,
-        ));
-    }
-    if max_length == 0 {
-        return Err(lbdp_validation_error(
-            "--max-length must be positive",
-            usage,
-        ));
+        "positions".to_string()
+    } else if field_type == "DirectedGraph" {
+        "arcs".to_string()
+    } else {
+        help_flag_name(field_name)
     }
-    Ok(max_length)
 }
diff --git a/problemreductions-cli/src/commands/create/tests.rs b/problemreductions-cli/src/commands/create/tests.rs
index 2e837b8c8..79294e200 100644
--- a/problemreductions-cli/src/commands/create/tests.rs
+++ b/problemreductions-cli/src/commands/create/tests.rs
@@ -2,11 +2,8 @@ use std::fs;
 use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use clap::Parser;
-
 use super::ensure_attribute_indices_in_range;
 use super::parse_bool_rows;
-use super::schema_support::*;
 use super::*;
 use crate::cli::{Cli, Commands};
 use crate::output::OutputConfig;
@@ -19,34 +16,6 @@ fn temp_output_path(name: &str) -> PathBuf {
     std::env::temp_dir().join(format!("{}_{}.json", name, suffix))
 }
 
-#[test]
-fn test_problem_help_uses_bound_for_length_bounded_disjoint_paths() {
-    assert_eq!(
-        problem_help_flag_name("LengthBoundedDisjointPaths", "max_length", "usize", false),
-        "max-length"
-    );
-}
-
-#[test]
-fn test_problem_help_preserves_generic_field_kebab_case() {
-    assert_eq!(
-        problem_help_flag_name("LengthBoundedDisjointPaths", "max_paths", "usize", false,),
-        "max-paths"
-    );
-}
-
-#[test]
-fn test_help_flag_name_mentions_m_alias_for_scheduling_processors() {
-    assert_eq!(
-        help_flag_name("SchedulingWithIndividualDeadlines", "num_processors"),
-        "num-processors/--m"
-    );
-    assert_eq!(
-        help_flag_name("FlowShopScheduling", "num_processors"),
-        "num-processors/--m"
-    );
-}
-
 #[test]
 fn test_parse_field_value_parses_simple_graph_to_json() {
     let value = parse_field_value("SimpleGraph", "graph", "0-1,1-2", &CreateContext::default())
@@ -77,7 +46,7 @@ fn test_parse_field_value_parses_dependency_pairs() {
 #[test]
 fn test_parse_field_value_parses_job_shop_jobs() {
     let value = parse_field_value(
-        "Vec<Vec<(usize, u64)>>",
+        "Vec<Vec<(usize, i64)>>",
         "jobs",
         "0:3,1:4;1:2,0:3,1:2",
         &CreateContext::default(),
@@ -90,28 +59,9 @@ fn test_parse_field_value_parses_job_shop_jobs() {
     );
 }
 
-#[test]
-fn test_parse_field_value_parses_quantifiers_using_context_num_vars() {
-    let context = CreateContext::default().with_field("num_vars", serde_json::json!(3));
-    let value = parse_field_value("Vec<Quantifier>", "quantifiers", "E,A,E", &context)
-        .expect("parse quantifiers");
-
-    assert_eq!(value, serde_json::json!(["Exists", "ForAll", "Exists"]));
-}
-
-#[test]
-fn test_schema_driven_supported_problem_includes_cli_creatable_problem() {
-    assert!(
-            schema_driven_supported_problem("ConjunctiveBooleanQuery"),
-            "all CLI-creatable problems should opt into schema-driven create unless explicitly excluded"
-        );
-    assert!(!schema_driven_supported_problem("ILP"));
-    assert!(!schema_driven_supported_problem("CircuitSAT"));
-}
-
 #[test]
 fn test_create_schema_driven_builds_job_shop_scheduling() {
-    let cli = Cli::parse_from([
+    let cli = Cli::try_parse_from([
         "pred",
         "create",
         "JobShopScheduling",
@@ -119,15 +69,15 @@ fn test_create_schema_driven_builds_job_shop_scheduling() {
         "0:3,1:4;1:2,0:3,1:2",
         "--num-processors",
         "2",
-    ]);
+    ])
+    .expect("create command parses");
 
     let Commands::Create(args) = cli.command else {
         panic!("expected create command");
     };
 
     let (data, variant) = create_schema_driven(&args, "JobShopScheduling", &BTreeMap::new())
-        .expect("schema-driven create should parse")
-        .expect("schema-driven path should support JobShopScheduling");
+        .expect("schema-driven create should parse");
 
     let entry = problemreductions::registry::find_variant_entry("JobShopScheduling", &variant)
         .expect("variant entry");
@@ -136,9 +86,149 @@ fn test_create_schema_driven_builds_job_shop_scheduling() {
     assert_eq!(data["jobs"][0], serde_json::json!([[0, 3], [1, 4]]));
 }
 
+#[test]
+fn construction_contract_scs_uses_registered_spec_and_canonical_serialization() {
+    let cli = Cli::try_parse_from(["pred", "create", "SCS", "--strings", "0,1;1,2"])
+        .expect("create command parses");
+    let Commands::Create(args) = cli.command else {
+        panic!("expected create command");
+    };
+
+    let (data, variant) =
+        create_schema_driven(&args, "ShortestCommonSupersequence", &BTreeMap::new())
+            .expect("registered SCS constructor should succeed");
+
+    assert!(variant.is_empty());
+    assert_eq!(data["alphabet_size"], 3);
+    assert_eq!(data["max_length"], 4);
+    assert_eq!(data["strings"], serde_json::json!([[0, 1], [1, 2]]));
+}
+
+#[test]
+fn construction_contract_cli_discovers_test_only_registered_model() {
+    let cli = Cli::try_parse_from([
+        "pred",
+        "create",
+        crate::test_support::AGGREGATE_SOURCE_NAME,
+        "--values",
+        "2,5,7",
+    ])
+    .expect("create command parses");
+    let Commands::Create(args) = cli.command else {
+        panic!("expected create command");
+    };
+
+    let (data, variant) = create_schema_driven(
+        &args,
+        crate::test_support::AGGREGATE_SOURCE_NAME,
+        &BTreeMap::new(),
+    )
+    .expect("test-only registry model should be constructed without frontend dispatch");
+
+    assert!(variant.is_empty());
+    assert_eq!(data, serde_json::json!({"values": [2, 5, 7]}));
+}
+
+#[test]
+fn construction_contract_preserves_variant_declared_numeric_types() {
+    let max_i64 = i64::MAX.to_string();
+    let cli = Cli::try_parse_from([
+        "pred",
+        "create",
+        "ThreePartition",
+        "--sizes",
+        "3074457345618258602,3074457345618258602,3074457345618258603",
+        "--bound",
+        max_i64.as_str(),
+    ])
+    .expect("create command parses");
+    let Commands::Create(args) = cli.command else {
+        panic!("expected create command");
+    };
+    let (data, _) = create_schema_driven(&args, "ThreePartition", &BTreeMap::new()).unwrap();
+    assert_eq!(data["bound"], serde_json::json!(i64::MAX));
+
+    let huge = "340282366920938463463374607431768211457";
+    let cli = Cli::try_parse_from([
+        "pred",
+        "create",
+        "SubsetSum",
+        "--sizes",
+        huge,
+        "--target",
+        huge,
+    ])
+    .expect("create command parses");
+    let Commands::Create(args) = cli.command else {
+        panic!("expected create command");
+    };
+    let (data, _) = create_schema_driven(&args, "SubsetSum", &BTreeMap::new()).unwrap();
+    assert_eq!(data["target"], serde_json::json!(huge));
+}
+
+#[test]
+fn construction_contract_biclique_uses_registered_composite_inputs() {
+    let cli = Cli::try_parse_from([
+        "pred",
+        "create",
+        "BicliqueCover",
+        "--left",
+        "2",
+        "--right",
+        "3",
+        "--biedges",
+        "0-0,0-1,1-2",
+        "--k",
+        "2",
+    ])
+    .expect("create command parses");
+    let Commands::Create(args) = cli.command else {
+        panic!("expected create command");
+    };
+
+    let (data, variant) = create_schema_driven(&args, "BicliqueCover", &BTreeMap::new())
+        .expect("registered BicliqueCover constructor should succeed");
+
+    assert!(variant.is_empty());
+    assert_eq!(data["graph"]["left_size"], 2);
+    assert_eq!(data["graph"]["right_size"], 3);
+    assert_eq!(
+        data["graph"]["edges"],
+        serde_json::json!([[0, 0], [0, 1], [1, 2]])
+    );
+    assert_eq!(data["k"], 2);
+}
+
+#[test]
+fn construction_contract_biclique_missing_input_comes_from_core_contract() {
+    let cli = Cli::try_parse_from([
+        "pred",
+        "create",
+        "BicliqueCover",
+        "--left",
+        "2",
+        "--right",
+        "3",
+        "--k",
+        "2",
+    ])
+    .expect("create command parses");
+    let Commands::Create(args) = cli.command else {
+        panic!("expected create command");
+    };
+
+    let error = create_schema_driven(&args, "BicliqueCover", &BTreeMap::new())
+        .expect_err("missing biedges must be rejected");
+    assert_eq!(
+        error.to_string(),
+        "missing required construction input(s): biedges\n\n\
+Usage: pred create BicliqueCover --left <VALUE> --right <VALUE> --biedges <VALUE> --k <VALUE>"
+    );
+}
+
 #[test]
 fn test_create_schema_driven_builds_quantified_boolean_formulas() {
-    let cli = Cli::parse_from([
+    let cli = Cli::try_parse_from([
         "pred",
         "create",
         "QuantifiedBooleanFormulas",
@@ -148,7 +238,8 @@ fn test_create_schema_driven_builds_quantified_boolean_formulas() {
         "E,A,E",
         "--clauses",
         "1,2;-1,3",
-    ]);
+    ])
+    .expect("create command parses");
 
     let Commands::Create(args) = cli.command else {
         panic!("expected create command");
@@ -156,8 +247,7 @@ fn test_create_schema_driven_builds_quantified_boolean_formulas() {
 
     let (data, variant) =
         create_schema_driven(&args, "QuantifiedBooleanFormulas", &BTreeMap::new())
-            .expect("schema-driven create should parse")
-            .expect("schema-driven path should support QBF");
+            .expect("schema-driven create should parse");
 
     let entry =
         problemreductions::registry::find_variant_entry("QuantifiedBooleanFormulas", &variant)
@@ -171,7 +261,7 @@ fn test_create_schema_driven_builds_quantified_boolean_formulas() {
 
 #[test]
 fn test_create_schema_driven_builds_undirected_flow_lower_bounds() {
-    let cli = Cli::parse_from([
+    let cli = Cli::try_parse_from([
         "pred",
         "create",
         "UndirectedFlowLowerBounds",
@@ -187,7 +277,8 @@ fn test_create_schema_driven_builds_undirected_flow_lower_bounds() {
         "3",
         "--requirement",
         "2",
-    ]);
+    ])
+    .expect("create command parses");
 
     let Commands::Create(args) = cli.command else {
         panic!("expected create command");
@@ -195,8 +286,7 @@ fn test_create_schema_driven_builds_undirected_flow_lower_bounds() {
 
     let (data, variant) =
         create_schema_driven(&args, "UndirectedFlowLowerBounds", &BTreeMap::new())
-            .expect("schema-driven create should parse")
-            .expect("schema-driven path should support UndirectedFlowLowerBounds");
+            .expect("schema-driven create should parse");
 
     let entry =
         problemreductions::registry::find_variant_entry("UndirectedFlowLowerBounds", &variant)
@@ -209,25 +299,24 @@ fn test_create_schema_driven_builds_undirected_flow_lower_bounds() {
 
 #[test]
 fn test_create_schema_driven_builds_conjunctive_boolean_query() {
-    let cli = Cli::parse_from([
+    let cli = Cli::try_parse_from([
         "pred",
         "create",
         "ConjunctiveBooleanQuery",
         "--domain-size",
         "6",
         "--relations",
-        "2:0,3|1,3;3:0,1,5|1,2,5",
-        "--conjuncts-spec",
-        "0:v0,c3;0:v1,c3;1:v0,v1,c5",
-    ]);
+        r#"[{"arity":2,"tuples":[[0,3],[1,3]]},{"arity":3,"tuples":[[0,1,5],[1,2,5]]}]"#,
+        "--conjuncts",
+        r#"[[0,[{"Variable":0},{"Constant":3}]],[0,[{"Variable":1},{"Constant":3}]],[1,[{"Variable":0},{"Variable":1},{"Constant":5}]]]"#,
+    ]).expect("create command parses");
 
     let Commands::Create(args) = cli.command else {
         panic!("expected create command");
     };
 
     let (data, variant) = create_schema_driven(&args, "ConjunctiveBooleanQuery", &BTreeMap::new())
-        .expect("schema-driven create should parse")
-        .expect("schema-driven path should support CBQ");
+        .expect("schema-driven create should parse");
 
     let entry =
         problemreductions::registry::find_variant_entry("ConjunctiveBooleanQuery", &variant)
@@ -242,42 +331,64 @@ fn test_create_schema_driven_builds_conjunctive_boolean_query() {
 }
 
 #[test]
-fn test_create_schema_driven_builds_closest_vector_problem_with_default_bounds() {
-    let cli = Cli::parse_from([
+fn test_create_schema_driven_builds_integer_target_closest_vector_problem() {
+    let cli = Cli::try_parse_from([
         "pred",
         "create",
         "CVP",
         "--basis",
         "1,0;0,1",
         "--target-vec",
-        "0.5,0.5",
-    ]);
+        "1,2",
+    ])
+    .expect("create command parses");
 
     let Commands::Create(args) = cli.command else {
         panic!("expected create command");
     };
 
-    let resolved_variant = variant_map(&[("weight", "i32")]);
+    let resolved_variant = BTreeMap::from([("target".to_string(), "i64".to_string())]);
     let (data, variant) = create_schema_driven(&args, "ClosestVectorProblem", &resolved_variant)
-        .expect("schema-driven create should parse")
-        .expect("schema-driven path should support CVP");
+        .expect("schema-driven create should parse");
 
     let entry = problemreductions::registry::find_variant_entry("ClosestVectorProblem", &variant)
         .expect("variant entry");
     (entry.factory)(data.clone()).expect("factory should deserialize generated JSON");
     assert_eq!(data["basis"], serde_json::json!([[1, 0], [0, 1]]));
-    assert_eq!(
-        data["bounds"],
-        serde_json::json!([
-            {"lower": -10, "upper": 10},
-            {"lower": -10, "upper": 10},
-        ])
-    );
+    assert_eq!(data["target"], serde_json::json!([1, 2]));
+    assert!(data.get("bounds").is_none());
+}
+
+#[test]
+fn test_create_schema_driven_builds_real_target_closest_vector_problem() {
+    let cli = Cli::try_parse_from([
+        "pred",
+        "create",
+        "CVP",
+        "--basis",
+        "1,0;0,1",
+        "--target-vec",
+        "0.5,1.25",
+    ])
+    .expect("create command parses");
+
+    let Commands::Create(args) = cli.command else {
+        panic!("expected create command");
+    };
+
+    let resolved_variant = BTreeMap::from([("target".to_string(), "f64".to_string())]);
+    let (data, variant) = create_schema_driven(&args, "ClosestVectorProblem", &resolved_variant)
+        .expect("schema-driven create should parse");
+    let entry = problemreductions::registry::find_variant_entry("ClosestVectorProblem", &variant)
+        .expect("variant entry");
+    (entry.factory)(data.clone()).expect("factory should deserialize generated JSON");
+    assert_eq!(data["basis"], serde_json::json!([[1, 0], [0, 1]]));
+    assert_eq!(data["target"], serde_json::json!([0.5, 1.25]));
 }
 
 #[test]
 fn test_create_schema_driven_builds_cdft() {
-    let cli = Cli::parse_from([
+    let cli = Cli::try_parse_from([
         "pred",
         "create",
         "ConsistencyOfDatabaseFrequencyTables",
@@ -286,10 +397,10 @@ fn test_create_schema_driven_builds_cdft() {
         "--attribute-domains",
         "2,3,2",
         "--frequency-tables",
-        "0,1:1,1,1|1,1,1;1,2:1,1|0,2|1,1",
+        r#"[{"attribute_a":0,"attribute_b":1,"counts":[[1,1,1],[1,1,1]]},{"attribute_a":1,"attribute_b":2,"counts":[[1,1],[0,2],[1,1]]}]"#,
         "--known-values",
-        "0,0,0;3,0,1;1,2,1",
-    ]);
+        r#"[{"object":0,"attribute":0,"value":0},{"object":3,"attribute":0,"value":1},{"object":1,"attribute":2,"value":1}]"#,
+    ]).expect("create command parses");
 
     let Commands::Create(args) = cli.command else {
         panic!("expected create command");
@@ -300,8 +411,7 @@ fn test_create_schema_driven_builds_cdft() {
         "ConsistencyOfDatabaseFrequencyTables",
         &BTreeMap::new(),
     )
-    .expect("schema-driven create should parse")
-    .expect("schema-driven path should support CDFT");
+    .expect("schema-driven create should parse");
 
     let entry = problemreductions::registry::find_variant_entry(
         "ConsistencyOfDatabaseFrequencyTables",
@@ -316,7 +426,7 @@ fn test_create_schema_driven_builds_cdft() {
 
 #[test]
 fn test_create_schema_driven_builds_balanced_complete_bipartite_subgraph() {
-    let cli = Cli::parse_from([
+    let cli = Cli::try_parse_from([
         "pred",
         "create",
         "BalancedCompleteBipartiteSubgraph",
@@ -328,7 +438,8 @@ fn test_create_schema_driven_builds_balanced_complete_bipartite_subgraph() {
         "0-0,0-1,0-2,1-0,1-1,1-2,2-0,2-1,2-2,3-0,3-1,3-3",
         "--k",
         "3",
-    ]);
+    ])
+    .expect("create command parses");
 
     let Commands::Create(args) = cli.command else {
         panic!("expected create command");
@@ -336,8 +447,7 @@ fn test_create_schema_driven_builds_balanced_complete_bipartite_subgraph() {
 
     let (data, variant) =
         create_schema_driven(&args, "BalancedCompleteBipartiteSubgraph", &BTreeMap::new())
-            .expect("schema-driven create should parse")
-            .expect("schema-driven path should support balanced biclique");
+            .expect("schema-driven create should parse");
 
     let entry = problemreductions::registry::find_variant_entry(
         "BalancedCompleteBipartiteSubgraph",
@@ -352,10 +462,10 @@ fn test_create_schema_driven_builds_balanced_complete_bipartite_subgraph() {
 
 #[test]
 fn test_create_schema_driven_builds_mixed_chinese_postman() {
-    let cli = Cli::parse_from([
+    let cli = Cli::try_parse_from([
         "pred",
         "create",
-        "MixedChinesePostman/i32",
+        "MixedChinesePostman/i64",
         "--graph",
         "0-2,1-3,0-4,4-2",
         "--arcs",
@@ -364,16 +474,16 @@ fn test_create_schema_driven_builds_mixed_chinese_postman() {
         "2,3,1,2",
         "--arc-weights",
         "2,3,1,4",
-    ]);
+    ])
+    .expect("create command parses");
 
     let Commands::Create(args) = cli.command else {
         panic!("expected create command");
     };
 
-    let resolved_variant = variant_map(&[("weight", "i32")]);
+    let resolved_variant = BTreeMap::from([("weight".to_string(), "i64".to_string())]);
     let (data, variant) = create_schema_driven(&args, "MixedChinesePostman", &resolved_variant)
-        .expect("schema-driven create should parse")
-        .expect("schema-driven path should support mixed chinese postman");
+        .expect("schema-driven create should parse");
 
     let entry = problemreductions::registry::find_variant_entry("MixedChinesePostman", &variant)
         .expect("variant entry");
@@ -385,22 +495,25 @@ fn test_create_schema_driven_builds_mixed_chinese_postman() {
 
 #[test]
 fn test_create_schema_driven_builds_unit_disk_graph_problem_with_default_radius() {
-    let cli = Cli::parse_from([
+    let cli = Cli::try_parse_from([
         "pred",
         "create",
         "MIS/UnitDiskGraph",
         "--positions",
         "0,0;1,0;0.5,0.8",
-    ]);
+    ])
+    .expect("create command parses");
 
     let Commands::Create(args) = cli.command else {
         panic!("expected create command");
     };
 
-    let resolved_variant = variant_map(&[("graph", "UnitDiskGraph"), ("weight", "One")]);
+    let resolved_variant = BTreeMap::from([
+        ("graph".to_string(), "UnitDiskGraph".to_string()),
+        ("weight".to_string(), "One".to_string()),
+    ]);
     let (data, variant) = create_schema_driven(&args, "MaximumIndependentSet", &resolved_variant)
-        .expect("schema-driven create should parse")
-        .expect("schema-driven path should support UnitDiskGraph variants");
+        .expect("schema-driven create should parse");
 
     let entry = problemreductions::registry::find_variant_entry("MaximumIndependentSet", &variant)
         .expect("variant entry");
@@ -412,52 +525,6 @@ fn test_create_schema_driven_builds_unit_disk_graph_problem_with_default_radius(
     );
 }
 
-#[test]
-fn test_schema_help_example_for_qbf_uses_example_db() {
-    let example = schema_help_example_for("QuantifiedBooleanFormulas", &BTreeMap::new()).unwrap();
-    assert_eq!(
-        example,
-        "--num-vars 2 --quantifiers E,A --clauses \"1,2;1,-2\""
-    );
-}
-
-#[test]
-fn test_schema_help_example_for_cbm_uses_json_matrix_syntax() {
-    let example =
-        schema_help_example_for("ConsecutiveBlockMinimization", &BTreeMap::new()).unwrap();
-    assert!(example.contains("--matrix \"[[false,true,false,false,false,false],[true,false,true,false,false,false],[false,true,false,true,false,false],[false,false,true,false,true,false],[false,false,false,true,false,true],[false,false,false,false,true,false]]\""));
-    assert!(example.contains("--bound-k 6"));
-}
-
-#[test]
-fn test_problem_help_flag_name_uses_bound_for_grouping_by_swapping_budget() {
-    assert_eq!(
-        problem_help_flag_name("GroupingBySwapping", "budget", "usize", false),
-        "bound"
-    );
-}
-
-#[test]
-fn test_problem_help_flag_name_preserves_edge_lengths_for_shortest_weight_constrained_path() {
-    assert_eq!(
-        problem_help_flag_name(
-            "ShortestWeightConstrainedPath",
-            "edge_lengths",
-            "Vec<W>",
-            false
-        ),
-        "edge-lengths"
-    );
-}
-
-#[test]
-fn test_problem_help_flag_name_uses_edge_weights_for_longest_circuit_edge_lengths() {
-    assert_eq!(
-        problem_help_flag_name("LongestCircuit", "edge_lengths", "Vec<W>", false),
-        "edge-weights"
-    );
-}
-
 #[test]
 fn test_ensure_attribute_indices_in_range_rejects_out_of_range_index() {
     let err = ensure_attribute_indices_in_range(&[0, 4], 3, "Functional dependency '0:4' rhs")
@@ -469,7 +536,7 @@ fn test_ensure_attribute_indices_in_range_rejects_out_of_range_index() {
 }
 
 #[test]
-fn test_create_scheduling_with_individual_deadlines_accepts_m_alias() {
+fn test_create_scheduling_with_individual_deadlines_accepts_num_processors() {
     let cli = Cli::try_parse_from([
         "pred",
         "create",
@@ -478,7 +545,7 @@ fn test_create_scheduling_with_individual_deadlines_accepts_m_alias() {
         "3",
         "--deadlines",
         "1,1,2",
-        "--m",
+        "--num-processors",
         "2",
     ])
     .expect("parse create command");
@@ -489,14 +556,13 @@ fn test_create_scheduling_with_individual_deadlines_accepts_m_alias() {
 
     let out = OutputConfig {
         output: Some(
-            std::env::temp_dir()
-                .join("pred_test_create_scheduling_with_individual_deadlines_m_alias.json"),
+            std::env::temp_dir().join("pred_test_create_scheduling_with_individual_deadlines.json"),
         ),
         quiet: true,
         json: false,
         auto_json: false,
     };
-    create(&args, &out).expect("`--m` should satisfy --num-processors alias");
+    create(&args, &out).expect("--num-processors should create the instance");
 
     let created: serde_json::Value =
         serde_json::from_str(&std::fs::read_to_string(out.output.as_ref().unwrap()).unwrap())
@@ -513,7 +579,7 @@ fn test_create_prime_attribute_name_accepts_canonical_flags() {
         "pred",
         "create",
         "PrimeAttributeName",
-        "--universe",
+        "--universe-size",
         "6",
         "--dependencies",
         "0,1>2,3,4,5;2,3>0,1,4,5",
@@ -548,76 +614,6 @@ fn test_create_prime_attribute_name_accepts_canonical_flags() {
     );
 }
 
-#[test]
-fn test_problem_help_uses_prime_attribute_name_cli_overrides() {
-    assert_eq!(
-        problem_help_flag_name("PrimeAttributeName", "num_attributes", "usize", false),
-        "universe"
-    );
-    assert_eq!(
-        problem_help_flag_name(
-            "PrimeAttributeName",
-            "dependencies",
-            "Vec<(Vec<usize>, Vec<usize>)>",
-            false,
-        ),
-        "dependencies"
-    );
-    assert_eq!(
-        problem_help_flag_name("PrimeAttributeName", "query_attribute", "usize", false),
-        "query-attribute"
-    );
-}
-
-#[test]
-fn test_problem_help_uses_problem_specific_lcs_strings_hint() {
-    assert_eq!(
-        help_flag_hint(
-            "LongestCommonSubsequence",
-            "strings",
-            "Vec<Vec<usize>>",
-            None,
-        ),
-        "raw strings: \"ABAC;BACA\" or symbol lists: \"0,1,0;1,0,1\""
-    );
-}
-
-#[test]
-fn test_problem_help_uses_string_to_string_correction_cli_flags() {
-    assert_eq!(
-        problem_help_flag_name("StringToStringCorrection", "source", "Vec<usize>", false),
-        "source-string"
-    );
-    assert_eq!(
-        problem_help_flag_name("StringToStringCorrection", "target", "Vec<usize>", false),
-        "target-string"
-    );
-    assert_eq!(
-        problem_help_flag_name("StringToStringCorrection", "bound", "usize", false),
-        "bound"
-    );
-}
-
-#[test]
-fn test_problem_help_keeps_generic_vec_vec_usize_hint_for_other_models() {
-    assert_eq!(
-        help_flag_hint("SetBasis", "sets", "Vec<Vec<usize>>", None),
-        "semicolon-separated sets: \"0,1;1,2;0,2\""
-    );
-}
-
-#[test]
-fn test_problem_help_uses_k_for_staff_scheduling() {
-    assert_eq!(
-        help_flag_name("StaffScheduling", "shifts_per_schedule"),
-        "k"
-    );
-    assert_eq!(
-        problem_help_flag_name("StaffScheduling", "shifts_per_schedule", "usize", false),
-        "k"
-    );
-}
-
 #[test]
 fn test_parse_bool_rows_reports_generic_invalid_boolean_entry() {
     let err = parse_bool_rows("1,maybe").unwrap_err().to_string();
@@ -797,32 +793,6 @@ fn test_create_staff_scheduling_reports_invalid_schedule_without_panic() {
     );
 }
 
-#[test]
-fn test_problem_help_uses_num_tasks_for_timetable_design() {
-    assert_eq!(
-        problem_help_flag_name("TimetableDesign", "num_tasks", "usize", false),
-        "num-tasks"
-    );
-    assert_eq!(
-        help_flag_hint("TimetableDesign", "craftsman_avail", "Vec<Vec<bool>>", None),
-        "semicolon-separated 0/1 rows: \"1,1,0;0,1,1\""
-    );
-}
-
-#[test]
-fn test_example_for_path_constrained_network_flow_mentions_paths_flag() {
-    let example = example_for("PathConstrainedNetworkFlow", None);
-    assert!(example.contains("--paths"));
-    assert!(example.contains("--requirement"));
-}
-
-#[test]
-fn test_example_for_three_partition_mentions_sizes_and_bound() {
-    let example = example_for("ThreePartition", None);
-    assert!(example.contains("--sizes"));
-    assert!(example.contains("--bound"));
-}
-
 #[test]
 fn test_create_three_partition_outputs_problem_json() {
     let cli = Cli::try_parse_from([
@@ -881,7 +851,7 @@ fn test_create_three_partition_requires_bound() {
     };
 
     let err = create(&args, &out).unwrap_err().to_string();
-    assert!(err.contains("ThreePartition requires --bound"));
+    assert!(err.contains("missing required construction input(s): bound"));
 }
 
 #[test]
@@ -1032,7 +1002,6 @@ fn test_create_timetable_design_reports_invalid_matrix_without_panic() {
         err.contains("--craftsman-avail"),
         "expected timetable matrix validation error, got: {err}"
     );
-    assert!(err.contains("Usage: pred create TimetableDesign"));
 }
 
 #[test]
@@ -1098,7 +1067,9 @@ fn test_create_generalized_hex_requires_sink() {
     };
 
     let err = create(&args, &out).unwrap_err();
-    assert!(err.to_string().contains("GeneralizedHex requires --sink"));
+    assert!(err
+        .to_string()
+        .contains("missing required construction input(s): sink"));
 }
 
 #[test]
@@ -1112,9 +1083,9 @@ fn test_create_capacity_assignment_serializes_problem_json() {
         "CapacityAssignment",
         "--capacities",
         "1,2,3",
-        "--cost-matrix",
+        "--cost",
         "1,3,6;2,4,7;1,2,5",
-        "--delay-matrix",
+        "--delay",
         "8,4,1;7,3,1;6,3,1",
         "--delay-budget",
         "12",
@@ -1241,7 +1212,7 @@ fn test_create_production_planning_requires_all_period_vectors() {
     let err = create(&args, &out).unwrap_err();
     assert!(err
         .to_string()
-        .contains("ProductionPlanning requires --production-costs"));
+        .contains("missing required construction input(s): production_costs"));
 }
 
 #[test]
@@ -1280,7 +1251,7 @@ fn test_create_production_planning_rejects_mismatched_period_lengths() {
     let err = create(&args, &out).unwrap_err();
     assert!(err
         .to_string()
-        .contains("--demands must contain exactly 6 entries"));
+        .contains("demands has 5 entries, expected 6"));
 }
 
 #[test]
@@ -1354,7 +1325,7 @@ fn test_create_longest_path_serializes_problem_json() {
     fs::remove_file(&output).unwrap();
     assert_eq!(json["type"], "LongestPath");
     assert_eq!(json["variant"]["graph"], "SimpleGraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
     assert_eq!(json["data"]["source_vertex"], 0);
     assert_eq!(json["data"]["target_vertex"], 6);
     assert_eq!(
@@ -1420,9 +1391,9 @@ fn test_create_capacity_assignment_rejects_non_monotone_cost_row() {
         "CapacityAssignment",
         "--capacities",
         "1,2,3",
-        "--cost-matrix",
+        "--cost",
         "1,3,2;2,4,7;1,2,5",
-        "--delay-matrix",
+        "--delay",
         "8,4,1;7,3,1;6,3,1",
         "--delay-budget",
         "12",
@@ -1452,9 +1423,9 @@ fn test_create_capacity_assignment_rejects_matrix_width_mismatch() {
         "CapacityAssignment",
         "--capacities",
         "1,2,3",
-        "--cost-matrix",
+        "--cost",
         "1,3;2,4,7;1,2,5",
-        "--delay-matrix",
+        "--delay",
         "8,4,1;7,3,1;6,3,1",
         "--delay-budget",
         "12",
@@ -1504,12 +1475,12 @@ fn test_create_longest_path_requires_edge_lengths() {
     let err = create(&args, &out).unwrap_err();
     assert!(err
         .to_string()
-        .contains("LongestPath requires --edge-lengths"));
+        .contains("missing required construction input(s): edge_lengths"));
 }
 
 #[test]
-fn test_create_longest_path_rejects_weights_flag() {
-    let cli = Cli::try_parse_from([
+fn test_create_longest_path_rejects_unrelated_weights_flag() {
+    let error = Cli::try_parse_from([
         "pred",
         "create",
         "LongestPath",
@@ -1524,22 +1495,9 @@ fn test_create_longest_path_rejects_weights_flag() {
         "--edge-lengths",
         "5,7",
     ])
-    .unwrap();
-    let out = OutputConfig {
-        output: None,
-        quiet: true,
-        json: false,
-        auto_json: false,
-    };
-    let args = match cli.command {
-        Commands::Create(args) => args,
-        _ => unreachable!(),
-    };
-
-    let err = create(&args, &out).unwrap_err();
-    assert!(err
-        .to_string()
-        .contains("LongestPath uses --edge-lengths, not --weights"));
+    .err()
+    .expect("unrelated flag is rejected by Clap");
+    assert_eq!(error.kind(), clap::error::ErrorKind::UnknownArgument);
 }
 
 #[test]
@@ -1574,260 +1532,47 @@ fn test_create_undirected_flow_lower_bounds_requires_lower_bounds() {
     let err = create(&args, &out).unwrap_err();
     assert!(err
         .to_string()
-        .contains("UndirectedFlowLowerBounds requires --lower-bounds"));
+        .contains("missing required construction input(s): lower_bounds"));
 }
 
 fn empty_args() -> CreateArgs {
-    CreateArgs {
-        problem: Some("BiconnectivityAugmentation".to_string()),
-        example: None,
-        example_target: None,
-        example_side: crate::cli::ExampleSide::Source,
-        graph: None,
-        weights: None,
-        edge_weights: None,
-        edge_lengths: None,
-        capacities: None,
-        demands: None,
-        setup_costs: None,
-        production_costs: None,
-        inventory_costs: None,
-        bundle_capacities: None,
-        cost_matrix: None,
-        delay_matrix: None,
-        lower_bounds: None,
-        multipliers: None,
-        source: None,
-        sink: None,
-        requirement: None,
-        num_paths_required: None,
-        paths: None,
-        couplings: None,
-        fields: None,
-        clauses: None,
-        disjuncts: None,
-        num_vars: None,
-        matrix: None,
-        k: None,
-        num_partitions: None,
-        random: false,
-        source_vertex: None,
-        target_vertex: None,
-        num_vertices: None,
-        edge_prob: None,
-        seed: None,
-        target: None,
-        m: None,
-        n: None,
-        positions: None,
-        radius: None,
-        source_1: None,
-        sink_1: None,
-        source_2: None,
-        sink_2: None,
-        requirement_1: None,
-        requirement_2: None,
-        sizes: None,
-        probabilities: None,
-        link_lengths: None,
-        target_point: None,
-        orientation_samples: None,
-        allowed_pairs: None,
-        graph_1: None,
-        graph_2: None,
-        num_vertices_1: None,
-        num_vertices_2: None,
-        contacts_1: None,
-        contacts_2: None,
-        capacity: None,
-        sequence: None,
-        sets: None,
-        r_sets: None,
-        s_sets: None,
-        r_weights: None,
-        s_weights: None,
-        partition: None,
-        partitions: None,
-        bundles: None,
-        universe: None,
-        biedges: None,
-        left: None,
-        right: None,
-        rank: None,
-        basis: None,
-        target_vec: None,
-        bounds: None,
-        release_times: None,
-        lengths: None,
-        terminals: None,
-        terminal_pairs: None,
-        tree: None,
-        required_edges: None,
-        bound: None,
-        latency_bound: None,
-        length_bound: None,
-        weight_bound: None,
-        diameter_bound: None,
-        cost_bound: None,
-        delay_budget: None,
-        pattern: None,
-        strings: None,
-        string: None,
-        arc_costs: None,
-        arcs: None,
-        left_arcs: None,
-        right_arcs: None,
-        values: None,
-        precedences: None,
-        distance_matrix: None,
-        potential_edges: None,
-        budget: None,
-        max_cycle_length: None,
-        candidate_arcs: None,
-        deadlines: None,
-        precedence_pairs: None,
-        task_lengths: None,
-        job_tasks: None,
-        resource_bounds: None,
-        resource_requirements: None,
-        deadline: None,
-        num_processors: None,
-        alphabet_size: None,
-        substring_length: None,
-        deps: None,
-        query: None,
-        dependencies: None,
-        num_attributes: None,
-        source_string: None,
-        target_string: None,
-        schedules: None,
-        requirements: None,
-        num_workers: None,
-        num_periods: None,
-        num_craftsmen: None,
-        num_tasks: None,
-        craftsman_avail: None,
-        task_avail: None,
-        num_groups: None,
-        num_sectors: None,
-        domain_size: None,
-        relations: None,
-        conjuncts_spec: None,
-        relation_attrs: None,
-        known_keys: None,
-        num_objects: None,
-        attribute_domains: None,
-        frequency_tables: None,
-        known_values: None,
-        costs: None,
-        cut_bound: None,
-        size_bound: None,
-        usage: None,
-        storage: None,
-        quantifiers: None,
-        homologous_pairs: None,
-        pointer_cost: None,
-        expression: None,
-        coeff_a: None,
-        coeff_b: None,
-        rhs: None,
-        coeff_c: None,
-        pairs: None,
-        required_columns: None,
-        compilers: None,
-        setup_times: None,
-        w_sizes: None,
-        x_sizes: None,
-        y_sizes: None,
-        equations: None,
-        assignment: None,
-        initial_marking: None,
-        output_arcs: None,
-        gate_types: None,
-        true_sentences: None,
-        implications: None,
-        loop_length: None,
-        loop_variables: None,
-        inputs: None,
-        outputs: None,
-        assignments: None,
-        num_variables: None,
-        truth_table: None,
-        test_matrix: None,
-        num_tests: None,
-        tiles: None,
-        grid_size: None,
-        num_colors: None,
-        vertex_prizes: None,
-        edge_costs: None,
-        beta: None,
-        omega: None,
-    }
+    CreateArgs::for_test("BiconnectivityAugmentation")
 }
-
 #[test]
 fn test_all_data_flags_empty_treats_potential_edges_as_input() {
     let mut args = empty_args();
-    args.potential_edges = Some("0-2:3,1-3:5".to_string());
+    args.insert("potential-weights", "0-2:3,1-3:5".to_string());
     assert!(!all_data_flags_empty(&args));
 }
 
 #[test]
 fn test_all_data_flags_empty_treats_budget_as_input() {
     let mut args = empty_args();
-    args.budget = Some("7".to_string());
+    args.insert("budget", "7".to_string());
     assert!(!all_data_flags_empty(&args));
 }
 
 #[test]
 fn test_all_data_flags_empty_treats_max_cycle_length_as_input() {
     let mut args = empty_args();
-    args.max_cycle_length = Some(4);
+    args.insert("max-cycle-length", 4);
     assert!(!all_data_flags_empty(&args));
 }
 
 #[test]
 fn test_all_data_flags_empty_treats_homologous_pairs_as_input() {
     let mut args = empty_args();
-    args.homologous_pairs = Some("2=5;4=3".to_string());
+    args.insert("homologous-pairs", "2=5;4=3".to_string());
     assert!(!all_data_flags_empty(&args));
 }
 
 #[test]
 fn test_all_data_flags_empty_treats_job_tasks_as_input() {
     let mut args = empty_args();
-    args.job_tasks = Some("0:1,1:1;1:1,0:1".to_string());
+    args.insert("jobs", "0:1,1:1;1:1,0:1".to_string());
     assert!(!all_data_flags_empty(&args));
 }
 
-#[test]
-fn test_parse_potential_edges() {
-    let mut args = empty_args();
-    args.potential_edges = Some("0-2:3,1-3:5".to_string());
-
-    let potential_edges = parse_potential_edges(&args).unwrap();
-
-    assert_eq!(potential_edges, vec![(0, 2, 3), (1, 3, 5)]);
-}
-
-#[test]
-fn test_parse_potential_edges_rejects_missing_weight() {
-    let mut args = empty_args();
-    args.potential_edges = Some("0-2,1-3:5".to_string());
-
-    let err = parse_potential_edges(&args).unwrap_err().to_string();
-
-    assert!(err.contains("u-v:w"));
-}
-
-#[test]
-fn test_parse_budget() {
-    let mut args = empty_args();
-    args.budget = Some("7".to_string());
-
-    assert_eq!(parse_budget(&args).unwrap(), 7);
-}
-
 #[test]
 fn test_create_disjoint_connecting_paths_json() {
     use crate::dispatch::ProblemJsonOutput;
@@ -1835,8 +1580,8 @@ fn test_create_disjoint_connecting_paths_json() {
 
     let mut args = empty_args();
     args.problem = Some("DisjointConnectingPaths".to_string());
-    args.graph = Some("0-1,1-3,0-2,1-4,2-4,3-5,4-5".to_string());
-    args.terminal_pairs = Some("0-3,2-5".to_string());
+    args.insert("graph", "0-1,1-3,0-2,1-4,2-4,3-5,4-5".to_string());
+    args.insert("terminal-pairs", "0-3,2-5".to_string());
 
     let output_path = std::env::temp_dir().join(format!("dcp-create-{}.json", std::process::id()));
     let out = OutputConfig {
@@ -1869,8 +1614,8 @@ fn test_create_disjoint_connecting_paths_json() {
 fn test_create_disjoint_connecting_paths_rejects_overlapping_terminal_pairs() {
     let mut args = empty_args();
     args.problem = Some("DisjointConnectingPaths".to_string());
-    args.graph = Some("0-1,1-2,2-3,3-4".to_string());
-    args.terminal_pairs = Some("0-2,2-4".to_string());
+    args.insert("graph", "0-1,1-2,2-3,3-4".to_string());
+    args.insert("terminal-pairs", "0-2,2-4".to_string());
 
     let out = OutputConfig {
         output: None,
@@ -1883,61 +1628,12 @@ fn test_create_disjoint_connecting_paths_rejects_overlapping_terminal_pairs() {
     assert!(err.contains("pairwise disjoint"));
 }
 
-#[test]
-fn test_parse_homologous_pairs() {
-    let mut args = empty_args();
-    args.homologous_pairs = Some("2=5;4=3".to_string());
-
-    assert_eq!(parse_homologous_pairs(&args).unwrap(), vec![(2, 5), (4, 3)]);
-}
-
-#[test]
-fn test_parse_homologous_pairs_rejects_invalid_token() {
-    let mut args = empty_args();
-    args.homologous_pairs = Some("2-5".to_string());
-
-    let err = parse_homologous_pairs(&args).unwrap_err().to_string();
-
-    assert!(err.contains("u=v"));
-}
-
-#[test]
-fn test_parse_graph_respects_explicit_num_vertices() {
-    let mut args = empty_args();
-    args.graph = Some("0-1".to_string());
-    args.num_vertices = Some(3);
-
-    let (graph, num_vertices) = parse_graph(&args).unwrap();
-
-    assert_eq!(num_vertices, 3);
-    assert_eq!(graph.num_vertices(), 3);
-    assert_eq!(graph.edges(), vec![(0, 1)]);
-}
-
-#[test]
-fn test_validate_potential_edges_rejects_existing_graph_edge() {
-    let err = validate_potential_edges(&SimpleGraph::path(3), &[(0, 1, 5)])
-        .unwrap_err()
-        .to_string();
-
-    assert!(err.contains("already exists in the graph"));
-}
-
-#[test]
-fn test_validate_potential_edges_rejects_duplicate_edges() {
-    let err = validate_potential_edges(&SimpleGraph::path(4), &[(0, 3, 1), (3, 0, 2)])
-        .unwrap_err()
-        .to_string();
-
-    assert!(err.contains("Duplicate potential edge"));
-}
-
 #[test]
 fn test_create_biconnectivity_augmentation_json() {
     let mut args = empty_args();
-    args.graph = Some("0-1,1-2,2-3".to_string());
-    args.potential_edges = Some("0-2:3,0-3:4,1-3:2".to_string());
-    args.budget = Some("5".to_string());
+    args.insert("graph", "0-1,1-2,2-3".to_string());
+    args.insert("potential-weights", "0-2:3,0-3:4,1-3:2".to_string());
+    args.insert("budget", "5".to_string());
 
     let output_path = std::env::temp_dir().join("pred_test_create_biconnectivity.json");
     let out = OutputConfig {
@@ -1964,10 +1660,10 @@ fn test_create_biconnectivity_augmentation_json() {
 #[test]
 fn test_create_biconnectivity_augmentation_json_with_isolated_vertices() {
     let mut args = empty_args();
-    args.graph = Some("0-1".to_string());
-    args.num_vertices = Some(3);
-    args.potential_edges = Some("1-2:1".to_string());
-    args.budget = Some("1".to_string());
+    args.insert("graph", "0-1".to_string());
+    args.insert("num-vertices", 3);
+    args.insert("potential-weights", "1-2:1".to_string());
+    args.insert("budget", "1".to_string());
 
     let output_path = std::env::temp_dir().join("pred_test_create_biconnectivity_isolated.json");
     let out = OutputConfig {
@@ -1981,7 +1677,7 @@ fn test_create_biconnectivity_augmentation_json_with_isolated_vertices() {
 
     let content = std::fs::read_to_string(&output_path).unwrap();
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
-    let problem: BiconnectivityAugmentation<SimpleGraph, i32> =
+    let problem: BiconnectivityAugmentation<SimpleGraph, i64> =
         serde_json::from_value(json["data"].clone()).unwrap();
 
     assert_eq!(problem.num_vertices(), 3);
@@ -1997,9 +1693,9 @@ fn test_create_partial_feedback_edge_set_json() {
 
     let mut args = empty_args();
     args.problem = Some("PartialFeedbackEdgeSet".to_string());
-    args.graph = Some("0-1,1-2,2-0".to_string());
-    args.budget = Some("1".to_string());
-    args.max_cycle_length = Some(3);
+    args.insert("graph", "0-1,1-2,2-0".to_string());
+    args.insert("budget", "1".to_string());
+    args.insert("max-cycle-length", 3);
 
     let output_path = std::env::temp_dir().join("pred_test_create_partial_feedback_edge_set.json");
     let out = OutputConfig {
@@ -2031,8 +1727,8 @@ fn test_create_partial_feedback_edge_set_json() {
 fn test_create_partial_feedback_edge_set_requires_max_cycle_length() {
     let mut args = empty_args();
     args.problem = Some("PartialFeedbackEdgeSet".to_string());
-    args.graph = Some("0-1,1-2,2-0".to_string());
-    args.budget = Some("1".to_string());
+    args.insert("graph", "0-1,1-2,2-0".to_string());
+    args.insert("budget", "1".to_string());
 
     let out = OutputConfig {
         output: None,
@@ -2042,16 +1738,16 @@ fn test_create_partial_feedback_edge_set_requires_max_cycle_length() {
     };
 
     let err = create(&args, &out).unwrap_err().to_string();
-    assert!(err.contains("PartialFeedbackEdgeSet requires --max-cycle-length"));
+    assert!(err.contains("missing required construction input(s): max_cycle_length"));
 }
 
 #[test]
 fn test_create_ensemble_computation_json() {
     let mut args = empty_args();
     args.problem = Some("EnsembleComputation".to_string());
-    args.universe = Some(4);
-    args.sets = Some("0,1,2;0,1,3".to_string());
-    args.budget = Some("4".to_string());
+    args.insert("universe-size", 4);
+    args.insert("subsets", "0,1,2;0,1,3".to_string());
+    args.insert("budget", "4".to_string());
 
     let output_path = std::env::temp_dir().join("pred_test_create_ensemble_computation.json");
     let out = OutputConfig {
@@ -2083,8 +1779,8 @@ fn test_create_expected_retrieval_cost_json() {
 
     let mut args = empty_args();
     args.problem = Some("ExpectedRetrievalCost".to_string());
-    args.probabilities = Some("0.2,0.15,0.15,0.2,0.1,0.2".to_string());
-    args.num_sectors = Some(3);
+    args.insert("probabilities", "0.2,0.15,0.15,0.2,0.1,0.2".to_string());
+    args.insert("num-sectors", 3);
 
     let output_path = std::env::temp_dir().join(format!(
         "expected-retrieval-cost-{}.json",
@@ -2108,7 +1804,7 @@ fn test_create_expected_retrieval_cost_json() {
     assert_eq!(problem.num_sectors(), 3);
     use problemreductions::types::Min;
     assert!(matches!(
-        problem.evaluate(&[0, 1, 2, 1, 0, 2]),
+        problem.evaluate(&vec![0, 1, 2, 1, 0, 2]).unwrap(),
         Min(Some(_))
     ));
 
@@ -2124,7 +1820,10 @@ fn test_create_job_shop_scheduling_json() {
 
     let mut args = empty_args();
     args.problem = Some("JobShopScheduling".to_string());
-    args.job_tasks = Some("0:3,1:4;1:2,0:3,1:2;0:4,1:3;1:5,0:2;0:2,1:3,0:1".to_string());
+    args.insert(
+        "jobs",
+        "0:3,1:4;1:2,0:3,1:2;0:4,1:3;1:5,0:2;0:2,1:3,0:1".to_string(),
+    );
 
     let output_path =
         std::env::temp_dir().join(format!("job-shop-scheduling-{}.json", std::process::id()));
@@ -2146,7 +1845,9 @@ fn test_create_job_shop_scheduling_json() {
     assert_eq!(problem.num_processors(), 2);
     assert_eq!(problem.num_jobs(), 5);
     assert_eq!(
-        problem.evaluate(&[0, 0, 0, 0, 0, 0, 1, 3, 0, 1, 1, 0]),
+        problem
+            .evaluate(&vec![0, 0, 0, 0, 0, 0, 1, 3, 0, 1, 1, 0])
+            .unwrap(),
         Min(Some(19))
     );
 
@@ -2157,7 +1858,7 @@ fn test_create_job_shop_scheduling_json() {
 fn test_create_job_shop_scheduling_requires_job_tasks() {
     let mut args = empty_args();
     args.problem = Some("JobShopScheduling".to_string());
-    args.num_processors = Some(2);
+    args.insert("num-processors", 2);
 
     let out = OutputConfig {
         output: None,
@@ -2167,14 +1868,14 @@ fn test_create_job_shop_scheduling_requires_job_tasks() {
     };
 
     let err = create(&args, &out).unwrap_err().to_string();
-    assert!(err.contains("JobShopScheduling requires --jobs"));
+    assert!(err.contains("missing required construction input(s): jobs"));
 }
 
 #[test]
 fn test_create_job_shop_scheduling_rejects_malformed_operation() {
     let mut args = empty_args();
     args.problem = Some("JobShopScheduling".to_string());
-    args.job_tasks = Some("0-3,1:4".to_string());
+    args.insert("jobs", "0-3,1:4".to_string());
 
     let out = OutputConfig {
         output: None,
@@ -2191,7 +1892,7 @@ fn test_create_job_shop_scheduling_rejects_malformed_operation() {
 fn test_create_job_shop_scheduling_rejects_consecutive_same_processor() {
     let mut args = empty_args();
     args.problem = Some("JobShopScheduling".to_string());
-    args.job_tasks = Some("0:1,0:1".to_string());
+    args.insert("jobs", "0:1,0:1".to_string());
 
     let out = OutputConfig {
         output: None,
@@ -2208,9 +1909,9 @@ fn test_create_job_shop_scheduling_rejects_consecutive_same_processor() {
 fn test_create_rooted_tree_storage_assignment_json() {
     let mut args = empty_args();
     args.problem = Some("RootedTreeStorageAssignment".to_string());
-    args.universe = Some(5);
-    args.sets = Some("0,2;1,3;0,4;2,4".to_string());
-    args.bound = Some(1);
+    args.insert("universe-size", 5);
+    args.insert("subsets", "0,2;1,3;0,4;2,4".to_string());
+    args.insert("bound", 1);
 
     let output_path =
         std::env::temp_dir().join("pred_test_create_rooted_tree_storage_assignment.json");
@@ -2240,11 +1941,11 @@ fn test_create_rooted_tree_storage_assignment_json() {
 fn test_create_stacker_crane_json() {
     let mut args = empty_args();
     args.problem = Some("StackerCrane".to_string());
-    args.num_vertices = Some(6);
-    args.arcs = Some("0>4,2>5,5>1,3>0,4>3".to_string());
-    args.graph = Some("0-1,1-2,2-3,3-5,4-5,0-3,1-5".to_string());
-    args.arc_costs = Some("3,4,2,5,3".to_string());
-    args.edge_lengths = Some("2,1,3,2,1,4,3".to_string());
+    args.insert("num-vertices", 6);
+    args.insert("arcs", "0>4,2>5,5>1,3>0,4>3".to_string());
+    args.insert("graph", "0-1,1-2,2-3,3-5,4-5,0-3,1-5".to_string());
+    args.insert("arc-lengths", "3,4,2,5,3".to_string());
+    args.insert("edge-lengths", "2,1,3,2,1,4,3".to_string());
 
     let output_path = std::env::temp_dir().join("pred_test_create_stacker_crane.json");
     let out = OutputConfig {
@@ -2270,12 +1971,12 @@ fn test_create_stacker_crane_json() {
 fn test_create_stacker_crane_rejects_mismatched_arc_lengths() {
     let mut args = empty_args();
     args.problem = Some("StackerCrane".to_string());
-    args.num_vertices = Some(6);
-    args.arcs = Some("0>4,2>5,5>1,3>0,4>3".to_string());
-    args.graph = Some("0-1,1-2,2-3,3-5,4-5,0-3,1-5".to_string());
-    args.arc_costs = Some("3,4,2,5".to_string());
-    args.edge_lengths = Some("2,1,3,2,1,4,3".to_string());
-    args.bound = Some(20);
+    args.insert("num-vertices", 6);
+    args.insert("arcs", "0>4,2>5,5>1,3>0,4>3".to_string());
+    args.insert("graph", "0-1,1-2,2-3,3-5,4-5,0-3,1-5".to_string());
+    args.insert("arc-lengths", "3,4,2,5".to_string());
+    args.insert("edge-lengths", "2,1,3,2,1,4,3".to_string());
+    args.insert("bound", 20);
 
     let out = OutputConfig {
         output: None,
@@ -2285,19 +1986,18 @@ fn test_create_stacker_crane_rejects_mismatched_arc_lengths() {
     };
 
     let err = create(&args, &out).unwrap_err().to_string();
-    assert!(err.contains("Expected 5 arc costs but got 4"));
+    assert!(err.contains("arc_lengths length must match arcs length"));
 }
 
 #[test]
 fn test_create_stacker_crane_rejects_out_of_range_vertices() {
     let mut args = empty_args();
     args.problem = Some("StackerCrane".to_string());
-    args.num_vertices = Some(5);
-    args.arcs = Some("0>4,2>5,5>1,3>0,4>3".to_string());
-    args.graph = Some("0-1,1-2,2-3,3-5,4-5,0-3,1-5".to_string());
-    args.arc_costs = Some("3,4,2,5,3".to_string());
-    args.edge_lengths = Some("2,1,3,2,1,4,3".to_string());
-    args.bound = Some(20);
+    args.insert("num-vertices", 5);
+    args.insert("arcs", "0>4,2>5,5>1,3>0,4>3".to_string());
+    args.insert("graph", "0-1,1-2,2-3,3-5,4-5,0-3,1-5".to_string());
+    args.insert("arc-lengths", "3,4,2,5,3".to_string());
+    args.insert("edge-lengths", "2,1,3,2,1,4,3".to_string());
 
     let out = OutputConfig {
         output: None,
@@ -2307,7 +2007,7 @@ fn test_create_stacker_crane_rejects_out_of_range_vertices() {
     };
 
     let err = create(&args, &out).unwrap_err().to_string();
-    assert!(err.contains("--num-vertices (5) is too small for the arcs"));
+    assert!(err.contains("num_vertices 5 is too small for the provided endpoints"));
 }
 
 #[test]
@@ -2317,8 +2017,8 @@ fn test_create_minimum_dummy_activities_pert_json() {
 
     let mut args = empty_args();
     args.problem = Some("MinimumDummyActivitiesPert".to_string());
-    args.num_vertices = Some(6);
-    args.arcs = Some("0>2,0>3,1>3,1>4,2>5".to_string());
+    args.insert("num-vertices", 6);
+    args.insert("arcs", "0>2,0>3,1>3,1>4,2>5".to_string());
 
     let output_path = temp_output_path("minimum_dummy_activities_pert");
     let out = OutputConfig {
@@ -2346,8 +2046,8 @@ fn test_create_minimum_dummy_activities_pert_json() {
 fn test_create_minimum_dummy_activities_pert_rejects_cycles() {
     let mut args = empty_args();
     args.problem = Some("MinimumDummyActivitiesPert".to_string());
-    args.num_vertices = Some(3);
-    args.arcs = Some("0>1,1>2,2>0".to_string());
+    args.insert("num-vertices", 3);
+    args.insert("arcs", "0>1,1>2,2>0".to_string());
 
     let out = OutputConfig {
         output: None,
@@ -2367,11 +2067,13 @@ fn test_create_balanced_complete_bipartite_subgraph() {
 
     let mut args = empty_args();
     args.problem = Some("BalancedCompleteBipartiteSubgraph".to_string());
-    args.biedges = Some("0-0,0-1,0-2,1-0,1-1,1-2,2-0,2-1,2-2,3-0,3-1,3-3".to_string());
-    args.left = Some(4);
-    args.right = Some(4);
-    args.k = Some(3);
-    args.graph = None;
+    args.insert(
+        "biedges",
+        "0-0,0-1,0-2,1-0,1-1,1-2,2-0,2-1,2-2,3-0,3-1,3-3".to_string(),
+    );
+    args.insert("left", 4);
+    args.insert("right", 4);
+    args.insert("k", 3);
 
     let output_path = std::env::temp_dir().join(format!("bcbs-create-{}.json", std::process::id()));
     let out = OutputConfig {
@@ -2401,11 +2103,10 @@ fn test_create_balanced_complete_bipartite_subgraph() {
 fn test_create_balanced_complete_bipartite_subgraph_rejects_out_of_range_biedges() {
     let mut args = empty_args();
     args.problem = Some("BalancedCompleteBipartiteSubgraph".to_string());
-    args.biedges = Some("4-0".to_string());
-    args.left = Some(4);
-    args.right = Some(4);
-    args.k = Some(3);
-    args.graph = None;
+    args.insert("biedges", "4-0".to_string());
+    args.insert("left", 4);
+    args.insert("right", 4);
+    args.insert("k", 3);
 
     let out = OutputConfig {
         output: None,
@@ -2425,8 +2126,8 @@ fn test_create_kclique() {
 
     let mut args = empty_args();
     args.problem = Some("KClique".to_string());
-    args.graph = Some("0-1,0-2,1-3,2-3,2-4,3-4".to_string());
-    args.k = Some(3);
+    args.insert("graph", "0-1,0-2,1-3,2-3,2-4,3-4".to_string());
+    args.insert("k", 3);
 
     let output_path =
         std::env::temp_dir().join(format!("kclique-create-{}.json", std::process::id()));
@@ -2450,7 +2151,9 @@ fn test_create_kclique() {
     let problem: KClique<SimpleGraph> = serde_json::from_value(created.data).unwrap();
     assert_eq!(problem.k(), 3);
     assert_eq!(problem.num_vertices(), 5);
-    assert!(problem.evaluate(&[0, 0, 1, 1, 1]));
+    assert!(problem
+        .evaluate(&vec![false, false, true, true, true])
+        .unwrap());
 
     let _ = std::fs::remove_file(output_path);
 }
@@ -2459,8 +2162,7 @@ fn test_create_kclique() {
 fn test_create_kclique_requires_valid_k() {
     let mut args = empty_args();
     args.problem = Some("KClique".to_string());
-    args.graph = Some("0-1,0-2,1-3,2-3,2-4,3-4".to_string());
-    args.k = None;
+    args.insert("graph", "0-1,0-2,1-3,2-3,2-4,3-4".to_string());
 
     let out = OutputConfig {
         output: None,
@@ -2471,11 +2173,12 @@ fn test_create_kclique_requires_valid_k() {
 
     let err = create(&args, &out).unwrap_err();
     assert!(
-        err.to_string().contains("KClique requires --k"),
+        err.to_string()
+            .contains("missing required construction input(s): k"),
         "unexpected error: {err}"
     );
 
-    args.k = Some(6);
+    args.insert("k", 6);
     let err = create(&args, &out).unwrap_err();
     assert!(
         err.to_string().contains("k must be <= graph num_vertices"),
@@ -2489,8 +2192,8 @@ fn test_create_sparse_matrix_compression_json() {
 
     let mut args = empty_args();
     args.problem = Some("SparseMatrixCompression".to_string());
-    args.matrix = Some("1,0,0,1;0,1,0,0;0,0,1,0;1,0,0,0".to_string());
-    args.bound = Some(2);
+    args.insert("matrix", "1,0,0,1;0,1,0,0;0,0,1,0;1,0,0,0".to_string());
+    args.insert("bound-k", 2);
 
     let output_path = std::env::temp_dir().join(format!("smc-create-{}.json", std::process::id()));
     let out = OutputConfig {
@@ -2526,7 +2229,7 @@ fn test_create_sparse_matrix_compression_json() {
 fn test_create_sparse_matrix_compression_requires_bound() {
     let mut args = empty_args();
     args.problem = Some("SparseMatrixCompression".to_string());
-    args.matrix = Some("1,0,0,1;0,1,0,0;0,0,1,0;1,0,0,0".to_string());
+    args.insert("matrix", "1,0,0,1;0,1,0,0;0,0,1,0;1,0,0,0".to_string());
 
     let out = OutputConfig {
         output: None,
@@ -2536,16 +2239,15 @@ fn test_create_sparse_matrix_compression_requires_bound() {
     };
 
     let err = create(&args, &out).unwrap_err().to_string();
-    assert!(err.contains("SparseMatrixCompression requires --matrix and --bound"));
-    assert!(err.contains("Usage: pred create SparseMatrixCompression"));
+    assert!(err.contains("missing required construction input(s): bound_k"));
 }
 
 #[test]
 fn test_create_sparse_matrix_compression_rejects_zero_bound() {
     let mut args = empty_args();
     args.problem = Some("SparseMatrixCompression".to_string());
-    args.matrix = Some("1,0;0,1".to_string());
-    args.bound = Some(0);
+    args.insert("matrix", "1,0;0,1".to_string());
+    args.insert("bound-k", 0);
 
     let out = OutputConfig {
         output: None,
@@ -2555,47 +2257,7 @@ fn test_create_sparse_matrix_compression_rejects_zero_bound() {
     };
 
     let err = create(&args, &out).unwrap_err().to_string();
-    assert!(err.contains("bound >= 1"));
-}
-
-#[test]
-fn test_create_graph_partitioning_with_num_partitions() {
-    use crate::dispatch::ProblemJsonOutput;
-    use problemreductions::models::graph::GraphPartitioning;
-    use problemreductions::topology::SimpleGraph;
-
-    let cli = Cli::try_parse_from([
-        "pred",
-        "create",
-        "GraphPartitioning",
-        "--graph",
-        "0-1,1-2,2-3,3-0",
-        "--num-partitions",
-        "2",
-    ])
-    .unwrap();
-    let args = match cli.command {
-        Commands::Create(args) => args,
-        _ => unreachable!(),
-    };
-
-    let output_path = temp_output_path("graph-partitioning-create");
-    let out = OutputConfig {
-        output: Some(output_path.clone()),
-        quiet: true,
-        json: false,
-        auto_json: false,
-    };
-
-    create(&args, &out).unwrap();
-
-    let json = fs::read_to_string(&output_path).unwrap();
-    let created: ProblemJsonOutput = serde_json::from_str(&json).unwrap();
-    assert_eq!(created.problem_type, "GraphPartitioning");
-    let problem: GraphPartitioning<SimpleGraph> = serde_json::from_value(created.data).unwrap();
-    assert_eq!(problem.num_vertices(), 4);
-
-    let _ = fs::remove_file(output_path);
+    assert!(err.contains("bound_k must be positive"));
 }
 
 #[test]
@@ -2643,8 +2305,11 @@ fn test_create_consecutive_ones_matrix_augmentation_json() {
 
     let mut args = empty_args();
     args.problem = Some("ConsecutiveOnesMatrixAugmentation".to_string());
-    args.matrix = Some("1,0,0,1,1;1,1,0,0,0;0,1,1,0,1;0,0,1,1,0".to_string());
-    args.bound = Some(2);
+    args.insert(
+        "matrix",
+        "1,0,0,1,1;1,1,0,0,0;0,1,1,0,1;0,0,1,1,0".to_string(),
+    );
+    args.insert("bound", 2);
 
     let output_path = std::env::temp_dir().join(format!("coma-create-{}.json", std::process::id()));
     let out = OutputConfig {
@@ -2680,7 +2345,7 @@ fn test_create_consecutive_ones_matrix_augmentation_json() {
 fn test_create_consecutive_ones_matrix_augmentation_requires_bound() {
     let mut args = empty_args();
     args.problem = Some("ConsecutiveOnesMatrixAugmentation".to_string());
-    args.matrix = Some("1,0;0,1".to_string());
+    args.insert("matrix", "1,0;0,1".to_string());
 
     let out = OutputConfig {
         output: None,
@@ -2690,16 +2355,15 @@ fn test_create_consecutive_ones_matrix_augmentation_requires_bound() {
     };
 
     let err = create(&args, &out).unwrap_err().to_string();
-    assert!(err.contains("ConsecutiveOnesMatrixAugmentation requires --matrix and --bound"));
-    assert!(err.contains("Usage: pred create ConsecutiveOnesMatrixAugmentation"));
+    assert!(err.contains("missing required construction input(s): bound"));
 }
 
 #[test]
 fn test_create_consecutive_ones_matrix_augmentation_negative_bound() {
     let mut args = empty_args();
     args.problem = Some("ConsecutiveOnesMatrixAugmentation".to_string());
-    args.matrix = Some("1,0;0,1".to_string());
-    args.bound = Some(-1);
+    args.insert("matrix", "1,0;0,1".to_string());
+    args.insert("bound", -1);
 
     let out = OutputConfig {
         output: None,
diff --git a/problemreductions-cli/src/commands/evaluate.rs b/problemreductions-cli/src/commands/evaluate.rs
index 563b848e1..7ce07cadf 100644
--- a/problemreductions-cli/src/commands/evaluate.rs
+++ b/problemreductions-cli/src/commands/evaluate.rs
@@ -25,41 +25,19 @@ pub fn evaluate(input: &Path, config_str: &str, out: &OutputConfig) -> Result<()
         problem_json.data,
     )?;
 
-    let config: Vec<usize> = config_str
-        .split(',')
-        .map(|s| {
-            s.trim()
-                .parse::<usize>()
-                .map_err(|e| anyhow::anyhow!("Invalid config value '{}': {}", s.trim(), e))
-        })
-        .collect::<Result<Vec<_>>>()?;
-
-    let dims = problem.dims_dyn();
-    if config.len() != dims.len() {
-        anyhow::bail!(
-            "Config has {} values but problem has {} variables",
-            config.len(),
-            dims.len()
-        );
-    }
-
-    for (i, (val, dim)) in config.iter().zip(dims.iter()).enumerate() {
-        if *val >= *dim {
-            anyhow::bail!(
-                "Config value {} at position {} is out of range: variable {} has {} possible values (0..{})",
-                val, i, i, dim, dim.saturating_sub(1)
-            );
-        }
-    }
-
-    let result = problem.evaluate_dyn(&config);
-
-    let text = result.to_string();
-    let json = serde_json::json!({
-        "problem": problem.problem_name(),
-        "config": config,
-        "result": result,
-    });
-
-    out.emit_with_default_name("pred_evaluate.json", &text, &json)
+    let config: serde_json::Value =
+        serde_json::from_str(config_str).context("Config is not valid JSON")?;
+
+    let result = problem.evaluate_dyn(&config)?;
+
+    out.emit(
+        || result.to_string(),
+        || {
+            Ok(serde_json::json!({
+                "problem": problem.problem_name(),
+                "config": config,
+                "result": result,
+            }))
+        },
+    )
 }
diff --git a/problemreductions-cli/src/commands/extract.rs b/problemreductions-cli/src/commands/extract.rs
index 18f12c377..79736a984 100644
--- a/problemreductions-cli/src/commands/extract.rs
+++ b/problemreductions-cli/src/commands/extract.rs
@@ -25,63 +25,37 @@ pub fn extract(input: &Path, config_str: &str, out: &OutputConfig) -> Result<()>
     let bundle: ReductionBundle =
         serde_json::from_value(json).context("Failed to parse reduction bundle")?;
 
-    // An empty --config means an empty target configuration (zero-variable target problem).
-    let target_config: Vec<usize> = if config_str.trim().is_empty() {
-        Vec::new()
-    } else {
-        config_str
-            .split(',')
-            .map(|s| {
-                s.trim()
-                    .parse::<usize>()
-                    .map_err(|e| anyhow::anyhow!("Invalid config value '{}': {}", s.trim(), e))
-            })
-            .collect::<Result<Vec<_>>>()?
-    };
+    let target_config: serde_json::Value =
+        serde_json::from_str(config_str).context("Target config is not valid JSON")?;
 
     let replay = BundleReplay::prepare(&bundle)?;
 
-    let target_dims = replay.target.dims_dyn();
-    if target_config.len() != target_dims.len() {
-        anyhow::bail!(
-            "Target config has {} values but target problem {} has {} variables",
-            target_config.len(),
-            replay.target_name,
-            target_dims.len()
-        );
-    }
-    for (i, (val, dim)) in target_config.iter().zip(target_dims.iter()).enumerate() {
-        if *val >= *dim {
-            anyhow::bail!(
-                "Target config value {} at position {} is out of range: variable {} has {} possible values (0..{})",
-                val, i, i, dim, dim.saturating_sub(1)
-            );
-        }
-    }
-    let target_eval = replay.target.evaluate_dyn(&target_config);
+    let target_eval = replay.target.evaluate_dyn(&target_config)?;
 
-    let (source_config, source_eval) = replay.extract(&target_config);
+    let (source_config, source_eval) = replay.extract(&target_config)?;
 
-    let text = format!(
-        "Problem: {}\nSolver: external (via {})\nSolution: {:?}\nEvaluation: {}",
-        replay.source_name, replay.target_name, source_config, source_eval,
-    );
-
-    // Schema aligned with `pred solve` on a bundle: `problem`, `reduced_to`, `solution`,
-    // `evaluation`, `intermediate { problem, solution, evaluation }`. `solver` is "external"
-    // to signal that pred did not run a solver — the target config came from outside.
-    let json = serde_json::json!({
-        "problem": replay.source_name,
-        "solver": "external",
-        "reduced_to": replay.target_name,
-        "solution": source_config,
-        "evaluation": source_eval,
-        "intermediate": {
-            "problem": replay.target_name,
-            "solution": target_config,
-            "evaluation": target_eval,
+    out.emit(
+        || {
+            format!(
+                "Problem: {}\nSolver: external (via {})\nSolution: {:?}\nEvaluation: {}",
+                replay.source_name, replay.target_name, source_config, source_eval,
+            )
         },
-    });
-
-    out.emit_with_default_name("pred_extract.json", &text, &json)
+        || {
+            // Schema aligned with `pred solve` on a bundle. `solver` is "external"
+            // because pred did not run the solver that produced the target config.
+            Ok(serde_json::json!({
+                "problem": replay.source_name,
+                "solver": "external",
+                "reduced_to": replay.target_name,
+                "solution": source_config,
+                "evaluation": source_eval,
+                "intermediate": {
+                    "problem": replay.target_name,
+                    "solution": target_config,
+                    "evaluation": target_eval,
+                },
+            }))
+        },
+    )
 }
diff --git a/problemreductions-cli/src/commands/graph.rs b/problemreductions-cli/src/commands/graph.rs
index f37940725..465b740a4 100644
--- a/problemreductions-cli/src/commands/graph.rs
+++ b/problemreductions-cli/src/commands/graph.rs
@@ -1,23 +1,71 @@
+use crate::dispatch::{load_problem, read_input, ProblemJson};
 use crate::output::OutputConfig;
 use crate::problem_name::{aliases_for, parse_problem_spec, resolve_problem_ref};
-use anyhow::{Context, Result};
+use anyhow::Result;
 use problemreductions::registry::collect_schemas;
-use problemreductions::rules::{Minimize, MinimizeSteps, ReductionGraph, TraversalFlow};
-use problemreductions::types::ProblemSize;
-use problemreductions::{big_o_normal_form, Expr};
+use problemreductions::registry::ProblemCategory;
+use problemreductions::rules::{ExecutedPath, ReductionGraph, ReductionPath, TraversalFlow};
+use problemreductions::{Expr, Growth};
+use std::any::Any;
 use std::collections::BTreeMap;
+use std::path::Path;
 
-pub fn list(out: &OutputConfig) -> Result<()> {
+pub fn list(
+    query: Option<&str>,
+    category: Option<ProblemCategory>,
+    all: bool,
+    verbose: bool,
+    out: &OutputConfig,
+) -> Result<()> {
     use crate::output::{format_table, Align};
 
-    let graph = ReductionGraph::new();
-
-    let mut types = graph.problem_types();
-    types.sort();
+    let needs_variant_rows = verbose || out.json || out.output.is_some();
+    let catalog = problemreductions::registry::problem_types();
+    let mut variant_aliases = BTreeMap::<&str, Vec<&str>>::new();
+    let mut variant_counts = BTreeMap::<&str, usize>::new();
+    let mut aliases_by_variant =
+        BTreeMap::<&str, BTreeMap<BTreeMap<String, String>, &'static [&'static str]>>::new();
+    for entry in problemreductions::registry::variant_entries() {
+        variant_aliases
+            .entry(entry.name)
+            .or_default()
+            .extend(entry.aliases);
+        *variant_counts.entry(entry.name).or_default() += 1;
+        if needs_variant_rows {
+            aliases_by_variant
+                .entry(entry.name)
+                .or_default()
+                .insert(entry.variant_map(), entry.aliases);
+        }
+    }
+    let query = query.map(str::to_lowercase);
+    let selected = catalog
+        .iter()
+        .filter(|problem| {
+            category.is_none_or(|wanted| problem.category == wanted)
+                && query.as_ref().is_none_or(|needle| {
+                    problem.canonical_name.to_lowercase().contains(needle)
+                        || problem.display_name.to_lowercase().contains(needle)
+                        || problem
+                            .aliases
+                            .iter()
+                            .any(|alias| alias.to_lowercase().contains(needle))
+                        || variant_aliases
+                            .get(problem.canonical_name)
+                            .is_some_and(|aliases| {
+                                aliases
+                                    .iter()
+                                    .any(|alias| alias.to_lowercase().contains(needle))
+                            })
+                })
+        })
+        .collect::<Vec<_>>();
+    let graph = needs_variant_rows.then(ReductionGraph::new);
+    let num_reductions = problemreductions::rules::registry::reduction_entries().len();
 
     // Collect data: one row per variant, grouped by problem type.
     struct VariantRow {
-        /// Full problem/variant name (e.g., "MIS/SimpleGraph/i32")
+        /// Full problem/variant name (e.g., "MIS/SimpleGraph/i64")
         display: String,
         /// Aliases (shown only on first variant of each problem)
         aliases: String,
@@ -27,60 +75,62 @@ pub fn list(out: &OutputConfig) -> Result<()> {
         rules: usize,
         /// Best-known complexity
         complexity: String,
+        category: ProblemCategory,
     }
 
     let mut rows_data: Vec<VariantRow> = Vec::new();
-    for name in &types {
-        let variants = graph.variants_for(name);
-        let default_variant = graph.default_variant_for(name);
-        let problem_aliases = aliases_for(name);
-
-        for (i, v) in variants.iter().enumerate() {
-            let slash = variant_to_full_slash(v);
-            let display = if slash.is_empty() {
-                name.to_string()
-            } else {
-                format!("{name}{slash}")
-            };
-            let is_default = default_variant.as_ref() == Some(v);
+    if let Some(graph) = &graph {
+        for problem in &selected {
+            let name = problem.canonical_name;
+            let variants = graph.variants_for(name);
+            let default_variant = graph.default_variant_for(name);
+            let problem_aliases = aliases_for(name);
             let rules = graph.outgoing_reductions(name).len();
-            let complexity = graph
-                .variant_complexity(name, v)
-                .map(|c| big_o_of(&Expr::parse(c)))
-                .unwrap_or_default();
-
-            // Per-row aliases: problem-level aliases on the first row, plus any
-            // variant-level aliases attached to the specific reduction-graph node.
-            let variant_aliases: Vec<&'static str> =
-                problemreductions::registry::find_variant_entry(name, v)
-                    .map(|entry| entry.aliases.to_vec())
+
+            for (i, v) in variants.iter().enumerate() {
+                let slash = variant_to_full_slash(name, v);
+                let display = if slash.is_empty() {
+                    name.to_string()
+                } else {
+                    format!("{name}{slash}")
+                };
+                let is_default = default_variant.as_ref() == Some(v);
+                let complexity = graph
+                    .variant_complexity(name, v)
+                    .map(|c| big_o_of(&Expr::parse(c)))
                     .unwrap_or_default();
-            let mut parts: Vec<String> = Vec::new();
-            if i == 0 {
-                for alias in &problem_aliases {
-                    push_alias_part(&mut parts, alias);
+
+                let mut parts: Vec<String> = Vec::new();
+                if i == 0 {
+                    for alias in &problem_aliases {
+                        push_alias_part(&mut parts, alias);
+                    }
+                }
+                if let Some(aliases) = aliases_by_variant
+                    .get(name)
+                    .and_then(|by_variant| by_variant.get(v))
+                {
+                    for alias in *aliases {
+                        push_alias_part(&mut parts, alias);
+                    }
                 }
-            }
-            for alias in &variant_aliases {
-                push_alias_part(&mut parts, alias);
-            }
 
-            rows_data.push(VariantRow {
-                display,
-                aliases: parts.join(", "),
-                is_default,
-                rules: if i == 0 { rules } else { 0 },
-                complexity,
-            });
+                rows_data.push(VariantRow {
+                    display,
+                    aliases: parts.join(", "),
+                    is_default,
+                    rules: if i == 0 { rules } else { 0 },
+                    complexity,
+                    category: problem.category,
+                });
+            }
         }
     }
 
-    let summary = format!(
-        "Registered problems: {} types, {} reductions, {} variant nodes\n",
-        graph.num_types(),
-        graph.num_reductions(),
-        graph.num_variant_nodes(),
-    );
+    let mut category_counts = BTreeMap::new();
+    for problem in &catalog {
+        *category_counts.entry(problem.category).or_insert(0usize) += 1;
+    }
 
     let columns: Vec<(&str, Align, usize)> = vec![
         ("Problem", Align::Left, 7),
@@ -113,34 +163,120 @@ pub fn list(out: &OutputConfig) -> Result<()> {
     let color_fns: Vec<Option<crate::output::CellFormatter>> =
         vec![Some(crate::output::fmt_problem_name), None, None, None];
 
-    let mut text = String::new();
-    text.push_str(&crate::output::fmt_section(&summary));
-    text.push('\n');
-    text.push_str(&format_table(&columns, &rows, &color_fns));
-    text.push_str("\n* = default variant\n");
-    text.push_str("Use `pred show <problem>` to see reductions and fields.\n");
-
-    let json = serde_json::json!({
-        "num_types": graph.num_types(),
-        "num_reductions": graph.num_reductions(),
-        "num_variant_nodes": graph.num_variant_nodes(),
-        "variants": rows_data.iter().map(|r| {
-            serde_json::json!({
-                "name": r.display,
-                "aliases": r.aliases,
-                "default": r.is_default,
-                "rules": r.rules,
-                "complexity": r.complexity,
-            })
-        }).collect::<Vec<_>>(),
-    });
-
-    out.emit_with_default_name("pred_graph_list.json", &text, &json)
+    let expanded = all || query.is_some() || category.is_some() || verbose;
+    out.emit(
+        || {
+            let mut text = format!(
+                "{}\n\n",
+                crate::output::fmt_section(&format!(
+                    "Registered catalog: {} problem types, {} variant nodes, {} reduction rules",
+                    catalog.len(),
+                    variant_counts.values().sum::<usize>(),
+                    num_reductions,
+                ))
+            );
+            if expanded {
+                if selected.is_empty() {
+                    text.push_str("No matching problem types.\n");
+                } else if verbose {
+                    text.push_str(&format_table(&columns, &rows, &color_fns));
+                    text.push_str("\n* = default variant\n");
+                } else {
+                    let compact_rows = selected
+                        .iter()
+                        .map(|problem| {
+                            let mut aliases = problem.aliases.to_vec();
+                            if let Some(extra) = variant_aliases.get(problem.canonical_name) {
+                                for alias in extra {
+                                    if !aliases
+                                        .iter()
+                                        .any(|known| known.eq_ignore_ascii_case(alias))
+                                    {
+                                        aliases.push(alias);
+                                    }
+                                }
+                            }
+                            vec![
+                                problem.canonical_name.to_string(),
+                                aliases.join(", "),
+                                problem.category.to_string(),
+                                variant_counts
+                                    .get(problem.canonical_name)
+                                    .copied()
+                                    .unwrap_or_default()
+                                    .to_string(),
+                            ]
+                        })
+                        .collect::<Vec<_>>();
+                    text.push_str(&format_table(
+                        &[
+                            ("Problem", Align::Left, 7),
+                            ("Aliases", Align::Left, 7),
+                            ("Category", Align::Left, 8),
+                            ("Variants", Align::Right, 8),
+                        ],
+                        &compact_rows,
+                        &[Some(crate::output::fmt_problem_name), None, None, None],
+                    ));
+                }
+                text.push_str(
+                    "\nUse `pred show <problem>` for fields, variants, and reductions.\n",
+                );
+            } else {
+                let category_rows = category_counts
+                    .iter()
+                    .map(|(name, count)| vec![name.to_string(), count.to_string()])
+                    .collect::<Vec<_>>();
+                text.push_str(&format_table(
+                    &[("Category", Align::Left, 8), ("Problems", Align::Right, 8)],
+                    &category_rows,
+                    &[None, None],
+                ));
+                text.push_str(
+                    "\nSearch with `pred list <query>`, browse a category with `pred list --category <name>`, or use `pred list --all`.\n",
+                );
+            }
+            text
+        },
+        || {
+            Ok(serde_json::json!({
+                "num_types": selected.len(),
+                "num_reductions": num_reductions,
+                "num_variant_nodes": rows_data.len(),
+                "variants": rows_data.iter().map(|r| {
+                    serde_json::json!({
+                        "name": r.display,
+                        "aliases": r.aliases,
+                        "default": r.is_default,
+                        "rules": r.rules,
+                        "complexity": r.complexity,
+                        "category": r.category,
+                    })
+                }).collect::<Vec<_>>(),
+            }))
+        },
+    )
 }
 
-pub fn list_rules(out: &OutputConfig) -> Result<()> {
+pub fn list_rules(query: Option<&str>, all: bool, verbose: bool, out: &OutputConfig) -> Result<()> {
     use crate::output::{format_table, Align};
 
+    let num_registered = problemreductions::rules::registry::reduction_entries().len();
+    let expanded = all || query.is_some() || verbose || out.json || out.output.is_some();
+    if !expanded {
+        return out.emit(
+            || {
+                format!(
+                    "{}\n\nSearch with `pred list --rules <query>` or use `pred list --rules --all`. Add `--verbose` for parameter contracts.\n",
+                    crate::output::fmt_section(&format!(
+                        "Registered reduction rules: {num_registered}"
+                    ))
+                )
+            },
+            || Ok(serde_json::json!({ "num_rules": num_registered, "rules": [] })),
+        );
+    }
+
     let graph = ReductionGraph::new();
 
     let mut types = graph.problem_types();
@@ -149,34 +285,79 @@ pub fn list_rules(out: &OutputConfig) -> Result<()> {
     struct RuleRow {
         source: String,
         target: String,
-        overhead: String,
+        parameter_contract: String,
     }
 
     let mut rows_data: Vec<RuleRow> = Vec::new();
     for name in &types {
         for edge in graph.outgoing_reductions(name) {
-            let source_slash = variant_to_full_slash(&edge.source_variant);
-            let target_slash = variant_to_full_slash(&edge.target_variant);
-            let oh_parts = fmt_overhead_parts(&edge.overhead.output_size);
+            let source_slash = variant_to_full_slash(edge.source_name, &edge.source_variant);
+            let target_slash = variant_to_full_slash(edge.target_name, &edge.target_variant);
+            let contract_parts = fmt_parameter_contract(&edge.parameter_contract);
             rows_data.push(RuleRow {
                 source: format!("{}{}", edge.source_name, source_slash),
                 target: format!("{}{}", edge.target_name, target_slash),
-                overhead: oh_parts.join(", "),
+                parameter_contract: contract_parts.join(", "),
             });
         }
     }
 
-    let summary = format!("Registered reduction rules: {}\n", rows_data.len());
+    let query = query.map(str::to_lowercase);
+    let alias_matches = query
+        .as_ref()
+        .map(|needle| {
+            problemreductions::registry::variant_entries()
+                .into_iter()
+                .filter(|entry| {
+                    entry
+                        .aliases
+                        .iter()
+                        .any(|alias| alias.to_lowercase().contains(needle))
+                })
+                .map(|entry| entry.name.to_lowercase())
+                .chain(
+                    problemreductions::registry::problem_types()
+                        .into_iter()
+                        .filter(|problem| {
+                            problem
+                                .aliases
+                                .iter()
+                                .any(|alias| alias.to_lowercase().contains(needle))
+                        })
+                        .map(|problem| problem.canonical_name.to_lowercase()),
+                )
+                .collect::<std::collections::BTreeSet<_>>()
+        })
+        .unwrap_or_default();
+    let selected = rows_data
+        .iter()
+        .filter(|row| {
+            query.as_ref().is_none_or(|needle| {
+                row.source.to_lowercase().contains(needle)
+                    || row.target.to_lowercase().contains(needle)
+                    || alias_matches.iter().any(|name| {
+                        row.source.to_lowercase().contains(name)
+                            || row.target.to_lowercase().contains(name)
+                    })
+            })
+        })
+        .collect::<Vec<_>>();
 
     let columns: Vec<(&str, Align, usize)> = vec![
         ("Source", Align::Left, 6),
         ("Target", Align::Left, 6),
-        ("Overhead", Align::Left, 8),
+        ("Parameter transform", Align::Left, 8),
     ];
 
-    let rows: Vec<Vec<String>> = rows_data
+    let rows: Vec<Vec<String>> = selected
         .iter()
-        .map(|r| vec![r.source.clone(), r.target.clone(), r.overhead.clone()])
+        .map(|r| {
+            let mut row = vec![r.source.clone(), r.target.clone()];
+            if verbose {
+                row.push(r.parameter_contract.clone());
+            }
+            row
+        })
         .collect();
 
     let color_fns: Vec<Option<crate::output::CellFormatter>> = vec![
@@ -185,24 +366,69 @@ pub fn list_rules(out: &OutputConfig) -> Result<()> {
         None,
     ];
 
-    let mut text = String::new();
-    text.push_str(&crate::output::fmt_section(&summary));
-    text.push('\n');
-    text.push_str(&format_table(&columns, &rows, &color_fns));
-    text.push_str("\nUse `pred show <problem>` for details on a specific problem.\n");
-
-    let json = serde_json::json!({
-        "num_rules": rows_data.len(),
-        "rules": rows_data.iter().map(|r| {
-            serde_json::json!({
-                "source": r.source,
-                "target": r.target,
-                "overhead": r.overhead,
-            })
-        }).collect::<Vec<_>>(),
-    });
+    out.emit(
+        || {
+            let mut text = format!(
+                "{}\n",
+                crate::output::fmt_section(&format!(
+                    "Registered reduction rules: {}",
+                    rows_data.len()
+                ))
+            );
+            if expanded {
+                let compact_columns = if verbose {
+                    columns
+                } else {
+                    vec![("Source", Align::Left, 6), ("Target", Align::Left, 6)]
+                };
+                let compact_colors: Vec<Option<crate::output::CellFormatter>> = if verbose {
+                    color_fns
+                } else {
+                    vec![
+                        Some(crate::output::fmt_problem_name),
+                        Some(crate::output::fmt_problem_name),
+                    ]
+                };
+                text.push('\n');
+                text.push_str(&format_table(&compact_columns, &rows, &compact_colors));
+                text.push_str("\nUse `pred show <problem>` for details on a specific problem.\n");
+            } else {
+                text.push_str(
+                    "\nSearch with `pred list --rules <query>` or use `pred list --rules --all`. Add `--verbose` for parameter contracts.\n",
+                );
+            }
+            text
+        },
+        || {
+            Ok(serde_json::json!({
+                "num_rules": selected.len(),
+                "rules": selected.iter().map(|r| {
+                    serde_json::json!({
+                        "source": r.source,
+                        "target": r.target,
+                        "parameter_contract": r.parameter_contract,
+                    })
+                }).collect::<Vec<_>>(),
+            }))
+        },
+    )
+}
 
-    out.emit_with_default_name("pred_rules_list.json", &text, &json)
+pub(crate) fn construction_inputs(
+    name: &str,
+    variant: &BTreeMap<String, String>,
+) -> Vec<serde_json::Value> {
+    problemreductions::registry::find_variant_entry(name, variant)
+        .expect("resolved variant must be registered")
+        .inputs()
+        .iter()
+        .map(|input| {
+            let mut value = serde_json::json!(input);
+            value["type_name"] =
+                crate::commands::create::resolve_schema_field_type(input.type_name, variant).into();
+            value
+        })
+        .collect()
 }
 
 pub fn show(problem: &str, out: &OutputConfig) -> Result<()> {
@@ -213,56 +439,10 @@ pub fn show(problem: &str, out: &OutputConfig) -> Result<()> {
 
     let default_variant = graph.default_variant_for(name);
     let is_default = default_variant.as_ref() == Some(variant);
-
-    let slash = variant_to_full_slash(variant);
-    let header = format!("{name}{slash}");
-    let mut text = format!("{}\n", crate::output::fmt_problem_name(&header));
-
-    // Show description from schema
     let schemas = collect_schemas();
     let schema = schemas.iter().find(|s| s.name == *name);
-    if let Some(s) = schema {
-        if !s.description.is_empty() {
-            text.push_str(&format!("  {}\n", s.description));
-        }
-    }
-
-    // Show variant info
-    if let Some(c) = graph.variant_complexity(name, variant) {
-        text.push_str(&format!(
-            "  Best Known Complexity: {}\n",
-            big_o_of(&Expr::parse(c))
-        ));
-    }
-
-    // Show fields from schema
-    if let Some(s) = schema {
-        text.push_str(&format!(
-            "\n{}\n",
-            crate::output::fmt_section(&format!("Fields ({}):", s.fields.len()))
-        ));
-        for field in &s.fields {
-            text.push_str(&format!("  {} ({})", field.name, field.type_name));
-            if !field.description.is_empty() {
-                text.push_str(&format!(" -- {}", field.description));
-            }
-            text.push('\n');
-        }
-    }
-
-    // Show size fields (used with `pred path --cost minimize:<field>`)
-    let size_fields = graph.size_field_names(name);
-    if !size_fields.is_empty() {
-        text.push_str(&format!(
-            "\n{}\n",
-            crate::output::fmt_section(&format!("Size fields ({}):", size_fields.len()))
-        ));
-        for f in &size_fields {
-            text.push_str(&format!("  {f}\n"));
-        }
-    }
-
-    // Show reductions filtered to this specific variant
+    let inputs = construction_inputs(name, variant);
+    let parameters = graph.parameter_names(name);
     let outgoing: Vec<_> = graph
         .outgoing_reductions(name)
         .into_iter()
@@ -273,112 +453,244 @@ pub fn show(problem: &str, out: &OutputConfig) -> Result<()> {
         .into_iter()
         .filter(|e| &e.target_variant == variant)
         .collect();
-
-    text.push_str(&format!(
-        "\n{}\n",
-        crate::output::fmt_section(&format!("Outgoing reductions ({}):", outgoing.len()))
-    ));
-    for e in &outgoing {
-        text.push_str(&format!(
-            "  {} {}",
-            crate::output::fmt_outgoing("\u{2192}"),
-            fmt_node(&graph, e.target_name, &e.target_variant),
-        ));
-        let oh_parts = fmt_overhead_parts(&e.overhead.output_size);
-        if !oh_parts.is_empty() {
-            text.push_str(&format!("  ({})", oh_parts.join(", ")));
-        }
-        text.push('\n');
-    }
-
-    text.push_str(&format!(
-        "\n{}\n",
-        crate::output::fmt_section(&format!("Incoming reductions ({}):", incoming.len()))
-    ));
-    for e in &incoming {
-        text.push_str(&format!(
-            "  {} {}",
-            fmt_node(&graph, e.source_name, &e.source_variant),
-            crate::output::fmt_outgoing("\u{2192}"),
-        ));
-        let oh_parts = fmt_overhead_parts(&e.overhead.output_size);
-        if !oh_parts.is_empty() {
-            text.push_str(&format!("  ({})", oh_parts.join(", ")));
-        }
-        text.push('\n');
-    }
-
-    let edge_to_json = |e: &problemreductions::rules::ReductionEdgeInfo| {
-        serde_json::json!({
-            "source": {"name": e.source_name, "variant": e.source_variant},
-            "target": {"name": e.target_name, "variant": e.target_variant},
-            "overhead": overhead_to_json(&e.overhead.output_size),
-        })
-    };
-
     let complexity = graph.variant_complexity(name, variant).unwrap_or("");
-    let mut json = serde_json::json!({
-        "name": name,
-        "variant": variant,
-        "default": is_default,
-        "complexity": complexity,
-        "big_o": if complexity.is_empty() {
-            String::new()
-        } else {
-            big_o_of(&Expr::parse(complexity))
+    out.emit(
+        || {
+            let slash = variant_to_full_slash(name, variant);
+            let header = format!("{name}{slash}");
+            let mut text = format!("{}\n", crate::output::fmt_problem_name(&header));
+            if let Some(schema) = schema {
+                if !schema.description.is_empty() {
+                    text.push_str(&format!("  {}\n", schema.description));
+                }
+            }
+            if !complexity.is_empty() {
+                text.push_str(&format!(
+                    "  Best Known Complexity: {}\n",
+                    big_o_of(&Expr::parse(complexity))
+                ));
+            }
+            text.push_str(&format!(
+                "\n{}\n",
+                crate::output::fmt_section(&format!("Inputs ({}):", inputs.len()))
+            ));
+            for input in &inputs {
+                text.push_str(&format!(
+                    "  {} ({})",
+                    input["name"].as_str().unwrap(),
+                    input["type_name"].as_str().unwrap()
+                ));
+                if !input["required"].as_bool().unwrap() {
+                    text.push_str(" [optional]");
+                }
+                let description = input["description"].as_str().unwrap();
+                if !description.is_empty() {
+                    text.push_str(&format!(" -- {description}"));
+                }
+                text.push('\n');
+            }
+            if !parameters.is_empty() {
+                text.push_str(&format!(
+                    "\n{}\n",
+                    crate::output::fmt_section(&format!("Parameters ({}):", parameters.len()))
+                ));
+                for field in &parameters {
+                    text.push_str(&format!("  {field}\n"));
+                }
+            }
+            text.push_str(&format!(
+                "\n{}\n",
+                crate::output::fmt_section(&format!("Outgoing reductions ({}):", outgoing.len()))
+            ));
+            for edge in &outgoing {
+                text.push_str(&format!(
+                    "  {} {}",
+                    crate::output::fmt_outgoing("\u{2192}"),
+                    fmt_node(&graph, edge.target_name, &edge.target_variant),
+                ));
+                let contract_parts = fmt_parameter_contract(&edge.parameter_contract);
+                if !contract_parts.is_empty() {
+                    text.push_str(&format!("  ({})", contract_parts.join(", ")));
+                }
+                text.push('\n');
+            }
+            text.push_str(&format!(
+                "\n{}\n",
+                crate::output::fmt_section(&format!("Incoming reductions ({}):", incoming.len()))
+            ));
+            for edge in &incoming {
+                text.push_str(&format!(
+                    "  {} {}",
+                    fmt_node(&graph, edge.source_name, &edge.source_variant),
+                    crate::output::fmt_outgoing("\u{2192}"),
+                ));
+                let contract_parts = fmt_parameter_contract(&edge.parameter_contract);
+                if !contract_parts.is_empty() {
+                    text.push_str(&format!("  ({})", contract_parts.join(", ")));
+                }
+                text.push('\n');
+            }
+            text
         },
-        "size_fields": size_fields,
-        "reduces_to": outgoing.iter().map(&edge_to_json).collect::<Vec<_>>(),
-        "reduces_from": incoming.iter().map(&edge_to_json).collect::<Vec<_>>(),
-    });
-    if let Some(s) = schema {
-        if let (Some(obj), Ok(schema_val)) = (json.as_object_mut(), serde_json::to_value(s)) {
-            obj.insert("schema".to_string(), schema_val);
-        }
-    }
-
-    let default_name = format!("pred_show_{}.json", name);
-    out.emit_with_default_name(&default_name, &text, &json)
+        || {
+            let edge_to_json = |edge: &problemreductions::rules::ReductionEdgeInfo| {
+                serde_json::json!({
+                    "source": {"name": edge.source_name, "variant": edge.source_variant},
+                    "target": {"name": edge.target_name, "variant": edge.target_variant},
+                    "parameter_contract": parameter_contract_to_json(&edge.parameter_contract),
+                })
+            };
+            let mut json = serde_json::json!({
+                "name": name,
+                "variant": variant,
+                "default": is_default,
+                "complexity": complexity,
+                "big_o": if complexity.is_empty() {
+                    String::new()
+                } else {
+                    big_o_of(&Expr::parse(complexity))
+                },
+                "inputs": inputs,
+                "parameters": parameters,
+                "reduces_to": outgoing.iter().map(&edge_to_json).collect::<Vec<_>>(),
+                "reduces_from": incoming.iter().map(&edge_to_json).collect::<Vec<_>>(),
+            });
+            if let Some(schema) = schema {
+                json["schema"] = serde_json::to_value(schema)?;
+                json["schema"].as_object_mut().unwrap().remove("fields");
+            }
+            Ok(json)
+        },
+    )
 }
 
-/// Format an expression as Big O notation using asymptotic normalization.
-/// Falls back to wrapping the original expression if normalization fails.
+/// Format an expression as Big O notation using the growth domain's canonical
+/// renderer. Bounded classes render as `O(<expr>)`; a growth the domain cannot
+/// bound symbolically (nonlinear exponent / factorial) renders as the honest
+/// `O(?)` marker — never the raw unreduced expression.
 fn big_o_of(expr: &Expr) -> String {
-    match big_o_normal_form(expr) {
-        Ok(norm) => format!("O({})", norm),
-        Err(_) => format!("O({})", expr),
-    }
+    Growth::from_expr(expr).to_big_o()
 }
 
-/// Format overhead fields as `field = O(...)` strings.
-fn fmt_overhead_parts(output_size: &[(&'static str, Expr)]) -> Vec<String> {
-    output_size
-        .iter()
-        .map(|(field, poly)| format!("{field} = {}", big_o_of(poly)))
-        .collect()
+enum StrongestContractRelation<'a> {
+    Exact(&'a Expr),
+    UpperBound(&'a Expr),
+    Unavailable(&'a str),
 }
 
-/// Convert overhead fields to JSON entries with Big O notation.
-fn overhead_to_json(output_size: &[(&'static str, Expr)]) -> Vec<serde_json::Value> {
-    output_size
-        .iter()
-        .map(|(field, poly)| {
-            serde_json::json!({
-                "field": field,
-                "formula": poly.to_string(),
-                "big_o": big_o_of(poly),
-            })
+fn strongest_contract_fields(
+    contract: &problemreductions::rules::ReductionParameterContract,
+) -> BTreeMap<&str, StrongestContractRelation<'_>> {
+    let mut fields = BTreeMap::new();
+    if let Some(transform) = contract.transform() {
+        for (field, expression) in transform.expressions() {
+            let relation = match transform.relation() {
+                problemreductions::parameters::ParameterRelation::Exact => {
+                    StrongestContractRelation::Exact(expression)
+                }
+                problemreductions::parameters::ParameterRelation::UpperBound => {
+                    StrongestContractRelation::UpperBound(expression)
+                }
+            };
+            fields.insert(field, relation);
+        }
+    }
+    for unavailable in contract.unavailable() {
+        fields
+            .entry(unavailable.field)
+            .or_insert(StrongestContractRelation::Unavailable(unavailable.reason));
+    }
+    fields
+}
+
+fn fmt_parameter_contract(
+    contract: &Result<
+        problemreductions::rules::ReductionParameterContract,
+        problemreductions::rules::ParameterContractError,
+    >,
+) -> Vec<String> {
+    let contract = match contract {
+        Ok(contract) => contract,
+        Err(error) => return vec![format!("invalid: {error}")],
+    };
+    strongest_contract_fields(contract)
+        .into_iter()
+        .map(|(field, relation)| match relation {
+            StrongestContractRelation::Exact(expression) => {
+                format!("{field} = {expression}")
+            }
+            StrongestContractRelation::UpperBound(expression) => {
+                format!("{field} <= {expression}")
+            }
+            StrongestContractRelation::Unavailable(reason) => {
+                format!("{field} unavailable: {reason}")
+            }
         })
         .collect()
 }
 
+fn strongest_parameter_contract_to_json(
+    contract: &Result<
+        problemreductions::rules::ReductionParameterContract,
+        problemreductions::rules::ParameterContractError,
+    >,
+) -> serde_json::Value {
+    match contract {
+        Ok(contract) => serde_json::Value::Array(
+            strongest_contract_fields(contract)
+                .into_iter()
+                .map(|(field, relation)| match relation {
+                    StrongestContractRelation::Exact(expression) => serde_json::json!({
+                        "field": field,
+                        "relation": "exact",
+                        "formula": expression.to_string(),
+                    }),
+                    StrongestContractRelation::UpperBound(expression) => serde_json::json!({
+                        "field": field,
+                        "relation": "upper_bound",
+                        "formula": expression.to_string(),
+                    }),
+                    StrongestContractRelation::Unavailable(reason) => serde_json::json!({
+                        "field": field,
+                        "relation": "unavailable",
+                        "reason": reason,
+                    }),
+                })
+                .collect(),
+        ),
+        Err(error) => serde_json::json!({"error": error.to_string()}),
+    }
+}
+
+pub(crate) fn parameter_contract_to_json(
+    contract: &Result<
+        problemreductions::rules::ReductionParameterContract,
+        problemreductions::rules::ParameterContractError,
+    >,
+) -> serde_json::Value {
+    match contract {
+        Ok(contract) => serde_json::json!({
+            "relation": contract.transform().map(|transform| transform.relation()),
+            "fields": contract.transform().map(|transform| transform.expressions().map(|(field, expression)| {
+                serde_json::json!({
+                    "field": field,
+                    "formula": expression.to_string(),
+                    "big_o": big_o_of(expression),
+                })
+            }).collect::<Vec<_>>()).unwrap_or_default(),
+            "unavailable": contract.unavailable(),
+        }),
+        Err(error) => serde_json::json!({"error": error.to_string()}),
+    }
+}
+
 /// Convert a variant BTreeMap to slash notation showing ALL values.
-/// E.g., {graph: "SimpleGraph", weight: "i32"} → "/SimpleGraph/i32".
-pub(crate) fn variant_to_full_slash(variant: &BTreeMap<String, String>) -> String {
+/// E.g., {graph: "SimpleGraph", weight: "i64"} → "/SimpleGraph/i64".
+pub(crate) fn variant_to_full_slash(name: &str, variant: &BTreeMap<String, String>) -> String {
     if variant.is_empty() {
         String::new()
     } else {
-        let vals: Vec<&str> = variant.values().map(|v| v.as_str()).collect();
+        let vals = crate::problem_name::ordered_variant_values(name, variant);
         format!("/{}", vals.join("/"))
     }
 }
@@ -392,7 +704,7 @@ pub(crate) fn variant_hint_for(graph: &ReductionGraph, name: &str) -> String {
     }
     let list: Vec<String> = variants
         .iter()
-        .map(|v| format!("{}{}", name, variant_to_full_slash(v)))
+        .map(|v| format!("{}{}", name, variant_to_full_slash(name, v)))
         .collect();
     format!(
         "\nTip: try specifying a variant. Available variants for {}:\n  {}\n",
@@ -404,10 +716,107 @@ pub(crate) fn variant_hint_for(graph: &ReductionGraph, name: &str) -> String {
 /// Format a problem node as **bold name/variant** in slash notation.
 /// This is the single source of truth for "name/variant" display.
 fn fmt_node(_graph: &ReductionGraph, name: &str, variant: &BTreeMap<String, String>) -> String {
-    let slash = variant_to_full_slash(variant);
+    let slash = variant_to_full_slash(name, variant);
     crate::output::fmt_problem_name(&format!("{name}{slash}"))
 }
 
+enum PreparedParameterRelation {
+    Exact(String),
+    UpperBound(String),
+    Unavailable(String),
+}
+
+struct PreparedParameterField {
+    field: String,
+    relation: PreparedParameterRelation,
+}
+
+fn terminal_parameter_contract(
+    graph: &ReductionGraph,
+    path: &ReductionPath,
+) -> Option<problemreductions::rules::ReductionParameterContract> {
+    path.steps
+        .windows(2)
+        .last()
+        .and_then(|pair| {
+            graph.find_entry(
+                &pair[0].name,
+                &pair[0].variant,
+                &pair[1].name,
+                &pair[1].variant,
+            )
+        })
+        .and_then(|entry| entry.parameter_contract.ok())
+}
+
+fn prepare_overall_parameters(
+    graph: &ReductionGraph,
+    path: &ReductionPath,
+) -> Vec<PreparedParameterField> {
+    let Some(target) = path.target() else {
+        return Vec::new();
+    };
+    let composed = graph.compose_path_parameter_transform(path);
+    let terminal_contract = terminal_parameter_contract(graph, path);
+
+    graph
+        .parameter_names(target)
+        .into_iter()
+        .map(|field| {
+            let expression = composed
+                .as_ref()
+                .ok()
+                .and_then(|transform| transform.as_ref())
+                .and_then(|transform| {
+                    transform
+                        .get(&field)
+                        .map(|expression| (transform.relation(), expression))
+                });
+            let relation = if let Some((relation, expression)) = expression {
+                match relation {
+                    problemreductions::parameters::ParameterRelation::Exact => {
+                        PreparedParameterRelation::Exact(expression.to_string())
+                    }
+                    problemreductions::parameters::ParameterRelation::UpperBound => {
+                        PreparedParameterRelation::UpperBound(expression.to_string())
+                    }
+                }
+            } else if let Some(unavailable) = terminal_contract.as_ref().and_then(|contract| {
+                contract
+                    .unavailable()
+                    .iter()
+                    .find(|unavailable| unavailable.field == field)
+            }) {
+                PreparedParameterRelation::Unavailable(unavailable.reason.to_string())
+            } else if terminal_contract
+                .as_ref()
+                .and_then(|contract| contract.transform())
+                .is_some_and(|transform| transform.get(&field).is_some())
+            {
+                PreparedParameterRelation::Unavailable(match &composed {
+                    Err(error) => error.to_string(),
+                    Ok(_) => {
+                        format!(
+                            "no composed parameter relation is available for target field {field}"
+                        )
+                    }
+                })
+            } else {
+                let reason = match &composed {
+                    Err(error) => error.to_string(),
+                    Ok(_) => {
+                        format!(
+                            "no symbolic parameter relation is registered for target field {field}"
+                        )
+                    }
+                };
+                PreparedParameterRelation::Unavailable(reason)
+            };
+            PreparedParameterField { field, relation }
+        })
+        .collect()
+}
+
 fn format_path_text(
     graph: &ReductionGraph,
     reduction_path: &problemreductions::rules::ReductionPath,
@@ -427,7 +836,6 @@ fn format_path_text(
     };
     let mut text = format!("Path ({} steps): {}\n", reduction_path.len(), path_summary);
 
-    let overheads = graph.path_overheads(reduction_path);
     let steps = &reduction_path.steps;
     for i in 0..steps.len().saturating_sub(1) {
         let from = &steps[i];
@@ -439,60 +847,97 @@ fn format_path_text(
             crate::output::fmt_outgoing("→"),
             fmt_node(graph, &to.name, &to.variant),
         ));
-        let oh = &overheads[i];
-        for (field, poly) in &oh.output_size {
-            text.push_str(&format!("    {field} = {}\n", big_o_of(poly)));
+        match graph.find_entry(&from.name, &from.variant, &to.name, &to.variant) {
+            Some(entry) => {
+                for part in fmt_parameter_contract(&entry.parameter_contract) {
+                    text.push_str(&format!("    {part}\n"));
+                }
+            }
+            None => text.push_str("    unregistered edge\n"),
         }
     }
 
-    // Show composed overall overhead for multi-step paths
     if reduction_path.len() > 1 {
-        let composed = graph.compose_path_overhead(reduction_path);
         text.push_str(&format!("\n  {}:\n", crate::output::fmt_section("Overall")));
-        for (field, poly) in &composed.output_size {
-            text.push_str(&format!("    {field} = {}\n", big_o_of(poly)));
+        for field in prepare_overall_parameters(graph, reduction_path) {
+            match field.relation {
+                PreparedParameterRelation::Exact(expression) => {
+                    text.push_str(&format!("    {} = {expression}\n", field.field));
+                }
+                PreparedParameterRelation::UpperBound(expression) => {
+                    text.push_str(&format!("    {} <= {expression}\n", field.field));
+                }
+                PreparedParameterRelation::Unavailable(reason) => {
+                    text.push_str(&format!("    {} unavailable: {reason}\n", field.field));
+                }
+            }
         }
     }
 
     text
 }
 
-fn format_path_json(
+pub(crate) fn format_path_json(
     graph: &ReductionGraph,
     reduction_path: &problemreductions::rules::ReductionPath,
 ) -> serde_json::Value {
-    let overheads = graph.path_overheads(reduction_path);
     let steps_json: Vec<serde_json::Value> = reduction_path
         .steps
         .windows(2)
-        .zip(overheads.iter())
         .enumerate()
-        .map(|(i, (pair, oh))| {
+        .map(|(i, pair)| {
+            let parameter_contract = graph
+                .find_entry(
+                    &pair[0].name,
+                    &pair[0].variant,
+                    &pair[1].name,
+                    &pair[1].variant,
+                )
+                .map(|entry| strongest_parameter_contract_to_json(&entry.parameter_contract))
+                .unwrap_or_else(|| serde_json::json!({"error": "unregistered edge"}));
             serde_json::json!({
                 "from": {"name": pair[0].name, "variant": pair[0].variant},
                 "to": {"name": pair[1].name, "variant": pair[1].variant},
                 "step": i + 1,
-                "overhead": overhead_to_json(&oh.output_size),
+                "parameter_contract": parameter_contract,
             })
         })
         .collect();
 
-    let composed = graph.compose_path_overhead(reduction_path);
-    let overall = overhead_to_json(&composed.output_size);
-
+    let fields = prepare_overall_parameters(graph, reduction_path)
+        .into_iter()
+        .map(|field| match field.relation {
+            PreparedParameterRelation::Exact(expression) => serde_json::json!({
+                "field": field.field,
+                "relation": "exact",
+                "formula": expression,
+            }),
+            PreparedParameterRelation::UpperBound(expression) => serde_json::json!({
+                "field": field.field,
+                "relation": "upper_bound",
+                "formula": expression,
+            }),
+            PreparedParameterRelation::Unavailable(reason) => serde_json::json!({
+                "field": field.field,
+                "relation": "unavailable",
+                "reason": reason,
+            }),
+        })
+        .collect::<Vec<_>>();
+    let mut overall_object = serde_json::Map::new();
+    overall_object.insert("fields".to_string(), serde_json::json!(fields));
     serde_json::json!({
         "steps": reduction_path.len(),
         "path": steps_json,
-        "overall_overhead": overall,
+        "overall_parameters": overall_object,
     })
 }
 
 pub fn path(
     source: &str,
     target: &str,
-    cost: &str,
-    all: bool,
-    max_paths: usize,
+    limit: usize,
+    instance: Option<&Path>,
     out: &OutputConfig,
 ) -> Result<()> {
     let src_spec = parse_problem_spec(source)?;
@@ -518,100 +963,68 @@ pub fn path(
     // Resolve source and target to exact variant nodes
     let src_ref = resolve_problem_ref(source, &graph)?;
     let dst_ref = resolve_problem_ref(target, &graph)?;
-
-    if all {
-        return path_all(
+    if let Some(instance) = instance {
+        let content = read_input(instance)?;
+        let problem_json: ProblemJson = serde_json::from_str(&content).map_err(|error| {
+            anyhow::anyhow!("Invalid problem JSON in {}: {error}", instance.display())
+        })?;
+        let loaded = load_problem(
+            &problem_json.problem_type,
+            &problem_json.variant,
+            problem_json.data,
+        )?;
+        if loaded.problem_name() != src_ref.name || loaded.variant_map() != src_ref.variant {
+            anyhow::bail!(
+                "Source argument resolves to {}{} but {} contains {}{}",
+                src_ref.name,
+                variant_to_full_slash(&src_ref.name, &src_ref.variant),
+                instance.display(),
+                loaded.problem_name(),
+                variant_to_full_slash(loaded.problem_name(), &loaded.variant_map()),
+            );
+        }
+        path_concrete(
             &graph,
             &src_ref.name,
             &src_ref.variant,
             &dst_ref.name,
             &dst_ref.variant,
-            max_paths,
+            limit,
+            loaded.as_any(),
             out,
-        );
-    }
-
-    let input_size = ProblemSize::new(vec![]);
-
-    // Parse cost function once (validate before the search loop)
-    enum CostChoice {
-        Steps,
-        Field(&'static str),
-    }
-    let cost_choice = if cost == "minimize-steps" {
-        CostChoice::Steps
-    } else if let Some(field) = cost.strip_prefix("minimize:") {
-        // Leak the field name to get &'static str (fine for a CLI that exits immediately)
-        CostChoice::Field(Box::leak(field.to_string().into_boxed_str()))
+        )
     } else {
-        anyhow::bail!(
-            "Unknown cost function: {}. Use 'minimize-steps' or 'minimize:<field>'",
-            cost
-        );
-    };
-
-    let best_path = match cost_choice {
-        CostChoice::Steps => graph.find_cheapest_path(
-            &src_ref.name,
-            &src_ref.variant,
-            &dst_ref.name,
-            &dst_ref.variant,
-            &input_size,
-            &MinimizeSteps,
-        ),
-        CostChoice::Field(f) => graph.find_cheapest_path(
+        path_symbolic(
+            &graph,
             &src_ref.name,
             &src_ref.variant,
             &dst_ref.name,
             &dst_ref.variant,
-            &input_size,
-            &Minimize(f),
-        ),
-    };
-
-    match best_path {
-        Some(ref reduction_path) => {
-            let text = format_path_text(&graph, reduction_path);
-            let json = format_path_json(&graph, reduction_path);
-            out.emit_with_default_name("", &text, &json)
-        }
-        None => {
-            let variant_hint = variant_hint_for(&graph, &dst_spec.name);
-            anyhow::bail!(
-                "No reduction path from {} to {}\n\
-                 {variant_hint}\n\
-                 Usage: pred path <SOURCE> <TARGET>\n\
-                 Example: pred path MIS QUBO\n\n\
-                 Run `pred show {}` and `pred show {}` to check available reductions.",
-                src_spec.name,
-                dst_spec.name,
-                src_spec.name,
-                dst_spec.name,
-            );
-        }
+            limit,
+            out,
+        )
     }
 }
 
-fn path_all(
+#[allow(clippy::too_many_arguments)]
+fn path_symbolic(
     graph: &ReductionGraph,
     src_name: &str,
     src_variant: &BTreeMap<String, String>,
     dst_name: &str,
     dst_variant: &BTreeMap<String, String>,
-    max_paths: usize,
+    limit: usize,
     out: &OutputConfig,
 ) -> Result<()> {
-    // Fetch one extra to detect truncation
-    let mut all_paths =
-        graph.find_paths_up_to(src_name, src_variant, dst_name, dst_variant, max_paths + 1);
+    let batch = find_path_batch(graph, src_name, src_variant, dst_name, dst_variant, limit)?;
 
-    if all_paths.is_empty() {
+    if batch.paths.is_empty() && !batch.truncated {
         let variant_hint = variant_hint_for(graph, dst_name);
         anyhow::bail!(
             "No reduction path from {} to {}\n\
              {variant_hint}\n\
-             Usage: pred path <SOURCE> <TARGET> --all\n\
-             Example: pred path MIS QUBO --all\n\n\
+             Usage: pred path <SOURCE> <TARGET>\n\
+             Example: pred path MIS QUBO\n\n\
              Run `pred show {}` and `pred show {}` to check available reductions.",
             src_name,
             dst_name,
@@ -619,108 +1032,236 @@ fn path_all(
             dst_name,
         );
     }
+    out.emit(
+        || {
+            render_paths_text(
+                graph,
+                &batch.paths,
+                src_name,
+                dst_name,
+                batch.truncated,
+                limit,
+            )
+        },
+        || path_batch_json(graph, &batch, None),
+    )
+}
 
-    // Sort by path length (shortest first)
-    all_paths.sort_by_key(|p| p.len());
+pub(crate) struct PathBatch {
+    pub(crate) paths: Vec<ReductionPath>,
+    pub(crate) truncated: bool,
+}
 
-    let truncated = all_paths.len() > max_paths;
-    if truncated {
-        all_paths.truncate(max_paths);
+pub(crate) const MAX_PATHS: usize = 999;
+pub(crate) const PATH_LIMIT_ERROR: &str = "limit must be an integer from 1 to 999 or 'all'";
+
+pub(crate) fn validate_path_limit(limit: usize) -> std::result::Result<usize, String> {
+    (1..=MAX_PATHS)
+        .contains(&limit)
+        .then_some(limit)
+        .ok_or_else(|| PATH_LIMIT_ERROR.to_string())
+}
+
+pub(crate) fn parse_path_limit(value: &str) -> std::result::Result<usize, String> {
+    if value == "all" {
+        return Ok(MAX_PATHS);
+    }
+    let limit = value
+        .parse::<usize>()
+        .map_err(|_| PATH_LIMIT_ERROR.to_string())?;
+    validate_path_limit(limit)
+}
+
+pub(crate) fn find_path_batch(
+    graph: &ReductionGraph,
+    src_name: &str,
+    src_variant: &BTreeMap<String, String>,
+    dst_name: &str,
+    dst_variant: &BTreeMap<String, String>,
+    limit: usize,
+) -> Result<PathBatch> {
+    validate_path_limit(limit).map_err(anyhow::Error::msg)?;
+    let mut paths = graph.find_paths_up_to(src_name, src_variant, dst_name, dst_variant, limit + 1);
+    let truncated = paths.len() > limit;
+    paths.truncate(limit);
+    Ok(PathBatch { paths, truncated })
+}
+
+pub(crate) fn path_batch_json(
+    graph: &ReductionGraph,
+    batch: &PathBatch,
+    executed: Option<&[ExecutedPath]>,
+) -> Result<serde_json::Value> {
+    let paths = match executed {
+        Some(executed) => {
+            if executed.len() != batch.paths.len() {
+                anyhow::bail!(
+                    "executed path count {} does not match enumerated path count {}",
+                    executed.len(),
+                    batch.paths.len()
+                );
+            }
+            executed
+                .iter()
+                .map(format_concrete_path_json)
+                .collect::<Vec<_>>()
+        }
+        None => batch
+            .paths
+            .iter()
+            .map(|path| format_path_json(graph, path))
+            .collect::<Vec<_>>(),
+    };
+    Ok(serde_json::json!({
+        "paths": paths,
+        "truncated": batch.truncated,
+    }))
+}
+
+fn path_truncation_note(limit: usize) -> &'static str {
+    if limit == MAX_PATHS {
+        "\n(more paths exist; path search is capped at 999)\n"
+    } else {
+        "\n(more paths exist; increase --limit, maximum: 999)\n"
     }
+}
 
-    let returned = all_paths.len();
+/// Render the symbolic path listing (header + per-path chains with normalized
+/// parameter contracts). Extracted so it is built only for text output and can be
+/// exercised in-process by regression tests without spawning the binary.
+fn render_paths_text(
+    graph: &ReductionGraph,
+    paths: &[ReductionPath],
+    src_name: &str,
+    dst_name: &str,
+    truncated: bool,
+    limit: usize,
+) -> String {
     let mut text = format!(
         "Found {} paths from {} to {}:\n",
-        returned, src_name, dst_name
+        paths.len(),
+        src_name,
+        dst_name
     );
-    for (idx, p) in all_paths.iter().enumerate() {
+    for (idx, p) in paths.iter().enumerate() {
         text.push_str(&format!("\n--- Path {} ---\n", idx + 1));
         text.push_str(&format_path_text(graph, p));
     }
     if truncated {
-        text.push_str(&format!(
-            "\n(showing {max_paths} of more paths; use --max-paths to increase)\n"
-        ));
+        text.push_str(path_truncation_note(limit));
     }
+    text
+}
 
-    let paths_json: Vec<serde_json::Value> = all_paths
-        .iter()
-        .map(|p| format_path_json(graph, p))
-        .collect();
+fn measured_parameters_json(
+    parameters: &problemreductions::ProblemParameters,
+) -> serde_json::Value {
+    serde_json::json!({
+        "fields": parameters.iter().map(|(field, value)| {
+            serde_json::json!({"field": field, "value": value})
+        }).collect::<Vec<_>>()
+    })
+}
 
-    let json = serde_json::json!({
-        "paths": paths_json,
-        "truncated": truncated,
-        "returned": returned,
-        "max_paths": max_paths,
-    });
-
-    if let Some(ref dir) = out.output {
-        // -o specifies the output folder; save each path as a separate JSON file
-        std::fs::create_dir_all(dir)
-            .with_context(|| format!("Failed to create directory {}", dir.display()))?;
-
-        for (idx, p) in all_paths.iter().enumerate() {
-            let path_json = format_path_json(graph, p);
-            let file = dir.join(format!("path_{}.json", idx + 1));
-            let content =
-                serde_json::to_string_pretty(&path_json).context("Failed to serialize JSON")?;
-            std::fs::write(&file, &content)
-                .with_context(|| format!("Failed to write {}", file.display()))?;
-        }
+pub(crate) fn format_concrete_path_json(executed: &ExecutedPath) -> serde_json::Value {
+    let parameters = executed.target_parameters();
+    let steps = executed
+        .path
+        .steps
+        .windows(2)
+        .zip(&parameters)
+        .enumerate()
+        .map(|(index, (pair, size))| {
+            serde_json::json!({
+                "from": {"name": pair[0].name, "variant": pair[0].variant},
+                "to": {"name": pair[1].name, "variant": pair[1].variant},
+                "step": index + 1,
+                "actual_target_parameters": measured_parameters_json(size),
+            })
+        })
+        .collect::<Vec<_>>();
+    serde_json::json!({
+        "steps": executed.path.len(),
+        "path": steps,
+        "actual_target_parameters": measured_parameters_json(parameters.last().expect("path has at least one edge")),
+    })
+}
 
-        // Write manifest
-        let manifest = serde_json::json!({
-            "paths": returned,
-            "truncated": truncated,
-            "max_paths": max_paths,
-        });
-        let manifest_file = dir.join("manifest.json");
-        let manifest_content =
-            serde_json::to_string_pretty(&manifest).context("Failed to serialize manifest")?;
-        std::fs::write(&manifest_file, &manifest_content)
-            .with_context(|| format!("Failed to write {}", manifest_file.display()))?;
-
-        out.info(&format!(
-            "Wrote {} path files to {}{}",
-            returned,
-            dir.display(),
-            if truncated {
-                " (truncated; use --max-paths to increase)".to_string()
-            } else {
-                String::new()
-            }
+fn format_concrete_path_text(graph: &ReductionGraph, executed: &ExecutedPath) -> String {
+    let parameters = executed.target_parameters();
+    let summary = executed
+        .path
+        .steps
+        .iter()
+        .map(|step| fmt_node(graph, &step.name, &step.variant))
+        .collect::<Vec<_>>()
+        .join(&format!(" {} ", crate::output::fmt_outgoing("→")));
+    let mut text = format!("Path ({} steps): {summary}\n", executed.path.len());
+    for (index, (pair, size)) in executed.path.steps.windows(2).zip(&parameters).enumerate() {
+        text.push_str(&format!(
+            "\n  {}: {} {} {}\n",
+            crate::output::fmt_section(&format!("Step {}", index + 1)),
+            fmt_node(graph, &pair[0].name, &pair[0].variant),
+            crate::output::fmt_outgoing("→"),
+            fmt_node(graph, &pair[1].name, &pair[1].variant),
         ));
-    } else if out.json {
-        println!(
-            "{}",
-            serde_json::to_string_pretty(&json).context("Failed to serialize JSON")?
-        );
-    } else {
-        println!("{text}");
+        for (field, value) in size.iter() {
+            text.push_str(&format!("    {field} = {value}\n"));
+        }
     }
+    text
+}
 
-    Ok(())
+#[allow(clippy::too_many_arguments)]
+fn path_concrete(
+    graph: &ReductionGraph,
+    src_name: &str,
+    src_variant: &BTreeMap<String, String>,
+    dst_name: &str,
+    dst_variant: &BTreeMap<String, String>,
+    limit: usize,
+    source: &dyn Any,
+    out: &OutputConfig,
+) -> Result<()> {
+    let batch = find_path_batch(graph, src_name, src_variant, dst_name, dst_variant, limit)?;
+    if batch.paths.is_empty() && !batch.truncated {
+        anyhow::bail!("No reduction path from {src_name} to {dst_name}");
+    }
+    let executed = graph.execute_paths(&batch.paths, source)?;
+    out.emit(
+        || {
+            let mut text = format!(
+                "Executed {} paths from {src_name} to {dst_name}:\n",
+                batch.paths.len()
+            );
+            for (index, path) in executed.iter().enumerate() {
+                text.push_str(&format!("\n--- Path {} ---\n", index + 1));
+                text.push_str(&format_concrete_path_text(graph, path));
+            }
+            if batch.truncated {
+                text.push_str(path_truncation_note(limit));
+            }
+            text
+        },
+        || path_batch_json(graph, &batch, Some(&executed)),
+    )
 }
 
 pub fn export(out: &OutputConfig) -> Result<()> {
     let graph = ReductionGraph::new();
 
-    let json_str = graph
-        .to_json_string()
-        .map_err(|e| anyhow::anyhow!("Failed to export: {}", e))?;
-    let json: serde_json::Value =
-        serde_json::from_str(&json_str).map_err(|e| anyhow::anyhow!("Failed to parse: {}", e))?;
-
-    let text = format!(
-        "Reduction graph: {} types, {} reductions, {} variant nodes\n\
-         Use -o to save as JSON.",
-        graph.num_types(),
-        graph.num_reductions(),
-        graph.num_variant_nodes(),
-    );
-
-    out.emit_with_default_name("reduction_graph.json", &text, &json)
+    out.emit(
+        || {
+            format!(
+                "Reduction graph: {} types, {} reductions, {} variant nodes\n\
+                 Use -o to save as JSON.",
+                graph.num_types(),
+                graph.num_reductions(),
+                graph.num_variant_nodes(),
+            )
+        },
+        || graph.to_json_value().map_err(anyhow::Error::from),
+    )
 }
 
 fn push_alias_part(parts: &mut Vec<String>, alias: &str) {
@@ -762,39 +1303,39 @@ pub fn neighbors(
     // Build tree structure via BFS with parent tracking
     let tree = graph.k_neighbor_tree(&spec_name, &variant, max_hops, direction);
 
-    let root_label = fmt_node(&graph, &spec_name, &variant);
-
-    let header_label = fmt_node(&graph, &spec_name, &variant);
-    let mut text = format!(
-        "{} — {}-hop neighbors ({})\n\n",
-        header_label, max_hops, dir_label,
-    );
-
-    text.push_str(&root_label);
-    text.push('\n');
-    render_tree(&graph, &tree, &mut text, "");
-
-    text.push_str(&format!(
-        "\n{} reachable nodes in {} hops\n",
-        neighbors.len(),
-        max_hops,
-    ));
-
-    let json = serde_json::json!({
-        "source": spec_name,
-        "hops": max_hops,
-        "direction": direction_str,
-        "neighbors": neighbors.iter().map(|n| {
-            serde_json::json!({
-                "name": n.name,
-                "variant": n.variant,
-                "hops": n.hops,
-            })
-        }).collect::<Vec<_>>(),
-    });
-
-    let default_name = format!("pred_{}_{}_{}.json", direction_str, spec_name, max_hops);
-    out.emit_with_default_name(&default_name, &text, &json)
+    out.emit(
+        || {
+            let root_label = fmt_node(&graph, &spec_name, &variant);
+            let header_label = fmt_node(&graph, &spec_name, &variant);
+            let mut text = format!(
+                "{} — {}-hop neighbors ({})\n\n",
+                header_label, max_hops, dir_label,
+            );
+            text.push_str(&root_label);
+            text.push('\n');
+            render_tree(&graph, &tree, &mut text, "");
+            text.push_str(&format!(
+                "\n{} reachable nodes in {} hops\n",
+                neighbors.len(),
+                max_hops,
+            ));
+            text
+        },
+        || {
+            Ok(serde_json::json!({
+                "source": spec_name,
+                "hops": max_hops,
+                "direction": direction_str,
+                "neighbors": neighbors.iter().map(|n| {
+                    serde_json::json!({
+                        "name": n.name,
+                        "variant": n.variant,
+                        "hops": n.hops,
+                    })
+                }).collect::<Vec<_>>(),
+            }))
+        },
+    )
 }
 
 use problemreductions::rules::NeighborTree;
diff --git a/problemreductions-cli/src/commands/inspect.rs b/problemreductions-cli/src/commands/inspect.rs
index d7e5daf8d..f5546052c 100644
--- a/problemreductions-cli/src/commands/inspect.rs
+++ b/problemreductions-cli/src/commands/inspect.rs
@@ -1,7 +1,10 @@
-use crate::dispatch::{load_problem, read_input, ProblemJson, ReductionBundle};
+use crate::dispatch::{
+    load_problem, read_input, solver_capabilities_view, ProblemJson, ReductionBundle,
+};
 use crate::output::OutputConfig;
 use anyhow::Result;
-use problemreductions::rules::ReductionGraph;
+use problemreductions::rules::{ReductionGraph, ReductionMode};
+use std::collections::BTreeMap;
 use std::path::Path;
 
 pub fn inspect(input: &Path, out: &OutputConfig) -> Result<()> {
@@ -23,79 +26,111 @@ fn inspect_problem(pj: &ProblemJson, out: &OutputConfig) -> Result<()> {
     let name = problem.problem_name();
     let variant = problem.variant_map();
     let graph = ReductionGraph::new();
+    let brute_force_num_variables = problem.brute_force_num_variables()?;
 
-    let variant_str = if variant.is_empty() {
-        String::new()
-    } else {
-        let pairs: Vec<String> = variant.iter().map(|(k, v)| format!("{k}={v}")).collect();
-        format!(" {{{}}}", pairs.join(", "))
-    };
-
-    let mut text = format!("Type: {}{}\n", name, variant_str);
-
-    // Size fields from the reduction graph
-    let size_fields = graph.size_field_names(name);
-    if !size_fields.is_empty() {
-        text.push_str(&format!("Size fields: {}\n", size_fields.join(", ")));
-    }
-    text.push_str(&format!("Variables: {}\n", problem.num_variables_dyn()));
-
-    let solvers = problem.available_solvers();
-    let solver_summary = solvers
-        .iter()
-        .map(|solver| {
-            if *solver == "ilp" {
-                "ilp (default)".to_string()
+    let parameters = graph.parameter_names(name);
+    let solver_view = solver_capabilities_view(&problem)?;
+    let targets = executable_reduction_targets(&graph, name, &variant);
+    out.emit(
+        || {
+            let variant_str = if variant.is_empty() {
+                String::new()
             } else {
-                (*solver).to_string()
+                let pairs: Vec<String> = variant.iter().map(|(k, v)| format!("{k}={v}")).collect();
+                format!(" {{{}}}", pairs.join(", "))
+            };
+            let mut text = format!("Type: {}{}\n", name, variant_str);
+            if !parameters.is_empty() {
+                text.push_str(&format!("Parameters: {}\n", parameters.join(", ")));
             }
-        })
-        .collect::<Vec<_>>()
-        .join(", ");
-    text.push_str(&format!("Solvers: {solver_summary}\n"));
-
-    // Reductions
-    let outgoing = graph.outgoing_reductions(name);
-    let targets = targets_deduped(&outgoing);
-    if !targets.is_empty() {
-        text.push_str(&format!("Reduces to: {}\n", targets.join(", ")));
-    }
-
-    let json_val = serde_json::json!({
-        "kind": "problem",
-        "type": name,
-        "variant": variant,
-        "size_fields": size_fields,
-        "num_variables": problem.num_variables_dyn(),
-        "solvers": solvers,
-        "reduces_to": targets,
-    });
-
-    out.emit_with_default_name("", &text, &json_val)
+            if let Some(num_variables) = brute_force_num_variables {
+                text.push_str(&format!("Brute-force variables: {num_variables}\n"));
+            }
+            text.push_str(&format!("Default solver: {}\n", solver_view.default_solver));
+            text.push_str(&format!("Solvers: {}\n", solver_view.solvers.join(", ")));
+            if let Some(customized) = solver_view.capabilities.customized.as_ref() {
+                text.push_str(&format!(
+                    "Customized implementation: {}\n",
+                    customized.implementation
+                ));
+            }
+            if let Some(ilp) = solver_view.capabilities.ilp.as_ref() {
+                text.push_str(&format!(
+                    "ILP pipeline: {}\n",
+                    ilp.reduction_path.join(" -> ")
+                ));
+            }
+            if !targets.is_empty() {
+                text.push_str(&format!("Reduces to: {}\n", targets.join(", ")));
+            }
+            text
+        },
+        || {
+            Ok(serde_json::json!({
+                "kind": "problem",
+                "type": name,
+                "variant": variant,
+                "parameters": parameters,
+                "parameter_values": problem.parameters_dyn().iter().collect::<BTreeMap<_, _>>(),
+                "brute_force_num_variables": brute_force_num_variables,
+                "solvers": solver_view.solvers,
+                "default_solver": solver_view.default_solver,
+                "solver_capabilities": solver_view.capabilities,
+                "reduces_to": targets,
+            }))
+        },
+    )
 }
 
 fn inspect_bundle(bundle: &ReductionBundle, out: &OutputConfig) -> Result<()> {
-    let mut text = String::from("Kind: Reduction Bundle\n");
-    text.push_str(&format!("Source: {}\n", bundle.source.problem_type));
-    text.push_str(&format!("Target: {}\n", bundle.target.problem_type));
-    text.push_str(&format!("Steps: {}\n", bundle.path.len().saturating_sub(1)));
-
     let path_str: Vec<&str> = bundle.path.iter().map(|s| s.name.as_str()).collect();
-    text.push_str(&format!("Path: {}\n", path_str.join(" -> ")));
-
-    let json_val = serde_json::json!({
-        "kind": "bundle",
-        "source": bundle.source.problem_type,
-        "target": bundle.target.problem_type,
-        "steps": bundle.path.len().saturating_sub(1),
-        "path": path_str,
-    });
-
-    out.emit_with_default_name("", &text, &json_val)
+    out.emit(
+        || {
+            let mut text = String::from("Kind: Reduction Bundle\n");
+            text.push_str(&format!("Source: {}\n", bundle.source.problem_type));
+            text.push_str(&format!("Target: {}\n", bundle.target.problem_type));
+            text.push_str(&format!("Steps: {}\n", bundle.path.len().saturating_sub(1)));
+            text.push_str(&format!("Path: {}\n", path_str.join(" -> ")));
+            text
+        },
+        || {
+            Ok(serde_json::json!({
+                "kind": "bundle",
+                "source": bundle.source.problem_type,
+                "target": bundle.target.problem_type,
+                "steps": bundle.path.len().saturating_sub(1),
+                "path": path_str,
+            }))
+        },
+    )
 }
 
-fn targets_deduped(outgoing: &[problemreductions::rules::ReductionEdgeInfo]) -> Vec<String> {
-    let mut targets: Vec<String> = outgoing.iter().map(|e| e.target_name.to_string()).collect();
+pub(crate) fn executable_reduction_targets(
+    graph: &ReductionGraph,
+    name: &str,
+    variant: &BTreeMap<String, String>,
+) -> Vec<String> {
+    let mut targets: Vec<String> = graph
+        .outgoing_reductions_from(name, variant, ReductionMode::Witness)
+        .into_iter()
+        .map(|edge| {
+            let default_variant = graph
+                .default_variant_for(edge.target_name)
+                .unwrap_or_else(|| panic!("default variant not found for {}", edge.target_name));
+            if default_variant == edge.target_variant {
+                edge.target_name.to_string()
+            } else {
+                format!(
+                    "{}{}",
+                    edge.target_name,
+                    crate::commands::graph::variant_to_full_slash(
+                        edge.target_name,
+                        &edge.target_variant
+                    )
+                )
+            }
+        })
+        .collect();
     targets.sort();
     targets.dedup();
     targets
diff --git a/problemreductions-cli/src/commands/reduce.rs b/problemreductions-cli/src/commands/reduce.rs
index f0a083d4e..0ff6f61c4 100644
--- a/problemreductions-cli/src/commands/reduce.rs
+++ b/problemreductions-cli/src/commands/reduce.rs
@@ -3,33 +3,55 @@ use crate::dispatch::{
     ReductionBundle,
 };
 use crate::output::OutputConfig;
-use crate::problem_name::resolve_problem_ref;
 use anyhow::{Context, Result};
-use problemreductions::rules::{
-    MinimizeSteps, ReductionGraph, ReductionMode, ReductionPath, ReductionStep,
-};
-use problemreductions::types::ProblemSize;
+use problemreductions::rules::{ReductionGraph, ReductionPath, ReductionStep};
 use std::collections::BTreeMap;
 use std::path::Path;
 
 /// Parse a path JSON file (produced by `pred path ... -o`) into a ReductionPath.
 fn load_path_file(path_file: &Path) -> Result<ReductionPath> {
     let content = std::fs::read_to_string(path_file).context("Failed to read path file")?;
-    let json: serde_json::Value =
-        serde_json::from_str(&content).context("Failed to parse path file")?;
+    parse_path_json(&content)
+}
+
+pub(crate) fn parse_path_json(content: &str) -> Result<ReductionPath> {
+    #[derive(serde::Deserialize)]
+    struct RouteNode {
+        name: String,
+        variant: BTreeMap<String, String>,
+    }
+
+    #[derive(serde::Deserialize)]
+    struct RouteEdge {
+        from: RouteNode,
+        to: RouteNode,
+    }
+
+    #[derive(serde::Deserialize)]
+    struct ExplicitRoute {
+        path: Vec<RouteEdge>,
+    }
 
-    let path_array = json["path"]
-        .as_array()
-        .ok_or_else(|| anyhow::anyhow!("Path file missing 'path' array"))?;
+    let route: ExplicitRoute =
+        serde_json::from_str(content).context("Expected one explicit route with a 'path' array")?;
 
     let mut steps: Vec<ReductionStep> = Vec::new();
-    for (i, entry) in path_array.iter().enumerate() {
-        if i == 0 {
-            let from = &entry["from"];
-            steps.push(parse_path_node(from)?);
+    for (i, edge) in route.path.into_iter().enumerate() {
+        let from = ReductionStep {
+            name: edge.from.name,
+            variant: edge.from.variant,
+        };
+        if let Some(previous) = steps.last() {
+            if previous.name != from.name || previous.variant != from.variant {
+                anyhow::bail!("Explicit route is not continuous at edge {i}");
+            }
+        } else {
+            steps.push(from);
         }
-        let to = &entry["to"];
-        steps.push(parse_path_node(to)?);
+        steps.push(ReductionStep {
+            name: edge.to.name,
+            variant: edge.to.variant,
+        });
     }
 
     if steps.len() < 2 {
@@ -39,127 +61,51 @@ fn load_path_file(path_file: &Path) -> Result<ReductionPath> {
     Ok(ReductionPath { steps })
 }
 
-fn parse_path_node(node: &serde_json::Value) -> Result<ReductionStep> {
-    let name = node["name"]
-        .as_str()
-        .ok_or_else(|| anyhow::anyhow!("Path node missing 'name'"))?
-        .to_string();
-    let variant: BTreeMap<String, String> = node
-        .get("variant")
-        .and_then(|v| serde_json::from_value(v.clone()).ok())
-        .unwrap_or_default();
-    Ok(ReductionStep { name, variant })
-}
-
-pub fn reduce(
-    input: &Path,
-    target: Option<&str>,
-    via: Option<&Path>,
-    out: &OutputConfig,
-) -> Result<()> {
-    // 1. Load source problem
-    let content = read_input(input)?;
-    let problem_json: ProblemJson = serde_json::from_str(&content)?;
-
+pub(crate) fn execute_route(
+    problem_json: ProblemJson,
+    reduction_path: ReductionPath,
+) -> Result<ReductionBundle> {
     let source = load_problem(
         &problem_json.problem_type,
         &problem_json.variant,
         problem_json.data.clone(),
     )?;
-
     let source_name = source.problem_name();
     let source_variant = source.variant_map();
-    let graph = ReductionGraph::new();
-
-    // 3. Get reduction path: from --via file or auto-discover
-    let reduction_path = if let Some(path_file) = via {
-        let path = load_path_file(path_file)?;
-        // Validate that the path starts with the source
-        let first = path.steps.first().unwrap();
-        let last = path.steps.last().unwrap();
-        if first.name != source_name || first.variant != source_variant {
-            anyhow::bail!(
-                "Path file starts with {}{} but source problem is {}{}",
-                first.name,
-                variant_to_full_slash(&first.variant),
-                source_name,
-                variant_to_full_slash(&source_variant),
-            );
-        }
-        // If --to is given, validate it matches the path's target
-        if let Some(target) = target {
-            let dst_ref = resolve_problem_ref(target, &graph)?;
-            if last.name != dst_ref.name || last.variant != dst_ref.variant {
-                anyhow::bail!(
-                    "Path file ends with {}{} but --to specifies {}{}",
-                    last.name,
-                    variant_to_full_slash(&last.variant),
-                    dst_ref.name,
-                    variant_to_full_slash(&dst_ref.variant),
-                );
-            }
-        }
-        path
-    } else {
-        // --to is required when --via is not given
-        let target = target.ok_or_else(|| {
-            anyhow::anyhow!(
-                "Either --to or --via is required.\n\n\
-                 Usage:\n\
-                   pred reduce problem.json --to QUBO\n\
-                   pred reduce problem.json --via path.json"
-            )
-        })?;
-        let dst_ref = resolve_problem_ref(target, &graph)?;
-
-        // Auto-discover cheapest path
-        let input_size = ProblemSize::new(vec![]);
-        let best_path = graph.find_cheapest_path_mode(
+    let first = reduction_path
+        .steps
+        .first()
+        .expect("route parser requires at least one edge");
+    if first.name != source_name || first.variant != source_variant {
+        anyhow::bail!(
+            "Explicit route starts with {}{} but source problem is {}{}",
+            first.name,
+            variant_to_full_slash(&first.name, &first.variant),
             source_name,
-            &source_variant,
-            &dst_ref.name,
-            &dst_ref.variant,
-            ReductionMode::Witness,
-            &input_size,
-            &MinimizeSteps,
+            variant_to_full_slash(source_name, &source_variant),
         );
+    }
 
-        best_path.ok_or_else(|| {
-            let variant_hint = variant_hint_for(&graph, &dst_ref.name);
-            anyhow::anyhow!(
-                "No witness-capable reduction path from {} to {}\n\
-                 {variant_hint}\n\
-                 Hint: generate a path file first, then pass it with --via:\n\
-                   pred path {} {} -o path.json\n\
-                   pred reduce {} --via path.json -o reduced.json",
-                source_name,
-                dst_ref.name,
-                source_name,
-                dst_ref.name,
-                input.display(),
-            )
-        })?
-    };
-
-    // 4. Execute reduction chain via reduce_along_path
+    let graph = ReductionGraph::new();
     let chain = graph
         .reduce_along_path(&reduction_path, source.as_any())
+        .map_err(|error| anyhow::anyhow!("Reduction path execution failed: {error}"))?
         .ok_or_else(|| {
             anyhow::anyhow!(
                 "Reduction bundles require witness-capable paths; this path cannot produce a recoverable witness."
             )
         })?;
-
-    // 5. Serialize target
-    let target_step = reduction_path.steps.last().unwrap();
+    let target_step = reduction_path
+        .steps
+        .last()
+        .expect("route parser requires at least one edge");
     let target_data = serialize_any_problem(
         &target_step.name,
         &target_step.variant,
         chain.target_problem_any(),
     )?;
 
-    // 6. Build full reduction bundle
-    let bundle = ReductionBundle {
+    Ok(ReductionBundle {
         source: ProblemJsonOutput {
             problem_type: source_name.to_string(),
             variant: source_variant,
@@ -172,30 +118,39 @@ pub fn reduce(
         },
         path: reduction_path
             .steps
-            .iter()
-            .map(|s| PathStep {
-                name: s.name.clone(),
-                variant: s.variant.clone(),
+            .into_iter()
+            .map(|step| PathStep {
+                name: step.name,
+                variant: step.variant,
             })
             .collect(),
-    };
-
-    let json = serde_json::to_value(&bundle)?;
-
-    let mut text = format!(
-        "Reduced {} to {} ({} steps)\n",
-        source_name,
-        target_step.name,
-        reduction_path.len(),
-    );
-    text.push_str(&format!("\nPath: {}\n", reduction_path));
-    text.push_str(
-        "\nHint: use -o to save the reduction bundle as JSON, or --json to print JSON to stdout.",
-    );
+    })
+}
 
-    out.emit_with_default_name("", &text, &json)?;
+pub fn reduce(input: &Path, via: &Path, out: &OutputConfig) -> Result<()> {
+    let content = read_input(input)?;
+    let problem_json: ProblemJson = serde_json::from_str(&content)?;
+    let reduction_path = load_path_file(via)?;
+    let route_len = reduction_path.len();
+    let route_text = reduction_path.to_string();
+    let bundle = execute_route(problem_json, reduction_path)?;
+
+    out.emit(
+        || {
+            let mut text = format!(
+                "Reduced {} to {} ({} steps)\n",
+                bundle.source.problem_type, bundle.target.problem_type, route_len,
+            );
+            text.push_str(&format!("\nPath: {route_text}\n"));
+            text.push_str(
+                "\nHint: use -o to save the reduction bundle as JSON, or --json to print JSON to stdout.",
+            );
+            text
+        },
+        || serde_json::to_value(&bundle).context("Failed to serialize reduction bundle"),
+    )?;
 
     Ok(())
 }
 
-use super::graph::{variant_hint_for, variant_to_full_slash};
+use super::graph::variant_to_full_slash;
diff --git a/problemreductions-cli/src/commands/solve.rs b/problemreductions-cli/src/commands/solve.rs
index 80207d44c..ce3c471de 100644
--- a/problemreductions-cli/src/commands/solve.rs
+++ b/problemreductions-cli/src/commands/solve.rs
@@ -1,6 +1,10 @@
-use crate::dispatch::{load_problem, read_input, BundleReplay, ProblemJson, ReductionBundle};
+use crate::dispatch::{
+    load_problem, read_input, solve_result_json, solver_request, BundleReplay, ProblemJson,
+    ReductionBundle,
+};
 use crate::output::OutputConfig;
 use anyhow::{Context, Result};
+use problemreductions::solvers::{SolveOutcome, SolveResult, SolverExecution, SolverRequest};
 use std::path::Path;
 use std::time::Duration;
 
@@ -28,75 +32,83 @@ fn parse_input(path: &Path) -> Result<SolveInput> {
     }
 }
 
-fn solve_result_text(problem: &str, solver: &str, result: &crate::dispatch::SolveResult) -> String {
-    let mut text = format!("Problem: {}\nSolver: {}", problem, solver);
-    if let Some(config) = &result.config {
-        text.push_str(&format!("\nSolution: {:?}", config));
+fn solver_text(solver: &SolverExecution) -> String {
+    match solver {
+        SolverExecution::Customized { implementation } => format!("customized ({implementation})"),
+        SolverExecution::Ilp { reduction_path } => {
+            format!("ilp ({})", reduction_path.join(" -> "))
+        }
+        SolverExecution::BruteForce => "brute-force".to_string(),
     }
-    text.push_str(&format!("\nEvaluation: {}", result.evaluation));
+}
+
+fn solve_result_text(problem: &str, result: &SolveResult) -> String {
+    let mut text = format!(
+        "Problem: {}\nSolver: {}",
+        problem,
+        solver_text(&result.solver)
+    );
+    append_outcome_text(&mut text, &result.outcome);
     text
 }
 
-fn solve_result_json(
-    problem: &str,
-    solver: &str,
-    result: &crate::dispatch::SolveResult,
-) -> serde_json::Value {
-    let mut json = serde_json::json!({
-        "problem": problem,
-        "solver": solver,
-        "evaluation": result.evaluation,
-    });
-    if let Some(config) = &result.config {
-        json["solution"] = serde_json::json!(config);
+fn append_outcome_text(text: &mut String, outcome: &SolveOutcome) {
+    match outcome {
+        SolveOutcome::Optimal {
+            solution,
+            evaluation,
+        } => {
+            text.push_str("\nStatus: optimal");
+            text.push_str(&format!("\nSolution: {:?}", solution));
+            text.push_str(&format!("\nEvaluation: {evaluation}"));
+        }
+        SolveOutcome::Infeasible => text.push_str("\nStatus: infeasible"),
     }
-    json
 }
 
-fn plain_problem_output(
-    problem: &str,
-    solver: &str,
-    result: &crate::dispatch::SolveResult,
-) -> (String, serde_json::Value) {
+#[cfg(test)]
+fn plain_problem_output(problem: &str, result: &SolveResult) -> (String, serde_json::Value) {
     (
-        solve_result_text(problem, solver, result),
-        solve_result_json(problem, solver, result),
+        solve_result_text(problem, result),
+        solve_result_json(problem, result),
     )
 }
 
-pub fn solve(input: &Path, solver_name: &str, timeout: u64, out: &OutputConfig) -> Result<()> {
-    if solver_name != "brute-force" && solver_name != "ilp" && solver_name != "customized" {
-        anyhow::bail!(
-            "Unknown solver: {}. Available solvers: brute-force, ilp, customized",
-            solver_name
-        );
-    }
+pub fn solve(
+    input: &Path,
+    solver_name: Option<&str>,
+    timeout: i64,
+    out: &OutputConfig,
+) -> Result<()> {
+    let request = solver_request(solver_name)?;
 
     let parsed = parse_input(input)?;
 
-    if timeout > 0 {
-        let solver_name = solver_name.to_string();
+    let timeout_seconds =
+        u64::try_from(timeout).map_err(|_| anyhow::anyhow!("timeout must be a nonnegative i64"))?;
+
+    if timeout_seconds > 0 {
         let out = out.clone();
         let (tx, rx) = std::sync::mpsc::channel();
         std::thread::spawn(move || {
             let result = match parsed {
                 SolveInput::Problem(pj) => {
-                    solve_problem(&pj.problem_type, &pj.variant, pj.data, &solver_name, &out)
+                    solve_problem(&pj.problem_type, &pj.variant, pj.data, request, &out)
                 }
-                SolveInput::Bundle(b) => solve_bundle(b, &solver_name, &out),
+                SolveInput::Bundle(b) => solve_bundle(b, request, &out),
             };
             tx.send(result).ok();
         });
-        match rx.recv_timeout(Duration::from_secs(timeout)) {
+        match rx.recv_timeout(Duration::from_secs(timeout_seconds)) {
             Ok(result) => result,
-            Err(_) => anyhow::bail!("Solve timed out after {} seconds", timeout),
+            Err(_) => anyhow::bail!("Solve timed out after {} seconds", timeout_seconds),
         }
     } else {
         match parsed {
             SolveInput::Problem(pj) => {
-                solve_problem(&pj.problem_type, &pj.variant, pj.data, solver_name, out)
+                solve_problem(&pj.problem_type, &pj.variant, pj.data, request, out)
             }
-            SolveInput::Bundle(b) => solve_bundle(b, solver_name, out),
+            SolveInput::Bundle(b) => solve_bundle(b, request, out),
         }
     }
 }
@@ -106,126 +118,58 @@ fn solve_problem(
     problem_type: &str,
     variant: &std::collections::BTreeMap<String, String>,
     data: serde_json::Value,
-    solver_name: &str,
+    request: SolverRequest,
     out: &OutputConfig,
 ) -> Result<()> {
     let problem = load_problem(problem_type, variant, data)?;
     let name = problem.problem_name();
-
-    match solver_name {
-        "brute-force" => {
-            let result = problem.solve_brute_force();
-            let (text, json) = plain_problem_output(name, "brute-force", &result);
-            let result = out.emit_with_default_name("", &text, &json);
-            if out.output.is_none() && crate::output::stderr_is_tty() {
-                out.info("\nHint: use -o to save full solution details as JSON.");
-            }
-            result
-        }
-        "ilp" => {
-            let result = problem.solve_with_ilp().map_err(add_ilp_solver_hint)?;
-            let solver_desc = if name == "ILP" {
-                "ilp".to_string()
-            } else {
-                "ilp (via ILP)".to_string()
-            };
-            let result = crate::dispatch::SolveResult {
-                config: Some(result.config),
-                evaluation: result.evaluation,
-            };
-            let text = solve_result_text(name, &solver_desc, &result);
-            let mut json = solve_result_json(name, "ilp", &result);
-            if name != "ILP" {
-                json["reduced_to"] = serde_json::json!("ILP");
-            }
-            let result = out.emit_with_default_name("", &text, &json);
-            if out.output.is_none() && crate::output::stderr_is_tty() {
-                out.info("\nHint: use -o to save full solution details as JSON.");
-            }
-            result
-        }
-        "customized" => {
-            let result = problem
-                .solve_with_customized()
-                .map_err(add_customized_solver_hint)?;
-            let result = crate::dispatch::SolveResult {
-                config: Some(result.config),
-                evaluation: result.evaluation,
-            };
-            let (text, json) = plain_problem_output(name, "customized", &result);
-            let result = out.emit_with_default_name("", &text, &json);
-            if out.output.is_none() && crate::output::stderr_is_tty() {
-                out.info("\nHint: use -o to save full solution details as JSON.");
-            }
-            result
-        }
-        _ => unreachable!(),
+    let result = problem.solve(request).map_err(add_solver_hint)?;
+    let emitted = out.emit(
+        || solve_result_text(name, &result),
+        || Ok(solve_result_json(name, &result)),
+    );
+    if out.output.is_none() && crate::output::stderr_is_tty() {
+        out.info("\nHint: use -o to save full solution details as JSON.");
     }
+    emitted
 }
 
 /// Solve a reduction bundle: solve the target problem, then map the solution back.
-fn solve_bundle(bundle: ReductionBundle, solver_name: &str, out: &OutputConfig) -> Result<()> {
+fn solve_bundle(bundle: ReductionBundle, request: SolverRequest, out: &OutputConfig) -> Result<()> {
     let replay = BundleReplay::prepare(&bundle)?;
-
-    let target_result = match solver_name {
-        "brute-force" => replay.target.solve_brute_force_witness().ok_or_else(|| {
-            anyhow::anyhow!(
-                "Bundle solving requires a witness-capable target problem and witness-capable reduction path; {} only supports aggregate-value solving.",
-                replay.target_name
-            )
-        })?,
-        "ilp" => replay.target.solve_with_ilp().map_err(add_ilp_solver_hint)?,
-        "customized" => replay
-            .target
-            .solve_with_customized()
-            .map_err(add_customized_solver_hint)?,
-        _ => unreachable!(),
-    };
-
-    let (source_config, source_eval) = replay.extract(&target_result.config);
-
-    let solver_desc = format!("{} (via {})", solver_name, replay.target_name);
-    let text = format!(
-        "Problem: {}\nSolver: {}\nSolution: {:?}\nEvaluation: {}",
-        replay.source_name, solver_desc, source_config, source_eval,
-    );
-
-    let json = serde_json::json!({
-        "problem": replay.source_name,
-        "solver": solver_name,
-        "reduced_to": replay.target_name,
-        "solution": source_config,
-        "evaluation": source_eval,
-        "intermediate": {
-            "problem": replay.target_name,
-            "solution": target_result.config,
-            "evaluation": target_result.evaluation,
+    let result = replay.solve(request).map_err(add_solver_hint)?;
+
+    let emitted = out.emit(
+        || {
+            let solver_desc = format!(
+                "{} (via {})",
+                solver_text(&result.solver),
+                result.target_name
+            );
+            let mut text = format!("Problem: {}\nSolver: {}", result.source_name, solver_desc);
+            append_outcome_text(&mut text, &result.source_outcome);
+            text
         },
-    });
-
-    let result = out.emit_with_default_name("", &text, &json);
+        || Ok(result.to_json()),
+    );
     if out.output.is_none() && crate::output::stderr_is_tty() {
         out.info("\nHint: use -o to save full solution details (including intermediate results) as JSON.");
     }
-    result
-}
-
-fn add_customized_solver_hint(err: anyhow::Error) -> anyhow::Error {
-    let message = err.to_string();
-    if message.contains("unsupported by customized solver") {
-        anyhow::anyhow!(
-            "{message}\n\nHint: the customized solver only supports select problems (FD-based models, PartialFeedbackEdgeSet, RootedTreeArrangement).\nTry `--solver brute-force` or `--solver ilp` instead."
-        )
-    } else {
-        err
-    }
+    emitted
 }
 
-fn add_ilp_solver_hint(err: anyhow::Error) -> anyhow::Error {
-    let message = err.to_string();
-    if (message.starts_with("No reduction path from ") && message.ends_with(" to ILP"))
-        || message.contains("witness-capable")
-    {
+fn add_solver_hint(err: anyhow::Error) -> anyhow::Error {
+    let missing_capability = err
+        .downcast_ref::<problemreductions::solvers::SolveError>()
+        .is_some_and(|error| {
+            matches!(
+                error,
+                problemreductions::solvers::SolveError::MissingIlpCapability(_)
+                    | problemreductions::solvers::SolveError::MissingCustomizedCapability(_)
+            )
+        });
+    if missing_capability {
+        let message = err.to_string();
         anyhow::anyhow!(
             "{message}\n\nHint: try `--solver brute-force` for direct exhaustive search on small instances."
         )
@@ -237,21 +181,23 @@ fn add_ilp_solver_hint(err: anyhow::Error) -> anyhow::Error {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::dispatch::SolveResult;
     use crate::output::OutputConfig;
     use crate::test_support::aggregate_bundle;
 
     #[test]
-    fn test_solve_value_only_problem_omits_solution() {
+    fn test_solve_result_contains_solution() {
         let result = SolveResult {
-            config: None,
-            evaluation: "Sum(56)".to_string(),
+            solver: SolverExecution::BruteForce,
+            outcome: SolveOutcome::Optimal {
+                solution: serde_json::json!([true, true, true]),
+                evaluation: "Max(14)".to_string(),
+            },
         };
-        let (text, json) =
-            plain_problem_output("CliTestAggregateValueSource", "brute-force", &result);
-        assert!(text.contains("Evaluation: Sum(56)"), "{text}");
-        assert!(!text.contains("Solution:"), "{text}");
-        assert!(json.get("solution").is_none(), "{json}");
+        let (text, json) = plain_problem_output("CliTestAggregateValueSource", &result);
+        assert!(text.contains("Evaluation: Max(14)"), "{text}");
+        assert!(text.contains("Solution:"), "{text}");
+        assert_eq!(json["solution"], serde_json::json!([true, true, true]));
+        assert_eq!(json["status"], "optimal");
     }
 
     #[test]
@@ -264,7 +210,7 @@ mod tests {
             auto_json: false,
         };
 
-        let err = solve_bundle(bundle, "brute-force", &out).unwrap_err();
+        let err = solve_bundle(bundle, SolverRequest::BruteForce, &out).unwrap_err();
         assert!(
             err.to_string().contains("witness"),
             "unexpected error: {err}"
diff --git a/problemreductions-cli/src/create_args.rs b/problemreductions-cli/src/create_args.rs
new file mode 100644
index 000000000..8c69eb2c0
--- /dev/null
+++ b/problemreductions-cli/src/create_args.rs
@@ -0,0 +1,281 @@
+use clap::parser::ValueSource;
+use clap::{Arg, ArgAction, ArgMatches, Args, Command, Error, FromArgMatches};
+use problemreductions::registry::{variant_entries, ProblemType};
+use std::collections::BTreeMap;
+use std::ffi::OsStr;
+use std::str::FromStr;
+
+use crate::cli::ExampleSide;
+
+const EXAMPLE: &str = "example";
+const EXAMPLE_TARGET: &str = "to";
+const EXAMPLE_SIDE: &str = "example-side";
+
+#[derive(Debug, Clone)]
+pub struct CreateArgs {
+    pub problem: Option<String>,
+    pub example: Option<String>,
+    pub example_target: Option<String>,
+    pub example_side: ExampleSide,
+    values: BTreeMap<String, String>,
+}
+
+impl CreateArgs {
+    pub fn raw(&self, name: &str) -> Option<&str> {
+        self.values.get(name).map(String::as_str)
+    }
+
+    pub fn has(&self, name: &str) -> bool {
+        self.values.contains_key(name)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
+    pub fn value<T>(&self, name: &str) -> Option<T>
+    where
+        T: FromStr,
+        T::Err: std::fmt::Display,
+    {
+        self.raw(name).map(|raw| {
+            raw.parse::<T>()
+                .unwrap_or_else(|error| panic!("invalid value for --{name}: {error}"))
+        })
+    }
+
+    #[cfg(test)]
+    pub fn for_test(problem: &str) -> Self {
+        Self {
+            problem: Some(problem.to_string()),
+            example: None,
+            example_target: None,
+            example_side: ExampleSide::Source,
+            values: BTreeMap::new(),
+        }
+    }
+
+    #[cfg(test)]
+    pub fn insert(&mut self, name: &str, value: impl ToString) {
+        self.values.insert(name.to_string(), value.to_string());
+    }
+}
+
+impl Args for CreateArgs {
+    fn augment_args(command: Command) -> Command {
+        command
+            .subcommand_required(false)
+            .allow_external_subcommands(true)
+            .subcommand_value_name("PROBLEM_SPEC")
+            .arg(Arg::new(EXAMPLE).long(EXAMPLE).value_name("PROBLEM_SPEC"))
+            .arg(
+                Arg::new(EXAMPLE_TARGET)
+                    .long(EXAMPLE_TARGET)
+                    .value_name("TARGET_SPEC")
+                    .requires(EXAMPLE),
+            )
+            .arg(
+                Arg::new(EXAMPLE_SIDE)
+                    .long(EXAMPLE_SIDE)
+                    .value_parser(clap::builder::EnumValueParser::<ExampleSide>::new())
+                    .default_value("source"),
+            )
+    }
+
+    fn augment_args_for_update(command: Command) -> Command {
+        Self::augment_args(command)
+    }
+}
+
+impl FromArgMatches for CreateArgs {
+    fn from_arg_matches(matches: &ArgMatches) -> Result<Self, Error> {
+        let example = matches.get_one::<String>(EXAMPLE).cloned();
+        let example_target = matches.get_one::<String>(EXAMPLE_TARGET).cloned();
+        let example_side = matches
+            .get_one::<ExampleSide>(EXAMPLE_SIDE)
+            .expect("--example-side has a default value")
+            .clone();
+
+        let (problem, values) = if let Some((problem, problem_matches)) = matches.subcommand() {
+            let values = problem_matches
+                .ids()
+                .filter_map(|id| {
+                    if problem_matches.value_source(id.as_str()) != Some(ValueSource::CommandLine) {
+                        return None;
+                    }
+                    problem_matches
+                        .get_raw(id.as_str())
+                        .and_then(|mut values| values.next())
+                        .map(|value| (id.to_string(), os_value(value)))
+                })
+                .collect();
+            (Some(problem.to_string()), values)
+        } else {
+            (None, BTreeMap::new())
+        };
+
+        Ok(Self {
+            problem,
+            example,
+            example_target,
+            example_side,
+            values,
+        })
+    }
+
+    fn update_from_arg_matches(&mut self, matches: &ArgMatches) -> Result<(), Error> {
+        *self = Self::from_arg_matches(matches)?;
+        Ok(())
+    }
+}
+
+fn os_value(value: &OsStr) -> String {
+    value
+        .to_str()
+        .expect("Clap accepted a non-UTF-8 create argument")
+        .to_string()
+}
+
+fn dimension_value<'a>(
+    variant: &'a BTreeMap<String, String>,
+    key: &str,
+    default: &'a str,
+) -> &'a str {
+    variant.get(key).map(String::as_str).unwrap_or(default)
+}
+
+fn join_spec(prefix: &str, values: &[&str]) -> String {
+    if values.is_empty() {
+        prefix.to_string()
+    } else {
+        format!("{prefix}/{}", values.join("/"))
+    }
+}
+
+fn add_selected_problem_args(
+    mut command: Command,
+    canonical: &str,
+    variant: &BTreeMap<String, String>,
+) -> Command {
+    let inputs = crate::commands::create::create_inputs_for(canonical, variant);
+
+    for input in inputs {
+        let mut arg = Arg::new(input.name.clone()).long(input.name.clone());
+        if input.kind == crate::commands::create::InputValueKind::Bool {
+            arg = arg.action(ArgAction::SetTrue);
+        } else {
+            arg = arg
+                .action(ArgAction::Set)
+                .value_name("VALUE")
+                .allow_hyphen_values(true);
+            arg = add_value_parser(arg, input.kind);
+        }
+        command = command.arg(arg);
+    }
+    command
+}
+
+pub(crate) fn command_for_selected_problem(
+    mut command: Command,
+    selected: &str,
+) -> Result<Command, Error> {
+    let spec = crate::problem_name::parse_problem_spec(selected)
+        .map_err(|error| invalid_problem_spec(&command, error.to_string()))?;
+    let problem = problemreductions::registry::find_problem_type(&spec.name).ok_or_else(|| {
+        invalid_problem_spec(
+            &command,
+            crate::problem_name::unknown_problem_error(&spec.name),
+        )
+    })?;
+    let problem_ref =
+        problemreductions::registry::ProblemRef::from_values(&problem, &spec.variant_values)
+            .map_err(|error| invalid_problem_spec(&command, error.to_string()))?;
+    if problemreductions::registry::find_variant_entry(problem_ref.name(), problem_ref.variant())
+        .is_none()
+    {
+        return Err(invalid_problem_spec(
+            &command,
+            format!(
+                "No concrete variant is registered for {} with {:?}",
+                problem_ref.name(),
+                problem_ref.variant()
+            ),
+        ));
+    }
+
+    let canonical_spec = canonical_problem_spec(&problem, problem_ref.variant());
+    let mut selected_command = Command::new(canonical_spec.clone())
+        .about(problem.description)
+        .long_about(format!(
+            "Create a {} instance ({canonical_spec})",
+            problem.canonical_name
+        ))
+        .disable_help_subcommand(true);
+    if selected != canonical_spec {
+        selected_command = selected_command.alias(selected.to_string());
+    }
+    selected_command = add_selected_problem_args(
+        selected_command,
+        problem.canonical_name,
+        problem_ref.variant(),
+    );
+
+    let create = command
+        .find_subcommand_mut("create")
+        .expect("Cli has a create subcommand");
+    *create = std::mem::take(create)
+        .allow_external_subcommands(false)
+        .subcommand(selected_command);
+    Ok(command)
+}
+
+fn invalid_problem_spec(command: &Command, message: String) -> Error {
+    command
+        .clone()
+        .error(clap::error::ErrorKind::InvalidSubcommand, message)
+}
+
+fn canonical_problem_spec(problem: &ProblemType, variant: &BTreeMap<String, String>) -> String {
+    let values = problem
+        .dimensions
+        .iter()
+        .filter_map(|dimension| {
+            let value = dimension_value(variant, dimension.key, dimension.default_value);
+            (value != dimension.default_value).then_some(value)
+        })
+        .collect::<Vec<_>>();
+    join_spec(problem.canonical_name, &values)
+}
+
+pub(crate) fn resolve_registered_create_variant(
+    selected: &str,
+) -> (&'static str, BTreeMap<String, String>) {
+    let mut parts = selected.split('/');
+    let canonical = parts.next().expect("registered command has a name");
+    let problem = problemreductions::registry::find_problem_type(canonical)
+        .unwrap_or_else(|| panic!("missing schema for registered create command `{selected}`"));
+    let values = parts.collect::<Vec<_>>();
+
+    if values.is_empty() {
+        return variant_entries()
+            .into_iter()
+            .find(|entry| entry.name == canonical && entry.is_default)
+            .map(|entry| (problem.canonical_name, entry.variant_map()))
+            .unwrap_or_else(|| panic!("missing default variant for `{canonical}`"));
+    }
+
+    let problem_ref = problemreductions::registry::ProblemRef::from_values(&problem, values)
+        .unwrap_or_else(|error| panic!("invalid registered create command `{selected}`: {error}"));
+    (problem.canonical_name, problem_ref.variant().clone())
+}
+
+fn add_value_parser(arg: Arg, kind: crate::commands::create::InputValueKind) -> Arg {
+    use crate::commands::create::InputValueKind;
+    match kind {
+        InputValueKind::Usize => arg.value_parser(clap::value_parser!(usize)),
+        InputValueKind::I64 => arg.value_parser(clap::value_parser!(i64)),
+        InputValueKind::F64 => arg.value_parser(clap::value_parser!(f64)),
+        InputValueKind::Text => arg,
+        InputValueKind::Bool => unreachable!("boolean inputs use SetTrue"),
+    }
+}
diff --git a/problemreductions-cli/src/dispatch.rs b/problemreductions-cli/src/dispatch.rs
index 4849373b7..341125bb4 100644
--- a/problemreductions-cli/src/dispatch.rs
+++ b/problemreductions-cli/src/dispatch.rs
@@ -1,8 +1,10 @@
 use anyhow::{Context, Result};
 use problemreductions::registry::{DynProblem, LoadedDynProblem};
-use problemreductions::rules::{MinimizeSteps, ReductionGraph, ReductionMode};
-use problemreductions::solvers::{CustomizedSolver, ILPSolver};
-use problemreductions::types::ProblemSize;
+use problemreductions::rules::ReductionGraph;
+use problemreductions::solvers::{
+    brute_force_dimensions, solve, solver_capabilities, ExactProblemKey, SolveOutcome, SolveResult,
+    SolverRequest,
+};
 use serde_json::Value;
 use std::any::Any;
 use std::collections::BTreeMap;
@@ -37,80 +39,151 @@ impl std::ops::Deref for LoadedProblem {
 }
 
 impl LoadedProblem {
-    pub fn solve_brute_force_value(&self) -> String {
-        self.inner.solve_brute_force_value()
+    pub fn brute_force_num_variables(&self) -> Result<Option<usize>> {
+        brute_force_dimensions(&self.inner)
+            .map(|dimensions| dimensions.map(|dimensions| dimensions.len()))
+            .map_err(|error| anyhow::anyhow!("solver capability registry is invalid: {error}"))
     }
 
-    pub fn solve_brute_force_witness(&self) -> Option<WitnessSolveResult> {
-        let (config, evaluation) = self.inner.solve_brute_force_witness()?;
-        Some(WitnessSolveResult { config, evaluation })
+    pub fn solve(&self, request: SolverRequest) -> Result<SolveResult> {
+        solve(&self.inner, request).map_err(anyhow::Error::from)
     }
+}
+
+#[derive(Clone, Debug, serde::Serialize)]
+pub struct CustomizedSolverCapabilityView {
+    pub implementation: &'static str,
+}
 
-    pub fn solve_brute_force(&self) -> SolveResult {
-        let evaluation = self.solve_brute_force_value();
-        let config = self.solve_brute_force_witness().map(|result| result.config);
-        SolveResult { config, evaluation }
+#[derive(Clone, Debug, serde::Serialize)]
+pub struct IlpSolverCapabilityView {
+    pub reduction_path: Vec<String>,
+}
+
+#[derive(Clone, Debug, serde::Serialize)]
+pub struct SolverCapabilityDetailsView {
+    pub customized: Option<CustomizedSolverCapabilityView>,
+    pub ilp: Option<IlpSolverCapabilityView>,
+    pub brute_force: bool,
+}
+
+#[derive(Clone, Debug, serde::Serialize)]
+pub struct SolverCapabilitiesView {
+    pub solvers: Vec<&'static str>,
+    pub default_solver: &'static str,
+    pub capabilities: SolverCapabilityDetailsView,
+}
+
+pub fn solver_capabilities_view(problem: &LoadedProblem) -> Result<SolverCapabilitiesView> {
+    let key = ExactProblemKey::new(problem.problem_name(), problem.variant_map());
+    let registered = solver_capabilities(&key)
+        .map_err(|error| anyhow::anyhow!("solver capability registry is invalid: {error}"))?;
+    let customized = registered
+        .customized
+        .map(|entry| CustomizedSolverCapabilityView {
+            implementation: entry.implementation,
+        });
+    let ilp = registered.ilp.map(|pipeline| IlpSolverCapabilityView {
+        reduction_path: pipeline.path_labels(),
+    });
+    let default_solver = if customized.is_some() {
+        "customized"
+    } else if ilp.is_some() {
+        "ilp"
+    } else if registered.brute_force {
+        "brute-force"
+    } else {
+        anyhow::bail!("no solver is registered for {}", key.label());
+    };
+    let mut solvers = Vec::with_capacity(3);
+    if customized.is_some() {
+        solvers.push("customized");
     }
+    if ilp.is_some() {
+        solvers.push("ilp");
+    }
+    if registered.brute_force {
+        solvers.push("brute-force");
+    }
+
+    Ok(SolverCapabilitiesView {
+        solvers,
+        default_solver,
+        capabilities: SolverCapabilityDetailsView {
+            customized,
+            ilp,
+            brute_force: registered.brute_force,
+        },
+    })
+}
 
-    pub fn supports_ilp_solver(&self) -> bool {
-        let name = self.problem_name();
-        let variant = self.variant_map();
-        name == "ILP" || {
-            let graph = ReductionGraph::new();
-            let ilp_variants = graph.variants_for("ILP");
-            let input_size = ProblemSize::new(vec![]);
-            ilp_variants.iter().any(|dv| {
-                graph
-                    .find_cheapest_path_mode(
-                        name,
-                        &variant,
-                        "ILP",
-                        dv,
-                        ReductionMode::Witness,
-                        &input_size,
-                        &MinimizeSteps,
-                    )
-                    .is_some()
-            })
+pub fn solver_request(solver_name: Option<&str>) -> Result<SolverRequest> {
+    match solver_name {
+        None => Ok(SolverRequest::Default),
+        Some("customized") => Ok(SolverRequest::Customized),
+        Some("ilp") => Ok(SolverRequest::Ilp),
+        Some("brute-force") => Ok(SolverRequest::BruteForce),
+        Some(other) => {
+            anyhow::bail!(
+                "Unknown solver: {other}. Available solver overrides: customized, ilp, brute-force"
+            )
         }
     }
+}
 
-    pub fn supports_customized_solver(&self) -> bool {
-        CustomizedSolver::supports_problem(self.as_any())
+pub fn solve_result_json(problem: &str, result: &SolveResult) -> serde_json::Value {
+    #[derive(serde::Serialize)]
+    struct SolveOutput<'a> {
+        problem: &'a str,
+        solver: &'a problemreductions::solvers::SolverExecution,
+        #[serde(flatten)]
+        outcome: &'a SolveOutcome,
     }
 
-    pub fn solve_with_customized(&self) -> Result<WitnessSolveResult> {
-        let solver = CustomizedSolver::new();
-        let config = solver
-            .solve_dyn(self.as_any())
-            .ok_or_else(|| anyhow::anyhow!("Problem unsupported by customized solver"))?;
-        let evaluation = self.evaluate_dyn(&config);
-        Ok(WitnessSolveResult { config, evaluation })
-    }
+    serde_json::to_value(SolveOutput {
+        problem,
+        solver: &result.solver,
+        outcome: &result.outcome,
+    })
+    .expect("solve output is serializable")
+}
+
+pub(crate) struct BundleSolveResult {
+    pub(crate) source_name: String,
+    pub(crate) target_name: String,
+    pub(crate) solver: problemreductions::solvers::SolverExecution,
+    pub(crate) source_outcome: SolveOutcome,
+    pub(crate) target_outcome: SolveOutcome,
+}
 
-    #[cfg_attr(not(feature = "mcp"), allow(dead_code))]
-    pub fn available_solvers(&self) -> Vec<&'static str> {
-        let mut solvers = Vec::new();
-        if self.supports_ilp_solver() {
-            solvers.push("ilp");
+impl BundleSolveResult {
+    pub(crate) fn to_json(&self) -> serde_json::Value {
+        #[derive(serde::Serialize)]
+        struct Intermediate<'a> {
+            problem: &'a str,
+            #[serde(flatten)]
+            outcome: &'a SolveOutcome,
         }
-        solvers.push("brute-force");
-        if self.supports_customized_solver() {
-            solvers.push("customized");
+
+        #[derive(serde::Serialize)]
+        struct BundleOutput<'a> {
+            problem: &'a str,
+            solver: &'a problemreductions::solvers::SolverExecution,
+            #[serde(flatten)]
+            outcome: &'a SolveOutcome,
+            intermediate: Intermediate<'a>,
         }
-        solvers
-    }
 
-    /// Solve using the ILP solver. If the problem is not ILP, auto-reduce to ILP first.
-    pub fn solve_with_ilp(&self) -> Result<WitnessSolveResult> {
-        let name = self.problem_name();
-        let variant = self.variant_map();
-        let solver = ILPSolver::new();
-        let config = solver
-            .try_solve_via_reduction(name, &variant, self.as_any())
-            .map_err(|err| anyhow::anyhow!(err))?;
-        let evaluation = self.evaluate_dyn(&config);
-        Ok(WitnessSolveResult { config, evaluation })
+        serde_json::to_value(BundleOutput {
+            problem: &self.source_name,
+            solver: &self.solver,
+            outcome: &self.source_outcome,
+            intermediate: Intermediate {
+                problem: &self.target_name,
+                outcome: &self.target_outcome,
+            },
+        })
+        .expect("bundle solve output is serializable")
     }
 }
 
@@ -138,7 +211,7 @@ impl BundleReplay {
     ///   (tampered/stale bundles where `target.data` disagrees with what
     ///   `reduce_along_path` actually produced are rejected)
     ///
-    /// Returns an error (not a panic) for malformed bundles or aggregate-only paths.
+    /// Returns an error (not a panic) for malformed bundles or paths without witness extraction.
     pub fn prepare(bundle: &ReductionBundle) -> Result<Self> {
         if bundle.path.len() < 2 {
             anyhow::bail!(
@@ -191,6 +264,7 @@ impl BundleReplay {
         let graph = ReductionGraph::new();
         let chain = graph
             .reduce_along_path(&reduction_path, source.as_any())
+            .map_err(|error| anyhow::anyhow!("Bundle reduction replay failed: {error}"))?
             .ok_or_else(|| anyhow::anyhow!(
                 "Bundle requires a witness-capable reduction path; this bundle cannot map a target solution back to the source."
             ))?;
@@ -219,10 +293,52 @@ impl BundleReplay {
     }
 
     /// Map a target-space configuration back to the source space and evaluate it.
-    pub fn extract(&self, target_config: &[usize]) -> (Vec<usize>, String) {
-        let source_config = self.chain.extract_solution(target_config);
-        let source_eval = self.source.evaluate_dyn(&source_config);
-        (source_config, source_eval)
+    pub fn extract(
+        &self,
+        target_config: &serde_json::Value,
+    ) -> Result<(serde_json::Value, String)> {
+        let source_config = self.chain.extract_solution_json(target_config.clone())?;
+        let source_eval = self.source.evaluate_witness_dyn(&source_config)?.ok_or_else(|| {
+            problemreductions::rules::ExtractionError::invalid(format!(
+                "extracted solution is infeasible for {}; the reduction did not establish a source solution",
+                self.source_name
+            ))
+        })?;
+        Ok((source_config, source_eval))
+    }
+
+    /// Solve the target and map the result back to the source problem.
+    ///
+    pub(crate) fn solve(&self, request: SolverRequest) -> Result<BundleSolveResult> {
+        let target_result = self.target.solve(request)?;
+        let solver = target_result.solver;
+        let (source_outcome, target_outcome) = match target_result.outcome {
+            SolveOutcome::Optimal {
+                solution: target_solution,
+                evaluation: target_evaluation,
+            } => {
+                let (source_solution, source_evaluation) = self.extract(&target_solution)?;
+                (
+                    SolveOutcome::Optimal {
+                        solution: source_solution,
+                        evaluation: source_evaluation,
+                    },
+                    SolveOutcome::Optimal {
+                        solution: target_solution,
+                        evaluation: target_evaluation,
+                    },
+                )
+            }
+            SolveOutcome::Infeasible => (SolveOutcome::Infeasible, SolveOutcome::Infeasible),
+        };
+
+        Ok(BundleSolveResult {
+            source_name: self.source_name.clone(),
+            target_name: self.target_name.clone(),
+            solver,
+            source_outcome,
+            target_outcome,
+        })
     }
 }
 
@@ -245,7 +361,11 @@ pub fn load_problem(
     data: Value,
 ) -> Result<LoadedProblem> {
     let canonical = resolve_alias(name);
-    let inner = problemreductions::registry::load_dyn(&canonical, variant, data)
+    let problem_type = problemreductions::registry::find_problem_type(&canonical)
+        .ok_or_else(|| anyhow::anyhow!("Unknown problem type: {canonical}"))?;
+    let normalized =
+        problemreductions::registry::ProblemRef::from_prefix_map(&problem_type, variant.clone())?;
+    let inner = problemreductions::registry::load_dyn(&canonical, normalized.variant(), data)
         .map_err(|e| anyhow::anyhow!(e))?;
     Ok(LoadedProblem { inner })
 }
@@ -298,24 +418,6 @@ pub struct PathStep {
     pub variant: BTreeMap<String, String>,
 }
 
-/// Result of solving a problem.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SolveResult {
-    /// The solution configuration when the problem supports witness extraction.
-    pub config: Option<Vec<usize>>,
-    /// Evaluation of the solution.
-    pub evaluation: String,
-}
-
-/// Result of solving a witness-capable problem.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct WitnessSolveResult {
-    /// The solution configuration.
-    pub config: Vec<usize>,
-    /// Evaluation of the solution.
-    pub evaluation: String,
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -325,12 +427,94 @@ mod tests {
     use problemreductions::topology::SimpleGraph;
     use serde_json::json;
 
+    #[test]
+    fn bundle_rejects_infeasible_extracted_witness() {
+        for (clauses, feasible) in [
+            (vec![vec![1, 1, 1], vec![-1, -1, -1]], false),
+            (vec![vec![1, 1, 1], vec![1, 1, 1]], true),
+        ] {
+            let source = problemreductions::models::formula::KSatisfiability::<
+                problemreductions::variant::K3,
+            >::new(
+                1,
+                clauses
+                    .into_iter()
+                    .map(problemreductions::models::formula::CNFClause::new)
+                    .collect(),
+            );
+            let source = ProblemJson {
+                problem_type: "KSatisfiability".into(),
+                variant: BTreeMap::from([("k".into(), "K3".into())]),
+                data: serde_json::to_value(source).unwrap(),
+            };
+            let route = crate::commands::reduce::parse_path_json(
+                r#"{"path":[{
+                    "from":{"name":"KSatisfiability","variant":{"k":"K3"}},
+                    "to":{"name":"MinimumVertexCover","variant":{"graph":"SimpleGraph","weight":"i64"}}
+                }]}"#,
+            ).unwrap();
+            let bundle = crate::commands::reduce::execute_route(source, route).unwrap();
+            let replay = BundleReplay::prepare(&bundle).unwrap();
+            let result = replay.solve(SolverRequest::BruteForce);
+            if feasible {
+                assert!(matches!(result.unwrap().source_outcome,
+                    SolveOutcome::Optimal { evaluation, .. } if evaluation == "Or(true)"));
+            } else {
+                let error = result.err().unwrap();
+                assert!(error
+                    .downcast_ref::<problemreductions::rules::ExtractionError>()
+                    .is_some());
+                assert!(error
+                    .to_string()
+                    .contains("extracted solution is infeasible"));
+            }
+        }
+    }
+
+    #[test]
+    fn test_float_bundle_round_trip_corpus_regression() {
+        let source = serde_json::from_value(json!({
+            "type": "ExpectedRetrievalCost",
+            "variant": {},
+            "data": {
+                "num_sectors": 3,
+                "probabilities": [
+                    0.08974358974358974, 0.24358974358974358,
+                    0.23076923076923078, 0.23076923076923078,
+                    0.038461538461538464, 0.16666666666666666
+                ]
+            }
+        }))
+        .unwrap();
+        let route = crate::commands::reduce::parse_path_json(
+            r#"{"path":[{
+                "from":{"name":"ExpectedRetrievalCost","variant":{}},
+                "to":{"name":"ILP","variant":{"coefficient":"f64","variable":"bool"}}
+            }]}"#,
+        )
+        .unwrap();
+        let bundle = crate::commands::reduce::execute_route(source, route).unwrap();
+        let encoded = serde_json::to_vec(&bundle).unwrap();
+        let mut restored: ReductionBundle = serde_json::from_slice(&encoded).unwrap();
+        assert_eq!(restored.source.data, bundle.source.data);
+        assert_eq!(restored.target.data, bundle.target.data);
+        BundleReplay::prepare(&restored).expect("an unchanged JSON bundle must replay exactly");
+
+        // A one-ULP change remains tampering; replay must not use a float tolerance.
+        let coefficient = restored.target.data["objective"][0][1].as_f64().unwrap();
+        restored.target.data["objective"][0][1] = json!(f64::from_bits(coefficient.to_bits() + 1));
+        let error = BundleReplay::prepare(&restored).err().unwrap();
+        assert!(error
+            .to_string()
+            .contains("does not match the result of replaying"));
+    }
+
     #[test]
     fn test_load_problem_alias_uses_registry_dispatch() {
-        let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+        let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
         let variant = BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]);
         let loaded =
             load_problem("MIS", &variant, serde_json::to_value(&problem).unwrap()).unwrap();
@@ -339,7 +523,7 @@ mod tests {
 
     #[test]
     fn test_load_problem_rejects_unresolved_weight_variant() {
-        let problem = BinPacking::new(vec![3i32, 3, 2, 2], 5i32);
+        let problem = BinPacking::new(vec![3i64, 3, 2, 2], 5i64).unwrap();
         let loaded = load_problem(
             "BinPacking",
             &BTreeMap::new(),
@@ -348,9 +532,29 @@ mod tests {
         assert!(loaded.is_err());
     }
 
+    #[test]
+    fn test_load_problem_fills_trailing_ilp_coefficient_variant() {
+        let data = json!({
+            "variables": [{"lower_bound": 0, "upper_bound": 1}],
+            "constraints": [],
+            "objective": [[0, 1]],
+            "sense": "Minimize"
+        });
+        let variant = BTreeMap::from([("variable".to_string(), "bool".to_string())]);
+        let loaded = load_problem("ILP", &variant, data).unwrap();
+        assert_eq!(loaded.variant_map()["variable"], "bool");
+        assert_eq!(loaded.variant_map()["coefficient"], "i64");
+    }
+
+    #[test]
+    fn test_load_problem_rejects_non_prefix_ilp_variant() {
+        let variant = BTreeMap::from([("coefficient".to_string(), "i64".to_string())]);
+        assert!(load_problem("ILP", &variant, json!({})).is_err());
+    }
+
     #[test]
     fn test_load_problem_rejects_invalid_strong_connectivity_augmentation_instance() {
-        let variant = BTreeMap::from([("weight".to_string(), "i32".to_string())]);
+        let variant = BTreeMap::from([("weight".to_string(), "i64".to_string())]);
         let data = json!({
             "graph": {
                 "num_vertices": 3,
@@ -369,8 +573,8 @@ mod tests {
 
     #[test]
     fn test_serialize_any_problem_round_trips_bin_packing() {
-        let problem = BinPacking::new(vec![3i32, 3, 2, 2], 5i32);
-        let variant = BTreeMap::from([("weight".to_string(), "i32".to_string())]);
+        let problem = BinPacking::new(vec![3i64, 3, 2, 2], 5i64).unwrap();
+        let variant = BTreeMap::from([("weight".to_string(), "i64".to_string())]);
         let json = serialize_any_problem("BinPacking", &variant, &problem as &dyn Any).unwrap();
         assert_eq!(json, serde_json::to_value(&problem).unwrap());
     }
@@ -398,7 +602,7 @@ mod tests {
     }
 
     #[test]
-    fn test_solve_brute_force_value_only_problem_has_no_witness() {
+    fn test_solve_brute_force_problem_returns_solution() {
         let loaded = load_problem(
             AGGREGATE_SOURCE_NAME,
             &BTreeMap::new(),
@@ -406,13 +610,18 @@ mod tests {
         )
         .unwrap();
 
-        let result = loaded.solve_brute_force();
-        assert_eq!(result.config, None);
-        assert_eq!(result.evaluation, "Sum(56)");
+        let result = loaded.solve(SolverRequest::BruteForce).unwrap();
+        assert_eq!(
+            result.outcome,
+            SolveOutcome::Optimal {
+                solution: serde_json::json!([true, true, true]),
+                evaluation: "Max(14)".to_string(),
+            }
+        );
     }
 
     #[test]
-    fn test_available_solvers_excludes_customized_for_unsupported_problem() {
+    fn test_default_uses_brute_force_without_registered_backend() {
         let loaded = load_problem(
             AGGREGATE_SOURCE_NAME,
             &BTreeMap::new(),
@@ -420,11 +629,15 @@ mod tests {
         )
         .unwrap();
 
-        assert!(!loaded.available_solvers().contains(&"customized"));
+        let result = loaded.solve(SolverRequest::Default).unwrap();
+        assert_eq!(
+            result.solver,
+            problemreductions::solvers::SolverExecution::BruteForce
+        );
     }
 
     #[test]
-    fn test_solve_with_customized_rejects_unsupported_problem() {
+    fn test_explicit_ilp_requires_registered_pipeline() {
         let loaded = load_problem(
             AGGREGATE_SOURCE_NAME,
             &BTreeMap::new(),
@@ -432,26 +645,73 @@ mod tests {
         )
         .unwrap();
 
-        let err = loaded.solve_with_customized().unwrap_err();
+        let err = loaded.solve(SolverRequest::Ilp).unwrap_err();
         assert!(
-            err.to_string().contains("unsupported by customized solver"),
+            err.to_string().contains("No ILP pipeline is registered"),
             "unexpected error: {err}"
         );
     }
 
     #[test]
-    fn test_solve_with_ilp_rejects_aggregate_only_problem() {
+    fn solver_request_accepts_only_documented_overrides() {
+        assert_eq!(solver_request(None).unwrap(), SolverRequest::Default);
+        assert_eq!(
+            solver_request(Some("customized")).unwrap(),
+            SolverRequest::Customized
+        );
+        assert_eq!(solver_request(Some("ilp")).unwrap(), SolverRequest::Ilp);
+        assert_eq!(
+            solver_request(Some("brute-force")).unwrap(),
+            SolverRequest::BruteForce
+        );
+        for rejected in ["auto", "implementation-id"] {
+            let error = solver_request(Some(rejected)).unwrap_err();
+            assert!(error.to_string().contains(rejected), "{error}");
+        }
+    }
+
+    #[test]
+    fn solve_result_json_preserves_structured_solver_contract() {
+        let result = SolveResult {
+            solver: problemreductions::solvers::SolverExecution::Ilp {
+                reduction_path: vec!["Source".to_string(), "ILP<i64, bool>".to_string()],
+            },
+            outcome: SolveOutcome::Optimal {
+                solution: serde_json::json!([true, false]),
+                evaluation: "Max(1)".to_string(),
+            },
+        };
+        let json = solve_result_json("Source", &result);
+
+        assert_eq!(json["problem"], "Source");
+        assert_eq!(json["solver"]["kind"], "ilp");
+        assert_eq!(json["status"], "optimal");
+        assert_eq!(
+            json["solver"]["reduction_path"],
+            serde_json::json!(["Source", "ILP<i64, bool>"])
+        );
+        assert_eq!(json["solution"], serde_json::json!([true, false]));
+        assert!(json.get("reduced_to").is_none());
+    }
+
+    #[test]
+    fn solver_capabilities_view_centralizes_default_and_available_order() {
+        use problemreductions::models::graph::RootedTreeArrangement;
+        use problemreductions::Problem;
+
+        let problem = RootedTreeArrangement::new(SimpleGraph::new(2, vec![(0, 1)]), 1);
         let loaded = load_problem(
-            AGGREGATE_SOURCE_NAME,
-            &BTreeMap::new(),
-            serde_json::to_value(AggregateValueSource::sample()).unwrap(),
+            RootedTreeArrangement::<SimpleGraph>::NAME,
+            &BTreeMap::from([("graph".to_string(), "SimpleGraph".to_string())]),
+            serde_json::to_value(problem).unwrap(),
         )
         .unwrap();
+        let view = solver_capabilities_view(&loaded).unwrap();
 
-        let err = loaded.solve_with_ilp().unwrap_err();
-        assert!(
-            err.to_string().contains("witness-capable"),
-            "unexpected error: {err}"
-        );
+        assert_eq!(view.default_solver, "customized");
+        assert_eq!(view.solvers, ["customized", "ilp", "brute-force"]);
+        assert!(view.capabilities.customized.is_some());
+        assert!(view.capabilities.ilp.is_some());
+        assert!(view.capabilities.brute_force);
     }
 }
diff --git a/problemreductions-cli/src/main.rs b/problemreductions-cli/src/main.rs
index 702199e49..9b0b23c1c 100644
--- a/problemreductions-cli/src/main.rs
+++ b/problemreductions-cli/src/main.rs
@@ -1,5 +1,6 @@
 mod cli;
 mod commands;
+mod create_args;
 mod dispatch;
 #[cfg(feature = "mcp")]
 mod mcp;
@@ -9,7 +10,7 @@ mod problem_name;
 mod test_support;
 mod util;
 
-use clap::{CommandFactory, Parser};
+use clap::CommandFactory;
 use cli::{Cli, Commands};
 use output::OutputConfig;
 
@@ -49,11 +50,17 @@ fn main() -> anyhow::Result<()> {
     };
 
     match cli.command {
-        Commands::List { rules } => {
+        Commands::List {
+            query,
+            rules,
+            category,
+            all,
+            verbose,
+        } => {
             if rules {
-                commands::graph::list_rules(&out)
+                commands::graph::list_rules(query.as_deref(), all, verbose, &out)
             } else {
-                commands::graph::list(&out)
+                commands::graph::list(query.as_deref(), category, all, verbose, &out)
             }
         }
         Commands::Show { problem } => commands::graph::show(&problem, &out),
@@ -62,19 +69,16 @@ fn main() -> anyhow::Result<()> {
         Commands::Path {
             source,
             target,
-            cost,
-            all,
-            max_paths,
-        } => commands::graph::path(&source, &target, &cost, all, max_paths, &out),
+            limit,
+            instance,
+        } => commands::graph::path(&source, &target, limit, instance.as_deref(), &out),
         Commands::ExportGraph => commands::graph::export(&out),
         Commands::Inspect(args) => commands::inspect::inspect(&args.input, &out),
         Commands::Create(args) => commands::create::create(&args, &out),
         Commands::Solve(args) => {
-            commands::solve::solve(&args.input, &args.solver, args.timeout, &out)
-        }
-        Commands::Reduce(args) => {
-            commands::reduce::reduce(&args.input, args.to.as_deref(), args.via.as_deref(), &out)
+            commands::solve::solve(&args.input, args.solver.as_deref(), args.timeout, &out)
         }
+        Commands::Reduce(args) => commands::reduce::reduce(&args.input, &args.via, &out),
         Commands::Evaluate(args) => commands::evaluate::evaluate(&args.input, &args.config, &out),
         Commands::Extract(args) => commands::extract::extract(&args.input, &args.config, &out),
         #[cfg(feature = "mcp")]
diff --git a/problemreductions-cli/src/mcp/prompts.rs b/problemreductions-cli/src/mcp/prompts.rs
index f9c4d44fa..61ac602df 100644
--- a/problemreductions-cli/src/mcp/prompts.rs
+++ b/problemreductions-cli/src/mcp/prompts.rs
@@ -69,7 +69,7 @@ pub fn list_prompts() -> Vec<Prompt> {
         ),
         Prompt::new(
             "find_reduction",
-            Some("Find the best reduction path between two problems, with cost analysis"),
+            Some("Enumerate symbolic reduction paths between two problems"),
             Some(vec![
                 PromptArgument::new("source")
                     .with_description("Source problem name or alias")
@@ -149,8 +149,8 @@ pub fn get_prompt(
                     "Compare \"{a}\" and \"{b}\".\n\n\
                      How are they related? Is there a direct reduction between them, or do \
                      they connect through intermediate problems? What are the key differences \
-                     in what they model? If one can be reduced to the other, what is the \
-                     overhead?"
+                     in what they model? If one can be reduced to the other, how does the \
+                     problem parameters change?"
                 ),
             ))
         }
@@ -163,7 +163,7 @@ pub fn get_prompt(
                 &format!(
                     "Walk me through reducing a \"{source}\" instance to \"{target}\", step \
                      by step.\n\n\
-                     1. Find the reduction path and explain the overhead.\n\
+                     1. Find the reduction path and explain how the problem parameters change at each step.\n\
                      2. Create a small, concrete example instance of \"{source}\".\n\
                      3. Reduce it to \"{target}\" and show what the transformed instance \
                         looks like.\n\
@@ -195,10 +195,9 @@ pub fn get_prompt(
             Some(prompt_result(
                 &format!("Find reduction path from {source} to {target}"),
                 &format!(
-                    "Find the best way to reduce \"{source}\" to \"{target}\".\n\n\
-                     Show me the cheapest reduction path and explain the cost at each step. \
-                     Are there alternative paths? If so, compare them — which is better for \
-                     small instances vs. large instances?"
+                    "Find reduction paths from \"{source}\" to \"{target}\".\n\n\
+                     Show each route and explain how the problem parameters change at each step. \
+                     Do not rank, prune, or recommend a route."
                 ),
             ))
         }
diff --git a/problemreductions-cli/src/mcp/tests.rs b/problemreductions-cli/src/mcp/tests.rs
index f03e93dda..65a7f15ee 100644
--- a/problemreductions-cli/src/mcp/tests.rs
+++ b/problemreductions-cli/src/mcp/tests.rs
@@ -1,535 +1,715 @@
-#[cfg(test)]
-mod tests {
-    use crate::mcp::tools::McpServer;
-    use crate::test_support::{aggregate_bundle, aggregate_problem_json};
-
-    #[test]
-    fn test_list_problems_returns_json() {
-        let server = McpServer::new();
-        let result = server.list_problems_inner();
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert!(json["num_types"].as_u64().unwrap() > 0);
-        assert!(json["problems"].as_array().unwrap().len() > 0);
-    }
+use crate::mcp::tools::{FindPathParams, McpServer, PathLimitParam};
+use crate::test_support::{aggregate_bundle, aggregate_problem_json};
+
+fn explicit_route(server: &McpServer, source: &str, target: &str, names: &[&str]) -> String {
+    let response = server
+        .find_path_inner(source, target, 999, None)
+        .expect("path enumeration");
+    let json: serde_json::Value = serde_json::from_str(&response).unwrap();
+    let entry = json["paths"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|entry| {
+            let edges = entry["path"].as_array().unwrap();
+            let mut actual = vec![edges[0]["from"]["name"].as_str().unwrap()];
+            actual.extend(
+                edges
+                    .iter()
+                    .map(|edge| edge["to"]["name"].as_str().unwrap()),
+            );
+            actual == names
+        })
+        .expect("requested explicit route");
+    serde_json::to_string(entry).unwrap()
+}
 
-    #[test]
-    fn test_show_problem_known() {
-        let server = McpServer::new();
-        let result = server.show_problem_inner("MIS");
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["name"], "MaximumIndependentSet");
-    }
+#[test]
+fn test_list_problems_returns_json() {
+    let server = McpServer::new();
+    let json: serde_json::Value =
+        serde_json::from_str(&server.list_problems_inner().unwrap()).unwrap();
+    assert!(json["num_types"].as_u64().unwrap() > 0);
+}
 
-    #[test]
-    fn test_show_problem_unknown() {
-        let server = McpServer::new();
-        let result = server.show_problem_inner("NonExistent");
-        assert!(result.is_err());
-    }
+#[test]
+fn test_show_problem_known_and_unknown() {
+    let server = McpServer::new();
+    assert!(server.show_problem_inner("MIS").is_ok());
+    assert!(server.show_problem_inner("NonExistent").is_err());
+}
 
-    #[test]
-    fn test_find_path() {
-        let server = McpServer::new();
-        let result = server.find_path_inner("MIS", "QUBO", "minimize-steps", false, 20);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert!(json["path"].as_array().unwrap().len() > 0);
-    }
+#[test]
+fn test_find_path_enumerates_without_a_mode() {
+    let server = McpServer::new();
+    let result: serde_json::Value = serde_json::from_str(
+        &server
+            .find_path_inner(
+                "MIS/SimpleGraph/i64",
+                "MaximumClique/SimpleGraph/i64",
+                20,
+                None,
+            )
+            .unwrap(),
+    )
+    .unwrap();
+    assert!(!result["paths"].as_array().unwrap().is_empty());
+}
 
-    #[test]
-    fn test_find_path_all() {
-        let server = McpServer::new();
-        let result = server.find_path_inner("MIS", "QUBO", "minimize-steps", true, 20);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        // --all returns a structured envelope
-        assert!(json["paths"].as_array().unwrap().len() > 0);
-        assert!(json["truncated"].is_boolean());
-        assert!(json["returned"].is_u64());
-        assert!(json["max_paths"].is_u64());
-    }
+#[test]
+fn test_find_path_executes_complete_instance_and_reports_actual_parameters() {
+    let server = McpServer::new();
+    let problem_json = r#"{
+            "type":"MaximumIndependentSet",
+            "variant":{"graph":"SimpleGraph","weight":"i64"},
+            "data":{"graph":{"num_vertices":5,"edges":[[0,1],[1,2],[2,3],[3,4]]},"weights":[1,1,1,1,1]}
+        }"#;
+    let result: serde_json::Value = serde_json::from_str(
+        &server
+            .find_path_inner(
+                "MIS/SimpleGraph/i64",
+                "MaximumClique/SimpleGraph/i64",
+                20,
+                Some(problem_json),
+            )
+            .unwrap(),
+    )
+    .unwrap();
+    let fields = result["paths"][0]["actual_target_parameters"]["fields"]
+        .as_array()
+        .unwrap();
+    let edges = fields
+        .iter()
+        .find(|field| field["field"] == "num_edges")
+        .unwrap();
+    assert_eq!(edges["value"], 6);
+}
 
-    #[test]
-    fn test_find_path_all_structured_response() {
-        let server = McpServer::new();
-        let result = server.find_path_inner("MIS", "QUBO", "minimize-steps", true, 20);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        // Verify the structured envelope fields
-        let paths = json["paths"].as_array().unwrap();
-        assert!(!paths.is_empty());
-        let returned = json["returned"].as_u64().unwrap() as usize;
-        assert_eq!(returned, paths.len());
-        assert_eq!(json["max_paths"].as_u64().unwrap(), 20);
-        // Each path should have steps, path, and overall_overhead
-        let first = &paths[0];
-        assert!(first["steps"].is_u64());
-        assert!(first["path"].is_array());
-        assert!(first["overall_overhead"].is_array());
-    }
+#[test]
+fn test_find_path_schema_has_no_filtering_option() {
+    let schema = serde_json::to_value(schemars::schema_for!(FindPathParams)).unwrap();
+    assert!(schema["properties"].get("unfiltered").is_none());
+    assert!(schema["properties"].get("selection").is_none());
+}
 
-    #[test]
-    fn test_find_path_no_route() {
-        let server = McpServer::new();
-        // Pick two problems with no path (if any). Use an unknown problem to trigger an error.
-        let result = server.find_path_inner("NonExistent", "QUBO", "minimize-steps", false, 20);
-        assert!(result.is_err());
-    }
+#[test]
+fn test_find_path_schema_accepts_complete_problem_json() {
+    let params: FindPathParams = serde_json::from_value(serde_json::json!({
+        "source": "MIS",
+        "target": "MaximumClique",
+        "problem_json": "{\"type\":\"MaximumIndependentSet\",\"variant\":{},\"data\":{}}"
+    }))
+    .unwrap();
+    assert!(params
+        .problem_json
+        .unwrap()
+        .contains("MaximumIndependentSet"));
+}
 
-    #[test]
-    fn test_show_problem_rejects_slash_spec() {
-        let server = McpServer::new();
-        let result = server.show_problem_inner("MIS/UnitDiskGraph");
-        assert!(result.is_err());
-        let err = result.unwrap_err().to_string();
-        assert!(
-            err.contains("type level"),
-            "error should mention type level: {err}"
-        );
-    }
+#[test]
+fn test_find_path_limit_all_resolves_to_999() {
+    let params: FindPathParams = serde_json::from_value(serde_json::json!({
+        "source": "MIS",
+        "target": "QUBO",
+        "limit": "all"
+    }))
+    .unwrap();
+    assert_eq!(params.limit.as_ref().unwrap().resolve().unwrap(), 999);
+
+    let numeric: PathLimitParam = serde_json::from_value(serde_json::json!(999)).unwrap();
+    assert_eq!(numeric.resolve().unwrap(), 999);
+
+    let numeric_string: PathLimitParam = serde_json::from_value(serde_json::json!("20")).unwrap();
+    assert!(numeric_string.resolve().is_err());
+}
 
-    #[test]
-    fn test_show_problem_marks_default() {
-        let server = McpServer::new();
-        let result = server.show_problem_inner("MIS");
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        let variants = json["variants"].as_array().unwrap();
-        // At least one variant should be marked as default
-        let has_default = variants
-            .iter()
-            .any(|v| v["is_default"].as_bool() == Some(true));
-        assert!(
-            has_default,
-            "expected at least one variant marked is_default=true"
-        );
-        // All variants should have the is_default field
-        for v in variants {
-            assert!(
-                v["is_default"].is_boolean(),
-                "expected is_default field on variant: {v}"
-            );
-        }
-    }
+#[test]
+fn test_find_path_is_capped_explicitly() {
+    let server = McpServer::new();
+    let json: serde_json::Value =
+        serde_json::from_str(&server.find_path_inner("MIS", "QUBO/f64", 1, None).unwrap()).unwrap();
+    assert_eq!(json["paths"].as_array().unwrap().len(), 1);
+    assert!(json.get("returned").is_none());
+    assert!(json.get("max_paths").is_none());
+    assert!(json.get("analysis").is_none());
+    assert_eq!(json["truncated"], true);
+}
 
-    #[test]
-    fn test_neighbors_out() {
-        let server = McpServer::new();
-        let result = server.neighbors_inner("MIS", 1, "out");
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["direction"], "out");
-        assert_eq!(json["hops"], 1);
-    }
+#[test]
+fn test_find_path_rejects_limit_above_maximum() {
+    let error = McpServer::new()
+        .find_path_inner("MIS", "QUBO", 1000, None)
+        .unwrap_err();
+    assert_eq!(
+        error.to_string(),
+        "limit must be an integer from 1 to 999 or 'all'"
+    );
+}
 
-    #[test]
-    fn test_neighbors_in() {
-        let server = McpServer::new();
-        let result = server.neighbors_inner("QUBO", 1, "in");
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["direction"], "in");
-    }
+#[test]
+fn test_neighbors_and_export_graph() {
+    let server = McpServer::new();
+    assert!(server.neighbors_inner("MIS", 1, "out").is_ok());
+    assert!(server.neighbors_inner("MIS", 1, "invalid").is_err());
+    let graph: serde_json::Value =
+        serde_json::from_str(&server.export_graph_inner().unwrap()).unwrap();
+    assert!(graph.is_object());
+}
 
-    #[test]
-    fn test_neighbors_both() {
-        let server = McpServer::new();
-        let result = server.neighbors_inner("MIS", 1, "both");
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["direction"], "both");
-    }
+// -- Instance tool tests --------------------------------------------------
 
-    #[test]
-    fn test_neighbors_unknown_problem() {
-        let server = McpServer::new();
-        let result = server.neighbors_inner("NonExistent", 1, "out");
-        assert!(result.is_err());
-    }
+fn create_test_mis(server: &McpServer) -> String {
+    let params = serde_json::json!({"graph": [[0, 1], [1, 2], [2, 3]]});
+    server
+        .create_problem_inner("MIS/SimpleGraph/i64", &params)
+        .unwrap()
+}
 
-    #[test]
-    fn test_neighbors_invalid_direction() {
-        let server = McpServer::new();
-        let result = server.neighbors_inner("MIS", 1, "invalid");
-        assert!(result.is_err());
-    }
+#[test]
+fn test_create_problem_mis() {
+    let server = McpServer::new();
+    let params = serde_json::json!({"graph": [[0, 1], [1, 2], [2, 3]]});
+    let result = server.create_problem_inner("MIS", &params);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["type"], "MaximumIndependentSet");
+}
 
-    #[test]
-    fn test_export_graph() {
-        let server = McpServer::new();
-        let result = server.export_graph_inner();
-        assert!(result.is_ok());
-        // Verify it parses as valid JSON
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert!(json.is_object());
-    }
+#[test]
+fn test_create_problem_sat() {
+    let server = McpServer::new();
+    let params = serde_json::json!({
+        "num_vars": 3,
+        "clauses": [{"literals": [1, 2]}, {"literals": [-1, 3]}]
+    });
+    let result = server.create_problem_inner("SAT", &params);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["type"], "Satisfiability");
+}
 
-    // -- Instance tool tests --------------------------------------------------
+#[test]
+fn test_create_problem_qubo() {
+    let server = McpServer::new();
+    let params = serde_json::json!({"matrix": [[1, -1], [0, 2]]});
+    let result = server.create_problem_inner("QUBO", &params);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["type"], "QUBO");
+}
 
-    fn create_test_mis(server: &McpServer) -> String {
-        let params = serde_json::json!({"edges": "0-1,1-2,2-3"});
-        server.create_problem_inner("MIS", &params).unwrap()
-    }
+#[test]
+fn test_create_problem_qubo_f64() {
+    let server = McpServer::new();
+    let params = serde_json::json!({"matrix": [[1.0, 0.5], [0.0, 2.0]]});
+    let result = server.create_problem_inner("QUBO/f64", &params);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["variant"]["weight"], "f64");
+}
 
-    #[test]
-    fn test_create_problem_mis() {
-        let server = McpServer::new();
-        let params = serde_json::json!({"edges": "0-1,1-2,2-3"});
-        let result = server.create_problem_inner("MIS", &params);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["type"], "MaximumIndependentSet");
-    }
+#[test]
+fn test_create_problem_maxcut() {
+    let server = McpServer::new();
+    let params = serde_json::json!({"graph": [[0, 1], [1, 2], [2, 0]]});
+    let result = server.create_problem_inner("MaxCut", &params);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["type"], "MaxCut");
+}
 
-    #[test]
-    fn test_create_problem_sat() {
-        let server = McpServer::new();
-        let params = serde_json::json!({"num_vars": 3, "clauses": "1,2;-1,3"});
-        let result = server.create_problem_inner("SAT", &params);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["type"], "Satisfiability");
-    }
+#[test]
+fn test_create_problem_longest_circuit() {
+    let server = McpServer::new();
+    let params = serde_json::json!({
+        "graph": [[0, 1], [1, 2], [2, 0]],
+        "edge_weights": [2, 3, 4]
+    });
+    let result = server.create_problem_inner("LongestCircuit", &params);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["type"], "LongestCircuit");
+    assert_eq!(json["data"]["edge_lengths"], serde_json::json!([2, 3, 4]));
+}
 
-    #[test]
-    fn test_create_problem_qubo() {
-        let server = McpServer::new();
-        let params = serde_json::json!({"matrix": "1,0.5;0.5,2"});
-        let result = server.create_problem_inner("QUBO", &params);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["type"], "QUBO");
-    }
+#[test]
+fn test_create_problem_longest_circuit_random() {
+    let server = McpServer::new();
+    let params = serde_json::json!({
+        "random": true,
+        "num_vertices": 5,
+        "seed": 7
+    });
+    let result = server.create_problem_inner("LongestCircuit", &params);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["type"], "LongestCircuit");
+    assert_eq!(json["data"]["graph"]["num_vertices"], 5);
+    assert!(json["data"]["edge_lengths"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .all(|length| length == 1));
+}
 
-    #[test]
-    fn test_create_problem_maxcut() {
-        let server = McpServer::new();
-        let params = serde_json::json!({"edges": "0-1,1-2,2-0"});
-        let result = server.create_problem_inner("MaxCut", &params);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["type"], "MaxCut");
-    }
+#[test]
+fn test_create_problem_kcoloring() {
+    let server = McpServer::new();
+    let params = serde_json::json!({"graph": [[0, 1], [1, 2], [2, 0]], "k": 3});
+    let result = server.create_problem_inner("KColoring", &params);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["type"], "KColoring");
+}
 
-    #[test]
-    fn test_create_problem_longest_circuit() {
-        let server = McpServer::new();
-        let params = serde_json::json!({
-            "edges": "0-1,1-2,2-0",
-            "edge_lengths": "2,3,4",
-            "bound": 3
-        });
-        let result = server.create_problem_inner("LongestCircuit", &params);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["type"], "LongestCircuit");
-        assert_eq!(json["data"]["edge_lengths"], serde_json::json!([2, 3, 4]));
-        assert_eq!(json["data"]["bound"], 3);
-    }
+#[test]
+fn test_create_problem_factoring() {
+    let server = McpServer::new();
+    let params = serde_json::json!({"target": "15"});
+    let result = server.create_problem_inner("Factoring", &params);
+    assert!(result.is_ok(), "{result:?}");
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["type"], "Factoring");
+    assert_eq!(json["data"]["target"], "15");
+    assert_eq!(json["data"]["m"], 2);
+    assert_eq!(json["data"]["n"], 3);
+}
 
-    #[test]
-    fn test_create_problem_longest_circuit_random() {
-        let server = McpServer::new();
-        let params = serde_json::json!({
-            "random": true,
-            "num_vertices": 5,
-            "seed": 7,
-            "bound": 4
-        });
-        let result = server.create_problem_inner("LongestCircuit", &params);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["type"], "LongestCircuit");
-        assert_eq!(json["data"]["bound"], 4);
-    }
+#[test]
+fn test_create_problem_unknown() {
+    let server = McpServer::new();
+    let params = serde_json::json!({"edges": "0-1"});
+    let result = server.create_problem_inner("NonExistent", &params);
+    assert!(result.is_err());
+}
 
-    #[test]
-    fn test_create_problem_kcoloring() {
-        let server = McpServer::new();
-        let params = serde_json::json!({"edges": "0-1,1-2,2-0", "k": 3});
-        let result = server.create_problem_inner("KColoring", &params);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["type"], "KColoring");
-    }
+#[test]
+fn test_create_problem_missing_edges() {
+    let server = McpServer::new();
+    let params = serde_json::json!({});
+    let result = server.create_problem_inner("MIS", &params);
+    assert!(result.is_err());
+}
 
-    #[test]
-    fn test_create_problem_factoring() {
-        let server = McpServer::new();
-        let params = serde_json::json!({"target": 15, "bits_m": 4, "bits_n": 4});
-        let result = server.create_problem_inner("Factoring", &params);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["type"], "Factoring");
-    }
+#[test]
+fn test_inspect_problem() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    let result = server.inspect_problem_inner(&problem_json);
+    assert!(result.is_ok(), "inspect failed: {result:?}");
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["type"], "MaximumIndependentSet");
+    assert_eq!(json["kind"], "problem");
+    assert!(json["brute_force_num_variables"].as_u64().unwrap() > 0);
+}
 
-    #[test]
-    fn test_create_problem_unknown() {
-        let server = McpServer::new();
-        let params = serde_json::json!({"edges": "0-1"});
-        let result = server.create_problem_inner("NonExistent", &params);
-        assert!(result.is_err());
-    }
+#[test]
+fn test_evaluate() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    let config = serde_json::json!([true, false, true, false]);
+    let result = server.evaluate_inner(&problem_json, &config);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["problem"], "MaximumIndependentSet");
+    assert_eq!(json["config"], config);
+}
 
-    #[test]
-    fn test_create_problem_missing_edges() {
-        let server = McpServer::new();
-        let params = serde_json::json!({});
-        let result = server.create_problem_inner("MIS", &params);
-        assert!(result.is_err());
-    }
+#[test]
+fn test_evaluate_wrong_config_length() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    let result = server.evaluate_inner(&problem_json, &serde_json::json!([true, false]));
+    assert!(result.is_err());
+}
 
-    #[test]
-    fn test_inspect_problem() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        let result = server.inspect_problem_inner(&problem_json);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["type"], "MaximumIndependentSet");
-        assert_eq!(json["kind"], "problem");
-        assert!(json["num_variables"].as_u64().unwrap() > 0);
-    }
+#[test]
+fn test_reduce() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    let route = explicit_route(
+        &server,
+        "MIS/SimpleGraph/i64",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
+            "QUBO",
+        ],
+    );
+    let result = server.reduce_inner(&problem_json, &route);
+    assert!(result.is_ok(), "{result:?}");
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert!(json["target"].is_object());
+    assert!(json["source"].is_object());
+    assert!(json["path"].is_array());
+}
 
-    #[test]
-    fn test_evaluate() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        let result = server.evaluate_inner(&problem_json, &[1, 0, 1, 0]);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["problem"], "MaximumIndependentSet");
-        assert_eq!(json["config"], serde_json::json!([1, 0, 1, 0]));
-    }
+#[test]
+fn test_reduce_unknown_target() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    let result = server.reduce_inner(&problem_json, "{}");
+    assert!(result.is_err());
+}
 
-    #[test]
-    fn test_evaluate_wrong_config_length() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        let result = server.evaluate_inner(&problem_json, &[1, 0]);
-        assert!(result.is_err());
-    }
+#[test]
+fn test_reduce_rejects_discontinuous_explicit_route() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    let route = explicit_route(
+        &server,
+        "MIS/SimpleGraph/i64",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
+            "QUBO",
+        ],
+    );
+    let mut route: serde_json::Value = serde_json::from_str(&route).unwrap();
+    route["path"][1]["from"]["name"] = serde_json::json!("MinimumVertexCover");
+    let error = server
+        .reduce_inner(&problem_json, &route.to_string())
+        .expect_err("discontinuous route must be rejected");
+    assert!(error.to_string().contains("not continuous"));
+}
 
-    #[test]
-    fn test_reduce() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        let result = server.reduce_inner(&problem_json, "QUBO");
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert!(json["target"].is_object());
-        assert!(json["source"].is_object());
-        assert!(json["path"].is_array());
-    }
+#[test]
+fn test_solve() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    let result = server.solve_inner(&problem_json, Some("brute-force"), None);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert!(json["solution"].is_array());
+    assert_eq!(json["solver"]["kind"], "brute-force");
+}
 
-    #[test]
-    fn test_reduce_unknown_target() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        let result = server.reduce_inner(&problem_json, "NonExistent");
-        assert!(result.is_err());
-    }
+#[test]
+fn test_solve_ilp() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    let result = server.solve_inner(&problem_json, Some("ilp"), None);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert!(json["solution"].is_array());
+}
 
-    #[test]
-    fn test_solve() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        let result = server.solve_inner(&problem_json, Some("brute-force"), None);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert!(json["solution"].is_array());
-        assert_eq!(json["solver"], "brute-force");
-    }
+#[test]
+fn deterministic_solver_dispatch_defaults_supported_problem_to_customized() {
+    let server = McpServer::new();
+    let problem_json = serde_json::json!({
+        "type": "MinimumCardinalityKey",
+        "variant": {},
+        "data": {
+            "num_attributes": 4,
+            "dependencies": [[[0], [1, 2]], [[1, 2], [3]]],
+            "bound": 2
+        }
+    })
+    .to_string();
+
+    let result = server.solve_inner(&problem_json, None, None);
+    assert!(result.is_ok(), "solve failed: {:?}", result);
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["solver"]["kind"], "customized");
+    assert_eq!(
+        json["solver"]["implementation"],
+        "fd-minimum-cardinality-key"
+    );
+    assert!(json["solution"].is_array(), "{json}");
+
+    let explicit = server
+        .solve_inner(&problem_json, Some("customized"), None)
+        .unwrap();
+    let explicit_json: serde_json::Value = serde_json::from_str(&explicit).unwrap();
+    assert_eq!(explicit_json["solver"]["kind"], "customized");
+}
 
-    #[test]
-    fn test_solve_ilp() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        let result = server.solve_inner(&problem_json, Some("ilp"), None);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert!(json["solution"].is_array());
+#[test]
+fn test_solve_unknown_solver() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    for rejected in ["auto", "fd-minimum-cardinality-key"] {
+        let error = server
+            .solve_inner(&problem_json, Some(rejected), None)
+            .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains(&format!("Unknown solver: {rejected}")),
+            "unexpected error for {rejected}: {error}"
+        );
     }
+}
 
-    #[test]
-    fn test_solve_customized_supported_problem() {
-        let server = McpServer::new();
-        let problem_json = serde_json::json!({
-            "type": "MinimumCardinalityKey",
-            "variant": {},
-            "data": {
-                "num_attributes": 4,
-                "dependencies": [[[0], [1, 2]], [[1, 2], [3]]],
-                "bound": 2
-            }
-        })
-        .to_string();
-
-        let result = server.solve_inner(&problem_json, Some("customized"), None);
-        assert!(result.is_ok(), "solve failed: {:?}", result);
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["solver"], "customized");
-        assert!(json["solution"].is_array(), "{json}");
-    }
+#[test]
+fn deterministic_solver_dispatch_mcp_output_is_repeatable_for_each_solver_class() {
+    let server = McpServer::new();
+    let problem_json = serde_json::json!({
+        "type": "RootedTreeArrangement",
+        "variant": {"graph": "SimpleGraph"},
+        "data": {
+            "graph": {"num_vertices": 3, "edges": [[0, 1], [1, 2]]},
+            "bound": 3
+        }
+    })
+    .to_string();
 
-    #[test]
-    fn test_solve_unknown_solver() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        let result = server.solve_inner(&problem_json, Some("unknown"), None);
-        assert!(result.is_err());
+    for solver in [None, Some("customized"), Some("ilp"), Some("brute-force")] {
+        let first = server.solve_inner(&problem_json, solver, None).unwrap();
+        let second = server.solve_inner(&problem_json, solver, None).unwrap();
+        assert_eq!(first, second, "{solver:?} MCP output changed");
     }
+}
 
-    #[test]
-    fn test_solve_bundle() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        // Reduce first, then solve the bundle
-        let bundle_json = server.reduce_inner(&problem_json, "QUBO").unwrap();
-        let result = server.solve_inner(&bundle_json, Some("brute-force"), None);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert!(json["solution"].is_array());
-        assert_eq!(json["problem"], "MaximumIndependentSet");
-    }
+#[test]
+fn test_solve_bundle() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    // Reduce first, then solve the bundle
+    let bundle_json = server
+        .reduce_inner(
+            &problem_json,
+            &explicit_route(
+                &server,
+                "MIS/SimpleGraph/i64",
+                "QUBO/f64",
+                &[
+                    "MaximumIndependentSet",
+                    "MaximumSetPacking",
+                    "MaximumSetPacking",
+                    "QUBO",
+                ],
+            ),
+        )
+        .unwrap();
+    let result = server.solve_inner(&bundle_json, Some("brute-force"), None);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert!(json["solution"].is_array());
+    assert_eq!(json["problem"], "MaximumIndependentSet");
+}
 
-    #[test]
-    fn test_solve_customized_bundle_rejects_unsupported_target_without_panicking() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        let bundle_json = server.reduce_inner(&problem_json, "QUBO").unwrap();
-        let result = server.solve_inner(&bundle_json, Some("customized"), None);
-        assert!(result.is_err());
-        let err = result.unwrap_err().to_string();
-        assert!(
-            err.contains("unsupported by customized solver"),
-            "unexpected error: {err}"
+#[test]
+fn test_solve_bundle_distinguishes_infeasibility_from_missing_witness_capability() {
+    let server = McpServer::new();
+
+    for (clauses, status, evaluation) in [
+        (
+            serde_json::json!([{"literals": [1]}, {"literals": [-1]}]),
+            "infeasible",
+            None,
+        ),
+        (
+            serde_json::json!([{"literals": [1]}]),
+            "optimal",
+            Some("Or(true)"),
+        ),
+    ] {
+        let problem_json = server
+            .create_problem_inner(
+                "Satisfiability",
+                &serde_json::json!({"num_vars": 1, "clauses": clauses}),
+            )
+            .unwrap();
+        let bundle_json = server
+            .reduce_inner(
+                &problem_json,
+                &explicit_route(
+                    &server,
+                    "Satisfiability",
+                    "NAESatisfiability",
+                    &["Satisfiability", "NAESatisfiability"],
+                ),
+            )
+            .unwrap();
+        let solved = server
+            .solve_inner(&bundle_json, Some("brute-force"), None)
+            .unwrap();
+        let json: serde_json::Value = serde_json::from_str(&solved).unwrap();
+
+        assert_eq!(json["status"], status);
+        assert_eq!(json.get("evaluation").and_then(|v| v.as_str()), evaluation);
+        assert_eq!(json.get("solution").is_some(), evaluation.is_some());
+        assert_eq!(json["intermediate"]["status"], status);
+        assert_eq!(
+            json["intermediate"]
+                .get("evaluation")
+                .and_then(|v| v.as_str()),
+            evaluation
+        );
+        assert_eq!(
+            json["intermediate"].get("solution").is_some(),
+            evaluation.is_some()
         );
     }
+}
 
-    #[test]
-    fn test_inspect_bundle() {
-        let server = McpServer::new();
-        let problem_json = create_test_mis(&server);
-        let bundle_json = server.reduce_inner(&problem_json, "QUBO").unwrap();
-        let result = server.inspect_problem_inner(&bundle_json);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["kind"], "bundle");
-        assert_eq!(json["source"], "MaximumIndependentSet");
-    }
+#[test]
+fn test_solve_bundle_rejects_unavailable_customized_solver() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    let bundle_json = server
+        .reduce_inner(
+            &problem_json,
+            &explicit_route(
+                &server,
+                "MIS/SimpleGraph/i64",
+                "QUBO/f64",
+                &[
+                    "MaximumIndependentSet",
+                    "MaximumSetPacking",
+                    "MaximumSetPacking",
+                    "QUBO",
+                ],
+            ),
+        )
+        .unwrap();
+    let result = server.solve_inner(&bundle_json, Some("customized"), None);
+    assert!(result.is_err());
+    let err = result.unwrap_err().to_string();
+    assert!(
+        err.contains("No customized solver is registered"),
+        "unexpected error: {err}"
+    );
+}
 
-    #[test]
-    fn test_inspect_minmaxmulticenter_lists_bruteforce_only() {
-        let server = McpServer::new();
-        let problem_json = serde_json::json!({
-            "type": "MinMaxMulticenter",
-            "variant": {"graph": "SimpleGraph", "weight": "i32"},
-            "data": {
-                "graph": {
-                    "inner": {
-                        "nodes": [null, null, null, null],
-                        "node_holes": [],
-                        "edge_property": "undirected",
-                        "edges": [[0, 1, null], [1, 2, null], [2, 3, null]]
-                    }
-                },
-                "vertex_weights": [1, 1, 1, 1],
-                "edge_lengths": [1, 1, 1],
-                "k": 2
-            }
-        })
-        .to_string();
-
-        let result = server.inspect_problem_inner(&problem_json);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        let solvers: Vec<&str> = json["solvers"]
-            .as_array()
-            .unwrap()
-            .iter()
-            .map(|v| v.as_str().unwrap())
-            .collect();
-        assert_eq!(solvers, vec!["brute-force"]);
-    }
+#[test]
+fn test_inspect_bundle() {
+    let server = McpServer::new();
+    let problem_json = create_test_mis(&server);
+    let bundle_json = server
+        .reduce_inner(
+            &problem_json,
+            &explicit_route(
+                &server,
+                "MIS/SimpleGraph/i64",
+                "QUBO/f64",
+                &[
+                    "MaximumIndependentSet",
+                    "MaximumSetPacking",
+                    "MaximumSetPacking",
+                    "QUBO",
+                ],
+            ),
+        )
+        .unwrap();
+    let result = server.inspect_problem_inner(&bundle_json);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["kind"], "bundle");
+    assert_eq!(json["source"], "MaximumIndependentSet");
+}
 
-    #[test]
-    fn test_inspect_minimum_cardinality_key_lists_customized_solver() {
-        let server = McpServer::new();
-        let problem_json = serde_json::json!({
-            "type": "MinimumCardinalityKey",
-            "variant": {},
-            "data": {
-                "num_attributes": 4,
-                "dependencies": [[[0], [1, 2]], [[1, 2], [3]]],
-                "bound": 2
-            }
-        })
-        .to_string();
-
-        let result = server.inspect_problem_inner(&problem_json);
-        assert!(result.is_ok(), "inspect failed: {:?}", result);
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        let solvers: Vec<&str> = json["solvers"]
-            .as_array()
-            .unwrap()
-            .iter()
-            .map(|v| v.as_str().unwrap())
-            .collect();
-        assert!(
-            solvers.contains(&"customized"),
-            "inspect should list customized when supported, got: {json}"
-        );
-    }
+#[test]
+fn test_inspect_minmaxmulticenter_reports_registered_ilp_pipeline() {
+    let server = McpServer::new();
+    let problem_json = serde_json::json!({
+        "type": "MinMaxMulticenter",
+        "variant": {"graph": "SimpleGraph", "weight": "i64"},
+        "data": {
+            "graph": {
+                "num_vertices": 4,
+                "edges": [[0, 1], [1, 2], [2, 3]]
+            },
+            "vertex_weights": [1, 1, 1, 1],
+            "edge_lengths": [1, 1, 1],
+            "k": 2
+        }
+    })
+    .to_string();
+
+    let result = server.inspect_problem_inner(&problem_json);
+    assert!(result.is_ok(), "inspect failed: {result:?}");
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["default_solver"], "ilp");
+    assert!(json["solver_capabilities"]["ilp"]["reduction_path"].is_array());
+}
 
-    #[test]
-    fn test_solve_sat_problem() {
-        let server = McpServer::new();
-        let params = serde_json::json!({"num_vars": 2, "clauses": "1;-2"});
-        let problem_json = server.create_problem_inner("SAT", &params).unwrap();
-        let result = server.solve_inner(&problem_json, Some("brute-force"), None);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["solver"], "brute-force");
-    }
+#[test]
+fn test_inspect_minimum_cardinality_key_reports_customized_solver() {
+    let server = McpServer::new();
+    let problem_json = serde_json::json!({
+        "type": "MinimumCardinalityKey",
+        "variant": {},
+        "data": {
+            "num_attributes": 4,
+            "dependencies": [[[0], [1, 2]], [[1, 2], [3]]],
+            "bound": 2
+        }
+    })
+    .to_string();
+
+    let result = server.inspect_problem_inner(&problem_json);
+    assert!(result.is_ok(), "inspect failed: {:?}", result);
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["default_solver"], "customized");
+    assert_eq!(
+        json["solver_capabilities"]["customized"]["implementation"],
+        "fd-minimum-cardinality-key"
+    );
+}
 
-    #[test]
-    fn test_reduce_rejects_aggregate_only_path() {
-        let server = McpServer::new();
-        let result = server.reduce_inner(&aggregate_problem_json(), "CliTestAggregateValueTarget");
-        assert!(result.is_err());
-        let err = result.unwrap_err().to_string();
-        assert!(err.contains("witness"), "unexpected error: {err}");
-    }
+#[test]
+fn test_solve_sat_problem() {
+    let server = McpServer::new();
+    let params = serde_json::json!({
+        "num_vars": 2,
+        "clauses": [{"literals": [1]}, {"literals": [-2]}]
+    });
+    let problem_json = server.create_problem_inner("SAT", &params).unwrap();
+    let result = server.solve_inner(&problem_json, Some("brute-force"), None);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["solver"]["kind"], "brute-force");
+}
 
-    #[test]
-    fn test_solve_aggregate_only_problem_omits_solution() {
-        let server = McpServer::new();
-        let result = server.solve_inner(&aggregate_problem_json(), Some("brute-force"), None);
-        assert!(result.is_ok());
-        let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
-        assert_eq!(json["evaluation"], "Sum(56)");
-        assert!(json.get("solution").is_none(), "{json}");
-    }
+#[test]
+fn test_reduce_rejects_aggregate_only_path() {
+    let server = McpServer::new();
+    let route = serde_json::json!({"path": [{
+        "from": {"name": "CliTestAggregateValueSource", "variant": {}},
+        "to": {"name": "CliTestAggregateValueTarget", "variant": {}}
+    }]})
+    .to_string();
+    let result = server.reduce_inner(&aggregate_problem_json(), &route);
+    assert!(result.is_err());
+    let err = result.unwrap_err().to_string();
+    assert!(err.contains("witness"), "unexpected error: {err}");
+}
 
-    #[test]
-    fn test_solve_ilp_rejects_aggregate_only_problem() {
-        let server = McpServer::new();
-        let result = server.solve_inner(&aggregate_problem_json(), Some("ilp"), None);
-        assert!(result.is_err());
-        let err = result.unwrap_err().to_string();
-        assert!(err.contains("witness-capable"), "unexpected error: {err}");
-    }
+#[test]
+fn test_solve_problem_includes_solution() {
+    let server = McpServer::new();
+    let result = server.solve_inner(&aggregate_problem_json(), Some("brute-force"), None);
+    assert!(result.is_ok());
+    let json: serde_json::Value = serde_json::from_str(&result.unwrap()).unwrap();
+    assert_eq!(json["evaluation"], "Max(14)");
+    assert_eq!(json["solution"], serde_json::json!([true, true, true]));
+}
 
-    #[test]
-    fn test_solve_bundle_rejects_aggregate_only_path() {
-        let server = McpServer::new();
-        let bundle_json = serde_json::to_string(&aggregate_bundle()).unwrap();
-        let result = server.solve_inner(&bundle_json, Some("brute-force"), None);
-        assert!(result.is_err());
-        let err = result.unwrap_err().to_string();
-        assert!(err.contains("witness"), "unexpected error: {err}");
-    }
+#[test]
+fn test_solve_ilp_rejects_problem_without_pipeline() {
+    let server = McpServer::new();
+    let result = server.solve_inner(&aggregate_problem_json(), Some("ilp"), None);
+    assert!(result.is_err());
+    let err = result.unwrap_err().to_string();
+    assert!(
+        err.contains("No ILP pipeline is registered"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn test_solve_bundle_rejects_aggregate_only_path() {
+    let server = McpServer::new();
+    let bundle_json = serde_json::to_string(&aggregate_bundle()).unwrap();
+    let result = server.solve_inner(&bundle_json, Some("brute-force"), None);
+    assert!(result.is_err());
+    let err = result.unwrap_err().to_string();
+    assert!(err.contains("witness"), "unexpected error: {err}");
 }
diff --git a/problemreductions-cli/src/mcp/tools.rs b/problemreductions-cli/src/mcp/tools.rs
index a0e2f1135..09cddd892 100644
--- a/problemreductions-cli/src/mcp/tools.rs
+++ b/problemreductions-cli/src/mcp/tools.rs
@@ -1,30 +1,15 @@
-use crate::util;
-use problemreductions::models::algebraic::QUBO;
-use problemreductions::models::formula::{CNFClause, NonTautology, Satisfiability};
-use problemreductions::models::graph::{
-    KClique, LongestCircuit, MaxCut, MaximumClique, MaximumIndependentSet, MaximumMatching,
-    MinimumDominatingSet, MinimumSumMulticenter, MinimumVertexCover, SpinGlass, TravelingSalesman,
-};
-use problemreductions::models::misc::Factoring;
 use problemreductions::registry::collect_schemas;
-use problemreductions::rules::{
-    CustomCost, MinimizeSteps, ReductionGraph, ReductionMode, TraversalFlow,
-};
-use problemreductions::topology::{
-    Graph, KingsSubgraph, SimpleGraph, TriangularSubgraph, UnitDiskGraph,
-};
-use problemreductions::types::ProblemSize;
-use rmcp::handler::server::router::tool::ToolRouter;
+use problemreductions::rules::{ReductionGraph, TraversalFlow};
+use problemreductions::solvers::SolverRequest;
 use rmcp::handler::server::wrapper::Parameters;
 use rmcp::tool;
-use serde::Serialize;
 use std::collections::BTreeMap;
 
 use crate::dispatch::{
-    load_problem, serialize_any_problem, BundleReplay, PathStep, ProblemJson, ProblemJsonOutput,
-    ReductionBundle,
+    load_problem, solve_result_json, solver_capabilities_view, solver_request, BundleReplay,
+    ProblemJson, ProblemJsonOutput, ReductionBundle,
 };
-use crate::problem_name::{aliases_for, resolve_problem_ref, unknown_problem_error};
+use crate::problem_name::{aliases_for, resolve_catalog_problem_ref, resolve_problem_ref};
 
 // ---------------------------------------------------------------------------
 // Parameter structs — graph query tools
@@ -46,18 +31,35 @@ pub struct NeighborsParams {
     pub direction: Option<String>,
 }
 
+#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
+#[serde(untagged)]
+pub enum PathLimitParam {
+    Number(usize),
+    Name(String),
+}
+
+impl PathLimitParam {
+    pub(crate) fn resolve(&self) -> Result<usize, String> {
+        match self {
+            Self::Number(limit) => crate::commands::graph::validate_path_limit(*limit),
+            Self::Name(limit) if limit == "all" => crate::commands::graph::parse_path_limit(limit),
+            Self::Name(_) => Err(crate::commands::graph::PATH_LIMIT_ERROR.to_string()),
+        }
+    }
+}
+
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
 pub struct FindPathParams {
     #[schemars(description = "Source problem name or alias")]
     pub source: String,
     #[schemars(description = "Target problem name or alias")]
     pub target: String,
-    #[schemars(description = "Cost function: minimize-steps (default), or minimize:<field>")]
-    pub cost: Option<String>,
-    #[schemars(description = "Return all paths instead of just the cheapest")]
-    pub all: Option<bool>,
-    #[schemars(description = "Maximum paths to return in all mode (default: 20)")]
-    pub max_paths: Option<usize>,
+    #[schemars(description = "Number of paths to inspect: 1-999, or 'all' for 999 (default: 20)")]
+    pub limit: Option<PathLimitParam>,
+    #[schemars(
+        description = "Optional complete source problem JSON. When present, execute every returned path and report actual constructed parameters."
+    )]
+    pub problem_json: Option<String>,
 }
 
 // ---------------------------------------------------------------------------
@@ -71,7 +73,7 @@ pub struct CreateProblemParams {
     )]
     pub problem_type: String,
     #[schemars(
-        description = "Problem parameters as JSON object. Graph problems: {\"edges\": \"0-1,1-2\", \"weights\": \"1,2,3\"}. SAT: {\"num_vars\": 3, \"clauses\": \"1,2;-1,3\"}. NonTautology: {\"num_vars\": 2, \"disjuncts\": \"1,2;-1,-2\"}. QUBO: {\"matrix\": \"1,0.5;0.5,2\"}. KColoring: {\"edges\": \"0-1,1-2\", \"k\": 3}. KClique: {\"edges\": \"0-1,0-2,1-3,2-3,2-4,3-4\", \"k\": 3}. Factoring: {\"target\": 15, \"bits_m\": 4, \"bits_n\": 4}. Random graph: {\"random\": true, \"num_vertices\": 10, \"edge_prob\": 0.3}. Geometry graphs (use with MIS/KingsSubgraph etc.): {\"positions\": \"0,0;1,0;1,1\"}. UnitDiskGraph: {\"positions\": \"0.0,0.0;1.0,0.0\", \"radius\": 1.5}"
+        description = "Named JSON construction inputs declared by the selected problem variant. Values must use their JSON types; unknown and missing required inputs are errors. Random graph generation remains available with {\"random\": true, \"num_vertices\": 10, \"edge_prob\": 0.3}."
     )]
     pub params: serde_json::Value,
 }
@@ -86,28 +88,28 @@ pub struct InspectParams {
 pub struct EvaluateParams {
     #[schemars(description = "Problem JSON string (from create_problem)")]
     pub problem_json: String,
-    #[schemars(
-        description = "Configuration to evaluate as array of integers (e.g., [1, 0, 1, 0])"
-    )]
-    pub config: Vec<usize>,
+    #[schemars(description = "Solution JSON matching the selected problem model's Solution type")]
+    pub config: serde_json::Value,
 }
 
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
 pub struct ReduceParams {
     #[schemars(description = "Problem JSON string (from create_problem)")]
     pub problem_json: String,
-    #[schemars(description = "Target problem type (e.g., QUBO, ILP, SpinGlass)")]
-    pub target: String,
+    #[schemars(description = "One explicit path entry selected from find_path output")]
+    pub path_json: String,
 }
 
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
 pub struct SolveParams {
     #[schemars(description = "Problem JSON string (from create_problem or reduce)")]
     pub problem_json: String,
-    #[schemars(description = "Solver: 'ilp' (default), 'brute-force', or 'customized'")]
+    #[schemars(
+        description = "Solver override: 'customized', 'ilp', or 'brute-force'; omit for default dispatch"
+    )]
     pub solver: Option<String>,
     #[schemars(description = "Timeout in seconds (0 = no limit, default: 0)")]
-    pub timeout: Option<u64>,
+    pub timeout: Option<i64>,
 }
 
 // ---------------------------------------------------------------------------
@@ -115,9 +117,7 @@ pub struct SolveParams {
 // ---------------------------------------------------------------------------
 
 #[derive(Debug, Clone)]
-pub struct McpServer {
-    tool_router: ToolRouter<Self>,
-}
+pub struct McpServer;
 
 // Tool implementations on the server struct.  Each `*_inner` method returns
 // `anyhow::Result<String>` (a JSON string) so unit tests can call them directly
@@ -125,9 +125,7 @@ pub struct McpServer {
 
 impl McpServer {
     pub fn new() -> Self {
-        Self {
-            tool_router: Self::tool_router(),
-        }
+        Self
     }
 
     // -- inner helpers (return JSON strings) ---------------------------------
@@ -183,22 +181,14 @@ impl McpServer {
             .into_iter()
             .filter(|e| &e.target_variant == variant)
             .collect();
-        let size_fields = graph.size_field_names(name);
+        let parameters = graph.parameter_names(name);
         let complexity = graph.variant_complexity(name, variant).unwrap_or("");
 
         let edge_to_json = |e: &problemreductions::rules::ReductionEdgeInfo| {
-            let overhead: Vec<serde_json::Value> = e
-                .overhead
-                .output_size
-                .iter()
-                .map(|(field, poly)| {
-                    serde_json::json!({"field": field, "formula": poly.to_string()})
-                })
-                .collect();
             serde_json::json!({
                 "source": {"name": e.source_name, "variant": e.source_variant},
                 "target": {"name": e.target_name, "variant": e.target_variant},
-                "overhead": overhead,
+                "parameter_contract": crate::commands::graph::parameter_contract_to_json(&e.parameter_contract),
             })
         };
 
@@ -207,14 +197,14 @@ impl McpServer {
             "variant": variant,
             "default": is_default,
             "complexity": complexity,
-            "size_fields": &size_fields,
+            "inputs": crate::commands::graph::construction_inputs(name, variant),
+            "parameters": &parameters,
             "reduces_to": outgoing.iter().map(&edge_to_json).collect::<Vec<_>>(),
             "reduces_from": incoming.iter().map(&edge_to_json).collect::<Vec<_>>(),
         });
-        if let Some(s) = schema {
-            if let (Some(obj), Ok(schema_val)) = (json.as_object_mut(), serde_json::to_value(s)) {
-                obj.insert("schema".to_string(), schema_val);
-            }
+        if let Some(schema) = schema {
+            json["schema"] = serde_json::to_value(schema)?;
+            json["schema"].as_object_mut().unwrap().remove("fields");
         }
 
         Ok(serde_json::to_string_pretty(&json)?)
@@ -252,105 +242,51 @@ impl McpServer {
         &self,
         source: &str,
         target: &str,
-        cost: &str,
-        all: bool,
-        max_paths: usize,
+        limit: usize,
+        problem_json: Option<&str>,
     ) -> anyhow::Result<String> {
         let graph = ReductionGraph::new();
         let src_ref = resolve_problem_ref(source, &graph)?;
         let dst_ref = resolve_problem_ref(target, &graph)?;
-
-        if all {
-            // Fetch one extra to detect truncation
-            let mut all_paths = graph.find_paths_up_to(
-                &src_ref.name,
-                &src_ref.variant,
-                &dst_ref.name,
-                &dst_ref.variant,
-                max_paths + 1,
-            );
-            if all_paths.is_empty() {
+        let loaded = problem_json
+            .map(|content| {
+                let problem: ProblemJson = serde_json::from_str(content)?;
+                load_problem(&problem.problem_type, &problem.variant, problem.data)
+            })
+            .transpose()?;
+        if let Some(loaded) = &loaded {
+            if loaded.problem_name() != src_ref.name || loaded.variant_map() != src_ref.variant {
                 anyhow::bail!(
-                    "No reduction path from {} to {}",
+                    "Source argument resolves to {} with variant {:?} but problem_json contains {} with variant {:?}",
                     src_ref.name,
-                    dst_ref.name
+                    src_ref.variant,
+                    loaded.problem_name(),
+                    loaded.variant_map(),
                 );
             }
-            all_paths.sort_by_key(|p| p.len());
-
-            let truncated = all_paths.len() > max_paths;
-            if truncated {
-                all_paths.truncate(max_paths);
-            }
-            let returned = all_paths.len();
-
-            let paths_json: Vec<serde_json::Value> = all_paths
-                .iter()
-                .map(|p| format_path_json(&graph, p))
-                .collect();
-
-            let json = serde_json::json!({
-                "paths": paths_json,
-                "truncated": truncated,
-                "returned": returned,
-                "max_paths": max_paths,
-            });
-            return Ok(serde_json::to_string_pretty(&json)?);
         }
 
-        // Single best path
-        let input_size = ProblemSize::new(vec![]);
-
-        let cost_field: Option<String> = if cost == "minimize-steps" {
-            None
-        } else if let Some(field) = cost.strip_prefix("minimize:") {
-            Some(field.to_string())
-        } else {
+        let batch = crate::commands::graph::find_path_batch(
+            &graph,
+            &src_ref.name,
+            &src_ref.variant,
+            &dst_ref.name,
+            &dst_ref.variant,
+            limit,
+        )?;
+        if batch.paths.is_empty() && !batch.truncated {
             anyhow::bail!(
-                "Unknown cost function: {}. Use 'minimize-steps' or 'minimize:<field>'",
-                cost
+                "No reduction path from {} to {}",
+                src_ref.name,
+                dst_ref.name
             );
-        };
-
-        let best_path = match cost_field {
-            None => graph.find_cheapest_path(
-                &src_ref.name,
-                &src_ref.variant,
-                &dst_ref.name,
-                &dst_ref.variant,
-                &input_size,
-                &MinimizeSteps,
-            ),
-            Some(ref f) => {
-                let cost_fn = CustomCost(
-                    |overhead: &problemreductions::rules::ReductionOverhead, size: &ProblemSize| {
-                        overhead.evaluate_output_size(size).get(f).unwrap_or(0) as f64
-                    },
-                );
-                graph.find_cheapest_path(
-                    &src_ref.name,
-                    &src_ref.variant,
-                    &dst_ref.name,
-                    &dst_ref.variant,
-                    &input_size,
-                    &cost_fn,
-                )
-            }
-        };
-
-        match best_path {
-            Some(ref reduction_path) => {
-                let json = format_path_json(&graph, reduction_path);
-                Ok(serde_json::to_string_pretty(&json)?)
-            }
-            None => {
-                anyhow::bail!(
-                    "No reduction path from {} to {}",
-                    src_ref.name,
-                    dst_ref.name
-                );
-            }
         }
+        let executed = loaded
+            .as_ref()
+            .map(|source| graph.execute_paths(&batch.paths, source.as_any()))
+            .transpose()?;
+        let json = crate::commands::graph::path_batch_json(&graph, &batch, executed.as_deref())?;
+        Ok(serde_json::to_string_pretty(&json)?)
     }
 
     pub fn export_graph_inner(&self) -> anyhow::Result<String> {
@@ -368,14 +304,15 @@ impl McpServer {
         problem_type: &str,
         params: &serde_json::Value,
     ) -> anyhow::Result<String> {
-        let rgraph = ReductionGraph::new();
-        let resolved = resolve_problem_ref(problem_type, &rgraph)?;
-        let canonical = resolved.name.clone();
-        let resolved_variant = resolved.variant;
-        let graph_type = resolved_variant
-            .get("graph")
-            .map(|s| s.as_str())
-            .unwrap_or("SimpleGraph");
+        let resolved = resolve_catalog_problem_ref(problem_type)?;
+        let canonical = resolved.name().to_string();
+        let resolved_variant = resolved.variant().clone();
+        let entry = problemreductions::registry::find_variant_entry(&canonical, &resolved_variant)
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "No concrete variant is registered for {canonical} with {resolved_variant:?}"
+                )
+            })?;
 
         // Check for random generation
         let is_random = params
@@ -384,338 +321,41 @@ impl McpServer {
             .unwrap_or(false);
 
         if is_random {
-            return self.create_random_inner(&canonical, &resolved_variant, params);
+            return self.generate_registered_random_inner(entry, params);
         }
 
-        let (data, variant) = match canonical.as_str() {
-            "MaximumIndependentSet"
-            | "MinimumVertexCover"
-            | "MaximumClique"
-            | "MinimumDominatingSet" => {
-                create_vertex_weight_from_params(&canonical, graph_type, &resolved_variant, params)?
-            }
-
-            "MaxCut" | "MaximumMatching" | "TravelingSalesman" => {
-                let (graph, _) = parse_graph_from_params(params)?;
-                let edge_weights = parse_edge_weights_from_params(params, graph.num_edges())?;
-                ser_edge_weight_problem(&canonical, graph, edge_weights)?
-            }
-
-            "LongestCircuit" => {
-                let (graph, _) = parse_graph_from_params(params)?;
-                let edge_lengths = parse_edge_lengths_from_params(params, graph.num_edges())?;
-                if edge_lengths.iter().any(|&length| length <= 0) {
-                    anyhow::bail!("LongestCircuit edge lengths must be positive (> 0)");
-                }
-                let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-                (ser(LongestCircuit::new(graph, edge_lengths))?, variant)
-            }
-
-            "KColoring" => {
-                let (graph, _) = parse_graph_from_params(params)?;
-                let k_flag = params.get("k").and_then(|v| v.as_u64()).map(|v| v as usize);
-                let (k, _variant) =
-                    util::validate_k_param(&resolved_variant, k_flag, None, "KColoring")?;
-                util::ser_kcoloring(graph, k)?
-            }
-
-            "KClique" => {
-                let (graph, _) = parse_graph_from_params(params)?;
-                let k_flag = params.get("k").and_then(|v| v.as_u64()).map(|v| v as usize);
-                let k = parse_kclique_threshold(k_flag, graph.num_vertices())?;
-                (
-                    ser(KClique::new(graph, k))?,
-                    variant_map(&[("graph", "SimpleGraph")]),
-                )
-            }
-
-            // SAT
-            "Satisfiability" => {
-                let num_vars = params
-                    .get("num_vars")
-                    .and_then(|v| v.as_u64())
-                    .map(|v| v as usize)
-                    .ok_or_else(|| anyhow::anyhow!("Satisfiability requires 'num_vars'"))?;
-                let clauses = parse_clauses_from_params(params)?;
-                let variant = BTreeMap::new();
-                (ser(Satisfiability::new(num_vars, clauses))?, variant)
-            }
-            "NonTautology" => {
-                let num_vars = params
-                    .get("num_vars")
-                    .and_then(|v| v.as_u64())
-                    .map(|v| v as usize)
-                    .ok_or_else(|| anyhow::anyhow!("NonTautology requires 'num_vars'"))?;
-                let disjuncts = parse_disjuncts_from_params(params)?;
-                let variant = BTreeMap::new();
-                (ser(NonTautology::new(num_vars, disjuncts))?, variant)
-            }
-            "KSatisfiability" => {
-                let num_vars = params
-                    .get("num_vars")
-                    .and_then(|v| v.as_u64())
-                    .map(|v| v as usize)
-                    .ok_or_else(|| anyhow::anyhow!("KSatisfiability requires 'num_vars'"))?;
-                let clauses = parse_clauses_from_params(params)?;
-                let k_flag = params.get("k").and_then(|v| v.as_u64()).map(|v| v as usize);
-                let (k, _variant) =
-                    util::validate_k_param(&resolved_variant, k_flag, Some(3), "KSatisfiability")?;
-                util::ser_ksat(num_vars, clauses, k)?
-            }
-
-            // QUBO
-            "QUBO" => {
-                let matrix = parse_matrix_from_params(params)?;
-                let variant = BTreeMap::new();
-                (ser(QUBO::from_matrix(matrix))?, variant)
-            }
-
-            // SpinGlass
-            "SpinGlass" => {
-                let (graph, n) = parse_graph_from_params(params)?;
-                let edge_weights = parse_edge_weights_from_params(params, graph.num_edges())?;
-                let fields = vec![0i32; n];
-                let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-                (
-                    ser(SpinGlass::from_graph(graph, edge_weights, fields))?,
-                    variant,
-                )
-            }
-
-            // Factoring
-            "Factoring" => {
-                let target = params
-                    .get("target")
-                    .and_then(|v| v.as_u64())
-                    .ok_or_else(|| anyhow::anyhow!("Factoring requires 'target'"))?;
-                let bits_m = params
-                    .get("bits_m")
-                    .and_then(|v| v.as_u64())
-                    .map(|v| v as usize)
-                    .ok_or_else(|| anyhow::anyhow!("Factoring requires 'bits_m'"))?;
-                let bits_n = params
-                    .get("bits_n")
-                    .and_then(|v| v.as_u64())
-                    .map(|v| v as usize)
-                    .ok_or_else(|| anyhow::anyhow!("Factoring requires 'bits_n'"))?;
-                let variant = BTreeMap::new();
-                (ser(Factoring::new(bits_m, bits_n, target))?, variant)
-            }
-
-            // MinimumSumMulticenter (p-median)
-            "MinimumSumMulticenter" => {
-                let (graph, n) = parse_graph_from_params(params)?;
-                let vertex_weights = parse_vertex_weights_from_params(params, n)?;
-                let edge_lengths = parse_edge_lengths_from_params(params, graph.num_edges())?;
-                let k = params
-                    .get("k")
-                    .and_then(|v| v.as_u64())
-                    .map(|v| v as usize)
-                    .ok_or_else(|| {
-                        anyhow::anyhow!("MinimumSumMulticenter requires 'k' (number of centers)")
-                    })?;
-                let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-                (
-                    ser(MinimumSumMulticenter::new(
-                        graph,
-                        vertex_weights,
-                        edge_lengths,
-                        k,
-                    ))?,
-                    variant,
-                )
-            }
-
-            _ => anyhow::bail!("{}", unknown_problem_error(&canonical)),
-        };
+        let normalized = normalize_mcp_create_inputs(params)?;
+        let problem = (entry.construct_fn)(normalized)?;
 
         let output = ProblemJsonOutput {
-            problem_type: canonical,
-            variant,
-            data,
+            problem_type: problem.problem_name().to_string(),
+            variant: problem.variant_map(),
+            data: problem.serialize_json(),
         };
         Ok(serde_json::to_string_pretty(&output)?)
     }
 
-    fn create_random_inner(
+    fn generate_registered_random_inner(
         &self,
-        canonical: &str,
-        resolved_variant: &BTreeMap<String, String>,
+        entry: &problemreductions::registry::VariantEntry,
         params: &serde_json::Value,
     ) -> anyhow::Result<String> {
-        let num_vertices = params
-            .get("num_vertices")
-            .and_then(|v| v.as_u64())
-            .map(|v| v as usize)
-            .ok_or_else(|| {
-                anyhow::anyhow!("Random generation requires 'num_vertices' parameter")
-            })?;
-        let seed = params.get("seed").and_then(|v| v.as_u64());
-        let graph_type = resolved_variant
-            .get("graph")
-            .map(|s| s.as_str())
-            .unwrap_or("SimpleGraph");
-
-        let (data, variant) = match canonical {
-            "MaximumIndependentSet"
-            | "MinimumVertexCover"
-            | "MaximumClique"
-            | "MinimumDominatingSet" => {
-                let weights = vec![1i32; num_vertices];
-                match graph_type {
-                    "KingsSubgraph" => {
-                        let positions = util::create_random_int_positions(num_vertices, seed);
-                        let graph = KingsSubgraph::new(positions);
-                        (
-                            ser_vertex_weight_problem_generic(canonical, graph, weights)?,
-                            resolved_variant.clone(),
-                        )
-                    }
-                    "TriangularSubgraph" => {
-                        let positions = util::create_random_int_positions(num_vertices, seed);
-                        let graph = TriangularSubgraph::new(positions);
-                        (
-                            ser_vertex_weight_problem_generic(canonical, graph, weights)?,
-                            resolved_variant.clone(),
-                        )
-                    }
-                    "UnitDiskGraph" => {
-                        let radius = params.get("radius").and_then(|v| v.as_f64()).unwrap_or(1.0);
-                        let positions = util::create_random_float_positions(num_vertices, seed);
-                        let graph = UnitDiskGraph::new(positions, radius);
-                        (
-                            ser_vertex_weight_problem_generic(canonical, graph, weights)?,
-                            resolved_variant.clone(),
-                        )
-                    }
-                    _ => {
-                        let edge_prob = params
-                            .get("edge_prob")
-                            .and_then(|v| v.as_f64())
-                            .unwrap_or(0.5);
-                        if !(0.0..=1.0).contains(&edge_prob) {
-                            anyhow::bail!("edge_prob must be between 0.0 and 1.0");
-                        }
-                        let graph = util::create_random_graph(num_vertices, edge_prob, seed);
-                        ser_vertex_weight_problem(canonical, graph, weights)?
-                    }
-                }
-            }
-            "MaxCut" | "MaximumMatching" | "TravelingSalesman" => {
-                let edge_prob = params
-                    .get("edge_prob")
-                    .and_then(|v| v.as_f64())
-                    .unwrap_or(0.5);
-                if !(0.0..=1.0).contains(&edge_prob) {
-                    anyhow::bail!("edge_prob must be between 0.0 and 1.0");
-                }
-                let graph = util::create_random_graph(num_vertices, edge_prob, seed);
-                let num_edges = graph.num_edges();
-                let edge_weights = vec![1i32; num_edges];
-                ser_edge_weight_problem(canonical, graph, edge_weights)?
-            }
-            "LongestCircuit" => {
-                let edge_prob = params
-                    .get("edge_prob")
-                    .and_then(|v| v.as_f64())
-                    .unwrap_or(0.5);
-                if !(0.0..=1.0).contains(&edge_prob) {
-                    anyhow::bail!("edge_prob must be between 0.0 and 1.0");
-                }
-                let graph = util::create_random_graph(num_vertices, edge_prob, seed);
-                let edge_lengths = vec![1i32; graph.num_edges()];
-                let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-                (ser(LongestCircuit::new(graph, edge_lengths))?, variant)
-            }
-            "SpinGlass" => {
-                let edge_prob = params
-                    .get("edge_prob")
-                    .and_then(|v| v.as_f64())
-                    .unwrap_or(0.5);
-                if !(0.0..=1.0).contains(&edge_prob) {
-                    anyhow::bail!("edge_prob must be between 0.0 and 1.0");
-                }
-                let graph = util::create_random_graph(num_vertices, edge_prob, seed);
-                let num_edges = graph.num_edges();
-                let couplings = vec![1i32; num_edges];
-                let fields = vec![0i32; num_vertices];
-                let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-                (
-                    ser(SpinGlass::from_graph(graph, couplings, fields))?,
-                    variant,
-                )
-            }
-            "KColoring" => {
-                let edge_prob = params
-                    .get("edge_prob")
-                    .and_then(|v| v.as_f64())
-                    .unwrap_or(0.5);
-                if !(0.0..=1.0).contains(&edge_prob) {
-                    anyhow::bail!("edge_prob must be between 0.0 and 1.0");
-                }
-                let graph = util::create_random_graph(num_vertices, edge_prob, seed);
-                let k_flag = params.get("k").and_then(|v| v.as_u64()).map(|v| v as usize);
-                let (k, _variant) =
-                    util::validate_k_param(resolved_variant, k_flag, Some(3), "KColoring")?;
-                util::ser_kcoloring(graph, k)?
-            }
-            "KClique" => {
-                let edge_prob = params
-                    .get("edge_prob")
-                    .and_then(|v| v.as_f64())
-                    .unwrap_or(0.5);
-                if !(0.0..=1.0).contains(&edge_prob) {
-                    anyhow::bail!("edge_prob must be between 0.0 and 1.0");
-                }
-                let graph = util::create_random_graph(num_vertices, edge_prob, seed);
-                let k_flag = params.get("k").and_then(|v| v.as_u64()).map(|v| v as usize);
-                let k = parse_kclique_threshold(k_flag, graph.num_vertices())?;
-                (
-                    ser(KClique::new(graph, k))?,
-                    variant_map(&[("graph", "SimpleGraph")]),
-                )
-            }
-            "MinimumSumMulticenter" => {
-                let edge_prob = params
-                    .get("edge_prob")
-                    .and_then(|v| v.as_f64())
-                    .unwrap_or(0.5);
-                if !(0.0..=1.0).contains(&edge_prob) {
-                    anyhow::bail!("edge_prob must be between 0.0 and 1.0");
-                }
-                let graph = util::create_random_graph(num_vertices, edge_prob, seed);
-                let num_edges = graph.num_edges();
-                let vertex_weights = vec![1i32; num_vertices];
-                let edge_lengths = vec![1i32; num_edges];
-                let k = params
-                    .get("k")
-                    .and_then(|v| v.as_u64())
-                    .map(|v| v as usize)
-                    .unwrap_or(1.max(num_vertices / 3));
-                let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-                (
-                    ser(MinimumSumMulticenter::new(
-                        graph,
-                        vertex_weights,
-                        edge_lengths,
-                        k,
-                    ))?,
-                    variant,
-                )
-            }
-            _ => anyhow::bail!(
-                "Random generation is not supported for {}. \
-                 Supported: graph-based problems (MIS, MVC, MaxCut, MaxClique, \
-                 MaximumMatching, MinimumDominatingSet, SpinGlass, KColoring, KClique, \
-                 TravelingSalesman, LongestCircuit, MinimumSumMulticenter)",
-                canonical
-            ),
-        };
-
+        let mut inputs = params
+            .as_object()
+            .ok_or_else(|| anyhow::anyhow!("random inputs must be a JSON object"))?
+            .clone();
+        inputs.remove("random");
+        let random = entry.random.ok_or_else(|| {
+            anyhow::anyhow!(
+                "Random generation is not registered for {}",
+                problemreductions::registry::variant::variant_label(entry)
+            )
+        })?;
+        let problem = (random.generate)(serde_json::Value::Object(inputs))?;
         let output = ProblemJsonOutput {
-            problem_type: canonical.to_string(),
-            variant,
-            data,
+            problem_type: problem.problem_name().to_string(),
+            variant: problem.variant_map(),
+            data: problem.serialize_json(),
         };
         Ok(serde_json::to_string_pretty(&output)?)
     }
@@ -746,40 +386,35 @@ impl McpServer {
         let variant = problem.variant_map();
         let graph = ReductionGraph::new();
 
-        let size_fields = graph.size_field_names(name);
+        let parameters = graph.parameter_names(name);
 
-        let outgoing = graph.outgoing_reductions(name);
-        let mut targets: Vec<String> = outgoing.iter().map(|e| e.target_name.to_string()).collect();
-        targets.sort();
-        targets.dedup();
-        let solvers = problem.available_solvers();
+        let targets =
+            crate::commands::inspect::executable_reduction_targets(&graph, name, &variant);
+        let solver_view = solver_capabilities_view(&problem)?;
 
         let result = serde_json::json!({
             "kind": "problem",
             "type": name,
             "variant": variant,
-            "size_fields": size_fields,
-            "num_variables": problem.num_variables_dyn(),
-            "solvers": solvers,
+            "parameters": parameters,
+            "brute_force_num_variables": problem.brute_force_num_variables()?,
+            "solvers": solver_view.solvers,
+            "default_solver": solver_view.default_solver,
+            "solver_capabilities": solver_view.capabilities,
             "reduces_to": targets,
         });
         Ok(serde_json::to_string_pretty(&result)?)
     }
 
-    pub fn evaluate_inner(&self, problem_json: &str, config: &[usize]) -> anyhow::Result<String> {
+    pub fn evaluate_inner(
+        &self,
+        problem_json: &str,
+        config: &serde_json::Value,
+    ) -> anyhow::Result<String> {
         let pj: ProblemJson = serde_json::from_str(problem_json)?;
         let problem = load_problem(&pj.problem_type, &pj.variant, pj.data)?;
 
-        let dims = problem.dims_dyn();
-        if config.len() != dims.len() {
-            anyhow::bail!(
-                "Config has {} values but problem has {} variables",
-                config.len(),
-                dims.len()
-            );
-        }
-
-        let result = problem.evaluate_dyn(config);
+        let result = problem.evaluate_dyn(config)?;
         let json = serde_json::json!({
             "problem": problem.problem_name(),
             "config": config,
@@ -788,75 +423,10 @@ impl McpServer {
         Ok(serde_json::to_string_pretty(&json)?)
     }
 
-    pub fn reduce_inner(&self, problem_json: &str, target: &str) -> anyhow::Result<String> {
+    pub fn reduce_inner(&self, problem_json: &str, path_json: &str) -> anyhow::Result<String> {
         let pj: ProblemJson = serde_json::from_str(problem_json)?;
-        let source = load_problem(&pj.problem_type, &pj.variant, pj.data.clone())?;
-
-        let source_name = source.problem_name();
-        let source_variant = source.variant_map();
-        let graph = ReductionGraph::new();
-
-        let dst_ref = resolve_problem_ref(target, &graph)?;
-
-        // Auto-discover cheapest path
-        let input_size = ProblemSize::new(vec![]);
-        let best_path = graph.find_cheapest_path_mode(
-            source_name,
-            &source_variant,
-            &dst_ref.name,
-            &dst_ref.variant,
-            ReductionMode::Witness,
-            &input_size,
-            &MinimizeSteps,
-        );
-
-        let reduction_path = best_path.ok_or_else(|| {
-            anyhow::anyhow!(
-                "No witness-capable reduction path from {} to {}",
-                source_name,
-                dst_ref.name
-            )
-        })?;
-
-        // Execute reduction chain
-        let chain = graph
-            .reduce_along_path(&reduction_path, source.as_any())
-            .ok_or_else(|| {
-                anyhow::anyhow!(
-                    "Reduction bundles require witness-capable paths; this path cannot produce a recoverable witness."
-                )
-            })?;
-
-        // Serialize target
-        let target_step = reduction_path.steps.last().unwrap();
-        let target_data = serialize_any_problem(
-            &target_step.name,
-            &target_step.variant,
-            chain.target_problem_any(),
-        )?;
-
-        // Build reduction bundle
-        let bundle = ReductionBundle {
-            source: ProblemJsonOutput {
-                problem_type: source_name.to_string(),
-                variant: source_variant,
-                data: pj.data,
-            },
-            target: ProblemJsonOutput {
-                problem_type: target_step.name.clone(),
-                variant: target_step.variant.clone(),
-                data: target_data,
-            },
-            path: reduction_path
-                .steps
-                .iter()
-                .map(|s| PathStep {
-                    name: s.name.clone(),
-                    variant: s.variant.clone(),
-                })
-                .collect(),
-        };
-
+        let reduction_path = crate::commands::reduce::parse_path_json(path_json)?;
+        let bundle = crate::commands::reduce::execute_route(pj, reduction_path)?;
         Ok(serde_json::to_string_pretty(&bundle)?)
     }
 
@@ -864,18 +434,13 @@ impl McpServer {
         &self,
         problem_json: &str,
         solver: Option<&str>,
-        timeout: Option<u64>,
+        timeout: Option<i64>,
     ) -> anyhow::Result<String> {
-        let solver_name = solver.unwrap_or("ilp");
-        if solver_name != "brute-force" && solver_name != "ilp" && solver_name != "customized" {
-            anyhow::bail!(
-                "Unknown solver: {}. Available solvers: brute-force, ilp, customized",
-                solver_name
-            );
-        }
+        let request = solver_request(solver)?;
 
         let json: serde_json::Value = serde_json::from_str(problem_json)?;
-        let timeout_secs = timeout.unwrap_or(0);
+        let timeout_secs = u64::try_from(timeout.unwrap_or(0))
+            .map_err(|_| anyhow::anyhow!("timeout must be a nonnegative i64"))?;
 
         // Detect if it's a bundle or a problem
         let is_bundle = json.get("source").is_some()
@@ -884,22 +449,18 @@ impl McpServer {
 
         if timeout_secs > 0 {
             let json_clone = json.clone();
-            let solver_name = solver_name.to_string();
             let (tx, rx) = std::sync::mpsc::channel();
             std::thread::spawn(move || {
                 let result = if is_bundle {
                     match serde_json::from_value::<ReductionBundle>(json_clone) {
-                        Ok(b) => solve_bundle_inner(b, &solver_name),
+                        Ok(b) => solve_bundle_inner(b, request),
                         Err(e) => Err(anyhow::Error::from(e)),
                     }
                 } else {
                     match serde_json::from_value::<ProblemJson>(json_clone) {
-                        Ok(pj) => solve_problem_inner(
-                            &pj.problem_type,
-                            &pj.variant,
-                            pj.data,
-                            &solver_name,
-                        ),
+                        Ok(pj) => {
+                            solve_problem_inner(&pj.problem_type, &pj.variant, pj.data, request)
+                        }
                         Err(e) => Err(anyhow::Error::from(e)),
                     }
                 };
@@ -911,10 +472,10 @@ impl McpServer {
             }
         } else if is_bundle {
             let bundle: ReductionBundle = serde_json::from_value(json)?;
-            solve_bundle_inner(bundle, solver_name)
+            solve_bundle_inner(bundle, request)
         } else {
             let pj: ProblemJson = serde_json::from_value(json)?;
-            solve_problem_inner(&pj.problem_type, &pj.variant, pj.data, solver_name)
+            solve_problem_inner(&pj.problem_type, &pj.variant, pj.data, request)
         }
     }
 }
@@ -934,7 +495,7 @@ impl McpServer {
         self.list_problems_inner().map_err(|e| e.to_string())
     }
 
-    /// Show details for a problem type: variants, fields, size fields, and reductions
+    /// Show details for a problem type: variants, fields, parameter fields, and reductions
     #[tool(
         name = "show_problem",
         annotations(read_only_hint = true, open_world_hint = false)
@@ -965,11 +526,17 @@ impl McpServer {
         annotations(read_only_hint = true, open_world_hint = false)
     )]
     fn find_path(&self, Parameters(params): Parameters<FindPathParams>) -> Result<String, String> {
-        let cost = params.cost.as_deref().unwrap_or("minimize-steps");
-        let all = params.all.unwrap_or(false);
-        let max_paths = params.max_paths.unwrap_or(20);
-        self.find_path_inner(&params.source, &params.target, cost, all, max_paths)
-            .map_err(|e| e.to_string())
+        let limit = params
+            .limit
+            .as_ref()
+            .map_or(Ok(20), PathLimitParam::resolve)?;
+        self.find_path_inner(
+            &params.source,
+            &params.target,
+            limit,
+            params.problem_json.as_deref(),
+        )
+        .map_err(|e| e.to_string())
     }
 
     /// Export the full reduction graph as JSON
@@ -994,7 +561,7 @@ impl McpServer {
             .map_err(|e| e.to_string())
     }
 
-    /// Inspect a problem JSON string or reduction bundle, returning type, size, and available operations
+    /// Inspect a problem JSON string or reduction bundle, returning type, parameters, and available operations
     #[tool(
         name = "inspect_problem",
         annotations(read_only_hint = true, open_world_hint = false)
@@ -1017,17 +584,17 @@ impl McpServer {
             .map_err(|e| e.to_string())
     }
 
-    /// Reduce a problem instance to a target problem type, returning a reduction bundle
+    /// Reduce a problem instance along an explicit enumerated route
     #[tool(
         name = "reduce",
         annotations(read_only_hint = true, open_world_hint = false)
     )]
     fn reduce(&self, Parameters(params): Parameters<ReduceParams>) -> Result<String, String> {
-        self.reduce_inner(&params.problem_json, &params.target)
+        self.reduce_inner(&params.problem_json, &params.path_json)
             .map_err(|e| e.to_string())
     }
 
-    /// Solve a problem instance using brute-force, ILP, or customized solver
+    /// Solve a problem using deterministic default dispatch or an explicit override
     #[tool(
         name = "solve",
         annotations(read_only_hint = true, open_world_hint = false)
@@ -1101,372 +668,15 @@ fn parse_direction(s: &str) -> anyhow::Result<TraversalFlow> {
     }
 }
 
-fn format_path_json(
-    graph: &ReductionGraph,
-    reduction_path: &problemreductions::rules::ReductionPath,
-) -> serde_json::Value {
-    let overheads = graph.path_overheads(reduction_path);
-    let steps_json: Vec<serde_json::Value> = reduction_path
-        .steps
-        .windows(2)
-        .zip(overheads.iter())
-        .enumerate()
-        .map(|(i, (pair, oh))| {
-            serde_json::json!({
-                "from": {"name": pair[0].name, "variant": pair[0].variant},
-                "to": {"name": pair[1].name, "variant": pair[1].variant},
-                "step": i + 1,
-                "overhead": oh.output_size.iter().map(|(field, poly)| {
-                    serde_json::json!({"field": field, "formula": poly.to_string()})
-                }).collect::<Vec<_>>(),
-            })
-        })
-        .collect();
-
-    let composed = graph.compose_path_overhead(reduction_path);
-    let overall: Vec<serde_json::Value> = composed
-        .output_size
-        .iter()
-        .map(|(field, poly)| serde_json::json!({"field": field, "formula": poly.to_string()}))
-        .collect();
-
-    serde_json::json!({
-        "steps": reduction_path.len(),
-        "path": steps_json,
-        "overall_overhead": overall,
-    })
-}
-
 // ---------------------------------------------------------------------------
 // Instance tool helpers
 // ---------------------------------------------------------------------------
 
-fn ser<T: Serialize>(problem: T) -> anyhow::Result<serde_json::Value> {
-    util::ser(problem)
-}
-
-fn solve_result_json(
-    problem: &str,
-    solver: &str,
-    result: &crate::dispatch::SolveResult,
-) -> serde_json::Value {
-    let mut json = serde_json::json!({
-        "problem": problem,
-        "solver": solver,
-        "evaluation": result.evaluation,
-    });
-    if let Some(config) = &result.config {
-        json["solution"] = serde_json::json!(config);
-    }
-    json
-}
-
-fn variant_map(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
-    util::variant_map(pairs)
-}
-
-/// Serialize a vertex-weight graph problem (MIS, MVC, MaxClique, MinDomSet).
-fn ser_vertex_weight_problem(
-    canonical: &str,
-    graph: SimpleGraph,
-    weights: Vec<i32>,
-) -> anyhow::Result<(serde_json::Value, BTreeMap<String, String>)> {
-    let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-    let data = match canonical {
-        "MaximumIndependentSet" => ser(MaximumIndependentSet::new(graph, weights))?,
-        "MinimumVertexCover" => ser(MinimumVertexCover::new(graph, weights))?,
-        "MaximumClique" => ser(MaximumClique::new(graph, weights))?,
-        "MinimumDominatingSet" => ser(MinimumDominatingSet::new(graph, weights))?,
-        _ => unreachable!(),
-    };
-    Ok((data, variant))
-}
-
-/// Serialize an edge-weight graph problem (MaxCut, MaximumMatching, TravelingSalesman).
-fn ser_edge_weight_problem(
-    canonical: &str,
-    graph: SimpleGraph,
-    edge_weights: Vec<i32>,
-) -> anyhow::Result<(serde_json::Value, BTreeMap<String, String>)> {
-    let variant = variant_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
-    let data = match canonical {
-        "MaxCut" => ser(MaxCut::new(graph, edge_weights))?,
-        "MaximumMatching" => ser(MaximumMatching::new(graph, edge_weights))?,
-        "TravelingSalesman" => ser(TravelingSalesman::new(graph, edge_weights))?,
-        _ => unreachable!(),
-    };
-    Ok((data, variant))
-}
-
-/// Serialize a vertex-weight problem with a generic graph type.
-fn ser_vertex_weight_problem_generic<G: Graph + Serialize>(
-    canonical: &str,
-    graph: G,
-    weights: Vec<i32>,
-) -> anyhow::Result<serde_json::Value> {
-    match canonical {
-        "MaximumIndependentSet" => ser(MaximumIndependentSet::new(graph, weights)),
-        "MinimumVertexCover" => ser(MinimumVertexCover::new(graph, weights)),
-        "MaximumClique" => ser(MaximumClique::new(graph, weights)),
-        "MinimumDominatingSet" => ser(MinimumDominatingSet::new(graph, weights)),
-        _ => unreachable!(),
-    }
-}
-
-/// Create a vertex-weight problem from MCP params, dispatching on graph type.
-fn create_vertex_weight_from_params(
-    canonical: &str,
-    graph_type: &str,
-    resolved_variant: &BTreeMap<String, String>,
-    params: &serde_json::Value,
-) -> anyhow::Result<(serde_json::Value, BTreeMap<String, String>)> {
-    match graph_type {
-        "KingsSubgraph" => {
-            let positions = parse_int_positions_from_params(params)?;
-            let n = positions.len();
-            let graph = KingsSubgraph::new(positions);
-            let weights = parse_vertex_weights_from_params(params, n)?;
-            Ok((
-                ser_vertex_weight_problem_generic(canonical, graph, weights)?,
-                resolved_variant.clone(),
-            ))
-        }
-        "TriangularSubgraph" => {
-            let positions = parse_int_positions_from_params(params)?;
-            let n = positions.len();
-            let graph = TriangularSubgraph::new(positions);
-            let weights = parse_vertex_weights_from_params(params, n)?;
-            Ok((
-                ser_vertex_weight_problem_generic(canonical, graph, weights)?,
-                resolved_variant.clone(),
-            ))
-        }
-        "UnitDiskGraph" => {
-            let positions = parse_float_positions_from_params(params)?;
-            let n = positions.len();
-            let radius = params.get("radius").and_then(|v| v.as_f64()).unwrap_or(1.0);
-            let graph = UnitDiskGraph::new(positions, radius);
-            let weights = parse_vertex_weights_from_params(params, n)?;
-            Ok((
-                ser_vertex_weight_problem_generic(canonical, graph, weights)?,
-                resolved_variant.clone(),
-            ))
-        }
-        _ => {
-            let (graph, n) = parse_graph_from_params(params)?;
-            let weights = parse_vertex_weights_from_params(params, n)?;
-            ser_vertex_weight_problem(canonical, graph, weights)
-        }
-    }
-}
-
-/// Extract and parse 'positions' param as integer grid positions.
-fn parse_int_positions_from_params(params: &serde_json::Value) -> anyhow::Result<Vec<(i32, i32)>> {
-    let pos_str = params
-        .get("positions")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| {
-            anyhow::anyhow!("This variant requires 'positions' parameter (e.g., \"0,0;1,0;1,1\")")
-        })?;
-    util::parse_positions(pos_str, "0,0;1,0;1,1")
-}
-
-/// Extract and parse 'positions' param as float positions.
-fn parse_float_positions_from_params(
-    params: &serde_json::Value,
-) -> anyhow::Result<Vec<(f64, f64)>> {
-    let pos_str = params
-        .get("positions")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| {
-            anyhow::anyhow!(
-                "This variant requires 'positions' parameter (e.g., \"0.0,0.0;1.0,0.0\")"
-            )
-        })?;
-    util::parse_positions(pos_str, "0.0,0.0;1.0,0.0")
-}
-
-/// Parse `edges` field from JSON params into a SimpleGraph.
-fn parse_graph_from_params(params: &serde_json::Value) -> anyhow::Result<(SimpleGraph, usize)> {
-    let edges_str = params
-        .get("edges")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| {
-            anyhow::anyhow!("This problem requires 'edges' parameter (e.g., \"0-1,1-2,2-3\")")
-        })?;
-
-    let edges: Vec<(usize, usize)> = edges_str
-        .split(',')
-        .map(|pair| {
-            let parts: Vec<&str> = pair.trim().split('-').collect();
-            if parts.len() != 2 {
-                anyhow::bail!("Invalid edge '{}': expected format u-v", pair.trim());
-            }
-            let u: usize = parts[0].parse()?;
-            let v: usize = parts[1].parse()?;
-            Ok((u, v))
-        })
-        .collect::<anyhow::Result<Vec<_>>>()?;
-
-    let num_vertices = edges
-        .iter()
-        .flat_map(|(u, v)| [*u, *v])
-        .max()
-        .map(|m| m + 1)
-        .unwrap_or(0);
-
-    Ok((SimpleGraph::new(num_vertices, edges), num_vertices))
-}
-
-fn parse_kclique_threshold(k_flag: Option<usize>, num_vertices: usize) -> anyhow::Result<usize> {
-    let k = k_flag.ok_or_else(|| anyhow::anyhow!("KClique requires 'k'"))?;
-    if k == 0 {
-        anyhow::bail!("KClique: 'k' must be positive");
-    }
-    if k > num_vertices {
-        anyhow::bail!("KClique: k must be <= graph num_vertices");
-    }
-    Ok(k)
-}
-
-/// Parse `weights` field from JSON params as vertex weights (i32), defaulting to all 1s.
-fn parse_vertex_weights_from_params(
-    params: &serde_json::Value,
-    num_vertices: usize,
-) -> anyhow::Result<Vec<i32>> {
-    match params.get("weights").and_then(|v| v.as_str()) {
-        Some(w) => {
-            let weights: Vec<i32> = w
-                .split(',')
-                .map(|s| s.trim().parse::<i32>())
-                .collect::<std::result::Result<Vec<_>, _>>()?;
-            if weights.len() != num_vertices {
-                anyhow::bail!(
-                    "Expected {} weights but got {}",
-                    num_vertices,
-                    weights.len()
-                );
-            }
-            Ok(weights)
-        }
-        None => Ok(vec![1i32; num_vertices]),
-    }
-}
-
-/// Parse `weights` field from JSON params as edge weights (i32), defaulting to all 1s.
-fn parse_edge_weights_from_params(
-    params: &serde_json::Value,
-    num_edges: usize,
-) -> anyhow::Result<Vec<i32>> {
-    match params.get("weights").and_then(|v| v.as_str()) {
-        Some(w) => {
-            let weights: Vec<i32> = w
-                .split(',')
-                .map(|s| s.trim().parse::<i32>())
-                .collect::<std::result::Result<Vec<_>, _>>()?;
-            if weights.len() != num_edges {
-                anyhow::bail!(
-                    "Expected {} edge weights but got {}",
-                    num_edges,
-                    weights.len()
-                );
-            }
-            Ok(weights)
-        }
-        None => Ok(vec![1i32; num_edges]),
-    }
-}
-
-/// Parse `edge_lengths` field from JSON params as edge lengths (i32), defaulting to all 1s.
-fn parse_edge_lengths_from_params(
-    params: &serde_json::Value,
-    num_edges: usize,
-) -> anyhow::Result<Vec<i32>> {
-    match params.get("edge_lengths").and_then(|v| v.as_str()) {
-        Some(w) => {
-            let lengths: Vec<i32> = w
-                .split(',')
-                .map(|s| s.trim().parse::<i32>())
-                .collect::<std::result::Result<Vec<_>, _>>()?;
-            if lengths.len() != num_edges {
-                anyhow::bail!(
-                    "Expected {} edge lengths but got {}",
-                    num_edges,
-                    lengths.len()
-                );
-            }
-            Ok(lengths)
-        }
-        None => Ok(vec![1i32; num_edges]),
-    }
-}
-
-/// Parse `clauses` field from JSON params as semicolon-separated clauses.
-fn parse_clauses_from_params(params: &serde_json::Value) -> anyhow::Result<Vec<CNFClause>> {
-    let clauses_str = params
-        .get("clauses")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| {
-            anyhow::anyhow!("SAT problems require 'clauses' parameter (e.g., \"1,2;-1,3\")")
-        })?;
-
-    clauses_str
-        .split(';')
-        .map(|clause| {
-            let literals: Vec<i32> = clause
-                .trim()
-                .split(',')
-                .map(|s| s.trim().parse::<i32>())
-                .collect::<std::result::Result<Vec<_>, _>>()?;
-            Ok(CNFClause::new(literals))
-        })
-        .collect()
-}
-
-/// Parse `disjuncts` field from JSON params as semicolon-separated conjunctions.
-fn parse_disjuncts_from_params(params: &serde_json::Value) -> anyhow::Result<Vec<Vec<i32>>> {
-    let disjuncts_str = params
-        .get("disjuncts")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| {
-            anyhow::anyhow!("NonTautology requires 'disjuncts' parameter (e.g., \"1,2;-1,3\")")
-        })?;
-
-    disjuncts_str
-        .split(';')
-        .map(|disjunct| {
-            disjunct
-                .trim()
-                .split(',')
-                .map(|s| s.trim().parse::<i32>())
-                .collect::<std::result::Result<Vec<_>, _>>()
-                .map_err(anyhow::Error::from)
-        })
-        .collect()
-}
-
-/// Parse `matrix` field from JSON params as semicolon-separated rows.
-fn parse_matrix_from_params(params: &serde_json::Value) -> anyhow::Result<Vec<Vec<f64>>> {
-    let matrix_str = params
-        .get("matrix")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| {
-            anyhow::anyhow!("QUBO requires 'matrix' parameter (e.g., \"1,0.5;0.5,2\")")
-        })?;
-
-    matrix_str
-        .split(';')
-        .map(|row| {
-            row.trim()
-                .split(',')
-                .map(|s| {
-                    s.trim()
-                        .parse::<f64>()
-                        .map_err(|e| anyhow::anyhow!("Invalid matrix value: {}", e))
-                })
-                .collect()
-        })
-        .collect()
+fn normalize_mcp_create_inputs(params: &serde_json::Value) -> anyhow::Result<serde_json::Value> {
+    let inputs = params
+        .as_object()
+        .ok_or_else(|| anyhow::anyhow!("construction inputs must be a JSON object"))?;
+    Ok(serde_json::Value::Object(inputs.clone()))
 }
 
 /// Solve a plain problem and return JSON string.
@@ -1474,73 +684,21 @@ fn solve_problem_inner(
     problem_type: &str,
     variant: &BTreeMap<String, String>,
     data: serde_json::Value,
-    solver_name: &str,
+    request: SolverRequest,
 ) -> anyhow::Result<String> {
     let problem = load_problem(problem_type, variant, data)?;
     let name = problem.problem_name();
-
-    match solver_name {
-        "brute-force" => {
-            let result = problem.solve_brute_force();
-            let json = solve_result_json(name, "brute-force", &result);
-            Ok(serde_json::to_string_pretty(&json)?)
-        }
-        "ilp" => {
-            let result = problem.solve_with_ilp()?;
-            let result = crate::dispatch::SolveResult {
-                config: Some(result.config),
-                evaluation: result.evaluation,
-            };
-            let mut json = solve_result_json(name, "ilp", &result);
-            if name != "ILP" {
-                json["reduced_to"] = serde_json::json!("ILP");
-            }
-            Ok(serde_json::to_string_pretty(&json)?)
-        }
-        "customized" => {
-            let result = problem.solve_with_customized()?;
-            let result = crate::dispatch::SolveResult {
-                config: Some(result.config),
-                evaluation: result.evaluation,
-            };
-            let json = solve_result_json(name, "customized", &result);
-            Ok(serde_json::to_string_pretty(&json)?)
-        }
-        _ => unreachable!(),
-    }
+    let result = problem.solve(request)?;
+    let json = solve_result_json(name, &result);
+    Ok(serde_json::to_string_pretty(&json)?)
 }
 
 /// Solve a reduction bundle: solve the target, then map the solution back.
-fn solve_bundle_inner(bundle: ReductionBundle, solver_name: &str) -> anyhow::Result<String> {
+fn solve_bundle_inner(bundle: ReductionBundle, request: SolverRequest) -> anyhow::Result<String> {
     let replay = BundleReplay::prepare(&bundle)?;
-
-    let target_result = match solver_name {
-        "brute-force" => replay.target.solve_brute_force_witness().ok_or_else(|| {
-            anyhow::anyhow!(
-                "Bundle solving requires a witness-capable target problem and witness-capable reduction path; {} only supports aggregate-value solving.",
-                replay.target_name
-            )
-        })?,
-        "ilp" => replay.target.solve_with_ilp()?,
-        "customized" => replay.target.solve_with_customized()?,
-        _ => unreachable!(),
-    };
-
-    let (source_config, source_eval) = replay.extract(&target_result.config);
-
-    let json = serde_json::json!({
-        "problem": replay.source_name,
-        "solver": solver_name,
-        "reduced_to": replay.target_name,
-        "solution": source_config,
-        "evaluation": source_eval,
-        "intermediate": {
-            "problem": replay.target_name,
-            "solution": target_result.config,
-            "evaluation": target_result.evaluation,
-        },
-    });
-    Ok(serde_json::to_string_pretty(&json)?)
+    Ok(serde_json::to_string_pretty(
+        &replay.solve(request)?.to_json(),
+    )?)
 }
 
 #[cfg(test)]
@@ -1550,14 +708,46 @@ mod tests {
     use problemreductions::models::formula::NonTautology;
 
     #[test]
-    fn test_create_problem_inner_nontautology_uses_disjuncts() {
+    fn unit_decision_inputs_match_construction() {
+        let server = McpServer::new();
+        for (name, data) in [
+            (
+                "DecisionMaximumIndependentSet/One",
+                serde_json::json!({"graph":[[0,1],[1,2]],"bound":2}),
+            ),
+            (
+                "DecisionMinimumDominatingSet/One",
+                serde_json::json!({"graph":{"num_vertices":3,"edges":[[0,1],[1,2]]},"bound":1}),
+            ),
+        ] {
+            let shown: serde_json::Value =
+                serde_json::from_str(&server.show_problem_inner(name).unwrap()).unwrap();
+            let inputs = shown["inputs"].as_array().unwrap();
+            assert!(inputs
+                .iter()
+                .any(|input| input["name"] == "bound" && input["type_name"] == "i64"));
+            assert!(!inputs.iter().any(|input| input["name"] == "weights"));
+            let output = server.create_problem_inner(name, &data).unwrap();
+            let created: ProblemJsonOutput = serde_json::from_str(&output).unwrap();
+            assert_eq!(
+                created.data["inner"]["weights"],
+                serde_json::json!([1, 1, 1])
+            );
+            let mut redundant = data;
+            redundant["weights"] = serde_json::json!([1, 1, 1]);
+            assert!(server.create_problem_inner(name, &redundant).is_err());
+        }
+    }
+
+    #[test]
+    fn construction_contract_create_problem_uses_typed_json_inputs() {
         let server = McpServer::new();
         let output = server
             .create_problem_inner(
                 "NonTautology",
                 &serde_json::json!({
                     "num_vars": 3,
-                    "disjuncts": "1,2,3;-1,-2,-3",
+                    "disjuncts": [[1, 2, 3], [-1, -2, -3]],
                 }),
             )
             .unwrap();
@@ -1567,4 +757,136 @@ mod tests {
         let problem: NonTautology = serde_json::from_value(created.data).unwrap();
         assert_eq!(problem.disjuncts(), &[vec![1, 2, 3], vec![-1, -2, -3]]);
     }
+
+    #[test]
+    fn construction_contract_discovers_model_without_mcp_dispatch() {
+        let server = McpServer::new();
+        let output = server
+            .create_problem_inner(
+                crate::test_support::AGGREGATE_SOURCE_NAME,
+                &serde_json::json!({"values": [2, 5, 7]}),
+            )
+            .unwrap();
+
+        let created: ProblemJsonOutput = serde_json::from_str(&output).unwrap();
+        assert_eq!(
+            created.problem_type,
+            crate::test_support::AGGREGATE_SOURCE_NAME
+        );
+        assert!(created.variant.is_empty());
+        assert_eq!(created.data, serde_json::json!({"values": [2, 5, 7]}));
+    }
+
+    #[test]
+    fn construction_contract_mcp_computes_model_owned_derived_fields() {
+        let output = McpServer::new()
+            .create_problem_inner("SCS", &serde_json::json!({"strings": [[0, 1], [1, 2]]}))
+            .unwrap();
+
+        let created: ProblemJsonOutput = serde_json::from_str(&output).unwrap();
+        assert_eq!(created.problem_type, "ShortestCommonSupersequence");
+        assert_eq!(created.data["alphabet_size"], serde_json::json!(3));
+        assert_eq!(created.data["max_length"], serde_json::json!(4));
+        assert_eq!(created.data["strings"], serde_json::json!([[0, 1], [1, 2]]));
+    }
+
+    #[test]
+    fn construction_contract_mcp_builds_composite_model_input() {
+        let output = McpServer::new()
+            .create_problem_inner(
+                "BicliqueCover",
+                &serde_json::json!({
+                    "left": 2,
+                    "right": 3,
+                    "biedges": [[0, 0], [0, 1], [1, 2]],
+                    "k": 2,
+                }),
+            )
+            .unwrap();
+
+        let created: ProblemJsonOutput = serde_json::from_str(&output).unwrap();
+        assert_eq!(created.problem_type, "BicliqueCover");
+        assert_eq!(created.data["graph"]["left_size"], serde_json::json!(2));
+        assert_eq!(created.data["graph"]["right_size"], serde_json::json!(3));
+        assert_eq!(created.data["k"], serde_json::json!(2));
+    }
+
+    #[test]
+    fn construction_contract_rejects_unknown_mcp_input() {
+        let error = McpServer::new()
+            .create_problem_inner(
+                "NonTautology",
+                &serde_json::json!({
+                    "num_vars": 3,
+                    "disjuncts": [[1, 2, 3]],
+                    "removed": true,
+                }),
+            )
+            .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("unknown construction input(s): removed"),
+            "unexpected error: {error}"
+        );
+    }
+
+    #[test]
+    fn construction_contract_rejects_missing_mcp_input() {
+        let error = McpServer::new()
+            .create_problem_inner("NonTautology", &serde_json::json!({"num_vars": 3}))
+            .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("missing required construction input(s): disjuncts"),
+            "unexpected error: {error}"
+        );
+    }
+
+    #[test]
+    fn construction_contract_rejects_non_object_mcp_input() {
+        let error = McpServer::new()
+            .create_problem_inner("NonTautology", &serde_json::json!([]))
+            .unwrap_err();
+        assert_eq!(
+            error.to_string(),
+            "construction inputs must be a JSON object"
+        );
+    }
+
+    #[test]
+    fn random_contract_mcp_uses_the_selected_variant_generator() {
+        let output = McpServer::new()
+            .create_problem_inner(
+                "MaximumIndependentSet",
+                &serde_json::json!({"random": true, "num_vertices": 4, "seed": 7}),
+            )
+            .unwrap();
+
+        let created: ProblemJsonOutput = serde_json::from_str(&output).unwrap();
+        assert_eq!(created.variant["graph"], "SimpleGraph");
+        assert_eq!(created.variant["weight"], "One");
+        assert_eq!(created.data["graph"]["num_vertices"], 4);
+    }
+
+    #[test]
+    fn random_contract_mcp_rejects_inputs_outside_model_contract() {
+        let error = McpServer::new()
+            .create_problem_inner(
+                "MaximumIndependentSet",
+                &serde_json::json!({
+                    "random": true,
+                    "num_vertices": 4,
+                    "bound": 2,
+                }),
+            )
+            .unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("unknown construction input(s): bound"),
+            "unexpected error: {error}"
+        );
+    }
 }
diff --git a/problemreductions-cli/src/output.rs b/problemreductions-cli/src/output.rs
index eff2a64fe..3318764ee 100644
--- a/problemreductions-cli/src/output.rs
+++ b/problemreductions-cli/src/output.rs
@@ -27,25 +27,24 @@ impl OutputConfig {
 
     /// Emit output: `-o` saves JSON to file, `--json` prints JSON to stdout,
     /// otherwise prints human-readable text.
-    pub fn emit_with_default_name(
-        &self,
-        _default_name: &str,
-        human_text: &str,
-        json_value: &serde_json::Value,
-    ) -> anyhow::Result<()> {
+    pub fn emit<H, J>(&self, human_text: H, json_value: J) -> anyhow::Result<()>
+    where
+        H: FnOnce() -> String,
+        J: FnOnce() -> anyhow::Result<serde_json::Value>,
+    {
         if let Some(ref path) = self.output {
             let content =
-                serde_json::to_string_pretty(json_value).context("Failed to serialize JSON")?;
+                serde_json::to_string_pretty(&json_value()?).context("Failed to serialize JSON")?;
             std::fs::write(path, &content)
                 .with_context(|| format!("Failed to write {}", path.display()))?;
             self.info(&format!("Wrote {}", path.display()));
         } else if self.json || (self.auto_json && !std::io::stdout().is_terminal()) {
             println!(
                 "{}",
-                serde_json::to_string_pretty(json_value).context("Failed to serialize JSON")?
+                serde_json::to_string_pretty(&json_value()?).context("Failed to serialize JSON")?
             );
         } else {
-            println!("{human_text}");
+            println!("{}", human_text());
         }
         Ok(())
     }
diff --git a/problemreductions-cli/src/problem_name.rs b/problemreductions-cli/src/problem_name.rs
index a08c72e41..1c3057466 100644
--- a/problemreductions-cli/src/problem_name.rs
+++ b/problemreductions-cli/src/problem_name.rs
@@ -6,7 +6,7 @@ use std::ffi::OsStr;
 pub struct ProblemSpec {
     /// Resolved canonical problem name.
     pub name: String,
-    /// Positional variant values (e.g., ["UnitDiskGraph", "i32"]).
+    /// Positional variant values (e.g., ["UnitDiskGraph", "i64"]).
     pub variant_values: Vec<String>,
 }
 
@@ -39,12 +39,6 @@ pub fn resolve_alias(input: &str) -> String {
     if input.eq_ignore_ascii_case("MinimumCodeGenerationParallelAssignments") {
         return "MinimumCodeGenerationParallelAssignments".to_string();
     }
-    if input.eq_ignore_ascii_case("ThreeMatroidIntersection") {
-        return "ThreeMatroidIntersection".to_string();
-    }
-    if input.eq_ignore_ascii_case("GraphPartitioning") {
-        return "GraphPartitioning".to_string();
-    }
     if let Some((entry, _)) = problemreductions::registry::find_variant_by_alias(input) {
         return entry.name.to_string();
     }
@@ -73,7 +67,7 @@ pub fn resolve_catalog_problem_ref(
         .map_err(|e| anyhow::anyhow!("{e}"))
 }
 
-/// Parse a problem spec string like "MIS/UnitDiskGraph/i32" into name + variant values.
+/// Parse a problem spec string like "MIS/UnitDiskGraph/i64" into name + variant values.
 ///
 /// Resolution order:
 /// 1. **Variant-level alias** (`"3SAT"` → `KSatisfiability` + variant tokens `["K3"]`):
@@ -89,7 +83,10 @@ pub fn parse_problem_spec(input: &str) -> anyhow::Result<ProblemSpec> {
     {
         // Prepend the alias's own variant values; the slash-spec resolver handles
         // additional user tokens (and errors on dimension collisions).
-        let mut variant_values: Vec<String> = variant_map.into_values().collect();
+        let mut variant_values: Vec<String> = ordered_variant_values(entry.name, &variant_map)
+            .into_iter()
+            .map(str::to_owned)
+            .collect();
         variant_values.extend(user_tokens);
         return Ok(ProblemSpec {
             name: entry.name.to_string(),
@@ -105,6 +102,25 @@ pub fn parse_problem_spec(input: &str) -> anyhow::Result<ProblemSpec> {
     })
 }
 
+/// Variant values in the model's declared dimension order (not map key order).
+pub(crate) fn ordered_variant_values<'a>(
+    name: &str,
+    variant: &'a BTreeMap<String, String>,
+) -> Vec<&'a str> {
+    let problem = problemreductions::registry::find_problem_type(name)
+        .expect("registered problem has a schema");
+    problem
+        .dimensions
+        .iter()
+        .map(|dimension| {
+            variant
+                .get(dimension.key)
+                .expect("registered variant has every declared dimension")
+                .as_str()
+        })
+        .collect()
+}
+
 fn format_variant(variant: &BTreeMap<String, String>) -> String {
     let parts = variant
         .iter()
@@ -138,11 +154,52 @@ fn resolve_variant_updates(
         return Ok(default_variant.clone());
     }
 
+    let problem = problemreductions::registry::find_problem_type(&spec.name)
+        .expect("registered problem has a schema");
+    if spec.variant_values.len() == problem.dimensions.len()
+        && problem
+            .dimensions
+            .iter()
+            .zip(&spec.variant_values)
+            .all(|(dimension, value)| dimension.allowed_values.contains(&value.as_str()))
+    {
+        let resolved = problem
+            .dimensions
+            .iter()
+            .zip(&spec.variant_values)
+            .map(|(dimension, value)| (dimension.key.to_string(), value.clone()))
+            .collect();
+        anyhow::ensure!(
+            known_variants.contains(&resolved),
+            "Resolved variant {} is not declared for {}",
+            format_variant(&resolved),
+            spec.name
+        );
+        return Ok(resolved);
+    }
+
     let token_index = dimension_values(known_variants);
     let mut resolved = default_variant.clone();
     let mut updated_dimensions = BTreeSet::new();
 
     for token in &spec.variant_values {
+        if let Some((dimension, value)) = token.split_once('=') {
+            let values = token_index.get(dimension).ok_or_else(|| {
+                anyhow::anyhow!(
+                    "Unknown variant dimension \"{dimension}\" for {}",
+                    spec.name
+                )
+            })?;
+            if !values.contains(value) {
+                anyhow::bail!("Unknown value \"{value}\" for variant dimension \"{dimension}\"");
+            }
+            if !updated_dimensions.insert(dimension.to_string()) {
+                anyhow::bail!("Variant dimension \"{dimension}\" was specified more than once");
+            }
+            resolved.insert(dimension.to_string(), value.to_string());
+            continue;
+        }
+
         let matching_dimensions = token_index
             .iter()
             .filter(|(_, values)| values.contains(token))
@@ -320,6 +377,41 @@ pub fn unknown_problem_error(input: &str) -> String {
 mod tests {
     use super::*;
 
+    #[test]
+    fn registered_variant_names_round_trip_in_declared_order() {
+        let graph = problemreductions::rules::ReductionGraph::new();
+        for entry in problemreductions::registry::variant_entries() {
+            let variant = entry.variant_map();
+            let name = format!(
+                "{}{}",
+                entry.name,
+                crate::commands::graph::variant_to_full_slash(entry.name, &variant)
+            );
+            let resolved = resolve_problem_ref(&name, &graph).unwrap();
+            assert_eq!(resolved.variant, variant, "{name}");
+            let parsed = crate::cli::Cli::try_parse_from(["pred", "create", &name]).unwrap();
+            let crate::cli::Commands::Create(args) = parsed.command else {
+                panic!("expected create command");
+            };
+            let (_, actual) = crate::create_args::resolve_registered_create_variant(
+                args.problem.as_deref().unwrap(),
+            );
+            assert_eq!(actual, variant, "{name}");
+        }
+    }
+
+    #[test]
+    fn ilp_full_name_uses_variable_then_coefficient() {
+        let graph = problemreductions::rules::ReductionGraph::new();
+        let resolved = resolve_problem_ref("ILP/bool/i64", &graph).unwrap();
+        assert_eq!(resolved.variant["variable"], "bool");
+        assert_eq!(resolved.variant["coefficient"], "i64");
+        assert_eq!(
+            crate::commands::graph::variant_to_full_slash("ILP", &resolved.variant),
+            "/bool/i64"
+        );
+    }
+
     #[test]
     fn test_alias_resolution() {
         assert_eq!(resolve_alias("MIS"), "MaximumIndependentSet");
@@ -371,6 +463,14 @@ mod tests {
         assert_eq!(spec.variant_values, vec!["SimpleGraph", "f64"]);
     }
 
+    #[test]
+    fn resolve_problem_ref_accepts_named_variant_dimension() {
+        let graph = problemreductions::rules::ReductionGraph::new();
+        let resolved = resolve_problem_ref("ILP/variable=i64", &graph).unwrap();
+        assert_eq!(resolved.variant["variable"], "i64");
+        assert_eq!(resolved.variant["coefficient"], "i64");
+    }
+
     #[test]
     fn test_resolve_alias_pass_through_undirected_two_commodity_integral_flow() {
         assert_eq!(
@@ -577,7 +677,7 @@ mod tests {
     #[test]
     fn resolve_problem_ref_rejects_duplicate_dimension_updates() {
         let graph = problemreductions::rules::ReductionGraph::new();
-        let err = resolve_problem_ref("MIS/One/i32", &graph).unwrap_err();
+        let err = resolve_problem_ref("MIS/One/i64", &graph).unwrap_err();
         assert!(
             err.to_string().contains("specified more than once"),
             "expected duplicate-dimension error, got: {err}"
@@ -611,7 +711,7 @@ mod tests {
     fn parse_problem_type_extracts_name_from_variant_spec() {
         // parse_problem_type extracts just the problem name from a variant spec
         assert_eq!(
-            parse_problem_type("MIS/UnitDiskGraph/i32").unwrap(),
+            parse_problem_type("MIS/UnitDiskGraph/i64").unwrap(),
             "MaximumIndependentSet"
         );
     }
@@ -619,9 +719,9 @@ mod tests {
     #[test]
     fn resolve_catalog_problem_ref_validates_against_schema() {
         // Schema-valid values should resolve
-        let r = resolve_catalog_problem_ref("MIS/i32").unwrap();
+        let r = resolve_catalog_problem_ref("MIS/i64").unwrap();
         assert_eq!(r.name(), "MaximumIndependentSet");
-        assert_eq!(r.variant().get("weight").map(|s| s.as_str()), Some("i32"));
+        assert_eq!(r.variant().get("weight").map(|s| s.as_str()), Some("i64"));
     }
 
     #[test]
diff --git a/problemreductions-cli/src/test_support.rs b/problemreductions-cli/src/test_support.rs
index 23f6f9d9f..ba3d7e15d 100644
--- a/problemreductions-cli/src/test_support.rs
+++ b/problemreductions-cli/src/test_support.rs
@@ -1,11 +1,12 @@
 use crate::dispatch::{PathStep, ProblemJsonOutput, ReductionBundle};
 use problemreductions::models::algebraic::{ObjectiveSense, ILP};
-use problemreductions::registry::VariantEntry;
-use problemreductions::rules::registry::{EdgeCapabilities, ReductionEntry, ReductionOverhead};
-use problemreductions::rules::{AggregateReductionResult, ReductionAutoCast};
-use problemreductions::solvers::{BruteForce, Solver};
+use problemreductions::registry::{
+    CreateInputCodec, CreateInputInfo, FieldInfo, ProblemSchemaEntry, VariantEntry,
+};
+use problemreductions::rules::registry::{ReductionEntry, ReductionParameterDeclarations};
+use problemreductions::rules::{AggregateReductionResult, VariantReductionResult};
 use problemreductions::traits::Problem;
-use problemreductions::types::{Extremum, ProblemSize, Sum};
+use problemreductions::types::{Aggregate, Extremum, Max, SolutionAggregate};
 use serde::{Deserialize, Serialize};
 use std::any::Any;
 use std::collections::BTreeMap;
@@ -13,9 +14,17 @@ use std::collections::BTreeMap;
 pub(crate) const AGGREGATE_SOURCE_NAME: &str = "CliTestAggregateValueSource";
 pub(crate) const AGGREGATE_TARGET_NAME: &str = "CliTestAggregateValueTarget";
 
+const AGGREGATE_SOURCE_INPUTS: &[CreateInputInfo] = &[CreateInputInfo {
+    name: "values",
+    type_name: "Vec<i64>",
+    description: "Values included by selected configuration bits",
+    required: true,
+    codec: CreateInputCodec::CommaSeparated,
+}];
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub(crate) struct AggregateValueSource {
-    values: Vec<u64>,
+    values: Vec<i64>,
 }
 
 impl AggregateValueSource {
@@ -24,24 +33,32 @@ impl AggregateValueSource {
             values: vec![2, 5, 7],
         }
     }
+
+    fn num_values(&self) -> usize {
+        self.values.len()
+    }
 }
 
 impl Problem for AggregateValueSource {
     const NAME: &'static str = AGGREGATE_SOURCE_NAME;
-    type Value = Sum<u64>;
+    type Solution = Vec<bool>;
+    type Value = Max<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.values.len()]
-    }
+    problemreductions::problem_parameters![("num_values", num_values)];
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        let total = self
-            .values
-            .iter()
-            .zip(config.iter().copied())
-            .filter_map(|(value, bit)| (bit == 1).then_some(*value))
-            .sum();
-        Sum(total)
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Self::Value, problemreductions::traits::EvaluationError> {
+        Ok({
+            let total = self
+                .values
+                .iter()
+                .zip(solution.iter().copied())
+                .filter_map(|(value, selected)| selected.then_some(*value))
+                .sum();
+            Max(Some(total))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -49,27 +66,41 @@ impl Problem for AggregateValueSource {
     }
 }
 
+impl problemreductions::solvers::BruteForceProblem for AggregateValueSource {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.values.len()]
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub(crate) struct AggregateValueTarget {
-    base: u64,
+    base: i64,
 }
 
 impl AggregateValueTarget {
     pub(crate) fn sample() -> Self {
         Self { base: 11 }
     }
+
+    fn num_values(&self) -> usize {
+        1
+    }
 }
 
 impl Problem for AggregateValueTarget {
     const NAME: &'static str = AGGREGATE_TARGET_NAME;
-    type Value = Sum<u64>;
+    type Solution = Vec<bool>;
+    type Value = Max<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2]
-    }
+    problemreductions::problem_parameters![("num_values", num_values)];
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Sum(self.base + config.iter().sum::<usize>() as u64)
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Self::Value, problemreductions::traits::EvaluationError> {
+        Ok(Max(Some(
+            self.base + solution.iter().filter(|&&selected| selected).count() as i64,
+        )))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -77,6 +108,12 @@ impl Problem for AggregateValueTarget {
     }
 }
 
+impl problemreductions::solvers::BruteForceProblem for AggregateValueTarget {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2]
+    }
+}
+
 #[derive(Debug, Clone)]
 struct AggregateValueToIlpReduction {
     target: ILP<bool>,
@@ -90,33 +127,167 @@ impl AggregateReductionResult for AggregateValueToIlpReduction {
         &self.target
     }
 
-    fn extract_value(&self, _target_value: Extremum<f64>) -> Sum<u64> {
-        Sum(0)
+    fn extract_value(&self, _target_value: Extremum<i64>) -> Max<i64> {
+        Max(Some(0))
     }
 }
 
-fn solve_value<P>(any: &dyn Any) -> String
+fn decode_bits(indices: Vec<usize>) -> Vec<bool> {
+    indices.into_iter().map(|index| index != 0).collect()
+}
+
+fn cartesian_indices(
+    dimensions: Vec<usize>,
+) -> Result<impl Iterator<Item = Vec<usize>>, problemreductions::solvers::SolveError> {
+    let total = if dimensions.is_empty() {
+        1
+    } else if dimensions.contains(&0) {
+        0
+    } else {
+        dimensions.iter().try_fold(1usize, |total, &dimension| {
+            total.checked_mul(dimension).ok_or_else(|| {
+                problemreductions::solvers::SolveError::SearchSpaceOverflow(dimensions.clone())
+            })
+        })?
+    };
+    Ok((0..total).map(move |mut index| {
+        let mut coordinates = vec![0; dimensions.len()];
+        for position in (0..dimensions.len()).rev() {
+            coordinates[position] = index % dimensions[position];
+            index /= dimensions[position];
+        }
+        coordinates
+    }))
+}
+
+fn solve_cartesian<P>(problem: &P) -> Result<P::Value, problemreductions::solvers::SolveError>
+where
+    P: Problem<Solution = Vec<bool>> + problemreductions::solvers::BruteForceProblem,
+    P::Value: Aggregate,
+{
+    let mut total = P::Value::identity();
+    for indices in cartesian_indices(problem.dimensions())? {
+        total = total.combine(problem.evaluate(&decode_bits(indices))?)?;
+    }
+    Ok(total)
+}
+
+fn solve_cartesian_solution<P>(
+    problem: &P,
+) -> Result<Option<P::Solution>, problemreductions::solvers::SolveError>
 where
-    P: Problem + Serialize + 'static,
-    P::Value: problemreductions::types::Aggregate + std::fmt::Display,
+    P: Problem<Solution = Vec<bool>> + problemreductions::solvers::BruteForceProblem,
+    P::Value: SolutionAggregate,
+{
+    let total = solve_cartesian(problem)?;
+    for indices in cartesian_indices(problem.dimensions())? {
+        let solution = decode_bits(indices);
+        let value = problem.evaluate(&solution)?;
+        if P::Value::contributes_to_solution(&value, &total) {
+            return Ok(Some(solution));
+        }
+    }
+    Ok(None)
+}
+
+fn solve_with_witnesses_cartesian<P>(
+    problem: &P,
+) -> Result<(P::Value, Vec<P::Solution>), problemreductions::solvers::SolveError>
+where
+    P: Problem<Solution = Vec<bool>> + problemreductions::solvers::BruteForceProblem,
+    P::Value: SolutionAggregate,
+{
+    let total = solve_cartesian(problem)?;
+    let mut witnesses = Vec::new();
+    for indices in cartesian_indices(problem.dimensions())? {
+        let solution = decode_bits(indices);
+        let value = problem.evaluate(&solution)?;
+        if P::Value::contributes_to_solution(&value, &total) {
+            witnesses.push(solution);
+        }
+    }
+    Ok((total, witnesses))
+}
+
+fn solve_dynamic<P>(
+    any: &dyn Any,
+) -> Result<Option<(serde_json::Value, String)>, problemreductions::solvers::SolveError>
+where
+    P: Problem<Solution = Vec<bool>>
+        + problemreductions::solvers::BruteForceProblem
+        + Serialize
+        + 'static,
+    P::Value: SolutionAggregate + std::fmt::Display,
+{
+    let problem = any.downcast_ref::<P>().expect("test solve downcast failed");
+    let Some(solution) = solve_cartesian_solution(problem)? else {
+        return Ok(None);
+    };
+    let evaluation = problemreductions::registry::format_metric(&problem.evaluate(&solution)?);
+    Ok(Some((
+        serde_json::to_value(solution).expect("test witness serialization failed"),
+        evaluation,
+    )))
+}
+
+fn solve_typed<P>(
+    any: &dyn Any,
+) -> Result<Option<Box<dyn Any>>, problemreductions::solvers::SolveError>
+where
+    P: Problem<Solution = Vec<bool>> + problemreductions::solvers::BruteForceProblem + 'static,
+    P::Value: SolutionAggregate + 'static,
 {
     let problem = any
         .downcast_ref::<P>()
-        .expect("test solve_value downcast failed");
-    let solver = BruteForce::new();
-    problemreductions::registry::format_metric(&solver.solve(problem))
+        .expect("test typed solve downcast failed");
+    Ok(solve_cartesian_solution(problem)?.map(|solution| Box::new(solution) as Box<dyn Any>))
 }
 
-fn solve_witness<P>(any: &dyn Any) -> Option<(Vec<usize>, String)>
+fn solve_typed_with_witnesses<P>(
+    any: &dyn Any,
+) -> Result<Box<dyn Any>, problemreductions::solvers::SolveError>
 where
-    P: Problem + Serialize + 'static,
-    P::Value: problemreductions::types::Aggregate + std::fmt::Display,
+    P: Problem<Solution = Vec<bool>> + problemreductions::solvers::BruteForceProblem + 'static,
+    P::Value: SolutionAggregate + 'static,
 {
-    let problem = any.downcast_ref::<P>()?;
-    let solver = BruteForce::new();
-    let config = solver.find_witness(problem)?;
-    let evaluation = problemreductions::registry::format_metric(&problem.evaluate(&config));
-    Some((config, evaluation))
+    let problem = any
+        .downcast_ref::<P>()
+        .expect("test typed solve with witnesses downcast failed");
+    Ok(Box::new(solve_with_witnesses_cartesian(problem)?))
+}
+
+problemreductions::inventory::submit! {
+    ProblemSchemaEntry {
+        name: AggregateValueSource::NAME,
+        display_name: "CLI test aggregate value source",
+        aliases: &[],
+        dimensions: &[],
+        category: problemreductions::registry::ProblemCategory::Misc,
+        module_path: module_path!(),
+        description: "Test-only dynamically discovered construction model",
+        fields: &[FieldInfo {
+            name: "values",
+            type_name: "Vec<i64>",
+            description: "Values included by selected configuration bits",
+        }],
+    }
+}
+
+problemreductions::inventory::submit! {
+    ProblemSchemaEntry {
+        name: AggregateValueTarget::NAME,
+        display_name: "CLI test aggregate value target",
+        aliases: &[],
+        dimensions: &[],
+        category: problemreductions::registry::ProblemCategory::Misc,
+        module_path: module_path!(),
+        description: "Test-only aggregate reduction target",
+        fields: &[FieldInfo {
+            name: "base",
+            type_name: "i64",
+            description: "Base aggregate value",
+        }],
+    }
 }
 
 problemreductions::inventory::submit! {
@@ -125,8 +296,22 @@ problemreductions::inventory::submit! {
         variant_fn: AggregateValueSource::variant,
         complexity: "2^num_values",
         complexity_eval_fn: |_| 1.0,
+        parameter_names_fn: AggregateValueSource::parameter_names,
+        parameter_measure_fn: |any| {
+            any.downcast_ref::<AggregateValueSource>()
+                .expect("AggregateValueSource size type mismatch")
+                .parameters()
+        },
         is_default: true,
         aliases: &[],
+        create_inputs: Some(|| AGGREGATE_SOURCE_INPUTS.to_vec()),
+        construct_fn: |data| {
+            problemreductions::registry::validate_create_inputs(AGGREGATE_SOURCE_INPUTS, &data)?;
+            let problem: AggregateValueSource = serde_json::from_value(data)
+                .map_err(|error| problemreductions::registry::ConstructionError::InvalidInput(error.to_string()))?;
+            Ok(Box::new(problem))
+        },
+        random: None,
         factory: |data| {
             let problem: AggregateValueSource = serde_json::from_value(data)?;
             Ok(Box::new(problem))
@@ -135,8 +320,22 @@ problemreductions::inventory::submit! {
             let problem = any.downcast_ref::<AggregateValueSource>()?;
             Some(serde_json::to_value(problem).expect("serialize AggregateValueSource failed"))
         },
-        solve_value_fn: solve_value::<AggregateValueSource>,
-        solve_witness_fn: solve_witness::<AggregateValueSource>,
+    }
+}
+
+problemreductions::inventory::submit! {
+    problemreductions::solvers::BruteForceRegistration {
+        source_name: AggregateValueSource::NAME,
+        source_variant_fn: AggregateValueSource::variant,
+        dimensions_fn: |any| {
+            let problem = any
+                .downcast_ref::<AggregateValueSource>()
+                .expect("AggregateValueSource brute-force dimensions type mismatch");
+            problemreductions::solvers::BruteForceProblem::dimensions(problem)
+        },
+        solve_fn: solve_dynamic::<AggregateValueSource>,
+        solve_typed_fn: solve_typed::<AggregateValueSource>,
+        solve_typed_with_witnesses_fn: solve_typed_with_witnesses::<AggregateValueSource>,
     }
 }
 
@@ -146,8 +345,21 @@ problemreductions::inventory::submit! {
         variant_fn: AggregateValueTarget::variant,
         complexity: "2",
         complexity_eval_fn: |_| 1.0,
+        parameter_names_fn: AggregateValueTarget::parameter_names,
+        parameter_measure_fn: |any| {
+            any.downcast_ref::<AggregateValueTarget>()
+                .expect("AggregateValueTarget size type mismatch")
+                .parameters()
+        },
         is_default: true,
         aliases: &[],
+        create_inputs: None,
+        construct_fn: |data| {
+            let problem: AggregateValueTarget = serde_json::from_value(data)
+                .map_err(|error| problemreductions::registry::ConstructionError::InvalidInput(error.to_string()))?;
+            Ok(Box::new(problem))
+        },
+        random: None,
         factory: |data| {
             let problem: AggregateValueTarget = serde_json::from_value(data)?;
             Ok(Box::new(problem))
@@ -156,8 +368,22 @@ problemreductions::inventory::submit! {
             let problem = any.downcast_ref::<AggregateValueTarget>()?;
             Some(serde_json::to_value(problem).expect("serialize AggregateValueTarget failed"))
         },
-        solve_value_fn: solve_value::<AggregateValueTarget>,
-        solve_witness_fn: solve_witness::<AggregateValueTarget>,
+    }
+}
+
+problemreductions::inventory::submit! {
+    problemreductions::solvers::BruteForceRegistration {
+        source_name: AggregateValueTarget::NAME,
+        source_variant_fn: AggregateValueTarget::variant,
+        dimensions_fn: |any| {
+            let problem = any
+                .downcast_ref::<AggregateValueTarget>()
+                .expect("AggregateValueTarget brute-force dimensions type mismatch");
+            problemreductions::solvers::BruteForceProblem::dimensions(problem)
+        },
+        solve_fn: solve_dynamic::<AggregateValueTarget>,
+        solve_typed_fn: solve_typed::<AggregateValueTarget>,
+        solve_typed_with_witnesses_fn: solve_typed_with_witnesses::<AggregateValueTarget>,
     }
 }
 
@@ -167,22 +393,27 @@ problemreductions::inventory::submit! {
         target_name: AggregateValueTarget::NAME,
         source_variant_fn: AggregateValueSource::variant,
         target_variant_fn: AggregateValueTarget::variant,
-        overhead_fn: || ReductionOverhead::default(),
+        parameter_declarations_fn: || ReductionParameterDeclarations {
+            relation: None,
+            fields: vec![],
+            unavailable: vec![problemreductions::rules::registry::UnavailableParameterField {
+                field: "num_values",
+                reason: "the synthetic aggregate target has no parameter model",
+            }],
+        },
         module_path: module_path!(),
         reduce_fn: None,
         reduce_aggregate_fn: Some(|any: &dyn Any| {
             let source = any
                 .downcast_ref::<AggregateValueSource>()
                 .expect("aggregate reduction downcast failed");
-            Box::new(ReductionAutoCast::<AggregateValueSource, AggregateValueTarget>::new(
+            Ok(Box::new(VariantReductionResult::<AggregateValueSource, AggregateValueTarget>::new(
                 AggregateValueTarget {
                     base: source.values.iter().sum(),
                 },
-            ))
+            )))
         }),
-        capabilities: EdgeCapabilities::aggregate_only(),
-        overhead_eval_fn: |_| ProblemSize::new(vec![]),
-        source_size_fn: |_| ProblemSize::new(vec![]),
+        turing: false,
     }
 }
 
@@ -192,20 +423,36 @@ problemreductions::inventory::submit! {
         target_name: ILP::<bool>::NAME,
         source_variant_fn: AggregateValueSource::variant,
         target_variant_fn: ILP::<bool>::variant,
-        overhead_fn: || ReductionOverhead::default(),
+        parameter_declarations_fn: || ReductionParameterDeclarations {
+            relation: None,
+            fields: vec![],
+            unavailable: vec![
+                problemreductions::rules::registry::UnavailableParameterField {
+                    field: "num_vars",
+                    reason: "the synthetic aggregate-to-ILP reduction has no parameter model",
+                },
+                problemreductions::rules::registry::UnavailableParameterField {
+                    field: "num_constraints",
+                    reason: "the synthetic aggregate-to-ILP reduction has no parameter model",
+                },
+                problemreductions::rules::registry::UnavailableParameterField {
+                    field: "num_nonzeros",
+                    reason: "the synthetic aggregate-to-ILP reduction has no parameter model",
+                },
+            ],
+        },
         module_path: module_path!(),
         reduce_fn: None,
         reduce_aggregate_fn: Some(|any: &dyn Any| {
             let _source = any
                 .downcast_ref::<AggregateValueSource>()
                 .expect("aggregate ILP reduction downcast failed");
-            Box::new(AggregateValueToIlpReduction {
-                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize),
-            })
+            Ok(Box::new(AggregateValueToIlpReduction {
+                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize)
+                    .expect("empty ILP is valid"),
+            }))
         }),
-        capabilities: EdgeCapabilities::aggregate_only(),
-        overhead_eval_fn: |_| ProblemSize::new(vec![]),
-        source_size_fn: |_| ProblemSize::new(vec![]),
+        turing: false,
     }
 }
 
diff --git a/problemreductions-cli/src/util.rs b/problemreductions-cli/src/util.rs
index 0f9b08a3d..04204bb8b 100644
--- a/problemreductions-cli/src/util.rs
+++ b/problemreductions-cli/src/util.rs
@@ -2,127 +2,6 @@
 
 use anyhow::{bail, Result};
 use num_bigint::BigUint;
-use problemreductions::prelude::*;
-use problemreductions::topology::SimpleGraph;
-use problemreductions::variant::{K2, K3, KN};
-use serde::Serialize;
-use std::collections::BTreeMap;
-
-// ---------------------------------------------------------------------------
-// K-parameter validation
-// ---------------------------------------------------------------------------
-
-/// Derive the k variant string from a numeric k value.
-fn k_variant_str(k: usize) -> &'static str {
-    match k {
-        1 => "K1",
-        2 => "K2",
-        3 => "K3",
-        4 => "K4",
-        5 => "K5",
-        _ => "KN",
-    }
-}
-
-/// Validate that `--k` (or `params.k`) is consistent with a variant suffix
-/// (e.g., `/K2`). Returns the effective k value and variant map.
-///
-/// Rules:
-/// - If the resolved variant has a specific k (e.g., K2), `k_flag` must
-///   either be `None` or match. A mismatch is an error.
-/// - If the resolved variant has k=KN (or no k), any `k_flag` is accepted.
-/// - If `k_flag` is `None`, k is inferred from the variant (K2→2, K3→3, etc.),
-///   or defaults to `default_k`.
-pub fn validate_k_param(
-    resolved_variant: &BTreeMap<String, String>,
-    k_flag: Option<usize>,
-    default_k: Option<usize>,
-    problem_name: &str,
-) -> Result<(usize, BTreeMap<String, String>)> {
-    let variant_k_str = resolved_variant.get("k").map(|s| s.as_str());
-    let variant_k_num: Option<usize> = match variant_k_str {
-        Some("K1") => Some(1),
-        Some("K2") => Some(2),
-        Some("K3") => Some(3),
-        Some("K4") => Some(4),
-        Some("K5") => Some(5),
-        _ => None, // KN or absent
-    };
-
-    let effective_k = match (k_flag, variant_k_num) {
-        (Some(flag), Some(from_variant)) if flag != from_variant => {
-            bail!(
-                "{problem_name}: --k {flag} conflicts with variant /{} (k={from_variant}). \
-                 Either omit the suffix or match the --k value.",
-                variant_k_str.unwrap()
-            );
-        }
-        (Some(flag), _) => flag,
-        (None, Some(from_variant)) => from_variant,
-        (None, None) => match default_k {
-            Some(d) => d,
-            None => bail!("{problem_name} requires --k <value>"),
-        },
-    };
-
-    if effective_k == 0 {
-        bail!("{problem_name}: --k must be positive");
-    }
-
-    // Build the variant map with the effective k
-    let mut variant = resolved_variant.clone();
-    variant.insert("k".to_string(), k_variant_str(effective_k).to_string());
-
-    Ok((effective_k, variant))
-}
-
-// ---------------------------------------------------------------------------
-// K-problem serialization
-// ---------------------------------------------------------------------------
-
-/// Serialize a KColoring instance given a graph and validated k.
-pub fn ser_kcoloring(
-    graph: SimpleGraph,
-    k: usize,
-) -> Result<(serde_json::Value, BTreeMap<String, String>)> {
-    match k {
-        2 => Ok((
-            ser(KColoring::<K2, SimpleGraph>::new(graph))?,
-            variant_map(&[("k", "K2"), ("graph", "SimpleGraph")]),
-        )),
-        3 => Ok((
-            ser(KColoring::<K3, SimpleGraph>::new(graph))?,
-            variant_map(&[("k", "K3"), ("graph", "SimpleGraph")]),
-        )),
-        _ => Ok((
-            ser(KColoring::<KN, SimpleGraph>::with_k(graph, k))?,
-            variant_map(&[("k", "KN"), ("graph", "SimpleGraph")]),
-        )),
-    }
-}
-
-/// Serialize a KSatisfiability instance given clauses and validated k.
-#[cfg(feature = "mcp")]
-pub fn ser_ksat(
-    num_vars: usize,
-    clauses: Vec<CNFClause>,
-    k: usize,
-) -> Result<(serde_json::Value, BTreeMap<String, String>)> {
-    match k {
-        2 => Ok((
-            ser(KSatisfiability::<K2>::new(num_vars, clauses))?,
-            variant_map(&[("k", "K2")]),
-        )),
-        3 => Ok((
-            ser(KSatisfiability::<K3>::new(num_vars, clauses))?,
-            variant_map(&[("k", "K3")]),
-        )),
-        _ => Ok((
-            ser(KSatisfiability::<KN>::new(num_vars, clauses))?,
-            variant_map(&[("k", "KN")]),
-        )),
-    }
-}
 
 // ---------------------------------------------------------------------------
 // Parsing helpers
@@ -157,97 +36,6 @@ where
 }
 
 // ---------------------------------------------------------------------------
-// Random generation (LCG-based)
-// ---------------------------------------------------------------------------
-
-/// LCG PRNG step — returns next state and a uniform f64 in [0, 1).
-pub fn lcg_step(state: &mut u64) -> f64 {
-    *state = state
-        .wrapping_mul(6364136223846793005)
-        .wrapping_add(1442695040888963407);
-    (*state >> 33) as f64 / (1u64 << 31) as f64
-}
-
-/// Initialize LCG state from seed or system time.
-pub fn lcg_init(seed: Option<u64>) -> u64 {
-    seed.unwrap_or_else(|| {
-        std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos() as u64
-    })
-}
-
-/// Generate a random Erdos-Renyi graph using a simple LCG PRNG.
-pub fn create_random_graph(num_vertices: usize, edge_prob: f64, seed: Option<u64>) -> SimpleGraph {
-    let mut state = lcg_init(seed);
-    let mut edges = Vec::new();
-    for i in 0..num_vertices {
-        for j in (i + 1)..num_vertices {
-            let rand_val = lcg_step(&mut state);
-            if rand_val < edge_prob {
-                edges.push((i, j));
-            }
-        }
-    }
-    SimpleGraph::new(num_vertices, edges)
-}
-
-/// Generate random unique integer positions on a grid for KingsSubgraph/TriangularSubgraph.
-pub fn create_random_int_positions(num_vertices: usize, seed: Option<u64>) -> Vec<(i32, i32)> {
-    let mut state = lcg_init(seed);
-    let grid_size = (num_vertices as f64).sqrt().ceil() as i32 + 1;
-    let mut positions = std::collections::BTreeSet::new();
-    while positions.len() < num_vertices {
-        let x = (lcg_step(&mut state) * grid_size as f64) as i32;
-        let y = (lcg_step(&mut state) * grid_size as f64) as i32;
-        positions.insert((x, y));
-    }
-    positions.into_iter().collect()
-}
-
-/// Generate random float positions in [0, sqrt(N)] x [0, sqrt(N)] for UnitDiskGraph.
-pub fn create_random_float_positions(num_vertices: usize, seed: Option<u64>) -> Vec<(f64, f64)> {
-    let mut state = lcg_init(seed);
-    let side = (num_vertices as f64).sqrt();
-    (0..num_vertices)
-        .map(|_| {
-            let x = lcg_step(&mut state) * side;
-            let y = lcg_step(&mut state) * side;
-            (x, y)
-        })
-        .collect()
-}
-
-/// Choose `k` distinct elements from `0..n` using Fisher-Yates partial shuffle.
-/// Returns a sorted vector of chosen indices.
-pub fn lcg_choose(state: &mut u64, n: usize, k: usize) -> Vec<usize> {
-    assert!(k <= n, "k={k} exceeds n={n}");
-    let mut indices: Vec<usize> = (0..n).collect();
-    for i in 0..k {
-        let j = i + (lcg_step(state) * (n - i) as f64) as usize % (n - i);
-        indices.swap(i, j);
-    }
-    let mut chosen: Vec<usize> = indices[..k].to_vec();
-    chosen.sort_unstable();
-    chosen
-}
-
-// ---------------------------------------------------------------------------
-// Small shared helpers
-// ---------------------------------------------------------------------------
-
-pub fn ser<T: Serialize>(problem: T) -> Result<serde_json::Value> {
-    Ok(serde_json::to_value(problem)?)
-}
-
-pub fn variant_map(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
-    pairs
-        .iter()
-        .map(|(k, v)| (k.to_string(), v.to_string()))
-        .collect()
-}
-
 /// Parse a comma-separated list of values.
 pub fn parse_comma_list<T: std::str::FromStr>(s: &str) -> Result<Vec<T>>
 where
@@ -287,19 +75,3 @@ pub fn parse_edge_pairs(s: &str) -> Result<Vec<(usize, usize)>> {
         })
         .collect()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::validate_k_param;
-    use std::collections::BTreeMap;
-
-    #[test]
-    fn test_validate_k_param_rejects_zero() {
-        let err = validate_k_param(&BTreeMap::new(), Some(0), None, "KthBestSpanningTree")
-            .expect_err("k=0 should be rejected before problem construction");
-        assert!(
-            err.to_string().contains("positive"),
-            "unexpected error message: {err}"
-        );
-    }
-}
diff --git a/problemreductions-cli/tests/cli_tests.rs b/problemreductions-cli/tests/cli_tests.rs
index 7bc3f386a..90224cc29 100644
--- a/problemreductions-cli/tests/cli_tests.rs
+++ b/problemreductions-cli/tests/cli_tests.rs
@@ -4,6 +4,75 @@ fn pred() -> Command {
     Command::new(env!("CARGO_BIN_EXE_pred"))
 }
 
+fn write_named_route(source: &str, target: &str, names: &[&str], output: &std::path::Path) {
+    let command = pred()
+        .args(["path", source, target, "--limit", "all", "--json"])
+        .output()
+        .unwrap();
+    assert!(
+        command.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&command.stderr)
+    );
+    let envelope: serde_json::Value = serde_json::from_slice(&command.stdout).unwrap();
+    let entry = envelope["paths"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|entry| {
+            let edges = entry["path"].as_array().unwrap();
+            let mut actual = vec![edges[0]["from"]["name"].as_str().unwrap()];
+            actual.extend(
+                edges
+                    .iter()
+                    .map(|edge| edge["to"]["name"].as_str().unwrap()),
+            );
+            actual == names
+        })
+        .expect("requested route must be present in path enumeration");
+    std::fs::write(output, serde_json::to_vec_pretty(entry).unwrap()).unwrap();
+}
+
+fn reduce_named_to_file(
+    problem: &std::path::Path,
+    source: &str,
+    target: &str,
+    names: &[&str],
+    output: &std::path::Path,
+) -> std::process::Output {
+    let route = output.with_extension("route.json");
+    write_named_route(source, target, names, &route);
+    let result = pred()
+        .args([
+            "-o",
+            output.to_str().unwrap(),
+            "reduce",
+            problem.to_str().unwrap(),
+            "--via",
+            route.to_str().unwrap(),
+        ])
+        .output()
+        .unwrap();
+    std::fs::remove_file(route).ok();
+    result
+}
+
+fn write_direct_route(source: &str, target: &str, output: &std::path::Path) {
+    let command = pred()
+        .args(["path", source, target, "--limit", "all", "--json"])
+        .output()
+        .unwrap();
+    assert!(command.status.success());
+    let envelope: serde_json::Value = serde_json::from_slice(&command.stdout).unwrap();
+    let route = envelope["paths"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|path| path["steps"] == 1)
+        .expect("advertised direct reduction must have a direct route");
+    std::fs::write(output, serde_json::to_vec_pretty(route).unwrap()).unwrap();
+}
+
 #[test]
 fn test_help() {
     let output = pred().arg("--help").output().unwrap();
@@ -17,13 +86,75 @@ fn test_list() {
     let output = pred().args(["list"]).output().unwrap();
     assert!(output.status.success());
     let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(stdout.contains("MaximumIndependentSet"));
-    assert!(stdout.contains("QUBO"));
+    assert!(stdout.contains("Registered catalog"));
+    assert!(stdout.contains("graph"));
+    for category in ["algebraic", "formula", "graph", "misc", "set"] {
+        assert!(stdout.contains(category));
+    }
+    assert!(!stdout.contains("MaximumIndependentSet"));
+    assert!(stdout.lines().count() < 30, "default list is too verbose");
+}
+
+#[test]
+fn test_list_filters_by_category() {
+    let output = pred()
+        .args(["list", "--category", "formula"])
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    assert!(stdout.contains("KSatisfiability"));
+    assert!(!stdout.contains("MaximumIndependentSet"));
+}
+
+#[test]
+fn test_list_json_respects_category_filter() {
+    let output = pred()
+        .args(["list", "--category", "formula", "--json"])
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    let variants = json["variants"].as_array().unwrap();
+    assert_eq!(json["num_types"], 9);
+    assert!(variants
+        .iter()
+        .all(|variant| variant["name"] != "MaximumIndependentSet"));
+    assert!(variants
+        .iter()
+        .all(|variant| variant["category"] == "formula"));
+    assert!(variants
+        .iter()
+        .any(|variant| variant["name"] == "KSatisfiability/K3"));
+}
+
+#[test]
+fn test_list_category_rejects_unknown_value() {
+    let output = pred()
+        .args(["list", "--category", "unknown"])
+        .output()
+        .unwrap();
+    assert!(!output.status.success());
+    let stderr = String::from_utf8(output.stderr).unwrap();
+    assert!(stderr.contains("unknown problem category `unknown`"));
+    assert!(stderr.contains("algebraic, formula, graph, misc, set"));
+}
+
+#[test]
+fn test_list_searches_variant_aliases() {
+    let output = pred().args(["list", "3SAT"]).output().unwrap();
+    assert!(output.status.success());
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    assert!(stdout.contains("KSatisfiability"));
+    assert!(stdout.contains("3SAT"));
 }
 
 #[test]
 fn test_list_includes_undirected_two_commodity_integral_flow() {
-    let output = pred().args(["list"]).output().unwrap();
+    let output = pred()
+        .args(["list", "UndirectedTwoCommodity"])
+        .output()
+        .unwrap();
     assert!(
         output.status.success(),
         "stderr: {}",
@@ -35,7 +166,10 @@ fn test_list_includes_undirected_two_commodity_integral_flow() {
 
 #[test]
 fn test_list_includes_integral_flow_homologous_arcs() {
-    let output = pred().args(["list"]).output().unwrap();
+    let output = pred()
+        .args(["list", "IntegralFlowHomologousArcs"])
+        .output()
+        .unwrap();
     assert!(
         output.status.success(),
         "stderr: {}",
@@ -59,7 +193,10 @@ fn test_solve_help_mentions_string_to_string_correction_bruteforce() {
 
 #[test]
 fn test_list_rules() {
-    let output = pred().args(["list", "--rules"]).output().unwrap();
+    let output = pred()
+        .args(["list", "--rules", "--all", "--verbose"])
+        .output()
+        .unwrap();
     assert!(
         output.status.success(),
         "stderr: {}",
@@ -69,7 +206,7 @@ fn test_list_rules() {
     assert!(stdout.contains("Registered reduction rules:"));
     assert!(stdout.contains("Source"));
     assert!(stdout.contains("Target"));
-    assert!(stdout.contains("Overhead"));
+    assert!(stdout.contains("Parameter transform"));
     // Should contain a known reduction
     assert!(
         stdout.contains("MaximumIndependentSet"),
@@ -88,7 +225,31 @@ fn test_list_rules_json() {
     assert!(!rules.is_empty());
     assert!(rules[0]["source"].is_string());
     assert!(rules[0]["target"].is_string());
-    assert!(rules[0]["overhead"].is_string());
+    assert!(rules[0]["parameter_contract"].is_string());
+}
+
+#[test]
+fn test_list_rules_searches_problem_aliases() {
+    let output = pred().args(["list", "--rules", "3SAT"]).output().unwrap();
+    assert!(output.status.success());
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    assert!(stdout.contains("KSatisfiability"));
+}
+
+#[test]
+fn test_list_rules_json_respects_query() {
+    let output = pred()
+        .args(["list", "--rules", "3SAT", "--json"])
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    let rules = json["rules"].as_array().unwrap();
+    assert_eq!(json["num_rules"].as_u64().unwrap() as usize, rules.len());
+    assert!(rules.iter().all(|rule| {
+        rule["source"].as_str().unwrap().contains("KSatisfiability")
+            || rule["target"].as_str().unwrap().contains("KSatisfiability")
+    }));
 }
 
 #[test]
@@ -189,8 +350,12 @@ fn test_solve_balanced_complete_bipartite_subgraph_default_solver_uses_ilp() {
     let stdout = String::from_utf8(solve.stdout).unwrap();
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["problem"], "BalancedCompleteBipartiteSubgraph");
-    assert_eq!(json["solver"], "ilp");
-    assert_eq!(json["reduced_to"], "ILP");
+    assert_eq!(json["solver"]["kind"], "ilp");
+    assert!(json["solver"]["reduction_path"]
+        .as_array()
+        .and_then(|path| path.last())
+        .and_then(|step| step.as_str())
+        .is_some_and(|step| step.starts_with("ILP<")));
     assert_eq!(json["evaluation"], "Or(true)");
     assert!(
         json["solution"]
@@ -203,47 +368,211 @@ fn test_solve_balanced_complete_bipartite_subgraph_default_solver_uses_ilp() {
 }
 
 #[test]
-fn test_path() {
-    let output = pred().args(["path", "MIS", "QUBO"]).output().unwrap();
+fn test_path_enumerates_without_mode() {
+    let output = pred().args(["path", "MIS", "QUBO/f64"]).output().unwrap();
     assert!(output.status.success());
     let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(stdout.contains("Path"));
-    assert!(stdout.contains("step"));
+    assert!(stdout.contains("Found"));
+    assert!(stdout.contains("paths from"));
+}
+
+#[test]
+fn test_path_rejects_zero_edge_route_for_symbolic_and_concrete_queries() {
+    let symbolic = pred()
+        .args(["path", "MIS", "MIS", "--json"])
+        .output()
+        .unwrap();
+    assert!(!symbolic.status.success());
+    assert!(String::from_utf8_lossy(&symbolic.stderr).contains("No reduction path"));
+
+    let instance = std::env::temp_dir().join("pred_path_same_source_mis.json");
+    std::fs::write(
+        &instance,
+        r#"{"type":"MaximumIndependentSet","variant":{"graph":"SimpleGraph","weight":"i64"},"data":{"graph":{"num_vertices":2,"edges":[[0,1]]},"weights":[1,1]}}"#,
+    )
+    .unwrap();
+    let concrete = pred()
+        .args([
+            "path",
+            "MIS/SimpleGraph/i64",
+            "MIS/SimpleGraph/i64",
+            instance.to_str().unwrap(),
+            "--json",
+        ])
+        .output()
+        .unwrap();
+    std::fs::remove_file(instance).ok();
+    assert!(!concrete.status.success());
+    assert!(String::from_utf8_lossy(&concrete.stderr).contains("No reduction path"));
+}
+
+#[test]
+fn test_path_concrete_execution_is_deterministic_and_measures_constructed_target() {
+    let instance = std::env::temp_dir().join("pred_path_concrete_mis.json");
+    std::fs::write(
+        &instance,
+        r#"{"type":"MaximumIndependentSet","variant":{"graph":"SimpleGraph","weight":"i64"},"data":{"graph":{"num_vertices":5,"edges":[[0,1],[1,2],[2,3],[3,4]]},"weights":[1,1,1,1,1]}}"#,
+    )
+    .unwrap();
+    let run = || {
+        let output = pred()
+            .args([
+                "path",
+                "MIS/SimpleGraph/i64",
+                "MaximumClique/SimpleGraph/i64",
+                instance.to_str().unwrap(),
+                "--json",
+            ])
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "stderr: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        String::from_utf8(output.stdout).unwrap()
+    };
+    let first = run();
+    let second = run();
+    std::fs::remove_file(instance).ok();
+    assert_eq!(first, second);
+    let json: serde_json::Value = serde_json::from_str(&first).unwrap();
+    let overall = json["paths"][0]["actual_target_parameters"]["fields"]
+        .as_array()
+        .unwrap();
+    let value = |field: &str| &overall.iter().find(|item| item["field"] == field).unwrap()["value"];
+    assert_eq!(value("num_vertices"), 5);
+    assert_eq!(value("num_edges"), 6);
+    assert!(json.get("comparison").is_none());
+}
+
+#[test]
+fn test_path_returns_every_enumerated_candidate_in_stable_order() {
+    let instance = std::env::temp_dir().join("pred_path_candidates_mis.json");
+    std::fs::write(
+        &instance,
+        r#"{"type":"MaximumIndependentSet","variant":{"graph":"SimpleGraph","weight":"i64"},"data":{"graph":{"num_vertices":5,"edges":[[0,1],[1,2],[2,3],[3,4]]},"weights":[1,1,1,1,1]}}"#,
+    )
+    .unwrap();
+    let run = |limit: &str| {
+        let output = pred()
+            .args([
+                "path",
+                "MIS/SimpleGraph/i64",
+                "QUBO/f64",
+                instance.to_str().unwrap(),
+                "--limit",
+                limit,
+                "--json",
+            ])
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "stderr: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        serde_json::from_slice::<serde_json::Value>(&output.stdout).unwrap()
+    };
+
+    let first_three = run("3");
+    let first = run("1");
+    std::fs::remove_file(instance).unwrap();
+
+    assert_eq!(first_three["paths"].as_array().unwrap().len(), 3);
+    assert_eq!(first["paths"].as_array().unwrap().len(), 1);
+    assert_eq!(first_three["truncated"], true);
+    assert_eq!(first["truncated"], true);
+    assert_eq!(first["paths"][0], first_three["paths"][0]);
 }
 
 #[test]
 fn test_path_save() {
     let tmp = std::env::temp_dir().join("pred_test_path.json");
     let output = pred()
-        .args(["path", "MIS", "QUBO", "-o", tmp.to_str().unwrap()])
+        .args([
+            "path",
+            "MIS/SimpleGraph/i64",
+            "MaximumClique/SimpleGraph/i64",
+            "-o",
+            tmp.to_str().unwrap(),
+        ])
         .output()
         .unwrap();
-    assert!(output.status.success());
+    assert!(
+        output.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
     assert!(tmp.exists());
     let content = std::fs::read_to_string(&tmp).unwrap();
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
-    assert!(json["path"].is_array());
+    assert!(json.get("path").is_none());
+    assert!(json["paths"]
+        .as_array()
+        .is_some_and(|paths| !paths.is_empty()));
     std::fs::remove_file(&tmp).ok();
 }
 
 #[test]
-fn test_path_all() {
+fn test_path_limit_bounds_enumeration() {
     let output = pred()
-        .args(["path", "MIS", "QUBO", "--all"])
+        .args(["path", "MIS", "QUBO/f64", "--limit", "1", "--json"])
         .output()
         .unwrap();
     assert!(output.status.success());
-    let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(stdout.contains("Found"));
-    assert!(stdout.contains("paths from"));
+    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    assert_eq!(json["paths"].as_array().unwrap().len(), 1);
+    assert_eq!(json["truncated"], true);
+    assert!(json.get("returned").is_none());
+    assert!(json.get("max_paths").is_none());
+}
+
+#[test]
+fn test_path_rejects_limit_above_maximum() {
+    let output = pred()
+        .args(["path", "MIS", "QUBO", "--limit", "1000"])
+        .output()
+        .unwrap();
+    assert!(!output.status.success());
+    assert!(String::from_utf8_lossy(&output.stderr)
+        .contains("limit must be an integer from 1 to 999 or 'all'"));
 }
 
 #[test]
-fn test_path_all_save() {
-    let dir = std::env::temp_dir().join("pred_test_all_paths");
-    let _ = std::fs::remove_dir_all(&dir);
+fn test_path_limit_all_is_alias_for_999() {
+    let run = |limit: &str| {
+        let output = pred()
+            .args(["path", "MIS", "QUBO/f64", "--limit", limit, "--json"])
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "stderr: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        output.stdout
+    };
+
+    assert_eq!(run("all"), run("999"));
+}
+
+#[test]
+fn test_path_rejects_zero_limit() {
+    let output = pred()
+        .args(["path", "MIS", "QUBO", "--limit", "0"])
+        .output()
+        .unwrap();
+    assert!(!output.status.success());
+    assert!(String::from_utf8_lossy(&output.stderr)
+        .contains("limit must be an integer from 1 to 999 or 'all'"));
+}
+
+#[test]
+fn test_path_set_save() {
+    let file = std::env::temp_dir().join("pred_test_paths.json");
     let output = pred()
-        .args(["path", "MIS", "QUBO", "--all", "-o", dir.to_str().unwrap()])
+        .args(["path", "MIS", "QUBO/f64", "-o", file.to_str().unwrap()])
         .output()
         .unwrap();
     assert!(
@@ -251,17 +580,11 @@ fn test_path_all_save() {
         "stderr: {}",
         String::from_utf8_lossy(&output.stderr)
     );
-    assert!(dir.is_dir());
-    let entries: Vec<_> = std::fs::read_dir(&dir).unwrap().collect();
-    assert!(entries.len() > 1, "expected multiple path files");
-
-    // Verify first file is valid JSON
-    let first = dir.join("path_1.json");
-    let content = std::fs::read_to_string(&first).unwrap();
+    let content = std::fs::read_to_string(&file).unwrap();
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
-    assert!(json["path"].is_array());
+    assert!(json["paths"].is_array());
 
-    std::fs::remove_dir_all(&dir).ok();
+    std::fs::remove_file(&file).ok();
 }
 
 #[test]
@@ -296,13 +619,44 @@ fn test_export_stdout() {
 }
 
 #[test]
-fn test_show_includes_fields() {
+fn test_show_includes_concrete_inputs() {
     let output = pred().args(["show", "MIS"]).output().unwrap();
     assert!(output.status.success());
     let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(stdout.contains("Fields"));
+    assert!(stdout.contains("Inputs"));
     assert!(stdout.contains("graph"));
-    assert!(stdout.contains("weights"));
+    assert!(!stdout.contains("  weights ("));
+}
+
+#[test]
+fn test_show_inputs_follow_the_selected_variant() {
+    for (spec, required_field, absent_field) in [
+        ("MVC/One", "graph", "weights"),
+        ("MVC/i64", "weights", "positions"),
+        ("MIS/KingsSubgraph/One", "positions", "graph"),
+        ("DecisionMaximumIndependentSet/One", "bound", "weights"),
+    ] {
+        let output = pred().args(["show", spec, "--json"]).output().unwrap();
+        assert!(
+            output.status.success(),
+            "{spec}: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        let result: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+        let inputs = result["inputs"].as_array().unwrap();
+        assert!(
+            inputs.iter().any(|input| input["name"] == required_field),
+            "{spec}"
+        );
+        assert!(
+            !inputs.iter().any(|input| input["name"] == absent_field),
+            "{spec}"
+        );
+        assert!(result["schema"].get("fields").is_none());
+        assert!(inputs
+            .iter()
+            .all(|input| !input["type_name"].as_str().unwrap().contains("<W>")));
+    }
 }
 
 #[test]
@@ -379,7 +733,7 @@ fn test_unknown_problem_no_match() {
 fn test_evaluate() {
     let problem_json = r#"{
         "type": "MaximumIndependentSet",
-        "variant": {"graph": "SimpleGraph", "weight": "i32"},
+        "variant": {"graph": "SimpleGraph", "weight": "i64"},
         "data": {
             "graph": {"num_vertices": 4, "edges": [[0,1],[1,2],[2,3]]},
             "weights": [1, 1, 1, 1]
@@ -389,7 +743,12 @@ fn test_evaluate() {
     std::fs::write(&tmp, problem_json).unwrap();
 
     let output = pred()
-        .args(["evaluate", tmp.to_str().unwrap(), "--config", "1,0,1,0"])
+        .args([
+            "evaluate",
+            tmp.to_str().unwrap(),
+            "--config",
+            "[true,false,true,false]",
+        ])
         .output()
         .unwrap();
     assert!(
@@ -415,7 +774,12 @@ fn test_evaluate_sat() {
     std::fs::write(&tmp, problem_json).unwrap();
 
     let output = pred()
-        .args(["evaluate", tmp.to_str().unwrap(), "--config", "1,1,0"])
+        .args([
+            "evaluate",
+            tmp.to_str().unwrap(),
+            "--config",
+            "[true,true,false]",
+        ])
         .output()
         .unwrap();
     assert!(output.status.success());
@@ -435,7 +799,7 @@ fn test_evaluate_consecutive_block_minimization_rejects_ragged_matrix() {
     std::fs::write(&tmp, problem_json).unwrap();
 
     let output = pred()
-        .args(["evaluate", tmp.to_str().unwrap(), "--config", "0,1"])
+        .args(["evaluate", tmp.to_str().unwrap(), "--config", "[0,1]"])
         .output()
         .unwrap();
     assert!(!output.status.success());
@@ -449,7 +813,7 @@ fn test_evaluate_consecutive_block_minimization_rejects_ragged_matrix() {
 fn test_evaluate_multiple_choice_branching_rejects_invalid_partition_without_panicking() {
     let problem_json = r#"{
         "type": "MultipleChoiceBranching",
-        "variant": {"weight": "i32"},
+        "variant": {"weight": "i64"},
         "data": {
             "graph": {"num_vertices": 2, "arcs": [[0,1]]},
             "weights": [1],
@@ -545,7 +909,7 @@ fn test_create_undirected_two_commodity_integral_flow_missing_capacities_shows_u
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("requires --capacities"));
+    assert!(stderr.contains("missing required construction input(s): capacities"));
     assert!(stderr.contains("Usage: pred create UndirectedTwoCommodityIntegralFlow"));
 }
 
@@ -576,7 +940,7 @@ fn test_create_undirected_two_commodity_integral_flow_rejects_invalid_capacity_t
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("Invalid capacity `x`"));
+    assert!(stderr.contains("invalid digit found in string"));
     assert!(stderr.contains("Usage: pred create UndirectedTwoCommodityIntegralFlow"));
 }
 
@@ -607,7 +971,7 @@ fn test_create_undirected_two_commodity_integral_flow_rejects_wrong_capacity_cou
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("Expected 3 capacities but got 2"));
+    assert!(stderr.contains("capacities length must match graph edge count"));
     assert!(stderr.contains("Usage: pred create UndirectedTwoCommodityIntegralFlow"));
 }
 
@@ -640,7 +1004,6 @@ fn test_create_undirected_two_commodity_integral_flow_rejects_oversized_capacity
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains(format!("Invalid capacity `{oversized}`").as_str()));
     assert!(stderr.contains("number too large to fit in target type"));
     assert!(stderr.contains("Usage: pred create UndirectedTwoCommodityIntegralFlow"));
 }
@@ -672,7 +1035,7 @@ fn test_create_undirected_two_commodity_integral_flow_rejects_out_of_range_termi
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("source-1 must be less than num_vertices (4)"));
+    assert!(stderr.contains("source_1 must be less than num_vertices"));
     assert!(stderr.contains("Usage: pred create UndirectedTwoCommodityIntegralFlow"));
     assert!(!stderr.contains("panicked at"), "stderr: {stderr}");
 }
@@ -747,7 +1110,7 @@ fn test_create_integral_flow_bundles_missing_bundles_shows_usage() {
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("requires --bundles"));
+    assert!(stderr.contains("missing required construction input(s): bundles"));
     assert!(stderr.contains("Usage: pred create IntegralFlowBundles"));
 }
 
@@ -776,7 +1139,7 @@ fn test_create_integral_flow_bundles_rejects_wrong_bundle_capacity_count() {
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("Expected 3 bundle capacities but got 2"));
+    assert!(stderr.contains("bundles length must match bundle_capacities length"));
     assert!(stderr.contains("Usage: pred create IntegralFlowBundles"));
 }
 
@@ -805,7 +1168,7 @@ fn test_create_integral_flow_bundles_rejects_out_of_range_bundle_arc() {
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("bundle 1 references arc 7"));
+    assert!(stderr.contains("bundle 1 arc is out of range"));
     assert!(stderr.contains("Usage: pred create IntegralFlowBundles"));
     assert!(!stderr.contains("panicked at"), "stderr: {stderr}");
 }
@@ -888,7 +1251,7 @@ fn test_create_integral_flow_homologous_arcs_requires_homologous_pairs() {
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("requires --homologous-pairs"));
+    assert!(stderr.contains("missing required construction input(s): homologous_pairs"));
     assert!(stderr.contains("Usage: pred create IntegralFlowHomologousArcs"));
 }
 
@@ -915,7 +1278,7 @@ fn test_create_integral_flow_homologous_arcs_rejects_invalid_pair_token() {
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("u=v"));
+    assert!(stderr.contains("expected format left=right"));
     assert!(stderr.contains("Usage: pred create IntegralFlowHomologousArcs"));
 }
 
@@ -983,7 +1346,7 @@ fn test_create_integral_flow_with_multipliers_missing_multipliers_shows_usage()
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("requires --multipliers"));
+    assert!(stderr.contains("missing required construction input(s): multipliers"));
     assert!(stderr.contains("Usage: pred create IntegralFlowWithMultipliers"));
 }
 
@@ -1010,7 +1373,7 @@ fn test_create_integral_flow_with_multipliers_rejects_wrong_multiplier_count() {
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("Expected 4 multipliers but got 3"));
+    assert!(stderr.contains("multipliers length must match num_vertices"));
     assert!(stderr.contains("Usage: pred create IntegralFlowWithMultipliers"));
 }
 
@@ -1064,7 +1427,7 @@ fn test_create_integral_flow_with_multipliers_rejects_identical_source_and_sink(
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("requires distinct --source and --sink"));
+    assert!(stderr.contains("source and sink must be distinct"));
     assert!(stderr.contains("Usage: pred create IntegralFlowWithMultipliers"));
 }
 
@@ -1075,45 +1438,24 @@ fn test_create_consecutive_block_minimization_rejects_ragged_matrix() {
             "create",
             "ConsecutiveBlockMinimization",
             "--matrix",
-            "[[true],[true,false]]",
-            "--bound",
+            "1;1,0",
+            "--bound-k",
             "2",
         ])
         .output()
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("all matrix rows must have the same length"));
+    assert!(stderr.contains("All rows in --matrix must have the same length"));
     assert!(stderr.contains("Usage: pred create ConsecutiveBlockMinimization"));
     assert!(!stderr.contains("panicked at"), "stderr: {stderr}");
 }
 
-#[test]
-fn test_create_consecutive_block_minimization_help_mentions_json_matrix_format() {
-    let output = pred()
-        .args(["create", "ConsecutiveBlockMinimization"])
-        .output()
-        .unwrap();
-    assert!(!output.status.success());
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("JSON 2D bool array"));
-    assert!(stderr.contains("[[true,false,true],[false,true,true]]"));
-}
-
-#[test]
-fn test_create_help_mentions_consecutive_block_minimization_matrix_format() {
-    let output = pred().args(["create", "--help"]).output().unwrap();
-    assert!(output.status.success());
-    let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(stdout.contains("ConsecutiveBlockMinimization"));
-    assert!(stdout.contains("JSON 2D bool array"));
-}
-
 #[test]
 fn test_reduce() {
     let problem_json = r#"{
         "type": "MIS",
-        "variant": {"graph": "SimpleGraph", "weight": "i32"},
+        "variant": {"graph": "SimpleGraph", "weight": "i64"},
         "data": {
             "graph": {"num_vertices": 4, "edges": [[0,1],[1,2],[2,3]]},
             "weights": [1, 1, 1, 1]
@@ -1121,7 +1463,19 @@ fn test_reduce() {
     }"#;
     let input = std::env::temp_dir().join("pred_test_reduce_in.json");
     let output_file = std::env::temp_dir().join("pred_test_reduce_out.json");
+    let route_file = std::env::temp_dir().join("pred_test_reduce_route.json");
     std::fs::write(&input, problem_json).unwrap();
+    write_named_route(
+        "MIS/SimpleGraph/i64",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
+            "QUBO",
+        ],
+        &route_file,
+    );
 
     let output = pred()
         .args([
@@ -1129,8 +1483,8 @@ fn test_reduce() {
             output_file.to_str().unwrap(),
             "reduce",
             input.to_str().unwrap(),
-            "--to",
-            "QUBO",
+            "--via",
+            route_file.to_str().unwrap(),
         ])
         .output()
         .unwrap();
@@ -1148,6 +1502,7 @@ fn test_reduce() {
     assert!(bundle["path"].is_array());
 
     std::fs::remove_file(&input).ok();
+    std::fs::remove_file(&route_file).ok();
     std::fs::remove_file(&output_file).ok();
 }
 
@@ -1160,7 +1515,7 @@ fn test_reduce_via_path() {
             "-o",
             problem_file.to_str().unwrap(),
             "create",
-            "MIS/SimpleGraph/i32",
+            "MIS/SimpleGraph/i64",
             "--graph",
             "0-1,1-2,2-3",
             "--weights",
@@ -1170,19 +1525,19 @@ fn test_reduce_via_path() {
         .unwrap();
     assert!(create_out.status.success());
 
-    // 2. Generate path file (use same variant as the problem)
+    // 2. Explicitly extract a named route from the enumerated path set.
     let path_file = std::env::temp_dir().join("pred_test_reduce_via_path.json");
-    let path_out = pred()
-        .args([
-            "path",
-            "MIS/SimpleGraph/i32",
+    write_named_route(
+        "MIS/SimpleGraph/i64",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-            "-o",
-            path_file.to_str().unwrap(),
-        ])
-        .output()
-        .unwrap();
-    assert!(path_out.status.success());
+        ],
+        &path_file,
+    );
 
     // 3. Reduce via path file
     let output_file = std::env::temp_dir().join("pred_test_reduce_via_out.json");
@@ -1192,8 +1547,6 @@ fn test_reduce_via_path() {
             output_file.to_str().unwrap(),
             "reduce",
             problem_file.to_str().unwrap(),
-            "--to",
-            "QUBO",
             "--via",
             path_file.to_str().unwrap(),
         ])
@@ -1217,74 +1570,66 @@ fn test_reduce_via_path() {
 }
 
 #[test]
-fn test_reduce_via_infer_target() {
-    // --via without --to: target is inferred from the path file
-    let problem_file = std::env::temp_dir().join("pred_test_reduce_via_infer_in.json");
-    let create_out = pred()
+fn test_reduce_rejects_discontinuous_explicit_route() {
+    let problem_file = std::env::temp_dir().join("pred_test_reduce_discontinuous_in.json");
+    let route_file = std::env::temp_dir().join("pred_test_reduce_discontinuous_route.json");
+    let create = pred()
         .args([
             "-o",
             problem_file.to_str().unwrap(),
             "create",
-            "MIS/SimpleGraph/i32",
+            "MIS/SimpleGraph/i64",
             "--graph",
-            "0-1,1-2,2-3",
+            "0-1,1-2",
             "--weights",
-            "1,1,1,1",
+            "1,1,1",
         ])
         .output()
         .unwrap();
-    assert!(create_out.status.success());
-
-    let path_file = std::env::temp_dir().join("pred_test_reduce_via_infer_path.json");
-    let path_out = pred()
-        .args([
-            "path",
-            "MIS/SimpleGraph/i32",
+    assert!(create.status.success());
+    write_named_route(
+        "MIS/SimpleGraph/i64",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-            "-o",
-            path_file.to_str().unwrap(),
-        ])
-        .output()
-        .unwrap();
-    assert!(path_out.status.success());
+        ],
+        &route_file,
+    );
+    let mut route: serde_json::Value =
+        serde_json::from_slice(&std::fs::read(&route_file).unwrap()).unwrap();
+    route["path"][1]["from"]["name"] = serde_json::json!("MinimumVertexCover");
+    std::fs::write(&route_file, serde_json::to_vec_pretty(&route).unwrap()).unwrap();
 
-    let output_file = std::env::temp_dir().join("pred_test_reduce_via_infer_out.json");
-    let reduce_out = pred()
+    let output = pred()
         .args([
-            "-o",
-            output_file.to_str().unwrap(),
             "reduce",
             problem_file.to_str().unwrap(),
             "--via",
-            path_file.to_str().unwrap(),
+            route_file.to_str().unwrap(),
         ])
         .output()
         .unwrap();
-    assert!(
-        reduce_out.status.success(),
-        "stderr: {}",
-        String::from_utf8_lossy(&reduce_out.stderr)
-    );
-
-    let content = std::fs::read_to_string(&output_file).unwrap();
-    let bundle: serde_json::Value = serde_json::from_str(&content).unwrap();
-    assert_eq!(bundle["source"]["type"], "MaximumIndependentSet");
-    assert_eq!(bundle["target"]["type"], "QUBO");
+    assert!(!output.status.success());
+    assert!(String::from_utf8_lossy(&output.stderr).contains("not continuous"));
 
-    std::fs::remove_file(&problem_file).ok();
-    std::fs::remove_file(&path_file).ok();
-    std::fs::remove_file(&output_file).ok();
+    std::fs::remove_file(problem_file).ok();
+    std::fs::remove_file(route_file).ok();
 }
 
+/// A path-set envelope is not itself an executable route.
 #[test]
-fn test_reduce_via_rejects_target_variant_mismatch() {
-    let problem_file = std::env::temp_dir().join("pred_test_reduce_via_variant_in.json");
+fn test_reduce_rejects_unselected_path_set() {
+    // 1. Create a small source problem (small so the target brute-force stays tiny).
+    let problem_file = std::env::temp_dir().join("pred_test_reduce_via_bare_in.json");
     let create_out = pred()
         .args([
             "-o",
             problem_file.to_str().unwrap(),
             "create",
-            "MIS/SimpleGraph/i32",
+            "MIS/SimpleGraph/i64",
             "--graph",
             "0-1,1-2,2-3",
             "--weights",
@@ -1294,12 +1639,13 @@ fn test_reduce_via_rejects_target_variant_mismatch() {
         .unwrap();
     assert!(create_out.status.success());
 
-    let path_file = std::env::temp_dir().join("pred_test_reduce_via_variant_path.json");
+    // 2. Save the path set without choosing a route.
+    let path_file = std::env::temp_dir().join("pred_test_reduce_via_bare_path.json");
     let path_out = pred()
         .args([
             "path",
-            "MIS/SimpleGraph/i32",
-            "ILP/bool",
+            "MaximumIndependentSet/SimpleGraph/i64",
+            "MaximumClique/SimpleGraph/i64",
             "-o",
             path_file.to_str().unwrap(),
         ])
@@ -1315,30 +1661,158 @@ fn test_reduce_via_rejects_target_variant_mismatch() {
         .args([
             "reduce",
             problem_file.to_str().unwrap(),
-            "--to",
-            "ILP/i32",
+            "--via",
+            path_file.to_str().unwrap(),
+        ])
+        .output()
+        .unwrap();
+    assert!(!reduce_out.status.success());
+    assert!(String::from_utf8_lossy(&reduce_out.stderr).contains("explicit route"));
+
+    std::fs::remove_file(&problem_file).ok();
+    std::fs::remove_file(&path_file).ok();
+}
+
+/// Every path-set item carries its route, while the envelope selects none.
+#[test]
+fn test_path_set_envelope_has_only_per_item_paths() {
+    let output = pred()
+        .args([
+            "path",
+            "MIS/SimpleGraph/i64",
+            "MaximumClique/SimpleGraph/i64",
+            "--json",
+        ])
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    let json: serde_json::Value =
+        serde_json::from_str(&String::from_utf8(output.stdout).unwrap()).unwrap();
+
+    assert!(json["paths"]
+        .as_array()
+        .is_some_and(|paths| !paths.is_empty()));
+
+    assert!(json.get("path").is_none());
+    let path = json["paths"][0]["path"]
+        .as_array()
+        .expect("path-set item route");
+    assert!(!path.is_empty(), "path-set item must have ≥ 1 step");
+    let first = &path[0];
+    assert!(first["from"]["name"].is_string(), "step needs from.name");
+    assert!(first["to"]["name"].is_string(), "step needs to.name");
+    assert_eq!(first["from"]["name"], "MaximumIndependentSet");
+}
+
+#[test]
+fn test_reduce_via_infer_target() {
+    // --via without --to: target is inferred from the path file
+    let problem_file = std::env::temp_dir().join("pred_test_reduce_via_infer_in.json");
+    let create_out = pred()
+        .args([
+            "-o",
+            problem_file.to_str().unwrap(),
+            "create",
+            "MIS/SimpleGraph/i64",
+            "--graph",
+            "0-1,1-2,2-3",
+            "--weights",
+            "1,1,1,1",
+        ])
+        .output()
+        .unwrap();
+    assert!(create_out.status.success());
+
+    let path_file = std::env::temp_dir().join("pred_test_reduce_via_infer_path.json");
+    write_named_route(
+        "MIS/SimpleGraph/i64",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
+            "QUBO",
+        ],
+        &path_file,
+    );
+
+    let output_file = std::env::temp_dir().join("pred_test_reduce_via_infer_out.json");
+    let reduce_out = pred()
+        .args([
+            "-o",
+            output_file.to_str().unwrap(),
+            "reduce",
+            problem_file.to_str().unwrap(),
+            "--via",
+            path_file.to_str().unwrap(),
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        reduce_out.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&reduce_out.stderr)
+    );
+
+    let content = std::fs::read_to_string(&output_file).unwrap();
+    let bundle: serde_json::Value = serde_json::from_str(&content).unwrap();
+    assert_eq!(bundle["source"]["type"], "MaximumIndependentSet");
+    assert_eq!(bundle["target"]["type"], "QUBO");
+
+    std::fs::remove_file(&problem_file).ok();
+    std::fs::remove_file(&path_file).ok();
+    std::fs::remove_file(&output_file).ok();
+}
+
+#[test]
+fn test_reduce_via_preserves_explicit_target_variant() {
+    let problem_file = std::env::temp_dir().join("pred_test_reduce_via_variant_in.json");
+    let create_out = pred()
+        .args([
+            "-o",
+            problem_file.to_str().unwrap(),
+            "create",
+            "MIS/SimpleGraph/i64",
+            "--graph",
+            "0-1,1-2,2-3",
+            "--weights",
+            "1,1,1,1",
+        ])
+        .output()
+        .unwrap();
+    assert!(create_out.status.success());
+
+    let path_file = std::env::temp_dir().join("pred_test_reduce_via_variant_path.json");
+    write_named_route(
+        "MIS/SimpleGraph/i64",
+        "ILP/bool",
+        &["MaximumIndependentSet", "MaximumClique", "ILP"],
+        &path_file,
+    );
+
+    let reduce_out = pred()
+        .args([
+            "reduce",
+            problem_file.to_str().unwrap(),
             "--via",
             path_file.to_str().unwrap(),
         ])
         .output()
         .unwrap();
     assert!(
-        !reduce_out.status.success(),
-        "stderr: {}",
-        String::from_utf8_lossy(&reduce_out.stderr)
-    );
-    let stderr = String::from_utf8_lossy(&reduce_out.stderr);
-    assert!(
-        stderr.contains("ILP") && stderr.contains("i32") && stderr.contains("bool"),
-        "expected variant mismatch details, got: {stderr}"
+        reduce_out.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&reduce_out.stderr)
     );
+    let bundle: serde_json::Value = serde_json::from_slice(&reduce_out.stdout).unwrap();
+    assert_eq!(bundle["target"]["variant"]["variable"], "bool");
 
     std::fs::remove_file(&problem_file).ok();
     std::fs::remove_file(&path_file).ok();
 }
 
 #[test]
-fn test_reduce_missing_to_and_via() {
+fn test_reduce_missing_via() {
     let problem_file = std::env::temp_dir().join("pred_test_reduce_missing.json");
     let create_out = pred()
         .args([
@@ -1359,7 +1833,7 @@ fn test_reduce_missing_to_and_via() {
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("--to") || stderr.contains("--via"));
+    assert!(stderr.contains("--via"));
 
     std::fs::remove_file(&problem_file).ok();
 }
@@ -1450,7 +1924,7 @@ fn test_create_multiprocessor_scheduling_rejects_zero_processors() {
         "zero processors should return a user error, got panic output: {stderr}"
     );
     assert!(
-        stderr.contains("requires --num-processors > 0"),
+        stderr.contains("num_processors must be positive"),
         "expected a validation error for zero processors, got: {stderr}"
     );
 }
@@ -1464,9 +1938,9 @@ fn test_create_x3c_alias() {
             output_file.to_str().unwrap(),
             "create",
             "X3C",
-            "--universe",
+            "--universe-size",
             "6",
-            "--sets",
+            "--subsets",
             "0,1,2;3,4,5",
         ])
         .output()
@@ -1572,12 +2046,12 @@ fn test_solve_d2cif_default_solver_uses_ilp() {
     );
     let stdout = String::from_utf8(solve_output.stdout).unwrap();
     assert!(
-        stdout.contains("\"solver\": \"ilp\""),
+        stdout.contains("\"kind\": \"ilp\""),
         "expected ILP solver output, got: {stdout}"
     );
     assert!(
-        stdout.contains("\"reduced_to\": \"ILP\""),
-        "expected auto-reduction marker, got: {stdout}"
+        stdout.contains("\"reduction_path\""),
+        "expected registered ILP pipeline metadata, got: {stdout}"
     );
 
     std::fs::remove_file(&output_file).ok();
@@ -1627,7 +2101,14 @@ fn test_inspect_rectilinear_picture_compression_lists_ilp_and_bruteforce() {
 #[test]
 fn test_create_x3c_rejects_duplicate_subset_elements() {
     let output = pred()
-        .args(["create", "X3C", "--universe", "6", "--sets", "0,0,1;3,4,5"])
+        .args([
+            "create",
+            "X3C",
+            "--universe-size",
+            "6",
+            "--subsets",
+            "0,0,1;3,4,5",
+        ])
         .output()
         .unwrap();
     assert!(
@@ -1651,7 +2132,7 @@ fn test_create_comparative_containment() {
             output_file.to_str().unwrap(),
             "create",
             "ComparativeContainment",
-            "--universe",
+            "--universe-size",
             "4",
             "--r-sets",
             "0,1,2,3;0,1",
@@ -1674,7 +2155,7 @@ fn test_create_comparative_containment() {
     let content = std::fs::read_to_string(&output_file).unwrap();
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
     assert_eq!(json["type"], "ComparativeContainment");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
     assert_eq!(json["data"]["universe_size"], 4);
     assert_eq!(
         json["data"]["r_sets"],
@@ -1696,7 +2177,7 @@ fn test_create_comparative_containment_rejects_out_of_range_elements_without_pan
         .args([
             "create",
             "ComparativeContainment",
-            "--universe",
+            "--universe-size",
             "4",
             "--r-sets",
             "0,1,4",
@@ -1720,7 +2201,7 @@ fn test_create_comparative_containment_rejects_nonpositive_weights_without_panic
         .args([
             "create",
             "ComparativeContainment",
-            "--universe",
+            "--universe-size",
             "4",
             "--r-sets",
             "0,1",
@@ -1746,9 +2227,9 @@ fn test_create_set_basis() {
             output_file.to_str().unwrap(),
             "create",
             "SetBasis",
-            "--universe",
+            "--universe-size",
             "4",
-            "--sets",
+            "--subsets",
             "0,1;1,2;0,2;0,1,2",
             "--k",
             "3",
@@ -1781,7 +2262,7 @@ fn test_create_comparative_containment_f64() {
             output_file.to_str().unwrap(),
             "create",
             "ComparativeContainment/f64",
-            "--universe",
+            "--universe-size",
             "4",
             "--r-sets",
             "0,1,2,3;0,1",
@@ -1817,7 +2298,7 @@ fn test_create_comparative_containment_one_rejects_nonunit_weights() {
         .args([
             "create",
             "ComparativeContainment/One",
-            "--universe",
+            "--universe-size",
             "4",
             "--r-sets",
             "0,1,2,3;0,1",
@@ -1837,7 +2318,7 @@ fn test_create_comparative_containment_one_rejects_nonunit_weights() {
     );
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("Non-unit weights are not supported for ComparativeContainment/One"),
+        stderr.contains("unexpected argument '--r-weights'"),
         "stderr: {stderr}"
     );
 }
@@ -1856,7 +2337,6 @@ fn test_create_comparative_containment_no_flags_shows_help() {
     assert!(stderr.contains("--universe-size"), "stderr: {stderr}");
     assert!(stderr.contains("--r-sets"), "stderr: {stderr}");
     assert!(stderr.contains("--s-sets"), "stderr: {stderr}");
-    assert!(!stderr.contains("--universe "), "stderr: {stderr}");
 }
 
 #[test]
@@ -1868,9 +2348,9 @@ fn test_create_minimum_hitting_set() {
             output_file.to_str().unwrap(),
             "create",
             "MinimumHittingSet",
-            "--universe",
+            "--universe-size",
             "6",
-            "--sets",
+            "--subsets",
             "0,1,2;0,3,4;1,3,5;2,4,5;0,1,5;2,3;1,4",
         ])
         .output()
@@ -1908,9 +2388,9 @@ fn test_create_minimum_hitting_set_rejects_out_of_range_elements_without_panicki
         .args([
             "create",
             "MinimumHittingSet",
-            "--universe",
+            "--universe-size",
             "4",
-            "--sets",
+            "--subsets",
             "0,1,4;1,2",
         ])
         .output()
@@ -1924,37 +2404,25 @@ fn test_create_minimum_hitting_set_rejects_out_of_range_elements_without_panicki
     assert!(!stderr.contains("panicked at"), "stderr: {stderr}");
 }
 
-#[test]
-fn test_create_help_lists_minimum_hitting_set_flags() {
-    let output = pred().args(["create", "--help"]).output().unwrap();
-    assert!(
-        output.status.success(),
-        "stderr: {}",
-        String::from_utf8_lossy(&output.stderr)
-    );
-    let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(
-        stdout.contains("MinimumHittingSet") && stdout.contains("--universe-size, --subsets"),
-        "stdout: {stdout}"
-    );
-}
-
 #[test]
 fn test_create_set_basis_requires_k() {
     let output = pred()
         .args([
             "create",
             "SetBasis",
-            "--universe",
+            "--universe-size",
             "4",
-            "--sets",
+            "--subsets",
             "0,1;1,2;0,2;0,1,2",
         ])
         .output()
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("SetBasis requires --k"), "stderr: {stderr}");
+    assert!(
+        stderr.contains("missing required construction input(s): k"),
+        "stderr: {stderr}"
+    );
 }
 
 #[test]
@@ -1963,9 +2431,9 @@ fn test_create_set_basis_rejects_out_of_range_elements() {
         .args([
             "create",
             "SetBasis",
-            "--universe",
+            "--universe-size",
             "4",
-            "--sets",
+            "--subsets",
             "0,4",
             "--k",
             "1",
@@ -1991,7 +2459,7 @@ fn test_create_sequencing_to_minimize_weighted_tardiness() {
             output_file.to_str().unwrap(),
             "create",
             "SequencingToMinimizeWeightedTardiness",
-            "--sizes",
+            "--lengths",
             "3,4,2,5,3",
             "--weights",
             "2,3,1,4,2",
@@ -2042,7 +2510,7 @@ fn test_create_sequencing_to_minimize_weighted_tardiness_rejects_mismatched_leng
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("lengths length (3) must equal weights length (2)"),
+        stderr.contains("weights length must equal lengths length"),
         "stderr: {stderr}"
     );
 }
@@ -2057,10 +2525,6 @@ fn test_create_minimum_cardinality_key_problem_help_uses_supported_flags() {
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(stderr.contains("--num-attributes"), "stderr: {stderr}");
     assert!(stderr.contains("--dependencies"), "stderr: {stderr}");
-    assert!(
-        stderr.contains("semicolon-separated dependencies"),
-        "stderr: {stderr}"
-    );
 }
 
 #[test]
@@ -2093,14 +2557,7 @@ fn test_create_minimum_cardinality_key_allows_empty_lhs_dependency() {
 #[test]
 fn test_create_minimum_cardinality_key_missing_num_attributes_message() {
     let output = pred()
-        .args([
-            "create",
-            "MinimumCardinalityKey",
-            "--dependencies",
-            "0>0",
-            "--bound",
-            "1",
-        ])
+        .args(["create", "MinimumCardinalityKey", "--dependencies", "0>0"])
         .output()
         .unwrap();
     assert!(!output.status.success());
@@ -2121,7 +2578,7 @@ fn test_create_two_dimensional_consecutive_sets_accepts_alphabet_size_flag() {
             "TwoDimensionalConsecutiveSets",
             "--alphabet-size",
             "6",
-            "--sets",
+            "--subsets",
             "0,1,2;3,4,5;1,3;2,4;0,5",
         ])
         .output()
@@ -2149,7 +2606,7 @@ fn test_create_two_dimensional_consecutive_sets_rejects_zero_alphabet_size_witho
             "TwoDimensionalConsecutiveSets",
             "--alphabet-size",
             "0",
-            "--sets",
+            "--subsets",
             "0",
         ])
         .output()
@@ -2171,7 +2628,7 @@ fn test_create_two_dimensional_consecutive_sets_rejects_duplicate_elements_witho
             "TwoDimensionalConsecutiveSets",
             "--alphabet-size",
             "3",
-            "--sets",
+            "--subsets",
             "0,0",
         ])
         .output()
@@ -2194,8 +2651,6 @@ fn test_create_then_evaluate() {
             "MIS",
             "--graph",
             "0-1,1-2,2-3",
-            "--weights",
-            "1,1,1,1",
         ])
         .output()
         .unwrap();
@@ -2211,7 +2666,7 @@ fn test_create_then_evaluate() {
             "evaluate",
             problem_file.to_str().unwrap(),
             "--config",
-            "1,0,1,0",
+            "[true,false,true,false]",
         ])
         .output()
         .unwrap();
@@ -2264,14 +2719,14 @@ fn test_create_multiple_choice_branching() {
             "-o",
             output_file.to_str().unwrap(),
             "create",
-            "MultipleChoiceBranching/i32",
+            "MultipleChoiceBranching/i64",
             "--arcs",
             "0>1,0>2,1>3,2>3,1>4,3>5,4>5,2>4",
             "--weights",
             "3,2,4,1,2,3,1,3",
             "--partition",
             "0,1;2,3;4,7;5,6",
-            "--bound",
+            "--threshold",
             "10",
         ])
         .output()
@@ -2286,7 +2741,7 @@ fn test_create_multiple_choice_branching() {
     let content = std::fs::read_to_string(&output_file).unwrap();
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
     assert_eq!(json["type"], "MultipleChoiceBranching");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
     assert_eq!(
         json["data"]["weights"],
         serde_json::json!([3, 2, 4, 1, 2, 3, 1, 3])
@@ -2303,7 +2758,7 @@ fn test_create_multiple_choice_branching() {
 #[test]
 fn test_create_model_example_multiple_choice_branching() {
     let output = pred()
-        .args(["create", "--example", "MultipleChoiceBranching/i32"])
+        .args(["create", "--example", "MultipleChoiceBranching/i64"])
         .output()
         .unwrap();
     assert!(
@@ -2315,7 +2770,7 @@ fn test_create_model_example_multiple_choice_branching() {
     let stdout = String::from_utf8(output.stdout).unwrap();
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "MultipleChoiceBranching");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
     assert_eq!(json["data"]["threshold"], 10);
     assert_eq!(json["data"]["partition"].as_array().unwrap().len(), 4);
 }
@@ -2333,7 +2788,7 @@ fn test_create_model_example_multiple_choice_branching_round_trips_into_solve()
         .args([
             "create",
             "--example",
-            "MultipleChoiceBranching/i32",
+            "MultipleChoiceBranching/i64",
             "-o",
             path.to_str().unwrap(),
         ])
@@ -2358,12 +2813,64 @@ fn test_create_model_example_multiple_choice_branching_round_trips_into_solve()
     std::fs::remove_file(&path).ok();
 }
 
+#[test]
+fn test_kth_largest_m_tuple_solve_uses_k_threshold() {
+    let solve = |k: u64| {
+        let create = pred()
+            .args([
+                "create",
+                "KthLargestMTuple",
+                "--subsets",
+                "2,5,8;3,6;1,4,7",
+                "--k",
+                &k.to_string(),
+                "--bound",
+                "12",
+            ])
+            .output()
+            .unwrap();
+        assert!(
+            create.status.success(),
+            "stderr: {}",
+            String::from_utf8_lossy(&create.stderr)
+        );
+
+        let path = std::env::temp_dir().join(format!(
+            "pred_test_kth_largest_m_tuple_{}_{}.json",
+            std::process::id(),
+            k
+        ));
+        std::fs::write(&path, create.stdout).unwrap();
+
+        let output = pred()
+            .args(["solve", path.to_str().unwrap(), "--solver", "brute-force"])
+            .output()
+            .unwrap();
+        std::fs::remove_file(path).unwrap();
+        assert!(
+            output.status.success(),
+            "stderr: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        serde_json::from_slice::<serde_json::Value>(&output.stdout).unwrap()
+    };
+
+    let at_threshold = solve(14);
+    let above_threshold = solve(15);
+
+    assert_eq!(at_threshold["status"], "optimal");
+    assert_eq!(at_threshold["evaluation"], "Or(true)");
+    assert_eq!(above_threshold["status"], "infeasible");
+    assert!(above_threshold.get("evaluation").is_none());
+    assert!(above_threshold.get("solution").is_none());
+}
+
 #[test]
 fn test_create_acyclic_partition() {
     let output = pred()
         .args([
             "create",
-            "AcyclicPartition/i32",
+            "AcyclicPartition/i64",
             "--arcs",
             "0>1,0>2,1>3,1>4,2>4,2>5,3>5,4>5",
             "--weights",
@@ -2386,7 +2893,7 @@ fn test_create_acyclic_partition() {
     let stdout = String::from_utf8(output.stdout).unwrap();
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "AcyclicPartition");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
     assert_eq!(
         json["data"]["vertex_weights"],
         serde_json::json!([2, 3, 2, 1, 3, 1])
@@ -2402,7 +2909,7 @@ fn test_create_acyclic_partition() {
 #[test]
 fn test_create_model_example_acyclic_partition() {
     let output = pred()
-        .args(["create", "--example", "AcyclicPartition/i32"])
+        .args(["create", "--example", "AcyclicPartition/i64"])
         .output()
         .unwrap();
     assert!(
@@ -2414,7 +2921,7 @@ fn test_create_model_example_acyclic_partition() {
     let stdout = String::from_utf8(output.stdout).unwrap();
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "AcyclicPartition");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
     assert_eq!(json["data"]["weight_bound"], 5);
     assert_eq!(json["data"]["cost_bound"], 5);
     assert_eq!(json["data"]["graph"]["num_vertices"], 6);
@@ -2433,7 +2940,7 @@ fn test_create_model_example_acyclic_partition_round_trips_into_solve() {
         .args([
             "create",
             "--example",
-            "AcyclicPartition/i32",
+            "AcyclicPartition/i64",
             "-o",
             path.to_str().unwrap(),
         ])
@@ -2470,10 +2977,8 @@ fn test_create_mixed_chinese_postman() {
             "0>1,1>2,2>3,3>0",
             "--edge-weights",
             "2,3,1,2",
-            "--arc-costs",
+            "--arc-weights",
             "2,3,1,4",
-            "--bound",
-            "24",
         ])
         .output()
         .unwrap();
@@ -2486,7 +2991,7 @@ fn test_create_mixed_chinese_postman() {
     let stdout = String::from_utf8(output.stdout).unwrap();
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "MixedChinesePostman");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
     assert_eq!(json["data"]["graph"]["num_vertices"], 5);
     assert_eq!(json["data"]["arc_weights"], serde_json::json!([2, 3, 1, 4]));
     assert_eq!(
@@ -2498,7 +3003,7 @@ fn test_create_mixed_chinese_postman() {
 #[test]
 fn test_create_model_example_mixed_chinese_postman() {
     let output = pred()
-        .args(["create", "--example", "MixedChinesePostman/i32"])
+        .args(["create", "--example", "MixedChinesePostman/i64"])
         .output()
         .unwrap();
     assert!(
@@ -2510,7 +3015,7 @@ fn test_create_model_example_mixed_chinese_postman() {
     let stdout = String::from_utf8(output.stdout).unwrap();
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "MixedChinesePostman");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
 }
 
 #[test]
@@ -2523,10 +3028,8 @@ fn test_create_mixed_chinese_postman_missing_arcs_shows_usage() {
             "0-2,1-3,0-4,4-2",
             "--edge-weights",
             "2,3,1,2",
-            "--arc-costs",
+            "--arc-weights",
             "2,3,1,4",
-            "--bound",
-            "24",
         ])
         .output()
         .unwrap();
@@ -2534,7 +3037,7 @@ fn test_create_mixed_chinese_postman_missing_arcs_shows_usage() {
 
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("MixedChinesePostman requires --arcs"),
+        stderr.contains("missing required construction input(s): arcs"),
         "expected missing --arcs error, got: {stderr}"
     );
     assert!(
@@ -2555,10 +3058,8 @@ fn test_create_mixed_chinese_postman_rejects_edge_weight_length_mismatch() {
             "0>1,1>2,2>3,3>0",
             "--edge-weights",
             "2,3",
-            "--arc-costs",
+            "--arc-weights",
             "2,3,1,4",
-            "--bound",
-            "24",
         ])
         .output()
         .unwrap();
@@ -2566,73 +3067,24 @@ fn test_create_mixed_chinese_postman_rejects_edge_weight_length_mismatch() {
 
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("Expected 4 edge weight"),
+        stderr.contains("edge_weights length must match num_edges"),
         "expected edge-weight mismatch diagnostic, got: {stderr}"
     );
 }
 
-#[test]
-fn test_create_multiple_choice_branching_rejects_negative_bound() {
-    let output = pred()
-        .args([
-            "create",
-            "MultipleChoiceBranching/i32",
-            "--arcs",
-            "0>1,0>2,1>3,2>3,1>4,3>5,4>5,2>4",
-            "--weights",
-            "3,2,4,1,2,3,1,3",
-            "--partition",
-            "0,1;2,3;4,7;5,6",
-            "--bound=-1",
-        ])
-        .output()
-        .unwrap();
-    assert!(!output.status.success());
-    let stderr = String::from_utf8(output.stderr).unwrap();
-    assert!(
-        stderr.contains("threshold") || stderr.contains("--bound"),
-        "stderr should mention the invalid threshold: {stderr}"
-    );
-}
-
-#[test]
-fn test_create_multiple_choice_branching_rejects_overflowing_bound() {
-    let output = pred()
-        .args([
-            "create",
-            "MultipleChoiceBranching/i32",
-            "--arcs",
-            "0>1,0>2,1>3,2>3,1>4,3>5,4>5,2>4",
-            "--weights",
-            "3,2,4,1,2,3,1,3",
-            "--partition",
-            "0,1;2,3;4,7;5,6",
-            "--bound",
-            "2147483648",
-        ])
-        .output()
-        .unwrap();
-    assert!(!output.status.success());
-    let stderr = String::from_utf8(output.stderr).unwrap();
-    assert!(
-        stderr.contains("threshold") || stderr.contains("--bound"),
-        "stderr should mention the overflowing threshold: {stderr}"
-    );
-}
-
 #[test]
 fn test_create_multiple_choice_branching_rejects_invalid_partition_without_panicking() {
     let output = pred()
         .args([
             "create",
-            "MultipleChoiceBranching/i32",
+            "MultipleChoiceBranching/i64",
             "--arcs",
             "0>1,0>2,1>3,2>3,1>4,3>5,4>5,2>4",
             "--weights",
             "3,2,4,1,2,3,1,3",
             "--partition",
             "0,1;2,3;4,7;5,7",
-            "--bound",
+            "--threshold",
             "10",
         ])
         .output()
@@ -2659,7 +3111,7 @@ fn test_create_qubo() {
             "create",
             "QUBO",
             "--matrix",
-            "1,0.5;0.5,2",
+            "1,-1;0,2",
         ])
         .output()
         .unwrap();
@@ -2677,6 +3129,33 @@ fn test_create_qubo() {
     std::fs::remove_file(&output_file).ok();
 }
 
+#[test]
+fn test_create_qubo_f64() {
+    let output_file = std::env::temp_dir().join("pred_test_create_qubo_f64.json");
+    let output = pred()
+        .args([
+            "-o",
+            output_file.to_str().unwrap(),
+            "create",
+            "QUBO/f64",
+            "--matrix",
+            "1,0.5;0,2",
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let content = std::fs::read_to_string(&output_file).unwrap();
+    let json: serde_json::Value = serde_json::from_str(&content).unwrap();
+    assert_eq!(json["variant"]["weight"], "f64");
+
+    std::fs::remove_file(&output_file).ok();
+}
+
 // ---- Solve command tests ----
 
 #[test]
@@ -2712,7 +3191,7 @@ fn test_solve_brute_force() {
     );
     let stdout = String::from_utf8(output.stdout).unwrap();
     // auto_json: data commands output JSON when stdout is not a TTY (as in tests)
-    assert!(stdout.contains("\"solver\": \"brute-force\""));
+    assert!(stdout.contains("\"kind\": \"brute-force\""));
     assert!(stdout.contains("\"solution\""));
 
     std::fs::remove_file(&problem_file).ok();
@@ -2744,11 +3223,11 @@ fn test_solve_ilp() {
         String::from_utf8_lossy(&output.stderr)
     );
     let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(stdout.contains("\"solver\": \"ilp\""));
+    assert!(stdout.contains("\"kind\": \"ilp\""));
     assert!(stdout.contains("\"solution\""));
     assert!(
-        stdout.contains("\"reduced_to\": \"ILP\""),
-        "MIS solved with ILP should show auto-reduction: {stdout}"
+        stdout.contains("\"reduction_path\""),
+        "MIS solved with ILP should report its registered pipeline: {stdout}"
     );
 
     std::fs::remove_file(&problem_file).ok();
@@ -2756,7 +3235,7 @@ fn test_solve_ilp() {
 
 #[test]
 fn test_solve_ilp_default() {
-    // Default solver is ilp
+    // MIS has no customized solver, so its registered ILP pipeline is the default.
     let problem_file = std::env::temp_dir().join("pred_test_solve_default.json");
     let create_out = pred()
         .args([
@@ -2783,16 +3262,15 @@ fn test_solve_ilp_default() {
     let stdout = String::from_utf8(output.stdout).unwrap();
     // auto_json: data commands output JSON when stdout is not a TTY
     assert!(
-        stdout.contains("\"solver\": \"ilp\"") && stdout.contains("\"reduced_to\": \"ILP\""),
-        "MIS with default solver should show auto-reduction: {stdout}"
+        stdout.contains("\"kind\": \"ilp\"") && stdout.contains("\"reduction_path\""),
+        "MIS with default solver should report its registered ILP pipeline: {stdout}"
     );
 
     std::fs::remove_file(&problem_file).ok();
 }
 
 #[test]
-fn test_solve_ilp_shows_via_ilp() {
-    // When solving a non-ILP problem with ILP solver, output should show "via ILP"
+fn test_solve_ilp_reports_registered_pipeline() {
     let problem_file = std::env::temp_dir().join("pred_test_solve_via_ilp.json");
     let create_out = pred()
         .args([
@@ -2819,8 +3297,8 @@ fn test_solve_ilp_shows_via_ilp() {
     let stdout = String::from_utf8(output.stdout).unwrap();
     // auto_json: data commands output JSON when stdout is not a TTY
     assert!(
-        stdout.contains("\"reduced_to\": \"ILP\""),
-        "Non-ILP problem solved with ILP should show auto-reduction indicator, got: {stdout}"
+        stdout.contains("\"reduction_path\""),
+        "Non-ILP problem solved with ILP should report its registered pipeline, got: {stdout}"
     );
     assert!(stdout.contains("\"problem\": \"MaximumIndependentSet\""));
 
@@ -2865,7 +3343,7 @@ fn test_solve_json_output() {
     let content = std::fs::read_to_string(&result_file).unwrap();
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
     assert!(json["solution"].is_array());
-    assert_eq!(json["solver"], "brute-force");
+    assert_eq!(json["solver"]["kind"], "brute-force");
 
     std::fs::remove_file(&problem_file).ok();
     std::fs::remove_file(&result_file).ok();
@@ -2890,17 +3368,19 @@ fn test_solve_bundle() {
         .unwrap();
     assert!(create_out.status.success());
 
-    let reduce_out = pred()
-        .args([
-            "-o",
-            bundle_file.to_str().unwrap(),
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    let reduce_out = reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-        ])
-        .output()
-        .unwrap();
+        ],
+        &bundle_file,
+    );
     assert!(
         reduce_out.status.success(),
         "reduce stderr: {}",
@@ -2931,37 +3411,115 @@ fn test_solve_bundle() {
     std::fs::remove_file(&bundle_file).ok();
 }
 
-#[test]
-fn test_solve_bundle_ilp() {
-    // Create → Reduce → Solve bundle with ILP
-    // Use MVC as target since it has an ILP reduction path (QUBO does not)
-    let problem_file = std::env::temp_dir().join("pred_test_solve_bundle_ilp_in.json");
-    let bundle_file = std::env::temp_dir().join("pred_test_solve_bundle_ilp.json");
+fn solve_sat_to_nae_bundle(case: &str, clauses: &str) -> serde_json::Value {
+    let temp_dir = std::env::temp_dir();
+    let process_id = std::process::id();
+    let problem_file = temp_dir.join(format!("pred_test_{case}_{process_id}_sat.json"));
+    let bundle_file = temp_dir.join(format!("pred_test_{case}_{process_id}_sat_nae_bundle.json"));
 
-    let create_out = pred()
+    let create = pred()
         .args([
             "-o",
             problem_file.to_str().unwrap(),
             "create",
-            "MIS",
-            "--graph",
-            "0-1,1-2",
+            "Satisfiability",
+            "--num-vars",
+            "1",
+            "--clauses",
+            clauses,
         ])
         .output()
         .unwrap();
-    assert!(create_out.status.success());
+    assert!(
+        create.status.success(),
+        "create stderr: {}",
+        String::from_utf8_lossy(&create.stderr)
+    );
 
-    let reduce_out = pred()
+    let reduce = reduce_named_to_file(
+        &problem_file,
+        "Satisfiability",
+        "NAESatisfiability",
+        &["Satisfiability", "NAESatisfiability"],
+        &bundle_file,
+    );
+    assert!(
+        reduce.status.success(),
+        "reduce stderr: {}",
+        String::from_utf8_lossy(&reduce.stderr)
+    );
+
+    let solve = pred()
         .args([
-            "-o",
+            "solve",
             bundle_file.to_str().unwrap(),
-            "reduce",
+            "--solver",
+            "brute-force",
+            "--json",
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        solve.status.success(),
+        "solve stderr: {}",
+        String::from_utf8_lossy(&solve.stderr)
+    );
+
+    std::fs::remove_file(problem_file).unwrap();
+    std::fs::remove_file(bundle_file).unwrap();
+    serde_json::from_slice(&solve.stdout).unwrap()
+}
+
+#[test]
+fn test_solve_bundle_distinguishes_infeasibility_from_missing_witness_capability() {
+    let infeasible = solve_sat_to_nae_bundle("infeasible", "1;-1");
+    assert_eq!(infeasible["status"], "infeasible");
+    assert!(infeasible.get("evaluation").is_none());
+    assert!(infeasible.get("solution").is_none());
+    assert_eq!(infeasible["intermediate"]["status"], "infeasible");
+    assert!(infeasible["intermediate"].get("evaluation").is_none());
+    assert!(infeasible["intermediate"].get("solution").is_none());
+
+    let feasible = solve_sat_to_nae_bundle("feasible", "1");
+    assert_eq!(feasible["status"], "optimal");
+    assert_eq!(feasible["evaluation"], "Or(true)");
+    assert!(feasible["solution"].is_array());
+    assert_eq!(feasible["intermediate"]["status"], "optimal");
+    assert_eq!(feasible["intermediate"]["evaluation"], "Or(true)");
+    assert!(feasible["intermediate"]["solution"].is_array());
+}
+
+#[test]
+fn test_solve_bundle_ilp() {
+    // Create → Reduce → Solve bundle with ILP
+    // Use MVC as the bundle target to exercise its registered fixed ILP pipeline.
+    let problem_file = std::env::temp_dir().join("pred_test_solve_bundle_ilp_in.json");
+    let bundle_file = std::env::temp_dir().join("pred_test_solve_bundle_ilp.json");
+
+    let create_out = pred()
+        .args([
+            "-o",
             problem_file.to_str().unwrap(),
-            "--to",
-            "MVC",
+            "create",
+            "MIS",
+            "--graph",
+            "0-1,1-2",
         ])
         .output()
         .unwrap();
+    assert!(create_out.status.success());
+
+    let reduce_out = reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "MVC/SimpleGraph/i64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MinimumVertexCover",
+        ],
+        &bundle_file,
+    );
     assert!(
         reduce_out.status.success(),
         "reduce stderr: {}",
@@ -2987,8 +3545,8 @@ fn test_solve_bundle_ilp() {
 }
 
 #[test]
-fn test_solve_direct_ilp_i32_problem() {
-    let problem_file = std::env::temp_dir().join("pred_test_solve_ilp_i32_problem.json");
+fn test_solve_direct_ilp_i64_problem() {
+    let problem_file = std::env::temp_dir().join("pred_test_solve_ilp_i64_problem.json");
 
     let create_out = pred()
         .args([
@@ -2998,7 +3556,7 @@ fn test_solve_direct_ilp_i32_problem() {
             "--example",
             "SequencingToMinimizeWeightedCompletionTime",
             "--to",
-            "ILP/i32",
+            "ILP/variable=i64",
             "--example-side",
             "target",
         ])
@@ -3021,13 +3579,13 @@ fn test_solve_direct_ilp_i32_problem() {
     );
     let stdout = String::from_utf8(output.stdout).unwrap();
     assert!(stdout.contains("\"problem\": \"ILP\""), "{stdout}");
-    assert!(stdout.contains("\"solver\": \"ilp\""), "{stdout}");
+    assert!(stdout.contains("\"kind\": \"ilp\""), "{stdout}");
 
     std::fs::remove_file(&problem_file).ok();
 }
 
 #[test]
-fn test_solve_sequencing_to_minimize_weighted_completion_time_default_solver() {
+fn test_solve_partial_ilp_route_defaults_to_brute_force() {
     let problem_file = std::env::temp_dir()
         .join("pred_test_solve_sequencing_to_minimize_weighted_completion_time.json");
 
@@ -3041,7 +3599,7 @@ fn test_solve_sequencing_to_minimize_weighted_completion_time_default_solver() {
             "2,1,3,1,2",
             "--weights",
             "3,5,1,4,2",
-            "--precedence-pairs",
+            "--precedences",
             "0>2,1>4",
         ])
         .output()
@@ -3066,7 +3624,7 @@ fn test_solve_sequencing_to_minimize_weighted_completion_time_default_solver() {
         stdout.contains("\"problem\": \"SequencingToMinimizeWeightedCompletionTime\""),
         "{stdout}"
     );
-    assert!(stdout.contains("\"solver\": \"ilp\""), "{stdout}");
+    assert!(stdout.contains("\"kind\": \"brute-force\""), "{stdout}");
     assert!(stdout.contains("\"solution\": ["), "{stdout}");
 
     std::fs::remove_file(&problem_file).ok();
@@ -3105,7 +3663,7 @@ fn test_solve_unknown_solver() {
 }
 
 #[test]
-fn test_solve_help_mentions_bruteforce_only_models() {
+fn test_solve_help_describes_deterministic_dispatch_and_overrides() {
     let output = pred().args(["solve", "--help"]).output().unwrap();
     assert!(
         output.status.success(),
@@ -3113,7 +3671,11 @@ fn test_solve_help_mentions_bruteforce_only_models() {
         String::from_utf8_lossy(&output.stderr)
     );
     let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(stdout.contains("MinMaxMulticenter"), "stdout: {stdout}");
+    assert!(
+        stdout.contains("deterministically selects"),
+        "stdout: {stdout}"
+    );
+    assert!(stdout.contains("never searches"), "stdout: {stdout}");
     assert!(stdout.contains("--solver brute-force"), "stdout: {stdout}");
 }
 
@@ -3211,7 +3773,7 @@ fn test_create_bounded_component_spanning_forest() {
             "2,3,1,2,3,1,2,1",
             "--k",
             "3",
-            "--bound",
+            "--max-weight",
             "6",
         ])
         .output()
@@ -3241,14 +3803,14 @@ fn test_create_bounded_component_spanning_forest_rejects_zero_k() {
             "1,1,1,1",
             "--k",
             "0",
-            "--bound",
+            "--max-weight",
             "2",
         ])
         .output()
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("--k >= 1"), "stderr: {stderr}");
+    assert!(stderr.contains("k must be at least 1"), "stderr: {stderr}");
 }
 
 #[test]
@@ -3264,7 +3826,7 @@ fn test_create_bounded_component_spanning_forest_accepts_k_larger_than_num_verti
             "1,1,1,1",
             "--k",
             "5",
-            "--bound",
+            "--max-weight",
             "2",
             "-o",
         ])
@@ -3292,14 +3854,17 @@ fn test_create_bounded_component_spanning_forest_rejects_negative_weights() {
             "1,-1,1,1",
             "--k",
             "2",
-            "--bound",
+            "--max-weight",
             "2",
         ])
         .output()
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("nonnegative --weights"), "stderr: {stderr}");
+    assert!(
+        stderr.contains("weights must be nonnegative"),
+        "stderr: {stderr}"
+    );
 }
 
 #[test]
@@ -3321,29 +3886,10 @@ fn test_create_bounded_component_spanning_forest_rejects_negative_bound() {
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("positive --max-weight"), "stderr: {stderr}");
-}
-
-#[test]
-fn test_create_bounded_component_spanning_forest_rejects_out_of_range_bound() {
-    let output = pred()
-        .args([
-            "create",
-            "BoundedComponentSpanningForest",
-            "--graph",
-            "0-1,1-2,2-3",
-            "--weights",
-            "1,1,1,1",
-            "--k",
-            "2",
-            "--bound",
-            "3000000000",
-        ])
-        .output()
-        .unwrap();
-    assert!(!output.status.success());
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("within i32 range"), "stderr: {stderr}");
+    assert!(
+        stderr.contains("max_weight must be positive"),
+        "stderr: {stderr}"
+    );
 }
 
 #[test]
@@ -3490,7 +4036,7 @@ fn test_create_string_to_string_correction_rejects_negative_bound() {
         "negative bound should be rejected"
     );
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("nonnegative --bound"), "stderr: {stderr}");
+    assert!(stderr.contains("invalid value '-1'"), "stderr: {stderr}");
 }
 
 #[test]
@@ -3594,8 +4140,6 @@ fn test_create_3sat() {
             "3",
             "--clauses",
             "1,2,3;-1,2,-3",
-            "--k",
-            "3",
         ])
         .output()
         .unwrap();
@@ -3662,7 +4206,7 @@ fn test_create_steiner_tree() {
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
     assert_eq!(json["type"], "SteinerTree");
     assert_eq!(json["variant"]["graph"], "SimpleGraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
     assert_eq!(json["data"]["terminals"], serde_json::json!([0, 2, 4]));
     std::fs::remove_file(&output_file).ok();
 }
@@ -3701,7 +4245,7 @@ fn test_create_sequencing_to_minimize_weighted_completion_time() {
             "2,1,3,1,2",
             "--weights",
             "3,5,1,4,2",
-            "--precedence-pairs",
+            "--precedences",
             "0>2,1>4",
         ])
         .output()
@@ -3723,18 +4267,6 @@ fn test_create_sequencing_to_minimize_weighted_completion_time() {
     std::fs::remove_file(&output_file).ok();
 }
 
-#[test]
-fn test_create_help_describes_precedence_pairs_generically() {
-    let output = pred().args(["create", "--help"]).output().unwrap();
-    assert!(
-        output.status.success(),
-        "stderr: {}",
-        String::from_utf8_lossy(&output.stderr)
-    );
-    let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(stdout.contains("Precedence pairs for MinimumTardinessSequencing, SchedulingWithIndividualDeadlines, or SequencingToMinimizeWeightedCompletionTime"));
-}
-
 #[test]
 fn test_create_with_edge_weights() {
     let output_file = std::env::temp_dir().join("pred_test_create_ew.json");
@@ -3783,9 +4315,9 @@ fn test_create_from_example_source() {
         .args([
             "create",
             "--example",
-            "MVC/SimpleGraph/i32",
+            "MVC/SimpleGraph/i64",
             "--to",
-            "MIS/SimpleGraph/i32",
+            "MIS/SimpleGraph/i64",
         ])
         .output()
         .unwrap();
@@ -3806,9 +4338,9 @@ fn test_create_from_example_target() {
         .args([
             "create",
             "--example",
-            "MVC/SimpleGraph/i32",
+            "MVC/SimpleGraph/i64",
             "--to",
-            "MIS/SimpleGraph/i32",
+            "MIS/SimpleGraph/i64",
             "--example-side",
             "target",
         ])
@@ -3850,7 +4382,7 @@ fn test_create_unknown_example_problem() {
 #[test]
 fn test_create_model_example_mis() {
     let output = pred()
-        .args(["create", "--example", "MIS/SimpleGraph/i32"])
+        .args(["create", "--example", "MIS/SimpleGraph/i64"])
         .output()
         .unwrap();
     assert!(
@@ -3862,7 +4394,7 @@ fn test_create_model_example_mis() {
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "MaximumIndependentSet");
     assert_eq!(json["variant"]["graph"], "SimpleGraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
 }
 
 #[test]
@@ -3886,7 +4418,7 @@ fn test_create_model_example_mis_shorthand() {
 #[test]
 fn test_create_model_example_mis_weight_only() {
     let output = pred()
-        .args(["create", "--example", "MIS/i32"])
+        .args(["create", "--example", "MIS/i64"])
         .output()
         .unwrap();
     assert!(
@@ -3898,7 +4430,7 @@ fn test_create_model_example_mis_weight_only() {
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "MaximumIndependentSet");
     assert_eq!(json["variant"]["graph"], "SimpleGraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
 }
 
 #[test]
@@ -3916,7 +4448,7 @@ fn test_create_model_example_steiner_tree() {
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "SteinerTree");
     assert_eq!(json["variant"]["graph"], "SimpleGraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
 }
 
 #[test]
@@ -3948,12 +4480,8 @@ fn test_create_no_flags_shows_help() {
         "expected '--graph' in help output, got: {stderr}"
     );
     assert!(
-        stderr.contains("--weights"),
-        "expected '--weights' in help output, got: {stderr}"
-    );
-    assert!(
-        stderr.contains("Example:"),
-        "expected 'Example:' in help output, got: {stderr}"
+        !stderr.contains("--weights"),
+        "unit weights should not appear in help output, got: {stderr}"
     );
 }
 
@@ -3975,7 +4503,7 @@ fn test_create_sequencing_to_minimize_weighted_tardiness_no_flags_shows_help() {
 #[test]
 fn test_create_multiple_choice_branching_help_uses_threshold_flag() {
     let output = pred()
-        .args(["create", "MultipleChoiceBranching/i32"])
+        .args(["create", "MultipleChoiceBranching/i64"])
         .output()
         .unwrap();
     assert!(!output.status.success());
@@ -3988,10 +4516,6 @@ fn test_create_multiple_choice_branching_help_uses_threshold_flag() {
         !stderr.contains("--bound"),
         "help output should not advertise '--bound', got: {stderr}"
     );
-    assert!(
-        stderr.contains("semicolon-separated groups"),
-        "expected '--partition' help to describe groups, got: {stderr}"
-    );
 }
 
 #[test]
@@ -4092,29 +4616,6 @@ fn test_create_register_sufficiency() {
     std::fs::remove_file(&output_file).ok();
 }
 
-#[test]
-fn test_create_help_uses_generic_matrix_and_k_descriptions() {
-    let output = pred().args(["create", "--help"]).output().unwrap();
-    assert!(output.status.success());
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    assert!(
-        stdout.contains("Matrix input"),
-        "expected generic matrix help, got: {stdout}"
-    );
-    assert!(
-        stdout.contains("Shared integer parameter"),
-        "expected generic k help, got: {stdout}"
-    );
-    assert!(
-        !stdout.contains("Matrix for QUBO"),
-        "create --help should not imply --matrix is QUBO-only, got: {stdout}"
-    );
-    assert!(
-        !stdout.contains("Number of colors for KColoring"),
-        "create --help should not imply --k is KColoring-only, got: {stdout}"
-    );
-}
-
 #[test]
 fn test_create_length_bounded_disjoint_paths_help_uses_max_length_flag() {
     let output = pred()
@@ -4149,10 +4650,6 @@ fn test_create_consecutive_ones_submatrix_no_flags_uses_actual_cli_help() {
         stderr.contains("--bound"),
         "expected '--bound' in help output, got: {stderr}"
     );
-    assert!(
-        stderr.contains("semicolon-separated 0/1 rows: \"1,0;0,1\""),
-        "expected bool matrix format hint in help output, got: {stderr}"
-    );
 }
 
 #[test]
@@ -4164,8 +4661,8 @@ fn test_create_prime_attribute_name_no_flags_uses_actual_cli_flag_names() {
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("--universe"),
-        "expected '--universe' in help output, got: {stderr}"
+        stderr.contains("--universe-size"),
+        "expected '--universe-size' in help output, got: {stderr}"
     );
     assert!(
         stderr.contains("--dependencies"),
@@ -4210,6 +4707,27 @@ fn test_create_lcs_with_raw_strings_infers_alphabet() {
     );
 }
 
+#[test]
+fn test_create_shortest_common_supersequence_derives_internal_fields() {
+    let output = pred()
+        .args([
+            "create",
+            "ShortestCommonSupersequence",
+            "--strings",
+            "0,1,2;1,2,0",
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    assert_eq!(json["data"]["alphabet_size"], 3);
+    assert_eq!(json["data"]["max_length"], 6);
+}
+
 #[test]
 fn test_create_lcs_rejects_empty_strings_without_panicking() {
     let output = pred()
@@ -4219,7 +4737,7 @@ fn test_create_lcs_rejects_empty_strings_without_panicking() {
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("at least one non-empty string"),
+        stderr.contains("at least one input string must be non-empty"),
         "expected user-facing validation error, got: {stderr}"
     );
     assert!(
@@ -4265,7 +4783,7 @@ fn test_create_minmaxmulticenter_success() {
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "MinMaxMulticenter");
     assert_eq!(json["variant"]["graph"], "SimpleGraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
     assert_eq!(json["data"]["k"], 2);
     assert_eq!(
         json["data"]["vertex_weights"],
@@ -4361,11 +4879,8 @@ fn test_solve_minmaxmulticenter_default_solver_uses_ilp() {
         String::from_utf8_lossy(&solve_out.stderr)
     );
     let stdout = String::from_utf8(solve_out.stdout).unwrap();
-    assert!(stdout.contains("\"solver\": \"ilp\""), "stdout: {stdout}");
-    assert!(
-        stdout.contains("\"reduced_to\": \"ILP\""),
-        "stdout: {stdout}"
-    );
+    assert!(stdout.contains("\"kind\": \"ilp\""), "stdout: {stdout}");
+    assert!(stdout.contains("\"reduction_path\""), "stdout: {stdout}");
 
     std::fs::remove_file(&problem_file).ok();
 }
@@ -4478,7 +4993,7 @@ fn test_create_length_bounded_disjoint_paths_rejects_equal_terminals() {
             "0",
             "--sink",
             "0",
-            "--bound",
+            "--max-length",
             "1",
         ])
         .output()
@@ -4486,7 +5001,7 @@ fn test_create_length_bounded_disjoint_paths_rejects_equal_terminals() {
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("--source and --sink must be distinct"),
+        stderr.contains("source and sink must be distinct"),
         "expected user-facing validation error, got: {stderr}"
     );
     assert!(
@@ -4507,7 +5022,7 @@ fn test_create_length_bounded_disjoint_paths_succeeds() {
             "0",
             "--sink",
             "3",
-            "--bound",
+            "--max-length",
             "2",
         ])
         .output()
@@ -4527,6 +5042,60 @@ fn test_create_length_bounded_disjoint_paths_succeeds() {
     assert_eq!(json["data"]["max_length"], 2);
 }
 
+#[test]
+fn test_solve_length_bounded_disjoint_paths_with_chord() {
+    use std::io::Write;
+    use std::process::Stdio;
+
+    let created = pred()
+        .args([
+            "create",
+            "LengthBoundedDisjointPaths",
+            "--graph",
+            "0-1,1-2,0-2",
+            "--source",
+            "0",
+            "--sink",
+            "2",
+            "--max-length",
+            "2",
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        created.status.success(),
+        "{}",
+        String::from_utf8_lossy(&created.stderr)
+    );
+    let mut child = pred()
+        .args(["solve", "-", "--json", "--quiet"])
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    child
+        .stdin
+        .take()
+        .unwrap()
+        .write_all(&created.stdout)
+        .unwrap();
+    let solved = child.wait_with_output().unwrap();
+    assert!(
+        solved.status.success(),
+        "{}",
+        String::from_utf8_lossy(&solved.stderr)
+    );
+    let json: serde_json::Value = serde_json::from_slice(&solved.stdout).unwrap();
+    assert_eq!(json["status"], "optimal");
+    assert_eq!(json["solver"]["kind"], "ilp");
+    assert_eq!(json["evaluation"], "Max(2)");
+    let paths = json["solution"].as_array().unwrap();
+    assert_eq!(paths.len(), 2);
+    assert!(paths.contains(&serde_json::json!([true, true, false])));
+    assert!(paths.contains(&serde_json::json!([false, false, true])));
+}
+
 #[test]
 fn test_create_length_bounded_disjoint_paths_rejects_negative_bound_value() {
     let output = pred()
@@ -4546,11 +5115,7 @@ fn test_create_length_bounded_disjoint_paths_rejects_negative_bound_value() {
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(
-        stderr
-            .contains("--max-length must be a nonnegative integer for LengthBoundedDisjointPaths"),
-        "expected user-facing negative-bound error, got: {stderr}"
-    );
+    assert!(stderr.contains("invalid value '-1'"), "stderr: {stderr}");
 }
 
 #[test]
@@ -4570,11 +5135,7 @@ fn test_create_random_length_bounded_disjoint_paths_rejects_negative_bound_value
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(
-        stderr
-            .contains("--max-length must be a nonnegative integer for LengthBoundedDisjointPaths"),
-        "expected shared negative-bound validation, got: {stderr}"
-    );
+    assert!(stderr.contains("invalid value '-1'"), "stderr: {stderr}");
 }
 
 #[test]
@@ -4688,7 +5249,7 @@ fn test_evaluate_wrong_config_length() {
             "evaluate",
             problem_file.to_str().unwrap(),
             "--config",
-            "1,0",
+            "[true,false]",
         ])
         .output()
         .unwrap();
@@ -4723,7 +5284,7 @@ fn test_evaluate_json_output() {
             "evaluate",
             problem_file.to_str().unwrap(),
             "--config",
-            "1,0,1",
+            "[true,false,true]",
         ])
         .output()
         .unwrap();
@@ -4778,87 +5339,93 @@ fn test_path_unknown_target() {
 }
 
 #[test]
-fn test_path_with_cost_minimize_field() {
+fn test_path_rejects_removed_cost_selection() {
     let output = pred()
         .args(["path", "MIS", "QUBO", "--cost", "minimize:num_variables"])
         .output()
         .unwrap();
-    assert!(
-        output.status.success(),
-        "stderr: {}",
-        String::from_utf8_lossy(&output.stderr)
-    );
-    let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(stdout.contains("Path"));
+    assert!(!output.status.success());
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(stderr.contains("unexpected argument '--cost'"));
 }
 
 #[test]
-fn test_path_unknown_cost() {
+fn test_path_rejects_removed_unfiltered_option() {
     let output = pred()
-        .args(["path", "MIS", "QUBO", "--cost", "bad-cost"])
+        .args(["path", "MIS", "QUBO", "--unfiltered"])
         .output()
         .unwrap();
     assert!(!output.status.success());
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("Unknown cost function"));
+    assert!(String::from_utf8_lossy(&output.stderr).contains("unexpected argument '--unfiltered'"));
 }
 
 #[test]
-fn test_path_overall_overhead_text() {
-    // Use a multi-step path so the "Overall" section appears
+fn test_path_overall_exact_map_text() {
     let output = pred().args(["path", "KSAT/K3", "MIS"]).output().unwrap();
     assert!(output.status.success());
     let stdout = String::from_utf8(output.stdout).unwrap();
     assert!(
         stdout.contains("Overall"),
-        "multi-step path should show Overall overhead"
+        "multi-step path should show Overall exact-map accounting"
     );
 }
 
 #[test]
-fn test_path_overall_overhead_json() {
-    let tmp = std::env::temp_dir().join("pred_test_path_overall.json");
+fn test_path_overall_exact_map_json() {
     let output = pred()
-        .args(["path", "KSAT/K3", "MIS", "-o", tmp.to_str().unwrap()])
+        .args([
+            "path",
+            "MIS/SimpleGraph/i64",
+            "MaximumClique/SimpleGraph/i64",
+            "--json",
+        ])
         .output()
         .unwrap();
     assert!(output.status.success());
-    let content = std::fs::read_to_string(&tmp).unwrap();
-    let json: serde_json::Value = serde_json::from_str(&content).unwrap();
+    let envelope: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    let json = &envelope["paths"][0];
     assert!(
-        json["overall_overhead"].is_array(),
-        "JSON should contain overall_overhead"
+        json["overall_parameters"]["fields"].is_array(),
+        "JSON should contain an overall exact parameter relation"
     );
-    let items = json["overall_overhead"].as_array().unwrap();
-    assert!(!items.is_empty(), "overall_overhead should have entries");
+    let items = json["overall_parameters"]["fields"].as_array().unwrap();
+    assert!(!items.is_empty(), "overall exact map should have entries");
     assert!(items[0]["field"].is_string());
     assert!(items[0]["formula"].is_string());
-    std::fs::remove_file(&tmp).ok();
 }
 
 #[test]
-fn test_path_overall_overhead_composition() {
-    // Verify that overall overhead is the symbolic composition of per-step overheads,
-    // not just the last step's overhead. For a multi-step path A→B→C, the overall
-    // should substitute B's output expressions into C's input expressions.
-    let tmp = std::env::temp_dir().join("pred_test_path_composition.json");
-    // 3SAT → SAT → MIS gives a 2-step path where:
-    //   Step 1 (3SAT→SAT): num_literals = num_literals (identity)
-    //   Step 2 (SAT→MIS): num_vertices = num_literals, num_edges = num_literals^2
-    //   Overall: num_vertices = num_literals, num_edges = num_literals^2
+fn test_path_overall_upper_bound_map_composition() {
     let output = pred()
-        .args(["path", "KSAT/K3", "MIS", "-o", tmp.to_str().unwrap()])
+        .args([
+            "path",
+            "MIS/SimpleGraph/One",
+            "MaximumClique/SimpleGraph/i64",
+            "--json",
+        ])
         .output()
         .unwrap();
     assert!(output.status.success());
-    let content = std::fs::read_to_string(&tmp).unwrap();
-    let json: serde_json::Value = serde_json::from_str(&content).unwrap();
+    let envelope: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    let json = envelope["paths"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|path| {
+            path["steps"].as_u64().is_some_and(|steps| steps >= 2)
+                && path["overall_parameters"]["fields"]
+                    .as_array()
+                    .and_then(|fields| fields.iter().find(|field| field["field"] == "num_edges"))
+                    .and_then(|field| field["formula"].as_str())
+                    .is_some_and(|formula| {
+                        formula.contains("num_vertices") && !formula.contains("num_edges")
+                    })
+        })
+        .expect("multi-step route with a composed edge bound");
 
-    // Must have at least 2 steps (K3→KN variant cast adds an extra step)
     assert!(json["steps"].as_u64().unwrap() >= 2);
 
-    // Collect overall overhead into a map
-    let overall: std::collections::HashMap<String, String> = json["overall_overhead"]
+    let overall: std::collections::HashMap<String, String> = json["overall_parameters"]["fields"]
         .as_array()
         .unwrap()
         .iter()
@@ -4870,8 +5437,6 @@ fn test_path_overall_overhead_composition() {
         })
         .collect();
 
-    // The composed overhead should reference source (3SAT) variables, not intermediate ones.
-    // num_vertices and num_edges should both be expressed in terms of num_literals.
     assert!(
         overall.contains_key("num_vertices"),
         "overall should have num_vertices"
@@ -4881,24 +5446,22 @@ fn test_path_overall_overhead_composition() {
         "overall should have num_edges"
     );
     assert!(
-        overall["num_vertices"].contains("num_literals"),
+        overall["num_vertices"].contains("num_vertices"),
         "num_vertices should be in terms of source vars, got: {}",
         overall["num_vertices"]
     );
     assert!(
-        overall["num_edges"].contains("num_literals"),
-        "num_edges should be in terms of source vars, got: {}",
+        overall["num_edges"].contains("num_vertices")
+            && !overall["num_edges"].contains("num_edges"),
+        "composed edge bound should be in terms of source vertices, got: {}",
         overall["num_edges"]
     );
-
-    std::fs::remove_file(&tmp).ok();
 }
 
 #[test]
-fn test_path_all_overall_overhead() {
-    // Every path in --all --json output should have overall_overhead
+fn test_path_set_has_explicit_parameter_information() {
     let output = pred()
-        .args(["path", "KSAT/K3", "MIS", "--all", "--json"])
+        .args(["path", "KSAT/K3", "MIS", "--json"])
         .output()
         .unwrap();
     assert!(output.status.success());
@@ -4910,23 +5473,91 @@ fn test_path_all_overall_overhead() {
     assert!(!paths.is_empty());
     for (i, p) in paths.iter().enumerate() {
         assert!(
-            p["overall_overhead"].is_array(),
-            "path {} missing overall_overhead",
-            i + 1
-        );
-        let items = p["overall_overhead"].as_array().unwrap();
-        assert!(
-            !items.is_empty(),
-            "path {} has empty overall_overhead",
+            p["overall_parameters"]["fields"].is_array(),
+            "path {} has no explicit size result",
             i + 1
         );
     }
     // Verify envelope metadata
-    assert!(envelope["returned"].is_number());
-    assert!(envelope["max_paths"].is_number());
+    assert!(envelope.get("returned").is_none());
+    assert!(envelope.get("max_paths").is_none());
+    assert!(envelope.get("analysis").is_none());
     assert!(envelope["truncated"].is_boolean());
 }
 
+#[test]
+fn test_path_overall_unavailable_is_reported_per_field_without_internal_modes() {
+    let output = pred()
+        .args(["path", "Factoring", "SpinGlass", "--json"])
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    let envelope: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    let overall = &envelope["paths"][0]["overall_parameters"];
+    let fields = overall["fields"].as_array().unwrap();
+    assert!(!fields.is_empty());
+    assert!(fields.iter().all(|field| {
+        field["relation"] == "unavailable"
+            && field["field"].is_string()
+            && field["reason"].is_string()
+    }));
+    assert!(overall.get("exact_composition_error").is_none());
+    assert!(overall.get("bound_composition_error").is_none());
+}
+
+#[test]
+fn test_path_overall_preserves_unavailable_fields_alongside_exact_fields() {
+    let output = pred()
+        .args([
+            "path",
+            "HighlyConnectedDeletion",
+            "ILP/bool",
+            "--limit",
+            "1",
+            "--json",
+        ])
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    let envelope: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    let fields = envelope["paths"][0]["overall_parameters"]["fields"]
+        .as_array()
+        .unwrap();
+    let relations = fields
+        .iter()
+        .map(|field| {
+            (
+                field["field"].as_str().unwrap(),
+                field["relation"].as_str().unwrap(),
+            )
+        })
+        .collect::<std::collections::BTreeMap<_, _>>();
+    assert_eq!(relations["num_constraints"], "exact");
+    assert_eq!(relations["num_vars"], "unavailable");
+}
+
+#[test]
+fn test_path_overall_unavailable_reason_explains_unsupported_bound() {
+    let output = pred()
+        .args(["path", "HighlyConnectedDeletion", "ILP/bool", "--json"])
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    let envelope: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    let fields = envelope["paths"][0]["overall_parameters"]["fields"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|field| (field["field"].as_str().unwrap(), field))
+        .collect::<std::collections::BTreeMap<_, _>>();
+
+    assert_eq!(fields["num_vars"]["relation"], "unavailable");
+    assert!(fields["num_vars"]["reason"]
+        .as_str()
+        .unwrap()
+        .contains("variable exponent unsupported"));
+}
+
 #[test]
 fn test_path_single_step_no_overall_text() {
     // Single-step path should NOT show the Overall section
@@ -4962,16 +5593,17 @@ fn test_show_json_output() {
 }
 
 #[test]
-fn test_show_size_fields() {
+fn test_show_parameters() {
     let output = pred().args(["show", "MIS"]).output().unwrap();
     assert!(output.status.success());
     let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(stdout.contains("Size fields"));
+    assert!(stdout.contains("Parameters"));
 }
 
 #[test]
-fn test_reduce_unknown_target() {
-    let problem_file = std::env::temp_dir().join("pred_test_reduce_unknown.json");
+fn test_reduce_stdout() {
+    // Reduce without -o prints to stdout
+    let problem_file = std::env::temp_dir().join("pred_test_reduce_stdout.json");
     let create_out = pred()
         .args([
             "-o",
@@ -4979,30 +5611,53 @@ fn test_reduce_unknown_target() {
             "create",
             "MIS",
             "--graph",
-            "0-1",
+            "0-1,1-2",
         ])
         .output()
         .unwrap();
     assert!(create_out.status.success());
+    let route_file = std::env::temp_dir().join("pred_test_reduce_stdout_route.json");
+    write_named_route(
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
+            "QUBO",
+        ],
+        &route_file,
+    );
 
     let output = pred()
         .args([
             "reduce",
             problem_file.to_str().unwrap(),
-            "--to",
-            "NonExistent",
+            "--via",
+            route_file.to_str().unwrap(),
+            "--json",
         ])
         .output()
         .unwrap();
-    assert!(!output.status.success());
+    assert!(
+        output.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
+    assert!(json["source"].is_object());
+    assert!(json["target"].is_object());
 
     std::fs::remove_file(&problem_file).ok();
+    std::fs::remove_file(&route_file).ok();
 }
 
 #[test]
-fn test_reduce_stdout() {
-    // Reduce without -o prints to stdout
-    let problem_file = std::env::temp_dir().join("pred_test_reduce_stdout.json");
+fn test_reduce_auto_json_output() {
+    // auto_json: reduce outputs JSON when stdout is not a TTY (as in tests)
+    let problem_file = std::env::temp_dir().join("pred_test_reduce_human.json");
     let create_out = pred()
         .args([
             "-o",
@@ -5015,51 +5670,29 @@ fn test_reduce_stdout() {
         .output()
         .unwrap();
     assert!(create_out.status.success());
-
-    let output = pred()
-        .args([
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    let route_file = std::env::temp_dir().join("pred_test_reduce_human_route.json");
+    write_named_route(
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-            "--json",
-        ])
-        .output()
-        .unwrap();
-    assert!(
-        output.status.success(),
-        "stderr: {}",
-        String::from_utf8_lossy(&output.stderr)
+        ],
+        &route_file,
     );
-    let stdout = String::from_utf8(output.stdout).unwrap();
-    let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
-    assert!(json["source"].is_object());
-    assert!(json["target"].is_object());
 
-    std::fs::remove_file(&problem_file).ok();
-}
-
-#[test]
-fn test_reduce_auto_json_output() {
-    // auto_json: reduce outputs JSON when stdout is not a TTY (as in tests)
-    let problem_file = std::env::temp_dir().join("pred_test_reduce_human.json");
-    let create_out = pred()
+    let output = pred()
         .args([
-            "-o",
+            "reduce",
             problem_file.to_str().unwrap(),
-            "create",
-            "MIS",
-            "--graph",
-            "0-1,1-2",
+            "--via",
+            route_file.to_str().unwrap(),
         ])
         .output()
         .unwrap();
-    assert!(create_out.status.success());
-
-    let output = pred()
-        .args(["reduce", problem_file.to_str().unwrap(), "--to", "QUBO"])
-        .output()
-        .unwrap();
     assert!(
         output.status.success(),
         "stderr: {}",
@@ -5081,6 +5714,7 @@ fn test_reduce_auto_json_output() {
     );
 
     std::fs::remove_file(&problem_file).ok();
+    std::fs::remove_file(&route_file).ok();
 }
 
 // ---- Hint suppression tests ----
@@ -5162,17 +5796,19 @@ fn test_solve_bundle_no_hint_when_piped() {
         .unwrap();
     assert!(create_out.status.success());
 
-    let reduce_out = pred()
-        .args([
-            "-o",
-            bundle_file.to_str().unwrap(),
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    let reduce_out = reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-        ])
-        .output()
-        .unwrap();
+        ],
+        &bundle_file,
+    );
     assert!(reduce_out.status.success());
 
     let output = pred()
@@ -5541,11 +6177,11 @@ fn test_solve_sum_of_squares_partition_default_solver_uses_ilp() {
 
     let stdout = String::from_utf8(output.stdout).unwrap();
     assert!(
-        stdout.contains("\"solver\": \"ilp\""),
+        stdout.contains("\"kind\": \"ilp\""),
         "stdout should report the ILP solver, got: {stdout}"
     );
     assert!(
-        stdout.contains("\"reduced_to\": \"ILP\""),
+        stdout.contains("\"reduction_path\""),
         "stdout should report the ILP reduction target, got: {stdout}"
     );
 
@@ -5557,14 +6193,14 @@ fn test_create_multiple_choice_branching_pipe_to_solve() {
     let create_out = pred()
         .args([
             "create",
-            "MultipleChoiceBranching/i32",
+            "MultipleChoiceBranching/i64",
             "--arcs",
             "0>1,0>2,1>3,2>3,1>4,3>5,4>5,2>4",
             "--weights",
             "3,2,4,1,2,3,1,3",
             "--partition",
             "0,1;2,3;4,7;5,6",
-            "--bound",
+            "--threshold",
             "10",
         ])
         .output()
@@ -5604,7 +6240,7 @@ fn test_create_multiple_choice_branching_pipe_to_solve() {
 
 #[test]
 fn test_create_pipe_to_evaluate() {
-    // pred create MIS --graph 0-1,1-2 | pred evaluate - --config 1,0,1
+    // pred create MIS --graph 0-1,1-2 | pred evaluate - --config '[true,false,true]'
     let create_out = pred()
         .args(["create", "MIS", "--graph", "0-1,1-2"])
         .output()
@@ -5617,7 +6253,7 @@ fn test_create_pipe_to_evaluate() {
 
     use std::io::Write;
     let mut child = pred()
-        .args(["evaluate", "-", "--config", "1,0,1"])
+        .args(["evaluate", "-", "--config", "[true,false,true]"])
         .stdin(std::process::Stdio::piped())
         .stdout(std::process::Stdio::piped())
         .stderr(std::process::Stdio::piped())
@@ -5644,7 +6280,7 @@ fn test_create_pipe_to_evaluate() {
 
 #[test]
 fn test_create_pipe_to_reduce() {
-    // pred create MIS --graph 0-1,1-2 | pred reduce - --to QUBO
+    // pred create MIS --graph 0-1,1-2 | pred reduce - --via route.json
     let create_out = pred()
         .args(["create", "MIS", "--graph", "0-1,1-2"])
         .output()
@@ -5654,10 +6290,29 @@ fn test_create_pipe_to_reduce() {
         "create stderr: {}",
         String::from_utf8_lossy(&create_out.stderr)
     );
+    let route_file = std::env::temp_dir().join("pred_test_pipe_reduce_route.json");
+    write_named_route(
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
+            "QUBO",
+        ],
+        &route_file,
+    );
 
     use std::io::Write;
     let mut child = pred()
-        .args(["reduce", "-", "--to", "QUBO", "--json"])
+        .args([
+            "reduce",
+            "-",
+            "--via",
+            route_file.to_str().unwrap(),
+            "--json",
+        ])
         .stdin(std::process::Stdio::piped())
         .stdout(std::process::Stdio::piped())
         .stderr(std::process::Stdio::piped())
@@ -5681,6 +6336,7 @@ fn test_create_pipe_to_reduce() {
         json["source"].is_object(),
         "expected source object in reduction bundle, got: {stdout}"
     );
+    std::fs::remove_file(route_file).ok();
 }
 
 // ---- Inspect command tests ----
@@ -5711,6 +6367,9 @@ fn test_inspect_problem() {
         String::from_utf8_lossy(&output.stderr)
     );
     let stdout = String::from_utf8(output.stdout).unwrap();
+    let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
+    assert_eq!(json["parameter_values"]["num_vertices"], 4);
+    assert_eq!(json["parameter_values"]["num_edges"], 3);
     // auto_json: data commands output JSON when stdout is not a TTY
     assert!(
         stdout.contains("MaximumIndependentSet"),
@@ -5728,6 +6387,166 @@ fn test_inspect_problem() {
     std::fs::remove_file(&problem_file).ok();
 }
 
+#[test]
+fn test_inspect_reports_only_executable_reductions_for_exact_variant() {
+    let unit_file = std::env::temp_dir().join("pred_test_inspect_exact_variant_unit.json");
+    let weighted_file = std::env::temp_dir().join("pred_test_inspect_exact_variant_weighted.json");
+
+    let decision_file =
+        std::env::temp_dir().join("pred_test_inspect_exact_variant_decision_unit.json");
+    let decision_create = pred()
+        .args([
+            "create",
+            "--example",
+            "DecisionMaximumIndependentSet/One",
+            "-o",
+            decision_file.to_str().unwrap(),
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        decision_create.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&decision_create.stderr)
+    );
+
+    let unit_create = pred()
+        .args([
+            "create",
+            "MIS",
+            "--graph",
+            "0-1,1-2,2-3",
+            "-o",
+            unit_file.to_str().unwrap(),
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        unit_create.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&unit_create.stderr)
+    );
+
+    let weighted_create = pred()
+        .args([
+            "create",
+            "MIS/SimpleGraph/i64",
+            "--graph",
+            "0-1,1-2,2-3",
+            "--weights",
+            "3,1,2,1",
+            "-o",
+            weighted_file.to_str().unwrap(),
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        weighted_create.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&weighted_create.stderr)
+    );
+
+    for (source, source_ref, expected, excluded) in [
+        (
+            &unit_file,
+            "MIS/SimpleGraph/One",
+            "MaximumSetPacking",
+            "IntegralFlowBundles",
+        ),
+        (
+            &weighted_file,
+            "MIS/SimpleGraph/i64",
+            "MaximumSetPacking/i64",
+            "IntegralFlowBundles",
+        ),
+        (
+            &decision_file,
+            "DecisionMaximumIndependentSet/SimpleGraph/One",
+            "IntegralFlowBundles",
+            "MaximumIndependentSet/SimpleGraph/i64",
+        ),
+    ] {
+        let inspect = pred()
+            .args(["inspect", source.to_str().unwrap(), "--json"])
+            .output()
+            .unwrap();
+        assert!(
+            inspect.status.success(),
+            "stderr: {}",
+            String::from_utf8_lossy(&inspect.stderr)
+        );
+        let json: serde_json::Value = serde_json::from_slice(&inspect.stdout).unwrap();
+        let targets = json["reduces_to"].as_array().unwrap();
+        assert!(targets.iter().any(|target| target == expected));
+        assert!(!targets.iter().any(|target| target == excluded));
+
+        for (index, target) in targets.iter().enumerate() {
+            let target = target.as_str().unwrap();
+            let bundle = std::env::temp_dir().join(format!(
+                "pred_test_inspect_exact_variant_bundle_{index}.json"
+            ));
+            let route = bundle.with_extension("route.json");
+            write_direct_route(source_ref, target, &route);
+            let reduce = pred()
+                .args([
+                    "reduce",
+                    source.to_str().unwrap(),
+                    "--via",
+                    route.to_str().unwrap(),
+                    "-o",
+                    bundle.to_str().unwrap(),
+                ])
+                .output()
+                .unwrap();
+            assert!(
+                reduce.status.success(),
+                "inspect advertised non-executable target {target}: {}",
+                String::from_utf8_lossy(&reduce.stderr)
+            );
+            std::fs::remove_file(route).unwrap();
+            std::fs::remove_file(bundle).unwrap();
+        }
+    }
+
+    std::fs::remove_file(unit_file).unwrap();
+    std::fs::remove_file(weighted_file).unwrap();
+    std::fs::remove_file(decision_file).unwrap();
+}
+
+#[test]
+fn test_inspect_excludes_non_witness_reductions() {
+    let problem_file = std::env::temp_dir().join("pred_test_inspect_witness_reductions_only.json");
+    let create = pred()
+        .args([
+            "create",
+            "--example",
+            "MinimumDominatingSet",
+            "-o",
+            problem_file.to_str().unwrap(),
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        create.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&create.stderr)
+    );
+
+    let inspect = pred()
+        .args(["inspect", problem_file.to_str().unwrap(), "--json"])
+        .output()
+        .unwrap();
+    assert!(
+        inspect.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&inspect.stderr)
+    );
+    let json: serde_json::Value = serde_json::from_slice(&inspect.stdout).unwrap();
+    assert_eq!(json["reduces_to"], serde_json::json!(["ILP"]));
+
+    std::fs::remove_file(problem_file).unwrap();
+}
+
 #[test]
 fn test_inspect_minmaxmulticenter_lists_ilp_and_bruteforce() {
     let problem_file = std::env::temp_dir().join("pred_test_inspect_minmaxmulticenter.json");
@@ -5790,17 +6609,19 @@ fn test_inspect_bundle() {
         .unwrap();
     assert!(create_out.status.success());
 
-    let reduce_out = pred()
-        .args([
-            "-o",
-            bundle_file.to_str().unwrap(),
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    let reduce_out = reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-        ])
-        .output()
-        .unwrap();
+        ],
+        &bundle_file,
+    );
     assert!(
         reduce_out.status.success(),
         "reduce stderr: {}",
@@ -5908,21 +6729,21 @@ fn test_inspect_json_output() {
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
     assert_eq!(json["kind"], "problem");
     assert_eq!(json["type"], "MaximumIndependentSet");
-    let size_fields: Vec<&str> = json["size_fields"]
+    let parameters: Vec<&str> = json["parameters"]
         .as_array()
-        .expect("size_fields should be an array")
+        .expect("parameters should be an array")
         .iter()
         .map(|v| v.as_str().unwrap())
         .collect();
     assert!(
-        size_fields.contains(&"num_vertices"),
-        "MIS size_fields should contain num_vertices, got: {:?}",
-        size_fields
+        parameters.contains(&"num_vertices"),
+        "MIS parameters should contain num_vertices, got: {:?}",
+        parameters
     );
     assert!(
-        size_fields.contains(&"num_edges"),
-        "MIS size_fields should contain num_edges, got: {:?}",
-        size_fields
+        parameters.contains(&"num_edges"),
+        "MIS parameters should contain num_edges, got: {:?}",
+        parameters
     );
     assert!(json["solvers"].is_array());
     assert!(json["reduces_to"].is_array());
@@ -5990,7 +6811,7 @@ fn test_inspect_multiprocessor_scheduling_reports_ilp_and_brute_force() {
 }
 
 #[test]
-fn test_inspect_undirected_two_commodity_integral_flow_reports_size_fields() {
+fn test_inspect_undirected_two_commodity_integral_flow_reports_parameters() {
     let problem_file = std::env::temp_dir().join("pred_test_utcif_inspect_in.json");
     let result_file = std::env::temp_dir().join("pred_test_utcif_inspect_out.json");
     let create_out = pred()
@@ -6027,21 +6848,21 @@ fn test_inspect_undirected_two_commodity_integral_flow_reports_size_fields() {
 
     let content = std::fs::read_to_string(&result_file).unwrap();
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
-    let size_fields: Vec<&str> = json["size_fields"]
+    let parameters: Vec<&str> = json["parameters"]
         .as_array()
-        .expect("size_fields should be an array")
+        .expect("parameters should be an array")
         .iter()
         .map(|v| v.as_str().unwrap())
         .collect();
     assert!(
-        size_fields.contains(&"num_vertices"),
-        "UndirectedTwoCommodityIntegralFlow size_fields should contain num_vertices, got: {:?}",
-        size_fields
+        parameters.contains(&"num_vertices"),
+        "UndirectedTwoCommodityIntegralFlow parameters should contain num_vertices, got: {:?}",
+        parameters
     );
     assert!(
-        size_fields.contains(&"num_edges"),
-        "UndirectedTwoCommodityIntegralFlow size_fields should contain num_edges, got: {:?}",
-        size_fields
+        parameters.contains(&"num_edges"),
+        "UndirectedTwoCommodityIntegralFlow parameters should contain num_edges, got: {:?}",
+        parameters
     );
 
     std::fs::remove_file(&problem_file).ok();
@@ -6049,7 +6870,7 @@ fn test_inspect_undirected_two_commodity_integral_flow_reports_size_fields() {
 }
 
 #[test]
-fn test_inspect_integral_flow_with_multipliers_reports_size_fields() {
+fn test_inspect_integral_flow_with_multipliers_reports_parameters() {
     let problem_file = std::env::temp_dir().join("pred_test_ifwm_inspect_in.json");
     let result_file = std::env::temp_dir().join("pred_test_ifwm_inspect_out.json");
     let create_out = pred()
@@ -6085,23 +6906,23 @@ fn test_inspect_integral_flow_with_multipliers_reports_size_fields() {
 
     let content = std::fs::read_to_string(&result_file).unwrap();
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
-    let size_fields: Vec<&str> = json["size_fields"]
+    let parameters: Vec<&str> = json["parameters"]
         .as_array()
-        .expect("size_fields should be an array")
+        .expect("parameters should be an array")
         .iter()
         .map(|v| v.as_str().unwrap())
         .collect();
-    assert!(size_fields.contains(&"num_vertices"));
-    assert!(size_fields.contains(&"num_arcs"));
-    assert!(size_fields.contains(&"max_capacity"));
-    assert!(size_fields.contains(&"requirement"));
+    assert!(parameters.contains(&"num_vertices"));
+    assert!(parameters.contains(&"num_arcs"));
+    assert!(parameters.contains(&"max_capacity"));
+    assert!(parameters.contains(&"requirement"));
 
     std::fs::remove_file(&problem_file).ok();
     std::fs::remove_file(&result_file).ok();
 }
 
 #[test]
-fn test_inspect_acyclic_partition_reports_size_fields() {
+fn test_inspect_acyclic_partition_reports_parameters() {
     let problem_file = std::env::temp_dir().join("pred_test_acyclic_partition_inspect_in.json");
     let result_file = std::env::temp_dir().join("pred_test_acyclic_partition_inspect_out.json");
     let create_out = pred()
@@ -6110,7 +6931,7 @@ fn test_inspect_acyclic_partition_reports_size_fields() {
             problem_file.to_str().unwrap(),
             "create",
             "--example",
-            "AcyclicPartition/i32",
+            "AcyclicPartition/i64",
         ])
         .output()
         .unwrap();
@@ -6138,21 +6959,21 @@ fn test_inspect_acyclic_partition_reports_size_fields() {
 
     let content = std::fs::read_to_string(&result_file).unwrap();
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
-    let size_fields: Vec<&str> = json["size_fields"]
+    let parameters: Vec<&str> = json["parameters"]
         .as_array()
-        .expect("size_fields should be an array")
+        .expect("parameters should be an array")
         .iter()
         .map(|v| v.as_str().unwrap())
         .collect();
     assert!(
-        size_fields.contains(&"num_vertices"),
-        "AcyclicPartition size_fields should contain num_vertices, got: {:?}",
-        size_fields
+        parameters.contains(&"num_vertices"),
+        "AcyclicPartition parameters should contain num_vertices, got: {:?}",
+        parameters
     );
     assert!(
-        size_fields.contains(&"num_arcs"),
-        "AcyclicPartition size_fields should contain num_arcs, got: {:?}",
-        size_fields
+        parameters.contains(&"num_arcs"),
+        "AcyclicPartition parameters should contain num_arcs, got: {:?}",
+        parameters
     );
 
     std::fs::remove_file(&problem_file).ok();
@@ -6160,7 +6981,7 @@ fn test_inspect_acyclic_partition_reports_size_fields() {
 }
 
 #[test]
-fn test_inspect_multiple_copy_file_allocation_reports_size_fields() {
+fn test_inspect_multiple_copy_file_allocation_reports_parameters() {
     let problem_file = std::env::temp_dir().join("pred_test_mcfa_inspect_in.json");
     let result_file = std::env::temp_dir().join("pred_test_mcfa_inspect_out.json");
     let create_out = pred()
@@ -6197,21 +7018,21 @@ fn test_inspect_multiple_copy_file_allocation_reports_size_fields() {
 
     let content = std::fs::read_to_string(&result_file).unwrap();
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
-    let size_fields: Vec<&str> = json["size_fields"]
+    let parameters: Vec<&str> = json["parameters"]
         .as_array()
-        .expect("size_fields should be an array")
+        .expect("parameters should be an array")
         .iter()
         .map(|v| v.as_str().unwrap())
         .collect();
     assert!(
-        size_fields.contains(&"num_vertices"),
-        "MultipleCopyFileAllocation size_fields should contain num_vertices, got: {:?}",
-        size_fields
+        parameters.contains(&"num_vertices"),
+        "MultipleCopyFileAllocation parameters should contain num_vertices, got: {:?}",
+        parameters
     );
     assert!(
-        size_fields.contains(&"num_edges"),
-        "MultipleCopyFileAllocation size_fields should contain num_edges, got: {:?}",
-        size_fields
+        parameters.contains(&"num_edges"),
+        "MultipleCopyFileAllocation parameters should contain num_edges, got: {:?}",
+        parameters
     );
     let solvers: Vec<&str> = json["solvers"]
         .as_array()
@@ -6330,8 +7151,8 @@ fn test_create_random_unsupported() {
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("not supported"),
-        "expected 'not supported' in error, got: {stderr}"
+        stderr.contains("unexpected argument '--random'"),
+        "expected Clap to reject unsupported random generation, got: {stderr}"
     );
 }
 
@@ -6344,7 +7165,7 @@ fn test_create_random_steiner_tree_requires_two_vertices() {
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("SteinerTree random generation requires --num-vertices >= 2"),
+        stderr.contains("num_vertices must be at least 2"),
         "{stderr}"
     );
 }
@@ -6366,7 +7187,7 @@ fn test_create_random_invalid_edge_prob() {
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("--edge-prob must be between"),
+        stderr.contains("edge_prob must be between"),
         "expected edge-prob validation error, got: {stderr}"
     );
 }
@@ -6557,17 +7378,29 @@ fn test_create_factoring_no_flags_shows_help() {
 }
 
 #[test]
-fn test_create_factoring_missing_bits() {
+fn test_create_factoring_derives_missing_bits() {
     let output = pred()
         .args(["create", "Factoring", "--target", "15"])
         .output()
         .unwrap();
-    assert!(!output.status.success());
-    let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("--m"),
-        "expected '--m' in error, got: {stderr}"
+        output.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
     );
+    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    assert_eq!(json["data"]["m"], 2);
+    assert_eq!(json["data"]["n"], 3);
+}
+
+#[test]
+fn test_create_factoring_requires_bits_together() {
+    let output = pred()
+        .args(["create", "Factoring", "--target", "15", "--m", "2"])
+        .output()
+        .unwrap();
+    assert!(!output.status.success());
+    assert!(String::from_utf8_lossy(&output.stderr).contains("provided together"));
 }
 
 #[test]
@@ -6578,7 +7411,7 @@ fn test_create_bcnf_rejects_out_of_range_attribute_indices() {
             "BoyceCoddNormalFormViolation",
             "--n",
             "3",
-            "--sets",
+            "--subsets",
             "0:4",
             "--target",
             "0,1,2",
@@ -6595,7 +7428,7 @@ fn test_create_bcnf_rejects_out_of_range_attribute_indices() {
         "CLI should return a user-facing error, got: {stderr}"
     );
     assert!(
-        stderr.contains("out of range"),
+        stderr.contains("outside universe of size 3"),
         "expected out-of-range error, got: {stderr}"
     );
 }
@@ -6608,7 +7441,7 @@ fn test_create_bcnf_rejects_out_of_range_lhs_attribute_indices() {
             "BoyceCoddNormalFormViolation",
             "--n",
             "3",
-            "--sets",
+            "--subsets",
             "4:0",
             "--target",
             "0,1,2",
@@ -6621,7 +7454,7 @@ fn test_create_bcnf_rejects_out_of_range_lhs_attribute_indices() {
     );
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("lhs contains attribute index 4"),
+        stderr.contains("subsets[0] contains attribute 4 outside universe of size 3"),
         "expected lhs-specific out-of-range error, got: {stderr}"
     );
 }
@@ -6634,7 +7467,7 @@ fn test_create_bcnf_rejects_out_of_range_target_attribute_indices() {
             "BoyceCoddNormalFormViolation",
             "--n",
             "3",
-            "--sets",
+            "--subsets",
             "0:1",
             "--target",
             "0,1,4",
@@ -6647,7 +7480,7 @@ fn test_create_bcnf_rejects_out_of_range_target_attribute_indices() {
     );
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("Target subset contains attribute index 4"),
+        stderr.contains("target contains attribute 4 outside universe of size 3"),
         "expected target-specific out-of-range error, got: {stderr}"
     );
 }
@@ -6663,9 +7496,9 @@ fn test_create_consistency_of_database_frequency_tables() {
             "--attribute-domains",
             "2,3,2",
             "--frequency-tables",
-            "0,1:1,1,1|1,1,1;1,2:1,1|0,2|1,1",
+            r#"[{"attribute_a":0,"attribute_b":1,"counts":[[1,1,1],[1,1,1]]},{"attribute_a":1,"attribute_b":2,"counts":[[1,1],[0,2],[1,1]]}]"#,
             "--known-values",
-            "0,0,0;3,0,1;1,2,1",
+            r#"[{"object":0,"attribute":0,"value":0},{"object":3,"attribute":0,"value":1},{"object":1,"attribute":2,"value":1}]"#,
         ])
         .output()
         .unwrap();
@@ -6725,8 +7558,6 @@ fn test_create_multiple_copy_file_allocation() {
             "5,4,3,2",
             "--storage",
             "1,1,1,1",
-            "--bound",
-            "8",
         ])
         .output()
         .unwrap();
@@ -6752,10 +7583,8 @@ fn test_create_sequencing_to_minimize_maximum_cumulative_cost() {
             "SequencingToMinimizeMaximumCumulativeCost",
             "--costs",
             "2,-1,3,-2,1,-3",
-            "--precedence-pairs",
+            "--precedences",
             "0>2,1>2,1>3,2>4,3>5,4>5",
-            "--bound",
-            "4",
         ])
         .output()
         .unwrap();
@@ -6831,8 +7660,6 @@ fn test_create_multiple_copy_file_allocation_rejects_length_mismatch() {
             "5,4",
             "--storage",
             "1,1,1,1",
-            "--bound",
-            "8",
         ])
         .output()
         .unwrap();
@@ -6854,15 +7681,15 @@ fn test_create_sequencing_to_minimize_maximum_cumulative_cost_missing_costs() {
         .args([
             "create",
             "SequencingToMinimizeMaximumCumulativeCost",
-            "--bound",
-            "4",
+            "--precedences",
+            "0>1",
         ])
         .output()
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("requires --costs"),
+        stderr.contains("missing required construction input(s): costs"),
         "expected missing --costs message, got: {stderr}"
     );
 }
@@ -6879,8 +7706,6 @@ fn test_create_multiple_copy_file_allocation_rejects_storage_length_mismatch() {
             "5,4,3,2",
             "--storage",
             "1,1",
-            "--bound",
-            "8",
         ])
         .output()
         .unwrap();
@@ -6904,10 +7729,8 @@ fn test_create_sequencing_to_minimize_maximum_cumulative_cost_bad_precedence() {
             "SequencingToMinimizeMaximumCumulativeCost",
             "--costs",
             "1,-1,2",
-            "--precedence-pairs",
+            "--precedences",
             "0>3",
-            "--bound",
-            "2",
         ])
         .output()
         .unwrap();
@@ -6931,15 +7754,13 @@ fn test_create_multiple_copy_file_allocation_rejects_invalid_usage_values() {
             "5,x,3,2",
             "--storage",
             "1,1,1,1",
-            "--bound",
-            "8",
         ])
         .output()
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("invalid usage list"),
+        stderr.contains("invalid digit found in string"),
         "expected usage parse diagnostic, got: {stderr}"
     );
     assert!(
@@ -6958,8 +7779,6 @@ fn test_create_sequencing_to_minimize_maximum_cumulative_cost_invalid_precedence
             "1,-1,2",
             "--precedences",
             "a>b",
-            "--bound",
-            "2",
         ])
         .output()
         .unwrap();
@@ -6979,8 +7798,6 @@ fn test_create_sequencing_to_minimize_maximum_cumulative_cost_allows_negative_va
             "SequencingToMinimizeMaximumCumulativeCost",
             "--costs",
             "-1,2,-3",
-            "--bound",
-            "-1",
         ])
         .output()
         .unwrap();
@@ -7017,7 +7834,7 @@ fn test_evaluate_multiprocessor_scheduling_rejects_zero_processors_json() {
             "evaluate",
             problem_file.to_str().unwrap(),
             "--config",
-            "0,0",
+            "[0,0]",
         ])
         .output()
         .unwrap();
@@ -7070,7 +7887,7 @@ fn test_solve_multiple_copy_file_allocation_brute_force() {
     );
     let stdout = String::from_utf8(output.stdout).unwrap();
     assert!(
-        stdout.contains("\"solver\": \"brute-force\""),
+        stdout.contains("\"kind\": \"brute-force\""),
         "MultipleCopyFileAllocation should solve with brute-force: {stdout}"
     );
 
@@ -7194,7 +8011,7 @@ fn test_create_mis_triangular_subgraph() {
     let output = pred()
         .args([
             "create",
-            "MIS/TriangularSubgraph/i32",
+            "MIS/TriangularSubgraph/i64",
             "--positions",
             "0,0;0,1;1,0;1,1",
         ])
@@ -7245,8 +8062,8 @@ fn test_create_mvc_kings_subgraph_unsupported_variant() {
     assert!(!output.status.success());
     let stderr = String::from_utf8(output.stderr).unwrap();
     assert!(
-        stderr.contains("Unknown variant token \"KingsSubgraph\""),
-        "should mention unknown variant token: {stderr}"
+        stderr.contains("Unknown variant value \"KingsSubgraph\""),
+        "should reject the unregistered variant: {stderr}"
     );
 }
 
@@ -7277,7 +8094,7 @@ fn test_create_mis_kings_subgraph_with_weights() {
     let output = pred()
         .args([
             "create",
-            "MIS/KingsSubgraph/i32",
+            "MIS/KingsSubgraph/i64",
             "--positions",
             "0,0;1,0;1,1",
             "--weights",
@@ -7294,7 +8111,7 @@ fn test_create_mis_kings_subgraph_with_weights() {
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "MaximumIndependentSet");
     assert_eq!(json["variant"]["graph"], "KingsSubgraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
 }
 
 #[test]
@@ -7327,7 +8144,7 @@ fn test_create_random_triangular_subgraph() {
     let output = pred()
         .args([
             "create",
-            "MIS/TriangularSubgraph/i32",
+            "MIS/TriangularSubgraph/i64",
             "--random",
             "--num-vertices",
             "8",
@@ -7394,7 +8211,7 @@ fn test_create_kings_subgraph_help() {
 #[test]
 fn test_create_geometry_graph_missing_positions() {
     let output = pred()
-        .args(["create", "MIS/KingsSubgraph", "--weights", "1,2,3"])
+        .args(["create", "MIS/KingsSubgraph/i64", "--weights", "1,2,3"])
         .output()
         .unwrap();
     assert!(!output.status.success());
@@ -7407,6 +8224,46 @@ fn test_create_geometry_graph_missing_positions() {
 
 // ---- Round-trip: canonical examples through solve ----
 
+#[test]
+fn test_fixed_directed_graph_examples_round_trip_into_inspect_and_solve() {
+    for name in ["DirectedHamiltonianPath", "EulerianPath", "Kernel"] {
+        let path = std::env::temp_dir().join(format!(
+            "pred_test_fixed_directed_graph_{name}_{}.json",
+            std::process::id()
+        ));
+        let create = pred()
+            .args(["create", "--example", name, "-o", path.to_str().unwrap()])
+            .output()
+            .unwrap();
+        assert!(
+            create.status.success(),
+            "{name} create: {}",
+            String::from_utf8_lossy(&create.stderr)
+        );
+        let instance: serde_json::Value =
+            serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
+        assert_eq!(instance["variant"], serde_json::json!({}));
+
+        for command in ["inspect", "solve"] {
+            let output = pred()
+                .args([command, path.to_str().unwrap(), "--json"])
+                .output()
+                .unwrap();
+            assert!(
+                output.status.success(),
+                "{name} {command}: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+            if command == "solve" {
+                let solved: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+                assert_eq!(solved["status"], "optimal", "{name}");
+                assert_eq!(solved["evaluation"], "Or(true)", "{name}");
+            }
+        }
+        std::fs::remove_file(path).unwrap();
+    }
+}
+
 #[test]
 fn test_create_model_example_mis_round_trips_into_solve() {
     let path = std::env::temp_dir().join(format!(
@@ -7420,7 +8277,7 @@ fn test_create_model_example_mis_round_trips_into_solve() {
         .args([
             "create",
             "--example",
-            "MIS/SimpleGraph/i32",
+            "MIS/SimpleGraph/i64",
             "-o",
             path.to_str().unwrap(),
         ])
@@ -7458,9 +8315,9 @@ fn test_create_rule_example_mvc_to_mis_round_trips_into_solve() {
         .args([
             "create",
             "--example",
-            "MVC/SimpleGraph/i32",
+            "MVC/SimpleGraph/i64",
             "--to",
-            "MIS/SimpleGraph/i32",
+            "MIS/SimpleGraph/i64",
             "-o",
             path.to_str().unwrap(),
         ])
@@ -7488,7 +8345,7 @@ fn test_create_rule_example_mvc_to_mis_round_trips_into_solve() {
 #[test]
 fn test_create_rule_example_mvc_to_mis_weight_only() {
     let output = pred()
-        .args(["create", "--example", "MVC/i32", "--to", "MIS/i32"])
+        .args(["create", "--example", "MVC/i64", "--to", "MIS/i64"])
         .output()
         .unwrap();
     assert!(
@@ -7500,7 +8357,7 @@ fn test_create_rule_example_mvc_to_mis_weight_only() {
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "MinimumVertexCover");
     assert_eq!(json["variant"]["graph"], "SimpleGraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
 }
 
 #[test]
@@ -7509,9 +8366,9 @@ fn test_create_rule_example_mvc_to_mis_target_weight_only() {
         .args([
             "create",
             "--example",
-            "MVC/i32",
+            "MVC/i64",
             "--to",
-            "MIS/i32",
+            "MIS/i64",
             "--example-side",
             "target",
         ])
@@ -7526,7 +8383,7 @@ fn test_create_rule_example_mvc_to_mis_target_weight_only() {
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "MaximumIndependentSet");
     assert_eq!(json["variant"]["graph"], "SimpleGraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
 }
 
 // ---- Variant-level show semantics ----
@@ -7578,18 +8435,9 @@ fn test_show_ksat_works() {
 // ---- Capped multi-path ----
 
 #[test]
-fn test_path_all_max_paths_truncates() {
-    // With --max-paths 3, should limit to 3 paths and indicate truncation
+fn test_path_limit_truncates() {
     let output = pred()
-        .args([
-            "path",
-            "KSat",
-            "QUBO",
-            "--all",
-            "--max-paths",
-            "3",
-            "--json",
-        ])
+        .args(["path", "KSat", "QUBO/f64", "--limit", "3", "--json"])
         .output()
         .unwrap();
     assert!(
@@ -7607,7 +8455,6 @@ fn test_path_all_max_paths_truncates() {
         "should return at most 3 paths, got {}",
         paths.len()
     );
-    assert_eq!(envelope["max_paths"], 3);
     // KSat -> QUBO has many paths, so truncation is expected
     assert_eq!(
         envelope["truncated"], true,
@@ -7615,17 +8462,72 @@ fn test_path_all_max_paths_truncates() {
     );
 }
 
+// Helper: run `pred path S T --limit N --json` and return the ordered list of
+// per-path step counts.
+fn path_step_counts(limit: &str) -> Vec<u64> {
+    let output = pred()
+        .args(["path", "KSat", "QUBO/f64", "--limit", limit, "--json"])
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    let envelope: serde_json::Value = serde_json::from_str(&stdout).unwrap();
+    envelope["paths"]
+        .as_array()
+        .expect("should have paths array")
+        .iter()
+        .map(|p| p["steps"].as_u64().expect("steps is a number"))
+        .collect()
+}
+
 #[test]
-fn test_path_all_max_paths_text_truncation_note() {
+fn test_path_truncates_after_sorting_not_before() {
+    // Path enumeration must order length-first and truncate only after
+    // ordering, so a small --limit returns the SHORTEST routes, not whichever
+    // routes DFS discovered first. Compare a tightly-truncated run against a run
+    // with a generous budget.
+    let full = path_step_counts("500");
+    assert!(full.len() > 3, "KSat->QUBO should have many routes");
+
+    // Full list is sorted shortest-first.
+    assert!(
+        full.windows(2).all(|w| w[0] <= w[1]),
+        "paths must be returned shortest-first, got {full:?}"
+    );
+    let shortest = *full.first().unwrap();
+
+    let truncated = path_step_counts("3");
+    assert!(truncated.len() <= 3);
+    // Truncated result is still sorted shortest-first...
+    assert!(
+        truncated.windows(2).all(|w| w[0] <= w[1]),
+        "truncated paths must be shortest-first, got {truncated:?}"
+    );
+    // ...and it must include the known shortest length (the bug returned long
+    // early-discovered routes and dropped the short ones).
+    assert_eq!(
+        truncated[0], shortest,
+        "truncated result must start with the known shortest route length {shortest}"
+    );
+    // The truncated step counts are exactly the shortest prefix of the full order.
+    assert_eq!(truncated.as_slice(), &full[..truncated.len()]);
+}
+
+#[test]
+fn test_path_limit_text_truncation_note() {
     let output = pred()
-        .args(["path", "KSat", "QUBO", "--all", "--max-paths", "2"])
+        .args(["path", "KSat", "QUBO/f64", "--limit", "2"])
         .output()
         .unwrap();
     assert!(output.status.success());
     let stdout = String::from_utf8(output.stdout).unwrap();
     assert!(
-        stdout.contains("--max-paths"),
-        "truncation note should mention --max-paths: {stdout}"
+        stdout.contains("--limit"),
+        "truncation note should mention --limit: {stdout}"
     );
 }
 
@@ -7730,7 +8632,7 @@ fn test_create_shortest_weight_constrained_path_edge_length_count_mismatch() {
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("Expected 8 edge length values but got 7"),
+        stderr.contains("edge_lengths has 7 entries, expected 8"),
         "stderr: {stderr}"
     );
 }
@@ -7750,14 +8652,6 @@ fn test_create_shortest_weight_constrained_path_no_flags_shows_vector_hints() {
         stderr.contains("--edge-lengths"),
         "expected '--edge-lengths' in help output, got: {stderr}"
     );
-    assert!(
-        stderr.match_indices("comma-separated: 1,2,3").count() >= 2,
-        "expected vector hints for edge lengths and weights, got: {stderr}"
-    );
-    assert!(
-        stderr.match_indices("numeric value: 10").count() >= 1,
-        "expected numeric hint for weight bound, got: {stderr}"
-    );
 }
 
 #[test]
@@ -7784,7 +8678,7 @@ fn test_create_shortest_weight_constrained_path_rejects_out_of_bounds_source_ver
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("source_vertex 9 out of bounds"),
+        stderr.contains("source_vertex 9 is outside graph with 6 vertices"),
         "stderr: {stderr}"
     );
     assert!(
@@ -7815,7 +8709,7 @@ fn test_create_shortest_weight_constrained_path_requires_edge_lengths() {
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("ShortestWeightConstrainedPath requires --edge-lengths"),
+        stderr.contains("missing required construction input(s): edge_lengths"),
         "stderr: {stderr}"
     );
 }
@@ -7844,7 +8738,7 @@ fn test_create_shortest_weight_constrained_path_rejects_weights_flag_typo() {
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("uses --edge-weights, not --weights"),
+        stderr.contains("unexpected argument '--weights'"),
         "stderr: {stderr}"
     );
 }
@@ -7872,7 +8766,7 @@ fn test_create_shortest_weight_constrained_path_rejects_non_positive_edge_length
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
-        stderr.contains("All edge lengths must be positive (> 0)"),
+        stderr.contains("edge_lengths must be positive"),
         "stderr: {stderr}"
     );
 }
@@ -7890,16 +8784,16 @@ fn test_show_shortest_weight_constrained_path_uses_weight_schema_type_names() {
     );
     let stdout = String::from_utf8(output.stdout).unwrap();
     assert!(
-        stdout.contains("edge_lengths (Vec<W>)"),
-        "expected Vec<W> schema type for edge_lengths, got: {stdout}"
+        stdout.contains("edge_lengths (Vec<i64>)"),
+        "expected concrete Vec<i64> construction type for edge_lengths, got: {stdout}"
     );
     assert!(
-        stdout.contains("edge_weights (Vec<W>)"),
-        "expected Vec<W> schema type for edge_weights, got: {stdout}"
+        stdout.contains("edge_weights (Vec<i64>)"),
+        "expected concrete Vec<i64> construction type for edge_weights, got: {stdout}"
     );
     assert!(
-        stdout.contains("weight_bound (W::Sum)"),
-        "expected W::Sum schema type for weight_bound, got: {stdout}"
+        stdout.contains("weight_bound (i64)"),
+        "expected concrete i64 construction type for weight_bound, got: {stdout}"
     );
 }
 
@@ -7919,41 +8813,6 @@ fn test_show_json_has_default_field() {
     assert!(json["variant"].is_object(), "should have variant object");
 }
 
-// ---- path --all directory output includes manifest ----
-
-#[test]
-fn test_path_all_save_manifest() {
-    let dir = std::env::temp_dir().join("pred_test_all_paths_manifest");
-    let _ = std::fs::remove_dir_all(&dir);
-    let output = pred()
-        .args([
-            "path",
-            "MaxCut",
-            "QUBO",
-            "--all",
-            "-o",
-            dir.to_str().unwrap(),
-        ])
-        .output()
-        .unwrap();
-    assert!(
-        output.status.success(),
-        "stderr: {}",
-        String::from_utf8_lossy(&output.stderr)
-    );
-    assert!(dir.is_dir());
-
-    let manifest_file = dir.join("manifest.json");
-    assert!(manifest_file.exists(), "manifest.json should be created");
-    let manifest_content = std::fs::read_to_string(&manifest_file).unwrap();
-    let manifest: serde_json::Value = serde_json::from_str(&manifest_content).unwrap();
-    assert!(manifest["paths"].is_number());
-    assert!(manifest["max_paths"].is_number());
-    assert!(manifest["truncated"].is_boolean());
-
-    std::fs::remove_dir_all(&dir).ok();
-}
-
 #[test]
 fn test_create_nonunit_weights_require_weighted_variant() {
     let output = pred()
@@ -7969,31 +8828,19 @@ fn test_create_nonunit_weights_require_weighted_variant() {
         .unwrap();
     assert!(
         !output.status.success(),
-        "non-unit weights should require /i32"
+        "non-unit weights should require /i64"
     );
     let stderr = String::from_utf8(output.stderr).unwrap();
     assert!(
-        stderr.contains("Use the weighted variant instead"),
-        "stderr should point to the explicit weighted variant: {stderr}"
-    );
-    assert!(
-        stderr.contains("MaximumIndependentSet/SimpleGraph/i32"),
-        "stderr should include the exact weighted variant: {stderr}"
+        stderr.contains("unexpected argument '--weights'"),
+        "stderr should reject non-unit input for the One variant: {stderr}"
     );
 }
 
 #[test]
-fn test_create_unit_weights_stays_one() {
-    // When all weights are 1, the variant should remain One.
+fn test_create_unit_weights_are_implicit() {
     let output = pred()
-        .args([
-            "create",
-            "MIS",
-            "--graph",
-            "0-1,1-2,2-3",
-            "--weights",
-            "1,1,1,1",
-        ])
+        .args(["create", "MIS", "--graph", "0-1,1-2,2-3"])
         .output()
         .unwrap();
     assert!(
@@ -8004,6 +8851,7 @@ fn test_create_unit_weights_stays_one() {
     let stdout = String::from_utf8(output.stdout).unwrap();
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["variant"]["weight"], "One");
+    assert_eq!(json["data"]["weights"], serde_json::json!([1, 1, 1, 1]));
 }
 
 #[test]
@@ -8012,7 +8860,7 @@ fn test_create_weighted_mis_round_trips_into_solve() {
     let create_output = pred()
         .args([
             "create",
-            "MIS/i32",
+            "MIS/i64",
             "--graph",
             "0-1,1-2,2-3",
             "--weights",
@@ -8076,7 +8924,7 @@ fn test_create_minimum_multiway_cut() {
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
     assert_eq!(json["type"], "MinimumMultiwayCut");
     assert_eq!(json["variant"]["graph"], "SimpleGraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
     assert_eq!(json["data"]["terminals"], serde_json::json!([0, 2]));
     assert_eq!(json["data"]["edge_weights"], serde_json::json!([1, 1, 1]));
     std::fs::remove_file(&output_file).ok();
@@ -8130,9 +8978,9 @@ fn test_create_ensemble_computation() {
             output_file.to_str().unwrap(),
             "create",
             "EnsembleComputation",
-            "--universe",
+            "--universe-size",
             "4",
-            "--sets",
+            "--subsets",
             "0,1,2;0,1,3",
             "--budget",
             "4",
@@ -8179,10 +9027,6 @@ fn test_create_ensemble_computation_no_flags_uses_cli_flag_names() {
         stderr.contains("--budget"),
         "expected --budget in help, got: {stderr}"
     );
-    assert!(
-        !stderr.contains("--universe "),
-        "help should use canonical CLI flags, got: {stderr}"
-    );
 }
 
 #[test]
@@ -8191,9 +9035,9 @@ fn test_create_ensemble_computation_rejects_out_of_range_elements_without_panick
         .args([
             "create",
             "EnsembleComputation",
-            "--universe",
+            "--universe-size",
             "4",
-            "--sets",
+            "--subsets",
             "0,1,5",
             "--budget",
             "4",
@@ -8213,7 +9057,7 @@ fn test_create_ensemble_computation_rejects_out_of_range_elements_without_panick
 }
 
 #[test]
-fn test_create_scheduling_with_individual_deadlines_with_m_alias() {
+fn test_create_scheduling_with_individual_deadlines() {
     let output_file =
         std::env::temp_dir().join("pred_test_create_scheduling_with_individual_deadlines.json");
     let output = pred()
@@ -8222,13 +9066,13 @@ fn test_create_scheduling_with_individual_deadlines_with_m_alias() {
             output_file.to_str().unwrap(),
             "create",
             "SchedulingWithIndividualDeadlines",
-            "--n",
+            "--num-tasks",
             "7",
             "--deadlines",
             "2,1,2,2,3,3,2",
-            "--m",
+            "--num-processors",
             "3",
-            "--precedence-pairs",
+            "--precedences",
             "0>3,1>3,1>4,2>4,2>5",
         ])
         .output()
@@ -8246,48 +9090,6 @@ fn test_create_scheduling_with_individual_deadlines_with_m_alias() {
     std::fs::remove_file(&output_file).ok();
 }
 
-#[test]
-fn test_create_scheduling_with_individual_deadlines_help_mentions_m_alias() {
-    let output = pred()
-        .args(["create", "SchedulingWithIndividualDeadlines"])
-        .output()
-        .unwrap();
-    assert!(
-        !output.status.success(),
-        "problem-specific help should exit non-zero"
-    );
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(
-        stderr.contains("--num-processors/--m"),
-        "expected alias in problem-specific help, got: {stderr}"
-    );
-}
-
-#[test]
-fn test_create_scheduling_with_individual_deadlines_rejects_conflicting_processor_flags() {
-    let output = pred()
-        .args([
-            "create",
-            "SchedulingWithIndividualDeadlines",
-            "--n",
-            "3",
-            "--deadlines",
-            "1,1,2",
-            "--num-processors",
-            "3",
-            "--m",
-            "2",
-        ])
-        .output()
-        .unwrap();
-    assert!(!output.status.success());
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(
-        stderr.contains("conflicting processor counts"),
-        "expected conflict error, got: {stderr}"
-    );
-}
-
 #[test]
 fn test_create_model_example_multiprocessor_scheduling() {
     let output = pred()
@@ -8341,7 +9143,7 @@ fn test_create_model_example_minimum_multiway_cut() {
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
     assert_eq!(json["type"], "MinimumMultiwayCut");
     assert_eq!(json["variant"]["graph"], "SimpleGraph");
-    assert_eq!(json["variant"]["weight"], "i32");
+    assert_eq!(json["variant"]["weight"], "i64");
 }
 
 #[test]
@@ -8400,7 +9202,7 @@ fn test_create_minimum_multiway_cut_rejects_single_terminal() {
 }
 
 #[test]
-fn test_create_sequencing_within_intervals_rejects_empty_window() {
+fn test_create_and_solve_sequencing_within_intervals_empty_window() {
     let output = pred()
         .args([
             "create",
@@ -8414,16 +9216,35 @@ fn test_create_sequencing_within_intervals_rejects_empty_window() {
         ])
         .output()
         .unwrap();
-    assert!(!output.status.success());
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(
-        !stderr.contains("panicked at"),
-        "expected graceful CLI error, got panic: {stderr}"
-    );
     assert!(
-        stderr.contains("time window is empty"),
-        "expected empty-window validation error, got: {stderr}"
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
     );
+    for solver in ["brute-force", "ilp"] {
+        use std::io::Write;
+        let mut child = pred()
+            .args(["solve", "-", "--solver", solver, "--json"])
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::piped())
+            .spawn()
+            .unwrap();
+        child
+            .stdin
+            .take()
+            .unwrap()
+            .write_all(&output.stdout)
+            .unwrap();
+        let solved = child.wait_with_output().unwrap();
+        assert!(
+            solved.status.success(),
+            "{}",
+            String::from_utf8_lossy(&solved.stderr)
+        );
+        let json: serde_json::Value = serde_json::from_slice(&solved.stdout).unwrap();
+        assert_eq!(json["status"], "infeasible");
+    }
 }
 
 #[test]
@@ -8460,11 +9281,11 @@ fn test_create_sequencing_within_intervals_rejects_overflow() {
             "create",
             "SequencingWithinIntervals",
             "--release-times",
-            "18446744073709551615",
+            "0",
             "--deadlines",
-            "18446744073709551615",
+            "9223372036854775807",
             "--lengths",
-            "1",
+            "0",
         ])
         .output()
         .unwrap();
@@ -8475,13 +9296,13 @@ fn test_create_sequencing_within_intervals_rejects_overflow() {
         "expected graceful CLI error, got panic: {stderr}"
     );
     assert!(
-        stderr.contains("overflow computing r(i) + l(i)"),
+        stderr.contains("task start-slot count overflows i64"),
         "expected overflow validation error, got: {stderr}"
     );
 }
 
 #[test]
-fn test_solve_customized_unsupported_problem_shows_hint() {
+fn deterministic_solver_dispatch_rejects_non_override_solver_names() {
     let problem_file = std::env::temp_dir().join("pred_test_solve_customized_unsupported.json");
     let create_out = pred()
         .args([
@@ -8496,27 +9317,69 @@ fn test_solve_customized_unsupported_problem_shows_hint() {
         .unwrap();
     assert!(create_out.status.success());
 
-    let output = pred()
-        .args([
-            "solve",
-            problem_file.to_str().unwrap(),
-            "--solver",
-            "customized",
-        ])
-        .output()
-        .unwrap();
-    assert!(!output.status.success());
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(
-        stderr.contains("unsupported by customized solver"),
-        "expected customized solver hint, got: {stderr}"
-    );
+    for rejected in ["auto", "fd-minimum-cardinality-key"] {
+        let output = pred()
+            .args([
+                "solve",
+                problem_file.to_str().unwrap(),
+                "--solver",
+                rejected,
+            ])
+            .output()
+            .unwrap();
+        assert!(!output.status.success(), "accepted --solver {rejected}");
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        assert!(
+            stderr.contains(&format!("Unknown solver: {rejected}")),
+            "unexpected error for {rejected}: {stderr}"
+        );
+    }
+
+    std::fs::remove_file(&problem_file).ok();
+}
+
+#[test]
+fn deterministic_solver_dispatch_cli_output_is_repeatable_for_each_solver_class() {
+    let problem_file = std::env::temp_dir().join("pred_test_solver_repeatability.json");
+    let problem = serde_json::json!({
+        "type": "RootedTreeArrangement",
+        "variant": {"graph": "SimpleGraph"},
+        "data": {
+            "graph": {"num_vertices": 3, "edges": [[0, 1], [1, 2]]},
+            "bound": 3
+        }
+    });
+    std::fs::write(&problem_file, serde_json::to_vec(&problem).unwrap()).unwrap();
+
+    for solver in [None, Some("customized"), Some("ilp"), Some("brute-force")] {
+        let run = || {
+            let mut command = pred();
+            command.args(["--json", "solve", problem_file.to_str().unwrap()]);
+            if let Some(solver) = solver {
+                command.args(["--solver", solver]);
+            }
+            command.output().unwrap()
+        };
+        let first = run();
+        let second = run();
+        assert!(
+            first.status.success(),
+            "first {solver:?} solve failed: {}",
+            String::from_utf8_lossy(&first.stderr)
+        );
+        assert!(
+            second.status.success(),
+            "second {solver:?} solve failed: {}",
+            String::from_utf8_lossy(&second.stderr)
+        );
+        assert_eq!(first.stdout, second.stdout, "{solver:?} output changed");
+    }
 
     std::fs::remove_file(&problem_file).ok();
 }
 
 #[test]
-fn test_solve_customized_minimum_cardinality_key() {
+fn deterministic_solver_dispatch_defaults_minimum_cardinality_key_to_customized() {
     let problem_file = std::env::temp_dir().join("pred_test_solve_customized_mck.json");
     let create_out = pred()
         .args([
@@ -8538,12 +9401,7 @@ fn test_solve_customized_minimum_cardinality_key() {
     );
 
     let output = pred()
-        .args([
-            "solve",
-            problem_file.to_str().unwrap(),
-            "--solver",
-            "customized",
-        ])
+        .args(["solve", problem_file.to_str().unwrap()])
         .output()
         .unwrap();
     assert!(
@@ -8552,9 +9410,11 @@ fn test_solve_customized_minimum_cardinality_key() {
         String::from_utf8_lossy(&output.stderr)
     );
     let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(
-        stdout.contains("customized"),
-        "expected 'customized' in output, got: {stdout}"
+    let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
+    assert_eq!(json["solver"]["kind"], "customized");
+    assert_eq!(
+        json["solver"]["implementation"],
+        "fd-minimum-cardinality-key"
     );
     assert!(
         stdout.contains("Min("),
@@ -8565,7 +9425,7 @@ fn test_solve_customized_minimum_cardinality_key() {
 }
 
 #[test]
-fn test_solve_customized_bundle_does_not_panic() {
+fn test_solve_bundle_rejects_unavailable_customized_solver_without_panicking() {
     let problem_file = std::env::temp_dir().join("pred_test_solve_customized_bundle_problem.json");
     let bundle_file = std::env::temp_dir().join("pred_test_solve_customized_bundle.json");
 
@@ -8582,17 +9442,19 @@ fn test_solve_customized_bundle_does_not_panic() {
         .unwrap();
     assert!(create_out.status.success());
 
-    let reduce_out = pred()
-        .args([
-            "-o",
-            bundle_file.to_str().unwrap(),
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    let reduce_out = reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-        ])
-        .output()
-        .unwrap();
+        ],
+        &bundle_file,
+    );
     assert!(
         reduce_out.status.success(),
         "reduce failed: {}",
@@ -8611,15 +9473,15 @@ fn test_solve_customized_bundle_does_not_panic() {
     let stderr = String::from_utf8_lossy(&solve_out.stderr);
     assert!(
         !stderr.contains("panicked at"),
-        "customized bundle solve should fail gracefully, got: {stderr}"
+        "unavailable customized solver should fail gracefully, got: {stderr}"
     );
     assert!(
         !solve_out.status.success(),
-        "customized solver should not silently succeed on unsupported bundle target"
+        "unavailable customized solver should not silently succeed"
     );
     assert!(
-        stderr.contains("unsupported by customized solver"),
-        "expected customized solver error, got: {stderr}"
+        stderr.contains("No customized solver is registered"),
+        "expected missing customized capability error, got: {stderr}"
     );
 
     std::fs::remove_file(&problem_file).ok();
@@ -8627,7 +9489,7 @@ fn test_solve_customized_bundle_does_not_panic() {
 }
 
 #[test]
-fn test_inspect_minimum_cardinality_key_lists_customized_solver() {
+fn test_inspect_minimum_cardinality_key_reports_customized_capability() {
     let problem_file = std::env::temp_dir().join("pred_test_inspect_customized_mck.json");
     let create_out = pred()
         .args([
@@ -8660,21 +9522,16 @@ fn test_inspect_minimum_cardinality_key_lists_customized_solver() {
 
     let stdout = String::from_utf8(inspect_out.stdout).unwrap();
     let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
-    let solvers: Vec<&str> = json["solvers"]
-        .as_array()
-        .unwrap()
-        .iter()
-        .map(|value| value.as_str().unwrap())
-        .collect();
-    assert!(
-        solvers.contains(&"customized"),
-        "inspect should list customized when supported, got: {json}"
+    assert_eq!(json["default_solver"], "customized");
+    assert_eq!(
+        json["solver_capabilities"]["customized"]["implementation"],
+        "fd-minimum-cardinality-key"
     );
 
     std::fs::remove_file(&problem_file).ok();
 }
 
-/// Solve a bundle with brute-force and return `(target_config_csv, source_evaluation)`.
+/// Solve a bundle with brute-force and return `(target_solution_json, source_evaluation)`.
 ///
 /// Used by extract tests so they do not depend on the exact reduction path chosen
 /// (which differs between `--features mcp` and default builds).
@@ -8695,14 +9552,9 @@ fn extract_test_solve_bundle(bundle_file: &std::path::Path) -> (String, String)
         String::from_utf8_lossy(&solve_out.stderr)
     );
     let json: serde_json::Value = serde_json::from_slice(&solve_out.stdout).unwrap();
-    let target_cfg: Vec<String> = json["intermediate"]["solution"]
-        .as_array()
-        .unwrap()
-        .iter()
-        .map(|v| v.as_u64().unwrap().to_string())
-        .collect();
+    let target_solution = json["intermediate"]["solution"].to_string();
     let source_eval = json["evaluation"].as_str().unwrap().to_string();
-    (target_cfg.join(","), source_eval)
+    (target_solution, source_eval)
 }
 
 #[test]
@@ -8723,27 +9575,27 @@ fn test_extract_roundtrip_mis_to_qubo() {
         .unwrap();
     assert!(create_out.status.success());
 
-    let reduce_out = pred()
-        .args([
-            "-o",
-            bundle_file.to_str().unwrap(),
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    let reduce_out = reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-        ])
-        .output()
-        .unwrap();
+        ],
+        &bundle_file,
+    );
     assert!(
         reduce_out.status.success(),
         "reduce stderr: {}",
         String::from_utf8_lossy(&reduce_out.stderr)
     );
 
-    // Derive a valid target config from `pred solve`, so this test works
-    // regardless of which reduction path is chosen (path length varies with
-    // feature flags — e.g. mcp build picks MIS -> ... -> ILP -> QUBO instead
-    // of the shorter MaxSetPacking -> QUBO path).
+    // Derive a valid target config from `pred solve`, so this test remains
+    // independent of the reduction path selected by the graph search.
     let (target_cfg, expected_source_eval) = extract_test_solve_bundle(&bundle_file);
 
     let extract_out = pred()
@@ -8772,26 +9624,19 @@ fn test_extract_roundtrip_mis_to_qubo() {
 
     // intermediate.solution must be exactly the target config we passed in
     // (extract echoes the input target config unchanged).
-    let expected_target: Vec<serde_json::Value> = target_cfg
-        .split(',')
-        .map(|s| serde_json::json!(s.parse::<u64>().unwrap()))
-        .collect();
-    assert_eq!(
-        json["intermediate"]["solution"].as_array().unwrap(),
-        &expected_target
-    );
+    let expected_target: serde_json::Value = serde_json::from_str(&target_cfg).unwrap();
+    assert_eq!(json["intermediate"]["solution"], expected_target);
 
     // Source config is over 4 MIS variables and must describe an independent set
     // whose size matches `expected_source_eval` (e.g. "Max(2)" -> 2 ones).
-    let source_sol: Vec<u64> = json["solution"]
+    let source_sol: Vec<bool> = json["solution"]
         .as_array()
         .unwrap()
         .iter()
-        .map(|v| v.as_u64().unwrap())
+        .map(|v| v.as_bool().unwrap())
         .collect();
     assert_eq!(source_sol.len(), 4);
-    assert!(source_sol.iter().all(|b| *b == 0 || *b == 1));
-    let ones = source_sol.iter().filter(|b| **b == 1).count();
+    let ones = source_sol.iter().filter(|&&selected| selected).count();
     assert_eq!(
         expected_source_eval,
         format!("Max({ones})"),
@@ -8802,6 +9647,63 @@ fn test_extract_roundtrip_mis_to_qubo() {
     std::fs::remove_file(&bundle_file).ok();
 }
 
+#[test]
+fn test_extract_rejects_structurally_invalid_one_hot_config() {
+    let problem_file = std::env::temp_dir().join("pred_test_extract_tsp_in.json");
+    let bundle_file = std::env::temp_dir().join("pred_test_extract_tsp_bundle.json");
+
+    let create_out = pred()
+        .args([
+            "-o",
+            problem_file.to_str().unwrap(),
+            "create",
+            "TSP",
+            "--graph",
+            "0-1,1-2,0-2",
+            "--edge-weights",
+            "1,1,1",
+        ])
+        .output()
+        .unwrap();
+    assert!(
+        create_out.status.success(),
+        "create stderr: {}",
+        String::from_utf8_lossy(&create_out.stderr)
+    );
+
+    let reduce_out = reduce_named_to_file(
+        &problem_file,
+        "TSP/SimpleGraph/i64",
+        "QUBO",
+        &["TravelingSalesman", "QUBO"],
+        &bundle_file,
+    );
+    assert!(
+        reduce_out.status.success(),
+        "reduce stderr: {}",
+        String::from_utf8_lossy(&reduce_out.stderr)
+    );
+
+    let extract_out = pred()
+        .args([
+            "extract",
+            bundle_file.to_str().unwrap(),
+            "--config",
+            "[false,false,false,false,false,false,false,false,false]",
+        ])
+        .output()
+        .unwrap();
+    assert!(!extract_out.status.success());
+    let stderr = String::from_utf8(extract_out.stderr).unwrap();
+    assert!(
+        stderr.contains("tour position 0 does not select exactly one vertex"),
+        "unexpected stderr: {stderr}"
+    );
+
+    std::fs::remove_file(&problem_file).ok();
+    std::fs::remove_file(&bundle_file).ok();
+}
+
 #[test]
 fn test_extract_rejects_plain_problem_file() {
     let problem_file = std::env::temp_dir().join("pred_test_extract_plain.json");
@@ -8824,7 +9726,7 @@ fn test_extract_rejects_plain_problem_file() {
             "extract",
             problem_file.to_str().unwrap(),
             "--config",
-            "0,1,0",
+            "[false,true,false]",
         ])
         .output()
         .unwrap();
@@ -8854,26 +9756,33 @@ fn test_extract_rejects_wrong_config_length() {
         ])
         .output()
         .unwrap();
-    pred()
-        .args([
-            "-o",
-            bundle_file.to_str().unwrap(),
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-        ])
-        .output()
-        .unwrap();
+        ],
+        &bundle_file,
+    );
 
     let extract_out = pred()
-        .args(["extract", bundle_file.to_str().unwrap(), "--config", "0,1"])
+        .args([
+            "extract",
+            bundle_file.to_str().unwrap(),
+            "--config",
+            "[false,true]",
+        ])
         .output()
         .unwrap();
     assert!(!extract_out.status.success());
     let stderr = String::from_utf8(extract_out.stderr).unwrap();
     assert!(
-        stderr.contains("Target config has 2 values"),
+        stderr.contains("solution has 2 variables, expected"),
         "unexpected stderr: {stderr}"
     );
 
@@ -8882,7 +9791,7 @@ fn test_extract_rejects_wrong_config_length() {
 }
 
 #[test]
-fn test_extract_rejects_out_of_range_config_value() {
+fn test_extract_rejects_non_boolean_solution_value() {
     let problem_file = std::env::temp_dir().join("pred_test_extract_range_in.json");
     let bundle_file = std::env::temp_dir().join("pred_test_extract_range_bundle.json");
 
@@ -8897,24 +9806,26 @@ fn test_extract_rejects_out_of_range_config_value() {
         ])
         .output()
         .unwrap();
-    pred()
-        .args([
-            "-o",
-            bundle_file.to_str().unwrap(),
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-        ])
-        .output()
-        .unwrap();
+        ],
+        &bundle_file,
+    );
 
-    // Build a valid-length config from pred solve, then flip one entry to 9
-    // (always out of range for a binary QUBO regardless of path).
+    // Build a valid semantic solution from pred solve, then replace one Boolean
+    // entry with an integer.
     let (target_cfg, _) = extract_test_solve_bundle(&bundle_file);
-    let mut parts: Vec<String> = target_cfg.split(',').map(|s| s.to_string()).collect();
-    parts[0] = "9".to_string();
-    let bad_cfg = parts.join(",");
+    let mut bad_cfg: serde_json::Value = serde_json::from_str(&target_cfg).unwrap();
+    bad_cfg.as_array_mut().unwrap()[0] = serde_json::json!(9);
+    let bad_cfg = bad_cfg.to_string();
 
     let extract_out = pred()
         .args([
@@ -8928,7 +9839,7 @@ fn test_extract_rejects_out_of_range_config_value() {
     assert!(!extract_out.status.success());
     let stderr = String::from_utf8(extract_out.stderr).unwrap();
     assert!(
-        stderr.contains("out of range"),
+        stderr.contains("invalid solution JSON"),
         "unexpected stderr: {stderr}"
     );
 
@@ -8955,17 +9866,19 @@ fn test_extract_rejects_malformed_bundle_path_source_mismatch() {
         ])
         .output()
         .unwrap();
-    pred()
-        .args([
-            "-o",
-            bundle_file.to_str().unwrap(),
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-        ])
-        .output()
-        .unwrap();
+        ],
+        &bundle_file,
+    );
 
     let bundle_text = std::fs::read_to_string(&bundle_file).unwrap();
     let mut bundle: serde_json::Value = serde_json::from_str(&bundle_text).unwrap();
@@ -8979,7 +9892,7 @@ fn test_extract_rejects_malformed_bundle_path_source_mismatch() {
             "extract",
             tampered_file.to_str().unwrap(),
             "--config",
-            "0,1,0",
+            "[false,true,false]",
         ])
         .output()
         .unwrap();
@@ -9019,17 +9932,19 @@ fn test_extract_rejects_tampered_target_data() {
         ])
         .output()
         .unwrap();
-    pred()
-        .args([
-            "-o",
-            bundle_file.to_str().unwrap(),
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-        ])
-        .output()
-        .unwrap();
+        ],
+        &bundle_file,
+    );
 
     // Tamper: flip one QUBO matrix entry so target.data no longer matches
     // what the reduction chain actually produces.
@@ -9104,17 +10019,19 @@ fn test_extract_reads_bundle_from_stdin() {
         ])
         .output()
         .unwrap();
-    pred()
-        .args([
-            "-o",
-            bundle_file.to_str().unwrap(),
-            "reduce",
-            problem_file.to_str().unwrap(),
-            "--to",
+    reduce_named_to_file(
+        &problem_file,
+        "MIS/SimpleGraph/One",
+        "QUBO/f64",
+        &[
+            "MaximumIndependentSet",
+            "MaximumIndependentSet",
+            "MaximumSetPacking",
+            "MaximumSetPacking",
             "QUBO",
-        ])
-        .output()
-        .unwrap();
+        ],
+        &bundle_file,
+    );
     let (target_cfg, _) = extract_test_solve_bundle(&bundle_file);
     let bundle_text = std::fs::read_to_string(&bundle_file).unwrap();
 
diff --git a/problemreductions-cli/tests/pred_sym_tests.rs b/problemreductions-cli/tests/pred_sym_tests.rs
index 64b424d2a..0cf2b8802 100644
--- a/problemreductions-cli/tests/pred_sym_tests.rs
+++ b/problemreductions-cli/tests/pred_sym_tests.rs
@@ -9,15 +9,14 @@ fn test_pred_sym_parse() {
     let output = pred_sym().args(["parse", "n + m"]).output().unwrap();
     assert!(output.status.success());
     let stdout = String::from_utf8(output.stdout).unwrap();
-    assert_eq!(stdout.trim(), "n + m");
+    assert_eq!(stdout.trim(), "m + n");
 }
 
 #[test]
-fn test_pred_sym_canon_merge_terms() {
+fn test_pred_sym_canon_subcommand_removed() {
+    // The exact-canonical-form engine is gone; `canon` is no longer a subcommand.
     let output = pred_sym().args(["canon", "n + n"]).output().unwrap();
-    assert!(output.status.success());
-    let stdout = String::from_utf8(output.stdout).unwrap();
-    assert_eq!(stdout.trim(), "2 * n");
+    assert!(!output.status.success());
 }
 
 #[test]
@@ -52,15 +51,11 @@ fn test_pred_sym_big_o_signed_polynomial() {
 }
 
 #[test]
-fn test_pred_sym_big_o_sqrt_display() {
-    let output = pred_sym().args(["big-o", "2^(n^(1/2))"]).output().unwrap();
+fn test_pred_sym_big_o_preserves_fractional_degrees() {
+    let output = pred_sym().args(["big-o", "sqrt(n * m)"]).output().unwrap();
     assert!(output.status.success());
     let stdout = String::from_utf8(output.stdout).unwrap();
-    assert!(
-        stdout.contains("sqrt"),
-        "expected sqrt notation, got: {}",
-        stdout.trim()
-    );
+    assert_eq!(stdout.trim(), "O(m^0.5 * n^0.5)");
 }
 
 #[test]
@@ -173,6 +168,20 @@ fn test_pred_sym_eval_unbound_variable_error() {
     );
 }
 
+#[test]
+fn test_pred_sym_eval_non_finite_result_is_an_error() {
+    let output = pred_sym()
+        .args(["eval", "log(n)", "--vars", "n=0"])
+        .output()
+        .unwrap();
+    assert!(!output.status.success());
+    let stderr = String::from_utf8(output.stderr).unwrap();
+    assert!(
+        stderr.contains("no finite real approximation"),
+        "got: {stderr}"
+    );
+}
+
 #[test]
 fn test_pred_sym_compare_unequal_exits_nonzero() {
     let output = pred_sym().args(["compare", "n^2", "n^3"]).output().unwrap();
diff --git a/problemreductions-expr/Cargo.toml b/problemreductions-expr/Cargo.toml
new file mode 100644
index 000000000..d19a1b770
--- /dev/null
+++ b/problemreductions-expr/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "problemreductions-expr"
+version = "0.6.0"
+edition = "2021"
+description = "Lossless symbolic expressions for problemreductions"
+license = "MIT"
+repository = "https://github.com/CodingThrust/problem-reductions"
+
+[dependencies]
+num-bigint = { version = "0.4", features = ["serde"] }
+num-rational = { version = "0.4", features = ["serde"] }
+num-traits = "0.2"
+serde = { version = "1.0", features = ["derive"] }
+thiserror = "2.0"
+
+[dev-dependencies]
+serde_json = "1.0"
diff --git a/problemreductions-expr/src/lib.rs b/problemreductions-expr/src/lib.rs
new file mode 100644
index 000000000..0d746b119
--- /dev/null
+++ b/problemreductions-expr/src/lib.rs
@@ -0,0 +1,1363 @@
+//! Lossless symbolic expressions shared by the runtime library and proc macros.
+
+use num_bigint::BigInt;
+use num_rational::BigRational;
+use num_traits::{One, Signed, Zero};
+use std::collections::{BTreeSet, HashMap, HashSet};
+use std::fmt;
+use std::str::FromStr;
+use std::sync::Arc;
+
+/// A validated problem-size variable name.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize)]
+#[serde(transparent)]
+pub struct Symbol(Box<str>);
+
+impl Symbol {
+    pub fn new(name: impl Into<Box<str>>) -> Result<Self, InvalidSymbol> {
+        let name = name.into();
+        if is_valid_symbol(&name) {
+            Ok(Self(name))
+        } else {
+            Err(InvalidSymbol(name))
+        }
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+impl AsRef<str> for Symbol {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl fmt::Display for Symbol {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(self.as_str())
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Symbol {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let name = Box::<str>::deserialize(deserializer)?;
+        Self::new(name).map_err(serde::de::Error::custom)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+#[error("invalid expression variable name {0:?}")]
+pub struct InvalidSymbol(Box<str>);
+
+fn is_valid_symbol(name: &str) -> bool {
+    let mut bytes = name.bytes();
+    let Some(first) = bytes.next() else {
+        return false;
+    };
+    if !(first.is_ascii_alphabetic() || first == b'_')
+        || !bytes.all(|byte| byte.is_ascii_alphanumeric() || byte == b'_')
+        || name == "_"
+    {
+        return false;
+    }
+    !matches!(
+        name,
+        "abstract"
+            | "as"
+            | "async"
+            | "await"
+            | "become"
+            | "box"
+            | "break"
+            | "const"
+            | "continue"
+            | "crate"
+            | "do"
+            | "dyn"
+            | "else"
+            | "enum"
+            | "extern"
+            | "false"
+            | "final"
+            | "fn"
+            | "for"
+            | "gen"
+            | "if"
+            | "impl"
+            | "in"
+            | "let"
+            | "loop"
+            | "macro"
+            | "match"
+            | "mod"
+            | "move"
+            | "mut"
+            | "override"
+            | "priv"
+            | "pub"
+            | "ref"
+            | "return"
+            | "self"
+            | "Self"
+            | "static"
+            | "struct"
+            | "super"
+            | "trait"
+            | "true"
+            | "try"
+            | "type"
+            | "typeof"
+            | "union"
+            | "unsafe"
+            | "unsized"
+            | "use"
+            | "virtual"
+            | "where"
+            | "while"
+            | "yield"
+    )
+}
+
+/// One immutable node in a symbolic expression DAG.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ExprNode {
+    Const(BigRational),
+    Var(Symbol),
+    Add(Box<[Expr]>),
+    Mul(Box<[Expr]>),
+    Pow(Expr, Expr),
+    Exp(Expr),
+    Log(Expr),
+    Factorial(Expr),
+}
+
+/// A cheap, immutable handle to a shared symbolic expression node.
+#[derive(Clone, Debug)]
+pub struct Expr(Arc<ExprNode>);
+
+impl PartialEq for Expr {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.0, &other.0) || self.node() == other.node()
+    }
+}
+
+impl Eq for Expr {}
+
+impl std::hash::Hash for Expr {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        std::hash::Hash::hash(self.node(), state);
+    }
+}
+
+impl PartialOrd for Expr {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Expr {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        if Arc::ptr_eq(&self.0, &other.0) {
+            std::cmp::Ordering::Equal
+        } else {
+            self.node().cmp(other.node())
+        }
+    }
+}
+
+/// Opaque identity used to memoize one traversal of an expression DAG.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct ExprNodeId(usize);
+
+impl serde::Serialize for Expr {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        ExprDocument::from_expression(self).serialize(serializer)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Expr {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        ExprDocument::deserialize(deserializer)?
+            .into_expression()
+            .map_err(serde::de::Error::custom)
+    }
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+struct ExprDocument {
+    nodes: Vec<SerializedNode>,
+    root: usize,
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+enum SerializedNode {
+    Const(BigRational),
+    Var(Symbol),
+    Add(Vec<usize>),
+    Mul(Vec<usize>),
+    Pow(usize, usize),
+    Exp(usize),
+    Log(usize),
+    Factorial(usize),
+}
+
+impl ExprDocument {
+    fn from_expression(root: &Expr) -> Self {
+        let mut ids = HashMap::new();
+        let mut nodes = Vec::new();
+        let mut pending = vec![(root, false)];
+        while let Some((expression, expanded)) = pending.pop() {
+            if ids.contains_key(&expression.node_identity()) {
+                continue;
+            }
+            if !expanded {
+                pending.push((expression, true));
+                match expression.node() {
+                    ExprNode::Add(values) | ExprNode::Mul(values) => {
+                        pending.extend(values.iter().rev().map(|value| (value, false)));
+                    }
+                    ExprNode::Pow(base, exponent) => {
+                        pending.push((exponent, false));
+                        pending.push((base, false));
+                    }
+                    ExprNode::Exp(value) | ExprNode::Log(value) | ExprNode::Factorial(value) => {
+                        pending.push((value, false))
+                    }
+                    ExprNode::Const(_) | ExprNode::Var(_) => {}
+                }
+                continue;
+            }
+
+            let child_id = |child: &Expr| ids[&child.node_identity()];
+            let node = match expression.node() {
+                ExprNode::Const(value) => SerializedNode::Const(value.clone()),
+                ExprNode::Var(symbol) => SerializedNode::Var(symbol.clone()),
+                ExprNode::Add(values) => SerializedNode::Add(values.iter().map(child_id).collect()),
+                ExprNode::Mul(values) => SerializedNode::Mul(values.iter().map(child_id).collect()),
+                ExprNode::Pow(base, exponent) => {
+                    SerializedNode::Pow(child_id(base), child_id(exponent))
+                }
+                ExprNode::Exp(value) => SerializedNode::Exp(child_id(value)),
+                ExprNode::Log(value) => SerializedNode::Log(child_id(value)),
+                ExprNode::Factorial(value) => SerializedNode::Factorial(child_id(value)),
+            };
+            let id = nodes.len();
+            nodes.push(node);
+            ids.insert(expression.node_identity(), id);
+        }
+        Self {
+            nodes,
+            root: ids[&root.node_identity()],
+        }
+    }
+
+    fn into_expression(self) -> Result<Expr, InvalidExpressionDocument> {
+        let mut expressions = Vec::with_capacity(self.nodes.len());
+        for (node_id, node) in self.nodes.into_iter().enumerate() {
+            let child = |id: usize| {
+                expressions
+                    .get(id)
+                    .cloned()
+                    .ok_or(InvalidExpressionDocument::UnavailableChild { node_id, id })
+            };
+            let expression = match node {
+                SerializedNode::Const(value) => Expr::constant(value),
+                SerializedNode::Var(symbol) => Expr::from_node(ExprNode::Var(symbol)),
+                SerializedNode::Add(ids) => {
+                    Expr::add_all(ids.into_iter().map(child).collect::<Result<_, _>>()?)
+                }
+                SerializedNode::Mul(ids) => {
+                    Expr::mul_all(ids.into_iter().map(child).collect::<Result<_, _>>()?)
+                }
+                SerializedNode::Pow(base, exponent) => Expr::pow(child(base)?, child(exponent)?),
+                SerializedNode::Exp(value) => Expr::exp(child(value)?),
+                SerializedNode::Log(value) => Expr::log(child(value)?),
+                SerializedNode::Factorial(value) => Expr::factorial(child(value)?),
+            };
+            expressions.push(expression);
+        }
+        expressions
+            .get(self.root)
+            .cloned()
+            .ok_or(InvalidExpressionDocument::UnavailableRoot(self.root))
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+enum InvalidExpressionDocument {
+    #[error("expression node {node_id} references unavailable child node {id}")]
+    UnavailableChild { node_id: usize, id: usize },
+    #[error("expression root references unavailable node {0}")]
+    UnavailableRoot(usize),
+}
+
+impl Expr {
+    fn from_node(node: ExprNode) -> Self {
+        Self(Arc::new(node))
+    }
+
+    pub fn node(&self) -> &ExprNode {
+        &self.0
+    }
+
+    /// Identity of this allocation for operation-local DAG memoization.
+    /// The value is process-local and remains valid while any clone of the node lives.
+    pub fn node_identity(&self) -> ExprNodeId {
+        ExprNodeId(Arc::as_ptr(&self.0) as usize)
+    }
+
+    pub fn integer(value: impl Into<BigInt>) -> Self {
+        Self::constant(BigRational::from_integer(value.into()))
+    }
+
+    pub fn rational(numerator: impl Into<BigInt>, denominator: impl Into<BigInt>) -> Self {
+        Self::constant(BigRational::new(numerator.into(), denominator.into()))
+    }
+
+    pub fn constant(value: BigRational) -> Self {
+        Self::from_node(ExprNode::Const(value))
+    }
+
+    pub fn variable(name: impl Into<Box<str>>) -> Self {
+        Self::try_variable(name).unwrap_or_else(|error| panic!("{error}"))
+    }
+
+    pub fn try_variable(name: impl Into<Box<str>>) -> Result<Self, InvalidSymbol> {
+        Symbol::new(name).map(|symbol| Self::from_node(ExprNode::Var(symbol)))
+    }
+
+    pub fn pow(base: Expr, exponent: Expr) -> Self {
+        if exponent.is_exact_integer(0) || base.is_exact_integer(1) {
+            return Self::integer(1);
+        }
+        if exponent.is_exact_integer(1) {
+            return base;
+        }
+        Self::from_node(ExprNode::Pow(base, exponent))
+    }
+
+    pub fn exp(value: Expr) -> Self {
+        Self::from_node(ExprNode::Exp(value))
+    }
+
+    pub fn log(value: Expr) -> Self {
+        Self::from_node(ExprNode::Log(value))
+    }
+
+    pub fn sqrt(value: Expr) -> Self {
+        Self::pow(value, Self::rational(1, 2))
+    }
+
+    pub fn factorial(value: Expr) -> Self {
+        Self::from_node(ExprNode::Factorial(value))
+    }
+
+    pub fn parse(input: &str) -> Self {
+        Self::try_parse(input)
+            .unwrap_or_else(|error| panic!("failed to parse expression {input:?}: {error}"))
+    }
+
+    pub fn try_parse(input: &str) -> Result<Self, ParseError> {
+        Parser::new(tokenize(input)?).parse()
+    }
+
+    pub fn variables(&self) -> BTreeSet<&str> {
+        let mut variables = BTreeSet::new();
+        let mut visited = HashSet::new();
+        self.collect_variables(&mut variables, &mut visited);
+        variables
+    }
+
+    fn collect_variables<'a>(
+        &'a self,
+        variables: &mut BTreeSet<&'a str>,
+        visited: &mut HashSet<ExprNodeId>,
+    ) {
+        if !visited.insert(self.node_identity()) {
+            return;
+        }
+        match self.node() {
+            ExprNode::Const(_) => {}
+            ExprNode::Var(name) => {
+                variables.insert(name.as_str());
+            }
+            ExprNode::Add(values) | ExprNode::Mul(values) => {
+                for value in values {
+                    value.collect_variables(variables, visited);
+                }
+            }
+            ExprNode::Pow(base, exponent) => {
+                base.collect_variables(variables, visited);
+                exponent.collect_variables(variables, visited);
+            }
+            ExprNode::Exp(value) | ExprNode::Log(value) | ExprNode::Factorial(value) => {
+                value.collect_variables(variables, visited);
+            }
+        }
+    }
+
+    /// Replace every variable or report the complete set of missing replacements.
+    pub fn substitute_complete(
+        &self,
+        replacements: &HashMap<&str, &Expr>,
+    ) -> Result<Expr, SubstitutionError> {
+        self.substitute_inner(replacements, &mut HashMap::new())
+            .map_err(SubstitutionError::new)
+    }
+
+    fn substitute_inner(
+        &self,
+        replacements: &HashMap<&str, &Expr>,
+        memo: &mut HashMap<ExprNodeId, Result<Expr, BTreeSet<Box<str>>>>,
+    ) -> Result<Expr, BTreeSet<Box<str>>> {
+        let identity = self.node_identity();
+        if let Some(result) = memo.get(&identity) {
+            return result.clone();
+        }
+        let result = match self.node() {
+            ExprNode::Const(_) => Ok(self.clone()),
+            ExprNode::Var(name) => match replacements.get(name.as_ref()) {
+                Some(replacement) => Ok((*replacement).clone()),
+                None => Err(BTreeSet::from([name.as_str().into()])),
+            },
+            ExprNode::Add(values) => {
+                Self::substitute_values(values, replacements, memo).map(Self::add_all)
+            }
+            ExprNode::Mul(values) => {
+                Self::substitute_values(values, replacements, memo).map(Self::mul_all)
+            }
+            ExprNode::Pow(base, exponent) => {
+                let base = base.substitute_inner(replacements, memo);
+                let exponent = exponent.substitute_inner(replacements, memo);
+                match (base, exponent) {
+                    (Ok(base), Ok(exponent)) => Ok(Self::pow(base, exponent)),
+                    (Err(mut left), Err(right)) => {
+                        left.extend(right);
+                        Err(left)
+                    }
+                    (Err(missing), _) | (_, Err(missing)) => Err(missing),
+                }
+            }
+            ExprNode::Exp(value) => value.substitute_inner(replacements, memo).map(Self::exp),
+            ExprNode::Log(value) => value.substitute_inner(replacements, memo).map(Self::log),
+            ExprNode::Factorial(value) => value
+                .substitute_inner(replacements, memo)
+                .map(Self::factorial),
+        };
+        memo.insert(identity, result.clone());
+        result
+    }
+
+    fn substitute_values(
+        values: &[Expr],
+        replacements: &HashMap<&str, &Expr>,
+        memo: &mut HashMap<ExprNodeId, Result<Expr, BTreeSet<Box<str>>>>,
+    ) -> Result<Vec<Expr>, BTreeSet<Box<str>>> {
+        let mut substituted = Vec::with_capacity(values.len());
+        let mut missing = BTreeSet::new();
+        for value in values {
+            match value.substitute_inner(replacements, memo) {
+                Ok(value) => substituted.push(value),
+                Err(variables) => missing.extend(variables),
+            }
+        }
+        if missing.is_empty() {
+            Ok(substituted)
+        } else {
+            Err(missing)
+        }
+    }
+
+    pub fn is_constant(&self) -> bool {
+        self.is_constant_inner(&mut HashMap::new())
+    }
+
+    fn is_constant_inner(&self, memo: &mut HashMap<ExprNodeId, bool>) -> bool {
+        if let Some(result) = memo.get(&self.node_identity()) {
+            return *result;
+        }
+        let result = match self.node() {
+            ExprNode::Const(_) => true,
+            ExprNode::Var(_) => false,
+            ExprNode::Add(values) | ExprNode::Mul(values) => {
+                values.iter().all(|value| value.is_constant_inner(memo))
+            }
+            ExprNode::Pow(base, exponent) => {
+                base.is_constant_inner(memo) && exponent.is_constant_inner(memo)
+            }
+            ExprNode::Exp(value) | ExprNode::Log(value) | ExprNode::Factorial(value) => {
+                value.is_constant_inner(memo)
+            }
+        };
+        memo.insert(self.node_identity(), result);
+        result
+    }
+
+    pub fn is_polynomial(&self) -> bool {
+        self.is_polynomial_inner(&mut HashMap::new())
+    }
+
+    fn is_polynomial_inner(&self, polynomial_memo: &mut HashMap<ExprNodeId, bool>) -> bool {
+        if let Some(result) = polynomial_memo.get(&self.node_identity()) {
+            return *result;
+        }
+        let result = match self.node() {
+            ExprNode::Const(_) | ExprNode::Var(_) => true,
+            ExprNode::Add(values) | ExprNode::Mul(values) => values
+                .iter()
+                .all(|value| value.is_polynomial_inner(polynomial_memo)),
+            ExprNode::Pow(base, exponent) => {
+                (matches!((base.node(), exponent.node()),
+                    (ExprNode::Const(base), ExprNode::Const(exponent))
+                        if exponent.is_integer()
+                            && (!exponent.is_negative() || !base.is_zero())))
+                    || (base.is_polynomial_inner(polynomial_memo)
+                        && matches!(exponent.node(), ExprNode::Const(value) if value.is_integer() && !value.is_negative()))
+            }
+            ExprNode::Exp(_) | ExprNode::Log(_) | ExprNode::Factorial(_) => false,
+        };
+        polynomial_memo.insert(self.node_identity(), result);
+        result
+    }
+
+    pub fn is_valid_complexity_notation(&self) -> bool {
+        self.complexity_notation_analysis(&mut HashMap::new()).1
+    }
+
+    fn complexity_notation_analysis(
+        &self,
+        memo: &mut HashMap<ExprNodeId, (bool, bool)>,
+    ) -> (bool, bool) {
+        if let Some(analysis) = memo.get(&self.node_identity()) {
+            return *analysis;
+        }
+        let analysis = match self.node() {
+            ExprNode::Const(value) => (true, value.is_one()),
+            ExprNode::Var(_) => (false, true),
+            ExprNode::Add(values) | ExprNode::Mul(values) => {
+                let mut all_constant = true;
+                let mut all_valid_nonconstant = true;
+                for value in values {
+                    let (constant, valid) = value.complexity_notation_analysis(memo);
+                    all_constant &= constant;
+                    all_valid_nonconstant &= !constant && valid;
+                }
+                (all_constant, all_valid_nonconstant)
+            }
+            ExprNode::Pow(base, exponent) => {
+                let base_analysis = base.complexity_notation_analysis(memo);
+                let exponent_analysis = exponent.complexity_notation_analysis(memo);
+                let base_valid = match base.node() {
+                    ExprNode::Const(value) => value.is_positive(),
+                    _ => base_analysis.1,
+                };
+                (
+                    base_analysis.0 && exponent_analysis.0,
+                    base_valid && (exponent_analysis.0 || exponent_analysis.1),
+                )
+            }
+            ExprNode::Exp(value) | ExprNode::Log(value) | ExprNode::Factorial(value) => {
+                value.complexity_notation_analysis(memo)
+            }
+        };
+        memo.insert(self.node_identity(), analysis);
+        analysis
+    }
+
+    pub fn unique_node_count(&self) -> usize {
+        let mut visited = HashSet::new();
+        let mut pending = vec![self];
+        while let Some(expression) = pending.pop() {
+            if !visited.insert(expression.node_identity()) {
+                continue;
+            }
+            match expression.node() {
+                ExprNode::Add(values) | ExprNode::Mul(values) => pending.extend(values),
+                ExprNode::Pow(base, exponent) => {
+                    pending.push(base);
+                    pending.push(exponent);
+                }
+                ExprNode::Exp(value) | ExprNode::Log(value) | ExprNode::Factorial(value) => {
+                    pending.push(value);
+                }
+                ExprNode::Const(_) | ExprNode::Var(_) => {}
+            }
+        }
+        visited.len()
+    }
+
+    fn is_exact_integer(&self, expected: i64) -> bool {
+        matches!(self.node(), ExprNode::Const(value) if *value == BigRational::from_integer(expected.into()))
+    }
+
+    fn add_all(values: Vec<Expr>) -> Expr {
+        let mut constant = BigRational::zero();
+        let mut coefficients: std::collections::BTreeMap<Expr, BigRational> =
+            std::collections::BTreeMap::new();
+        let mut pending = values;
+        while let Some(value) = pending.pop() {
+            match value.node() {
+                ExprNode::Add(nested) => pending.extend(nested.iter().cloned()),
+                ExprNode::Const(value) => constant += value,
+                ExprNode::Mul(factors)
+                    if matches!(factors.first().map(Expr::node), Some(ExprNode::Const(_))) =>
+                {
+                    let ExprNode::Const(coefficient) = factors[0].node() else {
+                        unreachable!()
+                    };
+                    let base = Self::mul_all(factors[1..].to_vec());
+                    *coefficients.entry(base).or_insert_with(BigRational::zero) += coefficient;
+                }
+                _ => {
+                    *coefficients.entry(value).or_insert_with(BigRational::zero) +=
+                        BigRational::one();
+                }
+            }
+        }
+        let mut terms = Vec::with_capacity(coefficients.len() + usize::from(!constant.is_zero()));
+        for (base, coefficient) in coefficients {
+            if coefficient.is_zero() {
+                continue;
+            }
+            if coefficient.is_one() {
+                terms.push(base);
+            } else {
+                terms.push(Self::mul_all(vec![Self::constant(coefficient), base]));
+            }
+        }
+        if !constant.is_zero() {
+            terms.push(Self::constant(constant));
+        }
+        terms.sort();
+        match terms.len() {
+            0 => Self::integer(0),
+            1 => terms.pop().expect("single normalized sum term"),
+            _ => Self::from_node(ExprNode::Add(terms.into_boxed_slice())),
+        }
+    }
+
+    fn mul_all(values: Vec<Expr>) -> Expr {
+        let mut constant = BigRational::one();
+        let mut powers: std::collections::BTreeMap<Expr, Vec<Expr>> =
+            std::collections::BTreeMap::new();
+        let mut pending = values;
+        while let Some(value) = pending.pop() {
+            match value.node() {
+                ExprNode::Mul(nested) => pending.extend(nested.iter().cloned()),
+                ExprNode::Const(value) => constant *= value,
+                ExprNode::Pow(base, exponent) => {
+                    powers
+                        .entry(base.clone())
+                        .or_default()
+                        .push(exponent.clone());
+                }
+                _ => powers.entry(value).or_default().push(Self::integer(1)),
+            }
+        }
+        let mut factors = Vec::with_capacity(powers.len() + usize::from(!constant.is_one()));
+        for (base, exponents) in powers {
+            factors.push(Self::pow(base, Self::add_all(exponents)));
+        }
+        if !constant.is_one() {
+            factors.push(Self::constant(constant));
+        }
+        factors.sort();
+        match factors.len() {
+            0 => Self::integer(1),
+            1 => factors.pop().expect("single normalized product factor"),
+            _ => Self::from_node(ExprNode::Mul(factors.into_boxed_slice())),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SubstitutionError {
+    missing: BTreeSet<Box<str>>,
+}
+
+impl SubstitutionError {
+    fn new(missing: BTreeSet<Box<str>>) -> Self {
+        Self { missing }
+    }
+
+    pub fn missing_variables(&self) -> impl Iterator<Item = &str> {
+        self.missing.iter().map(AsRef::as_ref)
+    }
+}
+
+impl fmt::Display for SubstitutionError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            formatter,
+            "missing substitutions for {}",
+            self.missing_variables().collect::<Vec<_>>().join(", ")
+        )
+    }
+}
+
+impl std::error::Error for SubstitutionError {}
+
+impl std::ops::Add for Expr {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        Self::add_all(vec![self, rhs])
+    }
+}
+
+impl std::ops::Sub for Expr {
+    type Output = Self;
+    fn sub(self, rhs: Self) -> Self::Output {
+        Self::add_all(vec![self, -rhs])
+    }
+}
+
+impl std::ops::Mul for Expr {
+    type Output = Self;
+    fn mul(self, rhs: Self) -> Self::Output {
+        Self::mul_all(vec![self, rhs])
+    }
+}
+
+impl std::ops::Div for Expr {
+    type Output = Self;
+    fn div(self, rhs: Self) -> Self::Output {
+        Self::mul_all(vec![self, Self::pow(rhs, Self::integer(-1))])
+    }
+}
+
+impl std::ops::Neg for Expr {
+    type Output = Self;
+    fn neg(self) -> Self::Output {
+        Self::mul_all(vec![Self::integer(-1), self])
+    }
+}
+
+impl fmt::Display for Expr {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.fmt_with_precedence(formatter, 0, false)
+    }
+}
+
+impl Expr {
+    fn precedence(&self) -> u8 {
+        match self.node() {
+            ExprNode::Add(_) => 1,
+            ExprNode::Mul(_) => 2,
+            ExprNode::Const(value) if decimal_factors(value.denom()).is_none() => 2,
+            ExprNode::Const(value) if value.is_negative() => 3,
+            ExprNode::Pow(_, _) => 4,
+            _ => 5,
+        }
+    }
+
+    fn fmt_with_precedence(
+        &self,
+        formatter: &mut fmt::Formatter<'_>,
+        parent_precedence: u8,
+        right_child: bool,
+    ) -> fmt::Result {
+        let precedence = self.precedence();
+        let needs_parentheses = (precedence < parent_precedence
+            && !(right_child && precedence == 3 && parent_precedence == 4))
+            || (right_child
+                && precedence == parent_precedence
+                && matches!(self.node(), ExprNode::Add(_) | ExprNode::Mul(_)))
+            || (!right_child
+                && precedence == parent_precedence
+                && matches!(self.node(), ExprNode::Pow(_, _)));
+        if needs_parentheses {
+            write!(formatter, "(")?;
+        }
+        match self.node() {
+            ExprNode::Const(value) => fmt_rational(value, formatter)?,
+            ExprNode::Var(name) => write!(formatter, "{name}")?,
+            ExprNode::Add(values) => {
+                for (index, value) in values.iter().enumerate() {
+                    if index > 0 {
+                        write!(formatter, " + ")?;
+                    }
+                    value.fmt_with_precedence(formatter, precedence, index > 0)?;
+                }
+            }
+            ExprNode::Mul(values) => {
+                for (index, value) in values.iter().enumerate() {
+                    if index > 0 {
+                        write!(formatter, " * ")?;
+                    }
+                    value.fmt_with_precedence(formatter, precedence, index > 0)?;
+                }
+            }
+            ExprNode::Pow(base, exponent) => {
+                base.fmt_with_precedence(formatter, precedence, false)?;
+                write!(formatter, "^")?;
+                exponent.fmt_with_precedence(formatter, precedence, true)?;
+            }
+            ExprNode::Exp(value) => write!(formatter, "exp({value})")?,
+            ExprNode::Log(value) => write!(formatter, "log({value})")?,
+            ExprNode::Factorial(value) => write!(formatter, "factorial({value})")?,
+        }
+        if needs_parentheses {
+            write!(formatter, ")")?;
+        }
+        Ok(())
+    }
+}
+
+fn decimal_factors(denominator: &BigInt) -> Option<(usize, usize)> {
+    let mut denominator = denominator.clone();
+    let mut twos = 0usize;
+    let mut fives = 0usize;
+    while (&denominator % 2u8).is_zero() {
+        denominator /= 2u8;
+        twos += 1;
+    }
+    while (&denominator % 5u8).is_zero() {
+        denominator /= 5u8;
+        fives += 1;
+    }
+    denominator.is_one().then_some((twos, fives))
+}
+
+fn fmt_rational(value: &BigRational, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+    if value.is_integer() {
+        return write!(formatter, "{}", value.to_integer());
+    }
+    let negative = value.is_negative();
+    let numerator = value.numer().abs();
+    let Some((twos, fives)) = decimal_factors(value.denom()) else {
+        return write!(formatter, "{}/{}", value.numer(), value.denom());
+    };
+    let scale = twos.max(fives);
+    let scaled = numerator
+        * BigInt::from(2u8).pow((scale - twos) as u32)
+        * BigInt::from(5u8).pow((scale - fives) as u32);
+    let digits = scaled.to_string();
+    let sign = if negative { "-" } else { "" };
+    if digits.len() <= scale {
+        write!(formatter, "{sign}0.{:0>width$}", digits, width = scale)
+    } else {
+        let split = digits.len() - scale;
+        write!(formatter, "{sign}{}.{}", &digits[..split], &digits[split..])
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+#[error("{message} at byte {position}")]
+pub struct ParseError {
+    position: usize,
+    message: String,
+}
+
+impl ParseError {
+    fn new(position: usize, message: impl Into<String>) -> Self {
+        Self {
+            position,
+            message: message.into(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct Token {
+    position: usize,
+    kind: TokenKind,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum TokenKind {
+    Number(BigRational),
+    Ident(Box<str>),
+    Plus,
+    Minus,
+    Star,
+    Slash,
+    Caret,
+    LeftParen,
+    RightParen,
+}
+
+fn tokenize(input: &str) -> Result<Vec<Token>, ParseError> {
+    let bytes = input.as_bytes();
+    let mut tokens = Vec::new();
+    let mut position = 0;
+    while position < bytes.len() {
+        match bytes[position] {
+            b' ' | b'\t' | b'\n' | b'\r' => position += 1,
+            b'+' => push_token(&mut tokens, &mut position, TokenKind::Plus),
+            b'-' => push_token(&mut tokens, &mut position, TokenKind::Minus),
+            b'*' => push_token(&mut tokens, &mut position, TokenKind::Star),
+            b'/' => push_token(&mut tokens, &mut position, TokenKind::Slash),
+            b'^' => push_token(&mut tokens, &mut position, TokenKind::Caret),
+            b'(' => push_token(&mut tokens, &mut position, TokenKind::LeftParen),
+            b')' => push_token(&mut tokens, &mut position, TokenKind::RightParen),
+            byte if byte.is_ascii_digit() || byte == b'.' => {
+                let start = position;
+                while position < bytes.len()
+                    && (bytes[position].is_ascii_digit() || bytes[position] == b'.')
+                {
+                    position += 1;
+                }
+                let spelling = &input[start..position];
+                let value = parse_decimal(spelling).ok_or_else(|| {
+                    ParseError::new(start, format!("invalid number {spelling:?}"))
+                })?;
+                tokens.push(Token {
+                    position: start,
+                    kind: TokenKind::Number(value),
+                });
+            }
+            byte if byte.is_ascii_alphabetic() || byte == b'_' => {
+                let start = position;
+                while position < bytes.len()
+                    && (bytes[position].is_ascii_alphanumeric() || bytes[position] == b'_')
+                {
+                    position += 1;
+                }
+                tokens.push(Token {
+                    position: start,
+                    kind: TokenKind::Ident(input[start..position].into()),
+                });
+            }
+            _ => {
+                let character = input[position..].chars().next().unwrap();
+                return Err(ParseError::new(
+                    position,
+                    format!("unexpected character {character:?}"),
+                ));
+            }
+        }
+    }
+    Ok(tokens)
+}
+
+fn push_token(tokens: &mut Vec<Token>, position: &mut usize, kind: TokenKind) {
+    tokens.push(Token {
+        position: *position,
+        kind,
+    });
+    *position += 1;
+}
+
+fn parse_decimal(spelling: &str) -> Option<BigRational> {
+    let mut parts = spelling.split('.');
+    let integer = parts.next()?;
+    let fractional = parts.next();
+    if parts.next().is_some() || (integer.is_empty() && fractional.is_none()) {
+        return None;
+    }
+    match fractional {
+        None => BigInt::from_str(integer)
+            .ok()
+            .map(BigRational::from_integer),
+        Some(fractional) if !integer.is_empty() || !fractional.is_empty() => {
+            let combined = format!("{integer}{fractional}");
+            let numerator = BigInt::from_str(&combined).ok()?;
+            let denominator = BigInt::from(10u8).pow(fractional.len() as u32);
+            Some(BigRational::new(numerator, denominator))
+        }
+        Some(_) => None,
+    }
+}
+
+struct Parser {
+    tokens: std::iter::Peekable<std::vec::IntoIter<Token>>,
+    end_position: usize,
+}
+
+impl Parser {
+    fn new(tokens: Vec<Token>) -> Self {
+        let end_position = tokens.last().map_or(0, |token| token.position + 1);
+        Self {
+            tokens: tokens.into_iter().peekable(),
+            end_position,
+        }
+    }
+
+    fn parse(mut self) -> Result<Expr, ParseError> {
+        if self.tokens.peek().is_none() {
+            return Err(ParseError::new(0, "expected expression"));
+        }
+        let expression = self.parse_additive()?;
+        if let Some(token) = self.peek() {
+            return Err(ParseError::new(token.position, "unexpected trailing token"));
+        }
+        Ok(expression)
+    }
+
+    fn peek(&mut self) -> Option<&Token> {
+        self.tokens.peek()
+    }
+
+    fn advance(&mut self) -> Option<Token> {
+        self.tokens.next()
+    }
+
+    fn consume(&mut self, kind: &TokenKind) -> bool {
+        if self.peek().is_some_and(|token| &token.kind == kind) {
+            self.tokens.next();
+            true
+        } else {
+            false
+        }
+    }
+
+    fn parse_additive(&mut self) -> Result<Expr, ParseError> {
+        let mut expression = self.parse_multiplicative()?;
+        loop {
+            if self.consume(&TokenKind::Plus) {
+                expression = expression + self.parse_multiplicative()?;
+            } else if self.consume(&TokenKind::Minus) {
+                expression = expression - self.parse_multiplicative()?;
+            } else {
+                return Ok(expression);
+            }
+        }
+    }
+
+    fn parse_multiplicative(&mut self) -> Result<Expr, ParseError> {
+        let mut expression = self.parse_unary()?;
+        loop {
+            if self.consume(&TokenKind::Star) {
+                expression = expression * self.parse_unary()?;
+            } else if self
+                .peek()
+                .is_some_and(|token| token.kind == TokenKind::Slash)
+            {
+                let position = self.advance().expect("peeked division token").position;
+                let denominator = self.parse_unary()?;
+                if denominator.is_exact_integer(0) {
+                    return Err(ParseError::new(position, "division by zero"));
+                }
+                expression = expression / denominator;
+            } else {
+                return Ok(expression);
+            }
+        }
+    }
+
+    fn parse_unary(&mut self) -> Result<Expr, ParseError> {
+        if self.consume(&TokenKind::Minus) {
+            Ok(-self.parse_unary()?)
+        } else {
+            self.parse_power()
+        }
+    }
+
+    fn parse_power(&mut self) -> Result<Expr, ParseError> {
+        let base = self.parse_primary()?;
+        if self
+            .peek()
+            .is_some_and(|token| token.kind == TokenKind::Caret)
+        {
+            let position = self.advance().expect("peeked power token").position;
+            let exponent = self.parse_unary()?;
+            if matches!((base.node(), exponent.node()),
+                (ExprNode::Const(base), ExprNode::Const(exponent))
+                    if base.is_zero() && exponent.is_negative())
+            {
+                return Err(ParseError::new(
+                    position,
+                    "zero cannot have a negative power",
+                ));
+            }
+            Ok(Expr::pow(base, exponent))
+        } else {
+            Ok(base)
+        }
+    }
+
+    fn parse_primary(&mut self) -> Result<Expr, ParseError> {
+        let token = self
+            .advance()
+            .ok_or_else(|| ParseError::new(self.end_position(), "expected expression"))?;
+        match token.kind {
+            TokenKind::Number(value) => Ok(Expr::constant(value)),
+            TokenKind::Ident(name) => {
+                if !self.consume(&TokenKind::LeftParen) {
+                    return Expr::try_variable(name)
+                        .map_err(|error| ParseError::new(token.position, error.to_string()));
+                }
+                let argument = self.parse_additive()?;
+                self.expect_right_paren()?;
+                match name.as_ref() {
+                    "exp" => Ok(Expr::exp(argument)),
+                    "log" => {
+                        if matches!(argument.node(), ExprNode::Const(value) if !value.is_positive())
+                        {
+                            Err(ParseError::new(
+                                token.position,
+                                "logarithm argument must be positive",
+                            ))
+                        } else {
+                            Ok(Expr::log(argument))
+                        }
+                    }
+                    "sqrt" => {
+                        if matches!(argument.node(), ExprNode::Const(value) if value.is_negative())
+                        {
+                            Err(ParseError::new(
+                                token.position,
+                                "square-root argument must be non-negative",
+                            ))
+                        } else {
+                            Ok(Expr::sqrt(argument))
+                        }
+                    }
+                    "factorial" => {
+                        if matches!(argument.node(), ExprNode::Const(value)
+                            if !value.is_integer() || value.is_negative())
+                        {
+                            Err(ParseError::new(
+                                token.position,
+                                "factorial argument must be a non-negative integer",
+                            ))
+                        } else {
+                            Ok(Expr::factorial(argument))
+                        }
+                    }
+                    _ => Err(ParseError::new(
+                        token.position,
+                        format!("unknown function {name:?}"),
+                    )),
+                }
+            }
+            TokenKind::LeftParen => {
+                let expression = self.parse_additive()?;
+                self.expect_right_paren()?;
+                Ok(expression)
+            }
+            _ => Err(ParseError::new(token.position, "expected expression")),
+        }
+    }
+
+    fn expect_right_paren(&mut self) -> Result<(), ParseError> {
+        if self.consume(&TokenKind::RightParen) {
+            Ok(())
+        } else {
+            Err(ParseError::new(
+                self.end_position(),
+                "expected closing parenthesis",
+            ))
+        }
+    }
+
+    fn end_position(&self) -> usize {
+        self.end_position
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn decimal_literals_are_exact() {
+        assert_eq!(Expr::parse("2.372"), Expr::rational(593, 250));
+    }
+
+    #[test]
+    fn parser_normalizes_source_operators() {
+        let expression = Expr::parse("n * (n - 1) / 2 - m");
+        assert!(matches!(expression.node(), ExprNode::Add(_)));
+        assert_eq!(expression.variables(), BTreeSet::from(["m", "n"]));
+    }
+
+    #[test]
+    fn parser_rejects_statically_undefined_expressions() {
+        for source in [
+            "0 / 0",
+            "0^-1",
+            "log(0)",
+            "log(-1)",
+            "sqrt(-1)",
+            "factorial(-1)",
+            "factorial(3.5)",
+        ] {
+            assert!(Expr::try_parse(source).is_err(), "accepted {source}");
+        }
+    }
+
+    #[test]
+    fn variables_are_owned() {
+        let name = String::from("dynamic_size");
+        let expression = Expr::parse(&name);
+        drop(name);
+        assert_eq!(expression.variables(), BTreeSet::from(["dynamic_size"]));
+    }
+
+    #[test]
+    fn variables_enforce_one_identifier_grammar() {
+        for invalid in ["", "_", "1n", "n-m", "type"] {
+            assert!(Expr::try_variable(invalid).is_err(), "accepted {invalid:?}");
+        }
+        for invalid_expression in ["", "_", "1n", "type"] {
+            assert!(
+                Expr::try_parse(invalid_expression).is_err(),
+                "parsed {invalid_expression:?}"
+            );
+        }
+        assert!(matches!(Expr::parse("n-m").node(), ExprNode::Add(_)));
+        for valid in ["n", "_n", "n_1", "num_vertices"] {
+            let expression = Expr::try_variable(valid).unwrap();
+            assert_eq!(
+                Expr::try_parse(&expression.to_string()).unwrap(),
+                expression
+            );
+        }
+    }
+
+    #[test]
+    fn deserialization_rejects_invalid_variable_names() {
+        assert!(serde_json::from_str::<Expr>(r#"{"nodes":[{"Var":"n-m"}],"root":0}"#).is_err());
+    }
+
+    #[test]
+    fn serialization_preserves_shared_nodes() {
+        let shared = Expr::variable("a") + Expr::variable("b");
+        let expression = Expr::pow(shared.clone(), shared);
+        let encoded = serde_json::to_value(&expression).unwrap();
+        assert_eq!(encoded["nodes"].as_array().unwrap().len(), 4);
+
+        let decoded: Expr = serde_json::from_value(encoded).unwrap();
+        assert_eq!(decoded, expression);
+        assert_eq!(decoded.unique_node_count(), 4);
+    }
+
+    #[test]
+    fn deserialization_rejects_forward_node_references() {
+        let error =
+            serde_json::from_str::<Expr>(r#"{"nodes":[{"Pow":[1,1]},{"Var":"n"}],"root":0}"#)
+                .unwrap_err();
+        assert!(error.to_string().contains("unavailable child node 1"));
+    }
+
+    #[test]
+    fn complete_substitution_rejects_missing_variables() {
+        let expression = Expr::parse("n + m");
+        let n = Expr::integer(3);
+        let replacements = HashMap::from([("n", &n)]);
+        let error = expression.substitute_complete(&replacements).unwrap_err();
+        assert_eq!(error.missing_variables().collect::<Vec<_>>(), ["m"]);
+
+        let m = Expr::integer(4);
+        let replacements = HashMap::from([("n", &n), ("m", &m)]);
+        assert_eq!(
+            expression.substitute_complete(&replacements),
+            Ok(Expr::integer(3) + Expr::integer(4))
+        );
+    }
+
+    #[test]
+    fn polynomial_accepts_exact_rational_coefficients() {
+        assert!(Expr::parse("-n / 2").is_polynomial());
+        assert!(
+            !(Expr::variable("n") * Expr::pow(Expr::integer(0), Expr::integer(-1))).is_polynomial()
+        );
+        assert!(!Expr::parse("n / m").is_polynomial());
+    }
+
+    #[test]
+    fn exponentiation_precedes_unary_minus() {
+        assert_eq!(
+            Expr::parse("-n^2"),
+            -Expr::pow(Expr::variable("n"), Expr::integer(2))
+        );
+        assert_eq!(
+            Expr::parse("2^-3"),
+            Expr::pow(Expr::integer(2), -Expr::integer(3))
+        );
+    }
+
+    #[test]
+    fn display_preserves_grouping() {
+        let expression = Expr::parse("n * (n - 1) / 2 - m");
+        assert_eq!(expression.to_string(), "-1 * m + n * (-1 + n) * 2^-1");
+        assert_eq!(Expr::parse(&expression.to_string()), expression);
+    }
+
+    #[test]
+    fn repeated_substitution_keeps_a_constant_number_of_nodes() {
+        let template = Expr::parse("x + x");
+        let mut expression = Expr::variable("n");
+        for _ in 0..100 {
+            let replacements = HashMap::from([("x", &expression)]);
+            expression = template
+                .substitute_complete(&replacements)
+                .expect("x has an exact replacement");
+        }
+
+        assert_eq!(expression.unique_node_count(), 3);
+        assert_eq!(expression.variables(), BTreeSet::from(["n"]));
+    }
+
+    #[test]
+    fn constructors_combine_coefficients_and_exponents() {
+        assert_eq!(Expr::parse("2*x + 3*x"), Expr::parse("5*x"));
+        assert_eq!(Expr::parse("x^2 * x^3"), Expr::parse("x^5"));
+        assert_eq!(Expr::parse("x * x^-1"), Expr::integer(1));
+    }
+
+    #[test]
+    fn canonicalization_preserves_deep_shared_subexpressions() {
+        let mut expression = Expr::variable("n");
+        for _ in 0..100 {
+            expression = Expr::pow(expression.clone(), Expr::integer(2)) + expression;
+        }
+
+        assert_eq!(expression.unique_node_count(), 301);
+    }
+
+    #[test]
+    fn serialization_preserves_every_operator() {
+        let expression = Expr::parse("-factorial(n - 1) + exp(m) / log(sqrt(k))^2");
+        let encoded = serde_json::to_string(&expression).unwrap();
+        let decoded: Expr = serde_json::from_str(&encoded).unwrap();
+        assert_eq!(decoded, expression);
+    }
+
+    #[test]
+    fn display_does_not_normalize_half_power_to_sqrt() {
+        let power = Expr::pow(Expr::variable("n"), Expr::rational(1, 2));
+        assert_eq!(power.to_string(), "n^0.5");
+        assert_eq!(Expr::parse(&power.to_string()), power);
+    }
+
+    #[test]
+    fn shared_dag_queries_reuse_nodes_without_losing_errors() {
+        let shared = Expr::variable("n") + Expr::variable("m");
+        let expression = Expr::pow(shared.clone(), shared);
+
+        assert_eq!(expression.variables(), BTreeSet::from(["m", "n"]));
+        assert!(!expression.is_constant());
+        assert!(!expression.is_polynomial());
+        assert!(expression.is_valid_complexity_notation());
+        assert_eq!(expression.unique_node_count(), 4);
+
+        let error = expression.substitute_complete(&HashMap::new()).unwrap_err();
+        assert_eq!(
+            error.missing_variables().collect::<Vec<_>>(),
+            vec!["m", "n"]
+        );
+
+        let mut expressions = HashSet::new();
+        assert!(expressions.insert(expression.clone()));
+        assert!(!expressions.insert(expression));
+    }
+
+    #[test]
+    fn display_and_parser_cover_non_decimal_rationals() {
+        assert_eq!(Expr::rational(1, 3).to_string(), "1/3");
+        assert!(Expr::try_parse(".").is_err());
+    }
+}
diff --git a/problemreductions-expr/tests/fixtures/sympy_oracle.json b/problemreductions-expr/tests/fixtures/sympy_oracle.json
new file mode 100644
index 000000000..999eaf1a4
--- /dev/null
+++ b/problemreductions-expr/tests/fixtures/sympy_oracle.json
@@ -0,0 +1,904 @@
+{
+  "oracle": {
+    "engine": "SymPy",
+    "version": "1.14.0",
+    "parse_evaluate": false,
+    "polynomial_mode": "simplify before classification",
+    "decimal_mode": "rationalize base-10 spelling",
+    "documentation": {
+      "parser": "https://docs.sympy.org/latest/modules/parsing.html",
+      "expression_core": "https://docs.sympy.org/latest/modules/core.html"
+    }
+  },
+  "cases": [
+    {
+      "name": "zero",
+      "source": "0",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "0/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "integer",
+      "source": "42",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "42/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "exact_decimal",
+      "source": "2.372",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "593/250",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "leading_decimal_point",
+      "source": ".125",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "1/8",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "arbitrary_precision_integer",
+      "source": "100000000000000000000000000000000000000000000000001",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "100000000000000000000000000000000000000000000000001/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "variable",
+      "source": "n",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 7
+      },
+      "exact_result": "7/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "negation",
+      "source": "-n",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 7
+      },
+      "exact_result": "-7/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "addition",
+      "source": "n + m",
+      "variables": [
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 3,
+        "m": 4
+      },
+      "exact_result": "7/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "subtraction",
+      "source": "n - m",
+      "variables": [
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 3,
+        "m": 7
+      },
+      "exact_result": "-4/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "multiplication",
+      "source": "n * m",
+      "variables": [
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 6,
+        "m": 7
+      },
+      "exact_result": "42/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "rational_coefficient",
+      "source": "n / 2",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 3
+      },
+      "exact_result": "3/2",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "variable_divisor",
+      "source": "n / m",
+      "variables": [
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 12,
+        "m": 5
+      },
+      "exact_result": "12/5",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "nested_divisor",
+      "source": "n / (m + 1)",
+      "variables": [
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 10,
+        "m": 4
+      },
+      "exact_result": "2/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "exact_size_formula",
+      "source": "n * (n - 1) / 2 - m",
+      "variables": [
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 5,
+        "m": 4
+      },
+      "exact_result": "6/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "zero_power",
+      "source": "n^0",
+      "variables": [],
+      "bindings": {
+        "n": 9
+      },
+      "exact_result": "1/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "integer_power",
+      "source": "n^3",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 4
+      },
+      "exact_result": "64/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "negative_power",
+      "source": "2^-3",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "1/8",
+      "compare_polynomial": false,
+      "is_polynomial": true
+    },
+    {
+      "name": "symbolic_exponent",
+      "source": "2^n",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 10
+      },
+      "exact_result": "1024/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "unary_precedence",
+      "source": "-n^2",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 3
+      },
+      "exact_result": "-9/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "parenthesized_negative_base",
+      "source": "(-n)^2",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 3
+      },
+      "exact_result": "9/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "fractional_power",
+      "source": "n^0.5",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 81
+      },
+      "exact_result": "9/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "square_root",
+      "source": "sqrt(n)",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 81
+      },
+      "exact_result": "9/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "pythagorean_root",
+      "source": "sqrt(n^2 + m^2)",
+      "variables": [
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 3,
+        "m": 4
+      },
+      "exact_result": "5/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "exponential_identity",
+      "source": "exp(n)",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 0
+      },
+      "exact_result": "1/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "logarithm_identity",
+      "source": "log(n)",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 1
+      },
+      "exact_result": "0/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "factorial",
+      "source": "factorial(n)",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 6
+      },
+      "exact_result": "720/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "factorial_subexpression",
+      "source": "factorial(n - 1)",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 6
+      },
+      "exact_result": "120/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "decimal_scaling",
+      "source": "2.372 * n",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 1000
+      },
+      "exact_result": "2372/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "difference_of_squares",
+      "source": "(n + m) * (n - m)",
+      "variables": [
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 10,
+        "m": 3
+      },
+      "exact_result": "91/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "multivariate_polynomial",
+      "source": "n^2 + 2 * n * m + m^2",
+      "variables": [
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 3,
+        "m": 4
+      },
+      "exact_result": "49/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "nested_rational",
+      "source": "n / (2 * m)",
+      "variables": [
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 12,
+        "m": 3
+      },
+      "exact_result": "2/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "long_decimal",
+      "source": "1.0000000000000000000000000000000000000001",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "10000000000000000000000000000000000000001/10000000000000000000000000000000000000000",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "nested_subtraction",
+      "source": "n - (m - k)",
+      "variables": [
+        "k",
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 10,
+        "m": 7,
+        "k": 2
+      },
+      "exact_result": "5/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "left_subtraction",
+      "source": "(n - m) - k",
+      "variables": [
+        "k",
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 10,
+        "m": 7,
+        "k": 2
+      },
+      "exact_result": "1/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "nested_division",
+      "source": "n / (m / k)",
+      "variables": [
+        "k",
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 12,
+        "m": 6,
+        "k": 3
+      },
+      "exact_result": "6/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "left_division",
+      "source": "(n / m) / k",
+      "variables": [
+        "k",
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 12,
+        "m": 6,
+        "k": 2
+      },
+      "exact_result": "1/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "right_associative_power",
+      "source": "n^(m^k)",
+      "variables": [
+        "k",
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 2,
+        "m": 3,
+        "k": 2
+      },
+      "exact_result": "512/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "parenthesized_power",
+      "source": "(n^m)^k",
+      "variables": [
+        "k",
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 2,
+        "m": 3,
+        "k": 2
+      },
+      "exact_result": "64/1",
+      "compare_polynomial": true,
+      "is_polynomial": false
+    },
+    {
+      "name": "double_negation",
+      "source": "--n",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 7
+      },
+      "exact_result": "7/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "zero_factorial",
+      "source": "factorial(0)",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "1/1",
+      "compare_polynomial": false,
+      "is_polynomial": true
+    },
+    {
+      "name": "zero_square_root",
+      "source": "sqrt(0)",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "0/1",
+      "compare_polynomial": false,
+      "is_polynomial": true
+    },
+    {
+      "name": "constant_functions",
+      "source": "exp(0) + log(1) + factorial(5)",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "121/1",
+      "compare_polynomial": false,
+      "is_polynomial": true
+    },
+    {
+      "name": "zero_product",
+      "source": "n * 0 + 7",
+      "variables": [],
+      "bindings": {
+        "n": 999
+      },
+      "exact_result": "7/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "self_division",
+      "source": "n / n",
+      "variables": [],
+      "bindings": {
+        "n": 5
+      },
+      "exact_result": "1/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "identity_power",
+      "source": "n^1",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 13
+      },
+      "exact_result": "13/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "decimal_integer_power",
+      "source": "n^2.0",
+      "variables": [
+        "n"
+      ],
+      "bindings": {
+        "n": 9
+      },
+      "exact_result": "81/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "decimal_sum",
+      "source": "0.1 + 0.2",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "3/10",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "large_mixed_decimal",
+      "source": "99999999999999999999.00000000000000000001",
+      "variables": [],
+      "bindings": {},
+      "exact_result": "9999999999999999999900000000000000000001/100000000000000000000",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "identifier_shapes",
+      "source": "n_1 + size2",
+      "variables": [
+        "n_1",
+        "size2"
+      ],
+      "bindings": {
+        "n_1": 8,
+        "size2": 9
+      },
+      "exact_result": "17/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    },
+    {
+      "name": "mixed_precedence",
+      "source": "n + m * k^2",
+      "variables": [
+        "k",
+        "m",
+        "n"
+      ],
+      "bindings": {
+        "n": 1,
+        "m": 2,
+        "k": 3
+      },
+      "exact_result": "19/1",
+      "compare_polynomial": true,
+      "is_polynomial": true
+    }
+  ],
+  "approximate_cases": [
+    {
+      "name": "exp_one",
+      "source": "exp(1)",
+      "bindings": {},
+      "decimal_result": "2.7182818284590452353602874713526624977572470936999595749669676277240766303535476",
+      "finite_f64": true
+    },
+    {
+      "name": "exp_fraction",
+      "source": "exp(n / 3)",
+      "bindings": {
+        "n": 5
+      },
+      "decimal_result": "5.2944900504700293668273720041970084836945003393922853071798661344646724034457350",
+      "finite_f64": true
+    },
+    {
+      "name": "log_two",
+      "source": "log(2)",
+      "bindings": {},
+      "decimal_result": "0.69314718055994530941723212145817656807550013436025525412068000949339362196969472",
+      "finite_f64": true
+    },
+    {
+      "name": "log_large",
+      "source": "log(1000000)",
+      "bindings": {},
+      "decimal_result": "13.815510557964274104107948728106185245606608931772637856199967405805435658064115",
+      "finite_f64": true
+    },
+    {
+      "name": "sqrt_two",
+      "source": "sqrt(2)",
+      "bindings": {},
+      "decimal_result": "1.4142135623730950488016887242096980785696718753769480731766797379907324784621070",
+      "finite_f64": true
+    },
+    {
+      "name": "sqrt_large",
+      "source": "sqrt(1234567)",
+      "bindings": {},
+      "decimal_result": "1111.1107055554815416396515848965904897963992832303701857506256489602822366577437",
+      "finite_f64": true
+    },
+    {
+      "name": "fractional_power",
+      "source": "7^2.372",
+      "bindings": {},
+      "decimal_result": "101.05843092384223958212718059829945761475621729782192940886273940327749873565595",
+      "finite_f64": true
+    },
+    {
+      "name": "mixed_transcendental",
+      "source": "exp(log(n)) + sqrt(m)",
+      "bindings": {
+        "n": 13,
+        "m": 2
+      },
+      "decimal_result": "14.414213562373095048801688724209698078569671875376948073176679737990732478462107",
+      "finite_f64": true
+    },
+    {
+      "name": "complexity_formula",
+      "source": "2^(2.372 * n / 3)",
+      "bindings": {
+        "n": 19
+      },
+      "decimal_result": "33286.894651335198492304106719929283764371367866374006692959786883373657361699408",
+      "finite_f64": true
+    },
+    {
+      "name": "factorial_ten",
+      "source": "factorial(10)",
+      "bindings": {},
+      "decimal_result": "3628800.0000000000000000000000000000000000000000000000000000000000000000000000000",
+      "finite_f64": true
+    },
+    {
+      "name": "factorial_f64_boundary",
+      "source": "factorial(170)",
+      "bindings": {},
+      "decimal_result": "7.2574156153079989673967282111292631147169916812964513765435777989005618434017062e+306",
+      "finite_f64": true
+    },
+    {
+      "name": "factorial_f64_overflow",
+      "source": "factorial(171)",
+      "bindings": {},
+      "decimal_result": "1.2410180702176678234248405241031039926166055775016931853889518036119960752216918e+309",
+      "finite_f64": false
+    }
+  ],
+  "growth_cases": [
+    {
+      "name": "constant_factor",
+      "left": "3 * n^2",
+      "right": "n^2",
+      "ratio_limit": "3",
+      "relation": "equivalent"
+    },
+    {
+      "name": "lower_order_sum",
+      "left": "n^2 + n",
+      "right": "n^2",
+      "ratio_limit": "1",
+      "relation": "equivalent"
+    },
+    {
+      "name": "shifted_power",
+      "left": "(n + 1)^2",
+      "right": "n^2",
+      "ratio_limit": "1",
+      "relation": "equivalent"
+    },
+    {
+      "name": "log_constant_power",
+      "left": "log(n^3)",
+      "right": "log(n)",
+      "ratio_limit": "3",
+      "relation": "equivalent"
+    },
+    {
+      "name": "higher_polynomial_degree",
+      "left": "n^3",
+      "right": "n^2",
+      "ratio_limit": "oo",
+      "relation": "left_dominates"
+    },
+    {
+      "name": "polynomial_over_log",
+      "left": "n",
+      "right": "log(n)^5",
+      "ratio_limit": "oo",
+      "relation": "left_dominates"
+    },
+    {
+      "name": "polylog_tie_break",
+      "left": "n^3 * log(n)",
+      "right": "n^3",
+      "ratio_limit": "oo",
+      "relation": "left_dominates"
+    },
+    {
+      "name": "small_base_exponential",
+      "left": "1.001^n",
+      "right": "n^100",
+      "ratio_limit": "oo",
+      "relation": "left_dominates"
+    },
+    {
+      "name": "exponential_base",
+      "left": "3^n",
+      "right": "2^n",
+      "ratio_limit": "oo",
+      "relation": "left_dominates"
+    },
+    {
+      "name": "exponential_rate",
+      "left": "2^(2 * n)",
+      "right": "2^n",
+      "ratio_limit": "oo",
+      "relation": "left_dominates"
+    },
+    {
+      "name": "natural_exponential",
+      "left": "exp(n)",
+      "right": "n^100",
+      "ratio_limit": "oo",
+      "relation": "left_dominates"
+    },
+    {
+      "name": "exponential_poly_tie_break",
+      "left": "2^n * n",
+      "right": "2^n",
+      "ratio_limit": "oo",
+      "relation": "left_dominates"
+    },
+    {
+      "name": "reverse_polynomial_degree",
+      "left": "n",
+      "right": "n^2",
+      "ratio_limit": "0",
+      "relation": "right_dominates"
+    },
+    {
+      "name": "reverse_exponential",
+      "left": "n^100",
+      "right": "exp(n)",
+      "ratio_limit": "0",
+      "relation": "right_dominates"
+    }
+  ],
+  "factorial_domain_cases": [
+    {
+      "source": "0",
+      "exact_argument": "0",
+      "accepted": true,
+      "finite_f64": true
+    },
+    {
+      "source": "1",
+      "exact_argument": "1",
+      "accepted": true,
+      "finite_f64": true
+    },
+    {
+      "source": "10",
+      "exact_argument": "10",
+      "accepted": true,
+      "finite_f64": true
+    },
+    {
+      "source": "170",
+      "exact_argument": "170",
+      "accepted": true,
+      "finite_f64": true
+    },
+    {
+      "source": "171",
+      "exact_argument": "171",
+      "accepted": true,
+      "finite_f64": false
+    },
+    {
+      "source": "-1",
+      "exact_argument": "-1",
+      "accepted": false,
+      "finite_f64": false
+    },
+    {
+      "source": "3.5",
+      "exact_argument": "7/2",
+      "accepted": false,
+      "finite_f64": false
+    },
+    {
+      "source": "1 / 2",
+      "exact_argument": "1/2",
+      "accepted": false,
+      "finite_f64": false
+    }
+  ]
+}
diff --git a/problemreductions-expr/tests/sympy_fixture.rs b/problemreductions-expr/tests/sympy_fixture.rs
new file mode 100644
index 000000000..3ed02deb8
--- /dev/null
+++ b/problemreductions-expr/tests/sympy_fixture.rs
@@ -0,0 +1,224 @@
+use num_bigint::BigInt;
+use num_rational::BigRational;
+use num_traits::{One, Signed, ToPrimitive, Zero};
+use problemreductions_expr::{Expr, ExprNode};
+use serde::Deserialize;
+use std::collections::BTreeMap;
+use std::str::FromStr;
+
+#[derive(Deserialize)]
+struct Fixture {
+    oracle: Oracle,
+    cases: Vec<Case>,
+}
+
+#[derive(Deserialize)]
+struct Oracle {
+    engine: String,
+    version: String,
+    parse_evaluate: bool,
+    decimal_mode: String,
+}
+
+#[derive(Deserialize)]
+struct Case {
+    name: String,
+    source: String,
+    variables: Vec<String>,
+    bindings: BTreeMap<String, i64>,
+    exact_result: String,
+    compare_polynomial: bool,
+    is_polynomial: bool,
+}
+
+#[test]
+fn sympy_fixture_matches_expression_semantics() {
+    let fixture: Fixture =
+        serde_json::from_str(include_str!("fixtures/sympy_oracle.json")).unwrap();
+    assert_eq!(fixture.oracle.engine, "SymPy");
+    assert_eq!(fixture.oracle.version, "1.14.0");
+    assert!(!fixture.oracle.parse_evaluate);
+    assert_eq!(fixture.oracle.decimal_mode, "rationalize base-10 spelling");
+    assert_eq!(fixture.cases.len(), 50);
+
+    let mut names = std::collections::BTreeSet::new();
+    let mut operators = std::collections::BTreeSet::new();
+    for case in fixture.cases {
+        assert!(
+            names.insert(case.name.clone()),
+            "duplicate case {}",
+            case.name
+        );
+        let expression = Expr::try_parse(&case.source)
+            .unwrap_or_else(|error| panic!("{} failed to parse: {error}", case.name));
+        assert_eq!(
+            expression.variables(),
+            case.variables.iter().map(String::as_str).collect(),
+            "{} free variables",
+            case.name
+        );
+        collect_operators(&expression, &mut operators);
+
+        let bindings: BTreeMap<_, _> = case
+            .bindings
+            .iter()
+            .map(|(name, value)| {
+                (
+                    name.as_str(),
+                    BigRational::from_integer(BigInt::from(*value)),
+                )
+            })
+            .collect();
+        let actual = evaluate_exact(&expression, &bindings)
+            .unwrap_or_else(|| panic!("{} left the exact fixture domain", case.name));
+        assert_eq!(
+            actual,
+            parse_rational(&case.exact_result),
+            "{} value",
+            case.name
+        );
+
+        if case.compare_polynomial {
+            assert_eq!(
+                expression.is_polynomial(),
+                case.is_polynomial,
+                "{} polynomial classification",
+                case.name
+            );
+        }
+    }
+    assert_eq!(
+        operators,
+        std::collections::BTreeSet::from([
+            "Add",
+            "Const",
+            "Exp",
+            "Factorial",
+            "Log",
+            "Mul",
+            "Pow",
+            "Var",
+        ])
+    );
+}
+
+fn collect_operators(expression: &Expr, operators: &mut std::collections::BTreeSet<&'static str>) {
+    let operator = match expression.node() {
+        ExprNode::Const(_) => "Const",
+        ExprNode::Var(_) => "Var",
+        ExprNode::Add(_) => "Add",
+        ExprNode::Mul(_) => "Mul",
+        ExprNode::Pow(_, _) => "Pow",
+        ExprNode::Exp(_) => "Exp",
+        ExprNode::Log(_) => "Log",
+        ExprNode::Factorial(_) => "Factorial",
+    };
+    operators.insert(operator);
+    match expression.node() {
+        ExprNode::Add(values) | ExprNode::Mul(values) => {
+            for value in values {
+                collect_operators(value, operators);
+            }
+        }
+        ExprNode::Pow(left, right) => {
+            collect_operators(left, operators);
+            collect_operators(right, operators);
+        }
+        ExprNode::Exp(value) | ExprNode::Log(value) | ExprNode::Factorial(value) => {
+            collect_operators(value, operators)
+        }
+        ExprNode::Const(_) | ExprNode::Var(_) => {}
+    }
+}
+
+fn evaluate_exact(
+    expression: &Expr,
+    bindings: &BTreeMap<&str, BigRational>,
+) -> Option<BigRational> {
+    match expression.node() {
+        ExprNode::Const(value) => Some(value.clone()),
+        ExprNode::Var(name) => bindings.get(name.as_ref()).cloned(),
+        ExprNode::Add(values) => values.iter().try_fold(BigRational::zero(), |sum, value| {
+            Some(sum + evaluate_exact(value, bindings)?)
+        }),
+        ExprNode::Mul(values) => values
+            .iter()
+            .try_fold(BigRational::one(), |product, value| {
+                Some(product * evaluate_exact(value, bindings)?)
+            }),
+        ExprNode::Pow(base, exponent) => {
+            let base = evaluate_exact(base, bindings)?;
+            let exponent = evaluate_exact(exponent, bindings)?;
+            if exponent == BigRational::new(BigInt::one(), BigInt::from(2)) {
+                exact_square_root(&base)
+            } else if exponent.is_integer() {
+                rational_power(base, exponent.to_integer().to_i32()?)
+            } else {
+                None
+            }
+        }
+        ExprNode::Exp(value) => evaluate_exact(value, bindings)?
+            .is_zero()
+            .then(BigRational::one),
+        ExprNode::Log(value) => {
+            (evaluate_exact(value, bindings)? == BigRational::one()).then(BigRational::zero)
+        }
+        ExprNode::Factorial(value) => {
+            let value = evaluate_exact(value, bindings)?;
+            if !value.is_integer() || value.is_negative() {
+                return None;
+            }
+            let value = value.to_integer().to_u32()?;
+            Some(BigRational::from_integer(
+                (2..=value).fold(BigInt::one(), |product, factor| product * factor),
+            ))
+        }
+    }
+}
+
+fn rational_power(base: BigRational, exponent: i32) -> Option<BigRational> {
+    let reciprocal = exponent.is_negative();
+    if reciprocal && base.is_zero() {
+        return None;
+    }
+    let mut remaining = exponent.unsigned_abs();
+    let mut factor = base;
+    let mut result = BigRational::one();
+    while remaining > 0 {
+        if remaining % 2 == 1 {
+            result *= &factor;
+        }
+        remaining /= 2;
+        if remaining > 0 {
+            factor = &factor * &factor;
+        }
+    }
+    if reciprocal {
+        Some(result.recip())
+    } else {
+        Some(result)
+    }
+}
+
+fn exact_square_root(value: &BigRational) -> Option<BigRational> {
+    if value.is_negative() {
+        return None;
+    }
+    Some(BigRational::new(
+        perfect_square_root(value.numer())?,
+        perfect_square_root(value.denom())?,
+    ))
+}
+
+fn perfect_square_root(value: &BigInt) -> Option<BigInt> {
+    let root = value.sqrt();
+    (&root * &root == *value).then_some(root)
+}
+
+fn parse_rational(source: &str) -> BigRational {
+    let (numerator, denominator) = source.split_once('/').unwrap();
+    BigRational::new(
+        BigInt::from_str(numerator).unwrap(),
+        BigInt::from_str(denominator).unwrap(),
+    )
+}
diff --git a/problemreductions-macros/Cargo.toml b/problemreductions-macros/Cargo.toml
index 9db71743c..16b94ead5 100644
--- a/problemreductions-macros/Cargo.toml
+++ b/problemreductions-macros/Cargo.toml
@@ -13,3 +13,5 @@ proc-macro = true
 syn = { version = "2.0", features = ["full", "parsing"] }
 quote = "1.0"
 proc-macro2 = "1.0"
+problemreductions-expr = { version = "0.6.0", path = "../problemreductions-expr" }
+num-traits = "0.2"
diff --git a/problemreductions-macros/src/expr_codegen.rs b/problemreductions-macros/src/expr_codegen.rs
new file mode 100644
index 000000000..03e58df74
--- /dev/null
+++ b/problemreductions-macros/src/expr_codegen.rs
@@ -0,0 +1,164 @@
+use num_traits::ToPrimitive;
+use problemreductions_expr::{Expr, ExprNode};
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub(crate) fn expr_tokens(expression: &Expr) -> TokenStream {
+    match expression.node() {
+        ExprNode::Const(value) => {
+            let numerator = value.numer().to_string();
+            let denominator = value.denom().to_string();
+            quote! {
+                crate::expr::Expr::rational(
+                    #numerator.parse::<crate::expr::BigInt>().expect("macro-generated numerator must be valid"),
+                    #denominator.parse::<crate::expr::BigInt>().expect("macro-generated denominator must be valid"),
+                )
+            }
+        }
+        ExprNode::Var(name) => {
+            let name = name.as_str();
+            quote! { crate::expr::Expr::variable(#name) }
+        }
+        ExprNode::Add(values) => {
+            nary_expr_tokens(values, |left, right| quote! { (#left) + (#right) })
+        }
+        ExprNode::Mul(values) => {
+            nary_expr_tokens(values, |left, right| quote! { (#left) * (#right) })
+        }
+        ExprNode::Pow(base, exponent) => {
+            let base = expr_tokens(base);
+            let exponent = expr_tokens(exponent);
+            quote! { crate::expr::Expr::pow(#base, #exponent) }
+        }
+        ExprNode::Exp(value) => {
+            unary_expr_tokens(value, |value| quote! { crate::expr::Expr::exp(#value) })
+        }
+        ExprNode::Log(value) => {
+            unary_expr_tokens(value, |value| quote! { crate::expr::Expr::log(#value) })
+        }
+        ExprNode::Factorial(value) => unary_expr_tokens(
+            value,
+            |value| quote! { crate::expr::Expr::factorial(#value) },
+        ),
+    }
+}
+
+pub(crate) fn complexity_estimate_tokens(
+    expression: &Expr,
+    parameters: &syn::Ident,
+) -> syn::Result<TokenStream> {
+    Ok(match expression.node() {
+        ExprNode::Const(value) => {
+            let value =
+                value
+                    .to_f64()
+                    .filter(|value| value.is_finite())
+                    .ok_or_else(|| {
+                        syn::Error::new(
+                    proc_macro2::Span::call_site(),
+                    format!("exact expression constant {value} is outside complexity estimation"),
+                )
+                    })?;
+            quote! { #value }
+        }
+        ExprNode::Var(name) => {
+            let name = name.as_str();
+            quote! {
+                (#parameters
+                    .get(#name)
+                    .expect("validated complexity parameter must be present") as f64)
+            }
+        }
+        ExprNode::Add(values) => nary_estimate_tokens(
+            values,
+            parameters,
+            |left, right| quote! { (#left + #right) },
+        )?,
+        ExprNode::Mul(values) => nary_estimate_tokens(
+            values,
+            parameters,
+            |left, right| quote! { (#left * #right) },
+        )?,
+        ExprNode::Pow(base, exponent) => {
+            let base = complexity_estimate_tokens(base, parameters)?;
+            let exponent = complexity_estimate_tokens(exponent, parameters)?;
+            quote! { f64::powf(#base, #exponent) }
+        }
+        ExprNode::Exp(value) => {
+            let value = complexity_estimate_tokens(value, parameters)?;
+            quote! { f64::exp(#value) }
+        }
+        ExprNode::Log(value) => {
+            let value = complexity_estimate_tokens(value, parameters)?;
+            quote! { f64::ln(#value) }
+        }
+        ExprNode::Factorial(value) => {
+            let value = complexity_estimate_tokens(value, parameters)?;
+            quote! {
+                crate::expr::approximate_factorial(#value)
+                    .unwrap_or_else(|error| match error {
+                        crate::expr::ApproximationError::NonFiniteResult(_) => f64::INFINITY,
+                        _ => f64::NAN,
+                    })
+            }
+        }
+    })
+}
+
+fn nary_estimate_tokens(
+    values: &[Expr],
+    parameters: &syn::Ident,
+    build: impl Fn(TokenStream, TokenStream) -> TokenStream,
+) -> syn::Result<TokenStream> {
+    let mut values = values.iter();
+    let first = complexity_estimate_tokens(
+        values
+            .next()
+            .expect("canonical n-ary expression has operands"),
+        parameters,
+    )?;
+    values.try_fold(first, |left, value| {
+        Ok(build(left, complexity_estimate_tokens(value, parameters)?))
+    })
+}
+
+fn nary_expr_tokens(
+    values: &[Expr],
+    build: impl Fn(TokenStream, TokenStream) -> TokenStream,
+) -> TokenStream {
+    let mut values = values.iter().map(expr_tokens);
+    let first = values
+        .next()
+        .expect("normalized n-ary expression has at least two operands");
+    values.fold(first, build)
+}
+
+fn unary_expr_tokens(value: &Expr, build: impl FnOnce(TokenStream) -> TokenStream) -> TokenStream {
+    build(expr_tokens(value))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn shared_parser_drives_codegen() {
+        let expression = Expr::parse("n * (n - 1) / 2 - m");
+        assert!(matches!(expression.node(), ExprNode::Add(_)));
+        assert_eq!(
+            expression.variables().into_iter().collect::<Vec<_>>(),
+            vec!["m", "n"]
+        );
+        assert!(!expr_tokens(&expression).is_empty());
+    }
+
+    #[test]
+    fn codegen_covers_every_semantic_operator() {
+        let expression = Expr::parse("exp(n) + log(n) + factorial(n) + n^2");
+        let constructed = expr_tokens(&expression).to_string();
+        assert!(constructed.contains("Expr :: exp"));
+        assert!(constructed.contains("Expr :: log"));
+        assert!(constructed.contains("Expr :: factorial"));
+        assert!(constructed.contains("Expr :: pow"));
+    }
+}
diff --git a/problemreductions-macros/src/lib.rs b/problemreductions-macros/src/lib.rs
index ac141e1bc..9ee54082e 100644
--- a/problemreductions-macros/src/lib.rs
+++ b/problemreductions-macros/src/lib.rs
@@ -2,16 +2,193 @@
 //!
 //! This crate provides the `#[reduction]` attribute macro that automatically
 //! generates `ReductionEntry` registrations from `ReduceTo` impl blocks,
-//! and the `declare_variants!` proc macro for compile-time validated variant
-//! registration.
+//! the `declare_variants!` proc macro for compile-time validated variant
+//! registration, and `register_brute_force!` for finite reference solvers.
 
-pub(crate) mod parser;
+mod expr_codegen;
 
+use expr_codegen::{complexity_estimate_tokens, expr_tokens};
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
 use std::collections::{HashMap, HashSet};
-use syn::{parse_macro_input, GenericArgument, ItemImpl, Path, PathArguments, Type};
+use syn::{parse_macro_input, DeriveInput, GenericArgument, ItemImpl, Path, PathArguments, Type};
+
+/// Generate static construction-input metadata from a typed create spec.
+#[proc_macro_derive(CreateSpec, attributes(create))]
+pub fn derive_create_spec(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    match generate_create_spec(&input) {
+        Ok(tokens) => tokens.into(),
+        Err(error) => error.to_compile_error().into(),
+    }
+}
+
+fn generate_create_spec(input: &DeriveInput) -> syn::Result<TokenStream2> {
+    let name = &input.ident;
+    let syn::Data::Struct(data) = &input.data else {
+        return Err(syn::Error::new_spanned(
+            input,
+            "CreateSpec can only be derived for structs",
+        ));
+    };
+    let syn::Fields::Named(fields) = &data.fields else {
+        return Err(syn::Error::new_spanned(
+            &data.fields,
+            "CreateSpec requires named fields",
+        ));
+    };
+
+    let mut field_entries = Vec::new();
+    let mut input_entries = Vec::new();
+    let mut input_renames = Vec::new();
+    for field in &fields.named {
+        let ident = field.ident.as_ref().expect("named field");
+        let rust_name = ident.to_string();
+        let mut input_name = rust_name.clone();
+        let mut codec = quote!(crate::registry::CreateInputCodec::Auto);
+        for attribute in &field.attrs {
+            if attribute.path().is_ident("create") {
+                attribute.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("name") {
+                        input_name = meta.value()?.parse::<syn::LitStr>()?.value();
+                        return Ok(());
+                    }
+                    if meta.path.is_ident("codec") {
+                        let value = meta.value()?.parse::<syn::LitStr>()?;
+                        codec = create_codec_tokens(&value)?;
+                        return Ok(());
+                    }
+                    Err(meta.error("expected `name` or `codec`"))
+                })?;
+            }
+        }
+        if input_name.is_empty()
+            || !input_name
+                .bytes()
+                .all(|byte| byte == b'_' || byte.is_ascii_lowercase() || byte.is_ascii_digit())
+        {
+            return Err(syn::Error::new(
+                ident.span(),
+                "construction input names must use non-empty snake_case",
+            ));
+        }
+
+        let (value_type, required) = option_inner_type(&field.ty)
+            .map(|inner| (inner, false))
+            .unwrap_or((&field.ty, true));
+        let type_name = quote!(#value_type).to_string().replace(' ', "");
+        let description = field
+            .attrs
+            .iter()
+            .filter(|attribute| attribute.path().is_ident("doc"))
+            .filter_map(|attribute| match &attribute.meta {
+                syn::Meta::NameValue(value) => match &value.value {
+                    syn::Expr::Lit(syn::ExprLit {
+                        lit: syn::Lit::Str(text),
+                        ..
+                    }) => Some(text.value().trim().to_string()),
+                    _ => None,
+                },
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+            .join(" ");
+        if input_name != rust_name {
+            let external_name = syn::LitStr::new(&input_name, ident.span());
+            let rust_name = syn::LitStr::new(&rust_name, ident.span());
+            input_renames.push(quote! {
+                if let Some(value) = object.remove(#external_name) {
+                    object.insert(#rust_name.to_string(), value);
+                }
+            });
+        }
+        let input_name = syn::LitStr::new(&input_name, ident.span());
+        let type_name = syn::LitStr::new(&type_name, ident.span());
+        let description = syn::LitStr::new(&description, ident.span());
+        field_entries.push(quote! {
+            crate::registry::FieldInfo {
+                name: #input_name,
+                type_name: #type_name,
+                description: #description,
+            }
+        });
+        input_entries.push(quote! {
+            crate::registry::CreateInputInfo {
+                name: #input_name,
+                type_name: #type_name,
+                description: #description,
+                required: #required,
+                codec: #codec,
+            }
+        });
+    }
+
+    let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();
+    Ok(quote! {
+        impl #impl_generics crate::registry::CreateSpec for #name #type_generics #where_clause {
+            const FIELDS: &'static [crate::registry::FieldInfo] = &[
+                #(#field_entries),*
+            ];
+            fn inputs() -> Vec<crate::registry::CreateInputInfo> {
+                vec![#(#input_entries),*]
+            }
+
+            fn deserialize_inputs(
+                mut data: serde_json::Value,
+            ) -> Result<Self, serde_json::Error>
+            where
+                Self: serde::de::DeserializeOwned,
+            {
+                let object = data
+                    .as_object_mut()
+                    .expect("construction inputs were validated as an object");
+                #(#input_renames)*
+                serde_json::from_value(data)
+            }
+        }
+    })
+}
+
+fn create_codec_tokens(value: &syn::LitStr) -> syn::Result<TokenStream2> {
+    let variant = match value.value().as_str() {
+        "auto" => quote!(Auto),
+        "scalar" => quote!(Scalar),
+        "json" => quote!(Json),
+        "comma-separated" => quote!(CommaSeparated),
+        "semicolon-separated" => quote!(SemicolonSeparated),
+        "edge-list" => quote!(EdgeList),
+        "arc-list" => quote!(ArcList),
+        "bipartite-edge-list" => quote!(BipartiteEdgeList),
+        "equality-pair-list" => quote!(EqualityPairList),
+        "functional-dependency-list" => quote!(FunctionalDependencyList),
+        "character-rows" => quote!(CharacterRows),
+        _ => {
+            return Err(syn::Error::new(
+                value.span(),
+                "unknown construction codec; expected one of: auto, scalar, json, comma-separated, semicolon-separated, edge-list, arc-list, bipartite-edge-list, equality-pair-list, functional-dependency-list, character-rows",
+            ))
+        }
+    };
+    Ok(quote!(crate::registry::CreateInputCodec::#variant))
+}
+
+fn option_inner_type(ty: &Type) -> Option<&Type> {
+    let Type::Path(path) = ty else {
+        return None;
+    };
+    let segment = path.path.segments.last()?;
+    if segment.ident != "Option" {
+        return None;
+    }
+    let PathArguments::AngleBracketed(arguments) = &segment.arguments else {
+        return None;
+    };
+    arguments.args.iter().find_map(|argument| match argument {
+        GenericArgument::Type(inner) => Some(inner),
+        _ => None,
+    })
+}
 
 /// Attribute macro for automatic reduction registration.
 ///
@@ -24,20 +201,21 @@ use syn::{parse_macro_input, GenericArgument, ItemImpl, Path, PathArguments, Typ
 ///
 /// # Attributes
 ///
-/// - `overhead = { expr }` — overhead specification
+/// - `transform = exact { field = expression, ... }` — exact target-parameter equalities
+/// - `transform = upper_bound { field = expression, ... }` — one rule-level upper bound
+/// - `transform = unavailable { field = "reason", ... }` — no symbolic parameter transform
+/// - `unavailable = { field = "reason", ... }` — fields that cannot be propagated
+/// - `aggregate = identity` or `aggregate = custom` — register the reduction result's
+///   `AggregateReductionResult` implementation alongside its witness extractor
 ///
-/// ## New syntax (preferred):
+/// ## Syntax
 /// ```ignore
-/// #[reduction(overhead = {
+/// #[reduction(transform = exact {
 ///     num_vars = "num_vertices^2",
-///     num_constraints = "num_edges",
+///     num_constraints = num_edges,
 /// })]
 /// ```
 ///
-/// ## Legacy syntax (still supported):
-/// ```ignore
-/// #[reduction(overhead = { ReductionOverhead::new(vec![...]) })]
-/// ```
 #[proc_macro_attribute]
 pub fn reduction(attr: TokenStream, item: TokenStream) -> TokenStream {
     let attrs = parse_macro_input!(attr as ReductionAttrs);
@@ -49,32 +227,93 @@ pub fn reduction(attr: TokenStream, item: TokenStream) -> TokenStream {
     }
 }
 
-/// Overhead specification: either new parsed syntax or legacy raw tokens.
-enum OverheadSpec {
-    /// Legacy syntax: raw token stream (e.g., `ReductionOverhead::new(...)`)
-    Legacy(TokenStream2),
-    /// New syntax: list of (field_name, expression_string) pairs
-    Parsed(Vec<(String, String)>),
+#[derive(Clone)]
+struct ParsedExpressionField {
+    name: String,
+    expression: problemreductions_expr::Expr,
 }
 
 /// Parsed attributes from #[reduction(...)]
 struct ReductionAttrs {
-    overhead: Option<OverheadSpec>,
+    transform_declared: bool,
+    relation: Option<ParameterRelationAttr>,
+    fields: Option<Vec<(String, String)>>,
+    unavailable: Option<Vec<(String, String)>>,
+    aggregate: bool,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum ParameterRelationAttr {
+    Exact,
+    UpperBound,
 }
 
 impl syn::parse::Parse for ReductionAttrs {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let mut attrs = ReductionAttrs { overhead: None };
+        let mut attrs = ReductionAttrs {
+            transform_declared: false,
+            relation: None,
+            fields: None,
+            unavailable: None,
+            aggregate: false,
+        };
 
         while !input.is_empty() {
             let ident: syn::Ident = input.parse()?;
             input.parse::<syn::Token![=]>()?;
 
             match ident.to_string().as_str() {
-                "overhead" => {
+                "transform" => {
+                    if attrs.transform_declared {
+                        return Err(syn::Error::new(
+                            ident.span(),
+                            "duplicate `transform` declaration",
+                        ));
+                    }
+                    attrs.transform_declared = true;
+                    let relation: syn::Ident = input.parse()?;
+                    let content;
+                    syn::braced!(content in input);
+                    match relation.to_string().as_str() {
+                        "exact" => {
+                            attrs.relation = Some(ParameterRelationAttr::Exact);
+                            attrs.fields = Some(parse_expression_fields(&content)?);
+                        }
+                        "upper_bound" => {
+                            attrs.relation = Some(ParameterRelationAttr::UpperBound);
+                            attrs.fields = Some(parse_expression_fields(&content)?);
+                        }
+                        "unavailable" => {
+                            attrs.unavailable = Some(parse_unavailable_fields(&content)?);
+                        }
+                        _ => {
+                            return Err(syn::Error::new(
+                                relation.span(),
+                                "expected `exact`, `upper_bound`, or `unavailable`",
+                            ));
+                        }
+                    }
+                }
+                "unavailable" => {
+                    if attrs.unavailable.is_some() {
+                        return Err(syn::Error::new(
+                            ident.span(),
+                            "duplicate `unavailable` declaration",
+                        ));
+                    }
                     let content;
                     syn::braced!(content in input);
-                    attrs.overhead = Some(parse_overhead_content(&content)?);
+                    attrs.unavailable = Some(parse_unavailable_fields(&content)?);
+                }
+                "aggregate" => {
+                    let value: syn::Ident = input.parse()?;
+                    if value != "identity" && value != "custom" {
+                        return Err(syn::Error::new(
+                            value.span(),
+                            "expected `identity` or `custom`",
+                        ));
+                    }
+                    attrs.aggregate = true;
                 }
                 _ => {
                     return Err(syn::Error::new(
@@ -89,45 +328,59 @@ impl syn::parse::Parse for ReductionAttrs {
             }
         }
 
+        if !attrs.transform_declared {
+            return Err(syn::Error::new(
+                proc_macro2::Span::call_site(),
+                "missing `transform` declaration",
+            ));
+        }
+
         Ok(attrs)
     }
 }
 
-/// Detect and parse the overhead content as either new or legacy syntax.
-///
-/// New syntax detection: the first tokens are `ident = "string_literal"`.
-/// Legacy syntax: everything else (starts with a path like `ReductionOverhead::...`).
-fn parse_overhead_content(content: syn::parse::ParseStream) -> syn::Result<OverheadSpec> {
-    // Fork to peek ahead without consuming
-    let fork = content.fork();
-
-    // Try to detect new syntax: ident = "string"
-    let is_new_syntax = fork.parse::<syn::Ident>().is_ok()
-        && fork.parse::<syn::Token![=]>().is_ok()
-        && fork.parse::<syn::LitStr>().is_ok();
-
-    if is_new_syntax {
-        // Parse new syntax: field_name = "expression", ...
-        let mut fields = Vec::new();
-        while !content.is_empty() {
-            let field_name: syn::Ident = content.parse()?;
-            content.parse::<syn::Token![=]>()?;
-            let expr_str: syn::LitStr = content.parse()?;
-            fields.push((field_name.to_string(), expr_str.value()));
-
-            if content.peek(syn::Token![,]) {
-                content.parse::<syn::Token![,]>()?;
-            }
+fn parse_expression_fields(content: syn::parse::ParseStream) -> syn::Result<Vec<(String, String)>> {
+    let mut fields = Vec::new();
+    while !content.is_empty() {
+        let field_name: syn::Ident = content.parse()?;
+        content.parse::<syn::Token![=]>()?;
+        let expression = if content.peek(syn::LitStr) {
+            content.parse::<syn::LitStr>()?.value()
+        } else {
+            content.parse::<syn::Ident>()?.to_string()
+        };
+        fields.push((field_name.to_string(), expression));
+
+        if content.peek(syn::Token![,]) {
+            content.parse::<syn::Token![,]>()?;
+        }
+    }
+    Ok(fields)
+}
+
+fn parse_unavailable_fields(
+    content: syn::parse::ParseStream,
+) -> syn::Result<Vec<(String, String)>> {
+    let mut fields = Vec::new();
+    while !content.is_empty() {
+        let field_name: syn::Ident = content.parse()?;
+        content.parse::<syn::Token![=]>()?;
+        let reason = content.parse::<syn::LitStr>()?.value();
+        if reason.trim().is_empty() {
+            return Err(syn::Error::new(
+                field_name.span(),
+                "unavailable parameter field requires a non-empty reason",
+            ));
+        }
+        fields.push((field_name.to_string(), reason));
+        if content.peek(syn::Token![,]) {
+            content.parse::<syn::Token![,]>()?;
         }
-        Ok(OverheadSpec::Parsed(fields))
-    } else {
-        // Legacy syntax: parse as raw token stream
-        let tokens: TokenStream2 = content.parse()?;
-        Ok(OverheadSpec::Legacy(tokens))
     }
+    Ok(fields)
 }
 
-/// Extract the base type name from a Type (e.g., "IndependentSet" from "IndependentSet<i32>").
+/// Extract the base type name from a Type (e.g., "IndependentSet" from "IndependentSet<i64>").
 /// Special-cases `Decision<T>` to produce `DecisionT`.
 fn extract_type_name(ty: &Type) -> Option<String> {
     match ty {
@@ -210,101 +463,35 @@ fn make_variant_fn_body(ty: &Type, type_generics: &HashSet<String>) -> syn::Resu
     Ok(quote! { <#ty as crate::traits::Problem>::variant() })
 }
 
-/// Generate overhead code from the new parsed syntax.
-///
-/// Produces a `ReductionOverhead` constructor that uses `Expr` AST values.
-fn generate_parsed_overhead(fields: &[(String, String)]) -> syn::Result<TokenStream2> {
-    let mut field_tokens = Vec::new();
-
-    for (field_name, expr_str) in fields {
-        let parsed = parser::parse_expr(expr_str).map_err(|e| {
-            syn::Error::new(
-                proc_macro2::Span::call_site(),
-                format!("error parsing overhead expression \"{expr_str}\": {e}"),
-            )
-        })?;
-
-        let expr_ast = parsed.to_expr_tokens();
-        let name_lit = field_name.as_str();
-        field_tokens.push(quote! { (#name_lit, #expr_ast) });
-    }
-
-    Ok(quote! {
-        crate::rules::registry::ReductionOverhead::new(vec![#(#field_tokens),*])
-    })
-}
-
-/// Generate a compiled overhead evaluation function from parsed overhead fields.
-///
-/// Produces a closure that downcasts `&dyn Any` to `&SourceType`, calls getter methods
-/// for each variable in the expressions, and returns a `ProblemSize`.
-fn generate_overhead_eval_fn(
+/// Parse one explicit exact or bound field declaration into the canonical expression DAG.
+fn parse_expression_fields_to_expr(
     fields: &[(String, String)],
-    source_type: &Type,
-) -> syn::Result<TokenStream2> {
-    let src_ident = syn::Ident::new("__src", proc_macro2::Span::call_site());
-
-    let mut field_eval_tokens = Vec::new();
-    for (field_name, expr_str) in fields {
-        let parsed = parser::parse_expr(expr_str).map_err(|e| {
-            syn::Error::new(
-                proc_macro2::Span::call_site(),
-                format!("error parsing overhead expression \"{expr_str}\": {e}"),
-            )
-        })?;
-
-        let eval_tokens = parsed.to_eval_tokens(&src_ident);
-        let name_lit = field_name.as_str();
-        field_eval_tokens.push(quote! { (#name_lit, (#eval_tokens).round() as usize) });
-    }
-
-    Ok(quote! {
-        |__any_src: &dyn std::any::Any| -> crate::types::ProblemSize {
-            let #src_ident = __any_src.downcast_ref::<#source_type>().unwrap();
-            crate::types::ProblemSize::new(vec![#(#field_eval_tokens),*])
-        }
-    })
-}
-
-/// Generate a function that extracts the source problem's size fields from `&dyn Any`.
-///
-/// Collects all variable names referenced in the overhead expressions, generates
-/// getter calls for each, and returns a `ProblemSize`.
-fn generate_source_size_fn(
-    fields: &[(String, String)],
-    source_type: &Type,
-) -> syn::Result<TokenStream2> {
-    let src_ident = syn::Ident::new("__src", proc_macro2::Span::call_site());
-
-    // Collect all unique variable names from overhead expressions
-    let mut var_names = std::collections::BTreeSet::new();
-    for (_, expr_str) in fields {
-        let parsed = parser::parse_expr(expr_str).map_err(|e| {
-            syn::Error::new(
-                proc_macro2::Span::call_site(),
-                format!("error parsing overhead expression \"{expr_str}\": {e}"),
-            )
-        })?;
-        for v in parsed.variables() {
-            var_names.insert(v.to_string());
-        }
-    }
-
-    let getter_tokens: Vec<_> = var_names
+) -> syn::Result<Vec<ParsedExpressionField>> {
+    fields
         .iter()
-        .map(|var| {
-            let getter = syn::Ident::new(var, proc_macro2::Span::call_site());
-            let name_lit = var.as_str();
-            quote! { (#name_lit, #src_ident.#getter() as usize) }
+        .map(|(name, source)| {
+            let expression = problemreductions_expr::Expr::try_parse(source).map_err(|error| {
+                syn::Error::new(
+                    proc_macro2::Span::call_site(),
+                    format!("error parsing parameter expression \"{source}\": {error}"),
+                )
+            })?;
+            Ok(ParsedExpressionField {
+                name: name.clone(),
+                expression,
+            })
         })
-        .collect();
+        .collect()
+}
 
-    Ok(quote! {
-        |__any_src: &dyn std::any::Any| -> crate::types::ProblemSize {
-            let #src_ident = __any_src.downcast_ref::<#source_type>().unwrap();
-            crate::types::ProblemSize::new(vec![#(#getter_tokens),*])
-        }
-    })
+fn generate_expression_fields(fields: &[ParsedExpressionField]) -> TokenStream2 {
+    let field_tokens = fields.iter().map(|field| {
+        let expression = expr_tokens(&field.expression);
+        let name = field.name.as_str();
+        quote! { (#name, #expression) }
+    });
+
+    quote! { vec![#(#field_tokens),*] }
 }
 
 /// Generate the reduction entry code
@@ -330,10 +517,18 @@ fn generate_reduction_entry(
         .ok_or_else(|| syn::Error::new_spanned(source_type, "Cannot extract source type name"))?;
     let target_name = extract_type_name(&target_type)
         .ok_or_else(|| syn::Error::new_spanned(&target_type, "Cannot extract target type name"))?;
-    let capabilities = if source_name == target_name {
-        quote! { crate::rules::EdgeCapabilities::both() }
+    let reduce_aggregate_fn = if attrs.aggregate {
+        quote! {
+            Some(|src: &dyn std::any::Any| -> Result<Box<dyn crate::rules::traits::DynAggregateReductionResult>, crate::rules::ReductionError> {
+                let src = src.downcast_ref::<#source_type>().ok_or_else(
+                    crate::rules::ReductionError::source_type_mismatch::<#source_type, #target_type>,
+                )?;
+                let result = <#source_type as crate::rules::ReduceTo<#target_type>>::reduce_to(src)?;
+                Ok(Box::new(result))
+            })
+        }
     } else {
-        quote! { crate::rules::EdgeCapabilities::witness_only() }
+        quote! { None }
     };
 
     // Collect generic parameter info from the impl block
@@ -343,35 +538,23 @@ fn generate_reduction_entry(
     let source_variant_body = make_variant_fn_body(source_type, &type_generics)?;
     let target_variant_body = make_variant_fn_body(&target_type, &type_generics)?;
 
-    // Generate overhead, eval fn, and source size fn
-    let (overhead, overhead_eval_fn, source_size_fn) = match &attrs.overhead {
-        Some(OverheadSpec::Legacy(tokens)) => {
-            let eval_fn = quote! {
-                |_: &dyn std::any::Any| -> crate::types::ProblemSize {
-                    panic!("overhead_eval_fn not available for legacy overhead syntax; \
-                            migrate to parsed syntax: field = \"expression\"")
-                }
-            };
-            let size_fn = quote! {
-                |_: &dyn std::any::Any| -> crate::types::ProblemSize {
-                    crate::types::ProblemSize::new(vec![])
-                }
-            };
-            (tokens.clone(), eval_fn, size_fn)
-        }
-        Some(OverheadSpec::Parsed(fields)) => {
-            let overhead_tokens = generate_parsed_overhead(fields)?;
-            let eval_fn = generate_overhead_eval_fn(fields, source_type)?;
-            let size_fn = generate_source_size_fn(fields, source_type)?;
-            (overhead_tokens, eval_fn, size_fn)
+    let fields = parse_expression_fields_to_expr(attrs.fields.as_deref().unwrap_or_default())?;
+    let field_tokens = generate_expression_fields(&fields);
+    let relation_tokens = match attrs.relation {
+        Some(ParameterRelationAttr::Exact) => {
+            quote! { Some(crate::parameters::ParameterRelation::Exact) }
         }
-        None => {
-            return Err(syn::Error::new(
-                proc_macro2::Span::call_site(),
-                "Missing overhead specification. Use #[reduction(overhead = { ... })] and specify overhead expressions for all target problem size fields.",
-            ));
+        Some(ParameterRelationAttr::UpperBound) => {
+            quote! { Some(crate::parameters::ParameterRelation::UpperBound) }
         }
+        None => quote! { None },
     };
+    let unavailable_tokens = attrs
+        .unavailable
+        .as_deref()
+        .unwrap_or_default()
+        .iter()
+        .map(|(field, reason)| quote! { crate::rules::registry::UnavailableParameterField { field: #field, reason: #reason } });
 
     // Generate the combined output
     let output = quote! {
@@ -383,22 +566,21 @@ fn generate_reduction_entry(
                 target_name: #target_name,
                 source_variant_fn: || { #source_variant_body },
                 target_variant_fn: || { #target_variant_body },
-                overhead_fn: || { #overhead },
+                parameter_declarations_fn: || crate::rules::registry::ReductionParameterDeclarations {
+                    relation: #relation_tokens,
+                    fields: #field_tokens,
+                    unavailable: vec![#(#unavailable_tokens),*],
+                },
                 module_path: module_path!(),
-                reduce_fn: Some(|src: &dyn std::any::Any| -> Box<dyn crate::rules::traits::DynReductionResult> {
-                    let src = src.downcast_ref::<#source_type>().unwrap_or_else(|| {
-                        panic!(
-                            "DynReductionResult: source type mismatch: expected `{}`, got `{}`",
-                            std::any::type_name::<#source_type>(),
-                            std::any::type_name_of_val(src),
-                        )
-                    });
-                    Box::new(<#source_type as crate::rules::ReduceTo<#target_type>>::reduce_to(src))
+                reduce_fn: Some(|src: &dyn std::any::Any| -> Result<Box<dyn crate::rules::traits::DynReductionResult>, crate::rules::ReductionError> {
+                    let src = src.downcast_ref::<#source_type>().ok_or_else(
+                        crate::rules::ReductionError::source_type_mismatch::<#source_type, #target_type>,
+                    )?;
+                    let result = <#source_type as crate::rules::ReduceTo<#target_type>>::reduce_to(src)?;
+                    Ok(Box::new(result))
                 }),
-                reduce_aggregate_fn: None,
-                capabilities: #capabilities,
-                overhead_eval_fn: #overhead_eval_fn,
-                source_size_fn: #source_size_fn,
+                reduce_aggregate_fn: #reduce_aggregate_fn,
+                turing: false,
             }
         }
 
@@ -450,6 +632,8 @@ struct DeclareVariantEntry {
     ty: Type,
     complexity: syn::LitStr,
     aliases: Vec<syn::LitStr>,
+    create_spec: Option<Type>,
+    random: bool,
 }
 
 impl syn::parse::Parse for DeclareVariantsInput {
@@ -466,15 +650,14 @@ impl syn::parse::Parse for DeclareVariantsInput {
             input.parse::<syn::Token![=>]>()?;
             let complexity: syn::LitStr = input.parse()?;
 
-            // Optional: `aliases ["X", "Y", ...]`
-            let aliases = if input.peek(syn::Ident) {
-                let fork = input.fork();
-                let ident: syn::Ident = fork.parse()?;
+            let mut aliases = Vec::new();
+            let mut create_spec = None;
+            let mut random = false;
+            while input.peek(syn::Ident) {
+                let ident: syn::Ident = input.parse()?;
                 if ident == "aliases" {
-                    input.parse::<syn::Ident>()?;
                     let content;
                     syn::bracketed!(content in input);
-                    let mut out = Vec::new();
                     while !content.is_empty() {
                         let lit: syn::LitStr = content.parse()?;
                         if lit.value().trim().is_empty() {
@@ -483,29 +666,36 @@ impl syn::parse::Parse for DeclareVariantsInput {
                                 "variant alias must not be empty or whitespace-only",
                             ));
                         }
-                        out.push(lit);
+                        aliases.push(lit);
                         if content.peek(syn::Token![,]) {
                             content.parse::<syn::Token![,]>()?;
                         }
                     }
-                    out
-                } else if fork.peek(syn::token::Bracket) {
+                } else if ident == "create" {
+                    if create_spec.is_some() {
+                        return Err(syn::Error::new(ident.span(), "duplicate `create` clause"));
+                    }
+                    create_spec = Some(input.parse()?);
+                } else if ident == "random" {
+                    if random {
+                        return Err(syn::Error::new(ident.span(), "duplicate `random` clause"));
+                    }
+                    random = true;
+                } else {
                     return Err(syn::Error::new(
                         ident.span(),
-                        format!("expected 'aliases', found '{ident}'"),
+                        format!("expected `aliases`, `create`, or `random`, found `{ident}`"),
                     ));
-                } else {
-                    Vec::new()
                 }
-            } else {
-                Vec::new()
-            };
+            }
 
             entries.push(DeclareVariantEntry {
                 is_default,
                 ty,
                 complexity,
                 aliases,
+                create_spec,
+                random,
             });
 
             if input.peek(syn::Token![,]) {
@@ -532,8 +722,8 @@ impl syn::parse::Parse for DeclareVariantsInput {
 ///
 /// ```text
 /// declare_variants! {
-///     MaximumIndependentSet<SimpleGraph, i32>   => "1.1996^num_vertices",
-///     MaximumIndependentSet<KingsSubgraph, i32> => "2^sqrt(num_vertices)",
+///     MaximumIndependentSet<SimpleGraph, i64>   => "1.1996^num_vertices",
+///     MaximumIndependentSet<KingsSubgraph, i64> => "2^sqrt(num_vertices)",
 /// }
 /// ```
 #[proc_macro]
@@ -545,6 +735,99 @@ pub fn declare_variants(input: TokenStream) -> TokenStream {
     }
 }
 
+struct BruteForceRegistrationInput {
+    entries: Vec<BruteForceRegistrationEntry>,
+}
+
+struct BruteForceRegistrationEntry {
+    ty: Type,
+    decoder: Option<syn::ExprClosure>,
+}
+
+impl syn::parse::Parse for BruteForceRegistrationInput {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let mut entries = Vec::new();
+        while !input.is_empty() {
+            let ty = input.parse()?;
+            let decoder = if input.peek(syn::Ident) {
+                let ident: syn::Ident = input.parse()?;
+                if ident != "decode" {
+                    return Err(syn::Error::new(ident.span(), "expected `decode`"));
+                }
+                Some(input.parse()?)
+            } else {
+                None
+            };
+            entries.push(BruteForceRegistrationEntry { ty, decoder });
+            if input.peek(syn::Token![,]) {
+                input.parse::<syn::Token![,]>()?;
+            }
+        }
+        Ok(Self { entries })
+    }
+}
+
+/// Register finite Cartesian reference solvers for concrete problem variants.
+#[proc_macro]
+pub fn register_brute_force(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as BruteForceRegistrationInput);
+    let entries = input.entries.iter().map(|entry| {
+        let ty = &entry.ty;
+        let decode = if let Some(decoder) = &entry.decoder {
+            quote! { |indices| (#decoder)(problem, indices) }
+        } else {
+            quote! { |indices| indices }
+        };
+        quote! {
+            crate::inventory::submit! {
+                crate::solvers::BruteForceRegistration {
+                    source_name: <#ty as crate::traits::Problem>::NAME,
+                    source_variant_fn: || <#ty as crate::traits::Problem>::variant(),
+                    dimensions_fn: |any| {
+                        let problem = any
+                            .downcast_ref::<#ty>()
+                            .expect("brute-force registration received the wrong problem type");
+                        <#ty as crate::solvers::BruteForceProblem>::dimensions(problem)
+                    },
+                    solve_fn: |any| {
+                        let problem = any
+                            .downcast_ref::<#ty>()
+                            .expect("brute-force registration received the wrong problem type");
+                        let solver = crate::solvers::BruteForce::new();
+                        let Some((solution, value)) = solver.find_cartesian(problem, #decode)? else {
+                            return Ok(None);
+                        };
+                        let evaluation = crate::registry::format_metric(&value);
+                        Ok(Some((
+                            serde_json::to_value(solution).expect("serialize solution failed"),
+                            evaluation,
+                        )))
+                    },
+                    solve_typed_fn: |any| {
+                        let problem = any
+                            .downcast_ref::<#ty>()
+                            .expect("brute-force registration received the wrong problem type");
+                        let solver = crate::solvers::BruteForce::new();
+                        Ok(solver
+                            .find_cartesian(problem, #decode)?
+                            .map(|(solution, _)| Box::new(solution) as Box<dyn std::any::Any>))
+                    },
+                    solve_typed_with_witnesses_fn: |any| {
+                        let problem = any
+                            .downcast_ref::<#ty>()
+                            .expect("brute-force registration received the wrong problem type");
+                        let solver = crate::solvers::BruteForce::new();
+                        Ok(Box::new(
+                            solver.solve_with_witnesses_cartesian(problem, #decode)?,
+                        ))
+                    },
+                }
+            }
+        }
+    });
+    quote! { #(#entries)* }.into()
+}
+
 /// Generate code for all `declare_variants!` entries.
 fn generate_declare_variants(input: &DeclareVariantsInput) -> syn::Result<TokenStream2> {
     // Validate default markers per problem name.
@@ -588,56 +871,67 @@ fn generate_declare_variants(input: &DeclareVariantsInput) -> syn::Result<TokenS
 
     for entry in &input.entries {
         let ty = &entry.ty;
+        let create_spec = &entry.create_spec;
+        let random = entry.random;
         let complexity_str = entry.complexity.value();
         let is_default = entry.is_default;
         let alias_lits: Vec<_> = entry.aliases.iter().map(|s| s.value()).collect();
 
         // Parse the complexity expression to validate syntax
-        let parsed = parser::parse_expr(&complexity_str).map_err(|e| {
+        let parsed = problemreductions_expr::Expr::try_parse(&complexity_str).map_err(|e| {
             syn::Error::new(
                 entry.complexity.span(),
                 format!("invalid complexity expression \"{complexity_str}\": {e}"),
             )
         })?;
 
-        // Generate getter validation for all variables
-        let vars = parsed.variables();
-        let validation = if vars.is_empty() {
-            quote! {}
-        } else {
-            let src_ident = syn::Ident::new("__src", proc_macro2::Span::call_site());
-            let getter_checks: Vec<_> = vars
-                .iter()
-                .map(|var| {
-                    let getter = syn::Ident::new(var, proc_macro2::Span::call_site());
-                    quote! { let _ = #src_ident.#getter(); }
-                })
-                .collect();
+        // Generate a compiled complexity evaluator over the problem-owned parameters.
+        let complexity_eval_fn = generate_complexity_eval_fn(&parsed, ty)?;
 
+        let construction_fields = if let Some(create_spec) = create_spec {
             quote! {
-                const _: () = {
-                    #[allow(unused)]
-                    fn _validate_complexity(#src_ident: &#ty) {
-                        #(#getter_checks)*
-                    }
-                };
+                create_inputs: Some(<#create_spec as crate::registry::CreateSpec>::inputs),
+                construct_fn: |data: serde_json::Value| -> Result<Box<dyn crate::registry::DynProblem>, crate::registry::ConstructionError> {
+                    crate::registry::validate_create_inputs(
+                        &<#create_spec as crate::registry::CreateSpec>::inputs(),
+                        &data,
+                    )?;
+                    let spec: #create_spec = <#create_spec as crate::registry::CreateSpec>::deserialize_inputs(data)
+                        .map_err(|error| crate::registry::ConstructionError::InvalidInput(error.to_string()))?;
+                    let problem: #ty = <#ty as std::convert::TryFrom<#create_spec>>::try_from(spec)
+                        .map_err(Into::<crate::registry::ConstructionError>::into)?;
+                    Ok(Box::new(problem))
+                },
+            }
+        } else {
+            quote! {
+                create_inputs: None,
+                construct_fn: |data: serde_json::Value| -> Result<Box<dyn crate::registry::DynProblem>, crate::registry::ConstructionError> {
+                    let problem_type = <#ty as crate::traits::Problem>::problem_type();
+                    crate::registry::validate_direct_create_inputs(problem_type.fields, &data)?;
+                    let problem: #ty = serde_json::from_value(data)
+                        .map_err(|error| crate::registry::ConstructionError::InvalidInput(error.to_string()))?;
+                    Ok(Box::new(problem))
+                },
             }
         };
 
-        // Generate compiled complexity eval fn
-        let complexity_eval_fn = generate_complexity_eval_fn(&parsed, ty)?;
-
-        // Generate dispatch fields based on aggregate value solving plus optional witnesses.
-        let solve_value_body = quote! {
-            let total = <crate::solvers::BruteForce as crate::solvers::Solver>::solve(&solver, p);
-            crate::registry::format_metric(&total)
-        };
-
-        let solve_witness_body = quote! {
-            let config = crate::solvers::BruteForce::find_witness(&solver, p)?;
+        let random_registration = if random {
+            quote! {
+                Some(crate::registry::RandomRegistration {
+                    inputs: <#ty as crate::registry::RandomGenerate>::inputs,
+                    generate: |data: serde_json::Value| -> Result<Box<dyn crate::registry::DynProblem>, crate::registry::ConstructionError> {
+                        Ok(Box::new(<#ty as crate::registry::RandomGenerate>::generate(data)?))
+                    },
+                })
+            }
+        } else {
+            quote! { None }
         };
 
         let dispatch_fields = quote! {
+            #construction_fields
+            random: #random_registration,
             factory: |data: serde_json::Value| -> Result<Box<dyn crate::registry::DynProblem>, serde_json::Error> {
                 let p: #ty = serde_json::from_value(data)?;
                 Ok(Box::new(p))
@@ -646,20 +940,6 @@ fn generate_declare_variants(input: &DeclareVariantsInput) -> syn::Result<TokenS
                 let p = any.downcast_ref::<#ty>()?;
                 Some(serde_json::to_value(p).expect("serialize failed"))
             },
-            solve_value_fn: |any: &dyn std::any::Any| -> String {
-                let p = any
-                    .downcast_ref::<#ty>()
-                    .expect("type-erased solve_value downcast failed");
-                let solver = crate::solvers::BruteForce::new();
-                #solve_value_body
-            },
-            solve_witness_fn: |any: &dyn std::any::Any| -> Option<(Vec<usize>, String)> {
-                let p = any.downcast_ref::<#ty>()?;
-                let solver = crate::solvers::BruteForce::new();
-                #solve_witness_body
-                let evaluation = crate::registry::format_metric(&crate::traits::Problem::evaluate(p, &config));
-                Some((config, evaluation))
-            },
         };
 
         output.extend(quote! {
@@ -671,13 +951,18 @@ fn generate_declare_variants(input: &DeclareVariantsInput) -> syn::Result<TokenS
                     variant_fn: || <#ty as crate::traits::Problem>::variant(),
                     complexity: #complexity_str,
                     complexity_eval_fn: #complexity_eval_fn,
+                    parameter_names_fn: || <#ty as crate::traits::Problem>::parameter_names(),
+                    parameter_measure_fn: |any: &dyn std::any::Any| {
+                        let problem = any
+                            .downcast_ref::<#ty>()
+                            .expect("type-erased parameter measurement downcast failed");
+                        <#ty as crate::traits::Problem>::parameters(problem)
+                    },
                     is_default: #is_default,
                     aliases: &[#(#alias_lits),*],
                     #dispatch_fields
                 }
             }
-
-            #validation
         });
     }
 
@@ -686,18 +971,19 @@ fn generate_declare_variants(input: &DeclareVariantsInput) -> syn::Result<TokenS
 
 /// Generate a compiled complexity evaluation function.
 ///
-/// Produces a closure that downcasts `&dyn Any` to the problem type, calls getter
-/// methods for all variables, and returns the worst-case time complexity as f64.
+/// Produces a closure that downcasts `&dyn Any` to the problem type, reads its
+/// canonical parameters, and returns the worst-case time complexity as `f64`.
 fn generate_complexity_eval_fn(
-    parsed: &parser::ParsedExpr,
+    parsed: &problemreductions_expr::Expr,
     ty: &Type,
 ) -> syn::Result<TokenStream2> {
-    let src_ident = syn::Ident::new("__src", proc_macro2::Span::call_site());
-    let eval_tokens = parsed.to_eval_tokens(&src_ident);
+    let parameters_ident = syn::Ident::new("__parameters", proc_macro2::Span::call_site());
+    let eval_tokens = complexity_estimate_tokens(parsed, &parameters_ident)?;
 
     Ok(quote! {
         |__any_src: &dyn std::any::Any| -> f64 {
-            let #src_ident = __any_src.downcast_ref::<#ty>().unwrap();
+            let __problem = __any_src.downcast_ref::<#ty>().unwrap();
+            let #parameters_ident = <#ty as crate::traits::Problem>::parameters(__problem);
             #eval_tokens
         }
     })
@@ -708,9 +994,18 @@ mod tests {
     use super::*;
     use syn::{parse_str, Type};
 
+    #[test]
+    fn parameters_report_expression_domain_errors() {
+        let fields = vec![("num_vertices".to_string(), "0 / 0".to_string())];
+        let Err(error) = parse_expression_fields_to_expr(&fields) else {
+            panic!("invalid parameter expression was accepted");
+        };
+        assert!(error.to_string().contains("division by zero"));
+    }
+
     #[test]
     fn extract_type_name_strips_non_decision_generics() {
-        let ty: Type = parse_str("MinimumVertexCover<SimpleGraph, i32>").unwrap();
+        let ty: Type = parse_str("MinimumVertexCover<SimpleGraph, i64>").unwrap();
         assert_eq!(
             extract_type_name(&ty).as_deref(),
             Some("MinimumVertexCover")
@@ -719,7 +1014,7 @@ mod tests {
 
     #[test]
     fn extract_type_name_unwraps_decision_inner_type() {
-        let ty: Type = parse_str("Decision<MinimumVertexCover<SimpleGraph, i32>>").unwrap();
+        let ty: Type = parse_str("Decision<MinimumVertexCover<SimpleGraph, i64>>").unwrap();
         assert_eq!(
             extract_type_name(&ty).as_deref(),
             Some("DecisionMinimumVertexCover")
@@ -842,11 +1137,99 @@ mod tests {
             Ok(_) => panic!("unknown aliases keyword should be rejected"),
             Err(err) => err,
         };
-        assert_eq!(err.to_string(), "expected 'aliases', found 'nicknames'");
+        assert_eq!(
+            err.to_string(),
+            "expected `aliases`, `create`, or `random`, found `nicknames`"
+        );
+    }
+
+    #[test]
+    fn create_spec_derive_generates_required_optional_and_codec_metadata() {
+        let input: DeriveInput = syn::parse_quote! {
+            struct ExampleCreateSpec {
+                /// Required edge data.
+                #[create(name = "edges", codec = "edge-list")]
+                graph_edges: Vec<(usize, usize)>,
+                /// Optional limit.
+                limit: Option<usize>,
+            }
+        };
+        let tokens = generate_create_spec(&input).unwrap().to_string();
+        assert!(tokens.contains("CreateSpec for ExampleCreateSpec"));
+        assert!(tokens.contains("const FIELDS"));
+        assert!(tokens.contains("crate :: registry :: FieldInfo"));
+        assert!(tokens.contains("name : \"edges\""));
+        assert!(tokens.contains("type_name : \"Vec<(usize,usize)>\""));
+        assert!(tokens.contains("required : true"));
+        assert!(tokens.contains("required : false"));
+        assert!(tokens.contains("CreateInputCodec :: EdgeList"));
+        assert!(tokens.contains("Required edge data."));
+    }
+
+    #[test]
+    fn create_spec_derive_rejects_unknown_codec() {
+        let input: DeriveInput = syn::parse_quote! {
+            struct ExampleCreateSpec {
+                #[create(codec = "model-specific")]
+                value: usize,
+            }
+        };
+        let error = generate_create_spec(&input).unwrap_err();
+        assert!(error.to_string().contains("unknown construction codec"));
+    }
+
+    #[test]
+    fn create_spec_derive_supports_generics() {
+        let input: DeriveInput = syn::parse_quote! {
+            struct ExampleCreateSpec<T>
+            where
+                T: Clone,
+            {
+                /// Generic value.
+                value: T,
+            }
+        };
+        let tokens = generate_create_spec(&input).unwrap().to_string();
+        assert!(tokens.contains("impl < T > crate :: registry :: CreateSpec"));
+        assert!(tokens.contains("for ExampleCreateSpec < T >"));
+        assert!(tokens.contains("where T : Clone"));
+    }
+
+    #[test]
+    fn declare_variants_generates_custom_constructor() {
+        let input: DeclareVariantsInput = syn::parse_quote! {
+            default Foo => "1" create FooCreateSpec aliases ["F"],
+        };
+        let tokens = generate_declare_variants(&input).unwrap().to_string();
+        assert!(tokens.contains("create_inputs : Some"));
+        assert!(tokens.contains("FooCreateSpec as crate :: registry :: CreateSpec"));
+        assert!(tokens.contains("TryFrom < FooCreateSpec >"));
+        assert!(tokens.contains("validate_create_inputs"));
     }
 
     #[test]
-    fn declare_variants_generates_aggregate_value_and_witness_dispatch() {
+    fn declare_variants_generates_direct_constructor_by_default() {
+        let input: DeclareVariantsInput = syn::parse_quote! {
+            default Foo => "1",
+        };
+        let tokens = generate_declare_variants(&input).unwrap().to_string();
+        assert!(tokens.contains("create_inputs : None"));
+        assert!(tokens.contains("validate_direct_create_inputs"));
+        assert!(tokens.contains("construct_fn :"));
+    }
+
+    #[test]
+    fn declare_variants_rejects_duplicate_create_clause() {
+        let error = syn::parse_str::<DeclareVariantsInput>(
+            "default Foo => \"1\" create First create Second",
+        )
+        .err()
+        .expect("duplicate create clause must fail");
+        assert_eq!(error.to_string(), "duplicate `create` clause");
+    }
+
+    #[test]
+    fn declare_variants_generates_model_dispatch_without_solver_dispatch() {
         let input: DeclareVariantsInput = syn::parse_quote! {
             default Foo => "1",
         };
@@ -856,14 +1239,8 @@ mod tests {
             tokens.contains("serialize_fn :"),
             "expected serialize_fn field"
         );
-        assert!(
-            tokens.contains("solve_value_fn :"),
-            "expected solve_value_fn field"
-        );
-        assert!(
-            tokens.contains("solve_witness_fn :"),
-            "expected solve_witness_fn field"
-        );
+        assert!(!tokens.contains("solve_typed_fn :"));
+        assert!(!tokens.contains("solve_fn :"));
         assert!(
             !tokens.contains("factory : None"),
             "factory should not be None"
@@ -872,22 +1249,7 @@ mod tests {
             !tokens.contains("serialize_fn : None"),
             "serialize_fn should not be None"
         );
-        assert!(
-            !tokens.contains("solve_value_fn : None"),
-            "solve_value_fn should not be None"
-        );
-        assert!(
-            !tokens.contains("solve_witness_fn : None"),
-            "solve_witness_fn should not be None"
-        );
-        assert!(
-            tokens.contains("let total ="),
-            "expected aggregate value solve"
-        );
-        assert!(
-            tokens.contains("find_witness"),
-            "expected find_witness in tokens"
-        );
+        assert!(!tokens.contains("find_cartesian"));
         assert!(
             !tokens.contains("find_best"),
             "did not expect legacy find_best in tokens"
@@ -902,7 +1264,7 @@ mod tests {
     fn reduction_rejects_unexpected_attribute() {
         let extra_attr = syn::Ident::new("extra", proc_macro2::Span::call_site());
         let parse_result = syn::parse2::<ReductionAttrs>(quote! {
-            #extra_attr = "unexpected", overhead = { num_vertices = "num_vertices" }
+            #extra_attr = "unexpected", transform = exact { num_vertices = "num_vertices" }
         });
         let err = match parse_result {
             Ok(_) => panic!("unexpected reduction attribute should be rejected"),
@@ -912,26 +1274,96 @@ mod tests {
     }
 
     #[test]
-    fn reduction_accepts_overhead_attribute() {
+    fn reduction_registers_explicit_aggregate_mapping() {
+        let implementation: syn::ItemImpl = syn::parse_quote! {
+            impl ReduceTo<Target> for Source {}
+        };
+        for (declaration, enabled) in [
+            (quote! {}, false),
+            (quote! { aggregate = identity, }, true),
+            (quote! { aggregate = custom, }, true),
+        ] {
+            let attrs: ReductionAttrs = syn::parse2(quote! {
+                #declaration transform = exact { num_vertices = "num_vertices" }
+            })
+            .unwrap();
+            let tokens = generate_reduction_entry(&attrs, &implementation)
+                .unwrap()
+                .to_string();
+            assert_eq!(tokens.contains("reduce_aggregate_fn : Some"), enabled);
+        }
+        assert!(syn::parse2::<ReductionAttrs>(quote! {
+            aggregate = unknown, transform = exact { num_vertices = "num_vertices" }
+        })
+        .is_err());
+    }
+
+    #[test]
+    fn reduction_accepts_explicit_transform_attributes() {
         let attrs: ReductionAttrs = syn::parse_quote! {
-            overhead = { n = "n" }
+            transform = upper_bound { n = n, squared = "n^2" },
+            unavailable = { encoding_bits = "coefficient magnitudes are not tracked" }
         };
-        assert!(attrs.overhead.is_some());
+        assert_eq!(
+            attrs.fields,
+            Some(vec![
+                ("n".to_string(), "n".to_string()),
+                ("squared".to_string(), "n^2".to_string()),
+            ])
+        );
+        assert_eq!(attrs.relation, Some(ParameterRelationAttr::UpperBound));
+        assert_eq!(
+            attrs.unavailable,
+            Some(vec![(
+                "encoding_bits".into(),
+                "coefficient magnitudes are not tracked".into()
+            )])
+        );
+    }
+
+    #[test]
+    fn reduction_rejects_legacy_overhead_attribute() {
+        let result = syn::parse2::<ReductionAttrs>(quote! {
+            overhead = { ReductionOverhead::default() }
+        });
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn reduction_rejects_legacy_exact_and_bound_attributes() {
+        assert!(syn::parse2::<ReductionAttrs>(quote! {
+            exact = { n = "n" }
+        })
+        .is_err());
+        assert!(syn::parse2::<ReductionAttrs>(quote! {
+            bound = { n = "n" }
+        })
+        .is_err());
+    }
+
+    #[test]
+    fn reduction_requires_unavailable_to_be_the_primary_transform_declaration() {
+        assert!(syn::parse2::<ReductionAttrs>(quote! {
+            unavailable = { n = "not represented" }
+        })
+        .is_err());
+        assert!(syn::parse2::<ReductionAttrs>(quote! {
+            transform = unavailable { n = "not represented" }
+        })
+        .is_ok());
     }
 
     #[test]
-    fn declare_variants_codegen_uses_required_dispatch_fields() {
+    fn declare_variants_codegen_uses_required_model_dispatch_fields() {
         let input: DeclareVariantsInput = syn::parse_quote! {
             default Foo => "1",
         };
         let tokens = generate_declare_variants(&input).unwrap().to_string();
         assert!(tokens.contains("factory :"));
         assert!(tokens.contains("serialize_fn :"));
-        assert!(tokens.contains("solve_value_fn :"));
-        assert!(tokens.contains("solve_witness_fn :"));
+        assert!(!tokens.contains("solve_fn :"));
+        assert!(!tokens.contains("solve_typed_fn :"));
         assert!(!tokens.contains("factory : None"));
         assert!(!tokens.contains("serialize_fn : None"));
-        assert!(!tokens.contains("solve_value_fn : None"));
-        assert!(!tokens.contains("solve_witness_fn : None"));
     }
 }
diff --git a/problemreductions-macros/src/parser.rs b/problemreductions-macros/src/parser.rs
deleted file mode 100644
index 36e9505cd..000000000
--- a/problemreductions-macros/src/parser.rs
+++ /dev/null
@@ -1,489 +0,0 @@
-//! Pratt parser for overhead expression strings.
-//!
-//! Parses expressions like:
-//! - `"num_vertices"`
-//! - `"num_vertices^2"`
-//! - `"num_edges + num_vertices^2"`
-//! - `"3 * num_vertices"`
-//! - `"exp(num_vertices^2)"`
-//! - `"sqrt(num_edges)"`
-//!
-//! Grammar:
-//!   expr     = term (('+' | '-') term)*
-//!   term     = factor (('*' | '/') factor)*
-//!   factor   = unary ('^' factor)?        // right-associative
-//!   unary    = '-' unary | primary
-//!   primary  = NUMBER | IDENT | func_call | '(' expr ')'
-//!   func_call = ('exp' | 'log' | 'sqrt' | 'factorial') '(' expr ')'
-
-use proc_macro2::TokenStream;
-use quote::quote;
-
-/// Parsed expression node (intermediate representation before codegen).
-#[derive(Debug, Clone, PartialEq)]
-pub enum ParsedExpr {
-    Const(f64),
-    Var(String),
-    Add(Box<ParsedExpr>, Box<ParsedExpr>),
-    Sub(Box<ParsedExpr>, Box<ParsedExpr>),
-    Mul(Box<ParsedExpr>, Box<ParsedExpr>),
-    Div(Box<ParsedExpr>, Box<ParsedExpr>),
-    Pow(Box<ParsedExpr>, Box<ParsedExpr>),
-    Neg(Box<ParsedExpr>),
-    Exp(Box<ParsedExpr>),
-    Log(Box<ParsedExpr>),
-    Sqrt(Box<ParsedExpr>),
-    Factorial(Box<ParsedExpr>),
-}
-
-#[derive(Debug, Clone, PartialEq)]
-enum Token {
-    Number(f64),
-    Ident(String),
-    Plus,
-    Minus,
-    Star,
-    Slash,
-    Caret,
-    LParen,
-    RParen,
-}
-
-fn tokenize(input: &str) -> Result<Vec<Token>, String> {
-    let mut tokens = Vec::new();
-    let mut chars = input.chars().peekable();
-    while let Some(&ch) = chars.peek() {
-        match ch {
-            ' ' | '\t' | '\n' => {
-                chars.next();
-            }
-            '+' => {
-                chars.next();
-                tokens.push(Token::Plus);
-            }
-            '-' => {
-                chars.next();
-                tokens.push(Token::Minus);
-            }
-            '*' => {
-                chars.next();
-                tokens.push(Token::Star);
-            }
-            '/' => {
-                chars.next();
-                tokens.push(Token::Slash);
-            }
-            '^' => {
-                chars.next();
-                tokens.push(Token::Caret);
-            }
-            '(' => {
-                chars.next();
-                tokens.push(Token::LParen);
-            }
-            ')' => {
-                chars.next();
-                tokens.push(Token::RParen);
-            }
-            c if c.is_ascii_digit() || c == '.' => {
-                let mut num = String::new();
-                while let Some(&c) = chars.peek() {
-                    if c.is_ascii_digit() || c == '.' {
-                        num.push(c);
-                        chars.next();
-                    } else {
-                        break;
-                    }
-                }
-                let val: f64 = num.parse().map_err(|_| format!("invalid number: {num}"))?;
-                tokens.push(Token::Number(val));
-            }
-            c if c.is_ascii_alphabetic() || c == '_' => {
-                let mut ident = String::new();
-                while let Some(&c) = chars.peek() {
-                    if c.is_ascii_alphanumeric() || c == '_' {
-                        ident.push(c);
-                        chars.next();
-                    } else {
-                        break;
-                    }
-                }
-                tokens.push(Token::Ident(ident));
-            }
-            _ => return Err(format!("unexpected character: '{ch}'")),
-        }
-    }
-    Ok(tokens)
-}
-
-struct Parser {
-    tokens: Vec<Token>,
-    pos: usize,
-}
-
-impl Parser {
-    fn new(tokens: Vec<Token>) -> Self {
-        Self { tokens, pos: 0 }
-    }
-
-    fn peek(&self) -> Option<&Token> {
-        self.tokens.get(self.pos)
-    }
-
-    fn advance(&mut self) -> Option<Token> {
-        let tok = self.tokens.get(self.pos).cloned();
-        self.pos += 1;
-        tok
-    }
-
-    fn expect(&mut self, expected: &Token) -> Result<(), String> {
-        match self.advance() {
-            Some(ref tok) if tok == expected => Ok(()),
-            Some(tok) => Err(format!("expected {expected:?}, got {tok:?}")),
-            None => Err(format!("expected {expected:?}, got end of input")),
-        }
-    }
-
-    fn parse_expr(&mut self) -> Result<ParsedExpr, String> {
-        let mut left = self.parse_term()?;
-        while matches!(self.peek(), Some(Token::Plus) | Some(Token::Minus)) {
-            let op = self.advance().unwrap();
-            let right = self.parse_term()?;
-            left = match op {
-                Token::Plus => ParsedExpr::Add(Box::new(left), Box::new(right)),
-                Token::Minus => ParsedExpr::Sub(Box::new(left), Box::new(right)),
-                _ => unreachable!(),
-            };
-        }
-        Ok(left)
-    }
-
-    fn parse_term(&mut self) -> Result<ParsedExpr, String> {
-        let mut left = self.parse_factor()?;
-        while matches!(self.peek(), Some(Token::Star) | Some(Token::Slash)) {
-            let op = self.advance().unwrap();
-            let right = self.parse_factor()?;
-            left = match op {
-                Token::Star => ParsedExpr::Mul(Box::new(left), Box::new(right)),
-                Token::Slash => ParsedExpr::Div(Box::new(left), Box::new(right)),
-                _ => unreachable!(),
-            };
-        }
-        Ok(left)
-    }
-
-    fn parse_factor(&mut self) -> Result<ParsedExpr, String> {
-        let base = self.parse_unary()?;
-        if matches!(self.peek(), Some(Token::Caret)) {
-            self.advance();
-            let exp = self.parse_factor()?; // right-associative
-            Ok(ParsedExpr::Pow(Box::new(base), Box::new(exp)))
-        } else {
-            Ok(base)
-        }
-    }
-
-    fn parse_unary(&mut self) -> Result<ParsedExpr, String> {
-        if matches!(self.peek(), Some(Token::Minus)) {
-            self.advance();
-            let expr = self.parse_unary()?;
-            Ok(ParsedExpr::Neg(Box::new(expr)))
-        } else {
-            self.parse_primary()
-        }
-    }
-
-    fn parse_primary(&mut self) -> Result<ParsedExpr, String> {
-        match self.advance() {
-            Some(Token::Number(n)) => Ok(ParsedExpr::Const(n)),
-            Some(Token::Ident(name)) => {
-                // Check for function call: exp(...), log(...), sqrt(...)
-                if matches!(self.peek(), Some(Token::LParen)) {
-                    self.advance(); // consume '('
-                    let arg = self.parse_expr()?;
-                    self.expect(&Token::RParen)?;
-                    match name.as_str() {
-                        "exp" => Ok(ParsedExpr::Exp(Box::new(arg))),
-                        "log" => Ok(ParsedExpr::Log(Box::new(arg))),
-                        "sqrt" => Ok(ParsedExpr::Sqrt(Box::new(arg))),
-                        "factorial" => Ok(ParsedExpr::Factorial(Box::new(arg))),
-                        _ => Err(format!("unknown function: {name}")),
-                    }
-                } else {
-                    Ok(ParsedExpr::Var(name))
-                }
-            }
-            Some(Token::LParen) => {
-                let expr = self.parse_expr()?;
-                self.expect(&Token::RParen)?;
-                Ok(expr)
-            }
-            Some(tok) => Err(format!("unexpected token: {tok:?}")),
-            None => Err("unexpected end of input".to_string()),
-        }
-    }
-}
-
-/// Parse an expression string into a ParsedExpr.
-pub fn parse_expr(input: &str) -> Result<ParsedExpr, String> {
-    let tokens = tokenize(input)?;
-    let mut parser = Parser::new(tokens);
-    let expr = parser.parse_expr()?;
-    if parser.pos != parser.tokens.len() {
-        return Err(format!(
-            "unexpected trailing tokens at position {}",
-            parser.pos
-        ));
-    }
-    Ok(expr)
-}
-
-impl ParsedExpr {
-    /// Generate TokenStream that constructs an `Expr` value.
-    pub fn to_expr_tokens(&self) -> TokenStream {
-        match self {
-            ParsedExpr::Const(c) => quote! { crate::expr::Expr::Const(#c) },
-            ParsedExpr::Var(name) => quote! { crate::expr::Expr::Var(#name) },
-            ParsedExpr::Add(a, b) => {
-                let a = a.to_expr_tokens();
-                let b = b.to_expr_tokens();
-                quote! { (#a) + (#b) }
-            }
-            ParsedExpr::Sub(a, b) => {
-                let a = a.to_expr_tokens();
-                let b = b.to_expr_tokens();
-                quote! { (#a) - (#b) }
-            }
-            ParsedExpr::Mul(a, b) => {
-                let a = a.to_expr_tokens();
-                let b = b.to_expr_tokens();
-                quote! { (#a) * (#b) }
-            }
-            ParsedExpr::Div(a, b) => {
-                let a = a.to_expr_tokens();
-                let b = b.to_expr_tokens();
-                quote! { (#a) / (#b) }
-            }
-            ParsedExpr::Pow(base, exp) => {
-                let base = base.to_expr_tokens();
-                let exp = exp.to_expr_tokens();
-                quote! { crate::expr::Expr::pow(#base, #exp) }
-            }
-            ParsedExpr::Neg(a) => {
-                let a = a.to_expr_tokens();
-                quote! { -(#a) }
-            }
-            ParsedExpr::Exp(a) => {
-                let a = a.to_expr_tokens();
-                quote! { crate::expr::Expr::Exp(Box::new(#a)) }
-            }
-            ParsedExpr::Log(a) => {
-                let a = a.to_expr_tokens();
-                quote! { crate::expr::Expr::Log(Box::new(#a)) }
-            }
-            ParsedExpr::Sqrt(a) => {
-                let a = a.to_expr_tokens();
-                quote! { crate::expr::Expr::Sqrt(Box::new(#a)) }
-            }
-            ParsedExpr::Factorial(a) => {
-                let a = a.to_expr_tokens();
-                quote! { crate::expr::Expr::Factorial(Box::new(#a)) }
-            }
-        }
-    }
-
-    /// Generate TokenStream that evaluates the expression by calling getter methods
-    /// on a source variable `src`.
-    pub fn to_eval_tokens(&self, src_ident: &syn::Ident) -> TokenStream {
-        match self {
-            ParsedExpr::Const(c) => quote! { (#c as f64) },
-            ParsedExpr::Var(name) => {
-                let getter = syn::Ident::new(name, proc_macro2::Span::call_site());
-                quote! { (#src_ident.#getter() as f64) }
-            }
-            ParsedExpr::Add(a, b) => {
-                let a = a.to_eval_tokens(src_ident);
-                let b = b.to_eval_tokens(src_ident);
-                quote! { (#a + #b) }
-            }
-            ParsedExpr::Sub(a, b) => {
-                let a = a.to_eval_tokens(src_ident);
-                let b = b.to_eval_tokens(src_ident);
-                quote! { (#a - #b) }
-            }
-            ParsedExpr::Mul(a, b) => {
-                let a = a.to_eval_tokens(src_ident);
-                let b = b.to_eval_tokens(src_ident);
-                quote! { (#a * #b) }
-            }
-            ParsedExpr::Div(a, b) => {
-                let a = a.to_eval_tokens(src_ident);
-                let b = b.to_eval_tokens(src_ident);
-                quote! { (#a / #b) }
-            }
-            ParsedExpr::Pow(base, exp) => {
-                let base = base.to_eval_tokens(src_ident);
-                let exp = exp.to_eval_tokens(src_ident);
-                quote! { f64::powf(#base, #exp) }
-            }
-            ParsedExpr::Neg(a) => {
-                let a = a.to_eval_tokens(src_ident);
-                quote! { (-(#a)) }
-            }
-            ParsedExpr::Exp(a) => {
-                let a = a.to_eval_tokens(src_ident);
-                quote! { f64::exp(#a) }
-            }
-            ParsedExpr::Log(a) => {
-                let a = a.to_eval_tokens(src_ident);
-                quote! { f64::ln(#a) }
-            }
-            ParsedExpr::Sqrt(a) => {
-                let a = a.to_eval_tokens(src_ident);
-                quote! { f64::sqrt(#a) }
-            }
-            ParsedExpr::Factorial(a) => {
-                let a = a.to_eval_tokens(src_ident);
-                quote! { {
-                    let __n = #a;
-                    let __r = __n.round();
-                    if (__n - __r).abs() < 1e-10 && __r >= 0.0 {
-                        let mut __f = 1u64;
-                        let __k = __r as u64;
-                        let mut __i = 2u64;
-                        while __i <= __k { __f = __f.saturating_mul(__i); __i += 1; }
-                        __f as f64
-                    } else {
-                        (2.0 * ::std::f64::consts::PI * __n).sqrt() * (__n / ::std::f64::consts::E).powf(__n)
-                    }
-                } }
-            }
-        }
-    }
-
-    /// Collect all variable names in the expression.
-    pub fn variables(&self) -> Vec<String> {
-        let mut vars = Vec::new();
-        self.collect_vars(&mut vars);
-        vars.sort();
-        vars.dedup();
-        vars
-    }
-
-    fn collect_vars(&self, vars: &mut Vec<String>) {
-        match self {
-            ParsedExpr::Const(_) => {}
-            ParsedExpr::Var(name) => vars.push(name.clone()),
-            ParsedExpr::Add(a, b)
-            | ParsedExpr::Sub(a, b)
-            | ParsedExpr::Mul(a, b)
-            | ParsedExpr::Div(a, b)
-            | ParsedExpr::Pow(a, b) => {
-                a.collect_vars(vars);
-                b.collect_vars(vars);
-            }
-            ParsedExpr::Neg(a)
-            | ParsedExpr::Exp(a)
-            | ParsedExpr::Log(a)
-            | ParsedExpr::Sqrt(a)
-            | ParsedExpr::Factorial(a) => {
-                a.collect_vars(vars);
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_var() {
-        assert_eq!(
-            parse_expr("num_vertices").unwrap(),
-            ParsedExpr::Var("num_vertices".into())
-        );
-    }
-
-    #[test]
-    fn test_parse_const() {
-        assert_eq!(parse_expr("42").unwrap(), ParsedExpr::Const(42.0));
-    }
-
-    #[test]
-    fn test_parse_pow() {
-        let e = parse_expr("n^2").unwrap();
-        assert_eq!(
-            e,
-            ParsedExpr::Pow(
-                Box::new(ParsedExpr::Var("n".into())),
-                Box::new(ParsedExpr::Const(2.0)),
-            )
-        );
-    }
-
-    #[test]
-    fn test_parse_add_mul() {
-        // n + 3 * m  →  n + (3*m)
-        let e = parse_expr("n + 3 * m").unwrap();
-        assert_eq!(
-            e,
-            ParsedExpr::Add(
-                Box::new(ParsedExpr::Var("n".into())),
-                Box::new(ParsedExpr::Mul(
-                    Box::new(ParsedExpr::Const(3.0)),
-                    Box::new(ParsedExpr::Var("m".into())),
-                )),
-            )
-        );
-    }
-
-    #[test]
-    fn test_parse_exp() {
-        let e = parse_expr("exp(n^2)").unwrap();
-        assert_eq!(
-            e,
-            ParsedExpr::Exp(Box::new(ParsedExpr::Pow(
-                Box::new(ParsedExpr::Var("n".into())),
-                Box::new(ParsedExpr::Const(2.0)),
-            )))
-        );
-    }
-
-    #[test]
-    fn test_parse_complex() {
-        // 3 * n^2 + exp(m) — should parse correctly
-        let e = parse_expr("3 * n^2 + exp(m)").unwrap();
-        assert!(matches!(e, ParsedExpr::Add(_, _)));
-    }
-
-    #[test]
-    fn test_parse_parens() {
-        let e = parse_expr("(n + m)^2").unwrap();
-        assert!(matches!(e, ParsedExpr::Pow(_, _)));
-    }
-
-    #[test]
-    fn test_variables() {
-        let e = parse_expr("n^2 + 3 * m + exp(k)").unwrap();
-        assert_eq!(e.variables(), vec!["k", "m", "n"]);
-    }
-
-    #[test]
-    fn test_parse_neg() {
-        let e = parse_expr("-n").unwrap();
-        assert_eq!(e, ParsedExpr::Neg(Box::new(ParsedExpr::Var("n".into()))));
-    }
-
-    #[test]
-    fn test_parse_sub() {
-        let e = parse_expr("n - m").unwrap();
-        assert_eq!(
-            e,
-            ParsedExpr::Sub(
-                Box::new(ParsedExpr::Var("n".into())),
-                Box::new(ParsedExpr::Var("m".into())),
-            )
-        );
-    }
-}
diff --git a/scripts/build_website.py b/scripts/build_website.py
index 536065f50..33a36f40c 100644
--- a/scripts/build_website.py
+++ b/scripts/build_website.py
@@ -2,6 +2,8 @@
 """Overlay the product website on mdBook, using its generated registry exports."""
 
 import argparse
+import ast
+from html import escape
 import json
 from pathlib import Path
 import re
@@ -12,6 +14,41 @@
 ROOT = Path(__file__).resolve().parents[1]
 
 
+def expression_mathml(expression):
+    """Typeset registry arithmetic with the browser's native MathML renderer."""
+    def render(node, parent_precedence=0):
+        match node:
+            case ast.Constant(value=value) if type(value) in (int, float):
+                return f"<mn>{value}</mn>"
+            case ast.Name(id=name):
+                return f'<mi mathvariant="normal">{escape(name)}</mi>'
+            case ast.BinOp(left=left, op=ast.Div(), right=right):
+                return f"<mfrac>{render(left)}{render(right)}</mfrac>"
+            case ast.BinOp(left=left, op=ast.Pow(), right=right):
+                return f"<msup>{render(left, 41)}{render(right)}</msup>"
+            case ast.BinOp(left=left, op=op, right=right):
+                symbol, precedence = {ast.Add: ("+", 10), ast.Sub: ("−", 10),
+                                      ast.Mult: ("·", 20)}[type(op)]
+                body = f"{render(left, precedence)}<mo>{symbol}</mo>{render(right, precedence + 1)}"
+            case ast.UnaryOp(op=ast.USub(), operand=operand):
+                precedence = 30
+                body = f"<mo>−</mo>{render(operand, precedence)}"
+            case ast.Call(func=ast.Name(id="sqrt"), args=[argument], keywords=[]):
+                return f"<msqrt>{render(argument)}</msqrt>"
+            case ast.Call(func=ast.Name(id="factorial"), args=[argument], keywords=[]):
+                return f"<mrow>{render(argument, 41)}<mo>!</mo></mrow>"
+            case ast.Call(func=ast.Name(id=name), args=[argument], keywords=[]) if name in ("exp", "log"):
+                return f'<mrow><mi mathvariant="normal">{name}</mi><mo>⁡</mo><mo>(</mo>{render(argument)}<mo>)</mo></mrow>'
+            case _:
+                raise ValueError(f"Unsupported registry expression: {expression}")
+        if precedence < parent_precedence:
+            body = f"<mo>(</mo>{body}<mo>)</mo>"
+        return f"<mrow>{body}</mrow>"
+
+    body = render(ast.parse(expression.replace("^", "**"), mode="eval").body)
+    return f'<math xmlns="http://www.w3.org/1998/Math/MathML" aria-label="{escape(expression, quote=True)}">{body}</math>'
+
+
 def build_markdown(output):
     """Publish the same short guides with mdBook includes expanded for agents."""
     source = ROOT / "docs/src"
@@ -141,6 +178,9 @@ def build(output, graph_path, schemas_path):
         )
         site_edges.append({
             **edge,
+            "parameters": [{**parameter, "mathml": expression_mathml(parameter["formula"])
+                            if parameter["formula"] is not None else None}
+                           for parameter in edge["parameters"]],
             "source_path": source_path,
             "api_path": contract,
             "test_path": test_path if (ROOT / test_path).is_file() else None,
@@ -148,6 +188,7 @@ def build(output, graph_path, schemas_path):
     # Decision<Inner> is one generic Rust type, not a struct for every catalog name.
     site_nodes = [{
         **node,
+        "complexity_mathml": expression_mathml(node["complexity"]),
         "api_path": (
             "models/decision/struct.Decision.html"
             if node["name"].startswith("Decision") else node["doc_path"]
diff --git a/scripts/generate_doc_snippets.sh b/scripts/generate_doc_snippets.sh
index 38767f697..bd65dca0d 100755
--- a/scripts/generate_doc_snippets.sh
+++ b/scripts/generate_doc_snippets.sh
@@ -37,12 +37,17 @@ echo "Generating doc snippets with $PRED ..."
 
 # 9. pred create + reduce + solve bundle
 "$PRED" create MIS --graph 0-1,1-2,2-3 -o /tmp/pred_doc_problem.json 2>/dev/null
-"$PRED" reduce /tmp/pred_doc_problem.json --to QUBO -o /tmp/pred_doc_reduced.json 2>/dev/null
+"$PRED" path MIS QUBO --json 2>/dev/null | python3 -c '
+import json, sys
+paths = json.load(sys.stdin)["paths"]
+json.dump(paths[0], sys.stdout)
+' > /tmp/pred_doc_route.json
+"$PRED" reduce /tmp/pred_doc_problem.json --via /tmp/pred_doc_route.json -o /tmp/pred_doc_reduced.json 2>/dev/null
 "$PRED" solve /tmp/pred_doc_reduced.json --solver brute-force 2>/dev/null > "$OUT/pred-solve-bundle.txt"
-rm -f /tmp/pred_doc_problem.json /tmp/pred_doc_reduced.json
+rm -f /tmp/pred_doc_problem.json /tmp/pred_doc_route.json /tmp/pred_doc_reduced.json
 
 # 10. pred evaluate
-"$PRED" create MIS --graph 0-1,1-2,2-3 2>/dev/null | "$PRED" evaluate - --config 1,0,1,0 2>/dev/null > "$OUT/pred-evaluate.txt"
+"$PRED" create MIS --graph 0-1,1-2,2-3 2>/dev/null | "$PRED" evaluate - --config '[true,false,true,false]' 2>/dev/null > "$OUT/pred-evaluate.txt"
 
 # 11. pred show typo suggestion (goes to stderr)
 "$PRED" show MaximumIndependentSe 2> "$OUT/pred-show-typo.txt" || true
@@ -78,6 +83,5 @@ print(f\"**{data['num_types']}** problem families · **{data['num_variant_nodes'
 FACTORING_OUTPUT=$(cargo run --example chained_reduction_factoring_to_spinglass 2>/dev/null)
 echo "$FACTORING_OUTPUT" | head -1 > "$OUT/factoring-path.txt"
 echo "$FACTORING_OUTPUT" | sed -n '2p' > "$OUT/factoring-result.txt"
-echo "$FACTORING_OUTPUT" | sed -n '3,$p' > "$OUT/factoring-overhead.txt"
 
 echo "Done. Generated $(ls "$OUT" | wc -l | tr -d ' ') snippets in $OUT/"
diff --git a/scripts/generate_symbolic_expr_fixture.py b/scripts/generate_symbolic_expr_fixture.py
new file mode 100644
index 000000000..082136b82
--- /dev/null
+++ b/scripts/generate_symbolic_expr_fixture.py
@@ -0,0 +1,298 @@
+"""Generate the symbolic-expression conformance fixture with SymPy.
+
+The committed fixture lets Rust tests use SymPy as an independent semantic
+oracle without adding Python to the Rust build or test environment.
+
+Usage:
+    uv run --project scripts python scripts/generate_symbolic_expr_fixture.py
+"""
+
+import json
+import math
+from pathlib import Path
+
+import sympy
+from sympy.parsing.sympy_parser import (
+    convert_xor,
+    parse_expr,
+    rationalize,
+    standard_transformations,
+)
+
+
+OUTPUT = (
+    Path(__file__).resolve().parents[1]
+    / "problemreductions-expr"
+    / "tests"
+    / "fixtures"
+    / "sympy_oracle.json"
+)
+TRANSFORMATIONS = standard_transformations + (convert_xor, rationalize)
+
+
+# The final boolean selects cases where SymPy's mathematical polynomial
+# predicate and this crate's deliberately syntactic predicate have the same
+# contract. Every case still participates in variable and exact-value checks.
+CASES = [
+    ("zero", "0", {}, True),
+    ("integer", "42", {}, True),
+    ("exact_decimal", "2.372", {}, True),
+    ("leading_decimal_point", ".125", {}, True),
+    (
+        "arbitrary_precision_integer",
+        "100000000000000000000000000000000000000000000000001",
+        {},
+        True,
+    ),
+    ("variable", "n", {"n": 7}, True),
+    ("negation", "-n", {"n": 7}, True),
+    ("addition", "n + m", {"n": 3, "m": 4}, True),
+    ("subtraction", "n - m", {"n": 3, "m": 7}, True),
+    ("multiplication", "n * m", {"n": 6, "m": 7}, True),
+    ("rational_coefficient", "n / 2", {"n": 3}, True),
+    ("variable_divisor", "n / m", {"n": 12, "m": 5}, True),
+    ("nested_divisor", "n / (m + 1)", {"n": 10, "m": 4}, True),
+    ("exact_size_formula", "n * (n - 1) / 2 - m", {"n": 5, "m": 4}, True),
+    ("zero_power", "n^0", {"n": 9}, True),
+    ("integer_power", "n^3", {"n": 4}, True),
+    ("negative_power", "2^-3", {}, False),
+    ("symbolic_exponent", "2^n", {"n": 10}, True),
+    ("unary_precedence", "-n^2", {"n": 3}, True),
+    ("parenthesized_negative_base", "(-n)^2", {"n": 3}, True),
+    ("fractional_power", "n^0.5", {"n": 81}, True),
+    ("square_root", "sqrt(n)", {"n": 81}, True),
+    ("pythagorean_root", "sqrt(n^2 + m^2)", {"n": 3, "m": 4}, True),
+    ("exponential_identity", "exp(n)", {"n": 0}, True),
+    ("logarithm_identity", "log(n)", {"n": 1}, True),
+    ("factorial", "factorial(n)", {"n": 6}, True),
+    ("factorial_subexpression", "factorial(n - 1)", {"n": 6}, True),
+    ("decimal_scaling", "2.372 * n", {"n": 1000}, True),
+    ("difference_of_squares", "(n + m) * (n - m)", {"n": 10, "m": 3}, True),
+    (
+        "multivariate_polynomial",
+        "n^2 + 2 * n * m + m^2",
+        {"n": 3, "m": 4},
+        True,
+    ),
+    ("nested_rational", "n / (2 * m)", {"n": 12, "m": 3}, True),
+    (
+        "long_decimal",
+        "1.0000000000000000000000000000000000000001",
+        {},
+        True,
+    ),
+    ("nested_subtraction", "n - (m - k)", {"n": 10, "m": 7, "k": 2}, True),
+    ("left_subtraction", "(n - m) - k", {"n": 10, "m": 7, "k": 2}, True),
+    ("nested_division", "n / (m / k)", {"n": 12, "m": 6, "k": 3}, True),
+    ("left_division", "(n / m) / k", {"n": 12, "m": 6, "k": 2}, True),
+    ("right_associative_power", "n^(m^k)", {"n": 2, "m": 3, "k": 2}, True),
+    ("parenthesized_power", "(n^m)^k", {"n": 2, "m": 3, "k": 2}, True),
+    ("double_negation", "--n", {"n": 7}, True),
+    ("zero_factorial", "factorial(0)", {}, False),
+    ("zero_square_root", "sqrt(0)", {}, False),
+    (
+        "constant_functions",
+        "exp(0) + log(1) + factorial(5)",
+        {},
+        False,
+    ),
+    ("zero_product", "n * 0 + 7", {"n": 999}, True),
+    ("self_division", "n / n", {"n": 5}, True),
+    ("identity_power", "n^1", {"n": 13}, True),
+    ("decimal_integer_power", "n^2.0", {"n": 9}, True),
+    ("decimal_sum", "0.1 + 0.2", {}, True),
+    (
+        "large_mixed_decimal",
+        "99999999999999999999.00000000000000000001",
+        {},
+        True,
+    ),
+    ("identifier_shapes", "n_1 + size2", {"n_1": 8, "size2": 9}, True),
+    ("mixed_precedence", "n + m * k^2", {"n": 1, "m": 2, "k": 3}, True),
+]
+
+
+# These cases exercise the production f64 boundary. Expected values are emitted
+# at 80 decimal digits so the Rust test, rather than Python's float conversion,
+# performs the final rounding to f64.
+APPROXIMATE_CASES = [
+    ("exp_one", "exp(1)", {}),
+    ("exp_fraction", "exp(n / 3)", {"n": 5}),
+    ("log_two", "log(2)", {}),
+    ("log_large", "log(1000000)", {}),
+    ("sqrt_two", "sqrt(2)", {}),
+    ("sqrt_large", "sqrt(1234567)", {}),
+    ("fractional_power", "7^2.372", {}),
+    ("mixed_transcendental", "exp(log(n)) + sqrt(m)", {"n": 13, "m": 2}),
+    ("complexity_formula", "2^(2.372 * n / 3)", {"n": 19}),
+    ("factorial_ten", "factorial(10)", {}),
+    ("factorial_f64_boundary", "factorial(170)", {}),
+    ("factorial_f64_overflow", "factorial(171)", {}),
+]
+
+
+# Univariate, eventually positive cases where asymptotic order is decided by
+# the exact limit of left / right as n tends to positive infinity.
+GROWTH_CASES = [
+    ("constant_factor", "3 * n^2", "n^2"),
+    ("lower_order_sum", "n^2 + n", "n^2"),
+    ("shifted_power", "(n + 1)^2", "n^2"),
+    ("log_constant_power", "log(n^3)", "log(n)"),
+    ("higher_polynomial_degree", "n^3", "n^2"),
+    ("polynomial_over_log", "n", "log(n)^5"),
+    ("polylog_tie_break", "n^3 * log(n)", "n^3"),
+    ("small_base_exponential", "1.001^n", "n^100"),
+    ("exponential_base", "3^n", "2^n"),
+    ("exponential_rate", "2^(2 * n)", "2^n"),
+    ("natural_exponential", "exp(n)", "n^100"),
+    ("exponential_poly_tie_break", "2^n * n", "2^n"),
+    ("reverse_polynomial_degree", "n", "n^2"),
+    ("reverse_exponential", "n^100", "exp(n)"),
+]
+
+
+FACTORIAL_ARGUMENTS = ["0", "1", "10", "170", "171", "-1", "3.5", "1 / 2"]
+
+
+def parse(source: str) -> sympy.Expr:
+    return parse_expr(source, transformations=TRANSFORMATIONS, evaluate=False)
+
+
+def exact_fraction(value: sympy.Expr) -> str:
+    value = value.doit()
+    if value.is_Rational is not True:
+        raise ValueError(f"fixture result is not exact rational: {value!r}")
+    numerator, denominator = value.as_numer_denom()
+    return f"{numerator}/{denominator}"
+
+
+def generate_case(
+    name: str,
+    source: str,
+    bindings: dict[str, int],
+    compare_polynomial: bool,
+) -> dict:
+    expression = parse(source)
+    source_symbols = sorted(str(symbol) for symbol in expression.free_symbols)
+    if set(source_symbols) != set(bindings):
+        raise ValueError(f"{name} bindings do not match free symbols")
+    canonical = sympy.simplify(expression)
+    symbols = sorted(str(symbol) for symbol in canonical.free_symbols)
+    substitutions = {sympy.Symbol(name): value for name, value in bindings.items()}
+    result = expression.subs(substitutions)
+    polynomial = canonical.is_polynomial(
+        *(sympy.Symbol(name) for name in symbols)
+    )
+    return {
+        "name": name,
+        "source": source,
+        "variables": symbols,
+        "bindings": bindings,
+        "exact_result": exact_fraction(result),
+        "compare_polynomial": compare_polynomial,
+        "is_polynomial": polynomial is True,
+    }
+
+
+def generate_approximate_case(
+    name: str,
+    source: str,
+    bindings: dict[str, int],
+) -> dict:
+    expression = parse(source)
+    symbols = sorted(str(symbol) for symbol in expression.free_symbols)
+    if set(symbols) != set(bindings):
+        raise ValueError(f"{name} bindings do not match free symbols")
+    substitutions = {sympy.Symbol(name): value for name, value in bindings.items()}
+    result = expression.subs(substitutions).doit()
+    if result.is_real is not True or result.is_finite is not True:
+        raise ValueError(f"{name} result is not a finite real number: {result!r}")
+    return {
+        "name": name,
+        "source": source,
+        "bindings": bindings,
+        "decimal_result": str(sympy.N(result, 80)),
+        "finite_f64": math.isfinite(float(result)),
+    }
+
+
+def generate_growth_case(name: str, left: str, right: str) -> dict:
+    variable = sympy.Symbol("n", positive=True)
+    local_dict = {"n": variable}
+    left_expression = parse_expr(
+        left,
+        local_dict=local_dict,
+        transformations=TRANSFORMATIONS,
+        evaluate=False,
+    )
+    right_expression = parse_expr(
+        right,
+        local_dict=local_dict,
+        transformations=TRANSFORMATIONS,
+        evaluate=False,
+    )
+    ratio_limit = sympy.limit(left_expression / right_expression, variable, sympy.oo)
+    if ratio_limit == 0:
+        relation = "right_dominates"
+    elif ratio_limit == sympy.oo:
+        relation = "left_dominates"
+    elif ratio_limit.is_positive is True and ratio_limit.is_finite is True:
+        relation = "equivalent"
+    else:
+        raise ValueError(f"{name} has unsupported ratio limit {ratio_limit!r}")
+    return {
+        "name": name,
+        "left": left,
+        "right": right,
+        "ratio_limit": str(ratio_limit),
+        "relation": relation,
+    }
+
+
+def generate_factorial_domain_case(source: str) -> dict:
+    argument = parse(source).doit()
+    accepted = argument.is_integer is True and argument.is_nonnegative is True
+    return {
+        "source": source,
+        "exact_argument": str(argument),
+        "accepted": accepted,
+        "finite_f64": bool(accepted and argument <= 170),
+    }
+
+
+def main() -> None:
+    if sympy.__version__ != "1.14.0":
+        raise RuntimeError(f"expected SymPy 1.14.0, found {sympy.__version__}")
+    fixture = {
+        "oracle": {
+            "engine": "SymPy",
+            "version": sympy.__version__,
+            "parse_evaluate": False,
+            "polynomial_mode": "simplify before classification",
+            "decimal_mode": "rationalize base-10 spelling",
+            "documentation": {
+                "parser": "https://docs.sympy.org/latest/modules/parsing.html",
+                "expression_core": "https://docs.sympy.org/latest/modules/core.html",
+            },
+        },
+        "cases": [generate_case(*case) for case in CASES],
+        "approximate_cases": [
+            generate_approximate_case(*case) for case in APPROXIMATE_CASES
+        ],
+        "growth_cases": [generate_growth_case(*case) for case in GROWTH_CASES],
+        "factorial_domain_cases": [
+            generate_factorial_domain_case(source) for source in FACTORIAL_ARGUMENTS
+        ],
+    }
+    OUTPUT.parent.mkdir(parents=True, exist_ok=True)
+    OUTPUT.write_text(json.dumps(fixture, indent=2) + "\n", encoding="utf-8")
+    print(
+        f"wrote {len(fixture['cases'])} exact and "
+        f"{len(fixture['approximate_cases'])} approximate and "
+        f"{len(fixture['growth_cases'])} growth cases plus "
+        f"{len(fixture['factorial_domain_cases'])} factorial domain cases to {OUTPUT}"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/pipeline_checks.py b/scripts/pipeline_checks.py
index 9f85addb5..f65e8e76d 100644
--- a/scripts/pipeline_checks.py
+++ b/scripts/pipeline_checks.py
@@ -292,10 +292,14 @@ def rule_completeness(
             if test_file.exists()
             else check_entry(status="fail", detail="missing rule unit tests")
         ),
-        "overhead_form": (
+        "parameter_transform_form": (
             check_entry(status="pass", path=str(rule_file.relative_to(repo_root)))
-            if rule_file.exists() and "#[reduction(overhead = {" in rule_text
-            else check_entry(status="fail", detail="missing #[reduction(overhead = {...})] form")
+            if rule_file.exists()
+            and any(key in rule_text for key in ("transform = exact", "transform = upper_bound", "transform = unavailable"))
+            else check_entry(
+                status="fail",
+                detail="missing explicit exact, upper-bound, or unavailable parameter transform",
+            )
         ),
         "canonical_example": (
             check_entry(status="pass", path=str(rule_file.relative_to(repo_root)))
diff --git a/scripts/pyproject.toml b/scripts/pyproject.toml
index a61d0e94f..d35725258 100644
--- a/scripts/pyproject.toml
+++ b/scripts/pyproject.toml
@@ -6,4 +6,5 @@ requires-python = ">=3.12"
 dependencies = [
     "numpy>=1.26,<2",
     "qubogen>=0.1.1",
+    "sympy==1.14.0",
 ]
diff --git a/scripts/record_cli_demo.py b/scripts/record_cli_demo.py
index e4399f0d3..ccbc06697 100755
--- a/scripts/record_cli_demo.py
+++ b/scripts/record_cli_demo.py
@@ -28,11 +28,12 @@
 
 # (comment, command) pairs, run in order.
 STEPS = [
-    ("Discover a route to an available solver", "./pred path MIS ILP"),
+    ("Discover a route to an available solver", "./pred path MIS ILP --json -o paths.json"),
+    ("Select the first returned route", "python3 -c 'import json; json.dump(json.load(open(\"paths.json\"))[\"paths\"][0], open(\"path.json\", \"w\"))'"),
     ("Create a five-vertex cycle", "./pred create MIS --graph 0-1,1-2,2-3,3-4,4-0 -o cycle.json"),
-    ("Transform the instance and preserve the way back", "./pred reduce cycle.json --to ILP -o reduced.json"),
+    ("Transform the instance and preserve the way back", "./pred reduce cycle.json --via path.json -o reduced.json"),
     ("Solve the target and recover a source solution", "./pred solve reduced.json"),
-    ("Check an independent set of size two", "./pred evaluate cycle.json --config 1,0,1,0,0"),
+    ("Check an independent set of size two", "./pred evaluate cycle.json --config '[true,false,true,false,false]'"),
     ("Solve the original instance with the default solver", "./pred solve cycle.json"),
 ]
 
diff --git a/scripts/test_documentation.py b/scripts/test_documentation.py
index 61d05e125..021664744 100644
--- a/scripts/test_documentation.py
+++ b/scripts/test_documentation.py
@@ -46,12 +46,12 @@ def test_recording_contains_real_solution_and_does_not_autoplay(self):
         events = [json.loads(line) for line in (ROOT / "docs/src/static/cli-demo.cast").read_text().splitlines()]
         self.assertEqual(events[0]["version"], 2)
         output = "".join(event[2] for event in events[1:])
-        self.assertEqual(output.count("Solver: ilp (via ILP)"), 2)
+        self.assertEqual(output.count("Solver: ilp"), 2)
         self.assertNotIn("brute-force", output)
         self.assertNotIn("panicked", output)
         self.assertGreaterEqual(output.count("Max(2)"), 3)
         # Command blocks are separated by a blank line.
-        self.assertEqual(output.count("\r\n\r\n\x1b[90m#"), 5)
+        self.assertEqual(output.count("\r\n\r\n\x1b[90m#"), 6)
         self.assertIn('"autoPlay": false', (ROOT / "docs/src/static/cli-demo.html").read_text())
 
     def test_demo_replays_and_matches_the_recorded_optimum(self):
@@ -64,15 +64,16 @@ def run(*args):
                                         text=True, timeout=4)
                 self.assertEqual(result.returncode, 0, result.stderr)
                 return result.stdout
-            run("path", "MIS", "ILP")
+            paths = json.loads(run("path", "MIS", "ILP", "--json"))["paths"]
+            (Path(work) / "path.json").write_text(json.dumps(paths[0]))
             run("create", "MIS", "--graph", "0-1,1-2,2-3,3-4,4-0", "-o", "cycle.json")
-            run("reduce", "cycle.json", "--to", "ILP", "-o", "reduced.json")
+            run("reduce", "cycle.json", "--via", "path.json", "-o", "reduced.json")
             reduced = json.loads(run("solve", "reduced.json", "--json"))
             direct = json.loads(run("solve", "cycle.json", "--json"))
             self.assertEqual(reduced["evaluation"], "Max(2)")
             self.assertEqual(direct["evaluation"], reduced["evaluation"])
             self.assertIn("Max(2)", run("evaluate", "cycle.json", "--config",
-                                       ",".join(map(str, reduced["solution"]))))
+                                       json.dumps(reduced["solution"])))
 
 
 class DocumentationBrowser(unittest.TestCase):
diff --git a/scripts/test_pipeline_checks.py b/scripts/test_pipeline_checks.py
index 84b14b3f0..41256bbc3 100644
--- a/scripts/test_pipeline_checks.py
+++ b/scripts/test_pipeline_checks.py
@@ -54,6 +54,7 @@ def test_fetch_existing_prs_falls_back_to_rest_search_on_pr_list_failure(
                     "number": 223,
                     "headRefName": "issue-212-multiprocessor-scheduling",
                     "url": "https://example.test/pull/223",
+                    "body": "",
                 }
             ],
         )
@@ -233,7 +234,7 @@ def test_rule_completeness_reports_all_required_components(self) -> None:
             self._write(
                 repo / "src/rules/binpacking_ilp.rs",
                 """
-                #[reduction(overhead = { num_vars = "num_items" })]
+                #[reduction(transform = exact { num_vars = "num_items" })]
                 impl ReduceTo<ILP> for BinPacking {}
                 pub(crate) fn canonical_rule_example_specs() -> Vec<RuleExampleSpec> { vec![] }
                 """,
@@ -261,7 +262,7 @@ def test_rule_completeness_reports_all_required_components(self) -> None:
             self.assertEqual(report["checks"]["module_registration"]["status"], "pass")
             self.assertEqual(report["checks"]["paper_rule"]["status"], "pass")
 
-    def test_rule_completeness_flags_missing_overhead_and_paper(self) -> None:
+    def test_rule_completeness_flags_missing_parameter_transform_and_paper(self) -> None:
         with tempfile.TemporaryDirectory() as tmpdir:
             repo = Path(tmpdir)
             self._write(
@@ -288,7 +289,7 @@ def test_rule_completeness_flags_missing_overhead_and_paper(self) -> None:
             )
 
             self.assertFalse(report["ok"])
-            self.assertIn("overhead_form", report["missing"])
+            self.assertIn("parameter_transform_form", report["missing"])
             self.assertIn("paper_rule", report["missing"])
             self.assertIn("module_registration", report["missing"])
 
diff --git a/scripts/test_website.py b/scripts/test_website.py
index 40fbcc958..801a885fb 100644
--- a/scripts/test_website.py
+++ b/scripts/test_website.py
@@ -71,15 +71,17 @@ def test_variant_changes_connections_and_survives_reload(self):
         self.visit("problem/MaximumIndependentSet")
         expect(self.page.locator("#variant-select")).to_have_value("graph=SimpleGraph,weight=One")
         expect(self.page.locator('.relation-link[href*="MinimumVertexCover"]')).to_have_count(0)
-        self.page.locator("#variant-select").select_option("graph=SimpleGraph,weight=i32")
+        self.page.locator("#variant-select").select_option("graph=SimpleGraph,weight=i64")
         expect(self.page.locator('.relation-link[href*="MinimumVertexCover"]')).to_have_count(2)
         self.page.reload()
-        expect(self.page.locator("#variant-select")).to_have_value("graph=SimpleGraph,weight=i32")
+        expect(self.page.locator("#variant-select")).to_have_value("graph=SimpleGraph,weight=i64")
 
     def test_reduction_evidence_and_complement_example(self):
         self.visit()
         self.page.locator("#featured-result-link").click()
         expect(self.page.locator("h1")).to_contain_text("Minimum Vertex Cover")
+        expect(self.page.locator(".schema-table tbody tr")).to_have_count(2)
+        expect(self.page.locator(".schema-table tbody")).to_contain_text("exact")
         expect(self.page.locator("#demo-value")).to_have_text("Maximum size: 2")
         self.page.get_by_role("button", name="Vertex cover", exact=True).click()
         expect(self.page.locator("#demo-value")).to_have_text("Minimum size: 3")
@@ -90,7 +92,7 @@ def test_reduction_evidence_and_complement_example(self):
         expect(self.page.locator("details")).to_have_attribute("open", "")
         source = self.page.get_by_role("link", name="Inspect source problem")
         source.click()
-        expect(self.page.locator("#variant-select")).to_have_value("graph=SimpleGraph,weight=i32")
+        expect(self.page.locator("#variant-select")).to_have_value("graph=SimpleGraph,weight=i64")
 
     def test_clipboard(self):
         self.visit()
diff --git a/scripts/test_website_math.py b/scripts/test_website_math.py
new file mode 100644
index 000000000..757573da7
--- /dev/null
+++ b/scripts/test_website_math.py
@@ -0,0 +1,25 @@
+"""Run with python3 scripts/test_website_math.py."""
+
+import unittest
+import xml.etree.ElementTree as ET
+
+from build_website import expression_mathml
+
+
+class WebsiteMathTests(unittest.TestCase):
+    def test_expression_structure_and_accessible_source(self):
+        source = "(num_vertices + 1)^2 / sqrt(num_edges) - factorial(k)"
+        math = ET.fromstring(expression_mathml(source))
+        ns = {"m": "http://www.w3.org/1998/Math/MathML"}
+        self.assertEqual(math.attrib["aria-label"], source)
+        power = math.find(".//m:mfrac/m:msup", ns)
+        self.assertEqual("".join(power[0].itertext()), "(num_vertices+1)")
+        self.assertEqual(power[1].text, "2")
+        self.assertEqual(math.find(".//m:msqrt/m:mi", ns).text, "num_edges")
+        self.assertIn("k!", "".join(math.itertext()))
+        with self.assertRaises(ValueError):
+            expression_mathml("unknown(num_vertices)")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/uv.lock b/scripts/uv.lock
index 58b3004f7..952679aca 100644
--- a/scripts/uv.lock
+++ b/scripts/uv.lock
@@ -1,7 +1,16 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.12"
 
+[[package]]
+name = "mpmath"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
+]
+
 [[package]]
 name = "networkx"
 version = "3.6.1"
@@ -46,10 +55,24 @@ source = { virtual = "." }
 dependencies = [
     { name = "numpy" },
     { name = "qubogen" },
+    { name = "sympy" },
 ]
 
 [package.metadata]
 requires-dist = [
     { name = "numpy", specifier = ">=1.26,<2" },
     { name = "qubogen", specifier = ">=0.1.1" },
+    { name = "sympy", specifier = "==1.14.0" },
+]
+
+[[package]]
+name = "sympy"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mpmath" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
 ]
diff --git a/src/big_o.rs b/src/big_o.rs
index 1b782d862..0cdb0ee1c 100644
--- a/src/big_o.rs
+++ b/src/big_o.rs
@@ -1,387 +1,33 @@
-//! Big-O asymptotic projection for canonical expressions.
+//! Big-O asymptotic normal form.
 //!
-//! Takes the output of `canonical_form()` and projects it into an
-//! asymptotic growth class by dropping dominated terms and constant factors.
+//! Thin wrapper over the [growth domain](crate::growth): compute the growth
+//! class of an expression bottom-up (without fully distributing the source AST) and
+//! render it back to a display [`Expr`]. Content the growth domain cannot bound
+//! symbolically (nonlinear exponents, factorials, negative exponents) maps to
+//! the [`AsymptoticAnalysisError::Unsupported`] error.
 
-use crate::canonical::canonical_form;
-use crate::expr::{AsymptoticAnalysisError, CanonicalizationError, Expr};
-
-#[derive(Clone, Debug)]
-struct ProjectedTerm {
-    expr: Expr,
-    negative: bool,
-}
+use crate::expr::{AsymptoticAnalysisError, Expr};
+use crate::growth::Growth;
 
 /// Compute the Big-O normal form of an expression.
 ///
-/// This is a two-phase pipeline:
-/// 1. `canonical_form()` — exact symbolic simplification
-/// 2. Asymptotic projection — drop dominated terms and constant factors
-///
-/// Returns an expression representing the asymptotic growth class.
+/// Returns an expression representing the asymptotic growth class, or
+/// [`AsymptoticAnalysisError::Unsupported`] when the growth domain cannot
+/// represent the input.
 pub fn big_o_normal_form(expr: &Expr) -> Result<Expr, AsymptoticAnalysisError> {
-    let canonical = canonical_form(expr).map_err(|e| match e {
-        CanonicalizationError::Unsupported(s) => AsymptoticAnalysisError::Unsupported(s),
-    })?;
-
-    project_big_o(&canonical)
-}
-
-/// Project a canonicalized expression into its Big-O growth class.
-fn project_big_o(expr: &Expr) -> Result<Expr, AsymptoticAnalysisError> {
-    // Decompose into additive terms
-    let mut terms = Vec::new();
-    collect_additive_terms(expr, &mut terms);
-
-    // Project each term: drop constant multiplicative factors
-    let mut projected: Vec<ProjectedTerm> = Vec::new();
-    for term in &terms {
-        if let Some(projected_term) = project_term(term)? {
-            projected.push(projected_term);
-        }
-        // Pure constants are dropped (asymptotically irrelevant)
-    }
-
-    // Remove dominated terms
-    let survivors = remove_dominated_terms(projected);
-
-    if survivors.is_empty() {
-        // All terms were constants → O(1)
-        return Ok(Expr::Const(1.0));
-    }
-
-    if let Some(negative) = survivors.iter().find(|term| term.negative) {
-        return Err(AsymptoticAnalysisError::Unsupported(format!(
-            "-1 * {}",
-            negative.expr
-        )));
-    }
-
-    // Deduplicate
-    let mut seen = std::collections::BTreeSet::new();
-    let mut deduped = Vec::new();
-    for term in survivors {
-        let key = term.expr.to_string();
-        if seen.insert(key) {
-            deduped.push(term);
-        }
-    }
-
-    // Rebuild sum
-    let mut result = deduped[0].expr.clone();
-    for term in &deduped[1..] {
-        result = result + term.expr.clone();
-    }
-
-    Ok(result)
-}
-
-fn collect_additive_terms(expr: &Expr, out: &mut Vec<Expr>) {
-    match expr {
-        Expr::Add(a, b) => {
-            collect_additive_terms(a, out);
-            collect_additive_terms(b, out);
-        }
-        other => out.push(other.clone()),
-    }
-}
-
-/// Project a single multiplicative term: strip constant factors.
-/// Returns None if the term is a pure constant.
-fn project_term(term: &Expr) -> Result<Option<ProjectedTerm>, AsymptoticAnalysisError> {
-    if term.constant_value().is_some() {
-        return Ok(None); // Pure constant → dropped
-    }
-
-    // Collect multiplicative factors
-    let mut factors = Vec::new();
-    collect_multiplicative_factors(term, &mut factors);
-
-    let mut coeff = 1.0;
-    let mut symbolic = Vec::new();
-    for factor in &factors {
-        if let Some(c) = factor.constant_value() {
-            coeff *= c;
-            continue;
-        }
-        if contains_negative_exponent(factor) {
-            return Err(AsymptoticAnalysisError::Unsupported(term.to_string()));
-        }
-        symbolic.push(factor.clone());
-    }
-
-    if symbolic.is_empty() {
-        return Ok(None);
-    }
-
-    let mut result = symbolic[0].clone();
-    for f in &symbolic[1..] {
-        result = result * f.clone();
-    }
-
-    Ok(Some(ProjectedTerm {
-        expr: result,
-        negative: coeff < 0.0,
-    }))
-}
-
-fn collect_multiplicative_factors(expr: &Expr, out: &mut Vec<Expr>) {
-    match expr {
-        Expr::Mul(a, b) => {
-            collect_multiplicative_factors(a, out);
-            collect_multiplicative_factors(b, out);
-        }
-        other => out.push(other.clone()),
-    }
-}
-
-/// Remove terms dominated by other terms using monomial comparison.
-///
-/// A term `t` is dominated if there exists another term `s` such that
-/// `t` grows no faster than `s` asymptotically.
-fn remove_dominated_terms(terms: Vec<ProjectedTerm>) -> Vec<ProjectedTerm> {
-    if terms.len() <= 1 {
-        return terms;
-    }
-
-    let mut survivors = Vec::new();
-    for (i, term) in terms.iter().enumerate() {
-        let is_dominated = terms
-            .iter()
-            .enumerate()
-            .any(|(j, other)| i != j && term_dominated_by(&term.expr, &other.expr));
-        if !is_dominated {
-            survivors.push(term.clone());
-        }
-    }
-    survivors
-}
-
-/// Check if `small` is asymptotically dominated by `big`.
-///
-/// Supports three comparison strategies:
-/// 1. Polynomial monomial exponent comparison (exact)
-/// 2. Exponential vs subexponential / base comparison (structural)
-/// 3. Numerical evaluation at two scales (for subexponential cross-class)
-fn term_dominated_by(small: &Expr, big: &Expr) -> bool {
-    // Case 1: Both pure polynomial monomials — use exponent comparison
-    let small_exps = extract_var_exponents(small);
-    let big_exps = extract_var_exponents(big);
-    if let (Some(ref se), Some(ref be)) = (small_exps, big_exps) {
-        return polynomial_dominated(se, be);
+    let growth = Growth::from_expr(expr);
+    match growth.to_expr() {
+        Some(expression) => Ok(expression),
+        None => Err(AsymptoticAnalysisError::Unsupported(
+            growth
+                .failures()
+                .expect("growth without an expression must contain failure reasons")
+                .iter()
+                .map(ToString::to_string)
+                .collect::<Vec<_>>()
+                .join("; "),
+        )),
     }
-
-    // Cross-class comparison: small's variables must be a subset of big's
-    let small_vars = small.variables();
-    let big_vars = big.variables();
-    if small_vars.is_empty() || big_vars.is_empty() || !small_vars.is_subset(&big_vars) {
-        return false;
-    }
-
-    // Case 2: Exponential comparison
-    let small_has_exp = has_exponential_growth(small);
-    let big_has_exp = has_exponential_growth(big);
-    match (small_has_exp, big_has_exp) {
-        (false, true) => return true,  // exponential dominates subexponential
-        (true, false) => return false, // subexponential can't dominate exponential
-        (true, true) => {
-            // Compare effective exponential bases
-            if let (Some(sb), Some(bb)) = (effective_exp_base(small), effective_exp_base(big)) {
-                if bb > sb * (1.0 + 1e-10) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        (false, false) => {} // both subexponential, fall through
-    }
-
-    // Case 3: Both subexponential, same variables — numerical comparison
-    // Handles: poly vs poly*log, log vs log(log), poly vs log, etc.
-    if small_vars == big_vars {
-        return numerical_dominance_check(small, big, &small_vars);
-    }
-
-    false
-}
-
-/// Check polynomial dominance: small ≤ big component-wise with at least one strict inequality.
-fn polynomial_dominated(
-    se: &std::collections::BTreeMap<&'static str, f64>,
-    be: &std::collections::BTreeMap<&'static str, f64>,
-) -> bool {
-    let mut all_leq = true;
-    let mut any_strictly_less = false;
-
-    for (var, small_exp) in se {
-        let big_exp = be.get(var).copied().unwrap_or(0.0);
-        if *small_exp > big_exp + 1e-15 {
-            all_leq = false;
-            break;
-        }
-        if *small_exp < big_exp - 1e-15 {
-            any_strictly_less = true;
-        }
-    }
-
-    if all_leq {
-        for (var, big_exp) in be {
-            if !se.contains_key(var) && *big_exp > 1e-15 {
-                any_strictly_less = true;
-            }
-        }
-    }
-
-    all_leq && any_strictly_less
-}
-
-/// Extract variable → exponent mapping from a monomial expression.
-/// Returns None for non-polynomial terms (exp, log, etc.).
-fn extract_var_exponents(expr: &Expr) -> Option<std::collections::BTreeMap<&'static str, f64>> {
-    use std::collections::BTreeMap;
-    let mut exps = BTreeMap::new();
-    extract_var_exponents_inner(expr, &mut exps)?;
-    Some(exps)
-}
-
-fn extract_var_exponents_inner(
-    expr: &Expr,
-    exps: &mut std::collections::BTreeMap<&'static str, f64>,
-) -> Option<()> {
-    match expr {
-        Expr::Var(name) => {
-            *exps.entry(name).or_insert(0.0) += 1.0;
-            Some(())
-        }
-        Expr::Pow(base, exp) => {
-            if let (Expr::Var(name), Some(e)) = (base.as_ref(), exp.constant_value()) {
-                if e < 0.0 {
-                    return None;
-                }
-                *exps.entry(name).or_insert(0.0) += e;
-                Some(())
-            } else {
-                None // Non-simple power
-            }
-        }
-        Expr::Mul(a, b) => {
-            extract_var_exponents_inner(a, exps)?;
-            extract_var_exponents_inner(b, exps)
-        }
-        Expr::Const(_) => Some(()), // Constants don't affect exponents
-        _ => None,                  // exp, log, sqrt → not a polynomial monomial
-    }
-}
-
-fn contains_negative_exponent(expr: &Expr) -> bool {
-    match expr {
-        Expr::Pow(_, exp) => exp.constant_value().is_some_and(|e| e < 0.0),
-        Expr::Mul(a, b) | Expr::Add(a, b) => {
-            contains_negative_exponent(a) || contains_negative_exponent(b)
-        }
-        Expr::Exp(arg) | Expr::Log(arg) | Expr::Sqrt(arg) | Expr::Factorial(arg) => {
-            contains_negative_exponent(arg)
-        }
-        Expr::Const(_) | Expr::Var(_) => false,
-    }
-}
-
-/// Check if an expression has exponential growth.
-///
-/// Returns true if the expression contains `exp(var_expr)` or `c^(var_expr)` where c > 1.
-fn has_exponential_growth(expr: &Expr) -> bool {
-    match expr {
-        Expr::Exp(arg) => !arg.variables().is_empty(),
-        Expr::Pow(base, exp) => {
-            base.constant_value().is_some_and(|c| c > 1.0) && !exp.variables().is_empty()
-        }
-        Expr::Mul(a, b) => has_exponential_growth(a) || has_exponential_growth(b),
-        _ => false,
-    }
-}
-
-/// Compute the effective exponential base for growth rate comparison.
-///
-/// For `c^(f(n))`, approximates the effective base as `c^(f(1))`.
-/// This works correctly for linear exponents (the common case in complexity expressions).
-fn effective_exp_base(expr: &Expr) -> Option<f64> {
-    match expr {
-        Expr::Exp(arg) => {
-            let vars = arg.variables();
-            if vars.is_empty() {
-                None
-            } else {
-                let size = unit_problem_size(&vars);
-                let rate = arg.eval(&size);
-                Some(std::f64::consts::E.powf(rate))
-            }
-        }
-        Expr::Pow(base, exp) => {
-            if let Some(c) = base.constant_value() {
-                let vars = exp.variables();
-                if c > 1.0 && !vars.is_empty() {
-                    let size = unit_problem_size(&vars);
-                    let exp_at_1 = exp.eval(&size);
-                    Some(c.powf(exp_at_1))
-                } else {
-                    None
-                }
-            } else {
-                None
-            }
-        }
-        Expr::Mul(a, b) => match (effective_exp_base(a), effective_exp_base(b)) {
-            (Some(ba), Some(bb)) => Some(ba * bb),
-            (Some(b), None) | (None, Some(b)) => Some(b),
-            (None, None) => None,
-        },
-        _ => None,
-    }
-}
-
-/// Create a `ProblemSize` with all variables set to the given value.
-fn make_problem_size(
-    vars: &std::collections::HashSet<&'static str>,
-    val: usize,
-) -> crate::types::ProblemSize {
-    crate::types::ProblemSize::new(vars.iter().map(|&v| (v, val)).collect())
-}
-
-/// Create a `ProblemSize` with all variables set to 1.
-fn unit_problem_size(vars: &std::collections::HashSet<&'static str>) -> crate::types::ProblemSize {
-    make_problem_size(vars, 1)
-}
-
-/// Check dominance numerically by evaluating at two scales.
-///
-/// Returns true if `big/small` ratio is > 1 and increasing between the two
-/// evaluation points, indicating `big` grows asymptotically faster.
-fn numerical_dominance_check(
-    small: &Expr,
-    big: &Expr,
-    vars: &std::collections::HashSet<&'static str>,
-) -> bool {
-    let size1 = make_problem_size(vars, 100);
-    let size2 = make_problem_size(vars, 10_000);
-
-    let s1 = small.eval(&size1);
-    let b1 = big.eval(&size1);
-    let s2 = small.eval(&size2);
-    let b2 = big.eval(&size2);
-
-    // Both must be finite and positive at both points
-    if !s1.is_finite() || !b1.is_finite() || !s2.is_finite() || !b2.is_finite() {
-        return false;
-    }
-    if s1 <= 1e-300 || b1 <= 1e-300 || s2 <= 1e-300 || b2 <= 1e-300 {
-        return false;
-    }
-
-    let ratio1 = b1 / s1;
-    let ratio2 = b2 / s2;
-
-    // Dominance: ratio is > 1 at both points and strictly increasing
-    ratio1 > 1.0 + 1e-10 && ratio2 > ratio1 * (1.0 + 1e-6)
 }
 
 #[cfg(test)]
diff --git a/src/canonical.rs b/src/canonical.rs
deleted file mode 100644
index 4f8c73ca7..000000000
--- a/src/canonical.rs
+++ /dev/null
@@ -1,431 +0,0 @@
-//! Exact symbolic canonicalization for `Expr`.
-//!
-//! Normalizes expressions into a canonical sum-of-terms form with signed
-//! coefficients and deterministic ordering, without losing algebraic precision.
-
-use std::collections::BTreeMap;
-
-use crate::expr::{CanonicalizationError, Expr};
-
-/// Hard cap on the number of additive terms produced while expanding an
-/// expression into canonical sum-of-monomials form.
-///
-/// Expanding a nested `(sum)^2 * (sum)^2` structure is exponential in nesting
-/// depth: composed-path overheads that traverse quadratic-overhead reductions
-/// (e.g. `QuadraticAssignment`) blow up to multi-GB of monomials and OOM/hang.
-/// When the intermediate term count would exceed this cap we abandon expansion
-/// and report the expression as `Unsupported`; callers (e.g. `big_o_of`) fall
-/// back to printing the compact, un-expanded expression. See issue #1069.
-///
-/// Legitimate overhead expressions stay far below this bound (the worst
-/// non-pathological case is a few hundred terms), so this never affects normal
-/// output — it only stops pathological blowups. This is a stopgap guard; the
-/// symbolic system is slated for a larger rework.
-const MAX_CANONICAL_TERMS: usize = 50_000;
-
-/// An opaque non-polynomial factor (exp, log, fractional-power base).
-///
-/// Stored by its canonical string representation for deterministic ordering.
-#[derive(Clone, Debug, PartialEq)]
-struct OpaqueFactor {
-    /// The canonical string form (used for equality and ordering).
-    key: String,
-    /// The original `Expr` for reconstruction.
-    expr: Expr,
-}
-
-impl Eq for OpaqueFactor {}
-
-impl PartialOrd for OpaqueFactor {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for OpaqueFactor {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.key.cmp(&other.key)
-    }
-}
-
-fn normalized_f64_bits(value: f64) -> u64 {
-    if value == 0.0 {
-        0.0f64.to_bits()
-    } else {
-        value.to_bits()
-    }
-}
-
-/// A single additive term: coefficient × product of canonical factors.
-#[derive(Clone, Debug)]
-struct CanonicalTerm {
-    /// Signed numeric coefficient.
-    coeff: f64,
-    /// Polynomial variable exponents (variable_name → exponent).
-    vars: BTreeMap<&'static str, f64>,
-    /// Non-polynomial opaque factors, sorted by key.
-    opaque: Vec<OpaqueFactor>,
-}
-
-/// Try to merge a new opaque factor into an existing list using transcendental identities.
-/// Returns `Some(updated_list)` if a merge happened, `None` if no identity applies.
-fn try_merge_opaque(existing: &[OpaqueFactor], new: &OpaqueFactor) -> Option<Vec<OpaqueFactor>> {
-    for (i, existing_factor) in existing.iter().enumerate() {
-        // exp(a) * exp(b) -> exp(a + b)
-        if let (Expr::Exp(a), Expr::Exp(b)) = (&existing_factor.expr, &new.expr) {
-            let merged_arg = (**a).clone() + (**b).clone();
-            let merged_expr =
-                Expr::Exp(Box::new(canonical_form(&merged_arg).unwrap_or(merged_arg)));
-            let mut result = existing.to_vec();
-            result[i] = OpaqueFactor {
-                key: merged_expr.to_string(),
-                expr: merged_expr,
-            };
-            return Some(result);
-        }
-
-        // c^a * c^b -> c^(a+b) for matching positive constant base c
-        if let (Expr::Pow(base1, exp1), Expr::Pow(base2, exp2)) = (&existing_factor.expr, &new.expr)
-        {
-            if let (Some(c1), Some(c2)) = (base1.constant_value(), base2.constant_value()) {
-                if c1 > 0.0 && c2 > 0.0 && (c1 - c2).abs() < 1e-15 {
-                    let merged_exp = (**exp1).clone() + (**exp2).clone();
-                    let canon_exp = canonical_form(&merged_exp).unwrap_or(merged_exp);
-                    let merged_expr = Expr::Pow(base1.clone(), Box::new(canon_exp));
-                    let mut result = existing.to_vec();
-                    result[i] = OpaqueFactor {
-                        key: merged_expr.to_string(),
-                        expr: merged_expr,
-                    };
-                    return Some(result);
-                }
-            }
-        }
-    }
-    None
-}
-
-/// A canonical sum of terms: the exact normal form of an expression.
-#[derive(Clone, Debug)]
-pub(crate) struct CanonicalSum {
-    terms: Vec<CanonicalTerm>,
-}
-
-impl CanonicalTerm {
-    fn constant(c: f64) -> Self {
-        Self {
-            coeff: c,
-            vars: BTreeMap::new(),
-            opaque: Vec::new(),
-        }
-    }
-
-    fn variable(name: &'static str) -> Self {
-        let mut vars = BTreeMap::new();
-        vars.insert(name, 1.0);
-        Self {
-            coeff: 1.0,
-            vars,
-            opaque: Vec::new(),
-        }
-    }
-
-    fn opaque_factor(expr: Expr) -> Self {
-        let key = expr.to_string();
-        Self {
-            coeff: 1.0,
-            vars: BTreeMap::new(),
-            opaque: vec![OpaqueFactor { key, expr }],
-        }
-    }
-
-    /// Multiply two terms, applying transcendental identities:
-    /// - `exp(a) * exp(b) -> exp(a + b)`
-    /// - `c^a * c^b -> c^(a + b)` for matching constant base `c`
-    fn mul(&self, other: &CanonicalTerm) -> CanonicalTerm {
-        let coeff = self.coeff * other.coeff;
-        let mut vars = self.vars.clone();
-        for (&v, &e) in &other.vars {
-            *vars.entry(v).or_insert(0.0) += e;
-        }
-        // Remove zero-exponent variables
-        vars.retain(|_, e| e.abs() > 1e-15);
-
-        // Merge opaque factors with transcendental identities
-        let mut opaque = self.opaque.clone();
-        for other_factor in &other.opaque {
-            if let Some(merged) = try_merge_opaque(&opaque, other_factor) {
-                opaque = merged;
-            } else {
-                opaque.push(other_factor.clone());
-            }
-        }
-        opaque.sort();
-        CanonicalTerm {
-            coeff,
-            vars,
-            opaque,
-        }
-    }
-
-    /// Deterministic sort key for ordering terms in a sum.
-    fn sort_key(&self) -> (Vec<(&'static str, u64)>, Vec<String>) {
-        let vars: Vec<_> = self
-            .vars
-            .iter()
-            .map(|(&k, &v)| (k, normalized_f64_bits(v)))
-            .collect();
-        let opaque: Vec<_> = self.opaque.iter().map(|o| o.key.clone()).collect();
-        (vars, opaque)
-    }
-}
-
-impl CanonicalSum {
-    fn from_term(term: CanonicalTerm) -> Self {
-        Self { terms: vec![term] }
-    }
-
-    fn add(mut self, other: CanonicalSum) -> Self {
-        self.terms.extend(other.terms);
-        self
-    }
-
-    fn mul(&self, other: &CanonicalSum) -> CanonicalSum {
-        let mut terms = Vec::new();
-        for a in &self.terms {
-            for b in &other.terms {
-                terms.push(a.mul(b));
-            }
-        }
-        CanonicalSum { terms }
-    }
-
-    /// Multiply with a guard against pathological expansion (see
-    /// [`MAX_CANONICAL_TERMS`]). The Cartesian product size is checked *before*
-    /// it is materialized, so this never allocates the blown-up vector.
-    fn try_mul(&self, other: &CanonicalSum) -> Result<CanonicalSum, CanonicalizationError> {
-        let product = self.terms.len().saturating_mul(other.terms.len());
-        if product > MAX_CANONICAL_TERMS {
-            return Err(CanonicalizationError::Unsupported(format!(
-                "expression too large to canonicalize ({product} terms exceeds cap of {MAX_CANONICAL_TERMS})"
-            )));
-        }
-        Ok(self.mul(other))
-    }
-
-    /// Merge terms with the same signature and drop zero-coefficient terms.
-    /// Sort the result deterministically.
-    fn simplify(self) -> Self {
-        type SortKey = (Vec<(&'static str, u64)>, Vec<String>);
-        let mut groups: BTreeMap<SortKey, CanonicalTerm> = BTreeMap::new();
-
-        for term in self.terms {
-            let key = term.sort_key();
-            groups
-                .entry(key)
-                .and_modify(|existing| existing.coeff += term.coeff)
-                .or_insert(term);
-        }
-
-        let mut terms: Vec<_> = groups
-            .into_values()
-            .filter(|t| t.coeff.abs() > 1e-15)
-            .collect();
-
-        terms.sort_by(|a, b| a.sort_key().cmp(&b.sort_key()));
-
-        CanonicalSum { terms }
-    }
-}
-
-/// Normalize an expression into its exact canonical sum-of-terms form.
-///
-/// This performs exact symbolic simplification:
-/// - Flattens nested Add/Mul
-/// - Merges duplicate additive terms by summing coefficients
-/// - Merges repeated multiplicative factors into powers
-/// - Preserves signed coefficients (supports subtraction)
-/// - Preserves transcendental identities: exp(a)*exp(b)=exp(a+b), etc.
-/// - Produces deterministic ordering
-///
-/// Does NOT drop terms or constant factors — use `big_o_normal_form()` for that.
-pub fn canonical_form(expr: &Expr) -> Result<Expr, CanonicalizationError> {
-    let sum = expr_to_canonical(expr)?;
-    let simplified = sum.simplify();
-    Ok(canonical_sum_to_expr(&simplified))
-}
-
-fn expr_to_canonical(expr: &Expr) -> Result<CanonicalSum, CanonicalizationError> {
-    match expr {
-        Expr::Const(c) => Ok(CanonicalSum::from_term(CanonicalTerm::constant(*c))),
-        Expr::Var(name) => Ok(CanonicalSum::from_term(CanonicalTerm::variable(name))),
-        Expr::Add(a, b) => {
-            let ca = expr_to_canonical(a)?;
-            let cb = expr_to_canonical(b)?;
-            Ok(ca.add(cb))
-        }
-        Expr::Mul(a, b) => {
-            let ca = expr_to_canonical(a)?;
-            let cb = expr_to_canonical(b)?;
-            ca.try_mul(&cb)
-        }
-        Expr::Pow(base, exp) => canonicalize_pow(base, exp),
-        Expr::Exp(arg) => {
-            // Treat exp(canonicalized_arg) as an opaque factor
-            let inner = canonical_form(arg)?;
-            Ok(CanonicalSum::from_term(CanonicalTerm::opaque_factor(
-                Expr::Exp(Box::new(inner)),
-            )))
-        }
-        Expr::Log(arg) => {
-            let inner = canonical_form(arg)?;
-            Ok(CanonicalSum::from_term(CanonicalTerm::opaque_factor(
-                Expr::Log(Box::new(inner)),
-            )))
-        }
-        Expr::Sqrt(arg) => {
-            // sqrt(x) = x^0.5 — canonicalize as power
-            canonicalize_pow(arg, &Expr::Const(0.5))
-        }
-        Expr::Factorial(arg) => {
-            let inner = canonical_form(arg)?;
-            Ok(CanonicalSum::from_term(CanonicalTerm::opaque_factor(
-                Expr::Factorial(Box::new(inner)),
-            )))
-        }
-    }
-}
-
-fn canonicalize_pow(base: &Expr, exp: &Expr) -> Result<CanonicalSum, CanonicalizationError> {
-    match (base, exp) {
-        // Constant base, constant exp → numeric constant
-        (_, _) if base.constant_value().is_some() && exp.constant_value().is_some() => {
-            let b = base.constant_value().unwrap();
-            let e = exp.constant_value().unwrap();
-            Ok(CanonicalSum::from_term(CanonicalTerm::constant(b.powf(e))))
-        }
-        // Variable ^ constant exponent → vars map (supports fractional/negative exponents)
-        (Expr::Var(name), _) if exp.constant_value().is_some() => {
-            let e = exp.constant_value().unwrap();
-            if e.abs() < 1e-15 {
-                return Ok(CanonicalSum::from_term(CanonicalTerm::constant(1.0)));
-            }
-            let mut vars = BTreeMap::new();
-            vars.insert(*name, e);
-            Ok(CanonicalSum::from_term(CanonicalTerm {
-                coeff: 1.0,
-                vars,
-                opaque: Vec::new(),
-            }))
-        }
-        // Polynomial base ^ constant integer exponent → expand
-        (_, _) if exp.constant_value().is_some() => {
-            let e = exp.constant_value().unwrap();
-            if e >= 0.0 && (e - e.round()).abs() < 1e-10 {
-                let n = e.round() as usize;
-                let base_sum = expr_to_canonical(base)?;
-                if n == 0 {
-                    return Ok(CanonicalSum::from_term(CanonicalTerm::constant(1.0)));
-                }
-                let mut result = base_sum.clone();
-                for _ in 1..n {
-                    result = result.try_mul(&base_sum)?;
-                }
-                Ok(result)
-            } else {
-                // Fractional exponent with non-variable base → opaque
-                let canon_base = canonical_form(base)?;
-                Ok(CanonicalSum::from_term(CanonicalTerm::opaque_factor(
-                    Expr::Pow(Box::new(canon_base), Box::new(Expr::Const(e))),
-                )))
-            }
-        }
-        // Constant base ^ variable exponent → opaque (exponential growth)
-        (_, _) if base.constant_value().is_some() => {
-            let c = base.constant_value().unwrap();
-            if (c - 1.0).abs() < 1e-15 {
-                return Ok(CanonicalSum::from_term(CanonicalTerm::constant(1.0)));
-            }
-            if c <= 0.0 {
-                return Err(CanonicalizationError::Unsupported(format!(
-                    "{}^{}",
-                    base, exp
-                )));
-            }
-            let canon_exp = canonical_form(exp)?;
-            Ok(CanonicalSum::from_term(CanonicalTerm::opaque_factor(
-                Expr::Pow(Box::new(base.clone()), Box::new(canon_exp)),
-            )))
-        }
-        // Variable base ^ variable exponent → unsupported
-        _ => Err(CanonicalizationError::Unsupported(format!(
-            "{}^{}",
-            base, exp
-        ))),
-    }
-}
-
-fn canonical_sum_to_expr(sum: &CanonicalSum) -> Expr {
-    if sum.terms.is_empty() {
-        return Expr::Const(0.0);
-    }
-
-    let term_exprs: Vec<Expr> = sum.terms.iter().map(canonical_term_to_expr).collect();
-
-    let mut result = term_exprs[0].clone();
-    for term in &term_exprs[1..] {
-        result = result + term.clone();
-    }
-    result
-}
-
-fn canonical_term_to_expr(term: &CanonicalTerm) -> Expr {
-    let mut factors: Vec<Expr> = Vec::new();
-
-    // Add coefficient if not 1.0 (or -1.0, handled specially)
-    let (coeff_factor, sign) = if term.coeff < 0.0 {
-        (term.coeff.abs(), true)
-    } else {
-        (term.coeff, false)
-    };
-
-    let has_other_factors = !term.vars.is_empty() || !term.opaque.is_empty();
-
-    if (coeff_factor - 1.0).abs() > 1e-15 || !has_other_factors {
-        factors.push(Expr::Const(coeff_factor));
-    }
-
-    // Add variable powers
-    for (&var, &exp) in &term.vars {
-        if (exp - 1.0).abs() < 1e-15 {
-            factors.push(Expr::Var(var));
-        } else {
-            factors.push(Expr::pow(Expr::Var(var), Expr::Const(exp)));
-        }
-    }
-
-    // Add opaque factors
-    for opaque in &term.opaque {
-        factors.push(opaque.expr.clone());
-    }
-
-    let mut result = if factors.is_empty() {
-        Expr::Const(1.0)
-    } else {
-        let mut r = factors[0].clone();
-        for f in &factors[1..] {
-            r = r * f.clone();
-        }
-        r
-    };
-
-    if sign {
-        result = -result;
-    }
-
-    result
-}
-
-#[cfg(test)]
-#[path = "unit_tests/canonical.rs"]
-mod tests;
diff --git a/src/config.rs b/src/config.rs
index 6a9e687ed..c5e2084fd 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -25,107 +25,15 @@ pub fn config_to_index(config: &[usize], num_flavors: usize) -> usize {
 }
 
 /// Convert a binary configuration to a bitvec-style representation.
-#[cfg(test)]
 pub(crate) fn config_to_bits(config: &[usize]) -> Vec<bool> {
     config.iter().map(|&v| v != 0).collect()
 }
 
 /// Convert a bitvec-style representation to a binary configuration.
-#[cfg(test)]
 pub(crate) fn bits_to_config(bits: &[bool]) -> Vec<usize> {
     bits.iter().map(|&b| if b { 1 } else { 0 }).collect()
 }
 
-/// Iterator over all configurations for per-variable dimension sizes.
-///
-/// Supports different cardinalities per variable (e.g., `dims = [2, 3, 2]`).
-pub struct DimsIterator {
-    dims: Vec<usize>,
-    current: Option<Vec<usize>>,
-    total_configs: usize,
-    current_index: usize,
-}
-
-impl DimsIterator {
-    /// Create a new iterator from per-variable dimensions.
-    ///
-    /// For empty dims, produces exactly one configuration (the empty config).
-    /// If any dimension is 0, produces no configurations.
-    pub fn new(dims: Vec<usize>) -> Self {
-        let total_configs = if dims.is_empty() {
-            // No variables means exactly 1 configuration: the empty config
-            1
-        } else {
-            dims.iter()
-                .copied()
-                .try_fold(
-                    1usize,
-                    |acc, d| {
-                        if d == 0 {
-                            None
-                        } else {
-                            acc.checked_mul(d)
-                        }
-                    },
-                )
-                .unwrap_or(0)
-        };
-        let current = if total_configs == 0 {
-            None
-        } else {
-            Some(vec![0; dims.len()])
-        };
-        Self {
-            dims,
-            current,
-            total_configs,
-            current_index: 0,
-        }
-    }
-
-    /// Returns the total number of configurations.
-    pub fn total(&self) -> usize {
-        self.total_configs
-    }
-}
-
-impl Iterator for DimsIterator {
-    type Item = Vec<usize>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let current = self.current.take()?;
-        let result = current.clone();
-
-        // Advance to next configuration
-        let mut next = current;
-        let mut carry = true;
-        for i in (0..self.dims.len()).rev() {
-            if carry {
-                next[i] += 1;
-                if next[i] >= self.dims[i] {
-                    next[i] = 0;
-                } else {
-                    carry = false;
-                }
-            }
-        }
-
-        self.current_index += 1;
-        if self.current_index < self.total_configs {
-            self.current = Some(next);
-        }
-
-        Some(result)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let remaining = self.total_configs - self.current_index;
-        (remaining, Some(remaining))
-    }
-}
-
-impl ExactSizeIterator for DimsIterator {}
-
 #[cfg(test)]
 #[path = "unit_tests/config.rs"]
 mod tests;
diff --git a/src/example_db/mod.rs b/src/example_db/mod.rs
index 6ed577a95..958ace123 100644
--- a/src/example_db/mod.rs
+++ b/src/example_db/mod.rs
@@ -54,7 +54,7 @@ fn validate_model_uniqueness(models: &[ModelExample]) -> Result<()> {
 /// Build the full example database from specs.
 ///
 /// ILP rule examples call the ILP solver at build time to compute solutions
-/// dynamically (feature-gated behind `ilp-solver`).
+/// dynamically.
 pub fn build_example_db() -> Result<ExampleDb> {
     let model_db = build_model_db()?;
     let rule_db = build_rule_db()?;
diff --git a/src/example_db/specs.rs b/src/example_db/specs.rs
index d6facb3ca..75f2210f4 100644
--- a/src/example_db/specs.rs
+++ b/src/example_db/specs.rs
@@ -19,7 +19,7 @@ pub struct ModelExampleSpec {
     /// The concrete problem instance (type-erased).
     pub instance: Box<dyn DynProblem>,
     /// One known optimal configuration.
-    pub optimal_config: Vec<usize>,
+    pub optimal_config: serde_json::Value,
     /// The optimal value as a serializable JSON value.
     pub optimal_value: serde_json::Value,
 }
@@ -58,7 +58,7 @@ where
     T: Problem + Serialize,
     <S as ReduceTo<T>>::Result: ReductionResult<Source = S, Target = T>,
 {
-    let reduction = source.reduce_to();
+    let reduction = source.reduce_to().expect("reduction should succeed");
     let target = reduction.target_problem();
     assemble_rule_example(&source, target, vec![solution])
 }
@@ -68,26 +68,52 @@ where
 /// This is the standard pattern for canonical ILP rule examples: reduce once,
 /// solve the ILP, extract the source config, and build the example — avoiding
 /// the double `reduce_to()` that would occur with `rule_example_with_witness`.
-#[cfg(feature = "ilp-solver")]
 pub fn rule_example_via_ilp<S, V>(source: S) -> RuleExample
 where
     S: Problem + Serialize + ReduceTo<crate::models::algebraic::ILP<V>>,
     V: crate::models::algebraic::VariableDomain,
     <S as ReduceTo<crate::models::algebraic::ILP<V>>>::Result:
         ReductionResult<Source = S, Target = crate::models::algebraic::ILP<V>>,
+    S::Solution: Serialize,
+{
+    rule_example_via_typed_ilp::<S, V, i64>(source)
+}
+
+/// Float-coefficient counterpart of [`rule_example_via_ilp`].
+pub fn rule_example_via_float_ilp<S, V>(source: S) -> RuleExample
+where
+    S: Problem + Serialize + ReduceTo<crate::models::algebraic::ILP<V, f64>>,
+    V: crate::models::algebraic::VariableDomain,
+    <S as ReduceTo<crate::models::algebraic::ILP<V, f64>>>::Result:
+        ReductionResult<Source = S, Target = crate::models::algebraic::ILP<V, f64>>,
+    S::Solution: Serialize,
+{
+    rule_example_via_typed_ilp::<S, V, f64>(source)
+}
+
+fn rule_example_via_typed_ilp<S, V, C>(source: S) -> RuleExample
+where
+    S: Problem + Serialize + ReduceTo<crate::models::algebraic::ILP<V, C>>,
+    V: crate::models::algebraic::VariableDomain,
+    C: crate::models::algebraic::ILPCoefficient + Serialize,
+    <S as ReduceTo<crate::models::algebraic::ILP<V, C>>>::Result:
+        ReductionResult<Source = S, Target = crate::models::algebraic::ILP<V, C>>,
+    S::Solution: Serialize,
 {
     use crate::export::SolutionPair;
-    let reduction = source.reduce_to();
+    let reduction = source.reduce_to().expect("reduction should succeed");
     let ilp_solution = crate::solvers::ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("canonical example must be ILP-solvable");
-    let source_config = reduction.extract_solution(&ilp_solution);
+    let source_config = reduction.extract_solution(&ilp_solution).unwrap();
     assemble_rule_example(
         &source,
         reduction.target_problem(),
         vec![SolutionPair {
-            source_config,
-            target_config: ilp_solution,
+            source_config: serde_json::to_value(source_config)
+                .expect("source solution serialization must succeed"),
+            target_config: serde_json::to_value(ilp_solution)
+                .expect("target solution serialization must succeed"),
         }],
     )
 }
diff --git a/src/export.rs b/src/export.rs
index 331055caf..86f6ece00 100644
--- a/src/export.rs
+++ b/src/export.rs
@@ -1,6 +1,6 @@
 //! JSON export schema for example payloads.
 
-use crate::rules::registry::ReductionOverhead;
+use crate::rules::registry::{ParameterContractError, ReductionParameterContract};
 use crate::rules::ReductionGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -51,8 +51,8 @@ pub struct ProblemRef {
 /// One source↔target solution pair.
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 pub struct SolutionPair {
-    pub source_config: Vec<usize>,
-    pub target_config: Vec<usize>,
+    pub source_config: serde_json::Value,
+    pub target_config: serde_json::Value,
 }
 
 /// A complete rule example: reduction + solutions in one file.
@@ -69,7 +69,7 @@ pub struct ModelExample {
     pub problem: String,
     pub variant: BTreeMap<String, String>,
     pub instance: serde_json::Value,
-    pub optimal_config: Vec<usize>,
+    pub optimal_config: serde_json::Value,
     pub optimal_value: serde_json::Value,
 }
 
@@ -78,7 +78,7 @@ impl ModelExample {
         problem: &str,
         variant: BTreeMap<String, String>,
         instance: serde_json::Value,
-        optimal_config: Vec<usize>,
+        optimal_config: serde_json::Value,
         optimal_value: serde_json::Value,
     ) -> Self {
         Self {
@@ -117,17 +117,19 @@ pub struct ExampleDb {
     pub rules: Vec<RuleExample>,
 }
 
-/// Look up `ReductionOverhead` for a direct reduction using `ReductionGraph::find_best_entry`.
-pub fn lookup_overhead(
+/// Look up the explicit parameter contract for an exact direct reduction entry.
+pub fn lookup_parameter_contract(
     source_name: &str,
     source_variant: &BTreeMap<String, String>,
     target_name: &str,
     target_variant: &BTreeMap<String, String>,
-) -> Option<ReductionOverhead> {
+) -> Result<Option<ReductionParameterContract>, ParameterContractError> {
     let graph = ReductionGraph::new();
-    let matched =
-        graph.find_best_entry(source_name, source_variant, target_name, target_variant)?;
-    Some(matched.overhead)
+    let Some(matched) = graph.find_entry(source_name, source_variant, target_name, target_variant)
+    else {
+        return Ok(None);
+    };
+    matched.parameter_contract.map(Some)
 }
 
 /// Convert `Problem::variant()` output to a stable `BTreeMap`.
diff --git a/src/expr.rs b/src/expr.rs
index a880b6a09..df5457930 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -1,572 +1,461 @@
-//! General symbolic expression AST for reduction overhead.
+//! Symbolic expression integration for the problem-reduction domain.
 
-use crate::types::ProblemSize;
-use std::collections::{HashMap, HashSet};
+pub use num_bigint::BigInt;
+use num_rational::BigRational;
+#[cfg(test)]
+use num_traits::FromPrimitive;
+use num_traits::{One, Signed, ToPrimitive, Zero};
+pub use problemreductions_expr::{
+    Expr, ExprNode, ExprNodeId, ParseError, SubstitutionError, Symbol,
+};
+use std::cmp::Ordering;
+use std::collections::{BTreeMap, HashMap};
 use std::fmt;
 
-/// A symbolic math expression over problem size variables.
-#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
-pub enum Expr {
-    /// Numeric constant.
-    Const(f64),
-    /// Named variable (e.g., "num_vertices").
-    Var(&'static str),
-    /// Addition: a + b.
-    Add(Box<Expr>, Box<Expr>),
-    /// Multiplication: a * b.
-    Mul(Box<Expr>, Box<Expr>),
-    /// Exponentiation: base ^ exponent.
-    Pow(Box<Expr>, Box<Expr>),
-    /// Exponential function: exp(a).
-    Exp(Box<Expr>),
-    /// Natural logarithm: log(a).
-    Log(Box<Expr>),
-    /// Square root: sqrt(a).
-    Sqrt(Box<Expr>),
-    /// Factorial: factorial(a).
-    Factorial(Box<Expr>),
-}
+use crate::types::ProblemParameters;
 
-impl Expr {
-    /// Convenience constructor for exponentiation.
-    pub fn pow(base: Expr, exp: Expr) -> Self {
-        Expr::Pow(Box::new(base), Box::new(exp))
-    }
+/// Algebraic facts computed once from the shared expression DAG and consumed by
+/// exact-size evaluation and asymptotic-growth projection.
+#[derive(Clone, Debug)]
+pub(crate) struct AlgebraicAnalysis {
+    facts: HashMap<ExprNodeId, AlgebraicFacts>,
+}
 
-    /// Multiply expression by a scalar constant.
-    pub fn scale(self, c: f64) -> Self {
-        Expr::Const(c) * self
-    }
+#[derive(Clone, Debug)]
+pub(crate) struct AlgebraicFacts {
+    pub(crate) is_constant: bool,
+    pub(crate) exact_rational: Option<BigRational>,
+    pub(crate) linear: Option<BTreeMap<Symbol, BigRational>>,
+    pub(crate) constant_domain: Option<bool>,
+    pub(crate) sign: Option<Ordering>,
+    pub(crate) cmp_one: Option<Ordering>,
+}
 
-    /// Evaluate the expression given concrete variable values.
-    pub fn eval(&self, vars: &ProblemSize) -> f64 {
-        match self {
-            Expr::Const(c) => *c,
-            Expr::Var(name) => vars.get(name).unwrap_or(0) as f64,
-            Expr::Add(a, b) => a.eval(vars) + b.eval(vars),
-            Expr::Mul(a, b) => a.eval(vars) * b.eval(vars),
-            Expr::Pow(base, exp) => base.eval(vars).powf(exp.eval(vars)),
-            Expr::Exp(a) => a.eval(vars).exp(),
-            Expr::Log(a) => a.eval(vars).ln(),
-            Expr::Sqrt(a) => a.eval(vars).sqrt(),
-            Expr::Factorial(a) => gamma_factorial(a.eval(vars)),
+impl AlgebraicAnalysis {
+    pub(crate) fn new(expressions: &[&Expr]) -> Self {
+        let mut facts = HashMap::new();
+        for expression in expressions {
+            analyze_algebraic(expression, &mut facts);
         }
+        Self { facts }
     }
 
-    /// Collect all variable names referenced in this expression.
-    pub fn variables(&self) -> HashSet<&'static str> {
-        let mut vars = HashSet::new();
-        self.collect_variables(&mut vars);
-        vars
+    pub(crate) fn facts(&self, expression: &Expr) -> &AlgebraicFacts {
+        &self.facts[&expression.node_identity()]
     }
+}
 
-    fn collect_variables(&self, vars: &mut HashSet<&'static str>) {
-        match self {
-            Expr::Const(_) => {}
-            Expr::Var(name) => {
-                vars.insert(name);
+fn analyze_algebraic(
+    expression: &Expr,
+    memo: &mut HashMap<ExprNodeId, AlgebraicFacts>,
+) -> AlgebraicFacts {
+    if let Some(facts) = memo.get(&expression.node_identity()) {
+        return facts.clone();
+    }
+    let facts = match expression.node() {
+        ExprNode::Const(value) => AlgebraicFacts {
+            is_constant: true,
+            exact_rational: Some(value.clone()),
+            linear: Some(BTreeMap::new()),
+            constant_domain: Some(true),
+            sign: Some(value.cmp(&BigRational::from_integer(0.into()))),
+            cmp_one: Some(value.cmp(&BigRational::from_integer(1.into()))),
+        },
+        ExprNode::Var(symbol) => AlgebraicFacts {
+            is_constant: false,
+            exact_rational: None,
+            linear: Some(BTreeMap::from([(
+                symbol.clone(),
+                BigRational::from_integer(1.into()),
+            )])),
+            constant_domain: None,
+            sign: None,
+            cmp_one: None,
+        },
+        ExprNode::Add(values) => {
+            let children = values
+                .iter()
+                .map(|value| analyze_algebraic(value, memo))
+                .collect::<Vec<_>>();
+            let is_constant = children.iter().all(|facts| facts.is_constant);
+            AlgebraicFacts {
+                is_constant,
+                exact_rational: sum_exact(&children),
+                linear: sum_linear(&children),
+                constant_domain: is_constant.then(|| all_domains(&children)).flatten(),
+                sign: is_constant.then(|| sum_sign(&children)).flatten(),
+                cmp_one: None,
             }
-            Expr::Add(a, b) | Expr::Mul(a, b) | Expr::Pow(a, b) => {
-                a.collect_variables(vars);
-                b.collect_variables(vars);
-            }
-            Expr::Exp(a) | Expr::Log(a) | Expr::Sqrt(a) | Expr::Factorial(a) => {
-                a.collect_variables(vars);
+        }
+        ExprNode::Mul(values) => {
+            let children = values
+                .iter()
+                .map(|value| analyze_algebraic(value, memo))
+                .collect::<Vec<_>>();
+            let is_constant = children.iter().all(|facts| facts.is_constant);
+            let exact_rational = product_exact(&children);
+            AlgebraicFacts {
+                is_constant,
+                linear: product_linear(&children),
+                constant_domain: is_constant.then(|| all_domains(&children)).flatten(),
+                sign: is_constant.then(|| product_sign(&children)).flatten(),
+                cmp_one: exact_rational
+                    .as_ref()
+                    .map(|value| value.cmp(&BigRational::from_integer(1.into()))),
+                exact_rational,
             }
         }
-    }
-
-    /// Substitute variables with other expressions.
-    pub fn substitute(&self, mapping: &HashMap<&str, &Expr>) -> Expr {
-        match self {
-            Expr::Const(c) => Expr::Const(*c),
-            Expr::Var(name) => {
-                if let Some(replacement) = mapping.get(name) {
-                    (*replacement).clone()
-                } else {
-                    Expr::Var(name)
+        ExprNode::Pow(base, exponent) => {
+            let base = analyze_algebraic(base, memo);
+            let exponent = analyze_algebraic(exponent, memo);
+            let is_constant = base.is_constant && exponent.is_constant;
+            let exact_rational = match (
+                base.exact_rational.as_ref(),
+                exponent.exact_rational.as_ref(),
+            ) {
+                (Some(base), Some(exponent)) if exponent == &-BigRational::one() => {
+                    (!base.is_zero()).then(|| base.recip())
                 }
+                _ => None,
+            };
+            let domain = if is_constant {
+                power_domain(&base, &exponent)
+            } else {
+                None
+            };
+            let sign = domain
+                .is_some_and(|defined| defined)
+                .then(|| power_sign(&base, &exponent))
+                .flatten();
+            let cmp_one = domain
+                .is_some_and(|defined| defined)
+                .then(|| power_cmp_one(&base, &exponent))
+                .flatten();
+            AlgebraicFacts {
+                is_constant,
+                exact_rational,
+                linear: is_constant.then(BTreeMap::new),
+                constant_domain: domain,
+                sign,
+                cmp_one,
             }
-            Expr::Add(a, b) => a.substitute(mapping) + b.substitute(mapping),
-            Expr::Mul(a, b) => a.substitute(mapping) * b.substitute(mapping),
-            Expr::Pow(a, b) => Expr::pow(a.substitute(mapping), b.substitute(mapping)),
-            Expr::Exp(a) => Expr::Exp(Box::new(a.substitute(mapping))),
-            Expr::Log(a) => Expr::Log(Box::new(a.substitute(mapping))),
-            Expr::Sqrt(a) => Expr::Sqrt(Box::new(a.substitute(mapping))),
-            Expr::Factorial(a) => Expr::Factorial(Box::new(a.substitute(mapping))),
         }
-    }
-
-    /// Parse an expression string into an `Expr` at runtime.
-    ///
-    /// **Memory note:** Variable names are leaked to `&'static str` via `Box::leak`
-    /// since `Expr::Var` requires static lifetimes. Each unique variable name leaks
-    /// a small allocation that is never freed. This is acceptable for testing and
-    /// one-time cross-check evaluation, but should not be used in hot loops with
-    /// dynamic input.
-    ///
-    /// # Panics
-    /// Panics if the expression string has invalid syntax.
-    pub fn parse(input: &str) -> Expr {
-        Self::try_parse(input)
-            .unwrap_or_else(|e| panic!("failed to parse expression \"{input}\": {e}"))
-    }
-
-    /// Parse an expression string into an `Expr`, returning a normal error on failure.
-    pub fn try_parse(input: &str) -> Result<Expr, String> {
-        parse_to_expr(input)
-    }
-
-    /// Check if this expression is a polynomial (no exp/log/sqrt, integer exponents only).
-    pub fn is_polynomial(&self) -> bool {
-        match self {
-            Expr::Const(_) | Expr::Var(_) => true,
-            Expr::Add(a, b) | Expr::Mul(a, b) => a.is_polynomial() && b.is_polynomial(),
-            Expr::Pow(base, exp) => {
-                base.is_polynomial()
-                    && matches!(exp.as_ref(), Expr::Const(c) if *c >= 0.0 && (*c - c.round()).abs() < 1e-10)
+        ExprNode::Exp(value) => {
+            let value = analyze_algebraic(value, memo);
+            let domain = value.is_constant.then_some(value.constant_domain).flatten();
+            AlgebraicFacts {
+                is_constant: value.is_constant,
+                exact_rational: value
+                    .exact_rational
+                    .as_ref()
+                    .filter(|value| value.is_zero())
+                    .map(|_| BigRational::from_integer(1.into())),
+                linear: value.is_constant.then(BTreeMap::new),
+                constant_domain: domain,
+                sign: domain
+                    .is_some_and(|defined| defined)
+                    .then_some(Ordering::Greater),
+                cmp_one: value.sign,
             }
-            Expr::Exp(_) | Expr::Log(_) | Expr::Sqrt(_) | Expr::Factorial(_) => false,
         }
-    }
-
-    /// Check whether this expression is suitable for asymptotic complexity notation.
-    ///
-    /// This is intentionally conservative for symbolic size formulas:
-    /// - rejects explicit multiplicative constant factors like `3 * n`
-    /// - rejects additive constant terms like `n + 1`
-    /// - allows constants used as exponents (e.g. `n^(1/3)`)
-    /// - allows constants used as exponential bases (e.g. `2^n`)
-    ///
-    /// The goal is to accept expressions that already look like reduced
-    /// asymptotic notation, rather than exact-count formulas.
-    pub fn is_valid_complexity_notation(&self) -> bool {
-        self.is_valid_complexity_notation_inner()
-    }
-
-    fn is_valid_complexity_notation_inner(&self) -> bool {
-        match self {
-            Expr::Const(c) => (*c - 1.0).abs() < 1e-10,
-            Expr::Var(_) => true,
-            Expr::Add(a, b) => {
-                a.constant_value().is_none()
-                    && b.constant_value().is_none()
-                    && a.is_valid_complexity_notation_inner()
-                    && b.is_valid_complexity_notation_inner()
-            }
-            Expr::Mul(a, b) => {
-                a.constant_value().is_none()
-                    && b.constant_value().is_none()
-                    && a.is_valid_complexity_notation_inner()
-                    && b.is_valid_complexity_notation_inner()
-            }
-            Expr::Pow(base, exp) => {
-                let base_is_constant = base.constant_value().is_some();
-                let exp_is_constant = exp.constant_value().is_some();
-
-                let base_ok = if base_is_constant {
-                    base.is_valid_exponential_base()
-                } else {
-                    base.is_valid_complexity_notation_inner()
-                };
-
-                let exp_ok = if exp_is_constant {
-                    true
-                } else {
-                    exp.is_valid_complexity_notation_inner()
-                };
-
-                base_ok && exp_ok
-            }
-            Expr::Exp(a) | Expr::Log(a) | Expr::Sqrt(a) | Expr::Factorial(a) => {
-                a.is_valid_complexity_notation_inner()
+        ExprNode::Log(value) => {
+            let value = analyze_algebraic(value, memo);
+            let domain = if value.is_constant {
+                value
+                    .constant_domain
+                    .map(|defined| defined && value.sign == Some(Ordering::Greater))
+            } else {
+                None
+            };
+            AlgebraicFacts {
+                is_constant: value.is_constant,
+                exact_rational: value
+                    .exact_rational
+                    .as_ref()
+                    .filter(|value| value.is_one())
+                    .map(|_| BigRational::from_integer(0.into())),
+                linear: value.is_constant.then(BTreeMap::new),
+                constant_domain: domain,
+                sign: domain
+                    .is_some_and(|defined| defined)
+                    .then_some(value.cmp_one)
+                    .flatten(),
+                cmp_one: None,
             }
         }
-    }
-
-    fn is_valid_exponential_base(&self) -> bool {
-        self.constant_value().is_some_and(|c| c > 0.0)
-    }
-
-    pub(crate) fn constant_value(&self) -> Option<f64> {
-        match self {
-            Expr::Const(c) => Some(*c),
-            Expr::Var(_) => None,
-            Expr::Add(a, b) => Some(a.constant_value()? + b.constant_value()?),
-            Expr::Mul(a, b) => Some(a.constant_value()? * b.constant_value()?),
-            Expr::Pow(base, exp) => Some(base.constant_value()?.powf(exp.constant_value()?)),
-            Expr::Exp(a) => Some(a.constant_value()?.exp()),
-            Expr::Log(a) => Some(a.constant_value()?.ln()),
-            Expr::Sqrt(a) => Some(a.constant_value()?.sqrt()),
-            Expr::Factorial(a) => Some(gamma_factorial(a.constant_value()?)),
-        }
-    }
-}
-
-impl fmt::Display for Expr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Expr::Const(c) => {
-                let ci = c.round() as i64;
-                if (*c - ci as f64).abs() < 1e-10 {
-                    write!(f, "{ci}")
-                } else {
-                    write!(f, "{c}")
-                }
-            }
-            Expr::Var(name) => write!(f, "{name}"),
-            Expr::Add(a, b) => write!(f, "{a} + {b}"),
-            Expr::Mul(a, b) => {
-                let left = if matches!(a.as_ref(), Expr::Add(_, _)) {
-                    format!("({a})")
-                } else {
-                    format!("{a}")
-                };
-                let right = if matches!(b.as_ref(), Expr::Add(_, _)) {
-                    format!("({b})")
-                } else {
-                    format!("{b}")
-                };
-                write!(f, "{left} * {right}")
+        ExprNode::Factorial(value) => {
+            let value = analyze_algebraic(value, memo);
+            let valid = value
+                .exact_rational
+                .as_ref()
+                .map(|value| value.is_integer() && !value.is_negative());
+            AlgebraicFacts {
+                is_constant: value.is_constant,
+                exact_rational: None,
+                linear: value.is_constant.then(BTreeMap::new),
+                constant_domain: value.is_constant.then_some(valid).flatten(),
+                sign: valid
+                    .is_some_and(|valid| valid)
+                    .then_some(Ordering::Greater),
+                cmp_one: valid.and_then(|valid| {
+                    valid.then(|| {
+                        if value
+                            .exact_rational
+                            .as_ref()
+                            .is_some_and(|value| value <= &BigRational::from_integer(1.into()))
+                        {
+                            Ordering::Equal
+                        } else {
+                            Ordering::Greater
+                        }
+                    })
+                }),
             }
-            Expr::Pow(base, exp) => {
-                // Special case: x^0.5 → sqrt(x)
-                if let Expr::Const(e) = exp.as_ref() {
-                    if (*e - 0.5).abs() < 1e-15 {
-                        return write!(f, "sqrt({base})");
-                    }
-                }
-                let base_str = if matches!(base.as_ref(), Expr::Add(_, _) | Expr::Mul(_, _)) {
-                    format!("({base})")
-                } else {
-                    format!("{base}")
-                };
-                let exp_str = if matches!(exp.as_ref(), Expr::Add(_, _) | Expr::Mul(_, _)) {
-                    format!("({exp})")
-                } else {
-                    format!("{exp}")
-                };
-                write!(f, "{base_str}^{exp_str}")
-            }
-            Expr::Exp(a) => write!(f, "exp({a})"),
-            Expr::Log(a) => write!(f, "log({a})"),
-            Expr::Sqrt(a) => write!(f, "sqrt({a})"),
-            Expr::Factorial(a) => write!(f, "factorial({a})"),
         }
-    }
+    };
+    memo.insert(expression.node_identity(), facts.clone());
+    facts
 }
 
-impl std::ops::Add for Expr {
-    type Output = Self;
-
-    fn add(self, other: Self) -> Self {
-        Expr::Add(Box::new(self), Box::new(other))
-    }
+fn sum_exact(children: &[AlgebraicFacts]) -> Option<BigRational> {
+    children.iter().try_fold(BigRational::zero(), |sum, child| {
+        Some(sum + child.exact_rational.as_ref()?)
+    })
 }
 
-impl std::ops::Mul for Expr {
-    type Output = Self;
-
-    fn mul(self, other: Self) -> Self {
-        Expr::Mul(Box::new(self), Box::new(other))
-    }
+fn product_exact(children: &[AlgebraicFacts]) -> Option<BigRational> {
+    children
+        .iter()
+        .try_fold(BigRational::one(), |product, child| {
+            Some(product * child.exact_rational.as_ref()?)
+        })
 }
 
-impl std::ops::Sub for Expr {
-    type Output = Self;
-
-    fn sub(self, other: Self) -> Self {
-        self + Expr::Const(-1.0) * other
+fn sum_linear(children: &[AlgebraicFacts]) -> Option<BTreeMap<Symbol, BigRational>> {
+    let mut result = BTreeMap::new();
+    for child in children {
+        for (symbol, coefficient) in child.linear.as_ref()? {
+            *result
+                .entry(symbol.clone())
+                .or_insert_with(BigRational::zero) += coefficient;
+        }
     }
+    result.retain(|_, coefficient| !coefficient.is_zero());
+    Some(result)
 }
 
-impl std::ops::Div for Expr {
-    type Output = Self;
-
-    fn div(self, other: Self) -> Self {
-        self * Expr::pow(other, Expr::Const(-1.0))
+fn product_linear(children: &[AlgebraicFacts]) -> Option<BTreeMap<Symbol, BigRational>> {
+    if children.iter().all(|child| child.is_constant) {
+        return Some(BTreeMap::new());
+    }
+    let mut coefficient = BigRational::one();
+    let mut linear = None;
+    for child in children {
+        if child.is_constant {
+            coefficient *= child.exact_rational.as_ref()?;
+        } else if linear.is_some() {
+            return None;
+        } else {
+            linear = Some(child.linear.clone()?);
+        }
     }
+    let mut linear = linear?;
+    for value in linear.values_mut() {
+        *value *= &coefficient;
+    }
+    linear.retain(|_, value| !value.is_zero());
+    Some(linear)
 }
 
-impl std::ops::Neg for Expr {
-    type Output = Self;
-
-    fn neg(self) -> Self {
-        Expr::Const(-1.0) * self
+fn all_domains(children: &[AlgebraicFacts]) -> Option<bool> {
+    let mut defined = true;
+    for child in children {
+        defined &= child.constant_domain?;
     }
+    Some(defined)
 }
 
-/// Error returned when analyzing asymptotic behavior.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum AsymptoticAnalysisError {
-    Unsupported(String),
+fn sum_sign(children: &[AlgebraicFacts]) -> Option<Ordering> {
+    if let Some(value) = sum_exact(children) {
+        return Some(value.cmp(&BigRational::zero()));
+    }
+    let signs = children
+        .iter()
+        .map(|child| child.sign)
+        .collect::<Option<Vec<_>>>()?;
+    if signs.iter().all(|sign| *sign != Ordering::Less) {
+        Some(if signs.contains(&Ordering::Greater) {
+            Ordering::Greater
+        } else {
+            Ordering::Equal
+        })
+    } else if signs.iter().all(|sign| *sign != Ordering::Greater) {
+        Some(Ordering::Less)
+    } else {
+        None
+    }
 }
 
-impl fmt::Display for AsymptoticAnalysisError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Unsupported(expr) => write!(f, "unsupported asymptotic expression: {expr}"),
+fn product_sign(children: &[AlgebraicFacts]) -> Option<Ordering> {
+    let mut sign = Ordering::Greater;
+    for child in children {
+        match child.sign? {
+            Ordering::Equal => return Some(Ordering::Equal),
+            Ordering::Less => sign = sign.reverse(),
+            Ordering::Greater => {}
         }
     }
+    Some(sign)
 }
 
-impl std::error::Error for AsymptoticAnalysisError {}
-
-/// Error returned when exact canonicalization fails.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum CanonicalizationError {
-    /// Expression cannot be canonicalized (e.g., variable in both base and exponent).
-    Unsupported(String),
+fn power_domain(base: &AlgebraicFacts, exponent: &AlgebraicFacts) -> Option<bool> {
+    if !base.constant_domain? || !exponent.constant_domain? {
+        return Some(false);
+    }
+    match base.sign? {
+        Ordering::Greater => Some(true),
+        Ordering::Equal => Some(exponent.sign? == Ordering::Greater),
+        Ordering::Less => exponent
+            .exact_rational
+            .as_ref()
+            .map(|value| value.is_integer()),
+    }
 }
 
-impl fmt::Display for CanonicalizationError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Unsupported(expr) => {
-                write!(f, "unsupported expression for canonicalization: {expr}")
+fn power_sign(base: &AlgebraicFacts, exponent: &AlgebraicFacts) -> Option<Ordering> {
+    let exponent_value = exponent.exact_rational.as_ref()?;
+    if exponent_value.is_zero() {
+        return Some(Ordering::Greater);
+    }
+    match base.sign? {
+        Ordering::Greater => Some(Ordering::Greater),
+        Ordering::Equal => Some(Ordering::Equal),
+        Ordering::Less => {
+            let exponent = exponent_value.to_integer();
+            if (&exponent % 2u8).is_zero() {
+                Some(Ordering::Greater)
+            } else {
+                Some(Ordering::Less)
             }
         }
     }
 }
 
-impl std::error::Error for CanonicalizationError {}
-
-/// Return a normalized `Expr` representing the asymptotic behavior of `expr`.
-///
-/// This is now a compatibility wrapper for `big_o_normal_form()`.
-pub fn asymptotic_normal_form(expr: &Expr) -> Result<Expr, AsymptoticAnalysisError> {
-    crate::big_o::big_o_normal_form(expr)
-}
-
-/// Compute factorial for non-negative values.
-///
-/// For non-negative integers, returns the exact integer factorial.
-/// For non-integer values, uses Stirling's approximation of the gamma function:
-/// n! = Γ(n+1) ≈ √(2πn) · (n/e)^n.
-fn gamma_factorial(n: f64) -> f64 {
-    if n < 0.0 {
-        return f64::NAN;
-    }
-    let rounded = n.round();
-    if (n - rounded).abs() < 1e-10 && rounded >= 0.0 {
-        let k = rounded as u64;
-        let mut result = 1u64;
-        for i in 2..=k {
-            result = result.saturating_mul(i);
-        }
-        result as f64
+fn power_cmp_one(base: &AlgebraicFacts, exponent: &AlgebraicFacts) -> Option<Ordering> {
+    let exponent = exponent.exact_rational.as_ref()?;
+    if exponent.is_zero() || base.cmp_one == Some(Ordering::Equal) {
+        Some(Ordering::Equal)
+    } else if exponent.is_positive() {
+        base.cmp_one
     } else {
-        // Stirling's approximation: Γ(n+1) ≈ √(2πn) · (n/e)^n
-        (2.0 * std::f64::consts::PI * n).sqrt() * (n / std::f64::consts::E).powf(n)
+        base.cmp_one.map(Ordering::reverse)
     }
 }
 
-// --- Runtime expression parser ---
-
-/// Parse an expression string into an `Expr`.
-///
-/// Uses the same grammar as the proc macro parser. Variable names are leaked
-/// to `&'static str` for compatibility with `Expr::Var`.
-fn parse_to_expr(input: &str) -> Result<Expr, String> {
-    let tokens = tokenize_expr(input)?;
-    let mut parser = ExprParser::new(tokens);
-    let expr = parser.parse_additive()?;
-    if parser.pos != parser.tokens.len() {
-        return Err(format!("trailing tokens at position {}", parser.pos));
-    }
-    Ok(expr)
+/// Evaluate an expression numerically at an explicitly approximate boundary.
+pub fn evaluate_approximate(
+    expression: &Expr,
+    variables: &ProblemParameters,
+) -> Result<f64, ApproximationError> {
+    evaluate_approximate_inner(expression, variables, &mut HashMap::new())
 }
 
-#[derive(Debug, Clone, PartialEq)]
-enum ExprToken {
-    Number(f64),
-    Ident(String),
-    Plus,
-    Minus,
-    Star,
-    Slash,
-    Caret,
-    LParen,
-    RParen,
-}
-
-fn tokenize_expr(input: &str) -> Result<Vec<ExprToken>, String> {
-    let mut tokens = Vec::new();
-    let mut chars = input.chars().peekable();
-    while let Some(&ch) = chars.peek() {
-        match ch {
-            ' ' | '\t' | '\n' => {
-                chars.next();
-            }
-            '+' => {
-                chars.next();
-                tokens.push(ExprToken::Plus);
-            }
-            '-' => {
-                chars.next();
-                tokens.push(ExprToken::Minus);
-            }
-            '*' => {
-                chars.next();
-                tokens.push(ExprToken::Star);
-            }
-            '/' => {
-                chars.next();
-                tokens.push(ExprToken::Slash);
-            }
-            '^' => {
-                chars.next();
-                tokens.push(ExprToken::Caret);
-            }
-            '(' => {
-                chars.next();
-                tokens.push(ExprToken::LParen);
-            }
-            ')' => {
-                chars.next();
-                tokens.push(ExprToken::RParen);
-            }
-            c if c.is_ascii_digit() || c == '.' => {
-                let mut num = String::new();
-                while let Some(&c) = chars.peek() {
-                    if c.is_ascii_digit() || c == '.' {
-                        num.push(c);
-                        chars.next();
-                    } else {
-                        break;
-                    }
-                }
-                tokens.push(ExprToken::Number(
-                    num.parse().map_err(|_| format!("invalid number: {num}"))?,
-                ));
-            }
-            c if c.is_ascii_alphabetic() || c == '_' => {
-                let mut ident = String::new();
-                while let Some(&c) = chars.peek() {
-                    if c.is_ascii_alphanumeric() || c == '_' {
-                        ident.push(c);
-                        chars.next();
-                    } else {
-                        break;
-                    }
-                }
-                tokens.push(ExprToken::Ident(ident));
-            }
-            _ => return Err(format!("unexpected character: '{ch}'")),
+fn evaluate_approximate_inner(
+    expression: &Expr,
+    variables: &ProblemParameters,
+    memo: &mut HashMap<ExprNodeId, f64>,
+) -> Result<f64, ApproximationError> {
+    if let Some(value) = memo.get(&expression.node_identity()) {
+        return Ok(*value);
+    }
+    let value = match expression.node() {
+        ExprNode::Const(value) => rational_to_f64(value),
+        ExprNode::Var(name) => variables
+            .get(name.as_str())
+            .map(|value| value as f64)
+            .ok_or_else(|| ApproximationError::MissingVariable(name.to_string())),
+        ExprNode::Add(values) => values.iter().try_fold(0.0, |sum, value| {
+            Ok(sum + evaluate_approximate_inner(value, variables, memo)?)
+        }),
+        ExprNode::Mul(values) => values.iter().try_fold(1.0, |product, value| {
+            Ok(product * evaluate_approximate_inner(value, variables, memo)?)
+        }),
+        ExprNode::Pow(base, exponent) => Ok(evaluate_approximate_inner(base, variables, memo)?
+            .powf(evaluate_approximate_inner(exponent, variables, memo)?)),
+        ExprNode::Exp(value) => Ok(evaluate_approximate_inner(value, variables, memo)?.exp()),
+        ExprNode::Log(value) => Ok(evaluate_approximate_inner(value, variables, memo)?.ln()),
+        ExprNode::Factorial(value) => {
+            approximate_factorial(evaluate_approximate_inner(value, variables, memo)?)
         }
+    }?;
+    if !value.is_finite() {
+        return Err(ApproximationError::NonFiniteResult(expression.to_string()));
     }
-    Ok(tokens)
+    memo.insert(expression.node_identity(), value);
+    Ok(value)
 }
 
-struct ExprParser {
-    tokens: Vec<ExprToken>,
-    pos: usize,
+/// Convert an approximation produced by the growth domain back to an exact AST constant.
+#[cfg(test)]
+pub(crate) fn expression_from_approximation(value: f64) -> Expr {
+    Expr::constant(
+        BigRational::from_f64(value)
+            .expect("growth-domain expression constants must be finite numbers"),
+    )
 }
 
-impl ExprParser {
-    fn new(tokens: Vec<ExprToken>) -> Self {
-        Self { tokens, pos: 0 }
-    }
-
-    fn peek(&self) -> Option<&ExprToken> {
-        self.tokens.get(self.pos)
-    }
+pub(crate) fn rational_to_f64(value: &BigRational) -> Result<f64, ApproximationError> {
+    value
+        .to_f64()
+        .filter(|value| value.is_finite())
+        .ok_or_else(|| ApproximationError::OutOfRange(value.to_string()))
+}
 
-    fn advance(&mut self) -> Option<ExprToken> {
-        let tok = self.tokens.get(self.pos).cloned();
-        self.pos += 1;
-        tok
+pub(crate) fn approximate_factorial(value: f64) -> Result<f64, ApproximationError> {
+    if !value.is_finite() || value < 0.0 || value.fract() != 0.0 {
+        return Err(ApproximationError::InvalidFactorialArgument(
+            value.to_string(),
+        ));
     }
-
-    fn expect(&mut self, expected: &ExprToken) -> Result<(), String> {
-        match self.advance() {
-            Some(ref tok) if tok == expected => Ok(()),
-            Some(tok) => Err(format!("expected {expected:?}, got {tok:?}")),
-            None => Err(format!("expected {expected:?}, got end of input")),
-        }
-    }
-
-    fn parse_additive(&mut self) -> Result<Expr, String> {
-        let mut left = self.parse_multiplicative()?;
-        while matches!(self.peek(), Some(ExprToken::Plus) | Some(ExprToken::Minus)) {
-            let op = self.advance().unwrap();
-            let right = self.parse_multiplicative()?;
-            left = match op {
-                ExprToken::Plus => left + right,
-                ExprToken::Minus => left - right,
-                _ => unreachable!(),
-            };
-        }
-        Ok(left)
-    }
-
-    fn parse_multiplicative(&mut self) -> Result<Expr, String> {
-        let mut left = self.parse_unary()?;
-        while matches!(self.peek(), Some(ExprToken::Star) | Some(ExprToken::Slash)) {
-            let op = self.advance().unwrap();
-            let right = self.parse_unary()?;
-            left = match op {
-                ExprToken::Star => left * right,
-                ExprToken::Slash => left / right,
-                _ => unreachable!(),
-            };
-        }
-        Ok(left)
+    if value > 170.0 {
+        Err(ApproximationError::NonFiniteResult(format!(
+            "factorial({value})"
+        )))
+    } else {
+        Ok((2..=value as u64).fold(1.0, |product, factor| product * factor as f64))
     }
+}
 
-    fn parse_power(&mut self) -> Result<Expr, String> {
-        let base = self.parse_primary()?;
-        if matches!(self.peek(), Some(ExprToken::Caret)) {
-            self.advance();
-            let exp = self.parse_unary()?; // right-associative, allows unary minus in exponent
-            Ok(Expr::pow(base, exp))
-        } else {
-            Ok(base)
-        }
-    }
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+pub enum ApproximationError {
+    #[error("missing expression variable {0}")]
+    MissingVariable(String),
+    #[error("exact constant {0} is outside the f64 approximation domain")]
+    OutOfRange(String),
+    #[error("factorial argument must be a non-negative integer, found {0}")]
+    InvalidFactorialArgument(String),
+    #[error("expression {0} has no finite real approximation")]
+    NonFiniteResult(String),
+}
 
-    fn parse_unary(&mut self) -> Result<Expr, String> {
-        if matches!(self.peek(), Some(ExprToken::Minus)) {
-            self.advance();
-            let expr = self.parse_unary()?;
-            Ok(-expr)
-        } else {
-            self.parse_power()
-        }
-    }
+/// Error returned when analyzing asymptotic behavior.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum AsymptoticAnalysisError {
+    Unsupported(String),
+}
 
-    fn parse_primary(&mut self) -> Result<Expr, String> {
-        match self.advance() {
-            Some(ExprToken::Number(n)) => Ok(Expr::Const(n)),
-            Some(ExprToken::Ident(name)) => {
-                if matches!(self.peek(), Some(ExprToken::LParen)) {
-                    self.advance();
-                    let arg = self.parse_additive()?;
-                    self.expect(&ExprToken::RParen)?;
-                    match name.as_str() {
-                        "exp" => Ok(Expr::Exp(Box::new(arg))),
-                        "log" => Ok(Expr::Log(Box::new(arg))),
-                        "sqrt" => Ok(Expr::Sqrt(Box::new(arg))),
-                        "factorial" => Ok(Expr::Factorial(Box::new(arg))),
-                        _ => Err(format!("unknown function: {name}")),
-                    }
-                } else {
-                    // Leak the string to get &'static str for Expr::Var
-                    let leaked: &'static str = Box::leak(name.into_boxed_str());
-                    Ok(Expr::Var(leaked))
-                }
-            }
-            Some(ExprToken::LParen) => {
-                let expr = self.parse_additive()?;
-                self.expect(&ExprToken::RParen)?;
-                Ok(expr)
+impl fmt::Display for AsymptoticAnalysisError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Unsupported(expression) => {
+                write!(formatter, "unsupported asymptotic expression: {expression}")
             }
-            Some(tok) => Err(format!("unexpected token: {tok:?}")),
-            None => Err("unexpected end of input".to_string()),
         }
     }
 }
 
+impl std::error::Error for AsymptoticAnalysisError {}
+
 #[cfg(test)]
 #[path = "unit_tests/expr.rs"]
 mod tests;
diff --git a/src/growth.rs b/src/growth.rs
new file mode 100644
index 000000000..1a2e05d30
--- /dev/null
+++ b/src/growth.rs
@@ -0,0 +1,898 @@
+//! Symbolic growth domain: a dedicated asymptotic normal form for reduction
+//! parameter expressions.
+//!
+//! Where full monomial canonicalization answers Big-O questions by expanding an
+//! [`Expr`] to monomial normal form, with exponential cost in nesting depth, the
+//! growth domain computes a Big-O normal form bottom-up without rewriting
+//! the source AST into a fully distributed polynomial. Work is output-sensitive:
+//! antichains are retained up to 32 terms; larger fronts are reported as
+//! unsupported instead of silently approximated.
+//!
+//! # Representation
+//!
+//! One internal growth term is a monomial
+//!
+//! ```text
+//! ∏_v ∏_f base[f]^(coefficient[f] · v)
+//!     · ∏_v v^(poly[v]) · ∏_v (log v)^(logs[v])
+//! ```
+//!
+//! and a [`Growth`] is either a known antichain of pairwise-incomparable dominant
+//! terms (each summand of an asymptotic sum), or an unknown result with explicit
+//! reasons for content we cannot represent symbolically.
+//!
+//! # Semantic foundation (the trust contract)
+//!
+//! Every expression admitted to the domain is assumed **nonnegative** and
+//! **weakly monotone** (nondecreasing in each variable) on `vars ≥ 2`. Under
+//! these axioms Howell's multivariate-O inconsistencies vanish and
+//! `f + g ≍ max(f, g)` up to a constant factor, which licenses
+//! `add = antichain union + prune`. All bounds produced are **upper** bounds.
+//!
+//! Widening (always toward a valid upper bound):
+//! - Subtraction is normalized to addition of a negative term, and
+//!   [`Growth::from_expr`] widens it to the union of both operands.
+//!   This also covers the
+//!   `sqrt((a − b)^2)` absolute-value idiom (`|a − b| ≤ a + b`).
+//! - Constants and constant multipliers/divisors are dropped on entry.
+//! - Exponentials with a **linear** exponent (`c^x`, `c^(r·x)`, `exp(x)`) are
+//!   first-class via symbolic base/coefficient factors. The original base is
+//!   authoritative: it is never normalized through a floating-point logarithm
+//!   and never reconstructed by rounding. Nonlinear exponents (`2^(n·k)`,
+//!   `2^sqrt(n)`), `factorial(·)`, and negative polynomial exponents widen to
+//!   an unknown result, which preserves its reasons through every operation.
+//! - The explicit approximation boundary treats [`Expr::log`] as the natural
+//!   logarithm, but all fixed
+//!   logarithm bases greater than one have the same asymptotic class and are
+//!   intentionally represented by the single `log(v)` factor.
+//!
+//! # `Pow` note
+//!
+//! `Pow(base, k)` for a nonnegative constant `k` raises **each** antichain term
+//! of `base` to the power `k` (scaling its exponents). This is the tight
+//! asymptotic answer — `(n + m)^2 ≍ max(n, m)^2 = max(n^2, m^2)` by AM-GM, so no
+//! binomial cross term is introduced — and it is what makes the widening chain
+//! `sqrt((n − m)^2) ≍ n + m` hold exactly.
+
+use crate::expr::{AlgebraicAnalysis, BigInt, Expr, ExprNode, ExprNodeId};
+use num_rational::BigRational;
+use num_traits::{One, Signed, ToPrimitive, Zero};
+use std::cmp::Ordering;
+use std::collections::{BTreeMap, HashMap};
+
+/// Maximum number of incomparable terms retained in one Big-O normal form.
+const ANTICHAIN_CAP: usize = 32;
+
+/// An exact fixed exponential base.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+enum ExpBase {
+    /// A positive rational constant used as the base of `Pow`.
+    Rational(BigRational),
+    /// The distinguished base of the `exp(...)` AST constructor.
+    Natural,
+}
+
+impl ExpBase {
+    fn directly_comparable_value(&self) -> Option<&BigRational> {
+        match self {
+            ExpBase::Rational(base) => Some(base),
+            ExpBase::Natural => None,
+        }
+    }
+
+    fn direction(&self) -> Ordering {
+        match self {
+            ExpBase::Rational(base) => base.cmp(&BigRational::one()),
+            ExpBase::Natural => Ordering::Greater,
+        }
+    }
+
+    fn coefficient_cmp(&self, a: &BigRational, b: &BigRational) -> Ordering {
+        if self.direction() == Ordering::Greater {
+            a.cmp(b)
+        } else {
+            a.cmp(b).reverse()
+        }
+    }
+}
+
+/// Exponential, polynomial, and logarithmic growth associated with one size
+/// variable. Missing components have exponent zero.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+struct VariableGrowth {
+    exp: BTreeMap<ExpBase, BigRational>,
+    poly: BigRational,
+    log: u32,
+}
+
+impl VariableGrowth {
+    fn empty() -> Self {
+        Self {
+            exp: BTreeMap::new(),
+            poly: BigRational::zero(),
+            log: 0,
+        }
+    }
+
+    fn exponential(base: ExpBase, coefficient: BigRational) -> Self {
+        Self {
+            exp: BTreeMap::from([(base, coefficient)]),
+            poly: BigRational::zero(),
+            log: 0,
+        }
+    }
+
+    fn polynomial(degree: BigRational) -> Self {
+        Self {
+            exp: BTreeMap::new(),
+            poly: degree,
+            log: 0,
+        }
+    }
+
+    fn logarithmic(power: u32) -> Self {
+        Self {
+            exp: BTreeMap::new(),
+            poly: BigRational::zero(),
+            log: power,
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.exp.is_empty() && self.poly.is_zero() && self.log == 0
+    }
+
+    fn mul(&self, other: &Self) -> Result<Self, GrowthFailure> {
+        let mut result = self.clone();
+        for (base, coefficient) in &other.exp {
+            *result
+                .exp
+                .entry(base.clone())
+                .or_insert_with(BigRational::zero) += coefficient;
+        }
+        result.exp.retain(|_, coefficient| !coefficient.is_zero());
+        result.poly += &other.poly;
+        result.log = result.log.checked_add(other.log).ok_or_else(|| {
+            GrowthFailure::RepresentedExponentOutOfRange(format!("{} + {}", self.log, other.log))
+        })?;
+        Ok(result)
+    }
+
+    fn pow(&self, power: &BigRational) -> Result<Self, GrowthFailure> {
+        let exp = self
+            .exp
+            .iter()
+            .filter_map(|(base, coefficient)| {
+                let coefficient = coefficient * power;
+                (!coefficient.is_zero()).then(|| (base.clone(), coefficient))
+            })
+            .collect();
+        let poly = &self.poly * power;
+        let scaled_log = BigRational::from_integer(BigInt::from(self.log)) * power;
+        let rounded =
+            (scaled_log.numer() + scaled_log.denom() - BigInt::one()) / scaled_log.denom();
+        let Some(log) = rounded.to_u32() else {
+            return Err(GrowthFailure::RepresentedExponentOutOfRange(
+                scaled_log.to_string(),
+            ));
+        };
+        Ok(Self { exp, poly, log })
+    }
+
+    fn cmp_exp(&self, other: &Self) -> Option<Ordering> {
+        let mut left_count = 0;
+        let mut right_count = 0;
+        let mut left_single: Option<(&ExpBase, BigRational)> = None;
+        let mut right_single: Option<(&ExpBase, BigRational)> = None;
+
+        for (base, a) in &self.exp {
+            if let Some(b) = other.exp.get(base) {
+                match base.coefficient_cmp(a, b) {
+                    Ordering::Equal => {}
+                    Ordering::Greater => {
+                        left_count += 1;
+                        left_single = Some((base, a - b));
+                    }
+                    Ordering::Less => {
+                        right_count += 1;
+                        right_single = Some((base, b - a));
+                    }
+                }
+            } else {
+                left_count += 1;
+                left_single = Some((base, a.clone()));
+            }
+        }
+
+        for (base, coefficient) in &other.exp {
+            if !self.exp.contains_key(base) {
+                right_count += 1;
+                right_single = Some((base, coefficient.clone()));
+            }
+        }
+
+        match (left_count, right_count) {
+            (0, 0) => Some(Ordering::Equal),
+            (0, _) => Some(Ordering::Less),
+            (_, 0) => Some(Ordering::Greater),
+            (1, 1) => {
+                let (a_base, a_coefficient) = left_single?;
+                let (b_base, b_coefficient) = right_single?;
+                Self::cmp_single_factor(a_base, &a_coefficient, b_base, &b_coefficient)
+            }
+            _ => None,
+        }
+    }
+
+    fn cmp_growth(&self, other: &Self) -> Option<Ordering> {
+        let exponential = self.cmp_exp(other)?;
+        Some(if exponential == Ordering::Equal {
+            self.poly.cmp(&other.poly).then(self.log.cmp(&other.log))
+        } else {
+            exponential
+        })
+    }
+
+    fn cmp_single_factor(
+        a_base: &ExpBase,
+        a_coefficient: &BigRational,
+        b_base: &ExpBase,
+        b_coefficient: &BigRational,
+    ) -> Option<Ordering> {
+        if a_base == b_base {
+            return Some(a_base.coefficient_cmp(a_coefficient, b_coefficient));
+        }
+
+        if a_coefficient == b_coefficient {
+            match (a_base, b_base) {
+                (ExpBase::Natural, ExpBase::Rational(_)) => {
+                    let base = b_base.directly_comparable_value()?;
+                    if base <= &BigRational::from_integer(2.into()) {
+                        return Some(Ordering::Greater);
+                    }
+                    if base >= &BigRational::from_integer(3.into()) {
+                        return Some(Ordering::Less);
+                    }
+                    return None;
+                }
+                (ExpBase::Rational(_), ExpBase::Natural) => {
+                    return Self::cmp_single_factor(b_base, b_coefficient, a_base, a_coefficient)
+                        .map(Ordering::reverse);
+                }
+                _ => {}
+            }
+        }
+
+        let (a_base, b_base) = (
+            a_base.directly_comparable_value()?,
+            b_base.directly_comparable_value()?,
+        );
+        if a_coefficient == b_coefficient {
+            let base_order = a_base.cmp(b_base);
+            return if a_coefficient.is_positive() {
+                Some(base_order)
+            } else {
+                Some(base_order.reverse())
+            };
+        }
+
+        if a_base > &BigRational::one() && b_base > &BigRational::one() {
+            match (a_base.cmp(b_base), a_coefficient.cmp(b_coefficient)) {
+                (Ordering::Greater | Ordering::Equal, Ordering::Greater | Ordering::Equal) => {
+                    Some(Ordering::Greater)
+                }
+                (Ordering::Less | Ordering::Equal, Ordering::Less | Ordering::Equal) => {
+                    Some(Ordering::Less)
+                }
+                _ => None,
+            }
+        } else if a_base < &BigRational::one() && b_base < &BigRational::one() {
+            match (a_base.cmp(b_base), a_coefficient.cmp(b_coefficient)) {
+                (Ordering::Less | Ordering::Equal, Ordering::Less | Ordering::Equal) => {
+                    Some(Ordering::Greater)
+                }
+                (Ordering::Greater | Ordering::Equal, Ordering::Greater | Ordering::Equal) => {
+                    Some(Ordering::Less)
+                }
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+}
+
+/// One growth monomial, e.g. `2^(3k) · n^2 · m · log(n)`.
+///
+/// Empty maps represent `O(1)`.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+struct GrowthTerm {
+    variables: BTreeMap<Box<str>, VariableGrowth>,
+}
+
+/// The asymptotic growth class of an [`Expr`].
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Growth(GrowthState);
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum GrowthState {
+    Known(Vec<GrowthTerm>),
+    /// Content outside the represented growth domain, with every reason that
+    /// contributed to the result.
+    Unknown(Vec<GrowthFailure>),
+}
+
+/// A precise reason why an expression has no represented [`Growth`] value.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, thiserror::Error)]
+pub enum GrowthFailure {
+    #[error("invalid or unproved constant domain for {expression}")]
+    InvalidConstantDomain { expression: String },
+    #[error("negative exponent is unsupported: {0}")]
+    NegativeExponent(String),
+    #[error("nonlinear exponent is unsupported: {0}")]
+    NonlinearExponent(String),
+    #[error("variable base and exponent are unsupported: {0}")]
+    VariableBaseAndExponent(String),
+    #[error("factorial of a nonconstant expression is unsupported: {0}")]
+    FactorialOfNonconstant(String),
+    #[error("invalid exponential base: {0}")]
+    InvalidExponentialBase(String),
+    #[error("represented exponent is outside the growth domain: {0}")]
+    RepresentedExponentOutOfRange(String),
+    #[error(
+        "exponential factor {base}^({coefficient} * {variable}) decreases as {variable} grows"
+    )]
+    DecayingExponential {
+        base: String,
+        variable: String,
+        coefficient: String,
+    },
+    #[error("missing substitution for {0}")]
+    MissingSubstitution(String),
+    #[error("Big-O antichain has {terms} terms, exceeding the limit of {limit}")]
+    AntichainLimitExceeded { limit: usize, terms: usize },
+}
+
+impl GrowthTerm {
+    /// The `O(1)` term (all maps empty).
+    fn one() -> Self {
+        GrowthTerm {
+            variables: BTreeMap::new(),
+        }
+    }
+
+    fn insert(&mut self, variable: Box<str>, growth: VariableGrowth) {
+        if !growth.is_empty() {
+            self.variables.insert(variable, growth);
+        }
+    }
+
+    /// Raise this term to a nonnegative real power `k` (scale every exponent).
+    /// Log powers are `u32`; a fractional result is rounded **up** (a valid
+    /// upper bound, since `(log v)^p ≤ (log v)^⌈p⌉` for `v ≥ 2`).
+    fn pow(&self, k: &BigRational) -> Result<GrowthTerm, GrowthFailure> {
+        let mut r = GrowthTerm::one();
+        for (variable, growth) in &self.variables {
+            r.insert(variable.clone(), growth.pow(k)?);
+        }
+        Ok(r)
+    }
+
+    /// Multiply two monomials (add matching exponents).
+    fn mul(&self, other: &GrowthTerm) -> Result<GrowthTerm, GrowthFailure> {
+        let mut t = self.clone();
+        for (variable, growth) in &other.variables {
+            let combined = match t.variables.get(variable) {
+                Some(current) => current.mul(growth)?,
+                None => growth.clone(),
+            };
+            if combined.is_empty() {
+                t.variables.remove(variable);
+            } else {
+                t.variables.insert(variable.clone(), combined);
+            }
+        }
+        Ok(t)
+    }
+
+    /// Partial order on terms: `Some(Greater)` iff `self` dominates `other`
+    /// (`≥` on every variable and `>` on at least one). Per variable,
+    /// exponential products are compared only when a symbolic proof succeeds;
+    /// polynomial degree and log power then break proven exponential ties.
+    /// Returns `None` for incomparable or unproved terms.
+    fn cmp(&self, other: &GrowthTerm) -> Option<Ordering> {
+        let mut saw_gt = false;
+        let mut saw_lt = false;
+        let empty = VariableGrowth::empty();
+        let mut left = self.variables.iter().peekable();
+        let mut right = other.variables.iter().peekable();
+        loop {
+            let (a, b) = match (left.peek(), right.peek()) {
+                (None, None) => break,
+                (Some((left_variable, _)), Some((right_variable, _))) => {
+                    match left_variable.cmp(right_variable) {
+                        Ordering::Less => (left.next().unwrap().1, &empty),
+                        Ordering::Greater => (&empty, right.next().unwrap().1),
+                        Ordering::Equal => (left.next().unwrap().1, right.next().unwrap().1),
+                    }
+                }
+                (Some(_), None) => (left.next().unwrap().1, &empty),
+                (None, Some(_)) => (&empty, right.next().unwrap().1),
+            };
+            let order = a.cmp_growth(b)?;
+            match order {
+                Ordering::Greater => saw_gt = true,
+                Ordering::Less => saw_lt = true,
+                Ordering::Equal => {}
+            }
+        }
+        match (saw_gt, saw_lt) {
+            (true, true) => None,
+            (true, false) => Some(Ordering::Greater),
+            (false, true) => Some(Ordering::Less),
+            (false, false) => Some(Ordering::Equal),
+        }
+    }
+
+    /// `true` iff `self` dominates `other` (grows at least as fast, and strictly
+    /// faster on at least one variable).
+    fn dominates(&self, other: &GrowthTerm) -> bool {
+        matches!(self.cmp(other), Some(Ordering::Greater))
+    }
+
+    /// `true` iff `self` dominates `other` or is asymptotically equal to it.
+    fn dominates_or_eq(&self, other: &GrowthTerm) -> bool {
+        matches!(
+            self.cmp(other),
+            Some(Ordering::Greater) | Some(Ordering::Equal)
+        )
+    }
+}
+
+impl Growth {
+    pub(crate) fn unknown(failure: GrowthFailure) -> Self {
+        Self(GrowthState::Unknown(vec![failure]))
+    }
+
+    pub fn failures(&self) -> Option<&[GrowthFailure]> {
+        match &self.0 {
+            GrowthState::Known(_) => None,
+            GrowthState::Unknown(failures) => Some(failures),
+        }
+    }
+
+    /// Compute the growth class of an expression in a single bottom-up pass.
+    pub fn from_expr(expr: &Expr) -> Growth {
+        let analysis = AlgebraicAnalysis::new(&[expr]);
+        Self::from_analysis(expr, &analysis)
+    }
+
+    pub(crate) fn from_analysis(expr: &Expr, analysis: &AlgebraicAnalysis) -> Growth {
+        growth_from_analysis(expr, analysis, &mut HashMap::new())
+    }
+
+    /// Partial order on represented Big-O normal forms.
+    ///
+    /// Unknown values are incomparable. For two known term antichains, `self`
+    /// dominates `other` iff every term of `other` is dominated-or-equal by
+    /// some term of `self` — the standard antichain (Pareto) comparison.
+    pub fn dominates(&self, other: &Growth) -> bool {
+        match (&self.0, &other.0) {
+            (GrowthState::Known(a), GrowthState::Known(b)) => {
+                b.iter().all(|tb| a.iter().any(|ta| ta.dominates_or_eq(tb)))
+            }
+            _ => false,
+        }
+    }
+
+    /// Render this growth class back to a display [`Expr`] (a sum of monomials),
+    /// or `None` for unknown growth. Terms are already in the deterministic
+    /// sort order, so the rendered expression is platform-stable.
+    ///
+    /// Exponential factors are rendered directly from their authoritative
+    /// symbolic bases and coefficients; no base reconstruction is performed.
+    pub fn to_expr(&self) -> Option<Expr> {
+        match &self.0 {
+            GrowthState::Unknown(_) => None,
+            GrowthState::Known(terms) => {
+                if terms.is_empty() {
+                    return Some(Expr::integer(1));
+                }
+                let mut it = terms.iter().map(term_to_expr);
+                let mut acc = it.next().unwrap();
+                for e in it {
+                    acc = acc + e;
+                }
+                Some(acc)
+            }
+        }
+    }
+
+    /// Canonical Big-O string for this growth class: `O(<expr>)` for a bounded
+    /// class, or `O(?)` for unknown growth (no honest asymptotic bound —
+    /// nonlinear exponent or factorial). This is the single source of truth for
+    /// how a growth is displayed as Big-O; presentation layers must call it rather
+    /// than re-deriving the mapping (and the `Unknown` spelling) themselves.
+    pub fn to_big_o(&self) -> String {
+        match self.to_expr() {
+            Some(e) => format!("O({e})"),
+            None => "O(?)".to_string(),
+        }
+    }
+}
+
+fn growth_from_analysis(
+    expression: &Expr,
+    analysis: &AlgebraicAnalysis,
+    memo: &mut HashMap<ExprNodeId, Growth>,
+) -> Growth {
+    if let Some(growth) = memo.get(&expression.node_identity()) {
+        return growth.clone();
+    }
+
+    let facts = analysis.facts(expression);
+    if facts.is_constant {
+        let growth = if facts.constant_domain == Some(true) {
+            constant_growth()
+        } else {
+            unknown(GrowthFailure::InvalidConstantDomain {
+                expression: expression.to_string(),
+            })
+        };
+        memo.insert(expression.node_identity(), growth.clone());
+        return growth;
+    }
+
+    let growth = match expression.node() {
+        ExprNode::Const(_) => unreachable!("constants are handled before node projection"),
+        ExprNode::Var(variable) => {
+            let mut term = GrowthTerm::one();
+            term.insert(
+                variable.as_str().into(),
+                VariableGrowth::polynomial(BigRational::one()),
+            );
+            exact_growth(vec![term])
+        }
+        ExprNode::Add(values) => values
+            .iter()
+            .map(|value| growth_from_analysis(value, analysis, memo))
+            .reduce(add)
+            .expect("normalized sum has at least two terms"),
+        ExprNode::Mul(values) => values
+            .iter()
+            .map(|value| growth_from_analysis(value, analysis, memo))
+            .reduce(mul)
+            .expect("normalized product has at least two factors"),
+        ExprNode::Pow(base, exponent) => {
+            let base_facts = analysis.facts(base);
+            let exponent_facts = analysis.facts(exponent);
+            if base_facts.is_constant && base_facts.constant_domain != Some(true) {
+                unknown(GrowthFailure::InvalidConstantDomain {
+                    expression: base.to_string(),
+                })
+            } else if exponent_facts.is_constant && exponent_facts.constant_domain != Some(true) {
+                unknown(GrowthFailure::InvalidConstantDomain {
+                    expression: exponent.to_string(),
+                })
+            } else if let Some(power) = exponent_facts.exact_rational.as_ref() {
+                if power.is_negative() {
+                    unknown(GrowthFailure::NegativeExponent(exponent.to_string()))
+                } else {
+                    pow_const(growth_from_analysis(base, analysis, memo), power)
+                }
+            } else if let ExprNode::Exp(argument) = base.node() {
+                match analysis.facts(argument).exact_rational.as_ref() {
+                    Some(coefficient) => exponential(
+                        ExpBase::Natural,
+                        scale_growth_linear(exponent_facts.linear.clone(), coefficient),
+                        exponent,
+                    ),
+                    None => unknown(GrowthFailure::InvalidExponentialBase(base.to_string())),
+                }
+            } else if let Some(base_value) = base_facts.exact_rational.as_ref() {
+                if base_value.is_positive() {
+                    exponential(
+                        ExpBase::Rational(base_value.clone()),
+                        growth_linear(exponent_facts.linear.clone()),
+                        exponent,
+                    )
+                } else {
+                    unknown(GrowthFailure::InvalidExponentialBase(base.to_string()))
+                }
+            } else if base_facts.is_constant {
+                unknown(GrowthFailure::InvalidExponentialBase(base.to_string()))
+            } else {
+                unknown(GrowthFailure::VariableBaseAndExponent(
+                    expression.to_string(),
+                ))
+            }
+        }
+        ExprNode::Exp(value) => {
+            let value_growth = growth_from_analysis(value, analysis, memo);
+            if value_growth.failures().is_some() {
+                value_growth
+            } else {
+                exponential(
+                    ExpBase::Natural,
+                    growth_linear(analysis.facts(value).linear.clone()),
+                    expression,
+                )
+            }
+        }
+        ExprNode::Log(value) => log_growth(growth_from_analysis(value, analysis, memo)),
+        ExprNode::Factorial(_) => unknown(GrowthFailure::FactorialOfNonconstant(
+            expression.to_string(),
+        )),
+    };
+    memo.insert(expression.node_identity(), growth.clone());
+    growth
+}
+
+fn growth_linear(
+    linear: Option<BTreeMap<crate::expr::Symbol, BigRational>>,
+) -> Option<BTreeMap<Box<str>, BigRational>> {
+    Some(
+        linear?
+            .into_iter()
+            .map(|(symbol, coefficient)| (symbol.as_str().into(), coefficient))
+            .collect(),
+    )
+}
+
+fn scale_growth_linear(
+    linear: Option<BTreeMap<crate::expr::Symbol, BigRational>>,
+    coefficient: &BigRational,
+) -> Option<BTreeMap<Box<str>, BigRational>> {
+    Some(
+        linear?
+            .into_iter()
+            .map(|(symbol, value)| (symbol.as_str().into(), coefficient * value))
+            .collect(),
+    )
+}
+fn constant_growth() -> Growth {
+    exact_growth(vec![GrowthTerm::one()])
+}
+
+fn unknown(failure: GrowthFailure) -> Growth {
+    Growth::unknown(failure)
+}
+
+fn merge_unknown(left: Growth, right: Growth) -> Growth {
+    let mut failures = Vec::new();
+    if let GrowthState::Unknown(left) = left.0 {
+        failures.extend(left);
+    }
+    if let GrowthState::Unknown(right) = right.0 {
+        failures.extend(right);
+    }
+    failures.sort();
+    failures.dedup();
+    Growth(GrowthState::Unknown(failures))
+}
+
+/// Render one monomial as a product of its factors (or `Const(1)` when empty).
+fn term_to_expr(t: &GrowthTerm) -> Expr {
+    let mut factors: Vec<Expr> = Vec::new();
+    for (variable, growth) in &t.variables {
+        factors.extend(
+            growth
+                .exp
+                .iter()
+                .map(|(base, coefficient)| exp_factor(variable, base, coefficient)),
+        );
+        if !growth.poly.is_zero() {
+            factors.push(poly_factor(variable, &growth.poly));
+        }
+        if growth.log != 0 {
+            factors.push(log_factor(variable, growth.log));
+        }
+    }
+    let mut it = factors.into_iter();
+    match it.next() {
+        None => Expr::integer(1),
+        Some(first) => it.fold(first, |acc, f| acc * f),
+    }
+}
+
+/// Render a stored exponential factor without changing its base or coefficient.
+fn exp_factor(v: &str, base: &ExpBase, coefficient: &BigRational) -> Expr {
+    let exponent = if coefficient.is_one() {
+        Expr::variable(v)
+    } else {
+        Expr::constant(coefficient.clone()) * Expr::variable(v)
+    };
+    match base {
+        ExpBase::Rational(base) => Expr::pow(Expr::constant(base.clone()), exponent),
+        ExpBase::Natural => Expr::exp(exponent),
+    }
+}
+
+/// Render `v^degree` (`Display` turns degree `0.5` into `sqrt(v)`).
+fn poly_factor(v: &str, degree: &BigRational) -> Expr {
+    if degree.is_one() {
+        Expr::variable(v)
+    } else {
+        Expr::pow(Expr::variable(v), Expr::constant(degree.clone()))
+    }
+}
+
+/// Render `(log v)^power`.
+fn log_factor(v: &str, power: u32) -> Expr {
+    let log = Expr::log(Expr::variable(v));
+    if power == 1 {
+        log
+    } else {
+        Expr::pow(log, Expr::integer(power))
+    }
+}
+
+/// Prune a bag of terms to its maximal antichain: drop any term dominated by
+/// another and collapse exact duplicates. The resulting *set* is independent of
+/// input order.
+fn prune(mut terms: Vec<GrowthTerm>) -> Vec<GrowthTerm> {
+    // Proven-equal terms can retain different symbolic spellings (for example,
+    // `exp(n)` and a literal-e base). Sort first so the representative does not
+    // depend on operand order.
+    terms.sort();
+    let mut result: Vec<GrowthTerm> = Vec::new();
+    for t in terms {
+        if result.iter().any(|r| r.dominates_or_eq(&t)) {
+            continue;
+        }
+        result.retain(|r| !t.dominates(r));
+        result.push(t);
+    }
+    result
+}
+
+fn exact_growth(terms: Vec<GrowthTerm>) -> Growth {
+    finish_growth(terms)
+}
+
+fn finish_growth(terms: Vec<GrowthTerm>) -> Growth {
+    let terms = prune(terms);
+    if terms.len() > ANTICHAIN_CAP {
+        return unknown(GrowthFailure::AntichainLimitExceeded {
+            limit: ANTICHAIN_CAP,
+            terms: terms.len(),
+        });
+    }
+    Growth(GrowthState::Known(terms))
+}
+
+/// Antichain union (asymptotic `+ ≍ max`).
+fn add(a: Growth, b: Growth) -> Growth {
+    if a.failures().is_some() || b.failures().is_some() {
+        return merge_unknown(a, b);
+    }
+    let mut terms = into_terms(a);
+    terms.extend(into_terms(b));
+    finish_growth(terms)
+}
+
+/// Pairwise product of two antichains.
+fn mul(a: Growth, b: Growth) -> Growth {
+    if a.failures().is_some() || b.failures().is_some() {
+        return merge_unknown(a, b);
+    }
+    let x = into_terms(a);
+    let y = into_terms(b);
+    let mut product = Vec::with_capacity(x.len() * y.len());
+    for tx in &x {
+        for ty in &y {
+            match tx.mul(ty) {
+                Ok(term) => product.push(term),
+                Err(failure) => return unknown(failure),
+            }
+        }
+    }
+    finish_growth(product)
+}
+
+/// Raise a whole antichain to a nonnegative real power `k` (raise each term).
+fn pow_const(g: Growth, k: &BigRational) -> Growth {
+    match g.0 {
+        GrowthState::Unknown(failures) => Growth(GrowthState::Unknown(failures)),
+        GrowthState::Known(terms) => match terms.iter().map(|term| term.pow(k)).collect() {
+            Ok(terms) => finish_growth(terms),
+            Err(failure) => unknown(failure),
+        },
+    }
+}
+
+fn into_terms(growth: Growth) -> Vec<GrowthTerm> {
+    match growth.0 {
+        GrowthState::Known(terms) => terms,
+        GrowthState::Unknown(_) => unreachable!("unknown growth is handled before term access"),
+    }
+}
+
+/// Transfer function for a symbolic fixed-base exponential.
+fn exponential(
+    base: ExpBase,
+    linear: Option<BTreeMap<Box<str>, BigRational>>,
+    exponent: &Expr,
+) -> Growth {
+    let direction = base.direction();
+    if direction == Ordering::Equal {
+        // 1^x = 1 for every x: bounded by O(1).
+        return exact_growth(vec![GrowthTerm::one()]);
+    }
+    match linear {
+        None => unknown(GrowthFailure::NonlinearExponent(exponent.to_string())),
+        Some(coeffs) => {
+            let mut term = GrowthTerm::one();
+            for (v, coeff) in coeffs {
+                if (direction == Ordering::Greater && coeff.is_positive())
+                    || (direction == Ordering::Less && coeff.is_negative())
+                {
+                    term.insert(v, VariableGrowth::exponential(base.clone(), coeff));
+                } else if !coeff.is_zero() {
+                    return unknown(GrowthFailure::DecayingExponential {
+                        base: match &base {
+                            ExpBase::Rational(value) => value.to_string(),
+                            ExpBase::Natural => "e".to_string(),
+                        },
+                        variable: v.to_string(),
+                        coefficient: coeff.to_string(),
+                    });
+                }
+            }
+            exact_growth(vec![term])
+        }
+    }
+}
+
+/// Transfer function for `Log(a)`: `log` of an antichain is `log` of its
+/// dominant term(s), unioned. Uses `log(n^a · m^b) ≍ log n + log m` and
+/// `log(2^(r·n)) ≍ n`.
+fn log_growth(g: Growth) -> Growth {
+    match g.0 {
+        GrowthState::Unknown(failures) => Growth(GrowthState::Unknown(failures)),
+        GrowthState::Known(terms) => {
+            let mut out = Vec::new();
+            for t in &terms {
+                out.extend(log_term(t));
+            }
+            if out.is_empty() {
+                out.push(GrowthTerm::one()); // log(O(1)) = O(1)
+            }
+            finish_growth(out)
+        }
+    }
+}
+
+/// `log` of a single monomial, returned as its own (small) antichain of
+/// summands. `log(∏ baseᵢ^(rᵢ·vᵢ) · ∏vⱼ^aⱼ · ∏(log vₖ)^sₖ)` distributes over the
+/// product into a *sum* of the log of each factor, so every factor class of the
+/// monomial contributes its own summand — none may be dropped (e.g. `log(2^n·m)`
+/// is `n + log m`, not `n`). `finish_growth`/`prune` then collapse any dominated
+/// summands (so `log(2^n·n^2)` reduces back to `n`).
+fn log_term(t: &GrowthTerm) -> Vec<GrowthTerm> {
+    let mut out = Vec::new();
+    for (variable, growth) in &t.variables {
+        if !growth.exp.is_empty() {
+            let mut term = GrowthTerm::one();
+            term.insert(
+                variable.clone(),
+                VariableGrowth::polynomial(BigRational::one()),
+            );
+            out.push(term);
+        }
+        if growth.poly.is_positive() || growth.log != 0 {
+            let mut term = GrowthTerm::one();
+            term.insert(variable.clone(), VariableGrowth::logarithmic(1));
+            out.push(term);
+        }
+    }
+    // Empty term: log(O(1)) = O(1).
+    if out.is_empty() {
+        out.push(GrowthTerm::one());
+    }
+    out
+}
+
+#[cfg(test)]
+#[path = "unit_tests/growth.rs"]
+mod tests;
diff --git a/src/io.rs b/src/io.rs
index 4814e5cd5..9e3eb8dc6 100644
--- a/src/io.rs
+++ b/src/io.rs
@@ -44,7 +44,7 @@ impl FileFormat {
 /// use problemreductions::models::graph::MaximumIndependentSet;
 /// use problemreductions::topology::SimpleGraph;
 ///
-/// let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+/// let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
 /// write_problem(&problem, "problem.json", FileFormat::Json).unwrap();
 /// ```
 pub fn write_problem<T: Serialize, P: AsRef<Path>>(
@@ -78,7 +78,7 @@ pub fn write_problem<T: Serialize, P: AsRef<Path>>(
 /// use problemreductions::models::graph::MaximumIndependentSet;
 /// use problemreductions::topology::SimpleGraph;
 ///
-/// let problem: MaximumIndependentSet<SimpleGraph, i32> = read_problem("problem.json", FileFormat::Json).unwrap();
+/// let problem: MaximumIndependentSet<SimpleGraph, i64> = read_problem("problem.json", FileFormat::Json).unwrap();
 /// ```
 pub fn read_problem<T: DeserializeOwned, P: AsRef<Path>>(path: P, format: FileFormat) -> Result<T> {
     let file = File::open(path.as_ref())
diff --git a/src/lib.rs b/src/lib.rs
index 2083070c1..69381f493 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,7 +12,7 @@
 //! | [`solvers`] | [`BruteForce`] and [`ILPSolver`](solvers::ILPSolver) |
 //! | [`topology`] | Graph types — [`SimpleGraph`](topology::SimpleGraph), [`UnitDiskGraph`](topology::UnitDiskGraph), etc. |
 //! | [`traits`] | Core traits — [`Problem`] |
-//! | [`types`] | [`Max`], [`Min`], [`Extremum`], [`ExtremumSense`], [`ProblemSize`], [`WeightElement`] |
+//! | [`types`] | [`Max`], [`Min`], [`Extremum`], [`ExtremumSense`], [`ProblemParameters`], [`WeightElement`] |
 //! | [`variant`] | Variant parameter system for problem type parameterization |
 //!
 //! Use [`prelude`] for convenient imports.
@@ -20,15 +20,19 @@
 extern crate self as problemreductions;
 
 pub(crate) mod big_o;
-pub(crate) mod canonical;
 pub mod config;
 pub mod error;
 #[cfg(feature = "example-db")]
 pub mod example_db;
 pub mod export;
-pub(crate) mod expr;
+pub mod expr;
+// Growth is an explicit terminal projection for complexity display. Exact and certified
+// parameter propagation never re-enters this domain.
+pub mod growth;
 pub mod io;
 pub mod models;
+pub mod parameters;
+pub mod random;
 pub mod registry;
 pub mod rules;
 pub mod solvers;
@@ -93,40 +97,44 @@ pub mod prelude {
         ComparativeContainment, ConsecutiveSets, ExactCoverBy3Sets, IntegerKnapsack,
         MaximumSetPacking, MinimumCardinalityKey, MinimumHittingSet, MinimumSetCovering,
         PrimeAttributeName, RootedTreeStorageAssignment, SetBasis, SetSplitting,
-        ThreeMatroidIntersection,
     };
 
     // Core traits
     pub use crate::rules::{ReduceTo, ReductionResult};
-    pub use crate::solvers::{BruteForce, Solver};
+    pub use crate::solvers::BruteForce;
     pub use crate::traits::Problem;
 
     // Types
     pub use crate::error::{ProblemError, Result};
     pub use crate::types::{
-        And, Extremum, ExtremumSense, Max, Min, One, Or, ProblemSize, Sum, Unweighted,
+        And, Extremum, ExtremumSense, Max, Min, One, Or, ProblemParameters, Sum,
     };
 }
 
 // Re-export commonly used items at crate root
 pub use big_o::big_o_normal_form;
-pub use canonical::canonical_form;
 pub use error::{ProblemError, Result};
-pub use expr::{asymptotic_normal_form, AsymptoticAnalysisError, CanonicalizationError, Expr};
+pub use expr::{
+    evaluate_approximate, ApproximationError, AsymptoticAnalysisError, Expr, ParseError,
+};
+pub use growth::Growth;
 pub use registry::{ComplexityClass, ProblemInfo};
-pub use solvers::{BruteForce, Solver};
+pub use solvers::BruteForce;
 pub use traits::Problem;
 pub use types::{
-    And, Extremum, ExtremumSense, Max, Min, NumericSize, One, Or, ProblemSize, Sum, Unweighted,
+    And, Extremum, ExtremumSense, Max, Min, NumericSize, One, Or, ProblemParameters, Sum,
     WeightElement,
 };
 
 // Re-export proc macros for reduction registration and variant declaration
-pub use problemreductions_macros::{declare_variants, reduction};
+pub use problemreductions_macros::{declare_variants, reduction, register_brute_force, CreateSpec};
 
 // Re-export inventory so `declare_variants!` can use `$crate::inventory::submit!`
 pub use inventory;
 
+#[cfg(all(test, feature = "example-db"))]
+#[path = "unit_tests/symbolic_parameter_contracts.rs"]
+mod symbolic_parameter_contracts;
 #[cfg(test)]
 #[path = "unit_tests/graph_models.rs"]
 mod test_graph_models;
@@ -134,6 +142,9 @@ mod test_graph_models;
 #[path = "unit_tests/prelude.rs"]
 mod test_prelude;
 #[cfg(test)]
+#[path = "unit_tests/problem_parameters.rs"]
+mod test_problem_parameters;
+#[cfg(test)]
 #[path = "unit_tests/property.rs"]
 mod test_property;
 #[cfg(test)]
diff --git a/src/models/algebraic/algebraic_equations_over_gf2.rs b/src/models/algebraic/algebraic_equations_over_gf2.rs
index be8d8c334..32649b5f2 100644
--- a/src/models/algebraic/algebraic_equations_over_gf2.rs
+++ b/src/models/algebraic/algebraic_equations_over_gf2.rs
@@ -4,7 +4,7 @@
 //! there exists an assignment of the variables making all polynomials evaluate
 //! to 0 (mod 2).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Algebraic Equations over GF(2)",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Find assignment satisfying multilinear polynomial equations over GF(2)",
         fields: &[
@@ -25,13 +26,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "AlgebraicEquationsOverGF2",
-        fields: &["num_variables", "num_equations"],
-    }
-}
-
 /// Algebraic Equations over GF(2).
 ///
 /// Given m multilinear polynomials over GF(2) in n variables, determine whether
@@ -47,7 +41,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::AlgebraicEquationsOverGF2;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Two equations in 3 variables:
 /// //   x0*x1 + x2 = 0 (mod 2)
@@ -61,7 +55,7 @@ inventory::submit! {
 /// ).unwrap();
 ///
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem);
+/// let witness = solver.solve(&problem).unwrap();
 /// assert!(witness.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize)]
@@ -74,7 +68,10 @@ pub struct AlgebraicEquationsOverGF2 {
 }
 
 impl AlgebraicEquationsOverGF2 {
-    fn validate(num_variables: usize, equations: &[Vec<Vec<usize>>]) -> Result<(), String> {
+    fn validate(
+        num_variables: usize,
+        equations: &[Vec<Vec<usize>>],
+    ) -> Result<(), crate::registry::ConstructionError> {
         for (eq_idx, equation) in equations.iter().enumerate() {
             for (mono_idx, monomial) in equation.iter().enumerate() {
                 // Check variable indices are in range
@@ -83,7 +80,8 @@ impl AlgebraicEquationsOverGF2 {
                         return Err(format!(
                             "Variable index {var} in equation {eq_idx}, monomial {mono_idx} \
                              is out of range (num_variables = {num_variables})"
-                        ));
+                        )
+                        .into());
                     }
                 }
                 // Check monomial is sorted and has no duplicates
@@ -93,7 +91,8 @@ impl AlgebraicEquationsOverGF2 {
                             "Monomial {mono_idx} in equation {eq_idx} is not strictly sorted: \
                              found {} >= {}",
                             w[0], w[1]
-                        ));
+                        )
+                        .into());
                     }
                 }
             }
@@ -105,7 +104,10 @@ impl AlgebraicEquationsOverGF2 {
     ///
     /// Returns an error if any variable index is out of range or any monomial
     /// is not strictly sorted.
-    pub fn new(num_variables: usize, equations: Vec<Vec<Vec<usize>>>) -> Result<Self, String> {
+    pub fn new(
+        num_variables: usize,
+        equations: Vec<Vec<Vec<usize>>>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate(num_variables, &equations)?;
         Ok(Self {
             num_variables,
@@ -132,12 +134,12 @@ impl AlgebraicEquationsOverGF2 {
     ///
     /// An empty monomial is the constant 1.
     /// A non-empty monomial is the product (AND) of the indicated variables.
-    fn evaluate_monomial(monomial: &[usize], assignment: &[usize]) -> usize {
+    fn evaluate_monomial(monomial: &[usize], assignment: &[bool]) -> usize {
         if monomial.is_empty() {
             return 1;
         }
         for &var in monomial {
-            if assignment[var] == 0 {
+            if !assignment[var] {
                 return 0;
             }
         }
@@ -147,7 +149,7 @@ impl AlgebraicEquationsOverGF2 {
     /// Evaluate a single equation (polynomial) given a binary assignment.
     ///
     /// Returns true if the polynomial evaluates to 0 (mod 2).
-    fn evaluate_equation(equation: &[Vec<usize>], assignment: &[usize]) -> bool {
+    fn evaluate_equation(equation: &[Vec<usize>], assignment: &[bool]) -> bool {
         let sum: usize = equation
             .iter()
             .map(|mono| Self::evaluate_monomial(mono, assignment))
@@ -174,21 +176,36 @@ impl<'de> Deserialize<'de> for AlgebraicEquationsOverGF2 {
 
 impl Problem for AlgebraicEquationsOverGF2 {
     const NAME: &'static str = "AlgebraicEquationsOverGF2";
+    type Solution = Vec<bool>;
     type Value = Or;
 
+    crate::problem_parameters![
+        ("num_equations", num_equations),
+        ("num_variables", num_variables),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_variables]
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_variables {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "assignment length does not match the equation variables".into(),
+            ));
+        }
+        Ok({
+            Or(self
+                .equations
+                .iter()
+                .all(|eq| Self::evaluate_equation(eq, config)))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or(self
-            .equations
-            .iter()
-            .all(|eq| Self::evaluate_equation(eq, config)))
+impl crate::solvers::BruteForceProblem for AlgebraicEquationsOverGF2 {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_variables]
     }
 }
 
@@ -196,6 +213,10 @@ crate::declare_variants! {
     default AlgebraicEquationsOverGF2 => "2^(0.6943 * num_variables)",
 }
 
+crate::register_brute_force! {
+    AlgebraicEquationsOverGF2 decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -215,7 +236,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             .unwrap(),
         ),
         // config [1,0,0]: eq1: 0*0+0=0 ✓, eq2: 0*0+1+1=0 ✓, eq3: 1+0+0+1=0 ✓
-        optimal_config: vec![1, 0, 0],
+        optimal_config: serde_json::json!(vec![true, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/algebraic/bmf.rs b/src/models/algebraic/bmf.rs
index 455514fe8..52aeb23e8 100644
--- a/src/models/algebraic/bmf.rs
+++ b/src/models/algebraic/bmf.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "BMF",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Boolean matrix factorization",
         fields: &[
@@ -39,7 +40,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::BMF;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 2x2 identity matrix — boolean rank 2
 /// let a = vec![
@@ -49,8 +50,8 @@ inventory::submit! {
 /// let problem = BMF::new(a, 2);
 ///
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem).unwrap();
-/// assert!(problem.is_exact(&witness));
+/// let witness = solver.solve(&problem).unwrap().unwrap();
+/// assert!(problem.is_exact(&witness).unwrap());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BMF {
@@ -112,31 +113,12 @@ impl BMF {
         &self.matrix
     }
 
-    /// Extract matrices B and C from a configuration.
-    ///
-    /// Config layout: first m*k bits are B (row-major), next k*n bits are C (row-major).
-    pub fn extract_factors(&self, config: &[usize]) -> (Vec<Vec<bool>>, Vec<Vec<bool>>) {
-        let b_size = self.m * self.k;
-
-        // Extract B (m x k)
-        let b: Vec<Vec<bool>> = (0..self.m)
-            .map(|i| {
-                (0..self.k)
-                    .map(|j| config.get(i * self.k + j).copied().unwrap_or(0) == 1)
-                    .collect()
-            })
-            .collect();
-
-        // Extract C (k x n)
-        let c: Vec<Vec<bool>> = (0..self.k)
-            .map(|i| {
-                (0..self.n)
-                    .map(|j| config.get(b_size + i * self.n + j).copied().unwrap_or(0) == 1)
-                    .collect()
-            })
-            .collect();
-
-        (b, c)
+    /// Return the two factor matrices represented by a solution.
+    pub fn extract_factors(
+        &self,
+        solution: &(Vec<Vec<bool>>, Vec<Vec<bool>>),
+    ) -> (Vec<Vec<bool>>, Vec<Vec<bool>>) {
+        solution.clone()
     }
 
     /// Compute the boolean product B * C.
@@ -157,10 +139,13 @@ impl BMF {
     }
 
     /// Compute the Hamming distance between the target and the product.
-    pub fn hamming_distance(&self, config: &[usize]) -> usize {
-        let (b, c) = self.extract_factors(config);
+    pub fn hamming_distance(
+        &self,
+        solution: &(Vec<Vec<bool>>, Vec<Vec<bool>>),
+    ) -> Result<i64, crate::traits::EvaluationError> {
+        let (b, c) = solution;
 
-        (0..self.m)
+        let distance = (0..self.m)
             .map(|i| {
                 (0..self.n)
                     .filter(|&j| {
@@ -169,17 +154,39 @@ impl BMF {
                     })
                     .count()
             })
-            .sum()
+            .sum::<usize>();
+        i64::try_from(distance).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting Boolean-matrix Hamming distance to i64".into(),
+            )
+        })
     }
 
     /// Check if the factorization is exact (Hamming distance = 0).
-    pub fn is_exact(&self, config: &[usize]) -> bool {
-        self.hamming_distance(config) == 0
+    pub fn is_exact(
+        &self,
+        solution: &(Vec<Vec<bool>>, Vec<Vec<bool>>),
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(self.hamming_distance(solution)? == 0)
     }
 
     /// Total number of 1s in B and C (the factor size to be minimized when exact).
-    pub fn total_factor_size(&self, config: &[usize]) -> usize {
-        config.iter().filter(|&&x| x == 1).count()
+    pub fn total_factor_size(
+        &self,
+        solution: &(Vec<Vec<bool>>, Vec<Vec<bool>>),
+    ) -> Result<i64, crate::traits::EvaluationError> {
+        let (left, right) = solution;
+        let size = left
+            .iter()
+            .chain(right)
+            .flatten()
+            .filter(|&&value| value)
+            .count();
+        i64::try_from(size).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting Boolean factor size to i64".into(),
+            )
+        })
     }
 }
 
@@ -206,19 +213,32 @@ pub(crate) fn matrix_hamming_distance(a: &[Vec<bool>], b: &[Vec<bool>]) -> usize
 
 impl Problem for BMF {
     const NAME: &'static str = "BMF";
-    type Value = Min<i32>;
+    type Solution = (Vec<Vec<bool>>, Vec<Vec<bool>>);
+    type Value = Min<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        // B: m*k + C: k*n binary variables
-        vec![2; self.m * self.k + self.k * self.n]
-    }
+    crate::problem_parameters![("cols", cols), ("rank", rank), ("rows", rows),];
 
-    fn evaluate(&self, config: &[usize]) -> Min<i32> {
-        // Feasible iff B*C = A exactly; objective is total factor size (|B| + |C| in 1s).
-        if self.hamming_distance(config) != 0 {
-            return Min(None);
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        let (left, right) = solution;
+        if left.len() != self.m
+            || left.iter().any(|row| row.len() != self.k)
+            || right.len() != self.k
+            || right.iter().any(|row| row.len() != self.n)
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "BMF factor dimensions do not match the instance".into(),
+            ));
         }
-        Min(Some(self.total_factor_size(config) as i32))
+        Ok({
+            // Feasible iff B*C = A exactly; objective is total factor size (|B| + |C| in 1s).
+            if self.hamming_distance(solution)? != 0 {
+                return Ok(Min(None));
+            }
+            Min(Some(self.total_factor_size(solution)?))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -226,10 +246,27 @@ impl Problem for BMF {
     }
 }
 
+impl crate::solvers::BruteForceProblem for BMF {
+    fn dimensions(&self) -> Vec<usize> {
+        // B: m*k + C: k*n binary variables
+        vec![2; self.m * self.k + self.k * self.n]
+    }
+}
+
 crate::declare_variants! {
     default BMF => "2^(rows * rank + rank * cols)",
 }
 
+crate::register_brute_force! {
+    BMF decode |problem: &BMF, indices: Vec<usize>| {
+        let split = problem.rows() * problem.rank();
+        (
+            indices[..split].chunks(problem.rank()).map(crate::config::config_to_bits).collect(),
+            indices[split..].chunks(problem.cols()).map(crate::config::config_to_bits).collect(),
+        )
+    },
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -242,9 +279,12 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
             2,
         )),
-        // B = [[1,0],[1,1],[0,1]] (row-major: 1,0,1,1,0,1), C = [[1,1,0],[0,1,1]] (row-major: 1,1,0,0,1,1).
+        // B = [[1,0],[1,1],[0,1]], C = [[1,1,0],[0,1,1]].
         // Total 1s: 4 in B + 4 in C = 8, and B * C = A exactly.
-        optimal_config: vec![1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1],
+        optimal_config: serde_json::json!((
+            vec![vec![true, false], vec![true, true], vec![false, true]],
+            vec![vec![true, true, false], vec![false, true, true]]
+        )),
         optimal_value: serde_json::json!(8),
     }]
 }
diff --git a/src/models/algebraic/closest_vector_problem.rs b/src/models/algebraic/closest_vector_problem.rs
index 3e3410538..d166b32fb 100644
--- a/src/models/algebraic/closest_vector_problem.rs
+++ b/src/models/algebraic/closest_vector_problem.rs
@@ -1,295 +1,309 @@
-//! Closest Vector Problem (CVP) implementation.
+//! Closest Vector Problem (CVP).
 //!
-//! Given a lattice basis B and target vector t, find integer coefficients x
-//! minimizing ‖Bx - t‖₂.
+//! Given an integer lattice basis `B` and a target vector `t`, find integer
+//! coefficients `x` minimizing `||Bx - t||_2`.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
-use crate::traits::Problem;
+use crate::registry::{ConstructionError, CreateSpec, ProblemSchemaEntry, VariantDimension};
+use crate::traits::{EvaluationError, Problem};
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
 
-inventory::submit! {
-    ProblemSchemaEntry {
-        name: "ClosestVectorProblem",
-        display_name: "Closest Vector Problem",
-        aliases: &["CVP"],
-        dimensions: &[VariantDimension::new("weight", "i32", &["i32", "f64"])],
-        module_path: module_path!(),
-        description: "Find the closest lattice point to a target vector",
-        fields: &[
-            FieldInfo { name: "basis", type_name: "Vec<Vec<T>>", description: "Basis matrix B as column vectors" },
-            FieldInfo { name: "target", type_name: "Vec<f64>", description: "Target vector t" },
-            FieldInfo { name: "bounds", type_name: "Vec<VarBounds>", description: "Integer bounds per variable" },
-        ],
-    }
-}
+/// Target coordinate domains supported by [`ClosestVectorProblem`].
+pub trait ClosestVectorTarget: Clone + std::fmt::Debug + 'static {
+    /// Registered value of the `target` variant dimension.
+    const NAME: &'static str;
 
-/// Variable bounds (None = unbounded in that direction).
-///
-/// Represents the lower and upper bounds for an integer variable.
-/// A value of `None` indicates the variable is unbounded in that direction.
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct VarBounds {
-    /// Lower bound (None = -infinity).
-    pub lower: Option<i64>,
-    /// Upper bound (None = +infinity).
-    pub upper: Option<i64>,
+    /// Validate one stored target coordinate.
+    fn validate(&self, index: usize) -> Result<(), ConstructionError>;
+
+    /// Convert one coordinate for numerical evaluation and solving.
+    fn to_f64(&self) -> Result<f64, EvaluationError>;
 }
 
-impl VarBounds {
-    /// Create bounds for a binary variable: 0 <= x <= 1.
-    pub fn binary() -> Self {
-        Self {
-            lower: Some(0),
-            upper: Some(1),
-        }
-    }
+impl ClosestVectorTarget for i64 {
+    const NAME: &'static str = "i64";
 
-    /// Create bounds for a non-negative variable: x >= 0.
-    pub fn non_negative() -> Self {
-        Self {
-            lower: Some(0),
-            upper: None,
-        }
+    fn validate(&self, _index: usize) -> Result<(), ConstructionError> {
+        Ok(())
     }
 
-    /// Create unbounded variable: -infinity < x < +infinity.
-    pub fn unbounded() -> Self {
-        Self {
-            lower: None,
-            upper: None,
-        }
+    fn to_f64(&self) -> Result<f64, EvaluationError> {
+        crate::types::i64_to_exact_f64(*self)
+            .map_err(|error| EvaluationError::InexactFloatConversion(error.to_string()))
     }
+}
 
-    /// Create bounds with explicit lower and upper: lo <= x <= hi.
-    pub fn bounded(lo: i64, hi: i64) -> Self {
-        Self {
-            lower: Some(lo),
-            upper: Some(hi),
-        }
-    }
+impl ClosestVectorTarget for f64 {
+    const NAME: &'static str = "f64";
 
-    /// Check if a value satisfies these bounds.
-    pub fn contains(&self, value: i64) -> bool {
-        if let Some(lo) = self.lower {
-            if value < lo {
-                return false;
-            }
-        }
-        if let Some(hi) = self.upper {
-            if value > hi {
-                return false;
-            }
+    fn validate(&self, index: usize) -> Result<(), ConstructionError> {
+        if self.is_finite() {
+            Ok(())
+        } else {
+            Err(ConstructionError::NonFiniteFloat(format!(
+                "target coordinate at index {index} must be finite"
+            )))
         }
-        true
     }
 
-    /// Get the number of integer values in this bound range.
-    /// Returns None if unbounded in either direction.
-    pub fn num_values(&self) -> Option<usize> {
-        match (self.lower, self.upper) {
-            (Some(lo), Some(hi)) => {
-                if hi >= lo {
-                    Some((hi - lo + 1) as usize)
-                } else {
-                    Some(0)
-                }
-            }
-            _ => None,
-        }
+    fn to_f64(&self) -> Result<f64, EvaluationError> {
+        Ok(*self)
     }
+}
 
-    /// Returns an exact bounded binary basis for offsets in this range.
-    ///
-    /// For a bounded variable with offsets `0..=hi-lo`, the returned weights
-    /// ensure that every bit-pattern reconstructs an in-range offset. Low-order
-    /// weights use powers of two; the final weight is capped so the maximum
-    /// reachable offset is exactly `hi-lo`.
-    pub(crate) fn exact_encoding_weights(&self) -> Vec<i64> {
-        let Some(num_values) = self.num_values() else {
-            panic!("CVP QUBO encoding requires finite variable bounds");
-        };
-        if num_values <= 1 {
-            return Vec::new();
+macro_rules! cvp_create_spec {
+    ($name:ident, $target:ty) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            /// Integer basis matrix as semicolon-separated column vectors.
+            #[create(codec = "semicolon-separated")]
+            basis: Vec<Vec<i64>>,
+            /// Target vector.
+            #[create(name = "target_vec", codec = "comma-separated")]
+            target: Vec<$target>,
         }
 
-        let max_offset = (num_values - 1) as i64;
-        let num_bits = (usize::BITS - (num_values - 1).leading_zeros()) as usize;
-        let mut weights = Vec::with_capacity(num_bits);
+        impl TryFrom<$name> for ClosestVectorProblem<$target> {
+            type Error = ConstructionError;
 
-        for bit in 0..num_bits.saturating_sub(1) {
-            weights.push(1_i64 << bit);
+            fn try_from(spec: $name) -> Result<Self, Self::Error> {
+                ClosestVectorProblem::new(spec.basis, spec.target)
+            }
         }
+    };
+}
 
-        let covered_by_lower_bits = if num_bits <= 1 {
-            0
-        } else {
-            (1_i64 << (num_bits - 1)) - 1
-        };
-        weights.push(max_offset - covered_by_lower_bits);
-        weights
-    }
+cvp_create_spec!(ClosestVectorProblemI64CreateSpec, i64);
+cvp_create_spec!(ClosestVectorProblemF64CreateSpec, f64);
 
-    /// Returns the number of encoding bits needed for the exact bounded basis.
-    pub(crate) fn num_encoding_bits(&self) -> usize {
-        self.exact_encoding_weights().len()
+inventory::submit! {
+    ProblemSchemaEntry {
+        name: "ClosestVectorProblem",
+        display_name: "Closest Vector Problem",
+        aliases: &["CVP"],
+        dimensions: &[VariantDimension::new("target", "i64", &["i64", "f64"])],
+        category: crate::registry::ProblemCategory::Algebraic,
+        module_path: module_path!(),
+        description: "Find the closest point in an integer lattice to a target vector",
+        fields: ClosestVectorProblemI64CreateSpec::FIELDS,
     }
 }
 
-/// Closest Vector Problem (CVP).
-///
-/// Given a lattice basis B ∈ R^{m×n} and target t ∈ R^m,
-/// find integer x ∈ Z^n minimizing ‖Bx - t‖₂.
-///
-/// Variables are integer coefficients with explicit bounds for enumeration.
-/// The configuration encoding follows ILP: config[i] is an offset from bounds[i].lower.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ClosestVectorProblem<T> {
-    /// Basis matrix B stored as n column vectors, each of dimension m.
-    basis: Vec<Vec<T>>,
-    /// Target vector t ∈ R^m.
-    target: Vec<f64>,
-    /// Integer bounds per variable for enumeration.
-    bounds: Vec<VarBounds>,
+/// Euclidean Closest Vector Problem over an integer lattice basis.
+#[derive(Debug, Clone, Serialize)]
+pub struct ClosestVectorProblem<T = i64> {
+    /// Basis matrix stored as column vectors.
+    basis: Vec<Vec<i64>>,
+    /// Target vector in the ambient space.
+    target: Vec<T>,
 }
 
-impl<T> ClosestVectorProblem<T> {
-    /// Create a new CVP instance.
-    ///
-    /// # Arguments
-    /// * `basis` - n column vectors of dimension m
-    /// * `target` - target vector of dimension m
-    /// * `bounds` - integer bounds per variable (length n)
-    ///
-    /// # Panics
-    /// Panics if basis/bounds lengths mismatch or dimensions are inconsistent.
-    pub fn new(basis: Vec<Vec<T>>, target: Vec<f64>, bounds: Vec<VarBounds>) -> Self {
-        let n = basis.len();
-        assert_eq!(
-            bounds.len(),
-            n,
-            "bounds length must match number of basis vectors"
-        );
-        let m = target.len();
-        for (i, col) in basis.iter().enumerate() {
-            assert_eq!(
-                col.len(),
-                m,
-                "basis vector {i} has length {}, expected {m}",
-                col.len()
-            );
+impl<T: ClosestVectorTarget> ClosestVectorProblem<T> {
+    /// Construct a CVP instance with a full-column-rank integer basis.
+    pub fn new(basis: Vec<Vec<i64>>, target: Vec<T>) -> Result<Self, ConstructionError> {
+        let ambient_dimension = target.len();
+        for (index, coordinate) in target.iter().enumerate() {
+            coordinate.validate(index)?;
         }
-        Self {
-            basis,
-            target,
-            bounds,
+        for (index, column) in basis.iter().enumerate() {
+            if column.len() != ambient_dimension {
+                return Err(ConstructionError::Conversion(format!(
+                    "basis vector {index} has length {}, expected {ambient_dimension}",
+                    column.len()
+                )));
+            }
+        }
+        if basis.len() > ambient_dimension {
+            return Err(ConstructionError::Conversion(format!(
+                "{} basis vectors cannot be independent in ambient dimension {ambient_dimension}",
+                basis.len()
+            )));
         }
+        if independent_rows(&basis, ambient_dimension)?.is_none() {
+            return Err(ConstructionError::Conversion(
+                "closest-vector basis columns must be linearly independent".into(),
+            ));
+        }
+        Ok(Self { basis, target })
     }
 
-    /// Number of basis vectors (lattice dimension n).
+    /// Number of basis vectors.
     pub fn num_basis_vectors(&self) -> usize {
         self.basis.len()
     }
 
-    /// Dimension of the ambient space (m).
+    /// Dimension of the ambient space.
     pub fn ambient_dimension(&self) -> usize {
         self.target.len()
     }
 
-    /// Access the basis matrix.
-    pub fn basis(&self) -> &[Vec<T>] {
+    /// Integer basis columns.
+    pub fn basis(&self) -> &[Vec<i64>] {
         &self.basis
     }
 
-    /// Access the target vector.
-    pub fn target(&self) -> &[f64] {
+    /// Target coordinates.
+    pub fn target(&self) -> &[T] {
         &self.target
     }
 
-    /// Access the variable bounds.
-    pub fn bounds(&self) -> &[VarBounds] {
-        &self.bounds
+    pub(crate) fn independent_rows(&self) -> Result<Vec<usize>, ConstructionError> {
+        independent_rows(&self.basis, self.ambient_dimension())?.ok_or_else(|| {
+            ConstructionError::Conversion(
+                "closest-vector basis columns must be linearly independent".into(),
+            )
+        })
     }
+}
 
-    /// Returns the total number of bounded-encoding bits used by the QUBO form.
-    pub fn num_encoding_bits(&self) -> usize {
-        self.bounds.iter().map(VarBounds::num_encoding_bits).sum()
+fn independent_rows(
+    basis: &[Vec<i64>],
+    ambient_dimension: usize,
+) -> Result<Option<Vec<usize>>, ConstructionError> {
+    let num_columns = basis.len();
+    if num_columns == 0 {
+        return Ok(Some(Vec::new()));
     }
 
-    /// Convert a configuration (offsets from lower bounds) to integer values.
-    fn config_to_values(&self, config: &[usize]) -> Vec<i64> {
-        config
-            .iter()
-            .enumerate()
-            .map(|(i, &c)| {
-                let lo = self.bounds.get(i).and_then(|b| b.lower).unwrap_or(0);
-                lo + c as i64
-            })
-            .collect()
+    let mut matrix = (0..ambient_dimension)
+        .map(|row| basis.iter().map(|column| column[row]).collect::<Vec<_>>())
+        .collect::<Vec<_>>();
+    let mut previous_pivot = 1_i64;
+    let mut row_indices = (0..ambient_dimension).collect::<Vec<_>>();
+
+    for column in 0..num_columns {
+        let Some(pivot_row) = (column..ambient_dimension).find(|&row| matrix[row][column] != 0)
+        else {
+            return Ok(None);
+        };
+        matrix.swap(column, pivot_row);
+        row_indices.swap(column, pivot_row);
+        let pivot = matrix[column][column];
+
+        for row in (column + 1)..ambient_dimension {
+            for next_column in (column + 1)..num_columns {
+                let left = matrix[row][next_column]
+                    .checked_mul(pivot)
+                    .ok_or_else(rank_overflow)?;
+                let right = matrix[row][column]
+                    .checked_mul(matrix[column][next_column])
+                    .ok_or_else(rank_overflow)?;
+                let numerator = left.checked_sub(right).ok_or_else(rank_overflow)?;
+                matrix[row][next_column] = numerator
+                    .checked_div(previous_pivot)
+                    .ok_or_else(rank_overflow)?;
+            }
+            matrix[row][column] = 0;
+        }
+        previous_pivot = pivot;
+    }
+    row_indices.truncate(num_columns);
+    Ok(Some(row_indices))
+}
+
+fn rank_overflow() -> ConstructionError {
+    ConstructionError::IntegerOverflow("checking closest-vector basis rank".into())
+}
+
+impl<'de, T> Deserialize<'de> for ClosestVectorProblem<T>
+where
+    T: ClosestVectorTarget + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Raw<T> {
+            basis: Vec<Vec<i64>>,
+            target: Vec<T>,
+        }
+
+        let raw = Raw::deserialize(deserializer)?;
+        Self::new(raw.basis, raw.target).map_err(serde::de::Error::custom)
     }
 }
 
 impl<T> Problem for ClosestVectorProblem<T>
 where
-    T: Clone
-        + Into<f64>
-        + crate::variant::VariantParam
-        + Serialize
-        + for<'de> Deserialize<'de>
-        + std::fmt::Debug
-        + 'static,
+    T: ClosestVectorTarget + Serialize + for<'de> Deserialize<'de>,
 {
     const NAME: &'static str = "ClosestVectorProblem";
+    type Solution = Vec<i64>;
     type Value = Min<f64>;
 
-    fn dims(&self) -> Vec<usize> {
-        self.bounds
+    crate::problem_parameters![
+        ("ambient_dimension", ambient_dimension),
+        ("num_basis_vectors", num_basis_vectors),
+    ];
+
+    fn evaluate(&self, solution: &Self::Solution) -> Result<Min<f64>, EvaluationError> {
+        if solution.len() != self.num_basis_vectors() {
+            return Err(EvaluationError::InvalidConfiguration(format!(
+                "expected {} closest-vector coefficients, got {}",
+                self.num_basis_vectors(),
+                solution.len()
+            )));
+        }
+
+        let mut displacement = self
+            .target
             .iter()
-            .map(|b| {
-                b.num_values().expect(
-                    "CVP brute-force enumeration requires all variables to have finite bounds",
-                )
-            })
-            .collect()
-    }
+            .map(ClosestVectorTarget::to_f64)
+            .collect::<Result<Vec<_>, _>>()?;
+        for value in &mut displacement {
+            *value = -*value;
+        }
 
-    fn evaluate(&self, config: &[usize]) -> Min<f64> {
-        let values = self.config_to_values(config);
-        let m = self.ambient_dimension();
-        let mut diff = vec![0.0f64; m];
-        for (i, &x_i) in values.iter().enumerate() {
-            for (j, b_ji) in self.basis[i].iter().enumerate() {
-                diff[j] += x_i as f64 * b_ji.clone().into();
+        for (&coefficient, column) in solution.iter().zip(&self.basis) {
+            let coefficient = crate::types::i64_to_exact_f64(coefficient)
+                .map_err(|error| EvaluationError::InexactFloatConversion(error.to_string()))?;
+            for (value, &basis_entry) in displacement.iter_mut().zip(column) {
+                let basis_entry = crate::types::i64_to_exact_f64(basis_entry)
+                    .map_err(|error| EvaluationError::InexactFloatConversion(error.to_string()))?;
+                let next = *value + coefficient * basis_entry;
+                if !next.is_finite() {
+                    return Err(EvaluationError::NonFiniteResult(
+                        "computing closest-vector displacement".into(),
+                    ));
+                }
+                *value = next;
             }
         }
-        for (d, t) in diff.iter_mut().zip(self.target.iter()) {
-            *d -= t;
-        }
-        let norm = diff.iter().map(|d| d * d).sum::<f64>().sqrt();
-        Min(Some(norm))
+
+        let squared_norm = displacement.into_iter().try_fold(0.0, |total, value| {
+            let next = total + value * value;
+            if next.is_finite() {
+                Ok(next)
+            } else {
+                Err(EvaluationError::NonFiniteResult(
+                    "computing closest-vector norm".into(),
+                ))
+            }
+        })?;
+        Ok(Min(Some(squared_norm.sqrt())))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
-        crate::variant_params![T]
+        vec![("target", T::NAME)]
     }
 }
 
 crate::declare_variants! {
-    default ClosestVectorProblem<i32> => "2^num_basis_vectors",
-    ClosestVectorProblem<f64> => "2^num_basis_vectors",
+    default ClosestVectorProblem<i64> => "2^(num_basis_vectors * log(num_basis_vectors))" create ClosestVectorProblemI64CreateSpec,
+    ClosestVectorProblem<f64> => "2^(num_basis_vectors * log(num_basis_vectors))" create ClosestVectorProblemF64CreateSpec,
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "closest_vector_problem_i32",
-        instance: Box::new(ClosestVectorProblem::new(
-            vec![vec![2, 0], vec![1, 2]],
-            vec![2.8, 1.5],
-            vec![VarBounds::bounded(-2, 4), VarBounds::bounded(-2, 4)],
-        )),
-        optimal_config: vec![3, 3],
-        optimal_value: serde_json::json!(0.5385164807134505),
+        id: "closest_vector_problem",
+        instance: Box::new(
+            ClosestVectorProblem::new(vec![vec![2, 0], vec![1, 2]], vec![3_i64, 2])
+                .expect("canonical closest-vector instance must be valid"),
+        ),
+        optimal_config: serde_json::json!(vec![1, 1]),
+        optimal_value: serde_json::json!(0.0),
     }]
 }
 
diff --git a/src/models/algebraic/consecutive_block_minimization.rs b/src/models/algebraic/consecutive_block_minimization.rs
index 0a5df44df..b0b4d34ee 100644
--- a/src/models/algebraic/consecutive_block_minimization.rs
+++ b/src/models/algebraic/consecutive_block_minimization.rs
@@ -8,7 +8,7 @@
 //! A "block" is a maximal contiguous run of 1-entries in a row.
 //! This is problem SR17 in Garey & Johnson.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -18,12 +18,10 @@ inventory::submit! {
         display_name: "Consecutive Block Minimization",
         aliases: &["CBM"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Permute columns of a binary matrix to have at most K consecutive blocks of 1s",
-        fields: &[
-            FieldInfo { name: "matrix", type_name: "Vec<Vec<bool>>", description: "Binary matrix A (m x n)" },
-            FieldInfo { name: "bound", type_name: "i64", description: "Upper bound K on total consecutive blocks" },
-        ],
+        fields: ConsecutiveBlockMinimizationCreateSpec::FIELDS,
     }
 }
 
@@ -38,7 +36,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::ConsecutiveBlockMinimization;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 2x3 binary matrix
 /// let problem = ConsecutiveBlockMinimization::new(
@@ -50,11 +48,11 @@ inventory::submit! {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Verify solutions satisfy the block bound
 /// for sol in solutions {
-///     assert!(problem.evaluate(&sol));
+///     assert!(problem.evaluate(&sol).unwrap());
 /// }
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -73,6 +71,22 @@ pub struct ConsecutiveBlockMinimization {
     bound: i64,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct ConsecutiveBlockMinimizationCreateSpec {
+    /// Binary matrix A (m x n).
+    matrix: Vec<Vec<bool>>,
+    /// Upper bound K on total consecutive blocks.
+    bound_k: i64,
+}
+
+impl TryFrom<ConsecutiveBlockMinimizationCreateSpec> for ConsecutiveBlockMinimization {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: ConsecutiveBlockMinimizationCreateSpec) -> Result<Self, Self::Error> {
+        Self::try_new(spec.matrix, spec.bound_k)
+    }
+}
+
 impl ConsecutiveBlockMinimization {
     /// Create a new ConsecutiveBlockMinimization problem.
     ///
@@ -88,7 +102,10 @@ impl ConsecutiveBlockMinimization {
 
     /// Create a new ConsecutiveBlockMinimization problem, returning an error
     /// instead of panicking when the matrix is ragged.
-    pub fn try_new(matrix: Vec<Vec<bool>>, bound: i64) -> Result<Self, String> {
+    pub fn try_new(
+        matrix: Vec<Vec<bool>>,
+        bound: i64,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         let (num_rows, num_cols) = validate_matrix_dimensions(&matrix)?;
         Ok(Self {
             matrix,
@@ -124,27 +141,34 @@ impl ConsecutiveBlockMinimization {
     /// `config[position] = column_index` defines the column permutation.
     /// Returns `Some(total_blocks)` if the config is a valid permutation,
     /// or `None` if it is not (wrong length, duplicate columns, or out-of-range).
-    pub fn count_consecutive_blocks(&self, config: &[usize]) -> Option<usize> {
+    pub fn count_consecutive_blocks(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         if config.len() != self.num_cols {
-            return None;
+            return Ok(None);
         }
 
         // Validate permutation: all values distinct and in 0..num_cols.
         let mut seen = vec![false; self.num_cols];
         for &col in config {
             if col >= self.num_cols || seen[col] {
-                return None;
+                return Ok(None);
             }
             seen[col] = true;
         }
 
-        let mut total_blocks = 0;
+        let mut total_blocks = 0usize;
         for row in &self.matrix {
             let mut in_block = false;
             for &pos in config {
                 if row[pos] {
                     if !in_block {
-                        total_blocks += 1;
+                        total_blocks = total_blocks.checked_add(1).ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "counting consecutive blocks".into(),
+                            )
+                        })?;
                         in_block = true;
                     }
                 } else {
@@ -153,38 +177,62 @@ impl ConsecutiveBlockMinimization {
             }
         }
 
-        Some(total_blocks)
+        Ok(Some(i64::try_from(total_blocks).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting consecutive-block count to i64".into(),
+            )
+        })?))
     }
 }
 
 impl Problem for ConsecutiveBlockMinimization {
     const NAME: &'static str = "ConsecutiveBlockMinimization";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_cols; self.num_cols]
-    }
+    crate::problem_parameters![("num_cols", num_cols), ("num_rows", num_rows),];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            match self.count_consecutive_blocks(config) {
-                Some(total) => (total as i64) <= self.bound,
-                None => false,
-            }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_cols {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "column ordering length does not match the matrix".into(),
+            ));
+        }
+        if config.iter().any(|&column| column >= self.num_cols) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "column ordering contains an out-of-range column".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or({
+                match self.count_consecutive_blocks(config)? {
+                    Some(total) => total <= self.bound,
+                    None => false,
+                }
+            })
         })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
+}
 
-    fn num_variables(&self) -> usize {
-        self.num_cols
+impl crate::solvers::BruteForceProblem for ConsecutiveBlockMinimization {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_cols; self.num_cols]
     }
 }
 
 crate::declare_variants! {
-    default ConsecutiveBlockMinimization => "factorial(num_cols) * num_rows * num_cols",
+    default ConsecutiveBlockMinimization => "factorial(num_cols) * num_rows * num_cols" create ConsecutiveBlockMinimizationCreateSpec,
+}
+
+crate::register_brute_force! {
+    ConsecutiveBlockMinimization,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -194,7 +242,7 @@ struct ConsecutiveBlockMinimizationDef {
 }
 
 impl TryFrom<ConsecutiveBlockMinimizationDef> for ConsecutiveBlockMinimization {
-    type Error = String;
+    type Error = crate::registry::ConstructionError;
 
     fn try_from(value: ConsecutiveBlockMinimizationDef) -> Result<Self, Self::Error> {
         Self::try_new(value.matrix, value.bound)
@@ -210,12 +258,16 @@ impl From<ConsecutiveBlockMinimization> for ConsecutiveBlockMinimizationDef {
     }
 }
 
-fn validate_matrix_dimensions(matrix: &[Vec<bool>]) -> Result<(usize, usize), String> {
+fn validate_matrix_dimensions(
+    matrix: &[Vec<bool>],
+) -> Result<(usize, usize), crate::registry::ConstructionError> {
     let num_rows = matrix.len();
     let num_cols = matrix.first().map_or(0, Vec::len);
 
     if matrix.iter().any(|row| row.len() != num_cols) {
-        return Err("all matrix rows must have the same length".to_string());
+        return Err("all matrix rows must have the same length"
+            .to_string()
+            .into());
     }
 
     Ok((num_rows, num_cols))
@@ -238,7 +290,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
             6,
         )),
-        optimal_config: vec![0, 2, 4, 1, 3, 5],
+        optimal_config: serde_json::json!(vec![0, 2, 4, 1, 3, 5]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/algebraic/consecutive_ones_matrix_augmentation.rs b/src/models/algebraic/consecutive_ones_matrix_augmentation.rs
index 079d7bcd6..0ddbe58a6 100644
--- a/src/models/algebraic/consecutive_ones_matrix_augmentation.rs
+++ b/src/models/algebraic/consecutive_ones_matrix_augmentation.rs
@@ -4,7 +4,7 @@
 //! whether there exists a permutation of the columns and at most K zero-to-one
 //! augmentations such that every row has consecutive 1s.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,12 +14,10 @@ inventory::submit! {
         display_name: "Consecutive Ones Matrix Augmentation",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Augment a binary matrix with at most K zero-to-one flips so some column permutation has the consecutive ones property",
-        fields: &[
-            FieldInfo { name: "matrix", type_name: "Vec<Vec<bool>>", description: "m x n binary matrix A" },
-            FieldInfo { name: "bound", type_name: "i64", description: "Upper bound K on zero-to-one augmentations" },
-        ],
+        fields: ConsecutiveOnesMatrixAugmentationCreateSpec::FIELDS,
     }
 }
 
@@ -29,18 +27,37 @@ pub struct ConsecutiveOnesMatrixAugmentation {
     bound: i64,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct ConsecutiveOnesMatrixAugmentationCreateSpec {
+    /// m x n binary matrix A.
+    matrix: Vec<Vec<bool>>,
+    /// Upper bound K on zero-to-one augmentations.
+    bound: i64,
+}
+impl TryFrom<ConsecutiveOnesMatrixAugmentationCreateSpec> for ConsecutiveOnesMatrixAugmentation {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: ConsecutiveOnesMatrixAugmentationCreateSpec) -> Result<Self, Self::Error> {
+        Self::try_new(spec.matrix, spec.bound)
+    }
+}
+
 impl ConsecutiveOnesMatrixAugmentation {
     pub fn new(matrix: Vec<Vec<bool>>, bound: i64) -> Self {
         Self::try_new(matrix, bound).unwrap_or_else(|err| panic!("{err}"))
     }
 
-    pub fn try_new(matrix: Vec<Vec<bool>>, bound: i64) -> Result<Self, String> {
+    pub fn try_new(
+        matrix: Vec<Vec<bool>>,
+        bound: i64,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         let num_cols = matrix.first().map_or(0, Vec::len);
         if matrix.iter().any(|row| row.len() != num_cols) {
-            return Err("all matrix rows must have the same length".to_string());
+            return Err("all matrix rows must have the same length"
+                .to_string()
+                .into());
         }
         if bound < 0 {
-            return Err("bound must be nonnegative".to_string());
+            return Err("bound must be nonnegative".to_string().into());
         }
         Ok(Self { matrix, bound })
     }
@@ -95,49 +112,78 @@ impl ConsecutiveOnesMatrixAugmentation {
         }
     }
 
-    fn total_augmentation_cost(&self, config: &[usize]) -> Option<usize> {
+    fn total_augmentation_cost(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<usize>, crate::traits::EvaluationError> {
         if !self.validate_permutation(config) {
-            return None;
+            return Ok(None);
         }
 
         let mut total = 0usize;
         for row in &self.matrix {
-            total += Self::row_augmentation_cost(row, config);
+            total = total
+                .checked_add(Self::row_augmentation_cost(row, config))
+                .ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing consecutive-ones matrix augmentation costs".to_string(),
+                    )
+                })?;
             if total > self.bound as usize {
-                return Some(total);
+                return Ok(Some(total));
             }
         }
 
-        Some(total)
+        Ok(Some(total))
     }
 }
 
 impl Problem for ConsecutiveOnesMatrixAugmentation {
     const NAME: &'static str = "ConsecutiveOnesMatrixAugmentation";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_cols(); self.num_cols()]
-    }
+    crate::problem_parameters![("num_cols", num_cols), ("num_rows", num_rows),];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            self.total_augmentation_cost(config)
-                .is_some_and(|cost| cost <= self.bound as usize)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_cols() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "column ordering length does not match the matrix".into(),
+            ));
+        }
+        if config.iter().any(|&column| column >= self.num_cols()) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "column ordering contains an out-of-range column".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or({
+                self.total_augmentation_cost(config)?
+                    .is_some_and(|cost| cost <= self.bound as usize)
+            })
         })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
+}
 
-    fn num_variables(&self) -> usize {
-        self.num_cols()
+impl crate::solvers::BruteForceProblem for ConsecutiveOnesMatrixAugmentation {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_cols(); self.num_cols()]
     }
 }
 
 crate::declare_variants! {
-    default ConsecutiveOnesMatrixAugmentation => "factorial(num_cols) * num_rows * num_cols",
+    default ConsecutiveOnesMatrixAugmentation => "factorial(num_cols) * num_rows * num_cols" create ConsecutiveOnesMatrixAugmentationCreateSpec,
+}
+
+crate::register_brute_force! {
+    ConsecutiveOnesMatrixAugmentation,
 }
 
 #[cfg(feature = "example-db")]
@@ -153,7 +199,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
             2,
         )),
-        optimal_config: vec![0, 1, 4, 2, 3],
+        optimal_config: serde_json::json!(vec![0, 1, 4, 2, 3]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/algebraic/consecutive_ones_submatrix.rs b/src/models/algebraic/consecutive_ones_submatrix.rs
index 3b7308ddc..8c8514e14 100644
--- a/src/models/algebraic/consecutive_ones_submatrix.rs
+++ b/src/models/algebraic/consecutive_ones_submatrix.rs
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Consecutive Ones Submatrix",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Find K columns of a binary matrix that can be permuted to have the consecutive ones property",
         fields: &[
@@ -44,7 +45,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::ConsecutiveOnesSubmatrix;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Tucker matrix (3×4) — full matrix does NOT have C1P, but K=3 does.
 /// let matrix = vec![
@@ -54,7 +55,7 @@ inventory::submit! {
 /// ];
 /// let problem = ConsecutiveOnesSubmatrix::new(matrix, 3);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -79,7 +80,7 @@ impl ConsecutiveOnesSubmatrix {
             assert_eq!(row.len(), n, "All rows must have the same length");
         }
         assert!(
-            bound <= n as i64,
+            bound < 0 || usize::try_from(bound).is_ok_and(|bound| bound <= n),
             "bound ({bound}) must be <= number of columns ({n})"
         );
         Self { matrix, bound }
@@ -173,36 +174,49 @@ impl ConsecutiveOnesSubmatrix {
 
 impl Problem for ConsecutiveOnesSubmatrix {
     const NAME: &'static str = "ConsecutiveOnesSubmatrix";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("bound", bound),
+        ("num_cols", num_cols),
+        ("num_rows", num_rows),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_cols()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_cols() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "column-selection length does not match the matrix".into(),
+                    ));
+                }
+                // Collect selected column indices
+                let selected: Vec<usize> = config
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, &v)| v)
+                    .map(|(i, _)| i)
+                    .collect();
+                if usize::try_from(self.bound) != Ok(selected.len()) {
+                    return Ok(crate::types::Or(false));
+                }
+                self.any_permutation_has_c1p(&selected)
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_cols() {
-                return crate::types::Or(false);
-            }
-            if config.iter().any(|&v| v >= 2) {
-                return crate::types::Or(false);
-            }
-            // Collect selected column indices
-            let selected: Vec<usize> = config
-                .iter()
-                .enumerate()
-                .filter(|(_, &v)| v == 1)
-                .map(|(i, _)| i)
-                .collect();
-            if (selected.len() as i64) != self.bound {
-                return crate::types::Or(false);
-            }
-            self.any_permutation_has_c1p(&selected)
-        })
+impl crate::solvers::BruteForceProblem for ConsecutiveOnesSubmatrix {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_cols()]
     }
 }
 
@@ -210,6 +224,10 @@ crate::declare_variants! {
     default ConsecutiveOnesSubmatrix => "2^(num_cols) * (num_rows + num_cols)",
 }
 
+crate::register_brute_force! {
+    ConsecutiveOnesSubmatrix decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -224,7 +242,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
             3,
         )),
-        optimal_config: vec![1, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![true, true, false, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/algebraic/equilibrium_point.rs b/src/models/algebraic/equilibrium_point.rs
index d87f37c3b..6d3392c40 100644
--- a/src/models/algebraic/equilibrium_point.rs
+++ b/src/models/algebraic/equilibrium_point.rs
@@ -5,7 +5,7 @@
 //! y = (y_1, ..., y_n) with y_i ∈ M_i such that for every player i,
 //! F_i(y) ≥ F_i(y with y_i replaced by any y' ∈ M_i).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Equilibrium Point",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Decide whether a pure-strategy Nash equilibrium exists for a multi-player game with polynomial payoff functions",
         fields: &[
@@ -34,13 +35,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "EquilibriumPoint",
-        fields: &["num_players"],
-    }
-}
-
 /// Equilibrium Point problem.
 ///
 /// Given n players, each with a finite strategy set M_i and a polynomial payoff
@@ -61,7 +55,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::EquilibriumPoint;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 3 players, M_i = {0, 1} for all i.
 /// // F1 = x1*x2*x3, F2 = (1-x1)*x2, F3 = x1*(1-x3)
@@ -73,7 +67,7 @@ inventory::submit! {
 /// let range_sets = vec![vec![0,1], vec![0,1], vec![0,1]];
 /// let problem = EquilibriumPoint::new(polynomials, range_sets).unwrap();
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem);
+/// let witness = solver.solve(&problem).unwrap();
 /// assert!(witness.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize)]
@@ -89,17 +83,18 @@ impl EquilibriumPoint {
     fn validate_inputs(
         polynomials: &[Vec<Vec<i64>>],
         range_sets: &[Vec<i64>],
-    ) -> Result<(), String> {
+    ) -> Result<(), crate::registry::ConstructionError> {
         let n = polynomials.len();
         if range_sets.len() != n {
             return Err(format!(
                 "polynomials has {n} entries but range_sets has {} entries; lengths must match",
                 range_sets.len()
-            ));
+            )
+            .into());
         }
         for (i, m) in range_sets.iter().enumerate() {
             if m.is_empty() {
-                return Err(format!("range_sets[{i}] must be non-empty"));
+                return Err(format!("range_sets[{i}] must be non-empty").into());
             }
         }
         // Each factor must have length n+1 (constant + one coefficient per player).
@@ -110,7 +105,7 @@ impl EquilibriumPoint {
                     return Err(format!(
                         "polynomials[{i}][{j}] has {} coefficients but expected {expected_factor_len} (1 + num_players)",
                         factor.len()
-                    ));
+                    ).into());
                 }
             }
         }
@@ -118,7 +113,10 @@ impl EquilibriumPoint {
     }
 
     /// Create a new `EquilibriumPoint` instance, returning an error on invalid input.
-    pub fn new(polynomials: Vec<Vec<Vec<i64>>>, range_sets: Vec<Vec<i64>>) -> Result<Self, String> {
+    pub fn new(
+        polynomials: Vec<Vec<Vec<i64>>>,
+        range_sets: Vec<Vec<i64>>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate_inputs(&polynomials, &range_sets)?;
         Ok(Self {
             polynomials,
@@ -144,21 +142,37 @@ impl EquilibriumPoint {
     /// Evaluate F_i at a given assignment y (as i64 slice).
     ///
     /// Returns the product of all affine factors for player i.
-    fn eval_payoff(&self, player: usize, assignment: &[i64]) -> i64 {
+    fn eval_payoff(
+        &self,
+        player: usize,
+        assignment: &[i64],
+    ) -> Result<i64, crate::traits::EvaluationError> {
         let factors = &self.polynomials[player];
         if factors.is_empty() {
-            return 0;
+            return Ok(0);
         }
-        factors.iter().fold(1i64, |prod, coeffs| {
-            // coeffs[0] + coeffs[1]*y_1 + ... + coeffs[n]*y_n
-            let val: i64 = coeffs[0]
-                + coeffs[1..]
-                    .iter()
-                    .zip(assignment.iter())
-                    .map(|(&c, &y)| c * y)
-                    .sum::<i64>();
-            prod * val
-        })
+        let mut product = 1_i64;
+        for coeffs in factors {
+            let mut value = coeffs[0];
+            for (&coefficient, &strategy) in coeffs[1..].iter().zip(assignment.iter()) {
+                let term = coefficient.checked_mul(strategy).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "multiplying equilibrium payoff coefficient by strategy".to_string(),
+                    )
+                })?;
+                value = value.checked_add(term).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing equilibrium payoff factor".to_string(),
+                    )
+                })?;
+            }
+            product = product.checked_mul(value).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "multiplying equilibrium payoff factors".to_string(),
+                )
+            })?;
+        }
+        Ok(product)
     }
 }
 
@@ -180,58 +194,61 @@ impl<'de> Deserialize<'de> for EquilibriumPoint {
 
 impl Problem for EquilibriumPoint {
     const NAME: &'static str = "EquilibriumPoint";
+    type Solution = Vec<i64>;
     type Value = Or;
 
+    crate::problem_parameters![("num_players", num_players),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        self.range_sets.iter().map(|m| m.len()).collect()
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Or {
-        let n = self.num_players();
-        if config.len() != n {
-            return Or(false);
-        }
-        // Validate config indices are in-bounds.
-        for (i, &idx) in config.iter().enumerate() {
-            if idx >= self.range_sets[i].len() {
-                return Or(false);
+    fn evaluate(&self, solution: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            let n = self.num_players();
+            if solution.len() != n {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    format!("expected {n} player choices, got {}", solution.len()),
+                ));
+            }
+            if solution
+                .iter()
+                .zip(&self.range_sets)
+                .any(|(value, range)| !range.contains(value))
+            {
+                return Ok(Or(false));
             }
-        }
-
-        // Extract assignment y_i = range_sets[i][config[i]].
-        let assignment: Vec<i64> = config
-            .iter()
-            .enumerate()
-            .map(|(i, &idx)| self.range_sets[i][idx])
-            .collect();
 
-        // Check best-response condition for each player.
-        for i in 0..n {
-            let current_payoff = self.eval_payoff(i, &assignment);
-            // Try every y' in M_i for player i.
-            let mut best_response_satisfied = true;
-            for &alt in &self.range_sets[i] {
-                if alt == assignment[i] {
-                    continue;
+            // Check best-response condition for each player.
+            for i in 0..n {
+                let current_payoff = self.eval_payoff(i, solution)?;
+                // Try every y' in M_i for player i.
+                let mut best_response_satisfied = true;
+                for &alt in &self.range_sets[i] {
+                    if alt == solution[i] {
+                        continue;
+                    }
+                    // Build alternative assignment with player i using alt.
+                    let mut alt_assignment = solution.clone();
+                    alt_assignment[i] = alt;
+                    let alt_payoff = self.eval_payoff(i, &alt_assignment)?;
+                    if alt_payoff > current_payoff {
+                        best_response_satisfied = false;
+                        break;
+                    }
                 }
-                // Build alternative assignment with player i using alt.
-                let mut alt_assignment = assignment.clone();
-                alt_assignment[i] = alt;
-                let alt_payoff = self.eval_payoff(i, &alt_assignment);
-                if alt_payoff > current_payoff {
-                    best_response_satisfied = false;
-                    break;
+                if !best_response_satisfied {
+                    return Ok(Or(false));
                 }
             }
-            if !best_response_satisfied {
-                return Or(false);
-            }
-        }
-        Or(true)
+            Or(true)
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for EquilibriumPoint {
+    fn dimensions(&self) -> Vec<usize> {
+        self.range_sets.iter().map(|m| m.len()).collect()
     }
 }
 
@@ -239,6 +256,10 @@ crate::declare_variants! {
     default EquilibriumPoint => "2^num_players",
 }
 
+crate::register_brute_force! {
+    EquilibriumPoint decode |problem: &EquilibriumPoint, indices: Vec<usize>| indices.into_iter().enumerate().map(|(player, choice)| problem.range_sets[player][choice]).collect(),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 3 players, M_i = {0, 1} for all i.
@@ -260,7 +281,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "equilibrium_point",
         instance: Box::new(EquilibriumPoint::new(polynomials, range_sets).unwrap()),
-        optimal_config: vec![0, 1, 0],
+        optimal_config: serde_json::json!(vec![0, 1, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/algebraic/feasible_basis_extension.rs b/src/models/algebraic/feasible_basis_extension.rs
index d80cc1ac9..88396d820 100644
--- a/src/models/algebraic/feasible_basis_extension.rs
+++ b/src/models/algebraic/feasible_basis_extension.rs
@@ -7,7 +7,7 @@
 //!
 //! NP-complete (Murty, 1972).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -17,13 +17,10 @@ inventory::submit! {
         display_name: "Feasible Basis Extension",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Given matrix A, vector a_bar, and required columns S, find a feasible basis extending S",
-        fields: &[
-            FieldInfo { name: "matrix", type_name: "Vec<Vec<i64>>", description: "m x n integer matrix A (row-major)" },
-            FieldInfo { name: "rhs", type_name: "Vec<i64>", description: "Column vector a_bar of length m" },
-            FieldInfo { name: "required_columns", type_name: "Vec<usize>", description: "Subset S of column indices that must be in the basis" },
-        ],
+        fields: FeasibleBasisExtensionCreateSpec::FIELDS,
     }
 }
 
@@ -45,7 +42,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::FeasibleBasisExtension;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let matrix = vec![
 ///     vec![1, 0, 1, 2, -1, 0],
@@ -56,7 +53,7 @@ inventory::submit! {
 /// let required = vec![0, 1];
 /// let problem = FeasibleBasisExtension::new(matrix, rhs, required);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -66,6 +63,57 @@ pub struct FeasibleBasisExtension {
     required_columns: Vec<usize>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct FeasibleBasisExtensionCreateSpec {
+    /// Integer matrix as JSON.
+    #[create(codec = "json")]
+    matrix: Vec<Vec<i64>>,
+    /// Right-hand side vector.
+    #[create(codec = "comma-separated")]
+    rhs: Vec<i64>,
+    /// Required column indices.
+    #[create(codec = "comma-separated")]
+    required_columns: Vec<usize>,
+}
+
+impl TryFrom<FeasibleBasisExtensionCreateSpec> for FeasibleBasisExtension {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: FeasibleBasisExtensionCreateSpec) -> Result<Self, Self::Error> {
+        let m = spec.matrix.len();
+        let first = spec
+            .matrix
+            .first()
+            .ok_or("matrix must have at least one row")?;
+        let n = first.len();
+        if spec.matrix.iter().any(|row| row.len() != n) {
+            return Err("all matrix rows must have the same length".into());
+        }
+        if m >= n {
+            return Err("number of rows must be less than number of columns".into());
+        }
+        if spec.rhs.len() != m {
+            return Err("rhs length must equal number of rows".into());
+        }
+        if spec.required_columns.len() >= m {
+            return Err("required_columns length must be less than number of rows".into());
+        }
+        let mut seen = std::collections::HashSet::new();
+        for &column in &spec.required_columns {
+            if column >= n {
+                return Err(format!("required column {column} is out of bounds").into());
+            }
+            if !seen.insert(column) {
+                return Err(format!("duplicate required column {column}").into());
+            }
+        }
+        Ok(Self {
+            matrix: spec.matrix,
+            rhs: spec.rhs,
+            required_columns: spec.required_columns,
+        })
+    }
+}
+
 impl FeasibleBasisExtension {
     /// Create a new FeasibleBasisExtension instance.
     ///
@@ -165,51 +213,84 @@ impl FeasibleBasisExtension {
     /// Uses exact rational arithmetic via integer Gaussian elimination with
     /// numerator/denominator tracking to avoid floating-point errors.
     #[allow(clippy::needless_range_loop)]
-    fn check_feasible_basis(&self, basis_cols: &[usize]) -> bool {
+    fn check_feasible_basis(
+        &self,
+        basis_cols: &[usize],
+    ) -> Result<bool, crate::traits::EvaluationError> {
         let m = self.num_rows();
         assert_eq!(basis_cols.len(), m);
 
-        // Build augmented matrix [A_B | a_bar] in i128 to avoid overflow
-        // during Bareiss fraction-free Gaussian elimination.
-        let mut aug128: Vec<Vec<i128>> = Vec::with_capacity(m);
+        // Build augmented matrix [A_B | a_bar] for Bareiss elimination.
+        let mut augmented: Vec<Vec<i64>> = Vec::with_capacity(m);
         for i in 0..m {
             let mut row = Vec::with_capacity(m + 1);
             for &col in basis_cols {
-                row.push(self.matrix[i][col] as i128);
+                row.push(self.matrix[i][col]);
             }
-            row.push(self.rhs[i] as i128);
-            aug128.push(row);
+            row.push(self.rhs[i]);
+            augmented.push(row);
         }
 
         // Bareiss algorithm: fraction-free Gaussian elimination.
         // After elimination, the system is upper-triangular.
-        let mut prev_pivot = 1i128;
+        let mut prev_pivot = 1_i64;
 
         for k in 0..m {
             // Partial pivoting
             let mut max_row = k;
-            let mut max_val = aug128[k][k].abs();
+            let mut max_val = augmented[k][k].checked_abs().ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "taking an elimination pivot magnitude".into(),
+                )
+            })?;
             for i in (k + 1)..m {
-                if aug128[i][k].abs() > max_val {
-                    max_val = aug128[i][k].abs();
+                let candidate = augmented[i][k].checked_abs().ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "taking an elimination candidate magnitude".into(),
+                    )
+                })?;
+                if candidate > max_val {
+                    max_val = candidate;
                     max_row = i;
                 }
             }
             if max_val == 0 {
-                return false; // singular
+                return Ok(false); // singular
             }
             if max_row != k {
-                aug128.swap(k, max_row);
+                augmented.swap(k, max_row);
             }
 
             for i in (k + 1)..m {
                 for j in (k + 1)..=m {
-                    aug128[i][j] =
-                        (aug128[k][k] * aug128[i][j] - aug128[i][k] * aug128[k][j]) / prev_pivot;
+                    let left = augmented[k][k]
+                        .checked_mul(augmented[i][j])
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "multiplying Bareiss pivot and row entry".into(),
+                            )
+                        })?;
+                    let right = augmented[i][k]
+                        .checked_mul(augmented[k][j])
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "multiplying Bareiss elimination entries".into(),
+                            )
+                        })?;
+                    let numerator = left.checked_sub(right).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "subtracting Bareiss products".into(),
+                        )
+                    })?;
+                    augmented[i][j] = numerator.checked_div(prev_pivot).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "dividing by the previous Bareiss pivot".into(),
+                        )
+                    })?;
                 }
-                aug128[i][k] = 0;
+                augmented[i][k] = 0;
             }
-            prev_pivot = aug128[k][k];
+            prev_pivot = augmented[k][k];
         }
 
         // Back-substitution to solve. We solve in rational form: x_i = num_i / det.
@@ -220,38 +301,92 @@ impl FeasibleBasisExtension {
         // x[i] = (aug128[i][m] - sum_{j>i} aug128[i][j] * x[j]) / aug128[i][i]
         // We track x[i] as (numerator, denominator) pairs.
 
-        let mut x_nums = vec![0i128; m];
-        let mut x_dens = vec![1i128; m];
+        let mut x_nums = vec![0_i64; m];
+        let mut x_dens = vec![1_i64; m];
 
         for i in (0..m).rev() {
             // numerator of (aug128[i][m] - sum_{j>i} aug128[i][j] * x[j])
-            let mut num = aug128[i][m];
-            let mut den = 1i128;
+            let mut num = augmented[i][m];
+            let mut den = 1_i64;
 
             for j in (i + 1)..m {
                 // subtract aug128[i][j] * (x_nums[j] / x_dens[j])
                 // num/den - aug128[i][j] * x_nums[j] / x_dens[j]
                 // = (num * x_dens[j] - den * aug128[i][j] * x_nums[j]) / (den * x_dens[j])
-                let a = aug128[i][j];
-                num = num * x_dens[j] - den * a * x_nums[j];
-                den *= x_dens[j];
+                let left = num.checked_mul(x_dens[j]).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "multiplying basis-solution numerator".into(),
+                    )
+                })?;
+                let right = den
+                    .checked_mul(augmented[i][j])
+                    .and_then(|value| value.checked_mul(x_nums[j]))
+                    .ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "multiplying basis-solution subtraction term".into(),
+                        )
+                    })?;
+                num = left.checked_sub(right).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "subtracting basis-solution terms".into(),
+                    )
+                })?;
+                den = den.checked_mul(x_dens[j]).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "multiplying basis-solution denominators".into(),
+                    )
+                })?;
                 // Simplify to avoid overflow
-                let g = gcd_i128(num.abs(), den.abs());
+                let g = gcd_i64(
+                    num.checked_abs().ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "taking basis-solution numerator magnitude".into(),
+                        )
+                    })?,
+                    den.checked_abs().ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "taking basis-solution denominator magnitude".into(),
+                        )
+                    })?,
+                );
                 if g > 1 {
                     num /= g;
                     den /= g;
                 }
             }
             // x[i] = (num/den) / aug128[i][i] = num / (den * aug128[i][i])
-            let diag = aug128[i][i];
+            let diag = augmented[i][i];
             x_nums[i] = num;
-            x_dens[i] = den * diag;
+            x_dens[i] = den.checked_mul(diag).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "multiplying basis-solution denominator by diagonal".into(),
+                )
+            })?;
             // Normalize sign: make denominator positive
             if x_dens[i] < 0 {
-                x_nums[i] = -x_nums[i];
-                x_dens[i] = -x_dens[i];
+                x_nums[i] = x_nums[i].checked_neg().ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "normalizing basis-solution numerator sign".into(),
+                    )
+                })?;
+                x_dens[i] = x_dens[i].checked_neg().ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "normalizing basis-solution denominator sign".into(),
+                    )
+                })?;
             }
-            let g = gcd_i128(x_nums[i].abs(), x_dens[i].abs());
+            let g = gcd_i64(
+                x_nums[i].checked_abs().ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "taking normalized numerator magnitude".into(),
+                    )
+                })?,
+                x_dens[i].checked_abs().ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "taking normalized denominator magnitude".into(),
+                    )
+                })?,
+            );
             if g > 1 {
                 x_nums[i] /= g;
                 x_dens[i] /= g;
@@ -260,12 +395,12 @@ impl FeasibleBasisExtension {
 
         // Check x >= 0: each x_nums[i] / x_dens[i] >= 0
         // Since x_dens[i] > 0 (normalized), we need x_nums[i] >= 0
-        x_nums.iter().take(m).all(|&num| num >= 0)
+        Ok(x_nums.iter().take(m).all(|&num| num >= 0))
     }
 }
 
-/// Compute GCD of two i128 values.
-fn gcd_i128(mut a: i128, mut b: i128) -> i128 {
+/// Compute GCD of two nonnegative i64 values.
+fn gcd_i64(mut a: i64, mut b: i64) -> i64 {
     while b != 0 {
         let t = b;
         b = a % b;
@@ -276,53 +411,69 @@ fn gcd_i128(mut a: i128, mut b: i128) -> i128 {
 
 impl Problem for FeasibleBasisExtension {
     const NAME: &'static str = "FeasibleBasisExtension";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_rows", num_rows),
+        ("num_columns", num_columns),
+        ("num_required", num_required),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_columns() - self.num_required()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        let free_cols = self.free_columns();
-        let num_free = free_cols.len();
-
-        if config.len() != num_free {
-            return crate::types::Or(false);
-        }
-        if config.iter().any(|&v| v >= 2) {
-            return crate::types::Or(false);
-        }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            let free_cols = self.free_columns();
+            let num_free = free_cols.len();
+
+            if config.len() != num_free {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "free-column selection length does not match the matrix".into(),
+                ));
+            }
+            let m = self.num_rows();
+            let s = self.num_required();
+            let needed = m - s;
+
+            // Count selected free columns
+            let selected_free: Vec<usize> = config
+                .iter()
+                .enumerate()
+                .filter(|(_, &v)| v)
+                .map(|(i, _)| free_cols[i])
+                .collect();
+
+            if selected_free.len() != needed {
+                return Ok(crate::types::Or(false));
+            }
 
-        let m = self.num_rows();
-        let s = self.num_required();
-        let needed = m - s;
-
-        // Count selected free columns
-        let selected_free: Vec<usize> = config
-            .iter()
-            .enumerate()
-            .filter(|(_, &v)| v == 1)
-            .map(|(i, _)| free_cols[i])
-            .collect();
-
-        if selected_free.len() != needed {
-            return crate::types::Or(false);
-        }
+            // Form basis: required columns + selected free columns
+            let mut basis_cols: Vec<usize> = self.required_columns.clone();
+            basis_cols.extend_from_slice(&selected_free);
 
-        // Form basis: required columns + selected free columns
-        let mut basis_cols: Vec<usize> = self.required_columns.clone();
-        basis_cols.extend_from_slice(&selected_free);
+            crate::types::Or(self.check_feasible_basis(&basis_cols)?)
+        })
+    }
+}
 
-        crate::types::Or(self.check_feasible_basis(&basis_cols))
+impl crate::solvers::BruteForceProblem for FeasibleBasisExtension {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_columns() - self.num_required()]
     }
 }
 
 crate::declare_variants! {
-    default FeasibleBasisExtension => "2^num_columns * num_rows^3",
+    default FeasibleBasisExtension => "2^num_columns * num_rows^3" create FeasibleBasisExtensionCreateSpec,
+}
+
+crate::register_brute_force! {
+    FeasibleBasisExtension decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -339,7 +490,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![7, 5, 3],
             vec![0, 1],
         )),
-        optimal_config: vec![1, 0, 0, 0], // select col 2 (first free column)
+        optimal_config: serde_json::json!(vec![true, false, false, false]), // select col 2 (first free column)
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/algebraic/ilp.rs b/src/models/algebraic/ilp.rs
index adcb80d15..7f4111e35 100644
--- a/src/models/algebraic/ilp.rs
+++ b/src/models/algebraic/ilp.rs
@@ -1,16 +1,16 @@
-//! Integer Linear Programming (ILP) problem implementation.
+//! Integer Linear Programming (ILP) intermediate representation.
 //!
-//! ILP optimizes a linear objective over integer variables subject to linear constraints.
-//! This is a fundamental "hub" problem that many other NP-hard problems can be reduced to.
-//!
-//! The type parameter `V` determines the variable domain:
-//! - `ILP<bool>`: binary variables (0 or 1)
-//! - `ILP<i32>`: non-negative integer variables (0..2^31-1)
-
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
-use crate::traits::Problem;
-use crate::types::Extremum;
-use serde::{Deserialize, Serialize};
+//! ILP stores integer variables with explicit possibly-unbounded intervals,
+//! sparse linear constraints, and a linear objective. The type parameters
+//! select the integer variable domain and coefficient type independently.
+
+use crate::registry::{ConstructionError, FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::traits::{EvaluationError, Problem};
+use crate::types::{
+    i64_to_exact_f64, Extremum, NumericArithmeticError, NumericSize, WeightElement,
+};
+use serde::{Deserialize, Deserializer, Serialize};
+use std::fmt::Debug;
 use std::marker::PhantomData;
 
 inventory::submit! {
@@ -18,280 +18,623 @@ inventory::submit! {
         name: "ILP",
         display_name: "ILP",
         aliases: &[],
-        dimensions: &[VariantDimension::new("variable", "bool", &["bool", "i32"])],
+        dimensions: &[
+            VariantDimension::new("variable", "bool", &["bool", "i64"]),
+            VariantDimension::new("coefficient", "i64", &["i64", "f64"]),
+        ],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
-        description: "Optimize linear objective subject to linear constraints",
+        description: "Optimize a linear objective over bounded or unbounded integer variables",
         fields: &[
-            FieldInfo { name: "num_vars", type_name: "usize", description: "Number of integer variables" },
-            FieldInfo { name: "constraints", type_name: "Vec<LinearConstraint>", description: "Linear constraints" },
-            FieldInfo { name: "objective", type_name: "Vec<(usize, f64)>", description: "Sparse objective coefficients" },
+            FieldInfo { name: "variables", type_name: "Vec<IntegerVariable>", description: "Integer variable bounds; null means an unbounded side" },
+            FieldInfo { name: "constraints", type_name: "Vec<LinearConstraint<C>>", description: "Sparse finite linear constraints" },
+            FieldInfo { name: "objective", type_name: "Vec<(usize, C)>", description: "Sparse finite objective coefficients" },
             FieldInfo { name: "sense", type_name: "ObjectiveSense", description: "Optimization direction" },
         ],
     }
 }
 
-/// Sealed trait for ILP variable domains.
-///
-/// `bool` = binary variables (0 or 1), `i32` = non-negative integers (0..2^31-1).
-pub trait VariableDomain: 'static + Clone + std::fmt::Debug + Send + Sync {
-    /// Number of possible values per variable (used by `dims()`).
-    const DIMS_PER_VAR: usize;
-    /// Name for the variant system (e.g., "bool", "i32").
+/// Static certificate for a homogeneous ILP variable domain.
+pub trait VariableDomain: 'static + Clone + Debug + Send + Sync {
+    /// Name used by the registered variant dimension.
     const NAME: &'static str;
+
+    /// Default stored variable used by homogeneous formulations.
+    fn default_variable() -> IntegerVariable;
+
+    /// Validate that stored bounds satisfy this static certificate.
+    fn validate_variables(variables: &[IntegerVariable]) -> Result<(), ConstructionError>;
+}
+
+/// Numeric domain shared by an ILP's constraints, right-hand sides, and objective.
+pub trait ILPCoefficient:
+    NumericSize + WeightElement<Sum = Self> + Copy + Debug + Send + Sync
+{
+    /// Name used by the registered variant dimension.
+    const NAME: &'static str;
+
+    /// Convert an integer variable value into this coefficient domain.
+    fn from_integer(value: i64) -> Result<Self, EvaluationError>;
+
+    /// Compare a finite evaluated row with its right-hand side.
+    fn satisfies(lhs: Self, comparison: Comparison, rhs: Self) -> bool;
+}
+
+impl ILPCoefficient for i64 {
+    const NAME: &'static str = "i64";
+
+    fn from_integer(value: i64) -> Result<Self, EvaluationError> {
+        Ok(value)
+    }
+
+    fn satisfies(lhs: Self, comparison: Comparison, rhs: Self) -> bool {
+        match comparison {
+            Comparison::Le => lhs <= rhs,
+            Comparison::Ge => lhs >= rhs,
+            Comparison::Eq => lhs == rhs,
+        }
+    }
+}
+
+impl ILPCoefficient for f64 {
+    const NAME: &'static str = "f64";
+
+    fn from_integer(value: i64) -> Result<Self, EvaluationError> {
+        i64_to_exact_f64(value).map_err(|_| {
+            EvaluationError::InexactFloatConversion(
+                "transporting an integer variable into an f64 ILP expression".into(),
+            )
+        })
+    }
+
+    fn satisfies(lhs: Self, comparison: Comparison, rhs: Self) -> bool {
+        let tolerance = 1e-9 * lhs.abs().max(rhs.abs()).max(1.0);
+        match comparison {
+            Comparison::Le => lhs <= rhs + tolerance,
+            Comparison::Ge => lhs >= rhs - tolerance,
+            Comparison::Eq => (lhs - rhs).abs() <= tolerance,
+        }
+    }
 }
 
 impl VariableDomain for bool {
-    const DIMS_PER_VAR: usize = 2;
     const NAME: &'static str = "bool";
+
+    fn default_variable() -> IntegerVariable {
+        IntegerVariable::binary()
+    }
+
+    fn validate_variables(variables: &[IntegerVariable]) -> Result<(), ConstructionError> {
+        if variables
+            .iter()
+            .any(|variable| variable.lower_bound != Some(0) || variable.upper_bound != Some(1))
+        {
+            return Err(ConstructionError::Conversion(
+                "binary ILP variables must have bounds [0, 1]".into(),
+            ));
+        }
+        Ok(())
+    }
 }
 
-impl VariableDomain for i32 {
-    const DIMS_PER_VAR: usize = (i32::MAX as usize) + 1;
-    const NAME: &'static str = "i32";
+impl VariableDomain for i64 {
+    const NAME: &'static str = "i64";
+
+    fn default_variable() -> IntegerVariable {
+        IntegerVariable::nonnegative()
+    }
+
+    fn validate_variables(_variables: &[IntegerVariable]) -> Result<(), ConstructionError> {
+        Ok(())
+    }
+}
+
+/// Bounds of one mathematical integer variable.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
+pub struct IntegerVariable {
+    lower_bound: Option<i64>,
+    upper_bound: Option<i64>,
 }
 
-/// Comparison operator for linear constraints.
+impl<'de> Deserialize<'de> for IntegerVariable {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Bounds {
+            lower_bound: Option<i64>,
+            upper_bound: Option<i64>,
+        }
+
+        let bounds = Bounds::deserialize(deserializer)?;
+        Self::new(bounds.lower_bound, bounds.upper_bound).map_err(serde::de::Error::custom)
+    }
+}
+
+impl IntegerVariable {
+    /// Construct an integer variable. `None` denotes the corresponding
+    /// infinite bound.
+    pub fn new(
+        lower_bound: Option<i64>,
+        upper_bound: Option<i64>,
+    ) -> Result<Self, ConstructionError> {
+        if lower_bound
+            .zip(upper_bound)
+            .is_some_and(|(lower, upper)| lower > upper)
+        {
+            return Err(ConstructionError::Conversion(
+                "integer variable lower bound exceeds its upper bound".into(),
+            ));
+        }
+        Ok(Self {
+            lower_bound,
+            upper_bound,
+        })
+    }
+
+    /// A binary integer variable in `[0, 1]`.
+    pub const fn binary() -> Self {
+        Self {
+            lower_bound: Some(0),
+            upper_bound: Some(1),
+        }
+    }
+
+    /// A non-negative integer variable in `[0, +∞)`.
+    pub const fn nonnegative() -> Self {
+        Self {
+            lower_bound: Some(0),
+            upper_bound: None,
+        }
+    }
+
+    /// A free integer variable in `(-∞, +∞)`.
+    pub const fn free() -> Self {
+        Self {
+            lower_bound: None,
+            upper_bound: None,
+        }
+    }
+
+    /// Finite lower bound, or `None` for negative infinity.
+    pub const fn lower_bound(self) -> Option<i64> {
+        self.lower_bound
+    }
+
+    /// Finite upper bound, or `None` for positive infinity.
+    pub const fn upper_bound(self) -> Option<i64> {
+        self.upper_bound
+    }
+
+    /// Whether a mathematical value belongs to this interval.
+    pub fn contains(self, value: i64) -> bool {
+        self.lower_bound.is_none_or(|lower| value >= lower)
+            && self.upper_bound.is_none_or(|upper| value <= upper)
+    }
+}
+
+/// Comparison operator for a linear constraint.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum Comparison {
-    /// Less than or equal (<=).
+    /// Less than or equal (`<=`).
     Le,
-    /// Greater than or equal (>=).
+    /// Greater than or equal (`>=`).
     Ge,
-    /// Equal (==).
+    /// Equal (`==`).
     Eq,
 }
 
-impl Comparison {
-    /// Check if the comparison holds between lhs and rhs.
-    pub fn holds(&self, lhs: f64, rhs: f64) -> bool {
-        match self {
-            Comparison::Le => lhs <= rhs,
-            Comparison::Ge => lhs >= rhs,
-            Comparison::Eq => (lhs - rhs).abs() < 1e-9,
-        }
-    }
-}
-
-/// A linear constraint: sum of (coefficient * variable) {<=, >=, ==} rhs.
-///
-/// The constraint is represented sparsely: only non-zero coefficients are stored.
+/// One sparse linear constraint.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct LinearConstraint {
-    /// Sparse representation: (var_index, coefficient) pairs.
-    pub terms: Vec<(usize, f64)>,
-    /// Comparison operator.
-    pub cmp: Comparison,
-    /// Right-hand side constant.
-    pub rhs: f64,
+pub struct LinearConstraint<C = i64> {
+    terms: Vec<(usize, C)>,
+    comparison: Comparison,
+    rhs: C,
 }
 
-impl LinearConstraint {
-    /// Create a new linear constraint.
-    pub(crate) fn new(terms: Vec<(usize, f64)>, cmp: Comparison, rhs: f64) -> Self {
-        Self { terms, cmp, rhs }
+impl<C> LinearConstraint<C> {
+    fn new(terms: Vec<(usize, C)>, comparison: Comparison, rhs: C) -> Self {
+        Self {
+            terms,
+            comparison,
+            rhs,
+        }
     }
 
     /// Create a less-than-or-equal constraint.
-    pub fn le(terms: Vec<(usize, f64)>, rhs: f64) -> Self {
+    pub fn le(terms: Vec<(usize, C)>, rhs: C) -> Self {
         Self::new(terms, Comparison::Le, rhs)
     }
 
     /// Create a greater-than-or-equal constraint.
-    pub fn ge(terms: Vec<(usize, f64)>, rhs: f64) -> Self {
+    pub fn ge(terms: Vec<(usize, C)>, rhs: C) -> Self {
         Self::new(terms, Comparison::Ge, rhs)
     }
 
     /// Create an equality constraint.
-    pub fn eq(terms: Vec<(usize, f64)>, rhs: f64) -> Self {
+    pub fn eq(terms: Vec<(usize, C)>, rhs: C) -> Self {
         Self::new(terms, Comparison::Eq, rhs)
     }
 
-    /// Evaluate the left-hand side of the constraint for given variable values.
-    pub fn evaluate_lhs(&self, values: &[i64]) -> f64 {
-        self.terms
-            .iter()
-            .map(|&(var, coef)| coef * values.get(var).copied().unwrap_or(0) as f64)
-            .sum()
+    /// Canonical sparse row terms.
+    pub fn terms(&self) -> &[(usize, C)] {
+        &self.terms
     }
 
-    /// Check if the constraint is satisfied by given variable values.
-    pub fn is_satisfied(&self, values: &[i64]) -> bool {
-        let lhs = self.evaluate_lhs(values);
-        self.cmp.holds(lhs, self.rhs)
+    /// Row comparison operator.
+    pub const fn comparison(&self) -> Comparison {
+        self.comparison
+    }
+
+    /// Row right-hand side.
+    pub fn variables(&self) -> impl Iterator<Item = usize> + '_ {
+        self.terms.iter().map(|&(variable, _)| variable)
+    }
+}
+
+impl<C: ILPCoefficient> LinearConstraint<C> {
+    /// Stored right-hand side.
+    pub fn rhs(&self) -> C {
+        self.rhs
+    }
+
+    /// Evaluate the left-hand side in the coefficient domain.
+    pub fn evaluate_lhs(&self, values: &[i64]) -> Result<C, EvaluationError> {
+        self.terms
+            .iter()
+            .try_fold(C::zero(), |sum, &(variable, coefficient)| {
+                let value = values.get(variable).copied().ok_or_else(|| {
+                    EvaluationError::InvalidConfiguration(format!(
+                        "an ILP constraint references variable {variable}, but the assignment has {} values",
+                        values.len()
+                    ))
+                })?;
+                let value = C::from_integer(value)?;
+                let product = C::checked_mul_sum(
+                    coefficient,
+                    value,
+                    "multiplying a term in an ILP constraint",
+                )?;
+                C::checked_add_to_sum(sum, product, "summing an ILP constraint")
+            })
     }
 
-    /// Get the set of variable indices involved in this constraint.
-    pub fn variables(&self) -> Vec<usize> {
-        self.terms.iter().map(|&(var, _)| var).collect()
+    /// Check whether this row is satisfied.
+    pub fn is_satisfied(&self, values: &[i64]) -> Result<bool, EvaluationError> {
+        let lhs = self.evaluate_lhs(values)?;
+        Ok(C::satisfies(lhs, self.comparison, self.rhs))
     }
 }
 
-/// Optimization direction for the ILP.
+/// Optimization direction.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum ObjectiveSense {
-    /// Maximize the objective function.
+    /// Maximize the objective.
     Maximize,
-    /// Minimize the objective function.
+    /// Minimize the objective.
     Minimize,
 }
 
-/// Integer Linear Programming (ILP) problem.
-///
-/// An ILP consists of:
-/// - A set of integer variables with a domain determined by `V`
-/// - Linear constraints on those variables
-/// - A linear objective function to optimize
-/// - An optimization sense (maximize or minimize)
-///
-/// # Type Parameter
-///
-/// - `V = bool`: binary variables (0 or 1)
-/// - `V = i32`: non-negative integer variables
-///
-/// # Example
-///
-/// ```
-/// use problemreductions::models::algebraic::{ILP, LinearConstraint, ObjectiveSense};
-/// use problemreductions::Problem;
-///
-/// // Create a simple binary ILP: maximize x0 + 2*x1
-/// // subject to: x0 + x1 <= 3, x0, x1 binary
-/// let ilp = ILP::<bool>::new(
-///     2,
-///     vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 3.0)],
-///     vec![(0, 1.0), (1, 2.0)],
-///     ObjectiveSense::Maximize,
-/// );
-///
-/// assert_eq!(ilp.num_variables(), 2);
-/// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(bound(serialize = "", deserialize = ""))]
-pub struct ILP<V: VariableDomain = bool> {
-    /// Number of variables.
-    pub num_vars: usize,
-    /// Linear constraints.
-    pub constraints: Vec<LinearConstraint>,
-    /// Sparse objective coefficients: (var_index, coefficient).
-    pub objective: Vec<(usize, f64)>,
-    /// Optimization direction.
-    pub sense: ObjectiveSense,
+/// Integer Linear Programming model.
+#[derive(Debug, Clone, Serialize)]
+pub struct ILP<V: VariableDomain = bool, C: ILPCoefficient = i64> {
+    variables: Vec<IntegerVariable>,
+    constraints: Vec<LinearConstraint<C>>,
+    objective: Vec<(usize, C)>,
+    sense: ObjectiveSense,
     #[serde(skip)]
-    _marker: PhantomData<V>,
+    marker: PhantomData<V>,
+}
+
+#[derive(Deserialize)]
+struct ILPData<C> {
+    variables: Vec<IntegerVariable>,
+    constraints: Vec<LinearConstraint<C>>,
+    objective: Vec<(usize, C)>,
+    sense: ObjectiveSense,
 }
 
-impl<V: VariableDomain> ILP<V> {
-    /// Create a new ILP problem.
+impl<'de, V, C> Deserialize<'de> for ILP<V, C>
+where
+    V: VariableDomain,
+    C: ILPCoefficient + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let data = ILPData::<C>::deserialize(deserializer)?;
+        Self::with_variables(data.variables, data.constraints, data.objective, data.sense)
+            .map_err(serde::de::Error::custom)
+    }
+}
+
+impl<V: VariableDomain, C: ILPCoefficient> ILP<V, C> {
+    /// Construct a homogeneous model using the domain certificate's standard
+    /// variable interval: binary `[0, 1]` or integer `[0, +∞)`.
     pub fn new(
-        num_vars: usize,
-        constraints: Vec<LinearConstraint>,
-        objective: Vec<(usize, f64)>,
+        num_variables: usize,
+        constraints: Vec<LinearConstraint<C>>,
+        objective: Vec<(usize, C)>,
         sense: ObjectiveSense,
-    ) -> Self {
-        Self {
-            num_vars,
+    ) -> Result<Self, ConstructionError> {
+        Self::with_variables(
+            vec![V::default_variable(); num_variables],
             constraints,
             objective,
             sense,
-            _marker: PhantomData,
-        }
+        )
+    }
+
+    /// Construct a model with explicit possibly-unbounded variable intervals.
+    pub fn with_variables(
+        variables: Vec<IntegerVariable>,
+        constraints: Vec<LinearConstraint<C>>,
+        objective: Vec<(usize, C)>,
+        sense: ObjectiveSense,
+    ) -> Result<Self, ConstructionError> {
+        V::validate_variables(&variables)?;
+        let num_variables = variables.len();
+        let constraints = constraints
+            .into_iter()
+            .enumerate()
+            .map(|(index, constraint)| normalize_constraint(constraint, num_variables, index))
+            .collect::<Result<_, _>>()?;
+        let objective = normalize_objective(objective, num_variables)?;
+        Ok(Self {
+            variables,
+            constraints,
+            objective,
+            sense,
+            marker: PhantomData,
+        })
     }
 
-    /// Create an empty ILP with no variables.
+    /// Empty model.
     pub fn empty() -> Self {
         Self::new(0, vec![], vec![], ObjectiveSense::Minimize)
+            .expect("the empty ILP satisfies all construction invariants")
     }
 
-    /// Evaluate the objective function for given variable values.
-    pub fn evaluate_objective(&self, values: &[i64]) -> f64 {
-        self.objective
-            .iter()
-            .map(|&(var, coef)| coef * values.get(var).copied().unwrap_or(0) as f64)
-            .sum()
+    /// Stored variables and their bounds.
+    pub fn variables(&self) -> &[IntegerVariable] {
+        &self.variables
     }
 
-    /// Check if all constraints are satisfied for given variable values.
-    pub fn constraints_satisfied(&self, values: &[i64]) -> bool {
-        self.constraints.iter().all(|c| c.is_satisfied(values))
+    /// Canonical sparse constraints.
+    pub fn constraints(&self) -> &[LinearConstraint<C>] {
+        &self.constraints
     }
 
-    /// Check if a solution is feasible (satisfies constraints).
-    pub fn is_feasible(&self, values: &[i64]) -> bool {
-        values.len() == self.num_vars && self.constraints_satisfied(values)
+    /// Canonical sparse objective.
+    pub fn objective(&self) -> &[(usize, C)] {
+        &self.objective
     }
 
-    /// Convert a configuration (Vec<usize>) to integer values (Vec<i64>).
-    /// For bool: config 0→0, 1→1. For i32: config index = value.
-    fn config_to_values(&self, config: &[usize]) -> Vec<i64> {
-        config.iter().map(|&c| c as i64).collect()
+    /// Optimization direction.
+    pub const fn sense(&self) -> ObjectiveSense {
+        self.sense
     }
 
-    /// Get the number of variables.
+    /// Number of variables.
     pub fn num_variables(&self) -> usize {
-        self.num_vars
+        self.variables.len()
     }
 
-    /// Get the number of variables.
+    /// Canonical size getter alias.
     pub fn num_vars(&self) -> usize {
         self.num_variables()
     }
 
-    /// Get the number of constraints.
+    /// Number of constraints.
     pub fn num_constraints(&self) -> usize {
         self.constraints.len()
     }
+
+    /// Number of non-zero row coefficients.
+    pub fn num_nonzeros(&self) -> usize {
+        self.constraints
+            .iter()
+            .map(|constraint| constraint.terms.len())
+            .sum()
+    }
+
+    /// Evaluate the objective in the coefficient domain.
+    pub fn evaluate_objective(&self, values: &[i64]) -> Result<C, EvaluationError> {
+        self.objective
+            .iter()
+            .try_fold(C::zero(), |sum, &(variable, coefficient)| {
+                let integer = values.get(variable).copied().ok_or_else(|| {
+                    EvaluationError::InvalidConfiguration(format!(
+                        "the ILP objective references variable {variable}, but the assignment has {} values",
+                        values.len()
+                    ))
+                })?;
+                let value = C::from_integer(integer)?;
+                let product = C::checked_mul_sum(
+                    coefficient,
+                    value,
+                    "multiplying a term in the ILP objective",
+                )?;
+                C::checked_add_to_sum(
+                    sum,
+                    product,
+                    "summing the ILP objective",
+                )
+            })
+    }
+
+    /// Check stored variable intervals and all rows.
+    pub fn is_feasible(&self, values: &[i64]) -> Result<bool, EvaluationError> {
+        if values.len() != self.variables.len() {
+            return Err(EvaluationError::InvalidConfiguration(
+                "variable assignment length does not match the ILP".into(),
+            ));
+        }
+        if self
+            .variables
+            .iter()
+            .zip(values)
+            .any(|(&variable, &value)| !variable.contains(value))
+        {
+            return Ok(false);
+        }
+        for constraint in &self.constraints {
+            if !constraint.is_satisfied(values)? {
+                return Ok(false);
+            }
+        }
+        Ok(true)
+    }
 }
 
-impl<V: VariableDomain> Problem for ILP<V> {
-    const NAME: &'static str = "ILP";
-    type Value = Extremum<f64>;
+fn construction_arithmetic_error(
+    error: NumericArithmeticError,
+    context: String,
+) -> ConstructionError {
+    match error {
+        NumericArithmeticError::IntegerOverflow => ConstructionError::IntegerOverflow(context),
+        NumericArithmeticError::NonFiniteResult => ConstructionError::NonFiniteFloat(context),
+    }
+}
+
+fn normalize_constraint<C: ILPCoefficient>(
+    constraint: LinearConstraint<C>,
+    num_variables: usize,
+    constraint_index: usize,
+) -> Result<LinearConstraint<C>, ConstructionError> {
+    let mut terms = constraint.terms;
+    constraint
+        .rhs
+        .validate_element("ILP constraint right-hand side")?;
+    for &(variable, coefficient) in &terms {
+        if variable >= num_variables {
+            return Err(ConstructionError::Conversion(format!(
+                "ILP constraint {constraint_index} references variable {variable}, but the model has {num_variables} variables"
+            )));
+        }
+        coefficient.validate_element("ILP constraint coefficient")?;
+    }
+    terms.sort_by_key(|&(variable, _)| variable);
+    let mut normalized: Vec<(usize, C)> = Vec::with_capacity(terms.len());
+    for (variable, coefficient) in terms {
+        if let Some((previous_variable, previous_coefficient)) = normalized.last_mut() {
+            if *previous_variable == variable {
+                *previous_coefficient = previous_coefficient
+                    .checked_add_value(coefficient)
+                    .map_err(|error| {
+                        construction_arithmetic_error(
+                            error,
+                            format!(
+                        "merging duplicate variable {variable} in ILP constraint {constraint_index}"
+                    ),
+                        )
+                    })?;
+                continue;
+            }
+        }
+        normalized.push((variable, coefficient));
+    }
+    normalized.retain(|&(_, coefficient)| !coefficient.is_zero());
+    Ok(LinearConstraint::new(
+        normalized,
+        constraint.comparison,
+        constraint.rhs,
+    ))
+}
 
-    fn dims(&self) -> Vec<usize> {
-        vec![V::DIMS_PER_VAR; self.num_vars]
+fn normalize_objective<C: ILPCoefficient>(
+    mut objective: Vec<(usize, C)>,
+    num_variables: usize,
+) -> Result<Vec<(usize, C)>, ConstructionError> {
+    for &(variable, coefficient) in &objective {
+        if variable >= num_variables {
+            return Err(ConstructionError::Conversion(format!(
+                "ILP objective references variable {variable}, but the model has {num_variables} variables"
+            )));
+        }
+        coefficient.validate_element("ILP objective coefficient")?;
+    }
+    objective.sort_by_key(|&(variable, _)| variable);
+    let mut normalized: Vec<(usize, C)> = Vec::with_capacity(objective.len());
+    for (variable, coefficient) in objective {
+        if let Some((previous_variable, previous_coefficient)) = normalized.last_mut() {
+            if *previous_variable == variable {
+                *previous_coefficient = previous_coefficient
+                    .checked_add_value(coefficient)
+                    .map_err(|error| {
+                        construction_arithmetic_error(
+                            error,
+                            format!("merged objective coefficient of variable {variable}"),
+                        )
+                    })?;
+                continue;
+            }
+        }
+        normalized.push((variable, coefficient));
     }
+    normalized.retain(|&(_, coefficient)| !coefficient.is_zero());
+    Ok(normalized)
+}
 
-    fn evaluate(&self, config: &[usize]) -> Extremum<f64> {
-        let values = self.config_to_values(config);
-        if !self.is_feasible(&values) {
-            return match self.sense {
+impl<V: VariableDomain, C: ILPCoefficient> Problem for ILP<V, C> {
+    const NAME: &'static str = "ILP";
+    type Solution = Vec<i64>;
+    type Value = Extremum<C>;
+
+    crate::problem_parameters![
+        ("num_constraints", num_constraints),
+        ("num_nonzeros", num_nonzeros),
+        ("num_vars", num_vars),
+    ];
+
+    fn evaluate(&self, solution: &Self::Solution) -> Result<Self::Value, EvaluationError> {
+        if !self.is_feasible(solution)? {
+            return Ok(match self.sense {
                 ObjectiveSense::Maximize => Extremum::maximize(None),
                 ObjectiveSense::Minimize => Extremum::minimize(None),
-            };
+            });
         }
-        let objective = self.evaluate_objective(&values);
-        match self.sense {
+        let objective = self.evaluate_objective(solution)?;
+        Ok(match self.sense {
             ObjectiveSense::Maximize => Extremum::maximize(Some(objective)),
             ObjectiveSense::Minimize => Extremum::minimize(Some(objective)),
-        }
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
-        vec![("variable", V::NAME)]
+        vec![("variable", V::NAME), ("coefficient", C::NAME)]
     }
 }
 
 crate::declare_variants! {
-    default ILP<bool> => "2^num_vars",
-    ILP<i32> => "num_vars^num_vars",
+    default ILP<bool, i64> => "2^num_vars",
+    ILP<i64, i64> => "num_vars^num_vars",
+    ILP<bool, f64> => "2^num_vars",
+    ILP<i64, f64> => "num_vars^num_vars",
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "ilp_i32",
-        instance: Box::new(ILP::<i32>::new(
-            2,
-            vec![
-                LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 5.0),
-                LinearConstraint::le(vec![(0, 4.0), (1, 7.0)], 28.0),
-            ],
-            vec![(0, -5.0), (1, -6.0)],
-            ObjectiveSense::Minimize,
-        )),
-        optimal_config: vec![3, 2],
+        id: "ilp",
+        instance: Box::new(
+            ILP::<i64, i64>::new(
+                2,
+                vec![
+                    LinearConstraint::le(vec![(0, 1), (1, 1)], 5),
+                    LinearConstraint::le(vec![(0, 4), (1, 7)], 28),
+                ],
+                vec![(0, -5), (1, -6)],
+                ObjectiveSense::Minimize,
+            )
+            .expect("canonical ILP construction must succeed"),
+        ),
+        optimal_config: serde_json::json!(vec![3, 2]),
         optimal_value: serde_json::json!({
             "sense": "Minimize",
-            "value": -27.0,
+            "value": -27,
         }),
     }]
 }
diff --git a/src/models/algebraic/minimum_matrix_cover.rs b/src/models/algebraic/minimum_matrix_cover.rs
index 7aada4ce1..8df124c06 100644
--- a/src/models/algebraic/minimum_matrix_cover.rs
+++ b/src/models/algebraic/minimum_matrix_cover.rs
@@ -14,6 +14,7 @@ inventory::submit! {
         display_name: "Minimum Matrix Cover",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Find sign assignment minimizing quadratic form over nonnegative integer matrix",
         fields: &[
@@ -36,7 +37,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::MinimumMatrixCover;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = MinimumMatrixCover::new(vec![
 ///     vec![0, 3, 1, 0],
@@ -46,7 +47,7 @@ inventory::submit! {
 /// ]);
 ///
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem);
+/// let witness = solver.solve(&problem).unwrap();
 /// assert!(witness.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -87,37 +88,60 @@ impl MinimumMatrixCover {
 
 impl Problem for MinimumMatrixCover {
     const NAME: &'static str = "MinimumMatrixCover";
+    type Solution = Vec<bool>;
     type Value = Min<i64>;
 
+    crate::problem_parameters![("num_rows", num_rows),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_rows()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<i64> {
-        let n = self.num_rows();
-        if config.len() != n {
-            return Min(None);
-        }
-        if config.iter().any(|&v| v >= 2) {
-            return Min(None);
-        }
-
-        // Map config to signs: 0 → -1, 1 → +1
-        let signs: Vec<i64> = config.iter().map(|&x| 2 * x as i64 - 1).collect();
-
-        // Compute Σ_{i,j} a_ij * f(i) * f(j)
-        let mut value: i64 = 0;
-        for i in 0..n {
-            for j in 0..n {
-                value += self.matrix[i][j] * signs[i] * signs[j];
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let n = self.num_rows();
+            if config.len() != n {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "row-sign assignment length does not match the matrix".into(),
+                ));
             }
-        }
+            // Map config to signs: 0 → -1, 1 → +1
+            let signs: Vec<i64> = config
+                .iter()
+                .map(|&value| if value { 1 } else { -1 })
+                .collect();
+
+            // Compute Σ_{i,j} a_ij * f(i) * f(j)
+            let mut value: i64 = 0;
+            for i in 0..n {
+                for j in 0..n {
+                    let term = self.matrix[i][j]
+                        .checked_mul(signs[i])
+                        .and_then(|term| term.checked_mul(signs[j]))
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "multiplying matrix-cover objective term".into(),
+                            )
+                        })?;
+                    value = value.checked_add(term).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing matrix-cover objective".into(),
+                        )
+                    })?;
+                }
+            }
+
+            Min(Some(value))
+        })
+    }
+}
 
-        Min(Some(value))
+impl crate::solvers::BruteForceProblem for MinimumMatrixCover {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_rows()]
     }
 }
 
@@ -125,6 +149,10 @@ crate::declare_variants! {
     default MinimumMatrixCover => "2^num_rows",
 }
 
+crate::register_brute_force! {
+    MinimumMatrixCover decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 4×4 symmetric matrix with zero diagonal
@@ -137,7 +165,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![1, 0, 0, 4],
             vec![0, 2, 4, 0],
         ])),
-        optimal_config: vec![0, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![false, true, true, false]),
         optimal_value: serde_json::json!(-20),
     }]
 }
diff --git a/src/models/algebraic/minimum_matrix_domination.rs b/src/models/algebraic/minimum_matrix_domination.rs
index 49fc9a2ee..2b4aaf579 100644
--- a/src/models/algebraic/minimum_matrix_domination.rs
+++ b/src/models/algebraic/minimum_matrix_domination.rs
@@ -14,6 +14,7 @@ inventory::submit! {
         display_name: "Minimum Matrix Domination",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Find minimum subset of 1-entries in a binary matrix that dominates all other 1-entries by shared row or column",
         fields: &[
@@ -38,7 +39,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::MinimumMatrixDomination;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 3×3 identity matrix: 3 ones on the diagonal, no shared rows/cols
 /// let matrix = vec![
@@ -48,9 +49,9 @@ inventory::submit! {
 /// ];
 /// let problem = MinimumMatrixDomination::new(matrix);
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem);
+/// let witness = solver.solve(&problem).unwrap();
 /// // All 3 diagonal entries must be selected (no domination possible)
-/// assert_eq!(witness, Some(vec![1, 1, 1]));
+/// assert_eq!(witness, Some(vec![true, true, true]));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumMatrixDomination {
@@ -112,53 +113,69 @@ impl MinimumMatrixDomination {
 
 impl Problem for MinimumMatrixDomination {
     const NAME: &'static str = "MinimumMatrixDomination";
-    type Value = Min<usize>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_cols", num_cols),
+        ("num_ones", num_ones),
+        ("num_rows", num_rows),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_ones()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if config.len() != self.num_ones() {
-            return Min(None);
-        }
-        if config.iter().any(|&v| v >= 2) {
-            return Min(None);
-        }
-
-        // Collect the set of selected 1-entry indices
-        let selected: Vec<usize> = config
-            .iter()
-            .enumerate()
-            .filter(|(_, &v)| v == 1)
-            .map(|(i, _)| i)
-            .collect();
-
-        // Build sets of rows and columns covered by selected entries
-        let mut covered_rows = std::collections::HashSet::new();
-        let mut covered_cols = std::collections::HashSet::new();
-        for &idx in &selected {
-            let (r, c) = self.ones[idx];
-            covered_rows.insert(r);
-            covered_cols.insert(c);
-        }
-
-        // Check domination: every unselected 1-entry must share a row or
-        // column with some selected entry
-        for (k, &(r, c)) in self.ones.iter().enumerate() {
-            if config[k] == 1 {
-                continue; // selected entries don't need domination
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.num_ones() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "selected-entry vector length does not match the matrix".into(),
+                ));
             }
-            if !covered_rows.contains(&r) && !covered_cols.contains(&c) {
-                return Min(None); // not dominated
+            // Collect the set of selected 1-entry indices
+            let selected: Vec<usize> = config
+                .iter()
+                .enumerate()
+                .filter(|(_, &v)| v)
+                .map(|(i, _)| i)
+                .collect();
+
+            // Build sets of rows and columns covered by selected entries
+            let mut covered_rows = std::collections::HashSet::new();
+            let mut covered_cols = std::collections::HashSet::new();
+            for &idx in &selected {
+                let (r, c) = self.ones[idx];
+                covered_rows.insert(r);
+                covered_cols.insert(c);
             }
-        }
 
-        Min(Some(selected.len()))
+            // Check domination: every unselected 1-entry must share a row or
+            // column with some selected entry
+            for (k, &(r, c)) in self.ones.iter().enumerate() {
+                if config[k] {
+                    continue; // selected entries don't need domination
+                }
+                if !covered_rows.contains(&r) && !covered_cols.contains(&c) {
+                    return Ok(Min(None)); // not dominated
+                }
+            }
+
+            Min(Some(i64::try_from(selected.len()).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting matrix-domination cardinality to i64".into(),
+                )
+            })?))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MinimumMatrixDomination {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_ones()]
     }
 }
 
@@ -166,6 +183,10 @@ crate::declare_variants! {
     default MinimumMatrixDomination => "2^num_ones",
 }
 
+crate::register_brute_force! {
+    MinimumMatrixDomination decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // P6 adjacency matrix (6×6, 10 ones)
@@ -182,7 +203,9 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "minimum_matrix_domination",
         instance: Box::new(MinimumMatrixDomination::new(matrix)),
-        optimal_config: vec![1, 1, 0, 0, 0, 0, 1, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![
+            true, true, false, false, false, false, true, true, false, false
+        ]),
         optimal_value: serde_json::json!(4),
     }]
 }
diff --git a/src/models/algebraic/minimum_weight_decoding.rs b/src/models/algebraic/minimum_weight_decoding.rs
index a4c424200..6b17433ce 100644
--- a/src/models/algebraic/minimum_weight_decoding.rs
+++ b/src/models/algebraic/minimum_weight_decoding.rs
@@ -4,7 +4,7 @@
 //! vector s of length n, find a binary vector x of length m minimizing the
 //! Hamming weight |x| subject to Hx ≡ s (mod 2).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -15,12 +15,10 @@ inventory::submit! {
         display_name: "Minimum Weight Decoding",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Find minimum Hamming weight binary vector x such that Hx ≡ s (mod 2)",
-        fields: &[
-            FieldInfo { name: "matrix", type_name: "Vec<Vec<bool>>", description: "n×m binary parity-check matrix H" },
-            FieldInfo { name: "target", type_name: "Vec<bool>", description: "binary syndrome vector s of length n" },
-        ],
+        fields: MinimumWeightDecodingCreateSpec::FIELDS,
     }
 }
 
@@ -40,7 +38,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::MinimumWeightDecoding;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let matrix = vec![
 ///     vec![true, false, true, true],
@@ -50,7 +48,7 @@ inventory::submit! {
 /// let target = vec![true, true, false];
 /// let problem = MinimumWeightDecoding::new(matrix, target);
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem);
+/// let witness = solver.solve(&problem).unwrap();
 /// assert!(witness.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -61,6 +59,39 @@ pub struct MinimumWeightDecoding {
     target: Vec<bool>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumWeightDecodingCreateSpec {
+    /// Binary parity-check matrix as JSON.
+    #[create(codec = "json")]
+    matrix: Vec<Vec<bool>>,
+    /// Binary syndrome vector.
+    #[create(name = "rhs", codec = "comma-separated")]
+    target: Vec<bool>,
+}
+
+impl TryFrom<MinimumWeightDecodingCreateSpec> for MinimumWeightDecoding {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumWeightDecodingCreateSpec) -> Result<Self, Self::Error> {
+        let first = spec
+            .matrix
+            .first()
+            .ok_or("matrix must have at least one row")?;
+        if first.is_empty() {
+            return Err("matrix must have at least one column".into());
+        }
+        if spec.matrix.iter().any(|row| row.len() != first.len()) {
+            return Err("all matrix rows must have the same length".into());
+        }
+        if spec.target.len() != spec.matrix.len() {
+            return Err("rhs length must equal number of rows".into());
+        }
+        Ok(Self {
+            matrix: spec.matrix,
+            target: spec.target,
+        })
+    }
+}
+
 impl MinimumWeightDecoding {
     /// Create a new MinimumWeightDecoding instance.
     ///
@@ -106,45 +137,61 @@ impl MinimumWeightDecoding {
 
 impl Problem for MinimumWeightDecoding {
     const NAME: &'static str = "MinimumWeightDecoding";
-    type Value = Min<usize>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_cols", num_cols), ("num_rows", num_rows),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_cols()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if config.len() != self.num_cols() {
-            return Min(None);
-        }
-        if config.iter().any(|&v| v >= 2) {
-            return Min(None);
-        }
-
-        // Check Hx ≡ s (mod 2) for each row
-        for (i, row) in self.matrix.iter().enumerate() {
-            let dot: usize = row
-                .iter()
-                .zip(config.iter())
-                .filter(|(&h, &x)| h && x == 1)
-                .count();
-            let syndrome_bit = dot % 2 == 1;
-            if syndrome_bit != self.target[i] {
-                return Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.num_cols() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "decoded-word length does not match the matrix columns".into(),
+                ));
+            }
+            // Check Hx ≡ s (mod 2) for each row
+            for (i, row) in self.matrix.iter().enumerate() {
+                let dot: usize = row
+                    .iter()
+                    .zip(config.iter())
+                    .filter(|(&h, &x)| h && x)
+                    .count();
+                let syndrome_bit = dot % 2 == 1;
+                if syndrome_bit != self.target[i] {
+                    return Ok(Min(None));
+                }
             }
-        }
 
-        // Feasible: return Hamming weight
-        let weight: usize = config.iter().filter(|&&v| v == 1).count();
-        Min(Some(weight))
+            // Feasible: return Hamming weight
+            let weight: usize = config.iter().filter(|&&v| v).count();
+            Min(Some(i64::try_from(weight).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting Hamming weight to i64".into(),
+                )
+            })?))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MinimumWeightDecoding {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_cols()]
     }
 }
 
 crate::declare_variants! {
-    default MinimumWeightDecoding => "2^(0.0494 * num_cols)",
+    default MinimumWeightDecoding => "2^(0.0494 * num_cols)" create MinimumWeightDecodingCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumWeightDecoding decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -160,7 +207,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "minimum_weight_decoding",
         instance: Box::new(MinimumWeightDecoding::new(matrix, target)),
-        optimal_config: vec![0, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![false, false, true, false]),
         optimal_value: serde_json::json!(1),
     }]
 }
diff --git a/src/models/algebraic/minimum_weight_solution_to_linear_equations.rs b/src/models/algebraic/minimum_weight_solution_to_linear_equations.rs
index 5457a1837..478f0b21e 100644
--- a/src/models/algebraic/minimum_weight_solution_to_linear_equations.rs
+++ b/src/models/algebraic/minimum_weight_solution_to_linear_equations.rs
@@ -3,7 +3,7 @@
 //! Given an n×m integer matrix A and integer vector b, find a rational vector y
 //! with Ay = b that minimizes the number of non-zero entries (Hamming weight).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -14,12 +14,10 @@ inventory::submit! {
         display_name: "Minimum Weight Solution to Linear Equations",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Find a rational solution to Ay=b minimizing the number of non-zero entries",
-        fields: &[
-            FieldInfo { name: "matrix", type_name: "Vec<Vec<i64>>", description: "n×m integer matrix A" },
-            FieldInfo { name: "rhs", type_name: "Vec<i64>", description: "right-hand side vector b of length n" },
-        ],
+        fields: MinimumWeightSolutionCreateSpec::FIELDS,
     }
 }
 
@@ -40,7 +38,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::MinimumWeightSolutionToLinearEquations;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let matrix = vec![
 ///     vec![1, 2, 3, 1],
@@ -49,7 +47,7 @@ inventory::submit! {
 /// let rhs = vec![5, 4];
 /// let problem = MinimumWeightSolutionToLinearEquations::new(matrix, rhs);
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem);
+/// let witness = solver.solve(&problem).unwrap();
 /// assert!(witness.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -60,6 +58,39 @@ pub struct MinimumWeightSolutionToLinearEquations {
     rhs: Vec<i64>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumWeightSolutionCreateSpec {
+    /// Integer matrix as JSON.
+    #[create(codec = "json")]
+    matrix: Vec<Vec<i64>>,
+    /// Right-hand side vector.
+    #[create(codec = "comma-separated")]
+    rhs: Vec<i64>,
+}
+
+impl TryFrom<MinimumWeightSolutionCreateSpec> for MinimumWeightSolutionToLinearEquations {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumWeightSolutionCreateSpec) -> Result<Self, Self::Error> {
+        let first = spec
+            .matrix
+            .first()
+            .ok_or("matrix must have at least one row")?;
+        if first.is_empty() {
+            return Err("matrix must have at least one column".into());
+        }
+        if spec.matrix.iter().any(|row| row.len() != first.len()) {
+            return Err("all matrix rows must have the same length".into());
+        }
+        if spec.rhs.len() != spec.matrix.len() {
+            return Err("rhs length must equal number of rows".into());
+        }
+        Ok(Self {
+            matrix: spec.matrix,
+            rhs: spec.rhs,
+        })
+    }
+}
+
 impl MinimumWeightSolutionToLinearEquations {
     /// Create a new MinimumWeightSolutionToLinearEquations instance.
     ///
@@ -104,20 +135,20 @@ impl MinimumWeightSolutionToLinearEquations {
 
     /// Check whether the system restricted to the given column indices is
     /// consistent over the rationals. Uses integer Gaussian elimination on
-    /// the augmented matrix [A'|b] with i128 arithmetic.
-    fn is_consistent(&self, columns: &[usize]) -> bool {
+    /// the augmented matrix [A'|b] with checked integer arithmetic.
+    fn is_consistent(&self, columns: &[usize]) -> Result<bool, crate::traits::EvaluationError> {
         let n = self.num_equations();
         let k = columns.len();
 
-        // Build augmented matrix [A'|b] as i128 to avoid overflow.
+        // Build augmented matrix [A'|b].
         // Each row has k coefficient columns + 1 rhs column.
-        let mut aug: Vec<Vec<i128>> = (0..n)
+        let mut aug: Vec<Vec<i64>> = (0..n)
             .map(|i| {
                 let mut row = Vec::with_capacity(k + 1);
                 for &j in columns {
-                    row.push(self.matrix[i][j] as i128);
+                    row.push(self.matrix[i][j]);
                 }
-                row.push(self.rhs[i] as i128);
+                row.push(self.rhs[i]);
                 row
             })
             .collect();
@@ -143,7 +174,21 @@ impl MinimumWeightSolutionToLinearEquations {
                 }
                 // row[r] = pivot_val * row[r] - factor * row[pivot_row]
                 for (cell, &pv) in row.iter_mut().zip(pivot_row_snapshot.iter()) {
-                    *cell = pivot_val * *cell - factor * pv;
+                    let left = pivot_val.checked_mul(*cell).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "multiplying a consistency-elimination row".into(),
+                        )
+                    })?;
+                    let right = factor.checked_mul(pv).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "multiplying a consistency-elimination pivot row".into(),
+                        )
+                    })?;
+                    *cell = left.checked_sub(right).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "subtracting consistency-elimination rows".into(),
+                        )
+                    })?;
                 }
             }
             pivot_row += 1;
@@ -153,59 +198,78 @@ impl MinimumWeightSolutionToLinearEquations {
         // non-zero rhs means the system is inconsistent.
         for row in &aug[pivot_row..n] {
             if row[k] != 0 {
-                return false;
+                return Ok(false);
             }
         }
-        true
+        Ok(true)
     }
 }
 
 impl Problem for MinimumWeightSolutionToLinearEquations {
     const NAME: &'static str = "MinimumWeightSolutionToLinearEquations";
-    type Value = Min<usize>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_equations", num_equations),
+        ("num_variables", num_variables),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_variables()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if config.len() != self.num_variables() {
-            return Min(None);
-        }
-        if config.iter().any(|&v| v >= 2) {
-            return Min(None);
-        }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.num_variables() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "assignment length does not match the equation variables".into(),
+                ));
+            }
+            let columns: Vec<usize> = config
+                .iter()
+                .enumerate()
+                .filter(|(_, &v)| v)
+                .map(|(j, _)| j)
+                .collect();
 
-        let columns: Vec<usize> = config
-            .iter()
-            .enumerate()
-            .filter(|(_, &v)| v == 1)
-            .map(|(j, _)| j)
-            .collect();
+            if columns.is_empty() {
+                // No columns selected — consistent iff b = 0.
+                if self.rhs.iter().all(|&v| v == 0) {
+                    return Ok(Min(Some(0)));
+                } else {
+                    return Ok(Min(None));
+                }
+            }
 
-        if columns.is_empty() {
-            // No columns selected — consistent iff b = 0.
-            if self.rhs.iter().all(|&v| v == 0) {
-                return Min(Some(0));
+            if self.is_consistent(&columns)? {
+                Min(Some(i64::try_from(columns.len()).map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting solution weight to i64".into(),
+                    )
+                })?))
             } else {
-                return Min(None);
+                Min(None)
             }
-        }
+        })
+    }
+}
 
-        if self.is_consistent(&columns) {
-            Min(Some(columns.len()))
-        } else {
-            Min(None)
-        }
+impl crate::solvers::BruteForceProblem for MinimumWeightSolutionToLinearEquations {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_variables()]
     }
 }
 
 crate::declare_variants! {
-    default MinimumWeightSolutionToLinearEquations => "2^num_variables",
+    default MinimumWeightSolutionToLinearEquations => "2^num_variables" create MinimumWeightSolutionCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumWeightSolutionToLinearEquations decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -218,7 +282,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "minimum_weight_solution_to_linear_equations",
         instance: Box::new(MinimumWeightSolutionToLinearEquations::new(matrix, rhs)),
-        optimal_config: vec![1, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![true, true, false, false]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/algebraic/mod.rs b/src/models/algebraic/mod.rs
index f9c7c79a6..328e6c21e 100644
--- a/src/models/algebraic/mod.rs
+++ b/src/models/algebraic/mod.rs
@@ -40,13 +40,16 @@ pub(crate) mod sparse_matrix_compression;
 
 pub use algebraic_equations_over_gf2::AlgebraicEquationsOverGF2;
 pub use bmf::BMF;
-pub use closest_vector_problem::{ClosestVectorProblem, VarBounds};
+pub use closest_vector_problem::{ClosestVectorProblem, ClosestVectorTarget};
 pub use consecutive_block_minimization::ConsecutiveBlockMinimization;
 pub use consecutive_ones_matrix_augmentation::ConsecutiveOnesMatrixAugmentation;
 pub use consecutive_ones_submatrix::ConsecutiveOnesSubmatrix;
 pub use equilibrium_point::EquilibriumPoint;
 pub use feasible_basis_extension::FeasibleBasisExtension;
-pub use ilp::{Comparison, LinearConstraint, ObjectiveSense, VariableDomain, ILP};
+pub use ilp::{
+    Comparison, ILPCoefficient, IntegerVariable, LinearConstraint, ObjectiveSense, VariableDomain,
+    ILP,
+};
 pub use minimum_matrix_cover::MinimumMatrixCover;
 pub use minimum_matrix_domination::MinimumMatrixDomination;
 pub use minimum_weight_decoding::MinimumWeightDecoding;
diff --git a/src/models/algebraic/quadratic_assignment.rs b/src/models/algebraic/quadratic_assignment.rs
index 2582d3106..72bafd830 100644
--- a/src/models/algebraic/quadratic_assignment.rs
+++ b/src/models/algebraic/quadratic_assignment.rs
@@ -14,6 +14,7 @@ inventory::submit! {
         display_name: "Quadratic Assignment",
         aliases: &["QAP"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Minimize total cost of assigning facilities to locations",
         fields: &[
@@ -30,7 +31,7 @@ inventory::submit! {
 /// distances between locations, find an injective assignment of facilities
 /// to locations that minimizes:
 ///
-/// f(p) = sum_{i != j} C[i][j] * D[p(i)][p(j)]
+/// `f(p) = sum_{i != j} C[i][j] * D[p(i)][p(j)]`
 ///
 /// where p is an injective mapping from facilities to locations (a permutation when n == m).
 ///
@@ -38,7 +39,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::QuadraticAssignment;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let cost_matrix = vec![
 ///     vec![0, 1, 2],
@@ -53,7 +54,7 @@ inventory::submit! {
 /// let problem = QuadraticAssignment::new(cost_matrix, distance_matrix);
 ///
 /// let solver = BruteForce::new();
-/// let best = solver.find_witness(&problem);
+/// let best = solver.solve(&problem).unwrap();
 /// assert!(best.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -115,48 +116,68 @@ impl QuadraticAssignment {
 
 impl Problem for QuadraticAssignment {
     const NAME: &'static str = "QuadraticAssignment";
+    type Solution = Vec<usize>;
     type Value = Min<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_locations(); self.num_facilities()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<i64> {
-        let n = self.num_facilities();
-        let m = self.num_locations();
-
-        // Check config length matches number of facilities
-        if config.len() != n {
-            return Min(None);
-        }
+    crate::problem_parameters![
+        ("num_facilities", num_facilities),
+        ("num_locations", num_locations),
+    ];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let n = self.num_facilities();
+            let m = self.num_locations();
+
+            // Check config length matches number of facilities
+            if config.len() != n {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "assignment length does not match the number of facilities".into(),
+                ));
+            }
 
-        // Check that all assignments are valid locations
-        for &loc in config {
-            if loc >= m {
-                return Min(None);
+            if config.iter().any(|&location| location >= m) {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "assignment contains an out-of-range location".into(),
+                ));
             }
-        }
 
-        // Check injectivity: no two facilities assigned to the same location
-        let mut used = vec![false; m];
-        for &loc in config {
-            if used[loc] {
-                return Min(None);
+            // Check injectivity: no two facilities assigned to the same location
+            let mut used = vec![false; m];
+            for &loc in config {
+                if used[loc] {
+                    return Ok(Min(None));
+                }
+                used[loc] = true;
             }
-            used[loc] = true;
-        }
 
-        // Compute objective: sum_{i != j} cost_matrix[i][j] * distance_matrix[config[i]][config[j]]
-        let mut total: i64 = 0;
-        for i in 0..n {
-            for j in 0..n {
-                if i != j {
-                    total += self.cost_matrix[i][j] * self.distance_matrix[config[i]][config[j]];
+            // Compute objective: sum_{i != j} cost_matrix[i][j] * distance_matrix[config[i]][config[j]]
+            let mut total: i64 = 0;
+            for i in 0..n {
+                for j in 0..n {
+                    if i != j {
+                        let term = self.cost_matrix[i][j]
+                            .checked_mul(self.distance_matrix[config[i]][config[j]])
+                            .ok_or_else(|| {
+                                crate::traits::EvaluationError::IntegerOverflow(
+                                    "multiplying quadratic assignment cost and distance"
+                                        .to_string(),
+                                )
+                            })?;
+                        total = total.checked_add(term).ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "summing quadratic assignment objective".to_string(),
+                            )
+                        })?;
+                    }
                 }
             }
-        }
 
-        Min(Some(total))
+            Min(Some(total))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -164,10 +185,20 @@ impl Problem for QuadraticAssignment {
     }
 }
 
+impl crate::solvers::BruteForceProblem for QuadraticAssignment {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_locations(); self.num_facilities()]
+    }
+}
+
 crate::declare_variants! {
     default QuadraticAssignment => "factorial(num_facilities)",
 }
 
+crate::register_brute_force! {
+    QuadraticAssignment,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -186,7 +217,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 vec![1, 4, 4, 0],
             ],
         )),
-        optimal_config: vec![3, 0, 1, 2],
+        optimal_config: serde_json::json!(vec![3, 0, 1, 2]),
         optimal_value: serde_json::json!(56),
     }]
 }
diff --git a/src/models/algebraic/quadratic_congruences.rs b/src/models/algebraic/quadratic_congruences.rs
index 12ba2fc3c..98212273c 100644
--- a/src/models/algebraic/quadratic_congruences.rs
+++ b/src/models/algebraic/quadratic_congruences.rs
@@ -8,7 +8,7 @@
 //! model can represent arbitrarily large instances while still fitting the
 //! crate's `Vec<usize>` configuration interface.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use num_bigint::{BigUint, ToBigUint};
@@ -22,6 +22,7 @@ inventory::submit! {
         display_name: "Quadratic Congruences",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Decide whether x² ≡ a (mod b) has a solution for x in {1, ..., c-1}",
         fields: &[
@@ -32,13 +33,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "QuadraticCongruences",
-        fields: &["bit_length_a", "bit_length_b", "bit_length_c"],
-    }
-}
-
 /// Quadratic Congruences problem.
 ///
 /// Given non-negative integers `a`, `b`, `c` with `b > 0` and `a < b`,
@@ -71,22 +65,26 @@ fn bit_length(value: &BigUint) -> usize {
 }
 
 impl QuadraticCongruences {
-    fn validate_inputs(a: &BigUint, b: &BigUint, c: &BigUint) -> Result<(), String> {
+    fn validate_inputs(
+        a: &BigUint,
+        b: &BigUint,
+        c: &BigUint,
+    ) -> Result<(), crate::registry::ConstructionError> {
         if b.is_zero() {
-            return Err("Modulus b must be positive".to_string());
+            return Err("Modulus b must be positive".to_string().into());
         }
         if c.is_zero() {
-            return Err("Bound c must be positive".to_string());
+            return Err("Bound c must be positive".to_string().into());
         }
         if a >= b {
-            return Err(format!("Residue a ({a}) must be less than modulus b ({b})"));
+            return Err(format!("Residue a ({a}) must be less than modulus b ({b})").into());
         }
         Ok(())
     }
 
     /// Create a new QuadraticCongruences instance, returning an error instead of
     /// panicking when the inputs are invalid.
-    pub fn try_new<A, B, C>(a: A, b: B, c: C) -> Result<Self, String>
+    pub fn try_new<A, B, C>(a: A, b: B, c: C) -> Result<Self, crate::registry::ConstructionError>
     where
         A: ToBigUint,
         B: ToBigUint,
@@ -223,13 +221,33 @@ impl<'de> Deserialize<'de> for QuadraticCongruences {
 
 impl Problem for QuadraticCongruences {
     const NAME: &'static str = "QuadraticCongruences";
+    type Solution = BigUint;
     type Value = Or;
 
+    crate::problem_parameters![
+        ("bit_length_a", bit_length_a),
+        ("bit_length_b", bit_length_b),
+        ("bit_length_c", bit_length_c),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(&self, x: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            if x.is_zero() || x >= self.c() {
+                return Ok(Or(false));
+            }
+
+            let satisfies = (x * x) % self.b() == self.a().clone();
+            Or(satisfies)
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for QuadraticCongruences {
+    fn dimensions(&self) -> Vec<usize> {
         let num_bits = self.witness_bit_length();
         if num_bits == 0 {
             Vec::new()
@@ -237,36 +255,26 @@ impl Problem for QuadraticCongruences {
             vec![2; num_bits]
         }
     }
-
-    fn evaluate(&self, config: &[usize]) -> Or {
-        let Some(x) = self.decode_witness(config) else {
-            return Or(false);
-        };
-
-        if x.is_zero() || x >= *self.c() {
-            return Or(false);
-        }
-
-        let satisfies = (&x * &x) % self.b() == self.a().clone();
-        Or(satisfies)
-    }
 }
 
 crate::declare_variants! {
     default QuadraticCongruences => "2^bit_length_c",
 }
 
+crate::register_brute_force! {
+    QuadraticCongruences decode |problem: &QuadraticCongruences, indices: Vec<usize>| problem.decode_witness(&indices).expect("enumerated quadratic-congruence bits are valid"),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     let instance = QuadraticCongruences::new(4u32, 15u32, 10u32);
-    let optimal_config = instance
-        .encode_witness(&BigUint::from(2u32))
-        .expect("x=2 should be a valid canonical witness");
+    let optimal_config = BigUint::from(2u32);
 
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "quadratic_congruences",
         instance: Box::new(instance),
-        optimal_config,
+        optimal_config: serde_json::to_value(optimal_config)
+            .expect("solution serialization must succeed"),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/algebraic/quadratic_diophantine_equations.rs b/src/models/algebraic/quadratic_diophantine_equations.rs
index 7fdc29844..6cef6e290 100644
--- a/src/models/algebraic/quadratic_diophantine_equations.rs
+++ b/src/models/algebraic/quadratic_diophantine_equations.rs
@@ -6,7 +6,7 @@
 //! The witness integer `x` is encoded as a little-endian binary vector so the
 //! model can represent large reductions without fixed-width overflow.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use num_bigint::{BigUint, ToBigUint};
@@ -20,6 +20,7 @@ inventory::submit! {
         display_name: "Quadratic Diophantine Equations",
         aliases: &["QDE"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Decide whether ax^2 + by = c has a solution in positive integers x, y",
         fields: &[
@@ -30,13 +31,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "QuadraticDiophantineEquations",
-        fields: &["bit_length_a", "bit_length_b", "bit_length_c"],
-    }
-}
-
 /// Quadratic Diophantine Equations problem.
 ///
 /// Given positive integers `a`, `b`, and `c`, determine whether there exist
@@ -68,15 +62,19 @@ fn bit_length(value: &BigUint) -> usize {
 }
 
 impl QuadraticDiophantineEquations {
-    fn validate_inputs(a: &BigUint, b: &BigUint, c: &BigUint) -> Result<(), String> {
+    fn validate_inputs(
+        a: &BigUint,
+        b: &BigUint,
+        c: &BigUint,
+    ) -> Result<(), crate::registry::ConstructionError> {
         if a.is_zero() {
-            return Err("Coefficient a must be positive".to_string());
+            return Err("Coefficient a must be positive".to_string().into());
         }
         if b.is_zero() {
-            return Err("Coefficient b must be positive".to_string());
+            return Err("Coefficient b must be positive".to_string().into());
         }
         if c.is_zero() {
-            return Err("Right-hand side c must be positive".to_string());
+            return Err("Right-hand side c must be positive".to_string().into());
         }
         Ok(())
     }
@@ -103,7 +101,7 @@ impl QuadraticDiophantineEquations {
 
     /// Create a new QuadraticDiophantineEquations instance, returning an error
     /// instead of panicking when inputs are invalid.
-    pub fn try_new<A, B, C>(a: A, b: B, c: C) -> Result<Self, String>
+    pub fn try_new<A, B, C>(a: A, b: B, c: C) -> Result<Self, crate::registry::ConstructionError>
     where
         A: ToBigUint,
         B: ToBigUint,
@@ -182,49 +180,6 @@ impl QuadraticDiophantineEquations {
         }
     }
 
-    /// Encode a candidate witness integer `x` as a little-endian binary configuration.
-    pub fn encode_witness(&self, x: &BigUint) -> Option<Vec<usize>> {
-        if x.is_zero() || x > &self.max_x() {
-            return None;
-        }
-
-        let num_bits = self.witness_bit_length();
-        let mut remaining = x.clone();
-        let mut config = Vec::with_capacity(num_bits);
-
-        for _ in 0..num_bits {
-            config.push(if (&remaining & BigUint::one()).is_zero() {
-                0
-            } else {
-                1
-            });
-            remaining >>= 1usize;
-        }
-
-        if remaining.is_zero() {
-            Some(config)
-        } else {
-            None
-        }
-    }
-
-    /// Decode a little-endian binary configuration into its candidate witness `x`.
-    pub fn decode_witness(&self, config: &[usize]) -> Option<BigUint> {
-        if config.len() != self.witness_bit_length() || config.iter().any(|&digit| digit > 1) {
-            return None;
-        }
-
-        let mut value = BigUint::zero();
-        let mut weight = BigUint::one();
-        for &digit in config {
-            if digit == 1 {
-                value += &weight;
-            }
-            weight <<= 1usize;
-        }
-        Some(value)
-    }
-
     /// Check whether a given x yields a valid positive integer y.
     ///
     /// Returns `Some(y)` if `y` is a positive integer, `None` otherwise.
@@ -274,13 +229,32 @@ impl<'de> Deserialize<'de> for QuadraticDiophantineEquations {
 
 impl Problem for QuadraticDiophantineEquations {
     const NAME: &'static str = "QuadraticDiophantineEquations";
+    type Solution = BigUint;
     type Value = Or;
 
+    crate::problem_parameters![
+        ("bit_length_a", bit_length_a),
+        ("bit_length_b", bit_length_b),
+        ("bit_length_c", bit_length_c),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(&self, x: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            if x.is_zero() || x > &self.max_x() {
+                return Ok(Or(false));
+            }
+
+            Or(self.check_x(x).is_some())
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for QuadraticDiophantineEquations {
+    fn dimensions(&self) -> Vec<usize> {
         let num_bits = self.witness_bit_length();
         if num_bits == 0 {
             Vec::new()
@@ -288,35 +262,26 @@ impl Problem for QuadraticDiophantineEquations {
             vec![2; num_bits]
         }
     }
-
-    fn evaluate(&self, config: &[usize]) -> Or {
-        let Some(x) = self.decode_witness(config) else {
-            return Or(false);
-        };
-
-        if x.is_zero() || x > self.max_x() {
-            return Or(false);
-        }
-
-        Or(self.check_x(&x).is_some())
-    }
 }
 
 crate::declare_variants! {
     default QuadraticDiophantineEquations => "2^bit_length_c",
 }
 
+crate::register_brute_force! {
+    QuadraticDiophantineEquations decode |_: &QuadraticDiophantineEquations, indices: Vec<usize>| indices.into_iter().enumerate().fold(BigUint::zero(), |value, (bit, set)| if set == 0 { value } else { value + (BigUint::one() << bit) }),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     let instance = QuadraticDiophantineEquations::new(3u32, 5u32, 53u32);
-    let optimal_config = instance
-        .encode_witness(&BigUint::from(1u32))
-        .expect("x=1 should be a valid canonical witness");
+    let optimal_config = BigUint::from(1u32);
 
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "quadratic_diophantine_equations",
         instance: Box::new(instance),
-        optimal_config,
+        optimal_config: serde_json::to_value(optimal_config)
+            .expect("solution serialization must succeed"),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/algebraic/qubo.rs b/src/models/algebraic/qubo.rs
index a36fd7bc4..1c145bd6e 100644
--- a/src/models/algebraic/qubo.rs
+++ b/src/models/algebraic/qubo.rs
@@ -2,9 +2,10 @@
 //!
 //! QUBO minimizes a quadratic function over binary variables.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{ConstructionError, CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
+use num_traits::Zero;
 use serde::{Deserialize, Serialize};
 
 inventory::submit! {
@@ -12,13 +13,11 @@ inventory::submit! {
         name: "QUBO",
         display_name: "QUBO",
         aliases: &[],
-        dimensions: &[VariantDimension::new("weight", "f64", &["f64"])],
+        dimensions: &[VariantDimension::new("weight", "i64", &["i64", "f64"])],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Minimize quadratic unconstrained binary objective",
-        fields: &[
-            FieldInfo { name: "num_vars", type_name: "usize", description: "Number of binary variables" },
-            FieldInfo { name: "matrix", type_name: "Vec<Vec<W>>", description: "Upper-triangular Q matrix" },
-        ],
+        fields: QuboCreateSpec::<i64>::FIELDS,
     }
 }
 
@@ -33,27 +32,31 @@ inventory::submit! {
 /// representing linear terms and off-diagonal elements representing
 /// quadratic interactions.
 ///
+/// `QUBO<i64>` is the default exact-integer variant. `QUBO<f64>` stores
+/// finite floating-point coefficients. An explicit variant reduction converts
+/// exactly representable integer coefficients to `f64`.
+///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::algebraic::QUBO;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Q matrix: minimize x0 - 2*x1 + x0*x1
 /// // Q = [[1, 1], [0, -2]]
 /// let problem = QUBO::from_matrix(vec![
-///     vec![1.0, 1.0],
-///     vec![0.0, -2.0],
-/// ]);
+///     vec![1, 1],
+///     vec![0, -2],
+/// ]).unwrap();
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Optimal is x = [0, 1] with value -2
-/// assert!(solutions.contains(&vec![0, 1]));
+/// assert!(solutions.contains(&vec![false, true]));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct QUBO<W = f64> {
+pub struct QUBO<W = i64> {
     /// Number of variables.
     num_vars: usize,
     /// Q matrix stored as upper triangular (row-major).
@@ -61,14 +64,43 @@ pub struct QUBO<W = f64> {
     matrix: Vec<Vec<W>>,
 }
 
-impl<W: Clone + Default> QUBO<W> {
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct QuboCreateSpec<W> {
+    /// Q matrix; the number of variables is its row count.
+    #[create(codec = "semicolon-separated")]
+    matrix: Vec<Vec<W>>,
+}
+
+impl<W: WeightElement> TryFrom<QuboCreateSpec<W>> for QUBO<W> {
+    type Error = ConstructionError;
+
+    fn try_from(spec: QuboCreateSpec<W>) -> Result<Self, Self::Error> {
+        Self::from_matrix(spec.matrix)
+    }
+}
+
+impl<W: WeightElement> QUBO<W> {
     /// Create a QUBO problem from a full matrix.
     ///
     /// The matrix should be square. Only the upper triangular part
     /// (including diagonal) is used.
-    pub fn from_matrix(matrix: Vec<Vec<W>>) -> Self {
+    pub fn from_matrix(matrix: Vec<Vec<W>>) -> Result<Self, ConstructionError> {
         let num_vars = matrix.len();
-        Self { num_vars, matrix }
+        if let Some((row, actual)) = matrix
+            .iter()
+            .enumerate()
+            .find_map(|(row, values)| (values.len() != num_vars).then_some((row, values.len())))
+        {
+            return Err(ConstructionError::Conversion(format!(
+                "QUBO matrix row {row} has length {actual}, expected {num_vars}"
+            )));
+        }
+        for (row, values) in matrix.iter().enumerate() {
+            for (column, value) in values.iter().enumerate() {
+                value.validate_element(&format!("QUBO coefficient at ({row}, {column})"))?;
+            }
+        }
+        Ok(Self { num_vars, matrix })
     }
 
     /// Create a QUBO from linear and quadratic terms.
@@ -76,12 +108,12 @@ impl<W: Clone + Default> QUBO<W> {
     /// # Arguments
     /// * `linear` - Linear coefficients (diagonal of Q)
     /// * `quadratic` - Quadratic coefficients as ((i, j), value) for i < j
-    pub fn new(linear: Vec<W>, quadratic: Vec<((usize, usize), W)>) -> Self
-    where
-        W: num_traits::Zero,
-    {
+    pub fn new(
+        linear: Vec<W>,
+        quadratic: Vec<((usize, usize), W)>,
+    ) -> Result<Self, ConstructionError> {
         let num_vars = linear.len();
-        let mut matrix = vec![vec![W::zero(); num_vars]; num_vars];
+        let mut matrix = vec![vec![W::default(); num_vars]; num_vars];
 
         // Set diagonal (linear terms)
         for (i, val) in linear.into_iter().enumerate() {
@@ -90,6 +122,11 @@ impl<W: Clone + Default> QUBO<W> {
 
         // Set off-diagonal (quadratic terms)
         for ((i, j), val) in quadratic {
+            if i >= num_vars || j >= num_vars {
+                return Err(ConstructionError::Conversion(format!(
+                    "QUBO quadratic index ({i}, {j}) is outside 0..{num_vars}"
+                )));
+            }
             if i < j {
                 matrix[i][j] = val;
             } else {
@@ -97,9 +134,11 @@ impl<W: Clone + Default> QUBO<W> {
             }
         }
 
-        Self { num_vars, matrix }
+        Self::from_matrix(matrix)
     }
+}
 
+impl<W> QUBO<W> {
     /// Get the number of variables.
     pub fn num_vars(&self) -> usize {
         self.num_vars
@@ -116,78 +155,87 @@ impl<W: Clone + Default> QUBO<W> {
     }
 }
 
-impl<W> QUBO<W>
+impl<W> Problem for QUBO<W>
 where
-    W: Clone + num_traits::Zero + std::ops::AddAssign + std::ops::Mul<Output = W>,
+    W: WeightElement + crate::variant::VariantParam,
 {
-    /// Evaluate the QUBO objective for a configuration.
-    pub fn evaluate(&self, config: &[usize]) -> W {
-        let mut value = W::zero();
+    const NAME: &'static str = "QUBO";
+    type Solution = Vec<bool>;
+    type Value = Min<W::Sum>;
+
+    crate::problem_parameters![("num_vars", num_vars),];
+
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if solution.len() != self.num_vars {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                format!(
+                    "solution has {} variables, expected {}",
+                    solution.len(),
+                    self.num_vars
+                ),
+            ));
+        }
+        let mut value = W::Sum::zero();
 
         for i in 0..self.num_vars {
-            let x_i = config.get(i).copied().unwrap_or(0);
-            if x_i == 0 {
+            if !solution[i] {
                 continue;
             }
 
-            for j in i..self.num_vars {
-                let x_j = config.get(j).copied().unwrap_or(0);
-                if x_j == 0 {
+            for (j, &selected) in solution.iter().enumerate().skip(i) {
+                if !selected {
                     continue;
                 }
 
                 if let Some(q_ij) = self.matrix.get(i).and_then(|row| row.get(j)) {
-                    value += q_ij.clone();
+                    value = W::checked_add_to_sum(
+                        value,
+                        q_ij.to_sum(),
+                        "summing selected QUBO coefficients",
+                    )?;
                 }
             }
         }
 
-        value
+        Ok(Min(Some(value)))
+    }
+
+    fn variant() -> Vec<(&'static str, &'static str)> {
+        crate::variant_params![W]
     }
 }
 
-impl<W> Problem for QUBO<W>
+impl<W> crate::solvers::BruteForceProblem for QUBO<W>
 where
-    W: WeightElement
-        + crate::variant::VariantParam
-        + PartialOrd
-        + num_traits::Num
-        + num_traits::Zero
-        + num_traits::Bounded
-        + std::ops::AddAssign
-        + std::ops::Mul<Output = W>,
+    W: WeightElement + crate::variant::VariantParam,
 {
-    const NAME: &'static str = "QUBO";
-    type Value = Min<W::Sum>;
-
-    fn dims(&self) -> Vec<usize> {
+    fn dimensions(&self) -> Vec<usize> {
         vec![2; self.num_vars]
     }
-
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        Min(Some(self.evaluate(config).to_sum()))
-    }
-
-    fn variant() -> Vec<(&'static str, &'static str)> {
-        crate::variant_params![W]
-    }
 }
 
 crate::declare_variants! {
-    default QUBO<f64> => "2^num_vars",
+    default QUBO<i64> => "2^num_vars" create QuboCreateSpec<i64>,
+    QUBO<f64> => "2^num_vars" create QuboCreateSpec<f64>,
+}
+
+crate::register_brute_force! {
+    QUBO<i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    QUBO<f64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "qubo_f64",
-        instance: Box::new(QUBO::from_matrix(vec![
-            vec![-1.0, 2.0, 0.0],
-            vec![0.0, -1.0, 2.0],
-            vec![0.0, 0.0, -1.0],
-        ])),
-        optimal_config: vec![1, 0, 1],
-        optimal_value: serde_json::json!(-2.0),
+        id: "qubo",
+        instance: Box::new(
+            QUBO::from_matrix(vec![vec![-1, 2, 0], vec![0, -1, 2], vec![0, 0, -1]]).unwrap(),
+        ),
+        optimal_config: serde_json::json!(vec![true, false, true]),
+        optimal_value: serde_json::json!(-2),
     }]
 }
 
diff --git a/src/models/algebraic/simultaneous_incongruences.rs b/src/models/algebraic/simultaneous_incongruences.rs
index 5dc6263d1..968d8deda 100644
--- a/src/models/algebraic/simultaneous_incongruences.rs
+++ b/src/models/algebraic/simultaneous_incongruences.rs
@@ -3,7 +3,7 @@
 //! Given a list of pairs (aᵢ, bᵢ) with bᵢ > 0 and 1 ≤ aᵢ ≤ bᵢ, determine whether
 //! there exists a non-negative integer x such that x ≢ aᵢ (mod bᵢ) for all i.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -15,25 +15,19 @@ inventory::submit! {
         display_name: "Simultaneous Incongruences",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Decide whether there exists x with x ≢ aᵢ (mod bᵢ) for all i",
         fields: &[
             FieldInfo {
                 name: "pairs",
-                type_name: "Vec<(u64, u64)>",
+                type_name: "Vec<(i64, i64)>",
                 description: "Pairs (aᵢ, bᵢ) with bᵢ > 0 and 1 ≤ aᵢ ≤ bᵢ",
             },
         ],
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "SimultaneousIncongruences",
-        fields: &["num_pairs"],
-    }
-}
-
 /// Simultaneous Incongruences problem.
 ///
 /// Given a list of pairs (aᵢ, bᵢ) with bᵢ > 0 and 1 ≤ aᵢ ≤ bᵢ, determine whether
@@ -46,34 +40,21 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::algebraic::SimultaneousIncongruences;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // pairs: [(2,2),(1,3),(2,5),(3,7)] — lcm=210, x=5 is a solution
 /// let problem = SimultaneousIncongruences::new(vec![(2,2),(1,3),(2,5),(3,7)]).unwrap();
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem);
+/// let witness = solver.solve(&problem).unwrap();
 /// assert!(witness.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize)]
 pub struct SimultaneousIncongruences {
     /// Incongruence pairs (aᵢ, bᵢ).
-    pairs: Vec<(u64, u64)>,
-}
-
-/// Maximum lcm value we will compute in full; if the lcm exceeds this cap we
-/// return this value to keep the brute-force search space manageable.
-pub(crate) const MAX_LCM: u128 = 1_000_000;
-
-fn lcm128(a: u128, b: u128) -> u128 {
-    if a == 0 || b == 0 {
-        return 0;
-    }
-    let g = gcd128(a, b);
-    // Use saturating arithmetic to avoid overflow; cap at MAX_LCM.
-    (a / g).saturating_mul(b).min(MAX_LCM)
+    pairs: Vec<(i64, i64)>,
 }
 
-fn gcd128(mut a: u128, mut b: u128) -> u128 {
+fn gcd(mut a: i64, mut b: i64) -> i64 {
     while b != 0 {
         let t = b;
         b = a % b;
@@ -83,28 +64,32 @@ fn gcd128(mut a: u128, mut b: u128) -> u128 {
 }
 
 impl SimultaneousIncongruences {
-    fn validate_inputs(pairs: &[(u64, u64)]) -> Result<(), String> {
+    fn validate_inputs(pairs: &[(i64, i64)]) -> Result<(), crate::registry::ConstructionError> {
         for (i, &(a, b)) in pairs.iter().enumerate() {
-            if b == 0 {
-                return Err(format!("Modulus b at index {i} must be positive (got b=0)"));
+            if b <= 0 {
+                return Err(format!("Modulus b at index {i} must be positive (got b={b})").into());
             }
-            if a == 0 {
-                return Err(format!(
-                    "Residue a at index {i} must be at least 1 (got a=0)"
-                ));
+            if a <= 0 {
+                return Err(format!("Residue a at index {i} must be at least 1 (got a=0)").into());
             }
             if a > b {
                 return Err(format!(
                     "Residue a ({a}) must not exceed modulus b ({b}) at index {i}"
-                ));
+                )
+                .into());
             }
         }
+        pairs.iter().try_fold(1i64, |lcm, &(_, modulus)| {
+            (lcm / gcd(lcm, modulus))
+                .checked_mul(modulus)
+                .ok_or_else(|| "Least common multiple of moduli exceeds i64 range".to_string())
+        })?;
         Ok(())
     }
 
     /// Create a new `SimultaneousIncongruences` instance, returning an error
     /// if any pair is invalid.
-    pub fn new(pairs: Vec<(u64, u64)>) -> Result<Self, String> {
+    pub fn new(pairs: Vec<(i64, i64)>) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate_inputs(&pairs)?;
         Ok(Self { pairs })
     }
@@ -115,26 +100,21 @@ impl SimultaneousIncongruences {
     }
 
     /// Get the incongruence pairs.
-    pub fn pairs(&self) -> &[(u64, u64)] {
+    pub fn pairs(&self) -> &[(i64, i64)] {
         &self.pairs
     }
 
-    /// Compute the LCM of all moduli (capped at `MAX_LCM`).
-    pub fn lcm_moduli(&self) -> u64 {
-        if self.pairs.is_empty() {
-            return 1;
-        }
-        let lcm = self
-            .pairs
-            .iter()
-            .fold(1u128, |acc, &(_, b)| lcm128(acc, b as u128));
-        lcm as u64
+    /// Compute the LCM of all moduli.
+    pub fn lcm_moduli(&self) -> i64 {
+        self.pairs.iter().fold(1i64, |lcm, &(_, modulus)| {
+            (lcm / gcd(lcm, modulus)) * modulus
+        })
     }
 }
 
 #[derive(Deserialize)]
 struct SimultaneousIncongruencesData {
-    pairs: Vec<(u64, u64)>,
+    pairs: Vec<(i64, i64)>,
 }
 
 impl<'de> Deserialize<'de> for SimultaneousIncongruences {
@@ -149,24 +129,27 @@ impl<'de> Deserialize<'de> for SimultaneousIncongruences {
 
 impl Problem for SimultaneousIncongruences {
     const NAME: &'static str = "SimultaneousIncongruences";
+    type Solution = i64;
     type Value = Or;
 
+    crate::problem_parameters![("num_pairs", num_pairs),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let lcm = self.lcm_moduli() as usize;
-        vec![lcm]
+    fn evaluate(&self, solution: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            // x is a solution iff x % bᵢ ≠ aᵢ % bᵢ for every pair.
+            Or(self.pairs.iter().all(|&(a, b)| solution % b != a % b))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Or {
-        if config.len() != 1 {
-            return Or(false);
-        }
-        let x = config[0] as u64;
-        // x is a solution iff x % bᵢ ≠ aᵢ % bᵢ for every pair.
-        Or(self.pairs.iter().all(|&(a, b)| x % b != a % b))
+impl crate::solvers::BruteForceProblem for SimultaneousIncongruences {
+    fn dimensions(&self) -> Vec<usize> {
+        let lcm = usize::try_from(self.lcm_moduli()).expect("validated positive LCM fits usize");
+        vec![lcm]
     }
 }
 
@@ -174,6 +157,10 @@ crate::declare_variants! {
     default SimultaneousIncongruences => "num_pairs",
 }
 
+crate::register_brute_force! {
+    SimultaneousIncongruences decode |_, indices: Vec<usize>| i64::try_from(indices[0]).expect("enumerated incongruence value fits i64"),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -182,7 +169,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             SimultaneousIncongruences::new(vec![(2, 2), (1, 3), (2, 5), (3, 7)]).unwrap(),
         ),
         // x=5: 5%2=1≠0(=2%2), 5%3=2≠1, 5%5=0≠2, 5%7=5≠3 ✓
-        optimal_config: vec![5],
+        optimal_config: serde_json::json!(5),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/algebraic/sparse_matrix_compression.rs b/src/models/algebraic/sparse_matrix_compression.rs
index 7f4f5e9c5..724a0aff7 100644
--- a/src/models/algebraic/sparse_matrix_compression.rs
+++ b/src/models/algebraic/sparse_matrix_compression.rs
@@ -4,7 +4,7 @@
 //! whether the rows can be overlaid into a storage vector of length `n + K`
 //! by assigning each row a shift in `{1, ..., K}` without collisions.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,12 +14,10 @@ inventory::submit! {
         display_name: "Sparse Matrix Compression",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Algebraic,
         module_path: module_path!(),
         description: "Overlay binary-matrix rows into a short storage vector by shifting each row without collisions",
-        fields: &[
-            FieldInfo { name: "matrix", type_name: "Vec<Vec<bool>>", description: "m x n binary matrix A" },
-            FieldInfo { name: "bound_k", type_name: "usize", description: "Maximum shift range K" },
-        ],
+        fields: SparseMatrixCompressionCreateSpec::FIELDS,
     }
 }
 
@@ -35,6 +33,30 @@ pub struct SparseMatrixCompression {
     bound_k: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SparseMatrixCompressionCreateSpec {
+    /// m x n binary matrix A.
+    matrix: Vec<Vec<bool>>,
+    /// Maximum shift range K.
+    bound_k: usize,
+}
+
+impl TryFrom<SparseMatrixCompressionCreateSpec> for SparseMatrixCompression {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: SparseMatrixCompressionCreateSpec) -> Result<Self, Self::Error> {
+        if spec.bound_k == 0 {
+            return Err("bound_k must be positive".to_string().into());
+        }
+        let columns = spec.matrix.first().map_or(0, Vec::len);
+        if spec.matrix.iter().any(|row| row.len() != columns) {
+            return Err("all matrix rows must have the same length"
+                .to_string()
+                .into());
+        }
+        Ok(Self::new(spec.matrix, spec.bound_k))
+    }
+}
+
 impl SparseMatrixCompression {
     /// Create a new SparseMatrixCompression instance.
     ///
@@ -119,14 +141,30 @@ impl SparseMatrixCompression {
 
 impl Problem for SparseMatrixCompression {
     const NAME: &'static str = "SparseMatrixCompression";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.bound_k; self.num_rows()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.storage_vector(config).is_some())
+    crate::problem_parameters![
+        ("bound_k", bound_k),
+        ("num_cols", num_cols),
+        ("num_rows", num_rows),
+    ];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_rows() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "shift-vector length does not match the matrix rows".into(),
+            ));
+        }
+        if config.iter().any(|&shift| shift >= self.bound_k) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "shift vector contains an out-of-range shift".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.storage_vector(config).is_some()))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -134,8 +172,18 @@ impl Problem for SparseMatrixCompression {
     }
 }
 
+impl crate::solvers::BruteForceProblem for SparseMatrixCompression {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.bound_k; self.num_rows()]
+    }
+}
+
 crate::declare_variants! {
-    default SparseMatrixCompression => "(bound_k ^ num_rows) * num_rows * num_cols",
+    default SparseMatrixCompression => "(bound_k ^ num_rows) * num_rows * num_cols" create SparseMatrixCompressionCreateSpec,
+}
+
+crate::register_brute_force! {
+    SparseMatrixCompression,
 }
 
 #[cfg(feature = "example-db")]
@@ -151,7 +199,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
             2,
         )),
-        optimal_config: vec![1, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![1, 1, 1, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/decision.rs b/src/models/decision.rs
index 7ef3d129d..1acb637ca 100644
--- a/src/models/decision.rs
+++ b/src/models/decision.rs
@@ -4,7 +4,7 @@ use crate::rules::{AggregateReductionResult, ReduceTo, ReduceToAggregate, Reduct
 use crate::traits::Problem;
 use crate::types::{OptimizationValue, Or};
 use serde::de::DeserializeOwned;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 
 /// Metadata for concrete optimization problems that expose a decision wrapper.
 pub trait DecisionProblemMeta: Problem
@@ -27,13 +27,10 @@ macro_rules! decision_problem_meta {
 
 /// Register the boilerplate inventory entries for a concrete `Decision<P>` variant.
 ///
-/// The `size_getters` parameter defines problem-specific size fields as
-/// `(name, getter_on_inner)` pairs, e.g., `[("num_vertices", num_vertices), ("num_edges", num_edges)]`.
-/// These are used for overhead expressions and `ProblemSize` extraction.
-/// The macro automatically adds a `("k", k)` entry for `source_size_fn` on the Decision side.
-///
-/// Callers must define inherent methods on `Decision<Inner>` (delegating to `self.inner()`)
-/// and a `k()` method (from `self.bound()`) **before** invoking this macro.
+/// Optional `additional: [Inner => "complexity", ...]` entries share the primary
+/// variant's construction fields and decoder without adding another schema or default.
+/// Both decision/optimization edges derive their identity parameter transforms directly
+/// from the inner problem's canonical parameter schema.
 #[macro_export]
 macro_rules! register_decision_variant {
     (
@@ -42,13 +39,14 @@ macro_rules! register_decision_variant {
         $complexity:literal,
         $aliases:expr,
         $description:literal,
+        category: $category:expr,
         dims: [$($dim:expr),* $(,)?],
         fields: [$($field:expr),* $(,)?],
-        size_getters: [$(($sg_name:literal, $sg_method:ident)),* $(,)?]
+        $(additional: [$($additional:ty => $additional_complexity:literal),* $(,)?],)?
+        decode: $decoder:expr
+        $(, $random:ident)?
     ) => {
-        $crate::declare_variants! {
-            default $crate::models::decision::Decision<$inner> => $complexity,
-        }
+        $crate::register_decision_variant!(@declare $inner, $complexity, $decoder, [$($($additional => $additional_complexity),*)?] $(, $random)?);
 
         $crate::inventory::submit! {
             $crate::registry::ProblemSchemaEntry {
@@ -56,12 +54,23 @@ macro_rules! register_decision_variant {
                 display_name: $crate::register_decision_variant!(@display_name $name),
                 aliases: $aliases,
                 dimensions: &[$($dim),*],
+                category: $category,
                 module_path: module_path!(),
                 description: $description,
                 fields: &[$($field),*],
             }
         }
 
+        $crate::register_decision_variant!(@edges $inner, $name);
+        $($(
+            $crate::register_brute_force! {
+                $crate::models::decision::Decision<$additional> decode $decoder,
+            }
+            $crate::register_decision_variant!(@edges $additional, $name);
+        )*)?
+    };
+
+    (@edges $inner:ty, $name:literal) => {
         // Decision<P> → P: both witness (identity config) and aggregate (solve + compare)
         $crate::inventory::submit! {
             $crate::rules::ReductionEntry {
@@ -69,42 +78,38 @@ macro_rules! register_decision_variant {
                 target_name: <$inner as $crate::traits::Problem>::NAME,
                 source_variant_fn: <$crate::models::decision::Decision<$inner> as $crate::traits::Problem>::variant,
                 target_variant_fn: <$inner as $crate::traits::Problem>::variant,
-                overhead_fn: || $crate::rules::ReductionOverhead::identity(&[$($sg_name),*]),
+                parameter_declarations_fn: || $crate::rules::registry::ReductionParameterDeclarations {
+                    relation: Some($crate::parameters::ParameterRelation::Exact),
+                    fields: <$inner as $crate::traits::Problem>::parameter_names()
+                        .iter()
+                        .map(|&name| (name, $crate::expr::Expr::variable(name)))
+                        .collect(),
+                    unavailable: vec![],
+                },
                 module_path: module_path!(),
                 reduce_fn: Some(|any| {
                     let source = any
                         .downcast_ref::<$crate::models::decision::Decision<$inner>>()
-                        .expect(concat!($name, " witness reduction source type mismatch"));
-                    Box::new(
-                        <$crate::models::decision::Decision<$inner> as $crate::rules::ReduceTo<$inner>>::reduce_to(source),
-                    )
+                        .ok_or_else($crate::rules::ReductionError::source_type_mismatch::<
+                            $crate::models::decision::Decision<$inner>,
+                            $inner,
+                        >)?;
+                    let result =
+                        <$crate::models::decision::Decision<$inner> as $crate::rules::ReduceTo<$inner>>::reduce_to(source)?;
+                    Ok(Box::new(result))
                 }),
                 reduce_aggregate_fn: Some(|any| {
                     let source = any
                         .downcast_ref::<$crate::models::decision::Decision<$inner>>()
-                        .expect(concat!($name, " aggregate reduction source type mismatch"));
-                    Box::new(
-                        <$crate::models::decision::Decision<$inner> as $crate::rules::ReduceToAggregate<$inner>>::reduce_to_aggregate(source),
-                    )
+                        .ok_or_else($crate::rules::ReductionError::source_type_mismatch::<
+                            $crate::models::decision::Decision<$inner>,
+                            $inner,
+                        >)?;
+                    let result =
+                        <$crate::models::decision::Decision<$inner> as $crate::rules::ReduceToAggregate<$inner>>::reduce_to_aggregate(source)?;
+                    Ok(Box::new(result))
                 }),
-                capabilities: $crate::rules::EdgeCapabilities::both(),
-                overhead_eval_fn: |any| {
-                    let source = any
-                        .downcast_ref::<$crate::models::decision::Decision<$inner>>()
-                        .expect(concat!($name, " overhead source type mismatch"));
-                    $crate::types::ProblemSize::new(vec![
-                        $(($sg_name, source.$sg_method())),*
-                    ])
-                },
-                source_size_fn: |any| {
-                    let source = any
-                        .downcast_ref::<$crate::models::decision::Decision<$inner>>()
-                        .expect(concat!($name, " size source type mismatch"));
-                    $crate::types::ProblemSize::new(vec![
-                        $(($sg_name, source.$sg_method()),)*
-                        ("k", source.k()),
-                    ])
-                },
+                turing: false,
             }
         }
 
@@ -115,30 +120,40 @@ macro_rules! register_decision_variant {
                 target_name: $name,
                 source_variant_fn: <$inner as $crate::traits::Problem>::variant,
                 target_variant_fn: <$crate::models::decision::Decision<$inner> as $crate::traits::Problem>::variant,
-                overhead_fn: || $crate::rules::ReductionOverhead::identity(&[$($sg_name),*]),
+                parameter_declarations_fn: || $crate::rules::registry::ReductionParameterDeclarations {
+                    relation: Some($crate::parameters::ParameterRelation::Exact),
+                    fields: <$inner as $crate::traits::Problem>::parameter_names()
+                        .iter()
+                        .map(|&name| (name, $crate::expr::Expr::variable(name)))
+                        .collect(),
+                    unavailable: vec![],
+                },
                 module_path: module_path!(),
                 reduce_fn: None,
                 reduce_aggregate_fn: None,
-                capabilities: $crate::rules::EdgeCapabilities::turing(),
-                overhead_eval_fn: |any| {
-                    let source = any
-                        .downcast_ref::<$inner>()
-                        .expect(concat!($name, " turing overhead source type mismatch"));
-                    $crate::types::ProblemSize::new(vec![
-                        $(($sg_name, source.$sg_method())),*
-                    ])
-                },
-                source_size_fn: |any| {
-                    let source = any
-                        .downcast_ref::<$inner>()
-                        .expect(concat!($name, " turing size source type mismatch"));
-                    $crate::types::ProblemSize::new(vec![
-                        $(($sg_name, source.$sg_method())),*
-                    ])
-                },
+                turing: true,
             }
         }
     };
+
+    (@declare $inner:ty, $complexity:literal, $decoder:expr, [$($additional:ty => $additional_complexity:literal),*], random) => {
+        $crate::declare_variants! {
+            default $crate::models::decision::Decision<$inner> => $complexity create $crate::models::decision::DecisionCreateSpec<$inner> random,
+            $($crate::models::decision::Decision<$additional> => $additional_complexity create $crate::models::decision::DecisionCreateSpec<$additional>,)*
+        }
+        $crate::register_brute_force! {
+            $crate::models::decision::Decision<$inner> decode $decoder,
+        }
+    };
+    (@declare $inner:ty, $complexity:literal, $decoder:expr, [$($additional:ty => $additional_complexity:literal),*]) => {
+        $crate::declare_variants! {
+            default $crate::models::decision::Decision<$inner> => $complexity create $crate::models::decision::DecisionCreateSpec<$inner>,
+            $($crate::models::decision::Decision<$additional> => $additional_complexity create $crate::models::decision::DecisionCreateSpec<$additional>,)*
+        }
+        $crate::register_brute_force! {
+            $crate::models::decision::Decision<$inner> decode $decoder,
+        }
+    };
     (@display_name "DecisionMinimumVertexCover") => {
         "Decision Minimum Vertex Cover"
     };
@@ -153,6 +168,89 @@ macro_rules! register_decision_variant {
     };
 }
 
+/// Flat construction DTO used by [`register_decision_variant!`].
+///
+/// Persisted decision problems remain `{ "inner": ..., "bound": ... }`, while
+/// construction inputs expose the inner problem's fields beside `bound`.
+#[doc(hidden)]
+pub struct DecisionCreateSpec<P>
+where
+    P: Problem,
+    P::Value: OptimizationValue,
+{
+    inner: P,
+    bound: <P::Value as OptimizationValue>::Inner,
+}
+
+impl<P> crate::registry::CreateSpec for DecisionCreateSpec<P>
+where
+    P: Problem,
+    P::Value: OptimizationValue,
+{
+    const FIELDS: &'static [crate::registry::FieldInfo] = &[];
+
+    fn inputs() -> Vec<crate::registry::CreateInputInfo> {
+        let variant = P::variant()
+            .into_iter()
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+            .collect();
+        let entry = crate::registry::find_variant_entry(P::NAME, &variant)
+            .expect("decision inner variant must be registered");
+        let mut inputs = entry.inputs();
+        inputs.push(crate::registry::CreateInputInfo {
+            name: "bound",
+            type_name: std::any::type_name::<<P::Value as OptimizationValue>::Inner>(),
+            description: "Decision objective bound",
+            required: true,
+            codec: crate::registry::CreateInputCodec::Scalar,
+        });
+        inputs
+    }
+}
+
+impl<'de, P> Deserialize<'de> for DecisionCreateSpec<P>
+where
+    P: Problem + 'static,
+    P::Value: OptimizationValue,
+    <P::Value as OptimizationValue>::Inner: DeserializeOwned,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = serde_json::Value::deserialize(deserializer)?;
+        let mut inputs = value.as_object().cloned().ok_or_else(|| {
+            serde::de::Error::custom("decision construction inputs must be an object")
+        })?;
+        let bound = inputs
+            .remove("bound")
+            .ok_or_else(|| serde::de::Error::missing_field("bound"))?;
+        let variant = P::variant()
+            .into_iter()
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+            .collect();
+        let entry = crate::registry::find_variant_entry(P::NAME, &variant)
+            .expect("decision inner variant must be registered");
+        let constructed = (entry.construct_fn)(serde_json::Value::Object(inputs))
+            .map_err(serde::de::Error::custom)?;
+        let inner = *(constructed as Box<dyn std::any::Any>)
+            .downcast::<P>()
+            .expect("registered constructor must return the declared inner type");
+        let bound = serde_json::from_value(bound).map_err(serde::de::Error::custom)?;
+        Ok(Self { inner, bound })
+    }
+}
+
+impl<P> From<DecisionCreateSpec<P>> for Decision<P>
+where
+    P: Problem,
+    P::Value: OptimizationValue,
+{
+    fn from(spec: DecisionCreateSpec<P>) -> Self {
+        Self::new(spec.inner, spec.bound)
+    }
+}
+
 /// Decision version of an optimization problem with a fixed objective bound.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Decision<P: Problem>
@@ -189,17 +287,24 @@ where
     P::Value: OptimizationValue,
 {
     const NAME: &'static str = P::DECISION_NAME;
+    type Solution = P::Solution;
     type Value = Or;
 
-    fn dims(&self) -> Vec<usize> {
-        self.inner.dims()
+    fn parameter_names() -> &'static [&'static str] {
+        P::parameter_names()
     }
 
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or(<P::Value as OptimizationValue>::meets_bound(
-            &self.inner.evaluate(config),
-            &self.bound,
-        ))
+    fn parameters(&self) -> crate::types::ProblemParameters {
+        self.inner.parameters()
+    }
+
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            Or(<P::Value as OptimizationValue>::meets_bound(
+                &self.inner.evaluate(config)?,
+                &self.bound,
+            ))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -207,6 +312,16 @@ where
     }
 }
 
+impl<P> crate::solvers::BruteForceProblem for Decision<P>
+where
+    P: DecisionProblemMeta + crate::solvers::BruteForceProblem,
+    P::Value: OptimizationValue,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        self.inner.dimensions()
+    }
+}
+
 /// Aggregate reduction result for `Decision<P> -> P`.
 #[derive(Debug, Clone)]
 pub struct DecisionToOptimizationResult<P>
@@ -245,11 +360,11 @@ where
 {
     type Result = DecisionToOptimizationResult<P>;
 
-    fn reduce_to_aggregate(&self) -> Self::Result {
-        DecisionToOptimizationResult {
+    fn reduce_to_aggregate(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(DecisionToOptimizationResult {
             target: self.inner.clone(),
             bound: self.bound.clone(),
-        }
+        })
     }
 }
 
@@ -270,6 +385,7 @@ where
 impl<P> ReductionResult for DecisionToOptimizationWitnessResult<P>
 where
     P: DecisionProblemMeta + 'static,
+    P::Solution: Clone,
     P::Value: OptimizationValue + Serialize + DeserializeOwned,
 {
     type Source = Decision<P>;
@@ -279,22 +395,28 @@ where
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.clone())
     }
 }
 
 impl<P> ReduceTo<P> for Decision<P>
 where
     P: DecisionProblemMeta + Clone + 'static,
+    P::Solution: Clone,
     P::Value: OptimizationValue + Serialize + DeserializeOwned,
 {
     type Result = DecisionToOptimizationWitnessResult<P>;
 
-    fn reduce_to(&self) -> Self::Result {
-        DecisionToOptimizationWitnessResult {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(DecisionToOptimizationWitnessResult {
             target: self.inner.clone(),
-        }
+        })
     }
 }
 
diff --git a/src/models/formula/circuit.rs b/src/models/formula/circuit.rs
index 1a951265c..2e078c074 100644
--- a/src/models/formula/circuit.rs
+++ b/src/models/formula/circuit.rs
@@ -14,6 +14,7 @@ inventory::submit! {
         display_name: "Circuit SAT",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Formula,
         module_path: module_path!(),
         description: "Find satisfying input to a boolean circuit",
         fields: &[
@@ -111,6 +112,17 @@ impl BooleanExpr {
         }
     }
 
+    /// Return the number of nodes in this expression tree.
+    pub fn num_nodes(&self) -> usize {
+        match &self.op {
+            BooleanOp::Var(_) | BooleanOp::Const(_) => 1,
+            BooleanOp::Not(inner) => 1 + inner.num_nodes(),
+            BooleanOp::And(args) | BooleanOp::Or(args) | BooleanOp::Xor(args) => {
+                1 + args.iter().map(BooleanExpr::num_nodes).sum::<usize>()
+            }
+        }
+    }
+
     /// Evaluate the expression given variable assignments.
     pub fn evaluate(&self, assignments: &HashMap<String, bool>) -> bool {
         match &self.op {
@@ -187,6 +199,22 @@ impl Circuit {
     pub fn num_assignments(&self) -> usize {
         self.assignments.len()
     }
+
+    /// Return the total number of Boolean expression nodes.
+    pub fn num_expression_nodes(&self) -> usize {
+        self.assignments
+            .iter()
+            .map(|assignment| assignment.expr.num_nodes())
+            .sum()
+    }
+
+    /// Return the total number of assignment outputs.
+    pub fn num_assignment_outputs(&self) -> usize {
+        self.assignments
+            .iter()
+            .map(|assignment| assignment.outputs.len())
+            .sum()
+    }
 }
 
 /// The Circuit SAT problem.
@@ -198,7 +226,7 @@ impl Circuit {
 ///
 /// ```
 /// use problemreductions::models::formula::{CircuitSAT, BooleanExpr, Assignment, Circuit};
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Create a simple circuit: c = x AND y
 /// let circuit = Circuit::new(vec![
@@ -210,7 +238,7 @@ impl Circuit {
 ///
 /// let problem = CircuitSAT::new(circuit);
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Multiple satisfying assignments exist
 /// assert!(!solutions.is_empty());
@@ -250,22 +278,40 @@ impl CircuitSAT {
         self.circuit.num_assignments()
     }
 
+    /// Return the total number of Boolean expression nodes.
+    pub fn num_expression_nodes(&self) -> usize {
+        self.circuit.num_expression_nodes()
+    }
+
+    /// Return the total number of assignment outputs.
+    pub fn num_assignment_outputs(&self) -> usize {
+        self.circuit.num_assignment_outputs()
+    }
+
     /// Check if a configuration is a valid satisfying assignment.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.count_satisfied(config) == self.circuit.num_assignments()
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if config.len() != self.variables.len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "assignment length does not match the circuit variables".into(),
+            ));
+        }
+        Ok(self.count_satisfied(config) == self.circuit.num_assignments())
     }
 
     /// Convert a configuration to variable assignments.
-    fn config_to_assignments(&self, config: &[usize]) -> HashMap<String, bool> {
+    fn config_to_assignments(&self, config: &[bool]) -> HashMap<String, bool> {
         self.variables
             .iter()
             .enumerate()
-            .map(|(i, name)| (name.clone(), config.get(i).copied().unwrap_or(0) == 1))
+            .map(|(i, name)| (name.clone(), config[i]))
             .collect()
     }
 
     /// Count how many assignments are satisfied.
-    fn count_satisfied(&self, config: &[usize]) -> usize {
+    fn count_satisfied(&self, config: &[bool]) -> usize {
         let assignments = self.config_to_assignments(config);
         self.circuit
             .assignments
@@ -289,14 +335,21 @@ pub(crate) fn is_circuit_satisfying(
 
 impl Problem for CircuitSAT {
     const NAME: &'static str = "CircuitSAT";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.variables.len()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.count_satisfied(config) == self.circuit.num_assignments())
+    crate::problem_parameters![
+        ("num_assignment_outputs", num_assignment_outputs),
+        ("num_assignments", num_assignments),
+        ("num_expression_nodes", num_expression_nodes),
+        ("num_variables", num_variables),
+    ];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -304,10 +357,20 @@ impl Problem for CircuitSAT {
     }
 }
 
+impl crate::solvers::BruteForceProblem for CircuitSAT {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.variables.len()]
+    }
+}
+
 crate::declare_variants! {
     default CircuitSAT => "2^num_variables",
 }
 
+crate::register_brute_force! {
+    CircuitSAT decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -326,7 +389,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 BooleanExpr::xor(vec![BooleanExpr::var("a"), BooleanExpr::var("b")]),
             ),
         ]))),
-        optimal_config: vec![0, 0, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![false, false, false, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/formula/ksat.rs b/src/models/formula/ksat.rs
index 1dc118638..dede5be57 100644
--- a/src/models/formula/ksat.rs
+++ b/src/models/formula/ksat.rs
@@ -8,9 +8,9 @@
 use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
 use crate::traits::Problem;
 use crate::variant::{KValue, K2, K3, KN};
-use serde::{Deserialize, Serialize};
+use serde::{de::Error as _, Deserialize, Deserializer, Serialize};
 
-use super::CNFClause;
+use super::{sat::validate_cnf_literals, CNFClause};
 
 pub(crate) fn first_n_odd_primes(count: usize) -> Vec<u64> {
     let mut primes = Vec::with_capacity(count);
@@ -54,6 +54,7 @@ inventory::submit! {
         display_name: "K-Satisfiability",
         aliases: &["KSAT"],
         dimensions: &[VariantDimension::new("k", "KN", &["KN", "K2", "K3"])],
+        category: crate::registry::ProblemCategory::Formula,
         module_path: module_path!(),
         description: "SAT with exactly k literals per clause",
         fields: &[
@@ -78,7 +79,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::formula::{KSatisfiability, CNFClause};
 /// use problemreductions::variant::K3;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 3-SAT formula: (x1 OR x2 OR x3) AND (NOT x1 OR x2 OR NOT x3)
 /// let problem = KSatisfiability::<K3>::new(
@@ -90,11 +91,10 @@ inventory::submit! {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 /// assert!(!solutions.is_empty());
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(bound(deserialize = ""))]
+#[derive(Debug, Clone, Serialize)]
 pub struct KSatisfiability<K: KValue> {
     /// Number of variables.
     num_vars: usize,
@@ -104,6 +104,22 @@ pub struct KSatisfiability<K: KValue> {
     _phantom: std::marker::PhantomData<K>,
 }
 
+#[derive(Deserialize)]
+struct KSatisfiabilityDef {
+    num_vars: usize,
+    clauses: Vec<CNFClause>,
+}
+
+impl<'de, K: KValue> Deserialize<'de> for KSatisfiability<K> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = KSatisfiabilityDef::deserialize(deserializer)?;
+        Self::try_new(value.num_vars, value.clauses).map_err(D::Error::custom)
+    }
+}
+
 impl<K: KValue> KSatisfiability<K> {
     /// Create a new K-SAT problem.
     ///
@@ -112,22 +128,29 @@ impl<K: KValue> KSatisfiability<K> {
     /// concrete value like K2, K3). When K is KN (arbitrary), no clause-length
     /// validation is performed.
     pub fn new(num_vars: usize, clauses: Vec<CNFClause>) -> Self {
+        Self::try_new(num_vars, clauses).unwrap_or_else(|message| panic!("{message}"))
+    }
+
+    /// Create a K-SAT problem after validating its clauses.
+    pub fn try_new(
+        num_vars: usize,
+        clauses: Vec<CNFClause>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        validate_cnf_literals(num_vars, &clauses)?;
         if let Some(k) = K::K {
             for (i, clause) in clauses.iter().enumerate() {
-                assert!(
-                    clause.len() == k,
-                    "Clause {} has {} literals, expected {}",
-                    i,
-                    clause.len(),
-                    k
-                );
+                if clause.len() != k {
+                    return Err(
+                        format!("Clause {i} has {} literals, expected {k}", clause.len()).into(),
+                    );
+                }
             }
         }
-        Self {
+        Ok(Self {
             num_vars,
             clauses,
             _phantom: std::marker::PhantomData,
-        }
+        })
     }
 
     /// Create a new K-SAT problem allowing clauses with fewer than K literals.
@@ -140,22 +163,31 @@ impl<K: KValue> KSatisfiability<K> {
     /// value like K2, K3). When K is KN (arbitrary), no clause-length
     /// validation is performed.
     pub fn new_allow_less(num_vars: usize, clauses: Vec<CNFClause>) -> Self {
+        Self::try_new_allow_less(num_vars, clauses).unwrap_or_else(|message| panic!("{message}"))
+    }
+
+    /// Create a K-SAT problem with shorter clauses after validation.
+    pub fn try_new_allow_less(
+        num_vars: usize,
+        clauses: Vec<CNFClause>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        validate_cnf_literals(num_vars, &clauses)?;
         if let Some(k) = K::K {
             for (i, clause) in clauses.iter().enumerate() {
-                assert!(
-                    clause.len() <= k,
-                    "Clause {} has {} literals, expected at most {}",
-                    i,
-                    clause.len(),
-                    k
-                );
+                if clause.len() > k {
+                    return Err(format!(
+                        "Clause {i} has {} literals, expected at most {k}",
+                        clause.len()
+                    )
+                    .into());
+                }
             }
         }
-        Self {
+        Ok(Self {
             num_vars,
             clauses,
             _phantom: std::marker::PhantomData,
-        }
+        })
     }
 
     /// Get the number of variables.
@@ -183,34 +215,21 @@ impl<K: KValue> KSatisfiability<K> {
         self.clauses().iter().map(|c| c.len()).sum()
     }
 
-    /// Padding term used by Sethi's Register Sufficiency reduction.
-    pub fn register_sufficiency_padding(&self) -> usize {
-        (2 * self.num_vars).saturating_sub(self.num_clauses())
-    }
-
-    pub fn simultaneous_incongruences_num_incongruences(&self) -> usize {
-        first_n_odd_primes(self.num_vars)
-            .into_iter()
-            .map(|prime| usize::try_from(prime - 2).expect("prime fits in usize"))
-            .sum::<usize>()
-            + self.num_clauses()
-    }
-
-    pub fn simultaneous_incongruences_bound(&self) -> usize {
-        first_n_odd_primes(self.num_vars)
-            .into_iter()
-            .try_fold(1usize, |product, prime| {
-                product.checked_mul(usize::try_from(prime).expect("prime fits in usize"))
-            })
-            .expect("simultaneous incongruences bound must fit in usize")
-    }
-
     /// Count satisfied clauses for an assignment.
-    pub fn count_satisfied(&self, assignment: &[bool]) -> usize {
-        self.clauses
+    pub fn count_satisfied(
+        &self,
+        assignment: &[bool],
+    ) -> Result<i64, crate::traits::EvaluationError> {
+        let count = self
+            .clauses
             .iter()
             .filter(|c| c.is_satisfied(assignment))
-            .count()
+            .count();
+        i64::try_from(count).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting satisfied-clause count to i64".into(),
+            )
+        })
     }
 
     /// Check if an assignment satisfies all clauses.
@@ -221,17 +240,25 @@ impl<K: KValue> KSatisfiability<K> {
 
 impl<K: KValue> Problem for KSatisfiability<K> {
     const NAME: &'static str = "KSatisfiability";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_vars]
-    }
+    crate::problem_parameters![
+        ("num_clauses", num_clauses),
+        ("num_literals", num_literals),
+        ("num_vars", num_vars),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let assignment = super::config_to_assignment(config);
-            self.is_satisfying(&assignment)
-        })
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_vars {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "assignment length does not match the formula variables".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_satisfying(config)))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -239,10 +266,22 @@ impl<K: KValue> Problem for KSatisfiability<K> {
     }
 }
 
+impl<K: KValue> crate::solvers::BruteForceProblem for KSatisfiability<K> {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_vars]
+    }
+}
+
 crate::declare_variants! {
-    default KSatisfiability<KN> => "2^num_variables",
-    KSatisfiability<K2> => "num_variables + num_clauses" aliases ["2SAT"],
-    KSatisfiability<K3> => "1.307^num_variables" aliases ["3SAT"],
+    default KSatisfiability<KN> => "2^num_vars",
+    KSatisfiability<K2> => "num_vars + num_clauses" aliases ["2SAT"],
+    KSatisfiability<K3> => "1.307^num_vars" aliases ["3SAT"],
+}
+
+crate::register_brute_force! {
+    KSatisfiability<KN> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    KSatisfiability<K2> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    KSatisfiability<K3> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -258,7 +297,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 CNFClause::new(vec![1, -2, -3]),
             ],
         )),
-        optimal_config: vec![0, 0, 1],
+        optimal_config: serde_json::json!(vec![false, false, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/formula/maximum_2_satisfiability.rs b/src/models/formula/maximum_2_satisfiability.rs
index 6d9f20843..5085b21ff 100644
--- a/src/models/formula/maximum_2_satisfiability.rs
+++ b/src/models/formula/maximum_2_satisfiability.rs
@@ -9,7 +9,7 @@ use crate::traits::Problem;
 use crate::types::Max;
 use serde::{Deserialize, Serialize};
 
-use super::CNFClause;
+use super::{sat::validate_cnf_literals, CNFClause};
 
 inventory::submit! {
     ProblemSchemaEntry {
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Maximum 2-Satisfiability",
         aliases: &["MAX2SAT"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Formula,
         module_path: module_path!(),
         description: "Maximize the number of satisfied 2-literal clauses",
         fields: &[
@@ -36,7 +37,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::formula::{Maximum2Satisfiability, CNFClause};
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = Maximum2Satisfiability::new(
 ///     3,
@@ -48,9 +49,10 @@ inventory::submit! {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// let value = solver.solve(&problem);
+/// let value = solver.solve(&problem).unwrap();
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(try_from = "Maximum2SatisfiabilityDef")]
 pub struct Maximum2Satisfiability {
     /// Number of Boolean variables.
     num_vars: usize,
@@ -64,15 +66,21 @@ impl Maximum2Satisfiability {
     /// # Panics
     /// Panics if any clause does not have exactly 2 literals.
     pub fn new(num_vars: usize, clauses: Vec<CNFClause>) -> Self {
+        Self::try_new(num_vars, clauses).unwrap_or_else(|message| panic!("{message}"))
+    }
+
+    /// Create a new MAX-2-SAT problem after validating its clauses.
+    pub fn try_new(
+        num_vars: usize,
+        clauses: Vec<CNFClause>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        validate_cnf_literals(num_vars, &clauses)?;
         for (i, clause) in clauses.iter().enumerate() {
-            assert!(
-                clause.len() == 2,
-                "Clause {} has {} literals, expected 2",
-                i,
-                clause.len()
-            );
+            if clause.len() != 2 {
+                return Err(format!("Clause {i} has {} literals, expected 2", clause.len()).into());
+            }
         }
-        Self { num_vars, clauses }
+        Ok(Self { num_vars, clauses })
     }
 
     /// Get the number of variables.
@@ -91,25 +99,40 @@ impl Maximum2Satisfiability {
     }
 
     /// Count satisfied clauses for an assignment.
-    pub fn count_satisfied(&self, assignment: &[bool]) -> usize {
-        self.clauses
+    pub fn count_satisfied(
+        &self,
+        assignment: &[bool],
+    ) -> Result<i64, crate::traits::EvaluationError> {
+        let count = self
+            .clauses
             .iter()
             .filter(|c| c.is_satisfied(assignment))
-            .count()
+            .count();
+        i64::try_from(count).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting satisfied-clause count to i64".into(),
+            )
+        })
     }
 }
 
 impl Problem for Maximum2Satisfiability {
     const NAME: &'static str = "Maximum2Satisfiability";
-    type Value = Max<usize>;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_vars]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Max<usize> {
-        let assignment = super::config_to_assignment(config);
-        Max(Some(self.count_satisfied(&assignment)))
+    type Solution = Vec<bool>;
+    type Value = Max<i64>;
+
+    crate::problem_parameters![("num_clauses", num_clauses), ("num_vars", num_vars),];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.num_vars {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "assignment length does not match the formula variables".into(),
+            ));
+        }
+        Ok(Max(Some(self.count_satisfied(config)?)))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -117,8 +140,32 @@ impl Problem for Maximum2Satisfiability {
     }
 }
 
+impl crate::solvers::BruteForceProblem for Maximum2Satisfiability {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_vars]
+    }
+}
+
 crate::declare_variants! {
-    default Maximum2Satisfiability => "2^(0.7905 * num_variables)",
+    default Maximum2Satisfiability => "2^(0.7905 * num_vars)",
+}
+
+crate::register_brute_force! {
+    Maximum2Satisfiability decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
+#[derive(Deserialize)]
+struct Maximum2SatisfiabilityDef {
+    num_vars: usize,
+    clauses: Vec<CNFClause>,
+}
+
+impl TryFrom<Maximum2SatisfiabilityDef> for Maximum2Satisfiability {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(value: Maximum2SatisfiabilityDef) -> Result<Self, Self::Error> {
+        Self::try_new(value.num_vars, value.clauses)
+    }
 }
 
 #[cfg(feature = "example-db")]
@@ -137,7 +184,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 CNFClause::new(vec![3, 4]),
             ],
         )),
-        optimal_config: vec![1, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![true, true, false, true]),
         optimal_value: serde_json::json!(6),
     }]
 }
diff --git a/src/models/formula/mod.rs b/src/models/formula/mod.rs
index e2c09d8d8..52bc6c034 100644
--- a/src/models/formula/mod.rs
+++ b/src/models/formula/mod.rs
@@ -31,11 +31,6 @@ pub use planar_3_satisfiability::Planar3Satisfiability;
 pub use qbf::{QuantifiedBooleanFormulas, Quantifier};
 pub use sat::{CNFClause, Satisfiability};
 
-/// Convert a binary config (0/1 per variable) to a boolean assignment.
-pub(crate) fn config_to_assignment(config: &[usize]) -> Vec<bool> {
-    config.iter().map(|&v| v == 1).collect()
-}
-
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     let mut specs = Vec::new();
diff --git a/src/models/formula/nae_satisfiability.rs b/src/models/formula/nae_satisfiability.rs
index 5e79f2de4..f65fdb717 100644
--- a/src/models/formula/nae_satisfiability.rs
+++ b/src/models/formula/nae_satisfiability.rs
@@ -7,7 +7,7 @@ use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
-use super::CNFClause;
+use super::{sat::validate_cnf_literals, CNFClause};
 
 inventory::submit! {
     ProblemSchemaEntry {
@@ -15,6 +15,7 @@ inventory::submit! {
         display_name: "Not-All-Equal Satisfiability",
         aliases: &["NAESAT"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Formula,
         module_path: module_path!(),
         description: "Find an assignment where every CNF clause has both a true and a false literal",
         fields: &[
@@ -49,7 +50,11 @@ impl NAESatisfiability {
 
     /// Create a new NAE-SAT problem, returning an error instead of panicking
     /// when a clause has fewer than two literals.
-    pub fn try_new(num_vars: usize, clauses: Vec<CNFClause>) -> Result<Self, String> {
+    pub fn try_new(
+        num_vars: usize,
+        clauses: Vec<CNFClause>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        validate_cnf_literals(num_vars, &clauses)?;
         validate_clause_lengths(&clauses)?;
         Ok(Self { num_vars, clauses })
     }
@@ -90,11 +95,20 @@ impl NAESatisfiability {
     }
 
     /// Count how many clauses satisfy the NAE condition under an assignment.
-    pub fn count_nae_satisfied(&self, assignment: &[bool]) -> usize {
-        self.clauses
+    pub fn count_nae_satisfied(
+        &self,
+        assignment: &[bool],
+    ) -> Result<i64, crate::traits::EvaluationError> {
+        let count = self
+            .clauses
             .iter()
             .filter(|clause| Self::clause_is_nae_satisfied(clause, assignment))
-            .count()
+            .count();
+        i64::try_from(count).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting NAE-satisfied-clause count to i64".into(),
+            )
+        })
     }
 
     /// Check whether all clauses satisfy the NAE condition under an assignment.
@@ -105,11 +119,19 @@ impl NAESatisfiability {
     }
 
     /// Check if a solution (config) is valid.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if config.len() != self.num_vars {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "assignment length does not match the formula variables".into(),
+            ));
+        }
+        Ok(self.is_nae_satisfying(config))
     }
 
-    fn literal_value(lit: i32, assignment: &[bool]) -> bool {
+    fn literal_value(lit: i64, assignment: &[bool]) -> bool {
         let var = lit.unsigned_abs() as usize - 1;
         let value = assignment.get(var).copied().unwrap_or(false);
         if lit > 0 {
@@ -141,17 +163,21 @@ impl NAESatisfiability {
 
 impl Problem for NAESatisfiability {
     const NAME: &'static str = "NAESatisfiability";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_vars]
-    }
+    crate::problem_parameters![
+        ("num_clauses", num_clauses),
+        ("num_literal_pairs", num_literal_pairs),
+        ("num_literals", num_literals),
+        ("num_vars", num_vars),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let assignment = super::config_to_assignment(config);
-            self.is_nae_satisfying(&assignment)
-        })
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -159,8 +185,18 @@ impl Problem for NAESatisfiability {
     }
 }
 
+impl crate::solvers::BruteForceProblem for NAESatisfiability {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_vars]
+    }
+}
+
 crate::declare_variants! {
-    default NAESatisfiability => "2^num_variables",
+    default NAESatisfiability => "2^num_vars",
+}
+
+crate::register_brute_force! {
+    NAESatisfiability decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -170,21 +206,24 @@ struct NAESatisfiabilityDef {
 }
 
 impl TryFrom<NAESatisfiabilityDef> for NAESatisfiability {
-    type Error = String;
+    type Error = crate::registry::ConstructionError;
 
     fn try_from(value: NAESatisfiabilityDef) -> Result<Self, Self::Error> {
         Self::try_new(value.num_vars, value.clauses)
     }
 }
 
-fn validate_clause_lengths(clauses: &[CNFClause]) -> Result<(), String> {
+fn validate_clause_lengths(
+    clauses: &[CNFClause],
+) -> Result<(), crate::registry::ConstructionError> {
     for (index, clause) in clauses.iter().enumerate() {
         if clause.len() < 2 {
             return Err(format!(
                 "Clause {} has {} literals, expected at least 2",
                 index,
                 clause.len()
-            ));
+            )
+            .into());
         }
     }
     Ok(())
@@ -204,7 +243,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 CNFClause::new(vec![1, -3, 5]),
             ],
         )),
-        optimal_config: vec![0, 0, 0, 1, 1],
+        optimal_config: serde_json::json!(vec![false, false, false, true, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/formula/non_tautology.rs b/src/models/formula/non_tautology.rs
index 7e983cfb8..a45f40aab 100644
--- a/src/models/formula/non_tautology.rs
+++ b/src/models/formula/non_tautology.rs
@@ -4,7 +4,7 @@
 //! there exists a truth assignment that makes the formula false — i.e., the
 //! formula is not a tautology.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{ConstructionError, FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,11 +14,12 @@ inventory::submit! {
         display_name: "Non-Tautology",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Formula,
         module_path: module_path!(),
         description: "Find a falsifying assignment for a DNF formula (proving it is not a tautology)",
         fields: &[
             FieldInfo { name: "num_vars", type_name: "usize", description: "Number of Boolean variables" },
-            FieldInfo { name: "disjuncts", type_name: "Vec<Vec<i32>>", description: "Disjuncts (each a conjunction of literals) in disjunctive normal form" },
+            FieldInfo { name: "disjuncts", type_name: "Vec<Vec<i64>>", description: "Disjuncts (each a conjunction of literals) in disjunctive normal form" },
         ],
     }
 }
@@ -38,50 +39,60 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::formula::NonTautology;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // (x1 AND x2 AND x3) OR (NOT x1 AND NOT x2 AND NOT x3)
 /// let problem = NonTautology::new(
 ///     3,
 ///     vec![vec![1, 2, 3], vec![-1, -2, -3]],
-/// );
+/// ).unwrap();
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct NonTautology {
     /// Number of variables.
     num_vars: usize,
     /// Disjuncts in DNF. Each disjunct is a conjunction of literals
     /// represented as signed integers (positive = variable, negative = negation).
-    disjuncts: Vec<Vec<i32>>,
+    disjuncts: Vec<Vec<i64>>,
 }
 
 impl NonTautology {
     /// Create a new Non-Tautology problem.
     ///
-    /// # Panics
-    /// Panics if any literal references a variable outside the range [1, num_vars].
-    pub fn new(num_vars: usize, disjuncts: Vec<Vec<i32>>) -> Self {
+    pub fn new(num_vars: usize, disjuncts: Vec<Vec<i64>>) -> Result<Self, ConstructionError> {
+        if num_vars > i64::MAX as usize {
+            return Err(ConstructionError::IntegerOverflow(format!(
+                "num_vars {num_vars} exceeds the SAT literal limit {}",
+                i64::MAX
+            )));
+        }
         for (i, disjunct) in disjuncts.iter().enumerate() {
             for &lit in disjunct {
-                let var = lit.unsigned_abs() as usize;
-                assert!(
-                    var >= 1 && var <= num_vars,
-                    "Disjunct {} contains literal {} referencing variable {} outside range [1, {}]",
-                    i,
-                    lit,
-                    var,
-                    num_vars
-                );
+                if lit == 0 || lit == i64::MIN {
+                    return Err(ConstructionError::Conversion(format!(
+                        "disjunct {i} contains invalid literal {lit}; allowed variable numbers are 1..={num_vars} with either sign"
+                    )));
+                }
+                let var = usize::try_from(lit.unsigned_abs()).map_err(|_| {
+                    ConstructionError::IntegerOverflow(format!(
+                        "literal {lit} magnitude does not fit usize"
+                    ))
+                })?;
+                if var > num_vars {
+                    return Err(ConstructionError::Conversion(format!(
+                        "disjunct {i} contains literal {lit} referencing variable {var} outside range [1, {num_vars}]"
+                    )));
+                }
             }
         }
-        Self {
+        Ok(Self {
             num_vars,
             disjuncts,
-        }
+        })
     }
 
     /// Get the number of variables.
@@ -95,12 +106,12 @@ impl NonTautology {
     }
 
     /// Get the disjuncts.
-    pub fn disjuncts(&self) -> &[Vec<i32>] {
+    pub fn disjuncts(&self) -> &[Vec<i64>] {
         &self.disjuncts
     }
 
     /// Check if a literal is true under the given assignment.
-    fn literal_is_true(lit: i32, assignment: &[bool]) -> bool {
+    fn literal_is_true(lit: i64, assignment: &[bool]) -> bool {
         let var = lit.unsigned_abs() as usize - 1;
         let value = assignment.get(var).copied().unwrap_or(false);
         if lit > 0 {
@@ -125,19 +136,39 @@ impl NonTautology {
     }
 }
 
+impl<'de> Deserialize<'de> for NonTautology {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Raw {
+            num_vars: usize,
+            disjuncts: Vec<Vec<i64>>,
+        }
+
+        let raw = Raw::deserialize(deserializer)?;
+        Self::new(raw.num_vars, raw.disjuncts).map_err(serde::de::Error::custom)
+    }
+}
+
 impl Problem for NonTautology {
     const NAME: &'static str = "NonTautology";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_vars]
-    }
+    crate::problem_parameters![("num_disjuncts", num_disjuncts), ("num_vars", num_vars),];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let assignment = super::config_to_assignment(config);
-            self.is_falsifying(&assignment)
-        })
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_vars {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "assignment length does not match the formula variables".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_falsifying(config)))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -145,16 +176,29 @@ impl Problem for NonTautology {
     }
 }
 
+impl crate::solvers::BruteForceProblem for NonTautology {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_vars]
+    }
+}
+
 crate::declare_variants! {
-    default NonTautology => "1.307^num_variables",
+    default NonTautology => "1.307^num_vars",
+}
+
+crate::register_brute_force! {
+    NonTautology decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "non_tautology",
-        instance: Box::new(NonTautology::new(3, vec![vec![1, 2, 3], vec![-1, -2, -3]])),
-        optimal_config: vec![1, 0, 0],
+        instance: Box::new(
+            NonTautology::new(3, vec![vec![1, 2, 3], vec![-1, -2, -3]])
+                .expect("canonical non-tautology instance must be valid"),
+        ),
+        optimal_config: serde_json::json!(vec![true, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/formula/one_in_three_satisfiability.rs b/src/models/formula/one_in_three_satisfiability.rs
index 8b5453ee3..f78004e32 100644
--- a/src/models/formula/one_in_three_satisfiability.rs
+++ b/src/models/formula/one_in_three_satisfiability.rs
@@ -8,7 +8,7 @@ use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
-use super::CNFClause;
+use super::{sat::validate_cnf_literals, CNFClause};
 
 inventory::submit! {
     ProblemSchemaEntry {
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "One-in-Three Satisfiability",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Formula,
         module_path: module_path!(),
         description: "3-SAT variant where each clause has exactly one true literal",
         fields: &[
@@ -38,7 +39,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::formula::{OneInThreeSatisfiability, CNFClause};
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // (x1 OR x2 OR x3) AND (NOT x1 OR x3 OR x4) AND (x2 OR NOT x3 OR NOT x4)
 /// let problem = OneInThreeSatisfiability::new(
@@ -51,10 +52,11 @@ inventory::submit! {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(try_from = "OneInThreeSatisfiabilityDef")]
 pub struct OneInThreeSatisfiability {
     /// Number of variables.
     num_vars: usize,
@@ -69,26 +71,21 @@ impl OneInThreeSatisfiability {
     /// Panics if any clause does not have exactly 3 literals, or if any
     /// literal references a variable outside the range [1, num_vars].
     pub fn new(num_vars: usize, clauses: Vec<CNFClause>) -> Self {
+        Self::try_new(num_vars, clauses).unwrap_or_else(|message| panic!("{message}"))
+    }
+
+    /// Create a new 1-in-3 SAT problem after validating its clauses.
+    pub fn try_new(
+        num_vars: usize,
+        clauses: Vec<CNFClause>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        validate_cnf_literals(num_vars, &clauses)?;
         for (i, clause) in clauses.iter().enumerate() {
-            assert!(
-                clause.len() == 3,
-                "Clause {} has {} literals, expected 3",
-                i,
-                clause.len()
-            );
-            for &lit in &clause.literals {
-                let var = lit.unsigned_abs() as usize;
-                assert!(
-                    var >= 1 && var <= num_vars,
-                    "Clause {} contains literal {} referencing variable {} outside range [1, {}]",
-                    i,
-                    lit,
-                    var,
-                    num_vars
-                );
+            if clause.len() != 3 {
+                return Err(format!("Clause {i} has {} literals, expected 3", clause.len()).into());
             }
         }
-        Self { num_vars, clauses }
+        Ok(Self { num_vars, clauses })
     }
 
     /// Get the number of variables.
@@ -134,17 +131,21 @@ impl OneInThreeSatisfiability {
 
 impl Problem for OneInThreeSatisfiability {
     const NAME: &'static str = "OneInThreeSatisfiability";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_vars]
-    }
+    crate::problem_parameters![("num_clauses", num_clauses), ("num_vars", num_vars),];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let assignment = super::config_to_assignment(config);
-            self.is_one_in_three_satisfying(&assignment)
-        })
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_vars {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "assignment length does not match the formula variables".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_one_in_three_satisfying(config)))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -152,8 +153,32 @@ impl Problem for OneInThreeSatisfiability {
     }
 }
 
+impl crate::solvers::BruteForceProblem for OneInThreeSatisfiability {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_vars]
+    }
+}
+
 crate::declare_variants! {
-    default OneInThreeSatisfiability => "1.307^num_variables",
+    default OneInThreeSatisfiability => "1.307^num_vars",
+}
+
+crate::register_brute_force! {
+    OneInThreeSatisfiability decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
+#[derive(Deserialize)]
+struct OneInThreeSatisfiabilityDef {
+    num_vars: usize,
+    clauses: Vec<CNFClause>,
+}
+
+impl TryFrom<OneInThreeSatisfiabilityDef> for OneInThreeSatisfiability {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(value: OneInThreeSatisfiabilityDef) -> Result<Self, Self::Error> {
+        Self::try_new(value.num_vars, value.clauses)
+    }
 }
 
 #[cfg(feature = "example-db")]
@@ -168,7 +193,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 CNFClause::new(vec![2, -3, -4]),
             ],
         )),
-        optimal_config: vec![1, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![true, false, false, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/formula/planar_3_satisfiability.rs b/src/models/formula/planar_3_satisfiability.rs
index b3b91871b..f32349663 100644
--- a/src/models/formula/planar_3_satisfiability.rs
+++ b/src/models/formula/planar_3_satisfiability.rs
@@ -9,7 +9,7 @@ use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
-use super::CNFClause;
+use super::{sat::validate_cnf_literals, CNFClause};
 
 inventory::submit! {
     ProblemSchemaEntry {
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Planar 3-Satisfiability",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Formula,
         module_path: module_path!(),
         description: "3-SAT with planar variable-clause incidence graph",
         fields: &[
@@ -45,7 +46,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::formula::{Planar3Satisfiability, CNFClause};
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Formula: (x1 OR x2 OR x3) AND (NOT x1 OR x2 OR x4)
 /// //       AND (x1 OR NOT x3 OR x4) AND (NOT x2 OR x3 OR NOT x4)
@@ -60,10 +61,11 @@ inventory::submit! {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(try_from = "Planar3SatisfiabilityDef")]
 pub struct Planar3Satisfiability {
     /// Number of variables.
     num_vars: usize,
@@ -80,26 +82,21 @@ impl Planar3Satisfiability {
     ///
     /// **Note:** Planarity of the incidence graph is not checked.
     pub fn new(num_vars: usize, clauses: Vec<CNFClause>) -> Self {
+        Self::try_new(num_vars, clauses).unwrap_or_else(|message| panic!("{message}"))
+    }
+
+    /// Create a new Planar 3-SAT problem after validating its clauses.
+    pub fn try_new(
+        num_vars: usize,
+        clauses: Vec<CNFClause>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        validate_cnf_literals(num_vars, &clauses)?;
         for (i, clause) in clauses.iter().enumerate() {
-            assert!(
-                clause.len() == 3,
-                "Clause {} has {} literals, expected 3",
-                i,
-                clause.len()
-            );
-            for &lit in &clause.literals {
-                let var = lit.unsigned_abs() as usize;
-                assert!(
-                    var >= 1 && var <= num_vars,
-                    "Clause {} contains literal {} referencing variable {} outside range [1, {}]",
-                    i,
-                    lit,
-                    var,
-                    num_vars
-                );
+            if clause.len() != 3 {
+                return Err(format!("Clause {i} has {} literals, expected 3", clause.len()).into());
             }
         }
-        Self { num_vars, clauses }
+        Ok(Self { num_vars, clauses })
     }
 
     /// Get the number of variables.
@@ -130,17 +127,21 @@ impl Planar3Satisfiability {
 
 impl Problem for Planar3Satisfiability {
     const NAME: &'static str = "Planar3Satisfiability";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_vars]
-    }
+    crate::problem_parameters![("num_vars", num_vars), ("num_clauses", num_clauses),];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let assignment = super::config_to_assignment(config);
-            self.is_satisfying(&assignment)
-        })
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_vars {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "assignment length does not match the formula variables".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_satisfying(config)))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -148,8 +149,32 @@ impl Problem for Planar3Satisfiability {
     }
 }
 
+impl crate::solvers::BruteForceProblem for Planar3Satisfiability {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_vars]
+    }
+}
+
 crate::declare_variants! {
-    default Planar3Satisfiability => "1.307^num_variables",
+    default Planar3Satisfiability => "1.307^num_vars",
+}
+
+crate::register_brute_force! {
+    Planar3Satisfiability decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
+#[derive(Deserialize)]
+struct Planar3SatisfiabilityDef {
+    num_vars: usize,
+    clauses: Vec<CNFClause>,
+}
+
+impl TryFrom<Planar3SatisfiabilityDef> for Planar3Satisfiability {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(value: Planar3SatisfiabilityDef) -> Result<Self, Self::Error> {
+        Self::try_new(value.num_vars, value.clauses)
+    }
 }
 
 #[cfg(feature = "example-db")]
@@ -165,7 +190,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 CNFClause::new(vec![-2, 3, -4]),
             ],
         )),
-        optimal_config: vec![1, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![true, true, true, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/formula/qbf.rs b/src/models/formula/qbf.rs
index d202e9f17..4aec9a7d7 100644
--- a/src/models/formula/qbf.rs
+++ b/src/models/formula/qbf.rs
@@ -8,7 +8,7 @@
 //! ∀ (ForAll) or ∃ (Exists) and E is a Boolean expression in CNF,
 //! determine whether F is true.
 
-use crate::models::formula::CNFClause;
+use crate::models::formula::{sat::validate_cnf_literals, CNFClause};
 use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -19,6 +19,7 @@ inventory::submit! {
         display_name: "Quantified Boolean Formulas",
         aliases: &["QBF"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Formula,
         module_path: module_path!(),
         description: "Determine if a quantified Boolean formula is true",
         fields: &[
@@ -63,6 +64,7 @@ pub enum Quantifier {
 /// assert!(problem.is_true());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(try_from = "QuantifiedBooleanFormulasDef")]
 pub struct QuantifiedBooleanFormulas {
     /// Number of variables.
     num_vars: usize,
@@ -79,18 +81,28 @@ impl QuantifiedBooleanFormulas {
     ///
     /// Panics if `quantifiers.len() != num_vars`.
     pub fn new(num_vars: usize, quantifiers: Vec<Quantifier>, clauses: Vec<CNFClause>) -> Self {
-        assert_eq!(
-            quantifiers.len(),
-            num_vars,
-            "quantifiers length ({}) must equal num_vars ({})",
-            quantifiers.len(),
-            num_vars
-        );
-        Self {
+        Self::try_new(num_vars, quantifiers, clauses).unwrap_or_else(|message| panic!("{message}"))
+    }
+
+    /// Create a QBF problem after validating its quantifiers and CNF literals.
+    pub fn try_new(
+        num_vars: usize,
+        quantifiers: Vec<Quantifier>,
+        clauses: Vec<CNFClause>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        if quantifiers.len() != num_vars {
+            return Err(format!(
+                "quantifiers length ({}) must equal num_vars ({num_vars})",
+                quantifiers.len()
+            )
+            .into());
+        }
+        validate_cnf_literals(num_vars, &clauses)?;
+        Ok(Self {
             num_vars,
             quantifiers,
             clauses,
-        }
+        })
     }
 
     /// Get the number of variables.
@@ -157,19 +169,16 @@ impl QuantifiedBooleanFormulas {
 
 impl Problem for QuantifiedBooleanFormulas {
     const NAME: &'static str = "QuantifiedBooleanFormulas";
+    type Solution = ();
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![]
-    }
+    crate::problem_parameters![("num_vars", num_vars), ("num_clauses", num_clauses),];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if !config.is_empty() {
-                return crate::types::Or(false);
-            }
-            self.is_true()
-        })
+    fn evaluate(
+        &self,
+        _solution: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok(crate::types::Or(self.is_true()))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -177,10 +186,35 @@ impl Problem for QuantifiedBooleanFormulas {
     }
 }
 
+impl crate::solvers::BruteForceProblem for QuantifiedBooleanFormulas {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![]
+    }
+}
+
 crate::declare_variants! {
     default QuantifiedBooleanFormulas => "2^num_vars",
 }
 
+crate::register_brute_force! {
+    QuantifiedBooleanFormulas decode |_, _| (),
+}
+
+#[derive(Deserialize)]
+struct QuantifiedBooleanFormulasDef {
+    num_vars: usize,
+    quantifiers: Vec<Quantifier>,
+    clauses: Vec<CNFClause>,
+}
+
+impl TryFrom<QuantifiedBooleanFormulasDef> for QuantifiedBooleanFormulas {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(value: QuantifiedBooleanFormulasDef) -> Result<Self, Self::Error> {
+        Self::try_new(value.num_vars, value.quantifiers, value.clauses)
+    }
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -193,7 +227,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 CNFClause::new(vec![1, -2]), // u_1 OR NOT u_2
             ],
         )),
-        optimal_config: vec![],
+        optimal_config: serde_json::json!(null),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/formula/sat.rs b/src/models/formula/sat.rs
index 8be2e2b90..fb0b6ff5f 100644
--- a/src/models/formula/sat.rs
+++ b/src/models/formula/sat.rs
@@ -15,6 +15,7 @@ inventory::submit! {
         display_name: "Satisfiability",
         aliases: &["SAT"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Formula,
         module_path: module_path!(),
         description: "Find satisfying assignment for CNF formula",
         fields: &[
@@ -36,7 +37,7 @@ inventory::submit! {
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct CNFClause {
     /// Literals in this clause (signed integers, 1-indexed).
-    pub literals: Vec<i32>,
+    pub literals: Vec<i64>,
 }
 
 impl CNFClause {
@@ -44,7 +45,7 @@ impl CNFClause {
     ///
     /// Literals are signed integers where positive means the variable
     /// and negative means its negation. Variables are 1-indexed.
-    pub fn new(literals: Vec<i32>) -> Self {
+    pub fn new(literals: Vec<i64>) -> Self {
         Self { literals }
     }
 
@@ -54,7 +55,10 @@ impl CNFClause {
     /// * `assignment` - Boolean assignment, 0-indexed
     pub fn is_satisfied(&self, assignment: &[bool]) -> bool {
         self.literals.iter().any(|&lit| {
-            let var = lit.unsigned_abs() as usize - 1; // Convert to 0-indexed
+            let var = usize::try_from(lit.unsigned_abs())
+                .expect("i64 literal magnitude must fit usize")
+                .checked_sub(1)
+                .expect("CNF literal 0 is invalid");
             let value = assignment.get(var).copied().unwrap_or(false);
             if lit > 0 {
                 value
@@ -68,7 +72,12 @@ impl CNFClause {
     pub fn variables(&self) -> Vec<usize> {
         self.literals
             .iter()
-            .map(|&lit| lit.unsigned_abs() as usize - 1)
+            .map(|&lit| {
+                usize::try_from(lit.unsigned_abs())
+                    .expect("i64 literal magnitude must fit usize")
+                    .checked_sub(1)
+                    .expect("CNF literal 0 is invalid")
+            })
             .collect()
     }
 
@@ -93,7 +102,7 @@ impl CNFClause {
 ///
 /// ```
 /// use problemreductions::models::formula::{Satisfiability, CNFClause};
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Formula: (x1 OR x2) AND (NOT x1 OR x3) AND (NOT x2 OR NOT x3)
 /// let problem = Satisfiability::new(
@@ -106,14 +115,15 @@ impl CNFClause {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Verify solutions satisfy all clauses
 /// for sol in solutions {
-///     assert!(problem.evaluate(&sol));
+///     assert!(problem.evaluate(&sol).unwrap());
 /// }
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(try_from = "SatisfiabilityDef")]
 pub struct Satisfiability {
     /// Number of variables.
     num_vars: usize,
@@ -124,7 +134,16 @@ pub struct Satisfiability {
 impl Satisfiability {
     /// Create a new SAT problem.
     pub fn new(num_vars: usize, clauses: Vec<CNFClause>) -> Self {
-        Self { num_vars, clauses }
+        Self::try_new(num_vars, clauses).unwrap_or_else(|message| panic!("{message}"))
+    }
+
+    /// Create a new SAT problem after validating its literal encoding.
+    pub fn try_new(
+        num_vars: usize,
+        clauses: Vec<CNFClause>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        validate_cnf_literals(num_vars, &clauses)?;
+        Ok(Self { num_vars, clauses })
     }
 
     /// Get the number of variables.
@@ -153,11 +172,20 @@ impl Satisfiability {
     }
 
     /// Count satisfied clauses for an assignment.
-    pub fn count_satisfied(&self, assignment: &[bool]) -> usize {
-        self.clauses
+    pub fn count_satisfied(
+        &self,
+        assignment: &[bool],
+    ) -> Result<i64, crate::traits::EvaluationError> {
+        let count = self
+            .clauses
             .iter()
             .filter(|c| c.is_satisfied(assignment))
-            .count()
+            .count();
+        i64::try_from(count).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting satisfied-clause count to i64".into(),
+            )
+        })
     }
 
     /// Check if an assignment satisfies all clauses.
@@ -168,24 +196,35 @@ impl Satisfiability {
     /// Check if a solution (config) is valid.
     ///
     /// For SAT, a valid solution is one that satisfies all clauses.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if config.len() != self.num_vars {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "assignment length does not match the formula variables".into(),
+            ));
+        }
+        Ok(self.is_satisfying(config))
     }
 }
 
 impl Problem for Satisfiability {
     const NAME: &'static str = "Satisfiability";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_vars]
-    }
+    crate::problem_parameters![
+        ("num_clauses", num_clauses),
+        ("num_literals", num_literals),
+        ("num_vars", num_vars),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let assignment = super::config_to_assignment(config);
-            self.is_satisfying(&assignment)
-        })
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -193,8 +232,65 @@ impl Problem for Satisfiability {
     }
 }
 
+impl crate::solvers::BruteForceProblem for Satisfiability {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_vars]
+    }
+}
+
 crate::declare_variants! {
-    default Satisfiability => "2^num_variables",
+    default Satisfiability => "2^num_vars",
+}
+
+crate::register_brute_force! {
+    Satisfiability decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
+#[derive(Deserialize)]
+struct SatisfiabilityDef {
+    num_vars: usize,
+    clauses: Vec<CNFClause>,
+}
+
+impl TryFrom<SatisfiabilityDef> for Satisfiability {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(value: SatisfiabilityDef) -> Result<Self, Self::Error> {
+        Self::try_new(value.num_vars, value.clauses)
+    }
+}
+
+pub(super) fn validate_cnf_literals(
+    num_vars: usize,
+    clauses: &[CNFClause],
+) -> Result<(), crate::registry::ConstructionError> {
+    if num_vars > i64::MAX as usize {
+        return Err(format!(
+            "num_vars {num_vars} exceeds the SAT literal limit {}",
+            i64::MAX
+        )
+        .into());
+    }
+
+    for (clause_index, clause) in clauses.iter().enumerate() {
+        for &literal in &clause.literals {
+            if literal == 0 || literal == i64::MIN {
+                return Err(format!(
+                    "clause {clause_index} contains invalid literal {literal}; allowed variable numbers are 1..={num_vars} with either sign"
+                ).into());
+            }
+            let magnitude = usize::try_from(literal.unsigned_abs()).map_err(|_| {
+                format!("clause {clause_index} literal {literal} magnitude does not fit usize")
+            })?;
+            if magnitude > num_vars {
+                return Err(format!(
+                    "clause {clause_index} contains invalid literal {literal}; allowed variable numbers are 1..={num_vars} with either sign"
+                ).into());
+            }
+        }
+    }
+
+    Ok(())
 }
 
 /// Check if an assignment satisfies a SAT formula.
@@ -206,7 +302,7 @@ crate::declare_variants! {
 #[cfg(test)]
 pub(crate) fn is_satisfying_assignment(
     _num_vars: usize,
-    clauses: &[Vec<i32>],
+    clauses: &[Vec<i64>],
     assignment: &[bool],
 ) -> bool {
     clauses.iter().all(|clause| {
@@ -234,7 +330,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 CNFClause::new(vec![-2, -3]),
             ],
         )),
-        optimal_config: vec![0, 1, 0],
+        optimal_config: serde_json::json!(vec![false, true, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/acyclic_partition.rs b/src/models/graph/acyclic_partition.rs
index 4bb5f4935..2ed924353 100644
--- a/src/models/graph/acyclic_partition.rs
+++ b/src/models/graph/acyclic_partition.rs
@@ -5,7 +5,7 @@
 //! DAG, each group's total vertex weight is bounded, and the total
 //! inter-partition arc cost is bounded.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use crate::types::WeightElement;
@@ -19,24 +19,12 @@ inventory::submit! {
         display_name: "Acyclic Partition",
         aliases: &[],
         dimensions: &[
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Partition a directed graph into bounded-weight groups with an acyclic quotient graph and bounded inter-partition cost",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "DirectedGraph", description: "The directed graph G=(V,A)" },
-            FieldInfo { name: "vertex_weights", type_name: "Vec<W>", description: "Vertex weights w(v) for each vertex v in V" },
-            FieldInfo { name: "arc_costs", type_name: "Vec<W>", description: "Arc costs c(a) for each arc a in A, matching graph.arcs() order" },
-            FieldInfo { name: "weight_bound", type_name: "W::Sum", description: "Maximum total vertex weight B for each partition" },
-            FieldInfo { name: "cost_bound", type_name: "W::Sum", description: "Maximum total inter-partition arc cost K" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "AcyclicPartition",
-        fields: &["num_vertices", "num_arcs"],
+        fields: AcyclicPartitionCreateSpec::FIELDS,
     }
 }
 
@@ -50,6 +38,72 @@ pub struct AcyclicPartition<W: WeightElement> {
     cost_bound: W::Sum,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct AcyclicPartitionCreateSpec {
+    #[create(codec = "arc-list")]
+    arcs: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    weights: Option<Vec<i64>>,
+    #[create(name = "arc_costs", codec = "comma-separated")]
+    arc_weights: Option<Vec<i64>>,
+    weight_bound: i64,
+    cost_bound: i64,
+}
+
+impl TryFrom<AcyclicPartitionCreateSpec> for AcyclicPartition<i64> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: AcyclicPartitionCreateSpec) -> Result<Self, Self::Error> {
+        if spec.arcs.is_empty() && spec.num_vertices.is_none() {
+            return Err("num_vertices is required for an empty arc list"
+                .to_string()
+                .into());
+        }
+        let inferred = spec
+            .arcs
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let num_vertices = spec.num_vertices.unwrap_or(inferred);
+        if num_vertices < inferred {
+            return Err(format!(
+                "num_vertices {num_vertices} is too small for arc endpoints; need at least {inferred}"
+            ).into());
+        }
+        let graph = DirectedGraph::new(num_vertices, spec.arcs);
+        let vertex_weights = spec.weights.unwrap_or_else(|| vec![1; num_vertices]);
+        if vertex_weights.len() != num_vertices {
+            return Err(format!(
+                "weights has length {}, expected {num_vertices}",
+                vertex_weights.len()
+            )
+            .into());
+        }
+        let arc_costs = spec
+            .arc_weights
+            .unwrap_or_else(|| vec![1; graph.num_arcs()]);
+        if arc_costs.len() != graph.num_arcs() {
+            return Err(format!(
+                "arc_weights has length {}, expected {}",
+                arc_costs.len(),
+                graph.num_arcs()
+            )
+            .into());
+        }
+        Ok(Self::new(
+            graph,
+            vertex_weights,
+            arc_costs,
+            spec.weight_bound,
+            spec.cost_bound,
+        ))
+    }
+}
+
 impl<W: WeightElement> AcyclicPartition<W> {
     /// Create a new Acyclic Partition instance.
     pub fn new(
@@ -139,7 +193,10 @@ impl<W: WeightElement> AcyclicPartition<W> {
     }
 
     /// Check whether a configuration is a valid solution.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<bool, crate::traits::EvaluationError> {
         is_valid_acyclic_partition(
             &self.graph,
             &self.vertex_weights,
@@ -156,27 +213,51 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "AcyclicPartition";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_arcs", num_arcs), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.graph.num_vertices(); self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        let n = self.graph.num_vertices();
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&part| part >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment contains an out-of-range part".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or({
+                is_valid_acyclic_partition(
+                    &self.graph,
+                    &self.vertex_weights,
+                    &self.arc_costs,
+                    &self.weight_bound,
+                    &self.cost_bound,
+                    config,
+                )?
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            is_valid_acyclic_partition(
-                &self.graph,
-                &self.vertex_weights,
-                &self.arc_costs,
-                &self.weight_bound,
-                &self.cost_bound,
-                config,
-            )
-        })
+impl<W> crate::solvers::BruteForceProblem for AcyclicPartition<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.graph.num_vertices(); self.graph.num_vertices()]
     }
 }
 
@@ -187,25 +268,29 @@ fn is_valid_acyclic_partition<W: WeightElement>(
     weight_bound: &W::Sum,
     cost_bound: &W::Sum,
     config: &[usize],
-) -> bool {
+) -> Result<bool, crate::traits::EvaluationError> {
     let num_vertices = graph.num_vertices();
     if config.len() != num_vertices {
-        return false;
+        return Ok(false);
     }
     if vertex_weights.len() != num_vertices || arc_costs.len() != graph.num_arcs() {
-        return false;
+        return Ok(false);
     }
     if config.iter().any(|&label| label >= num_vertices) {
-        return false;
+        return Ok(false);
     }
 
     let mut partition_weights = vec![W::Sum::zero(); num_vertices];
     let mut used_labels = vec![false; num_vertices];
     for (vertex, &label) in config.iter().enumerate() {
         used_labels[label] = true;
-        partition_weights[label] += vertex_weights[vertex].to_sum();
+        partition_weights[label] = W::checked_add_to_sum(
+            partition_weights[label].clone(),
+            vertex_weights[vertex].to_sum(),
+            "summing acyclic partition vertex weights",
+        )?;
         if partition_weights[label] > *weight_bound {
-            return false;
+            return Ok(false);
         }
     }
 
@@ -226,24 +311,32 @@ fn is_valid_acyclic_partition<W: WeightElement>(
         if source_label == target_label {
             continue;
         }
-        total_cost += cost.to_sum();
+        total_cost = W::checked_add_to_sum(
+            total_cost,
+            cost.to_sum(),
+            "summing acyclic partition arc costs",
+        )?;
         if total_cost > *cost_bound {
-            return false;
+            return Ok(false);
         }
         quotient_arcs.insert((dense_label[source_label], dense_label[target_label]));
     }
 
-    DirectedGraph::new(next_dense, quotient_arcs.into_iter().collect()).is_dag()
+    Ok(DirectedGraph::new(next_dense, quotient_arcs.into_iter().collect()).is_dag())
 }
 
 crate::declare_variants! {
-    default AcyclicPartition<i32> => "num_vertices^num_vertices",
+    default AcyclicPartition<i64> => "num_vertices^num_vertices" create AcyclicPartitionCreateSpec,
+}
+
+crate::register_brute_force! {
+    AcyclicPartition<i64>,
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "acyclic_partition_i32",
+        id: "acyclic_partition",
         instance: Box::new(AcyclicPartition::new(
             DirectedGraph::new(
                 6,
@@ -263,7 +356,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             5,
             5,
         )),
-        optimal_config: vec![0, 1, 0, 2, 2, 2],
+        optimal_config: serde_json::json!(vec![0, 1, 0, 2, 2, 2]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/balanced_complete_bipartite_subgraph.rs b/src/models/graph/balanced_complete_bipartite_subgraph.rs
index fe2ce502f..538bdbb82 100644
--- a/src/models/graph/balanced_complete_bipartite_subgraph.rs
+++ b/src/models/graph/balanced_complete_bipartite_subgraph.rs
@@ -1,4 +1,4 @@
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::BipartiteGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -10,12 +10,10 @@ inventory::submit! {
         display_name: "Balanced Complete Bipartite Subgraph",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Decide whether a bipartite graph contains a K_{k,k} subgraph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "BipartiteGraph", description: "The bipartite graph G = (A, B, E)" },
-            FieldInfo { name: "k", type_name: "usize", description: "Balanced biclique size" },
-        ],
+        fields: BalancedCompleteBipartiteSubgraphCreateSpec::FIELDS,
     }
 }
 
@@ -28,6 +26,44 @@ pub struct BalancedCompleteBipartiteSubgraph {
     edge_lookup: HashSet<(usize, usize)>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct BalancedCompleteBipartiteSubgraphCreateSpec {
+    /// Number of vertices in the left partition.
+    left: usize,
+    /// Number of vertices in the right partition.
+    right: usize,
+    /// Bipartite edges in left-local, right-local coordinates.
+    #[create(codec = "bipartite-edge-list")]
+    biedges: Vec<(usize, usize)>,
+    /// Balanced biclique size.
+    k: usize,
+}
+
+impl TryFrom<BalancedCompleteBipartiteSubgraphCreateSpec> for BalancedCompleteBipartiteSubgraph {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: BalancedCompleteBipartiteSubgraphCreateSpec) -> Result<Self, Self::Error> {
+        for (index, &(left, right)) in spec.biedges.iter().enumerate() {
+            if left >= spec.left {
+                return Err(format!(
+                    "biedges[{index}] left vertex {left} is out of bounds for left partition size {}",
+                    spec.left
+                ).into());
+            }
+            if right >= spec.right {
+                return Err(format!(
+                    "biedges[{index}] right vertex {right} is out of bounds for right partition size {}",
+                    spec.right
+                ).into());
+            }
+        }
+        Ok(Self::new(
+            BipartiteGraph::new(spec.left, spec.right, spec.biedges),
+            spec.k,
+        ))
+    }
+}
+
 impl BalancedCompleteBipartiteSubgraph {
     pub fn new(graph: BipartiteGraph, k: usize) -> Self {
         let edge_lookup = Self::build_edge_lookup(&graph);
@@ -66,7 +102,7 @@ impl BalancedCompleteBipartiteSubgraph {
         graph.left_edges().iter().copied().collect()
     }
 
-    fn selected_vertices(&self, config: &[usize]) -> Option<(Vec<usize>, Vec<usize>)> {
+    fn selected_vertices(&self, config: &[bool]) -> Option<(Vec<usize>, Vec<usize>)> {
         if config.len() != self.num_vertices() {
             return None;
         }
@@ -74,17 +110,13 @@ impl BalancedCompleteBipartiteSubgraph {
         let mut selected_left = Vec::new();
         let mut selected_right = Vec::new();
 
-        for (index, &value) in config.iter().enumerate() {
-            match value {
-                0 => {}
-                1 => {
-                    if index < self.left_size() {
-                        selected_left.push(index);
-                    } else {
-                        selected_right.push(index - self.left_size());
-                    }
+        for (index, &selected) in config.iter().enumerate() {
+            if selected {
+                if index < self.left_size() {
+                    selected_left.push(index);
+                } else {
+                    selected_right.push(index - self.left_size());
                 }
-                _ => return None,
             }
         }
 
@@ -95,35 +127,48 @@ impl BalancedCompleteBipartiteSubgraph {
         self.edge_lookup.contains(&(left, right))
     }
 
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if config.len() != self.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex-selection length does not match the graph".into(),
+            ));
+        }
+        let Some((selected_left, selected_right)) = self.selected_vertices(config) else {
+            return Ok(false);
+        };
+
+        if selected_left.len() != self.k || selected_right.len() != self.k {
+            return Ok(false);
+        }
+
+        Ok(selected_left.iter().all(|&left| {
+            selected_right
+                .iter()
+                .all(|&right| self.has_selected_edge(left, right))
+        }))
     }
 }
 
 impl Problem for BalancedCompleteBipartiteSubgraph {
     const NAME: &'static str = "BalancedCompleteBipartiteSubgraph";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_vertices()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let Some((selected_left, selected_right)) = self.selected_vertices(config) else {
-                return crate::types::Or(false);
-            };
-
-            if selected_left.len() != self.k || selected_right.len() != self.k {
-                return crate::types::Or(false);
-            }
+    crate::problem_parameters![
+        ("k", k),
+        ("left_size", left_size),
+        ("num_vertices", num_vertices),
+        ("right_size", right_size),
+    ];
 
-            selected_left.iter().all(|&left| {
-                selected_right
-                    .iter()
-                    .all(|&right| self.has_selected_edge(left, right))
-            })
-        })
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -131,6 +176,12 @@ impl Problem for BalancedCompleteBipartiteSubgraph {
     }
 }
 
+impl crate::solvers::BruteForceProblem for BalancedCompleteBipartiteSubgraph {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_vertices()]
+    }
+}
+
 #[derive(Deserialize)]
 struct BalancedCompleteBipartiteSubgraphRepr {
     graph: BipartiteGraph,
@@ -144,7 +195,11 @@ impl From<BalancedCompleteBipartiteSubgraphRepr> for BalancedCompleteBipartiteSu
 }
 
 crate::declare_variants! {
-    default BalancedCompleteBipartiteSubgraph => "1.3803^num_vertices",
+    default BalancedCompleteBipartiteSubgraph => "1.3803^num_vertices" create BalancedCompleteBipartiteSubgraphCreateSpec,
+}
+
+crate::register_brute_force! {
+    BalancedCompleteBipartiteSubgraph decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -172,7 +227,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ),
             3,
         )),
-        optimal_config: vec![1, 1, 1, 0, 1, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![true, true, true, false, true, true, true, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/biclique_cover.rs b/src/models/graph/biclique_cover.rs
index ef94bad62..6702a998f 100644
--- a/src/models/graph/biclique_cover.rs
+++ b/src/models/graph/biclique_cover.rs
@@ -13,7 +13,7 @@
 //! matrix of `G` (Monson, Pullman, Rees 1995), matching exact Boolean
 //! Matrix Factorization.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::BipartiteGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -26,14 +26,10 @@ inventory::submit! {
         display_name: "Biclique Cover",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Cover bipartite edges with k bicliques",
-        fields: &[
-            FieldInfo { name: "left_size", type_name: "usize", description: "Vertices in left partition" },
-            FieldInfo { name: "right_size", type_name: "usize", description: "Vertices in right partition" },
-            FieldInfo { name: "edges", type_name: "Vec<(usize, usize)>", description: "Bipartite edges" },
-            FieldInfo { name: "k", type_name: "usize", description: "Number of bicliques" },
-        ],
+        fields: BicliqueCoverCreateSpec::FIELDS,
     }
 }
 
@@ -47,7 +43,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::BicliqueCover;
 /// use problemreductions::topology::BipartiteGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Bipartite graph: L = {0, 1}, R = {0, 1}
 /// // Edges: (0,0), (0,1), (1,0) in bipartite-local coordinates
@@ -55,7 +51,7 @@ inventory::submit! {
 /// let problem = BicliqueCover::new(graph, 2);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Check coverage
 /// for sol in &solutions {
@@ -70,6 +66,43 @@ pub struct BicliqueCover {
     k: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct BicliqueCoverCreateSpec {
+    /// Number of vertices in the left partition.
+    left: usize,
+    /// Number of vertices in the right partition.
+    right: usize,
+    /// Bipartite edges in left-local, right-local coordinates.
+    #[create(codec = "bipartite-edge-list")]
+    biedges: Vec<(usize, usize)>,
+    /// Number of bicliques available to cover the edges.
+    k: usize,
+}
+
+impl TryFrom<BicliqueCoverCreateSpec> for BicliqueCover {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: BicliqueCoverCreateSpec) -> Result<Self, Self::Error> {
+        for (edge_index, &(left_vertex, right_vertex)) in spec.biedges.iter().enumerate() {
+            if left_vertex >= spec.left {
+                return Err(format!(
+                    "biedges[{edge_index}] left vertex {left_vertex} is out of bounds for left partition size {}",
+                    spec.left
+                ).into());
+            }
+            if right_vertex >= spec.right {
+                return Err(format!(
+                    "biedges[{edge_index}] right vertex {right_vertex} is out of bounds for right partition size {}",
+                    spec.right
+                ).into());
+            }
+        }
+
+        let graph = BipartiteGraph::new(spec.left, spec.right, spec.biedges);
+        Ok(Self::new(graph, spec.k))
+    }
+}
+
 impl BicliqueCover {
     /// Create a new Biclique Cover problem.
     ///
@@ -139,12 +172,11 @@ impl BicliqueCover {
 
     /// Convert a configuration to biclique memberships.
     ///
-    /// Config is a flat array where each vertex has k binary variables
-    /// indicating membership in each of the k bicliques.
+    /// Each row gives one vertex's membership in the `k` bicliques.
     /// Returns: (left_memberships, right_memberships) where each is a Vec of k HashSets.
     fn get_biclique_memberships(
         &self,
-        config: &[usize],
+        config: &[Vec<bool>],
     ) -> (Vec<HashSet<usize>>, Vec<HashSet<usize>>) {
         let n = self.num_vertices();
         let left_size = self.graph.left_size();
@@ -153,8 +185,12 @@ impl BicliqueCover {
 
         for v in 0..n {
             for b in 0..self.k {
-                let idx = v * self.k + b;
-                if config.get(idx).copied().unwrap_or(0) == 1 {
+                if config
+                    .get(b)
+                    .and_then(|memberships| memberships.get(v))
+                    .copied()
+                    .unwrap_or(false)
+                {
                     if v < left_size {
                         left_bicliques[b].insert(v);
                     } else {
@@ -170,7 +206,7 @@ impl BicliqueCover {
     /// Check if an edge is covered by the bicliques.
     ///
     /// Takes edge endpoints in unified vertex space.
-    fn is_edge_covered(&self, left: usize, right: usize, config: &[usize]) -> bool {
+    fn is_edge_covered(&self, left: usize, right: usize, config: &[Vec<bool>]) -> bool {
         let (left_bicliques, right_bicliques) = self.get_biclique_memberships(config);
 
         // Edge is covered if both endpoints are in the same biclique
@@ -183,7 +219,7 @@ impl BicliqueCover {
     }
 
     /// Check if a configuration is a valid biclique cover.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[Vec<bool>]) -> bool {
         self.is_valid_cover(config)
     }
 
@@ -194,7 +230,7 @@ impl BicliqueCover {
     /// and `r ∈ R_b` must be an edge of `G`. A configuration is a valid
     /// biclique cover iff every biclique is a sub-biclique of `G` and
     /// every edge of `G` is covered by at least one biclique.
-    pub fn is_valid_cover(&self, config: &[usize]) -> bool {
+    pub fn is_valid_cover(&self, config: &[Vec<bool>]) -> bool {
         use crate::topology::Graph;
         let (left_bicliques, right_bicliques) = self.get_biclique_memberships(config);
         let left_size = self.graph.left_size();
@@ -219,18 +255,39 @@ impl BicliqueCover {
     }
 
     /// Count covered edges.
-    pub fn count_covered_edges(&self, config: &[usize]) -> usize {
+    pub fn count_covered_edges(
+        &self,
+        config: &[Vec<bool>],
+    ) -> Result<i64, crate::traits::EvaluationError> {
         use crate::topology::Graph;
-        self.graph
+        let count = self
+            .graph
             .edges()
             .iter()
             .filter(|&&(l, r)| self.is_edge_covered(l, r, config))
-            .count()
+            .count();
+        i64::try_from(count).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting covered-edge count to i64".into(),
+            )
+        })
     }
 
     /// Count total biclique size (sum of vertices in all bicliques).
-    pub fn total_biclique_size(&self, config: &[usize]) -> usize {
-        config.iter().filter(|&&x| x == 1).count()
+    pub fn total_biclique_size(
+        &self,
+        config: &[Vec<bool>],
+    ) -> Result<i64, crate::traits::EvaluationError> {
+        let size = config
+            .iter()
+            .flatten()
+            .filter(|&&selected| selected)
+            .count();
+        i64::try_from(size).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting total biclique size to i64".into(),
+            )
+        })
     }
 }
 
@@ -270,18 +327,36 @@ pub(crate) fn is_biclique_cover(
 
 impl Problem for BicliqueCover {
     const NAME: &'static str = "BicliqueCover";
-    type Value = Min<i32>;
-
-    fn dims(&self) -> Vec<usize> {
-        // Each vertex has k binary variables (one per biclique)
-        vec![2; self.num_vertices() * self.k]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<i32> {
-        if !self.is_valid_cover(config) {
-            return Min(None);
+    type Solution = Vec<Vec<bool>>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("left_size", left_size),
+        ("num_edges", num_edges),
+        ("num_vertices", num_vertices),
+        ("rank", rank),
+        ("right_size", right_size),
+    ];
+
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        if solution.len() != self.k
+            || solution
+                .iter()
+                .any(|biclique| biclique.len() != self.num_vertices())
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "biclique membership dimensions do not match the instance".into(),
+            ));
         }
-        Min(Some(self.total_biclique_size(config) as i32))
+        Ok({
+            if !self.is_valid_cover(solution) {
+                return Ok(Min(None));
+            }
+            Min(Some(self.total_biclique_size(solution)?))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -289,8 +364,19 @@ impl Problem for BicliqueCover {
     }
 }
 
+impl crate::solvers::BruteForceProblem for BicliqueCover {
+    fn dimensions(&self) -> Vec<usize> {
+        // Each vertex has k binary variables (one per biclique)
+        vec![2; self.num_vertices() * self.k]
+    }
+}
+
 crate::declare_variants! {
-    default BicliqueCover => "2^(num_vertices * rank)",
+    default BicliqueCover => "2^(num_vertices * rank)" create BicliqueCoverCreateSpec,
+}
+
+crate::register_brute_force! {
+    BicliqueCover decode |problem: &BicliqueCover, indices: Vec<usize>| (0..problem.rank()).map(|biclique| (0..problem.num_vertices()).map(|vertex| indices[vertex * problem.rank() + biclique] != 0).collect()).collect(),
 }
 
 #[cfg(feature = "example-db")]
@@ -299,15 +385,17 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     // Biclique 0: L_0={ℓ_1}, R_0={r_1, r_2} — covers edges (0,0), (0,1).
     // Biclique 1: L_1={ℓ_2}, R_1={r_2, r_3} — covers edges (1,1), (1,2).
     // Both are sub-bicliques of G; every edge covered; total size = 6.
-    // Vertex-major layout with k=2: v=0 in b=0, v=1 in b=1, v=2 in b=0,
-    // v=3 in both, v=4 in b=1.
+    // One incidence row per biclique over the five vertices.
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "biclique_cover",
         instance: Box::new(BicliqueCover::new(
             BipartiteGraph::new(2, 3, vec![(0, 0), (0, 1), (1, 1), (1, 2)]),
             2,
         )),
-        optimal_config: vec![1, 0, 0, 1, 1, 0, 1, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![
+            vec![true, false, true, true, false],
+            vec![false, true, false, true, true]
+        ]),
         optimal_value: serde_json::json!(6),
     }]
 }
diff --git a/src/models/graph/biconnectivity_augmentation.rs b/src/models/graph/biconnectivity_augmentation.rs
index d923c2ce9..1e026104c 100644
--- a/src/models/graph/biconnectivity_augmentation.rs
+++ b/src/models/graph/biconnectivity_augmentation.rs
@@ -4,7 +4,7 @@
 //! adding some subset of the potential edges can make the graph biconnected
 //! without exceeding the budget.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::WeightElement;
@@ -19,15 +19,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Add weighted potential edges to make a graph biconnected within budget",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "potential_weights", type_name: "Vec<(usize, usize, W)>", description: "Potential edges with augmentation weights" },
-            FieldInfo { name: "budget", type_name: "W::Sum", description: "Maximum total augmentation weight B" },
-        ],
+        fields: BiconnectivityAugmentationCreateSpec::FIELDS,
     }
 }
 
@@ -54,6 +51,65 @@ where
     budget: W::Sum,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct BiconnectivityAugmentationCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    potential_weights: Vec<(usize, usize, i64)>,
+    budget: i64,
+}
+
+impl TryFrom<BiconnectivityAugmentationCreateSpec>
+    for BiconnectivityAugmentation<SimpleGraph, i64>
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: BiconnectivityAugmentationCreateSpec) -> Result<Self, Self::Error> {
+        if spec.graph.is_empty() && spec.num_vertices.is_none() {
+            return Err("num_vertices is required for an empty graph".into());
+        }
+        for &(u, v) in &spec.graph {
+            if u == v {
+                return Err(format!("self-loop {u}-{v} is not allowed").into());
+            }
+        }
+        let inferred = spec
+            .graph
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|v| v.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let count = spec.num_vertices.unwrap_or(inferred);
+        if count < inferred {
+            return Err("num_vertices is too small for graph endpoints".into());
+        }
+        let graph = SimpleGraph::new(count, spec.graph);
+        let mut seen = BTreeSet::new();
+        for &(u, v, _) in &spec.potential_weights {
+            if u >= count || v >= count {
+                return Err("potential edge endpoint is out of bounds".into());
+            }
+            if u == v {
+                return Err("potential edge is a self-loop".into());
+            }
+            let edge = normalize_edge(u, v);
+            if graph.has_edge(edge.0, edge.1) {
+                return Err("potential edge already exists in graph".into());
+            }
+            if !seen.insert(edge) {
+                return Err("duplicate potential edge".into());
+            }
+        }
+        Ok(Self {
+            graph,
+            potential_weights: spec.potential_weights,
+            budget: spec.budget,
+        })
+    }
+}
+
 impl<G: Graph, W: WeightElement> BiconnectivityAugmentation<G, W> {
     /// Create a new biconnectivity augmentation instance.
     ///
@@ -130,9 +186,12 @@ impl<G: Graph, W: WeightElement> BiconnectivityAugmentation<G, W> {
         !W::IS_UNIT
     }
 
-    fn augmented_graph(&self, config: &[usize]) -> Option<SimpleGraph> {
-        if config.len() != self.num_potential_edges() || config.iter().any(|&value| value >= 2) {
-            return None;
+    fn augmented_graph(
+        &self,
+        config: &[bool],
+    ) -> Result<Option<SimpleGraph>, crate::traits::EvaluationError> {
+        if config.len() != self.num_potential_edges() {
+            return Ok(None);
         }
 
         let mut total = W::Sum::zero();
@@ -143,19 +202,23 @@ impl<G: Graph, W: WeightElement> BiconnectivityAugmentation<G, W> {
         }
 
         for (selected, &(u, v, ref weight)) in config.iter().zip(&self.potential_weights) {
-            if *selected == 1 {
-                total += weight.to_sum();
-                if total > self.budget.clone() {
-                    return None;
-                }
+            if *selected {
+                total = W::checked_add_to_sum(
+                    total,
+                    weight.to_sum(),
+                    "summing biconnectivity augmentation weights",
+                )?;
                 edges.insert(normalize_edge(u, v));
             }
         }
+        if total > self.budget.clone() {
+            return Ok(None);
+        }
 
-        Some(SimpleGraph::new(
+        Ok(Some(SimpleGraph::new(
             self.num_vertices(),
             edges.into_iter().collect(),
-        ))
+        )))
     }
 }
 
@@ -165,21 +228,44 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "BiconnectivityAugmentation";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_potential_edges", num_potential_edges),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_potential_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_potential_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the candidate edges".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or({
+                self.augmented_graph(config)?
+                    .is_some_and(|graph| is_biconnected(&graph))
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            self.augmented_graph(config)
-                .is_some_and(|graph| is_biconnected(&graph))
-        })
+impl<G, W> crate::solvers::BruteForceProblem for BiconnectivityAugmentation<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_potential_edges()]
     }
 }
 
@@ -255,7 +341,11 @@ fn is_biconnected<G: Graph>(graph: &G) -> bool {
 }
 
 crate::declare_variants! {
-    default BiconnectivityAugmentation<SimpleGraph, i32> => "2^num_potential_edges",
+    default BiconnectivityAugmentation<SimpleGraph, i64> => "2^num_potential_edges" create BiconnectivityAugmentationCreateSpec,
+}
+
+crate::register_brute_force! {
+    BiconnectivityAugmentation<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -277,13 +367,15 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
             4,
         )),
-        optimal_config: vec![1, 0, 0, 1, 0, 0, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![
+            true, false, false, true, false, false, true, false, true
+        ]),
         optimal_value: serde_json::json!(true),
     }]
 }
 
 #[cfg(test)]
-pub(crate) fn example_instance() -> BiconnectivityAugmentation<SimpleGraph, i32> {
+pub(crate) fn example_instance() -> BiconnectivityAugmentation<SimpleGraph, i64> {
     BiconnectivityAugmentation::new(
         SimpleGraph::path(6),
         vec![
diff --git a/src/models/graph/bottleneck_traveling_salesman.rs b/src/models/graph/bottleneck_traveling_salesman.rs
index 3badad9cb..fd5aaac2c 100644
--- a/src/models/graph/bottleneck_traveling_salesman.rs
+++ b/src/models/graph/bottleneck_traveling_salesman.rs
@@ -3,7 +3,7 @@
 //! The Bottleneck Traveling Salesman problem asks for a Hamiltonian cycle
 //! minimizing the maximum selected edge weight.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::Min;
@@ -15,12 +15,10 @@ inventory::submit! {
         display_name: "Bottleneck Traveling Salesman",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a Hamiltonian cycle minimizing the maximum selected edge weight",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "SimpleGraph", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<i32>", description: "Edge weights w: E -> Z" },
-        ],
+        fields: BottleneckTravelingSalesmanCreateSpec::FIELDS,
     }
 }
 
@@ -28,12 +26,72 @@ inventory::submit! {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BottleneckTravelingSalesman {
     graph: SimpleGraph,
-    edge_weights: Vec<i32>,
+    edge_weights: Vec<i64>,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct BottleneckTravelingSalesmanCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    edge_weights: Option<Vec<i64>>,
+}
+
+impl TryFrom<BottleneckTravelingSalesmanCreateSpec> for BottleneckTravelingSalesman {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: BottleneckTravelingSalesmanCreateSpec) -> Result<Self, Self::Error> {
+        let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+        let edge_weights = spec
+            .edge_weights
+            .unwrap_or_else(|| vec![1; graph.num_edges()]);
+        if edge_weights.len() != graph.num_edges() {
+            return Err(format!(
+                "edge_weights has length {}, expected {}",
+                edge_weights.len(),
+                graph.num_edges()
+            )
+            .into());
+        }
+        Ok(Self::new(graph, edge_weights))
+    }
+}
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(format!(
+            "num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}"
+        )
+        .into());
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
 }
 
 impl BottleneckTravelingSalesman {
     /// Create a BottleneckTravelingSalesman problem from a graph with edge weights.
-    pub fn new(graph: SimpleGraph, edge_weights: Vec<i32>) -> Self {
+    pub fn new(graph: SimpleGraph, edge_weights: Vec<i64>) -> Self {
         assert_eq!(
             edge_weights.len(),
             graph.num_edges(),
@@ -51,18 +109,18 @@ impl BottleneckTravelingSalesman {
     }
 
     /// Get the weights for the problem.
-    pub fn weights(&self) -> Vec<i32> {
+    pub fn weights(&self) -> Vec<i64> {
         self.edge_weights.clone()
     }
 
     /// Set new weights for the problem.
-    pub fn set_weights(&mut self, weights: Vec<i32>) {
+    pub fn set_weights(&mut self, weights: Vec<i64>) {
         assert_eq!(weights.len(), self.graph.num_edges());
         self.edge_weights = weights;
     }
 
     /// Get all edges with their weights.
-    pub fn edges(&self) -> Vec<(usize, usize, i32)> {
+    pub fn edges(&self) -> Vec<(usize, usize, i64)> {
         self.graph
             .edges()
             .into_iter()
@@ -87,45 +145,55 @@ impl BottleneckTravelingSalesman {
     }
 
     /// Check if a configuration is a valid Hamiltonian cycle.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         if config.len() != self.graph.num_edges() {
             return false;
         }
-        let selected: Vec<bool> = config.iter().map(|&s| s == 1).collect();
-        super::traveling_salesman::is_hamiltonian_cycle(&self.graph, &selected)
+        super::traveling_salesman::is_hamiltonian_cycle(&self.graph, config)
     }
 }
 
 impl Problem for BottleneckTravelingSalesman {
     const NAME: &'static str = "BottleneckTravelingSalesman";
-    type Value = Min<i32>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.graph.num_edges() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "edge-selection length does not match the graph".into(),
+                ));
+            }
+
+            if !super::traveling_salesman::is_hamiltonian_cycle(&self.graph, config) {
+                return Ok(Min(None));
+            }
+
+            let bottleneck = config
+                .iter()
+                .zip(self.edge_weights.iter())
+                .filter_map(|(&selected, &weight)| selected.then_some(weight))
+                .max()
+                .expect("valid Hamiltonian cycle selects at least one edge");
+
+            Min(Some(bottleneck))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<i32> {
-        if config.len() != self.graph.num_edges() {
-            return Min(None);
-        }
-
-        let selected: Vec<bool> = config.iter().map(|&s| s == 1).collect();
-        if !super::traveling_salesman::is_hamiltonian_cycle(&self.graph, &selected) {
-            return Min(None);
-        }
-
-        let bottleneck = config
-            .iter()
-            .zip(self.edge_weights.iter())
-            .filter_map(|(&selected, &weight)| (selected == 1).then_some(weight))
-            .max()
-            .expect("valid Hamiltonian cycle selects at least one edge");
-
-        Min(Some(bottleneck))
+impl crate::solvers::BruteForceProblem for BottleneckTravelingSalesman {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
 }
 
@@ -151,13 +219,29 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ),
             vec![5, 4, 4, 5, 4, 1, 2, 1, 5, 4],
         )),
-        optimal_config: vec![0, 1, 1, 0, 1, 0, 1, 0, 0, 1],
+        optimal_config: serde_json::json!([
+            false, true, true, false, true, false, true, false, false, true
+        ]),
         optimal_value: serde_json::json!(4),
     }]
 }
 
+crate::impl_random_generate!(
+    BottleneckTravelingSalesman,
+    crate::random::SimpleGraphRandomSpec,
+    |spec| {
+        let graph = spec.graph()?;
+        let weights = vec![1; graph.num_edges()];
+        Ok(BottleneckTravelingSalesman::new(graph, weights))
+    }
+);
+
 crate::declare_variants! {
-    default BottleneckTravelingSalesman => "num_vertices^2 * 2^num_vertices",
+    default BottleneckTravelingSalesman => "num_vertices^2 * 2^num_vertices" create BottleneckTravelingSalesmanCreateSpec random,
+}
+
+crate::register_brute_force! {
+    BottleneckTravelingSalesman decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/bounded_component_spanning_forest.rs b/src/models/graph/bounded_component_spanning_forest.rs
index 32f229a1a..155532cbc 100644
--- a/src/models/graph/bounded_component_spanning_forest.rs
+++ b/src/models/graph/bounded_component_spanning_forest.rs
@@ -4,7 +4,7 @@
 //! weighted graph can be partitioned into at most `K` connected components, each
 //! of total weight at most `B`.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::WeightElement;
@@ -19,16 +19,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Partition vertices into at most K connected components, each of total weight at most B",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w(v) for each vertex v in V" },
-            FieldInfo { name: "max_components", type_name: "usize", description: "Upper bound K on the number of connected components" },
-            FieldInfo { name: "max_weight", type_name: "W::Sum", description: "Upper bound B on the total weight of each component" },
-        ],
+        fields: BoundedComponentSpanningForestCreateSpec::FIELDS,
     }
 }
 
@@ -50,6 +46,45 @@ pub struct BoundedComponentSpanningForest<G, W: WeightElement> {
     max_weight: W::Sum,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct BoundedComponentSpanningForestCreateSpec {
+    /// The underlying graph G=(V,E).
+    graph: SimpleGraph,
+    /// Vertex weights w(v) for each vertex v in V.
+    weights: Vec<i64>,
+    /// Upper bound K on the number of connected components.
+    k: usize,
+    /// Upper bound B on the total weight of each component.
+    max_weight: i64,
+}
+
+impl TryFrom<BoundedComponentSpanningForestCreateSpec>
+    for BoundedComponentSpanningForest<SimpleGraph, i64>
+{
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: BoundedComponentSpanningForestCreateSpec) -> Result<Self, Self::Error> {
+        if spec.weights.len() != spec.graph.num_vertices() {
+            return Err(format!(
+                "weights has {} entries, expected {}",
+                spec.weights.len(),
+                spec.graph.num_vertices()
+            )
+            .into());
+        }
+        if spec.weights.iter().any(|&weight| weight < 0) {
+            return Err("weights must be nonnegative".to_string().into());
+        }
+        if spec.k == 0 {
+            return Err("k must be at least 1".to_string().into());
+        }
+        if spec.max_weight <= 0 {
+            return Err("max_weight must be positive".to_string().into());
+        }
+        Ok(Self::new(spec.graph, spec.weights, spec.k, spec.max_weight))
+    }
+}
+
 impl<G: Graph, W: WeightElement> BoundedComponentSpanningForest<G, W> {
     /// Create a new bounded-component spanning forest instance.
     pub fn new(graph: G, weights: Vec<W>, max_components: usize, max_weight: W::Sum) -> Self {
@@ -110,10 +145,13 @@ impl<G: Graph, W: WeightElement> BoundedComponentSpanningForest<G, W> {
     }
 
     /// Check if a configuration is a valid bounded-component partition.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<bool, crate::traits::EvaluationError> {
         let num_vertices = self.graph.num_vertices();
         if config.len() != num_vertices {
-            return false;
+            return Ok(false);
         }
 
         let mut component_weights = vec![W::Sum::zero(); self.max_components];
@@ -123,7 +161,7 @@ impl<G: Graph, W: WeightElement> BoundedComponentSpanningForest<G, W> {
 
         for (vertex, &component) in config.iter().enumerate() {
             if component >= self.max_components {
-                return false;
+                return Ok(false);
             }
 
             if component_sizes[component] == 0 {
@@ -132,9 +170,13 @@ impl<G: Graph, W: WeightElement> BoundedComponentSpanningForest<G, W> {
             }
 
             component_sizes[component] += 1;
-            component_weights[component] += self.weights[vertex].to_sum();
+            component_weights[component] = W::checked_add_to_sum(
+                component_weights[component].clone(),
+                self.weights[vertex].to_sum(),
+                "summing bounded forest component weights",
+            )?;
             if component_weights[component] > self.max_weight {
-                return false;
+                return Ok(false);
             }
         }
 
@@ -142,7 +184,7 @@ impl<G: Graph, W: WeightElement> BoundedComponentSpanningForest<G, W> {
             .iter()
             .all(|&component| component_sizes[component] <= 1)
         {
-            return true;
+            return Ok(true);
         }
 
         let mut visited_marks = vec![0usize; num_vertices];
@@ -171,11 +213,11 @@ impl<G: Graph, W: WeightElement> BoundedComponentSpanningForest<G, W> {
             }
 
             if visited_count != component_size {
-                return false;
+                return Ok(false);
             }
         }
 
-        true
+        Ok(true)
     }
 }
 
@@ -185,25 +227,46 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "BoundedComponentSpanningForest";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("max_components", max_components),
+        ("num_edges", num_edges),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.max_components; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "component assignment length does not match the graph vertices".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_valid_solution(config))
+impl<G, W> crate::solvers::BruteForceProblem for BoundedComponentSpanningForest<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.max_components; self.graph.num_vertices()]
     }
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "bounded_component_spanning_forest_simplegraph_i32",
+        id: "bounded_component_spanning_forest_simplegraph",
         instance: Box::new(BoundedComponentSpanningForest::new(
             SimpleGraph::new(
                 8,
@@ -224,13 +287,17 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             3,
             6,
         )),
-        optimal_config: vec![0, 0, 1, 1, 1, 2, 2, 0],
+        optimal_config: serde_json::json!(vec![0, 0, 1, 1, 1, 2, 2, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
 
 crate::declare_variants! {
-    default BoundedComponentSpanningForest<SimpleGraph, i32> => "3^num_vertices",
+    default BoundedComponentSpanningForest<SimpleGraph, i64> => "3^num_vertices" create BoundedComponentSpanningForestCreateSpec,
+}
+
+crate::register_brute_force! {
+    BoundedComponentSpanningForest<SimpleGraph, i64>,
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/bounded_diameter_spanning_tree.rs b/src/models/graph/bounded_diameter_spanning_tree.rs
index 217e203b6..e156f4525 100644
--- a/src/models/graph/bounded_diameter_spanning_tree.rs
+++ b/src/models/graph/bounded_diameter_spanning_tree.rs
@@ -4,7 +4,7 @@
 //! bound D, determine whether G has a spanning tree with total weight at most B
 //! and diameter (longest shortest path in edges) at most D.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::WeightElement;
@@ -20,16 +20,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Does G have a spanning tree with total weight <= B and diameter <= D?",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge weights w: E -> ZZ_(> 0)" },
-            FieldInfo { name: "weight_bound", type_name: "W::Sum", description: "Upper bound B on total tree weight" },
-            FieldInfo { name: "diameter_bound", type_name: "usize", description: "Upper bound D on tree diameter (in edges)" },
-        ],
+        fields: BoundedDiameterSpanningTreeCreateSpec::FIELDS,
     }
 }
 
@@ -47,20 +43,20 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - Graph type (e.g., SimpleGraph)
-/// * `W` - Edge weight type (e.g., i32)
+/// * `W` - Edge weight type (e.g., i64)
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::graph::BoundedDiameterSpanningTree;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let graph = SimpleGraph::new(5, vec![(0,1),(0,2),(0,3),(1,2),(1,4),(2,3),(3,4)]);
 /// let problem = BoundedDiameterSpanningTree::new(graph, vec![1,2,1,1,2,1,1], 5, 3);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -80,6 +76,81 @@ pub struct BoundedDiameterSpanningTree<G, W: WeightElement> {
     edge_list: Vec<(usize, usize)>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct BoundedDiameterSpanningTreeCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    edge_weights: Option<Vec<i64>>,
+    weight_bound: i64,
+    diameter_bound: usize,
+}
+
+impl TryFrom<BoundedDiameterSpanningTreeCreateSpec>
+    for BoundedDiameterSpanningTree<SimpleGraph, i64>
+{
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: BoundedDiameterSpanningTreeCreateSpec) -> Result<Self, Self::Error> {
+        let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+        let edge_weights = spec
+            .edge_weights
+            .unwrap_or_else(|| vec![1; graph.num_edges()]);
+        if edge_weights.len() != graph.num_edges() {
+            return Err(format!(
+                "edge_weights has length {}, expected {}",
+                edge_weights.len(),
+                graph.num_edges()
+            )
+            .into());
+        }
+        if edge_weights.iter().any(|&weight| weight <= 0) {
+            return Err("edge_weights must be positive".to_string().into());
+        }
+        if spec.weight_bound <= 0 {
+            return Err("weight_bound must be positive".to_string().into());
+        }
+        if spec.diameter_bound == 0 {
+            return Err("diameter_bound must be at least 1".to_string().into());
+        }
+        Ok(Self::new(
+            graph,
+            edge_weights,
+            spec.weight_bound,
+            spec.diameter_bound,
+        ))
+    }
+}
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(format!("num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}").into());
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
+}
+
 impl<G: Graph, W: WeightElement> BoundedDiameterSpanningTree<G, W> {
     /// Create a new Bounded Diameter Spanning Tree instance.
     ///
@@ -204,83 +275,107 @@ where
     W: WeightElement + VariantParam,
 {
     const NAME: &'static str = "BoundedDiameterSpanningTree";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.edge_list.len()]
-    }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                let n = self.graph.num_vertices();
+                if config.len() != self.edge_list.len() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "edge-selection length does not match the graph".into(),
+                    ));
+                }
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let n = self.graph.num_vertices();
-            if config.len() != self.edge_list.len() {
-                return crate::types::Or(false);
-            }
+                // Collect selected edges
+                let selected_indices: Vec<usize> = config
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, &v)| v)
+                    .map(|(i, _)| i)
+                    .collect();
 
-            // Collect selected edges
-            let selected_indices: Vec<usize> = config
-                .iter()
-                .enumerate()
-                .filter(|(_, &v)| v == 1)
-                .map(|(i, _)| i)
-                .collect();
-
-            // A spanning tree on n vertices must have exactly n-1 edges
-            if n == 0 {
-                return crate::types::Or(selected_indices.is_empty());
-            }
-            if selected_indices.len() != n - 1 {
-                return crate::types::Or(false);
-            }
+                // A spanning tree on n vertices must have exactly n-1 edges
+                if n == 0 {
+                    return Ok(crate::types::Or(selected_indices.is_empty()));
+                }
+                if selected_indices.len() != n - 1 {
+                    return Ok(crate::types::Or(false));
+                }
 
-            // Build adjacency list and compute total weight
-            let mut adj: Vec<Vec<usize>> = vec![Vec::new(); n];
-            let mut total_weight = W::Sum::zero();
-            for &idx in &selected_indices {
-                let (u, v) = self.edge_list[idx];
-                adj[u].push(v);
-                adj[v].push(u);
-                total_weight += self.edge_weights[idx].to_sum();
-            }
+                // Build adjacency list and compute total weight
+                let mut adj: Vec<Vec<usize>> = vec![Vec::new(); n];
+                let mut total_weight = W::Sum::zero();
+                for &idx in &selected_indices {
+                    let (u, v) = self.edge_list[idx];
+                    adj[u].push(v);
+                    adj[v].push(u);
+                    total_weight = W::checked_add_to_sum(
+                        total_weight,
+                        self.edge_weights[idx].to_sum(),
+                        "summing bounded-diameter spanning tree weights",
+                    )?;
+                }
 
-            // Check weight bound
-            if total_weight > self.weight_bound.clone() {
-                return crate::types::Or(false);
-            }
+                // Check weight bound
+                if total_weight > self.weight_bound.clone() {
+                    return Ok(crate::types::Or(false));
+                }
 
-            // Check connectivity using BFS
-            let mut visited = vec![false; n];
-            let mut queue = VecDeque::new();
-            visited[0] = true;
-            queue.push_back(0);
-            let mut count = 1;
-            while let Some(v) = queue.pop_front() {
-                for &u in &adj[v] {
-                    if !visited[u] {
-                        visited[u] = true;
-                        count += 1;
-                        queue.push_back(u);
+                // Check connectivity using BFS
+                let mut visited = vec![false; n];
+                let mut queue = VecDeque::new();
+                visited[0] = true;
+                queue.push_back(0);
+                let mut count = 1;
+                while let Some(v) = queue.pop_front() {
+                    for &u in &adj[v] {
+                        if !visited[u] {
+                            visited[u] = true;
+                            count += 1;
+                            queue.push_back(u);
+                        }
                     }
                 }
-            }
 
-            if count != n {
-                return crate::types::Or(false);
-            }
+                if count != n {
+                    return Ok(crate::types::Or(false));
+                }
 
-            // Check diameter bound (BFS from each vertex)
-            let diameter = Self::tree_diameter(&adj, n);
-            diameter <= self.diameter_bound
+                // Check diameter bound (BFS from each vertex)
+                let diameter = Self::tree_diameter(&adj, n);
+                diameter <= self.diameter_bound
+            })
         })
     }
 }
 
+impl<G, W> crate::solvers::BruteForceProblem for BoundedDiameterSpanningTree<G, W>
+where
+    G: Graph + VariantParam,
+    W: WeightElement + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.edge_list.len()]
+    }
+}
+
 crate::declare_variants! {
-    default BoundedDiameterSpanningTree<SimpleGraph, i32> => "num_vertices ^ num_vertices",
+    default BoundedDiameterSpanningTree<SimpleGraph, i64> => "num_vertices ^ num_vertices" create BoundedDiameterSpanningTreeCreateSpec,
+}
+
+crate::register_brute_force! {
+    BoundedDiameterSpanningTree<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -290,7 +385,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     // Tree: edges (0,1),(0,3),(2,3),(3,4) → edge indices 0,2,5,6
     // Config: [1,0,1,0,0,1,1] → weight = 1+1+1+1 = 4 ≤ 5, diameter = 3 ≤ 3
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "bounded_diameter_spanning_tree_simplegraph_i32",
+        id: "bounded_diameter_spanning_tree_simplegraph",
         instance: Box::new(BoundedDiameterSpanningTree::new(
             SimpleGraph::new(
                 5,
@@ -300,7 +395,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             5,
             3,
         )),
-        optimal_config: vec![1, 0, 1, 0, 0, 1, 1],
+        optimal_config: serde_json::json!(vec![true, false, true, false, false, true, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/degree_constrained_spanning_tree.rs b/src/models/graph/degree_constrained_spanning_tree.rs
index 47338a8f1..005289d25 100644
--- a/src/models/graph/degree_constrained_spanning_tree.rs
+++ b/src/models/graph/degree_constrained_spanning_tree.rs
@@ -18,6 +18,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Does G have a spanning tree with maximum vertex degree at most K?",
         fields: &[
@@ -45,13 +46,13 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::DegreeConstrainedSpanningTree;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let graph = SimpleGraph::new(4, vec![(0,1),(1,2),(2,3),(0,3)]);
 /// let problem = DegreeConstrainedSpanningTree::new(graph, 2);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -111,79 +112,98 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "DegreeConstrainedSpanningTree";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.edge_list.len()]
-    }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                let n = self.graph.num_vertices();
+                if config.len() != self.edge_list.len() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "edge-selection length does not match the graph".into(),
+                    ));
+                }
+
+                // Collect selected edges
+                let selected: Vec<(usize, usize)> = config
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, &v)| v)
+                    .map(|(i, _)| self.edge_list[i])
+                    .collect();
+
+                // A spanning tree on n vertices must have exactly n-1 edges
+                if n == 0 {
+                    return Ok(crate::types::Or(selected.is_empty()));
+                }
+                if selected.len() != n - 1 {
+                    return Ok(crate::types::Or(false));
+                }
+
+                // Check connectivity using BFS on selected edges
+                let mut adj: Vec<Vec<usize>> = vec![Vec::new(); n];
+                let mut degree = vec![0usize; n];
+                for &(u, v) in &selected {
+                    adj[u].push(v);
+                    adj[v].push(u);
+                    degree[u] += 1;
+                    degree[v] += 1;
+                }
+
+                // Check max degree constraint
+                if degree.iter().any(|&d| d > self.max_degree) {
+                    return Ok(crate::types::Or(false));
+                }
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let n = self.graph.num_vertices();
-            if config.len() != self.edge_list.len() {
-                return crate::types::Or(false);
-            }
-
-            // Collect selected edges
-            let selected: Vec<(usize, usize)> = config
-                .iter()
-                .enumerate()
-                .filter(|(_, &v)| v == 1)
-                .map(|(i, _)| self.edge_list[i])
-                .collect();
-
-            // A spanning tree on n vertices must have exactly n-1 edges
-            if n == 0 {
-                return crate::types::Or(selected.is_empty());
-            }
-            if selected.len() != n - 1 {
-                return crate::types::Or(false);
-            }
-
-            // Check connectivity using BFS on selected edges
-            let mut adj: Vec<Vec<usize>> = vec![Vec::new(); n];
-            let mut degree = vec![0usize; n];
-            for &(u, v) in &selected {
-                adj[u].push(v);
-                adj[v].push(u);
-                degree[u] += 1;
-                degree[v] += 1;
-            }
-
-            // Check max degree constraint
-            if degree.iter().any(|&d| d > self.max_degree) {
-                return crate::types::Or(false);
-            }
-
-            // BFS to check connectivity
-            let mut visited = vec![false; n];
-            let mut queue = VecDeque::new();
-            visited[0] = true;
-            queue.push_back(0);
-            let mut count = 1;
-            while let Some(v) = queue.pop_front() {
-                for &u in &adj[v] {
-                    if !visited[u] {
-                        visited[u] = true;
-                        count += 1;
-                        queue.push_back(u);
+                // BFS to check connectivity
+                let mut visited = vec![false; n];
+                let mut queue = VecDeque::new();
+                visited[0] = true;
+                queue.push_back(0);
+                let mut count = 1;
+                while let Some(v) = queue.pop_front() {
+                    for &u in &adj[v] {
+                        if !visited[u] {
+                            visited[u] = true;
+                            count += 1;
+                            queue.push_back(u);
+                        }
                     }
                 }
-            }
 
-            count == n
+                count == n
+            })
         })
     }
 }
 
+impl<G> crate::solvers::BruteForceProblem for DegreeConstrainedSpanningTree<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.edge_list.len()]
+    }
+}
+
 crate::declare_variants! {
     default DegreeConstrainedSpanningTree<SimpleGraph> => "2^num_vertices",
 }
 
+crate::register_brute_force! {
+    DegreeConstrainedSpanningTree<SimpleGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 5 vertices, 7 edges: (0,1),(0,2),(0,3),(1,2),(1,4),(2,3),(3,4), K=2
@@ -199,7 +219,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ),
             2,
         )),
-        optimal_config: vec![0, 1, 1, 1, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![false, true, true, true, true, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/directed_hamiltonian_path.rs b/src/models/graph/directed_hamiltonian_path.rs
index b395853cc..261e04250 100644
--- a/src/models/graph/directed_hamiltonian_path.rs
+++ b/src/models/graph/directed_hamiltonian_path.rs
@@ -3,7 +3,7 @@
 //! The Directed Hamiltonian Path problem asks whether a directed graph contains
 //! a simple directed path that visits every vertex exactly once.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -13,9 +13,8 @@ inventory::submit! {
         name: "DirectedHamiltonianPath",
         display_name: "Directed Hamiltonian Path",
         aliases: &["DHP"],
-        dimensions: &[
-            VariantDimension::new("graph", "DirectedGraph", &["DirectedGraph"]),
-        ],
+        dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Does the directed graph contain a Hamiltonian path?",
         fields: &[
@@ -43,14 +42,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::DirectedHamiltonianPath;
 /// use problemreductions::topology::DirectedGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Simple directed path: 0->1->2->3
 /// let graph = DirectedGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
 /// let problem = DirectedHamiltonianPath::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -79,28 +78,48 @@ impl DirectedHamiltonianPath {
         self.graph.num_arcs()
     }
 
-    /// Check if a configuration is a valid directed Hamiltonian path.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        let perm = decode_lehmer(config);
-        is_valid_directed_hamiltonian_path(&self.graph, &perm)
+    /// Check if a permutation is a valid directed Hamiltonian path.
+    pub fn is_valid_solution(&self, solution: &[usize]) -> bool {
+        is_valid_directed_hamiltonian_path(&self.graph, solution)
     }
 }
 
 impl Problem for DirectedHamiltonianPath {
     const NAME: &'static str = "DirectedHamiltonianPath";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_arcs", num_arcs), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        lehmer_dims(self.graph.num_vertices())
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        let n = self.graph.num_vertices();
+        if solution.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "path ordering length does not match the graph vertices".into(),
+            ));
+        }
+        if solution.iter().any(|&vertex| vertex >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "path ordering contains an out-of-range vertex".into(),
+            ));
+        }
+        Ok(crate::types::Or(is_valid_directed_hamiltonian_path(
+            &self.graph,
+            solution,
+        )))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        let perm = decode_lehmer(config);
-        crate::types::Or(is_valid_directed_hamiltonian_path(&self.graph, &perm))
+impl crate::solvers::BruteForceProblem for DirectedHamiltonianPath {
+    fn dimensions(&self) -> Vec<usize> {
+        lehmer_dims(self.graph.num_vertices())
     }
 }
 
@@ -155,8 +174,6 @@ pub(crate) fn is_valid_directed_hamiltonian_path(graph: &DirectedGraph, perm: &[
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
-    use crate::rules::ilp_helpers::permutation_to_lehmer;
-
     // 6 vertices, arcs from issue #813
     // Hamiltonian path: [0, 1, 3, 2, 4, 5]
     let graph = DirectedGraph::new(
@@ -175,11 +192,11 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         ],
     );
     let optimal_perm = vec![0usize, 1, 3, 2, 4, 5];
-    let optimal_config = permutation_to_lehmer(&optimal_perm);
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "directed_hamiltonian_path",
         instance: Box::new(DirectedHamiltonianPath::new(graph)),
-        optimal_config,
+        optimal_config: serde_json::to_value(optimal_perm)
+            .expect("solution serialization must succeed"),
         optimal_value: serde_json::json!(true),
     }]
 }
@@ -188,6 +205,10 @@ crate::declare_variants! {
     default DirectedHamiltonianPath => "num_vertices^2 * 2^num_vertices",
 }
 
+crate::register_brute_force! {
+    DirectedHamiltonianPath decode |_problem: &DirectedHamiltonianPath, indices: Vec<usize>| decode_lehmer(&indices),
+}
+
 #[cfg(test)]
 #[path = "../../unit_tests/models/graph/directed_hamiltonian_path.rs"]
 mod tests;
diff --git a/src/models/graph/directed_two_commodity_integral_flow.rs b/src/models/graph/directed_two_commodity_integral_flow.rs
index f67445df5..11d7e53ef 100644
--- a/src/models/graph/directed_two_commodity_integral_flow.rs
+++ b/src/models/graph/directed_two_commodity_integral_flow.rs
@@ -17,17 +17,18 @@ inventory::submit! {
         display_name: "Directed Two-Commodity Integral Flow",
         aliases: &["D2CIF"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Two-commodity integral flow feasibility on a directed graph",
         fields: &[
             FieldInfo { name: "graph", type_name: "DirectedGraph", description: "Directed graph G = (V, A)" },
-            FieldInfo { name: "capacities", type_name: "Vec<u64>", description: "Capacity c(a) for each arc" },
+            FieldInfo { name: "capacities", type_name: "Vec<i64>", description: "Capacity c(a) for each arc" },
             FieldInfo { name: "source_1", type_name: "usize", description: "Source vertex s_1 for commodity 1" },
             FieldInfo { name: "sink_1", type_name: "usize", description: "Sink vertex t_1 for commodity 1" },
             FieldInfo { name: "source_2", type_name: "usize", description: "Source vertex s_2 for commodity 2" },
             FieldInfo { name: "sink_2", type_name: "usize", description: "Sink vertex t_2 for commodity 2" },
-            FieldInfo { name: "requirement_1", type_name: "u64", description: "Flow requirement R_1 for commodity 1" },
-            FieldInfo { name: "requirement_2", type_name: "u64", description: "Flow requirement R_2 for commodity 2" },
+            FieldInfo { name: "requirement_1", type_name: "i64", description: "Flow requirement R_1 for commodity 1" },
+            FieldInfo { name: "requirement_2", type_name: "i64", description: "Flow requirement R_2 for commodity 2" },
         ],
     }
 }
@@ -53,7 +54,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::DirectedTwoCommodityIntegralFlow;
 /// use problemreductions::topology::DirectedGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 6-vertex network: s1=0, s2=1, t1=4, t2=5
 /// let graph = DirectedGraph::new(6, vec![
@@ -64,14 +65,14 @@ inventory::submit! {
 ///     graph, vec![1; 8], 0, 4, 1, 5, 1, 1,
 /// );
 /// let solver = BruteForce::new();
-/// assert!(solver.find_witness(&problem).is_some());
+/// assert!(solver.solve(&problem).unwrap().is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DirectedTwoCommodityIntegralFlow {
     /// The directed graph G = (V, A).
     graph: DirectedGraph,
     /// Capacity c(a) for each arc.
-    capacities: Vec<u64>,
+    capacities: Vec<i64>,
     /// Source vertex s_1 for commodity 1.
     source_1: usize,
     /// Sink vertex t_1 for commodity 1.
@@ -81,9 +82,9 @@ pub struct DirectedTwoCommodityIntegralFlow {
     /// Sink vertex t_2 for commodity 2.
     sink_2: usize,
     /// Flow requirement R_1 for commodity 1.
-    requirement_1: u64,
+    requirement_1: i64,
     /// Flow requirement R_2 for commodity 2.
-    requirement_2: u64,
+    requirement_2: i64,
 }
 
 impl DirectedTwoCommodityIntegralFlow {
@@ -97,13 +98,13 @@ impl DirectedTwoCommodityIntegralFlow {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         graph: DirectedGraph,
-        capacities: Vec<u64>,
+        capacities: Vec<i64>,
         source_1: usize,
         sink_1: usize,
         source_2: usize,
         sink_2: usize,
-        requirement_1: u64,
-        requirement_2: u64,
+        requirement_1: i64,
+        requirement_2: i64,
     ) -> Self {
         let n = graph.num_vertices();
         assert_eq!(
@@ -111,6 +112,14 @@ impl DirectedTwoCommodityIntegralFlow {
             graph.num_arcs(),
             "capacities length must match graph num_arcs"
         );
+        assert!(
+            capacities.iter().all(|&capacity| capacity >= 0),
+            "capacities must be nonnegative"
+        );
+        assert!(
+            requirement_1 >= 0 && requirement_2 >= 0,
+            "flow requirements must be nonnegative"
+        );
         assert!(source_1 < n, "source_1 ({source_1}) >= num_vertices ({n})");
         assert!(sink_1 < n, "sink_1 ({sink_1}) >= num_vertices ({n})");
         assert!(source_2 < n, "source_2 ({source_2}) >= num_vertices ({n})");
@@ -133,7 +142,7 @@ impl DirectedTwoCommodityIntegralFlow {
     }
 
     /// Get a reference to the capacities.
-    pub fn capacities(&self) -> &[u64] {
+    pub fn capacities(&self) -> &[i64] {
         &self.capacities
     }
 
@@ -158,12 +167,12 @@ impl DirectedTwoCommodityIntegralFlow {
     }
 
     /// Get requirement for commodity 1.
-    pub fn requirement_1(&self) -> u64 {
+    pub fn requirement_1(&self) -> i64 {
         self.requirement_1
     }
 
     /// Get requirement for commodity 2.
-    pub fn requirement_2(&self) -> u64 {
+    pub fn requirement_2(&self) -> i64 {
         self.requirement_2
     }
 
@@ -178,39 +187,70 @@ impl DirectedTwoCommodityIntegralFlow {
     }
 
     /// Get the maximum capacity across all arcs.
-    pub fn max_capacity(&self) -> u64 {
+    pub fn max_capacity(&self) -> i64 {
         self.capacities.iter().copied().max().unwrap_or(0)
     }
 
     /// Check whether a flow assignment is feasible.
     ///
     /// `config` has 2*|A| entries: first |A| for commodity 1, next |A| for commodity 2.
-    pub fn is_feasible(&self, config: &[usize]) -> bool {
+    pub fn is_feasible(&self, config: &[usize]) -> Result<bool, crate::traits::EvaluationError> {
         let m = self.graph.num_arcs();
         if config.len() != 2 * m {
-            return false;
+            return Ok(false);
         }
         let arcs = self.graph.arcs();
         // (1) Joint capacity constraint
         for a in 0..m {
-            let f1 = config[a] as u64;
-            let f2 = config[m + a] as u64;
-            if f1 + f2 > self.capacities[a] {
-                return false;
+            let f1 = i64::try_from(config[a]).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting first commodity flow to i64".into(),
+                )
+            })?;
+            let f2 = i64::try_from(config[m + a]).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting second commodity flow to i64".into(),
+                )
+            })?;
+            if f1.checked_add(f2).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing two-commodity arc flow".into(),
+                )
+            })? > self.capacities[a]
+            {
+                return Ok(false);
             }
         }
 
         // (2) Flow conservation for each commodity at non-terminal vertices
         let n = self.graph.num_vertices();
-        let mut balances = [vec![0_i128; n], vec![0_i128; n]];
+        let mut balances = [vec![0_i64; n], vec![0_i64; n]];
         for (a, &(u, w)) in arcs.iter().enumerate() {
-            let flow_1 = config[a] as i128;
-            let flow_2 = config[m + a] as i128;
+            let flow_1 = i64::try_from(config[a]).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting first commodity flow to i64".into(),
+                )
+            })?;
+            let flow_2 = i64::try_from(config[m + a]).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting second commodity flow to i64".into(),
+                )
+            })?;
 
-            balances[0][u] -= flow_1;
-            balances[0][w] += flow_1;
-            balances[1][u] -= flow_2;
-            balances[1][w] += flow_2;
+            for (commodity, flow) in [(0, flow_1), (1, flow_2)] {
+                balances[commodity][u] =
+                    balances[commodity][u].checked_sub(flow).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "subtracting outgoing commodity flow".into(),
+                        )
+                    })?;
+                balances[commodity][w] =
+                    balances[commodity][w].checked_add(flow).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "adding incoming commodity flow".into(),
+                        )
+                    })?;
+            }
         }
 
         for (commodity, commodity_balances) in balances.iter().enumerate() {
@@ -226,7 +266,7 @@ impl DirectedTwoCommodityIntegralFlow {
                     self.sink_2
                 };
                 if v != src && v != snk && balance != 0 {
-                    return false;
+                    return Ok(false);
                 }
             }
 
@@ -241,29 +281,36 @@ impl DirectedTwoCommodityIntegralFlow {
                 self.requirement_2
             };
 
-            if commodity_balances[snk] < i128::from(req) {
-                return false;
+            if commodity_balances[snk] < req {
+                return Ok(false);
             }
         }
 
-        true
+        Ok(true)
     }
 }
 
 impl Problem for DirectedTwoCommodityIntegralFlow {
     const NAME: &'static str = "DirectedTwoCommodityIntegralFlow";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        self.capacities
-            .iter()
-            .chain(self.capacities.iter())
-            .map(|&c| (c as usize) + 1)
-            .collect()
-    }
+    crate::problem_parameters![
+        ("max_capacity", max_capacity),
+        ("num_arcs", num_arcs),
+        ("num_vertices", num_vertices),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_feasible(config))
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != 2 * self.graph.num_arcs() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "two-commodity flow vector length does not match the graph arcs".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_feasible(config)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -271,10 +318,24 @@ impl Problem for DirectedTwoCommodityIntegralFlow {
     }
 }
 
+impl crate::solvers::BruteForceProblem for DirectedTwoCommodityIntegralFlow {
+    fn dimensions(&self) -> Vec<usize> {
+        self.capacities
+            .iter()
+            .chain(self.capacities.iter())
+            .map(|&c| (c as usize) + 1)
+            .collect()
+    }
+}
+
 crate::declare_variants! {
     default DirectedTwoCommodityIntegralFlow => "(max_capacity + 1)^(2 * num_arcs)",
 }
 
+crate::register_brute_force! {
+    DirectedTwoCommodityIntegralFlow,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -301,7 +362,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             1,
             1,
         )),
-        optimal_config: vec![1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/disjoint_connecting_paths.rs b/src/models/graph/disjoint_connecting_paths.rs
index d565fa123..551e97e0f 100644
--- a/src/models/graph/disjoint_connecting_paths.rs
+++ b/src/models/graph/disjoint_connecting_paths.rs
@@ -3,7 +3,7 @@
 //! The problem asks whether an undirected graph contains pairwise
 //! vertex-disjoint paths connecting a prescribed collection of terminal pairs.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::variant::VariantParam;
@@ -18,12 +18,10 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find pairwise vertex-disjoint paths connecting given terminal pairs",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "terminal_pairs", type_name: "Vec<(usize, usize)>", description: "Disjoint terminal pairs (s_i, t_i)" },
-        ],
+        fields: DisjointConnectingPathsCreateSpec::FIELDS,
     }
 }
 
@@ -39,6 +37,62 @@ pub struct DisjointConnectingPaths<G> {
     terminal_pairs: Vec<(usize, usize)>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct DisjointConnectingPathsCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "edge-list")]
+    terminal_pairs: Vec<(usize, usize)>,
+}
+
+impl TryFrom<DisjointConnectingPathsCreateSpec> for DisjointConnectingPaths<SimpleGraph> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: DisjointConnectingPathsCreateSpec) -> Result<Self, Self::Error> {
+        if spec.graph.is_empty() && spec.num_vertices.is_none() {
+            return Err("num_vertices is required for an empty graph".into());
+        }
+        for &(u, v) in &spec.graph {
+            if u == v {
+                return Err(format!("self-loop {u}-{v} is not allowed").into());
+            }
+        }
+        let inferred = spec
+            .graph
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|v| v.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let count = spec.num_vertices.unwrap_or(inferred);
+        if count < inferred {
+            return Err("num_vertices is too small for graph endpoints".into());
+        }
+        if spec.terminal_pairs.is_empty() {
+            return Err("terminal_pairs must contain at least one pair".into());
+        }
+        let mut used = vec![false; count];
+        for &(source, sink) in &spec.terminal_pairs {
+            if source >= count || sink >= count {
+                return Err("terminal pair endpoint is out of bounds".into());
+            }
+            if source == sink {
+                return Err("terminal pair endpoints must be distinct".into());
+            }
+            if used[source] || used[sink] {
+                return Err("terminal vertices must be pairwise disjoint".into());
+            }
+            used[source] = true;
+            used[sink] = true;
+        }
+        Ok(Self {
+            graph: SimpleGraph::new(count, spec.graph),
+            terminal_pairs: spec.terminal_pairs,
+        })
+    }
+}
+
 impl<G: Graph> DisjointConnectingPaths<G> {
     /// Create a new Disjoint Connecting Paths instance.
     ///
@@ -107,7 +161,7 @@ impl<G: Graph> DisjointConnectingPaths<G> {
     }
 
     /// Check whether a configuration is a valid solution.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_valid_disjoint_connecting_paths(&self.graph, &self.terminal_pairs, config)
     }
 }
@@ -117,18 +171,38 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "DisjointConnectingPaths";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_pairs", num_pairs),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_valid_solution(config)))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_valid_solution(config))
+impl<G> crate::solvers::BruteForceProblem for DisjointConnectingPaths<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_edges()]
     }
 }
 
@@ -153,21 +227,17 @@ fn normalize_edge(u: usize, v: usize) -> (usize, usize) {
 fn is_valid_disjoint_connecting_paths<G: Graph>(
     graph: &G,
     terminal_pairs: &[(usize, usize)],
-    config: &[usize],
+    config: &[bool],
 ) -> bool {
     let edges = canonical_edges(graph);
     if config.len() != edges.len() {
         return false;
     }
-    if config.iter().any(|&value| value > 1) {
-        return false;
-    }
-
     let num_vertices = graph.num_vertices();
     let mut adjacency = vec![Vec::new(); num_vertices];
     let mut degrees = vec![0usize; num_vertices];
     for (index, &chosen) in config.iter().enumerate() {
-        if chosen == 1 {
+        if chosen {
             let (u, v) = edges[index];
             adjacency[u].push(v);
             adjacency[v].push(u);
@@ -243,7 +313,11 @@ fn is_valid_disjoint_connecting_paths<G: Graph>(
 }
 
 crate::declare_variants! {
-    default DisjointConnectingPaths<SimpleGraph> => "2^num_edges",
+    default DisjointConnectingPaths<SimpleGraph> => "2^num_edges" create DisjointConnectingPathsCreateSpec,
+}
+
+crate::register_brute_force! {
+    DisjointConnectingPaths<SimpleGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -257,7 +331,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ),
             vec![(0, 3), (2, 5)],
         )),
-        optimal_config: vec![1, 0, 1, 0, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![true, false, true, false, true, false, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/eulerian_path.rs b/src/models/graph/eulerian_path.rs
index b45f43db8..661ebd04a 100644
--- a/src/models/graph/eulerian_path.rs
+++ b/src/models/graph/eulerian_path.rs
@@ -15,7 +15,7 @@
 //! time `O(num_vertices + num_arcs)` by the classical degree-balance plus
 //! Hierholzer construction (Bang-Jensen & Gutin 2009; Ebert 1988).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry, VariantDimension};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -25,9 +25,8 @@ inventory::submit! {
         name: "EulerianPath",
         display_name: "Eulerian Path",
         aliases: &[],
-        dimensions: &[
-            VariantDimension::new("graph", "DirectedGraph", &["DirectedGraph"]),
-        ],
+        dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Does the directed multigraph admit a directed trail using every arc exactly once?",
         fields: &[
@@ -40,13 +39,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "EulerianPath",
-        fields: &["num_vertices", "num_arcs"],
-    }
-}
-
 /// The Eulerian Path problem on directed multigraphs.
 ///
 /// A configuration is an arc-ordering `pi`: position `t` carries the index of
@@ -66,7 +58,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::EulerianPath;
 /// use problemreductions::topology::DirectedGraph;
-/// use problemreductions::{BruteForce, Problem, Solver};
+/// use problemreductions::{BruteForce, Problem};
 ///
 /// // V = {0,1,2}; A = [(0,1), (0,1), (1,2), (2,0)] (parallel arc (0,1)).
 /// let graph = DirectedGraph::new(3, vec![(0, 1), (0, 1), (1, 2), (2, 0)]);
@@ -74,7 +66,7 @@ inventory::submit! {
 ///
 /// // Witness: ordering [a_0, a_2, a_3, a_1] = (0->1)->(1->2)->(2->0)->(0->1)
 /// // traces trail 0->1->2->0->1.
-/// let witness = BruteForce::new().find_witness(&problem);
+/// let witness = BruteForce::new().solve(&problem).unwrap();
 /// assert!(witness.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -111,19 +103,41 @@ impl EulerianPath {
 
 impl Problem for EulerianPath {
     const NAME: &'static str = "EulerianPath";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_arcs", num_arcs), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
         let m = self.graph.num_arcs();
-        vec![m; m]
+        if config.len() != m {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "arc ordering length does not match the graph".into(),
+            ));
+        }
+        if config.iter().any(|&arc| arc >= m) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "arc ordering contains an out-of-range arc".into(),
+            ));
+        }
+        Ok(crate::types::Or(is_valid_eulerian_trail(
+            &self.graph,
+            config,
+        )))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(is_valid_eulerian_trail(&self.graph, config))
+impl crate::solvers::BruteForceProblem for EulerianPath {
+    fn dimensions(&self) -> Vec<usize> {
+        let m = self.graph.num_arcs();
+        vec![m; m]
     }
 }
 
@@ -174,7 +188,8 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "eulerian_path",
         instance: Box::new(EulerianPath::new(graph)),
-        optimal_config,
+        optimal_config: serde_json::to_value(optimal_config)
+            .expect("solution serialization must succeed"),
         optimal_value: serde_json::json!(true),
     }]
 }
@@ -183,6 +198,10 @@ crate::declare_variants! {
     default EulerianPath => "num_vertices + num_arcs",
 }
 
+crate::register_brute_force! {
+    EulerianPath,
+}
+
 #[cfg(test)]
 #[path = "../../unit_tests/models/graph/eulerian_path.rs"]
 mod tests;
diff --git a/src/models/graph/generalized_hex.rs b/src/models/graph/generalized_hex.rs
index ef7252aae..7e91bc9b9 100644
--- a/src/models/graph/generalized_hex.rs
+++ b/src/models/graph/generalized_hex.rs
@@ -7,7 +7,7 @@ use std::collections::{HashMap, VecDeque};
 
 use serde::{Deserialize, Serialize};
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::variant::VariantParam;
@@ -20,13 +20,10 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Determine whether Player 1 has a forced blue path between two terminals",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "source", type_name: "usize", description: "The source terminal s" },
-            FieldInfo { name: "target", type_name: "usize", description: "The target terminal t" },
-        ],
+        fields: GeneralizedHexCreateSpec::FIELDS,
     }
 }
 
@@ -43,6 +40,42 @@ pub struct GeneralizedHex<G> {
     target: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct GeneralizedHexCreateSpec {
+    /// The underlying graph G=(V,E).
+    graph: SimpleGraph,
+    /// The source terminal s.
+    source: usize,
+    /// The target terminal t.
+    sink: usize,
+}
+
+impl TryFrom<GeneralizedHexCreateSpec> for GeneralizedHex<SimpleGraph> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: GeneralizedHexCreateSpec) -> Result<Self, Self::Error> {
+        let num_vertices = spec.graph.num_vertices();
+        if spec.source >= num_vertices {
+            return Err(format!(
+                "source {} is outside graph with {num_vertices} vertices",
+                spec.source
+            )
+            .into());
+        }
+        if spec.sink >= num_vertices {
+            return Err(format!(
+                "sink {} is outside graph with {num_vertices} vertices",
+                spec.sink
+            )
+            .into());
+        }
+        if spec.source == spec.sink {
+            return Err("source and sink must be distinct".to_string().into());
+        }
+        Ok(Self::new(spec.graph, spec.source, spec.sink))
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 enum ClaimState {
     Unclaimed,
@@ -239,32 +272,59 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "GeneralizedHex";
+    type Solution = ();
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_vertices", num_vertices),
+        ("num_edges", num_edges),
+        ("num_playable_vertices", num_playable_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![]
+    fn evaluate(
+        &self,
+        _solution: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                let playable_vertices = self.playable_vertices();
+                let vertex_to_state_index = self.vertex_to_state_index(&playable_vertices);
+                let mut state = vec![ClaimState::Unclaimed; playable_vertices.len()];
+                let mut memo = HashMap::new();
+                self.first_player_wins(&mut state, &vertex_to_state_index, &mut memo)
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if !config.is_empty() {
-                return crate::types::Or(false);
-            }
-            let playable_vertices = self.playable_vertices();
-            let vertex_to_state_index = self.vertex_to_state_index(&playable_vertices);
-            let mut state = vec![ClaimState::Unclaimed; playable_vertices.len()];
-            let mut memo = HashMap::new();
-            self.first_player_wins(&mut state, &vertex_to_state_index, &mut memo)
-        })
+impl<G> crate::solvers::BruteForceProblem for GeneralizedHex<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![]
     }
 }
 
+crate::impl_random_generate!(
+    GeneralizedHex<SimpleGraph>,
+    crate::random::EndpointRandomSpec,
+    |spec| {
+        let (source, sink) = spec.endpoints()?;
+        Ok(GeneralizedHex::new(spec.graph()?, source, sink))
+    }
+);
+
 crate::declare_variants! {
-    default GeneralizedHex<SimpleGraph> => "3^num_playable_vertices",
+    default GeneralizedHex<SimpleGraph> => "3^num_playable_vertices" create GeneralizedHexCreateSpec random,
+}
+
+crate::register_brute_force! {
+    GeneralizedHex<SimpleGraph> decode |_, _| (),
 }
 
 #[cfg(feature = "example-db")]
@@ -279,7 +339,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             0,
             5,
         )),
-        optimal_config: vec![],
+        optimal_config: serde_json::json!(null),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/graph_partitioning.rs b/src/models/graph/graph_partitioning.rs
index f69aadd2b..6a59a6e48 100644
--- a/src/models/graph/graph_partitioning.rs
+++ b/src/models/graph/graph_partitioning.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum cut balanced bisection of a graph",
         fields: &[
@@ -41,18 +42,18 @@ inventory::submit! {
 /// use problemreductions::models::graph::GraphPartitioning;
 /// use problemreductions::topology::SimpleGraph;
 /// use problemreductions::types::Min;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Square graph: 0-1, 1-2, 2-3, 3-0
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (3, 0)]);
 /// let problem = GraphPartitioning::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Minimum bisection of a 4-cycle: cut = 2
 /// for sol in solutions {
-///     let size = problem.evaluate(&sol);
+///     let size = problem.evaluate(&sol).unwrap();
 ///     assert_eq!(size, Min(Some(2)));
 /// }
 /// ```
@@ -92,41 +93,53 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "GraphPartitioning";
-    type Value = Min<i32>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let n = self.graph.num_vertices();
+            if config.len() != n {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "partition assignment length does not match the graph vertices".into(),
+                ));
+            }
+            // Balanced bisection requires even n
+            if !n.is_multiple_of(2) {
+                return Ok(Min(None));
+            }
+            // Check balanced: exactly n/2 vertices in partition 1
+            let count_ones = config.iter().filter(|&&x| x).count();
+            if count_ones != n / 2 {
+                return Ok(Min(None));
+            }
+            // Count crossing edges
+            let mut cut = 0i64;
+            for (u, v) in self.graph.edges() {
+                if config[u] != config[v] {
+                    cut += 1;
+                }
+            }
+            Min(Some(cut))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<i32> {
-        let n = self.graph.num_vertices();
-        if config.len() != n {
-            return Min(None);
-        }
-        if config.iter().any(|&part| part >= 2) {
-            return Min(None);
-        }
-        // Balanced bisection requires even n
-        if !n.is_multiple_of(2) {
-            return Min(None);
-        }
-        // Check balanced: exactly n/2 vertices in partition 1
-        let count_ones = config.iter().filter(|&&x| x == 1).count();
-        if count_ones != n / 2 {
-            return Min(None);
-        }
-        // Count crossing edges
-        let mut cut = 0i32;
-        for (u, v) in self.graph.edges() {
-            if config[u] != config[v] {
-                cut += 1;
-            }
-        }
-        Min(Some(cut))
+impl<G> crate::solvers::BruteForceProblem for GraphPartitioning<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
@@ -134,6 +147,10 @@ crate::declare_variants! {
     default GraphPartitioning<SimpleGraph> => "2^num_vertices",
 }
 
+crate::register_brute_force! {
+    GraphPartitioning<SimpleGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     use crate::topology::SimpleGraph;
@@ -154,7 +171,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 (4, 5),
             ],
         ))),
-        optimal_config: vec![0, 0, 0, 1, 1, 1],
+        optimal_config: serde_json::json!(vec![false, false, false, true, true, true]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/graph/hamiltonian_circuit.rs b/src/models/graph/hamiltonian_circuit.rs
index 471c15af0..35ea2621c 100644
--- a/src/models/graph/hamiltonian_circuit.rs
+++ b/src/models/graph/hamiltonian_circuit.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Does the graph contain a Hamiltonian circuit?",
         fields: &[
@@ -39,18 +40,18 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::HamiltonianCircuit;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Square graph (4-cycle) has a Hamiltonian circuit
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (0, 3)]);
 /// let problem = HamiltonianCircuit::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Verify all solutions are valid Hamiltonian circuits
 /// for sol in &solutions {
-///     assert!(problem.evaluate(sol));
+///     assert!(problem.evaluate(sol).unwrap());
 /// }
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -92,19 +93,44 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "HamiltonianCircuit";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
         let n = self.graph.num_vertices();
-        vec![n; n]
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "circuit ordering length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&vertex| vertex >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "circuit ordering contains an out-of-range vertex".into(),
+            ));
+        }
+        Ok(crate::types::Or(is_valid_hamiltonian_circuit(
+            &self.graph,
+            config,
+        )))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(is_valid_hamiltonian_circuit(&self.graph, config))
+impl<G> crate::solvers::BruteForceProblem for HamiltonianCircuit<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.graph.num_vertices();
+        vec![n; n]
     }
 }
 
@@ -159,13 +185,23 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 (2, 5),
             ],
         ))),
-        optimal_config: vec![0, 1, 2, 5, 4, 3],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 5, 4, 3]),
         optimal_value: serde_json::json!(true),
     }]
 }
 
+crate::impl_random_generate!(
+    HamiltonianCircuit<SimpleGraph>,
+    crate::random::SimpleGraphRandomSpec,
+    |spec| { Ok(HamiltonianCircuit::new(spec.graph()?)) }
+);
+
 crate::declare_variants! {
-    default HamiltonianCircuit<SimpleGraph> => "1.657^num_vertices",
+    default HamiltonianCircuit<SimpleGraph> => "1.657^num_vertices" random,
+}
+
+crate::register_brute_force! {
+    HamiltonianCircuit<SimpleGraph>,
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/hamiltonian_path.rs b/src/models/graph/hamiltonian_path.rs
index ddc39ffa1..b31d6d2ff 100644
--- a/src/models/graph/hamiltonian_path.rs
+++ b/src/models/graph/hamiltonian_path.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a Hamiltonian path in a graph",
         fields: &[
@@ -51,14 +52,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::HamiltonianPath;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Path graph: 0-1-2-3
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
 /// let problem = HamiltonianPath::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -99,19 +100,44 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "HamiltonianPath";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
         let n = self.graph.num_vertices();
-        vec![n; n]
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "path ordering length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&vertex| vertex >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "path ordering contains an out-of-range vertex".into(),
+            ));
+        }
+        Ok(crate::types::Or(is_valid_hamiltonian_path(
+            &self.graph,
+            config,
+        )))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(is_valid_hamiltonian_path(&self.graph, config))
+impl<G> crate::solvers::BruteForceProblem for HamiltonianPath<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.graph.num_vertices();
+        vec![n; n]
     }
 }
 
@@ -161,14 +187,24 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 (5, 1),
             ],
         ))),
-        optimal_config: vec![0, 2, 4, 3, 1, 5],
+        optimal_config: serde_json::json!(vec![0, 2, 4, 3, 1, 5]),
         optimal_value: serde_json::json!(true),
     }]
 }
 
 // Use Bjorklund (2014) O*(1.657^n) as best known for general undirected graphs
+crate::impl_random_generate!(
+    HamiltonianPath<SimpleGraph>,
+    crate::random::SimpleGraphRandomSpec,
+    |spec| { Ok(HamiltonianPath::new(spec.graph()?)) }
+);
+
 crate::declare_variants! {
-    default HamiltonianPath<SimpleGraph> => "1.657^num_vertices",
+    default HamiltonianPath<SimpleGraph> => "1.657^num_vertices" random,
+}
+
+crate::register_brute_force! {
+    HamiltonianPath<SimpleGraph>,
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/hamiltonian_path_between_two_vertices.rs b/src/models/graph/hamiltonian_path_between_two_vertices.rs
index 08dfe8408..7ae5bbbcd 100644
--- a/src/models/graph/hamiltonian_path_between_two_vertices.rs
+++ b/src/models/graph/hamiltonian_path_between_two_vertices.rs
@@ -18,6 +18,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a Hamiltonian path between two specified vertices in a graph",
         fields: &[
@@ -57,14 +58,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::HamiltonianPathBetweenTwoVertices;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Path graph: 0-1-2-3, source=0, target=3
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
 /// let problem = HamiltonianPathBetweenTwoVertices::new(graph, 0, 3);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -75,6 +76,20 @@ pub struct HamiltonianPathBetweenTwoVertices<G> {
     target_vertex: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct HamiltonianPathBetweenTwoVerticesRandomSpec {
+    /// Number of graph vertices.
+    num_vertices: usize,
+    /// Independent edge probability (default: 0.5).
+    edge_prob: Option<f64>,
+    /// Seed for reproducible generation.
+    seed: Option<i64>,
+    /// Path start vertex (default: 0).
+    source_vertex: Option<usize>,
+    /// Path end vertex (default: the final vertex).
+    target_vertex: Option<usize>,
+}
+
 impl<G: Graph> HamiltonianPathBetweenTwoVertices<G> {
     /// Create a new Hamiltonian Path Between Two Vertices problem.
     ///
@@ -138,24 +153,48 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "HamiltonianPathBetweenTwoVertices";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
         let n = self.graph.num_vertices();
-        vec![n; n]
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "path ordering length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&vertex| vertex >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "path ordering contains an out-of-range vertex".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or(is_valid_hamiltonian_st_path(
+                &self.graph,
+                config,
+                self.source_vertex,
+                self.target_vertex,
+            ))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(is_valid_hamiltonian_st_path(
-            &self.graph,
-            config,
-            self.source_vertex,
-            self.target_vertex,
-        ))
+impl<G> crate::solvers::BruteForceProblem for HamiltonianPathBetweenTwoVertices<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.graph.num_vertices();
+        vec![n; n]
     }
 }
 
@@ -223,14 +262,44 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             0,
             5,
         )),
-        optimal_config: vec![0, 3, 2, 1, 4, 5],
+        optimal_config: serde_json::json!(vec![0, 3, 2, 1, 4, 5]),
         optimal_value: serde_json::json!(true),
     }]
 }
 
 // Use Bjorklund (2014) O*(1.657^n) as best known for general undirected graphs
+crate::impl_random_generate!(
+    HamiltonianPathBetweenTwoVertices<SimpleGraph>,
+    HamiltonianPathBetweenTwoVerticesRandomSpec,
+    |spec| {
+        if spec.num_vertices < 2 {
+            return Err("num_vertices must be at least 2".to_string().into());
+        }
+        let source = spec.source_vertex.unwrap_or(0);
+        let sink = spec.target_vertex.unwrap_or(spec.num_vertices - 1);
+        if source >= spec.num_vertices || sink >= spec.num_vertices || source == sink {
+            return Err(
+                "source_vertex and target_vertex must be distinct valid vertices"
+                    .to_string()
+                    .into(),
+            );
+        }
+        let graph = crate::random::SimpleGraphRandomSpec {
+            num_vertices: spec.num_vertices,
+            edge_prob: spec.edge_prob,
+            seed: spec.seed,
+        }
+        .graph()?;
+        Ok(HamiltonianPathBetweenTwoVertices::new(graph, source, sink))
+    }
+);
+
 crate::declare_variants! {
-    default HamiltonianPathBetweenTwoVertices<SimpleGraph> => "1.657^num_vertices",
+    default HamiltonianPathBetweenTwoVertices<SimpleGraph> => "1.657^num_vertices" random,
+}
+
+crate::register_brute_force! {
+    HamiltonianPathBetweenTwoVertices<SimpleGraph>,
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/highly_connected_deletion.rs b/src/models/graph/highly_connected_deletion.rs
index a932f3c81..d1f7fca64 100644
--- a/src/models/graph/highly_connected_deletion.rs
+++ b/src/models/graph/highly_connected_deletion.rs
@@ -16,7 +16,7 @@
 //! - Hartuv, Shamir, "A clustering algorithm based on graph connectivity",
 //!   Information Processing Letters 76(4–6):175–181, 2000.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry, VariantDimension};
+use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::Min;
@@ -32,6 +32,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Minimum number of edge deletions so every component is an isolated vertex or a highly connected graph on >=3 vertices",
         fields: &[
@@ -40,13 +41,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "HighlyConnectedDeletion",
-        fields: &["num_vertices", "num_edges"],
-    }
-}
-
 /// The Highly Connected Deletion problem.
 ///
 /// Given a simple undirected graph `G = (V, E)`, find a minimum-cardinality
@@ -66,7 +60,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::HighlyConnectedDeletion;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{BruteForce, Problem, Solver};
+/// use problemreductions::{BruteForce, Problem};
 /// use problemreductions::types::Min;
 ///
 /// // Triangle on {0,1,2} with leaf vertex 3 attached to 2.
@@ -74,7 +68,8 @@ inventory::submit! {
 /// let problem = HighlyConnectedDeletion::new(graph);
 ///
 /// // Optimal: delete only the leaf edge (2,3) → K3 + isolated {3}.
-/// assert_eq!(BruteForce::new().solve(&problem), Min(Some(1)));
+/// let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+/// assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(1)));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(bound(deserialize = "G: serde::Deserialize<'de>"))]
@@ -106,7 +101,7 @@ impl<G: Graph> HighlyConnectedDeletion<G> {
 
     /// Check whether a deletion configuration leaves every component as either
     /// an isolated vertex or a highly connected graph on at least `3` vertices.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_feasible_deletion(&self.graph, config)
     }
 }
@@ -116,22 +111,45 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "HighlyConnectedDeletion";
+    type Solution = Vec<bool>;
     type Value = Min<i64>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
+        }
+        Ok({
+            if !is_feasible_deletion(&self.graph, config) {
+                return Ok(Min(None));
+            }
+            let deleted = i64::try_from(config.iter().filter(|&&deleted| deleted).count())
+                .map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting deleted-edge count to i64".into(),
+                    )
+                })?;
+            Min(Some(deleted))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<i64> {
-        if !is_feasible_deletion(&self.graph, config) {
-            return Min(None);
-        }
-        let deleted: i64 = config.iter().filter(|&&x| x == 1).count() as i64;
-        Min(Some(deleted))
+impl<G> crate::solvers::BruteForceProblem for HighlyConnectedDeletion<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
 }
 
@@ -140,7 +158,7 @@ where
 /// `config[e] = 1` means edge `e` (in `graph.edges()` order) is deleted.
 /// The remaining graph `G - F` must have every connected component be either
 /// a singleton or a highly connected graph on at least `3` vertices.
-fn is_feasible_deletion<G: Graph>(graph: &G, config: &[usize]) -> bool {
+fn is_feasible_deletion<G: Graph>(graph: &G, config: &[bool]) -> bool {
     let n = graph.num_vertices();
     let edges = graph.edges();
     if config.len() != edges.len() {
@@ -150,7 +168,7 @@ fn is_feasible_deletion<G: Graph>(graph: &G, config: &[usize]) -> bool {
     // Build adjacency from the surviving edges only.
     let mut adj: Vec<Vec<usize>> = vec![Vec::new(); n];
     for (i, &(u, v)) in edges.iter().enumerate() {
-        if config.get(i).copied().unwrap_or(0) == 0 {
+        if !config.get(i).copied().unwrap_or(false) {
             adj[u].push(v);
             adj[v].push(u);
         }
@@ -222,7 +240,7 @@ fn edge_connectivity(vertices: &[usize], adj: &[Vec<usize>]) -> usize {
     // current residual capacity.
     let in_component: HashSet<usize> = vertices.iter().copied().collect();
     let mut head: Vec<usize> = Vec::new();
-    let mut cap: Vec<i32> = Vec::new();
+    let mut cap: Vec<u8> = Vec::new();
     let mut out: Vec<Vec<usize>> = vec![Vec::new(); size];
 
     let mut seen_edges: HashSet<(usize, usize)> = HashSet::new();
@@ -259,7 +277,7 @@ fn edge_connectivity(vertices: &[usize], adj: &[Vec<usize>]) -> usize {
         let mut flow = 0usize;
         loop {
             // BFS to find an augmenting path with positive residual capacity.
-            let mut parent_arc: Vec<i32> = vec![-1; size];
+            let mut parent_arc: Vec<Option<usize>> = vec![None; size];
             let mut visited = vec![false; size];
             visited[s] = true;
             let mut queue: VecDeque<usize> = VecDeque::new();
@@ -272,7 +290,7 @@ fn edge_connectivity(vertices: &[usize], adj: &[Vec<usize>]) -> usize {
                     let v = head[a];
                     if !visited[v] && cap[a] > 0 {
                         visited[v] = true;
-                        parent_arc[v] = a as i32;
+                        parent_arc[v] = Some(a);
                         queue.push_back(v);
                     }
                 }
@@ -283,7 +301,7 @@ fn edge_connectivity(vertices: &[usize], adj: &[Vec<usize>]) -> usize {
             // Augment by 1 (unit capacities).
             let mut cur = t;
             while cur != s {
-                let a = parent_arc[cur] as usize;
+                let a = parent_arc[cur].expect("visited vertex has a BFS parent arc");
                 cap[a] -= 1;
                 cap[a ^ 1] += 1;
                 // The originating endpoint is the head of the reverse arc.
@@ -309,6 +327,10 @@ crate::declare_variants! {
     default HighlyConnectedDeletion<SimpleGraph> => "2^num_edges",
 }
 
+crate::register_brute_force! {
+    HighlyConnectedDeletion<SimpleGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -318,7 +340,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![(0, 1), (0, 2), (1, 2), (2, 3)],
         ))),
         // Edges in input order; deleting only edge index 3 = (2,3) leaves K3 + {3}.
-        optimal_config: vec![0, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![false, false, false, true]),
         optimal_value: serde_json::json!(1),
     }]
 }
diff --git a/src/models/graph/integral_flow_bundles.rs b/src/models/graph/integral_flow_bundles.rs
index 893cb1da3..a9f99f931 100644
--- a/src/models/graph/integral_flow_bundles.rs
+++ b/src/models/graph/integral_flow_bundles.rs
@@ -3,7 +3,7 @@
 //! Given a directed graph with overlapping bundle-capacity constraints on arcs,
 //! determine whether an integral flow can deliver a required amount to the sink.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -15,23 +15,10 @@ inventory::submit! {
         display_name: "Integral Flow with Bundles",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Integral flow feasibility on a directed graph with overlapping bundle capacities",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "DirectedGraph", description: "Directed graph G=(V,A)" },
-            FieldInfo { name: "source", type_name: "usize", description: "Source vertex s" },
-            FieldInfo { name: "sink", type_name: "usize", description: "Sink vertex t" },
-            FieldInfo { name: "bundles", type_name: "Vec<Vec<usize>>", description: "Bundles of arc indices covering A" },
-            FieldInfo { name: "bundle_capacities", type_name: "Vec<u64>", description: "Capacity c_j for each bundle I_j" },
-            FieldInfo { name: "requirement", type_name: "u64", description: "Required net inflow R at the sink" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "IntegralFlowBundles",
-        fields: &["num_vertices", "num_arcs", "num_bundles"],
+        fields: IntegralFlowBundlesCreateSpec::FIELDS,
     }
 }
 
@@ -42,8 +29,96 @@ pub struct IntegralFlowBundles {
     source: usize,
     sink: usize,
     bundles: Vec<Vec<usize>>,
-    bundle_capacities: Vec<u64>,
-    requirement: u64,
+    bundle_capacities: Vec<i64>,
+    requirement: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct IntegralFlowBundlesCreateSpec {
+    #[create(codec = "arc-list")]
+    arcs: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "semicolon-separated")]
+    bundles: Vec<Vec<usize>>,
+    #[create(codec = "comma-separated")]
+    bundle_capacities: Vec<i64>,
+    source: usize,
+    sink: usize,
+    requirement: i64,
+}
+
+impl TryFrom<IntegralFlowBundlesCreateSpec> for IntegralFlowBundles {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(
+        spec: IntegralFlowBundlesCreateSpec,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        if spec.arcs.is_empty() {
+            return Err("arcs must be non-empty".into());
+        }
+        let inferred = spec
+            .arcs
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|v| v.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let count = spec.num_vertices.unwrap_or(inferred);
+        if count < inferred {
+            return Err("num_vertices is too small".into());
+        }
+        if spec.source >= count || spec.sink >= count {
+            return Err("source and sink must be valid vertices".into());
+        }
+        if spec.source == spec.sink {
+            return Err("source and sink must be distinct".into());
+        }
+        if spec.bundles.len() != spec.bundle_capacities.len() {
+            return Err("bundles length must match bundle_capacities length".into());
+        }
+        if spec.requirement == 0 {
+            return Err("requirement must be positive".into());
+        }
+        let mut covered = vec![false; spec.arcs.len()];
+        let mut upper = vec![i64::MAX; spec.arcs.len()];
+        for (i, (bundle, &capacity)) in spec.bundles.iter().zip(&spec.bundle_capacities).enumerate()
+        {
+            if capacity == 0 {
+                return Err(format!("bundle capacity {i} must be positive").into());
+            }
+            let mut seen = BTreeSet::new();
+            for &arc in bundle {
+                if arc >= spec.arcs.len() {
+                    return Err(format!("bundle {i} arc is out of range").into());
+                }
+                if !seen.insert(arc) {
+                    return Err(format!("bundle {i} contains duplicate arc").into());
+                }
+                covered[arc] = true;
+                upper[arc] = upper[arc].min(capacity);
+            }
+        }
+        for (arc, &is_covered) in covered.iter().enumerate() {
+            if !is_covered {
+                return Err(format!("arc {arc} must belong to a bundle").into());
+            }
+            if usize::try_from(upper[arc])
+                .ok()
+                .and_then(|v| v.checked_add(1))
+                .is_none()
+            {
+                return Err(format!("arc {arc} upper bound is too large").into());
+            }
+        }
+        Ok(Self {
+            graph: DirectedGraph::new(count, spec.arcs),
+            source: spec.source,
+            sink: spec.sink,
+            bundles: spec.bundles,
+            bundle_capacities: spec.bundle_capacities,
+            requirement: spec.requirement,
+        })
+    }
 }
 
 impl IntegralFlowBundles {
@@ -53,8 +128,8 @@ impl IntegralFlowBundles {
         source: usize,
         sink: usize,
         bundles: Vec<Vec<usize>>,
-        bundle_capacities: Vec<u64>,
-        requirement: u64,
+        bundle_capacities: Vec<i64>,
+        requirement: i64,
     ) -> Self {
         let num_vertices = graph.num_vertices();
         let num_arcs = graph.num_arcs();
@@ -76,7 +151,7 @@ impl IntegralFlowBundles {
         assert!(requirement > 0, "requirement must be positive");
 
         let mut arc_covered = vec![false; num_arcs];
-        let mut arc_upper_bounds = vec![u64::MAX; num_arcs];
+        let mut arc_upper_bounds = vec![i64::MAX; num_arcs];
 
         for (bundle_index, (bundle, &capacity)) in
             bundles.iter().zip(&bundle_capacities).enumerate()
@@ -146,12 +221,12 @@ impl IntegralFlowBundles {
     }
 
     /// Get the bundle capacities.
-    pub fn bundle_capacities(&self) -> &[u64] {
+    pub fn bundle_capacities(&self) -> &[i64] {
         &self.bundle_capacities
     }
 
     /// Get the required net inflow at the sink.
-    pub fn requirement(&self) -> u64 {
+    pub fn requirement(&self) -> i64 {
         self.requirement
     }
 
@@ -171,12 +246,15 @@ impl IntegralFlowBundles {
     }
 
     /// Check whether a configuration is feasible.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
+    pub fn is_valid_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(self.evaluate_solution(config)?.0)
     }
 
-    fn arc_upper_bounds(&self) -> Vec<u64> {
-        let mut upper_bounds = vec![u64::MAX; self.num_arcs()];
+    fn arc_upper_bounds(&self) -> Vec<i64> {
+        let mut upper_bounds = vec![i64::MAX; self.num_arcs()];
         for (bundle, &capacity) in self.bundles.iter().zip(&self.bundle_capacities) {
             for &arc_index in bundle {
                 upper_bounds[arc_index] = upper_bounds[arc_index].min(capacity);
@@ -185,26 +263,113 @@ impl IntegralFlowBundles {
         upper_bounds
     }
 
-    fn vertex_balance(&self, config: &[usize], vertex: usize) -> Option<i128> {
-        let mut balance = 0i128;
+    fn vertex_balance(
+        &self,
+        config: &[usize],
+        vertex: usize,
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
+        let mut balance = 0_i64;
         for (arc_index, (u, v)) in self.graph.arcs().into_iter().enumerate() {
-            let flow = i128::from(u64::try_from(*config.get(arc_index)?).ok()?);
+            let Some(&raw_flow) = config.get(arc_index) else {
+                return Ok(None);
+            };
+            let flow = i64::try_from(raw_flow).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting bundled arc flow to i64".into(),
+                )
+            })?;
             if vertex == u {
-                balance -= flow;
+                balance = balance.checked_sub(flow).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "subtracting outgoing bundled flow".into(),
+                    )
+                })?;
             }
             if vertex == v {
-                balance += flow;
+                balance = balance.checked_add(flow).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "adding incoming bundled flow".into(),
+                    )
+                })?;
             }
         }
-        Some(balance)
+        Ok(Some(balance))
+    }
+
+    fn evaluate_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_arcs() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "flow vector length does not match the graph arcs".into(),
+            ));
+        }
+
+        let upper_bounds = self.arc_upper_bounds();
+        for (&value, &upper_bound) in config.iter().zip(&upper_bounds) {
+            if i64::try_from(value).map_or(true, |value| value > upper_bound) {
+                return Ok(crate::types::Or(false));
+            }
+        }
+
+        for (bundle, &capacity) in self.bundles.iter().zip(&self.bundle_capacities) {
+            let mut total = 0i64;
+            for &arc_index in bundle {
+                let Ok(flow) = i64::try_from(config[arc_index]) else {
+                    return Ok(crate::types::Or(false));
+                };
+                let Some(next_total) = total.checked_add(flow) else {
+                    return Ok(crate::types::Or(false));
+                };
+                total = next_total;
+            }
+            if total > capacity {
+                return Ok(crate::types::Or(false));
+            }
+        }
+
+        for vertex in 0..self.num_vertices() {
+            if vertex == self.source || vertex == self.sink {
+                continue;
+            }
+            if self.vertex_balance(config, vertex)? != Some(0) {
+                return Ok(crate::types::Or(false));
+            }
+        }
+
+        Ok(crate::types::Or(matches!(
+            self.vertex_balance(config, self.sink)?,
+            Some(balance) if balance >= self.requirement
+        )))
     }
 }
 
 impl Problem for IntegralFlowBundles {
     const NAME: &'static str = "IntegralFlowBundles";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
+    crate::problem_parameters![
+        ("num_arcs", num_arcs),
+        ("num_bundles", num_bundles),
+        ("num_vertices", num_vertices),
+    ];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        self.evaluate_solution(config)
+    }
+
+    fn variant() -> Vec<(&'static str, &'static str)> {
+        crate::variant_params![]
+    }
+}
+
+impl crate::solvers::BruteForceProblem for IntegralFlowBundles {
+    fn dimensions(&self) -> Vec<usize> {
         self.arc_upper_bounds()
             .into_iter()
             .map(|bound| {
@@ -215,59 +380,14 @@ impl Problem for IntegralFlowBundles {
             })
             .collect()
     }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_arcs() {
-                return crate::types::Or(false);
-            }
-
-            let upper_bounds = self.arc_upper_bounds();
-            for (&value, &upper_bound) in config.iter().zip(&upper_bounds) {
-                if u64::try_from(value).map_or(true, |value| value > upper_bound) {
-                    return crate::types::Or(false);
-                }
-            }
-
-            for (bundle, &capacity) in self.bundles.iter().zip(&self.bundle_capacities) {
-                let mut total = 0u64;
-                for &arc_index in bundle {
-                    let Ok(flow) = u64::try_from(config[arc_index]) else {
-                        return crate::types::Or(false);
-                    };
-                    let Some(next_total) = total.checked_add(flow) else {
-                        return crate::types::Or(false);
-                    };
-                    total = next_total;
-                }
-                if total > capacity {
-                    return crate::types::Or(false);
-                }
-            }
-
-            for vertex in 0..self.num_vertices() {
-                if vertex == self.source || vertex == self.sink {
-                    continue;
-                }
-                if self.vertex_balance(config, vertex) != Some(0) {
-                    return crate::types::Or(false);
-                }
-            }
-
-            matches!(
-                self.vertex_balance(config, self.sink),
-                Some(balance) if balance >= i128::from(self.requirement)
-            )
-        })
-    }
-
-    fn variant() -> Vec<(&'static str, &'static str)> {
-        crate::variant_params![]
-    }
 }
 
 crate::declare_variants! {
-    default IntegralFlowBundles => "2^num_arcs",
+    default IntegralFlowBundles => "2^num_arcs" create IntegralFlowBundlesCreateSpec,
+}
+
+crate::register_brute_force! {
+    IntegralFlowBundles,
 }
 
 #[cfg(feature = "example-db")]
@@ -282,7 +402,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![1, 1, 1],
             1,
         )),
-        optimal_config: vec![1, 0, 1, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![1, 0, 1, 0, 0, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/integral_flow_homologous_arcs.rs b/src/models/graph/integral_flow_homologous_arcs.rs
index 0798cd834..0ea45a9e2 100644
--- a/src/models/graph/integral_flow_homologous_arcs.rs
+++ b/src/models/graph/integral_flow_homologous_arcs.rs
@@ -4,7 +4,7 @@
 //! that must carry equal flow, determine whether an integral flow meeting the
 //! required sink inflow exists.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -15,23 +15,10 @@ inventory::submit! {
         display_name: "Integral Flow with Homologous Arcs",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Integral flow feasibility with arc-pair equality constraints",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "DirectedGraph", description: "Directed graph G = (V, A)" },
-            FieldInfo { name: "capacities", type_name: "Vec<u64>", description: "Capacity c(a) for each arc" },
-            FieldInfo { name: "source", type_name: "usize", description: "Source vertex s" },
-            FieldInfo { name: "sink", type_name: "usize", description: "Sink vertex t" },
-            FieldInfo { name: "requirement", type_name: "u64", description: "Required net inflow R at the sink" },
-            FieldInfo { name: "homologous_pairs", type_name: "Vec<(usize, usize)>", description: "Arc-index pairs (a, a') with f(a) = f(a')" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "IntegralFlowHomologousArcs",
-        fields: &["num_vertices", "num_arcs"],
+        fields: IntegralFlowHomologousArcsCreateSpec::FIELDS,
     }
 }
 
@@ -44,20 +31,86 @@ inventory::submit! {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct IntegralFlowHomologousArcs {
     graph: DirectedGraph,
-    capacities: Vec<u64>,
+    capacities: Vec<i64>,
+    source: usize,
+    sink: usize,
+    requirement: i64,
+    homologous_pairs: Vec<(usize, usize)>,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct IntegralFlowHomologousArcsCreateSpec {
+    #[create(codec = "arc-list")]
+    arcs: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    capacities: Option<Vec<i64>>,
     source: usize,
     sink: usize,
-    requirement: u64,
+    requirement: i64,
+    #[create(codec = "equality-pair-list")]
     homologous_pairs: Vec<(usize, usize)>,
 }
 
+impl TryFrom<IntegralFlowHomologousArcsCreateSpec> for IntegralFlowHomologousArcs {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(
+        spec: IntegralFlowHomologousArcsCreateSpec,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        if spec.arcs.is_empty() {
+            return Err("arcs must be non-empty".into());
+        }
+        let inferred = spec
+            .arcs
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|v| v.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let count = spec.num_vertices.unwrap_or(inferred);
+        if count < inferred {
+            return Err("num_vertices is too small".into());
+        }
+        let capacities = spec.capacities.unwrap_or_else(|| vec![1; spec.arcs.len()]);
+        if capacities.len() != spec.arcs.len() {
+            return Err("capacities length must match arcs length".into());
+        }
+        if spec.source >= count || spec.sink >= count {
+            return Err("source and sink must be valid vertices".into());
+        }
+        for &(a, b) in &spec.homologous_pairs {
+            if a >= spec.arcs.len() || b >= spec.arcs.len() {
+                return Err("homologous pair arc index is out of range".into());
+            }
+        }
+        for &c in &capacities {
+            if usize::try_from(c)
+                .ok()
+                .and_then(|v| v.checked_add(1))
+                .is_none()
+            {
+                return Err("capacity is too large".into());
+            }
+        }
+        Ok(Self {
+            graph: DirectedGraph::new(count, spec.arcs),
+            capacities,
+            source: spec.source,
+            sink: spec.sink,
+            requirement: spec.requirement,
+            homologous_pairs: spec.homologous_pairs,
+        })
+    }
+}
+
 impl IntegralFlowHomologousArcs {
     pub fn new(
         graph: DirectedGraph,
-        capacities: Vec<u64>,
+        capacities: Vec<i64>,
         source: usize,
         sink: usize,
-        requirement: u64,
+        requirement: i64,
         homologous_pairs: Vec<(usize, usize)>,
     ) -> Self {
         let num_vertices = graph.num_vertices();
@@ -106,7 +159,7 @@ impl IntegralFlowHomologousArcs {
         &self.graph
     }
 
-    pub fn capacities(&self) -> &[u64] {
+    pub fn capacities(&self) -> &[i64] {
         &self.capacities
     }
 
@@ -118,7 +171,7 @@ impl IntegralFlowHomologousArcs {
         self.sink
     }
 
-    pub fn requirement(&self) -> u64 {
+    pub fn requirement(&self) -> i64 {
         self.requirement
     }
 
@@ -134,15 +187,69 @@ impl IntegralFlowHomologousArcs {
         self.graph.num_arcs()
     }
 
-    pub fn max_capacity(&self) -> u64 {
+    pub fn max_capacity(&self) -> i64 {
         self.capacities.iter().copied().max().unwrap_or(0)
     }
 
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
+    pub fn is_valid_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(self.evaluate_solution(config)?.0)
+    }
+
+    fn evaluate_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_arcs() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "flow vector length does not match the graph arcs".into(),
+            ));
+        }
+
+        for &(a, b) in &self.homologous_pairs {
+            if config[a] != config[b] {
+                return Ok(crate::types::Or(false));
+            }
+        }
+
+        let mut balances = vec![0_i64; self.num_vertices()];
+        for (arc_index, ((u, v), &capacity)) in self
+            .graph
+            .arcs()
+            .into_iter()
+            .zip(self.capacities.iter())
+            .enumerate()
+        {
+            let Ok(flow) = i64::try_from(config[arc_index]) else {
+                return Ok(crate::types::Or(false));
+            };
+            if flow > capacity {
+                return Ok(crate::types::Or(false));
+            }
+            balances[u] = balances[u].checked_sub(flow).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "subtracting outgoing homologous-arc flow".into(),
+                )
+            })?;
+            balances[v] = balances[v].checked_add(flow).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "adding incoming homologous-arc flow".into(),
+                )
+            })?;
+        }
+
+        for (vertex, &balance) in balances.iter().enumerate() {
+            if vertex != self.source && vertex != self.sink && balance != 0 {
+                return Ok(crate::types::Or(false));
+            }
+        }
+
+        Ok(crate::types::Or(balances[self.sink] >= self.requirement))
     }
 
-    fn domain_size(capacity: u64) -> usize {
+    fn domain_size(capacity: i64) -> usize {
         usize::try_from(capacity)
             .ok()
             .and_then(|value| value.checked_add(1))
@@ -152,63 +259,42 @@ impl IntegralFlowHomologousArcs {
 
 impl Problem for IntegralFlowHomologousArcs {
     const NAME: &'static str = "IntegralFlowHomologousArcs";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("max_capacity", max_capacity),
+        ("num_arcs", num_arcs),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        self.evaluate_solution(config)
+    }
+}
+
+impl crate::solvers::BruteForceProblem for IntegralFlowHomologousArcs {
+    fn dimensions(&self) -> Vec<usize> {
         self.capacities
             .iter()
             .map(|&capacity| Self::domain_size(capacity))
             .collect()
     }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_arcs() {
-                return crate::types::Or(false);
-            }
-
-            for &(a, b) in &self.homologous_pairs {
-                if config[a] != config[b] {
-                    return crate::types::Or(false);
-                }
-            }
-
-            let mut balances = vec![0_i128; self.num_vertices()];
-            for (arc_index, ((u, v), &capacity)) in self
-                .graph
-                .arcs()
-                .into_iter()
-                .zip(self.capacities.iter())
-                .enumerate()
-            {
-                let Ok(flow) = u64::try_from(config[arc_index]) else {
-                    return crate::types::Or(false);
-                };
-                if flow > capacity {
-                    return crate::types::Or(false);
-                }
-                let flow = i128::from(flow);
-                balances[u] -= flow;
-                balances[v] += flow;
-            }
-
-            for (vertex, &balance) in balances.iter().enumerate() {
-                if vertex != self.source && vertex != self.sink && balance != 0 {
-                    return crate::types::Or(false);
-                }
-            }
-
-            balances[self.sink] >= i128::from(self.requirement)
-        })
-    }
 }
 
 crate::declare_variants! {
-    default IntegralFlowHomologousArcs => "(max_capacity + 1)^num_arcs",
+    default IntegralFlowHomologousArcs => "(max_capacity + 1)^num_arcs" create IntegralFlowHomologousArcsCreateSpec,
+}
+
+crate::register_brute_force! {
+    IntegralFlowHomologousArcs,
 }
 
 #[cfg(feature = "example-db")]
@@ -235,7 +321,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             2,
             vec![(2, 5), (4, 3)],
         )),
-        optimal_config: vec![1, 1, 1, 0, 0, 1, 1, 1],
+        optimal_config: serde_json::json!(vec![1, 1, 1, 0, 0, 1, 1, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/integral_flow_with_multipliers.rs b/src/models/graph/integral_flow_with_multipliers.rs
index d620d4b24..d5730c110 100644
--- a/src/models/graph/integral_flow_with_multipliers.rs
+++ b/src/models/graph/integral_flow_with_multipliers.rs
@@ -4,7 +4,7 @@
 //! non-terminals, and a sink demand, determine whether there exists an
 //! integral flow satisfying multiplier-scaled conservation.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -15,23 +15,10 @@ inventory::submit! {
         display_name: "Integral Flow With Multipliers",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Integral flow feasibility on a directed graph with multiplier-scaled conservation at non-terminal vertices",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "DirectedGraph", description: "Directed graph G = (V, A)" },
-            FieldInfo { name: "source", type_name: "usize", description: "Source vertex s" },
-            FieldInfo { name: "sink", type_name: "usize", description: "Sink vertex t" },
-            FieldInfo { name: "multipliers", type_name: "Vec<u64>", description: "Vertex multipliers h(v) in vertex order; source/sink entries are ignored" },
-            FieldInfo { name: "capacities", type_name: "Vec<u64>", description: "Arc capacities c(a) in graph arc order" },
-            FieldInfo { name: "requirement", type_name: "u64", description: "Required net inflow R at the sink" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "IntegralFlowWithMultipliers",
-        fields: &["num_vertices", "num_arcs", "max_capacity", "requirement"],
+        fields: IntegralFlowWithMultipliersCreateSpec::FIELDS,
     }
 }
 
@@ -40,9 +27,80 @@ pub struct IntegralFlowWithMultipliers {
     graph: DirectedGraph,
     source: usize,
     sink: usize,
-    multipliers: Vec<u64>,
-    capacities: Vec<u64>,
-    requirement: u64,
+    multipliers: Vec<i64>,
+    capacities: Vec<i64>,
+    requirement: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct IntegralFlowWithMultipliersCreateSpec {
+    #[create(codec = "arc-list")]
+    arcs: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    capacities: Vec<i64>,
+    source: usize,
+    sink: usize,
+    #[create(codec = "comma-separated")]
+    multipliers: Vec<i64>,
+    requirement: i64,
+}
+
+impl TryFrom<IntegralFlowWithMultipliersCreateSpec> for IntegralFlowWithMultipliers {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(
+        spec: IntegralFlowWithMultipliersCreateSpec,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        if spec.arcs.is_empty() {
+            return Err("arcs must be non-empty".into());
+        }
+        let inferred = spec
+            .arcs
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|v| v.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let count = spec.num_vertices.unwrap_or(inferred);
+        if count < inferred {
+            return Err("num_vertices is too small".into());
+        }
+        if spec.capacities.len() != spec.arcs.len() {
+            return Err("capacities length must match arcs length".into());
+        }
+        if spec.multipliers.len() != count {
+            return Err("multipliers length must match num_vertices".into());
+        }
+        if spec.source >= count || spec.sink >= count {
+            return Err("source and sink must be valid vertices".into());
+        }
+        if spec.source == spec.sink {
+            return Err("source and sink must be distinct".into());
+        }
+        for (v, &m) in spec.multipliers.iter().enumerate() {
+            if v != spec.source && v != spec.sink && m == 0 {
+                return Err("non-terminal multipliers must be positive".into());
+            }
+        }
+        for &c in &spec.capacities {
+            if usize::try_from(c)
+                .ok()
+                .and_then(|v| v.checked_add(1))
+                .is_none()
+            {
+                return Err("capacity is too large".into());
+            }
+        }
+        Ok(Self {
+            graph: DirectedGraph::new(count, spec.arcs),
+            source: spec.source,
+            sink: spec.sink,
+            multipliers: spec.multipliers,
+            capacities: spec.capacities,
+            requirement: spec.requirement,
+        })
+    }
 }
 
 impl IntegralFlowWithMultipliers {
@@ -50,9 +108,9 @@ impl IntegralFlowWithMultipliers {
         graph: DirectedGraph,
         source: usize,
         sink: usize,
-        multipliers: Vec<u64>,
-        capacities: Vec<u64>,
-        requirement: u64,
+        multipliers: Vec<i64>,
+        capacities: Vec<i64>,
+        requirement: i64,
     ) -> Self {
         assert_eq!(
             capacities.len(),
@@ -114,15 +172,15 @@ impl IntegralFlowWithMultipliers {
         self.sink
     }
 
-    pub fn multipliers(&self) -> &[u64] {
+    pub fn multipliers(&self) -> &[i64] {
         &self.multipliers
     }
 
-    pub fn capacities(&self) -> &[u64] {
+    pub fn capacities(&self) -> &[i64] {
         &self.capacities
     }
 
-    pub fn requirement(&self) -> u64 {
+    pub fn requirement(&self) -> i64 {
         self.requirement
     }
 
@@ -134,25 +192,25 @@ impl IntegralFlowWithMultipliers {
         self.graph.num_arcs()
     }
 
-    pub fn max_capacity(&self) -> u64 {
+    pub fn max_capacity(&self) -> i64 {
         self.capacities.iter().copied().max().unwrap_or(0)
     }
 
-    fn domain_size(capacity: u64) -> usize {
+    fn domain_size(capacity: i64) -> usize {
         usize::try_from(capacity)
             .ok()
             .and_then(|value| value.checked_add(1))
             .expect("capacity already validated to fit into usize")
     }
 
-    pub fn is_feasible(&self, config: &[usize]) -> bool {
+    pub fn is_feasible(&self, config: &[usize]) -> Result<bool, crate::traits::EvaluationError> {
         if config.len() != self.num_arcs() {
-            return false;
+            return Ok(false);
         }
 
         let num_vertices = self.num_vertices();
-        let mut inflow = vec![0_i128; num_vertices];
-        let mut outflow = vec![0_i128; num_vertices];
+        let mut inflow = vec![0_i64; num_vertices];
+        let mut outflow = vec![0_i64; num_vertices];
 
         for (arc_index, ((u, v), &capacity)) in self
             .graph
@@ -162,50 +220,75 @@ impl IntegralFlowWithMultipliers {
             .enumerate()
         {
             let Some(flow_usize) = config.get(arc_index).copied() else {
-                return false;
+                return Ok(false);
             };
-            let Ok(flow_u64) = u64::try_from(flow_usize) else {
-                return false;
+            let Ok(flow_u64) = i64::try_from(flow_usize) else {
+                return Ok(false);
             };
             if flow_u64 > capacity {
-                return false;
+                return Ok(false);
             }
-            let flow = i128::from(flow_u64);
-            outflow[u] += flow;
-            inflow[v] += flow;
+            outflow[u] = outflow[u].checked_add(flow_u64).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing outgoing multiplied flow".into(),
+                )
+            })?;
+            inflow[v] = inflow[v].checked_add(flow_u64).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing incoming multiplied flow".into(),
+                )
+            })?;
         }
 
         for vertex in 0..num_vertices {
             if vertex == self.source || vertex == self.sink {
                 continue;
             }
-            let multiplier = i128::from(self.multipliers[vertex]);
-            let Some(expected_outflow) = inflow[vertex].checked_mul(multiplier) else {
-                return false;
-            };
+            let expected_outflow = inflow[vertex]
+                .checked_mul(self.multipliers[vertex])
+                .ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "multiplying incoming flow by vertex multiplier".into(),
+                    )
+                })?;
             if expected_outflow != outflow[vertex] {
-                return false;
+                return Ok(false);
             }
         }
 
-        let sink_net_flow = inflow[self.sink] - outflow[self.sink];
-        sink_net_flow >= i128::from(self.requirement)
+        let sink_net_flow = inflow[self.sink]
+            .checked_sub(outflow[self.sink])
+            .ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "computing net flow into sink".into(),
+                )
+            })?;
+        Ok(sink_net_flow >= self.requirement)
     }
 }
 
 impl Problem for IntegralFlowWithMultipliers {
     const NAME: &'static str = "IntegralFlowWithMultipliers";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        self.capacities
-            .iter()
-            .map(|&capacity| Self::domain_size(capacity))
-            .collect()
-    }
+    crate::problem_parameters![
+        ("max_capacity", max_capacity),
+        ("num_arcs", num_arcs),
+        ("num_vertices", num_vertices),
+        ("requirement", requirement),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_feasible(config))
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_arcs() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "flow vector length does not match the graph arcs".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_feasible(config)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -213,8 +296,21 @@ impl Problem for IntegralFlowWithMultipliers {
     }
 }
 
+impl crate::solvers::BruteForceProblem for IntegralFlowWithMultipliers {
+    fn dimensions(&self) -> Vec<usize> {
+        self.capacities
+            .iter()
+            .map(|&capacity| Self::domain_size(capacity))
+            .collect()
+    }
+}
+
 crate::declare_variants! {
-    default IntegralFlowWithMultipliers => "(max_capacity + 1)^num_arcs",
+    default IntegralFlowWithMultipliers => "(max_capacity + 1)^num_arcs" create IntegralFlowWithMultipliersCreateSpec,
+}
+
+crate::register_brute_force! {
+    IntegralFlowWithMultipliers,
 }
 
 #[cfg(feature = "example-db")]
@@ -245,7 +341,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![1, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 4],
             12,
         )),
-        optimal_config: vec![1, 0, 1, 0, 1, 0, 2, 0, 4, 0, 6, 0],
+        optimal_config: serde_json::json!(vec![1, 0, 1, 0, 1, 0, 2, 0, 4, 0, 6, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/isomorphic_spanning_tree.rs b/src/models/graph/isomorphic_spanning_tree.rs
index b624280e7..ad2877684 100644
--- a/src/models/graph/isomorphic_spanning_tree.rs
+++ b/src/models/graph/isomorphic_spanning_tree.rs
@@ -18,6 +18,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Does graph G contain a spanning tree isomorphic to tree T?",
         fields: &[
@@ -41,7 +42,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::IsomorphicSpanningTree;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Host graph: triangle 0-1-2-0
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
@@ -50,16 +51,33 @@ inventory::submit! {
 /// let problem = IsomorphicSpanningTree::new(graph, tree);
 ///
 /// let solver = BruteForce::new();
-/// let sol = solver.find_witness(&problem);
+/// let sol = solver.solve(&problem).unwrap();
 /// assert!(sol.is_some());
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(bound(deserialize = "G: serde::Deserialize<'de>"))]
+#[derive(Debug, Clone, Serialize)]
 pub struct IsomorphicSpanningTree<G> {
     graph: G,
     tree: SimpleGraph,
 }
 
+impl<'de, G> Deserialize<'de> for IsomorphicSpanningTree<G>
+where
+    G: Graph + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Helper<G> {
+            graph: G,
+            tree: SimpleGraph,
+        }
+        let helper = Helper::<G>::deserialize(deserializer)?;
+        Self::try_new(helper.graph, helper.tree).map_err(serde::de::Error::custom)
+    }
+}
+
 impl<G: Graph> IsomorphicSpanningTree<G> {
     /// Create a new IsomorphicSpanningTree problem.
     ///
@@ -68,19 +86,21 @@ impl<G: Graph> IsomorphicSpanningTree<G> {
     /// Panics if |V(G)| != |V(T)| or if T is not a tree (not connected or
     /// wrong number of edges).
     pub fn new(graph: G, tree: SimpleGraph) -> Self {
+        Self::try_new(graph, tree).unwrap_or_else(|error| panic!("{error}"))
+    }
+
+    fn try_new(graph: G, tree: SimpleGraph) -> Result<Self, &'static str> {
         let n = graph.num_vertices();
-        assert_eq!(
-            n,
-            tree.num_vertices(),
-            "graph and tree must have the same number of vertices"
-        );
-        assert_eq!(
-            tree.num_edges(),
-            n.saturating_sub(1),
-            "tree must have exactly n-1 edges"
-        );
-        assert!(is_connected(&tree), "tree must be connected");
-        Self { graph, tree }
+        if n != tree.num_vertices() {
+            return Err("graph and tree must have the same number of vertices");
+        }
+        if tree.num_edges() != n.saturating_sub(1) {
+            return Err("tree must have exactly n-1 edges");
+        }
+        if !is_connected(&tree) {
+            return Err("tree must be connected");
+        }
+        Ok(Self { graph, tree })
     }
 
     /// Get a reference to the host graph.
@@ -114,22 +134,46 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "IsomorphicSpanningTree";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.graph.num_vertices(); self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        let n = self.graph.num_vertices();
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex mapping length does not match the graph".into(),
+            ));
+        }
+        if config.iter().any(|&vertex| vertex >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex mapping contains an out-of-range vertex".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or(is_valid_isomorphic_spanning_tree(
+                &self.graph,
+                &self.tree,
+                config,
+            ))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(is_valid_isomorphic_spanning_tree(
-            &self.graph,
-            &self.tree,
-            config,
-        ))
+impl<G> crate::solvers::BruteForceProblem for IsomorphicSpanningTree<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.graph.num_vertices(); self.graph.num_vertices()]
     }
 }
 
@@ -189,7 +233,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
             SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]),
         )),
-        optimal_config: vec![0, 1, 2, 3],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 3]),
         optimal_value: serde_json::json!(true),
     }]
 }
@@ -198,6 +242,10 @@ crate::declare_variants! {
     default IsomorphicSpanningTree<SimpleGraph> => "2^num_vertices",
 }
 
+crate::register_brute_force! {
+    IsomorphicSpanningTree<SimpleGraph>,
+}
+
 #[cfg(test)]
 #[path = "../../unit_tests/models/graph/isomorphic_spanning_tree.rs"]
 mod tests;
diff --git a/src/models/graph/kclique.rs b/src/models/graph/kclique.rs
index 94fa7e788..07bca75e7 100644
--- a/src/models/graph/kclique.rs
+++ b/src/models/graph/kclique.rs
@@ -3,7 +3,7 @@
 //! KClique is the decision version of Clique: determine whether a graph
 //! contains a clique of size at least `k`.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -14,12 +14,10 @@ inventory::submit! {
         display_name: "k-Clique",
         aliases: &["Clique"],
         dimensions: &[VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"])],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Determine whether a graph contains a clique of size at least k",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "k", type_name: "usize", description: "Minimum clique size threshold" },
-        ],
+        fields: KCliqueCreateSpec::FIELDS,
     }
 }
 
@@ -34,6 +32,50 @@ pub struct KClique<G> {
     k: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct KCliqueCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    k: usize,
+}
+
+impl TryFrom<KCliqueCreateSpec> for KClique<SimpleGraph> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: KCliqueCreateSpec) -> Result<Self, Self::Error> {
+        if spec.graph.is_empty() && spec.num_vertices.is_none() {
+            return Err("num_vertices is required for an empty graph".into());
+        }
+        for &(u, v) in &spec.graph {
+            if u == v {
+                return Err(format!("self-loop {u}-{v} is not allowed").into());
+            }
+        }
+        let inferred = spec
+            .graph
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|v| v.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let count = spec.num_vertices.unwrap_or(inferred);
+        if count < inferred {
+            return Err("num_vertices is too small for graph endpoints".into());
+        }
+        if spec.k == 0 {
+            return Err("k must be positive".into());
+        }
+        if spec.k > count {
+            return Err("k must be <= graph num_vertices".into());
+        }
+        Ok(Self {
+            graph: SimpleGraph::new(count, spec.graph),
+            k: spec.k,
+        })
+    }
+}
+
 impl<G: Graph> KClique<G> {
     /// Create a new k-Clique problem instance.
     pub fn new(graph: G, k: usize) -> Self {
@@ -63,21 +105,21 @@ impl<G: Graph> KClique<G> {
     }
 
     /// Check whether a configuration is a valid witness.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_kclique_config(&self.graph, config, self.k)
     }
 
     /// Build a binary selection config from the listed vertices.
-    pub fn config_from_vertices(num_vertices: usize, selected_vertices: &[usize]) -> Vec<usize> {
-        let mut config = vec![0; num_vertices];
+    pub fn config_from_vertices(num_vertices: usize, selected_vertices: &[usize]) -> Vec<bool> {
+        let mut config = vec![false; num_vertices];
         for &vertex in selected_vertices {
-            config[vertex] = 1;
+            config[vertex] = true;
         }
         config
     }
 
     /// Convenience wrapper around [`Self::config_from_vertices`] using `self.num_vertices()`.
-    pub fn config_from_selected_vertices(&self, selected_vertices: &[usize]) -> Vec<usize> {
+    pub fn config_from_selected_vertices(&self, selected_vertices: &[usize]) -> Vec<bool> {
         Self::config_from_vertices(self.num_vertices(), selected_vertices)
     }
 }
@@ -87,39 +129,55 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "KClique";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("k", k),
+        ("num_edges", num_edges),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex-selection length does not match the graph".into(),
+            ));
+        }
+        Ok(crate::types::Or(is_kclique_config(
+            &self.graph,
+            config,
+            self.k,
+        )))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(is_kclique_config(&self.graph, config, self.k))
+impl<G> crate::solvers::BruteForceProblem for KClique<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
-fn is_kclique_config<G: Graph>(graph: &G, config: &[usize], k: usize) -> bool {
+fn is_kclique_config<G: Graph>(graph: &G, config: &[bool], k: usize) -> bool {
     if config.len() != graph.num_vertices() {
         return false;
     }
 
-    let selected: Vec<usize> = match config
+    let selected: Vec<usize> = config
         .iter()
         .enumerate()
-        .map(|(index, &value)| match value {
-            0 => Ok(None),
-            1 => Ok(Some(index)),
-            _ => Err(()),
-        })
-        .collect::<Result<Vec<_>, _>>()
-    {
-        Ok(values) => values.into_iter().flatten().collect(),
-        Err(()) => return false,
-    };
+        .filter_map(|(index, &selected)| selected.then_some(index))
+        .collect();
 
     if selected.len() < k {
         return false;
@@ -135,8 +193,27 @@ fn is_kclique_config<G: Graph>(graph: &G, config: &[usize], k: usize) -> bool {
     true
 }
 
+crate::impl_random_generate!(
+    KClique<SimpleGraph>,
+    crate::random::CliqueRandomSpec,
+    |spec| {
+        if spec.k == 0 || spec.k > spec.num_vertices {
+            return Err(format!(
+                "k must be between 1 and num_vertices ({})",
+                spec.num_vertices
+            )
+            .into());
+        }
+        Ok(KClique::new(spec.graph()?, spec.k))
+    }
+);
+
 crate::declare_variants! {
-    default KClique<SimpleGraph> => "1.1996^num_vertices",
+    default KClique<SimpleGraph> => "1.1996^num_vertices" create KCliqueCreateSpec random,
+}
+
+crate::register_brute_force! {
+    KClique<SimpleGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -147,7 +224,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]),
             3,
         )),
-        optimal_config: vec![0, 0, 1, 1, 1],
+        optimal_config: serde_json::json!(vec![false, false, true, true, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/kcoloring.rs b/src/models/graph/kcoloring.rs
index 9e810dfc9..9f1662123 100644
--- a/src/models/graph/kcoloring.rs
+++ b/src/models/graph/kcoloring.rs
@@ -3,10 +3,10 @@
 //! The K-Coloring problem asks whether a graph can be colored with K colors
 //! such that no two adjacent vertices have the same color.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
-use crate::variant::{KValue, VariantParam, K2, K3, K4, K5, KN};
+use crate::variant::{KValue, VariantParam, K1, K2, K3, K4, K5, KN};
 use serde::{Deserialize, Serialize};
 
 inventory::submit! {
@@ -16,13 +16,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("k", "KN", &["KN", "K2", "K3", "K4", "K5"]),
+            VariantDimension::new("k", "KN", &["KN", "K1", "K2", "K3", "K4", "K5"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find valid k-coloring of a graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-        ],
+        fields: RuntimeKColoringCreateSpec::FIELDS,
     }
 }
 
@@ -42,18 +41,18 @@ inventory::submit! {
 /// use problemreductions::models::graph::KColoring;
 /// use problemreductions::topology::SimpleGraph;
 /// use problemreductions::variant::K3;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Triangle graph needs at least 3 colors
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
 /// let problem = KColoring::<K3, _>::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Verify all solutions are valid colorings
 /// for sol in &solutions {
-///     assert!(problem.evaluate(sol));
+///     assert!(problem.evaluate(sol).unwrap());
 /// }
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -62,12 +61,106 @@ pub struct KColoring<K: KValue, G> {
     /// The underlying graph.
     graph: G,
     /// Runtime number of colors. Always set; for compile-time K types it equals K::K.
-    #[serde(default = "default_num_colors::<K>")]
+    #[serde(
+        default = "default_num_colors::<K>",
+        deserialize_with = "deserialize_num_colors::<K, _>"
+    )]
     num_colors: usize,
     #[serde(skip)]
     _phantom: std::marker::PhantomData<K>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct FixedKColoringCreateSpec {
+    /// Undirected graph edges.
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    /// Vertex count, needed to preserve isolated vertices.
+    num_vertices: Option<usize>,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct RuntimeKColoringCreateSpec {
+    /// Undirected graph edges.
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    /// Vertex count, needed to preserve isolated vertices.
+    num_vertices: Option<usize>,
+    /// Runtime color count.
+    k: usize,
+}
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let count = num_vertices.unwrap_or(inferred);
+    if count < inferred {
+        return Err(format!(
+            "num_vertices {count} is too small for graph endpoints; need at least {inferred}"
+        )
+        .into());
+    }
+    Ok(SimpleGraph::new(count, edges))
+}
+
+impl<K: KValue> TryFrom<FixedKColoringCreateSpec> for KColoring<K, SimpleGraph> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: FixedKColoringCreateSpec) -> Result<Self, Self::Error> {
+        let num_colors = K::K.ok_or("runtime KColoring requires k")?;
+        Ok(Self {
+            graph: simple_graph_from_create(spec.graph, spec.num_vertices)?,
+            num_colors,
+            _phantom: std::marker::PhantomData,
+        })
+    }
+}
+
+impl TryFrom<RuntimeKColoringCreateSpec> for KColoring<KN, SimpleGraph> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: RuntimeKColoringCreateSpec) -> Result<Self, Self::Error> {
+        if spec.k == 0 {
+            return Err("k must be positive".to_string().into());
+        }
+        Ok(Self::with_k(
+            simple_graph_from_create(spec.graph, spec.num_vertices)?,
+            spec.k,
+        ))
+    }
+}
+
+// Fixed-K construction and persisted instances must describe the same problem.
+fn deserialize_num_colors<'de, K: KValue, D: serde::Deserializer<'de>>(
+    deserializer: D,
+) -> Result<usize, D::Error> {
+    let num_colors = usize::deserialize(deserializer)?;
+    match K::K {
+        Some(fixed) if num_colors != fixed => Err(serde::de::Error::custom(format!(
+            "fixed K requires {fixed} colors, got {num_colors}"
+        ))),
+        _ => Ok(num_colors),
+    }
+}
+
 fn default_num_colors<K: KValue>() -> usize {
     K::K.unwrap_or(0)
 }
@@ -145,18 +238,43 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "KColoring";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_vertices", num_vertices),
+        ("num_colors", num_colors),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![K, G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_colors; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "color assignment length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&color| color >= self.num_colors) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "color assignment contains an out-of-range color".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_valid_coloring(config)))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_valid_coloring(config))
+impl<K: KValue, G> crate::solvers::BruteForceProblem for KColoring<K, G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_colors; self.graph.num_vertices()]
     }
 }
 
@@ -195,18 +313,52 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             5,
             vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)],
         ))),
-        optimal_config: vec![0, 1, 1, 0, 2],
+        optimal_config: serde_json::json!(vec![0, 1, 1, 0, 2]),
         optimal_value: serde_json::json!(true),
     }]
 }
 
+crate::impl_random_generate!(KColoring<KN, SimpleGraph>, crate::random::ColoringRandomSpec, |spec| {
+    let k = spec.k.unwrap_or(3);
+    if k == 0 {
+        return Err("k must be positive".to_string().into());
+    }
+    Ok(KColoring::with_k(spec.graph()?, k))
+});
+crate::impl_random_generate!(KColoring<K2, SimpleGraph>, crate::random::ColoringRandomSpec, |spec| {
+    if spec.k.is_some_and(|k| k != 2) { return Err("k must match the selected K2 variant".to_string().into()); }
+    Ok(KColoring::new(spec.graph()?))
+});
+crate::impl_random_generate!(KColoring<K3, SimpleGraph>, crate::random::ColoringRandomSpec, |spec| {
+    if spec.k.is_some_and(|k| k != 3) { return Err("k must match the selected K3 variant".to_string().into()); }
+    Ok(KColoring::new(spec.graph()?))
+});
+crate::impl_random_generate!(KColoring<K4, SimpleGraph>, crate::random::ColoringRandomSpec, |spec| {
+    if spec.k.is_some_and(|k| k != 4) { return Err("k must match the selected K4 variant".to_string().into()); }
+    Ok(KColoring::new(spec.graph()?))
+});
+crate::impl_random_generate!(KColoring<K5, SimpleGraph>, crate::random::ColoringRandomSpec, |spec| {
+    if spec.k.is_some_and(|k| k != 5) { return Err("k must match the selected K5 variant".to_string().into()); }
+    Ok(KColoring::new(spec.graph()?))
+});
+
 crate::declare_variants! {
-    default KColoring<KN, SimpleGraph> => "2^num_vertices",
-    KColoring<K2, SimpleGraph> => "num_vertices + num_edges",
-    KColoring<K3, SimpleGraph> => "1.3289^num_vertices",
-    KColoring<K4, SimpleGraph> => "1.7159^num_vertices",
+    default KColoring<KN, SimpleGraph> => "2^num_vertices" create RuntimeKColoringCreateSpec random,
+    KColoring<K1, SimpleGraph> => "num_vertices + num_edges" create FixedKColoringCreateSpec,
+    KColoring<K2, SimpleGraph> => "num_vertices + num_edges" create FixedKColoringCreateSpec random,
+    KColoring<K3, SimpleGraph> => "1.3289^num_vertices" create FixedKColoringCreateSpec random,
+    KColoring<K4, SimpleGraph> => "1.7159^num_vertices" create FixedKColoringCreateSpec random,
     // Best known: O*((2-ε)^n) for some ε > 0 (Zamir 2021), concrete ε unknown
-    KColoring<K5, SimpleGraph> => "2^num_vertices",
+    KColoring<K5, SimpleGraph> => "2^num_vertices" create FixedKColoringCreateSpec random,
+}
+
+crate::register_brute_force! {
+    KColoring<KN, SimpleGraph>,
+    KColoring<K1, SimpleGraph>,
+    KColoring<K2, SimpleGraph>,
+    KColoring<K3, SimpleGraph>,
+    KColoring<K4, SimpleGraph>,
+    KColoring<K5, SimpleGraph>,
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/kernel.rs b/src/models/graph/kernel.rs
index 72b3e1b52..359c5ad42 100644
--- a/src/models/graph/kernel.rs
+++ b/src/models/graph/kernel.rs
@@ -5,7 +5,7 @@
 //! selected vertices) and absorbing (every unselected vertex has an arc to
 //! some selected vertex).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -15,9 +15,8 @@ inventory::submit! {
         name: "Kernel",
         display_name: "Kernel",
         aliases: &[],
-        dimensions: &[
-            VariantDimension::new("graph", "DirectedGraph", &["DirectedGraph"]),
-        ],
+        dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Does the directed graph contain a kernel (independent and absorbing vertex subset)?",
         fields: &[
@@ -44,14 +43,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::Kernel;
 /// use problemreductions::topology::DirectedGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let graph = DirectedGraph::new(5, vec![
 ///     (0,1),(0,2),(1,3),(2,3),(3,4),(4,0),(4,1),
 /// ]);
 /// let problem = Kernel::new(graph);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -83,63 +82,79 @@ impl Kernel {
 
 impl Problem for Kernel {
     const NAME: &'static str = "Kernel";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_arcs", num_arcs), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        let n = self.graph.num_vertices();
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex-selection length does not match the graph".into(),
+            ));
+        }
+        Ok({
+            let n = self.graph.num_vertices();
 
-        // Collect selected vertices
-        let selected: Vec<bool> = config.iter().map(|&c| c == 1).collect();
+            // Collect selected vertices
+            let selected = config;
 
-        // Independence: no arc between any two selected vertices
-        for u in 0..n {
-            if !selected[u] {
-                continue;
-            }
-            // Check that no successor of u is also selected
-            for &v in &self.graph.successors(u) {
-                if selected[v] {
-                    return crate::types::Or(false);
+            // Independence: no arc between any two selected vertices
+            for u in 0..n {
+                if !selected[u] {
+                    continue;
+                }
+                // Check that no successor of u is also selected
+                for &v in &self.graph.successors(u) {
+                    if selected[v] {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
             }
-        }
 
-        // Absorption: every unselected vertex must have an arc to some selected vertex
-        for u in 0..n {
-            if selected[u] {
-                continue;
-            }
-            let has_arc_to_selected = self.graph.successors(u).iter().any(|&v| selected[v]);
-            if !has_arc_to_selected {
-                return crate::types::Or(false);
+            // Absorption: every unselected vertex must have an arc to some selected vertex
+            for u in 0..n {
+                if selected[u] {
+                    continue;
+                }
+                let has_arc_to_selected = self.graph.successors(u).iter().any(|&v| selected[v]);
+                if !has_arc_to_selected {
+                    return Ok(crate::types::Or(false));
+                }
             }
-        }
 
-        crate::types::Or(true)
+            crate::types::Or(true)
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for Kernel {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 5 vertices, arcs: (0,1),(0,2),(1,3),(2,3),(3,4),(4,0),(4,1)
-    // Kernel: V' = {0, 3} → config [1,0,0,1,0]
+    // Kernel: V' = {0, 3}.
     let graph = DirectedGraph::new(
         5,
         vec![(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (4, 0), (4, 1)],
     );
-    let optimal_config = vec![1, 0, 0, 1, 0];
+    let optimal_config = vec![true, false, false, true, false];
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "kernel",
         instance: Box::new(Kernel::new(graph)),
-        optimal_config,
+        optimal_config: serde_json::to_value(optimal_config)
+            .expect("solution serialization must succeed"),
         optimal_value: serde_json::json!(true),
     }]
 }
@@ -148,6 +163,10 @@ crate::declare_variants! {
     default Kernel => "2^num_vertices",
 }
 
+crate::register_brute_force! {
+    Kernel decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(test)]
 #[path = "../../unit_tests/models/graph/kernel.rs"]
 mod tests;
diff --git a/src/models/graph/kth_best_spanning_tree.rs b/src/models/graph/kth_best_spanning_tree.rs
index f26c26fcb..e841da212 100644
--- a/src/models/graph/kth_best_spanning_tree.rs
+++ b/src/models/graph/kth_best_spanning_tree.rs
@@ -3,7 +3,7 @@
 //! Given a weighted graph, determine whether it contains `k` distinct spanning
 //! trees whose total weights are all at most a prescribed bound.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::WeightElement;
@@ -16,15 +16,11 @@ inventory::submit! {
         name: "KthBestSpanningTree",
         display_name: "Kth Best Spanning Tree",
         aliases: &[],
-        dimensions: &[VariantDimension::new("weight", "i32", &["i32"])],
+        dimensions: &[VariantDimension::new("weight", "i64", &["i64"])],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Do there exist k distinct spanning trees with total weight at most B?",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "SimpleGraph", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Edge weights w(e) for each edge in E" },
-            FieldInfo { name: "k", type_name: "usize", description: "Number of distinct spanning trees required" },
-            FieldInfo { name: "bound", type_name: "W::Sum", description: "Upper bound B on each spanning tree weight" },
-        ],
+        fields: KthBestSpanningTreeCreateSpec::FIELDS,
     }
 }
 
@@ -46,6 +42,68 @@ pub struct KthBestSpanningTree<W: WeightElement> {
     bound: W::Sum,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct KthBestSpanningTreeCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    edge_weights: Option<Vec<i64>>,
+    k: usize,
+    bound: i64,
+}
+
+impl TryFrom<KthBestSpanningTreeCreateSpec> for KthBestSpanningTree<i64> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: KthBestSpanningTreeCreateSpec) -> Result<Self, Self::Error> {
+        let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+        let weights = spec
+            .edge_weights
+            .unwrap_or_else(|| vec![1; graph.num_edges()]);
+        if weights.len() != graph.num_edges() {
+            return Err(format!(
+                "edge_weights has length {}, expected {}",
+                weights.len(),
+                graph.num_edges()
+            )
+            .into());
+        }
+        if spec.k == 0 {
+            return Err("k must be positive".to_string().into());
+        }
+        Ok(Self::new(graph, weights, spec.k, spec.bound))
+    }
+}
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(format!("num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}").into());
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
+}
+
 impl<W: WeightElement> KthBestSpanningTree<W> {
     /// Create a new KthBestSpanningTree instance.
     ///
@@ -105,19 +163,43 @@ impl<W: WeightElement> KthBestSpanningTree<W> {
     }
 
     /// Check whether a configuration satisfies the problem.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate_config(config)
+    pub fn is_valid_solution(
+        &self,
+        config: &[Vec<bool>],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if config.len() != self.k
+            || config
+                .iter()
+                .any(|tree| tree.len() != self.graph.num_edges())
+        {
+            return Ok(false);
+        }
+
+        let edges = self.graph.edges();
+        if !self.blocks_are_pairwise_distinct(config) {
+            return Ok(false);
+        }
+        for tree in config {
+            if !self.block_is_valid_tree(tree, &edges)? {
+                return Ok(false);
+            }
+        }
+        Ok(true)
     }
 
-    fn block_is_valid_tree(&self, block: &[usize], edges: &[(usize, usize)]) -> bool {
-        if block.len() != edges.len() || block.iter().any(|&value| value > 1) {
-            return false;
+    fn block_is_valid_tree(
+        &self,
+        block: &[bool],
+        edges: &[(usize, usize)],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if block.len() != edges.len() {
+            return Ok(false);
         }
 
         let num_vertices = self.graph.num_vertices();
-        let selected_count = block.iter().filter(|&&value| value == 1).count();
+        let selected_count = block.iter().filter(|&&selected| selected).count();
         if selected_count != num_vertices.saturating_sub(1) {
-            return false;
+            return Ok(false);
         }
 
         let mut total_weight = W::Sum::zero();
@@ -125,10 +207,14 @@ impl<W: WeightElement> KthBestSpanningTree<W> {
         let mut start = None;
 
         for (idx, &selected) in block.iter().enumerate() {
-            if selected == 0 {
+            if !selected {
                 continue;
             }
-            total_weight += self.weights[idx].to_sum();
+            total_weight = W::checked_add_to_sum(
+                total_weight,
+                self.weights[idx].to_sum(),
+                "summing spanning tree edge weights",
+            )?;
             let (u, v) = edges[idx];
             adjacency[u].push(v);
             adjacency[v].push(u);
@@ -138,11 +224,11 @@ impl<W: WeightElement> KthBestSpanningTree<W> {
         }
 
         if total_weight > self.bound {
-            return false;
+            return Ok(false);
         }
 
         if num_vertices <= 1 {
-            return true;
+            return Ok(true);
         }
 
         // SAFETY: num_vertices > 1 and selected_count == num_vertices - 1 > 0,
@@ -163,43 +249,19 @@ impl<W: WeightElement> KthBestSpanningTree<W> {
             }
         }
 
-        visited.into_iter().all(|seen| seen)
+        Ok(visited.into_iter().all(|seen| seen))
     }
 
-    fn blocks_are_pairwise_distinct(&self, config: &[usize], block_size: usize) -> bool {
-        debug_assert!(block_size > 0, "block_size must be positive");
-        let blocks: Vec<&[usize]> = config.chunks_exact(block_size).collect();
-        for left in 0..blocks.len() {
-            for right in (left + 1)..blocks.len() {
-                if blocks[left] == blocks[right] {
+    fn blocks_are_pairwise_distinct(&self, config: &[Vec<bool>]) -> bool {
+        for left in 0..config.len() {
+            for right in (left + 1)..config.len() {
+                if config[left] == config[right] {
                     return false;
                 }
             }
         }
         true
     }
-
-    fn evaluate_config(&self, config: &[usize]) -> bool {
-        let block_size = self.graph.num_edges();
-        let expected_len = self.k * block_size;
-        if config.len() != expected_len {
-            return false;
-        }
-
-        if block_size == 0 {
-            return self.k == 1 && self.block_is_valid_tree(config, &[]);
-        }
-
-        let edges = self.graph.edges();
-
-        if !self.blocks_are_pairwise_distinct(config, block_size) {
-            return false;
-        }
-
-        config
-            .chunks_exact(block_size)
-            .all(|block| self.block_is_valid_tree(block, &edges))
-    }
 }
 
 impl<W> Problem for KthBestSpanningTree<W>
@@ -207,18 +269,42 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "KthBestSpanningTree";
+    type Solution = Vec<Vec<bool>>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_vertices", num_vertices),
+        ("num_edges", num_edges),
+        ("k", k),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.k * self.graph.num_edges()]
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if solution.len() != self.k
+            || solution
+                .iter()
+                .any(|tree| tree.len() != self.graph.num_edges())
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "spanning-tree collection dimensions do not match the instance".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_valid_solution(solution)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.evaluate_config(config))
+impl<W> crate::solvers::BruteForceProblem for KthBestSpanningTree<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.k * self.graph.num_edges()]
     }
 }
 
@@ -232,15 +318,22 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
     let problem = KthBestSpanningTree::new(graph, vec![1, 1, 2, 2, 2, 3], 2, 4);
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "kth_best_spanning_tree_i32",
+        id: "kth_best_spanning_tree",
         instance: Box::new(problem),
-        optimal_config: vec![1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0],
+        optimal_config: serde_json::json!([
+            [true, true, true, false, false, false],
+            [true, true, false, false, true, false]
+        ]),
         optimal_value: serde_json::json!(true),
     }]
 }
 
 crate::declare_variants! {
-    default KthBestSpanningTree<i32> => "2^(num_edges * k)",
+    default KthBestSpanningTree<i64> => "2^(num_edges * k)" create KthBestSpanningTreeCreateSpec,
+}
+
+crate::register_brute_force! {
+    KthBestSpanningTree<i64> decode |problem: &KthBestSpanningTree<i64>, indices: Vec<usize>| indices.chunks(problem.num_edges()).map(crate::config::config_to_bits).collect(),
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/length_bounded_disjoint_paths.rs b/src/models/graph/length_bounded_disjoint_paths.rs
index 93e97073c..a12a08172 100644
--- a/src/models/graph/length_bounded_disjoint_paths.rs
+++ b/src/models/graph/length_bounded_disjoint_paths.rs
@@ -3,8 +3,8 @@
 //! The problem maximizes the number of internally vertex-disjoint `s-t` paths,
 //! each using at most `K` edges, over up to `max_paths` path slots.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
-use crate::topology::{Graph, SimpleGraph};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
+use crate::topology::{is_simple_st_path, Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::Max;
 use crate::variant::VariantParam;
@@ -18,23 +18,18 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Maximize the number of internally vertex-disjoint s-t paths of length at most K",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "source", type_name: "usize", description: "The shared source vertex s" },
-            FieldInfo { name: "sink", type_name: "usize", description: "The shared sink vertex t" },
-            FieldInfo { name: "max_paths", type_name: "usize", description: "Upper bound on the number of path slots" },
-            FieldInfo { name: "max_length", type_name: "usize", description: "Maximum path length K in edges" },
-        ],
+        fields: LengthBoundedDisjointPathsCreateSpec::FIELDS,
     }
 }
 
 /// Length-Bounded Disjoint Paths on an undirected graph.
 ///
-/// A configuration uses `max_paths * |V|` binary choices. For each path slot
-/// `j` and vertex `v`, `x_{j,v} = 1` means that `v` belongs to slot `j`'s
-/// path. Each non-empty slot must induce a simple `s-t` path, and the internal
+/// A configuration uses `max_paths * |E|` binary choices. For each path slot
+/// `j` and edge `e` in `graph.edges()` order, `x_{j,e} = 1` means that the
+/// path uses that edge. Each non-empty slot must form a simple `s-t` path, and the internal
 /// vertices of different slots must be disjoint. Empty slots (all zeros) are
 /// unused and do not count toward the objective. The objective is to maximize
 /// the number of non-empty valid path slots.
@@ -48,6 +43,92 @@ pub struct LengthBoundedDisjointPaths<G> {
     max_length: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct LengthBoundedDisjointPathsCreateSpec {
+    /// Undirected graph edges.
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    /// Vertex count, needed to preserve isolated vertices.
+    num_vertices: Option<usize>,
+    /// Shared source vertex.
+    source: usize,
+    /// Shared sink vertex.
+    sink: usize,
+    /// Maximum path length in edges.
+    max_length: usize,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct LengthBoundedDisjointPathsRandomSpec {
+    /// Number of graph vertices.
+    num_vertices: usize,
+    /// Independent edge probability (default: 0.5).
+    edge_prob: Option<f64>,
+    /// Seed for reproducible generation.
+    seed: Option<i64>,
+    /// Source vertex (default: 0).
+    source: Option<usize>,
+    /// Sink vertex (default: the final vertex).
+    sink: Option<usize>,
+    /// Maximum path length (default: num_vertices - 1).
+    max_length: Option<usize>,
+}
+
+impl TryFrom<LengthBoundedDisjointPathsCreateSpec> for LengthBoundedDisjointPaths<SimpleGraph> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: LengthBoundedDisjointPathsCreateSpec) -> Result<Self, Self::Error> {
+        if spec.graph.is_empty() && spec.num_vertices.is_none() {
+            return Err("num_vertices is required for an empty graph"
+                .to_string()
+                .into());
+        }
+        for (index, &(u, v)) in spec.graph.iter().enumerate() {
+            if u == v {
+                return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+            }
+        }
+        let inferred = spec
+            .graph
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let num_vertices = spec.num_vertices.unwrap_or(inferred);
+        if num_vertices < inferred {
+            return Err(format!(
+                "num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}"
+            ).into());
+        }
+        if spec.source >= num_vertices || spec.sink >= num_vertices {
+            return Err("source and sink must be valid graph vertices"
+                .to_string()
+                .into());
+        }
+        if spec.source == spec.sink {
+            return Err("source and sink must be distinct".to_string().into());
+        }
+        if spec.max_length == 0 {
+            return Err("max_length must be positive".to_string().into());
+        }
+
+        let graph = SimpleGraph::new(num_vertices, spec.graph);
+        let max_paths = graph
+            .neighbors(spec.source)
+            .len()
+            .min(graph.neighbors(spec.sink).len());
+        Ok(Self {
+            graph,
+            source: spec.source,
+            sink: spec.sink,
+            max_paths,
+            max_length: spec.max_length,
+        })
+    }
+}
+
 impl<G: Graph> LengthBoundedDisjointPaths<G> {
     /// Create a new Length-Bounded Disjoint Paths instance.
     ///
@@ -122,186 +203,162 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "LengthBoundedDisjointPaths";
-    type Value = Max<usize>;
+    type Solution = Vec<Vec<bool>>;
+    type Value = Max<i64>;
+
+    crate::problem_parameters![
+        ("max_paths", max_paths),
+        ("num_edges", num_edges),
+        ("num_vertices", num_vertices),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.max_paths * self.graph.num_vertices()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Max<usize> {
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
+        if solution.len() != self.max_paths
+            || solution
+                .iter()
+                .any(|path| path.len() != self.graph.num_edges())
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "path collection dimensions do not match the instance".into(),
+            ));
+        }
         validate_path_collection(
             &self.graph,
             self.source,
             self.sink,
-            self.max_paths,
             self.max_length,
-            config,
+            solution,
         )
     }
 }
 
+impl<G> crate::solvers::BruteForceProblem for LengthBoundedDisjointPaths<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.max_paths * self.graph.num_edges()]
+    }
+}
+
 /// Validate a path collection and return the number of valid non-empty paths,
 /// or `None` if any non-empty slot is structurally invalid.
 fn validate_path_collection<G: Graph>(
     graph: &G,
     source: usize,
     sink: usize,
-    max_paths: usize,
     max_length: usize,
-    config: &[usize],
-) -> Max<usize> {
-    let num_vertices = graph.num_vertices();
-    if config.len() != max_paths * num_vertices {
-        return Max(None);
-    }
-    if config.iter().any(|&value| value > 1) {
-        return Max(None);
-    }
-
-    let mut used_internal = vec![false; num_vertices];
+    solution: &[Vec<bool>],
+) -> Result<Max<i64>, crate::traits::EvaluationError> {
+    let edges = graph.edges();
+    let mut internal_owner = vec![None; graph.num_vertices()];
     let mut used_direct_path = false;
-    let mut count = 0usize;
-    for slot in config.chunks(num_vertices) {
-        // Check if slot is empty (all zeros)
-        if slot.iter().all(|&v| v == 0) {
+    let mut count = 0_i64;
+    for (path_index, slot) in solution.iter().enumerate() {
+        let edge_count = slot.iter().filter(|&&selected| selected).count();
+        if edge_count == 0 {
             continue;
         }
-        if !is_valid_path_slot(
-            graph,
-            source,
-            sink,
-            max_length,
-            slot,
-            &mut used_internal,
-            &mut used_direct_path,
-        ) {
-            return Max(None);
-        }
-        count += 1;
-    }
-    Max(Some(count))
-}
-
-fn is_valid_path_slot<G: Graph>(
-    graph: &G,
-    source: usize,
-    sink: usize,
-    max_length: usize,
-    slot: &[usize],
-    used_internal: &mut [bool],
-    used_direct_path: &mut bool,
-) -> bool {
-    if slot.len() != graph.num_vertices()
-        || slot.get(source) != Some(&1)
-        || slot.get(sink) != Some(&1)
-    {
-        return false;
-    }
-
-    let selected = slot
-        .iter()
-        .enumerate()
-        .filter_map(|(vertex, &chosen)| (chosen == 1).then_some(vertex))
-        .collect::<Vec<_>>();
-    if selected.len() < 2 {
-        return false;
-    }
-
-    let mut in_path = vec![false; graph.num_vertices()];
-    for &vertex in &selected {
-        in_path[vertex] = true;
-        if vertex != source && vertex != sink && used_internal[vertex] {
-            return false;
+        if edge_count > max_length
+            || !is_simple_st_path(graph.num_vertices(), &edges, source, sink, slot)
+        {
+            return Ok(Max(None));
         }
-    }
-
-    let mut degree_sum = 0usize;
-    for &vertex in &selected {
-        let degree = graph
-            .neighbors(vertex)
-            .into_iter()
-            .filter(|&neighbor| in_path[neighbor])
-            .count();
-        degree_sum += degree;
-
-        if vertex == source || vertex == sink {
-            if degree != 1 {
-                return false;
+        if edge_count == 1 {
+            if used_direct_path {
+                return Ok(Max(None));
             }
-        } else if degree != 2 {
-            return false;
-        }
-    }
-
-    let edge_count = degree_sum / 2;
-    if edge_count + 1 != selected.len() || edge_count > max_length {
-        return false;
-    }
-    if edge_count == 1 {
-        if *used_direct_path {
-            return false;
+            used_direct_path = true;
         }
-        *used_direct_path = true;
-    }
-
-    let mut seen = vec![false; graph.num_vertices()];
-    let mut stack = vec![source];
-    seen[source] = true;
-    let mut seen_count = 0usize;
-    while let Some(vertex) = stack.pop() {
-        seen_count += 1;
-        for neighbor in graph.neighbors(vertex) {
-            if in_path[neighbor] && !seen[neighbor] {
-                seen[neighbor] = true;
-                stack.push(neighbor);
+        for (&selected, &(u, v)) in slot.iter().zip(&edges) {
+            if !selected {
+                continue;
+            }
+            for vertex in [u, v] {
+                if vertex == source || vertex == sink {
+                    continue;
+                }
+                if internal_owner[vertex].is_some_and(|owner| owner != path_index) {
+                    return Ok(Max(None));
+                }
+                internal_owner[vertex] = Some(path_index);
             }
         }
+        count = count.checked_add(1).ok_or_else(|| {
+            crate::traits::EvaluationError::IntegerOverflow("counting disjoint paths".to_string())
+        })?;
     }
-
-    if !seen[sink] || seen_count != selected.len() {
-        return false;
-    }
-
-    for &vertex in &selected {
-        if vertex != source && vertex != sink {
-            used_internal[vertex] = true;
-        }
-    }
-    true
+    Ok(Max(Some(count)))
 }
 
-#[cfg(feature = "example-db")]
-fn encode_paths(num_vertices: usize, max_paths: usize, slots: &[&[usize]]) -> Vec<usize> {
-    let mut config = vec![0; num_vertices * max_paths];
-    for (slot_index, slot_vertices) in slots.iter().enumerate() {
-        let offset = slot_index * num_vertices;
-        for &vertex in *slot_vertices {
-            config[offset + vertex] = 1;
+#[cfg(any(test, feature = "example-db"))]
+fn encode_paths(num_edges: usize, max_paths: usize, slots: &[&[usize]]) -> Vec<Vec<bool>> {
+    let mut paths = vec![vec![false; num_edges]; max_paths];
+    for (slot_index, slot_edges) in slots.iter().enumerate() {
+        for &edge in *slot_edges {
+            paths[slot_index][edge] = true;
         }
     }
-    config
+    paths
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 4), (0, 2), (2, 4), (0, 3), (3, 4)]);
     // max_paths = min(deg(0), deg(4)) = min(3, 3) = 3
-    // 3 * 5 = 15 binary variables → 2^15 = 32768 configs (brute-force feasible)
+    // Three edge-selection rows over six edges.
     // Optimal: 3 disjoint paths [0,1,4], [0,2,4], [0,3,4]
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "length_bounded_disjoint_paths_simplegraph",
         instance: Box::new(LengthBoundedDisjointPaths::new(graph, 0, 4, 3)),
-        optimal_config: encode_paths(5, 3, &[&[0, 1, 4], &[0, 2, 4], &[0, 3, 4]]),
+        optimal_config: serde_json::json!(encode_paths(6, 3, &[&[0, 1], &[2, 3], &[4, 5]])),
         optimal_value: serde_json::json!(3),
     }]
 }
 
+crate::impl_random_generate!(
+    LengthBoundedDisjointPaths<SimpleGraph>,
+    LengthBoundedDisjointPathsRandomSpec,
+    |spec| {
+        let endpoints = crate::random::EndpointRandomSpec {
+            num_vertices: spec.num_vertices,
+            edge_prob: spec.edge_prob,
+            seed: spec.seed,
+            source: spec.source,
+            sink: spec.sink,
+        };
+        let (source, sink) = endpoints.endpoints()?;
+        let max_length = spec.max_length.unwrap_or(spec.num_vertices - 1);
+        if max_length == 0 {
+            return Err("max_length must be positive".to_string().into());
+        }
+        Ok(LengthBoundedDisjointPaths::new(
+            endpoints.graph()?,
+            source,
+            sink,
+            max_length,
+        ))
+    }
+);
+
 crate::declare_variants! {
-    default LengthBoundedDisjointPaths<SimpleGraph> => "2^(max_paths * num_vertices)",
+    default LengthBoundedDisjointPaths<SimpleGraph> => "2^(max_paths * num_edges)" create LengthBoundedDisjointPathsCreateSpec random,
+}
+
+crate::register_brute_force! {
+    LengthBoundedDisjointPaths<SimpleGraph> decode |problem: &LengthBoundedDisjointPaths<SimpleGraph>, indices: Vec<usize>| {
+        let m = problem.num_edges();
+        (0..problem.max_paths())
+            .map(|slot| crate::config::config_to_bits(&indices[slot * m..(slot + 1) * m]))
+            .collect()
+    },
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/longest_circuit.rs b/src/models/graph/longest_circuit.rs
index 735d11d00..f60e24bff 100644
--- a/src/models/graph/longest_circuit.rs
+++ b/src/models/graph/longest_circuit.rs
@@ -3,7 +3,7 @@
 //! The Longest Circuit problem asks for a simple circuit in a graph
 //! that maximizes the total edge length.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, WeightElement};
@@ -18,14 +18,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a simple circuit in a graph that maximizes total edge length",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "edge_lengths", type_name: "Vec<W>", description: "Positive edge lengths l: E -> Z_(> 0)" },
-        ],
+        fields: LongestCircuitCreateSpec::FIELDS,
     }
 }
 
@@ -48,6 +46,69 @@ pub struct LongestCircuit<G, W: WeightElement> {
     edge_lengths: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct LongestCircuitCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    edge_weights: Option<Vec<i64>>,
+}
+
+impl TryFrom<LongestCircuitCreateSpec> for LongestCircuit<SimpleGraph, i64> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: LongestCircuitCreateSpec) -> Result<Self, Self::Error> {
+        let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+        let edge_lengths = spec
+            .edge_weights
+            .unwrap_or_else(|| vec![1; graph.num_edges()]);
+        if edge_lengths.len() != graph.num_edges() {
+            return Err(format!(
+                "edge_weights has length {}, expected {}",
+                edge_lengths.len(),
+                graph.num_edges()
+            )
+            .into());
+        }
+        if edge_lengths.iter().any(|&length| length <= 0) {
+            return Err("edge_weights must be positive".to_string().into());
+        }
+        Ok(Self::new(graph, edge_lengths))
+    }
+}
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(format!(
+            "num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}"
+        )
+        .into());
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
+}
+
 impl<G: Graph, W: WeightElement> LongestCircuit<G, W> {
     /// Create a new LongestCircuit instance.
     ///
@@ -127,7 +188,7 @@ impl<G: Graph, W: WeightElement> LongestCircuit<G, W> {
     }
 
     /// Check whether a configuration is a valid simple circuit.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_simple_circuit(&self.graph, config)
     }
 }
@@ -138,33 +199,56 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "LongestCircuit";
+    type Solution = Vec<bool>;
     type Value = Max<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Max<W::Sum> {
-        if !is_simple_circuit(&self.graph, config) {
-            return Max(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (idx, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.edge_lengths[idx].to_sum();
+        Ok({
+            if !is_simple_circuit(&self.graph, config) {
+                return Ok(Max(None));
             }
-        }
-        Max(Some(total))
+            let mut total = W::Sum::zero();
+            for (idx, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.edge_lengths[idx].to_sum(),
+                        "summing circuit edge lengths",
+                    )?;
+                }
+            }
+            Max(Some(total))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for LongestCircuit<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
 }
 
 /// Check whether a binary edge-selection encodes exactly one simple circuit.
-pub(crate) fn is_simple_circuit<G: Graph>(graph: &G, config: &[usize]) -> bool {
-    if config.len() != graph.num_edges() || config.iter().any(|&value| value > 1) {
+pub(crate) fn is_simple_circuit<G: Graph>(graph: &G, config: &[bool]) -> bool {
+    if config.len() != graph.num_edges() {
         return false;
     }
 
@@ -176,7 +260,7 @@ pub(crate) fn is_simple_circuit<G: Graph>(graph: &G, config: &[usize]) -> bool {
     let mut start = None;
 
     for (idx, &selected) in config.iter().enumerate() {
-        if selected == 0 {
+        if !selected {
             continue;
         }
         let (u, v) = edges[idx];
@@ -231,7 +315,7 @@ pub(crate) fn is_simple_circuit<G: Graph>(graph: &G, config: &[usize]) -> bool {
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "longest_circuit_simplegraph_i32",
+        id: "longest_circuit_simplegraph",
         instance: Box::new(LongestCircuit::new(
             SimpleGraph::new(
                 6,
@@ -250,13 +334,25 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ),
             vec![3, 2, 4, 1, 5, 2, 3, 2, 1, 2],
         )),
-        optimal_config: vec![1, 0, 1, 0, 1, 0, 1, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![
+            true, false, true, false, true, false, true, true, true, false
+        ]),
         optimal_value: serde_json::json!(18),
     }]
 }
 
+crate::impl_random_generate!(LongestCircuit<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    let graph = spec.graph()?;
+    let lengths = vec![1; graph.num_edges()];
+    Ok(LongestCircuit::new(graph, lengths))
+});
+
 crate::declare_variants! {
-    default LongestCircuit<SimpleGraph, i32> => "2^num_vertices * num_vertices^2",
+    default LongestCircuit<SimpleGraph, i64> => "2^num_vertices * num_vertices^2" create LongestCircuitCreateSpec random,
+}
+
+crate::register_brute_force! {
+    LongestCircuit<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/longest_path.rs b/src/models/graph/longest_path.rs
index fd70dbeb3..2423f24fb 100644
--- a/src/models/graph/longest_path.rs
+++ b/src/models/graph/longest_path.rs
@@ -3,13 +3,12 @@
 //! The Longest Path problem asks for a simple path between two distinguished
 //! vertices that maximizes the total edge length.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
-use crate::topology::{Graph, SimpleGraph};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
+use crate::topology::{is_simple_st_path, Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, One, WeightElement};
 use num_traits::Zero;
 use serde::{Deserialize, Serialize};
-use std::collections::VecDeque;
 
 inventory::submit! {
     ProblemSchemaEntry {
@@ -18,16 +17,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32", "One"]),
+            VariantDimension::new("weight", "i64", &["i64", "One"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a simple s-t path of maximum total edge length",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "edge_lengths", type_name: "Vec<W>", description: "Positive edge lengths l: E -> ZZ_(> 0)" },
-            FieldInfo { name: "source_vertex", type_name: "usize", description: "Source vertex s" },
-            FieldInfo { name: "target_vertex", type_name: "usize", description: "Target vertex t" },
-        ],
+        fields: LongestPathI64CreateSpec::FIELDS,
     }
 }
 
@@ -53,6 +48,66 @@ pub struct LongestPath<G, W: WeightElement> {
     target_vertex: usize,
 }
 
+macro_rules! longest_path_create_spec {
+    (@lengths $spec:ident, $lengths:ident) => { $spec.$lengths };
+    (@lengths $spec:ident) => { vec![One; $spec.graph.len()] };
+    ($name:ident,$weight:ty $(, $lengths:ident)?) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            #[create(codec = "edge-list")]
+            graph: Vec<(usize, usize)>,
+            num_vertices: Option<usize>,
+            $(#[create(codec = "comma-separated")]
+            $lengths: Vec<$weight>,)?
+            source_vertex: usize,
+            target_vertex: usize,
+        }
+        impl TryFrom<$name> for LongestPath<SimpleGraph, $weight> {
+            type Error = crate::registry::ConstructionError;
+            fn try_from(spec: $name) -> Result<Self, crate::registry::ConstructionError> {
+                if spec.graph.is_empty() && spec.num_vertices.is_none() {
+                    return Err("num_vertices is required for an empty graph".into());
+                }
+                for &(u, v) in &spec.graph {
+                    if u == v {
+                        return Err("self-loops are not allowed".into());
+                    }
+                }
+                let inferred = spec
+                    .graph
+                    .iter()
+                    .flat_map(|&(u, v)| [u, v])
+                    .max()
+                    .map(|v| v.checked_add(1).ok_or("vertex count overflows usize"))
+                    .transpose()?
+                    .unwrap_or(0);
+                let count = spec.num_vertices.unwrap_or(inferred);
+                if count < inferred {
+                    return Err("num_vertices is too small".into());
+                }
+                let edge_lengths = longest_path_create_spec!(@lengths spec $(, $lengths)?);
+                if edge_lengths.len() != spec.graph.len() {
+                    return Err("edge_lengths length must match graph edge count".into());
+                }
+                if edge_lengths.iter().any(|v| v.to_sum() <= 0) {
+                    return Err("edge lengths must be positive".into());
+                }
+                if spec.source_vertex >= count || spec.target_vertex >= count {
+                    return Err("source_vertex and target_vertex must be valid vertices".into());
+                }
+                Ok(Self {
+                    graph: SimpleGraph::new(count, spec.graph),
+                    edge_lengths,
+                    source_vertex: spec.source_vertex,
+                    target_vertex: spec.target_vertex,
+                })
+            }
+        }
+    };
+}
+longest_path_create_spec!(LongestPathI64CreateSpec, i64, edge_lengths);
+longest_path_create_spec!(LongestPathOneCreateSpec, One);
+
 impl<G: Graph, W: WeightElement> LongestPath<G, W> {
     fn assert_positive_edge_lengths(edge_lengths: &[W]) {
         let zero = W::Sum::zero();
@@ -139,8 +194,14 @@ impl<G: Graph, W: WeightElement> LongestPath<G, W> {
     }
 
     /// Check if a configuration encodes a valid simple source-target path.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        is_simple_st_path(&self.graph, self.source_vertex, self.target_vertex, config)
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
+        is_simple_st_path(
+            self.graph.num_vertices(),
+            &self.graph.edges(),
+            self.source_vertex,
+            self.target_vertex,
+            config,
+        )
     }
 }
 
@@ -150,117 +211,68 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "LongestPath";
+    type Solution = Vec<bool>;
     type Value = Max<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Max<W::Sum> {
-        if !self.is_valid_solution(config) {
-            return Max(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
         }
+        Ok({
+            if !self.is_valid_solution(config) {
+                return Ok(Max(None));
+            }
 
-        let mut total = W::Sum::zero();
-        for (idx, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.edge_lengths[idx].to_sum();
+            let mut total = W::Sum::zero();
+            for (idx, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.edge_lengths[idx].to_sum(),
+                        "summing path edge lengths",
+                    )?;
+                }
             }
-        }
-        Max(Some(total))
+            Max(Some(total))
+        })
     }
 }
 
-fn is_simple_st_path<G: Graph>(
-    graph: &G,
-    source_vertex: usize,
-    target_vertex: usize,
-    config: &[usize],
-) -> bool {
-    if config.len() != graph.num_edges() || config.iter().any(|&value| value > 1) {
-        return false;
-    }
-
-    if source_vertex == target_vertex {
-        return config.iter().all(|&value| value == 0);
-    }
-
-    let edges = graph.edges();
-    let mut degree = vec![0usize; graph.num_vertices()];
-    let mut adjacency = vec![Vec::new(); graph.num_vertices()];
-    let mut selected_edge_count = 0usize;
-
-    for (idx, &selected) in config.iter().enumerate() {
-        if selected == 0 {
-            continue;
-        }
-        let (u, v) = edges[idx];
-        degree[u] += 1;
-        degree[v] += 1;
-        if degree[u] > 2 || degree[v] > 2 {
-            return false;
-        }
-        adjacency[u].push(v);
-        adjacency[v].push(u);
-        selected_edge_count += 1;
-    }
-
-    if selected_edge_count == 0 {
-        return false;
-    }
-    if degree[source_vertex] != 1 || degree[target_vertex] != 1 {
-        return false;
-    }
-
-    let mut selected_vertex_count = 0usize;
-    for (vertex, &vertex_degree) in degree.iter().enumerate() {
-        if vertex_degree == 0 {
-            continue;
-        }
-        selected_vertex_count += 1;
-        if vertex != source_vertex && vertex != target_vertex && vertex_degree != 2 {
-            return false;
-        }
-    }
-
-    if selected_edge_count != selected_vertex_count.saturating_sub(1) {
-        return false;
-    }
-
-    let mut visited = vec![false; graph.num_vertices()];
-    let mut queue = VecDeque::new();
-    visited[source_vertex] = true;
-    queue.push_back(source_vertex);
-
-    while let Some(vertex) = queue.pop_front() {
-        for &neighbor in &adjacency[vertex] {
-            if !visited[neighbor] {
-                visited[neighbor] = true;
-                queue.push_back(neighbor);
-            }
-        }
+impl<G, W> crate::solvers::BruteForceProblem for LongestPath<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
-
-    visited[target_vertex]
-        && degree
-            .iter()
-            .enumerate()
-            .all(|(vertex, &vertex_degree)| vertex_degree == 0 || visited[vertex])
 }
 
 crate::declare_variants! {
-    default LongestPath<SimpleGraph, i32> => "num_vertices * 2^num_vertices",
-    LongestPath<SimpleGraph, One> => "num_vertices * 2^num_vertices",
+    default LongestPath<SimpleGraph, i64> => "num_vertices * 2^num_vertices" create LongestPathI64CreateSpec,
+    LongestPath<SimpleGraph, One> => "num_vertices * 2^num_vertices" create LongestPathOneCreateSpec,
+}
+
+crate::register_brute_force! {
+    LongestPath<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    LongestPath<SimpleGraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "longest_path_simplegraph_i32",
+        id: "longest_path_simplegraph",
         instance: Box::new(LongestPath::new(
             SimpleGraph::new(
                 7,
@@ -281,7 +293,9 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             0,
             6,
         )),
-        optimal_config: vec![1, 0, 1, 1, 1, 0, 1, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![
+            true, false, true, true, true, false, true, false, true, false
+        ]),
         optimal_value: serde_json::json!(20),
     }]
 }
diff --git a/src/models/graph/max_cut.rs b/src/models/graph/max_cut.rs
index 0dba64bbc..0d414cfac 100644
--- a/src/models/graph/max_cut.rs
+++ b/src/models/graph/max_cut.rs
@@ -3,7 +3,7 @@
 //! The Maximum Cut problem asks for a partition of vertices into two sets
 //! that maximizes the total weight of edges crossing the partition.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, One, WeightElement};
@@ -14,17 +14,15 @@ inventory::submit! {
     ProblemSchemaEntry {
         name: "MaxCut",
         display_name: "Max Cut",
-        aliases: &["GraphPartitioning", "MaximumBipartiteSubgraph"],
+        aliases: &["MaximumBipartiteSubgraph"],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32", "One"]),
+            VariantDimension::new("weight", "i64", &["i64", "One"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find maximum weight cut in a graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The graph with edge weights" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge weights w: E -> R" },
-        ],
+        fields: MaxCutI64CreateSpec::FIELDS,
     }
 }
 
@@ -45,7 +43,7 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`, `KingsSubgraph`, `UnitDiskGraph`)
-/// * `W` - The weight type for edges (e.g., `i32`, `f64`)
+/// * `W` - The weight type for edges (e.g., `i64`, `f64`)
 ///
 /// # Example
 ///
@@ -53,7 +51,7 @@ inventory::submit! {
 /// use problemreductions::models::graph::MaxCut;
 /// use problemreductions::topology::SimpleGraph;
 /// use problemreductions::types::Max;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Create a triangle with unit weights
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
@@ -61,11 +59,11 @@ inventory::submit! {
 ///
 /// // Solve with brute force
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Maximum cut in triangle is 2 (any partition cuts 2 edges)
 /// for sol in solutions {
-///     let size = problem.evaluate(&sol);
+///     let size = problem.evaluate(&sol).unwrap();
 ///     assert_eq!(size, Max(Some(2)));
 /// }
 /// ```
@@ -77,6 +75,70 @@ pub struct MaxCut<G, W> {
     edge_weights: Vec<W>,
 }
 
+macro_rules! max_cut_create_spec {
+    ($name:ident, $weight:ty, $one:expr $(, $edge_weights:ident)?) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            #[create(codec = "edge-list")]
+            graph: Vec<(usize, usize)>,
+            num_vertices: Option<usize>,
+            $(
+            #[create(codec = "comma-separated")]
+            $edge_weights: Option<Vec<$weight>>,
+            )?
+        }
+
+        impl TryFrom<$name> for MaxCut<SimpleGraph, $weight> {
+            type Error = crate::registry::ConstructionError;
+
+            fn try_from(spec: $name) -> Result<Self, Self::Error> {
+                let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+                let edge_weights = { $(if let Some(value) = spec.$edge_weights { value } else)? { vec![$one; graph.num_edges()] } };
+                if edge_weights.len() != graph.num_edges() {
+                    return Err(format!(
+                        "edge_weights has length {}, expected {}",
+                        edge_weights.len(),
+                        graph.num_edges()
+                    )
+                    .into());
+                }
+                Ok(Self::new(graph, edge_weights))
+            }
+        }
+    };
+}
+
+max_cut_create_spec!(MaxCutI64CreateSpec, i64, 1, edge_weights);
+max_cut_create_spec!(MaxCutOneCreateSpec, One, One);
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(format!("num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}").into());
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
+}
+
 impl<G: Graph, W: Clone + Default> MaxCut<G, W> {
     /// Create a MaxCut problem from a graph with specified edge weights.
     ///
@@ -98,9 +160,9 @@ impl<G: Graph, W: Clone + Default> MaxCut<G, W> {
     /// Create a MaxCut problem with unit weights.
     pub fn unweighted(graph: G) -> Self
     where
-        W: From<i32>,
+        W: WeightElement,
     {
-        let edge_weights = vec![W::from(1); graph.num_edges()];
+        let edge_weights = vec![W::unit(); graph.num_edges()];
         Self {
             graph,
             edge_weights,
@@ -144,12 +206,11 @@ impl<G: Graph, W: Clone + Default> MaxCut<G, W> {
     }
 
     /// Compute the cut size for a given partition configuration.
-    pub fn cut_size(&self, config: &[usize]) -> W::Sum
+    pub fn cut_size(&self, config: &[bool]) -> Result<W::Sum, crate::traits::EvaluationError>
     where
         W: WeightElement,
     {
-        let partition: Vec<bool> = config.iter().map(|&c| c != 0).collect();
-        cut_size(&self.graph, &self.edge_weights, &partition)
+        cut_size(&self.graph, &self.edge_weights, config)
     }
 }
 
@@ -171,20 +232,38 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MaxCut";
+    type Solution = Vec<bool>;
     type Value = Max<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "cut assignment length does not match the graph vertices".into(),
+            ));
+        }
+        Ok({
+            // All cuts are valid, so always return Valid
+            Max(Some(cut_size(&self.graph, &self.edge_weights, config)?))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Max<W::Sum> {
-        // All cuts are valid, so always return Valid
-        let partition: Vec<bool> = config.iter().map(|&c| c != 0).collect();
-        Max(Some(cut_size(&self.graph, &self.edge_weights, &partition)))
+impl<G, W> crate::solvers::BruteForceProblem for MaxCut<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
@@ -194,7 +273,11 @@ where
 /// * `graph` - The graph structure
 /// * `edge_weights` - Weights for each edge (same order as `graph.edges()`)
 /// * `partition` - Boolean slice indicating which set each vertex belongs to
-pub(crate) fn cut_size<G, W>(graph: &G, edge_weights: &[W], partition: &[bool]) -> W::Sum
+pub(crate) fn cut_size<G, W>(
+    graph: &G,
+    edge_weights: &[W],
+    partition: &[bool],
+) -> Result<W::Sum, crate::traits::EvaluationError>
 where
     G: Graph,
     W: WeightElement,
@@ -202,31 +285,42 @@ where
     let mut total = W::Sum::zero();
     for ((u, v), weight) in graph.edges().iter().zip(edge_weights.iter()) {
         if *u < partition.len() && *v < partition.len() && partition[*u] != partition[*v] {
-            total += weight.to_sum();
+            total = W::checked_add_to_sum(total, weight.to_sum(), "summing cut-edge weights")?;
         }
     }
-    total
+    Ok(total)
 }
 
+crate::impl_random_generate!(MaxCut<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    let graph = spec.graph()?;
+    let weights = vec![1; graph.num_edges()];
+    Ok(MaxCut::new(graph, weights))
+});
+
 crate::declare_variants! {
-    default MaxCut<SimpleGraph, i32> => "2^(2.372 * num_vertices / 3)",
-    MaxCut<SimpleGraph, One> => "2^(0.7907 * num_vertices)",
+    default MaxCut<SimpleGraph, i64> => "2^(2.372 * num_vertices / 3)" create MaxCutI64CreateSpec random,
+    MaxCut<SimpleGraph, One> => "2^(0.7907 * num_vertices)" create MaxCutOneCreateSpec,
+}
+
+crate::register_brute_force! {
+    MaxCut<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaxCut<SimpleGraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![
         crate::example_db::specs::ModelExampleSpec {
-            id: "max_cut_simplegraph_i32",
-            instance: Box::new(MaxCut::<_, i32>::unweighted(SimpleGraph::new(
+            id: "max_cut_simplegraph",
+            instance: Box::new(MaxCut::<_, i64>::unweighted(SimpleGraph::new(
                 5,
                 vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)],
             ))),
-            optimal_config: vec![1, 0, 0, 1, 0],
+            optimal_config: serde_json::json!(vec![true, false, false, true, false]),
             optimal_value: serde_json::json!(5),
         },
         crate::example_db::specs::ModelExampleSpec {
-            id: "max_cut_simplegraph_one",
+            id: "max_cut_seven_edge_graph",
             instance: Box::new(MaxCut::new(
                 SimpleGraph::new(
                     5,
@@ -234,7 +328,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 ),
                 vec![One; 7],
             )),
-            optimal_config: vec![0, 1, 0, 1, 0],
+            optimal_config: serde_json::json!(vec![false, true, false, true, false]),
             optimal_value: serde_json::json!(6),
         },
     ]
diff --git a/src/models/graph/maximal_is.rs b/src/models/graph/maximal_is.rs
index b08c37d4b..079e0752d 100644
--- a/src/models/graph/maximal_is.rs
+++ b/src/models/graph/maximal_is.rs
@@ -3,7 +3,7 @@
 //! The Maximal Independent Set problem asks for an independent set that
 //! cannot be extended by adding any other vertex.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, WeightElement};
@@ -17,14 +17,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find maximum weight maximal independent set",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-        ],
+        fields: MaximalISCreateSpec::FIELDS,
     }
 }
 
@@ -41,18 +39,18 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MaximalIS;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Path graph 0-1-2
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
 /// let problem = MaximalIS::new(graph, vec![1; 3]);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Maximal independent sets: {0, 2} or {1}
 /// for sol in &solutions {
-///     assert!(problem.evaluate(sol).is_valid());
+///     assert!(problem.evaluate(sol).unwrap().is_valid());
 /// }
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -63,6 +61,29 @@ pub struct MaximalIS<G, W> {
     weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MaximalISCreateSpec {
+    /// The underlying graph G=(V,E).
+    graph: SimpleGraph,
+    /// Vertex weights w: V -> R.
+    weights: Vec<i64>,
+}
+
+impl TryFrom<MaximalISCreateSpec> for MaximalIS<SimpleGraph, i64> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MaximalISCreateSpec) -> Result<Self, Self::Error> {
+        if spec.weights.len() != spec.graph.num_vertices() {
+            return Err(format!(
+                "weights has {} entries, expected {}",
+                spec.weights.len(),
+                spec.graph.num_vertices()
+            )
+            .into());
+        }
+        Ok(Self::new(spec.graph, spec.weights))
+    }
+}
+
 impl<G: Graph, W: Clone + Default> MaximalIS<G, W> {
     /// Create a Maximal Independent Set problem from a graph with given weights.
     pub fn new(graph: G, weights: Vec<W>) -> Self {
@@ -93,15 +114,14 @@ impl<G: Graph, W: Clone + Default> MaximalIS<G, W> {
     }
 
     /// Check if a configuration is a valid maximal independent set.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         self.is_maximal(config)
     }
 
     /// Check if a configuration is an independent set.
-    fn is_independent(&self, config: &[usize]) -> bool {
+    fn is_independent(&self, config: &[bool]) -> bool {
         for (u, v) in self.graph.edges() {
-            if config.get(u).copied().unwrap_or(0) == 1 && config.get(v).copied().unwrap_or(0) == 1
-            {
+            if config.get(u).copied().unwrap_or(false) && config.get(v).copied().unwrap_or(false) {
                 return false;
             }
         }
@@ -109,14 +129,14 @@ impl<G: Graph, W: Clone + Default> MaximalIS<G, W> {
     }
 
     /// Check if an independent set is maximal (cannot be extended).
-    fn is_maximal(&self, config: &[usize]) -> bool {
+    fn is_maximal(&self, config: &[bool]) -> bool {
         if !self.is_independent(config) {
             return false;
         }
 
         let n = self.graph.num_vertices();
         for v in 0..n {
-            if config.get(v).copied().unwrap_or(0) == 1 {
+            if config.get(v).copied().unwrap_or(false) {
                 continue; // Already in set
             }
 
@@ -124,7 +144,7 @@ impl<G: Graph, W: Clone + Default> MaximalIS<G, W> {
             let neighbors = self.graph.neighbors(v);
             let can_add = neighbors
                 .iter()
-                .all(|&u| config.get(u).copied().unwrap_or(0) == 0);
+                .all(|&u| !config.get(u).copied().unwrap_or(false));
 
             if can_add {
                 return false; // Set is not maximal
@@ -153,39 +173,62 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MaximalIS";
+    type Solution = Vec<bool>;
     type Value = Max<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Max<W::Sum> {
-        if !self.is_maximal(config) {
-            return Max(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex-selection length does not match the graph".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.weights[i].to_sum();
+        Ok({
+            if !self.is_maximal(config) {
+                return Ok(Max(None));
             }
-        }
-        Max(Some(total))
+            let mut total = W::Sum::zero();
+            for (i, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.weights[i].to_sum(),
+                        "summing selected maximal-independent-set weights",
+                    )?;
+                }
+            }
+            Max(Some(total))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for MaximalIS<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "maximal_is_simplegraph_i32",
+        id: "maximal_is_simplegraph",
         instance: Box::new(MaximalIS::new(
             SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
-            vec![1i32; 5],
+            vec![1i64; 5],
         )),
-        optimal_config: vec![1, 0, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![true, false, true, false, true]),
         optimal_value: serde_json::json!(3),
     }]
 }
@@ -222,8 +265,16 @@ pub(crate) fn is_maximal_independent_set<G: Graph>(graph: &G, selected: &[bool])
     true
 }
 
+crate::impl_random_generate!(MaximalIS<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    Ok(MaximalIS::new(spec.graph()?, vec![1; spec.num_vertices]))
+});
+
 crate::declare_variants! {
-    default MaximalIS<SimpleGraph, i32> => "3^(num_vertices / 3)",
+    default MaximalIS<SimpleGraph, i64> => "3^(num_vertices / 3)" create MaximalISCreateSpec random,
+}
+
+crate::register_brute_force! {
+    MaximalIS<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/maximum_achromatic_number.rs b/src/models/graph/maximum_achromatic_number.rs
index b45aa0df2..6046f97e1 100644
--- a/src/models/graph/maximum_achromatic_number.rs
+++ b/src/models/graph/maximum_achromatic_number.rs
@@ -20,6 +20,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a complete proper coloring maximizing the number of colors",
         fields: &[
@@ -46,15 +47,15 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MaximumAchromaticNumber;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // C6: achromatic number is 3
 /// let graph = SimpleGraph::new(6, vec![(0,1),(1,2),(2,3),(3,4),(4,5),(5,0)]);
 /// let problem = MaximumAchromaticNumber::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem).unwrap();
-/// let value = problem.evaluate(&solution);
+/// let solution = solver.solve(&problem).unwrap().unwrap();
+/// let value = problem.evaluate(&solution).unwrap();
 /// assert_eq!(value, problemreductions::types::Max(Some(3)));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -127,36 +128,67 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MaximumAchromaticNumber";
-    type Value = Max<usize>;
+    type Solution = Vec<usize>;
+    type Value = Max<i64>;
+
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.graph.num_vertices(); self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.graph.num_vertices() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "color assignment length does not match the graph vertices".into(),
+                ));
+            }
+            if self.graph.num_vertices() == 0 {
+                return Ok(Max(Some(0)));
+            }
+            if !self.is_proper_coloring(config) {
+                return Ok(Max(None));
+            }
+            if !self.is_complete_coloring(config) {
+                return Ok(Max(None));
+            }
+            let distinct_colors: HashSet<usize> = config.iter().copied().collect();
+            Max(Some(i64::try_from(distinct_colors.len()).map_err(
+                |_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting achromatic color count to i64".to_string(),
+                    )
+                },
+            )?))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Max<usize> {
-        if config.len() != self.graph.num_vertices() {
-            return Max(None);
-        }
-        if self.graph.num_vertices() == 0 {
-            return Max(Some(0));
-        }
-        if !self.is_proper_coloring(config) {
-            return Max(None);
-        }
-        if !self.is_complete_coloring(config) {
-            return Max(None);
-        }
-        let distinct_colors: HashSet<usize> = config.iter().copied().collect();
-        Max(Some(distinct_colors.len()))
+impl<G> crate::solvers::BruteForceProblem for MaximumAchromaticNumber<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.graph.num_vertices(); self.graph.num_vertices()]
     }
 }
 
+crate::impl_random_generate!(
+    MaximumAchromaticNumber<SimpleGraph>,
+    crate::random::SimpleGraphRandomSpec,
+    |spec| { Ok(MaximumAchromaticNumber::new(spec.graph()?)) }
+);
+
 crate::declare_variants! {
-    default MaximumAchromaticNumber<SimpleGraph> => "num_vertices^num_vertices",
+    default MaximumAchromaticNumber<SimpleGraph> => "num_vertices^num_vertices" random,
+}
+
+crate::register_brute_force! {
+    MaximumAchromaticNumber<SimpleGraph>,
 }
 
 #[cfg(feature = "example-db")]
@@ -169,7 +201,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             6,
             vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 0)],
         ))),
-        optimal_config: vec![0, 1, 2, 0, 1, 2],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 0, 1, 2]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/graph/maximum_clique.rs b/src/models/graph/maximum_clique.rs
index 849bef38a..423242ba1 100644
--- a/src/models/graph/maximum_clique.rs
+++ b/src/models/graph/maximum_clique.rs
@@ -3,7 +3,7 @@
 //! The MaximumClique problem asks for a maximum weight subset of vertices
 //! such that all vertices in the subset are pairwise adjacent.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, One, WeightElement};
@@ -17,14 +17,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "One", &["One", "i32"]),
+            VariantDimension::new("weight", "One", &["One", "i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find maximum weight clique in a graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-        ],
+        fields: MaximumCliqueCreateSpec::<One>::FIELDS,
     }
 }
 
@@ -38,14 +36,14 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`, `KingsSubgraph`, `UnitDiskGraph`)
-/// * `W` - The weight type (e.g., `i32`, `f64`, `One`)
+/// * `W` - The weight type (e.g., `i64`, `f64`, `One`)
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::graph::MaximumClique;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Create a triangle graph (3 vertices, 3 edges - complete graph)
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
@@ -53,10 +51,10 @@ inventory::submit! {
 ///
 /// // Solve with brute force
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Maximum clique in a triangle (K3) is size 3
-/// assert!(solutions.iter().all(|s| s.iter().sum::<usize>() == 3));
+/// assert!(solutions.iter().all(|s| s.iter().filter(|&&selected| selected).count() == 3));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MaximumClique<G, W> {
@@ -66,6 +64,29 @@ pub struct MaximumClique<G, W> {
     weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MaximumCliqueCreateSpec<W> {
+    /// The underlying graph G=(V,E).
+    graph: SimpleGraph,
+    /// Vertex weights w: V -> R.
+    weights: Vec<W>,
+}
+
+impl<W: Clone + Default> TryFrom<MaximumCliqueCreateSpec<W>> for MaximumClique<SimpleGraph, W> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MaximumCliqueCreateSpec<W>) -> Result<Self, Self::Error> {
+        if spec.weights.len() != spec.graph.num_vertices() {
+            return Err(format!(
+                "weights has {} entries, expected {}",
+                spec.weights.len(),
+                spec.graph.num_vertices()
+            )
+            .into());
+        }
+        Ok(Self::new(spec.graph, spec.weights))
+    }
+}
+
 impl<G: Graph, W: Clone + Default> MaximumClique<G, W> {
     /// Create a MaximumClique problem from a graph with given weights.
     pub fn new(graph: G, weights: Vec<W>) -> Self {
@@ -96,7 +117,7 @@ impl<G: Graph, W: Clone + Default> MaximumClique<G, W> {
     }
 
     /// Check if a configuration is a valid clique.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_clique_config(&self.graph, config)
     }
 }
@@ -119,37 +140,60 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MaximumClique";
+    type Solution = Vec<bool>;
     type Value = Max<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Max<W::Sum> {
-        if !is_clique_config(&self.graph, config) {
-            return Max(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex-selection length does not match the graph".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.weights[i].to_sum();
+        Ok({
+            if !is_clique_config(&self.graph, config) {
+                return Ok(Max(None));
             }
-        }
-        Max(Some(total))
+            let mut total = W::Sum::zero();
+            for (i, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.weights[i].to_sum(),
+                        "summing selected clique weights",
+                    )?;
+                }
+            }
+            Max(Some(total))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for MaximumClique<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
 /// Check if a configuration forms a valid clique.
-fn is_clique_config<G: Graph>(graph: &G, config: &[usize]) -> bool {
+fn is_clique_config<G: Graph>(graph: &G, config: &[bool]) -> bool {
     // Collect all selected vertices
     let selected: Vec<usize> = config
         .iter()
         .enumerate()
-        .filter(|(_, &v)| v == 1)
+        .filter(|(_, &v)| v)
         .map(|(i, _)| i)
         .collect();
 
@@ -164,20 +208,46 @@ fn is_clique_config<G: Graph>(graph: &G, config: &[usize]) -> bool {
     true
 }
 
+crate::impl_random_generate!(MaximumClique<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    Ok(MaximumClique::new(spec.graph()?, vec![1; spec.num_vertices]))
+});
+crate::impl_random_generate!(MaximumClique<SimpleGraph, One>, crate::random::SimpleGraphRandomSpec, |spec| {
+    Ok(MaximumClique::new(spec.graph()?, vec![One; spec.num_vertices]))
+});
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MaximumCliqueOneCreateSpec {
+    /// The underlying graph.
+    graph: SimpleGraph,
+}
+
+impl TryFrom<MaximumCliqueOneCreateSpec> for MaximumClique<SimpleGraph, One> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MaximumCliqueOneCreateSpec) -> Result<Self, Self::Error> {
+        let weights = vec![One; spec.graph.num_vertices()];
+        Ok(Self::new(spec.graph, weights))
+    }
+}
+
 crate::declare_variants! {
-    MaximumClique<SimpleGraph, i32> => "1.1996^num_vertices",
-    default MaximumClique<SimpleGraph, One> => "1.1996^num_vertices",
+    MaximumClique<SimpleGraph, i64> => "1.1996^num_vertices" create MaximumCliqueCreateSpec<i64> random,
+    default MaximumClique<SimpleGraph, One> => "1.1996^num_vertices" create MaximumCliqueOneCreateSpec random,
+}
+
+crate::register_brute_force! {
+    MaximumClique<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumClique<SimpleGraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "maximum_clique_simplegraph_i32",
+        id: "maximum_clique_simplegraph",
         instance: Box::new(MaximumClique::new(
             SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]),
-            vec![1i32; 5],
+            vec![1i64; 5],
         )),
-        optimal_config: vec![0, 0, 1, 1, 1],
+        optimal_config: serde_json::json!(vec![false, false, true, true, true]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/graph/maximum_co_k_plex.rs b/src/models/graph/maximum_co_k_plex.rs
index 5c691e4e0..29495f0d6 100644
--- a/src/models/graph/maximum_co_k_plex.rs
+++ b/src/models/graph/maximum_co_k_plex.rs
@@ -8,7 +8,7 @@
 //! For k = 1 the problem degenerates to [`MaximumIndependentSet`]; for larger
 //! k it is the maximum (k-1)-dependent set / co-k-plex.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, One, WeightElement};
@@ -23,23 +23,13 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "One", &["One", "i32"]),
+            VariantDimension::new("weight", "One", &["One", "i64"]),
             VariantDimension::new("k", "KN", &["KN"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find maximum-weight vertex subset whose induced subgraph has maximum degree at most k-1",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-            FieldInfo { name: "bound_k", type_name: "usize", description: "Co-k-plex parameter k >= 1; selected-vertex induced degree must be at most k-1" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "MaximumCoKPlex",
-        fields: &["num_vertices", "num_edges"],
+        fields: MaximumCoKPlexCreateSpec::<One>::FIELDS,
     }
 }
 
@@ -53,7 +43,7 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - Graph type (e.g., [`SimpleGraph`]).
-/// * `W` - Weight type (e.g., [`One`], `i32`).
+/// * `W` - Weight type (e.g., [`One`], `i64`).
 /// * `K` - Compile-time [`KValue`] tag. [`KN`] stores `k` at runtime; fixed
 ///   variants (`K1`, `K2`, ...) can be added later by registering more
 ///   `declare_variants!` entries.
@@ -65,7 +55,7 @@ inventory::submit! {
 /// use problemreductions::topology::SimpleGraph;
 /// use problemreductions::types::One;
 /// use problemreductions::variant::KN;
-/// use problemreductions::{BruteForce, Problem, Solver};
+/// use problemreductions::{BruteForce, Problem};
 ///
 /// // 5-cycle C_5 with k = 2 (induced degree <= 1).
 /// let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]);
@@ -91,6 +81,37 @@ pub struct MaximumCoKPlex<G, W, K: KValue> {
     _phantom: std::marker::PhantomData<K>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MaximumCoKPlexCreateSpec<W> {
+    /// The underlying graph G=(V,E).
+    graph: SimpleGraph,
+    /// Vertex weights w: V -> R.
+    weights: Vec<W>,
+    /// Co-k-plex parameter k >= 1.
+    k: usize,
+}
+
+impl<W: Clone + Default> TryFrom<MaximumCoKPlexCreateSpec<W>>
+    for MaximumCoKPlex<SimpleGraph, W, KN>
+{
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: MaximumCoKPlexCreateSpec<W>) -> Result<Self, Self::Error> {
+        if spec.weights.len() != spec.graph.num_vertices() {
+            return Err(format!(
+                "weights has {} entries, expected {}",
+                spec.weights.len(),
+                spec.graph.num_vertices()
+            )
+            .into());
+        }
+        if spec.k == 0 {
+            return Err("k must be at least 1".to_string().into());
+        }
+        Ok(Self::with_k(spec.graph, spec.weights, spec.k))
+    }
+}
+
 impl<G: Graph, W: Clone + Default, K: KValue> MaximumCoKPlex<G, W, K> {
     /// Create an instance with an explicit runtime `k`.
     ///
@@ -153,7 +174,7 @@ impl<G: Graph, W: Clone + Default, K: KValue> MaximumCoKPlex<G, W, K> {
     }
 
     /// Check if a configuration satisfies the co-k-plex constraint.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_co_k_plex_config(&self.graph, config, self.bound_k)
     }
 }
@@ -177,41 +198,65 @@ where
     K: KValue,
 {
     const NAME: &'static str = "MaximumCoKPlex";
+    type Solution = Vec<bool>;
     type Value = Max<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W, K]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Max<W::Sum> {
-        if !is_co_k_plex_config(&self.graph, config, self.bound_k) {
-            return Max(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex-selection length does not match the graph".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.weights[i].to_sum();
+        Ok({
+            if !is_co_k_plex_config(&self.graph, config, self.bound_k) {
+                return Ok(Max(None));
             }
-        }
-        Max(Some(total))
+            let mut total = W::Sum::zero();
+            for (i, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.weights[i].to_sum(),
+                        "summing selected co-k-plex weights",
+                    )?;
+                }
+            }
+            Max(Some(total))
+        })
+    }
+}
+
+impl<G, W, K> crate::solvers::BruteForceProblem for MaximumCoKPlex<G, W, K>
+where
+    G: Graph + VariantParam,
+    W: WeightElement + VariantParam,
+    K: KValue,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
 /// Return true iff every selected vertex has at most `k - 1` selected
 /// neighbours in the induced subgraph.
-fn is_co_k_plex_config<G: Graph>(graph: &G, config: &[usize], bound_k: usize) -> bool {
+fn is_co_k_plex_config<G: Graph>(graph: &G, config: &[bool], bound_k: usize) -> bool {
     if bound_k == 0 {
         return false;
     }
     let n = graph.num_vertices();
     let mut induced_degree = vec![0usize; n];
     for (u, v) in graph.edges() {
-        let u_selected = config.get(u).copied().unwrap_or(0) == 1;
-        let v_selected = config.get(v).copied().unwrap_or(0) == 1;
+        let u_selected = config.get(u).copied().unwrap_or(false);
+        let v_selected = config.get(v).copied().unwrap_or(false);
         if u_selected && v_selected {
             induced_degree[u] += 1;
             induced_degree[v] += 1;
@@ -223,21 +268,44 @@ fn is_co_k_plex_config<G: Graph>(graph: &G, config: &[usize], bound_k: usize) ->
     true
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MaximumCoKPlexOneCreateSpec {
+    /// The underlying graph.
+    graph: SimpleGraph,
+    k: usize,
+}
+
+impl TryFrom<MaximumCoKPlexOneCreateSpec> for MaximumCoKPlex<SimpleGraph, One, KN> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MaximumCoKPlexOneCreateSpec) -> Result<Self, Self::Error> {
+        let weights = vec![One; spec.graph.num_vertices()];
+        if spec.k == 0 {
+            return Err("k must be at least 1".into());
+        }
+        Ok(Self::with_k(spec.graph, weights, spec.k))
+    }
+}
+
 crate::declare_variants! {
-    default MaximumCoKPlex<SimpleGraph, One, KN> => "2^num_vertices",
-    MaximumCoKPlex<SimpleGraph, i32, KN>          => "2^num_vertices",
+    default MaximumCoKPlex<SimpleGraph, One, KN> => "2^num_vertices" create MaximumCoKPlexOneCreateSpec,
+    MaximumCoKPlex<SimpleGraph, i64, KN>          => "2^num_vertices" create MaximumCoKPlexCreateSpec<i64>,
+}
+
+crate::register_brute_force! {
+    MaximumCoKPlex<SimpleGraph, One, KN> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumCoKPlex<SimpleGraph, i64, KN> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "maximum_co_k_plex_simplegraph_i32",
-        instance: Box::new(MaximumCoKPlex::<_, i32, KN>::with_k(
+        id: "maximum_co_k_plex_simplegraph",
+        instance: Box::new(MaximumCoKPlex::<_, i64, KN>::with_k(
             SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]),
             vec![5, 1, 4, 1, 3],
             2,
         )),
-        optimal_config: vec![1, 0, 1, 0, 1],
+        optimal_config: serde_json::json!([true, false, true, false, true]),
         optimal_value: serde_json::json!(12),
     }]
 }
diff --git a/src/models/graph/maximum_common_edge_subgraph.rs b/src/models/graph/maximum_common_edge_subgraph.rs
index d35668c64..179151b64 100644
--- a/src/models/graph/maximum_common_edge_subgraph.rs
+++ b/src/models/graph/maximum_common_edge_subgraph.rs
@@ -12,7 +12,7 @@
 //! `u` is matched to, with the sentinel value `|V2|` denoting "unmatched"
 //! (`bottom`). Feasibility requires injectivity on the matched vertices.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Max;
 use serde::{Deserialize, Serialize};
@@ -23,6 +23,7 @@ inventory::submit! {
         display_name: "Maximum Common Edge Subgraph",
         aliases: &["MCES"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Maximize the number of preserved labelled directed arcs under a partial injective vertex map from G1 into G2",
         fields: &[
@@ -40,13 +41,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "MaximumCommonEdgeSubgraph",
-        fields: &["num_vertices_1", "num_vertices_2", "num_arcs_1", "num_arcs_2"],
-    }
-}
-
 /// A directed labelled arc `(src, label, dst)` in a [`LabelledDigraph`].
 ///
 /// Labels are unsigned integers; the alphabet `Sigma` is encoded by mapping
@@ -56,14 +50,14 @@ pub struct LabelledArc {
     /// Source vertex index.
     pub src: usize,
     /// Edge label.
-    pub label: u32,
+    pub label: usize,
     /// Destination vertex index.
     pub dst: usize,
 }
 
 impl LabelledArc {
     /// Construct a new labelled arc.
-    pub fn new(src: usize, label: u32, dst: usize) -> Self {
+    pub fn new(src: usize, label: usize, dst: usize) -> Self {
         Self { src, label, dst }
     }
 }
@@ -225,13 +219,16 @@ impl MaximumCommonEdgeSubgraph {
 
     /// Count the labelled arcs in `G1` that are preserved by the partial
     /// injective map `config`. Returns `None` if `config` is infeasible.
-    pub fn preserved_arc_count(&self, config: &[usize]) -> Option<usize> {
+    pub fn preserved_arc_count(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         if !self.is_valid_solution(config) {
-            return None;
+            return Ok(None);
         }
         let bottom = self.bottom_index();
         // Build a lookup set of arcs in G2 for O(1) membership checks.
-        let arcs_2: std::collections::HashSet<(usize, u32, usize)> = self
+        let arcs_2: std::collections::HashSet<(usize, usize, usize)> = self
             .graph_2
             .arcs()
             .iter()
@@ -248,27 +245,56 @@ impl MaximumCommonEdgeSubgraph {
                 count += 1;
             }
         }
-        Some(count)
+        Ok(Some(i64::try_from(count).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting preserved-arc count to i64".into(),
+            )
+        })?))
     }
 }
 
 impl Problem for MaximumCommonEdgeSubgraph {
     const NAME: &'static str = "MaximumCommonEdgeSubgraph";
+    type Solution = Vec<usize>;
     type Value = Max<i64>;
 
+    crate::problem_parameters![
+        ("num_arcs_1", num_arcs_1),
+        ("num_arcs_2", num_arcs_2),
+        ("num_vertices_1", num_vertices_1),
+        ("num_vertices_2", num_vertices_2),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.graph_2.num_vertices() + 1; self.graph_1.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.num_vertices_1() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex mapping length does not match the first graph".into(),
+            ));
+        }
+        if config.iter().any(|&vertex| vertex > self.num_vertices_2()) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex mapping contains an out-of-range target vertex".into(),
+            ));
+        }
+        Ok({
+            match self.preserved_arc_count(config)? {
+                Some(count) => Max(Some(count)),
+                None => Max(None),
+            }
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Max<i64> {
-        match self.preserved_arc_count(config) {
-            Some(count) => Max(Some(count as i64)),
-            None => Max(None),
-        }
+impl crate::solvers::BruteForceProblem for MaximumCommonEdgeSubgraph {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.graph_2.num_vertices() + 1; self.graph_1.num_vertices()]
     }
 }
 
@@ -276,6 +302,10 @@ crate::declare_variants! {
     default MaximumCommonEdgeSubgraph => "(num_vertices_2 + 1)^num_vertices_1",
 }
 
+crate::register_brute_force! {
+    MaximumCommonEdgeSubgraph,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -306,7 +336,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         )),
         // 4 encodes bottom because |V2| = 4. The map 0->0, 1->1, 2->2, 3->3,
         // 4->bottom preserves the first five source arcs.
-        optimal_config: vec![0, 1, 2, 3, 4],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 3, 4]),
         optimal_value: serde_json::json!(5),
     }]
 }
diff --git a/src/models/graph/maximum_contact_map_overlap.rs b/src/models/graph/maximum_contact_map_overlap.rs
index a325a83bb..c7f340220 100644
--- a/src/models/graph/maximum_contact_map_overlap.rs
+++ b/src/models/graph/maximum_contact_map_overlap.rs
@@ -14,7 +14,7 @@
 //! Feasibility requires that the non-zero entries are pairwise distinct
 //! (injectivity) and strictly increasing in source order (order-preserving).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Max;
 use serde::{Deserialize, Serialize};
@@ -26,6 +26,7 @@ inventory::submit! {
         display_name: "Maximum Contact Map Overlap",
         aliases: &["CMO", "MaxCMO"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Maximize the number of preserved contacts under an order-preserving partial injective alignment from G_1 into G_2",
         fields: &[
@@ -53,13 +54,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "MaximumContactMapOverlap",
-        fields: &["num_vertices_1", "num_vertices_2", "num_contacts_1", "num_contacts_2"],
-    }
-}
-
 /// The Maximum Contact Map Overlap problem.
 ///
 /// Given two finite ordered contact maps `G_1 = (V_1, E_1)` and
@@ -196,9 +190,12 @@ impl MaximumContactMapOverlap {
 
     /// Count contacts of `G_1` preserved by the alignment `config`. Returns
     /// `None` if `config` is infeasible.
-    pub fn preserved_contact_count(&self, config: &[usize]) -> Option<usize> {
+    pub fn preserved_contact_count(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         if !self.is_valid_solution(config) {
-            return None;
+            return Ok(None);
         }
         let contacts_2_set: HashSet<(usize, usize)> = self.contacts_2.iter().copied().collect();
         let mut count = 0usize;
@@ -216,27 +213,56 @@ impl MaximumContactMapOverlap {
                 count += 1;
             }
         }
-        Some(count)
+        Ok(Some(i64::try_from(count).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting preserved-contact count to i64".into(),
+            )
+        })?))
     }
 }
 
 impl Problem for MaximumContactMapOverlap {
     const NAME: &'static str = "MaximumContactMapOverlap";
+    type Solution = Vec<usize>;
     type Value = Max<i64>;
 
+    crate::problem_parameters![
+        ("num_contacts_1", num_contacts_1),
+        ("num_contacts_2", num_contacts_2),
+        ("num_vertices_1", num_vertices_1),
+        ("num_vertices_2", num_vertices_2),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_vertices_2 + 1; self.num_vertices_1]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.num_vertices_1 {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "contact-map alignment length does not match the first map".into(),
+            ));
+        }
+        if config.iter().any(|&vertex| vertex > self.num_vertices_2) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "contact-map alignment contains an out-of-range target vertex".into(),
+            ));
+        }
+        Ok({
+            match self.preserved_contact_count(config)? {
+                Some(count) => Max(Some(count)),
+                None => Max(None),
+            }
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Max<i64> {
-        match self.preserved_contact_count(config) {
-            Some(count) => Max(Some(count as i64)),
-            None => Max(None),
-        }
+impl crate::solvers::BruteForceProblem for MaximumContactMapOverlap {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_vertices_2 + 1; self.num_vertices_1]
     }
 }
 
@@ -244,6 +270,10 @@ crate::declare_variants! {
     default MaximumContactMapOverlap => "(num_vertices_2 + 1)^num_vertices_1",
 }
 
+crate::register_brute_force! {
+    MaximumContactMapOverlap,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // Canonical example from the issue:
@@ -263,7 +293,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             5,
             vec![(0, 3), (1, 4), (0, 2)],
         )),
-        optimal_config: vec![1, 2, 4, 5],
+        optimal_config: serde_json::json!(vec![1, 2, 4, 5]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/graph/maximum_domatic_number.rs b/src/models/graph/maximum_domatic_number.rs
index 1052f6163..fce59b0e1 100644
--- a/src/models/graph/maximum_domatic_number.rs
+++ b/src/models/graph/maximum_domatic_number.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find maximum number of disjoint dominating sets partitioning V",
         fields: &[
@@ -40,15 +41,15 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MaximumDomaticNumber;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Path graph P3: 0-1-2
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
 /// let problem = MaximumDomaticNumber::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem).unwrap();
-/// let value = problem.evaluate(&witness);
+/// let witness = solver.solve(&problem).unwrap().unwrap();
+/// let value = problem.evaluate(&witness).unwrap();
 /// // Domatic number of P3 is 2
 /// assert_eq!(value, problemreductions::types::Max(Some(2)));
 /// ```
@@ -135,27 +136,65 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MaximumDomaticNumber";
-    type Value = Max<usize>;
+    type Solution = Vec<usize>;
+    type Value = Max<i64>;
+
+    crate::problem_parameters![("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
         let n = self.graph.num_vertices();
-        vec![n; n]
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&part| part >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment contains an out-of-range part".into(),
+            ));
+        }
+        Ok({
+            match self.evaluate_partition(config) {
+                Some(k) => Max(Some(i64::try_from(k).map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting domatic number to i64".into(),
+                    )
+                })?)),
+                None => Max(None),
+            }
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Max<usize> {
-        match self.evaluate_partition(config) {
-            Some(k) => Max(Some(k)),
-            None => Max(None),
-        }
+impl<G> crate::solvers::BruteForceProblem for MaximumDomaticNumber<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.graph.num_vertices();
+        vec![n; n]
     }
 }
 
+crate::impl_random_generate!(
+    MaximumDomaticNumber<SimpleGraph>,
+    crate::random::SimpleGraphRandomSpec,
+    |spec| { Ok(MaximumDomaticNumber::new(spec.graph()?)) }
+);
+
 crate::declare_variants! {
-    default MaximumDomaticNumber<SimpleGraph> => "2.695^num_vertices",
+    default MaximumDomaticNumber<SimpleGraph> => "2.695^num_vertices" random,
+}
+
+crate::register_brute_force! {
+    MaximumDomaticNumber<SimpleGraph>,
 }
 
 #[cfg(feature = "example-db")]
@@ -175,7 +214,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 (4, 5),
             ],
         ))),
-        optimal_config: vec![0, 1, 2, 0, 2, 1],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 0, 2, 1]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/graph/maximum_edge_weighted_k_clique.rs b/src/models/graph/maximum_edge_weighted_k_clique.rs
index 9babdbebc..9ba384908 100644
--- a/src/models/graph/maximum_edge_weighted_k_clique.rs
+++ b/src/models/graph/maximum_edge_weighted_k_clique.rs
@@ -11,7 +11,7 @@
 //! are allowed when `k` takes those values, with objective value 0 because no
 //! pair of selected vertices is induced.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry, VariantDimension};
+use crate::registry::{ConstructionError, CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, WeightElement};
@@ -23,21 +23,11 @@ inventory::submit! {
         name: "MaximumEdgeWeightedKClique",
         display_name: "Maximum Edge-Weighted k-Clique",
         aliases: &[],
-        dimensions: &[VariantDimension::new("weight", "i32", &["i32", "f64"])],
+        dimensions: &[VariantDimension::new("weight", "i64", &["i64", "f64"])],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Select exactly k pairwise-adjacent vertices maximizing the total weight of induced clique edges",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "SimpleGraph", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge weights in graph edge order" },
-            FieldInfo { name: "k", type_name: "usize", description: "Required clique size" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "MaximumEdgeWeightedKClique",
-        fields: &["num_vertices", "num_edges"],
+        fields: MaximumEdgeWeightedKCliqueCreateSpec::<i64>::FIELDS,
     }
 }
 
@@ -50,7 +40,7 @@ inventory::submit! {
 ///
 /// # Type Parameters
 ///
-/// * `W` - Edge weight type (e.g., `i32`, `f64`). The graph is fixed to
+/// * `W` - Edge weight type (e.g., `i64`, `f64`). The graph is fixed to
 ///   [`SimpleGraph`] in the current registered variants.
 ///
 /// # Example
@@ -59,15 +49,16 @@ inventory::submit! {
 /// use problemreductions::models::graph::MaximumEdgeWeightedKClique;
 /// use problemreductions::topology::SimpleGraph;
 /// use problemreductions::types::Max;
-/// use problemreductions::{BruteForce, Problem, Solver};
+/// use problemreductions::{BruteForce, Problem};
 ///
 /// // Graph from issue #1020: 4 vertices, triangles {0,1,2} and {0,1,3}.
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]);
-/// let weights = vec![5_i32, 4, -1, 1, 0];
-/// let problem = MaximumEdgeWeightedKClique::new(graph, weights, 3);
-/// assert_eq!(BruteForce::new().solve(&problem), Max(Some(8)));
+/// let weights = vec![5_i64, 4, -1, 1, 0];
+/// let problem = MaximumEdgeWeightedKClique::new(graph, weights, 3).unwrap();
+/// let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+/// assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(8)));
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct MaximumEdgeWeightedKClique<W: WeightElement> {
     /// The underlying graph.
     graph: SimpleGraph,
@@ -77,29 +68,76 @@ pub struct MaximumEdgeWeightedKClique<W: WeightElement> {
     k: usize,
 }
 
+#[derive(Deserialize)]
+struct MaximumEdgeWeightedKCliqueData<W> {
+    graph: SimpleGraph,
+    edge_weights: Vec<W>,
+    k: usize,
+}
+
+impl<'de, W> Deserialize<'de> for MaximumEdgeWeightedKClique<W>
+where
+    W: WeightElement + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let data = MaximumEdgeWeightedKCliqueData::deserialize(deserializer)?;
+        Self::new(data.graph, data.edge_weights, data.k).map_err(serde::de::Error::custom)
+    }
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MaximumEdgeWeightedKCliqueCreateSpec<W> {
+    /// The underlying graph.
+    graph: SimpleGraph,
+    /// Edge weights; defaults to one per edge.
+    edge_weights: Option<Vec<W>>,
+    /// Required clique size.
+    k: usize,
+}
+impl<W> TryFrom<MaximumEdgeWeightedKCliqueCreateSpec<W>> for MaximumEdgeWeightedKClique<W>
+where
+    W: WeightElement,
+{
+    type Error = ConstructionError;
+    fn try_from(spec: MaximumEdgeWeightedKCliqueCreateSpec<W>) -> Result<Self, Self::Error> {
+        let count = spec.graph.num_edges();
+        let edge_weights = spec
+            .edge_weights
+            .unwrap_or_else(|| (0..count).map(|_| W::unit()).collect());
+        Self::new(spec.graph, edge_weights, spec.k)
+    }
+}
+
 impl<W: WeightElement> MaximumEdgeWeightedKClique<W> {
     /// Create a new MaximumEdgeWeightedKClique instance.
     ///
-    /// # Panics
-    /// Panics if `edge_weights.len()` does not match `graph.num_edges()`, or
-    /// if `k > graph.num_vertices()`.
-    pub fn new(graph: SimpleGraph, edge_weights: Vec<W>, k: usize) -> Self {
-        assert_eq!(
-            edge_weights.len(),
-            graph.num_edges(),
-            "edge_weights length must match graph num_edges"
-        );
-        assert!(
-            k <= graph.num_vertices(),
-            "k = {} must be <= num_vertices = {}",
-            k,
-            graph.num_vertices()
-        );
-        Self {
+    pub fn new(
+        graph: SimpleGraph,
+        edge_weights: Vec<W>,
+        k: usize,
+    ) -> Result<Self, ConstructionError> {
+        if edge_weights.len() != graph.num_edges() {
+            return Err(ConstructionError::Conversion(
+                "edge_weights length must match graph num_edges".into(),
+            ));
+        }
+        for (index, weight) in edge_weights.iter().enumerate() {
+            weight.validate_element(&format!("edge weight at index {index}"))?;
+        }
+        if k > graph.num_vertices() {
+            return Err(ConstructionError::Conversion(format!(
+                "k = {k} must be <= num_vertices = {}",
+                graph.num_vertices()
+            )));
+        }
+        Ok(Self {
             graph,
             edge_weights,
             k,
-        }
+        })
     }
 
     /// Get a reference to the underlying graph.
@@ -128,7 +166,7 @@ impl<W: WeightElement> MaximumEdgeWeightedKClique<W> {
     }
 
     /// Check whether the selected vertices form a clique of size exactly `k`.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_k_clique_config(&self.graph, config, self.k)
     }
 }
@@ -138,35 +176,57 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MaximumEdgeWeightedKClique";
+    type Solution = Vec<bool>;
     type Value = Max<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Max<W::Sum> {
-        if !is_k_clique_config(&self.graph, config, self.k) {
-            return Max(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex-selection length does not match the graph".into(),
+            ));
         }
-        // Sum weights of edges whose both endpoints are selected.
-        let mut total = W::Sum::zero();
-        for ((u, v), weight) in self.graph.edges().iter().zip(self.edge_weights.iter()) {
-            if config.get(*u).copied().unwrap_or(0) == 1
-                && config.get(*v).copied().unwrap_or(0) == 1
-            {
-                total += weight.to_sum();
+        Ok({
+            if !is_k_clique_config(&self.graph, config, self.k) {
+                return Ok(Max(None));
             }
-        }
-        Max(Some(total))
+            // Sum weights of edges whose both endpoints are selected.
+            let mut total = W::Sum::zero();
+            for ((u, v), weight) in self.graph.edges().iter().zip(self.edge_weights.iter()) {
+                if config.get(*u).copied().unwrap_or(false)
+                    && config.get(*v).copied().unwrap_or(false)
+                {
+                    total = W::checked_add_to_sum(
+                        total,
+                        weight.to_sum(),
+                        "summing selected clique-edge weights",
+                    )?;
+                }
+            }
+            Max(Some(total))
+        })
+    }
+}
+
+impl<W> crate::solvers::BruteForceProblem for MaximumEdgeWeightedKClique<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
 /// Check whether `config` selects exactly `k` vertices that form a clique.
-fn is_k_clique_config(graph: &SimpleGraph, config: &[usize], k: usize) -> bool {
+fn is_k_clique_config(graph: &SimpleGraph, config: &[bool], k: usize) -> bool {
     let n = graph.num_vertices();
     if config.len() != n {
         return false;
@@ -174,7 +234,7 @@ fn is_k_clique_config(graph: &SimpleGraph, config: &[usize], k: usize) -> bool {
     let selected: Vec<usize> = config
         .iter()
         .enumerate()
-        .filter(|(_, &v)| v == 1)
+        .filter(|(_, &selected)| selected)
         .map(|(i, _)| i)
         .collect();
     if selected.len() != k {
@@ -191,20 +251,28 @@ fn is_k_clique_config(graph: &SimpleGraph, config: &[usize], k: usize) -> bool {
 }
 
 crate::declare_variants! {
-    default MaximumEdgeWeightedKClique<i32> => "2^num_vertices",
-    MaximumEdgeWeightedKClique<f64>         => "2^num_vertices",
+    default MaximumEdgeWeightedKClique<i64> => "2^num_vertices" create MaximumEdgeWeightedKCliqueCreateSpec<i64>,
+    MaximumEdgeWeightedKClique<f64>         => "2^num_vertices" create MaximumEdgeWeightedKCliqueCreateSpec<f64>,
+}
+
+crate::register_brute_force! {
+    MaximumEdgeWeightedKClique<i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumEdgeWeightedKClique<f64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "maximum_edge_weighted_k_clique_simplegraph_i32",
-        instance: Box::new(MaximumEdgeWeightedKClique::<i32>::new(
-            SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
-            vec![5, 4, -1, 1, 0],
-            3,
-        )),
-        optimal_config: vec![1, 1, 1, 0],
+        id: "maximum_edge_weighted_k_clique_simplegraph",
+        instance: Box::new(
+            MaximumEdgeWeightedKClique::<i64>::new(
+                SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
+                vec![5, 4, -1, 1, 0],
+                3,
+            )
+            .unwrap(),
+        ),
+        optimal_config: serde_json::json!(vec![true, true, true, false]),
         optimal_value: serde_json::json!(8),
     }]
 }
diff --git a/src/models/graph/maximum_independent_set.rs b/src/models/graph/maximum_independent_set.rs
index 9f7e72a08..55723eb26 100644
--- a/src/models/graph/maximum_independent_set.rs
+++ b/src/models/graph/maximum_independent_set.rs
@@ -3,7 +3,9 @@
 //! The Independent Set problem asks for a maximum weight subset of vertices
 //! such that no two vertices in the subset are adjacent.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{
+    ConstructionError, CreateSpec, FieldInfo, ProblemSchemaEntry, VariantDimension,
+};
 use crate::topology::{Graph, KingsSubgraph, SimpleGraph, TriangularSubgraph, UnitDiskGraph};
 use crate::traits::Problem;
 use crate::types::{Max, One, WeightElement};
@@ -17,14 +19,12 @@ inventory::submit! {
         aliases: &["MIS"],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph", "KingsSubgraph", "TriangularSubgraph", "UnitDiskGraph"]),
-            VariantDimension::new("weight", "One", &["One", "i32"]),
+            VariantDimension::new("weight", "One", &["One", "i64", "f64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find maximum weight independent set in a graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-        ],
+        fields: MaximumIndependentSetSimpleI64CreateSpec::FIELDS,
     }
 }
 
@@ -38,14 +38,14 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`, `KingsSubgraph`, `UnitDiskGraph`)
-/// * `W` - The weight type (e.g., `i32`, `f64`, `One`)
+/// * `W` - The weight type (e.g., `i64`, `f64`, `One`)
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::graph::MaximumIndependentSet;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Create a triangle graph (3 vertices, 3 edges)
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
@@ -53,10 +53,10 @@ inventory::submit! {
 ///
 /// // Solve with brute force
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Maximum independent set in a triangle has size 1
-/// assert!(solutions.iter().all(|s| s.iter().sum::<usize>() == 1));
+/// assert!(solutions.iter().all(|s| s.iter().filter(|&&selected| selected).count() == 1));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MaximumIndependentSet<G, W> {
@@ -66,6 +66,150 @@ pub struct MaximumIndependentSet<G, W> {
     weights: Vec<W>,
 }
 
+macro_rules! simple_mis_spec {
+    ($name:ident,$weight:ty,$one:expr $(, $weights:ident)?) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            #[create(codec = "edge-list")]
+            graph: Vec<(usize, usize)>,
+            num_vertices: Option<usize>,
+            $(
+            #[create(codec = "comma-separated")]
+            $weights: Option<Vec<$weight>>,
+            )?
+        }
+        impl TryFrom<$name> for MaximumIndependentSet<SimpleGraph, $weight> {
+            type Error = crate::registry::ConstructionError;
+            fn try_from(spec: $name) -> Result<Self, crate::registry::ConstructionError> {
+                if spec.graph.is_empty() && spec.num_vertices.is_none() {
+                    return Err("num_vertices is required for an empty graph".into());
+                }
+                for &(u, v) in &spec.graph {
+                    if u == v {
+                        return Err("self-loops are not allowed".into());
+                    }
+                }
+                let inferred = spec
+                    .graph
+                    .iter()
+                    .flat_map(|&(u, v)| [u, v])
+                    .max()
+                    .map(|v| v.checked_add(1).ok_or("vertex count overflows usize"))
+                    .transpose()?
+                    .unwrap_or(0);
+                let count = spec.num_vertices.unwrap_or(inferred);
+                if count < inferred {
+                    return Err("num_vertices is too small".into());
+                }
+                let weights = { $(if let Some(value) = spec.$weights { value } else)? { vec![$one; count] } };
+                if weights.len() != count {
+                    return Err("weights length must match num_vertices".into());
+                }
+                Ok(Self {
+                    graph: SimpleGraph::new(count, spec.graph),
+                    weights,
+                })
+            }
+        }
+    };
+}
+simple_mis_spec!(MaximumIndependentSetSimpleOneCreateSpec, One, One);
+simple_mis_spec!(
+    MaximumIndependentSetSimpleI64CreateSpec,
+    i64,
+    1_i64,
+    weights
+);
+simple_mis_spec!(
+    MaximumIndependentSetSimpleF64CreateSpec,
+    f64,
+    1_f64,
+    weights
+);
+
+macro_rules! grid_mis_spec {
+    ($name:ident,$graph:ty,$weight:ty,$one:expr $(, $weights:ident)?) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            positions: Vec<(i64, i64)>,
+            $(
+            #[create(codec = "comma-separated")]
+            $weights: Option<Vec<$weight>>,
+            )?
+        }
+        impl TryFrom<$name> for MaximumIndependentSet<$graph, $weight> {
+            type Error = crate::registry::ConstructionError;
+            fn try_from(spec: $name) -> Result<Self, crate::registry::ConstructionError> {
+                let weights = { $(if let Some(value) = spec.$weights { value } else)? { vec![$one; spec.positions.len()] } };
+                if weights.len() != spec.positions.len() {
+                    return Err("weights length must match positions length".into());
+                }
+                Ok(Self {
+                    graph: <$graph>::new(spec.positions),
+                    weights,
+                })
+            }
+        }
+    };
+}
+grid_mis_spec!(
+    MaximumIndependentSetKingsOneCreateSpec,
+    KingsSubgraph,
+    One,
+    One
+);
+grid_mis_spec!(
+    MaximumIndependentSetKingsI64CreateSpec,
+    KingsSubgraph,
+    i64,
+    1_i64,
+    weights
+);
+grid_mis_spec!(
+    MaximumIndependentSetTriangularI64CreateSpec,
+    TriangularSubgraph,
+    i64,
+    1_i64,
+    weights
+);
+
+macro_rules! unit_disk_mis_spec {
+    ($name:ident,$weight:ty,$one:expr $(, $weights:ident)?) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            positions: Vec<(f64, f64)>,
+            radius: Option<f64>,
+            $(
+            #[create(codec = "comma-separated")]
+            $weights: Option<Vec<$weight>>,
+            )?
+        }
+        impl TryFrom<$name> for MaximumIndependentSet<UnitDiskGraph, $weight> {
+            type Error = ConstructionError;
+            fn try_from(spec: $name) -> Result<Self, ConstructionError> {
+                let radius = spec.radius.unwrap_or(1.0);
+                let weights = { $(if let Some(value) = spec.$weights { value } else)? { vec![$one; spec.positions.len()] } };
+                if weights.len() != spec.positions.len() {
+                    return Err(ConstructionError::Conversion(
+                        "weights length must match positions length".into(),
+                    ));
+                }
+                Ok(Self {
+                    graph: UnitDiskGraph::new(spec.positions, radius)?,
+                    weights,
+                })
+            }
+        }
+    };
+}
+unit_disk_mis_spec!(MaximumIndependentSetUnitDiskOneCreateSpec, One, One);
+unit_disk_mis_spec!(
+    MaximumIndependentSetUnitDiskI64CreateSpec,
+    i64,
+    1_i64,
+    weights
+);
+
 impl<G: Graph, W: Clone + Default> MaximumIndependentSet<G, W> {
     /// Create an Independent Set problem from a graph with given weights.
     pub fn new(graph: G, weights: Vec<W>) -> Self {
@@ -96,7 +240,7 @@ impl<G: Graph, W: Clone + Default> MaximumIndependentSet<G, W> {
     }
 
     /// Check if a configuration is a valid independent set.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_independent_set_config(&self.graph, config)
     }
 }
@@ -119,48 +263,114 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MaximumIndependentSet";
+    type Solution = Vec<bool>;
     type Value = Max<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Max<W::Sum>, crate::traits::EvaluationError> {
+        Ok({
+            if solution.len() != self.graph.num_vertices() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    format!(
+                        "solution has {} variables, expected {}",
+                        solution.len(),
+                        self.graph.num_vertices()
+                    ),
+                ));
+            }
+            if !is_independent_set_config(&self.graph, solution) {
+                return Ok(Max(None));
+            }
+            let mut total = W::Sum::zero();
+            for (i, &selected) in solution.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.weights[i].to_sum(),
+                        "summing selected independent-set weights",
+                    )?;
+                }
+            }
+            Max(Some(total))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Max<W::Sum> {
-        if !is_independent_set_config(&self.graph, config) {
-            return Max(None);
-        }
-        let mut total = W::Sum::zero();
-        for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.weights[i].to_sum();
-            }
-        }
-        Max(Some(total))
+impl<G, W> crate::solvers::BruteForceProblem for MaximumIndependentSet<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
 /// Check if a configuration forms a valid independent set.
-fn is_independent_set_config<G: Graph>(graph: &G, config: &[usize]) -> bool {
+fn is_independent_set_config<G: Graph>(graph: &G, config: &[bool]) -> bool {
     for (u, v) in graph.edges() {
-        if config.get(u).copied().unwrap_or(0) == 1 && config.get(v).copied().unwrap_or(0) == 1 {
+        if config.get(u).copied().unwrap_or(false) && config.get(v).copied().unwrap_or(false) {
             return false;
         }
     }
     true
 }
 
+crate::impl_random_generate!(MaximumIndependentSet<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    Ok(MaximumIndependentSet::new(spec.graph()?, vec![1; spec.num_vertices]))
+});
+crate::impl_random_generate!(MaximumIndependentSet<SimpleGraph, One>, crate::random::SimpleGraphRandomSpec, |spec| {
+    Ok(MaximumIndependentSet::new(spec.graph()?, vec![One; spec.num_vertices]))
+});
+crate::impl_random_generate!(MaximumIndependentSet<KingsSubgraph, i64>, crate::random::IntegerGeometryRandomSpec, |spec| {
+    let seed = crate::random::seed_to_u64(spec.seed)?;
+    Ok(MaximumIndependentSet::new(KingsSubgraph::new(crate::random::create_random_int_positions(spec.num_vertices, seed)), vec![1; spec.num_vertices]))
+});
+crate::impl_random_generate!(MaximumIndependentSet<KingsSubgraph, One>, crate::random::IntegerGeometryRandomSpec, |spec| {
+    let seed = crate::random::seed_to_u64(spec.seed)?;
+    Ok(MaximumIndependentSet::new(KingsSubgraph::new(crate::random::create_random_int_positions(spec.num_vertices, seed)), vec![One; spec.num_vertices]))
+});
+crate::impl_random_generate!(MaximumIndependentSet<TriangularSubgraph, i64>, crate::random::IntegerGeometryRandomSpec, |spec| {
+    let seed = crate::random::seed_to_u64(spec.seed)?;
+    Ok(MaximumIndependentSet::new(TriangularSubgraph::new(crate::random::create_random_int_positions(spec.num_vertices, seed)), vec![1; spec.num_vertices]))
+});
+crate::impl_random_generate!(MaximumIndependentSet<UnitDiskGraph, i64>, crate::random::UnitDiskRandomSpec, |spec| {
+    let seed = crate::random::seed_to_u64(spec.seed)?;
+    Ok(MaximumIndependentSet::new(UnitDiskGraph::new(crate::random::create_random_float_positions(spec.num_vertices, seed), spec.radius.unwrap_or(1.0))?, vec![1; spec.num_vertices]))
+});
+crate::impl_random_generate!(MaximumIndependentSet<UnitDiskGraph, One>, crate::random::UnitDiskRandomSpec, |spec| {
+    let seed = crate::random::seed_to_u64(spec.seed)?;
+    Ok(MaximumIndependentSet::new(UnitDiskGraph::new(crate::random::create_random_float_positions(spec.num_vertices, seed), spec.radius.unwrap_or(1.0))?, vec![One; spec.num_vertices]))
+});
+
 crate::declare_variants! {
-    MaximumIndependentSet<SimpleGraph, i32>        => "1.1996^num_vertices",
-    default MaximumIndependentSet<SimpleGraph, One>         => "1.1996^num_vertices",
-    MaximumIndependentSet<KingsSubgraph, i32>      => "2^sqrt(num_vertices)",
-    MaximumIndependentSet<KingsSubgraph, One>       => "2^sqrt(num_vertices)",
-    MaximumIndependentSet<TriangularSubgraph, i32> => "2^sqrt(num_vertices)",
-    MaximumIndependentSet<UnitDiskGraph, i32>      => "2^sqrt(num_vertices)",
-    MaximumIndependentSet<UnitDiskGraph, One>       => "2^sqrt(num_vertices)",
+    MaximumIndependentSet<SimpleGraph, i64> => "1.1996^num_vertices" create MaximumIndependentSetSimpleI64CreateSpec random,
+    default MaximumIndependentSet<SimpleGraph, One> => "1.1996^num_vertices" create MaximumIndependentSetSimpleOneCreateSpec random,
+    MaximumIndependentSet<KingsSubgraph, i64> => "2^sqrt(num_vertices)" create MaximumIndependentSetKingsI64CreateSpec random,
+    MaximumIndependentSet<KingsSubgraph, One> => "2^sqrt(num_vertices)" create MaximumIndependentSetKingsOneCreateSpec random,
+    MaximumIndependentSet<TriangularSubgraph, i64> => "2^sqrt(num_vertices)" create MaximumIndependentSetTriangularI64CreateSpec random,
+    MaximumIndependentSet<UnitDiskGraph, i64> => "2^sqrt(num_vertices)" create MaximumIndependentSetUnitDiskI64CreateSpec random,
+    MaximumIndependentSet<UnitDiskGraph, One> => "2^sqrt(num_vertices)" create MaximumIndependentSetUnitDiskOneCreateSpec random,
+    MaximumIndependentSet<SimpleGraph, f64> => "2^num_vertices" create MaximumIndependentSetSimpleF64CreateSpec,
+}
+
+crate::register_brute_force! {
+    MaximumIndependentSet<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumIndependentSet<SimpleGraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumIndependentSet<KingsSubgraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumIndependentSet<KingsSubgraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumIndependentSet<TriangularSubgraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumIndependentSet<UnitDiskGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumIndependentSet<UnitDiskGraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumIndependentSet<SimpleGraph, f64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 impl<G, W> crate::models::decision::DecisionProblemMeta for MaximumIndependentSet<G, W>
@@ -172,11 +382,45 @@ where
     const DECISION_NAME: &'static str = "DecisionMaximumIndependentSet";
 }
 
+impl<W> crate::models::decision::Decision<MaximumIndependentSet<SimpleGraph, W>>
+where
+    W: WeightElement + crate::variant::VariantParam,
+    W::Sum: std::fmt::Debug + serde::Serialize + serde::de::DeserializeOwned,
+{
+    pub fn num_vertices(&self) -> usize {
+        self.inner().num_vertices()
+    }
+
+    pub fn num_edges(&self) -> usize {
+        self.inner().num_edges()
+    }
+}
+
+crate::register_decision_variant!(
+    MaximumIndependentSet<SimpleGraph, i64>,
+    "DecisionMaximumIndependentSet",
+    "1.1996^num_vertices",
+    &["DMIS", "IndependentSet"],
+    "Decision version: does an independent set of weight at least the bound exist?",
+    category: crate::registry::ProblemCategory::Graph,
+    dims: [
+        VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
+        VariantDimension::new("weight", "i64", &["i64", "One"]),
+    ],
+    fields: [
+        FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
+        FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
+        FieldInfo { name: "bound", type_name: "W::Sum", description: "Decision bound (minimum required independent-set weight)" },
+    ],
+    additional: [MaximumIndependentSet<SimpleGraph, One> => "1.1996^num_vertices"],
+    decode: |_, indices: Vec<usize>| crate::config::config_to_bits(&indices)
+);
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![
         crate::example_db::specs::ModelExampleSpec {
-            id: "maximum_independent_set_simplegraph_one",
+            id: "maximum_independent_set_petersen_graph",
             instance: Box::new(MaximumIndependentSet::new(
                 SimpleGraph::new(
                     10,
@@ -200,11 +444,13 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 ),
                 vec![One; 10],
             )),
-            optimal_config: vec![1, 0, 1, 0, 0, 0, 0, 0, 1, 1],
+            optimal_config: serde_json::json!(vec![
+                true, false, true, false, false, false, false, false, true, true
+            ]),
             optimal_value: serde_json::json!(4),
         },
         crate::example_db::specs::ModelExampleSpec {
-            id: "maximum_independent_set_simplegraph_i32",
+            id: "maximum_independent_set_simplegraph",
             instance: Box::new(MaximumIndependentSet::new(
                 SimpleGraph::new(
                     10,
@@ -228,12 +474,81 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 ),
                 vec![5, 1, 1, 1, 1, 3, 1, 1, 1, 3],
             )),
-            optimal_config: vec![1, 0, 1, 0, 0, 0, 0, 0, 1, 1],
+            optimal_config: serde_json::json!(vec![
+                true, false, true, false, false, false, false, false, true, true
+            ]),
             optimal_value: serde_json::json!(10),
         },
     ]
 }
 
+#[cfg(feature = "example-db")]
+pub(crate) fn decision_canonical_model_example_specs(
+) -> Vec<crate::example_db::specs::ModelExampleSpec> {
+    vec![
+        crate::example_db::specs::ModelExampleSpec {
+            id: "decision_maximum_independent_set_simplegraph",
+            instance: Box::new(crate::models::decision::Decision::new(
+                MaximumIndependentSet::new(SimpleGraph::path(4), vec![1i64; 4]),
+                2,
+            )),
+            optimal_config: serde_json::json!(vec![true, false, true, false]),
+            optimal_value: serde_json::json!(true),
+        },
+        crate::example_db::specs::ModelExampleSpec {
+            id: "decision_maximum_independent_set_unit",
+            instance: Box::new(crate::models::decision::Decision::new(
+                MaximumIndependentSet::new(SimpleGraph::path(3), vec![One; 3]),
+                2,
+            )),
+            optimal_config: serde_json::json!(vec![true, false, true]),
+            optimal_value: serde_json::json!(true),
+        },
+    ]
+}
+
+#[cfg(feature = "example-db")]
+pub(crate) fn decision_canonical_rule_example_specs(
+) -> Vec<crate::example_db::specs::RuleExampleSpec> {
+    use crate::example_db::specs::{rule_example_with_witness, RuleExampleSpec};
+    use crate::export::SolutionPair;
+    use crate::models::decision::Decision;
+    vec![
+        RuleExampleSpec {
+            id: "decision_maximum_independent_set_to_maximum_independent_set",
+            build: || {
+                let source = Decision::new(
+                    MaximumIndependentSet::new(SimpleGraph::path(4), vec![1i64; 4]),
+                    2,
+                );
+                rule_example_with_witness::<_, MaximumIndependentSet<SimpleGraph, i64>>(
+                    source,
+                    SolutionPair {
+                        source_config: serde_json::json!([true, false, true, false]),
+                        target_config: serde_json::json!([true, false, true, false]),
+                    },
+                )
+            },
+        },
+        RuleExampleSpec {
+            id: "decision_maximum_independent_set_unit_to_maximum_independent_set",
+            build: || {
+                let source = Decision::new(
+                    MaximumIndependentSet::new(SimpleGraph::path(3), vec![One; 3]),
+                    2,
+                );
+                rule_example_with_witness::<_, MaximumIndependentSet<SimpleGraph, One>>(
+                    source,
+                    SolutionPair {
+                        source_config: serde_json::json!([true, false, true]),
+                        target_config: serde_json::json!([true, false, true]),
+                    },
+                )
+            },
+        },
+    ]
+}
+
 /// Check if a set of vertices forms an independent set.
 ///
 /// # Arguments
diff --git a/src/models/graph/maximum_leaf_spanning_tree.rs b/src/models/graph/maximum_leaf_spanning_tree.rs
index 7fbf46b8c..9a8c8d3bd 100644
--- a/src/models/graph/maximum_leaf_spanning_tree.rs
+++ b/src/models/graph/maximum_leaf_spanning_tree.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find spanning tree maximizing the number of leaves",
         fields: &[
@@ -76,7 +77,7 @@ impl<G: Graph> MaximumLeafSpanningTree<G> {
     }
 
     /// Check if a configuration is a valid spanning tree.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_valid_spanning_tree(&self.graph, config)
     }
 }
@@ -84,7 +85,7 @@ impl<G: Graph> MaximumLeafSpanningTree<G> {
 /// Check if a configuration forms a valid spanning tree:
 /// 1. Exactly n-1 edges selected
 /// 2. Selected edges form a connected subgraph (which, combined with n-1 edges, implies a tree)
-fn is_valid_spanning_tree<G: Graph>(graph: &G, config: &[usize]) -> bool {
+fn is_valid_spanning_tree<G: Graph>(graph: &G, config: &[bool]) -> bool {
     let n = graph.num_vertices();
     let edges = graph.edges();
     if config.len() != edges.len() {
@@ -92,7 +93,7 @@ fn is_valid_spanning_tree<G: Graph>(graph: &G, config: &[usize]) -> bool {
     }
 
     // Count selected edges
-    let selected_count: usize = config.iter().sum();
+    let selected_count = config.iter().filter(|&&selected| selected).count();
     if selected_count != n - 1 {
         return false;
     }
@@ -100,7 +101,7 @@ fn is_valid_spanning_tree<G: Graph>(graph: &G, config: &[usize]) -> bool {
     // Build adjacency from selected edges and check connectivity via BFS
     let mut adj: Vec<Vec<usize>> = vec![vec![]; n];
     for (idx, &sel) in config.iter().enumerate() {
-        if sel == 1 {
+        if sel {
             let (u, v) = edges[idx];
             adj[u].push(v);
             adj[v].push(u);
@@ -126,12 +127,12 @@ fn is_valid_spanning_tree<G: Graph>(graph: &G, config: &[usize]) -> bool {
 }
 
 /// Count the number of leaves (degree-1 vertices) in the tree defined by the config.
-fn count_leaves<G: Graph>(graph: &G, config: &[usize]) -> usize {
+fn count_leaves<G: Graph>(graph: &G, config: &[bool]) -> usize {
     let n = graph.num_vertices();
     let edges = graph.edges();
     let mut degree = vec![0usize; n];
     for (idx, &sel) in config.iter().enumerate() {
-        if sel == 1 {
+        if sel {
             let (u, v) = edges[idx];
             degree[u] += 1;
             degree[v] += 1;
@@ -145,26 +146,65 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MaximumLeafSpanningTree";
-    type Value = Max<usize>;
+    type Solution = Vec<bool>;
+    type Value = Max<i64>;
+
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
+        }
+        Ok({
+            if !is_valid_spanning_tree(&self.graph, config) {
+                return Ok(Max(None));
+            }
+            Max(Some(
+                i64::try_from(count_leaves(&self.graph, config)).map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting leaf count to i64".into(),
+                    )
+                })?,
+            ))
+        })
+    }
+}
+
+impl<G> crate::solvers::BruteForceProblem for MaximumLeafSpanningTree<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
         vec![2; self.graph.num_edges()]
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Max<usize> {
-        if !is_valid_spanning_tree(&self.graph, config) {
-            return Max(None);
+crate::impl_random_generate!(
+    MaximumLeafSpanningTree<SimpleGraph>,
+    crate::random::SimpleGraphRandomSpec,
+    |spec| {
+        if spec.num_vertices < 2 {
+            return Err("num_vertices must be at least 2".to_string().into());
         }
-        Max(Some(count_leaves(&self.graph, config)))
+        Ok(MaximumLeafSpanningTree::new(spec.graph()?))
     }
-}
+);
 
 crate::declare_variants! {
-    default MaximumLeafSpanningTree<SimpleGraph> => "1.8966^num_vertices",
+    default MaximumLeafSpanningTree<SimpleGraph> => "1.8966^num_vertices" random,
+}
+
+crate::register_brute_force! {
+    MaximumLeafSpanningTree<SimpleGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -188,7 +228,9 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         // Edges: 0:(0,1), 1:(0,2), 2:(0,3), 3:(1,4), 4:(2,4), 5:(2,5), 6:(3,5), 7:(4,5), 8:(1,3)
         // Tree: {(0,1),(0,2),(0,3),(2,4),(2,5)} = indices 0,1,2,4,5
         // Leaves: 1,3,4,5 (degree 1 each), Internal: 0 (deg 3), 2 (deg 3)
-        optimal_config: vec![1, 1, 1, 0, 1, 1, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![
+            true, true, true, false, true, true, false, false, false
+        ]),
         optimal_value: serde_json::json!(4),
     }]
 }
diff --git a/src/models/graph/maximum_matching.rs b/src/models/graph/maximum_matching.rs
index f2c3d0719..6e68acfd5 100644
--- a/src/models/graph/maximum_matching.rs
+++ b/src/models/graph/maximum_matching.rs
@@ -3,7 +3,7 @@
 //! The Maximum Matching problem asks for a maximum weight set of edges
 //! such that no two edges share a vertex.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, WeightElement};
@@ -18,14 +18,12 @@ inventory::submit! {
         aliases: &["MaxMatching"],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find maximum weight matching in a graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge weights w: E -> R" },
-        ],
+        fields: MaximumMatchingCreateSpec::FIELDS,
     }
 }
 
@@ -37,25 +35,25 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`, `KingsSubgraph`, `UnitDiskGraph`)
-/// * `W` - The weight type (e.g., `i32`, `f64`, `One`)
+/// * `W` - The weight type (e.g., `i64`, `f64`, `One`)
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::graph::MaximumMatching;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Path graph 0-1-2
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-/// let problem = MaximumMatching::<_, i32>::unit_weights(graph);
+/// let problem = MaximumMatching::<_, i64>::unit_weights(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Maximum matching has 1 edge
 /// for sol in &solutions {
-///     assert_eq!(sol.iter().sum::<usize>(), 1);
+///     assert_eq!(sol.iter().filter(|&&selected| selected).count(), 1);
 /// }
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -66,6 +64,66 @@ pub struct MaximumMatching<G, W> {
     edge_weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MaximumMatchingCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    edge_weights: Option<Vec<i64>>,
+}
+
+impl TryFrom<MaximumMatchingCreateSpec> for MaximumMatching<SimpleGraph, i64> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: MaximumMatchingCreateSpec) -> Result<Self, Self::Error> {
+        let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+        let edge_weights = spec
+            .edge_weights
+            .unwrap_or_else(|| vec![1; graph.num_edges()]);
+        if edge_weights.len() != graph.num_edges() {
+            return Err(format!(
+                "edge_weights has length {}, expected {}",
+                edge_weights.len(),
+                graph.num_edges()
+            )
+            .into());
+        }
+        Ok(Self::new(graph, edge_weights))
+    }
+}
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(format!(
+            "num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}"
+        )
+        .into());
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
+}
+
 impl<G: Graph, W: Clone + Default> MaximumMatching<G, W> {
     /// Create a MaximumMatching problem from a graph with given edge weights.
     ///
@@ -87,9 +145,9 @@ impl<G: Graph, W: Clone + Default> MaximumMatching<G, W> {
     /// Create a MaximumMatching problem with unit weights.
     pub fn unit_weights(graph: G) -> Self
     where
-        W: From<i32>,
+        W: WeightElement,
     {
-        let edge_weights = vec![W::from(1); graph.num_edges()];
+        let edge_weights = vec![W::unit(); graph.num_edges()];
         Self {
             graph,
             edge_weights,
@@ -127,16 +185,16 @@ impl<G: Graph, W: Clone + Default> MaximumMatching<G, W> {
     }
 
     /// Check if a configuration is a valid matching.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         self.is_valid_matching(config)
     }
 
     /// Check if a configuration is a valid matching (internal).
-    fn is_valid_matching(&self, config: &[usize]) -> bool {
+    fn is_valid_matching(&self, config: &[bool]) -> bool {
         let mut vertex_used = vec![false; self.graph.num_vertices()];
 
         for (idx, &selected) in config.iter().enumerate() {
-            if selected == 1 {
+            if selected {
                 if let Some((u, v)) = self.edge_endpoints(idx) {
                     if vertex_used[u] || vertex_used[v] {
                         return false;
@@ -187,45 +245,78 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MaximumMatching";
+    type Solution = Vec<bool>;
     type Value = Max<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Max<W::Sum> {
-        if !self.is_valid_matching(config) {
-            return Max(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (idx, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                if let Some(w) = self.edge_weights.get(idx) {
-                    total += w.to_sum();
+        Ok({
+            if !self.is_valid_matching(config) {
+                return Ok(Max(None));
+            }
+            let mut total = W::Sum::zero();
+            for (idx, &selected) in config.iter().enumerate() {
+                if selected {
+                    if let Some(w) = self.edge_weights.get(idx) {
+                        total = W::checked_add_to_sum(
+                            total,
+                            w.to_sum(),
+                            "summing selected matching-edge weights",
+                        )?;
+                    }
                 }
             }
-        }
-        Max(Some(total))
+            Max(Some(total))
+        })
     }
 }
 
+impl<G, W> crate::solvers::BruteForceProblem for MaximumMatching<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
+    }
+}
+
+crate::impl_random_generate!(MaximumMatching<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    let graph = spec.graph()?;
+    let weights = vec![1; graph.num_edges()];
+    Ok(MaximumMatching::new(graph, weights))
+});
+
 crate::declare_variants! {
-    default MaximumMatching<SimpleGraph, i32> => "num_vertices^3",
+    default MaximumMatching<SimpleGraph, i64> => "num_vertices^3" create MaximumMatchingCreateSpec random,
+}
+
+crate::register_brute_force! {
+    MaximumMatching<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "maximum_matching_simplegraph_i32",
-        instance: Box::new(MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(
+        id: "maximum_matching_simplegraph",
+        instance: Box::new(MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(
             5,
             vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)],
         ))),
-        optimal_config: vec![1, 0, 0, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![true, false, false, false, true, false]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/graph/min_max_multicenter.rs b/src/models/graph/min_max_multicenter.rs
index 5bf60ef53..bcc697aff 100644
--- a/src/models/graph/min_max_multicenter.rs
+++ b/src/models/graph/min_max_multicenter.rs
@@ -3,10 +3,10 @@
 //! The vertex p-center problem asks for K centers on vertices of a graph that
 //! minimize the maximum weighted distance from any vertex to its nearest center.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
-use crate::types::{Min, WeightElement};
+use crate::types::{Min, One, WeightElement};
 use num_traits::Zero;
 use serde::{Deserialize, Serialize};
 
@@ -17,16 +17,12 @@ inventory::submit! {
         aliases: &["pCenter"],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32", "One"]),
+            VariantDimension::new("weight", "i64", &["i64", "One"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find K centers minimizing the maximum weighted distance from any vertex to its nearest center (vertex p-center)",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "vertex_weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-            FieldInfo { name: "edge_lengths", type_name: "Vec<W>", description: "Edge lengths l: E -> R" },
-            FieldInfo { name: "k", type_name: "usize", description: "Number of centers to place" },
-        ],
+        fields: MinMaxMulticenterI64CreateSpec::FIELDS,
     }
 }
 
@@ -40,21 +36,21 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`)
-/// * `W` - The weight/length type (e.g., `i32`)
+/// * `W` - The weight/length type (e.g., `i64`)
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::graph::MinMaxMulticenter;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Hexagonal-like graph: 6 vertices, 7 edges, unit weights/lengths, K=2
 /// let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (0, 5), (1, 4)]);
-/// let problem = MinMaxMulticenter::new(graph, vec![1i32; 6], vec![1i32; 7], 2);
+/// let problem = MinMaxMulticenter::new(graph, vec![1i64; 6], vec![1i64; 7], 2);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -69,6 +65,106 @@ pub struct MinMaxMulticenter<G, W: WeightElement> {
     k: usize,
 }
 
+macro_rules! min_max_multicenter_create_spec {
+    ($name:ident, $weight:ty, $one:expr $(, $weights:ident, $edge_weights:ident)?) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            #[create(codec = "edge-list")]
+            graph: Vec<(usize, usize)>,
+            num_vertices: Option<usize>,
+            $(
+            #[create(codec = "comma-separated")]
+            $weights: Option<Vec<$weight>>,
+            )?
+            $(
+            #[create(codec = "comma-separated")]
+            $edge_weights: Option<Vec<$weight>>,
+            )?
+            k: usize,
+        }
+
+        impl TryFrom<$name> for MinMaxMulticenter<SimpleGraph, $weight> {
+            type Error = crate::registry::ConstructionError;
+
+            fn try_from(spec: $name) -> Result<Self, Self::Error> {
+                let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+                let vertex_weights = { $(if let Some(value) = spec.$weights { value } else)? { vec![$one; graph.num_vertices()] } };
+                if vertex_weights.len() != graph.num_vertices() {
+                    return Err(format!(
+                        "weights has length {}, expected {}",
+                        vertex_weights.len(),
+                        graph.num_vertices()
+                    )
+                    .into());
+                }
+                let edge_lengths = { $(if let Some(value) = spec.$edge_weights { value } else)? { vec![$one; graph.num_edges()] } };
+                if edge_lengths.len() != graph.num_edges() {
+                    return Err(format!(
+                        "edge_weights has length {}, expected {}",
+                        edge_lengths.len(),
+                        graph.num_edges()
+                    )
+                    .into());
+                }
+                let zero = <$weight as WeightElement>::Sum::zero();
+                if vertex_weights
+                    .iter()
+                    .any(|weight| weight.to_sum() < zero.clone())
+                {
+                    return Err("weights must be non-negative".to_string().into());
+                }
+                if edge_lengths
+                    .iter()
+                    .any(|weight| weight.to_sum() < zero.clone())
+                {
+                    return Err("edge_weights must be non-negative".to_string().into());
+                }
+                if spec.k == 0 || spec.k > graph.num_vertices() {
+                    return Err(format!("k must be between 1 and {}", graph.num_vertices()).into());
+                }
+                Ok(Self::new(graph, vertex_weights, edge_lengths, spec.k))
+            }
+        }
+    };
+}
+
+min_max_multicenter_create_spec!(
+    MinMaxMulticenterI64CreateSpec,
+    i64,
+    1,
+    weights,
+    edge_weights
+);
+min_max_multicenter_create_spec!(MinMaxMulticenterOneCreateSpec, One, One);
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(format!("num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}").into());
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
+}
+
 impl<G: Graph, W: WeightElement> MinMaxMulticenter<G, W> {
     /// Create a MinMaxMulticenter problem.
     ///
@@ -153,9 +249,9 @@ impl<G: Graph, W: WeightElement> MinMaxMulticenter<G, W> {
     /// Correct because all edge lengths are non-negative.
     ///
     /// Returns `None` if any vertex is unreachable from all centers.
-    fn shortest_distances(&self, config: &[usize]) -> Option<Vec<W::Sum>> {
+    fn shortest_distances(&self, config: &[bool]) -> Option<Vec<W::Sum>> {
         let n = self.graph.num_vertices();
-        if config.len() != n || config.iter().any(|&selected| selected > 1) {
+        if config.len() != n {
             return None;
         }
         let edges = self.graph.edges();
@@ -173,7 +269,7 @@ impl<G: Graph, W: WeightElement> MinMaxMulticenter<G, W> {
 
         // Initialize centers
         for (v, &selected) in config.iter().enumerate() {
-            if selected == 1 {
+            if selected {
                 dist[v] = Some(W::Sum::zero());
             }
         }
@@ -228,68 +324,92 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinMaxMulticenter";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
-    }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.graph.num_vertices() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "center-selection length does not match the graph vertices".into(),
+                ));
+            }
 
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        if config.len() != self.graph.num_vertices() || config.iter().any(|&selected| selected > 1)
-        {
-            return Min(None);
-        }
+            // Check exactly K centers are selected
+            let num_selected = config.iter().filter(|&&selected| selected).count();
+            if num_selected != self.k {
+                return Ok(Min(None));
+            }
 
-        // Check exactly K centers are selected
-        let num_selected = config.iter().filter(|&&selected| selected == 1).count();
-        if num_selected != self.k {
-            return Min(None);
-        }
+            // Compute shortest distances to nearest center
+            let distances = match self.shortest_distances(config) {
+                Some(d) => d,
+                None => {
+                    return Ok(Min(None));
+                }
+            };
 
-        // Compute shortest distances to nearest center
-        let distances = match self.shortest_distances(config) {
-            Some(d) => d,
-            None => {
-                return Min(None);
-            }
-        };
-
-        // Compute max weighted distance: max_{v} w(v) * d(v)
-        let mut max_wd = W::Sum::zero();
-        for (v, dist) in distances.iter().enumerate() {
-            let wd = self.vertex_weights[v].to_sum() * dist.clone();
-            if wd > max_wd {
-                max_wd = wd;
+            // Compute max weighted distance: max_{v} w(v) * d(v)
+            let mut max_wd = W::Sum::zero();
+            for (v, dist) in distances.iter().enumerate() {
+                let wd = W::checked_mul_sum(
+                    self.vertex_weights[v].to_sum(),
+                    dist.clone(),
+                    "multiplying min-max multicenter vertex weight by distance",
+                )?;
+                if wd > max_wd {
+                    max_wd = wd;
+                }
             }
-        }
 
-        Min(Some(max_wd))
+            Min(Some(max_wd))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for MinMaxMulticenter<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
 crate::declare_variants! {
-    default MinMaxMulticenter<SimpleGraph, i32> => "1.4969^num_vertices",
-    MinMaxMulticenter<SimpleGraph, crate::types::One> => "1.4969^num_vertices",
+    default MinMaxMulticenter<SimpleGraph, i64> => "1.4969^num_vertices" create MinMaxMulticenterI64CreateSpec,
+    MinMaxMulticenter<SimpleGraph, One> => "1.4969^num_vertices" create MinMaxMulticenterOneCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinMaxMulticenter<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MinMaxMulticenter<SimpleGraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "min_max_multicenter_simplegraph_i32",
+        id: "min_max_multicenter_simplegraph",
         instance: Box::new(MinMaxMulticenter::new(
             SimpleGraph::new(
                 6,
                 vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (0, 5), (1, 4)],
             ),
-            vec![1i32; 6],
-            vec![1i32; 7],
+            vec![1i64; 6],
+            vec![1i64; 7],
             2,
         )),
-        optimal_config: vec![0, 1, 0, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![false, true, false, false, true, false]),
         optimal_value: serde_json::json!(1),
     }]
 }
diff --git a/src/models/graph/minimum_capacitated_spanning_tree.rs b/src/models/graph/minimum_capacitated_spanning_tree.rs
index 04762cf3d..631a960b6 100644
--- a/src/models/graph/minimum_capacitated_spanning_tree.rs
+++ b/src/models/graph/minimum_capacitated_spanning_tree.rs
@@ -8,7 +8,7 @@
 use num_traits::Zero;
 use serde::{Deserialize, Serialize};
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
@@ -20,17 +20,12 @@ inventory::submit! {
         aliases: &["MCST"],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum weight spanning tree with subtree capacity constraints",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Edge weights w: E -> R" },
-            FieldInfo { name: "root", type_name: "usize", description: "Root vertex" },
-            FieldInfo { name: "requirements", type_name: "Vec<W>", description: "Vertex requirements r: V -> R (root has 0)" },
-            FieldInfo { name: "capacity", type_name: "W::Sum", description: "Subtree capacity bound" },
-        ],
+        fields: MinimumCapacitatedSpanningTreeCreateSpec::FIELDS,
     }
 }
 
@@ -52,7 +47,7 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`)
-/// * `W` - The weight type for edges and requirements (e.g., `i32`)
+/// * `W` - The weight type for edges and requirements (e.g., `i64`)
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumCapacitatedSpanningTree<G, W: WeightElement> {
     /// The underlying graph.
@@ -67,6 +62,53 @@ pub struct MinimumCapacitatedSpanningTree<G, W: WeightElement> {
     capacity: W::Sum,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumCapacitatedSpanningTreeCreateSpec {
+    /// The underlying graph.
+    graph: SimpleGraph,
+    /// Edge weights; defaults to one per edge.
+    weights: Option<Vec<i64>>,
+    /// Root vertex.
+    root: usize,
+    /// Vertex requirements.
+    requirements: Vec<i64>,
+    /// Subtree capacity bound.
+    capacity: i64,
+}
+impl TryFrom<MinimumCapacitatedSpanningTreeCreateSpec>
+    for MinimumCapacitatedSpanningTree<SimpleGraph, i64>
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumCapacitatedSpanningTreeCreateSpec) -> Result<Self, Self::Error> {
+        let edges = spec.graph.num_edges();
+        let weights = spec.weights.unwrap_or_else(|| vec![1; edges]);
+        if weights.len() != edges {
+            return Err(format!("weights has {} entries, expected {edges}", weights.len()).into());
+        }
+        let vertices = spec.graph.num_vertices();
+        if vertices < 2 {
+            return Err("graph must have at least two vertices".to_string().into());
+        }
+        if spec.requirements.len() != vertices {
+            return Err(format!(
+                "requirements has {} entries, expected {vertices}",
+                spec.requirements.len()
+            )
+            .into());
+        }
+        if spec.root >= vertices {
+            return Err("root is outside the graph".to_string().into());
+        }
+        Ok(Self::new(
+            spec.graph,
+            weights,
+            spec.root,
+            spec.requirements,
+            spec.capacity,
+        ))
+    }
+}
+
 impl<G: Graph, W: WeightElement> MinimumCapacitatedSpanningTree<G, W> {
     /// Create a MinimumCapacitatedSpanningTree problem.
     ///
@@ -157,7 +199,10 @@ impl<G: Graph, W: WeightElement> MinimumCapacitatedSpanningTree<G, W> {
     }
 
     /// Check if a configuration is a valid capacitated spanning tree.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
         is_valid_capacitated_spanning_tree(
             &self.graph,
             &self.requirements,
@@ -171,14 +216,14 @@ impl<G: Graph, W: WeightElement> MinimumCapacitatedSpanningTree<G, W> {
 /// Check if a configuration forms a valid spanning tree:
 /// 1. Exactly n-1 edges selected
 /// 2. Selected edges form a connected subgraph
-fn is_spanning_tree<G: Graph>(graph: &G, config: &[usize]) -> bool {
+fn is_spanning_tree<G: Graph>(graph: &G, config: &[bool]) -> bool {
     let n = graph.num_vertices();
     let edges = graph.edges();
     if config.len() != edges.len() {
         return false;
     }
 
-    let selected_count: usize = config.iter().sum();
+    let selected_count = config.iter().filter(|&&selected| selected).count();
     if selected_count != n - 1 {
         return false;
     }
@@ -186,7 +231,7 @@ fn is_spanning_tree<G: Graph>(graph: &G, config: &[usize]) -> bool {
     // Build adjacency and BFS from vertex 0
     let mut adj: Vec<Vec<usize>> = vec![vec![]; n];
     for (idx, &sel) in config.iter().enumerate() {
-        if sel == 1 {
+        if sel {
             let (u, v) = edges[idx];
             adj[u].push(v);
             adj[v].push(u);
@@ -216,15 +261,15 @@ fn check_capacity<G: Graph, W: WeightElement>(
     requirements: &[W],
     root: usize,
     capacity: &W::Sum,
-    config: &[usize],
-) -> bool {
+    config: &[bool],
+) -> Result<bool, crate::traits::EvaluationError> {
     let n = graph.num_vertices();
     let edges = graph.edges();
 
     // Build adjacency list with edge indices
     let mut adj: Vec<Vec<(usize, usize)>> = vec![vec![]; n]; // (neighbor, edge_idx)
     for (idx, &sel) in config.iter().enumerate() {
-        if sel == 1 {
+        if sel {
             let (u, v) = edges[idx];
             adj[u].push((v, idx));
             adj[v].push((u, idx));
@@ -256,18 +301,22 @@ fn check_capacity<G: Graph, W: WeightElement>(
         if v != root {
             let p = parent[v];
             let sv = subtree_sum[v].clone();
-            subtree_sum[p] += sv;
+            subtree_sum[p] = W::checked_add_to_sum(
+                subtree_sum[p].clone(),
+                sv,
+                "summing capacitated spanning tree requirements",
+            )?;
         }
     }
 
     // Check capacity for each non-root vertex (its subtree sum is the flow on its parent edge)
     for (v, sum) in subtree_sum.iter().enumerate() {
         if v != root && *sum > *capacity {
-            return false;
+            return Ok(false);
         }
     }
 
-    true
+    Ok(true)
 }
 
 /// Check if a configuration forms a valid capacitated spanning tree.
@@ -276,10 +325,10 @@ fn is_valid_capacitated_spanning_tree<G: Graph, W: WeightElement>(
     requirements: &[W],
     root: usize,
     capacity: &W::Sum,
-    config: &[usize],
-) -> bool {
+    config: &[bool],
+) -> Result<bool, crate::traits::EvaluationError> {
     if !is_spanning_tree(graph, config) {
-        return false;
+        return Ok(false);
     }
     check_capacity(graph, requirements, root, capacity, config)
 }
@@ -290,46 +339,73 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumCapacitatedSpanningTree";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        if !is_valid_capacitated_spanning_tree(
-            &self.graph,
-            &self.requirements,
-            self.root,
-            &self.capacity,
-            config,
-        ) {
-            return Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (idx, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                if let Some(w) = self.weights.get(idx) {
-                    total += w.to_sum();
+        Ok({
+            if !is_valid_capacitated_spanning_tree(
+                &self.graph,
+                &self.requirements,
+                self.root,
+                &self.capacity,
+                config,
+            )? {
+                return Ok(Min(None));
+            }
+            let mut total = W::Sum::zero();
+            for (idx, &selected) in config.iter().enumerate() {
+                if selected {
+                    if let Some(w) = self.weights.get(idx) {
+                        total = W::checked_add_to_sum(
+                            total,
+                            w.to_sum(),
+                            "summing capacitated spanning tree edge weights",
+                        )?;
+                    }
                 }
             }
-        }
-        Min(Some(total))
+            Min(Some(total))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for MinimumCapacitatedSpanningTree<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
 }
 
 crate::declare_variants! {
-    default MinimumCapacitatedSpanningTree<SimpleGraph, i32> => "2^num_edges",
+    default MinimumCapacitatedSpanningTree<SimpleGraph, i64> => "2^num_edges" create MinimumCapacitatedSpanningTreeCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumCapacitatedSpanningTree<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "minimum_capacitated_spanning_tree_simplegraph_i32",
+        id: "minimum_capacitated_spanning_tree_simplegraph",
         instance: Box::new(MinimumCapacitatedSpanningTree::new(
             SimpleGraph::new(
                 5,
@@ -353,7 +429,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         // Weight = 2+1+1+1 = 5
         // Subtree sums: subtree(1)={1,4}->req=2<=3, subtree(2)={2}->req=1<=3,
         //   subtree(4)={4}->req=1<=3, subtree(3)={3}->req=1<=3
-        optimal_config: vec![1, 1, 0, 0, 1, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![true, true, false, false, true, false, false, true]),
         optimal_value: serde_json::json!(5),
     }]
 }
diff --git a/src/models/graph/minimum_cost_circulation.rs b/src/models/graph/minimum_cost_circulation.rs
index 9a405aab3..a61cea112 100644
--- a/src/models/graph/minimum_cost_circulation.rs
+++ b/src/models/graph/minimum_cost_circulation.rs
@@ -21,9 +21,9 @@
 //! # Integral-circulation restriction
 //!
 //! The mathematical formulation in issue #1030 uses continuous flows
-//! `g: A -> R_{>= 0}`, but the [`Problem`] trait requires a discrete
-//! configuration space via [`Problem::dims`]. Following the same
-//! precedent as [`MinimumEdgeCostFlow`](super::MinimumEdgeCostFlow) and
+//! `g: A -> R_{>= 0}`, but this model's registered reference solver uses a
+//! finite Cartesian space. Following the same precedent as
+//! [`MinimumEdgeCostFlow`](super::MinimumEdgeCostFlow) and
 //! the recently added [`MinimumCostMaximumFlow`](super::MinimumCostMaximumFlow),
 //! we therefore restrict to **integer** circulations: each variable
 //! `g(a)` ranges over `{0, 1, ..., c(a)}`. When capacities and costs are
@@ -32,7 +32,7 @@
 //! optimum exists, so this restriction does not change the optimal value
 //! on integer instances.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -43,6 +43,7 @@ inventory::submit! {
         display_name: "Minimum-Cost Circulation",
         aliases: &["MCC"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Integral circulation on a directed multigraph minimizing total signed arc cost",
         fields: &[
@@ -53,13 +54,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "MinimumCostCirculation",
-        fields: &["num_vertices", "num_arcs"],
-    }
-}
-
 /// Minimum-Cost Circulation problem.
 ///
 /// # Variables
@@ -72,7 +66,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumCostCirculation;
 /// use problemreductions::topology::DirectedGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Two competing cycles 0->1->0 and 0->2->0; the cheaper-per-unit
 /// // cycle 0->2->0 has lower capacity, but pushing both to capacity is
@@ -86,9 +80,9 @@ inventory::submit! {
 ///     vec![2, -3, 1, -4], // costs (signed)
 /// );
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem).unwrap();
+/// let witness = solver.solve(&problem).unwrap().unwrap();
 /// // Optimal cost = 2*2 + 2*(-3) + 1*1 + 1*(-4) = -5.
-/// assert_eq!(problem.total_cost(&witness), -5);
+/// assert_eq!(problem.total_cost(&witness).unwrap(), -5);
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumCostCirculation {
@@ -168,51 +162,91 @@ impl MinimumCostCirculation {
     /// 3. inflow equals outflow at **every** vertex (no exempt
     ///    terminals — this is what distinguishes a circulation from a
     ///    flow).
-    pub fn is_feasible(&self, config: &[usize]) -> bool {
+    pub fn is_feasible(&self, config: &[usize]) -> Result<bool, crate::traits::EvaluationError> {
         let m = self.graph.num_arcs();
         if config.len() != m {
-            return false;
+            return Ok(false);
         }
         // (1) Capacity constraints
         for (flow, cap) in config.iter().zip(self.capacities.iter()) {
-            if (*flow as i64) > *cap {
-                return false;
+            let flow = i64::try_from(*flow).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting circulation configuration value".to_string(),
+                )
+            })?;
+            if flow > *cap {
+                return Ok(false);
             }
         }
         // (2) Flow conservation at every vertex
         let n = self.graph.num_vertices();
         let mut balance = vec![0_i64; n];
         for (a, &(u, v)) in self.graph.arcs().iter().enumerate() {
-            let flow = config[a] as i64;
-            balance[u] -= flow;
-            balance[v] += flow;
+            let flow = i64::try_from(config[a]).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting circulation configuration value".to_string(),
+                )
+            })?;
+            balance[u] = balance[u].checked_sub(flow).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "computing circulation vertex balance".to_string(),
+                )
+            })?;
+            balance[v] = balance[v].checked_add(flow).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "computing circulation vertex balance".to_string(),
+                )
+            })?;
         }
-        balance.iter().all(|&b| b == 0)
+        Ok(balance.iter().all(|&b| b == 0))
     }
 
     /// Compute the total cost `sum_a a(a) * g(a)` of a circulation.
-    pub fn total_cost(&self, config: &[usize]) -> i64 {
-        config
-            .iter()
-            .zip(self.costs.iter())
-            .map(|(&g, &c)| (g as i64) * c)
-            .sum()
+    pub fn total_cost(&self, config: &[usize]) -> Result<i64, crate::traits::EvaluationError> {
+        let mut total = 0_i64;
+        for (&flow, &cost) in config.iter().zip(self.costs.iter()) {
+            let flow = i64::try_from(flow).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting circulation configuration value".to_string(),
+                )
+            })?;
+            let term = flow.checked_mul(cost).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "multiplying circulation arc cost".to_string(),
+                )
+            })?;
+            total = total.checked_add(term).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing circulation costs".to_string(),
+                )
+            })?;
+        }
+        Ok(total)
     }
 }
 
 impl Problem for MinimumCostCirculation {
     const NAME: &'static str = "MinimumCostCirculation";
+    type Solution = Vec<usize>;
     type Value = crate::types::Min<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        self.capacities.iter().map(|&c| (c as usize) + 1).collect()
-    }
+    crate::problem_parameters![("num_arcs", num_arcs), ("num_vertices", num_vertices),];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Min<i64> {
-        if !self.is_feasible(config) {
-            return crate::types::Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_arcs() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "flow vector length does not match the graph arcs".into(),
+            ));
         }
-        crate::types::Min(Some(self.total_cost(config)))
+        Ok({
+            if !self.is_feasible(config)? {
+                return Ok(crate::types::Min(None));
+            }
+            crate::types::Min(Some(self.total_cost(config)?))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -220,10 +254,20 @@ impl Problem for MinimumCostCirculation {
     }
 }
 
+impl crate::solvers::BruteForceProblem for MinimumCostCirculation {
+    fn dimensions(&self) -> Vec<usize> {
+        self.capacities.iter().map(|&c| (c as usize) + 1).collect()
+    }
+}
+
 crate::declare_variants! {
     default MinimumCostCirculation => "(num_vertices + num_arcs)^6",
 }
 
+crate::register_brute_force! {
+    MinimumCostCirculation,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // Two competing cycles on V = {0, 1, 2}:
@@ -237,8 +281,10 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         vec![2, 2, 1, 1],
         vec![2, -3, 1, -4],
     );
-    let optimal_config = vec![2_usize, 2, 1, 1];
-    let optimal_value = problem.evaluate(&optimal_config);
+    let optimal_config = vec![2, 2, 1, 1];
+    let optimal_value = problem
+        .evaluate(&optimal_config)
+        .expect("canonical example evaluation must succeed");
     let scalar = match optimal_value {
         crate::types::Min(Some(v)) => v,
         crate::types::Min(None) => panic!("canonical example must be feasible"),
@@ -246,7 +292,8 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "minimum_cost_circulation",
         instance: Box::new(problem),
-        optimal_config,
+        optimal_config: serde_json::to_value(optimal_config)
+            .expect("solution serialization must succeed"),
         optimal_value: serde_json::json!(scalar),
     }]
 }
diff --git a/src/models/graph/minimum_cost_maximum_flow.rs b/src/models/graph/minimum_cost_maximum_flow.rs
index 8065983f0..78cf0e271 100644
--- a/src/models/graph/minimum_cost_maximum_flow.rs
+++ b/src/models/graph/minimum_cost_maximum_flow.rs
@@ -15,9 +15,8 @@
 //! # Integral-flow restriction
 //!
 //! The mathematical CellRouter formulation in issue #1029 uses
-//! continuous flows `f: A -> R_{>= 0}`, but the [`Problem`] trait
-//! requires a discrete configuration space via [`Problem::dims`].
-//! Following the same precedent as
+//! continuous flows `f: A -> R_{>= 0}`, but this model's registered reference
+//! solver uses a finite Cartesian space. Following the same precedent as
 //! [`MinimumEdgeCostFlow`](super::MinimumEdgeCostFlow) (see
 //! `src/models/graph/minimum_edge_cost_flow.rs`), we therefore restrict
 //! to **integer** flows: each variable `f(a)` ranges over
@@ -40,7 +39,7 @@
 //! ties by `cost(f)`. The optimum is always non-negative, and a smaller
 //! score is strictly better in the lex order.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{ConstructionError, FieldInfo, ProblemSchemaEntry};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -51,6 +50,7 @@ inventory::submit! {
         display_name: "Minimum-Cost Maximum-Flow",
         aliases: &["MCMF"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Integral flow that lexicographically maximizes value then minimizes total arc cost",
         fields: &[
@@ -63,13 +63,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "MinimumCostMaximumFlow",
-        fields: &["num_vertices", "num_arcs"],
-    }
-}
-
 /// Minimum-Cost Maximum-Flow problem.
 ///
 /// # Variables
@@ -82,7 +75,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumCostMaximumFlow;
 /// use problemreductions::topology::DirectedGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Diamond network from the canonical example.
 /// let graph = DirectedGraph::new(4, vec![
@@ -95,12 +88,12 @@ inventory::submit! {
 ///     vec![1, 0, 0, 1, 2], // costs
 /// );
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem).unwrap();
+/// let witness = solver.solve(&problem).unwrap().unwrap();
 /// // Optimal flow has value 3 and cost 7.
-/// assert_eq!(problem.flow_value(&witness), 3);
-/// assert_eq!(problem.total_cost(&witness), 7);
+/// assert_eq!(problem.flow_value(&witness).unwrap(), 3);
+/// assert_eq!(problem.total_cost(&witness).unwrap(), 7);
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct MinimumCostMaximumFlow {
     /// The directed graph G = (V, A).
     graph: DirectedGraph,
@@ -114,6 +107,40 @@ pub struct MinimumCostMaximumFlow {
     costs: Vec<i64>,
 }
 
+#[derive(Deserialize)]
+struct MinimumCostMaximumFlowSerde {
+    graph: DirectedGraph,
+    source: usize,
+    sink: usize,
+    capacities: Vec<i64>,
+    costs: Vec<i64>,
+}
+
+impl TryFrom<MinimumCostMaximumFlowSerde> for MinimumCostMaximumFlow {
+    type Error = ConstructionError;
+
+    fn try_from(value: MinimumCostMaximumFlowSerde) -> Result<Self, Self::Error> {
+        Self::try_new(
+            value.graph,
+            value.source,
+            value.sink,
+            value.capacities,
+            value.costs,
+        )
+    }
+}
+
+impl<'de> Deserialize<'de> for MinimumCostMaximumFlow {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        MinimumCostMaximumFlowSerde::deserialize(deserializer)?
+            .try_into()
+            .map_err(serde::de::Error::custom)
+    }
+}
+
 impl MinimumCostMaximumFlow {
     /// Create a new Minimum-Cost Maximum-Flow problem.
     ///
@@ -134,36 +161,55 @@ impl MinimumCostMaximumFlow {
         capacities: Vec<i64>,
         costs: Vec<i64>,
     ) -> Self {
+        Self::try_new(graph, source, sink, capacities, costs)
+            .unwrap_or_else(|error| panic!("{error}"))
+    }
+
+    fn try_new(
+        graph: DirectedGraph,
+        source: usize,
+        sink: usize,
+        capacities: Vec<i64>,
+        costs: Vec<i64>,
+    ) -> Result<Self, ConstructionError> {
         let n = graph.num_vertices();
         let m = graph.num_arcs();
-        assert_eq!(
-            capacities.len(),
-            m,
-            "capacities length ({}) must match num_arcs ({m})",
-            capacities.len()
-        );
-        assert_eq!(
-            costs.len(),
-            m,
-            "costs length ({}) must match num_arcs ({m})",
-            costs.len()
-        );
-        assert!(source < n, "source ({source}) >= num_vertices ({n})");
-        assert!(sink < n, "sink ({sink}) >= num_vertices ({n})");
-        assert_ne!(source, sink, "source and sink must be distinct");
-        for (i, &c) in capacities.iter().enumerate() {
-            assert!(c >= 0, "capacity[{i}] = {c} is negative");
+        if capacities.len() != m {
+            return Err(format!(
+                "capacities length ({}) must match num_arcs ({m})",
+                capacities.len()
+            )
+            .into());
+        }
+        if costs.len() != m {
+            return Err(format!("costs length ({}) must match num_arcs ({m})", costs.len()).into());
+        }
+        if source >= n {
+            return Err(format!("source ({source}) >= num_vertices ({n})").into());
+        }
+        if sink >= n {
+            return Err(format!("sink ({sink}) >= num_vertices ({n})").into());
         }
-        for (i, &c) in costs.iter().enumerate() {
-            assert!(c >= 0, "cost[{i}] = {c} is negative");
+        if source == sink {
+            return Err("source and sink must be distinct".into());
         }
-        Self {
+        if let Some((index, capacity)) = capacities
+            .iter()
+            .enumerate()
+            .find(|(_, capacity)| **capacity < 0)
+        {
+            return Err(format!("capacity[{index}] = {capacity} is negative").into());
+        }
+        if let Some((index, cost)) = costs.iter().enumerate().find(|(_, cost)| **cost < 0) {
+            return Err(format!("cost[{index}] = {cost} is negative").into());
+        }
+        Ok(Self {
             graph,
             source,
             sink,
             capacities,
             costs,
-        }
+        })
     }
 
     /// Get a reference to the underlying directed graph.
@@ -207,96 +253,181 @@ impl MinimumCostMaximumFlow {
     /// 1. `config.len() == num_arcs`,
     /// 2. each `0 <= f(a) <= c(a)`, and
     /// 3. flow is conserved at every non-terminal vertex.
-    pub fn is_feasible(&self, config: &[usize]) -> bool {
+    pub fn is_feasible(&self, config: &[usize]) -> Result<bool, crate::traits::EvaluationError> {
         let m = self.graph.num_arcs();
         if config.len() != m {
-            return false;
+            return Ok(false);
         }
         // (1) Capacity constraints
         for (flow, cap) in config.iter().zip(self.capacities.iter()) {
-            if (*flow as i64) > *cap {
-                return false;
+            let flow = i64::try_from(*flow).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting maximum-flow configuration value".to_string(),
+                )
+            })?;
+            if flow > *cap {
+                return Ok(false);
             }
         }
         // (2) Flow conservation at non-terminal vertices
         let n = self.graph.num_vertices();
         let mut balance = vec![0_i64; n];
         for (a, &(u, v)) in self.graph.arcs().iter().enumerate() {
-            let flow = config[a] as i64;
-            balance[u] -= flow;
-            balance[v] += flow;
+            let flow = i64::try_from(config[a]).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting maximum-flow configuration value".to_string(),
+                )
+            })?;
+            balance[u] = balance[u].checked_sub(flow).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "computing maximum-flow vertex balance".to_string(),
+                )
+            })?;
+            balance[v] = balance[v].checked_add(flow).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "computing maximum-flow vertex balance".to_string(),
+                )
+            })?;
         }
         for (v, &bal) in balance.iter().enumerate() {
             if v != self.source && v != self.sink && bal != 0 {
-                return false;
+                return Ok(false);
             }
         }
-        true
+        Ok(true)
     }
 
     /// Compute the flow value `|f|` = net outflow from the source for a
     /// feasible configuration. Result is meaningless if `config` is not
     /// feasible.
-    pub fn flow_value(&self, config: &[usize]) -> i64 {
+    pub fn flow_value(&self, config: &[usize]) -> Result<i64, crate::traits::EvaluationError> {
         let mut net_out: i64 = 0;
         for (a, &(u, v)) in self.graph.arcs().iter().enumerate() {
-            let f = config[a] as i64;
+            let f = i64::try_from(config[a]).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting maximum-flow configuration value".to_string(),
+                )
+            })?;
             if u == self.source {
-                net_out += f;
+                net_out = net_out.checked_add(f).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "computing maximum-flow value".to_string(),
+                    )
+                })?;
             }
             if v == self.source {
-                net_out -= f;
+                net_out = net_out.checked_sub(f).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "computing maximum-flow value".to_string(),
+                    )
+                })?;
             }
         }
-        net_out
+        Ok(net_out)
     }
 
     /// Compute the total cost `sum_a cost(a) * f(a)` of a flow.
-    pub fn total_cost(&self, config: &[usize]) -> i64 {
-        config
-            .iter()
-            .zip(self.costs.iter())
-            .map(|(&f, &c)| (f as i64) * c)
-            .sum()
+    pub fn total_cost(&self, config: &[usize]) -> Result<i64, crate::traits::EvaluationError> {
+        let mut total = 0_i64;
+        for (&flow, &cost) in config.iter().zip(self.costs.iter()) {
+            let flow = i64::try_from(flow).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting maximum-flow configuration value".to_string(),
+                )
+            })?;
+            let term = flow.checked_mul(cost).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "multiplying maximum-flow arc cost".to_string(),
+                )
+            })?;
+            total = total.checked_add(term).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing maximum-flow costs".to_string(),
+                )
+            })?;
+        }
+        Ok(total)
     }
 
     /// Upper bound on the integral flow value: `sum_a c(a)` (a trivial
     /// but valid bound, since `|f|` is bounded by the total capacity).
-    fn max_possible_flow(&self) -> i64 {
-        self.capacities.iter().sum()
+    fn max_possible_flow(&self) -> Result<i64, crate::traits::EvaluationError> {
+        self.capacities.iter().try_fold(0_i64, |total, &capacity| {
+            total.checked_add(capacity).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing maximum-flow capacities".to_string(),
+                )
+            })
+        })
     }
 
     /// Strict upper bound on any feasible cost, used as the
     /// lex-multiplier `M` so that the scalar `score = M * (B - |f|)
     /// + cost(f)` orders by `(max |f|, min cost(f))`.
-    fn cost_multiplier(&self) -> i64 {
-        self.capacities
-            .iter()
-            .zip(self.costs.iter())
-            .map(|(&c, &k)| c * k)
-            .sum::<i64>()
-            + 1
+    fn cost_multiplier(&self) -> Result<i64, crate::traits::EvaluationError> {
+        let mut total = 0_i64;
+        for (&capacity, &cost) in self.capacities.iter().zip(self.costs.iter()) {
+            let term = capacity.checked_mul(cost).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "multiplying maximum-flow capacity by cost".to_string(),
+                )
+            })?;
+            total = total.checked_add(term).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing maximum-flow cost bounds".to_string(),
+                )
+            })?;
+        }
+        total.checked_add(1).ok_or_else(|| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "forming maximum-flow cost multiplier".to_string(),
+            )
+        })
     }
 }
 
 impl Problem for MinimumCostMaximumFlow {
     const NAME: &'static str = "MinimumCostMaximumFlow";
+    type Solution = Vec<usize>;
     type Value = crate::types::Min<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        self.capacities.iter().map(|&c| (c as usize) + 1).collect()
-    }
+    crate::problem_parameters![("num_arcs", num_arcs), ("num_vertices", num_vertices),];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Min<i64> {
-        if !self.is_feasible(config) {
-            return crate::types::Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_arcs() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "flow vector length does not match the graph arcs".into(),
+            ));
         }
-        let m = self.cost_multiplier();
-        let value = self.flow_value(config);
-        let cost = self.total_cost(config);
-        let bound = self.max_possible_flow();
-        // score = M * (max_possible_flow - |f|) + cost(f)
-        crate::types::Min(Some(m * (bound - value) + cost))
+        Ok({
+            if !self.is_feasible(config)? {
+                return Ok(crate::types::Min(None));
+            }
+            let m = self.cost_multiplier()?;
+            let value = self.flow_value(config)?;
+            let cost = self.total_cost(config)?;
+            let bound = self.max_possible_flow()?;
+            // score = M * (max_possible_flow - |f|) + cost(f)
+            let remaining = bound.checked_sub(value).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "computing maximum-flow objective gap".to_string(),
+                )
+            })?;
+            let penalty = m.checked_mul(remaining).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "multiplying maximum-flow objective penalty".to_string(),
+                )
+            })?;
+            let score = penalty.checked_add(cost).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing maximum-flow objective".to_string(),
+                )
+            })?;
+            crate::types::Min(Some(score))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -304,10 +435,20 @@ impl Problem for MinimumCostMaximumFlow {
     }
 }
 
+impl crate::solvers::BruteForceProblem for MinimumCostMaximumFlow {
+    fn dimensions(&self) -> Vec<usize> {
+        self.capacities.iter().map(|&c| (c as usize) + 1).collect()
+    }
+}
+
 crate::declare_variants! {
     default MinimumCostMaximumFlow => "(num_vertices + num_arcs)^6",
 }
 
+crate::register_brute_force! {
+    MinimumCostMaximumFlow,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     let problem = MinimumCostMaximumFlow::new(
@@ -323,8 +464,10 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     //   - 1 unit on 0->2->3        via arcs 1,4 (cost 0 + 2 = 2)
     // Arc flows sum to f = [2, 1, 1, 1, 2]: value = 3,
     // cost = 2*1 + 1*0 + 1*0 + 1*1 + 2*2 = 7.
-    let optimal_config = vec![2_usize, 1, 1, 1, 2];
-    let optimal_value = problem.evaluate(&optimal_config);
+    let optimal_config = vec![2, 1, 1, 1, 2];
+    let optimal_value = problem
+        .evaluate(&optimal_config)
+        .expect("canonical example evaluation must succeed");
     let scalar = match optimal_value {
         crate::types::Min(Some(v)) => v,
         crate::types::Min(None) => panic!("canonical example must be feasible"),
@@ -332,7 +475,8 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "minimum_cost_maximum_flow",
         instance: Box::new(problem),
-        optimal_config,
+        optimal_config: serde_json::to_value(optimal_config)
+            .expect("solution serialization must succeed"),
         optimal_value: serde_json::json!(scalar),
     }]
 }
diff --git a/src/models/graph/minimum_covering_by_cliques.rs b/src/models/graph/minimum_covering_by_cliques.rs
index 55080af3c..1f59f2bae 100644
--- a/src/models/graph/minimum_covering_by_cliques.rs
+++ b/src/models/graph/minimum_covering_by_cliques.rs
@@ -18,6 +18,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum number of cliques covering all edges",
         fields: &[
@@ -44,15 +45,15 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumCoveringByCliques;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Triangle: 3 edges can be covered by 1 clique
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
 /// let problem = MinimumCoveringByCliques::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem).unwrap();
-/// let value = problem.evaluate(&solution);
+/// let solution = solver.solve(&problem).unwrap().unwrap();
+/// let value = problem.evaluate(&solution).unwrap();
 /// assert_eq!(value, problemreductions::types::Min(Some(1)));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -128,33 +129,64 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumCoveringByCliques";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.graph.num_edges(); self.graph.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.graph.num_edges() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "edge-group assignment length does not match the graph edges".into(),
+                ));
+            }
+            if self.graph.num_edges() == 0 {
+                return Ok(Min(Some(0)));
+            }
+            if !self.is_valid_cover(config) {
+                return Ok(Min(None));
+            }
+            let distinct_groups: HashSet<usize> = config.iter().copied().collect();
+            Min(Some(i64::try_from(distinct_groups.len()).map_err(
+                |_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting clique-cover size to i64".into(),
+                    )
+                },
+            )?))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if config.len() != self.graph.num_edges() {
-            return Min(None);
-        }
-        if self.graph.num_edges() == 0 {
-            return Min(Some(0));
-        }
-        if !self.is_valid_cover(config) {
-            return Min(None);
-        }
-        let distinct_groups: HashSet<usize> = config.iter().copied().collect();
-        Min(Some(distinct_groups.len()))
+impl<G> crate::solvers::BruteForceProblem for MinimumCoveringByCliques<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.graph.num_edges(); self.graph.num_edges()]
     }
 }
 
+crate::impl_random_generate!(
+    MinimumCoveringByCliques<SimpleGraph>,
+    crate::random::SimpleGraphRandomSpec,
+    |spec| { Ok(MinimumCoveringByCliques::new(spec.graph()?)) }
+);
+
 crate::declare_variants! {
-    default MinimumCoveringByCliques<SimpleGraph> => "2^num_edges",
+    default MinimumCoveringByCliques<SimpleGraph> => "2^num_edges" random,
+}
+
+crate::register_brute_force! {
+    MinimumCoveringByCliques<SimpleGraph>,
 }
 
 #[cfg(feature = "example-db")]
@@ -183,7 +215,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 (5, 3),
             ],
         ))),
-        optimal_config: vec![0, 0, 1, 1, 0, 2, 2, 3, 3],
+        optimal_config: serde_json::json!(vec![0, 0, 1, 1, 0, 2, 2, 3, 3]),
         optimal_value: serde_json::json!(4),
     }]
 }
diff --git a/src/models/graph/minimum_cut_into_bounded_sets.rs b/src/models/graph/minimum_cut_into_bounded_sets.rs
index 6ebaa7af6..2f5167a65 100644
--- a/src/models/graph/minimum_cut_into_bounded_sets.rs
+++ b/src/models/graph/minimum_cut_into_bounded_sets.rs
@@ -4,7 +4,7 @@
 //! bounded-size sets (containing designated source and sink vertices) that
 //! minimizes total cut weight. From Garey & Johnson, A2 ND17.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
@@ -18,17 +18,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a minimum-weight cut partitioning vertices into two bounded-size sets",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The undirected graph G = (V, E)" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge weights w: E -> Z+" },
-            FieldInfo { name: "source", type_name: "usize", description: "Source vertex s (must be in V1)" },
-            FieldInfo { name: "sink", type_name: "usize", description: "Sink vertex t (must be in V2)" },
-            FieldInfo { name: "size_bound", type_name: "usize", description: "Maximum size B for each partition set" },
-        ],
+        fields: MinimumCutIntoBoundedSetsCreateSpec::FIELDS,
     }
 }
 
@@ -44,21 +39,21 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`)
-/// * `W` - The weight type for edges (e.g., `i32`)
+/// * `W` - The weight type for edges (e.g., `i64`)
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::graph::MinimumCutIntoBoundedSets;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Simple 4-vertex path graph with unit weights, s=0, t=3
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
 /// let problem = MinimumCutIntoBoundedSets::new(graph, vec![1, 1, 1], 0, 3, 3);
 ///
 /// // Partition {0,1} vs {2,3}: cut edge (1,2) with weight 1
-/// let val = problem.evaluate(&[0, 0, 1, 1]);
+/// let val = problem.evaluate(&vec![false, false, true, true]).unwrap();
 /// assert_eq!(val, problemreductions::types::Min(Some(1)));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -75,6 +70,47 @@ pub struct MinimumCutIntoBoundedSets<G, W: WeightElement> {
     size_bound: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumCutIntoBoundedSetsCreateSpec {
+    /// The undirected graph.
+    graph: SimpleGraph,
+    /// Edge weights; defaults to one per edge.
+    edge_weights: Option<Vec<i64>>,
+    /// Source vertex.
+    source: usize,
+    /// Sink vertex.
+    sink: usize,
+    /// Maximum size for each partition set.
+    size_bound: usize,
+}
+impl TryFrom<MinimumCutIntoBoundedSetsCreateSpec> for MinimumCutIntoBoundedSets<SimpleGraph, i64> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumCutIntoBoundedSetsCreateSpec) -> Result<Self, Self::Error> {
+        let count = spec.graph.num_edges();
+        let edge_weights = spec.edge_weights.unwrap_or_else(|| vec![1; count]);
+        if edge_weights.len() != count {
+            return Err(format!(
+                "edge_weights has {} entries, expected {count}",
+                edge_weights.len()
+            )
+            .into());
+        }
+        let vertices = spec.graph.num_vertices();
+        if spec.source >= vertices || spec.sink >= vertices || spec.source == spec.sink {
+            return Err("source and sink must be distinct valid graph vertices"
+                .to_string()
+                .into());
+        }
+        Ok(Self::new(
+            spec.graph,
+            edge_weights,
+            spec.source,
+            spec.sink,
+            spec.size_bound,
+        ))
+    }
+}
+
 impl<G: Graph, W: WeightElement> MinimumCutIntoBoundedSets<G, W> {
     /// Create a new MinimumCutIntoBoundedSets problem.
     ///
@@ -154,50 +190,70 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumCutIntoBoundedSets";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        let n = self.graph.num_vertices();
-        if config.len() != n {
-            return Min(None);
-        }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        Ok({
+            let n = self.graph.num_vertices();
+            if config.len() != n {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "partition assignment length does not match the graph vertices".into(),
+                ));
+            }
 
-        // Check source is in V1 (config=0) and sink is in V2 (config=1)
-        if config[self.source] != 0 || config[self.sink] != 1 {
-            return Min(None);
-        }
+            // Check source is in V1 (config=0) and sink is in V2 (config=1)
+            if config[self.source] || !config[self.sink] {
+                return Ok(Min(None));
+            }
 
-        // Check size bounds
-        let count_v1 = config.iter().filter(|&&x| x == 0).count();
-        let count_v2 = config.iter().filter(|&&x| x == 1).count();
-        if count_v1 > self.size_bound || count_v2 > self.size_bound {
-            return Min(None);
-        }
+            // Check size bounds
+            let count_v1 = config.iter().filter(|&&x| !x).count();
+            let count_v2 = config.iter().filter(|&&x| x).count();
+            if count_v1 > self.size_bound || count_v2 > self.size_bound {
+                return Ok(Min(None));
+            }
 
-        // Compute cut weight
-        let mut cut_weight = W::Sum::zero();
-        for ((u, v), weight) in self.graph.edges().iter().zip(self.edge_weights.iter()) {
-            if config[*u] != config[*v] {
-                cut_weight += weight.to_sum();
+            // Compute cut weight
+            let mut cut_weight = W::Sum::zero();
+            for ((u, v), weight) in self.graph.edges().iter().zip(self.edge_weights.iter()) {
+                if config[*u] != config[*v] {
+                    cut_weight = W::checked_add_to_sum(
+                        cut_weight,
+                        weight.to_sum(),
+                        "summing bounded-set cut weights",
+                    )?;
+                }
             }
-        }
 
-        Min(Some(cut_weight))
+            Min(Some(cut_weight))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for MinimumCutIntoBoundedSets<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "minimum_cut_into_bounded_sets_i32",
+        id: "minimum_cut_into_bounded_sets",
         instance: Box::new(MinimumCutIntoBoundedSets::new(
             SimpleGraph::new(
                 8,
@@ -222,13 +278,24 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             5,
         )),
         // V1={0,1,2,3}, V2={4,5,6,7}: cut edges (2,4)=2,(3,5)=1,(3,6)=3 => 6
-        optimal_config: vec![0, 0, 0, 0, 1, 1, 1, 1],
+        optimal_config: serde_json::json!(vec![false, false, false, false, true, true, true, true]),
         optimal_value: serde_json::json!(6),
     }]
 }
 
+crate::impl_random_generate!(MinimumCutIntoBoundedSets<SimpleGraph, i64>, crate::random::EndpointRandomSpec, |spec| {
+    let (source, sink) = spec.endpoints()?;
+    let graph = spec.graph()?;
+    let edge_weights = vec![1; graph.num_edges()];
+    Ok(MinimumCutIntoBoundedSets::new(graph, edge_weights, source, sink, spec.num_vertices))
+});
+
 crate::declare_variants! {
-    default MinimumCutIntoBoundedSets<SimpleGraph, i32> => "2^num_vertices",
+    default MinimumCutIntoBoundedSets<SimpleGraph, i64> => "2^num_vertices" create MinimumCutIntoBoundedSetsCreateSpec random,
+}
+
+crate::register_brute_force! {
+    MinimumCutIntoBoundedSets<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/minimum_dominating_set.rs b/src/models/graph/minimum_dominating_set.rs
index d1c7e63e8..b8c85a1a4 100644
--- a/src/models/graph/minimum_dominating_set.rs
+++ b/src/models/graph/minimum_dominating_set.rs
@@ -4,7 +4,7 @@
 //! such that every vertex is either in the set or adjacent to a vertex in the set.
 
 use crate::models::decision::Decision;
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, FieldInfo, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, One, WeightElement};
@@ -19,14 +19,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32", "One"]),
+            VariantDimension::new("weight", "i64", &["i64", "One"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum weight dominating set in a graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-        ],
+        fields: MinimumDominatingSetCreateSpec::<i64>::FIELDS,
     }
 }
 
@@ -42,17 +40,17 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumDominatingSet;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Star graph: center dominates all
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]);
 /// let problem = MinimumDominatingSet::new(graph, vec![1; 4]);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Minimum dominating set is just the center vertex
-/// assert!(solutions.contains(&vec![1, 0, 0, 0]));
+/// assert!(solutions.contains(&vec![true, false, false, false]));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumDominatingSet<G, W> {
@@ -62,6 +60,31 @@ pub struct MinimumDominatingSet<G, W> {
     weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumDominatingSetCreateSpec<W> {
+    /// The underlying graph G=(V,E).
+    graph: SimpleGraph,
+    /// Vertex weights w: V -> R.
+    weights: Vec<W>,
+}
+
+impl<W: Clone + Default> TryFrom<MinimumDominatingSetCreateSpec<W>>
+    for MinimumDominatingSet<SimpleGraph, W>
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumDominatingSetCreateSpec<W>) -> Result<Self, Self::Error> {
+        if spec.weights.len() != spec.graph.num_vertices() {
+            return Err(format!(
+                "weights has {} entries, expected {}",
+                spec.weights.len(),
+                spec.graph.num_vertices()
+            )
+            .into());
+        }
+        Ok(Self::new(spec.graph, spec.weights))
+    }
+}
+
 impl<G: Graph, W: Clone + Default> MinimumDominatingSet<G, W> {
     /// Create a Dominating Set problem from a graph with given weights.
     pub fn new(graph: G, weights: Vec<W>) -> Self {
@@ -96,17 +119,17 @@ impl<G: Graph, W: Clone + Default> MinimumDominatingSet<G, W> {
     }
 
     /// Check if a configuration is a valid dominating set.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         self.is_dominating(config)
     }
 
     /// Check if a set of vertices is a dominating set.
-    fn is_dominating(&self, config: &[usize]) -> bool {
+    fn is_dominating(&self, config: &[bool]) -> bool {
         let n = self.graph.num_vertices();
         let mut dominated = vec![false; n];
 
         for (v, &selected) in config.iter().enumerate() {
-            if selected == 1 {
+            if selected {
                 // v dominates itself
                 dominated[v] = true;
                 // v dominates all its neighbors
@@ -140,33 +163,82 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumDominatingSet";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex-selection length does not match the graph".into(),
+            ));
+        }
+        Ok({
+            if !self.is_dominating(config) {
+                return Ok(Min(None));
+            }
+            let mut total = W::Sum::zero();
+            for (i, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.weights[i].to_sum(),
+                        "summing selected dominating-set weights",
+                    )?;
+                }
+            }
+            Min(Some(total))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for MinimumDominatingSet<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
         vec![2; self.graph.num_vertices()]
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        if !self.is_dominating(config) {
-            return Min(None);
-        }
-        let mut total = W::Sum::zero();
-        for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.weights[i].to_sum();
-            }
-        }
-        Min(Some(total))
+crate::impl_random_generate!(MinimumDominatingSet<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    Ok(MinimumDominatingSet::new(spec.graph()?, vec![1; spec.num_vertices]))
+});
+crate::impl_random_generate!(MinimumDominatingSet<SimpleGraph, One>, crate::random::SimpleGraphRandomSpec, |spec| {
+    Ok(MinimumDominatingSet::new(spec.graph()?, vec![One; spec.num_vertices]))
+});
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumDominatingSetOneCreateSpec {
+    /// The underlying graph.
+    graph: SimpleGraph,
+}
+
+impl TryFrom<MinimumDominatingSetOneCreateSpec> for MinimumDominatingSet<SimpleGraph, One> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumDominatingSetOneCreateSpec) -> Result<Self, Self::Error> {
+        let weights = vec![One; spec.graph.num_vertices()];
+        Ok(Self::new(spec.graph, weights))
     }
 }
 
 crate::declare_variants! {
-    default MinimumDominatingSet<SimpleGraph, i32> => "1.4969^num_vertices",
-    MinimumDominatingSet<SimpleGraph, One> => "1.4969^num_vertices",
+    default MinimumDominatingSet<SimpleGraph, i64> => "1.4969^num_vertices" create MinimumDominatingSetCreateSpec<i64> random,
+    MinimumDominatingSet<SimpleGraph, One> => "1.4969^num_vertices" create MinimumDominatingSetOneCreateSpec random,
+}
+
+crate::register_brute_force! {
+    MinimumDominatingSet<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MinimumDominatingSet<SimpleGraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 impl<G, W> crate::models::decision::DecisionProblemMeta for MinimumDominatingSet<G, W>
@@ -178,7 +250,7 @@ where
     const DECISION_NAME: &'static str = "DecisionMinimumDominatingSet";
 }
 
-impl Decision<MinimumDominatingSet<SimpleGraph, i32>> {
+impl Decision<MinimumDominatingSet<SimpleGraph, i64>> {
     /// Number of vertices in the underlying graph.
     pub fn num_vertices(&self) -> usize {
         self.inner().num_vertices()
@@ -213,160 +285,34 @@ impl Decision<MinimumDominatingSet<SimpleGraph, One>> {
 }
 
 crate::register_decision_variant!(
-    MinimumDominatingSet<SimpleGraph, i32>,
+    MinimumDominatingSet<SimpleGraph, i64>,
     "DecisionMinimumDominatingSet",
     "1.4969^num_vertices",
     &[],
     "Decision version: does a dominating set of cost <= bound exist?",
+    category: crate::registry::ProblemCategory::Graph,
     dims: [
         VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-        VariantDimension::new("weight", "i32", &["i32", "One"]),
+        VariantDimension::new("weight", "i64", &["i64", "One"]),
     ],
     fields: [
         FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
         FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-        FieldInfo { name: "bound", type_name: "i32", description: "Decision bound (maximum allowed dominating-set cost)" },
+        FieldInfo { name: "bound", type_name: "i64", description: "Decision bound (maximum allowed dominating-set cost)" },
     ],
-    size_getters: [("num_vertices", num_vertices), ("num_edges", num_edges)]
+    additional: [MinimumDominatingSet<SimpleGraph, One> => "1.4969^num_vertices"],
+    decode: |_, indices: Vec<usize>| crate::config::config_to_bits(&indices)
 );
 
-impl crate::traits::DeclaredVariant for Decision<MinimumDominatingSet<SimpleGraph, One>> {}
-
-inventory::submit! {
-    crate::registry::VariantEntry {
-        name: <Decision<MinimumDominatingSet<SimpleGraph, One>> as Problem>::NAME,
-        variant_fn: <Decision<MinimumDominatingSet<SimpleGraph, One>> as Problem>::variant,
-        complexity: "1.4969^num_vertices",
-        complexity_eval_fn: |any| {
-            let problem = any
-                .downcast_ref::<Decision<MinimumDominatingSet<SimpleGraph, One>>>()
-                .expect("DecisionMinimumDominatingSet complexity source type mismatch");
-            1.4969_f64.powf(problem.num_vertices() as f64)
-        },
-        is_default: false,
-        aliases: &[],
-        factory: |data| {
-            serde_json::from_value::<Decision<MinimumDominatingSet<SimpleGraph, One>>>(data)
-                .map(|problem| Box::new(problem) as Box<dyn crate::registry::DynProblem>)
-        },
-        serialize_fn: |any| {
-            any.downcast_ref::<Decision<MinimumDominatingSet<SimpleGraph, One>>>()
-                .and_then(|problem| serde_json::to_value(problem).ok())
-        },
-        solve_value_fn: |any| {
-            let problem = any
-                .downcast_ref::<Decision<MinimumDominatingSet<SimpleGraph, One>>>()
-                .expect("DecisionMinimumDominatingSet value solve source type mismatch");
-            let (value, _) = crate::solvers::BruteForce::new().solve_with_witnesses(problem);
-            crate::registry::format_metric(&value)
-        },
-        solve_witness_fn: |any| {
-            let problem = any
-                .downcast_ref::<Decision<MinimumDominatingSet<SimpleGraph, One>>>()
-                .expect("DecisionMinimumDominatingSet witness solve source type mismatch");
-            let (value, witnesses) = crate::solvers::BruteForce::new().solve_with_witnesses(problem);
-            witnesses
-                .into_iter()
-                .next()
-                .map(|config| (config, crate::registry::format_metric(&value)))
-        },
-    }
-}
-
-// Decision<MDS<SG, One>> → MDS<SG, One>: both witness (identity config) and aggregate (solve + compare)
-inventory::submit! {
-    crate::rules::ReductionEntry {
-        source_name: "DecisionMinimumDominatingSet",
-        target_name: "MinimumDominatingSet",
-        source_variant_fn: <Decision<MinimumDominatingSet<SimpleGraph, One>> as Problem>::variant,
-        target_variant_fn: <MinimumDominatingSet<SimpleGraph, One> as Problem>::variant,
-        overhead_fn: || crate::rules::ReductionOverhead::identity(&["num_vertices", "num_edges"]),
-        module_path: module_path!(),
-        reduce_fn: Some(|any| {
-            let source = any
-                .downcast_ref::<Decision<MinimumDominatingSet<SimpleGraph, One>>>()
-                .expect("DecisionMinimumDominatingSet witness reduction source type mismatch");
-            Box::new(
-                <Decision<MinimumDominatingSet<SimpleGraph, One>> as crate::rules::ReduceTo<
-                    MinimumDominatingSet<SimpleGraph, One>,
-                >>::reduce_to(source),
-            )
-        }),
-        reduce_aggregate_fn: Some(|any| {
-            let source = any
-                .downcast_ref::<Decision<MinimumDominatingSet<SimpleGraph, One>>>()
-                .expect("DecisionMinimumDominatingSet aggregate reduction source type mismatch");
-            Box::new(
-                <Decision<MinimumDominatingSet<SimpleGraph, One>> as crate::rules::ReduceToAggregate<
-                    MinimumDominatingSet<SimpleGraph, One>,
-                >>::reduce_to_aggregate(source),
-            )
-        }),
-        capabilities: crate::rules::EdgeCapabilities::both(),
-        overhead_eval_fn: |any| {
-            let source = any
-                .downcast_ref::<Decision<MinimumDominatingSet<SimpleGraph, One>>>()
-                .expect("DecisionMinimumDominatingSet overhead source type mismatch");
-            crate::types::ProblemSize::new(vec![
-                ("num_vertices", source.num_vertices()),
-                ("num_edges", source.num_edges()),
-            ])
-        },
-        source_size_fn: |any| {
-            let source = any
-                .downcast_ref::<Decision<MinimumDominatingSet<SimpleGraph, One>>>()
-                .expect("DecisionMinimumDominatingSet size source type mismatch");
-            crate::types::ProblemSize::new(vec![
-                ("num_vertices", source.num_vertices()),
-                ("num_edges", source.num_edges()),
-                ("k", source.k()),
-            ])
-        },
-    }
-}
-
-// Reverse edge: MDS<SG, One> → Decision<MDS<SG, One>> (Turing)
-inventory::submit! {
-    crate::rules::ReductionEntry {
-        source_name: "MinimumDominatingSet",
-        target_name: "DecisionMinimumDominatingSet",
-        source_variant_fn: <MinimumDominatingSet<SimpleGraph, One> as Problem>::variant,
-        target_variant_fn: <Decision<MinimumDominatingSet<SimpleGraph, One>> as Problem>::variant,
-        overhead_fn: || crate::rules::ReductionOverhead::identity(&["num_vertices", "num_edges"]),
-        module_path: module_path!(),
-        reduce_fn: None,
-        reduce_aggregate_fn: None,
-        capabilities: crate::rules::EdgeCapabilities::turing(),
-        overhead_eval_fn: |any| {
-            let source = any
-                .downcast_ref::<MinimumDominatingSet<SimpleGraph, One>>()
-                .expect("DecisionMinimumDominatingSet turing overhead source type mismatch");
-            crate::types::ProblemSize::new(vec![
-                ("num_vertices", source.num_vertices()),
-                ("num_edges", source.num_edges()),
-            ])
-        },
-        source_size_fn: |any| {
-            let source = any
-                .downcast_ref::<MinimumDominatingSet<SimpleGraph, One>>()
-                .expect("DecisionMinimumDominatingSet turing size source type mismatch");
-            crate::types::ProblemSize::new(vec![
-                ("num_vertices", source.num_vertices()),
-                ("num_edges", source.num_edges()),
-            ])
-        },
-    }
-}
-
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "minimum_dominating_set_simplegraph_i32",
+        id: "minimum_dominating_set_simplegraph",
         instance: Box::new(MinimumDominatingSet::new(
             SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]),
-            vec![1i32; 5],
+            vec![1i64; 5],
         )),
-        optimal_config: vec![0, 0, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![false, false, true, true, false]),
         optimal_value: serde_json::json!(2),
     }]
 }
@@ -376,19 +322,19 @@ pub(crate) fn decision_canonical_model_example_specs(
 ) -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![
         crate::example_db::specs::ModelExampleSpec {
-            id: "decision_minimum_dominating_set_simplegraph_i32",
+            id: "decision_minimum_dominating_set_simplegraph",
             instance: Box::new(Decision::new(
                 MinimumDominatingSet::new(
                     SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]),
-                    vec![1i32; 5],
+                    vec![1i64; 5],
                 ),
                 2,
             )),
-            optimal_config: vec![0, 0, 1, 1, 0],
+            optimal_config: serde_json::json!(vec![false, false, true, true, false]),
             optimal_value: serde_json::json!(true),
         },
         crate::example_db::specs::ModelExampleSpec {
-            id: "decision_minimum_dominating_set_simplegraph_one",
+            id: "decision_minimum_dominating_set_six_vertex_graph",
             instance: Box::new(Decision::new(
                 MinimumDominatingSet::new(
                     SimpleGraph::new(
@@ -399,7 +345,7 @@ pub(crate) fn decision_canonical_model_example_specs(
                 ),
                 2,
             )),
-            optimal_config: vec![1, 0, 0, 1, 0, 0],
+            optimal_config: serde_json::json!(vec![true, false, false, true, false, false]),
             optimal_value: serde_json::json!(true),
         },
     ]
@@ -419,26 +365,28 @@ pub(crate) fn decision_canonical_rule_example_specs(
                 let source = crate::models::decision::Decision::new(
                     MinimumDominatingSet::new(
                         SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]),
-                        vec![1i32; 5],
+                        vec![1i64; 5],
                     ),
                     2,
                 );
-                let result = source.reduce_to_aggregate();
+                let result = source
+                    .reduce_to_aggregate()
+                    .expect("reduction should succeed");
                 let target = result.target_problem();
-                let config = vec![0, 0, 1, 1, 0];
+                let config = vec![false, false, true, true, false];
                 assemble_rule_example(
                     &source,
                     target,
                     vec![SolutionPair {
-                        source_config: config.clone(),
-                        target_config: config,
+                        source_config: serde_json::json!(config.clone()),
+                        target_config: serde_json::json!(config),
                     }],
                 )
             },
         },
-        // One-weight variant: Decision<MDS<SG, One>> → MDS<SG, One> (aggregate)
+        // Cardinality variant: Decision<MDS<SG, One>> → MDS<SG, One> (aggregate)
         crate::example_db::specs::RuleExampleSpec {
-            id: "decision_minimum_dominating_set_one_to_minimum_dominating_set_one",
+            id: "decision_cardinality_dominating_set_to_minimum_dominating_set",
             build: || {
                 use crate::example_db::specs::assemble_rule_example;
                 use crate::export::SolutionPair;
@@ -451,15 +399,17 @@ pub(crate) fn decision_canonical_rule_example_specs(
                     ),
                     2,
                 );
-                let result = source.reduce_to_aggregate();
+                let result = source
+                    .reduce_to_aggregate()
+                    .expect("reduction should succeed");
                 let target = result.target_problem();
-                let config = vec![0, 0, 1, 1, 0];
+                let config = vec![false, false, true, true, false];
                 assemble_rule_example(
                     &source,
                     target,
                     vec![SolutionPair {
-                        source_config: config.clone(),
-                        target_config: config,
+                        source_config: serde_json::json!(config.clone()),
+                        target_config: serde_json::json!(config),
                     }],
                 )
             },
diff --git a/src/models/graph/minimum_dummy_activities_pert.rs b/src/models/graph/minimum_dummy_activities_pert.rs
index c4a8dbdb0..c272044d6 100644
--- a/src/models/graph/minimum_dummy_activities_pert.rs
+++ b/src/models/graph/minimum_dummy_activities_pert.rs
@@ -7,7 +7,7 @@
 //! resulting event network is acyclic and preserves exactly the same
 //! task-to-task reachability relation as the original DAG.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -20,15 +20,10 @@ inventory::submit! {
         display_name: "Minimum Dummy Activities in PERT Networks",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a PERT event network for a precedence DAG minimizing dummy activities",
-        fields: &[
-            FieldInfo {
-                name: "graph",
-                type_name: "DirectedGraph",
-                description: "The precedence DAG G=(V,A) whose vertices are tasks and arcs encode direct precedence constraints",
-            },
-        ],
+        fields: MinimumDummyActivitiesPertCreateSpec::FIELDS,
     }
 }
 
@@ -46,9 +41,36 @@ pub struct MinimumDummyActivitiesPert {
     graph: DirectedGraph,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumDummyActivitiesPertCreateSpec {
+    /// Directed precedence arcs.
+    #[create(codec = "arc-list")]
+    arcs: Vec<(usize, usize)>,
+    /// Vertex count, needed to preserve isolated tasks.
+    num_vertices: Option<usize>,
+}
+impl TryFrom<MinimumDummyActivitiesPertCreateSpec> for MinimumDummyActivitiesPert {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumDummyActivitiesPertCreateSpec) -> Result<Self, Self::Error> {
+        let inferred = spec
+            .arcs
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let num_vertices = spec.num_vertices.unwrap_or(inferred);
+        if num_vertices < inferred {
+            return Err("num_vertices is too small for the provided arcs".into());
+        }
+        Self::try_new(DirectedGraph::new(num_vertices, spec.arcs))
+    }
+}
+
 impl MinimumDummyActivitiesPert {
     /// Fallible constructor used by CLI validation and deserialization.
-    pub fn try_new(graph: DirectedGraph) -> Result<Self, String> {
+    pub fn try_new(graph: DirectedGraph) -> Result<Self, crate::registry::ConstructionError> {
         if !graph.is_dag() {
             return Err("MinimumDummyActivitiesPert requires the input graph to be a DAG".into());
         }
@@ -80,24 +102,60 @@ impl MinimumDummyActivitiesPert {
     }
 
     /// Check whether the merge-selection config encodes a valid PERT network.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).is_valid()
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(self.evaluate_solution(config)?.is_valid())
+    }
+
+    fn evaluate_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.precedence_arcs().len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "arc-selection length does not match the precedence graph".into(),
+            ));
+        }
+        let Some(candidate) = self.build_candidate_network(config) else {
+            return Ok(Min(None));
+        };
+
+        let source_reachability = reachability_matrix(&self.graph);
+        let event_reachability = reachability_matrix(&candidate.event_graph);
+
+        for source in 0..self.num_vertices() {
+            for target in 0..self.num_vertices() {
+                let pert_reachable = candidate.finish_events[source]
+                    == candidate.start_events[target]
+                    || event_reachability[candidate.finish_events[source]]
+                        [candidate.start_events[target]];
+                if source_reachability[source][target] != pert_reachable {
+                    return Ok(Min(None));
+                }
+            }
+        }
+
+        Ok(Min(Some(
+            i64::try_from(candidate.num_dummy_arcs).expect("dummy activity count must fit in i64"),
+        )))
     }
 
     fn precedence_arcs(&self) -> Vec<(usize, usize)> {
         self.graph.arcs()
     }
 
-    fn build_candidate_network(&self, config: &[usize]) -> Option<CandidatePertNetwork> {
+    fn build_candidate_network(&self, config: &[bool]) -> Option<CandidatePertNetwork> {
         let num_tasks = self.num_vertices();
         let arcs = self.precedence_arcs();
-        if config.len() != arcs.len() || config.iter().any(|&bit| bit > 1) {
+        if config.len() != arcs.len() {
             return None;
         }
 
         let mut uf = UnionFind::new(2 * num_tasks);
         for ((u, v), &merge_bit) in arcs.iter().zip(config.iter()) {
-            if merge_bit == 1 {
+            if merge_bit {
                 uf.union(finish_endpoint(*u), start_endpoint(*v));
             }
         }
@@ -134,7 +192,7 @@ impl MinimumDummyActivitiesPert {
             .iter()
             .zip(config.iter())
             .filter_map(|((u, v), &merge_bit)| {
-                if merge_bit == 1 {
+                if merge_bit {
                     return None;
                 }
                 let source = finish_events[*u];
@@ -164,44 +222,35 @@ impl MinimumDummyActivitiesPert {
 
 impl Problem for MinimumDummyActivitiesPert {
     const NAME: &'static str = "MinimumDummyActivitiesPert";
-    type Value = Min<i32>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_vertices", num_vertices), ("num_arcs", num_arcs),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_arcs()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        self.evaluate_solution(config)
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<i32> {
-        let Some(candidate) = self.build_candidate_network(config) else {
-            return Min(None);
-        };
-
-        let source_reachability = reachability_matrix(&self.graph);
-        let event_reachability = reachability_matrix(&candidate.event_graph);
-
-        for source in 0..self.num_vertices() {
-            for target in 0..self.num_vertices() {
-                let pert_reachable = candidate.finish_events[source]
-                    == candidate.start_events[target]
-                    || event_reachability[candidate.finish_events[source]]
-                        [candidate.start_events[target]];
-                if source_reachability[source][target] != pert_reachable {
-                    return Min(None);
-                }
-            }
-        }
-
-        Min(Some(
-            i32::try_from(candidate.num_dummy_arcs).expect("dummy activity count must fit in i32"),
-        ))
+impl crate::solvers::BruteForceProblem for MinimumDummyActivitiesPert {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_arcs()]
     }
 }
 
 crate::declare_variants! {
-    default MinimumDummyActivitiesPert => "2^num_arcs",
+    default MinimumDummyActivitiesPert => "2^num_arcs" create MinimumDummyActivitiesPertCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumDummyActivitiesPert decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -212,7 +261,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             6,
             vec![(0, 2), (0, 3), (1, 3), (1, 4), (2, 5)],
         ))),
-        optimal_config: vec![1, 0, 0, 1, 1],
+        optimal_config: serde_json::json!(vec![true, false, false, true, true]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/graph/minimum_edge_cost_flow.rs b/src/models/graph/minimum_edge_cost_flow.rs
index 86edf9980..79e0ab8dd 100644
--- a/src/models/graph/minimum_edge_cost_flow.rs
+++ b/src/models/graph/minimum_edge_cost_flow.rs
@@ -19,6 +19,7 @@ inventory::submit! {
         display_name: "Minimum Edge-Cost Flow",
         aliases: &["MECF"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Integral flow minimizing the number of arcs with nonzero flow (weighted by price)",
         fields: &[
@@ -48,7 +49,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumEdgeCostFlow;
 /// use problemreductions::topology::DirectedGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 5-vertex network: s=0, t=4, R=3
 /// let graph = DirectedGraph::new(5, vec![
@@ -61,8 +62,8 @@ inventory::submit! {
 ///     0, 4, 3,
 /// );
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem).unwrap();
-/// assert_eq!(problem.evaluate(&witness), problemreductions::types::Min(Some(3)));
+/// let witness = solver.solve(&problem).unwrap().unwrap();
+/// assert_eq!(problem.evaluate(&witness).unwrap(), problemreductions::types::Min(Some(3)));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumEdgeCostFlow {
@@ -195,17 +196,22 @@ impl MinimumEdgeCostFlow {
     /// 1. Each arc's flow does not exceed its capacity
     /// 2. Flow is conserved at every non-terminal vertex
     /// 3. Net flow into the sink is at least the required flow
-    pub fn is_feasible(&self, config: &[usize]) -> bool {
+    pub fn is_feasible(&self, config: &[usize]) -> Result<bool, crate::traits::EvaluationError> {
         let m = self.graph.num_arcs();
         if config.len() != m {
-            return false;
+            return Ok(false);
         }
         let arcs = self.graph.arcs();
 
         // (1) Capacity constraints
         for (flow, cap) in config.iter().zip(self.capacities.iter()) {
-            if (*flow as i64) > *cap {
-                return false;
+            let flow = i64::try_from(*flow).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting edge-cost flow configuration value".to_string(),
+                )
+            })?;
+            if flow > *cap {
+                return Ok(false);
             }
         }
 
@@ -213,51 +219,81 @@ impl MinimumEdgeCostFlow {
         let n = self.graph.num_vertices();
         let mut balance = vec![0_i64; n];
         for (a, &(u, v)) in arcs.iter().enumerate() {
-            let flow = config[a] as i64;
-            balance[u] -= flow;
-            balance[v] += flow;
+            let flow = i64::try_from(config[a]).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting edge-cost flow configuration value".to_string(),
+                )
+            })?;
+            balance[u] = balance[u].checked_sub(flow).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "computing edge-cost flow balance".to_string(),
+                )
+            })?;
+            balance[v] = balance[v].checked_add(flow).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "computing edge-cost flow balance".to_string(),
+                )
+            })?;
         }
 
         for (v, &bal) in balance.iter().enumerate() {
             if v != self.source && v != self.sink && bal != 0 {
-                return false;
+                return Ok(false);
             }
         }
 
         // (3) Flow requirement: net flow into sink >= R
         if balance[self.sink] < self.required_flow {
-            return false;
+            return Ok(false);
         }
 
-        true
+        Ok(true)
     }
 
     /// Compute the edge cost for a feasible flow: sum of prices of arcs with
     /// nonzero flow.
-    pub fn edge_cost(&self, config: &[usize]) -> i64 {
+    pub fn edge_cost(&self, config: &[usize]) -> Result<i64, crate::traits::EvaluationError> {
         config
             .iter()
             .enumerate()
-            .filter(|(_, &f)| f > 0)
-            .map(|(a, _)| self.prices[a])
-            .sum()
+            .filter(|(_, &flow)| flow > 0)
+            .try_fold(0_i64, |total, (arc, _)| {
+                total.checked_add(self.prices[arc]).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing selected edge prices".to_string(),
+                    )
+                })
+            })
     }
 }
 
 impl Problem for MinimumEdgeCostFlow {
     const NAME: &'static str = "MinimumEdgeCostFlow";
+    type Solution = Vec<usize>;
     type Value = crate::types::Min<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        self.capacities.iter().map(|&c| (c as usize) + 1).collect()
-    }
+    crate::problem_parameters![
+        ("max_capacity", max_capacity),
+        ("num_edges", num_edges),
+        ("num_vertices", num_vertices),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Min<i64> {
-        if self.is_feasible(config) {
-            crate::types::Min(Some(self.edge_cost(config)))
-        } else {
-            crate::types::Min(None)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_arcs() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "flow vector length does not match the graph arcs".into(),
+            ));
         }
+        Ok({
+            if self.is_feasible(config)? {
+                crate::types::Min(Some(self.edge_cost(config)?))
+            } else {
+                crate::types::Min(None)
+            }
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -265,10 +301,20 @@ impl Problem for MinimumEdgeCostFlow {
     }
 }
 
+impl crate::solvers::BruteForceProblem for MinimumEdgeCostFlow {
+    fn dimensions(&self) -> Vec<usize> {
+        self.capacities.iter().map(|&c| (c as usize) + 1).collect()
+    }
+}
+
 crate::declare_variants! {
     default MinimumEdgeCostFlow => "(max_capacity + 1)^num_edges",
 }
 
+crate::register_brute_force! {
+    MinimumEdgeCostFlow,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -286,7 +332,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         )),
         // Optimal: route 1 unit via v2 and 2 units via v3 → cost = 1 + 2 = 3
         // config = [0, 1, 2, 0, 1, 2]
-        optimal_config: vec![0, 1, 2, 0, 1, 2],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 0, 1, 2]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/graph/minimum_feedback_arc_set.rs b/src/models/graph/minimum_feedback_arc_set.rs
index a69fa1aa6..7c337a1d5 100644
--- a/src/models/graph/minimum_feedback_arc_set.rs
+++ b/src/models/graph/minimum_feedback_arc_set.rs
@@ -3,7 +3,7 @@
 //! The Feedback Arc Set problem asks for a minimum-weight subset of arcs
 //! whose removal makes a directed graph acyclic (a DAG).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
@@ -16,14 +16,12 @@ inventory::submit! {
         display_name: "Minimum Feedback Arc Set",
         aliases: &["FAS"],
         dimensions: &[
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum weight feedback arc set in a directed graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "DirectedGraph", description: "The directed graph G=(V,A)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Arc weights w: A -> R" },
-        ],
+        fields: MinimumFeedbackArcSetCreateSpec::FIELDS,
     }
 }
 
@@ -44,18 +42,18 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumFeedbackArcSet;
 /// use problemreductions::topology::DirectedGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Directed cycle: 0->1->2->0
 /// let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-/// let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
+/// let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
 ///
 /// // Solve with brute force
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem).unwrap();
+/// let solution = solver.solve(&problem).unwrap().unwrap();
 ///
 /// // Minimum FAS has size 1 (remove any single arc to break the cycle)
-/// assert_eq!(solution.iter().sum::<usize>(), 1);
+/// assert_eq!(solution.iter().filter(|&&selected| selected).count(), 1);
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumFeedbackArcSet<W> {
@@ -65,6 +63,25 @@ pub struct MinimumFeedbackArcSet<W> {
     weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumFeedbackArcSetCreateSpec {
+    /// The directed graph.
+    graph: DirectedGraph,
+    /// Arc weights; defaults to one per arc.
+    weights: Option<Vec<i64>>,
+}
+impl TryFrom<MinimumFeedbackArcSetCreateSpec> for MinimumFeedbackArcSet<i64> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumFeedbackArcSetCreateSpec) -> Result<Self, Self::Error> {
+        let count = spec.graph.num_arcs();
+        let weights = spec.weights.unwrap_or_else(|| vec![1; count]);
+        if weights.len() != count {
+            return Err(format!("weights has {} entries, expected {count}", weights.len()).into());
+        }
+        Ok(Self::new(spec.graph, weights))
+    }
+}
+
 impl<W: Clone + Default> MinimumFeedbackArcSet<W> {
     /// Create a Minimum Feedback Arc Set problem from a directed graph with given weights.
     pub fn new(graph: DirectedGraph, weights: Vec<W>) -> Self {
@@ -99,7 +116,7 @@ impl<W: Clone + Default> MinimumFeedbackArcSet<W> {
     /// Check if a configuration is a valid feedback arc set.
     ///
     /// A configuration is valid if removing the selected arcs makes the graph acyclic.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_valid_fas(&self.graph, config)
     }
 }
@@ -126,27 +143,49 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumFeedbackArcSet";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![("num_arcs", num_arcs), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_arcs()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        if !is_valid_fas(&self.graph, config) {
-            return Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_arcs() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "arc-selection length does not match the graph".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (i, &selected) in config.iter().enumerate() {
-            if selected != 0 {
-                total += self.weights[i].to_sum();
+        Ok({
+            if !is_valid_fas(&self.graph, config) {
+                return Ok(Min(None));
             }
-        }
-        Min(Some(total))
+            let mut total = W::Sum::zero();
+            for (i, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.weights[i].to_sum(),
+                        "summing selected feedback-arc weights",
+                    )?;
+                }
+            }
+            Min(Some(total))
+        })
+    }
+}
+
+impl<W> crate::solvers::BruteForceProblem for MinimumFeedbackArcSet<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_arcs()]
     }
 }
 
@@ -154,18 +193,22 @@ where
 ///
 /// config[i] = 1 means arc i is selected for removal.
 /// The remaining arcs must form a DAG.
-fn is_valid_fas(graph: &DirectedGraph, config: &[usize]) -> bool {
+fn is_valid_fas(graph: &DirectedGraph, config: &[bool]) -> bool {
     let num_arcs = graph.num_arcs();
     if config.len() != num_arcs {
         return false;
     }
     // kept_arcs[i] = true means arc i is NOT removed (kept in the graph)
-    let kept_arcs: Vec<bool> = config.iter().map(|&x| x == 0).collect();
+    let kept_arcs: Vec<bool> = config.iter().map(|&removed| !removed).collect();
     graph.is_acyclic_subgraph(&kept_arcs)
 }
 
 crate::declare_variants! {
-    default MinimumFeedbackArcSet<i32> => "2^num_vertices",
+    default MinimumFeedbackArcSet<i64> => "2^num_vertices" create MinimumFeedbackArcSetCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumFeedbackArcSet<i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -176,9 +219,9 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         id: "minimum_feedback_arc_set",
         instance: Box::new(MinimumFeedbackArcSet::new(
             DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]),
-            vec![1i32, 1, 1],
+            vec![1i64, 1, 1],
         )),
-        optimal_config: vec![0, 0, 1],
+        optimal_config: serde_json::json!(vec![false, false, true]),
         optimal_value: serde_json::json!(1),
     }]
 }
diff --git a/src/models/graph/minimum_feedback_vertex_set.rs b/src/models/graph/minimum_feedback_vertex_set.rs
index fe6b277e4..762efe3da 100644
--- a/src/models/graph/minimum_feedback_vertex_set.rs
+++ b/src/models/graph/minimum_feedback_vertex_set.rs
@@ -3,10 +3,10 @@
 //! The Feedback Vertex Set problem asks for a minimum weight subset of vertices
 //! whose removal makes the directed graph acyclic (a DAG).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
-use crate::types::{Min, WeightElement};
+use crate::types::{Min, One, WeightElement};
 use num_traits::Zero;
 use serde::{Deserialize, Serialize};
 
@@ -16,14 +16,12 @@ inventory::submit! {
         display_name: "Minimum Feedback Vertex Set",
         aliases: &["FVS"],
         dimensions: &[
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64", "One"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum weight feedback vertex set in a directed graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "DirectedGraph", description: "The directed graph G=(V,A)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-        ],
+        fields: MinimumFeedbackVertexSetCreateSpec::<i64>::FIELDS,
     }
 }
 
@@ -39,14 +37,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumFeedbackVertexSet;
 /// use problemreductions::topology::DirectedGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Simple 3-cycle: 0 → 1 → 2 → 0
 /// let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
 /// let problem = MinimumFeedbackVertexSet::new(graph, vec![1; 3]);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Any single vertex breaks the cycle
 /// assert_eq!(solutions.len(), 3);
@@ -59,6 +57,27 @@ pub struct MinimumFeedbackVertexSet<W> {
     weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumFeedbackVertexSetCreateSpec<W> {
+    /// The directed graph.
+    graph: DirectedGraph,
+    /// Vertex weights; defaults to one per vertex.
+    weights: Option<Vec<W>>,
+}
+impl<W: WeightElement> TryFrom<MinimumFeedbackVertexSetCreateSpec<W>>
+    for MinimumFeedbackVertexSet<W>
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumFeedbackVertexSetCreateSpec<W>) -> Result<Self, Self::Error> {
+        let count = spec.graph.num_vertices();
+        let weights = spec.weights.unwrap_or_else(|| vec![W::unit(); count]);
+        if weights.len() != count {
+            return Err(format!("weights has {} entries, expected {count}", weights.len()).into());
+        }
+        Ok(Self::new(spec.graph, weights))
+    }
+}
+
 impl<W: Clone + Default> MinimumFeedbackVertexSet<W> {
     /// Create a Feedback Vertex Set problem from a directed graph with given weights.
     pub fn new(graph: DirectedGraph, weights: Vec<W>) -> Self {
@@ -122,55 +141,105 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumFeedbackVertexSet";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![("num_arcs", num_arcs), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![W]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.graph.num_vertices() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "vertex-selection length does not match the graph".into(),
+                ));
+            }
+            // keep[v] = true if vertex v is NOT selected for removal
+            let keep: Vec<bool> = config.iter().map(|&removed| !removed).collect();
+            let subgraph = self.graph.induced_subgraph(&keep);
+            if !subgraph.is_dag() {
+                return Ok(Min(None));
+            }
+            let mut total = W::Sum::zero();
+            for (i, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.weights[i].to_sum(),
+                        "summing selected feedback-vertex weights",
+                    )?;
+                }
+            }
+            Min(Some(total))
+        })
+    }
+}
+
+impl<W> crate::solvers::BruteForceProblem for MinimumFeedbackVertexSet<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
         vec![2; self.graph.num_vertices()]
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        if config.len() != self.graph.num_vertices() {
-            return Min(None);
-        }
-        // keep[v] = true if vertex v is NOT selected for removal
-        let keep: Vec<bool> = config.iter().map(|&c| c == 0).collect();
-        let subgraph = self.graph.induced_subgraph(&keep);
-        if !subgraph.is_dag() {
-            return Min(None);
-        }
-        let mut total = W::Sum::zero();
-        for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.weights[i].to_sum();
-            }
-        }
-        Min(Some(total))
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumFeedbackVertexSetOneCreateSpec {
+    /// The underlying graph.
+    graph: DirectedGraph,
+}
+
+impl TryFrom<MinimumFeedbackVertexSetOneCreateSpec> for MinimumFeedbackVertexSet<One> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumFeedbackVertexSetOneCreateSpec) -> Result<Self, Self::Error> {
+        let weights = vec![One; spec.graph.num_vertices()];
+        Ok(Self::new(spec.graph, weights))
     }
 }
 
 crate::declare_variants! {
-    default MinimumFeedbackVertexSet<i32> => "1.9977^num_vertices",
+    default MinimumFeedbackVertexSet<i64> => "1.9977^num_vertices" create MinimumFeedbackVertexSetCreateSpec<i64>,
+    MinimumFeedbackVertexSet<One> => "1.9977^num_vertices" create MinimumFeedbackVertexSetOneCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumFeedbackVertexSet<i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MinimumFeedbackVertexSet<One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     use crate::topology::DirectedGraph;
-    vec![crate::example_db::specs::ModelExampleSpec {
-        id: "minimum_feedback_vertex_set_i32",
-        instance: Box::new(MinimumFeedbackVertexSet::new(
-            DirectedGraph::new(
-                5,
-                vec![(0, 1), (1, 2), (2, 0), (0, 3), (3, 4), (4, 1), (4, 2)],
-            ),
-            vec![1i32; 5],
-        )),
-        optimal_config: vec![1, 0, 0, 0, 0],
-        optimal_value: serde_json::json!(1),
-    }]
+    vec![
+        crate::example_db::specs::ModelExampleSpec {
+            id: "minimum_feedback_vertex_set",
+            instance: Box::new(MinimumFeedbackVertexSet::new(
+                DirectedGraph::new(
+                    5,
+                    vec![(0, 1), (1, 2), (2, 0), (0, 3), (3, 4), (4, 1), (4, 2)],
+                ),
+                vec![1i64; 5],
+            )),
+            optimal_config: serde_json::json!(vec![true, false, false, false, false]),
+            optimal_value: serde_json::json!(1),
+        },
+        crate::example_db::specs::ModelExampleSpec {
+            id: "minimum_feedback_vertex_set_unit",
+            instance: Box::new(MinimumFeedbackVertexSet::new(
+                DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]),
+                vec![One; 3],
+            )),
+            optimal_config: serde_json::json!(vec![true, false, false]),
+            optimal_value: serde_json::json!(1),
+        },
+    ]
 }
 
 /// Check if a set of vertices is a feedback vertex set (removing them makes the graph a DAG).
diff --git a/src/models/graph/minimum_geometric_connected_dominating_set.rs b/src/models/graph/minimum_geometric_connected_dominating_set.rs
index b295af09e..393b20b6c 100644
--- a/src/models/graph/minimum_geometric_connected_dominating_set.rs
+++ b/src/models/graph/minimum_geometric_connected_dominating_set.rs
@@ -5,7 +5,7 @@
 //! 1. Every point in P \ P' is within Euclidean distance B of some point in P' (domination).
 //! 2. The subgraph induced on P' (edges between points within distance B) is connected.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{ConstructionError, FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Minimum Geometric Connected Dominating Set",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum connected dominating set in a geometric point set",
         fields: &[
@@ -45,19 +46,19 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::graph::MinimumGeometricConnectedDominatingSet;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Four collinear points with spacing 3 and radius 3.5:
 /// // each point reaches its immediate neighbor but not two steps away.
 /// let points = vec![(0.0, 0.0), (3.0, 0.0), (6.0, 0.0), (9.0, 0.0)];
-/// let problem = MinimumGeometricConnectedDominatingSet::new(points, 3.5);
+/// let problem = MinimumGeometricConnectedDominatingSet::new(points, 3.5).unwrap();
 ///
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem).unwrap();
-/// let value = problem.evaluate(&witness).unwrap();
+/// let witness = solver.solve(&problem).unwrap().unwrap();
+/// let value = problem.evaluate(&witness).unwrap().unwrap();
 /// assert_eq!(value, 2); // Two interior points dominate all and form a connected pair
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct MinimumGeometricConnectedDominatingSet {
     /// The set of points in the plane.
     points: Vec<(f64, f64)>,
@@ -68,21 +69,28 @@ pub struct MinimumGeometricConnectedDominatingSet {
 impl MinimumGeometricConnectedDominatingSet {
     /// Create a new instance.
     ///
-    /// # Panics
-    /// Panics if `radius <= 0.0` or if `points` is empty.
-    pub fn new(points: Vec<(f64, f64)>, radius: f64) -> Self {
-        assert!(radius > 0.0, "radius must be positive");
-        assert!(!points.is_empty(), "points must be non-empty");
-        Self { points, radius }
-    }
-
-    /// Fallible constructor used by CLI validation and deserialization.
-    pub fn try_new(points: Vec<(f64, f64)>, radius: f64) -> Result<Self, String> {
-        if radius <= 0.0 {
-            return Err("radius must be positive".into());
-        }
+    pub fn new(points: Vec<(f64, f64)>, radius: f64) -> Result<Self, ConstructionError> {
         if points.is_empty() {
-            return Err("points must be non-empty".into());
+            return Err(ConstructionError::Conversion(
+                "points must be non-empty".into(),
+            ));
+        }
+        if !radius.is_finite() || radius <= 0.0 {
+            if !radius.is_finite() {
+                return Err(ConstructionError::NonFiniteFloat(
+                    "radius must be finite".into(),
+                ));
+            }
+            return Err(ConstructionError::Conversion(
+                "radius must be positive".into(),
+            ));
+        }
+        for (index, &(x, y)) in points.iter().enumerate() {
+            if !x.is_finite() || !y.is_finite() {
+                return Err(ConstructionError::NonFiniteFloat(format!(
+                    "point at index {index} must have finite coordinates"
+                )));
+            }
         }
         Ok(Self { points, radius })
     }
@@ -103,41 +111,74 @@ impl MinimumGeometricConnectedDominatingSet {
     }
 
     /// Squared Euclidean distance between two points.
-    fn dist_sq(a: (f64, f64), b: (f64, f64)) -> f64 {
+    fn dist_sq(a: (f64, f64), b: (f64, f64)) -> Result<f64, crate::traits::EvaluationError> {
         let dx = a.0 - b.0;
         let dy = a.1 - b.1;
-        dx * dx + dy * dy
+        let distance = dx * dx + dy * dy;
+        distance.is_finite().then_some(distance).ok_or_else(|| {
+            crate::traits::EvaluationError::NonFiniteResult(
+                "computing geometric squared distance".into(),
+            )
+        })
     }
 
     /// Check if two points are within distance B.
-    fn within_radius(&self, i: usize, j: usize) -> bool {
-        Self::dist_sq(self.points[i], self.points[j]) <= self.radius * self.radius
+    fn within_radius(
+        &self,
+        i: usize,
+        j: usize,
+        radius_squared: f64,
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(Self::dist_sq(self.points[i], self.points[j])? <= radius_squared)
     }
 
     /// Check if a configuration is a valid connected dominating set.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if config.len() != self.points.len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "geometric connected dominating set expects one Boolean value per point".into(),
+            ));
+        }
+        let radius_squared = self.radius * self.radius;
+        if !radius_squared.is_finite() {
+            return Err(crate::traits::EvaluationError::NonFiniteResult(
+                "squaring the geometric radius".into(),
+            ));
+        }
         let selected: Vec<usize> = config
             .iter()
             .enumerate()
-            .filter(|(_, &v)| v == 1)
+            .filter(|(_, &v)| v)
             .map(|(i, _)| i)
             .collect();
 
         if selected.is_empty() {
-            return false;
+            return Ok(false);
         }
 
         // Check domination: every unselected point must be within distance B
         // of some selected point.
         for (i, &v) in config.iter().enumerate() {
-            if v == 0 && !selected.iter().any(|&s| self.within_radius(i, s)) {
-                return false;
+            if !v {
+                let mut dominated = false;
+                for &s in &selected {
+                    if self.within_radius(i, s, radius_squared)? {
+                        dominated = true;
+                        break;
+                    }
+                }
+                if !dominated {
+                    return Ok(false);
+                }
             }
         }
 
         // Check connectivity: BFS on selected points using distance-B edges.
         if selected.len() == 1 {
-            return true;
+            return Ok(true);
         }
         let mut visited = vec![false; selected.len()];
         let mut queue = VecDeque::new();
@@ -145,34 +186,64 @@ impl MinimumGeometricConnectedDominatingSet {
         queue.push_back(0);
         while let Some(u) = queue.pop_front() {
             for (vi, &vj) in selected.iter().enumerate() {
-                if !visited[vi] && self.within_radius(selected[u], vj) {
+                if !visited[vi] && self.within_radius(selected[u], vj, radius_squared)? {
                     visited[vi] = true;
                     queue.push_back(vi);
                 }
             }
         }
-        visited.iter().all(|&v| v)
+        Ok(visited.iter().all(|&v| v))
+    }
+}
+
+impl<'de> Deserialize<'de> for MinimumGeometricConnectedDominatingSet {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Raw {
+            points: Vec<(f64, f64)>,
+            radius: f64,
+        }
+
+        let raw = Raw::deserialize(deserializer)?;
+        Self::new(raw.points, raw.radius).map_err(serde::de::Error::custom)
     }
 }
 
 impl Problem for MinimumGeometricConnectedDominatingSet {
     const NAME: &'static str = "MinimumGeometricConnectedDominatingSet";
-    type Value = Min<usize>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_points", num_points),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_points()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if !self.is_valid_solution(config)? {
+                return Ok(Min(None));
+            }
+            let count = config.iter().filter(|&&v| v).count();
+            Min(Some(i64::try_from(count).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting dominating-set cardinality to i64".into(),
+                )
+            })?))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if !self.is_valid_solution(config) {
-            return Min(None);
-        }
-        let count = config.iter().filter(|&&v| v == 1).count();
-        Min(Some(count))
+impl crate::solvers::BruteForceProblem for MinimumGeometricConnectedDominatingSet {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_points()]
     }
 }
 
@@ -180,24 +251,31 @@ crate::declare_variants! {
     default MinimumGeometricConnectedDominatingSet => "2^num_points",
 }
 
+crate::register_brute_force! {
+    MinimumGeometricConnectedDominatingSet decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "minimum_geometric_connected_dominating_set",
-        instance: Box::new(MinimumGeometricConnectedDominatingSet::new(
-            vec![
-                (0.0, 0.0),
-                (3.0, 0.0),
-                (6.0, 0.0),
-                (9.0, 0.0),
-                (0.0, 3.0),
-                (3.0, 3.0),
-                (6.0, 3.0),
-                (9.0, 3.0),
-            ],
-            3.5,
-        )),
-        optimal_config: vec![1, 1, 1, 1, 0, 0, 0, 0],
+        instance: Box::new(
+            MinimumGeometricConnectedDominatingSet::new(
+                vec![
+                    (0.0, 0.0),
+                    (3.0, 0.0),
+                    (6.0, 0.0),
+                    (9.0, 0.0),
+                    (0.0, 3.0),
+                    (3.0, 3.0),
+                    (6.0, 3.0),
+                    (9.0, 3.0),
+                ],
+                3.5,
+            )
+            .expect("canonical geometric connected-dominating-set instance must be valid"),
+        ),
+        optimal_config: serde_json::json!(vec![true, true, true, true, false, false, false, false]),
         optimal_value: serde_json::json!(4),
     }]
 }
diff --git a/src/models/graph/minimum_graph_bandwidth.rs b/src/models/graph/minimum_graph_bandwidth.rs
index aac0cbce3..d214d03e8 100644
--- a/src/models/graph/minimum_graph_bandwidth.rs
+++ b/src/models/graph/minimum_graph_bandwidth.rs
@@ -18,6 +18,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a vertex ordering minimizing the maximum edge stretch",
         fields: &[
@@ -47,14 +48,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumGraphBandwidth;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Star graph S4: center 0 connected to 1, 2, 3
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]);
 /// let problem = MinimumGraphBandwidth::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -107,16 +108,23 @@ impl<G: Graph> MinimumGraphBandwidth<G> {
     /// Compute the bandwidth (maximum edge stretch) for a given arrangement.
     ///
     /// Returns `None` if the configuration is not a valid permutation.
-    pub fn bandwidth(&self, config: &[usize]) -> Option<usize> {
+    pub fn bandwidth(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         if !self.is_valid_permutation(config) {
-            return None;
+            return Ok(None);
         }
         let mut max_stretch = 0usize;
         for (u, v) in self.graph.edges() {
             let stretch = config[u].abs_diff(config[v]);
             max_stretch = max_stretch.max(stretch);
         }
-        Some(max_stretch)
+        Ok(Some(i64::try_from(max_stretch).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting graph bandwidth to i64".to_string(),
+            )
+        })?))
     }
 }
 
@@ -125,22 +133,46 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumGraphBandwidth";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.graph.num_vertices();
-        vec![n; n]
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex ordering length does not match the graph".into(),
+            ));
+        }
+        if config.iter().any(|&position| position >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex ordering contains an out-of-range position".into(),
+            ));
+        }
+        Ok({
+            match self.bandwidth(config)? {
+                Some(bw) => Min(Some(bw)),
+                None => Min(None),
+            }
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        match self.bandwidth(config) {
-            Some(bw) => Min(Some(bw)),
-            None => Min(None),
-        }
+impl<G> crate::solvers::BruteForceProblem for MinimumGraphBandwidth<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.graph.num_vertices();
+        vec![n; n]
     }
 }
 
@@ -148,6 +180,10 @@ crate::declare_variants! {
     default MinimumGraphBandwidth<SimpleGraph> => "factorial(num_vertices)",
 }
 
+crate::register_brute_force! {
+    MinimumGraphBandwidth<SimpleGraph>,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     use crate::topology::SimpleGraph;
@@ -162,7 +198,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             4,
             vec![(0, 1), (0, 2), (0, 3)],
         ))),
-        optimal_config: vec![1, 0, 2, 3],
+        optimal_config: serde_json::json!(vec![1, 0, 2, 3]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/graph/minimum_intersection_graph_basis.rs b/src/models/graph/minimum_intersection_graph_basis.rs
index d78795962..2f26294c4 100644
--- a/src/models/graph/minimum_intersection_graph_basis.rs
+++ b/src/models/graph/minimum_intersection_graph_basis.rs
@@ -19,6 +19,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum universe size for intersection graph representation",
         fields: &[
@@ -30,15 +31,15 @@ inventory::submit! {
 /// The Minimum Intersection Graph Basis problem.
 ///
 /// Given a graph G = (V, E), find a universe U of minimum cardinality and
-/// an assignment of subsets S[v] ⊆ U for each vertex v ∈ V such that:
-/// - For every edge (u, v) ∈ E: S[u] ∩ S[v] ≠ ∅
-/// - For every non-edge pair (u, v) ∉ E: S[u] ∩ S[v] = ∅
+/// an assignment of subsets `S[v]` ⊆ U for each vertex v ∈ V such that:
+/// - For every edge (u, v) ∈ E: `S[u] ∩ S[v] ≠ ∅`
+/// - For every non-edge pair (u, v) ∉ E: `S[u] ∩ S[v] = ∅`
 /// - |U| is minimized
 ///
 /// The minimum |U| is the *intersection number* of G.
 ///
 /// Variables: n × |E| binary variables where n = |V| and |E| is the upper bound
-/// on universe size. config[v * |E| + s] = 1 means element s ∈ S[v].
+/// on universe size. `config[v * |E| + s] = 1` means element s ∈ `S[v]`.
 ///
 /// # Type Parameters
 ///
@@ -49,15 +50,15 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumIntersectionGraphBasis;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Path P3: 3 vertices, edges (0,1), (1,2)
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
 /// let problem = MinimumIntersectionGraphBasis::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem).unwrap();
-/// let value = problem.evaluate(&solution);
+/// let solution = solver.solve(&problem).unwrap().unwrap();
+/// let value = problem.evaluate(&solution).unwrap();
 /// assert_eq!(value, problemreductions::types::Min(Some(2)));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -93,86 +94,116 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumIntersectionGraphBasis";
-    type Value = Min<usize>;
+    type Solution = Vec<Vec<bool>>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.graph.num_vertices();
         let m = self.graph.num_edges();
-        if m == 0 {
-            // No edges: no variables needed; empty assignment is trivially valid.
-            return vec![];
+        if solution.len() != n || solution.iter().any(|subset| subset.len() != m) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "intersection-basis dimensions do not match the graph".into(),
+            ));
         }
-        vec![2; n * m]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        let n = self.graph.num_vertices();
-        let m = self.graph.num_edges();
-
-        if m == 0 {
-            // No edges: universe size 0 suffices (all subsets empty, no
-            // adjacency constraints). But we must also check that no two
-            // vertices are adjacent — which is guaranteed when m == 0.
-            if config.is_empty() {
-                return Min(Some(0));
-            } else {
-                return Min(None);
+        Ok({
+            if m == 0 {
+                return Ok(Min(Some(0)));
             }
-        }
-
-        if config.len() != n * m {
-            return Min(None);
-        }
-
-        // Parse subsets: S[v] = set of elements s where config[v * m + s] == 1
-        let subsets: Vec<HashSet<usize>> = (0..n)
-            .map(|v| (0..m).filter(|&s| config[v * m + s] == 1).collect())
-            .collect();
 
-        // Check edge constraints: for every edge (u, v), S[u] ∩ S[v] ≠ ∅
-        let edges = self.graph.edges();
-        for &(u, v) in &edges {
-            if subsets[u].is_disjoint(&subsets[v]) {
-                return Min(None);
+            // Parse subsets: S[v] contains element s when solution[v][s] is true.
+            let subsets: Vec<HashSet<usize>> = solution
+                .iter()
+                .map(|row| {
+                    row.iter()
+                        .enumerate()
+                        .filter_map(|(element, &selected)| selected.then_some(element))
+                        .collect()
+                })
+                .collect();
+
+            // Check edge constraints: for every edge (u, v), S[u] ∩ S[v] ≠ ∅
+            let edges = self.graph.edges();
+            for &(u, v) in &edges {
+                if subsets[u].is_disjoint(&subsets[v]) {
+                    return Ok(Min(None));
+                }
             }
-        }
 
-        // Check non-edge constraints: for every non-edge pair (u, v), S[u] ∩ S[v] = ∅
-        for u in 0..n {
-            for v in (u + 1)..n {
-                if !self.graph.has_edge(u, v) && !subsets[u].is_disjoint(&subsets[v]) {
-                    return Min(None);
+            // Check non-edge constraints: for every non-edge pair (u, v), S[u] ∩ S[v] = ∅
+            for u in 0..n {
+                for v in (u + 1)..n {
+                    if !self.graph.has_edge(u, v) && !subsets[u].is_disjoint(&subsets[v]) {
+                        return Ok(Min(None));
+                    }
                 }
             }
-        }
 
-        // Count elements used (union of all subsets)
-        let used: HashSet<usize> = subsets.iter().flat_map(|s| s.iter().copied()).collect();
-        Min(Some(used.len()))
+            // Count elements used (union of all subsets)
+            let used: HashSet<usize> = subsets.iter().flat_map(|s| s.iter().copied()).collect();
+            Min(Some(i64::try_from(used.len()).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting intersection-basis size to i64".into(),
+                )
+            })?))
+        })
     }
 }
 
+impl<G> crate::solvers::BruteForceProblem for MinimumIntersectionGraphBasis<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.graph.num_vertices();
+        let m = self.graph.num_edges();
+        if m == 0 {
+            // No edges: no variables needed; empty assignment is trivially valid.
+            return vec![];
+        }
+        vec![2; n * m]
+    }
+}
+
+crate::impl_random_generate!(
+    MinimumIntersectionGraphBasis<SimpleGraph>,
+    crate::random::SimpleGraphRandomSpec,
+    |spec| { Ok(MinimumIntersectionGraphBasis::new(spec.graph()?)) }
+);
+
 crate::declare_variants! {
-    default MinimumIntersectionGraphBasis<SimpleGraph> => "num_edges^num_edges",
+    default MinimumIntersectionGraphBasis<SimpleGraph> => "num_edges^num_edges" random,
+}
+
+crate::register_brute_force! {
+    MinimumIntersectionGraphBasis<SimpleGraph> decode |problem: &MinimumIntersectionGraphBasis<SimpleGraph>, indices: Vec<usize>| if problem.num_edges() == 0 { vec![Vec::new(); problem.num_vertices()] } else { indices.chunks(problem.num_edges()).map(crate::config::config_to_bits).collect() },
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // P3: 3 vertices, edges (0,1), (1,2), num_edges=2
     // Intersection number = 2: S[0]={0}, S[1]={0,1}, S[2]={1}
-    // Config: vertex 0: [1,0], vertex 1: [1,1], vertex 2: [0,1]
-    // Full config: [1,0, 1,1, 0,1]
+    // Incidence rows: vertex 0: [true,false], vertex 1: [true,true],
+    // vertex 2: [false,true].
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "minimum_intersection_graph_basis_simplegraph",
         instance: Box::new(MinimumIntersectionGraphBasis::new(SimpleGraph::new(
             3,
             vec![(0, 1), (1, 2)],
         ))),
-        optimal_config: vec![1, 0, 1, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![
+            vec![true, false],
+            vec![true, true],
+            vec![false, true]
+        ]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/graph/minimum_maximal_matching.rs b/src/models/graph/minimum_maximal_matching.rs
index a31b886c1..d559fb9c1 100644
--- a/src/models/graph/minimum_maximal_matching.rs
+++ b/src/models/graph/minimum_maximal_matching.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph", "BipartiteGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a minimum-size matching that cannot be extended",
         fields: &[
@@ -40,17 +41,17 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumMaximalMatching;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Path graph P4: 0-1-2-3
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
 /// let problem = MinimumMaximalMatching::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem).unwrap();
+/// let solution = solver.solve(&problem).unwrap().unwrap();
 ///
 /// // Minimum maximal matching has 1 edge (e.g., edge (1,2))
-/// let count: usize = solution.iter().sum();
+/// let count = solution.iter().filter(|&&selected| selected).count();
 /// assert_eq!(count, 1);
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -86,14 +87,14 @@ impl<G: Graph> MinimumMaximalMatching<G> {
     /// 1. The selected edges form a matching (no two share an endpoint).
     /// 2. The matching is maximal (every non-selected edge shares an endpoint
     ///    with some selected edge).
-    pub fn is_valid_maximal_matching(&self, config: &[usize]) -> bool {
+    pub fn is_valid_maximal_matching(&self, config: &[bool]) -> bool {
         let edges = self.graph.edges();
         let n = self.graph.num_vertices();
 
         // Step 1: Check matching property.
         let mut vertex_used = vec![false; n];
         for (idx, &sel) in config.iter().enumerate() {
-            if sel == 1 {
+            if sel {
                 let (u, v) = edges[idx];
                 if vertex_used[u] || vertex_used[v] {
                     return false;
@@ -105,7 +106,7 @@ impl<G: Graph> MinimumMaximalMatching<G> {
 
         // Step 2: Check maximality — every unselected edge must be blocked.
         for (idx, &sel) in config.iter().enumerate() {
-            if sel == 0 {
+            if !sel {
                 let (u, v) = edges[idx];
                 // Edge (u,v) is blocked iff u or v is already matched.
                 if !vertex_used[u] && !vertex_used[v] {
@@ -123,33 +124,63 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumMaximalMatching";
-    type Value = Min<usize>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.graph.num_edges() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "edge-selection length does not match the graph".into(),
+                ));
+            }
+            if !self.is_valid_maximal_matching(config) {
+                return Ok(Min(None));
+            }
+            let count = config.iter().filter(|&&selected| selected).count();
+            Min(Some(i64::try_from(count).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting matching cardinality to i64".into(),
+                )
+            })?))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if config.len() != self.graph.num_edges() {
-            return Min(None);
-        }
-        if !self.is_valid_maximal_matching(config) {
-            return Min(None);
-        }
-        let count = config.iter().filter(|&&x| x == 1).count();
-        Min(Some(count))
+impl<G> crate::solvers::BruteForceProblem for MinimumMaximalMatching<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
 }
 
+crate::impl_random_generate!(
+    MinimumMaximalMatching<SimpleGraph>,
+    crate::random::SimpleGraphRandomSpec,
+    |spec| { Ok(MinimumMaximalMatching::new(spec.graph()?)) }
+);
+
 crate::declare_variants! {
-    default MinimumMaximalMatching<SimpleGraph> => "1.3160^num_vertices",
+    default MinimumMaximalMatching<SimpleGraph> => "1.3160^num_vertices" random,
     MinimumMaximalMatching<BipartiteGraph> => "1.3160^num_vertices",
 }
 
+crate::register_brute_force! {
+    MinimumMaximalMatching<SimpleGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MinimumMaximalMatching<BipartiteGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // Path graph P6: 6 vertices, edges [(0,1),(1,2),(2,3),(3,4),(4,5)]
@@ -160,7 +191,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             6,
             vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
         ))),
-        optimal_config: vec![0, 1, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![false, true, false, true, false]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/graph/minimum_metric_dimension.rs b/src/models/graph/minimum_metric_dimension.rs
index 21299860d..42261c5c3 100644
--- a/src/models/graph/minimum_metric_dimension.rs
+++ b/src/models/graph/minimum_metric_dimension.rs
@@ -19,6 +19,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum resolving set of a graph",
         fields: &[
@@ -63,15 +64,15 @@ pub fn bfs_distances<G: Graph>(graph: &G, source: usize) -> Vec<usize> {
 /// ```
 /// use problemreductions::models::graph::MinimumMetricDimension;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // House graph: vertices 0–4
 /// let graph = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]);
 /// let problem = MinimumMetricDimension::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem).unwrap();
-/// let value = problem.evaluate(&solution);
+/// let solution = solver.solve(&problem).unwrap().unwrap();
+/// let value = problem.evaluate(&solution).unwrap();
 /// assert!(value.is_valid());
 /// ```
 #[derive(Debug, Clone, Serialize)]
@@ -124,9 +125,9 @@ impl<G: Graph> MinimumMetricDimension<G> {
     ///
     /// A set S ⊆ V is resolving if for every pair of distinct vertices u, v ∈ V,
     /// there exists some w ∈ S such that d(u, w) ≠ d(v, w).
-    pub fn is_resolving(&self, config: &[usize]) -> bool {
+    pub fn is_resolving(&self, config: &[bool]) -> bool {
         let n = self.graph.num_vertices();
-        let selected: Vec<usize> = (0..n).filter(|&i| config[i] == 1).collect();
+        let selected: Vec<usize> = (0..n).filter(|&i| config[i]).collect();
         if selected.is_empty() {
             return false;
         }
@@ -153,22 +154,44 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumMetricDimension";
-    type Value = Min<usize>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex-selection length does not match the graph".into(),
+            ));
+        }
+        Ok({
+            if !self.is_resolving(config) {
+                return Ok(Min(None));
+            }
+            let count = config.iter().filter(|&&x| x).count();
+            Min(Some(i64::try_from(count).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting metric-basis size to i64".into(),
+                )
+            })?))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if !self.is_resolving(config) {
-            return Min(None);
-        }
-        let count = config.iter().filter(|&&x| x == 1).count();
-        Min(Some(count))
+impl<G> crate::solvers::BruteForceProblem for MinimumMetricDimension<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
@@ -176,6 +199,10 @@ crate::declare_variants! {
     default MinimumMetricDimension<SimpleGraph> => "2^num_vertices",
 }
 
+crate::register_brute_force! {
+    MinimumMetricDimension<SimpleGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -184,7 +211,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             5,
             vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)],
         ))),
-        optimal_config: vec![1, 1, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![true, true, false, false, false]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/graph/minimum_multiway_cut.rs b/src/models/graph/minimum_multiway_cut.rs
index 010a27bb7..6b1b66cec 100644
--- a/src/models/graph/minimum_multiway_cut.rs
+++ b/src/models/graph/minimum_multiway_cut.rs
@@ -3,7 +3,7 @@
 //! The Minimum Multiway Cut problem asks for a minimum weight set of edges
 //! whose removal disconnects all terminal pairs.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
@@ -18,15 +18,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum weight set of edges whose removal disconnects all terminal pairs",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The undirected graph G=(V,E)" },
-            FieldInfo { name: "terminals", type_name: "Vec<usize>", description: "Terminal vertices that must be separated" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge weights w: E -> R (same order as graph.edges())" },
-        ],
+        fields: MinimumMultiwayCutCreateSpec::FIELDS,
     }
 }
 
@@ -52,6 +49,51 @@ pub struct MinimumMultiwayCut<G, W> {
     edge_weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumMultiwayCutCreateSpec {
+    /// The undirected graph G=(V,E).
+    graph: SimpleGraph,
+    /// Terminal vertices that must be separated.
+    terminals: Vec<usize>,
+    /// Edge weights w: E -> R in graph edge order.
+    edge_weights: Vec<i64>,
+}
+
+impl TryFrom<MinimumMultiwayCutCreateSpec> for MinimumMultiwayCut<SimpleGraph, i64> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumMultiwayCutCreateSpec) -> Result<Self, Self::Error> {
+        if spec.edge_weights.len() != spec.graph.num_edges() {
+            return Err(format!(
+                "edge_weights has {} entries, expected {}",
+                spec.edge_weights.len(),
+                spec.graph.num_edges()
+            )
+            .into());
+        }
+        if spec.terminals.len() < 2 {
+            return Err("at least two terminals are required".to_string().into());
+        }
+        let mut distinct = spec.terminals.clone();
+        distinct.sort_unstable();
+        distinct.dedup();
+        if distinct.len() != spec.terminals.len() {
+            return Err("terminals must be distinct".to_string().into());
+        }
+        if let Some(&terminal) = spec
+            .terminals
+            .iter()
+            .find(|&&t| t >= spec.graph.num_vertices())
+        {
+            return Err(format!(
+                "terminal {terminal} is outside graph with {} vertices",
+                spec.graph.num_vertices()
+            )
+            .into());
+        }
+        Ok(Self::new(spec.graph, spec.terminals, spec.edge_weights))
+    }
+}
+
 impl<G: Graph, W: Clone + Default> MinimumMultiwayCut<G, W> {
     /// Create a MinimumMultiwayCut problem.
     ///
@@ -119,15 +161,15 @@ impl<G: Graph, W: WeightElement> MinimumMultiwayCut<G, W> {
 }
 
 /// Check if all terminals are in distinct connected components
-/// when edges marked as cut (config[e] == 1) are removed.
-fn terminals_separated<G: Graph>(graph: &G, terminals: &[usize], config: &[usize]) -> bool {
+/// when edges marked as cut (config[e]) are removed.
+fn terminals_separated<G: Graph>(graph: &G, terminals: &[usize], config: &[bool]) -> bool {
     let n = graph.num_vertices();
     let edges = graph.edges();
 
     // Build adjacency list from non-cut edges
     let mut adj: Vec<Vec<usize>> = vec![vec![]; n];
     for (idx, (u, v)) in edges.iter().enumerate() {
-        if config.get(idx).copied().unwrap_or(0) == 0 {
+        if !config.get(idx).copied().unwrap_or(false) {
             adj[*u].push(*v);
             adj[*v].push(*u);
         }
@@ -161,46 +203,77 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumMultiwayCut";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_terminals", num_terminals),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        if !terminals_separated(&self.graph, &self.terminals, config) {
-            return Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (idx, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                if let Some(w) = self.edge_weights.get(idx) {
-                    total += w.to_sum();
+        Ok({
+            if !terminals_separated(&self.graph, &self.terminals, config) {
+                return Ok(Min(None));
+            }
+            let mut total = W::Sum::zero();
+            for (idx, &selected) in config.iter().enumerate() {
+                if selected {
+                    if let Some(w) = self.edge_weights.get(idx) {
+                        total = W::checked_add_to_sum(
+                            total,
+                            w.to_sum(),
+                            "summing multiway cut edge weights",
+                        )?;
+                    }
                 }
             }
-        }
-        Min(Some(total))
+            Min(Some(total))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for MinimumMultiwayCut<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
 }
 
 crate::declare_variants! {
-    default MinimumMultiwayCut<SimpleGraph, i32> => "1.84^num_terminals * num_vertices^3",
+    default MinimumMultiwayCut<SimpleGraph, i64> => "1.84^num_terminals * num_vertices^3" create MinimumMultiwayCutCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumMultiwayCut<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "minimum_multiway_cut_simplegraph_i32",
+        id: "minimum_multiway_cut_simplegraph",
         instance: Box::new(MinimumMultiwayCut::new(
             SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (1, 3)]),
             vec![0, 2, 4],
             vec![2, 3, 1, 2, 4, 5],
         )),
-        optimal_config: vec![1, 0, 0, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![true, false, false, true, true, false]),
         optimal_value: serde_json::json!(8),
     }]
 }
diff --git a/src/models/graph/minimum_sum_multicenter.rs b/src/models/graph/minimum_sum_multicenter.rs
index e631f0d7c..2ba567460 100644
--- a/src/models/graph/minimum_sum_multicenter.rs
+++ b/src/models/graph/minimum_sum_multicenter.rs
@@ -3,7 +3,7 @@
 //! The p-median problem asks for K facility locations (centers) on a graph
 //! that minimize the total weighted distance from all vertices to their nearest center.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
@@ -17,16 +17,12 @@ inventory::submit! {
         aliases: &["pmedian"],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find K centers minimizing total weighted distance (p-median problem)",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "vertex_weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-            FieldInfo { name: "edge_lengths", type_name: "Vec<W>", description: "Edge lengths l: E -> R" },
-            FieldInfo { name: "k", type_name: "usize", description: "Number of centers to place" },
-        ],
+        fields: MinimumSumMulticenterCreateSpec::FIELDS,
     }
 }
 
@@ -40,23 +36,23 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`)
-/// * `W` - The weight/length type (e.g., `i32`, `One`)
+/// * `W` - The weight/length type (e.g., `i64`, `One`)
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::graph::MinimumSumMulticenter;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Path graph: 0-1-2, unit weights and lengths, K=1
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-/// let problem = MinimumSumMulticenter::new(graph, vec![1i32; 3], vec![1i32; 2], 1);
+/// let problem = MinimumSumMulticenter::new(graph, vec![1i64; 3], vec![1i64; 2], 1);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem).unwrap();
+/// let solution = solver.solve(&problem).unwrap().unwrap();
 /// // Center at vertex 1 gives total distance 0+1+1 = 2 (optimal)
-/// assert_eq!(solution, vec![0, 1, 0]);
+/// assert_eq!(solution, vec![false, true, false]);
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumSumMulticenter<G, W> {
@@ -70,6 +66,92 @@ pub struct MinimumSumMulticenter<G, W> {
     k: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumSumMulticenterCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    weights: Option<Vec<i64>>,
+    #[create(codec = "comma-separated")]
+    edge_weights: Option<Vec<i64>>,
+    k: usize,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumSumMulticenterRandomSpec {
+    /// Number of graph vertices.
+    num_vertices: usize,
+    /// Independent edge probability (default: 0.5).
+    edge_prob: Option<f64>,
+    /// Seed for reproducible generation.
+    seed: Option<i64>,
+    /// Number of centers (default: max(1, num_vertices / 3)).
+    k: Option<usize>,
+}
+
+impl TryFrom<MinimumSumMulticenterCreateSpec> for MinimumSumMulticenter<SimpleGraph, i64> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: MinimumSumMulticenterCreateSpec) -> Result<Self, Self::Error> {
+        let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+        let vertex_weights = spec
+            .weights
+            .unwrap_or_else(|| vec![1; graph.num_vertices()]);
+        if vertex_weights.len() != graph.num_vertices() {
+            return Err(format!(
+                "weights has length {}, expected {}",
+                vertex_weights.len(),
+                graph.num_vertices()
+            )
+            .into());
+        }
+        let edge_lengths = spec
+            .edge_weights
+            .unwrap_or_else(|| vec![1; graph.num_edges()]);
+        if edge_lengths.len() != graph.num_edges() {
+            return Err(format!(
+                "edge_weights has length {}, expected {}",
+                edge_lengths.len(),
+                graph.num_edges()
+            )
+            .into());
+        }
+        if spec.k == 0 || spec.k > graph.num_vertices() {
+            return Err(format!("k must be between 1 and {}", graph.num_vertices()).into());
+        }
+        Ok(Self::new(graph, vertex_weights, edge_lengths, spec.k))
+    }
+}
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(format!("num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}").into());
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
+}
+
 impl<G: Graph, W: Clone + Default> MinimumSumMulticenter<G, W> {
     /// Create a MinimumSumMulticenter problem.
     ///
@@ -142,7 +224,7 @@ impl<G: Graph, W: WeightElement> MinimumSumMulticenter<G, W> {
     /// Correct because all edge lengths are non-negative.
     ///
     /// Returns `None` if any vertex is unreachable from all centers.
-    fn shortest_distances(&self, config: &[usize]) -> Option<Vec<W::Sum>> {
+    fn shortest_distances(&self, config: &[bool]) -> Option<Vec<W::Sum>> {
         let n = self.graph.num_vertices();
         let edges = self.graph.edges();
 
@@ -159,7 +241,7 @@ impl<G: Graph, W: WeightElement> MinimumSumMulticenter<G, W> {
 
         // Initialize centers
         for (v, &selected) in config.iter().enumerate() {
-            if selected == 1 {
+            if selected {
                 dist[v] = Some(W::Sum::zero());
             }
         }
@@ -214,47 +296,93 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumSumMulticenter";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        // Check exactly K centers are selected
-        let num_selected: usize = config.iter().sum();
-        if num_selected != self.k {
-            return Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "center-selection length does not match the graph vertices".into(),
+            ));
         }
+        Ok({
+            // Check exactly K centers are selected
+            let num_selected = config.iter().filter(|&&selected| selected).count();
+            if num_selected != self.k {
+                return Ok(Min(None));
+            }
 
-        // Compute shortest distances to nearest center
-        let distances = match self.shortest_distances(config) {
-            Some(d) => d,
-            None => return Min(None),
-        };
+            // Compute shortest distances to nearest center
+            let distances = match self.shortest_distances(config) {
+                Some(d) => d,
+                None => return Ok(Min(None)),
+            };
 
-        // Compute total weighted distance: Σ w(v) * d(v)
-        let mut total = W::Sum::zero();
-        for (v, dist) in distances.iter().enumerate() {
-            total += self.vertex_weights[v].to_sum() * dist.clone();
-        }
+            // Compute total weighted distance: Σ w(v) * d(v)
+            let mut total = W::Sum::zero();
+            for (v, dist) in distances.iter().enumerate() {
+                let weighted_distance = W::checked_mul_sum(
+                    self.vertex_weights[v].to_sum(),
+                    dist.clone(),
+                    "multiplying multicenter vertex weight by distance",
+                )?;
+                total = W::checked_add_to_sum(
+                    total,
+                    weighted_distance,
+                    "summing weighted multicenter distances",
+                )?;
+            }
 
-        Min(Some(total))
+            Min(Some(total))
+        })
     }
 }
 
+impl<G, W> crate::solvers::BruteForceProblem for MinimumSumMulticenter<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
+    }
+}
+
+crate::impl_random_generate!(MinimumSumMulticenter<SimpleGraph, i64>, MinimumSumMulticenterRandomSpec, |spec| {
+    let graph = crate::random::SimpleGraphRandomSpec {
+        num_vertices: spec.num_vertices,
+        edge_prob: spec.edge_prob,
+        seed: spec.seed,
+    }.graph()?;
+    let k = spec.k.unwrap_or(std::cmp::max(1, spec.num_vertices / 3));
+    if k == 0 || k > spec.num_vertices {
+        return Err(format!("k must be between 1 and {}", spec.num_vertices).into());
+    }
+    let lengths = vec![1; graph.num_edges()];
+    Ok(MinimumSumMulticenter::new(graph, vec![1; spec.num_vertices], lengths, k))
+});
+
 crate::declare_variants! {
-    default MinimumSumMulticenter<SimpleGraph, i32> => "2^num_vertices",
+    default MinimumSumMulticenter<SimpleGraph, i64> => "2^num_vertices" create MinimumSumMulticenterCreateSpec random,
+}
+
+crate::register_brute_force! {
+    MinimumSumMulticenter<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "minimum_sum_multicenter_simplegraph_i32",
+        id: "minimum_sum_multicenter_simplegraph",
         instance: Box::new(MinimumSumMulticenter::new(
             SimpleGraph::new(
                 7,
@@ -269,11 +397,11 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                     (2, 5),
                 ],
             ),
-            vec![1i32; 7],
-            vec![1i32; 8],
+            vec![1i64; 7],
+            vec![1i64; 8],
             2,
         )),
-        optimal_config: vec![0, 0, 1, 0, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![false, false, true, false, false, true, false]),
         optimal_value: serde_json::json!(6),
     }]
 }
diff --git a/src/models/graph/minimum_vertex_cover.rs b/src/models/graph/minimum_vertex_cover.rs
index f33b93134..5f511118b 100644
--- a/src/models/graph/minimum_vertex_cover.rs
+++ b/src/models/graph/minimum_vertex_cover.rs
@@ -4,7 +4,7 @@
 //! such that every edge has at least one endpoint in the subset.
 
 use crate::models::decision::Decision;
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, FieldInfo, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, One, WeightElement};
@@ -18,14 +18,12 @@ inventory::submit! {
         aliases: &["MVC"],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32", "One"]),
+            VariantDimension::new("weight", "i64", &["i64", "One"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum weight vertex cover in a graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-        ],
+        fields: MinimumVertexCoverCreateSpec::<i64>::FIELDS,
     }
 }
 
@@ -41,7 +39,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MinimumVertexCover;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Create a path graph 0-1-2
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
@@ -49,10 +47,10 @@ inventory::submit! {
 ///
 /// // Solve with brute force
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Minimum vertex cover is just vertex 1
-/// assert!(solutions.contains(&vec![0, 1, 0]));
+/// assert!(solutions.contains(&vec![false, true, false]));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumVertexCover<G, W> {
@@ -62,6 +60,34 @@ pub struct MinimumVertexCover<G, W> {
     weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumVertexCoverCreateSpec<W> {
+    /// The underlying graph G=(V,E).
+    graph: SimpleGraph,
+    /// Vertex weights w: V -> R.
+    weights: Option<Vec<W>>,
+}
+
+impl<W: WeightElement> TryFrom<MinimumVertexCoverCreateSpec<W>>
+    for MinimumVertexCover<SimpleGraph, W>
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumVertexCoverCreateSpec<W>) -> Result<Self, Self::Error> {
+        let weights = spec
+            .weights
+            .unwrap_or_else(|| vec![W::unit(); spec.graph.num_vertices()]);
+        if weights.len() != spec.graph.num_vertices() {
+            return Err(format!(
+                "weights has {} entries, expected {}",
+                weights.len(),
+                spec.graph.num_vertices()
+            )
+            .into());
+        }
+        Ok(Self::new(spec.graph, weights))
+    }
+}
+
 impl<G: Graph, W: Clone + Default> MinimumVertexCover<G, W> {
     /// Create a Vertex Covering problem from a graph with given weights.
     pub fn new(graph: G, weights: Vec<W>) -> Self {
@@ -92,7 +118,7 @@ impl<G: Graph, W: Clone + Default> MinimumVertexCover<G, W> {
     }
 
     /// Check if a configuration is a valid vertex cover.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_vertex_cover_config(&self.graph, config)
     }
 }
@@ -115,35 +141,58 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumVertexCover";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.graph.num_vertices() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "vertex-selection length does not match the graph".into(),
+                ));
+            }
+            if !is_vertex_cover_config(&self.graph, config) {
+                return Ok(Min(None));
+            }
+            let mut total = W::Sum::zero();
+            for (i, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.weights[i].to_sum(),
+                        "summing selected vertex-cover weights",
+                    )?;
+                }
+            }
+            Min(Some(total))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        if !is_vertex_cover_config(&self.graph, config) {
-            return Min(None);
-        }
-        let mut total = W::Sum::zero();
-        for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.weights[i].to_sum();
-            }
-        }
-        Min(Some(total))
+impl<G, W> crate::solvers::BruteForceProblem for MinimumVertexCover<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
 /// Check if a configuration forms a valid vertex cover.
-pub(crate) fn is_vertex_cover_config<G: Graph>(graph: &G, config: &[usize]) -> bool {
+pub(crate) fn is_vertex_cover_config<G: Graph>(graph: &G, config: &[bool]) -> bool {
     for (u, v) in graph.edges() {
-        let u_covered = config.get(u).copied().unwrap_or(0) == 1;
-        let v_covered = config.get(v).copied().unwrap_or(0) == 1;
+        let u_covered = config.get(u).copied().unwrap_or(false);
+        let v_covered = config.get(v).copied().unwrap_or(false);
         if !u_covered && !v_covered {
             return false;
         }
@@ -151,9 +200,35 @@ pub(crate) fn is_vertex_cover_config<G: Graph>(graph: &G, config: &[usize]) -> b
     true
 }
 
+crate::impl_random_generate!(MinimumVertexCover<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    Ok(MinimumVertexCover::new(spec.graph()?, vec![1; spec.num_vertices]))
+});
+crate::impl_random_generate!(MinimumVertexCover<SimpleGraph, One>, crate::random::SimpleGraphRandomSpec, |spec| {
+    Ok(MinimumVertexCover::new(spec.graph()?, vec![One; spec.num_vertices]))
+});
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumVertexCoverOneCreateSpec {
+    /// The underlying graph.
+    graph: SimpleGraph,
+}
+
+impl TryFrom<MinimumVertexCoverOneCreateSpec> for MinimumVertexCover<SimpleGraph, One> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumVertexCoverOneCreateSpec) -> Result<Self, Self::Error> {
+        let weights = vec![One; spec.graph.num_vertices()];
+        Ok(Self::new(spec.graph, weights))
+    }
+}
+
 crate::declare_variants! {
-    default MinimumVertexCover<SimpleGraph, i32> => "1.1996^num_vertices",
-    MinimumVertexCover<SimpleGraph, One> => "1.1996^num_vertices",
+    default MinimumVertexCover<SimpleGraph, i64> => "1.1996^num_vertices" create MinimumVertexCoverCreateSpec<i64> random,
+    MinimumVertexCover<SimpleGraph, One> => "1.1996^num_vertices" create MinimumVertexCoverOneCreateSpec random,
+}
+
+crate::register_brute_force! {
+    MinimumVertexCover<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MinimumVertexCover<SimpleGraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 impl<G, W> crate::models::decision::DecisionProblemMeta for MinimumVertexCover<G, W>
@@ -165,7 +240,7 @@ where
     const DECISION_NAME: &'static str = "DecisionMinimumVertexCover";
 }
 
-impl Decision<MinimumVertexCover<SimpleGraph, i32>> {
+impl Decision<MinimumVertexCover<SimpleGraph, i64>> {
     /// Number of vertices in the underlying graph.
     pub fn num_vertices(&self) -> usize {
         self.inner().num_vertices()
@@ -182,33 +257,67 @@ impl Decision<MinimumVertexCover<SimpleGraph, i32>> {
     }
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct DecisionMinimumVertexCoverRandomSpec {
+    /// Number of graph vertices.
+    num_vertices: usize,
+    /// Independent edge probability (default: 0.5).
+    edge_prob: Option<f64>,
+    /// Seed for reproducible generation.
+    seed: Option<i64>,
+    /// Maximum allowed cover cost.
+    bound: i64,
+}
+
+crate::impl_random_generate!(
+    Decision<MinimumVertexCover<SimpleGraph, i64>>,
+    DecisionMinimumVertexCoverRandomSpec,
+    |spec| {
+        if spec.bound < 0 {
+            return Err("bound must be nonnegative".to_string().into());
+        }
+        let graph = crate::random::SimpleGraphRandomSpec {
+            num_vertices: spec.num_vertices,
+            edge_prob: spec.edge_prob,
+            seed: spec.seed,
+        }
+        .graph()?;
+        Ok(Decision::new(
+            MinimumVertexCover::new(graph, vec![1; spec.num_vertices]),
+            spec.bound,
+        ))
+    }
+);
+
 crate::register_decision_variant!(
-    MinimumVertexCover<SimpleGraph, i32>,
+    MinimumVertexCover<SimpleGraph, i64>,
     "DecisionMinimumVertexCover",
     "1.1996^num_vertices",
     &["DMVC", "VC", "VertexCover"],
     "Decision version: does a vertex cover of cost <= bound exist?",
+    category: crate::registry::ProblemCategory::Graph,
     dims: [
         VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-        VariantDimension::new("weight", "i32", &["i32"]),
+        VariantDimension::new("weight", "i64", &["i64"]),
     ],
     fields: [
         FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
         FieldInfo { name: "weights", type_name: "Vec<W>", description: "Vertex weights w: V -> R" },
-        FieldInfo { name: "bound", type_name: "i32", description: "Decision bound (maximum allowed cover cost)" },
+        FieldInfo { name: "bound", type_name: "W::Sum", description: "Decision bound (maximum allowed cover cost)" },
     ],
-    size_getters: [("num_vertices", num_vertices), ("num_edges", num_edges)]
+    decode: |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    random
 );
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "minimum_vertex_cover_simplegraph_i32",
+        id: "minimum_vertex_cover_simplegraph",
         instance: Box::new(MinimumVertexCover::new(
             SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]),
-            vec![1i32; 5],
+            vec![1i64; 5],
         )),
-        optimal_config: vec![1, 0, 0, 1, 1],
+        optimal_config: serde_json::json!(vec![true, false, false, true, true]),
         optimal_value: serde_json::json!(3),
     }]
 }
@@ -217,15 +326,15 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
 pub(crate) fn decision_canonical_model_example_specs(
 ) -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "decision_minimum_vertex_cover_simplegraph_i32",
+        id: "decision_minimum_vertex_cover_simplegraph",
         instance: Box::new(crate::models::decision::Decision::new(
             MinimumVertexCover::new(
                 SimpleGraph::new(4, vec![(0, 1), (1, 2), (0, 2), (2, 3)]),
-                vec![1i32; 4],
+                vec![1i64; 4],
             ),
             2,
         )),
-        optimal_config: vec![1, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![true, false, true, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
@@ -243,19 +352,21 @@ pub(crate) fn decision_canonical_rule_example_specs(
             let source = crate::models::decision::Decision::new(
                 MinimumVertexCover::new(
                     SimpleGraph::new(4, vec![(0, 1), (1, 2), (0, 2), (2, 3)]),
-                    vec![1i32; 4],
+                    vec![1i64; 4],
                 ),
                 2,
             );
-            let result = source.reduce_to_aggregate();
+            let result = source
+                .reduce_to_aggregate()
+                .expect("reduction should succeed");
             let target = result.target_problem();
-            let config = vec![1, 0, 1, 0];
+            let config = vec![true, false, true, false];
             assemble_rule_example(
                 &source,
                 target,
                 vec![SolutionPair {
-                    source_config: config.clone(),
-                    target_config: config,
+                    source_config: serde_json::json!(config.clone()),
+                    target_config: serde_json::json!(config),
                 }],
             )
         },
diff --git a/src/models/graph/mixed_chinese_postman.rs b/src/models/graph/mixed_chinese_postman.rs
index 866e2ecb7..8bd02cb1e 100644
--- a/src/models/graph/mixed_chinese_postman.rs
+++ b/src/models/graph/mixed_chinese_postman.rs
@@ -4,7 +4,7 @@
 //! minimum-cost closed walk that traverses every directed arc in its prescribed
 //! direction and every undirected edge in at least one direction.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{DirectedGraph, MixedGraph};
 use crate::traits::Problem;
 use crate::types::{Min, One, WeightElement};
@@ -20,15 +20,12 @@ inventory::submit! {
         display_name: "Mixed Chinese Postman",
         aliases: &["MCPP"],
         dimensions: &[
-            VariantDimension::new("weight", "i32", &["i32", "One"]),
+            VariantDimension::new("weight", "i64", &["i64", "One"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a minimum-cost closed walk covering all arcs and edges in a mixed graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "MixedGraph", description: "The mixed graph G=(V,A,E)" },
-            FieldInfo { name: "arc_weights", type_name: "Vec<W>", description: "Lengths for the directed arcs in A" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Lengths for the undirected edges in E" },
-        ],
+        fields: MixedChinesePostmanI64CreateSpec::FIELDS,
     }
 }
 
@@ -39,13 +36,94 @@ inventory::submit! {
 /// Postman subproblem, using all available arcs (including both directions of
 /// every undirected edge) for degree-balancing detours.
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MixedChinesePostman<W: WeightElement<Sum = i32>> {
+pub struct MixedChinesePostman<W: WeightElement<Sum = i64>> {
     graph: MixedGraph,
     arc_weights: Vec<W>,
     edge_weights: Vec<W>,
 }
 
-impl<W: WeightElement<Sum = i32>> MixedChinesePostman<W> {
+macro_rules! mixed_chinese_postman_create_spec {
+    ($name:ident, $weight:ty, $one:expr $(, $arc_weights:ident, $edge_weights:ident)?) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            /// Undirected graph edges.
+            #[create(codec = "edge-list")]
+            graph: Vec<(usize, usize)>,
+            /// Directed graph arcs.
+            #[create(codec = "arc-list")]
+            arcs: Vec<(usize, usize)>,
+            /// Vertex count, needed to preserve isolated vertices.
+            num_vertices: Option<usize>,
+            $(
+            /// Directed-arc lengths; defaults to one per arc.
+            #[create(codec = "comma-separated")]
+            $arc_weights: Option<Vec<$weight>>,
+            )?
+            $(
+            /// Undirected-edge lengths; defaults to one per edge.
+            #[create(codec = "comma-separated")]
+            $edge_weights: Option<Vec<$weight>>,
+            )?
+        }
+
+        impl TryFrom<$name> for MixedChinesePostman<$weight> {
+            type Error = crate::registry::ConstructionError;
+
+            fn try_from(spec: $name) -> Result<Self, Self::Error> {
+                if spec.graph.is_empty() && spec.num_vertices.is_none() {
+                    return Err("num_vertices is required for an empty graph".to_string().into());
+                }
+                if spec.arcs.is_empty() {
+                    return Err("arcs must be non-empty".to_string().into());
+                }
+                for (index, &(u, v)) in spec.graph.iter().enumerate() {
+                    if u == v {
+                        return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+                    }
+                }
+                let inferred = spec
+                    .graph
+                    .iter()
+                    .flat_map(|&(u, v)| [u, v])
+                    .max()
+                    .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+                    .transpose()?
+                    .unwrap_or(0);
+                let num_vertices = spec.num_vertices.unwrap_or(inferred);
+                if num_vertices < inferred {
+                    return Err(format!(
+                        "num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}"
+                    ).into());
+                }
+                for (index, &(u, v)) in spec.arcs.iter().enumerate() {
+                    if u >= num_vertices || v >= num_vertices {
+                        return Err(format!(
+                            "arc {index} endpoint is out of range for {num_vertices} vertices"
+                        ).into());
+                    }
+                }
+                let arc_weights = { $(if let Some(value) = spec.$arc_weights { value } else)? { vec![$one; spec.arcs.len()] } };
+                let edge_weights = { $(if let Some(value) = spec.$edge_weights { value } else)? { vec![$one; spec.graph.len()] } };
+                MixedChinesePostman::try_new(
+                    MixedGraph::new(num_vertices, spec.arcs, spec.graph),
+                    arc_weights,
+                    edge_weights,
+                )
+            }
+        }
+    };
+}
+
+mixed_chinese_postman_create_spec!(
+    MixedChinesePostmanI64CreateSpec,
+    i64,
+    1_i64,
+    arc_weights,
+    edge_weights
+);
+mixed_chinese_postman_create_spec!(MixedChinesePostmanOneCreateSpec, One, One);
+
+impl<W: WeightElement<Sum = i64>> MixedChinesePostman<W> {
     /// Create a new mixed Chinese postman instance.
     ///
     /// # Panics
@@ -53,42 +131,46 @@ impl<W: WeightElement<Sum = i32>> MixedChinesePostman<W> {
     /// Panics if the weight-vector lengths do not match the graph shape or if
     /// any weight is negative.
     pub fn new(graph: MixedGraph, arc_weights: Vec<W>, edge_weights: Vec<W>) -> Self {
-        assert_eq!(
-            arc_weights.len(),
-            graph.num_arcs(),
-            "arc_weights length must match num_arcs"
-        );
-        assert_eq!(
-            edge_weights.len(),
-            graph.num_edges(),
-            "edge_weights length must match num_edges"
-        );
+        Self::try_new(graph, arc_weights, edge_weights)
+            .unwrap_or_else(|message| panic!("{message}"))
+    }
+
+    /// Create an instance, returning validation errors instead of panicking.
+    pub fn try_new(
+        graph: MixedGraph,
+        arc_weights: Vec<W>,
+        edge_weights: Vec<W>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        if arc_weights.len() != graph.num_arcs() {
+            return Err("arc_weights length must match num_arcs".to_string().into());
+        }
+        if edge_weights.len() != graph.num_edges() {
+            return Err("edge_weights length must match num_edges"
+                .to_string()
+                .into());
+        }
         for (index, weight) in arc_weights.iter().enumerate() {
-            assert!(
-                matches!(
-                    weight.to_sum().partial_cmp(&W::Sum::zero()),
-                    Some(Ordering::Equal | Ordering::Greater)
-                ),
-                "arc weight at index {} must be nonnegative",
-                index
-            );
+            if !matches!(
+                weight.to_sum().partial_cmp(&W::Sum::zero()),
+                Some(Ordering::Equal | Ordering::Greater)
+            ) {
+                return Err(format!("arc weight at index {index} must be nonnegative").into());
+            }
         }
         for (index, weight) in edge_weights.iter().enumerate() {
-            assert!(
-                matches!(
-                    weight.to_sum().partial_cmp(&W::Sum::zero()),
-                    Some(Ordering::Equal | Ordering::Greater)
-                ),
-                "edge weight at index {} must be nonnegative",
-                index
-            );
+            if !matches!(
+                weight.to_sum().partial_cmp(&W::Sum::zero()),
+                Some(Ordering::Equal | Ordering::Greater)
+            ) {
+                return Err(format!("edge weight at index {index} must be nonnegative").into());
+            }
         }
 
-        Self {
+        Ok(Self {
             graph,
             arc_weights,
             edge_weights,
-        }
+        })
     }
 
     /// Return the mixed graph.
@@ -126,17 +208,17 @@ impl<W: WeightElement<Sum = i32>> MixedChinesePostman<W> {
         !W::IS_UNIT
     }
 
-    fn oriented_arc_pairs(&self, config: &[usize]) -> Option<Vec<(usize, usize)>> {
+    fn oriented_arc_pairs(&self, config: &[bool]) -> Option<Vec<(usize, usize)>> {
         if config.len() != self.graph.num_edges() {
             return None;
         }
 
         let mut arcs = self.graph.arcs();
-        for ((u, v), &direction) in self.graph.edges().iter().zip(config.iter()) {
-            match direction {
-                0 => arcs.push((*u, *v)),
-                1 => arcs.push((*v, *u)),
-                _ => return None,
+        for ((u, v), &reverse) in self.graph.edges().iter().zip(config.iter()) {
+            if reverse {
+                arcs.push((*v, *u));
+            } else {
+                arcs.push((*u, *v));
             }
         }
         Some(arcs)
@@ -157,11 +239,11 @@ impl<W: WeightElement<Sum = i32>> MixedChinesePostman<W> {
             .arcs()
             .into_iter()
             .zip(self.arc_weights.iter())
-            .map(|((u, v), weight)| (u, v, i64::from(weight.to_sum())))
+            .map(|((u, v), weight)| (u, v, weight.to_sum()))
             .collect();
 
         for ((u, v), weight) in self.graph.edges().iter().zip(self.edge_weights.iter()) {
-            let cost = i64::from(weight.to_sum());
+            let cost = weight.to_sum();
             arcs.push((*u, *v, cost));
             arcs.push((*v, *u, cost));
         }
@@ -169,83 +251,123 @@ impl<W: WeightElement<Sum = i32>> MixedChinesePostman<W> {
         arcs
     }
 
-    fn base_cost(&self) -> i64 {
-        self.arc_weights
-            .iter()
-            .map(|weight| i64::from(weight.to_sum()))
-            .sum::<i64>()
-            + self
-                .edge_weights
-                .iter()
-                .map(|weight| i64::from(weight.to_sum()))
-                .sum::<i64>()
+    fn base_cost(&self) -> Result<i64, crate::traits::EvaluationError> {
+        let mut total = 0_i64;
+        for weight in self.arc_weights.iter().chain(self.edge_weights.iter()) {
+            total = W::checked_add_to_sum(
+                total,
+                weight.to_sum(),
+                "summing mixed Chinese postman base costs",
+            )?;
+        }
+        Ok(total)
     }
 }
 
 impl<W> MixedChinesePostman<W>
 where
-    W: WeightElement<Sum = i32> + crate::variant::VariantParam,
+    W: WeightElement<Sum = i64> + crate::variant::VariantParam,
 {
     /// Check whether a configuration yields a valid orientation (strongly
     /// connected with proper coverage).
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0.is_some()
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(self.evaluate_solution(config)?.0.is_some())
+    }
+
+    fn evaluate_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-orientation length does not match the undirected edges".into(),
+            ));
+        }
+        let Some(oriented_pairs) = self.oriented_arc_pairs(config) else {
+            return Ok(Min(None));
+        };
+
+        let available = self.available_arc_pairs();
+        let mut keep = vec![false; self.graph.num_vertices()];
+        for &(tail, head) in &available {
+            keep[tail] = true;
+            keep[head] = true;
+        }
+        if !DirectedGraph::new(self.graph.num_vertices(), available)
+            .induced_subgraph(&keep)
+            .is_strongly_connected()
+        {
+            return Ok(Min(None));
+        }
+
+        let distances =
+            all_pairs_shortest_paths(self.graph.num_vertices(), &self.weighted_available_arcs())?;
+        let balance = degree_imbalances(self.graph.num_vertices(), &oriented_pairs)?;
+        let Some(extra_cost) = minimum_balancing_cost(&balance, &distances)? else {
+            return Ok(Min(None));
+        };
+
+        let total = self.base_cost()?.checked_add(extra_cost).ok_or_else(|| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "summing mixed Chinese postman objective".to_string(),
+            )
+        })?;
+        Ok(Min(Some(total)))
     }
 }
 
 impl<W> Problem for MixedChinesePostman<W>
 where
-    W: WeightElement<Sum = i32> + crate::variant::VariantParam,
+    W: WeightElement<Sum = i64> + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MixedChinesePostman";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![
+        ("num_arcs", num_arcs),
+        ("num_edges", num_edges),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        self.evaluate_solution(config)
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        let Some(oriented_pairs) = self.oriented_arc_pairs(config) else {
-            return Min(None);
-        };
-
-        // Connectivity uses the full available graph: original arcs plus both
-        // directions of every undirected edge.
-        if !DirectedGraph::new(self.graph.num_vertices(), self.available_arc_pairs())
-            .is_strongly_connected()
-        {
-            return Min(None);
-        }
-
-        // Shortest paths also use the full available graph so that balancing
-        // can route through undirected edges in either direction.
-        let distances =
-            all_pairs_shortest_paths(self.graph.num_vertices(), &self.weighted_available_arcs());
-        // Degree imbalance is computed from the required arcs only (original
-        // arcs plus the chosen orientation of each undirected edge).
-        let balance = degree_imbalances(self.graph.num_vertices(), &oriented_pairs);
-        let Some(extra_cost) = minimum_balancing_cost(&balance, &distances) else {
-            return Min(None);
-        };
-
-        let total = self.base_cost() + extra_cost;
-        Min(Some(total as W::Sum))
+impl<W> crate::solvers::BruteForceProblem for MixedChinesePostman<W>
+where
+    W: WeightElement<Sum = i64> + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
 }
 
 crate::declare_variants! {
-    default MixedChinesePostman<i32> => "2^num_edges * num_vertices^3",
-    MixedChinesePostman<One> => "2^num_edges * num_vertices^3",
+    default MixedChinesePostman<i64> => "2^num_edges * num_vertices^3" create MixedChinesePostmanI64CreateSpec,
+    MixedChinesePostman<One> => "2^num_edges * num_vertices^3" create MixedChinesePostmanOneCreateSpec,
+}
+
+crate::register_brute_force! {
+    MixedChinesePostman<i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MixedChinesePostman<One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "mixed_chinese_postman_i32",
+        id: "mixed_chinese_postman",
         instance: Box::new(MixedChinesePostman::new(
             MixedGraph::new(
                 5,
@@ -255,12 +377,15 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![2, 3, 1, 4],
             vec![2, 3, 1, 2],
         )),
-        optimal_config: vec![1, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![true, true, false, false]),
         optimal_value: serde_json::json!(21),
     }]
 }
 
-fn all_pairs_shortest_paths(num_vertices: usize, arcs: &[(usize, usize, i64)]) -> Vec<Vec<i64>> {
+fn all_pairs_shortest_paths(
+    num_vertices: usize,
+    arcs: &[(usize, usize, i64)],
+) -> Result<Vec<Vec<i64>>, crate::traits::EvaluationError> {
     let mut distances = vec![vec![INF_COST; num_vertices]; num_vertices];
 
     for (vertex, row) in distances.iter_mut().enumerate() {
@@ -282,7 +407,13 @@ fn all_pairs_shortest_paths(num_vertices: usize, arcs: &[(usize, usize, i64)]) -
                 if distances[via][dst] == INF_COST {
                     continue;
                 }
-                let through = distances[src][via] + distances[via][dst];
+                let through = distances[src][via]
+                    .checked_add(distances[via][dst])
+                    .ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "computing mixed Chinese postman shortest paths".to_string(),
+                        )
+                    })?;
                 if through < distances[src][dst] {
                     distances[src][dst] = through;
                 }
@@ -290,39 +421,53 @@ fn all_pairs_shortest_paths(num_vertices: usize, arcs: &[(usize, usize, i64)]) -
         }
     }
 
-    distances
+    Ok(distances)
 }
 
-fn degree_imbalances(num_vertices: usize, arcs: &[(usize, usize)]) -> Vec<i32> {
-    let mut balance = vec![0_i32; num_vertices];
+fn degree_imbalances(
+    num_vertices: usize,
+    arcs: &[(usize, usize)],
+) -> Result<Vec<i64>, crate::traits::EvaluationError> {
+    let mut balance = vec![0_i64; num_vertices];
     for &(u, v) in arcs {
-        balance[u] += 1;
-        balance[v] -= 1;
+        balance[u] = balance[u].checked_add(1).ok_or_else(|| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "computing mixed Chinese postman degree imbalance".to_string(),
+            )
+        })?;
+        balance[v] = balance[v].checked_sub(1).ok_or_else(|| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "computing mixed Chinese postman degree imbalance".to_string(),
+            )
+        })?;
     }
-    balance
+    Ok(balance)
 }
 
-fn minimum_balancing_cost(balance: &[i32], distances: &[Vec<i64>]) -> Option<i64> {
+fn minimum_balancing_cost(
+    balance: &[i64],
+    distances: &[Vec<i64>],
+) -> Result<Option<i64>, crate::traits::EvaluationError> {
     let mut deficits = Vec::new();
     let mut surpluses = Vec::new();
 
     for (vertex, &value) in balance.iter().enumerate() {
         if value < 0 {
-            for _ in 0..usize::try_from(-value).ok()? {
+            for _ in 0..value.unsigned_abs() {
                 deficits.push(vertex);
             }
         } else if value > 0 {
-            for _ in 0..usize::try_from(value).ok()? {
+            for _ in 0..value.unsigned_abs() {
                 surpluses.push(vertex);
             }
         }
     }
 
     if deficits.len() != surpluses.len() {
-        return None;
+        return Ok(None);
     }
     if deficits.is_empty() {
-        return Some(0);
+        return Ok(Some(0));
     }
 
     let mut costs = vec![vec![INF_COST; surpluses.len()]; deficits.len()];
@@ -335,13 +480,13 @@ fn minimum_balancing_cost(balance: &[i32], distances: &[Vec<i64>]) -> Option<i64
     hungarian_min_cost(&costs)
 }
 
-fn hungarian_min_cost(costs: &[Vec<i64>]) -> Option<i64> {
+fn hungarian_min_cost(costs: &[Vec<i64>]) -> Result<Option<i64>, crate::traits::EvaluationError> {
     let size = costs.len();
     if size == 0 {
-        return Some(0);
+        return Ok(Some(0));
     }
     if costs.iter().any(|row| row.len() != size) {
-        return None;
+        return Ok(None);
     }
 
     let mut u = vec![0_i64; size + 1];
@@ -366,7 +511,14 @@ fn hungarian_min_cost(costs: &[Vec<i64>]) -> Option<i64> {
                     continue;
                 }
 
-                let current = costs[row0 - 1][column - 1] - u[row0] - v[column];
+                let current = costs[row0 - 1][column - 1]
+                    .checked_sub(u[row0])
+                    .and_then(|value| value.checked_sub(v[column]))
+                    .ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "computing mixed Chinese postman assignment costs".to_string(),
+                        )
+                    })?;
                 if current < minv[column] {
                     minv[column] = current;
                     way[column] = column0;
@@ -378,15 +530,27 @@ fn hungarian_min_cost(costs: &[Vec<i64>]) -> Option<i64> {
             }
 
             if delta == INF_COST {
-                return None;
+                return Ok(None);
             }
 
             for column in 0..=size {
                 if used[column] {
-                    u[p[column]] += delta;
-                    v[column] -= delta;
+                    u[p[column]] = u[p[column]].checked_add(delta).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "updating mixed Chinese postman assignment potentials".to_string(),
+                        )
+                    })?;
+                    v[column] = v[column].checked_sub(delta).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "updating mixed Chinese postman assignment potentials".to_string(),
+                        )
+                    })?;
                 } else {
-                    minv[column] -= delta;
+                    minv[column] = minv[column].checked_sub(delta).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "updating mixed Chinese postman reduced costs".to_string(),
+                        )
+                    })?;
                 }
             }
 
@@ -415,11 +579,15 @@ fn hungarian_min_cost(costs: &[Vec<i64>]) -> Option<i64> {
     for row in 1..=size {
         let cost = costs[row - 1][assignment[row] - 1];
         if cost == INF_COST {
-            return None;
+            return Ok(None);
         }
-        total += cost;
+        total = total.checked_add(cost).ok_or_else(|| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "summing mixed Chinese postman assignment costs".to_string(),
+            )
+        })?;
     }
-    Some(total)
+    Ok(Some(total))
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/mod.rs b/src/models/graph/mod.rs
index 14b102c54..7835dd74f 100644
--- a/src/models/graph/mod.rs
+++ b/src/models/graph/mod.rs
@@ -260,6 +260,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     specs.extend(directed_hamiltonian_path::canonical_model_example_specs());
     specs.extend(eulerian_path::canonical_model_example_specs());
     specs.extend(maximum_independent_set::canonical_model_example_specs());
+    specs.extend(maximum_independent_set::decision_canonical_model_example_specs());
     specs.extend(maximum_leaf_spanning_tree::canonical_model_example_specs());
     specs.extend(minimum_vertex_cover::canonical_model_example_specs());
     specs.extend(minimum_vertex_cover::decision_canonical_model_example_specs());
diff --git a/src/models/graph/monochromatic_triangle.rs b/src/models/graph/monochromatic_triangle.rs
index 17366640b..272037f0d 100644
--- a/src/models/graph/monochromatic_triangle.rs
+++ b/src/models/graph/monochromatic_triangle.rs
@@ -20,6 +20,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "2-color edges so that no triangle is monochromatic",
         fields: &[
@@ -46,14 +47,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::MonochromaticTriangle;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // K4: complete graph on 4 vertices
 /// let graph = SimpleGraph::new(4, vec![(0,1),(0,2),(0,3),(1,2),(1,3),(2,3)]);
 /// let problem = MonochromaticTriangle::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -141,42 +142,65 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "MonochromaticTriangle";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_triangles", num_triangles),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.edge_list.len()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.edge_list.len() {
-                return crate::types::Or(false);
-            }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.edge_list.len() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "edge-coloring length does not match the graph".into(),
+                    ));
+                }
 
-            // Check each triangle: if all three edges have the same color,
-            // the coloring is invalid.
-            for tri in &self.triangles {
-                let c0 = config[tri[0]];
-                let c1 = config[tri[1]];
-                let c2 = config[tri[2]];
-                if c0 == c1 && c1 == c2 {
-                    return crate::types::Or(false);
+                // Check each triangle: if all three edges have the same color,
+                // the coloring is invalid.
+                for tri in &self.triangles {
+                    let c0 = config[tri[0]];
+                    let c1 = config[tri[1]];
+                    let c2 = config[tri[2]];
+                    if c0 == c1 && c1 == c2 {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 }
 
+impl<G> crate::solvers::BruteForceProblem for MonochromaticTriangle<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.edge_list.len()]
+    }
+}
+
 crate::declare_variants! {
     default MonochromaticTriangle<SimpleGraph> => "2^num_edges",
 }
 
+crate::register_brute_force! {
+    MonochromaticTriangle<SimpleGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // K4: 4 vertices, 6 edges, has a valid 2-coloring avoiding monochromatic triangles.
@@ -192,7 +216,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             4,
             vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)],
         ))),
-        optimal_config: vec![0, 0, 1, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![false, false, true, true, false, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/multiple_choice_branching.rs b/src/models/graph/multiple_choice_branching.rs
index c0e90cdba..b04671ee2 100644
--- a/src/models/graph/multiple_choice_branching.rs
+++ b/src/models/graph/multiple_choice_branching.rs
@@ -4,7 +4,7 @@
 //! threshold, determine whether there exists a high-weight branching that
 //! picks at most one arc from each partition group.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use crate::types::WeightElement;
@@ -18,16 +18,12 @@ inventory::submit! {
         display_name: "Multiple Choice Branching",
         aliases: &[],
         dimensions: &[
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a branching with partition constraints and weight at least K",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "DirectedGraph", description: "The directed graph G=(V,A)" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Arc weights w(a) for each arc a in A" },
-            FieldInfo { name: "partition", type_name: "Vec<Vec<usize>>", description: "Partition of arc indices; each arc index must appear in exactly one group" },
-            FieldInfo { name: "threshold", type_name: "W::Sum", description: "Weight threshold K" },
-        ],
+        fields: MultipleChoiceBranchingCreateSpec::FIELDS,
     }
 }
 
@@ -48,6 +44,59 @@ pub struct MultipleChoiceBranching<W: WeightElement> {
     threshold: W::Sum,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MultipleChoiceBranchingCreateSpec {
+    /// Directed graph arcs.
+    #[create(codec = "arc-list")]
+    arcs: Vec<(usize, usize)>,
+    /// Vertex count, needed to preserve isolated vertices.
+    num_vertices: Option<usize>,
+    /// Arc weights w(a) for each arc a in A.
+    weights: Vec<i64>,
+    /// Partition of arc indices; each arc must appear exactly once.
+    partition: Vec<Vec<usize>>,
+    /// Weight threshold K.
+    threshold: i64,
+}
+
+impl TryFrom<MultipleChoiceBranchingCreateSpec> for MultipleChoiceBranching<i64> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MultipleChoiceBranchingCreateSpec) -> Result<Self, Self::Error> {
+        let inferred = spec
+            .arcs
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let num_vertices = spec.num_vertices.unwrap_or(inferred);
+        if num_vertices < inferred {
+            return Err("num_vertices is too small for arc endpoints"
+                .to_string()
+                .into());
+        }
+        let graph = DirectedGraph::new(num_vertices, spec.arcs);
+        let num_arcs = graph.num_arcs();
+        if spec.weights.len() != num_arcs {
+            return Err(format!(
+                "weights has {} entries, expected {num_arcs}",
+                spec.weights.len()
+            )
+            .into());
+        }
+        if let Some(message) = partition_validation_error(&spec.partition, num_arcs) {
+            return Err(message.into());
+        }
+        Ok(Self::new(
+            graph,
+            spec.weights,
+            spec.partition,
+            spec.threshold,
+        ))
+    }
+}
+
 #[derive(Debug, Deserialize)]
 struct MultipleChoiceBranchingUnchecked<W: WeightElement> {
     graph: DirectedGraph,
@@ -160,7 +209,10 @@ impl<W: WeightElement> MultipleChoiceBranching<W> {
     }
 
     /// Check whether a configuration is a satisfying solution.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
         is_valid_multiple_choice_branching(
             &self.graph,
             &self.weights,
@@ -176,26 +228,48 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MultipleChoiceBranching";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_vertices", num_vertices),
+        ("num_arcs", num_arcs),
+        ("num_partition_groups", num_partition_groups),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_arcs()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_arcs() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "arc-selection length does not match the graph".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or({
+                is_valid_multiple_choice_branching(
+                    &self.graph,
+                    &self.weights,
+                    &self.partition,
+                    &self.threshold,
+                    config,
+                )?
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            is_valid_multiple_choice_branching(
-                &self.graph,
-                &self.weights,
-                &self.partition,
-                &self.threshold,
-                config,
-            )
-        })
+impl<W> crate::solvers::BruteForceProblem for MultipleChoiceBranching<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_arcs()]
     }
 }
 
@@ -236,23 +310,14 @@ fn is_valid_multiple_choice_branching<W: WeightElement>(
     weights: &[W],
     partition: &[Vec<usize>],
     threshold: &W::Sum,
-    config: &[usize],
-) -> bool {
+    config: &[bool],
+) -> Result<bool, crate::traits::EvaluationError> {
     if config.len() != graph.num_arcs() {
-        return false;
+        return Ok(false);
     }
-    if config.iter().any(|&value| value >= 2) {
-        return false;
-    }
-
     for group in partition {
-        if group
-            .iter()
-            .filter(|&&arc_index| config[arc_index] == 1)
-            .count()
-            > 1
-        {
-            return false;
+        if group.iter().filter(|&&arc_index| config[arc_index]).count() > 1 {
+            return Ok(false);
         }
     }
 
@@ -261,19 +326,23 @@ fn is_valid_multiple_choice_branching<W: WeightElement>(
     let mut selected_successors = vec![Vec::new(); graph.num_vertices()];
     let mut total = W::Sum::zero();
     for (index, &selected) in config.iter().enumerate() {
-        if selected == 1 {
+        if selected {
             let (source, target) = arcs[index];
             in_degree[target] += 1;
             if in_degree[target] > 1 {
-                return false;
+                return Ok(false);
             }
             selected_successors[source].push(target);
-            total += weights[index].to_sum();
+            total = W::checked_add_to_sum(
+                total,
+                weights[index].to_sum(),
+                "summing multiple-choice branching weights",
+            )?;
         }
     }
 
     if total < *threshold {
-        return false;
+        return Ok(false);
     }
 
     let mut queue: Vec<usize> = (0..graph.num_vertices())
@@ -290,17 +359,21 @@ fn is_valid_multiple_choice_branching<W: WeightElement>(
         }
     }
 
-    visited == graph.num_vertices()
+    Ok(visited == graph.num_vertices())
 }
 
 crate::declare_variants! {
-    default MultipleChoiceBranching<i32> => "2^num_arcs",
+    default MultipleChoiceBranching<i64> => "2^num_arcs" create MultipleChoiceBranchingCreateSpec,
+}
+
+crate::register_brute_force! {
+    MultipleChoiceBranching<i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "multiple_choice_branching_i32",
+        id: "multiple_choice_branching",
         instance: Box::new(MultipleChoiceBranching::new(
             DirectedGraph::new(
                 6,
@@ -319,7 +392,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![vec![0, 1], vec![2, 3], vec![4, 7], vec![5, 6]],
             10,
         )),
-        optimal_config: vec![1, 0, 1, 0, 0, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![true, false, true, false, false, true, false, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/multiple_copy_file_allocation.rs b/src/models/graph/multiple_copy_file_allocation.rs
index c54269d30..0813b0113 100644
--- a/src/models/graph/multiple_copy_file_allocation.rs
+++ b/src/models/graph/multiple_copy_file_allocation.rs
@@ -3,7 +3,7 @@
 //! The Multiple Copy File Allocation problem asks for a placement of file copies
 //! on graph vertices that minimizes the combined storage and access cost.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::Min;
@@ -16,20 +16,10 @@ inventory::submit! {
         display_name: "Multiple Copy File Allocation",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Place file copies on graph vertices to minimize total storage plus access cost",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "SimpleGraph", description: "The network graph G=(V,E)" },
-            FieldInfo { name: "usage", type_name: "Vec<i64>", description: "Usage frequencies u(v) for each vertex" },
-            FieldInfo { name: "storage", type_name: "Vec<i64>", description: "Storage costs s(v) for placing a copy at each vertex" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "MultipleCopyFileAllocation",
-        fields: &["num_vertices", "num_edges"],
+        fields: MultipleCopyFileAllocationCreateSpec::FIELDS,
     }
 }
 
@@ -49,6 +39,58 @@ pub struct MultipleCopyFileAllocation {
     storage: Vec<i64>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MultipleCopyFileAllocationCreateSpec {
+    /// Network graph edges.
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    /// Vertex count, needed for isolated vertices.
+    num_vertices: Option<usize>,
+    /// Usage frequency per vertex.
+    #[create(codec = "comma-separated")]
+    usage: Vec<i64>,
+    /// Storage cost per vertex.
+    #[create(codec = "comma-separated")]
+    storage: Vec<i64>,
+}
+
+impl TryFrom<MultipleCopyFileAllocationCreateSpec> for MultipleCopyFileAllocation {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MultipleCopyFileAllocationCreateSpec) -> Result<Self, Self::Error> {
+        if spec.graph.is_empty() && spec.num_vertices.is_none() {
+            return Err("num_vertices is required for an empty graph".into());
+        }
+        for &(u, v) in &spec.graph {
+            if u == v {
+                return Err(format!("self-loop {u}-{v} is not allowed").into());
+            }
+        }
+        let inferred = spec
+            .graph
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|v| v.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let count = spec.num_vertices.unwrap_or(inferred);
+        if count < inferred {
+            return Err("num_vertices is too small for graph endpoints".into());
+        }
+        if spec.usage.len() != count {
+            return Err("usage length must match num_vertices".into());
+        }
+        if spec.storage.len() != count {
+            return Err("storage length must match num_vertices".into());
+        }
+        Ok(Self {
+            graph: SimpleGraph::new(count, spec.graph),
+            usage: spec.usage,
+            storage: spec.storage,
+        })
+    }
+}
+
 impl MultipleCopyFileAllocation {
     /// Create a new Multiple Copy File Allocation instance.
     pub fn new(graph: SimpleGraph, usage: Vec<i64>, storage: Vec<i64>) -> Self {
@@ -94,17 +136,15 @@ impl MultipleCopyFileAllocation {
         self.graph.num_edges()
     }
 
-    fn selected_vertices(&self, config: &[usize]) -> Option<Vec<usize>> {
+    fn selected_vertices(&self, config: &[bool]) -> Option<Vec<usize>> {
         if config.len() != self.graph.num_vertices() {
             return None;
         }
 
         let mut selected = Vec::new();
-        for (vertex, &value) in config.iter().enumerate() {
-            match value {
-                0 => {}
-                1 => selected.push(vertex),
-                _ => return None,
+        for (vertex, &selected_here) in config.iter().enumerate() {
+            if selected_here {
+                selected.push(vertex);
             }
         }
 
@@ -146,43 +186,92 @@ impl MultipleCopyFileAllocation {
     ///
     /// Returns `None` if the configuration is not binary, has the wrong length,
     /// selects no copy vertices, or leaves some vertex unreachable from every copy.
-    pub fn total_cost(&self, config: &[usize]) -> Option<i64> {
-        let selected = self.selected_vertices(config)?;
-        let distances = self.shortest_distances(&selected)?;
-
-        let storage_cost = selected
-            .into_iter()
-            .map(|vertex| self.storage[vertex])
-            .sum::<i64>();
-        let access_cost = distances
-            .into_iter()
-            .enumerate()
-            .map(|(vertex, distance)| self.usage[vertex] * distance as i64)
-            .sum::<i64>();
-
-        Some(storage_cost + access_cost)
+    pub fn total_cost(
+        &self,
+        config: &[bool],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
+        let Some(selected) = self.selected_vertices(config) else {
+            return Ok(None);
+        };
+        let Some(distances) = self.shortest_distances(&selected) else {
+            return Ok(None);
+        };
+
+        let mut storage_cost = 0_i64;
+        for vertex in selected {
+            storage_cost = storage_cost
+                .checked_add(self.storage[vertex])
+                .ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing file-copy storage costs".to_string(),
+                    )
+                })?;
+        }
+
+        let mut access_cost = 0_i64;
+        for (vertex, distance) in distances.into_iter().enumerate() {
+            let distance = i64::try_from(distance).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting file-copy access distance".to_string(),
+                )
+            })?;
+            let term = self.usage[vertex].checked_mul(distance).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "multiplying file usage by access distance".to_string(),
+                )
+            })?;
+            access_cost = access_cost.checked_add(term).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing file-copy access costs".to_string(),
+                )
+            })?;
+        }
+
+        Ok(Some(storage_cost.checked_add(access_cost).ok_or_else(
+            || {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing file-copy allocation costs".to_string(),
+                )
+            },
+        )?))
     }
 
     /// Check whether a configuration is a valid placement (at least one copy, all reachable).
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.total_cost(config).is_some()
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(self.total_cost(config)?.is_some())
     }
 }
 
 impl Problem for MultipleCopyFileAllocation {
     const NAME: &'static str = "MultipleCopyFileAllocation";
+    type Solution = Vec<bool>;
     type Value = Min<i64>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "copy-selection length does not match the graph vertices".into(),
+            ));
+        }
+        Ok(Min(self.total_cost(config)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<i64> {
-        Min(self.total_cost(config))
+impl crate::solvers::BruteForceProblem for MultipleCopyFileAllocation {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
     }
 }
 
@@ -195,13 +284,17 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![5, 1, 1, 1, 1, 5],
             vec![6, 2, 6, 6, 2, 6],
         )),
-        optimal_config: vec![0, 1, 0, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![false, true, false, false, true, false]),
         optimal_value: serde_json::json!(16),
     }]
 }
 
 crate::declare_variants! {
-    default MultipleCopyFileAllocation => "2^num_vertices",
+    default MultipleCopyFileAllocation => "2^num_vertices" create MultipleCopyFileAllocationCreateSpec,
+}
+
+crate::register_brute_force! {
+    MultipleCopyFileAllocation decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/optimal_linear_arrangement.rs b/src/models/graph/optimal_linear_arrangement.rs
index d2f14f2f7..c50552603 100644
--- a/src/models/graph/optimal_linear_arrangement.rs
+++ b/src/models/graph/optimal_linear_arrangement.rs
@@ -19,6 +19,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a vertex ordering on a line minimizing total edge length",
         fields: &[
@@ -50,14 +51,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::OptimalLinearArrangement;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Path graph: 0-1-2-3
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
 /// let problem = OptimalLinearArrangement::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -115,17 +116,29 @@ impl<G: Graph> OptimalLinearArrangement<G> {
     /// Compute the total edge length for a given arrangement.
     ///
     /// Returns `None` if the configuration is not a valid permutation.
-    pub fn total_edge_length(&self, config: &[usize]) -> Option<usize> {
+    pub fn total_edge_length(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         if !self.is_valid_permutation(config) {
-            return None;
+            return Ok(None);
         }
-        let mut total = 0usize;
+        let mut total = 0_i64;
         for (u, v) in self.graph.edges() {
             let fu = config[u];
             let fv = config[v];
-            total += fu.abs_diff(fv);
+            let length = i64::try_from(fu.abs_diff(fv)).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting linear-arrangement edge length to i64".to_string(),
+                )
+            })?;
+            total = total.checked_add(length).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing linear-arrangement edge lengths".to_string(),
+                )
+            })?;
         }
-        Some(total)
+        Ok(Some(total))
     }
 }
 
@@ -134,27 +147,61 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "OptimalLinearArrangement";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.graph.num_vertices();
-        vec![n; n]
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex arrangement length does not match the graph".into(),
+            ));
+        }
+        if config.iter().any(|&position| position >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex arrangement contains an out-of-range position".into(),
+            ));
+        }
+        Ok({
+            match self.total_edge_length(config)? {
+                Some(cost) => Min(Some(cost)),
+                None => Min(None),
+            }
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        match self.total_edge_length(config) {
-            Some(cost) => Min(Some(cost)),
-            None => Min(None),
-        }
+impl<G> crate::solvers::BruteForceProblem for OptimalLinearArrangement<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.graph.num_vertices();
+        vec![n; n]
     }
 }
 
+crate::impl_random_generate!(
+    OptimalLinearArrangement<SimpleGraph>,
+    crate::random::SimpleGraphRandomSpec,
+    |spec| { Ok(OptimalLinearArrangement::new(spec.graph()?)) }
+);
+
 crate::declare_variants! {
-    default OptimalLinearArrangement<SimpleGraph> => "2^num_vertices",
+    default OptimalLinearArrangement<SimpleGraph> => "2^num_vertices" random,
+}
+
+crate::register_brute_force! {
+    OptimalLinearArrangement<SimpleGraph>,
 }
 
 impl<G> crate::models::decision::DecisionProblemMeta for OptimalLinearArrangement<G>
@@ -177,7 +224,7 @@ impl Decision<OptimalLinearArrangement<SimpleGraph>> {
 
     /// Decision bound (maximum allowed total edge length) as a nonnegative integer.
     pub fn k(&self) -> usize {
-        *self.bound()
+        usize::try_from(*self.bound()).expect("nonnegative decision bound must fit usize")
     }
 }
 
@@ -187,14 +234,15 @@ crate::register_decision_variant!(
     "2^num_vertices",
     &["DOLA"],
     "Decision version: does a linear arrangement of total edge length <= bound exist?",
+    category: crate::registry::ProblemCategory::Graph,
     dims: [
         VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
     ],
     fields: [
         FieldInfo { name: "graph", type_name: "G", description: "The undirected graph G=(V,E)" },
-        FieldInfo { name: "bound", type_name: "usize", description: "Decision bound (maximum allowed total edge length)" },
+        FieldInfo { name: "bound", type_name: "i64", description: "Decision bound (maximum allowed total edge length)" },
     ],
-    size_getters: [("num_vertices", num_vertices), ("num_edges", num_edges)]
+    decode: |_, indices: Vec<usize>| indices
 );
 
 #[cfg(feature = "example-db")]
@@ -208,7 +256,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             6,
             vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (0, 3), (2, 5)],
         ))),
-        optimal_config: vec![0, 1, 2, 3, 4, 5],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 3, 4, 5]),
         optimal_value: serde_json::json!(11),
     }]
 }
@@ -224,7 +272,7 @@ pub(crate) fn decision_canonical_model_example_specs(
             OptimalLinearArrangement::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)])),
             3,
         )),
-        optimal_config: vec![0, 1, 2, 3],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 3]),
         optimal_value: serde_json::json!(true),
     }]
 }
@@ -245,15 +293,17 @@ pub(crate) fn decision_canonical_rule_example_specs(
                 OptimalLinearArrangement::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)])),
                 3,
             );
-            let result = source.reduce_to_aggregate();
+            let result = source
+                .reduce_to_aggregate()
+                .expect("reduction should succeed");
             let target = result.target_problem();
             let config = vec![0, 1, 2, 3];
             assemble_rule_example(
                 &source,
                 target,
                 vec![SolutionPair {
-                    source_config: config.clone(),
-                    target_config: config,
+                    source_config: serde_json::json!(config.clone()),
+                    target_config: serde_json::json!(config),
                 }],
             )
         },
diff --git a/src/models/graph/partial_feedback_edge_set.rs b/src/models/graph/partial_feedback_edge_set.rs
index 5806cd534..c62ad3c72 100644
--- a/src/models/graph/partial_feedback_edge_set.rs
+++ b/src/models/graph/partial_feedback_edge_set.rs
@@ -3,7 +3,7 @@
 //! The Partial Feedback Edge Set problem asks whether removing at most `K`
 //! edges can hit every cycle of length at most `L`.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -18,13 +18,10 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Remove at most K edges so that every cycle of length at most L is hit",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "budget", type_name: "usize", description: "Maximum number K of edges that may be removed" },
-            FieldInfo { name: "max_cycle_length", type_name: "usize", description: "Cycle length bound L; every cycle with length at most L must be hit" },
-        ],
+        fields: PartialFeedbackEdgeSetCreateSpec::FIELDS,
     }
 }
 
@@ -46,6 +43,23 @@ pub struct PartialFeedbackEdgeSet<G> {
     max_cycle_length: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct PartialFeedbackEdgeSetCreateSpec {
+    /// The underlying graph G=(V,E).
+    graph: SimpleGraph,
+    /// Maximum number K of edges that may be removed.
+    budget: usize,
+    /// Cycle length bound L.
+    max_cycle_length: usize,
+}
+
+impl TryFrom<PartialFeedbackEdgeSetCreateSpec> for PartialFeedbackEdgeSet<SimpleGraph> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: PartialFeedbackEdgeSetCreateSpec) -> Result<Self, Self::Error> {
+        Ok(Self::new(spec.graph, spec.budget, spec.max_cycle_length))
+    }
+}
+
 impl<G: Graph> PartialFeedbackEdgeSet<G> {
     /// Create a new Partial Feedback Edge Set instance.
     pub fn new(graph: G, budget: usize, max_cycle_length: usize) -> Self {
@@ -82,17 +96,17 @@ impl<G: Graph> PartialFeedbackEdgeSet<G> {
     }
 
     /// Check whether a configuration is a satisfying partial feedback edge set.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        if config.len() != self.num_edges() || config.iter().any(|&value| value > 1) {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
+        if config.len() != self.num_edges() {
             return false;
         }
 
-        let removed_edges = config.iter().filter(|&&value| value == 1).count();
+        let removed_edges = config.iter().filter(|&&removed| removed).count();
         if removed_edges > self.budget {
             return false;
         }
 
-        let kept_edges: Vec<bool> = config.iter().map(|&value| value == 0).collect();
+        let kept_edges: Vec<bool> = config.iter().map(|&removed| !removed).collect();
         !has_cycle_with_length_at_most(&self.graph, &kept_edges, self.max_cycle_length)
     }
 }
@@ -102,18 +116,39 @@ where
     G: Graph + crate::variant::VariantParam,
 {
     const NAME: &'static str = "PartialFeedbackEdgeSet";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_vertices", num_vertices),
+        ("num_edges", num_edges),
+        ("max_cycle_length", max_cycle_length),
+        ("budget", budget),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_valid_solution(config)))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_valid_solution(config))
+impl<G> crate::solvers::BruteForceProblem for PartialFeedbackEdgeSet<G>
+where
+    G: Graph + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_edges()]
     }
 }
 
@@ -218,16 +253,17 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         .into_iter()
         .map(|(u, v)| normalize_edge(u, v))
         .collect();
-    let optimal_config = graph
+    let optimal_config: Vec<bool> = graph
         .edges()
         .into_iter()
-        .map(|(u, v)| usize::from(chosen.contains(&normalize_edge(u, v))))
+        .map(|(u, v)| chosen.contains(&normalize_edge(u, v)))
         .collect();
 
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "partial_feedback_edge_set_simplegraph",
         instance: Box::new(PartialFeedbackEdgeSet::new(graph, 3, 4)),
-        optimal_config,
+        optimal_config: serde_json::to_value(optimal_config)
+            .expect("solution serialization must succeed"),
         optimal_value: serde_json::json!(true),
     }]
 }
@@ -242,7 +278,11 @@ fn normalize_edge(u: usize, v: usize) -> (usize, usize) {
 }
 
 crate::declare_variants! {
-    default PartialFeedbackEdgeSet<SimpleGraph> => "2^num_edges",
+    default PartialFeedbackEdgeSet<SimpleGraph> => "2^num_edges" create PartialFeedbackEdgeSetCreateSpec,
+}
+
+crate::register_brute_force! {
+    PartialFeedbackEdgeSet<SimpleGraph> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/partition_into_cliques.rs b/src/models/graph/partition_into_cliques.rs
index 4189399be..5bb87de80 100644
--- a/src/models/graph/partition_into_cliques.rs
+++ b/src/models/graph/partition_into_cliques.rs
@@ -18,6 +18,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Partition vertices into K groups each inducing a clique",
         fields: &[
@@ -42,14 +43,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::PartitionIntoCliques;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Two triangles: 0-1-2-0 and 3-4-5-3
 /// let graph = SimpleGraph::new(6, vec![(0,1),(0,2),(1,2),(3,4),(3,5),(4,5)]);
 /// let problem = PartitionIntoCliques::new(graph, 3);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -101,22 +102,45 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "PartitionIntoCliques";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_cliques; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&part| part >= self.num_cliques) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment contains an out-of-range clique".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or(is_valid_clique_partition(
+                &self.graph,
+                self.num_cliques,
+                config,
+            ))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(is_valid_clique_partition(
-            &self.graph,
-            self.num_cliques,
-            config,
-        ))
+impl<G> crate::solvers::BruteForceProblem for PartitionIntoCliques<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_cliques; self.graph.num_vertices()]
     }
 }
 
@@ -151,6 +175,10 @@ crate::declare_variants! {
     default PartitionIntoCliques<SimpleGraph> => "2^num_vertices",
 }
 
+crate::register_brute_force! {
+    PartitionIntoCliques<SimpleGraph>,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -172,7 +200,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ),
             3,
         )),
-        optimal_config: vec![0, 0, 0, 1, 1, 1],
+        optimal_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/partition_into_forests.rs b/src/models/graph/partition_into_forests.rs
index 4c82a565b..09fe3a156 100644
--- a/src/models/graph/partition_into_forests.rs
+++ b/src/models/graph/partition_into_forests.rs
@@ -18,6 +18,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Partition vertices into K classes each inducing an acyclic subgraph",
         fields: &[
@@ -42,14 +43,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::PartitionIntoForests;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Graph containing two triangles; K=2 forests suffice
 /// let graph = SimpleGraph::new(6, vec![(0,1),(1,2),(2,0),(2,3),(3,4),(4,5),(5,3)]);
 /// let problem = PartitionIntoForests::new(graph, 2);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -97,22 +98,49 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "PartitionIntoForests";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_vertices", num_vertices),
+        ("num_edges", num_edges),
+        ("num_forests", num_forests),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_forests; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&part| part >= self.num_forests) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment contains an out-of-range forest".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or(is_valid_forest_partition(
+                &self.graph,
+                self.num_forests,
+                config,
+            ))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(is_valid_forest_partition(
-            &self.graph,
-            self.num_forests,
-            config,
-        ))
+impl<G> crate::solvers::BruteForceProblem for PartitionIntoForests<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_forests; self.graph.num_vertices()]
     }
 }
 
@@ -161,6 +189,10 @@ crate::declare_variants! {
     default PartitionIntoForests<SimpleGraph> => "num_forests^num_vertices",
 }
 
+crate::register_brute_force! {
+    PartitionIntoForests<SimpleGraph>,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -174,7 +206,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         )),
         // V0={0,3}: edges from graph in class 0: none among {0,3} → forest
         // V1={1,2,4,5}: edges (1,2),(3,4) but 3∉V1; edges among V1: (1,2),(4,5) → path forest
-        optimal_config: vec![0, 1, 1, 0, 1, 1],
+        optimal_config: serde_json::json!(vec![0, 1, 1, 0, 1, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/partition_into_paths_of_length_2.rs b/src/models/graph/partition_into_paths_of_length_2.rs
index 717bcab97..5c198c54f 100644
--- a/src/models/graph/partition_into_paths_of_length_2.rs
+++ b/src/models/graph/partition_into_paths_of_length_2.rs
@@ -20,6 +20,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Partition vertices into triples each inducing at least two edges (P3 or triangle)",
         fields: &[
@@ -47,14 +48,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::PartitionIntoPathsOfLength2;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 6-vertex graph with two P3 paths: 0-1-2 and 3-4-5
 /// let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (3, 4), (4, 5)]);
 /// let problem = PartitionIntoPathsOfLength2::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -148,19 +149,40 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "PartitionIntoPathsOfLength2";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let q = self.num_groups();
-        vec![q; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&group| group >= self.num_groups()) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment contains an out-of-range group".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_valid_partition(config)))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_valid_partition(config))
+impl<G> crate::solvers::BruteForceProblem for PartitionIntoPathsOfLength2<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let q = self.num_groups();
+        vec![q; self.graph.num_vertices()]
     }
 }
 
@@ -168,6 +190,10 @@ crate::declare_variants! {
     default PartitionIntoPathsOfLength2<SimpleGraph> => "3^num_vertices",
 }
 
+crate::register_brute_force! {
+    PartitionIntoPathsOfLength2<SimpleGraph>,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -189,7 +215,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 (4, 7),
             ],
         ))),
-        optimal_config: vec![0, 0, 0, 1, 1, 1, 2, 2, 2],
+        optimal_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1, 2, 2, 2]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/partition_into_perfect_matchings.rs b/src/models/graph/partition_into_perfect_matchings.rs
index 89fcef0bc..e93976e53 100644
--- a/src/models/graph/partition_into_perfect_matchings.rs
+++ b/src/models/graph/partition_into_perfect_matchings.rs
@@ -19,6 +19,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Partition vertices into K groups each inducing a perfect matching",
         fields: &[
@@ -44,14 +45,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::PartitionIntoPerfectMatchings;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 4 vertices with edges: (0,1),(2,3),(0,2),(1,3)
 /// let graph = SimpleGraph::new(4, vec![(0,1),(2,3),(0,2),(1,3)]);
 /// let problem = PartitionIntoPerfectMatchings::new(graph, 2);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -106,22 +107,49 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "PartitionIntoPerfectMatchings";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_matchings", num_matchings),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_matchings; self.graph.num_vertices()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&part| part >= self.num_matchings) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment contains an out-of-range matching".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or(is_valid_perfect_matching_partition(
+                &self.graph,
+                self.num_matchings,
+                config,
+            ))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(is_valid_perfect_matching_partition(
-            &self.graph,
-            self.num_matchings,
-            config,
-        ))
+impl<G> crate::solvers::BruteForceProblem for PartitionIntoPerfectMatchings<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_matchings; self.graph.num_vertices()]
     }
 }
 
@@ -172,6 +200,10 @@ crate::declare_variants! {
     default PartitionIntoPerfectMatchings<SimpleGraph> => "num_matchings^num_vertices",
 }
 
+crate::register_brute_force! {
+    PartitionIntoPerfectMatchings<SimpleGraph>,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -180,7 +212,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             SimpleGraph::new(4, vec![(0, 1), (2, 3), (0, 2), (1, 3)]),
             2,
         )),
-        optimal_config: vec![0, 0, 1, 1],
+        optimal_config: serde_json::json!(vec![0, 0, 1, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/partition_into_triangles.rs b/src/models/graph/partition_into_triangles.rs
index b14d5efe5..8638705d2 100644
--- a/src/models/graph/partition_into_triangles.rs
+++ b/src/models/graph/partition_into_triangles.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Partition vertices into triangles (K3 subgraphs)",
         fields: &[
@@ -39,14 +40,14 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::PartitionIntoTriangles;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Triangle graph: 3 vertices forming a single triangle
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
 /// let problem = PartitionIntoTriangles::new(graph);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -91,75 +92,96 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "PartitionIntoTriangles";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let q = self.graph.num_vertices() / 3;
-        vec![q; self.graph.num_vertices()]
-    }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                let n = self.graph.num_vertices();
+                let q = n / 3;
+
+                // Check config length
+                if config.len() != n {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "partition assignment length does not match the graph vertices".into(),
+                    ));
+                }
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let n = self.graph.num_vertices();
-            let q = n / 3;
-
-            // Check config length
-            if config.len() != n {
-                return crate::types::Or(false);
-            }
-
-            // Check all values are in range [0, q)
-            if config.iter().any(|&c| c >= q) {
-                return crate::types::Or(false);
-            }
-
-            // Count vertices per group
-            let mut counts = vec![0usize; q];
-            for &c in config {
-                counts[c] += 1;
-            }
-
-            // Each group must have exactly 3 vertices
-            if counts.iter().any(|&c| c != 3) {
-                return crate::types::Or(false);
-            }
-
-            // Build per-group vertex lists in a single pass over config.
-            let mut group_verts = vec![[0usize; 3]; q];
-            let mut group_pos = vec![0usize; q];
-
-            for (v, &g) in config.iter().enumerate() {
-                let pos = group_pos[g];
-                group_verts[g][pos] = v;
-                group_pos[g] = pos + 1;
-            }
-
-            // Check each group forms a triangle
-            for verts in &group_verts {
-                if !self.graph.has_edge(verts[0], verts[1]) {
-                    return crate::types::Or(false);
+                // Check all values are in range [0, q)
+                if config.iter().any(|&c| c >= q) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "partition assignment contains an out-of-range group".into(),
+                    ));
                 }
-                if !self.graph.has_edge(verts[0], verts[2]) {
-                    return crate::types::Or(false);
+
+                // Count vertices per group
+                let mut counts = vec![0usize; q];
+                for &c in config {
+                    counts[c] += 1;
+                }
+
+                // Each group must have exactly 3 vertices
+                if counts.iter().any(|&c| c != 3) {
+                    return Ok(crate::types::Or(false));
+                }
+
+                // Build per-group vertex lists in a single pass over config.
+                let mut group_verts = vec![[0usize; 3]; q];
+                let mut group_pos = vec![0usize; q];
+
+                for (v, &g) in config.iter().enumerate() {
+                    let pos = group_pos[g];
+                    group_verts[g][pos] = v;
+                    group_pos[g] = pos + 1;
                 }
-                if !self.graph.has_edge(verts[1], verts[2]) {
-                    return crate::types::Or(false);
+
+                // Check each group forms a triangle
+                for verts in &group_verts {
+                    if !self.graph.has_edge(verts[0], verts[1]) {
+                        return Ok(crate::types::Or(false));
+                    }
+                    if !self.graph.has_edge(verts[0], verts[2]) {
+                        return Ok(crate::types::Or(false));
+                    }
+                    if !self.graph.has_edge(verts[1], verts[2]) {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 }
 
+impl<G> crate::solvers::BruteForceProblem for PartitionIntoTriangles<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let q = self.graph.num_vertices() / 3;
+        vec![q; self.graph.num_vertices()]
+    }
+}
+
 crate::declare_variants! {
     default PartitionIntoTriangles<SimpleGraph> => "2^num_vertices",
 }
 
+crate::register_brute_force! {
+    PartitionIntoTriangles<SimpleGraph>,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -168,7 +190,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             6,
             vec![(0, 1), (0, 2), (1, 2), (3, 4), (3, 5), (4, 5), (0, 3)],
         ))),
-        optimal_config: vec![0, 0, 0, 1, 1, 1],
+        optimal_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/path_constrained_network_flow.rs b/src/models/graph/path_constrained_network_flow.rs
index 373598e22..e9f324664 100644
--- a/src/models/graph/path_constrained_network_flow.rs
+++ b/src/models/graph/path_constrained_network_flow.rs
@@ -6,7 +6,7 @@
 //! capacities are respected and the total delivered flow reaches the required
 //! threshold.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -18,16 +18,10 @@ inventory::submit! {
         display_name: "Path-Constrained Network Flow",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Integral flow feasibility on a prescribed collection of directed s-t paths",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "DirectedGraph", description: "Directed graph G = (V, A)" },
-            FieldInfo { name: "capacities", type_name: "Vec<u64>", description: "Capacity c(a) for each arc" },
-            FieldInfo { name: "source", type_name: "usize", description: "Source vertex s" },
-            FieldInfo { name: "sink", type_name: "usize", description: "Sink vertex t" },
-            FieldInfo { name: "paths", type_name: "Vec<Vec<usize>>", description: "Prescribed directed s-t paths as arc-index sequences" },
-            FieldInfo { name: "requirement", type_name: "u64", description: "Required total flow R" },
-        ],
+        fields: PathConstrainedNetworkFlowCreateSpec::FIELDS,
     }
 }
 
@@ -42,11 +36,69 @@ inventory::submit! {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PathConstrainedNetworkFlow {
     graph: DirectedGraph,
-    capacities: Vec<u64>,
+    capacities: Vec<i64>,
     source: usize,
     sink: usize,
     paths: Vec<Vec<usize>>,
-    requirement: u64,
+    requirement: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct PathConstrainedNetworkFlowCreateSpec {
+    /// Directed graph arcs.
+    #[create(codec = "arc-list")]
+    arcs: Vec<(usize, usize)>,
+    /// Vertex count, needed to preserve isolated vertices.
+    num_vertices: Option<usize>,
+    /// Arc capacities; defaults to one per arc.
+    #[create(codec = "comma-separated")]
+    capacities: Option<Vec<i64>>,
+    /// Source vertex.
+    source: usize,
+    /// Sink vertex.
+    sink: usize,
+    /// Prescribed paths as arc-index sequences.
+    #[create(codec = "semicolon-separated")]
+    paths: Vec<Vec<usize>>,
+    /// Required total flow.
+    requirement: i64,
+}
+
+impl TryFrom<PathConstrainedNetworkFlowCreateSpec> for PathConstrainedNetworkFlow {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: PathConstrainedNetworkFlowCreateSpec) -> Result<Self, Self::Error> {
+        if spec.arcs.is_empty() {
+            return Err("arcs must be non-empty".to_string().into());
+        }
+        if spec.paths.is_empty() {
+            return Err("paths must be non-empty".to_string().into());
+        }
+        let inferred = spec
+            .arcs
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let num_vertices = spec.num_vertices.unwrap_or(inferred);
+        if num_vertices < inferred {
+            return Err(format!(
+                "num_vertices {num_vertices} is too small for arc endpoints; need at least {inferred}"
+            ).into());
+        }
+        let capacities = spec.capacities.unwrap_or_else(|| vec![1; spec.arcs.len()]);
+        let graph = DirectedGraph::new(num_vertices, spec.arcs);
+        Self::try_new(
+            graph,
+            capacities,
+            spec.source,
+            spec.sink,
+            spec.paths,
+            spec.requirement,
+        )
+    }
 }
 
 impl PathConstrainedNetworkFlow {
@@ -60,44 +112,65 @@ impl PathConstrainedNetworkFlow {
     /// - any prescribed path is not a valid directed simple s-t path
     pub fn new(
         graph: DirectedGraph,
-        capacities: Vec<u64>,
+        capacities: Vec<i64>,
         source: usize,
         sink: usize,
         paths: Vec<Vec<usize>>,
-        requirement: u64,
+        requirement: i64,
     ) -> Self {
+        Self::try_new(graph, capacities, source, sink, paths, requirement)
+            .unwrap_or_else(|message| panic!("{message}"))
+    }
+
+    /// Create an instance, returning validation errors instead of panicking.
+    pub fn try_new(
+        graph: DirectedGraph,
+        capacities: Vec<i64>,
+        source: usize,
+        sink: usize,
+        paths: Vec<Vec<usize>>,
+        requirement: i64,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         let num_vertices = graph.num_vertices();
-        assert_eq!(
-            capacities.len(),
-            graph.num_arcs(),
-            "capacities length must match graph num_arcs"
-        );
-        assert!(
-            source < num_vertices,
-            "source ({source}) >= num_vertices ({num_vertices})"
-        );
-        assert!(
-            sink < num_vertices,
-            "sink ({sink}) >= num_vertices ({num_vertices})"
-        );
-        assert_ne!(source, sink, "source and sink must be distinct");
-
-        for path in &paths {
-            Self::assert_valid_path(&graph, path, source, sink);
+        if capacities.len() != graph.num_arcs() {
+            return Err("capacities length must match graph num_arcs"
+                .to_string()
+                .into());
+        }
+        if source >= num_vertices {
+            return Err(format!("source ({source}) >= num_vertices ({num_vertices})").into());
+        }
+        if sink >= num_vertices {
+            return Err(format!("sink ({sink}) >= num_vertices ({num_vertices})").into());
+        }
+        if source == sink {
+            return Err("source and sink must be distinct".to_string().into());
+        }
+
+        for (index, path) in paths.iter().enumerate() {
+            Self::validate_path(&graph, path, source, sink)
+                .map_err(|message| format!("path {index}: {message}"))?;
         }
 
-        Self {
+        Ok(Self {
             graph,
             capacities,
             source,
             sink,
             paths,
             requirement,
-        }
+        })
     }
 
-    fn assert_valid_path(graph: &DirectedGraph, path: &[usize], source: usize, sink: usize) {
-        assert!(!path.is_empty(), "prescribed paths must be non-empty");
+    fn validate_path(
+        graph: &DirectedGraph,
+        path: &[usize],
+        source: usize,
+        sink: usize,
+    ) -> Result<(), crate::registry::ConstructionError> {
+        if path.is_empty() {
+            return Err("prescribed paths must be non-empty".to_string().into());
+        }
 
         let arcs = graph.arcs();
         let mut visited_vertices = HashSet::from([source]);
@@ -106,25 +179,25 @@ impl PathConstrainedNetworkFlow {
         for &arc_idx in path {
             let &(tail, head) = arcs
                 .get(arc_idx)
-                .unwrap_or_else(|| panic!("path arc index {arc_idx} out of bounds"));
-            assert_eq!(
-                tail, current,
-                "prescribed path is not contiguous: expected arc leaving vertex {current}, got {tail}->{head}"
-            );
-            assert!(
-                visited_vertices.insert(head),
-                "prescribed path repeats vertex {head}, so it is not a simple path"
-            );
+                .ok_or_else(|| format!("arc index {arc_idx} out of bounds"))?;
+            if tail != current {
+                return Err(format!(
+                    "not contiguous: expected arc leaving vertex {current}, got {tail}->{head}"
+                )
+                .into());
+            }
+            if !visited_vertices.insert(head) {
+                return Err(format!("repeats vertex {head}, so it is not a simple path").into());
+            }
             current = head;
         }
-
-        assert_eq!(
-            current, sink,
-            "prescribed path must end at sink {sink}, ended at {current}"
-        );
+        if current != sink {
+            return Err(format!("must end at sink {sink}, ended at {current}").into());
+        }
+        Ok(())
     }
 
-    fn path_bottleneck(&self, path: &[usize]) -> u64 {
+    fn path_bottleneck(&self, path: &[usize]) -> i64 {
         path.iter()
             .map(|&arc_idx| self.capacities[arc_idx])
             .min()
@@ -137,7 +210,7 @@ impl PathConstrainedNetworkFlow {
     }
 
     /// Get the arc capacities.
-    pub fn capacities(&self) -> &[u64] {
+    pub fn capacities(&self) -> &[i64] {
         &self.capacities
     }
 
@@ -157,12 +230,12 @@ impl PathConstrainedNetworkFlow {
     }
 
     /// Get the required total flow.
-    pub fn requirement(&self) -> u64 {
+    pub fn requirement(&self) -> i64 {
         self.requirement
     }
 
     /// Update the required total flow.
-    pub fn set_requirement(&mut self, requirement: u64) {
+    pub fn set_requirement(&mut self, requirement: i64) {
         self.requirement = requirement;
     }
 
@@ -182,51 +255,70 @@ impl PathConstrainedNetworkFlow {
     }
 
     /// Get the maximum arc capacity.
-    pub fn max_capacity(&self) -> u64 {
+    pub fn max_capacity(&self) -> i64 {
         self.capacities.iter().copied().max().unwrap_or(0)
     }
 
     /// Check whether a path-flow assignment is feasible.
-    pub fn is_feasible(&self, config: &[usize]) -> bool {
+    pub fn is_feasible(&self, config: &[usize]) -> Result<bool, crate::traits::EvaluationError> {
         if config.len() != self.paths.len() {
-            return false;
+            return Ok(false);
         }
 
-        let mut arc_loads = vec![0_u64; self.capacities.len()];
-        let mut total_flow = 0_u64;
+        let mut arc_loads = vec![0_i64; self.capacities.len()];
+        let mut total_flow = 0_i64;
 
         for (flow_value, path) in config.iter().copied().zip(&self.paths) {
-            let path_flow = flow_value as u64;
+            let path_flow = i64::try_from(flow_value).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting path flow to i64".into(),
+                )
+            })?;
             if path_flow > self.path_bottleneck(path) {
-                return false;
+                return Ok(false);
             }
 
-            total_flow += path_flow;
+            total_flow = total_flow.checked_add(path_flow).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow("summing total path flow".into())
+            })?;
             for &arc_idx in path {
-                arc_loads[arc_idx] += path_flow;
+                arc_loads[arc_idx] =
+                    arc_loads[arc_idx].checked_add(path_flow).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing path flow on an arc".into(),
+                        )
+                    })?;
                 if arc_loads[arc_idx] > self.capacities[arc_idx] {
-                    return false;
+                    return Ok(false);
                 }
             }
         }
 
-        total_flow >= self.requirement
+        Ok(total_flow >= self.requirement)
     }
 }
 
 impl Problem for PathConstrainedNetworkFlow {
     const NAME: &'static str = "PathConstrainedNetworkFlow";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        self.paths
-            .iter()
-            .map(|path| (self.path_bottleneck(path) as usize) + 1)
-            .collect()
-    }
+    crate::problem_parameters![
+        ("max_capacity", max_capacity),
+        ("num_arcs", num_arcs),
+        ("num_paths", num_paths),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_feasible(config))
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.paths.len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "path-flow vector length does not match the candidate paths".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_feasible(config)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -234,8 +326,21 @@ impl Problem for PathConstrainedNetworkFlow {
     }
 }
 
+impl crate::solvers::BruteForceProblem for PathConstrainedNetworkFlow {
+    fn dimensions(&self) -> Vec<usize> {
+        self.paths
+            .iter()
+            .map(|path| (self.path_bottleneck(path) as usize) + 1)
+            .collect()
+    }
+}
+
 crate::declare_variants! {
-    default PathConstrainedNetworkFlow => "(max_capacity + 1)^num_paths",
+    default PathConstrainedNetworkFlow => "(max_capacity + 1)^num_paths" create PathConstrainedNetworkFlowCreateSpec,
+}
+
+crate::register_brute_force! {
+    PathConstrainedNetworkFlow,
 }
 
 #[cfg(feature = "example-db")]
@@ -270,7 +375,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
             3,
         )),
-        optimal_config: vec![1, 1, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![1, 1, 0, 0, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/prize_collecting_steiner_forest.rs b/src/models/graph/prize_collecting_steiner_forest.rs
index d44281dd0..1503614e1 100644
--- a/src/models/graph/prize_collecting_steiner_forest.rs
+++ b/src/models/graph/prize_collecting_steiner_forest.rs
@@ -24,7 +24,7 @@
 //! - Earlier conference version, RECOMB 2012, LNBI 7262, pp. 287--301.
 //!   <https://doi.org/10.1007/978-3-642-29627-7_31>
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry, VariantDimension};
+use crate::registry::{ConstructionError, CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
@@ -40,24 +40,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32", "f64"]),
+            VariantDimension::new("weight", "i64", &["i64", "f64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a forest minimizing omitted-prize plus edge-cost plus omega times the number of tree components",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying network G=(V,E)" },
-            FieldInfo { name: "vertex_prizes", type_name: "Vec<W>", description: "Nonnegative vertex prizes p: V -> R_{>=0}" },
-            FieldInfo { name: "edge_costs", type_name: "Vec<W>", description: "Nonnegative edge costs c: E -> R_{>=0} in graph.edges() order" },
-            FieldInfo { name: "beta", type_name: "W", description: "Tradeoff coefficient beta >= 0 on the omitted-prize term" },
-            FieldInfo { name: "omega", type_name: "W", description: "Per-component penalty omega >= 0 on the number of tree components" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "PrizeCollectingSteinerForest",
-        fields: &["num_vertices", "num_edges", "num_vertices_with_prize"],
+        fields: PrizeCollectingSteinerForestI64CreateSpec::FIELDS,
     }
 }
 
@@ -76,7 +64,7 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - Graph type (currently `SimpleGraph`).
-/// * `W` - Weight / cost type (e.g., `i32`, `f64`).
+/// * `W` - Weight / cost type (e.g., `i64`, `f64`).
 ///
 /// # Example
 ///
@@ -84,19 +72,19 @@ inventory::submit! {
 /// use problemreductions::models::graph::PrizeCollectingSteinerForest;
 /// use problemreductions::topology::SimpleGraph;
 /// use problemreductions::types::Min;
-/// use problemreductions::{BruteForce, Problem, Solver};
+/// use problemreductions::{BruteForce, Problem};
 ///
 /// // Path 0 - 1 - 2 with edge costs c(0,1)=1, c(1,2)=6 and vertex prizes
 /// // p = (5, 2, 5), beta = 1, omega = 2.
 /// let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
 /// let problem =
-///     PrizeCollectingSteinerForest::<_, i32>::new(graph, vec![5, 2, 5], vec![1, 6], 1, 2);
+///     PrizeCollectingSteinerForest::<_, i64>::new(graph, vec![5, 2, 5], vec![1, 6], 1, 2).unwrap();
 /// // V_F = {0,1,2}, E_F = {(0,1)} gives two components {0,1} and {2}:
 /// // objective = 0 + 1 + 2*2 = 5.
-/// assert_eq!(BruteForce::new().solve(&problem), Min(Some(5)));
+/// let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+/// assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(5)));
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(bound(deserialize = "G: serde::Deserialize<'de>, W: serde::Deserialize<'de>"))]
+#[derive(Debug, Clone, Serialize)]
 pub struct PrizeCollectingSteinerForest<G, W> {
     /// The underlying network.
     graph: G,
@@ -110,30 +98,144 @@ pub struct PrizeCollectingSteinerForest<G, W> {
     omega: W,
 }
 
-impl<G: Graph, W: Clone + Default> PrizeCollectingSteinerForest<G, W> {
+#[derive(Deserialize)]
+struct PrizeCollectingSteinerForestData<G, W> {
+    graph: G,
+    vertex_prizes: Vec<W>,
+    edge_costs: Vec<W>,
+    beta: W,
+    omega: W,
+}
+
+impl<'de, G, W> Deserialize<'de> for PrizeCollectingSteinerForest<G, W>
+where
+    G: Graph + Deserialize<'de>,
+    W: WeightElement + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let data = PrizeCollectingSteinerForestData::deserialize(deserializer)?;
+        Self::new(
+            data.graph,
+            data.vertex_prizes,
+            data.edge_costs,
+            data.beta,
+            data.omega,
+        )
+        .map_err(serde::de::Error::custom)
+    }
+}
+
+macro_rules! prize_collecting_steiner_forest_create_spec {
+    ($name:ident, $weight:ty, $one:expr) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            #[create(codec = "edge-list")]
+            graph: Vec<(usize, usize)>,
+            num_vertices: Option<usize>,
+            #[create(codec = "comma-separated")]
+            vertex_prizes: Option<Vec<$weight>>,
+            #[create(codec = "comma-separated")]
+            edge_costs: Option<Vec<$weight>>,
+            beta: $weight,
+            omega: $weight,
+        }
+
+        impl TryFrom<$name> for PrizeCollectingSteinerForest<SimpleGraph, $weight> {
+            type Error = ConstructionError;
+
+            fn try_from(spec: $name) -> Result<Self, Self::Error> {
+                let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+                let vertex_prizes = spec
+                    .vertex_prizes
+                    .unwrap_or_else(|| vec![$one; graph.num_vertices()]);
+                let edge_costs = spec
+                    .edge_costs
+                    .unwrap_or_else(|| vec![$one; graph.num_edges()]);
+                Self::new(graph, vertex_prizes, edge_costs, spec.beta, spec.omega)
+            }
+        }
+    };
+}
+
+prize_collecting_steiner_forest_create_spec!(PrizeCollectingSteinerForestI64CreateSpec, i64, 1);
+prize_collecting_steiner_forest_create_spec!(PrizeCollectingSteinerForestF64CreateSpec, f64, 1.0);
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err(ConstructionError::Conversion(
+            "num_vertices is required for an empty graph".into(),
+        ));
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(ConstructionError::Conversion(format!(
+                "graph edge {index} is a self-loop at vertex {u}"
+            )));
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| {
+            vertex.checked_add(1).ok_or_else(|| {
+                ConstructionError::IntegerOverflow(
+                    "inferring the PrizeCollectingSteinerForest vertex count".into(),
+                )
+            })
+        })
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(ConstructionError::Conversion(format!(
+            "num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}"
+        )));
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
+}
+
+impl<G: Graph, W: WeightElement> PrizeCollectingSteinerForest<G, W> {
     /// Create a new Prize-Collecting Steiner Forest instance.
     ///
-    /// # Panics
-    /// Panics if `vertex_prizes.len() != graph.num_vertices()` or
-    /// `edge_costs.len() != graph.num_edges()`.
-    pub fn new(graph: G, vertex_prizes: Vec<W>, edge_costs: Vec<W>, beta: W, omega: W) -> Self {
-        assert_eq!(
-            vertex_prizes.len(),
-            graph.num_vertices(),
-            "vertex_prizes length must match graph num_vertices"
-        );
-        assert_eq!(
-            edge_costs.len(),
-            graph.num_edges(),
-            "edge_costs length must match graph num_edges"
-        );
-        Self {
+    pub fn new(
+        graph: G,
+        vertex_prizes: Vec<W>,
+        edge_costs: Vec<W>,
+        beta: W,
+        omega: W,
+    ) -> Result<Self, ConstructionError> {
+        if vertex_prizes.len() != graph.num_vertices() {
+            return Err(ConstructionError::Conversion(
+                "vertex_prizes length must match graph num_vertices".into(),
+            ));
+        }
+        if edge_costs.len() != graph.num_edges() {
+            return Err(ConstructionError::Conversion(
+                "edge_costs length must match graph num_edges".into(),
+            ));
+        }
+        for (index, prize) in vertex_prizes.iter().enumerate() {
+            prize.validate_element(&format!("vertex prize at index {index}"))?;
+        }
+        for (index, cost) in edge_costs.iter().enumerate() {
+            cost.validate_element(&format!("edge cost at index {index}"))?;
+        }
+        beta.validate_element("beta")?;
+        omega.validate_element("omega")?;
+        Ok(Self {
             graph,
             vertex_prizes,
             edge_costs,
             beta,
             omega,
-        }
+        })
     }
 
     /// Reference to the underlying graph.
@@ -185,8 +287,8 @@ impl<G: Graph, W: WeightElement> PrizeCollectingSteinerForest<G, W> {
 
     /// Whether this configuration is a feasible forest (selected edges only
     /// touch selected vertices and induce an acyclic subgraph).
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        forest_components(&self.graph, config).is_some()
+    pub fn is_valid_solution(&self, solution: &(Vec<bool>, Vec<bool>)) -> bool {
+        forest_components(&self.graph, &solution.0, &solution.1).is_some()
     }
 }
 
@@ -196,58 +298,99 @@ where
     W: WeightElement + VariantParam,
 {
     const NAME: &'static str = "PrizeCollectingSteinerForest";
+    type Solution = (Vec<bool>, Vec<bool>);
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_vertices", num_vertices),
+        ("num_vertices_with_prize", num_vertices_with_prize),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices() + self.graph.num_edges()]
-    }
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        let (vertices, edges) = solution;
+        if vertices.len() != self.graph.num_vertices() || edges.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "Steiner forest selection dimensions do not match the graph".into(),
+            ));
+        }
+        Ok({
+            let kappa = match forest_components(&self.graph, vertices, edges) {
+                Some(kappa) => kappa,
+                None => return Ok(Min(None)),
+            };
 
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        let n = self.graph.num_vertices();
-        let kappa = match forest_components(&self.graph, config) {
-            Some(kappa) => kappa,
-            None => return Min(None),
-        };
-
-        // Objective: beta * sum_{v notin V_F} p(v)
-        //          + sum_{e in E_F} c(e)
-        //          + omega * kappa(F).
-        //
-        // `W::Sum: Num` (via `NumericSize`) gives us `Mul`, so we form the
-        // products `beta * (omitted prize sum)` and `omega * kappa` directly.
-        let mut omitted_prizes = W::Sum::zero();
-        for (v, prize) in self.vertex_prizes.iter().enumerate() {
-            if config[v] == 0 {
-                omitted_prizes += prize.to_sum();
+            // Objective: beta * sum_{v notin V_F} p(v)
+            //          + sum_{e in E_F} c(e)
+            //          + omega * kappa(F).
+            //
+            let mut omitted_prizes = W::Sum::zero();
+            for (v, prize) in self.vertex_prizes.iter().enumerate() {
+                if !vertices[v] {
+                    omitted_prizes = W::checked_add_to_sum(
+                        omitted_prizes,
+                        prize.to_sum(),
+                        "summing omitted Steiner forest prizes",
+                    )?;
+                }
+            }
+            let omitted_term = W::checked_mul_sum(
+                self.beta.to_sum(),
+                omitted_prizes,
+                "multiplying omitted prizes by beta",
+            )?;
+
+            let mut edge_term = W::Sum::zero();
+            for (i, cost) in self.edge_costs.iter().enumerate() {
+                if edges[i] {
+                    edge_term = W::checked_add_to_sum(
+                        edge_term,
+                        cost.to_sum(),
+                        "summing Steiner forest edge costs",
+                    )?;
+                }
             }
-        }
-        let omitted_term = self.beta.to_sum() * omitted_prizes;
 
-        let mut edge_term = W::Sum::zero();
-        for (i, cost) in self.edge_costs.iter().enumerate() {
-            if config[n + i] == 1 {
-                edge_term += cost.to_sum();
+            // Represent `kappa` in `W::Sum` by summing `omega` `kappa` times.
+            let omega_sum = self.omega.to_sum();
+            let mut kappa_sum = W::Sum::zero();
+            for _ in 0..kappa {
+                kappa_sum = W::checked_add_to_sum(
+                    kappa_sum,
+                    omega_sum.clone(),
+                    "multiplying Steiner forest component penalty",
+                )?;
             }
-        }
 
-        // Represent `kappa` in `W::Sum` by summing `omega` `kappa` times.
-        // `NumericSize` does not require a `From<usize>` conversion, so we
-        // accumulate additively rather than casting.
-        let omega_sum = self.omega.to_sum();
-        let mut kappa_sum = W::Sum::zero();
-        for _ in 0..kappa {
-            kappa_sum += omega_sum.clone();
-        }
+            let mut total = W::Sum::zero();
+            total = W::checked_add_to_sum(
+                total,
+                omitted_term,
+                "summing Steiner forest objective terms",
+            )?;
+            total =
+                W::checked_add_to_sum(total, edge_term, "summing Steiner forest objective terms")?;
+            total =
+                W::checked_add_to_sum(total, kappa_sum, "summing Steiner forest objective terms")?;
+            Min(Some(total))
+        })
+    }
+}
 
-        let mut total = W::Sum::zero();
-        total += omitted_term;
-        total += edge_term;
-        total += kappa_sum;
-        Min(Some(total))
+impl<G, W> crate::solvers::BruteForceProblem for PrizeCollectingSteinerForest<G, W>
+where
+    G: Graph + VariantParam,
+    W: WeightElement + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices() + self.graph.num_edges()]
     }
 }
 
@@ -255,23 +398,23 @@ where
 /// tree components `kappa(F)` among the selected vertices. Feasible means every
 /// selected edge is incident only to selected vertices and the selected
 /// subgraph is acyclic. Returns `None` for any infeasible configuration.
-fn forest_components<G: Graph>(graph: &G, config: &[usize]) -> Option<usize> {
+fn forest_components<G: Graph>(
+    graph: &G,
+    selected_vertices: &[bool],
+    selected_edges: &[bool],
+) -> Option<usize> {
     let n = graph.num_vertices();
     let m = graph.num_edges();
-    if config.len() != n + m {
+    if selected_vertices.len() != n || selected_edges.len() != m {
         return None;
     }
     let edges = graph.edges();
     let mut adj: Vec<Vec<(usize, usize)>> = vec![Vec::new(); n];
     for (i, &(u, v)) in edges.iter().enumerate() {
-        let y_e = config[n + i];
-        if y_e == 0 {
+        if !selected_edges[i] {
             continue;
         }
-        if y_e != 1 {
-            return None;
-        }
-        if config[u] != 1 || config[v] != 1 {
+        if !selected_vertices[u] || !selected_vertices[v] {
             return None;
         }
         adj[u].push((v, i));
@@ -280,7 +423,7 @@ fn forest_components<G: Graph>(graph: &G, config: &[usize]) -> Option<usize> {
     let mut visited = vec![false; n];
     let mut kappa: usize = 0;
     for start in 0..n {
-        if config[start] != 1 || visited[start] {
+        if !selected_vertices[start] || visited[start] {
             continue;
         }
         kappa += 1;
@@ -306,8 +449,13 @@ fn forest_components<G: Graph>(graph: &G, config: &[usize]) -> Option<usize> {
 }
 
 crate::declare_variants! {
-    default PrizeCollectingSteinerForest<SimpleGraph, i32> => "2^(num_vertices + num_edges)",
-    PrizeCollectingSteinerForest<SimpleGraph, f64> => "2^(num_vertices + num_edges)",
+    default PrizeCollectingSteinerForest<SimpleGraph, i64> => "2^(num_vertices + num_edges)" create PrizeCollectingSteinerForestI64CreateSpec,
+    PrizeCollectingSteinerForest<SimpleGraph, f64> => "2^(num_vertices + num_edges)" create PrizeCollectingSteinerForestF64CreateSpec,
+}
+
+crate::register_brute_force! {
+    PrizeCollectingSteinerForest<SimpleGraph, i64> decode |problem: &PrizeCollectingSteinerForest<SimpleGraph, i64>, indices: Vec<usize>| { let split = problem.num_vertices(); (crate::config::config_to_bits(&indices[..split]), crate::config::config_to_bits(&indices[split..])) },
+    PrizeCollectingSteinerForest<SimpleGraph, f64> decode |problem: &PrizeCollectingSteinerForest<SimpleGraph, f64>, indices: Vec<usize>| { let split = problem.num_vertices(); (crate::config::config_to_bits(&indices[..split]), crate::config::config_to_bits(&indices[split..])) },
 }
 
 #[cfg(feature = "example-db")]
@@ -317,16 +465,18 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     // Optimum: V_F = {0,1,2}, E_F = {(0,1)} (two components {0,1} and {2}),
     // objective = 0 + 1 + 2*2 = 5.
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "prize_collecting_steiner_forest_simplegraph_i32",
-        instance: Box::new(PrizeCollectingSteinerForest::<SimpleGraph, i32>::new(
-            SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-            vec![5, 2, 5],
-            vec![1, 6],
-            1,
-            2,
-        )),
-        // 3 vertex bits + 2 edge bits = 5-bit configuration.
-        optimal_config: vec![1, 1, 1, 1, 0],
+        id: "prize_collecting_steiner_forest_simplegraph",
+        instance: Box::new(
+            PrizeCollectingSteinerForest::<SimpleGraph, i64>::new(
+                SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
+                vec![5, 2, 5],
+                vec![1, 6],
+                1,
+                2,
+            )
+            .unwrap(),
+        ),
+        optimal_config: serde_json::json!((vec![true, true, true], vec![true, false])),
         optimal_value: serde_json::json!(5),
     }]
 }
diff --git a/src/models/graph/rooted_tree_arrangement.rs b/src/models/graph/rooted_tree_arrangement.rs
index 6fc20b366..316e28187 100644
--- a/src/models/graph/rooted_tree_arrangement.rs
+++ b/src/models/graph/rooted_tree_arrangement.rs
@@ -18,11 +18,12 @@ inventory::submit! {
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a rooted-tree embedding of a graph with bounded total edge stretch",
         fields: &[
             FieldInfo { name: "graph", type_name: "G", description: "The undirected graph G=(V,E)" },
-            FieldInfo { name: "bound", type_name: "usize", description: "Upper bound K on total tree stretch" },
+            FieldInfo { name: "bound", type_name: "i64", description: "Upper bound K on total tree stretch" },
         ],
     }
 }
@@ -31,7 +32,19 @@ inventory::submit! {
 #[serde(bound(deserialize = "G: serde::Deserialize<'de>"))]
 pub struct RootedTreeArrangement<G> {
     graph: G,
-    bound: usize,
+    bound: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct RootedTreeArrangementRandomSpec {
+    /// Number of graph vertices.
+    num_vertices: usize,
+    /// Independent edge probability (default: 0.5).
+    edge_prob: Option<f64>,
+    /// Seed for reproducible generation.
+    seed: Option<i64>,
+    /// Maximum total edge stretch (defaults to a graph-size upper bound).
+    bound: Option<i64>,
 }
 
 #[derive(Debug, Clone)]
@@ -40,7 +53,7 @@ struct TreeInfo {
 }
 
 impl<G: Graph> RootedTreeArrangement<G> {
-    pub fn new(graph: G, bound: usize) -> Self {
+    pub fn new(graph: G, bound: i64) -> Self {
         Self { graph, bound }
     }
 
@@ -48,7 +61,7 @@ impl<G: Graph> RootedTreeArrangement<G> {
         &self.graph
     }
 
-    pub fn bound(&self) -> usize {
+    pub fn bound(&self) -> i64 {
         self.bound
     }
 
@@ -60,33 +73,53 @@ impl<G: Graph> RootedTreeArrangement<G> {
         self.graph.num_edges()
     }
 
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        matches!(self.total_edge_stretch(config), Some(stretch) if stretch <= self.bound)
+    pub fn is_valid_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(matches!(self.total_edge_stretch(config)?, Some(stretch) if stretch <= self.bound))
     }
 
-    pub fn total_edge_stretch(&self, config: &[usize]) -> Option<usize> {
+    pub fn total_edge_stretch(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         let n = self.graph.num_vertices();
         if n == 0 {
-            return config.is_empty().then_some(0);
+            return Ok(config.is_empty().then_some(0));
         }
 
-        let (parent, mapping) = self.split_config(config)?;
-        let tree = analyze_parent_array(parent)?;
+        let Some((parent, mapping)) = self.split_config(config) else {
+            return Ok(None);
+        };
+        let Some(tree) = analyze_parent_array(parent) else {
+            return Ok(None);
+        };
         if !is_valid_permutation(mapping) {
-            return None;
+            return Ok(None);
         }
 
-        let mut total = 0usize;
+        let mut total = 0_i64;
         for (u, v) in self.graph.edges() {
             let tree_u = mapping[u];
             let tree_v = mapping[v];
             if !are_ancestor_comparable(parent, tree_u, tree_v) {
-                return None;
+                return Ok(None);
             }
-            total += tree.depth[tree_u].abs_diff(tree.depth[tree_v]);
+            let stretch =
+                i64::try_from(tree.depth[tree_u].abs_diff(tree.depth[tree_v])).map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting a rooted-tree edge stretch to i64".to_string(),
+                    )
+                })?;
+            total = total.checked_add(stretch).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing rooted-tree arrangement edge stretches".to_string(),
+                )
+            })?;
         }
 
-        Some(total)
+        Ok(Some(total))
     }
 
     fn split_config<'a>(&self, config: &'a [usize]) -> Option<(&'a [usize], &'a [usize])> {
@@ -100,19 +133,36 @@ where
     G: Graph + VariantParam,
 {
     const NAME: &'static str = "RootedTreeArrangement";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
         let n = self.graph.num_vertices();
-        vec![n; 2 * n]
+        if config.len() != 2 * n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "tree-arrangement representation length does not match the graph".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_valid_solution(config))
+impl<G> crate::solvers::BruteForceProblem for RootedTreeArrangement<G>
+where
+    G: Graph + VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.graph.num_vertices();
+        vec![n; 2 * n]
     }
 }
 
@@ -204,8 +254,46 @@ fn are_ancestor_comparable(parent: &[usize], u: usize, v: usize) -> bool {
     is_ancestor(parent, u, v) || is_ancestor(parent, v, u)
 }
 
+crate::impl_random_generate!(
+    RootedTreeArrangement<SimpleGraph>,
+    RootedTreeArrangementRandomSpec,
+    |spec| {
+        let graph = crate::random::SimpleGraphRandomSpec {
+            num_vertices: spec.num_vertices,
+            edge_prob: spec.edge_prob,
+            seed: spec.seed,
+        }
+        .graph()?;
+        let bound = match spec.bound {
+            Some(bound) => bound,
+            None => {
+                let max_depth = if spec.num_vertices == 0 {
+                    0
+                } else {
+                    spec.num_vertices - 1
+                };
+                let max_stretch = max_depth.checked_mul(graph.num_edges()).ok_or_else(|| {
+                    crate::registry::ConstructionError::IntegerOverflow(
+                        "default rooted-tree arrangement bound overflows usize".into(),
+                    )
+                })?;
+                i64::try_from(max_stretch).map_err(|_| {
+                    crate::registry::ConstructionError::IntegerOverflow(
+                        "default rooted-tree arrangement bound does not fit i64".into(),
+                    )
+                })?
+            }
+        };
+        Ok(RootedTreeArrangement::new(graph, bound))
+    }
+);
+
 crate::declare_variants! {
-    default RootedTreeArrangement<SimpleGraph> => "2^num_vertices",
+    default RootedTreeArrangement<SimpleGraph> => "2^num_vertices" random,
+}
+
+crate::register_brute_force! {
+    RootedTreeArrangement<SimpleGraph>,
 }
 
 #[cfg(feature = "example-db")]
@@ -216,7 +304,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (2, 3)]),
             5,
         )),
-        optimal_config: vec![0, 0, 1, 2, 0, 1, 2, 3],
+        optimal_config: serde_json::json!(vec![0, 0, 1, 2, 0, 1, 2, 3]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/rural_postman.rs b/src/models/graph/rural_postman.rs
index 164eccdc0..2561b04e1 100644
--- a/src/models/graph/rural_postman.rs
+++ b/src/models/graph/rural_postman.rs
@@ -3,7 +3,7 @@
 //! The Rural Postman problem asks for a minimum-cost circuit in a graph
 //! that includes each edge in a required subset E'.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
@@ -18,15 +18,12 @@ inventory::submit! {
         aliases: &["RPP"],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a minimum-cost circuit covering all required edges (Rural Postman Problem)",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge lengths l(e) for each e in E" },
-            FieldInfo { name: "required_edges", type_name: "Vec<usize>", description: "Edge indices of the required subset E' ⊆ E" },
-        ],
+        fields: RuralPostmanCreateSpec::FIELDS,
     }
 }
 
@@ -54,7 +51,7 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`)
-/// * `W` - The weight type for edge lengths (e.g., `i32`, `f64`)
+/// * `W` - The weight type for edge lengths (e.g., `i64`, `f64`)
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct RuralPostman<G, W: WeightElement> {
     /// The underlying graph.
@@ -65,6 +62,75 @@ pub struct RuralPostman<G, W: WeightElement> {
     required_edges: Vec<usize>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct RuralPostmanCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    edge_weights: Option<Vec<i64>>,
+    #[create(codec = "comma-separated")]
+    required_edges: Vec<usize>,
+}
+
+impl TryFrom<RuralPostmanCreateSpec> for RuralPostman<SimpleGraph, i64> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: RuralPostmanCreateSpec) -> Result<Self, Self::Error> {
+        let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+        let edge_lengths = spec
+            .edge_weights
+            .unwrap_or_else(|| vec![1; graph.num_edges()]);
+        if edge_lengths.len() != graph.num_edges() {
+            return Err(format!(
+                "edge_weights has length {}, expected {}",
+                edge_lengths.len(),
+                graph.num_edges()
+            )
+            .into());
+        }
+        if let Some(&edge) = spec
+            .required_edges
+            .iter()
+            .find(|&&edge| edge >= graph.num_edges())
+        {
+            return Err(format!("required edge index {edge} is out of bounds").into());
+        }
+        Ok(Self::new(graph, edge_lengths, spec.required_edges))
+    }
+}
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(format!(
+            "num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}"
+        )
+        .into());
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
+}
+
 impl<G: Graph, W: WeightElement> RuralPostman<G, W> {
     /// Create a new RuralPostman problem.
     ///
@@ -142,9 +208,12 @@ impl<G: Graph, W: WeightElement> RuralPostman<G, W> {
     /// Returns `Some(cost)` if valid, `None` otherwise.
     ///
     /// Each `config[i]` is the multiplicity (number of traversals) of edge `i`.
-    pub fn is_valid_solution(&self, config: &[usize]) -> Option<W::Sum> {
+    pub fn is_valid_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<W::Sum>, crate::traits::EvaluationError> {
         if config.len() != self.graph.num_edges() {
-            return None;
+            return Ok(None);
         }
 
         let edges = self.graph.edges();
@@ -153,7 +222,7 @@ impl<G: Graph, W: WeightElement> RuralPostman<G, W> {
         // Check all required edges are traversed at least once
         for &req_idx in &self.required_edges {
             if config[req_idx] == 0 {
-                return None;
+                return Ok(None);
             }
         }
 
@@ -172,16 +241,16 @@ impl<G: Graph, W: WeightElement> RuralPostman<G, W> {
         // No edges used: only valid if no required edges
         if !has_edges {
             if self.required_edges.is_empty() {
-                return Some(W::Sum::zero());
+                return Ok(Some(W::Sum::zero()));
             } else {
-                return None;
+                return Ok(None);
             }
         }
 
         // All vertices must have even degree (Eulerian condition)
         for &d in &degree {
             if d % 2 != 0 {
-                return None;
+                return Ok(None);
             }
         }
 
@@ -204,9 +273,9 @@ impl<G: Graph, W: WeightElement> RuralPostman<G, W> {
             Some(v) => v,
             None => {
                 if self.required_edges.is_empty() {
-                    return Some(W::Sum::zero());
+                    return Ok(Some(W::Sum::zero()));
                 } else {
-                    return None;
+                    return Ok(None);
                 }
             }
         };
@@ -228,7 +297,7 @@ impl<G: Graph, W: WeightElement> RuralPostman<G, W> {
         // All vertices with degree > 0 must be visited
         for v in 0..n {
             if degree[v] > 0 && !visited[v] {
-                return None;
+                return Ok(None);
             }
         }
 
@@ -236,11 +305,15 @@ impl<G: Graph, W: WeightElement> RuralPostman<G, W> {
         let mut total = W::Sum::zero();
         for (idx, &mult) in config.iter().enumerate() {
             for _ in 0..mult {
-                total += self.edge_lengths[idx].to_sum();
+                total = W::checked_add_to_sum(
+                    total,
+                    self.edge_lengths[idx].to_sum(),
+                    "summing rural postman edge lengths",
+                )?;
             }
         }
 
-        Some(total)
+        Ok(Some(total))
     }
 }
 
@@ -250,23 +323,48 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "RuralPostman";
+    type Solution = Vec<usize>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_required_edges", num_required_edges),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![3; self.graph.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-multiplicity vector length does not match the graph".into(),
+            ));
+        }
+        Ok(Min(self.is_valid_solution(config)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        Min(self.is_valid_solution(config))
+impl<G, W> crate::solvers::BruteForceProblem for RuralPostman<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![3; self.graph.num_edges()]
     }
 }
 
 crate::declare_variants! {
-    default RuralPostman<SimpleGraph, i32> => "2^num_vertices * num_vertices^2",
+    default RuralPostman<SimpleGraph, i64> => "2^num_vertices * num_vertices^2" create RuralPostmanCreateSpec,
+}
+
+crate::register_brute_force! {
+    RuralPostman<SimpleGraph, i64>,
 }
 
 #[cfg(feature = "example-db")]
@@ -294,7 +392,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![1, 1, 1, 1, 1, 1, 2, 2],
             vec![0, 2, 4],
         )),
-        optimal_config: vec![1, 1, 1, 1, 1, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![1, 1, 1, 1, 1, 1, 0, 0]),
         optimal_value: serde_json::json!(6),
     }]
 }
diff --git a/src/models/graph/shortest_weight_constrained_path.rs b/src/models/graph/shortest_weight_constrained_path.rs
index bfc1272b8..0dab498cf 100644
--- a/src/models/graph/shortest_weight_constrained_path.rs
+++ b/src/models/graph/shortest_weight_constrained_path.rs
@@ -4,13 +4,12 @@
 //! source vertex to a target vertex that minimizes total length while keeping
 //! the total weight within a prescribed bound.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
-use crate::topology::{Graph, SimpleGraph};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
+use crate::topology::{is_simple_st_path, Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
 use num_traits::Zero;
 use serde::{Deserialize, Serialize};
-use std::collections::VecDeque;
 
 inventory::submit! {
     ProblemSchemaEntry {
@@ -19,18 +18,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find a simple s-t path minimizing total length subject to a weight budget",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "edge_lengths", type_name: "Vec<W>", description: "Edge lengths l: E -> ZZ_(> 0)" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge weights w: E -> ZZ_(> 0)" },
-            FieldInfo { name: "source_vertex", type_name: "usize", description: "Source vertex s" },
-            FieldInfo { name: "target_vertex", type_name: "usize", description: "Target vertex t" },
-            FieldInfo { name: "weight_bound", type_name: "W::Sum", description: "Upper bound W on total path weight" },
-        ],
+        fields: ShortestWeightConstrainedPathCreateSpec::FIELDS,
     }
 }
 
@@ -57,7 +50,7 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`)
-/// * `N` - The edge length / weight type (e.g., `i32`, `f64`)
+/// * `N` - The edge length / weight type (e.g., `i64`, `f64`)
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ShortestWeightConstrainedPath<G, N: WeightElement> {
     /// The underlying graph.
@@ -74,6 +67,77 @@ pub struct ShortestWeightConstrainedPath<G, N: WeightElement> {
     weight_bound: N::Sum,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct ShortestWeightConstrainedPathCreateSpec {
+    /// The underlying graph G=(V,E).
+    graph: SimpleGraph,
+    /// Positive edge lengths in graph edge order.
+    edge_lengths: Vec<i64>,
+    /// Positive edge weights in graph edge order.
+    edge_weights: Vec<i64>,
+    /// Source vertex s.
+    source_vertex: usize,
+    /// Target vertex t.
+    target_vertex: usize,
+    /// Positive upper bound on total path weight.
+    weight_bound: i64,
+}
+
+impl TryFrom<ShortestWeightConstrainedPathCreateSpec>
+    for ShortestWeightConstrainedPath<SimpleGraph, i64>
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: ShortestWeightConstrainedPathCreateSpec) -> Result<Self, Self::Error> {
+        let edge_count = spec.graph.num_edges();
+        if spec.edge_lengths.len() != edge_count {
+            return Err(format!(
+                "edge_lengths has {} entries, expected {edge_count}",
+                spec.edge_lengths.len()
+            )
+            .into());
+        }
+        if spec.edge_weights.len() != edge_count {
+            return Err(format!(
+                "edge_weights has {} entries, expected {edge_count}",
+                spec.edge_weights.len()
+            )
+            .into());
+        }
+        if spec.edge_lengths.iter().any(|&value| value <= 0) {
+            return Err("edge_lengths must be positive".to_string().into());
+        }
+        if spec.edge_weights.iter().any(|&value| value <= 0) {
+            return Err("edge_weights must be positive".to_string().into());
+        }
+        let vertex_count = spec.graph.num_vertices();
+        if spec.source_vertex >= vertex_count {
+            return Err(format!(
+                "source_vertex {} is outside graph with {vertex_count} vertices",
+                spec.source_vertex
+            )
+            .into());
+        }
+        if spec.target_vertex >= vertex_count {
+            return Err(format!(
+                "target_vertex {} is outside graph with {vertex_count} vertices",
+                spec.target_vertex
+            )
+            .into());
+        }
+        if spec.weight_bound <= 0 {
+            return Err("weight_bound must be positive".to_string().into());
+        }
+        Ok(Self::new(
+            spec.graph,
+            spec.edge_lengths,
+            spec.edge_weights,
+            spec.source_vertex,
+            spec.target_vertex,
+            spec.weight_bound,
+        ))
+    }
+}
+
 impl<G: Graph, N: WeightElement> ShortestWeightConstrainedPath<G, N> {
     fn assert_positive_edge_values(values: &[N], label: &str) {
         let zero = N::Sum::zero();
@@ -208,92 +272,53 @@ impl<G: Graph, N: WeightElement> ShortestWeightConstrainedPath<G, N> {
     ///
     /// Returns `Some(total_length)` for a valid simple s-t path whose total
     /// weight is within the weight bound, or `None` otherwise.
-    pub fn is_valid_solution(&self, config: &[usize]) -> Option<N::Sum> {
-        if config.len() != self.graph.num_edges() || config.iter().any(|&value| value > 1) {
-            return None;
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<Option<N::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Ok(None);
         }
 
         if self.source_vertex == self.target_vertex {
-            if config.contains(&1) {
-                return None;
+            if config.contains(&true) {
+                return Ok(None);
             }
-            return Some(N::Sum::zero());
+            return Ok(Some(N::Sum::zero()));
         }
 
-        let edges = self.graph.edges();
-        let mut degree = vec![0usize; self.graph.num_vertices()];
-        let mut adjacency = vec![Vec::new(); self.graph.num_vertices()];
-        let mut selected_edge_count = 0usize;
         let mut total_length = N::Sum::zero();
         let mut total_weight = N::Sum::zero();
 
         for (idx, &selected) in config.iter().enumerate() {
-            if selected == 0 {
+            if !selected {
                 continue;
             }
-            let (u, v) = edges[idx];
-            degree[u] += 1;
-            degree[v] += 1;
-            adjacency[u].push(v);
-            adjacency[v].push(u);
-            selected_edge_count += 1;
-            total_length += self.edge_lengths[idx].to_sum();
-            total_weight += self.edge_weights[idx].to_sum();
-        }
-
-        if selected_edge_count == 0 {
-            return None;
+            total_length = N::checked_add_to_sum(
+                total_length,
+                self.edge_lengths[idx].to_sum(),
+                "summing constrained path edge lengths",
+            )?;
+            total_weight = N::checked_add_to_sum(
+                total_weight,
+                self.edge_weights[idx].to_sum(),
+                "summing constrained path edge weights",
+            )?;
         }
 
         if total_weight > self.weight_bound.clone() {
-            return None;
-        }
-
-        if degree[self.source_vertex] != 1 || degree[self.target_vertex] != 1 {
-            return None;
+            return Ok(None);
         }
-
-        for (vertex, &vertex_degree) in degree.iter().enumerate() {
-            if vertex == self.source_vertex || vertex == self.target_vertex {
-                continue;
-            }
-            if vertex_degree != 0 && vertex_degree != 2 {
-                return None;
-            }
-        }
-
-        let mut visited = vec![false; self.graph.num_vertices()];
-        let mut queue = VecDeque::new();
-        visited[self.source_vertex] = true;
-        queue.push_back(self.source_vertex);
-
-        while let Some(vertex) = queue.pop_front() {
-            for &neighbor in &adjacency[vertex] {
-                if !visited[neighbor] {
-                    visited[neighbor] = true;
-                    queue.push_back(neighbor);
-                }
-            }
-        }
-
-        if !visited[self.target_vertex] {
-            return None;
-        }
-
-        let used_vertex_count = degree
-            .iter()
-            .filter(|&&vertex_degree| vertex_degree > 0)
-            .count();
-        for (vertex, &vertex_degree) in degree.iter().enumerate() {
-            if vertex_degree > 0 && !visited[vertex] {
-                return None;
-            }
-        }
-
-        if used_vertex_count == selected_edge_count + 1 {
-            Some(total_length)
+        if !is_simple_st_path(
+            self.graph.num_vertices(),
+            &self.graph.edges(),
+            self.source_vertex,
+            self.target_vertex,
+            config,
+        ) {
+            Ok(None)
         } else {
-            None
+            Ok(Some(total_length))
         }
     }
 }
@@ -304,25 +329,42 @@ where
     N: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "ShortestWeightConstrainedPath";
+    type Solution = Vec<bool>;
     type Value = Min<N::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, N]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<N::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
+        }
+        Ok(Min(self.is_valid_solution(config)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<N::Sum> {
-        Min(self.is_valid_solution(config))
+impl<G, N> crate::solvers::BruteForceProblem for ShortestWeightConstrainedPath<G, N>
+where
+    G: Graph + crate::variant::VariantParam,
+    N: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "shortest_weight_constrained_path_simplegraph_i32",
+        id: "shortest_weight_constrained_path_simplegraph",
         instance: Box::new(ShortestWeightConstrainedPath::new(
             SimpleGraph::new(
                 6,
@@ -343,13 +385,19 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             5,
             8,
         )),
-        optimal_config: vec![0, 1, 0, 1, 0, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![
+            false, true, false, true, false, true, false, false
+        ]),
         optimal_value: serde_json::json!(9),
     }]
 }
 
 crate::declare_variants! {
-    default ShortestWeightConstrainedPath<SimpleGraph, i32> => "2^num_edges",
+    default ShortestWeightConstrainedPath<SimpleGraph, i64> => "2^num_edges" create ShortestWeightConstrainedPathCreateSpec,
+}
+
+crate::register_brute_force! {
+    ShortestWeightConstrainedPath<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/spin_glass.rs b/src/models/graph/spin_glass.rs
index 0e86144a5..b99974051 100644
--- a/src/models/graph/spin_glass.rs
+++ b/src/models/graph/spin_glass.rs
@@ -2,10 +2,11 @@
 //!
 //! The Spin Glass problem minimizes the Ising Hamiltonian energy.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{ConstructionError, CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
+use num_traits::{One as _, Zero as _};
 use serde::{Deserialize, Serialize};
 
 inventory::submit! {
@@ -15,15 +16,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32", "f64"]),
+            VariantDimension::new("weight", "i64", &["i64", "f64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Minimize Ising Hamiltonian on a graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The interaction graph" },
-            FieldInfo { name: "couplings", type_name: "Vec<W>", description: "Pairwise couplings J_ij" },
-            FieldInfo { name: "fields", type_name: "Vec<W>", description: "On-site fields h_i" },
-        ],
+        fields: SpinGlassI64CreateSpec::FIELDS,
     }
 }
 
@@ -43,27 +41,27 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`, `KingsSubgraph`, `UnitDiskGraph`)
-/// * `W` - The weight type for couplings (e.g., `i32`, `f64`)
+/// * `W` - The weight type for couplings (e.g., `i64`, `f64`)
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::graph::SpinGlass;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Two spins with antiferromagnetic coupling J_01 = 1
-/// let problem = SpinGlass::<SimpleGraph, f64>::new(2, vec![((0, 1), 1.0)], vec![0.0, 0.0]);
+/// let problem = SpinGlass::<SimpleGraph, f64>::new(2, vec![((0, 1), 1.0)], vec![0.0, 0.0]).unwrap();
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Ground state has opposite spins
 /// for sol in &solutions {
 ///     assert!(sol[0] != sol[1]); // Antiferromagnetic: opposite spins
 /// }
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct SpinGlass<G, W> {
     /// The underlying graph structure.
     graph: G,
@@ -73,27 +71,130 @@ pub struct SpinGlass<G, W> {
     fields: Vec<W>,
 }
 
-impl<W: Clone + Default> SpinGlass<SimpleGraph, W> {
+#[derive(Deserialize)]
+struct SpinGlassData<G, W> {
+    graph: G,
+    couplings: Vec<W>,
+    fields: Vec<W>,
+}
+
+impl<'de, G, W> Deserialize<'de> for SpinGlass<G, W>
+where
+    G: Graph + Deserialize<'de>,
+    W: WeightElement + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let data = SpinGlassData::deserialize(deserializer)?;
+        Self::from_graph(data.graph, data.couplings, data.fields).map_err(serde::de::Error::custom)
+    }
+}
+
+macro_rules! spin_glass_create_spec {
+    ($name:ident, $weight:ty, $one:expr, $zero:expr) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            /// Undirected interaction graph edges.
+            #[create(codec = "edge-list")]
+            graph: Vec<(usize, usize)>,
+            /// Vertex count, needed to preserve isolated spins.
+            num_vertices: Option<usize>,
+            /// Pairwise couplings; defaults to one per edge.
+            #[create(codec = "comma-separated")]
+            couplings: Option<Vec<$weight>>,
+            /// On-site fields; defaults to zero per vertex.
+            #[create(codec = "comma-separated")]
+            fields: Option<Vec<$weight>>,
+        }
+
+        impl TryFrom<$name> for SpinGlass<SimpleGraph, $weight> {
+            type Error = ConstructionError;
+
+            fn try_from(spec: $name) -> Result<Self, Self::Error> {
+                if spec.graph.is_empty() && spec.num_vertices.is_none() {
+                    return Err(ConstructionError::Conversion(
+                        "num_vertices is required for an empty graph".into(),
+                    ));
+                }
+                for (index, &(u, v)) in spec.graph.iter().enumerate() {
+                    if u == v {
+                        return Err(ConstructionError::Conversion(format!(
+                            "graph edge {index} is a self-loop at vertex {u}"
+                        )));
+                    }
+                }
+                let inferred = spec
+                    .graph
+                    .iter()
+                    .flat_map(|&(u, v)| [u, v])
+                    .max()
+                    .map(|vertex| {
+                        vertex.checked_add(1).ok_or_else(|| {
+                            ConstructionError::IntegerOverflow(
+                                "inferring the SpinGlass vertex count".into(),
+                            )
+                        })
+                    })
+                    .transpose()?
+                    .unwrap_or(0);
+                let num_vertices = spec.num_vertices.unwrap_or(inferred);
+                if num_vertices < inferred {
+                    return Err(ConstructionError::Conversion(format!(
+                        "num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}"
+                    )));
+                }
+                let couplings = spec
+                    .couplings
+                    .unwrap_or_else(|| vec![$one; spec.graph.len()]);
+                let fields = spec.fields.unwrap_or_else(|| vec![$zero; num_vertices]);
+                SpinGlass::from_graph(
+                    SimpleGraph::new(num_vertices, spec.graph),
+                    couplings,
+                    fields,
+                )
+            }
+        }
+    };
+}
+
+spin_glass_create_spec!(SpinGlassI64CreateSpec, i64, 1_i64, 0_i64);
+spin_glass_create_spec!(SpinGlassF64CreateSpec, f64, 1.0_f64, 0.0_f64);
+
+impl<W: WeightElement> SpinGlass<SimpleGraph, W> {
     /// Create a new Spin Glass problem.
     ///
     /// # Arguments
     /// * `num_spins` - Number of spin variables
     /// * `interactions` - Coupling terms J_ij as ((i, j), value)
     /// * `fields` - On-site fields h_i
-    pub fn new(num_spins: usize, interactions: Vec<((usize, usize), W)>, fields: Vec<W>) -> Self {
-        assert_eq!(fields.len(), num_spins);
-        let edges: Vec<_> = interactions.iter().map(|((i, j), _)| (*i, *j)).collect();
-        let couplings: Vec<_> = interactions.iter().map(|(_, w)| w.clone()).collect();
-        let graph = SimpleGraph::new(num_spins, edges);
-        Self {
-            graph,
-            couplings,
-            fields,
+    pub fn new(
+        num_spins: usize,
+        interactions: Vec<((usize, usize), W)>,
+        fields: Vec<W>,
+    ) -> Result<Self, ConstructionError> {
+        for (index, &((u, v), _)) in interactions.iter().enumerate() {
+            if u >= num_spins || v >= num_spins {
+                return Err(ConstructionError::Conversion(format!(
+                    "interaction {index} endpoint exceeds num_spins"
+                )));
+            }
         }
+        let edges = interactions.iter().map(|((u, v), _)| (*u, *v)).collect();
+        let couplings = interactions
+            .iter()
+            .map(|(_, coupling)| coupling.clone())
+            .collect();
+        let graph = SimpleGraph::new(num_spins, edges);
+        Self::from_graph(graph, couplings, fields)
     }
 
     /// Create a Spin Glass with no on-site fields.
-    pub fn without_fields(num_spins: usize, interactions: Vec<((usize, usize), W)>) -> Self
+    pub fn without_fields(
+        num_spins: usize,
+        interactions: Vec<((usize, usize), W)>,
+    ) -> Result<Self, ConstructionError>
     where
         W: num_traits::Zero,
     {
@@ -102,40 +203,52 @@ impl<W: Clone + Default> SpinGlass<SimpleGraph, W> {
     }
 }
 
-impl<G: Graph, W: Clone + Default> SpinGlass<G, W> {
+impl<G: Graph, W: WeightElement> SpinGlass<G, W> {
     /// Create a SpinGlass problem from a graph with specified couplings.
     ///
     /// # Arguments
     /// * `graph` - The underlying graph
     /// * `couplings` - Coupling terms (must match graph.num_edges())
     /// * `fields` - On-site fields h_i
-    pub fn from_graph(graph: G, couplings: Vec<W>, fields: Vec<W>) -> Self {
-        assert_eq!(
-            couplings.len(),
-            graph.num_edges(),
-            "couplings length must match num_edges"
-        );
-        assert_eq!(
-            fields.len(),
-            graph.num_vertices(),
-            "fields length must match num_vertices"
-        );
-        Self {
+    pub fn from_graph(
+        graph: G,
+        couplings: Vec<W>,
+        fields: Vec<W>,
+    ) -> Result<Self, ConstructionError> {
+        if couplings.len() != graph.num_edges() {
+            return Err(ConstructionError::Conversion(
+                "couplings length must match num_edges".into(),
+            ));
+        }
+        if fields.len() != graph.num_vertices() {
+            return Err(ConstructionError::Conversion(
+                "fields length must match num_vertices".into(),
+            ));
+        }
+        for (index, coupling) in couplings.iter().enumerate() {
+            coupling.validate_element(&format!("coupling at index {index}"))?;
+        }
+        for (index, field) in fields.iter().enumerate() {
+            field.validate_element(&format!("field at index {index}"))?;
+        }
+        Ok(Self {
             graph,
             couplings,
             fields,
-        }
+        })
     }
 
     /// Create a SpinGlass problem from a graph with no on-site fields.
-    pub fn from_graph_without_fields(graph: G, couplings: Vec<W>) -> Self
+    pub fn from_graph_without_fields(graph: G, couplings: Vec<W>) -> Result<Self, ConstructionError>
     where
         W: num_traits::Zero,
     {
         let fields = vec![W::zero(); graph.num_vertices()];
         Self::from_graph(graph, couplings, fields)
     }
+}
 
+impl<G: Graph, W: Clone + Default> SpinGlass<G, W> {
     /// Get a reference to the underlying graph.
     pub fn graph(&self) -> &G {
         &self.graph
@@ -173,36 +286,70 @@ impl<G: Graph, W: Clone + Default> SpinGlass<G, W> {
         &self.fields
     }
 
-    /// Convert binary config (0,1) to spin config (-1,+1).
-    pub fn config_to_spins(config: &[usize]) -> Vec<i32> {
-        config.iter().map(|&x| 2 * x as i32 - 1).collect()
+    /// Convert a binary configuration to implementation-local spin signs.
+    pub fn config_to_spins(config: &[usize]) -> Result<Vec<i8>, crate::traits::EvaluationError> {
+        config
+            .iter()
+            .map(|&value| match value {
+                0 => Ok(-1),
+                1 => Ok(1),
+                _ => Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    format!("binary spin configuration value must be 0 or 1, got {value}"),
+                )),
+            })
+            .collect()
     }
 }
 
 impl<G, W> SpinGlass<G, W>
 where
     G: Graph,
-    W: Clone + num_traits::Zero + std::ops::AddAssign + std::ops::Mul<Output = W> + From<i32>,
+    W: WeightElement,
 {
     /// Compute the Hamiltonian energy for a spin configuration.
-    pub fn compute_energy(&self, spins: &[i32]) -> W {
-        let mut energy = W::zero();
+    pub fn compute_energy(&self, spins: &[i8]) -> Result<W::Sum, crate::traits::EvaluationError> {
+        if spins.len() != self.graph.num_vertices() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                format!(
+                    "expected {} spin values, got {}",
+                    self.graph.num_vertices(),
+                    spins.len()
+                ),
+            ));
+        }
+        let spin_sign = |spin| match spin {
+            1 => Ok(W::Sum::one()),
+            -1 => Ok(W::Sum::zero() - W::Sum::one()),
+            value => Err(crate::traits::EvaluationError::InvalidConfiguration(
+                format!("spin value must be -1 or 1, got {value}"),
+            )),
+        };
+        let mut energy = W::Sum::zero();
 
         // Interaction terms: sum J_ij * s_i * s_j
         for ((i, j), j_val) in self.graph.edges().iter().zip(self.couplings.iter()) {
-            let s_i = spins.get(*i).copied().unwrap_or(1);
-            let s_j = spins.get(*j).copied().unwrap_or(1);
-            let product: i32 = s_i * s_j;
-            energy += j_val.clone() * W::from(product);
+            let s_i = spins[*i];
+            let s_j = spins[*j];
+            let product = s_i * s_j;
+            let term = W::checked_mul_sum(
+                j_val.to_sum(),
+                spin_sign(product)?,
+                "multiplying a SpinGlass coupling by its spin sign",
+            )?;
+            energy = W::checked_add_to_sum(energy, term, "summing SpinGlass interaction energy")?;
         }
 
         // On-site terms: sum h_i * s_i
         for (i, h_val) in self.fields.iter().enumerate() {
-            let s_i = spins.get(i).copied().unwrap_or(1);
-            energy += h_val.clone() * W::from(s_i);
+            let term = W::checked_mul_sum(
+                h_val.to_sum(),
+                spin_sign(spins[i])?,
+                "multiplying a SpinGlass field by its spin sign",
+            )?;
+            energy = W::checked_add_to_sum(energy, term, "summing SpinGlass field energy")?;
         }
 
-        energy
+        Ok(energy)
     }
 }
 
@@ -212,23 +359,23 @@ where
     W: WeightElement
         + crate::variant::VariantParam
         + PartialOrd
-        + num_traits::Num
         + num_traits::Zero
-        + num_traits::Bounded
-        + std::ops::AddAssign
-        + std::ops::Mul<Output = W>
-        + From<i32>,
+        + num_traits::Bounded,
 {
     const NAME: &'static str = "SpinGlass";
+    type Solution = Vec<i8>;
     type Value = Min<W::Sum>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_vertices()]
-    }
+    crate::problem_parameters![
+        ("num_interactions", num_interactions),
+        ("num_spins", num_spins),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        let spins = Self::config_to_spins(config);
-        Min(Some(self.compute_energy(&spins).to_sum()))
+    fn evaluate(
+        &self,
+        spins: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        Ok(Min(Some(self.compute_energy(spins)?)))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -236,28 +383,60 @@ where
     }
 }
 
+impl<G, W> crate::solvers::BruteForceProblem for SpinGlass<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement
+        + crate::variant::VariantParam
+        + PartialOrd
+        + num_traits::Zero
+        + num_traits::Bounded,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_vertices()]
+    }
+}
+
+crate::impl_random_generate!(SpinGlass<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    let graph = spec.graph()?;
+    let num_edges = graph.num_edges();
+    SpinGlass::from_graph(
+        graph,
+        vec![1; num_edges],
+        vec![0; spec.num_vertices],
+    )
+});
+
 crate::declare_variants! {
-    default SpinGlass<SimpleGraph, i32> => "2^num_spins",
-    SpinGlass<SimpleGraph, f64> => "2^num_spins",
+    default SpinGlass<SimpleGraph, i64> => "2^num_spins" create SpinGlassI64CreateSpec random,
+    SpinGlass<SimpleGraph, f64> => "2^num_spins" create SpinGlassF64CreateSpec,
+}
+
+crate::register_brute_force! {
+    SpinGlass<SimpleGraph, i64> decode |_, indices: Vec<usize>| SpinGlass::<SimpleGraph, i64>::config_to_spins(&indices).expect("enumerated spin bits are valid"),
+    SpinGlass<SimpleGraph, f64> decode |_, indices: Vec<usize>| SpinGlass::<SimpleGraph, f64>::config_to_spins(&indices).expect("enumerated spin bits are valid"),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "spin_glass_simplegraph_i32",
-        instance: Box::new(SpinGlass::<SimpleGraph, i32>::without_fields(
-            5,
-            vec![
-                ((0, 1), 1),
-                ((1, 2), 1),
-                ((3, 4), 1),
-                ((0, 3), 1),
-                ((1, 3), 1),
-                ((1, 4), 1),
-                ((2, 4), 1),
-            ],
-        )),
-        optimal_config: vec![1, 0, 1, 1, 0],
+        id: "spin_glass_simplegraph",
+        instance: Box::new(
+            SpinGlass::<SimpleGraph, i64>::without_fields(
+                5,
+                vec![
+                    ((0, 1), 1),
+                    ((1, 2), 1),
+                    ((3, 4), 1),
+                    ((0, 3), 1),
+                    ((1, 3), 1),
+                    ((1, 4), 1),
+                    ((2, 4), 1),
+                ],
+            )
+            .unwrap(),
+        ),
+        optimal_config: serde_json::json!(vec![1, -1, 1, 1, -1]),
         optimal_value: serde_json::json!(-3),
     }]
 }
diff --git a/src/models/graph/steiner_tree.rs b/src/models/graph/steiner_tree.rs
index b58f8c331..6f819ecae 100644
--- a/src/models/graph/steiner_tree.rs
+++ b/src/models/graph/steiner_tree.rs
@@ -9,7 +9,7 @@ use num_traits::Zero;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    registry::{FieldInfo, ProblemSchemaEntry, VariantDimension},
+    registry::{CreateSpec, ProblemSchemaEntry, VariantDimension},
     topology::{Graph, SimpleGraph},
     traits::Problem,
     types::{Min, One, WeightElement},
@@ -22,15 +22,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["One", "i32"]),
+            VariantDimension::new("weight", "i64", &["One", "i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum weight tree connecting terminal vertices",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge weights w: E -> R" },
-            FieldInfo { name: "terminals", type_name: "Vec<usize>", description: "Terminal vertices T that must be connected" },
-        ],
+        fields: SteinerTreeCreateSpec::<i64>::FIELDS,
     }
 }
 
@@ -53,8 +50,8 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`)
-/// * `W` - The weight type for edges (e.g., `i32`, `f64`)
-#[derive(Debug, Clone, Serialize, Deserialize)]
+/// * `W` - The weight type for edges (e.g., `i64`, `f64`)
+#[derive(Debug, Clone, Serialize)]
 pub struct SteinerTree<G, W> {
     /// The underlying graph.
     graph: G,
@@ -64,38 +61,81 @@ pub struct SteinerTree<G, W> {
     terminals: Vec<usize>,
 }
 
+impl<'de, G, W> Deserialize<'de> for SteinerTree<G, W>
+where
+    G: Graph + Deserialize<'de>,
+    W: Clone + Default + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Fields<G, W> {
+            graph: G,
+            edge_weights: Vec<W>,
+            terminals: Vec<usize>,
+        }
+
+        let fields = Fields::deserialize(deserializer)?;
+        Self::try_new(fields.graph, fields.edge_weights, fields.terminals)
+            .map_err(serde::de::Error::custom)
+    }
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SteinerTreeCreateSpec<W> {
+    /// The underlying graph G=(V,E).
+    graph: SimpleGraph,
+    /// Edge weights w: E -> R.
+    edge_weights: Vec<W>,
+    /// Terminal vertices T that must be connected.
+    terminals: Vec<usize>,
+}
+
+impl<W: Clone + Default> TryFrom<SteinerTreeCreateSpec<W>> for SteinerTree<SimpleGraph, W> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: SteinerTreeCreateSpec<W>) -> Result<Self, Self::Error> {
+        Self::try_new(spec.graph, spec.edge_weights, spec.terminals).map_err(Into::into)
+    }
+}
+
 impl<G: Graph, W: Clone + Default> SteinerTree<G, W> {
-    /// Create a SteinerTree problem from a graph, edge weights, and terminals.
-    pub fn new(graph: G, edge_weights: Vec<W>, terminals: Vec<usize>) -> Self {
-        assert_eq!(
-            edge_weights.len(),
-            graph.num_edges(),
-            "edge_weights length must match num_edges"
-        );
-        let n = graph.num_vertices();
+    fn try_new(graph: G, edge_weights: Vec<W>, terminals: Vec<usize>) -> Result<Self, String> {
+        if edge_weights.len() != graph.num_edges() {
+            return Err("edge_weights length must match num_edges".into());
+        }
+        if terminals.len() < 2 {
+            return Err("at least 2 terminals required".into());
+        }
         let distinct_terminals: BTreeSet<_> = terminals.iter().copied().collect();
-        assert_eq!(
-            distinct_terminals.len(),
-            terminals.len(),
-            "terminals must be distinct"
-        );
-        for &t in &terminals {
-            assert!(t < n, "terminal {t} out of range (num_vertices = {n})");
+        if distinct_terminals.len() != terminals.len() {
+            return Err("terminals must be distinct".into());
+        }
+        let n = graph.num_vertices();
+        if let Some(&terminal) = terminals.iter().find(|&&terminal| terminal >= n) {
+            return Err(format!(
+                "terminal {terminal} out of range (num_vertices = {n})"
+            ));
         }
-        assert!(terminals.len() >= 2, "at least 2 terminals required");
-        Self {
+        Ok(Self {
             graph,
             edge_weights,
             terminals,
-        }
+        })
+    }
+
+    /// Create a SteinerTree problem from a graph, edge weights, and terminals.
+    pub fn new(graph: G, edge_weights: Vec<W>, terminals: Vec<usize>) -> Self {
+        Self::try_new(graph, edge_weights, terminals).unwrap_or_else(|error| panic!("{error}"))
     }
 
     /// Create a SteinerTree problem with unit edge weights.
     pub fn unit_weights(graph: G, terminals: Vec<usize>) -> Self
     where
-        W: From<i32>,
+        W: WeightElement,
     {
-        let edge_weights = vec![W::from(1); graph.num_edges()];
+        let edge_weights = vec![W::unit(); graph.num_edges()];
         Self::new(graph, edge_weights, terminals)
     }
 
@@ -134,7 +174,7 @@ impl<G: Graph, W: Clone + Default> SteinerTree<G, W> {
     }
 
     /// Check if a configuration is a valid Steiner tree.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_valid_steiner_tree(&self.graph, &self.terminals, config)
     }
 }
@@ -159,7 +199,7 @@ impl<G: Graph, W: WeightElement> SteinerTree<G, W> {
 /// Check if a configuration forms a valid Steiner tree:
 /// 1. Selected edges form a connected subgraph containing all terminals
 /// 2. Selected edges are acyclic (tree property)
-fn is_valid_steiner_tree<G: Graph>(graph: &G, terminals: &[usize], config: &[usize]) -> bool {
+fn is_valid_steiner_tree<G: Graph>(graph: &G, terminals: &[usize], config: &[bool]) -> bool {
     let n = graph.num_vertices();
     let edges = graph.edges();
     if config.len() != edges.len() {
@@ -171,7 +211,7 @@ fn is_valid_steiner_tree<G: Graph>(graph: &G, terminals: &[usize], config: &[usi
     let mut selected_count = 0usize;
     let mut involved = vec![false; n];
     for (idx, &sel) in config.iter().enumerate() {
-        if sel == 1 {
+        if sel {
             let (u, v) = edges[idx];
             adj[u].push(v);
             adj[v].push(u);
@@ -221,41 +261,104 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "SteinerTree";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_terminals", num_terminals),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        if !is_valid_steiner_tree(&self.graph, &self.terminals, config) {
-            return Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (idx, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                if let Some(w) = self.edge_weights.get(idx) {
-                    total += w.to_sum();
+        Ok({
+            if !is_valid_steiner_tree(&self.graph, &self.terminals, config) {
+                return Ok(Min(None));
+            }
+            let mut total = W::Sum::zero();
+            for (idx, &selected) in config.iter().enumerate() {
+                if selected {
+                    if let Some(w) = self.edge_weights.get(idx) {
+                        total = W::checked_add_to_sum(
+                            total,
+                            w.to_sum(),
+                            "summing Steiner tree edge weights",
+                        )?;
+                    }
                 }
             }
-        }
-        Min(Some(total))
+            Min(Some(total))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for SteinerTree<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
+    }
+}
+
+crate::impl_random_generate!(SteinerTree<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    if spec.num_vertices < 2 {
+        return Err("num_vertices must be at least 2".to_string().into());
+    }
+    let mut state = crate::random::lcg_init(crate::random::seed_to_u64(spec.seed)?);
+    let graph = spec.graph()?;
+    for _ in 0..spec.num_vertices * spec.num_vertices {
+        crate::random::lcg_step(&mut state);
+    }
+    let weights = (0..graph.num_edges()).map(|_| (crate::random::lcg_step(&mut state) * 9.0) as i64 + 1).collect();
+    let count = std::cmp::max(2, spec.num_vertices * 2 / 5);
+    let terminals = crate::random::lcg_choose(&mut state, spec.num_vertices, count)
+        .map_err(|error| error.to_string())?;
+    Ok(SteinerTree::new(graph, weights, terminals))
+});
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SteinerTreeOneCreateSpec {
+    /// The underlying graph.
+    graph: SimpleGraph,
+    terminals: Vec<usize>,
+}
+
+impl TryFrom<SteinerTreeOneCreateSpec> for SteinerTree<SimpleGraph, One> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: SteinerTreeOneCreateSpec) -> Result<Self, Self::Error> {
+        let weights = vec![One; spec.graph.num_edges()];
+        Self::try_new(spec.graph, weights, spec.terminals).map_err(Into::into)
     }
 }
 
 crate::declare_variants! {
-    default SteinerTree<SimpleGraph, i32> => "3^num_terminals * num_vertices + 2^num_terminals * num_vertices^2",
-    SteinerTree<SimpleGraph, One> => "3^num_terminals * num_vertices + 2^num_terminals * num_vertices^2",
+    default SteinerTree<SimpleGraph, i64> => "3^num_terminals * num_vertices + 2^num_terminals * num_vertices^2" create SteinerTreeCreateSpec<i64> random,
+    SteinerTree<SimpleGraph, One> => "3^num_terminals * num_vertices + 2^num_terminals * num_vertices^2" create SteinerTreeOneCreateSpec,
+}
+
+crate::register_brute_force! {
+    SteinerTree<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    SteinerTree<SimpleGraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "steiner_tree_simplegraph_i32",
+        id: "steiner_tree_simplegraph",
         instance: Box::new(SteinerTree::new(
             SimpleGraph::new(
                 5,
@@ -264,7 +367,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![2, 5, 2, 1, 5, 6, 1],
             vec![0, 2, 4],
         )),
-        optimal_config: vec![1, 0, 1, 1, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![true, false, true, true, false, false, true]),
         optimal_value: serde_json::json!(6),
     }]
 }
diff --git a/src/models/graph/steiner_tree_in_graphs.rs b/src/models/graph/steiner_tree_in_graphs.rs
index 9a191078c..fe7e42f5d 100644
--- a/src/models/graph/steiner_tree_in_graphs.rs
+++ b/src/models/graph/steiner_tree_in_graphs.rs
@@ -3,7 +3,7 @@
 //! The Steiner Tree problem asks for a minimum-weight subtree of a graph
 //! that connects all terminal vertices.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, One, WeightElement};
@@ -17,15 +17,12 @@ inventory::submit! {
         aliases: &[],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["One", "i32"]),
+            VariantDimension::new("weight", "i64", &["One", "i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum weight subtree connecting all terminal vertices",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "terminals", type_name: "Vec<usize>", description: "Required terminal vertices R ⊆ V" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge weights w: E -> R" },
-        ],
+        fields: SteinerTreeInGraphsCreateSpec::<i64>::FIELDS,
     }
 }
 
@@ -49,23 +46,23 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`)
-/// * `W` - The weight type for edges (e.g., `i32`, `f64`)
+/// * `W` - The weight type for edges (e.g., `i64`, `f64`)
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::graph::SteinerTreeInGraphs;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Path graph 0-1-2-3, terminals {0, 3}
 /// let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
 /// let problem = SteinerTreeInGraphs::new(graph, vec![0, 3], vec![1, 1, 1]);
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem).unwrap();
+/// let solution = solver.solve(&problem).unwrap().unwrap();
 /// // Optimal: select all 3 edges (the only path from 0 to 3)
-/// assert_eq!(solution, vec![1, 1, 1]);
+/// assert_eq!(solution, vec![true, true, true]);
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SteinerTreeInGraphs<G, W> {
@@ -77,6 +74,43 @@ pub struct SteinerTreeInGraphs<G, W> {
     edge_weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SteinerTreeInGraphsCreateSpec<W> {
+    /// The underlying graph.
+    graph: SimpleGraph,
+    /// Required terminal vertices.
+    terminals: Vec<usize>,
+    /// Edge weights; defaults to one per edge.
+    edge_weights: Option<Vec<W>>,
+}
+impl<W> TryFrom<SteinerTreeInGraphsCreateSpec<W>> for SteinerTreeInGraphs<SimpleGraph, W>
+where
+    W: WeightElement,
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: SteinerTreeInGraphsCreateSpec<W>) -> Result<Self, Self::Error> {
+        let count = spec.graph.num_edges();
+        let edge_weights = spec
+            .edge_weights
+            .unwrap_or_else(|| (0..count).map(|_| W::unit()).collect());
+        if edge_weights.len() != count {
+            return Err(format!(
+                "edge_weights has {} entries, expected {count}",
+                edge_weights.len()
+            )
+            .into());
+        }
+        if let Some(&terminal) = spec
+            .terminals
+            .iter()
+            .find(|&&t| t >= spec.graph.num_vertices())
+        {
+            return Err(format!("terminal {terminal} is outside the graph").into());
+        }
+        Ok(Self::new(spec.graph, spec.terminals, edge_weights))
+    }
+}
+
 impl<G: Graph, W: Clone + Default> SteinerTreeInGraphs<G, W> {
     /// Create a SteinerTreeInGraphs problem from a graph, terminals, and edge weights.
     ///
@@ -175,33 +209,57 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "SteinerTreeInGraphs";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_terminals", num_terminals),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        if config.len() != self.graph.num_edges() {
-            return Min(None);
-        }
-        let selected: Vec<bool> = config.iter().map(|&s| s == 1).collect();
-        if !is_steiner_tree(&self.graph, &self.terminals, &selected) {
-            return Min(None);
-        }
-        let mut total = W::Sum::zero();
-        for (idx, &sel) in config.iter().enumerate() {
-            if sel == 1 {
-                if let Some(w) = self.edge_weights.get(idx) {
-                    total += w.to_sum();
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.graph.num_edges() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "edge-selection length does not match the graph".into(),
+                ));
+            }
+            let selected = config;
+            if !is_steiner_tree(&self.graph, &self.terminals, selected) {
+                return Ok(Min(None));
+            }
+            let mut total = W::Sum::zero();
+            for (idx, &sel) in config.iter().enumerate() {
+                if sel {
+                    if let Some(w) = self.edge_weights.get(idx) {
+                        total = W::checked_add_to_sum(
+                            total,
+                            w.to_sum(),
+                            "summing Steiner tree edge weights",
+                        )?;
+                    }
                 }
             }
-        }
-        Min(Some(total))
+            Min(Some(total))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for SteinerTreeInGraphs<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
 }
 
@@ -273,15 +331,52 @@ pub(crate) fn is_steiner_tree<G: Graph>(graph: &G, terminals: &[usize], selected
     terminals.iter().all(|&t| visited[t])
 }
 
+crate::impl_random_generate!(SteinerTreeInGraphs<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    if spec.num_vertices < 2 {
+        return Err("num_vertices must be at least 2".to_string().into());
+    }
+    let graph = spec.graph()?;
+    let terminals = (0..std::cmp::max(2, spec.num_vertices / 2)).collect();
+    let weights = vec![1; graph.num_edges()];
+    Ok(SteinerTreeInGraphs::new(graph, terminals, weights))
+});
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SteinerTreeInGraphsOneCreateSpec {
+    /// The underlying graph.
+    graph: SimpleGraph,
+    terminals: Vec<usize>,
+}
+
+impl TryFrom<SteinerTreeInGraphsOneCreateSpec> for SteinerTreeInGraphs<SimpleGraph, One> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: SteinerTreeInGraphsOneCreateSpec) -> Result<Self, Self::Error> {
+        let weights = vec![One; spec.graph.num_edges()];
+        if let Some(&terminal) = spec
+            .terminals
+            .iter()
+            .find(|&&t| t >= spec.graph.num_vertices())
+        {
+            return Err(format!("terminal {terminal} is outside the graph").into());
+        }
+        Ok(Self::new(spec.graph, spec.terminals, weights))
+    }
+}
+
 crate::declare_variants! {
-    default SteinerTreeInGraphs<SimpleGraph, i32> => "2^num_terminals * num_vertices^3",
-    SteinerTreeInGraphs<SimpleGraph, One> => "2^num_terminals * num_vertices^3",
+    default SteinerTreeInGraphs<SimpleGraph, i64> => "2^num_terminals * num_vertices^3" create SteinerTreeInGraphsCreateSpec<i64> random,
+    SteinerTreeInGraphs<SimpleGraph, One> => "2^num_terminals * num_vertices^3" create SteinerTreeInGraphsOneCreateSpec,
+}
+
+crate::register_brute_force! {
+    SteinerTreeInGraphs<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    SteinerTreeInGraphs<SimpleGraph, One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "steiner_tree_in_graphs_simplegraph_i32",
+        id: "steiner_tree_in_graphs_simplegraph",
         instance: Box::new(SteinerTreeInGraphs::new(
             SimpleGraph::new(
                 6,
@@ -291,7 +386,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![3, 2, 4, 1, 2, 3, 1],
         )),
         // Optimal: edges {0,2}(w=2), {2,3}(w=1), {2,5}(w=2) = weight 5
-        optimal_config: vec![0, 1, 0, 1, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![false, true, false, true, true, false, false]),
         optimal_value: serde_json::json!(5),
     }]
 }
diff --git a/src/models/graph/strong_connectivity_augmentation.rs b/src/models/graph/strong_connectivity_augmentation.rs
index d22906400..83c2c6cdf 100644
--- a/src/models/graph/strong_connectivity_augmentation.rs
+++ b/src/models/graph/strong_connectivity_augmentation.rs
@@ -18,8 +18,9 @@ inventory::submit! {
         display_name: "Strong Connectivity Augmentation",
         aliases: &[],
         dimensions: &[
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Add a bounded set of weighted candidate arcs to make a digraph strongly connected",
         fields: &[
@@ -49,12 +50,12 @@ impl<W: WeightElement> StrongConnectivityAugmentation<W> {
         graph: DirectedGraph,
         candidate_arcs: Vec<(usize, usize, W)>,
         bound: W::Sum,
-    ) -> Result<Self, String> {
+    ) -> Result<Self, crate::registry::ConstructionError> {
         if !matches!(
             bound.partial_cmp(&W::Sum::zero()),
             Some(Ordering::Equal | Ordering::Greater)
         ) {
-            return Err("bound must be nonnegative".to_string());
+            return Err("bound must be nonnegative".to_string().into());
         }
 
         let num_vertices = graph.num_vertices();
@@ -65,25 +66,24 @@ impl<W: WeightElement> StrongConnectivityAugmentation<W> {
                 return Err(format!(
                     "candidate arc ({}, {}) references vertex >= num_vertices ({})",
                     u, v, num_vertices
-                ));
+                )
+                .into());
             }
             if !matches!(
                 weight.to_sum().partial_cmp(&W::Sum::zero()),
                 Some(Ordering::Greater)
             ) {
-                return Err(format!(
-                    "candidate arc ({}, {}) weight must be positive",
-                    u, v
-                ));
+                return Err(format!("candidate arc ({}, {}) weight must be positive", u, v).into());
             }
             if graph.has_arc(*u, *v) {
                 return Err(format!(
                     "candidate arc ({}, {}) already exists in the base graph",
                     u, v
-                ));
+                )
+                .into());
             }
             if !seen_pairs.insert((*u, *v)) {
-                return Err(format!("duplicate candidate arc ({}, {})", u, v));
+                return Err(format!("duplicate candidate arc ({}, {})", u, v).into());
             }
         }
 
@@ -145,32 +145,36 @@ impl<W: WeightElement> StrongConnectivityAugmentation<W> {
     }
 
     /// Check whether a configuration is a satisfying augmentation.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
         self.evaluate_config(config)
     }
 
-    fn evaluate_config(&self, config: &[usize]) -> bool {
+    fn evaluate_config(&self, config: &[bool]) -> Result<bool, crate::traits::EvaluationError> {
         if config.len() != self.candidate_arcs.len() {
-            return false;
+            return Ok(false);
         }
 
         let mut total = W::Sum::zero();
         let mut augmented_arcs = self.graph.arcs();
 
         for ((u, v, weight), &selected) in self.candidate_arcs.iter().zip(config.iter()) {
-            if selected > 1 {
-                return false;
-            }
-            if selected == 1 {
-                total += weight.to_sum();
+            if selected {
+                total = W::checked_add_to_sum(
+                    total,
+                    weight.to_sum(),
+                    "summing strong-connectivity augmentation weights",
+                )?;
                 if total > self.bound {
-                    return false;
+                    return Ok(false);
                 }
                 augmented_arcs.push((*u, *v));
             }
         }
 
-        DirectedGraph::new(self.graph.num_vertices(), augmented_arcs).is_strongly_connected()
+        Ok(DirectedGraph::new(self.graph.num_vertices(), augmented_arcs).is_strongly_connected())
     }
 }
 
@@ -179,23 +183,47 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "StrongConnectivityAugmentation";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_arcs", num_arcs),
+        ("num_potential_arcs", num_potential_arcs),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.candidate_arcs.len()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.candidate_arcs.len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "arc-selection length does not match the candidate arcs".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.evaluate_config(config)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.evaluate_config(config))
+impl<W> crate::solvers::BruteForceProblem for StrongConnectivityAugmentation<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.candidate_arcs.len()]
     }
 }
 
 crate::declare_variants! {
-    default StrongConnectivityAugmentation<i32> => "2^num_potential_arcs",
+    default StrongConnectivityAugmentation<i64> => "2^num_potential_arcs",
+}
+
+crate::register_brute_force! {
+    StrongConnectivityAugmentation<i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[derive(Deserialize)]
@@ -222,7 +250,7 @@ where
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "strong_connectivity_augmentation_i32",
+        id: "strong_connectivity_augmentation",
         // Path digraph 0→1→2→3→4 (not strongly connected — no back-edges).
         // Nine candidate arcs are all individually affordable, but only the
         // pair (4→1, w=3) + (1→0, w=5) = 8 = B achieves strong connectivity.
@@ -241,7 +269,9 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
             8,
         )),
-        optimal_config: vec![0, 0, 0, 1, 0, 0, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![
+            false, false, false, true, false, false, false, false, true
+        ]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/subgraph_isomorphism.rs b/src/models/graph/subgraph_isomorphism.rs
index ca7f7506b..def3018fc 100644
--- a/src/models/graph/subgraph_isomorphism.rs
+++ b/src/models/graph/subgraph_isomorphism.rs
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Subgraph Isomorphism",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Determine if host graph G contains a subgraph isomorphic to pattern graph H",
         fields: &[
@@ -46,7 +47,7 @@ inventory::submit! {
 /// ```
 /// use problemreductions::models::graph::SubgraphIsomorphism;
 /// use problemreductions::topology::SimpleGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Host: K4 (complete graph on 4 vertices)
 /// let host = SimpleGraph::new(4, vec![(0,1),(0,2),(0,3),(1,2),(1,3),(2,3)]);
@@ -55,10 +56,10 @@ inventory::submit! {
 /// let problem = SubgraphIsomorphism::new(host, pattern);
 ///
 /// // Mapping [0, 1, 2] means pattern vertex 0->host 0, 1->1, 2->2
-/// assert!(problem.evaluate(&[0, 1, 2]));
+/// assert!(problem.evaluate(&vec![0, 1, 2]).unwrap());
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -113,16 +114,68 @@ impl SubgraphIsomorphism {
     }
 
     /// Check if a configuration represents a valid subgraph isomorphism.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
+    pub fn is_valid_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        let n_pattern = self.pattern_graph.num_vertices();
+        let n_host = self.host_graph.num_vertices();
+
+        if n_pattern > n_host {
+            return Ok(false);
+        }
+        if config.len() != n_pattern {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex mapping length does not match the pattern graph".into(),
+            ));
+        }
+        if config.iter().any(|&vertex| vertex >= n_host) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "vertex mapping contains an out-of-range target vertex".into(),
+            ));
+        }
+        for i in 0..n_pattern {
+            for j in (i + 1)..n_pattern {
+                if config[i] == config[j] {
+                    return Ok(false);
+                }
+            }
+        }
+        for (u, v) in self.pattern_graph.edges() {
+            if !self.host_graph.has_edge(config[u], config[v]) {
+                return Ok(false);
+            }
+        }
+        Ok(true)
     }
 }
 
 impl Problem for SubgraphIsomorphism {
     const NAME: &'static str = "SubgraphIsomorphism";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
+    crate::problem_parameters![
+        ("num_host_edges", num_host_edges),
+        ("num_host_vertices", num_host_vertices),
+        ("num_pattern_edges", num_pattern_edges),
+        ("num_pattern_vertices", num_pattern_vertices),
+    ];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
+    }
+
+    fn variant() -> Vec<(&'static str, &'static str)> {
+        crate::variant_params![]
+    }
+}
+
+impl crate::solvers::BruteForceProblem for SubgraphIsomorphism {
+    fn dimensions(&self) -> Vec<usize> {
         let n_host = self.host_graph.num_vertices();
         let n_pattern = self.pattern_graph.num_vertices();
 
@@ -133,56 +186,16 @@ impl Problem for SubgraphIsomorphism {
             vec![n_host; n_pattern]
         }
     }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let n_pattern = self.pattern_graph.num_vertices();
-            let n_host = self.host_graph.num_vertices();
-
-            // If the pattern has more vertices than the host, no injective mapping exists.
-            if n_pattern > n_host {
-                return crate::types::Or(false);
-            }
-
-            // Config must have one entry per pattern vertex
-            if config.len() != n_pattern {
-                return crate::types::Or(false);
-            }
-
-            // All values must be valid host vertex indices
-            if config.iter().any(|&v| v >= n_host) {
-                return crate::types::Or(false);
-            }
-
-            // Check injectivity: all mapped host vertices must be distinct
-            for i in 0..n_pattern {
-                for j in (i + 1)..n_pattern {
-                    if config[i] == config[j] {
-                        return crate::types::Or(false);
-                    }
-                }
-            }
-
-            // Check edge preservation: every pattern edge must map to a host edge
-            for (u, v) in self.pattern_graph.edges() {
-                if !self.host_graph.has_edge(config[u], config[v]) {
-                    return crate::types::Or(false);
-                }
-            }
-
-            true
-        })
-    }
-
-    fn variant() -> Vec<(&'static str, &'static str)> {
-        crate::variant_params![]
-    }
 }
 
 crate::declare_variants! {
     default SubgraphIsomorphism => "num_host_vertices ^ num_pattern_vertices",
 }
 
+crate::register_brute_force! {
+    SubgraphIsomorphism,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     use crate::topology::SimpleGraph;
@@ -193,7 +206,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
             SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]),
         )),
-        optimal_config: vec![0, 1, 2],
+        optimal_config: serde_json::json!(vec![0, 1, 2]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/graph/traveling_salesman.rs b/src/models/graph/traveling_salesman.rs
index 017fabf7c..b658067da 100644
--- a/src/models/graph/traveling_salesman.rs
+++ b/src/models/graph/traveling_salesman.rs
@@ -3,7 +3,7 @@
 //! The Traveling Salesman problem asks for a minimum-weight cycle
 //! that visits every vertex exactly once.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
@@ -17,14 +17,12 @@ inventory::submit! {
         aliases: &["TSP"],
         dimensions: &[
             VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
-            VariantDimension::new("weight", "i32", &["i32"]),
+            VariantDimension::new("weight", "i64", &["i64"]),
         ],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Find minimum weight Hamiltonian cycle in a graph (Traveling Salesman Problem)",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "G", description: "The underlying graph G=(V,E)" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<W>", description: "Edge weights w: E -> R" },
-        ],
+        fields: TravelingSalesmanCreateSpec::FIELDS,
     }
 }
 
@@ -48,7 +46,7 @@ inventory::submit! {
 /// # Type Parameters
 ///
 /// * `G` - The graph type (e.g., `SimpleGraph`, `KingsSubgraph`)
-/// * `W` - The weight type for edges (e.g., `i32`, `f64`)
+/// * `W` - The weight type for edges (e.g., `i64`, `f64`)
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TravelingSalesman<G, W> {
     /// The underlying graph.
@@ -57,6 +55,66 @@ pub struct TravelingSalesman<G, W> {
     edge_weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct TravelingSalesmanCreateSpec {
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+    #[create(codec = "comma-separated")]
+    edge_weights: Option<Vec<i64>>,
+}
+
+impl TryFrom<TravelingSalesmanCreateSpec> for TravelingSalesman<SimpleGraph, i64> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: TravelingSalesmanCreateSpec) -> Result<Self, Self::Error> {
+        let graph = simple_graph_from_create(spec.graph, spec.num_vertices)?;
+        let edge_weights = spec
+            .edge_weights
+            .unwrap_or_else(|| vec![1; graph.num_edges()]);
+        if edge_weights.len() != graph.num_edges() {
+            return Err(format!(
+                "edge_weights has length {}, expected {}",
+                edge_weights.len(),
+                graph.num_edges()
+            )
+            .into());
+        }
+        Ok(Self::new(graph, edge_weights))
+    }
+}
+
+fn simple_graph_from_create(
+    edges: Vec<(usize, usize)>,
+    num_vertices: Option<usize>,
+) -> Result<SimpleGraph, crate::registry::ConstructionError> {
+    if edges.is_empty() && num_vertices.is_none() {
+        return Err("num_vertices is required for an empty graph"
+            .to_string()
+            .into());
+    }
+    for (index, &(u, v)) in edges.iter().enumerate() {
+        if u == v {
+            return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+        }
+    }
+    let inferred = edges
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| vertex.checked_add(1).ok_or("vertex count overflows usize"))
+        .transpose()?
+        .unwrap_or(0);
+    let num_vertices = num_vertices.unwrap_or(inferred);
+    if num_vertices < inferred {
+        return Err(format!(
+            "num_vertices {num_vertices} is too small for graph endpoints; need at least {inferred}"
+        )
+        .into());
+    }
+    Ok(SimpleGraph::new(num_vertices, edges))
+}
+
 impl<G: Graph, W: Clone + Default> TravelingSalesman<G, W> {
     /// Create a TravelingSalesman problem from a graph with given edge weights.
     pub fn new(graph: G, edge_weights: Vec<W>) -> Self {
@@ -74,9 +132,9 @@ impl<G: Graph, W: Clone + Default> TravelingSalesman<G, W> {
     /// Create a TravelingSalesman problem with unit weights.
     pub fn unit_weights(graph: G) -> Self
     where
-        W: From<i32>,
+        W: WeightElement,
     {
-        let edge_weights = vec![W::from(1); graph.num_edges()];
+        let edge_weights = vec![W::unit(); graph.num_edges()];
         Self {
             graph,
             edge_weights,
@@ -118,17 +176,17 @@ impl<G: Graph, W: Clone + Default> TravelingSalesman<G, W> {
     }
 
     /// Check if a configuration is a valid Hamiltonian cycle.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         self.is_valid_hamiltonian_cycle(config)
     }
 
     /// Check if a configuration forms a valid Hamiltonian cycle.
-    fn is_valid_hamiltonian_cycle(&self, config: &[usize]) -> bool {
+    fn is_valid_hamiltonian_cycle(&self, config: &[bool]) -> bool {
         if config.len() != self.graph.num_edges() {
             return false;
         }
-        let selected: Vec<bool> = config.iter().map(|&s| s == 1).collect();
-        is_hamiltonian_cycle(&self.graph, &selected)
+        let selected = config;
+        is_hamiltonian_cycle(&self.graph, selected)
     }
 }
 
@@ -150,29 +208,52 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "TravelingSalesman";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![G, W]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.graph.num_edges()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        if !self.is_valid_hamiltonian_cycle(config) {
-            return Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.graph.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the graph".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (idx, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                if let Some(w) = self.edge_weights.get(idx) {
-                    total += w.to_sum();
+        Ok({
+            if !self.is_valid_hamiltonian_cycle(config) {
+                return Ok(Min(None));
+            }
+            let mut total = W::Sum::zero();
+            for (idx, &selected) in config.iter().enumerate() {
+                if selected {
+                    if let Some(w) = self.edge_weights.get(idx) {
+                        total = W::checked_add_to_sum(
+                            total,
+                            w.to_sum(),
+                            "summing traveling salesman edge weights",
+                        )?;
+                    }
                 }
             }
-        }
-        Min(Some(total))
+            Min(Some(total))
+        })
+    }
+}
+
+impl<G, W> crate::solvers::BruteForceProblem for TravelingSalesman<G, W>
+where
+    G: Graph + crate::variant::VariantParam,
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.graph.num_edges()]
     }
 }
 
@@ -249,18 +330,28 @@ pub(crate) fn is_hamiltonian_cycle<G: Graph>(graph: &G, selected: &[bool]) -> bo
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "traveling_salesman_simplegraph_i32",
+        id: "traveling_salesman_simplegraph",
         instance: Box::new(TravelingSalesman::new(
             SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
             vec![1, 3, 2, 2, 3, 1],
         )),
-        optimal_config: vec![1, 0, 1, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![true, false, true, true, false, true]),
         optimal_value: serde_json::json!(6),
     }]
 }
 
+crate::impl_random_generate!(TravelingSalesman<SimpleGraph, i64>, crate::random::SimpleGraphRandomSpec, |spec| {
+    let graph = spec.graph()?;
+    let weights = vec![1; graph.num_edges()];
+    Ok(TravelingSalesman::new(graph, weights))
+});
+
 crate::declare_variants! {
-    default TravelingSalesman<SimpleGraph, i32> => "2^num_vertices",
+    default TravelingSalesman<SimpleGraph, i64> => "2^num_vertices" create TravelingSalesmanCreateSpec random,
+}
+
+crate::register_brute_force! {
+    TravelingSalesman<SimpleGraph, i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/undirected_flow_lower_bounds.rs b/src/models/graph/undirected_flow_lower_bounds.rs
index be86186dd..ff9b0657f 100644
--- a/src/models/graph/undirected_flow_lower_bounds.rs
+++ b/src/models/graph/undirected_flow_lower_bounds.rs
@@ -13,7 +13,7 @@
 //! lower bounds, so the registered exact complexity matches brute-force
 //! enumeration over the `2^|E|` edge orientations.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -25,44 +25,96 @@ inventory::submit! {
         display_name: "Undirected Flow with Lower Bounds",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Determine whether an undirected lower-bounded flow of value at least R exists",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "SimpleGraph", description: "Undirected graph G=(V,E)" },
-            FieldInfo { name: "capacities", type_name: "Vec<u64>", description: "Upper capacities c(e) in graph edge order" },
-            FieldInfo { name: "lower_bounds", type_name: "Vec<u64>", description: "Lower bounds l(e) in graph edge order" },
-            FieldInfo { name: "source", type_name: "usize", description: "Source vertex s" },
-            FieldInfo { name: "sink", type_name: "usize", description: "Sink vertex t" },
-            FieldInfo { name: "requirement", type_name: "u64", description: "Required net inflow R at sink t" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "UndirectedFlowLowerBounds",
-        fields: &["num_vertices", "num_edges"],
+        fields: UndirectedFlowLowerBoundsCreateSpec::FIELDS,
     }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct UndirectedFlowLowerBounds {
     graph: SimpleGraph,
-    capacities: Vec<u64>,
-    lower_bounds: Vec<u64>,
+    capacities: Vec<i64>,
+    lower_bounds: Vec<i64>,
     source: usize,
     sink: usize,
-    requirement: u64,
+    requirement: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct UndirectedFlowLowerBoundsCreateSpec {
+    /// Undirected graph.
+    graph: SimpleGraph,
+    /// Upper capacities in graph edge order.
+    capacities: Vec<i64>,
+    /// Lower bounds in graph edge order.
+    lower_bounds: Vec<i64>,
+    /// Source vertex.
+    source: usize,
+    /// Sink vertex.
+    sink: usize,
+    /// Required net inflow at the sink.
+    requirement: i64,
+}
+impl TryFrom<UndirectedFlowLowerBoundsCreateSpec> for UndirectedFlowLowerBounds {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: UndirectedFlowLowerBoundsCreateSpec) -> Result<Self, Self::Error> {
+        let edges = spec.graph.num_edges();
+        if spec.capacities.len() != edges {
+            return Err(format!(
+                "capacities has {} entries, expected {edges}",
+                spec.capacities.len()
+            )
+            .into());
+        }
+        if spec.lower_bounds.len() != edges {
+            return Err(format!(
+                "lower_bounds has {} entries, expected {edges}",
+                spec.lower_bounds.len()
+            )
+            .into());
+        }
+        let vertices = spec.graph.num_vertices();
+        if spec.source >= vertices || spec.sink >= vertices {
+            return Err("source and sink must be valid graph vertices"
+                .to_string()
+                .into());
+        }
+        if spec.source == spec.sink {
+            return Err("source and sink must be distinct".to_string().into());
+        }
+        if spec.requirement == 0 {
+            return Err("requirement must be at least 1".to_string().into());
+        }
+        if let Some((index, _)) = spec
+            .lower_bounds
+            .iter()
+            .zip(&spec.capacities)
+            .enumerate()
+            .find(|(_, (&lower, &upper))| lower > upper)
+        {
+            return Err(format!("lower bound at edge {index} exceeds its capacity").into());
+        }
+        Ok(Self::new(
+            spec.graph,
+            spec.capacities,
+            spec.lower_bounds,
+            spec.source,
+            spec.sink,
+            spec.requirement,
+        ))
+    }
 }
 
 impl UndirectedFlowLowerBounds {
     pub fn new(
         graph: SimpleGraph,
-        capacities: Vec<u64>,
-        lower_bounds: Vec<u64>,
+        capacities: Vec<i64>,
+        lower_bounds: Vec<i64>,
         source: usize,
         sink: usize,
-        requirement: u64,
+        requirement: i64,
     ) -> Self {
         assert_eq!(
             capacities.len(),
@@ -108,11 +160,11 @@ impl UndirectedFlowLowerBounds {
         &self.graph
     }
 
-    pub fn capacities(&self) -> &[u64] {
+    pub fn capacities(&self) -> &[i64] {
         &self.capacities
     }
 
-    pub fn lower_bounds(&self) -> &[u64] {
+    pub fn lower_bounds(&self) -> &[i64] {
         &self.lower_bounds
     }
 
@@ -124,7 +176,7 @@ impl UndirectedFlowLowerBounds {
         self.sink
     }
 
-    pub fn requirement(&self) -> u64 {
+    pub fn requirement(&self) -> i64 {
         self.requirement
     }
 
@@ -136,34 +188,47 @@ impl UndirectedFlowLowerBounds {
         self.graph.num_edges()
     }
 
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if config.len() != self.num_edges() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-orientation length does not match the graph".into(),
+            ));
+        }
+        self.has_feasible_orientation(config)
     }
 
-    fn total_capacity(&self) -> Option<u128> {
-        self.capacities.iter().try_fold(0_u128, |acc, &capacity| {
-            acc.checked_add(u128::from(capacity))
+    fn total_capacity(&self) -> Result<i64, crate::traits::EvaluationError> {
+        self.capacities.iter().try_fold(0_i64, |total, &capacity| {
+            total.checked_add(capacity).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing undirected flow capacities".into(),
+                )
+            })
         })
     }
 
-    fn has_feasible_orientation(&self, config: &[usize]) -> bool {
+    fn has_feasible_orientation(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
         if config.len() != self.num_edges() {
-            return false;
+            return Ok(false);
         }
 
-        let Some(total_capacity) = self.total_capacity() else {
-            return false;
-        };
-        let requirement = u128::from(self.requirement);
+        let total_capacity = self.total_capacity()?;
+        let requirement = self.requirement;
         if requirement > total_capacity {
-            return false;
+            return Ok(false);
         }
 
         let node_count = self.num_vertices();
         let super_source = node_count;
         let super_sink = node_count + 1;
         let mut network = ResidualNetwork::new(node_count + 2);
-        let mut balances = vec![0_i128; node_count];
+        let mut balances = vec![0_i64; node_count];
 
         for (edge_index, ((u, v), &orientation)) in self
             .graph
@@ -172,15 +237,11 @@ impl UndirectedFlowLowerBounds {
             .zip(config.iter())
             .enumerate()
         {
-            let (from, to) = match orientation {
-                0 => (u, v),
-                1 => (v, u),
-                _ => return false,
-            };
-            let lower = u128::from(self.lower_bounds[edge_index]);
-            let upper = u128::from(self.capacities[edge_index]);
-            if !add_lower_bounded_edge(&mut network, &mut balances, from, to, lower, upper) {
-                return false;
+            let (from, to) = if orientation { (v, u) } else { (u, v) };
+            let lower = self.lower_bounds[edge_index];
+            let upper = self.capacities[edge_index];
+            if !add_lower_bounded_edge(&mut network, &mut balances, from, to, lower, upper)? {
+                return Ok(false);
             }
         }
 
@@ -191,48 +252,70 @@ impl UndirectedFlowLowerBounds {
             self.source,
             requirement,
             total_capacity,
-        ) {
-            return false;
+        )? {
+            return Ok(false);
         }
 
-        let mut demand = 0_u128;
+        let mut demand = 0_i64;
         for (vertex, balance) in balances.into_iter().enumerate() {
             if balance > 0 {
-                let needed = u128::try_from(balance).expect("positive i128 balance fits u128");
-                demand = match demand.checked_add(needed) {
+                demand = match demand.checked_add(balance) {
                     Some(value) => value,
-                    None => return false,
+                    None => {
+                        return Err(crate::traits::EvaluationError::IntegerOverflow(
+                            "summing lower-bound flow demand".into(),
+                        ));
+                    }
                 };
-                network.add_edge(super_source, vertex, needed);
+                network.add_edge(super_source, vertex, balance);
             } else if balance < 0 {
-                let needed = u128::try_from(-balance).expect("negative i128 balance fits u128");
-                network.add_edge(vertex, super_sink, needed);
+                network.add_edge(
+                    vertex,
+                    super_sink,
+                    balance.checked_neg().ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "negating lower-bound flow balance".into(),
+                        )
+                    })?,
+                );
             }
         }
 
-        network.max_flow(super_source, super_sink) == demand
+        Ok(network.max_flow(super_source, super_sink)? == demand)
     }
 }
 
 impl Problem for UndirectedFlowLowerBounds {
     const NAME: &'static str = "UndirectedFlowLowerBounds";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.has_feasible_orientation(config))
+impl crate::solvers::BruteForceProblem for UndirectedFlowLowerBounds {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_edges()]
     }
 }
 
 crate::declare_variants! {
-    default UndirectedFlowLowerBounds => "2^num_edges",
+    default UndirectedFlowLowerBounds => "2^num_edges" create UndirectedFlowLowerBoundsCreateSpec,
+}
+
+crate::register_brute_force! {
+    UndirectedFlowLowerBounds decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -250,7 +333,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             5,
             3,
         )),
-        optimal_config: vec![0, 0, 0, 0, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![false, false, false, false, false, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
@@ -259,7 +342,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
 struct ResidualEdge {
     to: usize,
     rev: usize,
-    capacity: u128,
+    capacity: i64,
 }
 
 #[derive(Debug, Clone)]
@@ -274,7 +357,7 @@ impl ResidualNetwork {
         }
     }
 
-    fn add_edge(&mut self, from: usize, to: usize, capacity: u128) {
+    fn add_edge(&mut self, from: usize, to: usize, capacity: i64) {
         let reverse_at_to = self.adjacency[to].len();
         let reverse_at_from = self.adjacency[from].len();
         self.adjacency[from].push(ResidualEdge {
@@ -289,8 +372,12 @@ impl ResidualNetwork {
         });
     }
 
-    fn max_flow(&mut self, source: usize, sink: usize) -> u128 {
-        let mut total_flow = 0_u128;
+    fn max_flow(
+        &mut self,
+        source: usize,
+        sink: usize,
+    ) -> Result<i64, crate::traits::EvaluationError> {
+        let mut total_flow = 0_i64;
 
         loop {
             let mut parent: Vec<Option<(usize, usize)>> = vec![None; self.adjacency.len()];
@@ -313,10 +400,10 @@ impl ResidualNetwork {
             }
 
             if parent[sink].is_none() {
-                return total_flow;
+                return Ok(total_flow);
             }
 
-            let mut path_flow = u128::MAX;
+            let mut path_flow = i64::MAX;
             let mut vertex = sink;
             while vertex != source {
                 let (prev, edge_index) = parent[vertex].expect("sink is reachable");
@@ -328,39 +415,65 @@ impl ResidualNetwork {
             while vertex != source {
                 let (prev, edge_index) = parent[vertex].expect("sink is reachable");
                 let reverse_edge = self.adjacency[prev][edge_index].rev;
-                self.adjacency[prev][edge_index].capacity -= path_flow;
-                self.adjacency[vertex][reverse_edge].capacity += path_flow;
+                self.adjacency[prev][edge_index].capacity = self.adjacency[prev][edge_index]
+                    .capacity
+                    .checked_sub(path_flow)
+                    .ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "subtracting residual path flow".into(),
+                        )
+                    })?;
+                self.adjacency[vertex][reverse_edge].capacity = self.adjacency[vertex]
+                    [reverse_edge]
+                    .capacity
+                    .checked_add(path_flow)
+                    .ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "adding reverse residual path flow".into(),
+                        )
+                    })?;
                 vertex = prev;
             }
 
-            total_flow += path_flow;
+            total_flow = total_flow.checked_add(path_flow).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow("summing maximum flow".into())
+            })?;
         }
     }
 }
 
 fn add_lower_bounded_edge(
     network: &mut ResidualNetwork,
-    balances: &mut [i128],
+    balances: &mut [i64],
     from: usize,
     to: usize,
-    lower: u128,
-    upper: u128,
-) -> bool {
+    lower: i64,
+    upper: i64,
+) -> Result<bool, crate::traits::EvaluationError> {
     if lower > upper {
-        return false;
+        return Ok(false);
     }
 
-    let residual = upper - lower;
+    let residual = upper.checked_sub(lower).ok_or_else(|| {
+        crate::traits::EvaluationError::IntegerOverflow(
+            "subtracting lower bound from flow capacity".into(),
+        )
+    })?;
     if residual > 0 {
         network.add_edge(from, to, residual);
     }
 
-    let Ok(lower_signed) = i128::try_from(lower) else {
-        return false;
-    };
-    balances[from] -= lower_signed;
-    balances[to] += lower_signed;
-    true
+    balances[from] = balances[from].checked_sub(lower).ok_or_else(|| {
+        crate::traits::EvaluationError::IntegerOverflow(
+            "subtracting lower bound from source balance".into(),
+        )
+    })?;
+    balances[to] = balances[to].checked_add(lower).ok_or_else(|| {
+        crate::traits::EvaluationError::IntegerOverflow(
+            "adding lower bound to target balance".into(),
+        )
+    })?;
+    Ok(true)
 }
 
 #[cfg(test)]
diff --git a/src/models/graph/undirected_two_commodity_integral_flow.rs b/src/models/graph/undirected_two_commodity_integral_flow.rs
index 6159336b8..ad8a584f1 100644
--- a/src/models/graph/undirected_two_commodity_integral_flow.rs
+++ b/src/models/graph/undirected_two_commodity_integral_flow.rs
@@ -3,7 +3,7 @@
 //! The problem asks whether two integral commodities can be routed through an
 //! undirected capacitated graph while sharing edge capacities.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
@@ -14,25 +14,10 @@ inventory::submit! {
         display_name: "Undirected Two-Commodity Integral Flow",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Graph,
         module_path: module_path!(),
         description: "Determine whether two integral commodities can satisfy sink demands in an undirected capacitated graph",
-        fields: &[
-            FieldInfo { name: "graph", type_name: "SimpleGraph", description: "Undirected graph G=(V,E)" },
-            FieldInfo { name: "capacities", type_name: "Vec<u64>", description: "Edge capacities c(e) in graph edge order" },
-            FieldInfo { name: "source_1", type_name: "usize", description: "Source vertex s_1 for commodity 1" },
-            FieldInfo { name: "sink_1", type_name: "usize", description: "Sink vertex t_1 for commodity 1" },
-            FieldInfo { name: "source_2", type_name: "usize", description: "Source vertex s_2 for commodity 2" },
-            FieldInfo { name: "sink_2", type_name: "usize", description: "Sink vertex t_2 for commodity 2" },
-            FieldInfo { name: "requirement_1", type_name: "u64", description: "Required net inflow R_1 at sink t_1" },
-            FieldInfo { name: "requirement_2", type_name: "u64", description: "Required net inflow R_2 at sink t_2" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "UndirectedTwoCommodityIntegralFlow",
-        fields: &["num_vertices", "num_edges", "num_nonterminal_vertices"],
+        fields: UndirectedTwoCommodityIntegralFlowCreateSpec::FIELDS,
     }
 }
 
@@ -47,26 +32,102 @@ inventory::submit! {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct UndirectedTwoCommodityIntegralFlow {
     graph: SimpleGraph,
-    capacities: Vec<u64>,
+    capacities: Vec<i64>,
+    source_1: usize,
+    sink_1: usize,
+    source_2: usize,
+    sink_2: usize,
+    requirement_1: i64,
+    requirement_2: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct UndirectedTwoCommodityIntegralFlowCreateSpec {
+    /// Undirected graph edges.
+    #[create(codec = "edge-list")]
+    graph: Vec<(usize, usize)>,
+    /// Vertex count, needed for isolated vertices.
+    num_vertices: Option<usize>,
+    /// Edge capacities.
+    #[create(codec = "comma-separated")]
+    capacities: Vec<i64>,
     source_1: usize,
     sink_1: usize,
     source_2: usize,
     sink_2: usize,
-    requirement_1: u64,
-    requirement_2: u64,
+    requirement_1: i64,
+    requirement_2: i64,
+}
+
+impl TryFrom<UndirectedTwoCommodityIntegralFlowCreateSpec> for UndirectedTwoCommodityIntegralFlow {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: UndirectedTwoCommodityIntegralFlowCreateSpec) -> Result<Self, Self::Error> {
+        if spec.graph.is_empty() && spec.num_vertices.is_none() {
+            return Err("num_vertices is required for an empty graph".into());
+        }
+        for &(u, v) in &spec.graph {
+            if u == v {
+                return Err(format!("self-loop {u}-{v} is not allowed").into());
+            }
+        }
+        let inferred = spec
+            .graph
+            .iter()
+            .flat_map(|&(u, v)| [u, v])
+            .max()
+            .map(|v| v.checked_add(1).ok_or("vertex count overflows usize"))
+            .transpose()?
+            .unwrap_or(0);
+        let count = spec.num_vertices.unwrap_or(inferred);
+        if count < inferred {
+            return Err("num_vertices is too small for graph endpoints".into());
+        }
+        if spec.capacities.len() != spec.graph.len() {
+            return Err("capacities length must match graph edge count".into());
+        }
+        for &capacity in &spec.capacities {
+            if usize::try_from(capacity)
+                .ok()
+                .and_then(|v| v.checked_add(1))
+                .is_none()
+            {
+                return Err("capacity is too large for this platform".into());
+            }
+        }
+        for (label, vertex) in [
+            ("source_1", spec.source_1),
+            ("sink_1", spec.sink_1),
+            ("source_2", spec.source_2),
+            ("sink_2", spec.sink_2),
+        ] {
+            if vertex >= count {
+                return Err(format!("{label} must be less than num_vertices").into());
+            }
+        }
+        Ok(Self {
+            graph: SimpleGraph::new(count, spec.graph),
+            capacities: spec.capacities,
+            source_1: spec.source_1,
+            sink_1: spec.sink_1,
+            source_2: spec.source_2,
+            sink_2: spec.sink_2,
+            requirement_1: spec.requirement_1,
+            requirement_2: spec.requirement_2,
+        })
+    }
 }
 
 impl UndirectedTwoCommodityIntegralFlow {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         graph: SimpleGraph,
-        capacities: Vec<u64>,
+        capacities: Vec<i64>,
         source_1: usize,
         sink_1: usize,
         source_2: usize,
         sink_2: usize,
-        requirement_1: u64,
-        requirement_2: u64,
+        requirement_1: i64,
+        requirement_2: i64,
     ) -> Self {
         assert_eq!(
             capacities.len(),
@@ -113,7 +174,7 @@ impl UndirectedTwoCommodityIntegralFlow {
         &self.graph
     }
 
-    pub fn capacities(&self) -> &[u64] {
+    pub fn capacities(&self) -> &[i64] {
         &self.capacities
     }
 
@@ -133,11 +194,11 @@ impl UndirectedTwoCommodityIntegralFlow {
         self.sink_2
     }
 
-    pub fn requirement_1(&self) -> u64 {
+    pub fn requirement_1(&self) -> i64 {
         self.requirement_1
     }
 
-    pub fn requirement_2(&self) -> u64 {
+    pub fn requirement_2(&self) -> i64 {
         self.requirement_2
     }
 
@@ -149,21 +210,25 @@ impl UndirectedTwoCommodityIntegralFlow {
         self.graph.num_edges()
     }
 
-    pub fn num_nonterminal_vertices(&self) -> usize {
-        (0..self.num_vertices())
-            .filter(|&vertex| !self.is_terminal(vertex))
-            .count()
+    pub fn num_conservation_constraints(&self) -> usize {
+        [(self.source_1, self.sink_1), (self.source_2, self.sink_2)]
+            .into_iter()
+            .map(|(source, sink)| self.num_vertices() - if source == sink { 1 } else { 2 })
+            .sum()
     }
 
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
+    pub fn is_valid_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(self.evaluate_solution(config)?.0)
     }
 
     fn config_len(&self) -> usize {
         self.num_edges() * 4
     }
 
-    fn domain_size(capacity: u64) -> usize {
+    fn domain_size(capacity: i64) -> usize {
         usize::try_from(capacity)
             .ok()
             .and_then(|value| value.checked_add(1))
@@ -180,10 +245,6 @@ impl UndirectedTwoCommodityIntegralFlow {
         ])
     }
 
-    fn is_terminal(&self, vertex: usize) -> bool {
-        [self.source_1, self.sink_1, self.source_2, self.sink_2].contains(&vertex)
-    }
-
     fn flow_pair_for_commodity(flows: [usize; 4], commodity: usize) -> (usize, usize) {
         match commodity {
             1 => (flows[0], flows[1]),
@@ -192,45 +253,157 @@ impl UndirectedTwoCommodityIntegralFlow {
         }
     }
 
-    fn commodity_balance(&self, config: &[usize], commodity: usize, vertex: usize) -> Option<i128> {
-        let mut balance = 0i128;
+    fn commodity_balance(
+        &self,
+        config: &[usize],
+        commodity: usize,
+        vertex: usize,
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
+        let mut balance = 0_i64;
         for (edge_index, (u, v)) in self.graph.edges().into_iter().enumerate() {
-            let flows = self.edge_flows(config, edge_index)?;
+            let Some(flows) = self.edge_flows(config, edge_index) else {
+                return Ok(None);
+            };
             let (uv, vu) = Self::flow_pair_for_commodity(flows, commodity);
-            let uv = i128::from(u64::try_from(uv).ok()?);
-            let vu = i128::from(u64::try_from(vu).ok()?);
+            let uv = i64::try_from(uv).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting forward commodity flow to i64".into(),
+                )
+            })?;
+            let vu = i64::try_from(vu).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting reverse commodity flow to i64".into(),
+                )
+            })?;
 
             if vertex == u {
-                balance -= uv;
-                balance += vu;
+                balance = balance.checked_sub(uv).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "subtracting forward commodity flow".into(),
+                    )
+                })?;
+                balance = balance.checked_add(vu).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "adding reverse commodity flow".into(),
+                    )
+                })?;
             } else if vertex == v {
-                balance += uv;
-                balance -= vu;
+                balance = balance.checked_add(uv).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "adding forward commodity flow".into(),
+                    )
+                })?;
+                balance = balance.checked_sub(vu).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "subtracting reverse commodity flow".into(),
+                    )
+                })?;
             }
         }
-        Some(balance)
+        Ok(Some(balance))
     }
 
-    fn net_flow_into_sink(&self, config: &[usize], commodity: usize) -> Option<u64> {
+    fn net_flow_into_sink(
+        &self,
+        config: &[usize],
+        commodity: usize,
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         let sink = match commodity {
             1 => self.sink_1,
             2 => self.sink_2,
             _ => unreachable!("commodity must be 1 or 2"),
         };
-        let balance = self.commodity_balance(config, commodity, sink)?;
-        u64::try_from(balance).ok()
+        self.commodity_balance(config, commodity, sink)
+    }
+
+    fn evaluate_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.config_len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "flow representation length does not match the graph".into(),
+            ));
+        }
+
+        for (edge_index, &capacity) in self.capacities.iter().enumerate() {
+            let Some(flows) = self.edge_flows(config, edge_index) else {
+                return Ok(crate::types::Or(false));
+            };
+
+            if flows
+                .iter()
+                .any(|&value| i64::try_from(value).map_or(true, |value| value > capacity))
+            {
+                return Ok(crate::types::Or(false));
+            }
+            if flows[0] > 0 && flows[1] > 0 || flows[2] > 0 && flows[3] > 0 {
+                return Ok(crate::types::Or(false));
+            }
+
+            let commodity_1 = i64::try_from(std::cmp::max(flows[0], flows[1]))
+                .expect("flow values already validated against i64 capacities");
+            let commodity_2 = i64::try_from(std::cmp::max(flows[2], flows[3]))
+                .expect("flow values already validated against i64 capacities");
+            let shared = commodity_1.checked_add(commodity_2).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing two commodities on an undirected edge".into(),
+                )
+            })?;
+            if shared > capacity {
+                return Ok(crate::types::Or(false));
+            }
+        }
+
+        for (commodity, source, sink) in [
+            (1, self.source_1, self.sink_1),
+            (2, self.source_2, self.sink_2),
+        ] {
+            for vertex in 0..self.num_vertices() {
+                if vertex != source
+                    && vertex != sink
+                    && self.commodity_balance(config, commodity, vertex)? != Some(0)
+                {
+                    return Ok(crate::types::Or(false));
+                }
+            }
+        }
+
+        Ok(crate::types::Or(
+            self.net_flow_into_sink(config, 1)?
+                .is_some_and(|flow| flow >= self.requirement_1)
+                && self
+                    .net_flow_into_sink(config, 2)?
+                    .is_some_and(|flow| flow >= self.requirement_2),
+        ))
     }
 }
 
 impl Problem for UndirectedTwoCommodityIntegralFlow {
     const NAME: &'static str = "UndirectedTwoCommodityIntegralFlow";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_edges", num_edges),
+        ("num_conservation_constraints", num_conservation_constraints),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        self.evaluate_solution(config)
+    }
+}
+
+impl crate::solvers::BruteForceProblem for UndirectedTwoCommodityIntegralFlow {
+    fn dimensions(&self) -> Vec<usize> {
         self.capacities
             .iter()
             .flat_map(|&capacity| {
@@ -239,67 +412,14 @@ impl Problem for UndirectedTwoCommodityIntegralFlow {
             })
             .collect()
     }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.config_len() {
-                return crate::types::Or(false);
-            }
-
-            for (edge_index, &capacity) in self.capacities.iter().enumerate() {
-                let Some(flows) = self.edge_flows(config, edge_index) else {
-                    return crate::types::Or(false);
-                };
-
-                if flows
-                    .iter()
-                    .any(|&value| u64::try_from(value).map_or(true, |value| value > capacity))
-                {
-                    return crate::types::Or(false);
-                }
-
-                if flows[0] > 0 && flows[1] > 0 {
-                    return crate::types::Or(false);
-                }
-                if flows[2] > 0 && flows[3] > 0 {
-                    return crate::types::Or(false);
-                }
-
-                let commodity_1 = u64::try_from(std::cmp::max(flows[0], flows[1]))
-                    .expect("flow values already validated against u64 capacities");
-                let commodity_2 = u64::try_from(std::cmp::max(flows[2], flows[3]))
-                    .expect("flow values already validated against u64 capacities");
-                let Some(shared) = commodity_1.checked_add(commodity_2) else {
-                    return crate::types::Or(false);
-                };
-                if shared > capacity {
-                    return crate::types::Or(false);
-                }
-            }
-
-            for vertex in 0..self.num_vertices() {
-                if self.is_terminal(vertex) {
-                    continue;
-                }
-
-                if self.commodity_balance(config, 1, vertex) != Some(0)
-                    || self.commodity_balance(config, 2, vertex) != Some(0)
-                {
-                    return crate::types::Or(false);
-                }
-            }
-
-            self.net_flow_into_sink(config, 1)
-                .is_some_and(|flow| flow >= self.requirement_1)
-                && self
-                    .net_flow_into_sink(config, 2)
-                    .is_some_and(|flow| flow >= self.requirement_2)
-        })
-    }
 }
 
 crate::declare_variants! {
-    default UndirectedTwoCommodityIntegralFlow => "5^num_edges",
+    default UndirectedTwoCommodityIntegralFlow => "5^num_edges" create UndirectedTwoCommodityIntegralFlowCreateSpec,
+}
+
+crate::register_brute_force! {
+    UndirectedTwoCommodityIntegralFlow,
 }
 
 #[cfg(feature = "example-db")]
@@ -316,7 +436,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             1,
             1,
         )),
-        optimal_config: vec![1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/additional_key.rs b/src/models/misc/additional_key.rs
index 6073fc46c..d15016c1b 100644
--- a/src/models/misc/additional_key.rs
+++ b/src/models/misc/additional_key.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Additional Key",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine whether a relational schema has a candidate key not in a given set",
         fields: &[
@@ -47,7 +48,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::AdditionalKey;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = AdditionalKey::new(
 ///     3,
@@ -56,7 +57,7 @@ inventory::submit! {
 ///     vec![],
 /// );
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -192,74 +193,91 @@ impl AdditionalKey {
 
 impl Problem for AdditionalKey {
     const NAME: &'static str = "AdditionalKey";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_attributes", num_attributes),
+        ("num_dependencies", num_dependencies),
+        ("num_relation_attrs", num_relation_attrs),
+        ("num_known_keys", num_known_keys),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.relation_attrs.len()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            // Check config length
-            if config.len() != self.relation_attrs.len() {
-                return crate::types::Or(false);
-            }
-            // Check all values are 0 or 1
-            if config.iter().any(|&v| v >= 2) {
-                return crate::types::Or(false);
-            }
-
-            // Build selected attribute set
-            let selected: Vec<usize> = config
-                .iter()
-                .enumerate()
-                .filter(|(_, &v)| v == 1)
-                .map(|(i, _)| self.relation_attrs[i])
-                .collect();
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                // Check config length
+                if config.len() != self.relation_attrs.len() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "attribute-selection length does not match the relation".into(),
+                    ));
+                }
+                // Check all values are 0 or 1
+                // Build selected attribute set
+                let selected: Vec<usize> = config
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, &v)| v)
+                    .map(|(i, _)| self.relation_attrs[i])
+                    .collect();
 
-            // Empty selection is not a key
-            if selected.is_empty() {
-                return crate::types::Or(false);
-            }
+                // Empty selection is not a key
+                if selected.is_empty() {
+                    return Ok(crate::types::Or(false));
+                }
 
-            // Compute closure of selected attributes
-            let mut attr_set = vec![false; self.num_attributes];
-            for &a in &selected {
-                attr_set[a] = true;
-            }
-            let closure = self.compute_closure(&attr_set);
+                // Compute closure of selected attributes
+                let mut attr_set = vec![false; self.num_attributes];
+                for &a in &selected {
+                    attr_set[a] = true;
+                }
+                let closure = self.compute_closure(&attr_set);
 
-            // Check closure covers all relation_attrs
-            if !self.relation_attrs.iter().all(|&a| closure[a]) {
-                return crate::types::Or(false);
-            }
+                // Check closure covers all relation_attrs
+                if !self.relation_attrs.iter().all(|&a| closure[a]) {
+                    return Ok(crate::types::Or(false));
+                }
 
-            // Check minimality: removing any single selected attribute should break coverage
-            for &a in &selected {
-                let mut reduced = attr_set.clone();
-                reduced[a] = false;
-                let reduced_closure = self.compute_closure(&reduced);
-                if self.relation_attrs.iter().all(|&ra| reduced_closure[ra]) {
-                    return crate::types::Or(false); // Not minimal
+                // Check minimality: removing any single selected attribute should break coverage
+                for &a in &selected {
+                    let mut reduced = attr_set.clone();
+                    reduced[a] = false;
+                    let reduced_closure = self.compute_closure(&reduced);
+                    if self.relation_attrs.iter().all(|&ra| reduced_closure[ra]) {
+                        return Ok(crate::types::Or(false)); // Not minimal
+                    }
                 }
-            }
 
-            // Build sorted selected vec and check it's not in known_keys
-            let mut sorted_selected = selected;
-            sorted_selected.sort_unstable();
-            !self.known_keys.contains(&sorted_selected)
+                // Build sorted selected vec and check it's not in known_keys
+                let mut sorted_selected = selected;
+                sorted_selected.sort_unstable();
+                !self.known_keys.contains(&sorted_selected)
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for AdditionalKey {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.relation_attrs.len()]
+    }
+}
+
 crate::declare_variants! {
     default AdditionalKey => "2^num_relation_attrs * num_dependencies * num_attributes",
 }
 
+crate::register_brute_force! {
+    AdditionalKey decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -276,7 +294,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![0, 1, 2, 3, 4, 5],
             vec![vec![0, 1], vec![2, 3], vec![4, 5]],
         )),
-        optimal_config: vec![1, 0, 1, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![true, false, true, false, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/betweenness.rs b/src/models/misc/betweenness.rs
index 2062f6af0..bf55a1c12 100644
--- a/src/models/misc/betweenness.rs
+++ b/src/models/misc/betweenness.rs
@@ -5,7 +5,7 @@
 //! such that for each (a, b, c) ∈ C, either f(a) < f(b) < f(c) or
 //! f(c) < f(b) < f(a) (i.e., b is between a and c).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Betweenness",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a linear ordering where specified elements are between others",
         fields: &[
@@ -26,13 +27,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "Betweenness",
-        fields: &["num_elements", "num_triples"],
-    }
-}
-
 #[derive(Debug, Clone, Serialize)]
 pub struct Betweenness {
     num_elements: usize,
@@ -43,22 +37,24 @@ impl Betweenness {
     fn validate_inputs(
         num_elements: usize,
         triples: &[(usize, usize, usize)],
-    ) -> Result<(), String> {
+    ) -> Result<(), crate::registry::ConstructionError> {
         if num_elements == 0 {
-            return Err("Betweenness requires at least one element".to_string());
+            return Err("Betweenness requires at least one element"
+                .to_string()
+                .into());
         }
         for (i, &(a, b, c)) in triples.iter().enumerate() {
             if a >= num_elements || b >= num_elements || c >= num_elements {
                 return Err(format!(
                     "Triple {} has element(s) out of range 0..{}",
                     i, num_elements
-                ));
+                )
+                .into());
             }
             if a == b || b == c || a == c {
-                return Err(format!(
-                    "Triple {} has duplicate elements ({}, {}, {})",
-                    i, a, b, c
-                ));
+                return Err(
+                    format!("Triple {} has duplicate elements ({}, {}, {})", i, a, b, c).into(),
+                );
             }
         }
         Ok(())
@@ -67,7 +63,7 @@ impl Betweenness {
     pub fn try_new(
         num_elements: usize,
         triples: Vec<(usize, usize, usize)>,
-    ) -> Result<Self, String> {
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate_inputs(num_elements, &triples)?;
         Ok(Self {
             num_elements,
@@ -149,18 +145,33 @@ impl<'de> Deserialize<'de> for Betweenness {
 
 impl Problem for Betweenness {
     const NAME: &'static str = "Betweenness";
+    type Solution = Vec<usize>;
     type Value = Or;
 
+    crate::problem_parameters![("num_elements", num_elements), ("num_triples", num_triples),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_elements; self.num_elements]
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_elements {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "ordering length does not match the elements".into(),
+            ));
+        }
+        if config.iter().any(|&position| position >= self.num_elements) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "ordering contains an out-of-range position".into(),
+            ));
+        }
+        Ok(Or(self.is_valid_solution(config)))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or(self.is_valid_solution(config))
+impl crate::solvers::BruteForceProblem for Betweenness {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_elements; self.num_elements]
     }
 }
 
@@ -168,6 +179,10 @@ crate::declare_variants! {
     default Betweenness => "2^num_elements",
 }
 
+crate::register_brute_force! {
+    Betweenness,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -176,7 +191,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             5,
             vec![(0, 1, 2), (2, 3, 4), (0, 2, 4), (1, 3, 4)],
         )),
-        optimal_config: vec![0, 1, 2, 3, 4],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 3, 4]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/biguint_serde.rs b/src/models/misc/biguint_serde.rs
index 0911144db..cf0650c40 100644
--- a/src/models/misc/biguint_serde.rs
+++ b/src/models/misc/biguint_serde.rs
@@ -5,22 +5,9 @@ pub(crate) mod decimal_biguint {
     use serde::de::Error;
     use serde::{Deserialize, Deserializer, Serializer};
 
-    #[derive(Deserialize)]
-    #[serde(untagged)]
-    pub enum Repr {
-        String(String),
-        U64(u64),
-        I64(i64),
-    }
-
-    pub fn parse_repr<E: Error>(value: Repr) -> Result<BigUint, E> {
-        match value {
-            Repr::String(s) => BigUint::parse_bytes(s.as_bytes(), 10)
-                .ok_or_else(|| E::custom(format!("invalid decimal integer: {s}"))),
-            Repr::U64(n) => Ok(BigUint::from(n)),
-            Repr::I64(n) if n >= 0 => Ok(BigUint::from(n as u64)),
-            Repr::I64(n) => Err(E::custom(format!("expected nonnegative integer, got {n}"))),
-        }
+    pub fn parse<E: Error>(value: &str) -> Result<BigUint, E> {
+        BigUint::parse_bytes(value.as_bytes(), 10)
+            .ok_or_else(|| E::custom(format!("invalid decimal integer: {value}")))
     }
 
     pub fn serialize<S>(value: &BigUint, serializer: S) -> Result<S::Ok, S::Error>
@@ -34,7 +21,7 @@ pub(crate) mod decimal_biguint {
     where
         D: Deserializer<'de>,
     {
-        parse_repr(Repr::deserialize(deserializer)?)
+        parse(&String::deserialize(deserializer)?)
     }
 }
 
@@ -54,10 +41,10 @@ pub(crate) mod decimal_biguint_vec {
     where
         D: Deserializer<'de>,
     {
-        let values = Vec::<super::decimal_biguint::Repr>::deserialize(deserializer)?;
+        let values = Vec::<String>::deserialize(deserializer)?;
         values
             .into_iter()
-            .map(super::decimal_biguint::parse_repr::<D::Error>)
+            .map(|value| super::decimal_biguint::parse::<D::Error>(&value))
             .collect()
     }
 }
diff --git a/src/models/misc/bin_packing.rs b/src/models/misc/bin_packing.rs
index a778c2395..0f952f549 100644
--- a/src/models/misc/bin_packing.rs
+++ b/src/models/misc/bin_packing.rs
@@ -3,9 +3,10 @@
 //! The Bin Packing problem asks for an assignment of items to bins
 //! that minimizes the number of bins used while respecting capacity constraints.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{ConstructionError, FieldInfo, ProblemSchemaEntry, VariantDimension};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
+use num_traits::Zero;
 use serde::{Deserialize, Serialize};
 
 inventory::submit! {
@@ -13,7 +14,8 @@ inventory::submit! {
         name: "BinPacking",
         display_name: "Bin Packing",
         aliases: &[],
-        dimensions: &[VariantDimension::new("weight", "i32", &["i32", "f64"])],
+        dimensions: &[VariantDimension::new("weight", "i64", &["i64", "f64"])],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Assign items to bins minimizing number of bins used, subject to capacity",
         fields: &[
@@ -37,21 +39,21 @@ inventory::submit! {
 ///
 /// # Type Parameters
 ///
-/// * `W` - The weight type for sizes and capacity (e.g., `i32`, `f64`)
+/// * `W` - The weight type for sizes and capacity (e.g., `i64`, `f64`)
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::misc::BinPacking;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 4 items with sizes [3, 3, 2, 2], capacity 5
-/// let problem = BinPacking::new(vec![3, 3, 2, 2], 5);
+/// let problem = BinPacking::new(vec![3, 3, 2, 2], 5).unwrap();
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct BinPacking<W> {
     /// Item sizes.
     sizes: Vec<W>,
@@ -59,10 +61,33 @@ pub struct BinPacking<W> {
     capacity: W,
 }
 
-impl<W: Clone> BinPacking<W> {
+#[derive(Deserialize)]
+struct BinPackingData<W> {
+    sizes: Vec<W>,
+    capacity: W,
+}
+
+impl<'de, W> Deserialize<'de> for BinPacking<W>
+where
+    W: WeightElement + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let data = BinPackingData::deserialize(deserializer)?;
+        Self::new(data.sizes, data.capacity).map_err(serde::de::Error::custom)
+    }
+}
+
+impl<W: WeightElement> BinPacking<W> {
     /// Create a Bin Packing problem from item sizes and capacity.
-    pub fn new(sizes: Vec<W>, capacity: W) -> Self {
-        Self { sizes, capacity }
+    pub fn new(sizes: Vec<W>, capacity: W) -> Result<Self, ConstructionError> {
+        for (index, size) in sizes.iter().enumerate() {
+            size.validate_element(&format!("item size at index {index}"))?;
+        }
+        capacity.validate_element("bin capacity")?;
+        Ok(Self { sizes, capacity })
     }
 
     /// Get the item sizes.
@@ -87,47 +112,84 @@ where
     W::Sum: PartialOrd,
 {
     const NAME: &'static str = "BinPacking";
-    type Value = Min<i32>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_items", num_items),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![W]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.sizes.len();
-        vec![n; n]
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "bin assignment length does not match the items".into(),
+            ));
+        }
+        if config.iter().any(|&bin| bin >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "bin assignment contains an out-of-range bin".into(),
+            ));
+        }
+        Ok({
+            if !is_valid_packing(&self.sizes, &self.capacity, config)? {
+                return Ok(Min(None));
+            }
+            let num_bins = count_bins(config);
+            Min(Some(i64::try_from(num_bins).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting used-bin count to i64".into(),
+                )
+            })?))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<i32> {
-        if !is_valid_packing(&self.sizes, &self.capacity, config) {
-            return Min(None);
-        }
-        let num_bins = count_bins(config);
-        Min(Some(num_bins as i32))
+impl<W> crate::solvers::BruteForceProblem for BinPacking<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+    W::Sum: PartialOrd,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.sizes.len();
+        vec![n; n]
     }
 }
 
 /// Check if a configuration is a valid bin packing (all bins within capacity).
-fn is_valid_packing<W: WeightElement>(sizes: &[W], capacity: &W, config: &[usize]) -> bool
+fn is_valid_packing<W: WeightElement>(
+    sizes: &[W],
+    capacity: &W,
+    config: &[usize],
+) -> Result<bool, crate::traits::EvaluationError>
 where
     W::Sum: PartialOrd,
 {
     if config.len() != sizes.len() {
-        return false;
+        return Ok(false);
     }
     let n = sizes.len();
     // Check all bin indices are in range
     if config.iter().any(|&b| b >= n) {
-        return false;
+        return Ok(false);
     }
     // Compute load per bin
     let cap_sum = capacity.to_sum();
-    let mut bin_load: Vec<W::Sum> = vec![W::Sum::default(); n];
+    let mut bin_load: Vec<W::Sum> = vec![W::Sum::zero(); n];
     for (i, &bin) in config.iter().enumerate() {
-        bin_load[bin] += sizes[i].to_sum();
+        bin_load[bin] = W::checked_add_to_sum(
+            bin_load[bin].clone(),
+            sizes[i].to_sum(),
+            "summing bin loads",
+        )?;
     }
     // Check capacity constraints
-    bin_load.iter().all(|load| *load <= cap_sum)
+    Ok(bin_load.iter().all(|load| *load <= cap_sum))
 }
 
 /// Count the number of distinct bins used in a configuration.
@@ -142,17 +204,22 @@ fn count_bins(config: &[usize]) -> usize {
 }
 
 crate::declare_variants! {
-    default BinPacking<i32> => "2^num_items",
+    default BinPacking<i64> => "2^num_items",
     BinPacking<f64> => "2^num_items",
 }
 
+crate::register_brute_force! {
+    BinPacking<i64>,
+    BinPacking<f64>,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "bin_packing",
         // 3 items of sizes [3,3,4], capacity 7 → optimal 2 bins
-        instance: Box::new(BinPacking::<i32>::new(vec![3, 3, 4], 7)),
-        optimal_config: vec![0, 1, 0],
+        instance: Box::new(BinPacking::<i64>::new(vec![3, 3, 4], 7).unwrap()),
+        optimal_config: serde_json::json!(vec![0, 1, 0]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/misc/boyce_codd_normal_form_violation.rs b/src/models/misc/boyce_codd_normal_form_violation.rs
index 3e465c5bf..a09631428 100644
--- a/src/models/misc/boyce_codd_normal_form_violation.rs
+++ b/src/models/misc/boyce_codd_normal_form_violation.rs
@@ -5,7 +5,7 @@
 //! `X ⊆ A'` such that the closure of `X` under the functional dependencies contains
 //! some but not all attributes of `A' \ X` — i.e., a witness to a BCNF violation.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
@@ -16,13 +16,10 @@ inventory::submit! {
         display_name: "Boyce-Codd Normal Form Violation",
         aliases: &["BCNFViolation", "BCNF"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Test whether a subset of attributes violates Boyce-Codd normal form",
-        fields: &[
-            FieldInfo { name: "num_attributes", type_name: "usize", description: "Total number of attributes in A" },
-            FieldInfo { name: "functional_deps", type_name: "Vec<(Vec<usize>, Vec<usize>)>", description: "Functional dependencies (lhs_attributes, rhs_attributes)" },
-            FieldInfo { name: "target_subset", type_name: "Vec<usize>", description: "Subset A' of attributes to test for BCNF violation" },
-        ],
+        fields: BoyceCoddNormalFormViolationCreateSpec::FIELDS,
     }
 }
 
@@ -42,7 +39,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::BoyceCoddNormalFormViolation;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 6 attributes, FDs: {0,1}→{2}, {2}→{3}, {3,4}→{5}
 /// let problem = BoyceCoddNormalFormViolation::new(
@@ -56,7 +53,9 @@ inventory::submit! {
 /// );
 /// let solver = BruteForce::new();
 /// // X = {2}: closure = {2, 3}, y=3 ∈ closure, z=0 ∉ closure → BCNF violation
-/// assert!(problem.evaluate(&[0, 0, 1, 0, 0, 0]));
+/// assert!(problem
+///     .evaluate(&vec![false, false, true, false, false, false])
+///     .unwrap());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BoyceCoddNormalFormViolation {
@@ -68,6 +67,50 @@ pub struct BoyceCoddNormalFormViolation {
     target_subset: Vec<usize>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct BoyceCoddNormalFormViolationCreateSpec {
+    /// Total number of attributes in A.
+    n: usize,
+    /// Functional dependencies (lhs attributes, rhs attributes).
+    #[create(codec = "functional-dependency-list")]
+    subsets: Vec<(Vec<usize>, Vec<usize>)>,
+    /// Subset A' of attributes to test for BCNF violation.
+    target: Vec<usize>,
+}
+
+impl TryFrom<BoyceCoddNormalFormViolationCreateSpec> for BoyceCoddNormalFormViolation {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: BoyceCoddNormalFormViolationCreateSpec) -> Result<Self, Self::Error> {
+        if spec.target.is_empty() {
+            return Err("target must be non-empty".to_string().into());
+        }
+        for (dependency_index, (lhs, rhs)) in spec.subsets.iter().enumerate() {
+            if lhs.is_empty() {
+                return Err(format!("subsets[{dependency_index}] has an empty left side").into());
+            }
+            if let Some(&attribute) = lhs
+                .iter()
+                .chain(rhs)
+                .find(|&&attribute| attribute >= spec.n)
+            {
+                return Err(format!(
+                    "subsets[{dependency_index}] contains attribute {attribute} outside universe of size {}",
+                    spec.n
+                ).into());
+            }
+        }
+        if let Some(&attribute) = spec.target.iter().find(|&&attribute| attribute >= spec.n) {
+            return Err(format!(
+                "target contains attribute {attribute} outside universe of size {}",
+                spec.n
+            )
+            .into());
+        }
+        Ok(Self::new(spec.n, spec.subsets, spec.target))
+    }
+}
+
 impl BoyceCoddNormalFormViolation {
     /// Create a new Boyce-Codd Normal Form Violation instance.
     ///
@@ -176,37 +219,47 @@ impl BoyceCoddNormalFormViolation {
 
 impl Problem for BoyceCoddNormalFormViolation {
     const NAME: &'static str = "BoyceCoddNormalFormViolation";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.target_subset.len()]
-    }
+    crate::problem_parameters![
+        ("num_attributes", num_attributes),
+        ("num_functional_deps", num_functional_deps),
+        ("num_target_attributes", num_target_attributes),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.target_subset.len() || config.iter().any(|&v| v > 1) {
-                return crate::types::Or(false);
-            }
-            let x: HashSet<usize> = config
-                .iter()
-                .enumerate()
-                .filter(|(_, &v)| v == 1)
-                .map(|(i, _)| self.target_subset[i])
-                .collect();
-            let closure = Self::compute_closure(&x, &self.functional_deps);
-            // Check: ∃ y, z ∈ A' \ X s.t. y ∈ closure ∧ z ∉ closure
-            let mut has_in_closure = false;
-            let mut has_not_in_closure = false;
-            for &a in &self.target_subset {
-                if !x.contains(&a) {
-                    if closure.contains(&a) {
-                        has_in_closure = true;
-                    } else {
-                        has_not_in_closure = true;
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.target_subset.len() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "attribute-selection length does not match the target subset".into(),
+                    ));
+                }
+                let x: HashSet<usize> = config
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, &v)| v)
+                    .map(|(i, _)| self.target_subset[i])
+                    .collect();
+                let closure = Self::compute_closure(&x, &self.functional_deps);
+                // Check: ∃ y, z ∈ A' \ X s.t. y ∈ closure ∧ z ∉ closure
+                let mut has_in_closure = false;
+                let mut has_not_in_closure = false;
+                for &a in &self.target_subset {
+                    if !x.contains(&a) {
+                        if closure.contains(&a) {
+                            has_in_closure = true;
+                        } else {
+                            has_not_in_closure = true;
+                        }
                     }
                 }
-            }
-            has_in_closure && has_not_in_closure
+                has_in_closure && has_not_in_closure
+            })
         })
     }
 
@@ -215,8 +268,18 @@ impl Problem for BoyceCoddNormalFormViolation {
     }
 }
 
+impl crate::solvers::BruteForceProblem for BoyceCoddNormalFormViolation {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.target_subset.len()]
+    }
+}
+
 crate::declare_variants! {
-    default BoyceCoddNormalFormViolation => "2^num_target_attributes * num_target_attributes^2 * num_functional_deps",
+    default BoyceCoddNormalFormViolation => "2^num_target_attributes * num_target_attributes^2 * num_functional_deps" create BoyceCoddNormalFormViolationCreateSpec,
+}
+
+crate::register_brute_force! {
+    BoyceCoddNormalFormViolation decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -233,7 +296,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![0, 1, 2, 3, 4, 5],
         )),
         // X={2}: closure={2,3}, y=3 in closure, z=0 not in closure -> violation
-        optimal_config: vec![0, 0, 1, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![false, false, true, false, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/capacity_assignment.rs b/src/models/misc/capacity_assignment.rs
index cd4426daf..f397cdb4d 100644
--- a/src/models/misc/capacity_assignment.rs
+++ b/src/models/misc/capacity_assignment.rs
@@ -3,7 +3,7 @@
 //! Capacity Assignment asks for the minimum-cost assignment of capacity levels
 //! to communication links, subject to a delay budget constraint.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -13,14 +13,10 @@ inventory::submit! {
         display_name: "Capacity Assignment",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Minimize total cost of capacity assignment subject to a delay budget",
-        fields: &[
-            FieldInfo { name: "capacities", type_name: "Vec<u64>", description: "Ordered capacity levels M" },
-            FieldInfo { name: "cost", type_name: "Vec<Vec<u64>>", description: "Cost matrix g(c, m) for each link and capacity" },
-            FieldInfo { name: "delay", type_name: "Vec<Vec<u64>>", description: "Delay matrix d(c, m) for each link and capacity" },
-            FieldInfo { name: "delay_budget", type_name: "u64", description: "Budget J on total delay penalty" },
-        ],
+        fields: CapacityAssignmentCreateSpec::FIELDS,
     }
 }
 
@@ -32,19 +28,70 @@ inventory::submit! {
 /// total cost subject to a delay budget constraint.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CapacityAssignment {
-    capacities: Vec<u64>,
-    cost: Vec<Vec<u64>>,
-    delay: Vec<Vec<u64>>,
-    delay_budget: u64,
+    capacities: Vec<i64>,
+    cost: Vec<Vec<i64>>,
+    delay: Vec<Vec<i64>>,
+    delay_budget: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct CapacityAssignmentCreateSpec {
+    #[create(codec = "comma-separated")]
+    capacities: Vec<i64>,
+    #[create(codec = "semicolon-separated")]
+    cost: Vec<Vec<i64>>,
+    #[create(codec = "semicolon-separated")]
+    delay: Vec<Vec<i64>>,
+    delay_budget: i64,
+}
+
+impl TryFrom<CapacityAssignmentCreateSpec> for CapacityAssignment {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: CapacityAssignmentCreateSpec) -> Result<Self, Self::Error> {
+        if spec.capacities.is_empty() {
+            return Err("capacities must be non-empty".into());
+        }
+        if spec.capacities.contains(&0) {
+            return Err("capacities must be positive".into());
+        }
+        if !spec.capacities.windows(2).all(|w| w[0] < w[1]) {
+            return Err("capacities must be strictly increasing".into());
+        }
+        if spec.cost.len() != spec.delay.len() {
+            return Err("cost and delay must have the same number of links".into());
+        }
+        for (i, row) in spec.cost.iter().enumerate() {
+            if row.len() != spec.capacities.len() {
+                return Err(format!("cost row {i} length must match capacities length").into());
+            }
+            if !row.windows(2).all(|w| w[0] <= w[1]) {
+                return Err(format!("cost row {i} must be non-decreasing").into());
+            }
+        }
+        for (i, row) in spec.delay.iter().enumerate() {
+            if row.len() != spec.capacities.len() {
+                return Err(format!("delay row {i} length must match capacities length").into());
+            }
+            if !row.windows(2).all(|w| w[0] >= w[1]) {
+                return Err(format!("delay row {i} must be non-increasing").into());
+            }
+        }
+        Ok(Self {
+            capacities: spec.capacities,
+            cost: spec.cost,
+            delay: spec.delay,
+            delay_budget: spec.delay_budget,
+        })
+    }
 }
 
 impl CapacityAssignment {
     /// Create a new Capacity Assignment instance.
     pub fn new(
-        capacities: Vec<u64>,
-        cost: Vec<Vec<u64>>,
-        delay: Vec<Vec<u64>>,
-        delay_budget: u64,
+        capacities: Vec<i64>,
+        cost: Vec<Vec<i64>>,
+        delay: Vec<Vec<i64>>,
+        delay_budget: i64,
     ) -> Self {
         assert!(!capacities.is_empty(), "capacities must be non-empty");
         assert!(
@@ -104,63 +151,92 @@ impl CapacityAssignment {
     }
 
     /// Ordered capacity levels.
-    pub fn capacities(&self) -> &[u64] {
+    pub fn capacities(&self) -> &[i64] {
         &self.capacities
     }
 
     /// Cost matrix indexed by link, then capacity.
-    pub fn cost(&self) -> &[Vec<u64>] {
+    pub fn cost(&self) -> &[Vec<i64>] {
         &self.cost
     }
 
     /// Delay matrix indexed by link, then capacity.
-    pub fn delay(&self) -> &[Vec<u64>] {
+    pub fn delay(&self) -> &[Vec<i64>] {
         &self.delay
     }
 
     /// Total delay budget.
-    pub fn delay_budget(&self) -> u64 {
+    pub fn delay_budget(&self) -> i64 {
         self.delay_budget
     }
 
-    fn total_cost_and_delay(&self, config: &[usize]) -> Option<(u128, u128)> {
+    fn total_cost_and_delay(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<(i64, i64)>, crate::traits::EvaluationError> {
         if config.len() != self.num_links() {
-            return None;
+            return Ok(None);
         }
 
         let num_capacities = self.num_capacities();
-        let mut total_cost = 0u128;
-        let mut total_delay = 0u128;
+        let mut total_cost = 0i64;
+        let mut total_delay = 0i64;
 
         for (link, &choice) in config.iter().enumerate() {
             if choice >= num_capacities {
-                return None;
+                return Ok(None);
             }
-            total_cost += self.cost[link][choice] as u128;
-            total_delay += self.delay[link][choice] as u128;
+            total_cost = total_cost
+                .checked_add(self.cost[link][choice])
+                .ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing capacity-assignment costs".to_string(),
+                    )
+                })?;
+            total_delay = total_delay
+                .checked_add(self.delay[link][choice])
+                .ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing capacity-assignment delays".to_string(),
+                    )
+                })?;
         }
 
-        Some((total_cost, total_delay))
+        Ok(Some((total_cost, total_delay)))
     }
 }
 
 impl Problem for CapacityAssignment {
     const NAME: &'static str = "CapacityAssignment";
-    type Value = crate::types::Min<u128>;
+    type Solution = Vec<usize>;
+    type Value = crate::types::Min<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_capacities(); self.num_links()]
-    }
+    crate::problem_parameters![("num_capacities", num_capacities), ("num_links", num_links),];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Min<u128> {
-        let Some((total_cost, total_delay)) = self.total_cost_and_delay(config) else {
-            return crate::types::Min(None);
-        };
-        if total_delay <= self.delay_budget as u128 {
-            crate::types::Min(Some(total_cost))
-        } else {
-            crate::types::Min(None)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.num_links() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "capacity-choice length does not match the links".into(),
+            ));
+        }
+        if config.iter().any(|&choice| choice >= self.num_capacities()) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "capacity assignment contains an out-of-range choice".into(),
+            ));
         }
+        Ok({
+            let Some((total_cost, total_delay)) = self.total_cost_and_delay(config)? else {
+                return Ok(crate::types::Min(None));
+            };
+            if total_delay <= self.delay_budget {
+                crate::types::Min(Some(total_cost))
+            } else {
+                crate::types::Min(None)
+            }
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -168,8 +244,18 @@ impl Problem for CapacityAssignment {
     }
 }
 
+impl crate::solvers::BruteForceProblem for CapacityAssignment {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_capacities(); self.num_links()]
+    }
+}
+
 crate::declare_variants! {
-    default CapacityAssignment => "num_capacities ^ num_links",
+    default CapacityAssignment => "num_capacities ^ num_links" create CapacityAssignmentCreateSpec,
+}
+
+crate::register_brute_force! {
+    CapacityAssignment,
 }
 
 #[cfg(feature = "example-db")]
@@ -182,7 +268,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![vec![8, 4, 1], vec![7, 3, 1], vec![6, 3, 1]],
             12,
         )),
-        optimal_config: vec![1, 1, 1],
+        optimal_config: serde_json::json!(vec![1, 1, 1]),
         optimal_value: serde_json::json!(9),
     }]
 }
diff --git a/src/models/misc/closest_string.rs b/src/models/misc/closest_string.rs
index 05c646890..722d23dfd 100644
--- a/src/models/misc/closest_string.rs
+++ b/src/models/misc/closest_string.rs
@@ -5,7 +5,7 @@
 //! same alphabet that minimizes the maximum Hamming distance from `c` to any
 //! input string.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Closest String",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a center string of fixed length that minimizes the maximum Hamming distance to a list of equal-length input strings",
         fields: &[
@@ -33,13 +34,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "ClosestString",
-        fields: &["alphabet_size", "num_strings", "string_length", "total_length"],
-    }
-}
-
 /// The Closest String problem.
 ///
 /// Given a finite alphabet `Sigma = {0, ..., q - 1}` and `n` input strings
@@ -122,32 +116,61 @@ impl ClosestString {
 
 impl Problem for ClosestString {
     const NAME: &'static str = "ClosestString";
+    type Solution = Vec<usize>;
     type Value = Min<i64>;
 
+    crate::problem_parameters![
+        ("alphabet_size", alphabet_size),
+        ("num_strings", num_strings),
+        ("string_length", string_length),
+        ("total_length", total_length),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.alphabet_size; self.string_length()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let m = self.string_length();
+            if config.len() != m {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "candidate string length does not match the instance strings".into(),
+                ));
+            }
+            if config.iter().any(|&symbol| symbol >= self.alphabet_size) {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "candidate string contains an out-of-range symbol".into(),
+                ));
+            }
+            // Maximum Hamming distance from the center to any input string.
+            let mut max_distance = 0_i64;
+            for string in &self.strings {
+                let distance = i64::try_from(
+                    config
+                        .iter()
+                        .zip(string.iter())
+                        .filter(|(center, target)| center != target)
+                        .count(),
+                )
+                .map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting Hamming distance to i64".into(),
+                    )
+                })?;
+                max_distance = max_distance.max(distance);
+            }
+            Min(Some(max_distance))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<i64> {
-        let m = self.string_length();
-        if config.len() != m {
-            return Min(None);
-        }
-        if config.iter().any(|&symbol| symbol >= self.alphabet_size) {
-            return Min(None);
-        }
-        // Maximum Hamming distance from the center to any input string.
-        let max_distance = self
-            .strings
-            .iter()
-            .map(|s| config.iter().zip(s.iter()).filter(|(c, t)| c != t).count() as i64)
-            .max()
-            .unwrap_or(0);
-        Min(Some(max_distance))
+impl crate::solvers::BruteForceProblem for ClosestString {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.alphabet_size; self.string_length()]
     }
 }
 
@@ -155,6 +178,10 @@ crate::declare_variants! {
     default ClosestString => "alphabet_size ^ string_length",
 }
 
+crate::register_brute_force! {
+    ClosestString,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -163,7 +190,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             2,
             vec![vec![0, 0, 0], vec![0, 1, 1], vec![1, 0, 1], vec![1, 1, 0]],
         )),
-        optimal_config: vec![0, 0, 0],
+        optimal_config: serde_json::json!(vec![0, 0, 0]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/misc/closest_substring.rs b/src/models/misc/closest_substring.rs
index 7e33a1b52..56a504e5a 100644
--- a/src/models/misc/closest_substring.rs
+++ b/src/models/misc/closest_substring.rs
@@ -6,7 +6,7 @@
 //! input string that together minimize the maximum Hamming distance from `c`
 //! to any selected window.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Closest Substring",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a center string of fixed length and one length-ell window per input string that minimize the maximum Hamming distance between the center and any selected window",
         fields: &[
@@ -39,19 +40,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "ClosestSubstring",
-        fields: &[
-            "alphabet_size",
-            "num_strings",
-            "substring_length",
-            "total_length",
-            "total_num_windows",
-        ],
-    }
-}
-
 /// The Closest Substring problem.
 ///
 /// Given a finite alphabet `Sigma = {0, ..., q - 1}`, `n` input strings
@@ -64,48 +52,77 @@ inventory::submit! {
 ///
 /// where `d_H` is the Hamming distance. Every choice in the discrete cube is
 /// syntactically feasible.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct ClosestSubstring {
     alphabet_size: usize,
     strings: Vec<Vec<usize>>,
     substring_length: usize,
 }
 
+#[derive(Deserialize)]
+struct ClosestSubstringData {
+    alphabet_size: usize,
+    strings: Vec<Vec<usize>>,
+    substring_length: usize,
+}
+
+impl<'de> Deserialize<'de> for ClosestSubstring {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let data = ClosestSubstringData::deserialize(deserializer)?;
+        Self::new(data.alphabet_size, data.strings, data.substring_length)
+            .map_err(serde::de::Error::custom)
+    }
+}
+
 impl ClosestSubstring {
     /// Create a new `ClosestSubstring` instance.
     ///
-    /// # Panics
-    ///
-    /// Panics if:
-    /// - `strings` is empty (the problem requires at least one input string),
-    /// - `substring_length > |s_i|` for any input string,
-    /// - `alphabet_size == 0` while `substring_length > 0`,
-    /// - any symbol in any input string is `>= alphabet_size`.
-    pub fn new(alphabet_size: usize, strings: Vec<Vec<usize>>, substring_length: usize) -> Self {
-        assert!(
-            !strings.is_empty(),
-            "ClosestSubstring requires at least one input string"
-        );
-        assert!(
-            strings.iter().all(|s| s.len() >= substring_length),
-            "substring_length must be <= |s_i| for every input string"
-        );
-        assert!(
-            alphabet_size > 0 || substring_length == 0,
-            "alphabet_size must be > 0 when substring_length > 0"
-        );
-        assert!(
-            strings
-                .iter()
-                .flat_map(|s| s.iter())
-                .all(|&symbol| symbol < alphabet_size),
-            "input symbols must be less than alphabet_size"
-        );
-        Self {
+    pub fn new(
+        alphabet_size: usize,
+        strings: Vec<Vec<usize>>,
+        substring_length: usize,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        if strings.is_empty() {
+            return Err("ClosestSubstring requires at least one input string".into());
+        }
+        if strings.iter().any(|s| s.len() < substring_length) {
+            return Err("substring_length must be <= |s_i| for every input string".into());
+        }
+        if alphabet_size == 0 && substring_length > 0 {
+            return Err("alphabet_size must be > 0 when substring_length > 0".into());
+        }
+        if strings
+            .iter()
+            .flat_map(|s| s.iter())
+            .any(|&symbol| symbol >= alphabet_size)
+        {
+            return Err("input symbols must be less than alphabet_size".into());
+        }
+        substring_length
+            .checked_add(strings.len())
+            .ok_or("configuration length exceeds usize")?;
+        strings
+            .iter()
+            .try_fold(0_usize, |total, string| total.checked_add(string.len()))
+            .ok_or("total input length exceeds usize")?;
+        strings
+            .iter()
+            .map(|string| string.len() - substring_length + 1)
+            .try_fold(0_usize, usize::checked_add)
+            .ok_or("total number of windows exceeds usize")?;
+        strings
+            .iter()
+            .map(|string| string.len() - substring_length + 1)
+            .try_fold(1_usize, usize::checked_mul)
+            .ok_or("window-choice count exceeds usize")?;
+        Ok(Self {
             alphabet_size,
             strings,
             substring_length,
-        }
+        })
     }
 
     /// Returns the alphabet size `q`.
@@ -143,85 +160,116 @@ impl ClosestSubstring {
 
     /// Returns `prod_i W_i`, the number of distinct window-selection tuples.
     ///
-    /// Uses saturating multiplication so the value cannot overflow; callers
-    /// should treat a return of `usize::MAX` as "very large".
     pub fn num_window_choice_product(&self) -> usize {
         self.strings
             .iter()
             .map(|s| s.len() - self.substring_length + 1)
-            .fold(1usize, |acc, w| acc.saturating_mul(w))
+            .try_fold(1usize, usize::checked_mul)
+            .expect("validated window-choice count must fit usize")
     }
 }
 
 impl Problem for ClosestSubstring {
     const NAME: &'static str = "ClosestSubstring";
+    type Solution = Vec<usize>;
     type Value = Min<i64>;
 
+    crate::problem_parameters![
+        ("alphabet_size", alphabet_size),
+        ("num_strings", num_strings),
+        ("substring_length", substring_length),
+        ("total_length", total_length),
+        ("total_num_windows", total_num_windows),
+        ("num_window_choice_product", num_window_choice_product),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let ell = self.substring_length;
+            let n = self.num_strings();
+            if config.len() != ell + n {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "substring witness length does not match the instance".into(),
+                ));
+            }
+            let (center, window_starts) = config.split_at(ell);
+            if center.iter().any(|&symbol| symbol >= self.alphabet_size) {
+                return Ok(Min(None));
+            }
+            for (i, &start) in window_starts.iter().enumerate() {
+                let w_i = self.strings[i].len() - ell + 1;
+                if start >= w_i {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "substring witness contains an out-of-range window start".into(),
+                    ));
+                }
+            }
+            // Maximum Hamming distance from the center to the chosen window of each string.
+            let mut max_distance = 0_i64;
+            for (i, &start) in window_starts.iter().enumerate() {
+                let window = &self.strings[i][start..start + ell];
+                let distance = i64::try_from(
+                    center
+                        .iter()
+                        .zip(window.iter())
+                        .filter(|(center_symbol, target_symbol)| center_symbol != target_symbol)
+                        .count(),
+                )
+                .map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting substring Hamming distance to i64".into(),
+                    )
+                })?;
+                max_distance = max_distance.max(distance);
+            }
+            Min(Some(max_distance))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for ClosestSubstring {
+    fn dimensions(&self) -> Vec<usize> {
         let ell = self.substring_length;
         let mut dims = vec![self.alphabet_size; ell];
         dims.extend(self.strings.iter().map(|s| s.len() - ell + 1));
         dims
     }
-
-    fn evaluate(&self, config: &[usize]) -> Min<i64> {
-        let ell = self.substring_length;
-        let n = self.num_strings();
-        if config.len() != ell + n {
-            return Min(None);
-        }
-        let (center, window_starts) = config.split_at(ell);
-        if center.iter().any(|&symbol| symbol >= self.alphabet_size) {
-            return Min(None);
-        }
-        for (i, &start) in window_starts.iter().enumerate() {
-            let w_i = self.strings[i].len() - ell + 1;
-            if start >= w_i {
-                return Min(None);
-            }
-        }
-        // Maximum Hamming distance from the center to the chosen window of each string.
-        let max_distance = window_starts
-            .iter()
-            .enumerate()
-            .map(|(i, &start)| {
-                let window = &self.strings[i][start..start + ell];
-                center
-                    .iter()
-                    .zip(window.iter())
-                    .filter(|(c, t)| c != t)
-                    .count() as i64
-            })
-            .max()
-            .unwrap_or(0);
-        Min(Some(max_distance))
-    }
 }
 
 crate::declare_variants! {
     default ClosestSubstring => "alphabet_size ^ substring_length * num_window_choice_product",
 }
 
+crate::register_brute_force! {
+    ClosestSubstring,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "closest_substring",
-        instance: Box::new(ClosestSubstring::new(
-            2,
-            vec![
-                vec![0, 0, 0, 1, 1],
-                vec![1, 0, 1, 0, 0],
-                vec![1, 1, 0, 0, 1],
-            ],
-            3,
-        )),
+        instance: Box::new(
+            ClosestSubstring::new(
+                2,
+                vec![
+                    vec![0, 0, 0, 1, 1],
+                    vec![1, 0, 1, 0, 0],
+                    vec![1, 1, 0, 0, 1],
+                ],
+                3,
+            )
+            .unwrap(),
+        ),
         // Center c = [0, 1, 0]; windows (0, 1, 0) selecting s_1[0..3] = 000,
         // s_2[1..4] = 010, s_3[0..3] = 110 with distances 1, 0, 1 and radius 1.
-        optimal_config: vec![0, 1, 0, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![0, 1, 0, 0, 1, 0]),
         optimal_value: serde_json::json!(1),
     }]
 }
diff --git a/src/models/misc/clustering.rs b/src/models/misc/clustering.rs
index 3bb340087..e87998c73 100644
--- a/src/models/misc/clustering.rs
+++ b/src/models/misc/clustering.rs
@@ -15,12 +15,13 @@ inventory::submit! {
         display_name: "Clustering",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Partition elements into at most K clusters where all intra-cluster distances are at most B",
         fields: &[
-            FieldInfo { name: "distances", type_name: "Vec<Vec<u64>>", description: "Symmetric distance matrix with zero diagonal" },
+            FieldInfo { name: "distances", type_name: "Vec<Vec<i64>>", description: "Symmetric distance matrix with zero diagonal" },
             FieldInfo { name: "num_clusters", type_name: "usize", description: "Maximum number of clusters K" },
-            FieldInfo { name: "diameter_bound", type_name: "u64", description: "Maximum allowed intra-cluster pairwise distance B" },
+            FieldInfo { name: "diameter_bound", type_name: "i64", description: "Maximum allowed intra-cluster pairwise distance B" },
         ],
     }
 }
@@ -43,7 +44,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::Clustering;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 4 elements, 2 clusters, diameter bound 1
 /// let distances = vec![
@@ -54,17 +55,17 @@ inventory::submit! {
 /// ];
 /// let problem = Clustering::new(distances, 2, 1);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Clustering {
     /// Symmetric distance matrix with zero diagonal.
-    distances: Vec<Vec<u64>>,
+    distances: Vec<Vec<i64>>,
     /// Maximum number of clusters K.
     num_clusters: usize,
     /// Maximum allowed intra-cluster pairwise distance B.
-    diameter_bound: u64,
+    diameter_bound: i64,
 }
 
 impl Clustering {
@@ -78,7 +79,7 @@ impl Clustering {
     /// - `distances` is not symmetric
     /// - diagonal entries are not zero
     /// - `num_clusters` is zero
-    pub fn new(distances: Vec<Vec<u64>>, num_clusters: usize, diameter_bound: u64) -> Self {
+    pub fn new(distances: Vec<Vec<i64>>, num_clusters: usize, diameter_bound: i64) -> Self {
         let n = distances.len();
         assert!(n > 0, "Clustering requires at least one element");
         assert!(num_clusters > 0, "num_clusters must be at least 1");
@@ -111,7 +112,7 @@ impl Clustering {
     }
 
     /// Returns the distance matrix.
-    pub fn distances(&self) -> &[Vec<u64>] {
+    pub fn distances(&self) -> &[Vec<i64>] {
         &self.distances
     }
 
@@ -126,7 +127,7 @@ impl Clustering {
     }
 
     /// Returns the diameter bound B.
-    pub fn diameter_bound(&self) -> u64 {
+    pub fn diameter_bound(&self) -> i64 {
         self.diameter_bound
     }
 
@@ -160,18 +161,39 @@ impl Clustering {
 
 impl Problem for Clustering {
     const NAME: &'static str = "Clustering";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_clusters", num_clusters),
+        ("num_elements", num_elements),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_clusters; self.num_elements()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_elements() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "cluster assignment length does not match the elements".into(),
+            ));
+        }
+        if config.iter().any(|&cluster| cluster >= self.num_clusters) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "cluster assignment contains an out-of-range cluster".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_valid_partition(config)))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_valid_partition(config))
+impl crate::solvers::BruteForceProblem for Clustering {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_clusters; self.num_elements()]
     }
 }
 
@@ -179,6 +201,10 @@ crate::declare_variants! {
     default Clustering => "num_clusters^num_elements",
 }
 
+crate::register_brute_force! {
+    Clustering,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 6 elements in two tight groups {0,1,2} and {3,4,5}
@@ -195,7 +221,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "clustering",
         instance: Box::new(Clustering::new(distances, 2, 1)),
-        optimal_config: vec![0, 0, 0, 1, 1, 1],
+        optimal_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/conjunctive_boolean_query.rs b/src/models/misc/conjunctive_boolean_query.rs
index e9e4b8737..a6ce31f50 100644
--- a/src/models/misc/conjunctive_boolean_query.rs
+++ b/src/models/misc/conjunctive_boolean_query.rs
@@ -10,7 +10,7 @@
 //! the domain. The query is satisfiable iff there exists an assignment to the
 //! variables such that every conjunct's resolved tuple belongs to its relation.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -20,14 +20,10 @@ inventory::submit! {
         display_name: "Conjunctive Boolean Query",
         aliases: &["CBQ"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Evaluate a conjunctive Boolean query over a relational database",
-        fields: &[
-            FieldInfo { name: "domain_size", type_name: "usize", description: "Size of the finite domain D" },
-            FieldInfo { name: "relations", type_name: "Vec<Relation>", description: "Collection of relations R" },
-            FieldInfo { name: "num_variables", type_name: "usize", description: "Number of existentially quantified variables" },
-            FieldInfo { name: "conjuncts", type_name: "Vec<(usize, Vec<QueryArg>)>", description: "Query conjuncts: (relation_index, arguments)" },
-        ],
+        fields: ConjunctiveBooleanQueryCreateSpec::FIELDS,
     }
 }
 
@@ -66,7 +62,7 @@ pub enum QueryArg {
 ///
 /// ```
 /// use problemreductions::models::misc::{ConjunctiveBooleanQuery, CbqRelation, QueryArg};
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let relations = vec![
 ///     CbqRelation { arity: 2, tuples: vec![vec![0, 3], vec![1, 3]] },
@@ -76,7 +72,7 @@ pub enum QueryArg {
 /// ];
 /// let problem = ConjunctiveBooleanQuery::new(6, relations, 1, conjuncts);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -87,6 +83,90 @@ pub struct ConjunctiveBooleanQuery {
     conjuncts: Vec<(usize, Vec<QueryArg>)>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct ConjunctiveBooleanQueryCreateSpec {
+    /// Size of the finite domain.
+    domain_size: usize,
+    /// Relations evaluated by the query.
+    #[create(codec = "json")]
+    relations: Vec<Relation>,
+    /// Query atoms; the number of variables is inferred from their arguments.
+    #[create(codec = "json")]
+    conjuncts: Vec<(usize, Vec<QueryArg>)>,
+}
+
+impl TryFrom<ConjunctiveBooleanQueryCreateSpec> for ConjunctiveBooleanQuery {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: ConjunctiveBooleanQueryCreateSpec) -> Result<Self, Self::Error> {
+        let mut num_variables = 0_usize;
+        for (_, args) in &spec.conjuncts {
+            for arg in args {
+                if let QueryArg::Variable(variable) = arg {
+                    let count = variable
+                        .checked_add(1)
+                        .ok_or_else(|| "number of query variables overflows usize".to_string())?;
+                    num_variables = num_variables.max(count);
+                }
+            }
+        }
+
+        for (relation_index, relation) in spec.relations.iter().enumerate() {
+            for (tuple_index, tuple) in relation.tuples.iter().enumerate() {
+                if tuple.len() != relation.arity {
+                    return Err(format!(
+                        "relation {relation_index} tuple {tuple_index} has length {}, expected arity {}",
+                        tuple.len(),
+                        relation.arity
+                    ).into());
+                }
+                for (entry_index, &value) in tuple.iter().enumerate() {
+                    if value >= spec.domain_size {
+                        return Err(format!(
+                            "relation {relation_index} tuple {tuple_index} entry {entry_index} is {value}, must be less than domain size {}",
+                            spec.domain_size
+                        ).into());
+                    }
+                }
+            }
+        }
+
+        for (conjunct_index, (relation_index, args)) in spec.conjuncts.iter().enumerate() {
+            let relation = spec.relations.get(*relation_index).ok_or_else(|| {
+                format!(
+                    "conjunct {conjunct_index} relation index {relation_index} is out of range for {} relations",
+                    spec.relations.len()
+                )
+            })?;
+            if args.len() != relation.arity {
+                return Err(format!(
+                    "conjunct {conjunct_index} has {} arguments, expected arity {}",
+                    args.len(),
+                    relation.arity
+                )
+                .into());
+            }
+            for (argument_index, arg) in args.iter().enumerate() {
+                if let QueryArg::Constant(value) = arg {
+                    if *value >= spec.domain_size {
+                        return Err(format!(
+                            "conjunct {conjunct_index} argument {argument_index} constant {value} must be less than domain size {}",
+                            spec.domain_size
+                        ).into());
+                    }
+                }
+            }
+        }
+
+        Ok(Self {
+            domain_size: spec.domain_size,
+            relations: spec.relations,
+            num_variables,
+            conjuncts: spec.conjuncts,
+        })
+    }
+}
+
 impl ConjunctiveBooleanQuery {
     /// Create a new ConjunctiveBooleanQuery instance.
     ///
@@ -191,40 +271,63 @@ impl ConjunctiveBooleanQuery {
 
 impl Problem for ConjunctiveBooleanQuery {
     const NAME: &'static str = "ConjunctiveBooleanQuery";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("domain_size", domain_size),
+        ("num_conjuncts", num_conjuncts),
+        ("num_relations", num_relations),
+        ("num_variables", num_variables),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.domain_size; self.num_variables]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_variables {
-                return crate::types::Or(false);
-            }
-            if config.iter().any(|&v| v >= self.domain_size) {
-                return crate::types::Or(false);
-            }
-            self.conjuncts.iter().all(|(rel_idx, args)| {
-                let tuple: Vec<usize> = args
-                    .iter()
-                    .map(|arg| match arg {
-                        QueryArg::Variable(i) => config[*i],
-                        QueryArg::Constant(c) => *c,
-                    })
-                    .collect();
-                self.relations[*rel_idx].tuples.contains(&tuple)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_variables {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "variable assignment length does not match the query".into(),
+                    ));
+                }
+                if config.iter().any(|&v| v >= self.domain_size) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "variable assignment contains an out-of-range domain value".into(),
+                    ));
+                }
+                self.conjuncts.iter().all(|(rel_idx, args)| {
+                    let tuple: Vec<usize> = args
+                        .iter()
+                        .map(|arg| match arg {
+                            QueryArg::Variable(i) => config[*i],
+                            QueryArg::Constant(c) => *c,
+                        })
+                        .collect();
+                    self.relations[*rel_idx].tuples.contains(&tuple)
+                })
             })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for ConjunctiveBooleanQuery {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.domain_size; self.num_variables]
+    }
+}
+
 crate::declare_variants! {
-    default ConjunctiveBooleanQuery => "domain_size ^ num_variables",
+    default ConjunctiveBooleanQuery => "domain_size ^ num_variables" create ConjunctiveBooleanQueryCreateSpec,
+}
+
+crate::register_brute_force! {
+    ConjunctiveBooleanQuery,
 }
 
 #[cfg(feature = "example-db")]
@@ -259,7 +362,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 ),
             ],
         )),
-        optimal_config: vec![0, 1],
+        optimal_config: serde_json::json!(vec![0, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/conjunctive_query_foldability.rs b/src/models/misc/conjunctive_query_foldability.rs
index cd3963c50..d8f6ed074 100644
--- a/src/models/misc/conjunctive_query_foldability.rs
+++ b/src/models/misc/conjunctive_query_foldability.rs
@@ -15,6 +15,7 @@ inventory::submit! {
         display_name: "Conjunctive Query Foldability",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine if one conjunctive query can be folded into another by substituting undistinguished variables",
         fields: &[
@@ -65,7 +66,7 @@ pub enum Term {
 ///
 /// ```
 /// use problemreductions::models::misc::{ConjunctiveQueryFoldability, Term};
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Q1: R(x, u) ∧ R(u, u)    Q2: R(x, x)  (single atom; duplicates are irrelevant)
 /// // σ: u → x (index = domain_size + 0 = 0) folds Q1 to Q2
@@ -81,7 +82,7 @@ pub enum Term {
 ///     ],
 /// );
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -262,64 +263,82 @@ impl ConjunctiveQueryFoldability {
 
 impl Problem for ConjunctiveQueryFoldability {
     const NAME: &'static str = "ConjunctiveQueryFoldability";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("domain_size", domain_size),
+        ("num_distinguished", num_distinguished),
+        ("num_undistinguished", num_undistinguished),
+        ("num_conjuncts_q1", num_conjuncts_q1),
+        ("num_conjuncts_q2", num_conjuncts_q2),
+        ("num_relations", num_relations),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    /// Returns the configuration space dimensions.
-    ///
-    /// Each of the `num_undistinguished` variables can map to any element of
-    /// `D ∪ X ∪ Y`, giving `domain_size + num_distinguished + num_undistinguished`
-    /// choices per variable.  When `num_undistinguished == 0` the vector is empty
-    /// (Q1 contains no variables to substitute; the problem is trivially decided
-    /// by checking set equality of Q1 and Q2 at evaluation time).
-    fn dims(&self) -> Vec<usize> {
-        let range = self.domain_size + self.num_distinguished + self.num_undistinguished;
-        vec![range; self.num_undistinguished]
-    }
-
     /// Evaluate whether configuration `config` represents a folding of Q1 into Q2.
     ///
     /// Returns `true` iff applying the substitution encoded by `config` to every
     /// atom of Q1 produces exactly the set of atoms in Q2.
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_undistinguished {
-                return crate::types::Or(false);
-            }
-            let range = self.domain_size + self.num_distinguished + self.num_undistinguished;
-            if config.iter().any(|&v| v >= range) {
-                return crate::types::Or(false);
-            }
-
-            // Apply σ to every atom of Q1.
-            let substituted: HashSet<(usize, Vec<Term>)> = self
-                .query1_conjuncts
-                .iter()
-                .map(|(rel_idx, args)| {
-                    let new_args = args
-                        .iter()
-                        .map(|term| self.apply_substitution(term, config))
-                        .collect();
-                    (*rel_idx, new_args)
-                })
-                .collect();
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_undistinguished {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "folding-map length does not match the query variables".into(),
+                    ));
+                }
+                let range = self.domain_size + self.num_distinguished + self.num_undistinguished;
+                if config.iter().any(|&value| value >= range) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "folding map contains an out-of-range value".into(),
+                    ));
+                }
+                // Apply σ to every atom of Q1.
+                let substituted: HashSet<(usize, Vec<Term>)> = self
+                    .query1_conjuncts
+                    .iter()
+                    .map(|(rel_idx, args)| {
+                        let new_args = args
+                            .iter()
+                            .map(|term| self.apply_substitution(term, config))
+                            .collect();
+                        (*rel_idx, new_args)
+                    })
+                    .collect();
 
-            // Collect Q2 as a set.
-            let q2_set: HashSet<(usize, Vec<Term>)> =
-                self.query2_conjuncts.iter().cloned().collect();
+                // Collect Q2 as a set.
+                let q2_set: HashSet<(usize, Vec<Term>)> =
+                    self.query2_conjuncts.iter().cloned().collect();
 
-            substituted == q2_set
+                substituted == q2_set
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for ConjunctiveQueryFoldability {
+    /// Each undistinguished variable can map to any element of `D ∪ X ∪ Y`.
+    fn dimensions(&self) -> Vec<usize> {
+        let range = self.domain_size + self.num_distinguished + self.num_undistinguished;
+        vec![range; self.num_undistinguished]
+    }
+}
+
 crate::declare_variants! {
     default ConjunctiveQueryFoldability => "(num_distinguished + num_undistinguished + domain_size)^num_undistinguished * num_conjuncts_q1",
 }
 
+crate::register_brute_force! {
+    ConjunctiveQueryFoldability,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // YES instance: triangle + self-loop folds to lollipop.
@@ -348,7 +367,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 (0, vec![Term::Undistinguished(2), Term::Distinguished(0)]), // R(a, x)
             ],
         )),
-        optimal_config: vec![3, 3, 3],
+        optimal_config: serde_json::json!(vec![3, 3, 3]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/consistency_of_database_frequency_tables.rs b/src/models/misc/consistency_of_database_frequency_tables.rs
index 04ade7a9e..b177ed320 100644
--- a/src/models/misc/consistency_of_database_frequency_tables.rs
+++ b/src/models/misc/consistency_of_database_frequency_tables.rs
@@ -6,7 +6,7 @@
 //! assignment of attribute values to all objects that matches every published
 //! frequency table and every known value.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeSet;
@@ -15,12 +15,12 @@ use std::collections::BTreeSet;
 pub struct FrequencyTable {
     attribute_a: usize,
     attribute_b: usize,
-    counts: Vec<Vec<usize>>,
+    counts: Vec<Vec<i64>>,
 }
 
 impl FrequencyTable {
     /// Create a new pairwise frequency table.
-    pub fn new(attribute_a: usize, attribute_b: usize, counts: Vec<Vec<usize>>) -> Self {
+    pub fn new(attribute_a: usize, attribute_b: usize, counts: Vec<Vec<i64>>) -> Self {
         Self {
             attribute_a,
             attribute_b,
@@ -39,7 +39,7 @@ impl FrequencyTable {
     }
 
     /// Returns the table counts.
-    pub fn counts(&self) -> &[Vec<usize>] {
+    pub fn counts(&self) -> &[Vec<i64>] {
         &self.counts
     }
 
@@ -88,14 +88,10 @@ inventory::submit! {
         display_name: "Consistency of Database Frequency Tables",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine whether pairwise frequency tables and known values admit a consistent complete database assignment",
-        fields: &[
-            FieldInfo { name: "num_objects", type_name: "usize", description: "Number of objects in the database" },
-            FieldInfo { name: "attribute_domains", type_name: "Vec<usize>", description: "Domain size for each attribute" },
-            FieldInfo { name: "frequency_tables", type_name: "Vec<FrequencyTable>", description: "Published pairwise frequency tables" },
-            FieldInfo { name: "known_values", type_name: "Vec<KnownValue>", description: "Known object-attribute-value triples" },
-        ],
+        fields: ConsistencyOfDatabaseFrequencyTablesCreateSpec::FIELDS,
     }
 }
 
@@ -108,6 +104,114 @@ pub struct ConsistencyOfDatabaseFrequencyTables {
     known_values: Vec<KnownValue>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct ConsistencyOfDatabaseFrequencyTablesCreateSpec {
+    /// Number of database objects.
+    num_objects: usize,
+    /// Domain size for each attribute.
+    #[create(codec = "comma-separated")]
+    attribute_domains: Vec<usize>,
+    /// Pairwise frequency tables as JSON objects.
+    #[create(codec = "json")]
+    frequency_tables: Vec<FrequencyTable>,
+    /// Known object-attribute values as JSON objects; defaults to empty.
+    #[create(codec = "json")]
+    known_values: Option<Vec<KnownValue>>,
+}
+
+impl TryFrom<ConsistencyOfDatabaseFrequencyTablesCreateSpec>
+    for ConsistencyOfDatabaseFrequencyTables
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: ConsistencyOfDatabaseFrequencyTablesCreateSpec) -> Result<Self, Self::Error> {
+        let known_values = spec.known_values.unwrap_or_default();
+        validate_cdft_create(
+            spec.num_objects,
+            &spec.attribute_domains,
+            &spec.frequency_tables,
+            &known_values,
+        )?;
+        Ok(Self {
+            num_objects: spec.num_objects,
+            attribute_domains: spec.attribute_domains,
+            frequency_tables: spec.frequency_tables,
+            known_values,
+        })
+    }
+}
+
+fn validate_cdft_create(
+    num_objects: usize,
+    domains: &[usize],
+    tables: &[FrequencyTable],
+    known: &[KnownValue],
+) -> Result<(), crate::registry::ConstructionError> {
+    for (attribute, &size) in domains.iter().enumerate() {
+        if size == 0 {
+            return Err(
+                format!("attribute domain size at index {attribute} must be positive").into(),
+            );
+        }
+    }
+    let mut pairs = BTreeSet::new();
+    for table in tables {
+        let a = table.attribute_a();
+        let b = table.attribute_b();
+        if a >= domains.len() || b >= domains.len() {
+            return Err("frequency table attribute is out of range".into());
+        }
+        if a == b {
+            return Err("frequency table attributes must be distinct".into());
+        }
+        let pair = if a < b { (a, b) } else { (b, a) };
+        if !pairs.insert(pair) {
+            return Err(format!("duplicate frequency table pair ({}, {})", pair.0, pair.1).into());
+        }
+        if table.counts().len() != domains[a] {
+            return Err(
+                format!("frequency table rows must equal domain size for attribute {a}").into(),
+            );
+        }
+        if table.counts().iter().any(|row| row.len() != domains[b]) {
+            return Err(format!(
+                "frequency table column count must equal domain size for attribute {b}"
+            )
+            .into());
+        }
+        if table.counts().iter().flatten().any(|&count| count < 0) {
+            return Err("frequency table counts must be nonnegative".into());
+        }
+        let total = table
+            .counts()
+            .iter()
+            .flatten()
+            .try_fold(0_i64, |sum, &value| {
+                sum.checked_add(value)
+                    .ok_or("frequency table count total overflows i64")
+            })?;
+        let expected_total =
+            i64::try_from(num_objects).map_err(|_| "num_objects cannot be represented as i64")?;
+        if total != expected_total {
+            return Err(format!(
+                "frequency table total {total} must equal num_objects {num_objects}"
+            )
+            .into());
+        }
+    }
+    for value in known {
+        if value.object() >= num_objects {
+            return Err("known value object is out of range".into());
+        }
+        if value.attribute() >= domains.len() {
+            return Err("known value attribute is out of range".into());
+        }
+        if value.value() >= domains[value.attribute()] {
+            return Err("known value value is outside the attribute domain".into());
+        }
+    }
+    Ok(())
+}
+
 impl ConsistencyOfDatabaseFrequencyTables {
     /// Create a new consistency-of-database-frequency-tables instance.
     pub fn new(
@@ -116,89 +220,13 @@ impl ConsistencyOfDatabaseFrequencyTables {
         frequency_tables: Vec<FrequencyTable>,
         known_values: Vec<KnownValue>,
     ) -> Self {
-        for (attribute, &domain_size) in attribute_domains.iter().enumerate() {
-            assert!(
-                domain_size > 0,
-                "attribute domain size at index {attribute} must be positive"
-            );
-        }
-
-        let num_attributes = attribute_domains.len();
-        let mut seen_pairs = BTreeSet::new();
-        for table in &frequency_tables {
-            let attribute_a = table.attribute_a();
-            let attribute_b = table.attribute_b();
-            assert!(
-                attribute_a < num_attributes,
-                "frequency table attribute_a {attribute_a} out of range for {num_attributes} attributes"
-            );
-            assert!(
-                attribute_b < num_attributes,
-                "frequency table attribute_b {attribute_b} out of range for {num_attributes} attributes"
-            );
-            assert!(
-                attribute_a != attribute_b,
-                "frequency table attributes must be distinct"
-            );
-
-            let pair = if attribute_a < attribute_b {
-                (attribute_a, attribute_b)
-            } else {
-                (attribute_b, attribute_a)
-            };
-            assert!(
-                seen_pairs.insert(pair),
-                "duplicate frequency table pair ({}, {})",
-                pair.0,
-                pair.1
-            );
-
-            let expected_rows = attribute_domains[attribute_a];
-            assert_eq!(
-                table.counts().len(),
-                expected_rows,
-                "frequency table rows ({}) must equal attribute_domains[{attribute_a}] ({expected_rows})",
-                table.counts().len()
-            );
-
-            let expected_cols = attribute_domains[attribute_b];
-            for (row, row_counts) in table.counts().iter().enumerate() {
-                assert_eq!(
-                    row_counts.len(),
-                    expected_cols,
-                    "frequency table columns ({}) in row {row} must equal attribute_domains[{attribute_b}] ({expected_cols})",
-                    row_counts.len()
-                );
-            }
-
-            let total: usize = table.counts().iter().flatten().copied().sum();
-            assert_eq!(
-                total, num_objects,
-                "frequency table total ({total}) must equal num_objects ({num_objects})"
-            );
-        }
-
-        for known_value in &known_values {
-            assert!(
-                known_value.object() < num_objects,
-                "known value object {} out of range for num_objects {}",
-                known_value.object(),
-                num_objects
-            );
-            assert!(
-                known_value.attribute() < num_attributes,
-                "known value attribute {} out of range for {num_attributes} attributes",
-                known_value.attribute()
-            );
-            let domain_size = attribute_domains[known_value.attribute()];
-            assert!(
-                known_value.value() < domain_size,
-                "known value value {} out of range for attribute {} with domain size {}",
-                known_value.value(),
-                known_value.attribute(),
-                domain_size
-            );
-        }
+        validate_cdft_create(
+            num_objects,
+            &attribute_domains,
+            &frequency_tables,
+            &known_values,
+        )
+        .unwrap_or_else(|error| panic!("{error}"));
 
         Self {
             num_objects,
@@ -238,6 +266,11 @@ impl ConsistencyOfDatabaseFrequencyTables {
         self.attribute_domains.iter().copied().product()
     }
 
+    /// Returns the sum of all attribute-domain sizes.
+    pub fn total_domain_size(&self) -> usize {
+        self.attribute_domains.iter().sum()
+    }
+
     /// Returns the number of object-attribute assignment variables in the direct encoding.
     pub fn num_assignment_variables(&self) -> usize {
         self.num_objects * self.num_attributes()
@@ -278,65 +311,96 @@ impl ConsistencyOfDatabaseFrequencyTables {
 
 impl Problem for ConsistencyOfDatabaseFrequencyTables {
     const NAME: &'static str = "ConsistencyOfDatabaseFrequencyTables";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_objects", num_objects),
+        ("num_attributes", num_attributes),
+        ("total_domain_size", total_domain_size),
+        ("domain_size_product", domain_size_product),
+        ("num_frequency_tables", num_frequency_tables),
+        ("num_frequency_cells", num_frequency_cells),
+        ("num_known_values", num_known_values),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let mut dims = Vec::with_capacity(self.num_assignment_variables());
-        for _ in 0..self.num_objects {
-            dims.extend(self.attribute_domains.iter().copied());
-        }
-        dims
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_assignment_variables() {
-                return crate::types::Or(false);
-            }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_assignment_variables() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "table-assignment length does not match the instance".into(),
+                    ));
+                }
 
-            for object in 0..self.num_objects {
-                for (attribute, &domain_size) in self.attribute_domains.iter().enumerate() {
-                    if config[self.config_index(object, attribute)] >= domain_size {
-                        return crate::types::Or(false);
+                for object in 0..self.num_objects {
+                    for (attribute, &domain_size) in self.attribute_domains.iter().enumerate() {
+                        if config[self.config_index(object, attribute)] >= domain_size {
+                            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                                "table assignment contains an out-of-range domain value".into(),
+                            ));
+                        }
                     }
                 }
-            }
 
-            for known_value in &self.known_values {
-                if config[self.config_index(known_value.object(), known_value.attribute())]
-                    != known_value.value()
-                {
-                    return crate::types::Or(false);
+                for known_value in &self.known_values {
+                    if config[self.config_index(known_value.object(), known_value.attribute())]
+                        != known_value.value()
+                    {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
-            }
-
-            for table in &self.frequency_tables {
-                let rows = self.attribute_domains[table.attribute_a()];
-                let cols = self.attribute_domains[table.attribute_b()];
-                let mut observed = vec![vec![0usize; cols]; rows];
 
-                for object in 0..self.num_objects {
-                    let value_a = config[self.config_index(object, table.attribute_a())];
-                    let value_b = config[self.config_index(object, table.attribute_b())];
-                    observed[value_a][value_b] += 1;
-                }
+                for table in &self.frequency_tables {
+                    let rows = self.attribute_domains[table.attribute_a()];
+                    let cols = self.attribute_domains[table.attribute_b()];
+                    let mut observed = vec![vec![0_i64; cols]; rows];
+
+                    for object in 0..self.num_objects {
+                        let value_a = config[self.config_index(object, table.attribute_a())];
+                        let value_b = config[self.config_index(object, table.attribute_b())];
+                        observed[value_a][value_b] =
+                            observed[value_a][value_b].checked_add(1).ok_or_else(|| {
+                                crate::traits::EvaluationError::IntegerOverflow(
+                                    "counting observed database frequencies".to_string(),
+                                )
+                            })?;
+                    }
 
-                if observed != table.counts {
-                    return crate::types::Or(false);
+                    if observed != table.counts {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for ConsistencyOfDatabaseFrequencyTables {
+    fn dimensions(&self) -> Vec<usize> {
+        let mut dims = Vec::with_capacity(self.num_assignment_variables());
+        for _ in 0..self.num_objects {
+            dims.extend(self.attribute_domains.iter().copied());
+        }
+        dims
+    }
+}
+
 crate::declare_variants! {
-    default ConsistencyOfDatabaseFrequencyTables => "domain_size_product^num_objects",
+    default ConsistencyOfDatabaseFrequencyTables => "domain_size_product^num_objects" create ConsistencyOfDatabaseFrequencyTablesCreateSpec,
+}
+
+crate::register_brute_force! {
+    ConsistencyOfDatabaseFrequencyTables,
 }
 
 #[cfg(feature = "example-db")]
@@ -356,7 +420,9 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 KnownValue::new(1, 2, 1),
             ],
         )),
-        optimal_config: vec![0, 0, 0, 0, 1, 1, 0, 2, 1, 1, 0, 1, 1, 1, 1, 1, 2, 0],
+        optimal_config: serde_json::json!(vec![
+            0, 0, 0, 0, 1, 1, 0, 2, 1, 1, 0, 1, 1, 1, 1, 1, 2, 0
+        ]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/cosine_product_integration.rs b/src/models/misc/cosine_product_integration.rs
index 1716cc770..824e46e09 100644
--- a/src/models/misc/cosine_product_integration.rs
+++ b/src/models/misc/cosine_product_integration.rs
@@ -19,6 +19,7 @@ inventory::submit! {
         display_name: "Cosine Product Integration",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Decide whether a balanced sign assignment exists for a sequence of integer frequencies",
         fields: &[
@@ -45,12 +46,12 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::CosineProductIntegration;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // coefficients [2, 3, 5]: sign assignment (+2, +3, -5) = 0
 /// let problem = CosineProductIntegration::new(vec![2, 3, 5]);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -85,39 +86,54 @@ impl CosineProductIntegration {
 
 impl Problem for CosineProductIntegration {
     const NAME: &'static str = "CosineProductIntegration";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_coefficients", num_coefficients),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_coefficients()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_coefficients() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "sign-selection length does not match the coefficients".into(),
+                    ));
+                }
+                let signed_sum = self.coefficients.iter().zip(config.iter()).try_fold(
+                    0_i64,
+                    |total, (&coefficient, &bit)| {
+                        let term = if !bit {
+                            coefficient
+                        } else {
+                            coefficient.checked_neg().ok_or_else(|| {
+                                crate::traits::EvaluationError::IntegerOverflow(
+                                    "negating cosine-product coefficient".into(),
+                                )
+                            })?
+                        };
+                        total.checked_add(term).ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "summing signed cosine-product coefficients".into(),
+                            )
+                        })
+                    },
+                )?;
+                signed_sum == 0
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_coefficients() {
-                return crate::types::Or(false);
-            }
-            if config.iter().any(|&v| v >= 2) {
-                return crate::types::Or(false);
-            }
-            let signed_sum: i128 = self
-                .coefficients
-                .iter()
-                .zip(config.iter())
-                .map(|(&a, &bit)| {
-                    let val = a as i128;
-                    if bit == 0 {
-                        val
-                    } else {
-                        -val
-                    }
-                })
-                .sum();
-            signed_sum == 0
-        })
+impl crate::solvers::BruteForceProblem for CosineProductIntegration {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_coefficients()]
     }
 }
 
@@ -125,12 +141,16 @@ crate::declare_variants! {
     default CosineProductIntegration => "2^(num_coefficients / 2)",
 }
 
+crate::register_brute_force! {
+    CosineProductIntegration decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "cosine_product_integration",
         instance: Box::new(CosineProductIntegration::new(vec![2, 3, 5])),
-        optimal_config: vec![0, 0, 1],
+        optimal_config: serde_json::json!(vec![false, false, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/cyclic_ordering.rs b/src/models/misc/cyclic_ordering.rs
index 9087fe497..0edaffe5f 100644
--- a/src/models/misc/cyclic_ordering.rs
+++ b/src/models/misc/cyclic_ordering.rs
@@ -6,7 +6,7 @@
 //! in cyclic order — i.e., (f(a) < f(b) < f(c)) ∨ (f(b) < f(c) < f(a))
 //! ∨ (f(c) < f(a) < f(b)).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -18,6 +18,7 @@ inventory::submit! {
         display_name: "Cyclic Ordering",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a permutation satisfying cyclic ordering constraints on triples",
         fields: &[
@@ -27,13 +28,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "CyclicOrdering",
-        fields: &["num_elements", "num_triples"],
-    }
-}
-
 #[derive(Debug, Clone, Serialize)]
 pub struct CyclicOrdering {
     num_elements: usize,
@@ -44,22 +38,24 @@ impl CyclicOrdering {
     fn validate_inputs(
         num_elements: usize,
         triples: &[(usize, usize, usize)],
-    ) -> Result<(), String> {
+    ) -> Result<(), crate::registry::ConstructionError> {
         if num_elements == 0 {
-            return Err("CyclicOrdering requires at least one element".to_string());
+            return Err("CyclicOrdering requires at least one element"
+                .to_string()
+                .into());
         }
         for (i, &(a, b, c)) in triples.iter().enumerate() {
             if a >= num_elements || b >= num_elements || c >= num_elements {
                 return Err(format!(
                     "Triple {} has element(s) out of range 0..{}",
                     i, num_elements
-                ));
+                )
+                .into());
             }
             if a == b || b == c || a == c {
-                return Err(format!(
-                    "Triple {} has duplicate elements ({}, {}, {})",
-                    i, a, b, c
-                ));
+                return Err(
+                    format!("Triple {} has duplicate elements ({}, {}, {})", i, a, b, c).into(),
+                );
             }
         }
         Ok(())
@@ -68,7 +64,7 @@ impl CyclicOrdering {
     pub fn try_new(
         num_elements: usize,
         triples: Vec<(usize, usize, usize)>,
-    ) -> Result<Self, String> {
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate_inputs(num_elements, &triples)?;
         Ok(Self {
             num_elements,
@@ -154,18 +150,33 @@ impl<'de> Deserialize<'de> for CyclicOrdering {
 
 impl Problem for CyclicOrdering {
     const NAME: &'static str = "CyclicOrdering";
+    type Solution = Vec<usize>;
     type Value = Or;
 
+    crate::problem_parameters![("num_elements", num_elements), ("num_triples", num_triples),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_elements; self.num_elements]
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_elements {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "ordering length does not match the elements".into(),
+            ));
+        }
+        if config.iter().any(|&position| position >= self.num_elements) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "ordering contains an out-of-range position".into(),
+            ));
+        }
+        Ok(Or(self.is_valid_solution(config)))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or(self.is_valid_solution(config))
+impl crate::solvers::BruteForceProblem for CyclicOrdering {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_elements; self.num_elements]
     }
 }
 
@@ -173,6 +184,10 @@ crate::declare_variants! {
     default CyclicOrdering => "factorial(num_elements)",
 }
 
+crate::register_brute_force! {
+    CyclicOrdering,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -181,7 +196,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             5,
             vec![(0, 1, 2), (2, 3, 0), (1, 3, 4)],
         )),
-        optimal_config: vec![1, 3, 4, 0, 2],
+        optimal_config: serde_json::json!(vec![1, 3, 4, 0, 2]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/dynamic_storage_allocation.rs b/src/models/misc/dynamic_storage_allocation.rs
index adcba4d93..37ccb3c60 100644
--- a/src/models/misc/dynamic_storage_allocation.rs
+++ b/src/models/misc/dynamic_storage_allocation.rs
@@ -5,7 +5,7 @@
 //! address such that every item fits within [0, D-1] and no two
 //! time-overlapping items share memory addresses.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Dynamic Storage Allocation",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Assign starting addresses for items with time intervals and sizes within bounded memory",
         fields: &[
@@ -26,13 +27,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "DynamicStorageAllocation",
-        fields: &["num_items", "memory_size"],
-    }
-}
-
 /// Dynamic Storage Allocation problem.
 ///
 /// Each item `a` has arrival time `r(a)`, departure time `d(a)`, and size `s(a)`.
@@ -45,33 +39,43 @@ pub struct DynamicStorageAllocation {
 }
 
 impl DynamicStorageAllocation {
-    fn validate_inputs(items: &[(usize, usize, usize)], memory_size: usize) -> Result<(), String> {
+    fn validate_inputs(
+        items: &[(usize, usize, usize)],
+        memory_size: usize,
+    ) -> Result<(), crate::registry::ConstructionError> {
         if items.is_empty() {
-            return Err("DynamicStorageAllocation requires at least one item".to_string());
+            return Err("DynamicStorageAllocation requires at least one item"
+                .to_string()
+                .into());
         }
         if memory_size == 0 {
-            return Err("DynamicStorageAllocation requires a positive memory_size".to_string());
+            return Err("DynamicStorageAllocation requires a positive memory_size"
+                .to_string()
+                .into());
         }
         for (i, &(arrival, departure, size)) in items.iter().enumerate() {
             if size == 0 {
-                return Err(format!("Item {i} has zero size; all sizes must be >= 1"));
+                return Err(format!("Item {i} has zero size; all sizes must be >= 1").into());
             }
             if departure <= arrival {
                 return Err(format!(
                     "Item {i} has departure ({departure}) <= arrival ({arrival}); departure must be strictly greater"
-                ));
+                ).into());
             }
             if size > memory_size {
                 return Err(format!(
                     "Item {i} has size ({size}) > memory_size ({memory_size}); every item must fit in memory"
-                ));
+                ).into());
             }
         }
         Ok(())
     }
 
     /// Try to create a new `DynamicStorageAllocation` instance.
-    pub fn try_new(items: Vec<(usize, usize, usize)>, memory_size: usize) -> Result<Self, String> {
+    pub fn try_new(
+        items: Vec<(usize, usize, usize)>,
+        memory_size: usize,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate_inputs(&items, memory_size)?;
         Ok(Self { items, memory_size })
     }
@@ -119,58 +123,71 @@ impl<'de> Deserialize<'de> for DynamicStorageAllocation {
 
 impl Problem for DynamicStorageAllocation {
     const NAME: &'static str = "DynamicStorageAllocation";
+    type Solution = Vec<usize>;
     type Value = Or;
 
+    crate::problem_parameters![("memory_size", memory_size), ("num_items", num_items),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        self.items
-            .iter()
-            .map(|&(_, _, s)| self.memory_size - s + 1)
-            .collect()
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or({
-            if config.len() != self.num_items() {
-                return Or(false);
-            }
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            Or({
+                if config.len() != self.num_items() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "allocation length does not match the number of items".into(),
+                    ));
+                }
 
-            // Check each item fits within memory
-            for (i, &(_, _, size)) in self.items.iter().enumerate() {
-                let start = config[i];
-                if start + size > self.memory_size {
-                    return Or(false);
+                // Check each item fits within memory
+                for (i, &(_, _, size)) in self.items.iter().enumerate() {
+                    let start = config[i];
+                    if start + size > self.memory_size {
+                        return Ok(Or(false));
+                    }
                 }
-            }
 
-            // Check all pairs of time-overlapping items for memory non-overlap
-            for (i, &(r_i, d_i, s_i)) in self.items.iter().enumerate() {
-                let sigma_i = config[i];
-                for (j, &(r_j, d_j, s_j)) in self.items.iter().enumerate().skip(i + 1) {
-                    // Time overlap: r_i < d_j AND r_j < d_i
-                    if r_i < d_j && r_j < d_i {
-                        let sigma_j = config[j];
-                        // Memory overlap: NOT (sigma_i + s_i <= sigma_j OR sigma_j + s_j <= sigma_i)
-                        let no_memory_overlap =
-                            sigma_i + s_i <= sigma_j || sigma_j + s_j <= sigma_i;
-                        if !no_memory_overlap {
-                            return Or(false);
+                // Check all pairs of time-overlapping items for memory non-overlap
+                for (i, &(r_i, d_i, s_i)) in self.items.iter().enumerate() {
+                    let sigma_i = config[i];
+                    for (j, &(r_j, d_j, s_j)) in self.items.iter().enumerate().skip(i + 1) {
+                        // Time overlap: r_i < d_j AND r_j < d_i
+                        if r_i < d_j && r_j < d_i {
+                            let sigma_j = config[j];
+                            // Memory overlap: NOT (sigma_i + s_i <= sigma_j OR sigma_j + s_j <= sigma_i)
+                            let no_memory_overlap =
+                                sigma_i + s_i <= sigma_j || sigma_j + s_j <= sigma_i;
+                            if !no_memory_overlap {
+                                return Ok(Or(false));
+                            }
                         }
                     }
                 }
-            }
-            true
+                true
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for DynamicStorageAllocation {
+    fn dimensions(&self) -> Vec<usize> {
+        self.items
+            .iter()
+            .map(|&(_, _, s)| self.memory_size - s + 1)
+            .collect()
+    }
+}
+
 crate::declare_variants! {
     default DynamicStorageAllocation => "(memory_size + 1)^num_items",
 }
 
+crate::register_brute_force! {
+    DynamicStorageAllocation,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -179,7 +196,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![(0, 3, 2), (0, 2, 3), (1, 4, 1), (2, 5, 3), (3, 5, 2)],
             6,
         )),
-        optimal_config: vec![0, 2, 5, 2, 0],
+        optimal_config: serde_json::json!(vec![0, 2, 5, 2, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/ensemble_computation.rs b/src/models/misc/ensemble_computation.rs
index 479e7eb48..abe93a81c 100644
--- a/src/models/misc/ensemble_computation.rs
+++ b/src/models/misc/ensemble_computation.rs
@@ -11,6 +11,7 @@ inventory::submit! {
         display_name: "Ensemble Computation",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find the minimum-length sequence of disjoint unions that builds all required subsets",
         fields: &[
@@ -55,9 +56,9 @@ impl EnsembleComputation {
         universe_size: usize,
         subsets: Vec<Vec<usize>>,
         budget: usize,
-    ) -> Result<Self, String> {
+    ) -> Result<Self, crate::registry::ConstructionError> {
         if budget == 0 {
-            return Err("budget must be positive".to_string());
+            return Err("budget must be positive".to_string().into());
         }
         let subsets = subsets
             .into_iter()
@@ -164,47 +165,61 @@ impl EnsembleComputation {
 
 impl Problem for EnsembleComputation {
     const NAME: &'static str = "EnsembleComputation";
-    type Value = Min<usize>;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![self.universe_size + self.budget; 2 * self.budget]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if config.len() != 2 * self.budget {
-            return Min(None);
-        }
-
-        let Some(required_subsets) = self.required_subsets() else {
-            return Min(None);
-        };
-        if required_subsets.is_empty() {
-            return Min(Some(0));
-        }
-
-        let mut computed = Vec::with_capacity(self.budget);
-        for step in 0..self.budget {
-            let left_operand = config[2 * step];
-            let right_operand = config[2 * step + 1];
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("budget", budget),
+        ("num_subsets", num_subsets),
+        ("universe_size", universe_size),
+    ];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != 2 * self.budget {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "ensemble program length does not match the operation budget".into(),
+                ));
+            }
 
-            let Some(left) = self.decode_operand(left_operand, &computed) else {
-                return Min(None);
-            };
-            let Some(right) = self.decode_operand(right_operand, &computed) else {
-                return Min(None);
+            let Some(required_subsets) = self.required_subsets() else {
+                return Ok(Min(None));
             };
-
-            if !Self::are_disjoint(&left, &right) {
-                return Min(None);
+            if required_subsets.is_empty() {
+                return Ok(Min(Some(0)));
             }
 
-            computed.push(Self::union_disjoint(&left, &right));
-            if Self::all_required_subsets_present(&required_subsets, &computed) {
-                return Min(Some(step + 1));
+            let mut computed = Vec::with_capacity(self.budget);
+            for step in 0..self.budget {
+                let left_operand = config[2 * step];
+                let right_operand = config[2 * step + 1];
+
+                let Some(left) = self.decode_operand(left_operand, &computed) else {
+                    return Ok(Min(None));
+                };
+                let Some(right) = self.decode_operand(right_operand, &computed) else {
+                    return Ok(Min(None));
+                };
+
+                if !Self::are_disjoint(&left, &right) {
+                    return Ok(Min(None));
+                }
+
+                computed.push(Self::union_disjoint(&left, &right));
+                if Self::all_required_subsets_present(&required_subsets, &computed) {
+                    return Ok(Min(Some(i64::try_from(step + 1).map_err(|_| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "converting union-operation count to i64".into(),
+                        )
+                    })?)));
+                }
             }
-        }
 
-        Min(None)
+            Min(None)
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -212,10 +227,20 @@ impl Problem for EnsembleComputation {
     }
 }
 
+impl crate::solvers::BruteForceProblem for EnsembleComputation {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.universe_size + self.budget; 2 * self.budget]
+    }
+}
+
 crate::declare_variants! {
     default EnsembleComputation => "(universe_size + budget)^(2 * budget)",
 }
 
+crate::register_brute_force! {
+    EnsembleComputation,
+}
+
 #[derive(Debug, Clone, Deserialize)]
 struct EnsembleComputationDef {
     universe_size: usize,
@@ -224,7 +249,7 @@ struct EnsembleComputationDef {
 }
 
 impl TryFrom<EnsembleComputationDef> for EnsembleComputation {
-    type Error = String;
+    type Error = crate::registry::ConstructionError;
 
     fn try_from(value: EnsembleComputationDef) -> Result<Self, Self::Error> {
         Self::try_new(value.universe_size, value.subsets, value.budget)
@@ -242,7 +267,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![vec![0, 1], vec![0, 1, 2]],
             2,
         )),
-        optimal_config: vec![0, 1, 3, 2],
+        optimal_config: serde_json::json!(vec![0, 1, 3, 2]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/misc/expected_retrieval_cost.rs b/src/models/misc/expected_retrieval_cost.rs
index 573e6f49d..a904aa39b 100644
--- a/src/models/misc/expected_retrieval_cost.rs
+++ b/src/models/misc/expected_retrieval_cost.rs
@@ -3,7 +3,7 @@
 //! Given record access probabilities, find an assignment of records to circular
 //! storage sectors that minimizes the expected rotational latency.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{ConstructionError, FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Expected Retrieval Cost",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Assign records to circular storage sectors to minimize expected retrieval latency",
         fields: &[
@@ -25,48 +26,51 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "ExpectedRetrievalCost",
-        fields: &["num_records", "num_sectors"],
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct ExpectedRetrievalCost {
     probabilities: Vec<f64>,
     num_sectors: usize,
 }
 
 impl ExpectedRetrievalCost {
-    pub fn new(probabilities: Vec<f64>, num_sectors: usize) -> Self {
-        assert!(
-            !probabilities.is_empty(),
-            "ExpectedRetrievalCost requires at least one record"
-        );
-        assert!(
-            num_sectors >= 2,
-            "ExpectedRetrievalCost requires at least two sectors"
-        );
-        for &probability in &probabilities {
-            assert!(
-                probability.is_finite(),
-                "probabilities must be finite real numbers"
-            );
-            assert!(
-                (0.0..=1.0).contains(&probability),
-                "probabilities must lie in [0, 1]"
-            );
+    pub fn new(probabilities: Vec<f64>, num_sectors: usize) -> Result<Self, ConstructionError> {
+        if probabilities.is_empty() {
+            return Err(ConstructionError::Conversion(
+                "ExpectedRetrievalCost requires at least one record".into(),
+            ));
+        }
+        if num_sectors < 2 {
+            return Err(ConstructionError::Conversion(
+                "ExpectedRetrievalCost requires at least two sectors".into(),
+            ));
+        }
+        for (index, &probability) in probabilities.iter().enumerate() {
+            if !probability.is_finite() {
+                return Err(ConstructionError::NonFiniteFloat(format!(
+                    "probability at index {index} must be finite"
+                )));
+            }
+            if !(0.0..=1.0).contains(&probability) {
+                return Err(ConstructionError::Conversion(format!(
+                    "probability at index {index} must lie in [0, 1]"
+                )));
+            }
         }
         let total_probability: f64 = probabilities.iter().sum();
-        assert!(
-            (total_probability - 1.0).abs() <= FLOAT_TOLERANCE,
-            "probabilities must sum to 1.0"
-        );
-        Self {
+        if !total_probability.is_finite() || (total_probability - 1.0).abs() > FLOAT_TOLERANCE {
+            if !total_probability.is_finite() {
+                return Err(ConstructionError::NonFiniteFloat(
+                    "summing probabilities produced a non-finite value".into(),
+                ));
+            }
+            return Err(ConstructionError::Conversion(
+                "probabilities must sum to 1.0".into(),
+            ));
+        }
+        Ok(Self {
             probabilities,
             num_sectors,
-        }
+        })
     }
 
     pub fn probabilities(&self) -> &[f64] {
@@ -81,56 +85,125 @@ impl ExpectedRetrievalCost {
         self.num_sectors
     }
 
-    pub fn sector_masses(&self, config: &[usize]) -> Option<Vec<f64>> {
+    pub fn sector_masses(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<Vec<f64>>, crate::traits::EvaluationError> {
         if config.len() != self.num_records() {
-            return None;
+            return Ok(None);
         }
 
         let mut masses = vec![0.0; self.num_sectors];
         for (record, &sector) in config.iter().enumerate() {
             if sector >= self.num_sectors {
-                return None;
+                return Ok(None);
             }
-            masses[sector] += self.probabilities[record];
+            let mass = masses[sector] + self.probabilities[record];
+            if !mass.is_finite() {
+                return Err(crate::traits::EvaluationError::NonFiniteResult(
+                    "summing expected-retrieval sector probabilities".to_string(),
+                ));
+            }
+            masses[sector] = mass;
         }
-        Some(masses)
+        Ok(Some(masses))
     }
 
-    pub fn expected_cost(&self, config: &[usize]) -> Option<f64> {
-        let masses = self.sector_masses(config)?;
+    pub fn expected_cost(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<f64>, crate::traits::EvaluationError> {
+        let Some(masses) = self.sector_masses(config)? else {
+            return Ok(None);
+        };
         let mut total = 0.0;
         for source in 0..self.num_sectors {
             for target in 0..self.num_sectors {
-                total += masses[source]
-                    * masses[target]
-                    * latency_distance(self.num_sectors, source, target) as f64;
+                let latency = i64::try_from(latency_distance(self.num_sectors, source, target))
+                    .map_err(|_| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "converting expected-retrieval latency to i64".to_string(),
+                        )
+                    })?;
+                let latency = crate::types::i64_to_exact_f64(latency).map_err(|_| {
+                    crate::traits::EvaluationError::InexactFloatConversion(
+                        "converting expected-retrieval latency to f64".to_string(),
+                    )
+                })?;
+                let term = masses[source] * masses[target] * latency;
+                let next = total + term;
+                if !term.is_finite() || !next.is_finite() {
+                    return Err(crate::traits::EvaluationError::NonFiniteResult(
+                        "computing expected retrieval cost".to_string(),
+                    ));
+                }
+                total = next;
             }
         }
-        Some(total)
+        Ok(Some(total))
     }
 
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.expected_cost(config).is_some()
+    pub fn is_valid_solution(
+        &self,
+        config: &[usize],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(self.expected_cost(config)?.is_some())
+    }
+}
+
+#[derive(Deserialize)]
+struct ExpectedRetrievalCostData {
+    probabilities: Vec<f64>,
+    num_sectors: usize,
+}
+
+impl<'de> Deserialize<'de> for ExpectedRetrievalCost {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let data = ExpectedRetrievalCostData::deserialize(deserializer)?;
+        Self::new(data.probabilities, data.num_sectors).map_err(serde::de::Error::custom)
     }
 }
 
 impl Problem for ExpectedRetrievalCost {
     const NAME: &'static str = "ExpectedRetrievalCost";
+    type Solution = Vec<usize>;
     type Value = Min<f64>;
 
+    crate::problem_parameters![("num_records", num_records), ("num_sectors", num_sectors),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_sectors; self.num_records()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<f64>, crate::traits::EvaluationError> {
+        if config.len() != self.num_records() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "sector assignment length does not match the records".into(),
+            ));
+        }
+        if config.iter().any(|&sector| sector >= self.num_sectors) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "sector assignment contains an out-of-range sector".into(),
+            ));
+        }
+        Ok({
+            match self.expected_cost(config)? {
+                Some(cost) => Min(Some(cost)),
+                None => Min(None),
+            }
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<f64> {
-        match self.expected_cost(config) {
-            Some(cost) => Min(Some(cost)),
-            None => Min(None),
-        }
+impl crate::solvers::BruteForceProblem for ExpectedRetrievalCost {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_sectors; self.num_records()]
     }
 }
 
@@ -146,15 +219,18 @@ crate::declare_variants! {
     default ExpectedRetrievalCost => "num_sectors ^ num_records",
 }
 
+crate::register_brute_force! {
+    ExpectedRetrievalCost,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "expected_retrieval_cost",
-        instance: Box::new(ExpectedRetrievalCost::new(
-            vec![0.2, 0.15, 0.15, 0.2, 0.1, 0.2],
-            3,
-        )),
-        optimal_config: vec![0, 1, 2, 1, 0, 2],
+        instance: Box::new(
+            ExpectedRetrievalCost::new(vec![0.2, 0.15, 0.15, 0.2, 0.1, 0.2], 3).unwrap(),
+        ),
+        optimal_config: serde_json::json!(vec![0, 1, 2, 1, 0, 2]),
         optimal_value: serde_json::json!(1.0025),
     }]
 }
diff --git a/src/models/misc/factoring.rs b/src/models/misc/factoring.rs
index 9b72b2754..eae8f35da 100644
--- a/src/models/misc/factoring.rs
+++ b/src/models/misc/factoring.rs
@@ -3,9 +3,11 @@
 //! The Factoring problem represents integer factorization as a computational problem.
 //! Given a number N, find two factors (a, b) such that a * b = N.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{ConstructionError, CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
-use crate::types::Min;
+use crate::types::Or;
+use num_bigint::{BigUint, ToBigUint};
+use num_traits::{One, Zero};
 use serde::{Deserialize, Serialize};
 
 inventory::submit! {
@@ -14,142 +16,220 @@ inventory::submit! {
         display_name: "Factoring",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Factor a composite integer into two factors",
-        fields: &[
-            FieldInfo { name: "m", type_name: "usize", description: "Bits for first factor" },
-            FieldInfo { name: "n", type_name: "usize", description: "Bits for second factor" },
-            FieldInfo { name: "target", type_name: "u64", description: "Number to factor" },
-        ],
+        fields: FactoringCreateSpec::FIELDS,
     }
 }
 
 /// The Integer Factoring problem.
 ///
-/// Given a number to factor, find two integers that multiply to give
-/// the target number. Variables represent the bits of the two factors.
+/// Given a number to factor, find two ordered integers that multiply to give
+/// the target number. Variables represent the bits of the two factors. Factor
+/// widths may be supplied explicitly or derived from the target bit length.
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::misc::Factoring;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
-/// // Factor 6 with 2-bit factors (allowing factors 0-3)
-/// let problem = Factoring::new(2, 2, 6);
+/// // Factor 6 using the derived 2-bit factor widths.
+/// let problem = Factoring::new(6);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
-/// // Should find: 2*3=6 or 3*2=6
-/// for sol in &solutions {
-///     let (a, b) = problem.read_factors(sol);
-///     assert_eq!(a * b, 6);
+/// // The canonical factor order finds 2*3=6.
+/// for (a, b) in &solutions {
+///     assert_eq!(a * b, num_bigint::BigUint::from(6u32));
 /// }
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct Factoring {
     /// Number of bits for the first factor.
     m: usize,
     /// Number of bits for the second factor.
     n: usize,
     /// The number to factor.
-    target: u64,
+    #[serde(with = "super::biguint_serde::decimal_biguint")]
+    target: BigUint,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct FactoringCreateSpec {
+    /// Number to factor.
+    #[serde(with = "super::biguint_serde::decimal_biguint")]
+    target: BigUint,
+    /// Optional maximum bit width of the smaller factor.
+    m: Option<usize>,
+    /// Optional maximum bit width of the larger factor.
+    n: Option<usize>,
+}
+
+impl TryFrom<FactoringCreateSpec> for Factoring {
+    type Error = ConstructionError;
+
+    fn try_from(spec: FactoringCreateSpec) -> Result<Self, Self::Error> {
+        match (spec.m, spec.n) {
+            (None, None) => Ok(Self::from_target(spec.target)),
+            (Some(m), Some(n)) if m <= n => Ok(Self {
+                m,
+                n,
+                target: spec.target,
+            }),
+            (Some(m), Some(n)) => Err(format!(
+                "first factor width m={m} must not exceed second factor width n={n}"
+            )
+            .into()),
+            _ => Err("factor widths m and n must be provided together".into()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for Factoring {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let spec = FactoringCreateSpec::deserialize(deserializer)?;
+        Self::try_from(spec).map_err(serde::de::Error::custom)
+    }
 }
 
 impl Factoring {
-    /// Create a new Factoring problem.
+    /// Create a Factoring problem with widths derived from the target.
     ///
     /// # Arguments
-    /// * `m` - Number of bits for the first factor
-    /// * `n` - Number of bits for the second factor
     /// * `target` - The number to factor
-    pub fn new(m: usize, n: usize, target: u64) -> Self {
+    pub fn new<T: ToBigUint>(target: T) -> Self {
+        let target = target
+            .to_biguint()
+            .expect("Factoring target must be nonnegative");
+        Self::from_target(target)
+    }
+
+    fn from_target(target: BigUint) -> Self {
+        let target_bits =
+            usize::try_from(target.bits().max(1)).expect("BigUint bit length fits usize");
+        let smaller_width = target_bits.div_ceil(2);
+        let larger_width = target_bits.saturating_sub(1);
+        let (m, n) = (
+            smaller_width.min(larger_width),
+            smaller_width.max(larger_width),
+        );
         Self { m, n, target }
     }
 
-    /// Get the number of bits for the first factor.
+    /// Create a Factoring problem with explicit maximum factor widths.
+    ///
+    /// The first factor is canonicalized as the smaller factor, so `m` must
+    /// not exceed `n`. Explicit widths may admit the trivial factorization
+    /// `(1, target)`.
+    pub fn with_factor_bits<T: ToBigUint>(target: T, m: usize, n: usize) -> Self {
+        assert!(
+            m <= n,
+            "first factor width m must not exceed second factor width n"
+        );
+        let target = target
+            .to_biguint()
+            .expect("Factoring target must be nonnegative");
+        Self { m, n, target }
+    }
+
+    /// Get the maximum number of bits for the smaller factor.
     pub fn m(&self) -> usize {
         self.m
     }
 
-    /// Get the number of bits for the second factor.
+    /// Get the maximum number of bits for the larger factor.
     pub fn n(&self) -> usize {
         self.n
     }
 
-    /// Get the number of bits for the first factor (alias for `m()`).
+    /// Get the maximum number of bits for the smaller factor (alias for `m()`).
     pub fn num_bits_first(&self) -> usize {
         self.m()
     }
 
-    /// Get the number of bits for the second factor (alias for `n()`).
+    /// Get the maximum number of bits for the larger factor (alias for `n()`).
     pub fn num_bits_second(&self) -> usize {
         self.n()
     }
 
     /// Get the target number to factor.
-    pub fn target(&self) -> u64 {
-        self.target
+    pub fn target(&self) -> &BigUint {
+        &self.target
+    }
+
+    /// Number of bits needed to represent the target (`1` for zero).
+    pub fn target_bits(&self) -> usize {
+        usize::try_from(self.target.bits().max(1)).expect("BigUint bit length fits usize")
     }
 
     /// Read the two factors from a configuration.
     ///
     /// The first `m` bits represent the first factor,
     /// the next `n` bits represent the second factor.
-    pub fn read_factors(&self, config: &[usize]) -> (u64, u64) {
-        let a = bits_to_int(&config[..self.m]);
-        let b = bits_to_int(&config[self.m..self.m + self.n]);
+    fn decode_factors(&self, config: &[usize]) -> (BigUint, BigUint) {
+        let a = bits_to_biguint(&config[..self.m]);
+        let b = bits_to_biguint(&config[self.m..self.m + self.n]);
         (a, b)
     }
 
     /// Check if a configuration is a valid factorization.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.is_valid_factorization(config)
+    pub fn is_valid_solution(&self, solution: &(BigUint, BigUint)) -> bool {
+        self.is_valid_factorization(solution)
     }
 
     /// Check if the configuration is a valid factorization.
-    pub fn is_valid_factorization(&self, config: &[usize]) -> bool {
-        let (a, b) = self.read_factors(config);
-        a * b == self.target
+    pub fn is_valid_factorization(&self, solution: &(BigUint, BigUint)) -> bool {
+        let (left, right) = solution;
+        left.bits() <= u64::try_from(self.m).expect("factor width fits u64")
+            && right.bits() <= u64::try_from(self.n).expect("factor width fits u64")
+            && left <= right
+            && left * right == self.target
     }
 }
 
 /// Convert a bit vector (little-endian) to an integer.
-fn bits_to_int(bits: &[usize]) -> u64 {
-    bits.iter().enumerate().map(|(i, &b)| (b as u64) << i).sum()
+fn bits_to_biguint(bits: &[usize]) -> BigUint {
+    bits.iter()
+        .enumerate()
+        .filter(|(_, bit)| **bit == 1)
+        .fold(BigUint::zero(), |value, (index, _)| {
+            value + (BigUint::one() << index)
+        })
 }
 
 /// Convert an integer to a bit vector (little-endian).
 #[allow(dead_code)]
-fn int_to_bits(n: u64, num_bits: usize) -> Vec<usize> {
-    (0..num_bits).map(|i| ((n >> i) & 1) as usize).collect()
+fn int_to_bits(n: &BigUint, num_bits: usize) -> Vec<usize> {
+    (0..num_bits)
+        .map(|index| usize::from(n.bit(u64::try_from(index).expect("bit index fits u64"))))
+        .collect()
 }
 
 /// Check if the given factors correctly factorize the target.
 #[cfg(test)]
-pub(crate) fn is_factoring(target: u64, a: u64, b: u64) -> bool {
-    a * b == target
+pub(crate) fn is_factoring(target: &BigUint, a: &BigUint, b: &BigUint) -> bool {
+    a * b == *target
 }
 
 impl Problem for Factoring {
     const NAME: &'static str = "Factoring";
-    type Value = Min<i32>;
+    type Solution = (BigUint, BigUint);
+    type Value = Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.m + self.n]
-    }
+    crate::problem_parameters![
+        ("num_bits_first", num_bits_first),
+        ("num_bits_second", num_bits_second),
+        ("target_bits", target_bits),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> Min<i32> {
-        let (a, b) = self.read_factors(config);
-        let product = a * b;
-        // Distance from target (0 means exact match)
-        let distance = if product > self.target {
-            (product - self.target) as i32
-        } else {
-            (self.target - product) as i32
-        };
-        Min(Some(distance))
+    fn evaluate(&self, solution: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok(Or(self.is_valid_factorization(solution)))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -157,17 +237,28 @@ impl Problem for Factoring {
     }
 }
 
+impl crate::solvers::BruteForceProblem for Factoring {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.m + self.n]
+    }
+}
+
 crate::declare_variants! {
-    default Factoring => "exp((m + n)^(1/3) * log(m + n)^(2/3))",
+    default Factoring => "exp((num_bits_first + num_bits_second)^(1/3) * log(num_bits_first + num_bits_second)^(2/3))" create FactoringCreateSpec,
+}
+
+crate::register_brute_force! {
+    Factoring decode |problem: &Factoring, indices: Vec<usize>| problem.decode_factors(&indices),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "factoring",
-        instance: Box::new(Factoring::new(2, 3, 15)),
-        optimal_config: vec![1, 1, 1, 0, 1],
-        optimal_value: serde_json::json!(0),
+        instance: Box::new(Factoring::new(15)),
+        optimal_config: serde_json::to_value((BigUint::from(3u32), BigUint::from(5u32)))
+            .expect("solution serialization must succeed"),
+        optimal_value: serde_json::json!(true),
     }]
 }
 
diff --git a/src/models/misc/feasible_register_assignment.rs b/src/models/misc/feasible_register_assignment.rs
index 64c0e340a..2e485061c 100644
--- a/src/models/misc/feasible_register_assignment.rs
+++ b/src/models/misc/feasible_register_assignment.rs
@@ -15,6 +15,7 @@ inventory::submit! {
         display_name: "Feasible Register Assignment",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine whether a DAG computation can be scheduled without register conflicts under a fixed assignment",
         fields: &[
@@ -44,7 +45,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::FeasibleRegisterAssignment;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 4 vertices: v0 depends on v1 and v2, v1 depends on v3
 /// let problem = FeasibleRegisterAssignment::new(
@@ -54,7 +55,7 @@ inventory::submit! {
 ///     vec![0, 1, 0, 0],
 /// );
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize)]
@@ -269,18 +270,41 @@ impl FeasibleRegisterAssignment {
 
 impl Problem for FeasibleRegisterAssignment {
     const NAME: &'static str = "FeasibleRegisterAssignment";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_arcs", num_arcs),
+        ("num_registers", num_registers),
+        ("num_same_register_pairs", num_same_register_pairs),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_vertices; self.num_vertices]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_vertices {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "ordering length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&position| position >= self.num_vertices) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "ordering contains an out-of-range position".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_feasible(config)))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_feasible(config))
+impl crate::solvers::BruteForceProblem for FeasibleRegisterAssignment {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_vertices; self.num_vertices]
     }
 }
 
@@ -288,6 +312,10 @@ crate::declare_variants! {
     default FeasibleRegisterAssignment => "factorial(num_vertices)",
 }
 
+crate::register_brute_force! {
+    FeasibleRegisterAssignment,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -302,7 +330,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         )),
         // config[v] = position: v0 at pos 3, v1 at pos 1, v2 at pos 2, v3 at pos 0
         // Order: v3(pos0), v1(pos1), v2(pos2), v0(pos3)
-        optimal_config: vec![3, 1, 2, 0],
+        optimal_config: serde_json::json!(vec![3, 1, 2, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/flow_shop_scheduling.rs b/src/models/misc/flow_shop_scheduling.rs
index d29937b8a..bd9ee27eb 100644
--- a/src/models/misc/flow_shop_scheduling.rs
+++ b/src/models/misc/flow_shop_scheduling.rs
@@ -14,12 +14,13 @@ inventory::submit! {
         display_name: "Flow Shop Scheduling",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine if a flow-shop schedule for jobs on m processors meets a deadline",
         fields: &[
             FieldInfo { name: "num_processors", type_name: "usize", description: "Number of machines m" },
-            FieldInfo { name: "task_lengths", type_name: "Vec<Vec<u64>>", description: "task_lengths[j][i] = length of job j's task on machine i" },
-            FieldInfo { name: "deadline", type_name: "u64", description: "Global deadline D" },
+            FieldInfo { name: "task_lengths", type_name: "Vec<Vec<i64>>", description: "task_lengths[j][i] = length of job j's task on machine i" },
+            FieldInfo { name: "deadline", type_name: "i64", description: "Global deadline D" },
         ],
     }
 }
@@ -48,12 +49,12 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::FlowShopScheduling;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 2 machines, 3 jobs, deadline 10
 /// let problem = FlowShopScheduling::new(2, vec![vec![2, 3], vec![3, 2], vec![1, 4]], 10);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -61,9 +62,9 @@ pub struct FlowShopScheduling {
     /// Number of processors (machines).
     num_processors: usize,
     /// Task lengths: `task_lengths[j][i]` is the processing time of job `j` on machine `i`.
-    task_lengths: Vec<Vec<u64>>,
+    task_lengths: Vec<Vec<i64>>,
     /// Global deadline.
-    deadline: u64,
+    deadline: i64,
 }
 
 impl FlowShopScheduling {
@@ -71,13 +72,13 @@ impl FlowShopScheduling {
     ///
     /// # Arguments
     /// * `num_processors` - Number of machines m
-    /// * `task_lengths` - task_lengths[j][i] = processing time of job j on machine i.
+    /// * `task_lengths` - `task_lengths[j][i]` = processing time of job j on machine i.
     ///   Each inner Vec must have length `num_processors`.
     /// * `deadline` - Global deadline D
     ///
     /// # Panics
     /// Panics if any job does not have exactly `num_processors` tasks.
-    pub fn new(num_processors: usize, task_lengths: Vec<Vec<u64>>, deadline: u64) -> Self {
+    pub fn new(num_processors: usize, task_lengths: Vec<Vec<i64>>, deadline: i64) -> Self {
         for (j, tasks) in task_lengths.iter().enumerate() {
             assert_eq!(
                 tasks.len(),
@@ -88,6 +89,11 @@ impl FlowShopScheduling {
                 num_processors
             );
         }
+        assert!(
+            task_lengths.iter().flatten().all(|&length| length >= 0),
+            "task lengths must be nonnegative"
+        );
+        assert!(deadline >= 0, "deadline must be nonnegative");
         Self {
             num_processors,
             task_lengths,
@@ -101,12 +107,12 @@ impl FlowShopScheduling {
     }
 
     /// Get the task lengths matrix.
-    pub fn task_lengths(&self) -> &[Vec<u64>] {
+    pub fn task_lengths(&self) -> &[Vec<i64>] {
         &self.task_lengths
     }
 
     /// Get the deadline.
-    pub fn deadline(&self) -> u64 {
+    pub fn deadline(&self) -> i64 {
         self.deadline
     }
 
@@ -119,7 +125,10 @@ impl FlowShopScheduling {
     ///
     /// The job_order slice must be a permutation of `0..num_jobs`.
     /// Returns the completion time of the last job on the last machine.
-    pub fn compute_makespan(&self, job_order: &[usize]) -> u64 {
+    pub fn compute_makespan(
+        &self,
+        job_order: &[usize],
+    ) -> Result<i64, crate::traits::EvaluationError> {
         let n = job_order.len();
         let m = self.num_processors;
         assert_eq!(
@@ -139,46 +148,74 @@ impl FlowShopScheduling {
             );
         }
         if n == 0 || m == 0 {
-            return 0;
+            return Ok(0);
         }
 
         // completion[k][i] = completion time of the k-th job in sequence on machine i
-        let mut completion = vec![vec![0u64; m]; n];
+        let mut completion = vec![vec![0i64; m]; n];
 
         for (k, &job) in job_order.iter().enumerate() {
             for i in 0..m {
                 let prev_machine = if i == 0 { 0 } else { completion[k][i - 1] };
                 let prev_job = if k == 0 { 0 } else { completion[k - 1][i] };
                 let start = prev_machine.max(prev_job);
-                completion[k][i] = start + self.task_lengths[job][i];
+                completion[k][i] =
+                    start
+                        .checked_add(self.task_lengths[job][i])
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "computing flow-shop completion time".to_string(),
+                            )
+                        })?;
             }
         }
 
-        completion[n - 1][m - 1]
+        Ok(completion[n - 1][m - 1])
     }
 }
 
 impl Problem for FlowShopScheduling {
     const NAME: &'static str = "FlowShopScheduling";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_jobs", num_jobs), ("num_processors", num_processors),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        super::lehmer_dims(self.num_jobs())
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        let n = self.num_jobs();
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "job ordering length does not match the jobs".into(),
+            ));
+        }
+        if config.iter().any(|&job| job >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "job ordering contains an out-of-range job".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or({
+                let Some(job_order) = super::decode_permutation(config, self.num_jobs()) else {
+                    return Ok(crate::types::Or(false));
+                };
+
+                let makespan = self.compute_makespan(&job_order)?;
+                makespan <= self.deadline
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let Some(job_order) = super::decode_lehmer(config, self.num_jobs()) else {
-                return crate::types::Or(false);
-            };
-
-            let makespan = self.compute_makespan(&job_order);
-            makespan <= self.deadline
-        })
+impl crate::solvers::BruteForceProblem for FlowShopScheduling {
+    fn dimensions(&self) -> Vec<usize> {
+        super::lehmer_dims(self.num_jobs())
     }
 }
 
@@ -186,6 +223,10 @@ crate::declare_variants! {
     default FlowShopScheduling => "factorial(num_jobs)",
 }
 
+crate::register_brute_force! {
+    FlowShopScheduling decode |problem: &FlowShopScheduling, indices: Vec<usize>| super::decode_lehmer(&indices, problem.num_jobs()).expect("enumerated Lehmer digits are valid"),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -202,7 +243,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             25,
         )),
         // Job order [3,0,4,2,1] = Lehmer code [3,0,2,1,0], makespan 23
-        optimal_config: vec![3, 0, 2, 1, 0],
+        optimal_config: serde_json::json!(vec![3, 0, 4, 2, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/grouping_by_swapping.rs b/src/models/misc/grouping_by_swapping.rs
index ff6cc0d36..863c0fec6 100644
--- a/src/models/misc/grouping_by_swapping.rs
+++ b/src/models/misc/grouping_by_swapping.rs
@@ -4,7 +4,7 @@
 //! whether at most `K` adjacent swaps can transform the string so that every
 //! symbol appears in a single contiguous block.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,13 +14,10 @@ inventory::submit! {
         display_name: "Grouping by Swapping",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Group equal symbols into contiguous blocks using at most K adjacent swaps",
-        fields: &[
-            FieldInfo { name: "alphabet_size", type_name: "usize", description: "Size of the alphabet" },
-            FieldInfo { name: "string", type_name: "Vec<usize>", description: "Input string over {0, ..., alphabet_size-1}" },
-            FieldInfo { name: "budget", type_name: "usize", description: "Maximum number of adjacent swaps allowed" },
-        ],
+        fields: GroupingBySwappingCreateSpec::FIELDS,
     }
 }
 
@@ -36,6 +33,58 @@ pub struct GroupingBySwapping {
     budget: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct GroupingBySwappingCreateSpec {
+    /// Optional alphabet size; omitted values are inferred from the string.
+    alphabet_size: Option<usize>,
+    /// Input string to group.
+    #[create(codec = "comma-separated")]
+    string: Vec<usize>,
+    /// Maximum number of adjacent swaps.
+    bound: usize,
+}
+
+impl TryFrom<GroupingBySwappingCreateSpec> for GroupingBySwapping {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: GroupingBySwappingCreateSpec) -> Result<Self, Self::Error> {
+        let inferred_alphabet_size = spec
+            .string
+            .iter()
+            .copied()
+            .max()
+            .map(|symbol| {
+                symbol
+                    .checked_add(1)
+                    .ok_or_else(|| "inferred alphabet size overflows usize".to_string())
+            })
+            .transpose()?
+            .unwrap_or(0);
+        let alphabet_size = spec.alphabet_size.unwrap_or(inferred_alphabet_size);
+        if alphabet_size < inferred_alphabet_size {
+            return Err(format!(
+                "alphabet size {alphabet_size} is smaller than inferred alphabet size {inferred_alphabet_size}"
+            ).into());
+        }
+        if alphabet_size == 0 && !spec.string.is_empty() {
+            return Err("alphabet size must be positive for a non-empty string"
+                .to_string()
+                .into());
+        }
+        if spec.string.is_empty() && spec.bound != 0 {
+            return Err("bound must be zero when the string is empty"
+                .to_string()
+                .into());
+        }
+
+        Ok(Self {
+            alphabet_size,
+            string: spec.string,
+            budget: spec.bound,
+        })
+    }
+}
+
 impl GroupingBySwapping {
     /// Create a new GroupingBySwapping instance.
     ///
@@ -141,16 +190,34 @@ impl GroupingBySwapping {
 
 impl Problem for GroupingBySwapping {
     const NAME: &'static str = "GroupingBySwapping";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.string_len(); self.budget]
-    }
+    crate::problem_parameters![
+        ("alphabet_size", alphabet_size),
+        ("string_len", string_len),
+        ("budget", budget),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            self.apply_swap_program(config)
-                .is_some_and(|candidate| self.is_grouped(&candidate))
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.budget {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "swap-program length does not match the budget".into(),
+            ));
+        }
+        if config.iter().any(|&slot| slot >= self.string.len()) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "swap program contains an out-of-range slot".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or({
+                self.apply_swap_program(config)
+                    .is_some_and(|candidate| self.is_grouped(&candidate))
+            })
         })
     }
 
@@ -159,8 +226,18 @@ impl Problem for GroupingBySwapping {
     }
 }
 
+impl crate::solvers::BruteForceProblem for GroupingBySwapping {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.string_len(); self.budget]
+    }
+}
+
 crate::declare_variants! {
-    default GroupingBySwapping => "string_len ^ budget",
+    default GroupingBySwapping => "string_len ^ budget" create GroupingBySwappingCreateSpec,
+}
+
+crate::register_brute_force! {
+    GroupingBySwapping,
 }
 
 #[cfg(feature = "example-db")]
@@ -168,7 +245,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "grouping_by_swapping",
         instance: Box::new(GroupingBySwapping::new(3, vec![0, 1, 2, 0, 1, 2], 5)),
-        optimal_config: vec![2, 1, 3, 5, 5],
+        optimal_config: serde_json::json!(vec![2, 1, 3, 5, 5]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/integer_expression_membership.rs b/src/models/misc/integer_expression_membership.rs
index 0e47f3006..e526e32b3 100644
--- a/src/models/misc/integer_expression_membership.rs
+++ b/src/models/misc/integer_expression_membership.rs
@@ -15,11 +15,12 @@ inventory::submit! {
         display_name: "Integer Expression Membership",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Decide whether a target integer belongs to the set represented by an expression tree over union and Minkowski sum",
         fields: &[
             FieldInfo { name: "expression", type_name: "IntExpr", description: "Recursive expression tree" },
-            FieldInfo { name: "target", type_name: "u64", description: "Target integer K" },
+            FieldInfo { name: "target", type_name: "i64", description: "Target integer K" },
         ],
     }
 }
@@ -33,7 +34,7 @@ inventory::submit! {
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub enum IntExpr {
     /// Singleton set {n} for a positive integer n.
-    Atom(u64),
+    Atom(i64),
     /// Set union: F ∪ G.
     Union(Box<IntExpr>, Box<IntExpr>),
     /// Minkowski sum: {m + n : m ∈ F, n ∈ G}.
@@ -88,7 +89,7 @@ impl IntExpr {
     ///
     /// `counter` tracks which union node we are at (DFS order).
     /// Returns `Some(value)` if the config is valid, `None` otherwise.
-    fn evaluate_with_config(&self, config: &[usize], counter: &mut usize) -> Option<u64> {
+    fn evaluate_with_config(&self, config: &[bool], counter: &mut usize) -> Option<i64> {
         match self {
             IntExpr::Atom(n) => Some(*n),
             IntExpr::Union(left, right) => {
@@ -97,10 +98,10 @@ impl IntExpr {
                 if idx >= config.len() {
                     return None;
                 }
-                match config[idx] {
-                    0 => left.evaluate_with_config(config, counter),
-                    1 => right.evaluate_with_config(config, counter),
-                    _ => None,
+                if config[idx] {
+                    right.evaluate_with_config(config, counter)
+                } else {
+                    left.evaluate_with_config(config, counter)
                 }
             }
             IntExpr::Sum(left, right) => {
@@ -129,7 +130,7 @@ impl IntExpr {
 ///
 /// ```
 /// use problemreductions::models::misc::{IntegerExpressionMembership, IntExpr};
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // e = (1 ∪ 4) + (3 ∪ 6) + (2 ∪ 5), target K = 12
 /// let expr = IntExpr::Sum(
@@ -150,7 +151,7 @@ impl IntExpr {
 /// );
 /// let problem = IntegerExpressionMembership::new(expr, 12);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -158,7 +159,7 @@ pub struct IntegerExpressionMembership {
     /// The recursive expression tree.
     expression: IntExpr,
     /// The target integer K.
-    target: u64,
+    target: i64,
 }
 
 impl IntegerExpressionMembership {
@@ -167,7 +168,7 @@ impl IntegerExpressionMembership {
     /// # Arguments
     /// * `expression` - The integer expression tree
     /// * `target` - The target integer K
-    pub fn new(expression: IntExpr, target: u64) -> Self {
+    pub fn new(expression: IntExpr, target: i64) -> Self {
         assert!(target > 0, "target must be a positive integer (got 0)");
         assert!(
             expression.all_atoms_positive(),
@@ -182,7 +183,7 @@ impl IntegerExpressionMembership {
     }
 
     /// Returns the target integer K.
-    pub fn target(&self) -> u64 {
+    pub fn target(&self) -> i64 {
         self.target
     }
 
@@ -209,7 +210,7 @@ impl IntegerExpressionMembership {
     /// Evaluate the expression for a given config and return the resulting integer.
     ///
     /// Returns `Some(value)` if the config is valid, `None` otherwise.
-    pub fn evaluate_config(&self, config: &[usize]) -> Option<u64> {
+    pub fn evaluate_config(&self, config: &[bool]) -> Option<i64> {
         let mut counter = 0;
         self.expression.evaluate_with_config(config, &mut counter)
     }
@@ -217,24 +218,24 @@ impl IntegerExpressionMembership {
 
 impl Problem for IntegerExpressionMembership {
     const NAME: &'static str = "IntegerExpressionMembership";
+    type Solution = Vec<bool>;
     type Value = Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_union_nodes()]
-    }
+    crate::problem_parameters![("num_union_nodes", num_union_nodes),];
 
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or({
-            if config.len() != self.num_union_nodes() {
-                return Or(false);
-            }
-            if config.iter().any(|&v| v >= 2) {
-                return Or(false);
-            }
-            match self.evaluate_config(config) {
-                Some(value) => value == self.target,
-                None => false,
-            }
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            Or({
+                if config.len() != self.num_union_nodes() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "union-choice length does not match the expression".into(),
+                    ));
+                }
+                match self.evaluate_config(config) {
+                    Some(value) => value == self.target,
+                    None => false,
+                }
+            })
         })
     }
 
@@ -243,10 +244,20 @@ impl Problem for IntegerExpressionMembership {
     }
 }
 
+impl crate::solvers::BruteForceProblem for IntegerExpressionMembership {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_union_nodes()]
+    }
+}
+
 crate::declare_variants! {
     default IntegerExpressionMembership => "2^num_union_nodes",
 }
 
+crate::register_brute_force! {
+    IntegerExpressionMembership decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // e = (1 ∪ 4) + (3 ∪ 6) + (2 ∪ 5), K = 12
@@ -271,7 +282,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "integer_expression_membership",
         instance: Box::new(IntegerExpressionMembership::new(expr, 12)),
-        optimal_config: vec![1, 1, 0],
+        optimal_config: serde_json::json!(vec![true, true, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/job_shop_scheduling.rs b/src/models/misc/job_shop_scheduling.rs
index be2dbb4bf..2be0b6f7e 100644
--- a/src/models/misc/job_shop_scheduling.rs
+++ b/src/models/misc/job_shop_scheduling.rs
@@ -5,7 +5,7 @@
 //! makespan (completion time of the last task) while respecting both within-job
 //! precedence and single-processor capacity constraints.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -17,29 +17,86 @@ inventory::submit! {
         display_name: "Job-Shop Scheduling",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Minimize the makespan of a job-shop schedule",
-        fields: &[
-            FieldInfo { name: "num_processors", type_name: "usize", description: "Number of processors m" },
-            FieldInfo { name: "jobs", type_name: "Vec<Vec<(usize, u64)>>", description: "jobs[j][k] = (processor, length) for the k-th task of job j" },
-        ],
+        fields: JobShopSchedulingCreateSpec::FIELDS,
     }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct JobShopScheduling {
     num_processors: usize,
-    jobs: Vec<Vec<(usize, u64)>>,
+    jobs: Vec<Vec<(usize, i64)>>,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct JobShopSchedulingCreateSpec {
+    /// Jobs expressed as ordered processor-duration operations.
+    #[create(codec = "semicolon-separated")]
+    jobs: Vec<Vec<(usize, i64)>>,
+    /// Optional processor count; omitted values are inferred from the jobs.
+    num_processors: Option<usize>,
+}
+
+impl TryFrom<JobShopSchedulingCreateSpec> for JobShopScheduling {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: JobShopSchedulingCreateSpec) -> Result<Self, Self::Error> {
+        let inferred_processors = spec
+            .jobs
+            .iter()
+            .flatten()
+            .map(|(processor, _)| *processor)
+            .max()
+            .map(|processor| {
+                processor
+                    .checked_add(1)
+                    .ok_or_else(|| "inferred processor count overflows usize".to_string())
+            })
+            .transpose()?;
+        let num_processors = spec.num_processors.or(inferred_processors).ok_or_else(|| {
+            "cannot infer processor count from an empty job list; provide num_processors"
+                .to_string()
+        })?;
+        if num_processors == 0 {
+            return Err("num_processors must be positive".to_string().into());
+        }
+
+        for (job_index, job) in spec.jobs.iter().enumerate() {
+            for (task_index, &(processor, _)) in job.iter().enumerate() {
+                if processor >= num_processors {
+                    return Err(format!(
+                        "job {job_index} task {task_index} uses processor {processor}, but num_processors is {num_processors}"
+                    ).into());
+                }
+            }
+            for (task_index, pair) in job.windows(2).enumerate() {
+                if pair[0].0 == pair[1].0 {
+                    return Err(format!(
+                        "job {job_index} tasks {task_index} and {} must use different processors",
+                        task_index + 1
+                    )
+                    .into());
+                }
+            }
+        }
+
+        Ok(Self {
+            num_processors,
+            jobs: spec.jobs,
+        })
+    }
 }
 
 struct FlattenedTasks {
     job_task_ids: Vec<Vec<usize>>,
     machine_task_ids: Vec<Vec<usize>>,
-    lengths: Vec<u64>,
+    lengths: Vec<i64>,
 }
 
 impl JobShopScheduling {
-    pub fn new(num_processors: usize, jobs: Vec<Vec<(usize, u64)>>) -> Self {
+    pub fn new(num_processors: usize, jobs: Vec<Vec<(usize, i64)>>) -> Self {
         let num_tasks: usize = jobs.iter().map(Vec::len).sum();
         if num_tasks > 0 {
             assert!(
@@ -47,6 +104,10 @@ impl JobShopScheduling {
                 "num_processors must be positive when tasks are present"
             );
         }
+        assert!(
+            jobs.iter().flatten().all(|&(_, length)| length >= 0),
+            "operation lengths must be nonnegative"
+        );
 
         for (job_index, job) in jobs.iter().enumerate() {
             for (task_index, &(processor, _length)) in job.iter().enumerate() {
@@ -76,7 +137,7 @@ impl JobShopScheduling {
         self.num_processors
     }
 
-    pub fn jobs(&self) -> &[Vec<(usize, u64)>] {
+    pub fn jobs(&self) -> &[Vec<(usize, i64)>] {
         &self.jobs
     }
 
@@ -136,7 +197,7 @@ impl JobShopScheduling {
 
     /// Compute start times from a Lehmer-code config. Returns `None` if the
     /// config is invalid or induces a cycle in the precedence DAG.
-    pub fn schedule_from_config(&self, config: &[usize]) -> Option<Vec<u64>> {
+    pub fn schedule_from_config(&self, config: &[usize]) -> Option<Vec<i64>> {
         self.schedule_from_config_inner(config, &self.flatten_tasks())
     }
 
@@ -144,7 +205,7 @@ impl JobShopScheduling {
         &self,
         config: &[usize],
         flattened: &FlattenedTasks,
-    ) -> Option<Vec<u64>> {
+    ) -> Option<Vec<i64>> {
         let machine_orders = self.decode_machine_orders(config, flattened)?;
         let num_tasks = flattened.lengths.len();
 
@@ -176,7 +237,7 @@ impl JobShopScheduling {
             }
         }
 
-        let mut start_times = vec![0u64; num_tasks];
+        let mut start_times = vec![0i64; num_tasks];
         let mut processed = 0usize;
 
         while let Some(task_id) = queue.pop_front() {
@@ -202,39 +263,75 @@ impl JobShopScheduling {
 
 impl Problem for JobShopScheduling {
     const NAME: &'static str = "JobShopScheduling";
-    type Value = Min<u64>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_processors", num_processors),
+        ("num_jobs", num_jobs),
+        ("num_tasks", num_tasks),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        let flattened = self.flatten_tasks();
+        if config.len() != flattened.lengths.len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "machine-order encoding length does not match the tasks".into(),
+            ));
+        }
+        let dimensions = flattened
+            .machine_task_ids
+            .iter()
+            .flat_map(|machine_tasks| super::lehmer_dims(machine_tasks.len()));
+        if config
+            .iter()
+            .zip(dimensions)
+            .any(|(&digit, radix)| digit >= radix)
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "machine-order encoding contains an out-of-range digit".into(),
+            ));
+        }
+        Ok({
+            match self.schedule_from_config_inner(config, &flattened) {
+                Some(start_times) => {
+                    let makespan = start_times
+                        .iter()
+                        .enumerate()
+                        .map(|(i, &s)| s + flattened.lengths[i])
+                        .max()
+                        .unwrap_or(0);
+                    Min(Some(makespan))
+                }
+                None => Min(None),
+            }
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for JobShopScheduling {
+    fn dimensions(&self) -> Vec<usize> {
         self.flatten_tasks()
             .machine_task_ids
             .into_iter()
             .flat_map(|machine_tasks| super::lehmer_dims(machine_tasks.len()))
             .collect()
     }
-
-    fn evaluate(&self, config: &[usize]) -> Min<u64> {
-        let flattened = self.flatten_tasks();
-        match self.schedule_from_config_inner(config, &flattened) {
-            Some(start_times) => {
-                let makespan = start_times
-                    .iter()
-                    .enumerate()
-                    .map(|(i, &s)| s + flattened.lengths[i])
-                    .max()
-                    .unwrap_or(0);
-                Min(Some(makespan))
-            }
-            None => Min(None),
-        }
-    }
 }
 
 crate::declare_variants! {
-    default JobShopScheduling => "factorial(num_tasks)",
+    default JobShopScheduling => "factorial(num_tasks)" create JobShopSchedulingCreateSpec,
+}
+
+crate::register_brute_force! {
+    JobShopScheduling,
 }
 
 #[cfg(feature = "example-db")]
@@ -253,7 +350,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         )),
         // Machine 0 order [0,3,5,8,9,11] => [0,0,0,0,0,0]
         // Machine 1 order [2,7,1,6,10,4] => [1,3,0,1,1,0]
-        optimal_config: vec![0, 0, 0, 0, 0, 0, 1, 3, 0, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![0, 0, 0, 0, 0, 0, 1, 3, 0, 1, 1, 0]),
         optimal_value: serde_json::json!(19),
     }]
 }
diff --git a/src/models/misc/knapsack.rs b/src/models/misc/knapsack.rs
index 2c282fc8c..95d7fd023 100644
--- a/src/models/misc/knapsack.rs
+++ b/src/models/misc/knapsack.rs
@@ -3,7 +3,7 @@
 //! The 0-1 Knapsack problem asks for a subset of items that maximizes
 //! total value while respecting a weight capacity constraint.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Max;
 use serde::{Deserialize, Serialize};
@@ -14,13 +14,10 @@ inventory::submit! {
         display_name: "Knapsack",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Select items to maximize total value subject to weight capacity constraint",
-        fields: &[
-            FieldInfo { name: "weights", type_name: "Vec<i64>", description: "Nonnegative item weights w_i" },
-            FieldInfo { name: "values", type_name: "Vec<i64>", description: "Nonnegative item values v_i" },
-            FieldInfo { name: "capacity", type_name: "i64", description: "Nonnegative knapsack capacity C" },
-        ],
+        fields: KnapsackCreateSpec::FIELDS,
     }
 }
 
@@ -39,11 +36,11 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::Knapsack;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = Knapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], 7);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -56,6 +53,35 @@ pub struct Knapsack {
     capacity: i64,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct KnapsackCreateSpec {
+    /// Nonnegative item weights; defaults to one per value.
+    weights: Option<Vec<i64>>,
+    /// Nonnegative item values.
+    values: Vec<i64>,
+    /// Nonnegative knapsack capacity.
+    capacity: i64,
+}
+impl TryFrom<KnapsackCreateSpec> for Knapsack {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: KnapsackCreateSpec) -> Result<Self, Self::Error> {
+        let count = spec.values.len();
+        let weights = spec.weights.unwrap_or_else(|| vec![1; count]);
+        if weights.len() != count {
+            return Err("weights length must equal values length".to_string().into());
+        }
+        if weights.iter().any(|&value| value < 0)
+            || spec.values.iter().any(|&value| value < 0)
+            || spec.capacity < 0
+        {
+            return Err("weights, values, and capacity must be nonnegative"
+                .to_string()
+                .into());
+        }
+        Ok(Self::new(weights, spec.values, spec.capacity))
+    }
+}
+
 impl Knapsack {
     /// Create a new Knapsack instance.
     ///
@@ -112,51 +138,76 @@ impl Knapsack {
         if self.capacity == 0 {
             1
         } else {
-            (u64::BITS - (self.capacity as u64).leading_zeros()) as usize
+            self.capacity.ilog2() as usize + 1
         }
     }
 }
 
 impl Problem for Knapsack {
     const NAME: &'static str = "Knapsack";
+    type Solution = Vec<bool>;
     type Value = Max<i64>;
 
+    crate::problem_parameters![("capacity", capacity), ("num_items", num_items),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_items()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.num_items() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "item-selection length does not match the instance".into(),
+                ));
+            }
+            let total_weight = config
+                .iter()
+                .enumerate()
+                .filter(|(_, &x)| x)
+                .map(|(i, _)| self.weights[i])
+                .try_fold(0_i64, |total, weight| {
+                    total.checked_add(weight).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing selected knapsack weights".into(),
+                        )
+                    })
+                })?;
+            if total_weight > self.capacity {
+                return Ok(Max(None));
+            }
+            let total_value = config
+                .iter()
+                .enumerate()
+                .filter(|(_, &x)| x)
+                .map(|(i, _)| self.values[i])
+                .try_fold(0_i64, |total, value| {
+                    total.checked_add(value).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing selected knapsack values".into(),
+                        )
+                    })
+                })?;
+            Max(Some(total_value))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Max<i64> {
-        if config.len() != self.num_items() {
-            return Max(None);
-        }
-        if config.iter().any(|&v| v >= 2) {
-            return Max(None);
-        }
-        let total_weight: i64 = config
-            .iter()
-            .enumerate()
-            .filter(|(_, &x)| x == 1)
-            .map(|(i, _)| self.weights[i])
-            .sum();
-        if total_weight > self.capacity {
-            return Max(None);
-        }
-        let total_value: i64 = config
-            .iter()
-            .enumerate()
-            .filter(|(_, &x)| x == 1)
-            .map(|(i, _)| self.values[i])
-            .sum();
-        Max(Some(total_value))
+impl crate::solvers::BruteForceProblem for Knapsack {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_items()]
     }
 }
 
 crate::declare_variants! {
-    default Knapsack => "2^(num_items / 2)",
+    default Knapsack => "2^(num_items / 2)" create KnapsackCreateSpec,
+}
+
+crate::register_brute_force! {
+    Knapsack decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 mod nonnegative_i64 {
@@ -202,7 +253,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "knapsack",
         instance: Box::new(Knapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], 7)),
-        optimal_config: vec![1, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![true, false, false, true]),
         optimal_value: serde_json::json!(10),
     }]
 }
diff --git a/src/models/misc/kth_largest_m_tuple.rs b/src/models/misc/kth_largest_m_tuple.rs
index 6b600a98e..8f6137c42 100644
--- a/src/models/misc/kth_largest_m_tuple.rs
+++ b/src/models/misc/kth_largest_m_tuple.rs
@@ -1,12 +1,12 @@
 //! Kth Largest m-Tuple problem implementation.
 //!
-//! Given m sets of positive integers and thresholds K and B, count how many
-//! distinct m-tuples (one element per set) have total size at least B.
-//! The answer is YES iff the count is at least K. Garey & Johnson MP10.
+//! Given m sets of positive integers and thresholds K and B, determine whether
+//! at least K distinct m-tuples (one element per set) have total size at least B.
+//! Garey & Johnson MP10.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
-use crate::types::Sum;
+use crate::types::Or;
 use serde::de::Error as _;
 use serde::{Deserialize, Deserializer, Serialize};
 
@@ -16,41 +16,30 @@ inventory::submit! {
         display_name: "Kth Largest m-Tuple",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Count m-tuples whose total size meets a bound and compare against a threshold K",
-        fields: &[
-            FieldInfo { name: "sets", type_name: "Vec<Vec<u64>>", description: "m sets, each containing positive integer sizes" },
-            FieldInfo { name: "k", type_name: "u64", description: "Threshold K (answer YES iff count >= K)" },
-            FieldInfo { name: "bound", type_name: "u64", description: "Lower bound B on tuple sum" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "KthLargestMTuple",
-        fields: &["num_sets", "total_tuples"],
+        fields: KthLargestMTupleCreateSpec::FIELDS,
     }
 }
 
 /// The Kth Largest m-Tuple problem.
 ///
 /// Given sets `X_1, ..., X_m` of positive integers, a threshold `K`, and a
-/// bound `B`, count how many distinct m-tuples `(x_1, ..., x_m)` in
-/// `X_1 x ... x X_m` satisfy `sum(x_i) >= B`. The answer is YES iff the
-/// count is at least `K`.
+/// bound `B`, determine whether at least `K` distinct m-tuples
+/// `(x_1, ..., x_m)` in `X_1 x ... x X_m` satisfy `sum(x_i) >= B`.
 ///
 /// # Representation
 ///
-/// Variable `i` selects an element from set `X_i`, ranging over `{0, ..., |X_i|-1}`.
-/// `evaluate` returns `Sum(1)` if the tuple sum >= B, else `Sum(0)`.
-/// The aggregate over all configurations gives the total count of qualifying tuples.
+/// The empty configuration triggers enumeration of the Cartesian product.
+/// `evaluate` returns `Or(true)` as soon as `K` qualifying tuples have been
+/// found and `Or(false)` if the complete product contains fewer than `K`.
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::misc::KthLargestMTuple;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = KthLargestMTuple::new(
 ///     vec![vec![2, 5, 8], vec![3, 6], vec![1, 4, 7]],
@@ -58,39 +47,67 @@ inventory::submit! {
 ///     12,
 /// );
 /// let solver = BruteForce::new();
-/// let value = solver.solve(&problem);
-/// // 14 of the 18 tuples have sum >= 12
-/// assert_eq!(value, problemreductions::types::Sum(14));
+/// let solution = solver.solve(&problem).unwrap().unwrap();
+/// // 14 of the 18 tuples have sum >= 12, so count >= K.
+/// assert_eq!(problem.evaluate(&solution).unwrap(), problemreductions::types::Or(true));
 /// ```
 #[derive(Debug, Clone, Serialize)]
 pub struct KthLargestMTuple {
-    sets: Vec<Vec<u64>>,
-    k: u64,
-    bound: u64,
+    sets: Vec<Vec<i64>>,
+    k: i64,
+    bound: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct KthLargestMTupleCreateSpec {
+    /// m sets, each containing positive integer sizes.
+    subsets: Vec<Vec<i64>>,
+    /// Threshold K (answer YES iff count >= K).
+    k: i64,
+    /// Lower bound B on tuple sum.
+    bound: i64,
+}
+
+impl TryFrom<KthLargestMTupleCreateSpec> for KthLargestMTuple {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: KthLargestMTupleCreateSpec) -> Result<Self, Self::Error> {
+        Self::try_new(spec.subsets, spec.k, spec.bound)
+    }
 }
 
 impl KthLargestMTuple {
-    fn validate(sets: &[Vec<u64>], k: u64, bound: u64) -> Result<(), String> {
+    fn validate(
+        sets: &[Vec<i64>],
+        k: i64,
+        bound: i64,
+    ) -> Result<(), crate::registry::ConstructionError> {
         if sets.is_empty() {
-            return Err("KthLargestMTuple requires at least one set".to_string());
+            return Err("KthLargestMTuple requires at least one set"
+                .to_string()
+                .into());
         }
         if sets.iter().any(|s| s.is_empty()) {
-            return Err("Every set must be non-empty".to_string());
+            return Err("Every set must be non-empty".to_string().into());
         }
-        if sets.iter().any(|s| s.contains(&0)) {
-            return Err("All sizes must be positive (> 0)".to_string());
+        if sets.iter().flatten().any(|&size| size <= 0) {
+            return Err("All sizes must be positive (> 0)".to_string().into());
         }
-        if k == 0 {
-            return Err("Threshold K must be positive".to_string());
+        if k <= 0 {
+            return Err("Threshold K must be positive".to_string().into());
         }
-        if bound == 0 {
-            return Err("Bound B must be positive".to_string());
+        if bound <= 0 {
+            return Err("Bound B must be positive".to_string().into());
         }
         Ok(())
     }
 
     /// Try to create a new KthLargestMTuple instance.
-    pub fn try_new(sets: Vec<Vec<u64>>, k: u64, bound: u64) -> Result<Self, String> {
+    pub fn try_new(
+        sets: Vec<Vec<i64>>,
+        k: i64,
+        bound: i64,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate(&sets, k, bound)?;
         Ok(Self { sets, k, bound })
     }
@@ -100,22 +117,22 @@ impl KthLargestMTuple {
     /// # Panics
     ///
     /// Panics if the inputs are invalid.
-    pub fn new(sets: Vec<Vec<u64>>, k: u64, bound: u64) -> Self {
+    pub fn new(sets: Vec<Vec<i64>>, k: i64, bound: i64) -> Self {
         Self::try_new(sets, k, bound).unwrap_or_else(|msg| panic!("{msg}"))
     }
 
     /// Returns the sets.
-    pub fn sets(&self) -> &[Vec<u64>] {
+    pub fn sets(&self) -> &[Vec<i64>] {
         &self.sets
     }
 
     /// Returns the threshold K.
-    pub fn k(&self) -> u64 {
+    pub fn k(&self) -> i64 {
         self.k
     }
 
     /// Returns the bound B.
-    pub fn bound(&self) -> u64 {
+    pub fn bound(&self) -> i64 {
         self.bound
     }
 
@@ -126,15 +143,54 @@ impl KthLargestMTuple {
 
     /// Returns the total number of m-tuples (product of set sizes).
     pub fn total_tuples(&self) -> usize {
-        self.sets.iter().map(|s| s.len()).product()
+        self.sets
+            .iter()
+            .try_fold(1usize, |total, set| total.checked_mul(set.len()))
+            .expect("KthLargestMTuple total tuple count exceeds usize")
+    }
+
+    fn has_at_least_k_qualifying_tuples(&self) -> Result<bool, crate::traits::EvaluationError> {
+        let mut choices = vec![0; self.sets.len()];
+        let mut qualifying = 0;
+
+        loop {
+            let mut sum = 0i64;
+            for (set, &choice) in self.sets.iter().zip(&choices) {
+                sum = sum.checked_add(set[choice]).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing a KthLargestMTuple tuple".to_string(),
+                    )
+                })?;
+            }
+            if sum >= self.bound {
+                qualifying += 1;
+                if qualifying == self.k {
+                    return Ok(true);
+                }
+            }
+
+            let mut advanced = false;
+            for set_index in (0..choices.len()).rev() {
+                choices[set_index] += 1;
+                if choices[set_index] == self.sets[set_index].len() {
+                    choices[set_index] = 0;
+                } else {
+                    advanced = true;
+                    break;
+                }
+            }
+            if !advanced {
+                return Ok(false);
+            }
+        }
     }
 }
 
 #[derive(Deserialize)]
 struct KthLargestMTupleDef {
-    sets: Vec<Vec<u64>>,
-    k: u64,
-    bound: u64,
+    sets: Vec<Vec<i64>>,
+    k: i64,
+    bound: i64,
 }
 
 impl<'de> Deserialize<'de> for KthLargestMTuple {
@@ -149,48 +205,40 @@ impl<'de> Deserialize<'de> for KthLargestMTuple {
 
 impl Problem for KthLargestMTuple {
     const NAME: &'static str = "KthLargestMTuple";
-    type Value = Sum<u64>;
+    type Solution = ();
+    type Value = Or;
+
+    crate::problem_parameters![("num_sets", num_sets), ("total_tuples", total_tuples),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        self.sets.iter().map(|s| s.len()).collect()
+    fn evaluate(&self, _solution: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok(Or(self.has_at_least_k_qualifying_tuples()?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Sum<u64> {
-        if config.len() != self.num_sets() {
-            return Sum(0);
-        }
-        for (i, &choice) in config.iter().enumerate() {
-            if choice >= self.sets[i].len() {
-                return Sum(0);
-            }
-        }
-        let total: u64 = config
-            .iter()
-            .enumerate()
-            .map(|(i, &choice)| self.sets[i][choice])
-            .sum();
-        if total >= self.bound {
-            Sum(1)
-        } else {
-            Sum(0)
-        }
+impl crate::solvers::BruteForceProblem for KthLargestMTuple {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![]
     }
 }
 
 // Best known: brute-force enumeration of all tuples, O(total_tuples * num_sets).
 // No sub-exponential exact algorithm is known for the general case.
 crate::declare_variants! {
-    default KthLargestMTuple => "total_tuples * num_sets",
+    default KthLargestMTuple => "total_tuples * num_sets" create KthLargestMTupleCreateSpec,
+}
+
+crate::register_brute_force! {
+    KthLargestMTuple decode |_, _| (),
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // m=3, X_1={2,5,8}, X_2={3,6}, X_3={1,4,7}, B=12, K=14.
-    // 14 of 18 tuples have sum >= 12. The config [2,1,2] picks (8,6,7) with sum=21 >= 12.
+    // 14 of 18 tuples have sum >= 12, so the answer is YES at K=14.
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "kth_largest_m_tuple",
         instance: Box::new(KthLargestMTuple::new(
@@ -198,8 +246,8 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             14,
             12,
         )),
-        optimal_config: vec![2, 1, 2],
-        optimal_value: serde_json::json!(1),
+        optimal_config: serde_json::json!(null),
+        optimal_value: serde_json::json!(true),
     }]
 }
 
diff --git a/src/models/misc/longest_common_subsequence.rs b/src/models/misc/longest_common_subsequence.rs
index 7425ad942..15bb0c0d2 100644
--- a/src/models/misc/longest_common_subsequence.rs
+++ b/src/models/misc/longest_common_subsequence.rs
@@ -2,10 +2,10 @@
 //!
 //! Given a finite alphabet and a set of strings over that alphabet, find a
 //! longest common subsequence. The configuration is a fixed-length vector of
-//! `max_length` positions, where each entry is either a valid symbol or the
-//! padding symbol (`alphabet_size`). Padding must be contiguous at the end.
+//! `max_length` positions, where each entry is either a valid symbol or `None`
+//! as padding. Padding must be contiguous at the end.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Max;
 use serde::{Deserialize, Serialize};
@@ -16,13 +16,10 @@ inventory::submit! {
         display_name: "Longest Common Subsequence",
         aliases: &["LCS"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a longest common subsequence for a set of strings",
-        fields: &[
-            FieldInfo { name: "alphabet_size", type_name: "usize", description: "Size of the alphabet" },
-            FieldInfo { name: "strings", type_name: "Vec<Vec<usize>>", description: "Input strings over the alphabet {0, ..., alphabet_size-1}" },
-            FieldInfo { name: "max_length", type_name: "usize", description: "Maximum possible subsequence length (min of string lengths)" },
-        ],
+        fields: LongestCommonSubsequenceCreateSpec::FIELDS,
     }
 }
 
@@ -33,11 +30,11 @@ inventory::submit! {
 ///
 /// # Representation
 ///
-/// The configuration is a vector of length `max_length`, where each entry is a
-/// symbol in `{0, ..., alphabet_size}`. The value `alphabet_size` is the
-/// padding symbol. Padding must be contiguous at the end of the vector. The
-/// effective subsequence consists of all non-padding symbols (the prefix before
-/// padding starts). The objective is to maximize the effective length.
+/// The configuration is a vector of length `max_length`, where each entry is
+/// either a symbol in `{0, ..., alphabet_size - 1}` or `None` as padding.
+/// Padding must be contiguous at the end of the vector. The effective
+/// subsequence consists of the symbols before padding starts. The objective is
+/// to maximize the effective length.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LongestCommonSubsequence {
     alphabet_size: usize,
@@ -45,6 +42,56 @@ pub struct LongestCommonSubsequence {
     max_length: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct LongestCommonSubsequenceCreateSpec {
+    /// Optional alphabet size; omitted values are inferred from the strings.
+    alphabet_size: Option<usize>,
+    /// Input strings over the shared alphabet.
+    #[create(codec = "character-rows")]
+    strings: Vec<Vec<usize>>,
+}
+
+impl TryFrom<LongestCommonSubsequenceCreateSpec> for LongestCommonSubsequence {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: LongestCommonSubsequenceCreateSpec) -> Result<Self, Self::Error> {
+        if !spec.strings.iter().any(|string| !string.is_empty()) {
+            return Err("at least one input string must be non-empty"
+                .to_string()
+                .into());
+        }
+        let inferred_alphabet_size = spec
+            .strings
+            .iter()
+            .flatten()
+            .copied()
+            .max()
+            .map(|symbol| {
+                symbol
+                    .checked_add(1)
+                    .ok_or_else(|| "inferred alphabet size overflows usize".to_string())
+            })
+            .transpose()?
+            .unwrap_or(0);
+        let alphabet_size = spec.alphabet_size.unwrap_or(inferred_alphabet_size);
+        if alphabet_size < inferred_alphabet_size {
+            return Err(format!(
+                "alphabet size {alphabet_size} is smaller than inferred alphabet size {inferred_alphabet_size}"
+            ).into());
+        }
+        if alphabet_size == 0 {
+            return Err("alphabet size must be positive".to_string().into());
+        }
+        let max_length = spec.strings.iter().map(Vec::len).min().unwrap_or(0);
+
+        Ok(Self {
+            alphabet_size,
+            strings: spec.strings,
+            max_length,
+        })
+    }
+}
+
 impl LongestCommonSubsequence {
     /// Create a new LongestCommonSubsequence instance.
     ///
@@ -157,53 +204,87 @@ fn is_subsequence(candidate: &[usize], target: &[usize]) -> bool {
 
 impl Problem for LongestCommonSubsequence {
     const NAME: &'static str = "LongestCommonSubsequence";
-    type Value = Max<usize>;
+    type Solution = Vec<Option<usize>>;
+    type Value = Max<i64>;
+
+    crate::problem_parameters![
+        ("alphabet_size", alphabet_size),
+        ("cross_frequency_product", cross_frequency_product),
+        ("max_length", max_length),
+        ("num_strings", num_strings),
+        ("num_transitions", num_transitions),
+        ("sum_triangular_lengths", sum_triangular_lengths),
+        ("total_length", total_length),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.alphabet_size + 1; self.max_length]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Max<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
         if config.len() != self.max_length {
-            return Max(None);
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "subsequence representation length does not match the bound".into(),
+            ));
         }
-
-        let padding = self.alphabet_size;
-
-        // Find effective length = index of first padding symbol (or max_length if no padding).
-        let effective_length = config
+        if config
             .iter()
-            .position(|&s| s == padding)
-            .unwrap_or(self.max_length);
-
-        // Verify all positions after the first padding are also padding (no interleaved padding).
-        if config[effective_length..].iter().any(|&s| s != padding) {
-            return Max(None);
+            .any(|symbol| symbol.is_some_and(|value| value >= self.alphabet_size))
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "subsequence contains an out-of-range symbol".into(),
+            ));
         }
+        let config = config
+            .iter()
+            .map(|symbol| symbol.unwrap_or(self.alphabet_size))
+            .collect::<Vec<_>>();
+        Ok({
+            let padding = self.alphabet_size;
 
-        // Extract the non-padding prefix as the candidate subsequence.
-        let prefix = &config[..effective_length];
+            // Find effective length = index of first padding symbol (or max_length if no padding).
+            let effective_length = config
+                .iter()
+                .position(|&s| s == padding)
+                .unwrap_or(self.max_length);
 
-        // Check all symbols in prefix are valid (0..alphabet_size).
-        if prefix.iter().any(|&s| s >= self.alphabet_size) {
-            return Max(None);
-        }
+            // Verify all positions after the first padding are also padding (no interleaved padding).
+            if config[effective_length..].iter().any(|&s| s != padding) {
+                return Ok(Max(None));
+            }
 
-        // Check the prefix is a subsequence of every input string.
-        if !self.strings.iter().all(|s| is_subsequence(prefix, s)) {
-            return Max(None);
-        }
+            // Extract the non-padding prefix as the candidate subsequence.
+            let prefix = &config[..effective_length];
 
-        Max(Some(effective_length))
+            // Check the prefix is a subsequence of every input string.
+            if !self.strings.iter().all(|s| is_subsequence(prefix, s)) {
+                return Ok(Max(None));
+            }
+
+            Max(Some(i64::try_from(effective_length).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting subsequence length to i64".into(),
+                )
+            })?))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for LongestCommonSubsequence {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.alphabet_size + 1; self.max_length]
     }
 }
 
 crate::declare_variants! {
-    default LongestCommonSubsequence => "(alphabet_size + 1) ^ max_length",
+    default LongestCommonSubsequence => "(alphabet_size + 1) ^ max_length" create LongestCommonSubsequenceCreateSpec,
+}
+
+crate::register_brute_force! {
+    LongestCommonSubsequence decode |problem: &LongestCommonSubsequence, indices: Vec<usize>| indices.into_iter().map(|value| (value != problem.alphabet_size()).then_some(value)).collect(),
 }
 
 #[cfg(feature = "example-db")]
@@ -221,7 +302,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 vec![1, 0, 1, 0, 1, 0],
             ],
         )),
-        optimal_config: vec![0, 0, 1, 0, 2, 2],
+        optimal_config: serde_json::json!(vec![Some(0), Some(0), Some(1), Some(0), None, None]),
         optimal_value: serde_json::json!(4),
     }]
 }
diff --git a/src/models/misc/maximum_likelihood_ranking.rs b/src/models/misc/maximum_likelihood_ranking.rs
index 89d178d46..6483aa1a8 100644
--- a/src/models/misc/maximum_likelihood_ranking.rs
+++ b/src/models/misc/maximum_likelihood_ranking.rs
@@ -17,10 +17,11 @@ inventory::submit! {
         display_name: "Maximum Likelihood Ranking",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a ranking minimizing total pairwise disagreement cost",
         fields: &[
-            FieldInfo { name: "matrix", type_name: "Vec<Vec<i32>>", description: "Antisymmetric comparison matrix A (a_ij + a_ji = c, a_ii = 0)" },
+            FieldInfo { name: "matrix", type_name: "Vec<Vec<i64>>", description: "Antisymmetric comparison matrix A (a_ij + a_ji = c, a_ii = 0)" },
         ],
     }
 }
@@ -40,7 +41,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MaximumLikelihoodRanking;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let matrix = vec![
 ///     vec![0, 4, 3, 5],
@@ -50,12 +51,12 @@ inventory::submit! {
 /// ];
 /// let problem = MaximumLikelihoodRanking::new(matrix);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MaximumLikelihoodRanking {
-    matrix: Vec<Vec<i32>>,
+    matrix: Vec<Vec<i64>>,
 }
 
 impl MaximumLikelihoodRanking {
@@ -65,7 +66,7 @@ impl MaximumLikelihoodRanking {
     /// Panics if the matrix is not square, if any diagonal element is nonzero,
     /// or if the pairwise sums `a_ij + a_ji` are not the same constant for
     /// all `i != j`.
-    pub fn new(matrix: Vec<Vec<i32>>) -> Self {
+    pub fn new(matrix: Vec<Vec<i64>>) -> Self {
         let n = matrix.len();
         for (i, row) in matrix.iter().enumerate() {
             assert_eq!(
@@ -100,7 +101,7 @@ impl MaximumLikelihoodRanking {
     }
 
     /// Returns the comparison matrix.
-    pub fn matrix(&self) -> &Vec<Vec<i32>> {
+    pub fn matrix(&self) -> &Vec<Vec<i64>> {
         &self.matrix
     }
 
@@ -110,7 +111,7 @@ impl MaximumLikelihoodRanking {
     }
 
     /// Returns the constant pairwise comparison count `c`.
-    pub fn comparison_count(&self) -> i32 {
+    pub fn comparison_count(&self) -> i64 {
         if self.matrix.len() < 2 {
             0
         } else {
@@ -121,47 +122,69 @@ impl MaximumLikelihoodRanking {
 
 impl Problem for MaximumLikelihoodRanking {
     const NAME: &'static str = "MaximumLikelihoodRanking";
+    type Solution = Vec<usize>;
     type Value = Min<i64>;
 
+    crate::problem_parameters![("num_items", num_items),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let n = self.num_items();
-        vec![n; n]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<i64> {
-        let n = self.num_items();
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let n = self.num_items();
+
+            // Validate config length
+            if config.len() != n {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "ranking length does not match the number of alternatives".into(),
+                ));
+            }
 
-        // Validate config length
-        if config.len() != n {
-            return Min(None);
-        }
+            if config.iter().any(|&rank| rank >= n) {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "ranking contains an out-of-range position".into(),
+                ));
+            }
 
-        // Validate permutation: all values must be distinct and in 0..n
-        let mut seen = vec![false; n];
-        for &rank in config {
-            if rank >= n || seen[rank] {
-                return Min(None);
+            // Validate permutation: all values must be distinct and in 0..n
+            let mut seen = vec![false; n];
+            for &rank in config {
+                if rank >= n || seen[rank] {
+                    return Ok(Min(None));
+                }
+                seen[rank] = true;
             }
-            seen[rank] = true;
-        }
 
-        // config[item] = rank position of item
-        // Disagreement cost: for all pairs of items (a, b) where a is
-        // ranked AFTER b (config[a] > config[b]), add matrix[a][b].
-        let mut cost: i64 = 0;
-        for a in 0..n {
-            for b in 0..n {
-                if a != b && config[a] > config[b] {
-                    cost += self.matrix[a][b] as i64;
+            // config[item] = rank position of item
+            // Disagreement cost: for all pairs of items (a, b) where a is
+            // ranked AFTER b (config[a] > config[b]), add matrix[a][b].
+            let mut cost: i64 = 0;
+            for a in 0..n {
+                for b in 0..n {
+                    if a != b && config[a] > config[b] {
+                        cost = cost.checked_add(self.matrix[a][b]).ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "summing ranking disagreement costs".into(),
+                            )
+                        })?;
+                    }
                 }
             }
-        }
 
-        Min(Some(cost))
+            Min(Some(cost))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MaximumLikelihoodRanking {
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.num_items();
+        vec![n; n]
     }
 }
 
@@ -169,6 +192,10 @@ crate::declare_variants! {
     default MaximumLikelihoodRanking => "num_items * num_items * 2^num_items",
 }
 
+crate::register_brute_force! {
+    MaximumLikelihoodRanking,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 4 items with comparison matrix.
@@ -186,7 +213,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "maximum_likelihood_ranking",
         instance: Box::new(MaximumLikelihoodRanking::new(matrix)),
-        optimal_config: vec![0, 1, 2, 3],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 3]),
         optimal_value: serde_json::json!(7),
     }]
 }
diff --git a/src/models/misc/minimum_axiom_set.rs b/src/models/misc/minimum_axiom_set.rs
index 705e155cf..cbbe0fd03 100644
--- a/src/models/misc/minimum_axiom_set.rs
+++ b/src/models/misc/minimum_axiom_set.rs
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Minimum Axiom Set",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find smallest axiom subset whose deductive closure equals the true sentences",
         fields: &[
@@ -44,7 +45,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumAxiomSet;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 8 sentences, all true, with implications forming a cycle
 /// let problem = MinimumAxiomSet::new(
@@ -58,7 +59,7 @@ inventory::submit! {
 ///     ],
 /// );
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -163,45 +164,61 @@ fn deductive_closure(current: &mut [bool], implications: &[(Vec<usize>, usize)])
 
 impl Problem for MinimumAxiomSet {
     const NAME: &'static str = "MinimumAxiomSet";
-    type Value = Min<usize>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_implications", num_implications),
+        ("num_sentences", num_sentences),
+        ("num_true_sentences", num_true_sentences),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_true_sentences()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if config.len() != self.num_true_sentences() {
-            return Min(None);
-        }
-        if config.iter().any(|&v| v >= 2) {
-            return Min(None);
-        }
-
-        // Build the initial set of selected axioms
-        let mut current = vec![false; self.num_sentences];
-        let mut count = 0usize;
-        for (i, &v) in config.iter().enumerate() {
-            if v == 1 {
-                current[self.true_sentences[i]] = true;
-                count += 1;
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.num_true_sentences() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "axiom-selection length does not match the true sentences".into(),
+                ));
+            }
+            // Build the initial set of selected axioms
+            let mut current = vec![false; self.num_sentences];
+            let mut count = 0usize;
+            for (i, &v) in config.iter().enumerate() {
+                if v {
+                    current[self.true_sentences[i]] = true;
+                    count += 1;
+                }
             }
-        }
 
-        // Compute deductive closure
-        deductive_closure(&mut current, &self.implications);
+            // Compute deductive closure
+            deductive_closure(&mut current, &self.implications);
 
-        // Check if closure equals T
-        let closure_equals_t = self.true_sentences.iter().all(|&s| current[s]);
+            // Check if closure equals T
+            let closure_equals_t = self.true_sentences.iter().all(|&s| current[s]);
 
-        if closure_equals_t {
-            Min(Some(count))
-        } else {
-            Min(None)
-        }
+            if closure_equals_t {
+                Min(Some(i64::try_from(count).map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting axiom-set size to i64".into(),
+                    )
+                })?))
+            } else {
+                Min(None)
+            }
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MinimumAxiomSet {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_true_sentences()]
     }
 }
 
@@ -209,6 +226,10 @@ crate::declare_variants! {
     default MinimumAxiomSet => "2^num_true_sentences",
 }
 
+crate::register_brute_force! {
+    MinimumAxiomSet decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 8 sentences, all true, with implications forming a cycle
@@ -229,7 +250,9 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 (vec![6, 7], 1),
             ],
         )),
-        optimal_config: vec![1, 1, 0, 0, 0, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![
+            true, true, false, false, false, false, false, false
+        ]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/misc/minimum_code_generation_one_register.rs b/src/models/misc/minimum_code_generation_one_register.rs
index 58fe83a27..c0b1c6d4c 100644
--- a/src/models/misc/minimum_code_generation_one_register.rs
+++ b/src/models/misc/minimum_code_generation_one_register.rs
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Minimum Code Generation (One Register)",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find minimum-length instruction sequence for a one-register machine to evaluate an expression DAG",
         fields: &[
@@ -43,7 +44,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumCodeGenerationOneRegister;
-/// use problemreductions::{Problem, Solver, BruteForce, Min};
+/// use problemreductions::{Problem, BruteForce, Min};
 ///
 /// // 7 vertices: leaves {4,5,6}, internal {0,1,2,3}
 /// // v3 = op(v5, v6), v1 = op(v3, v4), v2 = op(v3, v5), v0 = op(v1, v2)
@@ -52,8 +53,8 @@ inventory::submit! {
 ///     vec![(0,1),(0,2),(1,3),(1,4),(2,3),(2,5),(3,5),(3,6)],
 ///     3,
 /// );
-/// let result = BruteForce::new().solve(&problem);
-/// assert_eq!(result, Min(Some(8)));
+/// let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+/// assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(8)));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumCodeGenerationOneRegister {
@@ -164,11 +165,14 @@ impl MinimumCodeGenerationOneRegister {
     /// Simulate the one-register machine for a given evaluation order of
     /// internal vertices and return the instruction count, or `None` if the
     /// ordering is invalid (not a permutation or violates dependencies).
-    pub fn simulate(&self, config: &[usize]) -> Option<usize> {
+    pub fn simulate(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         let internal = self.internal_vertices();
         let n_internal = internal.len();
         if config.len() != n_internal {
-            return None;
+            return Ok(None);
         }
 
         // config[i] = evaluation position for internal vertex index i
@@ -178,10 +182,10 @@ impl MinimumCodeGenerationOneRegister {
         let mut used = vec![false; n_internal];
         for (i, &pos) in config.iter().enumerate() {
             if pos >= n_internal {
-                return None;
+                return Ok(None);
             }
             if used[pos] {
-                return None;
+                return Ok(None);
             }
             used[pos] = true;
             order[pos] = i;
@@ -218,7 +222,7 @@ impl MinimumCodeGenerationOneRegister {
             }
         }
 
-        let mut instructions = 0usize;
+        let mut instructions = 0_i64;
 
         for step in 0..n_internal {
             let v = internal[order[step]];
@@ -227,7 +231,7 @@ impl MinimumCodeGenerationOneRegister {
             for &c in &children[v] {
                 let available = in_memory[c] || register == Some(c);
                 if !available {
-                    return None; // child was computed but lost (not stored, overwritten)
+                    return Ok(None); // child was computed but lost (not stored, overwritten)
                 }
             }
 
@@ -245,7 +249,11 @@ impl MinimumCodeGenerationOneRegister {
             // 3. That value is not already in memory
             if let Some(r) = register {
                 if !in_memory[r] && future_uses[r] > 0 {
-                    instructions += 1; // STORE
+                    instructions = instructions.checked_add(1).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "counting one-register instructions".to_string(),
+                        )
+                    })?; // STORE
                     in_memory[r] = true;
                 }
             }
@@ -257,44 +265,82 @@ impl MinimumCodeGenerationOneRegister {
                 let one_in_register = (register == Some(c0) && in_memory[c1])
                     || (register == Some(c1) && in_memory[c0]);
                 if one_in_register {
-                    instructions += 1; // OP v (one operand in register, other in memory)
+                    instructions = instructions.checked_add(1).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "counting one-register instructions".to_string(),
+                        )
+                    })?; // OP v
                 } else {
                     // Need to LOAD one operand, OP with the other from memory
-                    instructions += 1; // LOAD
-                    instructions += 1; // OP
+                    instructions = instructions.checked_add(2).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "counting one-register instructions".to_string(),
+                        )
+                    })?; // LOAD + OP
                 }
             } else if operands.len() == 1 {
                 let c0 = operands[0];
                 if register == Some(c0) {
-                    instructions += 1; // OP v (unary)
+                    instructions = instructions.checked_add(1).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "counting one-register instructions".to_string(),
+                        )
+                    })?; // OP v
                 } else {
-                    instructions += 1; // LOAD
-                    instructions += 1; // OP
+                    instructions = instructions.checked_add(2).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "counting one-register instructions".to_string(),
+                        )
+                    })?; // LOAD + OP
                 }
             }
 
             register = Some(v);
         }
 
-        Some(instructions)
+        Ok(Some(instructions))
     }
 }
 
 impl Problem for MinimumCodeGenerationOneRegister {
     const NAME: &'static str = "MinimumCodeGenerationOneRegister";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_vertices", num_vertices),
+        ("num_edges", num_edges),
+        ("num_leaves", num_leaves),
+        ("num_internal", num_internal),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let n_internal = self.num_internal();
-        vec![n_internal; n_internal]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        let n = self.internal_vertices().len();
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "evaluation ordering length does not match the internal vertices".into(),
+            ));
+        }
+        if config.iter().any(|&position| position >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "evaluation ordering contains an out-of-range position".into(),
+            ));
+        }
+        Ok(Min(self.simulate(config)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        Min(self.simulate(config))
+impl crate::solvers::BruteForceProblem for MinimumCodeGenerationOneRegister {
+    fn dimensions(&self) -> Vec<usize> {
+        let n_internal = self.num_internal();
+        vec![n_internal; n_internal]
     }
 }
 
@@ -302,6 +348,10 @@ crate::declare_variants! {
     default MinimumCodeGenerationOneRegister => "2 ^ num_vertices",
 }
 
+crate::register_brute_force! {
+    MinimumCodeGenerationOneRegister,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -328,7 +378,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
             3,
         )),
-        optimal_config: vec![3, 2, 1, 0],
+        optimal_config: serde_json::json!(vec![3, 2, 1, 0]),
         optimal_value: serde_json::json!(8),
     }]
 }
diff --git a/src/models/misc/minimum_code_generation_parallel_assignments.rs b/src/models/misc/minimum_code_generation_parallel_assignments.rs
index 09f4595fd..405f7a962 100644
--- a/src/models/misc/minimum_code_generation_parallel_assignments.rs
+++ b/src/models/misc/minimum_code_generation_parallel_assignments.rs
@@ -15,6 +15,7 @@ inventory::submit! {
         display_name: "Minimum Code Generation (Parallel Assignments)",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find an ordering of parallel assignments minimizing backward dependencies",
         fields: &[
@@ -36,7 +37,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumCodeGenerationParallelAssignments;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 4 variables, 4 assignments:
 /// // A_0: a <- op(b, c)   -> (0, [1, 2])
@@ -51,7 +52,7 @@ inventory::submit! {
 /// ];
 /// let problem = MinimumCodeGenerationParallelAssignments::new(4, assignments);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -102,56 +103,81 @@ impl MinimumCodeGenerationParallelAssignments {
 
 impl Problem for MinimumCodeGenerationParallelAssignments {
     const NAME: &'static str = "MinimumCodeGenerationParallelAssignments";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_variables", num_variables),
+        ("num_assignments", num_assignments),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let m = self.num_assignments();
-        vec![m; m]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        let m = self.num_assignments();
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let m = self.num_assignments();
+
+            // Validate config length
+            if config.len() != m {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "assignment length does not match the internal nodes".into(),
+                ));
+            }
 
-        // Validate config length
-        if config.len() != m {
-            return Min(None);
-        }
+            if config.iter().any(|&position| position >= m) {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "assignment contains an out-of-range execution position".into(),
+                ));
+            }
 
-        // Validate permutation: all values must be distinct and in 0..m
-        let mut seen = vec![false; m];
-        for &pos in config {
-            if pos >= m || seen[pos] {
-                return Min(None);
+            // Validate permutation: all values must be distinct and in 0..m
+            let mut seen = vec![false; m];
+            for &pos in config {
+                if seen[pos] {
+                    return Ok(Min(None));
+                }
+                seen[pos] = true;
             }
-            seen[pos] = true;
-        }
 
-        // config[i] = position of assignment i in execution order
-        // Build execution order: order[pos] = assignment index
-        let mut order = vec![0usize; m];
-        for (assignment_idx, &pos) in config.iter().enumerate() {
-            order[pos] = assignment_idx;
-        }
+            // config[i] = position of assignment i in execution order
+            // Build execution order: order[pos] = assignment index
+            let mut order = vec![0usize; m];
+            for (assignment_idx, &pos) in config.iter().enumerate() {
+                order[pos] = assignment_idx;
+            }
 
-        // Count backward dependencies: for each pair (i, j) where i < j
-        // (i executes before j), check if the target variable of order[i]
-        // is in the read set of order[j]
-        let mut count = 0usize;
-        for (i, &earlier) in order.iter().enumerate() {
-            let (target_var, _) = &self.assignments[earlier];
-            for &later in &order[(i + 1)..] {
-                let (_, read_vars) = &self.assignments[later];
-                if read_vars.contains(target_var) {
-                    count += 1;
+            // Count backward dependencies: for each pair (i, j) where i < j
+            // (i executes before j), check if the target variable of order[i]
+            // is in the read set of order[j]
+            let mut count = 0usize;
+            for (i, &earlier) in order.iter().enumerate() {
+                let (target_var, _) = &self.assignments[earlier];
+                for &later in &order[(i + 1)..] {
+                    let (_, read_vars) = &self.assignments[later];
+                    if read_vars.contains(target_var) {
+                        count += 1;
+                    }
                 }
             }
-        }
 
-        Min(Some(count))
+            Min(Some(i64::try_from(count).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting parallel instruction count to i64".into(),
+                )
+            })?))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MinimumCodeGenerationParallelAssignments {
+    fn dimensions(&self) -> Vec<usize> {
+        let m = self.num_assignments();
+        vec![m; m]
     }
 }
 
@@ -159,6 +185,10 @@ crate::declare_variants! {
     default MinimumCodeGenerationParallelAssignments => "2^num_assignments",
 }
 
+crate::register_brute_force! {
+    MinimumCodeGenerationParallelAssignments,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 4 variables, 4 assignments:
@@ -180,7 +210,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             4,
             assignments,
         )),
-        optimal_config: vec![0, 3, 1, 2],
+        optimal_config: serde_json::json!(vec![0, 3, 1, 2]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/misc/minimum_code_generation_unlimited_registers.rs b/src/models/misc/minimum_code_generation_unlimited_registers.rs
index e4144d608..fbf5f84ee 100644
--- a/src/models/misc/minimum_code_generation_unlimited_registers.rs
+++ b/src/models/misc/minimum_code_generation_unlimited_registers.rs
@@ -19,6 +19,7 @@ inventory::submit! {
         display_name: "Minimum Code Generation (Unlimited Registers)",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find minimum-length instruction sequence for an unlimited-register machine with 2-address instructions to evaluate an expression DAG",
         fields: &[
@@ -48,7 +49,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumCodeGenerationUnlimitedRegisters;
-/// use problemreductions::{Problem, Solver, BruteForce, Min};
+/// use problemreductions::{Problem, BruteForce, Min};
 ///
 /// // 5 vertices: leaves {3,4}, internal {0,1,2}
 /// // v1 = op(v3, v4), v2 = op(v3, v4), v0 = op(v1, v2)
@@ -57,8 +58,8 @@ inventory::submit! {
 ///     vec![(1,3),(2,3),(0,1)],  // left arcs (child destroyed)
 ///     vec![(1,4),(2,4),(0,2)],  // right arcs (child preserved)
 /// );
-/// let result = BruteForce::new().solve(&problem);
-/// assert_eq!(result, Min(Some(4)));
+/// let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+/// assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(4)));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumCodeGenerationUnlimitedRegisters {
@@ -213,11 +214,14 @@ impl MinimumCodeGenerationUnlimitedRegisters {
     /// - LOAD: copies a register value (needed when a left operand is still
     ///   needed later and would be destroyed)
     /// - Cost = num_OPs + num_LOADs
-    pub fn simulate(&self, config: &[usize]) -> Option<usize> {
+    pub fn simulate(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         let internal = self.internal_vertices();
         let n_internal = internal.len();
         if config.len() != n_internal {
-            return None;
+            return Ok(None);
         }
 
         // config[i] = evaluation position for internal vertex index i
@@ -226,10 +230,10 @@ impl MinimumCodeGenerationUnlimitedRegisters {
         let mut used = vec![false; n_internal];
         for (i, &pos) in config.iter().enumerate() {
             if pos >= n_internal {
-                return None;
+                return Ok(None);
             }
             if used[pos] {
-                return None;
+                return Ok(None);
             }
             used[pos] = true;
             order[pos] = i;
@@ -270,7 +274,7 @@ impl MinimumCodeGenerationUnlimitedRegisters {
             }
         }
 
-        let mut instructions = 0usize;
+        let mut instructions = 0_i64;
 
         // With unlimited registers, each value has its own register.
         // When OP v executes: result goes into left_child's register.
@@ -285,12 +289,12 @@ impl MinimumCodeGenerationUnlimitedRegisters {
             // Check dependencies
             if let Some(l) = lc {
                 if !computed[l] {
-                    return None;
+                    return Ok(None);
                 }
             }
             if let Some(r) = rc {
                 if !computed[r] {
-                    return None;
+                    return Ok(None);
                 }
             }
 
@@ -306,36 +310,63 @@ impl MinimumCodeGenerationUnlimitedRegisters {
             if let Some(l) = lc {
                 let still_needed = future_left_uses[l] + future_right_uses[l] > 0;
                 if still_needed {
-                    instructions += 1; // LOAD (copy)
+                    instructions = instructions.checked_add(1).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "counting unlimited-register instructions".to_string(),
+                        )
+                    })?; // LOAD
                 }
             }
 
             // OP v
-            instructions += 1;
+            instructions = instructions.checked_add(1).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "counting unlimited-register instructions".to_string(),
+                )
+            })?;
 
             // Mark v as computed
             computed[v] = true;
         }
 
-        Some(instructions)
+        Ok(Some(instructions))
     }
 }
 
 impl Problem for MinimumCodeGenerationUnlimitedRegisters {
     const NAME: &'static str = "MinimumCodeGenerationUnlimitedRegisters";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let n_internal = self.num_internal();
-        vec![n_internal; n_internal]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        let n = self.internal_vertices().len();
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "evaluation ordering length does not match the internal vertices".into(),
+            ));
+        }
+        if config.iter().any(|&position| position >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "evaluation ordering contains an out-of-range position".into(),
+            ));
+        }
+        Ok(Min(self.simulate(config)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        Min(self.simulate(config))
+impl crate::solvers::BruteForceProblem for MinimumCodeGenerationUnlimitedRegisters {
+    fn dimensions(&self) -> Vec<usize> {
+        let n_internal = self.num_internal();
+        vec![n_internal; n_internal]
     }
 }
 
@@ -343,6 +374,10 @@ crate::declare_variants! {
     default MinimumCodeGenerationUnlimitedRegisters => "2 ^ num_vertices",
 }
 
+crate::register_brute_force! {
+    MinimumCodeGenerationUnlimitedRegisters,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -359,7 +394,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![(1, 3), (2, 3), (0, 1)],
             vec![(1, 4), (2, 4), (0, 2)],
         )),
-        optimal_config: vec![2, 0, 1],
+        optimal_config: serde_json::json!(vec![2, 0, 1]),
         optimal_value: serde_json::json!(4),
     }]
 }
diff --git a/src/models/misc/minimum_decision_tree.rs b/src/models/misc/minimum_decision_tree.rs
index 453b80089..da7297a4e 100644
--- a/src/models/misc/minimum_decision_tree.rs
+++ b/src/models/misc/minimum_decision_tree.rs
@@ -4,7 +4,7 @@
 //! that identifies each object with minimum total external path length
 //! (sum of depths of all leaves).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -15,13 +15,10 @@ inventory::submit! {
         display_name: "Minimum Decision Tree",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find decision tree identifying objects with minimum total path length",
-        fields: &[
-            FieldInfo { name: "test_matrix", type_name: "Vec<Vec<bool>>", description: "Binary matrix: test_matrix[j][i] = object i passes test j" },
-            FieldInfo { name: "num_objects", type_name: "usize", description: "Number of objects to identify" },
-            FieldInfo { name: "num_tests", type_name: "usize", description: "Number of available binary tests" },
-        ],
+        fields: MinimumDecisionTreeCreateSpec::FIELDS,
     }
 }
 
@@ -38,7 +35,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumDecisionTree;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = MinimumDecisionTree::new(
 ///     vec![
@@ -50,7 +47,7 @@ inventory::submit! {
 ///     3,
 /// );
 /// let solver = BruteForce::new();
-/// let value = solver.solve(&problem);
+/// let value = solver.solve(&problem).unwrap();
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumDecisionTree {
@@ -62,6 +59,55 @@ pub struct MinimumDecisionTree {
     num_tests: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumDecisionTreeCreateSpec {
+    /// Binary test matrix as JSON.
+    #[create(codec = "json")]
+    test_matrix: Vec<Vec<bool>>,
+    /// Number of objects.
+    num_objects: usize,
+    /// Number of tests.
+    num_tests: usize,
+}
+
+impl TryFrom<MinimumDecisionTreeCreateSpec> for MinimumDecisionTree {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumDecisionTreeCreateSpec) -> Result<Self, Self::Error> {
+        if spec.num_objects < 2 {
+            return Err("num_objects must be at least 2".into());
+        }
+        if spec.num_tests == 0 {
+            return Err("num_tests must be positive".into());
+        }
+        if spec.test_matrix.len() != spec.num_tests {
+            return Err("test_matrix row count must equal num_tests".into());
+        }
+        if spec
+            .test_matrix
+            .iter()
+            .any(|row| row.len() != spec.num_objects)
+        {
+            return Err("each test_matrix row must have num_objects columns".into());
+        }
+        for a in 0..spec.num_objects {
+            for b in a + 1..spec.num_objects {
+                if !(0..spec.num_tests)
+                    .any(|test| spec.test_matrix[test][a] != spec.test_matrix[test][b])
+                {
+                    return Err(
+                        format!("objects {a} and {b} are not distinguished by any test").into(),
+                    );
+                }
+            }
+        }
+        Ok(Self {
+            test_matrix: spec.test_matrix,
+            num_objects: spec.num_objects,
+            num_tests: spec.num_tests,
+        })
+    }
+}
+
 impl MinimumDecisionTree {
     /// Create a new MinimumDecisionTree problem.
     ///
@@ -128,11 +174,11 @@ impl MinimumDecisionTree {
 
     /// Simulate the decision tree for all objects and return total external path length,
     /// or None if the tree is invalid (doesn't identify all objects uniquely).
-    fn simulate(&self, config: &[usize]) -> Option<usize> {
+    fn simulate(&self, config: &[usize]) -> Result<Option<i64>, crate::traits::EvaluationError> {
         let sentinel = self.leaf_sentinel();
         let max_slots = self.num_tree_slots();
         let mut seen_leaves = std::collections::HashSet::new();
-        let mut total_depth = 0usize;
+        let mut total_depth = 0_i64;
 
         for obj in 0..self.num_objects {
             let mut node = 0usize;
@@ -142,9 +188,18 @@ impl MinimumDecisionTree {
                 if node >= max_slots || config[node] == sentinel {
                     // Two objects at same leaf — invalid
                     if !seen_leaves.insert(node) {
-                        return None;
+                        return Ok(None);
                     }
-                    total_depth += depth;
+                    let depth = i64::try_from(depth).map_err(|_| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "converting decision-tree depth to i64".to_string(),
+                        )
+                    })?;
+                    total_depth = total_depth.checked_add(depth).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing decision-tree external path length".to_string(),
+                        )
+                    })?;
                     break;
                 }
 
@@ -156,29 +211,34 @@ impl MinimumDecisionTree {
                 depth += 1;
 
                 if depth > self.num_objects {
-                    return None;
+                    return Ok(None);
                 }
             }
         }
 
-        Some(total_depth)
+        Ok(Some(total_depth))
     }
 }
 
 impl Problem for MinimumDecisionTree {
     const NAME: &'static str = "MinimumDecisionTree";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        // Each internal node can hold test 0..num_tests-1 or sentinel (leaf)
-        vec![self.num_tests + 1; self.num_tree_slots()]
-    }
+    crate::problem_parameters![("num_objects", num_objects), ("num_tests", num_tests),];
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if config.len() != self.num_tree_slots() {
-            return Min(None);
-        }
-        Min(self.simulate(config))
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.num_tree_slots() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "decision-tree encoding length does not match the instance".into(),
+                ));
+            }
+            Min(self.simulate(config)?)
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -186,8 +246,19 @@ impl Problem for MinimumDecisionTree {
     }
 }
 
+impl crate::solvers::BruteForceProblem for MinimumDecisionTree {
+    fn dimensions(&self) -> Vec<usize> {
+        // Each internal node can hold test 0..num_tests-1 or sentinel (leaf)
+        vec![self.num_tests + 1; self.num_tree_slots()]
+    }
+}
+
 crate::declare_variants! {
-    default MinimumDecisionTree => "num_tests^num_objects",
+    default MinimumDecisionTree => "num_tests^num_objects" create MinimumDecisionTreeCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumDecisionTree,
 }
 
 #[cfg(feature = "example-db")]
@@ -204,7 +275,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             3,
         )),
         // T0 at root, T2 left, T1 right, rest are leaves (sentinel=3)
-        optimal_config: vec![0, 2, 1, 3, 3, 3, 3],
+        optimal_config: serde_json::json!(vec![0, 2, 1, 3, 3, 3, 3]),
         optimal_value: serde_json::json!(8),
     }]
 }
diff --git a/src/models/misc/minimum_discrete_planar_inverse_kinematics.rs b/src/models/misc/minimum_discrete_planar_inverse_kinematics.rs
index deff9704a..f002f1bc5 100644
--- a/src/models/misc/minimum_discrete_planar_inverse_kinematics.rs
+++ b/src/models/misc/minimum_discrete_planar_inverse_kinematics.rs
@@ -6,7 +6,7 @@
 //! consecutive-pair constraints are satisfied and the squared distance from
 //! the end-effector to the target point is minimized.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Minimum Discrete Planar Inverse Kinematics",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Pick one sampled absolute orientation per link, subject to consecutive-pair feasibility constraints, to minimize the squared distance from the end-effector to a target point",
         fields: &[
@@ -44,13 +45,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "MinimumDiscretePlanarInverseKinematics",
-        fields: &["num_links"],
-    }
-}
-
 /// The Minimum Discrete Planar Inverse Kinematics problem.
 ///
 /// Given positive link lengths `l_1, ..., l_n`, a target point `g` in
@@ -61,7 +55,7 @@ inventory::submit! {
 /// for every `j = 2, ..., n`, minimizing
 ///
 /// `|| Σ_{j=1}^n l_j (cos(phi_{j,a_j}), sin(phi_{j,a_j})) - g ||_2^2`.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct MinimumDiscretePlanarInverseKinematics {
     link_lengths: Vec<f64>,
     target_point: (f64, f64),
@@ -69,75 +63,96 @@ pub struct MinimumDiscretePlanarInverseKinematics {
     allowed_pairs: Vec<Vec<(usize, usize)>>,
 }
 
+#[derive(Deserialize)]
+struct MinimumDiscretePlanarInverseKinematicsData {
+    link_lengths: Vec<f64>,
+    target_point: (f64, f64),
+    orientation_samples: Vec<Vec<f64>>,
+    allowed_pairs: Vec<Vec<(usize, usize)>>,
+}
+
+impl<'de> Deserialize<'de> for MinimumDiscretePlanarInverseKinematics {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let data = MinimumDiscretePlanarInverseKinematicsData::deserialize(deserializer)?;
+        Self::new(
+            data.link_lengths,
+            data.target_point,
+            data.orientation_samples,
+            data.allowed_pairs,
+        )
+        .map_err(serde::de::Error::custom)
+    }
+}
+
 impl MinimumDiscretePlanarInverseKinematics {
     /// Construct a new instance.
     ///
-    /// # Panics
-    /// Panics if the input fields are not mutually consistent (see the
-    /// validation rules in the source).
     pub fn new(
         link_lengths: Vec<f64>,
         target_point: (f64, f64),
         orientation_samples: Vec<Vec<f64>>,
         allowed_pairs: Vec<Vec<(usize, usize)>>,
-    ) -> Self {
+    ) -> Result<Self, crate::registry::ConstructionError> {
         let n = link_lengths.len();
-        assert!(
-            n >= 1,
-            "MinimumDiscretePlanarInverseKinematics requires at least one link"
-        );
-        for &length in &link_lengths {
-            assert!(
-                length.is_finite() && length > 0.0,
-                "link lengths must be positive finite reals"
-            );
+        if n == 0 {
+            return Err("MinimumDiscretePlanarInverseKinematics requires at least one link".into());
+        }
+        for (index, &length) in link_lengths.iter().enumerate() {
+            if !length.is_finite() || length <= 0.0 {
+                return Err(
+                    format!("link length at index {index} must be positive and finite").into(),
+                );
+            }
+        }
+        if !target_point.0.is_finite() || !target_point.1.is_finite() {
+            return Err("target point coordinates must be finite".into());
+        }
+        if orientation_samples.len() != n {
+            return Err("orientation_samples must have one entry per link".into());
         }
-        assert!(
-            target_point.0.is_finite() && target_point.1.is_finite(),
-            "target point coordinates must be finite reals"
-        );
-        assert_eq!(
-            orientation_samples.len(),
-            n,
-            "orientation_samples must have one entry per link"
-        );
-        for samples in &orientation_samples {
-            assert!(
-                !samples.is_empty(),
-                "each link must have at least one candidate orientation"
-            );
-            for &angle in samples {
-                assert!(
-                    angle.is_finite(),
-                    "orientation samples must be finite real numbers"
+        let mut total_configurations = 1_usize;
+        for (link, samples) in orientation_samples.iter().enumerate() {
+            if samples.is_empty() {
+                return Err(
+                    format!("link {link} must have at least one candidate orientation").into(),
                 );
             }
+            total_configurations = total_configurations
+                .checked_mul(samples.len())
+                .ok_or("orientation configuration count exceeds usize")?;
+            for (sample, &angle) in samples.iter().enumerate() {
+                if !angle.is_finite() {
+                    return Err(format!(
+                        "orientation sample {sample} for link {link} must be finite"
+                    )
+                    .into());
+                }
+            }
+        }
+        if allowed_pairs.len() != n - 1 {
+            return Err("allowed_pairs must have one entry per junction".into());
         }
-        assert_eq!(
-            allowed_pairs.len(),
-            n.saturating_sub(1),
-            "allowed_pairs must have one entry per junction (n - 1 entries)"
-        );
         for (j_minus_1, pairs) in allowed_pairs.iter().enumerate() {
             let m_prev = orientation_samples[j_minus_1].len();
             let m_curr = orientation_samples[j_minus_1 + 1].len();
             for &(a_prev, a_curr) in pairs {
-                assert!(
-                    a_prev < m_prev,
-                    "allowed_pair index out of range for previous link"
-                );
-                assert!(
-                    a_curr < m_curr,
-                    "allowed_pair index out of range for current link"
-                );
+                if a_prev >= m_prev || a_curr >= m_curr {
+                    return Err(format!(
+                        "allowed pair ({a_prev}, {a_curr}) at junction {j_minus_1} is out of range"
+                    )
+                    .into());
+                }
             }
         }
-        Self {
+        Ok(Self {
             link_lengths,
             target_point,
             orientation_samples,
             allowed_pairs,
-        }
+        })
     }
 
     /// Get the link lengths.
@@ -168,7 +183,11 @@ impl MinimumDiscretePlanarInverseKinematics {
     /// Total number of configurations (product of per-link sample counts):
     /// `prod_{j=1}^n m_j`. This is the size of the brute-force search space.
     pub fn total_configurations(&self) -> usize {
-        self.orientation_samples.iter().map(|s| s.len()).product()
+        self.orientation_samples
+            .iter()
+            .map(|samples| samples.len())
+            .try_fold(1_usize, usize::checked_mul)
+            .expect("validated orientation configuration count must fit usize")
     }
 
     /// Total number of sampled orientations across all links:
@@ -201,27 +220,48 @@ impl MinimumDiscretePlanarInverseKinematics {
 
     /// Compute the end-effector position for a configuration.
     /// Returns `None` if the configuration is infeasible.
-    pub fn end_effector(&self, config: &[usize]) -> Option<(f64, f64)> {
+    pub fn end_effector(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<(f64, f64)>, crate::traits::EvaluationError> {
         if !self.is_feasible(config) {
-            return None;
+            return Ok(None);
         }
         let mut x = 0.0_f64;
         let mut y = 0.0_f64;
         for (j, &a) in config.iter().enumerate() {
             let phi = self.orientation_samples[j][a];
-            x += self.link_lengths[j] * phi.cos();
-            y += self.link_lengths[j] * phi.sin();
+            let next_x = x + self.link_lengths[j] * phi.cos();
+            let next_y = y + self.link_lengths[j] * phi.sin();
+            if !next_x.is_finite() || !next_y.is_finite() {
+                return Err(crate::traits::EvaluationError::NonFiniteResult(
+                    "computing the inverse-kinematics end-effector position".into(),
+                ));
+            }
+            x = next_x;
+            y = next_y;
         }
-        Some((x, y))
+        Ok(Some((x, y)))
     }
 
     /// Compute the squared end-effector distance to the target.
     /// Returns `None` if the configuration is infeasible.
-    pub fn squared_distance(&self, config: &[usize]) -> Option<f64> {
-        let (x, y) = self.end_effector(config)?;
+    pub fn squared_distance(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<f64>, crate::traits::EvaluationError> {
+        let Some((x, y)) = self.end_effector(config)? else {
+            return Ok(None);
+        };
         let dx = x - self.target_point.0;
         let dy = y - self.target_point.1;
-        Some(dx * dx + dy * dy)
+        let squared_distance = dx * dx + dy * dy;
+        if !squared_distance.is_finite() {
+            return Err(crate::traits::EvaluationError::NonFiniteResult(
+                "computing the inverse-kinematics squared distance".into(),
+            ));
+        }
+        Ok(Some(squared_distance))
     }
 
     /// Whether the configuration represents a valid feasible solution.
@@ -232,43 +272,78 @@ impl MinimumDiscretePlanarInverseKinematics {
 
 impl Problem for MinimumDiscretePlanarInverseKinematics {
     const NAME: &'static str = "MinimumDiscretePlanarInverseKinematics";
+    type Solution = Vec<usize>;
     type Value = Min<f64>;
 
+    crate::problem_parameters![
+        ("total_configurations", total_configurations),
+        ("num_links", num_links),
+        ("num_orientation_samples", num_orientation_samples),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<f64>, crate::traits::EvaluationError> {
+        if config.len() != self.num_links() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "orientation assignment length does not match the links".into(),
+            ));
+        }
+        if config
+            .iter()
+            .enumerate()
+            .any(|(link, &orientation)| orientation >= self.orientation_samples[link].len())
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "orientation assignment contains an out-of-range sample".into(),
+            ));
+        }
+        Ok({
+            match self.squared_distance(config)? {
+                Some(value) => Min(Some(value)),
+                None => Min(None),
+            }
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MinimumDiscretePlanarInverseKinematics {
+    fn dimensions(&self) -> Vec<usize> {
         self.orientation_samples
             .iter()
             .map(|samples| samples.len())
             .collect()
     }
-
-    fn evaluate(&self, config: &[usize]) -> Min<f64> {
-        match self.squared_distance(config) {
-            Some(value) => Min(Some(value)),
-            None => Min(None),
-        }
-    }
 }
 
 crate::declare_variants! {
     default MinimumDiscretePlanarInverseKinematics => "total_configurations",
 }
 
+crate::register_brute_force! {
+    MinimumDiscretePlanarInverseKinematics,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     use std::f64::consts::FRAC_PI_2;
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "minimum_discrete_planar_inverse_kinematics",
-        instance: Box::new(MinimumDiscretePlanarInverseKinematics::new(
-            vec![2.0, 1.0],
-            (2.0, 1.0),
-            vec![vec![0.0, FRAC_PI_2], vec![0.0, FRAC_PI_2]],
-            vec![vec![(0, 0), (0, 1), (1, 1)]],
-        )),
-        optimal_config: vec![0, 1],
+        instance: Box::new(
+            MinimumDiscretePlanarInverseKinematics::new(
+                vec![2.0, 1.0],
+                (2.0, 1.0),
+                vec![vec![0.0, FRAC_PI_2], vec![0.0, FRAC_PI_2]],
+                vec![vec![(0, 0), (0, 1), (1, 1)]],
+            )
+            .unwrap(),
+        ),
+        optimal_config: serde_json::json!(vec![0, 1]),
         optimal_value: serde_json::json!(0.0),
     }]
 }
diff --git a/src/models/misc/minimum_disjunctive_normal_form.rs b/src/models/misc/minimum_disjunctive_normal_form.rs
index a705a34e3..ac2b429c0 100644
--- a/src/models/misc/minimum_disjunctive_normal_form.rs
+++ b/src/models/misc/minimum_disjunctive_normal_form.rs
@@ -15,6 +15,7 @@ inventory::submit! {
         display_name: "Minimum Disjunctive Normal Form",
         aliases: &["MinDNF"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find minimum-term DNF formula equivalent to a Boolean function",
         fields: &[
@@ -60,13 +61,13 @@ impl PrimeImplicant {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumDisjunctiveNormalForm;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // f(x1,x2,x3) = 1 when exactly 1 or 2 variables are true
 /// let truth_table = vec![false, true, true, true, true, true, true, false];
 /// let problem = MinimumDisjunctiveNormalForm::new(3, truth_table);
 /// let solver = BruteForce::new();
-/// let value = solver.solve(&problem);
+/// let value = solver.solve(&problem).unwrap();
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumDisjunctiveNormalForm {
@@ -142,39 +143,52 @@ impl MinimumDisjunctiveNormalForm {
 
 impl Problem for MinimumDisjunctiveNormalForm {
     const NAME: &'static str = "MinimumDisjunctiveNormalForm";
-    type Value = Min<usize>;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.prime_implicants.len()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        if config.len() != self.prime_implicants.len() {
-            return Min(None);
-        }
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_variables", num_variables),
+        ("num_prime_implicants", num_prime_implicants),
+    ];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.prime_implicants.len() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "implicant-selection length does not match the instance".into(),
+                ));
+            }
 
-        // Collect selected prime implicants
-        let selected: Vec<usize> = config
-            .iter()
-            .enumerate()
-            .filter_map(|(i, &v)| if v == 1 { Some(i) } else { None })
-            .collect();
+            // Collect selected prime implicants
+            let selected: Vec<usize> = config
+                .iter()
+                .enumerate()
+                .filter_map(|(i, &v)| if v { Some(i) } else { None })
+                .collect();
 
-        if selected.is_empty() {
-            return Min(None);
-        }
+            if selected.is_empty() {
+                return Ok(Min(None));
+            }
 
-        // Check that all minterms are covered
-        for &mt in &self.minterms {
-            let covered = selected
-                .iter()
-                .any(|&pi_idx| self.prime_implicants[pi_idx].covers(mt));
-            if !covered {
-                return Min(None);
+            // Check that all minterms are covered
+            for &mt in &self.minterms {
+                let covered = selected
+                    .iter()
+                    .any(|&pi_idx| self.prime_implicants[pi_idx].covers(mt));
+                if !covered {
+                    return Ok(Min(None));
+                }
             }
-        }
 
-        Min(Some(selected.len()))
+            Min(Some(i64::try_from(selected.len()).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting DNF term count to i64".into(),
+                )
+            })?))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -182,10 +196,20 @@ impl Problem for MinimumDisjunctiveNormalForm {
     }
 }
 
+impl crate::solvers::BruteForceProblem for MinimumDisjunctiveNormalForm {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.prime_implicants.len()]
+    }
+}
+
 crate::declare_variants! {
     default MinimumDisjunctiveNormalForm => "2^(3^num_variables)",
 }
 
+crate::register_brute_force! {
+    MinimumDisjunctiveNormalForm decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 /// Compute all prime implicants of a Boolean function using Quine-McCluskey.
 ///
 /// Each implicant is represented as a Vec<Option<bool>> of length num_variables.
@@ -284,7 +308,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         // Select prime implicants: p1(¬x1∧x2), p4(x1∧¬x3), p5(¬x2∧x3)
         // The order of PIs depends on the QMC algorithm output.
         // We'll verify this in tests.
-        optimal_config: vec![1, 0, 0, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![true, false, false, true, true, false]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/misc/minimum_external_macro_data_compression.rs b/src/models/misc/minimum_external_macro_data_compression.rs
index dd6fbbd0d..dbaa37c8f 100644
--- a/src/models/misc/minimum_external_macro_data_compression.rs
+++ b/src/models/misc/minimum_external_macro_data_compression.rs
@@ -25,12 +25,13 @@ inventory::submit! {
         display_name: "Minimum External Macro Data Compression",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find minimum-cost compression using an external dictionary and compressed string with pointers",
         fields: &[
             FieldInfo { name: "alphabet_size", type_name: "usize", description: "Size of the alphabet (symbols indexed 0..alphabet_size)" },
             FieldInfo { name: "string", type_name: "Vec<usize>", description: "Source string as symbol indices" },
-            FieldInfo { name: "pointer_cost", type_name: "usize", description: "Pointer cost h (each pointer contributes h to the cost)" },
+            FieldInfo { name: "pointer_cost", type_name: "i64", description: "Pointer cost h (each pointer contributes h to the cost)" },
         ],
     }
 }
@@ -59,19 +60,56 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumExternalMacroDataCompression;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Alphabet {a, b}, string "abab", pointer cost h=2
 /// let problem = MinimumExternalMacroDataCompression::new(2, vec![0, 1, 0, 1], 2);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(try_from = "MinimumExternalMacroDataCompressionSerde")]
 pub struct MinimumExternalMacroDataCompression {
     alphabet_size: usize,
     string: Vec<usize>,
-    pointer_cost: usize,
+    pointer_cost: i64,
+}
+
+#[derive(Deserialize)]
+struct MinimumExternalMacroDataCompressionSerde {
+    alphabet_size: usize,
+    string: Vec<usize>,
+    pointer_cost: i64,
+}
+
+impl TryFrom<MinimumExternalMacroDataCompressionSerde> for MinimumExternalMacroDataCompression {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(value: MinimumExternalMacroDataCompressionSerde) -> Result<Self, Self::Error> {
+        if value.alphabet_size == 0 && !value.string.is_empty() {
+            return Err("alphabet_size must be > 0 when the string is non-empty"
+                .to_string()
+                .into());
+        }
+        if value
+            .string
+            .iter()
+            .any(|&symbol| symbol >= value.alphabet_size)
+        {
+            return Err("all symbols must be less than alphabet_size"
+                .to_string()
+                .into());
+        }
+        if value.pointer_cost <= 0 {
+            return Err("pointer_cost must be positive".to_string().into());
+        }
+        Ok(Self {
+            alphabet_size: value.alphabet_size,
+            string: value.string,
+            pointer_cost: value.pointer_cost,
+        })
+    }
 }
 
 impl MinimumExternalMacroDataCompression {
@@ -81,7 +119,7 @@ impl MinimumExternalMacroDataCompression {
     ///
     /// Panics if `alphabet_size` is 0 and the string is non-empty, or if
     /// any symbol in the string is >= `alphabet_size`, or if `pointer_cost` is 0.
-    pub fn new(alphabet_size: usize, string: Vec<usize>, pointer_cost: usize) -> Self {
+    pub fn new(alphabet_size: usize, string: Vec<usize>, pointer_cost: i64) -> Self {
         assert!(
             alphabet_size > 0 || string.is_empty(),
             "alphabet_size must be > 0 when the string is non-empty"
@@ -111,7 +149,7 @@ impl MinimumExternalMacroDataCompression {
     }
 
     /// Returns the pointer cost h.
-    pub fn pointer_cost(&self) -> usize {
+    pub fn pointer_cost(&self) -> i64 {
         self.pointer_cost
     }
 
@@ -153,98 +191,144 @@ impl MinimumExternalMacroDataCompression {
 
 impl Problem for MinimumExternalMacroDataCompression {
     const NAME: &'static str = "MinimumExternalMacroDataCompression";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("alphabet_size", alphabet_size),
+        ("string_length", string_length),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let n = self.string.len();
-        let d_domain = self.alphabet_size + 1; // symbols + empty
-        let c_domain = self.c_domain_size(); // symbols + empty + pointers
-        let mut dims = vec![d_domain; n]; // D-slots
-        dims.extend(vec![c_domain; n]); // C-slots
-        dims
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        let n = self.string.len();
-        if config.len() != 2 * n {
-            return Min(None);
-        }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let n = self.string.len();
+            if config.len() != 2 * n {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "macro encoding length does not match the string".into(),
+                ));
+            }
 
-        // Handle empty string case
-        if n == 0 {
-            return Min(Some(0));
-        }
+            // Handle empty string case
+            if n == 0 {
+                return Ok(Min(Some(0)));
+            }
 
-        let empty_d = self.alphabet_size; // empty marker for D-slots
-        let empty_c = self.alphabet_size; // empty marker for C-slots
+            let empty_d = self.alphabet_size; // empty marker for D-slots
+            let empty_c = self.alphabet_size; // empty marker for C-slots
 
-        // Decode D: prefix of non-empty D-slots
-        let d_slots = &config[..n];
-        let d_len = d_slots.iter().position(|&v| v == empty_d).unwrap_or(n);
+            // Decode D: prefix of non-empty D-slots
+            let d_slots = &config[..n];
+            let d_len = d_slots.iter().position(|&v| v == empty_d).unwrap_or(n);
 
-        // Verify contiguous: all after first empty must be empty
-        for &v in &d_slots[d_len..] {
-            if v != empty_d {
-                return Min(None);
+            // Verify contiguous: all after first empty must be empty
+            for &v in &d_slots[d_len..] {
+                if v != empty_d {
+                    return Ok(Min(None));
+                }
             }
-        }
 
-        // Verify D symbols are valid alphabet symbols
-        let d_str: Vec<usize> = d_slots[..d_len].to_vec();
-        if d_str.iter().any(|&v| v >= self.alphabet_size) {
-            return Min(None);
-        }
+            // Verify D symbols are valid alphabet symbols
+            let d_str: Vec<usize> = d_slots[..d_len].to_vec();
+            if d_str.iter().any(|&v| v >= self.alphabet_size) {
+                return Ok(Min(None));
+            }
 
-        // Decode C: prefix of non-empty C-slots
-        let c_slots = &config[n..];
-        let c_len = c_slots.iter().position(|&v| v == empty_c).unwrap_or(n);
+            // Decode C: prefix of non-empty C-slots
+            let c_slots = &config[n..];
+            let c_len = c_slots.iter().position(|&v| v == empty_c).unwrap_or(n);
 
-        // Verify contiguous: all after first empty must be empty
-        for &v in &c_slots[c_len..] {
-            if v != empty_c {
-                return Min(None);
+            // Verify contiguous: all after first empty must be empty
+            for &v in &c_slots[c_len..] {
+                if v != empty_c {
+                    return Ok(Min(None));
+                }
             }
-        }
 
-        // Decode C into a sequence of symbols, counting pointers
-        let mut decoded = Vec::new();
-        let mut pointer_count: usize = 0;
-
-        for &v in &c_slots[..c_len] {
-            if v < self.alphabet_size {
-                // Literal symbol
-                decoded.push(v);
-            } else if v > self.alphabet_size {
-                // Pointer into D
-                let ptr_idx = v - (self.alphabet_size + 1);
-                if let Some((start, len)) = self.decode_pointer(ptr_idx) {
-                    // Pointer must reference valid portion of D
-                    if start + len > d_len {
-                        return Min(None);
+            // Decode C into a sequence of symbols, counting pointers
+            let mut decoded = Vec::new();
+            let mut pointer_count: usize = 0;
+
+            for &v in &c_slots[..c_len] {
+                if v < self.alphabet_size {
+                    // Literal symbol
+                    decoded.push(v);
+                } else if v > self.alphabet_size {
+                    // Pointer into D
+                    let ptr_idx = v - (self.alphabet_size + 1);
+                    if let Some((start, len)) = self.decode_pointer(ptr_idx) {
+                        // Pointer must reference valid portion of D
+                        if start + len > d_len {
+                            return Ok(Min(None));
+                        }
+                        decoded.extend_from_slice(&d_str[start..start + len]);
+                        pointer_count += 1;
+                    } else {
+                        return Ok(Min(None));
                     }
-                    decoded.extend_from_slice(&d_str[start..start + len]);
-                    pointer_count += 1;
                 } else {
-                    return Min(None);
+                    // v == empty_c, but we already filtered those out
+                    return Ok(Min(None));
                 }
-            } else {
-                // v == empty_c, but we already filtered those out
-                return Min(None);
             }
-        }
 
-        // Check decoded string matches the source string
-        if decoded != self.string {
-            return Min(None);
-        }
+            // Check decoded string matches the source string
+            if decoded != self.string {
+                return Ok(Min(None));
+            }
 
-        // Compute cost: |D| + |C| + (h-1) * pointer_count
-        let cost = d_len + c_len + (self.pointer_cost - 1) * pointer_count;
-        Min(Some(cost))
+            // Compute cost: |D| + |C| + (h-1) * pointer_count
+            let d_len = i64::try_from(d_len).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting the dictionary length to i64".to_string(),
+                )
+            })?;
+            let c_len = i64::try_from(c_len).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting the compressed-string length to i64".to_string(),
+                )
+            })?;
+            let pointer_count = i64::try_from(pointer_count).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting the pointer count to i64".to_string(),
+                )
+            })?;
+            let pointer_cost = self
+                .pointer_cost
+                .checked_sub(1)
+                .and_then(|cost| cost.checked_mul(pointer_count))
+                .ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "computing the external macro pointer cost".to_string(),
+                    )
+                })?;
+            let cost = d_len
+                .checked_add(c_len)
+                .and_then(|cost| cost.checked_add(pointer_cost))
+                .ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "computing the external macro compression cost".to_string(),
+                    )
+                })?;
+            Min(Some(cost))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MinimumExternalMacroDataCompression {
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.string.len();
+        let d_domain = self.alphabet_size + 1; // symbols + empty
+        let c_domain = self.c_domain_size(); // symbols + empty + pointers
+        let mut dims = vec![d_domain; n]; // D-slots
+        dims.extend(vec![c_domain; n]); // C-slots
+        dims
     }
 }
 
@@ -252,6 +336,10 @@ crate::declare_variants! {
     default MinimumExternalMacroDataCompression => "(alphabet_size + 1) ^ string_length * (alphabet_size + 1 + string_length * (string_length + 1) / 2) ^ string_length",
 }
 
+crate::register_brute_force! {
+    MinimumExternalMacroDataCompression,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // Issue #441 example: alphabet {a,b,c,d,e,f} (6), s="abcdefabcdefabcdef" (18), h=2.
@@ -270,7 +358,8 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "minimum_external_macro_data_compression",
         instance: Box::new(MinimumExternalMacroDataCompression::new(6, s, 2)),
-        optimal_config,
+        optimal_config: serde_json::to_value(optimal_config)
+            .expect("solution serialization must succeed"),
         optimal_value: serde_json::json!(12),
     }]
 }
diff --git a/src/models/misc/minimum_fault_detection_test_set.rs b/src/models/misc/minimum_fault_detection_test_set.rs
index 43efeae64..daadcd56d 100644
--- a/src/models/misc/minimum_fault_detection_test_set.rs
+++ b/src/models/misc/minimum_fault_detection_test_set.rs
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Minimum Fault Detection Test Set",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find minimum set of input-output paths covering all internal DAG vertices",
         fields: &[
@@ -44,7 +45,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumFaultDetectionTestSet;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = MinimumFaultDetectionTestSet::new(
 ///     7,
@@ -53,9 +54,8 @@ inventory::submit! {
 ///     vec![5, 6],
 /// );
 /// let solver = BruteForce::new();
-/// use problemreductions::solvers::Solver as _;
-/// let optimal = solver.solve(&problem);
-/// assert_eq!(optimal, problemreductions::types::Min(Some(2)));
+/// let solution = solver.solve(&problem).unwrap().unwrap();
+/// assert_eq!(problem.evaluate(&solution).unwrap(), problemreductions::types::Min(Some(2)));
 /// ```
 #[derive(Debug, Clone, Serialize)]
 pub struct MinimumFaultDetectionTestSet {
@@ -269,56 +269,74 @@ impl MinimumFaultDetectionTestSet {
 
 impl Problem for MinimumFaultDetectionTestSet {
     const NAME: &'static str = "MinimumFaultDetectionTestSet";
-    type Value = Min<usize>;
+    type Solution = Vec<Vec<bool>>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_arcs", num_arcs),
+        ("num_inputs", num_inputs),
+        ("num_outputs", num_outputs),
+        ("num_vertices", num_vertices),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.inputs.len() * self.outputs.len()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        let num_pairs = self.inputs.len() * self.outputs.len();
-        if config.len() != num_pairs {
-            return Min(None);
-        }
-        if config.iter().any(|&c| c > 1) {
-            return Min(None);
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        if solution.len() != self.inputs.len()
+            || solution.iter().any(|row| row.len() != self.outputs.len())
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "fault-test matrix dimensions do not match the instance".into(),
+            ));
         }
+        Ok({
+            let mut boundary = vec![false; self.num_vertices];
+            for &input in &self.inputs {
+                boundary[input] = true;
+            }
+            for &output in &self.outputs {
+                boundary[output] = true;
+            }
+            let required_internal_vertices =
+                boundary.iter().filter(|&&is_boundary| !is_boundary).count();
 
-        let mut boundary = vec![false; self.num_vertices];
-        for &input in &self.inputs {
-            boundary[input] = true;
-        }
-        for &output in &self.outputs {
-            boundary[output] = true;
-        }
-        let required_internal_vertices =
-            boundary.iter().filter(|&&is_boundary| !is_boundary).count();
+            // Collect union of internal vertices covered by the selected pairs.
+            let mut covered: HashSet<usize> = HashSet::new();
+            let mut count = 0usize;
+            for (idx, &selected) in solution.iter().flatten().enumerate() {
+                if selected {
+                    count += 1;
+                    covered.extend(
+                        self.coverage[idx]
+                            .iter()
+                            .copied()
+                            .filter(|&vertex| !boundary[vertex]),
+                    );
+                }
+            }
 
-        // Collect union of internal vertices covered by the selected pairs.
-        let mut covered: HashSet<usize> = HashSet::new();
-        let mut count = 0usize;
-        for (idx, &sel) in config.iter().enumerate() {
-            if sel == 1 {
-                count += 1;
-                covered.extend(
-                    self.coverage[idx]
-                        .iter()
-                        .copied()
-                        .filter(|&vertex| !boundary[vertex]),
-                );
+            // Check all internal vertices are covered.
+            if covered.len() == required_internal_vertices {
+                Min(Some(i64::try_from(count).map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting test-set size to i64".into(),
+                    )
+                })?))
+            } else {
+                Min(None)
             }
-        }
+        })
+    }
+}
 
-        // Check all internal vertices are covered.
-        if covered.len() == required_internal_vertices {
-            Min(Some(count))
-        } else {
-            Min(None)
-        }
+impl crate::solvers::BruteForceProblem for MinimumFaultDetectionTestSet {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.inputs.len() * self.outputs.len()]
     }
 }
 
@@ -326,6 +344,10 @@ crate::declare_variants! {
     default MinimumFaultDetectionTestSet => "2^(num_inputs * num_outputs)",
 }
 
+crate::register_brute_force! {
+    MinimumFaultDetectionTestSet decode |problem: &MinimumFaultDetectionTestSet, indices: Vec<usize>| if problem.num_outputs() == 0 { vec![Vec::new(); problem.num_inputs()] } else { indices.chunks(problem.num_outputs()).map(crate::config::config_to_bits).collect() },
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 7 vertices, inputs={0,1}, outputs={5,6}
@@ -350,7 +372,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![0, 1],
             vec![5, 6],
         )),
-        optimal_config: vec![1, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![vec![true, false], vec![false, true]]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/misc/minimum_internal_macro_data_compression.rs b/src/models/misc/minimum_internal_macro_data_compression.rs
index 15f76309e..611981db0 100644
--- a/src/models/misc/minimum_internal_macro_data_compression.rs
+++ b/src/models/misc/minimum_internal_macro_data_compression.rs
@@ -23,12 +23,13 @@ inventory::submit! {
         display_name: "Minimum Internal Macro Data Compression",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find minimum-cost self-referencing compression of a string with embedded pointers",
         fields: &[
             FieldInfo { name: "alphabet_size", type_name: "usize", description: "Size of the alphabet (symbols indexed 0..alphabet_size)" },
             FieldInfo { name: "string", type_name: "Vec<usize>", description: "Source string as symbol indices" },
-            FieldInfo { name: "pointer_cost", type_name: "usize", description: "Pointer cost h (each pointer adds h−1 extra to the cost)" },
+            FieldInfo { name: "pointer_cost", type_name: "i64", description: "Pointer cost h (each pointer adds h−1 extra to the cost)" },
         ],
     }
 }
@@ -56,19 +57,56 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumInternalMacroDataCompression;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Alphabet {a, b}, string "abab", pointer cost h=2
 /// let problem = MinimumInternalMacroDataCompression::new(2, vec![0, 1, 0, 1], 2);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(try_from = "MinimumInternalMacroDataCompressionSerde")]
 pub struct MinimumInternalMacroDataCompression {
     alphabet_size: usize,
     string: Vec<usize>,
-    pointer_cost: usize,
+    pointer_cost: i64,
+}
+
+#[derive(Deserialize)]
+struct MinimumInternalMacroDataCompressionSerde {
+    alphabet_size: usize,
+    string: Vec<usize>,
+    pointer_cost: i64,
+}
+
+impl TryFrom<MinimumInternalMacroDataCompressionSerde> for MinimumInternalMacroDataCompression {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(value: MinimumInternalMacroDataCompressionSerde) -> Result<Self, Self::Error> {
+        if value.alphabet_size == 0 && !value.string.is_empty() {
+            return Err("alphabet_size must be > 0 when the string is non-empty"
+                .to_string()
+                .into());
+        }
+        if value
+            .string
+            .iter()
+            .any(|&symbol| symbol >= value.alphabet_size)
+        {
+            return Err("all symbols must be less than alphabet_size"
+                .to_string()
+                .into());
+        }
+        if value.pointer_cost <= 0 {
+            return Err("pointer_cost must be positive".to_string().into());
+        }
+        Ok(Self {
+            alphabet_size: value.alphabet_size,
+            string: value.string,
+            pointer_cost: value.pointer_cost,
+        })
+    }
 }
 
 impl MinimumInternalMacroDataCompression {
@@ -78,7 +116,7 @@ impl MinimumInternalMacroDataCompression {
     ///
     /// Panics if `alphabet_size` is 0 and the string is non-empty, or if
     /// any symbol in the string is >= `alphabet_size`, or if `pointer_cost` is 0.
-    pub fn new(alphabet_size: usize, string: Vec<usize>, pointer_cost: usize) -> Self {
+    pub fn new(alphabet_size: usize, string: Vec<usize>, pointer_cost: i64) -> Self {
         assert!(
             alphabet_size > 0 || string.is_empty(),
             "alphabet_size must be > 0 when the string is non-empty"
@@ -108,7 +146,7 @@ impl MinimumInternalMacroDataCompression {
     }
 
     /// Returns the pointer cost h.
-    pub fn pointer_cost(&self) -> usize {
+    pub fn pointer_cost(&self) -> i64 {
         self.pointer_cost
     }
 
@@ -182,40 +220,75 @@ impl MinimumInternalMacroDataCompression {
 
 impl Problem for MinimumInternalMacroDataCompression {
     const NAME: &'static str = "MinimumInternalMacroDataCompression";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("alphabet_size", alphabet_size), ("string_len", string_len),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let n = self.string.len();
-        let domain = self.alphabet_size + n + 1; // literals + EOS + pointers
-        vec![domain; n]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        let n = self.string.len();
-        if config.len() != n {
-            return Min(None);
-        }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let n = self.string.len();
+            if config.len() != n {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "macro encoding length does not match the string".into(),
+                ));
+            }
 
-        // Handle empty string
-        if n == 0 {
-            return Min(Some(0));
-        }
+            // Handle empty string
+            if n == 0 {
+                return Ok(Min(Some(0)));
+            }
 
-        match self.decode(config) {
-            Some((decoded, active_len, pointer_count)) => {
-                if decoded != self.string {
-                    Min(None)
-                } else {
-                    let cost = active_len + (self.pointer_cost - 1) * pointer_count;
-                    Min(Some(cost))
+            match self.decode(config) {
+                Some((decoded, active_len, pointer_count)) => {
+                    if decoded != self.string {
+                        Min(None)
+                    } else {
+                        let active_len = i64::try_from(active_len).map_err(|_| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "converting the active encoding length to i64".to_string(),
+                            )
+                        })?;
+                        let pointer_count = i64::try_from(pointer_count).map_err(|_| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "converting the pointer count to i64".to_string(),
+                            )
+                        })?;
+                        let pointer_cost = self
+                            .pointer_cost
+                            .checked_sub(1)
+                            .and_then(|cost| cost.checked_mul(pointer_count))
+                            .ok_or_else(|| {
+                                crate::traits::EvaluationError::IntegerOverflow(
+                                    "computing the internal macro pointer cost".to_string(),
+                                )
+                            })?;
+                        let cost = active_len.checked_add(pointer_cost).ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "computing the internal macro compression cost".to_string(),
+                            )
+                        })?;
+                        Min(Some(cost))
+                    }
                 }
+                None => Min(None),
             }
-            None => Min(None),
-        }
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MinimumInternalMacroDataCompression {
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.string.len();
+        let domain = self.alphabet_size + n + 1; // literals + EOS + pointers
+        vec![domain; n]
     }
 }
 
@@ -223,6 +296,10 @@ crate::declare_variants! {
     default MinimumInternalMacroDataCompression => "(alphabet_size + string_len + 1) ^ string_len",
 }
 
+crate::register_brute_force! {
+    MinimumInternalMacroDataCompression,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // Issue #442 example: alphabet {a,b,c} (3), s="abcabcabc" (9), h=2
@@ -245,7 +322,8 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "minimum_internal_macro_data_compression",
         instance: Box::new(MinimumInternalMacroDataCompression::new(3, s, 2)),
-        optimal_config,
+        optimal_config: serde_json::to_value(optimal_config)
+            .expect("solution serialization must succeed"),
         optimal_value: serde_json::json!(7),
     }]
 }
diff --git a/src/models/misc/minimum_register_sufficiency_for_loops.rs b/src/models/misc/minimum_register_sufficiency_for_loops.rs
index fc6d19027..fd2bf3465 100644
--- a/src/models/misc/minimum_register_sufficiency_for_loops.rs
+++ b/src/models/misc/minimum_register_sufficiency_for_loops.rs
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Minimum Register Sufficiency for Loops",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Assign registers to loop variables minimizing register count, no two conflicting variables share a register",
         fields: &[
@@ -47,7 +48,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumRegisterSufficiencyForLoops;
-/// use problemreductions::{Problem, Solver, BruteForce, Min};
+/// use problemreductions::{Problem, BruteForce, Min};
 ///
 /// // 3 variables on a loop of length 6, all pairs conflict
 /// let problem = MinimumRegisterSufficiencyForLoops::new(
@@ -55,9 +56,9 @@ inventory::submit! {
 ///     vec![(0, 3), (2, 3), (4, 3)],
 /// );
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
-/// let val = problem.evaluate(&solution.unwrap());
+/// let val = problem.evaluate(&solution.unwrap()).unwrap();
 /// assert_eq!(val, Min(Some(3)));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -153,47 +154,67 @@ impl MinimumRegisterSufficiencyForLoops {
 
 impl Problem for MinimumRegisterSufficiencyForLoops {
     const NAME: &'static str = "MinimumRegisterSufficiencyForLoops";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("loop_length", loop_length),
+        ("num_variables", num_variables),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let n = self.variables.len();
-        vec![n; n]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        let n = self.variables.len();
-        if config.len() != n {
-            return Min(None);
-        }
-        // Check all register indices are in valid range
-        if config.iter().any(|&r| r >= n) {
-            return Min(None);
-        }
-
-        // Check for conflicts: no two overlapping variables share a register
-        for i in 0..n {
-            for j in (i + 1)..n {
-                if config[i] == config[j] {
-                    let (s1, l1) = self.variables[i];
-                    let (s2, l2) = self.variables[j];
-                    if Self::arcs_overlap(s1, l1, s2, l2, self.loop_length) {
-                        return Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let n = self.variables.len();
+            if config.len() != n {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "register assignment length does not match the variables".into(),
+                ));
+            }
+            // Check all register indices are in valid range
+            if config.iter().any(|&register| register >= n) {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "register assignment contains an out-of-range register".into(),
+                ));
+            }
+            // Check for conflicts: no two overlapping variables share a register
+            for i in 0..n {
+                for j in (i + 1)..n {
+                    if config[i] == config[j] {
+                        let (s1, l1) = self.variables[i];
+                        let (s2, l2) = self.variables[j];
+                        if Self::arcs_overlap(s1, l1, s2, l2, self.loop_length) {
+                            return Ok(Min(None));
+                        }
                     }
                 }
             }
-        }
 
-        // Count distinct registers used
-        let mut used = vec![false; n];
-        for &r in config {
-            used[r] = true;
-        }
-        let count = used.iter().filter(|&&u| u).count();
-        Min(Some(count))
+            // Count distinct registers used
+            let mut used = vec![false; n];
+            for &r in config {
+                used[r] = true;
+            }
+            let count = used.iter().filter(|&&u| u).count();
+            Min(Some(i64::try_from(count).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting register count to i64".into(),
+                )
+            })?))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MinimumRegisterSufficiencyForLoops {
+    fn dimensions(&self) -> Vec<usize> {
+        let n = self.variables.len();
+        vec![n; n]
     }
 }
 
@@ -201,6 +222,10 @@ crate::declare_variants! {
     default MinimumRegisterSufficiencyForLoops => "num_variables ^ num_variables",
 }
 
+crate::register_brute_force! {
+    MinimumRegisterSufficiencyForLoops,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -211,7 +236,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             6,
             vec![(0, 3), (2, 3), (4, 3)],
         )),
-        optimal_config: vec![0, 1, 2],
+        optimal_config: serde_json::json!(vec![0, 1, 2]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/misc/minimum_tardiness_sequencing.rs b/src/models/misc/minimum_tardiness_sequencing.rs
index f507094d5..c8865a5e2 100644
--- a/src/models/misc/minimum_tardiness_sequencing.rs
+++ b/src/models/misc/minimum_tardiness_sequencing.rs
@@ -6,9 +6,9 @@
 //!
 //! Variants:
 //! - `MinimumTardinessSequencing<One>` — unit-length tasks (`1|prec, pj=1|∑Uj`)
-//! - `MinimumTardinessSequencing<i32>` — arbitrary-length tasks (`1|prec|∑Uj`)
+//! - `MinimumTardinessSequencing<i64>` — arbitrary-length tasks (`1|prec|∑Uj`)
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::traits::Problem;
 use crate::types::{Min, One, WeightElement};
 use serde::{Deserialize, Serialize};
@@ -18,14 +18,11 @@ inventory::submit! {
         name: "MinimumTardinessSequencing",
         display_name: "Minimum Tardiness Sequencing",
         aliases: &[],
-        dimensions: &[VariantDimension::new("weight", "One", &["One", "i32"])],
+        dimensions: &[VariantDimension::new("weight", "One", &["One", "i64"])],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Schedule tasks with precedence constraints and deadlines to minimize the number of tardy tasks",
-        fields: &[
-            FieldInfo { name: "lengths", type_name: "Vec<W>", description: "Processing time l(t) for each task" },
-            FieldInfo { name: "deadlines", type_name: "Vec<usize>", description: "Deadline d(t) for each task" },
-            FieldInfo { name: "precedences", type_name: "Vec<(usize, usize)>", description: "Precedence pairs (predecessor, successor)" },
-        ],
+        fields: MinimumTardinessSequencingI64CreateSpec::FIELDS,
     }
 }
 
@@ -38,14 +35,14 @@ inventory::submit! {
 ///
 /// # Type Parameters
 ///
-/// * `W` - The weight/length type. `One` for unit-length tasks, `i32` for arbitrary.
+/// * `W` - The weight/length type. `One` for unit-length tasks, `i64` for arbitrary.
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumTardinessSequencing;
 /// use problemreductions::types::One;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Unit-length: 3 tasks, task 0 must precede task 2
 /// let problem = MinimumTardinessSequencing::<One>::new(
@@ -54,16 +51,86 @@ inventory::submit! {
 ///     vec![(0, 2)],
 /// );
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MinimumTardinessSequencing<W> {
     lengths: Vec<W>,
-    deadlines: Vec<usize>,
+    deadlines: Vec<i64>,
     precedences: Vec<(usize, usize)>,
 }
 
+macro_rules! minimum_tardiness_create_spec {
+    ($name:ident, $weight:ty, $construct:expr) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            lengths: Vec<$weight>,
+            deadlines: Vec<i64>,
+            precedences: Option<Vec<(usize, usize)>>,
+        }
+
+        impl TryFrom<$name> for MinimumTardinessSequencing<$weight> {
+            type Error = crate::registry::ConstructionError;
+
+            fn try_from(spec: $name) -> Result<Self, Self::Error> {
+                if spec.lengths.len() != spec.deadlines.len() {
+                    return Err("lengths and deadlines must have the same length"
+                        .to_string()
+                        .into());
+                }
+                let precedences = spec.precedences.unwrap_or_default();
+                let num_tasks = spec.lengths.len();
+                if let Some(&(pred, succ)) = precedences
+                    .iter()
+                    .find(|&&(pred, succ)| pred >= num_tasks || succ >= num_tasks)
+                {
+                    return Err(format!(
+                        "precedence ({pred}, {succ}) is out of range for {num_tasks} tasks"
+                    )
+                    .into());
+                }
+                $construct(spec.lengths, spec.deadlines, precedences)
+            }
+        }
+    };
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumTardinessSequencingOneCreateSpec {
+    deadlines: Vec<i64>,
+    precedences: Option<Vec<(usize, usize)>>,
+}
+impl TryFrom<MinimumTardinessSequencingOneCreateSpec> for MinimumTardinessSequencing<One> {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumTardinessSequencingOneCreateSpec) -> Result<Self, Self::Error> {
+        let num_tasks = spec.deadlines.len();
+        let precedences = spec.precedences.unwrap_or_default();
+        if precedences
+            .iter()
+            .any(|&(a, b)| a >= num_tasks || b >= num_tasks)
+        {
+            return Err("precedence indices must be within the task count".into());
+        }
+        Ok(Self::new(num_tasks, spec.deadlines, precedences))
+    }
+}
+
+minimum_tardiness_create_spec!(
+    MinimumTardinessSequencingI64CreateSpec,
+    i64,
+    |lengths: Vec<i64>, deadlines, precedences| {
+        if lengths.iter().any(|&length| length <= 0) {
+            return Err("all task lengths must be positive".to_string().into());
+        }
+        Ok(MinimumTardinessSequencing::with_lengths(
+            lengths,
+            deadlines,
+            precedences,
+        ))
+    }
+);
+
 impl MinimumTardinessSequencing<One> {
     /// Create a new unit-length MinimumTardinessSequencing instance.
     ///
@@ -71,7 +138,7 @@ impl MinimumTardinessSequencing<One> {
     ///
     /// Panics if `deadlines.len() != num_tasks` or if any task index in `precedences`
     /// is out of range.
-    pub fn new(num_tasks: usize, deadlines: Vec<usize>, precedences: Vec<(usize, usize)>) -> Self {
+    pub fn new(num_tasks: usize, deadlines: Vec<i64>, precedences: Vec<(usize, usize)>) -> Self {
         assert_eq!(
             deadlines.len(),
             num_tasks,
@@ -86,7 +153,7 @@ impl MinimumTardinessSequencing<One> {
     }
 }
 
-impl MinimumTardinessSequencing<i32> {
+impl MinimumTardinessSequencing<i64> {
     /// Create a new arbitrary-length MinimumTardinessSequencing instance.
     ///
     /// # Panics
@@ -94,8 +161,8 @@ impl MinimumTardinessSequencing<i32> {
     /// Panics if `lengths.len() != deadlines.len()`, if any length is 0,
     /// or if any task index in `precedences` is out of range.
     pub fn with_lengths(
-        lengths: Vec<i32>,
-        deadlines: Vec<usize>,
+        lengths: Vec<i64>,
+        deadlines: Vec<i64>,
         precedences: Vec<(usize, usize)>,
     ) -> Self {
         assert_eq!(
@@ -146,7 +213,7 @@ impl<W: WeightElement> MinimumTardinessSequencing<W> {
     }
 
     /// Returns the deadlines.
-    pub fn deadlines(&self) -> &[usize] {
+    pub fn deadlines(&self) -> &[i64] {
         &self.deadlines
     }
 
@@ -160,11 +227,11 @@ impl<W: WeightElement> MinimumTardinessSequencing<W> {
         self.precedences.len()
     }
 
-    /// Decode and validate a schedule, returning the inverse permutation (sigma).
+    /// Validate a schedule and return the inverse permutation (sigma).
     /// Returns None if the config is invalid or violates precedences.
     fn decode_and_validate(&self, config: &[usize]) -> Option<Vec<usize>> {
         let n = self.num_tasks();
-        let schedule = super::decode_lehmer(config, n)?;
+        let schedule = super::decode_permutation(config, n)?;
 
         let mut sigma = vec![0usize; n];
         for (pos, &task) in schedule.iter().enumerate() {
@@ -183,72 +250,151 @@ impl<W: WeightElement> MinimumTardinessSequencing<W> {
 
 impl Problem for MinimumTardinessSequencing<One> {
     const NAME: &'static str = "MinimumTardinessSequencing";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_precedences", num_precedences),
+        ("num_tasks", num_tasks),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![One]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        super::lehmer_dims(self.num_tasks())
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.num_tasks();
-        let Some(sigma) = self.decode_and_validate(config) else {
-            return Min(None);
-        };
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule length does not match the tasks".into(),
+            ));
+        }
+        if config.iter().any(|&task| task >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule contains an out-of-range task".into(),
+            ));
+        }
+        Ok({
+            let Some(sigma) = self.decode_and_validate(config) else {
+                return Ok(Min(None));
+            };
+
+            // Unit length: completion time at position p is p + 1
+            let mut tardy_count = 0_i64;
+            for (task, &position) in sigma.iter().enumerate() {
+                let completion = i64::try_from(position)
+                    .ok()
+                    .and_then(|position| position.checked_add(1))
+                    .ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "computing a unit-length task completion time".to_string(),
+                        )
+                    })?;
+                if completion > self.deadlines[task] {
+                    tardy_count = tardy_count.checked_add(1).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "counting tardy tasks".to_string(),
+                        )
+                    })?;
+                }
+            }
 
-        // Unit length: completion time at position p is p + 1
-        let tardy_count = (0..n).filter(|&t| sigma[t] + 1 > self.deadlines[t]).count();
+            Min(Some(tardy_count))
+        })
+    }
+}
 
-        Min(Some(tardy_count))
+impl crate::solvers::BruteForceProblem for MinimumTardinessSequencing<One> {
+    fn dimensions(&self) -> Vec<usize> {
+        super::lehmer_dims(self.num_tasks())
     }
 }
 
-impl Problem for MinimumTardinessSequencing<i32> {
+impl Problem for MinimumTardinessSequencing<i64> {
     const NAME: &'static str = "MinimumTardinessSequencing";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
 
-    fn variant() -> Vec<(&'static str, &'static str)> {
-        crate::variant_params![i32]
-    }
+    crate::problem_parameters![
+        ("num_precedences", num_precedences),
+        ("num_tasks", num_tasks),
+    ];
 
-    fn dims(&self) -> Vec<usize> {
-        super::lehmer_dims(self.num_tasks())
+    fn variant() -> Vec<(&'static str, &'static str)> {
+        crate::variant_params![i64]
     }
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.num_tasks();
-        let Some(sigma) = self.decode_and_validate(config) else {
-            return Min(None);
-        };
-
-        // Build schedule order from sigma (inverse permutation)
-        let mut schedule = vec![0usize; n];
-        for (task, &pos) in sigma.iter().enumerate() {
-            schedule[pos] = task;
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule length does not match the tasks".into(),
+            ));
         }
-
-        // Compute completion times using actual lengths
-        let mut completion = vec![0usize; n];
-        let mut cumulative = 0usize;
-        for &task in &schedule {
-            cumulative += self.lengths[task] as usize;
-            completion[task] = cumulative;
+        if config.iter().any(|&task| task >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule contains an out-of-range task".into(),
+            ));
         }
+        Ok({
+            let Some(sigma) = self.decode_and_validate(config) else {
+                return Ok(Min(None));
+            };
+
+            // Build schedule order from sigma (inverse permutation)
+            let mut schedule = vec![0usize; n];
+            for (task, &pos) in sigma.iter().enumerate() {
+                schedule[pos] = task;
+            }
+
+            // Compute completion times using actual lengths
+            let mut completion = vec![0_i64; n];
+            let mut cumulative = 0_i64;
+            for &task in &schedule {
+                cumulative = cumulative.checked_add(self.lengths[task]).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing task lengths while computing completion times".to_string(),
+                    )
+                })?;
+                completion[task] = cumulative;
+            }
+
+            let mut tardy_count = 0_i64;
+            for (task, &completion_time) in completion.iter().enumerate() {
+                if completion_time > self.deadlines[task] {
+                    tardy_count = tardy_count.checked_add(1).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "counting tardy tasks".to_string(),
+                        )
+                    })?;
+                }
+            }
 
-        let tardy_count = (0..n)
-            .filter(|&t| completion[t] > self.deadlines[t])
-            .count();
+            Min(Some(tardy_count))
+        })
+    }
+}
 
-        Min(Some(tardy_count))
+impl crate::solvers::BruteForceProblem for MinimumTardinessSequencing<i64> {
+    fn dimensions(&self) -> Vec<usize> {
+        super::lehmer_dims(self.num_tasks())
     }
 }
 
 crate::declare_variants! {
-    default MinimumTardinessSequencing<One> => "2^num_tasks",
-    MinimumTardinessSequencing<i32> => "2^num_tasks",
+    default MinimumTardinessSequencing<One> => "2^num_tasks" create MinimumTardinessSequencingOneCreateSpec,
+    MinimumTardinessSequencing<i64> => "2^num_tasks" create MinimumTardinessSequencingI64CreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumTardinessSequencing<One> decode |problem: &MinimumTardinessSequencing<One>, indices: Vec<usize>| super::decode_lehmer(&indices, problem.num_tasks()).expect("enumerated Lehmer digits are valid"),
+    MinimumTardinessSequencing<i64> decode |problem: &MinimumTardinessSequencing<i64>, indices: Vec<usize>| super::decode_lehmer(&indices, problem.num_tasks()).expect("enumerated Lehmer digits are valid"),
 }
 
 #[cfg(feature = "example-db")]
@@ -262,7 +408,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 vec![2, 3, 1, 4],
                 vec![(0, 2)],
             )),
-            optimal_config: vec![0, 0, 0, 0],
+            optimal_config: serde_json::json!(vec![0, 1, 2, 3]),
             optimal_value: serde_json::json!(1),
         },
         // Arbitrary-length variant
@@ -272,12 +418,12 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             // Optimal schedule: t0,t4,t2,t1,t3 → 2 tardy
             // Lehmer [0,3,1,0,0]: avail=[0,1,2,3,4] pick 0→0; [1,2,3,4] pick 3→4;
             //   [1,2,3] pick 1→2; [1,3] pick 0→1; [3] pick 0→3
-            instance: Box::new(MinimumTardinessSequencing::<i32>::with_lengths(
+            instance: Box::new(MinimumTardinessSequencing::<i64>::with_lengths(
                 vec![3, 2, 2, 1, 2],
                 vec![4, 3, 8, 3, 6],
                 vec![(0, 2), (1, 3)],
             )),
-            optimal_config: vec![0, 3, 1, 0, 0],
+            optimal_config: serde_json::json!(vec![0, 4, 2, 1, 3]),
             optimal_value: serde_json::json!(2),
         },
     ]
diff --git a/src/models/misc/minimum_weight_and_or_graph.rs b/src/models/misc/minimum_weight_and_or_graph.rs
index dc497a6f5..879879967 100644
--- a/src/models/misc/minimum_weight_and_or_graph.rs
+++ b/src/models/misc/minimum_weight_and_or_graph.rs
@@ -3,7 +3,7 @@
 //! Given a directed acyclic graph with AND/OR gates, find the minimum-weight
 //! solution subgraph from a designated source vertex.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Deserializer, Serialize};
@@ -14,15 +14,10 @@ inventory::submit! {
         display_name: "Minimum Weight AND/OR Graph",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find the minimum-weight solution subgraph from a source in a DAG with AND/OR gates",
-        fields: &[
-            FieldInfo { name: "num_vertices", type_name: "usize", description: "Number of vertices in the DAG" },
-            FieldInfo { name: "arcs", type_name: "Vec<(usize, usize)>", description: "Directed arcs (u, v)" },
-            FieldInfo { name: "source", type_name: "usize", description: "Source vertex index" },
-            FieldInfo { name: "gate_types", type_name: "Vec<Option<bool>>", description: "Gate type per vertex: Some(true)=AND, Some(false)=OR, None=leaf" },
-            FieldInfo { name: "arc_weights", type_name: "Vec<i32>", description: "Weight of each arc" },
-        ],
+        fields: MinimumWeightAndOrGraphCreateSpec::FIELDS,
     }
 }
 
@@ -46,7 +41,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MinimumWeightAndOrGraph;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 7 vertices: AND at 0, OR at 1 and 2, leaves 3-6
 /// let problem = MinimumWeightAndOrGraph::new(
@@ -57,9 +52,8 @@ inventory::submit! {
 ///     vec![1, 2, 3, 1, 4, 2],
 /// );
 /// let solver = BruteForce::new();
-/// use problemreductions::solvers::Solver as _;
-/// let optimal = solver.solve(&problem);
-/// assert_eq!(optimal, problemreductions::types::Min(Some(6)));
+/// let solution = solver.solve(&problem).unwrap().unwrap();
+/// assert_eq!(problem.evaluate(&solution).unwrap(), problemreductions::types::Min(Some(6)));
 /// ```
 #[derive(Debug, Clone, Serialize)]
 pub struct MinimumWeightAndOrGraph {
@@ -72,19 +66,72 @@ pub struct MinimumWeightAndOrGraph {
     /// Gate type per vertex: Some(true)=AND, Some(false)=OR, None=leaf.
     gate_types: Vec<Option<bool>>,
     /// Weight of each arc.
-    arc_weights: Vec<i32>,
+    arc_weights: Vec<i64>,
     /// Precomputed: outgoing arcs for each vertex (arc indices).
     #[serde(skip)]
     outgoing: Vec<Vec<usize>>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumWeightAndOrGraphCreateSpec {
+    /// Number of vertices in the DAG.
+    num_vertices: usize,
+    /// Directed arcs.
+    arcs: Vec<(usize, usize)>,
+    /// Source vertex.
+    source: usize,
+    /// Gate type per vertex.
+    gate_types: Vec<Option<bool>>,
+    /// Arc weights; defaults to one per arc.
+    arc_weights: Option<Vec<i64>>,
+}
+impl TryFrom<MinimumWeightAndOrGraphCreateSpec> for MinimumWeightAndOrGraph {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MinimumWeightAndOrGraphCreateSpec) -> Result<Self, Self::Error> {
+        if spec.source >= spec.num_vertices {
+            return Err("source is outside the graph".to_string().into());
+        }
+        if spec.gate_types.len() != spec.num_vertices {
+            return Err("gate_types length must equal num_vertices"
+                .to_string()
+                .into());
+        }
+        if spec.gate_types[spec.source].is_none() {
+            return Err("source must be an AND or OR gate".to_string().into());
+        }
+        if let Some(&(u, v)) = spec
+            .arcs
+            .iter()
+            .find(|&&(u, v)| u >= spec.num_vertices || v >= spec.num_vertices)
+        {
+            return Err(format!("arc ({u}, {v}) is out of bounds").into());
+        }
+        let count = spec.arcs.len();
+        let arc_weights = spec.arc_weights.unwrap_or_else(|| vec![1; count]);
+        if arc_weights.len() != count {
+            return Err(format!(
+                "arc_weights has {} entries, expected {count}",
+                arc_weights.len()
+            )
+            .into());
+        }
+        Ok(Self::new(
+            spec.num_vertices,
+            spec.arcs,
+            spec.source,
+            spec.gate_types,
+            arc_weights,
+        ))
+    }
+}
+
 #[derive(Deserialize)]
 struct MinimumWeightAndOrGraphData {
     num_vertices: usize,
     arcs: Vec<(usize, usize)>,
     source: usize,
     gate_types: Vec<Option<bool>>,
-    arc_weights: Vec<i32>,
+    arc_weights: Vec<i64>,
 }
 
 impl<'de> Deserialize<'de> for MinimumWeightAndOrGraph {
@@ -118,7 +165,7 @@ impl MinimumWeightAndOrGraph {
         arcs: Vec<(usize, usize)>,
         source: usize,
         gate_types: Vec<Option<bool>>,
-        arc_weights: Vec<i32>,
+        arc_weights: Vec<i64>,
     ) -> Self {
         assert!(
             source < num_vertices,
@@ -200,102 +247,120 @@ impl MinimumWeightAndOrGraph {
     }
 
     /// Get the arc weights.
-    pub fn arc_weights(&self) -> &[i32] {
+    pub fn arc_weights(&self) -> &[i64] {
         &self.arc_weights
     }
 }
 
 impl Problem for MinimumWeightAndOrGraph {
     const NAME: &'static str = "MinimumWeightAndOrGraph";
-    type Value = Min<i32>;
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_arcs", num_arcs), ("num_vertices", num_vertices),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.arcs.len()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<i32> {
-        if config.len() != self.arcs.len() {
-            return Min(None);
-        }
-
-        // Check all config values are 0 or 1
-        if config.iter().any(|&c| c > 1) {
-            return Min(None);
-        }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.arcs.len() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "arc-selection length does not match the graph".into(),
+                ));
+            }
 
-        // Determine which arcs are selected
-        let selected: Vec<bool> = config.iter().map(|&c| c == 1).collect();
+            // Check all config values are 0 or 1
+            // Determine which arcs are selected
+            let selected = config;
 
-        // Propagate "solved" status top-down from source
-        let mut solved = vec![false; self.num_vertices];
-        let mut stack = vec![self.source];
-        solved[self.source] = true;
+            // Propagate "solved" status top-down from source
+            let mut solved = vec![false; self.num_vertices];
+            let mut stack = vec![self.source];
+            solved[self.source] = true;
 
-        while let Some(v) = stack.pop() {
-            match self.gate_types[v] {
-                None => {
-                    // Leaf vertex: trivially solved, no outgoing arcs needed
-                }
-                Some(is_and) => {
-                    let out_arcs = &self.outgoing[v];
-                    let selected_out: Vec<usize> = out_arcs
-                        .iter()
-                        .copied()
-                        .filter(|&ai| selected[ai])
-                        .collect();
+            while let Some(v) = stack.pop() {
+                match self.gate_types[v] {
+                    None => {
+                        // Leaf vertex: trivially solved, no outgoing arcs needed
+                    }
+                    Some(is_and) => {
+                        let out_arcs = &self.outgoing[v];
+                        let selected_out: Vec<usize> = out_arcs
+                            .iter()
+                            .copied()
+                            .filter(|&ai| selected[ai])
+                            .collect();
 
-                    if is_and {
-                        // AND gate: all outgoing arcs must be selected
-                        if selected_out.len() != out_arcs.len() {
-                            return Min(None);
-                        }
-                    } else {
-                        // OR gate: at least one outgoing arc must be selected
-                        if selected_out.is_empty() {
-                            return Min(None);
+                        if is_and {
+                            // AND gate: all outgoing arcs must be selected
+                            if selected_out.len() != out_arcs.len() {
+                                return Ok(Min(None));
+                            }
+                        } else {
+                            // OR gate: at least one outgoing arc must be selected
+                            if selected_out.is_empty() {
+                                return Ok(Min(None));
+                            }
                         }
-                    }
 
-                    // Mark children of selected arcs as solved
-                    for &ai in &selected_out {
-                        let (_u, child) = self.arcs[ai];
-                        if !solved[child] {
-                            solved[child] = true;
-                            stack.push(child);
+                        // Mark children of selected arcs as solved
+                        for &ai in &selected_out {
+                            let (_u, child) = self.arcs[ai];
+                            if !solved[child] {
+                                solved[child] = true;
+                                stack.push(child);
+                            }
                         }
                     }
                 }
             }
-        }
 
-        // Check no selected arcs come from non-solved vertices (no dangling arcs)
-        for (ai, &sel) in selected.iter().enumerate() {
-            if sel {
-                let (u, _v) = self.arcs[ai];
-                if !solved[u] {
-                    return Min(None);
+            // Check no selected arcs come from non-solved vertices (no dangling arcs)
+            for (ai, &sel) in selected.iter().enumerate() {
+                if sel {
+                    let (u, _v) = self.arcs[ai];
+                    if !solved[u] {
+                        return Ok(Min(None));
+                    }
                 }
             }
-        }
 
-        // Compute total weight of selected arcs
-        let total_weight: i32 = selected
-            .iter()
-            .enumerate()
-            .filter(|(_, &sel)| sel)
-            .map(|(i, _)| self.arc_weights[i])
-            .sum();
+            // Compute total weight of selected arcs
+            let total_weight = selected
+                .iter()
+                .enumerate()
+                .filter(|(_, &sel)| sel)
+                .map(|(i, _)| self.arc_weights[i])
+                .try_fold(0_i64, |total, weight| {
+                    total.checked_add(weight).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing selected AND/OR graph arc weights".into(),
+                        )
+                    })
+                })?;
 
-        Min(Some(total_weight))
+            Min(Some(total_weight))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MinimumWeightAndOrGraph {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.arcs.len()]
     }
 }
 
 crate::declare_variants! {
-    default MinimumWeightAndOrGraph => "2^num_arcs",
+    default MinimumWeightAndOrGraph => "2^num_arcs" create MinimumWeightAndOrGraphCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumWeightAndOrGraph decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -330,7 +395,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![Some(true), Some(false), Some(false), None, None, None, None],
             vec![1, 2, 3, 1, 4, 2],
         )),
-        optimal_config: vec![1, 1, 0, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![true, true, false, true, false, true]),
         optimal_value: serde_json::json!(6),
     }]
 }
diff --git a/src/models/misc/multiprocessor_scheduling.rs b/src/models/misc/multiprocessor_scheduling.rs
index 4339a99ce..0cfb11a7c 100644
--- a/src/models/misc/multiprocessor_scheduling.rs
+++ b/src/models/misc/multiprocessor_scheduling.rs
@@ -4,7 +4,7 @@
 //! can be assigned to identical processors such that no processor's
 //! total load exceeds a given deadline.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,13 +14,10 @@ inventory::submit! {
         display_name: "Multiprocessor Scheduling",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Assign tasks to processors so that no processor's load exceeds a deadline",
-        fields: &[
-            FieldInfo { name: "lengths", type_name: "Vec<u64>", description: "Processing time l(t) for each task" },
-            FieldInfo { name: "num_processors", type_name: "usize", description: "Number of identical processors m" },
-            FieldInfo { name: "deadline", type_name: "u64", description: "Global deadline D" },
-        ],
+        fields: MultiprocessorSchedulingCreateSpec::FIELDS,
     }
 }
 
@@ -44,23 +41,42 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::MultiprocessorScheduling;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 5 tasks with lengths [4, 5, 3, 2, 6], 2 processors, deadline 10
 /// let problem = MultiprocessorScheduling::new(vec![4, 5, 3, 2, 6], 2, 10);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MultiprocessorScheduling {
     /// Processing time for each task.
-    lengths: Vec<u64>,
+    lengths: Vec<i64>,
     /// Number of identical processors.
     #[serde(deserialize_with = "positive_usize::deserialize")]
     num_processors: usize,
     /// Global deadline.
-    deadline: u64,
+    deadline: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MultiprocessorSchedulingCreateSpec {
+    /// Processing time for each task.
+    lengths: Vec<i64>,
+    /// Number of identical processors.
+    num_processors: usize,
+    /// Global deadline.
+    deadline: i64,
+}
+impl TryFrom<MultiprocessorSchedulingCreateSpec> for MultiprocessorScheduling {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: MultiprocessorSchedulingCreateSpec) -> Result<Self, Self::Error> {
+        if spec.num_processors == 0 {
+            return Err("num_processors must be positive".to_string().into());
+        }
+        Ok(Self::new(spec.lengths, spec.num_processors, spec.deadline))
+    }
 }
 
 impl MultiprocessorScheduling {
@@ -68,8 +84,13 @@ impl MultiprocessorScheduling {
     ///
     /// # Panics
     /// Panics if `num_processors` is zero.
-    pub fn new(lengths: Vec<u64>, num_processors: usize, deadline: u64) -> Self {
+    pub fn new(lengths: Vec<i64>, num_processors: usize, deadline: i64) -> Self {
         assert!(num_processors > 0, "num_processors must be positive");
+        assert!(
+            lengths.iter().all(|&length| length >= 0),
+            "task lengths must be nonnegative"
+        );
+        assert!(deadline >= 0, "deadline must be nonnegative");
         Self {
             lengths,
             num_processors,
@@ -78,7 +99,7 @@ impl MultiprocessorScheduling {
     }
 
     /// Returns the processing times for each task.
-    pub fn lengths(&self) -> &[u64] {
+    pub fn lengths(&self) -> &[i64] {
         &self.lengths
     }
 
@@ -88,7 +109,7 @@ impl MultiprocessorScheduling {
     }
 
     /// Returns the deadline.
-    pub fn deadline(&self) -> u64 {
+    pub fn deadline(&self) -> i64 {
         self.deadline
     }
 
@@ -98,43 +119,68 @@ impl MultiprocessorScheduling {
     }
 
     /// Returns the total processing time of all tasks.
-    pub fn total_length(&self) -> u64 {
+    pub fn total_length(&self) -> i64 {
         self.lengths.iter().sum()
     }
 }
 
 impl Problem for MultiprocessorScheduling {
     const NAME: &'static str = "MultiprocessorScheduling";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_processors", num_processors), ("num_tasks", num_tasks),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_processors; self.num_tasks()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_tasks() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "processor assignment length does not match the tasks".into(),
+                    ));
+                }
+                let m = self.num_processors;
+                if config.iter().any(|&processor| processor >= m) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "assignment contains an out-of-range processor".into(),
+                    ));
+                }
+                let mut loads = vec![0i64; m];
+                for (i, &processor) in config.iter().enumerate() {
+                    loads[processor] =
+                        loads[processor]
+                            .checked_add(self.lengths[i])
+                            .ok_or_else(|| {
+                                crate::traits::EvaluationError::IntegerOverflow(
+                                    "summing multiprocessor load".into(),
+                                )
+                            })?;
+                }
+                loads.iter().all(|&load| load <= self.deadline)
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_tasks() {
-                return crate::types::Or(false);
-            }
-            let m = self.num_processors;
-            if config.iter().any(|&p| p >= m) {
-                return crate::types::Or(false);
-            }
-            let mut loads = vec![0u64; m];
-            for (i, &processor) in config.iter().enumerate() {
-                loads[processor] += self.lengths[i];
-            }
-            loads.iter().all(|&load| load <= self.deadline)
-        })
+impl crate::solvers::BruteForceProblem for MultiprocessorScheduling {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_processors; self.num_tasks()]
     }
 }
 
 crate::declare_variants! {
-    default MultiprocessorScheduling => "2^num_tasks",
+    default MultiprocessorScheduling => "2^num_tasks" create MultiprocessorSchedulingCreateSpec,
+}
+
+crate::register_brute_force! {
+    MultiprocessorScheduling,
 }
 
 #[cfg(feature = "example-db")]
@@ -142,7 +188,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "multiprocessor_scheduling",
         instance: Box::new(MultiprocessorScheduling::new(vec![4, 5, 3, 2, 6], 2, 10)),
-        optimal_config: vec![0, 1, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![0, 1, 1, 1, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/non_liveness_free_petri_net.rs b/src/models/misc/non_liveness_free_petri_net.rs
index 322a2e727..66fca114a 100644
--- a/src/models/misc/non_liveness_free_petri_net.rs
+++ b/src/models/misc/non_liveness_free_petri_net.rs
@@ -10,7 +10,7 @@
 //! transitions are claimed to be globally dead. The answer is YES (Or(true))
 //! when at least one selected transition is indeed globally dead.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{ConstructionError, FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -23,6 +23,7 @@ inventory::submit! {
         display_name: "Non-Liveness Free Petri Net",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine whether a free-choice Petri net is not live (some transition can become permanently dead)",
         fields: &[
@@ -30,25 +31,18 @@ inventory::submit! {
             FieldInfo { name: "num_transitions", type_name: "usize", description: "Number of transitions |T|" },
             FieldInfo { name: "place_to_transition", type_name: "Vec<(usize,usize)>", description: "Arcs from places to transitions" },
             FieldInfo { name: "transition_to_place", type_name: "Vec<(usize,usize)>", description: "Arcs from transitions to places" },
-            FieldInfo { name: "initial_marking", type_name: "Vec<usize>", description: "Initial marking M₀ (tokens per place)" },
+            FieldInfo { name: "initial_marking", type_name: "Vec<i64>", description: "Initial marking M₀ (tokens per place)" },
         ],
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "NonLivenessFreePetriNet",
-        fields: &["num_places", "num_transitions", "num_arcs", "initial_token_sum"],
-    }
-}
-
 #[derive(Debug, Clone, Serialize)]
 pub struct NonLivenessFreePetriNet {
     num_places: usize,
     num_transitions: usize,
     place_to_transition: Vec<(usize, usize)>,
     transition_to_place: Vec<(usize, usize)>,
-    initial_marking: Vec<usize>,
+    initial_marking: Vec<i64>,
     /// Precomputed globally dead transitions (not serialized).
     #[serde(skip)]
     globally_dead: Vec<bool>,
@@ -60,47 +54,67 @@ impl NonLivenessFreePetriNet {
         num_transitions: usize,
         place_to_transition: &[(usize, usize)],
         transition_to_place: &[(usize, usize)],
-        initial_marking: &[usize],
-    ) -> Result<(), String> {
+        initial_marking: &[i64],
+    ) -> Result<(), ConstructionError> {
         if num_places == 0 {
-            return Err("NonLivenessFreePetriNet requires at least one place".to_string());
+            return Err(ConstructionError::Conversion(
+                "NonLivenessFreePetriNet requires at least one place".into(),
+            ));
         }
         if num_transitions == 0 {
-            return Err("NonLivenessFreePetriNet requires at least one transition".to_string());
+            return Err(ConstructionError::Conversion(
+                "NonLivenessFreePetriNet requires at least one transition".into(),
+            ));
         }
         if initial_marking.len() != num_places {
-            return Err(format!(
+            return Err(ConstructionError::Conversion(format!(
                 "initial_marking length {} does not match num_places {}",
                 initial_marking.len(),
                 num_places
+            )));
+        }
+        if initial_marking.iter().any(|&tokens| tokens < 0) {
+            return Err(ConstructionError::Conversion(
+                "initial_marking must contain non-negative token counts".into(),
             ));
         }
+        let total_tokens = initial_marking
+            .iter()
+            .try_fold(0_i64, |total, &tokens| total.checked_add(tokens))
+            .ok_or_else(|| {
+                ConstructionError::IntegerOverflow("summing initial Petri-net tokens".into())
+            })?;
+        usize::try_from(total_tokens).map_err(|_| {
+            ConstructionError::IntegerOverflow(
+                "initial Petri-net token sum does not fit usize".into(),
+            )
+        })?;
         for (i, &(p, t)) in place_to_transition.iter().enumerate() {
             if p >= num_places {
-                return Err(format!(
+                return Err(ConstructionError::Conversion(format!(
                     "place_to_transition arc {} has place {} out of range 0..{}",
                     i, p, num_places
-                ));
+                )));
             }
             if t >= num_transitions {
-                return Err(format!(
+                return Err(ConstructionError::Conversion(format!(
                     "place_to_transition arc {} has transition {} out of range 0..{}",
                     i, t, num_transitions
-                ));
+                )));
             }
         }
         for (i, &(t, p)) in transition_to_place.iter().enumerate() {
             if t >= num_transitions {
-                return Err(format!(
+                return Err(ConstructionError::Conversion(format!(
                     "transition_to_place arc {} has transition {} out of range 0..{}",
                     i, t, num_transitions
-                ));
+                )));
             }
             if p >= num_places {
-                return Err(format!(
+                return Err(ConstructionError::Conversion(format!(
                     "transition_to_place arc {} has place {} out of range 0..{}",
                     i, p, num_places
-                ));
+                )));
             }
         }
 
@@ -124,10 +138,10 @@ impl NonLivenessFreePetriNet {
                     let p1 = preset.get(&t1).cloned().unwrap_or_default();
                     let p2 = preset.get(&t2).cloned().unwrap_or_default();
                     if p1 != p2 {
-                        return Err(format!(
+                        return Err(ConstructionError::Conversion(format!(
                             "Free-choice violation: transitions {} and {} share input place {} but have different presets",
                             t1, t2, p
-                        ));
+                        )));
                     }
                 }
             }
@@ -136,15 +150,14 @@ impl NonLivenessFreePetriNet {
         Ok(())
     }
 
-    /// Try to create a new `NonLivenessFreePetriNet` instance, returning an error
-    /// if validation fails.
-    pub fn try_new(
+    /// Create a new `NonLivenessFreePetriNet` instance.
+    pub fn new(
         num_places: usize,
         num_transitions: usize,
         place_to_transition: Vec<(usize, usize)>,
         transition_to_place: Vec<(usize, usize)>,
-        initial_marking: Vec<usize>,
-    ) -> Result<Self, String> {
+        initial_marking: Vec<i64>,
+    ) -> Result<Self, ConstructionError> {
         Self::validate_inputs(
             num_places,
             num_transitions,
@@ -160,33 +173,10 @@ impl NonLivenessFreePetriNet {
             initial_marking,
             globally_dead: Vec::new(),
         };
-        net.globally_dead = net.compute_globally_dead_transitions();
+        net.globally_dead = net.compute_globally_dead_transitions()?;
         Ok(net)
     }
 
-    /// Create a new `NonLivenessFreePetriNet` instance.
-    ///
-    /// # Panics
-    ///
-    /// Panics if validation fails (indices out of range, wrong marking length,
-    /// or free-choice violation).
-    pub fn new(
-        num_places: usize,
-        num_transitions: usize,
-        place_to_transition: Vec<(usize, usize)>,
-        transition_to_place: Vec<(usize, usize)>,
-        initial_marking: Vec<usize>,
-    ) -> Self {
-        Self::try_new(
-            num_places,
-            num_transitions,
-            place_to_transition,
-            transition_to_place,
-            initial_marking,
-        )
-        .unwrap_or_else(|message| panic!("{message}"))
-    }
-
     /// Number of places |S|.
     pub fn num_places(&self) -> usize {
         self.num_places
@@ -204,7 +194,12 @@ impl NonLivenessFreePetriNet {
 
     /// Sum of tokens in the initial marking.
     pub fn initial_token_sum(&self) -> usize {
-        self.initial_marking.iter().sum()
+        let total = self
+            .initial_marking
+            .iter()
+            .try_fold(0_i64, |total, &tokens| total.checked_add(tokens))
+            .expect("construction validates the initial token sum");
+        usize::try_from(total).expect("validated initial token sum fits usize")
     }
 
     /// Arcs from places to transitions.
@@ -218,12 +213,12 @@ impl NonLivenessFreePetriNet {
     }
 
     /// Initial marking M₀.
-    pub fn initial_marking(&self) -> &[usize] {
+    pub fn initial_marking(&self) -> &[i64] {
         &self.initial_marking
     }
 
     /// Determine which transitions are enabled at the given marking.
-    fn enabled_transitions(&self, marking: &[usize]) -> Vec<bool> {
+    fn enabled_transitions(&self, marking: &[i64]) -> Vec<bool> {
         let mut enabled = vec![true; self.num_transitions];
         // A transition t is enabled iff every input place has at least one token.
         // Transitions with no input places remain enabled (source transitions).
@@ -236,13 +231,17 @@ impl NonLivenessFreePetriNet {
     }
 
     /// Fire a transition, producing a new marking. Returns None if not enabled.
-    fn fire(&self, marking: &[usize], transition: usize) -> Option<Vec<usize>> {
+    fn fire(
+        &self,
+        marking: &[i64],
+        transition: usize,
+    ) -> Result<Option<Vec<i64>>, ConstructionError> {
         let mut new_marking = marking.to_vec();
         // Remove tokens from input places
         for &(p, t) in &self.place_to_transition {
             if t == transition {
                 if new_marking[p] == 0 {
-                    return None;
+                    return Ok(None);
                 }
                 new_marking[p] -= 1;
             }
@@ -250,10 +249,14 @@ impl NonLivenessFreePetriNet {
         // Add tokens to output places
         for &(t, p) in &self.transition_to_place {
             if t == transition {
-                new_marking[p] += 1;
+                new_marking[p] = new_marking[p].checked_add(1).ok_or_else(|| {
+                    ConstructionError::IntegerOverflow(
+                        "firing a Petri-net transition increments a token count".into(),
+                    )
+                })?;
             }
         }
-        Some(new_marking)
+        Ok(Some(new_marking))
     }
 
     /// Build the bounded reachability graph and determine which transitions
@@ -263,13 +266,17 @@ impl NonLivenessFreePetriNet {
     /// For boundedness, we cap exploration at markings where no place exceeds
     /// `initial_token_sum`. This is sound for free-choice nets under the
     /// NP-completeness assumption from Garey & Johnson.
-    fn compute_globally_dead_transitions(&self) -> Vec<bool> {
-        let token_cap = self.initial_token_sum();
+    fn compute_globally_dead_transitions(&self) -> Result<Vec<bool>, ConstructionError> {
+        let token_cap = self
+            .initial_marking
+            .iter()
+            .try_fold(0_i64, |total, &tokens| total.checked_add(tokens))
+            .expect("construction validates the initial token sum");
         let num_t = self.num_transitions;
 
         // Build reachability graph: BFS from initial marking.
-        let mut marking_index: HashMap<Vec<usize>, usize> = HashMap::new();
-        let mut markings: Vec<Vec<usize>> = Vec::new();
+        let mut marking_index: HashMap<Vec<i64>, usize> = HashMap::new();
+        let mut markings: Vec<Vec<i64>> = Vec::new();
         // successors[m_idx] = list of (transition, next_marking_idx)
         let mut successors: Vec<Vec<(usize, usize)>> = Vec::new();
         let mut queue: VecDeque<usize> = VecDeque::new();
@@ -286,7 +293,7 @@ impl NonLivenessFreePetriNet {
                 if !is_enabled {
                     continue;
                 }
-                if let Some(new_marking) = self.fire(&markings[m_idx], t) {
+                if let Some(new_marking) = self.fire(&markings[m_idx], t)? {
                     // Check bound: no place exceeds token_cap
                     if new_marking.iter().any(|&tokens| tokens > token_cap) {
                         continue;
@@ -354,7 +361,7 @@ impl NonLivenessFreePetriNet {
             }
         }
 
-        globally_dead
+        Ok(globally_dead)
     }
 }
 
@@ -364,7 +371,7 @@ struct NonLivenessFreePetriNetData {
     num_transitions: usize,
     place_to_transition: Vec<(usize, usize)>,
     transition_to_place: Vec<(usize, usize)>,
-    initial_marking: Vec<usize>,
+    initial_marking: Vec<i64>,
 }
 
 impl<'de> Deserialize<'de> for NonLivenessFreePetriNet {
@@ -373,7 +380,7 @@ impl<'de> Deserialize<'de> for NonLivenessFreePetriNet {
         D: Deserializer<'de>,
     {
         let data = NonLivenessFreePetriNetData::deserialize(deserializer)?;
-        Self::try_new(
+        Self::new(
             data.num_places,
             data.num_transitions,
             data.place_to_transition,
@@ -386,30 +393,44 @@ impl<'de> Deserialize<'de> for NonLivenessFreePetriNet {
 
 impl Problem for NonLivenessFreePetriNet {
     const NAME: &'static str = "NonLivenessFreePetriNet";
+    type Solution = Vec<bool>;
     type Value = Or;
 
+    crate::problem_parameters![
+        ("initial_token_sum", initial_token_sum),
+        ("num_arcs", num_arcs),
+        ("num_places", num_places),
+        ("num_transitions", num_transitions),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_transitions]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Or {
-        if config.len() != self.num_transitions {
-            return Or(false);
-        }
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.num_transitions {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "transition-selection length does not match the net".into(),
+                ));
+            }
 
-        // Config selects transitions claimed to be dead.
-        // Return true iff at least one selected transition is indeed globally dead.
-        for (t, &selected) in config.iter().enumerate() {
-            if selected == 1 && self.globally_dead[t] {
-                return Or(true);
+            // Config selects transitions claimed to be dead.
+            // Return true iff at least one selected transition is indeed globally dead.
+            for (t, &selected) in config.iter().enumerate() {
+                if selected && self.globally_dead[t] {
+                    return Ok(Or(true));
+                }
             }
-        }
 
-        Or(false)
+            Or(false)
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for NonLivenessFreePetriNet {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_transitions]
     }
 }
 
@@ -417,18 +438,25 @@ crate::declare_variants! {
     default NonLivenessFreePetriNet => "(initial_token_sum + 1) ^ num_places * num_transitions",
 }
 
+crate::register_brute_force! {
+    NonLivenessFreePetriNet decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "non_liveness_free_petri_net",
-        instance: Box::new(NonLivenessFreePetriNet::new(
-            4,
-            3,
-            vec![(0, 0), (1, 1), (2, 2)],
-            vec![(0, 1), (1, 2), (2, 3)],
-            vec![1, 0, 0, 0],
-        )),
-        optimal_config: vec![1, 1, 1],
+        instance: Box::new(
+            NonLivenessFreePetriNet::new(
+                4,
+                3,
+                vec![(0, 0), (1, 1), (2, 2)],
+                vec![(0, 1), (1, 2), (2, 3)],
+                vec![1, 0, 0, 0],
+            )
+            .unwrap(),
+        ),
+        optimal_config: serde_json::json!(vec![true, true, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/numerical_3_dimensional_matching.rs b/src/models/misc/numerical_3_dimensional_matching.rs
index cb4363647..2a07faf11 100644
--- a/src/models/misc/numerical_3_dimensional_matching.rs
+++ b/src/models/misc/numerical_3_dimensional_matching.rs
@@ -1,12 +1,12 @@
 //! Numerical 3-Dimensional Matching (N3DM) problem implementation.
 //!
-//! Given disjoint sets W, X, Y each with m elements, sizes s(a) ∈ Z⁺ for
-//! every element with B/4 < s(a) < B/2, and a bound B where the total sum
+//! Given disjoint sets W, X, Y each with m elements, positive integer sizes
+//! s(a), and a positive integer bound B where the total sum
 //! equals mB.  Decide whether W ∪ X ∪ Y can be partitioned into m triples,
 //! each containing one element from W, X, and Y, with each triple summing
 //! to exactly B.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -18,89 +18,81 @@ inventory::submit! {
         display_name: "Numerical 3-Dimensional Matching",
         aliases: &["N3DM"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Partition W∪X∪Y into m triples (one from each set) each summing to B",
         fields: &[
-            FieldInfo { name: "sizes_w", type_name: "Vec<u64>", description: "Positive integer sizes for each element of W" },
-            FieldInfo { name: "sizes_x", type_name: "Vec<u64>", description: "Positive integer sizes for each element of X" },
-            FieldInfo { name: "sizes_y", type_name: "Vec<u64>", description: "Positive integer sizes for each element of Y" },
-            FieldInfo { name: "bound", type_name: "u64", description: "Target sum B for each triple" },
+            FieldInfo { name: "sizes_w", type_name: "Vec<i64>", description: "Positive integer sizes for each element of W" },
+            FieldInfo { name: "sizes_x", type_name: "Vec<i64>", description: "Positive integer sizes for each element of X" },
+            FieldInfo { name: "sizes_y", type_name: "Vec<i64>", description: "Positive integer sizes for each element of Y" },
+            FieldInfo { name: "bound", type_name: "i64", description: "Target sum B for each triple" },
         ],
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "Numerical3DimensionalMatching",
-        fields: &["num_groups", "bound"],
-    }
-}
-
 #[derive(Debug, Clone, Serialize)]
 pub struct Numerical3DimensionalMatching {
-    sizes_w: Vec<u64>,
-    sizes_x: Vec<u64>,
-    sizes_y: Vec<u64>,
-    bound: u64,
+    sizes_w: Vec<i64>,
+    sizes_x: Vec<i64>,
+    sizes_y: Vec<i64>,
+    bound: i64,
 }
 
 impl Numerical3DimensionalMatching {
     fn validate_inputs(
-        sizes_w: &[u64],
-        sizes_x: &[u64],
-        sizes_y: &[u64],
-        bound: u64,
-    ) -> Result<(), String> {
+        sizes_w: &[i64],
+        sizes_x: &[i64],
+        sizes_y: &[i64],
+        bound: i64,
+    ) -> Result<(), crate::registry::ConstructionError> {
         let m = sizes_w.len();
         if m == 0 {
             return Err(
-                "Numerical3DimensionalMatching requires at least one element per set".to_string(),
+                "Numerical3DimensionalMatching requires at least one element per set".into(),
             );
         }
         if sizes_x.len() != m || sizes_y.len() != m {
             return Err(
                 "Numerical3DimensionalMatching requires all three sets to have the same size"
-                    .to_string(),
+                    .into(),
             );
         }
-        if bound == 0 {
-            return Err("Numerical3DimensionalMatching requires a positive bound".to_string());
+        if bound <= 0 {
+            return Err("Numerical3DimensionalMatching requires a positive bound"
+                .to_string()
+                .into());
         }
 
-        let bound128 = u128::from(bound);
         for &size in sizes_w.iter().chain(sizes_x.iter()).chain(sizes_y.iter()) {
-            if size == 0 {
-                return Err("All sizes must be positive (> 0)".to_string());
-            }
-            let size128 = u128::from(size);
-            if !(4 * size128 > bound128 && 2 * size128 < bound128) {
-                return Err("Every size must lie strictly between B/4 and B/2".to_string());
+            if size <= 0 {
+                return Err("All sizes must be positive (> 0)".to_string().into());
             }
         }
 
-        let total_sum: u128 = sizes_w
+        let total_sum = sizes_w
             .iter()
             .chain(sizes_x.iter())
             .chain(sizes_y.iter())
-            .map(|&s| u128::from(s))
-            .sum();
-        let expected_sum = bound128 * (m as u128);
+            .try_fold(0_i64, |total, &size| total.checked_add(size))
+            .ok_or("total size sum exceeds i64 range")?;
+        let group_count = i64::try_from(m).map_err(|_| "group count exceeds i64 range")?;
+        let expected_sum = bound
+            .checked_mul(group_count)
+            .ok_or("m * bound exceeds i64 range")?;
         if total_sum != expected_sum {
-            return Err("Total sum of all sizes must equal m * bound".to_string());
-        }
-        if total_sum > u128::from(u64::MAX) {
-            return Err("Total sum exceeds u64 range".to_string());
+            return Err("Total sum of all sizes must equal m * bound"
+                .to_string()
+                .into());
         }
-
         Ok(())
     }
 
     pub fn try_new(
-        sizes_w: Vec<u64>,
-        sizes_x: Vec<u64>,
-        sizes_y: Vec<u64>,
-        bound: u64,
-    ) -> Result<Self, String> {
+        sizes_w: Vec<i64>,
+        sizes_x: Vec<i64>,
+        sizes_y: Vec<i64>,
+        bound: i64,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate_inputs(&sizes_w, &sizes_x, &sizes_y, bound)?;
         Ok(Self {
             sizes_w,
@@ -115,24 +107,24 @@ impl Numerical3DimensionalMatching {
     /// # Panics
     ///
     /// Panics if the input violates the N3DM invariants.
-    pub fn new(sizes_w: Vec<u64>, sizes_x: Vec<u64>, sizes_y: Vec<u64>, bound: u64) -> Self {
+    pub fn new(sizes_w: Vec<i64>, sizes_x: Vec<i64>, sizes_y: Vec<i64>, bound: i64) -> Self {
         Self::try_new(sizes_w, sizes_x, sizes_y, bound)
             .unwrap_or_else(|message| panic!("{message}"))
     }
 
-    pub fn sizes_w(&self) -> &[u64] {
+    pub fn sizes_w(&self) -> &[i64] {
         &self.sizes_w
     }
 
-    pub fn sizes_x(&self) -> &[u64] {
+    pub fn sizes_x(&self) -> &[i64] {
         &self.sizes_x
     }
 
-    pub fn sizes_y(&self) -> &[u64] {
+    pub fn sizes_y(&self) -> &[i64] {
         &self.sizes_y
     }
 
-    pub fn bound(&self) -> u64 {
+    pub fn bound(&self) -> i64 {
         self.bound
     }
 
@@ -143,10 +135,10 @@ impl Numerical3DimensionalMatching {
 
 #[derive(Deserialize)]
 struct Numerical3DimensionalMatchingData {
-    sizes_w: Vec<u64>,
-    sizes_x: Vec<u64>,
-    sizes_y: Vec<u64>,
-    bound: u64,
+    sizes_w: Vec<i64>,
+    sizes_x: Vec<i64>,
+    sizes_y: Vec<i64>,
+    bound: i64,
 }
 
 impl<'de> Deserialize<'de> for Numerical3DimensionalMatching {
@@ -162,59 +154,82 @@ impl<'de> Deserialize<'de> for Numerical3DimensionalMatching {
 
 impl Problem for Numerical3DimensionalMatching {
     const NAME: &'static str = "Numerical3DimensionalMatching";
+    type Solution = Vec<usize>;
     type Value = Or;
 
+    crate::problem_parameters![("bound", bound), ("num_groups", num_groups),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_groups(); 2 * self.num_groups()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or({
-            let m = self.num_groups();
-            if config.len() != 2 * m {
-                return Or(false);
-            }
-
-            // First m values: assignment of X-elements to W-elements (must be a permutation)
-            let x_perm = &config[..m];
-            // Second m values: assignment of Y-elements to W-elements (must be a permutation)
-            let y_perm = &config[m..];
-
-            // Check that both are valid permutations of 0..m
-            let mut x_used = vec![false; m];
-            let mut y_used = vec![false; m];
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            Or({
+                let m = self.num_groups();
+                if config.len() != 2 * m {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "matching permutation length does not match the instance".into(),
+                    ));
+                }
 
-            for i in 0..m {
-                if x_perm[i] >= m || y_perm[i] >= m {
-                    return Or(false);
+                if config.iter().any(|&index| index >= m) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "matching permutation contains an out-of-range index".into(),
+                    ));
                 }
-                if x_used[x_perm[i]] || y_used[y_perm[i]] {
-                    return Or(false);
+
+                // First m values: assignment of X-elements to W-elements (must be a permutation)
+                let x_perm = &config[..m];
+                // Second m values: assignment of Y-elements to W-elements (must be a permutation)
+                let y_perm = &config[m..];
+
+                // Check that both are valid permutations of 0..m
+                let mut x_used = vec![false; m];
+                let mut y_used = vec![false; m];
+
+                for i in 0..m {
+                    if x_used[x_perm[i]] || y_used[y_perm[i]] {
+                        return Ok(Or(false));
+                    }
+                    x_used[x_perm[i]] = true;
+                    y_used[y_perm[i]] = true;
                 }
-                x_used[x_perm[i]] = true;
-                y_used[y_perm[i]] = true;
-            }
 
-            // Check that each triple sums to B
-            let target = u128::from(self.bound);
-            (0..m).all(|i| {
-                let sum = u128::from(self.sizes_w[i])
-                    + u128::from(self.sizes_x[x_perm[i]])
-                    + u128::from(self.sizes_y[y_perm[i]]);
-                sum == target
+                // Check that each triple sums to B
+                for i in 0..m {
+                    let sum = self.sizes_w[i]
+                        .checked_add(self.sizes_x[x_perm[i]])
+                        .and_then(|sum| sum.checked_add(self.sizes_y[y_perm[i]]))
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "summing numerical three-dimensional matching triple".into(),
+                            )
+                        })?;
+                    if sum != self.bound {
+                        return Ok(Or(false));
+                    }
+                }
+                true
             })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for Numerical3DimensionalMatching {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_groups(); 2 * self.num_groups()]
+    }
+}
+
 crate::declare_variants! {
     default Numerical3DimensionalMatching => "num_groups^(2 * num_groups)",
 }
 
+crate::register_brute_force! {
+    Numerical3DimensionalMatching,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -225,7 +240,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![5, 7],
             15,
         )),
-        optimal_config: vec![0, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![0, 1, 1, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/numerical_matching_with_target_sums.rs b/src/models/misc/numerical_matching_with_target_sums.rs
index 377c4438c..bccdc2f7c 100644
--- a/src/models/misc/numerical_matching_with_target_sums.rs
+++ b/src/models/misc/numerical_matching_with_target_sums.rs
@@ -6,7 +6,7 @@
 //! each containing one element from X and one from Y, such that the
 //! multiset of pair sums {s(x_i) + s(y_{π(i)})} equals the target multiset.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -18,6 +18,7 @@ inventory::submit! {
         display_name: "Numerical Matching with Target Sums",
         aliases: &["NMTS"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Partition X∪Y into m pairs (one from X, one from Y) with pair sums matching targets",
         fields: &[
@@ -28,13 +29,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "NumericalMatchingWithTargetSums",
-        fields: &["num_pairs"],
-    }
-}
-
 #[derive(Debug, Clone, Serialize)]
 pub struct NumericalMatchingWithTargetSums {
     sizes_x: Vec<i64>,
@@ -43,23 +37,27 @@ pub struct NumericalMatchingWithTargetSums {
 }
 
 impl NumericalMatchingWithTargetSums {
-    fn validate_inputs(sizes_x: &[i64], sizes_y: &[i64], targets: &[i64]) -> Result<(), String> {
+    fn validate_inputs(
+        sizes_x: &[i64],
+        sizes_y: &[i64],
+        targets: &[i64],
+    ) -> Result<(), crate::registry::ConstructionError> {
         let m = sizes_x.len();
         if m == 0 {
             return Err(
-                "NumericalMatchingWithTargetSums requires at least one element per set".to_string(),
+                "NumericalMatchingWithTargetSums requires at least one element per set".into(),
             );
         }
         if sizes_y.len() != m {
             return Err(
                 "NumericalMatchingWithTargetSums requires sizes_x and sizes_y to have the same length"
-                    .to_string(),
+                    .into(),
             );
         }
         if targets.len() != m {
             return Err(
                 "NumericalMatchingWithTargetSums requires targets to have the same length as sizes_x"
-                    .to_string(),
+                    .into(),
             );
         }
         Ok(())
@@ -69,7 +67,7 @@ impl NumericalMatchingWithTargetSums {
         sizes_x: Vec<i64>,
         sizes_y: Vec<i64>,
         targets: Vec<i64>,
-    ) -> Result<Self, String> {
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate_inputs(&sizes_x, &sizes_y, &targets)?;
         Ok(Self {
             sizes_x,
@@ -127,49 +125,68 @@ impl<'de> Deserialize<'de> for NumericalMatchingWithTargetSums {
 
 impl Problem for NumericalMatchingWithTargetSums {
     const NAME: &'static str = "NumericalMatchingWithTargetSums";
+    type Solution = Vec<usize>;
     type Value = Or;
 
+    crate::problem_parameters![("num_pairs", num_pairs),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let m = self.num_pairs();
-        vec![m; m]
-    }
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            Or({
+                let m = self.num_pairs();
+                if config.len() != m {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "matching permutation length does not match the instance".into(),
+                    ));
+                }
 
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or({
-            let m = self.num_pairs();
-            if config.len() != m {
-                return Or(false);
-            }
-
-            // Check config is valid permutation of 0..m
-            let mut used = vec![false; m];
-            for &idx in config {
-                if idx >= m || used[idx] {
-                    return Or(false);
+                if config.iter().any(|&index| index >= m) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "matching permutation contains an out-of-range index".into(),
+                    ));
                 }
-                used[idx] = true;
-            }
-
-            // Compute pair sums and compare multisets
-            let mut pair_sums: Vec<i64> = (0..m)
-                .map(|i| self.sizes_x[i] + self.sizes_y[config[i]])
-                .collect();
-            let mut sorted_targets = self.targets.clone();
-            pair_sums.sort();
-            sorted_targets.sort();
-            pair_sums == sorted_targets
+
+                // Check config is valid permutation of 0..m
+                let mut used = vec![false; m];
+                for &idx in config {
+                    if idx >= m || used[idx] {
+                        return Ok(Or(false));
+                    }
+                    used[idx] = true;
+                }
+
+                // Compute pair sums and compare multisets
+                let mut pair_sums: Vec<i64> = (0..m)
+                    .map(|i| self.sizes_x[i] + self.sizes_y[config[i]])
+                    .collect();
+                let mut sorted_targets = self.targets.clone();
+                pair_sums.sort();
+                sorted_targets.sort();
+                pair_sums == sorted_targets
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for NumericalMatchingWithTargetSums {
+    fn dimensions(&self) -> Vec<usize> {
+        let m = self.num_pairs();
+        vec![m; m]
+    }
+}
+
 crate::declare_variants! {
     default NumericalMatchingWithTargetSums => "2^num_pairs",
 }
 
+crate::register_brute_force! {
+    NumericalMatchingWithTargetSums,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -179,7 +196,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![2, 5, 3],
             vec![3, 7, 12],
         )),
-        optimal_config: vec![0, 2, 1],
+        optimal_config: serde_json::json!(vec![0, 2, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/open_shop_scheduling.rs b/src/models/misc/open_shop_scheduling.rs
index 3db688a38..30680b8cc 100644
--- a/src/models/misc/open_shop_scheduling.rs
+++ b/src/models/misc/open_shop_scheduling.rs
@@ -6,7 +6,7 @@
 //! both machine capacity (one job at a time per machine) and job capacity
 //! (each job uses at most one machine at a time) constraints.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -17,12 +17,10 @@ inventory::submit! {
         display_name: "Open Shop Scheduling",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Minimize the makespan of an open-shop schedule",
-        fields: &[
-            FieldInfo { name: "num_machines", type_name: "usize", description: "Number of machines m" },
-            FieldInfo { name: "processing_times", type_name: "Vec<Vec<usize>>", description: "processing_times[j][i] = processing time of job j on machine i (n x m)" },
-        ],
+        fields: OpenShopSchedulingCreateSpec::FIELDS,
     }
 }
 
@@ -41,32 +39,63 @@ inventory::submit! {
 ///
 /// # Configuration Encoding
 ///
-/// The configuration is a flat array of `n * m` values.
-/// `config[i * n .. (i + 1) * n]` gives the permutation of jobs on machine `i`
-/// (direct job indices, not Lehmer code). A segment is valid iff it is a
-/// permutation of `0..n`. Invalid configs return `Min(None)`.
+/// The configuration is a flat array of `n * m` non-negative start times in
+/// job-major order: `config[j * m + i]` is the start time of job `j` on
+/// machine `i`. A configuration is valid exactly when operations of the same
+/// job and operations on the same machine do not overlap.
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::misc::OpenShopScheduling;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 /// use problemreductions::types::Min;
 ///
 /// // 2 machines, 2 jobs
 /// let p = vec![vec![1, 2], vec![2, 1]];
 /// let problem = OpenShopScheduling::new(2, p);
 /// let solver = BruteForce::new();
-/// let value = Solver::solve(&solver, &problem);
-/// assert_eq!(value, Min(Some(3)));
+/// let solution = solver.solve(&problem).unwrap().unwrap();
+/// assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(3)));
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(try_from = "OpenShopSchedulingSerde")]
 pub struct OpenShopScheduling {
     /// Number of machines m.
     num_machines: usize,
     /// Processing time matrix: `processing_times[j][i]` is the time to process
     /// job `j` on machine `i`. Dimensions: n jobs × m machines.
-    processing_times: Vec<Vec<usize>>,
+    processing_times: Vec<Vec<i64>>,
+}
+
+#[derive(Deserialize)]
+struct OpenShopSchedulingSerde {
+    num_machines: usize,
+    processing_times: Vec<Vec<i64>>,
+}
+
+impl TryFrom<OpenShopSchedulingSerde> for OpenShopScheduling {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(value: OpenShopSchedulingSerde) -> Result<Self, Self::Error> {
+        Self::try_new(value.num_machines, value.processing_times)
+    }
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct OpenShopSchedulingCreateSpec {
+    /// Number of machines m.
+    num_processors: usize,
+    /// Processing time of each job on each machine (n x m).
+    processing_times: Vec<Vec<i64>>,
+}
+
+impl TryFrom<OpenShopSchedulingCreateSpec> for OpenShopScheduling {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: OpenShopSchedulingCreateSpec) -> Result<Self, Self::Error> {
+        Self::try_new(spec.num_processors, spec.processing_times)
+    }
 }
 
 impl OpenShopScheduling {
@@ -78,22 +107,58 @@ impl OpenShopScheduling {
     ///   Each inner Vec must have length `num_machines`.
     ///
     /// # Panics
-    /// Panics if any job does not have exactly `num_machines` processing times.
-    pub fn new(num_machines: usize, processing_times: Vec<Vec<usize>>) -> Self {
-        for (j, times) in processing_times.iter().enumerate() {
-            assert_eq!(
-                times.len(),
-                num_machines,
-                "Job {} has {} processing times, expected {}",
-                j,
-                times.len(),
-                num_machines
-            );
+    /// Panics if the processing matrix or its schedule horizon is invalid.
+    pub fn new(num_machines: usize, processing_times: Vec<Vec<i64>>) -> Self {
+        Self::try_new(num_machines, processing_times)
+            .expect("invalid open-shop scheduling instance")
+    }
+
+    /// Construct an instance, validating dimensions, durations, and the horizon.
+    pub fn try_new(
+        num_machines: usize,
+        processing_times: Vec<Vec<i64>>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        for (job, times) in processing_times.iter().enumerate() {
+            if times.len() != num_machines {
+                return Err(format!(
+                    "processing_times[{job}] has {} entries, expected {num_machines}",
+                    times.len(),
+                )
+                .into());
+            }
+            if times.iter().any(|&time| time < 0) {
+                return Err(format!("processing_times[{job}] contains a negative duration").into());
+            }
         }
-        Self {
+        processing_times
+            .len()
+            .checked_mul(num_machines)
+            .ok_or_else(|| {
+                crate::registry::ConstructionError::IntegerOverflow(
+                    "operation count overflows usize".into(),
+                )
+            })?;
+        let horizon = processing_times
+            .iter()
+            .flatten()
+            .try_fold(0i64, |total, &time| total.checked_add(time))
+            .ok_or_else(|| {
+                crate::registry::ConstructionError::IntegerOverflow(
+                    "schedule horizon overflows i64".into(),
+                )
+            })?;
+        usize::try_from(horizon)
+            .ok()
+            .and_then(|value| value.checked_add(1))
+            .ok_or_else(|| {
+                crate::registry::ConstructionError::IntegerOverflow(
+                    "schedule horizon domain overflows usize".into(),
+                )
+            })?;
+        Ok(Self {
             num_machines,
             processing_times,
-        }
+        })
     }
 
     /// Get the number of machines.
@@ -107,122 +172,133 @@ impl OpenShopScheduling {
     }
 
     /// Get the processing time matrix.
-    pub fn processing_times(&self) -> &[Vec<usize>] {
+    pub fn processing_times(&self) -> &[Vec<i64>] {
         &self.processing_times
     }
 
-    /// Decode the per-machine job orderings from a config.
-    ///
-    /// Returns `None` if the config length is wrong or any segment is not a
-    /// valid permutation of `0..n`.
-    pub fn decode_orders(&self, config: &[usize]) -> Option<Vec<Vec<usize>>> {
-        let n = self.num_jobs();
-        let m = self.num_machines;
-        if config.len() != n * m {
-            return None;
-        }
-        let mut orders = Vec::with_capacity(m);
-        for i in 0..m {
-            let seg = &config[i * n..(i + 1) * n];
-            // Validate that seg is a permutation of 0..n
-            let mut seen = vec![false; n];
-            for &job in seg {
-                if job >= n || seen[job] {
-                    return None;
-                }
-                seen[job] = true;
-            }
-            orders.push(seg.to_vec());
-        }
-        Some(orders)
+    /// Return the sum of all processing times, a valid serial-schedule horizon.
+    pub fn schedule_horizon(&self) -> usize {
+        self.processing_times
+            .iter()
+            .flatten()
+            .try_fold(0usize, |total, &time| {
+                usize::try_from(time)
+                    .ok()
+                    .and_then(|time| total.checked_add(time))
+            })
+            .expect("processing times must fit the brute-force schedule horizon")
     }
 
-    /// Compute the makespan from a set of per-machine job orderings.
-    ///
-    /// Uses a greedy simulation: at each step, among all machines whose next
-    /// scheduled job can start (both machine and job are free), schedule the
-    /// one with the earliest available start time.
-    pub fn compute_makespan(&self, orders: &[Vec<usize>]) -> usize {
-        let n = self.num_jobs();
-        let m = self.num_machines;
-
-        if n == 0 || m == 0 {
-            return 0;
-        }
-
-        // `machine_avail[i]` = next time machine i is free.
-        let mut machine_avail = vec![0usize; m];
-        // `job_avail[j]` = next time job j is free (all its currently scheduled
-        // tasks have finished).
-        let mut job_avail = vec![0usize; n];
-        // Pointer to next unscheduled position in each machine's ordering.
-        let mut next_on_machine = vec![0usize; m];
-
-        let total_tasks = n * m;
-        let mut scheduled = 0;
-
-        while scheduled < total_tasks {
-            // Find the (machine, earliest start time) among all machines that
-            // still have unscheduled tasks.
-            let mut best_start = usize::MAX;
-            let mut best_machine = usize::MAX;
-
-            for i in 0..m {
-                if next_on_machine[i] < n {
-                    let j = orders[i][next_on_machine[i]];
-                    let start = machine_avail[i].max(job_avail[j]);
-                    // Tie-break by machine index to make the result deterministic.
-                    if start < best_start || (start == best_start && i < best_machine) {
-                        best_start = start;
-                        best_machine = i;
-                    }
-                }
-            }
-
-            // Schedule the chosen task.
-            let i = best_machine;
-            let j = orders[i][next_on_machine[i]];
-            let start = machine_avail[i].max(job_avail[j]);
-            let finish = start + self.processing_times[j][i];
-            machine_avail[i] = finish;
-            job_avail[j] = finish;
-            next_on_machine[i] += 1;
-            scheduled += 1;
-        }
+    fn finish_time(
+        &self,
+        config: &[usize],
+        job: usize,
+        machine: usize,
+    ) -> Result<i64, crate::traits::EvaluationError> {
+        let start = i64::try_from(config[job * self.num_machines + machine]).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting an open-shop start time to i64".into(),
+            )
+        })?;
+        start
+            .checked_add(self.processing_times[job][machine])
+            .ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "computing an open-shop completion time".into(),
+                )
+            })
+    }
 
-        machine_avail
-            .iter()
-            .copied()
-            .max()
-            .unwrap_or(0)
-            .max(job_avail.iter().copied().max().unwrap_or(0))
+    fn operations_overlap(
+        &self,
+        config: &[usize],
+        first: (usize, usize),
+        second: (usize, usize),
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        let (j1, i1) = first;
+        let (j2, i2) = second;
+        let s1 = i64::try_from(config[j1 * self.num_machines + i1]).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow("converting start time to i64".into())
+        })?;
+        let s2 = i64::try_from(config[j2 * self.num_machines + i2]).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow("converting start time to i64".into())
+        })?;
+        let f1 = self.finish_time(config, j1, i1)?;
+        let f2 = self.finish_time(config, j2, i2)?;
+        Ok(s1 < f2 && s2 < f1)
     }
 }
 
 impl Problem for OpenShopScheduling {
     const NAME: &'static str = "OpenShopScheduling";
-    type Value = Min<usize>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_jobs", num_jobs),
+        ("num_machines", num_machines),
+        ("schedule_horizon", schedule_horizon),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.num_jobs();
         let m = self.num_machines;
-        vec![n; n * m]
+        if config.len() != n * m {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "start-time representation length does not match the instance".into(),
+            ));
+        }
+        for machine in 0..m {
+            for first in 0..n {
+                for second in (first + 1)..n {
+                    if self.operations_overlap(config, (first, machine), (second, machine))? {
+                        return Ok(Min(None));
+                    }
+                }
+            }
+        }
+        for job in 0..n {
+            for first in 0..m {
+                for second in (first + 1)..m {
+                    if self.operations_overlap(config, (job, first), (job, second))? {
+                        return Ok(Min(None));
+                    }
+                }
+            }
+        }
+        let mut makespan = 0;
+        for job in 0..n {
+            for machine in 0..m {
+                makespan = makespan.max(self.finish_time(config, job, machine)?);
+            }
+        }
+        Ok(Min(Some(makespan)))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        match self.decode_orders(config) {
-            Some(orders) => Min(Some(self.compute_makespan(&orders))),
-            None => Min(None),
-        }
+impl crate::solvers::BruteForceProblem for OpenShopScheduling {
+    fn dimensions(&self) -> Vec<usize> {
+        let domain = self
+            .schedule_horizon()
+            .checked_add(1)
+            .expect("schedule horizon overflow");
+        vec![domain; self.num_jobs() * self.num_machines]
     }
 }
 
 crate::declare_variants! {
-    default OpenShopScheduling => "factorial(num_jobs)^num_machines",
+    default OpenShopScheduling => "(schedule_horizon + 1)^(num_jobs * num_machines)" create OpenShopSchedulingCreateSpec,
+}
+
+crate::register_brute_force! {
+    OpenShopScheduling,
 }
 
 #[cfg(feature = "example-db")]
@@ -237,29 +313,15 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     // Per-machine totals: M1=8, M2=8, M3=7.  Per-job totals: J1=6, J2=6, J3=6, J4=5.
     // Lower bound: max(8, 6) = 8. True optimal makespan = 8.
     //
-    // Optimal machine orderings (0-indexed jobs):
-    //   M1: [J1, J2, J3, J4] = [0, 1, 2, 3]
-    //   M2: [J2, J1, J4, J3] = [1, 0, 3, 2]
-    //   M3: [J3, J4, J1, J2] = [2, 3, 0, 1]
-    //
-    // config = [M1 order | M2 order | M3 order]
-    //        = [0, 1, 2, 3, 1, 0, 3, 2, 2, 3, 0, 1]
-    //
-    // Resulting schedule:
-    //   J1: M1=[0,3), M2=[7,8), M3=[1,3)  — job non-overlap: [0,3),[1,3) overlap!
-    //   Actually use simulation to verify:
-    //   Step 1: best start = M1(J1:0), M2(J2:0), M3(J3:0) → M1 ties with M2,M3; pick M1
-    //           J1 on M1: [0,3)
-    //   ... (simulation produces makespan=8)
-    //
-    // 224 out of 13824 orderings achieve the optimal makespan of 8.
+    // Job-major start times: J1=[0,3,4], J2=[3,0,6], J3=[5,6,0], J4=[6,4,3].
+    // Each job and machine has non-overlapping operations; the last finish is 8.
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "open_shop_scheduling",
         instance: Box::new(OpenShopScheduling::new(
             3,
             vec![vec![3, 1, 2], vec![2, 3, 1], vec![1, 2, 3], vec![2, 2, 1]],
         )),
-        optimal_config: vec![0, 1, 2, 3, 1, 0, 3, 2, 2, 3, 0, 1],
+        optimal_config: serde_json::json!(vec![0, 3, 4, 3, 0, 6, 5, 6, 0, 6, 4, 3]),
         optimal_value: serde_json::json!(8),
     }]
 }
diff --git a/src/models/misc/optimum_communication_spanning_tree.rs b/src/models/misc/optimum_communication_spanning_tree.rs
index 6f2729b9a..a2732e7a1 100644
--- a/src/models/misc/optimum_communication_spanning_tree.rs
+++ b/src/models/misc/optimum_communication_spanning_tree.rs
@@ -5,7 +5,7 @@
 //! minimizes the total communication cost: sum_{u<v} r(u,v) * W_T(u,v),
 //! where W_T(u,v) is the sum of edge weights on the unique path from u to v in T.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -17,13 +17,10 @@ inventory::submit! {
         display_name: "Optimum Communication Spanning Tree",
         aliases: &["OCST"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find spanning tree minimizing total weighted communication cost",
-        fields: &[
-            FieldInfo { name: "num_vertices", type_name: "usize", description: "Number of vertices n" },
-            FieldInfo { name: "edge_weights", type_name: "Vec<Vec<i32>>", description: "Symmetric weight matrix w(i,j)" },
-            FieldInfo { name: "requirements", type_name: "Vec<Vec<i32>>", description: "Symmetric requirement matrix r(i,j)" },
-        ],
+        fields: OptimumCommunicationSpanningTreeCreateSpec::FIELDS,
     }
 }
 
@@ -47,7 +44,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::OptimumCommunicationSpanningTree;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = OptimumCommunicationSpanningTree::new(
 ///     vec![
@@ -62,14 +59,57 @@ inventory::submit! {
 ///     ],
 /// );
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct OptimumCommunicationSpanningTree {
     num_vertices: usize,
-    edge_weights: Vec<Vec<i32>>,
-    requirements: Vec<Vec<i32>>,
+    edge_weights: Vec<Vec<i64>>,
+    requirements: Vec<Vec<i64>>,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct OptimumCommunicationSpanningTreeCreateSpec {
+    /// Number of vertices.
+    num_vertices: usize,
+    /// Symmetric weight matrix; defaults to unit off-diagonal weights.
+    edge_weights: Option<Vec<Vec<i64>>>,
+    /// Symmetric communication requirement matrix.
+    requirements: Vec<Vec<i64>>,
+}
+impl TryFrom<OptimumCommunicationSpanningTreeCreateSpec> for OptimumCommunicationSpanningTree {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: OptimumCommunicationSpanningTreeCreateSpec) -> Result<Self, Self::Error> {
+        let n = spec.num_vertices;
+        if n < 2 {
+            return Err("must have at least two vertices".to_string().into());
+        }
+        let edge_weights = spec.edge_weights.unwrap_or_else(|| {
+            (0..n)
+                .map(|i| (0..n).map(|j| i64::from(i != j)).collect())
+                .collect()
+        });
+        for (name, matrix) in [
+            ("edge_weights", &edge_weights),
+            ("requirements", &spec.requirements),
+        ] {
+            if matrix.len() != n || matrix.iter().any(|row| row.len() != n) {
+                return Err(format!("{name} must be a {n} x {n} matrix").into());
+            }
+            for (i, row) in matrix.iter().enumerate() {
+                if row[i] != 0 {
+                    return Err(format!("{name} diagonal must be zero").into());
+                }
+                for (j, &value) in row.iter().enumerate().skip(i + 1) {
+                    if value != matrix[j][i] || value < 0 {
+                        return Err(format!("{name} must be symmetric and nonnegative").into());
+                    }
+                }
+            }
+        }
+        Ok(Self::new(edge_weights, spec.requirements))
+    }
 }
 
 impl OptimumCommunicationSpanningTree {
@@ -84,7 +124,7 @@ impl OptimumCommunicationSpanningTree {
     ///
     /// Panics if the matrices are not square, not the same size, have nonzero
     /// diagonals, are not symmetric, or contain negative entries.
-    pub fn new(edge_weights: Vec<Vec<i32>>, requirements: Vec<Vec<i32>>) -> Self {
+    pub fn new(edge_weights: Vec<Vec<i64>>, requirements: Vec<Vec<i64>>) -> Self {
         let n = edge_weights.len();
         assert!(n >= 2, "must have at least 2 vertices");
         assert_eq!(
@@ -165,12 +205,12 @@ impl OptimumCommunicationSpanningTree {
     }
 
     /// Returns the edge weight matrix.
-    pub fn edge_weights(&self) -> &Vec<Vec<i32>> {
+    pub fn edge_weights(&self) -> &Vec<Vec<i64>> {
         &self.edge_weights
     }
 
     /// Returns the requirements matrix.
-    pub fn requirements(&self) -> &Vec<Vec<i32>> {
+    pub fn requirements(&self) -> &Vec<Vec<i64>> {
         &self.requirements
     }
 
@@ -194,18 +234,13 @@ impl OptimumCommunicationSpanningTree {
 }
 
 /// Check if a configuration forms a valid spanning tree of K_n.
-fn is_valid_spanning_tree(n: usize, edges: &[(usize, usize)], config: &[usize]) -> bool {
+fn is_valid_spanning_tree(n: usize, edges: &[(usize, usize)], config: &[bool]) -> bool {
     if config.len() != edges.len() {
         return false;
     }
 
-    // Check all values are 0 or 1
-    if config.iter().any(|&v| v > 1) {
-        return false;
-    }
-
     // Count selected edges: must be exactly n-1
-    let selected_count: usize = config.iter().sum();
+    let selected_count = config.iter().filter(|&&selected| selected).count();
     if selected_count != n - 1 {
         return false;
     }
@@ -213,7 +248,7 @@ fn is_valid_spanning_tree(n: usize, edges: &[(usize, usize)], config: &[usize])
     // Build adjacency and check connectivity via BFS
     let mut adj: Vec<Vec<usize>> = vec![vec![]; n];
     for (idx, &sel) in config.iter().enumerate() {
-        if sel == 1 {
+        if sel {
             let (u, v) = edges[idx];
             adj[u].push(v);
             adj[v].push(u);
@@ -243,14 +278,14 @@ fn is_valid_spanning_tree(n: usize, edges: &[(usize, usize)], config: &[usize])
 fn communication_cost(
     n: usize,
     edges: &[(usize, usize)],
-    config: &[usize],
-    edge_weights: &[Vec<i32>],
-    requirements: &[Vec<i32>],
-) -> i64 {
+    config: &[bool],
+    edge_weights: &[Vec<i64>],
+    requirements: &[Vec<i64>],
+) -> Result<i64, crate::traits::EvaluationError> {
     // Build weighted adjacency list for the tree
-    let mut adj: Vec<Vec<(usize, i32)>> = vec![vec![]; n];
+    let mut adj: Vec<Vec<(usize, i64)>> = vec![vec![]; n];
     for (idx, &sel) in config.iter().enumerate() {
-        if sel == 1 {
+        if sel {
             let (u, v) = edges[idx];
             let w = edge_weights[u][v];
             adj[u].push((v, w));
@@ -269,7 +304,11 @@ fn communication_cost(
         while let Some(u) = queue.pop_front() {
             for &(v, w) in &adj[u] {
                 if dist[v] < 0 {
-                    dist[v] = dist[u] + w as i64;
+                    dist[v] = dist[u].checked_add(w).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing communication-tree path weights".to_string(),
+                        )
+                    })?;
                     queue.push_back(v);
                 }
             }
@@ -277,42 +316,70 @@ fn communication_cost(
 
         // Accumulate r(src, dst) * W_T(src, dst) for dst > src
         for (dst, &d) in dist.iter().enumerate().skip(src + 1) {
-            total_cost += requirements[src][dst] as i64 * d;
+            let term = requirements[src][dst].checked_mul(d).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "multiplying communication requirement by path weight".to_string(),
+                )
+            })?;
+            total_cost = total_cost.checked_add(term).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing communication-tree costs".to_string(),
+                )
+            })?;
         }
     }
 
-    total_cost
+    Ok(total_cost)
 }
 
 impl Problem for OptimumCommunicationSpanningTree {
     const NAME: &'static str = "OptimumCommunicationSpanningTree";
+    type Solution = Vec<bool>;
     type Value = Min<i64>;
 
+    crate::problem_parameters![("num_edges", num_edges), ("num_vertices", num_vertices),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_edges()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.edges().len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "edge-selection length does not match the complete graph".into(),
+            ));
+        }
+        Ok({
+            let edges = self.edges();
+            if !is_valid_spanning_tree(self.num_vertices, &edges, config) {
+                return Ok(Min(None));
+            }
+            Min(Some(communication_cost(
+                self.num_vertices,
+                &edges,
+                config,
+                &self.edge_weights,
+                &self.requirements,
+            )?))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<i64> {
-        let edges = self.edges();
-        if !is_valid_spanning_tree(self.num_vertices, &edges, config) {
-            return Min(None);
-        }
-        Min(Some(communication_cost(
-            self.num_vertices,
-            &edges,
-            config,
-            &self.edge_weights,
-            &self.requirements,
-        )))
+impl crate::solvers::BruteForceProblem for OptimumCommunicationSpanningTree {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_edges()]
     }
 }
 
 crate::declare_variants! {
-    default OptimumCommunicationSpanningTree => "2^num_edges",
+    default OptimumCommunicationSpanningTree => "2^num_edges" create OptimumCommunicationSpanningTreeCreateSpec,
+}
+
+crate::register_brute_force! {
+    OptimumCommunicationSpanningTree decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -344,7 +411,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             edge_weights,
             requirements,
         )),
-        optimal_config: vec![1, 0, 1, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![true, false, true, false, false, true]),
         optimal_value: serde_json::json!(20),
     }]
 }
diff --git a/src/models/misc/paintshop.rs b/src/models/misc/paintshop.rs
index b144ced5b..e758c9faf 100644
--- a/src/models/misc/paintshop.rs
+++ b/src/models/misc/paintshop.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Paint Shop",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Minimize color changes in paint shop sequence",
         fields: &[
@@ -34,17 +35,17 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::PaintShop;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Sequence: a, b, a, c, c, b
 /// let problem = PaintShop::new(vec!["a", "b", "a", "c", "c", "b"]);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // The minimum number of color switches
 /// for sol in &solutions {
-///     let switches = problem.count_switches(sol);
+///     let switches = problem.count_switches(sol).unwrap();
 ///     println!("Switches: {}", switches);
 /// }
 /// ```
@@ -148,45 +149,63 @@ impl PaintShop {
     ///
     /// Config assigns a color (0 or 1) to each car for its first occurrence.
     /// The second occurrence gets the opposite color.
-    pub fn get_coloring(&self, config: &[usize]) -> Vec<usize> {
-        self.sequence_indices
+    pub fn get_coloring(
+        &self,
+        config: &[bool],
+    ) -> Result<Vec<bool>, crate::traits::EvaluationError> {
+        if config.len() != self.num_cars {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "paint assignment length does not match the cars".into(),
+            ));
+        }
+        Ok(self
+            .sequence_indices
             .iter()
             .enumerate()
             .map(|(i, &car_idx)| {
-                let first_color = config.get(car_idx).copied().unwrap_or(0);
+                let first_color = config[car_idx];
                 if self.is_first[i] {
                     first_color
                 } else {
-                    1 - first_color // Opposite color for second occurrence
+                    !first_color // Opposite color for second occurrence
                 }
             })
-            .collect()
+            .collect())
     }
 
     /// Count the number of color switches in the sequence.
-    pub fn count_switches(&self, config: &[usize]) -> usize {
-        let coloring = self.get_coloring(config);
-        coloring.windows(2).filter(|w| w[0] != w[1]).count()
+    pub fn count_switches(&self, config: &[bool]) -> Result<i64, crate::traits::EvaluationError> {
+        let coloring = self.get_coloring(config)?;
+        let count = coloring.windows(2).filter(|w| w[0] != w[1]).count();
+        i64::try_from(count).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting paint-switch count to i64".into(),
+            )
+        })
     }
 }
 
 /// Count color switches in a painted sequence.
 #[cfg(test)]
-pub(crate) fn count_paint_switches(coloring: &[usize]) -> usize {
+pub(crate) fn count_paint_switches(coloring: &[bool]) -> usize {
     coloring.windows(2).filter(|w| w[0] != w[1]).count()
 }
 
 impl Problem for PaintShop {
     const NAME: &'static str = "PaintShop";
-    type Value = Min<i32>;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_cars]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<i32> {
-        // All configurations are valid (no hard constraints).
-        Min(Some(self.count_switches(config) as i32))
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_cars", num_cars), ("num_sequence", num_sequence),];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            // All configurations are valid (no hard constraints).
+            Min(Some(self.count_switches(config)?))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -194,16 +213,26 @@ impl Problem for PaintShop {
     }
 }
 
+impl crate::solvers::BruteForceProblem for PaintShop {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_cars]
+    }
+}
+
 crate::declare_variants! {
     default PaintShop => "2^num_cars",
 }
 
+crate::register_brute_force! {
+    PaintShop decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "paintshop",
         instance: Box::new(PaintShop::new(vec!["A", "B", "A", "C", "B", "C"])),
-        optimal_config: vec![0, 0, 1],
+        optimal_config: serde_json::json!(vec![false, false, true]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/misc/partially_ordered_knapsack.rs b/src/models/misc/partially_ordered_knapsack.rs
index 405dab450..af4e40f5b 100644
--- a/src/models/misc/partially_ordered_knapsack.rs
+++ b/src/models/misc/partially_ordered_knapsack.rs
@@ -4,7 +4,7 @@
 //! an item requires including all its predecessors (downward-closed set).
 //! NP-complete in the strong sense (Garey & Johnson, A6 MP12).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Max;
 use serde::{Deserialize, Serialize};
@@ -15,14 +15,10 @@ inventory::submit! {
         display_name: "Partially Ordered Knapsack",
         aliases: &["POK"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Select items to maximize total value subject to precedence constraints and weight capacity",
-        fields: &[
-            FieldInfo { name: "weights", type_name: "Vec<i64>", description: "Item weights w(u) for each item" },
-            FieldInfo { name: "values", type_name: "Vec<i64>", description: "Item values v(u) for each item" },
-            FieldInfo { name: "precedences", type_name: "Vec<(usize, usize)>", description: "Precedence pairs (a, b) meaning a must be included before b" },
-            FieldInfo { name: "capacity", type_name: "i64", description: "Knapsack capacity B" },
-        ],
+        fields: PartiallyOrderedKnapsackCreateSpec::FIELDS,
     }
 }
 
@@ -43,7 +39,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::PartiallyOrderedKnapsack;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = PartiallyOrderedKnapsack::new(
 ///     vec![2, 3, 4, 1, 2, 3],  // weights
@@ -52,7 +48,7 @@ inventory::submit! {
 ///     11,  // capacity
 /// );
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 ///
@@ -76,6 +72,70 @@ pub struct PartiallyOrderedKnapsack {
     predecessors: Vec<Vec<usize>>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct PartiallyOrderedKnapsackCreateSpec {
+    weights: Vec<i64>,
+    values: Vec<i64>,
+    precedences: Option<Vec<(usize, usize)>>,
+    capacity: i64,
+}
+
+impl TryFrom<PartiallyOrderedKnapsackCreateSpec> for PartiallyOrderedKnapsack {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: PartiallyOrderedKnapsackCreateSpec) -> Result<Self, Self::Error> {
+        if spec.weights.len() != spec.values.len() {
+            return Err("weights and values must have the same length"
+                .to_string()
+                .into());
+        }
+        if spec.capacity < 0 {
+            return Err("capacity must be non-negative".to_string().into());
+        }
+        if let Some((index, weight)) = spec
+            .weights
+            .iter()
+            .enumerate()
+            .find(|(_, weight)| **weight < 0)
+        {
+            return Err(format!("weight[{index}] must be non-negative, got {weight}").into());
+        }
+        if let Some((index, value)) = spec
+            .values
+            .iter()
+            .enumerate()
+            .find(|(_, value)| **value < 0)
+        {
+            return Err(format!("value[{index}] must be non-negative, got {value}").into());
+        }
+        let precedences = spec.precedences.unwrap_or_default();
+        let num_items = spec.weights.len();
+        if let Some(&(pred, succ)) = precedences
+            .iter()
+            .find(|&&(pred, succ)| pred >= num_items || succ >= num_items)
+        {
+            return Err(format!(
+                "precedence ({pred}, {succ}) is out of range for {num_items} items"
+            )
+            .into());
+        }
+        let predecessors = Self::compute_predecessors(&precedences, num_items);
+        if let Some(item) = predecessors
+            .iter()
+            .enumerate()
+            .find_map(|(item, preds)| preds.contains(&item).then_some(item))
+        {
+            return Err(format!("precedences contain a cycle involving item {item}").into());
+        }
+        Ok(Self::new(
+            spec.weights,
+            spec.values,
+            precedences,
+            spec.capacity,
+        ))
+    }
+}
+
 impl Serialize for PartiallyOrderedKnapsack {
     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         PartiallyOrderedKnapsackRaw {
@@ -207,11 +267,11 @@ impl PartiallyOrderedKnapsack {
     ///
     /// Uses precomputed transitive predecessors: if item `b` is selected,
     /// all its predecessors must also be selected.
-    fn is_downward_closed(&self, config: &[usize]) -> bool {
+    fn is_downward_closed(&self, config: &[bool]) -> bool {
         for (b, preds) in self.predecessors.iter().enumerate() {
-            if config[b] == 1 {
+            if config[b] {
                 for &a in preds {
-                    if config[a] != 1 {
+                    if !config[a] {
                         return false;
                     }
                 }
@@ -223,50 +283,78 @@ impl PartiallyOrderedKnapsack {
 
 impl Problem for PartiallyOrderedKnapsack {
     const NAME: &'static str = "PartiallyOrderedKnapsack";
+    type Solution = Vec<bool>;
     type Value = Max<i64>;
 
+    crate::problem_parameters![
+        ("num_items", num_items),
+        ("num_precedences", num_precedences),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_items()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.num_items() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "item-selection length does not match the instance".into(),
+                ));
+            }
+            // Check downward-closure (precedence constraints)
+            if !self.is_downward_closed(config) {
+                return Ok(Max(None));
+            }
+            // Check capacity constraint
+            let total_weight = config
+                .iter()
+                .enumerate()
+                .filter(|(_, &x)| x)
+                .map(|(i, _)| self.weights[i])
+                .try_fold(0_i64, |total, weight| {
+                    total.checked_add(weight).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing selected partially ordered knapsack weights".into(),
+                        )
+                    })
+                })?;
+            if total_weight > self.capacity {
+                return Ok(Max(None));
+            }
+            // Compute total value
+            let total_value = config
+                .iter()
+                .enumerate()
+                .filter(|(_, &x)| x)
+                .map(|(i, _)| self.values[i])
+                .try_fold(0_i64, |total, value| {
+                    total.checked_add(value).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing selected partially ordered knapsack values".into(),
+                        )
+                    })
+                })?;
+            Max(Some(total_value))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Max<i64> {
-        if config.len() != self.num_items() {
-            return Max(None);
-        }
-        if config.iter().any(|&v| v >= 2) {
-            return Max(None);
-        }
-        // Check downward-closure (precedence constraints)
-        if !self.is_downward_closed(config) {
-            return Max(None);
-        }
-        // Check capacity constraint
-        let total_weight: i64 = config
-            .iter()
-            .enumerate()
-            .filter(|(_, &x)| x == 1)
-            .map(|(i, _)| self.weights[i])
-            .sum();
-        if total_weight > self.capacity {
-            return Max(None);
-        }
-        // Compute total value
-        let total_value: i64 = config
-            .iter()
-            .enumerate()
-            .filter(|(_, &x)| x == 1)
-            .map(|(i, _)| self.values[i])
-            .sum();
-        Max(Some(total_value))
+impl crate::solvers::BruteForceProblem for PartiallyOrderedKnapsack {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_items()]
     }
 }
 
 crate::declare_variants! {
-    default PartiallyOrderedKnapsack => "2^num_items",
+    default PartiallyOrderedKnapsack => "2^num_items" create PartiallyOrderedKnapsackCreateSpec,
+}
+
+crate::register_brute_force! {
+    PartiallyOrderedKnapsack decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -279,7 +367,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![(0, 2), (0, 3), (1, 4), (3, 5), (4, 5)],
             11,
         )),
-        optimal_config: vec![1, 1, 0, 1, 1, 1],
+        optimal_config: serde_json::json!(vec![true, true, false, true, true, true]),
         optimal_value: serde_json::json!(20),
     }]
 }
diff --git a/src/models/misc/partition.rs b/src/models/misc/partition.rs
index 1f42dddb0..032f4eccc 100644
--- a/src/models/misc/partition.rs
+++ b/src/models/misc/partition.rs
@@ -4,7 +4,7 @@
 //! partitioned into two subsets of equal sum. One of Karp's original 21
 //! NP-complete problems (1972), Garey & Johnson SP12.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{ConstructionError, FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,10 +14,11 @@ inventory::submit! {
         display_name: "Partition",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine whether a multiset of positive integers can be partitioned into two subsets of equal sum",
         fields: &[
-            FieldInfo { name: "sizes", type_name: "Vec<u64>", description: "Positive integer size for each element" },
+            FieldInfo { name: "sizes", type_name: "Vec<i64>", description: "Positive integer size for each element" },
         ],
     }
 }
@@ -37,35 +38,41 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::Partition;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
-/// let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]);
+/// let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct Partition {
-    sizes: Vec<u64>,
+    sizes: Vec<i64>,
 }
 
 impl Partition {
     /// Create a new Partition instance.
     ///
-    /// # Panics
-    ///
-    /// Panics if `sizes` is empty or any size is zero.
-    pub fn new(sizes: Vec<u64>) -> Self {
-        assert!(!sizes.is_empty(), "Partition requires at least one element");
-        assert!(
-            sizes.iter().all(|&s| s > 0),
-            "All sizes must be positive (> 0)"
-        );
-        Self { sizes }
+    pub fn new(sizes: Vec<i64>) -> Result<Self, ConstructionError> {
+        if sizes.is_empty() {
+            return Err(ConstructionError::Conversion(
+                "Partition requires at least one element".into(),
+            ));
+        }
+        if sizes.iter().any(|&size| size <= 0) {
+            return Err(ConstructionError::Conversion(
+                "all Partition sizes must be positive".into(),
+            ));
+        }
+        sizes
+            .iter()
+            .try_fold(0i64, |sum, &size| sum.checked_add(size))
+            .ok_or_else(|| ConstructionError::IntegerOverflow("summing Partition sizes".into()))?;
+        Ok(Self { sizes })
     }
 
     /// Returns the element sizes.
-    pub fn sizes(&self) -> &[u64] {
+    pub fn sizes(&self) -> &[i64] {
         &self.sizes
     }
 
@@ -75,39 +82,63 @@ impl Partition {
     }
 
     /// Returns the total sum of all sizes.
-    pub fn total_sum(&self) -> u64 {
+    pub fn total_sum(&self) -> i64 {
         self.sizes.iter().sum()
     }
 }
 
+impl<'de> Deserialize<'de> for Partition {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Raw {
+            sizes: Vec<i64>,
+        }
+
+        let raw = Raw::deserialize(deserializer)?;
+        Self::new(raw.sizes).map_err(serde::de::Error::custom)
+    }
+}
+
 impl Problem for Partition {
     const NAME: &'static str = "Partition";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_elements", num_elements),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_elements()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_elements() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "partition selection length does not match the elements".into(),
+                    ));
+                }
+                let selected_sum: i64 = config
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, &x)| x)
+                    .map(|(i, _)| self.sizes[i])
+                    .sum();
+                selected_sum == self.total_sum() - selected_sum
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_elements() {
-                return crate::types::Or(false);
-            }
-            if config.iter().any(|&v| v >= 2) {
-                return crate::types::Or(false);
-            }
-            let selected_sum: u64 = config
-                .iter()
-                .enumerate()
-                .filter(|(_, &x)| x == 1)
-                .map(|(i, _)| self.sizes[i])
-                .sum();
-            selected_sum * 2 == self.total_sum()
-        })
+impl crate::solvers::BruteForceProblem for Partition {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_elements()]
     }
 }
 
@@ -115,12 +146,16 @@ crate::declare_variants! {
     default Partition => "2^(num_elements / 2)",
 }
 
+crate::register_brute_force! {
+    Partition decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "partition",
-        instance: Box::new(Partition::new(vec![3, 1, 1, 2, 2, 1])),
-        optimal_config: vec![1, 0, 0, 1, 0, 0],
+        instance: Box::new(Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap()),
+        optimal_config: serde_json::json!(vec![true, false, false, true, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/precedence_constrained_scheduling.rs b/src/models/misc/precedence_constrained_scheduling.rs
index e5c887e07..b062b26a2 100644
--- a/src/models/misc/precedence_constrained_scheduling.rs
+++ b/src/models/misc/precedence_constrained_scheduling.rs
@@ -4,7 +4,7 @@
 //! deadline D, determine whether all tasks can be scheduled to meet D while
 //! respecting precedences. NP-complete via reduction from 3SAT (Ullman, 1975).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,14 +14,10 @@ inventory::submit! {
         display_name: "Precedence Constrained Scheduling",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Schedule unit-length tasks on m processors by deadline D respecting precedence constraints",
-        fields: &[
-            FieldInfo { name: "num_tasks", type_name: "usize", description: "Number of tasks n = |T|" },
-            FieldInfo { name: "num_processors", type_name: "usize", description: "Number of processors m" },
-            FieldInfo { name: "deadline", type_name: "usize", description: "Global deadline D" },
-            FieldInfo { name: "precedences", type_name: "Vec<(usize, usize)>", description: "Precedence pairs (i, j) meaning task i must finish before task j starts" },
-        ],
+        fields: PrecedenceConstrainedSchedulingCreateSpec::FIELDS,
     }
 }
 
@@ -42,22 +38,69 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::PrecedenceConstrainedScheduling;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 4 tasks, 2 processors, deadline 3, with t0 < t2 and t1 < t3
 /// let problem = PrecedenceConstrainedScheduling::new(4, 2, 3, vec![(0, 2), (1, 3)]);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PrecedenceConstrainedScheduling {
     num_tasks: usize,
     num_processors: usize,
-    deadline: usize,
+    deadline: i64,
     precedences: Vec<(usize, usize)>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct PrecedenceConstrainedSchedulingCreateSpec {
+    num_tasks: usize,
+    num_processors: usize,
+    deadline: i64,
+    precedences: Option<Vec<(usize, usize)>>,
+}
+
+impl TryFrom<PrecedenceConstrainedSchedulingCreateSpec> for PrecedenceConstrainedScheduling {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: PrecedenceConstrainedSchedulingCreateSpec) -> Result<Self, Self::Error> {
+        if spec.num_tasks > 0 && spec.num_processors == 0 {
+            return Err("num_processors must be positive when there are tasks"
+                .to_string()
+                .into());
+        }
+        if spec.num_tasks > 0 && spec.deadline == 0 {
+            return Err("deadline must be positive when there are tasks"
+                .to_string()
+                .into());
+        }
+        if spec.deadline < 0 || usize::try_from(spec.deadline).is_err() {
+            return Err("deadline must be nonnegative and fit usize"
+                .to_string()
+                .into());
+        }
+        let precedences = spec.precedences.unwrap_or_default();
+        if let Some(&(pred, succ)) = precedences
+            .iter()
+            .find(|&&(pred, succ)| pred >= spec.num_tasks || succ >= spec.num_tasks)
+        {
+            return Err(format!(
+                "precedence ({pred}, {succ}) is out of range for {} tasks",
+                spec.num_tasks
+            )
+            .into());
+        }
+        Ok(Self::new(
+            spec.num_tasks,
+            spec.num_processors,
+            spec.deadline,
+            precedences,
+        ))
+    }
+}
+
 impl PrecedenceConstrainedScheduling {
     /// Create a new Precedence Constrained Scheduling instance.
     ///
@@ -68,7 +111,7 @@ impl PrecedenceConstrainedScheduling {
     pub fn new(
         num_tasks: usize,
         num_processors: usize,
-        deadline: usize,
+        deadline: i64,
         precedences: Vec<(usize, usize)>,
     ) -> Self {
         if num_tasks > 0 {
@@ -78,6 +121,10 @@ impl PrecedenceConstrainedScheduling {
             );
             assert!(deadline > 0, "deadline must be > 0 when there are tasks");
         }
+        assert!(
+            deadline >= 0 && usize::try_from(deadline).is_ok(),
+            "deadline must be nonnegative and fit usize"
+        );
         for &(i, j) in &precedences {
             assert!(
                 i < num_tasks && j < num_tasks,
@@ -106,7 +153,7 @@ impl PrecedenceConstrainedScheduling {
     }
 
     /// Get the deadline.
-    pub fn deadline(&self) -> usize {
+    pub fn deadline(&self) -> i64 {
         self.deadline
     }
 
@@ -114,50 +161,81 @@ impl PrecedenceConstrainedScheduling {
     pub fn precedences(&self) -> &[(usize, usize)] {
         &self.precedences
     }
+
+    /// Return the number of precedence relations.
+    pub fn num_precedences(&self) -> usize {
+        self.precedences.len()
+    }
 }
 
 impl Problem for PrecedenceConstrainedScheduling {
     const NAME: &'static str = "PrecedenceConstrainedScheduling";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("deadline", deadline),
+        ("num_precedences", num_precedences),
+        ("num_tasks", num_tasks),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.deadline; self.num_tasks]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_tasks {
-                return crate::types::Or(false);
-            }
-            // Check all values are valid time slots
-            if config.iter().any(|&v| v >= self.deadline) {
-                return crate::types::Or(false);
-            }
-            // Check processor capacity: at most num_processors tasks per time slot
-            let mut slot_count = vec![0usize; self.deadline];
-            for &slot in config {
-                slot_count[slot] += 1;
-                if slot_count[slot] > self.num_processors {
-                    return crate::types::Or(false);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_tasks {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "schedule length does not match the tasks".into(),
+                    ));
+                }
+                let deadline =
+                    usize::try_from(self.deadline).expect("validated deadline must fit usize");
+                if config.iter().any(|&v| v >= deadline) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "schedule contains an out-of-range time slot".into(),
+                    ));
                 }
-            }
-            // Check precedence constraints: for (i, j), slot[j] >= slot[i] + 1
-            for &(i, j) in &self.precedences {
-                if config[j] < config[i] + 1 {
-                    return crate::types::Or(false);
+                // Check processor capacity: at most num_processors tasks per time slot
+                let mut slot_count = vec![0usize; deadline];
+                for &slot in config {
+                    slot_count[slot] += 1;
+                    if slot_count[slot] > self.num_processors {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
-            }
-            true
+                // Check precedence constraints: for (i, j), slot[j] >= slot[i] + 1
+                for &(i, j) in &self.precedences {
+                    if config[j] < config[i] + 1 {
+                        return Ok(crate::types::Or(false));
+                    }
+                }
+                true
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for PrecedenceConstrainedScheduling {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![
+            usize::try_from(self.deadline).expect("validated deadline must fit usize");
+            self.num_tasks
+        ]
+    }
+}
+
 crate::declare_variants! {
-    default PrecedenceConstrainedScheduling => "2^num_tasks",
+    default PrecedenceConstrainedScheduling => "2^num_tasks" create PrecedenceConstrainedSchedulingCreateSpec,
+}
+
+crate::register_brute_force! {
+    PrecedenceConstrainedScheduling,
 }
 
 #[cfg(feature = "example-db")]
@@ -182,7 +260,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
         )),
         // Valid schedule: slot 0: {t0,t1}, slot 1: {t2,t3,t4}, slot 2: {t5,t6}, slot 3: {t7}
-        optimal_config: vec![0, 0, 1, 1, 1, 2, 2, 3],
+        optimal_config: serde_json::json!(vec![0, 0, 1, 1, 1, 2, 2, 3]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/preemptive_scheduling.rs b/src/models/misc/preemptive_scheduling.rs
index cad0d78ee..119fae84d 100644
--- a/src/models/misc/preemptive_scheduling.rs
+++ b/src/models/misc/preemptive_scheduling.rs
@@ -5,7 +5,7 @@
 //! `m` identical processors, subject to precedence constraints.
 //! The goal is to minimize the makespan (latest completion time).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{ConstructionError, CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -16,13 +16,10 @@ inventory::submit! {
         display_name: "Preemptive Scheduling",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Minimize makespan for preemptive parallel-processor scheduling with precedence constraints",
-        fields: &[
-            FieldInfo { name: "lengths", type_name: "Vec<usize>", description: "Processing length l(t) for each task" },
-            FieldInfo { name: "num_processors", type_name: "usize", description: "Number of identical processors m" },
-            FieldInfo { name: "precedences", type_name: "Vec<(usize, usize)>", description: "Precedence pairs (pred, succ) — pred must finish before succ starts" },
-        ],
+        fields: PreemptiveSchedulingCreateSpec::FIELDS,
     }
 }
 
@@ -36,7 +33,7 @@ inventory::submit! {
 /// A configuration is a binary vector of length `n × D_max` where
 /// `D_max = sum of all lengths` is the worst-case makespan.
 ///
-/// `config[t * D_max + u] = 1` means task `t` is processed at time slot `u`.
+/// `solution[t][u] = true` means task `t` is processed at time slot `u`.
 ///
 /// A valid schedule satisfies:
 /// - Each task `t` is active in exactly `l(t)` time slots.
@@ -52,47 +49,80 @@ inventory::submit! {
 /// use problemreductions::models::misc::PreemptiveScheduling;
 /// use problemreductions::Problem;
 ///
-/// let problem = PreemptiveScheduling::new(vec![2, 1], 2, vec![]);
-/// // D_max = 3, config length = 2 * 3 = 6
+/// let problem = PreemptiveScheduling::new(vec![2, 1], 2, vec![]).unwrap();
+/// // D_max = 3, so the solution is a 2 × 3 task-by-time matrix.
 /// // task 0 active at slots 0,1; task 1 active at slot 0
-/// let config = vec![1, 1, 0, 1, 0, 0];
-/// assert_eq!(problem.evaluate(&config), problemreductions::types::Min(Some(2)));
+/// let solution = vec![
+///     vec![true, true, false],
+///     vec![true, false, false],
+/// ];
+/// assert_eq!(problem.evaluate(&solution).unwrap(), problemreductions::types::Min(Some(2)));
 /// ```
 #[derive(Debug, Clone, Serialize)]
 pub struct PreemptiveScheduling {
     /// Processing length for each task.
-    lengths: Vec<usize>,
+    lengths: Vec<i64>,
     /// Number of identical processors.
     num_processors: usize,
     /// Precedence constraints: (pred, succ) means pred must finish before succ starts.
     precedences: Vec<(usize, usize)>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct PreemptiveSchedulingCreateSpec {
+    lengths: Vec<i64>,
+    num_processors: usize,
+    precedences: Option<Vec<(usize, usize)>>,
+}
+
+impl TryFrom<PreemptiveSchedulingCreateSpec> for PreemptiveScheduling {
+    type Error = ConstructionError;
+
+    fn try_from(spec: PreemptiveSchedulingCreateSpec) -> Result<Self, Self::Error> {
+        let precedences = spec.precedences.unwrap_or_default();
+        Self::new(spec.lengths, spec.num_processors, precedences)
+    }
+}
+
 #[derive(Deserialize)]
 struct PreemptiveSchedulingSerde {
-    lengths: Vec<usize>,
+    lengths: Vec<i64>,
     num_processors: usize,
     precedences: Vec<(usize, usize)>,
 }
 
 impl PreemptiveScheduling {
     fn validate(
-        lengths: &[usize],
+        lengths: &[i64],
         num_processors: usize,
         precedences: &[(usize, usize)],
-    ) -> Result<(), String> {
-        if lengths.contains(&0) {
-            return Err("task lengths must be positive".to_string());
+    ) -> Result<(), ConstructionError> {
+        if lengths.iter().any(|&length| length <= 0) {
+            return Err(ConstructionError::Conversion(
+                "task lengths must be positive".into(),
+            ));
         }
         if num_processors == 0 {
-            return Err("num_processors must be positive".to_string());
+            return Err(ConstructionError::Conversion(
+                "num_processors must be positive".into(),
+            ));
         }
         let n = lengths.len();
+        let total_length = lengths
+            .iter()
+            .try_fold(0_i64, |total, &length| total.checked_add(length))
+            .ok_or_else(|| ConstructionError::IntegerOverflow("summing task lengths".into()))?;
+        let horizon = usize::try_from(total_length).map_err(|_| {
+            ConstructionError::IntegerOverflow("task horizon does not fit usize".into())
+        })?;
+        n.checked_mul(horizon).ok_or_else(|| {
+            ConstructionError::IntegerOverflow("configuration size does not fit usize".into())
+        })?;
         for &(pred, succ) in precedences {
             if pred >= n || succ >= n {
-                return Err(format!(
+                return Err(ConstructionError::Conversion(format!(
                     "precedence index out of range: ({pred}, {succ}) but num_tasks = {n}"
-                ));
+                )));
             }
         }
         Ok(())
@@ -105,22 +135,17 @@ impl PreemptiveScheduling {
     /// * `num_processors` - Number of identical processors `m` (must be positive)
     /// * `precedences` - Pairs `(pred, succ)`: task `pred` must finish before task `succ` starts
     ///
-    /// # Panics
-    ///
-    /// Panics if any length is zero, `num_processors` is zero, or any precedence
-    /// index is out of range.
     pub fn new(
-        lengths: Vec<usize>,
+        lengths: Vec<i64>,
         num_processors: usize,
         precedences: Vec<(usize, usize)>,
-    ) -> Self {
-        Self::validate(&lengths, num_processors, &precedences)
-            .unwrap_or_else(|err| panic!("{err}"));
-        Self {
+    ) -> Result<Self, ConstructionError> {
+        Self::validate(&lengths, num_processors, &precedences)?;
+        Ok(Self {
             lengths,
             num_processors,
             precedences,
-        }
+        })
     }
 
     /// Get the number of tasks.
@@ -139,7 +164,7 @@ impl PreemptiveScheduling {
     }
 
     /// Get the processing lengths.
-    pub fn lengths(&self) -> &[usize] {
+    pub fn lengths(&self) -> &[i64] {
         &self.lengths
     }
 
@@ -150,20 +175,20 @@ impl PreemptiveScheduling {
 
     /// Compute `D_max = sum of all task lengths` (worst-case makespan).
     pub fn d_max(&self) -> usize {
-        self.lengths.iter().sum()
+        let total = self
+            .lengths
+            .iter()
+            .try_fold(0_i64, |total, &length| total.checked_add(length))
+            .expect("construction validates the task horizon");
+        usize::try_from(total).expect("validated task horizon fits usize")
     }
 }
 
 impl TryFrom<PreemptiveSchedulingSerde> for PreemptiveScheduling {
-    type Error = String;
+    type Error = ConstructionError;
 
     fn try_from(value: PreemptiveSchedulingSerde) -> Result<Self, Self::Error> {
-        Self::validate(&value.lengths, value.num_processors, &value.precedences)?;
-        Ok(Self {
-            lengths: value.lengths,
-            num_processors: value.num_processors,
-            precedences: value.precedences,
-        })
+        Self::new(value.lengths, value.num_processors, value.precedences)
     }
 }
 
@@ -179,72 +204,89 @@ impl<'de> Deserialize<'de> for PreemptiveScheduling {
 
 impl Problem for PreemptiveScheduling {
     const NAME: &'static str = "PreemptiveScheduling";
-    type Value = Min<usize>;
+    type Solution = Vec<Vec<bool>>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("d_max", d_max),
+        ("num_precedences", num_precedences),
+        ("num_processors", num_processors),
+        ("num_tasks", num_tasks),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        let d = self.d_max();
-        vec![2; self.num_tasks() * d]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.num_tasks();
         let d = self.d_max();
-
-        // Check config length
-        if config.len() != n * d {
-            return Min(None);
-        }
-
-        // Check each slot is binary
-        if config.iter().any(|&v| v > 1) {
-            return Min(None);
+        if solution.len() != n || solution.iter().any(|task| task.len() != d) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "preemptive schedule dimensions do not match the instance".into(),
+            ));
         }
-
-        // Check each task t is active in exactly l(t) slots
-        for t in 0..n {
-            let active: usize = config[t * d..(t + 1) * d].iter().sum();
-            if active != self.lengths[t] {
-                return Min(None);
+        Ok({
+            // Check each task t is active in exactly l(t) slots
+            for (task, &length) in solution.iter().zip(&self.lengths) {
+                let active = task.iter().filter(|&&active| active).count();
+                if i64::try_from(active).expect("active slots fit the validated horizon") != length
+                {
+                    return Ok(Min(None));
+                }
             }
-        }
 
-        // Check processor capacity at each time slot
-        for u in 0..d {
-            let active_count: usize = (0..n).filter(|&t| config[t * d + u] == 1).count();
-            if active_count > self.num_processors {
-                return Min(None);
+            // Check processor capacity at each time slot
+            for u in 0..d {
+                let active_count = solution.iter().filter(|task| task[u]).count();
+                if active_count > self.num_processors {
+                    return Ok(Min(None));
+                }
             }
-        }
 
-        // Check precedence constraints:
-        // last active slot of pred < first active slot of succ
-        for &(pred, succ) in &self.precedences {
-            let last_pred = (0..d).rev().find(|&u| config[pred * d + u] == 1);
-            let first_succ = (0..d).find(|&u| config[succ * d + u] == 1);
-            if let (Some(lp), Some(fs)) = (last_pred, first_succ) {
-                if lp >= fs {
-                    return Min(None);
+            // Check precedence constraints:
+            // last active slot of pred < first active slot of succ
+            for &(pred, succ) in &self.precedences {
+                let last_pred = (0..d).rev().find(|&u| solution[pred][u]);
+                let first_succ = (0..d).find(|&u| solution[succ][u]);
+                if let (Some(lp), Some(fs)) = (last_pred, first_succ) {
+                    if lp >= fs {
+                        return Ok(Min(None));
+                    }
                 }
             }
-        }
 
-        // Compute makespan: max over all t of (last active slot + 1)
-        let makespan = (0..n)
-            .filter_map(|t| (0..d).rev().find(|&u| config[t * d + u] == 1))
-            .map(|last| last + 1)
-            .max()
-            .unwrap_or(0);
+            // Compute makespan: max over all t of (last active slot + 1)
+            let makespan = solution
+                .iter()
+                .filter_map(|task| (0..d).rev().find(|&u| task[u]))
+                .map(|last| last + 1)
+                .max()
+                .unwrap_or(0);
 
-        Min(Some(makespan))
+            Min(Some(
+                i64::try_from(makespan).expect("makespan fits the validated horizon"),
+            ))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for PreemptiveScheduling {
+    fn dimensions(&self) -> Vec<usize> {
+        let d = self.d_max();
+        vec![2; self.num_tasks() * d]
     }
 }
 
 crate::declare_variants! {
-    default PreemptiveScheduling => "2^(num_tasks * num_tasks)",
+    default PreemptiveScheduling => "2^(num_tasks * num_tasks)" create PreemptiveSchedulingCreateSpec,
+}
+
+crate::register_brute_force! {
+    PreemptiveScheduling decode |problem: &PreemptiveScheduling, indices: Vec<usize>| if problem.d_max() == 0 { vec![Vec::new(); problem.num_tasks()] } else { indices.chunks(problem.d_max()).map(crate::config::config_to_bits).collect() },
 }
 
 #[cfg(feature = "example-db")]
@@ -263,29 +305,22 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     //   t2 (18..27):[0,0,1,1,1,0,0,0,0]
     //   t3 (27..36):[0,0,1,1,0,0,0,0,0]
     //   t4 (36..45):[0,1,0,0,0,0,0,0,0]
-    let mut config = vec![0usize; 5 * 9];
-    // t0 (config[0..9]) at slots 0,1
-    config[0] = 1;
-    config[1] = 1;
-    // t1 (config[9..18]) at slot 0
-    config[9] = 1;
-    // t2 (config[18..27]) at slots 2,3,4
-    config[18 + 2] = 1;
-    config[18 + 3] = 1;
-    config[18 + 4] = 1;
-    // t3 (config[27..36]) at slots 2,3
-    config[27 + 2] = 1;
-    config[27 + 3] = 1;
-    // t4 (config[36..45]) at slot 1
-    config[36 + 1] = 1;
+    let mut config = vec![vec![false; 9]; 5];
+    config[0][0] = true;
+    config[0][1] = true;
+    config[1][0] = true;
+    config[2][2] = true;
+    config[2][3] = true;
+    config[2][4] = true;
+    config[3][2] = true;
+    config[3][3] = true;
+    config[4][1] = true;
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "preemptive_scheduling",
-        instance: Box::new(PreemptiveScheduling::new(
-            vec![2, 1, 3, 2, 1],
-            2,
-            vec![(0, 2), (1, 3)],
-        )),
-        optimal_config: config,
+        instance: Box::new(
+            PreemptiveScheduling::new(vec![2, 1, 3, 2, 1], 2, vec![(0, 2), (1, 3)]).unwrap(),
+        ),
+        optimal_config: serde_json::json!(config),
         optimal_value: serde_json::json!(5),
     }]
 }
diff --git a/src/models/misc/production_planning.rs b/src/models/misc/production_planning.rs
index 914df0d3b..58e0449cc 100644
--- a/src/models/misc/production_planning.rs
+++ b/src/models/misc/production_planning.rs
@@ -5,7 +5,7 @@
 //! exists a feasible production plan that satisfies all demand without
 //! backlogging and stays within budget.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::{Deserialize, Serialize};
@@ -16,17 +16,10 @@ inventory::submit! {
         display_name: "Production Planning",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine whether a multi-period production plan can satisfy all demand within a cost bound",
-        fields: &[
-            FieldInfo { name: "num_periods", type_name: "usize", description: "Number of planning periods n" },
-            FieldInfo { name: "demands", type_name: "Vec<u64>", description: "Demand r_i for each period" },
-            FieldInfo { name: "capacities", type_name: "Vec<u64>", description: "Production capacity c_i for each period" },
-            FieldInfo { name: "setup_costs", type_name: "Vec<u64>", description: "Setup cost b_i incurred when x_i > 0" },
-            FieldInfo { name: "production_costs", type_name: "Vec<u64>", description: "Per-unit production cost coefficient p_i" },
-            FieldInfo { name: "inventory_costs", type_name: "Vec<u64>", description: "Per-unit inventory cost coefficient h_i" },
-            FieldInfo { name: "cost_bound", type_name: "u64", description: "Total cost bound B" },
-        ],
+        fields: ProductionPlanningCreateSpec::FIELDS,
     }
 }
 
@@ -34,23 +27,79 @@ inventory::submit! {
 pub struct ProductionPlanning {
     #[serde(deserialize_with = "positive_usize::deserialize")]
     num_periods: usize,
-    demands: Vec<u64>,
-    capacities: Vec<u64>,
-    setup_costs: Vec<u64>,
-    production_costs: Vec<u64>,
-    inventory_costs: Vec<u64>,
-    cost_bound: u64,
+    demands: Vec<i64>,
+    capacities: Vec<i64>,
+    setup_costs: Vec<i64>,
+    production_costs: Vec<i64>,
+    inventory_costs: Vec<i64>,
+    cost_bound: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct ProductionPlanningCreateSpec {
+    /// Number of planning periods.
+    num_periods: usize,
+    /// Demand per period.
+    demands: Vec<i64>,
+    /// Production capacity per period.
+    capacities: Vec<i64>,
+    /// Setup cost per period.
+    setup_costs: Vec<i64>,
+    /// Per-unit production cost per period.
+    production_costs: Vec<i64>,
+    /// Per-unit inventory cost per period.
+    inventory_costs: Vec<i64>,
+    /// Total cost bound.
+    cost_bound: i64,
+}
+impl TryFrom<ProductionPlanningCreateSpec> for ProductionPlanning {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: ProductionPlanningCreateSpec) -> Result<Self, Self::Error> {
+        if spec.num_periods == 0 {
+            return Err("num_periods must be positive".to_string().into());
+        }
+        for (name, len) in [
+            ("demands", spec.demands.len()),
+            ("capacities", spec.capacities.len()),
+            ("setup_costs", spec.setup_costs.len()),
+            ("production_costs", spec.production_costs.len()),
+            ("inventory_costs", spec.inventory_costs.len()),
+        ] {
+            if len != spec.num_periods {
+                return Err(
+                    format!("{name} has {len} entries, expected {}", spec.num_periods).into(),
+                );
+            }
+        }
+        if spec.capacities.iter().any(|&capacity| {
+            usize::try_from(capacity)
+                .ok()
+                .and_then(|v| v.checked_add(1))
+                .is_none()
+        }) {
+            return Err("capacities must fit in usize for dims()".to_string().into());
+        }
+        Ok(Self::new(
+            spec.num_periods,
+            spec.demands,
+            spec.capacities,
+            spec.setup_costs,
+            spec.production_costs,
+            spec.inventory_costs,
+            spec.cost_bound,
+        ))
+    }
 }
 
 impl ProductionPlanning {
     pub fn new(
         num_periods: usize,
-        demands: Vec<u64>,
-        capacities: Vec<u64>,
-        setup_costs: Vec<u64>,
-        production_costs: Vec<u64>,
-        inventory_costs: Vec<u64>,
-        cost_bound: u64,
+        demands: Vec<i64>,
+        capacities: Vec<i64>,
+        setup_costs: Vec<i64>,
+        production_costs: Vec<i64>,
+        inventory_costs: Vec<i64>,
+        cost_bound: i64,
     ) -> Self {
         assert!(num_periods > 0, "num_periods must be positive");
         for len in [
@@ -74,6 +123,17 @@ impl ProductionPlanning {
             }),
             "capacities must fit in usize for dims()"
         );
+        assert!(
+            demands
+                .iter()
+                .chain(&capacities)
+                .chain(&setup_costs)
+                .chain(&production_costs)
+                .chain(&inventory_costs)
+                .all(|&value| value >= 0),
+            "demands, capacities, and costs must be nonnegative"
+        );
+        assert!(cost_bound >= 0, "cost bound must be nonnegative");
 
         Self {
             num_periods,
@@ -90,92 +150,136 @@ impl ProductionPlanning {
         self.num_periods
     }
 
-    pub fn demands(&self) -> &[u64] {
+    pub fn demands(&self) -> &[i64] {
         &self.demands
     }
 
-    pub fn capacities(&self) -> &[u64] {
+    pub fn capacities(&self) -> &[i64] {
         &self.capacities
     }
 
-    pub fn setup_costs(&self) -> &[u64] {
+    pub fn setup_costs(&self) -> &[i64] {
         &self.setup_costs
     }
 
-    pub fn production_costs(&self) -> &[u64] {
+    pub fn production_costs(&self) -> &[i64] {
         &self.production_costs
     }
 
-    pub fn inventory_costs(&self) -> &[u64] {
+    pub fn inventory_costs(&self) -> &[i64] {
         &self.inventory_costs
     }
 
-    pub fn cost_bound(&self) -> u64 {
+    pub fn cost_bound(&self) -> i64 {
         self.cost_bound
     }
 
-    pub fn max_capacity(&self) -> u64 {
+    pub fn max_capacity(&self) -> i64 {
         self.capacities.iter().copied().max().unwrap_or(0)
     }
 }
 
 impl Problem for ProductionPlanning {
     const NAME: &'static str = "ProductionPlanning";
+    type Solution = Vec<usize>;
     type Value = Or;
 
-    fn dims(&self) -> Vec<usize> {
-        self.capacities
-            .iter()
-            .map(|&capacity| {
-                usize::try_from(capacity)
-                    .ok()
-                    .and_then(|value| value.checked_add(1))
-                    .expect("capacities validated in constructor")
-            })
-            .collect()
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or({
-            if config.len() != self.num_periods {
-                return Or(false);
-            }
+    crate::problem_parameters![("max_capacity", max_capacity), ("num_periods", num_periods),];
 
-            let mut cumulative_production = 0u128;
-            let mut cumulative_demand = 0u128;
-            let mut total_cost = 0u128;
-            let cost_bound = self.cost_bound as u128;
-
-            for (i, &production) in config.iter().enumerate() {
-                let capacity = match usize::try_from(self.capacities[i]) {
-                    Ok(value) => value,
-                    Err(_) => return Or(false),
-                };
-                if production > capacity {
-                    return Or(false);
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        Ok({
+            Or({
+                if config.len() != self.num_periods {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "production-plan length does not match the periods".into(),
+                    ));
                 }
 
-                let production = production as u128;
-                cumulative_production += production;
-                cumulative_demand += self.demands[i] as u128;
+                let mut cumulative_production = 0_i64;
+                let mut cumulative_demand = 0_i64;
+                let mut total_cost = 0_i64;
 
-                if cumulative_production < cumulative_demand {
-                    return Or(false);
-                }
+                for (i, &production) in config.iter().enumerate() {
+                    let capacity = match usize::try_from(self.capacities[i]) {
+                        Ok(value) => value,
+                        Err(_) => return Ok(Or(false)),
+                    };
+                    if production > capacity {
+                        return Ok(Or(false));
+                    }
 
-                let inventory = cumulative_production - cumulative_demand;
-                total_cost += self.production_costs[i] as u128 * production;
-                total_cost += self.inventory_costs[i] as u128 * inventory;
-                if production > 0 {
-                    total_cost += self.setup_costs[i] as u128;
-                }
+                    let production = i64::try_from(production).map_err(|_| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "converting production quantity to i64".into(),
+                        )
+                    })?;
+                    cumulative_production = cumulative_production
+                        .checked_add(production)
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "summing cumulative production".to_string(),
+                            )
+                        })?;
+                    cumulative_demand =
+                        cumulative_demand
+                            .checked_add(self.demands[i])
+                            .ok_or_else(|| {
+                                crate::traits::EvaluationError::IntegerOverflow(
+                                    "summing cumulative demand".to_string(),
+                                )
+                            })?;
+
+                    if cumulative_production < cumulative_demand {
+                        return Ok(Or(false));
+                    }
+
+                    let inventory = cumulative_production
+                        .checked_sub(cumulative_demand)
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "computing production inventory".into(),
+                            )
+                        })?;
+                    let production_cost = self.production_costs[i]
+                        .checked_mul(production)
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "multiplying production cost".to_string(),
+                            )
+                        })?;
+                    total_cost = total_cost.checked_add(production_cost).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing production-planning costs".to_string(),
+                        )
+                    })?;
+                    let inventory_cost = self.inventory_costs[i]
+                        .checked_mul(inventory)
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "multiplying inventory cost".to_string(),
+                            )
+                        })?;
+                    total_cost = total_cost.checked_add(inventory_cost).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing production-planning costs".to_string(),
+                        )
+                    })?;
+                    if production > 0 {
+                        total_cost =
+                            total_cost.checked_add(self.setup_costs[i]).ok_or_else(|| {
+                                crate::traits::EvaluationError::IntegerOverflow(
+                                    "adding production setup cost".to_string(),
+                                )
+                            })?;
+                    }
 
-                if total_cost > cost_bound {
-                    return Or(false);
+                    if total_cost > self.cost_bound {
+                        return Ok(Or(false));
+                    }
                 }
-            }
 
-            total_cost <= cost_bound
+                total_cost <= self.cost_bound
+            })
         })
     }
 
@@ -184,8 +288,26 @@ impl Problem for ProductionPlanning {
     }
 }
 
+impl crate::solvers::BruteForceProblem for ProductionPlanning {
+    fn dimensions(&self) -> Vec<usize> {
+        self.capacities
+            .iter()
+            .map(|&capacity| {
+                usize::try_from(capacity)
+                    .ok()
+                    .and_then(|value| value.checked_add(1))
+                    .expect("capacities validated in constructor")
+            })
+            .collect()
+    }
+}
+
 crate::declare_variants! {
-    default ProductionPlanning => "(max_capacity + 1)^num_periods",
+    default ProductionPlanning => "(max_capacity + 1)^num_periods" create ProductionPlanningCreateSpec,
+}
+
+crate::register_brute_force! {
+    ProductionPlanning,
 }
 
 #[cfg(feature = "example-db")]
@@ -201,7 +323,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![1, 1, 1, 1],
             16,
         )),
-        optimal_config: vec![3, 0, 4, 1],
+        optimal_config: serde_json::json!(vec![3, 0, 4, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/rectilinear_picture_compression.rs b/src/models/misc/rectilinear_picture_compression.rs
index 13243e40d..cd399f591 100644
--- a/src/models/misc/rectilinear_picture_compression.rs
+++ b/src/models/misc/rectilinear_picture_compression.rs
@@ -19,6 +19,7 @@ inventory::submit! {
         display_name: "Rectilinear Picture Compression",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Cover all 1-entries of a binary matrix with at most K axis-aligned all-1 rectangles",
         fields: &[
@@ -45,7 +46,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::RectilinearPictureCompression;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let matrix = vec![
 ///     vec![true, true, false, false],
@@ -55,7 +56,7 @@ inventory::submit! {
 /// ];
 /// let problem = RectilinearPictureCompression::new(matrix, 2);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize)]
@@ -234,64 +235,81 @@ impl RectilinearPictureCompression {
 
 impl Problem for RectilinearPictureCompression {
     const NAME: &'static str = "RectilinearPictureCompression";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_cols", num_cols), ("num_rows", num_rows),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.maximal_rects.len()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let rects = &self.maximal_rects;
-            if config.len() != rects.len() {
-                return crate::types::Or(false);
-            }
-            if config.iter().any(|&v| v >= 2) {
-                return crate::types::Or(false);
-            }
-
-            // Count selected rectangles.
-            let selected_count: usize = config.iter().sum();
-            if (selected_count as i64) > self.bound {
-                return crate::types::Or(false);
-            }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                let rects = &self.maximal_rects;
+                if config.len() != rects.len() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "rectangle-selection length does not match the maximal rectangles".into(),
+                    ));
+                }
+                // Count selected rectangles.
+                let selected_count = config.iter().filter(|&&selected| selected).count();
+                let selected_count = i64::try_from(selected_count).map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting selected-rectangle count to i64".into(),
+                    )
+                })?;
+                if selected_count > self.bound {
+                    return Ok(crate::types::Or(false));
+                }
 
-            // Check that all 1-entries are covered.
-            let m = self.num_rows();
-            let n = self.num_cols();
-            let mut covered = vec![vec![false; n]; m];
-            for (i, &x) in config.iter().enumerate() {
-                if x == 1 {
-                    let (r1, c1, r2, c2) = rects[i];
-                    for row in &mut covered[r1..=r2] {
-                        for cell in &mut row[c1..=c2] {
-                            *cell = true;
+                // Check that all 1-entries are covered.
+                let m = self.num_rows();
+                let n = self.num_cols();
+                let mut covered = vec![vec![false; n]; m];
+                for (i, &x) in config.iter().enumerate() {
+                    if x {
+                        let (r1, c1, r2, c2) = rects[i];
+                        for row in &mut covered[r1..=r2] {
+                            for cell in &mut row[c1..=c2] {
+                                *cell = true;
+                            }
                         }
                     }
                 }
-            }
 
-            for (row_m, row_c) in self.matrix.iter().zip(covered.iter()) {
-                for (&entry, &cov) in row_m.iter().zip(row_c.iter()) {
-                    if entry && !cov {
-                        return crate::types::Or(false);
+                for (row_m, row_c) in self.matrix.iter().zip(covered.iter()) {
+                    for (&entry, &cov) in row_m.iter().zip(row_c.iter()) {
+                        if entry && !cov {
+                            return Ok(crate::types::Or(false));
+                        }
                     }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for RectilinearPictureCompression {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.maximal_rects.len()]
+    }
+}
+
 crate::declare_variants! {
     default RectilinearPictureCompression => "2^(num_rows * num_cols)",
 }
 
+crate::register_brute_force! {
+    RectilinearPictureCompression decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -308,7 +326,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             ],
             2,
         )),
-        optimal_config: vec![1, 1],
+        optimal_config: serde_json::json!(vec![true, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/register_sufficiency.rs b/src/models/misc/register_sufficiency.rs
index 3530cddeb..ebf2972f7 100644
--- a/src/models/misc/register_sufficiency.rs
+++ b/src/models/misc/register_sufficiency.rs
@@ -14,6 +14,7 @@ inventory::submit! {
         display_name: "Register Sufficiency",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine whether a DAG computation can be performed using K or fewer registers",
         fields: &[
@@ -42,7 +43,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::RegisterSufficiency;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 4 vertices: v2 depends on v0, v3 depends on v0 and v1
 /// let problem = RegisterSufficiency::new(
@@ -51,7 +52,7 @@ inventory::submit! {
 ///     2,
 /// );
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -121,10 +122,13 @@ impl RegisterSufficiency {
     /// Simulate register usage for a given evaluation ordering and return the
     /// maximum number of registers used, or `None` if the ordering is invalid
     /// (not a permutation or violates dependencies).
-    pub fn simulate_registers(&self, config: &[usize]) -> Option<usize> {
+    pub fn simulate_registers(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         let n = self.num_vertices;
         if config.len() != n {
-            return None;
+            return Ok(None);
         }
 
         // Check valid permutation: each position 0..n-1 used exactly once
@@ -132,10 +136,10 @@ impl RegisterSufficiency {
         let mut used = vec![false; n];
         for (vertex, &position) in config.iter().enumerate() {
             if position >= n {
-                return None;
+                return Ok(None);
             }
             if used[position] {
-                return None;
+                return Ok(None);
             }
             used[position] = true;
             order[position] = vertex;
@@ -179,7 +183,7 @@ impl RegisterSufficiency {
             for &dep in &dependencies[vertex] {
                 if config[dep] >= step {
                     // Dependency not yet evaluated
-                    return None;
+                    return Ok(None);
                 }
             }
 
@@ -198,7 +202,11 @@ impl RegisterSufficiency {
             max_registers = max_registers.max(reg_count);
         }
 
-        Some(max_registers)
+        Ok(Some(i64::try_from(max_registers).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting register-usage count to i64".into(),
+            )
+        })?))
     }
 
     /// Exact branch-and-bound solver: finds a topological ordering using at
@@ -342,21 +350,49 @@ impl BnBState {
 
 impl Problem for RegisterSufficiency {
     const NAME: &'static str = "RegisterSufficiency";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("bound", bound),
+        ("num_arcs", num_arcs),
+        ("num_sinks", num_sinks),
+        ("num_vertices", num_vertices),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_vertices; self.num_vertices]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_vertices {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "evaluation ordering length does not match the graph vertices".into(),
+            ));
+        }
+        if config.iter().any(|&position| position >= self.num_vertices) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "evaluation ordering contains an out-of-range position".into(),
+            ));
+        }
+        let bound = i64::try_from(self.bound).map_err(|_| {
+            crate::traits::EvaluationError::IntegerOverflow(
+                "converting register bound to i64".into(),
+            )
+        })?;
+        Ok(crate::types::Or(
+            self.simulate_registers(config)?
+                .is_some_and(|max_reg| max_reg <= bound),
+        ))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(
-            self.simulate_registers(config)
-                .is_some_and(|max_reg| max_reg <= self.bound),
-        )
+impl crate::solvers::BruteForceProblem for RegisterSufficiency {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_vertices; self.num_vertices]
     }
 }
 
@@ -364,6 +400,10 @@ crate::declare_variants! {
     default RegisterSufficiency => "num_vertices ^ 2 * 2 ^ num_vertices",
 }
 
+crate::register_brute_force! {
+    RegisterSufficiency,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -387,7 +427,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         )),
         // Order: v1,v2,v3,v4,v6,v5,v7 (1-indexed) = v0,v1,v2,v3,v5,v4,v6 (0-indexed)
         // Positions: v0->0, v1->1, v2->2, v3->3, v4->5, v5->4, v6->6
-        optimal_config: vec![0, 1, 2, 3, 5, 4, 6],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 3, 5, 4, 6]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/resource_constrained_scheduling.rs b/src/models/misc/resource_constrained_scheduling.rs
index 4a714371f..c43d4bdca 100644
--- a/src/models/misc/resource_constrained_scheduling.rs
+++ b/src/models/misc/resource_constrained_scheduling.rs
@@ -4,7 +4,7 @@
 //! unit-length tasks must be assigned to identical processors under both a
 //! processor capacity limit and resource usage constraints per time slot.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{ConstructionError, FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,13 +14,14 @@ inventory::submit! {
         display_name: "Resource Constrained Scheduling",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Schedule unit-length tasks on m processors with resource constraints and a deadline",
         fields: &[
             FieldInfo { name: "num_processors", type_name: "usize", description: "Number of identical processors m" },
-            FieldInfo { name: "resource_bounds", type_name: "Vec<u64>", description: "Resource bound B_i for each resource i" },
-            FieldInfo { name: "resource_requirements", type_name: "Vec<Vec<u64>>", description: "R_i(t) for each task t and resource i (n x r matrix)" },
-            FieldInfo { name: "deadline", type_name: "u64", description: "Overall deadline D" },
+            FieldInfo { name: "resource_bounds", type_name: "Vec<i64>", description: "Resource bound B_i for each resource i" },
+            FieldInfo { name: "resource_requirements", type_name: "Vec<Vec<i64>>", description: "R_i(t) for each task t and resource i (n x r matrix)" },
+            FieldInfo { name: "deadline", type_name: "i64", description: "Overall deadline D" },
         ],
     }
 }
@@ -43,7 +44,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::ResourceConstrainedScheduling;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 6 tasks, 3 processors, 1 resource with bound 20, deadline 2
 /// let problem = ResourceConstrainedScheduling::new(
@@ -51,21 +52,21 @@ inventory::submit! {
 ///     vec![20],
 ///     vec![vec![6], vec![7], vec![7], vec![6], vec![8], vec![6]],
 ///     2,
-/// );
+/// ).unwrap();
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct ResourceConstrainedScheduling {
     /// Number of identical processors.
     num_processors: usize,
     /// Resource bounds B_i for each resource.
-    resource_bounds: Vec<u64>,
+    resource_bounds: Vec<i64>,
     /// Resource requirements R_i(t) for each task t and resource i (n x r matrix).
-    resource_requirements: Vec<Vec<u64>>,
+    resource_requirements: Vec<Vec<i64>>,
     /// Overall deadline D.
-    deadline: u64,
+    deadline: i64,
 }
 
 impl ResourceConstrainedScheduling {
@@ -78,26 +79,43 @@ impl ResourceConstrainedScheduling {
     /// * `deadline` - Overall deadline `D`
     pub fn new(
         num_processors: usize,
-        resource_bounds: Vec<u64>,
-        resource_requirements: Vec<Vec<u64>>,
-        deadline: u64,
-    ) -> Self {
-        assert!(deadline > 0, "deadline must be positive");
+        resource_bounds: Vec<i64>,
+        resource_requirements: Vec<Vec<i64>>,
+        deadline: i64,
+    ) -> Result<Self, ConstructionError> {
+        if deadline <= 0 {
+            return Err(ConstructionError::Conversion(
+                "deadline must be positive".into(),
+            ));
+        }
+        usize::try_from(deadline).map_err(|_| {
+            ConstructionError::IntegerOverflow("deadline does not fit usize".into())
+        })?;
+        if resource_bounds.iter().any(|&bound| bound < 0) {
+            return Err(ConstructionError::Conversion(
+                "resource bounds must be nonnegative".into(),
+            ));
+        }
         let r = resource_bounds.len();
         for (t, row) in resource_requirements.iter().enumerate() {
-            assert_eq!(
-                row.len(),
-                r,
-                "task {t} has {} resource requirements, expected {r}",
-                row.len()
-            );
+            if row.len() != r {
+                return Err(ConstructionError::Conversion(format!(
+                    "task {t} has {} resource requirements, expected {r}",
+                    row.len()
+                )));
+            }
+            if row.iter().any(|&requirement| requirement < 0) {
+                return Err(ConstructionError::Conversion(format!(
+                    "task {t} resource requirements must be nonnegative"
+                )));
+            }
         }
-        Self {
+        Ok(Self {
             num_processors,
             resource_bounds,
             resource_requirements,
             deadline,
-        }
+        })
     }
 
     /// Get the number of tasks.
@@ -111,17 +129,17 @@ impl ResourceConstrainedScheduling {
     }
 
     /// Get the resource bounds.
-    pub fn resource_bounds(&self) -> &[u64] {
+    pub fn resource_bounds(&self) -> &[i64] {
         &self.resource_bounds
     }
 
     /// Get the resource requirements matrix.
-    pub fn resource_requirements(&self) -> &[Vec<u64>] {
+    pub fn resource_requirements(&self) -> &[Vec<i64>] {
         &self.resource_requirements
     }
 
     /// Get the deadline.
-    pub fn deadline(&self) -> u64 {
+    pub fn deadline(&self) -> i64 {
         self.deadline
     }
 
@@ -131,87 +149,139 @@ impl ResourceConstrainedScheduling {
     }
 }
 
+impl<'de> Deserialize<'de> for ResourceConstrainedScheduling {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Raw {
+            num_processors: usize,
+            resource_bounds: Vec<i64>,
+            resource_requirements: Vec<Vec<i64>>,
+            deadline: i64,
+        }
+
+        let raw = Raw::deserialize(deserializer)?;
+        Self::new(
+            raw.num_processors,
+            raw.resource_bounds,
+            raw.resource_requirements,
+            raw.deadline,
+        )
+        .map_err(serde::de::Error::custom)
+    }
+}
+
 impl Problem for ResourceConstrainedScheduling {
     const NAME: &'static str = "ResourceConstrainedScheduling";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("deadline", deadline),
+        ("num_resources", num_resources),
+        ("num_tasks", num_tasks),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.deadline as usize; self.num_tasks()]
-    }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                let n = self.num_tasks();
+                let d = self.deadline as usize;
+                let r = self.num_resources();
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let n = self.num_tasks();
-            let d = self.deadline as usize;
-            let r = self.num_resources();
+                // Check config length
+                if config.len() != n {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "schedule length does not match the tasks".into(),
+                    ));
+                }
 
-            // Check config length
-            if config.len() != n {
-                return crate::types::Or(false);
-            }
+                if config.iter().any(|&start| start >= d) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "schedule contains an out-of-range start time".into(),
+                    ));
+                }
 
-            // Check all time slots are in range
-            if config.iter().any(|&slot| slot >= d) {
-                return crate::types::Or(false);
-            }
+                // Check processor capacity and resource constraints at each time slot
+                for u in 0..d {
+                    // Collect tasks scheduled at time slot u
+                    let mut task_count = 0usize;
+                    let mut resource_usage = vec![0i64; r];
 
-            // Check processor capacity and resource constraints at each time slot
-            for u in 0..d {
-                // Collect tasks scheduled at time slot u
-                let mut task_count = 0usize;
-                let mut resource_usage = vec![0u64; r];
-
-                for (t, &slot) in config.iter().enumerate() {
-                    if slot == u {
-                        task_count += 1;
-                        // Accumulate resource usage
-                        for (usage, &req) in resource_usage
-                            .iter_mut()
-                            .zip(self.resource_requirements[t].iter())
-                        {
-                            *usage = usage.saturating_add(req);
+                    for (t, &slot) in config.iter().enumerate() {
+                        if slot == u {
+                            task_count += 1;
+                            // Accumulate resource usage
+                            for (usage, &req) in resource_usage
+                                .iter_mut()
+                                .zip(self.resource_requirements[t].iter())
+                            {
+                                *usage = usage.checked_add(req).ok_or_else(|| {
+                                    crate::traits::EvaluationError::IntegerOverflow(
+                                        "summing scheduled resource usage".to_string(),
+                                    )
+                                })?;
+                            }
                         }
                     }
-                }
 
-                // Check processor capacity
-                if task_count > self.num_processors {
-                    return crate::types::Or(false);
-                }
+                    // Check processor capacity
+                    if task_count > self.num_processors {
+                        return Ok(crate::types::Or(false));
+                    }
 
-                // Check resource bounds
-                for (usage, bound) in resource_usage.iter().zip(self.resource_bounds.iter()) {
-                    if usage > bound {
-                        return crate::types::Or(false);
+                    // Check resource bounds
+                    for (usage, bound) in resource_usage.iter().zip(self.resource_bounds.iter()) {
+                        if usage > bound {
+                            return Ok(crate::types::Or(false));
+                        }
                     }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for ResourceConstrainedScheduling {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.deadline as usize; self.num_tasks()]
+    }
+}
+
 crate::declare_variants! {
     default ResourceConstrainedScheduling => "deadline ^ num_tasks",
 }
 
+crate::register_brute_force! {
+    ResourceConstrainedScheduling,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "resource_constrained_scheduling",
         // 6 tasks, 3 processors, 1 resource B_1=20, deadline 2
-        instance: Box::new(ResourceConstrainedScheduling::new(
-            3,
-            vec![20],
-            vec![vec![6], vec![7], vec![7], vec![6], vec![8], vec![6]],
-            2,
-        )),
-        optimal_config: vec![0, 0, 0, 1, 1, 1],
+        instance: Box::new(
+            ResourceConstrainedScheduling::new(
+                3,
+                vec![20],
+                vec![vec![6], vec![7], vec![7], vec![6], vec![8], vec![6]],
+                2,
+            )
+            .expect("canonical resource-constrained-scheduling instance must be valid"),
+        ),
+        optimal_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/scheduling_to_minimize_weighted_completion_time.rs b/src/models/misc/scheduling_to_minimize_weighted_completion_time.rs
index 15c6d1895..68459fc3f 100644
--- a/src/models/misc/scheduling_to_minimize_weighted_completion_time.rs
+++ b/src/models/misc/scheduling_to_minimize_weighted_completion_time.rs
@@ -6,7 +6,7 @@
 //! completion time. Within each processor, tasks are ordered by Smith's
 //! rule (non-decreasing length-to-weight ratio).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -17,13 +17,10 @@ inventory::submit! {
         display_name: "Scheduling to Minimize Weighted Completion Time",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Assign tasks to processors to minimize total weighted completion time (Smith's rule ordering)",
-        fields: &[
-            FieldInfo { name: "lengths", type_name: "Vec<u64>", description: "Processing time l(t) for each task" },
-            FieldInfo { name: "weights", type_name: "Vec<u64>", description: "Weight w(t) for each task" },
-            FieldInfo { name: "num_processors", type_name: "usize", description: "Number of identical processors m" },
-        ],
+        fields: SchedulingToMinimizeWeightedCompletionTimeCreateSpec::FIELDS,
     }
 }
 
@@ -46,7 +43,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::SchedulingToMinimizeWeightedCompletionTime;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 /// use problemreductions::types::Min;
 ///
 /// // 5 tasks, 2 processors
@@ -54,41 +51,78 @@ inventory::submit! {
 ///     vec![1, 2, 3, 4, 5], vec![6, 4, 3, 2, 1], 2,
 /// );
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem).unwrap();
-/// assert_eq!(problem.evaluate(&witness), Min(Some(47)));
+/// let witness = solver.solve(&problem).unwrap().unwrap();
+/// assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(47)));
 /// ```
 #[derive(Debug, Clone, Serialize)]
 pub struct SchedulingToMinimizeWeightedCompletionTime {
-    lengths: Vec<u64>,
-    weights: Vec<u64>,
+    lengths: Vec<i64>,
+    weights: Vec<i64>,
     #[serde(serialize_with = "serialize_num_processors")]
     num_processors: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SchedulingToMinimizeWeightedCompletionTimeCreateSpec {
+    /// Processing time for each task.
+    lengths: Vec<i64>,
+    /// Task weights; defaults to one per task.
+    weights: Option<Vec<i64>>,
+    /// Number of identical processors.
+    num_processors: usize,
+}
+impl TryFrom<SchedulingToMinimizeWeightedCompletionTimeCreateSpec>
+    for SchedulingToMinimizeWeightedCompletionTime
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(
+        spec: SchedulingToMinimizeWeightedCompletionTimeCreateSpec,
+    ) -> Result<Self, Self::Error> {
+        if spec.num_processors == 0 {
+            return Err("num_processors must be positive".to_string().into());
+        }
+        let count = spec.lengths.len();
+        let weights = spec.weights.unwrap_or_else(|| vec![1; count]);
+        if weights.len() != count {
+            return Err("weights length must equal lengths length"
+                .to_string()
+                .into());
+        }
+        Ok(Self::new(spec.lengths, weights, spec.num_processors))
+    }
+}
+
 fn serialize_num_processors<S: serde::Serializer>(v: &usize, s: S) -> Result<S::Ok, S::Error> {
-    s.serialize_u64(*v as u64)
+    let value = i64::try_from(*v).map_err(serde::ser::Error::custom)?;
+    s.serialize_i64(value)
 }
 
 #[derive(Deserialize)]
 struct SchedulingToMinimizeWeightedCompletionTimeSerde {
-    lengths: Vec<u64>,
-    weights: Vec<u64>,
+    lengths: Vec<i64>,
+    weights: Vec<i64>,
     num_processors: usize,
 }
 
 impl SchedulingToMinimizeWeightedCompletionTime {
-    fn validate(lengths: &[u64], weights: &[u64], num_processors: usize) -> Result<(), String> {
+    fn validate(
+        lengths: &[i64],
+        weights: &[i64],
+        num_processors: usize,
+    ) -> Result<(), crate::registry::ConstructionError> {
         if lengths.len() != weights.len() {
-            return Err("lengths and weights must have the same length".to_string());
+            return Err("lengths and weights must have the same length"
+                .to_string()
+                .into());
         }
         if num_processors == 0 {
-            return Err("num_processors must be positive".to_string());
+            return Err("num_processors must be positive".to_string().into());
         }
         if lengths.contains(&0) {
-            return Err("task lengths must be positive".to_string());
+            return Err("task lengths must be positive".to_string().into());
         }
         if weights.contains(&0) {
-            return Err("task weights must be positive".to_string());
+            return Err("task weights must be positive".to_string().into());
         }
         Ok(())
     }
@@ -99,7 +133,7 @@ impl SchedulingToMinimizeWeightedCompletionTime {
     ///
     /// Panics if `lengths.len() != weights.len()`, if `num_processors` is zero,
     /// or if any length or weight is zero.
-    pub fn new(lengths: Vec<u64>, weights: Vec<u64>, num_processors: usize) -> Self {
+    pub fn new(lengths: Vec<i64>, weights: Vec<i64>, num_processors: usize) -> Self {
         Self::validate(&lengths, &weights, num_processors).unwrap_or_else(|err| panic!("{err}"));
         Self {
             lengths,
@@ -119,27 +153,30 @@ impl SchedulingToMinimizeWeightedCompletionTime {
     }
 
     /// Returns the processing times.
-    pub fn lengths(&self) -> &[u64] {
+    pub fn lengths(&self) -> &[i64] {
         &self.lengths
     }
 
     /// Returns the task weights.
-    pub fn weights(&self) -> &[u64] {
+    pub fn weights(&self) -> &[i64] {
         &self.weights
     }
 
     /// Compute the total weighted completion time for a given processor
     /// assignment. Tasks on each processor are ordered by Smith's rule
     /// (non-decreasing l(t)/w(t) ratio).
-    fn compute_weighted_completion_time(&self, config: &[usize]) -> Min<u64> {
+    fn compute_weighted_completion_time(
+        &self,
+        config: &[usize],
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.num_tasks();
         let m = self.num_processors;
 
         if config.len() != n {
-            return Min(None);
+            return Ok(Min(None));
         }
         if config.iter().any(|&p| p >= m) {
-            return Min(None);
+            return Ok(Min(None));
         }
 
         // Group task indices by processor
@@ -148,39 +185,68 @@ impl SchedulingToMinimizeWeightedCompletionTime {
             processor_tasks[processor].push(task);
         }
 
-        let mut total_weighted_completion = 0u64;
+        let mut total_weighted_completion = 0i64;
 
         for tasks in &mut processor_tasks {
             // Smith's rule: sort by non-decreasing l(t)/w(t)
             // Equivalent to: l(i)*w(j) <= l(j)*w(i) (avoids floating point)
-            tasks.sort_by(|&a, &b| {
-                let lhs = self.lengths[a] as u128 * self.weights[b] as u128;
-                let rhs = self.lengths[b] as u128 * self.weights[a] as u128;
-                lhs.cmp(&rhs).then(a.cmp(&b))
-            });
+            for index in 1..tasks.len() {
+                let mut position = index;
+                while position > 0 {
+                    let a = tasks[position - 1];
+                    let b = tasks[position];
+                    let lhs = self.lengths[a]
+                        .checked_mul(self.weights[b])
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "comparing weighted-completion task ratios".into(),
+                            )
+                        })?;
+                    let rhs = self.lengths[b]
+                        .checked_mul(self.weights[a])
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "comparing weighted-completion task ratios".into(),
+                            )
+                        })?;
+                    if lhs < rhs || (lhs == rhs && a < b) {
+                        break;
+                    }
+                    tasks.swap(position - 1, position);
+                    position -= 1;
+                }
+            }
 
-            let mut elapsed = 0u64;
+            let mut elapsed = 0i64;
             for &task in tasks.iter() {
-                elapsed = elapsed
-                    .checked_add(self.lengths[task])
-                    .expect("processing time overflowed u64");
-                let contribution = elapsed
-                    .checked_mul(self.weights[task])
-                    .expect("weighted completion time overflowed u64");
+                elapsed = elapsed.checked_add(self.lengths[task]).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing parallel-machine processing times".to_string(),
+                    )
+                })?;
+                let contribution = elapsed.checked_mul(self.weights[task]).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "multiplying task weight by completion time".to_string(),
+                    )
+                })?;
                 total_weighted_completion = total_weighted_completion
                     .checked_add(contribution)
-                    .expect("total weighted completion time overflowed u64");
+                    .ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing weighted completion times".to_string(),
+                        )
+                    })?;
             }
         }
 
-        Min(Some(total_weighted_completion))
+        Ok(Min(Some(total_weighted_completion)))
     }
 }
 
 impl TryFrom<SchedulingToMinimizeWeightedCompletionTimeSerde>
     for SchedulingToMinimizeWeightedCompletionTime
 {
-    type Error = String;
+    type Error = crate::registry::ConstructionError;
 
     fn try_from(
         value: SchedulingToMinimizeWeightedCompletionTimeSerde,
@@ -206,23 +272,48 @@ impl<'de> Deserialize<'de> for SchedulingToMinimizeWeightedCompletionTime {
 
 impl Problem for SchedulingToMinimizeWeightedCompletionTime {
     const NAME: &'static str = "SchedulingToMinimizeWeightedCompletionTime";
-    type Value = Min<u64>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_processors", num_processors), ("num_tasks", num_tasks),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_processors; self.num_tasks()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.num_tasks() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "processor assignment length does not match the tasks".into(),
+            ));
+        }
+        if config
+            .iter()
+            .any(|&processor| processor >= self.num_processors)
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "assignment contains an out-of-range processor".into(),
+            ));
+        }
+        self.compute_weighted_completion_time(config)
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<u64> {
-        self.compute_weighted_completion_time(config)
+impl crate::solvers::BruteForceProblem for SchedulingToMinimizeWeightedCompletionTime {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_processors; self.num_tasks()]
     }
 }
 
 crate::declare_variants! {
-    default SchedulingToMinimizeWeightedCompletionTime => "num_processors^num_tasks",
+    default SchedulingToMinimizeWeightedCompletionTime => "num_processors^num_tasks" create SchedulingToMinimizeWeightedCompletionTimeCreateSpec,
+}
+
+crate::register_brute_force! {
+    SchedulingToMinimizeWeightedCompletionTime,
 }
 
 #[cfg(feature = "example-db")]
@@ -235,7 +326,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             2,
         )),
         // P0={t0,t2,t4}, P1={t1,t3} => config [0, 1, 0, 1, 0]
-        optimal_config: vec![0, 1, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![0, 1, 0, 1, 0]),
         optimal_value: serde_json::json!(47),
     }]
 }
diff --git a/src/models/misc/scheduling_with_individual_deadlines.rs b/src/models/misc/scheduling_with_individual_deadlines.rs
index 391ca772b..6f8b21658 100644
--- a/src/models/misc/scheduling_with_individual_deadlines.rs
+++ b/src/models/misc/scheduling_with_individual_deadlines.rs
@@ -4,7 +4,7 @@
 //! determine whether they can be scheduled on `m` identical processors so that
 //! every task finishes by its own deadline.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
@@ -15,14 +15,10 @@ inventory::submit! {
         display_name: "Scheduling With Individual Deadlines",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine whether unit-length tasks can be scheduled on m processors while meeting individual deadlines",
-        fields: &[
-            FieldInfo { name: "num_tasks", type_name: "usize", description: "Number of tasks |T|" },
-            FieldInfo { name: "num_processors", type_name: "usize", description: "Number of identical processors m" },
-            FieldInfo { name: "deadlines", type_name: "Vec<usize>", description: "Deadline d(t) for each task" },
-            FieldInfo { name: "precedences", type_name: "Vec<(usize, usize)>", description: "Precedence pairs (predecessor, successor)" },
-        ],
+        fields: SchedulingWithIndividualDeadlinesCreateSpec::FIELDS,
     }
 }
 
@@ -36,15 +32,69 @@ inventory::submit! {
 pub struct SchedulingWithIndividualDeadlines {
     num_tasks: usize,
     num_processors: usize,
-    deadlines: Vec<usize>,
+    deadlines: Vec<i64>,
     precedences: Vec<(usize, usize)>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SchedulingWithIndividualDeadlinesCreateSpec {
+    /// Number of tasks.
+    num_tasks: usize,
+    /// Number of identical processors.
+    num_processors: usize,
+    /// Deadline for each task.
+    deadlines: Vec<i64>,
+    /// Precedence pairs.
+    precedences: Option<Vec<(usize, usize)>>,
+}
+impl TryFrom<SchedulingWithIndividualDeadlinesCreateSpec> for SchedulingWithIndividualDeadlines {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: SchedulingWithIndividualDeadlinesCreateSpec) -> Result<Self, Self::Error> {
+        if spec.deadlines.len() != spec.num_tasks {
+            return Err(format!(
+                "deadlines has {} entries, expected {}",
+                spec.deadlines.len(),
+                spec.num_tasks
+            )
+            .into());
+        }
+        if spec.deadlines.iter().any(|&deadline| deadline < 0) {
+            return Err("deadlines must be nonnegative".to_string().into());
+        }
+        if spec
+            .deadlines
+            .iter()
+            .any(|&deadline| usize::try_from(deadline).is_err())
+        {
+            return Err("deadlines must fit usize to define schedule slots"
+                .to_string()
+                .into());
+        }
+        let precedences = spec.precedences.unwrap_or_default();
+        if let Some(&(pred, succ)) = precedences
+            .iter()
+            .find(|&&(p, s)| p >= spec.num_tasks || s >= spec.num_tasks)
+        {
+            return Err(format!(
+                "precedence ({pred}, {succ}) is out of range for {} tasks",
+                spec.num_tasks
+            )
+            .into());
+        }
+        Ok(Self::new(
+            spec.num_tasks,
+            spec.num_processors,
+            spec.deadlines,
+            precedences,
+        ))
+    }
+}
+
 impl SchedulingWithIndividualDeadlines {
     pub fn new(
         num_tasks: usize,
         num_processors: usize,
-        deadlines: Vec<usize>,
+        deadlines: Vec<i64>,
         precedences: Vec<(usize, usize)>,
     ) -> Self {
         assert_eq!(
@@ -52,6 +102,16 @@ impl SchedulingWithIndividualDeadlines {
             num_tasks,
             "deadlines length must equal num_tasks"
         );
+        assert!(
+            deadlines.iter().all(|&deadline| deadline >= 0),
+            "deadlines must be nonnegative"
+        );
+        assert!(
+            deadlines
+                .iter()
+                .all(|&deadline| usize::try_from(deadline).is_ok()),
+            "deadlines must fit usize to define schedule slots"
+        );
         for &(pred, succ) in &precedences {
             assert!(
                 pred < num_tasks,
@@ -83,7 +143,7 @@ impl SchedulingWithIndividualDeadlines {
         self.num_processors
     }
 
-    pub fn deadlines(&self) -> &[usize] {
+    pub fn deadlines(&self) -> &[i64] {
         &self.deadlines
     }
 
@@ -95,57 +155,82 @@ impl SchedulingWithIndividualDeadlines {
         self.precedences.len()
     }
 
-    pub fn max_deadline(&self) -> usize {
+    pub fn max_deadline(&self) -> i64 {
         self.deadlines.iter().copied().max().unwrap_or(0)
     }
 }
 
 impl Problem for SchedulingWithIndividualDeadlines {
     const NAME: &'static str = "SchedulingWithIndividualDeadlines";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("max_deadline", max_deadline),
+        ("num_precedences", num_precedences),
+        ("num_tasks", num_tasks),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        self.deadlines.clone()
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_tasks {
-                return crate::types::Or(false);
-            }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_tasks {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "schedule length does not match the tasks".into(),
+                    ));
+                }
 
-            for (&start, &deadline) in config.iter().zip(&self.deadlines) {
-                if start >= deadline {
-                    return crate::types::Or(false);
+                for (&start, &deadline) in config.iter().zip(&self.deadlines) {
+                    let deadline =
+                        usize::try_from(deadline).expect("validated deadline must fit usize");
+                    if start >= deadline {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
-            }
 
-            for &(pred, succ) in &self.precedences {
-                if config[pred] + 1 > config[succ] {
-                    return crate::types::Or(false);
+                for &(pred, succ) in &self.precedences {
+                    if config[pred] + 1 > config[succ] {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
-            }
-
-            let mut slot_loads = BTreeMap::new();
-            for &start in config {
-                let load = slot_loads.entry(start).or_insert(0usize);
-                *load += 1;
-                if *load > self.num_processors {
-                    return crate::types::Or(false);
+
+                let mut slot_loads = BTreeMap::new();
+                for &start in config {
+                    let load = slot_loads.entry(start).or_insert(0usize);
+                    *load += 1;
+                    if *load > self.num_processors {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for SchedulingWithIndividualDeadlines {
+    fn dimensions(&self) -> Vec<usize> {
+        self.deadlines
+            .iter()
+            .map(|&deadline| usize::try_from(deadline).expect("validated deadline must fit usize"))
+            .collect()
+    }
+}
+
 crate::declare_variants! {
-    default SchedulingWithIndividualDeadlines => "max_deadline^num_tasks",
+    default SchedulingWithIndividualDeadlines => "max_deadline^num_tasks" create SchedulingWithIndividualDeadlinesCreateSpec,
+}
+
+crate::register_brute_force! {
+    SchedulingWithIndividualDeadlines,
 }
 
 #[cfg(feature = "example-db")]
@@ -158,7 +243,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![2, 1, 2, 2, 3, 3, 2],
             vec![(0, 3), (1, 3), (1, 4), (2, 4), (2, 5)],
         )),
-        optimal_config: vec![0, 0, 0, 1, 2, 1, 1],
+        optimal_config: serde_json::json!(vec![0, 0, 0, 1, 2, 1, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/sequencing_to_minimize_maximum_cumulative_cost.rs b/src/models/misc/sequencing_to_minimize_maximum_cumulative_cost.rs
index 46627bfcf..95b9cc819 100644
--- a/src/models/misc/sequencing_to_minimize_maximum_cumulative_cost.rs
+++ b/src/models/misc/sequencing_to_minimize_maximum_cumulative_cost.rs
@@ -4,7 +4,7 @@
 //! a valid one-machine schedule that minimizes the maximum cumulative cost
 //! over all prefixes.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::de::Error as _;
 use serde::{Deserialize, Serialize};
@@ -15,12 +15,10 @@ inventory::submit! {
         display_name: "Sequencing to Minimize Maximum Cumulative Cost",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Schedule tasks with precedence constraints to minimize the maximum cumulative cost prefix",
-        fields: &[
-            FieldInfo { name: "costs", type_name: "Vec<i64>", description: "Task costs in schedule order-independent indexing" },
-            FieldInfo { name: "precedences", type_name: "Vec<(usize, usize)>", description: "Precedence pairs (predecessor, successor)" },
-        ],
+        fields: SequencingCumulativeCostCreateSpec::FIELDS,
     }
 }
 
@@ -40,6 +38,30 @@ pub struct SequencingToMinimizeMaximumCumulativeCost {
     precedences: Vec<(usize, usize)>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SequencingCumulativeCostCreateSpec {
+    /// Task costs.
+    #[create(codec = "comma-separated")]
+    costs: Vec<i64>,
+    /// Precedence arcs; omitted means no constraints.
+    #[create(codec = "arc-list")]
+    precedences: Option<Vec<(usize, usize)>>,
+}
+
+impl TryFrom<SequencingCumulativeCostCreateSpec> for SequencingToMinimizeMaximumCumulativeCost {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: SequencingCumulativeCostCreateSpec) -> Result<Self, Self::Error> {
+        let precedences = spec.precedences.unwrap_or_default();
+        if let Some(message) = precedence_validation_error(&precedences, spec.costs.len()) {
+            return Err(message.into());
+        }
+        Ok(Self {
+            costs: spec.costs,
+            precedences,
+        })
+    }
+}
+
 #[derive(Debug, Deserialize)]
 struct SequencingToMinimizeMaximumCumulativeCostUnchecked {
     costs: Vec<i64>,
@@ -78,7 +100,7 @@ impl SequencingToMinimizeMaximumCumulativeCost {
     }
 
     fn decode_schedule(&self, config: &[usize]) -> Option<Vec<usize>> {
-        super::decode_lehmer(config, self.num_tasks())
+        super::decode_permutation(config, self.num_tasks())
     }
 }
 
@@ -127,45 +149,77 @@ fn precedence_validation_error(precedences: &[(usize, usize)], num_tasks: usize)
 
 impl Problem for SequencingToMinimizeMaximumCumulativeCost {
     const NAME: &'static str = "SequencingToMinimizeMaximumCumulativeCost";
+    type Solution = Vec<usize>;
     type Value = crate::types::Min<i64>;
 
+    crate::problem_parameters![
+        ("num_precedences", num_precedences),
+        ("num_tasks", num_tasks),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        super::lehmer_dims(self.num_tasks())
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Min<i64> {
-        let Some(schedule) = self.decode_schedule(config) else {
-            return crate::types::Min(None);
-        };
-
-        let mut positions = vec![0usize; self.num_tasks()];
-        for (position, &task) in schedule.iter().enumerate() {
-            positions[task] = position;
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Min<i64>, crate::traits::EvaluationError> {
+        let n = self.num_tasks();
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule length does not match the tasks".into(),
+            ));
         }
-        for &(pred, succ) in &self.precedences {
-            if positions[pred] >= positions[succ] {
-                return crate::types::Min(None);
-            }
+        if config.iter().any(|&task| task >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule contains an out-of-range task".into(),
+            ));
         }
+        Ok({
+            let Some(schedule) = self.decode_schedule(config) else {
+                return Ok(crate::types::Min(None));
+            };
+
+            let mut positions = vec![0usize; self.num_tasks()];
+            for (position, &task) in schedule.iter().enumerate() {
+                positions[task] = position;
+            }
+            for &(pred, succ) in &self.precedences {
+                if positions[pred] >= positions[succ] {
+                    return Ok(crate::types::Min(None));
+                }
+            }
 
-        let mut cumulative = 0i64;
-        let mut max_cumulative = 0i64;
-        for &task in &schedule {
-            cumulative += self.costs[task];
-            if cumulative > max_cumulative {
-                max_cumulative = cumulative;
+            let mut cumulative = 0i64;
+            let mut max_cumulative = 0i64;
+            for &task in &schedule {
+                cumulative = cumulative.checked_add(self.costs[task]).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing sequencing cumulative costs".into(),
+                    )
+                })?;
+                if cumulative > max_cumulative {
+                    max_cumulative = cumulative;
+                }
             }
-        }
-        crate::types::Min(Some(max_cumulative))
+            crate::types::Min(Some(max_cumulative))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for SequencingToMinimizeMaximumCumulativeCost {
+    fn dimensions(&self) -> Vec<usize> {
+        super::lehmer_dims(self.num_tasks())
     }
 }
 
 crate::declare_variants! {
-    default SequencingToMinimizeMaximumCumulativeCost => "factorial(num_tasks)",
+    default SequencingToMinimizeMaximumCumulativeCost => "factorial(num_tasks)" create SequencingCumulativeCostCreateSpec,
+}
+
+crate::register_brute_force! {
+    SequencingToMinimizeMaximumCumulativeCost decode |problem: &SequencingToMinimizeMaximumCumulativeCost, indices: Vec<usize>| super::decode_lehmer(&indices, problem.num_tasks()).expect("enumerated Lehmer digits are valid"),
 }
 
 #[cfg(feature = "example-db")]
@@ -176,7 +230,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![2, -1, 3, -2, 1, -3],
             vec![(0, 2), (1, 2), (1, 3), (2, 4), (3, 5), (4, 5)],
         )),
-        optimal_config: vec![1, 0, 1, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![1, 0, 3, 2, 4, 5]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/misc/sequencing_to_minimize_tardy_task_weight.rs b/src/models/misc/sequencing_to_minimize_tardy_task_weight.rs
index 379dac87d..c60474b40 100644
--- a/src/models/misc/sequencing_to_minimize_tardy_task_weight.rs
+++ b/src/models/misc/sequencing_to_minimize_tardy_task_weight.rs
@@ -4,7 +4,7 @@
 //! Garey & Johnson, 1979) where tasks with processing times, weights,
 //! and deadlines must be scheduled to minimize the total weight of tardy tasks.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -15,13 +15,10 @@ inventory::submit! {
         display_name: "Sequencing to Minimize Tardy Task Weight",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Schedule tasks with lengths, weights, and deadlines to minimize total weight of tardy tasks",
-        fields: &[
-            FieldInfo { name: "lengths", type_name: "Vec<u64>", description: "Processing time for each task" },
-            FieldInfo { name: "weights", type_name: "Vec<u64>", description: "Weight w(t) for each task" },
-            FieldInfo { name: "deadlines", type_name: "Vec<u64>", description: "Deadline d(t) for each task" },
-        ],
+        fields: SequencingToMinimizeTardyTaskWeightCreateSpec::FIELDS,
     }
 }
 
@@ -39,31 +36,69 @@ inventory::submit! {
 /// A configuration is valid iff it is a permutation of `0..n`.
 #[derive(Debug, Clone, Serialize)]
 pub struct SequencingToMinimizeTardyTaskWeight {
-    lengths: Vec<u64>,
-    weights: Vec<u64>,
-    deadlines: Vec<u64>,
+    lengths: Vec<i64>,
+    weights: Vec<i64>,
+    deadlines: Vec<i64>,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SequencingToMinimizeTardyTaskWeightCreateSpec {
+    /// Processing time for each task.
+    lengths: Vec<i64>,
+    /// Task weights; defaults to one per task.
+    weights: Option<Vec<i64>>,
+    /// Deadline for each task.
+    deadlines: Vec<i64>,
+}
+impl TryFrom<SequencingToMinimizeTardyTaskWeightCreateSpec>
+    for SequencingToMinimizeTardyTaskWeight
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: SequencingToMinimizeTardyTaskWeightCreateSpec) -> Result<Self, Self::Error> {
+        let count = spec.lengths.len();
+        if spec.deadlines.len() != count {
+            return Err("deadlines length must equal lengths length"
+                .to_string()
+                .into());
+        }
+        let weights = spec.weights.unwrap_or_else(|| vec![1; count]);
+        if weights.len() != count {
+            return Err("weights length must equal lengths length"
+                .to_string()
+                .into());
+        }
+        Ok(Self::new(spec.lengths, weights, spec.deadlines))
+    }
 }
 
 #[derive(Deserialize)]
 struct SequencingToMinimizeTardyTaskWeightSerde {
-    lengths: Vec<u64>,
-    weights: Vec<u64>,
-    deadlines: Vec<u64>,
+    lengths: Vec<i64>,
+    weights: Vec<i64>,
+    deadlines: Vec<i64>,
 }
 
 impl SequencingToMinimizeTardyTaskWeight {
-    fn validate(lengths: &[u64], weights: &[u64], deadlines: &[u64]) -> Result<(), String> {
+    fn validate(
+        lengths: &[i64],
+        weights: &[i64],
+        deadlines: &[i64],
+    ) -> Result<(), crate::registry::ConstructionError> {
         if lengths.len() != weights.len() {
-            return Err("lengths length must equal weights length".to_string());
+            return Err("lengths length must equal weights length"
+                .to_string()
+                .into());
         }
         if lengths.len() != deadlines.len() {
-            return Err("lengths length must equal deadlines length".to_string());
+            return Err("lengths length must equal deadlines length"
+                .to_string()
+                .into());
         }
         if lengths.contains(&0) {
-            return Err("task lengths must be positive".to_string());
+            return Err("task lengths must be positive".to_string().into());
         }
         if weights.contains(&0) {
-            return Err("task weights must be positive".to_string());
+            return Err("task weights must be positive".to_string().into());
         }
         Ok(())
     }
@@ -74,7 +109,7 @@ impl SequencingToMinimizeTardyTaskWeight {
     ///
     /// Panics if `lengths`, `weights`, and `deadlines` are not all the same
     /// length, or if any length or weight is zero.
-    pub fn new(lengths: Vec<u64>, weights: Vec<u64>, deadlines: Vec<u64>) -> Self {
+    pub fn new(lengths: Vec<i64>, weights: Vec<i64>, deadlines: Vec<i64>) -> Self {
         Self::validate(&lengths, &weights, &deadlines).unwrap_or_else(|err| panic!("{err}"));
         Self {
             lengths,
@@ -89,39 +124,46 @@ impl SequencingToMinimizeTardyTaskWeight {
     }
 
     /// Returns the processing times.
-    pub fn lengths(&self) -> &[u64] {
+    pub fn lengths(&self) -> &[i64] {
         &self.lengths
     }
 
     /// Returns the task weights.
-    pub fn weights(&self) -> &[u64] {
+    pub fn weights(&self) -> &[i64] {
         &self.weights
     }
 
     /// Returns the task deadlines.
-    pub fn deadlines(&self) -> &[u64] {
+    pub fn deadlines(&self) -> &[i64] {
         &self.deadlines
     }
 
-    fn tardy_task_weight(&self, schedule: &[usize]) -> Min<u64> {
-        let mut elapsed: u64 = 0;
-        let mut total: u64 = 0;
+    fn tardy_task_weight(
+        &self,
+        schedule: &[usize],
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        let mut elapsed: i64 = 0;
+        let mut total: i64 = 0;
         for &task in schedule {
-            elapsed = elapsed
-                .checked_add(self.lengths[task])
-                .expect("total processing time overflowed u64");
+            elapsed = elapsed.checked_add(self.lengths[task]).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing tardiness sequencing processing times".to_string(),
+                )
+            })?;
             if elapsed > self.deadlines[task] {
-                total = total
-                    .checked_add(self.weights[task])
-                    .expect("tardy task weight overflowed u64");
+                total = total.checked_add(self.weights[task]).ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing tardy task weights".to_string(),
+                    )
+                })?;
             }
         }
-        Min(Some(total))
+        Ok(Min(Some(total)))
     }
 }
 
 impl TryFrom<SequencingToMinimizeTardyTaskWeightSerde> for SequencingToMinimizeTardyTaskWeight {
-    type Error = String;
+    type Error = crate::registry::ConstructionError;
 
     fn try_from(value: SequencingToMinimizeTardyTaskWeightSerde) -> Result<Self, Self::Error> {
         Self::validate(&value.lengths, &value.weights, &value.deadlines)?;
@@ -145,28 +187,52 @@ impl<'de> Deserialize<'de> for SequencingToMinimizeTardyTaskWeight {
 
 impl Problem for SequencingToMinimizeTardyTaskWeight {
     const NAME: &'static str = "SequencingToMinimizeTardyTaskWeight";
-    type Value = Min<u64>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_tasks", num_tasks),];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.num_tasks();
-        vec![n; n]
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule length does not match the tasks".into(),
+            ));
+        }
+        if config.iter().any(|&task| task >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule contains an out-of-range task".into(),
+            ));
+        }
+        Ok({
+            let Some(schedule) = super::decode_permutation(config, n) else {
+                return Ok(Min(None));
+            };
+            self.tardy_task_weight(&schedule)?
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<u64> {
+impl crate::solvers::BruteForceProblem for SequencingToMinimizeTardyTaskWeight {
+    fn dimensions(&self) -> Vec<usize> {
         let n = self.num_tasks();
-        let Some(schedule) = super::decode_permutation(config, n) else {
-            return Min(None);
-        };
-        self.tardy_task_weight(&schedule)
+        vec![n; n]
     }
 }
 
 crate::declare_variants! {
-    default SequencingToMinimizeTardyTaskWeight => "factorial(num_tasks)",
+    default SequencingToMinimizeTardyTaskWeight => "factorial(num_tasks)" create SequencingToMinimizeTardyTaskWeightCreateSpec,
+}
+
+crate::register_brute_force! {
+    SequencingToMinimizeTardyTaskWeight,
 }
 
 #[cfg(feature = "example-db")]
@@ -186,7 +252,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![5, 3, 7, 2, 4],
             vec![6, 4, 10, 2, 8],
         )),
-        optimal_config: vec![3, 0, 4, 2, 1],
+        optimal_config: serde_json::json!(vec![3, 0, 4, 2, 1]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/misc/sequencing_to_minimize_weighted_completion_time.rs b/src/models/misc/sequencing_to_minimize_weighted_completion_time.rs
index 6a62e11eb..05cd17d62 100644
--- a/src/models/misc/sequencing_to_minimize_weighted_completion_time.rs
+++ b/src/models/misc/sequencing_to_minimize_weighted_completion_time.rs
@@ -10,7 +10,7 @@
 //! Optimal Linear Arrangement, which uses zero-length edge jobs instead
 //! of padding them to unit length.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -21,13 +21,10 @@ inventory::submit! {
         display_name: "Sequencing to Minimize Weighted Completion Time",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Schedule tasks with lengths, weights, and precedence constraints to minimize total weighted completion time",
-        fields: &[
-            FieldInfo { name: "lengths", type_name: "Vec<u64>", description: "Processing time l(t) for each task" },
-            FieldInfo { name: "weights", type_name: "Vec<u64>", description: "Weight w(t) for each task" },
-            FieldInfo { name: "precedences", type_name: "Vec<(usize, usize)>", description: "Precedence pairs (predecessor, successor)" },
-        ],
+        fields: SequencingToMinimizeWeightedCompletionTimeCreateSpec::FIELDS,
     }
 }
 
@@ -41,26 +38,49 @@ inventory::submit! {
 /// Configurations use Lehmer code with `dims() = [n, n-1, ..., 1]`.
 #[derive(Debug, Clone, Serialize)]
 pub struct SequencingToMinimizeWeightedCompletionTime {
-    lengths: Vec<u64>,
-    weights: Vec<u64>,
+    lengths: Vec<i64>,
+    weights: Vec<i64>,
     precedences: Vec<(usize, usize)>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SequencingToMinimizeWeightedCompletionTimeCreateSpec {
+    lengths: Vec<i64>,
+    weights: Vec<i64>,
+    precedences: Option<Vec<(usize, usize)>>,
+}
+
+impl TryFrom<SequencingToMinimizeWeightedCompletionTimeCreateSpec>
+    for SequencingToMinimizeWeightedCompletionTime
+{
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(
+        spec: SequencingToMinimizeWeightedCompletionTimeCreateSpec,
+    ) -> Result<Self, Self::Error> {
+        let precedences = spec.precedences.unwrap_or_default();
+        Self::validate(&spec.lengths, &spec.weights, &precedences)?;
+        Ok(Self::new(spec.lengths, spec.weights, precedences))
+    }
+}
+
 #[derive(Deserialize)]
 struct SequencingToMinimizeWeightedCompletionTimeSerde {
-    lengths: Vec<u64>,
-    weights: Vec<u64>,
+    lengths: Vec<i64>,
+    weights: Vec<i64>,
     precedences: Vec<(usize, usize)>,
 }
 
 impl SequencingToMinimizeWeightedCompletionTime {
     fn validate(
-        lengths: &[u64],
-        weights: &[u64],
+        lengths: &[i64],
+        weights: &[i64],
         precedences: &[(usize, usize)],
-    ) -> Result<(), String> {
+    ) -> Result<(), crate::registry::ConstructionError> {
         if lengths.len() != weights.len() {
-            return Err("lengths length must equal weights length".to_string());
+            return Err("lengths length must equal weights length"
+                .to_string()
+                .into());
         }
 
         let num_tasks = lengths.len();
@@ -69,13 +89,15 @@ impl SequencingToMinimizeWeightedCompletionTime {
                 return Err(format!(
                     "predecessor index {} out of range (num_tasks = {})",
                     pred, num_tasks
-                ));
+                )
+                .into());
             }
             if succ >= num_tasks {
                 return Err(format!(
                     "successor index {} out of range (num_tasks = {})",
                     succ, num_tasks
-                ));
+                )
+                .into());
             }
         }
 
@@ -88,7 +110,7 @@ impl SequencingToMinimizeWeightedCompletionTime {
     ///
     /// Panics if `lengths.len() != weights.len()` or if any precedence
     /// endpoint is out of range.
-    pub fn new(lengths: Vec<u64>, weights: Vec<u64>, precedences: Vec<(usize, usize)>) -> Self {
+    pub fn new(lengths: Vec<i64>, weights: Vec<i64>, precedences: Vec<(usize, usize)>) -> Self {
         Self::validate(&lengths, &weights, &precedences).unwrap_or_else(|err| panic!("{err}"));
 
         Self {
@@ -104,12 +126,12 @@ impl SequencingToMinimizeWeightedCompletionTime {
     }
 
     /// Returns the processing times.
-    pub fn lengths(&self) -> &[u64] {
+    pub fn lengths(&self) -> &[i64] {
         &self.lengths
     }
 
     /// Returns the task weights.
-    pub fn weights(&self) -> &[u64] {
+    pub fn weights(&self) -> &[i64] {
         &self.weights
     }
 
@@ -123,54 +145,55 @@ impl SequencingToMinimizeWeightedCompletionTime {
         self.precedences.len()
     }
 
-    /// Returns the sum of all processing times.
-    pub fn total_processing_time(&self) -> u64 {
-        self.lengths
-            .iter()
-            .try_fold(0u64, |acc, &length| acc.checked_add(length))
-            .expect("total processing time overflowed u64")
-    }
-
     fn decode_schedule(&self, config: &[usize]) -> Option<Vec<usize>> {
-        super::decode_lehmer(config, self.num_tasks())
+        super::decode_permutation(config, self.num_tasks())
     }
 
-    fn weighted_completion_time(&self, schedule: &[usize]) -> Min<u64> {
+    fn weighted_completion_time(
+        &self,
+        schedule: &[usize],
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         let n = self.num_tasks();
         let mut positions = vec![0usize; n];
-        let mut completion_times = vec![0u64; n];
-        let mut elapsed = 0u64;
+        let mut completion_times = vec![0i64; n];
+        let mut elapsed = 0i64;
 
         for (position, &task) in schedule.iter().enumerate() {
             positions[task] = position;
-            elapsed = elapsed
-                .checked_add(self.lengths[task])
-                .expect("total processing time overflowed u64");
+            elapsed = elapsed.checked_add(self.lengths[task]).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing sequencing processing times".to_string(),
+                )
+            })?;
             completion_times[task] = elapsed;
         }
 
         for &(pred, succ) in &self.precedences {
             if positions[pred] >= positions[succ] {
-                return Min(None);
+                return Ok(Min(None));
             }
         }
 
         let total = completion_times
             .iter()
             .enumerate()
-            .try_fold(0u64, |acc, (task, &completion)| -> Option<u64> {
+            .try_fold(0i64, |acc, (task, &completion)| -> Option<i64> {
                 let weighted_completion = completion.checked_mul(self.weights[task])?;
                 acc.checked_add(weighted_completion)
             })
-            .expect("weighted completion time overflowed u64");
-        Min(Some(total))
+            .ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "computing weighted completion time".to_string(),
+                )
+            })?;
+        Ok(Min(Some(total)))
     }
 }
 
 impl TryFrom<SequencingToMinimizeWeightedCompletionTimeSerde>
     for SequencingToMinimizeWeightedCompletionTime
 {
-    type Error = String;
+    type Error = crate::registry::ConstructionError;
 
     fn try_from(
         value: SequencingToMinimizeWeightedCompletionTimeSerde,
@@ -196,26 +219,54 @@ impl<'de> Deserialize<'de> for SequencingToMinimizeWeightedCompletionTime {
 
 impl Problem for SequencingToMinimizeWeightedCompletionTime {
     const NAME: &'static str = "SequencingToMinimizeWeightedCompletionTime";
-    type Value = Min<u64>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_precedences", num_precedences),
+        ("num_tasks", num_tasks),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        super::lehmer_dims(self.num_tasks())
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        let n = self.num_tasks();
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule length does not match the tasks".into(),
+            ));
+        }
+        if config.iter().any(|&task| task >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule contains an out-of-range task".into(),
+            ));
+        }
+        Ok({
+            let Some(schedule) = self.decode_schedule(config) else {
+                return Ok(Min(None));
+            };
+            self.weighted_completion_time(&schedule)?
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<u64> {
-        let Some(schedule) = self.decode_schedule(config) else {
-            return Min(None);
-        };
-        self.weighted_completion_time(&schedule)
+impl crate::solvers::BruteForceProblem for SequencingToMinimizeWeightedCompletionTime {
+    fn dimensions(&self) -> Vec<usize> {
+        super::lehmer_dims(self.num_tasks())
     }
 }
 
 crate::declare_variants! {
-    default SequencingToMinimizeWeightedCompletionTime => "factorial(num_tasks)",
+    default SequencingToMinimizeWeightedCompletionTime => "factorial(num_tasks)" create SequencingToMinimizeWeightedCompletionTimeCreateSpec,
+}
+
+crate::register_brute_force! {
+    SequencingToMinimizeWeightedCompletionTime decode |problem: &SequencingToMinimizeWeightedCompletionTime, indices: Vec<usize>| super::decode_lehmer(&indices, problem.num_tasks()).expect("enumerated Lehmer digits are valid"),
 }
 
 #[cfg(feature = "example-db")]
@@ -227,7 +278,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![3, 5, 1, 4, 2],
             vec![(0, 2), (1, 4)],
         )),
-        optimal_config: vec![1, 2, 0, 1, 0],
+        optimal_config: serde_json::json!(vec![1, 3, 0, 4, 2]),
         optimal_value: serde_json::json!(46),
     }]
 }
diff --git a/src/models/misc/sequencing_to_minimize_weighted_tardiness.rs b/src/models/misc/sequencing_to_minimize_weighted_tardiness.rs
index 946ae2140..08b6d8419 100644
--- a/src/models/misc/sequencing_to_minimize_weighted_tardiness.rs
+++ b/src/models/misc/sequencing_to_minimize_weighted_tardiness.rs
@@ -5,7 +5,7 @@
 //! total weighted tardiness is at most a given bound.
 //! Corresponds to scheduling notation `1 || sum w_j T_j`.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -15,14 +15,10 @@ inventory::submit! {
         display_name: "Sequencing to Minimize Weighted Tardiness",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Schedule jobs on one machine so total weighted tardiness is at most K",
-        fields: &[
-            FieldInfo { name: "lengths", type_name: "Vec<u64>", description: "Processing times l_j for each job" },
-            FieldInfo { name: "weights", type_name: "Vec<u64>", description: "Tardiness weights w_j for each job" },
-            FieldInfo { name: "deadlines", type_name: "Vec<u64>", description: "Deadlines d_j for each job" },
-            FieldInfo { name: "bound", type_name: "u64", description: "Upper bound K on total weighted tardiness" },
-        ],
+        fields: SequencingToMinimizeWeightedTardinessCreateSpec::FIELDS,
     }
 }
 
@@ -43,7 +39,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::SequencingToMinimizeWeightedTardiness;
-/// use problemreductions::{BruteForce, Problem, Solver};
+/// use problemreductions::{BruteForce, Problem};
 ///
 /// let problem = SequencingToMinimizeWeightedTardiness::new(
 ///     vec![3, 4, 2, 5, 3],
@@ -53,14 +49,51 @@ inventory::submit! {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// assert!(solver.find_witness(&problem).is_some());
+/// assert!(solver.solve(&problem).unwrap().is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SequencingToMinimizeWeightedTardiness {
-    lengths: Vec<u64>,
-    weights: Vec<u64>,
-    deadlines: Vec<u64>,
-    bound: u64,
+    lengths: Vec<i64>,
+    weights: Vec<i64>,
+    deadlines: Vec<i64>,
+    bound: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SequencingToMinimizeWeightedTardinessCreateSpec {
+    /// Processing times for each job.
+    lengths: Vec<i64>,
+    /// Tardiness weights for each job.
+    weights: Vec<i64>,
+    /// Deadlines for each job.
+    deadlines: Vec<i64>,
+    /// Upper bound on total weighted tardiness.
+    bound: i64,
+}
+impl TryFrom<SequencingToMinimizeWeightedTardinessCreateSpec>
+    for SequencingToMinimizeWeightedTardiness
+{
+    type Error = crate::registry::ConstructionError;
+    fn try_from(
+        spec: SequencingToMinimizeWeightedTardinessCreateSpec,
+    ) -> Result<Self, Self::Error> {
+        if spec.lengths.len() != spec.weights.len() {
+            return Err("weights length must equal lengths length"
+                .to_string()
+                .into());
+        }
+        if spec.lengths.len() != spec.deadlines.len() {
+            return Err("deadlines length must equal lengths length"
+                .to_string()
+                .into());
+        }
+        Ok(Self::new(
+            spec.lengths,
+            spec.weights,
+            spec.deadlines,
+            spec.bound,
+        ))
+    }
 }
 
 impl SequencingToMinimizeWeightedTardiness {
@@ -69,7 +102,7 @@ impl SequencingToMinimizeWeightedTardiness {
     /// # Panics
     ///
     /// Panics if the input vectors do not have the same length.
-    pub fn new(lengths: Vec<u64>, weights: Vec<u64>, deadlines: Vec<u64>, bound: u64) -> Self {
+    pub fn new(lengths: Vec<i64>, weights: Vec<i64>, deadlines: Vec<i64>, bound: i64) -> Self {
         assert_eq!(
             lengths.len(),
             weights.len(),
@@ -80,6 +113,19 @@ impl SequencingToMinimizeWeightedTardiness {
             deadlines.len(),
             "deadlines length must equal lengths length"
         );
+        assert!(
+            lengths.iter().all(|&length| length >= 0),
+            "task lengths must be nonnegative"
+        );
+        assert!(
+            weights.iter().all(|&weight| weight >= 0),
+            "task weights must be nonnegative"
+        );
+        assert!(
+            deadlines.iter().all(|&deadline| deadline >= 0),
+            "deadlines must be nonnegative"
+        );
+        assert!(bound >= 0, "bound must be nonnegative");
         Self {
             lengths,
             weights,
@@ -89,22 +135,22 @@ impl SequencingToMinimizeWeightedTardiness {
     }
 
     /// Returns the job lengths.
-    pub fn lengths(&self) -> &[u64] {
+    pub fn lengths(&self) -> &[i64] {
         &self.lengths
     }
 
     /// Returns the tardiness weights.
-    pub fn weights(&self) -> &[u64] {
+    pub fn weights(&self) -> &[i64] {
         &self.weights
     }
 
     /// Returns the deadlines.
-    pub fn deadlines(&self) -> &[u64] {
+    pub fn deadlines(&self) -> &[i64] {
         &self.deadlines
     }
 
     /// Returns the weighted tardiness bound.
-    pub fn bound(&self) -> u64 {
+    pub fn bound(&self) -> i64 {
         self.bound
     }
 
@@ -114,52 +160,106 @@ impl SequencingToMinimizeWeightedTardiness {
     }
 
     fn decode_schedule(&self, config: &[usize]) -> Option<Vec<usize>> {
-        super::decode_lehmer(config, self.num_tasks())
+        super::decode_permutation(config, self.num_tasks())
     }
 
-    fn schedule_weighted_tardiness(&self, schedule: &[usize]) -> Option<u64> {
-        let mut completion_time = 0u128;
-        let mut total = 0u128;
+    fn schedule_weighted_tardiness(
+        &self,
+        schedule: &[usize],
+    ) -> Result<i64, crate::traits::EvaluationError> {
+        let mut completion_time = 0i64;
+        let mut total = 0i64;
         for &job in schedule {
-            completion_time += u128::from(self.lengths[job]);
-            let tardiness = completion_time.saturating_sub(u128::from(self.deadlines[job]));
-            total += tardiness * u128::from(self.weights[job]);
+            completion_time = completion_time
+                .checked_add(self.lengths[job])
+                .ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "summing weighted-tardiness completion times".to_string(),
+                    )
+                })?;
+            let tardiness = completion_time
+                .checked_sub(self.deadlines[job])
+                .ok_or_else(|| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "computing job tardiness".to_string(),
+                    )
+                })?
+                .max(0);
+            let weighted_tardiness = tardiness.checked_mul(self.weights[job]).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "multiplying tardiness by job weight".to_string(),
+                )
+            })?;
+            total = total.checked_add(weighted_tardiness).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing weighted job tardiness".to_string(),
+                )
+            })?;
         }
-        u64::try_from(total).ok()
+        Ok(total)
     }
 
     /// Compute the total weighted tardiness of a Lehmer-encoded schedule.
     ///
-    /// Returns `None` if the configuration is not a valid Lehmer code or if
-    /// the accumulated objective does not fit in `u64`.
-    pub fn total_weighted_tardiness(&self, config: &[usize]) -> Option<u64> {
-        let schedule = self.decode_schedule(config)?;
-        self.schedule_weighted_tardiness(&schedule)
+    /// Returns `Ok(None)` if the configuration is not a valid Lehmer code.
+    pub fn total_weighted_tardiness(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
+        let Some(schedule) = self.decode_schedule(config) else {
+            return Ok(None);
+        };
+        Ok(Some(self.schedule_weighted_tardiness(&schedule)?))
     }
 }
 
 impl Problem for SequencingToMinimizeWeightedTardiness {
     const NAME: &'static str = "SequencingToMinimizeWeightedTardiness";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_tasks", num_tasks),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        super::lehmer_dims(self.num_tasks())
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        let n = self.num_tasks();
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule length does not match the tasks".into(),
+            ));
+        }
+        if config.iter().any(|&task| task >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule contains an out-of-range task".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or({
+                self.total_weighted_tardiness(config)?
+                    .is_some_and(|total| total <= self.bound)
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            self.total_weighted_tardiness(config)
-                .is_some_and(|total| total <= self.bound)
-        })
+impl crate::solvers::BruteForceProblem for SequencingToMinimizeWeightedTardiness {
+    fn dimensions(&self) -> Vec<usize> {
+        super::lehmer_dims(self.num_tasks())
     }
 }
 
 crate::declare_variants! {
-    default SequencingToMinimizeWeightedTardiness => "factorial(num_tasks)",
+    default SequencingToMinimizeWeightedTardiness => "factorial(num_tasks)" create SequencingToMinimizeWeightedTardinessCreateSpec,
+}
+
+crate::register_brute_force! {
+    SequencingToMinimizeWeightedTardiness decode |problem: &SequencingToMinimizeWeightedTardiness, indices: Vec<usize>| super::decode_lehmer(&indices, problem.num_tasks()).expect("enumerated Lehmer digits are valid"),
 }
 
 #[cfg(feature = "example-db")]
@@ -172,7 +272,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![5, 8, 4, 15, 10],
             13,
         )),
-        optimal_config: vec![0, 0, 2, 1, 0],
+        optimal_config: serde_json::json!(vec![0, 1, 4, 3, 2]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/sequencing_with_deadlines_and_set_up_times.rs b/src/models/misc/sequencing_with_deadlines_and_set_up_times.rs
index 3b14e6bcf..568c4f3df 100644
--- a/src/models/misc/sequencing_with_deadlines_and_set_up_times.rs
+++ b/src/models/misc/sequencing_with_deadlines_and_set_up_times.rs
@@ -16,13 +16,14 @@ inventory::submit! {
         display_name: "Sequencing with Deadlines and Set-Up Times",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Determine whether all tasks can be scheduled on a single machine by their deadlines given compiler-switch setup penalties",
         fields: &[
-            FieldInfo { name: "lengths", type_name: "Vec<u64>", description: "Processing time for each task" },
-            FieldInfo { name: "deadlines", type_name: "Vec<u64>", description: "Deadline d(t) for each task" },
+            FieldInfo { name: "lengths", type_name: "Vec<i64>", description: "Processing time for each task" },
+            FieldInfo { name: "deadlines", type_name: "Vec<i64>", description: "Deadline d(t) for each task" },
             FieldInfo { name: "compilers", type_name: "Vec<usize>", description: "Compiler index k(t) for each task" },
-            FieldInfo { name: "setup_times", type_name: "Vec<u64>", description: "Setup time s(c) charged when switching to compiler c" },
+            FieldInfo { name: "setup_times", type_name: "Vec<i64>", description: "Setup time s(c) charged when switching to compiler c" },
         ],
     }
 }
@@ -43,42 +44,47 @@ inventory::submit! {
 /// A configuration is valid iff it is a permutation of `0..n`.
 #[derive(Debug, Clone, Serialize)]
 pub struct SequencingWithDeadlinesAndSetUpTimes {
-    lengths: Vec<u64>,
-    deadlines: Vec<u64>,
+    lengths: Vec<i64>,
+    deadlines: Vec<i64>,
     compilers: Vec<usize>,
-    setup_times: Vec<u64>,
+    setup_times: Vec<i64>,
 }
 
 #[derive(Deserialize)]
 struct SequencingWithDeadlinesAndSetUpTimesSerde {
-    lengths: Vec<u64>,
-    deadlines: Vec<u64>,
+    lengths: Vec<i64>,
+    deadlines: Vec<i64>,
     compilers: Vec<usize>,
-    setup_times: Vec<u64>,
+    setup_times: Vec<i64>,
 }
 
 impl SequencingWithDeadlinesAndSetUpTimes {
     fn validate(
-        lengths: &[u64],
-        deadlines: &[u64],
+        lengths: &[i64],
+        deadlines: &[i64],
         compilers: &[usize],
-        setup_times: &[u64],
-    ) -> Result<(), String> {
+        setup_times: &[i64],
+    ) -> Result<(), crate::registry::ConstructionError> {
         if lengths.len() != deadlines.len() {
-            return Err("lengths length must equal deadlines length".to_string());
+            return Err("lengths length must equal deadlines length"
+                .to_string()
+                .into());
         }
         if lengths.len() != compilers.len() {
-            return Err("lengths length must equal compilers length".to_string());
+            return Err("lengths length must equal compilers length"
+                .to_string()
+                .into());
         }
         if lengths.contains(&0) {
-            return Err("task lengths must be positive".to_string());
+            return Err("task lengths must be positive".to_string().into());
         }
         let num_compilers = setup_times.len();
         for &c in compilers {
             if c >= num_compilers {
                 return Err(format!(
                     "compiler index {c} is out of range for setup_times of length {num_compilers}"
-                ));
+                )
+                .into());
             }
         }
         Ok(())
@@ -90,10 +96,10 @@ impl SequencingWithDeadlinesAndSetUpTimes {
     ///
     /// Panics if the input vectors are inconsistent or contain invalid values.
     pub fn new(
-        lengths: Vec<u64>,
-        deadlines: Vec<u64>,
+        lengths: Vec<i64>,
+        deadlines: Vec<i64>,
         compilers: Vec<usize>,
-        setup_times: Vec<u64>,
+        setup_times: Vec<i64>,
     ) -> Self {
         Self::validate(&lengths, &deadlines, &compilers, &setup_times)
             .unwrap_or_else(|err| panic!("{err}"));
@@ -116,12 +122,12 @@ impl SequencingWithDeadlinesAndSetUpTimes {
     }
 
     /// Returns the processing times.
-    pub fn lengths(&self) -> &[u64] {
+    pub fn lengths(&self) -> &[i64] {
         &self.lengths
     }
 
     /// Returns the task deadlines.
-    pub fn deadlines(&self) -> &[u64] {
+    pub fn deadlines(&self) -> &[i64] {
         &self.deadlines
     }
 
@@ -131,15 +137,18 @@ impl SequencingWithDeadlinesAndSetUpTimes {
     }
 
     /// Returns the per-compiler setup times.
-    pub fn setup_times(&self) -> &[u64] {
+    pub fn setup_times(&self) -> &[i64] {
         &self.setup_times
     }
 
     /// Check whether a schedule meets all deadlines.
     ///
     /// Returns `true` iff every task in the schedule completes by its deadline.
-    fn all_deadlines_met(&self, schedule: &[usize]) -> bool {
-        let mut elapsed: u64 = 0;
+    fn all_deadlines_met(
+        &self,
+        schedule: &[usize],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        let mut elapsed: i64 = 0;
         let mut prev_compiler: Option<usize> = None;
         for &task in schedule {
             // Add setup time if the compiler switches.
@@ -147,23 +156,29 @@ impl SequencingWithDeadlinesAndSetUpTimes {
                 if prev != self.compilers[task] {
                     elapsed = elapsed
                         .checked_add(self.setup_times[self.compilers[task]])
-                        .expect("elapsed time overflowed u64");
+                        .ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "adding sequencing setup time".to_string(),
+                            )
+                        })?;
                 }
             }
-            elapsed = elapsed
-                .checked_add(self.lengths[task])
-                .expect("elapsed time overflowed u64");
+            elapsed = elapsed.checked_add(self.lengths[task]).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "adding sequencing task length".to_string(),
+                )
+            })?;
             if elapsed > self.deadlines[task] {
-                return false;
+                return Ok(false);
             }
             prev_compiler = Some(self.compilers[task]);
         }
-        true
+        Ok(true)
     }
 }
 
 impl TryFrom<SequencingWithDeadlinesAndSetUpTimesSerde> for SequencingWithDeadlinesAndSetUpTimes {
-    type Error = String;
+    type Error = crate::registry::ConstructionError;
 
     fn try_from(value: SequencingWithDeadlinesAndSetUpTimesSerde) -> Result<Self, Self::Error> {
         Self::validate(
@@ -193,23 +208,40 @@ impl<'de> Deserialize<'de> for SequencingWithDeadlinesAndSetUpTimes {
 
 impl Problem for SequencingWithDeadlinesAndSetUpTimes {
     const NAME: &'static str = "SequencingWithDeadlinesAndSetUpTimes";
+    type Solution = Vec<usize>;
     type Value = Or;
 
+    crate::problem_parameters![("num_tasks", num_tasks),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
         let n = self.num_tasks();
-        vec![n; n]
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule length does not match the tasks".into(),
+            ));
+        }
+        if config.iter().any(|&task| task >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule contains an out-of-range task".into(),
+            ));
+        }
+        Ok({
+            let Some(schedule) = super::decode_permutation(config, n) else {
+                return Ok(Or(false));
+            };
+            Or(self.all_deadlines_met(&schedule)?)
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Or {
+impl crate::solvers::BruteForceProblem for SequencingWithDeadlinesAndSetUpTimes {
+    fn dimensions(&self) -> Vec<usize> {
         let n = self.num_tasks();
-        let Some(schedule) = super::decode_permutation(config, n) else {
-            return Or(false);
-        };
-        Or(self.all_deadlines_met(&schedule))
+        vec![n; n]
     }
 }
 
@@ -217,6 +249,10 @@ crate::declare_variants! {
     default SequencingWithDeadlinesAndSetUpTimes => "factorial(num_tasks)",
 }
 
+crate::register_brute_force! {
+    SequencingWithDeadlinesAndSetUpTimes,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -235,7 +271,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![0, 1, 0, 1, 0],
             vec![1, 2],
         )),
-        optimal_config: vec![2, 0, 4, 1, 3],
+        optimal_config: serde_json::json!(vec![2, 0, 4, 1, 3]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/sequencing_with_release_times_and_deadlines.rs b/src/models/misc/sequencing_with_release_times_and_deadlines.rs
index 35c7c9607..3bc6449ea 100644
--- a/src/models/misc/sequencing_with_release_times_and_deadlines.rs
+++ b/src/models/misc/sequencing_with_release_times_and_deadlines.rs
@@ -15,12 +15,13 @@ inventory::submit! {
         display_name: "Sequencing with Release Times and Deadlines",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Single-machine scheduling feasibility: can all tasks be scheduled within their release-deadline windows without overlap?",
         fields: &[
-            FieldInfo { name: "lengths", type_name: "Vec<u64>", description: "Processing time l(t) for each task (positive)" },
-            FieldInfo { name: "release_times", type_name: "Vec<u64>", description: "Release time r(t) for each task (non-negative)" },
-            FieldInfo { name: "deadlines", type_name: "Vec<u64>", description: "Deadline d(t) for each task (positive)" },
+            FieldInfo { name: "lengths", type_name: "Vec<i64>", description: "Processing time l(t) for each task (positive)" },
+            FieldInfo { name: "release_times", type_name: "Vec<i64>", description: "Release time r(t) for each task (non-negative)" },
+            FieldInfo { name: "deadlines", type_name: "Vec<i64>", description: "Deadline d(t) for each task (positive)" },
         ],
     }
 }
@@ -44,7 +45,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::SequencingWithReleaseTimesAndDeadlines;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = SequencingWithReleaseTimesAndDeadlines::new(
 ///     vec![1, 2, 1],
@@ -52,14 +53,14 @@ inventory::submit! {
 ///     vec![3, 3, 4],
 /// );
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SequencingWithReleaseTimesAndDeadlines {
-    lengths: Vec<u64>,
-    release_times: Vec<u64>,
-    deadlines: Vec<u64>,
+    lengths: Vec<i64>,
+    release_times: Vec<i64>,
+    deadlines: Vec<i64>,
 }
 
 impl SequencingWithReleaseTimesAndDeadlines {
@@ -68,9 +69,21 @@ impl SequencingWithReleaseTimesAndDeadlines {
     /// # Panics
     ///
     /// Panics if the three vectors have different lengths.
-    pub fn new(lengths: Vec<u64>, release_times: Vec<u64>, deadlines: Vec<u64>) -> Self {
+    pub fn new(lengths: Vec<i64>, release_times: Vec<i64>, deadlines: Vec<i64>) -> Self {
         assert_eq!(lengths.len(), release_times.len());
         assert_eq!(lengths.len(), deadlines.len());
+        assert!(
+            lengths.iter().all(|&length| length >= 0),
+            "task lengths must be nonnegative"
+        );
+        assert!(
+            release_times.iter().all(|&release| release >= 0),
+            "release times must be nonnegative"
+        );
+        assert!(
+            deadlines.iter().all(|&deadline| deadline >= 0),
+            "deadlines must be nonnegative"
+        );
         Self {
             lengths,
             release_times,
@@ -79,17 +92,17 @@ impl SequencingWithReleaseTimesAndDeadlines {
     }
 
     /// Returns the processing times.
-    pub fn lengths(&self) -> &[u64] {
+    pub fn lengths(&self) -> &[i64] {
         &self.lengths
     }
 
     /// Returns the release times.
-    pub fn release_times(&self) -> &[u64] {
+    pub fn release_times(&self) -> &[i64] {
         &self.release_times
     }
 
     /// Returns the deadlines.
-    pub fn deadlines(&self) -> &[u64] {
+    pub fn deadlines(&self) -> &[i64] {
         &self.deadlines
     }
 
@@ -99,49 +112,74 @@ impl SequencingWithReleaseTimesAndDeadlines {
     }
 
     /// Returns the time horizon (maximum deadline).
-    pub fn time_horizon(&self) -> u64 {
+    pub fn time_horizon(&self) -> i64 {
         self.deadlines.iter().copied().max().unwrap_or(0)
     }
 }
 
 impl Problem for SequencingWithReleaseTimesAndDeadlines {
     const NAME: &'static str = "SequencingWithReleaseTimesAndDeadlines";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_tasks", num_tasks), ("time_horizon", time_horizon),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        super::lehmer_dims(self.num_tasks())
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let Some(schedule) = super::decode_lehmer(config, self.num_tasks()) else {
-                return crate::types::Or(false);
-            };
-
-            // Schedule tasks left-to-right: each task starts at max(release_time, current_time).
-            let mut current_time: u64 = 0;
-            for &task in &schedule {
-                let start = current_time.max(self.release_times[task]);
-                let finish = start + self.lengths[task];
-                if finish > self.deadlines[task] {
-                    return crate::types::Or(false);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        let n = self.num_tasks();
+        if config.len() != n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule length does not match the tasks".into(),
+            ));
+        }
+        if config.iter().any(|&task| task >= n) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "schedule contains an out-of-range task".into(),
+            ));
+        }
+        Ok({
+            crate::types::Or({
+                let Some(schedule) = super::decode_permutation(config, self.num_tasks()) else {
+                    return Ok(crate::types::Or(false));
+                };
+
+                // Schedule tasks left-to-right: each task starts at max(release_time, current_time).
+                let mut current_time: i64 = 0;
+                for &task in &schedule {
+                    let start = current_time.max(self.release_times[task]);
+                    let finish = start + self.lengths[task];
+                    if finish > self.deadlines[task] {
+                        return Ok(crate::types::Or(false));
+                    }
+                    current_time = finish;
                 }
-                current_time = finish;
-            }
 
-            true
+                true
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for SequencingWithReleaseTimesAndDeadlines {
+    fn dimensions(&self) -> Vec<usize> {
+        super::lehmer_dims(self.num_tasks())
+    }
+}
+
 crate::declare_variants! {
     default SequencingWithReleaseTimesAndDeadlines => "2^num_tasks * num_tasks",
 }
 
+crate::register_brute_force! {
+    SequencingWithReleaseTimesAndDeadlines decode |problem: &SequencingWithReleaseTimesAndDeadlines, indices: Vec<usize>| super::decode_lehmer(&indices, problem.num_tasks()).expect("enumerated Lehmer digits are valid"),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -154,7 +192,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![0, 1, 5, 0, 8],
             vec![5, 6, 10, 3, 12],
         )),
-        optimal_config: vec![3, 0, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![3, 0, 1, 2, 4]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/sequencing_within_intervals.rs b/src/models/misc/sequencing_within_intervals.rs
index cc391444a..dd7d3deb3 100644
--- a/src/models/misc/sequencing_within_intervals.rs
+++ b/src/models/misc/sequencing_within_intervals.rs
@@ -4,7 +4,7 @@
 //! determine whether all tasks can be scheduled non-overlappingly such that each
 //! task runs entirely within its allowed time window.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{ConstructionError, CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,13 +14,10 @@ inventory::submit! {
         display_name: "Sequencing Within Intervals",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Schedule tasks non-overlappingly within their time windows",
-        fields: &[
-            FieldInfo { name: "release_times", type_name: "Vec<u64>", description: "Release time r(t) for each task" },
-            FieldInfo { name: "deadlines", type_name: "Vec<u64>", description: "Deadline d(t) for each task" },
-            FieldInfo { name: "lengths", type_name: "Vec<u64>", description: "Processing length l(t) for each task" },
-        ],
+        fields: SequencingWithinIntervalsCreateSpec::FIELDS,
     }
 }
 
@@ -39,78 +36,98 @@ inventory::submit! {
 ///
 /// Each task has a variable representing its start time offset from the release time.
 /// Variable `i` takes values in `{0, ..., d(i) - r(i) - l(i)}`, so the actual start
-/// time is `r(i) + config[i]`.
+/// time is `r(i) + config[i]`. If this range is empty, the instance is infeasible.
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::misc::SequencingWithinIntervals;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 3 tasks: release_times = [0, 2, 4], deadlines = [3, 5, 7], lengths = [2, 2, 2]
-/// let problem = SequencingWithinIntervals::new(vec![0, 2, 4], vec![3, 5, 7], vec![2, 2, 2]);
+/// let problem = SequencingWithinIntervals::new(vec![0, 2, 4], vec![3, 5, 7], vec![2, 2, 2]).unwrap();
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize)]
 pub struct SequencingWithinIntervals {
     /// Release times for each task.
-    release_times: Vec<u64>,
+    release_times: Vec<i64>,
     /// Deadlines for each task.
-    deadlines: Vec<u64>,
+    deadlines: Vec<i64>,
     /// Processing lengths for each task.
-    lengths: Vec<u64>,
+    lengths: Vec<i64>,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SequencingWithinIntervalsCreateSpec {
+    /// Release times.
+    release_times: Vec<i64>,
+    /// Deadlines.
+    deadlines: Vec<i64>,
+    /// Processing lengths.
+    lengths: Vec<i64>,
+}
+impl TryFrom<SequencingWithinIntervalsCreateSpec> for SequencingWithinIntervals {
+    type Error = ConstructionError;
+    fn try_from(spec: SequencingWithinIntervalsCreateSpec) -> Result<Self, Self::Error> {
+        Self::new(spec.release_times, spec.deadlines, spec.lengths)
+    }
 }
 
 impl SequencingWithinIntervals {
     /// Create a new SequencingWithinIntervals problem.
     ///
-    /// # Panics
-    /// Panics if the three vectors have different lengths, or if any task has
-    /// `r(i) + l(i) > d(i)` (empty time window).
-    pub fn new(release_times: Vec<u64>, deadlines: Vec<u64>, lengths: Vec<u64>) -> Self {
-        assert_eq!(
-            release_times.len(),
-            deadlines.len(),
-            "release_times and deadlines must have the same length"
-        );
-        assert_eq!(
-            release_times.len(),
-            lengths.len(),
-            "release_times and lengths must have the same length"
-        );
+    pub fn new(
+        release_times: Vec<i64>,
+        deadlines: Vec<i64>,
+        lengths: Vec<i64>,
+    ) -> Result<Self, ConstructionError> {
+        if release_times.len() != deadlines.len() {
+            return Err(ConstructionError::Conversion(
+                "release_times and deadlines must have the same length".into(),
+            ));
+        }
+        if release_times.len() != lengths.len() {
+            return Err(ConstructionError::Conversion(
+                "release_times and lengths must have the same length".into(),
+            ));
+        }
+        if release_times.iter().any(|&release| release < 0)
+            || deadlines.iter().any(|&deadline| deadline < 0)
+            || lengths.iter().any(|&length| length < 0)
+        {
+            return Err(ConstructionError::Conversion(
+                "release times, deadlines, and lengths must be nonnegative".into(),
+            ));
+        }
+        let mut total_slots = 0usize;
         for i in 0..release_times.len() {
-            let sum = release_times[i]
-                .checked_add(lengths[i])
-                .expect("overflow computing r(i) + l(i)");
-            assert!(
-                sum <= deadlines[i],
-                "Task {i}: r({}) + l({}) > d({}), time window is empty",
-                release_times[i],
-                lengths[i],
-                deadlines[i]
-            );
+            let slots = start_slot_count(release_times[i], deadlines[i], lengths[i])?;
+            total_slots = total_slots.checked_add(slots).ok_or_else(|| {
+                ConstructionError::IntegerOverflow("total start-slot count exceeds usize".into())
+            })?;
         }
-        Self {
+        Ok(Self {
             release_times,
             deadlines,
             lengths,
-        }
+        })
     }
 
     /// Returns the release times.
-    pub fn release_times(&self) -> &[u64] {
+    pub fn release_times(&self) -> &[i64] {
         &self.release_times
     }
 
     /// Returns the deadlines.
-    pub fn deadlines(&self) -> &[u64] {
+    pub fn deadlines(&self) -> &[i64] {
         &self.deadlines
     }
 
     /// Returns the processing lengths.
-    pub fn lengths(&self) -> &[u64] {
+    pub fn lengths(&self) -> &[i64] {
         &self.lengths
     }
 
@@ -118,74 +135,158 @@ impl SequencingWithinIntervals {
     pub fn num_tasks(&self) -> usize {
         self.release_times.len()
     }
+
+    /// Return the total number of feasible start slots across all tasks.
+    pub fn num_start_slots(&self) -> usize {
+        self.start_slot_counts().sum()
+    }
+
+    pub(crate) fn start_slot_counts(&self) -> impl Iterator<Item = usize> + '_ {
+        self.release_times
+            .iter()
+            .zip(&self.deadlines)
+            .zip(&self.lengths)
+            .map(|((&release, &deadline), &length)| {
+                start_slot_count(release, deadline, length)
+                    .expect("start-slot count validated at construction")
+            })
+    }
+}
+
+fn start_slot_count(release: i64, deadline: i64, length: i64) -> Result<usize, ConstructionError> {
+    let latest_start = deadline - length;
+    if latest_start < release {
+        return Ok(0);
+    }
+    let count = (latest_start - release).checked_add(1).ok_or_else(|| {
+        ConstructionError::IntegerOverflow("task start-slot count overflows i64".into())
+    })?;
+    usize::try_from(count).map_err(|_| {
+        ConstructionError::IntegerOverflow("task start-slot count does not fit usize".into())
+    })
+}
+
+impl<'de> Deserialize<'de> for SequencingWithinIntervals {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Raw {
+            release_times: Vec<i64>,
+            deadlines: Vec<i64>,
+            lengths: Vec<i64>,
+        }
+
+        let raw = Raw::deserialize(deserializer)?;
+        Self::new(raw.release_times, raw.deadlines, raw.lengths).map_err(serde::de::Error::custom)
+    }
 }
 
 impl Problem for SequencingWithinIntervals {
     const NAME: &'static str = "SequencingWithinIntervals";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![
+        ("num_start_slots", num_start_slots),
+        ("num_tasks", num_tasks),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        (0..self.num_tasks())
-            .map(|i| (self.deadlines[i] - self.release_times[i] - self.lengths[i] + 1) as usize)
-            .collect()
-    }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                let n = self.num_tasks();
+                if config.len() != n {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "sequence length does not match the tasks".into(),
+                    ));
+                }
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let n = self.num_tasks();
-            if config.len() != n {
-                return crate::types::Or(false);
-            }
-
-            // Check each variable is within range and compute start times
-            let mut starts = Vec::with_capacity(n);
-            for (i, &c) in config.iter().enumerate() {
-                let dim =
-                    (self.deadlines[i] - self.release_times[i] - self.lengths[i] + 1) as usize;
-                if c >= dim {
-                    return crate::types::Or(false);
+                // Check each variable is within range and compute start times
+                let mut starts = Vec::with_capacity(n);
+                for (i, (&c, dim)) in config.iter().zip(self.start_slot_counts()).enumerate() {
+                    if c >= dim {
+                        return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                            "schedule contains an out-of-range start offset".into(),
+                        ));
+                    }
+                    // start = r[i] + c, and c < dim = d[i] - r[i] - l[i] + 1,
+                    // so start + l[i] <= d[i] follows from the offset range check.
+                    let offset = i64::try_from(c).map_err(|_| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "converting a sequencing start offset to i64".into(),
+                        )
+                    })?;
+                    let start = self.release_times[i].checked_add(offset).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "adding a sequencing start offset".into(),
+                        )
+                    })?;
+                    starts.push(start);
                 }
-                // start = r[i] + c, and c < dim = d[i] - r[i] - l[i] + 1,
-                // so start + l[i] <= d[i] is guaranteed by construction.
-                let start = self.release_times[i] + c as u64;
-                starts.push(start);
-            }
-
-            // Check no two tasks overlap
-            for i in 0..n {
-                for j in (i + 1)..n {
-                    let end_i = starts[i] + self.lengths[i];
-                    let end_j = starts[j] + self.lengths[j];
-                    // Tasks overlap if neither finishes before the other starts
-                    if !(end_i <= starts[j] || end_j <= starts[i]) {
-                        return crate::types::Or(false);
+                let ends = starts
+                    .iter()
+                    .zip(&self.lengths)
+                    .map(|(&start, &length)| {
+                        start.checked_add(length).ok_or_else(|| {
+                            crate::traits::EvaluationError::IntegerOverflow(
+                                "computing a sequencing task end".into(),
+                            )
+                        })
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+
+                // Check no two tasks overlap
+                for i in 0..n {
+                    for j in (i + 1)..n {
+                        // Tasks overlap if neither finishes before the other starts
+                        if !(ends[i] <= starts[j] || ends[j] <= starts[i]) {
+                            return Ok(crate::types::Or(false));
+                        }
                     }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for SequencingWithinIntervals {
+    fn dimensions(&self) -> Vec<usize> {
+        self.start_slot_counts().collect()
+    }
+}
+
 crate::declare_variants! {
-    default SequencingWithinIntervals => "2^num_tasks",
+    default SequencingWithinIntervals => "2^num_tasks" create SequencingWithinIntervalsCreateSpec,
+}
+
+crate::register_brute_force! {
+    SequencingWithinIntervals,
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "sequencing_within_intervals",
-        instance: Box::new(SequencingWithinIntervals::new(
-            vec![0, 1, 3, 6, 0],
-            vec![5, 8, 9, 12, 12],
-            vec![2, 2, 2, 3, 2],
-        )),
-        optimal_config: vec![0, 1, 1, 0, 9],
+        instance: Box::new(
+            SequencingWithinIntervals::new(
+                vec![0, 1, 3, 6, 0],
+                vec![5, 8, 9, 12, 12],
+                vec![2, 2, 2, 3, 2],
+            )
+            .expect("canonical sequencing-within-intervals instance must be valid"),
+        ),
+        optimal_config: serde_json::json!(vec![0, 1, 1, 0, 9]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/shortest_common_supersequence.rs b/src/models/misc/shortest_common_supersequence.rs
index b6d6bafee..b158a5347 100644
--- a/src/models/misc/shortest_common_supersequence.rs
+++ b/src/models/misc/shortest_common_supersequence.rs
@@ -6,13 +6,12 @@
 //! characters from `w`).
 //!
 //! The configuration uses a fixed-length representation of `max_length`
-//! symbols from `{0, ..., alphabet_size}`, where `alphabet_size` serves as a
-//! padding/end symbol. The effective supersequence is the prefix before the
-//! first padding symbol. `max_length` equals the sum of all input string
-//! lengths (the worst case where no overlap exists). This problem is NP-hard
-//! (Maier, 1978).
+//! optional symbols. `None` serves as padding/end marker, and the effective
+//! supersequence is the prefix before the first `None`. `max_length` equals
+//! the sum of all input string lengths (the worst case where no overlap
+//! exists). This problem is NP-hard (Maier, 1978).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -23,13 +22,10 @@ inventory::submit! {
         display_name: "Shortest Common Supersequence",
         aliases: &["SCS"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a shortest common supersequence for a set of strings",
-        fields: &[
-            FieldInfo { name: "alphabet_size", type_name: "usize", description: "Size of the alphabet" },
-            FieldInfo { name: "strings", type_name: "Vec<Vec<usize>>", description: "Input strings over the alphabet {0, ..., alphabet_size-1}" },
-            FieldInfo { name: "max_length", type_name: "usize", description: "Maximum possible supersequence length (sum of all string lengths)" },
-        ],
+        fields: ShortestCommonSupersequenceCreateSpec::FIELDS,
     }
 }
 
@@ -41,21 +37,21 @@ inventory::submit! {
 ///
 /// # Representation
 ///
-/// The configuration is a vector of length `max_length`, where each entry is a
-/// symbol in `{0, ..., alphabet_size}`. The value `alphabet_size` acts as a
-/// padding/end symbol. The effective supersequence is the prefix of
-/// non-padding symbols. Padding must be contiguous at the end.
+/// The configuration is a vector of length `max_length`, where each entry is
+/// either a symbol in `{0, ..., alphabet_size - 1}` or `None` as padding. The
+/// effective supersequence is the prefix of symbols before the first padding
+/// value. Padding must be contiguous at the end.
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::misc::ShortestCommonSupersequence;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Alphabet {0, 1}, strings [0,1] and [1,0]
 /// let problem = ShortestCommonSupersequence::new(2, vec![vec![0, 1], vec![1, 0]]);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -65,6 +61,48 @@ pub struct ShortestCommonSupersequence {
     max_length: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct ShortestCommonSupersequenceCreateSpec {
+    /// Input strings; the alphabet and maximum length are inferred from them.
+    #[create(codec = "semicolon-separated")]
+    strings: Vec<Vec<usize>>,
+}
+
+impl TryFrom<ShortestCommonSupersequenceCreateSpec> for ShortestCommonSupersequence {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: ShortestCommonSupersequenceCreateSpec) -> Result<Self, Self::Error> {
+        if spec.strings.is_empty() {
+            return Err("must have at least one string".to_string().into());
+        }
+
+        let alphabet_size = spec
+            .strings
+            .iter()
+            .flatten()
+            .copied()
+            .max()
+            .map(|symbol| {
+                symbol
+                    .checked_add(1)
+                    .ok_or_else(|| "alphabet size overflows usize".to_string())
+            })
+            .transpose()?
+            .unwrap_or(0);
+        let max_length = spec.strings.iter().try_fold(0_usize, |total, string| {
+            total
+                .checked_add(string.len())
+                .ok_or_else(|| "maximum supersequence length overflows usize".to_string())
+        })?;
+
+        Ok(Self {
+            alphabet_size,
+            strings: spec.strings,
+            max_length,
+        })
+    }
+}
+
 impl ShortestCommonSupersequence {
     /// Create a new ShortestCommonSupersequence instance.
     ///
@@ -133,53 +171,84 @@ fn is_subsequence(needle: &[usize], haystack: &[usize]) -> bool {
 
 impl Problem for ShortestCommonSupersequence {
     const NAME: &'static str = "ShortestCommonSupersequence";
-    type Value = Min<usize>;
+    type Solution = Vec<Option<usize>>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("alphabet_size", alphabet_size),
+        ("max_length", max_length),
+        ("total_length", total_length),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.alphabet_size + 1; self.max_length]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         if config.len() != self.max_length {
-            return Min(None);
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "supersequence representation length does not match the bound".into(),
+            ));
         }
-
-        let pad = self.alphabet_size;
-
-        // Find effective length = index of first padding symbol
-        let effective_length = config
+        if config
+            .iter()
+            .any(|symbol| symbol.is_some_and(|value| value >= self.alphabet_size))
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "supersequence contains an out-of-range symbol".into(),
+            ));
+        }
+        let config = config
             .iter()
-            .position(|&v| v == pad)
-            .unwrap_or(self.max_length);
+            .map(|symbol| symbol.unwrap_or(self.alphabet_size))
+            .collect::<Vec<_>>();
+        Ok({
+            let pad = self.alphabet_size;
+
+            // Find effective length = index of first padding symbol
+            let effective_length = config
+                .iter()
+                .position(|&v| v == pad)
+                .unwrap_or(self.max_length);
 
-        // Verify all positions after first padding are also padding (no interleaved padding)
-        for &v in &config[effective_length..] {
-            if v != pad {
-                return Min(None);
+            // Verify all positions after first padding are also padding (no interleaved padding)
+            for &v in &config[effective_length..] {
+                if v != pad {
+                    return Ok(Min(None));
+                }
             }
-        }
 
-        // Check all symbols in the prefix are valid (0..alphabet_size)
-        let prefix = &config[..effective_length];
-        if prefix.iter().any(|&v| v >= self.alphabet_size) {
-            return Min(None);
-        }
+            let prefix = &config[..effective_length];
 
-        // Check every input string is a subsequence of the prefix
-        if !self.strings.iter().all(|s| is_subsequence(s, prefix)) {
-            return Min(None);
-        }
+            // Check every input string is a subsequence of the prefix
+            if !self.strings.iter().all(|s| is_subsequence(s, prefix)) {
+                return Ok(Min(None));
+            }
+
+            Min(Some(i64::try_from(effective_length).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting supersequence length to i64".into(),
+                )
+            })?))
+        })
+    }
+}
 
-        Min(Some(effective_length))
+impl crate::solvers::BruteForceProblem for ShortestCommonSupersequence {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.alphabet_size + 1; self.max_length]
     }
 }
 
 crate::declare_variants! {
-    default ShortestCommonSupersequence => "(alphabet_size + 1) ^ max_length",
+    default ShortestCommonSupersequence => "(alphabet_size + 1) ^ max_length" create ShortestCommonSupersequenceCreateSpec,
+}
+
+crate::register_brute_force! {
+    ShortestCommonSupersequence decode |problem: &ShortestCommonSupersequence, indices: Vec<usize>| indices.into_iter().map(|value| (value != problem.alphabet_size()).then_some(value)).collect(),
 }
 
 #[cfg(feature = "example-db")]
@@ -193,7 +262,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             2,
             vec![vec![0, 1], vec![1, 0]],
         )),
-        optimal_config: vec![0, 1, 0, 2],
+        optimal_config: serde_json::json!(vec![Some(0), Some(1), Some(0), None]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/misc/shortest_common_superstring.rs b/src/models/misc/shortest_common_superstring.rs
index 9aabc97d2..81fee2a1c 100644
--- a/src/models/misc/shortest_common_superstring.rs
+++ b/src/models/misc/shortest_common_superstring.rs
@@ -7,11 +7,10 @@
 //! `ShortestCommonSupersequence`.
 //!
 //! The configuration uses a fixed-length representation of `max_length`
-//! symbols from `{0, ..., alphabet_size}`, where `alphabet_size` serves as a
-//! padding/end symbol. The effective superstring is the prefix before the
-//! first padding symbol. `max_length` equals the sum of all input string
-//! lengths (the worst case where no overlap exists). This problem is
-//! NP-complete (Maier and Storer, 1977).
+//! optional symbols. `None` serves as padding/end marker, and the effective
+//! superstring is the prefix before the first `None`. `max_length` equals the
+//! sum of all input string lengths (the worst case where no overlap exists).
+//! This problem is NP-complete (Maier and Storer, 1977).
 //!
 //! Reference: Garey & Johnson, *Computers and Intractability*, problem SR9
 //! (P157).
@@ -27,6 +26,7 @@ inventory::submit! {
         display_name: "Shortest Common Superstring",
         aliases: &["SCSS"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a shortest string that contains every input string as a contiguous substring",
         fields: &[
@@ -45,21 +45,21 @@ inventory::submit! {
 ///
 /// # Representation
 ///
-/// The configuration is a vector of length `max_length`, where each entry is a
-/// symbol in `{0, ..., alphabet_size}`. The value `alphabet_size` acts as a
-/// padding/end symbol. The effective superstring is the prefix of
-/// non-padding symbols. Padding must be contiguous at the end.
+/// The configuration is a vector of length `max_length`, where each entry is
+/// either a symbol in `{0, ..., alphabet_size - 1}` or `None` as padding. The
+/// effective superstring is the prefix of symbols before the first padding
+/// value. Padding must be contiguous at the end.
 ///
 /// # Example
 ///
 /// ```
 /// use problemreductions::models::misc::ShortestCommonSuperstring;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Alphabet {0, 1}, strings [0,1] and [1,0]
 /// let problem = ShortestCommonSuperstring::new(2, vec![vec![0, 1], vec![1, 0]]);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -134,48 +134,76 @@ fn is_substring(needle: &[usize], haystack: &[usize]) -> bool {
 
 impl Problem for ShortestCommonSuperstring {
     const NAME: &'static str = "ShortestCommonSuperstring";
-    type Value = Min<usize>;
+    type Solution = Vec<Option<usize>>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("alphabet_size", alphabet_size),
+        ("num_strings", num_strings),
+        ("max_length", max_length),
+        ("total_length", total_length),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.alphabet_size + 1; self.max_length]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
         if config.len() != self.max_length {
-            return Min(None);
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "superstring representation length does not match the bound".into(),
+            ));
         }
-
-        let pad = self.alphabet_size;
-
-        // Find effective length = index of first padding symbol
-        let effective_length = config
+        if config
             .iter()
-            .position(|&v| v == pad)
-            .unwrap_or(self.max_length);
-
-        // Verify all positions after first padding are also padding (no interleaved padding)
-        for &v in &config[effective_length..] {
-            if v != pad {
-                return Min(None);
-            }
+            .any(|symbol| symbol.is_some_and(|value| value >= self.alphabet_size))
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "superstring contains an out-of-range symbol".into(),
+            ));
         }
+        let config = config
+            .iter()
+            .map(|symbol| symbol.unwrap_or(self.alphabet_size))
+            .collect::<Vec<_>>();
+        Ok({
+            let pad = self.alphabet_size;
+
+            // Find effective length = index of first padding symbol
+            let effective_length = config
+                .iter()
+                .position(|&v| v == pad)
+                .unwrap_or(self.max_length);
+
+            // Verify all positions after first padding are also padding (no interleaved padding)
+            for &v in &config[effective_length..] {
+                if v != pad {
+                    return Ok(Min(None));
+                }
+            }
 
-        // Check all symbols in the prefix are valid (0..alphabet_size)
-        let prefix = &config[..effective_length];
-        if prefix.iter().any(|&v| v >= self.alphabet_size) {
-            return Min(None);
-        }
+            let prefix = &config[..effective_length];
 
-        // Check every input string appears as a contiguous substring of the prefix
-        if !self.strings.iter().all(|s| is_substring(s, prefix)) {
-            return Min(None);
-        }
+            // Check every input string appears as a contiguous substring of the prefix
+            if !self.strings.iter().all(|s| is_substring(s, prefix)) {
+                return Ok(Min(None));
+            }
 
-        Min(Some(effective_length))
+            Min(Some(i64::try_from(effective_length).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting superstring length to i64".into(),
+                )
+            })?))
+        })
+    }
+}
+
+impl crate::solvers::BruteForceProblem for ShortestCommonSuperstring {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.alphabet_size + 1; self.max_length]
     }
 }
 
@@ -183,6 +211,10 @@ crate::declare_variants! {
     default ShortestCommonSuperstring => "num_strings ^ 2 * 2 ^ num_strings",
 }
 
+crate::register_brute_force! {
+    ShortestCommonSuperstring decode |problem: &ShortestCommonSuperstring, indices: Vec<usize>| indices.into_iter().map(|value| (value != problem.alphabet_size()).then_some(value)).collect(),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // Alphabet {0, 1}, strings [0,1] and [1,0].
@@ -195,7 +227,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             2,
             vec![vec![0, 1], vec![1, 0]],
         )),
-        optimal_config: vec![0, 1, 0, 2],
+        optimal_config: serde_json::json!(vec![Some(0), Some(1), Some(0), None]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/misc/square_tiling.rs b/src/models/misc/square_tiling.rs
index fe27d4a3a..4f8b4b951 100644
--- a/src/models/misc/square_tiling.rs
+++ b/src/models/misc/square_tiling.rs
@@ -5,7 +5,7 @@
 //! exists a tiling of an N x N grid using tiles from T such that adjacent tiles
 //! have matching edge colors. Tiles may be reused but not rotated or reflected.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{FieldInfo, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "Square Tiling",
         aliases: &["WangTiling"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Place colored square tiles on an N x N grid with matching edge colors",
         fields: &[
@@ -27,13 +28,6 @@ inventory::submit! {
     }
 }
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "SquareTiling",
-        fields: &["num_colors", "num_tiles", "grid_size"],
-    }
-}
-
 /// A tile with four colored edges: (top, right, bottom, left).
 /// Each color is an index in `0..num_colors`.
 pub type Tile = (usize, usize, usize, usize);
@@ -46,15 +40,21 @@ pub struct SquareTiling {
 }
 
 impl SquareTiling {
-    fn validate_inputs(num_colors: usize, tiles: &[Tile], grid_size: usize) -> Result<(), String> {
+    fn validate_inputs(
+        num_colors: usize,
+        tiles: &[Tile],
+        grid_size: usize,
+    ) -> Result<(), crate::registry::ConstructionError> {
         if num_colors == 0 {
-            return Err("SquareTiling requires at least one color".to_string());
+            return Err("SquareTiling requires at least one color"
+                .to_string()
+                .into());
         }
         if tiles.is_empty() {
-            return Err("SquareTiling requires at least one tile".to_string());
+            return Err("SquareTiling requires at least one tile".to_string().into());
         }
         if grid_size == 0 {
-            return Err("SquareTiling requires grid_size >= 1".to_string());
+            return Err("SquareTiling requires grid_size >= 1".to_string().into());
         }
         for (i, &(top, right, bottom, left)) in tiles.iter().enumerate() {
             if top >= num_colors
@@ -62,17 +62,20 @@ impl SquareTiling {
                 || bottom >= num_colors
                 || left >= num_colors
             {
-                return Err(format!(
-                    "Tile {} has color(s) out of range 0..{}",
-                    i, num_colors
-                ));
+                return Err(
+                    format!("Tile {} has color(s) out of range 0..{}", i, num_colors).into(),
+                );
             }
         }
         Ok(())
     }
 
     /// Create a new `SquareTiling` instance, returning an error if inputs are invalid.
-    pub fn try_new(num_colors: usize, tiles: Vec<Tile>, grid_size: usize) -> Result<Self, String> {
+    pub fn try_new(
+        num_colors: usize,
+        tiles: Vec<Tile>,
+        grid_size: usize,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate_inputs(num_colors, &tiles, grid_size)?;
         Ok(Self {
             num_colors,
@@ -174,18 +177,38 @@ impl<'de> Deserialize<'de> for SquareTiling {
 
 impl Problem for SquareTiling {
     const NAME: &'static str = "SquareTiling";
+    type Solution = Vec<usize>;
     type Value = Or;
 
+    crate::problem_parameters![
+        ("grid_size", grid_size),
+        ("num_colors", num_colors),
+        ("num_tiles", num_tiles),
+    ];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.tiles.len(); self.grid_size * self.grid_size]
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        let n = self.grid_size;
+        if config.len() != n * n {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "tiling representation length does not match the grid".into(),
+            ));
+        }
+        if config.iter().any(|&tile| tile >= self.tiles.len()) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "tiling contains an out-of-range tile".into(),
+            ));
+        }
+        Ok(Or(self.is_valid_tiling(config)))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or(self.is_valid_tiling(config))
+impl crate::solvers::BruteForceProblem for SquareTiling {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.tiles.len(); self.grid_size * self.grid_size]
     }
 }
 
@@ -193,6 +216,10 @@ crate::declare_variants! {
     default SquareTiling => "num_tiles^(grid_size^2)",
 }
 
+crate::register_brute_force! {
+    SquareTiling,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -202,7 +229,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![(0, 1, 2, 0), (0, 0, 2, 1), (2, 1, 0, 0), (2, 0, 0, 1)],
             2,
         )),
-        optimal_config: vec![0, 1, 2, 3],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 3]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/stacker_crane.rs b/src/models/misc/stacker_crane.rs
index e1b835d28..6d56ca1b8 100644
--- a/src/models/misc/stacker_crane.rs
+++ b/src/models/misc/stacker_crane.rs
@@ -4,7 +4,7 @@
 //! walk that traverses every required arc in some order and minimizes the
 //! total route length.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -17,15 +17,10 @@ inventory::submit! {
         display_name: "Stacker Crane",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a closed walk that traverses each required directed arc and minimizes total length",
-        fields: &[
-            FieldInfo { name: "num_vertices", type_name: "usize", description: "Number of vertices in the mixed graph" },
-            FieldInfo { name: "arcs", type_name: "Vec<(usize, usize)>", description: "Required directed arcs that must be traversed" },
-            FieldInfo { name: "edges", type_name: "Vec<(usize, usize)>", description: "Undirected edges available for connector paths" },
-            FieldInfo { name: "arc_lengths", type_name: "Vec<i32>", description: "Nonnegative lengths of the required directed arcs" },
-            FieldInfo { name: "edge_lengths", type_name: "Vec<i32>", description: "Nonnegative lengths of the undirected connector edges" },
-        ],
+        fields: StackerCraneCreateSpec::FIELDS,
     }
 }
 
@@ -42,8 +37,90 @@ pub struct StackerCrane {
     num_vertices: usize,
     arcs: Vec<(usize, usize)>,
     edges: Vec<(usize, usize)>,
-    arc_lengths: Vec<i32>,
-    edge_lengths: Vec<i32>,
+    arc_lengths: Vec<i64>,
+    edge_lengths: Vec<i64>,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct StackerCraneCreateSpec {
+    /// Required directed arcs.
+    #[create(codec = "arc-list")]
+    arcs: Vec<(usize, usize)>,
+    /// Undirected connector edges.
+    #[create(name = "graph", codec = "edge-list")]
+    edges: Vec<(usize, usize)>,
+    /// Vertex count, needed to preserve isolated vertices.
+    num_vertices: Option<usize>,
+    /// Required-arc lengths; defaults to one per arc.
+    #[create(codec = "comma-separated")]
+    arc_lengths: Option<Vec<i64>>,
+    /// Connector-edge lengths; defaults to one per edge.
+    #[create(codec = "comma-separated")]
+    edge_lengths: Option<Vec<i64>>,
+}
+
+impl TryFrom<StackerCraneCreateSpec> for StackerCrane {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: StackerCraneCreateSpec) -> Result<Self, Self::Error> {
+        if spec.arcs.is_empty() {
+            return Err("arcs must be non-empty".to_string().into());
+        }
+        if spec.edges.is_empty() && spec.num_vertices.is_none() {
+            return Err("num_vertices is required for an empty graph"
+                .to_string()
+                .into());
+        }
+        for (index, &(u, v)) in spec.edges.iter().enumerate() {
+            if u == v {
+                return Err(format!("graph edge {index} is a self-loop at vertex {u}").into());
+            }
+        }
+        let inferred_arcs = inferred_vertex_count(&spec.arcs)?;
+        let inferred_edges = inferred_vertex_count(&spec.edges)?;
+        let num_vertices = match spec.num_vertices {
+            Some(count) => count,
+            None if inferred_arcs == inferred_edges => inferred_arcs,
+            None => {
+                return Err(format!(
+                    "directed and undirected inputs infer different vertex counts ({inferred_arcs} and {inferred_edges}); provide num_vertices"
+                ).into())
+            }
+        };
+        if num_vertices < inferred_arcs || num_vertices < inferred_edges {
+            return Err(format!(
+                "num_vertices {num_vertices} is too small for the provided endpoints"
+            )
+            .into());
+        }
+        let arc_lengths = spec.arc_lengths.unwrap_or_else(|| vec![1; spec.arcs.len()]);
+        let edge_lengths = spec
+            .edge_lengths
+            .unwrap_or_else(|| vec![1; spec.edges.len()]);
+        Self::try_new(
+            num_vertices,
+            spec.arcs,
+            spec.edges,
+            arc_lengths,
+            edge_lengths,
+        )
+    }
+}
+
+fn inferred_vertex_count(
+    pairs: &[(usize, usize)],
+) -> Result<usize, crate::registry::ConstructionError> {
+    Ok(pairs
+        .iter()
+        .flat_map(|&(u, v)| [u, v])
+        .max()
+        .map(|vertex| {
+            vertex
+                .checked_add(1)
+                .ok_or("vertex count overflows usize".to_string())
+        })
+        .transpose()
+        .map(|count| count.unwrap_or(0))?)
 }
 
 impl StackerCrane {
@@ -57,8 +134,8 @@ impl StackerCrane {
         num_vertices: usize,
         arcs: Vec<(usize, usize)>,
         edges: Vec<(usize, usize)>,
-        arc_lengths: Vec<i32>,
-        edge_lengths: Vec<i32>,
+        arc_lengths: Vec<i64>,
+        edge_lengths: Vec<i64>,
     ) -> Self {
         Self::try_new(num_vertices, arcs, edges, arc_lengths, edge_lengths)
             .unwrap_or_else(|message| panic!("{message}"))
@@ -69,37 +146,43 @@ impl StackerCrane {
         num_vertices: usize,
         arcs: Vec<(usize, usize)>,
         edges: Vec<(usize, usize)>,
-        arc_lengths: Vec<i32>,
-        edge_lengths: Vec<i32>,
-    ) -> Result<Self, String> {
+        arc_lengths: Vec<i64>,
+        edge_lengths: Vec<i64>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         if arc_lengths.len() != arcs.len() {
-            return Err("arc_lengths length must match arcs length".to_string());
+            return Err("arc_lengths length must match arcs length"
+                .to_string()
+                .into());
         }
         if edge_lengths.len() != edges.len() {
-            return Err("edge_lengths length must match edges length".to_string());
+            return Err("edge_lengths length must match edges length"
+                .to_string()
+                .into());
         }
         for (arc_index, &(tail, head)) in arcs.iter().enumerate() {
             if tail >= num_vertices || head >= num_vertices {
                 return Err(format!(
                     "arc {arc_index} endpoint out of range for {num_vertices} vertices"
-                ));
+                )
+                .into());
             }
         }
         for (edge_index, &(u, v)) in edges.iter().enumerate() {
             if u >= num_vertices || v >= num_vertices {
                 return Err(format!(
                     "edge {edge_index} endpoint out of range for {num_vertices} vertices"
-                ));
+                )
+                .into());
             }
         }
         for (arc_index, &length) in arc_lengths.iter().enumerate() {
             if length < 0 {
-                return Err(format!("arc length {arc_index} must be nonnegative"));
+                return Err(format!("arc length {arc_index} must be nonnegative").into());
             }
         }
         for (edge_index, &length) in edge_lengths.iter().enumerate() {
             if length < 0 {
-                return Err(format!("edge length {edge_index} must be nonnegative"));
+                return Err(format!("edge length {edge_index} must be nonnegative").into());
             }
         }
 
@@ -128,12 +211,12 @@ impl StackerCrane {
     }
 
     /// Get the required arc lengths.
-    pub fn arc_lengths(&self) -> &[i32] {
+    pub fn arc_lengths(&self) -> &[i64] {
         &self.arc_lengths
     }
 
     /// Get the undirected edge lengths.
-    pub fn edge_lengths(&self) -> &[i32] {
+    pub fn edge_lengths(&self) -> &[i64] {
         &self.edge_lengths
     }
 
@@ -163,7 +246,7 @@ impl StackerCrane {
         true
     }
 
-    fn mixed_graph_adjacency(&self) -> Vec<Vec<(usize, i32)>> {
+    fn mixed_graph_adjacency(&self) -> Vec<Vec<(usize, i64)>> {
         let mut adjacency = vec![Vec::new(); self.num_vertices];
 
         for (&(tail, head), &length) in self.arcs.iter().zip(&self.arc_lengths) {
@@ -180,7 +263,7 @@ impl StackerCrane {
 
     fn shortest_path_length(
         &self,
-        adjacency: &[Vec<(usize, i32)>],
+        adjacency: &[Vec<(usize, i64)>],
         source: usize,
         target: usize,
     ) -> Option<i64> {
@@ -202,7 +285,7 @@ impl StackerCrane {
             }
 
             for &(next, length) in &adjacency[node] {
-                let next_cost = cost.checked_add(i64::from(length))?;
+                let next_cost = cost.checked_add(length)?;
                 if next_cost < dist[next] {
                     dist[next] = next_cost;
                     heap.push((Reverse(next_cost), next));
@@ -217,7 +300,7 @@ impl StackerCrane {
     ///
     /// Returns `None` for invalid permutations, unreachable connector paths,
     /// or arithmetic overflow.
-    pub fn closed_walk_length(&self, config: &[usize]) -> Option<i32> {
+    pub fn closed_walk_length(&self, config: &[usize]) -> Option<i64> {
         if !self.is_arc_permutation(config) {
             return None;
         }
@@ -234,7 +317,7 @@ impl StackerCrane {
             let (_, arc_head) = self.arcs[arc_index];
             let (next_arc_tail, _) = self.arcs[next_arc_index];
 
-            total = total.checked_add(i64::from(self.arc_lengths[arc_index]))?;
+            total = total.checked_add(self.arc_lengths[arc_index])?;
             total = total.checked_add(self.shortest_path_length(
                 &adjacency,
                 arc_head,
@@ -242,32 +325,60 @@ impl StackerCrane {
             )?)?;
         }
 
-        i32::try_from(total).ok()
+        Some(total)
     }
 }
 
 impl Problem for StackerCrane {
     const NAME: &'static str = "StackerCrane";
-    type Value = Min<i32>;
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![
+        ("num_arcs", num_arcs),
+        ("num_edges", num_edges),
+        ("num_vertices", num_vertices),
+    ];
 
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_arcs(); self.num_arcs()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.num_arcs() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "arc ordering length does not match the required arcs".into(),
+            ));
+        }
+        if config.iter().any(|&arc| arc >= self.num_arcs()) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "arc ordering contains an out-of-range arc".into(),
+            ));
+        }
+        Ok({
+            match self.closed_walk_length(config) {
+                Some(total) => Min(Some(total)),
+                None => Min(None),
+            }
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<i32> {
-        match self.closed_walk_length(config) {
-            Some(total) => Min(Some(total)),
-            None => Min(None),
-        }
+impl crate::solvers::BruteForceProblem for StackerCrane {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_arcs(); self.num_arcs()]
     }
 }
 
 crate::declare_variants! {
-    default StackerCrane => "num_vertices^2 * 2^num_arcs",
+    default StackerCrane => "num_vertices^2 * 2^num_arcs" create StackerCraneCreateSpec,
+}
+
+crate::register_brute_force! {
+    StackerCrane,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -275,12 +386,12 @@ struct StackerCraneDef {
     num_vertices: usize,
     arcs: Vec<(usize, usize)>,
     edges: Vec<(usize, usize)>,
-    arc_lengths: Vec<i32>,
-    edge_lengths: Vec<i32>,
+    arc_lengths: Vec<i64>,
+    edge_lengths: Vec<i64>,
 }
 
 impl TryFrom<StackerCraneDef> for StackerCrane {
-    type Error = String;
+    type Error = crate::registry::ConstructionError;
 
     fn try_from(value: StackerCraneDef) -> Result<Self, Self::Error> {
         Self::try_new(
@@ -304,7 +415,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![3, 4, 2, 5, 3],
             vec![2, 1, 3, 2, 1, 4, 3],
         )),
-        optimal_config: vec![0, 2, 1, 4, 3],
+        optimal_config: serde_json::json!(vec![0, 2, 1, 4, 3]),
         optimal_value: serde_json::json!(20),
     }]
 }
diff --git a/src/models/misc/staff_scheduling.rs b/src/models/misc/staff_scheduling.rs
index 7db6f75be..1d5d60a0d 100644
--- a/src/models/misc/staff_scheduling.rs
+++ b/src/models/misc/staff_scheduling.rs
@@ -4,7 +4,7 @@
 //! worker budget, determine whether workers can be assigned to schedules so that
 //! all requirements are met without exceeding the budget.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,14 +14,10 @@ inventory::submit! {
         display_name: "Staff Scheduling",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Assign workers to schedule patterns to satisfy per-period staffing requirements within a worker budget",
-        fields: &[
-            FieldInfo { name: "shifts_per_schedule", type_name: "usize", description: "Required number of active periods in each schedule pattern" },
-            FieldInfo { name: "schedules", type_name: "Vec<Vec<bool>>", description: "Binary schedule patterns available to workers" },
-            FieldInfo { name: "requirements", type_name: "Vec<u64>", description: "Minimum staffing requirement for each period" },
-            FieldInfo { name: "num_workers", type_name: "u64", description: "Maximum number of workers available" },
-        ],
+        fields: StaffSchedulingCreateSpec::FIELDS,
     }
 }
 
@@ -34,8 +30,60 @@ inventory::submit! {
 pub struct StaffScheduling {
     shifts_per_schedule: usize,
     schedules: Vec<Vec<bool>>,
-    requirements: Vec<u64>,
-    num_workers: u64,
+    requirements: Vec<i64>,
+    num_workers: i64,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct StaffSchedulingCreateSpec {
+    /// Required number of active periods in each schedule pattern.
+    k: usize,
+    /// Binary schedule patterns available to workers.
+    schedules: Vec<Vec<bool>>,
+    /// Minimum staffing requirement for each period.
+    requirements: Vec<i64>,
+    /// Maximum number of workers available.
+    num_workers: i64,
+}
+
+impl TryFrom<StaffSchedulingCreateSpec> for StaffScheduling {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: StaffSchedulingCreateSpec) -> Result<Self, Self::Error> {
+        if usize::try_from(spec.num_workers)
+            .ok()
+            .and_then(|workers| workers.checked_add(1))
+            .is_none()
+        {
+            return Err("num_workers must be nonnegative and encodable by dims()"
+                .to_string()
+                .into());
+        }
+        for (schedule_index, schedule) in spec.schedules.iter().enumerate() {
+            if schedule.len() != spec.requirements.len() {
+                return Err(format!(
+                    "schedules[{schedule_index}] has {} periods, expected {}",
+                    schedule.len(),
+                    spec.requirements.len()
+                )
+                .into());
+            }
+            let active_periods = schedule.iter().filter(|&&active| active).count();
+            if active_periods != spec.k {
+                return Err(format!(
+                    "schedules[{schedule_index}] has {active_periods} active periods, expected {}",
+                    spec.k
+                )
+                .into());
+            }
+        }
+        Ok(Self::new(
+            spec.k,
+            spec.schedules,
+            spec.requirements,
+            spec.num_workers,
+        ))
+    }
 }
 
 impl StaffScheduling {
@@ -50,12 +98,15 @@ impl StaffScheduling {
     pub fn new(
         shifts_per_schedule: usize,
         schedules: Vec<Vec<bool>>,
-        requirements: Vec<u64>,
-        num_workers: u64,
+        requirements: Vec<i64>,
+        num_workers: i64,
     ) -> Self {
         assert!(
-            num_workers < usize::MAX as u64,
-            "num_workers must fit in usize so dims() can encode 0..=num_workers"
+            usize::try_from(num_workers)
+                .ok()
+                .and_then(|workers| workers.checked_add(1))
+                .is_some(),
+            "num_workers must be nonnegative and encodable by dims()"
         );
 
         let num_periods = requirements.len();
@@ -100,12 +151,12 @@ impl StaffScheduling {
     }
 
     /// Get the staffing requirements.
-    pub fn requirements(&self) -> &[u64] {
+    pub fn requirements(&self) -> &[i64] {
         &self.requirements
     }
 
     /// Get the worker budget.
-    pub fn num_workers(&self) -> u64 {
+    pub fn num_workers(&self) -> i64 {
         self.num_workers
     }
 
@@ -115,55 +166,86 @@ impl StaffScheduling {
     }
 
     fn worker_limit(&self) -> usize {
-        self.num_workers as usize
+        usize::try_from(self.num_workers)
+            .expect("validated nonnegative worker count must fit usize")
     }
 
     fn worker_counts_valid(&self, config: &[usize]) -> bool {
         config.iter().all(|&count| count <= self.worker_limit())
     }
 
-    fn within_budget(&self, config: &[usize]) -> bool {
-        config.iter().map(|&count| count as u128).sum::<u128>() <= self.num_workers as u128
+    fn within_budget(&self, config: &[usize]) -> Result<bool, crate::traits::EvaluationError> {
+        let total = config.iter().try_fold(0_i64, |total, &count| {
+            let count = i64::try_from(count).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting assigned worker count to i64".into(),
+                )
+            })?;
+            total.checked_add(count).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing assigned worker counts".into(),
+                )
+            })
+        })?;
+        Ok(total <= self.num_workers)
     }
 
-    fn meets_requirements(&self, config: &[usize]) -> bool {
-        let mut coverage = vec![0u128; self.num_periods()];
+    fn meets_requirements(&self, config: &[usize]) -> Result<bool, crate::traits::EvaluationError> {
+        let mut coverage = vec![0_i64; self.num_periods()];
 
         for (count, schedule) in config.iter().zip(&self.schedules) {
             if *count == 0 {
                 continue;
             }
-            let count = *count as u128;
+            let count = i64::try_from(*count).map_err(|_| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "converting scheduled worker count to i64".into(),
+                )
+            })?;
             for (period, active) in schedule.iter().enumerate() {
                 if *active {
-                    coverage[period] += count;
+                    coverage[period] = coverage[period].checked_add(count).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing staffing coverage".into(),
+                        )
+                    })?;
                 }
             }
         }
 
-        coverage
+        Ok(coverage
             .iter()
             .zip(&self.requirements)
-            .all(|(covered, required)| *covered >= *required as u128)
+            .all(|(covered, required)| covered >= required))
     }
 }
 
 impl Problem for StaffScheduling {
     const NAME: &'static str = "StaffScheduling";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.worker_limit() + 1; self.num_schedules()]
-    }
+    crate::problem_parameters![
+        ("num_periods", num_periods),
+        ("num_schedules", num_schedules),
+        ("num_workers", num_workers),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_schedules() {
-                return crate::types::Or(false);
-            }
-            self.worker_counts_valid(config)
-                && self.within_budget(config)
-                && self.meets_requirements(config)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_schedules() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "staffing vector length does not match the schedules".into(),
+                    ));
+                }
+                self.worker_counts_valid(config)
+                    && self.within_budget(config)?
+                    && self.meets_requirements(config)?
+            })
         })
     }
 
@@ -172,8 +254,18 @@ impl Problem for StaffScheduling {
     }
 }
 
+impl crate::solvers::BruteForceProblem for StaffScheduling {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.worker_limit() + 1; self.num_schedules()]
+    }
+}
+
 crate::declare_variants! {
-    default StaffScheduling => "(num_workers + 1)^num_schedules",
+    default StaffScheduling => "(num_workers + 1)^num_schedules" create StaffSchedulingCreateSpec,
+}
+
+crate::register_brute_force! {
+    StaffScheduling,
 }
 
 #[cfg(feature = "example-db")]
@@ -192,7 +284,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![2, 2, 2, 3, 3, 2, 1],
             4,
         )),
-        optimal_config: vec![1, 1, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![1, 1, 1, 1, 0]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/string_to_string_correction.rs b/src/models/misc/string_to_string_correction.rs
index 30f02a3d0..0343806e8 100644
--- a/src/models/misc/string_to_string_correction.rs
+++ b/src/models/misc/string_to_string_correction.rs
@@ -14,7 +14,7 @@
 //!
 //! This problem is NP-complete (Wagner, 1975).
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -24,14 +24,10 @@ inventory::submit! {
         display_name: "String-to-String Correction",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Derive target string from source using at most K deletions and adjacent swaps",
-        fields: &[
-            FieldInfo { name: "alphabet_size", type_name: "usize", description: "Size of the finite alphabet" },
-            FieldInfo { name: "source", type_name: "Vec<usize>", description: "Source string (symbol indices)" },
-            FieldInfo { name: "target", type_name: "Vec<usize>", description: "Target string (symbol indices)" },
-            FieldInfo { name: "bound", type_name: "usize", description: "Maximum number of operations allowed" },
-        ],
+        fields: StringToStringCorrectionCreateSpec::FIELDS,
     }
 }
 
@@ -61,12 +57,12 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::StringToStringCorrection;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // source = [0,1,2,3,1,0], target = [0,1,3,2,1], bound = 2
 /// let problem = StringToStringCorrection::new(4, vec![0,1,2,3,1,0], vec![0,1,3,2,1], 2);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -77,6 +73,57 @@ pub struct StringToStringCorrection {
     bound: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct StringToStringCorrectionCreateSpec {
+    /// Optional alphabet size; omitted values are inferred from both strings.
+    alphabet_size: Option<usize>,
+    /// Source string.
+    #[create(codec = "comma-separated")]
+    source_string: Vec<usize>,
+    /// Target string.
+    #[create(codec = "comma-separated")]
+    target_string: Vec<usize>,
+    /// Maximum number of correction operations.
+    bound: usize,
+}
+
+impl TryFrom<StringToStringCorrectionCreateSpec> for StringToStringCorrection {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: StringToStringCorrectionCreateSpec) -> Result<Self, Self::Error> {
+        let inferred_alphabet_size = spec
+            .source_string
+            .iter()
+            .chain(&spec.target_string)
+            .copied()
+            .max()
+            .map(|symbol| {
+                symbol
+                    .checked_add(1)
+                    .ok_or_else(|| "inferred alphabet size overflows usize".to_string())
+            })
+            .transpose()?
+            .unwrap_or(0);
+        let alphabet_size = spec.alphabet_size.unwrap_or(inferred_alphabet_size);
+        if alphabet_size < inferred_alphabet_size {
+            return Err(format!(
+                "alphabet size {alphabet_size} is smaller than inferred alphabet size {inferred_alphabet_size}"
+            ).into());
+        }
+        if alphabet_size == 0 && (!spec.source_string.is_empty() || !spec.target_string.is_empty())
+        {
+            return Err("alphabet size must be positive when either string is non-empty".into());
+        }
+
+        Ok(Self {
+            alphabet_size,
+            source: spec.source_string,
+            target: spec.target_string,
+            bound: spec.bound,
+        })
+    }
+}
+
 impl StringToStringCorrection {
     /// Create a new StringToStringCorrection instance.
     ///
@@ -139,59 +186,77 @@ impl StringToStringCorrection {
 
 impl Problem for StringToStringCorrection {
     const NAME: &'static str = "StringToStringCorrection";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("bound", bound), ("source_length", source_length),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2 * self.source.len() + 1; self.bound]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.bound {
-                return crate::types::Or(false);
-            }
-            if self.target.len() > self.source.len()
-                || self.target.len() < self.source.len().saturating_sub(self.bound)
-            {
-                return crate::types::Or(false);
-            }
-            let n = self.source.len();
-            let domain = 2 * n + 1;
-            if config.iter().any(|&v| v >= domain) {
-                return crate::types::Or(false);
-            }
-            let noop = 2 * n;
-            let mut working = self.source.clone();
-            for &op in config {
-                if op == noop {
-                    // no-op
-                    continue;
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.bound {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "edit-program length does not match the operation bound".into(),
+                    ));
                 }
-                let current_len = working.len();
-                if op < current_len {
-                    // delete at index op
-                    working.remove(op);
-                } else {
-                    let swap_pos = op - current_len;
-                    if swap_pos + 1 < current_len {
-                        working.swap(swap_pos, swap_pos + 1);
+                if self.target.len() > self.source.len()
+                    || self.target.len() < self.source.len().saturating_sub(self.bound)
+                {
+                    return Ok(crate::types::Or(false));
+                }
+                let n = self.source.len();
+                let domain = 2 * n + 1;
+                if config.iter().any(|&v| v >= domain) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "edit program contains an out-of-range operation".into(),
+                    ));
+                }
+                let noop = 2 * n;
+                let mut working = self.source.clone();
+                for &op in config {
+                    if op == noop {
+                        // no-op
+                        continue;
+                    }
+                    let current_len = working.len();
+                    if op < current_len {
+                        // delete at index op
+                        working.remove(op);
                     } else {
-                        // invalid operation for current string state
-                        return crate::types::Or(false);
+                        let swap_pos = op - current_len;
+                        if swap_pos + 1 < current_len {
+                            working.swap(swap_pos, swap_pos + 1);
+                        } else {
+                            // invalid operation for current string state
+                            return Ok(crate::types::Or(false));
+                        }
                     }
                 }
-            }
-            working == self.target
+                working == self.target
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for StringToStringCorrection {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2 * self.source.len() + 1; self.bound]
+    }
+}
+
 crate::declare_variants! {
-    default StringToStringCorrection => "(2 * source_length + 1) ^ bound",
+    default StringToStringCorrection => "(2 * source_length + 1) ^ bound" create StringToStringCorrectionCreateSpec,
+}
+
+crate::register_brute_force! {
+    StringToStringCorrection,
 }
 
 #[cfg(feature = "example-db")]
@@ -207,7 +272,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![0, 1, 3, 2, 1],
             2,
         )),
-        optimal_config: vec![8, 5],
+        optimal_config: serde_json::json!(vec![8, 5]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/subset_product.rs b/src/models/misc/subset_product.rs
index b82136ed4..71cd0f4c1 100644
--- a/src/models/misc/subset_product.rs
+++ b/src/models/misc/subset_product.rs
@@ -19,6 +19,7 @@ inventory::submit! {
         display_name: "Subset Product",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a subset of positive integers whose product equals exactly a target value",
         fields: &[
@@ -42,11 +43,11 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::SubsetProduct;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = SubsetProduct::new(vec![2u32, 3, 5, 7, 6, 10], 210u32);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -107,49 +108,62 @@ impl SubsetProduct {
 
 impl Problem for SubsetProduct {
     const NAME: &'static str = "SubsetProduct";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_elements", num_elements),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_elements()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_elements() {
-                return crate::types::Or(false);
-            }
-            if config.iter().any(|&v| v >= 2) {
-                return crate::types::Or(false);
-            }
-            let mut product = BigUint::one();
-            for (i, &x) in config.iter().enumerate() {
-                if x == 1 {
-                    product *= &self.sizes[i];
-                    if product > self.target {
-                        return crate::types::Or(false);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_elements() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "subset-selection length does not match the elements".into(),
+                    ));
+                }
+                let mut product = BigUint::one();
+                for (i, &x) in config.iter().enumerate() {
+                    if x {
+                        product *= &self.sizes[i];
+                        if product > self.target {
+                            return Ok(crate::types::Or(false));
+                        }
                     }
                 }
-            }
-            product == self.target
+                product == self.target
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for SubsetProduct {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_elements()]
+    }
+}
+
 crate::declare_variants! {
     default SubsetProduct => "2^num_elements",
 }
 
+crate::register_brute_force! {
+    SubsetProduct decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 6 elements [2,3,5,7,6,10], target 210 → select {2,3,5,7}
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "subset_product",
         instance: Box::new(SubsetProduct::new(vec![2u32, 3, 5, 7, 6, 10], 210u32)),
-        optimal_config: vec![1, 1, 1, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![true, true, true, true, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/subset_sum.rs b/src/models/misc/subset_sum.rs
index d0346613f..95611a696 100644
--- a/src/models/misc/subset_sum.rs
+++ b/src/models/misc/subset_sum.rs
@@ -19,6 +19,7 @@ inventory::submit! {
         display_name: "Subset Sum",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Find a subset of positive integers that sums to exactly a target value",
         fields: &[
@@ -42,11 +43,11 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::SubsetSum;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// let problem = SubsetSum::new(vec![3u32, 7, 1, 8, 2, 4], 11u32);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -108,46 +109,59 @@ impl SubsetSum {
 
 impl Problem for SubsetSum {
     const NAME: &'static str = "SubsetSum";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
+    crate::problem_parameters![("num_elements", num_elements),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_elements()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.num_elements() {
-                return crate::types::Or(false);
-            }
-            if config.iter().any(|&v| v >= 2) {
-                return crate::types::Or(false);
-            }
-            let mut total = BigUint::zero();
-            for (i, &x) in config.iter().enumerate() {
-                if x == 1 {
-                    total += &self.sizes[i];
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_elements() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "subset-selection length does not match the elements".into(),
+                    ));
+                }
+                let mut total = BigUint::zero();
+                for (i, &x) in config.iter().enumerate() {
+                    if x {
+                        total += &self.sizes[i];
+                    }
                 }
-            }
-            total == self.target
+                total == self.target
+            })
         })
     }
 }
 
+impl crate::solvers::BruteForceProblem for SubsetSum {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_elements()]
+    }
+}
+
 crate::declare_variants! {
     default SubsetSum => "2^(num_elements / 2)",
 }
 
+crate::register_brute_force! {
+    SubsetSum decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     // 6 elements [3,7,1,8,2,4], target 11 → select {3,8}
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "subset_sum",
         instance: Box::new(SubsetSum::new(vec![3u32, 7, 1, 8, 2, 4], 11u32)),
-        optimal_config: vec![1, 0, 0, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![true, false, false, true, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/sum_of_squares_partition.rs b/src/models/misc/sum_of_squares_partition.rs
index 050042bd1..0edae8f31 100644
--- a/src/models/misc/sum_of_squares_partition.rs
+++ b/src/models/misc/sum_of_squares_partition.rs
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Sum of Squares Partition",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Partition positive integers into K groups minimizing the sum of squared group sums",
         fields: &[
@@ -43,12 +44,12 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::misc::SumOfSquaresPartition;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 6 elements with sizes [5, 3, 8, 2, 7, 1], K=3 groups
 /// let problem = SumOfSquaresPartition::new(vec![5, 3, 8, 2, 7, 1], 3);
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize)]
@@ -60,21 +61,29 @@ pub struct SumOfSquaresPartition {
 }
 
 impl SumOfSquaresPartition {
-    fn validate_inputs(sizes: &[i64], num_groups: usize) -> Result<(), String> {
+    fn validate_inputs(
+        sizes: &[i64],
+        num_groups: usize,
+    ) -> Result<(), crate::registry::ConstructionError> {
         if sizes.iter().any(|&size| size <= 0) {
-            return Err("All sizes must be positive (> 0)".to_string());
+            return Err("All sizes must be positive (> 0)".to_string().into());
         }
         if num_groups == 0 {
-            return Err("Number of groups must be positive".to_string());
+            return Err("Number of groups must be positive".to_string().into());
         }
         if num_groups > sizes.len() {
-            return Err("Number of groups must not exceed number of elements".to_string());
+            return Err("Number of groups must not exceed number of elements"
+                .to_string()
+                .into());
         }
         Ok(())
     }
 
     /// Create a new SumOfSquaresPartition instance, returning validation errors.
-    pub fn try_new(sizes: Vec<i64>, num_groups: usize) -> Result<Self, String> {
+    pub fn try_new(
+        sizes: Vec<i64>,
+        num_groups: usize,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate_inputs(&sizes, num_groups)?;
         Ok(Self { sizes, num_groups })
     }
@@ -108,24 +117,37 @@ impl SumOfSquaresPartition {
     ///
     /// Returns `None` if the configuration is invalid (wrong length or
     /// out-of-range group index), or if arithmetic overflows `i64`.
-    pub fn sum_of_squares(&self, config: &[usize]) -> Option<i64> {
+    pub fn sum_of_squares(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<i64>, crate::traits::EvaluationError> {
         if config.len() != self.sizes.len() {
-            return None;
+            return Ok(None);
         }
-        let mut group_sums = vec![0i128; self.num_groups];
+        let mut group_sums = vec![0_i64; self.num_groups];
         for (i, &g) in config.iter().enumerate() {
             if g >= self.num_groups {
-                return None;
+                return Ok(None);
             }
-            group_sums[g] = group_sums[g].checked_add(i128::from(self.sizes[i]))?;
+            group_sums[g] = group_sums[g].checked_add(self.sizes[i]).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing a sum-of-squares partition group".into(),
+                )
+            })?;
         }
-        group_sums
-            .into_iter()
-            .try_fold(0i128, |total, group_sum| {
-                let square = group_sum.checked_mul(group_sum)?;
-                total.checked_add(square)
+        let total = group_sums.into_iter().try_fold(0_i64, |total, group_sum| {
+            let square = group_sum.checked_mul(group_sum).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "squaring a partition group sum".into(),
+                )
+            })?;
+            total.checked_add(square).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing squared partition group sums".into(),
+                )
             })
-            .and_then(|total| i64::try_from(total).ok())
+        })?;
+        Ok(Some(total))
     }
 }
 
@@ -147,18 +169,36 @@ impl<'de> Deserialize<'de> for SumOfSquaresPartition {
 
 impl Problem for SumOfSquaresPartition {
     const NAME: &'static str = "SumOfSquaresPartition";
+    type Solution = Vec<usize>;
     type Value = Min<i64>;
 
+    crate::problem_parameters![("num_elements", num_elements), ("num_groups", num_groups),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_groups; self.sizes.len()]
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        if config.len() != self.sizes.len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "group assignment length does not match the elements".into(),
+            ));
+        }
+        if config.iter().any(|&group| group >= self.num_groups) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "group assignment contains an out-of-range group".into(),
+            ));
+        }
+        Ok(Min(self.sum_of_squares(config)?))
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Min<i64> {
-        Min(self.sum_of_squares(config))
+impl crate::solvers::BruteForceProblem for SumOfSquaresPartition {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_groups; self.sizes.len()]
     }
 }
 
@@ -166,6 +206,10 @@ crate::declare_variants! {
     default SumOfSquaresPartition => "num_groups^num_elements",
 }
 
+crate::register_brute_force! {
+    SumOfSquaresPartition,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -173,7 +217,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         // sizes=[5,3,8,2,7,1], K=3
         // Optimal: groups {8},{2,7},{5,3,1} -> sums 8,9,9 -> 64+81+81=226
         instance: Box::new(SumOfSquaresPartition::new(vec![5, 3, 8, 2, 7, 1], 3)),
-        optimal_config: vec![2, 2, 0, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![2, 2, 0, 1, 1, 0]),
         optimal_value: serde_json::json!(226),
     }]
 }
diff --git a/src/models/misc/three_partition.rs b/src/models/misc/three_partition.rs
index 9131544d4..9a57d336c 100644
--- a/src/models/misc/three_partition.rs
+++ b/src/models/misc/three_partition.rs
@@ -3,7 +3,7 @@
 //! Given 3m positive integers that each lie strictly between B/4 and B/2,
 //! determine whether they can be partitioned into m triples that all sum to B.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Or;
 use serde::de::Error as _;
@@ -15,66 +15,75 @@ inventory::submit! {
         display_name: "3-Partition",
         aliases: &["3Partition", "3-Partition"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Partition 3m bounded positive integers into m triples whose sums all equal B",
-        fields: &[
-            FieldInfo { name: "sizes", type_name: "Vec<u64>", description: "Positive integer sizes s(a) for each element a in A" },
-            FieldInfo { name: "bound", type_name: "u64", description: "Target sum B for each triple" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "ThreePartition",
-        fields: &["num_elements", "num_groups"],
+        fields: ThreePartitionCreateSpec::FIELDS,
     }
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ThreePartition {
-    sizes: Vec<u64>,
-    bound: u64,
+    sizes: Vec<i64>,
+    bound: i64,
 }
 
+type GroupCountsAndSums = (Vec<usize>, Vec<i64>);
+
 impl ThreePartition {
-    fn validate_inputs(sizes: &[u64], bound: u64) -> Result<(), String> {
+    fn validate_inputs(
+        sizes: &[i64],
+        bound: i64,
+    ) -> Result<(), crate::registry::ConstructionError> {
         if sizes.is_empty() {
-            return Err("ThreePartition requires at least one element".to_string());
+            return Err("ThreePartition requires at least one element"
+                .to_string()
+                .into());
         }
         if !sizes.len().is_multiple_of(3) {
             return Err(
-                "ThreePartition requires the number of elements to be a multiple of 3".to_string(),
+                "ThreePartition requires the number of elements to be a multiple of 3".into(),
             );
         }
-        if bound == 0 {
-            return Err("ThreePartition requires a positive bound".to_string());
+        if bound <= 0 {
+            return Err("ThreePartition requires a positive bound"
+                .to_string()
+                .into());
         }
-        if sizes.contains(&0) {
-            return Err("All sizes must be positive (> 0)".to_string());
+        if sizes.iter().any(|&size| size <= 0) {
+            return Err("All sizes must be positive (> 0)".to_string().into());
         }
 
-        let bound128 = u128::from(bound);
         for &size in sizes {
-            let size = u128::from(size);
-            if !(4 * size > bound128 && 2 * size < bound128) {
-                return Err("Every size must lie strictly between B/4 and B/2".to_string());
+            let four_times_size = i128::from(size) * 4;
+            let two_times_size = i128::from(size) * 2;
+            let bound = i128::from(bound);
+            if !(four_times_size > bound && two_times_size < bound) {
+                return Err("Every size must lie strictly between B/4 and B/2"
+                    .to_string()
+                    .into());
             }
         }
 
-        let total_sum: u128 = sizes.iter().map(|&size| u128::from(size)).sum();
-        let expected_sum = u128::from(bound) * (sizes.len() as u128 / 3);
+        let total_sum = sizes
+            .iter()
+            .try_fold(0_i64, |total, &size| total.checked_add(size))
+            .ok_or("total size sum exceeds i64 range")?;
+        let group_count =
+            i64::try_from(sizes.len() / 3).map_err(|_| "group count exceeds i64 range")?;
+        let expected_sum = bound
+            .checked_mul(group_count)
+            .ok_or("group count times bound exceeds i64 range")?;
         if total_sum != expected_sum {
-            return Err("Total sum of sizes must equal m * bound".to_string());
+            return Err("Total sum of sizes must equal m * bound".to_string().into());
         }
-        if total_sum > u128::from(u64::MAX) {
-            return Err("Total sum exceeds u64 range".to_string());
-        }
-
         Ok(())
     }
 
-    pub fn try_new(sizes: Vec<u64>, bound: u64) -> Result<Self, String> {
+    pub fn try_new(
+        sizes: Vec<i64>,
+        bound: i64,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         Self::validate_inputs(&sizes, bound)?;
         Ok(Self { sizes, bound })
     }
@@ -84,15 +93,15 @@ impl ThreePartition {
     /// # Panics
     ///
     /// Panics if the input violates the classical 3-Partition invariants.
-    pub fn new(sizes: Vec<u64>, bound: u64) -> Self {
+    pub fn new(sizes: Vec<i64>, bound: i64) -> Self {
         Self::try_new(sizes, bound).unwrap_or_else(|message| panic!("{message}"))
     }
 
-    pub fn sizes(&self) -> &[u64] {
+    pub fn sizes(&self) -> &[i64] {
         &self.sizes
     }
 
-    pub fn bound(&self) -> u64 {
+    pub fn bound(&self) -> i64 {
         self.bound
     }
 
@@ -104,41 +113,59 @@ impl ThreePartition {
         self.sizes.len() / 3
     }
 
-    pub fn total_sum(&self) -> u64 {
+    pub fn total_sum(&self) -> i64 {
         self.sizes
             .iter()
             .copied()
             .reduce(|acc, value| {
                 acc.checked_add(value)
-                    .expect("validated sum must fit in u64")
+                    .expect("validated sum must fit in i64")
             })
             .unwrap_or(0)
     }
 
-    fn group_counts_and_sums(&self, config: &[usize]) -> Option<(Vec<usize>, Vec<u128>)> {
+    fn group_counts_and_sums(
+        &self,
+        config: &[usize],
+    ) -> Result<Option<GroupCountsAndSums>, crate::traits::EvaluationError> {
         if config.len() != self.num_elements() {
-            return None;
+            return Ok(None);
         }
 
         let mut counts = vec![0usize; self.num_groups()];
-        let mut sums = vec![0u128; self.num_groups()];
+        let mut sums = vec![0_i64; self.num_groups()];
 
         for (index, &group) in config.iter().enumerate() {
             if group >= self.num_groups() {
-                return None;
+                return Ok(None);
             }
             counts[group] += 1;
-            sums[group] += u128::from(self.sizes[index]);
+            sums[group] = sums[group].checked_add(self.sizes[index]).ok_or_else(|| {
+                crate::traits::EvaluationError::IntegerOverflow(
+                    "summing three-partition group".into(),
+                )
+            })?;
         }
 
-        Some((counts, sums))
+        Ok(Some((counts, sums)))
     }
 }
 
-#[derive(Deserialize)]
-struct ThreePartitionData {
-    sizes: Vec<u64>,
-    bound: u64,
+#[derive(Deserialize, crate::CreateSpec)]
+struct ThreePartitionCreateSpec {
+    /// Positive integer sizes for the elements to partition.
+    #[create(codec = "comma-separated")]
+    sizes: Vec<i64>,
+    /// Target sum for each triple.
+    bound: i64,
+}
+
+impl TryFrom<ThreePartitionCreateSpec> for ThreePartition {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: ThreePartitionCreateSpec) -> Result<Self, Self::Error> {
+        Self::try_new(spec.sizes, spec.bound)
+    }
 }
 
 impl<'de> Deserialize<'de> for ThreePartition {
@@ -146,37 +173,58 @@ impl<'de> Deserialize<'de> for ThreePartition {
     where
         D: Deserializer<'de>,
     {
-        let data = ThreePartitionData::deserialize(deserializer)?;
-        Self::try_new(data.sizes, data.bound).map_err(D::Error::custom)
+        let spec = ThreePartitionCreateSpec::deserialize(deserializer)?;
+        Self::try_from(spec).map_err(D::Error::custom)
     }
 }
 
 impl Problem for ThreePartition {
     const NAME: &'static str = "ThreePartition";
+    type Solution = Vec<usize>;
     type Value = Or;
 
+    crate::problem_parameters![("num_elements", num_elements), ("num_groups", num_groups),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.num_groups(); self.num_elements()]
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        if config.len() != self.num_elements() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "group assignment length does not match the elements".into(),
+            ));
+        }
+        if config.iter().any(|&group| group >= self.num_groups()) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "group assignment contains an out-of-range group".into(),
+            ));
+        }
+        Ok({
+            Or({
+                let Some((counts, sums)) = self.group_counts_and_sums(config)? else {
+                    return Ok(Or(false));
+                };
+
+                counts.into_iter().all(|count| count == 3)
+                    && sums.into_iter().all(|sum| sum == self.bound)
+            })
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Or {
-        Or({
-            let Some((counts, sums)) = self.group_counts_and_sums(config) else {
-                return Or(false);
-            };
-
-            let target = u128::from(self.bound);
-            counts.into_iter().all(|count| count == 3) && sums.into_iter().all(|sum| sum == target)
-        })
+impl crate::solvers::BruteForceProblem for ThreePartition {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.num_groups(); self.num_elements()]
     }
 }
 
 crate::declare_variants! {
-    default ThreePartition => "3^num_elements",
+    default ThreePartition => "3^num_elements" create ThreePartitionCreateSpec,
+}
+
+crate::register_brute_force! {
+    ThreePartition,
 }
 
 #[cfg(feature = "example-db")]
@@ -184,7 +232,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "three_partition",
         instance: Box::new(ThreePartition::new(vec![4, 5, 6, 4, 6, 5], 15)),
-        optimal_config: vec![0, 0, 0, 1, 1, 1],
+        optimal_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/misc/timetable_design.rs b/src/models/misc/timetable_design.rs
index ba290ce40..b96bbe294 100644
--- a/src/models/misc/timetable_design.rs
+++ b/src/models/misc/timetable_design.rs
@@ -4,7 +4,7 @@
 //! respecting availability, per-period exclusivity, and exact pairwise work
 //! requirements.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,16 +14,10 @@ inventory::submit! {
         display_name: "Timetable Design",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
         module_path: module_path!(),
         description: "Assign craftsmen to tasks over work periods subject to availability and exact pairwise requirements",
-        fields: &[
-            FieldInfo { name: "num_periods", type_name: "usize", description: "Number of work periods |H|" },
-            FieldInfo { name: "num_craftsmen", type_name: "usize", description: "Number of craftsmen |C|" },
-            FieldInfo { name: "num_tasks", type_name: "usize", description: "Number of tasks |T|" },
-            FieldInfo { name: "craftsman_avail", type_name: "Vec<Vec<bool>>", description: "Availability matrix A(c) for craftsmen (|C| x |H|)" },
-            FieldInfo { name: "task_avail", type_name: "Vec<Vec<bool>>", description: "Availability matrix A(t) for tasks (|T| x |H|)" },
-            FieldInfo { name: "requirements", type_name: "Vec<Vec<u64>>", description: "Required work periods R(c,t) for each craftsman-task pair (|C| x |T|)" },
-        ],
+        fields: TimetableDesignCreateSpec::FIELDS,
     }
 }
 
@@ -39,7 +33,99 @@ pub struct TimetableDesign {
     num_tasks: usize,
     craftsman_avail: Vec<Vec<bool>>,
     task_avail: Vec<Vec<bool>>,
-    requirements: Vec<Vec<u64>>,
+    requirements: Vec<Vec<i64>>,
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct TimetableDesignCreateSpec {
+    /// Number of work periods.
+    num_periods: usize,
+    /// Number of craftsmen.
+    num_craftsmen: usize,
+    /// Number of tasks.
+    num_tasks: usize,
+    /// Craftsman availability matrix.
+    craftsman_avail: Vec<Vec<bool>>,
+    /// Task availability matrix.
+    task_avail: Vec<Vec<bool>>,
+    /// Required work periods for each craftsman-task pair.
+    requirements: Vec<Vec<i64>>,
+}
+impl TryFrom<TimetableDesignCreateSpec> for TimetableDesign {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(spec: TimetableDesignCreateSpec) -> Result<Self, Self::Error> {
+        if spec.craftsman_avail.len() != spec.num_craftsmen {
+            return Err(format!(
+                "craftsman_avail has {} rows, expected {}",
+                spec.craftsman_avail.len(),
+                spec.num_craftsmen
+            )
+            .into());
+        }
+        if let Some((index, row)) = spec
+            .craftsman_avail
+            .iter()
+            .enumerate()
+            .find(|(_, row)| row.len() != spec.num_periods)
+        {
+            return Err(format!(
+                "craftsman_avail row {index} has {} periods, expected {}",
+                row.len(),
+                spec.num_periods
+            )
+            .into());
+        }
+        if spec.task_avail.len() != spec.num_tasks {
+            return Err(format!(
+                "task_avail has {} rows, expected {}",
+                spec.task_avail.len(),
+                spec.num_tasks
+            )
+            .into());
+        }
+        if let Some((index, row)) = spec
+            .task_avail
+            .iter()
+            .enumerate()
+            .find(|(_, row)| row.len() != spec.num_periods)
+        {
+            return Err(format!(
+                "task_avail row {index} has {} periods, expected {}",
+                row.len(),
+                spec.num_periods
+            )
+            .into());
+        }
+        if spec.requirements.len() != spec.num_craftsmen {
+            return Err(format!(
+                "requirements has {} rows, expected {}",
+                spec.requirements.len(),
+                spec.num_craftsmen
+            )
+            .into());
+        }
+        if let Some((index, row)) = spec
+            .requirements
+            .iter()
+            .enumerate()
+            .find(|(_, row)| row.len() != spec.num_tasks)
+        {
+            return Err(format!(
+                "requirements row {index} has {} tasks, expected {}",
+                row.len(),
+                spec.num_tasks
+            )
+            .into());
+        }
+        Ok(Self::new(
+            spec.num_periods,
+            spec.num_craftsmen,
+            spec.num_tasks,
+            spec.craftsman_avail,
+            spec.task_avail,
+            spec.requirements,
+        ))
+    }
 }
 
 impl TimetableDesign {
@@ -54,7 +140,7 @@ impl TimetableDesign {
         num_tasks: usize,
         craftsman_avail: Vec<Vec<bool>>,
         task_avail: Vec<Vec<bool>>,
-        requirements: Vec<Vec<u64>>,
+        requirements: Vec<Vec<i64>>,
     ) -> Self {
         assert_eq!(
             craftsman_avail.len(),
@@ -146,7 +232,7 @@ impl TimetableDesign {
     }
 
     /// Get the pairwise work requirements.
-    pub fn requirements(&self) -> &[Vec<u64>] {
+    pub fn requirements(&self) -> &[Vec<i64>] {
         &self.requirements
     }
 
@@ -158,8 +244,7 @@ impl TimetableDesign {
         ((craftsman * self.num_tasks) + task) * self.num_periods + period
     }
 
-    #[cfg(feature = "ilp-solver")]
-    pub(crate) fn solve_via_required_assignments(&self) -> Option<Vec<usize>> {
+    pub(crate) fn solve_via_required_assignments(&self) -> Option<Vec<Vec<Vec<bool>>>> {
         #[derive(Clone)]
         struct PairRequirement {
             craftsman: usize,
@@ -173,8 +258,8 @@ impl TimetableDesign {
         let mut pairs = Vec::new();
 
         for (craftsman, requirement_row) in self.requirements.iter().enumerate() {
-            for (task, required_u64) in requirement_row.iter().enumerate() {
-                let required = usize::try_from(*required_u64).ok()?;
+            for (task, required_i64) in requirement_row.iter().enumerate() {
+                let required = usize::try_from(*required_i64).ok()?;
                 craftsman_demand[craftsman] += required;
                 task_demand[task] += required;
 
@@ -294,7 +379,21 @@ impl TimetableDesign {
         };
 
         if state.search_pair(0, 0, pairs.first().map_or(0, |pair| pair.required)) {
-            Some(state.config)
+            Some(
+                (0..self.num_craftsmen)
+                    .map(|craftsman| {
+                        (0..self.num_tasks)
+                            .map(|task| {
+                                (0..self.num_periods)
+                                    .map(|period| {
+                                        state.config[self.index(craftsman, task, period)] == 1
+                                    })
+                                    .collect()
+                            })
+                            .collect()
+                    })
+                    .collect(),
+            )
         } else {
             None
         }
@@ -303,50 +402,70 @@ impl TimetableDesign {
 
 impl Problem for TimetableDesign {
     const NAME: &'static str = "TimetableDesign";
+    type Solution = Vec<Vec<Vec<bool>>>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.config_len()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.config_len() {
-                return crate::types::Or(false);
-            }
-            if config.iter().any(|&value| value > 1) {
-                return crate::types::Or(false);
-            }
-
-            let mut craftsman_busy = vec![vec![false; self.num_periods]; self.num_craftsmen];
-            let mut task_busy = vec![vec![false; self.num_periods]; self.num_tasks];
-            let mut pair_counts = vec![vec![0u64; self.num_tasks]; self.num_craftsmen];
-
-            for craftsman in 0..self.num_craftsmen {
-                for task in 0..self.num_tasks {
-                    for period in 0..self.num_periods {
-                        if config[self.index(craftsman, task, period)] == 0 {
-                            continue;
-                        }
-
-                        if !self.craftsman_avail[craftsman][period]
-                            || !self.task_avail[task][period]
-                        {
-                            return crate::types::Or(false);
-                        }
-
-                        if craftsman_busy[craftsman][period] || task_busy[task][period] {
-                            return crate::types::Or(false);
+    crate::problem_parameters![
+        ("num_craftsmen", num_craftsmen),
+        ("num_periods", num_periods),
+        ("num_tasks", num_tasks),
+    ];
+
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if solution.len() != self.num_craftsmen
+            || solution.iter().any(|craftsman| {
+                craftsman.len() != self.num_tasks
+                    || craftsman.iter().any(|task| task.len() != self.num_periods)
+            })
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "timetable dimensions do not match the instance".into(),
+            ));
+        }
+        let config = solution
+            .iter()
+            .flatten()
+            .flatten()
+            .copied()
+            .collect::<Vec<_>>();
+        Ok({
+            crate::types::Or({
+                if config.len() != self.config_len() {
+                    return Ok(crate::types::Or(false));
+                }
+                let mut craftsman_busy = vec![vec![false; self.num_periods]; self.num_craftsmen];
+                let mut task_busy = vec![vec![false; self.num_periods]; self.num_tasks];
+                let mut pair_counts = vec![vec![0i64; self.num_tasks]; self.num_craftsmen];
+
+                for craftsman in 0..self.num_craftsmen {
+                    for task in 0..self.num_tasks {
+                        for period in 0..self.num_periods {
+                            if !config[self.index(craftsman, task, period)] {
+                                continue;
+                            }
+
+                            if !self.craftsman_avail[craftsman][period]
+                                || !self.task_avail[task][period]
+                            {
+                                return Ok(crate::types::Or(false));
+                            }
+
+                            if craftsman_busy[craftsman][period] || task_busy[task][period] {
+                                return Ok(crate::types::Or(false));
+                            }
+
+                            craftsman_busy[craftsman][period] = true;
+                            task_busy[task][period] = true;
+                            pair_counts[craftsman][task] += 1;
                         }
-
-                        craftsman_busy[craftsman][period] = true;
-                        task_busy[task][period] = true;
-                        pair_counts[craftsman][task] += 1;
                     }
                 }
-            }
 
-            pair_counts == self.requirements
+                pair_counts == self.requirements
+            })
         })
     }
 
@@ -355,8 +474,18 @@ impl Problem for TimetableDesign {
     }
 }
 
+impl crate::solvers::BruteForceProblem for TimetableDesign {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.config_len()]
+    }
+}
+
 crate::declare_variants! {
-    default TimetableDesign => "2^(num_craftsmen * num_tasks * num_periods)",
+    default TimetableDesign => "2^(num_craftsmen * num_tasks * num_periods)" create TimetableDesignCreateSpec,
+}
+
+crate::register_brute_force! {
+    TimetableDesign decode |problem: &TimetableDesign, indices: Vec<usize>| (0..problem.num_craftsmen()).map(|craftsman| (0..problem.num_tasks()).map(|task| (0..problem.num_periods()).map(|period| indices[problem.index(craftsman, task, period)] != 0).collect()).collect()).collect(),
 }
 
 #[cfg(any(test, feature = "example-db"))]
@@ -401,11 +530,14 @@ fn issue_example_problem() -> TimetableDesign {
 }
 
 #[cfg(any(test, feature = "example-db"))]
-fn issue_example_config() -> Vec<usize> {
+fn issue_example_config() -> Vec<Vec<Vec<bool>>> {
     let problem = issue_example_problem();
-    let mut config = vec![0; problem.config_len()];
+    let mut config = vec![
+        vec![vec![false; problem.num_periods()]; problem.num_tasks()];
+        problem.num_craftsmen()
+    ];
     for &(craftsman, task, period) in ISSUE_EXAMPLE_ASSIGNMENTS {
-        config[problem.index(craftsman, task, period)] = 1;
+        config[craftsman][task][period] = true;
     }
     config
 }
@@ -415,7 +547,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "timetable_design",
         instance: Box::new(issue_example_problem()),
-        optimal_config: issue_example_config(),
+        optimal_config: serde_json::json!(issue_example_config()),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/mod.rs b/src/models/mod.rs
index ca989952b..21220aa30 100644
--- a/src/models/mod.rs
+++ b/src/models/mod.rs
@@ -76,5 +76,5 @@ pub use set::{
     ComparativeContainment, ConsecutiveSets, ExactCoverBy3Sets, IntegerKnapsack, MaximumSetPacking,
     MinimumCardinalityKey, MinimumHittingSet, MinimumSetCovering, PrimeAttributeName,
     RootedTreeStorageAssignment, SetBasis, SetSplitting, ThreeDimensionalMatching,
-    ThreeMatroidIntersection, TwoDimensionalConsecutiveSets,
+    TwoDimensionalConsecutiveSets,
 };
diff --git a/src/models/set/comparative_containment.rs b/src/models/set/comparative_containment.rs
index c1ad0629f..f628c9744 100644
--- a/src/models/set/comparative_containment.rs
+++ b/src/models/set/comparative_containment.rs
@@ -4,34 +4,22 @@
 //! whether there exists a subset of the universe whose containment weight
 //! in the first family is at least its containment weight in the second.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry, VariantDimension};
+use crate::registry::{ConstructionError, CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::traits::Problem;
 use crate::types::{One, WeightElement};
 use num_traits::Zero;
 use serde::{Deserialize, Serialize};
 
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "ComparativeContainment",
-        fields: &["universe_size", "num_r_sets", "num_s_sets"],
-    }
-}
-
 inventory::submit! {
     ProblemSchemaEntry {
         name: "ComparativeContainment",
         display_name: "Comparative Containment",
         aliases: &[],
-        dimensions: &[VariantDimension::new("weight", "i32", &["One", "i32", "f64"])],
+        dimensions: &[VariantDimension::new("weight", "i64", &["One", "i64", "f64"])],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Compare containment-weight sums for two set families over a shared universe",
-        fields: &[
-            FieldInfo { name: "universe_size", type_name: "usize", description: "Size of the universe X" },
-            FieldInfo { name: "r_sets", type_name: "Vec<Vec<usize>>", description: "First set family R over X" },
-            FieldInfo { name: "s_sets", type_name: "Vec<Vec<usize>>", description: "Second set family S over X" },
-            FieldInfo { name: "r_weights", type_name: "Vec<W>", description: "Positive weights for sets in R" },
-            FieldInfo { name: "s_weights", type_name: "Vec<W>", description: "Positive weights for sets in S" },
-        ],
+        fields: ComparativeContainmentI64CreateSpec::FIELDS,
     }
 }
 
@@ -41,8 +29,8 @@ inventory::submit! {
 /// on those sets, determine whether there exists a subset `Y ⊆ X` such that
 /// the total weight of `R`-sets containing `Y` is at least the total weight
 /// of `S`-sets containing `Y`.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ComparativeContainment<W = i32> {
+#[derive(Debug, Clone, Serialize)]
+pub struct ComparativeContainment<W = i64> {
     universe_size: usize,
     r_sets: Vec<Vec<usize>>,
     s_sets: Vec<Vec<usize>>,
@@ -50,14 +38,118 @@ pub struct ComparativeContainment<W = i32> {
     s_weights: Vec<W>,
 }
 
+macro_rules! comparative_containment_create_spec {
+    ($name:ident, $weight:ty, $one:expr $(, $r_weights:ident, $s_weights:ident)?) => {
+        #[derive(Debug, Deserialize, crate::CreateSpec)]
+        struct $name {
+            /// Size of the common universe.
+            universe_size: usize,
+            /// First set family.
+            #[create(codec = "semicolon-separated")]
+            r_sets: Vec<Vec<usize>>,
+            /// Second set family.
+            #[create(codec = "semicolon-separated")]
+            s_sets: Vec<Vec<usize>>,
+            $(
+            /// Positive weights for the first family; defaults to one.
+            #[create(codec = "comma-separated")]
+            $r_weights: Option<Vec<$weight>>,
+            )?
+            $(
+            /// Positive weights for the second family; defaults to one.
+            #[create(codec = "comma-separated")]
+            $s_weights: Option<Vec<$weight>>,
+            )?
+        }
+
+        impl TryFrom<$name> for ComparativeContainment<$weight> {
+            type Error = ConstructionError;
+            fn try_from(spec: $name) -> Result<Self, Self::Error> {
+                let r_weights = { $(if let Some(value) = spec.$r_weights { value } else)? { vec![$one; spec.r_sets.len()] } };
+                let s_weights = { $(if let Some(value) = spec.$s_weights { value } else)? { vec![$one; spec.s_sets.len()] } };
+                ComparativeContainment::with_weights(
+                    spec.universe_size,
+                    spec.r_sets,
+                    spec.s_sets,
+                    r_weights,
+                    s_weights,
+                )
+            }
+        }
+    };
+}
+
+fn validate_create_set_family(
+    label: &str,
+    universe_size: usize,
+    sets: &[Vec<usize>],
+) -> Result<(), ConstructionError> {
+    for (set_index, set) in sets.iter().enumerate() {
+        for &element in set {
+            if element >= universe_size {
+                return Err(ConstructionError::Conversion(format!("{label} set {set_index} contains element {element} outside universe of size {universe_size}")));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_create_weights<W: WeightElement>(
+    label: &str,
+    count: usize,
+    weights: &[W],
+) -> Result<(), ConstructionError> {
+    if weights.len() != count {
+        return Err(ConstructionError::Conversion(format!(
+            "number of {label} sets and weights must match"
+        )));
+    }
+    for (index, weight) in weights.iter().enumerate() {
+        match weight.to_sum().partial_cmp(&W::Sum::zero()) {
+            None => {
+                return Err(ConstructionError::NonFiniteFloat(format!(
+                    "{label} weight at index {index} must be finite"
+                )));
+            }
+            Some(std::cmp::Ordering::Greater) => {}
+            Some(_) => {
+                return Err(ConstructionError::Conversion(format!(
+                    "{label} weight at index {index} must be positive"
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+comparative_containment_create_spec!(
+    ComparativeContainmentI64CreateSpec,
+    i64,
+    1_i64,
+    r_weights,
+    s_weights
+);
+comparative_containment_create_spec!(
+    ComparativeContainmentF64CreateSpec,
+    f64,
+    1.0_f64,
+    r_weights,
+    s_weights
+);
+comparative_containment_create_spec!(ComparativeContainmentOneCreateSpec, One, One);
+
 impl<W: WeightElement> ComparativeContainment<W> {
     /// Create a new instance with unit weights.
-    pub fn new(universe_size: usize, r_sets: Vec<Vec<usize>>, s_sets: Vec<Vec<usize>>) -> Self
+    pub fn new(
+        universe_size: usize,
+        r_sets: Vec<Vec<usize>>,
+        s_sets: Vec<Vec<usize>>,
+    ) -> Result<Self, ConstructionError>
     where
-        W: From<i32>,
+        W: WeightElement,
     {
-        let r_weights = vec![W::from(1); r_sets.len()];
-        let s_weights = vec![W::from(1); s_sets.len()];
+        let r_weights = vec![W::unit(); r_sets.len()];
+        let s_weights = vec![W::unit(); s_sets.len()];
         Self::with_weights(universe_size, r_sets, s_sets, r_weights, s_weights)
     }
 
@@ -68,28 +160,18 @@ impl<W: WeightElement> ComparativeContainment<W> {
         s_sets: Vec<Vec<usize>>,
         r_weights: Vec<W>,
         s_weights: Vec<W>,
-    ) -> Self {
-        assert_eq!(
-            r_sets.len(),
-            r_weights.len(),
-            "number of R sets and R weights must match"
-        );
-        assert_eq!(
-            s_sets.len(),
-            s_weights.len(),
-            "number of S sets and S weights must match"
-        );
-        validate_set_family("R", universe_size, &r_sets);
-        validate_set_family("S", universe_size, &s_sets);
-        validate_weight_family("R", &r_weights);
-        validate_weight_family("S", &s_weights);
-        Self {
+    ) -> Result<Self, ConstructionError> {
+        validate_create_set_family("R", universe_size, &r_sets)?;
+        validate_create_set_family("S", universe_size, &s_sets)?;
+        validate_create_weights("R", r_sets.len(), &r_weights)?;
+        validate_create_weights("S", s_sets.len(), &s_weights)?;
+        Ok(Self {
             universe_size,
             r_sets,
             s_sets,
             r_weights,
             s_weights,
-        }
+        })
     }
 
     /// Get the size of the universe.
@@ -128,12 +210,41 @@ impl<W: WeightElement> ComparativeContainment<W> {
     }
 
     /// Check whether the subset selected by `config` is contained in `set`.
-    pub fn contains_selected_subset(&self, config: &[usize], set: &[usize]) -> bool {
+    pub fn contains_selected_subset(&self, config: &[bool], set: &[usize]) -> bool {
         self.valid_config(config) && contains_selected_subset_unchecked(config, set)
     }
 
-    fn valid_config(&self, config: &[usize]) -> bool {
-        config.len() == self.universe_size && config.iter().all(|&value| value <= 1)
+    fn valid_config(&self, config: &[bool]) -> bool {
+        config.len() == self.universe_size
+    }
+}
+
+impl<'de, W> Deserialize<'de> for ComparativeContainment<W>
+where
+    W: WeightElement + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Raw<W> {
+            universe_size: usize,
+            r_sets: Vec<Vec<usize>>,
+            s_sets: Vec<Vec<usize>>,
+            r_weights: Vec<W>,
+            s_weights: Vec<W>,
+        }
+
+        let raw = Raw::deserialize(deserializer)?;
+        Self::with_weights(
+            raw.universe_size,
+            raw.r_sets,
+            raw.s_sets,
+            raw.r_weights,
+            raw.s_weights,
+        )
+        .map_err(serde::de::Error::custom)
     }
 }
 
@@ -142,40 +253,55 @@ where
     W: WeightElement,
 {
     /// Total R-family weight for sets containing the selected subset.
-    pub fn r_weight_sum(&self, config: &[usize]) -> Option<W::Sum> {
+    pub fn r_weight_sum(
+        &self,
+        config: &[bool],
+    ) -> Result<Option<W::Sum>, crate::traits::EvaluationError> {
         self.sum_containing_weights(config, &self.r_sets, &self.r_weights)
     }
 
     /// Total S-family weight for sets containing the selected subset.
-    pub fn s_weight_sum(&self, config: &[usize]) -> Option<W::Sum> {
+    pub fn s_weight_sum(
+        &self,
+        config: &[bool],
+    ) -> Result<Option<W::Sum>, crate::traits::EvaluationError> {
         self.sum_containing_weights(config, &self.s_sets, &self.s_weights)
     }
 
     /// Check if a configuration is a satisfying solution.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        match (self.r_weight_sum(config), self.s_weight_sum(config)) {
-            (Some(r_total), Some(s_total)) => r_total >= s_total,
-            _ => false,
-        }
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        Ok(
+            match (self.r_weight_sum(config)?, self.s_weight_sum(config)?) {
+                (Some(r_total), Some(s_total)) => r_total >= s_total,
+                _ => false,
+            },
+        )
     }
 
     fn sum_containing_weights(
         &self,
-        config: &[usize],
+        config: &[bool],
         sets: &[Vec<usize>],
         weights: &[W],
-    ) -> Option<W::Sum> {
+    ) -> Result<Option<W::Sum>, crate::traits::EvaluationError> {
         if !self.valid_config(config) {
-            return None;
+            return Ok(None);
         }
 
         let mut total = W::Sum::zero();
         for (set, weight) in sets.iter().zip(weights.iter()) {
             if contains_selected_subset_unchecked(config, set) {
-                total += weight.to_sum();
+                total = W::checked_add_to_sum(
+                    total,
+                    weight.to_sum(),
+                    "summing comparative containment weights",
+                )?;
             }
         }
-        Some(total)
+        Ok(Some(total))
     }
 }
 
@@ -184,14 +310,25 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "ComparativeContainment";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.universe_size]
-    }
+    crate::problem_parameters![
+        ("num_r_sets", num_r_sets),
+        ("num_s_sets", num_s_sets),
+        ("universe_size", universe_size),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.is_valid_solution(config))
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.universe_size {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "element-selection length does not match the universe".into(),
+            ));
+        }
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -199,52 +336,49 @@ where
     }
 }
 
-crate::declare_variants! {
-    ComparativeContainment<One> => "2^universe_size",
-    default ComparativeContainment<i32> => "2^universe_size",
-    ComparativeContainment<f64> => "2^universe_size",
+impl<W> crate::solvers::BruteForceProblem for ComparativeContainment<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.universe_size]
+    }
 }
 
-fn validate_set_family(label: &str, universe_size: usize, sets: &[Vec<usize>]) {
-    for (set_index, set) in sets.iter().enumerate() {
-        for &element in set {
-            assert!(
-                element < universe_size,
-                "{label} set {set_index} contains element {element} outside universe of size {universe_size}"
-            );
-        }
-    }
+crate::declare_variants! {
+    ComparativeContainment<One> => "2^universe_size" create ComparativeContainmentOneCreateSpec,
+    default ComparativeContainment<i64> => "2^universe_size" create ComparativeContainmentI64CreateSpec,
+    ComparativeContainment<f64> => "2^universe_size" create ComparativeContainmentF64CreateSpec,
 }
 
-fn validate_weight_family<W: WeightElement>(label: &str, weights: &[W]) {
-    for (index, weight) in weights.iter().enumerate() {
-        let sum = weight.to_sum();
-        assert!(
-            sum.partial_cmp(&W::Sum::zero()) == Some(std::cmp::Ordering::Greater),
-            "{label} weights must be finite and positive; weight at index {index} is not"
-        );
-    }
+crate::register_brute_force! {
+    ComparativeContainment<One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    ComparativeContainment<i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    ComparativeContainment<f64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
-fn contains_selected_subset_unchecked(config: &[usize], set: &[usize]) -> bool {
+fn contains_selected_subset_unchecked(config: &[bool], set: &[usize]) -> bool {
     config
         .iter()
         .enumerate()
-        .all(|(element, &selected)| selected == 0 || set.contains(&element))
+        .all(|(element, &selected)| !selected || set.contains(&element))
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "comparative_containment_i32",
-        instance: Box::new(ComparativeContainment::with_weights(
-            4,
-            vec![vec![0, 1, 2, 3], vec![0, 1]],
-            vec![vec![0, 1, 2, 3], vec![2, 3]],
-            vec![2, 5],
-            vec![3, 6],
-        )),
-        optimal_config: vec![0, 1, 0, 0],
+        id: "comparative_containment",
+        instance: Box::new(
+            ComparativeContainment::with_weights(
+                4,
+                vec![vec![0, 1, 2, 3], vec![0, 1]],
+                vec![vec![0, 1, 2, 3], vec![2, 3]],
+                vec![2, 5],
+                vec![3, 6],
+            )
+            .expect("canonical comparative-containment instance must be valid"),
+        ),
+        optimal_config: serde_json::json!(vec![false, true, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/set/consecutive_sets.rs b/src/models/set/consecutive_sets.rs
index 1e50f29dc..9fc0aa171 100644
--- a/src/models/set/consecutive_sets.rs
+++ b/src/models/set/consecutive_sets.rs
@@ -16,6 +16,7 @@ inventory::submit! {
         display_name: "Consecutive Sets",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Determine if a string exists where each subset's elements appear consecutively",
         fields: &[
@@ -33,10 +34,9 @@ inventory::submit! {
 /// such that the elements of each subset appear as a contiguous block (in any
 /// order) within w.
 ///
-/// Configurations use `bound_k` positions. Values `0..alphabet_size-1`
-/// represent alphabet symbols, and the extra value `alphabet_size` marks
-/// unused positions beyond the end of a shorter string. Only trailing unused
-/// positions are valid.
+/// Solutions use `bound_k` positions. `Some(symbol)` represents an alphabet
+/// symbol and trailing `None` positions mark the unused suffix of a shorter
+/// string.
 ///
 /// This problem is NP-complete and arises in physical mapping of DNA and in
 /// consecutive arrangements of hypergraph vertices.
@@ -45,7 +45,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::set::ConsecutiveSets;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Alphabet: {0, 1, 2, 3, 4, 5}, subsets that must appear consecutively
 /// let problem = ConsecutiveSets::new(
@@ -55,17 +55,20 @@ inventory::submit! {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 ///
 /// // w = [0, 4, 2, 5, 1, 3] is a valid solution
 /// assert!(solution.is_some());
-/// assert!(problem.evaluate(&solution.unwrap()));
+/// assert!(problem.evaluate(&solution.unwrap()).unwrap());
 ///
-/// // Shorter strings are encoded with trailing `unused = alphabet_size`.
+/// // Shorter strings use trailing `None` positions.
 /// let shorter = ConsecutiveSets::new(3, vec![vec![0, 1]], 4);
-/// let unused = shorter.alphabet_size();
-/// assert!(shorter.evaluate(&[0, 1, unused, unused]));
-/// assert!(!shorter.evaluate(&[0, unused, 1, unused]));
+/// assert!(shorter
+///     .evaluate(&vec![Some(0), Some(1), None, None])
+///     .unwrap());
+/// assert!(!shorter
+///     .evaluate(&vec![Some(0), None, Some(1), None])
+///     .unwrap());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ConsecutiveSets {
@@ -135,84 +138,103 @@ impl ConsecutiveSets {
 
 impl Problem for ConsecutiveSets {
     const NAME: &'static str = "ConsecutiveSets";
+    type Solution = Vec<Option<usize>>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        // Each position can be any symbol (0..alphabet_size-1) or "unused" (alphabet_size)
-        vec![self.alphabet_size + 1; self.bound_k]
-    }
+    crate::problem_parameters![
+        ("alphabet_size", alphabet_size),
+        ("num_subsets", num_subsets),
+        ("bound_k", bound_k),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            // 1. Validate config
-            if config.len() != self.bound_k || config.iter().any(|&v| v > self.alphabet_size) {
-                return crate::types::Or(false);
-            }
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        if config.len() != self.bound_k {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "ordering representation length does not match the bound".into(),
+            ));
+        }
+        if config
+            .iter()
+            .any(|symbol| symbol.is_some_and(|value| value >= self.alphabet_size))
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "ordering representation contains an out-of-range symbol".into(),
+            ));
+        }
+        let config = config
+            .iter()
+            .map(|symbol| symbol.unwrap_or(self.alphabet_size))
+            .collect::<Vec<_>>();
+        Ok({
+            crate::types::Or({
+                // 2. Build string: find the actual string length (strip trailing "unused")
+                let unused = self.alphabet_size;
+                let str_len = config
+                    .iter()
+                    .rposition(|&v| v != unused)
+                    .map_or(0, |p| p + 1);
 
-            // 2. Build string: find the actual string length (strip trailing "unused")
-            let unused = self.alphabet_size;
-            let str_len = config
-                .iter()
-                .rposition(|&v| v != unused)
-                .map_or(0, |p| p + 1);
-
-            // 3. Check no internal "unused" symbols
-            let w = &config[..str_len];
-            if w.contains(&unused) {
-                return crate::types::Or(false);
-            }
+                // 3. Check no internal "unused" symbols
+                let w = &config[..str_len];
+                if w.contains(&unused) {
+                    return Ok(crate::types::Or(false));
+                }
 
-            let mut subset_membership = vec![0usize; self.alphabet_size];
-            let mut seen_in_window = vec![0usize; self.alphabet_size];
-            let mut subset_stamp = 1usize;
-            let mut window_stamp = 1usize;
+                let mut subset_membership = vec![0usize; self.alphabet_size];
+                let mut seen_in_window = vec![0usize; self.alphabet_size];
+                let mut subset_stamp = 1usize;
+                let mut window_stamp = 1usize;
 
-            // 4. Check each subset has a consecutive block
-            for subset in &self.subsets {
-                let subset_len = subset.len();
-                if subset_len == 0 {
-                    continue; // empty subset trivially satisfied
-                }
-                if subset_len > str_len {
-                    return crate::types::Or(false); // can't fit
-                }
+                // 4. Check each subset has a consecutive block
+                for subset in &self.subsets {
+                    let subset_len = subset.len();
+                    if subset_len == 0 {
+                        continue; // empty subset trivially satisfied
+                    }
+                    if subset_len > str_len {
+                        return Ok(crate::types::Or(false)); // can't fit
+                    }
 
-                for &elem in subset {
-                    subset_membership[elem] = subset_stamp;
-                }
+                    for &elem in subset {
+                        subset_membership[elem] = subset_stamp;
+                    }
 
-                let mut found = false;
-                for start in 0..=(str_len - subset_len) {
-                    let window = &w[start..start + subset_len];
-                    let current_window_stamp = window_stamp;
-                    window_stamp += 1;
-
-                    // Because subsets are validated to contain unique elements,
-                    // a window matches iff every symbol belongs to the subset and
-                    // appears at most once.
-                    if window.iter().all(|&elem| {
-                        let is_member = subset_membership[elem] == subset_stamp;
-                        let is_new = seen_in_window[elem] != current_window_stamp;
-                        if is_member && is_new {
-                            seen_in_window[elem] = current_window_stamp;
-                            true
-                        } else {
-                            false
+                    let mut found = false;
+                    for start in 0..=(str_len - subset_len) {
+                        let window = &w[start..start + subset_len];
+                        let current_window_stamp = window_stamp;
+                        window_stamp += 1;
+
+                        // Because subsets are validated to contain unique elements,
+                        // a window matches iff every symbol belongs to the subset and
+                        // appears at most once.
+                        if window.iter().all(|&elem| {
+                            let is_member = subset_membership[elem] == subset_stamp;
+                            let is_new = seen_in_window[elem] != current_window_stamp;
+                            if is_member && is_new {
+                                seen_in_window[elem] = current_window_stamp;
+                                true
+                            } else {
+                                false
+                            }
+                        }) {
+                            // subset is already sorted
+                            found = true;
+                            break;
                         }
-                    }) {
-                        // subset is already sorted
-                        found = true;
-                        break;
                     }
-                }
-                if !found {
-                    return crate::types::Or(false);
-                }
+                    if !found {
+                        return Ok(crate::types::Or(false));
+                    }
 
-                subset_stamp += 1;
-            }
+                    subset_stamp += 1;
+                }
 
-            true
+                true
+            })
         })
     }
 
@@ -221,10 +243,21 @@ impl Problem for ConsecutiveSets {
     }
 }
 
+impl crate::solvers::BruteForceProblem for ConsecutiveSets {
+    fn dimensions(&self) -> Vec<usize> {
+        // Each position can be any symbol (0..alphabet_size-1) or "unused" (alphabet_size)
+        vec![self.alphabet_size + 1; self.bound_k]
+    }
+}
+
 crate::declare_variants! {
     default ConsecutiveSets => "alphabet_size^bound_k * num_subsets",
 }
 
+crate::register_brute_force! {
+    ConsecutiveSets decode |problem: &ConsecutiveSets, indices: Vec<usize>| indices.into_iter().map(|value| (value != problem.alphabet_size()).then_some(value)).collect(),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -235,7 +268,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![vec![0, 4], vec![2, 4], vec![2, 5], vec![1, 5], vec![1, 3]],
             6,
         )),
-        optimal_config: vec![0, 4, 2, 5, 1, 3],
+        optimal_config: serde_json::json!(vec![0, 4, 2, 5, 1, 3]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/set/exact_cover_by_3_sets.rs b/src/models/set/exact_cover_by_3_sets.rs
index c65dc0c67..ac6f64852 100644
--- a/src/models/set/exact_cover_by_3_sets.rs
+++ b/src/models/set/exact_cover_by_3_sets.rs
@@ -4,7 +4,7 @@
 //! subsets of X, determine if C contains an exact cover -- a subcollection of
 //! q disjoint triples covering every element exactly once.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
@@ -15,12 +15,10 @@ inventory::submit! {
         display_name: "Exact Cover by 3-Sets",
         aliases: &["X3C"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Determine if a collection of 3-element subsets contains an exact cover",
-        fields: &[
-            FieldInfo { name: "universe_size", type_name: "usize", description: "Size of universe X (must be divisible by 3)" },
-            FieldInfo { name: "subsets", type_name: "Vec<[usize; 3]>", description: "Collection C of 3-element subsets of X" },
-        ],
+        fields: ExactCoverBy3SetsCreateSpec::FIELDS,
     }
 }
 
@@ -37,7 +35,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::set::ExactCoverBy3Sets;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Universe: {0, 1, 2, 3, 4, 5} (q = 2)
 /// // Subsets: S0={0,1,2}, S1={3,4,5}, S2={0,3,4}
@@ -47,11 +45,11 @@ inventory::submit! {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // S0 and S1 form an exact cover
 /// assert_eq!(solutions.len(), 1);
-/// assert!(problem.evaluate(&solutions[0]));
+/// assert!(problem.evaluate(&solutions[0]).unwrap());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ExactCoverBy3Sets {
@@ -61,6 +59,40 @@ pub struct ExactCoverBy3Sets {
     subsets: Vec<[usize; 3]>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct ExactCoverBy3SetsCreateSpec {
+    universe_size: usize,
+    #[create(codec = "semicolon-separated")]
+    subsets: Vec<[usize; 3]>,
+}
+
+impl TryFrom<ExactCoverBy3SetsCreateSpec> for ExactCoverBy3Sets {
+    type Error = crate::registry::ConstructionError;
+    fn try_from(mut spec: ExactCoverBy3SetsCreateSpec) -> Result<Self, Self::Error> {
+        if !spec.universe_size.is_multiple_of(3) {
+            return Err("universe_size must be divisible by 3".into());
+        }
+        for (index, subset) in spec.subsets.iter_mut().enumerate() {
+            if subset[0] == subset[1] || subset[0] == subset[2] || subset[1] == subset[2] {
+                return Err(format!("subset {index} contains duplicate elements").into());
+            }
+            if let Some(&element) = subset
+                .iter()
+                .find(|&&element| element >= spec.universe_size)
+            {
+                return Err(
+                    format!("subset {index} contains out-of-range element {element}").into(),
+                );
+            }
+            subset.sort();
+        }
+        Ok(Self {
+            universe_size: spec.universe_size,
+            subsets: spec.subsets,
+        })
+    }
+}
+
 impl ExactCoverBy3Sets {
     /// Create a new X3C problem.
     ///
@@ -141,15 +173,39 @@ impl ExactCoverBy3Sets {
     ///
     /// A valid exact cover selects exactly q = universe_size/3 subsets
     /// that are pairwise disjoint and whose union equals the universe.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if config.len() != self.subsets.len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "subset-selection length does not match the instance".into(),
+            ));
+        }
+
+        let q = self.universe_size / 3;
+        if config.iter().filter(|&&selected| selected).count() != q {
+            return Ok(false);
+        }
+
+        let mut covered = HashSet::with_capacity(self.universe_size);
+        for (subset, &selected) in self.subsets.iter().zip(config) {
+            if selected {
+                for &element in subset {
+                    if !covered.insert(element) {
+                        return Ok(false);
+                    }
+                }
+            }
+        }
+        Ok(covered.len() == self.universe_size)
     }
 
     /// Get the elements covered by the selected subsets.
-    pub fn covered_elements(&self, config: &[usize]) -> HashSet<usize> {
+    pub fn covered_elements(&self, config: &[bool]) -> HashSet<usize> {
         let mut covered = HashSet::new();
         for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
+            if selected {
                 if let Some(subset) = self.subsets.get(i) {
                     covered.extend(subset.iter().copied());
                 }
@@ -161,44 +217,20 @@ impl ExactCoverBy3Sets {
 
 impl Problem for ExactCoverBy3Sets {
     const NAME: &'static str = "ExactCoverBy3Sets";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.subsets.len()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.subsets.len() || config.iter().any(|&value| value > 1) {
-                return crate::types::Or(false);
-            }
-
-            let q = self.universe_size / 3;
-
-            // Count selected subsets
-            let selected_count: usize = config.iter().filter(|&&v| v == 1).sum();
-            if selected_count != q {
-                return crate::types::Or(false);
-            }
-
-            // Check that selected subsets are pairwise disjoint and cover everything
-            let mut covered = HashSet::with_capacity(self.universe_size);
-            for (i, &selected) in config.iter().enumerate() {
-                if selected == 1 {
-                    if let Some(subset) = self.subsets.get(i) {
-                        for &elem in subset {
-                            if !covered.insert(elem) {
-                                // Element already covered -- not disjoint
-                                return crate::types::Or(false);
-                            }
-                        }
-                    }
-                }
-            }
+    crate::problem_parameters![
+        ("num_sets", num_sets),
+        ("num_subsets", num_subsets),
+        ("universe_size", universe_size),
+    ];
 
-            // Check all elements are covered
-            covered.len() == self.universe_size
-        })
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -206,8 +238,18 @@ impl Problem for ExactCoverBy3Sets {
     }
 }
 
+impl crate::solvers::BruteForceProblem for ExactCoverBy3Sets {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.subsets.len()]
+    }
+}
+
 crate::declare_variants! {
-    default ExactCoverBy3Sets => "2^universe_size",
+    default ExactCoverBy3Sets => "2^universe_size" create ExactCoverBy3SetsCreateSpec,
+}
+
+crate::register_brute_force! {
+    ExactCoverBy3Sets decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -226,7 +268,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 [2, 5, 8],
             ],
         )),
-        optimal_config: vec![1, 0, 1, 0, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![true, false, true, false, true, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/set/integer_knapsack.rs b/src/models/set/integer_knapsack.rs
index aba6cb1f6..6080cbdff 100644
--- a/src/models/set/integer_knapsack.rs
+++ b/src/models/set/integer_knapsack.rs
@@ -3,7 +3,9 @@
 //! The Integer Knapsack problem generalizes the 0-1 Knapsack by allowing
 //! each item to be selected with a non-negative integer multiplicity.
 
+use crate::registry::ConstructionError;
 use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Max;
 use serde::{Deserialize, Serialize};
@@ -14,6 +16,7 @@ inventory::submit! {
         display_name: "Integer Knapsack",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Select items with integer multiplicities to maximize total value subject to capacity constraint",
         fields: &[
@@ -40,11 +43,11 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::set::IntegerKnapsack;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
-/// let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15);
+/// let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15).unwrap();
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize)]
@@ -58,32 +61,16 @@ pub struct IntegerKnapsack {
 impl IntegerKnapsack {
     /// Create a new IntegerKnapsack instance.
     ///
-    /// # Panics
-    /// Panics if `sizes` and `values` have different lengths, or if any
-    /// size or value is not positive, or if capacity is negative.
-    pub fn new(sizes: Vec<i64>, values: Vec<i64>, capacity: i64) -> Self {
-        assert_eq!(
-            sizes.len(),
-            values.len(),
-            "sizes and values must have the same length"
-        );
-        assert!(
-            sizes.iter().all(|&s| s > 0),
-            "IntegerKnapsack sizes must be positive"
-        );
-        assert!(
-            values.iter().all(|&v| v > 0),
-            "IntegerKnapsack values must be positive"
-        );
-        assert!(
-            capacity >= 0,
-            "IntegerKnapsack capacity must be nonnegative"
-        );
-        Self {
+    pub fn new(
+        sizes: Vec<i64>,
+        values: Vec<i64>,
+        capacity: i64,
+    ) -> Result<Self, ConstructionError> {
+        Self::try_from(RawIntegerKnapsack {
             sizes,
             values,
             capacity,
-        }
+        })
     }
 
     /// Returns the item sizes.
@@ -109,41 +96,93 @@ impl IntegerKnapsack {
 
 impl Problem for IntegerKnapsack {
     const NAME: &'static str = "IntegerKnapsack";
+    type Solution = Vec<usize>;
     type Value = Max<i64>;
 
+    crate::problem_parameters![("capacity", capacity), ("num_items", num_items),];
+
     fn variant() -> Vec<(&'static str, &'static str)> {
         crate::variant_params![]
     }
 
-    fn dims(&self) -> Vec<usize> {
-        self.sizes
-            .iter()
-            .map(|&s| (self.capacity / s + 1) as usize)
-            .collect()
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.num_items() {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "multiplicity-vector length does not match the items".into(),
+                ));
+            }
+            let dims = self.dimensions();
+            if config
+                .iter()
+                .zip(&dims)
+                .any(|(&count, &dimension)| count >= dimension)
+            {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "multiplicity vector contains an out-of-range count".into(),
+                ));
+            }
+            let total_size = config
+                .iter()
+                .enumerate()
+                .try_fold(0_i64, |total, (i, &c)| {
+                    let count = i64::try_from(c).map_err(|_| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "converting knapsack item count to i64".into(),
+                        )
+                    })?;
+                    let contribution = count.checked_mul(self.sizes[i]).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "multiplying knapsack item count by size".into(),
+                        )
+                    })?;
+                    total.checked_add(contribution).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing knapsack item sizes".into(),
+                        )
+                    })
+                })?;
+            if total_size > self.capacity {
+                return Ok(Max(None));
+            }
+            let total_value = config
+                .iter()
+                .enumerate()
+                .try_fold(0_i64, |total, (i, &c)| {
+                    let count = i64::try_from(c).map_err(|_| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "converting knapsack item count to i64".into(),
+                        )
+                    })?;
+                    let contribution = count.checked_mul(self.values[i]).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "multiplying knapsack item count by value".into(),
+                        )
+                    })?;
+                    total.checked_add(contribution).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing knapsack item values".into(),
+                        )
+                    })
+                })?;
+            Max(Some(total_value))
+        })
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Max<i64> {
-        if config.len() != self.num_items() {
-            return Max(None);
-        }
-        let dims = self.dims();
-        if config.iter().zip(dims.iter()).any(|(&c, &d)| c >= d) {
-            return Max(None);
-        }
-        let total_size: i64 = config
-            .iter()
-            .enumerate()
-            .map(|(i, &c)| c as i64 * self.sizes[i])
-            .sum();
-        if total_size > self.capacity {
-            return Max(None);
-        }
-        let total_value: i64 = config
+impl crate::solvers::BruteForceProblem for IntegerKnapsack {
+    fn dimensions(&self) -> Vec<usize> {
+        self.sizes
             .iter()
-            .enumerate()
-            .map(|(i, &c)| c as i64 * self.values[i])
-            .sum();
-        Max(Some(total_value))
+            .map(|&s| {
+                let dimension = i128::from(self.capacity) / i128::from(s) + 1;
+                usize::try_from(dimension)
+                    .expect("validated integer-knapsack dimension must fit usize")
+            })
+            .collect()
     }
 }
 
@@ -151,6 +190,10 @@ crate::declare_variants! {
     default IntegerKnapsack => "(capacity + 1)^num_items",
 }
 
+crate::register_brute_force! {
+    IntegerKnapsack,
+}
+
 /// Raw representation for serde deserialization with full validation.
 #[derive(Deserialize, Serialize)]
 struct RawIntegerKnapsack {
@@ -170,27 +213,40 @@ impl From<IntegerKnapsack> for RawIntegerKnapsack {
 }
 
 impl TryFrom<RawIntegerKnapsack> for IntegerKnapsack {
-    type Error = String;
+    type Error = ConstructionError;
 
-    fn try_from(raw: RawIntegerKnapsack) -> Result<Self, String> {
+    fn try_from(raw: RawIntegerKnapsack) -> Result<Self, Self::Error> {
         if raw.sizes.len() != raw.values.len() {
-            return Err(format!(
+            return Err(ConstructionError::Conversion(format!(
                 "sizes and values must have the same length, got {} and {}",
                 raw.sizes.len(),
                 raw.values.len()
-            ));
+            )));
         }
         if let Some(&s) = raw.sizes.iter().find(|&&s| s <= 0) {
-            return Err(format!("expected positive sizes, got {s}"));
+            return Err(ConstructionError::Conversion(format!(
+                "expected positive sizes, got {s}"
+            )));
         }
         if let Some(&v) = raw.values.iter().find(|&&v| v <= 0) {
-            return Err(format!("expected positive values, got {v}"));
+            return Err(ConstructionError::Conversion(format!(
+                "expected positive values, got {v}"
+            )));
         }
         if raw.capacity < 0 {
-            return Err(format!(
+            return Err(ConstructionError::Conversion(format!(
                 "expected nonnegative capacity, got {}",
                 raw.capacity
-            ));
+            )));
+        }
+        for &size in &raw.sizes {
+            let dimension = i128::from(raw.capacity) / i128::from(size) + 1;
+            usize::try_from(dimension).map_err(|_| {
+                ConstructionError::IntegerOverflow(format!(
+                    "knapsack dimension for capacity {} and item size {size} does not fit usize",
+                    raw.capacity
+                ))
+            })?;
         }
         Ok(IntegerKnapsack {
             sizes: raw.sizes,
@@ -216,12 +272,10 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     // Optimal: c=(0,0,1,5,0) → total_size=5+10=15, total_value=7+15=22
     vec![crate::example_db::specs::ModelExampleSpec {
         id: "integer-knapsack",
-        instance: Box::new(IntegerKnapsack::new(
-            vec![3, 4, 5, 2, 7],
-            vec![4, 5, 7, 3, 9],
-            15,
-        )),
-        optimal_config: vec![0, 0, 1, 5, 0],
+        instance: Box::new(
+            IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15).unwrap(),
+        ),
+        optimal_config: serde_json::json!(vec![0, 0, 1, 5, 0]),
         optimal_value: serde_json::json!(22),
     }]
 }
diff --git a/src/models/set/maximum_set_packing.rs b/src/models/set/maximum_set_packing.rs
index fb199d5a2..40542427c 100644
--- a/src/models/set/maximum_set_packing.rs
+++ b/src/models/set/maximum_set_packing.rs
@@ -3,7 +3,7 @@
 //! The Set Packing problem asks for a maximum weight collection of
 //! pairwise disjoint sets.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{ConstructionError, CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::traits::Problem;
 use crate::types::{Max, One, WeightElement};
 use num_traits::Zero;
@@ -15,13 +15,11 @@ inventory::submit! {
         name: "MaximumSetPacking",
         display_name: "Maximum Set Packing",
         aliases: &[],
-        dimensions: &[VariantDimension::new("weight", "One", &["One", "i32", "f64"])],
+        dimensions: &[VariantDimension::new("weight", "One", &["One", "i64", "f64"])],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Find maximum weight collection of disjoint sets",
-        fields: &[
-            FieldInfo { name: "sets", type_name: "Vec<Vec<usize>>", description: "Collection of sets over a universe" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Weight for each set" },
-        ],
+        fields: MaximumSetPackingCreateSpec::<One>::FIELDS,
     }
 }
 
@@ -34,11 +32,11 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::set::MaximumSetPacking;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Sets: S0={0,1}, S1={1,2}, S2={2,3}, S3={3,4}
 /// // S0 and S1 overlap, S2 and S3 are disjoint from S0
-/// let problem = MaximumSetPacking::<i32>::new(vec![
+/// let problem = MaximumSetPacking::<i64>::new(vec![
 ///     vec![0, 1],
 ///     vec![1, 2],
 ///     vec![2, 3],
@@ -46,36 +44,81 @@ inventory::submit! {
 /// ]);
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Verify solutions are pairwise disjoint
 /// for sol in solutions {
-///     assert!(problem.evaluate(&sol).is_valid());
+///     assert!(problem.evaluate(&sol).unwrap().is_valid());
 /// }
 /// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MaximumSetPacking<W = i32> {
+#[derive(Debug, Clone, Serialize)]
+pub struct MaximumSetPacking<W = i64> {
     /// Collection of sets.
     sets: Vec<Vec<usize>>,
     /// Weights for each set.
     weights: Vec<W>,
 }
 
+#[derive(Deserialize)]
+struct MaximumSetPackingData<W> {
+    sets: Vec<Vec<usize>>,
+    weights: Vec<W>,
+}
+
+impl<'de, W> Deserialize<'de> for MaximumSetPacking<W>
+where
+    W: WeightElement + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let data = MaximumSetPackingData::deserialize(deserializer)?;
+        Self::with_weights(data.sets, data.weights).map_err(serde::de::Error::custom)
+    }
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MaximumSetPackingCreateSpec<W> {
+    /// Collection of sets over a universe.
+    subsets: Vec<Vec<usize>>,
+    /// Weight for each set.
+    weights: Vec<W>,
+}
+
+impl<W: WeightElement> TryFrom<MaximumSetPackingCreateSpec<W>> for MaximumSetPacking<W> {
+    type Error = ConstructionError;
+
+    fn try_from(spec: MaximumSetPackingCreateSpec<W>) -> Result<Self, Self::Error> {
+        Self::with_weights(spec.subsets, spec.weights)
+    }
+}
+
 impl<W: Clone + Default> MaximumSetPacking<W> {
     /// Create a new Set Packing problem with unit weights.
     pub fn new(sets: Vec<Vec<usize>>) -> Self
     where
-        W: From<i32>,
+        W: WeightElement,
     {
         let num_sets = sets.len();
-        let weights = vec![W::from(1); num_sets];
+        let weights = vec![W::unit(); num_sets];
         Self { sets, weights }
     }
 
     /// Create a new Set Packing problem with custom weights.
-    pub fn with_weights(sets: Vec<Vec<usize>>, weights: Vec<W>) -> Self {
-        assert_eq!(sets.len(), weights.len());
-        Self { sets, weights }
+    pub fn with_weights(sets: Vec<Vec<usize>>, weights: Vec<W>) -> Result<Self, ConstructionError>
+    where
+        W: WeightElement,
+    {
+        if sets.len() != weights.len() {
+            return Err(ConstructionError::Conversion(
+                "weights length must match number of sets".into(),
+            ));
+        }
+        for (index, weight) in weights.iter().enumerate() {
+            weight.validate_element(&format!("set weight at index {index}"))?;
+        }
+        Ok(Self { sets, weights })
     }
 
     /// Get the number of sets.
@@ -131,7 +174,7 @@ impl<W: Clone + Default> MaximumSetPacking<W> {
     }
 
     /// Check if a configuration is a valid set packing.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         is_valid_packing(&self.sets, config)
     }
 }
@@ -141,23 +184,36 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MaximumSetPacking";
+    type Solution = Vec<bool>;
     type Value = Max<W::Sum>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.sets.len()]
-    }
+    crate::problem_parameters![("num_sets", num_sets), ("universe_size", universe_size),];
 
-    fn evaluate(&self, config: &[usize]) -> Max<W::Sum> {
-        if !is_valid_packing(&self.sets, config) {
-            return Max(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Max<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.sets.len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "set-selection length does not match the family".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.weights[i].to_sum();
+        Ok({
+            if !is_valid_packing(&self.sets, config) {
+                return Ok(Max(None));
             }
-        }
-        Max(Some(total))
+            let mut total = W::Sum::zero();
+            for (i, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.weights[i].to_sum(),
+                        "summing selected set-packing weights",
+                    )?;
+                }
+            }
+            Max(Some(total))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -165,18 +221,46 @@ where
     }
 }
 
+impl<W> crate::solvers::BruteForceProblem for MaximumSetPacking<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.sets.len()]
+    }
+}
+
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MaximumSetPackingOneCreateSpec {
+    /// Collection of sets over a universe.
+    subsets: Vec<Vec<usize>>,
+}
+impl TryFrom<MaximumSetPackingOneCreateSpec> for MaximumSetPacking<One> {
+    type Error = ConstructionError;
+    fn try_from(spec: MaximumSetPackingOneCreateSpec) -> Result<Self, Self::Error> {
+        let weights = vec![One; spec.subsets.len()];
+        Self::with_weights(spec.subsets, weights)
+    }
+}
+
 crate::declare_variants! {
-    default MaximumSetPacking<One> => "2^num_sets",
-    MaximumSetPacking<i32> => "2^num_sets",
-    MaximumSetPacking<f64> => "2^num_sets",
+    default MaximumSetPacking<One> => "2^num_sets" create MaximumSetPackingOneCreateSpec,
+    MaximumSetPacking<i64> => "2^num_sets" create MaximumSetPackingCreateSpec<i64>,
+    MaximumSetPacking<f64> => "2^num_sets" create MaximumSetPackingCreateSpec<f64>,
+}
+
+crate::register_brute_force! {
+    MaximumSetPacking<One> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumSetPacking<i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+    MaximumSetPacking<f64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 /// Check if a selection forms a valid set packing (pairwise disjoint).
-fn is_valid_packing(sets: &[Vec<usize>], config: &[usize]) -> bool {
+fn is_valid_packing(sets: &[Vec<usize>], config: &[bool]) -> bool {
     let selected_sets: Vec<_> = config
         .iter()
         .enumerate()
-        .filter(|(_, &s)| s == 1)
+        .filter(|(_, &selected)| selected)
         .map(|(i, _)| i)
         .collect();
 
@@ -199,21 +283,20 @@ pub(crate) fn is_set_packing(sets: &[Vec<usize>], selected: &[bool]) -> bool {
         return false;
     }
 
-    let config: Vec<usize> = selected.iter().map(|&b| if b { 1 } else { 0 }).collect();
-    is_valid_packing(sets, &config)
+    is_valid_packing(sets, selected)
 }
 
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "maximum_set_packing_i32",
-        instance: Box::new(MaximumSetPacking::<i32>::new(vec![
+        id: "maximum_set_packing",
+        instance: Box::new(MaximumSetPacking::<i64>::new(vec![
             vec![0, 1],
             vec![1, 2],
             vec![2, 3],
             vec![3, 4],
         ])),
-        optimal_config: vec![0, 1, 0, 1],
+        optimal_config: serde_json::json!(vec![false, true, false, true]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/set/minimum_cardinality_key.rs b/src/models/set/minimum_cardinality_key.rs
index 7aa90ddaf..89b3a21ac 100644
--- a/src/models/set/minimum_cardinality_key.rs
+++ b/src/models/set/minimum_cardinality_key.rs
@@ -14,6 +14,7 @@ inventory::submit! {
         display_name: "Minimum Cardinality Key",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Find a candidate key of minimum cardinality in a relational system",
         fields: &[
@@ -117,25 +118,36 @@ impl MinimumCardinalityKey {
 
 impl Problem for MinimumCardinalityKey {
     const NAME: &'static str = "MinimumCardinalityKey";
+    type Solution = Vec<bool>;
     type Value = Min<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_attributes]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<i64> {
-        if config.len() != self.num_attributes || config.iter().any(|&v| v > 1) {
-            return Min(None);
-        }
-
-        let selected: Vec<bool> = config.iter().map(|&v| v == 1).collect();
+    crate::problem_parameters![
+        ("num_attributes", num_attributes),
+        ("num_dependencies", num_dependencies),
+    ];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            if config.len() != self.num_attributes {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "attribute-selection length does not match the relation".into(),
+                ));
+            }
 
-        if self.is_key(&selected) {
-            let count = selected.iter().filter(|&&v| v).count();
-            Min(Some(count as i64))
-        } else {
-            Min(None)
-        }
+            if self.is_key(config) {
+                let count = config.iter().filter(|&&v| v).count();
+                Min(Some(i64::try_from(count).map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting selected-attribute count to i64".into(),
+                    )
+                })?))
+            } else {
+                Min(None)
+            }
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -143,10 +155,20 @@ impl Problem for MinimumCardinalityKey {
     }
 }
 
+impl crate::solvers::BruteForceProblem for MinimumCardinalityKey {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_attributes]
+    }
+}
+
 crate::declare_variants! {
     default MinimumCardinalityKey => "2^num_attributes",
 }
 
+crate::register_brute_force! {
+    MinimumCardinalityKey decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -160,7 +182,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 (vec![2, 4], vec![5]),
             ],
         )),
-        optimal_config: vec![1, 1, 0, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![true, true, false, false, false, false]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/set/minimum_hitting_set.rs b/src/models/set/minimum_hitting_set.rs
index e7b0d47d2..ca2aa38d2 100644
--- a/src/models/set/minimum_hitting_set.rs
+++ b/src/models/set/minimum_hitting_set.rs
@@ -3,7 +3,7 @@
 //! The Minimum Hitting Set problem asks for a minimum-size subset of universe
 //! elements that intersects every set in a collection.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, ProblemSizeFieldEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use crate::types::Min;
 use serde::{Deserialize, Serialize};
@@ -14,19 +14,10 @@ inventory::submit! {
         display_name: "Minimum Hitting Set",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Find a minimum-size subset of universe elements that hits every set",
-        fields: &[
-            FieldInfo { name: "universe_size", type_name: "usize", description: "Size of the universe U" },
-            FieldInfo { name: "sets", type_name: "Vec<Vec<usize>>", description: "Collection of subsets of U that must each be hit" },
-        ],
-    }
-}
-
-inventory::submit! {
-    ProblemSizeFieldEntry {
-        name: "MinimumHittingSet",
-        fields: &["num_sets", "universe_size"],
+        fields: MinimumHittingSetCreateSpec::FIELDS,
     }
 }
 
@@ -40,6 +31,31 @@ pub struct MinimumHittingSet {
     sets: Vec<Vec<usize>>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumHittingSetCreateSpec {
+    /// Size of the universe U.
+    universe_size: usize,
+    /// Collection of subsets of U that must each be hit.
+    subsets: Vec<Vec<usize>>,
+}
+
+impl TryFrom<MinimumHittingSetCreateSpec> for MinimumHittingSet {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: MinimumHittingSetCreateSpec) -> Result<Self, Self::Error> {
+        for (set_index, set) in spec.subsets.iter().enumerate() {
+            if let Some(&element) = set.iter().find(|&&element| element >= spec.universe_size) {
+                return Err(format!(
+                    "subsets[{set_index}] contains element {element} outside universe of size {}",
+                    spec.universe_size
+                )
+                .into());
+            }
+        }
+        Ok(Self::new(spec.universe_size, spec.subsets))
+    }
+}
+
 impl MinimumHittingSet {
     /// Create a new Minimum Hitting Set instance.
     ///
@@ -86,24 +102,22 @@ impl MinimumHittingSet {
     }
 
     /// Decode the selected universe elements from a binary configuration.
-    pub fn selected_elements(&self, config: &[usize]) -> Option<Vec<usize>> {
+    pub fn selected_elements(&self, config: &[bool]) -> Option<Vec<usize>> {
         if config.len() != self.universe_size {
             return None;
         }
 
         let mut selected = Vec::new();
-        for (element, &value) in config.iter().enumerate() {
-            match value {
-                0 => {}
-                1 => selected.push(element),
-                _ => return None,
+        for (element, &is_selected) in config.iter().enumerate() {
+            if is_selected {
+                selected.push(element);
             }
         }
         Some(selected)
     }
 
     /// Check whether a configuration hits every set in the collection.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         let Some(selected) = self.selected_elements(config) else {
             return false;
         };
@@ -117,25 +131,35 @@ impl MinimumHittingSet {
 
 impl Problem for MinimumHittingSet {
     const NAME: &'static str = "MinimumHittingSet";
-    type Value = Min<usize>;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.universe_size]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Min<usize> {
-        let Some(selected) = self.selected_elements(config) else {
-            return Min(None);
-        };
-
-        if self.sets.iter().all(|set| {
-            set.iter()
-                .any(|element| selected.binary_search(element).is_ok())
-        }) {
-            Min(Some(selected.len()))
-        } else {
-            Min(None)
-        }
+    type Solution = Vec<bool>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_sets", num_sets), ("universe_size", universe_size),];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<i64>, crate::traits::EvaluationError> {
+        Ok({
+            let Some(selected) = self.selected_elements(config) else {
+                return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                    "element-selection length does not match the universe".into(),
+                ));
+            };
+
+            if self.sets.iter().all(|set| {
+                set.iter()
+                    .any(|element| selected.binary_search(element).is_ok())
+            }) {
+                Min(Some(i64::try_from(selected.len()).map_err(|_| {
+                    crate::traits::EvaluationError::IntegerOverflow(
+                        "converting hitting-set cardinality to i64".into(),
+                    )
+                })?))
+            } else {
+                Min(None)
+            }
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -143,8 +167,18 @@ impl Problem for MinimumHittingSet {
     }
 }
 
+impl crate::solvers::BruteForceProblem for MinimumHittingSet {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.universe_size]
+    }
+}
+
 crate::declare_variants! {
-    default MinimumHittingSet => "2^universe_size",
+    default MinimumHittingSet => "2^universe_size" create MinimumHittingSetCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumHittingSet decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -163,7 +197,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 vec![1, 4],
             ],
         )),
-        optimal_config: vec![0, 1, 0, 1, 1, 0],
+        optimal_config: serde_json::json!(vec![false, true, false, true, true, false]),
         optimal_value: serde_json::json!(3),
     }]
 }
diff --git a/src/models/set/minimum_set_covering.rs b/src/models/set/minimum_set_covering.rs
index 4387375a5..81748fc00 100644
--- a/src/models/set/minimum_set_covering.rs
+++ b/src/models/set/minimum_set_covering.rs
@@ -3,7 +3,7 @@
 //! The Set Covering problem asks for a minimum weight collection of sets
 //! that covers all elements in the universe.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry, VariantDimension};
+use crate::registry::{CreateSpec, ProblemSchemaEntry, VariantDimension};
 use crate::traits::Problem;
 use crate::types::{Min, WeightElement};
 use num_traits::Zero;
@@ -15,14 +15,11 @@ inventory::submit! {
         name: "MinimumSetCovering",
         display_name: "Minimum Set Covering",
         aliases: &[],
-        dimensions: &[VariantDimension::new("weight", "i32", &["i32"])],
+        dimensions: &[VariantDimension::new("weight", "i64", &["i64"])],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Find minimum weight collection covering the universe",
-        fields: &[
-            FieldInfo { name: "universe_size", type_name: "usize", description: "Size of the universe U" },
-            FieldInfo { name: "sets", type_name: "Vec<Vec<usize>>", description: "Collection of subsets of U" },
-            FieldInfo { name: "weights", type_name: "Vec<W>", description: "Weight for each set" },
-        ],
+        fields: MinimumSetCoveringCreateSpec::FIELDS,
     }
 }
 
@@ -36,11 +33,11 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::set::MinimumSetCovering;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Universe: {0, 1, 2, 3}
 /// // Sets: S0={0,1}, S1={1,2}, S2={2,3}, S3={0,3}
-/// let problem = MinimumSetCovering::<i32>::new(
+/// let problem = MinimumSetCovering::<i64>::new(
 ///     4, // universe size
 ///     vec![
 ///         vec![0, 1],
@@ -51,15 +48,15 @@ inventory::submit! {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // Verify solutions cover all elements
 /// for sol in solutions {
-///     assert!(problem.evaluate(&sol).is_valid());
+///     assert!(problem.evaluate(&sol).unwrap().is_valid());
 /// }
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MinimumSetCovering<W = i32> {
+pub struct MinimumSetCovering<W = i64> {
     /// Size of the universe (elements are 0..universe_size).
     universe_size: usize,
     /// Collection of sets, each represented as a vector of elements.
@@ -68,14 +65,53 @@ pub struct MinimumSetCovering<W = i32> {
     weights: Vec<W>,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct MinimumSetCoveringCreateSpec {
+    /// Size of the universe U.
+    universe_size: usize,
+    /// Collection of subsets of U.
+    subsets: Vec<Vec<usize>>,
+    /// Weight for each subset.
+    weights: Vec<i64>,
+}
+
+impl TryFrom<MinimumSetCoveringCreateSpec> for MinimumSetCovering<i64> {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: MinimumSetCoveringCreateSpec) -> Result<Self, Self::Error> {
+        if spec.subsets.len() != spec.weights.len() {
+            return Err(format!(
+                "weights has {} entries, expected one for each of {} subsets",
+                spec.weights.len(),
+                spec.subsets.len()
+            )
+            .into());
+        }
+        for (set_index, set) in spec.subsets.iter().enumerate() {
+            if let Some(&element) = set.iter().find(|&&element| element >= spec.universe_size) {
+                return Err(format!(
+                    "subsets[{set_index}] contains element {element} outside universe of size {}",
+                    spec.universe_size
+                )
+                .into());
+            }
+        }
+        Ok(Self::with_weights(
+            spec.universe_size,
+            spec.subsets,
+            spec.weights,
+        ))
+    }
+}
+
 impl<W: Clone + Default> MinimumSetCovering<W> {
     /// Create a new Set Covering problem with unit weights.
     pub fn new(universe_size: usize, sets: Vec<Vec<usize>>) -> Self
     where
-        W: From<i32>,
+        W: WeightElement,
     {
         let num_sets = sets.len();
-        let weights = vec![W::from(1); num_sets];
+        let weights = vec![W::unit(); num_sets];
         Self {
             universe_size,
             sets,
@@ -119,16 +155,16 @@ impl<W: Clone + Default> MinimumSetCovering<W> {
     }
 
     /// Check if a configuration is a valid set cover.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
+    pub fn is_valid_solution(&self, config: &[bool]) -> bool {
         let covered = self.covered_elements(config);
         covered.len() == self.universe_size && (0..self.universe_size).all(|e| covered.contains(&e))
     }
 
     /// Check which elements are covered by selected sets.
-    pub fn covered_elements(&self, config: &[usize]) -> HashSet<usize> {
+    pub fn covered_elements(&self, config: &[bool]) -> HashSet<usize> {
         let mut covered = HashSet::new();
         for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
+            if selected {
                 if let Some(set) = self.sets.get(i) {
                     covered.extend(set.iter().copied());
                 }
@@ -143,26 +179,39 @@ where
     W: WeightElement + crate::variant::VariantParam,
 {
     const NAME: &'static str = "MinimumSetCovering";
+    type Solution = Vec<bool>;
     type Value = Min<W::Sum>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.sets.len()]
-    }
+    crate::problem_parameters![("num_sets", num_sets), ("universe_size", universe_size),];
 
-    fn evaluate(&self, config: &[usize]) -> Min<W::Sum> {
-        let covered = self.covered_elements(config);
-        let is_valid = covered.len() == self.universe_size
-            && (0..self.universe_size).all(|e| covered.contains(&e));
-        if !is_valid {
-            return Min(None);
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Min<W::Sum>, crate::traits::EvaluationError> {
+        if config.len() != self.sets.len() {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "set-selection length does not match the family".into(),
+            ));
         }
-        let mut total = W::Sum::zero();
-        for (i, &selected) in config.iter().enumerate() {
-            if selected == 1 {
-                total += self.weights[i].to_sum();
+        Ok({
+            let covered = self.covered_elements(config);
+            let is_valid = covered.len() == self.universe_size
+                && (0..self.universe_size).all(|e| covered.contains(&e));
+            if !is_valid {
+                return Ok(Min(None));
             }
-        }
-        Min(Some(total))
+            let mut total = W::Sum::zero();
+            for (i, &selected) in config.iter().enumerate() {
+                if selected {
+                    total = W::checked_add_to_sum(
+                        total,
+                        self.weights[i].to_sum(),
+                        "summing selected set-cover weights",
+                    )?;
+                }
+            }
+            Min(Some(total))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -170,8 +219,21 @@ where
     }
 }
 
+impl<W> crate::solvers::BruteForceProblem for MinimumSetCovering<W>
+where
+    W: WeightElement + crate::variant::VariantParam,
+{
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.sets.len()]
+    }
+}
+
 crate::declare_variants! {
-    default MinimumSetCovering<i32> => "2^num_sets",
+    default MinimumSetCovering<i64> => "2^num_sets" create MinimumSetCoveringCreateSpec,
+}
+
+crate::register_brute_force! {
+    MinimumSetCovering<i64> decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 /// Check if a selection of sets forms a valid set cover.
@@ -194,12 +256,12 @@ pub(crate) fn is_set_cover(universe_size: usize, sets: &[Vec<usize>], selected:
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
-        id: "minimum_set_covering_i32",
-        instance: Box::new(MinimumSetCovering::<i32>::new(
+        id: "minimum_set_covering",
+        instance: Box::new(MinimumSetCovering::<i64>::new(
             5,
             vec![vec![0, 1, 2], vec![1, 3], vec![2, 3, 4]],
         )),
-        optimal_config: vec![1, 0, 1],
+        optimal_config: serde_json::json!(vec![true, false, true]),
         optimal_value: serde_json::json!(2),
     }]
 }
diff --git a/src/models/set/mod.rs b/src/models/set/mod.rs
index 970cb314c..dd8f5115b 100644
--- a/src/models/set/mod.rs
+++ b/src/models/set/mod.rs
@@ -13,7 +13,6 @@
 //! - [`SetBasis`]: Minimum-cardinality basis generating all sets by union
 //! - [`SetSplitting`]: 2-color universe so every specified subset is non-monochromatic
 //! - [`ThreeDimensionalMatching`]: Perfect matching in a tripartite 3-uniform hypergraph
-//! - [`ThreeMatroidIntersection`]: Common independent set of size K in three partition matroids
 //! - [`TwoDimensionalConsecutiveSets`]: 2D consecutive arrangement of subset elements
 //! - [`MinimumCardinalityKey`]: Smallest attribute set that uniquely identifies tuples
 
@@ -30,7 +29,6 @@ pub(crate) mod rooted_tree_storage_assignment;
 pub(crate) mod set_basis;
 pub(crate) mod set_splitting;
 pub(crate) mod three_dimensional_matching;
-pub(crate) mod three_matroid_intersection;
 pub(crate) mod two_dimensional_consecutive_sets;
 
 pub use comparative_containment::ComparativeContainment;
@@ -46,7 +44,6 @@ pub use rooted_tree_storage_assignment::RootedTreeStorageAssignment;
 pub use set_basis::SetBasis;
 pub use set_splitting::SetSplitting;
 pub use three_dimensional_matching::ThreeDimensionalMatching;
-pub use three_matroid_intersection::ThreeMatroidIntersection;
 pub use two_dimensional_consecutive_sets::TwoDimensionalConsecutiveSets;
 
 #[cfg(feature = "example-db")]
@@ -65,7 +62,6 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
     specs.extend(set_basis::canonical_model_example_specs());
     specs.extend(set_splitting::canonical_model_example_specs());
     specs.extend(three_dimensional_matching::canonical_model_example_specs());
-    specs.extend(three_matroid_intersection::canonical_model_example_specs());
     specs.extend(two_dimensional_consecutive_sets::canonical_model_example_specs());
     specs
 }
diff --git a/src/models/set/prime_attribute_name.rs b/src/models/set/prime_attribute_name.rs
index 96a9741e1..42a3c1839 100644
--- a/src/models/set/prime_attribute_name.rs
+++ b/src/models/set/prime_attribute_name.rs
@@ -3,7 +3,7 @@
 //! Given a set of attributes A, a collection of functional dependencies F on A,
 //! and a query attribute x, determine if x belongs to any candidate key of <A, F>.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -13,13 +13,10 @@ inventory::submit! {
         display_name: "Prime Attribute Name",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Determine if an attribute belongs to any candidate key under functional dependencies",
-        fields: &[
-            FieldInfo { name: "num_attributes", type_name: "usize", description: "Number of attributes" },
-            FieldInfo { name: "dependencies", type_name: "Vec<(Vec<usize>, Vec<usize>)>", description: "Functional dependencies (lhs, rhs) pairs" },
-            FieldInfo { name: "query_attribute", type_name: "usize", description: "The query attribute index" },
-        ],
+        fields: PrimeAttributeNameCreateSpec::FIELDS,
     }
 }
 
@@ -40,7 +37,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::set::PrimeAttributeName;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // 6 attributes, FDs: {0,1}->rest, {2,3}->rest, {0,3}->rest
 /// let problem = PrimeAttributeName::new(
@@ -54,10 +51,12 @@ inventory::submit! {
 /// );
 ///
 /// // {2, 3} is a candidate key containing attribute 3
-/// assert!(problem.evaluate(&[0, 0, 1, 1, 0, 0]));
+/// assert!(problem
+///     .evaluate(&vec![false, false, true, true, false, false])
+///     .unwrap());
 ///
 /// let solver = BruteForce::new();
-/// let solution = solver.find_witness(&problem);
+/// let solution = solver.solve(&problem).unwrap();
 /// assert!(solution.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -70,6 +69,52 @@ pub struct PrimeAttributeName {
     query_attribute: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct PrimeAttributeNameCreateSpec {
+    /// Number of attributes.
+    universe_size: usize,
+    /// Functional dependencies (lhs, rhs) pairs.
+    dependencies: Vec<(Vec<usize>, Vec<usize>)>,
+    /// The query attribute index.
+    query_attribute: usize,
+}
+
+impl TryFrom<PrimeAttributeNameCreateSpec> for PrimeAttributeName {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: PrimeAttributeNameCreateSpec) -> Result<Self, Self::Error> {
+        if spec.query_attribute >= spec.universe_size {
+            return Err(format!(
+                "query_attribute {} is outside universe of size {}",
+                spec.query_attribute, spec.universe_size
+            )
+            .into());
+        }
+        for (dependency_index, (lhs, rhs)) in spec.dependencies.iter().enumerate() {
+            if lhs.is_empty() {
+                return Err(
+                    format!("dependencies[{dependency_index}] has an empty left side").into(),
+                );
+            }
+            if let Some(&attribute) = lhs
+                .iter()
+                .chain(rhs)
+                .find(|&&attribute| attribute >= spec.universe_size)
+            {
+                return Err(format!(
+                    "dependencies[{dependency_index}] contains attribute {attribute} outside universe of size {}",
+                    spec.universe_size
+                ).into());
+            }
+        }
+        Ok(Self::new(
+            spec.universe_size,
+            spec.dependencies,
+            spec.query_attribute,
+        ))
+    }
+}
+
 impl PrimeAttributeName {
     /// Create a new Prime Attribute Name problem.
     ///
@@ -155,47 +200,52 @@ impl PrimeAttributeName {
 
 impl Problem for PrimeAttributeName {
     const NAME: &'static str = "PrimeAttributeName";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_attributes]
-    }
+    crate::problem_parameters![
+        ("num_attributes", num_attributes),
+        ("num_dependencies", num_dependencies),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            // Check config length and binary values
-            if config.len() != self.num_attributes || config.iter().any(|&v| v > 1) {
-                return crate::types::Or(false);
-            }
-
-            // K = {i : config[i] = 1}
-            let k: Vec<bool> = config.iter().map(|&v| v == 1).collect();
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.num_attributes {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "attribute-selection length does not match the relation".into(),
+                    ));
+                }
 
-            // query_attribute must be in K
-            if !k[self.query_attribute] {
-                return crate::types::Or(false);
-            }
+                // query_attribute must be in K
+                if !config[self.query_attribute] {
+                    return Ok(crate::types::Or(false));
+                }
 
-            // Compute closure(K) -- must equal all attributes (K is a superkey)
-            let closure = self.compute_closure(&k);
-            if closure.iter().any(|&v| !v) {
-                return crate::types::Or(false);
-            }
+                // Compute closure(K) -- must equal all attributes (K is a superkey)
+                let closure = self.compute_closure(config);
+                if closure.iter().any(|&v| !v) {
+                    return Ok(crate::types::Or(false));
+                }
 
-            // Check minimality: removing any attribute from K must break the superkey property
-            for i in 0..self.num_attributes {
-                if k[i] {
-                    let mut reduced = k.clone();
-                    reduced[i] = false;
-                    let reduced_closure = self.compute_closure(&reduced);
-                    if reduced_closure.iter().all(|&v| v) {
-                        // K \ {i} is still a superkey, so K is not minimal
-                        return crate::types::Or(false);
+                // Check minimality: removing any attribute from K must break the superkey property
+                for i in 0..self.num_attributes {
+                    if config[i] {
+                        let mut reduced = config.clone();
+                        reduced[i] = false;
+                        let reduced_closure = self.compute_closure(&reduced);
+                        if reduced_closure.iter().all(|&v| v) {
+                            // K \ {i} is still a superkey, so K is not minimal
+                            return Ok(crate::types::Or(false));
+                        }
                     }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 
@@ -204,8 +254,18 @@ impl Problem for PrimeAttributeName {
     }
 }
 
+impl crate::solvers::BruteForceProblem for PrimeAttributeName {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_attributes]
+    }
+}
+
 crate::declare_variants! {
-    default PrimeAttributeName => "2^num_attributes * num_dependencies * num_attributes",
+    default PrimeAttributeName => "2^num_attributes * num_dependencies * num_attributes" create PrimeAttributeNameCreateSpec,
+}
+
+crate::register_brute_force! {
+    PrimeAttributeName decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
 }
 
 #[cfg(feature = "example-db")]
@@ -223,7 +283,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             3,
         )),
         // {2, 3} is a candidate key containing attribute 3
-        optimal_config: vec![0, 0, 1, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![false, false, true, true, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/set/rooted_tree_storage_assignment.rs b/src/models/set/rooted_tree_storage_assignment.rs
index b4138f5af..1593976d0 100644
--- a/src/models/set/rooted_tree_storage_assignment.rs
+++ b/src/models/set/rooted_tree_storage_assignment.rs
@@ -11,12 +11,13 @@ inventory::submit! {
         display_name: "Rooted Tree Storage Assignment",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Does there exist a rooted tree whose subset path extensions cost at most K?",
         fields: &[
             FieldInfo { name: "universe_size", type_name: "usize", description: "Size of the ground set X" },
             FieldInfo { name: "subsets", type_name: "Vec<Vec<usize>>", description: "Collection of subsets of X" },
-            FieldInfo { name: "bound", type_name: "usize", description: "Upper bound K on the total extension cost" },
+            FieldInfo { name: "bound", type_name: "i64", description: "Upper bound K on the total extension cost" },
         ],
     }
 }
@@ -26,26 +27,26 @@ inventory::submit! {
 pub struct RootedTreeStorageAssignment {
     universe_size: usize,
     subsets: Vec<Vec<usize>>,
-    bound: usize,
+    bound: i64,
 }
 
 #[derive(Debug, Deserialize)]
 struct RootedTreeStorageAssignmentDef {
     universe_size: usize,
     subsets: Vec<Vec<usize>>,
-    bound: usize,
+    bound: i64,
 }
 
 impl RootedTreeStorageAssignment {
-    pub fn new(universe_size: usize, subsets: Vec<Vec<usize>>, bound: usize) -> Self {
+    pub fn new(universe_size: usize, subsets: Vec<Vec<usize>>, bound: i64) -> Self {
         Self::try_new(universe_size, subsets, bound).unwrap_or_else(|err| panic!("{err}"))
     }
 
     pub fn try_new(
         universe_size: usize,
         subsets: Vec<Vec<usize>>,
-        bound: usize,
-    ) -> Result<Self, String> {
+        bound: i64,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         let subsets = subsets
             .into_iter()
             .enumerate()
@@ -53,14 +54,14 @@ impl RootedTreeStorageAssignment {
                 let mut seen = HashSet::with_capacity(subset.len());
                 for &element in &subset {
                     if element >= universe_size {
-                        return Err(format!(
+                        return Err::<Vec<usize>, crate::registry::ConstructionError>(format!(
                             "subset {subset_index} contains element {element} outside universe of size {universe_size}"
-                        ));
+                        ).into());
                     }
                     if !seen.insert(element) {
-                        return Err(format!(
+                        return Err::<Vec<usize>, crate::registry::ConstructionError>(format!(
                             "subset {subset_index} contains duplicate element {element}"
-                        ));
+                        ).into());
                     }
                 }
                 subset.sort_unstable();
@@ -87,7 +88,7 @@ impl RootedTreeStorageAssignment {
         &self.subsets
     }
 
-    pub fn bound(&self) -> usize {
+    pub fn bound(&self) -> i64 {
         self.bound
     }
 
@@ -174,40 +175,60 @@ impl RootedTreeStorageAssignment {
 
 impl Problem for RootedTreeStorageAssignment {
     const NAME: &'static str = "RootedTreeStorageAssignment";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.universe_size; self.universe_size]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.universe_size {
-                return crate::types::Or(false);
-            }
-            if config.iter().any(|&parent| parent >= self.universe_size) {
-                return crate::types::Or(false);
-            }
-            if self.universe_size == 0 {
-                return crate::types::Or(self.subsets.is_empty());
-            }
+    crate::problem_parameters![
+        ("num_subsets", num_subsets),
+        ("universe_size", universe_size),
+    ];
 
-            let Some(depth) = Self::analyze_tree(config) else {
-                return crate::types::Or(false);
-            };
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.universe_size {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "parent assignment length does not match the universe".into(),
+                    ));
+                }
+                if config.iter().any(|&parent| parent >= self.universe_size) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "parent assignment contains an out-of-range element".into(),
+                    ));
+                }
+                if self.universe_size == 0 {
+                    return Ok(crate::types::Or(self.subsets.is_empty()));
+                }
 
-            let mut total_cost = 0usize;
-            for subset in &self.subsets {
-                let Some(cost) = self.subset_extension_cost(subset, config, &depth) else {
-                    return crate::types::Or(false);
+                let Some(depth) = Self::analyze_tree(config) else {
+                    return Ok(crate::types::Or(false));
                 };
-                total_cost += cost;
-                if total_cost > self.bound {
-                    return crate::types::Or(false);
+
+                let mut total_cost = 0_i64;
+                for subset in &self.subsets {
+                    let Some(cost) = self.subset_extension_cost(subset, config, &depth) else {
+                        return Ok(crate::types::Or(false));
+                    };
+                    let cost = i64::try_from(cost).map_err(|_| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "converting a rooted-tree storage assignment cost to i64".to_string(),
+                        )
+                    })?;
+                    total_cost = total_cost.checked_add(cost).ok_or_else(|| {
+                        crate::traits::EvaluationError::IntegerOverflow(
+                            "summing rooted-tree storage assignment costs".to_string(),
+                        )
+                    })?;
+                    if total_cost > self.bound {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 
@@ -216,10 +237,20 @@ impl Problem for RootedTreeStorageAssignment {
     }
 }
 
+impl crate::solvers::BruteForceProblem for RootedTreeStorageAssignment {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.universe_size; self.universe_size]
+    }
+}
+
 crate::declare_variants! {
     default RootedTreeStorageAssignment => "universe_size^universe_size",
 }
 
+crate::register_brute_force! {
+    RootedTreeStorageAssignment,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -229,13 +260,13 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![vec![0, 2], vec![1, 3], vec![0, 4], vec![2, 4]],
             1,
         )),
-        optimal_config: vec![0, 0, 0, 1, 2],
+        optimal_config: serde_json::json!(vec![0, 0, 0, 1, 2]),
         optimal_value: serde_json::json!(true),
     }]
 }
 
 impl TryFrom<RootedTreeStorageAssignmentDef> for RootedTreeStorageAssignment {
-    type Error = String;
+    type Error = crate::registry::ConstructionError;
 
     fn try_from(value: RootedTreeStorageAssignmentDef) -> Result<Self, Self::Error> {
         Self::try_new(value.universe_size, value.subsets, value.bound)
diff --git a/src/models/set/set_basis.rs b/src/models/set/set_basis.rs
index e1b9f92bf..be76ee298 100644
--- a/src/models/set/set_basis.rs
+++ b/src/models/set/set_basis.rs
@@ -4,7 +4,7 @@
 //! determine whether there exist `k` basis sets such that every target set
 //! can be reconstructed as a union of some subcollection of the basis.
 
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
+use crate::registry::{CreateSpec, ProblemSchemaEntry};
 use crate::traits::Problem;
 use serde::{Deserialize, Serialize};
 
@@ -14,13 +14,10 @@ inventory::submit! {
         display_name: "Set Basis",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Determine whether a collection of sets admits a basis of size k under union",
-        fields: &[
-            FieldInfo { name: "universe_size", type_name: "usize", description: "Size of the ground set S" },
-            FieldInfo { name: "collection", type_name: "Vec<Vec<usize>>", description: "Collection C of target subsets of S" },
-            FieldInfo { name: "k", type_name: "usize", description: "Required number of basis sets" },
-        ],
+        fields: SetBasisCreateSpec::FIELDS,
     }
 }
 
@@ -40,6 +37,33 @@ pub struct SetBasis {
     k: usize,
 }
 
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+struct SetBasisCreateSpec {
+    /// Size of the ground set S.
+    universe_size: usize,
+    /// Collection C of target subsets of S.
+    subsets: Vec<Vec<usize>>,
+    /// Required number of basis sets.
+    k: usize,
+}
+
+impl TryFrom<SetBasisCreateSpec> for SetBasis {
+    type Error = crate::registry::ConstructionError;
+
+    fn try_from(spec: SetBasisCreateSpec) -> Result<Self, Self::Error> {
+        for (set_index, set) in spec.subsets.iter().enumerate() {
+            if let Some(&element) = set.iter().find(|&&element| element >= spec.universe_size) {
+                return Err(format!(
+                    "subsets[{set_index}] contains element {element} outside universe of size {}",
+                    spec.universe_size
+                )
+                .into());
+            }
+        }
+        Ok(Self::new(spec.universe_size, spec.subsets, spec.k))
+    }
+}
+
 impl SetBasis {
     /// Create a new Set Basis instance.
     ///
@@ -95,28 +119,36 @@ impl SetBasis {
     }
 
     /// Check whether the configuration is a satisfying Set Basis solution.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
-    }
-
-    fn decode_basis(&self, config: &[usize]) -> Option<Vec<Vec<usize>>> {
-        let expected_len = self.k * self.universe_size;
-        if config.len() != expected_len || config.iter().any(|&value| value > 1) {
-            return None;
+    pub fn is_valid_solution(
+        &self,
+        solution: &[Vec<bool>],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if solution.len() != self.k
+            || solution
+                .iter()
+                .any(|subset| subset.len() != self.universe_size)
+        {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "set-basis dimensions do not match the instance".into(),
+            ));
         }
+        let basis = Self::decode_basis(solution);
+        Ok(self
+            .collection
+            .iter()
+            .all(|target| Self::can_represent_target(&basis, target, self.universe_size)))
+    }
 
-        let mut basis = Vec::with_capacity(self.k);
-        for row in 0..self.k {
-            let mut subset = Vec::new();
-            let start = row * self.universe_size;
-            for element in 0..self.universe_size {
-                if config[start + element] == 1 {
-                    subset.push(element);
-                }
-            }
-            basis.push(subset);
-        }
-        Some(basis)
+    fn decode_basis(solution: &[Vec<bool>]) -> Vec<Vec<usize>> {
+        solution
+            .iter()
+            .map(|row| {
+                row.iter()
+                    .enumerate()
+                    .filter_map(|(element, &selected)| selected.then_some(element))
+                    .collect()
+            })
+            .collect()
     }
 
     fn is_subset(candidate: &[usize], target_membership: &[bool]) -> bool {
@@ -147,22 +179,20 @@ impl SetBasis {
 
 impl Problem for SetBasis {
     const NAME: &'static str = "SetBasis";
+    type Solution = Vec<Vec<bool>>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.k * self.universe_size]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            let Some(basis) = self.decode_basis(config) else {
-                return crate::types::Or(false);
-            };
-
-            self.collection
-                .iter()
-                .all(|target| Self::can_represent_target(&basis, target, self.universe_size))
-        })
+    crate::problem_parameters![
+        ("universe_size", universe_size),
+        ("num_sets", num_sets),
+        ("basis_size", basis_size),
+    ];
+
+    fn evaluate(
+        &self,
+        solution: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok(crate::types::Or(self.is_valid_solution(solution)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -170,8 +200,18 @@ impl Problem for SetBasis {
     }
 }
 
+impl crate::solvers::BruteForceProblem for SetBasis {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.k * self.universe_size]
+    }
+}
+
 crate::declare_variants! {
-    default SetBasis => "2^(basis_size * universe_size)",
+    default SetBasis => "2^(basis_size * universe_size)" create SetBasisCreateSpec,
+}
+
+crate::register_brute_force! {
+    SetBasis decode |problem: &SetBasis, indices: Vec<usize>| if problem.universe_size() == 0 { vec![Vec::new(); problem.basis_size()] } else { indices.chunks(problem.universe_size()).map(crate::config::config_to_bits).collect() },
 }
 
 #[cfg(feature = "example-db")]
@@ -183,7 +223,11 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             vec![vec![0, 1], vec![1, 2], vec![0, 2], vec![0, 1, 2]],
             3,
         )),
-        optimal_config: vec![0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0],
+        optimal_config: serde_json::json!(vec![
+            vec![false, false, true, false],
+            vec![false, true, false, false],
+            vec![true, false, false, false]
+        ]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/set/set_splitting.rs b/src/models/set/set_splitting.rs
index e63053aa7..1c7f46a76 100644
--- a/src/models/set/set_splitting.rs
+++ b/src/models/set/set_splitting.rs
@@ -13,6 +13,7 @@ inventory::submit! {
         display_name: "Set Splitting",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Partition a universe into two parts so that every subset is non-monochromatic",
         fields: &[
@@ -34,7 +35,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::set::SetSplitting;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Universe {0,1,2,3,4,5}, subsets that all must be split
 /// let problem = SetSplitting::new(6, vec![
@@ -45,7 +46,7 @@ inventory::submit! {
 /// ]);
 ///
 /// let solver = BruteForce::new();
-/// let witness = solver.find_witness(&problem);
+/// let witness = solver.solve(&problem).unwrap();
 /// assert!(witness.is_some());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -98,21 +99,26 @@ impl SetSplitting {
     }
 
     /// Create a new Set Splitting problem, returning an error instead of panicking.
-    pub fn try_new(universe_size: usize, subsets: Vec<Vec<usize>>) -> Result<Self, String> {
+    pub fn try_new(
+        universe_size: usize,
+        subsets: Vec<Vec<usize>>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         for (i, subset) in subsets.iter().enumerate() {
             if subset.len() < 2 {
                 return Err(format!(
                     "Subset {} has {} element(s), expected at least 2",
                     i,
                     subset.len()
-                ));
+                )
+                .into());
             }
             for &elem in subset {
                 if elem >= universe_size {
                     return Err(format!(
                         "Subset {} contains element {} which is outside universe of size {}",
                         i, elem, universe_size
-                    ));
+                    )
+                    .into());
                 }
             }
         }
@@ -164,25 +170,38 @@ impl SetSplitting {
     }
 
     /// Check if a coloring (config) splits all subsets.
-    pub fn is_valid_solution(&self, config: &[usize]) -> bool {
-        self.evaluate(config).0
+    pub fn is_valid_solution(
+        &self,
+        config: &[bool],
+    ) -> Result<bool, crate::traits::EvaluationError> {
+        if config.len() != self.universe_size {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "partition assignment length does not match the universe".into(),
+            ));
+        }
+        Ok(self.subsets.iter().all(|subset| {
+            let has_zero = subset.iter().any(|&element| !config[element]);
+            let has_one = subset.iter().any(|&element| config[element]);
+            has_zero && has_one
+        }))
     }
 }
 
 impl Problem for SetSplitting {
     const NAME: &'static str = "SetSplitting";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.universe_size]
-    }
+    crate::problem_parameters![
+        ("num_subsets", num_subsets),
+        ("universe_size", universe_size),
+    ];
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or(self.subsets.iter().all(|subset| {
-            let has_zero = subset.iter().any(|&e| config[e] == 0);
-            let has_one = subset.iter().any(|&e| config[e] == 1);
-            has_zero && has_one
-        }))
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok(crate::types::Or(self.is_valid_solution(config)?))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -190,10 +209,20 @@ impl Problem for SetSplitting {
     }
 }
 
+impl crate::solvers::BruteForceProblem for SetSplitting {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.universe_size]
+    }
+}
+
 crate::declare_variants! {
     default SetSplitting => "2^universe_size",
 }
 
+crate::register_brute_force! {
+    SetSplitting decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[derive(Debug, Clone, Deserialize)]
 struct SetSplittingDef {
     universe_size: usize,
@@ -201,7 +230,7 @@ struct SetSplittingDef {
 }
 
 impl TryFrom<SetSplittingDef> for SetSplitting {
-    type Error = String;
+    type Error = crate::registry::ConstructionError;
 
     fn try_from(value: SetSplittingDef) -> Result<Self, Self::Error> {
         Self::try_new(value.universe_size, value.subsets)
@@ -218,7 +247,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
         )),
         // config[i]=0 means element i in S1, config[i]=1 means element i in S2
         // S1={1,3,4}, S2={0,2,5} → config [1,0,1,0,0,1]
-        optimal_config: vec![1, 0, 1, 0, 0, 1],
+        optimal_config: serde_json::json!(vec![true, false, true, false, false, true]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/set/three_dimensional_matching.rs b/src/models/set/three_dimensional_matching.rs
index fcad38548..6b7fb2641 100644
--- a/src/models/set/three_dimensional_matching.rs
+++ b/src/models/set/three_dimensional_matching.rs
@@ -15,6 +15,7 @@ inventory::submit! {
         display_name: "Three-Dimensional Matching",
         aliases: &["3DM"],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Find a perfect matching in a tripartite hypergraph",
         fields: &[
@@ -38,7 +39,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::set::ThreeDimensionalMatching;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // W = X = Y = {0, 1, 2} (q = 3)
 /// // Triples: (0,1,2), (1,0,1), (2,2,0), (0,0,0), (1,2,2)
@@ -48,11 +49,11 @@ inventory::submit! {
 /// );
 ///
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
+/// let solutions = solver.find_all_witnesses(&problem).unwrap();
 ///
 /// // First three triples form a valid matching
 /// assert!(!solutions.is_empty());
-/// assert!(problem.evaluate(&solutions[0]));
+/// assert!(problem.evaluate(&solutions[0]).unwrap());
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ThreeDimensionalMatching {
@@ -121,45 +122,54 @@ impl ThreeDimensionalMatching {
 
 impl Problem for ThreeDimensionalMatching {
     const NAME: &'static str = "ThreeDimensionalMatching";
+    type Solution = Vec<bool>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.triples.len()]
-    }
+    crate::problem_parameters![
+        ("num_triples", num_triples),
+        ("universe_size", universe_size),
+    ];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.triples.len() {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "triple-selection length does not match the instance".into(),
+                    ));
+                }
 
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.triples.len() || config.iter().any(|&value| value > 1) {
-                return crate::types::Or(false);
-            }
-
-            // Count selected triples
-            let selected_count: usize = config.iter().filter(|&&v| v == 1).sum();
-            if selected_count != self.universe_size {
-                return crate::types::Or(false);
-            }
-
-            // Check that selected triples have all distinct coordinates
-            let mut used_w = HashSet::with_capacity(self.universe_size);
-            let mut used_x = HashSet::with_capacity(self.universe_size);
-            let mut used_y = HashSet::with_capacity(self.universe_size);
-
-            for (i, &selected) in config.iter().enumerate() {
-                if selected == 1 {
-                    let (w, x, y) = self.triples[i];
-                    if !used_w.insert(w) {
-                        return crate::types::Or(false);
-                    }
-                    if !used_x.insert(x) {
-                        return crate::types::Or(false);
-                    }
-                    if !used_y.insert(y) {
-                        return crate::types::Or(false);
+                // Count selected triples
+                let selected_count = config.iter().filter(|&&v| v).count();
+                if selected_count != self.universe_size {
+                    return Ok(crate::types::Or(false));
+                }
+
+                // Check that selected triples have all distinct coordinates
+                let mut used_w = HashSet::with_capacity(self.universe_size);
+                let mut used_x = HashSet::with_capacity(self.universe_size);
+                let mut used_y = HashSet::with_capacity(self.universe_size);
+
+                for (i, &selected) in config.iter().enumerate() {
+                    if selected {
+                        let (w, x, y) = self.triples[i];
+                        if !used_w.insert(w) {
+                            return Ok(crate::types::Or(false));
+                        }
+                        if !used_x.insert(x) {
+                            return Ok(crate::types::Or(false));
+                        }
+                        if !used_y.insert(y) {
+                            return Ok(crate::types::Or(false));
+                        }
                     }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 
@@ -168,10 +178,20 @@ impl Problem for ThreeDimensionalMatching {
     }
 }
 
+impl crate::solvers::BruteForceProblem for ThreeDimensionalMatching {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.triples.len()]
+    }
+}
+
 crate::declare_variants! {
     default ThreeDimensionalMatching => "2^num_triples",
 }
 
+crate::register_brute_force! {
+    ThreeDimensionalMatching decode |_, indices: Vec<usize>| crate::config::config_to_bits(&indices),
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -180,7 +200,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
             3,
             vec![(0, 1, 2), (1, 0, 1), (2, 2, 0), (0, 0, 0), (1, 2, 2)],
         )),
-        optimal_config: vec![1, 1, 1, 0, 0],
+        optimal_config: serde_json::json!(vec![true, true, true, false, false]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/models/set/three_matroid_intersection.rs b/src/models/set/three_matroid_intersection.rs
deleted file mode 100644
index 75959467c..000000000
--- a/src/models/set/three_matroid_intersection.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-//! Three-Matroid Intersection problem implementation.
-//!
-//! Given three partition matroids on a common ground set E and a positive integer K,
-//! determine whether there exists a common independent set of size K.
-
-use crate::registry::{FieldInfo, ProblemSchemaEntry};
-use crate::traits::Problem;
-use serde::{Deserialize, Serialize};
-
-inventory::submit! {
-    ProblemSchemaEntry {
-        name: "ThreeMatroidIntersection",
-        display_name: "Three-Matroid Intersection",
-        aliases: &[],
-        dimensions: &[],
-        module_path: module_path!(),
-        description: "Find a common independent set of size K in three partition matroids",
-        fields: &[
-            FieldInfo { name: "ground_set_size", type_name: "usize", description: "Number of elements in the ground set E" },
-            FieldInfo { name: "partitions", type_name: "Vec<Vec<Vec<usize>>>", description: "Three partition matroids, each as a list of groups" },
-            FieldInfo { name: "bound", type_name: "usize", description: "Required size K of the common independent set" },
-        ],
-    }
-}
-
-/// Three-Matroid Intersection problem.
-///
-/// Given three partition matroids on a common ground set E = {0, ..., n-1} and a
-/// positive integer K ≤ |E|, determine whether there exists a subset E' ⊆ E such
-/// that |E'| = K and E' is independent in all three matroids.
-///
-/// A partition matroid is defined by a partition of E into groups. A set S is
-/// independent if |S ∩ G| ≤ 1 for every group G.
-///
-/// While 2-matroid intersection is solvable in polynomial time (Edmonds, 1970),
-/// the jump to three matroids captures NP-hardness.
-///
-/// # Example
-///
-/// ```
-/// use problemreductions::models::set::ThreeMatroidIntersection;
-/// use problemreductions::{Problem, Solver, BruteForce};
-///
-/// // Ground set E = {0, 1, 2, 3, 4, 5}, K = 2
-/// let problem = ThreeMatroidIntersection::new(
-///     6,
-///     vec![
-///         vec![vec![0, 1, 2], vec![3, 4, 5]],       // M1
-///         vec![vec![0, 3], vec![1, 4], vec![2, 5]],  // M2
-///         vec![vec![0, 4], vec![1, 5], vec![2, 3]],  // M3
-///     ],
-///     2,
-/// );
-///
-/// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(&problem);
-/// assert!(!solutions.is_empty());
-/// ```
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ThreeMatroidIntersection {
-    /// Number of elements in the ground set E (elements are 0..ground_set_size).
-    ground_set_size: usize,
-    /// Three partition matroids. Each matroid is a list of groups, where each
-    /// group is a list of element indices. A set is independent in a partition
-    /// matroid if it contains at most one element from each group.
-    partitions: Vec<Vec<Vec<usize>>>,
-    /// Required size K of the common independent set.
-    bound: usize,
-}
-
-impl ThreeMatroidIntersection {
-    /// Create a new Three-Matroid Intersection problem.
-    ///
-    /// # Panics
-    ///
-    /// Panics if:
-    /// - `partitions` does not contain exactly 3 matroids
-    /// - Any element index is outside `0..ground_set_size`
-    /// - `bound` exceeds `ground_set_size`
-    pub fn new(ground_set_size: usize, partitions: Vec<Vec<Vec<usize>>>, bound: usize) -> Self {
-        assert_eq!(
-            partitions.len(),
-            3,
-            "Expected exactly 3 partition matroids, got {}",
-            partitions.len()
-        );
-        assert!(
-            bound <= ground_set_size,
-            "Bound {} exceeds ground set size {}",
-            bound,
-            ground_set_size
-        );
-        for (m_idx, matroid) in partitions.iter().enumerate() {
-            for (g_idx, group) in matroid.iter().enumerate() {
-                for &elem in group {
-                    assert!(
-                        elem < ground_set_size,
-                        "Matroid {} group {} contains element {} which is outside 0..{}",
-                        m_idx,
-                        g_idx,
-                        elem,
-                        ground_set_size
-                    );
-                }
-            }
-        }
-        Self {
-            ground_set_size,
-            partitions,
-            bound,
-        }
-    }
-
-    /// Get the ground set size.
-    pub fn ground_set_size(&self) -> usize {
-        self.ground_set_size
-    }
-
-    /// Get the three partition matroids.
-    pub fn partitions(&self) -> &[Vec<Vec<usize>>] {
-        &self.partitions
-    }
-
-    /// Get the bound K.
-    pub fn bound(&self) -> usize {
-        self.bound
-    }
-
-    /// Get the total number of groups across all three matroids.
-    pub fn num_groups(&self) -> usize {
-        self.partitions.iter().map(|m| m.len()).sum()
-    }
-}
-
-impl Problem for ThreeMatroidIntersection {
-    const NAME: &'static str = "ThreeMatroidIntersection";
-    type Value = crate::types::Or;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.ground_set_size]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.ground_set_size || config.iter().any(|&v| v > 1) {
-                return crate::types::Or(false);
-            }
-
-            // Check selected set has exactly K elements
-            let selected_count: usize = config.iter().filter(|&&v| v == 1).sum();
-            if selected_count != self.bound {
-                return crate::types::Or(false);
-            }
-
-            // Check independence in each of the three partition matroids
-            for matroid in &self.partitions {
-                for group in matroid {
-                    let count = group.iter().filter(|&&e| config[e] == 1).count();
-                    if count > 1 {
-                        return crate::types::Or(false);
-                    }
-                }
-            }
-
-            true
-        })
-    }
-
-    fn variant() -> Vec<(&'static str, &'static str)> {
-        crate::variant_params![]
-    }
-}
-
-crate::declare_variants! {
-    default ThreeMatroidIntersection => "2^ground_set_size",
-}
-
-#[cfg(feature = "example-db")]
-pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
-    vec![crate::example_db::specs::ModelExampleSpec {
-        id: "three_matroid_intersection",
-        instance: Box::new(ThreeMatroidIntersection::new(
-            6,
-            vec![
-                vec![vec![0, 1, 2], vec![3, 4, 5]],
-                vec![vec![0, 3], vec![1, 4], vec![2, 5]],
-                vec![vec![0, 4], vec![1, 5], vec![2, 3]],
-            ],
-            2,
-        )),
-        optimal_config: vec![1, 0, 0, 0, 0, 1],
-        optimal_value: serde_json::json!(true),
-    }]
-}
-
-#[cfg(test)]
-#[path = "../../unit_tests/models/set/three_matroid_intersection.rs"]
-mod tests;
diff --git a/src/models/set/two_dimensional_consecutive_sets.rs b/src/models/set/two_dimensional_consecutive_sets.rs
index de247c110..e14af706f 100644
--- a/src/models/set/two_dimensional_consecutive_sets.rs
+++ b/src/models/set/two_dimensional_consecutive_sets.rs
@@ -17,6 +17,7 @@ inventory::submit! {
         display_name: "2-Dimensional Consecutive Sets",
         aliases: &[],
         dimensions: &[],
+        category: crate::registry::ProblemCategory::Set,
         module_path: module_path!(),
         description: "Determine if alphabet can be partitioned into ordered groups with intersection and consecutiveness constraints",
         fields: &[
@@ -40,7 +41,7 @@ inventory::submit! {
 ///
 /// ```
 /// use problemreductions::models::set::TwoDimensionalConsecutiveSets;
-/// use problemreductions::{Problem, Solver, BruteForce};
+/// use problemreductions::{Problem, BruteForce};
 ///
 /// // Alphabet: {0,1,2,3,4,5}
 /// // Subsets: {0,1,2}, {3,4,5}, {1,3}, {2,4}, {0,5}
@@ -51,7 +52,7 @@ inventory::submit! {
 ///
 /// // Partition: X0={0}, X1={1,5}, X2={2,3}, X3={4}
 /// // config[i] = group index of symbol i
-/// assert!(problem.evaluate(&[0, 1, 2, 2, 3, 1]));
+/// assert!(problem.evaluate(&vec![0, 1, 2, 2, 3, 1]).unwrap());
 /// ```
 #[derive(Debug, Clone, Serialize)]
 pub struct TwoDimensionalConsecutiveSets {
@@ -67,9 +68,12 @@ struct TwoDimensionalConsecutiveSetsUnchecked {
     subsets: Vec<Vec<usize>>,
 }
 
-fn validate(alphabet_size: usize, subsets: &[Vec<usize>]) -> Result<(), String> {
+fn validate(
+    alphabet_size: usize,
+    subsets: &[Vec<usize>],
+) -> Result<(), crate::registry::ConstructionError> {
     if alphabet_size == 0 {
-        return Err("Alphabet size must be positive".to_string());
+        return Err("Alphabet size must be positive".to_string().into());
     }
 
     for (i, subset) in subsets.iter().enumerate() {
@@ -79,10 +83,11 @@ fn validate(alphabet_size: usize, subsets: &[Vec<usize>]) -> Result<(), String>
                 return Err(format!(
                     "Subset {} contains element {} which is outside alphabet of size {}",
                     i, elem, alphabet_size
-                ));
+                )
+                .into());
             }
             if !seen.insert(elem) {
-                return Err(format!("Subset {} contains duplicate element {}", i, elem));
+                return Err(format!("Subset {} contains duplicate element {}", i, elem).into());
             }
         }
     }
@@ -102,7 +107,10 @@ impl<'de> Deserialize<'de> for TwoDimensionalConsecutiveSets {
 
 impl TwoDimensionalConsecutiveSets {
     /// Create a new 2-Dimensional Consecutive Sets instance, returning validation errors.
-    pub fn try_new(alphabet_size: usize, subsets: Vec<Vec<usize>>) -> Result<Self, String> {
+    pub fn try_new(
+        alphabet_size: usize,
+        subsets: Vec<Vec<usize>>,
+    ) -> Result<Self, crate::registry::ConstructionError> {
         validate(alphabet_size, &subsets)?;
         let subsets = subsets
             .into_iter()
@@ -145,56 +153,68 @@ impl TwoDimensionalConsecutiveSets {
 
 impl Problem for TwoDimensionalConsecutiveSets {
     const NAME: &'static str = "TwoDimensionalConsecutiveSets";
+    type Solution = Vec<usize>;
     type Value = crate::types::Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![self.alphabet_size; self.alphabet_size]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> crate::types::Or {
-        crate::types::Or({
-            if config.len() != self.alphabet_size {
-                return crate::types::Or(false);
-            }
-            if config.iter().any(|&v| v >= self.alphabet_size) {
-                return crate::types::Or(false);
-            }
+    crate::problem_parameters![
+        ("alphabet_size", alphabet_size),
+        ("num_subsets", num_subsets),
+    ];
 
-            // Empty labels do not create gaps in the partition order, so compress used labels first.
-            let mut used = vec![false; self.alphabet_size];
-            for &group in config {
-                used[group] = true;
-            }
-            let mut dense_labels = vec![0; self.alphabet_size];
-            let mut next_label = 0;
-            for (label, is_used) in used.into_iter().enumerate() {
-                if is_used {
-                    dense_labels[label] = next_label;
-                    next_label += 1;
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<crate::types::Or, crate::traits::EvaluationError> {
+        Ok({
+            crate::types::Or({
+                if config.len() != self.alphabet_size {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "group assignment length does not match the alphabet".into(),
+                    ));
                 }
-            }
-
-            for subset in &self.subsets {
-                if subset.is_empty() {
-                    continue;
+                if config.iter().any(|&v| v >= self.alphabet_size) {
+                    return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                        "group assignment contains an out-of-range group".into(),
+                    ));
                 }
-                let groups: Vec<usize> = subset.iter().map(|&s| dense_labels[config[s]]).collect();
 
-                // Intersection constraint: all group indices must be distinct
-                let unique: HashSet<usize> = groups.iter().copied().collect();
-                if unique.len() != subset.len() {
-                    return crate::types::Or(false);
+                // Empty labels do not create gaps in the partition order, so compress used labels first.
+                let mut used = vec![false; self.alphabet_size];
+                for &group in config {
+                    used[group] = true;
+                }
+                let mut dense_labels = vec![0; self.alphabet_size];
+                let mut next_label = 0;
+                for (label, is_used) in used.into_iter().enumerate() {
+                    if is_used {
+                        dense_labels[label] = next_label;
+                        next_label += 1;
+                    }
                 }
 
-                // Consecutiveness: group indices must form a contiguous range
-                let min_g = *unique.iter().min().unwrap();
-                let max_g = *unique.iter().max().unwrap();
-                if max_g - min_g + 1 != subset.len() {
-                    return crate::types::Or(false);
+                for subset in &self.subsets {
+                    if subset.is_empty() {
+                        continue;
+                    }
+                    let groups: Vec<usize> =
+                        subset.iter().map(|&s| dense_labels[config[s]]).collect();
+
+                    // Intersection constraint: all group indices must be distinct
+                    let unique: HashSet<usize> = groups.iter().copied().collect();
+                    if unique.len() != subset.len() {
+                        return Ok(crate::types::Or(false));
+                    }
+
+                    // Consecutiveness: group indices must form a contiguous range
+                    let min_g = *unique.iter().min().unwrap();
+                    let max_g = *unique.iter().max().unwrap();
+                    if max_g - min_g + 1 != subset.len() {
+                        return Ok(crate::types::Or(false));
+                    }
                 }
-            }
 
-            true
+                true
+            })
         })
     }
 
@@ -203,10 +223,20 @@ impl Problem for TwoDimensionalConsecutiveSets {
     }
 }
 
+impl crate::solvers::BruteForceProblem for TwoDimensionalConsecutiveSets {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![self.alphabet_size; self.alphabet_size]
+    }
+}
+
 crate::declare_variants! {
     default TwoDimensionalConsecutiveSets => "alphabet_size^alphabet_size",
 }
 
+crate::register_brute_force! {
+    TwoDimensionalConsecutiveSets,
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::ModelExampleSpec> {
     vec![crate::example_db::specs::ModelExampleSpec {
@@ -221,7 +251,7 @@ pub(crate) fn canonical_model_example_specs() -> Vec<crate::example_db::specs::M
                 vec![0, 5],
             ],
         )),
-        optimal_config: vec![0, 1, 2, 2, 3, 1],
+        optimal_config: serde_json::json!(vec![0, 1, 2, 2, 3, 1]),
         optimal_value: serde_json::json!(true),
     }]
 }
diff --git a/src/parameters.rs b/src/parameters.rs
new file mode 100644
index 000000000..2cf4ec93e
--- /dev/null
+++ b/src/parameters.rs
@@ -0,0 +1,546 @@
+//! Symbolic parameter transformations carried by reduction rules.
+
+use crate::expr::{AlgebraicAnalysis, Expr, ExprNode, ExprNodeId, Symbol};
+use crate::types::ProblemParameters;
+use num_bigint::{BigInt, BigUint, Sign};
+use num_rational::BigRational;
+use num_traits::{One, Signed, Zero};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::sync::Arc;
+
+/// What one reduction rule promises about all of its declared parameter formulas.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ParameterRelation {
+    Exact,
+    UpperBound,
+}
+
+impl ParameterRelation {
+    fn compose(self, next: Self) -> Self {
+        if self == Self::Exact && next == Self::Exact {
+            Self::Exact
+        } else {
+            Self::UpperBound
+        }
+    }
+}
+
+/// One rule-level symbolic transformation. Its relation applies to every formula.
+#[derive(Clone, Debug)]
+pub struct ParameterTransform {
+    edge: Box<str>,
+    relation: ParameterRelation,
+    fields: Vec<ParameterField>,
+}
+
+#[derive(Clone, Debug)]
+struct ParameterField {
+    name: Box<str>,
+    expression: Expr,
+    plan: Plan,
+}
+
+#[derive(Clone, Debug)]
+struct Plan(Arc<PlanNode>);
+
+#[derive(Debug)]
+enum PlanNode {
+    Const(BigRational),
+    Var(Symbol),
+    Add(Box<[Plan]>),
+    Mul(Box<[Plan]>),
+    Pow(Plan, BigInt),
+}
+
+impl Plan {
+    fn identity(&self) -> usize {
+        Arc::as_ptr(&self.0) as usize
+    }
+}
+
+impl ParameterTransform {
+    pub fn new<I, N>(
+        edge: impl Into<Box<str>>,
+        relation: ParameterRelation,
+        fields: I,
+    ) -> Result<Self, ParameterTransformError>
+    where
+        I: IntoIterator<Item = (N, Expr)>,
+        N: Into<Box<str>>,
+    {
+        let edge = edge.into();
+        let mut names = HashSet::new();
+        let mut raw_fields = Vec::new();
+        for (name, expression) in fields {
+            let name = name.into();
+            if let Err(error) = Symbol::new(name.clone()) {
+                return Err(ParameterTransformError::InvalidTargetField {
+                    edge,
+                    field: name,
+                    reason: error.to_string().into(),
+                });
+            }
+            if !names.insert(name.clone()) {
+                return Err(ParameterTransformError::DuplicateTargetField { edge, field: name });
+            }
+            raw_fields.push((name, expression));
+        }
+
+        let expressions = raw_fields
+            .iter()
+            .map(|(_, expression)| expression)
+            .collect::<Vec<_>>();
+        let analysis = AlgebraicAnalysis::new(&expressions);
+        let mut plans = HashMap::new();
+        let fields = raw_fields
+            .into_iter()
+            .map(|(name, expression)| {
+                let plan = compile(&expression, &analysis, &mut plans).map_err(|failure| {
+                    validation_error(edge.clone(), name.clone(), expression.to_string(), failure)
+                })?;
+                Ok(ParameterField {
+                    name,
+                    expression,
+                    plan,
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(Self {
+            edge,
+            relation,
+            fields,
+        })
+    }
+
+    pub fn edge(&self) -> &str {
+        &self.edge
+    }
+
+    pub fn relation(&self) -> ParameterRelation {
+        self.relation
+    }
+
+    pub fn expressions(&self) -> impl Iterator<Item = (&str, &Expr)> {
+        self.fields
+            .iter()
+            .map(|field| (field.name.as_ref(), &field.expression))
+    }
+
+    pub fn get(&self, target_field: &str) -> Option<&Expr> {
+        self.fields
+            .iter()
+            .find(|field| field.name.as_ref() == target_field)
+            .map(|field| &field.expression)
+    }
+
+    pub fn evaluate(
+        &self,
+        input: &ProblemParameters,
+    ) -> Result<ProblemParameters, ParameterTransformError> {
+        let mut memo = HashMap::new();
+        let mut output = Vec::with_capacity(self.fields.len());
+        for field in &self.fields {
+            let value = evaluate_plan(&field.plan, input, &mut memo).map_err(|failure| {
+                evaluation_error(self.edge.clone(), field.name.clone(), failure)
+            })?;
+            if value.is_negative() {
+                return Err(ParameterTransformError::NegativeResult {
+                    edge: self.edge.clone(),
+                    field: field.name.clone(),
+                    value,
+                });
+            }
+            let value = if self.relation == ParameterRelation::Exact {
+                if !value.is_integer() {
+                    return Err(ParameterTransformError::NonIntegralResult {
+                        edge: self.edge.clone(),
+                        field: field.name.clone(),
+                        value: value.to_string().into(),
+                    });
+                }
+                value.to_integer().magnitude().clone()
+            } else {
+                ceil_nonnegative(&value)
+            };
+            let value =
+                u64::try_from(&value).map_err(|_| ParameterTransformError::OutputOutOfRange {
+                    field: field.name.clone(),
+                    value: value.clone(),
+                })?;
+            output.push((field.name.to_string(), value));
+        }
+        Ok(ProblemParameters::from_owned(output))
+    }
+
+    pub fn compose(
+        &self,
+        next: &ParameterTransform,
+        edge: impl Into<Box<str>>,
+    ) -> Result<ParameterTransform, ParameterTransformError> {
+        let edge = edge.into();
+        let replacements: HashMap<&str, &Expr> = self.expressions().collect();
+        let fields = next
+            .fields
+            .iter()
+            .map(|field| {
+                let expression = if self.relation == ParameterRelation::UpperBound {
+                    positive_polynomial_hull(&field.expression).ok_or_else(|| {
+                        ParameterTransformError::CannotPropagateUpperBound {
+                            edge: next.edge.clone(),
+                            field: field.name.clone(),
+                            expression: field.expression.to_string().into(),
+                        }
+                    })?
+                } else {
+                    field.expression.clone()
+                };
+                let expression =
+                    expression
+                        .substitute_complete(&replacements)
+                        .map_err(|error| ParameterTransformError::MissingCompositionInput {
+                            edge: edge.clone(),
+                            field: field.name.clone(),
+                            input_fields: error.missing_variables().map(Box::<str>::from).collect(),
+                        })?;
+                Ok((field.name.clone(), expression))
+            })
+            .collect::<Result<Vec<_>, ParameterTransformError>>()?;
+        Self::new(edge, self.relation.compose(next.relation), fields)
+    }
+}
+
+type Monomial = BTreeMap<Symbol, BigUint>;
+type Polynomial = BTreeMap<Monomial, BigRational>;
+
+fn positive_polynomial_hull(expression: &Expr) -> Option<Expr> {
+    let polynomial = polynomial(expression)?;
+    let terms = polynomial
+        .into_iter()
+        .filter(|(_, coefficient)| coefficient.is_positive())
+        .map(|(monomial, coefficient)| {
+            monomial
+                .into_iter()
+                .fold(Expr::constant(coefficient), |term, (variable, exponent)| {
+                    term * Expr::pow(
+                        Expr::variable(variable.as_str()),
+                        Expr::integer(BigInt::from(exponent)),
+                    )
+                })
+        });
+    Some(terms.fold(Expr::integer(0), |sum, term| sum + term))
+}
+
+fn polynomial(expression: &Expr) -> Option<Polynomial> {
+    match expression.node() {
+        ExprNode::Const(value) => Some(BTreeMap::from([(BTreeMap::new(), value.clone())])),
+        ExprNode::Var(variable) => Some(BTreeMap::from([(
+            BTreeMap::from([(variable.clone(), BigUint::one())]),
+            BigRational::one(),
+        )])),
+        ExprNode::Add(values) => values.iter().try_fold(BTreeMap::new(), |sum, value| {
+            Some(add_polynomials(sum, polynomial(value)?))
+        }),
+        ExprNode::Mul(values) => values.iter().try_fold(
+            BTreeMap::from([(BTreeMap::new(), BigRational::one())]),
+            |product, value| Some(multiply_polynomials(product, polynomial(value)?)),
+        ),
+        ExprNode::Pow(base, exponent) => {
+            let ExprNode::Const(exponent) = exponent.node() else {
+                return None;
+            };
+            if !exponent.is_integer() {
+                return None;
+            }
+            if exponent.is_negative() {
+                let ExprNode::Const(base) = base.node() else {
+                    return None;
+                };
+                if base.is_zero() {
+                    return None;
+                }
+                return Some(BTreeMap::from([(
+                    BTreeMap::new(),
+                    pow_rational(base.clone(), &exponent.to_integer()),
+                )]));
+            }
+            let mut exponent = exponent.to_integer().magnitude().clone();
+            let mut base = polynomial(base)?;
+            let mut result = BTreeMap::from([(BTreeMap::new(), BigRational::one())]);
+            while !exponent.is_zero() {
+                if exponent.bit(0) {
+                    result = multiply_polynomials(result, base.clone());
+                }
+                exponent >>= 1usize;
+                if !exponent.is_zero() {
+                    base = multiply_polynomials(base.clone(), base);
+                }
+            }
+            Some(result)
+        }
+        ExprNode::Exp(_) | ExprNode::Log(_) | ExprNode::Factorial(_) => None,
+    }
+}
+
+fn add_polynomials(mut left: Polynomial, right: Polynomial) -> Polynomial {
+    for (monomial, right_coefficient) in right {
+        *left.entry(monomial).or_insert_with(BigRational::zero) += right_coefficient;
+    }
+    left.retain(|_, coefficient| !coefficient.is_zero());
+    left
+}
+
+fn multiply_polynomials(left: Polynomial, right: Polynomial) -> Polynomial {
+    let mut product = Polynomial::new();
+    for (left_monomial, left_coefficient) in left {
+        for (right_monomial, right_coefficient) in &right {
+            let mut monomial = left_monomial.clone();
+            for (variable, exponent) in right_monomial {
+                *monomial.entry(variable.clone()).or_default() += exponent;
+            }
+            *product.entry(monomial).or_insert_with(BigRational::zero) +=
+                &left_coefficient * right_coefficient;
+        }
+    }
+    product.retain(|_, coefficient| !coefficient.is_zero());
+    product
+}
+
+fn compile(
+    expression: &Expr,
+    analysis: &AlgebraicAnalysis,
+    memo: &mut HashMap<ExprNodeId, Plan>,
+) -> Result<Plan, ValidationFailure> {
+    if let Some(plan) = memo.get(&expression.node_identity()) {
+        return Ok(plan.clone());
+    }
+    let node = match expression.node() {
+        ExprNode::Const(value) => PlanNode::Const(value.clone()),
+        ExprNode::Var(symbol) => PlanNode::Var(symbol.clone()),
+        ExprNode::Add(values) => PlanNode::Add(
+            values
+                .iter()
+                .map(|value| compile(value, analysis, memo))
+                .collect::<Result<Vec<_>, _>>()?
+                .into_boxed_slice(),
+        ),
+        ExprNode::Mul(values) => PlanNode::Mul(
+            values
+                .iter()
+                .map(|value| compile(value, analysis, memo))
+                .collect::<Result<Vec<_>, _>>()?
+                .into_boxed_slice(),
+        ),
+        ExprNode::Pow(base, exponent) => {
+            let Some(exponent) = analysis.facts(exponent).exact_rational.as_ref() else {
+                return Err(ValidationFailure::NonIntegralConstantExponent(
+                    exponent.to_string().into(),
+                ));
+            };
+            if !exponent.is_integer() {
+                return Err(ValidationFailure::NonIntegralConstantExponent(
+                    exponent.to_string().into(),
+                ));
+            }
+            PlanNode::Pow(compile(base, analysis, memo)?, exponent.to_integer())
+        }
+        ExprNode::Exp(_) => return Err(ValidationFailure::UnsupportedOperator("exp")),
+        ExprNode::Log(_) => return Err(ValidationFailure::UnsupportedOperator("log")),
+        ExprNode::Factorial(_) => {
+            return Err(ValidationFailure::UnsupportedOperator("factorial"));
+        }
+    };
+    let plan = Plan(Arc::new(node));
+    memo.insert(expression.node_identity(), plan.clone());
+    Ok(plan)
+}
+
+fn evaluate_plan(
+    plan: &Plan,
+    input: &ProblemParameters,
+    memo: &mut HashMap<usize, BigRational>,
+) -> Result<BigRational, EvaluationFailure> {
+    if let Some(value) = memo.get(&plan.identity()) {
+        return Ok(value.clone());
+    }
+    let value = match plan.0.as_ref() {
+        PlanNode::Const(value) => value.clone(),
+        PlanNode::Var(symbol) => BigRational::from_integer(BigInt::from(
+            input
+                .get(symbol.as_str())
+                .ok_or_else(|| EvaluationFailure::MissingInputField(symbol.to_string().into()))?,
+        )),
+        PlanNode::Add(values) => values.iter().try_fold(BigRational::zero(), |sum, value| {
+            Ok(sum + evaluate_plan(value, input, memo)?)
+        })?,
+        PlanNode::Mul(values) => values
+            .iter()
+            .try_fold(BigRational::one(), |product, value| {
+                Ok(product * evaluate_plan(value, input, memo)?)
+            })?,
+        PlanNode::Pow(base, exponent) => {
+            let base = evaluate_plan(base, input, memo)?;
+            if exponent.sign() == Sign::Minus && base.is_zero() {
+                return Err(EvaluationFailure::DivisionByZero);
+            }
+            pow_rational(base, exponent)
+        }
+    };
+    memo.insert(plan.identity(), value.clone());
+    Ok(value)
+}
+
+fn pow_rational(mut base: BigRational, exponent: &BigInt) -> BigRational {
+    let negative = exponent.sign() == Sign::Minus;
+    let mut exponent = exponent.magnitude().clone();
+    let mut result = BigRational::one();
+    while !exponent.is_zero() {
+        if exponent.bit(0) {
+            result *= &base;
+        }
+        exponent >>= 1usize;
+        if !exponent.is_zero() {
+            base = &base * &base;
+        }
+    }
+    if negative {
+        result.recip()
+    } else {
+        result
+    }
+}
+
+fn ceil_nonnegative(value: &BigRational) -> BigUint {
+    ((value.numer() + value.denom() - BigInt::one()) / value.denom())
+        .magnitude()
+        .clone()
+}
+
+#[derive(Debug)]
+enum ValidationFailure {
+    NonIntegralConstantExponent(Box<str>),
+    UnsupportedOperator(&'static str),
+}
+
+#[derive(Debug)]
+enum EvaluationFailure {
+    MissingInputField(Box<str>),
+    DivisionByZero,
+}
+
+fn validation_error(
+    edge: Box<str>,
+    field: Box<str>,
+    expression: String,
+    failure: ValidationFailure,
+) -> ParameterTransformError {
+    match failure {
+        ValidationFailure::NonIntegralConstantExponent(exponent) => {
+            ParameterTransformError::NonIntegralConstantExponent {
+                edge,
+                field,
+                expression: expression.into(),
+                exponent,
+            }
+        }
+        ValidationFailure::UnsupportedOperator(operator) => {
+            ParameterTransformError::UnsupportedOperator {
+                edge,
+                field,
+                expression: expression.into(),
+                operator,
+            }
+        }
+    }
+}
+
+fn evaluation_error(
+    edge: Box<str>,
+    field: Box<str>,
+    failure: EvaluationFailure,
+) -> ParameterTransformError {
+    match failure {
+        EvaluationFailure::MissingInputField(input_field) => {
+            ParameterTransformError::MissingInputField {
+                edge,
+                field,
+                input_field,
+            }
+        }
+        EvaluationFailure::DivisionByZero => {
+            ParameterTransformError::DivisionByZero { edge, field }
+        }
+    }
+}
+
+/// Validation, composition, or evaluation failure for a [`ParameterTransform`].
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+pub enum ParameterTransformError {
+    #[error("reduction `{edge}` has invalid target parameter field `{field}`: {reason}")]
+    InvalidTargetField {
+        edge: Box<str>,
+        field: Box<str>,
+        reason: Box<str>,
+    },
+    #[error("reduction `{edge}` declares target parameter field `{field}` more than once")]
+    DuplicateTargetField { edge: Box<str>, field: Box<str> },
+    #[error("reduction `{edge}` target field `{field}` has non-integral constant exponent `{exponent}` in `{expression}`")]
+    NonIntegralConstantExponent {
+        edge: Box<str>,
+        field: Box<str>,
+        expression: Box<str>,
+        exponent: Box<str>,
+    },
+    #[error("reduction `{edge}` target field `{field}` uses unsupported operator `{operator}` in `{expression}`")]
+    UnsupportedOperator {
+        edge: Box<str>,
+        field: Box<str>,
+        expression: Box<str>,
+        operator: &'static str,
+    },
+    #[error("reduction `{edge}` target field `{field}` cannot propagate an upper bound through `{expression}`")]
+    CannotPropagateUpperBound {
+        edge: Box<str>,
+        field: Box<str>,
+        expression: Box<str>,
+    },
+    #[error(
+        "reduction `{edge}` target field `{field}` is missing input parameter field `{input_field}`"
+    )]
+    MissingInputField {
+        edge: Box<str>,
+        field: Box<str>,
+        input_field: Box<str>,
+    },
+    #[error(
+        "reduction `{edge}` target field `{field}` is missing composition inputs {input_fields:?}"
+    )]
+    MissingCompositionInput {
+        edge: Box<str>,
+        field: Box<str>,
+        input_fields: Vec<Box<str>>,
+    },
+    #[error("reduction `{edge}` target field `{field}` divides by zero")]
+    DivisionByZero { edge: Box<str>, field: Box<str> },
+    #[error("reduction `{edge}` target field `{field}` evaluates to non-integral parameter value `{value}`")]
+    NonIntegralResult {
+        edge: Box<str>,
+        field: Box<str>,
+        value: Box<str>,
+    },
+    #[error(
+        "reduction `{edge}` target field `{field}` evaluates to negative parameter value `{value}`"
+    )]
+    NegativeResult {
+        edge: Box<str>,
+        field: Box<str>,
+        value: BigRational,
+    },
+    #[error("parameter field `{field}` value `{value}` does not fit u64")]
+    OutputOutOfRange { field: Box<str>, value: BigUint },
+}
+
+#[cfg(test)]
+#[path = "unit_tests/parameters.rs"]
+mod tests;
diff --git a/src/random.rs b/src/random.rs
new file mode 100644
index 000000000..a25fbb121
--- /dev/null
+++ b/src/random.rs
@@ -0,0 +1,262 @@
+//! Shared deterministic building blocks for model-owned random generators.
+
+use crate::registry::ConstructionError;
+use crate::topology::SimpleGraph;
+use serde::Deserialize;
+
+/// Inputs shared by models generated from an Erdős–Rényi simple graph.
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+pub struct SimpleGraphRandomSpec {
+    /// Number of graph vertices.
+    pub num_vertices: usize,
+    /// Independent probability of including each possible edge (default: 0.5).
+    pub edge_prob: Option<f64>,
+    /// Seed for reproducible generation.
+    pub seed: Option<i64>,
+}
+
+/// Inputs shared by integer-lattice graph generators.
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+pub struct IntegerGeometryRandomSpec {
+    /// Number of graph vertices.
+    pub num_vertices: usize,
+    /// Seed for reproducible generation.
+    pub seed: Option<i64>,
+}
+
+/// Inputs shared by unit-disk graph generators.
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+pub struct UnitDiskRandomSpec {
+    /// Number of graph vertices.
+    pub num_vertices: usize,
+    /// Disk radius used to derive edges (default: 1.0).
+    pub radius: Option<f64>,
+    /// Seed for reproducible generation.
+    pub seed: Option<i64>,
+}
+
+/// Random simple-graph inputs with a required clique size.
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+pub struct CliqueRandomSpec {
+    /// Number of graph vertices.
+    pub num_vertices: usize,
+    /// Independent edge probability (default: 0.5).
+    pub edge_prob: Option<f64>,
+    /// Seed for reproducible generation.
+    pub seed: Option<i64>,
+    /// Required clique size.
+    pub k: usize,
+}
+
+impl CliqueRandomSpec {
+    /// Generate the graph using the common graph inputs.
+    pub fn graph(&self) -> Result<SimpleGraph, ConstructionError> {
+        SimpleGraphRandomSpec {
+            num_vertices: self.num_vertices,
+            edge_prob: self.edge_prob,
+            seed: self.seed,
+        }
+        .graph()
+    }
+}
+
+/// Random simple-graph inputs with optional source and sink vertices.
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+pub struct EndpointRandomSpec {
+    /// Number of graph vertices.
+    pub num_vertices: usize,
+    /// Independent edge probability (default: 0.5).
+    pub edge_prob: Option<f64>,
+    /// Seed for reproducible generation.
+    pub seed: Option<i64>,
+    /// Source vertex (default: 0).
+    pub source: Option<usize>,
+    /// Sink vertex (default: the final vertex).
+    pub sink: Option<usize>,
+}
+
+/// Random simple-graph inputs with an optional runtime color count.
+#[derive(Debug, Deserialize, crate::CreateSpec)]
+pub struct ColoringRandomSpec {
+    /// Number of graph vertices.
+    pub num_vertices: usize,
+    /// Independent edge probability (default: 0.5).
+    pub edge_prob: Option<f64>,
+    /// Seed for reproducible generation.
+    pub seed: Option<i64>,
+    /// Runtime color count (default: 3).
+    pub k: Option<usize>,
+}
+
+impl ColoringRandomSpec {
+    /// Generate the graph using the common graph inputs.
+    pub fn graph(&self) -> Result<SimpleGraph, ConstructionError> {
+        SimpleGraphRandomSpec {
+            num_vertices: self.num_vertices,
+            edge_prob: self.edge_prob,
+            seed: self.seed,
+        }
+        .graph()
+    }
+}
+
+impl EndpointRandomSpec {
+    /// Generate the graph using the common graph inputs.
+    pub fn graph(&self) -> Result<SimpleGraph, ConstructionError> {
+        SimpleGraphRandomSpec {
+            num_vertices: self.num_vertices,
+            edge_prob: self.edge_prob,
+            seed: self.seed,
+        }
+        .graph()
+    }
+
+    /// Validate and return distinct source and sink vertices.
+    pub fn endpoints(&self) -> Result<(usize, usize), ConstructionError> {
+        if self.num_vertices < 2 {
+            return Err("num_vertices must be at least 2".into());
+        }
+        let source = self.source.unwrap_or(0);
+        let sink = self.sink.unwrap_or(self.num_vertices - 1);
+        if source >= self.num_vertices || sink >= self.num_vertices {
+            return Err(format!(
+                "source and sink must be below num_vertices ({})",
+                self.num_vertices
+            )
+            .into());
+        }
+        if source == sink {
+            return Err("source and sink must be distinct".into());
+        }
+        Ok((source, sink))
+    }
+}
+
+impl SimpleGraphRandomSpec {
+    /// Generate the requested graph after validating its probability.
+    pub fn graph(&self) -> Result<SimpleGraph, ConstructionError> {
+        let edge_prob = self.edge_prob.unwrap_or(0.5);
+        if !(0.0..=1.0).contains(&edge_prob) {
+            return Err(format!("edge_prob must be between 0 and 1, got {edge_prob}").into());
+        }
+        Ok(create_random_graph(
+            self.num_vertices,
+            edge_prob,
+            seed_to_u64(self.seed)?,
+        ))
+    }
+}
+
+/// Implement a typed, model-owned random generator using a typed input spec.
+#[macro_export]
+macro_rules! impl_random_generate {
+    ($target:ty, $spec:ty, |$input:ident| $body:block) => {
+        impl $crate::registry::RandomGenerate for $target {
+            fn inputs() -> Vec<$crate::registry::CreateInputInfo> {
+                <$spec as $crate::registry::CreateSpec>::inputs()
+            }
+
+            fn generate(
+                data: serde_json::Value,
+            ) -> Result<Self, $crate::registry::ConstructionError> {
+                $crate::registry::validate_create_inputs(&Self::inputs(), &data)?;
+                let $input: $spec = <$spec as $crate::registry::CreateSpec>::deserialize_inputs(
+                    data,
+                )
+                .map_err(|error| {
+                    $crate::registry::ConstructionError::InvalidInput(error.to_string())
+                })?;
+                let generate = || -> Result<Self, $crate::registry::ConstructionError> { $body };
+                generate()
+            }
+        }
+    };
+}
+
+/// LCG PRNG step returning a uniform value in `[0, 1)`.
+pub(crate) fn lcg_step(state: &mut u64) -> f64 {
+    *state = state
+        .wrapping_mul(6364136223846793005)
+        .wrapping_add(1442695040888963407);
+    (*state >> 33) as f64 / (1u64 << 31) as f64
+}
+
+/// Initialize LCG state from a seed or the current time.
+pub(crate) fn lcg_init(seed: Option<u64>) -> u64 {
+    seed.unwrap_or_else(|| {
+        let duration = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .expect("system clock must be after the Unix epoch");
+        duration.as_secs() ^ u64::from(duration.subsec_nanos())
+    })
+}
+
+/// Generate an Erdős–Rényi simple graph.
+pub(crate) fn create_random_graph(
+    num_vertices: usize,
+    edge_prob: f64,
+    seed: Option<u64>,
+) -> SimpleGraph {
+    let mut state = lcg_init(seed);
+    let edges = (0..num_vertices)
+        .flat_map(|u| ((u + 1)..num_vertices).map(move |v| (u, v)))
+        .filter(|_| lcg_step(&mut state) < edge_prob)
+        .collect();
+    SimpleGraph::new(num_vertices, edges)
+}
+
+/// Generate unique integer positions on a square grid.
+pub(crate) fn create_random_int_positions(
+    num_vertices: usize,
+    seed: Option<u64>,
+) -> Vec<(i64, i64)> {
+    let mut state = lcg_init(seed);
+    let grid_size = (num_vertices as f64).sqrt().ceil() as i64 + 1;
+    let capacity = (grid_size * grid_size) as usize;
+    lcg_choose(&mut state, capacity, num_vertices)
+        .expect("grid capacity exceeds the requested position count")
+        .into_iter()
+        .map(|index| {
+            let index = i64::try_from(index).expect("random position index exceeds i64");
+            (index / grid_size, index % grid_size)
+        })
+        .collect()
+}
+
+/// Generate float positions in `[0, sqrt(N)]²`.
+pub(crate) fn create_random_float_positions(
+    num_vertices: usize,
+    seed: Option<u64>,
+) -> Vec<(f64, f64)> {
+    let mut state = lcg_init(seed);
+    let side = (num_vertices as f64).sqrt();
+    (0..num_vertices)
+        .map(|_| (lcg_step(&mut state) * side, lcg_step(&mut state) * side))
+        .collect()
+}
+
+/// Choose `k` distinct sorted indices from `0..n`.
+pub(crate) fn lcg_choose(
+    state: &mut u64,
+    n: usize,
+    k: usize,
+) -> Result<Vec<usize>, ConstructionError> {
+    if k > n {
+        return Err(ConstructionError::Conversion(format!(
+            "cannot choose {k} elements from {n}"
+        )));
+    }
+    let mut indices = (0..n).collect::<Vec<_>>();
+    for i in 0..k {
+        let j = i + (lcg_step(state) * (n - i) as f64) as usize % (n - i);
+        indices.swap(i, j);
+    }
+    let mut chosen = indices[..k].to_vec();
+    chosen.sort_unstable();
+    Ok(chosen)
+}
+
+pub(crate) fn seed_to_u64(seed: Option<i64>) -> Result<Option<u64>, ConstructionError> {
+    seed.map(|value| u64::try_from(value).map_err(|_| "seed must be a nonnegative i64".into()))
+        .transpose()
+}
diff --git a/src/registry/dyn_problem.rs b/src/registry/dyn_problem.rs
index 19483463a..e5938bdc4 100644
--- a/src/registry/dyn_problem.rs
+++ b/src/registry/dyn_problem.rs
@@ -4,13 +4,12 @@ use std::any::Any;
 use std::collections::BTreeMap;
 use std::fmt;
 
-use crate::traits::Problem;
+use crate::traits::{EvaluationError, Problem};
+use crate::types::SolutionAggregate;
 
 /// Format a metric for CLI- and registry-facing dynamic dispatch.
 ///
-/// Dynamic formatting uses the aggregate display form directly, so optimization
-/// metrics appear as `Max(...)` / `Min(...)` alongside aggregate-only values
-/// such as `Or(true)` or `Sum(56)`.
+/// Dynamic formatting uses the problem value's display form directly.
 pub fn format_metric<T>(metric: &T) -> String
 where
     T: fmt::Display,
@@ -20,37 +19,55 @@ where
 
 /// Type-erased problem interface for dynamic dispatch.
 ///
-/// Implemented via blanket impl for any `T: Problem + Serialize + 'static`.
+/// Implemented for serializable problems whose values support solution witnesses.
 pub trait DynProblem: Any {
     /// Evaluate a configuration and return the CLI-facing metric string.
-    fn evaluate_dyn(&self, config: &[usize]) -> String;
+    fn evaluate_dyn(&self, solution: &Value) -> Result<String, EvaluationError>;
+    /// Evaluate a candidate witness, returning `None` when it is infeasible.
+    /// This validates feasibility, not global optimality.
+    fn evaluate_witness_dyn(&self, solution: &Value) -> Result<Option<String>, EvaluationError>;
     /// Evaluate a configuration and return the result as a serializable JSON value.
-    fn evaluate_json(&self, config: &[usize]) -> Value;
+    fn evaluate_json(&self, solution: &Value) -> Result<Value, EvaluationError>;
     /// Serialize the problem to a JSON value.
     fn serialize_json(&self) -> Value;
     /// Downcast to `&dyn Any` for type recovery.
     fn as_any(&self) -> &dyn Any;
-    /// Return the configuration space dimensions.
-    fn dims_dyn(&self) -> Vec<usize>;
     /// Return the problem name (`Problem::NAME`).
     fn problem_name(&self) -> &'static str;
     /// Return the variant key-value map.
     fn variant_map(&self) -> BTreeMap<String, String>;
-    /// Return the number of variables.
-    fn num_variables_dyn(&self) -> usize;
+    /// Return this problem model's canonical parameter names.
+    fn parameter_names_dyn(&self) -> &'static [&'static str];
+    /// Measure the complete canonical parameters of this concrete instance.
+    fn parameters_dyn(&self) -> crate::types::ProblemParameters;
 }
 
 impl<T> DynProblem for T
 where
     T: Problem + Serialize + 'static,
-    T::Value: fmt::Display + Serialize,
+    T::Solution: serde::de::DeserializeOwned,
+    T::Value: SolutionAggregate + fmt::Display + Serialize,
 {
-    fn evaluate_dyn(&self, config: &[usize]) -> String {
-        format_metric(&self.evaluate(config))
+    fn evaluate_dyn(&self, solution: &Value) -> Result<String, EvaluationError> {
+        let solution = serde::Deserialize::deserialize(solution).map_err(|error| {
+            EvaluationError::InvalidConfiguration(format!("invalid solution JSON: {error}"))
+        })?;
+        Ok(format_metric(&self.evaluate(&solution)?))
     }
 
-    fn evaluate_json(&self, config: &[usize]) -> Value {
-        serde_json::to_value(self.evaluate(config)).expect("serialize metric failed")
+    fn evaluate_json(&self, solution: &Value) -> Result<Value, EvaluationError> {
+        let solution = serde::Deserialize::deserialize(solution).map_err(|error| {
+            EvaluationError::InvalidConfiguration(format!("invalid solution JSON: {error}"))
+        })?;
+        Ok(serde_json::to_value(self.evaluate(&solution)?).expect("serialize metric failed"))
+    }
+
+    fn evaluate_witness_dyn(&self, solution: &Value) -> Result<Option<String>, EvaluationError> {
+        let solution = serde::Deserialize::deserialize(solution).map_err(|error| {
+            EvaluationError::InvalidConfiguration(format!("invalid solution JSON: {error}"))
+        })?;
+        let value = self.evaluate(&solution)?;
+        Ok(T::Value::contributes_to_solution(&value, &value).then(|| format_metric(&value)))
     }
 
     fn serialize_json(&self) -> Value {
@@ -61,10 +78,6 @@ where
         self
     }
 
-    fn dims_dyn(&self) -> Vec<usize> {
-        self.dims()
-    }
-
     fn problem_name(&self) -> &'static str {
         T::NAME
     }
@@ -73,24 +86,18 @@ where
         crate::export::variant_to_map(T::variant())
     }
 
-    fn num_variables_dyn(&self) -> usize {
-        self.num_variables()
+    fn parameter_names_dyn(&self) -> &'static [&'static str] {
+        T::parameter_names()
     }
-}
-
-/// Function pointer type for brute-force value solve dispatch.
-pub type SolveValueFn = fn(&dyn Any) -> String;
 
-/// Function pointer type for brute-force witness solve dispatch.
-pub type SolveWitnessFn = fn(&dyn Any) -> Option<(Vec<usize>, String)>;
+    fn parameters_dyn(&self) -> crate::types::ProblemParameters {
+        self.parameters()
+    }
+}
 
-/// A loaded problem with type-erased solve capability.
-///
-/// Wraps a `Box<dyn DynProblem>` with brute-force value and witness function pointers.
+/// A loaded type-erased problem.
 pub struct LoadedDynProblem {
     inner: Box<dyn DynProblem>,
-    solve_value_fn: SolveValueFn,
-    solve_witness_fn: SolveWitnessFn,
 }
 
 impl std::fmt::Debug for LoadedDynProblem {
@@ -103,31 +110,8 @@ impl std::fmt::Debug for LoadedDynProblem {
 
 impl LoadedDynProblem {
     /// Create a new loaded dynamic problem.
-    pub fn new(
-        inner: Box<dyn DynProblem>,
-        solve_value_fn: SolveValueFn,
-        solve_witness_fn: SolveWitnessFn,
-    ) -> Self {
-        Self {
-            inner,
-            solve_value_fn,
-            solve_witness_fn,
-        }
-    }
-
-    /// Solve the problem using brute force and return its aggregate value string.
-    pub fn solve_brute_force_value(&self) -> String {
-        (self.solve_value_fn)(self.inner.as_any())
-    }
-
-    /// Solve the problem using brute force and return a witness when available.
-    pub fn solve_brute_force_witness(&self) -> Option<(Vec<usize>, String)> {
-        (self.solve_witness_fn)(self.inner.as_any())
-    }
-
-    /// Backward-compatible witness solve entry point.
-    pub fn solve_brute_force(&self) -> Option<(Vec<usize>, String)> {
-        self.solve_brute_force_witness()
+    pub(crate) fn new(inner: Box<dyn DynProblem>) -> Self {
+        Self { inner }
     }
 }
 
diff --git a/src/registry/info.rs b/src/registry/info.rs
index 919670a8e..d39ca69c7 100644
--- a/src/registry/info.rs
+++ b/src/registry/info.rs
@@ -125,7 +125,7 @@ pub struct ProblemInfo {
     pub canonical_reduction_from: Option<&'static str>,
     /// Wikipedia or reference URL.
     pub reference_url: Option<&'static str>,
-    /// Struct field descriptions for schema export.
+    /// Construction input descriptions for schema export.
     pub fields: &'static [FieldInfo],
 }
 
@@ -181,7 +181,7 @@ impl ProblemInfo {
         self
     }
 
-    /// Builder method to set struct field descriptions.
+    /// Builder method to set construction input descriptions.
     pub const fn with_fields(mut self, fields: &'static [FieldInfo]) -> Self {
         self.fields = fields;
         self
@@ -206,10 +206,10 @@ impl fmt::Display for ProblemInfo {
     }
 }
 
-/// Description of a struct field for JSON schema export.
+/// Description of a problem construction input for schema export.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct FieldInfo {
-    /// Field name as it appears in the Rust struct.
+    /// Input name supplied when constructing the problem.
     pub name: &'static str,
     /// Type name (e.g., `Vec<W>`, `UnGraph<(), ()>`).
     pub type_name: &'static str,
diff --git a/src/registry/mod.rs b/src/registry/mod.rs
index d253d4c4a..b76eb4199 100644
--- a/src/registry/mod.rs
+++ b/src/registry/mod.rs
@@ -51,18 +51,37 @@ pub mod problem_type;
 mod schema;
 pub mod variant;
 
-pub use dyn_problem::{format_metric, DynProblem, LoadedDynProblem, SolveValueFn, SolveWitnessFn};
+pub use dyn_problem::{format_metric, DynProblem, LoadedDynProblem};
 pub use info::{ComplexityClass, FieldInfo, ProblemInfo, ProblemMetadata};
 pub use problem_ref::{parse_catalog_problem_ref, require_graph_variant, ProblemRef};
 pub use problem_type::{find_problem_type, find_problem_type_by_alias, problem_types, ProblemType};
 pub use schema::{
-    collect_schemas, declared_size_fields, FieldInfoJson, ProblemSchemaEntry, ProblemSchemaJson,
-    ProblemSizeFieldEntry, VariantDimension,
+    collect_schemas, FieldInfoJson, ParseProblemCategoryError, ProblemCategory, ProblemSchemaEntry,
+    ProblemSchemaJson, VariantDimension,
 };
 pub use variant::{
-    find_variant_by_alias, find_variant_entry, validate_variant_aliases, VariantEntry,
+    find_variant_by_alias, find_variant_entry, validate_create_inputs,
+    validate_direct_create_inputs, validate_variant_aliases, validate_variant_parameter_schemas,
+    variant_entries, ConstructProblemFn, ConstructionError, CreateInputCodec, CreateInputInfo,
+    CreateSpec, RandomGenerate, RandomRegistration, VariantEntry,
 };
 
+/// Construct a problem from normalized construction inputs using the exact
+/// registered problem name and variant.
+pub fn construct_dyn(
+    name: &str,
+    variant: &BTreeMap<String, String>,
+    data: serde_json::Value,
+) -> Result<Box<dyn DynProblem>, ConstructionError> {
+    let entry = find_variant_entry(name, variant).ok_or_else(|| {
+        ConstructionError::UnregisteredVariant {
+            name: name.to_string(),
+            variant: variant.clone(),
+        }
+    })?;
+    (entry.construct_fn)(data)
+}
+
 use std::any::Any;
 use std::collections::BTreeMap;
 
@@ -73,21 +92,17 @@ pub fn load_dyn(
     name: &str,
     variant: &BTreeMap<String, String>,
     data: serde_json::Value,
-) -> Result<LoadedDynProblem, String> {
+) -> Result<LoadedDynProblem, ConstructionError> {
     let entry = find_variant_entry(name, variant).ok_or_else(|| {
-        format!(
-            "No registered variant for `{name}` with variant {:?}",
-            variant
-        )
+        ConstructionError::UnregisteredVariant {
+            name: name.to_string(),
+            variant: variant.clone(),
+        }
     })?;
 
-    let inner =
-        (entry.factory)(data).map_err(|e| format!("Failed to deserialize `{name}`: {e}"))?;
-    Ok(LoadedDynProblem::new(
-        inner,
-        entry.solve_value_fn,
-        entry.solve_witness_fn,
-    ))
+    let inner = (entry.factory)(data)
+        .map_err(|error| ConstructionError::InvalidInput(error.to_string()))?;
+    Ok(LoadedDynProblem::new(inner))
 }
 
 /// Serialize a `&dyn Any` by exact problem name and exact variant map.
diff --git a/src/registry/problem_ref.rs b/src/registry/problem_ref.rs
index 07880e265..64a4dfd6e 100644
--- a/src/registry/problem_ref.rs
+++ b/src/registry/problem_ref.rs
@@ -1,6 +1,7 @@
 //! Typed internal problem references with catalog-validated variants.
 
 use super::problem_type::ProblemType;
+use super::ConstructionError;
 use std::collections::BTreeMap;
 
 /// A typed internal reference to a specific problem variant.
@@ -25,7 +26,10 @@ impl ProblemRef {
     /// # Errors
     ///
     /// Returns an error if any value doesn't match a dimension's allowed values.
-    pub fn from_values<I, S>(problem_type: &ProblemType, values: I) -> Result<Self, String>
+    pub fn from_values<I, S>(
+        problem_type: &ProblemType,
+        values: I,
+    ) -> Result<Self, ConstructionError>
     where
         I: IntoIterator<Item = S>,
         S: AsRef<str>,
@@ -59,7 +63,8 @@ impl ProblemRef {
                     return Err(format!(
                         "Unknown variant value \"{val}\" for {}. Known variants: {known:?}",
                         problem_type.canonical_name,
-                    ));
+                    )
+                    .into());
                 }
             }
         }
@@ -74,7 +79,7 @@ impl ProblemRef {
     pub fn from_map(
         problem_type: &ProblemType,
         variant: BTreeMap<String, String>,
-    ) -> Result<Self, String> {
+    ) -> Result<Self, ConstructionError> {
         // Validate all keys and values
         for (key, value) in &variant {
             let dim = problem_type
@@ -91,7 +96,8 @@ impl ProblemRef {
                 return Err(format!(
                     "Unknown value \"{value}\" for dimension \"{key}\" of {}. Known variants: {:?}",
                     problem_type.canonical_name, dim.allowed_values
-                ));
+                )
+                .into());
             }
         }
 
@@ -105,6 +111,39 @@ impl ProblemRef {
         })
     }
 
+    /// Create a `ProblemRef` from a non-empty prefix of the declared dimensions.
+    ///
+    /// Missing trailing dimensions are filled with their declared defaults. This
+    /// is intended for external formats that permit trailing generic arguments
+    /// to be omitted while keeping the leading type arguments mandatory.
+    pub fn from_prefix_map(
+        problem_type: &ProblemType,
+        variant: BTreeMap<String, String>,
+    ) -> Result<Self, ConstructionError> {
+        if !problem_type.dimensions.is_empty() && variant.is_empty() {
+            return Err(format!(
+                "Variant for {} must specify its first dimension \"{}\"",
+                problem_type.canonical_name, problem_type.dimensions[0].key
+            )
+            .into());
+        }
+
+        let supplied = variant.len();
+        if supplied > problem_type.dimensions.len()
+            || problem_type.dimensions[..supplied]
+                .iter()
+                .any(|dimension| !variant.contains_key(dimension.key))
+        {
+            return Err(format!(
+                "Variant for {} must specify a prefix of its dimensions",
+                problem_type.canonical_name
+            )
+            .into());
+        }
+
+        Self::from_map(problem_type, variant)
+    }
+
     /// Get the canonical problem name.
     pub fn name(&self) -> &str {
         &self.name
@@ -128,7 +167,7 @@ impl ProblemRef {
 ///
 /// Only validates against catalog schema (names, aliases, dimensions).
 /// Does NOT check reduction graph reachability.
-pub fn parse_catalog_problem_ref(input: &str) -> Result<ProblemRef, String> {
+pub fn parse_catalog_problem_ref(input: &str) -> Result<ProblemRef, ConstructionError> {
     let parts: Vec<&str> = input.split('/').collect();
     let raw_name = parts[0];
     let values: Vec<&str> = parts[1..].to_vec();
@@ -149,7 +188,7 @@ pub fn parse_catalog_problem_ref(input: &str) -> Result<ProblemRef, String> {
 pub fn require_graph_variant(
     graph: &crate::rules::ReductionGraph,
     problem_ref: &ProblemRef,
-) -> Result<crate::export::ProblemRef, String> {
+) -> Result<crate::export::ProblemRef, ConstructionError> {
     let known_variants = graph.variants_for(problem_ref.name());
     if known_variants.iter().any(|v| v == problem_ref.variant()) {
         return Ok(problem_ref.to_export_ref());
@@ -161,5 +200,6 @@ pub fn require_graph_variant(
         problem_ref.variant(),
         problem_ref.name(),
         known_variants
-    ))
+    )
+    .into())
 }
diff --git a/src/registry/problem_type.rs b/src/registry/problem_type.rs
index 5337873c2..509ecff45 100644
--- a/src/registry/problem_type.rs
+++ b/src/registry/problem_type.rs
@@ -1,6 +1,6 @@
 //! Problem type catalog: runtime lookup by name, alias, and variant validation.
 
-use super::schema::{ProblemSchemaEntry, VariantDimension};
+use super::schema::{ProblemCategory, ProblemSchemaEntry, VariantDimension};
 use super::FieldInfo;
 use std::collections::BTreeMap;
 
@@ -17,8 +17,10 @@ pub struct ProblemType {
     pub dimensions: &'static [VariantDimension],
     /// Human-readable description.
     pub description: &'static str,
-    /// Struct fields.
+    /// Inputs accepted when constructing this problem.
     pub fields: &'static [FieldInfo],
+    /// Explicit structural model category.
+    pub category: ProblemCategory,
 }
 
 impl ProblemType {
@@ -31,6 +33,7 @@ impl ProblemType {
             dimensions: entry.dimensions,
             description: entry.description,
             fields: entry.fields,
+            category: entry.category,
         }
     }
 
diff --git a/src/registry/schema.rs b/src/registry/schema.rs
index 00f202917..629047479 100644
--- a/src/registry/schema.rs
+++ b/src/registry/schema.rs
@@ -2,6 +2,73 @@
 
 use super::FieldInfo;
 use serde::Serialize;
+use std::fmt;
+use std::str::FromStr;
+
+/// Structural category used to organize problem implementations and catalog output.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ProblemCategory {
+    Algebraic,
+    Formula,
+    Graph,
+    Misc,
+    Set,
+}
+
+impl ProblemCategory {
+    pub const ALL: [Self; 5] = [
+        Self::Algebraic,
+        Self::Formula,
+        Self::Graph,
+        Self::Misc,
+        Self::Set,
+    ];
+
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Algebraic => "algebraic",
+            Self::Formula => "formula",
+            Self::Graph => "graph",
+            Self::Misc => "misc",
+            Self::Set => "set",
+        }
+    }
+}
+
+impl fmt::Display for ProblemCategory {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(self.as_str())
+    }
+}
+
+/// Error returned when a catalog category is not one of the five supported values.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ParseProblemCategoryError(String);
+
+impl fmt::Display for ParseProblemCategoryError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let expected = ProblemCategory::ALL.map(ProblemCategory::as_str).join(", ");
+        write!(
+            formatter,
+            "unknown problem category `{}`; expected one of: {expected}",
+            self.0,
+        )
+    }
+}
+
+impl std::error::Error for ParseProblemCategoryError {}
+
+impl FromStr for ProblemCategory {
+    type Err = ParseProblemCategoryError;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        Self::ALL
+            .into_iter()
+            .find(|category| category.as_str() == value)
+            .ok_or_else(|| ParseProblemCategoryError(value.to_string()))
+    }
+}
 
 /// A declared variant dimension for a problem type.
 ///
@@ -33,6 +100,22 @@ impl VariantDimension {
 }
 
 /// A registered problem schema entry for static inventory registration.
+///
+/// Category is required rather than inferred from source location:
+///
+/// ```compile_fail
+/// use problemreductions::registry::ProblemSchemaEntry;
+///
+/// let _schema = ProblemSchemaEntry {
+///     name: "Example",
+///     display_name: "Example",
+///     aliases: &[],
+///     dimensions: &[],
+///     module_path: module_path!(),
+///     description: "Example schema",
+///     fields: &[],
+/// };
+/// ```
 pub struct ProblemSchemaEntry {
     /// Problem name (e.g., "MaximumIndependentSet").
     pub name: &'static str,
@@ -42,29 +125,18 @@ pub struct ProblemSchemaEntry {
     pub aliases: &'static [&'static str],
     /// Declared variant dimensions with defaults and allowed values.
     pub dimensions: &'static [VariantDimension],
+    /// Explicit structural category shown in catalog output.
+    pub category: ProblemCategory,
     /// Module path from `module_path!()` (e.g., "problemreductions::models::graph::maximum_independent_set").
     pub module_path: &'static str,
     /// Human-readable description.
     pub description: &'static str,
-    /// Struct fields.
+    /// Inputs accepted when constructing this problem.
     pub fields: &'static [FieldInfo],
 }
 
 inventory::collect!(ProblemSchemaEntry);
 
-/// Optional static size-field metadata for problem types.
-///
-/// This is used when a problem has meaningful size fields even before it
-/// participates in any reduction overhead expressions.
-pub struct ProblemSizeFieldEntry {
-    /// Problem name (e.g., "MaximumIndependentSet").
-    pub name: &'static str,
-    /// Size field names (e.g., `&["num_vertices", "num_edges"]`).
-    pub fields: &'static [&'static str],
-}
-
-inventory::collect!(ProblemSizeFieldEntry);
-
 /// JSON-serializable problem schema.
 #[derive(Debug, Clone, Serialize)]
 pub struct ProblemSchemaJson {
@@ -72,7 +144,9 @@ pub struct ProblemSchemaJson {
     pub name: String,
     /// Problem description.
     pub description: String,
-    /// Struct fields.
+    /// Structural catalog category.
+    pub category: ProblemCategory,
+    /// Inputs accepted when constructing this problem.
     pub fields: Vec<FieldInfoJson>,
 }
 
@@ -94,6 +168,7 @@ pub fn collect_schemas() -> Vec<ProblemSchemaJson> {
         .map(|entry| ProblemSchemaJson {
             name: entry.name.to_string(),
             description: entry.description.to_string(),
+            category: entry.category,
             fields: entry
                 .fields
                 .iter()
@@ -109,14 +184,6 @@ pub fn collect_schemas() -> Vec<ProblemSchemaJson> {
     schemas
 }
 
-/// Collect explicitly declared size fields for a problem type.
-pub fn declared_size_fields(name: &str) -> Vec<&'static str> {
-    inventory::iter::<ProblemSizeFieldEntry>()
-        .filter(|entry| entry.name == name)
-        .flat_map(|entry| entry.fields.iter().copied())
-        .collect()
-}
-
 #[cfg(test)]
 #[path = "../unit_tests/registry/schema.rs"]
 mod tests;
diff --git a/src/registry/variant.rs b/src/registry/variant.rs
index 254fd0539..08f464b00 100644
--- a/src/registry/variant.rs
+++ b/src/registry/variant.rs
@@ -3,11 +3,222 @@
 use std::any::Any;
 use std::collections::BTreeMap;
 
-use crate::registry::dyn_problem::{DynProblem, SolveValueFn, SolveWitnessFn};
+use crate::registry::dyn_problem::DynProblem;
+use crate::registry::FieldInfo;
+
+/// Reusable syntax used to transport one construction input.
+///
+/// `Auto` asks a frontend to choose the codec from `type_name`. The explicit
+/// variants are for Rust types whose compact external syntax is ambiguous.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize)]
+pub enum CreateInputCodec {
+    /// Infer the transport syntax from the Rust value type.
+    #[default]
+    Auto,
+    /// A single scalar value.
+    Scalar,
+    /// A JSON value.
+    Json,
+    /// Comma-separated values.
+    CommaSeparated,
+    /// Semicolon-separated rows or groups.
+    SemicolonSeparated,
+    /// Undirected edges such as `0-1,1-2`.
+    EdgeList,
+    /// Directed arcs such as `0>1,1>2`.
+    ArcList,
+    /// Bipartite-local edges such as `0-0,0-1`.
+    BipartiteEdgeList,
+    /// Equality-linked index pairs such as `2=5;4=3`.
+    EqualityPairList,
+    /// Functional dependencies such as `0,1:2;2:3,4`.
+    FunctionalDependencyList,
+    /// Semicolon-separated character strings sharing one inferred alphabet.
+    CharacterRows,
+}
+
+/// A user-facing input accepted when constructing a problem instance.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
+pub struct CreateInputInfo {
+    /// Input name in snake_case. Frontends may render it in their native style.
+    pub name: &'static str,
+    /// Concrete Rust value type accepted by the construction spec.
+    pub type_name: &'static str,
+    /// Human-readable input description.
+    pub description: &'static str,
+    /// Whether the input must be present.
+    pub required: bool,
+    /// Reusable transport syntax for this input.
+    pub codec: CreateInputCodec,
+}
+
+impl CreateInputInfo {
+    /// Promote catalog field metadata into a required construction input.
+    pub const fn from_field(field: FieldInfo) -> Self {
+        Self {
+            name: field.name,
+            type_name: field.type_name,
+            description: field.description,
+            required: true,
+            codec: CreateInputCodec::Auto,
+        }
+    }
+}
+
+/// Construction-input metadata generated from a typed create spec.
+pub trait CreateSpec {
+    /// Construction-facing field metadata used by the problem catalog.
+    const FIELDS: &'static [FieldInfo];
+    /// Inputs accepted by this specification, including composed decision inputs.
+    fn inputs() -> Vec<CreateInputInfo>;
+
+    /// Deserialize normalized construction inputs into the typed specification.
+    fn deserialize_inputs(data: serde_json::Value) -> Result<Self, serde_json::Error>
+    where
+        Self: Sized + serde::de::DeserializeOwned,
+    {
+        serde_json::from_value(data)
+    }
+}
+
+/// Failure while validating or applying a model construction contract.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum ConstructionError {
+    /// No concrete variant matches the requested problem reference.
+    #[error("no registered variant for `{name}` with variant {variant:?}")]
+    UnregisteredVariant {
+        /// Canonical problem name.
+        name: String,
+        /// Exact requested variant.
+        variant: BTreeMap<String, String>,
+    },
+    /// Construction values must be supplied as a named JSON object.
+    #[error("construction inputs must be a JSON object")]
+    ExpectedObject,
+    /// A construction contract declared the same input more than once.
+    #[error("construction input `{0}` is declared more than once")]
+    DuplicateInput(String),
+    /// The caller supplied values outside the declared construction contract.
+    #[error("unknown construction input(s): {}", .0.join(", "))]
+    UnknownInputs(Vec<String>),
+    /// The caller omitted required construction values.
+    #[error("missing required construction input(s): {}", .0.join(", "))]
+    MissingInputs(Vec<String>),
+    /// Normalized values could not be deserialized into the direct model or create spec.
+    #[error("invalid construction input: {0}")]
+    InvalidInput(String),
+    /// A typed create spec failed to convert into the problem model.
+    #[error("problem construction failed: {0}")]
+    Conversion(String),
+    /// Arithmetic used to produce a stored model field overflowed.
+    #[error("integer overflow during construction: {0}")]
+    IntegerOverflow(String),
+    /// A stored approximate value is not finite.
+    #[error("non-finite floating-point construction value: {0}")]
+    NonFiniteFloat(String),
+    /// An exact integer cannot be stored in the target floating-point domain.
+    #[error("inexact integer-to-float construction value: {0}")]
+    InexactFloatConversion(#[from] crate::types::ExactI64ToF64Error),
+}
+
+impl From<String> for ConstructionError {
+    fn from(message: String) -> Self {
+        Self::Conversion(message)
+    }
+}
+
+impl From<&str> for ConstructionError {
+    fn from(message: &str) -> Self {
+        Self::Conversion(message.to_string())
+    }
+}
+
+impl From<std::convert::Infallible> for ConstructionError {
+    fn from(value: std::convert::Infallible) -> Self {
+        match value {}
+    }
+}
+
+/// Type-erased problem constructor used by dynamic frontends.
+pub type ConstructProblemFn =
+    fn(serde_json::Value) -> Result<Box<dyn DynProblem>, ConstructionError>;
+
+/// Random-generation contract for one concrete problem variant.
+#[derive(Clone, Copy)]
+pub struct RandomRegistration {
+    /// Inputs accepted by the generator.
+    pub inputs: fn() -> Vec<CreateInputInfo>,
+    /// Generate a concrete problem from normalized inputs.
+    pub generate: ConstructProblemFn,
+}
+
+/// A concrete problem type that can generate itself from typed random inputs.
+pub trait RandomGenerate: DynProblem + Sized {
+    /// Inputs accepted by this model's random generator.
+    fn inputs() -> Vec<CreateInputInfo>;
+
+    /// Generate a concrete problem from normalized random inputs.
+    fn generate(data: serde_json::Value) -> Result<Self, ConstructionError>;
+}
+
+/// Validate normalized values against a typed construction contract.
+pub fn validate_create_inputs(
+    inputs: &[CreateInputInfo],
+    data: &serde_json::Value,
+) -> Result<(), ConstructionError> {
+    validate_input_contract(
+        inputs.iter().map(|input| (input.name, input.required)),
+        data,
+    )
+}
+
+/// Validate the direct-construction path backed by catalog field metadata.
+///
+/// Direct models have no separate create DTO, so every catalog field is a
+/// required construction input.
+pub fn validate_direct_create_inputs(
+    fields: &[FieldInfo],
+    data: &serde_json::Value,
+) -> Result<(), ConstructionError> {
+    validate_input_contract(fields.iter().map(|field| (field.name, true)), data)
+}
+
+fn validate_input_contract<'a>(
+    inputs: impl IntoIterator<Item = (&'a str, bool)>,
+    data: &serde_json::Value,
+) -> Result<(), ConstructionError> {
+    let object = data.as_object().ok_or(ConstructionError::ExpectedObject)?;
+    let mut declared = BTreeMap::new();
+    for (name, required) in inputs {
+        if declared.insert(name, required).is_some() {
+            return Err(ConstructionError::DuplicateInput(name.to_string()));
+        }
+    }
+
+    let unknown = object
+        .keys()
+        .filter(|name| !declared.contains_key(name.as_str()))
+        .cloned()
+        .collect::<Vec<_>>();
+    if !unknown.is_empty() {
+        return Err(ConstructionError::UnknownInputs(unknown));
+    }
+
+    let missing = declared
+        .into_iter()
+        .filter(|(name, required)| *required && !object.contains_key(*name))
+        .map(|(name, _)| name.to_string())
+        .collect::<Vec<_>>();
+    if !missing.is_empty() {
+        return Err(ConstructionError::MissingInputs(missing));
+    }
+
+    Ok(())
+}
 
 /// A registered problem variant entry.
 ///
-/// Submitted by [`declare_variants!`] for each concrete problem type.
+/// Submitted by `declare_variants!` for each concrete problem type.
 /// The reduction graph uses these entries to build nodes with complexity metadata.
 pub struct VariantEntry {
     /// Problem name (from `Problem::NAME`).
@@ -20,6 +231,10 @@ pub struct VariantEntry {
     /// Takes a `&dyn Any` (must be `&ProblemType`), calls getter methods directly,
     /// and returns the estimated worst-case time as f64.
     pub complexity_eval_fn: fn(&dyn Any) -> f64,
+    /// Canonical problem-owned parameter names.
+    pub parameter_names_fn: fn() -> &'static [&'static str],
+    /// Measure the complete canonical parameters of a concrete instance.
+    pub parameter_measure_fn: fn(&dyn Any) -> crate::types::ProblemParameters,
     /// Whether this entry is the declared default variant for its problem.
     pub is_default: bool,
     /// Variant-level aliases (e.g., `&["3SAT"]` for `KSatisfiability<K3>`).
@@ -28,17 +243,34 @@ pub struct VariantEntry {
     /// specific reduction-graph node, not just to a canonical problem name. The CLI
     /// resolver tries variant-level aliases first and falls back to problem-level.
     pub aliases: &'static [&'static str],
+    /// Custom construction inputs. `None` means the catalog schema fields are
+    /// also the construction inputs through the direct path.
+    pub create_inputs: Option<fn() -> Vec<CreateInputInfo>>,
+    /// Construct a validated concrete problem from normalized construction data.
+    pub construct_fn: ConstructProblemFn,
+    /// Model-owned random generator for this exact variant.
+    pub random: Option<RandomRegistration>,
     /// Factory: deserialize JSON into a boxed dynamic problem.
     pub factory: fn(serde_json::Value) -> Result<Box<dyn DynProblem>, serde_json::Error>,
     /// Serialize: downcast `&dyn Any` and serialize to JSON.
     pub serialize_fn: fn(&dyn Any) -> Option<serde_json::Value>,
-    /// Solve value: downcast `&dyn Any` and brute-force solve to an aggregate string.
-    pub solve_value_fn: SolveValueFn,
-    /// Solve witness: downcast `&dyn Any` and brute-force recover a witness when available.
-    pub solve_witness_fn: SolveWitnessFn,
 }
 
 impl VariantEntry {
+    /// Inputs accepted by this concrete variant's constructor.
+    pub fn inputs(&self) -> Vec<CreateInputInfo> {
+        match self.create_inputs {
+            Some(inputs) => inputs(),
+            None => super::find_problem_type(self.name)
+                .expect("registered variant must have a problem schema")
+                .fields
+                .iter()
+                .cloned()
+                .map(CreateInputInfo::from_field)
+                .collect(),
+        }
+    }
+
     /// Get the variant by calling the function.
     pub fn variant(&self) -> Vec<(&'static str, &'static str)> {
         (self.variant_fn)()
@@ -51,6 +283,70 @@ impl VariantEntry {
             .map(|(k, v)| (k.to_string(), v.to_string()))
             .collect()
     }
+
+    /// Return the canonical parameter names for this exact variant.
+    pub fn parameter_names(&self) -> &'static [&'static str] {
+        (self.parameter_names_fn)()
+    }
+}
+
+/// Return every registered concrete problem variant.
+pub fn variant_entries() -> Vec<&'static VariantEntry> {
+    inventory::iter::<VariantEntry>().collect()
+}
+
+/// Validate canonical parameter schemas for every registered exact variant.
+pub fn validate_variant_parameter_schemas() -> Result<(), Vec<String>> {
+    let mut errors = Vec::new();
+    let mut schemas = BTreeMap::<&str, Vec<&str>>::new();
+
+    for entry in inventory::iter::<VariantEntry> {
+        let names = entry.parameter_names();
+        if names.is_empty() {
+            errors.push(format!("{} has no parameters", variant_label(entry)));
+            continue;
+        }
+
+        let unique = names
+            .iter()
+            .copied()
+            .collect::<std::collections::BTreeSet<_>>();
+        if unique.len() != names.len() {
+            errors.push(format!(
+                "{} declares duplicate parameters: {names:?}",
+                variant_label(entry)
+            ));
+        }
+
+        let canonical = names.to_vec();
+        if let Some(expected) = schemas.get(entry.name) {
+            if expected != &canonical {
+                errors.push(format!(
+                    "{} has parameter schema {canonical:?}, expected {expected:?}",
+                    variant_label(entry)
+                ));
+            }
+        } else {
+            schemas.insert(entry.name, canonical.clone());
+        }
+
+        let expression = crate::expr::Expr::parse(entry.complexity);
+        for variable in expression.variables() {
+            if !canonical.contains(&variable) {
+                errors.push(format!(
+                    "{} complexity references unknown parameter `{variable}`; declared: {canonical:?}",
+                    variant_label(entry)
+                ));
+            }
+        }
+    }
+
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        errors.sort();
+        Err(errors)
+    }
 }
 
 /// Find a variant entry by exact problem name and exact variant map.
diff --git a/src/rules/acyclicpartition_ilp.rs b/src/rules/acyclicpartition_ilp.rs
index 18a58090a..df8b781e2 100644
--- a/src/rules/acyclicpartition_ilp.rs
+++ b/src/rules/acyclicpartition_ilp.rs
@@ -1,7 +1,7 @@
-//! Reduction from AcyclicPartition to ILP<i32>.
+//! Reduction from AcyclicPartition to `ILP<i64>`.
 //!
 //! One-hot assignment x_{v,c}, McCormick same-class indicators s_{t,c},
-//! crossing flags y_t, class ordering o_c, vertex-order copies p_v.
+//! crossing flags y_t, and partition labels used directly as a topological order.
 //! See the paper entry for the full formulation.
 
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
@@ -12,41 +12,42 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 
 #[derive(Debug, Clone)]
 pub struct ReductionAcyclicPartitionToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     n: usize,
 }
 
 impl ReductionResult for ReductionAcyclicPartitionToILP {
-    type Source = AcyclicPartition<i32>;
-    type Target = ILP<i32>;
+    type Source = AcyclicPartition<i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// One-hot decode: for each vertex v, output the unique c with x_{v,c} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.n;
-        (0..n)
-            .map(|v| {
-                (0..n)
-                    .find(|&c| target_solution[v * n + c] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(target_solution, self.n, self.n, 0)
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "num_vertices * num_vertices + num_arcs * num_vertices + num_arcs + 2 * num_vertices",
-        num_constraints = "num_vertices + num_vertices + num_arcs * num_vertices + num_arcs + 1 + 2 * num_vertices + 2 * num_vertices * num_vertices + num_arcs",
+    transform = exact {
+        num_vars = "num_vertices * num_vertices + num_arcs * num_vertices + num_arcs",
+        num_constraints = "2 * num_vertices + 3 * num_arcs * num_vertices + 2 * num_arcs + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for AcyclicPartition<i32> {
+impl ReduceTo<ILP<i64>> for AcyclicPartition<i64> {
     type Result = ReductionAcyclicPartitionToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let arcs = self.graph().arcs();
         let m = arcs.len();
@@ -55,33 +56,30 @@ impl ReduceTo<ILP<i32>> for AcyclicPartition<i32> {
         // x_{v,c} : v*n + c                          [0, n^2)
         // s_{t,c} : n^2 + t*n + c                    [n^2, n^2 + m*n)
         // y_t     : n^2 + m*n + t                     [n^2 + m*n, n^2 + m*n + m)
-        // o_c     : n^2 + m*n + m + c                 [n^2 + m*n + m, n^2 + m*n + m + n)
-        // p_v     : n^2 + m*n + m + n + v              [n^2 + m*n + m + n, n^2 + m*n + m + 2n)
         let x_idx = |v: usize, c: usize| -> usize { v * n + c };
         let s_idx = |t: usize, c: usize| -> usize { n * n + t * n + c };
         let y_idx = |t: usize| -> usize { n * n + m * n + t };
-        let o_idx = |c: usize| -> usize { n * n + m * n + m + c };
-        let p_idx = |v: usize| -> usize { n * n + m * n + m + n + v };
-
-        let num_vars = n * n + m * n + m + 2 * n;
+        let num_vars = n * n + m * n + m;
         let mut constraints = Vec::new();
-        let big_m = n as f64;
+        let vertex_weights = self.vertex_weights();
+        let arc_costs = self.arc_costs();
+        let weight_bound = *self.weight_bound();
+        let cost_bound = *self.cost_bound();
 
         // 1) Assignment: Σ_c x_{v,c} = 1  for each vertex v
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|c| (x_idx(v, c), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|c| (x_idx(v, c), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 2) Weight bound: Σ_v w_v * x_{v,c} ≤ B  for each class c
         for c in 0..n {
-            let terms: Vec<(usize, f64)> = self
-                .vertex_weights()
+            let terms: Vec<(usize, i64)> = vertex_weights
                 .iter()
                 .enumerate()
-                .map(|(v, &w)| (x_idx(v, c), w as f64))
+                .map(|(vertex, &weight)| (x_idx(vertex, c), weight))
                 .collect();
-            constraints.push(LinearConstraint::le(terms, *self.weight_bound() as f64));
+            constraints.push(LinearConstraint::le(terms, weight_bound));
         }
 
         // 3) McCormick: s_{t,c} = x_{u_t,c} * x_{v_t,c}
@@ -93,69 +91,38 @@ impl ReduceTo<ILP<i32>> for AcyclicPartition<i32> {
 
         // 4) Crossing: y_t + Σ_c s_{t,c} = 1
         for t in 0..m {
-            let mut terms: Vec<(usize, f64)> = vec![(y_idx(t), 1.0)];
+            let mut terms: Vec<(usize, i64)> = vec![(y_idx(t), 1)];
             for c in 0..n {
-                terms.push((s_idx(t, c), 1.0));
+                terms.push((s_idx(t, c), 1));
             }
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 5) Cost bound: Σ_t cost(a_t) * y_t ≤ K
-        let cost_terms: Vec<(usize, f64)> = self
-            .arc_costs()
+        let cost_terms: Vec<(usize, i64)> = arc_costs
             .iter()
             .enumerate()
-            .map(|(t, &c)| (y_idx(t), c as f64))
+            .map(|(arc, &cost)| (y_idx(arc), cost))
             .collect();
-        constraints.push(LinearConstraint::le(cost_terms, *self.cost_bound() as f64));
-
-        // 6) Order bounds: 0 ≤ o_c ≤ n-1, 0 ≤ p_v ≤ n-1
-        for c in 0..n {
-            constraints.push(LinearConstraint::ge(vec![(o_idx(c), 1.0)], 0.0));
-            constraints.push(LinearConstraint::le(vec![(o_idx(c), 1.0)], (n - 1) as f64));
-        }
-        for v in 0..n {
-            constraints.push(LinearConstraint::ge(vec![(p_idx(v), 1.0)], 0.0));
-            constraints.push(LinearConstraint::le(vec![(p_idx(v), 1.0)], (n - 1) as f64));
-        }
-
-        // 7) Link p_v to o_c: p_v - o_c ≤ (n-1)(1 - x_{v,c}) and o_c - p_v ≤ (n-1)(1 - x_{v,c})
-        for v in 0..n {
-            for c in 0..n {
-                // p_v - o_c + (n-1)*x_{v,c} ≤ n-1
-                constraints.push(LinearConstraint::le(
-                    vec![
-                        (p_idx(v), 1.0),
-                        (o_idx(c), -1.0),
-                        (x_idx(v, c), (n - 1) as f64),
-                    ],
-                    (n - 1) as f64,
-                ));
-                // o_c - p_v + (n-1)*x_{v,c} ≤ n-1
-                constraints.push(LinearConstraint::le(
-                    vec![
-                        (o_idx(c), 1.0),
-                        (p_idx(v), -1.0),
-                        (x_idx(v, c), (n - 1) as f64),
-                    ],
-                    (n - 1) as f64,
-                ));
-            }
-        }
-
-        // 8) DAG ordering: p_{v_t} - p_{u_t} ≥ 1 - n * Σ_c s_{t,c}
-        //    i.e., p_{v_t} - p_{u_t} + n * Σ_c s_{t,c} ≥ 1
-        for (t, &(u, v)) in arcs.iter().enumerate() {
-            let mut terms = vec![(p_idx(v), 1.0), (p_idx(u), -1.0)];
-            for c in 0..n {
-                terms.push((s_idx(t, c), big_m));
+        constraints.push(LinearConstraint::le(cost_terms, cost_bound));
+
+        // 6) Topological labels: every arc goes from a lower or equal class to a
+        //    higher or equal class. Equal labels are internal arcs; strict
+        //    increases are quotient arcs.
+        for (u, v) in arcs {
+            let mut terms = Vec::with_capacity(2 * n.saturating_sub(1));
+            for c in 1..n {
+                let label = Self::exact_i64(c, "representing a partition label in ILP rows")?;
+                terms.push((x_idx(u, c), label));
+                terms.push((x_idx(v, c), -label));
             }
-            constraints.push(LinearConstraint::ge(terms, 1.0));
+            constraints.push(LinearConstraint::le(terms, 0));
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionAcyclicPartitionToILP { target, n }
+        Ok(ReductionAcyclicPartitionToILP { target, n })
     }
 }
 
@@ -174,16 +141,17 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 2,
             );
             let reduction: ReductionAcyclicPartitionToILP =
-                crate::rules::ReduceTo::<ILP<i32>>::reduce_to(&source);
+                crate::rules::ReduceTo::<ILP<i64>>::reduce_to(&source)
+                    .expect("reduction should succeed");
             let ilp_sol = crate::solvers::ILPSolver::new()
                 .solve(reduction.target_problem())
                 .expect("ILP should be solvable");
-            let extracted = reduction.extract_solution(&ilp_sol);
-            crate::example_db::specs::rule_example_with_witness::<_, ILP<i32>>(
+            let extracted = reduction.extract_solution(&ilp_sol).unwrap();
+            crate::example_db::specs::rule_example_with_witness::<_, ILP<i64>>(
                 source,
                 SolutionPair {
-                    source_config: extracted,
-                    target_config: ilp_sol,
+                    source_config: serde_json::json!(extracted),
+                    target_config: serde_json::json!(ilp_sol),
                 },
             )
         },
diff --git a/src/rules/analysis.rs b/src/rules/analysis.rs
index 6d616877d..c7cb50648 100644
--- a/src/rules/analysis.rs
+++ b/src/rules/analysis.rs
@@ -1,458 +1,7 @@
-//! Analysis utilities for the reduction graph.
-//!
-//! Detects primitive reduction rules that are dominated by composite paths,
-//! using asymptotic normalization plus monomial-dominance comparison.
-//!
-//! This analysis is **sound but incomplete**: it reports `Dominated` only when
-//! the symbolic comparison is trustworthy, and `Unknown` when metadata is too
-//! weak to compare safely.
-
-use crate::canonical::canonical_form;
-use crate::expr::Expr;
-use crate::rules::graph::{ReductionGraph, ReductionPath};
-use crate::rules::registry::ReductionOverhead;
-use std::collections::{BTreeMap, BTreeSet};
-use std::fmt;
-
-/// Result of comparing one primitive rule against one composite path.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ComparisonStatus {
-    /// Composite is equal or better on all common fields.
-    Dominated,
-    /// Composite is worse on at least one common field.
-    NotDominated,
-    /// Cannot decide: expression not normalizable or path not trustworthy.
-    Unknown,
-}
-
-/// A primitive reduction rule proven dominated by a composite path.
-#[derive(Debug, Clone)]
-pub struct DominatedRule {
-    pub source_name: &'static str,
-    pub source_variant: BTreeMap<String, String>,
-    pub target_name: &'static str,
-    pub target_variant: BTreeMap<String, String>,
-    pub primitive_overhead: ReductionOverhead,
-    pub dominating_path: ReductionPath,
-    pub composed_overhead: ReductionOverhead,
-    pub comparable_fields: Vec<String>,
-}
-
-impl DominatedRule {
-    pub fn source_display(&self) -> String {
-        format_problem_variant(self.source_name, &self.source_variant)
-    }
-
-    pub fn target_display(&self) -> String {
-        format_problem_variant(self.target_name, &self.target_variant)
-    }
-}
-
-impl fmt::Display for DominatedRule {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{} -> {}", self.source_display(), self.target_display())
-    }
-}
-
-/// A candidate comparison that could not be decided soundly.
-#[derive(Debug, Clone)]
-pub struct UnknownComparison {
-    pub source_name: &'static str,
-    pub source_variant: BTreeMap<String, String>,
-    pub target_name: &'static str,
-    pub target_variant: BTreeMap<String, String>,
-    pub candidate_path: ReductionPath,
-    pub reason: String,
-}
-
-impl UnknownComparison {
-    pub fn source_display(&self) -> String {
-        format_problem_variant(self.source_name, &self.source_variant)
-    }
-
-    pub fn target_display(&self) -> String {
-        format_problem_variant(self.target_name, &self.target_variant)
-    }
-}
-
-impl fmt::Display for UnknownComparison {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{} -> {}", self.source_display(), self.target_display())
-    }
-}
-
-pub fn format_problem_variant(name: &str, variant: &BTreeMap<String, String>) -> String {
-    if variant.is_empty() {
-        return name.to_string();
-    }
-
-    let vars = variant
-        .iter()
-        .map(|(k, v)| format!("{k}: {v:?}"))
-        .collect::<Vec<_>>()
-        .join(", ");
-    format!("{name} {{{vars}}}")
-}
-
-// ────────── Polynomial normalization ──────────
-
-/// A monomial: coefficient × ∏(variable ^ exponent).
-#[derive(Debug, Clone)]
-struct Monomial {
-    coeff: f64,
-    /// Variable name → exponent. Only non-zero exponents stored.
-    vars: BTreeMap<&'static str, f64>,
-}
-
-impl Monomial {
-    fn constant(c: f64) -> Self {
-        Self {
-            coeff: c,
-            vars: BTreeMap::new(),
-        }
-    }
-
-    fn variable(name: &'static str) -> Self {
-        let mut vars = BTreeMap::new();
-        vars.insert(name, 1.0);
-        Self { coeff: 1.0, vars }
-    }
-
-    /// Multiply two monomials.
-    fn mul(&self, other: &Monomial) -> Monomial {
-        let coeff = self.coeff * other.coeff;
-        let mut vars = self.vars.clone();
-        for (&v, &e) in &other.vars {
-            *vars.entry(v).or_insert(0.0) += e;
-        }
-        Monomial { coeff, vars }
-    }
-}
-
-/// A polynomial (sum of monomials) in normal form.
-#[derive(Debug, Clone)]
-struct NormalizedPoly {
-    terms: Vec<Monomial>,
-}
-
-impl NormalizedPoly {
-    fn add(mut self, other: NormalizedPoly) -> NormalizedPoly {
-        self.terms.extend(other.terms);
-        self
-    }
-
-    fn mul(&self, other: &NormalizedPoly) -> NormalizedPoly {
-        let mut terms = Vec::new();
-        for a in &self.terms {
-            for b in &other.terms {
-                terms.push(a.mul(b));
-            }
-        }
-        NormalizedPoly { terms }
-    }
+//! Topology analysis utilities for the reduction graph.
 
-    /// True if any monomial has a negative coefficient.
-    fn has_negative_coefficients(&self) -> bool {
-        self.terms.iter().any(|m| m.coeff < -1e-15)
-    }
-}
-
-/// Normalize an expression into a sum of monomials.
-///
-/// Supports: constants, variables, addition, multiplication,
-/// and powers with non-negative constant exponents.
-/// Returns `Err` for exp, log, sqrt, division, and negative exponents.
-fn normalize_polynomial(expr: &Expr) -> Result<NormalizedPoly, String> {
-    match expr {
-        Expr::Const(c) => Ok(NormalizedPoly {
-            terms: vec![Monomial::constant(*c)],
-        }),
-        Expr::Var(v) => Ok(NormalizedPoly {
-            terms: vec![Monomial::variable(v)],
-        }),
-        Expr::Add(a, b) => {
-            let pa = normalize_polynomial(a)?;
-            let pb = normalize_polynomial(b)?;
-            Ok(pa.add(pb))
-        }
-        Expr::Mul(a, b) => {
-            let pa = normalize_polynomial(a)?;
-            let pb = normalize_polynomial(b)?;
-            Ok(pa.mul(&pb))
-        }
-        Expr::Pow(base, exp) => {
-            if let Expr::Const(c) = exp.as_ref() {
-                if *c < 0.0 {
-                    return Err(format!("negative exponent: {c}"));
-                }
-                let pb = normalize_polynomial(base)?;
-                // Single monomial: multiply exponents
-                if pb.terms.len() == 1 {
-                    let m = &pb.terms[0];
-                    let coeff = m.coeff.powf(*c);
-                    let vars: BTreeMap<_, _> = m.vars.iter().map(|(&v, &e)| (v, e * c)).collect();
-                    return Ok(NormalizedPoly {
-                        terms: vec![Monomial { coeff, vars }],
-                    });
-                }
-                // Multi-term polynomial raised to non-negative integer power
-                let n = *c as usize;
-                if c.fract().abs() < 1e-10 {
-                    if n == 0 {
-                        return Ok(NormalizedPoly {
-                            terms: vec![Monomial::constant(1.0)],
-                        });
-                    }
-                    let mut result = pb.clone();
-                    for _ in 1..n {
-                        result = result.mul(&pb);
-                    }
-                    return Ok(result);
-                }
-                Err(format!(
-                    "non-integer power of multi-term polynomial: ({base})^{c}"
-                ))
-            } else {
-                Err(format!("variable exponent: ({base})^({exp})"))
-            }
-        }
-        Expr::Exp(_) => Err("exp() not supported".into()),
-        Expr::Log(_) => Err("log() not supported".into()),
-        Expr::Sqrt(_) => Err("sqrt() not supported".into()),
-        Expr::Factorial(_) => Err("factorial() not supported".into()),
-    }
-}
-
-fn prepare_expr_for_comparison(expr: &Expr) -> Expr {
-    canonical_form(expr).unwrap_or_else(|_| expr.clone())
-}
-
-// ────────── Monomial-dominance comparison ──────────
-
-/// Check if monomial `small` is asymptotically dominated by monomial `big`.
-///
-/// True iff for every variable in `small`, `big` has at least as large an exponent.
-/// This means `small` grows no faster than `big` as all variables → ∞.
-fn monomial_dominated_by(small: &Monomial, big: &Monomial) -> bool {
-    for (&var, &exp_small) in &small.vars {
-        let exp_big = big.vars.get(var).copied().unwrap_or(0.0);
-        if exp_small > exp_big + 1e-10 {
-            return false;
-        }
-    }
-    true
-}
-
-/// Check if polynomial `a` is asymptotically ≤ polynomial `b`.
-///
-/// True iff every positive-coefficient monomial in `a` is dominated by
-/// some positive-coefficient monomial in `b`.
-fn poly_leq(a: &NormalizedPoly, b: &NormalizedPoly) -> bool {
-    let b_positive: Vec<&Monomial> = b.terms.iter().filter(|m| m.coeff > 1e-15).collect();
-
-    for a_term in &a.terms {
-        if a_term.coeff <= 1e-15 {
-            continue; // zero or negative — can only make `a` smaller
-        }
-        let dominated = b_positive
-            .iter()
-            .any(|b_term| monomial_dominated_by(a_term, b_term));
-        if !dominated {
-            return false;
-        }
-    }
-    true
-}
-
-// ────────── Overhead comparison ──────────
-
-/// Compare two overheads across all common fields.
-///
-/// Returns `Dominated` if composite ≤ primitive on all common fields.
-/// Returns `NotDominated` if composite is worse on any common field.
-/// Returns `Unknown` if any common field's expressions cannot be normalized
-/// into a comparable polynomial form or contain negative coefficients.
-pub fn compare_overhead(
-    primitive: &ReductionOverhead,
-    composite: &ReductionOverhead,
-) -> ComparisonStatus {
-    let comp_map: std::collections::HashMap<&str, &Expr> = composite
-        .output_size
-        .iter()
-        .map(|(name, expr)| (*name, expr))
-        .collect();
-
-    let mut any_common = false;
-
-    for (field, prim_expr) in &primitive.output_size {
-        let Some(comp_expr) = comp_map.get(field) else {
-            continue;
-        };
-        any_common = true;
-
-        let primitive_prepared = prepare_expr_for_comparison(prim_expr);
-        let composite_prepared = prepare_expr_for_comparison(comp_expr);
-
-        if primitive_prepared == composite_prepared {
-            continue;
-        }
-
-        let primitive_poly = match normalize_polynomial(&primitive_prepared) {
-            Ok(p) => p,
-            Err(_) => return ComparisonStatus::Unknown,
-        };
-        let composite_poly = match normalize_polynomial(&composite_prepared) {
-            Ok(p) => p,
-            Err(_) => return ComparisonStatus::Unknown,
-        };
-
-        // Reject expressions with negative coefficients
-        if primitive_poly.has_negative_coefficients() || composite_poly.has_negative_coefficients()
-        {
-            return ComparisonStatus::Unknown;
-        }
-
-        // Check: composite ≤ primitive on this field
-        if !poly_leq(&composite_poly, &primitive_poly) {
-            return ComparisonStatus::NotDominated;
-        }
-    }
-
-    if any_common {
-        ComparisonStatus::Dominated
-    } else {
-        ComparisonStatus::NotDominated
-    }
-}
-
-// ────────── Main analysis ──────────
-
-/// Find all primitive reduction rules dominated by composite paths.
-///
-/// Returns a tuple of:
-/// - `Vec<DominatedRule>`: rules proven dominated by a composite path
-/// - `Vec<UnknownComparison>`: candidates that could not be decided
-///
-/// For each primitive rule (direct edge), enumerates all alternative paths,
-/// validates trustworthiness, composes overheads, and compares.
-/// Keeps only the best (shortest) dominating path per primitive rule.
-///
-/// Note: iterates the graph's coalesced edges rather than raw `inventory` entries.
-/// This is sound because `test_no_duplicate_primitive_rules_per_variant_pair` guards
-/// the invariant that at most one registration exists per (source_variant, target_variant) pair.
-pub fn find_dominated_rules(
-    graph: &ReductionGraph,
-) -> (Vec<DominatedRule>, Vec<UnknownComparison>) {
-    const MAX_PATHS_PER_EDGE: usize = 1024;
-    const MAX_INTERMEDIATE_NODES: usize = 6;
-
-    let mut dominated = Vec::new();
-    let mut unknown = Vec::new();
-
-    for edge_info in all_edges(graph) {
-        let paths = graph.find_paths_up_to_mode_bounded(
-            edge_info.source_name,
-            &edge_info.source_variant,
-            edge_info.target_name,
-            &edge_info.target_variant,
-            crate::rules::graph::ReductionMode::Witness,
-            MAX_PATHS_PER_EDGE,
-            Some(MAX_INTERMEDIATE_NODES),
-        );
-
-        let mut best_dominating: Option<(ReductionPath, ReductionOverhead, Vec<String>)> = None;
-
-        for path in paths {
-            if path.len() <= 1 {
-                continue; // skip the direct edge itself
-            }
-
-            let composed = graph.compose_path_overhead(&path);
-
-            match compare_overhead(&edge_info.overhead, &composed) {
-                ComparisonStatus::Dominated => {
-                    let comparable_fields = common_fields(&edge_info.overhead, &composed);
-                    let is_better = match &best_dominating {
-                        None => true,
-                        Some((best_path, _, _)) => path.len() < best_path.len(),
-                    };
-                    if is_better {
-                        best_dominating = Some((path, composed, comparable_fields));
-                    }
-                }
-                ComparisonStatus::Unknown => {
-                    unknown.push(UnknownComparison {
-                        source_name: edge_info.source_name,
-                        source_variant: edge_info.source_variant.clone(),
-                        target_name: edge_info.target_name,
-                        target_variant: edge_info.target_variant.clone(),
-                        candidate_path: path,
-                        reason: "expression comparison returned Unknown".into(),
-                    });
-                }
-                ComparisonStatus::NotDominated => {}
-            }
-        }
-
-        if let Some((path, composed, fields)) = best_dominating {
-            dominated.push(DominatedRule {
-                source_name: edge_info.source_name,
-                source_variant: edge_info.source_variant.clone(),
-                target_name: edge_info.target_name,
-                target_variant: edge_info.target_variant.clone(),
-                primitive_overhead: edge_info.overhead.clone(),
-                dominating_path: path,
-                composed_overhead: composed,
-                comparable_fields: fields,
-            });
-        }
-    }
-
-    // Deterministic output
-    dominated.sort_by(|a, b| {
-        (
-            format_problem_variant(a.source_name, &a.source_variant),
-            format_problem_variant(a.target_name, &a.target_variant),
-            a.dominating_path.len(),
-        )
-            .cmp(&(
-                format_problem_variant(b.source_name, &b.source_variant),
-                format_problem_variant(b.target_name, &b.target_variant),
-                b.dominating_path.len(),
-            ))
-    });
-    unknown.sort_by(|a, b| {
-        (
-            format_problem_variant(a.source_name, &a.source_variant),
-            format_problem_variant(a.target_name, &a.target_variant),
-        )
-            .cmp(&(
-                format_problem_variant(b.source_name, &b.source_variant),
-                format_problem_variant(b.target_name, &b.target_variant),
-            ))
-    });
-
-    (dominated, unknown)
-}
-
-/// Fields present in both overheads.
-fn common_fields(a: &ReductionOverhead, b: &ReductionOverhead) -> Vec<String> {
-    let b_fields: std::collections::HashSet<&str> = b.output_size.iter().map(|(n, _)| *n).collect();
-    a.output_size
-        .iter()
-        .filter(|&(f, _)| b_fields.contains(f))
-        .map(|(f, _)| f.to_string())
-        .collect()
-}
-
-/// Collect all edges from the reduction graph.
-fn all_edges(graph: &ReductionGraph) -> Vec<crate::rules::graph::ReductionEdgeInfo> {
-    let mut edges = Vec::new();
-    for name in graph.problem_types() {
-        edges.extend(graph.outgoing_reductions(name));
-    }
-    edges
-}
+use crate::rules::graph::ReductionGraph;
+use std::collections::{BTreeMap, BTreeSet};
 
 // ────────── Topology checks ──────────
 
diff --git a/src/rules/balancedcompletebipartitesubgraph_ilp.rs b/src/rules/balancedcompletebipartitesubgraph_ilp.rs
index 955fd772d..8c220ba38 100644
--- a/src/rules/balancedcompletebipartitesubgraph_ilp.rs
+++ b/src/rules/balancedcompletebipartitesubgraph_ilp.rs
@@ -24,52 +24,64 @@ impl ReductionResult for ReductionBCBSToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_vertices]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_vertices",
-        num_constraints = "num_vertices * num_vertices",
+        num_constraints = "num_vertices^2 + 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for BalancedCompleteBipartiteSubgraph {
     type Result = ReductionBCBSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let left = self.left_size();
         let right = self.right_size();
         let n = left + right;
-        let k = self.k();
+        let k = Self::exact_i64(self.k(), "encoding the selected partition size")?;
         let mut constraints = Vec::new();
 
         // Build edge lookup (bipartite-local coords)
         let edge_set: HashSet<(usize, usize)> = self.graph().left_edges().iter().copied().collect();
 
         // Σ x_l = k (for l in 0..left)
-        let left_terms: Vec<(usize, f64)> = (0..left).map(|l| (l, 1.0)).collect();
-        constraints.push(LinearConstraint::eq(left_terms, k as f64));
+        let left_terms: Vec<(usize, i64)> = (0..left).map(|l| (l, 1)).collect();
+        constraints.push(LinearConstraint::eq(left_terms, k));
 
         // Σ y_r = k (for r in 0..right, variable index = left + r)
-        let right_terms: Vec<(usize, f64)> = (0..right).map(|r| (left + r, 1.0)).collect();
-        constraints.push(LinearConstraint::eq(right_terms, k as f64));
+        let right_terms: Vec<(usize, i64)> = (0..right).map(|r| (left + r, 1)).collect();
+        constraints.push(LinearConstraint::eq(right_terms, k));
 
         // Non-edge constraints: x_l + y_r ≤ 1 for (l, r) not in E
         for l in 0..left {
             for r in 0..right {
                 if !edge_set.contains(&(l, r)) {
-                    constraints.push(LinearConstraint::le(vec![(l, 1.0), (left + r, 1.0)], 1.0));
+                    constraints.push(LinearConstraint::le(vec![(l, 1), (left + r, 1)], 1));
                 }
             }
         }
 
-        let target = ILP::new(n, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionBCBSToILP {
+        let target = ILP::new(n, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionBCBSToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -87,8 +99,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 0, 1, 1, 0],
-                    target_config: vec![1, 1, 0, 1, 1, 0],
+                    source_config: serde_json::json!(vec![true, true, false, true, true, false]),
+                    target_config: serde_json::json!(vec![1, 1, 0, 1, 1, 0]),
                 },
             )
         },
diff --git a/src/rules/bicliquecover_bmf.rs b/src/rules/bicliquecover_bmf.rs
index 93f9e93fe..bcd5bd822 100644
--- a/src/rules/bicliquecover_bmf.rs
+++ b/src/rules/bicliquecover_bmf.rs
@@ -36,13 +36,18 @@ impl ReductionResult for ReductionBicliqueCoverToBMF {
 
     /// Map a BMF config (B row-major, C row-major) to a BicliqueCover
     /// config (vertex-major) via the inverse transpose.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        config_bmf_to_bc(target_solution, self.m, self.n, self.k)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(config_bmf_to_bc(target_solution, self.m, self.n, self.k))
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         rows = "left_size",
         cols = "right_size",
         rank = "rank",
@@ -51,7 +56,7 @@ impl ReductionResult for ReductionBicliqueCoverToBMF {
 impl ReduceTo<BMF> for BicliqueCover {
     type Result = ReductionBicliqueCoverToBMF;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.left_size();
         let n = self.right_size();
         let k = self.k();
@@ -60,7 +65,7 @@ impl ReduceTo<BMF> for BicliqueCover {
             matrix[i][j] = true;
         }
         let target = BMF::new(matrix, k);
-        ReductionBicliqueCoverToBMF { target, m, n, k }
+        Ok(ReductionBicliqueCoverToBMF { target, m, n, k })
     }
 }
 
@@ -80,10 +85,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, BMF>(
                 source,
                 SolutionPair {
-                    // BicliqueCover (vertex-major, k=1): all 4 vertices in biclique 0
-                    source_config: vec![1, 1, 1, 1],
-                    // BMF (B row-major then C row-major): B=[[1],[1]], C=[[1,1]]
-                    target_config: vec![1, 1, 1, 1],
+                    source_config: serde_json::json!(vec![vec![true, true, true, true]]),
+                    target_config: serde_json::json!((
+                        vec![vec![true], vec![true]],
+                        vec![vec![true, true]]
+                    )),
                 },
             )
         },
diff --git a/src/rules/biconnectivityaugmentation_ilp.rs b/src/rules/biconnectivityaugmentation_ilp.rs
index 4be442b96..6fc7dd3bc 100644
--- a/src/rules/biconnectivityaugmentation_ilp.rs
+++ b/src/rules/biconnectivityaugmentation_ilp.rs
@@ -1,10 +1,10 @@
-//! Reduction from BiconnectivityAugmentation to ILP<i32>.
+//! Reduction from BiconnectivityAugmentation to `ILP<i64>`.
 //!
-//! Select candidate edges under budget and, for every deleted vertex q,
+//! Select candidate edges under budget and, both before deletion and for every deleted vertex q,
 //! certify that the remaining augmented graph stays connected via unit-flow
 //! commodities from a surviving root to every other surviving vertex.
 
-use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::models::algebraic::{IntegerVariable, LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::BiconnectivityAugmentation;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
@@ -12,78 +12,109 @@ use crate::topology::{Graph, SimpleGraph};
 
 #[derive(Debug, Clone)]
 pub struct ReductionBiconnAugToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_candidates: usize,
 }
 
+impl ReductionBiconnAugToILP {
+    fn dimensions(
+        n: usize,
+        m: usize,
+        p: usize,
+    ) -> Result<(usize, usize), crate::rules::ReductionError> {
+        let overflow = || {
+            crate::rules::ReductionError::integer_overflow::<
+                BiconnectivityAugmentation<SimpleGraph, i64>,
+                ILP<i64>,
+            >("computing connectivity flow variable counts")
+        };
+        let commodities = n
+            .checked_add(1)
+            .and_then(|x| x.checked_mul(n))
+            .ok_or_else(overflow)?;
+        let base_variables = commodities
+            .checked_mul(m)
+            .and_then(|x| x.checked_mul(2))
+            .ok_or_else(overflow)?;
+        let candidate_start = p.checked_add(base_variables).ok_or_else(overflow)?;
+        let num_variables = commodities
+            .checked_mul(p)
+            .and_then(|x| x.checked_mul(2))
+            .and_then(|x| x.checked_add(candidate_start))
+            .ok_or_else(overflow)?;
+        Ok((candidate_start, num_variables))
+    }
+}
+
 impl ReductionResult for ReductionBiconnAugToILP {
-    type Source = BiconnectivityAugmentation<SimpleGraph, i32>;
-    type Target = ILP<i32>;
+    type Source = BiconnectivityAugmentation<SimpleGraph, i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_candidates].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        if crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?
+            .value
+            .is_none()
+        {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target ILP assignment is infeasible",
+            ));
+        }
+
+        Ok(target_solution[..self.num_candidates]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "num_potential_edges + 2 * num_vertices * num_vertices * (num_edges + num_potential_edges)",
-        num_constraints = "1 + 2 * num_vertices * num_vertices * num_potential_edges + num_vertices * num_vertices * num_vertices",
+    transform = upper_bound {
+        num_vars = "num_potential_edges + 2 * num_vertices * (num_vertices + 1) * (num_edges + num_potential_edges)",
+        num_constraints = "1 + num_vertices * (num_vertices + 1) * (2 * num_edges + 4 * num_potential_edges + num_vertices)",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for BiconnectivityAugmentation<SimpleGraph, i32> {
+impl ReduceTo<ILP<i64>> for BiconnectivityAugmentation<SimpleGraph, i64> {
     type Result = ReductionBiconnAugToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let p = self.num_potential_edges();
 
-        // Trivial case: n ≤ 1 already biconnected
-        if n <= 1 {
-            let target = ILP::new(p, vec![], vec![], ObjectiveSense::Minimize);
-            return ReductionBiconnAugToILP {
-                target,
-                num_candidates: p,
-            };
-        }
-
         let base_edges = self.graph().edges();
         let m = base_edges.len();
 
-        // Variable layout:
-        // y_j:                j                                      [0, p)
-        // f^{q,t}_{i,eta}:   p + ((q*n + t)*m + i)*2 + eta          [p, p + 2*m*n^2)
-        // g^{q,t}_{j,eta}:   p + 2*m*n^2 + ((q*n + t)*p + j)*2 + eta  [p + 2*m*n^2, p + 2*n^2*(m+p))
-        let num_vars = p + 2 * n * n * (m + p);
+        // q = n certifies the original graph; q < n deletes that vertex.
+        // y_j occupies [0,p), followed by all base-edge and candidate-edge flows.
+        let (candidate_start, num_vars) = ReductionBiconnAugToILP::dimensions(n, m, p)?;
         let f_idx = |q: usize, t: usize, i: usize, eta: usize| -> usize {
             p + ((q * n + t) * m + i) * 2 + eta
         };
         let g_idx = |q: usize, t: usize, j: usize, eta: usize| -> usize {
-            p + 2 * m * n * n + ((q * n + t) * p + j) * 2 + eta
+            candidate_start + ((q * n + t) * p + j) * 2 + eta
         };
-
         let mut constraints = Vec::new();
 
-        // Binary bounds: y_j ≤ 1
-        for j in 0..p {
-            constraints.push(LinearConstraint::le(vec![(j, 1.0)], 1.0));
-        }
-
         // Budget constraint: Σ w_j y_j ≤ B
-        let budget_terms: Vec<(usize, f64)> = self
+        let budget_terms: Vec<(usize, i64)> = self
             .potential_weights()
             .iter()
             .enumerate()
-            .map(|(j, &(_, _, w))| (j, w as f64))
+            .map(|(candidate, &(_, _, weight))| (candidate, weight))
             .collect();
-        constraints.push(LinearConstraint::le(budget_terms, *self.budget() as f64));
+        constraints.push(LinearConstraint::le(budget_terms, *self.budget()));
 
-        // For each deleted vertex q
-        for q in 0..n {
+        // Include q = n: no endpoint equals n, so no vertex or edge is deleted.
+        for q in 0..=n {
             let root = if q != 0 { 0 } else { 1 };
 
             for t in 0..n {
@@ -92,13 +123,13 @@ impl ReduceTo<ILP<i32>> for BiconnectivityAugmentation<SimpleGraph, i32> {
                     for i in 0..m {
                         for eta in 0..2 {
                             constraints
-                                .push(LinearConstraint::eq(vec![(f_idx(q, t, i, eta), 1.0)], 0.0));
+                                .push(LinearConstraint::eq(vec![(f_idx(q, t, i, eta), 1)], 0));
                         }
                     }
                     for j in 0..p {
                         for eta in 0..2 {
                             constraints
-                                .push(LinearConstraint::eq(vec![(g_idx(q, t, j, eta), 1.0)], 0.0));
+                                .push(LinearConstraint::eq(vec![(g_idx(q, t, j, eta), 1)], 0));
                         }
                     }
                     continue;
@@ -109,7 +140,7 @@ impl ReduceTo<ILP<i32>> for BiconnectivityAugmentation<SimpleGraph, i32> {
                     if u == q || v == q {
                         for eta in 0..2 {
                             constraints
-                                .push(LinearConstraint::eq(vec![(f_idx(q, t, i, eta), 1.0)], 0.0));
+                                .push(LinearConstraint::eq(vec![(f_idx(q, t, i, eta), 1)], 0));
                         }
                     }
                 }
@@ -117,7 +148,7 @@ impl ReduceTo<ILP<i32>> for BiconnectivityAugmentation<SimpleGraph, i32> {
                     if sj == q || tj == q {
                         for eta in 0..2 {
                             constraints
-                                .push(LinearConstraint::eq(vec![(g_idx(q, t, j, eta), 1.0)], 0.0));
+                                .push(LinearConstraint::eq(vec![(g_idx(q, t, j, eta), 1)], 0));
                         }
                     }
                 }
@@ -130,8 +161,8 @@ impl ReduceTo<ILP<i32>> for BiconnectivityAugmentation<SimpleGraph, i32> {
                     }
                     for eta in 0..2 {
                         constraints.push(LinearConstraint::le(
-                            vec![(g_idx(q, t, j, eta), 1.0), (j, -1.0)],
-                            0.0,
+                            vec![(g_idx(q, t, j, eta), 1), (j, -1)],
+                            0,
                         ));
                     }
                 }
@@ -141,7 +172,7 @@ impl ReduceTo<ILP<i32>> for BiconnectivityAugmentation<SimpleGraph, i32> {
                     if v == q {
                         continue;
                     }
-                    let mut terms: Vec<(usize, f64)> = Vec::new();
+                    let mut terms: Vec<(usize, i64)> = Vec::new();
 
                     // Base edges
                     for (i, &(u_e, v_e)) in base_edges.iter().enumerate() {
@@ -150,12 +181,12 @@ impl ReduceTo<ILP<i32>> for BiconnectivityAugmentation<SimpleGraph, i32> {
                         }
                         // eta=0 means u->v direction
                         if u_e == v {
-                            terms.push((f_idx(q, t, i, 0), 1.0)); // outgoing
-                            terms.push((f_idx(q, t, i, 1), -1.0)); // incoming
+                            terms.push((f_idx(q, t, i, 0), 1)); // outgoing
+                            terms.push((f_idx(q, t, i, 1), -1)); // incoming
                         }
                         if v_e == v {
-                            terms.push((f_idx(q, t, i, 0), -1.0)); // incoming
-                            terms.push((f_idx(q, t, i, 1), 1.0)); // outgoing
+                            terms.push((f_idx(q, t, i, 0), -1)); // incoming
+                            terms.push((f_idx(q, t, i, 1), 1)); // outgoing
                         }
                     }
 
@@ -166,32 +197,38 @@ impl ReduceTo<ILP<i32>> for BiconnectivityAugmentation<SimpleGraph, i32> {
                         }
                         // eta=0 means s->t direction
                         if sj == v {
-                            terms.push((g_idx(q, t, j, 0), 1.0));
-                            terms.push((g_idx(q, t, j, 1), -1.0));
+                            terms.push((g_idx(q, t, j, 0), 1));
+                            terms.push((g_idx(q, t, j, 1), -1));
                         }
                         if tj == v {
-                            terms.push((g_idx(q, t, j, 0), -1.0));
-                            terms.push((g_idx(q, t, j, 1), 1.0));
+                            terms.push((g_idx(q, t, j, 0), -1));
+                            terms.push((g_idx(q, t, j, 1), 1));
                         }
                     }
 
                     let rhs = if v == root {
-                        1.0
+                        1
                     } else if v == t {
-                        -1.0
+                        -1
                     } else {
-                        0.0
+                        0
                     };
                     constraints.push(LinearConstraint::eq(terms, rhs));
                 }
             }
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionBiconnAugToILP {
+        let target = ILP::with_variables(
+            vec![IntegerVariable::binary(); num_vars],
+            constraints,
+            vec![],
+            ObjectiveSense::Minimize,
+        )
+        .map_err(Self::target_construction)?;
+        Ok(ReductionBiconnAugToILP {
             target,
             num_candidates: p,
-        }
+        })
     }
 }
 
@@ -208,16 +245,17 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 3,
             );
             let reduction: ReductionBiconnAugToILP =
-                crate::rules::ReduceTo::<ILP<i32>>::reduce_to(&source);
+                crate::rules::ReduceTo::<ILP<i64>>::reduce_to(&source)
+                    .expect("reduction should succeed");
             let ilp_sol = crate::solvers::ILPSolver::new()
                 .solve(reduction.target_problem())
                 .expect("ILP should be solvable");
-            let extracted = reduction.extract_solution(&ilp_sol);
-            crate::example_db::specs::rule_example_with_witness::<_, ILP<i32>>(
+            let extracted = reduction.extract_solution(&ilp_sol).unwrap();
+            crate::example_db::specs::rule_example_with_witness::<_, ILP<i64>>(
                 source,
                 SolutionPair {
-                    source_config: extracted,
-                    target_config: ilp_sol,
+                    source_config: serde_json::json!(extracted),
+                    target_config: serde_json::json!(ilp_sol),
                 },
             )
         },
diff --git a/src/rules/binpacking_ilp.rs b/src/rules/binpacking_ilp.rs
index 49dc2f51e..24d3cc5a8 100644
--- a/src/rules/binpacking_ilp.rs
+++ b/src/rules/binpacking_ilp.rs
@@ -9,6 +9,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::BinPacking;
 use crate::reduction;
+use crate::rules::ilp_helpers::one_hot_decode_rows;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing BinPacking to ILP.
@@ -26,7 +27,7 @@ pub struct ReductionBPToILP {
 }
 
 impl ReductionResult for ReductionBPToILP {
-    type Source = BinPacking<i32>;
+    type Source = BinPacking<i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
@@ -36,31 +37,29 @@ impl ReductionResult for ReductionBPToILP {
     /// Extract solution from ILP back to BinPacking.
     ///
     /// For each item i, find the unique bin j where x_{ij} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.n;
-        let mut assignment = vec![0usize; n];
-        for i in 0..n {
-            for j in 0..n {
-                if target_solution[i * n + j] == 1 {
-                    assignment[i] = j;
-                    break;
-                }
-            }
-        }
-        assignment
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        one_hot_decode_rows(target_solution, self.n, self.n, 0)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_items * num_items + num_items",
         num_constraints = "2 * num_items",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for BinPacking<i32> {
+impl ReduceTo<ILP<bool>> for BinPacking<i64> {
     type Result = ReductionBPToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_items();
         let num_vars = n * n + n;
 
@@ -68,31 +67,32 @@ impl ReduceTo<ILP<bool>> for BinPacking<i32> {
 
         // Assignment constraints: for each item i, sum_j x_{ij} = 1
         for i in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|j| (i * n + j, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|j| (i * n + j, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Capacity + linking constraints: for each bin j,
         // sum_i w_i * x_{ij} - C * y_j <= 0
-        let cap = *self.capacity() as f64;
+        let cap = *self.capacity();
+        let sizes = self.sizes();
         for j in 0..n {
-            let mut terms: Vec<(usize, f64)> = self
-                .sizes()
+            let mut terms: Vec<(usize, i64)> = sizes
                 .iter()
                 .enumerate()
-                .map(|(i, w)| (i * n + j, *w as f64))
+                .map(|(i, &weight)| (i * n + j, weight))
                 .collect();
             // Subtract C * y_j
             terms.push((n * n + j, -cap));
-            constraints.push(LinearConstraint::le(terms, 0.0));
+            constraints.push(LinearConstraint::le(terms, 0));
         }
 
         // Objective: minimize sum_j y_j
-        let objective: Vec<(usize, f64)> = (0..n).map(|j| (n * n + j, 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..n).map(|j| (n * n + j, 1)).collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionBPToILP { target, n }
+        Ok(ReductionBPToILP { target, n })
     }
 }
 
@@ -104,13 +104,13 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "binpacking_to_ilp",
         build: || {
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
-                BinPacking::new(vec![6, 5, 5, 4, 3], 10),
+                BinPacking::new(vec![6, 5, 5, 4, 3], 10).unwrap(),
                 SolutionPair {
-                    source_config: vec![2, 1, 0, 0, 2],
-                    target_config: vec![
+                    source_config: serde_json::json!(vec![2, 1, 0, 0, 2]),
+                    target_config: serde_json::json!(vec![
                         0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
                         1, 1, 1, 0, 0,
-                    ],
+                    ]),
                 },
             )
         },
diff --git a/src/rules/bmf_bicliquecover.rs b/src/rules/bmf_bicliquecover.rs
index bafa9b304..8f9790636 100644
--- a/src/rules/bmf_bicliquecover.rs
+++ b/src/rules/bmf_bicliquecover.rs
@@ -20,38 +20,45 @@ use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::BipartiteGraph;
 
-/// Convert a BicliqueCover config (vertex-major: index `v*k + b`) to a BMF
-/// config (B row-major at `[0, m*k)` then C row-major at `[m*k, m*k + k*n)`).
-///
-/// The left half copies unchanged; the right half transposes from
-/// vertex-major `(m+j)*k + l` to biclique-row-major `m*k + l*n + j`.
-pub(crate) fn config_bc_to_bmf(bc: &[usize], m: usize, n: usize, k: usize) -> Vec<usize> {
-    let mut bmf = vec![0usize; m * k + k * n];
+/// Convert one vertex-membership row per biclique into BMF factors.
+pub(crate) fn config_bc_to_bmf(
+    bc: &[Vec<bool>],
+    m: usize,
+    n: usize,
+    k: usize,
+) -> (Vec<Vec<bool>>, Vec<Vec<bool>>) {
+    let mut b = vec![vec![false; k]; m];
+    let mut c = vec![vec![false; n]; k];
     for i in 0..m {
         for l in 0..k {
-            bmf[i * k + l] = bc[i * k + l];
+            b[i][l] = bc[l][i];
         }
     }
     for l in 0..k {
         for j in 0..n {
-            bmf[m * k + l * n + j] = bc[(m + j) * k + l];
+            c[l][j] = bc[l][m + j];
         }
     }
-    bmf
+    (b, c)
 }
 
-/// Inverse of [`config_bc_to_bmf`]: BMF config (B row-major then C row-major)
-/// to BicliqueCover config (vertex-major).
-pub(crate) fn config_bmf_to_bc(bmf: &[usize], m: usize, n: usize, k: usize) -> Vec<usize> {
-    let mut bc = vec![0usize; (m + n) * k];
+/// Inverse of [`config_bc_to_bmf`].
+pub(crate) fn config_bmf_to_bc(
+    bmf: &(Vec<Vec<bool>>, Vec<Vec<bool>>),
+    m: usize,
+    n: usize,
+    k: usize,
+) -> Vec<Vec<bool>> {
+    let (b, c) = bmf;
+    let mut bc = vec![vec![false; m + n]; k];
     for i in 0..m {
         for l in 0..k {
-            bc[i * k + l] = bmf[i * k + l];
+            bc[l][i] = b[i][l];
         }
     }
     for l in 0..k {
         for j in 0..n {
-            bc[(m + j) * k + l] = bmf[m * k + l * n + j];
+            bc[l][m + j] = c[l][j];
         }
     }
     bc
@@ -75,22 +82,31 @@ impl ReductionResult for ReductionBMFToBicliqueCover {
     }
 
     /// Map a BicliqueCover config (vertex-major) back to a BMF config (B row-major, then C row-major).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        config_bc_to_bmf(target_solution, self.m, self.n, self.k)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(config_bc_to_bmf(target_solution, self.m, self.n, self.k))
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "rows + cols",
         num_edges = "rows * cols",
         rank = "rank",
+    },
+    unavailable = {
+        left_size = "the exact target parameter is not represented by this reduction's symbolic transform",
+        right_size = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<BicliqueCover> for BMF {
     type Result = ReductionBMFToBicliqueCover;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.rows();
         let n = self.cols();
         let k = self.rank();
@@ -103,7 +119,7 @@ impl ReduceTo<BicliqueCover> for BMF {
             }
         }
         let target = BicliqueCover::new(BipartiteGraph::new(m, n, edges), k);
-        ReductionBMFToBicliqueCover { target, m, n, k }
+        Ok(ReductionBMFToBicliqueCover { target, m, n, k })
     }
 }
 
@@ -119,10 +135,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, BicliqueCover>(
                 source,
                 SolutionPair {
-                    // BMF config (B row-major, C row-major): B = [[1],[1]], C = [[1,1]]
-                    source_config: vec![1, 1, 1, 1],
-                    // BicliqueCover config (vertex-major, k=1): v0, v1 (left), v2, v3 (right) all in biclique 0
-                    target_config: vec![1, 1, 1, 1],
+                    source_config: serde_json::json!((
+                        vec![vec![true], vec![true]],
+                        vec![vec![true, true]]
+                    )),
+                    target_config: serde_json::json!(vec![vec![true, true, true, true]]),
                 },
             )
         },
diff --git a/src/rules/bmf_ilp.rs b/src/rules/bmf_ilp.rs
index 2764ef419..8944c45e5 100644
--- a/src/rules/bmf_ilp.rs
+++ b/src/rules/bmf_ilp.rs
@@ -25,23 +25,44 @@ impl ReductionResult for ReductionBMFToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Extract B (m x k) then C (k x n) — first m*k + k*n variables
-        let total = self.m * self.k + self.k * self.n;
-        target_solution[..total].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        let b = (0..self.m)
+            .map(|i| {
+                (0..self.k)
+                    .map(|r| target_solution[i * self.k + r] == 1)
+                    .collect()
+            })
+            .collect();
+        let c_offset = self.m * self.k;
+        let c = (0..self.k)
+            .map(|r| {
+                (0..self.n)
+                    .map(|j| target_solution[c_offset + r * self.n + j] == 1)
+                    .collect()
+            })
+            .collect();
+        Ok((b, c))
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "rows * rank + rank * cols + rows * rank * cols + rows * cols",
         num_constraints = "3 * rows * rank * cols + rank * rows * cols + rows * cols + rows * cols",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for BMF {
     type Result = ReductionBMFToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.rows();
         let n = self.cols();
         let k = self.rank();
@@ -75,30 +96,30 @@ impl ReduceTo<ILP<bool>> for BMF {
                 // w_{i,j} >= p_{i,r,j} for all r
                 for r in 0..k {
                     let p_idx = p_offset + i * k * n + r * n + j;
-                    constraints.push(LinearConstraint::ge(vec![(w_idx, 1.0), (p_idx, -1.0)], 0.0));
+                    constraints.push(LinearConstraint::ge(vec![(w_idx, 1), (p_idx, -1)], 0));
                 }
 
                 // w_{i,j} <= sum_r p_{i,r,j}
-                let mut w_upper_terms = vec![(w_idx, 1.0)];
+                let mut w_upper_terms = vec![(w_idx, 1)];
                 for r in 0..k {
                     let p_idx = p_offset + i * k * n + r * n + j;
-                    w_upper_terms.push((p_idx, -1.0));
+                    w_upper_terms.push((p_idx, -1));
                 }
-                constraints.push(LinearConstraint::le(w_upper_terms, 0.0));
+                constraints.push(LinearConstraint::le(w_upper_terms, 0));
 
                 // Exact factorization: w_{i,j} = A_{i,j}
-                let a_val = if self.matrix()[i][j] { 1.0 } else { 0.0 };
-                constraints.push(LinearConstraint::eq(vec![(w_idx, 1.0)], a_val));
+                let a_val = if self.matrix()[i][j] { 1 } else { 0 };
+                constraints.push(LinearConstraint::eq(vec![(w_idx, 1)], a_val));
             }
         }
 
         // Objective: minimize sum_{i,r} b_{i,r} + sum_{r,j} c_{r,j} (total factor size)
-        let mut objective: Vec<(usize, f64)> =
-            (0..m * k).map(|idx| (b_offset + idx, 1.0)).collect();
-        objective.extend((0..k * n).map(|idx| (c_offset + idx, 1.0)));
+        let mut objective: Vec<(usize, i64)> = (0..m * k).map(|idx| (b_offset + idx, 1)).collect();
+        objective.extend((0..k * n).map(|idx| (c_offset + idx, 1)));
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
-        ReductionBMFToILP { target, m, n, k }
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
+        Ok(ReductionBMFToILP { target, m, n, k })
     }
 }
 
diff --git a/src/rules/bottlenecktravelingsalesman_ilp.rs b/src/rules/bottlenecktravelingsalesman_ilp.rs
index a67dda8e2..6951b619a 100644
--- a/src/rules/bottlenecktravelingsalesman_ilp.rs
+++ b/src/rules/bottlenecktravelingsalesman_ilp.rs
@@ -1,174 +1,194 @@
-//! Reduction from BottleneckTravelingSalesman to ILP (Integer Linear Programming).
-//!
-//! Cyclic position-assignment formulation with bottleneck variable:
-//! - Binary x_{v,p}: vertex v at position p (cyclic tour)
-//! - Binary z_{e,p,dir}: linearized consecutive-pair products
-//! - Integer bottleneck variable b >= w_e * z_{e,p,dir}
-//! - Objective: minimize b
+//! Bottleneck TSP to ILP using cyclic positions and a selected maximum edge.
 
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::BottleneckTravelingSalesman;
 use crate::reduction;
-use crate::rules::ilp_helpers::mccormick_product;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::Graph;
 
-/// Result of reducing BottleneckTravelingSalesman to ILP.
-///
-/// Variable layout (ILP<i32>, all non-negative):
-/// - `x_{v,p}` at index `v * n + p`, bounded to {0,1}
-/// - `z_{e,p,dir}` at index `n^2 + 2*(e*n + p) + dir`, bounded to {0,1}
-/// - `b` (bottleneck) at index `n^2 + 2*m*n`
+/// A tour is encoded by positions and distinct directed uses of source edges.
+/// One selected maximum-weight edge carries the exact objective coefficient.
 #[derive(Debug, Clone)]
 pub struct ReductionBTSPToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_vertices: usize,
-    source_edges: Vec<(usize, usize)>,
+    num_edges: usize,
 }
 
 impl ReductionResult for ReductionBTSPToILP {
     type Source = BottleneckTravelingSalesman;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    /// Extract: decode tour from x variables, then mark selected edges.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_vertices;
-
-        // Decode tour: for each position p, find vertex v with x_{v,p} = 1
-        let mut tour = vec![0usize; n];
-        for p in 0..n {
-            for v in 0..n {
-                if target_solution[v * n + p] == 1 {
-                    tour[p] = v;
-                    break;
-                }
-            }
-        }
-
-        // Map tour to edge selection
-        let mut edge_selection = vec![0usize; self.source_edges.len()];
-        for p in 0..n {
-            let u = tour[p];
-            let v = tour[(p + 1) % n];
-            for (idx, &(a, b)) in self.source_edges.iter().enumerate() {
-                if (a == u && b == v) || (a == v && b == u) {
-                    edge_selection[idx] = 1;
-                    break;
-                }
-            }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.is_valid() {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target ILP assignment is infeasible",
+            ));
         }
+        let n = self.num_vertices;
+        Ok((0..self.num_edges)
+            .map(|edge| {
+                (0..2 * n).any(|offset| target_solution[n * n + 2 * n * edge + offset] == 1)
+            })
+            .collect())
+    }
+}
 
-        edge_selection
+impl ReductionBTSPToILP {
+    fn dimensions(
+        n: usize,
+        m: usize,
+    ) -> Result<(usize, usize, usize, usize), crate::rules::ReductionError> {
+        let overflow = || {
+            crate::rules::ReductionError::integer_overflow::<BottleneckTravelingSalesman, ILP<i64>>(
+                "sizing the cyclic edge-selection formulation",
+            )
+        };
+        let x = n.checked_mul(n).ok_or_else(overflow)?;
+        let z = n
+            .checked_mul(m)
+            .and_then(|v| v.checked_mul(2))
+            .ok_or_else(overflow)?;
+        let vars = x
+            .checked_add(z)
+            .and_then(|v| v.checked_add(m))
+            .ok_or_else(overflow)?;
+        let constraints = vars
+            .checked_add(z)
+            .and_then(|v| v.checked_add(z))
+            .and_then(|v| {
+                n.checked_add(m)
+                    .and_then(|extra| extra.checked_mul(3))
+                    .and_then(|extra| v.checked_add(extra))
+            })
+            .and_then(|v| v.checked_add(1))
+            .ok_or_else(overflow)?;
+        <BottleneckTravelingSalesman as ReduceTo<ILP<i64>>>::exact_i64(
+            vars,
+            "bounding binary constraint accumulation",
+        )?;
+        Ok((x, z, vars, constraints))
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "num_vertices^2 + 2 * num_edges * num_vertices + 1",
-        num_constraints = "2 * num_vertices + num_vertices^2 + 2 * num_edges * num_vertices + 6 * num_edges * num_vertices + num_vertices + 2 * num_edges * num_vertices",
+    transform = exact {
+        num_vars = "num_vertices^2 + 2 * num_edges * num_vertices + num_edges",
+        num_constraints = "num_vertices^2 + 6 * num_edges * num_vertices + 4 * num_edges + 3 * num_vertices + 1",
+    },
+    unavailable = {
+        num_nonzeros = "threshold comparisons depend on the ordering of edge weights",
     }
 )]
-impl ReduceTo<ILP<i32>> for BottleneckTravelingSalesman {
+impl ReduceTo<ILP<i64>> for BottleneckTravelingSalesman {
     type Result = ReductionBTSPToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
-        let graph = self.graph();
-        let edges = graph.edges();
+        let edges = self.graph().edges();
         let m = edges.len();
         let weights = self.weights();
-
-        let num_x = n * n;
-        let num_z = 2 * m * n;
-        let b_idx = num_x + num_z;
-        let num_vars = num_x + num_z + 1;
-
-        let x_idx = |v: usize, p: usize| -> usize { v * n + p };
-        let z_fwd_idx = |e: usize, p: usize| -> usize { num_x + 2 * (e * n + p) };
-        let z_rev_idx = |e: usize, p: usize| -> usize { num_x + 2 * (e * n + p) + 1 };
-
-        let mut constraints = Vec::new();
-
-        // Assignment: each vertex in exactly one position
-        for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|p| (x_idx(v, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+        if weights.len() != m {
+            return Err(
+                crate::rules::ReductionError::invalid_target::<Self, ILP<i64>>(
+                    "edge weights must match the source edges",
+                ),
+            );
         }
-
-        // Assignment: each position has exactly one vertex
-        for p in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|v| (x_idx(v, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+        let (num_x, num_z, num_vars, num_constraints) = ReductionBTSPToILP::dimensions(n, m)?;
+        let x = |vertex: usize, position: usize| vertex * n + position;
+        let z = |edge: usize, position: usize, direction: usize| {
+            num_x + 2 * (edge * n + position) + direction
+        };
+        let q = |edge: usize| num_x + num_z + edge;
+        let uses = |edge: usize| {
+            (0..n)
+                .flat_map(move |p| [(z(edge, p, 0), 1), (z(edge, p, 1), 1)])
+                .collect::<Vec<_>>()
+        };
+        let mut constraints = Vec::with_capacity(num_constraints);
+        // ILP<i64> variables are nonnegative. Check binary bounds before sums.
+        for variable in 0..num_vars {
+            constraints.push(LinearConstraint::le(vec![(variable, 1)], 1));
         }
-
-        // Binary bounds for x variables (ILP<i32> is non-negative integer)
-        for idx in 0..num_x {
-            constraints.push(LinearConstraint::le(vec![(idx, 1.0)], 1.0));
+        for vertex in 0..n {
+            constraints.push(LinearConstraint::eq(
+                (0..n).map(|p| (x(vertex, p), 1)).collect(),
+                1,
+            ));
         }
-
-        // Binary bounds for z variables
-        for idx in 0..num_z {
-            constraints.push(LinearConstraint::le(vec![(num_x + idx, 1.0)], 1.0));
+        for p in 0..n {
+            constraints.push(LinearConstraint::eq(
+                (0..n).map(|vertex| (x(vertex, p), 1)).collect(),
+                1,
+            ));
         }
-
-        // McCormick linearization for z variables (cyclic: position (p+1) mod n)
-        for (e, &(u, v)) in edges.iter().enumerate() {
+        // Choose one actual edge at each cyclic step. Parallel edges remain
+        // independent choices, and the two orientations of a loop are choices.
+        for (edge, &(u, v)) in edges.iter().enumerate() {
             for p in 0..n {
-                let p_next = (p + 1) % n;
-                // Forward: z_fwd = x_{u,p} * x_{v,p_next}
-                constraints.extend(mccormick_product(
-                    z_fwd_idx(e, p),
-                    x_idx(u, p),
-                    x_idx(v, p_next),
-                ));
-                // Reverse: z_rev = x_{v,p} * x_{u,p_next}
-                constraints.extend(mccormick_product(
-                    z_rev_idx(e, p),
-                    x_idx(v, p),
-                    x_idx(u, p_next),
-                ));
+                for (direction, a, b) in [(0, u, v), (1, v, u)] {
+                    constraints.push(LinearConstraint::le(
+                        vec![(z(edge, p, direction), 1), (x(a, p), -1)],
+                        0,
+                    ));
+                    constraints.push(LinearConstraint::le(
+                        vec![(z(edge, p, direction), 1), (x(b, (p + 1) % n), -1)],
+                        0,
+                    ));
+                }
             }
         }
-
-        // Adjacency: for each position p, exactly one edge in either direction
         for p in 0..n {
-            let mut terms = Vec::new();
-            for e in 0..m {
-                terms.push((z_fwd_idx(e, p), 1.0));
-                terms.push((z_rev_idx(e, p), 1.0));
-            }
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(
+                (0..m)
+                    .flat_map(|edge| [(z(edge, p, 0), 1), (z(edge, p, 1), 1)])
+                    .collect(),
+                1,
+            ));
         }
-
-        // Bottleneck: b >= w_e * z_{e,p,dir} for all e, p, dir
-        for (e, &w) in weights.iter().enumerate() {
-            let w_f64 = w as f64;
-            for p in 0..n {
-                constraints.push(LinearConstraint::ge(
-                    vec![(b_idx, 1.0), (z_fwd_idx(e, p), -w_f64)],
-                    0.0,
-                ));
-                constraints.push(LinearConstraint::ge(
-                    vec![(b_idx, 1.0), (z_rev_idx(e, p), -w_f64)],
-                    0.0,
-                ));
-            }
+        for edge in 0..m {
+            constraints.push(LinearConstraint::le(uses(edge), 1));
         }
-
-        // Objective: minimize b
-        let objective = vec![(b_idx, 1.0)];
-
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
-
-        ReductionBTSPToILP {
+        // The selector is a used edge whose weight dominates every used edge.
+        // We compare weights without subtraction or negation, including MIN.
+        constraints.push(LinearConstraint::eq(
+            (0..m).map(|edge| (q(edge), 1)).collect(),
+            1,
+        ));
+        for edge in 0..m {
+            let mut threshold = uses(edge);
+            threshold.extend(
+                (0..m)
+                    .filter(|&other| weights[other] >= weights[edge])
+                    .map(|other| (q(other), -1)),
+            );
+            constraints.push(LinearConstraint::le(threshold, 0));
+            let mut selected = vec![(q(edge), 1)];
+            selected.extend(uses(edge).into_iter().map(|(var, _)| (var, -1)));
+            constraints.push(LinearConstraint::le(selected, 0));
+        }
+        let objective = weights
+            .into_iter()
+            .enumerate()
+            .map(|(edge, weight)| (q(edge), weight))
+            .collect();
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionBTSPToILP {
             target,
             num_vertices: n,
-            source_edges: edges,
-        }
+            num_edges: m,
+        })
     }
 }
 
@@ -182,7 +202,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 crate::topology::SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (3, 0)]),
                 vec![1, 2, 3, 4],
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/boundedcomponentspanningforest_ilp.rs b/src/rules/boundedcomponentspanningforest_ilp.rs
index 7688ddff6..96c32f915 100644
--- a/src/rules/boundedcomponentspanningforest_ilp.rs
+++ b/src/rules/boundedcomponentspanningforest_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from BoundedComponentSpanningForest to ILP<i32>.
+//! Reduction from BoundedComponentSpanningForest to `ILP<i64>`.
 //!
 //! Assign every vertex to one of K components, bound weight, certify
 //! connectivity inside each used component via flow.
@@ -7,48 +7,49 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::BoundedComponentSpanningForest;
 use crate::reduction;
+use crate::rules::ilp_helpers::one_hot_decode_rows;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
 
 #[derive(Debug, Clone)]
 pub struct ReductionBCSFToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     n: usize,
     k: usize,
 }
 
 impl ReductionResult for ReductionBCSFToILP {
-    type Source = BoundedComponentSpanningForest<SimpleGraph, i32>;
-    type Target = ILP<i32>;
+    type Source = BoundedComponentSpanningForest<SimpleGraph, i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// One-hot decode: for each vertex v, output the unique component c with x_{v,c} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.n;
-        let k = self.k;
-        (0..n)
-            .map(|v| {
-                (0..k)
-                    .find(|&c| target_solution[v * k + c] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        one_hot_decode_rows(target_solution, self.n, self.k, 0)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "3 * num_vertices * max_components + 2 * max_components + 2 * num_edges * max_components",
-        num_constraints = "num_vertices + max_components + max_components + 2 * max_components + num_vertices * max_components + 4 * num_vertices * max_components + 4 * num_edges * max_components + num_vertices * max_components",
+        num_constraints = "num_vertices + 5 * max_components + 6 * num_vertices * max_components + 6 * num_edges * max_components",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for BoundedComponentSpanningForest<SimpleGraph, i32> {
+impl ReduceTo<ILP<i64>> for BoundedComponentSpanningForest<SimpleGraph, i64> {
     type Result = ReductionBCSFToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let edges = self.graph().edges();
         let m = edges.len();
@@ -63,57 +64,55 @@ impl ReduceTo<ILP<i32>> for BoundedComponentSpanningForest<SimpleGraph, i32> {
             |i: usize, eta: usize, c: usize| -> usize { 3 * n * k + 2 * k + (i * 2 + eta) * k + c };
 
         let num_vars = 3 * n * k + 2 * k + 2 * m * k;
-        let n_f64 = n as f64;
+        let n_i64 = Self::exact_i64(n, "encoding the vertex count")?;
         let mut constraints = Vec::new();
+        let weights = self.weights();
+        let max_weight = *self.max_weight();
 
         // 1) Assignment: sum_c x_{v,c} = 1 for each vertex v
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..k).map(|c| (x_idx(v, c), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..k).map(|c| (x_idx(v, c), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 2) Weight bound: sum_v w_v * x_{v,c} <= B for each component c
         for c in 0..k {
-            let terms: Vec<(usize, f64)> = self
-                .weights()
+            let terms: Vec<(usize, i64)> = weights
                 .iter()
                 .enumerate()
-                .map(|(v, &w)| (x_idx(v, c), w as f64))
+                .map(|(vertex, &weight)| (x_idx(vertex, c), weight))
                 .collect();
-            constraints.push(LinearConstraint::le(terms, *self.max_weight() as f64));
+            constraints.push(LinearConstraint::le(terms, max_weight));
         }
 
         // 3) Size: s_c = sum_v x_{v,c}
         for c in 0..k {
-            let mut terms: Vec<(usize, f64)> = vec![(s_idx(c), -1.0)];
+            let mut terms: Vec<(usize, i64)> = vec![(s_idx(c), -1)];
             for v in 0..n {
-                terms.push((x_idx(v, c), 1.0));
+                terms.push((x_idx(v, c), 1));
             }
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // 4) Nonempty indicator: u_c <= s_c and s_c <= n * u_c
         for c in 0..k {
+            constraints.push(LinearConstraint::le(vec![(u_idx(c), 1), (s_idx(c), -1)], 0));
             constraints.push(LinearConstraint::le(
-                vec![(u_idx(c), 1.0), (s_idx(c), -1.0)],
-                0.0,
-            ));
-            constraints.push(LinearConstraint::le(
-                vec![(s_idx(c), 1.0), (u_idx(c), -n_f64)],
-                0.0,
+                vec![(s_idx(c), 1), (u_idx(c), -n_i64)],
+                0,
             ));
         }
 
         // 5) Root selection: sum_v r_{v,c} = u_c and r_{v,c} <= x_{v,c}
         for c in 0..k {
-            let mut terms: Vec<(usize, f64)> = (0..n).map(|v| (r_idx(v, c), 1.0)).collect();
-            terms.push((u_idx(c), -1.0));
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            let mut terms: Vec<(usize, i64)> = (0..n).map(|v| (r_idx(v, c), 1)).collect();
+            terms.push((u_idx(c), -1));
+            constraints.push(LinearConstraint::eq(terms, 0));
 
             for v in 0..n {
                 constraints.push(LinearConstraint::le(
-                    vec![(r_idx(v, c), 1.0), (x_idx(v, c), -1.0)],
-                    0.0,
+                    vec![(r_idx(v, c), 1), (x_idx(v, c), -1)],
+                    0,
                 ));
             }
         }
@@ -123,37 +122,37 @@ impl ReduceTo<ILP<i32>> for BoundedComponentSpanningForest<SimpleGraph, i32> {
             for c in 0..k {
                 // b <= s_c
                 constraints.push(LinearConstraint::le(
-                    vec![(b_idx(v, c), 1.0), (s_idx(c), -1.0)],
-                    0.0,
+                    vec![(b_idx(v, c), 1), (s_idx(c), -1)],
+                    0,
                 ));
                 // b <= n * r
                 constraints.push(LinearConstraint::le(
-                    vec![(b_idx(v, c), 1.0), (r_idx(v, c), -n_f64)],
-                    0.0,
+                    vec![(b_idx(v, c), 1), (r_idx(v, c), -n_i64)],
+                    0,
                 ));
                 // b >= s - n*(1-r) => b - s - n*r >= -n
                 constraints.push(LinearConstraint::ge(
-                    vec![(b_idx(v, c), 1.0), (s_idx(c), -1.0), (r_idx(v, c), -n_f64)],
-                    -n_f64,
+                    vec![(b_idx(v, c), 1), (s_idx(c), -1), (r_idx(v, c), -n_i64)],
+                    -n_i64,
                 ));
                 // b >= 0
-                constraints.push(LinearConstraint::ge(vec![(b_idx(v, c), 1.0)], 0.0));
+                constraints.push(LinearConstraint::ge(vec![(b_idx(v, c), 1)], 0));
             }
         }
 
         // 7) Flow capacity: 0 <= f_{i,eta,c} <= (n-1)*x_{u_i,c} and <= (n-1)*x_{v_i,c}
-        let cap = (n as f64) - 1.0;
+        let cap = n_i64 - 1;
         for (i, &(u_e, v_e)) in edges.iter().enumerate() {
             for eta in 0..2usize {
                 for c in 0..k {
-                    constraints.push(LinearConstraint::ge(vec![(f_idx(i, eta, c), 1.0)], 0.0));
+                    constraints.push(LinearConstraint::ge(vec![(f_idx(i, eta, c), 1)], 0));
                     constraints.push(LinearConstraint::le(
-                        vec![(f_idx(i, eta, c), 1.0), (x_idx(u_e, c), -cap)],
-                        0.0,
+                        vec![(f_idx(i, eta, c), 1), (x_idx(u_e, c), -cap)],
+                        0,
                     ));
                     constraints.push(LinearConstraint::le(
-                        vec![(f_idx(i, eta, c), 1.0), (x_idx(v_e, c), -cap)],
-                        0.0,
+                        vec![(f_idx(i, eta, c), 1), (x_idx(v_e, c), -cap)],
+                        0,
                     ));
                 }
             }
@@ -162,27 +161,28 @@ impl ReduceTo<ILP<i32>> for BoundedComponentSpanningForest<SimpleGraph, i32> {
         // 8) Flow conservation: net_flow(v,c) = b_{v,c} - x_{v,c}
         for v in 0..n {
             for c in 0..k {
-                let mut terms: Vec<(usize, f64)> = Vec::new();
+                let mut terms: Vec<(usize, i64)> = Vec::new();
 
                 for (i, &(u_e, v_e)) in edges.iter().enumerate() {
                     if u_e == v {
-                        terms.push((f_idx(i, 0, c), 1.0));
-                        terms.push((f_idx(i, 1, c), -1.0));
+                        terms.push((f_idx(i, 0, c), 1));
+                        terms.push((f_idx(i, 1, c), -1));
                     }
                     if v_e == v {
-                        terms.push((f_idx(i, 0, c), -1.0));
-                        terms.push((f_idx(i, 1, c), 1.0));
+                        terms.push((f_idx(i, 0, c), -1));
+                        terms.push((f_idx(i, 1, c), 1));
                     }
                 }
 
-                terms.push((b_idx(v, c), -1.0));
-                terms.push((x_idx(v, c), 1.0));
-                constraints.push(LinearConstraint::eq(terms, 0.0));
+                terms.push((b_idx(v, c), -1));
+                terms.push((x_idx(v, c), 1));
+                constraints.push(LinearConstraint::eq(terms, 0));
             }
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionBCSFToILP { target, n, k }
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionBCSFToILP { target, n, k })
     }
 }
 
@@ -199,16 +199,17 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 4,
             );
             let reduction: ReductionBCSFToILP =
-                crate::rules::ReduceTo::<ILP<i32>>::reduce_to(&source);
+                crate::rules::ReduceTo::<ILP<i64>>::reduce_to(&source)
+                    .expect("reduction should succeed");
             let ilp_sol = crate::solvers::ILPSolver::new()
                 .solve(reduction.target_problem())
                 .expect("ILP should be solvable");
-            let extracted = reduction.extract_solution(&ilp_sol);
-            crate::example_db::specs::rule_example_with_witness::<_, ILP<i32>>(
+            let extracted = reduction.extract_solution(&ilp_sol).unwrap();
+            crate::example_db::specs::rule_example_with_witness::<_, ILP<i64>>(
                 source,
                 SolutionPair {
-                    source_config: extracted,
-                    target_config: ilp_sol,
+                    source_config: serde_json::json!(extracted),
+                    target_config: serde_json::json!(ilp_sol),
                 },
             )
         },
diff --git a/src/rules/capacityassignment_ilp.rs b/src/rules/capacityassignment_ilp.rs
index 798646c85..1b348b59a 100644
--- a/src/rules/capacityassignment_ilp.rs
+++ b/src/rules/capacityassignment_ilp.rs
@@ -34,68 +34,76 @@ impl ReductionResult for ReductionCAToILP {
     }
 
     /// Extract solution: for each link l, find the unique capacity c where x_{l,c} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_capacities = self.num_capacities;
-        (0..self.num_links)
-            .map(|l| {
-                (0..num_capacities)
-                    .find(|&c| target_solution[l * num_capacities + c] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_links,
+            self.num_capacities,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_links * num_capacities",
         num_constraints = "num_links + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for CapacityAssignment {
     type Result = ReductionCAToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_links = self.num_links();
         let num_capacities = self.num_capacities();
         let num_vars = num_links * num_capacities;
+        let delay = self.delay();
+        let cost = self.cost();
+        let delay_budget = self.delay_budget();
 
         let mut constraints = Vec::with_capacity(num_links + 1);
 
         // Assignment constraints: for each link l, Σ_c x_{l,c} = 1
         for l in 0..num_links {
-            let terms: Vec<(usize, f64)> = (0..num_capacities)
-                .map(|c| (l * num_capacities + c, 1.0))
+            let terms: Vec<(usize, i64)> = (0..num_capacities)
+                .map(|c| (l * num_capacities + c, 1))
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Delay budget constraint: Σ_{l,c} delay[l][c] * x_{l,c} ≤ delay_budget
-        let delay_terms: Vec<(usize, f64)> = (0..num_links)
-            .flat_map(|l| {
-                (0..num_capacities)
-                    .map(move |c| (l * num_capacities + c, self.delay()[l][c] as f64))
-            })
-            .collect();
-        constraints.push(LinearConstraint::le(
-            delay_terms,
-            self.delay_budget() as f64,
-        ));
+        let mut delay_terms = Vec::with_capacity(num_vars);
+        for (link, row) in delay.iter().enumerate() {
+            for (capacity, &value) in row.iter().enumerate() {
+                delay_terms.push((link * num_capacities + capacity, value));
+            }
+        }
+        constraints.push(LinearConstraint::le(delay_terms, delay_budget));
 
         // Objective: minimize total cost
-        let objective: Vec<(usize, f64)> = (0..num_links)
-            .flat_map(|l| {
-                (0..num_capacities).map(move |c| (l * num_capacities + c, self.cost()[l][c] as f64))
-            })
-            .collect();
+        let mut objective = Vec::with_capacity(num_vars);
+        for (link, row) in cost.iter().enumerate() {
+            for (capacity, &value) in row.iter().enumerate() {
+                objective.push((link * num_capacities + capacity, value));
+            }
+        }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionCAToILP {
+        Ok(ReductionCAToILP {
             target,
             num_links,
             num_capacities,
-        }
+        })
     }
 }
 
diff --git a/src/rules/circuit_ilp.rs b/src/rules/circuit_ilp.rs
index fcd26f97a..6fa63d452 100644
--- a/src/rules/circuit_ilp.rs
+++ b/src/rules/circuit_ilp.rs
@@ -36,11 +36,25 @@ impl ReductionResult for ReductionCircuitToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.source_variables
-            .iter()
-            .map(|name| target_solution[self.variable_map[name]])
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        if crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?
+            .value
+            .is_none()
+        {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target ILP assignment is infeasible",
+            ));
+        }
+
+        Ok({
+            self.source_variables
+                .iter()
+                .map(|name| target_solution[self.variable_map[name]] == 1)
+                .collect()
+        })
     }
 }
 
@@ -61,144 +75,155 @@ impl ILPBuilder {
     }
 
     /// Get or create a variable index for a named circuit variable.
-    fn get_or_create_var(&mut self, name: &str) -> usize {
+    fn get_or_create_var(&mut self, name: &str) -> Result<usize, crate::rules::ReductionError> {
         if let Some(&idx) = self.variable_map.get(name) {
-            idx
+            Ok(idx)
         } else {
-            let idx = self.num_vars;
+            let idx = self.alloc_aux()?;
             self.variable_map.insert(name.to_string(), idx);
-            self.num_vars += 1;
-            idx
+            Ok(idx)
         }
     }
 
     /// Allocate an anonymous auxiliary variable.
-    fn alloc_aux(&mut self) -> usize {
+    fn alloc_aux(&mut self) -> Result<usize, crate::rules::ReductionError> {
         let idx = self.num_vars;
-        self.num_vars += 1;
-        idx
+        self.num_vars = self.num_vars.checked_add(1).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<CircuitSAT, ILP<bool>>(
+                "allocating a circuit ILP variable",
+            )
+        })?;
+        Ok(idx)
     }
 
     /// Recursively process a BooleanExpr, returning the ILP variable index
     /// that holds the expression's value.
-    fn process_expr(&mut self, expr: &BooleanExpr) -> usize {
-        match &expr.op {
-            BooleanOp::Var(name) => self.get_or_create_var(name),
+    fn process_expr(&mut self, expr: &BooleanExpr) -> Result<usize, crate::rules::ReductionError> {
+        Ok(match &expr.op {
+            BooleanOp::Var(name) => self.get_or_create_var(name)?,
             BooleanOp::Const(value) => {
-                let c = self.alloc_aux();
-                let v = if *value { 1.0 } else { 0.0 };
-                self.constraints
-                    .push(LinearConstraint::eq(vec![(c, 1.0)], v));
+                let c = self.alloc_aux()?;
+                let v = if *value { 1 } else { 0 };
+                self.constraints.push(LinearConstraint::eq(vec![(c, 1)], v));
                 c
             }
             BooleanOp::Not(inner) => {
-                let a = self.process_expr(inner);
-                let c = self.alloc_aux();
+                let a = self.process_expr(inner)?;
+                let c = self.alloc_aux()?;
                 // c + a = 1
                 self.constraints
-                    .push(LinearConstraint::eq(vec![(c, 1.0), (a, 1.0)], 1.0));
+                    .push(LinearConstraint::eq(vec![(c, 1), (a, 1)], 1));
                 c
             }
             BooleanOp::And(args) => {
-                let inputs: Vec<usize> = args.iter().map(|a| self.process_expr(a)).collect();
-                let c = self.alloc_aux();
-                let k = inputs.len() as f64;
+                let inputs: Vec<usize> = args
+                    .iter()
+                    .map(|arg| self.process_expr(arg))
+                    .collect::<Result<_, _>>()?;
+                let c = self.alloc_aux()?;
+                let k = <CircuitSAT as ReduceTo<ILP<bool>>>::exact_i64(
+                    inputs.len(),
+                    "encoding a circuit gate arity",
+                )?;
                 // c ≤ a_i for all i
                 for &a_i in &inputs {
                     self.constraints
-                        .push(LinearConstraint::le(vec![(c, 1.0), (a_i, -1.0)], 0.0));
+                        .push(LinearConstraint::le(vec![(c, 1), (a_i, -1)], 0));
                 }
                 // c ≥ Σa_i - (k - 1)
-                let mut terms: Vec<(usize, f64)> = vec![(c, 1.0)];
+                let mut terms: Vec<(usize, i64)> = vec![(c, 1)];
                 for &a_i in &inputs {
-                    terms.push((a_i, -1.0));
+                    terms.push((a_i, -1));
                 }
-                self.constraints
-                    .push(LinearConstraint::ge(terms, -(k - 1.0)));
+                self.constraints.push(LinearConstraint::ge(terms, 1 - k));
                 c
             }
             BooleanOp::Or(args) => {
-                let inputs: Vec<usize> = args.iter().map(|a| self.process_expr(a)).collect();
-                let c = self.alloc_aux();
+                let inputs: Vec<usize> = args
+                    .iter()
+                    .map(|arg| self.process_expr(arg))
+                    .collect::<Result<_, _>>()?;
+                let c = self.alloc_aux()?;
                 // c ≥ a_i for all i
                 for &a_i in &inputs {
                     self.constraints
-                        .push(LinearConstraint::ge(vec![(c, 1.0), (a_i, -1.0)], 0.0));
+                        .push(LinearConstraint::ge(vec![(c, 1), (a_i, -1)], 0));
                 }
                 // c ≤ Σa_i
-                let mut terms: Vec<(usize, f64)> = vec![(c, 1.0)];
+                let mut terms: Vec<(usize, i64)> = vec![(c, 1)];
                 for &a_i in &inputs {
-                    terms.push((a_i, -1.0));
+                    terms.push((a_i, -1));
                 }
-                self.constraints.push(LinearConstraint::le(terms, 0.0));
+                self.constraints.push(LinearConstraint::le(terms, 0));
                 c
             }
             BooleanOp::Xor(args) => {
                 // Chain pairwise: XOR(a1, a2, a3) = XOR(XOR(a1, a2), a3)
-                let inputs: Vec<usize> = args.iter().map(|a| self.process_expr(a)).collect();
-                assert!(!inputs.is_empty());
-                let mut result = inputs[0];
-                for &next in &inputs[1..] {
-                    let c = self.alloc_aux();
+                let inputs: Vec<usize> = args
+                    .iter()
+                    .map(|arg| self.process_expr(arg))
+                    .collect::<Result<_, _>>()?;
+                let mut inputs = inputs.into_iter();
+                let mut result = match inputs.next() {
+                    Some(first) => first,
+                    // False is the identity of the Boolean XOR fold.
+                    None => self.process_expr(&BooleanExpr::constant(false))?,
+                };
+                for next in inputs {
+                    let c = self.alloc_aux()?;
                     let a = result;
                     let b = next;
                     // c ≤ a + b
-                    self.constraints.push(LinearConstraint::le(
-                        vec![(c, 1.0), (a, -1.0), (b, -1.0)],
-                        0.0,
-                    ));
+                    self.constraints
+                        .push(LinearConstraint::le(vec![(c, 1), (a, -1), (b, -1)], 0));
                     // c ≥ a - b
-                    self.constraints.push(LinearConstraint::ge(
-                        vec![(c, 1.0), (a, -1.0), (b, 1.0)],
-                        0.0,
-                    ));
+                    self.constraints
+                        .push(LinearConstraint::ge(vec![(c, 1), (a, -1), (b, 1)], 0));
                     // c ≥ b - a
-                    self.constraints.push(LinearConstraint::ge(
-                        vec![(c, 1.0), (a, 1.0), (b, -1.0)],
-                        0.0,
-                    ));
+                    self.constraints
+                        .push(LinearConstraint::ge(vec![(c, 1), (a, 1), (b, -1)], 0));
                     // c ≤ 2 - a - b
-                    self.constraints.push(LinearConstraint::le(
-                        vec![(c, 1.0), (a, 1.0), (b, 1.0)],
-                        2.0,
-                    ));
+                    self.constraints
+                        .push(LinearConstraint::le(vec![(c, 1), (a, 1), (b, 1)], 2));
                     result = c;
                 }
                 result
             }
-        }
+        })
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "num_variables + num_assignments",
-        num_constraints = "num_variables + num_assignments",
+    transform = upper_bound {
+        num_vars = "num_variables + 2 * num_expression_nodes",
+        num_constraints = "5 * num_expression_nodes + num_assignment_outputs",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for CircuitSAT {
     type Result = ReductionCircuitToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let mut builder = ILPBuilder::new();
 
         // Pre-register all circuit variables to preserve ordering
         for name in self.variable_names() {
-            builder.get_or_create_var(name);
+            builder.get_or_create_var(name)?;
         }
 
         // Process each assignment
         for assignment in &self.circuit().assignments {
-            let expr_var = builder.process_expr(&assignment.expr);
+            let expr_var = builder.process_expr(&assignment.expr)?;
             // Constrain each output to equal the expression result
             for output_name in &assignment.outputs {
-                let out_var = builder.get_or_create_var(output_name);
+                let out_var = builder.get_or_create_var(output_name)?;
                 if out_var != expr_var {
                     // out = expr_var
-                    builder.constraints.push(LinearConstraint::eq(
-                        vec![(out_var, 1.0), (expr_var, -1.0)],
-                        0.0,
-                    ));
+                    builder
+                        .constraints
+                        .push(LinearConstraint::eq(vec![(out_var, 1), (expr_var, -1)], 0));
                 }
             }
         }
@@ -210,13 +235,14 @@ impl ReduceTo<ILP<bool>> for CircuitSAT {
             builder.constraints,
             objective,
             ObjectiveSense::Minimize,
-        );
+        )
+        .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionCircuitToILP {
+        Ok(ReductionCircuitToILP {
             target,
             source_variables: self.variable_names().to_vec(),
             variable_map: builder.variable_map,
-        }
+        })
     }
 }
 
@@ -260,8 +286,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             >(
                 full_adder_circuit_sat(),
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 0, 0, 0, 0, 0],
-                    target_config: vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                    source_config: serde_json::json!(vec![
+                        false, false, false, false, false, false, false, false
+                    ]),
+                    target_config: serde_json::json!(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
                 },
             )
         },
diff --git a/src/rules/circuit_sat.rs b/src/rules/circuit_sat.rs
index b0cbb6760..34811903a 100644
--- a/src/rules/circuit_sat.rs
+++ b/src/rules/circuit_sat.rs
@@ -4,6 +4,7 @@ use crate::models::formula::{
     Assignment, BooleanExpr, BooleanOp, CNFClause, CircuitSAT, Satisfiability,
 };
 use crate::reduction;
+use crate::rules::sat_helpers::SatVariableAllocator;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use std::collections::HashMap;
 
@@ -20,7 +21,7 @@ enum NormalizedExpr {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum EncodedTerm {
     Const(bool),
-    Var(i32),
+    Var(i64),
 }
 
 #[derive(Debug, Clone)]
@@ -31,23 +32,28 @@ struct TseitinEncoding {
 
 #[derive(Debug)]
 struct TseitinEncoder {
-    source_var_ids: HashMap<String, i32>,
+    source_var_ids: HashMap<String, i64>,
     clauses: Vec<CNFClause>,
-    next_var: i32,
+    variables: SatVariableAllocator,
 }
 
 impl TseitinEncoder {
     fn new(source: &CircuitSAT) -> Self {
+        let mut variables = SatVariableAllocator::new("CircuitSAT -> Satisfiability", 0)
+            .unwrap_or_else(|message| panic!("{message}"));
+        let source_ids = variables
+            .allocate_many(source.num_variables())
+            .unwrap_or_else(|message| panic!("{message}"));
         let source_var_ids = source
             .variable_names()
             .iter()
-            .enumerate()
-            .map(|(index, name)| (name.clone(), index as i32 + 1))
+            .zip(source_ids)
+            .map(|(name, variable)| (name.clone(), variable))
             .collect();
         Self {
             source_var_ids,
             clauses: Vec::new(),
-            next_var: source.num_variables() as i32 + 1,
+            variables,
         }
     }
 
@@ -57,7 +63,7 @@ impl TseitinEncoder {
         }
 
         TseitinEncoding {
-            num_vars: (self.next_var - 1) as usize,
+            num_vars: self.variables.num_vars(),
             clauses: self.clauses,
         }
     }
@@ -135,7 +141,7 @@ impl TseitinEncoder {
         }
     }
 
-    fn expect_var(&self, term: EncodedTerm, context: &str) -> i32 {
+    fn expect_var(&self, term: EncodedTerm, context: &str) -> i64 {
         match term {
             EncodedTerm::Var(var) => var,
             EncodedTerm::Const(_) => {
@@ -144,25 +150,25 @@ impl TseitinEncoder {
         }
     }
 
-    fn source_var(&self, name: &str) -> i32 {
+    fn source_var(&self, name: &str) -> i64 {
         *self
             .source_var_ids
             .get(name)
             .unwrap_or_else(|| panic!("CircuitSAT variable {name:?} missing from source ordering"))
     }
 
-    fn allocate_auxiliary_var(&mut self) -> i32 {
-        let var = self.next_var;
-        self.next_var += 1;
-        var
+    fn allocate_auxiliary_var(&mut self) -> i64 {
+        self.variables
+            .allocate()
+            .unwrap_or_else(|message| panic!("{message}"))
     }
 
-    fn push_equivalence(&mut self, left: i32, right: i32) {
+    fn push_equivalence(&mut self, left: i64, right: i64) {
         self.push_clause(vec![-left, right]);
         self.push_clause(vec![left, -right]);
     }
 
-    fn push_clause(&mut self, literals: Vec<i32>) {
+    fn push_clause(&mut self, literals: Vec<i64>) {
         self.clauses.push(CNFClause::new(literals));
     }
 }
@@ -268,16 +274,6 @@ fn build_tseitin_encoding(source: &CircuitSAT) -> TseitinEncoding {
     TseitinEncoder::new(source).encode_problem(source)
 }
 
-impl CircuitSAT {
-    pub fn tseitin_num_vars(&self) -> usize {
-        build_tseitin_encoding(self).num_vars
-    }
-
-    pub fn tseitin_num_clauses(&self) -> usize {
-        build_tseitin_encoding(self).clauses.len()
-    }
-}
-
 /// Result of reducing CircuitSAT to SAT.
 #[derive(Debug, Clone)]
 pub struct ReductionCircuitSATToSAT {
@@ -293,30 +289,32 @@ impl ReductionResult for ReductionCircuitSATToSAT {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution
-            .iter()
-            .take(self.source_var_count)
-            .copied()
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.source_var_count].to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "tseitin_num_vars",
-        num_clauses = "tseitin_num_clauses",
-    }
+    transform = unavailable {
+        num_vars = "the exact Tseitin variable count is specific to this reduction and is not a CircuitSAT parameter",
+        num_clauses = "the exact Tseitin clause count is specific to this reduction and is not a CircuitSAT parameter",
+            num_literals = "the exact target parameter is not represented by this reduction's symbolic transform",
+}
 )]
 impl ReduceTo<Satisfiability> for CircuitSAT {
     type Result = ReductionCircuitSATToSAT;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let encoding = build_tseitin_encoding(self);
-        ReductionCircuitSATToSAT {
+        Ok(ReductionCircuitSATToSAT {
             target: Satisfiability::new(encoding.num_vars, encoding.clauses),
             source_var_count: self.num_variables(),
-        }
+        })
     }
 }
 
@@ -345,20 +343,24 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "circuitsat_to_satisfiability",
         build: || {
             let source = issue_example_source();
-            let source_config = vec![1, 1, 1, 0, 1];
-            let reduction = ReduceTo::<Satisfiability>::reduce_to(&source);
+            let source_config = vec![true, true, true, false, true];
+            let reduction =
+                ReduceTo::<Satisfiability>::reduce_to(&source).expect("reduction should succeed");
             let target_config = BruteForce::new()
                 .find_all_witnesses(reduction.target_problem())
+                .expect("canonical target evaluation must succeed")
                 .into_iter()
-                .find(|candidate| reduction.extract_solution(candidate) == source_config)
+                .find(|candidate| reduction.extract_solution(candidate).unwrap() == source_config)
                 .expect("canonical CircuitSAT -> Satisfiability example must be satisfiable");
 
             crate::example_db::specs::assemble_rule_example(
                 &source,
                 reduction.target_problem(),
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/circuit_spinglass.rs b/src/rules/circuit_spinglass.rs
index da080d921..92ee614d4 100644
--- a/src/rules/circuit_spinglass.rs
+++ b/src/rules/circuit_spinglass.rs
@@ -11,10 +11,14 @@ use crate::models::graph::SpinGlass;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::SimpleGraph;
+use crate::types::WeightElement;
 use num_traits::Zero;
 use std::collections::HashMap;
+#[cfg(test)]
 use std::ops::AddAssign;
 
+type BuiltSpinGlass = (SpinGlass<SimpleGraph, i64>, HashMap<String, usize>, i64);
+
 /// A logic gadget represented as a SpinGlass problem.
 ///
 /// Each gadget encodes a logic gate where the ground states of the
@@ -71,7 +75,7 @@ impl<W: Clone + Default> LogicGadget<W> {
 ///       So h values are negated to produce equivalent ground states.
 pub fn and_gadget<W>() -> LogicGadget<W>
 where
-    W: Clone + Default + From<i32>,
+    W: WeightElement + From<i64>,
 {
     let interactions = vec![
         ((0, 1), W::from(1)),
@@ -80,7 +84,11 @@ where
     ];
     let fields = vec![W::from(-1), W::from(-1), W::from(2)];
     let sg = SpinGlass::new(3, interactions, fields);
-    LogicGadget::new(sg, vec![0, 1], vec![2])
+    LogicGadget::new(
+        sg.expect("static AND gadget must be valid"),
+        vec![0, 1],
+        vec![2],
+    )
 }
 
 /// Create an OR gate gadget.
@@ -93,7 +101,7 @@ where
 /// h = [1, 1, -2] (negated from Julia to account for different spin convention)
 pub fn or_gadget<W>() -> LogicGadget<W>
 where
-    W: Clone + Default + From<i32>,
+    W: WeightElement + From<i64>,
 {
     let interactions = vec![
         ((0, 1), W::from(1)),
@@ -102,7 +110,11 @@ where
     ];
     let fields = vec![W::from(1), W::from(1), W::from(-2)];
     let sg = SpinGlass::new(3, interactions, fields);
-    LogicGadget::new(sg, vec![0, 1], vec![2])
+    LogicGadget::new(
+        sg.expect("static OR gadget must be valid"),
+        vec![0, 1],
+        vec![2],
+    )
 }
 
 /// Create a NOT gate gadget.
@@ -114,12 +126,16 @@ where
 /// h = \[0, 0\]
 pub fn not_gadget<W>() -> LogicGadget<W>
 where
-    W: Clone + Default + From<i32> + Zero,
+    W: WeightElement + From<i64> + Zero,
 {
     let interactions = vec![((0, 1), W::from(1))];
     let fields = vec![W::zero(), W::zero()];
     let sg = SpinGlass::new(2, interactions, fields);
-    LogicGadget::new(sg, vec![0], vec![1])
+    LogicGadget::new(
+        sg.expect("static NOT gadget must be valid"),
+        vec![0],
+        vec![1],
+    )
 }
 
 /// Create an XOR gate gadget.
@@ -131,7 +147,7 @@ where
 /// h = [-1, -1, 1, 2] (negated from Julia to account for different spin convention)
 pub fn xor_gadget<W>() -> LogicGadget<W>
 where
-    W: Clone + Default + From<i32>,
+    W: WeightElement + From<i64>,
 {
     let interactions = vec![
         ((0, 1), W::from(1)),
@@ -146,7 +162,11 @@ where
     // Note: output is at index 2 (not 3) according to Julia code
     // The Julia code has: LogicGadget(sg, [1, 2], [3]) which is 1-indexed
     // In 0-indexed: inputs [0, 1], output [2]
-    LogicGadget::new(sg, vec![0, 1], vec![2])
+    LogicGadget::new(
+        sg.expect("static XOR gadget must be valid"),
+        vec![0, 1],
+        vec![2],
+    )
 }
 
 /// Create a SET0 gadget (constant false).
@@ -155,12 +175,16 @@ where
 /// h = \[1\] (negated from Julia's \[-1\] to account for different spin convention)
 pub fn set0_gadget<W>() -> LogicGadget<W>
 where
-    W: Clone + Default + From<i32>,
+    W: WeightElement + From<i64>,
 {
     let interactions = vec![];
     let fields = vec![W::from(1)];
     let sg = SpinGlass::new(1, interactions, fields);
-    LogicGadget::new(sg, vec![], vec![0])
+    LogicGadget::new(
+        sg.expect("static SET0 gadget must be valid"),
+        vec![],
+        vec![0],
+    )
 }
 
 /// Create a SET1 gadget (constant true).
@@ -169,93 +193,138 @@ where
 /// h = \[-1\] (negated from Julia's \[1\] to account for different spin convention)
 pub fn set1_gadget<W>() -> LogicGadget<W>
 where
-    W: Clone + Default + From<i32>,
+    W: WeightElement + From<i64>,
 {
     let interactions = vec![];
     let fields = vec![W::from(-1)];
     let sg = SpinGlass::new(1, interactions, fields);
-    LogicGadget::new(sg, vec![], vec![0])
+    LogicGadget::new(
+        sg.expect("static SET1 gadget must be valid"),
+        vec![],
+        vec![0],
+    )
 }
 
 /// Result of reducing CircuitSAT to SpinGlass.
 #[derive(Debug, Clone)]
 pub struct ReductionCircuitToSG {
     /// The target SpinGlass problem.
-    target: SpinGlass<SimpleGraph, i32>,
+    target: SpinGlass<SimpleGraph, i64>,
     /// Mapping from source variable names to spin indices.
     variable_map: HashMap<String, usize>,
     /// Source variable names in order.
     source_variables: Vec<String>,
+    /// Sum of the individual gate and equality ground energies.
+    zero_penalty_energy: i64,
 }
 
 impl ReductionResult for ReductionCircuitToSG {
     type Source = CircuitSAT;
-    type Target = SpinGlass<SimpleGraph, i32>;
+    type Target = SpinGlass<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.source_variables
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "SpinGlass energy does not meet the circuit zero-penalty threshold",
+            ));
+        }
+
+        Ok(self
+            .source_variables
             .iter()
-            .map(|var| {
-                self.variable_map
-                    .get(var)
-                    .and_then(|&idx| target_solution.get(idx).copied())
-                    .unwrap_or(0)
-            })
-            .collect()
+            .map(|variable| target_solution[self.variable_map[variable]] == 1)
+            .collect())
+    }
+}
+
+impl crate::rules::AggregateReductionResult for ReductionCircuitToSG {
+    type Source = CircuitSAT;
+    type Target = SpinGlass<SimpleGraph, i64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, value: crate::types::Min<i64>) -> crate::types::Or {
+        crate::types::Or(value.0 == Some(self.zero_penalty_energy))
     }
 }
 
 /// Builder for constructing the combined SpinGlass from circuit gadgets.
-struct SpinGlassBuilder<W> {
+struct SpinGlassBuilder {
     /// Current number of spins.
     num_spins: usize,
     /// Accumulated interactions.
-    interactions: HashMap<(usize, usize), W>,
+    interactions: HashMap<(usize, usize), i64>,
     /// Accumulated fields.
-    fields: Vec<W>,
+    fields: Vec<i64>,
     /// Variable name to spin index mapping.
     variable_map: HashMap<String, usize>,
+    zero_penalty_energy: i64,
 }
 
-impl<W> SpinGlassBuilder<W>
-where
-    W: Clone + Default + Zero + AddAssign + From<i32>,
-{
+impl SpinGlassBuilder {
     fn new() -> Self {
         Self {
             num_spins: 0,
             interactions: HashMap::new(),
             fields: Vec::new(),
             variable_map: HashMap::new(),
+            zero_penalty_energy: 0,
         }
     }
 
     /// Allocate a new spin and return its index.
-    fn allocate_spin(&mut self) -> usize {
+    fn allocate_spin(&mut self) -> Result<usize, crate::registry::ConstructionError> {
         let idx = self.num_spins;
-        self.num_spins += 1;
-        self.fields.push(W::zero());
-        idx
+        self.num_spins = self
+            .num_spins
+            .checked_add(1)
+            .ok_or("spin count exceeds usize")?;
+        self.fields.push(0);
+        Ok(idx)
     }
 
     /// Get or create a spin index for a variable.
-    fn get_or_create_variable(&mut self, name: &str) -> usize {
+    fn get_or_create_variable(
+        &mut self,
+        name: &str,
+    ) -> Result<usize, crate::registry::ConstructionError> {
         if let Some(&idx) = self.variable_map.get(name) {
-            idx
+            Ok(idx)
         } else {
-            let idx = self.allocate_spin();
+            let idx = self.allocate_spin()?;
             self.variable_map.insert(name.to_string(), idx);
-            idx
+            Ok(idx)
         }
     }
 
     /// Add a gadget to the builder with the given spin mapping.
-    fn add_gadget(&mut self, gadget: &LogicGadget<W>, spin_map: &[usize]) {
-        // Add interactions
+    fn add_gadget(
+        &mut self,
+        gadget: &LogicGadget<i64>,
+        spin_map: &[usize],
+        ground_energy: i64,
+    ) -> Result<(), crate::registry::ConstructionError> {
+        self.zero_penalty_energy = self
+            .zero_penalty_energy
+            .checked_add(ground_energy)
+            .ok_or_else(|| {
+                crate::registry::ConstructionError::IntegerOverflow(
+                    "summing circuit gate ground energies".into(),
+                )
+            })?;
+        // Add interactions. Shared inputs may identify local spins; their
+        // diagonal terms remain in the Hamiltonian as s_i^2 = 1.
         for ((i, j), weight) in gadget.problem.interactions() {
             let global_i = spin_map[i];
             let global_j = spin_map[j];
@@ -264,75 +333,79 @@ where
             } else {
                 (global_j, global_i)
             };
-            self.interactions
-                .entry(key)
-                .or_insert_with(W::zero)
-                .add_assign(weight.clone());
+            let entry = self.interactions.entry(key).or_insert(0);
+            *entry = entry
+                .checked_add(weight)
+                .ok_or("circuit SpinGlass coupling overflow")?;
         }
 
         // Add fields
         for (local_idx, field) in gadget.problem.fields().iter().enumerate() {
             let global_idx = spin_map[local_idx];
-            self.fields[global_idx].add_assign(field.clone());
+            self.fields[global_idx] = self.fields[global_idx]
+                .checked_add(*field)
+                .ok_or("circuit SpinGlass field overflow")?;
         }
+        Ok(())
     }
 
     /// Build the final SpinGlass.
-    fn build(self) -> (SpinGlass<SimpleGraph, W>, HashMap<String, usize>) {
-        let mut interactions: Vec<((usize, usize), W)> = self.interactions.into_iter().collect();
+    fn build(self) -> Result<BuiltSpinGlass, crate::registry::ConstructionError> {
+        let mut interactions: Vec<((usize, usize), i64)> = self.interactions.into_iter().collect();
         interactions.sort_by_key(|((u, v), _)| (*u, *v));
         let sg = SpinGlass::new(self.num_spins, interactions, self.fields);
-        (sg, self.variable_map)
+        Ok((sg?, self.variable_map, self.zero_penalty_energy))
     }
 }
 
 /// Process a boolean expression and return the spin index of its output.
-fn process_expression<W>(expr: &BooleanExpr, builder: &mut SpinGlassBuilder<W>) -> usize
-where
-    W: Clone + Default + Zero + AddAssign + From<i32>,
-{
+fn process_expression(
+    expr: &BooleanExpr,
+    builder: &mut SpinGlassBuilder,
+) -> Result<usize, crate::registry::ConstructionError> {
     match &expr.op {
         BooleanOp::Var(name) => builder.get_or_create_variable(name),
 
         BooleanOp::Const(value) => {
-            let gadget: LogicGadget<W> = if *value { set1_gadget() } else { set0_gadget() };
-            let output_spin = builder.allocate_spin();
+            let gadget: LogicGadget<i64> = if *value { set1_gadget() } else { set0_gadget() };
+            let output_spin = builder.allocate_spin()?;
             let spin_map = vec![output_spin];
-            builder.add_gadget(&gadget, &spin_map);
-            output_spin
+            builder.add_gadget(&gadget, &spin_map, -1)?;
+            Ok(output_spin)
         }
 
         BooleanOp::Not(inner) => {
-            let input_spin = process_expression(inner, builder);
-            let gadget: LogicGadget<W> = not_gadget();
-            let output_spin = builder.allocate_spin();
+            let input_spin = process_expression(inner, builder)?;
+            let gadget: LogicGadget<i64> = not_gadget();
+            let output_spin = builder.allocate_spin()?;
             let spin_map = vec![input_spin, output_spin];
-            builder.add_gadget(&gadget, &spin_map);
-            output_spin
+            builder.add_gadget(&gadget, &spin_map, -1)?;
+            Ok(output_spin)
         }
 
-        BooleanOp::And(args) => process_binary_chain(args, builder, and_gadget),
+        BooleanOp::And(args) => process_binary_chain(args, builder, and_gadget, -3, true),
 
-        BooleanOp::Or(args) => process_binary_chain(args, builder, or_gadget),
+        BooleanOp::Or(args) => process_binary_chain(args, builder, or_gadget, -3, false),
 
-        BooleanOp::Xor(args) => process_binary_chain(args, builder, xor_gadget),
+        BooleanOp::Xor(args) => process_binary_chain(args, builder, xor_gadget, -4, false),
     }
 }
 
 /// Process a multi-input gate by chaining binary gates.
-fn process_binary_chain<W, F>(
+fn process_binary_chain<F>(
     args: &[BooleanExpr],
-    builder: &mut SpinGlassBuilder<W>,
+    builder: &mut SpinGlassBuilder,
     gadget_fn: F,
-) -> usize
+    ground_energy: i64,
+    empty_value: bool,
+) -> Result<usize, crate::registry::ConstructionError>
 where
-    W: Clone + Default + Zero + AddAssign + From<i32>,
-    F: Fn() -> LogicGadget<W>,
+    F: Fn() -> LogicGadget<i64>,
 {
-    assert!(
-        !args.is_empty(),
-        "Binary gate must have at least one argument"
-    );
+    if args.is_empty() {
+        // Boolean folds have an identity even when their input list is empty.
+        return process_expression(&BooleanExpr::constant(empty_value), builder);
+    }
 
     if args.len() == 1 {
         // Single argument - just return its output
@@ -341,102 +414,116 @@ where
 
     // Process first two arguments
     let mut result_spin = {
-        let input0 = process_expression(&args[0], builder);
-        let input1 = process_expression(&args[1], builder);
+        let input0 = process_expression(&args[0], builder)?;
+        let input1 = process_expression(&args[1], builder)?;
         let gadget = gadget_fn();
-        let output_spin = builder.allocate_spin();
+        let output_spin = builder.allocate_spin()?;
 
         // For XOR gadget, we need to allocate the auxiliary spin too
         let spin_map = if gadget.num_spins() == 4 {
             // XOR: inputs [0, 1], aux at 3, output at 2
-            let aux_spin = builder.allocate_spin();
+            let aux_spin = builder.allocate_spin()?;
             vec![input0, input1, output_spin, aux_spin]
         } else {
             // AND/OR: inputs [0, 1], output at 2
             vec![input0, input1, output_spin]
         };
 
-        builder.add_gadget(&gadget, &spin_map);
+        builder.add_gadget(&gadget, &spin_map, ground_energy)?;
         output_spin
     };
 
     // Chain remaining arguments
     for arg in args.iter().skip(2) {
-        let next_input = process_expression(arg, builder);
+        let next_input = process_expression(arg, builder)?;
         let gadget = gadget_fn();
-        let output_spin = builder.allocate_spin();
+        let output_spin = builder.allocate_spin()?;
 
         let spin_map = if gadget.num_spins() == 4 {
-            let aux_spin = builder.allocate_spin();
+            let aux_spin = builder.allocate_spin()?;
             vec![result_spin, next_input, output_spin, aux_spin]
         } else {
             vec![result_spin, next_input, output_spin]
         };
 
-        builder.add_gadget(&gadget, &spin_map);
+        builder.add_gadget(&gadget, &spin_map, ground_energy)?;
         result_spin = output_spin;
     }
 
-    result_spin
+    Ok(result_spin)
 }
 
 /// Process a circuit assignment.
-fn process_assignment<W>(assignment: &Assignment, builder: &mut SpinGlassBuilder<W>)
-where
-    W: Clone + Default + Zero + AddAssign + From<i32>,
-{
+fn process_assignment(
+    assignment: &Assignment,
+    builder: &mut SpinGlassBuilder,
+) -> Result<(), crate::registry::ConstructionError> {
     // Process the expression to get the output spin
-    let expr_output = process_expression(&assignment.expr, builder);
+    let expr_output = process_expression(&assignment.expr, builder)?;
 
     // For each output variable, we need to constrain it to equal the expression output
-    // This is done by adding a NOT gadget constraint (with J=1) to enforce equality
+    // A ferromagnetic coupling has minimum -4 exactly when the spins agree.
     for output_name in &assignment.outputs {
-        let output_spin = builder.get_or_create_variable(output_name);
+        let output_spin = builder.get_or_create_variable(output_name)?;
 
         // If the output spin is different from expr_output, add equality constraint
         if output_spin != expr_output {
             // Add ferromagnetic coupling to enforce s_i = s_j
             // J = -1 means aligned spins have lower energy
-            // Actually, we want to use a strong negative coupling
             let key = if output_spin < expr_output {
                 (output_spin, expr_output)
             } else {
                 (expr_output, output_spin)
             };
-            builder
-                .interactions
-                .entry(key)
-                .or_insert_with(W::zero)
-                .add_assign(W::from(-4)); // Strong ferromagnetic coupling
+            builder.zero_penalty_energy =
+                builder.zero_penalty_energy.checked_sub(4).ok_or_else(|| {
+                    crate::registry::ConstructionError::IntegerOverflow(
+                        "summing circuit equality ground energies".into(),
+                    )
+                })?;
+            let entry = builder.interactions.entry(key).or_insert(0);
+            *entry = entry
+                .checked_add(-4)
+                .ok_or("circuit SpinGlass equality coupling overflow")?;
         }
     }
+    Ok(())
 }
 
 #[reduction(
-    overhead = {
-        num_spins = "num_assignments * num_variables",
-        num_interactions = "num_assignments * num_variables",
+    aggregate = custom,
+    transform = upper_bound {
+        num_spins = "num_variables + 3 * num_expression_nodes",
+        num_interactions = "6 * num_expression_nodes + num_assignment_outputs",
     }
 )]
-impl ReduceTo<SpinGlass<SimpleGraph, i32>> for CircuitSAT {
+impl ReduceTo<SpinGlass<SimpleGraph, i64>> for CircuitSAT {
     type Result = ReductionCircuitToSG;
 
-    fn reduce_to(&self) -> Self::Result {
-        let mut builder: SpinGlassBuilder<i32> = SpinGlassBuilder::new();
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let mut builder = SpinGlassBuilder::new();
 
         // Process each assignment in the circuit
         for assignment in &self.circuit().assignments {
-            process_assignment(assignment, &mut builder);
+            process_assignment(assignment, &mut builder).map_err(
+                crate::rules::ReductionError::construction::<
+                    CircuitSAT,
+                    SpinGlass<SimpleGraph, i64>,
+                >,
+            )?;
         }
 
-        let (target, variable_map) = builder.build();
+        let (target, variable_map, zero_penalty_energy) = builder.build().map_err(
+            crate::rules::ReductionError::construction::<CircuitSAT, SpinGlass<SimpleGraph, i64>>,
+        )?;
         let source_variables = self.variable_names().to_vec();
 
-        ReductionCircuitToSG {
+        Ok(ReductionCircuitToSG {
             target,
             variable_map,
             source_variables,
-        }
+            zero_penalty_energy,
+        })
     }
 }
 
@@ -474,11 +561,15 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "circuitsat_to_spinglass",
         build: || {
-            crate::example_db::specs::rule_example_with_witness::<_, SpinGlass<SimpleGraph, i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, SpinGlass<SimpleGraph, i64>>(
                 full_adder_circuit_sat(),
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 0, 0, 0, 0, 0],
-                    target_config: vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                    source_config: serde_json::json!(vec![
+                        false, false, false, false, false, false, false, false
+                    ]),
+                    target_config: serde_json::json!(vec![
+                        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+                    ]),
                 },
             )
         },
diff --git a/src/rules/closeststring_ilp.rs b/src/rules/closeststring_ilp.rs
index 222c60186..1f7d2a922 100644
--- a/src/rules/closeststring_ilp.rs
+++ b/src/rules/closeststring_ilp.rs
@@ -28,54 +28,69 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing ClosestString to ILP.
 ///
-/// Variable layout (`ILP<i32>`, all non-negative):
+/// Variable layout (`ILP<i64>`, all non-negative):
 /// - `x_{j, a}` at index `j * alphabet_size + a` for `j in [0, m)` and
 ///   `a in [0, q)`, bounded to `{0, 1}`.
 /// - `R` (radius) at index `m * q`, an integer in `[0, m]`.
 #[derive(Debug, Clone)]
 pub struct ReductionClosestStringToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     alphabet_size: usize,
     string_length: usize,
 }
 
 impl ReductionResult for ReductionClosestStringToILP {
     type Source = ClosestString;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Decode the integer ILP assignment into the source center config.
     ///
     /// For every position `j`, choose the unique alphabet symbol `a` with
-    /// `x_{j, a} = 1`. If the target assignment is missing or none of the
-    /// per-position `x_{j, *}` variables are set to 1, we fall back to symbol
-    /// `0` so the returned vector still has the expected length; partial /
-    /// infeasible ILP solutions are the caller's responsibility.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    /// `x_{j, a} = 1`.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         let q = self.alphabet_size;
-        (0..self.string_length)
-            .map(|j| {
-                (0..q)
-                    .find(|&a| target_solution.get(j * q + a).copied().unwrap_or(0) == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+        let mut center = Vec::with_capacity(self.string_length);
+        for position in 0..self.string_length {
+            let block = &target_solution[position * q..(position + 1) * q];
+            let mut selected = block.iter().enumerate().filter(|(_, value)| **value == 1);
+            let symbol = selected.next().map(|(symbol, _)| symbol).ok_or_else(|| {
+                crate::rules::ExtractionError::invalid(format!(
+                    "center position {position} has no selected symbol"
+                ))
+            })?;
+            if selected.next().is_some() || block.iter().any(|&value| value > 1) {
+                return Err(crate::rules::ExtractionError::invalid(format!(
+                    "center position {position} is not one-hot"
+                )));
+            }
+            center.push(symbol);
+        }
+        Ok(center)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "alphabet_size * string_length + 1",
         num_constraints = "string_length + num_strings",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for ClosestString {
+impl ReduceTo<ILP<i64>> for ClosestString {
     type Result = ReductionClosestStringToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let q = self.alphabet_size();
         let m = self.string_length();
         let strings = self.strings();
@@ -88,34 +103,38 @@ impl ReduceTo<ILP<i32>> for ClosestString {
         let mut constraints: Vec<LinearConstraint> = Vec::with_capacity(m + n);
 
         // Assignment constraints: exactly one symbol per center position.
-        // Together with the non-negativity built into ILP<i32>, this also
+        // Together with the non-negativity built into `ILP<i64>`, this also
         // forces every x_{j, a} to lie in {0, 1}.
         for j in 0..m {
-            let terms: Vec<(usize, f64)> = (0..q).map(|a| (x_idx(j, a), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..q).map(|a| (x_idx(j, a), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Radius constraints: R + sum_j x_{j, s_i[j]} >= m.
         // Equivalently, R >= m - sum_j x_{j, s_i[j]} = d_H(c, s_i).
         for s in strings.iter() {
-            let mut terms: Vec<(usize, f64)> = Vec::with_capacity(m + 1);
-            terms.push((r_idx, 1.0));
+            let mut terms: Vec<(usize, i64)> = Vec::with_capacity(m + 1);
+            terms.push((r_idx, 1));
             for (j, &symbol) in s.iter().enumerate() {
-                terms.push((x_idx(j, symbol), 1.0));
+                terms.push((x_idx(j, symbol), 1));
             }
-            constraints.push(LinearConstraint::ge(terms, m as f64));
+            constraints.push(LinearConstraint::ge(
+                terms,
+                Self::exact_i64(m, "encoding the string length")?,
+            ));
         }
 
         // Objective: minimize R.
-        let objective = vec![(r_idx, 1.0)];
+        let objective = vec![(r_idx, 1)];
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionClosestStringToILP {
+        Ok(ReductionClosestStringToILP {
             target,
             alphabet_size: q,
             string_length: m,
-        }
+        })
     }
 }
 
@@ -131,7 +150,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 2,
                 vec![vec![0, 0, 0], vec![0, 1, 1], vec![1, 0, 1], vec![1, 1, 0]],
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/closestsubstring_ilp.rs b/src/rules/closestsubstring_ilp.rs
index dccc61963..65416c54c 100644
--- a/src/rules/closestsubstring_ilp.rs
+++ b/src/rules/closestsubstring_ilp.rs
@@ -36,7 +36,7 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing ClosestSubstring to ILP.
 ///
-/// Variable layout (`ILP<i32>`, all non-negative):
+/// Variable layout (`ILP<i64>`, all non-negative):
 /// - `x_{r, a}` at index `r * alphabet_size + a` for `r in [0, ell)` and
 ///   `a in [0, q)`, forced into `{0, 1}` by the assignment constraints.
 /// - `y_{i, p}` at index `q * ell + window_offsets[i] + p` for input string
@@ -46,7 +46,7 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 ///   integer in `[0, ell]`.
 #[derive(Debug, Clone)]
 pub struct ReductionClosestSubstringToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     alphabet_size: usize,
     substring_length: usize,
     /// Prefix sums of per-string window counts: `window_offsets[i]` is the
@@ -58,9 +58,9 @@ pub struct ReductionClosestSubstringToILP {
 
 impl ReductionResult for ReductionClosestSubstringToILP {
     type Source = ClosestSubstring;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
@@ -70,53 +70,67 @@ impl ReductionResult for ReductionClosestSubstringToILP {
     /// first `ell` entries are the center symbols, the remaining `n` entries
     /// are per-string window starts. For each center position `r`, we pick the
     /// unique alphabet symbol `a` with `x_{r, a} = 1`; for each input string
-    /// `s_i`, we pick the unique window start `p` with `y_{i, p} = 1`. When no
-    /// indicator is set to 1 in some block (which only happens on partial /
-    /// infeasible ILP solutions), we fall back to 0 so the returned vector
-    /// still has the expected shape.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    /// `s_i`, we pick the unique window start `p` with `y_{i, p} = 1`.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         let q = self.alphabet_size;
         let ell = self.substring_length;
         let y_base = q * ell;
-
         let mut out = Vec::with_capacity(ell + self.window_counts.len());
 
-        // Center symbols.
-        for r in 0..ell {
-            let symbol = (0..q)
-                .find(|&a| target_solution.get(r * q + a).copied().unwrap_or(0) == 1)
-                .unwrap_or(0);
-            out.push(symbol);
+        for position in 0..ell {
+            let block = &target_solution[position * q..(position + 1) * q];
+            out.push(decode_one_hot(block, "center position", position)?);
         }
-
-        // Window starts.
-        for (i, &w_i) in self.window_counts.iter().enumerate() {
-            let start = (0..w_i)
-                .find(|&p| {
-                    target_solution
-                        .get(y_base + self.window_offsets[i] + p)
-                        .copied()
-                        .unwrap_or(0)
-                        == 1
-                })
-                .unwrap_or(0);
-            out.push(start);
+        for (string, &window_count) in self.window_counts.iter().enumerate() {
+            let start = y_base + self.window_offsets[string];
+            out.push(decode_one_hot(
+                &target_solution[start..start + window_count],
+                "string window",
+                string,
+            )?);
         }
 
-        out
+        Ok(out)
     }
 }
 
+fn decode_one_hot(
+    block: &[i64],
+    block_name: &str,
+    block_index: usize,
+) -> crate::rules::ExtractionResult<usize> {
+    let mut selected = block.iter().enumerate().filter(|(_, value)| **value == 1);
+    let index = selected.next().map(|(index, _)| index).ok_or_else(|| {
+        crate::rules::ExtractionError::invalid(format!(
+            "{block_name} {block_index} has no selected value"
+        ))
+    })?;
+    if selected.next().is_some() || block.iter().any(|&value| value > 1) {
+        return Err(crate::rules::ExtractionError::invalid(format!(
+            "{block_name} {block_index} is not one-hot"
+        )));
+    }
+    Ok(index)
+}
+
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "alphabet_size * substring_length + total_num_windows + 1",
         num_constraints = "substring_length + num_strings + total_num_windows + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for ClosestSubstring {
+impl ReduceTo<ILP<i64>> for ClosestSubstring {
     type Result = ReductionClosestSubstringToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let q = self.alphabet_size();
         let ell = self.substring_length();
         let strings = self.strings();
@@ -138,31 +152,32 @@ impl ReduceTo<ILP<i32>> for ClosestSubstring {
         let y_idx = |i: usize, p: usize| -> usize { y_base + window_offsets[i] + p };
         let r_idx = y_base + total_windows;
         let num_vars = r_idx + 1;
+        let ell_i64 = Self::exact_i64(ell, "encoding the substring length")?;
 
         let mut constraints: Vec<LinearConstraint> =
             Vec::with_capacity(ell + n + total_windows + 1);
 
         // Assignment constraints: exactly one symbol per center position.
-        // Together with the non-negativity built into ILP<i32>, this also
+        // Together with the non-negativity built into `ILP<i64>`, this also
         // forces every x_{r, a} to lie in {0, 1}.
         for r in 0..ell {
-            let terms: Vec<(usize, f64)> = (0..q).map(|a| (x_idx(r, a), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..q).map(|a| (x_idx(r, a), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Tight upper bound on R: the worst-case Hamming distance over a
         // length-ell window is at most ell. Added as a single-term `<=`
         // constraint so the solver's bound-tightening pass (which scans for
         // exactly this pattern) picks it up. Without this, R defaults to the
-        // full i32 domain, which severely degrades HiGHS performance even on
+        // full i64 domain, which severely degrades HiGHS performance even on
         // tiny instances.
-        constraints.push(LinearConstraint::le(vec![(r_idx, 1.0)], ell as f64));
+        constraints.push(LinearConstraint::le(vec![(r_idx, 1)], ell_i64));
 
         // Window-choice constraints: exactly one window per input string.
         // Combined with non-negativity, this forces every y_{i, p} in {0, 1}.
         for (i, &w_i) in window_counts.iter().enumerate() {
-            let terms: Vec<(usize, f64)> = (0..w_i).map(|p| (y_idx(i, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..w_i).map(|p| (y_idx(i, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Conditional radius constraints: for every (input string, window
@@ -172,28 +187,29 @@ impl ReduceTo<ILP<i32>> for ClosestSubstring {
         //   automatically satisfied because R >= 0.
         for (i, s) in strings.iter().enumerate() {
             for p in 0..window_counts[i] {
-                let mut terms: Vec<(usize, f64)> = Vec::with_capacity(ell + 2);
-                terms.push((r_idx, 1.0));
+                let mut terms: Vec<(usize, i64)> = Vec::with_capacity(ell + 2);
+                terms.push((r_idx, 1));
                 for r in 0..ell {
-                    terms.push((x_idx(r, s[p + r]), 1.0));
+                    terms.push((x_idx(r, s[p + r]), 1));
                 }
-                terms.push((y_idx(i, p), -(ell as f64)));
-                constraints.push(LinearConstraint::ge(terms, 0.0));
+                terms.push((y_idx(i, p), -ell_i64));
+                constraints.push(LinearConstraint::ge(terms, 0));
             }
         }
 
         // Objective: minimize R.
-        let objective = vec![(r_idx, 1.0)];
+        let objective = vec![(r_idx, 1)];
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionClosestSubstringToILP {
+        Ok(ReductionClosestSubstringToILP {
             target,
             alphabet_size: q,
             substring_length: ell,
             window_offsets,
             window_counts,
-        }
+        })
     }
 }
 
@@ -214,8 +230,9 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     vec![1, 1, 0, 0, 1],
                 ],
                 3,
-            );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            )
+            .unwrap();
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/closestvectorproblem_casts.rs b/src/rules/closestvectorproblem_casts.rs
new file mode 100644
index 000000000..9e45d59df
--- /dev/null
+++ b/src/rules/closestvectorproblem_casts.rs
@@ -0,0 +1,35 @@
+//! Numeric variant reduction for Closest Vector Problem.
+
+use crate::impl_variant_reduction;
+use crate::models::algebraic::ClosestVectorProblem;
+use crate::rules::ReductionError;
+use crate::types::i64_to_exact_f64;
+
+impl_variant_reduction!(
+    ClosestVectorProblem,
+    <i64> => <f64>,
+    fields: [ambient_dimension, num_basis_vectors],
+    |src| {
+        let target = src
+            .target()
+            .iter()
+            .copied()
+            .map(i64_to_exact_f64)
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|error| {
+                ReductionError::inexact_float_conversion::<
+                    ClosestVectorProblem<i64>,
+                    ClosestVectorProblem<f64>,
+                >(error)
+            })?;
+        ClosestVectorProblem::new(src.basis().to_vec(), target).map_err(|error| {
+            ReductionError::construction::<ClosestVectorProblem<i64>, ClosestVectorProblem<f64>>(
+                error,
+            )
+        })?
+    }
+);
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/closestvectorproblem_casts.rs"]
+mod tests;
diff --git a/src/rules/closestvectorproblem_qubo.rs b/src/rules/closestvectorproblem_qubo.rs
index bfc4b6c73..3efa14979 100644
--- a/src/rules/closestvectorproblem_qubo.rs
+++ b/src/rules/closestvectorproblem_qubo.rs
@@ -1,190 +1,349 @@
-//! Reduction from ClosestVectorProblem to QUBO.
+//! Reduction from integer-target CVP to QUBO.
 //!
-//! Encodes each bounded CVP coefficient with an exact in-range binary basis and
-//! expands the squared-distance objective into a QUBO over those bits.
+//! The reduction derives a finite coefficient box from the lattice basis and
+//! target, then expands the squared Euclidean distance over exact-range binary
+//! encodings.
 
 #[cfg(feature = "example-db")]
 use crate::export::SolutionPair;
 use crate::models::algebraic::{ClosestVectorProblem, QUBO};
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
+use num_bigint::BigInt;
+use num_traits::Zero;
+
+type Source = ClosestVectorProblem<i64>;
+type Target = QUBO<i64>;
 
 #[derive(Debug, Clone)]
 struct EncodingSpan {
     start: usize,
-    weights: Vec<usize>,
+    weights: Vec<i64>,
+    lower: i64,
 }
 
-/// Result of reducing a bounded ClosestVectorProblem instance to QUBO.
+/// Result of reducing an integer-target CVP instance to QUBO.
 #[derive(Debug, Clone)]
 pub struct ReductionCVPToQUBO {
-    target: QUBO<f64>,
+    target: Target,
     encodings: Vec<EncodingSpan>,
 }
 
 impl ReductionResult for ReductionCVPToQUBO {
-    type Source = ClosestVectorProblem<i32>;
-    type Target = QUBO<f64>;
+    type Source = Source;
+    type Target = Target;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    /// Reconstruct the source configuration offsets from the encoded QUBO bits.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         self.encodings
             .iter()
             .map(|encoding| {
-                encoding
-                    .weights
-                    .iter()
-                    .enumerate()
-                    .map(|(offset, weight)| {
-                        target_solution
-                            .get(encoding.start + offset)
-                            .copied()
-                            .unwrap_or(0)
-                            * weight
+                let offset = encoding.weights.iter().enumerate().try_fold(
+                    0_i64,
+                    |offset, (index, &weight)| {
+                        if target_solution[encoding.start + index] {
+                            offset.checked_add(weight)
+                        } else {
+                            Some(offset)
+                        }
+                    },
+                );
+                offset
+                    .and_then(|offset| encoding.lower.checked_add(offset))
+                    .ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid(
+                            "decoded closest-vector coefficient overflows i64",
+                        )
                     })
-                    .sum()
             })
             .collect()
     }
 }
 
-#[cfg(feature = "example-db")]
-fn canonical_cvp_instance() -> ClosestVectorProblem<i32> {
-    ClosestVectorProblem::new(
-        vec![vec![2, 0], vec![1, 2]],
-        vec![2.8, 1.5],
-        vec![
-            crate::models::algebraic::VarBounds::bounded(-2, 4),
-            crate::models::algebraic::VarBounds::bounded(-2, 4),
-        ],
-    )
+fn overflow(operation: &str) -> crate::rules::ReductionError {
+    crate::rules::ReductionError::integer_overflow::<Source, Target>(operation)
 }
 
-fn encoding_spans(problem: &ClosestVectorProblem<i32>) -> Vec<EncodingSpan> {
-    let mut start = 0usize;
-    let mut spans = Vec::with_capacity(problem.num_basis_vectors());
-    for bounds in problem.bounds() {
-        let weights = bounds
-            .exact_encoding_weights()
-            .into_iter()
-            .map(|weight| usize::try_from(weight).expect("encoding weights must be nonnegative"))
-            .collect::<Vec<_>>();
-        spans.push(EncodingSpan { start, weights });
-        start += spans.last().expect("just pushed").weights.len();
+fn determinant(matrix: &[Vec<i64>]) -> Result<i64, crate::rules::ReductionError> {
+    let size = matrix.len();
+    if size == 0 {
+        return Ok(1);
     }
-    spans
+    // Pivoted Bareiss elimination uses exact division and cubic arithmetic work.
+    // BigInt preserves cancellation when intermediate products exceed i64.
+    let mut matrix: Vec<Vec<BigInt>> = matrix
+        .iter()
+        .map(|row| row.iter().copied().map(BigInt::from).collect())
+        .collect();
+    let mut previous_pivot = BigInt::from(1);
+    let mut negative = false;
+    for column in 0..size - 1 {
+        let Some(pivot_row) = (column..size).find(|&row| !matrix[row][column].is_zero()) else {
+            return Ok(0);
+        };
+        if pivot_row != column {
+            matrix.swap(column, pivot_row);
+            negative = !negative;
+        }
+        let pivot = matrix[column][column].clone();
+        for row in column + 1..size {
+            for next_column in column + 1..size {
+                matrix[row][next_column] = (&matrix[row][next_column] * &pivot
+                    - &matrix[row][column] * &matrix[column][next_column])
+                    / &previous_pivot;
+            }
+            matrix[row][column] = BigInt::zero();
+        }
+        previous_pivot = pivot;
+    }
+    let value = matrix[size - 1][size - 1].clone();
+    i64::try_from(if negative { -value } else { value })
+        .map_err(|_| overflow("computing a closest-vector determinant"))
 }
 
-fn gram_matrix(problem: &ClosestVectorProblem<i32>) -> Vec<Vec<f64>> {
-    let basis = problem.basis();
-    let n = basis.len();
-    let mut gram = vec![vec![0.0; n]; n];
-    for i in 0..n {
-        for j in i..n {
-            let dot = basis[i]
+fn coefficient_bounds(problem: &Source) -> Result<Vec<i64>, crate::rules::ReductionError> {
+    let rows = problem
+        .independent_rows()
+        .map_err(crate::rules::ReductionError::construction::<Source, Target>)?;
+    let size = problem.num_basis_vectors();
+    if size == 0 {
+        return Ok(Vec::new());
+    }
+
+    let matrix = rows
+        .iter()
+        .map(|&row| {
+            problem
+                .basis()
                 .iter()
-                .zip(&basis[j])
-                .map(|(&lhs, &rhs)| lhs as f64 * rhs as f64)
-                .sum::<f64>();
-            gram[i][j] = dot;
-            gram[j][i] = dot;
+                .map(|column| column[row])
+                .collect::<Vec<_>>()
+        })
+        .collect::<Vec<_>>();
+    if determinant(&matrix)? == 0 {
+        return Err(
+            crate::rules::ReductionError::invalid_target::<Source, Target>(
+                "selected closest-vector rows are not independent",
+            ),
+        );
+    }
+
+    let target_norm = problem.target().iter().try_fold(0_i64, |total, &value| {
+        total
+            .checked_add(
+                value
+                    .checked_abs()
+                    .ok_or_else(|| overflow("taking a closest-vector target absolute value"))?,
+            )
+            .ok_or_else(|| overflow("computing the closest-vector target one-norm"))
+    })?;
+    let row_bounds = rows
+        .iter()
+        .map(|&row| {
+            problem.target()[row]
+                .checked_abs()
+                .and_then(|value| value.checked_add(target_norm))
+                .ok_or_else(|| overflow("computing a closest-vector selected-row bound"))
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    (0..size)
+        .map(|coefficient| {
+            (0..size).try_fold(0_i64, |bound, selected_row| {
+                let minor = (0..size)
+                    .filter(|&row| row != selected_row)
+                    .map(|row| {
+                        (0..size)
+                            .filter(|&column| column != coefficient)
+                            .map(|column| matrix[row][column])
+                            .collect::<Vec<_>>()
+                    })
+                    .collect::<Vec<_>>();
+                let adjugate_magnitude = determinant(&minor)?
+                    .checked_abs()
+                    .ok_or_else(|| overflow("taking a closest-vector cofactor absolute value"))?;
+                let term = adjugate_magnitude
+                    .checked_mul(row_bounds[selected_row])
+                    .ok_or_else(|| overflow("computing a closest-vector coefficient bound"))?;
+                bound
+                    .checked_add(term)
+                    .ok_or_else(|| overflow("computing a closest-vector coefficient bound"))
+            })
+        })
+        .collect()
+}
+
+fn exact_range_weights(maximum: i64) -> Result<Vec<i64>, crate::rules::ReductionError> {
+    let mut weights = Vec::new();
+    let mut remaining = maximum;
+    let mut power = 1_i64;
+    while remaining > 0 {
+        let weight = power.min(remaining);
+        weights.push(weight);
+        remaining -= weight;
+        if remaining > 0 {
+            power = power
+                .checked_mul(2)
+                .ok_or_else(|| overflow("computing closest-vector encoding weights"))?;
         }
     }
-    gram
+    Ok(weights)
 }
 
-fn at_times_target(problem: &ClosestVectorProblem<i32>) -> Vec<f64> {
-    problem
-        .basis()
+fn encoding_spans(bounds: &[i64]) -> Result<Vec<EncodingSpan>, crate::rules::ReductionError> {
+    let mut start = 0usize;
+    bounds
         .iter()
-        .map(|column| {
-            column
-                .iter()
-                .zip(problem.target())
-                .map(|(&entry, &target)| entry as f64 * target)
-                .sum()
+        .map(|&bound| {
+            let maximum = bound
+                .checked_mul(2)
+                .ok_or_else(|| overflow("computing a closest-vector encoding range"))?;
+            let weights = exact_range_weights(maximum)?;
+            let span = EncodingSpan {
+                start,
+                weights,
+                lower: -bound,
+            };
+            start = start
+                .checked_add(span.weights.len())
+                .ok_or_else(|| overflow("computing closest-vector encoding offsets"))?;
+            Ok(span)
         })
         .collect()
 }
 
-#[reduction(overhead = { num_vars = "num_encoding_bits" })]
-impl ReduceTo<QUBO<f64>> for ClosestVectorProblem<i32> {
+fn dot(left: &[i64], right: &[i64], operation: &str) -> Result<i64, crate::rules::ReductionError> {
+    left.iter()
+        .zip(right)
+        .try_fold(0_i64, |total, (&left, &right)| {
+            let product = left.checked_mul(right).ok_or_else(|| overflow(operation))?;
+            total
+                .checked_add(product)
+                .ok_or_else(|| overflow(operation))
+        })
+}
+
+#[reduction(transform = unavailable {
+    num_vars = "the exact encoding size depends on the concrete basis and target values",
+})]
+impl ReduceTo<QUBO<i64>> for ClosestVectorProblem<i64> {
     type Result = ReductionCVPToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
-        let encodings = encoding_spans(self);
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let bounds = coefficient_bounds(self)?;
+        let encodings = encoding_spans(&bounds)?;
         let total_bits = encodings
             .last()
             .map(|encoding| encoding.start + encoding.weights.len())
             .unwrap_or(0);
-        let mut matrix = vec![vec![0.0; total_bits]; total_bits];
 
-        if total_bits == 0 {
-            return ReductionCVPToQUBO {
-                target: QUBO::from_matrix(matrix),
-                encodings,
-            };
+        let size = self.num_basis_vectors();
+        let mut gram = vec![vec![0_i64; size]; size];
+        for (i, row) in gram.iter_mut().enumerate() {
+            for (j, entry) in row.iter_mut().enumerate() {
+                *entry = dot(
+                    &self.basis()[i],
+                    &self.basis()[j],
+                    "computing a closest-vector Gram entry",
+                )?;
+            }
         }
-
-        let gram = gram_matrix(self);
-        let h = at_times_target(self);
-        let lowers = self
-            .bounds()
+        let h = self
+            .basis()
             .iter()
-            .map(|bounds| {
-                bounds
-                    .lower
-                    .expect("CVP QUBO reduction requires finite lower bounds")
+            .map(|column| {
+                dot(
+                    column,
+                    self.target(),
+                    "computing a closest-vector target projection",
+                )
             })
-            .map(|lower| lower as f64)
-            .collect::<Vec<_>>();
-        let g_lo_minus_h = (0..self.num_basis_vectors())
+            .collect::<Result<Vec<_>, _>>()?;
+        let linear = (0..size)
             .map(|i| {
-                (0..self.num_basis_vectors())
-                    .map(|j| gram[i][j] * lowers[j])
-                    .sum::<f64>()
-                    - h[i]
+                let product = (0..size).try_fold(0_i64, |total, j| {
+                    let term = gram[i][j]
+                        .checked_mul(encodings[j].lower)
+                        .ok_or_else(|| overflow("computing a closest-vector linear term"))?;
+                    total
+                        .checked_add(term)
+                        .ok_or_else(|| overflow("computing a closest-vector linear term"))
+                })?;
+                product
+                    .checked_sub(h[i])
+                    .ok_or_else(|| overflow("computing a closest-vector linear term"))
             })
-            .collect::<Vec<_>>();
-
-        let mut bit_terms = Vec::with_capacity(total_bits);
-        for (var_index, encoding) in encodings.iter().enumerate() {
-            for &weight in &encoding.weights {
-                bit_terms.push((var_index, weight as f64));
-            }
-        }
+            .collect::<Result<Vec<_>, _>>()?;
 
+        let bit_terms = encodings
+            .iter()
+            .enumerate()
+            .flat_map(|(coefficient, encoding)| {
+                encoding
+                    .weights
+                    .iter()
+                    .map(move |&weight| (coefficient, weight))
+            })
+            .collect::<Vec<_>>();
+        let mut integer_matrix = vec![vec![0_i64; total_bits]; total_bits];
         for u in 0..total_bits {
-            let (var_u, weight_u) = bit_terms[u];
-            matrix[u][u] =
-                gram[var_u][var_u] * weight_u * weight_u + 2.0 * weight_u * g_lo_minus_h[var_u];
+            let (coefficient_u, weight_u) = bit_terms[u];
+            let quadratic = gram[coefficient_u][coefficient_u]
+                .checked_mul(weight_u)
+                .and_then(|value| value.checked_mul(weight_u))
+                .ok_or_else(|| overflow("computing a closest-vector QUBO diagonal"))?;
+            let linear_term = linear[coefficient_u]
+                .checked_mul(weight_u)
+                .and_then(|value| value.checked_mul(2))
+                .ok_or_else(|| overflow("computing a closest-vector QUBO diagonal"))?;
+            integer_matrix[u][u] = quadratic
+                .checked_add(linear_term)
+                .ok_or_else(|| overflow("computing a closest-vector QUBO diagonal"))?;
 
-            for (v, &(var_v, weight_v)) in bit_terms.iter().enumerate().skip(u + 1) {
-                matrix[u][v] = 2.0 * gram[var_u][var_v] * weight_u * weight_v;
+            for v in (u + 1)..total_bits {
+                let (coefficient_v, weight_v) = bit_terms[v];
+                integer_matrix[u][v] = gram[coefficient_u][coefficient_v]
+                    .checked_mul(weight_u)
+                    .and_then(|value| value.checked_mul(weight_v))
+                    .and_then(|value| value.checked_mul(2))
+                    .ok_or_else(|| overflow("computing a closest-vector QUBO interaction"))?;
             }
         }
 
-        ReductionCVPToQUBO {
-            target: QUBO::from_matrix(matrix),
+        Ok(ReductionCVPToQUBO {
+            target: QUBO::from_matrix(integer_matrix)
+                .map_err(crate::rules::ReductionError::construction::<Source, Target>)?,
             encodings,
-        }
+        })
     }
 }
 
+#[cfg(feature = "example-db")]
+fn canonical_cvp_instance() -> Source {
+    ClosestVectorProblem::new(vec![vec![2, 0], vec![1, 2]], vec![3_i64, 2])
+        .expect("canonical closest-vector instance must be valid")
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "closestvectorproblem_to_qubo",
         build: || {
-            crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
+            crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
                 canonical_cvp_instance(),
                 SolutionPair {
-                    source_config: vec![3, 3],
-                    target_config: vec![0, 0, 1, 0, 0, 1],
+                    source_config: serde_json::json!(vec![1, 1]),
+                    target_config: serde_json::json!(vec![
+                        false, false, false, true, true, false, false, true, false, false, true,
+                    ]),
                 },
             )
         },
diff --git a/src/rules/clustering_ilp.rs b/src/rules/clustering_ilp.rs
index 659eb0d38..bb3149ae0 100644
--- a/src/rules/clustering_ilp.rs
+++ b/src/rules/clustering_ilp.rs
@@ -18,12 +18,6 @@ pub struct ReductionClusteringToILP {
     num_clusters: usize,
 }
 
-impl ReductionClusteringToILP {
-    fn var_index(&self, element: usize, cluster: usize) -> usize {
-        element * self.num_clusters + cluster
-    }
-}
-
 impl ReductionResult for ReductionClusteringToILP {
     type Source = Clustering;
     type Target = ILP<bool>;
@@ -32,30 +26,34 @@ impl ReductionResult for ReductionClusteringToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.num_elements)
-            .map(|element| {
-                (0..self.num_clusters)
-                    .find(|&cluster| {
-                        let idx = self.var_index(element, cluster);
-                        idx < target_solution.len() && target_solution[idx] == 1
-                    })
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_elements,
+            self.num_clusters,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_elements * num_clusters",
         num_constraints = "num_elements + num_elements * (num_elements - 1) / 2 * num_clusters",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for Clustering {
     type Result = ReductionClusteringToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_elements = self.num_elements();
         let num_clusters = self.num_clusters();
         let num_vars = num_elements * num_clusters;
@@ -65,10 +63,10 @@ impl ReduceTo<ILP<bool>> for Clustering {
             |element: usize, cluster: usize| -> usize { element * num_clusters + cluster };
 
         for element in 0..num_elements {
-            let terms: Vec<(usize, f64)> = (0..num_clusters)
-                .map(|cluster| (var_index(element, cluster), 1.0))
+            let terms: Vec<(usize, i64)> = (0..num_clusters)
+                .map(|cluster| (var_index(element, cluster), 1))
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         let distances = self.distances();
@@ -78,19 +76,20 @@ impl ReduceTo<ILP<bool>> for Clustering {
                 if distance > diameter_bound {
                     for cluster in 0..num_clusters {
                         constraints.push(LinearConstraint::le(
-                            vec![(var_index(i, cluster), 1.0), (var_index(j, cluster), 1.0)],
-                            1.0,
+                            vec![(var_index(i, cluster), 1), (var_index(j, cluster), 1)],
+                            1,
                         ));
                     }
                 }
             }
         }
 
-        ReductionClusteringToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionClusteringToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_elements,
             num_clusters,
-        }
+        })
     }
 }
 
@@ -114,8 +113,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 1, 1],
-                    target_config: vec![1, 0, 1, 0, 0, 1, 0, 1],
+                    source_config: serde_json::json!(vec![0, 0, 1, 1]),
+                    target_config: serde_json::json!(vec![1, 0, 1, 0, 0, 1, 0, 1]),
                 },
             )
         },
diff --git a/src/rules/coloring_ilp.rs b/src/rules/coloring_ilp.rs
index 8fa5095c8..37c6f5944 100644
--- a/src/rules/coloring_ilp.rs
+++ b/src/rules/coloring_ilp.rs
@@ -10,6 +10,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::KColoring;
 use crate::reduction;
+use crate::rules::ilp_helpers::one_hot_decode_rows;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
 use crate::variant::{KValue, K1, K2, K3, K4, KN};
@@ -28,13 +29,6 @@ pub struct ReductionKColoringToILP<K: KValue, G> {
     _phantom: std::marker::PhantomData<(K, G)>,
 }
 
-impl<K: KValue, G> ReductionKColoringToILP<K, G> {
-    /// Get the variable index for vertex v with color c.
-    fn var_index(&self, vertex: usize, color: usize) -> usize {
-        vertex * self.num_colors + color
-    }
-}
-
 impl<K: KValue, G> ReductionResult for ReductionKColoringToILP<K, G>
 where
     G: Graph + crate::variant::VariantParam,
@@ -50,25 +44,20 @@ where
     ///
     /// The ILP solution has num_vertices * K binary variables.
     /// For each vertex, we find which color has value 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let k = self.num_colors;
-        (0..self.num_vertices)
-            .map(|v| {
-                (0..k)
-                    .find(|&c| {
-                        let var_idx = self.var_index(v, c);
-                        var_idx < target_solution.len() && target_solution[var_idx] == 1
-                    })
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        one_hot_decode_rows(target_solution, self.num_vertices, self.num_colors, 0)
     }
 }
 
 /// Helper function implementing the KColoring to ILP reduction logic.
 fn reduce_kcoloring_to_ilp<K: KValue, G: Graph>(
     problem: &KColoring<K, G>,
-) -> ReductionKColoringToILP<K, G> {
+) -> Result<ReductionKColoringToILP<K, G>, crate::registry::ConstructionError> {
     let k = problem.num_colors();
     let num_vertices = problem.graph().num_vertices();
     let num_vars = num_vertices * k;
@@ -81,8 +70,8 @@ fn reduce_kcoloring_to_ilp<K: KValue, G: Graph>(
     // Constraint 1: Each vertex has exactly one color
     // sum_c x_{v,c} = 1 for each vertex v
     for v in 0..num_vertices {
-        let terms: Vec<(usize, f64)> = (0..k).map(|c| (var_index(v, c), 1.0)).collect();
-        constraints.push(LinearConstraint::eq(terms, 1.0));
+        let terms: Vec<(usize, i64)> = (0..k).map(|c| (var_index(v, c), 1)).collect();
+        constraints.push(LinearConstraint::eq(terms, 1));
     }
 
     // Constraint 2: Adjacent vertices have different colors
@@ -90,38 +79,39 @@ fn reduce_kcoloring_to_ilp<K: KValue, G: Graph>(
     for (u, v) in problem.graph().edges() {
         for c in 0..k {
             constraints.push(LinearConstraint::le(
-                vec![(var_index(u, c), 1.0), (var_index(v, c), 1.0)],
-                1.0,
+                vec![(var_index(u, c), 1), (var_index(v, c), 1)],
+                1,
             ));
         }
     }
 
     // Objective: minimize 0 (feasibility problem)
     // We use an empty objective
-    let objective: Vec<(usize, f64)> = vec![];
+    let objective: Vec<(usize, i64)> = vec![];
 
-    let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+    let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)?;
 
-    ReductionKColoringToILP {
+    Ok(ReductionKColoringToILP {
         target,
         num_vertices,
         num_colors: k,
         _phantom: std::marker::PhantomData,
-    }
+    })
 }
 
 // Register only the KN variant in the reduction graph
 #[reduction(
-    overhead = {
-        num_vars = "num_vertices^2",
-        num_constraints = "num_vertices + num_vertices * num_edges",
+    transform = exact {
+        num_vars = "num_vertices * num_colors",
+        num_constraints = "num_vertices + num_edges * num_colors",
+        num_nonzeros = "num_colors * (num_vertices + 2 * num_edges)",
     }
 )]
 impl ReduceTo<ILP<bool>> for KColoring<KN, SimpleGraph> {
     type Result = ReductionKColoringToILP<KN, SimpleGraph>;
 
-    fn reduce_to(&self) -> Self::Result {
-        reduce_kcoloring_to_ilp(self)
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        reduce_kcoloring_to_ilp(self).map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)
     }
 }
 
@@ -130,7 +120,10 @@ macro_rules! impl_kcoloring_to_ilp {
     ($($ktype:ty),+) => {$(
         impl ReduceTo<ILP<bool>> for KColoring<$ktype, SimpleGraph> {
             type Result = ReductionKColoringToILP<$ktype, SimpleGraph>;
-            fn reduce_to(&self) -> Self::Result { reduce_kcoloring_to_ilp(self) }
+            fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+                reduce_kcoloring_to_ilp(self)
+                    .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)
+            }
         }
     )+};
 }
@@ -150,11 +143,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 2, 0, 1, 2, 1, 1, 2, 0, 0],
-                    target_config: vec![
+                    source_config: serde_json::json!(vec![0, 2, 0, 1, 2, 1, 1, 2, 0, 0]),
+                    target_config: serde_json::json!(vec![
                         1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1,
                         0, 0, 1, 0, 0,
-                    ],
+                    ]),
                 },
             )
         },
diff --git a/src/rules/coloring_qubo.rs b/src/rules/coloring_qubo.rs
index e85c498f8..c29893620 100644
--- a/src/rules/coloring_qubo.rs
+++ b/src/rules/coloring_qubo.rs
@@ -3,8 +3,8 @@
 //! One-hot encoding: x_{v,c} = 1 iff vertex v gets color c.
 //! QUBO variable index: v * K + c.
 //!
-//! One-hot penalty: P1*sum_v (1 - sum_c x_{v,c})^2
-//! Edge penalty: P2*sum_{(u,v) in E} sum_c x_{u,c}*x_{v,c}
+//! Integer-scaled one-hot penalty: 2P*sum_v (1 - sum_c x_{v,c})^2
+//! Edge penalty: P*sum_{(u,v) in E} sum_c x_{u,c}*x_{v,c}
 //!
 //! QUBO has n*K variables.
 
@@ -18,70 +18,141 @@ use crate::variant::{KValue, K2, K3, KN};
 /// Result of reducing KColoring to QUBO.
 #[derive(Debug, Clone)]
 pub struct ReductionKColoringToQUBO<K: KValue> {
-    target: QUBO<f64>,
+    target: QUBO<i64>,
     num_vertices: usize,
     num_colors: usize,
+    feasible_energy: i64,
     _phantom: std::marker::PhantomData<K>,
 }
 
 impl<K: KValue> ReductionResult for ReductionKColoringToQUBO<K> {
     type Source = KColoring<K, SimpleGraph>;
-    type Target = QUBO<f64>;
+    type Target = QUBO<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
     /// Decode one-hot: for each vertex, find which color bit is 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let k = self.num_colors;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target QUBO configuration does not certify a proper coloring",
+            ));
+        }
+
         (0..self.num_vertices)
-            .map(|v| {
-                (0..k)
-                    .find(|&c| target_solution[v * k + c] == 1)
-                    .unwrap_or(0)
+            .map(|vertex| {
+                let mut selected = (0..self.num_colors)
+                    .filter(|&color| target_solution[vertex * self.num_colors + color]);
+                match (selected.next(), selected.next()) {
+                    (Some(color), None) => Ok(color),
+                    (None, _) => Err(crate::rules::ExtractionError::invalid(format!(
+                        "assignment row {vertex} has no selected color"
+                    ))),
+                    (Some(_), Some(_)) => Err(crate::rules::ExtractionError::invalid(format!(
+                        "assignment row {vertex} has multiple selected colors"
+                    ))),
+                }
             })
             .collect()
     }
 }
 
+impl<K: KValue> crate::rules::AggregateReductionResult for ReductionKColoringToQUBO<K> {
+    type Source = KColoring<K, SimpleGraph>;
+    type Target = QUBO<i64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, value: crate::types::Min<i64>) -> crate::types::Or {
+        crate::types::Or(value.0 == Some(self.feasible_energy))
+    }
+}
+
+/// Check dimensions and the omitted constant before allocating the matrix.
+fn coloring_qubo_parameters<K: KValue>(
+    n: usize,
+    k: usize,
+) -> Result<(usize, i64, i64), crate::rules::ReductionError> {
+    let overflow = |operation| {
+        crate::rules::ReductionError::integer_overflow::<KColoring<K, SimpleGraph>, QUBO<i64>>(
+            operation,
+        )
+    };
+    let nq = n
+        .checked_mul(k)
+        .ok_or_else(|| overflow("computing the number of QUBO variables"))?;
+    nq.checked_mul(nq)
+        .ok_or_else(|| overflow("computing the QUBO matrix size"))?;
+    let n_i64 = i64::try_from(n)
+        .map_err(|_| overflow("converting the vertex count to a QUBO coefficient"))?;
+    let penalty = n_i64
+        .checked_add(1)
+        .ok_or_else(|| overflow("computing the coloring penalty"))?;
+    let feasible_energy = n_i64
+        .checked_mul(penalty)
+        .and_then(|value| value.checked_mul(-2))
+        .ok_or_else(|| overflow("computing the zero-penalty coloring energy"))?;
+    Ok((nq, penalty, feasible_energy))
+}
+
 /// Helper function implementing the KColoring to QUBO reduction logic.
 fn reduce_kcoloring_to_qubo<K: KValue>(
     problem: &KColoring<K, SimpleGraph>,
-) -> ReductionKColoringToQUBO<K> {
+) -> Result<ReductionKColoringToQUBO<K>, crate::rules::ReductionError> {
     let k = problem.num_colors();
     let n = problem.graph().num_vertices();
     let edges = problem.graph().edges();
-    let nq = n * k;
-
-    // Penalty must be large enough to enforce one-hot constraints
-    // P1 for one-hot, P2 for edge conflicts; use same penalty
-    let penalty = 1.0 + n as f64;
-
-    let mut matrix = vec![vec![0.0; nq]; nq];
-
-    // One-hot penalty: P1*sum_v (1 - sum_c x_{v,c})^2
+    let overflow = |operation| {
+        crate::rules::ReductionError::integer_overflow::<KColoring<K, SimpleGraph>, QUBO<i64>>(
+            operation,
+        )
+    };
+    let (nq, penalty, feasible_energy) = coloring_qubo_parameters::<K>(n, k)?;
+
+    let diagonal_penalty = penalty
+        .checked_mul(-2)
+        .ok_or_else(|| overflow("computing a coloring diagonal coefficient"))?;
+    let one_hot_interaction = penalty
+        .checked_mul(4)
+        .ok_or_else(|| overflow("computing a one-hot interaction coefficient"))?;
+
+    let mut matrix = vec![vec![0i64; nq]; nq];
+
+    // Twice the former half-integral objective keeps every coefficient integral.
+    // One-hot penalty: 2P*sum_v (1 - sum_c x_{v,c})^2
     // Expanding: (1 - sum_c x_{v,c})^2 = 1 - 2*sum_c x_{v,c} + (sum_c x_{v,c})^2
     // = 1 - 2*sum_c x_{v,c} + sum_c x_{v,c}^2 + 2*sum_{c<c'} x_{v,c}*x_{v,c'}
     // Since x^2 = x for binary: = 1 - sum_c x_{v,c} + 2*sum_{c<c'} x_{v,c}*x_{v,c'}
     for v in 0..n {
         for c in 0..k {
             let idx = v * k + c;
-            // Diagonal: -P1 (from the linear term -sum_c x_{v,c})
-            matrix[idx][idx] -= penalty;
+            // Diagonal: -2P
+            matrix[idx][idx] = matrix[idx][idx]
+                .checked_add(diagonal_penalty)
+                .ok_or_else(|| overflow("adding a coloring diagonal coefficient"))?;
         }
-        // Off-diagonal within same vertex: 2*P1 for each pair of colors
+        // Off-diagonal within same vertex: 4P for each pair of colors
         for c1 in 0..k {
             for c2 in (c1 + 1)..k {
                 let idx1 = v * k + c1;
                 let idx2 = v * k + c2;
-                matrix[idx1][idx2] += 2.0 * penalty;
+                matrix[idx1][idx2] = matrix[idx1][idx2]
+                    .checked_add(one_hot_interaction)
+                    .ok_or_else(|| overflow("adding a one-hot interaction coefficient"))?;
             }
         }
     }
 
-    // Edge penalty: P2*sum_{(u,v) in E} sum_c x_{u,c}*x_{v,c}
-    let edge_penalty = penalty / 2.0;
+    // Edge penalty: P*sum_{(u,v) in E} sum_c x_{u,c}*x_{v,c}
     for (u, v) in &edges {
         for c in 0..k {
             let idx_u = u * k + c;
@@ -91,26 +162,36 @@ fn reduce_kcoloring_to_qubo<K: KValue>(
             } else {
                 (idx_v, idx_u)
             };
-            matrix[i][j] += edge_penalty;
+            matrix[i][j] = matrix[i][j]
+                .checked_add(penalty)
+                .ok_or_else(|| overflow("adding an edge-conflict coefficient"))?;
         }
     }
 
-    ReductionKColoringToQUBO {
-        target: QUBO::from_matrix(matrix),
+    Ok(ReductionKColoringToQUBO {
+        target: QUBO::from_matrix(matrix).map_err(|message| {
+            crate::rules::ReductionError::construction::<KColoring<K, SimpleGraph>, QUBO<i64>>(
+                message,
+            )
+        })?,
         num_vertices: n,
         num_colors: k,
+        feasible_energy,
         _phantom: std::marker::PhantomData,
-    }
+    })
 }
 
 // Register only the KN variant in the reduction graph
 #[reduction(
-    overhead = { num_vars = "num_vertices^2" }
+    aggregate = custom,
+    transform = exact {
+        num_vars = "num_vertices * num_colors",
+    }
 )]
-impl ReduceTo<QUBO<f64>> for KColoring<KN, SimpleGraph> {
+impl ReduceTo<QUBO<i64>> for KColoring<KN, SimpleGraph> {
     type Result = ReductionKColoringToQUBO<KN>;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         reduce_kcoloring_to_qubo(self)
     }
 }
@@ -118,9 +199,11 @@ impl ReduceTo<QUBO<f64>> for KColoring<KN, SimpleGraph> {
 // Additional concrete impls for tests (not registered in reduction graph)
 macro_rules! impl_kcoloring_to_qubo {
     ($($ktype:ty),+) => {$(
-        impl ReduceTo<QUBO<f64>> for KColoring<$ktype, SimpleGraph> {
+        impl ReduceTo<QUBO<i64>> for KColoring<$ktype, SimpleGraph> {
             type Result = ReductionKColoringToQUBO<$ktype>;
-            fn reduce_to(&self) -> Self::Result { reduce_kcoloring_to_qubo(self) }
+            fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+                reduce_kcoloring_to_qubo(self)
+            }
         }
     )+};
 }
@@ -137,11 +220,14 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             let (n, edges) = crate::topology::small_graphs::house();
             let source = KColoring::<KN, _>::with_k(SimpleGraph::new(n, edges), 3);
-            crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
+            crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 2, 2, 1, 0],
-                    target_config: vec![0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0],
+                    source_config: serde_json::json!(vec![1, 2, 2, 1, 0]),
+                    target_config: serde_json::json!(vec![
+                        false, true, false, false, false, true, false, false, true, false, true,
+                        false, true, false, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/consecutiveblockminimization_ilp.rs b/src/rules/consecutiveblockminimization_ilp.rs
index f63ff9770..ca25d2c2f 100644
--- a/src/rules/consecutiveblockminimization_ilp.rs
+++ b/src/rules/consecutiveblockminimization_ilp.rs
@@ -24,22 +24,29 @@ impl ReductionResult for ReductionCBMToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Decode the column permutation from x_{c,p}
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         one_hot_decode(target_solution, self.num_cols, self.num_cols, 0)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_cols * num_cols + num_rows * num_cols + num_rows * num_cols",
         num_constraints = "num_cols + num_cols + num_rows * num_cols + num_rows + num_rows * num_cols + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for ConsecutiveBlockMinimization {
     type Result = ReductionCBMToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.num_rows();
         let n = self.num_cols();
 
@@ -65,13 +72,13 @@ impl ReduceTo<ILP<bool>> for ConsecutiveBlockMinimization {
             for p in 0..n {
                 let a_idx = a_offset + r * n + p;
                 // a_{r,p} - sum_c A_{r,c} * x_{c,p} = 0
-                let mut terms = vec![(a_idx, 1.0)];
+                let mut terms = vec![(a_idx, 1)];
                 for c in 0..n {
                     if self.matrix()[r][c] {
-                        terms.push((x_offset + c * n + p, -1.0));
+                        terms.push((x_offset + c * n + p, -1));
                     }
                 }
-                constraints.push(LinearConstraint::eq(terms, 0.0));
+                constraints.push(LinearConstraint::eq(terms, 0));
             }
         }
 
@@ -80,7 +87,7 @@ impl ReduceTo<ILP<bool>> for ConsecutiveBlockMinimization {
             // b_{r,0} = a_{r,0}
             let b_idx = b_offset + r * n;
             let a_idx = a_offset + r * n;
-            constraints.push(LinearConstraint::eq(vec![(b_idx, 1.0), (a_idx, -1.0)], 0.0));
+            constraints.push(LinearConstraint::eq(vec![(b_idx, 1), (a_idx, -1)], 0));
 
             // b_{r,p} >= a_{r,p} - a_{r,p-1} for p > 0
             for p in 1..n {
@@ -88,8 +95,8 @@ impl ReduceTo<ILP<bool>> for ConsecutiveBlockMinimization {
                 let a_cur = a_offset + r * n + p;
                 let a_prev = a_offset + r * n + (p - 1);
                 constraints.push(LinearConstraint::ge(
-                    vec![(b_idx, 1.0), (a_cur, -1.0), (a_prev, 1.0)],
-                    0.0,
+                    vec![(b_idx, 1), (a_cur, -1), (a_prev, 1)],
+                    0,
                 ));
             }
         }
@@ -98,16 +105,17 @@ impl ReduceTo<ILP<bool>> for ConsecutiveBlockMinimization {
         let mut bound_terms = Vec::new();
         for r in 0..m {
             for p in 0..n {
-                bound_terms.push((b_offset + r * n + p, 1.0));
+                bound_terms.push((b_offset + r * n + p, 1));
             }
         }
-        constraints.push(LinearConstraint::le(bound_terms, self.bound() as f64));
+        constraints.push(LinearConstraint::le(bound_terms, self.bound()));
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionCBMToILP {
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionCBMToILP {
             target,
             num_cols: n,
-        }
+        })
     }
 }
 
diff --git a/src/rules/consecutiveonesmatrixaugmentation_ilp.rs b/src/rules/consecutiveonesmatrixaugmentation_ilp.rs
index 41a475898..0941ff0a7 100644
--- a/src/rules/consecutiveonesmatrixaugmentation_ilp.rs
+++ b/src/rules/consecutiveonesmatrixaugmentation_ilp.rs
@@ -25,21 +25,29 @@ impl ReductionResult for ReductionCOMAToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         one_hot_decode(target_solution, self.num_cols, self.num_cols, 0)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_cols * num_cols + 5 * num_rows * num_cols",
         num_constraints = "num_cols + num_cols + num_rows * num_cols + 2 * num_rows + num_rows + 3 * num_rows * num_cols + 4 * num_rows * num_cols + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for ConsecutiveOnesMatrixAugmentation {
     type Result = ReductionCOMAToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.num_rows();
         let n = self.num_cols();
 
@@ -67,42 +75,50 @@ impl ReduceTo<ILP<bool>> for ConsecutiveOnesMatrixAugmentation {
         for r in 0..m {
             for p in 0..n {
                 let a_idx = a_off + r * n + p;
-                let mut terms = vec![(a_idx, 1.0)];
+                let mut terms = vec![(a_idx, 1)];
                 for c in 0..n {
                     if self.matrix()[r][c] {
-                        terms.push((x_off + c * n + p, -1.0));
+                        terms.push((x_off + c * n + p, -1));
                     }
                 }
-                constraints.push(LinearConstraint::eq(terms, 0.0));
+                constraints.push(LinearConstraint::eq(terms, 0));
             }
         }
 
         // Per-row interval constraints
         for r in 0..m {
-            let beta_r: f64 = if self.matrix()[r].iter().any(|&v| v) {
-                1.0
+            let beta_r: i64 = if self.matrix()[r].iter().any(|&v| v) {
+                1
             } else {
-                0.0
+                0
             };
 
             // sum_p l_{r,p} = beta_r
-            let l_terms: Vec<(usize, f64)> = (0..n).map(|p| (l_off + r * n + p, 1.0)).collect();
+            let l_terms: Vec<(usize, i64)> = (0..n).map(|p| (l_off + r * n + p, 1)).collect();
             constraints.push(LinearConstraint::eq(l_terms, beta_r));
 
             // sum_p u_{r,p} = beta_r
-            let u_terms: Vec<(usize, f64)> = (0..n).map(|p| (u_off + r * n + p, 1.0)).collect();
+            let u_terms: Vec<(usize, i64)> = (0..n).map(|p| (u_off + r * n + p, 1)).collect();
             constraints.push(LinearConstraint::eq(u_terms, beta_r));
 
             // sum_p p*l_{r,p} <= sum_p p*u_{r,p} + (n-1)*(1 - beta_r)
             // => sum_p p*l_{r,p} - sum_p p*u_{r,p} <= (n-1)*(1 - beta_r)
             let mut order_terms = Vec::new();
             for p in 0..n {
-                order_terms.push((l_off + r * n + p, p as f64));
-                order_terms.push((u_off + r * n + p, -(p as f64)));
+                let p_i64 = <Self as ReduceTo<ILP<bool>>>::exact_i64(
+                    p,
+                    "encoding a matrix column position",
+                )?;
+                order_terms.push((l_off + r * n + p, p_i64));
+                order_terms.push((u_off + r * n + p, -p_i64));
             }
+            let last_position = <Self as ReduceTo<ILP<bool>>>::exact_i64(
+                n.saturating_sub(1),
+                "encoding the final matrix column position",
+            )?;
             constraints.push(LinearConstraint::le(
                 order_terms,
-                (n as f64 - 1.0) * (1.0 - beta_r),
+                last_position * (1 - beta_r),
             ));
 
             for p in 0..n {
@@ -111,43 +127,42 @@ impl ReduceTo<ILP<bool>> for ConsecutiveOnesMatrixAugmentation {
                 let f_idx = f_off + r * n + p;
 
                 // h_{r,p} <= sum_{q=0}^{p} l_{r,q}
-                let l_prefix: Vec<(usize, f64)> =
-                    (0..=p).map(|q| (l_off + r * n + q, -1.0)).collect();
-                let mut h_le_l = vec![(h_idx, 1.0)];
+                let l_prefix: Vec<(usize, i64)> =
+                    (0..=p).map(|q| (l_off + r * n + q, -1)).collect();
+                let mut h_le_l = vec![(h_idx, 1)];
                 h_le_l.extend(l_prefix);
-                constraints.push(LinearConstraint::le(h_le_l, 0.0));
+                constraints.push(LinearConstraint::le(h_le_l, 0));
 
                 // h_{r,p} <= sum_{q=p}^{n-1} u_{r,q}
-                let u_suffix: Vec<(usize, f64)> =
-                    (p..n).map(|q| (u_off + r * n + q, -1.0)).collect();
-                let mut h_le_u = vec![(h_idx, 1.0)];
+                let u_suffix: Vec<(usize, i64)> = (p..n).map(|q| (u_off + r * n + q, -1)).collect();
+                let mut h_le_u = vec![(h_idx, 1)];
                 h_le_u.extend(u_suffix);
-                constraints.push(LinearConstraint::le(h_le_u, 0.0));
+                constraints.push(LinearConstraint::le(h_le_u, 0));
 
                 // h_{r,p} >= sum_{q=0}^{p} l_{r,q} + sum_{q=p}^{n-1} u_{r,q} - 1
-                let mut h_ge_terms = vec![(h_idx, 1.0)];
+                let mut h_ge_terms = vec![(h_idx, 1)];
                 for q in 0..=p {
-                    h_ge_terms.push((l_off + r * n + q, -1.0));
+                    h_ge_terms.push((l_off + r * n + q, -1));
                 }
                 for q in p..n {
-                    h_ge_terms.push((u_off + r * n + q, -1.0));
+                    h_ge_terms.push((u_off + r * n + q, -1));
                 }
-                constraints.push(LinearConstraint::ge(h_ge_terms, -1.0));
+                constraints.push(LinearConstraint::ge(h_ge_terms, -1));
 
                 // a_{r,p} <= h_{r,p}
-                constraints.push(LinearConstraint::le(vec![(a_idx, 1.0), (h_idx, -1.0)], 0.0));
+                constraints.push(LinearConstraint::le(vec![(a_idx, 1), (h_idx, -1)], 0));
 
                 // h_{r,p} <= a_{r,p} + f_{r,p}
                 constraints.push(LinearConstraint::le(
-                    vec![(h_idx, 1.0), (a_idx, -1.0), (f_idx, -1.0)],
-                    0.0,
+                    vec![(h_idx, 1), (a_idx, -1), (f_idx, -1)],
+                    0,
                 ));
 
                 // f_{r,p} <= h_{r,p}
-                constraints.push(LinearConstraint::le(vec![(f_idx, 1.0), (h_idx, -1.0)], 0.0));
+                constraints.push(LinearConstraint::le(vec![(f_idx, 1), (h_idx, -1)], 0));
 
                 // f_{r,p} + a_{r,p} <= 1
-                constraints.push(LinearConstraint::le(vec![(f_idx, 1.0), (a_idx, 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(f_idx, 1), (a_idx, 1)], 1));
             }
         }
 
@@ -155,16 +170,17 @@ impl ReduceTo<ILP<bool>> for ConsecutiveOnesMatrixAugmentation {
         let mut budget_terms = Vec::new();
         for r in 0..m {
             for p in 0..n {
-                budget_terms.push((f_off + r * n + p, 1.0));
+                budget_terms.push((f_off + r * n + p, 1));
             }
         }
-        constraints.push(LinearConstraint::le(budget_terms, self.bound() as f64));
+        constraints.push(LinearConstraint::le(budget_terms, self.bound()));
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionCOMAToILP {
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionCOMAToILP {
             target,
             num_cols: n,
-        }
+        })
     }
 }
 
@@ -182,17 +198,19 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Row 0: [1,0,1] needs 1 flip (the middle 0), cost=1
             // Row 1: [0,1,1] needs 0 flips, cost=0
             // Total = 1 <= 1
-            let reduction: ReductionCOMAToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+            let reduction: ReductionCOMAToILP =
+                ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
             let ilp_solver = crate::solvers::ILPSolver::new();
             let target_config = ilp_solver
                 .solve(reduction.target_problem())
                 .expect("ILP should be solvable");
-            let extracted = reduction.extract_solution(&target_config);
+            let extracted = reduction.extract_solution(&target_config).unwrap();
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: extracted,
-                    target_config,
+                    source_config: serde_json::json!(extracted),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/consecutiveonessubmatrix_ilp.rs b/src/rules/consecutiveonessubmatrix_ilp.rs
index 0703410b1..d279e0913 100644
--- a/src/rules/consecutiveonessubmatrix_ilp.rs
+++ b/src/rules/consecutiveonessubmatrix_ilp.rs
@@ -22,22 +22,35 @@ impl ReductionResult for ReductionCOSToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Output the selection bits s_c (first num_cols variables)
-        target_solution[..self.num_cols].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // Output the selection bits s_c (first num_cols variables)
+            target_solution[..self.num_cols]
+                .iter()
+                .map(|&value| value == 1)
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_cols + num_cols * bound + 5 * num_rows * bound",
-        num_constraints = "1 + num_cols + bound + num_rows * bound + 2 * num_rows + num_rows + 3 * num_rows * bound + 4 * num_rows * bound",
+        num_constraints = "2 + num_cols + bound + 3 * num_rows + 8 * num_rows * bound",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for ConsecutiveOnesSubmatrix {
     type Result = ReductionCOSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.num_rows();
         let n = self.num_cols();
         let k = self.bound() as usize;
@@ -62,66 +75,64 @@ impl ReduceTo<ILP<bool>> for ConsecutiveOnesSubmatrix {
         let mut constraints = Vec::new();
 
         // sum_c s_c = K
-        let s_terms: Vec<(usize, f64)> = (0..n).map(|c| (s_off + c, 1.0)).collect();
-        constraints.push(LinearConstraint::eq(s_terms, k as f64));
+        let s_terms: Vec<(usize, i64)> = (0..n).map(|c| (s_off + c, 1)).collect();
+        constraints.push(LinearConstraint::eq(
+            s_terms,
+            <Self as ReduceTo<ILP<bool>>>::exact_i64(k, "encoding the selected column count")?,
+        ));
 
         // sum_p x_{c,p} = s_c for all c
         for c in 0..n {
-            let mut terms: Vec<(usize, f64)> = (0..k).map(|p| (x_off + c * k + p, 1.0)).collect();
-            terms.push((s_off + c, -1.0));
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            let mut terms: Vec<(usize, i64)> = (0..k).map(|p| (x_off + c * k + p, 1)).collect();
+            terms.push((s_off + c, -1));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // sum_c x_{c,p} = 1 for all p in {0, ..., K-1}
         for p in 0..k {
-            let terms: Vec<(usize, f64)> = (0..n).map(|c| (x_off + c * k + p, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|c| (x_off + c * k + p, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // a_{r,p} = sum_c A_{r,c} * x_{c,p}
         for r in 0..m {
             for p in 0..k {
                 let a_idx = a_off + r * k + p;
-                let mut terms = vec![(a_idx, 1.0)];
+                let mut terms = vec![(a_idx, 1)];
                 for c in 0..n {
                     if self.matrix()[r][c] {
-                        terms.push((x_off + c * k + p, -1.0));
+                        terms.push((x_off + c * k + p, -1));
                     }
                 }
-                constraints.push(LinearConstraint::eq(terms, 0.0));
+                constraints.push(LinearConstraint::eq(terms, 0));
             }
         }
 
         // C1P interval constraints on the K-position permuted submatrix
         for r in 0..m {
-            // beta_r = 1 if row r has at least one 1 in the original matrix
-            // (among any column, not just selected ones — the ILP will determine)
-            // We use beta_r = 1 for rows that have any 1, to allow intervals
-            let beta_r: f64 = if self.matrix()[r].iter().any(|&v| v) {
-                1.0
-            } else {
-                0.0
-            };
-
-            // sum_p l_{r,p} = beta_r
-            let l_terms: Vec<(usize, f64)> = (0..k).map(|p| (l_off + r * k + p, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(l_terms, beta_r));
-
-            // sum_p u_{r,p} = beta_r
-            let u_terms: Vec<(usize, f64)> = (0..k).map(|p| (u_off + r * k + p, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(u_terms, beta_r));
-
-            // sum_p p*l_{r,p} <= sum_p p*u_{r,p} + (K-1)*(1 - beta_r)
+            // A row has either no interval (all selected entries are zero), or
+            // exactly one pair of left and right boundaries. Existing a <= h
+            // constraints force the latter whenever a selected entry is one.
+            let l_terms: Vec<(usize, i64)> = (0..k).map(|p| (l_off + r * k + p, 1)).collect();
+            constraints.push(LinearConstraint::le(l_terms.clone(), 1));
+
+            let u_terms: Vec<(usize, i64)> = (0..k).map(|p| (u_off + r * k + p, 1)).collect();
+            let mut boundary_count_terms = l_terms;
+            boundary_count_terms.extend(u_terms.into_iter().map(|(index, _)| (index, -1)));
+            constraints.push(LinearConstraint::eq(boundary_count_terms, 0));
+
+            // The left boundary cannot occur after the right boundary
             if k > 0 {
                 let mut order_terms = Vec::new();
                 for p in 0..k {
-                    order_terms.push((l_off + r * k + p, p as f64));
-                    order_terms.push((u_off + r * k + p, -(p as f64)));
+                    let p_i64 = <Self as ReduceTo<ILP<bool>>>::exact_i64(
+                        p,
+                        "encoding a selected-column position",
+                    )?;
+                    order_terms.push((l_off + r * k + p, p_i64));
+                    order_terms.push((u_off + r * k + p, -p_i64));
                 }
-                constraints.push(LinearConstraint::le(
-                    order_terms,
-                    (k as f64 - 1.0).max(0.0) * (1.0 - beta_r),
-                ));
+                constraints.push(LinearConstraint::le(order_terms, 0));
             }
 
             for p in 0..k {
@@ -130,44 +141,44 @@ impl ReduceTo<ILP<bool>> for ConsecutiveOnesSubmatrix {
                 let f_idx = f_off + r * k + p;
 
                 // h_{r,p} <= sum_{q=0}^{p} l_{r,q}
-                let mut h_le_l = vec![(h_idx, 1.0)];
+                let mut h_le_l = vec![(h_idx, 1)];
                 for q in 0..=p {
-                    h_le_l.push((l_off + r * k + q, -1.0));
+                    h_le_l.push((l_off + r * k + q, -1));
                 }
-                constraints.push(LinearConstraint::le(h_le_l, 0.0));
+                constraints.push(LinearConstraint::le(h_le_l, 0));
 
                 // h_{r,p} <= sum_{q=p}^{K-1} u_{r,q}
-                let mut h_le_u = vec![(h_idx, 1.0)];
+                let mut h_le_u = vec![(h_idx, 1)];
                 for q in p..k {
-                    h_le_u.push((u_off + r * k + q, -1.0));
+                    h_le_u.push((u_off + r * k + q, -1));
                 }
-                constraints.push(LinearConstraint::le(h_le_u, 0.0));
+                constraints.push(LinearConstraint::le(h_le_u, 0));
 
                 // h_{r,p} >= sum_{q=0}^{p} l_{r,q} + sum_{q=p}^{K-1} u_{r,q} - 1
-                let mut h_ge_terms = vec![(h_idx, 1.0)];
+                let mut h_ge_terms = vec![(h_idx, 1)];
                 for q in 0..=p {
-                    h_ge_terms.push((l_off + r * k + q, -1.0));
+                    h_ge_terms.push((l_off + r * k + q, -1));
                 }
                 for q in p..k {
-                    h_ge_terms.push((u_off + r * k + q, -1.0));
+                    h_ge_terms.push((u_off + r * k + q, -1));
                 }
-                constraints.push(LinearConstraint::ge(h_ge_terms, -1.0));
+                constraints.push(LinearConstraint::ge(h_ge_terms, -1));
 
                 // a_{r,p} <= h_{r,p}  — every 1 must be inside the interval
-                constraints.push(LinearConstraint::le(vec![(a_idx, 1.0), (h_idx, -1.0)], 0.0));
+                constraints.push(LinearConstraint::le(vec![(a_idx, 1), (h_idx, -1)], 0));
 
                 // For C1P (no augmentation): the interval must exactly cover the 1s
                 // h_{r,p} <= a_{r,p} + f_{r,p} — position inside interval but 0 costs a flip
                 constraints.push(LinearConstraint::le(
-                    vec![(h_idx, 1.0), (a_idx, -1.0), (f_idx, -1.0)],
-                    0.0,
+                    vec![(h_idx, 1), (a_idx, -1), (f_idx, -1)],
+                    0,
                 ));
 
                 // f_{r,p} <= h_{r,p}
-                constraints.push(LinearConstraint::le(vec![(f_idx, 1.0), (h_idx, -1.0)], 0.0));
+                constraints.push(LinearConstraint::le(vec![(f_idx, 1), (h_idx, -1)], 0));
 
                 // f_{r,p} + a_{r,p} <= 1
-                constraints.push(LinearConstraint::le(vec![(f_idx, 1.0), (a_idx, 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(f_idx, 1), (a_idx, 1)], 1));
             }
         }
 
@@ -176,18 +187,19 @@ impl ReduceTo<ILP<bool>> for ConsecutiveOnesSubmatrix {
         let mut flip_terms = Vec::new();
         for r in 0..m {
             for p in 0..k {
-                flip_terms.push((f_off + r * k + p, 1.0));
+                flip_terms.push((f_off + r * k + p, 1));
             }
         }
         if !flip_terms.is_empty() {
-            constraints.push(LinearConstraint::eq(flip_terms, 0.0));
+            constraints.push(LinearConstraint::eq(flip_terms, 0));
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionCOSToILP {
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionCOSToILP {
             target,
             num_cols: n,
-        }
+        })
     }
 }
 
@@ -206,17 +218,19 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 ],
                 3,
             );
-            let reduction: ReductionCOSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+            let reduction: ReductionCOSToILP =
+                ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
             let ilp_solver = crate::solvers::ILPSolver::new();
             let target_config = ilp_solver
                 .solve(reduction.target_problem())
                 .expect("ILP should be solvable");
-            let extracted = reduction.extract_solution(&target_config);
+            let extracted = reduction.extract_solution(&target_config).unwrap();
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: extracted,
-                    target_config,
+                    source_config: serde_json::json!(extracted),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/consistencyofdatabasefrequencytables_ilp.rs b/src/rules/consistencyofdatabasefrequencytables_ilp.rs
index a900f93de..71710293c 100644
--- a/src/rules/consistencyofdatabasefrequencytables_ilp.rs
+++ b/src/rules/consistencyofdatabasefrequencytables_ilp.rs
@@ -9,6 +9,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::ConsistencyOfDatabaseFrequencyTables;
 use crate::reduction;
+use crate::rules::ilp_helpers::mccormick_product;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing ConsistencyOfDatabaseFrequencyTables to ILP.
@@ -56,8 +57,8 @@ impl ReductionCDFTToILP {
 
     /// Encode a satisfying source assignment as a concrete ILP variable vector.
     #[cfg_attr(not(test), allow(dead_code))]
-    pub(crate) fn encode_source_solution(&self, source_solution: &[usize]) -> Vec<usize> {
-        let mut target_solution = vec![0usize; self.target.num_vars];
+    pub(crate) fn encode_source_solution(&self, source_solution: &[usize]) -> Vec<i64> {
+        let mut target_solution = vec![0_i64; self.target.num_vars()];
         let num_attributes = self.source.num_attributes();
 
         for object in 0..self.source.num_objects() {
@@ -90,36 +91,55 @@ impl ReductionResult for ReductionCDFTToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let mut source_solution = Vec::with_capacity(self.source.num_assignment_variables());
-        for object in 0..self.source.num_objects() {
-            for (attribute, &domain_size) in self.source.attribute_domains().iter().enumerate() {
-                let value = (0..domain_size)
-                    .find(|&candidate| {
-                        target_solution
-                            .get(self.assignment_var_index(object, attribute, candidate))
-                            .copied()
-                            .unwrap_or(0)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let mut source_solution = Vec::with_capacity(self.source.num_assignment_variables());
+            for object in 0..self.source.num_objects() {
+                for (attribute, &domain_size) in self.source.attribute_domains().iter().enumerate()
+                {
+                    let mut selected = (0..domain_size).filter(|&candidate| {
+                        target_solution[self.assignment_var_index(object, attribute, candidate)]
                             == 1
-                    })
-                    .unwrap_or(0);
-                source_solution.push(value);
+                    });
+                    let value = match (selected.next(), selected.next()) {
+                        (Some(value), None) => value,
+                        (None, _) => {
+                            return Err(crate::rules::ExtractionError::invalid(format!(
+                                "object {object}, attribute {attribute} has no selected value"
+                            )))
+                        }
+                        (Some(_), Some(_)) => {
+                            return Err(crate::rules::ExtractionError::invalid(format!(
+                                "object {object}, attribute {attribute} has multiple selected values"
+                            )))
+                        }
+                    };
+                    source_solution.push(value);
+                }
             }
-        }
-        source_solution
+            source_solution
+        })
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "num_assignment_indicators + num_auxiliary_frequency_indicators",
-        num_constraints = "num_assignment_variables + num_known_values + num_frequency_cells + 3 * num_auxiliary_frequency_indicators",
+    transform = exact {
+        num_vars = "num_objects * total_domain_size + num_objects * num_frequency_cells",
+        num_constraints = "num_objects * num_attributes + num_known_values + num_frequency_cells + 3 * num_objects * num_frequency_cells",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for ConsistencyOfDatabaseFrequencyTables {
     type Result = ReductionCDFTToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let source = self.clone();
         let helper = ReductionCDFTToILP {
             target: ILP::empty(),
@@ -136,9 +156,9 @@ impl ReduceTo<ILP<bool>> for ConsistencyOfDatabaseFrequencyTables {
         for object in 0..source.num_objects() {
             for (attribute, &domain_size) in source.attribute_domains().iter().enumerate() {
                 let terms = (0..domain_size)
-                    .map(|value| (helper.assignment_var_index(object, attribute, value), 1.0))
+                    .map(|value| (helper.assignment_var_index(object, attribute, value), 1))
                     .collect();
-                constraints.push(LinearConstraint::eq(terms, 1.0));
+                constraints.push(LinearConstraint::eq(terms, 1));
             }
         }
 
@@ -150,9 +170,9 @@ impl ReduceTo<ILP<bool>> for ConsistencyOfDatabaseFrequencyTables {
                         known_value.attribute(),
                         known_value.value(),
                     ),
-                    1.0,
+                    1,
                 )],
-                1.0,
+                1,
             ));
         }
 
@@ -166,26 +186,19 @@ impl ReduceTo<ILP<bool>> for ConsistencyOfDatabaseFrequencyTables {
                         .map(|object| {
                             (
                                 helper.auxiliary_var_index(table_index, object, value_a, value_b),
-                                1.0,
+                                1,
                             )
                         })
                         .collect();
-                    constraints.push(LinearConstraint::eq(
-                        count_terms,
-                        table.counts()[value_a][value_b] as f64,
-                    ));
+                    let count = table.counts()[value_a][value_b];
+                    constraints.push(LinearConstraint::eq(count_terms, count));
 
                     for object in 0..source.num_objects() {
                         let z = helper.auxiliary_var_index(table_index, object, value_a, value_b);
                         let y_a = helper.assignment_var_index(object, table.attribute_a(), value_a);
                         let y_b = helper.assignment_var_index(object, table.attribute_b(), value_b);
 
-                        constraints.push(LinearConstraint::le(vec![(z, 1.0), (y_a, -1.0)], 0.0));
-                        constraints.push(LinearConstraint::le(vec![(z, 1.0), (y_b, -1.0)], 0.0));
-                        constraints.push(LinearConstraint::ge(
-                            vec![(z, 1.0), (y_a, -1.0), (y_b, -1.0)],
-                            -1.0,
-                        ));
+                        constraints.extend(mccormick_product(z, y_a, y_b));
                     }
                 }
             }
@@ -196,9 +209,10 @@ impl ReduceTo<ILP<bool>> for ConsistencyOfDatabaseFrequencyTables {
             constraints,
             vec![],
             ObjectiveSense::Minimize,
-        );
+        )
+        .map_err(Self::target_construction)?;
 
-        ReductionCDFTToILP { target, source }
+        Ok(ReductionCDFTToILP { target, source })
     }
 }
 
diff --git a/src/rules/cost.rs b/src/rules/cost.rs
deleted file mode 100644
index 7678d4d87..000000000
--- a/src/rules/cost.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-//! Cost functions for reduction path optimization.
-
-use crate::rules::registry::ReductionOverhead;
-use crate::types::ProblemSize;
-
-/// User-defined cost function for path optimization.
-pub trait PathCostFn {
-    /// Compute cost of taking an edge given current problem size.
-    fn edge_cost(&self, overhead: &ReductionOverhead, current_size: &ProblemSize) -> f64;
-}
-
-/// Minimize a single output field.
-pub struct Minimize(pub &'static str);
-
-impl PathCostFn for Minimize {
-    fn edge_cost(&self, overhead: &ReductionOverhead, size: &ProblemSize) -> f64 {
-        overhead.evaluate_output_size(size).get(self.0).unwrap_or(0) as f64
-    }
-}
-
-/// Minimize number of reduction steps.
-pub struct MinimizeSteps;
-
-impl PathCostFn for MinimizeSteps {
-    fn edge_cost(&self, _overhead: &ReductionOverhead, _size: &ProblemSize) -> f64 {
-        1.0
-    }
-}
-
-/// Minimize total output size (sum of all output field values).
-///
-/// Prefers reduction paths that produce smaller intermediate and final problems.
-/// Breaks ties that `MinimizeSteps` cannot resolve (e.g., two 2-step paths
-/// where one produces 144 ILP variables and the other 1,332).
-pub struct MinimizeOutputSize;
-
-impl PathCostFn for MinimizeOutputSize {
-    fn edge_cost(&self, overhead: &ReductionOverhead, size: &ProblemSize) -> f64 {
-        let output = overhead.evaluate_output_size(size);
-        output.total() as f64
-    }
-}
-
-/// Minimize steps first, then use output size as tiebreaker.
-///
-/// Each edge has a primary cost of `STEP_WEIGHT` (ensuring fewer-step paths
-/// always win) plus a small overhead-based cost that breaks ties between
-/// equal-step paths.
-pub struct MinimizeStepsThenOverhead;
-
-impl PathCostFn for MinimizeStepsThenOverhead {
-    fn edge_cost(&self, overhead: &ReductionOverhead, size: &ProblemSize) -> f64 {
-        // Use a large step weight to ensure step count dominates.
-        // The overhead tiebreaker uses log1p to compress the range,
-        // keeping it far smaller than STEP_WEIGHT for any realistic problem size.
-        const STEP_WEIGHT: f64 = 1e9;
-        let output = overhead.evaluate_output_size(size);
-        let overhead_tiebreaker = (1.0 + output.total() as f64).ln();
-        STEP_WEIGHT + overhead_tiebreaker
-    }
-}
-
-/// Custom cost function from closure.
-pub struct CustomCost<F>(pub F);
-
-impl<F: Fn(&ReductionOverhead, &ProblemSize) -> f64> PathCostFn for CustomCost<F> {
-    fn edge_cost(&self, overhead: &ReductionOverhead, size: &ProblemSize) -> f64 {
-        (self.0)(overhead, size)
-    }
-}
-
-#[cfg(test)]
-#[path = "../unit_tests/rules/cost.rs"]
-mod tests;
diff --git a/src/rules/decisionmaximumindependentset_integralflowbundles.rs b/src/rules/decisionmaximumindependentset_integralflowbundles.rs
new file mode 100644
index 000000000..7fdeab6b4
--- /dev/null
+++ b/src/rules/decisionmaximumindependentset_integralflowbundles.rs
@@ -0,0 +1,160 @@
+//! Unit-weight decision independent set to integral flow with bundles.
+//!
+//! Sahni (1974), Theorem 2.2(b)(iv), uses a cardinality threshold and repeated
+//! flow queries to recover an optimum. This direct rule preserves one decision
+//! query. An auxiliary binary path shifts the threshold to remain positive,
+//! including empty graphs and nonpositive source bounds.
+
+use crate::models::decision::Decision;
+use crate::models::graph::{IntegralFlowBundles, MaximumIndependentSet};
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::topology::{Graph, SimpleGraph};
+use crate::types::One;
+
+/// Result of a unit-weight independent-set decision reduction.
+#[derive(Debug, Clone)]
+pub struct ReductionDecisionMISToIFB {
+    target: IntegralFlowBundles,
+    num_source_vertices: usize,
+}
+
+impl ReductionResult for ReductionDecisionMISToIFB {
+    type Source = Decision<MaximumIndependentSet<SimpleGraph, One>>;
+    type Target = IntegralFlowBundles;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let feasible =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !feasible.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target flow must satisfy conservation, bundle capacities, and the requirement",
+            ));
+        }
+        Ok((0..self.num_source_vertices)
+            .map(|i| target_solution[2 * i + 1] == 1)
+            .collect())
+    }
+}
+
+/// Check all graph and bundle allocation counts before constructing the network.
+fn flow_dimensions(
+    n: usize,
+    m: usize,
+) -> Result<(usize, usize, usize), crate::rules::ReductionError> {
+    n.checked_add(3)
+        .zip(n.checked_add(1).and_then(|count| count.checked_mul(2)))
+        .zip(n.checked_add(m).and_then(|count| count.checked_add(1)))
+        .map(|((vertices, arcs), bundles)| (vertices, arcs, bundles))
+        .ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                Decision<MaximumIndependentSet<SimpleGraph, One>>,
+                IntegralFlowBundles,
+            >("counting independent-set flow paths and bundles")
+        })
+}
+
+/// Thresholds outside [0,n] have constant truth values for cardinality decisions.
+/// Map them to 0 and n+1, then account for the auxiliary unit of flow.
+fn flow_requirement(n: usize, bound: i64) -> Result<i64, crate::rules::ReductionError> {
+    let n = <Decision<MaximumIndependentSet<SimpleGraph, One>> as ReduceTo<
+        IntegralFlowBundles,
+    >>::exact_i64(n, "converting the independent-set vertex count")?;
+    let maximum_requirement = n.checked_add(2).ok_or_else(|| {
+        crate::rules::ReductionError::integer_overflow::<
+            Decision<MaximumIndependentSet<SimpleGraph, One>>,
+            IntegralFlowBundles,
+        >("shifting the independent-set decision threshold")
+    })?;
+    Ok(bound.clamp(0, maximum_requirement - 1) + 1)
+}
+
+#[reduction(
+    transform = exact {
+        num_vertices = "num_vertices + 3",
+        num_arcs = "2 * num_vertices + 2",
+        num_bundles = "num_edges + num_vertices + 1",
+    }
+)]
+impl ReduceTo<IntegralFlowBundles> for Decision<MaximumIndependentSet<SimpleGraph, One>> {
+    type Result = ReductionDecisionMISToIFB;
+
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let graph = self.inner().graph();
+        let n = graph.num_vertices();
+        let (num_vertices, num_arcs, num_bundles) = flow_dimensions(n, graph.num_edges())?;
+        let requirement = flow_requirement(n, *self.bound())?;
+        let sink = n + 2;
+        let mut arcs = Vec::with_capacity(num_arcs);
+        // The final path is auxiliary; the other n paths represent source vertices.
+        for i in 0..=n {
+            arcs.push((0, i + 1));
+            arcs.push((i + 1, sink));
+        }
+        let mut bundles = Vec::with_capacity(num_bundles);
+        let mut capacities = Vec::with_capacity(num_bundles);
+        // Mixing incoming/outgoing arcs keeps the two bundle members distinct
+        // even for a self-loop. Conservation makes its constraint 2*f_i <= 1.
+        for (u, v) in graph.edges() {
+            bundles.push(vec![2 * u, 2 * v + 1]);
+            capacities.push(1);
+        }
+        for i in 0..=n {
+            bundles.push(vec![2 * i, 2 * i + 1]);
+            capacities.push(2);
+        }
+        let target = IntegralFlowBundles::new(
+            crate::topology::DirectedGraph::new(num_vertices, arcs),
+            0,
+            sink,
+            bundles,
+            capacities,
+            requirement,
+        );
+        Ok(ReductionDecisionMISToIFB {
+            target,
+            num_source_vertices: n,
+        })
+    }
+}
+
+#[cfg(feature = "example-db")]
+pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
+    use crate::export::SolutionPair;
+    use crate::solvers::BruteForce;
+    vec![crate::example_db::specs::RuleExampleSpec {
+        id: "decisionmaximumindependentset_to_integralflowbundles",
+        build: || {
+            let source = Decision::new(
+                MaximumIndependentSet::new(SimpleGraph::path(3), vec![One; 3]),
+                2,
+            );
+            let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source)
+                .expect("canonical reduction must succeed");
+            let target_witness = BruteForce::new()
+                .solve(reduction.target_problem())
+                .expect("canonical target evaluation must succeed")
+                .expect("the path has an independent set of size two");
+            let source_witness = reduction.extract_solution(&target_witness).unwrap();
+            crate::example_db::specs::assemble_rule_example(
+                &source,
+                reduction.target_problem(),
+                vec![SolutionPair {
+                    source_config: serde_json::json!(source_witness),
+                    target_config: serde_json::json!(target_witness),
+                }],
+            )
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/decisionmaximumindependentset_integralflowbundles.rs"]
+mod tests;
diff --git a/src/rules/decisionminimumdominatingset_minimumsummulticenter.rs b/src/rules/decisionminimumdominatingset_minimumsummulticenter.rs
index 807b03c34..60d57a4cb 100644
--- a/src/rules/decisionminimumdominatingset_minimumsummulticenter.rs
+++ b/src/rules/decisionminimumdominatingset_minimumsummulticenter.rs
@@ -1,50 +1,118 @@
 //! Reduction from Decision Minimum Dominating Set to Minimum Sum Multicenter.
 //!
-//! On unit-weight, unit-length graphs, choosing `K` centers with total distance
-//! `n - K` is exactly choosing a dominating set of size at most `K`.
+//! For K >= 0, add an isolated vertex and choose min(K, n) + 1 centers.
+//! Finite cost forces the isolated vertex to be a center. The optimum equals
+//! n - min(K, n) iff the original graph has a dominating set of size <= K.
+//! For K < 0, two added isolated vertices and one center force infeasibility.
 
 use crate::models::decision::Decision;
 use crate::models::graph::{MinimumDominatingSet, MinimumSumMulticenter};
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
-use crate::types::One;
+use crate::types::{Min, One, Or};
 
 /// Result of reducing DecisionMinimumDominatingSet to MinimumSumMulticenter.
 #[derive(Debug, Clone)]
 pub struct ReductionDecisionMinimumDominatingSetToMinimumSumMulticenter {
-    target: MinimumSumMulticenter<SimpleGraph, i32>,
+    target: MinimumSumMulticenter<SimpleGraph, i64>,
+    source_num_vertices: usize,
+    threshold: i64,
 }
 
 impl ReductionResult for ReductionDecisionMinimumDominatingSetToMinimumSumMulticenter {
     type Source = Decision<MinimumDominatingSet<SimpleGraph, One>>;
-    type Target = MinimumSumMulticenter<SimpleGraph, i32>;
+    type Target = MinimumSumMulticenter<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target placement does not certify a dominating set within the source bound",
+            ));
+        }
+        // Original vertices precede the auxiliary isolated vertices.
+        Ok(target_solution[..self.source_num_vertices].to_vec())
     }
 }
 
-#[reduction(overhead = { num_vertices = "num_vertices", num_edges = "num_edges" })]
-impl ReduceTo<MinimumSumMulticenter<SimpleGraph, i32>>
+impl crate::rules::AggregateReductionResult
+    for ReductionDecisionMinimumDominatingSetToMinimumSumMulticenter
+{
+    type Source = Decision<MinimumDominatingSet<SimpleGraph, One>>;
+    type Target = MinimumSumMulticenter<SimpleGraph, i64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, target_value: Min<i64>) -> Or {
+        Or(target_value.0 == Some(self.threshold))
+    }
+}
+
+#[reduction(
+    aggregate = custom,
+    transform = upper_bound { num_vertices = "num_vertices + 2", num_edges = "num_edges" }
+)]
+impl ReduceTo<MinimumSumMulticenter<SimpleGraph, i64>>
     for Decision<MinimumDominatingSet<SimpleGraph, One>>
 {
     type Result = ReductionDecisionMinimumDominatingSetToMinimumSumMulticenter;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let source_graph = self.inner().graph();
+        let n = source_graph.num_vertices();
+        let (target_n, centers, threshold) = multicenter_parameters(n, *self.bound())?;
         let target = MinimumSumMulticenter::new(
-            SimpleGraph::new(source_graph.num_vertices(), source_graph.edges()),
-            vec![1i32; source_graph.num_vertices()],
-            vec![1i32; source_graph.num_edges()],
-            self.k(),
+            SimpleGraph::new(target_n, source_graph.edges()),
+            vec![1i64; target_n],
+            vec![1i64; source_graph.num_edges()],
+            centers,
         );
-        ReductionDecisionMinimumDominatingSetToMinimumSumMulticenter { target }
+        Ok(
+            ReductionDecisionMinimumDominatingSetToMinimumSumMulticenter {
+                target,
+                source_num_vertices: n,
+                threshold,
+            },
+        )
+    }
+}
+
+/// Compute the construction's counts without allocating the graph, so numeric
+/// domain boundaries can be checked independently of available memory.
+fn multicenter_parameters(
+    n: usize,
+    bound: i64,
+) -> Result<(usize, usize, i64), crate::rules::ReductionError> {
+    type Source = Decision<MinimumDominatingSet<SimpleGraph, One>>;
+    type Target = MinimumSumMulticenter<SimpleGraph, i64>;
+    let overflow = || {
+        crate::rules::ReductionError::integer_overflow::<Source, Target>(
+            "encoding multicenter construction parameters",
+        )
+    };
+    let extra_vertices = if bound < 0 { 2 } else { 1 };
+    let target_n = n.checked_add(extra_vertices).ok_or_else(overflow)?;
+    let n_i64 = i64::try_from(n).map_err(|_| overflow())?;
+    if bound < 0 {
+        // Two auxiliary isolates cannot both be served by one center.
+        return Ok((target_n, 1, -1));
     }
+    // No subset contains more than n vertices, so these bounds are equivalent.
+    let q = bound.min(n_i64);
+    let q_usize = usize::try_from(q).map_err(|_| overflow())?;
+    // q <= n and n + 1 was checked above, so q + 1 cannot overflow.
+    Ok((target_n, q_usize + 1, n_i64 - q))
 }
 
 #[cfg(feature = "example-db")]
@@ -56,7 +124,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             crate::example_db::specs::rule_example_with_witness::<
                 _,
-                MinimumSumMulticenter<SimpleGraph, i32>,
+                MinimumSumMulticenter<SimpleGraph, i64>,
             >(
                 Decision::new(
                     MinimumDominatingSet::new(
@@ -69,8 +137,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     2,
                 ),
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1, 0, 0],
-                    target_config: vec![1, 0, 0, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, false, false, true, false, false]),
+                    target_config: serde_json::json!(vec![
+                        true, false, false, true, false, false, true
+                    ]),
                 },
             )
         },
diff --git a/src/rules/decisionminimumdominatingset_minmaxmulticenter.rs b/src/rules/decisionminimumdominatingset_minmaxmulticenter.rs
index 26af00e85..5bcb1bac1 100644
--- a/src/rules/decisionminimumdominatingset_minmaxmulticenter.rs
+++ b/src/rules/decisionminimumdominatingset_minmaxmulticenter.rs
@@ -1,19 +1,21 @@
-//! Reduction from Decision Minimum Dominating Set to Min-Max Multicenter.
+//! Unit decision dominating set to min-max multicenter.
 //!
-//! On unit-weight, unit-length graphs, choosing `K` centers with maximum
-//! distance at most `1` is exactly choosing a dominating set of size `K`.
+//! Add two isolated vertices and use clamp(K,-1,n)+2 centers. Every finite
+//! placement selects both isolates; radius <= 1 is then exactly the source
+//! dominating-set threshold. This includes empty graphs and every signed K.
 
 use crate::models::decision::Decision;
 use crate::models::graph::{MinMaxMulticenter, MinimumDominatingSet};
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
-use crate::types::One;
+use crate::types::{Min, One, Or};
 
-/// Result of reducing DecisionMinimumDominatingSet to MinMaxMulticenter.
+/// The source vertices precede the two mandatory auxiliary centers.
 #[derive(Debug, Clone)]
 pub struct ReductionDecisionMinimumDominatingSetToMinMaxMulticenter {
     target: MinMaxMulticenter<SimpleGraph, One>,
+    source_num_vertices: usize,
 }
 
 impl ReductionResult for ReductionDecisionMinimumDominatingSetToMinMaxMulticenter {
@@ -24,14 +26,40 @@ impl ReductionResult for ReductionDecisionMinimumDominatingSetToMinMaxMulticente
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target placement does not certify a dominating set: radius must be at most one",
+            ));
+        }
+        Ok(target_solution[..self.source_num_vertices].to_vec())
+    }
+}
+
+impl crate::rules::AggregateReductionResult
+    for ReductionDecisionMinimumDominatingSetToMinMaxMulticenter
+{
+    type Source = Decision<MinimumDominatingSet<SimpleGraph, One>>;
+    type Target = MinMaxMulticenter<SimpleGraph, One>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, target_value: Min<i64>) -> Or {
+        Or(target_value.0.is_some_and(|radius| radius <= 1))
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "num_vertices",
+    aggregate = custom,
+    transform = exact {
+        num_vertices = "num_vertices + 2",
         num_edges = "num_edges",
     }
 )]
@@ -40,18 +68,44 @@ impl ReduceTo<MinMaxMulticenter<SimpleGraph, One>>
 {
     type Result = ReductionDecisionMinimumDominatingSetToMinMaxMulticenter;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let source_graph = self.inner().graph();
+        let n = source_graph.num_vertices();
+        let (target_n, centers) = multicenter_parameters(n, *self.bound())?;
         let target = MinMaxMulticenter::new(
-            SimpleGraph::new(source_graph.num_vertices(), source_graph.edges()),
-            vec![One; source_graph.num_vertices()],
+            SimpleGraph::new(target_n, source_graph.edges()),
+            vec![One; target_n],
             vec![One; source_graph.num_edges()],
-            self.k(),
+            centers,
         );
-        ReductionDecisionMinimumDominatingSetToMinMaxMulticenter { target }
+        Ok(ReductionDecisionMinimumDominatingSetToMinMaxMulticenter {
+            target,
+            source_num_vertices: n,
+        })
     }
 }
 
+/// Check parameter arithmetic before allocating either graph or weight vectors.
+fn multicenter_parameters(
+    n: usize,
+    bound: i64,
+) -> Result<(usize, usize), crate::rules::ReductionError> {
+    type Source = Decision<MinimumDominatingSet<SimpleGraph, One>>;
+    type Target = MinMaxMulticenter<SimpleGraph, One>;
+    let overflow = || {
+        crate::rules::ReductionError::integer_overflow::<Source, Target>(
+            "encoding min-max multicenter parameters",
+        )
+    };
+    let target_n = n.checked_add(2).ok_or_else(overflow)?;
+    let n_i64 = i64::try_from(n).map_err(|_| overflow())?;
+    // Subset sizes lie in [0,n], so all lower bounds share the NO case -1.
+    let normalized = bound.clamp(-1, n_i64);
+    let centers = normalized.checked_add(2).ok_or_else(overflow)?;
+    let centers = usize::try_from(centers).map_err(|_| overflow())?;
+    Ok((target_n, centers))
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
     use crate::export::SolutionPair;
@@ -74,8 +128,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     2,
                 ),
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1, 0, 0],
-                    target_config: vec![1, 0, 0, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, false, false, true, false, false]),
+                    target_config: serde_json::json!(vec![
+                        true, false, false, true, false, false, true, true
+                    ]),
                 },
             )
         },
diff --git a/src/rules/decisionminimumvertexcover_hamiltoniancircuit.rs b/src/rules/decisionminimumvertexcover_hamiltoniancircuit.rs
index 963e3f5e1..201a2c437 100644
--- a/src/rules/decisionminimumvertexcover_hamiltoniancircuit.rs
+++ b/src/rules/decisionminimumvertexcover_hamiltoniancircuit.rs
@@ -1,7 +1,7 @@
 //! Reduction from Decision Minimum Vertex Cover to Hamiltonian Circuit.
 //!
 //! This implements the gadget construction from Garey & Johnson, Theorem 3.4,
-//! on the unit-weight `Decision<MinimumVertexCover<SimpleGraph, i32>>` model.
+//! on the unit-weight `Decision<MinimumVertexCover<SimpleGraph, i64>>` model.
 
 use crate::models::decision::Decision;
 use crate::models::graph::{HamiltonianCircuit, MinimumVertexCover};
@@ -13,8 +13,8 @@ use std::collections::BTreeSet;
 
 #[derive(Debug, Clone)]
 enum ConstructionKind {
-    FixedYes { source_cover: Vec<usize> },
-    FixedNo { num_source_vertices: usize },
+    FixedYes { source_cover: Vec<bool> },
+    FixedNo,
     Theorem(TheoremConstruction),
 }
 
@@ -65,21 +65,21 @@ impl TheoremConstruction {
         ))
     }
 
-    fn covers_all_edges(&self, selected: &[usize]) -> bool {
+    fn covers_all_edges(&self, selected: &[bool]) -> bool {
         self.edges
             .iter()
-            .all(|&(u, v)| selected.get(u) == Some(&1) || selected.get(v) == Some(&1))
+            .all(|&(u, v)| selected.get(u) == Some(&true) || selected.get(v) == Some(&true))
     }
 
     #[cfg(any(test, feature = "example-db"))]
-    fn exact_selected_vertices(&self, source_cover: &[usize]) -> Option<Vec<usize>> {
+    fn exact_selected_vertices(&self, source_cover: &[bool]) -> Option<Vec<usize>> {
         if source_cover.len() != self.num_source_vertices || !self.covers_all_edges(source_cover) {
             return None;
         }
 
         let mut selected: Vec<usize> = self
             .active_vertices()
-            .filter(|&v| source_cover[v] == 1)
+            .filter(|&v| source_cover[v])
             .collect();
 
         if selected.len() > self.selector_count {
@@ -90,7 +90,7 @@ impl TheoremConstruction {
             if selected.len() == self.selector_count {
                 break;
             }
-            if source_cover[v] == 0 {
+            if !source_cover[v] {
                 selected.push(v);
             }
         }
@@ -166,7 +166,7 @@ impl TheoremConstruction {
     }
 
     #[cfg(any(test, feature = "example-db"))]
-    fn build_target_witness(&self, source_cover: &[usize]) -> Vec<usize> {
+    fn build_target_witness(&self, source_cover: &[bool]) -> Vec<usize> {
         let Some(selected_vertices) = self.exact_selected_vertices(source_cover) else {
             return Vec::new();
         };
@@ -182,51 +182,59 @@ impl TheoremConstruction {
         witness
     }
 
-    fn extract_solution(
+    fn decode_solution(
         &self,
         target_problem: &HamiltonianCircuit<SimpleGraph>,
-        target_solution: &[usize],
-    ) -> Vec<usize> {
-        let mut source_cover = vec![0; self.num_source_vertices];
-        if !target_problem.evaluate(target_solution).0 {
-            return source_cover;
-        }
-
-        let mut positions = vec![usize::MAX; target_solution.len()];
-        for (idx, &vertex) in target_solution.iter().enumerate() {
-            if vertex >= positions.len() || positions[vertex] != usize::MAX {
-                return vec![0; self.num_source_vertices];
+        target_solution: &Vec<usize>,
+    ) -> crate::rules::ExtractionResult<Vec<bool>> {
+        Ok({
+            let mut source_cover = vec![false; self.num_source_vertices];
+            if !target_problem.evaluate(target_solution)?.0 {
+                return Err(crate::rules::ExtractionError::invalid(
+                    "target configuration is not a Hamiltonian circuit",
+                ));
             }
-            positions[vertex] = idx;
-        }
 
-        let len = target_solution.len();
-        let touches_selector = |vertex: usize| {
-            let idx = positions[vertex];
-            let prev = target_solution[(idx + len - 1) % len];
-            let next = target_solution[(idx + 1) % len];
-            prev < self.selector_count || next < self.selector_count
-        };
+            let mut positions = vec![usize::MAX; target_solution.len()];
+            for (idx, &vertex) in target_solution.iter().enumerate() {
+                if vertex >= positions.len() || positions[vertex] != usize::MAX {
+                    return Err(crate::rules::ExtractionError::invalid(
+                        "target circuit contains an invalid or repeated vertex",
+                    ));
+                }
+                positions[vertex] = idx;
+            }
 
-        for vertex in self.active_vertices() {
-            let Some((start, end)) = self.path_endpoints(vertex) else {
-                continue;
+            let len = target_solution.len();
+            let touches_selector = |vertex: usize| {
+                let idx = positions[vertex];
+                let prev = target_solution[(idx + len - 1) % len];
+                let next = target_solution[(idx + 1) % len];
+                prev < self.selector_count || next < self.selector_count
             };
-            if touches_selector(start) && touches_selector(end) {
-                source_cover[vertex] = 1;
+
+            for vertex in self.active_vertices() {
+                let Some((start, end)) = self.path_endpoints(vertex) else {
+                    continue;
+                };
+                if touches_selector(start) && touches_selector(end) {
+                    source_cover[vertex] = true;
+                }
             }
-        }
 
-        let selected_count = source_cover.iter().filter(|&&x| x == 1).count();
-        if selected_count != self.selector_count || !self.covers_all_edges(&source_cover) {
-            return vec![0; self.num_source_vertices];
-        }
+            let selected_count = source_cover.iter().filter(|&&x| x).count();
+            if selected_count != self.selector_count || !self.covers_all_edges(&source_cover) {
+                return Err(crate::rules::ExtractionError::invalid(
+                    "target circuit does not encode a source vertex cover of the required size",
+                ));
+            }
 
-        source_cover
+            source_cover
+        })
     }
 }
 
-/// Result of reducing Decision<MinimumVertexCover<SimpleGraph, i32>> to
+/// Result of reducing Decision<MinimumVertexCover<SimpleGraph, i64>> to
 /// HamiltonianCircuit<SimpleGraph>.
 #[derive(Debug, Clone)]
 pub struct ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
@@ -236,10 +244,10 @@ pub struct ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
 
 impl ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
     #[cfg(any(test, feature = "example-db"))]
-    fn build_target_witness(&self, source_cover: &[usize]) -> Vec<usize> {
+    fn build_target_witness(&self, source_cover: &[bool]) -> Vec<usize> {
         match &self.construction {
             ConstructionKind::FixedYes { .. } => vec![0, 1, 2],
-            ConstructionKind::FixedNo { .. } => Vec::new(),
+            ConstructionKind::FixedNo => Vec::new(),
             ConstructionKind::Theorem(construction) => {
                 construction.build_target_witness(source_cover)
             }
@@ -248,29 +256,40 @@ impl ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
 }
 
 impl ReductionResult for ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
-    type Source = Decision<MinimumVertexCover<SimpleGraph, i32>>;
+    type Source = Decision<MinimumVertexCover<SimpleGraph, i64>>;
     type Target = HamiltonianCircuit<SimpleGraph>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        match &self.construction {
-            ConstructionKind::FixedYes { source_cover } => {
-                if self.target.evaluate(target_solution).0 {
-                    source_cover.clone()
-                } else {
-                    vec![0; source_cover.len()]
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            match &self.construction {
+                ConstructionKind::FixedYes { source_cover } => {
+                    if self.target.evaluate(target_solution)?.0 {
+                        source_cover.clone()
+                    } else {
+                        return Err(crate::rules::ExtractionError::invalid(
+                            "target configuration is not the fixed Hamiltonian circuit",
+                        ));
+                    }
+                }
+                ConstructionKind::FixedNo => {
+                    return Err(crate::rules::ExtractionError::invalid(
+                        "the fixed negative target instance has no extractable witness",
+                    ))
+                }
+                ConstructionKind::Theorem(construction) => {
+                    construction.decode_solution(&self.target, target_solution)?
                 }
             }
-            ConstructionKind::FixedNo {
-                num_source_vertices,
-            } => vec![0; *num_source_vertices],
-            ConstructionKind::Theorem(construction) => {
-                construction.extract_solution(&self.target, target_solution)
-            }
-        }
+        })
     }
 }
 
@@ -289,30 +308,32 @@ fn insert_edge(edges: &mut BTreeSet<(usize, usize)>, a: usize, b: usize) {
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "12 * num_edges + k",
-        num_edges = "16 * num_edges - num_vertices + 2 * k * num_vertices",
+    transform = unavailable {
+        num_vertices = "the construction size depends on the decision threshold, which is not a problem parameter",
+        num_edges = "the construction size depends on the decision threshold, which is not a problem parameter",
     }
 )]
-impl ReduceTo<HamiltonianCircuit<SimpleGraph>> for Decision<MinimumVertexCover<SimpleGraph, i32>> {
+impl ReduceTo<HamiltonianCircuit<SimpleGraph>> for Decision<MinimumVertexCover<SimpleGraph, i64>> {
     type Result = ReductionDecisionMinimumVertexCoverToHamiltonianCircuit;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let weights = self.inner().weights();
-        assert!(
-            weights.iter().all(|&weight| weight == 1),
-            "Garey-Johnson Theorem 3.4 requires unit vertex weights"
-        );
+        if weights.iter().any(|&weight| weight != 1) {
+            return Err(crate::rules::ReductionError::invalid_target::<
+                Decision<MinimumVertexCover<SimpleGraph, i64>>,
+                HamiltonianCircuit<SimpleGraph>,
+            >(
+                "Garey-Johnson construction requires unit vertex weights"
+            ));
+        }
 
         let num_source_vertices = self.inner().graph().num_vertices();
         let raw_bound = *self.bound();
         if raw_bound < 0 {
-            return ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
+            return Ok(ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
                 target: HamiltonianCircuit::new(SimpleGraph::path(3)),
-                construction: ConstructionKind::FixedNo {
-                    num_source_vertices,
-                },
-            };
+                construction: ConstructionKind::FixedNo,
+            });
         }
 
         let k = self.k();
@@ -332,23 +353,21 @@ impl ReduceTo<HamiltonianCircuit<SimpleGraph>> for Decision<MinimumVertexCover<S
         let active_count = active_vertices.len();
 
         if active_count == 0 || k >= active_count {
-            let mut source_cover = vec![0; num_source_vertices];
+            let mut source_cover = vec![false; num_source_vertices];
             for vertex in active_vertices {
-                source_cover[vertex] = 1;
+                source_cover[vertex] = true;
             }
-            return ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
+            return Ok(ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
                 target: HamiltonianCircuit::new(SimpleGraph::cycle(3)),
                 construction: ConstructionKind::FixedYes { source_cover },
-            };
+            });
         }
 
         if k == 0 {
-            return ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
+            return Ok(ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
                 target: HamiltonianCircuit::new(SimpleGraph::path(3)),
-                construction: ConstructionKind::FixedNo {
-                    num_source_vertices,
-                },
-            };
+                construction: ConstructionKind::FixedNo,
+            });
         }
 
         let construction = TheoremConstruction {
@@ -405,9 +424,12 @@ impl ReduceTo<HamiltonianCircuit<SimpleGraph>> for Decision<MinimumVertexCover<S
                 );
             }
 
-            let (start, end) = construction
-                .path_endpoints(vertex)
-                .expect("active vertices have path endpoints");
+            let (start, end) = construction.path_endpoints(vertex).ok_or_else(|| {
+                crate::rules::ReductionError::invalid_target::<
+                    Decision<MinimumVertexCover<SimpleGraph, i64>>,
+                    HamiltonianCircuit<SimpleGraph>,
+                >("active source vertex has no Hamiltonian gadget path endpoints")
+            })?;
             for selector in 0..construction.selector_count {
                 insert_edge(&mut target_edges, selector, start);
                 insert_edge(&mut target_edges, selector, end);
@@ -419,10 +441,10 @@ impl ReduceTo<HamiltonianCircuit<SimpleGraph>> for Decision<MinimumVertexCover<S
             target_edges.into_iter().collect(),
         ));
 
-        ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
+        Ok(ReductionDecisionMinimumVertexCoverToHamiltonianCircuit {
             target,
             construction: ConstructionKind::Theorem(construction),
-        }
+        })
     }
 }
 
@@ -438,15 +460,18 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1, 1, 1]),
                 1,
             );
-            let source_config = vec![0, 1, 0];
-            let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source);
+            let source_config = vec![false, true, false];
+            let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source)
+                .expect("reduction should succeed");
             let target_config = reduction.build_target_witness(&source_config);
             assemble_rule_example(
                 &source,
                 reduction.target_problem(),
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/directedhamiltonianpath_ilp.rs b/src/rules/directedhamiltonianpath_ilp.rs
index f9cb01525..af6cd0de9 100644
--- a/src/rules/directedhamiltonianpath_ilp.rs
+++ b/src/rules/directedhamiltonianpath_ilp.rs
@@ -9,9 +9,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::DirectedHamiltonianPath;
 use crate::reduction;
-use crate::rules::ilp_helpers::{
-    one_hot_assignment_constraints, one_hot_decode, permutation_to_lehmer,
-};
+use crate::rules::ilp_helpers::{one_hot_assignment_constraints, one_hot_decode};
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing DirectedHamiltonianPath to ILP.
@@ -32,24 +30,34 @@ impl ReductionResult for ReductionDirectedHamiltonianPathToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_vertices;
-        // Decode one-hot assignment: permutation[k] = v where x_{v,k} = 1
-        let perm = one_hot_decode(target_solution, n, n, 0);
-        permutation_to_lehmer(&perm)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_vertices;
+            // Decode one-hot assignment: permutation[k] = v where x_{v,k} = 1
+
+            one_hot_decode(target_solution, n, n, 0)?
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices^2",
         num_constraints = "3 * num_vertices + (num_vertices - 1) * (num_vertices^2 - num_arcs)",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for DirectedHamiltonianPath {
     type Result = ReductionDirectedHamiltonianPathToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let arcs = self.graph().arcs();
 
@@ -71,8 +79,8 @@ impl ReduceTo<ILP<bool>> for DirectedHamiltonianPath {
         // one_hot_assignment_constraints gives: row eq + col le
         // We need col eq, so add col ge (col le + col ge = col eq)
         for k in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|v| (x_idx(v, k), 1.0)).collect();
-            constraints.push(LinearConstraint::ge(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|v| (x_idx(v, k), 1)).collect();
+            constraints.push(LinearConstraint::ge(terms, 1));
         }
 
         // (2) Arc existence: for each consecutive position pair (k, k+1),
@@ -83,8 +91,8 @@ impl ReduceTo<ILP<bool>> for DirectedHamiltonianPath {
                     for w in 0..n {
                         if !arc_set.contains(&(v, w)) {
                             constraints.push(LinearConstraint::le(
-                                vec![(x_idx(v, k), 1.0), (x_idx(w, k + 1), 1.0)],
-                                1.0,
+                                vec![(x_idx(v, k), 1), (x_idx(w, k + 1), 1)],
+                                1,
                             ));
                         }
                     }
@@ -93,12 +101,13 @@ impl ReduceTo<ILP<bool>> for DirectedHamiltonianPath {
         }
 
         // Feasibility objective
-        let target = ILP::new(n * n, constraints, vec![], ObjectiveSense::Minimize);
+        let target = ILP::new(n * n, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionDirectedHamiltonianPathToILP {
+        Ok(ReductionDirectedHamiltonianPathToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
diff --git a/src/rules/directedtwocommodityintegralflow_ilp.rs b/src/rules/directedtwocommodityintegralflow_ilp.rs
index 86f625769..6e644d21f 100644
--- a/src/rules/directedtwocommodityintegralflow_ilp.rs
+++ b/src/rules/directedtwocommodityintegralflow_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from DirectedTwoCommodityIntegralFlow to ILP<i32>.
+//! Reduction from DirectedTwoCommodityIntegralFlow to `ILP<i64>`.
 //!
 //! One non-negative integer variable per (commodity, arc):
 //!   f1_a = a             for a in 0..num_arcs  (commodity 1 flow on arc a)
@@ -17,41 +17,49 @@ use crate::models::graph::DirectedTwoCommodityIntegralFlow;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing DirectedTwoCommodityIntegralFlow to ILP<i32>.
+/// Result of reducing DirectedTwoCommodityIntegralFlow to `ILP<i64>`.
 ///
 /// Variable layout:
 /// - `f1_a` at index a for a in 0..num_arcs (commodity 1)
 /// - `f2_a` at index num_arcs + a for a in 0..num_arcs (commodity 2)
 #[derive(Debug, Clone)]
 pub struct ReductionD2CIFToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_arcs: usize,
 }
 
 impl ReductionResult for ReductionD2CIFToILP {
     type Source = DirectedTwoCommodityIntegralFlow;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Extract flow solution: all 2*|A| variables directly encode the flow.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..2 * self.num_arcs].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::decode_usize_values(&target_solution[..2 * self.num_arcs])
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "2 * num_arcs",
         num_constraints = "num_arcs + 2 * num_vertices + 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for DirectedTwoCommodityIntegralFlow {
+impl ReduceTo<ILP<i64>> for DirectedTwoCommodityIntegralFlow {
     type Result = ReductionD2CIFToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let arcs = self.graph().arcs();
         let m = arcs.len();
         let n = self.num_vertices();
@@ -65,17 +73,17 @@ impl ReduceTo<ILP<i32>> for DirectedTwoCommodityIntegralFlow {
         // 1. Joint capacity: f1_a + f2_a ≤ cap[a]
         for a in 0..m {
             constraints.push(LinearConstraint::le(
-                vec![(f1(a), 1.0), (f2(a), 1.0)],
-                self.capacities()[a] as f64,
+                vec![(f1(a), 1), (f2(a), 1)],
+                self.capacities()[a],
             ));
         }
 
         // 2. Flow conservation away from each commodity's own source and sink
         for vertex in 0..n {
             // Commodity 1: Σ_in f1 - Σ_out f1 = 0
-            let mut terms_c1: Option<Vec<(usize, f64)>> = None;
+            let mut terms_c1: Option<Vec<(usize, i64)>> = None;
             // Commodity 2: Σ_in f2 - Σ_out f2 = 0
-            let mut terms_c2: Option<Vec<(usize, f64)>> = None;
+            let mut terms_c2: Option<Vec<(usize, i64)>> = None;
 
             if vertex != self.source_1() && vertex != self.sink_1() {
                 terms_c1 = Some(Vec::new());
@@ -88,64 +96,59 @@ impl ReduceTo<ILP<i32>> for DirectedTwoCommodityIntegralFlow {
                 if vertex == u {
                     // Arc leaves vertex: outgoing
                     if let Some(terms) = &mut terms_c1 {
-                        terms.push((f1(a), -1.0));
+                        terms.push((f1(a), -1));
                     }
                     if let Some(terms) = &mut terms_c2 {
-                        terms.push((f2(a), -1.0));
+                        terms.push((f2(a), -1));
                     }
                 } else if vertex == v {
                     // Arc enters vertex: incoming
                     if let Some(terms) = &mut terms_c1 {
-                        terms.push((f1(a), 1.0));
+                        terms.push((f1(a), 1));
                     }
                     if let Some(terms) = &mut terms_c2 {
-                        terms.push((f2(a), 1.0));
+                        terms.push((f2(a), 1));
                     }
                 }
             }
 
             if let Some(terms_c1) = terms_c1.filter(|terms| !terms.is_empty()) {
-                constraints.push(LinearConstraint::eq(terms_c1, 0.0));
+                constraints.push(LinearConstraint::eq(terms_c1, 0));
             }
             if let Some(terms_c2) = terms_c2.filter(|terms| !terms.is_empty()) {
-                constraints.push(LinearConstraint::eq(terms_c2, 0.0));
+                constraints.push(LinearConstraint::eq(terms_c2, 0));
             }
         }
 
         // 3. Net flow into sink_1 ≥ requirement_1
         let sink_1 = self.sink_1();
-        let mut sink1_terms: Vec<(usize, f64)> = Vec::new();
+        let mut sink1_terms: Vec<(usize, i64)> = Vec::new();
         for (a, &(u, v)) in arcs.iter().enumerate() {
             if v == sink_1 {
-                sink1_terms.push((f1(a), 1.0));
+                sink1_terms.push((f1(a), 1));
             } else if u == sink_1 {
-                sink1_terms.push((f1(a), -1.0));
+                sink1_terms.push((f1(a), -1));
             }
         }
-        constraints.push(LinearConstraint::ge(
-            sink1_terms,
-            self.requirement_1() as f64,
-        ));
+        constraints.push(LinearConstraint::ge(sink1_terms, self.requirement_1()));
 
         // Net flow into sink_2 ≥ requirement_2
         let sink_2 = self.sink_2();
-        let mut sink2_terms: Vec<(usize, f64)> = Vec::new();
+        let mut sink2_terms: Vec<(usize, i64)> = Vec::new();
         for (a, &(u, v)) in arcs.iter().enumerate() {
             if v == sink_2 {
-                sink2_terms.push((f2(a), 1.0));
+                sink2_terms.push((f2(a), 1));
             } else if u == sink_2 {
-                sink2_terms.push((f2(a), -1.0));
+                sink2_terms.push((f2(a), -1));
             }
         }
-        constraints.push(LinearConstraint::ge(
-            sink2_terms,
-            self.requirement_2() as f64,
-        ));
+        constraints.push(LinearConstraint::ge(sink2_terms, self.requirement_2()));
 
-        ReductionD2CIFToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionD2CIFToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_arcs: m,
-        }
+        })
     }
 }
 
@@ -181,7 +184,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 1,
                 1,
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/disjointconnectingpaths_ilp.rs b/src/rules/disjointconnectingpaths_ilp.rs
index 1c4b7f5df..5d1269c13 100644
--- a/src/rules/disjointconnectingpaths_ilp.rs
+++ b/src/rules/disjointconnectingpaths_ilp.rs
@@ -1,13 +1,14 @@
 //! Reduction from DisjointConnectingPaths to ILP.
 //!
 //! Binary flow variables `f^k_{e,dir}` per commodity per directed arc orientation.
-//! Flow conservation, anti-parallel constraints, and vertex disjointness.
+//! Flow conservation and unit vertex capacities enforce vertex-disjoint paths.
 
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::DisjointConnectingPaths;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::SimpleGraph;
+use std::collections::VecDeque;
 
 /// Result of reducing DisjointConnectingPaths to ILP.
 ///
@@ -22,7 +23,8 @@ pub struct ReductionDCPToILP {
     target: ILP<bool>,
     /// Canonical edge list used during construction.
     edges: Vec<(usize, usize)>,
-    num_commodities: usize,
+    num_vertices: usize,
+    terminal_pairs: Vec<(usize, usize)>,
     num_edge_vars_per_commodity: usize,
 }
 
@@ -34,42 +36,83 @@ impl ReductionResult for ReductionDCPToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Mark an edge selected iff some orientation carries flow for some commodity.
-        let m = self.edges.len();
-        let mut result = vec![0usize; m];
-        for k in 0..self.num_commodities {
-            for e in 0..m {
-                let fwd = target_solution[k * self.num_edge_vars_per_commodity + 2 * e];
-                let rev = target_solution[k * self.num_edge_vars_per_commodity + 2 * e + 1];
-                if fwd == 1 || rev == 1 {
-                    result[e] = 1;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        let mut result = vec![false; self.edges.len()];
+        for (k, &(source, sink)) in self.terminal_pairs.iter().enumerate() {
+            let offset = k * self.num_edge_vars_per_commodity;
+            let mut adjacency = vec![Vec::new(); self.num_vertices];
+            for (edge, &(u, v)) in self.edges.iter().enumerate() {
+                if target_solution[offset + 2 * edge] == 1 {
+                    adjacency[u].push((v, edge));
                 }
+                if target_solution[offset + 2 * edge + 1] == 1 {
+                    adjacency[v].push((u, edge));
+                }
+            }
+            let mut visited = vec![false; self.num_vertices];
+            let mut predecessor = vec![None; self.num_vertices];
+            let mut queue = VecDeque::from([source]);
+            visited[source] = true;
+            while let Some(u) = queue.pop_front() {
+                if u == sink {
+                    break;
+                }
+                for &(v, edge) in &adjacency[u] {
+                    if !visited[v] {
+                        visited[v] = true;
+                        predecessor[v] = Some((u, edge));
+                        queue.push_back(v);
+                    }
+                }
+            }
+            let mut vertex = sink;
+            while vertex != source {
+                let (previous, edge) = predecessor[vertex].ok_or_else(|| {
+                    crate::rules::ExtractionError::invalid(
+                        "commodity flow does not connect its terminal pair",
+                    )
+                })?;
+                result[edge] = true;
+                vertex = previous;
             }
         }
-        result
+        Ok(result)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_pairs * 2 * num_edges",
-        num_constraints = "num_pairs * num_vertices + num_pairs * num_edges + num_edges + num_vertices",
+        num_constraints = "num_pairs * num_vertices + num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for DisjointConnectingPaths<SimpleGraph> {
     type Result = ReductionDCPToILP;
 
     #[allow(clippy::needless_range_loop)]
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let edges = self.ordered_edges();
         let m = edges.len();
         let n = self.num_vertices();
         let k_count = self.num_pairs();
 
-        // Variable layout: only flow variables, no MTZ ordering needed for binary flow
-        let num_flow_vars_per_k = 2 * m; // f^k_{e,dir}
-        let num_vars = k_count * num_flow_vars_per_k;
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<Self, ILP<bool>>(operation)
+        };
+        let num_flow_vars_per_k = m
+            .checked_mul(2)
+            .ok_or_else(|| overflow("computing the flow-variable stride"))?;
+        let num_vars = k_count
+            .checked_mul(num_flow_vars_per_k)
+            .ok_or_else(|| overflow("computing the flow-variable count"))?;
 
         let flow_var =
             |k: usize, e: usize, dir: usize| -> usize { k * num_flow_vars_per_k + 2 * e + dir };
@@ -83,11 +126,9 @@ impl ReduceTo<ILP<bool>> for DisjointConnectingPaths<SimpleGraph> {
             vertex_edges[v].push(e);
         }
 
-        // Identify terminal vertices
-        let mut is_terminal = vec![false; n];
-        for &(s, t) in self.terminal_pairs() {
-            is_terminal[s] = true;
-            is_terminal[t] = true;
+        let mut is_source = vec![false; n];
+        for &(source, _) in self.terminal_pairs() {
+            is_source[source] = true;
         }
 
         for (k, &(s_k, t_k)) in self.terminal_pairs().iter().enumerate() {
@@ -98,73 +139,53 @@ impl ReduceTo<ILP<bool>> for DisjointConnectingPaths<SimpleGraph> {
                     let (eu, _ev) = edges[e];
                     if vertex == eu {
                         // vertex is first endpoint: dir=0 is outgoing, dir=1 is incoming
-                        terms.push((flow_var(k, e, 0), 1.0));
-                        terms.push((flow_var(k, e, 1), -1.0));
+                        terms.push((flow_var(k, e, 0), 1));
+                        terms.push((flow_var(k, e, 1), -1));
                     } else {
                         // vertex is second endpoint: dir=1 is outgoing, dir=0 is incoming
-                        terms.push((flow_var(k, e, 1), 1.0));
-                        terms.push((flow_var(k, e, 0), -1.0));
+                        terms.push((flow_var(k, e, 1), 1));
+                        terms.push((flow_var(k, e, 0), -1));
                     }
                 }
 
                 let demand = if vertex == s_k {
-                    1.0
+                    1
                 } else if vertex == t_k {
-                    -1.0
+                    -1
                 } else {
-                    0.0
+                    0
                 };
                 constraints.push(LinearConstraint::eq(terms, demand));
             }
-
-            // Anti-parallel: f^k_{e,0} + f^k_{e,1} <= 1 for each edge
-            for e in 0..m {
-                constraints.push(LinearConstraint::le(
-                    vec![(flow_var(k, e, 0), 1.0), (flow_var(k, e, 1), 1.0)],
-                    1.0,
-                ));
-            }
         }
 
-        // Edge disjointness: each edge is used by at most one commodity
-        // sum_k (f^k_{e,0} + f^k_{e,1}) <= 1
-        for e in 0..m {
-            let mut terms = Vec::new();
-            for k in 0..k_count {
-                terms.push((flow_var(k, e, 0), 1.0));
-                terms.push((flow_var(k, e, 1), 1.0));
-            }
-            constraints.push(LinearConstraint::le(terms, 1.0));
-        }
-
-        // Vertex disjointness: for each non-terminal vertex v,
-        // sum over all commodities k of (outgoing flow from v) <= 1
+        // Incoming flow records vertex use. A source is occupied by its own
+        // commodity even though it has no incoming flow.
         for v in 0..n {
-            if is_terminal[v] {
-                continue;
-            }
             let mut terms = Vec::new();
             for k in 0..k_count {
                 for &e in &vertex_edges[v] {
                     let (eu, _ev) = edges[e];
                     if v == eu {
-                        terms.push((flow_var(k, e, 0), 1.0));
+                        terms.push((flow_var(k, e, 1), 1));
                     } else {
-                        terms.push((flow_var(k, e, 1), 1.0));
+                        terms.push((flow_var(k, e, 0), 1));
                     }
                 }
             }
-            constraints.push(LinearConstraint::le(terms, 1.0));
+            constraints.push(LinearConstraint::le(terms, 1 - i64::from(is_source[v])));
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionDCPToILP {
+        Ok(ReductionDCPToILP {
             target,
             edges,
-            num_commodities: k_count,
+            num_vertices: n,
+            terminal_pairs: self.terminal_pairs().to_vec(),
             num_edge_vars_per_commodity: num_flow_vars_per_k,
-        }
+        })
     }
 }
 
diff --git a/src/rules/ensemblecomputation_ilp.rs b/src/rules/ensemblecomputation_ilp.rs
new file mode 100644
index 000000000..2ed359613
--- /dev/null
+++ b/src/rules/ensemblecomputation_ilp.rs
@@ -0,0 +1,308 @@
+//! Polynomial-size circuit-slot reduction from EnsembleComputation to `ILP<i64>`.
+
+use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::models::misc::EnsembleComputation;
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+
+#[derive(Debug, Clone)]
+pub struct ReductionEnsembleComputationToILP {
+    target: ILP<i64>,
+    universe_size: usize,
+    budget: usize,
+    activity_base: usize,
+    left_selector_base: usize,
+    right_selector_base: usize,
+}
+
+impl ReductionEnsembleComputationToILP {
+    fn operand_offset(&self, step: usize) -> usize {
+        step * self.universe_size + step * step.saturating_sub(1) / 2
+    }
+
+    fn selector_var(&self, left: bool, step: usize, operand: usize) -> usize {
+        let base = if left {
+            self.left_selector_base
+        } else {
+            self.right_selector_base
+        };
+        base + self.operand_offset(step) + operand
+    }
+}
+
+impl ReductionResult for ReductionEnsembleComputationToILP {
+    type Source = EnsembleComputation;
+    type Target = ILP<i64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        let mut config = Vec::with_capacity(2 * self.budget);
+        let mut inactive = false;
+        for step in 0..self.budget {
+            let active = target_solution[self.activity_base + step];
+            if active == 0 {
+                inactive = true;
+                continue;
+            }
+            if active != 1 || inactive {
+                return Err(crate::rules::ExtractionError::invalid(
+                    "active ensemble-operation slots must form a binary prefix",
+                ));
+            }
+            for left in [true, false] {
+                let selected = (0..self.universe_size + step)
+                    .filter(|&operand| target_solution[self.selector_var(left, step, operand)] == 1)
+                    .collect::<Vec<_>>();
+                if selected.len() != 1 {
+                    return Err(crate::rules::ExtractionError::invalid(
+                        "each active ensemble operation must select exactly one operand per side",
+                    ));
+                }
+                config.push(selected[0]);
+            }
+        }
+        let filler = if self.universe_size >= 2 {
+            [0, 1]
+        } else {
+            [0, 0]
+        };
+        while config.len() < 2 * self.budget {
+            config.extend(filler);
+        }
+        Ok(config)
+    }
+}
+
+#[reduction(
+    transform = exact {
+        num_vars = "3 * budget * universe_size + budget * (budget - 1) * (universe_size + 1) + num_subsets * budget + budget",
+        num_constraints = "5 * budget - 1 + budget * (budget - 1) * (1 + 3 * universe_size) + 2 * budget * universe_size + num_subsets * budget * (universe_size + 2) + num_subsets",
+    },
+    unavailable = {
+        num_nonzeros = "depends on the cardinalities and duplicate structure of the required subsets",
+    }
+)]
+impl ReduceTo<ILP<i64>> for EnsembleComputation {
+    type Result = ReductionEnsembleComputationToILP;
+
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let u = self.universe_size();
+        let budget = self.budget();
+        let t = self.num_subsets();
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<EnsembleComputation, ILP<i64>>(
+                operation,
+            )
+        };
+        let pair_count = budget
+            .checked_mul(budget.saturating_sub(1))
+            .and_then(|value| value.checked_div(2))
+            .ok_or_else(|| overflow("counting earlier ensemble-operation pairs"))?;
+        let operand_count = budget
+            .checked_mul(u)
+            .and_then(|value| value.checked_add(pair_count))
+            .ok_or_else(|| overflow("counting ensemble operand selectors"))?;
+        let result_count = budget
+            .checked_mul(u)
+            .ok_or_else(|| overflow("counting ensemble result bits"))?;
+        let product_count = pair_count
+            .checked_mul(u)
+            .ok_or_else(|| overflow("counting ensemble selector-result products"))?;
+        let match_count = t
+            .checked_mul(budget)
+            .ok_or_else(|| overflow("counting ensemble target matches"))?;
+
+        let activity_base = 0;
+        let left_selector_base = budget;
+        let right_selector_base = left_selector_base
+            .checked_add(operand_count)
+            .ok_or_else(|| overflow("laying out left ensemble selectors"))?;
+        let result_base = right_selector_base
+            .checked_add(operand_count)
+            .ok_or_else(|| overflow("laying out right ensemble selectors"))?;
+        let left_product_base = result_base
+            .checked_add(result_count)
+            .ok_or_else(|| overflow("laying out ensemble result bits"))?;
+        let right_product_base = left_product_base
+            .checked_add(product_count)
+            .ok_or_else(|| overflow("laying out left ensemble products"))?;
+        let match_base = right_product_base
+            .checked_add(product_count)
+            .ok_or_else(|| overflow("laying out right ensemble products"))?;
+        let num_vars = match_base
+            .checked_add(match_count)
+            .ok_or_else(|| overflow("counting ensemble ILP variables"))?;
+
+        let operand_offset = |step: usize| step * u + step * step.saturating_sub(1) / 2;
+        let selector = |left: bool, step: usize, operand: usize| {
+            (if left {
+                left_selector_base
+            } else {
+                right_selector_base
+            }) + operand_offset(step)
+                + operand
+        };
+        let result = |step: usize, element: usize| result_base + step * u + element;
+        let pair_index = |step: usize, earlier: usize| step * step.saturating_sub(1) / 2 + earlier;
+        let product = |left: bool, step: usize, earlier: usize, element: usize| {
+            (if left {
+                left_product_base
+            } else {
+                right_product_base
+            }) + pair_index(step, earlier) * u
+                + element
+        };
+        let matched = |target: usize, step: usize| match_base + target * budget + step;
+
+        let mut constraints = Vec::new();
+        for step in 0..budget {
+            constraints.push(LinearConstraint::le(vec![(activity_base + step, 1)], 1));
+        }
+        for step in 0..budget.saturating_sub(1) {
+            constraints.push(LinearConstraint::ge(
+                vec![(activity_base + step, 1), (activity_base + step + 1, -1)],
+                0,
+            ));
+        }
+
+        for step in 0..budget {
+            for left in [true, false] {
+                let mut terms = (0..u + step)
+                    .map(|operand| (selector(left, step, operand), 1))
+                    .collect::<Vec<_>>();
+                terms.push((activity_base + step, -1));
+                constraints.push(LinearConstraint::eq(terms, 0));
+                for earlier in 0..step {
+                    constraints.push(LinearConstraint::le(
+                        vec![
+                            (selector(left, step, u + earlier), 1),
+                            (activity_base + earlier, -1),
+                        ],
+                        0,
+                    ));
+                }
+            }
+            // Disjoint union is commutative. Canonically ordering operand
+            // indices removes the two equivalent orientations of every gate.
+            let mut canonical_order = vec![(activity_base + step, 1)];
+            for operand in 0..u + step {
+                let coefficient = i64::try_from(
+                    operand
+                        .checked_add(1)
+                        .ok_or_else(|| overflow("ordering ensemble operands"))?,
+                )
+                .map_err(|_| overflow("ordering ensemble operands"))?;
+                canonical_order.push((selector(true, step, operand), coefficient));
+                canonical_order.push((selector(false, step, operand), -coefficient));
+            }
+            constraints.push(LinearConstraint::le(canonical_order, 0));
+        }
+
+        for step in 0..budget {
+            for earlier in 0..step {
+                for element in 0..u {
+                    for left in [true, false] {
+                        let value = product(left, step, earlier, element);
+                        let selected = selector(left, step, u + earlier);
+                        let bit = result(earlier, element);
+                        constraints.extend(crate::rules::ilp_helpers::mccormick_product(
+                            value, selected, bit,
+                        ));
+                    }
+                }
+            }
+        }
+
+        for step in 0..budget {
+            for element in 0..u {
+                let membership = |left: bool| {
+                    let mut terms = vec![(selector(left, step, element), 1)];
+                    terms.extend(
+                        (0..step).map(|earlier| (product(left, step, earlier, element), 1)),
+                    );
+                    terms
+                };
+                let left = membership(true);
+                let right = membership(false);
+                let mut disjoint = left.clone();
+                disjoint.extend(right.clone());
+                constraints.push(LinearConstraint::le(disjoint, 1));
+                let mut union = vec![(result(step, element), 1)];
+                union.extend(
+                    left.into_iter()
+                        .map(|(variable, coefficient)| (variable, -coefficient)),
+                );
+                union.extend(
+                    right
+                        .into_iter()
+                        .map(|(variable, coefficient)| (variable, -coefficient)),
+                );
+                constraints.push(LinearConstraint::eq(union, 0));
+            }
+        }
+
+        for (target_index, target) in self.subsets().iter().enumerate() {
+            let membership: Vec<bool> = (0..u)
+                .map(|element| target.binary_search(&element).is_ok())
+                .collect();
+            let mut present = Vec::with_capacity(budget);
+            for step in 0..budget {
+                let match_var = matched(target_index, step);
+                present.push((match_var, 1));
+                constraints.push(LinearConstraint::le(vec![(match_var, 1)], 1));
+                constraints.push(LinearConstraint::le(
+                    vec![(match_var, 1), (activity_base + step, -1)],
+                    0,
+                ));
+                for (element, &contains_element) in membership.iter().enumerate() {
+                    if contains_element {
+                        constraints.push(LinearConstraint::le(
+                            vec![(match_var, 1), (result(step, element), -1)],
+                            0,
+                        ));
+                    } else {
+                        constraints.push(LinearConstraint::le(
+                            vec![(match_var, 1), (result(step, element), 1)],
+                            1,
+                        ));
+                    }
+                }
+            }
+            constraints.push(LinearConstraint::ge(present, 1));
+        }
+
+        let objective = (0..budget).map(|step| (activity_base + step, 1)).collect();
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionEnsembleComputationToILP {
+            target,
+            universe_size: u,
+            budget,
+            activity_base,
+            left_selector_base,
+            right_selector_base,
+        })
+    }
+}
+
+#[cfg(feature = "example-db")]
+pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
+    vec![crate::example_db::specs::RuleExampleSpec {
+        id: "ensemblecomputation_to_ilp",
+        build: || {
+            let source = EnsembleComputation::new(4, vec![vec![0, 1], vec![0, 1, 2, 3]], 3);
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/ensemblecomputation_ilp.rs"]
+mod tests;
diff --git a/src/rules/eulerianpath_ilp.rs b/src/rules/eulerianpath_ilp.rs
index 5701d0039..ce8ec318b 100644
--- a/src/rules/eulerianpath_ilp.rs
+++ b/src/rules/eulerianpath_ilp.rs
@@ -28,7 +28,7 @@ use crate::models::graph::EulerianPath;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing EulerianPath to `ILP<i32>`.
+/// Result of reducing EulerianPath to `ILP<i64>`.
 ///
 /// Variable layout (all in the non-negative integer domain, with explicit
 /// upper bounds enforcing the intended `0/1` and `0..m-1` ranges):
@@ -42,7 +42,7 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// where `p = pairs.len()` is the number of compatible ordered pairs.
 #[derive(Debug, Clone)]
 pub struct ReductionEulerianPathToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     /// Compatible ordered pairs `(a, b)` in the order their `y_{a,b}` variables
     /// appear in the ILP, for `m > 0`. Empty when `m = 0`.
     pairs: Vec<(usize, usize)>,
@@ -58,9 +58,9 @@ impl ReductionEulerianPathToILP {
 
 impl ReductionResult for ReductionEulerianPathToILP {
     type Source = EulerianPath;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
@@ -68,67 +68,59 @@ impl ReductionResult for ReductionEulerianPathToILP {
     ///
     /// Reads the unique active start arc (`s_a = 1`) and walks the active
     /// successor relation (`y_{a,b} = 1`) one step at a time, producing an arc
-    /// permutation of length `m`. If the assignment is malformed (no start,
-    /// no successor mid-walk, or revisits an arc) we fall back to the identity
-    /// ordering `0..m` in release builds; debug builds trip a
-    /// `debug_assert!` to surface the caller bug. Callers must independently
-    /// check feasibility on the source side via
-    /// `EulerianPath::is_valid_solution`.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let m = self.num_arcs;
-        if m == 0 {
-            return Vec::new();
-        }
-        let fallback: Vec<usize> = (0..m).collect();
+    /// permutation of length `m`. Malformed assignments return an extraction
+    /// error instead of fabricating an ordering.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
-        // Find the unique active start arc.
-        let mut current = match (0..m)
-            .find(|&a| target_solution.get(self.s_idx(a)).copied().unwrap_or(0) == 1)
-        {
-            Some(a) => a,
-            None => {
-                debug_assert!(
-                    false,
-                    "EulerianPath -> ILP extract_solution: malformed assignment, no active start arc (expected exactly one s_a = 1)",
-                );
-                return fallback;
+        Ok({
+            let m = self.num_arcs;
+            if m == 0 {
+                return Ok(Vec::new());
             }
-        };
 
-        // Walk the active successor relation, recording each visited arc.
-        let mut order = Vec::with_capacity(m);
-        let mut visited = vec![false; m];
-        order.push(current);
-        visited[current] = true;
+            // Find the unique active start arc.
+            let mut current = match (0..m).find(|&a| target_solution[self.s_idx(a)] == 1) {
+                Some(a) => a,
+                None => {
+                    return Err(crate::rules::ExtractionError::invalid(
+                        "ILP witness has no active Eulerian-path start arc",
+                    ));
+                }
+            };
+
+            // Walk the active successor relation, recording each visited arc.
+            let mut order = Vec::with_capacity(m);
+            let mut visited = vec![false; m];
+            order.push(current);
+            visited[current] = true;
 
-        for _ in 1..m {
-            let next = self
-                .pairs
-                .iter()
-                .enumerate()
-                .find(|&(k, &(a, _))| {
-                    a == current && target_solution.get(k).copied().unwrap_or(0) == 1
-                })
-                .map(|(_, &(_, b))| b);
+            for _ in 1..m {
+                let next = self
+                    .pairs
+                    .iter()
+                    .enumerate()
+                    .find(|&(k, &(a, _))| a == current && target_solution[k] == 1)
+                    .map(|(_, &(_, b))| b);
 
-            match next {
-                Some(b) if !visited[b] => {
-                    order.push(b);
-                    visited[b] = true;
-                    current = b;
-                }
-                _ => {
-                    debug_assert!(
-                        false,
-                        "EulerianPath -> ILP extract_solution: malformed assignment at arc {} (expected exactly one active successor y_{{{},b}} = 1 leading to an unvisited arc)",
-                        current,
-                        current,
-                    );
-                    return fallback;
+                match next {
+                    Some(b) if !visited[b] => {
+                        order.push(b);
+                        visited[b] = true;
+                        current = b;
+                    }
+                    _ => {
+                        return Err(crate::rules::ExtractionError::invalid(format!(
+                            "ILP witness has no unvisited successor for arc {current}",
+                        )));
+                    }
                 }
             }
-        }
-        order
+            order
+        })
     }
 }
 
@@ -148,26 +140,30 @@ fn compatible_pairs(arcs: &[(usize, usize)]) -> Vec<(usize, usize)> {
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "3 * num_arcs + num_arcs * num_arcs",
         num_constraints = "5 * num_arcs + 2 * num_arcs * num_arcs + 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for EulerianPath {
+impl ReduceTo<ILP<i64>> for EulerianPath {
     type Result = ReductionEulerianPathToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let arcs = self.graph().arcs();
         let m = arcs.len();
 
         // Empty-arc instance: vacuously feasible empty ILP.
         if m == 0 {
-            let target = ILP::new(0, Vec::new(), Vec::new(), ObjectiveSense::Minimize);
-            return ReductionEulerianPathToILP {
+            let target = ILP::new(0, Vec::new(), Vec::new(), ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?;
+            return Ok(ReductionEulerianPathToILP {
                 target,
                 pairs: Vec::new(),
                 num_arcs: 0,
-            };
+            });
         }
 
         let pairs = compatible_pairs(&arcs);
@@ -194,56 +190,55 @@ impl ReduceTo<ILP<i32>> for EulerianPath {
 
         // (1) Predecessor equality: s_a + sum_{(b,a) in P} y_{b,a} = 1.
         // (2) Successor equality:   e_a + sum_{(a,b) in P} y_{a,b} = 1.
+        let m_i64 = Self::exact_i64(m, "encoding the arc order")?;
         for a in 0..m {
-            let mut pred_terms: Vec<(usize, f64)> = vec![(s_idx(a), 1.0)];
+            let mut pred_terms: Vec<(usize, i64)> = vec![(s_idx(a), 1)];
             for &k in &incoming[a] {
-                pred_terms.push((y_idx(k), 1.0));
+                pred_terms.push((y_idx(k), 1));
             }
-            constraints.push(LinearConstraint::eq(pred_terms, 1.0));
+            constraints.push(LinearConstraint::eq(pred_terms, 1));
 
-            let mut succ_terms: Vec<(usize, f64)> = vec![(e_idx(a), 1.0)];
+            let mut succ_terms: Vec<(usize, i64)> = vec![(e_idx(a), 1)];
             for &k in &outgoing[a] {
-                succ_terms.push((y_idx(k), 1.0));
+                succ_terms.push((y_idx(k), 1));
             }
-            constraints.push(LinearConstraint::eq(succ_terms, 1.0));
+            constraints.push(LinearConstraint::eq(succ_terms, 1));
         }
 
         // (3) Binary upper bounds on start / end variables, and position
         //     upper bound on `u_a`.
         for a in 0..m {
-            constraints.push(LinearConstraint::le(vec![(s_idx(a), 1.0)], 1.0));
-            constraints.push(LinearConstraint::le(vec![(e_idx(a), 1.0)], 1.0));
-            constraints.push(LinearConstraint::le(
-                vec![(u_idx(a), 1.0)],
-                (m as f64) - 1.0,
-            ));
+            constraints.push(LinearConstraint::le(vec![(s_idx(a), 1)], 1));
+            constraints.push(LinearConstraint::le(vec![(e_idx(a), 1)], 1));
+            constraints.push(LinearConstraint::le(vec![(u_idx(a), 1)], m_i64 - 1));
         }
 
         // (4) Binary upper bounds on successor variables.
         // (5) Order consistency (MTZ): u_b >= u_a + 1 - m * (1 - y_{a,b})
         //     i.e.  u_a - u_b + m * y_{a,b} <= m - 1.
         for (k, &(a, b)) in pairs.iter().enumerate() {
-            constraints.push(LinearConstraint::le(vec![(y_idx(k), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(y_idx(k), 1)], 1));
             constraints.push(LinearConstraint::le(
-                vec![(u_idx(a), 1.0), (u_idx(b), -1.0), (y_idx(k), m as f64)],
-                (m as f64) - 1.0,
+                vec![(u_idx(a), 1), (u_idx(b), -1), (y_idx(k), m_i64)],
+                m_i64 - 1,
             ));
         }
 
         // (6) Unique start: sum_a s_a = 1.
         // (7) Unique end:   sum_a e_a = 1.
-        let start_sum: Vec<(usize, f64)> = (0..m).map(|a| (s_idx(a), 1.0)).collect();
-        let end_sum: Vec<(usize, f64)> = (0..m).map(|a| (e_idx(a), 1.0)).collect();
-        constraints.push(LinearConstraint::eq(start_sum, 1.0));
-        constraints.push(LinearConstraint::eq(end_sum, 1.0));
+        let start_sum: Vec<(usize, i64)> = (0..m).map(|a| (s_idx(a), 1)).collect();
+        let end_sum: Vec<(usize, i64)> = (0..m).map(|a| (e_idx(a), 1)).collect();
+        constraints.push(LinearConstraint::eq(start_sum, 1));
+        constraints.push(LinearConstraint::eq(end_sum, 1));
 
-        let target = ILP::new(num_vars, constraints, Vec::new(), ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, Vec::new(), ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionEulerianPathToILP {
+        Ok(ReductionEulerianPathToILP {
             target,
             pairs,
             num_arcs: m,
-        }
+        })
     }
 }
 
@@ -258,7 +253,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Witness ordering (a_0, a_2, a_3, a_1) traces 0->1->2->0->1.
             let source =
                 EulerianPath::new(DirectedGraph::new(3, vec![(0, 1), (0, 1), (1, 2), (2, 0)]));
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/exactcoverby3sets_algebraicequationsovergf2.rs b/src/rules/exactcoverby3sets_algebraicequationsovergf2.rs
index c931682fc..ace09c92b 100644
--- a/src/rules/exactcoverby3sets_algebraicequationsovergf2.rs
+++ b/src/rules/exactcoverby3sets_algebraicequationsovergf2.rs
@@ -18,18 +18,24 @@ impl ReductionResult for ReductionX3CToAlgebraicEquationsOverGF2 {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_sets",
+#[reduction(transform = upper_bound {
+    num_variables = "num_sets",
+    num_equations = "universe_size + 9 * num_sets^2",
 })]
 impl ReduceTo<AlgebraicEquationsOverGF2> for ExactCoverBy3Sets {
     type Result = ReductionX3CToAlgebraicEquationsOverGF2;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let mut sets_per_element = vec![Vec::new(); self.universe_size()];
         for (set_index, set) in self.sets().iter().enumerate() {
             for &element in set {
@@ -53,10 +59,13 @@ impl ReduceTo<AlgebraicEquationsOverGF2> for ExactCoverBy3Sets {
             }
         }
 
-        ReductionX3CToAlgebraicEquationsOverGF2 {
-            target: AlgebraicEquationsOverGF2::new(self.num_sets(), equations)
-                .expect("reduction produces valid equations"),
-        }
+        let target = AlgebraicEquationsOverGF2::new(self.num_sets(), equations).map_err(
+            crate::rules::ReductionError::construction::<
+                ExactCoverBy3Sets,
+                AlgebraicEquationsOverGF2,
+            >,
+        )?;
+        Ok(ReductionX3CToAlgebraicEquationsOverGF2 { target })
     }
 }
 
@@ -70,8 +79,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, AlgebraicEquationsOverGF2>(
                 ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]),
                 SolutionPair {
-                    source_config: vec![1, 1, 0],
-                    target_config: vec![1, 1, 0],
+                    source_config: serde_json::json!(vec![true, true, false]),
+                    target_config: serde_json::json!(vec![true, true, false]),
                 },
             )
         },
diff --git a/src/rules/exactcoverby3sets_boundeddiameterspanningtree.rs b/src/rules/exactcoverby3sets_boundeddiameterspanningtree.rs
index 27a9d654a..f87ba0c2a 100644
--- a/src/rules/exactcoverby3sets_boundeddiameterspanningtree.rs
+++ b/src/rules/exactcoverby3sets_boundeddiameterspanningtree.rs
@@ -36,17 +36,53 @@ use crate::models::set::ExactCoverBy3Sets;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::SimpleGraph;
+use std::collections::HashSet;
 
 /// Result of reducing ExactCoverBy3Sets to BoundedDiameterSpanningTree.
 #[derive(Debug, Clone)]
 pub struct ReductionX3CToBoundedDiameterSpanningTree {
-    target: BoundedDiameterSpanningTree<SimpleGraph, i32>,
+    target: BoundedDiameterSpanningTree<SimpleGraph, i64>,
     source_num_subsets: usize,
 }
 
+impl ReductionX3CToBoundedDiameterSpanningTree {
+    /// Counts for the incidence construction, checked before allocating it.
+    fn dimensions(
+        universe_size: usize,
+        m: usize,
+    ) -> Result<(usize, usize, i64), crate::rules::ReductionError> {
+        let overflow = || {
+            crate::rules::ReductionError::integer_overflow::<
+                ExactCoverBy3Sets,
+                BoundedDiameterSpanningTree<SimpleGraph, i64>,
+            >("computing bounded-diameter incidence construction dimensions")
+        };
+        let vertices = universe_size
+            .checked_add(m)
+            .and_then(|v| v.checked_add(3))
+            .ok_or_else(overflow)?;
+        let clique = match m {
+            0 => 0,
+            _ => m.checked_mul(m - 1).ok_or_else(overflow)? / 2,
+        };
+        let edges = m
+            .checked_mul(4)
+            .and_then(|v| v.checked_add(clique))
+            .and_then(|v| v.checked_add(2))
+            .ok_or_else(overflow)?;
+        let bound = (universe_size / 3)
+            .checked_mul(4)
+            .and_then(|v| v.checked_add(m))
+            .and_then(|v| v.checked_add(2))
+            .and_then(|v| i64::try_from(v).ok())
+            .ok_or_else(overflow)?;
+        Ok((vertices, edges, bound))
+    }
+}
+
 impl ReductionResult for ReductionX3CToBoundedDiameterSpanningTree {
     type Source = ExactCoverBy3Sets;
-    type Target = BoundedDiameterSpanningTree<SimpleGraph, i32>;
+    type Target = BoundedDiameterSpanningTree<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
@@ -58,44 +94,59 @@ impl ReductionResult for ReductionX3CToBoundedDiameterSpanningTree {
     /// 2..2+m (right after the forced-center path edges). For a YES-instance,
     /// the optimal target witness selects exactly q of these edges, which
     /// correspond to the q chosen subsets.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let m = self.source_num_subsets;
-        let root_to_set_offset = 2;
-        (0..m)
-            .map(|i| {
-                usize::from(
-                    target_solution
-                        .get(root_to_set_offset + i)
-                        .copied()
-                        .unwrap_or(0)
-                        == 1,
-                )
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target edge selection is not a feasible bounded-diameter spanning tree",
+            ));
+        }
+
+        Ok({
+            let m = self.source_num_subsets;
+            let root_to_set_offset = 2;
+            (0..m)
+                .map(|i| target_solution[root_to_set_offset + i])
+                .collect()
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vertices = "num_subsets + universe_size + 3",
-    num_edges = "2 + 4 * num_subsets + num_subsets * (num_subsets - 1) / 2",
-    weight_bound = "4 * universe_size / 3 + num_subsets + 2",
-    diameter_bound = "4",
-})]
-impl ReduceTo<BoundedDiameterSpanningTree<SimpleGraph, i32>> for ExactCoverBy3Sets {
+#[reduction(
+    transform = upper_bound {
+        num_vertices = "num_subsets + universe_size + 3",
+        num_edges = "2 + 4 * num_subsets + num_subsets * (num_subsets - 1) / 2",
+    })]
+impl ReduceTo<BoundedDiameterSpanningTree<SimpleGraph, i64>> for ExactCoverBy3Sets {
     type Result = ReductionX3CToBoundedDiameterSpanningTree;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let universe_size = self.universe_size();
         let m = self.num_subsets();
-        let q = self.q();
+        // Every element must occur in the collection before an exact cover can
+        // exist. Count the union without allocating an array of universe_size.
+        let covered: HashSet<_> = self.subsets().iter().flatten().copied().collect();
+        if covered.len() != universe_size {
+            // Two isolated vertices have no spanning tree. No certificate can
+            // pass validation, so the ordinary extractor is never reached.
+            return Ok(ReductionX3CToBoundedDiameterSpanningTree {
+                target: BoundedDiameterSpanningTree::new(SimpleGraph::empty(2), vec![], 1, 4),
+                source_num_subsets: m,
+            });
+        }
+        let (num_vertices, num_edges, weight_bound) =
+            ReductionX3CToBoundedDiameterSpanningTree::dimensions(universe_size, m)?;
 
         // Vertex indexing matches the docstring.
         let s_index = |i: usize| 3 + i;
         let e_index = |j: usize| 3 + m + j;
-        let num_vertices = 3 + m + universe_size;
 
-        let mut edges: Vec<(usize, usize)> = Vec::new();
-        let mut weights: Vec<i32> = Vec::new();
+        let mut edges: Vec<(usize, usize)> = Vec::with_capacity(num_edges);
+        let mut weights: Vec<i64> = Vec::with_capacity(num_edges);
 
         // Forced-center path edges (indices 0 and 1).
         edges.push((0, 1)); // (r, v_1)
@@ -132,16 +183,15 @@ impl ReduceTo<BoundedDiameterSpanningTree<SimpleGraph, i32>> for ExactCoverBy3Se
             }
         }
 
-        let weight_bound: i32 = (4 * q + m + 2) as i32;
         let diameter_bound: usize = 4;
 
         let graph = SimpleGraph::new(num_vertices, edges);
         let target = BoundedDiameterSpanningTree::new(graph, weights, weight_bound, diameter_bound);
 
-        ReductionX3CToBoundedDiameterSpanningTree {
+        Ok(ReductionX3CToBoundedDiameterSpanningTree {
             target,
             source_num_subsets: m,
-        }
+        })
     }
 }
 
@@ -158,7 +208,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5]]);
 
             // Source: select both subsets.
-            let source_config = vec![1, 1];
+            let source_config = vec![true, true];
 
             // Target spanning tree (n = 11, n-1 = 10 edges):
             //   (r,v1)=idx 0, (v1,v2)=idx 1, (r,s0)=idx 2, (r,s1)=idx 3,
@@ -170,16 +220,20 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             //   edge order = forced(2) + root-to-set(m=2) + set-to-element(6) + clique(1)
             //              = indices 0..1, 2..3, 4..9, 10
             // Select every edge except the clique edge.
-            let target_config = vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0];
+            let target_config = vec![
+                true, true, true, true, true, true, true, true, true, true, false,
+            ];
 
             crate::example_db::specs::rule_example_with_witness::<
                 _,
-                BoundedDiameterSpanningTree<SimpleGraph, i32>,
+                BoundedDiameterSpanningTree<SimpleGraph, i64>,
             >(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/exactcoverby3sets_ilp.rs b/src/rules/exactcoverby3sets_ilp.rs
index e7a81a0d3..b42f93864 100644
--- a/src/rules/exactcoverby3sets_ilp.rs
+++ b/src/rules/exactcoverby3sets_ilp.rs
@@ -21,45 +21,57 @@ impl ReductionResult for ReductionX3CToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_subsets",
         num_constraints = "universe_size + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for ExactCoverBy3Sets {
     type Result = ReductionX3CToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.num_subsets();
         let mut constraints = Vec::new();
 
         // For each element e: Σ_{j: e ∈ triple_j} x_j = 1
         for element in 0..self.universe_size() {
-            let terms: Vec<(usize, f64)> = self
+            let terms: Vec<(usize, i64)> = self
                 .subsets()
                 .iter()
                 .enumerate()
                 .filter(|(_, subset)| subset.contains(&element))
-                .map(|(j, _)| (j, 1.0))
+                .map(|(j, _)| (j, 1))
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Σ x_j = universe_size / 3
-        let cardinality_terms: Vec<(usize, f64)> = (0..num_vars).map(|j| (j, 1.0)).collect();
+        let cardinality_terms: Vec<(usize, i64)> = (0..num_vars).map(|j| (j, 1)).collect();
         constraints.push(LinearConstraint::eq(
             cardinality_terms,
-            (self.universe_size() / 3) as f64,
+            <Self as ReduceTo<ILP<bool>>>::exact_i64(
+                self.universe_size() / 3,
+                "encoding the exact-cover cardinality",
+            )?,
         ));
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionX3CToILP { target }
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
+        Ok(ReductionX3CToILP { target })
     }
 }
 
@@ -74,8 +86,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 0, 0],
-                    target_config: vec![1, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, true, false, false]),
+                    target_config: serde_json::json!(vec![1, 1, 0, 0]),
                 },
             )
         },
diff --git a/src/rules/exactcoverby3sets_maximumsetpacking.rs b/src/rules/exactcoverby3sets_maximumsetpacking.rs
index 8718485c6..60536abc0 100644
--- a/src/rules/exactcoverby3sets_maximumsetpacking.rs
+++ b/src/rules/exactcoverby3sets_maximumsetpacking.rs
@@ -1,7 +1,7 @@
 //! Reduction from ExactCoverBy3Sets to MaximumSetPacking.
 //!
 //! Given an X3C instance with universe X (|X| = 3q) and collection C of
-//! 3-element subsets, construct a MaximumSetPacking<One> instance where each
+//! 3-element subsets, construct a `MaximumSetPacking<One>` instance where each
 //! triple becomes a variable-length set with unit weight. An exact cover
 //! of q disjoint triples corresponds to a maximum packing of value q.
 
@@ -29,27 +29,37 @@ impl ReductionResult for ReductionXC3SToMaximumSetPacking {
     /// The configuration is identity (same binary selection vector).
     /// A packing of q disjoint 3-sets over a 3q-element universe is necessarily
     /// an exact cover, so no additional checking is needed.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
-#[reduction(overhead = {
-    num_sets = "num_subsets",
-})]
+#[reduction(
+    transform = exact {
+        num_sets = "num_subsets",
+    },
+    unavailable = {
+        universe_size = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<MaximumSetPacking<One>> for ExactCoverBy3Sets {
     type Result = ReductionXC3SToMaximumSetPacking;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let sets: Vec<Vec<usize>> = self
             .subsets()
             .iter()
             .map(|triple| triple.to_vec())
             .collect();
 
-        ReductionXC3SToMaximumSetPacking {
+        Ok(ReductionXC3SToMaximumSetPacking {
             target: MaximumSetPacking::<One>::new(sets),
-        }
+        })
     }
 }
 
@@ -69,8 +79,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, MaximumSetPacking<One>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 0, 1, 0, 0],
-                    target_config: vec![1, 0, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, false, true, false, false]),
+                    target_config: serde_json::json!(vec![true, false, true, false, false]),
                 },
             )
         },
diff --git a/src/rules/exactcoverby3sets_minimumaxiomset.rs b/src/rules/exactcoverby3sets_minimumaxiomset.rs
index a09c2ebbd..5c9827351 100644
--- a/src/rules/exactcoverby3sets_minimumaxiomset.rs
+++ b/src/rules/exactcoverby3sets_minimumaxiomset.rs
@@ -29,23 +29,31 @@ impl ReductionResult for ReductionXC3SToMinimumAxiomSet {
     /// For YES-instances, every optimal target witness of value q consists only of
     /// q set-sentences, which form an exact cover. For NO-instances, the extracted
     /// vector may be non-satisfying, which is expected for an `Or -> Min` rule.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let set_offset = self.source_universe_size;
-        (0..self.source_num_subsets)
-            .map(|j| usize::from(target_solution.get(set_offset + j).copied().unwrap_or(0) > 0))
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let set_offset = self.source_universe_size;
+            (0..self.source_num_subsets)
+                .map(|j| target_solution[set_offset + j])
+                .collect()
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_sentences = "universe_size + num_subsets",
-    num_true_sentences = "universe_size + num_subsets",
-    num_implications = "4 * num_subsets",
-})]
+#[reduction(
+    transform = exact {
+        num_sentences = "universe_size + num_subsets",
+        num_true_sentences = "universe_size + num_subsets",
+        num_implications = "4 * num_subsets",
+    })]
 impl ReduceTo<MinimumAxiomSet> for ExactCoverBy3Sets {
     type Result = ReductionXC3SToMinimumAxiomSet;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let universe_size = self.universe_size();
         let num_subsets = self.num_subsets();
         let num_sentences = universe_size + num_subsets;
@@ -62,11 +70,11 @@ impl ReduceTo<MinimumAxiomSet> for ExactCoverBy3Sets {
         let target =
             MinimumAxiomSet::new(num_sentences, (0..num_sentences).collect(), implications);
 
-        ReductionXC3SToMinimumAxiomSet {
+        Ok(ReductionXC3SToMinimumAxiomSet {
             target,
             source_universe_size: universe_size,
             source_num_subsets: num_subsets,
-        }
+        })
     }
 }
 
@@ -84,8 +92,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, MinimumAxiomSet>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 1, 1],
-                    target_config: vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
+                    source_config: serde_json::json!(vec![false, false, false, true, true]),
+                    target_config: serde_json::json!(vec![
+                        false, false, false, false, false, false, false, false, false, true, true
+                    ]),
                 },
             )
         },
diff --git a/src/rules/exactcoverby3sets_minimumfaultdetectiontestset.rs b/src/rules/exactcoverby3sets_minimumfaultdetectiontestset.rs
index 427c9d01f..eb2846373 100644
--- a/src/rules/exactcoverby3sets_minimumfaultdetectiontestset.rs
+++ b/src/rules/exactcoverby3sets_minimumfaultdetectiontestset.rs
@@ -24,21 +24,27 @@ impl ReductionResult for ReductionXC3SToMinimumFaultDetectionTestSet {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|row| row[0]).collect())
     }
 }
 
-#[reduction(overhead = {
-    num_vertices = "num_subsets + universe_size + 1",
-    num_arcs = "3 * num_subsets + universe_size",
-    num_inputs = "num_subsets",
-    num_outputs = "1",
-})]
+#[reduction(
+    transform = exact {
+        num_vertices = "num_subsets + universe_size + 1",
+        num_arcs = "3 * num_subsets + universe_size",
+        num_inputs = "num_subsets",
+        num_outputs = "1",
+    })]
 impl ReduceTo<MinimumFaultDetectionTestSet> for ExactCoverBy3Sets {
     type Result = ReductionXC3SToMinimumFaultDetectionTestSet;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_inputs = self.num_subsets();
         let element_offset = num_inputs;
         let output = element_offset + self.universe_size();
@@ -53,14 +59,14 @@ impl ReduceTo<MinimumFaultDetectionTestSet> for ExactCoverBy3Sets {
             arcs.push((element_offset + element, output));
         }
 
-        ReductionXC3SToMinimumFaultDetectionTestSet {
+        Ok(ReductionXC3SToMinimumFaultDetectionTestSet {
             target: MinimumFaultDetectionTestSet::new(
                 output + 1,
                 arcs,
                 (0..num_inputs).collect(),
                 vec![output],
             ),
-        }
+        })
     }
 }
 
@@ -75,8 +81,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, MinimumFaultDetectionTestSet>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 0],
-                    target_config: vec![1, 1, 0],
+                    source_config: serde_json::json!(vec![true, true, false]),
+                    target_config: serde_json::json!(vec![vec![true], vec![true], vec![false]]),
                 },
             )
         },
diff --git a/src/rules/exactcoverby3sets_staffscheduling.rs b/src/rules/exactcoverby3sets_staffscheduling.rs
index 68684bc5e..3721b7fb9 100644
--- a/src/rules/exactcoverby3sets_staffscheduling.rs
+++ b/src/rules/exactcoverby3sets_staffscheduling.rs
@@ -33,16 +33,18 @@ impl ReductionResult for ReductionXC3SToStaffScheduling {
     ///
     /// StaffScheduling config[j] = number of workers assigned to schedule j.
     /// XC3S config[j] = 1 if subset j is selected, 0 otherwise.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution
-            .iter()
-            .map(|&count| if count > 0 { 1 } else { 0 })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&count| count > 0).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_periods = "universe_size",
         num_schedules = "num_subsets",
         num_workers = "universe_size / 3",
@@ -51,7 +53,7 @@ impl ReductionResult for ReductionXC3SToStaffScheduling {
 impl ReduceTo<StaffScheduling> for ExactCoverBy3Sets {
     type Result = ReductionXC3SToStaffScheduling;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let universe_size = self.universe_size();
         let q = universe_size / 3;
 
@@ -69,16 +71,21 @@ impl ReduceTo<StaffScheduling> for ExactCoverBy3Sets {
             .collect();
 
         // Each period requires exactly 1 worker
-        let requirements = vec![1u64; universe_size];
+        let requirements = vec![1i64; universe_size];
+        let num_workers = i64::try_from(q).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<ExactCoverBy3Sets, StaffScheduling>(
+                "converting the exact-cover set count to an i64 worker count",
+            )
+        })?;
 
         let target = StaffScheduling::new(
             3, // shifts_per_schedule
             schedules,
             requirements,
-            q as u64, // num_workers = q
+            num_workers,
         );
 
-        ReductionXC3SToStaffScheduling { target }
+        Ok(ReductionXC3SToStaffScheduling { target })
     }
 }
 
@@ -97,8 +104,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, StaffScheduling>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 0, 0],
-                    target_config: vec![1, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, true, false, false]),
+                    target_config: serde_json::json!(vec![1, 1, 0, 0]),
                 },
             )
         },
diff --git a/src/rules/exactcoverby3sets_subsetproduct.rs b/src/rules/exactcoverby3sets_subsetproduct.rs
index 3b6aa896e..4084f1a40 100644
--- a/src/rules/exactcoverby3sets_subsetproduct.rs
+++ b/src/rules/exactcoverby3sets_subsetproduct.rs
@@ -26,8 +26,13 @@ impl ReductionResult for ReductionX3CToSubsetProduct {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
@@ -53,13 +58,14 @@ fn assigned_primes(universe_size: usize) -> Vec<u64> {
     }
 }
 
-#[reduction(overhead = {
-    num_elements = "num_sets",
-})]
+#[reduction(
+    transform = exact {
+        num_elements = "num_sets",
+    })]
 impl ReduceTo<SubsetProduct> for ExactCoverBy3Sets {
     type Result = ReductionX3CToSubsetProduct;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let primes = assigned_primes(self.universe_size());
         let values = self
             .sets()
@@ -68,9 +74,9 @@ impl ReduceTo<SubsetProduct> for ExactCoverBy3Sets {
             .collect();
         let target = product_biguint(primes.iter().copied());
 
-        ReductionX3CToSubsetProduct {
+        Ok(ReductionX3CToSubsetProduct {
             target: SubsetProduct::new(values, target),
-        }
+        })
     }
 }
 
@@ -84,8 +90,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, SubsetProduct>(
                 ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]),
                 SolutionPair {
-                    source_config: vec![1, 1, 0],
-                    target_config: vec![1, 1, 0],
+                    source_config: serde_json::json!(vec![true, true, false]),
+                    target_config: serde_json::json!(vec![true, true, false]),
                 },
             )
         },
diff --git a/src/rules/expectedretrievalcost_ilp.rs b/src/rules/expectedretrievalcost_ilp.rs
index 23b285509..a2d76cefb 100644
--- a/src/rules/expectedretrievalcost_ilp.rs
+++ b/src/rules/expectedretrievalcost_ilp.rs
@@ -17,6 +17,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::ExpectedRetrievalCost;
 use crate::reduction;
+use crate::rules::ilp_helpers::{mccormick_product, one_hot_decode_rows};
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Compute the latency distance between sectors on a circular device.
@@ -40,7 +41,7 @@ fn latency_distance(num_sectors: usize, source: usize, target: usize) -> usize {
 /// Total: num_records * num_sectors + (num_records * num_sectors)^2 variables.
 #[derive(Debug, Clone)]
 pub struct ReductionERCToILP {
-    target: ILP<bool>,
+    target: ILP<bool, f64>,
     num_records: usize,
     num_sectors: usize,
 }
@@ -58,38 +59,36 @@ impl ReductionERCToILP {
 
 impl ReductionResult for ReductionERCToILP {
     type Source = ExpectedRetrievalCost;
-    type Target = ILP<bool>;
+    type Target = ILP<bool, f64>;
 
-    fn target_problem(&self) -> &ILP<bool> {
+    fn target_problem(&self) -> &ILP<bool, f64> {
         &self.target
     }
 
     /// Extract solution: for each record r, find the unique sector s where x_{r,s} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_sectors = self.num_sectors;
-        (0..self.num_records)
-            .map(|r| {
-                (0..num_sectors)
-                    .find(|&s| {
-                        let idx = r * num_sectors + s;
-                        idx < target_solution.len() && target_solution[idx] == 1
-                    })
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        one_hot_decode_rows(target_solution, self.num_records, self.num_sectors, 0)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_records * num_sectors + num_records^2 * num_sectors^2",
         num_constraints = "num_records + 3 * num_records^2 * num_sectors^2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for ExpectedRetrievalCost {
+impl ReduceTo<ILP<bool, f64>> for ExpectedRetrievalCost {
     type Result = ReductionERCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_records = self.num_records();
         let num_sectors = self.num_sectors();
         let n = num_records * num_sectors; // total x variables
@@ -101,7 +100,7 @@ impl ReduceTo<ILP<bool>> for ExpectedRetrievalCost {
             num_sectors,
         };
 
-        let mut constraints = Vec::new();
+        let mut constraints: Vec<LinearConstraint<f64>> = Vec::new();
 
         // Assignment constraints: for each record r, Σ_s x_{r,s} = 1
         for r in 0..num_records {
@@ -123,15 +122,7 @@ impl ReduceTo<ILP<bool>> for ExpectedRetrievalCost {
                         let x1 = result.x_var(r, s);
                         let x2 = result.x_var(r2, s2);
 
-                        // z ≤ x_{r,s}: z - x_{r,s} ≤ 0
-                        constraints.push(LinearConstraint::le(vec![(z, 1.0), (x1, -1.0)], 0.0));
-                        // z ≤ x_{r',s'}: z - x_{r',s'} ≤ 0
-                        constraints.push(LinearConstraint::le(vec![(z, 1.0), (x2, -1.0)], 0.0));
-                        // z ≥ x_{r,s} + x_{r',s'} - 1: -z + x_{r,s} + x_{r',s'} ≤ 1
-                        constraints.push(LinearConstraint::le(
-                            vec![(z, -1.0), (x1, 1.0), (x2, 1.0)],
-                            1.0,
-                        ));
+                        constraints.extend(mccormick_product(z, x1, x2));
                     }
                 }
             }
@@ -157,13 +148,14 @@ impl ReduceTo<ILP<bool>> for ExpectedRetrievalCost {
             }
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionERCToILP {
+        Ok(ReductionERCToILP {
             target,
             num_records,
             num_sectors,
-        }
+        })
     }
 }
 
@@ -176,18 +168,20 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             // 2 records with probabilities [0.5, 0.5], 2 sectors
             // Assignment: record 0 → sector 0, record 1 → sector 1
-            let source = ExpectedRetrievalCost::new(vec![0.5, 0.5], 2);
+            let source = ExpectedRetrievalCost::new(vec![0.5, 0.5], 2).unwrap();
             // Compute target_config from solver to ensure consistency
-            let reduction: ReductionERCToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+            let reduction: ReductionERCToILP =
+                ReduceTo::<ILP<bool, f64>>::reduce_to(&source).expect("reduction should succeed");
             let solver = crate::solvers::ILPSolver::new();
             let target_config = solver
                 .solve(reduction.target_problem())
                 .expect("canonical example should be feasible");
-            crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
+            crate::example_db::specs::rule_example_with_witness::<_, ILP<bool, f64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1],
-                    target_config,
+                    source_config: serde_json::json!(vec![0, 1]),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/factoring_circuit.rs b/src/rules/factoring_circuit.rs
index b000c7c8e..330406035 100644
--- a/src/rules/factoring_circuit.rs
+++ b/src/rules/factoring_circuit.rs
@@ -11,6 +11,8 @@ use crate::models::formula::{Assignment, BooleanExpr, Circuit, CircuitSAT};
 use crate::models::misc::Factoring;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
+use num_bigint::BigUint;
+use num_traits::{One, Zero};
 /// Result of reducing Factoring to CircuitSAT.
 ///
 /// This struct contains:
@@ -40,40 +42,75 @@ impl ReductionResult for ReductionFactoringToCircuit {
 
     /// Extract a Factoring solution from a CircuitSAT solution.
     ///
-    /// Returns a configuration where the first m bits are the first factor p,
-    /// and the next n bits are the second factor q.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let var_names = self.target.variable_names();
-
-        // Build a map from variable name to its value
-        let var_map: std::collections::HashMap<&str, usize> = var_names
-            .iter()
-            .enumerate()
-            .map(|(i, name)| (name.as_str(), target_solution.get(i).copied().unwrap_or(0)))
-            .collect();
-
-        // Extract p bits
-        let p_bits: Vec<usize> = self
-            .p_vars
-            .iter()
-            .map(|name| *var_map.get(name.as_str()).unwrap_or(&0))
-            .collect();
-
-        // Extract q bits
-        let q_bits: Vec<usize> = self
-            .q_vars
-            .iter()
-            .map(|name| *var_map.get(name.as_str()).unwrap_or(&0))
-            .collect();
-
-        // Concatenate p and q bits
-        let mut result = p_bits;
-        result.extend(q_bits);
-        result
+    /// Returns the decoded factors in ascending order.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target assignment does not satisfy the multiplication circuit",
+            ));
+        }
+
+        Ok({
+            let var_names = self.target.variable_names();
+
+            // Build a map from variable name to its value
+            let var_map: std::collections::HashMap<&str, bool> = var_names
+                .iter()
+                .enumerate()
+                .map(|(i, name)| (name.as_str(), target_solution[i]))
+                .collect();
+
+            let decode = |names: &[String]| {
+                names
+                    .iter()
+                    .enumerate()
+                    .try_fold(BigUint::zero(), |value, (index, name)| {
+                        let bit = var_map.get(name.as_str()).copied().ok_or_else(|| {
+                            crate::rules::ExtractionError::invalid(format!(
+                                "target circuit does not contain factor variable {name}"
+                            ))
+                        })?;
+                        Ok::<BigUint, crate::rules::ExtractionError>(if bit {
+                            value + (BigUint::one() << index)
+                        } else {
+                            value
+                        })
+                    })
+            };
+            let left = decode(&self.p_vars)?;
+            let right = decode(&self.q_vars)?;
+            if left <= right {
+                (left, right)
+            } else {
+                (right, left)
+            }
+        })
     }
 }
 
 impl ReductionFactoringToCircuit {
+    /// Product width and assignment capacity, checked before circuit allocation.
+    fn dimensions(m: usize, n: usize) -> Result<(usize, usize), crate::rules::ReductionError> {
+        let overflow = || {
+            crate::rules::ReductionError::integer_overflow::<Factoring, CircuitSAT>(
+                "computing multiplication circuit dimensions",
+            )
+        };
+        let width = m.checked_add(n).ok_or_else(overflow)?;
+        let capacity = m
+            .checked_mul(n)
+            .and_then(|v| v.checked_mul(6))
+            .and_then(|v| width.checked_mul(2).and_then(|w| v.checked_add(w)))
+            .and_then(|v| v.checked_add(2))
+            .ok_or_else(overflow)?;
+        Ok((width, capacity))
+    }
+
     /// Get the variable names for the first factor.
     pub fn p_vars(&self) -> &[String] {
         &self.p_vars
@@ -91,11 +128,11 @@ impl ReductionFactoringToCircuit {
 }
 
 /// Read the i-th bit (1-indexed) of a number (little-endian).
-fn read_bit(n: u64, i: usize) -> bool {
-    if i == 0 || i > 64 {
+fn read_bit(n: &BigUint, i: usize) -> bool {
+    if i == 0 {
         false
     } else {
-        ((n >> (i - 1)) & 1) == 1
+        n.bit(u64::try_from(i - 1).expect("bit index fits u64"))
     }
 }
 
@@ -175,29 +212,42 @@ fn build_multiplier_cell(
     (assignments, ancillas)
 }
 
-#[reduction(overhead = {
-    num_variables = "6 * num_bits_first * num_bits_second + num_bits_first + num_bits_second",
-    num_assignments = "6 * num_bits_first * num_bits_second + num_bits_first + num_bits_second",
-})]
+#[reduction(
+    transform = upper_bound {
+        num_variables = "6 * num_bits_first * num_bits_second + 2 * (num_bits_first + num_bits_second) + 1",
+        num_assignments = "6 * num_bits_first * num_bits_second + 2 * (num_bits_first + num_bits_second) + 2",
+    },
+    unavailable = {
+        num_assignment_outputs = "the exact target parameter is not represented by this reduction's symbolic transform",
+        num_expression_nodes = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<CircuitSAT> for Factoring {
     type Result = ReductionFactoringToCircuit;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n1 = self.m(); // bits for first factor
         let n2 = self.n(); // bits for second factor
         let target = self.target();
+        let (width, capacity) = ReductionFactoringToCircuit::dimensions(n1, n2)?;
 
         // Create input variables for the two factors
         let p_vars: Vec<String> = (1..=n1).map(|i| format!("p{}", i)).collect();
         let q_vars: Vec<String> = (1..=n2).map(|i| format!("q{}", i)).collect();
 
         // Accumulate assignments and product bits
-        let mut assignments = Vec::new();
-        let mut m_vars = Vec::new();
+        let mut assignments = Vec::with_capacity(capacity);
+        let mut product_bits = Vec::with_capacity(width);
 
         // Initialize s_pre (previous sum signals) with false constants
         // s_pre has n2+1 elements to handle the carry propagation
-        let mut s_pre: Vec<BooleanExpr> = (0..=n2).map(|_| BooleanExpr::constant(false)).collect();
+        let mut s_pre = Vec::with_capacity(n2 + 1);
+        s_pre.push(BooleanExpr::constant(false));
+        // The zero accumulator is expressed as Q AND zero. This also keeps
+        // every Q input in the circuit when no multiplier rows are present.
+        s_pre.extend(q_vars.iter().map(|name| {
+            BooleanExpr::and(vec![BooleanExpr::var(name), BooleanExpr::constant(false)])
+        }));
 
         // Build the array multiplier row by row
         for i in 1..=n1 {
@@ -235,15 +285,17 @@ impl ReduceTo<CircuitSAT> for Factoring {
             s_pre[n2] = c_pre;
 
             // The first element of s_pre is the i-th bit of the product
-            m_vars.push(format!("s{}_{}", i, 1));
+            product_bits.push(s_pre[0].clone());
         }
 
-        // The remaining bits of the product come from s_pre[1..=n2]
-        for j in 2..=n2 {
-            m_vars.push(format!("s{}_{}", n1, j));
+        // After all rows, the residual accumulator supplies the remaining
+        // high bits. With zero rows these are the actual zero expressions,
+        // not names of multiplier cells that were never constructed.
+        product_bits.extend(s_pre.into_iter().skip(1));
+        let m_vars: Vec<_> = (0..width).map(|i| format!("product_{i}")).collect();
+        for (name, expr) in m_vars.iter().zip(product_bits) {
+            assignments.push(Assignment::new(vec![name.clone()], expr));
         }
-        // The final carry is the last bit
-        m_vars.push(format!("c{}_{}", n1, n2));
 
         // Constrain the output bits to match the target number
         for (i, m_var) in m_vars.iter().enumerate() {
@@ -254,16 +306,27 @@ impl ReduceTo<CircuitSAT> for Factoring {
             ));
         }
 
+        // An m-bit by n-bit product cannot contain a set bit above position m+n-1.
+        // Encode an explicit contradiction instead of truncating an oversized target.
+        if target.bits() > u64::try_from(m_vars.len()).expect("product width fits u64") {
+            let overflow = "target_overflow".to_string();
+            assignments.push(Assignment::new(
+                vec![overflow.clone()],
+                BooleanExpr::constant(false),
+            ));
+            assignments.push(Assignment::new(vec![overflow], BooleanExpr::constant(true)));
+        }
+
         // Build the circuit
         let circuit = Circuit::new(assignments);
         let circuit_sat = CircuitSAT::new(circuit);
 
-        ReductionFactoringToCircuit {
+        Ok(ReductionFactoringToCircuit {
             target: circuit_sat,
             p_vars,
             q_vars,
             m_vars,
-        }
+        })
     }
 }
 
@@ -275,14 +338,18 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "factoring_to_circuitsat",
         build: || {
             crate::example_db::specs::rule_example_with_witness::<_, CircuitSAT>(
-                Factoring::new(3, 3, 35),
+                Factoring::with_factor_bits(35, 3, 3),
                 SolutionPair {
-                    source_config: vec![1, 0, 1, 1, 1, 1],
-                    target_config: vec![
-                        1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0,
-                        1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1,
-                        1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
-                    ],
+                    source_config: serde_json::to_value((BigUint::from(5u32), BigUint::from(7u32)))
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::json!(vec![
+                        true, true, true, false, false, false, true, true, true, false, false,
+                        false, false, false, false, true, false, false, true, true, true, true,
+                        true, false, false, true, true, false, false, false, false, false, false,
+                        false, true, true, false, false, false, false, false, false, true, true,
+                        true, true, false, true, true, true, false, false, false, true, true, true,
+                        true, true, true, true, true, true, false, false, false, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/factoring_ilp.rs b/src/rules/factoring_ilp.rs
index a3bffb0e9..eef11666f 100644
--- a/src/rules/factoring_ilp.rs
+++ b/src/rules/factoring_ilp.rs
@@ -22,6 +22,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::Factoring;
 use crate::reduction;
+use crate::rules::ilp_helpers::mccormick_product;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use std::cmp::min;
 
@@ -33,7 +34,7 @@ use std::cmp::min;
 /// - Constraints enforce the multiplication equals the target
 #[derive(Debug, Clone)]
 pub struct ReductionFactoringToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     m: usize, // bits for first factor
     n: usize, // bits for second factor
 }
@@ -64,9 +65,9 @@ impl ReductionFactoringToILP {
 
 impl ReductionResult for ReductionFactoringToILP {
     type Source = Factoring;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
@@ -74,43 +75,54 @@ impl ReductionResult for ReductionFactoringToILP {
     ///
     /// The first m variables are p_i (first factor bits).
     /// The next n variables are q_j (second factor bits).
-    /// Returns concatenated bit vector [p_0, ..., p_{m-1}, q_0, ..., q_{n-1}].
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Extract p bits (first factor)
-        let p_bits: Vec<usize> = (0..self.m)
-            .map(|i| target_solution.get(self.p_var(i)).copied().unwrap_or(0))
-            .collect();
-
-        // Extract q bits (second factor)
-        let q_bits: Vec<usize> = (0..self.n)
-            .map(|j| target_solution.get(self.q_var(j)).copied().unwrap_or(0))
-            .collect();
-
-        // Concatenate p and q bits
-        let mut result = p_bits;
-        result.extend(q_bits);
-        result
+    /// Returns the decoded factors in ascending order.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // Extract p bits (first factor)
+            let p = (0..self.m)
+                .filter(|&i| target_solution[self.p_var(i)] == 1)
+                .fold(num_bigint::BigUint::from(0u8), |value, index| {
+                    value + (num_bigint::BigUint::from(1u8) << index)
+                });
+
+            // Extract q bits (second factor)
+            let q = (0..self.n)
+                .filter(|&j| target_solution[self.q_var(j)] == 1)
+                .fold(num_bigint::BigUint::from(0u8), |value, index| {
+                    value + (num_bigint::BigUint::from(1u8) << index)
+                });
+            if p <= q {
+                (p, q)
+            } else {
+                (q, p)
+            }
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_bits_first * num_bits_second",
-    num_constraints = "num_bits_first * num_bits_second",
-})]
-impl ReduceTo<ILP<i32>> for Factoring {
+#[reduction(transform = upper_bound {
+    num_vars = "num_bits_first * num_bits_second + 2 * num_bits_first + 2 * num_bits_second + target_bits",
+    num_constraints = "3 * num_bits_first * num_bits_second + 4 * num_bits_first + 4 * num_bits_second + 3 * target_bits + 1",
+},
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<i64>> for Factoring {
     type Result = ReductionFactoringToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.m();
         let n = self.n();
         let target = self.target();
 
         // Calculate the number of bits needed for the target
-        let target_bits = if target == 0 {
-            1
-        } else {
-            (64 - target.leading_zeros()) as usize
-        };
+        let target_bits = self.target_bits();
 
         // Number of bit positions to check: max(m+n, target_bits)
         // For feasible instances, target_bits <= m+n (product of m-bit × n-bit has at most m+n bits).
@@ -144,17 +156,7 @@ impl ReduceTo<ILP<i32>> for Factoring {
                 let p = p_var(i);
                 let q = q_var(j);
 
-                // z_ij - p_i ≤ 0
-                constraints.push(LinearConstraint::le(vec![(z, 1.0), (p, -1.0)], 0.0));
-
-                // z_ij - q_j ≤ 0
-                constraints.push(LinearConstraint::le(vec![(z, 1.0), (q, -1.0)], 0.0));
-
-                // z_ij - p_i - q_j ≥ -1
-                constraints.push(LinearConstraint::ge(
-                    vec![(z, 1.0), (p, -1.0), (q, -1.0)],
-                    -1.0,
-                ));
+                constraints.extend(mccormick_product(z, p, q));
             }
         }
 
@@ -163,61 +165,59 @@ impl ReduceTo<ILP<i32>> for Factoring {
         //   Σ_{i+j=k} z_ij + c_{k-1} = N_k + 2·c_k
         // Rearranged: Σ_{i+j=k} z_ij + c_{k-1} - 2·c_k = N_k
         for k in 0..num_bit_positions {
-            let mut terms: Vec<(usize, f64)> = Vec::new();
+            let mut terms: Vec<(usize, i64)> = Vec::new();
 
             // Collect all z_ij where i + j = k
             for i in 0..m {
                 if k >= i && k - i < n {
                     let j = k - i;
-                    terms.push((z_var(i, j), 1.0));
+                    terms.push((z_var(i, j), 1));
                 }
             }
 
             // Add carry_in (from position k-1)
             if k > 0 {
-                terms.push((carry_var(k - 1), 1.0));
+                terms.push((carry_var(k - 1), 1));
             }
 
             // Subtract 2 × carry_out
-            terms.push((carry_var(k), -2.0));
+            terms.push((carry_var(k), -2));
 
-            // RHS is N_k (k-th bit of target). For k >= 64, the bit is 0 for u64.
-            let n_k = if k < 64 {
-                ((target >> k) & 1) as f64
-            } else {
-                0.0
-            };
+            // RHS is N_k (k-th bit of target).
+            let n_k = i64::from(target.bit(u64::try_from(k).expect("bit index fits u64")));
             constraints.push(LinearConstraint::eq(terms, n_k));
         }
 
         // Constraint 3: Final carry must be zero (no overflow)
         constraints.push(LinearConstraint::eq(
-            vec![(carry_var(num_bit_positions - 1), 1.0)],
-            0.0,
+            vec![(carry_var(num_bit_positions - 1), 1)],
+            0,
         ));
 
         // Constraint 4: Binary bounds for p_i and q_j (enforce 0/1 in integer domain)
         for i in 0..m {
-            constraints.push(LinearConstraint::le(vec![(p_var(i), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(p_var(i), 1)], 1));
         }
         for j in 0..n {
-            constraints.push(LinearConstraint::le(vec![(q_var(j), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(q_var(j), 1)], 1));
         }
 
         // Constraint 5: Carry bounds (0 ≤ c_k ≤ min(m, n))
-        let carry_upper = min(m, n) as f64;
+        let carry_upper =
+            <Self as ReduceTo<ILP<i64>>>::exact_i64(min(m, n), "encoding a carry bound")?;
         for k in 0..num_carries {
             let cv = carry_var(k);
-            constraints.push(LinearConstraint::ge(vec![(cv, 1.0)], 0.0));
-            constraints.push(LinearConstraint::le(vec![(cv, 1.0)], carry_upper));
+            constraints.push(LinearConstraint::ge(vec![(cv, 1)], 0));
+            constraints.push(LinearConstraint::le(vec![(cv, 1)], carry_upper));
         }
 
         // Objective: feasibility problem (minimize 0)
-        let objective: Vec<(usize, f64)> = vec![];
+        let objective: Vec<(usize, i64)> = vec![];
 
-        let ilp = ILP::<i32>::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let ilp = ILP::<i64>::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<i64>>>::target_construction)?;
 
-        ReductionFactoringToILP { target: ilp, m, n }
+        Ok(ReductionFactoringToILP { target: ilp, m, n })
     }
 }
 
@@ -226,8 +226,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "factoring_to_ilp",
         build: || {
-            let source = Factoring::new(3, 3, 35);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            let source = Factoring::with_factor_bits(35, 3, 3);
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/feasibleregisterassignment_ilp.rs b/src/rules/feasibleregisterassignment_ilp.rs
index def32c86d..69b181c5d 100644
--- a/src/rules/feasibleregisterassignment_ilp.rs
+++ b/src/rules/feasibleregisterassignment_ilp.rs
@@ -17,31 +17,41 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 
 #[derive(Debug, Clone)]
 pub struct ReductionFeasibleRegisterAssignmentToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_vertices: usize,
 }
 
 impl ReductionResult for ReductionFeasibleRegisterAssignmentToILP {
     type Source = FeasibleRegisterAssignment;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::decode_usize_values(&target_solution[..self.num_vertices])
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "2 * num_vertices + num_vertices * (num_vertices - 1) / 2",
-    num_constraints = "3 * num_vertices * (num_vertices - 1) / 2 + 3 * num_vertices + 2 * num_arcs + 2 * num_same_register_pairs",
-})]
-impl ReduceTo<ILP<i32>> for FeasibleRegisterAssignment {
+#[reduction(
+    transform = exact {
+        num_vars = "2 * num_vertices + num_vertices * (num_vertices - 1) / 2",
+        num_constraints = "3 * num_vertices * (num_vertices - 1) / 2 + 3 * num_vertices + 2 * num_arcs + 2 * num_same_register_pairs",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<i64>> for FeasibleRegisterAssignment {
     type Result = ReductionFeasibleRegisterAssignmentToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let pair_list: Vec<(usize, usize)> = (0..n)
             .flat_map(|u| ((u + 1)..n).map(move |v| (u, v)))
@@ -56,7 +66,9 @@ impl ReduceTo<ILP<i32>> for FeasibleRegisterAssignment {
 
         let num_pair_vars = pair_list.len();
         let num_vars = 2 * n + num_pair_vars;
-        let big_m = n as f64;
+        let big_m = Self::exact_i64(n, "encoding the schedule order")?;
+        let last_position =
+            Self::exact_i64(n.saturating_sub(1), "encoding the final schedule position")?;
 
         let time_idx = |vertex: usize| -> usize { vertex };
         let latest_idx = |vertex: usize| -> usize { n + vertex };
@@ -68,67 +80,60 @@ impl ReduceTo<ILP<i32>> for FeasibleRegisterAssignment {
 
         for vertex in 0..n {
             constraints.push(LinearConstraint::le(
-                vec![(time_idx(vertex), 1.0)],
-                (n.saturating_sub(1)) as f64,
+                vec![(time_idx(vertex), 1)],
+                last_position,
             ));
             constraints.push(LinearConstraint::le(
-                vec![(latest_idx(vertex), 1.0)],
-                (n.saturating_sub(1)) as f64,
+                vec![(latest_idx(vertex), 1)],
+                last_position,
             ));
             constraints.push(LinearConstraint::ge(
-                vec![(latest_idx(vertex), 1.0), (time_idx(vertex), -1.0)],
-                0.0,
+                vec![(latest_idx(vertex), 1), (time_idx(vertex), -1)],
+                0,
             ));
         }
 
         for &(dependent, dependency) in self.arcs() {
             constraints.push(LinearConstraint::ge(
-                vec![(time_idx(dependent), 1.0), (time_idx(dependency), -1.0)],
-                1.0,
+                vec![(time_idx(dependent), 1), (time_idx(dependency), -1)],
+                1,
             ));
             constraints.push(LinearConstraint::ge(
-                vec![(latest_idx(dependency), 1.0), (time_idx(dependent), -1.0)],
-                0.0,
+                vec![(latest_idx(dependency), 1), (time_idx(dependent), -1)],
+                0,
             ));
         }
 
         for (pair_idx, &(u, v)) in pair_list.iter().enumerate() {
             let order_var = order_idx(pair_idx);
-            constraints.push(LinearConstraint::le(vec![(order_var, 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(order_var, 1)], 1));
             constraints.push(LinearConstraint::ge(
-                vec![(time_idx(v), 1.0), (time_idx(u), -1.0), (order_var, -big_m)],
-                1.0 - big_m,
+                vec![(time_idx(v), 1), (time_idx(u), -1), (order_var, -big_m)],
+                1 - big_m,
             ));
             constraints.push(LinearConstraint::ge(
-                vec![(time_idx(u), 1.0), (time_idx(v), -1.0), (order_var, big_m)],
-                1.0,
+                vec![(time_idx(u), 1), (time_idx(v), -1), (order_var, big_m)],
+                1,
             ));
         }
 
         for &(u, v, pair_idx) in &same_register_pairs {
             let order_var = order_idx(pair_idx);
             constraints.push(LinearConstraint::ge(
-                vec![
-                    (time_idx(v), 1.0),
-                    (latest_idx(u), -1.0),
-                    (order_var, -big_m),
-                ],
+                vec![(time_idx(v), 1), (latest_idx(u), -1), (order_var, -big_m)],
                 -big_m,
             ));
             constraints.push(LinearConstraint::ge(
-                vec![
-                    (time_idx(u), 1.0),
-                    (latest_idx(v), -1.0),
-                    (order_var, big_m),
-                ],
-                0.0,
+                vec![(time_idx(u), 1), (latest_idx(v), -1), (order_var, big_m)],
+                0,
             ));
         }
 
-        ReductionFeasibleRegisterAssignmentToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionFeasibleRegisterAssignmentToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -143,7 +148,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 2,
                 vec![0, 1, 0, 0],
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/flowshopscheduling_ilp.rs b/src/rules/flowshopscheduling_ilp.rs
index 7f15251e2..d5a4d60ee 100644
--- a/src/rules/flowshopscheduling_ilp.rs
+++ b/src/rules/flowshopscheduling_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from FlowShopScheduling to ILP<i32>.
+//! Reduction from FlowShopScheduling to `ILP<i64>`.
 //!
 //! Binary order variables y_{i,j} with y_{i,j}=1 iff job i precedes job j,
 //! integer completion-time variables C_{j,q} for each job j and machine q.
@@ -8,10 +8,9 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::FlowShopScheduling;
 use crate::reduction;
-use crate::rules::ilp_helpers::permutation_to_lehmer;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing FlowShopScheduling to ILP<i32>.
+/// Result of reducing FlowShopScheduling to `ILP<i64>`.
 ///
 /// Variable layout:
 /// - `y_{i,j}` for each ordered pair (i,j) with i<j: index `i*n + j - (i+1)*(i+2)/2`
@@ -21,64 +20,53 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Total: n*(n-1)/2 + n*m variables.
 #[derive(Debug, Clone)]
 pub struct ReductionFSSToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_jobs: usize,
     num_machines: usize,
     num_order_vars: usize,
 }
 
-impl ReductionFSSToILP {
-    fn encode_schedule_as_lehmer(schedule: &[usize]) -> Vec<usize> {
-        let mut available: Vec<usize> = (0..schedule.len()).collect();
-        let mut config = Vec::with_capacity(schedule.len());
-        for &task in schedule {
-            let digit = available
-                .iter()
-                .position(|&c| c == task)
-                .expect("schedule must be a permutation");
-            config.push(digit);
-            available.remove(digit);
-        }
-        config
-    }
-}
-
 impl ReductionResult for ReductionFSSToILP {
     type Source = FlowShopScheduling;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    /// Extract solution: sort jobs by final-machine completion time C_{j,m-1},
-    /// then convert permutation to Lehmer code.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_jobs;
-        let m = self.num_machines;
-        let c_offset = self.num_order_vars;
-        let mut jobs: Vec<usize> = (0..n).collect();
-        jobs.sort_by_key(|&j| {
-            let idx = c_offset + j * m + (m - 1);
-            (target_solution.get(idx).copied().unwrap_or(0), j)
-        });
-        let perm = permutation_to_lehmer(&jobs);
-        Self::encode_schedule_as_lehmer(&jobs)
-            .into_iter()
-            .zip(perm)
-            .map(|(lehmer, _)| lehmer)
-            .collect()
+    /// Extract solution by sorting jobs by final-machine completion time C_{j,m-1}.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_jobs;
+            let m = self.num_machines;
+            let c_offset = self.num_order_vars;
+            let mut jobs: Vec<usize> = (0..n).collect();
+            jobs.sort_by_key(|&j| {
+                let idx = c_offset + j * m + (m - 1);
+                (target_solution[idx], j)
+            });
+            jobs
+        })
     }
 }
 
-#[reduction(overhead = {
+#[reduction(transform = upper_bound {
     num_vars = "num_jobs * (num_jobs - 1) / 2 + num_jobs * num_processors",
-    num_constraints = "num_jobs * (num_jobs - 1) / 2 + num_jobs + num_jobs * (num_processors - 1) + num_jobs * (num_jobs - 1) * num_processors + num_jobs",
-})]
-impl ReduceTo<ILP<i32>> for FlowShopScheduling {
+    num_constraints = "num_jobs * (num_jobs - 1) + num_jobs + num_jobs * (num_processors - 1) + num_jobs * (num_jobs - 1) * num_processors + num_jobs",
+},
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<i64>> for FlowShopScheduling {
     type Result = ReductionFSSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_jobs();
         let m = self.num_processors();
 
@@ -96,6 +84,7 @@ impl ReduceTo<ILP<i32>> for FlowShopScheduling {
 
         let p = self.task_lengths();
         let d = self.deadline();
+        let deadline = d;
 
         // Big-M: D + max processing time
         let max_p = p
@@ -104,8 +93,11 @@ impl ReduceTo<ILP<i32>> for FlowShopScheduling {
             .copied()
             .max()
             .unwrap_or(0);
-        let big_m = (d + max_p) as f64;
-
+        let big_m = d.checked_add(max_p).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<FlowShopScheduling, ILP<i64>>(
+                "computing the flow-shop big-M bound",
+            )
+        })?;
         let mut constraints = Vec::new();
 
         // 1. Symmetry: y_{i,j} + y_{j,i} = 1 for all i != j
@@ -113,17 +105,14 @@ impl ReduceTo<ILP<i32>> for FlowShopScheduling {
         // via 0 <= y_{i,j} <= 1.
         for i in 0..n {
             for j in (i + 1)..n {
-                constraints.push(LinearConstraint::le(vec![(order_var(i, j), 1.0)], 1.0));
-                constraints.push(LinearConstraint::ge(vec![(order_var(i, j), 1.0)], 0.0));
+                constraints.push(LinearConstraint::le(vec![(order_var(i, j), 1)], 1));
+                constraints.push(LinearConstraint::ge(vec![(order_var(i, j), 1)], 0));
             }
         }
 
         // 2. C_{j,0} >= p_{j,0} for all j
         for (j, p_j) in p.iter().enumerate() {
-            constraints.push(LinearConstraint::ge(
-                vec![(c_var(j, 0), 1.0)],
-                p_j[0] as f64,
-            ));
+            constraints.push(LinearConstraint::ge(vec![(c_var(j, 0), 1)], p_j[0]));
         }
 
         // 3. Machine chain: C_{j,q+1} >= C_{j,q} + p_{j,q+1} for all j, q in 0..m-1
@@ -131,8 +120,8 @@ impl ReduceTo<ILP<i32>> for FlowShopScheduling {
             for q in 0..(m.saturating_sub(1)) {
                 // C_{j,q+1} - C_{j,q} >= p_{j,q+1}
                 constraints.push(LinearConstraint::ge(
-                    vec![(c_var(j, q + 1), 1.0), (c_var(j, q), -1.0)],
-                    p_j[q + 1] as f64,
+                    vec![(c_var(j, q + 1), 1), (c_var(j, q), -1)],
+                    p_j[q + 1],
                 ));
             }
         }
@@ -165,11 +154,11 @@ impl ReduceTo<ILP<i32>> for FlowShopScheduling {
                         // C_{j,q} - C_{i,q} - M*y_{i,j} >= p_{j,q} - M
                         constraints.push(LinearConstraint::ge(
                             vec![
-                                (c_var(j, q), 1.0),
-                                (c_var(i, q), -1.0),
+                                (c_var(j, q), 1),
+                                (c_var(i, q), -1),
                                 (order_var(i, j), -big_m),
                             ],
-                            p_jq as f64 - big_m,
+                            p_jq - big_m,
                         ));
                     } else {
                         // i > j: y_{j,i} is stored. y_{i,j} = 1 - y_{j,i}.
@@ -178,11 +167,11 @@ impl ReduceTo<ILP<i32>> for FlowShopScheduling {
                         // C_{j,q} - C_{i,q} + M*y_{j,i} >= p_{j,q}
                         constraints.push(LinearConstraint::ge(
                             vec![
-                                (c_var(j, q), 1.0),
-                                (c_var(i, q), -1.0),
+                                (c_var(j, q), 1),
+                                (c_var(i, q), -1),
                                 (order_var(j, i), big_m),
                             ],
-                            p_jq as f64,
+                            p_jq,
                         ));
                     }
                 }
@@ -192,16 +181,17 @@ impl ReduceTo<ILP<i32>> for FlowShopScheduling {
         // 5. Deadline: C_{j,m-1} <= D for all j
         if m > 0 {
             for j in 0..n {
-                constraints.push(LinearConstraint::le(vec![(c_var(j, m - 1), 1.0)], d as f64));
+                constraints.push(LinearConstraint::le(vec![(c_var(j, m - 1), 1)], deadline));
             }
         }
 
-        ReductionFSSToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionFSSToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_jobs: n,
             num_machines: m,
             num_order_vars,
-        }
+        })
     }
 }
 
@@ -212,7 +202,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             // 2 machines, 3 jobs, deadline 10
             let source = FlowShopScheduling::new(2, vec![vec![2, 3], vec![3, 2], vec![1, 4]], 10);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/graph.rs b/src/rules/graph.rs
index 608da182b..f89ffbb49 100644
--- a/src/rules/graph.rs
+++ b/src/rules/graph.rs
@@ -1,31 +1,30 @@
 //! Runtime reduction graph for discovering and executing reduction paths.
 //!
 //! The graph uses variant-level nodes: each node is a unique `(problem_name, variant)` pair.
-//! Nodes are built in two phases:
-//! 1. From `VariantEntry` inventory (with complexity metadata)
-//! 2. From `ReductionEntry` inventory (fallback for backwards compatibility)
+//! Nodes come from `VariantEntry` inventory, and `ReductionEntry` inventory supplies edges.
 //!
 //! Edges come exclusively from `#[reduction]` registrations via `inventory::iter::<ReductionEntry>`.
 //!
 //! This module implements:
 //! - Variant-level graph construction from `VariantEntry` and `ReductionEntry` inventory
-//! - Dijkstra's algorithm with custom cost functions for optimal paths
+//! - Symbolic path composition and concrete path execution
 //! - JSON export for documentation and visualization
 
-use crate::rules::cost::PathCostFn;
 use crate::rules::registry::{
-    AggregateReduceFn, EdgeCapabilities, ReduceFn, ReductionEntry, ReductionOverhead,
+    AggregateReduceFn, EdgeCapabilities, ParameterContractError, ReduceFn, ReductionEntry,
+    ReductionParameterContract,
 };
 use crate::rules::traits::{DynAggregateReductionResult, DynReductionResult};
-use crate::types::ProblemSize;
-use ordered_float::OrderedFloat;
+use crate::types::ProblemParameters;
 use petgraph::algo::all_simple_paths;
 use petgraph::graph::{DiGraph, EdgeIndex, NodeIndex};
 use petgraph::visit::EdgeRef;
 use serde::Serialize;
 use std::any::Any;
-use std::cmp::Reverse;
-use std::collections::{BTreeMap, BinaryHeap, HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
+use std::rc::Rc;
+
+type NodePathOrderKey<'a> = (usize, Vec<(&'static str, &'a BTreeMap<String, String>)>);
 
 /// A source/target pair from the reduction graph, returned by
 /// [`ReductionGraph::outgoing_reductions`] and [`ReductionGraph::incoming_reductions`].
@@ -35,17 +34,23 @@ pub struct ReductionEdgeInfo {
     pub source_variant: BTreeMap<String, String>,
     pub target_name: &'static str,
     pub target_variant: BTreeMap<String, String>,
-    pub overhead: ReductionOverhead,
+    pub parameter_contract: Result<ReductionParameterContract, ParameterContractError>,
     pub capabilities: EdgeCapabilities,
 }
 
-/// Internal edge data combining overhead and executable reduce function.
+/// Internal edge data combining explicit parameter contracts and executable reduction functions.
 #[derive(Clone)]
 pub(crate) struct ReductionEdgeData {
-    pub overhead: ReductionOverhead,
+    pub parameter_contract: Result<ReductionParameterContract, ParameterContractError>,
     pub reduce_fn: Option<ReduceFn>,
     pub reduce_aggregate_fn: Option<AggregateReduceFn>,
-    pub capabilities: EdgeCapabilities,
+    pub turing: bool,
+}
+
+impl ReductionEdgeData {
+    fn capabilities(&self) -> EdgeCapabilities {
+        EdgeCapabilities::from_executors(self.reduce_fn, self.reduce_aggregate_fn, self.turing)
+    }
 }
 
 /// JSON-serializable representation of the reduction graph.
@@ -78,8 +83,8 @@ pub(crate) struct NodeJson {
     pub(crate) name: String,
     /// Variant attributes as key-value pairs.
     pub(crate) variant: BTreeMap<String, String>,
-    /// Category of the problem (e.g., "graph", "set", "optimization", "satisfiability", "specialized").
-    pub(crate) category: String,
+    /// Structural category declared by the problem schema.
+    pub(crate) category: crate::registry::ProblemCategory,
     /// Relative rustdoc path (e.g., "models/graph/maximum_independent_set").
     pub(crate) doc_path: String,
     /// Worst-case time complexity expression (empty if not declared).
@@ -93,13 +98,13 @@ struct VariantRef {
     variant: BTreeMap<String, String>,
 }
 
-/// A single output field in the reduction overhead.
+/// One explicitly classified target parameter field in graph export.
 #[derive(Debug, Clone, Serialize)]
-pub(crate) struct OverheadFieldJson {
-    /// Output field name (e.g., "num_vars").
+pub(crate) struct ParameterFieldJson {
     pub(crate) field: String,
-    /// Formula as a human-readable string (e.g., "num_vertices").
-    pub(crate) formula: String,
+    pub(crate) contract: &'static str,
+    pub(crate) formula: Option<String>,
+    pub(crate) reason: Option<String>,
 }
 
 /// An edge in the reduction graph JSON.
@@ -109,8 +114,9 @@ pub(crate) struct EdgeJson {
     pub(crate) source: usize,
     /// Index into the `nodes` array for the target problem variant.
     pub(crate) target: usize,
-    /// Reduction overhead: output size as expressions of input size.
-    pub(crate) overhead: Vec<OverheadFieldJson>,
+    /// Symbolic or unavailable target-parameter fields.
+    pub(crate) parameters: Vec<ParameterFieldJson>,
+    pub(crate) parameter_contract_error: Option<String>,
     /// Relative rustdoc path for the reduction module.
     pub(crate) doc_path: String,
     /// Whether the edge supports witness/config workflows.
@@ -128,6 +134,90 @@ pub struct ReductionPath {
     pub steps: Vec<ReductionStep>,
 }
 
+/// A selected concrete path batch could not be executed.
+#[derive(Clone, Debug, Eq, PartialEq, thiserror::Error)]
+pub enum ExecutePathsError {
+    #[error("concrete path {path_index} is empty")]
+    EmptyPath { path_index: usize },
+    #[error("concrete path {path_index} contains no reduction edge")]
+    NoEdges { path_index: usize },
+    #[error("concrete path {path_index} starts at a different source node")]
+    DifferentSource { path_index: usize },
+    #[error("concrete path {path_index} references unknown node {problem} {variant:?}")]
+    UnknownNode {
+        path_index: usize,
+        problem: String,
+        variant: BTreeMap<String, String>,
+    },
+    #[error("concrete path {path_index} has no registered edge from {source_problem} to {target_problem}")]
+    MissingEdge {
+        path_index: usize,
+        source_problem: String,
+        target_problem: String,
+    },
+    #[error("concrete path {path_index} edge {source_problem} -> {target_problem} is not witness-executable")]
+    NotWitnessExecutable {
+        path_index: usize,
+        source_problem: String,
+        target_problem: String,
+    },
+    #[error("concrete path {path_index} failed during reduction: {cause}")]
+    Reduction {
+        path_index: usize,
+        #[source]
+        cause: crate::rules::ReductionError,
+    },
+}
+
+/// Why symbolic parameter propagation could not be completed for a path.
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+pub enum PathParameterError {
+    #[error("cannot compose an empty reduction path")]
+    EmptyPath,
+    #[error("reduction path references unknown node {problem} {variant:?}")]
+    UnknownNode {
+        problem: String,
+        variant: BTreeMap<String, String>,
+    },
+    #[error(
+        "reduction path contains no registered edge from {source_problem} to {target_problem}"
+    )]
+    MissingEdge {
+        source_problem: String,
+        target_problem: String,
+    },
+    #[error("reduction step {step} ({source_problem} -> {target_problem}) is a multi-query reduction without a query-cost model")]
+    TuringEdge {
+        step: usize,
+        source_problem: String,
+        target_problem: String,
+    },
+    #[error("reduction step {step} ({source_problem} -> {target_problem}) has an invalid parameter contract: {error}")]
+    InvalidContract {
+        step: usize,
+        source_problem: String,
+        target_problem: String,
+        #[source]
+        error: Box<ParameterContractError>,
+    },
+    #[error("reduction step {step} ({source_problem} -> {target_problem}) has no symbolic parameter transform")]
+    Unavailable {
+        step: usize,
+        source_problem: String,
+        target_problem: String,
+    },
+    #[error(
+        "cannot compose reduction step {step} ({source_problem} -> {target_problem}): {error}"
+    )]
+    Step {
+        step: usize,
+        source_problem: String,
+        target_problem: String,
+        #[source]
+        error: Box<crate::parameters::ParameterTransformError>,
+    },
+}
+
 impl ReductionPath {
     /// Number of edges (reductions) in the path.
     pub fn len(&self) -> usize {
@@ -183,11 +273,11 @@ impl std::fmt::Display for ReductionPath {
 }
 
 /// A node in a variant-level reduction path.
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Eq, Hash, PartialEq, Serialize)]
 pub struct ReductionStep {
     /// Problem name (e.g., "MaximumIndependentSet").
     pub name: String,
-    /// Variant at this point (e.g., {"graph": "KingsSubgraph", "weight": "i32"}).
+    /// Variant at this point (e.g., {"graph": "KingsSubgraph", "weight": "i64"}).
     pub variant: BTreeMap<String, String>,
 }
 
@@ -206,20 +296,6 @@ impl std::fmt::Display for ReductionStep {
     }
 }
 
-/// Classify a problem's category from its module path.
-/// Expected format: "problemreductions::models::<category>::<module_name>"
-pub(crate) fn classify_problem_category(module_path: &str) -> &str {
-    let parts: Vec<&str> = module_path.split("::").collect();
-    if parts.len() >= 3 {
-        if let Some(pos) = parts.iter().position(|&p| p == "models") {
-            if pos + 1 < parts.len() {
-                return parts[pos + 1];
-            }
-        }
-    }
-    "other"
-}
-
 /// Internal node data for the variant-level graph.
 #[derive(Debug, Clone)]
 struct VariantNode {
@@ -278,7 +354,6 @@ pub struct NeighborTree {
 ///
 /// The graph supports:
 /// - Auto-discovery of reductions from `inventory::iter::<ReductionEntry>`
-/// - Dijkstra with custom cost functions
 /// - Path finding by problem type or by name
 pub struct ReductionGraph {
     /// Graph with node indices as node data, edge weights as ReductionEdgeData.
@@ -294,6 +369,15 @@ pub struct ReductionGraph {
 impl ReductionGraph {
     /// Create a new reduction graph with all registered reductions from inventory.
     pub fn new() -> Self {
+        crate::registry::validate_variant_parameter_schemas().unwrap_or_else(|errors| {
+            panic!("invalid problem parameters schemas:\n{}", errors.join("\n"))
+        });
+        crate::rules::registry::validate_reduction_parameter_schemas().unwrap_or_else(|errors| {
+            panic!(
+                "invalid reduction parameter schemas:\n{}",
+                errors.join("\n")
+            )
+        });
         let mut graph = DiGraph::new();
         let mut nodes: Vec<VariantNode> = Vec::new();
         let mut node_index: HashMap<VariantRef, NodeIndex> = HashMap::new();
@@ -353,37 +437,25 @@ impl ReductionGraph {
             let source_variant = Self::variant_to_map(&entry.source_variant());
             let target_variant = Self::variant_to_map(&entry.target_variant());
 
-            // Nodes should already exist from Phase 1.
-            // Fall back to creating them with empty complexity for backwards compatibility.
-            let src_idx = ensure_node(
-                entry.source_name,
-                source_variant,
-                "",
-                &mut nodes,
-                &mut graph,
-                &mut node_index,
-                &mut name_to_nodes,
-            );
-            let dst_idx = ensure_node(
-                entry.target_name,
-                target_variant,
-                "",
-                &mut nodes,
-                &mut graph,
-                &mut node_index,
-                &mut name_to_nodes,
-            );
+            let src_idx = node_index[&VariantRef {
+                name: entry.source_name.to_string(),
+                variant: source_variant,
+            }];
+            let dst_idx = node_index[&VariantRef {
+                name: entry.target_name.to_string(),
+                variant: target_variant,
+            }];
 
-            let overhead = entry.overhead();
+            let parameter_contract = entry.parameter_contract();
             if graph.find_edge(src_idx, dst_idx).is_none() {
                 graph.add_edge(
                     src_idx,
                     dst_idx,
                     ReductionEdgeData {
-                        overhead,
+                        parameter_contract,
                         reduce_fn: entry.reduce_fn,
                         reduce_aggregate_fn: entry.reduce_aggregate_fn,
-                        capabilities: entry.capabilities,
+                        turing: entry.turing,
                     },
                 );
             }
@@ -424,12 +496,31 @@ impl ReductionGraph {
 
     fn edge_supports_mode(edge: &ReductionEdgeData, mode: ReductionMode) -> bool {
         match mode {
-            ReductionMode::Witness => edge.capabilities.witness,
-            ReductionMode::Aggregate => edge.capabilities.aggregate,
-            ReductionMode::Turing => edge.capabilities.turing,
+            ReductionMode::Witness => edge.reduce_fn.is_some(),
+            ReductionMode::Aggregate => edge.reduce_aggregate_fn.is_some(),
+            ReductionMode::Turing => edge.turing,
         }
     }
 
+    fn ordered_outgoing_edges(
+        &self,
+        node: NodeIndex,
+        mode: ReductionMode,
+    ) -> Vec<(NodeIndex, EdgeIndex)> {
+        let mut edges: Vec<_> = self
+            .graph
+            .edges(node)
+            .filter(|edge| Self::edge_supports_mode(edge.weight(), mode))
+            .map(|edge| (edge.target(), edge.id()))
+            .collect();
+        edges.sort_by(|a, b| {
+            let a = &self.nodes[self.graph[a.0]];
+            let b = &self.nodes[self.graph[b.0]];
+            (a.name, &a.variant).cmp(&(b.name, &b.variant))
+        });
+        edges
+    }
+
     fn node_path_supports_mode(&self, node_path: &[NodeIndex], mode: ReductionMode) -> bool {
         node_path.windows(2).all(|pair| {
             self.graph
@@ -438,125 +529,154 @@ impl ReductionGraph {
         })
     }
 
-    /// Find the cheapest path between two specific problem variants.
-    ///
-    /// Uses Dijkstra's algorithm on the variant-level graph from the exact
-    /// source variant node to the exact target variant node.
-    pub fn find_cheapest_path<C: PathCostFn>(
-        &self,
-        source: &str,
-        source_variant: &BTreeMap<String, String>,
-        target: &str,
-        target_variant: &BTreeMap<String, String>,
-        input_size: &ProblemSize,
-        cost_fn: &C,
-    ) -> Option<ReductionPath> {
-        self.find_cheapest_path_mode(
-            source,
-            source_variant,
-            target,
-            target_variant,
-            ReductionMode::Witness,
-            input_size,
-            cost_fn,
-        )
+    /// Convert a node index path to a `ReductionPath`.
+    fn node_path_to_reduction_path(&self, node_path: &[NodeIndex]) -> ReductionPath {
+        let steps = node_path
+            .iter()
+            .map(|&idx| {
+                let node = &self.nodes[self.graph[idx]];
+                ReductionStep {
+                    name: node.name.to_string(),
+                    variant: node.variant.clone(),
+                }
+            })
+            .collect();
+        ReductionPath { steps }
     }
 
-    /// Find the cheapest path between two specific problem variants while
-    /// requiring a specific edge capability.
-    #[allow(clippy::too_many_arguments)]
-    pub fn find_cheapest_path_mode<C: PathCostFn>(
-        &self,
-        source: &str,
-        source_variant: &BTreeMap<String, String>,
-        target: &str,
-        target_variant: &BTreeMap<String, String>,
-        mode: ReductionMode,
-        input_size: &ProblemSize,
-        cost_fn: &C,
-    ) -> Option<ReductionPath> {
-        let src = self.lookup_node(source, source_variant)?;
-        let dst = self.lookup_node(target, target_variant)?;
-        let node_path = self.dijkstra(src, dst, mode, input_size, cost_fn)?;
-        Some(self.node_path_to_reduction_path(&node_path))
+    fn node_path_order_key(&self, node_path: &[NodeIndex]) -> NodePathOrderKey<'_> {
+        (
+            node_path.len().saturating_sub(1),
+            node_path
+                .iter()
+                .map(|&idx| {
+                    let node = &self.nodes[self.graph[idx]];
+                    (node.name, &node.variant)
+                })
+                .collect(),
+        )
     }
 
-    /// Core Dijkstra search on node indices.
-    fn dijkstra<C: PathCostFn>(
+    #[allow(clippy::too_many_arguments)]
+    fn shortest_node_path(
         &self,
-        src: NodeIndex,
-        dst: NodeIndex,
-        mode: ReductionMode,
-        input_size: &ProblemSize,
-        cost_fn: &C,
+        source: NodeIndex,
+        target: NodeIndex,
+        adjacency: &[Vec<NodeIndex>],
+        excluded_nodes: &HashSet<NodeIndex>,
+        excluded_edges: &HashSet<(NodeIndex, NodeIndex)>,
+        max_nodes: usize,
     ) -> Option<Vec<NodeIndex>> {
-        let mut costs: HashMap<NodeIndex, f64> = HashMap::new();
-        let mut sizes: HashMap<NodeIndex, ProblemSize> = HashMap::new();
-        let mut prev: HashMap<NodeIndex, NodeIndex> = HashMap::new();
-        let mut heap = BinaryHeap::new();
-
-        costs.insert(src, 0.0);
-        sizes.insert(src, input_size.clone());
-        heap.push(Reverse((OrderedFloat(0.0), src)));
-
-        while let Some(Reverse((cost, node))) = heap.pop() {
-            if node == dst {
-                let mut path = vec![dst];
-                let mut current = dst;
-                while current != src {
-                    let &prev_node = prev.get(&current)?;
-                    path.push(prev_node);
-                    current = prev_node;
-                }
-                path.reverse();
-                return Some(path);
-            }
+        if excluded_nodes.contains(&source) || max_nodes == 0 {
+            return None;
+        }
+        if source == target {
+            return Some(vec![source]);
+        }
+
+        let mut queue = VecDeque::from([(source, 1usize)]);
+        let mut parents = HashMap::new();
+        let mut visited = HashSet::from([source]);
 
-            if cost.0 > *costs.get(&node).unwrap_or(&f64::INFINITY) {
+        while let Some((current, path_nodes)) = queue.pop_front() {
+            if path_nodes == max_nodes {
                 continue;
             }
-
-            let current_size = match sizes.get(&node) {
-                Some(s) => s.clone(),
-                None => continue,
-            };
-
-            for edge_ref in self.graph.edges(node) {
-                if !Self::edge_supports_mode(edge_ref.weight(), mode) {
+            for &next in &adjacency[current.index()] {
+                if excluded_nodes.contains(&next)
+                    || excluded_edges.contains(&(current, next))
+                    || !visited.insert(next)
+                {
                     continue;
                 }
-                let overhead = &edge_ref.weight().overhead;
-                let next = edge_ref.target();
-
-                let edge_cost = cost_fn.edge_cost(overhead, &current_size);
-                let new_cost = cost.0 + edge_cost;
-                let new_size = overhead.evaluate_output_size(&current_size);
-
-                if new_cost < *costs.get(&next).unwrap_or(&f64::INFINITY) {
-                    costs.insert(next, new_cost);
-                    sizes.insert(next, new_size);
-                    prev.insert(next, node);
-                    heap.push(Reverse((OrderedFloat(new_cost), next)));
+                parents.insert(next, current);
+                if next == target {
+                    let mut path = vec![target];
+                    let mut node = target;
+                    while node != source {
+                        node = parents[&node];
+                        path.push(node);
+                    }
+                    path.reverse();
+                    return Some(path);
                 }
+                queue.push_back((next, path_nodes + 1));
             }
         }
-
         None
     }
 
-    /// Convert a node index path to a `ReductionPath`.
-    fn node_path_to_reduction_path(&self, node_path: &[NodeIndex]) -> ReductionPath {
-        let steps = node_path
-            .iter()
-            .map(|&idx| {
-                let node = &self.nodes[self.graph[idx]];
-                ReductionStep {
-                    name: node.name.to_string(),
-                    variant: node.variant.clone(),
+    fn find_k_shortest_node_paths(
+        &self,
+        source: NodeIndex,
+        target: NodeIndex,
+        mode: ReductionMode,
+        limit: usize,
+        max_nodes: usize,
+    ) -> Vec<Vec<NodeIndex>> {
+        if source == target || limit == 0 {
+            return Vec::new();
+        }
+
+        let mut adjacency = vec![Vec::new(); self.graph.node_count()];
+        for node in self.graph.node_indices() {
+            adjacency[node.index()] = self
+                .ordered_outgoing_edges(node, mode)
+                .into_iter()
+                .map(|(target, _)| target)
+                .collect();
+        }
+
+        let Some(first) = self.shortest_node_path(
+            source,
+            target,
+            &adjacency,
+            &HashSet::new(),
+            &HashSet::new(),
+            max_nodes,
+        ) else {
+            return Vec::new();
+        };
+
+        let mut accepted = vec![first];
+        let mut candidates = BTreeSet::new();
+
+        while accepted.len() < limit {
+            let previous = accepted.last().expect("accepted path exists");
+            for spur_index in 0..previous.len().saturating_sub(1) {
+                let root = &previous[..=spur_index];
+                let excluded_edges = accepted
+                    .iter()
+                    .filter(|path| path.len() > spur_index + 1 && path[..=spur_index] == *root)
+                    .map(|path| (path[spur_index], path[spur_index + 1]))
+                    .collect::<HashSet<_>>();
+                let excluded_nodes = root[..spur_index].iter().copied().collect();
+                let max_spur_nodes = max_nodes.saturating_sub(spur_index);
+                let Some(spur) = self.shortest_node_path(
+                    previous[spur_index],
+                    target,
+                    &adjacency,
+                    &excluded_nodes,
+                    &excluded_edges,
+                    max_spur_nodes,
+                ) else {
+                    continue;
+                };
+                let mut candidate = root[..spur_index].to_vec();
+                candidate.extend(spur);
+                if !accepted.contains(&candidate) {
+                    let key = self.node_path_order_key(&candidate);
+                    candidates.insert((key, candidate));
                 }
-            })
-            .collect();
-        ReductionPath { steps }
+            }
+
+            let Some((_, next)) = candidates.pop_first() else {
+                break;
+            };
+            accepted.push(next);
+        }
+
+        accepted
     }
 
     /// Find all simple paths between two specific problem variants.
@@ -614,8 +734,9 @@ impl ReductionGraph {
 
     /// Find up to `limit` simple paths between two specific problem variants.
     ///
-    /// Like [`find_all_paths`](Self::find_all_paths) but stops enumeration after
-    /// collecting `limit` paths. This avoids combinatorial explosion on dense graphs.
+    /// Returns witness-capable paths in deterministic order: fewest edges first,
+    /// then canonical problem name and variant order. Enumeration stops after
+    /// collecting `limit` paths.
     pub fn find_paths_up_to(
         &self,
         source: &str,
@@ -635,8 +756,8 @@ impl ReductionGraph {
         )
     }
 
-    /// Like [`find_all_paths_mode`](Self::find_all_paths_mode) but stops
-    /// enumeration after collecting `limit` paths.
+    /// Returns paths whose edges support `mode`, ordered by fewest edges first
+    /// and canonical problem name and variant order, stopping after `limit` paths.
     pub fn find_paths_up_to_mode(
         &self,
         source: &str,
@@ -657,8 +778,8 @@ impl ReductionGraph {
         )
     }
 
-    /// Like [`find_paths_up_to_mode`](Self::find_paths_up_to_mode) but also
-    /// bounds the number of intermediate nodes in each enumerated path.
+    /// Like [`find_paths_up_to_mode`](Self::find_paths_up_to_mode), with at most
+    /// `max_intermediate_nodes` nodes strictly between the source and target.
     #[allow(clippy::too_many_arguments)]
     pub fn find_paths_up_to_mode_bounded(
         &self,
@@ -679,18 +800,16 @@ impl ReductionGraph {
             None => return vec![],
         };
 
-        let paths: Vec<Vec<NodeIndex>> = all_simple_paths::<
-            Vec<NodeIndex>,
-            _,
-            std::hash::RandomState,
-        >(&self.graph, src, dst, 0, max_intermediate_nodes)
-        .take(limit)
-        .collect();
+        if limit == 0 {
+            return Vec::new();
+        }
 
-        paths
+        let max_intermediate =
+            max_intermediate_nodes.unwrap_or_else(|| self.graph.node_count().saturating_sub(2));
+        let max_nodes = max_intermediate.saturating_add(2);
+        self.find_k_shortest_node_paths(src, dst, mode, limit, max_nodes)
             .iter()
-            .filter(|p| self.node_path_supports_mode(p, mode))
-            .map(|p| self.node_path_to_reduction_path(p))
+            .map(|path| self.node_path_to_reduction_path(path))
             .collect()
     }
 
@@ -784,56 +903,107 @@ impl ReductionGraph {
         self.nodes.len()
     }
 
-    /// Get the per-edge overhead expressions along a reduction path.
-    ///
-    /// Returns one `ReductionOverhead` per edge (i.e., `path.steps.len() - 1` items).
-    ///
-    /// Panics if any step in the path does not correspond to an edge in the graph.
-    pub fn path_overheads(&self, path: &ReductionPath) -> Vec<ReductionOverhead> {
+    /// Return the symbolic parameter transform for every edge of a path.
+    pub fn path_parameter_transforms(
+        &self,
+        path: &ReductionPath,
+    ) -> Result<Vec<crate::parameters::ParameterTransform>, PathParameterError> {
         if path.steps.len() <= 1 {
-            return vec![];
+            return Ok(vec![]);
         }
 
         let node_indices: Vec<NodeIndex> = path
             .steps
             .iter()
             .map(|step| {
-                self.lookup_node(&step.name, &step.variant)
-                    .unwrap_or_else(|| panic!("Node not found: {} {:?}", step.name, step.variant))
+                self.lookup_node(&step.name, &step.variant).ok_or_else(|| {
+                    PathParameterError::UnknownNode {
+                        problem: step.name.clone(),
+                        variant: step.variant.clone(),
+                    }
+                })
             })
-            .collect();
+            .collect::<Result<_, _>>()?;
 
         node_indices
             .windows(2)
-            .map(|pair| {
-                let edge_idx = self.graph.find_edge(pair[0], pair[1]).unwrap_or_else(|| {
-                    let src = &self.nodes[self.graph[pair[0]]];
-                    let dst = &self.nodes[self.graph[pair[1]]];
-                    panic!(
-                        "No edge from {} {:?} to {} {:?}",
-                        src.name, src.variant, dst.name, dst.variant
-                    )
-                });
-                self.graph[edge_idx].overhead.clone()
+            .enumerate()
+            .map(|(index, pair)| {
+                let edge_idx = self.graph.find_edge(pair[0], pair[1]).ok_or_else(|| {
+                    PathParameterError::MissingEdge {
+                        source_problem: path.steps[index].name.clone(),
+                        target_problem: path.steps[index + 1].name.clone(),
+                    }
+                })?;
+                if self.graph[edge_idx].turing {
+                    return Err(PathParameterError::TuringEdge {
+                        step: index + 1,
+                        source_problem: path.steps[index].name.clone(),
+                        target_problem: path.steps[index + 1].name.clone(),
+                    });
+                }
+                let contract =
+                    self.graph[edge_idx]
+                        .parameter_contract
+                        .as_ref()
+                        .map_err(|error| PathParameterError::InvalidContract {
+                            step: index + 1,
+                            source_problem: path.steps[index].name.clone(),
+                            target_problem: path.steps[index + 1].name.clone(),
+                            error: Box::new(error.clone()),
+                        })?;
+                contract
+                    .transform()
+                    .cloned()
+                    .ok_or_else(|| PathParameterError::Unavailable {
+                        step: index + 1,
+                        source_problem: path.steps[index].name.clone(),
+                        target_problem: path.steps[index + 1].name.clone(),
+                    })
             })
             .collect()
     }
 
-    /// Compose overheads along a path symbolically.
-    ///
-    /// Returns a single `ReductionOverhead` whose expressions map from the
-    /// source problem's size variables directly to the final target's size variables.
-    pub fn compose_path_overhead(&self, path: &ReductionPath) -> ReductionOverhead {
-        self.path_overheads(path)
-            .into_iter()
-            .reduce(|acc, oh| acc.compose(&oh))
-            .unwrap_or_default()
+    /// Compose symbolic parameter transforms along a path.
+    pub fn compose_path_parameter_transform(
+        &self,
+        path: &ReductionPath,
+    ) -> Result<Option<crate::parameters::ParameterTransform>, PathParameterError> {
+        if path.steps.is_empty() {
+            return Err(PathParameterError::EmptyPath);
+        }
+        if path.steps.len() == 1 {
+            return Ok(None);
+        }
+
+        let mut transforms = self.path_parameter_transforms(path)?.into_iter();
+        let Some(mut composed) = transforms.next() else {
+            return Ok(None);
+        };
+        for (offset, transform) in transforms.enumerate() {
+            let edge_index = offset + 1;
+            composed = composed
+                .compose(
+                    &transform,
+                    format!(
+                        "{} -> {}",
+                        path.steps[0].name,
+                        path.steps[edge_index + 1].name
+                    ),
+                )
+                .map_err(|error| PathParameterError::Step {
+                    step: edge_index + 1,
+                    source_problem: path.steps[edge_index].name.clone(),
+                    target_problem: path.steps[edge_index + 1].name.clone(),
+                    error: Box::new(error),
+                })?;
+        }
+        Ok(Some(composed))
     }
 
     /// Get all variant maps registered for a problem name.
     ///
-    /// Returns variants sorted deterministically: the "default" variant
-    /// (SimpleGraph, i32, etc.) comes first, then remaining variants
+    /// Returns the declared default first, followed by the remaining variants
     /// in lexicographic order.
     pub fn variants_for(&self, name: &str) -> Vec<BTreeMap<String, String>> {
         let mut variants: Vec<BTreeMap<String, String>> = self
@@ -846,16 +1016,13 @@ impl ReductionGraph {
                     .collect()
             })
             .unwrap_or_default();
-        // Sort deterministically: default variant values (SimpleGraph, One, KN)
-        // sort first so callers can rely on variants[0] being the "base" variant.
-        variants.sort_by(|a, b| {
-            fn default_rank(v: &BTreeMap<String, String>) -> usize {
-                v.values()
-                    .filter(|val| !["SimpleGraph", "One", "KN"].contains(&val.as_str()))
-                    .count()
+        variants.sort();
+        if let Some(default) = self.default_variants.get(name) {
+            if let Some(index) = variants.iter().position(|variant| variant == default) {
+                let default = variants.remove(index);
+                variants.insert(0, default);
             }
-            default_rank(a).cmp(&default_rank(b)).then_with(|| a.cmp(b))
-        });
+        }
         variants
     }
 
@@ -901,90 +1068,69 @@ impl ReductionGraph {
                     source_variant: src.variant.clone(),
                     target_name: dst.name,
                     target_variant: dst.variant.clone(),
-                    overhead: self.graph[e.id()].overhead.clone(),
-                    capabilities: self.graph[e.id()].capabilities,
+                    parameter_contract: self.graph[e.id()].parameter_contract.clone(),
+                    capabilities: self.graph[e.id()].capabilities(),
                 }
             })
             .collect()
     }
 
-    /// Get the problem size field names for a problem type.
+    /// Get executable outgoing reductions from one exact problem variant.
     ///
-    /// Derives size fields from the overhead expressions of reduction entries
-    /// where this problem appears as source or target. When the problem is a
-    /// source, its size fields are the input variables referenced in the overhead
-    /// expressions. When it's a target, its size fields are the output field names.
-    pub fn size_field_names(&self, name: &str) -> Vec<&'static str> {
-        let mut fields: std::collections::HashSet<&'static str> =
-            crate::registry::declared_size_fields(name)
-                .into_iter()
-                .collect();
-        for entry in inventory::iter::<ReductionEntry> {
-            if entry.source_name == name {
-                // Source's size fields are the input variables of the overhead.
-                fields.extend(entry.overhead().input_variable_names());
-            }
-            if entry.target_name == name {
-                // Target's size fields are the output field names.
-                let overhead = entry.overhead();
-                fields.extend(overhead.output_size.iter().map(|(name, _)| *name));
-            }
-        }
-        let mut result: Vec<&'static str> = fields.into_iter().collect();
-        result.sort_unstable();
-        result
-    }
-
-    /// Evaluate the cumulative output size along a reduction path.
+    /// # Panics
     ///
-    /// Walks the path from start to end, applying each edge's overhead
-    /// expressions to transform the problem size at each step.
-    /// Returns `None` if any edge in the path cannot be found.
-    pub fn evaluate_path_overhead(
+    /// Panics if `name` and `variant` do not identify an exactly registered problem variant.
+    pub fn outgoing_reductions_from(
         &self,
-        path: &ReductionPath,
-        input_size: &ProblemSize,
-    ) -> Option<ProblemSize> {
-        let mut current_size = input_size.clone();
-        for pair in path.steps.windows(2) {
-            let src = self.lookup_node(&pair[0].name, &pair[0].variant)?;
-            let dst = self.lookup_node(&pair[1].name, &pair[1].variant)?;
-            let edge_idx = self.graph.find_edge(src, dst)?;
-            let edge = &self.graph[edge_idx];
-            current_size = edge.overhead.evaluate_output_size(&current_size);
-        }
-        Some(current_size)
+        name: &str,
+        variant: &BTreeMap<String, String>,
+        mode: ReductionMode,
+    ) -> Vec<ReductionEdgeInfo> {
+        let source = self
+            .lookup_node(name, variant)
+            .unwrap_or_else(|| panic!("registered problem variant not found: {name} {variant:?}"));
+
+        self.ordered_outgoing_edges(source, mode)
+            .into_iter()
+            .map(|(target, edge)| {
+                let src = &self.nodes[self.graph[source]];
+                let dst = &self.nodes[self.graph[target]];
+                ReductionEdgeInfo {
+                    source_name: src.name,
+                    source_variant: src.variant.clone(),
+                    target_name: dst.name,
+                    target_variant: dst.variant.clone(),
+                    parameter_contract: self.graph[edge].parameter_contract.clone(),
+                    capabilities: self.graph[edge].capabilities(),
+                }
+            })
+            .collect()
     }
 
-    /// Compute the source problem's size from a type-erased instance.
-    ///
-    /// Iterates over all registered reduction entries whose source name *and*
-    /// variant match, and merges their `source_size_fn` results to capture all
-    /// size fields. Different entries may reference different getter methods
-    /// (e.g., one uses `num_vertices` while another also uses `num_edges`).
-    /// Each `source_size_fn` downcasts to one concrete type, so entries for
-    /// other variants of the same problem must not be consulted.
-    pub fn compute_source_size(
+    /// Get a problem type's canonical parameter names in declaration order.
+    pub fn parameter_names(&self, name: &str) -> Vec<String> {
+        inventory::iter::<crate::registry::VariantEntry>
+            .into_iter()
+            .find(|entry| entry.name == name)
+            .map(|entry| {
+                entry
+                    .parameter_names()
+                    .iter()
+                    .map(|name| (*name).to_string())
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
+    /// Measure the complete problem-owned parameters at this exact variant.
+    pub fn compute_problem_parameters(
         name: &str,
         variant: &BTreeMap<String, String>,
         instance: &dyn Any,
-    ) -> ProblemSize {
-        let mut merged: Vec<(String, usize)> = Vec::new();
-        let mut seen: HashSet<String> = HashSet::new();
-
-        for entry in inventory::iter::<ReductionEntry> {
-            if entry.source_name != name
-                || Self::variant_to_map(&entry.source_variant()) != *variant
-            {
-                continue;
-            }
-            for (k, v) in (entry.source_size_fn)(instance).components {
-                if seen.insert(k.clone()) {
-                    merged.push((k, v));
-                }
-            }
-        }
-        ProblemSize { components: merged }
+    ) -> ProblemParameters {
+        let entry = crate::registry::find_variant_entry(name, variant)
+            .unwrap_or_else(|| panic!("unregistered exact problem variant `{name}` {variant:?}"));
+        (entry.parameter_measure_fn)(instance)
     }
 
     /// Get all incoming reductions to a problem (across all its variants).
@@ -1004,8 +1150,8 @@ impl ReductionGraph {
                     source_variant: src.variant.clone(),
                     target_name: dst.name,
                     target_variant: dst.variant.clone(),
-                    overhead: self.graph[e.id()].overhead.clone(),
-                    capabilities: self.graph[e.id()].capabilities,
+                    parameter_contract: self.graph[e.id()].parameter_contract.clone(),
+                    capabilities: self.graph[e.id()].capabilities(),
                 }
             })
             .collect()
@@ -1169,11 +1315,12 @@ impl ReductionGraph {
     pub(crate) fn to_json(&self) -> ReductionGraphJson {
         use crate::registry::ProblemSchemaEntry;
 
-        // Build name -> module_path lookup from ProblemSchemaEntry inventory
-        let schema_modules: HashMap<&str, &str> = inventory::iter::<ProblemSchemaEntry>
-            .into_iter()
-            .map(|entry| (entry.name, entry.module_path))
-            .collect();
+        // Build the model-owned metadata lookup from ProblemSchemaEntry inventory.
+        let schema_metadata: HashMap<&str, (&str, crate::registry::ProblemCategory)> =
+            inventory::iter::<ProblemSchemaEntry>
+                .into_iter()
+                .map(|entry| (entry.name, (entry.module_path, entry.category)))
+                .collect();
 
         // Build sorted node list from the internal nodes
         let mut json_nodes: Vec<(usize, NodeJson)> = self
@@ -1181,21 +1328,20 @@ impl ReductionGraph {
             .iter()
             .enumerate()
             .map(|(i, node)| {
-                let (category, doc_path) = if let Some(&mod_path) = schema_modules.get(node.name) {
-                    (
-                        Self::category_from_module_path(mod_path),
-                        Self::doc_path_from_module_path(mod_path, node.name),
-                    )
-                } else {
-                    ("other".to_string(), String::new())
-                };
+                let &(module_path, category) =
+                    schema_metadata.get(node.name).unwrap_or_else(|| {
+                        panic!(
+                            "missing problem schema for registered variant `{}`",
+                            node.name
+                        )
+                    });
                 (
                     i,
                     NodeJson {
                         name: node.name.to_string(),
                         variant: node.variant.clone(),
                         category,
-                        doc_path,
+                        doc_path: Self::doc_path_from_module_path(module_path, node.name),
                         complexity: node.complexity.to_string(),
                     },
                 )
@@ -1216,17 +1362,35 @@ impl ReductionGraph {
         for edge_ref in self.graph.edge_references() {
             let src_node_id = self.graph[edge_ref.source()];
             let dst_node_id = self.graph[edge_ref.target()];
-            let overhead = &edge_ref.weight().overhead;
-            let capabilities = edge_ref.weight().capabilities;
-
-            let overhead_fields = overhead
-                .output_size
-                .iter()
-                .map(|(field, poly)| OverheadFieldJson {
-                    field: field.to_string(),
-                    formula: poly.to_string(),
-                })
-                .collect();
+            let contract = &edge_ref.weight().parameter_contract;
+            let capabilities = edge_ref.weight().capabilities();
+
+            let mut parameters = Vec::new();
+            if let Ok(contract) = contract {
+                if let Some(transform) = contract.transform() {
+                    let relation = match transform.relation() {
+                        crate::parameters::ParameterRelation::Exact => "exact",
+                        crate::parameters::ParameterRelation::UpperBound => "upper_bound",
+                    };
+                    parameters.extend(transform.expressions().map(|(field, expression)| {
+                        ParameterFieldJson {
+                            field: field.to_string(),
+                            contract: relation,
+                            formula: Some(expression.to_string()),
+                            reason: None,
+                        }
+                    }));
+                }
+                parameters.extend(contract.unavailable().iter().map(|unavailable| {
+                    ParameterFieldJson {
+                        field: unavailable.field.to_string(),
+                        contract: "unavailable",
+                        formula: None,
+                        reason: Some(unavailable.reason.to_string()),
+                    }
+                }));
+            }
+            let parameter_contract_error = contract.as_ref().err().map(ToString::to_string);
 
             // Find the doc_path from the matching ReductionEntry
             let src_name = self.nodes[src_node_id].name;
@@ -1239,7 +1403,8 @@ impl ReductionGraph {
             edges.push(EdgeJson {
                 source: old_to_new[&src_node_id],
                 target: old_to_new[&dst_node_id],
-                overhead: overhead_fields,
+                parameters,
+                parameter_contract_error,
                 doc_path,
                 witness: capabilities.witness,
                 aggregate: capabilities.aggregate,
@@ -1292,6 +1457,11 @@ impl ReductionGraph {
         serde_json::to_string_pretty(&json)
     }
 
+    /// Export the reduction graph as a JSON value.
+    pub fn to_json_value(&self) -> Result<serde_json::Value, serde_json::Error> {
+        serde_json::to_value(self.to_json())
+    }
+
     /// Export the reduction graph to a JSON file.
     pub fn to_json_file(&self, path: &std::path::Path) -> std::io::Result<()> {
         let json_string = self
@@ -1310,13 +1480,6 @@ impl ReductionGraph {
         format!("{}/index.html", stripped.replace("::", "/"))
     }
 
-    /// Extract the category from a module path.
-    ///
-    /// E.g., `"problemreductions::models::graph::maximum_independent_set"` -> `"graph"`.
-    fn category_from_module_path(module_path: &str) -> String {
-        classify_problem_category(module_path).to_string()
-    }
-
     /// Build the rustdoc path from a module path and problem name.
     ///
     /// E.g., `"problemreductions::models::graph::maximum_independent_set"`, `"MaximumIndependentSet"`
@@ -1332,49 +1495,37 @@ impl ReductionGraph {
         }
     }
 
-    /// Find the matching `ReductionEntry` for a (source_name, target_name) pair
-    /// given exact source and target variants.
+    /// Find the graph edge for exact source and target variants.
     ///
-    /// Returns `Some(MatchedEntry)` only when both the source and target variants
-    /// match exactly. No fallback is attempted — callers that need fuzzy matching
-    /// should resolve variants before calling this method.
-    pub fn find_best_entry(
+    /// No fallback is attempted — callers that need fuzzy matching should resolve
+    /// variants before calling this method.
+    pub fn find_entry(
         &self,
         source_name: &str,
         source_variant: &BTreeMap<String, String>,
         target_name: &str,
         target_variant: &BTreeMap<String, String>,
     ) -> Option<MatchedEntry> {
-        for entry in inventory::iter::<ReductionEntry> {
-            if entry.source_name != source_name || entry.target_name != target_name {
-                continue;
-            }
-
-            let entry_source = Self::variant_to_map(&entry.source_variant());
-            let entry_target = Self::variant_to_map(&entry.target_variant());
-
-            // Exact match on both source and target variant
-            if source_variant == &entry_source && target_variant == &entry_target {
-                return Some(MatchedEntry {
-                    source_variant: entry_source,
-                    target_variant: entry_target,
-                    overhead: entry.overhead(),
-                });
-            }
-        }
-
-        None
+        let source = self.lookup_node(source_name, source_variant)?;
+        let target = self.lookup_node(target_name, target_variant)?;
+        let edge = self.graph.find_edge(source, target)?;
+
+        Some(MatchedEntry {
+            source_variant: source_variant.clone(),
+            target_variant: target_variant.clone(),
+            parameter_contract: self.graph[edge].parameter_contract.clone(),
+        })
     }
 }
 
-/// A matched reduction entry returned by [`ReductionGraph::find_best_entry`].
+/// A matched reduction entry returned by [`ReductionGraph::find_entry`].
 pub struct MatchedEntry {
     /// The entry's source variant.
     pub source_variant: BTreeMap<String, String>,
     /// The entry's target variant.
     pub target_variant: BTreeMap<String, String>,
-    /// The overhead of the reduction.
-    pub overhead: ReductionOverhead,
+    /// The reduction's explicit parameter contract.
+    pub parameter_contract: Result<ReductionParameterContract, ParameterContractError>,
 }
 
 /// A composed reduction chain produced by [`ReductionGraph::reduce_along_path`].
@@ -1405,13 +1556,33 @@ impl ReductionChain {
     }
 
     /// Extract a solution from target space back to source space.
-    pub fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.steps
-            .iter()
-            .rev()
-            .fold(target_solution.to_vec(), |sol, step| {
-                step.extract_solution_dyn(&sol)
-            })
+    pub fn extract_solution<S: 'static, T: 'static>(
+        &self,
+        target_solution: &T,
+    ) -> crate::rules::ExtractionResult<S> {
+        let mut steps = self.steps.iter().rev();
+        let first = steps.next().expect("ReductionChain has no steps");
+        let mut solution = first.extract_solution_dyn(target_solution)?;
+        for step in steps {
+            solution = step.extract_solution_dyn(solution.as_ref())?;
+        }
+        solution
+            .downcast::<S>()
+            .map(|solution| *solution)
+            .map_err(|_| crate::rules::ExtractionError::invalid("source solution type mismatch"))
+    }
+
+    /// Extract a JSON target witness into a JSON source witness.
+    pub fn extract_solution_json(
+        &self,
+        target_solution: serde_json::Value,
+    ) -> crate::rules::ExtractionResult<serde_json::Value> {
+        let last = self.steps.last().expect("ReductionChain has no steps");
+        let mut solution = last.target_solution_from_json(target_solution)?;
+        for step in self.steps.iter().rev() {
+            solution = step.extract_solution_dyn(solution.as_ref())?;
+        }
+        self.steps[0].source_solution_json(solution.as_ref())
     }
 }
 
@@ -1448,43 +1619,21 @@ impl AggregateReductionChain {
     }
 }
 
-struct WitnessBackedIdentityAggregateStep {
-    inner: Box<dyn DynReductionResult>,
-}
-
-impl DynAggregateReductionResult for WitnessBackedIdentityAggregateStep {
-    fn target_problem_any(&self) -> &dyn Any {
-        self.inner.target_problem_any()
-    }
-
-    fn extract_value_dyn(&self, target_value: serde_json::Value) -> serde_json::Value {
-        target_value
-    }
-}
-
 impl ReductionGraph {
     fn execute_aggregate_edge(
         &self,
         edge_idx: EdgeIndex,
         input: &dyn Any,
-    ) -> Option<Box<dyn DynAggregateReductionResult>> {
+    ) -> Result<Option<Box<dyn DynAggregateReductionResult>>, crate::rules::ReductionError> {
         let edge = &self.graph[edge_idx];
         if !Self::edge_supports_mode(edge, ReductionMode::Aggregate) {
-            return None;
-        }
-
-        if let Some(edge_fn) = edge.reduce_aggregate_fn {
-            return Some(edge_fn(input));
-        }
-
-        if edge.capabilities.witness && edge.capabilities.aggregate {
-            let edge_fn = edge.reduce_fn?;
-            return Some(Box::new(WitnessBackedIdentityAggregateStep {
-                inner: edge_fn(input),
-            }));
+            return Ok(None);
         }
 
-        None
+        let Some(reduce) = edge.reduce_aggregate_fn else {
+            return Ok(None);
+        };
+        reduce(input).map(Some)
     }
 
     /// Execute a reduction path on a source problem instance.
@@ -1496,7 +1645,9 @@ impl ReductionGraph {
     /// # Example
     ///
     /// ```text
-    /// let chain = graph.reduce_along_path(&path, &source_problem)?;
+    /// let Some(chain) = graph.reduce_along_path(&path, &source_problem)? else {
+    ///     return Err("path is not witness-executable".into());
+    /// };
     /// let target: &QUBO<f64> = chain.target_problem();
     /// let source_solution = chain.extract_solution(&target_solution);
     /// ```
@@ -1504,33 +1655,42 @@ impl ReductionGraph {
         &self,
         path: &ReductionPath,
         source: &dyn Any,
-    ) -> Option<ReductionChain> {
+    ) -> Result<Option<ReductionChain>, crate::rules::ReductionError> {
         if path.steps.len() < 2 {
-            return None;
+            return Ok(None);
         }
         // Collect edge reduce_fns
         let mut edge_fns = Vec::new();
         for window in path.steps.windows(2) {
-            let src = self.lookup_node(&window[0].name, &window[0].variant)?;
-            let dst = self.lookup_node(&window[1].name, &window[1].variant)?;
-            let edge_idx = self.graph.find_edge(src, dst)?;
+            let Some(src) = self.lookup_node(&window[0].name, &window[0].variant) else {
+                return Ok(None);
+            };
+            let Some(dst) = self.lookup_node(&window[1].name, &window[1].variant) else {
+                return Ok(None);
+            };
+            let Some(edge_idx) = self.graph.find_edge(src, dst) else {
+                return Ok(None);
+            };
             if !Self::edge_supports_mode(&self.graph[edge_idx], ReductionMode::Witness) {
-                return None;
+                return Ok(None);
             }
-            edge_fns.push(self.graph[edge_idx].reduce_fn?);
+            let Some(reduce) = self.graph[edge_idx].reduce_fn else {
+                return Ok(None);
+            };
+            edge_fns.push(reduce);
         }
         // Execute the chain
         let mut steps: Vec<Box<dyn DynReductionResult>> = Vec::new();
-        let step = (edge_fns[0])(source);
+        let step = (edge_fns[0])(source)?;
         steps.push(step);
         for edge_fn in &edge_fns[1..] {
             let step = {
                 let prev_target = steps.last().unwrap().target_problem_any();
-                edge_fn(prev_target)
+                edge_fn(prev_target)?
             };
             steps.push(step);
         }
-        Some(ReductionChain { steps })
+        Ok(Some(ReductionChain { steps }))
     }
 
     /// Execute an aggregate-value reduction path on a source problem instance.
@@ -1538,30 +1698,233 @@ impl ReductionGraph {
         &self,
         path: &ReductionPath,
         source: &dyn Any,
-    ) -> Option<AggregateReductionChain> {
+    ) -> Result<Option<AggregateReductionChain>, crate::rules::ReductionError> {
         if path.steps.len() < 2 {
-            return None;
+            return Ok(None);
         }
 
         let mut edge_indices = Vec::new();
         for window in path.steps.windows(2) {
-            let src = self.lookup_node(&window[0].name, &window[0].variant)?;
-            let dst = self.lookup_node(&window[1].name, &window[1].variant)?;
-            let edge_idx = self.graph.find_edge(src, dst)?;
+            let Some(src) = self.lookup_node(&window[0].name, &window[0].variant) else {
+                return Ok(None);
+            };
+            let Some(dst) = self.lookup_node(&window[1].name, &window[1].variant) else {
+                return Ok(None);
+            };
+            let Some(edge_idx) = self.graph.find_edge(src, dst) else {
+                return Ok(None);
+            };
             edge_indices.push(edge_idx);
         }
 
         let mut steps: Vec<Box<dyn DynAggregateReductionResult>> = Vec::new();
-        let step = self.execute_aggregate_edge(edge_indices[0], source)?;
+        let Some(step) = self.execute_aggregate_edge(edge_indices[0], source)? else {
+            return Ok(None);
+        };
         steps.push(step);
         for &edge_idx in &edge_indices[1..] {
             let step = {
                 let prev_target = steps.last().unwrap().target_problem_any();
-                self.execute_aggregate_edge(edge_idx, prev_target)?
+                let Some(step) = self.execute_aggregate_edge(edge_idx, prev_target)? else {
+                    return Ok(None);
+                };
+                step
             };
             steps.push(step);
         }
-        Some(AggregateReductionChain { steps })
+        Ok(Some(AggregateReductionChain { steps }))
+    }
+}
+
+/// A concrete reduction path whose reductions have already been executed.
+///
+/// The constructed chain is retained so callers can inspect target parameterss and
+/// extract solutions without re-executing any reduction.
+pub struct ExecutedPath {
+    /// The variant-level path.
+    pub path: ReductionPath,
+    /// The executed reduction steps (one per hop), shared via `Rc`.
+    steps: Vec<Rc<dyn DynReductionResult>>,
+}
+
+impl ExecutedPath {
+    /// Get the final target problem as a type-erased reference.
+    pub fn target_problem_any(&self) -> &dyn Any {
+        self.steps
+            .last()
+            .expect("ExecutedPath has no steps")
+            .target_problem_any()
+    }
+
+    /// Return the parameters of every concrete intermediate target in this path.
+    pub fn target_parameters(&self) -> Vec<ProblemParameters> {
+        self.steps
+            .iter()
+            .zip(self.path.steps.iter().skip(1))
+            .map(|(result, target)| {
+                ReductionGraph::compute_problem_parameters(
+                    &target.name,
+                    &target.variant,
+                    result.target_problem_any(),
+                )
+            })
+            .collect()
+    }
+
+    /// Extract a solution from target space back to source space.
+    pub fn extract_solution<S: 'static, T: 'static>(
+        &self,
+        target_solution: &T,
+    ) -> crate::rules::ExtractionResult<S> {
+        let mut steps = self.steps.iter().rev();
+        let first = steps.next().expect("ExecutedPath has no steps");
+        let mut solution = first.extract_solution_dyn(target_solution)?;
+        for step in steps {
+            solution = step.extract_solution_dyn(solution.as_ref())?;
+        }
+        solution
+            .downcast::<S>()
+            .map(|solution| *solution)
+            .map_err(|_| crate::rules::ExtractionError::invalid("source solution type mismatch"))
+    }
+}
+
+impl ReductionGraph {
+    /// Execute a selected batch of witness paths while sharing every common prefix.
+    pub fn execute_paths(
+        &self,
+        paths: &[ReductionPath],
+        source_instance: &dyn Any,
+    ) -> Result<Vec<ExecutedPath>, ExecutePathsError> {
+        let mut prefixes: HashMap<Vec<ReductionStep>, Vec<Rc<dyn DynReductionResult>>> =
+            HashMap::new();
+        let mut executed = Vec::with_capacity(paths.len());
+        let mut batch_source: Option<&ReductionStep> = None;
+        for (path_index, path) in paths.iter().enumerate() {
+            let source = path
+                .steps
+                .first()
+                .ok_or(ExecutePathsError::EmptyPath { path_index })?;
+            if path.steps.len() < 2 {
+                return Err(ExecutePathsError::NoEdges { path_index });
+            }
+            if let Some(expected) = batch_source {
+                if source != expected {
+                    return Err(ExecutePathsError::DifferentSource { path_index });
+                }
+            } else {
+                batch_source = Some(source);
+            }
+            let source_prefix = vec![source.clone()];
+            let mut chain = prefixes.get(&source_prefix).cloned().unwrap_or_default();
+            prefixes.entry(source_prefix.clone()).or_default();
+            let mut prefix = source_prefix;
+            for pair in path.steps.windows(2) {
+                prefix.push(pair[1].clone());
+                if let Some(cached) = prefixes.get(&prefix) {
+                    chain = cached.clone();
+                    continue;
+                }
+                let source_node = self
+                    .lookup_node(&pair[0].name, &pair[0].variant)
+                    .ok_or_else(|| ExecutePathsError::UnknownNode {
+                        path_index,
+                        problem: pair[0].name.clone(),
+                        variant: pair[0].variant.clone(),
+                    })?;
+                let target_node_index = self
+                    .lookup_node(&pair[1].name, &pair[1].variant)
+                    .ok_or_else(|| ExecutePathsError::UnknownNode {
+                        path_index,
+                        problem: pair[1].name.clone(),
+                        variant: pair[1].variant.clone(),
+                    })?;
+                let edge_index = self
+                    .graph
+                    .find_edge(source_node, target_node_index)
+                    .ok_or_else(|| ExecutePathsError::MissingEdge {
+                        path_index,
+                        source_problem: pair[0].name.clone(),
+                        target_problem: pair[1].name.clone(),
+                    })?;
+                let edge_data = &self.graph[edge_index];
+                let Some(reduce_fn) = edge_data.reduce_fn else {
+                    return Err(ExecutePathsError::NotWitnessExecutable {
+                        path_index,
+                        source_problem: pair[0].name.clone(),
+                        target_problem: pair[1].name.clone(),
+                    });
+                };
+                let current = chain
+                    .last()
+                    .map(|step| step.target_problem_any())
+                    .unwrap_or(source_instance);
+                let result = reduce_fn(current)
+                    .map_err(|cause| ExecutePathsError::Reduction { path_index, cause })?;
+                chain.push(Rc::from(result));
+                prefixes.insert(prefix.clone(), chain.clone());
+            }
+            executed.push(ExecutedPath {
+                path: path.clone(),
+                steps: chain,
+            });
+        }
+        Ok(executed)
+    }
+}
+
+#[cfg(test)]
+impl ReductionGraph {
+    /// Build a bare reduction graph from an explicit node/edge list (test-only).
+    ///
+    /// Nodes carry the empty variant and empty complexity; each edge carries a
+    /// [`ReductionEdgeData`] without depending on registered inventory.
+    pub(crate) fn from_test_edges(
+        node_names: &[&'static str],
+        edges: &[(&'static str, &'static str, ReductionEdgeData)],
+    ) -> Self {
+        Self::from_test_variant_edges(
+            &node_names
+                .iter()
+                .map(|&name| (name, BTreeMap::new()))
+                .collect::<Vec<_>>(),
+            edges,
+        )
+    }
+
+    pub(crate) fn from_test_variant_edges(
+        test_nodes: &[(&'static str, BTreeMap<String, String>)],
+        edges: &[(&'static str, &'static str, ReductionEdgeData)],
+    ) -> Self {
+        let mut graph: DiGraph<usize, ReductionEdgeData> = DiGraph::new();
+        let mut nodes: Vec<VariantNode> = Vec::new();
+        let mut name_to_nodes: HashMap<&'static str, Vec<NodeIndex>> = HashMap::new();
+        let mut index_of: HashMap<&'static str, NodeIndex> = HashMap::new();
+
+        for (name, variant) in test_nodes {
+            let node_id = nodes.len();
+            nodes.push(VariantNode {
+                name,
+                variant: variant.clone(),
+                complexity: "",
+            });
+            let idx = graph.add_node(node_id);
+            index_of.insert(name, idx);
+            name_to_nodes.entry(name).or_default().push(idx);
+        }
+
+        for (src, dst, data) in edges {
+            let s = index_of[src];
+            let d = index_of[dst];
+            graph.add_edge(s, d, data.clone());
+        }
+
+        Self {
+            graph,
+            nodes,
+            name_to_nodes,
+            default_variants: HashMap::new(),
+        }
     }
 }
 
@@ -1573,11 +1936,11 @@ mod tests;
 #[path = "../unit_tests/rules/reduction_path_parity.rs"]
 mod reduction_path_parity_tests;
 
-#[cfg(all(test, feature = "ilp-solver"))]
+#[cfg(test)]
 #[path = "../unit_tests/rules/maximumindependentset_ilp.rs"]
 mod maximumindependentset_ilp_path_tests;
 
-#[cfg(all(test, feature = "ilp-solver"))]
+#[cfg(test)]
 #[path = "../unit_tests/rules/minimumvertexcover_ilp.rs"]
 mod minimumvertexcover_ilp_path_tests;
 
diff --git a/src/rules/graph_helpers.rs b/src/rules/graph_helpers.rs
index bdc02ae88..288c734c1 100644
--- a/src/rules/graph_helpers.rs
+++ b/src/rules/graph_helpers.rs
@@ -6,22 +6,29 @@ use crate::topology::{Graph, SimpleGraph};
 ///
 /// Given a graph and a binary `target_solution` over its edges (1 = selected),
 /// walks the selected edges to produce a vertex permutation representing the cycle.
-/// Returns `vec![0; n]` if the selection does not form a valid Hamiltonian cycle.
-pub(crate) fn edges_to_cycle_order<G: Graph>(graph: &G, target_solution: &[usize]) -> Vec<usize> {
+/// Returns an error if the selection does not form a valid Hamiltonian cycle.
+pub(crate) fn edges_to_cycle_order<G: Graph>(
+    graph: &G,
+    target_solution: &[bool],
+) -> crate::rules::ExtractionResult<Vec<usize>> {
     let n = graph.num_vertices();
     if n == 0 {
-        return vec![];
+        return Ok(vec![]);
     }
 
     let edges = graph.edges();
     if target_solution.len() != edges.len() {
-        return vec![0; n];
+        return Err(crate::rules::ExtractionError::invalid(format!(
+            "expected {} edge-selection values, got {}",
+            edges.len(),
+            target_solution.len()
+        )));
     }
 
     let mut adjacency = vec![Vec::new(); n];
     let mut selected_count = 0usize;
     for (idx, &selected) in target_solution.iter().enumerate() {
-        if selected != 1 {
+        if !selected {
             continue;
         }
         let (u, v) = edges[idx];
@@ -31,14 +38,23 @@ pub(crate) fn edges_to_cycle_order<G: Graph>(graph: &G, target_solution: &[usize
     }
 
     if selected_count != n || adjacency.iter().any(|neighbors| neighbors.len() != 2) {
-        return vec![0; n];
+        return Err(crate::rules::ExtractionError::invalid(
+            "selected edges do not form a Hamiltonian cycle",
+        ));
     }
 
     let mut order = Vec::with_capacity(n);
+    let mut visited = vec![false; n];
     let mut prev = None;
     let mut current = 0usize;
 
     for _ in 0..n {
+        if visited[current] {
+            return Err(crate::rules::ExtractionError::invalid(
+                "selected edges contain multiple disjoint cycles",
+            ));
+        }
+        visited[current] = true;
         order.push(current);
         let neighbors = &adjacency[current];
         let next = match prev {
@@ -55,7 +71,13 @@ pub(crate) fn edges_to_cycle_order<G: Graph>(graph: &G, target_solution: &[usize
         current = next;
     }
 
-    order
+    if current != 0 || visited.iter().any(|seen| !seen) {
+        return Err(crate::rules::ExtractionError::invalid(
+            "selected edges do not form one Hamiltonian cycle",
+        ));
+    }
+
+    Ok(order)
 }
 
 /// Build the complement graph edges: edges between all non-adjacent vertex pairs.
@@ -71,3 +93,15 @@ pub(crate) fn complement_edges(graph: &SimpleGraph) -> Vec<(usize, usize)> {
     }
     edges
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rejects_disjoint_selected_cycles() {
+        let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (0, 2), (3, 4), (4, 5), (3, 5)]);
+
+        assert!(edges_to_cycle_order(&graph, &[true; 6]).is_err());
+    }
+}
diff --git a/src/rules/graphpartitioning_ilp.rs b/src/rules/graphpartitioning_ilp.rs
index 94b280286..3186696a2 100644
--- a/src/rules/graphpartitioning_ilp.rs
+++ b/src/rules/graphpartitioning_ilp.rs
@@ -30,21 +30,32 @@ impl ReductionResult for ReductionGraphPartitioningToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_vertices]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices + num_edges",
         num_constraints = "2 * num_edges + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for GraphPartitioning<SimpleGraph> {
     type Result = ReductionGraphPartitioningToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let edges = self.graph().edges();
         let m = edges.len();
@@ -52,28 +63,26 @@ impl ReduceTo<ILP<bool>> for GraphPartitioning<SimpleGraph> {
 
         let mut constraints = Vec::with_capacity(2 * m + 1);
 
-        let balance_terms: Vec<(usize, f64)> = (0..n).map(|v| (v, 1.0)).collect();
-        constraints.push(LinearConstraint::eq(balance_terms, n as f64 / 2.0));
+        let balance_terms: Vec<(usize, i64)> = (0..n).map(|v| (v, 2)).collect();
+        constraints.push(LinearConstraint::eq(
+            balance_terms,
+            <Self as ReduceTo<ILP<bool>>>::exact_i64(n, "encoding the partition cardinality")?,
+        ));
 
         for (edge_idx, (u, v)) in edges.iter().enumerate() {
             let y_var = n + edge_idx;
-            constraints.push(LinearConstraint::ge(
-                vec![(y_var, 1.0), (*u, -1.0), (*v, 1.0)],
-                0.0,
-            ));
-            constraints.push(LinearConstraint::ge(
-                vec![(y_var, 1.0), (*u, 1.0), (*v, -1.0)],
-                0.0,
-            ));
+            constraints.push(LinearConstraint::ge(vec![(y_var, 1), (*u, -1), (*v, 1)], 0));
+            constraints.push(LinearConstraint::ge(vec![(y_var, 1), (*u, 1), (*v, -1)], 0));
         }
 
-        let objective: Vec<(usize, f64)> = (0..m).map(|edge_idx| (n + edge_idx, 1.0)).collect();
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let objective: Vec<(usize, i64)> = (0..m).map(|edge_idx| (n + edge_idx, 1)).collect();
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionGraphPartitioningToILP {
+        Ok(ReductionGraphPartitioningToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -101,8 +110,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 1, 1, 1],
-                    target_config: vec![0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0],
+                    source_config: serde_json::json!(vec![false, false, false, true, true, true]),
+                    target_config: serde_json::json!(vec![
+                        0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0
+                    ]),
                 },
             )
         },
diff --git a/src/rules/graphpartitioning_maxcut.rs b/src/rules/graphpartitioning_maxcut.rs
index 0bf31b369..658bfe136 100644
--- a/src/rules/graphpartitioning_maxcut.rs
+++ b/src/rules/graphpartitioning_maxcut.rs
@@ -8,22 +8,27 @@ use crate::topology::{Graph, SimpleGraph};
 /// Result of reducing GraphPartitioning to MaxCut.
 #[derive(Debug, Clone)]
 pub struct ReductionGPToMaxCut {
-    target: MaxCut<SimpleGraph, i32>,
+    target: MaxCut<SimpleGraph, i64>,
 }
 
 #[cfg(any(test, feature = "example-db"))]
-const ISSUE_EXAMPLE_WITNESS: [usize; 6] = [0, 0, 0, 1, 1, 1];
+const ISSUE_EXAMPLE_WITNESS: [bool; 6] = [false, false, false, true, true, true];
 
 impl ReductionResult for ReductionGPToMaxCut {
     type Source = GraphPartitioning<SimpleGraph>;
-    type Target = MaxCut<SimpleGraph, i32>;
+    type Target = MaxCut<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
@@ -45,7 +50,7 @@ fn issue_example() -> GraphPartitioning<SimpleGraph> {
     ))
 }
 
-fn complete_graph_edges_and_weights(graph: &SimpleGraph) -> (Vec<(usize, usize)>, Vec<i32>) {
+fn complete_graph_edges_and_weights(graph: &SimpleGraph) -> (Vec<(usize, usize)>, Vec<i64>) {
     let num_vertices = graph.num_vertices();
     let p = penalty_weight(graph.num_edges());
     let mut edges = Vec::new();
@@ -61,27 +66,27 @@ fn complete_graph_edges_and_weights(graph: &SimpleGraph) -> (Vec<(usize, usize)>
     (edges, weights)
 }
 
-fn penalty_weight(num_edges: usize) -> i32 {
-    i32::try_from(num_edges)
+fn penalty_weight(num_edges: usize) -> i64 {
+    i64::try_from(num_edges)
         .ok()
         .and_then(|num_edges| num_edges.checked_add(1))
-        .expect("GraphPartitioning -> MaxCut penalty exceeds i32 range")
+        .expect("GraphPartitioning -> MaxCut penalty exceeds i64 range")
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_vertices * (num_vertices - 1) / 2",
     }
 )]
-impl ReduceTo<MaxCut<SimpleGraph, i32>> for GraphPartitioning<SimpleGraph> {
+impl ReduceTo<MaxCut<SimpleGraph, i64>> for GraphPartitioning<SimpleGraph> {
     type Result = ReductionGPToMaxCut;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let (edges, weights) = complete_graph_edges_and_weights(self.graph());
         let target = MaxCut::new(SimpleGraph::new(self.num_vertices(), edges), weights);
 
-        ReductionGPToMaxCut { target }
+        Ok(ReductionGPToMaxCut { target })
     }
 }
 
@@ -92,11 +97,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "graphpartitioning_to_maxcut",
         build: || {
-            crate::example_db::specs::rule_example_with_witness::<_, MaxCut<SimpleGraph, i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, MaxCut<SimpleGraph, i64>>(
                 issue_example(),
                 SolutionPair {
-                    source_config: ISSUE_EXAMPLE_WITNESS.to_vec(),
-                    target_config: ISSUE_EXAMPLE_WITNESS.to_vec(),
+                    source_config: serde_json::json!(ISSUE_EXAMPLE_WITNESS.to_vec()),
+                    target_config: serde_json::json!(ISSUE_EXAMPLE_WITNESS.to_vec()),
                 },
             )
         },
diff --git a/src/rules/graphpartitioning_qubo.rs b/src/rules/graphpartitioning_qubo.rs
index 8e32846c9..9840bc491 100644
--- a/src/rules/graphpartitioning_qubo.rs
+++ b/src/rules/graphpartitioning_qubo.rs
@@ -13,30 +13,46 @@ use crate::topology::{Graph, SimpleGraph};
 /// Result of reducing GraphPartitioning to QUBO.
 #[derive(Debug, Clone)]
 pub struct ReductionGraphPartitioningToQUBO {
-    target: QUBO<f64>,
+    target: QUBO<i64>,
 }
 
 impl ReductionResult for ReductionGraphPartitioningToQUBO {
     type Source = GraphPartitioning<SimpleGraph>;
-    type Target = QUBO<f64>;
+    type Target = QUBO<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
-#[reduction(overhead = { num_vars = "num_vertices" })]
-impl ReduceTo<QUBO<f64>> for GraphPartitioning<SimpleGraph> {
+#[reduction(transform = exact {
+    num_vars = "num_vertices",
+})]
+impl ReduceTo<QUBO<i64>> for GraphPartitioning<SimpleGraph> {
     type Result = ReductionGraphPartitioningToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
-        let penalty = self.num_edges() as f64 + 1.0;
-        let mut matrix = vec![vec![0.0f64; n]; n];
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<Self, QUBO<i64>>(operation)
+        };
+        let n_i64 = i64::try_from(n)
+            .map_err(|_| overflow("converting the vertex count to a QUBO coefficient"))?;
+        let edge_count = i64::try_from(self.num_edges())
+            .map_err(|_| overflow("converting the edge count to a QUBO coefficient"))?;
+        let penalty = edge_count
+            .checked_add(1)
+            .ok_or_else(|| overflow("computing the balance penalty"))?;
+        let mut matrix = vec![vec![0i64; n]; n];
         let mut degrees = vec![0usize; n];
         let edges = self.graph().edges();
 
@@ -46,20 +62,39 @@ impl ReduceTo<QUBO<f64>> for GraphPartitioning<SimpleGraph> {
         }
 
         for (i, row) in matrix.iter_mut().enumerate() {
-            row[i] = degrees[i] as f64 + penalty * (1.0 - n as f64);
+            let degree = i64::try_from(degrees[i])
+                .map_err(|_| overflow("converting a vertex degree to a QUBO coefficient"))?;
+            let balance_linear = penalty
+                .checked_mul(
+                    1i64.checked_sub(n_i64)
+                        .ok_or_else(|| overflow("computing a balance coefficient"))?,
+                )
+                .ok_or_else(|| overflow("computing a balance coefficient"))?;
+            row[i] = degree
+                .checked_add(balance_linear)
+                .ok_or_else(|| overflow("combining QUBO diagonal coefficients"))?;
             for value in row.iter_mut().skip(i + 1) {
-                *value = 2.0 * penalty;
+                *value = penalty
+                    .checked_mul(2)
+                    .ok_or_else(|| overflow("computing a balance interaction coefficient"))?;
             }
         }
 
         for (u, v) in edges {
             let (lo, hi) = if u < v { (u, v) } else { (v, u) };
-            matrix[lo][hi] -= 2.0;
+            matrix[lo][hi] = matrix[lo][hi]
+                .checked_sub(2)
+                .ok_or_else(|| overflow("adding a cut interaction coefficient"))?;
         }
 
-        ReductionGraphPartitioningToQUBO {
-            target: QUBO::from_matrix(matrix),
-        }
+        Ok(ReductionGraphPartitioningToQUBO {
+            target: QUBO::from_matrix(matrix).map_err(|message| {
+                crate::rules::ReductionError::construction::<
+                    GraphPartitioning<SimpleGraph>,
+                    QUBO<i64>,
+                >(message)
+            })?,
+        })
     }
 }
 
@@ -70,7 +105,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "graphpartitioning_to_qubo",
         build: || {
-            crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
+            crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
                 GraphPartitioning::new(SimpleGraph::new(
                     6,
                     vec![
@@ -86,8 +121,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     ],
                 )),
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 1, 1, 1],
-                    target_config: vec![0, 0, 0, 1, 1, 1],
+                    source_config: serde_json::json!(vec![false, false, false, true, true, true]),
+                    target_config: serde_json::json!(vec![false, false, false, true, true, true]),
                 },
             )
         },
diff --git a/src/rules/hamiltoniancircuit_biconnectivityaugmentation.rs b/src/rules/hamiltoniancircuit_biconnectivityaugmentation.rs
index cc3e75aae..07576fe0e 100644
--- a/src/rules/hamiltoniancircuit_biconnectivityaugmentation.rs
+++ b/src/rules/hamiltoniancircuit_biconnectivityaugmentation.rs
@@ -2,7 +2,10 @@
 //!
 //! Based on the Eswaran & Tarjan (1976) approach:
 //!
-//! Given a Hamiltonian Circuit instance G = (V, E) with n vertices, construct a
+//! For n < 3, the source has no circuit: output three isolated vertices with
+//! no candidate edges and budget zero, a fixed infeasible target.
+//!
+//! Given a Hamiltonian Circuit instance G = (V, E) with n >= 3 vertices, construct a
 //! BiconnectivityAugmentation instance as follows:
 //!
 //! 1. Start with an edgeless graph on n vertices.
@@ -29,7 +32,7 @@ use crate::topology::{Graph, SimpleGraph};
 /// vertex pairs for solution extraction.
 #[derive(Debug, Clone)]
 pub struct ReductionHamiltonianCircuitToBiconnectivityAugmentation {
-    target: BiconnectivityAugmentation<SimpleGraph, i32>,
+    target: BiconnectivityAugmentation<SimpleGraph, i64>,
     /// Number of vertices in the original graph.
     num_vertices: usize,
     /// Potential edges as (u, v) pairs, in the same order as the target's potential_weights.
@@ -38,73 +41,101 @@ pub struct ReductionHamiltonianCircuitToBiconnectivityAugmentation {
 
 impl ReductionResult for ReductionHamiltonianCircuitToBiconnectivityAugmentation {
     type Source = HamiltonianCircuit<SimpleGraph>;
-    type Target = BiconnectivityAugmentation<SimpleGraph, i32>;
+    type Target = BiconnectivityAugmentation<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_vertices;
-        if n < 3 {
-            return vec![0; n];
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        if !crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?
+            .0
+        {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target augmentation is infeasible",
+            ));
         }
 
-        // Collect selected edges (those with config value 1)
-        let mut adj: Vec<Vec<usize>> = vec![vec![]; n];
-        for (i, &(u, v)) in self.potential_edges.iter().enumerate() {
-            if i < target_solution.len() && target_solution[i] == 1 {
-                adj[u].push(v);
-                adj[v].push(u);
+        Ok({
+            let n = self.num_vertices;
+            if n < 3 {
+                return Err(crate::rules::ExtractionError::invalid(
+                    "a Hamiltonian circuit requires at least three vertices",
+                ));
             }
-        }
 
-        // Check that every vertex has exactly degree 2 (Hamiltonian cycle)
-        if adj.iter().any(|neighbors| neighbors.len() != 2) {
-            return vec![0; n];
-        }
+            // Collect selected edges (those with config value 1)
+            let mut adj: Vec<Vec<usize>> = vec![vec![]; n];
+            for (i, &(u, v)) in self.potential_edges.iter().enumerate() {
+                if target_solution[i] {
+                    adj[u].push(v);
+                    adj[v].push(u);
+                }
+            }
 
-        // Walk the cycle starting from vertex 0
-        let mut circuit = Vec::with_capacity(n);
-        circuit.push(0);
-        let mut prev = 0;
-        let mut current = adj[0][0];
-        while current != 0 {
-            circuit.push(current);
-            let next = if adj[current][0] == prev {
-                adj[current][1]
-            } else {
-                adj[current][0]
-            };
-            prev = current;
-            current = next;
-
-            // Safety: if we've visited more than n vertices, something is wrong
-            if circuit.len() > n {
-                return vec![0; n];
+            // Check that every vertex has exactly degree 2 (Hamiltonian cycle)
+            if adj.iter().any(|neighbors| neighbors.len() != 2) {
+                return Err(crate::rules::ExtractionError::invalid(
+                    "selected edges do not give every source vertex degree two",
+                ));
             }
-        }
 
-        if circuit.len() == n {
-            circuit
-        } else {
-            vec![0; n]
-        }
+            // Walk the cycle starting from vertex 0
+            let mut circuit = Vec::with_capacity(n);
+            circuit.push(0);
+            let mut prev = 0;
+            let mut current = adj[0][0];
+            while current != 0 {
+                circuit.push(current);
+                let next = if adj[current][0] == prev {
+                    adj[current][1]
+                } else {
+                    adj[current][0]
+                };
+                prev = current;
+                current = next;
+
+                // Safety: if we've visited more than n vertices, something is wrong
+                if circuit.len() > n {
+                    return Err(crate::rules::ExtractionError::invalid(
+                        "selected edges revisit a source vertex",
+                    ));
+                }
+            }
+
+            if circuit.len() == n {
+                circuit
+            } else {
+                return Err(crate::rules::ExtractionError::invalid(
+                    "selected edges do not form a spanning circuit",
+                ));
+            }
+        })
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "num_vertices",
+    transform = upper_bound {
+        num_vertices = "num_vertices + 3",
         num_edges = "0",
         num_potential_edges = "num_vertices * (num_vertices - 1) / 2",
     }
 )]
-impl ReduceTo<BiconnectivityAugmentation<SimpleGraph, i32>> for HamiltonianCircuit<SimpleGraph> {
+impl ReduceTo<BiconnectivityAugmentation<SimpleGraph, i64>> for HamiltonianCircuit<SimpleGraph> {
     type Result = ReductionHamiltonianCircuitToBiconnectivityAugmentation;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
+        if n < 3 {
+            return Ok(ReductionHamiltonianCircuitToBiconnectivityAugmentation {
+                target: BiconnectivityAugmentation::new(SimpleGraph::empty(3), vec![], 0),
+                num_vertices: n,
+                potential_edges: vec![],
+            });
+        }
         let graph = self.graph();
 
         // Edgeless initial graph
@@ -122,15 +153,20 @@ impl ReduceTo<BiconnectivityAugmentation<SimpleGraph, i32>> for HamiltonianCircu
         }
 
         // Budget = n (exactly enough for n weight-1 edges)
-        let budget = n as i32;
+        let budget = i64::try_from(n).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                HamiltonianCircuit<SimpleGraph>,
+                BiconnectivityAugmentation<SimpleGraph, i64>,
+            >("converting the vertex count to the target budget")
+        })?;
 
         let target = BiconnectivityAugmentation::new(initial_graph, potential_weights, budget);
 
-        ReductionHamiltonianCircuitToBiconnectivityAugmentation {
+        Ok(ReductionHamiltonianCircuitToBiconnectivityAugmentation {
             target,
             num_vertices: n,
             potential_edges,
-        }
+        })
     }
 }
 
@@ -150,12 +186,12 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Config: [1, 0, 1, 1, 0, 1]
             crate::example_db::specs::rule_example_with_witness::<
                 _,
-                BiconnectivityAugmentation<SimpleGraph, i32>,
+                BiconnectivityAugmentation<SimpleGraph, i64>,
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 2, 3],
-                    target_config: vec![1, 0, 1, 1, 0, 1],
+                    source_config: serde_json::json!(vec![0, 1, 2, 3]),
+                    target_config: serde_json::json!(vec![true, false, true, true, false, true]),
                 },
             )
         },
diff --git a/src/rules/hamiltoniancircuit_bottlenecktravelingsalesman.rs b/src/rules/hamiltoniancircuit_bottlenecktravelingsalesman.rs
index 061ac0e81..abe6c3783 100644
--- a/src/rules/hamiltoniancircuit_bottlenecktravelingsalesman.rs
+++ b/src/rules/hamiltoniancircuit_bottlenecktravelingsalesman.rs
@@ -23,13 +23,18 @@ impl ReductionResult for ReductionHamiltonianCircuitToBottleneckTravelingSalesma
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         crate::rules::graph_helpers::edges_to_cycle_order(self.target.graph(), target_solution)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_vertices * (num_vertices - 1) / 2",
     }
@@ -37,7 +42,7 @@ impl ReductionResult for ReductionHamiltonianCircuitToBottleneckTravelingSalesma
 impl ReduceTo<BottleneckTravelingSalesman> for HamiltonianCircuit<SimpleGraph> {
     type Result = ReductionHamiltonianCircuitToBottleneckTravelingSalesman;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vertices = self.num_vertices();
         let target_graph = SimpleGraph::complete(num_vertices);
         let weights = target_graph
@@ -47,7 +52,7 @@ impl ReduceTo<BottleneckTravelingSalesman> for HamiltonianCircuit<SimpleGraph> {
             .collect();
         let target = BottleneckTravelingSalesman::new(target_graph, weights);
 
-        ReductionHamiltonianCircuitToBottleneckTravelingSalesman { target }
+        Ok(ReductionHamiltonianCircuitToBottleneckTravelingSalesman { target })
     }
 }
 
@@ -62,8 +67,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, BottleneckTravelingSalesman>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 2, 3],
-                    target_config: vec![1, 0, 1, 1, 0, 1],
+                    source_config: serde_json::json!(vec![0, 1, 2, 3]),
+                    target_config: serde_json::json!(vec![true, false, true, true, false, true]),
                 },
             )
         },
diff --git a/src/rules/hamiltoniancircuit_hamiltonianpath.rs b/src/rules/hamiltoniancircuit_hamiltonianpath.rs
index a3b20d080..4d15d9227 100644
--- a/src/rules/hamiltoniancircuit_hamiltonianpath.rs
+++ b/src/rules/hamiltoniancircuit_hamiltonianpath.rs
@@ -36,41 +36,50 @@ impl ReductionResult for ReductionHamiltonianCircuitToHamiltonianPath {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_original_vertices;
-        if n == 0 {
-            return vec![];
-        }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_original_vertices;
+            if n == 0 {
+                return Ok(vec![]);
+            }
 
-        if target_solution.len() != n + 3 {
-            return vec![0; n];
-        }
+            let v_prime = n; // index of duplicated vertex v'
+            let s = n + 1; // pendant attached to v=0
+            let t = n + 2; // pendant attached to v'
+
+            // The two pendants force any valid witness to have endpoints s and t.
+            let reversed;
+            let oriented = match (target_solution.first(), target_solution.last()) {
+                (Some(&start), Some(&end)) if start == s && end == t => target_solution,
+                (Some(&start), Some(&end)) if start == t && end == s => {
+                    reversed = target_solution.iter().copied().rev().collect::<Vec<_>>();
+                    reversed.as_slice()
+                }
+                _ => {
+                    return Err(crate::rules::ExtractionError::invalid(
+                        "target path does not have the required pendant endpoints",
+                    ))
+                }
+            };
 
-        let v_prime = n; // index of duplicated vertex v'
-        let s = n + 1; // pendant attached to v=0
-        let t = n + 2; // pendant attached to v'
-
-        // The two pendants force any valid witness to have endpoints s and t.
-        let reversed;
-        let oriented = match (target_solution.first(), target_solution.last()) {
-            (Some(&start), Some(&end)) if start == s && end == t => target_solution,
-            (Some(&start), Some(&end)) if start == t && end == s => {
-                reversed = target_solution.iter().copied().rev().collect::<Vec<_>>();
-                reversed.as_slice()
+            if oriented.get(1) != Some(&0) || oriented.get(n + 1) != Some(&v_prime) {
+                return Err(crate::rules::ExtractionError::invalid(
+                    "target path does not traverse the duplicated source vertex correctly",
+                ));
             }
-            _ => return vec![0; n],
-        };
 
-        if oriented.get(1) != Some(&0) || oriented.get(n + 1) != Some(&v_prime) {
-            return vec![0; n];
-        }
-
-        oriented[1..=n].to_vec()
+            oriented[1..=n].to_vec()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vertices = "num_vertices + 3",
         num_edges = "num_edges + num_vertices + 1",
     }
@@ -78,17 +87,17 @@ impl ReductionResult for ReductionHamiltonianCircuitToHamiltonianPath {
 impl ReduceTo<HamiltonianPath<SimpleGraph>> for HamiltonianCircuit<SimpleGraph> {
     type Result = ReductionHamiltonianCircuitToHamiltonianPath;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
 
         // HC is unsatisfiable for n < 3; return a trivially unsatisfiable HP instance.
         if n < 3 {
             let target_graph = SimpleGraph::empty(n + 3);
             let target = HamiltonianPath::new(target_graph);
-            return ReductionHamiltonianCircuitToHamiltonianPath {
+            return Ok(ReductionHamiltonianCircuitToHamiltonianPath {
                 target,
                 num_original_vertices: n,
-            };
+            });
         }
 
         let source_graph = self.graph();
@@ -123,10 +132,10 @@ impl ReduceTo<HamiltonianPath<SimpleGraph>> for HamiltonianCircuit<SimpleGraph>
         let target_graph = SimpleGraph::new(n + 3, edges);
         let target = HamiltonianPath::new(target_graph);
 
-        ReductionHamiltonianCircuitToHamiltonianPath {
+        Ok(ReductionHamiltonianCircuitToHamiltonianPath {
             target,
             num_original_vertices: n,
-        }
+        })
     }
 }
 
@@ -143,9 +152,9 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 source,
                 SolutionPair {
                     // HC solution: visit vertices in order 0, 1, 2, 3
-                    source_config: vec![0, 1, 2, 3],
+                    source_config: serde_json::json!(vec![0, 1, 2, 3]),
                     // HP solution on G' (7 vertices): s=5, 0, 1, 2, 3, v'=4, t=6
-                    target_config: vec![5, 0, 1, 2, 3, 4, 6],
+                    target_config: serde_json::json!(vec![5, 0, 1, 2, 3, 4, 6]),
                 },
             )
         },
diff --git a/src/rules/hamiltoniancircuit_longestcircuit.rs b/src/rules/hamiltoniancircuit_longestcircuit.rs
index c6d9a0bba..34ae58de9 100644
--- a/src/rules/hamiltoniancircuit_longestcircuit.rs
+++ b/src/rules/hamiltoniancircuit_longestcircuit.rs
@@ -12,36 +12,65 @@ use crate::topology::{Graph, SimpleGraph};
 /// Result of reducing HamiltonianCircuit to LongestCircuit.
 #[derive(Debug, Clone)]
 pub struct ReductionHamiltonianCircuitToLongestCircuit {
-    target: LongestCircuit<SimpleGraph, i32>,
+    target: LongestCircuit<SimpleGraph, i64>,
 }
 
 impl ReductionResult for ReductionHamiltonianCircuitToLongestCircuit {
     type Source = HamiltonianCircuit<SimpleGraph>;
-    type Target = LongestCircuit<SimpleGraph, i32>;
+    type Target = LongestCircuit<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target circuit does not certify a Hamiltonian circuit",
+            ));
+        }
+
         crate::rules::graph_helpers::edges_to_cycle_order(self.target.graph(), target_solution)
     }
 }
 
+impl crate::rules::AggregateReductionResult for ReductionHamiltonianCircuitToLongestCircuit {
+    type Source = HamiltonianCircuit<SimpleGraph>;
+    type Target = LongestCircuit<SimpleGraph, i64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, target_value: crate::types::Max<i64>) -> crate::types::Or {
+        crate::types::Or(
+            target_value
+                .0
+                .is_some_and(|length| usize::try_from(length) == Ok(self.target.num_vertices())),
+        )
+    }
+}
+
 #[reduction(
-    overhead = {
+    aggregate = custom,
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_edges",
     }
 )]
-impl ReduceTo<LongestCircuit<SimpleGraph, i32>> for HamiltonianCircuit<SimpleGraph> {
+impl ReduceTo<LongestCircuit<SimpleGraph, i64>> for HamiltonianCircuit<SimpleGraph> {
     type Result = ReductionHamiltonianCircuitToLongestCircuit;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let edges = self.graph().edges();
-        let target = LongestCircuit::new(SimpleGraph::new(n, edges), vec![1i32; self.num_edges()]);
-        ReductionHamiltonianCircuitToLongestCircuit { target }
+        let target = LongestCircuit::new(SimpleGraph::new(n, edges), vec![1i64; self.num_edges()]);
+        Ok(ReductionHamiltonianCircuitToLongestCircuit { target })
     }
 }
 
@@ -53,11 +82,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "hamiltoniancircuit_to_longestcircuit",
         build: || {
             let source = HamiltonianCircuit::new(SimpleGraph::cycle(4));
-            crate::example_db::specs::rule_example_with_witness::<_, LongestCircuit<SimpleGraph, i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, LongestCircuit<SimpleGraph, i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 2, 3],
-                    target_config: vec![1, 1, 1, 1],
+                    source_config: serde_json::json!(vec![0, 1, 2, 3]),
+                    target_config: serde_json::json!(vec![true, true, true, true]),
                 },
             )
         },
diff --git a/src/rules/hamiltoniancircuit_quadraticassignment.rs b/src/rules/hamiltoniancircuit_quadraticassignment.rs
index f366b4770..4cd1e5264 100644
--- a/src/rules/hamiltoniancircuit_quadraticassignment.rs
+++ b/src/rules/hamiltoniancircuit_quadraticassignment.rs
@@ -1,10 +1,9 @@
 //! Reduction from HamiltonianCircuit to QuadraticAssignment.
 //!
-//! Uses the Sahni & Gonzalez (1976) construction. The cost matrix encodes
-//! cycle adjacency on positions: c[i][j] = 1 if j = (i+1) mod n, else 0.
-//! The distance matrix encodes graph connectivity: d[k][l] = 1 if {k,l} ∈ E,
-//! else ω = n+1 (penalty). A Hamiltonian circuit exists iff the QAP optimum
-//! equals n.
+//! Uses an exact-decision normalization of the Sahni & Gonzalez (1976)
+//! cycle-position construction. The QAP cost counts missing edges in a cyclic
+//! permutation, so zero cost certifies a Hamiltonian circuit. Sources with fewer
+//! than three vertices map to a fixed positive-cost instance.
 
 use crate::models::algebraic::QuadraticAssignment;
 use crate::models::graph::HamiltonianCircuit;
@@ -26,56 +25,64 @@ impl ReductionResult for ReductionHamiltonianCircuitToQuadraticAssignment {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // QAP config is a permutation γ mapping positions to vertices,
-        // which is directly the Hamiltonian circuit visit order.
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target assignment does not certify a Hamiltonian circuit",
+            ));
+        }
+
+        // Zero cost makes this permutation itself a Hamiltonian circuit.
+        Ok(target_solution.to_vec())
+    }
+}
+
+impl crate::rules::AggregateReductionResult for ReductionHamiltonianCircuitToQuadraticAssignment {
+    type Source = HamiltonianCircuit<SimpleGraph>;
+    type Target = QuadraticAssignment;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, target_value: crate::types::Min<i64>) -> crate::types::Or {
+        crate::types::Or(target_value == crate::types::Min(Some(0)))
     }
 }
 
 #[reduction(
-    overhead = {
-        num_facilities = "num_vertices",
-        num_locations = "num_vertices",
+    aggregate = custom,
+    transform = upper_bound {
+        num_facilities = "num_vertices + 3",
+        num_locations = "num_vertices + 3",
     }
 )]
 impl ReduceTo<QuadraticAssignment> for HamiltonianCircuit<SimpleGraph> {
     type Result = ReductionHamiltonianCircuitToQuadraticAssignment;
 
-    fn reduce_to(&self) -> Self::Result {
-        let n = self.num_vertices();
-        let omega = (n + 1) as i64;
-
-        // Cost matrix C: cycle adjacency on positions.
-        // c[i][j] = 1 if j == (i+1) mod n, else 0.
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let source_n = self.num_vertices();
+        // The source requires at least three vertices. For smaller graphs use
+        // three positions with every distinct pair charged, hence optimum 3.
+        let n = source_n.max(3);
         let cost_matrix: Vec<Vec<i64>> = (0..n)
-            .map(|i| {
-                (0..n)
-                    .map(|j| if j == (i + 1) % n { 1 } else { 0 })
-                    .collect()
-            })
+            .map(|i| (0..n).map(|j| i64::from(j == (i + 1) % n)).collect())
             .collect();
-
-        // Distance matrix D: graph connectivity.
-        // d[k][l] = 1 if {k,l} ∈ E, else ω (penalty) for k ≠ l; d[k][k] = 0.
         let distance_matrix: Vec<Vec<i64>> = (0..n)
             .map(|k| {
                 (0..n)
-                    .map(|l| {
-                        if k == l {
-                            0
-                        } else if self.graph().has_edge(k, l) {
-                            1
-                        } else {
-                            omega
-                        }
-                    })
+                    .map(|l| i64::from(k != l && (source_n < 3 || !self.graph().has_edge(k, l))))
                     .collect()
             })
             .collect();
 
         let target = QuadraticAssignment::new(cost_matrix, distance_matrix);
-        ReductionHamiltonianCircuitToQuadraticAssignment { target }
+        Ok(ReductionHamiltonianCircuitToQuadraticAssignment { target })
     }
 }
 
@@ -90,8 +97,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, QuadraticAssignment>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 2, 3],
-                    target_config: vec![0, 1, 2, 3],
+                    source_config: serde_json::json!(vec![0, 1, 2, 3]),
+                    target_config: serde_json::json!(vec![0, 1, 2, 3]),
                 },
             )
         },
diff --git a/src/rules/hamiltoniancircuit_ruralpostman.rs b/src/rules/hamiltoniancircuit_ruralpostman.rs
index 277b1aa18..e1e2d321d 100644
--- a/src/rules/hamiltoniancircuit_ruralpostman.rs
+++ b/src/rules/hamiltoniancircuit_ruralpostman.rs
@@ -31,7 +31,7 @@ use crate::topology::{Graph, SimpleGraph};
 /// Result of reducing HamiltonianCircuit to RuralPostman.
 #[derive(Debug, Clone)]
 pub struct ReductionHamiltonianCircuitToRuralPostman {
-    target: RuralPostman<SimpleGraph, i32>,
+    target: RuralPostman<SimpleGraph, i64>,
     /// Number of vertices in the original graph.
     n: usize,
     /// Edges of the original graph (for solution extraction).
@@ -40,72 +40,80 @@ pub struct ReductionHamiltonianCircuitToRuralPostman {
 
 impl ReductionResult for ReductionHamiltonianCircuitToRuralPostman {
     type Source = HamiltonianCircuit<SimpleGraph>;
-    type Target = RuralPostman<SimpleGraph, i32>;
+    type Target = RuralPostman<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // The target solution is edge multiplicities.
-        // Required edges are indices 0..n (the {v_i^a, v_i^b} edges).
-        // Connectivity edges start at index n.
-        // For each source edge (v_i, v_j) at source index k:
-        //   target edge n + 2*k is {v_i^b, v_j^a}
-        //   target edge n + 2*k + 1 is {v_j^b, v_i^a}
-        //
-        // A connectivity edge {v_i^b, v_j^a} used with multiplicity 1 means
-        // the tour goes from vertex i to vertex j (j follows i in the HC).
-
-        let n = self.n;
-
-        // Build successor map from connectivity edges used exactly once
-        let mut successor = vec![usize::MAX; n];
-        for (k, &(vi, vj)) in self.source_edges.iter().enumerate() {
-            let fwd_idx = n + 2 * k; // {v_i^b, v_j^a}
-            let bwd_idx = n + 2 * k + 1; // {v_j^b, v_i^a}
-
-            let fwd_mult = target_solution.get(fwd_idx).copied().unwrap_or(0);
-            let bwd_mult = target_solution.get(bwd_idx).copied().unwrap_or(0);
-
-            // In an optimal HC solution, each connectivity edge is used 0 or 1 times.
-            // Each vertex should have exactly one outgoing connectivity edge.
-            if fwd_mult > 0 && successor[vi] == usize::MAX {
-                successor[vi] = vj;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // The target solution is edge multiplicities.
+            // Required edges are indices 0..n (the {v_i^a, v_i^b} edges).
+            // Connectivity edges start at index n.
+            // For each source edge (v_i, v_j) at source index k:
+            //   target edge n + 2*k is {v_i^b, v_j^a}
+            //   target edge n + 2*k + 1 is {v_j^b, v_i^a}
+            //
+            // A connectivity edge {v_i^b, v_j^a} used with multiplicity 1 means
+            // the tour goes from vertex i to vertex j (j follows i in the HC).
+
+            let n = self.n;
+
+            // Build successor map from connectivity edges used exactly once
+            let mut successor = vec![usize::MAX; n];
+            for (k, &(vi, vj)) in self.source_edges.iter().enumerate() {
+                let fwd_idx = n + 2 * k; // {v_i^b, v_j^a}
+                let bwd_idx = n + 2 * k + 1; // {v_j^b, v_i^a}
+
+                let fwd_mult = target_solution[fwd_idx];
+                let bwd_mult = target_solution[bwd_idx];
+
+                // In an optimal HC solution, each connectivity edge is used 0 or 1 times.
+                // Each vertex should have exactly one outgoing connectivity edge.
+                if fwd_mult > 0 && successor[vi] == usize::MAX {
+                    successor[vi] = vj;
+                }
+                if bwd_mult > 0 && successor[vj] == usize::MAX {
+                    successor[vj] = vi;
+                }
             }
-            if bwd_mult > 0 && successor[vj] == usize::MAX {
-                successor[vj] = vi;
-            }
-        }
 
-        // Walk the successor chain starting from vertex 0
-        let mut cycle = Vec::with_capacity(n);
-        let mut current = 0;
-        for _ in 0..n {
-            cycle.push(current);
-            let next = successor[current];
-            if next == usize::MAX {
-                // No valid successor found; return fallback
-                return vec![0; n];
+            // Walk the successor chain starting from vertex 0
+            let mut cycle = Vec::with_capacity(n);
+            let mut current = 0;
+            for _ in 0..n {
+                cycle.push(current);
+                let next = successor[current];
+                if next == usize::MAX {
+                    return Err(crate::rules::ExtractionError::invalid(
+                        "target tour does not provide one successor for every source vertex",
+                    ));
+                }
+                current = next;
             }
-            current = next;
-        }
 
-        cycle
+            cycle
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "2 * num_vertices",
         num_edges = "num_vertices + 2 * num_edges",
         num_required_edges = "num_vertices",
     }
 )]
-impl ReduceTo<RuralPostman<SimpleGraph, i32>> for HamiltonianCircuit<SimpleGraph> {
+impl ReduceTo<RuralPostman<SimpleGraph, i64>> for HamiltonianCircuit<SimpleGraph> {
     type Result = ReductionHamiltonianCircuitToRuralPostman;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let source_edges: Vec<(usize, usize)> = self.graph().edges();
         let m = source_edges.len();
@@ -136,11 +144,11 @@ impl ReduceTo<RuralPostman<SimpleGraph, i32>> for HamiltonianCircuit<SimpleGraph
         let target_graph = SimpleGraph::new(2 * n, target_edges);
         let target = RuralPostman::new(target_graph, edge_weights, required_edges);
 
-        ReductionHamiltonianCircuitToRuralPostman {
+        Ok(ReductionHamiltonianCircuitToRuralPostman {
             target,
             n,
             source_edges,
-        }
+        })
     }
 }
 
@@ -161,11 +169,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             //   2->0: bwd edge of source edge 2=(0,2), idx=8
             // Required edges all have multiplicity 1.
             // target_config = [1, 1, 1, 1, 0, 1, 0, 0, 1]
-            crate::example_db::specs::rule_example_with_witness::<_, RuralPostman<SimpleGraph, i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, RuralPostman<SimpleGraph, i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 2],
-                    target_config: vec![1, 1, 1, 1, 0, 1, 0, 0, 1],
+                    source_config: serde_json::json!(vec![0, 1, 2]),
+                    target_config: serde_json::json!(vec![1, 1, 1, 1, 0, 1, 0, 0, 1]),
                 },
             )
         },
diff --git a/src/rules/hamiltoniancircuit_stackercrane.rs b/src/rules/hamiltoniancircuit_stackercrane.rs
index 7b8d05345..bccffa686 100644
--- a/src/rules/hamiltoniancircuit_stackercrane.rs
+++ b/src/rules/hamiltoniancircuit_stackercrane.rs
@@ -1,16 +1,16 @@
 //! Reduction from HamiltonianCircuit to StackerCrane.
 //!
-//! Based on the vertex-splitting construction of Frederickson, Hecht & Kim (1978).
+//! Vertex splitting into the mixed routing formulation of StackerCrane.
 //! Each vertex v_i is split into v_i^in (= 2i) and v_i^out (= 2i+1). A mandatory
 //! directed arc (v_i^in → v_i^out) of length 1 is added for each vertex. For each
 //! undirected edge {v_i, v_j} in the source graph, two undirected connector edges
 //! {v_i^out, v_j^in} and {v_j^out, v_i^in} of length 1 are added.
 //!
 //! The source graph has a Hamiltonian circuit iff the optimal Stacker Crane tour
-//! cost equals 2n (n arcs of cost 1 plus n single-hop connectors of cost 1).
+//! cost equals 2n and n >= 3 (n service arcs and n unit-cost connectors).
 //! Using connector length 1 (rather than 0) ensures that multi-hop connector
-//! paths cost strictly more than single-hop ones, so every optimal permutation
-//! corresponds to a valid Hamiltonian circuit.
+//! paths cost strictly more than single-hop ones. Only permutations attaining
+//! this lower bound certify a Hamiltonian circuit.
 
 use crate::models::graph::HamiltonianCircuit;
 use crate::models::misc::StackerCrane;
@@ -32,16 +32,43 @@ impl ReductionResult for ReductionHamiltonianCircuitToStackerCrane {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // The target config is a permutation of arc indices.
-        // Arc i corresponds to original vertex i (arc from 2i to 2i+1).
-        // The permutation order directly gives the Hamiltonian circuit vertex order.
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target tour does not certify a Hamiltonian circuit",
+            ));
+        }
+        // Service arc i corresponds to source vertex i.
+        Ok(target_solution.to_vec())
+    }
+}
+
+impl crate::rules::AggregateReductionResult for ReductionHamiltonianCircuitToStackerCrane {
+    type Source = HamiltonianCircuit<SimpleGraph>;
+    type Target = StackerCrane;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, value: crate::types::Min<i64>) -> crate::types::Or {
+        crate::types::Or(
+            self.target.num_arcs() >= 3
+                && value
+                    .0
+                    .is_some_and(|cost| usize::try_from(cost) == Ok(self.target.num_vertices())),
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    aggregate = custom,
+    transform = exact {
         num_vertices = "2 * num_vertices",
         num_arcs = "num_vertices",
         num_edges = "2 * num_edges",
@@ -50,23 +77,23 @@ impl ReductionResult for ReductionHamiltonianCircuitToStackerCrane {
 impl ReduceTo<StackerCrane> for HamiltonianCircuit<SimpleGraph> {
     type Result = ReductionHamiltonianCircuitToStackerCrane;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
 
         // Each vertex i becomes two vertices: 2i (in) and 2i+1 (out).
-        let target_num_vertices = 2 * n;
+        let (target_num_vertices, target_num_edges) = split_graph_dimensions(n, self.num_edges())?;
 
         // One mandatory arc per original vertex: (2i, 2i+1) with length 1.
         let arcs: Vec<(usize, usize)> = (0..n).map(|i| (2 * i, 2 * i + 1)).collect();
-        let arc_lengths: Vec<i32> = vec![1; n];
+        let arc_lengths: Vec<i64> = vec![1; n];
 
         // For each original edge {u, v}, add two undirected connector edges:
         //   {u^out, v^in} = {2u+1, 2v}  with length 1
         //   {v^out, u^in} = {2v+1, 2u}  with length 1
         // Using length 1 (not 0) prevents multi-hop zero-cost shortcuts that
         // would create optimal SC permutations not corresponding to valid HCs.
-        let mut edges = Vec::new();
-        let mut edge_lengths = Vec::new();
+        let mut edges = Vec::with_capacity(target_num_edges);
+        let mut edge_lengths = Vec::with_capacity(target_num_edges);
         for (u, v) in self.graph().edges() {
             edges.push((2 * u + 1, 2 * v));
             edge_lengths.push(1);
@@ -74,12 +101,34 @@ impl ReduceTo<StackerCrane> for HamiltonianCircuit<SimpleGraph> {
             edge_lengths.push(1);
         }
 
-        let target = StackerCrane::new(target_num_vertices, arcs, edges, arc_lengths, edge_lengths);
+        let target =
+            StackerCrane::try_new(target_num_vertices, arcs, edges, arc_lengths, edge_lengths)
+                .map_err(<Self as ReduceTo<StackerCrane>>::target_construction)?;
 
-        ReductionHamiltonianCircuitToStackerCrane { target }
+        Ok(ReductionHamiltonianCircuitToStackerCrane { target })
     }
 }
 
+/// Check split indices and every finite service-order cost before allocation.
+fn split_graph_dimensions(
+    n: usize,
+    m: usize,
+) -> Result<(usize, usize), crate::rules::ReductionError> {
+    type Source = HamiltonianCircuit<SimpleGraph>;
+    let overflow = || {
+        crate::rules::ReductionError::integer_overflow::<Source, StackerCrane>(
+            "encoding split graph dimensions and route costs",
+        )
+    };
+    let vertices = n.checked_mul(2).ok_or_else(overflow)?;
+    let edges = m.checked_mul(2).ok_or_else(overflow)?;
+    // A shortest connector is simple and has at most 2n-1 unit steps.
+    // The n services therefore cost at most n * (1 + (2n-1)).
+    let cost_bound = n.checked_mul(vertices).ok_or_else(overflow)?;
+    <Source as ReduceTo<StackerCrane>>::exact_i64(cost_bound, "bounding split graph route costs")?;
+    Ok((vertices, edges))
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
     use crate::export::SolutionPair;
@@ -91,8 +140,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, StackerCrane>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 2, 3],
-                    target_config: vec![0, 1, 2, 3],
+                    source_config: serde_json::json!(vec![0, 1, 2, 3]),
+                    target_config: serde_json::json!(vec![0, 1, 2, 3]),
                 },
             )
         },
diff --git a/src/rules/hamiltoniancircuit_strongconnectivityaugmentation.rs b/src/rules/hamiltoniancircuit_strongconnectivityaugmentation.rs
index e90842ca6..e2592e77e 100644
--- a/src/rules/hamiltoniancircuit_strongconnectivityaugmentation.rs
+++ b/src/rules/hamiltoniancircuit_strongconnectivityaugmentation.rs
@@ -15,66 +15,76 @@ use crate::topology::{DirectedGraph, Graph, SimpleGraph};
 /// Result of reducing HamiltonianCircuit to StrongConnectivityAugmentation.
 #[derive(Debug, Clone)]
 pub struct ReductionHamiltonianCircuitToStrongConnectivityAugmentation {
-    target: StrongConnectivityAugmentation<i32>,
+    target: StrongConnectivityAugmentation<i64>,
     n: usize,
 }
 
 impl ReductionResult for ReductionHamiltonianCircuitToStrongConnectivityAugmentation {
     type Source = HamiltonianCircuit<SimpleGraph>;
-    type Target = StrongConnectivityAugmentation<i32>;
+    type Target = StrongConnectivityAugmentation<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.n;
-        if n == 0 {
-            return vec![];
-        }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
-        // Build directed adjacency from selected arcs.
-        let candidate_arcs = self.target.candidate_arcs();
-        let mut successors = vec![Vec::new(); n];
-        for (idx, &selected) in target_solution.iter().enumerate() {
-            if selected == 1 {
-                let (u, v, _) = candidate_arcs[idx];
-                successors[u].push(v);
+        Ok({
+            let n = self.n;
+            if n == 0 {
+                return Ok(vec![]);
             }
-        }
 
-        // Walk the directed cycle starting from vertex 0.
-        let mut order = Vec::with_capacity(n);
-        let mut current = 0;
-        let mut visited = vec![false; n];
-        for _ in 0..n {
-            if visited[current] {
-                // Not a valid Hamiltonian cycle; return fallback.
-                return vec![0; n];
+            // Build directed adjacency from selected arcs.
+            let candidate_arcs = self.target.candidate_arcs();
+            let mut successors = vec![Vec::new(); n];
+            for (idx, &selected) in target_solution.iter().enumerate() {
+                if selected {
+                    let (u, v, _) = candidate_arcs[idx];
+                    successors[u].push(v);
+                }
             }
-            visited[current] = true;
-            order.push(current);
-            if successors[current].len() != 1 {
-                return vec![0; n];
+
+            // Walk the directed cycle starting from vertex 0.
+            let mut order = Vec::with_capacity(n);
+            let mut current = 0;
+            let mut visited = vec![false; n];
+            for _ in 0..n {
+                if visited[current] {
+                    return Err(crate::rules::ExtractionError::invalid(
+                        "selected arcs revisit a source vertex",
+                    ));
+                }
+                visited[current] = true;
+                order.push(current);
+                if successors[current].len() != 1 {
+                    return Err(crate::rules::ExtractionError::invalid(
+                        "selected arcs do not provide one successor for every source vertex",
+                    ));
+                }
+                current = successors[current][0];
             }
-            current = successors[current][0];
-        }
 
-        order
+            order
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_arcs = "0",
         num_potential_arcs = "num_vertices * (num_vertices - 1)",
     }
 )]
-impl ReduceTo<StrongConnectivityAugmentation<i32>> for HamiltonianCircuit<SimpleGraph> {
+impl ReduceTo<StrongConnectivityAugmentation<i64>> for HamiltonianCircuit<SimpleGraph> {
     type Result = ReductionHamiltonianCircuitToStrongConnectivityAugmentation;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let graph = DirectedGraph::empty(n);
 
@@ -89,10 +99,15 @@ impl ReduceTo<StrongConnectivityAugmentation<i32>> for HamiltonianCircuit<Simple
             }
         }
 
-        let bound = n as i32;
+        let bound = i64::try_from(n).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                HamiltonianCircuit<SimpleGraph>,
+                StrongConnectivityAugmentation<i64>,
+            >("converting the vertex count to the target bound")
+        })?;
         let target = StrongConnectivityAugmentation::new(graph, candidate_arcs, bound);
 
-        ReductionHamiltonianCircuitToStrongConnectivityAugmentation { target, n }
+        Ok(ReductionHamiltonianCircuitToStrongConnectivityAugmentation { target, n })
     }
 }
 
@@ -105,7 +120,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             // 4-cycle: 0-1-2-3-0
             let source = HamiltonianCircuit::new(SimpleGraph::cycle(4));
-            let reduction = ReduceTo::<StrongConnectivityAugmentation<i32>>::reduce_to(&source);
+            let reduction = ReduceTo::<StrongConnectivityAugmentation<i64>>::reduce_to(&source)
+                .expect("reduction should succeed");
             let target = reduction.target_problem();
 
             // The HC permutation [0, 1, 2, 3] corresponds to the directed cycle
@@ -114,16 +130,16 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // for each v in 0..n where u!=v, so arc (u,v) is at index
             // u*(n-1) + (if v > u then v-1 else v).
             let n = 4;
-            let mut target_config = vec![0usize; n * (n - 1)];
+            let mut target_config = vec![false; n * (n - 1)];
             let cycle_arcs = [(0, 1), (1, 2), (2, 3), (3, 0)];
             for (u, v) in cycle_arcs {
                 let idx = u * (n - 1) + if v > u { v - 1 } else { v };
-                target_config[idx] = 1;
+                target_config[idx] = true;
             }
 
             // Verify the target config is valid
             assert!(
-                target.is_valid_solution(&target_config),
+                target.is_valid_solution(&target_config).unwrap(),
                 "canonical target config must be a valid SCA solution"
             );
 
@@ -131,8 +147,9 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 &source,
                 target,
                 vec![SolutionPair {
-                    source_config: vec![0, 1, 2, 3],
-                    target_config,
+                    source_config: serde_json::json!(vec![0, 1, 2, 3]),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/hamiltoniancircuit_travelingsalesman.rs b/src/rules/hamiltoniancircuit_travelingsalesman.rs
index eebeb26af..8e90e4ac8 100644
--- a/src/rules/hamiltoniancircuit_travelingsalesman.rs
+++ b/src/rules/hamiltoniancircuit_travelingsalesman.rs
@@ -12,32 +12,37 @@ use crate::topology::{Graph, SimpleGraph};
 /// Result of reducing HamiltonianCircuit to TravelingSalesman.
 #[derive(Debug, Clone)]
 pub struct ReductionHamiltonianCircuitToTravelingSalesman {
-    target: TravelingSalesman<SimpleGraph, i32>,
+    target: TravelingSalesman<SimpleGraph, i64>,
 }
 
 impl ReductionResult for ReductionHamiltonianCircuitToTravelingSalesman {
     type Source = HamiltonianCircuit<SimpleGraph>;
-    type Target = TravelingSalesman<SimpleGraph, i32>;
+    type Target = TravelingSalesman<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         crate::rules::graph_helpers::edges_to_cycle_order(self.target.graph(), target_solution)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_vertices * (num_vertices - 1) / 2",
     }
 )]
-impl ReduceTo<TravelingSalesman<SimpleGraph, i32>> for HamiltonianCircuit<SimpleGraph> {
+impl ReduceTo<TravelingSalesman<SimpleGraph, i64>> for HamiltonianCircuit<SimpleGraph> {
     type Result = ReductionHamiltonianCircuitToTravelingSalesman;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vertices = self.num_vertices();
         let target_graph = SimpleGraph::complete(num_vertices);
         let weights = target_graph
@@ -47,7 +52,7 @@ impl ReduceTo<TravelingSalesman<SimpleGraph, i32>> for HamiltonianCircuit<Simple
             .collect();
         let target = TravelingSalesman::new(target_graph, weights);
 
-        ReductionHamiltonianCircuitToTravelingSalesman { target }
+        Ok(ReductionHamiltonianCircuitToTravelingSalesman { target })
     }
 }
 
@@ -61,12 +66,12 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             let source = HamiltonianCircuit::new(SimpleGraph::cycle(4));
             crate::example_db::specs::rule_example_with_witness::<
                 _,
-                TravelingSalesman<SimpleGraph, i32>,
+                TravelingSalesman<SimpleGraph, i64>,
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 2, 3],
-                    target_config: vec![1, 0, 1, 1, 0, 1],
+                    source_config: serde_json::json!(vec![0, 1, 2, 3]),
+                    target_config: serde_json::json!(vec![true, false, true, true, false, true]),
                 },
             )
         },
diff --git a/src/rules/hamiltonianpath_degreeconstrainedspanningtree.rs b/src/rules/hamiltonianpath_degreeconstrainedspanningtree.rs
index e6fc6c548..c783517cb 100644
--- a/src/rules/hamiltonianpath_degreeconstrainedspanningtree.rs
+++ b/src/rules/hamiltonianpath_degreeconstrainedspanningtree.rs
@@ -21,13 +21,18 @@ impl ReductionResult for ReductionHamiltonianPathToDegreeConstrainedSpanningTree
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         extract_hamiltonian_order(self.target.graph(), target_solution)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_edges",
     }
@@ -35,32 +40,28 @@ impl ReductionResult for ReductionHamiltonianPathToDegreeConstrainedSpanningTree
 impl ReduceTo<DegreeConstrainedSpanningTree<SimpleGraph>> for HamiltonianPath<SimpleGraph> {
     type Result = ReductionHamiltonianPathToDegreeConstrainedSpanningTree;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let target = DegreeConstrainedSpanningTree::new(
             SimpleGraph::new(self.graph().num_vertices(), self.graph().edges()),
             2,
         );
-        ReductionHamiltonianPathToDegreeConstrainedSpanningTree { target }
+        Ok(ReductionHamiltonianPathToDegreeConstrainedSpanningTree { target })
     }
 }
 
-fn extract_hamiltonian_order(graph: &SimpleGraph, target_solution: &[usize]) -> Vec<usize> {
+fn extract_hamiltonian_order(
+    graph: &SimpleGraph,
+    target_solution: &[bool],
+) -> crate::rules::ExtractionResult<Vec<usize>> {
     let num_vertices = graph.num_vertices();
-    if num_vertices == 0 {
-        return vec![];
-    }
-    if num_vertices == 1 {
-        return vec![0];
+    if num_vertices < 2 {
+        return Ok((0..num_vertices).collect());
     }
 
     let edges = graph.edges();
-    if target_solution.len() != edges.len() {
-        return vec![];
-    }
-
     let mut adjacency = vec![Vec::new(); num_vertices];
     for ((u, v), &selected) in edges.iter().copied().zip(target_solution.iter()) {
-        if selected != 1 {
+        if !selected {
             continue;
         }
         adjacency[u].push(v);
@@ -74,7 +75,9 @@ fn extract_hamiltonian_order(graph: &SimpleGraph, target_solution: &[usize]) ->
         .collect();
     endpoints.sort_unstable();
     if endpoints.len() != 2 {
-        return vec![];
+        return Err(crate::rules::ExtractionError::invalid(
+            "selected edges do not form a Hamiltonian path",
+        ));
     }
 
     let mut order = Vec::with_capacity(num_vertices);
@@ -84,7 +87,9 @@ fn extract_hamiltonian_order(graph: &SimpleGraph, target_solution: &[usize]) ->
 
     loop {
         if visited[current] {
-            return vec![];
+            return Err(crate::rules::ExtractionError::invalid(
+                "selected edges contain a cycle",
+            ));
         }
         visited[current] = true;
         order.push(current);
@@ -103,14 +108,16 @@ fn extract_hamiltonian_order(graph: &SimpleGraph, target_solution: &[usize]) ->
     }
 
     if order.len() == num_vertices {
-        order
+        Ok(order)
     } else {
-        vec![]
+        Err(crate::rules::ExtractionError::invalid(
+            "selected edges do not span every source vertex",
+        ))
     }
 }
 
 #[cfg(feature = "example-db")]
-fn edge_config_for_path(graph: &SimpleGraph, path: &[usize]) -> Vec<usize> {
+fn edge_config_for_path(graph: &SimpleGraph, path: &[usize]) -> Vec<bool> {
     let selected_edges: Vec<(usize, usize)> = path
         .windows(2)
         .map(|window| (window[0], window[1]))
@@ -119,11 +126,9 @@ fn edge_config_for_path(graph: &SimpleGraph, path: &[usize]) -> Vec<usize> {
         .edges()
         .into_iter()
         .map(|(u, v)| {
-            usize::from(
-                selected_edges
-                    .iter()
-                    .any(|&(a, b)| (a == u && b == v) || (a == v && b == u)),
-            )
+            selected_edges
+                .iter()
+                .any(|&(a, b)| (a == u && b == v) || (a == v && b == u))
         })
         .collect()
 }
@@ -152,7 +157,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             let source_config = vec![0, 2, 4, 3, 1, 5];
             let source = source_example();
             let reduction =
-                ReduceTo::<DegreeConstrainedSpanningTree<SimpleGraph>>::reduce_to(&source);
+                ReduceTo::<DegreeConstrainedSpanningTree<SimpleGraph>>::reduce_to(&source)
+                    .expect("reduction should succeed");
             let target_config =
                 edge_config_for_path(reduction.target_problem().graph(), &source_config);
             crate::example_db::specs::rule_example_with_witness::<
@@ -161,8 +167,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             >(
                 source,
                 crate::export::SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/hamiltonianpath_ilp.rs b/src/rules/hamiltonianpath_ilp.rs
index d60f1291a..378545040 100644
--- a/src/rules/hamiltonianpath_ilp.rs
+++ b/src/rules/hamiltonianpath_ilp.rs
@@ -35,21 +35,29 @@ impl ReductionResult for ReductionHamiltonianPathToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         one_hot_decode(target_solution, self.num_vertices, self.num_vertices, 0)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_vertices^2 + 2 * num_edges * num_vertices",
         num_constraints = "2 * num_vertices + 6 * num_edges * num_vertices + num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for HamiltonianPath<SimpleGraph> {
     type Result = ReductionHamiltonianPathToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let graph = self.graph();
         let edges = graph.edges();
@@ -91,19 +99,20 @@ impl ReduceTo<ILP<bool>> for HamiltonianPath<SimpleGraph> {
         for p in 0..n_pos {
             let mut terms = Vec::new();
             for e in 0..m {
-                terms.push((z_fwd_idx(e, p), 1.0));
-                terms.push((z_rev_idx(e, p), 1.0));
+                terms.push((z_fwd_idx(e, p), 1));
+                terms.push((z_rev_idx(e, p), 1));
             }
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Feasibility: no objective
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionHamiltonianPathToILP {
+        Ok(ReductionHamiltonianPathToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
diff --git a/src/rules/hamiltonianpath_isomorphicspanningtree.rs b/src/rules/hamiltonianpath_isomorphicspanningtree.rs
index a5a96e829..b95b555d4 100644
--- a/src/rules/hamiltonianpath_isomorphicspanningtree.rs
+++ b/src/rules/hamiltonianpath_isomorphicspanningtree.rs
@@ -1,4 +1,4 @@
-//! Reduction from HamiltonianPath to IsomorphicSpanningTree<SimpleGraph>.
+//! Reduction from HamiltonianPath to `IsomorphicSpanningTree<SimpleGraph>`.
 //!
 //! A Hamiltonian path in G exists iff G has a spanning tree isomorphic to the
 //! path graph P_n. The reduction keeps G unchanged as the host graph and
@@ -28,22 +28,26 @@ impl ReductionResult for ReductionHPToIST {
     /// The IST config maps tree vertex i to graph vertex config[i]. Since the
     /// tree is P_n (path 0-1-2-...-n-1), this mapping directly gives the
     /// vertex ordering of the Hamiltonian path.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
-        num_graph_edges = "num_edges",
-        num_tree_edges = "num_vertices - 1",
+        num_edges = "num_edges",
     }
 )]
 impl ReduceTo<IsomorphicSpanningTree<SimpleGraph>> for HamiltonianPath<SimpleGraph> {
     type Result = ReductionHPToIST;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
 
         // Host graph: keep G unchanged
@@ -51,9 +55,9 @@ impl ReduceTo<IsomorphicSpanningTree<SimpleGraph>> for HamiltonianPath<SimpleGra
 
         let tree = SimpleGraph::path(n);
 
-        ReductionHPToIST {
+        Ok(ReductionHPToIST {
             target: IsomorphicSpanningTree::new(graph, tree),
-        }
+        })
     }
 }
 
@@ -72,8 +76,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 2, 3, 4],
-                    target_config: vec![0, 1, 2, 3, 4],
+                    source_config: serde_json::json!(vec![0, 1, 2, 3, 4]),
+                    target_config: serde_json::json!(vec![0, 1, 2, 3, 4]),
                 },
             )
         },
diff --git a/src/rules/hamiltonianpathbetweentwovertices_longestpath.rs b/src/rules/hamiltonianpathbetweentwovertices_longestpath.rs
index bc177227e..0a9186ee1 100644
--- a/src/rules/hamiltonianpathbetweentwovertices_longestpath.rs
+++ b/src/rules/hamiltonianpathbetweentwovertices_longestpath.rs
@@ -15,10 +15,6 @@ use crate::types::One;
 #[derive(Debug, Clone)]
 pub struct ReductionHPBTVToLP {
     target: LongestPath<SimpleGraph, One>,
-    /// Cached edge list from the graph, indexed by edge position.
-    edges: Vec<(usize, usize)>,
-    source_vertex: usize,
-    num_vertices: usize,
 }
 
 impl ReductionResult for ReductionHPBTVToLP {
@@ -33,55 +29,75 @@ impl ReductionResult for ReductionHPBTVToLP {
     ///
     /// The target solution is a binary vector over edges. We walk the selected
     /// edges from the source vertex to reconstruct the vertex ordering.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_vertices;
-
-        // Build adjacency from selected edges
-        let mut adj: Vec<Vec<usize>> = vec![Vec::new(); n];
-        for (idx, &selected) in target_solution.iter().enumerate() {
-            if selected == 1 {
-                let (u, v) = self.edges[idx];
-                adj[u].push(v);
-                adj[v].push(u);
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target path does not certify a Hamiltonian source-target path",
+            ));
+        }
+
+        let mut adjacency = vec![Vec::new(); self.target.num_vertices()];
+        for (&selected, (u, v)) in target_solution.iter().zip(self.target.graph().edges()) {
+            if selected {
+                adjacency[u].push(v);
+                adjacency[v].push(u);
             }
         }
 
-        // Walk the path from source
-        let mut path = Vec::with_capacity(n);
-        let mut current = self.source_vertex;
-        let mut prev = usize::MAX; // sentinel for "no previous"
+        // Target feasibility guarantees a single simple path with these endpoints.
+        // Its certified n-1 edges visit every vertex; walking away from the
+        // previous vertex terminates at the target without repetitions.
+        let mut current = self.target.source_vertex();
+        let mut previous = None;
+        let mut path = Vec::with_capacity(self.target.num_vertices());
         path.push(current);
-
-        while path.len() < n {
-            let next = adj[current]
-                .iter()
-                .find(|&&neighbor| neighbor != prev)
-                .copied();
-            match next {
-                Some(next_vertex) => {
-                    prev = current;
-                    current = next_vertex;
-                    path.push(current);
-                }
-                None => break,
-            }
+        while let Some(&next) = adjacency[current]
+            .iter()
+            .find(|&&neighbor| Some(neighbor) != previous)
+        {
+            previous = Some(current);
+            current = next;
+            path.push(current);
         }
+        Ok(path)
+    }
+}
+
+impl crate::rules::AggregateReductionResult for ReductionHPBTVToLP {
+    type Source = HamiltonianPathBetweenTwoVertices<SimpleGraph>;
+    type Target = LongestPath<SimpleGraph, One>;
 
-        path
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, value: crate::types::Max<i64>) -> crate::types::Or {
+        // The source requires distinct valid endpoints, hence at least two vertices.
+        crate::types::Or(
+            value.0.is_some_and(|length| {
+                usize::try_from(length) == Ok(self.target.num_vertices() - 1)
+            }),
+        )
     }
 }
 
-#[reduction(overhead = {
-    num_vertices = "num_vertices",
-    num_edges = "num_edges",
-})]
+#[reduction(
+    aggregate = custom,
+    transform = exact {
+        num_vertices = "num_vertices",
+        num_edges = "num_edges",
+    })]
 impl ReduceTo<LongestPath<SimpleGraph, One>> for HamiltonianPathBetweenTwoVertices<SimpleGraph> {
     type Result = ReductionHPBTVToLP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let graph = self.graph().clone();
         let num_edges = graph.num_edges();
-        let edges = graph.edges();
         let edge_lengths = vec![One; num_edges];
 
         let target = LongestPath::new(
@@ -91,12 +107,7 @@ impl ReduceTo<LongestPath<SimpleGraph, One>> for HamiltonianPathBetweenTwoVertic
             self.target_vertex(),
         );
 
-        ReductionHPBTVToLP {
-            target,
-            edges,
-            source_vertex: self.source_vertex(),
-            num_vertices: self.num_vertices(),
-        }
+        Ok(ReductionHPBTVToLP { target })
     }
 }
 
@@ -116,8 +127,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, LongestPath<SimpleGraph, One>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 2, 3, 4],
-                    target_config: vec![1, 1, 1, 1],
+                    source_config: serde_json::json!(vec![0, 1, 2, 3, 4]),
+                    target_config: serde_json::json!(vec![true, true, true, true]),
                 },
             )
         },
diff --git a/src/rules/highlyconnecteddeletion_ilp.rs b/src/rules/highlyconnecteddeletion_ilp.rs
index 74493280f..1fb2c0b47 100644
--- a/src/rules/highlyconnecteddeletion_ilp.rs
+++ b/src/rules/highlyconnecteddeletion_ilp.rs
@@ -60,36 +60,41 @@ impl ReductionResult for ReductionHighlyConnectedDeletionToILP {
     /// For every source edge `(u, v)`, the edge is *kept* iff some chosen
     /// cluster `S` (i.e. with `x_S = 1`) contains both `u` and `v`; otherwise
     /// it is deleted (`config[e] = 1`).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Map every vertex to the (unique, for a feasible ILP solution) chosen
-        // cluster id. For partial/infeasible target assignments we fall back to
-        // `None`, which forces the corresponding source edges to be marked
-        // deleted -- preserving feasibility of `is_valid_solution` is the
-        // caller's responsibility, not ours.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         let mut cluster_of: Vec<Option<usize>> = vec![None; vertex_count(&self.clusters)];
         for (c, cluster) in self.clusters.iter().enumerate() {
-            if target_solution.get(c).copied().unwrap_or(0) == 1 {
+            if target_solution[c] == 1 {
                 for &v in cluster {
+                    if cluster_of[v].is_some() {
+                        return Err(crate::rules::ExtractionError::invalid(format!(
+                            "vertex {v} belongs to multiple selected clusters"
+                        )));
+                    }
                     cluster_of[v] = Some(c);
                 }
+            } else if target_solution[c] != 0 {
+                return Err(crate::rules::ExtractionError::invalid(format!(
+                    "cluster selection {c} is not binary"
+                )));
             }
         }
 
-        self.edges
+        if let Some(vertex) = cluster_of.iter().position(Option::is_none) {
+            return Err(crate::rules::ExtractionError::invalid(format!(
+                "vertex {vertex} has no selected cluster"
+            )));
+        }
+
+        Ok(self
+            .edges
             .iter()
-            .map(|&(u, v)| {
-                debug_assert!(
-                    cluster_of[u].is_some() && cluster_of[v].is_some(),
-                    "extract_solution invariant violated: edge ({}, {}) has endpoint(s) with no cluster assignment; a well-formed ILP witness assigns every vertex to exactly one selected cluster",
-                    u,
-                    v
-                );
-                match (cluster_of[u], cluster_of[v]) {
-                    (Some(cu), Some(cv)) if cu == cv => 0,
-                    _ => 1,
-                }
-            })
-            .collect()
+            .map(|&(u, v)| cluster_of[u] != cluster_of[v])
+            .collect())
     }
 }
 
@@ -146,15 +151,18 @@ fn enumerate_feasible_clusters(graph: &SimpleGraph) -> Vec<Vec<usize>> {
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "2^num_vertices",
+    transform = exact {
         num_constraints = "num_vertices",
-    }
+    },
+    unavailable = {
+        num_vars = "the feasible-cluster count depends on graph structure, and its 2^num_vertices upper bound requires a variable exponent unsupported by the size-transform evaluator",
+            num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+}
 )]
 impl ReduceTo<ILP<bool>> for HighlyConnectedDeletion<SimpleGraph> {
     type Result = ReductionHighlyConnectedDeletionToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let graph = self.graph();
         let n = graph.num_vertices();
         let clusters = enumerate_feasible_clusters(graph);
@@ -166,34 +174,44 @@ impl ReduceTo<ILP<bool>> for HighlyConnectedDeletion<SimpleGraph> {
         // small graphs we use in tests.
         let mut constraints: Vec<LinearConstraint> = Vec::with_capacity(n);
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = clusters
+            let terms: Vec<(usize, i64)> = clusters
                 .iter()
                 .enumerate()
                 .filter_map(|(c, cluster)| {
                     if cluster.binary_search(&v).is_ok() {
-                        Some((c, 1.0))
+                        Some((c, 1))
                     } else {
                         None
                     }
                 })
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Objective: maximize sum_S |E(G[S])| * x_S.
-        let objective: Vec<(usize, f64)> = clusters
+        let objective: Vec<(usize, i64)> = clusters
             .iter()
             .enumerate()
-            .map(|(c, cluster)| (c, induced_edge_count(graph, cluster) as f64))
-            .collect();
+            .map(|(c, cluster)| {
+                i64::try_from(induced_edge_count(graph, cluster))
+                    .map(|count| (c, count))
+                    .map_err(|_| {
+                        crate::rules::ReductionError::integer_overflow::<
+                            HighlyConnectedDeletion<SimpleGraph>,
+                            ILP<bool>,
+                        >("encoding an induced edge count")
+                    })
+            })
+            .collect::<Result<_, _>>()?;
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(Self::target_construction)?;
 
-        ReductionHighlyConnectedDeletionToILP {
+        Ok(ReductionHighlyConnectedDeletionToILP {
             target,
             clusters,
             edges: graph.edges(),
-        }
+        })
     }
 }
 
diff --git a/src/rules/ilp_bool_ilp_i32.rs b/src/rules/ilp_bool_ilp_i32.rs
deleted file mode 100644
index 5e36032a8..000000000
--- a/src/rules/ilp_bool_ilp_i32.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-//! Natural embedding of binary ILP into general integer ILP.
-//!
-//! Every binary (0-1) variable is a valid non-negative integer variable.
-//! The constraints carry over unchanged. Additional upper-bound constraints
-//! (x_i <= 1) are added to preserve binary semantics.
-//!
-//! This is a same-name variant cast (ILP → ILP), so by convention it does not
-//! have an example file or a paper `reduction-rule` entry.
-
-use crate::models::algebraic::{LinearConstraint, ILP};
-use crate::reduction;
-use crate::rules::traits::{ReduceTo, ReductionResult};
-
-#[derive(Debug, Clone)]
-pub struct ReductionBinaryILPToIntILP {
-    target: ILP<i32>,
-}
-
-impl ReductionResult for ReductionBinaryILPToIntILP {
-    type Source = ILP<bool>;
-    type Target = ILP<i32>;
-
-    fn target_problem(&self) -> &ILP<i32> {
-        &self.target
-    }
-
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
-    }
-}
-
-#[reduction(overhead = {
-    num_vars = "num_vars",
-    num_constraints = "num_constraints + num_vars",
-})]
-impl ReduceTo<ILP<i32>> for ILP<bool> {
-    type Result = ReductionBinaryILPToIntILP;
-
-    fn reduce_to(&self) -> Self::Result {
-        let mut constraints = self.constraints.clone();
-        // Add x_i <= 1 for each variable to preserve binary domain
-        for i in 0..self.num_vars {
-            constraints.push(LinearConstraint::le(vec![(i, 1.0)], 1.0));
-        }
-        ReductionBinaryILPToIntILP {
-            target: ILP::<i32>::new(
-                self.num_vars,
-                constraints,
-                self.objective.clone(),
-                self.sense,
-            ),
-        }
-    }
-}
-
-#[cfg(test)]
-#[path = "../unit_tests/rules/ilp_bool_ilp_i32.rs"]
-mod tests;
diff --git a/src/rules/ilp_bool_ilp_i64.rs b/src/rules/ilp_bool_ilp_i64.rs
new file mode 100644
index 000000000..c5bb1df86
--- /dev/null
+++ b/src/rules/ilp_bool_ilp_i64.rs
@@ -0,0 +1,58 @@
+//! Natural embedding of binary ILP into general integer ILP.
+//!
+//! The stored `[0, 1]` bounds, constraints, and objective carry over unchanged.
+//!
+//! This same-name variant reduction preserves the witness representation.
+
+use crate::models::algebraic::ILP;
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+
+#[derive(Debug, Clone)]
+pub struct ReductionBinaryILPToIntILP {
+    target: ILP<i64>,
+}
+
+impl ReductionResult for ReductionBinaryILPToIntILP {
+    type Source = ILP<bool>;
+    type Target = ILP<i64>;
+
+    fn target_problem(&self) -> &ILP<i64> {
+        &self.target
+    }
+
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
+    }
+}
+
+#[reduction(
+    transform = exact {
+        num_vars = "num_vars",
+        num_constraints = "num_constraints",
+        num_nonzeros = "num_nonzeros",
+    },)]
+impl ReduceTo<ILP<i64>> for ILP<bool> {
+    type Result = ReductionBinaryILPToIntILP;
+
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(ReductionBinaryILPToIntILP {
+            target: ILP::<i64>::with_variables(
+                self.variables().to_vec(),
+                self.constraints().to_vec(),
+                self.objective().to_vec(),
+                self.sense(),
+            )
+            .map_err(<Self as ReduceTo<ILP<i64>>>::target_construction)?,
+        })
+    }
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/ilp_bool_ilp_i64.rs"]
+mod tests;
diff --git a/src/rules/ilp_casts.rs b/src/rules/ilp_casts.rs
new file mode 100644
index 000000000..586fe6605
--- /dev/null
+++ b/src/rules/ilp_casts.rs
@@ -0,0 +1,110 @@
+//! Numeric variant reductions for ILP.
+
+use crate::models::algebraic::{Comparison, LinearConstraint, VariableDomain, ILP};
+use crate::reduction;
+use crate::rules::{ReduceTo, ReductionError, ReductionResult};
+use crate::types::i64_to_exact_f64;
+
+#[derive(Debug, Clone)]
+pub struct ReductionILPToFloat<V: VariableDomain> {
+    source: ILP<V>,
+    target: ILP<V, f64>,
+}
+
+impl<V: VariableDomain> ReductionILPToFloat<V> {
+    fn new(source: &ILP<V>) -> Result<Self, ReductionError> {
+        let convert = |coefficient: i64| {
+            i64_to_exact_f64(coefficient)
+                .map_err(ReductionError::inexact_float_conversion::<ILP<V>, ILP<V, f64>>)
+        };
+        let constraints = source
+            .constraints()
+            .iter()
+            .map(|constraint| {
+                let terms = constraint
+                    .terms()
+                    .iter()
+                    .map(|&(variable, coefficient)| Ok((variable, convert(coefficient)?)))
+                    .collect::<Result<Vec<_>, ReductionError>>()?;
+                let rhs = convert(constraint.rhs())?;
+                Ok(match constraint.comparison() {
+                    Comparison::Le => LinearConstraint::le(terms, rhs),
+                    Comparison::Ge => LinearConstraint::ge(terms, rhs),
+                    Comparison::Eq => LinearConstraint::eq(terms, rhs),
+                })
+            })
+            .collect::<Result<Vec<_>, ReductionError>>()?;
+        let objective = source
+            .objective()
+            .iter()
+            .map(|&(variable, coefficient)| Ok((variable, convert(coefficient)?)))
+            .collect::<Result<Vec<_>, ReductionError>>()?;
+        let target = ILP::with_variables(
+            source.variables().to_vec(),
+            constraints,
+            objective,
+            source.sense(),
+        )
+        .map_err(ReductionError::construction::<ILP<V>, ILP<V, f64>>)?;
+        Ok(Self {
+            source: source.clone(),
+            target,
+        })
+    }
+}
+
+impl<V: VariableDomain> ReductionResult for ReductionILPToFloat<V> {
+    type Source = ILP<V>;
+    type Target = ILP<V, f64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !self.source.is_feasible(target_solution)? {
+            return Err(crate::rules::ExtractionError::invalid(
+                "the floating-point assignment violates the source integer ILP",
+            ));
+        }
+        Ok(target_solution.clone())
+    }
+}
+
+#[reduction(
+    transform = exact {
+        num_vars = "num_vars",
+        num_constraints = "num_constraints",
+        num_nonzeros = "num_nonzeros",
+    },
+)]
+impl ReduceTo<ILP<bool, f64>> for ILP<bool> {
+    type Result = ReductionILPToFloat<bool>;
+
+    fn reduce_to(&self) -> Result<Self::Result, ReductionError> {
+        ReductionILPToFloat::new(self)
+    }
+}
+
+#[reduction(
+    transform = exact {
+        num_vars = "num_vars",
+        num_constraints = "num_constraints",
+        num_nonzeros = "num_nonzeros",
+    },
+)]
+impl ReduceTo<ILP<i64, f64>> for ILP<i64> {
+    type Result = ReductionILPToFloat<i64>;
+
+    fn reduce_to(&self) -> Result<Self::Result, ReductionError> {
+        ReductionILPToFloat::new(self)
+    }
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/ilp_casts.rs"]
+mod tests;
diff --git a/src/rules/ilp_helpers.rs b/src/rules/ilp_helpers.rs
index db5294571..4f982bdc5 100644
--- a/src/rules/ilp_helpers.rs
+++ b/src/rules/ilp_helpers.rs
@@ -1,197 +1,143 @@
-//! Shared ILP linearization helpers for Tier 3 reductions.
-//!
-//! These functions generate `LinearConstraint` sets for common ILP patterns:
-//! McCormick products, MTZ orderings, flow conservation, big-M activation,
-//! absolute-value differentials, minimax bounds, and one-hot decoding.
+//! Shared exact-integer helpers for ILP reductions.
 
-#![allow(dead_code)]
 use crate::models::algebraic::LinearConstraint;
 
-/// McCormick linearization: `y = x_a * x_b` (both binary).
-///
-/// Returns 3 constraints: `y ≤ x_a`, `y ≤ x_b`, `y ≥ x_a + x_b - 1`.
-pub fn mccormick_product(y_idx: usize, x_a: usize, x_b: usize) -> Vec<LinearConstraint> {
-    vec![
-        // y <= x_a
-        LinearConstraint::le(vec![(y_idx, 1.0), (x_a, -1.0)], 0.0),
-        // y <= x_b
-        LinearConstraint::le(vec![(y_idx, 1.0), (x_b, -1.0)], 0.0),
-        // y >= x_a + x_b - 1  =>  x_a + x_b - y <= 1
-        LinearConstraint::le(vec![(x_a, 1.0), (x_b, 1.0), (y_idx, -1.0)], 1.0),
-    ]
+/// Convert exact ILP integer values into a source model's `usize` representation.
+pub fn decode_usize_values(values: &[i64]) -> crate::rules::ExtractionResult<Vec<usize>> {
+    values
+        .iter()
+        .enumerate()
+        .map(|(index, &value)| {
+            usize::try_from(value).map_err(|_| {
+                crate::rules::ExtractionError::invalid(format!(
+                    "ILP value {value} at index {index} cannot be represented as usize"
+                ))
+            })
+        })
+        .collect()
 }
 
-/// MTZ topological ordering for directed arcs.
-///
-/// For each arc `(u → v)`: `o_v - o_u ≥ 1 - M*(1 - x_u) - M*(1 - x_v)`
-/// when both endpoints are kept (x=0 means kept, x=1 means removed).
-/// Also emits bound constraints: `0 ≤ o_i ≤ n-1`.
-///
-/// `x_offset`: start index for removal indicator variables.
-/// `o_offset`: start index for ordering variables.
-pub fn mtz_ordering(
-    arcs: &[(usize, usize)],
-    n: usize,
-    x_offset: usize,
-    o_offset: usize,
-) -> Vec<LinearConstraint> {
-    let big_m = n as f64;
-    let mut constraints = Vec::new();
-
-    for &(u, v) in arcs {
-        // o_v - o_u + M*x_u + M*x_v >= 1
-        constraints.push(LinearConstraint::ge(
+/// McCormick linearization: `y = x_a * x_b` for binary variables.
+pub fn mccormick_product<C: From<i8>>(
+    y_idx: usize,
+    x_a: usize,
+    x_b: usize,
+) -> [LinearConstraint<C>; 3] {
+    [
+        LinearConstraint::le(
+            vec![(y_idx, 1_i8.into()), (x_a, (-1_i8).into())],
+            0_i8.into(),
+        ),
+        LinearConstraint::le(
+            vec![(y_idx, 1_i8.into()), (x_b, (-1_i8).into())],
+            0_i8.into(),
+        ),
+        LinearConstraint::le(
             vec![
-                (o_offset + v, 1.0),
-                (o_offset + u, -1.0),
-                (x_offset + u, big_m),
-                (x_offset + v, big_m),
+                (x_a, 1_i8.into()),
+                (x_b, 1_i8.into()),
+                (y_idx, (-1_i8).into()),
             ],
-            1.0,
-        ));
-    }
-
-    // Bound constraints: 0 <= o_i <= n-1
-    for i in 0..n {
-        constraints.push(LinearConstraint::le(
-            vec![(o_offset + i, 1.0)],
-            (n - 1) as f64,
-        ));
-        constraints.push(LinearConstraint::ge(vec![(o_offset + i, 1.0)], 0.0));
-    }
-
-    constraints
+            1_i8.into(),
+        ),
+    ]
 }
 
-/// Flow conservation at each node.
-///
-/// For each node `u`: `Σ_{(u,v)} f_{uv} - Σ_{(v,u)} f_{vu} = demand[u]`.
-///
-/// `flow_idx` maps an arc index to the ILP variable index for that arc's flow.
-pub fn flow_conservation(
-    arcs: &[(usize, usize)],
-    num_nodes: usize,
-    flow_idx: &dyn Fn(usize) -> usize,
-    demand: &[f64],
-) -> Vec<LinearConstraint> {
-    let mut constraints = Vec::with_capacity(num_nodes);
-    for (node, &rhs) in demand.iter().enumerate().take(num_nodes) {
-        let mut terms = Vec::new();
-        for (arc_idx, &(u, v)) in arcs.iter().enumerate() {
-            if u == node {
-                terms.push((flow_idx(arc_idx), 1.0)); // outgoing
-            }
-            if v == node {
-                terms.push((flow_idx(arc_idx), -1.0)); // incoming
+/// Decode one selected item from each slot of a column-major one-hot matrix.
+pub fn one_hot_decode(
+    solution: &[i64],
+    num_items: usize,
+    num_slots: usize,
+    var_offset: usize,
+) -> crate::rules::ExtractionResult<Vec<usize>> {
+    let assignment: Vec<usize> = (0..num_slots)
+        .map(|slot| {
+            let mut selected =
+                (0..num_items).filter(|&item| solution[var_offset + item * num_slots + slot] == 1);
+            let item = selected.next().ok_or_else(|| {
+                crate::rules::ExtractionError::invalid(format!(
+                    "assignment slot {slot} has no selected item"
+                ))
+            })?;
+            if selected.next().is_some() {
+                return Err(crate::rules::ExtractionError::invalid(format!(
+                    "assignment slot {slot} has multiple selected items"
+                )));
             }
+            Ok(item)
+        })
+        .collect::<crate::rules::ExtractionResult<_>>()?;
+
+    let mut assigned = vec![false; num_items];
+    for &item in &assignment {
+        if std::mem::replace(&mut assigned[item], true) {
+            return Err(crate::rules::ExtractionError::invalid(format!(
+                "item {item} is selected for multiple assignment slots"
+            )));
         }
-        constraints.push(LinearConstraint::eq(terms, rhs));
     }
-    constraints
-}
-
-/// Big-M activation: `f ≤ M * y`. Single constraint.
-pub fn big_m_activation(f_idx: usize, y_idx: usize, big_m: f64) -> LinearConstraint {
-    // f - M*y <= 0
-    LinearConstraint::le(vec![(f_idx, 1.0), (y_idx, -big_m)], 0.0)
+    Ok(assignment)
 }
 
-/// Absolute value linearization: `|a - b| ≤ z`.
-///
-/// Returns 2 constraints: `a - b ≤ z`, `b - a ≤ z`.
-pub fn abs_diff_le(a_idx: usize, b_idx: usize, z_idx: usize) -> Vec<LinearConstraint> {
-    vec![
-        // a - b - z <= 0
-        LinearConstraint::le(vec![(a_idx, 1.0), (b_idx, -1.0), (z_idx, -1.0)], 0.0),
-        // b - a - z <= 0
-        LinearConstraint::le(vec![(b_idx, 1.0), (a_idx, -1.0), (z_idx, -1.0)], 0.0),
-    ]
-}
-
-/// Minimax: `z ≥ expr_i` for each expression.
-///
-/// Each `expr` is a list of `(var_idx, coeff)` terms representing a linear expression.
-pub fn minimax_constraints(
-    z_idx: usize,
-    expr_terms: &[Vec<(usize, f64)>],
-) -> Vec<LinearConstraint> {
-    expr_terms
-        .iter()
-        .map(|terms| {
-            // z >= Σ coeff_j * x_j  =>  z - Σ coeff_j * x_j >= 0
-            let mut constraint_terms = vec![(z_idx, 1.0)];
-            for &(var, coeff) in terms {
-                constraint_terms.push((var, -coeff));
+/// Decode one selected column from each row of a row-major one-hot matrix.
+pub fn one_hot_decode_rows(
+    solution: &[i64],
+    num_rows: usize,
+    num_columns: usize,
+    var_offset: usize,
+) -> crate::rules::ExtractionResult<Vec<usize>> {
+    (0..num_rows)
+        .map(|row| {
+            let mut selected = (0..num_columns)
+                .filter(|&column| solution[var_offset + row * num_columns + column] == 1);
+            match (selected.next(), selected.next()) {
+                (Some(column), None) => Ok(column),
+                (None, _) => Err(crate::rules::ExtractionError::invalid(format!(
+                    "assignment row {row} has no selected column"
+                ))),
+                (Some(_), Some(_)) => Err(crate::rules::ExtractionError::invalid(format!(
+                    "assignment row {row} has multiple selected columns"
+                ))),
             }
-            LinearConstraint::ge(constraint_terms, 0.0)
         })
         .collect()
 }
 
-/// One-hot to index extraction.
-///
-/// Given `num_items * num_slots` binary assignment variables starting at `var_offset`,
-/// decode each slot `p` → value `v` where `x_{v*num_slots + p} = 1`.
-///
-/// Layout: variable at index `var_offset + v * num_slots + p` represents
-/// "item v is assigned to slot p".
-pub fn one_hot_decode(
-    solution: &[usize],
-    num_items: usize,
-    num_slots: usize,
-    var_offset: usize,
-) -> Vec<usize> {
-    (0..num_slots)
-        .map(|p| {
-            (0..num_items)
-                .find(|&v| solution[var_offset + v * num_slots + p] == 1)
-                .unwrap_or(0)
+/// Convert a permutation to Lehmer code.
+#[cfg(test)]
+pub fn permutation_to_lehmer(permutation: &[usize]) -> Vec<usize> {
+    (0..permutation.len())
+        .map(|index| {
+            (index + 1..permutation.len())
+                .filter(|&right| permutation[right] < permutation[index])
+                .count()
         })
         .collect()
 }
 
-/// Convert a permutation to Lehmer code.
-///
-/// Given a permutation of `[0..n)`, returns the Lehmer code representation
-/// where each element counts the number of smaller elements to its right.
-pub fn permutation_to_lehmer(perm: &[usize]) -> Vec<usize> {
-    let n = perm.len();
-    let mut lehmer = Vec::with_capacity(n);
-    for i in 0..n {
-        let count = (i + 1..n).filter(|&j| perm[j] < perm[i]).count();
-        lehmer.push(count);
-    }
-    lehmer
-}
-
-/// One-hot assignment constraints: each item assigned to exactly one slot,
-/// each slot assigned at most one item.
-///
-/// Returns constraints for a `num_items × num_slots` assignment matrix
-/// starting at `var_offset`.
+/// Constrain each item to exactly one slot and each slot to at most one item.
 pub fn one_hot_assignment_constraints(
     num_items: usize,
     num_slots: usize,
     var_offset: usize,
 ) -> Vec<LinearConstraint> {
-    let mut constraints = Vec::new();
-
-    // Each item assigned to exactly one slot
-    for v in 0..num_items {
-        let terms: Vec<(usize, f64)> = (0..num_slots)
-            .map(|p| (var_offset + v * num_slots + p, 1.0))
-            .collect();
-        constraints.push(LinearConstraint::eq(terms, 1.0));
+    let mut constraints = Vec::with_capacity(num_items + num_slots);
+    for item in 0..num_items {
+        constraints.push(LinearConstraint::eq(
+            (0..num_slots)
+                .map(|slot| (var_offset + item * num_slots + slot, 1))
+                .collect(),
+            1,
+        ));
     }
-
-    // Each slot assigned at most one item
-    for p in 0..num_slots {
-        let terms: Vec<(usize, f64)> = (0..num_items)
-            .map(|v| (var_offset + v * num_slots + p, 1.0))
-            .collect();
-        constraints.push(LinearConstraint::le(terms, 1.0));
+    for slot in 0..num_slots {
+        constraints.push(LinearConstraint::le(
+            (0..num_items)
+                .map(|item| (var_offset + item * num_slots + slot, 1))
+                .collect(),
+            1,
+        ));
     }
-
     constraints
 }
 
diff --git a/src/rules/ilp_i32_ilp_bool.rs b/src/rules/ilp_i32_ilp_bool.rs
deleted file mode 100644
index 6577cb5e5..000000000
--- a/src/rules/ilp_i32_ilp_bool.rs
+++ /dev/null
@@ -1,356 +0,0 @@
-//! Reduction from ILP<i32> to ILP<bool> via truncated binary encoding with FBBT.
-//!
-//! Uses Feasibility-Based Bound Tightening (Savelsbergh 1994, Achterberg et al. 2020)
-//! to infer per-variable upper bounds, then encodes each integer variable into
-//! ceil(log2(U+1)) binary variables using truncated binary encoding (Karimi & Rosenberg 2017).
-
-use crate::models::algebraic::{Comparison, LinearConstraint, ILP};
-use crate::reduction;
-use crate::rules::traits::{ReduceTo, ReductionResult};
-
-/// Error type for FBBT failures.
-#[derive(Debug, Clone, PartialEq)]
-pub enum FbbtError {
-    /// At least one variable has an unbounded upper bound after FBBT.
-    Unbounded,
-    /// The constraint system is provably infeasible.
-    Infeasible,
-}
-
-/// Per-variable encoding info: start index in binary variables, weights.
-#[derive(Debug, Clone)]
-struct VarEncoding {
-    /// Index of the first binary variable for this integer variable.
-    start: usize,
-    /// Weights for each binary variable: [1, 2, 4, ..., remainder].
-    weights: Vec<i64>,
-}
-
-/// Infer upper bounds for non-negative integer variables via FBBT.
-///
-/// Returns `Ok(bounds)` with finite upper bounds, or an error if the system
-/// is infeasible or unbounded.
-fn fbbt(num_vars: usize, constraints: &[LinearConstraint]) -> Result<Vec<i64>, FbbtError> {
-    const INF: i64 = i64::MAX / 2; // sentinel for +infinity (safe for addition)
-
-    let mut lower = vec![0i64; num_vars];
-    let mut upper = vec![INF; num_vars];
-
-    let max_iters = num_vars + 1;
-
-    for _ in 0..max_iters {
-        let mut changed = false;
-
-        for c in constraints {
-            // Compute activity bounds: act_min = sum of min contributions, act_max = sum of max contributions
-            let mut act_min: i64 = 0;
-            let mut act_max: i64 = 0;
-            let mut act_min_finite = true;
-            let mut act_max_finite = true;
-
-            for &(var, coef) in &c.terms {
-                let coef_i = coef as i64; // coefficients are integer-valued in practice
-                if coef_i > 0 {
-                    act_min = act_min.saturating_add(coef_i.saturating_mul(lower[var]));
-                    if upper[var] >= INF {
-                        act_max_finite = false;
-                    } else {
-                        act_max = act_max.saturating_add(coef_i.saturating_mul(upper[var]));
-                    }
-                } else if coef_i < 0 {
-                    if upper[var] >= INF {
-                        act_min_finite = false;
-                    } else {
-                        act_min = act_min.saturating_add(coef_i.saturating_mul(upper[var]));
-                    }
-                    act_max = act_max.saturating_add(coef_i.saturating_mul(lower[var]));
-                }
-            }
-
-            let rhs = c.rhs as i64;
-
-            // Infeasibility checks
-            if matches!(c.cmp, Comparison::Le | Comparison::Eq) && act_min_finite && act_min > rhs {
-                return Err(FbbtError::Infeasible);
-            }
-            if matches!(c.cmp, Comparison::Ge | Comparison::Eq) && act_max_finite && act_max < rhs {
-                return Err(FbbtError::Infeasible);
-            }
-
-            // Tighten each variable
-            for &(var, coef) in &c.terms {
-                let coef_i = coef as i64;
-                if coef_i == 0 {
-                    continue;
-                }
-
-                // From Le or Eq: upper bound tightening for positive coef, lower bound for negative
-                if matches!(c.cmp, Comparison::Le | Comparison::Eq) {
-                    // Compute residual min = act_min - this variable's min contribution
-                    let my_min = if coef_i > 0 {
-                        coef_i.saturating_mul(lower[var])
-                    } else {
-                        if upper[var] >= INF {
-                            continue; // can't compute residual
-                        }
-                        coef_i.saturating_mul(upper[var])
-                    };
-                    if !(act_min_finite || coef_i < 0 && upper[var] >= INF) {
-                        // act_min is -inf, residual is -inf, no useful bound
-                        continue;
-                    }
-                    let res_min = if act_min_finite {
-                        act_min - my_min
-                    } else {
-                        // act_min was -inf because of this var's contribution
-                        // but my_min was the infinite part, so residual is finite
-                        // This case shouldn't produce useful bounds
-                        continue;
-                    };
-
-                    if coef_i > 0 {
-                        // a_i * x_i <= rhs - res_min => x_i <= floor((rhs - res_min) / a_i)
-                        let new_u = floor_div(rhs - res_min, coef_i);
-                        if new_u < upper[var] {
-                            upper[var] = new_u;
-                            changed = true;
-                        }
-                    } else {
-                        // a_i * x_i <= rhs - res_min, a_i < 0 => x_i >= ceil((rhs - res_min) / a_i)
-                        let new_l = ceil_div(rhs - res_min, coef_i);
-                        if new_l > lower[var] {
-                            lower[var] = new_l;
-                            changed = true;
-                        }
-                    }
-                }
-
-                // From Ge or Eq: lower bound tightening for positive coef, upper for negative
-                if matches!(c.cmp, Comparison::Ge | Comparison::Eq) {
-                    let my_max = if coef_i > 0 {
-                        if upper[var] >= INF {
-                            continue;
-                        }
-                        coef_i.saturating_mul(upper[var])
-                    } else {
-                        coef_i.saturating_mul(lower[var])
-                    };
-                    if !(act_max_finite || coef_i > 0 && upper[var] >= INF) {
-                        continue;
-                    }
-                    let res_max = if act_max_finite {
-                        act_max - my_max
-                    } else {
-                        continue;
-                    };
-
-                    if coef_i > 0 {
-                        // a_i * x_i >= rhs - res_max => x_i >= ceil((rhs - res_max) / a_i)
-                        let new_l = ceil_div(rhs - res_max, coef_i);
-                        if new_l > lower[var] {
-                            lower[var] = new_l;
-                            changed = true;
-                        }
-                    } else {
-                        // a_i * x_i >= rhs - res_max, a_i < 0 => x_i <= floor((rhs - res_max) / a_i)
-                        let new_u = floor_div(rhs - res_max, coef_i);
-                        if new_u < upper[var] {
-                            upper[var] = new_u;
-                            changed = true;
-                        }
-                    }
-                }
-
-                if lower[var] > upper[var] {
-                    return Err(FbbtError::Infeasible);
-                }
-            }
-        }
-
-        if !changed {
-            break;
-        }
-    }
-
-    // Check for unbounded variables
-    for &u in &upper {
-        if u >= INF {
-            return Err(FbbtError::Unbounded);
-        }
-    }
-
-    Ok(upper)
-}
-
-/// Floor division that rounds toward negative infinity.
-fn floor_div(a: i64, b: i64) -> i64 {
-    let d = a / b;
-    let r = a % b;
-    if (r != 0) && ((r ^ b) < 0) {
-        d - 1
-    } else {
-        d
-    }
-}
-
-/// Ceiling division that rounds toward positive infinity.
-fn ceil_div(a: i64, b: i64) -> i64 {
-    let d = a / b;
-    let r = a % b;
-    if (r != 0) && ((r ^ b) >= 0) {
-        d + 1
-    } else {
-        d
-    }
-}
-
-/// Compute the truncated binary encoding weights for a variable with upper bound U.
-///
-/// Returns weights [1, 2, 4, ..., remainder] such that sum of weights = U.
-fn binary_weights(upper_bound: i64) -> Vec<i64> {
-    if upper_bound == 0 {
-        return vec![]; // fixed at 0, no binary variables needed
-    }
-    let k = num_bits(upper_bound);
-    let mut weights = Vec::with_capacity(k);
-    for j in 0..(k - 1) {
-        weights.push(1i64 << j);
-    }
-    // Last weight: U - (2^{K-1} - 1)
-    let last = upper_bound - ((1i64 << (k - 1)) - 1);
-    weights.push(last);
-    weights
-}
-
-/// Number of binary variables needed: ceil(log2(U + 1)).
-fn num_bits(upper_bound: i64) -> usize {
-    if upper_bound <= 0 {
-        return 0;
-    }
-    // ceil(log2(U + 1)) = floor(log2(U)) + 1 = 64 - leading_zeros(U)
-    64 - (upper_bound as u64).leading_zeros() as usize
-}
-
-/// Reduction result for ILP<i32> -> ILP<bool>.
-#[derive(Debug, Clone)]
-pub struct ReductionIntILPToBinaryILP {
-    target: ILP<bool>,
-    /// Per-source-variable encoding info.
-    encodings: Vec<VarEncoding>,
-}
-
-impl ReductionResult for ReductionIntILPToBinaryILP {
-    type Source = ILP<i32>;
-    type Target = ILP<bool>;
-
-    fn target_problem(&self) -> &ILP<bool> {
-        &self.target
-    }
-
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.encodings
-            .iter()
-            .map(|enc| {
-                let val: i64 = enc
-                    .weights
-                    .iter()
-                    .enumerate()
-                    .map(|(j, &w)| w * target_solution[enc.start + j] as i64)
-                    .sum();
-                val as usize
-            })
-            .collect()
-    }
-}
-
-#[reduction(overhead = {
-    num_vars = "31 * num_variables",
-    num_constraints = "num_constraints",
-})]
-impl ReduceTo<ILP<bool>> for ILP<i32> {
-    type Result = ReductionIntILPToBinaryILP;
-
-    fn reduce_to(&self) -> Self::Result {
-        if self.num_vars == 0 {
-            return ReductionIntILPToBinaryILP {
-                target: ILP::<bool>::new(0, vec![], vec![], self.sense),
-                encodings: vec![],
-            };
-        }
-
-        // Step 1: FBBT to infer upper bounds
-        let upper_bounds = match fbbt(self.num_vars, &self.constraints) {
-            Ok(bounds) => bounds,
-            Err(FbbtError::Infeasible) => {
-                // Return an infeasible ILP<bool>: 1 variable, constraint y0 >= 1 AND y0 <= 0
-                return ReductionIntILPToBinaryILP {
-                    target: ILP::<bool>::new(
-                        1,
-                        vec![
-                            LinearConstraint::ge(vec![(0, 1.0)], 1.0),
-                            LinearConstraint::le(vec![(0, 1.0)], 0.0),
-                        ],
-                        vec![],
-                        self.sense,
-                    ),
-                    encodings: (0..self.num_vars)
-                        .map(|_| VarEncoding {
-                            start: 0,
-                            weights: vec![],
-                        })
-                        .collect(),
-                };
-            }
-            Err(FbbtError::Unbounded) => {
-                // Fallback: use 31 bits per variable (full i32 range)
-                vec![(1i64 << 31) - 1; self.num_vars]
-            }
-        };
-
-        // Step 2: Build encodings
-        let mut encodings = Vec::with_capacity(self.num_vars);
-        let mut total_bool_vars = 0;
-        for &u in &upper_bounds {
-            let weights = binary_weights(u);
-            encodings.push(VarEncoding {
-                start: total_bool_vars,
-                weights: weights.clone(),
-            });
-            total_bool_vars += weights.len();
-        }
-
-        // Step 3: Transform constraints
-        let constraints = self
-            .constraints
-            .iter()
-            .map(|c| {
-                let mut new_terms = Vec::new();
-                for &(var, coef) in &c.terms {
-                    let enc = &encodings[var];
-                    for (j, &w) in enc.weights.iter().enumerate() {
-                        new_terms.push((enc.start + j, coef * w as f64));
-                    }
-                }
-                LinearConstraint::new(new_terms, c.cmp, c.rhs)
-            })
-            .collect();
-
-        // Step 4: Transform objective
-        let mut new_objective = Vec::new();
-        for &(var, coef) in &self.objective {
-            let enc = &encodings[var];
-            for (j, &w) in enc.weights.iter().enumerate() {
-                new_objective.push((enc.start + j, coef * w as f64));
-            }
-        }
-
-        ReductionIntILPToBinaryILP {
-            target: ILP::<bool>::new(total_bool_vars, constraints, new_objective, self.sense),
-            encodings,
-        }
-    }
-}
-
-#[cfg(test)]
-#[path = "../unit_tests/rules/ilp_i32_ilp_bool.rs"]
-mod tests;
diff --git a/src/rules/ilp_i64_ilp_bool.rs b/src/rules/ilp_i64_ilp_bool.rs
new file mode 100644
index 000000000..ea783e12f
--- /dev/null
+++ b/src/rules/ilp_i64_ilp_bool.rs
@@ -0,0 +1,179 @@
+//! Encode finitely bounded integer ILP variables as binary variables.
+
+use crate::models::algebraic::{Comparison, LinearConstraint, ILP};
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::rules::ReductionError;
+
+#[derive(Debug, Clone)]
+struct VarEncoding {
+    lower_bound: i64,
+    start: usize,
+    weights: Vec<i64>,
+}
+
+fn overflow(operation: impl Into<String>) -> ReductionError {
+    ReductionError::integer_overflow::<ILP<i64>, ILP<bool>>(operation)
+}
+
+fn binary_weights(width: i64) -> Vec<i64> {
+    if width == 0 {
+        return Vec::new();
+    }
+    let num_bits = 64 - width.leading_zeros() as usize;
+    let mut weights = Vec::with_capacity(num_bits);
+    for bit in 0..num_bits - 1 {
+        weights.push(1_i64 << bit);
+    }
+    weights.push(width - ((1_i64 << (num_bits - 1)) - 1));
+    weights
+}
+
+fn encoded_constraint(
+    constraint: &LinearConstraint,
+    encodings: &[VarEncoding],
+) -> Result<LinearConstraint, ReductionError> {
+    let mut terms = Vec::new();
+    let mut constant = 0_i64;
+    for &(variable, coefficient) in constraint.terms() {
+        let encoding = &encodings[variable];
+        constant = constant
+            .checked_add(
+                coefficient
+                    .checked_mul(encoding.lower_bound)
+                    .ok_or_else(|| {
+                        overflow("multiplying an ILP row coefficient by a lower bound")
+                    })?,
+            )
+            .ok_or_else(|| overflow("summing the lower-bound shift of an ILP row"))?;
+        for (offset, &weight) in encoding.weights.iter().enumerate() {
+            terms.push((
+                encoding.start + offset,
+                coefficient
+                    .checked_mul(weight)
+                    .ok_or_else(|| overflow("encoding an integer ILP row coefficient"))?,
+            ));
+        }
+    }
+    let rhs = constraint
+        .rhs()
+        .checked_sub(constant)
+        .ok_or_else(|| overflow("shifting an integer ILP right-hand side"))?;
+    Ok(match constraint.comparison() {
+        Comparison::Le => LinearConstraint::le(terms, rhs),
+        Comparison::Ge => LinearConstraint::ge(terms, rhs),
+        Comparison::Eq => LinearConstraint::eq(terms, rhs),
+    })
+}
+
+#[derive(Debug, Clone)]
+pub struct ReductionIntILPToBinaryILP {
+    target: ILP<bool>,
+    encodings: Vec<VarEncoding>,
+}
+
+impl ReductionResult for ReductionIntILPToBinaryILP {
+    type Source = ILP<i64>;
+    type Target = ILP<bool>;
+
+    fn target_problem(&self) -> &ILP<bool> {
+        &self.target
+    }
+
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        self.encodings
+            .iter()
+            .map(|encoding| {
+                encoding.weights.iter().enumerate().try_fold(
+                    encoding.lower_bound,
+                    |value, (offset, &weight)| {
+                        let term = weight
+                            .checked_mul(target_solution[encoding.start + offset])
+                            .ok_or_else(|| {
+                                crate::rules::ExtractionError::invalid(
+                                    "binary ILP decoding multiplication overflowed i64",
+                                )
+                            })?;
+                        value.checked_add(term).ok_or_else(|| {
+                            crate::rules::ExtractionError::invalid(
+                                "binary ILP decoding sum overflowed i64",
+                            )
+                        })
+                    },
+                )
+            })
+            .collect()
+    }
+}
+
+#[reduction(
+    transform = unavailable {
+        num_vars = "the binary width depends on concrete variable bounds, not registered problem parameters",
+        num_constraints = "the exact row count is preserved but the target parameters model is unavailable until all ILP overhead declarations are migrated",
+        num_nonzeros = "binary expansion depends on concrete variable bounds and row sparsity",
+    },
+)]
+impl ReduceTo<ILP<bool>> for ILP<i64> {
+    type Result = ReductionIntILPToBinaryILP;
+
+    fn reduce_to(&self) -> Result<Self::Result, ReductionError> {
+        let mut encodings = Vec::with_capacity(self.num_vars());
+        let mut num_binary_variables = 0_usize;
+        for variable in self.variables() {
+            let lower_bound = variable.lower_bound().ok_or_else(|| {
+                ReductionError::invalid_target::<ILP<i64>, ILP<bool>>(
+                    "binary encoding requires a finite lower bound for every integer variable",
+                )
+            })?;
+            let upper_bound = variable.upper_bound().ok_or_else(|| {
+                ReductionError::invalid_target::<ILP<i64>, ILP<bool>>(
+                    "binary encoding requires a finite upper bound for every integer variable",
+                )
+            })?;
+            let width = upper_bound
+                .checked_sub(lower_bound)
+                .ok_or_else(|| overflow("computing an integer variable interval width"))?;
+            let weights = binary_weights(width);
+            let num_weights = weights.len();
+            encodings.push(VarEncoding {
+                lower_bound,
+                start: num_binary_variables,
+                weights,
+            });
+            num_binary_variables = num_binary_variables
+                .checked_add(num_weights)
+                .ok_or_else(|| overflow("counting binary encoding variables"))?;
+        }
+
+        let constraints = self
+            .constraints()
+            .iter()
+            .map(|constraint| encoded_constraint(constraint, &encodings))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let mut objective = Vec::new();
+        for &(variable, coefficient) in self.objective() {
+            let encoding = &encodings[variable];
+            for (offset, &weight) in encoding.weights.iter().enumerate() {
+                let encoded_coefficient = coefficient
+                    .checked_mul(weight)
+                    .ok_or_else(|| overflow("encoding an integer ILP objective coefficient"))?;
+                objective.push((encoding.start + offset, encoded_coefficient));
+            }
+        }
+
+        Ok(ReductionIntILPToBinaryILP {
+            target: ILP::<bool>::new(num_binary_variables, constraints, objective, self.sense())
+                .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?,
+            encodings,
+        })
+    }
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/ilp_i64_ilp_bool.rs"]
+mod tests;
diff --git a/src/rules/ilp_qubo.rs b/src/rules/ilp_qubo.rs
index 829bab31c..fbe885057 100644
--- a/src/rules/ilp_qubo.rs
+++ b/src/rules/ilp_qubo.rs
@@ -7,7 +7,9 @@
 //! 2. QUBO = -diag(c + 2·P·b·A) + P·A^T·A
 //!
 //! For Minimize sense, c is negated (convert to maximization).
-//! Slack variables: ceil(log2(slack_range)) bits per inequality constraint.
+//! Slack variables: ceil(log2(slack_range + 1)) bits for a nonnegative range.
+//! The custom aggregate restores the omitted constant and both objective senses;
+//! only zero-penalty configurations certify a feasible source assignment.
 
 use crate::models::algebraic::{Comparison, ObjectiveSense, ILP, QUBO};
 use crate::reduction;
@@ -16,77 +18,154 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Result of reducing binary ILP to QUBO.
 #[derive(Debug, Clone)]
 pub struct ReductionILPToQUBO {
-    target: QUBO<f64>,
+    target: QUBO<i64>,
     num_original_vars: usize,
+    sense: ObjectiveSense,
+    penalty_constant: i64,
+    feasible_energy_lower: i64,
+    feasible_energy_upper: i64,
 }
 
 impl ReductionResult for ReductionILPToQUBO {
     type Source = ILP<bool>;
-    type Target = QUBO<f64>;
+    type Target = QUBO<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
     /// Extract only the original variables (discard slack).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_original_vars].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).is_valid() {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target QUBO configuration does not certify a feasible ILP assignment",
+            ));
+        }
+
+        Ok(target_solution[..self.num_original_vars]
+            .iter()
+            .map(|&value| i64::from(value))
+            .collect())
+    }
+}
+
+impl crate::rules::AggregateReductionResult for ReductionILPToQUBO {
+    type Source = ILP<bool>;
+    type Target = QUBO<i64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, value: crate::types::Min<i64>) -> crate::types::Extremum<i64> {
+        let objective = value
+            .0
+            .filter(|&energy| {
+                self.feasible_energy_lower <= energy && energy <= self.feasible_energy_upper
+            })
+            // The checked energy interval guarantees this sum is representable.
+            .map(|energy| energy + self.penalty_constant);
+        match self.sense {
+            ObjectiveSense::Minimize => crate::types::Extremum::minimize(objective),
+            // The strict penalty bound excludes i64::MIN from this interval.
+            ObjectiveSense::Maximize => crate::types::Extremum::maximize(objective.map(|v| -v)),
+        }
     }
 }
 
 #[reduction(
-    overhead = { num_vars = "num_vars + num_constraints * num_vars" }
+    aggregate = custom,
+    transform = unavailable {
+        num_vars = "the slack-bit count depends on coefficient magnitudes and right-hand sides absent from the registered source parameters vector",
+    }
 )]
-impl ReduceTo<QUBO<f64>> for ILP<bool> {
+impl ReduceTo<QUBO<i64>> for ILP<bool> {
     type Result = ReductionILPToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
-        let n = self.num_vars;
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let n = self.num_vars();
 
         // All variables are binary by type — no runtime check needed.
 
         // Build dense constraint matrix A and rhs vector b
         // Also compute slack sizes for inequality constraints
-        let num_constraints = self.constraints.len();
-        let mut a_dense = vec![vec![0.0; n]; num_constraints];
-        let mut b_vec = vec![0.0; num_constraints];
+        let num_constraints = self.constraints().len();
+        let mut a_dense = vec![vec![0_i64; n]; num_constraints];
+        let mut b_vec = vec![0_i64; num_constraints];
         let mut slack_sizes = vec![0usize; num_constraints];
 
-        for (k, constraint) in self.constraints.iter().enumerate() {
-            for &(var, coef) in &constraint.terms {
-                a_dense[k][var] += coef;
+        for (k, constraint) in self.constraints().iter().enumerate() {
+            for &(var, coef) in constraint.terms() {
+                a_dense[k][var] = coef;
             }
-            b_vec[k] = constraint.rhs;
+            b_vec[k] = constraint.rhs();
 
             // Compute slack variable count: ceil(log2(slack_range + 1)) bits
             // to represent integer values 0..slack_range with binary encoding.
             // For binary variables, min_lhs = Σ min(0, a_i), max_lhs = Σ max(0, a_i).
-            match constraint.cmp {
+            match constraint.comparison() {
                 Comparison::Eq => {} // no slack needed
                 Comparison::Le => {
                     // Ax <= b → Ax + s = b, s ∈ {0, ..., b - min_lhs}
-                    let min_lhs: f64 = a_dense[k].iter().map(|&c| c.min(0.0)).sum();
-                    let slack_range = constraint.rhs - min_lhs;
-                    if slack_range > 0.0 {
-                        slack_sizes[k] = (slack_range + 1.0).log2().ceil() as usize;
+                    let min_lhs = a_dense[k]
+                        .iter()
+                        .try_fold(0_i64, |sum, &coefficient| {
+                            sum.checked_add(coefficient.min(0))
+                        })
+                        .ok_or_else(|| {
+                            crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                                "computing an inequality's minimum left-hand side",
+                            )
+                        })?;
+                    let slack_range = constraint.rhs().checked_sub(min_lhs).ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                            "computing a less-than inequality's slack range",
+                        )
+                    })?;
+                    if slack_range > 0 {
+                        slack_sizes[k] = i64::BITS as usize - slack_range.leading_zeros() as usize;
                     }
                 }
                 Comparison::Ge => {
                     // Ax >= b → Ax - s = b, s ∈ {0, ..., max_lhs - b}
-                    let max_lhs: f64 = a_dense[k].iter().map(|&c| c.max(0.0)).sum();
-                    let slack_range = max_lhs - constraint.rhs;
-                    if slack_range > 0.0 {
-                        slack_sizes[k] = (slack_range + 1.0).log2().ceil() as usize;
+                    let max_lhs = a_dense[k]
+                        .iter()
+                        .try_fold(0_i64, |sum, &coefficient| {
+                            sum.checked_add(coefficient.max(0))
+                        })
+                        .ok_or_else(|| {
+                            crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                                "computing an inequality's maximum left-hand side",
+                            )
+                        })?;
+                    let slack_range = max_lhs.checked_sub(constraint.rhs()).ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                            "computing a greater-than inequality's slack range",
+                        )
+                    })?;
+                    if slack_range > 0 {
+                        slack_sizes[k] = i64::BITS as usize - slack_range.leading_zeros() as usize;
                     }
                 }
             }
         }
 
-        let total_slack: usize = slack_sizes.iter().sum();
-        let nq = n + total_slack;
+        let total_slack = slack_sizes.iter().try_fold(0_usize, |total, &size| {
+            total.checked_add(size).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                    "counting QUBO slack variables",
+                )
+            })
+        })?;
+        let nq = qubo_num_variables(n, total_slack)?;
 
         // Extend A with slack columns
-        let mut a_ext = vec![vec![0.0; nq]; num_constraints];
+        let mut a_ext = vec![vec![0_i64; nq]; num_constraints];
         for k in 0..num_constraints {
             for j in 0..n {
                 a_ext[k][j] = a_dense[k][j];
@@ -97,50 +176,119 @@ impl ReduceTo<QUBO<f64>> for ILP<bool> {
         let mut slack_col = n;
         for (k, &ns) in slack_sizes.iter().enumerate() {
             if ns > 0 {
-                let sign = match self.constraints[k].cmp {
-                    Comparison::Le => 1.0,  // Ax + s = b
-                    Comparison::Ge => -1.0, // Ax - s = b
-                    Comparison::Eq => 0.0,
+                let sign = match self.constraints()[k].comparison() {
+                    Comparison::Le => 1,  // Ax + s = b
+                    Comparison::Ge => -1, // Ax - s = b
+                    Comparison::Eq => 0,
                 };
                 for s in 0..ns {
-                    a_ext[k][slack_col + s] = sign * 2.0_f64.powi(s as i32);
+                    let bit = u32::try_from(s).map_err(|_| {
+                        crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                            "encoding a QUBO slack bit",
+                        )
+                    })?;
+                    a_ext[k][slack_col + s] = 1_i64.checked_shl(bit).ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                            "encoding a QUBO slack bit",
+                        )
+                    })? * sign;
                 }
                 slack_col += ns;
             }
         }
 
         // Build dense cost vector (nq elements)
-        let mut c_vec = vec![0.0; nq];
-        for &(var, coef) in &self.objective {
+        let mut c_vec = vec![0_i64; nq];
+        for &(var, coef) in self.objective() {
             c_vec[var] = coef;
         }
 
         // For Minimize sense, negate the cost (formula assumes maximization)
-        if self.sense == ObjectiveSense::Minimize {
+        if self.sense() == ObjectiveSense::Minimize {
             for c in c_vec.iter_mut() {
-                *c = -*c;
+                *c = c.checked_neg().ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                        "negating an ILP objective coefficient",
+                    )
+                })?;
             }
         }
 
         // Penalty: must be large enough to enforce constraints
-        let penalty = 1.0
-            + c_vec.iter().map(|c| c.abs()).sum::<f64>()
-            + b_vec.iter().map(|b| b.abs()).sum::<f64>();
+        let objective_magnitude = c_vec.iter().try_fold(0_i64, |total, &coefficient| {
+            let magnitude = coefficient.checked_abs().ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                    "taking the magnitude of an ILP objective coefficient",
+                )
+            })?;
+            total.checked_add(magnitude).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                    "summing ILP objective coefficient magnitudes",
+                )
+            })
+        })?;
+        let rhs_magnitude = b_vec.iter().try_fold(0_i64, |total, &rhs| {
+            let magnitude = rhs.checked_abs().ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                    "taking the magnitude of an ILP right-hand side",
+                )
+            })?;
+            total.checked_add(magnitude).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                    "summing ILP right-hand-side magnitudes",
+                )
+            })
+        })?;
+        let penalty = objective_magnitude
+            .checked_add(rhs_magnitude)
+            .and_then(|sum| sum.checked_add(1))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                    "computing the QUBO constraint penalty",
+                )
+            })?;
+
+        let (penalty_constant, feasible_energy_lower, feasible_energy_upper) =
+            feasible_energy_range(&c_vec, &b_vec, penalty)?;
 
         // QUBO = -diag(c + 2·P·b·A) + P·A^T·A
-        let mut matrix = vec![vec![0.0; nq]; nq];
+        let mut matrix = vec![vec![0_i64; nq]; nq];
 
         // Compute b·A (b_vec dot each column of a_ext)
-        let mut ba = vec![0.0; nq];
+        let mut ba = vec![0_i64; nq];
         for (j, ba_j) in ba.iter_mut().enumerate() {
             for (k, &b_k) in b_vec.iter().enumerate() {
-                *ba_j += b_k * a_ext[k][j];
+                let term = b_k.checked_mul(a_ext[k][j]).ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                        "multiplying a right-hand side by a row coefficient",
+                    )
+                })?;
+                *ba_j = ba_j.checked_add(term).ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                        "computing the right-hand-side row product",
+                    )
+                })?;
             }
         }
 
         // Diagonal: -(c_j + 2·P·(b·A)_j)
         for j in 0..nq {
-            matrix[j][j] = -(c_vec[j] + 2.0 * penalty * ba[j]);
+            let penalty_term = penalty
+                .checked_mul(ba[j])
+                .and_then(|value| value.checked_mul(2))
+                .ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                        "computing a QUBO diagonal penalty",
+                    )
+                })?;
+            matrix[j][j] = c_vec[j]
+                .checked_add(penalty_term)
+                .and_then(i64::checked_neg)
+                .ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                        "computing a QUBO diagonal coefficient",
+                    )
+                })?;
         }
 
         // A^T·A contribution (upper-triangular convention)
@@ -148,25 +296,98 @@ impl ReduceTo<QUBO<f64>> for ILP<bool> {
         // Off-diagonal (i<j): 2·P · Σ_k a_{ki}·a_{kj}
         for row in &a_ext {
             for (i, row_i) in matrix.iter_mut().enumerate() {
-                if row[i].abs() < 1e-15 {
+                if row[i] == 0 {
                     continue;
                 }
                 // Diagonal
-                row_i[i] += penalty * row[i] * row[i];
+                let diagonal = penalty
+                    .checked_mul(row[i])
+                    .and_then(|value| value.checked_mul(row[i]))
+                    .ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                            "computing a quadratic QUBO diagonal penalty",
+                        )
+                    })?;
+                row_i[i] = row_i[i].checked_add(diagonal).ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                        "adding a quadratic QUBO diagonal penalty",
+                    )
+                })?;
                 // Off-diagonal
                 for j in (i + 1)..nq {
-                    row_i[j] += 2.0 * penalty * row[i] * row[j];
+                    let interaction = penalty
+                        .checked_mul(row[i])
+                        .and_then(|value| value.checked_mul(row[j]))
+                        .and_then(|value| value.checked_mul(2))
+                        .ok_or_else(|| {
+                            crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                                "computing a quadratic QUBO interaction penalty",
+                            )
+                        })?;
+                    row_i[j] = row_i[j].checked_add(interaction).ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+                            "adding a quadratic QUBO interaction penalty",
+                        )
+                    })?;
                 }
             }
         }
 
-        ReductionILPToQUBO {
-            target: QUBO::from_matrix(matrix),
+        Ok(ReductionILPToQUBO {
+            target: QUBO::from_matrix(matrix)
+                .map_err(crate::rules::ReductionError::construction::<ILP<bool>, QUBO<i64>>)?,
             num_original_vars: n,
-        }
+            sense: self.sense(),
+            penalty_constant,
+            feasible_energy_lower,
+            feasible_energy_upper,
+        })
     }
 }
 
+/// Check the dense QUBO dimensions before allocating either extended matrix.
+fn qubo_num_variables(n: usize, slack: usize) -> Result<usize, crate::rules::ReductionError> {
+    let overflow = || {
+        crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+            "counting dense QUBO entries",
+        )
+    };
+    let total = n.checked_add(slack).ok_or_else(overflow)?;
+    total.checked_mul(total).ok_or_else(overflow)?;
+    Ok(total)
+}
+
+/// Restore the omitted squared-residual constant and bound zero-penalty energies.
+/// `cost` is the maximization-oriented objective used in the QUBO expansion.
+fn feasible_energy_range(
+    cost: &[i64],
+    rhs: &[i64],
+    penalty: i64,
+) -> Result<(i64, i64, i64), crate::rules::ReductionError> {
+    let overflow = || {
+        crate::rules::ReductionError::integer_overflow::<ILP<bool>, QUBO<i64>>(
+            "encoding the QUBO feasible energy interval",
+        )
+    };
+    let constant = rhs.iter().try_fold(0_i64, |sum, &b| {
+        b.checked_mul(b)
+            .and_then(|square| square.checked_mul(penalty))
+            .and_then(|term| sum.checked_add(term))
+            .ok_or_else(overflow)
+    })?;
+    let (lower, upper) = cost.iter().try_fold((0_i64, 0_i64), |(low, high), &c| {
+        Ok::<_, crate::rules::ReductionError>((
+            low.checked_sub(c.max(0)).ok_or_else(overflow)?,
+            high.checked_sub(c.min(0)).ok_or_else(overflow)?,
+        ))
+    })?;
+    Ok((
+        constant,
+        lower.checked_sub(constant).ok_or_else(overflow)?,
+        upper.checked_sub(constant).ok_or_else(overflow)?,
+    ))
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
     use crate::export::SolutionPair;
@@ -178,21 +399,22 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             let source = ILP::new(
                 6,
                 vec![
-                    LinearConstraint::le(
-                        vec![(0, 3.0), (1, 2.0), (2, 5.0), (3, 4.0), (4, 2.0), (5, 3.0)],
-                        10.0,
-                    ),
-                    LinearConstraint::le(vec![(0, 1.0), (1, 1.0), (2, 1.0)], 2.0),
-                    LinearConstraint::le(vec![(3, 1.0), (4, 1.0), (5, 1.0)], 2.0),
+                    LinearConstraint::le(vec![(0, 3), (1, 2), (2, 5), (3, 4), (4, 2), (5, 3)], 10),
+                    LinearConstraint::le(vec![(0, 1), (1, 1), (2, 1)], 2),
+                    LinearConstraint::le(vec![(3, 1), (4, 1), (5, 1)], 2),
                 ],
-                vec![(0, 10.0), (1, 7.0), (2, 12.0), (3, 8.0), (4, 6.0), (5, 9.0)],
+                vec![(0, 10), (1, 7), (2, 12), (3, 8), (4, 6), (5, 9)],
                 ObjectiveSense::Maximize,
-            );
-            crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
+            )
+            .expect("canonical ILP example must satisfy construction invariants");
+            crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 0, 0, 1, 1],
-                    target_config: vec![1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+                    source_config: serde_json::json!(vec![1, 1, 0, 0, 1, 1]),
+                    target_config: serde_json::json!(vec![
+                        true, true, false, false, true, true, false, false, false, false, false,
+                        false, false, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/integerknapsack_ilp.rs b/src/rules/integerknapsack_ilp.rs
index d5e7ef33d..8eb5b2aca 100644
--- a/src/rules/integerknapsack_ilp.rs
+++ b/src/rules/integerknapsack_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from IntegerKnapsack to ILP<i32>.
+//! Reduction from IntegerKnapsack to `ILP<i64>`.
 //!
 //! Each item multiplicity becomes a non-negative integer ILP variable. The
 //! capacity inequality is kept directly, and explicit upper bounds
@@ -11,63 +11,65 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 
 #[derive(Debug, Clone)]
 pub struct ReductionIntegerKnapsackToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
 }
 
 impl ReductionResult for ReductionIntegerKnapsackToILP {
     type Source = IntegerKnapsack;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::decode_usize_values(target_solution)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_items",
         num_constraints = "num_items + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for IntegerKnapsack {
+impl ReduceTo<ILP<i64>> for IntegerKnapsack {
     type Result = ReductionIntegerKnapsackToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.num_items();
         let mut constraints = Vec::with_capacity(num_vars + 1);
+        let sizes = self.sizes();
+        let values = self.values();
 
         constraints.push(LinearConstraint::le(
-            self.sizes()
+            sizes
                 .iter()
                 .enumerate()
-                .map(|(i, &size)| (i, size as f64))
+                .map(|(item, &size)| (item, size))
                 .collect(),
-            self.capacity() as f64,
+            self.capacity(),
         ));
 
         for (i, &size) in self.sizes().iter().enumerate() {
             let upper_bound = self.capacity() / size;
-            assert!(
-                upper_bound <= i32::MAX as i64,
-                "IntegerKnapsack -> ILP requires multiplicity bounds to fit in ILP<i32> variable bounds"
-            );
-            constraints.push(LinearConstraint::le(vec![(i, 1.0)], upper_bound as f64));
+            constraints.push(LinearConstraint::le(vec![(i, 1)], upper_bound));
         }
 
-        let objective = self
-            .values()
-            .iter()
-            .enumerate()
-            .map(|(i, &value)| (i, value as f64))
-            .collect();
+        let objective = values.iter().copied().enumerate().collect();
 
-        ReductionIntegerKnapsackToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize),
-        }
+        Ok(ReductionIntegerKnapsackToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+                .map_err(Self::target_construction)?,
+        })
     }
 }
 
@@ -76,8 +78,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "integerknapsack_to_ilp",
         build: || {
-            let source = IntegerKnapsack::new(vec![3, 4, 5], vec![4, 5, 7], 10);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            let source = IntegerKnapsack::new(vec![3, 4, 5], vec![4, 5, 7], 10).unwrap();
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/integralflowbundles_ilp.rs b/src/rules/integralflowbundles_ilp.rs
index ad423ec32..d4220c41e 100644
--- a/src/rules/integralflowbundles_ilp.rs
+++ b/src/rules/integralflowbundles_ilp.rs
@@ -12,38 +12,46 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Result of reducing IntegralFlowBundles to ILP.
 #[derive(Debug, Clone)]
 pub struct ReductionIFBToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
 }
 
 impl ReductionResult for ReductionIFBToILP {
     type Source = IntegralFlowBundles;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::decode_usize_values(target_solution)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_arcs",
         num_constraints = "num_bundles + num_vertices - 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for IntegralFlowBundles {
+impl ReduceTo<ILP<i64>> for IntegralFlowBundles {
     type Result = ReductionIFBToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let arcs = self.graph().arcs();
         let mut constraints = Vec::with_capacity(self.num_bundles() + self.num_vertices() - 1);
 
         for (bundle, &capacity) in self.bundles().iter().zip(self.bundle_capacities()) {
-            let terms = bundle.iter().map(|&arc_index| (arc_index, 1.0)).collect();
-            constraints.push(LinearConstraint::le(terms, capacity as f64));
+            let terms = bundle.iter().map(|&arc_index| (arc_index, 1)).collect();
+            constraints.push(LinearConstraint::le(terms, capacity));
         }
 
         for vertex in 0..self.num_vertices() {
@@ -54,34 +62,35 @@ impl ReduceTo<ILP<i32>> for IntegralFlowBundles {
             let mut terms = Vec::new();
             for (arc_index, (u, v)) in arcs.iter().copied().enumerate() {
                 if vertex == u {
-                    terms.push((arc_index, -1.0));
+                    terms.push((arc_index, -1));
                 }
                 if vertex == v {
-                    terms.push((arc_index, 1.0));
+                    terms.push((arc_index, 1));
                 }
             }
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         let mut sink_terms = Vec::new();
         for (arc_index, (u, v)) in arcs.iter().copied().enumerate() {
             if self.sink() == u {
-                sink_terms.push((arc_index, -1.0));
+                sink_terms.push((arc_index, -1));
             }
             if self.sink() == v {
-                sink_terms.push((arc_index, 1.0));
+                sink_terms.push((arc_index, 1));
             }
         }
-        constraints.push(LinearConstraint::ge(sink_terms, self.requirement() as f64));
+        constraints.push(LinearConstraint::ge(sink_terms, self.requirement()));
 
-        ReductionIFBToILP {
+        Ok(ReductionIFBToILP {
             target: ILP::new(
                 self.num_arcs(),
                 constraints,
                 vec![],
                 ObjectiveSense::Minimize,
-            ),
-        }
+            )
+            .map_err(Self::target_construction)?,
+        })
     }
 }
 
@@ -100,7 +109,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 vec![1, 1, 1],
                 1,
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/integralflowhomologousarcs_ilp.rs b/src/rules/integralflowhomologousarcs_ilp.rs
index 05c6cfc1e..006ecdb56 100644
--- a/src/rules/integralflowhomologousarcs_ilp.rs
+++ b/src/rules/integralflowhomologousarcs_ilp.rs
@@ -11,32 +11,40 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Result of reducing IntegralFlowHomologousArcs to ILP.
 #[derive(Debug, Clone)]
 pub struct ReductionIFHAToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
 }
 
 impl ReductionResult for ReductionIFHAToILP {
     type Source = IntegralFlowHomologousArcs;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::decode_usize_values(target_solution)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_arcs",
-        num_constraints = "num_arcs + num_vertices - 2 + 1",
+        num_constraints = "num_arcs^2 + num_arcs + num_vertices + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for IntegralFlowHomologousArcs {
+impl ReduceTo<ILP<i64>> for IntegralFlowHomologousArcs {
     type Result = ReductionIFHAToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let arcs = self.graph().arcs();
         let num_arcs = self.num_arcs();
         let num_vertices = self.num_vertices();
@@ -44,7 +52,7 @@ impl ReduceTo<ILP<i32>> for IntegralFlowHomologousArcs {
 
         // Capacity: f_a <= c_a for each arc
         for (arc_idx, &capacity) in self.capacities().iter().enumerate() {
-            constraints.push(LinearConstraint::le(vec![(arc_idx, 1.0)], capacity as f64));
+            constraints.push(LinearConstraint::le(vec![(arc_idx, 1)], capacity));
         }
 
         // Conservation: sum_{a in delta^-(v)} f_a = sum_{a in delta^+(v)} f_a
@@ -56,35 +64,36 @@ impl ReduceTo<ILP<i32>> for IntegralFlowHomologousArcs {
             let mut terms = Vec::new();
             for (arc_idx, &(u, v)) in arcs.iter().enumerate() {
                 if v == vertex {
-                    terms.push((arc_idx, 1.0)); // incoming
+                    terms.push((arc_idx, 1)); // incoming
                 }
                 if u == vertex {
-                    terms.push((arc_idx, -1.0)); // outgoing
+                    terms.push((arc_idx, -1)); // outgoing
                 }
             }
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // Homologous equality: f_a = f_b for each pair (a, b)
         for &(a, b) in self.homologous_pairs() {
-            constraints.push(LinearConstraint::eq(vec![(a, 1.0), (b, -1.0)], 0.0));
+            constraints.push(LinearConstraint::eq(vec![(a, 1), (b, -1)], 0));
         }
 
         // Sink inflow requirement: sum_{a in delta^-(t)} f_a - sum_{a in delta^+(t)} f_a >= R
         let mut sink_terms = Vec::new();
         for (arc_idx, &(u, v)) in arcs.iter().enumerate() {
             if v == self.sink() {
-                sink_terms.push((arc_idx, 1.0)); // incoming
+                sink_terms.push((arc_idx, 1)); // incoming
             }
             if u == self.sink() {
-                sink_terms.push((arc_idx, -1.0)); // outgoing
+                sink_terms.push((arc_idx, -1)); // outgoing
             }
         }
-        constraints.push(LinearConstraint::ge(sink_terms, self.requirement() as f64));
+        constraints.push(LinearConstraint::ge(sink_terms, self.requirement()));
 
-        ReductionIFHAToILP {
-            target: ILP::new(num_arcs, constraints, vec![], ObjectiveSense::Minimize),
-        }
+        Ok(ReductionIFHAToILP {
+            target: ILP::new(num_arcs, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
+        })
     }
 }
 
@@ -103,7 +112,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 2,
                 vec![(0, 1)],
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/integralflowwithmultipliers_ilp.rs b/src/rules/integralflowwithmultipliers_ilp.rs
index c53b35bc4..6c700a3ba 100644
--- a/src/rules/integralflowwithmultipliers_ilp.rs
+++ b/src/rules/integralflowwithmultipliers_ilp.rs
@@ -11,32 +11,40 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Result of reducing IntegralFlowWithMultipliers to ILP.
 #[derive(Debug, Clone)]
 pub struct ReductionIFWMToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
 }
 
 impl ReductionResult for ReductionIFWMToILP {
     type Source = IntegralFlowWithMultipliers;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::decode_usize_values(target_solution)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_arcs",
         num_constraints = "num_arcs + num_vertices - 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for IntegralFlowWithMultipliers {
+impl ReduceTo<ILP<i64>> for IntegralFlowWithMultipliers {
     type Result = ReductionIFWMToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let arcs = self.graph().arcs();
         let num_arcs = self.num_arcs();
         let num_vertices = self.num_vertices();
@@ -44,7 +52,7 @@ impl ReduceTo<ILP<i32>> for IntegralFlowWithMultipliers {
 
         // Capacity: f_a <= c_a for each arc
         for (arc_idx, &capacity) in self.capacities().iter().enumerate() {
-            constraints.push(LinearConstraint::le(vec![(arc_idx, 1.0)], capacity as f64));
+            constraints.push(LinearConstraint::le(vec![(arc_idx, 1)], capacity));
         }
 
         // Multiplier-scaled conservation:
@@ -55,34 +63,35 @@ impl ReduceTo<ILP<i32>> for IntegralFlowWithMultipliers {
             if vertex == self.source() || vertex == self.sink() {
                 continue;
             }
-            let multiplier = self.multipliers()[vertex] as f64;
+            let multiplier = self.multipliers()[vertex];
             let mut terms = Vec::new();
             for (arc_idx, &(u, v)) in arcs.iter().enumerate() {
                 if u == vertex {
-                    terms.push((arc_idx, 1.0)); // outgoing
+                    terms.push((arc_idx, 1)); // outgoing
                 }
                 if v == vertex {
                     terms.push((arc_idx, -multiplier)); // incoming scaled by -h(v)
                 }
             }
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // Sink inflow requirement: sum_{a in delta^-(t)} f_a - sum_{a in delta^+(t)} f_a >= R
         let mut sink_terms = Vec::new();
         for (arc_idx, &(u, v)) in arcs.iter().enumerate() {
             if v == self.sink() {
-                sink_terms.push((arc_idx, 1.0)); // incoming
+                sink_terms.push((arc_idx, 1)); // incoming
             }
             if u == self.sink() {
-                sink_terms.push((arc_idx, -1.0)); // outgoing
+                sink_terms.push((arc_idx, -1)); // outgoing
             }
         }
-        constraints.push(LinearConstraint::ge(sink_terms, self.requirement() as f64));
+        constraints.push(LinearConstraint::ge(sink_terms, self.requirement()));
 
-        ReductionIFWMToILP {
-            target: ILP::new(num_arcs, constraints, vec![], ObjectiveSense::Minimize),
-        }
+        Ok(ReductionIFWMToILP {
+            target: ILP::new(num_arcs, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
+        })
     }
 }
 
@@ -102,7 +111,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 vec![2, 2, 2, 2],
                 2,
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/isomorphicspanningtree_ilp.rs b/src/rules/isomorphicspanningtree_ilp.rs
index dad7a8126..e2d9e2ec4 100644
--- a/src/rules/isomorphicspanningtree_ilp.rs
+++ b/src/rules/isomorphicspanningtree_ilp.rs
@@ -24,28 +24,29 @@ impl ReductionResult for ReductionISTToILP {
     }
 
     /// For each tree vertex u, output the unique graph vertex v with x_{u,v} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.n;
-        (0..n)
-            .map(|u| {
-                (0..n)
-                    .find(|&v| target_solution[u * n + v] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(target_solution, self.n, self.n, 0)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_vertices * num_vertices",
         num_constraints = "2 * num_vertices + 2 * (num_vertices - 1) * num_vertices * num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for IsomorphicSpanningTree<SimpleGraph> {
     type Result = ReductionISTToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let num_vars = n * n;
 
@@ -54,15 +55,15 @@ impl ReduceTo<ILP<bool>> for IsomorphicSpanningTree<SimpleGraph> {
         // Each tree vertex u maps to exactly one graph vertex:
         // Σ_v x_{u,v} = 1  ∀ u
         for u in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|v| (u * n + v, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|v| (u * n + v, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Each graph vertex v is mapped to by exactly one tree vertex:
         // Σ_u x_{u,v} = 1  ∀ v
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|u| (u * n + v, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|u| (u * n + v, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // For each tree edge {u, w} and each pair (v, z) that is NOT a graph edge:
@@ -73,16 +74,17 @@ impl ReduceTo<ILP<bool>> for IsomorphicSpanningTree<SimpleGraph> {
                 for z in 0..n {
                     if v != z && !self.graph().has_edge(v, z) {
                         constraints.push(LinearConstraint::le(
-                            vec![(u * n + v, 1.0), (w * n + z, 1.0)],
-                            1.0,
+                            vec![(u * n + v, 1), (w * n + z, 1)],
+                            1,
                         ));
                     }
                 }
             }
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionISTToILP { target, n }
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionISTToILP { target, n })
     }
 }
 
@@ -102,9 +104,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 2, 3],
+                    source_config: serde_json::json!(vec![0, 1, 2, 3]),
                     // x_{0,0}=1, x_{1,1}=1, x_{2,2}=1, x_{3,3}=1
-                    target_config: vec![1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+                    target_config: serde_json::json!(vec![
+                        1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1
+                    ]),
                 },
             )
         },
diff --git a/src/rules/kclique_balancedcompletebipartitesubgraph.rs b/src/rules/kclique_balancedcompletebipartitesubgraph.rs
index 0c84772a3..b8285dbf6 100644
--- a/src/rules/kclique_balancedcompletebipartitesubgraph.rs
+++ b/src/rules/kclique_balancedcompletebipartitesubgraph.rs
@@ -32,26 +32,36 @@ impl ReductionResult for ReductionKCliqueToBCBS {
     /// Extract KClique solution from BalancedCompleteBipartiteSubgraph solution.
     ///
     /// The k-clique is S = {v in V : v not in A'}, i.e., the original vertices
-    /// NOT selected on the left side. For each original vertex v (0..n-1):
-    /// source_config[v] = 1 - target_config[v].
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.num_original_vertices)
-            .map(|v| 1 - target_solution[v])
-            .collect()
+    /// NOT selected on the left side. For each original vertex v (0..n-1),
+    /// the source selection is the negation of the target's left-side selection.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            (0..self.num_original_vertices)
+                .map(|v| !target_solution[v])
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         left_size = "num_vertices + k * (k - 1) / 2",
         right_size = "num_edges + num_vertices - k",
         k = "num_vertices + k * (k - 1) / 2 - k",
+    },
+    unavailable = {
+        num_vertices = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<BalancedCompleteBipartiteSubgraph> for KClique<SimpleGraph> {
     type Result = ReductionKCliqueToBCBS;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let k = self.k();
         let edges: Vec<(usize, usize)> = self.graph().edges();
@@ -92,10 +102,10 @@ impl ReduceTo<BalancedCompleteBipartiteSubgraph> for KClique<SimpleGraph> {
         let graph = BipartiteGraph::new(left_size, right_size, bip_edges);
         let target = BalancedCompleteBipartiteSubgraph::new(graph, target_k);
 
-        ReductionKCliqueToBCBS {
+        Ok(ReductionKCliqueToBCBS {
             target,
             num_original_vertices: n,
-        }
+        })
     }
 }
 
@@ -125,8 +135,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 1, 0],
-                    target_config: vec![0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1],
+                    source_config: serde_json::json!(vec![true, true, true, false]),
+                    target_config: serde_json::json!(vec![
+                        false, false, false, true, true, true, true, true, true, true, false, true
+                    ]),
                 },
             )
         },
diff --git a/src/rules/kclique_conjunctivebooleanquery.rs b/src/rules/kclique_conjunctivebooleanquery.rs
index 0dcd3c4ca..e0c66f76b 100644
--- a/src/rules/kclique_conjunctivebooleanquery.rs
+++ b/src/rules/kclique_conjunctivebooleanquery.rs
@@ -34,13 +34,21 @@ impl ReductionResult for ReductionKCliqueToCBQ {
     /// CBQ config: vec of length k, each value is a domain element (vertex index).
     /// KClique config: binary vec of length n; set config[v]=1 for each v in
     /// the CBQ assignment.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        KClique::<SimpleGraph>::config_from_vertices(self.num_vertices, target_solution)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(KClique::<SimpleGraph>::config_from_vertices(
+            self.num_vertices,
+            target_solution,
+        ))
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         domain_size = "num_vertices",
         num_relations = "1",
         num_variables = "k",
@@ -50,7 +58,7 @@ impl ReductionResult for ReductionKCliqueToCBQ {
 impl ReduceTo<ConjunctiveBooleanQuery> for KClique<SimpleGraph> {
     type Result = ReductionKCliqueToCBQ;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let k = self.k();
 
@@ -72,10 +80,10 @@ impl ReduceTo<ConjunctiveBooleanQuery> for KClique<SimpleGraph> {
 
         let target = ConjunctiveBooleanQuery::new(n, vec![relation], k, conjuncts);
 
-        ReductionKCliqueToCBQ {
+        Ok(ReductionKCliqueToCBQ {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -94,8 +102,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ConjunctiveBooleanQuery>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 1, 0, 0],
-                    target_config: vec![0, 1, 2],
+                    source_config: serde_json::json!(vec![true, true, true, false, false]),
+                    target_config: serde_json::json!(vec![0, 1, 2]),
                 },
             )
         },
diff --git a/src/rules/kclique_ilp.rs b/src/rules/kclique_ilp.rs
index 96db11c91..1c3e0f962 100644
--- a/src/rules/kclique_ilp.rs
+++ b/src/rules/kclique_ilp.rs
@@ -39,44 +39,54 @@ impl ReductionResult for ReductionKCliqueToILP {
     ///
     /// Since the mapping is 1:1 (each vertex maps to one binary variable),
     /// the solution extraction is simply copying the configuration.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_vertices",
-        num_constraints = "num_vertices^2",
+        num_constraints = "num_vertices^2 + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for KClique<SimpleGraph> {
     type Result = ReductionKCliqueToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.graph().num_vertices();
-        let k = self.k();
+        let k =
+            <Self as ReduceTo<ILP<bool>>>::exact_i64(self.k(), "encoding the clique cardinality")?;
 
         let mut constraints: Vec<LinearConstraint> = Vec::new();
 
         // Cardinality constraint: sum of x_v >= k (select at least k vertices)
-        let cardinality_terms: Vec<(usize, f64)> = (0..num_vars).map(|v| (v, 1.0)).collect();
-        constraints.push(LinearConstraint::ge(cardinality_terms, k as f64));
+        let cardinality_terms: Vec<(usize, i64)> = (0..num_vars).map(|v| (v, 1)).collect();
+        constraints.push(LinearConstraint::ge(cardinality_terms, k));
 
         // Non-edge constraints: x_u + x_v <= 1 for each non-edge (u, v)
         // Ensures no two selected vertices are non-adjacent (i.e., selected set is a clique)
         for u in 0..num_vars {
             for v in (u + 1)..num_vars {
                 if !self.graph().has_edge(u, v) {
-                    constraints.push(LinearConstraint::le(vec![(u, 1.0), (v, 1.0)], 1.0));
+                    constraints.push(LinearConstraint::le(vec![(u, 1), (v, 1)], 1));
                 }
             }
         }
 
         // Objective: empty (feasibility problem — minimize 0)
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionKCliqueToILP { target }
+        Ok(ReductionKCliqueToILP { target })
     }
 }
 
@@ -95,8 +105,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 1, 0],
-                    target_config: vec![1, 1, 1, 0],
+                    source_config: serde_json::json!(vec![true, true, true, false]),
+                    target_config: serde_json::json!(vec![1, 1, 1, 0]),
                 },
             )
         },
diff --git a/src/rules/kclique_subgraphisomorphism.rs b/src/rules/kclique_subgraphisomorphism.rs
index e351a2cfa..f39f27561 100644
--- a/src/rules/kclique_subgraphisomorphism.rs
+++ b/src/rules/kclique_subgraphisomorphism.rs
@@ -34,13 +34,21 @@ impl ReductionResult for ReductionKCliqueToSubIso {
     /// The SubgraphIsomorphism config maps each pattern vertex (0..k-1) to a
     /// host vertex. We create a binary vector of length n and set positions
     /// f(0), f(1), ..., f(k-1) to 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        KClique::<SimpleGraph>::config_from_vertices(self.num_source_vertices, target_solution)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(KClique::<SimpleGraph>::config_from_vertices(
+            self.num_source_vertices,
+            target_solution,
+        ))
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_host_vertices = "num_vertices",
         num_host_edges = "num_edges",
         num_pattern_vertices = "k",
@@ -50,7 +58,7 @@ impl ReductionResult for ReductionKCliqueToSubIso {
 impl ReduceTo<SubgraphIsomorphism> for KClique<SimpleGraph> {
     type Result = ReductionKCliqueToSubIso;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let k = self.k();
 
@@ -59,10 +67,10 @@ impl ReduceTo<SubgraphIsomorphism> for KClique<SimpleGraph> {
 
         let target = SubgraphIsomorphism::new(host, pattern);
 
-        ReductionKCliqueToSubIso {
+        Ok(ReductionKCliqueToSubIso {
             target,
             num_source_vertices: n,
-        }
+        })
     }
 }
 
@@ -81,8 +89,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, SubgraphIsomorphism>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 1, 1, 1],
-                    target_config: vec![2, 3, 4],
+                    source_config: serde_json::json!(vec![false, false, true, true, true]),
+                    target_config: serde_json::json!(vec![2, 3, 4]),
                 },
             )
         },
diff --git a/src/rules/kcoloring_bicliquecover.rs b/src/rules/kcoloring_bicliquecover.rs
index 2c28ced38..46be9a726 100644
--- a/src/rules/kcoloring_bicliquecover.rs
+++ b/src/rules/kcoloring_bicliquecover.rs
@@ -3,13 +3,13 @@
 //! Self-contained gadget: given a KColoring instance `(G, q)` with `n = |V|`
 //! and `m = |E|`, build a bipartite graph `H = (L, R, F)` with `2n` left
 //! vertices and `2n` right vertices, and ask for a biclique cover of `H`
-//! using `n + q` sub-bicliques. The construction is designed so that
+//! using `n + min(q, n)` sub-bicliques. The construction is designed so that
 //! exactly `n` of the bicliques are forced to cover guard-anchor edges,
 //! leaving at most `q` bicliques to cover the `n` diagonal edges
 //! `(a_v, b_v)`. These remaining bicliques behave as color classes: two
 //! source vertices may share one only when they are nonadjacent in `G`.
 //!
-//! See issue #1058 for the full proof sketch.
+//! The paper contains the full proof, including native loops and repeated edges.
 //!
 //! ## Vertex layout
 //!
@@ -68,73 +68,91 @@ impl ReductionResult for ReductionKColoringToBicliqueCover {
     /// cover yields at most `q` such distinct bicliques, so the result is a
     /// proper `q`-coloring of the source.
     ///
-    /// If the witness is invalid (e.g. some diagonal edge is uncovered),
-    /// the extracted entry for `v` falls back to color `0`. Validation
-    /// downstream is the responsibility of `source.is_valid_solution`.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_vertices;
-        let k = self.target.k();
-        let left_size = 2 * n;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if value.0.is_none() {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target configuration is not a biclique cover",
+            ));
+        }
 
-        // For each source vertex v, find the first biclique r that contains
-        // both a_v (unified index v) and b_v (unified index left_size + v).
-        let mut diagonal_biclique = vec![None; n];
-        for (v, slot) in diagonal_biclique.iter_mut().enumerate() {
-            let a_v = v;
-            let b_v = left_size + v;
-            for r in 0..k {
-                let a_idx = a_v * k + r;
-                let b_idx = b_v * k + r;
-                if target_solution.get(a_idx).copied().unwrap_or(0) == 1
-                    && target_solution.get(b_idx).copied().unwrap_or(0) == 1
-                {
-                    *slot = Some(r);
-                    break;
-                }
+        Ok({
+            let n = self.num_vertices;
+            let k = self.target.k();
+            let left_size = 2 * n;
+
+            // For each source vertex v, find the first biclique r that contains
+            // both a_v (unified index v) and b_v (unified index left_size + v).
+            let mut diagonal_biclique = Vec::with_capacity(n);
+            for v in 0..n {
+                let a_v = v;
+                let b_v = left_size + v;
+                let biclique = (0..k)
+                    .find(|&r| target_solution[r][a_v] && target_solution[r][b_v])
+                    .ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid(format!(
+                            "target cover leaves diagonal gadget edge {v} uncovered"
+                        ))
+                    })?;
+                diagonal_biclique.push(biclique);
             }
-        }
 
-        // Compact distinct biclique indices into colors 0..q-1 in first-seen order.
-        let mut color_of_biclique: std::collections::HashMap<usize, usize> =
-            std::collections::HashMap::new();
-        let mut coloring = vec![0usize; n];
-        for (v, slot) in diagonal_biclique.iter().enumerate() {
-            if let Some(r) = *slot {
+            // Compact distinct biclique indices into colors 0..q-1 in first-seen order.
+            let mut color_of_biclique: std::collections::HashMap<usize, usize> =
+                std::collections::HashMap::new();
+            let mut coloring = Vec::with_capacity(n);
+            for biclique in diagonal_biclique {
                 let next_color = color_of_biclique.len();
-                let color = *color_of_biclique.entry(r).or_insert(next_color);
-                // Clamp into [0, q-1]: if the witness exceeds q distinct
-                // diagonal bicliques (which a valid cover never does) keep
-                // the entry in range so the downstream validator can
-                // simply reject it as an improper coloring.
-                coloring[v] = if self.num_colors == 0 {
-                    0
-                } else {
-                    color.min(self.num_colors - 1)
-                };
+                let color = *color_of_biclique.entry(biclique).or_insert(next_color);
+                if color >= self.num_colors {
+                    return Err(crate::rules::ExtractionError::invalid(format!(
+                        "target cover uses more than {} diagonal bicliques",
+                        self.num_colors
+                    )));
+                }
+                coloring.push(color);
             }
-        }
-        coloring
+            coloring
+        })
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "4 * num_vertices",
-        num_edges = "2 * num_vertices * (num_vertices - 1) - 4 * num_edges + 3 * num_vertices",
-        rank = "num_vertices + num_colors",
+    transform = upper_bound {
+        left_size = "2 * num_vertices + 1",
+        num_vertices = "4 * num_vertices + 2",
+        num_edges = "2 * num_vertices^2 + num_vertices + 1",
+        rank = "2 * num_vertices",
+        right_size = "2 * num_vertices + 1",
     }
 )]
 impl ReduceTo<BicliqueCover> for KColoring<KN, SimpleGraph> {
     type Result = ReductionKColoringToBicliqueCover;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
-        let q = self.num_colors();
+        // Relabeling the used colors preserves feasibility with at most n colors.
+        // Native node storage bounds make 4*n and n+min(q,n) fit usize.
+        let q = self.num_colors().min(n);
+        let native_edges = self.graph().edges();
+        if native_edges.iter().any(|&(u, v)| u == v) {
+            // A loop cannot be properly colored. A single edge cannot be
+            // covered with zero bicliques, giving a fixed NO instance.
+            return Ok(ReductionKColoringToBicliqueCover {
+                target: BicliqueCover::new(BipartiteGraph::new(1, 1, vec![(0, 0)]), 0),
+                num_vertices: n,
+                num_colors: q,
+            });
+        }
 
         // Build the set of source edges as an undirected lookup so the
-        // construction can skip endpoints {u,v} in E in O(1).
+        // construction can test endpoints {u,v} in E in O(log m).
         let mut source_edges: BTreeSet<(usize, usize)> = BTreeSet::new();
-        for (u, v) in self.graph().edges() {
+        for (u, v) in native_edges {
             let (a, b) = if u <= v { (u, v) } else { (v, u) };
             source_edges.insert((a, b));
         }
@@ -195,11 +213,11 @@ impl ReduceTo<BicliqueCover> for KColoring<KN, SimpleGraph> {
         let right_size = 2 * n;
         let target = BicliqueCover::new(BipartiteGraph::new(left_size, right_size, edges), n + q);
 
-        ReductionKColoringToBicliqueCover {
+        Ok(ReductionKColoringToBicliqueCover {
             target,
             num_vertices: n,
             num_colors: q,
-        }
+        })
     }
 }
 
@@ -217,8 +235,8 @@ impl ReduceTo<BicliqueCover> for KColoring<KN, SimpleGraph> {
 /// C_color = ({a_v : v in C}, {b_v : v in C}).
 /// ```
 ///
-/// Returns a vertex-major BicliqueCover configuration of length
-/// `4n * (n + q)` (i.e. `num_vertices * rank`).
+/// Returns one membership row per biclique. Each row has one Boolean entry
+/// per target vertex.
 ///
 /// `coloring[v]` must be in `0..q`. The order of color bicliques is the
 /// order of first appearance of each color along `0..n`, so unused colors
@@ -227,16 +245,16 @@ impl ReduceTo<BicliqueCover> for KColoring<KN, SimpleGraph> {
 pub(crate) fn forward_witness(
     source: &KColoring<KN, SimpleGraph>,
     coloring: &[usize],
-) -> Vec<usize> {
+) -> Vec<Vec<bool>> {
     let n = source.graph().num_vertices();
-    let q = source.num_colors();
+    let q = source.num_colors().min(n);
     let k = n + q;
     let left_size = 2 * n;
     let num_vertices = 4 * n;
-    let mut config = vec![0usize; num_vertices * k];
+    let mut config = vec![vec![false; num_vertices]; k];
 
-    let set_member = |config: &mut Vec<usize>, vertex: usize, biclique: usize| {
-        config[vertex * k + biclique] = 1;
+    let set_member = |config: &mut Vec<Vec<bool>>, vertex: usize, biclique: usize| {
+        config[biclique][vertex] = true;
     };
 
     // Edge-membership lookup for source edges (undirected).
@@ -300,8 +318,9 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, BicliqueCover>(
                 source,
                 SolutionPair {
-                    source_config: coloring,
-                    target_config,
+                    source_config: serde_json::json!(coloring),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/kcoloring_casts.rs b/src/rules/kcoloring_casts.rs
index 800584dcf..15b848cee 100644
--- a/src/rules/kcoloring_casts.rs
+++ b/src/rules/kcoloring_casts.rs
@@ -1,4 +1,4 @@
-//! Variant cast reductions for KColoring.
+//! Variant reductions for KColoring.
 
 use crate::impl_variant_reduction;
 use crate::models::graph::KColoring;
@@ -8,6 +8,7 @@ use crate::variant::{K3, KN};
 impl_variant_reduction!(
     KColoring,
     <K3, SimpleGraph> => <KN, SimpleGraph>,
-    fields: [num_vertices, num_edges],
+    fields: [num_vertices, num_edges, num_colors],
+    aggregate: identity,
     |src| KColoring::with_k(src.graph().clone(), src.num_colors())
 );
diff --git a/src/rules/kcoloring_clustering.rs b/src/rules/kcoloring_clustering.rs
index 3ce0ef69e..6311eb3af 100644
--- a/src/rules/kcoloring_clustering.rs
+++ b/src/rules/kcoloring_clustering.rs
@@ -28,12 +28,17 @@ impl ReductionResult for ReductionKColoringToClustering {
 
     /// Cluster labels are color labels. The empty-graph corner case uses one
     /// dummy target element because Clustering forbids empty instances.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.source_num_vertices.min(target_solution.len())].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.source_num_vertices].to_vec())
     }
 }
 
-fn build_distances(graph: &SimpleGraph) -> Vec<Vec<u64>> {
+fn build_distances(graph: &SimpleGraph) -> Vec<Vec<i64>> {
     let n = graph.num_vertices();
     if n == 0 {
         return vec![vec![0]];
@@ -47,17 +52,20 @@ fn build_distances(graph: &SimpleGraph) -> Vec<Vec<u64>> {
     distances
 }
 
-#[reduction(overhead = {
-    num_elements = "num_vertices",
-})]
+#[reduction(
+    transform = exact {
+        num_elements = "num_vertices",
+        num_clusters = "num_colors",
+    }
+)]
 impl ReduceTo<Clustering> for KColoring<K3, SimpleGraph> {
     type Result = ReductionKColoringToClustering;
 
-    fn reduce_to(&self) -> Self::Result {
-        ReductionKColoringToClustering {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(ReductionKColoringToClustering {
             target: Clustering::new(build_distances(self.graph()), self.num_colors(), 0),
             source_num_vertices: self.graph().num_vertices(),
-        }
+        })
     }
 }
 
@@ -72,8 +80,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, Clustering>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 0, 1, 2],
-                    target_config: vec![0, 1, 0, 1, 2],
+                    source_config: serde_json::json!(vec![0, 1, 0, 1, 2]),
+                    target_config: serde_json::json!(vec![0, 1, 0, 1, 2]),
                 },
             )
         },
diff --git a/src/rules/kcoloring_partitionintocliques.rs b/src/rules/kcoloring_partitionintocliques.rs
index 081a0d82c..bb3dd69bd 100644
--- a/src/rules/kcoloring_partitionintocliques.rs
+++ b/src/rules/kcoloring_partitionintocliques.rs
@@ -25,13 +25,18 @@ impl ReductionResult for ReductionKColoringToPartitionIntoCliques {
     }
 
     /// Solution extraction is the identity: color classes become clique classes.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_vertices * (num_vertices - 1) / 2 - num_edges",
     }
@@ -39,12 +44,12 @@ impl ReductionResult for ReductionKColoringToPartitionIntoCliques {
 impl ReduceTo<PartitionIntoCliques<SimpleGraph>> for KColoring<KN, SimpleGraph> {
     type Result = ReductionKColoringToPartitionIntoCliques;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let target = PartitionIntoCliques::new(
             SimpleGraph::new(self.graph().num_vertices(), complement_edges(self.graph())),
             self.num_colors(),
         );
-        ReductionKColoringToPartitionIntoCliques { target }
+        Ok(ReductionKColoringToPartitionIntoCliques { target })
     }
 }
 
@@ -65,8 +70,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0, 2],
-                    target_config: vec![0, 1, 1, 0, 2],
+                    source_config: serde_json::json!(vec![0, 1, 1, 0, 2]),
+                    target_config: serde_json::json!(vec![0, 1, 1, 0, 2]),
                 },
             )
         },
diff --git a/src/rules/kcoloring_twodimensionalconsecutivesets.rs b/src/rules/kcoloring_twodimensionalconsecutivesets.rs
index 18fd9575e..da2a2318e 100644
--- a/src/rules/kcoloring_twodimensionalconsecutivesets.rs
+++ b/src/rules/kcoloring_twodimensionalconsecutivesets.rs
@@ -5,10 +5,12 @@
 //! - Alphabet: V union {d_e : e in E}, size n + m
 //! - For each edge e = {u, v}, one subset {u, v, d_e} of size 3
 //!
-//! A valid 3-coloring corresponds to a partition into 3 groups where each
-//! edge-subset spans 3 consecutive groups with one element per group.
+//! A valid 3-coloring extends to at most three groups. Conversely, each edge
+//! triple spans three consecutive groups. After retaining only vertex groups,
+//! endpoint ranks differ by one or two, so rank modulo three gives a coloring.
+//! Empty sources map to a one-symbol YES instance; loops to a fixed NO instance.
 //!
-//! Reference: Garey & Johnson, Appendix A4.2, p.230 (Lipski 1977).
+//! Definition: Lipski, CSL Report T-67 (1978), Problem 5; see the paper for proof.
 
 use crate::models::graph::KColoring;
 use crate::models::set::TwoDimensionalConsecutiveSets;
@@ -39,58 +41,80 @@ impl ReductionResult for ReductionKColoringToTDCS {
     /// The first `num_vertices` symbols correspond to graph vertices,
     /// so their group assignments directly give a valid 3-coloring
     /// (after remapping to colors 0, 1, 2).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // The target solution is config[symbol] = group_index.
-        // Vertex symbols are indices 0..num_vertices.
-        // We need to remap the group indices to colors 0, 1, 2.
-        // The target may use any labels, so we compress the distinct
-        // group indices used by vertex symbols to 0..2.
-
-        let vertex_groups = &target_solution[..self.num_vertices];
-
-        // Collect distinct group indices used by vertices and map to 0..k-1
-        let mut used: Vec<usize> = vertex_groups.to_vec();
-        used.sort();
-        used.dedup();
-
-        let group_to_color: std::collections::HashMap<usize, usize> = used
-            .into_iter()
-            .enumerate()
-            .map(|(color, group)| (group, color % 3))
-            .collect();
-
-        vertex_groups.iter().map(|&g| group_to_color[&g]).collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target grouping is not a consecutive-set partition",
+            ));
+        }
+
+        Ok({
+            // The target solution is config[symbol] = group_index.
+            // Vertex symbols are indices 0..num_vertices.
+            // Removing dummy-only groups cannot increase the separation of
+            // edge endpoints: their distinct ranks differ by one or two.
+            // Taking these ranks modulo three therefore preserves every edge.
+
+            let vertex_groups = &target_solution[..self.num_vertices];
+
+            // Collect distinct group indices used by vertices and map to 0..k-1
+            let mut used: Vec<usize> = vertex_groups.to_vec();
+            used.sort();
+            used.dedup();
+
+            let group_to_color: std::collections::HashMap<usize, usize> = used
+                .into_iter()
+                .enumerate()
+                .map(|(color, group)| (group, color % 3))
+                .collect();
+
+            vertex_groups.iter().map(|&g| group_to_color[&g]).collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
-        alphabet_size = "num_vertices + num_edges",
-        num_subsets = "num_edges",
+    transform = upper_bound {
+        alphabet_size = "num_vertices + num_edges + 3",
+        num_subsets = "num_edges + 3",
     }
 )]
 impl ReduceTo<TwoDimensionalConsecutiveSets> for KColoring<K3, SimpleGraph> {
     type Result = ReductionKColoringToTDCS;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let edges: Vec<(usize, usize)> = self.graph().edges();
         let m = edges.len();
-        let alphabet_size = n + m;
-
-        // For each edge e_i = {u, v}, create subset {u, v, n + i}
-        let subsets: Vec<Vec<usize>> = edges
-            .iter()
-            .enumerate()
-            .map(|(i, &(u, v))| vec![u, v, n + i])
-            .collect();
-
-        let target = TwoDimensionalConsecutiveSets::new(alphabet_size, subsets);
-
-        ReductionKColoringToTDCS {
+        let (alphabet_size, subsets) = if edges.iter().any(|&(u, v)| u == v) {
+            // Three symbols cannot occupy pairwise consecutive distinct groups:
+            // the first and last groups are not adjacent. This is a fixed NO.
+            (3, vec![vec![0, 1], vec![1, 2], vec![0, 2]])
+        } else {
+            // Native node and edge Vec allocation bounds make n + m fit usize.
+            let alphabet_size = n + m;
+            let subsets = edges
+                .iter()
+                .enumerate()
+                .map(|(i, &(u, v))| vec![u, v, n + i])
+                .collect();
+            // The empty graph is colorable, while the target requires a
+            // positive alphabet. One unconstrained symbol preserves YES.
+            (alphabet_size.max(1), subsets)
+        };
+        let target = TwoDimensionalConsecutiveSets::try_new(alphabet_size, subsets).map_err(
+            crate::rules::ReductionError::construction::<Self, TwoDimensionalConsecutiveSets>,
+        )?;
+
+        Ok(ReductionKColoringToTDCS {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -109,7 +133,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 KColoring::<K3, _>::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (0, 2), (2, 3)]));
             let reduction = <KColoring<K3, SimpleGraph> as ReduceTo<
                 TwoDimensionalConsecutiveSets,
-            >>::reduce_to(&source);
+            >>::reduce_to(&source)
+            .expect("reduction should succeed");
             let target = reduction.target_problem();
 
             // Source coloring: 0->0, 1->1, 2->2, 3->0
@@ -124,7 +149,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
 
             // Verify the target config is valid
             assert!(
-                target.evaluate(&target_config).0,
+                target
+                    .evaluate(&target_config)
+                    .expect("canonical target evaluation must succeed")
+                    .0,
                 "canonical example target config must be valid"
             );
 
@@ -132,8 +160,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 &source,
                 target,
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/knapsack_ilp.rs b/src/rules/knapsack_ilp.rs
index 6732870ac..2601ce5f9 100644
--- a/src/rules/knapsack_ilp.rs
+++ b/src/rules/knapsack_ilp.rs
@@ -24,39 +24,46 @@ impl ReductionResult for ReductionKnapsackToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_items",
         num_constraints = "1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for Knapsack {
     type Result = ReductionKnapsackToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.num_items();
+        let weights = self.weights();
+        let values = self.values();
+        let capacity = self.capacity();
         let constraints = vec![LinearConstraint::le(
-            self.weights()
+            weights
                 .iter()
                 .enumerate()
-                .map(|(i, &weight)| (i, weight as f64))
+                .map(|(item, &weight)| (item, weight))
                 .collect(),
-            self.capacity() as f64,
+            capacity,
         )];
-        let objective = self
-            .values()
-            .iter()
-            .enumerate()
-            .map(|(i, &value)| (i, value as f64))
-            .collect();
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let objective = values.iter().copied().enumerate().collect();
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionKnapsackToILP { target }
+        Ok(ReductionKnapsackToILP { target })
     }
 }
 
@@ -70,8 +77,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 Knapsack::new(vec![1, 3, 4, 5], vec![1, 4, 5, 7], 7),
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0],
-                    target_config: vec![0, 1, 1, 0],
+                    source_config: serde_json::json!(vec![false, true, true, false]),
+                    target_config: serde_json::json!(vec![0, 1, 1, 0]),
                 },
             )
         },
diff --git a/src/rules/knapsack_qubo.rs b/src/rules/knapsack_qubo.rs
index fd8898ea2..63a0e208d 100644
--- a/src/rules/knapsack_qubo.rs
+++ b/src/rules/knapsack_qubo.rs
@@ -15,39 +15,64 @@ use crate::models::misc::Knapsack;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
+fn overflow(operation: &'static str) -> crate::rules::ReductionError {
+    crate::rules::ReductionError::integer_overflow::<Knapsack, QUBO<i64>>(operation)
+}
+
 /// Result of reducing Knapsack to QUBO.
 #[derive(Debug, Clone)]
 pub struct ReductionKnapsackToQUBO {
-    target: QUBO<f64>,
+    target: QUBO<i64>,
     num_items: usize,
 }
 
 impl ReductionResult for ReductionKnapsackToQUBO {
     type Source = Knapsack;
-    type Target = QUBO<f64>;
+    type Target = QUBO<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_items].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_items].to_vec())
     }
 }
 
-#[reduction(overhead = { num_vars = "num_items + num_slack_bits" })]
-impl ReduceTo<QUBO<f64>> for Knapsack {
+#[reduction(transform = unavailable {
+    num_vars = "the exact piecewise slack-bit count is not representable in the parameter-expression language",
+})]
+impl ReduceTo<QUBO<i64>> for Knapsack {
     type Result = ReductionKnapsackToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_items();
         let c = self.capacity();
         let b = self.num_slack_bits();
         let total = n + b;
 
         // Penalty must exceed sum of all values
-        let sum_values: i64 = self.values().iter().sum();
-        let penalty = (sum_values + 1) as f64;
+        let sum_values = self
+            .values()
+            .iter()
+            .try_fold(0_i64, |total, &value| total.checked_add(value))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<Knapsack, QUBO<i64>>(
+                    "summing item values for the QUBO penalty",
+                )
+            })?;
+        let penalty_i64 = sum_values.checked_add(1).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<Knapsack, QUBO<i64>>(
+                "incrementing the QUBO penalty",
+            )
+        })?;
+        let penalty = penalty_i64;
+        let values = self.values();
 
         // Build QUBO matrix
         // H = -sum(v_i * x_i) + P * (sum(w_i * x_i) + sum(2^j * s_j) - C)^2
@@ -65,36 +90,64 @@ impl ReduceTo<QUBO<f64>> for Knapsack {
         // Off-diagonal terms (i < j):
         //   Q[i][j] = 2P * a_i * a_j
 
-        let mut coeffs = vec![0.0f64; total];
+        let mut coeffs = vec![0_i64; total];
         for (i, coeff) in coeffs.iter_mut().enumerate().take(n) {
-            *coeff = self.weights()[i] as f64;
+            *coeff = self.weights()[i];
         }
         for j in 0..b {
-            coeffs[n + j] = (1u64 << j) as f64;
+            let bit = u32::try_from(j).map_err(|_| {
+                crate::rules::ReductionError::invalid_target::<Knapsack, QUBO<i64>>(
+                    "slack-bit index does not fit u32",
+                )
+            })?;
+            let weight = 1_i64.checked_shl(bit).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<Knapsack, QUBO<i64>>(
+                    "constructing a slack-bit weight",
+                )
+            })?;
+            coeffs[n + j] = weight;
         }
 
-        let c_f = c as f64;
-        let mut matrix = vec![vec![0.0f64; total]; total];
+        let mut matrix = vec![vec![0_i64; total]; total];
 
         // Diagonal: P * a_k^2 - 2P * C * a_k - v_k (for items)
         for k in 0..total {
-            matrix[k][k] = penalty * coeffs[k] * coeffs[k] - 2.0 * penalty * c_f * coeffs[k];
+            let square = penalty
+                .checked_mul(coeffs[k])
+                .and_then(|value| value.checked_mul(coeffs[k]))
+                .ok_or_else(|| overflow("computing a knapsack QUBO square penalty"))?;
+            let linear = penalty
+                .checked_mul(c)
+                .and_then(|value| value.checked_mul(coeffs[k]))
+                .and_then(|value| value.checked_mul(2))
+                .ok_or_else(|| overflow("computing a knapsack QUBO linear penalty"))?;
+            matrix[k][k] = square
+                .checked_sub(linear)
+                .ok_or_else(|| overflow("combining knapsack QUBO diagonal penalties"))?;
             if k < n {
-                matrix[k][k] -= self.values()[k] as f64;
+                matrix[k][k] = matrix[k][k]
+                    .checked_sub(values[k])
+                    .ok_or_else(|| overflow("adding a knapsack value to the QUBO objective"))?;
             }
         }
 
         // Off-diagonal (upper triangular): 2P * a_i * a_j
         for i in 0..total {
             for j in (i + 1)..total {
-                matrix[i][j] = 2.0 * penalty * coeffs[i] * coeffs[j];
+                matrix[i][j] = penalty
+                    .checked_mul(coeffs[i])
+                    .and_then(|value| value.checked_mul(coeffs[j]))
+                    .and_then(|value| value.checked_mul(2))
+                    .ok_or_else(|| overflow("computing a knapsack QUBO interaction"))?;
             }
         }
 
-        ReductionKnapsackToQUBO {
-            target: QUBO::from_matrix(matrix),
+        Ok(ReductionKnapsackToQUBO {
+            target: QUBO::from_matrix(matrix).map_err(|message| {
+                crate::rules::ReductionError::construction::<Knapsack, QUBO<i64>>(message)
+            })?,
             num_items: n,
-        }
+        })
     }
 }
 
@@ -105,11 +158,13 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "knapsack_to_qubo",
         build: || {
-            crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
+            crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
                 Knapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], 7),
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1],
-                    target_config: vec![1, 0, 0, 1, 0, 0, 0],
+                    source_config: serde_json::json!(vec![true, false, false, true]),
+                    target_config: serde_json::json!(vec![
+                        true, false, false, true, false, false, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_acyclicpartition.rs b/src/rules/ksatisfiability_acyclicpartition.rs
index 6e747aa60..257516807 100644
--- a/src/rules/ksatisfiability_acyclicpartition.rs
+++ b/src/rules/ksatisfiability_acyclicpartition.rs
@@ -1,177 +1,165 @@
-//! Reduction from KSatisfiability (3-SAT) to AcyclicPartition.
+//! 3-SAT to the bounded-weight quotient-DAG partition problem.
 //!
-//! The repository's `AcyclicPartition` model is the weighted quotient-DAG
-//! partition problem, not the "partition vertices into two induced acyclic
-//! subgraphs" variant described in issue #247. The implemented rule therefore
-//! uses a witness-preserving composition:
-//! 3-SAT -> SubsetSum -> Partition -> AcyclicPartition.
+//! Compose the formal SAT-to-clique reduction with an incidence construction.
+//! Unit vertex/edge items encode a clique under a cardinality bound. Two heavy
+//! anchors and polynomial arc costs force exactly two blocks and encode the
+//! incidence closure and clique-size inequalities, without digit-encoded weights.
 
 use crate::models::formula::KSatisfiability;
-use crate::models::graph::AcyclicPartition;
-use crate::models::misc::{Partition, SubsetSum};
+use crate::models::graph::{AcyclicPartition, KClique};
 use crate::reduction;
-use crate::rules::ksatisfiability_subsetsum::Reduction3SATToSubsetSum;
-use crate::rules::subsetsum_partition::ReductionSubsetSumToPartition;
+use crate::rules::ksatisfiability_kclique::Reduction3SATToKClique;
 use crate::rules::traits::{ReduceTo, ReductionResult};
-use crate::topology::DirectedGraph;
+use crate::topology::{DirectedGraph, Graph, SimpleGraph};
 use crate::variant::K3;
 
+/// Literal-clique extraction follows the incidence partition projection.
 #[derive(Debug, Clone)]
-struct ReductionPartitionToAcyclicPartition {
-    target: AcyclicPartition<i32>,
-    source_num_elements: usize,
+pub struct Reduction3SATToAcyclicPartition {
+    sat_to_clique: Reduction3SATToKClique,
+    target: AcyclicPartition<i64>,
     source_vertex: usize,
-    sink_vertex: usize,
 }
 
-impl ReductionPartitionToAcyclicPartition {
-    fn new(source: &Partition) -> Self {
-        let num_elements = source.num_elements();
-        let source_vertex = num_elements;
-        let sink_vertex = num_elements + 1;
-        let total_sum = source.total_sum();
-
-        let arcs: Vec<(usize, usize)> = (0..num_elements)
-            .flat_map(|item| [(source_vertex, item), (item, sink_vertex)])
-            .collect();
-
-        let mut vertex_weights: Vec<i32> = source
-            .sizes()
-            .iter()
-            .copied()
-            .map(|size| {
-                let doubled = size
-                    .checked_mul(2)
-                    .expect("Partition -> AcyclicPartition item weight overflow");
-                u64_to_i32(
-                    doubled,
-                    "Partition -> AcyclicPartition requires doubled sizes to fit in i32",
-                )
-            })
-            .collect();
-
-        let endpoint_weight = total_sum
-            .checked_add(1)
-            .expect("Partition -> AcyclicPartition endpoint weight overflow");
-        let even_prefix = total_sum - (total_sum % 2);
-        let weight_bound = endpoint_weight
-            .checked_add(even_prefix)
-            .expect("Partition -> AcyclicPartition weight bound overflow");
-
-        vertex_weights.push(u64_to_i32(
-            endpoint_weight,
-            "Partition -> AcyclicPartition requires endpoint weight to fit in i32",
-        ));
-        vertex_weights.push(u64_to_i32(
-            endpoint_weight,
-            "Partition -> AcyclicPartition requires endpoint weight to fit in i32",
-        ));
-
-        let arc_costs = vec![1; arcs.len()];
-        let target = AcyclicPartition::new(
-            DirectedGraph::new(num_elements + 2, arcs),
-            vertex_weights,
-            arc_costs,
-            u64_to_i32(
-                weight_bound,
-                "Partition -> AcyclicPartition requires weight bound to fit in i32",
-            ),
-            usize_to_i32(
-                num_elements,
-                "Partition -> AcyclicPartition requires num_elements to fit in i32",
-            ),
-        );
-
-        Self {
-            target,
-            source_num_elements: num_elements,
-            source_vertex,
-            sink_vertex,
-        }
-    }
-}
-
-impl ReductionResult for ReductionPartitionToAcyclicPartition {
-    type Source = Partition;
-    type Target = AcyclicPartition<i32>;
+impl ReductionResult for Reduction3SATToAcyclicPartition {
+    type Source = KSatisfiability<K3>;
+    type Target = AcyclicPartition<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        if target_solution.len() != self.source_num_elements + 2 {
-            return vec![0; self.source_num_elements];
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        if !crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?
+            .0
+        {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target partition does not satisfy the acyclic partition constraints",
+            ));
         }
-
         let source_label = target_solution[self.source_vertex];
-        let sink_label = target_solution[self.sink_vertex];
-        debug_assert_ne!(
-            source_label, sink_label,
-            "valid target witnesses must place source and sink in different blocks"
-        );
-
-        (0..self.source_num_elements)
-            .map(|item| usize::from(target_solution[item] == sink_label))
-            .collect()
-    }
-}
-
-/// Result of reducing KSatisfiability<K3> to AcyclicPartition<i32>.
-#[derive(Debug, Clone)]
-pub struct Reduction3SATToAcyclicPartition {
-    sat_to_subset: Reduction3SATToSubsetSum,
-    subset_to_partition: ReductionSubsetSumToPartition,
-    partition_to_acyclic: ReductionPartitionToAcyclicPartition,
-}
-
-impl ReductionResult for Reduction3SATToAcyclicPartition {
-    type Source = KSatisfiability<K3>;
-    type Target = AcyclicPartition<i32>;
-
-    fn target_problem(&self) -> &Self::Target {
-        self.partition_to_acyclic.target_problem()
-    }
-
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let partition_solution = self.partition_to_acyclic.extract_solution(target_solution);
-        let subset_solution = self
-            .subset_to_partition
-            .extract_solution(&partition_solution);
-        self.sat_to_subset.extract_solution(&subset_solution)
+        let selected = target_solution[..self.sat_to_clique.target_problem().num_vertices()]
+            .iter()
+            .map(|&label| label == source_label)
+            .collect();
+        self.sat_to_clique.extract_solution(&selected)
     }
 }
 
-fn u64_to_i32(value: u64, context: &str) -> i32 {
-    i32::try_from(value).expect(context)
-}
-
-fn usize_to_i32(value: usize, context: &str) -> i32 {
-    i32::try_from(value).expect(context)
-}
-
 #[reduction(
-    overhead = {
-        num_vertices = "2 * num_vars + 2 * num_clauses + 3",
-        num_arcs = "4 * num_vars + 4 * num_clauses + 2",
+    transform = upper_bound {
+        num_vertices = "(9 * num_clauses^2 + 3 * num_clauses + 6) / 2",
+        num_arcs = "18 * num_clauses^2 + 2",
     }
 )]
-impl ReduceTo<AcyclicPartition<i32>> for KSatisfiability<K3> {
+impl ReduceTo<AcyclicPartition<i64>> for KSatisfiability<K3> {
     type Result = Reduction3SATToAcyclicPartition;
 
-    fn reduce_to(&self) -> Self::Result {
-        let sat_to_subset = <KSatisfiability<K3> as ReduceTo<SubsetSum>>::reduce_to(self);
-        let subset_to_partition =
-            <SubsetSum as ReduceTo<Partition>>::reduce_to(sat_to_subset.target_problem());
-        let partition_to_acyclic =
-            ReductionPartitionToAcyclicPartition::new(subset_to_partition.target_problem());
-
-        Reduction3SATToAcyclicPartition {
-            sat_to_subset,
-            subset_to_partition,
-            partition_to_acyclic,
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let sat_to_clique = ReduceTo::<KClique<SimpleGraph>>::reduce_to(self)?;
+        let clique = sat_to_clique.target_problem();
+        let n = clique.num_vertices();
+        let edges = clique.graph().edges();
+        let e = edges.len();
+        let (target_n, arc_count, capacity, magnitude, weight_bound, cost_bound) =
+            incidence_parameters(n, e, clique.k())?;
+        let items = target_n - 2;
+        let source_vertex = items;
+        let sink_vertex = items + 1;
+        let mut degree = vec![0i64; n];
+        for &(u, v) in &edges {
+            // Degree <= e, whose doubled value fits the checked magnitude.
+            degree[u] += 1;
+            degree[v] += 1;
+        }
+        let mut arcs = Vec::with_capacity(arc_count);
+        let mut arc_costs = Vec::with_capacity(arc_count);
+        let profits = degree
+            .iter()
+            .map(|&d| d + 1)
+            .chain(std::iter::repeat_n(0, e));
+        for (item, profit) in profits.enumerate() {
+            arcs.push((source_vertex, item));
+            arc_costs.push(magnitude);
+            arcs.push((item, sink_vertex));
+            arc_costs.push(magnitude - profit);
+        }
+        for (j, &(u, v)) in edges.iter().enumerate() {
+            arcs.push((u, n + j));
+            arc_costs.push(1);
+            arcs.push((v, n + j));
+            arc_costs.push(1);
         }
+        let mut weights = vec![1; items];
+        weights.push(weight_bound - capacity);
+        weights.push(
+            weight_bound
+                - <Self as ReduceTo<AcyclicPartition<i64>>>::exact_i64(
+                    items,
+                    "representing incidence item count",
+                )?,
+        );
+        let target = AcyclicPartition::new(
+            DirectedGraph::new(target_n, arcs),
+            weights,
+            arc_costs,
+            weight_bound,
+            cost_bound,
+        );
+        Ok(Reduction3SATToAcyclicPartition {
+            sat_to_clique,
+            target,
+            source_vertex,
+        })
+    }
+}
+
+/// All values use polynomial-size counts; check them before graph allocation.
+fn incidence_parameters(
+    n: usize,
+    e: usize,
+    k: usize,
+) -> Result<(usize, usize, i64, i64, i64, i64), crate::rules::ReductionError> {
+    type Source = KSatisfiability<K3>;
+    type Target = AcyclicPartition<i64>;
+    let overflow = || {
+        crate::rules::ReductionError::integer_overflow::<Source, Target>(
+            "encoding clique incidence partition parameters",
+        )
+    };
+    let items = n.checked_add(e).ok_or_else(overflow)?;
+    let target_n = items.checked_add(2).ok_or_else(overflow)?;
+    let arcs = items
+        .checked_add(e)
+        .and_then(|x| x.checked_mul(2))
+        .ok_or_else(overflow)?;
+    let l = i64::try_from(items).map_err(|_| overflow())?;
+    let k = i64::try_from(k).map_err(|_| overflow())?;
+    let next = k.checked_add(1).ok_or_else(overflow)?;
+    let capacity = if k % 2 == 0 {
+        (k / 2).checked_mul(next)
+    } else {
+        k.checked_mul(next / 2)
     }
+    .ok_or_else(overflow)?;
+    let magnitude = l
+        .checked_mul(2)
+        .and_then(|x| x.checked_add(1))
+        .ok_or_else(overflow)?;
+    let bound = l
+        .checked_add(capacity)
+        .and_then(|x| x.checked_mul(2))
+        .and_then(|x| x.checked_add(1))
+        .ok_or_else(overflow)?;
+    let square = k.checked_mul(k).ok_or_else(overflow)?;
+    let cost_bound = magnitude
+        .checked_mul(l)
+        .and_then(|x| x.checked_sub(square))
+        .ok_or_else(overflow)?;
+    Ok((target_n, arcs, capacity, magnitude, bound, cost_bound))
 }
 
 #[cfg(feature = "example-db")]
@@ -182,11 +170,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "ksatisfiability_to_acyclicpartition",
         build: || {
-            crate::example_db::specs::rule_example_with_witness::<_, AcyclicPartition<i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, AcyclicPartition<i64>>(
                 KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1, 1, 1])]),
                 SolutionPair {
-                    source_config: vec![1],
-                    target_config: vec![1, 0, 1, 1, 0, 0, 1],
+                    source_config: serde_json::json!(vec![true]),
+                    target_config: serde_json::json!(vec![0, 1, 1, 0, 0, 1, 1, 0, 1]),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_bicliquecover.rs b/src/rules/ksatisfiability_bicliquecover.rs
index 9e01fc831..5caf355a0 100644
--- a/src/rules/ksatisfiability_bicliquecover.rs
+++ b/src/rules/ksatisfiability_bicliquecover.rs
@@ -4,7 +4,10 @@
 //! Theorem 6 and Section 3). The reduction has two stages:
 //!
 //! 1. **Normalize** the source 3-CNF formula:
-//!    - For each original variable `x_i`, create two normalized variables
+//!    - Compact the variables appearing in clauses, retaining the inverse map.
+//!      Repeat literals to pad nonempty short clauses to three positions.
+//!      Empty formulas and empty clauses map to fixed YES and NO targets.
+//!    - For each appearing variable `x_i`, create two normalized variables
 //!      `t_i` and `f_i`. Replace literal `x_i` by `t_i`, replace literal
 //!      `¬x_i` by `f_i`. Add exactly-one clauses
 //!      `(t_i ∨ f_i ∨ f_i)` and `(¬t_i ∨ ¬f_i ∨ ¬f_i)` so that any
@@ -53,15 +56,15 @@ use std::collections::BTreeSet;
 /// Result of reducing KSatisfiability/K3 to BicliqueCover.
 ///
 /// Carries the normalization metadata needed for solution extraction:
-/// the source variable count, the number of normalized variables, and
-/// the offset of the `H` vertex block inside the bipartite gadget.
+/// the source variable count, the inverse map of appearing variables, and
+/// the important anchor used to locate the assignment biclique.
 #[derive(Debug, Clone)]
 pub struct ReductionKSatisfiabilityToBicliqueCover {
     target: BicliqueCover,
     /// Number of variables in the source 3-CNF formula.
     source_num_vars: usize,
     /// Number of normalized variables `n = 2^ell` (a power of two and
-    /// at least `2 * source_num_vars`).
+    /// at least twice the number of appearing variables). Zero for sentinels.
     normalized_n: usize,
     /// Bipartite-local offset of the `S_1` block on the left side.
     /// Used to locate vertex `s_11^u` for B_1 identification.
@@ -69,13 +72,9 @@ pub struct ReductionKSatisfiabilityToBicliqueCover {
     /// Bipartite-local offset of the `S_1` block on the right side.
     /// Used to locate vertex `s_11^v` for B_1 identification.
     s1_right_offset: usize,
-    /// Bipartite-local offset of the `Y` block on the left side.
-    /// Used to skip free-edge bicliques during extraction.
-    y_left_offset: usize,
-    /// Bipartite-local offset of the `Y` block on the right side.
-    y_right_offset: usize,
-    /// Number of free-edge bicliques `k_f`.
-    k_f: usize,
+    /// Original zero-based indices of the variables used by the formula,
+    /// in the order of their compact normalized pairs.
+    source_variables: Vec<usize>,
 }
 
 impl ReductionResult for ReductionKSatisfiabilityToBicliqueCover {
@@ -86,84 +85,47 @@ impl ReductionResult for ReductionKSatisfiabilityToBicliqueCover {
         &self.target
     }
 
-    /// Recover a source assignment from a BicliqueCover witness.
-    ///
-    /// 1. Ignore bicliques that cover the `Y` matching edges — these are
-    ///    the `k_f` free-edge bicliques fixed by Lemma 17.
-    /// 2. Identify `B_1` as a biclique containing both `s_11^u` and
-    ///    `s_11^v`, but no `y_r^u` or `y_r^v` (so it is an
-    ///    important-edge biclique).
-    /// 3. For each normalized variable `i`, set the normalized
-    ///    `t_i = true` iff `h_i^u ∈ B_1`.
-    /// 4. Map normalized variables back to source variables by reading
-    ///    each original `t_i`.
-    ///
-    /// If no qualifying `B_1` is found (e.g. the witness is invalid),
-    /// the extracted assignment defaults to all-false.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.normalized_n;
-        let left_size = self.target.left_size();
-        let k = self.target.k();
-
-        // Unified-vertex helpers for the named gadget anchors.
-        let s11_u = self.s1_left_offset; // s_{1,1}^u
-        let s11_v = left_size + self.s1_right_offset; // s_{1,1}^v
-        let h_left = |i: usize| -> usize { i }; // h_i^u (i in 0..n)
-        let y_left = |r: usize| -> usize { self.y_left_offset + r };
-        let y_right = |r: usize| -> usize { left_size + self.y_right_offset + r };
-
-        // Find a biclique containing both s_11^u and s_11^v, but no
-        // Y-matching vertex. By Lemma 17, free-edge bicliques touch the
-        // Y matching; the important-edge biclique B_1 does not.
-        let mut b1_index: Option<usize> = None;
-        for r in 0..k {
-            let in_b1 = |vertex: usize| -> bool {
-                target_solution.get(vertex * k + r).copied().unwrap_or(0) == 1
-            };
-            if !in_b1(s11_u) || !in_b1(s11_v) {
-                continue;
-            }
-            // Reject bicliques that touch the Y matching on either side.
-            let touches_y = (0..self.k_f).any(|r_y| in_b1(y_left(r_y)) || in_b1(y_right(r_y)));
-            if touches_y {
-                continue;
-            }
-            b1_index = Some(r);
-            break;
+    /// Recover an assignment from any feasible cover, independently of row order.
+    /// The rank budget forces a unique row covering the first domino anchor.
+    /// Its left crown memberships give the normalized truth assignment.
+    /// Map appearing variables back to their original indices and assign false
+    /// to variables absent from the formula. Infeasible covers are rejected.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if value.0.is_none() {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target configuration is not a biclique cover",
+            ));
         }
-
-        // Read off normalized assignment: t_i = (h_i^u in B_1) for i in 0..n.
-        let mut normalized_assignment = vec![false; n];
-        if let Some(r) = b1_index {
-            for (i, slot) in normalized_assignment.iter_mut().enumerate() {
-                *slot = target_solution.get(h_left(i) * k + r).copied().unwrap_or(0) == 1;
-            }
+        // Variables absent from every clause may be assigned false.
+        // This also defines the inverse map for the empty-formula YES target.
+        let mut source_assignment = vec![false; self.source_num_vars];
+        if self.source_variables.is_empty() {
+            return Ok(source_assignment);
         }
-
-        // Map normalized t_i back to the source: source x_s = t_s
-        // (with s in 1..=source_num_vars). t_s sits at normalized index
-        // 2 * (s - 1).
-        let mut source_assignment = vec![0usize; self.source_num_vars];
-        for (s, slot) in source_assignment.iter_mut().enumerate() {
-            let t_idx = 2 * s;
-            *slot = if normalized_assignment.get(t_idx).copied().unwrap_or(false) {
-                1
-            } else {
-                0
-            };
+        let s11_u = self.s1_left_offset;
+        let s11_v = self.target.left_size() + self.s1_right_offset;
+        // The Y matching and the important induced matching use the entire
+        // rank budget. Exactly one row covers this important anchor edge.
+        let b1_index = target_solution
+            .iter()
+            .position(|row| row[s11_u] && row[s11_v]);
+
+        let b1_index = b1_index.ok_or_else(|| {
+            crate::rules::ExtractionError::invalid(
+                "target configuration has no important-edge biclique B_1",
+            )
+        })?;
+        // Pair i corresponds to source_variables[i]; its t variable is 2*i.
+        for (i, &source_index) in self.source_variables.iter().enumerate() {
+            source_assignment[source_index] = target_solution[b1_index][2 * i];
         }
-        source_assignment
-    }
-}
-
-/// Smallest power of two greater than or equal to `n`. Returns at least
-/// `1` (so `next_power_of_two(0) == 1`).
-fn next_power_of_two_at_least(n: usize) -> usize {
-    let mut p = 1usize;
-    while p < n {
-        p *= 2;
+        Ok(source_assignment)
     }
-    p
 }
 
 /// `ceil(log2(m))` with the convention `ceil_log2(0) = ceil_log2(1) = 0`.
@@ -180,97 +142,184 @@ fn ceil_log2(m: usize) -> usize {
     bits
 }
 
-/// Build the normalized 3-CNF formula from a source formula.
+/// Normalize the appearing variables of a source formula to balanced 3-CNF.
 ///
 /// Returns `(n, normalized_clauses)` where `n` is a power of two
 /// (the normalized variable count). Normalized clauses use signed
 /// integer literals with the convention:
 ///
-/// - `t_i` is normalized variable `2*(i-1)` (0-indexed); 1-indexed literal `2i-1`.
-/// - `f_i` is normalized variable `2*(i-1) + 1` (0-indexed); 1-indexed literal `2i`.
+/// - Compact variable `i` has `t_i` at index `2*(i-1)` and `f_i` at `2*i-1`.
+/// - `source_variables` records the original zero-based index of each pair.
 ///
-/// For each source variable `i` in `1..=source_num_vars` and each padded
+/// For each appearing variable and each padded
 /// dummy variable, two exactly-one clauses are appended.
-fn normalize(source: &KSatisfiability<K3>) -> (usize, Vec<Vec<i32>>) {
-    let s = source.num_vars();
+fn normalize(
+    source: &KSatisfiability<K3>,
+    source_variables: &[usize],
+) -> Result<(usize, Vec<Vec<i64>>), crate::rules::ReductionError> {
+    let overflow = |operation| {
+        crate::rules::ReductionError::integer_overflow::<KSatisfiability<K3>, BicliqueCover>(
+            operation,
+        )
+    };
+    let s = source_variables.len();
     // Padded source-variable count `s_pad` so that `2 * s_pad` is a
     // power of two.
-    let s_pad = next_power_of_two_at_least(s.max(1));
-    let n = 2 * s_pad;
-
-    let t_lit = |i_one_indexed: usize| -> i32 { (2 * i_one_indexed - 1) as i32 };
-    let f_lit = |i_one_indexed: usize| -> i32 { (2 * i_one_indexed) as i32 };
+    let s_pad = s
+        .max(1)
+        .checked_next_power_of_two()
+        .ok_or_else(|| overflow("padding the normalized variable count to a power of two"))?;
+    let n = s_pad
+        .checked_mul(2)
+        .ok_or_else(|| overflow("doubling the normalized variable count"))?;
+
+    let f_lit = |i_one_indexed: usize| {
+        i_one_indexed
+            .checked_mul(2)
+            .and_then(|literal| i64::try_from(literal).ok())
+            .ok_or_else(|| overflow("encoding a normalized SAT literal"))
+    };
+    let t_lit = |i_one_indexed: usize| {
+        f_lit(i_one_indexed)?
+            .checked_sub(1)
+            .ok_or_else(|| overflow("encoding a normalized SAT literal"))
+    };
 
-    let mut clauses: Vec<Vec<i32>> = Vec::new();
+    let mut clauses: Vec<Vec<i64>> = Vec::new();
 
     // 1. Translate source clauses: x_i -> t_i, ¬x_i -> f_i.
     //    Both replacements use positive normalized literals; the
     //    exactly-one clauses below tie t_i and f_i to opposite truth
     //    values in any satisfying assignment.
     for clause in source.clauses() {
-        let mut translated: Vec<i32> = Vec::with_capacity(clause.literals.len());
+        let mut translated: Vec<i64> = Vec::with_capacity(clause.literals.len());
         for &lit in &clause.literals {
-            let var = lit.unsigned_abs() as usize; // 1-indexed source var
+            let var = usize::try_from(lit.unsigned_abs())
+                .expect("SAT construction validates literal indices against usize");
+            let compact = source_variables
+                .binary_search(&(var - 1))
+                .expect("every source literal has a collected variable")
+                + 1;
             if lit > 0 {
-                translated.push(t_lit(var));
+                translated.push(t_lit(compact)?);
             } else {
-                translated.push(f_lit(var));
+                translated.push(f_lit(compact)?);
             }
         }
+        // Nonempty short clauses are equivalent after repeating a literal.
+        // Empty clauses are handled by the fixed NO construction before here.
+        translated.resize(3, translated[0]);
         clauses.push(translated);
     }
 
     // 2. Exactly-one clauses for each (real or dummy) normalized pair.
     //    (t_i ∨ f_i ∨ f_i) and (¬t_i ∨ ¬f_i ∨ ¬f_i).
     for i in 1..=s_pad {
-        let t = t_lit(i);
-        let f = f_lit(i);
+        let t = t_lit(i)?;
+        let f = f_lit(i)?;
         clauses.push(vec![t, f, f]);
         clauses.push(vec![-t, -f, -f]);
     }
 
-    (n, clauses)
+    Ok((n, clauses))
 }
 
 /// Compute `k_f = 4*ell + 2*ceil(log2 m) + 6` for the normalized formula.
-fn free_edge_budget(ell: usize, m: usize) -> usize {
-    4 * ell + 2 * ceil_log2(m) + 6
+fn free_edge_budget(ell: usize, m: usize) -> Option<usize> {
+    ell.checked_mul(4)?
+        .checked_add(ceil_log2(m).checked_mul(2)?)?
+        .checked_add(6)
 }
 
-// Overhead expressions are upper bounds in terms of source counts.
-// After normalization, `n ≤ 4·num_vars` (next power of two of `2·num_vars`)
-// and `m ≤ num_clauses + n ≤ num_clauses + 4·num_vars`. With
-// `ell = log2 n ≤ 2 + log2(num_vars)` we use the coarser bound
-// `ell ≤ num_vars` and `ceil(log2 m) ≤ num_clauses + 4·num_vars`,
-// giving the polynomial bounds below. Edges are bounded by
-// `partition_size^2` which is `O((num_vars + num_clauses)^2)`.
+// With s source variables and m source clauses, the normalized counts
+// satisfy n <= 4(s+1), M <= m+4(s+1), ell <= s+1, ceil(log2 M) <= M.
+// Hence each partition is <= 31s+5m+39 and rank <= 14s+2m+22.
+// The declared coarser bounds also cover the fixed YES and NO targets.
 #[reduction(
-    overhead = {
-        num_vertices = "32 * num_vars + 24 * num_clauses + 100",
-        num_edges = "(32 * num_vars + 24 * num_clauses + 100) * (32 * num_vars + 24 * num_clauses + 100)",
-        rank = "10 * num_vars + 4 * num_clauses + 20",
+    transform = upper_bound {
+        left_size = "32 * num_vars + 8 * num_clauses + 48",
+        right_size = "32 * num_vars + 8 * num_clauses + 48",
+        num_vertices = "64 * num_vars + 16 * num_clauses + 96",
+        num_edges = "(32 * num_vars + 8 * num_clauses + 48)^2",
+        rank = "16 * num_vars + 4 * num_clauses + 32",
     }
 )]
 impl ReduceTo<BicliqueCover> for KSatisfiability<K3> {
     type Result = ReductionKSatisfiabilityToBicliqueCover;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         // ---------------- Stage 1: normalize ----------------
         let source_num_vars = self.num_vars();
-        let (n, normalized_clauses) = normalize(self);
+        let has_empty_clause = self
+            .clauses()
+            .iter()
+            .any(|clause| clause.literals.is_empty());
+        if has_empty_clause || self.clauses().is_empty() {
+            // The empty conjunction is YES; a conjunction with an empty
+            // disjunction is NO. Zero bicliques cover only the empty graph.
+            let size = usize::from(has_empty_clause);
+            let edges = if has_empty_clause {
+                vec![(0, 0)]
+            } else {
+                vec![]
+            };
+            return Ok(ReductionKSatisfiabilityToBicliqueCover {
+                target: BicliqueCover::new(BipartiteGraph::new(size, size, edges), 0),
+                source_num_vars,
+                normalized_n: 0,
+                s1_left_offset: 0,
+                s1_right_offset: 0,
+                source_variables: vec![],
+            });
+        }
+        let source_variables: Vec<usize> = self
+            .clauses()
+            .iter()
+            .flat_map(|clause| clause.literals.iter())
+            .map(|literal| {
+                usize::try_from(literal.unsigned_abs())
+                    .expect("source construction validates literal indices")
+                    - 1
+            })
+            .collect::<BTreeSet<_>>()
+            .into_iter()
+            .collect();
+        let (n, normalized_clauses) = normalize(self, &source_variables)?;
         let ell = ceil_log2(n).max(1); // n = 2^ell; ell >= 1
         let m = normalized_clauses.len();
-        let k_f = free_edge_budget(ell, m);
-        let rank = k_f + 2 * ell + 2;
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<Self, BicliqueCover>(operation)
+        };
+        let k_f =
+            free_edge_budget(ell, m).ok_or_else(|| overflow("computing the free-edge budget"))?;
+        let twice_ell = ell
+            .checked_mul(2)
+            .ok_or_else(|| overflow("doubling the normalization exponent"))?;
+        let rank = k_f
+            .checked_add(twice_ell)
+            .and_then(|value| value.checked_add(2))
+            .ok_or_else(|| overflow("computing the biclique-cover rank"))?;
 
         // ---------------- Stage 2: assemble vertex layout ----------------
         // Bipartite-local block offsets (same on left and right partitions).
         let h_offset = 0usize;
-        let p_offset = h_offset + n;
-        let s_offset = p_offset + 3 * m;
-        let q_offset = s_offset + 3 * ell;
-        let y_offset = q_offset + 2;
-        let partition_size = y_offset + k_f;
+        let p_offset = h_offset
+            .checked_add(n)
+            .ok_or_else(|| overflow("computing the clause-block offset"))?;
+        let s_offset = m
+            .checked_mul(3)
+            .and_then(|size| p_offset.checked_add(size))
+            .ok_or_else(|| overflow("computing the domino-block offset"))?;
+        let q_offset = ell
+            .checked_mul(3)
+            .and_then(|size| s_offset.checked_add(size))
+            .ok_or_else(|| overflow("computing the guard-block offset"))?;
+        let y_offset = q_offset
+            .checked_add(2)
+            .ok_or_else(|| overflow("computing the forcing-block offset"))?;
+        let partition_size = y_offset
+            .checked_add(k_f)
+            .ok_or_else(|| overflow("computing the bipartite partition size"))?;
 
         // Coordinate helpers (bipartite-local).
         let h_left = |i: usize| -> usize { h_offset + i };
@@ -378,7 +427,8 @@ impl ReduceTo<BicliqueCover> for KSatisfiability<K3> {
         //     0-indexed var_idx = var - 1.)
         for (i, clause) in normalized_clauses.iter().enumerate() {
             for (a, &lit) in clause.iter().enumerate() {
-                let var_one_indexed = lit.unsigned_abs() as usize;
+                let var_one_indexed = usize::try_from(lit.unsigned_abs())
+                    .expect("normalized literal indices fit usize");
                 let var_zero_indexed = var_one_indexed - 1;
                 let is_positive = lit > 0;
                 for j in 0..n {
@@ -450,16 +500,14 @@ impl ReduceTo<BicliqueCover> for KSatisfiability<K3> {
         let bipartite = BipartiteGraph::new(partition_size, partition_size, edges_vec);
         let target = BicliqueCover::new(bipartite, rank);
 
-        ReductionKSatisfiabilityToBicliqueCover {
+        Ok(ReductionKSatisfiabilityToBicliqueCover {
             target,
             source_num_vars,
             normalized_n: n,
             s1_left_offset: s_offset,
             s1_right_offset: s_offset,
-            y_left_offset: y_offset,
-            y_right_offset: y_offset,
-            k_f,
-        }
+            source_variables,
+        })
     }
 }
 
@@ -488,7 +536,7 @@ fn enumerate_free_bicliques(
     n: usize,
     m: usize,
     ell: usize,
-    normalized_clauses: &[Vec<i32>],
+    normalized_clauses: &[Vec<i64>],
     h_left: &dyn Fn(usize) -> usize,
     h_right: &dyn Fn(usize) -> usize,
     p_left: &dyn Fn(usize, usize) -> usize,
@@ -610,7 +658,9 @@ fn enumerate_free_bicliques(
             }
             for (i, clause) in normalized_clauses.iter().enumerate() {
                 for (a, &lit) in clause.iter().enumerate() {
-                    let var_idx = lit.unsigned_abs() as usize - 1;
+                    let var_idx = usize::try_from(lit.unsigned_abs())
+                        .expect("normalized literal indices fit usize")
+                        - 1;
                     let is_positive = lit > 0;
                     // p_{i,a}^u h_j^v omitted only when positive literal
                     // hits j == var_idx. Include p_{i,a}^u in B_u iff
@@ -636,7 +686,9 @@ fn enumerate_free_bicliques(
             }
             for (i, clause) in normalized_clauses.iter().enumerate() {
                 for (a, &lit) in clause.iter().enumerate() {
-                    let var_idx = lit.unsigned_abs() as usize - 1;
+                    let var_idx = usize::try_from(lit.unsigned_abs())
+                        .expect("normalized literal indices fit usize")
+                        - 1;
                     let is_positive = lit > 0;
                     let var_bit_matches = ((var_idx >> bit) & 1 == 1) == invert;
                     let include = is_positive || !var_bit_matches;
@@ -680,7 +732,7 @@ fn enumerate_free_bicliques(
 /// variable, 1 source clause. After normalization the formula has
 /// `n = 2`, `ell = 1`, `m = 3` clauses, `k_f = 14`, and rank `= 18`.
 ///
-/// The witness is a vertex-major BicliqueCover configuration with
+/// The witness is a biclique-major BicliqueCover configuration with
 /// `4` important-edge bicliques (`B_1`, `B̄_1`, `B_1^g`, `B_2^g`)
 /// followed by `14` free-edge bicliques `B_r^f ∪ {y_r^u, y_r^v}`
 /// that each absorb the matching edge `y_r^u y_r^v` and the
@@ -701,23 +753,20 @@ fn enumerate_free_bicliques(
 /// - The two guard bicliques each cover one `Q` edge and one of the
 ///   two non-selected literal edges per clause; cross-pairs are P-P
 ///   and P-Q free edges.
-#[cfg(feature = "example-db")]
-fn forward_witness_single_variable_single_clause(source: &KSatisfiability<K3>) -> Vec<usize> {
-    use crate::traits::Problem;
-
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(source);
+#[cfg(any(test, feature = "example-db"))]
+fn forward_witness_single_variable_single_clause(source: &KSatisfiability<K3>) -> Vec<Vec<bool>> {
+    let reduction = ReduceTo::<BicliqueCover>::reduce_to(source).expect("reduction should succeed");
     let target = reduction.target_problem();
     let k = target.k();
     let left_size = target.left_size();
     let num_vertices = target.num_vertices();
-    let mut config = vec![0usize; num_vertices * k];
-    let _ = target.dims(); // ensure dims matches num_vertices * k
+    let mut config = vec![vec![false; num_vertices]; k];
 
     // Bipartite-local helpers, mirroring `reduce_to`.
     let n = reduction.normalized_n;
     let ell = ceil_log2(n).max(1);
     let m = 3usize; // hard-coded for the canonical case
-    let k_f = free_edge_budget(ell, m);
+    let k_f = free_edge_budget(ell, m).expect("canonical free-edge budget must fit usize");
     let h_offset = 0usize;
     let p_offset = h_offset + n;
     let s_offset = p_offset + 3 * m;
@@ -736,8 +785,8 @@ fn forward_witness_single_variable_single_clause(source: &KSatisfiability<K3>) -
     let y_left = |r: usize| y_offset + r;
     let y_right_u = |r: usize| left_size + y_offset + r;
 
-    let mark = |cfg: &mut [usize], vertex: usize, biclique: usize| {
-        cfg[vertex * k + biclique] = 1;
+    let mark = |cfg: &mut [Vec<bool>], vertex: usize, biclique: usize| {
+        cfg[biclique][vertex] = true;
     };
 
     // Biclique 0: B_1 — important.
@@ -803,7 +852,8 @@ fn forward_witness_single_variable_single_clause(source: &KSatisfiability<K3>) -
     }
 
     // Bicliques 4..(4+k_f): free-edge bicliques B_r^f ∪ {y_r^u, y_r^v}.
-    let (_, normalized_clauses) = normalize(source);
+    let (_, normalized_clauses) =
+        normalize(source, &reduction.source_variables).expect("fixture normalization must succeed");
     let free = enumerate_free_bicliques(
         n,
         m,
@@ -856,8 +906,9 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, BicliqueCover>(
                 source,
                 SolutionPair {
-                    source_config: vec![1usize], // x_1 = true
-                    target_config,
+                    source_config: serde_json::json!([true]), // x_1 = true
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_casts.rs b/src/rules/ksatisfiability_casts.rs
index e98a02a1f..659c4d5b9 100644
--- a/src/rules/ksatisfiability_casts.rs
+++ b/src/rules/ksatisfiability_casts.rs
@@ -1,4 +1,4 @@
-//! Variant cast reductions for KSatisfiability.
+//! Variant reductions for KSatisfiability.
 
 use crate::impl_variant_reduction;
 use crate::models::formula::KSatisfiability;
@@ -7,13 +7,15 @@ use crate::variant::{K2, K3, KN};
 impl_variant_reduction!(
     KSatisfiability,
     <K2> => <KN>,
-    fields: [num_vars, num_clauses],
+    fields: [num_vars, num_clauses, num_literals],
+    aggregate: identity,
     |src| KSatisfiability::new_allow_less(src.num_vars(), src.clauses().to_vec())
 );
 
 impl_variant_reduction!(
     KSatisfiability,
     <K3> => <KN>,
-    fields: [num_vars, num_clauses],
+    fields: [num_vars, num_clauses, num_literals],
+    aggregate: identity,
     |src| KSatisfiability::new_allow_less(src.num_vars(), src.clauses().to_vec())
 );
diff --git a/src/rules/ksatisfiability_cyclicordering.rs b/src/rules/ksatisfiability_cyclicordering.rs
index d56c3b49d..704a26f66 100644
--- a/src/rules/ksatisfiability_cyclicordering.rs
+++ b/src/rules/ksatisfiability_cyclicordering.rs
@@ -8,18 +8,27 @@
 //! triples enforcing that at least one literal orientation must be the
 //! "true" one.
 //!
+//! Before applying the gadget, remove tautologies and repeated literals,
+//! compact occurring variables, and expand short clauses with fresh variables.
+//! Each resulting clause has three distinct variables in global index order.
+//! This is the hypothesis needed to combine the paper's local cyclic orders.
+//! Empty clauses and empty conjunctions map to fixed NO and YES targets.
+//!
 //! Reference: Galil and Megiddo, "Cyclic ordering is NP-complete", 1977.
 
 use crate::models::formula::KSatisfiability;
 use crate::models::misc::CyclicOrdering;
 use crate::reduction;
+use crate::rules::sat_helpers::SatVariableAllocator;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::variant::K3;
+use std::collections::BTreeSet;
 
 #[derive(Debug, Clone)]
 pub struct Reduction3SATToCyclicOrdering {
     target: CyclicOrdering,
     source_num_vars: usize,
+    source_variables: Vec<usize>,
 }
 
 impl ReductionResult for Reduction3SATToCyclicOrdering {
@@ -30,17 +39,27 @@ impl ReductionResult for Reduction3SATToCyclicOrdering {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.source_num_vars)
-            .map(|var_idx| {
-                let (alpha, beta, gamma) = variable_triple(var_idx);
-                usize::from(!is_cyclic_order(
-                    target_solution[alpha],
-                    target_solution[beta],
-                    target_solution[gamma],
-                ))
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target configuration is not a feasible cyclic ordering",
+            ));
+        }
+        let mut assignment = vec![false; self.source_num_vars];
+        for (compact, &original) in self.source_variables.iter().enumerate() {
+            let (alpha, beta, gamma) = variable_triple(compact);
+            assignment[original] = !is_cyclic_order(
+                target_solution[alpha],
+                target_solution[beta],
+                target_solution[gamma],
+            );
+        }
+        Ok(assignment)
     }
 }
 
@@ -49,8 +68,10 @@ fn variable_triple(var_idx: usize) -> (usize, usize, usize) {
     (base, base + 1, base + 2)
 }
 
-fn literal_triple(literal: i32) -> (usize, usize, usize) {
-    let (alpha, beta, gamma) = variable_triple((literal.unsigned_abs() as usize) - 1);
+fn literal_triple(literal: i64) -> (usize, usize, usize) {
+    let (alpha, beta, gamma) = variable_triple(
+        usize::try_from(literal.unsigned_abs()).expect("normalized literal indices fit usize") - 1,
+    );
     if literal > 0 {
         (alpha, beta, gamma)
     } else {
@@ -63,27 +84,133 @@ fn is_cyclic_order(a: usize, b: usize, c: usize) -> bool {
     (a < b && b < c) || (b < c && c < a) || (c < a && a < b)
 }
 
+/// Three distinct, globally ordered variables per clause are required by
+/// Galil--Megiddo's simultaneous-extension argument (Corollary 2).
+struct NormalizedFormula {
+    source_variables: Vec<usize>,
+    num_vars: usize,
+    clauses: Vec<[i64; 3]>,
+}
+
+fn normalize(
+    source: &KSatisfiability<K3>,
+) -> Result<NormalizedFormula, crate::rules::ReductionError> {
+    let mut clauses = Vec::new();
+    let mut variables = BTreeSet::new();
+    for clause in source.clauses() {
+        let mut literals = clause.literals.clone();
+        literals.sort_unstable_by_key(|literal| (literal.unsigned_abs(), *literal));
+        literals.dedup();
+        if literals.windows(2).any(|pair| pair[0] == -pair[1]) {
+            continue;
+        }
+        for literal in &literals {
+            variables.insert(
+                usize::try_from(literal.unsigned_abs()).expect("native SAT indices fit usize") - 1,
+            );
+        }
+        clauses.push(literals);
+    }
+    let source_variables: Vec<_> = variables.into_iter().collect();
+    let mut variables =
+        SatVariableAllocator::new("KSatisfiability -> CyclicOrdering", source_variables.len())
+            .map_err(<KSatisfiability<K3> as ReduceTo<CyclicOrdering>>::target_construction)?;
+    let mut normalized = Vec::new();
+    for clause in clauses {
+        let literals: Vec<_> = clause
+            .iter()
+            .map(|literal| {
+                let original = usize::try_from(literal.unsigned_abs())
+                    .expect("native SAT indices fit usize")
+                    - 1;
+                let compact = source_variables
+                    .binary_search(&original)
+                    .expect("all retained variables were collected")
+                    + 1;
+                let index = i64::try_from(compact)
+                    .expect("compaction cannot increase a valid source variable index");
+                if *literal > 0 {
+                    index
+                } else {
+                    -index
+                }
+            })
+            .collect();
+        match *literals.as_slice() {
+            [a, b, c] => normalized.push([a, b, c]),
+            [a, b] => {
+                let u = variables.allocate()
+                    .map_err(<KSatisfiability<K3> as ReduceTo<CyclicOrdering>>::target_construction)?;
+                normalized.extend([[a, b, u], [a, b, -u]]);
+            }
+            [a] => {
+                let u = variables.allocate()
+                    .map_err(<KSatisfiability<K3> as ReduceTo<CyclicOrdering>>::target_construction)?;
+                let v = variables.allocate()
+                    .map_err(<KSatisfiability<K3> as ReduceTo<CyclicOrdering>>::target_construction)?;
+                normalized.extend([[a, u, v], [a, u, -v], [a, -u, v], [a, -u, -v]]);
+            }
+            _ => unreachable!("empty clauses are handled before normalization; native clauses have at most three literals"),
+        }
+    }
+    // Original compact indices precede all fresh indices. Every emitted
+    // clause is therefore already sorted by absolute variable index.
+    Ok(NormalizedFormula {
+        source_variables,
+        num_vars: variables.num_vars(),
+        clauses: normalized,
+    })
+}
+
 #[reduction(
-    overhead = {
-        num_elements = "3 * num_vars + 5 * num_clauses",
-        num_triples = "10 * num_clauses",
+    transform = upper_bound {
+        num_elements = "3 * num_vars + 26 * num_clauses + 3",
+        num_triples = "40 * num_clauses + 2",
     }
 )]
 impl ReduceTo<CyclicOrdering> for KSatisfiability<K3> {
     type Result = Reduction3SATToCyclicOrdering;
 
-    fn reduce_to(&self) -> Self::Result {
-        let num_vars = self.num_vars();
-        let num_clauses = self.num_clauses();
-        let num_elements = 3 * num_vars + 5 * num_clauses;
-        let mut triples = Vec::with_capacity(10 * num_clauses);
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        if self
+            .clauses()
+            .iter()
+            .any(|clause| clause.literals.is_empty())
+        {
+            return Ok(Reduction3SATToCyclicOrdering {
+                target: CyclicOrdering::try_new(3, vec![(0, 1, 2), (0, 2, 1)])
+                    .map_err(<Self as ReduceTo<CyclicOrdering>>::target_construction)?,
+                source_num_vars: self.num_vars(),
+                source_variables: Vec::new(),
+            });
+        }
+        let normalized = normalize(self)?;
+        let num_vars = normalized.num_vars;
+        let num_clauses = normalized.clauses.len();
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<Self, CyclicOrdering>(operation)
+        };
+        let variable_elements = num_vars
+            .checked_mul(3)
+            .ok_or_else(|| overflow("counting variable elements"))?;
+        let clause_elements = num_clauses
+            .checked_mul(5)
+            .ok_or_else(|| overflow("counting clause elements"))?;
+        let num_elements = variable_elements
+            .checked_add(clause_elements)
+            .ok_or_else(|| overflow("counting target elements"))?
+            .max(1);
+        let num_triples = num_clauses
+            .checked_mul(10)
+            .ok_or_else(|| overflow("counting target triples"))?;
+        let mut triples = Vec::with_capacity(num_triples);
 
-        for (clause_idx, clause) in self.clauses().iter().enumerate() {
-            let (a, b, c) = literal_triple(clause.literals[0]);
-            let (d, e, f) = literal_triple(clause.literals[1]);
-            let (g, h, i) = literal_triple(clause.literals[2]);
+        for (clause_idx, clause) in normalized.clauses.iter().enumerate() {
+            let (a, b, c) = literal_triple(clause[0]);
+            let (d, e, f) = literal_triple(clause[1]);
+            let (g, h, i) = literal_triple(clause[2]);
 
-            let base = 3 * num_vars + 5 * clause_idx;
+            let base = variable_elements + 5 * clause_idx;
             let j = base;
             let k = base + 1;
             let l = base + 2;
@@ -104,10 +231,12 @@ impl ReduceTo<CyclicOrdering> for KSatisfiability<K3> {
             ]);
         }
 
-        Reduction3SATToCyclicOrdering {
-            target: CyclicOrdering::new(num_elements, triples),
-            source_num_vars: num_vars,
-        }
+        Ok(Reduction3SATToCyclicOrdering {
+            target: CyclicOrdering::try_new(num_elements, triples)
+                .map_err(<Self as ReduceTo<CyclicOrdering>>::target_construction)?,
+            source_num_vars: self.num_vars(),
+            source_variables: normalized.source_variables,
+        })
     }
 }
 
@@ -122,8 +251,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, CyclicOrdering>(
                 KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]),
                 SolutionPair {
-                    source_config: vec![1, 1, 1],
-                    target_config: vec![0, 11, 1, 9, 12, 10, 6, 13, 7, 2, 3, 4, 8, 5],
+                    source_config: serde_json::json!(vec![true, true, true]),
+                    target_config: serde_json::json!(vec![
+                        0, 11, 1, 9, 12, 10, 6, 13, 7, 2, 3, 4, 8, 5
+                    ]),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_decisionminimumvertexcover.rs b/src/rules/ksatisfiability_decisionminimumvertexcover.rs
index 37d22483f..3bb329f47 100644
--- a/src/rules/ksatisfiability_decisionminimumvertexcover.rs
+++ b/src/rules/ksatisfiability_decisionminimumvertexcover.rs
@@ -1,7 +1,7 @@
 //! Reduction from KSatisfiability (3-SAT) to Decision Minimum Vertex Cover.
 //!
 //! This wraps the classical Garey & Johnson Theorem 3.3 construction in the
-//! `Decision<MinimumVertexCover<SimpleGraph, i32>>` wrapper, with threshold
+//! `Decision<MinimumVertexCover<SimpleGraph, i64>>` wrapper, with threshold
 //! `k = n + 2m` for `n` variables and `m` clauses.
 
 use crate::models::decision::Decision;
@@ -13,48 +13,59 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::SimpleGraph;
 use crate::variant::K3;
 
-/// Result of reducing KSatisfiability<K3> to Decision<MinimumVertexCover<SimpleGraph, i32>>.
+/// Result of reducing KSatisfiability<K3> to Decision<MinimumVertexCover<SimpleGraph, i64>>.
 #[derive(Debug, Clone)]
 pub struct Reduction3SATToDecisionMVC {
-    target: Decision<MinimumVertexCover<SimpleGraph, i32>>,
+    target: Decision<MinimumVertexCover<SimpleGraph, i64>>,
     base_reduction: Reduction3SATToMVC,
 }
 
 impl ReductionResult for Reduction3SATToDecisionMVC {
     type Source = KSatisfiability<K3>;
-    type Target = Decision<MinimumVertexCover<SimpleGraph, i32>>;
+    type Target = Decision<MinimumVertexCover<SimpleGraph, i64>>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
         self.base_reduction.extract_solution(target_solution)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "2 * num_vars + 3 * num_clauses",
         num_edges = "num_vars + 6 * num_clauses",
-        k = "num_vars + 2 * num_clauses",
     }
 )]
-impl ReduceTo<Decision<MinimumVertexCover<SimpleGraph, i32>>> for KSatisfiability<K3> {
+impl ReduceTo<Decision<MinimumVertexCover<SimpleGraph, i64>>> for KSatisfiability<K3> {
     type Result = Reduction3SATToDecisionMVC;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let base_reduction = <KSatisfiability<K3> as ReduceTo<
-            MinimumVertexCover<SimpleGraph, i32>,
-        >>::reduce_to(self);
-        let bound = i32::try_from(self.num_vars() + 2 * self.num_clauses())
-            .expect("decision minimum vertex cover bound must fit in i32");
+            MinimumVertexCover<SimpleGraph, i64>,
+        >>::reduce_to(self)?;
+        let bound = self
+            .num_clauses()
+            .checked_mul(2)
+            .and_then(|value| value.checked_add(self.num_vars()))
+            .and_then(|value| i64::try_from(value).ok())
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    KSatisfiability<K3>,
+                    Decision<MinimumVertexCover<SimpleGraph, i64>>,
+                >("computing the target cover bound")
+            })?;
         let target = Decision::new(base_reduction.target_problem().clone(), bound);
 
-        Reduction3SATToDecisionMVC {
+        Ok(Reduction3SATToDecisionMVC {
             target,
             base_reduction,
-        }
+        })
     }
 }
 
@@ -75,12 +86,14 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             );
             crate::example_db::specs::rule_example_with_witness::<
                 _,
-                Decision<MinimumVertexCover<SimpleGraph, i32>>,
+                Decision<MinimumVertexCover<SimpleGraph, i64>>,
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 1],
-                    target_config: vec![0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0],
+                    source_config: serde_json::json!(vec![false, false, true]),
+                    target_config: serde_json::json!(vec![
+                        false, true, false, true, true, false, true, true, false, true, true, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_directedtwocommodityintegralflow.rs b/src/rules/ksatisfiability_directedtwocommodityintegralflow.rs
index d0cde28e5..a9e5d8bcb 100644
--- a/src/rules/ksatisfiability_directedtwocommodityintegralflow.rs
+++ b/src/rules/ksatisfiability_directedtwocommodityintegralflow.rs
@@ -61,13 +61,13 @@ pub struct Reduction3SATToDirectedTwoCommodityIntegralFlow {
     clause_sink_arcs: Vec<usize>,
 }
 
-fn literal_var_index(literal: i32) -> usize {
+fn literal_var_index(literal: i64) -> usize {
     literal.unsigned_abs() as usize - 1
 }
 
 #[cfg_attr(not(any(test, feature = "example-db")), allow(dead_code))]
-fn literal_satisfied(requires_true: bool, assignment: &[usize], variable: usize) -> bool {
-    assignment.get(variable).copied().unwrap_or(0) == usize::from(requires_true)
+fn literal_satisfied(requires_true: bool, assignment: &[bool], variable: usize) -> bool {
+    assignment.get(variable).copied().unwrap_or(false) == requires_true
 }
 
 fn build_branch<FV, FA>(
@@ -122,7 +122,7 @@ where
 
 impl Reduction3SATToDirectedTwoCommodityIntegralFlow {
     #[cfg(any(test, feature = "example-db"))]
-    pub(crate) fn encode_assignment(&self, assignment: &[usize]) -> Vec<usize> {
+    pub(crate) fn encode_assignment(&self, assignment: &[bool]) -> Vec<usize> {
         assert_eq!(
             assignment.len(),
             self.variable_paths.len(),
@@ -137,7 +137,7 @@ impl Reduction3SATToDirectedTwoCommodityIntegralFlow {
         }
 
         for (value, paths) in assignment.iter().zip(&self.variable_paths) {
-            let chosen_path = if *value == 1 {
+            let chosen_path = if *value {
                 &paths.lower_path
             } else {
                 &paths.upper_path
@@ -171,30 +171,34 @@ impl ReductionResult for Reduction3SATToDirectedTwoCommodityIntegralFlow {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.variable_paths
-            .iter()
-            .map(|paths| {
-                usize::from(
-                    target_solution
-                        .get(paths.lower_entry_arc)
-                        .copied()
-                        .unwrap_or(0)
-                        > 0,
-                )
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            self.variable_paths
+                .iter()
+                .map(|paths| target_solution[paths.lower_entry_arc] > 0)
+                .collect()
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vertices = "6 * num_vars + 2 * num_literals + num_clauses + 4",
-    num_arcs = "7 * num_vars + 4 * num_literals + num_clauses + 1",
-})]
+#[reduction(
+    transform = exact {
+        num_vertices = "6 * num_vars + 2 * num_literals + num_clauses + 4",
+        num_arcs = "7 * num_vars + 4 * num_literals + num_clauses + 1",
+    },
+    unavailable = {
+        max_capacity = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<DirectedTwoCommodityIntegralFlow> for KSatisfiability<K3> {
     type Result = Reduction3SATToDirectedTwoCommodityIntegralFlow;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let source_1 = 0usize;
         let sink_1 = 1usize;
         let source_2 = 2usize;
@@ -288,7 +292,13 @@ impl ReduceTo<DirectedTwoCommodityIntegralFlow> for KSatisfiability<K3> {
             .map(|&clause_vertex| add_arc(clause_vertex, sink_2))
             .collect();
 
-        let capacities = vec![1u64; arcs.len()];
+        let capacities = vec![1i64; arcs.len()];
+        let clause_requirement = i64::try_from(self.num_clauses()).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                KSatisfiability<K3>,
+                DirectedTwoCommodityIntegralFlow,
+            >("converting the clause count to an i64 flow requirement")
+        })?;
         let target = DirectedTwoCommodityIntegralFlow::new(
             DirectedGraph::new(next_vertex, arcs),
             capacities,
@@ -297,16 +307,16 @@ impl ReduceTo<DirectedTwoCommodityIntegralFlow> for KSatisfiability<K3> {
             source_2,
             sink_2,
             1,
-            self.num_clauses() as u64,
+            clause_requirement,
         );
 
-        Reduction3SATToDirectedTwoCommodityIntegralFlow {
+        Ok(Reduction3SATToDirectedTwoCommodityIntegralFlow {
             target,
             commodity_1_chain_arcs,
             variable_paths,
             clause_routes,
             clause_sink_arcs,
-        }
+        })
     }
 }
 
@@ -325,16 +335,19 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 ],
             );
             let reduction =
-                crate::rules::ReduceTo::<DirectedTwoCommodityIntegralFlow>::reduce_to(&source);
-            let source_config = vec![1, 1, 0];
+                crate::rules::ReduceTo::<DirectedTwoCommodityIntegralFlow>::reduce_to(&source)
+                    .expect("reduction should succeed");
+            let source_config = vec![true, true, false];
             let target_config = reduction.encode_assignment(&source_config);
 
             crate::example_db::specs::assemble_rule_example(
                 &source,
                 reduction.target_problem(),
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/ksatisfiability_feasibleregisterassignment.rs b/src/rules/ksatisfiability_feasibleregisterassignment.rs
index 80f6d0ade..23176c5ed 100644
--- a/src/rules/ksatisfiability_feasibleregisterassignment.rs
+++ b/src/rules/ksatisfiability_feasibleregisterassignment.rs
@@ -1,6 +1,9 @@
 //! Reduction from KSatisfiability (3-SAT) to Feasible Register Assignment.
 //!
-//! This follows Sethi's Reduction 3 / Theorem 5.11:
+//! This follows Sethi's Reduction 3 / Theorem 5.11 (STOC 1973):
+//! Nonempty short clauses are padded by literal repetition, an empty clause
+//! maps to a fixed infeasible DAG, and appearing variables are compacted with
+//! an inverse map. No ordering or distinct-variable hypothesis is needed.
 //! - Variable leaf pairs `s_pos[k], s_neg[k]` share register `S[k]`
 //! - Each literal occurrence adds `p[i,j], q[i,j], r[i,j], rbar[i,j]`
 //! - `r[i,j]` and `rbar[i,j]` share register `R[i,j]`
@@ -14,6 +17,7 @@ use crate::models::misc::FeasibleRegisterAssignment;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::variant::K3;
+use std::collections::BTreeSet;
 
 fn s_pos_idx(var: usize) -> usize {
     var
@@ -59,6 +63,7 @@ fn r_register(num_vars: usize, clause_idx: usize, literal_pos: usize) -> usize {
 pub struct Reduction3SATToFeasibleRegisterAssignment {
     target: FeasibleRegisterAssignment,
     num_vars: usize,
+    source_variables: Vec<usize>,
 }
 
 impl ReductionResult for Reduction3SATToFeasibleRegisterAssignment {
@@ -69,33 +74,89 @@ impl ReductionResult for Reduction3SATToFeasibleRegisterAssignment {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.num_vars)
-            .map(|var| {
-                usize::from(
-                    target_solution[s_pos_idx(var)]
-                        < target_solution[s_neg_idx(self.num_vars, var)],
-                )
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target configuration is not a feasible register assignment realization",
+            ));
+        }
+        let mut assignment = vec![false; self.num_vars];
+        let compact_vars = self.source_variables.len();
+        for (compact, &original) in self.source_variables.iter().enumerate() {
+            assignment[original] = target_solution[s_pos_idx(compact)]
+                < target_solution[s_neg_idx(compact_vars, compact)];
+        }
+        Ok(assignment)
     }
 }
 
-#[reduction(overhead = {
-    num_vertices = "2 * num_vars + 12 * num_clauses",
-    num_arcs = "15 * num_clauses",
-    num_registers = "num_vars + 9 * num_clauses",
-})]
+#[reduction(
+    transform = upper_bound {
+        num_vertices = "2 * num_vars + 12 * num_clauses",
+        num_arcs = "15 * num_clauses",
+        num_registers = "num_vars + 9 * num_clauses",
+        num_same_register_pairs = "num_vars + 3 * num_clauses",
+    }
+)]
 impl ReduceTo<FeasibleRegisterAssignment> for KSatisfiability<K3> {
     type Result = Reduction3SATToFeasibleRegisterAssignment;
 
-    fn reduce_to(&self) -> Self::Result {
-        let num_vars = self.num_vars();
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        if self
+            .clauses()
+            .iter()
+            .any(|clause| clause.literals.is_empty())
+        {
+            // Both predecessors must remain live until vertex 2, but they
+            // share a register. This acyclic target has no realization.
+            return Ok(Reduction3SATToFeasibleRegisterAssignment {
+                target: FeasibleRegisterAssignment::new(3, vec![(2, 0), (2, 1)], 2, vec![0, 0, 1]),
+                num_vars: self.num_vars(),
+                source_variables: Vec::new(),
+            });
+        }
+        let source_variables: Vec<_> = self
+            .clauses()
+            .iter()
+            .flat_map(|clause| clause.literals.iter())
+            .map(|literal| {
+                usize::try_from(literal.unsigned_abs()).expect("native SAT indices fit usize") - 1
+            })
+            .collect::<BTreeSet<_>>()
+            .into_iter()
+            .collect();
+        let num_vars = source_variables.len();
         let num_clauses = self.num_clauses();
-        let num_vertices = 2 * num_vars + 12 * num_clauses;
-        let num_registers = num_vars + 9 * num_clauses;
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<Self, FeasibleRegisterAssignment>(
+                operation,
+            )
+        };
+        let variable_vertices = num_vars
+            .checked_mul(2)
+            .ok_or_else(|| overflow("counting variable leaves"))?;
+        let clause_vertices = num_clauses
+            .checked_mul(12)
+            .ok_or_else(|| overflow("counting clause vertices"))?;
+        let num_vertices = variable_vertices
+            .checked_add(clause_vertices)
+            .ok_or_else(|| overflow("counting target vertices"))?;
+        let clause_registers = num_clauses
+            .checked_mul(9)
+            .ok_or_else(|| overflow("counting clause registers"))?;
+        let num_registers = num_vars
+            .checked_add(clause_registers)
+            .ok_or_else(|| overflow("counting target registers"))?;
+        let num_arcs = num_clauses
+            .checked_mul(15)
+            .ok_or_else(|| overflow("counting target arcs"))?;
         let mut assignment = vec![0usize; num_vertices];
-        let mut arcs = Vec::with_capacity(15 * num_clauses);
+        let mut arcs = Vec::with_capacity(num_arcs);
 
         for var in 0..num_vars {
             assignment[s_pos_idx(var)] = var;
@@ -103,6 +164,10 @@ impl ReduceTo<FeasibleRegisterAssignment> for KSatisfiability<K3> {
         }
 
         for (clause_idx, clause) in self.clauses().iter().enumerate() {
+            // Repetition preserves a nonempty disjunction. Every occurrence
+            // keeps its own gadget and register pair, even for repeated literals.
+            let mut literals = clause.literals.clone();
+            literals.resize(3, literals[0]);
             for literal_pos in 0..3 {
                 assignment[p_idx(num_vars, clause_idx, literal_pos)] =
                     p_register(num_vars, clause_idx, literal_pos);
@@ -136,8 +201,13 @@ impl ReduceTo<FeasibleRegisterAssignment> for KSatisfiability<K3> {
                 rbar_idx(num_vars, clause_idx, 0),
             ));
 
-            for (literal_pos, &literal) in clause.literals.iter().enumerate() {
-                let var = literal.unsigned_abs() as usize - 1;
+            for (literal_pos, &literal) in literals.iter().enumerate() {
+                let original = usize::try_from(literal.unsigned_abs())
+                    .expect("native SAT indices fit usize")
+                    - 1;
+                let var = source_variables
+                    .binary_search(&original)
+                    .expect("all appearing variables were collected");
                 let (literal_leaf, opposite_leaf) = if literal > 0 {
                     (s_pos_idx(var), s_neg_idx(num_vars, var))
                 } else {
@@ -148,10 +218,11 @@ impl ReduceTo<FeasibleRegisterAssignment> for KSatisfiability<K3> {
             }
         }
 
-        Reduction3SATToFeasibleRegisterAssignment {
+        Ok(Reduction3SATToFeasibleRegisterAssignment {
             target: FeasibleRegisterAssignment::new(num_vertices, arcs, num_registers, assignment),
-            num_vars,
-        }
+            num_vars: self.num_vars(),
+            source_variables,
+        })
     }
 }
 
@@ -173,21 +244,25 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 ],
             );
             let to_fra =
-                <KSatisfiability<K3> as ReduceTo<FeasibleRegisterAssignment>>::reduce_to(&source);
-            let to_ilp = <FeasibleRegisterAssignment as ReduceTo<ILP<i32>>>::reduce_to(
+                <KSatisfiability<K3> as ReduceTo<FeasibleRegisterAssignment>>::reduce_to(&source)
+                    .expect("reduction should succeed");
+            let to_ilp = <FeasibleRegisterAssignment as ReduceTo<ILP<i64>>>::reduce_to(
                 to_fra.target_problem(),
-            );
+            )
+            .expect("reduction should succeed");
             let ilp_solution = ILPSolver::new()
                 .solve(to_ilp.target_problem())
                 .expect("canonical FRA example must reduce to a feasible ILP");
-            let target_config = to_ilp.extract_solution(&ilp_solution);
-            let source_config = to_fra.extract_solution(&target_config);
+            let target_config = to_ilp.extract_solution(&ilp_solution).unwrap();
+            let source_config = to_fra.extract_solution(&target_config).unwrap();
             crate::example_db::specs::assemble_rule_example(
                 &source,
                 to_fra.target_problem(),
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/ksatisfiability_kclique.rs b/src/rules/ksatisfiability_kclique.rs
index 0c5d1b16b..19c92416b 100644
--- a/src/rules/ksatisfiability_kclique.rs
+++ b/src/rules/ksatisfiability_kclique.rs
@@ -1,16 +1,10 @@
-//! Reduction from KSatisfiability (3-SAT) to KClique.
+//! Karp's literal-compatibility construction with a universal vertex.
 //!
-//! Classical Karp (1972) reduction. Given a 3-SAT formula with `m` clauses over
-//! `n` variables, construct a graph with `3m` vertices — one per literal position
-//! in each clause. Connect two vertices `(j1, p1)` and `(j2, p2)` if and only if
-//! they belong to different clauses (`j1 ≠ j2`) and their literals are not
-//! contradictory (not `x_i` and `¬x_i`). Set `k = m`.
-//!
-//! A satisfying assignment selects one true literal per clause, forming a clique
-//! of size `m`. Conversely, any `m`-clique picks one non-contradictory literal
-//! per clause, which can be extended to a satisfying assignment.
-//!
-//! Reference: Karp, "Reducibility among combinatorial problems", 1972.
+//! Use actual literal occurrences, including shorter clauses accepted by
+//! KSatisfiability::new_allow_less. For m clauses and t occurrences, create
+//! max(t,m)+1 vertices and request a clique of size m+1. Vertex t is adjacent
+//! to all literal vertices; remaining padding vertices are isolated. This
+//! uniformly represents empty formulas and formulas containing empty clauses.
 
 use crate::models::formula::KSatisfiability;
 use crate::models::graph::KClique;
@@ -19,12 +13,11 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::SimpleGraph;
 use crate::variant::K3;
 
-/// Result of reducing KSatisfiability<K3> to KClique<SimpleGraph>.
+/// Literal vertices carry their validated source variable index and polarity.
 #[derive(Debug, Clone)]
 pub struct Reduction3SATToKClique {
     target: KClique<SimpleGraph>,
-    /// Clauses from the source problem, needed for solution extraction.
-    source_clauses: Vec<Vec<i32>>,
+    literal_assignments: Vec<(usize, bool)>,
     source_num_vars: usize,
 }
 
@@ -36,84 +29,95 @@ impl ReductionResult for Reduction3SATToKClique {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.source_num_vars;
-        // Start with all variables unset (false = 0).
-        let mut assignment = vec![0usize; n];
-        // Track which variables have been explicitly set by a clique vertex.
-        let mut set = vec![false; n];
-
-        for (v, &val) in target_solution.iter().enumerate() {
-            if val != 1 {
-                continue;
-            }
-            // Vertex v corresponds to clause j, position p.
-            let j = v / 3;
-            let p = v % 3;
-            let lit = self.source_clauses[j][p];
-            let var_idx = (lit.unsigned_abs() as usize) - 1; // 0-indexed
-            if !set[var_idx] {
-                assignment[var_idx] = if lit > 0 { 1 } else { 0 };
-                set[var_idx] = true;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        if !crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?
+            .0
+        {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target selection is not a clique meeting the threshold",
+            ));
+        }
+        // Variables absent from the selected literals are free; choose false.
+        let mut assignment = vec![false; self.source_num_vars];
+        for (&selected, &(variable, positive)) in target_solution[..self.literal_assignments.len()]
+            .iter()
+            .zip(&self.literal_assignments)
+        {
+            if selected {
+                assignment[variable] = positive;
             }
         }
-        assignment
+        Ok(assignment)
     }
 }
 
-/// Check whether two literals are contradictory (one is the negation of the other).
-fn literals_contradict(lit1: i32, lit2: i32) -> bool {
-    lit1 == -lit2
-}
-
 #[reduction(
-    overhead = {
-        num_vertices = "3 * num_clauses",
-        num_edges = "9 * num_clauses * (num_clauses - 1) / 2",
-        k = "num_clauses",
+    transform = upper_bound {
+        num_vertices = "3 * num_clauses + 1",
+        k = "num_clauses + 1",
+        num_edges = "9 * num_clauses^2 + 3 * num_clauses",
     }
 )]
 impl ReduceTo<KClique<SimpleGraph>> for KSatisfiability<K3> {
     type Result = Reduction3SATToKClique;
 
-    fn reduce_to(&self) -> Self::Result {
-        let m = self.num_clauses();
-        let num_verts = 3 * m;
-
-        // Collect literals for each clause for easy access.
-        let clause_lits: Vec<Vec<i32>> =
-            self.clauses().iter().map(|c| c.literals.clone()).collect();
-
-        // Build edges: connect (j1,p1) and (j2,p2) if j1 != j2 and literals
-        // are not contradictory.
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let (num_vertices, k) =
+            clique_sizes(self.num_clauses(), self.clauses().iter().map(|c| c.len()))?;
+        // CNFClause::variables performs the formal literal-to-index conversion;
+        // the source constructor has already validated its range and polarity.
+        let positions: Vec<_> = self
+            .clauses()
+            .iter()
+            .enumerate()
+            .flat_map(|(clause, c)| {
+                c.variables()
+                    .into_iter()
+                    .zip(&c.literals)
+                    .map(move |(var, &lit)| (clause, var, lit > 0))
+            })
+            .collect();
         let mut edges = Vec::new();
-        for j1 in 0..m {
-            for j2 in (j1 + 1)..m {
-                for p1 in 0..3 {
-                    for p2 in 0..3 {
-                        let lit1 = clause_lits[j1][p1];
-                        let lit2 = clause_lits[j2][p2];
-                        if !literals_contradict(lit1, lit2) {
-                            let v1 = 3 * j1 + p1;
-                            let v2 = 3 * j2 + p2;
-                            edges.push((v1, v2));
-                        }
-                    }
+        for (u, &(cu, vu, pu)) in positions.iter().enumerate() {
+            for (v, &(cv, vv, pv)) in positions.iter().enumerate().skip(u + 1) {
+                if cu != cv && (vu != vv || pu == pv) {
+                    edges.push((u, v));
                 }
             }
         }
-
-        let graph = SimpleGraph::new(num_verts, edges);
-        let target = KClique::new(graph, m);
-
-        Reduction3SATToKClique {
+        let anchor = positions.len();
+        edges.extend((0..anchor).map(|v| (v, anchor)));
+        let target = KClique::new(SimpleGraph::new(num_vertices, edges), k);
+        Ok(Reduction3SATToKClique {
             target,
-            source_clauses: clause_lits,
+            literal_assignments: positions.into_iter().map(|(_, v, p)| (v, p)).collect(),
             source_num_vars: self.num_vars(),
-        }
+        })
     }
 }
 
+/// Check occurrence and output counts before allocating the compatibility graph.
+fn clique_sizes(
+    m: usize,
+    lengths: impl IntoIterator<Item = usize>,
+) -> Result<(usize, usize), crate::rules::ReductionError> {
+    let overflow = || {
+        crate::rules::ReductionError::integer_overflow::<KSatisfiability<K3>, KClique<SimpleGraph>>(
+            "counting SAT clique occurrences and auxiliary vertices",
+        )
+    };
+    let t = lengths
+        .into_iter()
+        .try_fold(0usize, |sum, len| sum.checked_add(len))
+        .ok_or_else(overflow)?;
+    let vertices = t.max(m).checked_add(1).ok_or_else(overflow)?;
+    // m+1 <= max(t,m)+1, whose representability was checked above.
+    Ok((vertices, m + 1))
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
     use crate::export::SolutionPair;
@@ -133,12 +137,14 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // x1=F, x2=F, x3=T satisfies both clauses.
             // Clause 0: pick literal x3 (position 2) → vertex 2
             // Clause 1: pick literal ¬x1 (position 0) → vertex 3
-            // Target config: 6 vertices, vertices 2 and 3 selected.
+            // Select literal vertices 2 and 3 and the universal vertex 6.
             crate::example_db::specs::rule_example_with_witness::<_, KClique<SimpleGraph>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 1],
-                    target_config: vec![0, 0, 1, 1, 0, 0],
+                    source_config: serde_json::json!(vec![false, false, true]),
+                    target_config: serde_json::json!(vec![
+                        false, false, true, true, false, false, true
+                    ]),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_kernel.rs b/src/rules/ksatisfiability_kernel.rs
index c09f9aca9..d426e0025 100644
--- a/src/rules/ksatisfiability_kernel.rs
+++ b/src/rules/ksatisfiability_kernel.rs
@@ -1,7 +1,9 @@
 //! Reduction from 3-SAT to Kernel.
 //!
 //! This is Chvatal's 1973 construction using variable digons and clause
-//! 3-cycles with arcs to literal vertices.
+//! 3-cycles with arcs to literal vertices. Appearing variables are compacted
+//! with an inverse map; native clauses of length zero through three keep
+//! their original occurrence arcs, including the empty clause's kernel-free cycle.
 
 use crate::models::formula::KSatisfiability;
 use crate::models::graph::Kernel;
@@ -9,12 +11,14 @@ use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::DirectedGraph;
 use crate::variant::K3;
+use std::collections::BTreeSet;
 
 /// Result of reducing 3-SAT to Kernel.
 #[derive(Debug, Clone)]
 pub struct Reduction3SatToKernel {
     target: Kernel,
     source_num_vars: usize,
+    source_variables: Vec<usize>,
 }
 
 impl ReductionResult for Reduction3SatToKernel {
@@ -25,24 +29,27 @@ impl ReductionResult for Reduction3SatToKernel {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.source_num_vars)
-            .map(|i| usize::from(target_solution.get(2 * i).copied().unwrap_or(0) == 1))
-            .collect()
-    }
-}
-
-fn literal_vertex(literal: i32) -> usize {
-    let variable = literal.unsigned_abs() as usize - 1;
-    if literal > 0 {
-        2 * variable
-    } else {
-        2 * variable + 1
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target vertex selection is not a kernel",
+            ));
+        }
+        let mut assignment = vec![false; self.source_num_vars];
+        for (compact, &original) in self.source_variables.iter().enumerate() {
+            assignment[original] = target_solution[2 * compact];
+        }
+        Ok(assignment)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vertices = "2 * num_vars + 3 * num_clauses",
         num_arcs = "2 * num_vars + 6 * num_clauses",
     }
@@ -50,10 +57,35 @@ fn literal_vertex(literal: i32) -> usize {
 impl ReduceTo<Kernel> for KSatisfiability<K3> {
     type Result = Reduction3SatToKernel;
 
-    fn reduce_to(&self) -> Self::Result {
-        let num_vars = self.num_vars();
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let source_variables: Vec<_> = self
+            .clauses()
+            .iter()
+            .flat_map(|clause| clause.literals.iter())
+            .map(|literal| {
+                usize::try_from(literal.unsigned_abs()).expect("native SAT indices fit usize") - 1
+            })
+            .collect::<BTreeSet<_>>()
+            .into_iter()
+            .collect();
+        let num_vars = source_variables.len();
         let num_clauses = self.num_clauses();
-        let mut arcs = Vec::with_capacity(2 * num_vars + 6 * num_clauses);
+        let overflow =
+            |operation| crate::rules::ReductionError::integer_overflow::<Self, Kernel>(operation);
+        let variable_vertices = num_vars
+            .checked_mul(2)
+            .ok_or_else(|| overflow("counting variable vertices"))?;
+        let clause_vertices = num_clauses
+            .checked_mul(3)
+            .ok_or_else(|| overflow("counting clause vertices"))?;
+        let num_vertices = variable_vertices
+            .checked_add(clause_vertices)
+            .ok_or_else(|| overflow("counting target vertices"))?;
+        let arc_capacity = num_clauses
+            .checked_mul(6)
+            .and_then(|clause_arcs| variable_vertices.checked_add(clause_arcs))
+            .ok_or_else(|| overflow("counting target arcs"))?;
+        let mut arcs = Vec::with_capacity(arc_capacity);
 
         for variable in 0..num_vars {
             let positive = 2 * variable;
@@ -69,14 +101,22 @@ impl ReduceTo<Kernel> for KSatisfiability<K3> {
             arcs.push((clause_base + 2, clause_base));
 
             for (literal_index, &literal) in clause.literals.iter().enumerate() {
-                arcs.push((clause_base + literal_index, literal_vertex(literal)));
+                let original = usize::try_from(literal.unsigned_abs())
+                    .expect("native SAT indices fit usize")
+                    - 1;
+                let compact = source_variables
+                    .binary_search(&original)
+                    .expect("all appearing variables were collected");
+                let literal_vertex = 2 * compact + usize::from(literal < 0);
+                arcs.push((clause_base + literal_index, literal_vertex));
             }
         }
 
-        Reduction3SatToKernel {
-            target: Kernel::new(DirectedGraph::new(2 * num_vars + 3 * num_clauses, arcs)),
-            source_num_vars: num_vars,
-        }
+        Ok(Reduction3SatToKernel {
+            target: Kernel::new(DirectedGraph::new(num_vertices, arcs)),
+            source_num_vars: self.num_vars(),
+            source_variables,
+        })
     }
 }
 
@@ -97,8 +137,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     ],
                 ),
                 SolutionPair {
-                    source_config: vec![1, 1, 1],
-                    target_config: vec![1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0],
+                    source_config: serde_json::json!(vec![true, true, true]),
+                    target_config: serde_json::json!(vec![
+                        true, false, true, false, true, false, false, false, false, false, true,
+                        false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_minimumvertexcover.rs b/src/rules/ksatisfiability_minimumvertexcover.rs
index 9e881dd4e..38d133bbe 100644
--- a/src/rules/ksatisfiability_minimumvertexcover.rs
+++ b/src/rules/ksatisfiability_minimumvertexcover.rs
@@ -21,13 +21,13 @@ use crate::variant::K3;
 /// Result of reducing KSatisfiability<K3> to MinimumVertexCover.
 #[derive(Debug, Clone)]
 pub struct Reduction3SATToMVC {
-    target: MinimumVertexCover<SimpleGraph, i32>,
+    target: MinimumVertexCover<SimpleGraph, i64>,
     source_num_vars: usize,
 }
 
 impl ReductionResult for Reduction3SATToMVC {
     type Source = KSatisfiability<K3>;
-    type Target = MinimumVertexCover<SimpleGraph, i32>;
+    type Target = MinimumVertexCover<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
@@ -40,30 +40,33 @@ impl ReductionResult for Reduction3SATToMVC {
     /// is not-u_i. Each truth-setting edge forces exactly one of these two
     /// into any minimum vertex cover. If u_i is in the cover, set x_i = 1;
     /// if not-u_i is in the cover, set x_i = 0.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.source_num_vars)
-            .map(|i| {
-                // u_i is at index 2*i, not-u_i is at index 2*i+1
-                if target_solution[2 * i] == 1 {
-                    1
-                } else {
-                    0
-                }
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            (0..self.source_num_vars)
+                .map(|i| {
+                    // u_i is at index 2*i, not-u_i is at index 2*i+1
+                    target_solution[2 * i]
+                })
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "2 * num_vars + 3 * num_clauses",
         num_edges = "num_vars + 6 * num_clauses",
     }
 )]
-impl ReduceTo<MinimumVertexCover<SimpleGraph, i32>> for KSatisfiability<K3> {
+impl ReduceTo<MinimumVertexCover<SimpleGraph, i64>> for KSatisfiability<K3> {
     type Result = Reduction3SATToMVC;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vars();
         let m = self.num_clauses();
         let total_vertices = 2 * n + 3 * m;
@@ -98,13 +101,13 @@ impl ReduceTo<MinimumVertexCover<SimpleGraph, i32>> for KSatisfiability<K3> {
         }
 
         let graph = SimpleGraph::new(total_vertices, edges);
-        let weights = vec![1i32; total_vertices];
+        let weights = vec![1i64; total_vertices];
         let target = MinimumVertexCover::new(graph, weights);
 
-        Reduction3SATToMVC {
+        Ok(Reduction3SATToMVC {
             target,
             source_num_vars: n,
-        }
+        })
     }
 }
 
@@ -125,12 +128,12 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             );
             crate::example_db::specs::rule_example_with_witness::<
                 _,
-                MinimumVertexCover<SimpleGraph, i32>,
+                MinimumVertexCover<SimpleGraph, i64>,
             >(
                 source,
                 SolutionPair {
                     // x1=0, x2=0, x3=1 satisfies both clauses
-                    source_config: vec![0, 0, 1],
+                    source_config: serde_json::json!(vec![false, false, true]),
                     // Literal vertices: u1(0), ~u1(1), u2(2), ~u2(3), u3(4), ~u3(5)
                     // Clause 0 triangle: v6, v7, v8 (literals x1, x2, x3)
                     // Clause 1 triangle: v9, v10, v11 (literals ~x1, ~x2, x3)
@@ -138,7 +141,9 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     // Clause 0: u1,u2 not in cover -> pick v6,v7; u3 in cover -> v8 free
                     // Clause 1: ~u1,~u2,u3 all in cover -> pick any 2: v9,v10
                     // Total cover size = 3 + 2 + 2 = 7 = n + 2m
-                    target_config: vec![0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0],
+                    target_config: serde_json::json!(vec![
+                        false, true, false, true, true, false, true, true, false, true, true, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_monochromatictriangle.rs b/src/rules/ksatisfiability_monochromatictriangle.rs
index d2a49e311..61a8de78a 100644
--- a/src/rules/ksatisfiability_monochromatictriangle.rs
+++ b/src/rules/ksatisfiability_monochromatictriangle.rs
@@ -1,33 +1,38 @@
-//! Reduction from KSatisfiability (3-SAT) to MonochromaticTriangle.
+//! Reduction from 3-SAT to edge colouring without monochromatic triangles.
 //!
-//! For each variable, create positive/negative literal vertices joined by a
-//! negation edge. Each clause adds three fresh intermediates that form a clause
-//! triangle, plus six fan edges from the clause literals to those intermediates.
-//! The resulting graph has a triangle-free 2-edge-coloring iff the source
-//! formula is satisfiable.
+//! The construction uses the signal-sender framework of Burr, Erdős and Lovász
+//! (On graphs of Ramsey type, 1976). Here an equality sender is two K5 copies
+//! sharing a private triangle: their two complementary edges must have the same
+//! colour. NAE clause triangles are linked to disjoint literal signal edges by
+//! these senders, so their colour constraints actually encode the formula.
+//!
+//! See the full sender, composition and extraction proof in reductions.typ.
 
-use crate::models::formula::KSatisfiability;
+use crate::models::formula::{KSatisfiability, NAESatisfiability, Satisfiability};
 use crate::models::graph::MonochromaticTriangle;
 use crate::reduction;
+use crate::rules::sat_helpers::SatVariableAllocator;
+use crate::rules::satisfiability_naesatisfiability::ReductionSATToNAESAT;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::SimpleGraph;
-use crate::traits::Problem;
 use crate::variant::K3;
-use std::collections::HashMap;
 
-fn normalized_edge(u: usize, v: usize) -> (usize, usize) {
-    if u < v {
-        (u, v)
-    } else {
-        (v, u)
-    }
-}
-
-fn literal_vertex(num_vars: usize, literal: i32) -> usize {
-    if literal > 0 {
-        literal as usize - 1
-    } else {
-        num_vars + literal.unsigned_abs() as usize - 1
+/// Append the fifteen nonterminal edges of an equality sender.
+///
+/// The terminal edges already exist and have four distinct endpoints. The
+/// three vertices starting at `private` belong only to this sender. Both K5
+/// copies induce the same private triangle; their complementary edges have
+/// its majority colour in every valid colouring. Either equal colour extends.
+fn add_equality_sender(
+    edges: &mut Vec<(usize, usize)>,
+    first: (usize, usize),
+    second: (usize, usize),
+    private: usize,
+) {
+    let [u, v, w] = [private, private + 1, private + 2];
+    edges.extend([(u, v), (u, w), (v, w)]);
+    for endpoint in [first.0, first.1, second.0, second.1] {
+        edges.extend([(endpoint, u), (endpoint, v), (endpoint, w)]);
     }
 }
 
@@ -35,8 +40,7 @@ fn literal_vertex(num_vars: usize, literal: i32) -> usize {
 #[derive(Debug, Clone)]
 pub struct Reduction3SATToMonochromaticTriangle {
     target: MonochromaticTriangle<SimpleGraph>,
-    source: KSatisfiability<K3>,
-    negation_edge_indices: Vec<usize>,
+    nae_reduction: ReductionSATToNAESAT,
 }
 
 impl ReductionResult for Reduction3SATToMonochromaticTriangle {
@@ -47,93 +51,114 @@ impl ReductionResult for Reduction3SATToMonochromaticTriangle {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let direct: Vec<usize> = self
-            .negation_edge_indices
-            .iter()
-            .map(
-                |&edge_idx| match target_solution.get(edge_idx).copied().unwrap_or(1) {
-                    0 => 1,
-                    _ => 0,
-                },
-            )
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        let nae_solution = (0..self.nae_reduction.target_problem().num_vars())
+            .map(|index| target_solution[2 * index])
             .collect();
-        if self.source.evaluate(&direct).0 {
-            return direct;
-        }
-
-        let complement: Vec<usize> = direct.iter().map(|&value| 1 - value).collect();
-        if self.source.evaluate(&complement).0 {
-            return complement;
-        }
-
-        direct
+        // Reuse the formal SAT -> NAE extraction (including sentinel
+        // normalization); no assignment search or speculative complement.
+        self.nae_reduction.extract_solution(&nae_solution)
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "2 * num_vars + 3 * num_clauses",
-        num_edges = "num_vars + 9 * num_clauses",
+    transform = upper_bound {
+        num_vertices = "16 * num_vars + 40 * num_clauses + 16",
+        num_edges = "50 * num_vars + 146 * num_clauses + 50",
+        num_triangles = "58 * num_vars + 174 * num_clauses + 58",
     }
 )]
 impl ReduceTo<MonochromaticTriangle<SimpleGraph>> for KSatisfiability<K3> {
     type Result = Reduction3SATToMonochromaticTriangle;
 
-    fn reduce_to(&self) -> Self::Result {
-        let num_vars = self.num_vars();
-        let num_clauses = self.num_clauses();
-        let mut edges = Vec::with_capacity(num_vars + 9 * num_clauses);
-
-        for var in 0..num_vars {
-            edges.push((var, num_vars + var));
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let sat = ReduceTo::<Satisfiability>::reduce_to(self)?;
+        let nae_reduction = ReduceTo::<NAESatisfiability>::reduce_to(sat.target_problem())?;
+        let nae = nae_reduction.target_problem();
+        let auxiliary_count = nae.clauses().iter().filter(|c| c.len() == 4).count();
+        let overflow = || {
+            crate::rules::ReductionError::integer_overflow::<Self, MonochromaticTriangle<SimpleGraph>>(
+                "computing signal-sender graph size",
+            )
+        };
+        let variable_count = nae
+            .num_vars()
+            .checked_add(auxiliary_count)
+            .ok_or_else(overflow)?;
+        let triple_count = variable_count
+            .checked_add(nae.num_clauses())
+            .and_then(|n| n.checked_add(auxiliary_count))
+            .ok_or_else(overflow)?;
+        let num_vertices = variable_count
+            .checked_mul(4)
+            .and_then(|n| triple_count.checked_mul(12).and_then(|t| n.checked_add(t)))
+            .ok_or_else(overflow)?;
+        let num_edges = variable_count
+            .checked_mul(2)
+            .and_then(|n| triple_count.checked_mul(48).and_then(|t| n.checked_add(t)))
+            .ok_or_else(overflow)?;
+
+        let mut variables =
+            SatVariableAllocator::new("KSatisfiability -> MonochromaticTriangle", nae.num_vars())
+                .map_err(
+                crate::rules::ReductionError::construction::<
+                    Self,
+                    MonochromaticTriangle<SimpleGraph>,
+                >,
+            )?;
+        let mut triples = Vec::with_capacity(triple_count);
+        for index in 0..variable_count {
+            let literal = i64::try_from(index + 1).map_err(|_| overflow())?;
+            triples.push([literal, literal, -literal]);
         }
-
-        for (clause_idx, clause) in self.clauses().iter().enumerate() {
-            let clause_base = 2 * num_vars + 3 * clause_idx;
-            let m12 = clause_base;
-            let m13 = clause_base + 1;
-            let m23 = clause_base + 2;
-            let literal_vertices: Vec<usize> = clause
-                .literals
-                .iter()
-                .map(|&literal| literal_vertex(num_vars, literal))
-                .collect();
-            let v1 = literal_vertices[0];
-            let v2 = literal_vertices[1];
-            let v3 = literal_vertices[2];
-
-            edges.extend_from_slice(&[
-                (v1, m12),
-                (v2, m12),
-                (v1, m13),
-                (v3, m13),
-                (v2, m23),
-                (v3, m23),
-                (m12, m13),
-                (m12, m23),
-                (m13, m23),
-            ]);
+        for clause in nae.clauses() {
+            let literals = &clause.literals;
+            if literals.len() == 4 {
+                let z = variables.allocate().map_err(
+                    crate::rules::ReductionError::construction::<
+                        Self,
+                        MonochromaticTriangle<SimpleGraph>,
+                    >,
+                )?;
+                triples.push([literals[0], literals[1], z]);
+                triples.push([-z, literals[2], literals[3]]);
+            } else {
+                // NAE(a,b) = NAE(a,b,b). Formal SAT -> NAE produces only
+                // lengths 2, 3 and 4, including NAE(s,s) for an empty clause.
+                triples.push([literals[0], literals[1], literals[literals.len() - 1]]);
+            }
         }
 
-        let target =
-            MonochromaticTriangle::new(SimpleGraph::new(2 * num_vars + 3 * num_clauses, edges));
-        let edge_indices: HashMap<(usize, usize), usize> = target
-            .edge_list()
-            .iter()
-            .copied()
-            .enumerate()
-            .map(|(idx, (u, v))| (normalized_edge(u, v), idx))
-            .collect();
-        let negation_edge_indices = (0..num_vars)
-            .map(|var| edge_indices[&normalized_edge(var, num_vars + var)])
-            .collect();
-
-        Reduction3SATToMonochromaticTriangle {
-            target,
-            source: self.clone(),
-            negation_edge_indices,
+        let mut edges = Vec::with_capacity(num_edges);
+        for index in 0..variable_count {
+            edges.extend([(4 * index, 4 * index + 1), (4 * index + 2, 4 * index + 3)]);
         }
+        // All following offsets are bounded by the checked total above.
+        let mut next_vertex = 4 * variable_count;
+        for triple in triples {
+            let [a, b, c] = [next_vertex, next_vertex + 1, next_vertex + 2];
+            next_vertex += 3;
+            let sides = [(a, b), (a, c), (b, c)];
+            edges.extend(sides);
+            for (literal, side) in triple.into_iter().zip(sides) {
+                let index = usize::try_from(literal.unsigned_abs() - 1)
+                    .expect("validated SAT variable index fits usize");
+                let endpoint = 4 * index + if literal < 0 { 2 } else { 0 };
+                add_equality_sender(&mut edges, (endpoint, endpoint + 1), side, next_vertex);
+                next_vertex += 3;
+            }
+        }
+        debug_assert_eq!(next_vertex, num_vertices);
+        debug_assert_eq!(edges.len(), num_edges);
+        let target = MonochromaticTriangle::new(SimpleGraph::new(num_vertices, edges));
+        Ok(Reduction3SATToMonochromaticTriangle {
+            target,
+            nae_reduction,
+        })
     }
 }
 
@@ -141,26 +166,26 @@ impl ReduceTo<MonochromaticTriangle<SimpleGraph>> for KSatisfiability<K3> {
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
     use crate::export::SolutionPair;
     use crate::models::formula::CNFClause;
-    use crate::solvers::BruteForce;
+    use crate::solvers::ILPSolver;
 
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "ksatisfiability_to_monochromatictriangle",
         build: || {
             let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-            let reduction =
-                <KSatisfiability<K3> as ReduceTo<MonochromaticTriangle<SimpleGraph>>>::reduce_to(
-                    &source,
-                );
-            let target_config = BruteForce::new()
-                .find_witness(reduction.target_problem())
-                .expect("canonical MonochromaticTriangle example must be feasible");
-            let source_config = reduction.extract_solution(&target_config);
+            let reduction = ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source)
+                .expect("reduction should succeed");
+            let target_config = ILPSolver::new()
+                .solve(reduction.target_problem())
+                .expect("canonical target must be colourable");
+            let source_config = reduction.extract_solution(&target_config).unwrap();
             crate::example_db::specs::assemble_rule_example(
                 &source,
                 reduction.target_problem(),
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/ksatisfiability_oneinthreesatisfiability.rs b/src/rules/ksatisfiability_oneinthreesatisfiability.rs
index 7895c8e23..3c9faa76c 100644
--- a/src/rules/ksatisfiability_oneinthreesatisfiability.rs
+++ b/src/rules/ksatisfiability_oneinthreesatisfiability.rs
@@ -1,13 +1,21 @@
 //! Reduction from KSatisfiability (3-SAT) to One-In-Three Satisfiability.
+//!
+//! Schaefer's Lemma 3.5 (STOC 1978) expresses a three-input disjunction
+//! using five one-in-three constraints. Missing native clause positions
+//! use the forced false variable; appearing source variables are compacted
+//! and restored through an inverse map during extraction.
 
 use crate::models::formula::{CNFClause, KSatisfiability, OneInThreeSatisfiability};
 use crate::reduction;
+use crate::rules::sat_helpers::SatVariableAllocator;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::variant::K3;
+use std::collections::BTreeSet;
 
 #[derive(Debug, Clone)]
 pub struct Reduction3SATToOneInThreeSAT {
     source_num_vars: usize,
+    source_variables: Vec<usize>,
     target: OneInThreeSatisfiability,
 }
 
@@ -19,52 +27,123 @@ impl ReductionResult for Reduction3SATToOneInThreeSAT {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.source_num_vars].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target assignment does not satisfy every one-in-three clause",
+            ));
+        }
+        let mut assignment = vec![false; self.source_num_vars];
+        for (compact, &original) in self.source_variables.iter().enumerate() {
+            assignment[original] = target_solution[compact];
+        }
+        Ok(assignment)
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_vars + 2 + 6 * num_clauses",
-    num_clauses = "1 + 5 * num_clauses",
-})]
+#[reduction(
+    transform = upper_bound {
+        num_vars = "num_vars + 2 + 6 * num_clauses",
+        num_clauses = "1 + 5 * num_clauses",
+    })]
 impl ReduceTo<OneInThreeSatisfiability> for KSatisfiability<K3> {
     type Result = Reduction3SATToOneInThreeSAT;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let source_num_vars = self.num_vars();
-        let z_false = source_num_vars as i32 + 1;
-        let z_true = source_num_vars as i32 + 2;
-        let mut next_var = source_num_vars as i32 + 3;
+        let source_variables: Vec<_> = self
+            .clauses()
+            .iter()
+            .flat_map(|clause| clause.literals.iter())
+            .map(|literal| {
+                usize::try_from(literal.unsigned_abs()).expect("native SAT indices fit usize") - 1
+            })
+            .collect::<BTreeSet<_>>()
+            .into_iter()
+            .collect();
+        let mut variables = SatVariableAllocator::new(
+            "KSatisfiability -> OneInThreeSatisfiability",
+            source_variables.len(),
+        )
+        .map_err(
+            crate::rules::ReductionError::construction::<
+                KSatisfiability<K3>,
+                OneInThreeSatisfiability,
+            >,
+        )?;
+        let sentinels = variables.allocate_many(2).map_err(
+            crate::rules::ReductionError::construction::<
+                KSatisfiability<K3>,
+                OneInThreeSatisfiability,
+            >,
+        )?;
+        let z_false = sentinels[0];
+        let z_true = sentinels[1];
 
-        let mut clauses = Vec::with_capacity(1 + 5 * self.num_clauses());
+        let capacity = self
+            .num_clauses()
+            .checked_mul(5)
+            .and_then(|count| count.checked_add(1))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    KSatisfiability<K3>,
+                    OneInThreeSatisfiability,
+                >("computing the target clause count")
+            })?;
+        let mut clauses = Vec::with_capacity(capacity);
         clauses.push(CNFClause::new(vec![z_false, z_false, z_true]));
 
         for clause in self.clauses() {
-            let [l1, l2, l3] = clause.literals.as_slice() else {
-                unreachable!("K3 clauses must have exactly three literals");
+            // Adding false disjuncts preserves every native clause, including
+            // the empty disjunction, while using the same three-input gadget.
+            let mut literals = [z_false; 3];
+            for (position, &literal) in clause.literals.iter().enumerate() {
+                let original = usize::try_from(literal.unsigned_abs())
+                    .expect("native SAT indices fit usize")
+                    - 1;
+                let compact = source_variables
+                    .binary_search(&original)
+                    .expect("all appearing variables were collected");
+                let variable = i64::try_from(compact + 1).expect("compact SAT indices fit i64");
+                literals[position] = if literal > 0 { variable } else { -variable };
+            }
+            let [l1, l2, l3] = literals;
+            let allocated = variables.allocate_many(6).map_err(
+                crate::rules::ReductionError::construction::<
+                    KSatisfiability<K3>,
+                    OneInThreeSatisfiability,
+                >,
+            )?;
+            let [a, b, c, d, e, f] = allocated.as_slice() else {
+                return Err(crate::rules::ReductionError::invalid_target::<
+                    KSatisfiability<K3>,
+                    OneInThreeSatisfiability,
+                >(
+                    "SAT allocator returned an unexpected variable count"
+                ));
             };
-            let a = next_var;
-            let b = next_var + 1;
-            let c = next_var + 2;
-            let d = next_var + 3;
-            let e = next_var + 4;
-            let f = next_var + 5;
-            next_var += 6;
 
-            clauses.push(CNFClause::new(vec![*l1, a, d]));
-            clauses.push(CNFClause::new(vec![*l2, b, d]));
-            clauses.push(CNFClause::new(vec![a, b, e]));
-            clauses.push(CNFClause::new(vec![c, d, f]));
-            clauses.push(CNFClause::new(vec![*l3, c, z_false]));
+            clauses.push(CNFClause::new(vec![l1, *a, *d]));
+            clauses.push(CNFClause::new(vec![l2, *b, *d]));
+            clauses.push(CNFClause::new(vec![*a, *b, *e]));
+            clauses.push(CNFClause::new(vec![*c, *d, *f]));
+            clauses.push(CNFClause::new(vec![l3, *c, z_false]));
         }
 
-        let target = OneInThreeSatisfiability::new((next_var - 1) as usize, clauses);
+        let target = OneInThreeSatisfiability::try_new(variables.num_vars(), clauses).map_err(
+            crate::rules::ReductionError::construction::<Self, OneInThreeSatisfiability>,
+        )?;
 
-        Reduction3SATToOneInThreeSAT {
+        Ok(Reduction3SATToOneInThreeSAT {
             source_num_vars,
+            source_variables,
             target,
-        }
+        })
     }
 }
 
@@ -79,8 +158,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, OneInThreeSatisfiability>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 1],
-                    target_config: vec![0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0],
+                    source_config: serde_json::json!(vec![false, false, true]),
+                    target_config: serde_json::json!(vec![
+                        false, false, true, false, true, false, false, false, true, true, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_preemptivescheduling.rs b/src/rules/ksatisfiability_preemptivescheduling.rs
index ec7ec9bc3..e994b9cda 100644
--- a/src/rules/ksatisfiability_preemptivescheduling.rs
+++ b/src/rules/ksatisfiability_preemptivescheduling.rs
@@ -55,7 +55,7 @@ fn slot_capacities(num_vars: usize, num_clauses: usize) -> Vec<usize> {
 }
 
 fn literal_endpoint(
-    literal: i32,
+    literal: i64,
     pick_literal: bool,
     positive_chains: &[Vec<usize>],
     negative_chains: &[Vec<usize>],
@@ -193,11 +193,11 @@ fn build_ullman_construction(source: &KSatisfiability<K3>) -> UllmanConstruction
     }
 }
 
-fn task_slot(config: &[usize], task: usize, d_max: usize) -> Option<usize> {
-    let start = task.checked_mul(d_max)?;
-    let end = start.checked_add(d_max)?;
-    let task_slice = config.get(start..end)?;
-    task_slice.iter().position(|&value| value == 1)
+fn task_slot(config: &[Vec<bool>], task: usize, d_max: usize) -> Option<usize> {
+    let task_slice = config.get(task)?;
+    (task_slice.len() == d_max)
+        .then(|| task_slice.iter().position(|&value| value))
+        .flatten()
 }
 
 #[cfg(any(test, feature = "example-db"))]
@@ -208,12 +208,12 @@ fn set_task_slot(task_slots: &mut [Option<usize>], job: usize, slot: usize) {
 #[cfg(any(test, feature = "example-db"))]
 fn clause_pattern_for_assignment(
     clause: &crate::models::formula::CNFClause,
-    assignment: &[usize],
+    assignment: &[bool],
 ) -> usize {
     let mut pattern = 0usize;
     for (position, &literal) in clause.literals.iter().enumerate() {
         let variable = literal.unsigned_abs() as usize - 1;
-        let value = assignment.get(variable).copied().unwrap_or(0) == 1;
+        let value = assignment.get(variable).copied().unwrap_or(false);
         let literal_true = if literal > 0 { value } else { !value };
         if literal_true {
             pattern |= 1 << (2 - position);
@@ -225,9 +225,9 @@ fn clause_pattern_for_assignment(
 #[cfg(any(test, feature = "example-db"))]
 fn construct_schedule_from_assignment(
     target: &PreemptiveScheduling,
-    assignment: &[usize],
+    assignment: &[bool],
     source: &KSatisfiability<K3>,
-) -> Option<Vec<usize>> {
+) -> Option<Vec<Vec<bool>>> {
     let construction = build_ullman_construction(source);
     if assignment.len() != source.num_vars() || target.num_tasks() != construction.num_jobs {
         return None;
@@ -236,7 +236,7 @@ fn construct_schedule_from_assignment(
     let mut task_slots = vec![None; construction.num_jobs];
 
     for variable in 0..source.num_vars() {
-        let value_is_true = assignment[variable] == 1;
+        let value_is_true = assignment[variable];
         for step in 0..=source.num_vars() {
             if value_is_true {
                 set_task_slot(
@@ -305,10 +305,10 @@ fn construct_schedule_from_assignment(
     }
 
     let d_max = target.d_max();
-    let mut config = vec![0usize; construction.num_jobs * d_max];
+    let mut config = vec![vec![false; d_max]; construction.num_jobs];
     for (job, slot) in task_slots.into_iter().enumerate() {
         let slot = slot?;
-        config[job * d_max + slot] = 1;
+        config[job][slot] = true;
     }
     Some(config)
 }
@@ -335,34 +335,47 @@ impl ReductionResult for Reduction3SATToPreemptiveScheduling {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let d_max = self.target.d_max();
-        self.positive_start_jobs
-            .iter()
-            .map(|&job| usize::from(task_slot(target_solution, job, d_max) == Some(0)))
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let d_max = self.target.d_max();
+            self.positive_start_jobs
+                .iter()
+                .map(|&job| task_slot(target_solution, job, d_max) == Some(0))
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
-        num_tasks = "(((2 * num_vars + 2) + 6 * num_clauses + sqrt(((2 * num_vars + 2) - 6 * num_clauses)^2)) / 2) * (num_vars + 3)",
-        num_processors = "((2 * num_vars + 2) + 6 * num_clauses + sqrt(((2 * num_vars + 2) - 6 * num_clauses)^2)) / 2",
-        d_max = "(((2 * num_vars + 2) + 6 * num_clauses + sqrt(((2 * num_vars + 2) - 6 * num_clauses)^2)) / 2) * (num_vars + 3)",
+    transform = upper_bound {
+        num_tasks = "(2 * num_vars + 2 + 6 * num_clauses) * (num_vars + 3)",
+        num_processors = "2 * num_vars + 2 + 6 * num_clauses",
+        d_max = "(2 * num_vars + 2 + 6 * num_clauses) * (num_vars + 3)",
+    },
+    unavailable = {
+        num_precedences = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<PreemptiveScheduling> for KSatisfiability<K3> {
     type Result = Reduction3SATToPreemptiveScheduling;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let construction = build_ullman_construction(self);
         let target = PreemptiveScheduling::new(
-            vec![1; construction.num_jobs],
+            vec![1_i64; construction.num_jobs],
             construction.num_processors,
             construction.precedences.clone(),
-        );
+        )
+        .map_err(
+            crate::rules::ReductionError::construction::<KSatisfiability<K3>, PreemptiveScheduling>,
+        )?;
 
-        Reduction3SATToPreemptiveScheduling {
+        Ok(Reduction3SATToPreemptiveScheduling {
             target,
             positive_start_jobs: construction
                 .positive_chains
@@ -370,7 +383,7 @@ impl ReduceTo<PreemptiveScheduling> for KSatisfiability<K3> {
                 .map(|chain| chain[0])
                 .collect(),
             threshold: construction.time_limit,
-        }
+        })
     }
 }
 
@@ -383,8 +396,9 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "ksatisfiability_to_preemptivescheduling",
         build: || {
             let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-            let reduction = ReduceTo::<PreemptiveScheduling>::reduce_to(&source);
-            let source_config = vec![0, 0, 1];
+            let reduction = ReduceTo::<PreemptiveScheduling>::reduce_to(&source)
+                .expect("reduction should succeed");
+            let source_config = vec![false, false, true];
             let target_config = construct_schedule_from_assignment(
                 reduction.target_problem(),
                 &source_config,
@@ -394,8 +408,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, PreemptiveScheduling>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_quadraticcongruences.rs b/src/rules/ksatisfiability_quadraticcongruences.rs
index e24189349..15320498f 100644
--- a/src/rules/ksatisfiability_quadraticcongruences.rs
+++ b/src/rules/ksatisfiability_quadraticcongruences.rs
@@ -1,7 +1,10 @@
-//! Reduction from KSatisfiability (3-SAT) to Quadratic Congruences.
+//! Reduction from 3-SAT to bounded quadratic congruences.
 //!
-//! This follows the Manders-Adleman construction in its doubled-coefficient
-//! form, matching the verified reference vectors for issue #553.
+//! Manders and Adleman (ERL-M615, 1976), Section 2: an odd signed-knapsack
+//! target and prime-power CRT encode the clauses. Only the actual normalized
+//! clauses need base-eight positions; widths zero through three use the same
+//! slack equation. Squaring uses twice the linear modulus, and extraction
+//! orients every sign by the distinguished odd coordinate.
 
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -11,14 +14,16 @@ use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::variant::K3;
 use num_bigint::{BigInt, BigUint};
-use num_traits::{One, Signed, Zero};
+#[cfg(any(test, feature = "example-db"))]
+use num_traits::Signed;
+use num_traits::{One, Zero};
 
 #[derive(Debug, Clone)]
 pub struct Reduction3SATToQuadraticCongruences {
     target: QuadraticCongruences,
     source_num_vars: usize,
     active_to_source: Vec<usize>,
-    standard_clause_count: usize,
+    clause_count: usize,
     h: BigUint,
     prime_powers: Vec<BigUint>,
 }
@@ -31,37 +36,29 @@ impl ReductionResult for Reduction3SATToQuadraticCongruences {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let mut source_assignment = vec![0; self.source_num_vars];
-        let Some(x) = self.target.decode_witness(target_solution) else {
-            return source_assignment;
-        };
-        if x > self.h {
-            return source_assignment;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target integer does not satisfy the bounded quadratic congruence",
+            ));
         }
-
-        let h_minus_x = &self.h - &x;
-        let h_plus_x = &self.h + &x;
-        let mut alpha = vec![0i8; self.prime_powers.len()];
-
-        for (j, prime_power) in self.prime_powers.iter().enumerate() {
-            if (&h_minus_x % prime_power).is_zero() {
-                alpha[j] = 1;
-            } else if (&h_plus_x % prime_power).is_zero() {
-                alpha[j] = -1;
-            }
+        // Validation gives 0 < x <= H. Each prime power divides exactly one
+        // of H-x and H+x. The coordinate zero sign chooses x or -x so that
+        // the odd linear target, rather than its negative, is recovered.
+        let h_minus_x = &self.h - target_solution;
+        let positive_orientation = (&h_minus_x % &self.prime_powers[0]).is_zero();
+        let mut assignment = vec![false; self.source_num_vars];
+        for (active, &original) in self.active_to_source.iter().enumerate() {
+            let coordinate = 2 * self.clause_count + active + 1;
+            let positive = (&h_minus_x % &self.prime_powers[coordinate]).is_zero();
+            assignment[original] = positive != positive_orientation;
         }
-
-        for (active_index, &source_index) in self.active_to_source.iter().enumerate() {
-            let alpha_index = 2 * self.standard_clause_count + active_index + 1;
-            source_assignment[source_index] = if alpha.get(alpha_index) == Some(&-1) {
-                1
-            } else {
-                0
-            };
-        }
-
-        source_assignment
+        Ok(assignment)
     }
 }
 
@@ -71,14 +68,11 @@ struct MandersAdlemanConstruction {
     target: QuadraticCongruences,
     source_num_vars: usize,
     active_to_source: Vec<usize>,
-    remapped_clause_set: BTreeSet<Vec<i32>>,
-    standard_clauses: Vec<Vec<i32>>,
-    standard_clause_count: usize,
-    active_var_count: usize,
+    clauses: Vec<Vec<i64>>,
     #[cfg_attr(not(test), allow(dead_code))]
-    doubled_coefficients: Vec<BigInt>,
+    coefficients: Vec<BigInt>,
     #[cfg_attr(not(test), allow(dead_code))]
-    tau_2: BigInt,
+    tau: BigInt,
     thetas: Vec<BigUint>,
     h: BigUint,
     prime_powers: Vec<BigUint>,
@@ -94,9 +88,8 @@ fn is_prime(candidate: u64) -> bool {
     if candidate.is_multiple_of(2) {
         return false;
     }
-
     let mut divisor = 3u64;
-    while divisor * divisor <= candidate {
+    while divisor <= candidate / divisor {
         if candidate.is_multiple_of(divisor) {
             return false;
         }
@@ -105,25 +98,21 @@ fn is_prime(candidate: u64) -> bool {
     true
 }
 
-fn admissible_primes(count: usize) -> Vec<u64> {
+fn admissible_primes(count: usize) -> Result<Vec<u64>, crate::rules::ReductionError> {
     let mut primes = Vec::with_capacity(count);
     let mut candidate = 13u64;
     while primes.len() < count {
         if is_prime(candidate) {
             primes.push(candidate);
         }
-        candidate += 1;
-    }
-    primes
-}
-
-fn pow_biguint_u64(base: u64, exp: usize) -> BigUint {
-    let mut result = BigUint::one();
-    let factor = BigUint::from(base);
-    for _ in 0..exp {
-        result *= &factor;
+        candidate = candidate.checked_add(1).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                KSatisfiability<K3>,
+                QuadraticCongruences,
+            >("enumerating CRT primes")
+        })?;
     }
-    result
+    Ok(primes)
 }
 
 fn bigint_mod_to_biguint(value: &BigInt, modulus: &BigUint) -> BigUint {
@@ -131,394 +120,221 @@ fn bigint_mod_to_biguint(value: &BigInt, modulus: &BigUint) -> BigUint {
     let reduced = ((value % &modulus_bigint) + &modulus_bigint) % &modulus_bigint;
     reduced
         .to_biguint()
-        .expect("nonnegative reduced residue must fit BigUint")
+        .expect("Euclidean residue is nonnegative")
 }
 
-fn modular_inverse(value: &BigUint, modulus: &BigUint) -> BigUint {
-    let mut t = BigInt::zero();
-    let mut new_t = BigInt::one();
-    let mut r = BigInt::from(modulus.clone());
-    let mut new_r = BigInt::from(value.clone() % modulus);
-
-    while !new_r.is_zero() {
-        let quotient = &r / &new_r;
-        let next_t = &t - &quotient * &new_t;
-        let next_r = &r - &quotient * &new_r;
-        t = new_t;
-        new_t = next_t;
-        r = new_r;
-        new_r = next_r;
-    }
-
-    assert_eq!(r, BigInt::one(), "value and modulus must be coprime");
-    if t.is_negative() {
-        t += BigInt::from(modulus.clone());
-    }
-    t.to_biguint().expect("inverse must be nonnegative")
-}
-
-fn normalize_clause(clause: &[i32]) -> Option<Vec<i32>> {
-    let mut lits = BTreeSet::new();
-    for &lit in clause {
-        if lits.contains(&-lit) {
+fn normalize_clause(clause: &[i64]) -> Option<Vec<i64>> {
+    let mut literals = BTreeSet::new();
+    for &literal in clause {
+        if literals.contains(&-literal) {
             return None;
         }
-        lits.insert(lit);
-    }
-    Some(lits.into_iter().collect())
-}
-
-fn preprocess_formula(source: &KSatisfiability<K3>) -> (Vec<Vec<i32>>, Vec<usize>) {
-    let mut seen = BTreeSet::new();
-    let mut normalized_clauses = Vec::new();
-    let mut active_vars = BTreeSet::new();
-
-    for clause in source.clauses() {
-        let Some(normalized) = normalize_clause(&clause.literals) else {
-            continue;
-        };
-        if normalized.len() != 3 {
-            panic!(
-                "3-SAT -> QuadraticCongruences requires each non-tautological clause to use three distinct literals; got {:?}",
-                clause.literals
-            );
-        }
-
-        let distinct_vars: BTreeSet<_> = normalized
-            .iter()
-            .map(|lit| lit.unsigned_abs() as usize)
-            .collect();
-        if distinct_vars.len() != 3 {
-            panic!(
-                "3-SAT -> QuadraticCongruences requires each non-tautological clause to use three distinct variables; got {:?}",
-                clause.literals
-            );
-        }
-
-        if seen.insert(normalized.clone()) {
-            for &lit in &normalized {
-                active_vars.insert(lit.unsigned_abs() as usize);
-            }
-            normalized_clauses.push(normalized);
-        }
-    }
-
-    (normalized_clauses, active_vars.into_iter().collect())
-}
-
-fn build_standard_clauses(num_active_vars: usize) -> (Vec<Vec<i32>>, BTreeMap<Vec<i32>, usize>) {
-    let mut clauses = Vec::new();
-    let mut index = BTreeMap::new();
-
-    if num_active_vars < 3 {
-        return (clauses, index);
-    }
-
-    for i in 1..=num_active_vars - 2 {
-        for j in i + 1..=num_active_vars - 1 {
-            for k in j + 1..=num_active_vars {
-                for s1 in [1i32, -1] {
-                    for s2 in [1i32, -1] {
-                        for s3 in [1i32, -1] {
-                            let mut clause = vec![s1 * i as i32, s2 * j as i32, s3 * k as i32];
-                            clause.sort_unstable();
-                            index.insert(clause.clone(), clauses.len() + 1);
-                            clauses.push(clause);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    (clauses, index)
-}
-
-fn pow8_table(max_power: usize) -> Vec<BigUint> {
-    let mut table = Vec::with_capacity(max_power + 1);
-    table.push(BigUint::one());
-    for _ in 0..max_power {
-        let next = table.last().expect("pow8 table is nonempty") * BigUint::from(8u32);
-        table.push(next);
+        literals.insert(literal);
     }
-    table
+    Some(literals.into_iter().collect())
 }
 
-fn build_construction(source: &KSatisfiability<K3>) -> MandersAdlemanConstruction {
-    let (normalized_clauses, active_vars) = preprocess_formula(source);
-    let active_var_count = active_vars.len();
-    let var_map: BTreeMap<usize, usize> = active_vars
+fn build_construction(
+    source: &KSatisfiability<K3>,
+) -> Result<MandersAdlemanConstruction, crate::rules::ReductionError> {
+    let clauses: BTreeSet<_> = source
+        .clauses()
         .iter()
-        .enumerate()
-        .map(|(new_index, &old_index)| (old_index, new_index + 1))
+        .filter_map(|clause| normalize_clause(&clause.literals))
         .collect();
-
-    let remapped_clauses = normalized_clauses
+    let active_vars: Vec<_> = clauses
+        .iter()
+        .flatten()
+        .map(|literal| {
+            usize::try_from(literal.unsigned_abs()).expect("native SAT indices fit usize")
+        })
+        .collect::<BTreeSet<_>>()
+        .into_iter()
+        .collect();
+    let var_map: BTreeMap<_, _> = active_vars
         .iter()
+        .enumerate()
+        .map(|(compact, &original)| (original, compact + 1))
+        .collect();
+    let clauses: Vec<Vec<i64>> = clauses
+        .into_iter()
         .map(|clause| {
-            let mut remapped = clause
-                .iter()
-                .map(|&lit| {
-                    let var = lit.unsigned_abs() as usize;
-                    let new_var = *var_map
-                        .get(&var)
-                        .expect("active variable must be present in the remapping");
-                    if lit > 0 {
-                        new_var as i32
+            clause
+                .into_iter()
+                .map(|literal| {
+                    let original = usize::try_from(literal.unsigned_abs())
+                        .expect("native SAT indices fit usize");
+                    let variable =
+                        i64::try_from(var_map[&original]).expect("compact SAT indices fit i64");
+                    if literal > 0 {
+                        variable
                     } else {
-                        -(new_var as i32)
+                        -variable
                     }
                 })
-                .collect::<Vec<_>>();
-            remapped.sort_unstable();
-            remapped
+                .collect()
         })
-        .collect::<Vec<_>>();
-    let remapped_clause_set = remapped_clauses.iter().cloned().collect::<BTreeSet<_>>();
-
-    let (standard_clauses, standard_index) = build_standard_clauses(active_var_count);
-    let standard_clause_count = standard_clauses.len();
-    let aux_dimension = 2 * standard_clause_count + active_var_count;
-    let pow8 = pow8_table(standard_clause_count + 1);
-
-    let mut tau_phi = BigInt::zero();
-    for clause in &remapped_clauses {
-        if let Some(&j) = standard_index.get(clause) {
-            tau_phi -= BigInt::from(pow8[j].clone());
-        }
-    }
-
-    let mut positive_occurrences = vec![BigInt::zero(); active_var_count + 1];
-    let mut negative_occurrences = vec![BigInt::zero(); active_var_count + 1];
-    for (j, clause) in standard_clauses.iter().enumerate() {
-        let weight = BigInt::from(pow8[j + 1].clone());
-        for &lit in clause {
-            let var = lit.unsigned_abs() as usize;
-            if lit > 0 {
-                positive_occurrences[var] += &weight;
+        .collect();
+    let m = clauses.len();
+    let coordinate_count = m
+        .checked_mul(2)
+        .and_then(|aux| aux.checked_add(active_vars.len()))
+        .and_then(|count| count.checked_add(1))
+        .ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                KSatisfiability<K3>,
+                QuadraticCongruences,
+            >("counting signed-knapsack coordinates")
+        })?;
+    let mut coefficients = vec![BigInt::zero(); coordinate_count];
+    coefficients[0] = BigInt::one();
+    let mut tau = BigInt::one();
+    let mut weight = BigUint::one();
+    for (j, clause) in clauses.iter().enumerate() {
+        weight *= 8u32;
+        let half_weight = BigInt::from(&weight / 2u32);
+        coefficients[2 * j + 1] = -&half_weight;
+        coefficients[2 * j + 2] = -BigInt::from(weight.clone());
+        let width =
+            i64::try_from(clause.len()).expect("native K3 clauses have at most three literals");
+        tau += (width - 5) * &half_weight;
+        for &literal in clause {
+            let variable =
+                usize::try_from(literal.unsigned_abs()).expect("compact SAT indices fit usize");
+            if literal > 0 {
+                coefficients[2 * m + variable] += &half_weight;
             } else {
-                negative_occurrences[var] += &weight;
+                coefficients[2 * m + variable] -= &half_weight;
             }
         }
     }
-
-    let mut doubled_coefficients = vec![BigInt::zero(); aux_dimension + 1];
-    doubled_coefficients[0] = BigInt::from(2u32);
-    for k in 1..=standard_clause_count {
-        let weight = BigInt::from(pow8[k].clone());
-        doubled_coefficients[2 * k - 1] = -weight.clone();
-        doubled_coefficients[2 * k] = -(weight * BigInt::from(2u32));
-    }
-    for i in 1..=active_var_count {
-        doubled_coefficients[2 * standard_clause_count + i] =
-            &positive_occurrences[i] - &negative_occurrences[i];
-    }
-
-    let sum_coefficients = doubled_coefficients
-        .iter()
-        .cloned()
-        .fold(BigInt::zero(), |acc, value| acc + value);
-    let sum_negative_occurrences = negative_occurrences
+    // c.alpha - tau = alpha_0 - 1 + sum_j (y_j - true_literals_j + 1) 8^j.
+    // tau is odd; coefficient doubling would invalidate the square-root lemma.
+    let linear_modulus = weight * 8u32;
+    let primes = admissible_primes(coordinate_count)?;
+    let prime_powers: Vec<_> = primes
         .iter()
-        .skip(1)
-        .cloned()
-        .fold(BigInt::zero(), |acc, value| acc + value);
-    let tau_2 = BigInt::from(2u32) * tau_phi
-        + sum_coefficients
-        + BigInt::from(2u32) * sum_negative_occurrences;
-    let mod_val = BigUint::from(2u32) * pow8[standard_clause_count + 1].clone();
-
-    let primes = admissible_primes(aux_dimension + 1);
-    let prime_powers = primes
-        .iter()
-        .map(|&prime| pow_biguint_u64(prime, aux_dimension + 1))
-        .collect::<Vec<_>>();
-    let k = prime_powers
-        .iter()
-        .cloned()
-        .fold(BigUint::one(), |acc, value| acc * value);
-
-    let mut thetas = Vec::with_capacity(aux_dimension + 1);
-    for j in 0..=aux_dimension {
-        let other = &k / &prime_powers[j];
-        let lcm = &other * &mod_val;
-        let residue = bigint_mod_to_biguint(&doubled_coefficients[j], &mod_val);
-        let inverse = modular_inverse(&(other.clone() % &mod_val), &mod_val);
-        let mut theta = (&other * ((&residue * inverse) % &mod_val)) % &lcm;
+        .map(|&prime| num_traits::Pow::pow(BigUint::from(prime), coordinate_count))
+        .collect();
+    let k: BigUint = prime_powers.iter().product();
+    let mut thetas = Vec::with_capacity(coordinate_count);
+    for ((coefficient, prime_power), prime) in coefficients.iter().zip(&prime_powers).zip(&primes) {
+        let other = &k / prime_power;
+        let step = &other * &linear_modulus;
+        let residue = bigint_mod_to_biguint(coefficient, &linear_modulus);
+        let inverse = other
+            .modinv(&linear_modulus)
+            .expect("an odd prime-power product is coprime to a power of two");
+        let mut theta = &other * ((residue * inverse) % &linear_modulus);
         if theta.is_zero() {
-            theta = lcm.clone();
+            theta += &step;
         }
-        let prime = BigUint::from(primes[j]);
-        while (&theta % &prime).is_zero() {
-            theta += &lcm;
+        if (&theta % BigUint::from(*prime)).is_zero() {
+            theta += &step;
         }
         thetas.push(theta);
     }
-
-    let h = thetas
-        .iter()
-        .cloned()
-        .fold(BigUint::zero(), |acc, value| acc + value);
-    let beta = &mod_val * &k;
-    let inverse_factor = &mod_val + &k;
-    let inverse = modular_inverse(&(inverse_factor % &beta), &beta);
-    let tau_2_squared = (&tau_2 * &tau_2)
-        .to_biguint()
-        .expect("squared doubled target must be nonnegative");
-    let alpha = (&inverse * ((&k * tau_2_squared) + (&mod_val * (&h * &h)))) % &beta;
-    let target = QuadraticCongruences::new(alpha, beta, &h + BigUint::one());
-
-    MandersAdlemanConstruction {
+    let h: BigUint = thetas.iter().sum();
+    // With N=2m+l+1, 13^N > 4N*8^(m+1) for m>=1, hence 2H<K.
+    // For the empty formula N=1, theta_0=1 and K=13 give the same strict bound.
+    let square_modulus = &linear_modulus * 2u32;
+    let b = &square_modulus * &k;
+    let inverse = (&square_modulus + &k)
+        .modinv(&b)
+        .expect("the two CRT moduli are coprime");
+    let tau_squared = (&tau * &tau).to_biguint().expect("a square is nonnegative");
+    let a = (inverse * (&k * tau_squared + &square_modulus * &h * &h)) % &b;
+    let target = QuadraticCongruences::try_new(a, b, &h + BigUint::one()).map_err(
+        crate::rules::ReductionError::construction::<KSatisfiability<K3>, QuadraticCongruences>,
+    )?;
+    Ok(MandersAdlemanConstruction {
         target,
         source_num_vars: source.num_vars(),
-        active_to_source: active_vars.into_iter().map(|var| var - 1).collect(),
-        remapped_clause_set,
-        standard_clauses,
-        standard_clause_count,
-        active_var_count,
-        doubled_coefficients,
-        tau_2,
+        active_to_source: active_vars
+            .into_iter()
+            .map(|variable| variable - 1)
+            .collect(),
+        clauses,
+        coefficients,
+        tau,
         thetas,
         h,
         prime_powers,
-    }
+    })
 }
 
 #[cfg(any(test, feature = "example-db"))]
-fn build_alphas(
-    construction: &MandersAdlemanConstruction,
-    assignment: &[usize],
-) -> Option<Vec<i8>> {
+fn build_alphas(construction: &MandersAdlemanConstruction, assignment: &[bool]) -> Option<Vec<i8>> {
     if assignment.len() != construction.source_num_vars {
         return None;
     }
-
-    let mut active_assignment = vec![0i8; construction.active_var_count + 1];
-    for (active_index, &source_index) in construction.active_to_source.iter().enumerate() {
-        active_assignment[active_index + 1] = if assignment[source_index] == 0 { 0 } else { 1 };
+    let m = construction.clauses.len();
+    let mut alphas = vec![1; construction.thetas.len()];
+    for (i, &original) in construction.active_to_source.iter().enumerate() {
+        alphas[2 * m + i + 1] = 1 - 2 * i8::from(assignment[original]);
     }
-
-    let mut alphas =
-        vec![0i8; 2 * construction.standard_clause_count + construction.active_var_count + 1];
-    alphas[0] = 1;
-
-    for i in 1..=construction.active_var_count {
-        alphas[2 * construction.standard_clause_count + i] = 1 - 2 * active_assignment[i];
-    }
-
-    for k in 1..=construction.standard_clause_count {
-        let clause = &construction.standard_clauses[k - 1];
-        let mut y = 0i32;
-        for &lit in clause {
-            let var = lit.unsigned_abs() as usize;
-            if lit > 0 {
-                y += i32::from(active_assignment[var]);
-            } else {
-                y += 1 - i32::from(active_assignment[var]);
-            }
+    for (j, clause) in construction.clauses.iter().enumerate() {
+        let mut y = -1i8;
+        for &literal in clause {
+            let variable =
+                usize::try_from(literal.unsigned_abs()).expect("compact SAT indices fit usize") - 1;
+            let truth = assignment[construction.active_to_source[variable]];
+            y += i8::from(truth == (literal > 0));
         }
-        if construction.remapped_clause_set.contains(clause) {
-            y -= 1;
-        }
-
-        match 3 - 2 * y {
-            3 => {
-                alphas[2 * k - 1] = 1;
-                alphas[2 * k] = 1;
-            }
-            1 => {
-                alphas[2 * k - 1] = -1;
-                alphas[2 * k] = 1;
-            }
-            -1 => {
-                alphas[2 * k - 1] = 1;
-                alphas[2 * k] = -1;
-            }
-            -3 => {
-                alphas[2 * k - 1] = -1;
-                alphas[2 * k] = -1;
-            }
+        let (first, second) = match y {
+            0 => (1, 1),
+            1 => (-1, 1),
+            2 => (1, -1),
             _ => return None,
-        }
+        };
+        alphas[2 * j + 1] = first;
+        alphas[2 * j + 2] = second;
     }
-
     Some(alphas)
 }
 
 #[cfg(any(test, feature = "example-db"))]
 fn witness_value_from_alphas(alphas: &[i8], thetas: &[BigUint]) -> BigUint {
-    let signed_sum = alphas
+    alphas
         .iter()
         .zip(thetas)
-        .fold(BigInt::zero(), |acc, (&alpha, theta)| {
-            if alpha == 1 {
-                acc + BigInt::from(theta.clone())
-            } else {
-                acc - BigInt::from(theta.clone())
-            }
-        });
-    signed_sum
+        .map(|(&alpha, theta)| BigInt::from(alpha) * BigInt::from(theta.clone()))
+        .sum::<BigInt>()
         .abs()
         .to_biguint()
-        .expect("absolute witness must be nonnegative")
+        .expect("absolute witness is nonnegative")
 }
 
 #[cfg(any(test, feature = "example-db"))]
 fn witness_config_for_assignment(
     source: &KSatisfiability<K3>,
-    assignment: &[usize],
-) -> Option<Vec<usize>> {
-    let construction = build_construction(source);
+    assignment: &[bool],
+) -> Option<BigUint> {
+    let construction = build_construction(source).expect("example or test source must reduce");
     let alphas = build_alphas(&construction, assignment)?;
-    let witness = witness_value_from_alphas(&alphas, &construction.thetas);
-    construction.target.encode_witness(&witness)
+    Some(witness_value_from_alphas(&alphas, &construction.thetas))
 }
 
-#[cfg(test)]
-fn exhaustive_alpha_solution(source: &KSatisfiability<K3>) -> Option<Vec<i8>> {
-    let construction = build_construction(source);
-    let n = construction.doubled_coefficients.len();
-    if n >= usize::BITS as usize {
-        return None;
-    }
-
-    for bits in 0usize..(1usize << n) {
-        let alphas = (0..n)
-            .map(|j| if (bits >> j) & 1 == 1 { 1i8 } else { -1i8 })
-            .collect::<Vec<_>>();
-        let sum = construction
-            .doubled_coefficients
-            .iter()
-            .zip(&alphas)
-            .fold(BigInt::zero(), |acc, (coefficient, &alpha)| {
-                acc + coefficient * BigInt::from(alpha)
-            });
-        if sum == construction.tau_2 {
-            return Some(alphas);
-        }
+#[reduction(
+    transform = upper_bound {
+        bit_length_a = "64 * (2 * num_clauses + num_vars + 1)^2 + 3 * num_clauses + 4",
+        bit_length_b = "64 * (2 * num_clauses + num_vars + 1)^2 + 3 * num_clauses + 4",
+        bit_length_c = "64 * (2 * num_clauses + num_vars + 1)^2 + 3 * num_clauses + 4",
     }
-
-    None
-}
-
-#[reduction(overhead = {
-    bit_length_a = "(num_vars + num_clauses)^2 * log(num_vars + num_clauses + 1)",
-    bit_length_b = "(num_vars + num_clauses)^2 * log(num_vars + num_clauses + 1)",
-    bit_length_c = "(num_vars + num_clauses)^2 * log(num_vars + num_clauses + 1)",
-})]
+)]
 impl ReduceTo<QuadraticCongruences> for KSatisfiability<K3> {
     type Result = Reduction3SATToQuadraticCongruences;
 
-    fn reduce_to(&self) -> Self::Result {
-        let construction = build_construction(self);
-        Reduction3SATToQuadraticCongruences {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let construction = build_construction(self)?;
+        Ok(Reduction3SATToQuadraticCongruences {
             target: construction.target,
             source_num_vars: construction.source_num_vars,
             active_to_source: construction.active_to_source,
-            standard_clause_count: construction.standard_clause_count,
+            clause_count: construction.clauses.len(),
             h: construction.h,
             prime_powers: construction.prime_powers,
-        }
+        })
     }
 }
 
@@ -533,13 +349,14 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 3,
                 vec![crate::models::formula::CNFClause::new(vec![1, 2, 3])],
             );
-            let target_config = witness_config_for_assignment(&source, &[1, 0, 0])
+            let target_config = witness_config_for_assignment(&source, &[true, false, false])
                 .expect("canonical satisfying assignment should lift to a QC witness");
             crate::example_db::specs::rule_example_with_witness::<_, QuadraticCongruences>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 0, 0],
-                    target_config,
+                    source_config: serde_json::json!(vec![true, false, false]),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_quadraticdiophantineequations.rs b/src/rules/ksatisfiability_quadraticdiophantineequations.rs
index dc82fed95..e8e4053c8 100644
--- a/src/rules/ksatisfiability_quadraticdiophantineequations.rs
+++ b/src/rules/ksatisfiability_quadraticdiophantineequations.rs
@@ -28,21 +28,16 @@ impl ReductionResult for Reduction3SATToQuadraticDiophantineEquations {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let Some(x) = self.target.decode_witness(target_solution) else {
-            return self.congruence_reduction.extract_solution(&[]);
-        };
-
-        let Some(congruence_config) = self
-            .congruence_reduction
-            .target_problem()
-            .encode_witness(&x)
-        else {
-            return self.congruence_reduction.extract_solution(&[]);
-        };
-
-        self.congruence_reduction
-            .extract_solution(&congruence_config)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            self.congruence_reduction
+                .extract_solution(target_solution)?
+        })
     }
 }
 
@@ -67,22 +62,24 @@ fn translate_congruence(source: &QuadraticCongruences) -> QuadraticDiophantineEq
     QuadraticDiophantineEquations::new(BigUint::one(), source.b().clone(), c)
 }
 
-#[reduction(overhead = {
-    bit_length_a = "1",
-    bit_length_b = "(num_vars + num_clauses)^2 * log(num_vars + num_clauses + 1)",
-    bit_length_c = "(num_vars + num_clauses)^2 * log(num_vars + num_clauses + 1)",
-})]
+#[reduction(
+    transform = upper_bound {
+        bit_length_a = "1",
+        bit_length_b = "64 * (2 * num_clauses + num_vars + 1)^2 + 3 * num_clauses + 4",
+        bit_length_c = "128 * (2 * num_clauses + num_vars + 1)^2 + 6 * num_clauses + 9",
+    }
+)]
 impl ReduceTo<QuadraticDiophantineEquations> for KSatisfiability<K3> {
     type Result = Reduction3SATToQuadraticDiophantineEquations;
 
-    fn reduce_to(&self) -> Self::Result {
-        let congruence_reduction = ReduceTo::<QuadraticCongruences>::reduce_to(self);
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let congruence_reduction = ReduceTo::<QuadraticCongruences>::reduce_to(self)?;
         let target = translate_congruence(congruence_reduction.target_problem());
 
-        Reduction3SATToQuadraticDiophantineEquations {
+        Ok(Reduction3SATToQuadraticDiophantineEquations {
             target,
             congruence_reduction,
-        }
+        })
     }
 }
 
@@ -95,11 +92,8 @@ fn canonical_source() -> KSatisfiability<K3> {
 
 #[cfg(any(test, feature = "example-db"))]
 fn canonical_witness() -> BigUint {
-    BigUint::parse_bytes(
-        b"1751451122102119958305507786775835374858648979796949071929887579732578264063983923970828608254544727567945005331103265320267846420581308180536461678218456421163010842022583797942541569366464959069523226763069748653830351684499364645098951736761394790343553460544021210289436100818494593367113721596780252083857888675004881955664228675079663569835052161564690932502575257394108174870151908279593037426404556490332761276593006398441245490978500647642893471046425509487910796951416870024826654351366508266859321005453091128123256128675758429165869380881549388896022325625404673271432251145796159394173120179999131480837018022329857587128653018300402",
-        10,
-    )
-    .expect("reference witness must parse")
+    BigUint::parse_bytes(b"3851422232510508672725868082377332726402809", 10)
+        .expect("canonical CRT witness must parse")
 }
 
 #[cfg(feature = "example-db")]
@@ -111,18 +105,17 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "ksatisfiability_to_quadraticdiophantineequations",
         build: || {
             let source = canonical_source();
-            let reduction = ReduceTo::<QuadraticDiophantineEquations>::reduce_to(&source);
-            let target_config = reduction
-                .target_problem()
-                .encode_witness(&canonical_witness())
-                .expect("reference witness must fit QDE encoding");
+            let reduction = ReduceTo::<QuadraticDiophantineEquations>::reduce_to(&source)
+                .expect("reduction should succeed");
+            let target_config = canonical_witness();
 
             assemble_rule_example(
                 &source,
                 reduction.target_problem(),
                 vec![SolutionPair {
-                    source_config: vec![1, 0, 0],
-                    target_config,
+                    source_config: serde_json::json!(vec![true, false, false]),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/ksatisfiability_qubo.rs b/src/rules/ksatisfiability_qubo.rs
index a39f404c7..4a7b8b21c 100644
--- a/src/rules/ksatisfiability_qubo.rs
+++ b/src/rules/ksatisfiability_qubo.rs
@@ -20,59 +20,89 @@ use crate::variant::{K2, K3};
 /// Result of reducing KSatisfiability to QUBO.
 #[derive(Debug, Clone)]
 pub struct ReductionKSatToQUBO {
-    target: QUBO<f64>,
+    target: QUBO<i64>,
     source_num_vars: usize,
+    zero_penalty_energy: i64,
 }
 
 impl ReductionResult for ReductionKSatToQUBO {
     type Source = KSatisfiability<K2>;
-    type Target = QUBO<f64>;
+    type Target = QUBO<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.source_num_vars].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "QUBO energy does not meet the SAT zero-penalty threshold",
+            ));
+        }
+        Ok(target_solution[..self.source_num_vars].to_vec())
     }
 }
 
 /// Result of reducing `KSatisfiability<K3>` to QUBO.
 #[derive(Debug, Clone)]
 pub struct Reduction3SATToQUBO {
-    target: QUBO<f64>,
+    target: QUBO<i64>,
     source_num_vars: usize,
+    zero_penalty_energy: i64,
 }
 
 impl ReductionResult for Reduction3SATToQUBO {
     type Source = KSatisfiability<K3>;
-    type Target = QUBO<f64>;
+    type Target = QUBO<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.source_num_vars].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "QUBO energy does not meet the SAT zero-penalty threshold",
+            ));
+        }
+        Ok(target_solution[..self.source_num_vars].to_vec())
     }
 }
 
-/// Convert a signed literal to (0-indexed variable, is_negated).
-fn lit_to_var(lit: i32) -> (usize, bool) {
-    let var = (lit.unsigned_abs() as usize) - 1;
-    let neg = lit < 0;
-    (var, neg)
-}
-
 /// Add the quadratic penalty term for a 2-literal clause to the QUBO matrix.
 ///
 /// For clause (l_i ∨ l_j), the penalty for the clause being unsatisfied is
 /// the product of the complemented literals.
-fn add_2sat_clause_penalty(matrix: &mut [Vec<f64>], lits: &[i32]) {
+fn add_coefficient(
+    matrix: &mut [Vec<i64>],
+    row: usize,
+    column: usize,
+    coefficient: i64,
+) -> Result<(), &'static str> {
+    matrix[row][column] = matrix[row][column]
+        .checked_add(coefficient)
+        .ok_or("adding a SAT QUBO coefficient")?;
+    Ok(())
+}
+
+fn add_2sat_clause_penalty(
+    matrix: &mut [Vec<i64>],
+    lits: &[(usize, bool)],
+) -> Result<(), &'static str> {
     assert_eq!(lits.len(), 2, "Expected 2-literal clause");
 
-    let (var_i, neg_i) = lit_to_var(lits[0]);
-    let (var_j, neg_j) = lit_to_var(lits[1]);
+    let (var_i, neg_i) = lits[0];
+    let (var_j, neg_j) = lits[1];
 
     // Ensure i <= j for upper-triangular form
     let (i, j, ni, nj) = if var_i <= var_j {
@@ -84,25 +114,26 @@ fn add_2sat_clause_penalty(matrix: &mut [Vec<f64>], lits: &[i32]) {
     match (ni, nj) {
         (false, false) => {
             // (x_i ∨ x_j): penalty = (1-x_i)(1-x_j) = 1 - x_i - x_j + x_i·x_j
-            matrix[i][i] -= 1.0;
-            matrix[j][j] -= 1.0;
-            matrix[i][j] += 1.0;
+            add_coefficient(matrix, i, i, -1)?;
+            add_coefficient(matrix, j, j, -1)?;
+            add_coefficient(matrix, i, j, 1)?;
         }
         (true, false) => {
             // (¬x_i ∨ x_j): penalty = x_i(1-x_j) = x_i - x_i·x_j
-            matrix[i][i] += 1.0;
-            matrix[i][j] -= 1.0;
+            add_coefficient(matrix, i, i, 1)?;
+            add_coefficient(matrix, i, j, -1)?;
         }
         (false, true) => {
             // (x_i ∨ ¬x_j): penalty = (1-x_i)x_j = x_j - x_i·x_j
-            matrix[j][j] += 1.0;
-            matrix[i][j] -= 1.0;
+            add_coefficient(matrix, j, j, 1)?;
+            add_coefficient(matrix, i, j, -1)?;
         }
         (true, true) => {
             // (¬x_i ∨ ¬x_j): penalty = x_i·x_j
-            matrix[i][j] += 1.0;
+            add_coefficient(matrix, i, j, 1)?;
         }
     }
+    Ok(())
 }
 
 /// Add the QUBO terms for a 3-literal clause using Rosenberg quadratization.
@@ -119,13 +150,17 @@ fn add_2sat_clause_penalty(matrix: &mut [Vec<f64>], lits: &[i32]) {
 ///   H = a·y3 + M·(y1·y2 - 2·y1·a - 2·y2·a + 3·a)
 ///
 /// `aux_var` is the 0-indexed auxiliary variable.
-fn add_3sat_clause_penalty(matrix: &mut [Vec<f64>], lits: &[i32], aux_var: usize) {
+fn add_3sat_clause_penalty(
+    matrix: &mut [Vec<i64>],
+    lits: &[(usize, bool)],
+    aux_var: usize,
+) -> Result<(), &'static str> {
     assert_eq!(lits.len(), 3, "Expected 3-literal clause");
-    let penalty = 2.0; // Rosenberg penalty weight
+    let penalty = 2; // Rosenberg penalty weight
 
-    let (v1, n1) = lit_to_var(lits[0]);
-    let (v2, n2) = lit_to_var(lits[1]);
-    let (v3, n3) = lit_to_var(lits[2]);
+    let (v1, n1) = lits[0];
+    let (v2, n2) = lits[1];
+    let (v3, n3) = lits[2];
     let a = aux_var;
 
     // We need to express yi = (1 - li) in terms of xi:
@@ -141,7 +176,13 @@ fn add_3sat_clause_penalty(matrix: &mut [Vec<f64>], lits: &[i32], aux_var: usize
 
     // Helper: add coefficient * yi * yj to the matrix
     // where yi depends on variable vi and negation ni
-    let add_yy = |matrix: &mut [Vec<f64>], vi: usize, ni: bool, vj: usize, nj: bool, coeff: f64| {
+    let add_yy = |matrix: &mut [Vec<i64>],
+                  vi: usize,
+                  ni: bool,
+                  vj: usize,
+                  nj: bool,
+                  coeff: i64|
+     -> Result<(), &'static str> {
         // yi = xi if ni (negated literal), yi = 1 - xi if !ni (positive literal)
         // yi * yj expansion:
         if vi == vj {
@@ -153,15 +194,15 @@ fn add_3sat_clause_penalty(matrix: &mut [Vec<f64>], lits: &[i32], aux_var: usize
                 // yi * yi = yi (binary)
                 if ni {
                     // yi = xi, add coeff * xi
-                    matrix[vi][vi] += coeff;
+                    add_coefficient(matrix, vi, vi, coeff)?;
                 } else {
                     // yi = 1 - xi, add coeff * (1 - xi) = coeff - coeff * xi
                     // constant term ignored in QUBO (offset), diagonal:
-                    matrix[vi][vi] -= coeff;
+                    add_coefficient(matrix, vi, vi, -coeff)?;
                 }
             }
             // else: xi * (1-xi) = 0, nothing to add
-            return;
+            return Ok(());
         }
         // Different variables: yi * yj
         let (lo, hi, lo_neg, hi_neg) = if vi < vj {
@@ -175,152 +216,194 @@ fn add_3sat_clause_penalty(matrix: &mut [Vec<f64>], lits: &[i32], aux_var: usize
         match (lo_neg, hi_neg) {
             (true, true) => {
                 // xi * xj
-                matrix[lo][hi] += coeff;
+                add_coefficient(matrix, lo, hi, coeff)?;
             }
             (true, false) => {
                 // xi * (1 - xj) = xi - xi*xj
-                matrix[lo][lo] += coeff;
-                matrix[lo][hi] -= coeff;
+                add_coefficient(matrix, lo, lo, coeff)?;
+                add_coefficient(matrix, lo, hi, -coeff)?;
             }
             (false, true) => {
                 // (1 - xi) * xj = xj - xi*xj
-                matrix[hi][hi] += coeff;
-                matrix[lo][hi] -= coeff;
+                add_coefficient(matrix, hi, hi, coeff)?;
+                add_coefficient(matrix, lo, hi, -coeff)?;
             }
             (false, false) => {
                 // (1-xi)(1-xj) = 1 - xi - xj + xi*xj
                 // constant 1 ignored (offset)
-                matrix[lo][lo] -= coeff;
-                matrix[hi][hi] -= coeff;
-                matrix[lo][hi] += coeff;
+                add_coefficient(matrix, lo, lo, -coeff)?;
+                add_coefficient(matrix, hi, hi, -coeff)?;
+                add_coefficient(matrix, lo, hi, coeff)?;
             }
         }
+        Ok(())
     };
 
     // Helper: add coefficient * yi * a to the matrix
     // where yi depends on variable vi and negation ni, a is aux variable
-    let add_ya = |matrix: &mut [Vec<f64>], vi: usize, ni: bool, a: usize, coeff: f64| {
+    let add_ya = |matrix: &mut [Vec<i64>],
+                  vi: usize,
+                  ni: bool,
+                  a: usize,
+                  coeff: i64|
+     -> Result<(), &'static str> {
         // yi = xi if ni (negated literal), yi = 1-xi if !ni (positive literal)
         // yi * a:
         let (lo, hi) = if vi < a { (vi, a) } else { (a, vi) };
         if ni {
             // yi = xi, so yi * a = xi * a
-            matrix[lo][hi] += coeff;
+            add_coefficient(matrix, lo, hi, coeff)?;
         } else {
             // yi = 1 - xi, so yi * a = a - xi * a
-            matrix[a][a] += coeff;
-            matrix[lo][hi] -= coeff;
-        }
-    };
-
-    // Helper: add coefficient * yi to the matrix (linear term)
-    let add_y = |matrix: &mut [Vec<f64>], vi: usize, ni: bool, coeff: f64| {
-        if ni {
-            // yi = xi
-            matrix[vi][vi] += coeff;
-        } else {
-            // yi = 1 - xi, linear part: -coeff * xi (constant coeff ignored)
-            matrix[vi][vi] -= coeff;
+            add_coefficient(matrix, a, a, coeff)?;
+            add_coefficient(matrix, lo, hi, -coeff)?;
         }
+        Ok(())
     };
 
-    // Term 1: a * y3 (coefficient = 1.0)
-    add_ya(matrix, v3, n3, a, 1.0);
+    // Term 1: a * y3 (coefficient = 1)
+    add_ya(matrix, v3, n3, a, 1)?;
 
     // Term 2: M * y1 * y2
-    add_yy(matrix, v1, n1, v2, n2, penalty);
+    add_yy(matrix, v1, n1, v2, n2, penalty)?;
 
     // Term 3: -2M * y1 * a
-    add_ya(matrix, v1, n1, a, -2.0 * penalty);
+    add_ya(matrix, v1, n1, a, -2 * penalty)?;
 
     // Term 4: -2M * y2 * a
-    add_ya(matrix, v2, n2, a, -2.0 * penalty);
+    add_ya(matrix, v2, n2, a, -2 * penalty)?;
 
     // Term 5: 3M * a (linear)
     // a is a binary variable, a^2 = a, so linear a → diagonal
-    matrix[a][a] += 3.0 * penalty;
+    add_coefficient(matrix, a, a, 3 * penalty)?;
 
-    // We also need to add linear terms that come from constant offsets in products
-    // Actually, let's verify: the full expansion of
-    //   H = a·y3 + M·(y1·y2 - 2·y1·a - 2·y2·a + 3·a)
-    // All terms are handled above.
-    //
-    // However, we need to account for the case where "add_ya" with !ni adds
-    // a linear term in `a`. Let me verify the add_ya logic handles this correctly.
-    //
-    // add_ya with ni=false: yi = 1-xi, yi*a = a - xi*a
-    //   matrix[a][a] += coeff (linear in a)
-    //   matrix[min(vi,a)][max(vi,a)] -= coeff (quadratic xi*a)
-    // This is correct.
-
-    // Note: We ignore constant terms (don't affect QUBO optimization).
-    let _ = add_y; // suppress unused warning - linear terms in y handled via products
+    Ok(())
 }
 
-/// Build a QUBO matrix from a KSatisfiability instance.
-///
-/// For K=2, directly encodes quadratic penalties.
-/// For K=3, uses Rosenberg quadratization with one auxiliary variable per clause.
-///
-/// Returns (matrix, num_source_vars) where matrix is (n + aux) x (n + aux).
+/// Expand clause penalties and retain the constant omitted by QUBO.
+/// K3 reserves one auxiliary per clause, including free auxiliaries for short
+/// clauses; K2 reserves none. The source constructor validates clause widths.
 fn build_qubo_matrix(
     num_vars: usize,
     clauses: &[crate::models::formula::CNFClause],
-    k: usize,
-) -> Vec<Vec<f64>> {
-    match k {
-        2 => {
-            let mut matrix = vec![vec![0.0; num_vars]; num_vars];
-            for clause in clauses {
-                add_2sat_clause_penalty(&mut matrix, &clause.literals);
+    num_aux: usize,
+) -> Result<(Vec<Vec<i64>>, i64), &'static str> {
+    let total = num_vars
+        .checked_add(num_aux)
+        .ok_or("computing the number of SAT QUBO variables")?;
+    total
+        .checked_mul(total)
+        .ok_or("computing the SAT QUBO dense matrix entry count")?;
+    let mut matrix = vec![vec![0; total]; total];
+    let mut constant = 0i64;
+    for (idx, clause) in clauses.iter().enumerate() {
+        let literals: Vec<_> = clause
+            .variables()
+            .into_iter()
+            .zip(&clause.literals)
+            .map(|(variable, &literal)| (variable, literal < 0))
+            .collect();
+        let offset = match literals.as_slice() {
+            [] => 1,
+            &[(v, neg)] => {
+                add_coefficient(&mut matrix, v, v, if neg { 1 } else { -1 })?;
+                i64::from(!neg)
             }
-            matrix
-        }
-        3 => {
-            let num_aux = clauses.len(); // one auxiliary per clause
-            let total = num_vars + num_aux;
-            let mut matrix = vec![vec![0.0; total]; total];
-            for (idx, clause) in clauses.iter().enumerate() {
-                let aux_var = num_vars + idx;
-                add_3sat_clause_penalty(&mut matrix, &clause.literals, aux_var);
+            &[(_, n1), (_, n2)] => {
+                add_2sat_clause_penalty(&mut matrix, &literals)?;
+                i64::from(!n1 && !n2)
             }
-            matrix
-        }
-        _ => unimplemented!("KSatisfiability to QUBO only supports K=2 and K=3"),
+            &[(_, n1), (_, n2), _] => {
+                add_3sat_clause_penalty(&mut matrix, &literals, num_vars + idx)?;
+                2 * i64::from(!n1 && !n2)
+            }
+            _ => unreachable!("the source validates clause width at most three"),
+        };
+        constant = constant
+            .checked_add(offset)
+            .ok_or("accumulating the SAT QUBO constant")?;
+    }
+    Ok((matrix, constant))
+}
+
+impl crate::rules::AggregateReductionResult for ReductionKSatToQUBO {
+    type Source = KSatisfiability<K2>;
+    type Target = QUBO<i64>;
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+    fn extract_value(&self, value: crate::types::Min<i64>) -> crate::types::Or {
+        crate::types::Or(value.0 == Some(self.zero_penalty_energy))
+    }
+}
+
+impl crate::rules::AggregateReductionResult for Reduction3SATToQUBO {
+    type Source = KSatisfiability<K3>;
+    type Target = QUBO<i64>;
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+    fn extract_value(&self, value: crate::types::Min<i64>) -> crate::types::Or {
+        crate::types::Or(value.0 == Some(self.zero_penalty_energy))
     }
 }
 
 #[reduction(
-    overhead = { num_vars = "num_vars" }
+    aggregate = custom,
+    transform = exact {
+        num_vars = "num_vars",
+    }
 )]
-impl ReduceTo<QUBO<f64>> for KSatisfiability<K2> {
+impl ReduceTo<QUBO<i64>> for KSatisfiability<K2> {
     type Result = ReductionKSatToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vars();
-        let matrix = build_qubo_matrix(n, self.clauses(), 2);
-
-        ReductionKSatToQUBO {
-            target: QUBO::from_matrix(matrix),
+        let (matrix, constant) = build_qubo_matrix(n, self.clauses(), 0).map_err(|operation| {
+            crate::rules::ReductionError::integer_overflow::<KSatisfiability<K2>, QUBO<i64>>(
+                operation,
+            )
+        })?;
+
+        Ok(ReductionKSatToQUBO {
+            target: QUBO::from_matrix(matrix).map_err(|message| {
+                crate::rules::ReductionError::construction::<KSatisfiability<K2>, QUBO<i64>>(
+                    message,
+                )
+            })?,
             source_num_vars: n,
-        }
+            zero_penalty_energy: -constant,
+        })
     }
 }
 
 #[reduction(
-    overhead = { num_vars = "num_vars + num_clauses" }
+    aggregate = custom,
+    transform = exact {
+        num_vars = "num_vars + num_clauses",
+    }
 )]
-impl ReduceTo<QUBO<f64>> for KSatisfiability<K3> {
+impl ReduceTo<QUBO<i64>> for KSatisfiability<K3> {
     type Result = Reduction3SATToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vars();
-        let matrix = build_qubo_matrix(n, self.clauses(), 3);
+        let (matrix, constant) =
+            build_qubo_matrix(n, self.clauses(), self.num_clauses()).map_err(|operation| {
+                crate::rules::ReductionError::integer_overflow::<KSatisfiability<K3>, QUBO<i64>>(
+                    operation,
+                )
+            })?;
 
-        Reduction3SATToQUBO {
-            target: QUBO::from_matrix(matrix),
+        Ok(Reduction3SATToQUBO {
+            target: QUBO::from_matrix(matrix).map_err(|message| {
+                crate::rules::ReductionError::construction::<KSatisfiability<K3>, QUBO<i64>>(
+                    message,
+                )
+            })?,
             source_num_vars: n,
-        }
+            zero_penalty_energy: -constant,
+        })
     }
 }
 
@@ -343,11 +426,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                         CNFClause::new(vec![-3, -4]),
                     ],
                 );
-                crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
+                crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
                     source,
                     SolutionPair {
-                        source_config: vec![0, 1, 0, 1],
-                        target_config: vec![0, 1, 0, 1],
+                        source_config: serde_json::json!(vec![false, true, false, true]),
+                        target_config: serde_json::json!(vec![false, true, false, true]),
                     },
                 )
             },
@@ -367,11 +450,14 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                         CNFClause::new(vec![3, -4, -5]),
                     ],
                 );
-                crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
+                crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
                     source,
                     SolutionPair {
-                        source_config: vec![0, 0, 0, 0, 0],
-                        target_config: vec![0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+                        source_config: serde_json::json!(vec![false, false, false, false, false]),
+                        target_config: serde_json::json!(vec![
+                            false, false, false, false, false, true, false, false, false, false,
+                            false, false
+                        ]),
                     },
                 )
             },
diff --git a/src/rules/ksatisfiability_registersufficiency.rs b/src/rules/ksatisfiability_registersufficiency.rs
index 30caf6c25..8cde3e058 100644
--- a/src/rules/ksatisfiability_registersufficiency.rs
+++ b/src/rules/ksatisfiability_registersufficiency.rs
@@ -1,6 +1,8 @@
 //! Reduction from KSatisfiability (3-SAT) to RegisterSufficiency.
 //!
-//! This is Sethi's Reduction I / Theorem 3.11 with the corrected extraction
+//! This is Sethi's Reduction I / Theorem 3.11 (STOC 1973), with native
+//! empty-formula/empty-clause boundary targets, compact variables, and literal
+//! repetition for nonempty short clauses. The corrected extraction
 //! rule from issue #872:
 //! - the snapshot is taken immediately after `w[n]`
 //! - `x_k = true` iff `x_pos[k]` has been computed by that snapshot
@@ -12,6 +14,7 @@ use crate::models::misc::RegisterSufficiency;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::variant::K3;
+use std::collections::BTreeSet;
 
 #[cfg_attr(not(any(test, feature = "example-db")), allow(dead_code))]
 #[derive(Debug, Clone)]
@@ -35,12 +38,43 @@ struct SethiRegisterLayout {
     x_neg_start: usize,
     z_start: usize,
     total_vertices: usize,
+    arc_capacity: usize,
+    register_bound: usize,
 }
 
 #[cfg_attr(not(any(test, feature = "example-db")), allow(dead_code))]
 impl SethiRegisterLayout {
-    fn new(num_vars: usize, num_clauses: usize) -> Self {
-        let b_padding = (2 * num_vars).saturating_sub(num_clauses);
+    fn new(num_vars: usize, num_clauses: usize) -> Result<Self, crate::rules::ReductionError> {
+        let overflow = || {
+            crate::rules::ReductionError::integer_overflow::<KSatisfiability<K3>, RegisterSufficiency>(
+                "computing Sethi layout dimensions",
+            )
+        };
+        let twice_vars = num_vars.checked_mul(2).ok_or_else(overflow)?;
+        let square = num_vars.checked_mul(num_vars).ok_or_else(overflow)?;
+        let b_padding = twice_vars.saturating_sub(num_clauses);
+        let total_vertices = square
+            .checked_mul(3)
+            .and_then(|size| size.checked_add(num_vars.checked_mul(9)?))
+            .and_then(|size| size.checked_add(num_clauses.checked_mul(4)?))
+            .and_then(|size| size.checked_add(b_padding))
+            .and_then(|size| size.checked_add(4))
+            .ok_or_else(overflow)?;
+        let arc_capacity = square
+            .checked_mul(6)
+            .and_then(|size| size.checked_add(num_vars.checked_mul(19)?))
+            .and_then(|size| size.checked_add(num_clauses.checked_mul(16)?))
+            .and_then(|size| size.checked_add(b_padding.checked_mul(2)?))
+            .and_then(|size| size.checked_add(1))
+            .ok_or_else(overflow)?;
+        let register_bound = num_clauses
+            .checked_mul(3)
+            .and_then(|size| size.checked_add(num_vars.checked_mul(4)?))
+            .and_then(|size| size.checked_add(b_padding))
+            .and_then(|size| size.checked_add(1))
+            .ok_or_else(overflow)?;
+        // Every following prefix is a sum of nonnegative block sizes bounded
+        // by the checked total; twice_vars also bounds the per-variable indices.
         let mut next = 0usize;
 
         let a_start = next;
@@ -92,8 +126,9 @@ impl SethiRegisterLayout {
 
         let z_start = next;
         next += num_vars;
+        debug_assert_eq!(next, total_vertices);
 
-        Self {
+        Ok(Self {
             num_vars,
             num_clauses,
             b_padding,
@@ -112,8 +147,10 @@ impl SethiRegisterLayout {
             x_pos_start,
             x_neg_start,
             z_start,
-            total_vertices: next,
-        }
+            total_vertices,
+            arc_capacity,
+            register_bound,
+        })
     }
 
     fn total_vertices(&self) -> usize {
@@ -121,7 +158,7 @@ impl SethiRegisterLayout {
     }
 
     fn bound(&self) -> usize {
-        3 * self.num_clauses + 4 * self.num_vars + 1 + self.b_padding
+        self.register_bound
     }
 
     fn initial(&self) -> usize {
@@ -183,12 +220,68 @@ impl SethiRegisterLayout {
     fn z(&self, var: usize) -> usize {
         self.z_start + var
     }
+    #[cfg(any(test, feature = "example-db"))]
+    fn schedule_for_assignment(&self, assignment: &[bool]) -> Vec<usize> {
+        assert_eq!(assignment.len(), self.num_vars);
+        let mut order = Vec::with_capacity(self.total_vertices);
+        order.extend((0..2 * self.num_vars + 1).map(|i| self.a(i)));
+        order.extend((0..self.b_padding).map(|i| self.bnode(i)));
+        for clause in 0..self.num_clauses {
+            order.extend((0..3).map(|position| self.f(clause, position)));
+        }
+        for variable in 0..self.num_vars {
+            order.extend((0..2).map(|slot| self.u(variable, slot)));
+        }
+        order.push(self.initial());
+        for (variable, &positive) in assignment.iter().enumerate() {
+            order.extend((0..2 * self.num_vars - 2 * variable).map(|i| self.r(variable, i)));
+            order.push(self.z(variable));
+            order.extend((0..2 * self.num_vars - 2 * variable - 1).map(|i| {
+                if positive {
+                    self.s(variable, i)
+                } else {
+                    self.t(variable, i)
+                }
+            }));
+            order.push(if positive {
+                self.x_pos(variable)
+            } else {
+                self.x_neg(variable)
+            });
+            order.push(self.w(variable));
+        }
+        order.extend((0..self.num_clauses).map(|clause| self.c(clause)));
+        order.push(self.d());
+        for (variable, &positive) in assignment.iter().enumerate() {
+            order.extend((0..2 * self.num_vars - 2 * variable - 1).map(|i| {
+                if positive {
+                    self.t(variable, i)
+                } else {
+                    self.s(variable, i)
+                }
+            }));
+            order.push(if positive {
+                self.x_neg(variable)
+            } else {
+                self.x_pos(variable)
+            });
+        }
+        order.push(self.final_node());
+        assert_eq!(order.len(), self.total_vertices);
+        let mut positions = vec![0; self.total_vertices];
+        for (position, vertex) in order.into_iter().enumerate() {
+            positions[vertex] = position;
+        }
+        positions
+    }
 }
 
 #[derive(Debug, Clone)]
 pub struct Reduction3SATToRegisterSufficiency {
     target: RegisterSufficiency,
-    layout: SethiRegisterLayout,
+    layout: Option<SethiRegisterLayout>,
+    source_num_vars: usize,
+    source_variables: Vec<usize>,
 }
 
 impl ReductionResult for Reduction3SATToRegisterSufficiency {
@@ -199,75 +292,134 @@ impl ReductionResult for Reduction3SATToRegisterSufficiency {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        if self.layout.num_vars == 0 {
-            return Vec::new();
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target ordering does not satisfy the register bound and dependencies",
+            ));
         }
-
-        let cutoff = target_solution[self.layout.w(self.layout.num_vars - 1)];
-        (0..self.layout.num_vars)
-            .map(|var| {
-                let x_pos_before = target_solution[self.layout.x_pos(var)] < cutoff;
-                let x_neg_before = target_solution[self.layout.x_neg(var)] < cutoff;
-                debug_assert!(
-                    !(x_pos_before && x_neg_before),
-                    "Sethi extraction expects at most one of x_pos/x_neg before w[n]",
-                );
-                usize::from(x_pos_before)
-            })
-            .collect()
+        let mut assignment = vec![false; self.source_num_vars];
+        let Some(layout) = &self.layout else {
+            // Only the empty-conjunction target has a feasible witness here.
+            return Ok(assignment);
+        };
+        let cutoff = target_solution[layout.w(layout.num_vars - 1)];
+        for (variable, &original) in self.source_variables.iter().enumerate() {
+            let positive = target_solution[layout.x_pos(variable)] < cutoff;
+            let negative = target_solution[layout.x_neg(variable)] < cutoff;
+            if positive && negative {
+                return Err(crate::rules::ExtractionError::invalid(format!(
+                    "both literals of variable {original} precede the extraction cutoff"
+                )));
+            }
+            assignment[original] = positive;
+        }
+        Ok(assignment)
     }
 }
 
-#[reduction(overhead = {
-    num_vertices = "3 * num_vars^2 + 9 * num_vars + 4 * num_clauses + register_sufficiency_padding + 4",
-    num_arcs = "6 * num_vars^2 + 19 * num_vars + 16 * num_clauses + 2 * register_sufficiency_padding + 1",
-    bound = "3 * num_clauses + 4 * num_vars + 1 + register_sufficiency_padding",
-})]
+#[reduction(
+    transform = upper_bound {
+        num_vertices = "3 * num_vars^2 + 11 * num_vars + 4 * num_clauses + 4",
+        num_arcs = "6 * num_vars^2 + 23 * num_vars + 16 * num_clauses + 1",
+        bound = "6 * num_vars + 3 * num_clauses + 1",
+        num_sinks = "1",
+    }
+)]
 impl ReduceTo<RegisterSufficiency> for KSatisfiability<K3> {
     type Result = Reduction3SATToRegisterSufficiency;
 
-    fn reduce_to(&self) -> Self::Result {
-        let layout = SethiRegisterLayout::new(self.num_vars(), self.num_clauses());
-        let mut arcs = Vec::with_capacity(
-            6 * self.num_vars() * self.num_vars()
-                + 19 * self.num_vars()
-                + 16 * self.num_clauses()
-                + 2 * layout.b_padding
-                + 1,
-        );
-
-        for index in 0..(2 * self.num_vars() + 1) {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let empty_clause = self
+            .clauses()
+            .iter()
+            .any(|clause| clause.literals.is_empty());
+        if empty_clause || self.num_clauses() == 0 {
+            // Zero vertices need zero registers (YES); one output vertex
+            // cannot be computed with zero registers (NO).
+            return Ok(Reduction3SATToRegisterSufficiency {
+                target: RegisterSufficiency::new(usize::from(empty_clause), Vec::new(), 0),
+                layout: None,
+                source_num_vars: self.num_vars(),
+                source_variables: Vec::new(),
+            });
+        }
+        let source_variables: Vec<_> = self
+            .clauses()
+            .iter()
+            .flat_map(|clause| &clause.literals)
+            .map(|literal| {
+                usize::try_from(literal.unsigned_abs())
+                    .expect("native SAT variable indices fit usize")
+                    - 1
+            })
+            .collect::<BTreeSet<_>>()
+            .into_iter()
+            .collect();
+        let clauses: Vec<_> = self
+            .clauses()
+            .iter()
+            .map(|clause| {
+                let mut literals = [0i64; 3];
+                for (position, &literal) in clause.literals.iter().enumerate() {
+                    let original = usize::try_from(literal.unsigned_abs())
+                        .expect("native SAT variable indices fit usize")
+                        - 1;
+                    let compact = source_variables
+                        .binary_search(&original)
+                        .expect("all appearing SAT variables were collected");
+                    let variable = i64::try_from(compact + 1).expect("compact SAT indices fit i64");
+                    literals[position] = if literal > 0 { variable } else { -variable };
+                }
+                // Repeating a literal preserves a nonempty disjunction. Every
+                // slot has a real literal and the original first-true lock proof.
+                for position in clause.literals.len()..3 {
+                    literals[position] = literals[0];
+                }
+                literals
+            })
+            .collect();
+        let num_vars = source_variables.len();
+        let num_clauses = clauses.len();
+        let layout = SethiRegisterLayout::new(num_vars, num_clauses)?;
+        let mut arcs = Vec::with_capacity(layout.arc_capacity);
+
+        for index in 0..(2 * num_vars + 1) {
             arcs.push((layout.initial(), layout.a(index)));
         }
         for index in 0..layout.b_padding {
             arcs.push((layout.initial(), layout.bnode(index)));
         }
-        for clause in 0..self.num_clauses() {
+        for clause in 0..num_clauses {
             for literal_pos in 0..3 {
                 arcs.push((layout.initial(), layout.f(clause, literal_pos)));
             }
         }
-        for var in 0..self.num_vars() {
+        for var in 0..num_vars {
             arcs.push((layout.initial(), layout.u(var, 0)));
             arcs.push((layout.initial(), layout.u(var, 1)));
         }
 
-        for clause in 0..self.num_clauses() {
+        for clause in 0..num_clauses {
             arcs.push((layout.c(clause), layout.initial()));
         }
-        for var in 0..self.num_vars() {
-            for index in 0..(2 * self.num_vars() - 2 * var) {
+        for var in 0..num_vars {
+            for index in 0..(2 * num_vars - 2 * var) {
                 arcs.push((layout.r(var, index), layout.initial()));
             }
-            for index in 0..(2 * self.num_vars() - 2 * var - 1) {
+            for index in 0..(2 * num_vars - 2 * var - 1) {
                 arcs.push((layout.s(var, index), layout.initial()));
                 arcs.push((layout.t(var, index), layout.initial()));
             }
             arcs.push((layout.w(var), layout.initial()));
         }
 
-        for var in 0..self.num_vars() {
+        for var in 0..num_vars {
             arcs.push((layout.final_node(), layout.w(var)));
             arcs.push((layout.final_node(), layout.x_pos(var)));
             arcs.push((layout.final_node(), layout.x_neg(var)));
@@ -276,41 +428,41 @@ impl ReduceTo<RegisterSufficiency> for KSatisfiability<K3> {
         arcs.push((layout.final_node(), layout.initial()));
         arcs.push((layout.final_node(), layout.d()));
 
-        for var in 0..self.num_vars() {
+        for var in 0..num_vars {
             arcs.push((layout.x_pos(var), layout.z(var)));
             arcs.push((layout.x_neg(var), layout.z(var)));
             arcs.push((layout.x_pos(var), layout.u(var, 0)));
             arcs.push((layout.x_neg(var), layout.u(var, 1)));
         }
 
-        for var in 0..self.num_vars() {
+        for var in 0..num_vars {
             arcs.push((layout.w(var), layout.u(var, 0)));
             arcs.push((layout.w(var), layout.u(var, 1)));
         }
 
-        for var in 0..self.num_vars() {
-            for index in 0..(2 * self.num_vars() - 2 * var - 1) {
+        for var in 0..num_vars {
+            for index in 0..(2 * num_vars - 2 * var - 1) {
                 arcs.push((layout.x_pos(var), layout.s(var, index)));
                 arcs.push((layout.x_neg(var), layout.t(var, index)));
             }
-            for index in 0..(2 * self.num_vars() - 2 * var) {
+            for index in 0..(2 * num_vars - 2 * var) {
                 arcs.push((layout.z(var), layout.r(var, index)));
             }
         }
 
-        for var in 1..self.num_vars() {
+        for var in 1..num_vars {
             arcs.push((layout.z(var), layout.w(var - 1)));
             arcs.push((layout.z(var), layout.z(var - 1)));
         }
-        if self.num_vars() > 0 {
-            let last_var = self.num_vars() - 1;
-            for clause in 0..self.num_clauses() {
+        if num_vars > 0 {
+            let last_var = num_vars - 1;
+            for clause in 0..num_clauses {
                 arcs.push((layout.c(clause), layout.w(last_var)));
                 arcs.push((layout.c(clause), layout.z(last_var)));
             }
         }
 
-        for clause in 0..self.num_clauses() {
+        for clause in 0..num_clauses {
             for literal_pos in 0..3 {
                 arcs.push((layout.c(clause), layout.f(clause, literal_pos)));
             }
@@ -319,16 +471,18 @@ impl ReduceTo<RegisterSufficiency> for KSatisfiability<K3> {
         for index in 0..layout.b_padding {
             arcs.push((layout.d(), layout.bnode(index)));
         }
-        for clause in 0..self.num_clauses() {
+        for clause in 0..num_clauses {
             arcs.push((layout.d(), layout.c(clause)));
         }
 
-        for (clause_idx, clause) in self.clauses().iter().enumerate() {
+        for (clause_idx, clause) in clauses.iter().enumerate() {
             let mut lit_nodes = [0usize; 3];
             let mut neg_nodes = [0usize; 3];
 
-            for (literal_pos, &literal) in clause.literals.iter().enumerate() {
-                let var = literal.unsigned_abs() as usize - 1;
+            for (literal_pos, &literal) in clause.iter().enumerate() {
+                let var = usize::try_from(literal.unsigned_abs())
+                    .expect("compact SAT variable indices fit usize")
+                    - 1;
                 if literal > 0 {
                     lit_nodes[literal_pos] = layout.x_pos(var);
                     neg_nodes[literal_pos] = layout.x_neg(var);
@@ -346,10 +500,12 @@ impl ReduceTo<RegisterSufficiency> for KSatisfiability<K3> {
             }
         }
 
-        Reduction3SATToRegisterSufficiency {
+        Ok(Reduction3SATToRegisterSufficiency {
             target: RegisterSufficiency::new(layout.total_vertices(), arcs, layout.bound()),
-            layout,
-        }
+            layout: Some(layout),
+            source_num_vars: self.num_vars(),
+            source_variables,
+        })
     }
 }
 
@@ -369,22 +525,24 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 ],
             );
             let to_registers =
-                <KSatisfiability<K3> as ReduceTo<RegisterSufficiency>>::reduce_to(&source);
+                <KSatisfiability<K3> as ReduceTo<RegisterSufficiency>>::reduce_to(&source)
+                    .expect("reduction should succeed");
 
-            // Use the B&B solver on the RS instance directly, avoiding the
-            // expensive RS→ILP chain (17K vars, minutes on CI).
             let target_config = to_registers
-                .target_problem()
-                .solve_exact()
-                .expect("satisfying 3-SAT instance must yield a feasible RS witness");
-            let source_config = to_registers.extract_solution(&target_config);
+                .layout
+                .as_ref()
+                .expect("canonical formula has nonempty clauses")
+                .schedule_for_assignment(&[true, true, true]);
+            let source_config = to_registers.extract_solution(&target_config).unwrap();
 
             crate::example_db::specs::assemble_rule_example(
                 &source,
                 to_registers.target_problem(),
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/ksatisfiability_simultaneousincongruences.rs b/src/rules/ksatisfiability_simultaneousincongruences.rs
index 484d50585..785e808b8 100644
--- a/src/rules/ksatisfiability_simultaneousincongruences.rs
+++ b/src/rules/ksatisfiability_simultaneousincongruences.rs
@@ -6,7 +6,6 @@
 
 use std::collections::BTreeMap;
 
-use crate::models::algebraic::simultaneous_incongruences::MAX_LCM;
 use crate::models::algebraic::SimultaneousIncongruences;
 use crate::models::formula::{ksat::first_n_odd_primes, CNFClause, KSatisfiability};
 use crate::reduction;
@@ -27,16 +26,27 @@ impl ReductionResult for Reduction3SATToSimultaneousIncongruences {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let x = target_solution.first().copied().unwrap_or(0) as u64;
-        self.variable_primes
-            .iter()
-            .map(|&prime| if x % prime == 1 { 1 } else { 0 })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let x = u64::try_from(*target_solution).map_err(|_| {
+                crate::rules::ExtractionError::invalid(
+                    "target value cannot be represented in the CRT implementation domain",
+                )
+            })?;
+            self.variable_primes
+                .iter()
+                .map(|&prime| x % prime == 1)
+                .collect()
+        })
     }
 }
 
-fn falsifying_residue(literal: i32) -> u64 {
+fn falsifying_residue(literal: i64) -> u64 {
     if literal > 0 {
         2
     } else {
@@ -44,7 +54,7 @@ fn falsifying_residue(literal: i32) -> u64 {
     }
 }
 
-fn modular_inverse(value: u64, modulus: u64) -> u64 {
+fn modular_inverse(value: u64, modulus: u64) -> Option<u64> {
     let mut t = 0i128;
     let mut new_t = 1i128;
     let mut r = modulus as i128;
@@ -56,38 +66,48 @@ fn modular_inverse(value: u64, modulus: u64) -> u64 {
         (r, new_r) = (new_r, r - quotient * new_r);
     }
 
-    assert_eq!(r, 1, "value and modulus must be coprime");
+    if r != 1 {
+        return None;
+    }
     if t < 0 {
         t += modulus as i128;
     }
-    t as u64
+    Some(t as u64)
 }
 
-fn crt_residue(congruences: &[(u64, u64)]) -> (u64, u64) {
-    let modulus = congruences.iter().fold(1u64, |product, &(m, _)| {
-        product
-            .checked_mul(m)
-            .expect("CRT modulus product overflow")
-    });
+fn crt_residue(congruences: &[(u64, u64)]) -> Result<(u64, u64), &'static str> {
+    let modulus = congruences
+        .iter()
+        .try_fold(1u64, |product, &(m, _)| product.checked_mul(m))
+        .ok_or("CRT modulus product overflow")?;
 
     let residue = congruences
         .iter()
-        .fold(0u128, |acc, &(modulus_i, residue_i)| {
+        .try_fold(0u128, |acc, &(modulus_i, residue_i)| {
             let partial = modulus / modulus_i;
-            let inverse = modular_inverse(partial % modulus_i, modulus_i);
-            acc + residue_i as u128 * partial as u128 * inverse as u128
-        })
+            let inverse = modular_inverse(partial % modulus_i, modulus_i)
+                .ok_or("CRT moduli must be pairwise coprime")?;
+            let term = u128::from(residue_i)
+                .checked_mul(u128::from(partial))
+                .and_then(|value| value.checked_mul(u128::from(inverse)))
+                .ok_or("CRT residue term overflow")?;
+            acc.checked_add(term).ok_or("CRT residue sum overflow")
+        })?
         % modulus as u128;
 
-    (residue as u64, modulus)
+    Ok((residue as u64, modulus))
 }
 
-fn clause_bad_residue(clause: &CNFClause, variable_primes: &[u64]) -> (u64, u64) {
+fn clause_bad_residue(
+    clause: &CNFClause,
+    variable_primes: &[u64],
+) -> Result<(u64, u64), &'static str> {
     let mut residue_by_var = BTreeMap::new();
     let mut contradictory_var = None;
 
     for &literal in &clause.literals {
-        let var_index = literal.unsigned_abs() as usize - 1;
+        let var_index =
+            usize::try_from(literal.unsigned_abs()).map_err(|_| "literal index exceeds usize")? - 1;
         let residue = falsifying_residue(literal);
 
         match residue_by_var.insert(var_index, residue) {
@@ -105,7 +125,9 @@ fn clause_bad_residue(clause: &CNFClause, variable_primes: &[u64]) -> (u64, u64)
 
     if let Some(var_index) = contradictory_var {
         for &literal in &clause.literals {
-            let candidate = literal.unsigned_abs() as usize - 1;
+            let candidate = usize::try_from(literal.unsigned_abs())
+                .map_err(|_| "literal index exceeds usize")?
+                - 1;
             if candidate != var_index {
                 residue_by_var
                     .entry(candidate)
@@ -117,45 +139,55 @@ fn clause_bad_residue(clause: &CNFClause, variable_primes: &[u64]) -> (u64, u64)
     let congruences = residue_by_var
         .into_iter()
         .map(|(var_index, residue)| {
-            (
-                *variable_primes
-                    .get(var_index)
-                    .expect("clause variable index must be within num_vars"),
-                residue,
-            )
+            variable_primes
+                .get(var_index)
+                .copied()
+                .map(|prime| (prime, residue))
+                .ok_or("clause variable index exceeds num_vars")
         })
-        .collect::<Vec<_>>();
+        .collect::<Result<Vec<_>, _>>()?;
 
     crt_residue(&congruences)
 }
 
-fn ensure_prime_product_within_lcm_cap(variable_primes: &[u64]) {
+fn ensure_prime_product_fits_target(
+    variable_primes: &[u64],
+) -> Result<(), crate::registry::ConstructionError> {
     let mut product = 1u128;
     for &prime in variable_primes {
-        product = product.checked_mul(prime as u128).unwrap_or_else(|| {
-            panic!(
-                "3-SAT -> SimultaneousIncongruences requires the variable-prime product to fit within the target model's LCM cap ({MAX_LCM}); num_vars={} overflows while multiplying primes",
+        product = product.checked_mul(prime as u128).ok_or_else(|| {
+            format!(
+                "variable-prime product overflows for {} variables",
                 variable_primes.len()
             )
-        });
-        if product > MAX_LCM {
-            panic!(
-                "3-SAT -> SimultaneousIncongruences requires the variable-prime product to fit within the target model's LCM cap ({MAX_LCM}); num_vars={} yields prime product {product}",
+        })?;
+        if product > i64::MAX as u128 {
+            return Err(format!(
+                "variable-prime product {product} for {} variables exceeds the target i64 domain",
                 variable_primes.len()
-            );
+            )
+            .into());
         }
     }
+    Ok(())
 }
 
-#[reduction(overhead = {
-    num_pairs = "simultaneous_incongruences_num_incongruences",
-})]
+#[reduction(
+    transform = unavailable {
+        num_pairs = "the number of residue pairs depends on the first num_vars odd primes and is not expressible in the size-expression language",
+    }
+)]
 impl ReduceTo<SimultaneousIncongruences> for KSatisfiability<K3> {
     type Result = Reduction3SATToSimultaneousIncongruences;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let variable_primes = first_n_odd_primes(self.num_vars());
-        ensure_prime_product_within_lcm_cap(&variable_primes);
+        ensure_prime_product_fits_target(&variable_primes).map_err(|message| {
+            crate::rules::ReductionError::invalid_target::<
+                KSatisfiability<K3>,
+                SimultaneousIncongruences,
+            >(message.to_string())
+        })?;
 
         let mut pairs = Vec::new();
 
@@ -170,7 +202,13 @@ impl ReduceTo<SimultaneousIncongruences> for KSatisfiability<K3> {
         }
 
         for clause in self.clauses() {
-            let (bad_residue, clause_modulus) = clause_bad_residue(clause, &variable_primes);
+            let (bad_residue, clause_modulus) = clause_bad_residue(clause, &variable_primes)
+                .map_err(|message| {
+                    crate::rules::ReductionError::invalid_target::<
+                        KSatisfiability<K3>,
+                        SimultaneousIncongruences,
+                    >(message)
+                })?;
             // The model requires a >= 1. Use modulus instead of 0 since
             // modulus % modulus = 0, achieving the same incongruence.
             let a = if bad_residue == 0 {
@@ -181,11 +219,31 @@ impl ReduceTo<SimultaneousIncongruences> for KSatisfiability<K3> {
             pairs.push((a, clause_modulus));
         }
 
-        Reduction3SATToSimultaneousIncongruences {
-            target: SimultaneousIncongruences::new(pairs)
-                .expect("reduction produces valid incongruences"),
+        let pairs = pairs
+            .into_iter()
+            .map(|(residue, modulus)| {
+                Ok((
+                    i64::try_from(residue).map_err(|_| "residue exceeds i64")?,
+                    i64::try_from(modulus).map_err(|_| "modulus exceeds i64")?,
+                ))
+            })
+            .collect::<Result<Vec<_>, &str>>()
+            .map_err(|message| {
+                crate::rules::ReductionError::invalid_target::<
+                    KSatisfiability<K3>,
+                    SimultaneousIncongruences,
+                >(message)
+            })?;
+        let target = SimultaneousIncongruences::new(pairs).map_err(|message| {
+            crate::rules::ReductionError::construction::<
+                KSatisfiability<K3>,
+                SimultaneousIncongruences,
+            >(message)
+        })?;
+        Ok(Reduction3SATToSimultaneousIncongruences {
+            target,
             variable_primes,
-        }
+        })
     }
 }
 
@@ -206,8 +264,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, SimultaneousIncongruences>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1],
-                    target_config: vec![1],
+                    source_config: serde_json::json!(vec![true, true]),
+                    target_config: serde_json::json!(1),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_subsetsum.rs b/src/rules/ksatisfiability_subsetsum.rs
index 1f4efc32b..3c62e5d14 100644
--- a/src/rules/ksatisfiability_subsetsum.rs
+++ b/src/rules/ksatisfiability_subsetsum.rs
@@ -35,20 +35,20 @@ impl ReductionResult for Reduction3SATToSubsetSum {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Variable integers are the first 2n elements in 0-based indexing:
-        // for variable i (0 <= i < n), y_i is stored at index 2*i and z_i at index 2*i + 1.
-        // If y_i is selected (target_solution[2*i] == 1), set x_i = 1; otherwise x_i = 0.
-        (0..self.source_num_vars)
-            .map(|i| {
-                let y_selected = target_solution[2 * i] == 1;
-                if y_selected {
-                    1
-                } else {
-                    0
-                }
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // Variable integers are the first 2n elements in 0-based indexing:
+            // for variable i (0 <= i < n), y_i is stored at index 2*i and z_i at index 2*i + 1.
+            // If y_i is selected (target_solution[2*i]), set x_i = 1; otherwise x_i = 0.
+            (0..self.source_num_vars)
+                .map(|i| target_solution[2 * i])
+                .collect()
+        })
     }
 }
 
@@ -65,12 +65,12 @@ fn digits_to_integer(digits: &[u8]) -> BigUint {
 }
 
 #[reduction(
-    overhead = { num_elements = "2 * num_vars + 2 * num_clauses" }
+    transform = upper_bound { num_elements = "2 * num_vars + 2 * num_clauses" }
 )]
 impl ReduceTo<SubsetSum> for KSatisfiability<K3> {
     type Result = Reduction3SATToSubsetSum;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vars();
         let m = self.num_clauses();
         let num_digits = n + m;
@@ -129,10 +129,10 @@ impl ReduceTo<SubsetSum> for KSatisfiability<K3> {
         }
         let target = digits_to_integer(&target_digits);
 
-        Reduction3SATToSubsetSum {
+        Ok(Reduction3SATToSubsetSum {
             target: SubsetSum::new_unchecked(sizes, target),
             source_num_vars: n,
-        }
+        })
     }
 }
 
@@ -155,8 +155,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, SubsetSum>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 1],
-                    target_config: vec![0, 1, 0, 1, 1, 0, 1, 1, 1, 0],
+                    source_config: serde_json::json!(vec![false, false, true]),
+                    target_config: serde_json::json!(vec![
+                        false, true, false, true, true, false, true, true, true, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/ksatisfiability_timetabledesign.rs b/src/rules/ksatisfiability_timetabledesign.rs
index 08f9e4d0a..112eabbb6 100644
--- a/src/rules/ksatisfiability_timetabledesign.rs
+++ b/src/rules/ksatisfiability_timetabledesign.rs
@@ -23,9 +23,8 @@
 use crate::models::formula::{CNFClause, KSatisfiability};
 use crate::models::misc::TimetableDesign;
 use crate::reduction;
+use crate::rules::sat_helpers::SatVariableAllocator;
 use crate::rules::traits::{ReduceTo, ReductionResult};
-#[cfg(any(test, feature = "example-db"))]
-use crate::traits::Problem;
 use crate::variant::K3;
 use std::collections::VecDeque;
 
@@ -111,7 +110,7 @@ struct ReductionLayout {
     num_periods: usize,
     craftsman_avail: Vec<Vec<bool>>,
     task_avail: Vec<Vec<bool>>,
-    requirements: Vec<Vec<u64>>,
+    requirements: Vec<Vec<i64>>,
     pure_assignments: Vec<Option<usize>>,
     transformed_to_original: Vec<usize>,
     normalized_clauses: Vec<CNFClause>,
@@ -127,14 +126,14 @@ pub struct Reduction3SATToTimetableDesign {
     layout: ReductionLayout,
 }
 
-fn literal_var_index(literal: i32) -> usize {
-    literal.unsigned_abs() as usize - 1
+fn literal_var_index(literal: i64) -> usize {
+    usize::try_from(literal.unsigned_abs()).expect("SAT literal magnitude must fit usize") - 1
 }
 
 #[cfg(any(test, feature = "example-db"))]
-fn evaluate_clause(clause: &CNFClause, assignment: &[usize]) -> bool {
+fn evaluate_clause(clause: &CNFClause, assignment: &[bool]) -> bool {
     clause.literals.iter().any(|&literal| {
-        let value = assignment[literal_var_index(literal)] == 1;
+        let value = assignment[literal_var_index(literal)];
         if literal > 0 {
             value
         } else {
@@ -203,7 +202,11 @@ fn normalize_formula(source: &KSatisfiability<K3>) -> NormalizedFormula {
     let (mut clauses, pure_assignments) = eliminate_pure_literals(source);
     let source_num_vars = source.num_vars();
     let mut transformed_to_original = Vec::new();
-    let mut next_var = source_num_vars + 1;
+    let mut variables = SatVariableAllocator::new(
+        "KSatisfiability -> TimetableDesign normalization",
+        source_num_vars,
+    )
+    .unwrap_or_else(|message| panic!("{message}"));
 
     for original_var in 1..=source_num_vars {
         let mut occurrences = Vec::new();
@@ -220,41 +223,38 @@ fn normalize_formula(source: &KSatisfiability<K3>) -> NormalizedFormula {
         }
 
         if occurrences.len() <= 3 {
-            let replacement = next_var;
-            next_var += 1;
+            let replacement = variables
+                .allocate()
+                .unwrap_or_else(|message| panic!("{message}"));
             transformed_to_original.push(original_var - 1);
             for (clause_idx, lit_idx, is_positive) in occurrences {
                 clauses[clause_idx].literals[lit_idx] = if is_positive {
-                    replacement as i32
+                    replacement
                 } else {
-                    -(replacement as i32)
+                    -replacement
                 };
             }
             continue;
         }
 
-        let replacements: Vec<usize> = (0..occurrences.len())
-            .map(|_| {
-                let id = next_var;
-                next_var += 1;
-                transformed_to_original.push(original_var - 1);
-                id
-            })
-            .collect();
+        let replacements = variables
+            .allocate_many(occurrences.len())
+            .unwrap_or_else(|message| panic!("{message}"));
+        transformed_to_original.extend(std::iter::repeat_n(original_var - 1, replacements.len()));
 
         for ((clause_idx, lit_idx, is_positive), replacement) in
             occurrences.into_iter().zip(replacements.iter().copied())
         {
             clauses[clause_idx].literals[lit_idx] = if is_positive {
-                replacement as i32
+                replacement
             } else {
-                -(replacement as i32)
+                -replacement
             };
         }
 
         for idx in 0..replacements.len() {
-            let current = replacements[idx] as i32;
-            let next = replacements[(idx + 1) % replacements.len()] as i32;
+            let current = replacements[idx];
+            let next = replacements[(idx + 1) % replacements.len()];
             clauses.push(CNFClause::new(vec![current, -next]));
         }
     }
@@ -262,13 +262,16 @@ fn normalize_formula(source: &KSatisfiability<K3>) -> NormalizedFormula {
     for clause in &mut clauses {
         for literal in &mut clause.literals {
             let sign = if *literal < 0 { -1 } else { 1 };
-            let temp_var = literal.unsigned_abs() as usize;
+            let temp_var = usize::try_from(literal.unsigned_abs())
+                .expect("SAT literal magnitude must fit usize");
             debug_assert!(
                 temp_var > source_num_vars,
                 "all residual literals should have been replaced by transformed variables"
             );
             let compact_var = temp_var - source_num_vars;
-            *literal = sign * compact_var as i32;
+            *literal = sign
+                * i64::try_from(compact_var)
+                    .expect("checked normalized SAT variable count fits i64");
         }
     }
 
@@ -311,7 +314,7 @@ fn normalize_formula(source: &KSatisfiability<K3>) -> NormalizedFormula {
 #[cfg(any(test, feature = "example-db"))]
 fn choose_clause_edge_color(
     clause: &CNFClause,
-    assignment: &[usize],
+    assignment: &[bool],
     colors: &[usize],
 ) -> Option<usize> {
     clause
@@ -319,7 +322,7 @@ fn choose_clause_edge_color(
         .iter()
         .zip(colors.iter().copied())
         .find_map(|(&literal, color)| {
-            let value = assignment[literal_var_index(literal)] == 1;
+            let value = assignment[literal_var_index(literal)];
             let satisfied = if literal > 0 { value } else { !value };
             satisfied.then_some(color)
         })
@@ -372,14 +375,9 @@ fn add_direct_clause_edge(
     EdgeEncoding::Direct { edge, allowed }
 }
 
-fn core_edge_color(
-    solution: &[usize],
-    pair: (usize, usize),
-    num_tasks: usize,
-    num_periods: usize,
-) -> usize {
+fn core_edge_color(solution: &[Vec<Vec<bool>>], pair: (usize, usize), num_periods: usize) -> usize {
     (0..num_periods)
-        .find(|&period| solution[((pair.0 * num_tasks) + pair.1) * num_periods + period] == 1)
+        .find(|&period| solution[pair.0][pair.1][period])
         .expect("each required pair should be scheduled exactly once")
 }
 
@@ -605,7 +603,7 @@ fn build_layout(source: &KSatisfiability<K3>) -> ReductionLayout {
 
     let mut craftsman_avail = vec![vec![true; num_periods]; num_craftsmen];
     let mut task_avail = vec![vec![true; num_periods]; num_tasks];
-    let mut requirements = vec![vec![0u64; num_tasks]; num_craftsmen];
+    let mut requirements = vec![vec![0i64; num_tasks]; num_craftsmen];
     let mut edge_pairs = vec![(usize::MAX, usize::MAX); graph.edges.len()];
 
     for (edge_idx, &(u, v)) in graph.edges.iter().enumerate() {
@@ -658,7 +656,7 @@ fn build_layout(source: &KSatisfiability<K3>) -> ReductionLayout {
 
 impl Reduction3SATToTimetableDesign {
     #[cfg(any(test, feature = "example-db"))]
-    fn construct_target_solution(&self, source_assignment: &[usize]) -> Option<Vec<usize>> {
+    fn construct_target_solution(&self, source_assignment: &[bool]) -> Option<Vec<Vec<Vec<bool>>>> {
         if source_assignment.len() != self.layout.source_num_vars {
             return None;
         }
@@ -667,12 +665,12 @@ impl Reduction3SATToTimetableDesign {
             .pure_assignments
             .iter()
             .enumerate()
-            .any(|(var, fixed)| fixed.is_some_and(|value| source_assignment[var] != value))
+            .any(|(var, fixed)| fixed.is_some_and(|value| source_assignment[var] != (value == 1)))
         {
             return None;
         }
 
-        let transformed_assignment: Vec<usize> = self
+        let transformed_assignment: Vec<bool> = self
             .layout
             .transformed_to_original
             .iter()
@@ -691,7 +689,7 @@ impl Reduction3SATToTimetableDesign {
         let mut colors = vec![None; self.layout.edge_pairs.len()];
 
         for (transformed_var, encoding) in self.layout.variable_encodings.iter().enumerate() {
-            let choose_first = transformed_assignment[transformed_var] == 1;
+            let choose_first = transformed_assignment[transformed_var];
             for edge in [
                 &encoding.ab,
                 &encoding.bc,
@@ -725,12 +723,13 @@ impl Reduction3SATToTimetableDesign {
 
         let num_tasks = self.target.num_tasks();
         let num_periods = self.target.num_periods();
-        let mut config = vec![0usize; self.target.dims().len()];
+        let mut config =
+            vec![vec![vec![false; num_periods]; num_tasks]; self.target.num_craftsmen()];
 
         for (edge_idx, color) in colors.into_iter().enumerate() {
             let (craft, task) = self.layout.edge_pairs[edge_idx];
             let color = color.expect("all core edges should be colored");
-            config[((craft * num_tasks) + task) * num_periods + color] = 1;
+            config[craft][task][color] = true;
         }
 
         Some(config)
@@ -745,51 +744,59 @@ impl ReductionResult for Reduction3SATToTimetableDesign {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_tasks = self.target.num_tasks();
-        let num_periods = self.target.num_periods();
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
-        let mut transformed_assignment = vec![0usize; self.layout.transformed_to_original.len()];
-        for (index, encoding) in self.layout.variable_encodings.iter().enumerate() {
-            let vb_pair = match &encoding.vb {
-                EdgeEncoding::Direct { edge, .. } => self.layout.edge_pairs[*edge],
-                EdgeEncoding::TwoList { left_outer, .. } => self.layout.edge_pairs[*left_outer],
-            };
-            let vb_color = core_edge_color(target_solution, vb_pair, num_tasks, num_periods);
-            transformed_assignment[index] = usize::from(vb_color == encoding.neg2);
-        }
+        Ok({
+            let num_periods = self.target.num_periods();
+
+            let mut transformed_assignment = vec![false; self.layout.transformed_to_original.len()];
+            for (index, encoding) in self.layout.variable_encodings.iter().enumerate() {
+                let vb_pair = match &encoding.vb {
+                    EdgeEncoding::Direct { edge, .. } => self.layout.edge_pairs[*edge],
+                    EdgeEncoding::TwoList { left_outer, .. } => self.layout.edge_pairs[*left_outer],
+                };
+                let vb_color = core_edge_color(target_solution, vb_pair, num_periods);
+                transformed_assignment[index] = vb_color == encoding.neg2;
+            }
 
-        let mut source_assignment = vec![0usize; self.layout.source_num_vars];
-        for (var, fixed) in self.layout.pure_assignments.iter().copied().enumerate() {
-            if let Some(value) = fixed {
-                source_assignment[var] = value;
+            let mut source_assignment = vec![false; self.layout.source_num_vars];
+            for (var, fixed) in self.layout.pure_assignments.iter().copied().enumerate() {
+                if let Some(value) = fixed {
+                    source_assignment[var] = value == 1;
+                }
             }
-        }
 
-        let mut seen_transformed = vec![false; self.layout.source_num_vars];
-        for (value, &original_var) in transformed_assignment
-            .iter()
-            .zip(self.layout.transformed_to_original.iter())
-        {
-            if !seen_transformed[original_var] {
-                source_assignment[original_var] = *value;
-                seen_transformed[original_var] = true;
+            let mut seen_transformed = vec![false; self.layout.source_num_vars];
+            for (value, &original_var) in transformed_assignment
+                .iter()
+                .zip(self.layout.transformed_to_original.iter())
+            {
+                if !seen_transformed[original_var] {
+                    source_assignment[original_var] = *value;
+                    seen_transformed[original_var] = true;
+                }
             }
-        }
 
-        source_assignment
+            source_assignment
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_periods = "4 * num_literals",
-    num_craftsmen = "24 * num_literals + 1",
-    num_tasks = "24 * num_literals + 1",
-})]
+#[reduction(
+    transform = upper_bound {
+        num_periods = "4 * num_literals",
+        num_craftsmen = "24 * num_literals + 1",
+        num_tasks = "24 * num_literals + 1",
+    }
+)]
 impl ReduceTo<TimetableDesign> for KSatisfiability<K3> {
     type Result = Reduction3SATToTimetableDesign;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let layout = build_layout(self);
         let target = TimetableDesign::new(
             layout.num_periods,
@@ -800,7 +807,7 @@ impl ReduceTo<TimetableDesign> for KSatisfiability<K3> {
             layout.requirements.clone(),
         );
 
-        Reduction3SATToTimetableDesign { target, layout }
+        Ok(Reduction3SATToTimetableDesign { target, layout })
     }
 }
 
@@ -808,10 +815,11 @@ impl ReduceTo<TimetableDesign> for KSatisfiability<K3> {
 #[allow(dead_code)]
 pub(super) fn construct_timetable_from_assignment(
     target: &TimetableDesign,
-    assignment: &[usize],
+    assignment: &[bool],
     source: &KSatisfiability<K3>,
-) -> Option<Vec<usize>> {
-    let reduction = ReduceTo::<TimetableDesign>::reduce_to(source);
+) -> Option<Vec<Vec<Vec<bool>>>> {
+    let reduction =
+        ReduceTo::<TimetableDesign>::reduce_to(source).expect("reduction should succeed");
     if reduction.target_problem().num_periods() != target.num_periods()
         || reduction.target_problem().num_craftsmen() != target.num_craftsmen()
         || reduction.target_problem().num_tasks() != target.num_tasks()
@@ -839,8 +847,9 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     CNFClause::new(vec![-1, -2, -3]),
                 ],
             );
-            let reduction = ReduceTo::<TimetableDesign>::reduce_to(&source);
-            let source_config = vec![1, 0, 0];
+            let reduction =
+                ReduceTo::<TimetableDesign>::reduce_to(&source).expect("reduction should succeed");
+            let source_config = vec![true, false, false];
             let target_config = reduction
                 .construct_target_solution(&source_config)
                 .expect("canonical satisfying assignment should lift to timetable");
@@ -848,8 +857,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, TimetableDesign>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/lengthboundeddisjointpaths_ilp.rs b/src/rules/lengthboundeddisjointpaths_ilp.rs
index 08eaadc37..5745f463e 100644
--- a/src/rules/lengthboundeddisjointpaths_ilp.rs
+++ b/src/rules/lengthboundeddisjointpaths_ilp.rs
@@ -8,20 +8,24 @@ use crate::models::graph::LengthBoundedDisjointPaths;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
+use std::collections::VecDeque;
 
 /// Result of reducing LengthBoundedDisjointPaths to ILP.
 ///
 /// Variable layout (all binary):
 /// - Flow: `f^k_{e,dir}` at index `k * 2m + 2e + dir`
+/// - Activation: `a_k` at index `J * 2m + k`
 ///
-/// Total: `J * 2m` variables.
+/// Total: `J * (2m + 1)` variables.
 #[derive(Debug, Clone)]
 pub struct ReductionLBDPToILP {
     target: ILP<bool>,
-    /// Canonical sorted edges.
+    /// Edges in the source graph's order, with their original orientations.
     edges: Vec<(usize, usize)>,
     num_vertices: usize,
     num_paths: usize,
+    source: usize,
+    sink: usize,
 }
 
 impl ReductionResult for ReductionLBDPToILP {
@@ -32,72 +36,107 @@ impl ReductionResult for ReductionLBDPToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // For each path slot k, set the source vertex-indicator block to 1
-        // exactly on the vertices incident to the commodity-k path, including s and t.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         let m = self.edges.len();
-        let n = self.num_vertices;
-        let j = self.num_paths;
         let flow_vars_per_k = 2 * m;
-
-        let mut result = vec![0usize; j * n];
-        for k in 0..j {
-            // Find which vertices are on the path for commodity k
-            let mut on_path = vec![false; n];
-            for e in 0..m {
-                let (u, v) = self.edges[e];
-                let fwd = target_solution[k * flow_vars_per_k + 2 * e];
-                let rev = target_solution[k * flow_vars_per_k + 2 * e + 1];
-                if fwd == 1 {
-                    on_path[u] = true;
-                    on_path[v] = true;
+        let activation_offset = self.num_paths * flow_vars_per_k;
+        let mut result = vec![vec![false; m]; self.num_paths];
+        for (k, path) in result.iter_mut().enumerate() {
+            if target_solution[activation_offset + k] == 0 {
+                if target_solution[k * flow_vars_per_k..(k + 1) * flow_vars_per_k]
+                    .iter()
+                    .any(|&flow| flow != 0)
+                {
+                    return Err(crate::rules::ExtractionError::invalid(
+                        "inactive path slot contains flow",
+                    ));
+                }
+                continue;
+            }
+            let mut adjacency = vec![Vec::new(); self.num_vertices];
+            for (e, &(u, v)) in self.edges.iter().enumerate() {
+                if target_solution[k * flow_vars_per_k + 2 * e] == 1 {
+                    adjacency[u].push((v, e));
                 }
-                if rev == 1 {
-                    on_path[u] = true;
-                    on_path[v] = true;
+                if target_solution[k * flow_vars_per_k + 2 * e + 1] == 1 {
+                    adjacency[v].push((u, e));
                 }
             }
-            for v in 0..n {
-                if on_path[v] {
-                    result[k * n + v] = 1;
+
+            // A unit flow contains an s-t path; BFS excludes any extra circulation.
+            let mut visited = vec![false; self.num_vertices];
+            let mut predecessor = vec![None; self.num_vertices];
+            let mut queue = VecDeque::from([self.source]);
+            visited[self.source] = true;
+            while let Some(u) = queue.pop_front() {
+                if u == self.sink {
+                    break;
+                }
+                for &(v, edge) in &adjacency[u] {
+                    if !visited[v] {
+                        visited[v] = true;
+                        predecessor[v] = Some((u, edge));
+                        queue.push_back(v);
+                    }
                 }
             }
+            let mut vertex = self.sink;
+            while vertex != self.source {
+                let (previous, edge) = predecessor[vertex].ok_or_else(|| {
+                    crate::rules::ExtractionError::invalid(
+                        "active path flow does not connect source to sink",
+                    )
+                })?;
+                path[edge] = true;
+                vertex = previous;
+            }
         }
-        result
+        Ok(result)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "max_paths * 2 * num_edges + max_paths",
         num_constraints = "max_paths * num_vertices + max_paths * num_edges + max_paths + num_edges + num_vertices + max_paths",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for LengthBoundedDisjointPaths<SimpleGraph> {
     type Result = ReductionLBDPToILP;
 
     #[allow(clippy::needless_range_loop)]
-    fn reduce_to(&self) -> Self::Result {
-        let mut edges: Vec<(usize, usize)> = self
-            .graph()
-            .edges()
-            .into_iter()
-            .map(|(u, v)| if u <= v { (u, v) } else { (v, u) })
-            .collect();
-        edges.sort_unstable();
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let edges = self.graph().edges();
 
         let m = edges.len();
         let n = self.num_vertices();
         let j = self.max_paths();
-        let max_len = self.max_length();
+        let max_len = Self::exact_i64(self.max_length(), "encoding the path-length bound")?;
         let s = self.source();
         let t = self.sink();
 
         // Variable layout: flow variables + activation variables a_k
-        let flow_vars_per_k = 2 * m;
-        let num_flow = j * flow_vars_per_k;
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<Self, ILP<bool>>(operation)
+        };
+        let flow_vars_per_k = m
+            .checked_mul(2)
+            .ok_or_else(|| overflow("computing the flow-variable stride"))?;
+        let num_flow = j
+            .checked_mul(flow_vars_per_k)
+            .ok_or_else(|| overflow("computing the flow-variable count"))?;
         let a_var = |k: usize| num_flow + k;
-        let num_vars = num_flow + j;
+        let num_vars = num_flow
+            .checked_add(j)
+            .ok_or_else(|| overflow("computing the ILP variable count"))?;
 
         let flow_var = |k: usize, e: usize, dir: usize| k * flow_vars_per_k + 2 * e + dir;
 
@@ -117,52 +156,52 @@ impl ReduceTo<ILP<bool>> for LengthBoundedDisjointPaths<SimpleGraph> {
                 for &e in &vertex_edges[vertex] {
                     let (eu, _) = edges[e];
                     if vertex == eu {
-                        terms.push((flow_var(k, e, 0), 1.0)); // outgoing
-                        terms.push((flow_var(k, e, 1), -1.0)); // incoming
+                        terms.push((flow_var(k, e, 0), 1)); // outgoing
+                        terms.push((flow_var(k, e, 1), -1)); // incoming
                     } else {
-                        terms.push((flow_var(k, e, 1), 1.0)); // outgoing
-                        terms.push((flow_var(k, e, 0), -1.0)); // incoming
+                        terms.push((flow_var(k, e, 1), 1)); // outgoing
+                        terms.push((flow_var(k, e, 0), -1)); // incoming
                     }
                 }
                 if vertex == s {
                     // outflow - inflow = a_k  =>  outflow - inflow - a_k = 0
-                    terms.push((a_var(k), -1.0));
-                    constraints.push(LinearConstraint::eq(terms, 0.0));
+                    terms.push((a_var(k), -1));
+                    constraints.push(LinearConstraint::eq(terms, 0));
                 } else if vertex == t {
                     // outflow - inflow = -a_k  =>  outflow - inflow + a_k = 0
-                    terms.push((a_var(k), 1.0));
-                    constraints.push(LinearConstraint::eq(terms, 0.0));
+                    terms.push((a_var(k), 1));
+                    constraints.push(LinearConstraint::eq(terms, 0));
                 } else {
-                    constraints.push(LinearConstraint::eq(terms, 0.0));
+                    constraints.push(LinearConstraint::eq(terms, 0));
                 }
             }
 
             // Anti-parallel
             for e in 0..m {
                 constraints.push(LinearConstraint::le(
-                    vec![(flow_var(k, e, 0), 1.0), (flow_var(k, e, 1), 1.0)],
-                    1.0,
+                    vec![(flow_var(k, e, 0), 1), (flow_var(k, e, 1), 1)],
+                    1,
                 ));
             }
 
             // Length bound: total flow for commodity k <= max_length * a_k
             let mut len_terms = Vec::new();
             for e in 0..m {
-                len_terms.push((flow_var(k, e, 0), 1.0));
-                len_terms.push((flow_var(k, e, 1), 1.0));
+                len_terms.push((flow_var(k, e, 0), 1));
+                len_terms.push((flow_var(k, e, 1), 1));
             }
-            len_terms.push((a_var(k), -(max_len as f64)));
-            constraints.push(LinearConstraint::le(len_terms, 0.0));
+            len_terms.push((a_var(k), -max_len));
+            constraints.push(LinearConstraint::le(len_terms, 0));
         }
 
         // Edge disjointness: each edge used by at most one commodity
         for e in 0..m {
             let mut terms = Vec::new();
             for k in 0..j {
-                terms.push((flow_var(k, e, 0), 1.0));
-                terms.push((flow_var(k, e, 1), 1.0));
+                terms.push((flow_var(k, e, 0), 1));
+                terms.push((flow_var(k, e, 1), 1));
             }
-            constraints.push(LinearConstraint::le(terms, 1.0));
+            constraints.push(LinearConstraint::le(terms, 1));
         }
 
         // Vertex disjointness for non-terminal vertices
@@ -175,25 +214,28 @@ impl ReduceTo<ILP<bool>> for LengthBoundedDisjointPaths<SimpleGraph> {
                 for &e in &vertex_edges[v] {
                     let (eu, _) = edges[e];
                     if v == eu {
-                        terms.push((flow_var(k, e, 0), 1.0));
+                        terms.push((flow_var(k, e, 0), 1));
                     } else {
-                        terms.push((flow_var(k, e, 1), 1.0));
+                        terms.push((flow_var(k, e, 1), 1));
                     }
                 }
             }
-            constraints.push(LinearConstraint::le(terms, 1.0));
+            constraints.push(LinearConstraint::le(terms, 1));
         }
 
         // Objective: maximize number of active path slots
-        let objective: Vec<(usize, f64)> = (0..j).map(|k| (a_var(k), 1.0)).collect();
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let objective: Vec<(usize, i64)> = (0..j).map(|k| (a_var(k), 1)).collect();
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(Self::target_construction)?;
 
-        ReductionLBDPToILP {
+        Ok(ReductionLBDPToILP {
             target,
             edges,
             num_vertices: n,
             num_paths: j,
-        }
+            source: s,
+            sink: t,
+        })
     }
 }
 
diff --git a/src/rules/longestcircuit_ilp.rs b/src/rules/longestcircuit_ilp.rs
index e52911a30..c67c9a2e7 100644
--- a/src/rules/longestcircuit_ilp.rs
+++ b/src/rules/longestcircuit_ilp.rs
@@ -6,7 +6,7 @@
 //! - Degree: sum_{e : v in e} y_e = 2 s_v
 //! - At least 3 edges selected
 //! - Maximize: sum l_e y_e
-//! - Multi-commodity flow connectivity
+//! - Multi-commodity flow connectivity from a root chosen on the circuit
 
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::LongestCircuit;
@@ -19,7 +19,8 @@ use crate::topology::{Graph, SimpleGraph};
 /// Variable layout (all binary):
 /// - `y_e` for edge e, indices `0..m`
 /// - `s_v` for vertex v, indices `m..m+n`
-/// - `f^t_{e,dir}` flow for commodity t, indices `m+n..m+n+2m*(n-1)`
+/// - `r_v` for the chosen root, indices `m+n..m+2n`
+/// - `f^t_{e,dir}` flow to vertex t, indices `m+2n..m+2n+2mn`
 #[derive(Debug, Clone)]
 pub struct ReductionLongestCircuitToILP {
     target: ILP<bool>,
@@ -27,7 +28,7 @@ pub struct ReductionLongestCircuitToILP {
 }
 
 impl ReductionResult for ReductionLongestCircuitToILP {
-    type Source = LongestCircuit<SimpleGraph, i32>;
+    type Source = LongestCircuit<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
@@ -35,115 +36,141 @@ impl ReductionResult for ReductionLongestCircuitToILP {
     }
 
     /// Extract: output the binary edge-selection vector (y_e).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_edges].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_edges]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "num_edges + num_vertices + 2 * num_edges * (num_vertices - 1)",
-        num_constraints = "1 + num_vertices^2 + 2 * num_edges * (num_vertices - 1)",
+    transform = exact {
+        num_vars = "num_edges + 2 * num_vertices + 2 * num_edges * num_vertices",
+        num_constraints = "2 + num_vertices + 2 * num_vertices^2 + 2 * num_edges * num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for LongestCircuit<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for LongestCircuit<SimpleGraph, i64> {
     type Result = ReductionLongestCircuitToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let m = self.num_edges();
         let edges = self.graph().edges();
         let lengths = self.edge_lengths();
 
+        let num_vars = m
+            .checked_mul(n)
+            .and_then(|flow| flow.checked_add(n))
+            .and_then(|flow_and_vertices| flow_and_vertices.checked_mul(2))
+            .and_then(|auxiliary| auxiliary.checked_add(m))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<Self, ILP<bool>>(
+                    "computing the number of cycle and flow variables",
+                )
+            })?;
+
         let y_idx = |e: usize| -> usize { e };
         let s_idx = |v: usize| -> usize { m + v };
-
-        // Multi-commodity flow for connectivity
-        let num_commodities = n.saturating_sub(1);
-        let num_flow = 2 * m * num_commodities;
-        let num_vars = m + n + num_flow;
-
+        let r_idx = |v: usize| -> usize { m + n + v };
         let flow_idx = |commodity: usize, edge: usize, dir: usize| -> usize {
-            m + n + commodity * 2 * m + 2 * edge + dir
+            m + 2 * n + commodity * 2 * m + 2 * edge + dir
         };
+        let mut vertex_edges = vec![Vec::new(); n];
+        for (edge, &(u, v)) in edges.iter().enumerate() {
+            vertex_edges[u].push(edge);
+            vertex_edges[v].push(edge);
+        }
 
         let mut constraints = Vec::new();
 
         // Degree constraints: sum_{e : v in e} y_e = 2 s_v for all v
-        for v in 0..n {
-            let mut terms: Vec<(usize, f64)> = Vec::new();
-            for (e, &(u, w)) in edges.iter().enumerate() {
-                if u == v || w == v {
-                    terms.push((y_idx(e), 1.0));
-                }
+        for (v, incident_edges) in vertex_edges.iter().enumerate() {
+            let mut terms: Vec<(usize, i64)> = Vec::new();
+            for &edge in incident_edges {
+                terms.push((y_idx(edge), 1));
             }
-            terms.push((s_idx(v), -2.0));
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            terms.push((s_idx(v), -2));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // At least 3 edges selected
-        let all_edge_terms: Vec<(usize, f64)> = (0..m).map(|e| (y_idx(e), 1.0)).collect();
-        constraints.push(LinearConstraint::ge(all_edge_terms, 3.0));
-
-        // Multi-commodity flow for connectivity
-        // Root = vertex 0. For each non-root vertex t (commodity index = t-1):
-        for t in 1..n {
-            let commodity = t - 1;
+        let all_edge_terms: Vec<(usize, i64)> = (0..m).map(|e| (y_idx(e), 1)).collect();
+        constraints.push(LinearConstraint::ge(all_edge_terms, 3));
+
+        // Choose exactly one root among the selected vertices.
+        constraints.push(LinearConstraint::eq(
+            (0..n).map(|v| (r_idx(v), 1)).collect(),
+            1,
+        ));
+        for v in 0..n {
+            constraints.push(LinearConstraint::le(vec![(r_idx(v), 1), (s_idx(v), -1)], 0));
+        }
 
+        // Each selected non-root vertex receives one unit from the chosen root.
+        for t in 0..n {
             // Flow conservation at each vertex v
-            for v in 0..n {
+            for (v, incident_edges) in vertex_edges.iter().enumerate() {
                 let mut terms = Vec::new();
-                for (e, &(u, w)) in edges.iter().enumerate() {
+                for &edge in incident_edges {
+                    let (u, _) = edges[edge];
                     // Forward dir: u->w, reverse dir: w->u
                     if u == v {
-                        terms.push((flow_idx(commodity, e, 0), 1.0)); // outgoing
-                        terms.push((flow_idx(commodity, e, 1), -1.0)); // incoming
-                    }
-                    if w == v {
-                        terms.push((flow_idx(commodity, e, 0), -1.0)); // incoming
-                        terms.push((flow_idx(commodity, e, 1), 1.0)); // outgoing
+                        terms.push((flow_idx(t, edge, 0), 1)); // outgoing
+                        terms.push((flow_idx(t, edge, 1), -1)); // incoming
+                    } else {
+                        terms.push((flow_idx(t, edge, 0), -1)); // incoming
+                        terms.push((flow_idx(t, edge, 1), 1)); // outgoing
                     }
                 }
 
-                if v == 0 {
-                    // Root: outflow - inflow = s_t
-                    terms.push((s_idx(t), -1.0));
-                    constraints.push(LinearConstraint::eq(terms, 0.0));
-                } else if v == t {
-                    // Target: outflow - inflow = -s_t
-                    terms.push((s_idx(t), 1.0));
-                    constraints.push(LinearConstraint::eq(terms, 0.0));
+                if v == t {
+                    // Target: outflow - inflow = r_t - s_t.
+                    terms.push((s_idx(t), 1));
+                    terms.push((r_idx(t), -1));
+                    constraints.push(LinearConstraint::eq(terms, 0));
                 } else {
-                    // Transit: outflow - inflow = 0
-                    constraints.push(LinearConstraint::eq(terms, 0.0));
+                    // Only the root can supply flow: 0 <= outflow - inflow <= r_v.
+                    constraints.push(LinearConstraint::ge(terms.clone(), 0));
+                    terms.push((r_idx(v), -1));
+                    constraints.push(LinearConstraint::le(terms, 0));
                 }
             }
 
             // Capacity: f^t_{e,dir} <= y_e
             for e in 0..m {
                 constraints.push(LinearConstraint::le(
-                    vec![(flow_idx(commodity, e, 0), 1.0), (y_idx(e), -1.0)],
-                    0.0,
+                    vec![(flow_idx(t, e, 0), 1), (y_idx(e), -1)],
+                    0,
                 ));
                 constraints.push(LinearConstraint::le(
-                    vec![(flow_idx(commodity, e, 1), 1.0), (y_idx(e), -1.0)],
-                    0.0,
+                    vec![(flow_idx(t, e, 1), 1), (y_idx(e), -1)],
+                    0,
                 ));
             }
         }
 
         // Objective: maximize total edge length
-        let objective: Vec<(usize, f64)> = lengths
+        let objective: Vec<(usize, i64)> = lengths
             .iter()
             .enumerate()
-            .map(|(e, &l)| (y_idx(e), l as f64))
+            .map(|(e, &length)| (y_idx(e), length))
             .collect();
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(Self::target_construction)?;
 
-        ReductionLongestCircuitToILP {
+        Ok(ReductionLongestCircuitToILP {
             target,
             num_edges: m,
-        }
+        })
     }
 }
 
diff --git a/src/rules/longestcommonsubsequence_ilp.rs b/src/rules/longestcommonsubsequence_ilp.rs
index 565305fc2..11225f470 100644
--- a/src/rules/longestcommonsubsequence_ilp.rs
+++ b/src/rules/longestcommonsubsequence_ilp.rs
@@ -31,29 +31,37 @@ impl ReductionResult for ReductionLCSToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_symbols = self.alphabet_size + 1;
-        let mut witness = Vec::with_capacity(self.max_length);
-        for position in 0..self.max_length {
-            let selected = (0..num_symbols)
-                .find(|&symbol| target_solution.get(position * num_symbols + symbol) == Some(&1))
-                .unwrap_or(self.alphabet_size);
-            witness.push(selected);
-        }
-        witness
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.max_length,
+            self.alphabet_size + 1,
+            0,
+        )?
+        .into_iter()
+        .map(|symbol| (symbol < self.alphabet_size).then_some(symbol))
+        .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "max_length * (alphabet_size + 1) + max_length * total_length",
         num_constraints = "max_length + num_transitions + max_length * num_strings + max_length * total_length + num_transitions * sum_triangular_lengths",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for LongestCommonSubsequence {
     type Result = ReductionLCSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let alphabet_size = self.alphabet_size();
         let max_length = self.max_length();
         let strings = self.strings();
@@ -78,9 +86,9 @@ impl ReduceTo<ILP<bool>> for LongestCommonSubsequence {
         // (1) Exactly one symbol (including padding) per witness position.
         for position in 0..max_length {
             let terms = (0..num_symbols)
-                .map(|symbol| (position * num_symbols + symbol, 1.0))
+                .map(|symbol| (position * num_symbols + symbol, 1))
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // (2) Contiguity: once padding starts, it stays padding.
@@ -88,10 +96,10 @@ impl ReduceTo<ILP<bool>> for LongestCommonSubsequence {
         for position in 0..max_length.saturating_sub(1) {
             constraints.push(LinearConstraint::ge(
                 vec![
-                    (position * num_symbols + padding, -1.0),
-                    ((position + 1) * num_symbols + padding, 1.0),
+                    (position * num_symbols + padding, -1),
+                    ((position + 1) * num_symbols + padding, 1),
                 ],
-                0.0,
+                0,
             ));
         }
 
@@ -100,11 +108,11 @@ impl ReduceTo<ILP<bool>> for LongestCommonSubsequence {
         //   sum_j y_(r,p,j) + x_(p, padding) = 1
         for (string_index, string) in strings.iter().enumerate() {
             for position in 0..max_length {
-                let mut terms: Vec<(usize, f64)> = (0..string.len())
-                    .map(|char_index| (match_var(string_index, position, char_index), 1.0))
+                let mut terms: Vec<(usize, i64)> = (0..string.len())
+                    .map(|char_index| (match_var(string_index, position, char_index), 1))
                     .collect();
-                terms.push((position * num_symbols + padding, 1.0));
-                constraints.push(LinearConstraint::eq(terms, 1.0));
+                terms.push((position * num_symbols + padding, 1));
+                constraints.push(LinearConstraint::eq(terms, 1));
             }
         }
 
@@ -115,10 +123,10 @@ impl ReduceTo<ILP<bool>> for LongestCommonSubsequence {
                 for (char_index, &symbol) in string.iter().enumerate() {
                     constraints.push(LinearConstraint::le(
                         vec![
-                            (match_var(string_index, position, char_index), 1.0),
-                            (position * num_symbols + symbol, -1.0),
+                            (match_var(string_index, position, char_index), 1),
+                            (position * num_symbols + symbol, -1),
                         ],
-                        0.0,
+                        0,
                     ));
                 }
             }
@@ -132,10 +140,10 @@ impl ReduceTo<ILP<bool>> for LongestCommonSubsequence {
                     for next in 0..=previous {
                         constraints.push(LinearConstraint::le(
                             vec![
-                                (match_var(string_index, position, previous), 1.0),
-                                (match_var(string_index, position + 1, next), 1.0),
+                                (match_var(string_index, position, previous), 1),
+                                (match_var(string_index, position + 1, next), 1),
                             ],
-                            1.0,
+                            1,
                         ));
                     }
                 }
@@ -146,17 +154,18 @@ impl ReduceTo<ILP<bool>> for LongestCommonSubsequence {
 
         // Objective: maximize number of non-padding positions.
         // maximize sum_p sum_{a != padding} x_(p,a)
-        let objective: Vec<(usize, f64)> = (0..max_length)
-            .flat_map(|p| (0..alphabet_size).map(move |a| (p * num_symbols + a, 1.0)))
+        let objective: Vec<(usize, i64)> = (0..max_length)
+            .flat_map(|p| (0..alphabet_size).map(move |a| (p * num_symbols + a, 1)))
             .collect();
 
-        let target = ILP::<bool>::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let target = ILP::<bool>::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionLCSToILP {
+        Ok(ReductionLCSToILP {
             target,
             alphabet_size,
             max_length,
-        }
+        })
     }
 }
 
diff --git a/src/rules/longestcommonsubsequence_maximumindependentset.rs b/src/rules/longestcommonsubsequence_maximumindependentset.rs
index 9cecb576a..be5454a14 100644
--- a/src/rules/longestcommonsubsequence_maximumindependentset.rs
+++ b/src/rules/longestcommonsubsequence_maximumindependentset.rs
@@ -32,8 +32,6 @@ pub struct ReductionLCSToIS {
     match_chars: Vec<usize>,
     /// Maximum possible subsequence length in the source problem.
     max_length: usize,
-    /// Alphabet size of the source problem (used as the padding symbol).
-    alphabet_size: usize,
 }
 
 impl ReductionResult for ReductionLCSToIS {
@@ -48,32 +46,39 @@ impl ReductionResult for ReductionLCSToIS {
     ///
     /// Selected vertices correspond to match nodes. Sort by position in
     /// the first string to get the subsequence order, then pad to `max_length`.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Collect selected match nodes with their characters
-        let mut selected: Vec<(usize, usize)> = target_solution
-            .iter()
-            .enumerate()
-            .filter(|(_, &v)| v == 1)
-            .map(|(i, _)| (self.match_nodes[i][0], self.match_chars[i]))
-            .collect();
-        // Sort by position in the first string
-        selected.sort_by_key(|&(pos, _)| pos);
-
-        // Build config: characters followed by padding
-        let mut config = Vec::with_capacity(self.max_length);
-        for &(_, ch) in &selected {
-            config.push(ch);
-        }
-        // Pad with alphabet_size (the padding symbol)
-        while config.len() < self.max_length {
-            config.push(self.alphabet_size);
-        }
-        config
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // Collect selected match nodes with their characters
+            let mut selected: Vec<(usize, usize)> = target_solution
+                .iter()
+                .enumerate()
+                .filter(|(_, &v)| v)
+                .map(|(i, _)| (self.match_nodes[i][0], self.match_chars[i]))
+                .collect();
+            // Sort by position in the first string
+            selected.sort_by_key(|&(pos, _)| pos);
+
+            // Build config: characters followed by padding
+            let mut config = Vec::with_capacity(self.max_length);
+            for &(_, ch) in &selected {
+                config.push(Some(ch));
+            }
+            // Pad with alphabet_size (the padding symbol)
+            while config.len() < self.max_length {
+                config.push(None);
+            }
+            config
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vertices = "cross_frequency_product",
         num_edges = "cross_frequency_product^2",
     }
@@ -81,7 +86,7 @@ impl ReductionResult for ReductionLCSToIS {
 impl ReduceTo<MaximumIndependentSet<SimpleGraph, One>> for LongestCommonSubsequence {
     type Result = ReductionLCSToIS;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let strings = self.strings();
         let k = self.num_strings();
 
@@ -133,13 +138,12 @@ impl ReduceTo<MaximumIndependentSet<SimpleGraph, One>> for LongestCommonSubseque
             vec![One; num_vertices],
         );
 
-        ReductionLCSToIS {
+        Ok(ReductionLCSToIS {
             target,
             match_nodes,
             match_chars,
             max_length: self.max_length(),
-            alphabet_size: self.alphabet_size(),
-        }
+        })
     }
 }
 
@@ -207,15 +211,15 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             //   c=B(1): v4=(1,0)
             //   c=C(2): v5=(3,2)
             // MIS {v2, v4, v5} => positions B@(1,0), A@(2,1), C@(3,2)
-            // source_config = [1, 0, 2, 3] (B, A, C, padding)
+            // source_config = [1, 0, 2, null] (B, A, C, padding)
             crate::example_db::specs::rule_example_with_witness::<
                 _,
                 MaximumIndependentSet<SimpleGraph, One>,
             >(
                 lcs_abac_baca(),
                 SolutionPair {
-                    source_config: vec![1, 0, 2, 3],
-                    target_config: vec![0, 0, 1, 0, 1, 1],
+                    source_config: serde_json::json!(vec![Some(1), Some(0), Some(2), None]),
+                    target_config: serde_json::json!(vec![false, false, true, false, true, true]),
                 },
             )
         },
diff --git a/src/rules/longestpath_ilp.rs b/src/rules/longestpath_ilp.rs
index 7c43a1a74..ef0246564 100644
--- a/src/rules/longestpath_ilp.rs
+++ b/src/rules/longestpath_ilp.rs
@@ -13,7 +13,7 @@ use crate::topology::{Graph, SimpleGraph};
 
 #[derive(Debug, Clone)]
 pub struct ReductionLongestPathToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_edges: usize,
 }
 
@@ -24,48 +24,54 @@ impl ReductionLongestPathToILP {
 }
 
 impl ReductionResult for ReductionLongestPathToILP {
-    type Source = LongestPath<SimpleGraph, i32>;
-    type Target = ILP<i32>;
+    type Source = LongestPath<SimpleGraph, i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.num_edges)
-            .map(|edge_idx| {
-                usize::from(
-                    target_solution
-                        .get(Self::arc_var(edge_idx, 0))
-                        .copied()
-                        .unwrap_or(0)
-                        > 0
-                        || target_solution
-                            .get(Self::arc_var(edge_idx, 1))
-                            .copied()
-                            .unwrap_or(0)
-                            > 0,
-                )
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            (0..self.num_edges)
+                .map(|edge_idx| {
+                    target_solution[Self::arc_var(edge_idx, 0)] > 0
+                        || target_solution[Self::arc_var(edge_idx, 1)] > 0
+                })
+                .collect()
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "2 * num_edges + num_vertices",
-    num_constraints = "5 * num_edges + 4 * num_vertices + 1",
-})]
-impl ReduceTo<ILP<i32>> for LongestPath<SimpleGraph, i32> {
+#[reduction(
+    transform = exact {
+        num_vars = "2 * num_edges + num_vertices",
+        num_constraints = "5 * num_edges + 4 * num_vertices + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<i64>> for LongestPath<SimpleGraph, i64> {
     type Result = ReductionLongestPathToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let edges = self.graph().edges();
         let num_vertices = self.num_vertices();
         let num_edges = self.num_edges();
         let num_vars = 2 * num_edges + num_vertices;
         let source = self.source_vertex();
         let target = self.target_vertex();
-        let big_m = num_vertices as f64;
+        let big_m = Self::exact_i64(num_vertices, "encoding the vertex order")?;
+        let max_order = Self::exact_i64(
+            num_vertices.saturating_sub(1),
+            "encoding the maximum vertex order",
+        )?;
 
         let order_var = |vertex: usize| 2 * num_edges + vertex;
 
@@ -75,31 +81,31 @@ impl ReduceTo<ILP<i32>> for LongestPath<SimpleGraph, i32> {
         for (edge_idx, &(u, v)) in edges.iter().enumerate() {
             let forward = ReductionLongestPathToILP::arc_var(edge_idx, 0);
             let reverse = ReductionLongestPathToILP::arc_var(edge_idx, 1);
-            outgoing[u].push((forward, 1.0));
-            incoming[v].push((forward, 1.0));
-            outgoing[v].push((reverse, 1.0));
-            incoming[u].push((reverse, 1.0));
+            outgoing[u].push((forward, 1));
+            incoming[v].push((forward, 1));
+            outgoing[v].push((reverse, 1));
+            incoming[u].push((reverse, 1));
         }
 
         let mut constraints = Vec::new();
 
-        // Directed arc variables are binary within ILP<i32>.
+        // Directed arc variables are binary within `ILP<i64>`.
         for edge_idx in 0..num_edges {
             constraints.push(LinearConstraint::le(
-                vec![(ReductionLongestPathToILP::arc_var(edge_idx, 0), 1.0)],
-                1.0,
+                vec![(ReductionLongestPathToILP::arc_var(edge_idx, 0), 1)],
+                1,
             ));
             constraints.push(LinearConstraint::le(
-                vec![(ReductionLongestPathToILP::arc_var(edge_idx, 1), 1.0)],
-                1.0,
+                vec![(ReductionLongestPathToILP::arc_var(edge_idx, 1), 1)],
+                1,
             ));
         }
 
         // Order variables stay within [0, |V|-1].
         for vertex in 0..num_vertices {
             constraints.push(LinearConstraint::le(
-                vec![(order_var(vertex), 1.0)],
-                num_vertices.saturating_sub(1) as f64,
+                vec![(order_var(vertex), 1)],
+                max_order,
             ));
         }
 
@@ -112,28 +118,28 @@ impl ReduceTo<ILP<i32>> for LongestPath<SimpleGraph, i32> {
 
             let rhs = if source != target {
                 if vertex == source {
-                    1.0
+                    1
                 } else if vertex == target {
-                    -1.0
+                    -1
                 } else {
-                    0.0
+                    0
                 }
             } else {
-                0.0
+                0
             };
             constraints.push(LinearConstraint::eq(balance_terms, rhs));
-            constraints.push(LinearConstraint::le(outgoing[vertex].clone(), 1.0));
-            constraints.push(LinearConstraint::le(incoming[vertex].clone(), 1.0));
+            constraints.push(LinearConstraint::le(outgoing[vertex].clone(), 1));
+            constraints.push(LinearConstraint::le(incoming[vertex].clone(), 1));
         }
 
         // An undirected edge can be used in at most one direction.
         for edge_idx in 0..num_edges {
             constraints.push(LinearConstraint::le(
                 vec![
-                    (ReductionLongestPathToILP::arc_var(edge_idx, 0), 1.0),
-                    (ReductionLongestPathToILP::arc_var(edge_idx, 1), 1.0),
+                    (ReductionLongestPathToILP::arc_var(edge_idx, 0), 1),
+                    (ReductionLongestPathToILP::arc_var(edge_idx, 1), 1),
                 ],
-                1.0,
+                1,
             ));
         }
 
@@ -141,35 +147,36 @@ impl ReduceTo<ILP<i32>> for LongestPath<SimpleGraph, i32> {
         for (edge_idx, &(u, v)) in edges.iter().enumerate() {
             constraints.push(LinearConstraint::ge(
                 vec![
-                    (order_var(v), 1.0),
-                    (order_var(u), -1.0),
+                    (order_var(v), 1),
+                    (order_var(u), -1),
                     (ReductionLongestPathToILP::arc_var(edge_idx, 0), -big_m),
                 ],
-                1.0 - big_m,
+                1 - big_m,
             ));
             constraints.push(LinearConstraint::ge(
                 vec![
-                    (order_var(u), 1.0),
-                    (order_var(v), -1.0),
+                    (order_var(u), 1),
+                    (order_var(v), -1),
                     (ReductionLongestPathToILP::arc_var(edge_idx, 1), -big_m),
                 ],
-                1.0 - big_m,
+                1 - big_m,
             ));
         }
 
-        constraints.push(LinearConstraint::eq(vec![(order_var(source), 1.0)], 0.0));
+        constraints.push(LinearConstraint::eq(vec![(order_var(source), 1)], 0));
 
         let mut objective = Vec::with_capacity(2 * num_edges);
         for (edge_idx, length) in self.edge_lengths().iter().enumerate() {
-            let coeff = f64::from(*length);
+            let coeff = *length;
             objective.push((ReductionLongestPathToILP::arc_var(edge_idx, 0), coeff));
             objective.push((ReductionLongestPathToILP::arc_var(edge_idx, 1), coeff));
         }
 
-        ReductionLongestPathToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize),
+        Ok(ReductionLongestPathToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+                .map_err(Self::target_construction)?,
             num_edges,
-        }
+        })
     }
 }
 
@@ -180,7 +187,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             let source =
                 LongestPath::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![2, 3], 0, 2);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/maxcut_minimumcutintoboundedsets.rs b/src/rules/maxcut_minimumcutintoboundedsets.rs
index e3289b666..795c46ffb 100644
--- a/src/rules/maxcut_minimumcutintoboundedsets.rs
+++ b/src/rules/maxcut_minimumcutintoboundedsets.rs
@@ -15,14 +15,14 @@ use crate::topology::{Graph, SimpleGraph};
 /// Result of reducing MaxCut to MinimumCutIntoBoundedSets.
 #[derive(Debug, Clone)]
 pub struct ReductionMaxCutToMinCutBounded {
-    target: MinimumCutIntoBoundedSets<SimpleGraph, i32>,
+    target: MinimumCutIntoBoundedSets<SimpleGraph, i64>,
     /// Number of original vertices in the source problem.
     original_n: usize,
 }
 
 impl ReductionResult for ReductionMaxCutToMinCutBounded {
-    type Source = MaxCut<SimpleGraph, i32>;
-    type Target = MinimumCutIntoBoundedSets<SimpleGraph, i32>;
+    type Source = MaxCut<SimpleGraph, i64>;
+    type Target = MinimumCutIntoBoundedSets<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
@@ -30,37 +30,63 @@ impl ReductionResult for ReductionMaxCutToMinCutBounded {
 
     /// Extract the source solution from the target balanced bisection.
     /// Take only the first `original_n` vertex assignments.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.original_n].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.original_n].to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "2 * num_vertices + 2",
         num_edges = "(num_vertices + 1) * (2 * num_vertices + 1)",
     }
 )]
-impl ReduceTo<MinimumCutIntoBoundedSets<SimpleGraph, i32>> for MaxCut<SimpleGraph, i32> {
+impl ReduceTo<MinimumCutIntoBoundedSets<SimpleGraph, i64>> for MaxCut<SimpleGraph, i64> {
     type Result = ReductionMaxCutToMinCutBounded;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
 
         // Step 1: Pad to even vertex count.
         // n' = n if n is even, n+1 if n is odd. N = 2*n'.
-        let n_prime = n + (n % 2); // round up to even
-        let big_n = 2 * n_prime;
+        let n_prime = n.checked_add(n % 2).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                MaxCut<SimpleGraph, i64>,
+                MinimumCutIntoBoundedSets<SimpleGraph, i64>,
+            >("padding the source vertex count")
+        })?;
+        let big_n = n_prime.checked_mul(2).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                MaxCut<SimpleGraph, i64>,
+                MinimumCutIntoBoundedSets<SimpleGraph, i64>,
+            >("computing the target vertex count")
+        })?;
 
         // Step 2: Compute W_max
-        let w_max = self.edge_weights().iter().copied().max().unwrap_or(0) + 1;
+        let w_max = self
+            .edge_weights()
+            .iter()
+            .copied()
+            .max()
+            .unwrap_or(0)
+            .checked_add(1)
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    MaxCut<SimpleGraph, i64>,
+                    MinimumCutIntoBoundedSets<SimpleGraph, i64>,
+                >("computing the inverted-weight ceiling")
+            })?;
 
         // Build an adjacency lookup for the original graph
         let orig_edges = self.graph().edges();
-        let mut edge_weight_map: std::collections::HashMap<(usize, usize), i32> =
+        let mut edge_weight_map: std::collections::HashMap<(usize, usize), i64> =
             std::collections::HashMap::new();
-        for (idx, &(u, v)) in orig_edges.iter().enumerate() {
-            let w = *self.edge_weight_by_index(idx).unwrap();
+        for (&(u, v), w) in orig_edges.iter().zip(self.edge_weights()) {
             let (a, b) = if u < v { (u, v) } else { (v, u) };
             edge_weight_map.insert((a, b), w);
         }
@@ -72,7 +98,12 @@ impl ReduceTo<MinimumCutIntoBoundedSets<SimpleGraph, i32>> for MaxCut<SimpleGrap
             for j in (i + 1)..big_n {
                 edges.push((i, j));
                 if let Some(&w) = edge_weight_map.get(&(i, j)) {
-                    weights.push(w_max - w);
+                    weights.push(w_max.checked_sub(w).ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<
+                            MaxCut<SimpleGraph, i64>,
+                            MinimumCutIntoBoundedSets<SimpleGraph, i64>,
+                        >("inverting an edge weight")
+                    })?);
                 } else {
                     weights.push(w_max);
                 }
@@ -81,7 +112,12 @@ impl ReduceTo<MinimumCutIntoBoundedSets<SimpleGraph, i32>> for MaxCut<SimpleGrap
 
         // Step 4: Set source, sink, size_bound
         let source_vertex = n_prime;
-        let sink_vertex = n_prime + 1;
+        let sink_vertex = n_prime.checked_add(1).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                MaxCut<SimpleGraph, i64>,
+                MinimumCutIntoBoundedSets<SimpleGraph, i64>,
+            >("computing the target sink vertex")
+        })?;
         let size_bound = n_prime;
 
         let target = MinimumCutIntoBoundedSets::new(
@@ -92,10 +128,10 @@ impl ReduceTo<MinimumCutIntoBoundedSets<SimpleGraph, i32>> for MaxCut<SimpleGrap
             size_bound,
         );
 
-        ReductionMaxCutToMinCutBounded {
+        Ok(ReductionMaxCutToMinCutBounded {
             target,
             original_n: n,
-        }
+        })
     }
 }
 
@@ -110,22 +146,29 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Triangle with unit weights: max cut = 2
             let source = MaxCut::new(
                 SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-                vec![1i32, 1, 1],
+                vec![1i64, 1, 1],
             );
             let reduction =
-                ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i32>>::reduce_to(&source);
+                ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i64>>::reduce_to(&source)
+                    .expect("reduction should succeed");
 
             // Find optimal source and target solutions
             let solver = BruteForce::new();
-            let source_witness = solver.find_witness(&source).unwrap();
-            let target_witness = solver.find_witness(reduction.target_problem()).unwrap();
+            let source_witness = solver
+                .solve(&source)
+                .expect("canonical source evaluation must succeed")
+                .expect("canonical source must have an optimum");
+            let target_witness = solver
+                .solve(reduction.target_problem())
+                .expect("canonical target evaluation must succeed")
+                .expect("canonical target must have an optimum");
 
             crate::example_db::specs::assemble_rule_example(
                 &source,
                 reduction.target_problem(),
                 vec![SolutionPair {
-                    source_config: source_witness,
-                    target_config: target_witness,
+                    source_config: serde_json::json!(source_witness),
+                    target_config: serde_json::json!(target_witness),
                 }],
             )
         },
diff --git a/src/rules/maxcut_minimummatrixcover.rs b/src/rules/maxcut_minimummatrixcover.rs
index 3cc465185..a1e8f50c7 100644
--- a/src/rules/maxcut_minimummatrixcover.rs
+++ b/src/rules/maxcut_minimummatrixcover.rs
@@ -33,7 +33,7 @@ pub struct ReductionMaxCutToMMC {
 }
 
 impl ReductionResult for ReductionMaxCutToMMC {
-    type Source = MaxCut<SimpleGraph, i32>;
+    type Source = MaxCut<SimpleGraph, i64>;
     type Target = MinimumMatrixCover;
 
     fn target_problem(&self) -> &Self::Target {
@@ -48,36 +48,45 @@ impl ReductionResult for ReductionMaxCutToMMC {
     /// vertex `i` in `S`. The complementary assignment is equally optimal
     /// because the quadratic form (and the cut) is invariant under
     /// `f -> -f`.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_rows = "num_vertices",
     }
 )]
-impl ReduceTo<MinimumMatrixCover> for MaxCut<SimpleGraph, i32> {
+impl ReduceTo<MinimumMatrixCover> for MaxCut<SimpleGraph, i64> {
     type Result = ReductionMaxCutToMMC;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let mut matrix: Vec<Vec<i64>> = vec![vec![0i64; n]; n];
 
         for (u, v, w) in self.edges() {
-            assert!(
-                w >= 0,
-                "MaxCut -> MinimumMatrixCover requires nonnegative edge weights, got w({u},{v}) = {w}"
-            );
-            let w64 = w as i64;
+            if w < 0 {
+                return Err(crate::rules::ReductionError::invalid_target::<
+                    MaxCut<SimpleGraph, i64>,
+                    MinimumMatrixCover,
+                >(format!(
+                    "edge ({u}, {v}) has negative weight {w}"
+                )));
+            }
+            let w64 = w;
             matrix[u][v] = w64;
             matrix[v][u] = w64;
         }
 
-        ReductionMaxCutToMMC {
+        Ok(ReductionMaxCutToMMC {
             target: MinimumMatrixCover::new(matrix),
-        }
+        })
     }
 }
 
@@ -91,7 +100,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Canonical example: C_4 (4-cycle) with unit weights.
             // W = 4, max cut = 4 (partition {0,2} vs {1,3} cuts all edges).
             // The target's minimum quadratic form value is 2W - 4 * cut = 8 - 16 = -8.
-            let source = MaxCut::<SimpleGraph, i32>::new(
+            let source = MaxCut::<SimpleGraph, i64>::new(
                 SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (0, 3)]),
                 vec![1, 1, 1, 1],
             );
@@ -99,8 +108,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 source,
                 SolutionPair {
                     // S = {0, 2}: vertices 0 and 2 have f = +1.
-                    source_config: vec![1, 0, 1, 0],
-                    target_config: vec![1, 0, 1, 0],
+                    source_config: serde_json::json!(vec![true, false, true, false]),
+                    target_config: serde_json::json!(vec![true, false, true, false]),
                 },
             )
         },
diff --git a/src/rules/maximalis_ilp.rs b/src/rules/maximalis_ilp.rs
index 8e0f45a00..1d2e3f93c 100644
--- a/src/rules/maximalis_ilp.rs
+++ b/src/rules/maximalis_ilp.rs
@@ -15,28 +15,36 @@ pub struct ReductionMxISToILP {
 }
 
 impl ReductionResult for ReductionMxISToILP {
-    type Source = MaximalIS<SimpleGraph, i32>;
+    type Source = MaximalIS<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices",
         num_constraints = "num_edges + num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MaximalIS<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for MaximalIS<SimpleGraph, i64> {
     type Result = ReductionMxISToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let mut constraints = Vec::new();
 
@@ -44,30 +52,31 @@ impl ReduceTo<ILP<bool>> for MaximalIS<SimpleGraph, i32> {
         for u in 0..n {
             for v in (u + 1)..n {
                 if self.graph().has_edge(u, v) {
-                    constraints.push(LinearConstraint::le(vec![(u, 1.0), (v, 1.0)], 1.0));
+                    constraints.push(LinearConstraint::le(vec![(u, 1), (v, 1)], 1));
                 }
             }
         }
 
         // Maximality: ∀ v: x_v + Σ_{u∈N(v)} x_u ≥ 1
         for v in 0..n {
-            let mut terms = vec![(v, 1.0)];
+            let mut terms = vec![(v, 1)];
             for u in self.graph().neighbors(v) {
-                terms.push((u, 1.0));
+                terms.push((u, 1));
             }
-            constraints.push(LinearConstraint::ge(terms, 1.0));
+            constraints.push(LinearConstraint::ge(terms, 1));
         }
 
         // Objective: Maximize Σ w_v·x_v
         let weights = self.weights();
-        let objective: Vec<(usize, f64)> = weights
+        let objective: Vec<(usize, i64)> = weights
             .iter()
             .enumerate()
-            .map(|(i, w)| (i, *w as f64))
+            .map(|(i, &weight)| (i, weight))
             .collect();
 
-        let target = ILP::new(n, constraints, objective, ObjectiveSense::Maximize);
-        ReductionMxISToILP { target }
+        let target = ILP::new(n, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionMxISToILP { target })
     }
 }
 
diff --git a/src/rules/maximum2satisfiability_ilp.rs b/src/rules/maximum2satisfiability_ilp.rs
index 1631aff91..cfa12df13 100644
--- a/src/rules/maximum2satisfiability_ilp.rs
+++ b/src/rules/maximum2satisfiability_ilp.rs
@@ -27,21 +27,32 @@ impl ReductionResult for ReductionMaximum2SatisfiabilityToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vars].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_vars]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vars + num_clauses",
         num_constraints = "num_clauses",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for Maximum2Satisfiability {
     type Result = ReductionMaximum2SatisfiabilityToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vars();
         let m = self.num_clauses();
         let num_ilp_vars = n + m;
@@ -58,42 +69,43 @@ impl ReduceTo<ILP<bool>> for Maximum2Satisfiability {
             .iter()
             .enumerate()
             .map(|(j, clause)| {
-                let mut terms: Vec<(usize, f64)> = Vec::new();
-                let mut neg_count = 0i32;
+                let mut terms: Vec<(usize, i64)> = Vec::new();
+                let mut neg_count = 0;
 
                 // z_{n+j} has coefficient +1
-                terms.push((n + j, 1.0));
+                terms.push((n + j, 1));
 
                 for &lit in &clause.literals {
                     let var_idx = lit.unsigned_abs() as usize - 1;
                     if lit > 0 {
                         // positive literal: subtract y_i
-                        terms.push((var_idx, -1.0));
+                        terms.push((var_idx, -1));
                     } else {
                         // negative literal: add y_i
-                        terms.push((var_idx, 1.0));
+                        terms.push((var_idx, 1));
                         neg_count += 1;
                     }
                 }
 
-                LinearConstraint::le(terms, neg_count as f64)
+                LinearConstraint::le(terms, neg_count)
             })
             .collect();
 
         // Objective: maximize sum of z_j indicators
-        let objective: Vec<(usize, f64)> = (0..m).map(|j| (n + j, 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..m).map(|j| (n + j, 1)).collect();
 
         let target = ILP::new(
             num_ilp_vars,
             constraints,
             objective,
             ObjectiveSense::Maximize,
-        );
+        )
+        .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionMaximum2SatisfiabilityToILP {
+        Ok(ReductionMaximum2SatisfiabilityToILP {
             target,
             num_vars: n,
-        }
+        })
     }
 }
 
@@ -130,8 +142,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 0, 1],
-                    target_config: vec![1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1],
+                    source_config: serde_json::json!(vec![true, true, false, true]),
+                    target_config: serde_json::json!(vec![1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1]),
                 },
             )
         },
diff --git a/src/rules/maximum2satisfiability_maxcut.rs b/src/rules/maximum2satisfiability_maxcut.rs
index 8b0e8d6cd..e153b5d4f 100644
--- a/src/rules/maximum2satisfiability_maxcut.rs
+++ b/src/rules/maximum2satisfiability_maxcut.rs
@@ -21,32 +21,39 @@ use std::collections::BTreeMap;
 /// Result of reducing Maximum2Satisfiability to MaxCut.
 #[derive(Debug, Clone)]
 pub struct ReductionMaximum2SatisfiabilityToMaxCut {
-    target: MaxCut<SimpleGraph, i32>,
+    target: MaxCut<SimpleGraph, i64>,
     source_num_vars: usize,
 }
 
 impl ReductionResult for ReductionMaximum2SatisfiabilityToMaxCut {
     type Source = Maximum2Satisfiability;
-    type Target = MaxCut<SimpleGraph, i32>;
+    type Target = MaxCut<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let reference_side = target_solution[0];
-        (0..self.source_num_vars)
-            .map(|i| usize::from(target_solution[i + 1] == reference_side))
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let reference_side = target_solution[0];
+            (0..self.source_num_vars)
+                .map(|i| target_solution[i + 1] == reference_side)
+                .collect()
+        })
     }
 }
 
-fn add_edge_weight(weights: &mut BTreeMap<(usize, usize), i32>, u: usize, v: usize, delta: i32) {
+fn add_edge_weight(weights: &mut BTreeMap<(usize, usize), i64>, u: usize, v: usize, delta: i64) {
     let edge = if u < v { (u, v) } else { (v, u) };
     *weights.entry(edge).or_insert(0) += delta;
 }
 
-fn literal_polarity(lit: i32) -> i32 {
+fn literal_polarity(lit: i64) -> i64 {
     if lit > 0 {
         1
     } else {
@@ -55,15 +62,15 @@ fn literal_polarity(lit: i32) -> i32 {
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vertices = "num_vars + 1",
-        num_edges = "num_vars + num_clauses",
+        num_edges = "(num_vars + 1)^2",
     }
 )]
-impl ReduceTo<MaxCut<SimpleGraph, i32>> for Maximum2Satisfiability {
+impl ReduceTo<MaxCut<SimpleGraph, i64>> for Maximum2Satisfiability {
     type Result = ReductionMaximum2SatisfiabilityToMaxCut;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let mut accumulated = BTreeMap::new();
 
         for clause in self.clauses() {
@@ -88,10 +95,10 @@ impl ReduceTo<MaxCut<SimpleGraph, i32>> for Maximum2Satisfiability {
 
         let target = MaxCut::new(SimpleGraph::new(self.num_vars() + 1, edges), weights);
 
-        ReductionMaximum2SatisfiabilityToMaxCut {
+        Ok(ReductionMaximum2SatisfiabilityToMaxCut {
             target,
             source_num_vars: self.num_vars(),
-        }
+        })
     }
 }
 
@@ -113,14 +120,14 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     CNFClause::new(vec![1, 3]),
                 ],
             );
-            crate::example_db::specs::rule_example_with_witness::<_, MaxCut<SimpleGraph, i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, MaxCut<SimpleGraph, i64>>(
                 source,
                 SolutionPair {
                     // x1=F, x2=T, x3=T satisfies all five clauses.
-                    source_config: vec![0, 1, 1],
+                    source_config: serde_json::json!(vec![false, true, true]),
                     // Vertex 0 is the reference vertex s. Variables are true
                     // exactly when they share s's side of the cut.
-                    target_config: vec![0, 1, 0, 0],
+                    target_config: serde_json::json!(vec![false, true, false, false]),
                 },
             )
         },
diff --git a/src/rules/maximumclique_ilp.rs b/src/rules/maximumclique_ilp.rs
index c0ac43130..7f62e15b1 100644
--- a/src/rules/maximumclique_ilp.rs
+++ b/src/rules/maximumclique_ilp.rs
@@ -24,7 +24,7 @@ pub struct ReductionCliqueToILP {
 }
 
 impl ReductionResult for ReductionCliqueToILP {
-    type Source = MaximumClique<SimpleGraph, i32>;
+    type Source = MaximumClique<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
@@ -35,21 +35,29 @@ impl ReductionResult for ReductionCliqueToILP {
     ///
     /// Since the mapping is 1:1 (each vertex maps to one binary variable),
     /// the solution extraction is simply copying the configuration.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_vertices",
         num_constraints = "num_vertices^2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MaximumClique<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for MaximumClique<SimpleGraph, i64> {
     type Result = ReductionCliqueToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.graph().num_vertices();
 
         // Constraints: x_u + x_v <= 1 for each NON-EDGE (u, v)
@@ -59,22 +67,23 @@ impl ReduceTo<ILP<bool>> for MaximumClique<SimpleGraph, i32> {
         for u in 0..num_vars {
             for v in (u + 1)..num_vars {
                 if !self.graph().has_edge(u, v) {
-                    constraints.push(LinearConstraint::le(vec![(u, 1.0), (v, 1.0)], 1.0));
+                    constraints.push(LinearConstraint::le(vec![(u, 1), (v, 1)], 1));
                 }
             }
         }
 
         // Objective: maximize sum of w_i * x_i (weighted sum of selected vertices)
-        let objective: Vec<(usize, f64)> = self
+        let objective: Vec<(usize, i64)> = self
             .weights()
             .iter()
             .enumerate()
-            .map(|(i, &w)| (i, w as f64))
+            .map(|(i, &weight)| (i, weight))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionCliqueToILP { target }
+        Ok(ReductionCliqueToILP { target })
     }
 }
 
@@ -84,7 +93,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "maximumclique_to_ilp",
         build: || {
             let (n, edges) = crate::topology::small_graphs::octahedral();
-            let source = MaximumClique::new(SimpleGraph::new(n, edges), vec![1i32; 6]);
+            let source = MaximumClique::new(SimpleGraph::new(n, edges), vec![1i64; 6]);
             crate::example_db::specs::rule_example_via_ilp::<_, bool>(source)
         },
     }]
diff --git a/src/rules/maximumclique_maximumindependentset.rs b/src/rules/maximumclique_maximumindependentset.rs
index 91bd6ebbf..7a42f27f4 100644
--- a/src/rules/maximumclique_maximumindependentset.rs
+++ b/src/rules/maximumclique_maximumindependentset.rs
@@ -28,8 +28,13 @@ where
 
     /// Solution extraction: identity mapping.
     /// A clique in G is an independent set in the complement, so the configuration is the same.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
@@ -45,21 +50,21 @@ fn reduce_clique_to_is<W: WeightElement>(
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_vertices * (num_vertices - 1) / 2 - num_edges",
     }
 )]
-impl ReduceTo<MaximumIndependentSet<SimpleGraph, i32>> for MaximumClique<SimpleGraph, i32> {
-    type Result = ReductionCliqueToIS<i32>;
+impl ReduceTo<MaximumIndependentSet<SimpleGraph, i64>> for MaximumClique<SimpleGraph, i64> {
+    type Result = ReductionCliqueToIS<i64>;
 
-    fn reduce_to(&self) -> Self::Result {
-        reduce_clique_to_is(self)
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(reduce_clique_to_is(self))
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_vertices * (num_vertices - 1) / 2 - num_edges",
     }
@@ -67,8 +72,8 @@ impl ReduceTo<MaximumIndependentSet<SimpleGraph, i32>> for MaximumClique<SimpleG
 impl ReduceTo<MaximumIndependentSet<SimpleGraph, One>> for MaximumClique<SimpleGraph, One> {
     type Result = ReductionCliqueToIS<One>;
 
-    fn reduce_to(&self) -> Self::Result {
-        reduce_clique_to_is(self)
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(reduce_clique_to_is(self))
     }
 }
 
@@ -78,26 +83,26 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
 
     vec![
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumclique_to_maximumindependentset",
+            id: "weighted_maximumclique_to_maximumindependentset",
             build: || {
                 let source = MaximumClique::new(
                     SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-                    vec![1i32; 4],
+                    vec![1i64; 4],
                 );
                 crate::example_db::specs::rule_example_with_witness::<
                     _,
-                    MaximumIndependentSet<SimpleGraph, i32>,
+                    MaximumIndependentSet<SimpleGraph, i64>,
                 >(
                     source,
                     SolutionPair {
-                        source_config: vec![0, 1, 1, 0],
-                        target_config: vec![0, 1, 1, 0],
+                        source_config: serde_json::json!(vec![false, true, true, false]),
+                        target_config: serde_json::json!(vec![false, true, true, false]),
                     },
                 )
             },
         },
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumclique_to_maximumindependentset_one",
+            id: "cardinality_maximumclique_to_maximumindependentset",
             build: || {
                 let source = MaximumClique::new(
                     SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
@@ -109,8 +114,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 >(
                     source,
                     SolutionPair {
-                        source_config: vec![0, 1, 1, 0],
-                        target_config: vec![0, 1, 1, 0],
+                        source_config: serde_json::json!(vec![false, true, true, false]),
+                        target_config: serde_json::json!(vec![false, true, true, false]),
                     },
                 )
             },
diff --git a/src/rules/maximumcokplex_ilp.rs b/src/rules/maximumcokplex_ilp.rs
index 4e809c7f2..8021bb316 100644
--- a/src/rules/maximumcokplex_ilp.rs
+++ b/src/rules/maximumcokplex_ilp.rs
@@ -31,81 +31,110 @@ where
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
-fn build_constraints(graph: &SimpleGraph, bound_k: usize) -> Vec<LinearConstraint> {
+fn build_constraints(graph: &SimpleGraph, bound_k: usize) -> Result<Vec<LinearConstraint>, ()> {
     (0..graph.num_vertices())
         .map(|v| {
-            let degree = graph.degree(v) as f64;
-            let mut terms: Vec<(usize, f64)> =
-                graph.neighbors(v).into_iter().map(|u| (u, 1.0)).collect();
-            if degree > 0.0 {
+            let degree = i64::try_from(graph.degree(v)).map_err(|_| ())?;
+            let bound_k = i64::try_from(bound_k).map_err(|_| ())?;
+            let mut terms: Vec<(usize, i64)> =
+                graph.neighbors(v).into_iter().map(|u| (u, 1)).collect();
+            if degree > 0 {
                 terms.push((v, degree));
             }
-            LinearConstraint::le(terms, degree + (bound_k - 1) as f64)
+            let rhs = degree
+                .checked_add(bound_k)
+                .and_then(|value| value.checked_sub(1))
+                .ok_or(())?;
+            Ok(LinearConstraint::le(terms, rhs))
         })
         .collect()
 }
 
 fn reduce_cokplex_to_ilp<W>(
     src: &MaximumCoKPlex<SimpleGraph, W, KN>,
-    objective: Vec<(usize, f64)>,
-) -> ReductionCoKPlexToILP<W>
+    constraints: Vec<LinearConstraint>,
+    objective: Vec<(usize, i64)>,
+) -> Result<ReductionCoKPlexToILP<W>, crate::registry::ConstructionError>
 where
     W: WeightElement + VariantParam,
 {
     let target = ILP::new(
         src.num_vertices(),
-        build_constraints(src.graph(), src.bound_k()),
+        constraints,
         objective,
         ObjectiveSense::Maximize,
-    );
-    ReductionCoKPlexToILP {
+    )?;
+    Ok(ReductionCoKPlexToILP {
         target,
         _marker: PhantomData,
-    }
+    })
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices",
         num_constraints = "num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MaximumCoKPlex<SimpleGraph, i32, KN> {
-    type Result = ReductionCoKPlexToILP<i32>;
+impl ReduceTo<ILP<bool>> for MaximumCoKPlex<SimpleGraph, i64, KN> {
+    type Result = ReductionCoKPlexToILP<i64>;
 
-    fn reduce_to(&self) -> Self::Result {
-        let objective: Vec<(usize, f64)> = self
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let objective: Vec<(usize, i64)> = self
             .weights()
             .iter()
             .enumerate()
-            .map(|(v, &weight)| (v, weight as f64))
+            .map(|(vertex, &weight)| (vertex, weight))
             .collect();
-        reduce_cokplex_to_ilp(self, objective)
+        let constraints = build_constraints(self.graph(), self.bound_k()).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                MaximumCoKPlex<SimpleGraph, i64, KN>,
+                ILP<bool>,
+            >("encoding a degree or co-k-plex bound")
+        })?;
+        reduce_cokplex_to_ilp(self, constraints, objective).map_err(Self::target_construction)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices",
         num_constraints = "num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MaximumCoKPlex<SimpleGraph, One, KN> {
     type Result = ReductionCoKPlexToILP<One>;
 
-    fn reduce_to(&self) -> Self::Result {
-        let objective: Vec<(usize, f64)> = self
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let objective: Vec<(usize, i64)> = self
             .weights()
             .iter()
             .enumerate()
-            .map(|(v, _)| (v, 1.0))
+            .map(|(v, _)| (v, 1))
             .collect();
-        reduce_cokplex_to_ilp(self, objective)
+        let constraints = build_constraints(self.graph(), self.bound_k()).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                MaximumCoKPlex<SimpleGraph, One, KN>,
+                ILP<bool>,
+            >("encoding a degree or co-k-plex bound")
+        })?;
+        reduce_cokplex_to_ilp(self, constraints, objective).map_err(Self::target_construction)
     }
 }
 
@@ -113,9 +142,9 @@ impl ReduceTo<ILP<bool>> for MaximumCoKPlex<SimpleGraph, One, KN> {
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
     vec![
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumcokplex_i32_to_ilp",
+            id: "weighted_maximumcokplex_to_ilp",
             build: || {
-                let source = MaximumCoKPlex::<_, i32, KN>::with_k(
+                let source = MaximumCoKPlex::<_, i64, KN>::with_k(
                     SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]),
                     vec![5, 1, 4, 1, 3],
                     2,
@@ -124,7 +153,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             },
         },
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumcokplex_one_to_ilp",
+            id: "cardinality_maximumcokplex_to_ilp",
             build: || {
                 let source = MaximumCoKPlex::<_, One, KN>::with_k(
                     SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]),
diff --git a/src/rules/maximumcommonedgesubgraph_ilp.rs b/src/rules/maximumcommonedgesubgraph_ilp.rs
index a36090ec4..4ab7d8858 100644
--- a/src/rules/maximumcommonedgesubgraph_ilp.rs
+++ b/src/rules/maximumcommonedgesubgraph_ilp.rs
@@ -43,29 +43,42 @@ impl ReductionResult for ReductionMCESToILP {
     /// Extract: for each source vertex `u`, output the unique target vertex
     /// `p` with `x_(u,p) = 1`, or the sentinel `n2` ("bottom") when no
     /// mapping variable is selected.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n1 = self.num_vertices_1;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         let n2 = self.num_vertices_2;
-        (0..n1)
-            .map(|u| {
-                (0..n2)
-                    .find(|&p| target_solution[u * n2 + p] == 1)
-                    .unwrap_or(n2)
+        (0..self.num_vertices_1)
+            .map(|vertex| {
+                let mut selected =
+                    (0..n2).filter(|&mapped| target_solution[vertex * n2 + mapped] == 1);
+                match (selected.next(), selected.next()) {
+                    (Some(mapped), None) => Ok(mapped),
+                    (None, _) => Ok(n2),
+                    (Some(_), Some(_)) => Err(crate::rules::ExtractionError::invalid(format!(
+                        "source vertex {vertex} maps to multiple target vertices"
+                    ))),
+                }
             })
             .collect()
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_vertices_1 * num_vertices_2 + num_arcs_1 * num_arcs_2",
         num_constraints = "num_vertices_1 + num_vertices_2 + 3 * num_arcs_1 * num_arcs_2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MaximumCommonEdgeSubgraph {
     type Result = ReductionMCESToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n1 = self.num_vertices_1();
         let n2 = self.num_vertices_2();
         let arcs_1 = self.graph_1().arcs();
@@ -93,14 +106,14 @@ impl ReduceTo<ILP<bool>> for MaximumCommonEdgeSubgraph {
 
         // Row constraints: each source vertex maps to at most one target.
         for u in 0..n1 {
-            let terms: Vec<(usize, f64)> = (0..n2).map(|p| (x_idx(u, p), 1.0)).collect();
-            constraints.push(LinearConstraint::le(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n2).map(|p| (x_idx(u, p), 1)).collect();
+            constraints.push(LinearConstraint::le(terms, 1));
         }
 
         // Column constraints: each target vertex receives at most one source.
         for p in 0..n2 {
-            let terms: Vec<(usize, f64)> = (0..n1).map(|u| (x_idx(u, p), 1.0)).collect();
-            constraints.push(LinearConstraint::le(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n1).map(|u| (x_idx(u, p), 1)).collect();
+            constraints.push(LinearConstraint::le(terms, 1));
         }
 
         // Linking constraints: y_(a,b) = x_(u,p) AND x_(v,q) via McCormick.
@@ -115,15 +128,16 @@ impl ReduceTo<ILP<bool>> for MaximumCommonEdgeSubgraph {
         }
 
         // Objective: maximize the number of preserved labelled arcs.
-        let objective: Vec<(usize, f64)> = (0..num_y).map(|seq| (y_idx(seq), 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..num_y).map(|seq| (y_idx(seq), 1)).collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(Self::target_construction)?;
 
-        ReductionMCESToILP {
+        Ok(ReductionMCESToILP {
             target,
             num_vertices_1: n1,
             num_vertices_2: n2,
-        }
+        })
     }
 }
 
diff --git a/src/rules/maximumcontactmapoverlap_ilp.rs b/src/rules/maximumcontactmapoverlap_ilp.rs
index 6607997da..709e0053f 100644
--- a/src/rules/maximumcontactmapoverlap_ilp.rs
+++ b/src/rules/maximumcontactmapoverlap_ilp.rs
@@ -46,30 +46,42 @@ impl ReductionResult for ReductionCMOToILP {
     /// For each source residue `i in V_1`, find the unique `j` with
     /// `x_(i,j) = 1` and encode it as `j + 1` (CMO's `bot` is `0`); if no
     /// `x_(i,*)` is selected, the residue is left unmatched (`0`).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n1 = self.num_vertices_1;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         let n2 = self.num_vertices_2;
-        (0..n1)
-            .map(|i| {
-                (0..n2)
-                    .find(|&j| target_solution[i * n2 + j] == 1)
-                    .map(|j| j + 1)
-                    .unwrap_or(0)
+        (0..self.num_vertices_1)
+            .map(|residue| {
+                let mut selected =
+                    (0..n2).filter(|&mapped| target_solution[residue * n2 + mapped] == 1);
+                match (selected.next(), selected.next()) {
+                    (Some(mapped), None) => Ok(mapped + 1),
+                    (None, _) => Ok(0),
+                    (Some(_), Some(_)) => Err(crate::rules::ExtractionError::invalid(format!(
+                        "source residue {residue} maps to multiple target residues"
+                    ))),
+                }
             })
             .collect()
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices_1 * num_vertices_2 + num_contacts_1 * num_contacts_2",
         num_constraints = "num_vertices_1 + num_vertices_2 + num_vertices_1 * (num_vertices_1 - 1) / 2 * num_vertices_2 * (num_vertices_2 + 1) / 2 + 2 * num_contacts_1 * num_contacts_2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MaximumContactMapOverlap {
     type Result = ReductionCMOToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n1 = self.num_vertices_1();
         let n2 = self.num_vertices_2();
         let contacts_1 = self.contacts_1();
@@ -88,14 +100,14 @@ impl ReduceTo<ILP<bool>> for MaximumContactMapOverlap {
 
         // Row constraints: each residue of G_1 maps to at most one residue of G_2.
         for i in 0..n1 {
-            let terms: Vec<(usize, f64)> = (0..n2).map(|j| (x_idx(i, j), 1.0)).collect();
-            constraints.push(LinearConstraint::le(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n2).map(|j| (x_idx(i, j), 1)).collect();
+            constraints.push(LinearConstraint::le(terms, 1));
         }
 
         // Column constraints: each residue of G_2 receives at most one residue of G_1.
         for j in 0..n2 {
-            let terms: Vec<(usize, f64)> = (0..n1).map(|i| (x_idx(i, j), 1.0)).collect();
-            constraints.push(LinearConstraint::le(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n1).map(|i| (x_idx(i, j), 1)).collect();
+            constraints.push(LinearConstraint::le(terms, 1));
         }
 
         // Order-preservation: for i < k in V_1 and j >= l in V_2,
@@ -106,8 +118,8 @@ impl ReduceTo<ILP<bool>> for MaximumContactMapOverlap {
                 for j in 0..n2 {
                     for l in 0..=j {
                         constraints.push(LinearConstraint::le(
-                            vec![(x_idx(i, j), 1.0), (x_idx(k, l), 1.0)],
-                            1.0,
+                            vec![(x_idx(i, j), 1), (x_idx(k, l), 1)],
+                            1,
                         ));
                     }
                 }
@@ -122,28 +134,23 @@ impl ReduceTo<ILP<bool>> for MaximumContactMapOverlap {
         for &(i, k) in contacts_1 {
             for &(j, l) in contacts_2 {
                 let yv = y_idx(seq);
-                constraints.push(LinearConstraint::le(
-                    vec![(yv, 1.0), (x_idx(i, j), -1.0)],
-                    0.0,
-                ));
-                constraints.push(LinearConstraint::le(
-                    vec![(yv, 1.0), (x_idx(k, l), -1.0)],
-                    0.0,
-                ));
+                constraints.push(LinearConstraint::le(vec![(yv, 1), (x_idx(i, j), -1)], 0));
+                constraints.push(LinearConstraint::le(vec![(yv, 1), (x_idx(k, l), -1)], 0));
                 seq += 1;
             }
         }
 
         // Objective: maximize the number of preserved contacts.
-        let objective: Vec<(usize, f64)> = (0..num_y).map(|s| (y_idx(s), 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..num_y).map(|s| (y_idx(s), 1)).collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(Self::target_construction)?;
 
-        ReductionCMOToILP {
+        Ok(ReductionCMOToILP {
             target,
             num_vertices_1: n1,
             num_vertices_2: n2,
-        }
+        })
     }
 }
 
diff --git a/src/rules/maximumdomaticnumber_ilp.rs b/src/rules/maximumdomaticnumber_ilp.rs
index ebf772153..3a0221a6e 100644
--- a/src/rules/maximumdomaticnumber_ilp.rs
+++ b/src/rules/maximumdomaticnumber_ilp.rs
@@ -36,39 +36,49 @@ impl ReductionResult for ReductionDomaticNumberToILP {
     /// Extract solution from ILP back to MaximumDomaticNumber.
     ///
     /// For each vertex v, find the set index i where x_{v,i} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.n;
-        let mut config = vec![0; n];
-        for v in 0..n {
-            for i in 0..n {
-                if target_solution[v * n + i] == 1 {
-                    config[v] = i;
-                    break;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.n;
+            let mut config = vec![0; n];
+            for v in 0..n {
+                for i in 0..n {
+                    if target_solution[v * n + i] == 1 {
+                        config[v] = i;
+                        break;
+                    }
                 }
             }
-        }
-        config
+            config
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices * num_vertices + num_vertices",
         num_constraints = "num_vertices + num_vertices * num_vertices + num_vertices * num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MaximumDomaticNumber<SimpleGraph> {
     type Result = ReductionDomaticNumberToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let num_vars = n * n + n;
         let mut constraints = Vec::new();
 
         // Partition constraints: for each vertex v, Σ_i x_{v,i} = 1
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|i| (v * n + i, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|i| (v * n + i, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Domination constraints: for each v, i: x_{v,i} + Σ_{u ∈ N(v)} x_{u,i} >= y_i
@@ -76,13 +86,13 @@ impl ReduceTo<ILP<bool>> for MaximumDomaticNumber<SimpleGraph> {
         for v in 0..n {
             let neighbors = self.graph().neighbors(v);
             for i in 0..n {
-                let mut terms: Vec<(usize, f64)> = vec![(v * n + i, 1.0)];
+                let mut terms: Vec<(usize, i64)> = vec![(v * n + i, 1)];
                 for &u in &neighbors {
-                    terms.push((u * n + i, 1.0));
+                    terms.push((u * n + i, 1));
                 }
                 // -y_i
-                terms.push((n * n + i, -1.0));
-                constraints.push(LinearConstraint::ge(terms, 0.0));
+                terms.push((n * n + i, -1));
+                constraints.push(LinearConstraint::ge(terms, 0));
             }
         }
 
@@ -92,18 +102,19 @@ impl ReduceTo<ILP<bool>> for MaximumDomaticNumber<SimpleGraph> {
         for v in 0..n {
             for i in 0..n {
                 constraints.push(LinearConstraint::le(
-                    vec![(v * n + i, 1.0), (n * n + i, -1.0)],
-                    0.0,
+                    vec![(v * n + i, 1), (n * n + i, -1)],
+                    0,
                 ));
             }
         }
 
         // Objective: maximize Σ y_i
-        let objective: Vec<(usize, f64)> = (0..n).map(|i| (n * n + i, 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..n).map(|i| (n * n + i, 1)).collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(Self::target_construction)?;
 
-        ReductionDomaticNumberToILP { target, n }
+        Ok(ReductionDomaticNumberToILP { target, n })
     }
 }
 
diff --git a/src/rules/maximumedgeweightedkclique_ilp.rs b/src/rules/maximumedgeweightedkclique_ilp.rs
index 5db911e78..c7909601b 100644
--- a/src/rules/maximumedgeweightedkclique_ilp.rs
+++ b/src/rules/maximumedgeweightedkclique_ilp.rs
@@ -22,15 +22,13 @@
 //! sparse graphs with compact formulations," EURO J. Comput. Optim. 3(1)
 //! (2015).
 
-use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::models::algebraic::{ILPCoefficient, LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::MaximumEdgeWeightedKClique;
 use crate::reduction;
 use crate::rules::ilp_helpers::mccormick_product;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::Graph;
-use crate::types::WeightElement;
 use crate::variant::VariantParam;
-use std::marker::PhantomData;
 
 /// Result of reducing MaximumEdgeWeightedKClique to ILP.
 ///
@@ -39,59 +37,78 @@ use std::marker::PhantomData;
 /// - `y_uv` at index `num_vertices + e` for the `e`-th graph edge in
 ///   `graph.edges()` order.
 #[derive(Debug, Clone)]
-pub struct ReductionMaximumEdgeWeightedKCliqueToILP<W> {
-    target: ILP<bool>,
+pub struct ReductionMaximumEdgeWeightedKCliqueToILP<W>
+where
+    W: ILPCoefficient,
+{
+    target: ILP<bool, W>,
     num_vertices: usize,
-    _marker: PhantomData<W>,
 }
 
 impl<W> ReductionResult for ReductionMaximumEdgeWeightedKCliqueToILP<W>
 where
-    W: WeightElement + VariantParam,
+    W: ILPCoefficient + VariantParam,
 {
     type Source = MaximumEdgeWeightedKClique<W>;
-    type Target = ILP<bool>;
+    type Target = ILP<bool, W>;
 
-    fn target_problem(&self) -> &ILP<bool> {
+    fn target_problem(&self) -> &ILP<bool, W> {
         &self.target
     }
 
     /// Extract: take the first `num_vertices` entries of the ILP solution.
     /// They are exactly the binary `x_v` selection variables.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_vertices]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 fn build_reduction<W>(
     src: &MaximumEdgeWeightedKClique<W>,
-    objective_coefficients: Vec<f64>,
-) -> ReductionMaximumEdgeWeightedKCliqueToILP<W>
+) -> Result<ReductionMaximumEdgeWeightedKCliqueToILP<W>, crate::rules::ReductionError>
 where
-    W: WeightElement + VariantParam,
+    W: ILPCoefficient + VariantParam + From<i8>,
 {
     let n = src.num_vertices();
     let edges = src.graph().edges();
     let m = edges.len();
-    debug_assert_eq!(objective_coefficients.len(), m);
-
     let num_vars = n + m;
+    let k =
+        i64::try_from(src.k()).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                MaximumEdgeWeightedKClique<W>,
+                ILP<bool, W>,
+            >("encoding the clique cardinality")
+        })?;
     let x_idx = |v: usize| -> usize { v };
     let y_idx = |e: usize| -> usize { n + e };
 
-    let mut constraints: Vec<LinearConstraint> = Vec::new();
+    let mut constraints: Vec<LinearConstraint<W>> = Vec::new();
 
     // Exact-cardinality constraint: sum_v x_v = k.
-    let cardinality_terms: Vec<(usize, f64)> = (0..n).map(|v| (x_idx(v), 1.0)).collect();
-    constraints.push(LinearConstraint::eq(cardinality_terms, src.k() as f64));
+    let cardinality_terms = (0..n).map(|v| (x_idx(v), 1_i8.into())).collect();
+    let k = W::from_integer(k).map_err(|error| {
+        crate::rules::ReductionError::invalid_target::<MaximumEdgeWeightedKClique<W>, ILP<bool, W>>(
+            error.to_string(),
+        )
+    })?;
+    constraints.push(LinearConstraint::eq(cardinality_terms, k));
 
     // Non-edge clique constraints: x_u + x_v <= 1 for every non-edge.
     for u in 0..n {
         for v in (u + 1)..n {
             if !src.graph().has_edge(u, v) {
                 constraints.push(LinearConstraint::le(
-                    vec![(x_idx(u), 1.0), (x_idx(v), 1.0)],
-                    1.0,
+                    vec![(x_idx(u), 1_i8.into()), (x_idx(v), 1_i8.into())],
+                    1_i8.into(),
                 ));
             }
         }
@@ -103,48 +120,55 @@ where
     }
 
     // Objective: maximize sum_e w_e * y_e.
-    let objective: Vec<(usize, f64)> = objective_coefficients
-        .into_iter()
+    let objective: Vec<(usize, W)> = src
+        .edge_weights()
+        .iter()
+        .copied()
         .enumerate()
         .map(|(e, w)| (y_idx(e), w))
         .collect();
 
-    let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+    let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize).map_err(
+        crate::rules::ReductionError::construction::<MaximumEdgeWeightedKClique<W>, ILP<bool, W>>,
+    )?;
 
-    ReductionMaximumEdgeWeightedKCliqueToILP {
+    Ok(ReductionMaximumEdgeWeightedKCliqueToILP {
         target,
         num_vertices: n,
-        _marker: PhantomData,
-    }
+    })
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices + num_edges",
         num_constraints = "1 + num_vertices * (num_vertices - 1) / 2 + 2 * num_edges",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MaximumEdgeWeightedKClique<i32> {
-    type Result = ReductionMaximumEdgeWeightedKCliqueToILP<i32>;
+impl ReduceTo<ILP<bool>> for MaximumEdgeWeightedKClique<i64> {
+    type Result = ReductionMaximumEdgeWeightedKCliqueToILP<i64>;
 
-    fn reduce_to(&self) -> Self::Result {
-        let coefficients: Vec<f64> = self.edge_weights().iter().map(|w| *w as f64).collect();
-        build_reduction(self, coefficients)
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        build_reduction(self)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices + num_edges",
         num_constraints = "1 + num_vertices * (num_vertices - 1) / 2 + 2 * num_edges",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MaximumEdgeWeightedKClique<f64> {
+impl ReduceTo<ILP<bool, f64>> for MaximumEdgeWeightedKClique<f64> {
     type Result = ReductionMaximumEdgeWeightedKCliqueToILP<f64>;
 
-    fn reduce_to(&self) -> Self::Result {
-        let coefficients: Vec<f64> = self.edge_weights().to_vec();
-        build_reduction(self, coefficients)
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        build_reduction(self)
     }
 }
 
@@ -153,27 +177,29 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     use crate::topology::SimpleGraph;
     vec![
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumedgeweightedkclique_i32_to_ilp",
+            id: "exact_maximumedgeweightedkclique_to_ilp",
             build: || {
                 // Canonical issue #1020 instance: 4 vertices, 5 edges, k = 3.
                 // Optimum induced weight is 5 + 4 + (-1) = 8 on clique {0, 1, 2}.
-                let source = MaximumEdgeWeightedKClique::<i32>::new(
+                let source = MaximumEdgeWeightedKClique::<i64>::new(
                     SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
                     vec![5, 4, -1, 1, 0],
                     3,
-                );
+                )
+                .unwrap();
                 crate::example_db::specs::rule_example_via_ilp::<_, bool>(source)
             },
         },
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumedgeweightedkclique_f64_to_ilp",
+            id: "approximate_maximumedgeweightedkclique_to_ilp",
             build: || {
                 let source = MaximumEdgeWeightedKClique::<f64>::new(
                     SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
                     vec![5.0, 4.0, -1.0, 1.0, 0.0],
                     3,
-                );
-                crate::example_db::specs::rule_example_via_ilp::<_, bool>(source)
+                )
+                .unwrap();
+                crate::example_db::specs::rule_example_via_float_ilp::<_, bool>(source)
             },
         },
     ]
diff --git a/src/rules/maximumindependentset_casts.rs b/src/rules/maximumindependentset_casts.rs
index c293f0019..ff7d07906 100644
--- a/src/rules/maximumindependentset_casts.rs
+++ b/src/rules/maximumindependentset_casts.rs
@@ -1,76 +1,135 @@
-//! Variant cast reductions for MaximumIndependentSet.
+//! Variant reductions for MaximumIndependentSet.
 //!
-//! These explicit casts convert MIS between graph subtypes using
-//! the variant hierarchy's `CastToParent` trait.
+//! Each rule converts one registered graph or weight representation.
 
 use crate::impl_variant_reduction;
 use crate::models::graph::MaximumIndependentSet;
-use crate::topology::{KingsSubgraph, SimpleGraph, TriangularSubgraph, UnitDiskGraph};
+use crate::topology::{Graph, KingsSubgraph, SimpleGraph, TriangularSubgraph, UnitDiskGraph};
 use crate::types::One;
-use crate::variant::CastToParent;
 
 impl_variant_reduction!(
     MaximumIndependentSet,
-    <KingsSubgraph, i32> => <UnitDiskGraph, i32>,
+    <KingsSubgraph, i64> => <UnitDiskGraph, i64>,
     fields: [num_vertices, num_edges],
+    aggregate: identity,
     |src| MaximumIndependentSet::new(
-        src.graph().cast_to_parent(), src.weights().to_vec())
+        src.graph().try_to_unit_disk_graph().map_err(
+            crate::rules::ReductionError::construction::<
+                MaximumIndependentSet<KingsSubgraph, i64>,
+                MaximumIndependentSet<UnitDiskGraph, i64>,
+            >,
+        )?,
+        src.weights().to_vec())
 );
 
 impl_variant_reduction!(
     MaximumIndependentSet,
-    <TriangularSubgraph, i32> => <UnitDiskGraph, i32>,
+    <TriangularSubgraph, i64> => <UnitDiskGraph, i64>,
     fields: [num_vertices, num_edges],
+    aggregate: identity,
     |src| MaximumIndependentSet::new(
-        src.graph().cast_to_parent(), src.weights().to_vec())
+        src.graph().try_to_unit_disk_graph().map_err(
+            crate::rules::ReductionError::construction::<
+                MaximumIndependentSet<TriangularSubgraph, i64>,
+                MaximumIndependentSet<UnitDiskGraph, i64>,
+            >,
+        )?,
+        src.weights().to_vec())
 );
 
 impl_variant_reduction!(
     MaximumIndependentSet,
-    <UnitDiskGraph, i32> => <SimpleGraph, i32>,
+    <UnitDiskGraph, i64> => <SimpleGraph, i64>,
     fields: [num_vertices, num_edges],
+    aggregate: identity,
     |src| MaximumIndependentSet::new(
-        src.graph().cast_to_parent(), src.weights().to_vec())
+        SimpleGraph::new(src.num_vertices(), Graph::edges(src.graph())),
+        src.weights().to_vec())
 );
 
-// Graph-hierarchy casts (same weight One)
+// Graph representation reductions with unit weights
 impl_variant_reduction!(
     MaximumIndependentSet,
     <KingsSubgraph, One> => <UnitDiskGraph, One>,
     fields: [num_vertices, num_edges],
+    aggregate: identity,
     |src| MaximumIndependentSet::new(
-        src.graph().cast_to_parent(), src.weights().to_vec())
+        src.graph().try_to_unit_disk_graph().map_err(
+            crate::rules::ReductionError::construction::<
+                MaximumIndependentSet<KingsSubgraph, One>,
+                MaximumIndependentSet<UnitDiskGraph, One>,
+            >,
+        )?,
+        src.weights().to_vec())
 );
 
 impl_variant_reduction!(
     MaximumIndependentSet,
     <UnitDiskGraph, One> => <SimpleGraph, One>,
     fields: [num_vertices, num_edges],
+    aggregate: identity,
     |src| MaximumIndependentSet::new(
-        src.graph().cast_to_parent(), src.weights().to_vec())
+        SimpleGraph::new(src.num_vertices(), Graph::edges(src.graph())),
+        src.weights().to_vec())
 );
 
-// Weight-hierarchy casts (One → i32)
+// Unit-to-integer weight reductions
 impl_variant_reduction!(
     MaximumIndependentSet,
-    <SimpleGraph, One> => <SimpleGraph, i32>,
+    <SimpleGraph, One> => <SimpleGraph, i64>,
     fields: [num_vertices, num_edges],
+    aggregate: identity,
     |src| MaximumIndependentSet::new(
-        src.graph().clone(), src.weights().iter().map(|w| w.cast_to_parent()).collect())
+        src.graph().clone(), vec![1_i64; src.num_vertices()])
 );
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::rules::{ReduceTo, ReductionError};
+    use crate::types::MAX_EXACT_F64_INTEGER;
+
+    #[test]
+    fn kings_to_unit_disk_exposes_coordinate_conversion_error() {
+        let source = MaximumIndependentSet::new(
+            KingsSubgraph::new(vec![(MAX_EXACT_F64_INTEGER + 1, 0)]),
+            vec![1_i64],
+        );
+
+        assert!(matches!(
+            ReduceTo::<MaximumIndependentSet<UnitDiskGraph, i64>>::reduce_to(&source),
+            Err(ReductionError::Construction { .. })
+        ));
+    }
+
+    #[test]
+    fn triangular_to_unit_disk_exposes_adjacency_conversion_error() {
+        let source = MaximumIndependentSet::new(
+            TriangularSubgraph::new(vec![(MAX_EXACT_F64_INTEGER, 0), (MAX_EXACT_F64_INTEGER, 1)]),
+            vec![1_i64, 1_i64],
+        );
+
+        assert!(matches!(
+            ReduceTo::<MaximumIndependentSet<UnitDiskGraph, i64>>::reduce_to(&source),
+            Err(ReductionError::Construction { .. })
+        ));
+    }
+}
+
 impl_variant_reduction!(
     MaximumIndependentSet,
-    <KingsSubgraph, One> => <KingsSubgraph, i32>,
+    <KingsSubgraph, One> => <KingsSubgraph, i64>,
     fields: [num_vertices, num_edges],
+    aggregate: identity,
     |src| MaximumIndependentSet::new(
-        src.graph().clone(), src.weights().iter().map(|w| w.cast_to_parent()).collect())
+        src.graph().clone(), vec![1_i64; src.num_vertices()])
 );
 
 impl_variant_reduction!(
     MaximumIndependentSet,
-    <UnitDiskGraph, One> => <UnitDiskGraph, i32>,
+    <UnitDiskGraph, One> => <UnitDiskGraph, i64>,
     fields: [num_vertices, num_edges],
+    aggregate: identity,
     |src| MaximumIndependentSet::new(
-        src.graph().clone(), src.weights().iter().map(|w| w.cast_to_parent()).collect())
+        src.graph().clone(), vec![1_i64; src.num_vertices()])
 );
diff --git a/src/rules/maximumindependentset_gridgraph.rs b/src/rules/maximumindependentset_gridgraph.rs
index 2515371b8..1542a67fb 100644
--- a/src/rules/maximumindependentset_gridgraph.rs
+++ b/src/rules/maximumindependentset_gridgraph.rs
@@ -25,15 +25,22 @@ impl ReductionResult for ReductionISSimpleOneToGridOne {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.mapping_result.map_config_back(target_solution)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        let encoded = crate::config::bits_to_config(target_solution);
+        let mapped = self.mapping_result.map_config_back(&encoded)?;
+        Ok(crate::config::config_to_bits(&mapped))
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "num_vertices * num_vertices",
-        num_edges = "num_vertices * num_vertices",
+    transform = upper_bound {
+        num_vertices = "16 * num_vertices^2 + 32 * num_vertices + 12",
+        num_edges = "64 * num_vertices^2 + 128 * num_vertices + 48",
     }
 )]
 impl ReduceTo<MaximumIndependentSet<KingsSubgraph, One>>
@@ -41,17 +48,19 @@ impl ReduceTo<MaximumIndependentSet<KingsSubgraph, One>>
 {
     type Result = ReductionISSimpleOneToGridOne;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let edges = self.graph().edges();
-        let result = ksg::map_unweighted(n, &edges);
+        let result = ksg::map_unweighted(n, &edges).map_err(|error| {
+            error.for_reduction::<Self, MaximumIndependentSet<KingsSubgraph, One>>()
+        })?;
         let grid = result.to_kings_subgraph();
         let weights = vec![One; grid.num_vertices()];
         let target = MaximumIndependentSet::new(grid, weights);
-        ReductionISSimpleOneToGridOne {
+        Ok(ReductionISSimpleOneToGridOne {
             target,
             mapping_result: result,
-        }
+        })
     }
 }
 
diff --git a/src/rules/maximumindependentset_integralflowbundles.rs b/src/rules/maximumindependentset_integralflowbundles.rs
deleted file mode 100644
index 6928d7336..000000000
--- a/src/rules/maximumindependentset_integralflowbundles.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-//! Reduction from MaximumIndependentSet to IntegralFlowBundles (Sahni 1974).
-//!
-//! For a graph G = (V, E) with n = |V| vertices and m = |E| edges:
-//!
-//! 1. Create a directed graph with n + 2 vertices: source s, intermediate
-//!    vertices w_0, ..., w_{n-1}, and sink t.
-//! 2. For each vertex v_i, create two arcs: arc_in_i = (s, w_i) and
-//!    arc_out_i = (w_i, t). Arc indices: arc_in_i = 2i, arc_out_i = 2i + 1.
-//! 3. For each edge {v_i, v_j}, create bundle {arc_out_i, arc_out_j} with
-//!    capacity 1 (conflict constraint: at most one endpoint selected).
-//! 4. For each vertex v_i, create bundle {arc_in_i, arc_out_i} with capacity 2.
-//!    Flow conservation at w_i forces arc_in_i = arc_out_i = f_i, so the
-//!    bundle sum is 2*f_i <= 2, giving f_i in {0, 1}. This bundle also
-//!    ensures every arc is covered by at least one bundle.
-//! 5. Set requirement R = 1 (any non-empty independent set gives a feasible flow).
-//!
-//! An independent set of size k corresponds to a feasible flow of value k.
-//! The bundle constraints ensure only independent sets produce valid flows.
-
-use crate::models::graph::{IntegralFlowBundles, MaximumIndependentSet};
-use crate::reduction;
-use crate::rules::traits::{ReduceTo, ReductionResult};
-use crate::topology::{Graph, SimpleGraph};
-
-#[cfg(feature = "example-db")]
-use crate::solvers::BruteForce;
-
-/// Result of reducing MaximumIndependentSet to IntegralFlowBundles.
-#[derive(Debug, Clone)]
-pub struct ReductionMISToIFB {
-    target: IntegralFlowBundles,
-    /// Number of vertices in the source graph.
-    num_source_vertices: usize,
-}
-
-impl ReductionResult for ReductionMISToIFB {
-    type Source = MaximumIndependentSet<SimpleGraph, i32>;
-    type Target = IntegralFlowBundles;
-
-    fn target_problem(&self) -> &Self::Target {
-        &self.target
-    }
-
-    /// Extract solution: vertex i is selected iff arc_out_i (index 2i + 1)
-    /// has nonzero flow.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.num_source_vertices)
-            .map(|i| {
-                if target_solution.get(2 * i + 1).copied().unwrap_or(0) > 0 {
-                    1
-                } else {
-                    0
-                }
-            })
-            .collect()
-    }
-}
-
-#[reduction(
-    overhead = {
-        num_vertices = "num_vertices + 2",
-        num_arcs = "2 * num_vertices",
-        num_bundles = "num_edges + num_vertices",
-    }
-)]
-impl ReduceTo<IntegralFlowBundles> for MaximumIndependentSet<SimpleGraph, i32> {
-    type Result = ReductionMISToIFB;
-
-    fn reduce_to(&self) -> Self::Result {
-        let n = self.graph().num_vertices();
-        let edges = self.graph().edges();
-
-        // Set requirement = 1: any independent set of size >= 1 maps to a feasible flow.
-        // The bundle constraints ensure only independent sets produce valid flows.
-        let requirement = 1u64;
-
-        // Vertices: s = 0, w_i = i + 1 (for i in 0..n), t = n + 1
-        let source_vertex = 0;
-        let sink_vertex = n + 1;
-
-        // Arcs: arc_in_i = (s, w_i), arc_out_i = (w_i, t)
-        let mut arcs = Vec::with_capacity(2 * n);
-        for i in 0..n {
-            arcs.push((source_vertex, i + 1)); // arc_in_i at index 2*i
-            arcs.push((i + 1, sink_vertex)); // arc_out_i at index 2*i + 1
-        }
-
-        let directed_graph = crate::topology::DirectedGraph::new(n + 2, arcs);
-
-        // Bundles: edge bundles + vertex bundles
-        let mut bundles = Vec::with_capacity(edges.len() + n);
-        let mut bundle_capacities = Vec::with_capacity(edges.len() + n);
-
-        // Edge bundles: for each edge {v_i, v_j}, bundle {arc_out_i, arc_out_j} with cap 1
-        for &(u, v) in &edges {
-            bundles.push(vec![2 * u + 1, 2 * v + 1]);
-            bundle_capacities.push(1);
-        }
-
-        // Vertex bundles: for each vertex v_i, bundle {arc_in_i, arc_out_i} with cap 2.
-        // Flow conservation forces arc_in_i = arc_out_i = f_i, so bundle sum =
-        // 2*f_i <= 2, hence f_i in {0, 1}. This also ensures every arc is in
-        // at least one bundle (required by IntegralFlowBundles).
-        for i in 0..n {
-            bundles.push(vec![2 * i, 2 * i + 1]);
-            bundle_capacities.push(2);
-        }
-
-        let target = IntegralFlowBundles::new(
-            directed_graph,
-            source_vertex,
-            sink_vertex,
-            bundles,
-            bundle_capacities,
-            requirement,
-        );
-
-        ReductionMISToIFB {
-            target,
-            num_source_vertices: n,
-        }
-    }
-}
-
-#[cfg(feature = "example-db")]
-pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
-    use crate::export::SolutionPair;
-
-    vec![crate::example_db::specs::RuleExampleSpec {
-        id: "maximumindependentset_to_integralflowbundles",
-        build: || {
-            // Path graph: 0-1-2-3, unit weights
-            // Optimal MIS = {0, 2} or {1, 3} or {0, 3}, size = 2
-            let source = MaximumIndependentSet::new(
-                SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-                vec![1i32; 4],
-            );
-            let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source);
-            let target = reduction.target_problem();
-
-            let target_witness = BruteForce::new()
-                .find_witness(target)
-                .expect("target should have a feasible solution");
-            let source_witness = reduction.extract_solution(&target_witness);
-
-            crate::example_db::specs::rule_example_with_witness::<_, IntegralFlowBundles>(
-                source,
-                SolutionPair {
-                    source_config: source_witness,
-                    target_config: target_witness,
-                },
-            )
-        },
-    }]
-}
-
-#[cfg(test)]
-#[path = "../unit_tests/rules/maximumindependentset_integralflowbundles.rs"]
-mod tests;
diff --git a/src/rules/maximumindependentset_maximumclique.rs b/src/rules/maximumindependentset_maximumclique.rs
index f65042b51..98adc9190 100644
--- a/src/rules/maximumindependentset_maximumclique.rs
+++ b/src/rules/maximumindependentset_maximumclique.rs
@@ -28,8 +28,13 @@ where
 
     /// Solution extraction: identity mapping.
     /// A vertex selected in the clique (target) is also selected in the independent set (source).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
@@ -45,21 +50,21 @@ fn reduce_is_to_clique<W: WeightElement>(
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_vertices * (num_vertices - 1) / 2 - num_edges",
     }
 )]
-impl ReduceTo<MaximumClique<SimpleGraph, i32>> for MaximumIndependentSet<SimpleGraph, i32> {
-    type Result = ReductionISToClique<i32>;
+impl ReduceTo<MaximumClique<SimpleGraph, i64>> for MaximumIndependentSet<SimpleGraph, i64> {
+    type Result = ReductionISToClique<i64>;
 
-    fn reduce_to(&self) -> Self::Result {
-        reduce_is_to_clique(self)
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(reduce_is_to_clique(self))
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_vertices * (num_vertices - 1) / 2 - num_edges",
     }
@@ -67,8 +72,8 @@ impl ReduceTo<MaximumClique<SimpleGraph, i32>> for MaximumIndependentSet<SimpleG
 impl ReduceTo<MaximumClique<SimpleGraph, One>> for MaximumIndependentSet<SimpleGraph, One> {
     type Result = ReductionISToClique<One>;
 
-    fn reduce_to(&self) -> Self::Result {
-        reduce_is_to_clique(self)
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(reduce_is_to_clique(self))
     }
 }
 
@@ -78,26 +83,26 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
 
     vec![
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumindependentset_to_maximumclique",
+            id: "weighted_maximumindependentset_to_maximumclique",
             build: || {
                 let source = MaximumIndependentSet::new(
                     SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
-                    vec![1i32; 5],
+                    vec![1i64; 5],
                 );
                 crate::example_db::specs::rule_example_with_witness::<
                     _,
-                    MaximumClique<SimpleGraph, i32>,
+                    MaximumClique<SimpleGraph, i64>,
                 >(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 0, 1, 0, 1],
-                        target_config: vec![1, 0, 1, 0, 1],
+                        source_config: serde_json::json!(vec![true, false, true, false, true]),
+                        target_config: serde_json::json!(vec![true, false, true, false, true]),
                     },
                 )
             },
         },
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumindependentset_to_maximumclique_one",
+            id: "cardinality_maximumindependentset_to_maximumclique",
             build: || {
                 let source = MaximumIndependentSet::new(
                     SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
@@ -109,8 +114,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 >(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 0, 1, 0, 1],
-                        target_config: vec![1, 0, 1, 0, 1],
+                        source_config: serde_json::json!(vec![true, false, true, false, true]),
+                        target_config: serde_json::json!(vec![true, false, true, false, true]),
                     },
                 )
             },
diff --git a/src/rules/maximumindependentset_maximumsetpacking.rs b/src/rules/maximumindependentset_maximumsetpacking.rs
index fbe156436..6695e87f4 100644
--- a/src/rules/maximumindependentset_maximumsetpacking.rs
+++ b/src/rules/maximumindependentset_maximumsetpacking.rs
@@ -29,18 +29,23 @@ where
     }
 
     /// Solutions map directly: vertex selection = set selection.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 macro_rules! impl_is_to_sp {
     ($W:ty) => {
-        #[reduction(overhead = { num_sets = "num_vertices", universe_size = "num_edges" })]
+        #[reduction(transform = upper_bound { num_sets = "num_vertices", universe_size = "num_edges" })]
         impl ReduceTo<MaximumSetPacking<$W>> for MaximumIndependentSet<SimpleGraph, $W> {
             type Result = ReductionISToSP<$W>;
 
-            fn reduce_to(&self) -> Self::Result {
+            fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
                 let edges = self.graph().edges();
                 let n = self.graph().num_vertices();
 
@@ -51,15 +56,21 @@ macro_rules! impl_is_to_sp {
                     sets[v].push(edge_idx);
                 }
 
-                let target = MaximumSetPacking::with_weights(sets, self.weights().to_vec());
+                let target = MaximumSetPacking::with_weights(sets, self.weights().to_vec())
+                    .map_err(|cause| {
+                        crate::rules::ReductionError::construction::<
+                            MaximumIndependentSet<SimpleGraph, $W>,
+                            MaximumSetPacking<$W>,
+                        >(cause)
+                    })?;
 
-                ReductionISToSP { target }
+                Ok(ReductionISToSP { target })
             }
         }
     };
 }
 
-impl_is_to_sp!(i32);
+impl_is_to_sp!(i64);
 impl_is_to_sp!(One);
 
 /// Result of reducing MaximumSetPacking to MaximumIndependentSet.
@@ -80,18 +91,23 @@ where
     }
 
     /// Solutions map directly.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 macro_rules! impl_sp_to_is {
     ($W:ty) => {
-        #[reduction(overhead = { num_vertices = "num_sets", num_edges = "num_sets^2" })]
+        #[reduction(transform = upper_bound { num_vertices = "num_sets", num_edges = "num_sets^2" })]
         impl ReduceTo<MaximumIndependentSet<SimpleGraph, $W>> for MaximumSetPacking<$W> {
             type Result = ReductionSPToIS<$W>;
 
-            fn reduce_to(&self) -> Self::Result {
+            fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
                 let sets = self.sets();
                 let n = sets.len();
 
@@ -112,13 +128,13 @@ macro_rules! impl_sp_to_is {
                     self.weights_ref().clone(),
                 );
 
-                ReductionSPToIS { target }
+                Ok(ReductionSPToIS { target })
             }
         }
     };
 }
 
-impl_sp_to_is!(i32);
+impl_sp_to_is!(i64);
 impl_sp_to_is!(One);
 
 #[cfg(feature = "example-db")]
@@ -127,35 +143,43 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
 
     vec![
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumindependentset_to_maximumsetpacking",
+            id: "weighted_maximumindependentset_to_maximumsetpacking",
             build: || {
                 let (n, edges) = crate::topology::small_graphs::petersen();
-                let source = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i32; 10]);
-                crate::example_db::specs::rule_example_with_witness::<_, MaximumSetPacking<i32>>(
+                let source = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i64; 10]);
+                crate::example_db::specs::rule_example_with_witness::<_, MaximumSetPacking<i64>>(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 0, 0, 1, 0, 0, 1, 1, 0, 0],
-                        target_config: vec![1, 0, 0, 1, 0, 0, 1, 1, 0, 0],
+                        source_config: serde_json::json!(vec![
+                            true, false, false, true, false, false, true, true, false, false
+                        ]),
+                        target_config: serde_json::json!(vec![
+                            true, false, false, true, false, false, true, true, false, false
+                        ]),
                     },
                 )
             },
         },
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumindependentset_one_to_maximumsetpacking_one",
+            id: "cardinality_maximumindependentset_to_maximumsetpacking",
             build: || {
                 let (n, edges) = crate::topology::small_graphs::petersen();
                 let source = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![One; 10]);
                 crate::example_db::specs::rule_example_with_witness::<_, MaximumSetPacking<One>>(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 0, 0, 1, 0, 0, 1, 1, 0, 0],
-                        target_config: vec![1, 0, 0, 1, 0, 0, 1, 1, 0, 0],
+                        source_config: serde_json::json!(vec![
+                            true, false, false, true, false, false, true, true, false, false
+                        ]),
+                        target_config: serde_json::json!(vec![
+                            true, false, false, true, false, false, true, true, false, false
+                        ]),
                     },
                 )
             },
         },
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumsetpacking_to_maximumindependentset",
+            id: "weighted_maximumsetpacking_to_maximumindependentset",
             build: || {
                 let sets = vec![
                     vec![0, 1, 2],
@@ -164,21 +188,21 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     vec![1, 5, 7],
                     vec![3, 6],
                 ];
-                let source = MaximumSetPacking::with_weights(sets, vec![1i32; 5]);
+                let source = MaximumSetPacking::with_weights(sets, vec![1i64; 5]).unwrap();
                 crate::example_db::specs::rule_example_with_witness::<
                     _,
-                    MaximumIndependentSet<SimpleGraph, i32>,
+                    MaximumIndependentSet<SimpleGraph, i64>,
                 >(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 0, 0, 0, 1],
-                        target_config: vec![1, 0, 0, 0, 1],
+                        source_config: serde_json::json!(vec![true, false, false, false, true]),
+                        target_config: serde_json::json!(vec![true, false, false, false, true]),
                     },
                 )
             },
         },
         crate::example_db::specs::RuleExampleSpec {
-            id: "maximumsetpacking_one_to_maximumindependentset_one",
+            id: "cardinality_maximumsetpacking_to_maximumindependentset",
             build: || {
                 let sets = vec![
                     vec![0, 1, 2],
@@ -187,15 +211,15 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     vec![1, 5, 7],
                     vec![3, 6],
                 ];
-                let source = MaximumSetPacking::with_weights(sets, vec![One; 5]);
+                let source = MaximumSetPacking::with_weights(sets, vec![One; 5]).unwrap();
                 crate::example_db::specs::rule_example_with_witness::<
                     _,
                     MaximumIndependentSet<SimpleGraph, One>,
                 >(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 0, 0, 0, 1],
-                        target_config: vec![1, 0, 0, 0, 1],
+                        source_config: serde_json::json!(vec![true, false, false, false, true]),
+                        target_config: serde_json::json!(vec![true, false, false, false, true]),
                     },
                 )
             },
diff --git a/src/rules/maximumindependentset_triangular.rs b/src/rules/maximumindependentset_triangular.rs
index 6d9bd44c5..644c75bae 100644
--- a/src/rules/maximumindependentset_triangular.rs
+++ b/src/rules/maximumindependentset_triangular.rs
@@ -12,49 +12,58 @@ use crate::rules::unitdiskmapping::triangular;
 use crate::topology::{Graph, SimpleGraph, TriangularSubgraph};
 use crate::types::One;
 
-/// Result of reducing MIS<SimpleGraph, One> to MIS<TriangularSubgraph, i32>.
+/// Result of reducing MIS<SimpleGraph, One> to MIS<TriangularSubgraph, i64>.
 #[derive(Debug, Clone)]
 pub struct ReductionISSimpleToTriangular {
-    target: MaximumIndependentSet<TriangularSubgraph, i32>,
+    target: MaximumIndependentSet<TriangularSubgraph, i64>,
     mapping_result: ksg::MappingResult<ksg::KsgTapeEntry>,
 }
 
 impl ReductionResult for ReductionISSimpleToTriangular {
     type Source = MaximumIndependentSet<SimpleGraph, One>;
-    type Target = MaximumIndependentSet<TriangularSubgraph, i32>;
+    type Target = MaximumIndependentSet<TriangularSubgraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.mapping_result
-            .map_config_back_via_centers(target_solution)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        let encoded = crate::config::bits_to_config(target_solution);
+        let mapped = triangular::map_config_back(&self.mapping_result, &encoded)?;
+        Ok(crate::config::config_to_bits(&mapped))
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "num_vertices * num_vertices",
-        num_edges = "num_vertices * num_vertices",
+    transform = upper_bound {
+        num_vertices = "36 * num_vertices^2 + 36 * num_vertices",
+        num_edges = "108 * num_vertices^2 + 108 * num_vertices",
     }
 )]
-impl ReduceTo<MaximumIndependentSet<TriangularSubgraph, i32>>
+impl ReduceTo<MaximumIndependentSet<TriangularSubgraph, i64>>
     for MaximumIndependentSet<SimpleGraph, One>
 {
     type Result = ReductionISSimpleToTriangular;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let edges = self.graph().edges();
-        let result = triangular::map_weighted(n, &edges);
-        let weights = result.node_weights.clone();
+        let mapping_error = |error: crate::rules::ReductionError| {
+            error.for_reduction::<Self, MaximumIndependentSet<TriangularSubgraph, i64>>()
+        };
+        let result = triangular::map_weighted(n, &edges).map_err(&mapping_error)?;
+        let weights = triangular::map_unit_weights(&result).map_err(mapping_error)?;
         let grid = result.to_triangular_subgraph();
         let target = MaximumIndependentSet::new(grid, weights);
-        ReductionISSimpleToTriangular {
+        Ok(ReductionISSimpleToTriangular {
             target,
             mapping_result: result,
-        }
+        })
     }
 }
 
diff --git a/src/rules/maximumleafspanningtree_ilp.rs b/src/rules/maximumleafspanningtree_ilp.rs
index c6bdcb78d..2623018b7 100644
--- a/src/rules/maximumleafspanningtree_ilp.rs
+++ b/src/rules/maximumleafspanningtree_ilp.rs
@@ -27,38 +27,52 @@ use crate::topology::{Graph, SimpleGraph};
 /// Result of reducing MaximumLeafSpanningTree to ILP.
 #[derive(Debug, Clone)]
 pub struct ReductionMaximumLeafSpanningTreeToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_edges: usize,
 }
 
 impl ReductionResult for ReductionMaximumLeafSpanningTreeToILP {
     type Source = MaximumLeafSpanningTree<SimpleGraph>;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // First m variables are edge selectors
-        target_solution[..self.num_edges].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // First m variables are edge selectors
+            target_solution[..self.num_edges]
+                .iter()
+                .map(|&value| value == 1)
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "3 * num_edges + num_vertices",
         num_constraints = "3 * num_vertices + 2 * num_edges + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for MaximumLeafSpanningTree<SimpleGraph> {
+impl ReduceTo<ILP<i64>> for MaximumLeafSpanningTree<SimpleGraph> {
     type Result = ReductionMaximumLeafSpanningTreeToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let m = self.num_edges();
         let edges = self.graph().edges();
         let root = 0usize;
+        let n_i64 = Self::exact_i64(n, "encoding the spanning-tree order")?;
 
         let num_vars = 3 * m + n;
         // Variable indices
@@ -69,8 +83,8 @@ impl ReduceTo<ILP<i32>> for MaximumLeafSpanningTree<SimpleGraph> {
         let mut constraints = Vec::new();
 
         // 1. Tree cardinality: sum(y_e) = n - 1
-        let terms: Vec<(usize, f64)> = (0..m).map(|e| (edge_var(e), 1.0)).collect();
-        constraints.push(LinearConstraint::eq(terms, (n - 1) as f64));
+        let terms: Vec<(usize, i64)> = (0..m).map(|e| (edge_var(e), 1)).collect();
+        constraints.push(LinearConstraint::eq(terms, n_i64 - 1));
 
         // 2. Flow conservation
         // Build incidence: for each vertex, which edges are incident and which direction
@@ -81,24 +95,24 @@ impl ReduceTo<ILP<i32>> for MaximumLeafSpanningTree<SimpleGraph> {
                 // flow_var(e, 1) is flow from v to u
                 if v == vertex {
                     // inflow from edge direction u->v
-                    terms.push((flow_var(edge_idx, 0), 1.0));
+                    terms.push((flow_var(edge_idx, 0), 1));
                     // outflow from edge direction v->u
-                    terms.push((flow_var(edge_idx, 1), -1.0));
+                    terms.push((flow_var(edge_idx, 1), -1));
                 }
                 if u == vertex {
                     // outflow from edge direction u->v
-                    terms.push((flow_var(edge_idx, 0), -1.0));
+                    terms.push((flow_var(edge_idx, 0), -1));
                     // inflow from edge direction v->u
-                    terms.push((flow_var(edge_idx, 1), 1.0));
+                    terms.push((flow_var(edge_idx, 1), 1));
                 }
             }
 
             let rhs = if vertex == root {
                 // Root sends n-1 units out => net inflow = -(n-1)
-                -((n - 1) as f64)
+                1 - n_i64
             } else {
                 // Each non-root vertex receives exactly 1 unit
-                1.0
+                1
             };
             constraints.push(LinearConstraint::eq(terms, rhs));
         }
@@ -107,11 +121,11 @@ impl ReduceTo<ILP<i32>> for MaximumLeafSpanningTree<SimpleGraph> {
         for edge_idx in 0..m {
             constraints.push(LinearConstraint::le(
                 vec![
-                    (flow_var(edge_idx, 0), 1.0),
-                    (flow_var(edge_idx, 1), 1.0),
-                    (edge_var(edge_idx), -((n - 1) as f64)),
+                    (flow_var(edge_idx, 0), 1),
+                    (flow_var(edge_idx, 1), 1),
+                    (edge_var(edge_idx), 1 - n_i64),
                 ],
-                0.0,
+                0,
             ));
         }
 
@@ -126,28 +140,29 @@ impl ReduceTo<ILP<i32>> for MaximumLeafSpanningTree<SimpleGraph> {
         }
 
         for (v, inc) in incident.iter().enumerate() {
-            let mut terms: Vec<(usize, f64)> = inc.iter().map(|&e| (edge_var(e), 1.0)).collect();
-            terms.push((leaf_var(v), (n - 2) as f64));
-            constraints.push(LinearConstraint::le(terms, (n - 1) as f64));
+            let mut terms: Vec<(usize, i64)> = inc.iter().map(|&e| (edge_var(e), 1)).collect();
+            terms.push((leaf_var(v), n_i64 - 2));
+            constraints.push(LinearConstraint::le(terms, n_i64 - 1));
         }
 
         // 5. Variable bounds: y_e <= 1, z_v <= 1
         for e in 0..m {
-            constraints.push(LinearConstraint::le(vec![(edge_var(e), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(edge_var(e), 1)], 1));
         }
         for v in 0..n {
-            constraints.push(LinearConstraint::le(vec![(leaf_var(v), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(leaf_var(v), 1)], 1));
         }
 
         // Objective: maximize sum(z_v)
-        let objective: Vec<(usize, f64)> = (0..n).map(|v| (leaf_var(v), 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..n).map(|v| (leaf_var(v), 1)).collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(Self::target_construction)?;
 
-        ReductionMaximumLeafSpanningTreeToILP {
+        Ok(ReductionMaximumLeafSpanningTreeToILP {
             target,
             num_edges: m,
-        }
+        })
     }
 }
 
@@ -160,7 +175,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 4,
                 vec![(0, 1), (1, 2), (2, 3), (0, 2)],
             ));
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/maximumlikelihoodranking_ilp.rs b/src/rules/maximumlikelihoodranking_ilp.rs
index 52abbac60..954b09627 100644
--- a/src/rules/maximumlikelihoodranking_ilp.rs
+++ b/src/rules/maximumlikelihoodranking_ilp.rs
@@ -39,52 +39,68 @@ impl ReductionResult for ReductionMaximumLikelihoodRankingToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.n;
-        if n == 0 {
-            return vec![];
-        }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.n;
+            if n == 0 {
+                return Ok(vec![]);
+            }
 
-        // Count how many items are ranked before each item i.
-        // config[i] = number of items ranked before i = rank of item i.
-        let mut config = vec![0usize; n];
-        for i in 0..n {
-            for j in (i + 1)..n {
-                let idx = pair_index(i, j, n);
-                if target_solution[idx] == 1 {
-                    // i is before j -> contributes 1 to config[j]
-                    config[j] += 1;
-                } else {
-                    // j is before i -> contributes 1 to config[i]
-                    config[i] += 1;
+            // Count how many items are ranked before each item i.
+            // config[i] = number of items ranked before i = rank of item i.
+            let mut config = vec![0usize; n];
+            for i in 0..n {
+                for j in (i + 1)..n {
+                    let idx = pair_index(i, j, n);
+                    if target_solution[idx] == 1 {
+                        // i is before j -> contributes 1 to config[j]
+                        config[j] += 1;
+                    } else {
+                        // j is before i -> contributes 1 to config[i]
+                        config[i] += 1;
+                    }
                 }
             }
-        }
 
-        config
+            config
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_items * (num_items - 1) / 2",
         num_constraints = "num_items * (num_items - 1) * (num_items - 2) / 3",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MaximumLikelihoodRanking {
     type Result = ReductionMaximumLikelihoodRankingToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_items();
         let num_vars = n * (n.saturating_sub(1)) / 2;
         let matrix = self.matrix();
 
         // Build objective: minimize sum_{i<j} (a_{ji} - a_{ij}) * x_{ij}
-        let mut objective: Vec<(usize, f64)> = Vec::new();
+        let mut objective: Vec<(usize, i64)> = Vec::new();
         for (i, row_i) in matrix.iter().enumerate() {
             for j in (i + 1)..n {
-                let coeff = (matrix[j][i] - row_i[j]) as f64;
-                if coeff != 0.0 {
+                let difference = matrix[j][i].checked_sub(row_i[j]).ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<
+                        MaximumLikelihoodRanking,
+                        ILP<bool>,
+                    >("subtracting ranking matrix entries")
+                })?;
+                let coeff = difference;
+                if coeff != 0 {
                     objective.push((pair_index(i, j, n), coeff));
                 }
             }
@@ -103,23 +119,18 @@ impl ReduceTo<ILP<bool>> for MaximumLikelihoodRanking {
                     let ac = pair_index(a, c, n);
 
                     // x_{ab} + x_{bc} - x_{ac} <= 1
-                    constraints.push(LinearConstraint::le(
-                        vec![(ab, 1.0), (bc, 1.0), (ac, -1.0)],
-                        1.0,
-                    ));
+                    constraints.push(LinearConstraint::le(vec![(ab, 1), (bc, 1), (ac, -1)], 1));
 
                     // -x_{ab} - x_{bc} + x_{ac} <= 0
-                    constraints.push(LinearConstraint::le(
-                        vec![(ab, -1.0), (bc, -1.0), (ac, 1.0)],
-                        0.0,
-                    ));
+                    constraints.push(LinearConstraint::le(vec![(ab, -1), (bc, -1), (ac, 1)], 0));
                 }
             }
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionMaximumLikelihoodRankingToILP { target, n }
+        Ok(ReductionMaximumLikelihoodRankingToILP { target, n })
     }
 }
 
diff --git a/src/rules/maximummatching_ilp.rs b/src/rules/maximummatching_ilp.rs
index 329a104d5..a4e27b0d9 100644
--- a/src/rules/maximummatching_ilp.rs
+++ b/src/rules/maximummatching_ilp.rs
@@ -24,7 +24,7 @@ pub struct ReductionMatchingToILP {
 }
 
 impl ReductionResult for ReductionMatchingToILP {
-    type Source = MaximumMatching<SimpleGraph, i32>;
+    type Source = MaximumMatching<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
@@ -35,21 +35,29 @@ impl ReductionResult for ReductionMatchingToILP {
     ///
     /// Since the mapping is 1:1 (each edge maps to one binary variable),
     /// the solution extraction is simply copying the configuration.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_edges",
         num_constraints = "num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MaximumMatching<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for MaximumMatching<SimpleGraph, i64> {
     type Result = ReductionMatchingToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.graph().num_edges(); // Number of edges
 
         // Constraints: For each vertex v, sum of incident edge variables <= 1
@@ -59,22 +67,23 @@ impl ReduceTo<ILP<bool>> for MaximumMatching<SimpleGraph, i32> {
             .filter_map(|vertex| v2e.get(&vertex))
             .filter(|edges| !edges.is_empty())
             .map(|edges| {
-                let terms: Vec<(usize, f64)> = edges.iter().map(|&e| (e, 1.0)).collect();
-                LinearConstraint::le(terms, 1.0)
+                let terms: Vec<(usize, i64)> = edges.iter().map(|&e| (e, 1)).collect();
+                LinearConstraint::le(terms, 1)
             })
             .collect();
 
         // Objective: maximize sum of w_e * x_e (weighted sum of selected edges)
         let weights = self.weights();
-        let objective: Vec<(usize, f64)> = weights
+        let objective: Vec<(usize, i64)> = weights
             .iter()
             .enumerate()
-            .map(|(i, &w)| (i, w as f64))
+            .map(|(edge, &weight)| (edge, weight))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionMatchingToILP { target }
+        Ok(ReductionMatchingToILP { target })
     }
 }
 
diff --git a/src/rules/maximummatching_maximumsetpacking.rs b/src/rules/maximummatching_maximumsetpacking.rs
index 9c74bf411..1d98ef7a1 100644
--- a/src/rules/maximummatching_maximumsetpacking.rs
+++ b/src/rules/maximummatching_maximumsetpacking.rs
@@ -30,21 +30,26 @@ where
     }
 
     /// Solutions map directly: edge i in MaximumMatching = set i in MaximumSetPacking.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_sets = "num_edges",
         universe_size = "num_vertices",
     }
 )]
-impl ReduceTo<MaximumSetPacking<i32>> for MaximumMatching<SimpleGraph, i32> {
-    type Result = ReductionMatchingToSP<SimpleGraph, i32>;
+impl ReduceTo<MaximumSetPacking<i64>> for MaximumMatching<SimpleGraph, i64> {
+    type Result = ReductionMatchingToSP<SimpleGraph, i64>;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let edges = self.edges();
 
         // For each edge, create a set containing its two endpoint vertices
@@ -53,12 +58,17 @@ impl ReduceTo<MaximumSetPacking<i32>> for MaximumMatching<SimpleGraph, i32> {
         // Preserve weights from edges
         let weights = self.weights();
 
-        let target = MaximumSetPacking::with_weights(sets, weights);
+        let target = MaximumSetPacking::with_weights(sets, weights).map_err(|cause| {
+            crate::rules::ReductionError::construction::<
+                MaximumMatching<SimpleGraph, i64>,
+                MaximumSetPacking<i64>,
+            >(cause)
+        })?;
 
-        ReductionMatchingToSP {
+        Ok(ReductionMatchingToSP {
             target,
             _marker: std::marker::PhantomData,
-        }
+        })
     }
 }
 
@@ -72,11 +82,17 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             let (n, edges) = crate::topology::small_graphs::petersen();
             let source = MaximumMatching::unit_weights(SimpleGraph::new(n, edges));
-            crate::example_db::specs::rule_example_with_witness::<_, MaximumSetPacking<i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, MaximumSetPacking<i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1],
-                    target_config: vec![0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1],
+                    source_config: serde_json::json!(vec![
+                        false, false, true, true, false, false, false, true, false, false, false,
+                        false, true, false, true
+                    ]),
+                    target_config: serde_json::json!(vec![
+                        false, false, true, true, false, false, false, true, false, false, false,
+                        false, true, false, true
+                    ]),
                 },
             )
         },
diff --git a/src/rules/maximumsetpacking_casts.rs b/src/rules/maximumsetpacking_casts.rs
index e9afd996f..04314c4df 100644
--- a/src/rules/maximumsetpacking_casts.rs
+++ b/src/rules/maximumsetpacking_casts.rs
@@ -1,26 +1,47 @@
-//! Variant cast reductions for MaximumSetPacking.
+//! Variant reductions for MaximumSetPacking.
 
 use crate::impl_variant_reduction;
 use crate::models::set::MaximumSetPacking;
-use crate::types::One;
-use crate::variant::CastToParent;
+use crate::rules::ReductionError;
+use crate::types::{i64_to_exact_f64, One};
 
 impl_variant_reduction!(
     MaximumSetPacking,
-    <One> => <i32>,
+    <One> => <i64>,
     fields: [num_sets, universe_size],
+    aggregate: identity,
     |src| MaximumSetPacking::with_weights(
         src.sets().to_vec(),
-        src.weights_ref().iter().map(|w| w.cast_to_parent()).collect())
+        vec![1_i64; src.num_sets()])
+        .map_err(ReductionError::construction::<
+            MaximumSetPacking<One>,
+            MaximumSetPacking<i64>,
+        >)?
 );
 
 impl_variant_reduction!(
     MaximumSetPacking,
-    <i32> => <f64>,
+    <i64> => <f64>,
     fields: [num_sets, universe_size],
-    |src| MaximumSetPacking::with_weights(
-        src.sets().to_vec(),
-        src.weights_ref().iter().map(|w| w.cast_to_parent()).collect())
+    |src| {
+        let weights = src
+            .weights_ref()
+            .iter()
+            .copied()
+            .map(i64_to_exact_f64)
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|error| {
+                ReductionError::inexact_float_conversion::<
+                    MaximumSetPacking<i64>,
+                    MaximumSetPacking<f64>,
+                >(error)
+            })?;
+        MaximumSetPacking::with_weights(src.sets().to_vec(), weights).map_err(|cause| {
+            ReductionError::construction::<MaximumSetPacking<i64>, MaximumSetPacking<f64>>(
+                cause,
+            )
+        })?
+    }
 );
 
 #[cfg(test)]
diff --git a/src/rules/maximumsetpacking_ilp.rs b/src/rules/maximumsetpacking_ilp.rs
index 7ccd7de47..82766a60e 100644
--- a/src/rules/maximumsetpacking_ilp.rs
+++ b/src/rules/maximumsetpacking_ilp.rs
@@ -22,28 +22,36 @@ pub struct ReductionSPToILP {
 }
 
 impl ReductionResult for ReductionSPToILP {
-    type Source = MaximumSetPacking<i32>;
+    type Source = MaximumSetPacking<i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_sets",
         num_constraints = "universe_size",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MaximumSetPacking<i32> {
+impl ReduceTo<ILP<bool>> for MaximumSetPacking<i64> {
     type Result = ReductionSPToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.num_sets();
 
         // Build element-to-sets mapping, then create one constraint per element
@@ -59,21 +67,22 @@ impl ReduceTo<ILP<bool>> for MaximumSetPacking<i32> {
             .into_iter()
             .filter(|sets| sets.len() > 1)
             .map(|sets| {
-                let terms: Vec<(usize, f64)> = sets.into_iter().map(|i| (i, 1.0)).collect();
-                LinearConstraint::le(terms, 1.0)
+                let terms: Vec<(usize, i64)> = sets.into_iter().map(|i| (i, 1)).collect();
+                LinearConstraint::le(terms, 1)
             })
             .collect();
 
-        let objective: Vec<(usize, f64)> = self
+        let objective: Vec<(usize, i64)> = self
             .weights_ref()
             .iter()
             .enumerate()
-            .map(|(i, &w)| (i, w as f64))
+            .map(|(set, &weight)| (set, weight))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionSPToILP { target }
+        Ok(ReductionSPToILP { target })
     }
 }
 
diff --git a/src/rules/maximumsetpacking_qubo.rs b/src/rules/maximumsetpacking_qubo.rs
index a3b13949c..2a7559884 100644
--- a/src/rules/maximumsetpacking_qubo.rs
+++ b/src/rules/maximumsetpacking_qubo.rs
@@ -4,7 +4,12 @@
 //! Maximize Σ w_i·x_i s.t. x_i·x_j = 0 for overlapping pairs (i,j).
 //! = Minimize -Σ w_i·x_i + P·Σ_{overlapping (i,j)} x_i·x_j
 //!
-//! Q[i][i] = -w_i, Q[i][j] = P for overlapping pairs. P = 1 + Σ w_i.
+//! Q[i][i] = -w_i, Q[i][j] = P for overlapping pairs, with
+//! P = 2 max(1, max_i w_i). Negative and zero weights are allowed.
+//!
+//! If a selected set i conflicts with d >= 1 selected sets, removing it changes
+//! the energy by w_i - P*d < 0. Thus every minimizer is a packing. On packings,
+//! the energy is exactly the negative total weight, preserving every optimum.
 
 use crate::models::algebraic::QUBO;
 use crate::models::set::MaximumSetPacking;
@@ -25,22 +30,37 @@ impl ReductionResult for ReductionSPToQUBO {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 #[reduction(
-    overhead = { num_vars = "num_sets" }
+    transform = exact {
+        num_vars = "num_sets",
+    }
 )]
 impl ReduceTo<QUBO<f64>> for MaximumSetPacking<f64> {
     type Result = ReductionSPToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_sets();
         let weights = self.weights_ref();
-        let total_weight: f64 = weights.iter().sum();
-        let penalty = 1.0 + total_weight;
+        // Doubling gives a strict margin even where adding 1.0 would round
+        // back to the original weight. Do not let negative weights cancel it.
+        let max_weight = weights.iter().copied().fold(1.0_f64, f64::max);
+        let penalty = 2.0 * max_weight;
+        if !penalty.is_finite() {
+            return Err(crate::rules::ReductionError::non_finite_result::<
+                MaximumSetPacking<f64>,
+                QUBO<f64>,
+            >("computing the set-packing conflict penalty"));
+        }
 
         let mut matrix = vec![vec![0.0; n]; n];
 
@@ -55,9 +75,13 @@ impl ReduceTo<QUBO<f64>> for MaximumSetPacking<f64> {
             matrix[a][b] += penalty;
         }
 
-        ReductionSPToQUBO {
-            target: QUBO::from_matrix(matrix),
-        }
+        Ok(ReductionSPToQUBO {
+            target: QUBO::from_matrix(matrix).map_err(|message| {
+                crate::rules::ReductionError::construction::<MaximumSetPacking<f64>, QUBO<f64>>(
+                    message,
+                )
+            })?,
+        })
     }
 }
 
@@ -80,8 +104,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 1, 1, 0],
-                    target_config: vec![0, 0, 0, 1, 1, 0],
+                    source_config: serde_json::json!(vec![false, false, false, true, true, false]),
+                    target_config: serde_json::json!(vec![false, false, false, true, true, false]),
                 },
             )
         },
diff --git a/src/rules/minimumcapacitatedspanningtree_ilp.rs b/src/rules/minimumcapacitatedspanningtree_ilp.rs
index 7208dc432..0886ad247 100644
--- a/src/rules/minimumcapacitatedspanningtree_ilp.rs
+++ b/src/rules/minimumcapacitatedspanningtree_ilp.rs
@@ -5,10 +5,12 @@
 //! - Flow on each edge is bounded by the capacity constraint
 //! - Flow-edge linking ensures flow only travels on selected edges
 //!
-//! Variable layout (all non-negative integers, ILP<i32>):
+//! Variable layout (all non-negative integers, `ILP<i64>`):
 //! - `y_e` for each undirected edge `e` (indices `0..m`): edge selector (binary)
 //! - `f_{2e}`, `f_{2e+1}` for each edge `e=(u,v)` (indices `m..3m`):
-//!   directed flow from u to v and v to u respectively
+//!   directed requirement flow from u to v and v to u respectively
+//! - `g_{2e}`, `g_{2e+1}` for each edge `e=(u,v)` (indices `3m..5m`):
+//!   directed unit-demand connectivity flow
 //!
 //! Constraints:
 //! 1. Tree cardinality: sum(y_e) = n-1
@@ -17,6 +19,8 @@
 //!    root absorbs all (total R = sum of requirements)
 //! 4. Flow-edge linking: f_{uv} + f_{vu} <= R * y_e
 //! 5. Capacity: f_{uv} <= c and f_{vu} <= c for each directed edge
+//! 6. Connectivity flow: each non-root vertex sends one unit to the root,
+//!    linked to selected edges by g_{uv} + g_{vu} <= (n-1)y_e
 //!
 //! Objective: minimize sum(w_e * y_e)
 
@@ -30,59 +34,86 @@ use crate::types::WeightElement;
 /// Result of reducing MinimumCapacitatedSpanningTree to ILP.
 #[derive(Debug, Clone)]
 pub struct ReductionMinimumCapacitatedSpanningTreeToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_edges: usize,
 }
 
 impl ReductionResult for ReductionMinimumCapacitatedSpanningTreeToILP {
-    type Source = MinimumCapacitatedSpanningTree<SimpleGraph, i32>;
-    type Target = ILP<i32>;
+    type Source = MinimumCapacitatedSpanningTree<SimpleGraph, i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // First m variables are edge selectors
-        target_solution[..self.num_edges].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // First m variables are edge selectors
+            target_solution[..self.num_edges]
+                .iter()
+                .map(|&value| value == 1)
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "3 * num_edges",
-        num_constraints = "5 * num_edges + num_vertices + 1",
+    transform = upper_bound {
+        num_vars = "5 * num_edges",
+        num_constraints = "5 * num_edges + 2 * num_vertices + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
+impl ReduceTo<ILP<i64>> for MinimumCapacitatedSpanningTree<SimpleGraph, i64> {
     type Result = ReductionMinimumCapacitatedSpanningTreeToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let m = self.num_edges();
         let edges = self.graph().edges();
         let root = self.root();
         let requirements = self.requirements();
-        let cap = *self.capacity() as f64;
+        let cap = *self.capacity();
 
-        let num_vars = 3 * m;
+        let num_vars = 5 * m;
 
         // Variable indices
         let edge_var = |e: usize| e; // y_e: 0..m
         let flow_var = |e: usize, dir: usize| m + 2 * e + dir; // f: m..3m
+        let connectivity_var = |e: usize, dir: usize| 3 * m + 2 * e + dir; // g: 3m..5m
 
         // Total requirement (flow from all non-root vertices to root)
-        let total_req: f64 = requirements.iter().map(|r| r.to_sum() as f64).sum();
-
+        let total_req = requirements
+            .iter()
+            .enumerate()
+            .filter(|(vertex, _)| *vertex != root)
+            .try_fold(0_i64, |total, (_, requirement)| {
+                total.checked_add(requirement.to_sum()).ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<
+                        MinimumCapacitatedSpanningTree<SimpleGraph, i64>,
+                        ILP<i64>,
+                    >("summing vertex requirements")
+                })
+            })?;
         let mut constraints = Vec::new();
 
         // 1. Tree cardinality: sum(y_e) = n - 1
-        let terms: Vec<(usize, f64)> = (0..m).map(|e| (edge_var(e), 1.0)).collect();
-        constraints.push(LinearConstraint::eq(terms, (n - 1) as f64));
+        let terms: Vec<(usize, i64)> = (0..m).map(|e| (edge_var(e), 1)).collect();
+        constraints.push(LinearConstraint::eq(
+            terms,
+            Self::exact_i64(n, "encoding the spanning-tree order")? - 1,
+        ));
 
         // 2. Binary edge bounds: y_e <= 1
         for e in 0..m {
-            constraints.push(LinearConstraint::le(vec![(edge_var(e), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(edge_var(e), 1)], 1));
         }
 
         // 3. Flow conservation
@@ -95,15 +126,15 @@ impl ReduceTo<ILP<i32>> for MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
                 // flow_var(e, 1) = flow from v to u
                 if v == vertex {
                     // inflow from u->v direction
-                    terms.push((flow_var(edge_idx, 0), 1.0));
+                    terms.push((flow_var(edge_idx, 0), 1));
                     // outflow from v->u direction
-                    terms.push((flow_var(edge_idx, 1), -1.0));
+                    terms.push((flow_var(edge_idx, 1), -1));
                 }
                 if u == vertex {
                     // outflow from u->v direction
-                    terms.push((flow_var(edge_idx, 0), -1.0));
+                    terms.push((flow_var(edge_idx, 0), -1));
                     // inflow from v->u direction
-                    terms.push((flow_var(edge_idx, 1), 1.0));
+                    terms.push((flow_var(edge_idx, 1), 1));
                 }
             }
 
@@ -113,7 +144,7 @@ impl ReduceTo<ILP<i32>> for MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
             } else {
                 // Non-root vertex generates r(v) units toward root:
                 // net inflow = -r(v)
-                -(req.to_sum() as f64)
+                -req.to_sum()
             };
             constraints.push(LinearConstraint::eq(terms, rhs));
         }
@@ -122,40 +153,68 @@ impl ReduceTo<ILP<i32>> for MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
         for edge_idx in 0..m {
             constraints.push(LinearConstraint::le(
                 vec![
-                    (flow_var(edge_idx, 0), 1.0),
-                    (flow_var(edge_idx, 1), 1.0),
+                    (flow_var(edge_idx, 0), 1),
+                    (flow_var(edge_idx, 1), 1),
                     (edge_var(edge_idx), -total_req),
                 ],
-                0.0,
+                0,
             ));
         }
 
         // 5. Capacity bounds: f_{uv} <= c, f_{vu} <= c
+        for edge_idx in 0..m {
+            constraints.push(LinearConstraint::le(vec![(flow_var(edge_idx, 0), 1)], cap));
+            constraints.push(LinearConstraint::le(vec![(flow_var(edge_idx, 1), 1)], cap));
+        }
+
+        // 6. Unit-demand flow guarantees that every vertex is connected to the root,
+        // including vertices whose capacity requirement is zero.
+        let connectivity_total = Self::exact_i64(n, "encoding connectivity flow")? - 1;
+        for vertex in 0..n {
+            let mut terms = Vec::new();
+            for (edge_idx, &(u, v)) in edges.iter().enumerate() {
+                if v == vertex {
+                    terms.push((connectivity_var(edge_idx, 0), 1));
+                    terms.push((connectivity_var(edge_idx, 1), -1));
+                }
+                if u == vertex {
+                    terms.push((connectivity_var(edge_idx, 0), -1));
+                    terms.push((connectivity_var(edge_idx, 1), 1));
+                }
+            }
+            let rhs = if vertex == root {
+                connectivity_total
+            } else {
+                -1
+            };
+            constraints.push(LinearConstraint::eq(terms, rhs));
+        }
         for edge_idx in 0..m {
             constraints.push(LinearConstraint::le(
-                vec![(flow_var(edge_idx, 0), 1.0)],
-                cap,
-            ));
-            constraints.push(LinearConstraint::le(
-                vec![(flow_var(edge_idx, 1), 1.0)],
-                cap,
+                vec![
+                    (connectivity_var(edge_idx, 0), 1),
+                    (connectivity_var(edge_idx, 1), 1),
+                    (edge_var(edge_idx), -connectivity_total),
+                ],
+                0,
             ));
         }
 
         // Objective: minimize sum(w_e * y_e)
-        let objective: Vec<(usize, f64)> = self
+        let objective: Vec<(usize, i64)> = self
             .weights()
             .iter()
             .enumerate()
-            .map(|(edge_idx, w)| (edge_var(edge_idx), w.to_sum() as f64))
+            .map(|(edge_idx, weight)| (edge_var(edge_idx), weight.to_sum()))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionMinimumCapacitatedSpanningTreeToILP {
+        Ok(ReductionMinimumCapacitatedSpanningTreeToILP {
             target,
             num_edges: m,
-        }
+        })
     }
 }
 
@@ -171,7 +230,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 vec![0, 1, 1, 1],    // requirements
                 2,                   // capacity
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/minimumcostmaximumflow_minimumcostcirculation.rs b/src/rules/minimumcostmaximumflow_minimumcostcirculation.rs
index 36c941c36..0d6df7ddb 100644
--- a/src/rules/minimumcostmaximumflow_minimumcostcirculation.rs
+++ b/src/rules/minimumcostmaximumflow_minimumcostcirculation.rs
@@ -43,13 +43,18 @@ impl ReductionResult for ReductionMCMFToMCC {
     /// Extract the source flow by discarding the return arc: the first
     /// `num_original_arcs` entries of the circulation are exactly the
     /// flow values on the original arcs.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_original_arcs].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_original_arcs].to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_arcs = "num_arcs + 1",
     }
@@ -57,25 +62,46 @@ impl ReductionResult for ReductionMCMFToMCC {
 impl ReduceTo<MinimumCostCirculation> for MinimumCostMaximumFlow {
     type Result = ReductionMCMFToMCC;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let m = self.num_arcs();
         let source = self.source();
         let sink = self.sink();
 
         // U = sum of capacities of arcs leaving the source.
-        let u_bound: i64 = self
+        let u_bound = self
             .graph()
             .arcs()
             .iter()
             .zip(self.capacities().iter())
             .filter_map(|(&(u, _), &cap)| if u == source { Some(cap) } else { None })
-            .sum();
+            .try_fold(0_i64, |total, capacity| total.checked_add(capacity))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    MinimumCostMaximumFlow,
+                    MinimumCostCirculation,
+                >("summing capacities leaving the source")
+            })?;
 
         // B = 1 + sum of all original arc costs. Strictly exceeds any
         // simple s-t path cost, so the return arc's negative cost
         // dominates all positive original costs lexicographically.
-        let b_const: i64 = 1 + self.costs().iter().sum::<i64>();
+        let cost_sum = self
+            .costs()
+            .iter()
+            .try_fold(0_i64, |total, &cost| total.checked_add(cost))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    MinimumCostMaximumFlow,
+                    MinimumCostCirculation,
+                >("summing arc costs")
+            })?;
+        let b_const = cost_sum.checked_add(1).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                MinimumCostMaximumFlow,
+                MinimumCostCirculation,
+            >("adding one to the arc-cost sum")
+        })?;
 
         // Keep every original arc and append the return arc (t, s).
         let mut arcs = self.graph().arcs();
@@ -85,14 +111,19 @@ impl ReduceTo<MinimumCostCirculation> for MinimumCostMaximumFlow {
         capacities.push(u_bound);
 
         let mut costs = self.costs().to_vec();
-        costs.push(-b_const);
+        costs.push(b_const.checked_neg().ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                MinimumCostMaximumFlow,
+                MinimumCostCirculation,
+            >("negating the return-arc cost")
+        })?);
 
         let target = MinimumCostCirculation::new(DirectedGraph::new(n, arcs), capacities, costs);
 
-        ReductionMCMFToMCC {
+        Ok(ReductionMCMFToMCC {
             target,
             num_original_arcs: m,
-        }
+        })
     }
 }
 
@@ -117,8 +148,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, MinimumCostCirculation>(
                 source,
                 SolutionPair {
-                    source_config: vec![2, 1, 1, 1, 2],
-                    target_config: vec![2, 1, 1, 1, 2, 3],
+                    source_config: serde_json::json!(vec![2, 1, 1, 1, 2]),
+                    target_config: serde_json::json!(vec![2, 1, 1, 1, 2, 3]),
                 },
             )
         },
diff --git a/src/rules/minimumcoveringbycliques_ilp.rs b/src/rules/minimumcoveringbycliques_ilp.rs
index 52c643111..fc139660b 100644
--- a/src/rules/minimumcoveringbycliques_ilp.rs
+++ b/src/rules/minimumcoveringbycliques_ilp.rs
@@ -39,33 +39,41 @@ impl ReductionResult for ReductionMinimumCoveringByCliquesToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        if self.num_edges == 0 {
-            return vec![];
-        }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
         (0..self.num_edges)
-            .map(|edge_idx| {
+            .map(|edge| {
                 (0..self.num_edges)
-                    .find(|&slot| {
-                        target_solution[self.y_offset + edge_idx * self.num_edges + slot] == 1
+                    .find(|&clique| {
+                        target_solution[self.y_offset + edge * self.num_edges + clique] == 1
+                    })
+                    .ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid(format!(
+                            "edge {edge} is not covered by any clique"
+                        ))
                     })
-                    .unwrap_or(0)
             })
             .collect()
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices * num_edges + num_edges + num_edges * num_edges",
         num_constraints = "num_vertices * num_edges + (num_vertices * (num_vertices - 1) / 2 - num_edges) * num_edges + 3 * num_edges * num_edges + num_edges",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MinimumCoveringByCliques<SimpleGraph> {
     type Result = ReductionMinimumCoveringByCliquesToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let graph = self.graph();
         let num_vertices = graph.num_vertices();
         let edges = graph.edges();
@@ -84,8 +92,8 @@ impl ReduceTo<ILP<bool>> for MinimumCoveringByCliques<SimpleGraph> {
         for slot in 0..num_slots {
             for u in 0..num_vertices {
                 constraints.push(LinearConstraint::le(
-                    vec![(x_idx(u, slot), 1.0), (z_idx(slot), -1.0)],
-                    0.0,
+                    vec![(x_idx(u, slot), 1), (z_idx(slot), -1)],
+                    0,
                 ));
             }
         }
@@ -95,8 +103,8 @@ impl ReduceTo<ILP<bool>> for MinimumCoveringByCliques<SimpleGraph> {
                 for v in (u + 1)..num_vertices {
                     if !graph.has_edge(u, v) {
                         constraints.push(LinearConstraint::le(
-                            vec![(x_idx(u, slot), 1.0), (x_idx(v, slot), 1.0)],
-                            1.0,
+                            vec![(x_idx(u, slot), 1), (x_idx(v, slot), 1)],
+                            1,
                         ));
                     }
                 }
@@ -114,25 +122,26 @@ impl ReduceTo<ILP<bool>> for MinimumCoveringByCliques<SimpleGraph> {
         }
 
         for edge_idx in 0..num_edges {
-            let terms: Vec<(usize, f64)> = (0..num_slots)
-                .map(|slot| (y_idx(edge_idx, slot), 1.0))
+            let terms: Vec<(usize, i64)> = (0..num_slots)
+                .map(|slot| (y_idx(edge_idx, slot), 1))
                 .collect();
-            constraints.push(LinearConstraint::ge(terms, 1.0));
+            constraints.push(LinearConstraint::ge(terms, 1));
         }
 
-        let objective: Vec<(usize, f64)> = (0..num_slots).map(|slot| (z_idx(slot), 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..num_slots).map(|slot| (z_idx(slot), 1)).collect();
         let target = ILP::new(
             y_offset + num_edges * num_slots,
             constraints,
             objective,
             ObjectiveSense::Minimize,
-        );
+        )
+        .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionMinimumCoveringByCliquesToILP {
+        Ok(ReductionMinimumCoveringByCliquesToILP {
             target,
             num_edges,
             y_offset,
-        }
+        })
     }
 }
 
diff --git a/src/rules/minimumcoveringbycliques_minimumintersectiongraphbasis.rs b/src/rules/minimumcoveringbycliques_minimumintersectiongraphbasis.rs
index a700acdfe..892f31b03 100644
--- a/src/rules/minimumcoveringbycliques_minimumintersectiongraphbasis.rs
+++ b/src/rules/minimumcoveringbycliques_minimumintersectiongraphbasis.rs
@@ -16,25 +16,19 @@ pub struct ReductionMinimumCoveringByCliquesToMinimumIntersectionGraphBasis {
     target: MinimumIntersectionGraphBasis<SimpleGraph>,
 }
 
-fn invalid_source_solution(num_edges: usize) -> Vec<usize> {
-    if num_edges == 0 {
-        // Deliberately wrong length so source `evaluate` returns `Min(None)`.
-        vec![0]
-    } else {
-        vec![0; num_edges - 1]
-    }
-}
-
-fn extract_edge_clique_cover(graph: &SimpleGraph, target_solution: &[usize]) -> Option<Vec<usize>> {
+fn extract_edge_clique_cover(
+    graph: &SimpleGraph,
+    target_solution: &[Vec<bool>],
+) -> Option<Vec<usize>> {
     let n = graph.num_vertices();
     let m = graph.num_edges();
 
-    if m == 0 {
-        return target_solution.is_empty().then(Vec::new);
+    if target_solution.len() != n || target_solution.iter().any(|row| row.len() != m) {
+        return None;
     }
 
-    if target_solution.len() != n * m {
-        return None;
+    if m == 0 {
+        return Some(Vec::new());
     }
 
     let mut label_map = BTreeMap::new();
@@ -42,9 +36,8 @@ fn extract_edge_clique_cover(graph: &SimpleGraph, target_solution: &[usize]) ->
     let mut source_solution = Vec::with_capacity(m);
 
     for (u, v) in graph.edges() {
-        let shared_label = (0..m).find(|&slot| {
-            target_solution[u * m + slot] == 1 && target_solution[v * m + slot] == 1
-        })?;
+        let shared_label =
+            (0..m).find(|&slot| target_solution[u][slot] && target_solution[v][slot])?;
         let compressed = *label_map.entry(shared_label).or_insert_with(|| {
             let label = next_label;
             next_label += 1;
@@ -57,7 +50,7 @@ fn extract_edge_clique_cover(graph: &SimpleGraph, target_solution: &[usize]) ->
 }
 
 #[cfg(any(test, feature = "example-db"))]
-fn intersection_basis_config(graph: &SimpleGraph, subsets: &[&[usize]]) -> Vec<usize> {
+fn intersection_basis_config(graph: &SimpleGraph, subsets: &[&[usize]]) -> Vec<Vec<bool>> {
     let n = graph.num_vertices();
     let m = graph.num_edges();
 
@@ -68,14 +61,14 @@ fn intersection_basis_config(graph: &SimpleGraph, subsets: &[&[usize]]) -> Vec<u
             subsets.iter().all(|subset| subset.is_empty()),
             "empty graphs have empty subsets in canonical configs"
         );
-        return Vec::new();
+        return vec![Vec::new(); n];
     }
 
-    let mut config = vec![0; n * m];
+    let mut config = vec![vec![false; m]; n];
     for (vertex, subset) in subsets.iter().enumerate() {
         for &slot in *subset {
             assert!(slot < m, "intersection-basis slot out of range");
-            config[vertex * m + slot] = 1;
+            config[vertex][slot] = true;
         }
     }
     config
@@ -89,18 +82,30 @@ impl ReductionResult for ReductionMinimumCoveringByCliquesToMinimumIntersectionG
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        if !self.target.evaluate(target_solution).is_valid() {
-            return invalid_source_solution(self.target.num_edges());
-        }
-
-        extract_edge_clique_cover(self.target.graph(), target_solution)
-            .unwrap_or_else(|| invalid_source_solution(self.target.num_edges()))
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            if !self.target.evaluate(target_solution)?.is_valid() {
+                return Err(crate::rules::ExtractionError::invalid(
+                    "target configuration is not a valid intersection graph basis",
+                ));
+            }
+
+            extract_edge_clique_cover(self.target.graph(), target_solution).ok_or_else(|| {
+                crate::rules::ExtractionError::invalid(
+                    "target basis does not assign a shared label to every source edge",
+                )
+            })?
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_edges",
     }
@@ -110,10 +115,10 @@ impl ReduceTo<MinimumIntersectionGraphBasis<SimpleGraph>>
 {
     type Result = ReductionMinimumCoveringByCliquesToMinimumIntersectionGraphBasis;
 
-    fn reduce_to(&self) -> Self::Result {
-        Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(Self::Result {
             target: MinimumIntersectionGraphBasis::new(self.graph().clone()),
-        }
+        })
     }
 }
 
@@ -137,8 +142,9 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 1],
-                    target_config,
+                    source_config: serde_json::json!(vec![0, 0, 0, 1]),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/minimumcutintoboundedsets_ilp.rs b/src/rules/minimumcutintoboundedsets_ilp.rs
index 8edb3a65d..bb0331be8 100644
--- a/src/rules/minimumcutintoboundedsets_ilp.rs
+++ b/src/rules/minimumcutintoboundedsets_ilp.rs
@@ -19,79 +19,84 @@ pub struct ReductionMinCutBSToILP {
 }
 
 impl ReductionResult for ReductionMinCutBSToILP {
-    type Source = MinimumCutIntoBoundedSets<SimpleGraph, i32>;
+    type Source = MinimumCutIntoBoundedSets<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_vertices]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices + num_edges",
         num_constraints = "2 + 2 + 2 * num_edges",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MinimumCutIntoBoundedSets<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for MinimumCutIntoBoundedSets<SimpleGraph, i64> {
     type Result = ReductionMinCutBSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let edges = self.graph().edges();
         let m = edges.len();
         let num_vars = n + m;
+        let n_i64 = Self::exact_i64(n, "encoding the partition size")?;
+        let size_bound = Self::exact_i64(self.size_bound(), "encoding the set-size bound")?;
         let mut constraints = Vec::new();
 
         // x_s = 0
-        constraints.push(LinearConstraint::eq(vec![(self.source(), 1.0)], 0.0));
+        constraints.push(LinearConstraint::eq(vec![(self.source(), 1)], 0));
 
         // x_t = 1
-        constraints.push(LinearConstraint::eq(vec![(self.sink(), 1.0)], 1.0));
+        constraints.push(LinearConstraint::eq(vec![(self.sink(), 1)], 1));
 
         // Σ x_v ≤ B (sink side count)
-        let all_terms: Vec<(usize, f64)> = (0..n).map(|v| (v, 1.0)).collect();
-        constraints.push(LinearConstraint::le(all_terms, self.size_bound() as f64));
+        let all_terms: Vec<(usize, i64)> = (0..n).map(|v| (v, 1)).collect();
+        constraints.push(LinearConstraint::le(all_terms, size_bound));
 
         // Σ (1 - x_v) ≤ B  ⟹  n - Σ x_v ≤ B  ⟹  -Σ x_v ≤ B - n  ⟹  Σ x_v ≥ n - B
-        let all_terms2: Vec<(usize, f64)> = (0..n).map(|v| (v, 1.0)).collect();
-        constraints.push(LinearConstraint::ge(
-            all_terms2,
-            (n as f64) - (self.size_bound() as f64),
-        ));
+        let all_terms2: Vec<(usize, i64)> = (0..n).map(|v| (v, 1)).collect();
+        constraints.push(LinearConstraint::ge(all_terms2, n_i64 - size_bound));
 
         // Cut linking: for each edge e = {u, v}, y_e ≥ x_u - x_v and y_e ≥ x_v - x_u
         for (e_idx, &(u, v)) in edges.iter().enumerate() {
             let y = n + e_idx;
             // y_e - x_u + x_v ≥ 0  (y_e ≥ x_u - x_v)
-            constraints.push(LinearConstraint::ge(
-                vec![(y, 1.0), (u, -1.0), (v, 1.0)],
-                0.0,
-            ));
+            constraints.push(LinearConstraint::ge(vec![(y, 1), (u, -1), (v, 1)], 0));
             // y_e + x_u - x_v ≥ 0  (y_e ≥ x_v - x_u)
-            constraints.push(LinearConstraint::ge(
-                vec![(y, 1.0), (u, 1.0), (v, -1.0)],
-                0.0,
-            ));
+            constraints.push(LinearConstraint::ge(vec![(y, 1), (u, 1), (v, -1)], 0));
         }
 
         // Objective: minimize cut weight Σ w_e y_e
-        let objective: Vec<(usize, f64)> = self
+        let objective: Vec<(usize, i64)> = self
             .edge_weights()
             .iter()
             .enumerate()
-            .map(|(e_idx, &w)| (n + e_idx, w as f64))
+            .map(|(edge, &weight)| (n + edge, weight))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
-        ReductionMinCutBSToILP {
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionMinCutBSToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
diff --git a/src/rules/minimumdiscreteplanarinversekinematics_qubo.rs b/src/rules/minimumdiscreteplanarinversekinematics_qubo.rs
index 317daa77c..a00026804 100644
--- a/src/rules/minimumdiscreteplanarinversekinematics_qubo.rs
+++ b/src/rules/minimumdiscreteplanarinversekinematics_qubo.rs
@@ -39,25 +39,42 @@ impl ReductionResult for ReductionMinimumDiscretePlanarInverseKinematicsToQUBO {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         self.block_offsets
             .iter()
             .zip(&self.block_sizes)
-            .map(|(&start, &size)| {
-                target_solution[start..start + size]
+            .enumerate()
+            .map(|(link, (&start, &size))| {
+                let mut selected = target_solution[start..start + size]
                     .iter()
-                    .position(|&bit| bit == 1)
-                    .unwrap_or(0)
+                    .enumerate()
+                    .filter_map(|(orientation, &bit)| bit.then_some(orientation));
+                match (selected.next(), selected.next()) {
+                    (Some(orientation), None) => Ok(orientation),
+                    (None, _) => Err(crate::rules::ExtractionError::invalid(format!(
+                        "link {link} has no selected orientation"
+                    ))),
+                    (Some(_), Some(_)) => Err(crate::rules::ExtractionError::invalid(format!(
+                        "link {link} has multiple selected orientations"
+                    ))),
+                }
             })
             .collect()
     }
 }
 
-#[reduction(overhead = { num_vars = "num_orientation_samples" })]
+#[reduction(transform = exact {
+    num_vars = "num_orientation_samples",
+})]
 impl ReduceTo<QUBO<f64>> for MinimumDiscretePlanarInverseKinematics {
     type Result = ReductionMinimumDiscretePlanarInverseKinematicsToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let block_sizes: Vec<usize> = self.orientation_samples().iter().map(Vec::len).collect();
         let block_offsets = block_offsets(&block_sizes);
         let total_vars: usize = block_sizes.iter().sum();
@@ -138,11 +155,16 @@ impl ReduceTo<QUBO<f64>> for MinimumDiscretePlanarInverseKinematics {
             }
         }
 
-        ReductionMinimumDiscretePlanarInverseKinematicsToQUBO {
-            target: QUBO::from_matrix(matrix),
+        Ok(ReductionMinimumDiscretePlanarInverseKinematicsToQUBO {
+            target: QUBO::from_matrix(matrix).map_err(|message| {
+                crate::rules::ReductionError::construction::<
+                    MinimumDiscretePlanarInverseKinematics,
+                    QUBO<f64>,
+                >(message)
+            })?,
             block_offsets,
             block_sizes,
-        }
+        })
     }
 }
 
@@ -160,10 +182,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     (2.0, 1.0),
                     vec![vec![0.0, FRAC_PI_2], vec![0.0, FRAC_PI_2]],
                     vec![vec![(0, 0), (0, 1), (1, 1)]],
-                ),
+                )
+                .unwrap(),
                 SolutionPair {
-                    source_config: vec![0, 1],
-                    target_config: vec![1, 0, 0, 1],
+                    source_config: serde_json::json!(vec![0, 1]),
+                    target_config: serde_json::json!(vec![true, false, false, true]),
                 },
             )
         },
diff --git a/src/rules/minimumdominatingset_ilp.rs b/src/rules/minimumdominatingset_ilp.rs
index 7aa9933c0..5b1d3f945 100644
--- a/src/rules/minimumdominatingset_ilp.rs
+++ b/src/rules/minimumdominatingset_ilp.rs
@@ -25,7 +25,7 @@ pub struct ReductionDSToILP {
 }
 
 impl ReductionResult for ReductionDSToILP {
-    type Source = MinimumDominatingSet<SimpleGraph, i32>;
+    type Source = MinimumDominatingSet<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
@@ -36,21 +36,29 @@ impl ReductionResult for ReductionDSToILP {
     ///
     /// Since the mapping is 1:1 (each vertex maps to one binary variable),
     /// the solution extraction is simply copying the configuration.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices",
         num_constraints = "num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MinimumDominatingSet<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for MinimumDominatingSet<SimpleGraph, i64> {
     type Result = ReductionDSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.graph().num_vertices();
 
         // Constraints: For each vertex v, x_v + sum_{u in N(v)} x_u >= 1
@@ -58,25 +66,26 @@ impl ReduceTo<ILP<bool>> for MinimumDominatingSet<SimpleGraph, i32> {
         let constraints: Vec<LinearConstraint> = (0..num_vars)
             .map(|v| {
                 // Build terms: x_v with coefficient 1, plus each neighbor with coefficient 1
-                let mut terms: Vec<(usize, f64)> = vec![(v, 1.0)];
+                let mut terms: Vec<(usize, i64)> = vec![(v, 1)];
                 for neighbor in self.neighbors(v) {
-                    terms.push((neighbor, 1.0));
+                    terms.push((neighbor, 1));
                 }
-                LinearConstraint::ge(terms, 1.0)
+                LinearConstraint::ge(terms, 1)
             })
             .collect();
 
         // Objective: minimize sum of w_i * x_i (weighted sum of selected vertices)
-        let objective: Vec<(usize, f64)> = self
+        let objective: Vec<(usize, i64)> = self
             .weights()
             .iter()
             .enumerate()
-            .map(|(i, &w)| (i, w as f64))
+            .map(|(vertex, &weight)| (vertex, weight))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionDSToILP { target }
+        Ok(ReductionDSToILP { target })
     }
 }
 
@@ -86,7 +95,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "minimumdominatingset_to_ilp",
         build: || {
             let (n, edges) = crate::topology::small_graphs::petersen();
-            let source = MinimumDominatingSet::new(SimpleGraph::new(n, edges), vec![1i32; 10]);
+            let source = MinimumDominatingSet::new(SimpleGraph::new(n, edges), vec![1i64; 10]);
             crate::example_db::specs::rule_example_via_ilp::<_, bool>(source)
         },
     }]
diff --git a/src/rules/minimumedgecostflow_ilp.rs b/src/rules/minimumedgecostflow_ilp.rs
index fda1c6908..dd30eb04a 100644
--- a/src/rules/minimumedgecostflow_ilp.rs
+++ b/src/rules/minimumedgecostflow_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from MinimumEdgeCostFlow to ILP<i32>.
+//! Reduction from MinimumEdgeCostFlow to `ILP<i64>`.
 //!
 //! Variables (2m total):
 //!   f_a  (a = 0..m-1)  — integer flow on arc a, domain {0, ..., c(a)}
@@ -23,41 +23,49 @@ use crate::models::graph::MinimumEdgeCostFlow;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing MinimumEdgeCostFlow to ILP<i32>.
+/// Result of reducing MinimumEdgeCostFlow to `ILP<i64>`.
 ///
 /// Variable layout:
 /// - `f_a` at index a for a in 0..num_edges (flow on arc a)
 /// - `y_a` at index num_edges + a for a in 0..num_edges (binary indicator)
 #[derive(Debug, Clone)]
 pub struct ReductionMECFToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_edges: usize,
 }
 
 impl ReductionResult for ReductionMECFToILP {
     type Source = MinimumEdgeCostFlow;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Extract flow solution: first m variables are the flow values.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_edges].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::decode_usize_values(&target_solution[..self.num_edges])
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "2 * num_edges",
         num_constraints = "2 * num_edges + num_vertices - 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for MinimumEdgeCostFlow {
+impl ReduceTo<ILP<i64>> for MinimumEdgeCostFlow {
     type Result = ReductionMECFToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let arcs = self.graph().arcs();
         let m = arcs.len();
         let n = self.num_vertices();
@@ -71,14 +79,14 @@ impl ReduceTo<ILP<i32>> for MinimumEdgeCostFlow {
         // 1. Linking: f_a - c(a) * y_a ≤ 0  (forces y_a = 1 when f_a > 0)
         for a in 0..m {
             constraints.push(LinearConstraint::le(
-                vec![(f(a), 1.0), (y(a), -(self.capacities()[a] as f64))],
-                0.0,
+                vec![(f(a), 1), (y(a), -self.capacities()[a])],
+                0,
             ));
         }
 
         // 2. Binary bound: y_a ≤ 1
         for a in 0..m {
-            constraints.push(LinearConstraint::le(vec![(y(a), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(y(a), 1)], 1));
         }
 
         // 3. Flow conservation at non-terminal vertices
@@ -87,43 +95,40 @@ impl ReduceTo<ILP<i32>> for MinimumEdgeCostFlow {
                 continue;
             }
 
-            let mut terms: Vec<(usize, f64)> = Vec::new();
+            let mut terms: Vec<(usize, i64)> = Vec::new();
             for (a, &(u, v)) in arcs.iter().enumerate() {
                 if vertex == u {
-                    terms.push((f(a), -1.0)); // outgoing
+                    terms.push((f(a), -1)); // outgoing
                 } else if vertex == v {
-                    terms.push((f(a), 1.0)); // incoming
+                    terms.push((f(a), 1)); // incoming
                 }
             }
 
             if !terms.is_empty() {
-                constraints.push(LinearConstraint::eq(terms, 0.0));
+                constraints.push(LinearConstraint::eq(terms, 0));
             }
         }
 
         // 4. Flow requirement: net flow into sink ≥ R
         let sink = self.sink();
-        let mut sink_terms: Vec<(usize, f64)> = Vec::new();
+        let mut sink_terms: Vec<(usize, i64)> = Vec::new();
         for (a, &(u, v)) in arcs.iter().enumerate() {
             if v == sink {
-                sink_terms.push((f(a), 1.0));
+                sink_terms.push((f(a), 1));
             } else if u == sink {
-                sink_terms.push((f(a), -1.0));
+                sink_terms.push((f(a), -1));
             }
         }
-        constraints.push(LinearConstraint::ge(
-            sink_terms,
-            self.required_flow() as f64,
-        ));
+        constraints.push(LinearConstraint::ge(sink_terms, self.required_flow()));
 
         // Objective: minimize Σ p(a) · y_a
-        let objective: Vec<(usize, f64)> =
-            (0..m).map(|a| (y(a), self.prices()[a] as f64)).collect();
+        let objective: Vec<(usize, i64)> = (0..m).map(|a| (y(a), self.prices()[a])).collect();
 
-        ReductionMECFToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize),
+        Ok(ReductionMECFToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_edges: m,
-        }
+        })
     }
 }
 
@@ -142,7 +147,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 4,
                 3,
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/minimumexternalmacrodatacompression_ilp.rs b/src/rules/minimumexternalmacrodatacompression_ilp.rs
index 9e50b9f1a..ba34bba53 100644
--- a/src/rules/minimumexternalmacrodatacompression_ilp.rs
+++ b/src/rules/minimumexternalmacrodatacompression_ilp.rs
@@ -121,66 +121,85 @@ impl ReductionResult for ReductionEMDCToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.layout.n;
-        let k = self.alphabet_size;
-        let empty = k; // empty marker
-
-        // Build D-slots
-        let mut d_slots = vec![empty; n];
-        for j in 0..n {
-            if target_solution[self.layout.d_used_var(j)] == 1 {
-                for c in 0..k {
-                    if target_solution[self.layout.d_var(j, c)] == 1 {
-                        d_slots[j] = c;
-                        break;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.layout.n;
+            let k = self.alphabet_size;
+            let empty = k; // empty marker
+
+            // Build D-slots
+            let mut d_slots = vec![empty; n];
+            for j in 0..n {
+                let symbols: Vec<_> = (0..k)
+                    .filter(|&c| target_solution[self.layout.d_var(j, c)] == 1)
+                    .collect();
+                if target_solution[self.layout.d_used_var(j)] == 1 {
+                    match symbols.as_slice() {
+                        [symbol] => d_slots[j] = *symbol,
+                        [] => {
+                            return Err(crate::rules::ExtractionError::invalid(format!(
+                                "dictionary slot {j} is active without a symbol"
+                            )))
+                        }
+                        _ => {
+                            return Err(crate::rules::ExtractionError::invalid(format!(
+                                "dictionary slot {j} selects multiple symbols"
+                            )))
+                        }
                     }
+                } else if !symbols.is_empty() {
+                    return Err(crate::rules::ExtractionError::invalid(format!(
+                        "inactive dictionary slot {j} selects a symbol"
+                    )));
                 }
             }
-        }
 
-        // Walk through active segments to build C-slots
-        let mut c_slots = vec![empty; n];
-        let mut c_pos = 0;
-        let mut pos = 0;
-        while pos < n {
-            // Check if lit[pos] = 1
-            if target_solution[self.layout.lit_var(pos)] == 1 {
-                // Literal at position pos
-                c_slots[c_pos] = self.source_string[pos];
-                c_pos += 1;
-                pos += 1;
-                continue;
-            }
-            // Check for an active pointer starting at pos
-            let mut found = false;
-            for l in 1..=(n - pos) {
-                for d_start in 0..=(n - l) {
-                    let var_idx = self.layout.ptr_var(pos, l, d_start);
-                    if target_solution[var_idx] == 1 {
-                        // Encode pointer (d_start, l) as EMDC pointer index
-                        let ptr_idx = encode_pointer(n, d_start, l);
-                        c_slots[c_pos] = k + 1 + ptr_idx;
-                        c_pos += 1;
-                        pos += l;
-                        found = true;
-                        break;
+            // Walk through active segments to build C-slots
+            let mut c_slots = vec![empty; n];
+            let mut c_pos = 0;
+            let mut pos = 0;
+            while pos < n {
+                let pointers: Vec<_> = (1..=(n - pos))
+                    .flat_map(|length| {
+                        (0..=(n - length)).filter_map(move |start| {
+                            (target_solution[self.layout.ptr_var(pos, length, start)] == 1)
+                                .then_some((start, length))
+                        })
+                    })
+                    .collect();
+                if target_solution[self.layout.lit_var(pos)] == 1 {
+                    if !pointers.is_empty() {
+                        return Err(crate::rules::ExtractionError::invalid(format!(
+                            "position {pos} selects both a literal and a pointer"
+                        )));
                     }
+                    // Literal at position pos
+                    c_slots[c_pos] = self.source_string[pos];
+                    c_pos += 1;
+                    pos += 1;
+                    continue;
                 }
-                if found {
-                    break;
-                }
-            }
-            if !found {
-                // Should not happen with a valid ILP solution
-                pos += 1;
+                let [(d_start, length)] = pointers.as_slice() else {
+                    return Err(crate::rules::ExtractionError::invalid(format!(
+                        "position {pos} must select exactly one pointer"
+                    )));
+                };
+                let ptr_idx = encode_pointer(n, *d_start, *length);
+                c_slots[c_pos] = k + 1 + ptr_idx;
+                c_pos += 1;
+                pos += length;
             }
-        }
 
-        // Combine D-slots and C-slots
-        let mut config = d_slots;
-        config.extend(c_slots);
-        config
+            // Combine D-slots and C-slots
+            let mut config = d_slots;
+            config.extend(c_slots);
+            config
+        })
     }
 }
 
@@ -195,15 +214,18 @@ fn encode_pointer(n: usize, start: usize, len: usize) -> usize {
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "string_length * alphabet_size + 2 * string_length + string_length ^ 3",
         num_constraints = "string_length + string_length * alphabet_size + string_length + string_length + 1 + string_length ^ 3 * string_length",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MinimumExternalMacroDataCompression {
     type Result = ReductionEMDCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.string_length();
         let k = self.alphabet_size();
         let h = self.pointer_cost();
@@ -212,13 +234,14 @@ impl ReduceTo<ILP<bool>> for MinimumExternalMacroDataCompression {
         // Handle empty string
         if n == 0 {
             let layout = VarLayout::new(0, k);
-            let target = ILP::new(0, vec![], vec![], ObjectiveSense::Minimize);
-            return ReductionEMDCToILP {
+            let target = ILP::new(0, vec![], vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?;
+            return Ok(ReductionEMDCToILP {
                 target,
                 layout,
                 source_string: vec![],
                 alphabet_size: k,
-            };
+            });
         }
 
         let layout = VarLayout::new(n, k);
@@ -227,16 +250,16 @@ impl ReduceTo<ILP<bool>> for MinimumExternalMacroDataCompression {
 
         // 1. Dictionary one-hot: for each j, sum_c d[j][c] <= 1
         for j in 0..n {
-            let terms: Vec<(usize, f64)> = (0..k).map(|c| (layout.d_var(j, c), 1.0)).collect();
-            constraints.push(LinearConstraint::le(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..k).map(|c| (layout.d_var(j, c), 1)).collect();
+            constraints.push(LinearConstraint::le(terms, 1));
         }
 
         // 2. Dictionary linking: d[j][c] <= d_used[j] for all j, c
         for j in 0..n {
             for c in 0..k {
                 constraints.push(LinearConstraint::le(
-                    vec![(layout.d_var(j, c), 1.0), (layout.d_used_var(j), -1.0)],
-                    0.0,
+                    vec![(layout.d_var(j, c), 1), (layout.d_used_var(j), -1)],
+                    0,
                 ));
             }
         }
@@ -244,11 +267,8 @@ impl ReduceTo<ILP<bool>> for MinimumExternalMacroDataCompression {
         // 3. Dictionary contiguous: d_used[j+1] <= d_used[j] for j=0..n-2
         for j in 0..n.saturating_sub(1) {
             constraints.push(LinearConstraint::le(
-                vec![
-                    (layout.d_used_var(j + 1), 1.0),
-                    (layout.d_used_var(j), -1.0),
-                ],
-                0.0,
+                vec![(layout.d_used_var(j + 1), 1), (layout.d_used_var(j), -1)],
+                0,
             ));
         }
 
@@ -264,28 +284,28 @@ impl ReduceTo<ILP<bool>> for MinimumExternalMacroDataCompression {
         // At node n: sum of incoming = 1
 
         // Helper: get all terms for "segment flow" at (i, l)
-        // Returns the variable indices with coefficient 1.0
-        let segment_terms = |i: usize, l: usize| -> Vec<(usize, f64)> {
+        // Returns the variable indices with coefficient 1
+        let segment_terms = |i: usize, l: usize| -> Vec<(usize, i64)> {
             let mut terms = Vec::new();
             if l == 1 {
-                terms.push((layout.lit_var(i), 1.0));
+                terms.push((layout.lit_var(i), 1));
             }
             for &var in &layout.ptr_vars_for_segment(i, l) {
-                terms.push((var, 1.0));
+                terms.push((var, 1));
             }
             terms
         };
 
         // For each node, compute outgoing and incoming segment terms
         for node in 0..=n {
-            let mut all_terms: Vec<(usize, f64)> = Vec::new();
+            let mut all_terms: Vec<(usize, i64)> = Vec::new();
 
             if node == 0 {
                 // sum of outgoing(0, l) = 1
                 for l in 1..=n {
                     all_terms.extend(segment_terms(0, l));
                 }
-                constraints.push(LinearConstraint::eq(all_terms, 1.0));
+                constraints.push(LinearConstraint::eq(all_terms, 1));
             } else if node == n {
                 // sum of incoming(n) = 1
                 // incoming at node n: segments (j, l) where j + l = n
@@ -293,7 +313,7 @@ impl ReduceTo<ILP<bool>> for MinimumExternalMacroDataCompression {
                     let l = n - j;
                     all_terms.extend(segment_terms(j, l));
                 }
-                constraints.push(LinearConstraint::eq(all_terms, 1.0));
+                constraints.push(LinearConstraint::eq(all_terms, 1));
             } else {
                 // node 1..n-1: incoming = outgoing
                 // incoming: segments (j, l) where j + l = node
@@ -314,7 +334,7 @@ impl ReduceTo<ILP<bool>> for MinimumExternalMacroDataCompression {
                 for (var, coef) in outgoing {
                     all_terms.push((var, -coef));
                 }
-                constraints.push(LinearConstraint::eq(all_terms, 0.0));
+                constraints.push(LinearConstraint::eq(all_terms, 0));
             }
         }
 
@@ -326,11 +346,8 @@ impl ReduceTo<ILP<bool>> for MinimumExternalMacroDataCompression {
                 let symbol = s[i + offset];
                 // ptr[i][l][d_start] <= d[d_start + offset][symbol]
                 constraints.push(LinearConstraint::le(
-                    vec![
-                        (ptr_idx, 1.0),
-                        (layout.d_var(d_start + offset, symbol), -1.0),
-                    ],
-                    0.0,
+                    vec![(ptr_idx, 1), (layout.d_var(d_start + offset, symbol), -1)],
+                    0,
                 ));
             }
         }
@@ -342,25 +359,26 @@ impl ReduceTo<ILP<bool>> for MinimumExternalMacroDataCompression {
         // objective already penalizes literals.
 
         // Objective: minimize sum d_used[j] + sum lit[i] + h * sum ptr[i][l][d_start]
-        let mut objective: Vec<(usize, f64)> = Vec::new();
+        let mut objective: Vec<(usize, i64)> = Vec::new();
         for j in 0..n {
-            objective.push((layout.d_used_var(j), 1.0));
+            objective.push((layout.d_used_var(j), 1));
         }
         for i in 0..n {
-            objective.push((layout.lit_var(i), 1.0));
+            objective.push((layout.lit_var(i), 1));
         }
         for (idx, _) in layout.ptr_triples.iter().enumerate() {
-            objective.push((layout.ptr_offset + idx, h as f64));
+            objective.push((layout.ptr_offset + idx, h));
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionEMDCToILP {
+        Ok(ReductionEMDCToILP {
             target,
             layout,
             source_string: s.to_vec(),
             alphabet_size: k,
-        }
+        })
     }
 }
 
@@ -376,26 +394,29 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "minimumexternalmacrodatacompression_to_ilp",
         build: || {
             let source = MinimumExternalMacroDataCompression::new(2, vec![0, 1], 2);
-            let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+            let reduction =
+                ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
             let layout = &reduction.layout;
             let n = 2;
             let k = 2;
 
             // Build target config: all zeros, then set lit[0]=1, lit[1]=1
-            let mut target_config = vec![0usize; layout.total_vars];
+            let mut target_config = vec![0_i64; layout.total_vars];
             target_config[layout.lit_var(0)] = 1;
             target_config[layout.lit_var(1)] = 1;
 
             // Verify this is correct
-            let source_config = reduction.extract_solution(&target_config);
+            let source_config = reduction.extract_solution(&target_config).unwrap();
             debug_assert_eq!(source_config[..n], [k, k]); // D empty
             debug_assert_eq!(source_config[n..], [0, 1]); // C = "ab"
 
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/minimumfaultdetectiontestset_ilp.rs b/src/rules/minimumfaultdetectiontestset_ilp.rs
index 3e84ff1f9..bf0893c70 100644
--- a/src/rules/minimumfaultdetectiontestset_ilp.rs
+++ b/src/rules/minimumfaultdetectiontestset_ilp.rs
@@ -11,10 +11,12 @@ use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use std::collections::VecDeque;
 
-/// Result of reducing MinimumFaultDetectionTestSet to ILP<bool>.
+/// Result of reducing MinimumFaultDetectionTestSet to `ILP<bool>`.
 #[derive(Debug, Clone)]
 pub struct ReductionMFDTSToILP {
     target: ILP<bool>,
+    num_inputs: usize,
+    num_outputs: usize,
 }
 
 impl ReductionResult for ReductionMFDTSToILP {
@@ -25,19 +27,35 @@ impl ReductionResult for ReductionMFDTSToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok((0..self.num_inputs)
+            .map(|input| {
+                (0..self.num_outputs)
+                    .map(|output| target_solution[input * self.num_outputs + output] == 1)
+                    .collect()
+            })
+            .collect())
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_inputs * num_outputs",
-    num_constraints = "num_vertices - num_inputs - num_outputs",
-})]
+#[reduction(
+    transform = exact {
+        num_vars = "num_inputs * num_outputs",
+        num_constraints = "num_vertices - num_inputs - num_outputs",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<ILP<bool>> for MinimumFaultDetectionTestSet {
     type Result = ReductionMFDTSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         fn reachable(adj: &[Vec<usize>], start: usize) -> Vec<bool> {
             let mut seen = vec![false; adj.len()];
             let mut queue = VecDeque::new();
@@ -95,19 +113,22 @@ impl ReduceTo<ILP<bool>> for MinimumFaultDetectionTestSet {
                     for (output_idx, output_cov) in output_reachability.iter().enumerate() {
                         if input_cov[vertex] && output_cov[vertex] {
                             let pair_idx = input_idx * self.num_outputs() + output_idx;
-                            terms.push((pair_idx, 1.0));
+                            terms.push((pair_idx, 1));
                         }
                     }
                 }
-                LinearConstraint::ge(terms, 1.0)
+                LinearConstraint::ge(terms, 1)
             })
             .collect();
 
-        let objective = (0..num_pairs).map(|pair_idx| (pair_idx, 1.0)).collect();
+        let objective = (0..num_pairs).map(|pair_idx| (pair_idx, 1)).collect();
 
-        ReductionMFDTSToILP {
-            target: ILP::new(num_pairs, constraints, objective, ObjectiveSense::Minimize),
-        }
+        Ok(ReductionMFDTSToILP {
+            target: ILP::new(num_pairs, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
+            num_inputs: self.num_inputs(),
+            num_outputs: self.num_outputs(),
+        })
     }
 }
 
diff --git a/src/rules/minimumfeedbackarcset_ilp.rs b/src/rules/minimumfeedbackarcset_ilp.rs
index fcce6d4ec..2de455d85 100644
--- a/src/rules/minimumfeedbackarcset_ilp.rs
+++ b/src/rules/minimumfeedbackarcset_ilp.rs
@@ -16,7 +16,7 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing MinimumFeedbackArcSet to ILP.
 ///
-/// The ILP uses integer variables (`ILP<i32>`) because it needs both
+/// The ILP uses integer variables (`ILP<i64>`) because it needs both
 /// binary arc-removal variables (y_a) and integer ordering variables (o_v).
 ///
 /// Variable layout:
@@ -24,16 +24,16 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// - `o_v` at index `m + v` for `v in 0..n`: integer in {0, ..., n-1}, topological order
 #[derive(Debug, Clone)]
 pub struct ReductionFASToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     /// Number of arcs in the source graph (needed for solution extraction).
     num_arcs: usize,
 }
 
 impl ReductionResult for ReductionFASToILP {
-    type Source = MinimumFeedbackArcSet<i32>;
-    type Target = ILP<i32>;
+    type Source = MinimumFeedbackArcSet<i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
@@ -41,21 +41,32 @@ impl ReductionResult for ReductionFASToILP {
     ///
     /// The first m variables of the ILP solution are the binary y_a values,
     /// which directly correspond to the FAS configuration (1 = removed).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_arcs].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_arcs]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_arcs + num_vertices",
         num_constraints = "num_arcs + num_arcs + num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for MinimumFeedbackArcSet<i32> {
+impl ReduceTo<ILP<i64>> for MinimumFeedbackArcSet<i64> {
     type Result = ReductionFASToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let m = self.num_arcs();
         let arcs = self.graph().arcs();
@@ -66,44 +77,45 @@ impl ReduceTo<ILP<i32>> for MinimumFeedbackArcSet<i32> {
         // o_v = m + v     (integer: topological order of vertex v)
 
         let mut constraints = Vec::new();
+        let n_i64 = Self::exact_i64(n, "encoding the topological order")?;
 
         // Binary bounds: y_a <= 1 for a in 0..m
         for a in 0..m {
-            constraints.push(LinearConstraint::le(vec![(a, 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(a, 1)], 1));
         }
 
         // Order bounds: o_v <= n - 1 for v in 0..n
         for v in 0..n {
-            constraints.push(LinearConstraint::le(vec![(m + v, 1.0)], (n - 1) as f64));
+            constraints.push(LinearConstraint::le(vec![(m + v, 1)], n_i64 - 1));
         }
 
         // Arc constraints: for each arc a = (u -> v):
         //   o_v - o_u >= 1 - n * y_a
         // Rearranged: o_v - o_u + n * y_a >= 1
-        let n_f64 = n as f64;
         for (a, &(u, v)) in arcs.iter().enumerate() {
             let terms = vec![
-                (m + v, 1.0),  // o_v
-                (m + u, -1.0), // -o_u
-                (a, n_f64),    // n * y_a
+                (m + v, 1),  // o_v
+                (m + u, -1), // -o_u
+                (a, n_i64),  // n * y_a
             ];
-            constraints.push(LinearConstraint::ge(terms, 1.0));
+            constraints.push(LinearConstraint::ge(terms, 1));
         }
 
         // Objective: minimize sum w_a * y_a
-        let objective: Vec<(usize, f64)> = self
+        let objective: Vec<(usize, i64)> = self
             .weights()
             .iter()
             .enumerate()
-            .map(|(a, &w)| (a, w as f64))
+            .map(|(arc, &weight)| (arc, weight))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionFASToILP {
+        Ok(ReductionFASToILP {
             target,
             num_arcs: m,
-        }
+        })
     }
 }
 
@@ -119,8 +131,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Remove arc 2 (2->0): source_config = [0, 0, 1]
             // ILP solution: y_0=0, y_1=0, y_2=1, o_0=0, o_1=1, o_2=2
             let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-            let source = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            let source = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/minimumfeedbackarcset_maximumlikelihoodranking.rs b/src/rules/minimumfeedbackarcset_maximumlikelihoodranking.rs
deleted file mode 100644
index 3b07146a5..000000000
--- a/src/rules/minimumfeedbackarcset_maximumlikelihoodranking.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-//! Reduction from MinimumFeedbackArcSet to MaximumLikelihoodRanking.
-//!
-//! On unit-weight instances, a ranking induces exactly the feedback arc set of
-//! backward arcs. The target matrix uses the skew-symmetric `c = 0` encoding:
-//! one-way arcs become `+/-1`, while bidirectional pairs and missing pairs map
-//! to `0`.
-
-use crate::models::graph::MinimumFeedbackArcSet;
-use crate::models::misc::MaximumLikelihoodRanking;
-use crate::reduction;
-use crate::rules::traits::{ReduceTo, ReductionResult};
-
-#[allow(clippy::needless_range_loop)]
-fn build_skew_symmetric_matrix(problem: &MinimumFeedbackArcSet<i32>) -> Vec<Vec<i32>> {
-    let n = problem.num_vertices();
-    let graph = problem.graph();
-    let mut matrix = vec![vec![0i32; n]; n];
-
-    for i in 0..n {
-        for j in (i + 1)..n {
-            let ij = graph.has_arc(i, j);
-            let ji = graph.has_arc(j, i);
-            if ij && !ji {
-                matrix[i][j] = 1;
-                matrix[j][i] = -1;
-            } else if ji && !ij {
-                matrix[i][j] = -1;
-                matrix[j][i] = 1;
-            }
-        }
-    }
-
-    matrix
-}
-
-/// Result of reducing MinimumFeedbackArcSet to MaximumLikelihoodRanking.
-#[derive(Debug, Clone)]
-pub struct ReductionFASToMLR {
-    target: MaximumLikelihoodRanking,
-    source_arcs: Vec<(usize, usize)>,
-}
-
-impl ReductionResult for ReductionFASToMLR {
-    type Source = MinimumFeedbackArcSet<i32>;
-    type Target = MaximumLikelihoodRanking;
-
-    fn target_problem(&self) -> &Self::Target {
-        &self.target
-    }
-
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.source_arcs
-            .iter()
-            .map(|&(u, v)| usize::from(target_solution[u] > target_solution[v]))
-            .collect()
-    }
-}
-
-#[reduction(
-    overhead = {
-        num_items = "num_vertices",
-    }
-)]
-impl ReduceTo<MaximumLikelihoodRanking> for MinimumFeedbackArcSet<i32> {
-    type Result = ReductionFASToMLR;
-
-    fn reduce_to(&self) -> Self::Result {
-        assert!(
-            self.weights().iter().all(|&weight| weight == 1),
-            "MinimumFeedbackArcSet -> MaximumLikelihoodRanking requires unit arc weights"
-        );
-
-        ReductionFASToMLR {
-            target: MaximumLikelihoodRanking::new(build_skew_symmetric_matrix(self)),
-            source_arcs: self.graph().arcs(),
-        }
-    }
-}
-
-#[cfg(feature = "example-db")]
-pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
-    use crate::export::SolutionPair;
-    use crate::solvers::BruteForce;
-
-    vec![crate::example_db::specs::RuleExampleSpec {
-        id: "minimumfeedbackarcset_to_maximumlikelihoodranking",
-        build: || {
-            let source = MinimumFeedbackArcSet::new(
-                crate::topology::DirectedGraph::new(
-                    5,
-                    vec![(0, 1), (1, 2), (2, 0), (2, 3), (3, 4), (4, 2), (0, 4)],
-                ),
-                vec![1i32; 7],
-            );
-            let reduction = ReduceTo::<MaximumLikelihoodRanking>::reduce_to(&source);
-            let target_witness = BruteForce::new()
-                .find_witness(reduction.target_problem())
-                .expect("target should have an optimum");
-            let source_witness = reduction.extract_solution(&target_witness);
-
-            crate::example_db::specs::rule_example_with_witness::<_, MaximumLikelihoodRanking>(
-                source,
-                SolutionPair {
-                    source_config: source_witness,
-                    target_config: target_witness,
-                },
-            )
-        },
-    }]
-}
-
-#[cfg(test)]
-#[path = "../unit_tests/rules/minimumfeedbackarcset_maximumlikelihoodranking.rs"]
-mod tests;
diff --git a/src/rules/minimumfeedbackvertexset_ilp.rs b/src/rules/minimumfeedbackvertexset_ilp.rs
index 1f3e45032..8b712b1a1 100644
--- a/src/rules/minimumfeedbackvertexset_ilp.rs
+++ b/src/rules/minimumfeedbackvertexset_ilp.rs
@@ -13,7 +13,7 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing MinimumFeedbackVertexSet to ILP.
 ///
-/// The ILP uses integer variables (`ILP<i32>`) because it needs both
+/// The ILP uses integer variables (`ILP<i64>`) because it needs both
 /// binary selection variables (x_i) and integer ordering variables (o_i).
 ///
 /// Variable layout:
@@ -21,16 +21,16 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// - `o_i` at index `n + i` for `i in 0..n`: integer in {0, ..., n-1}, topological order
 #[derive(Debug, Clone)]
 pub struct ReductionMFVSToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     /// Number of vertices in the source graph (needed for solution extraction).
     num_vertices: usize,
 }
 
 impl ReductionResult for ReductionMFVSToILP {
-    type Source = MinimumFeedbackVertexSet<i32>;
-    type Target = ILP<i32>;
+    type Source = MinimumFeedbackVertexSet<i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
@@ -38,21 +38,32 @@ impl ReductionResult for ReductionMFVSToILP {
     ///
     /// The first n variables of the ILP solution are the binary x_i values,
     /// which directly correspond to the FVS configuration (1 = removed).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_vertices]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "2 * num_vertices",
         num_constraints = "num_arcs + 2 * num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for MinimumFeedbackVertexSet<i32> {
+impl ReduceTo<ILP<i64>> for MinimumFeedbackVertexSet<i64> {
     type Result = ReductionMFVSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let arcs = self.graph().arcs();
         let num_vars = 2 * n;
@@ -62,45 +73,46 @@ impl ReduceTo<ILP<i32>> for MinimumFeedbackVertexSet<i32> {
         // o_i = n + i     (integer: topological order of vertex i)
 
         let mut constraints = Vec::new();
+        let n_i64 = <Self as ReduceTo<ILP<i64>>>::exact_i64(n, "encoding the topological order")?;
 
         // Binary bounds: x_i <= 1 for i in 0..n
         for i in 0..n {
-            constraints.push(LinearConstraint::le(vec![(i, 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(i, 1)], 1));
         }
 
         // Order bounds: o_i <= n - 1 for i in 0..n
         for i in 0..n {
-            constraints.push(LinearConstraint::le(vec![(n + i, 1.0)], (n - 1) as f64));
+            constraints.push(LinearConstraint::le(vec![(n + i, 1)], n_i64 - 1));
         }
 
         // Arc constraints: for each arc (u -> v):
         //   o_v - o_u >= 1 - n * (x_u + x_v)
         // Rearranged: o_v - o_u + n*x_u + n*x_v >= 1
-        let n_f64 = n as f64;
         for &(u, v) in &arcs {
             let terms = vec![
-                (n + v, 1.0),  // o_v
-                (n + u, -1.0), // -o_u
-                (u, n_f64),    // n * x_u
-                (v, n_f64),    // n * x_v
+                (n + v, 1),  // o_v
+                (n + u, -1), // -o_u
+                (u, n_i64),  // n * x_u
+                (v, n_i64),  // n * x_v
             ];
-            constraints.push(LinearConstraint::ge(terms, 1.0));
+            constraints.push(LinearConstraint::ge(terms, 1));
         }
 
         // Objective: minimize sum w_i * x_i
-        let objective: Vec<(usize, f64)> = self
+        let objective: Vec<(usize, i64)> = self
             .weights()
             .iter()
             .enumerate()
-            .map(|(i, &w)| (i, w as f64))
+            .map(|(vertex, &weight)| (vertex, weight))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<i64>>>::target_construction)?;
 
-        ReductionMFVSToILP {
+        Ok(ReductionMFVSToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -113,8 +125,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             // Simple cycle: 0 -> 1 -> 2 -> 0 (FVS = 1 vertex)
             let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-            let source = MinimumFeedbackVertexSet::new(graph, vec![1i32; 3]);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            let source = MinimumFeedbackVertexSet::new(graph, vec![1i64; 3]);
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters.rs b/src/rules/minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters.rs
index 82f5db3d7..1e336e56b 100644
--- a/src/rules/minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters.rs
+++ b/src/rules/minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters.rs
@@ -1,145 +1,125 @@
-//! Reduction from MinimumFeedbackVertexSet to MinimumCodeGenerationUnlimitedRegisters.
+//! Unit-weight feedback vertex set to unlimited-register code generation.
 //!
-//! The Aho-Johnson-Ullman chain gadget construction: for each source vertex x
-//! with outgoing edges (x,y₁),...,(x,y_d), create a chain of internal nodes
-//! x¹,...,x^d where xⁱ has left child x^{i-1} and right child y_i⁰ (the leaf).
-//! Copies in an optimal program correspond exactly to a minimum feedback vertex set.
+//! The Aho–Johnson–Ullman reduction encodes cardinality, not arbitrary vertex
+//! weights. Each source vertex has a start operation followed by its outgoing
+//! arc operations. The separate start makes each right-use strictly later than
+//! the originating start, including self-loops. An additional right-only leaf
+//! makes every start binary without introducing another possible copy.
 
 use crate::models::graph::MinimumFeedbackVertexSet;
 use crate::models::misc::MinimumCodeGenerationUnlimitedRegisters;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::types::One;
 
-/// Result of reducing MinimumFeedbackVertexSet to MinimumCodeGenerationUnlimitedRegisters.
+/// Result of the unit-weight FVS to code-generation reduction.
 #[derive(Debug, Clone)]
 pub struct ReductionFVSToCodeGen {
     target: MinimumCodeGenerationUnlimitedRegisters,
-    /// Number of source vertices (= number of leaves in the target DAG).
-    num_source_vertices: usize,
-    /// For each source vertex x, the target index of x¹ (first chain node).
-    /// `None` if vertex x has out-degree 0 (no chain, leaf only).
-    chain_start: Vec<Option<usize>>,
-    /// For each leaf x⁰ (source vertex x), the list of internal node target
-    /// indices that use x⁰ as a right child.
+    /// Configuration index of each source vertex's start operation.
+    chain_start: Vec<usize>,
+    /// Configuration indices of operations that right-use each original leaf.
     right_child_users: Vec<Vec<usize>>,
 }
 
 impl ReductionResult for ReductionFVSToCodeGen {
-    type Source = MinimumFeedbackVertexSet<i32>;
+    type Source = MinimumFeedbackVertexSet<One>;
     type Target = MinimumCodeGenerationUnlimitedRegisters;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    /// Extract a feedback vertex set from a target evaluation-order solution.
-    ///
-    /// A leaf register R_x is destroyed when x¹ executes (left operand).
-    /// If any right-child user of x⁰ is evaluated after x¹, a LOAD was needed,
-    /// meaning x is in the feedback vertex set.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_source_vertices;
-        let mut source_config = vec![0usize; n];
-
-        // target_solution[i] = evaluation position for the i-th internal node
-        // Internal nodes are indices n, n+1, ..., n+m-1 (sorted), so
-        // target_solution[j] = position for internal node (n + j).
-
-        // eval_pos[j] = evaluation position for internal node (n + j)
-        let eval_pos = target_solution;
-
-        for (x, cfg) in source_config.iter_mut().enumerate() {
-            if let Some(chain_start_idx) = self.chain_start[x] {
-                let start_j = chain_start_idx - n;
-                let start_pos = eval_pos[start_j];
-
-                for &user_idx in &self.right_child_users[x] {
-                    let user_j = user_idx - n;
-                    if eval_pos[user_j] > start_pos {
-                        *cfg = 1;
-                        break;
-                    }
-                }
-            }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if value.0.is_none() {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target order must be a permutation respecting expression dependencies",
+            ));
         }
-
-        source_config
+        Ok(self
+            .chain_start
+            .iter()
+            .zip(&self.right_child_users)
+            .map(|(&start, users)| {
+                users
+                    .iter()
+                    .any(|&user| target_solution[user] > target_solution[start])
+            })
+            .collect())
     }
 }
 
+/// Count source leaves, the dummy leaf, and all start/arc operations before allocation.
+fn code_generation_vertex_count(n: usize, m: usize) -> Result<usize, crate::rules::ReductionError> {
+    n.checked_mul(2)
+        .and_then(|count| count.checked_add(m))
+        .and_then(|count| count.checked_add(1))
+        .ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                MinimumFeedbackVertexSet<One>,
+                MinimumCodeGenerationUnlimitedRegisters,
+            >("counting code-generation start and arc nodes")
+        })
+}
+
 #[reduction(
-    overhead = {
-        num_vertices = "num_vertices + num_arcs",
+    transform = exact {
+        num_vertices = "2 * num_vertices + num_arcs + 1",
     }
 )]
-impl ReduceTo<MinimumCodeGenerationUnlimitedRegisters> for MinimumFeedbackVertexSet<i32> {
+impl ReduceTo<MinimumCodeGenerationUnlimitedRegisters> for MinimumFeedbackVertexSet<One> {
     type Result = ReductionFVSToCodeGen;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let m = self.graph().num_arcs();
-
-        // Build outgoing adjacency list
-        let mut out_neighbors: Vec<Vec<usize>> = vec![vec![]; n];
+        let num_vertices = code_generation_vertex_count(n, m)?;
+        // All subsequent offsets are bounded by the checked total above.
+        let first_internal = n + 1;
+        let num_internal = n + m;
+        let mut out_neighbors = vec![vec![]; n];
         for (u, v) in self.graph().arcs() {
             out_neighbors[u].push(v);
         }
-
-        // Assign internal node indices: leaves are 0..n, chain nodes are n..n+m
-        let mut left_arcs = Vec::with_capacity(m);
-        let mut right_arcs = Vec::with_capacity(m);
-        let mut chain_start = vec![None; n];
-        let mut right_child_users: Vec<Vec<usize>> = vec![vec![]; n];
-
-        let mut next_internal = n; // first internal node index
-        for x in 0..n {
-            let neighbors = &out_neighbors[x];
-            let d = neighbors.len();
-            if d == 0 {
-                continue;
+        let mut left_arcs = Vec::with_capacity(num_internal);
+        let mut right_arcs = Vec::with_capacity(num_internal);
+        let mut chain_start = Vec::with_capacity(n);
+        let mut right_child_users = vec![vec![]; n];
+        let mut next_internal = first_internal;
+        for (x, neighbors) in out_neighbors.iter().enumerate() {
+            chain_start.push(next_internal - first_internal);
+            left_arcs.push((next_internal, x));
+            right_arcs.push((next_internal, n)); // dummy leaf is never overwritten
+            next_internal += 1;
+            for &neighbor in neighbors {
+                left_arcs.push((next_internal, next_internal - 1));
+                right_arcs.push((next_internal, neighbor));
+                right_child_users[neighbor].push(next_internal - first_internal);
+                next_internal += 1;
             }
-
-            chain_start[x] = Some(next_internal);
-
-            for (i, &neighbor) in neighbors.iter().enumerate() {
-                let node_idx = next_internal + i;
-                // Left child: predecessor in chain
-                let left_child = if i == 0 {
-                    x // leaf x⁰
-                } else {
-                    next_internal + i - 1 // previous chain node
-                };
-                // Right child: leaf y_i⁰
-                let right_child = neighbor; // leaf index = source vertex index
-
-                left_arcs.push((node_idx, left_child));
-                right_arcs.push((node_idx, right_child));
-                right_child_users[right_child].push(node_idx);
-            }
-
-            next_internal += d;
         }
-
-        debug_assert_eq!(next_internal, n + m);
-
-        let target = MinimumCodeGenerationUnlimitedRegisters::new(n + m, left_arcs, right_arcs);
-
-        ReductionFVSToCodeGen {
+        debug_assert_eq!(next_internal, num_vertices);
+        let target =
+            MinimumCodeGenerationUnlimitedRegisters::new(num_vertices, left_arcs, right_arcs);
+        Ok(ReductionFVSToCodeGen {
             target,
-            num_source_vertices: n,
             chain_start,
             right_child_users,
-        }
+        })
     }
 }
 
 #[cfg(any(test, feature = "example-db"))]
-fn issue_example_source() -> MinimumFeedbackVertexSet<i32> {
+fn issue_example_source() -> MinimumFeedbackVertexSet<One> {
     use crate::topology::DirectedGraph;
-    // 3-cycle: a→b→c→a (vertices 0,1,2)
     MinimumFeedbackVertexSet::new(
         DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]),
-        vec![1i32; 3],
+        vec![One; 3],
     )
 }
 
@@ -152,31 +132,21 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "minimumfeedbackvertexset_to_minimumcodegenerationunlimitedregisters",
         build: || {
             let source = issue_example_source();
-            let reduction = ReduceTo::<MinimumCodeGenerationUnlimitedRegisters>::reduce_to(&source);
-
-            // Find a target witness whose extracted source solution matches an optimal FVS
-            let solver = BruteForce::new();
-            let source_witnesses = solver.find_all_witnesses(&source);
-            let target_witnesses = solver.find_all_witnesses(reduction.target_problem());
-
-            let (source_config, target_config) = target_witnesses
-                .iter()
-                .find_map(|tw| {
-                    let extracted = reduction.extract_solution(tw);
-                    if source_witnesses.contains(&extracted) {
-                        Some((extracted, tw.clone()))
-                    } else {
-                        None
-                    }
-                })
-                .expect("canonical FVS -> CodeGen example must have matching witness");
-
+            let reduction = ReduceTo::<MinimumCodeGenerationUnlimitedRegisters>::reduce_to(&source)
+                .expect("reduction should succeed");
+            let target_config = BruteForce::new()
+                .solve(reduction.target_problem())
+                .expect("canonical target evaluation must succeed")
+                .expect("canonical DAG has an evaluation order");
+            let source_config = reduction.extract_solution(&target_config).unwrap();
             crate::example_db::specs::assemble_rule_example(
                 &source,
                 reduction.target_problem(),
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/minimumgraphbandwidth_ilp.rs b/src/rules/minimumgraphbandwidth_ilp.rs
index 119d657d6..76e1b5692 100644
--- a/src/rules/minimumgraphbandwidth_ilp.rs
+++ b/src/rules/minimumgraphbandwidth_ilp.rs
@@ -15,47 +15,53 @@ use crate::topology::{Graph, SimpleGraph};
 
 /// Result of reducing MinimumGraphBandwidth to ILP.
 ///
-/// Variable layout (ILP<i32>, non-negative integers):
+/// Variable layout (`ILP<i64>`, non-negative integers):
 /// - `x_{v,p}` at index `v * n + p`, bounded to {0,1}
 /// - `pos_v` at index `n^2 + v`, integer position in {0, ..., n-1}
 /// - `B` (bandwidth) at index `n^2 + n`
 #[derive(Debug, Clone)]
 pub struct ReductionMGBToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_vertices: usize,
 }
 
 impl ReductionResult for ReductionMGBToILP {
     type Source = MinimumGraphBandwidth<SimpleGraph>;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Extract: for each vertex v, output its position p (the unique p with x_{v,p} = 1).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_vertices;
-        (0..n)
-            .map(|v| {
-                (0..n)
-                    .find(|&p| target_solution[v * n + p] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_vertices,
+            self.num_vertices,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices^2 + num_vertices + 1",
         num_constraints = "2 * num_vertices + num_vertices^2 + num_vertices + num_vertices + 1 + 2 * num_edges",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for MinimumGraphBandwidth<SimpleGraph> {
+impl ReduceTo<ILP<i64>> for MinimumGraphBandwidth<SimpleGraph> {
     type Result = ReductionMGBToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let graph = self.graph();
         let edges = graph.edges();
@@ -68,68 +74,70 @@ impl ReduceTo<ILP<i32>> for MinimumGraphBandwidth<SimpleGraph> {
         let b_idx = num_x + n;
 
         let mut constraints = Vec::new();
+        let n_i64 = Self::exact_i64(n, "encoding a vertex position")?;
 
         // Assignment: each vertex in exactly one position
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|p| (x_idx(v, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|p| (x_idx(v, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Assignment: each position has exactly one vertex
         for p in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|v| (x_idx(v, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|v| (x_idx(v, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
-        // Binary bounds for x variables (ILP<i32>)
+        // Binary bounds for x variables (`ILP<i64>`)
         for v in 0..n {
             for p in 0..n {
-                constraints.push(LinearConstraint::le(vec![(x_idx(v, p), 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(x_idx(v, p), 1)], 1));
             }
         }
 
         // Position variable linking: pos_v = sum_p p * x_{v,p}
         for v in 0..n {
-            let mut terms: Vec<(usize, f64)> = vec![(pos_idx(v), 1.0)];
+            let mut terms: Vec<(usize, i64)> = vec![(pos_idx(v), 1)];
             for p in 0..n {
-                terms.push((x_idx(v, p), -(p as f64)));
+                terms.push((
+                    x_idx(v, p),
+                    -Self::exact_i64(p, "encoding a vertex position")?,
+                ));
             }
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // Position bounds: 0 <= pos_v <= n-1
         for v in 0..n {
-            constraints.push(LinearConstraint::le(
-                vec![(pos_idx(v), 1.0)],
-                (n - 1) as f64,
-            ));
+            constraints.push(LinearConstraint::le(vec![(pos_idx(v), 1)], n_i64 - 1));
         }
 
         // Bandwidth upper bound: B <= n-1 (max possible position difference)
-        constraints.push(LinearConstraint::le(vec![(b_idx, 1.0)], (n - 1) as f64));
+        constraints.push(LinearConstraint::le(vec![(b_idx, 1)], n_i64 - 1));
 
         // Bandwidth constraints: for each edge (u,v):
         //   pos_u - pos_v <= B  =>  pos_u - pos_v - B <= 0
         //   pos_v - pos_u <= B  =>  pos_v - pos_u - B <= 0
         for &(u, v) in edges.iter() {
             constraints.push(LinearConstraint::le(
-                vec![(pos_idx(u), 1.0), (pos_idx(v), -1.0), (b_idx, -1.0)],
-                0.0,
+                vec![(pos_idx(u), 1), (pos_idx(v), -1), (b_idx, -1)],
+                0,
             ));
             constraints.push(LinearConstraint::le(
-                vec![(pos_idx(v), 1.0), (pos_idx(u), -1.0), (b_idx, -1.0)],
-                0.0,
+                vec![(pos_idx(v), 1), (pos_idx(u), -1), (b_idx, -1)],
+                0,
             ));
         }
 
         // Objective: minimize B
-        let objective = vec![(b_idx, 1.0)];
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let objective = vec![(b_idx, 1)];
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionMGBToILP {
+        Ok(ReductionMGBToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -141,7 +149,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Star S4: center 0 connected to 1, 2, 3
             let source =
                 MinimumGraphBandwidth::new(SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]));
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/minimumhittingset_ilp.rs b/src/rules/minimumhittingset_ilp.rs
index 14018ffaf..fe8f498d9 100644
--- a/src/rules/minimumhittingset_ilp.rs
+++ b/src/rules/minimumhittingset_ilp.rs
@@ -21,33 +21,42 @@ impl ReductionResult for ReductionHSToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "universe_size",
         num_constraints = "num_sets",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MinimumHittingSet {
     type Result = ReductionHSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.universe_size();
         let constraints: Vec<LinearConstraint> = self
             .sets()
             .iter()
             .map(|set| {
-                let terms: Vec<(usize, f64)> = set.iter().map(|&e| (e, 1.0)).collect();
-                LinearConstraint::ge(terms, 1.0)
+                let terms: Vec<(usize, i64)> = set.iter().map(|&e| (e, 1)).collect();
+                LinearConstraint::ge(terms, 1)
             })
             .collect();
-        let objective: Vec<(usize, f64)> = (0..num_vars).map(|i| (i, 1.0)).collect();
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
-        ReductionHSToILP { target }
+        let objective: Vec<(usize, i64)> = (0..num_vars).map(|i| (i, 1)).collect();
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionHSToILP { target })
     }
 }
 
diff --git a/src/rules/minimuminternalmacrodatacompression_ilp.rs b/src/rules/minimuminternalmacrodatacompression_ilp.rs
index fe442a3e2..0ff986409 100644
--- a/src/rules/minimuminternalmacrodatacompression_ilp.rs
+++ b/src/rules/minimuminternalmacrodatacompression_ilp.rs
@@ -95,73 +95,83 @@ impl ReductionResult for ReductionIMDCToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.layout.n;
-        let k = self.alphabet_size;
-        let eos = k; // end-of-string marker
-
-        // First pass: collect segments and build source-to-compressed-position map.
-        // source_to_c_pos[i] = compressed position that covers source position i.
-        let mut source_to_c_pos = vec![0usize; n];
-        let mut segments: Vec<(usize, usize, Option<usize>)> = Vec::new(); // (source_start, len, ref_source_pos)
-        let mut c_pos = 0;
-        let mut pos = 0;
-
-        while pos < n {
-            if target_solution[self.layout.lit_var(pos)] == 1 {
-                source_to_c_pos[pos] = c_pos;
-                segments.push((pos, 1, None));
-                c_pos += 1;
-                pos += 1;
-                continue;
-            }
-            let mut found = false;
-            for (idx, &(i, l, r)) in self.layout.ptr_triples.iter().enumerate() {
-                if i == pos && target_solution[self.layout.ptr_offset + idx] == 1 {
-                    for offset in 0..l {
-                        source_to_c_pos[pos + offset] = c_pos;
-                    }
-                    segments.push((pos, l, Some(r)));
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.layout.n;
+            let k = self.alphabet_size;
+            let eos = k; // end-of-string marker
+
+            // First pass: collect segments and build source-to-compressed-position map.
+            // source_to_c_pos[i] = compressed position that covers source position i.
+            let mut source_to_c_pos = vec![0usize; n];
+            let mut segments: Vec<(usize, usize, Option<usize>)> = Vec::new(); // (source_start, len, ref_source_pos)
+            let mut c_pos = 0;
+            let mut pos = 0;
+
+            while pos < n {
+                if target_solution[self.layout.lit_var(pos)] == 1 {
+                    source_to_c_pos[pos] = c_pos;
+                    segments.push((pos, 1, None));
                     c_pos += 1;
-                    pos += l;
-                    found = true;
-                    break;
+                    pos += 1;
+                    continue;
+                }
+                let mut found = false;
+                for (idx, &(i, l, r)) in self.layout.ptr_triples.iter().enumerate() {
+                    if i == pos && target_solution[self.layout.ptr_offset + idx] == 1 {
+                        for offset in 0..l {
+                            source_to_c_pos[pos + offset] = c_pos;
+                        }
+                        segments.push((pos, l, Some(r)));
+                        c_pos += 1;
+                        pos += l;
+                        found = true;
+                        break;
+                    }
+                }
+                if !found {
+                    pos += 1;
                 }
             }
-            if !found {
-                pos += 1;
-            }
-        }
 
-        // Second pass: build config using source_to_c_pos for pointer references
-        let mut config = vec![eos; n];
-        for (idx, &(src_start, _len, ref_pos)) in segments.iter().enumerate() {
-            match ref_pos {
-                None => {
-                    config[idx] = self.source_string[src_start];
-                }
-                Some(r) => {
-                    // Pointer references source position r, which is at
-                    // compressed position source_to_c_pos[r]
-                    config[idx] = k + 1 + source_to_c_pos[r];
+            // Second pass: build config using source_to_c_pos for pointer references
+            let mut config = vec![eos; n];
+            for (idx, &(src_start, _len, ref_pos)) in segments.iter().enumerate() {
+                match ref_pos {
+                    None => {
+                        config[idx] = self.source_string[src_start];
+                    }
+                    Some(r) => {
+                        // Pointer references source position r, which is at
+                        // compressed position source_to_c_pos[r]
+                        config[idx] = k + 1 + source_to_c_pos[r];
+                    }
                 }
             }
-        }
 
-        config
+            config
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "string_len + string_len ^ 3",
         num_constraints = "string_len + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MinimumInternalMacroDataCompression {
     type Result = ReductionIMDCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.string_len();
         let k = self.alphabet_size();
         let h = self.pointer_cost();
@@ -170,13 +180,14 @@ impl ReduceTo<ILP<bool>> for MinimumInternalMacroDataCompression {
         // Handle empty string
         if n == 0 {
             let layout = VarLayout::new(0, s);
-            let target = ILP::new(0, vec![], vec![], ObjectiveSense::Minimize);
-            return ReductionIMDCToILP {
+            let target = ILP::new(0, vec![], vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?;
+            return Ok(ReductionIMDCToILP {
                 target,
                 layout,
                 source_string: vec![],
                 alphabet_size: k,
-            };
+            });
         }
 
         let layout = VarLayout::new(n, s);
@@ -192,34 +203,34 @@ impl ReduceTo<ILP<bool>> for MinimumInternalMacroDataCompression {
         // At node j (1..n-1): sum of incoming = sum of outgoing
         // At node n: sum of incoming = 1
 
-        let segment_terms = |i: usize, l: usize| -> Vec<(usize, f64)> {
+        let segment_terms = |i: usize, l: usize| -> Vec<(usize, i64)> {
             let mut terms = Vec::new();
             if l == 1 {
-                terms.push((layout.lit_var(i), 1.0));
+                terms.push((layout.lit_var(i), 1));
             }
             // All ptr variables for segment (i, l, *)
             for (idx, &(pi, pl, _)) in layout.ptr_triples.iter().enumerate() {
                 if pi == i && pl == l {
-                    terms.push((layout.ptr_offset + idx, 1.0));
+                    terms.push((layout.ptr_offset + idx, 1));
                 }
             }
             terms
         };
 
         for node in 0..=n {
-            let mut all_terms: Vec<(usize, f64)> = Vec::new();
+            let mut all_terms: Vec<(usize, i64)> = Vec::new();
 
             if node == 0 {
                 for l in 1..=n {
                     all_terms.extend(segment_terms(0, l));
                 }
-                constraints.push(LinearConstraint::eq(all_terms, 1.0));
+                constraints.push(LinearConstraint::eq(all_terms, 1));
             } else if node == n {
                 for j in 0..n {
                     let l = n - j;
                     all_terms.extend(segment_terms(j, l));
                 }
-                constraints.push(LinearConstraint::eq(all_terms, 1.0));
+                constraints.push(LinearConstraint::eq(all_terms, 1));
             } else {
                 let mut incoming = Vec::new();
                 for j in 0..node {
@@ -236,7 +247,7 @@ impl ReduceTo<ILP<bool>> for MinimumInternalMacroDataCompression {
                 for (var, coef) in outgoing {
                     all_terms.push((var, -coef));
                 }
-                constraints.push(LinearConstraint::eq(all_terms, 0.0));
+                constraints.push(LinearConstraint::eq(all_terms, 0));
             }
         }
 
@@ -250,22 +261,23 @@ impl ReduceTo<ILP<bool>> for MinimumInternalMacroDataCompression {
         // Since each literal contributes 1 to |C| and each pointer contributes
         // 1 to |C| plus (h-1) to the pointer penalty:
         // cost = |C| + (h-1)*pointers = (lits + ptrs) + (h-1)*ptrs = lits + h*ptrs
-        let mut objective: Vec<(usize, f64)> = Vec::new();
+        let mut objective: Vec<(usize, i64)> = Vec::new();
         for i in 0..n {
-            objective.push((layout.lit_var(i), 1.0));
+            objective.push((layout.lit_var(i), 1));
         }
         for (idx, _) in layout.ptr_triples.iter().enumerate() {
-            objective.push((layout.ptr_offset + idx, h as f64));
+            objective.push((layout.ptr_offset + idx, h));
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionIMDCToILP {
+        Ok(ReductionIMDCToILP {
             target,
             layout,
             source_string: s.to_vec(),
             alphabet_size: k,
-        }
+        })
     }
 }
 
@@ -280,20 +292,23 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "minimuminternalmacrodatacompression_to_ilp",
         build: || {
             let source = MinimumInternalMacroDataCompression::new(2, vec![0, 1], 2);
-            let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+            let reduction =
+                ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
             let layout = &reduction.layout;
 
-            let mut target_config = vec![0usize; layout.total_vars];
+            let mut target_config = vec![0_i64; layout.total_vars];
             target_config[layout.lit_var(0)] = 1;
             target_config[layout.lit_var(1)] = 1;
 
-            let source_config = reduction.extract_solution(&target_config);
+            let source_config = reduction.extract_solution(&target_config).unwrap();
 
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/minimummatrixcover_ilp.rs b/src/rules/minimummatrixcover_ilp.rs
index ecbfe96e5..d279e1b67 100644
--- a/src/rules/minimummatrixcover_ilp.rs
+++ b/src/rules/minimummatrixcover_ilp.rs
@@ -8,8 +8,9 @@
 //!   y_{ij} ≤ x_i, y_{ij} ≤ x_j, y_{ij} ≥ x_i + x_j - 1
 
 use crate::models::algebraic::MinimumMatrixCover;
-use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::models::algebraic::{ObjectiveSense, ILP};
 use crate::reduction;
+use crate::rules::ilp_helpers::mccormick_product;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing MinimumMatrixCover to ILP.
@@ -27,9 +28,19 @@ impl ReductionResult for ReductionMinimumMatrixCoverToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // First n variables are the sign variables x_0,...,x_{n-1}
-        target_solution[..self.n].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // First n variables are the sign variables x_0,...,x_{n-1}
+            target_solution[..self.n]
+                .iter()
+                .map(|&value| value == 1)
+                .collect()
+        })
     }
 }
 
@@ -42,15 +53,18 @@ fn y_index(n: usize, i: usize, j: usize) -> usize {
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_rows + num_rows * (num_rows - 1) / 2",
         num_constraints = "3 * num_rows * (num_rows - 1) / 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MinimumMatrixCover {
     type Result = ReductionMinimumMatrixCoverToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_rows();
         let num_pairs = n * (n.saturating_sub(1)) / 2;
         let num_vars = n + num_pairs;
@@ -61,17 +75,7 @@ impl ReduceTo<ILP<bool>> for MinimumMatrixCover {
             for j in (i + 1)..n {
                 let y = y_index(n, i, j);
 
-                // y_{ij} ≤ x_i  →  y_{ij} - x_i ≤ 0
-                constraints.push(LinearConstraint::le(vec![(y, 1.0), (i, -1.0)], 0.0));
-
-                // y_{ij} ≤ x_j  →  y_{ij} - x_j ≤ 0
-                constraints.push(LinearConstraint::le(vec![(y, 1.0), (j, -1.0)], 0.0));
-
-                // y_{ij} ≥ x_i + x_j - 1  →  -y_{ij} + x_i + x_j ≤ 1
-                constraints.push(LinearConstraint::le(
-                    vec![(y, -1.0), (i, 1.0), (j, 1.0)],
-                    1.0,
-                ));
+                constraints.extend(mccormick_product(y, i, j));
             }
         }
 
@@ -88,41 +92,63 @@ impl ReduceTo<ILP<bool>> for MinimumMatrixCover {
         //             + Σ_k [-2·(Σ_{j≠k} (a_kj + a_jk))]·x_k
         //             + constant
         //
-        // The constant doesn't affect which x minimizes the objective.
-        // But we can still include it as an ILP constant offset... however
-        // ILP only has linear terms. Since extract_solution maps back to source
-        // and source.evaluate() computes the correct value, we just need the
-        // ILP to find the right optimum assignment. The constant is irrelevant.
+        // The constant does not affect the minimizing assignment. The mapped
+        // source solution is evaluated by the source problem, so omit it here.
 
         let matrix = self.matrix();
-        let mut obj_coeffs = vec![0.0f64; num_vars];
+        let mut obj_coeffs = vec![0i64; num_vars];
 
         // y_{ij} coefficients: 4·(a_ij + a_ji) for each i<j
         for (i, row_i) in matrix.iter().enumerate() {
             for j in (i + 1)..n {
                 let y = y_index(n, i, j);
-                obj_coeffs[y] = 4.0 * (row_i[j] + matrix[j][i]) as f64;
+                let coefficient = row_i[j]
+                    .checked_add(matrix[j][i])
+                    .and_then(|value| value.checked_mul(4))
+                    .ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<
+                            MinimumMatrixCover,
+                            ILP<bool>,
+                        >(
+                            "computing an off-diagonal matrix-cover coefficient"
+                        )
+                    })?;
+                obj_coeffs[y] = coefficient;
             }
         }
 
         // x_k coefficients: -2·Σ_{j≠k} (a_kj + a_jk)
         for (k, row_k) in matrix.iter().enumerate() {
-            let sum: i64 = (0..n)
-                .filter(|&j| j != k)
-                .map(|j| row_k[j] + matrix[j][k])
-                .sum();
-            obj_coeffs[k] = -2.0 * sum as f64;
+            let sum = (0..n).filter(|&j| j != k).try_fold(0_i64, |total, j| {
+                let pair = row_k[j].checked_add(matrix[j][k]).ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<MinimumMatrixCover, ILP<bool>>(
+                        "adding symmetric matrix-cover entries",
+                    )
+                })?;
+                total.checked_add(pair).ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<MinimumMatrixCover, ILP<bool>>(
+                        "summing matrix-cover row coefficients",
+                    )
+                })
+            })?;
+            let coefficient = sum.checked_mul(-2).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<MinimumMatrixCover, ILP<bool>>(
+                    "scaling a matrix-cover row coefficient",
+                )
+            })?;
+            obj_coeffs[k] = coefficient;
         }
 
-        let objective: Vec<(usize, f64)> = obj_coeffs
+        let objective: Vec<(usize, i64)> = obj_coeffs
             .into_iter()
             .enumerate()
-            .filter(|&(_, c)| c != 0.0)
+            .filter(|&(_, c)| c != 0)
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionMinimumMatrixCoverToILP { target, n }
+        Ok(ReductionMinimumMatrixCoverToILP { target, n })
     }
 }
 
@@ -144,8 +170,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1],
-                    target_config: vec![0, 1, 0],
+                    source_config: serde_json::json!(vec![false, true]),
+                    target_config: serde_json::json!(vec![0, 1, 0]),
                 },
             )
         },
diff --git a/src/rules/minimummaximalmatching_ilp.rs b/src/rules/minimummaximalmatching_ilp.rs
index bbb39f80c..33e1f2afe 100644
--- a/src/rules/minimummaximalmatching_ilp.rs
+++ b/src/rules/minimummaximalmatching_ilp.rs
@@ -38,21 +38,29 @@ impl ReductionResult for ReductionMMMToILP {
     ///
     /// Since the mapping is 1:1 (each edge maps to one binary variable),
     /// the solution extraction is simply copying the configuration.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_edges",
         num_constraints = "num_vertices + num_edges",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MinimumMaximalMatching<SimpleGraph> {
     type Result = ReductionMMMToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let edges = self.graph().edges();
         let num_vars = edges.len();
         let mut constraints = Vec::new();
@@ -67,8 +75,8 @@ impl ReduceTo<ILP<bool>> for MinimumMaximalMatching<SimpleGraph> {
         }
         for incident in &v2e {
             if !incident.is_empty() {
-                let terms: Vec<(usize, f64)> = incident.iter().map(|&e| (e, 1.0)).collect();
-                constraints.push(LinearConstraint::le(terms, 1.0));
+                let terms: Vec<(usize, i64)> = incident.iter().map(|&e| (e, 1)).collect();
+                constraints.push(LinearConstraint::le(terms, 1));
             }
         }
 
@@ -83,15 +91,16 @@ impl ReduceTo<ILP<bool>> for MinimumMaximalMatching<SimpleGraph> {
                     neighbors.push(i);
                 }
             }
-            let terms: Vec<(usize, f64)> = neighbors.iter().map(|&i| (i, 1.0)).collect();
-            constraints.push(LinearConstraint::ge(terms, 1.0));
+            let terms: Vec<(usize, i64)> = neighbors.iter().map(|&i| (i, 1)).collect();
+            constraints.push(LinearConstraint::ge(terms, 1));
         }
 
         // Objective: minimize sum e_i
-        let objective: Vec<(usize, f64)> = (0..num_vars).map(|i| (i, 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..num_vars).map(|i| (i, 1)).collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
-        ReductionMMMToILP { target }
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionMMMToILP { target })
     }
 }
 
diff --git a/src/rules/minimummaximalmatching_maximumachromaticnumber.rs b/src/rules/minimummaximalmatching_maximumachromaticnumber.rs
index 81bbbb893..65615aa27 100644
--- a/src/rules/minimummaximalmatching_maximumachromaticnumber.rs
+++ b/src/rules/minimummaximalmatching_maximumachromaticnumber.rs
@@ -42,16 +42,23 @@ impl ReductionResult for ReductionMMMToAchromatic {
     /// size 2, i.e., a source edge. A source edge `(u, v)` belongs to the
     /// extracted matching iff `u` and `v` share a color, which we detect in a
     /// single pass over `source_edges`.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.source_edges
-            .iter()
-            .map(|&(u, v)| usize::from(target_solution[u] == target_solution[v]))
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            self.source_edges
+                .iter()
+                .map(|&(u, v)| target_solution[u] == target_solution[v])
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_vertices * (num_vertices - 1) / 2 - num_edges",
     }
@@ -59,7 +66,7 @@ impl ReductionResult for ReductionMMMToAchromatic {
 impl ReduceTo<MaximumAchromaticNumber<SimpleGraph>> for MinimumMaximalMatching<BipartiteGraph> {
     type Result = ReductionMMMToAchromatic;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let source_edges = self.graph().edges();
 
@@ -81,10 +88,10 @@ impl ReduceTo<MaximumAchromaticNumber<SimpleGraph>> for MinimumMaximalMatching<B
 
         let target = MaximumAchromaticNumber::new(SimpleGraph::new(n, complement_edges));
 
-        ReductionMMMToAchromatic {
+        Ok(ReductionMMMToAchromatic {
             target,
             source_edges,
-        }
+        })
     }
 }
 
@@ -150,8 +157,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 0, 0],
-                    target_config: vec![1, 0, 3, 0, 2],
+                    source_config: serde_json::json!(vec![false, true, false, false]),
+                    target_config: serde_json::json!(vec![1, 0, 3, 0, 2]),
                 },
             )
         },
diff --git a/src/rules/minimummaximalmatching_minimummatrixdomination.rs b/src/rules/minimummaximalmatching_minimummatrixdomination.rs
index 97c5d4d75..03b0c98d7 100644
--- a/src/rules/minimummaximalmatching_minimummatrixdomination.rs
+++ b/src/rules/minimummaximalmatching_minimummatrixdomination.rs
@@ -93,107 +93,127 @@ impl ReductionResult for ReductionMMMToMatrixDomination {
     /// and a swap candidate, for a total of `O(|F|^3)` time. The result is a
     /// matching that is an EDS, i.e. an independent EDS, which is precisely a
     /// maximal matching.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let graph = self.source.graph();
-        let edges = graph.edges();
-        let num_source_edges = edges.len();
-        let m = graph.left_size();
-        let target_ones = self.target.ones();
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
-        // Step 1: map selected target 1-entries back to source edge indices.
-        // The reduction places source edge `(l_i, r_j)` (in bipartite-local
-        // form) at matrix cell `(i, m + j)`, which equals the global edge
-        // `(i, m + j)` returned by `Graph::edges()`. Build the lookup from
-        // matrix cell -> source edge index so we are robust to any ordering
-        // discrepancy between `Graph::edges()` and row-major 1-entries.
-        let cell_to_source_edge: std::collections::HashMap<(usize, usize), usize> = edges
-            .iter()
-            .enumerate()
-            .map(|(idx, &(u, v))| {
-                // Source edge endpoints in bipartite global coords are
-                // (left_idx, m + right_idx); matrix cell is (row=left, col=m+right).
-                let (row, col) = if u < m { (u, v) } else { (v, u) };
-                ((row, col), idx)
-            })
-            .collect();
-        let mut d: Vec<usize> = target_solution
-            .iter()
-            .zip(target_ones.iter())
-            .filter_map(|(&sel, &cell)| {
-                if sel == 1 {
-                    cell_to_source_edge.get(&cell).copied()
-                } else {
-                    None
-                }
-            })
-            .collect();
+        Ok({
+            let graph = self.source.graph();
+            let edges = graph.edges();
+            let num_source_edges = edges.len();
+            let m = graph.left_size();
+            let target_ones = self.target.ones();
 
-        // Step 2: Yannakakis-Gavril EDS -> independent EDS (maximal matching).
-        // Loop invariants: `d` is an EDS of the source graph; each iteration
-        // strictly decreases either |d| or the number of (unordered) pairs of
-        // adjacent edges inside `d`.
-        loop {
-            // Find an adjacent pair (e1_idx, e2_idx) inside `d`, sharing vertex v.
-            let pair = find_adjacent_pair(&d, &edges);
-            let Some((e1_idx, e2_idx, _shared)) = pair else {
-                break; // `d` is a matching; we are done.
-            };
+            // Step 1: map selected target 1-entries back to source edge indices.
+            // The reduction places source edge `(l_i, r_j)` (in bipartite-local
+            // form) at matrix cell `(i, m + j)`, which equals the global edge
+            // `(i, m + j)` returned by `Graph::edges()`. Build the lookup from
+            // matrix cell -> source edge index so we are robust to any ordering
+            // discrepancy between `Graph::edges()` and row-major 1-entries.
+            let cell_to_source_edge: std::collections::HashMap<(usize, usize), usize> = edges
+                .iter()
+                .enumerate()
+                .map(|(idx, &(u, v))| {
+                    // Source edge endpoints in bipartite global coords are
+                    // (left_idx, m + right_idx); matrix cell is (row=left, col=m+right).
+                    let (row, col) = if u < m { (u, v) } else { (v, u) };
+                    ((row, col), idx)
+                })
+                .collect();
+            let mut d: Vec<usize> = target_solution
+                .iter()
+                .zip(target_ones.iter())
+                .filter_map(|(&sel, &cell)| {
+                    if sel {
+                        Some(cell_to_source_edge.get(&cell).copied().ok_or_else(|| {
+                            crate::rules::ExtractionError::invalid(format!(
+                                "selected matrix cell {cell:?} has no source edge"
+                            ))
+                        }))
+                    } else {
+                        None
+                    }
+                })
+                .collect::<crate::rules::ExtractionResult<_>>()?;
 
-            // Try dropping e1_idx or e2_idx if the remainder is still an EDS.
-            let mut without_e1 = d.clone();
-            without_e1.swap_remove(d.iter().position(|&x| x == e1_idx).unwrap());
-            if is_edge_dominating_set(&without_e1, &edges) {
-                d = without_e1;
-                continue;
-            }
-            let mut without_e2 = d.clone();
-            without_e2.swap_remove(d.iter().position(|&x| x == e2_idx).unwrap());
-            if is_edge_dominating_set(&without_e2, &edges) {
-                d = without_e2;
-                continue;
-            }
+            // Step 2: Yannakakis-Gavril EDS -> independent EDS (maximal matching).
+            // Loop invariants: `d` is an EDS of the source graph; each iteration
+            // strictly decreases either |d| or the number of (unordered) pairs of
+            // adjacent edges inside `d`.
+            loop {
+                // Find an adjacent pair (e1_idx, e2_idx) inside `d`, sharing vertex v.
+                let pair = find_adjacent_pair(&d, &edges);
+                let Some((e1_idx, e2_idx, _shared)) = pair else {
+                    break; // `d` is a matching; we are done.
+                };
 
-            // Neither drop works -> perform a swap on one of e1 or e2.
-            // Choose endpoint not shared with the other edge: for e1=(u, v),
-            // e2=(v, w), the "non-shared" endpoint of e1 is u.
-            let (e1_a, e1_b) = edges[e1_idx];
-            let (e2_a, e2_b) = edges[e2_idx];
-            let shared = if e1_a == e2_a || e1_a == e2_b {
-                e1_a
-            } else {
-                e1_b
-            };
-            let u = if e1_a == shared { e1_b } else { e1_a };
-            let w = if e2_a == shared { e2_b } else { e2_a };
+                // Try dropping e1_idx or e2_idx if the remainder is still an EDS.
+                let mut without_e1 = d.clone();
+                let e1_position = d.iter().position(|&x| x == e1_idx).ok_or_else(|| {
+                    crate::rules::ExtractionError::invalid(
+                        "edge-domination transformation lost its selected edge",
+                    )
+                })?;
+                without_e1.swap_remove(e1_position);
+                if is_edge_dominating_set(&without_e1, &edges) {
+                    d = without_e1;
+                    continue;
+                }
+                let mut without_e2 = d.clone();
+                let e2_position = d.iter().position(|&x| x == e2_idx).ok_or_else(|| {
+                    crate::rules::ExtractionError::invalid(
+                        "edge-domination transformation lost its selected edge",
+                    )
+                })?;
+                without_e2.swap_remove(e2_position);
+                if is_edge_dominating_set(&without_e2, &edges) {
+                    d = without_e2;
+                    continue;
+                }
 
-            // Try to swap e1 := (u, x) where x ∉ V(d \ {e1}). The YG proof
-            // guarantees such x exists when neither drop succeeded.
-            if let Some(new_idx) = find_swap_edge(u, e1_idx, &d, &edges) {
-                replace_in(&mut d, e1_idx, new_idx);
-                continue;
-            }
-            // Symmetric swap on e2.
-            if let Some(new_idx) = find_swap_edge(w, e2_idx, &d, &edges) {
-                replace_in(&mut d, e2_idx, new_idx);
-                continue;
-            }
+                // Neither drop works -> perform a swap on one of e1 or e2.
+                // Choose endpoint not shared with the other edge: for e1=(u, v),
+                // e2=(v, w), the "non-shared" endpoint of e1 is u.
+                let (e1_a, e1_b) = edges[e1_idx];
+                let (e2_a, e2_b) = edges[e2_idx];
+                let shared = if e1_a == e2_a || e1_a == e2_b {
+                    e1_a
+                } else {
+                    e1_b
+                };
+                let u = if e1_a == shared { e1_b } else { e1_a };
+                let w = if e2_a == shared { e2_b } else { e2_a };
 
-            // YG guarantees that for an EDS at least one of the four moves
-            // above succeeds. Reaching this point implies the input was not
-            // a valid EDS (i.e., not a feasible MMD witness on the constructed
-            // instance), which violates the reduction's precondition.
-            unreachable!(
-                "Yannakakis-Gavril EDS->IEDS transformation could not progress; \
-                 target witness must be a feasible (dominating) MMD configuration"
-            );
-        }
+                // Try to swap e1 := (u, x) where x ∉ V(d \ {e1}). The YG proof
+                // guarantees such x exists when neither drop succeeded.
+                if let Some(new_idx) = find_swap_edge(u, e1_idx, &d, &edges) {
+                    d[e1_position] = new_idx;
+                    continue;
+                }
+                // Symmetric swap on e2.
+                if let Some(new_idx) = find_swap_edge(w, e2_idx, &d, &edges) {
+                    d[e2_position] = new_idx;
+                    continue;
+                }
 
-        // Step 3: encode the matching as a binary configuration over source edges.
-        let mut config = vec![0usize; num_source_edges];
-        for &idx in &d {
-            config[idx] = 1;
-        }
-        config
+                // YG guarantees that for an EDS at least one of the four moves
+                // above succeeds. Reaching this point implies the input was not
+                // a valid EDS (i.e., not a feasible MMD witness on the constructed
+                // instance), which violates the reduction's precondition.
+                return Err(crate::rules::ExtractionError::invalid(
+                    "target matrix entries do not encode an edge-dominating set",
+                ));
+            }
+
+            // Step 3: encode the matching as a binary configuration over source edges.
+            let mut config = vec![false; num_source_edges];
+            for &idx in &d {
+                config[idx] = true;
+            }
+            config
+        })
     }
 }
 
@@ -272,18 +292,8 @@ fn find_swap_edge(
     None
 }
 
-/// Replace `old_idx` with `new_idx` inside `d` in-place. Panics if `old_idx`
-/// is not present.
-fn replace_in(d: &mut [usize], old_idx: usize, new_idx: usize) {
-    let pos = d
-        .iter()
-        .position(|&x| x == old_idx)
-        .expect("old_idx must be present in d");
-    d[pos] = new_idx;
-}
-
 #[reduction(
-    overhead = {
+    transform = exact {
         num_rows = "num_vertices",
         num_cols = "num_vertices",
         num_ones = "num_edges",
@@ -292,7 +302,7 @@ fn replace_in(d: &mut [usize], old_idx: usize, new_idx: usize) {
 impl ReduceTo<MinimumMatrixDomination> for MinimumMaximalMatching<BipartiteGraph> {
     type Result = ReductionMMMToMatrixDomination;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let g = self.graph();
         let m = g.left_size();
         let n = g.right_size();
@@ -311,10 +321,10 @@ impl ReduceTo<MinimumMatrixDomination> for MinimumMaximalMatching<BipartiteGraph
 
         let target = MinimumMatrixDomination::new(matrix);
 
-        ReductionMMMToMatrixDomination {
+        Ok(ReductionMMMToMatrixDomination {
             target,
             source: self.clone(),
-        }
+        })
     }
 }
 
@@ -359,8 +369,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, MinimumMatrixDomination>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1, 0],
-                    target_config: vec![1, 0, 0, 1, 0],
+                    source_config: serde_json::json!(vec![true, false, false, true, false]),
+                    target_config: serde_json::json!(vec![true, false, false, true, false]),
                 },
             )
         },
diff --git a/src/rules/minimummetricdimension_ilp.rs b/src/rules/minimummetricdimension_ilp.rs
index 16516c72a..a10a1e9a5 100644
--- a/src/rules/minimummetricdimension_ilp.rs
+++ b/src/rules/minimummetricdimension_ilp.rs
@@ -38,21 +38,29 @@ impl ReductionResult for ReductionMDToILP {
     ///
     /// Since the mapping is 1:1 (each vertex maps to one binary variable),
     /// the solution extraction is simply copying the configuration.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices",
         num_constraints = "num_vertices * (num_vertices - 1) / 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MinimumMetricDimension<SimpleGraph> {
     type Result = ReductionMDToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
 
         // Precompute all-pairs shortest paths via BFS from each vertex
@@ -63,20 +71,21 @@ impl ReduceTo<ILP<bool>> for MinimumMetricDimension<SimpleGraph> {
         let mut constraints = Vec::new();
         for u in 0..n {
             for v in (u + 1)..n {
-                let terms: Vec<(usize, f64)> = (0..n)
+                let terms: Vec<(usize, i64)> = (0..n)
                     .filter(|&w| all_dists[w][u] != all_dists[w][v])
-                    .map(|w| (w, 1.0))
+                    .map(|w| (w, 1))
                     .collect();
-                constraints.push(LinearConstraint::ge(terms, 1.0));
+                constraints.push(LinearConstraint::ge(terms, 1));
             }
         }
 
         // Objective: minimize Σ z_v (unit weights)
-        let objective: Vec<(usize, f64)> = (0..n).map(|v| (v, 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..n).map(|v| (v, 1)).collect();
 
-        let target = ILP::new(n, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(n, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionMDToILP { target }
+        Ok(ReductionMDToILP { target })
     }
 }
 
diff --git a/src/rules/minimummultiwaycut_ilp.rs b/src/rules/minimummultiwaycut_ilp.rs
index 62f442eaf..51c157007 100644
--- a/src/rules/minimummultiwaycut_ilp.rs
+++ b/src/rules/minimummultiwaycut_ilp.rs
@@ -32,7 +32,7 @@ pub struct ReductionMMCToILP {
 }
 
 impl ReductionResult for ReductionMMCToILP {
-    type Source = MinimumMultiwayCut<SimpleGraph, i32>;
+    type Source = MinimumMultiwayCut<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
@@ -42,22 +42,34 @@ impl ReductionResult for ReductionMMCToILP {
     /// Extract solution from ILP back to MinimumMultiwayCut.
     ///
     /// For each edge e, source config[e] = target_solution[k*n + e] (the x_e variable).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let offset = self.k * self.n;
-        (0..self.m).map(|e| target_solution[offset + e]).collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let offset = self.k * self.n;
+            (0..self.m)
+                .map(|e| target_solution[offset + e] == 1)
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_terminals * num_vertices + num_edges",
         num_constraints = "num_vertices + 2 * num_terminals * num_edges + num_terminals * num_terminals",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MinimumMultiwayCut<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for MinimumMultiwayCut<SimpleGraph, i64> {
     type Result = ReductionMMCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let m = self.num_edges();
         let k = self.num_terminals();
@@ -75,22 +87,22 @@ impl ReduceTo<ILP<bool>> for MinimumMultiwayCut<SimpleGraph, i32> {
 
         // Terminal fixing: y_{i, t_i} = 1 for each terminal i
         for (i, &t) in terminals.iter().enumerate() {
-            constraints.push(LinearConstraint::eq(vec![(i * n + t, 1.0)], 1.0));
+            constraints.push(LinearConstraint::eq(vec![(i * n + t, 1)], 1));
         }
 
         // Terminal fixing: y_{j, t_i} = 0 for j != i
         for (i, &t) in terminals.iter().enumerate() {
             for j in 0..k {
                 if j != i {
-                    constraints.push(LinearConstraint::eq(vec![(j * n + t, 1.0)], 0.0));
+                    constraints.push(LinearConstraint::eq(vec![(j * n + t, 1)], 0));
                 }
             }
         }
 
         // Partition constraints: sum_i y_{iv} = 1 for each vertex v
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..k).map(|i| (i * n + v, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..k).map(|i| (i * n + v, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Edge-cut linking constraints: for each edge e=(u,v) and each terminal i:
@@ -103,27 +115,28 @@ impl ReduceTo<ILP<bool>> for MinimumMultiwayCut<SimpleGraph, i32> {
                 let y_iv = i * n + v;
                 // x_e - y_{iu} + y_{iv} >= 0
                 constraints.push(LinearConstraint::ge(
-                    vec![(x_var, 1.0), (y_iu, -1.0), (y_iv, 1.0)],
-                    0.0,
+                    vec![(x_var, 1), (y_iu, -1), (y_iv, 1)],
+                    0,
                 ));
                 // x_e + y_{iu} - y_{iv} >= 0
                 constraints.push(LinearConstraint::ge(
-                    vec![(x_var, 1.0), (y_iu, 1.0), (y_iv, -1.0)],
-                    0.0,
+                    vec![(x_var, 1), (y_iu, 1), (y_iv, -1)],
+                    0,
                 ));
             }
         }
 
         // Objective: minimize sum_e w_e * x_e
-        let objective: Vec<(usize, f64)> = weights
+        let objective: Vec<(usize, i64)> = weights
             .iter()
             .enumerate()
-            .map(|(e_idx, w)| (k * n + e_idx, *w as f64))
+            .map(|(e_idx, &weight)| (k * n + e_idx, weight))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionMMCToILP { target, n, m, k }
+        Ok(ReductionMMCToILP { target, n, m, k })
     }
 }
 
diff --git a/src/rules/minimummultiwaycut_qubo.rs b/src/rules/minimummultiwaycut_qubo.rs
index 610ec7397..8679c2285 100644
--- a/src/rules/minimummultiwaycut_qubo.rs
+++ b/src/rules/minimummultiwaycut_qubo.rs
@@ -20,15 +20,15 @@ use crate::topology::{Graph, SimpleGraph};
 /// Result of reducing MinimumMultiwayCut to QUBO.
 #[derive(Debug, Clone)]
 pub struct ReductionMinimumMultiwayCutToQUBO {
-    target: QUBO<f64>,
+    target: QUBO<i64>,
     num_vertices: usize,
     num_terminals: usize,
     edges: Vec<(usize, usize)>,
 }
 
 impl ReductionResult for ReductionMinimumMultiwayCutToQUBO {
-    type Source = MinimumMultiwayCut<SimpleGraph, i32>;
-    type Target = QUBO<f64>;
+    type Source = MinimumMultiwayCut<SimpleGraph, i64>;
+    type Target = QUBO<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
@@ -36,54 +36,84 @@ impl ReductionResult for ReductionMinimumMultiwayCutToQUBO {
 
     /// Decode one-hot assignment: for each vertex find its terminal, then
     /// for each edge check if endpoints are in different terminals.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let k = self.num_terminals;
-        let n = self.num_vertices;
-
-        // For each vertex, find which terminal position it is assigned to
-        let assignments: Vec<usize> = (0..n)
-            .map(|u| {
-                (0..k)
-                    .find(|&t| target_solution[u * k + t] == 1)
-                    .unwrap_or(0)
-            })
-            .collect();
-
-        // For each edge, output 1 (cut) if endpoints differ, 0 (keep) otherwise
-        self.edges
-            .iter()
-            .map(|&(u, v)| {
-                if assignments[u] != assignments[v] {
-                    1
-                } else {
-                    0
-                }
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let k = self.num_terminals;
+            let n = self.num_vertices;
+
+            // For each vertex, find which terminal position it is assigned to
+            let assignments: Vec<usize> = (0..n)
+                .map(|vertex| {
+                    let mut selected =
+                        (0..k).filter(|&terminal| target_solution[vertex * k + terminal]);
+                    match (selected.next(), selected.next()) {
+                        (Some(terminal), None) => Ok(terminal),
+                        _ => Err(crate::rules::ExtractionError::invalid(format!(
+                            "vertex {vertex} does not have exactly one terminal assignment"
+                        ))),
+                    }
+                })
+                .collect::<crate::rules::ExtractionResult<_>>()?;
+
+            // For each edge, output 1 (cut) if endpoints differ, 0 (keep) otherwise
+            self.edges
+                .iter()
+                .map(|&(u, v)| assignments[u] != assignments[v])
+                .collect()
+        })
     }
 }
 
-#[reduction(overhead = { num_vars = "num_terminals * num_vertices" })]
-impl ReduceTo<QUBO<f64>> for MinimumMultiwayCut<SimpleGraph, i32> {
+#[reduction(transform = exact {
+    num_vars = "num_terminals * num_vertices",
+})]
+impl ReduceTo<QUBO<i64>> for MinimumMultiwayCut<SimpleGraph, i64> {
     type Result = ReductionMinimumMultiwayCutToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let k = self.num_terminals();
         let edges = self.graph().edges();
         let edge_weights = self.edge_weights();
         let terminals = self.terminals();
-        let nq = n * k;
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<
+                MinimumMultiwayCut<SimpleGraph, i64>,
+                QUBO<i64>,
+            >(operation)
+        };
+        let nq = n
+            .checked_mul(k)
+            .ok_or_else(|| overflow("computing the number of QUBO variables"))?;
 
         // Penalty: sum of all edge weights + 1
-        let alpha: f64 = edge_weights.iter().map(|&w| (w as f64).abs()).sum::<f64>() + 1.0;
-
-        let mut matrix = vec![vec![0.0f64; nq]; nq];
+        let alpha = edge_weights.iter().try_fold(0i64, |total, &weight| {
+            total
+                .checked_add(
+                    weight
+                        .checked_abs()
+                        .ok_or_else(|| overflow("taking the absolute value of a cut weight"))?,
+                )
+                .ok_or_else(|| overflow("summing absolute cut weights"))
+        })?;
+        let alpha = alpha
+            .checked_add(1)
+            .ok_or_else(|| overflow("computing the partition penalty"))?;
+
+        let mut matrix = vec![vec![0i64; nq]; nq];
 
         // Helper: add value to upper-triangular position
-        let mut add_upper = |i: usize, j: usize, val: f64| {
+        let mut add_upper = |i: usize, j: usize, val: i64| {
             let (lo, hi) = if i <= j { (i, j) } else { (j, i) };
-            matrix[lo][hi] += val;
+            matrix[lo][hi] = matrix[lo][hi]
+                .checked_add(val)
+                .ok_or_else(|| overflow("adding a multiway-cut QUBO coefficient"))?;
+            Ok::<(), crate::rules::ReductionError>(())
         };
 
         // H_A: one-hot constraint per vertex
@@ -92,12 +122,24 @@ impl ReduceTo<QUBO<f64>> for MinimumMultiwayCut<SimpleGraph, i32> {
         for u in 0..n {
             // Diagonal: -alpha for each terminal position
             for s in 0..k {
-                add_upper(u * k + s, u * k + s, -alpha);
+                add_upper(
+                    u * k + s,
+                    u * k + s,
+                    alpha
+                        .checked_neg()
+                        .ok_or_else(|| overflow("negating the partition penalty"))?,
+                )?;
             }
             // Off-diagonal within same vertex: +2*alpha for each pair
             for s in 0..k {
                 for t in (s + 1)..k {
-                    add_upper(u * k + s, u * k + t, 2.0 * alpha);
+                    add_upper(
+                        u * k + s,
+                        u * k + t,
+                        alpha
+                            .checked_mul(2)
+                            .ok_or_else(|| overflow("doubling the partition penalty"))?,
+                    )?;
                 }
             }
         }
@@ -107,7 +149,7 @@ impl ReduceTo<QUBO<f64>> for MinimumMultiwayCut<SimpleGraph, i32> {
         for (t_pos, &t_vertex) in terminals.iter().enumerate() {
             for s in 0..k {
                 if s != t_pos {
-                    add_upper(t_vertex * k + s, t_vertex * k + s, alpha);
+                    add_upper(t_vertex * k + s, t_vertex * k + s, alpha)?;
                 }
             }
         }
@@ -116,22 +158,27 @@ impl ReduceTo<QUBO<f64>> for MinimumMultiwayCut<SimpleGraph, i32> {
         // For each edge (u,v) with weight w, for each pair of distinct
         // terminal positions s != t: add w to Q[u*k+s, v*k+t]
         for (edge_idx, &(u, v)) in edges.iter().enumerate() {
-            let w = edge_weights[edge_idx] as f64;
+            let w = edge_weights[edge_idx];
             for s in 0..k {
                 for t in 0..k {
                     if s != t {
-                        add_upper(u * k + s, v * k + t, w);
+                        add_upper(u * k + s, v * k + t, w)?;
                     }
                 }
             }
         }
 
-        ReductionMinimumMultiwayCutToQUBO {
-            target: QUBO::from_matrix(matrix),
+        Ok(ReductionMinimumMultiwayCutToQUBO {
+            target: QUBO::from_matrix(matrix).map_err(|message| {
+                crate::rules::ReductionError::construction::<
+                    MinimumMultiwayCut<SimpleGraph, i64>,
+                    QUBO<i64>,
+                >(message)
+            })?,
             num_vertices: n,
             num_terminals: k,
             edges,
-        }
+        })
     }
 }
 
@@ -147,11 +194,14 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             use crate::topology::SimpleGraph;
             let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (1, 3)]);
             let source = MinimumMultiwayCut::new(graph, vec![0, 2, 4], vec![2, 3, 1, 2, 4, 5]);
-            crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
+            crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1, 1, 0],
-                    target_config: vec![1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1],
+                    source_config: serde_json::json!(vec![true, false, false, true, true, false]),
+                    target_config: serde_json::json!(vec![
+                        true, false, false, false, true, false, false, true, false, false, true,
+                        false, false, false, true
+                    ]),
                 },
             )
         },
diff --git a/src/rules/minimumsetcovering_ilp.rs b/src/rules/minimumsetcovering_ilp.rs
index 7befcbaca..6f208be75 100644
--- a/src/rules/minimumsetcovering_ilp.rs
+++ b/src/rules/minimumsetcovering_ilp.rs
@@ -22,7 +22,7 @@ pub struct ReductionSCToILP {
 }
 
 impl ReductionResult for ReductionSCToILP {
-    type Source = MinimumSetCovering<i32>;
+    type Source = MinimumSetCovering<i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
@@ -33,21 +33,29 @@ impl ReductionResult for ReductionSCToILP {
     ///
     /// Since the mapping is 1:1 (each set maps to one binary variable),
     /// the solution extraction is simply copying the configuration.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_sets",
         num_constraints = "universe_size",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MinimumSetCovering<i32> {
+impl ReduceTo<ILP<bool>> for MinimumSetCovering<i64> {
     type Result = ReductionSCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.num_sets();
 
         // Constraints: For each element e, sum_{j: e in set_j} x_j >= 1
@@ -55,29 +63,30 @@ impl ReduceTo<ILP<bool>> for MinimumSetCovering<i32> {
         let constraints: Vec<LinearConstraint> = (0..self.universe_size())
             .map(|element| {
                 // Find all sets containing this element
-                let terms: Vec<(usize, f64)> = self
+                let terms: Vec<(usize, i64)> = self
                     .sets()
                     .iter()
                     .enumerate()
                     .filter(|(_, set)| set.contains(&element))
-                    .map(|(j, _)| (j, 1.0))
+                    .map(|(j, _)| (j, 1))
                     .collect();
 
-                LinearConstraint::ge(terms, 1.0)
+                LinearConstraint::ge(terms, 1)
             })
             .collect();
 
         // Objective: minimize sum of w_i * x_i (weighted sum of selected sets)
-        let objective: Vec<(usize, f64)> = self
+        let objective: Vec<(usize, i64)> = self
             .weights_ref()
             .iter()
             .enumerate()
-            .map(|(i, &w)| (i, w as f64))
+            .map(|(set, &weight)| (set, weight))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionSCToILP { target }
+        Ok(ReductionSCToILP { target })
     }
 }
 
diff --git a/src/rules/minimumsummulticenter_ilp.rs b/src/rules/minimumsummulticenter_ilp.rs
index 976f1a387..bb6f82fd6 100644
--- a/src/rules/minimumsummulticenter_ilp.rs
+++ b/src/rules/minimumsummulticenter_ilp.rs
@@ -34,15 +34,23 @@ pub struct ReductionMSMCToILP {
 }
 
 impl ReductionResult for ReductionMSMCToILP {
-    type Source = MinimumSumMulticenter<SimpleGraph, i32>;
+    type Source = MinimumSumMulticenter<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_vertices]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
@@ -51,13 +59,13 @@ impl ReductionResult for ReductionMSMCToILP {
 /// Returns a vector of length `n`; unreachable vertices remain `None`.
 fn weighted_distances_msmc(
     graph: &SimpleGraph,
-    edge_lengths: &[i32],
+    edge_lengths: &[i64],
     source: usize,
     n: usize,
 ) -> Vec<Option<i64>> {
     let mut adj: Vec<Vec<(usize, i64)>> = vec![Vec::new(); n];
     for (idx, &(u, v)) in graph.edges().iter().enumerate() {
-        let len = i64::from(edge_lengths[idx]);
+        let len = edge_lengths[idx];
         adj[u].push((v, len));
         adj[v].push((u, len));
     }
@@ -110,17 +118,20 @@ fn weighted_distances_msmc(
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_vertices + num_vertices^2",
         num_constraints = "num_vertices^2 + 2 * num_vertices + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for MinimumSumMulticenter<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for MinimumSumMulticenter<SimpleGraph, i64> {
     type Result = ReductionMSMCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
-        let k = self.k();
+        let k = Self::exact_i64(self.k(), "encoding the number of centers")?;
         let vertex_weights = self.vertex_weights();
         let edge_lengths = self.edge_lengths();
 
@@ -138,13 +149,13 @@ impl ReduceTo<ILP<bool>> for MinimumSumMulticenter<SimpleGraph, i32> {
         let mut constraints = Vec::with_capacity(n * n + 2 * n + 1);
 
         // Cardinality constraint: Σ_j x_j = k
-        let center_terms: Vec<(usize, f64)> = (0..n).map(|j| (x_var(j), 1.0)).collect();
-        constraints.push(LinearConstraint::eq(center_terms, k as f64));
+        let center_terms: Vec<(usize, i64)> = (0..n).map(|j| (x_var(j), 1)).collect();
+        constraints.push(LinearConstraint::eq(center_terms, k));
 
         // Assignment constraints: ∀i: Σ_j y_{i,j} = 1
         for i in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|j| (y_var(i, j), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|j| (y_var(i, j), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Assignment link constraints:
@@ -153,34 +164,42 @@ impl ReduceTo<ILP<bool>> for MinimumSumMulticenter<SimpleGraph, i32> {
             for (j, distance) in distances.iter().enumerate() {
                 if distance.is_some() {
                     constraints.push(LinearConstraint::le(
-                        vec![(y_var(i, j), 1.0), (x_var(j), -1.0)],
-                        0.0,
+                        vec![(y_var(i, j), 1), (x_var(j), -1)],
+                        0,
                     ));
                 } else {
-                    constraints.push(LinearConstraint::eq(vec![(y_var(i, j), 1.0)], 0.0));
+                    constraints.push(LinearConstraint::eq(vec![(y_var(i, j), 1)], 0));
                 }
             }
         }
 
         // Objective: Minimize Σ_{i,j} w_i · d(i,j) · y_{i,j}
-        let mut objective: Vec<(usize, f64)> = Vec::new();
+        let mut objective: Vec<(usize, i64)> = Vec::new();
         for (i, &w) in vertex_weights.iter().enumerate() {
-            let w_i = w as f64;
             for (j, distance) in all_dist[i].iter().enumerate() {
                 if let Some(distance) = distance {
-                    let coeff = w_i * *distance as f64;
-                    if coeff != 0.0 {
+                    let weighted_distance = w.checked_mul(*distance).ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<
+                            MinimumSumMulticenter<SimpleGraph, i64>,
+                            ILP<bool>,
+                        >(
+                            "multiplying a vertex weight by a shortest-path distance"
+                        )
+                    })?;
+                    let coeff = weighted_distance;
+                    if coeff != 0 {
                         objective.push((y_var(i, j), coeff));
                     }
                 }
             }
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
-        ReductionMSMCToILP {
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionMSMCToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -193,8 +212,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Optimal center is vertex 1 with total distance 1+0+1 = 2.
             let source = MinimumSumMulticenter::new(
                 SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-                vec![1i32; 3],
-                vec![1i32; 2],
+                vec![1i64; 3],
+                vec![1i64; 2],
                 1,
             );
             crate::example_db::specs::rule_example_via_ilp::<_, bool>(source)
diff --git a/src/rules/minimumtardinesssequencing_ilp.rs b/src/rules/minimumtardinesssequencing_ilp.rs
index f09bdc7f4..e8533153d 100644
--- a/src/rules/minimumtardinesssequencing_ilp.rs
+++ b/src/rules/minimumtardinesssequencing_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from MinimumTardinessSequencing to ILP<bool>.
+//! Reduction from MinimumTardinessSequencing to `ILP<bool>`.
 //!
 //! Position-assignment ILP: binary x_{j,p} placing task j in position p,
 //! with binary tardy indicator u_j. Precedence constraints and a
@@ -7,11 +7,11 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::MinimumTardinessSequencing;
 use crate::reduction;
-use crate::rules::ilp_helpers::{one_hot_decode, permutation_to_lehmer};
+use crate::rules::ilp_helpers::one_hot_decode;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::types::One;
 
-/// Result of reducing MinimumTardinessSequencing<One> to ILP<bool>.
+/// Result of reducing MinimumTardinessSequencing<One> to `ILP<bool>`.
 #[derive(Debug, Clone)]
 pub struct ReductionMTSToILP {
     target: ILP<bool>,
@@ -26,14 +26,21 @@ impl ReductionResult for ReductionMTSToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_tasks;
-        let schedule = one_hot_decode(target_solution, n, n, 0);
-        permutation_to_lehmer(&schedule)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_tasks;
+
+            one_hot_decode(target_solution, n, n, 0)?
+        })
     }
 }
 
-/// Result of reducing MinimumTardinessSequencing<i32> to ILP<bool>.
+/// Result of reducing MinimumTardinessSequencing<i64> to `ILP<bool>`.
 #[derive(Debug, Clone)]
 pub struct ReductionMTSWeightedToILP {
     target: ILP<bool>,
@@ -41,23 +48,31 @@ pub struct ReductionMTSWeightedToILP {
 }
 
 impl ReductionResult for ReductionMTSWeightedToILP {
-    type Source = MinimumTardinessSequencing<i32>;
+    type Source = MinimumTardinessSequencing<i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_tasks;
-        let schedule = one_hot_decode(target_solution, n, n, 0);
-        permutation_to_lehmer(&schedule)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_tasks;
+
+            one_hot_decode(target_solution, n, n, 0)?
+        })
     }
 }
 
 /// Build task assignment + position filling + precedence constraints (shared).
 fn build_common_constraints(
     n: usize,
+    positions: &[i64],
     precedences: &[(usize, usize)],
     x_var: impl Fn(usize, usize) -> usize,
 ) -> Vec<LinearConstraint> {
@@ -65,108 +80,142 @@ fn build_common_constraints(
 
     // 1. Each task assigned to exactly one position
     for j in 0..n {
-        let terms: Vec<(usize, f64)> = (0..n).map(|p| (x_var(j, p), 1.0)).collect();
-        constraints.push(LinearConstraint::eq(terms, 1.0));
+        let terms: Vec<(usize, i64)> = (0..n).map(|p| (x_var(j, p), 1)).collect();
+        constraints.push(LinearConstraint::eq(terms, 1));
     }
 
     // 2. Each position has exactly one task
     for p in 0..n {
-        let terms: Vec<(usize, f64)> = (0..n).map(|j| (x_var(j, p), 1.0)).collect();
-        constraints.push(LinearConstraint::eq(terms, 1.0));
+        let terms: Vec<(usize, i64)> = (0..n).map(|j| (x_var(j, p), 1)).collect();
+        constraints.push(LinearConstraint::eq(terms, 1));
     }
 
     // 3. Precedence constraints
     for &(i, j) in precedences {
-        let mut terms: Vec<(usize, f64)> = Vec::new();
-        for p in 0..n {
-            terms.push((x_var(j, p), p as f64));
-            terms.push((x_var(i, p), -(p as f64)));
+        let mut terms: Vec<(usize, i64)> = Vec::new();
+        for (p, &position) in positions.iter().enumerate() {
+            terms.push((x_var(j, p), position));
+            terms.push((x_var(i, p), -position));
         }
-        constraints.push(LinearConstraint::ge(terms, 1.0));
+        constraints.push(LinearConstraint::ge(terms, 1));
     }
 
     constraints
 }
 
 // Unit-length variant
-#[reduction(overhead = {
-    num_vars = "num_tasks * num_tasks + num_tasks",
-    num_constraints = "2 * num_tasks + num_precedences + num_tasks",
-})]
+#[reduction(
+    transform = exact {
+        num_vars = "num_tasks * num_tasks + num_tasks",
+        num_constraints = "2 * num_tasks + num_precedences + num_tasks",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<ILP<bool>> for MinimumTardinessSequencing<One> {
     type Result = ReductionMTSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
         let num_x_vars = n * n;
         let num_vars = num_x_vars + n;
-        let big_m = n as f64;
+        let positions = (0..n)
+            .map(|position| Self::exact_i64(position, "representing a task position in ILP rows"))
+            .collect::<Result<Vec<_>, _>>()?;
+        let big_m = Self::exact_i64(n, "representing the number of tasks in ILP rows")?;
 
         let x_var = |j: usize, p: usize| -> usize { j * n + p };
         let u_var = |j: usize| -> usize { num_x_vars + j };
 
-        let mut constraints = build_common_constraints(n, self.precedences(), x_var);
+        let mut constraints = build_common_constraints(n, &positions, self.precedences(), x_var);
 
         // Tardy indicator (unit length: completion = p+1)
         for j in 0..n {
-            let mut terms: Vec<(usize, f64)> =
-                (0..n).map(|p| (x_var(j, p), (p + 1) as f64)).collect();
+            let mut terms: Vec<(usize, i64)> =
+                (0..n).map(|p| (x_var(j, p), positions[p] + 1)).collect();
             terms.push((u_var(j), -big_m));
-            constraints.push(LinearConstraint::le(terms, self.deadlines()[j] as f64));
+            let deadline = self.deadlines()[j];
+            constraints.push(LinearConstraint::le(terms, deadline));
         }
 
-        let objective: Vec<(usize, f64)> = (0..n).map(|j| (u_var(j), 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..n).map(|j| (u_var(j), 1)).collect();
 
-        ReductionMTSToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize),
+        Ok(ReductionMTSToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
-        }
+        })
     }
 }
 
 // Arbitrary-length variant
-#[reduction(overhead = {
-    num_vars = "num_tasks * num_tasks + num_tasks",
-    num_constraints = "2 * num_tasks + num_precedences + num_tasks * num_tasks",
-})]
-impl ReduceTo<ILP<bool>> for MinimumTardinessSequencing<i32> {
+#[reduction(
+    transform = exact {
+        num_vars = "num_tasks * num_tasks + num_tasks",
+        num_constraints = "2 * num_tasks + num_precedences + num_tasks * num_tasks",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<bool>> for MinimumTardinessSequencing<i64> {
     type Result = ReductionMTSWeightedToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
         let num_x_vars = n * n;
         let num_vars = num_x_vars + n;
-        let total_length: i32 = self.lengths().iter().copied().sum();
-        let big_m = total_length as f64;
+        let total_length = self.lengths().iter().try_fold(0_i64, |total, &length| {
+            total.checked_add(length).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    MinimumTardinessSequencing<i64>,
+                    ILP<bool>,
+                >("summing task lengths")
+            })
+        })?;
+        let big_m = total_length;
+        let positions = (0..n)
+            .map(|position| Self::exact_i64(position, "representing a task position in ILP rows"))
+            .collect::<Result<Vec<_>, _>>()?;
 
         let x_var = |j: usize, p: usize| -> usize { j * n + p };
         let u_var = |j: usize| -> usize { num_x_vars + j };
 
-        let mut constraints = build_common_constraints(n, self.precedences(), x_var);
+        let mut constraints = build_common_constraints(n, &positions, self.precedences(), x_var);
 
         // Tardy indicator for arbitrary lengths.
         let lengths = self.lengths();
         for j in 0..n {
             for p in 0..n {
-                let mut terms: Vec<(usize, f64)> = Vec::new();
+                let mut terms: Vec<(usize, i64)> = Vec::new();
                 terms.push((x_var(j, p), big_m));
                 for pp in 0..p {
                     for (jj, &len) in lengths.iter().enumerate() {
-                        terms.push((x_var(jj, pp), len as f64));
+                        terms.push((x_var(jj, pp), len));
                     }
                 }
                 terms.push((u_var(j), -big_m));
-                let rhs = self.deadlines()[j] as f64 - lengths[j] as f64 + big_m;
+                let rhs = self.deadlines()[j]
+                    .checked_sub(lengths[j])
+                    .and_then(|value| value.checked_add(total_length))
+                    .ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<
+                            MinimumTardinessSequencing<i64>,
+                            ILP<bool>,
+                        >("computing a tardiness constraint bound")
+                    })?;
                 constraints.push(LinearConstraint::le(terms, rhs));
             }
         }
 
-        let objective: Vec<(usize, f64)> = (0..n).map(|j| (u_var(j), 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..n).map(|j| (u_var(j), 1)).collect();
 
-        ReductionMTSWeightedToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize),
+        Ok(ReductionMTSWeightedToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
-        }
+        })
     }
 }
 
@@ -183,7 +232,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         crate::example_db::specs::RuleExampleSpec {
             id: "minimumtardinesssequencing_weighted_to_ilp",
             build: || {
-                let source = MinimumTardinessSequencing::<i32>::with_lengths(
+                let source = MinimumTardinessSequencing::<i64>::with_lengths(
                     vec![2, 1, 3],
                     vec![3, 4, 5],
                     vec![(0, 2)],
diff --git a/src/rules/minimumvertexcover_comparativecontainment.rs b/src/rules/minimumvertexcover_comparativecontainment.rs
index 64344c219..4e08fc68a 100644
--- a/src/rules/minimumvertexcover_comparativecontainment.rs
+++ b/src/rules/minimumvertexcover_comparativecontainment.rs
@@ -1,22 +1,13 @@
-//! Reduction from Decision Minimum Vertex Cover to Comparative Containment.
+//! Signed-weight decision vertex cover to comparative containment.
 //!
-//! Implements the Plaisted (1976) construction (Garey & Johnson SP10): given a
-//! graph `G = (V, E)` and a bound `K`, build a Comparative Containment instance
-//! over universe `X = V` with two weighted set families `R` and `S` such that a
-//! subset `Y ⊆ X` satisfies the containment inequality iff `Y` is a vertex
-//! cover of `G` of size at most `K`.
-//!
-//! - For each vertex `v`, add `R_v = V \ {v}` with weight `1`. The total
-//!   R-weight equals `n - |Y|`.
-//! - For each edge `e = {u, v}`, add `S_e = V \ {u, v}` with weight `n + 1`.
-//!   Each uncovered edge contributes a penalty larger than the maximum possible
-//!   R-weight, so any feasible `Y` must cover every edge.
-//! - One budget set `S_0 = V` with weight `n - K`. The containment inequality
-//!   becomes `K - |Y| ≥ (n + 1) · (# uncovered edges)`.
-//!
-//! Source: `Decision<MinimumVertexCover<SimpleGraph, i32>>` with unit weights.
-//! See `decisionminimumvertexcover_hamiltoniancircuit.rs` for the analogous
-//! unit-weight assertion pattern.
+//! Extends the complement-set construction cited in Garey--Johnson SP10.
+//! Let W = sum w_v, U = sum max(w_v,0), B = min(K,U), and
+//! P = 1 + sum |w_v|. Encode the signed containment expression
+//! B - W + sum w_v [Y subset V\{v}] - P sum_e [Y subset V\e].
+//! Positive terms go to R, negative terms to S, and zero terms are omitted.
+//! Its value is B - w(Y) - P * uncovered(Y), so it is nonnegative exactly
+//! for vertex covers meeting the bound. Extraction is the identity.
+//! Stored weights and family totals must fit the repository's i64 contract.
 
 use crate::models::decision::Decision;
 use crate::models::graph::MinimumVertexCover;
@@ -25,136 +16,119 @@ use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
 
-/// Result of reducing `Decision<MinimumVertexCover<SimpleGraph, i32>>` to
-/// `ComparativeContainment<i32>`.
+/// Identity witness map for the signed-weight containment construction.
 #[derive(Debug, Clone)]
 pub struct ReductionDecisionMVCToComparativeContainment {
-    target: ComparativeContainment<i32>,
-    num_source_vertices: usize,
-    /// If `Some`, the bound makes every vertex subset trivially feasible
-    /// (`K ≥ n`); the reduction emits an empty target instance and any
-    /// extracted source configuration is forced to be a YES instance.
-    trivial_yes: Option<Vec<usize>>,
+    target: ComparativeContainment<i64>,
 }
 
 impl ReductionResult for ReductionDecisionMVCToComparativeContainment {
-    type Source = Decision<MinimumVertexCover<SimpleGraph, i32>>;
-    type Target = ComparativeContainment<i32>;
+    type Source = Decision<MinimumVertexCover<SimpleGraph, i64>>;
+    type Target = ComparativeContainment<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        if let Some(witness) = &self.trivial_yes {
-            return witness.clone();
-        }
-        let mut cover = vec![0; self.num_source_vertices];
-        for (vertex, &selected) in target_solution
-            .iter()
-            .take(self.num_source_vertices)
-            .enumerate()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        if !crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?
+            .0
         {
-            cover[vertex] = selected;
+            return Err(crate::rules::ExtractionError::invalid(
+                "containment inequality is not satisfied",
+            ));
         }
-        cover
+        Ok(target_solution.clone())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         universe_size = "num_vertices",
-        num_r_sets = "num_vertices",
-        num_s_sets = "num_edges + 1",
+        num_r_sets = "num_vertices + 1",
+        num_s_sets = "num_vertices + num_edges + 1",
     }
 )]
-impl ReduceTo<ComparativeContainment<i32>> for Decision<MinimumVertexCover<SimpleGraph, i32>> {
+impl ReduceTo<ComparativeContainment<i64>> for Decision<MinimumVertexCover<SimpleGraph, i64>> {
     type Result = ReductionDecisionMVCToComparativeContainment;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<Self, ComparativeContainment<i64>>(
+                operation,
+            )
+        };
         let weights = self.inner().weights();
-        assert!(
-            weights.iter().all(|&weight| weight == 1),
-            "Plaisted 1976 reduction requires unit vertex weights"
-        );
-
-        let num_vertices = self.inner().graph().num_vertices();
-        let raw_bound = *self.bound();
-
-        // Trivially NO corner case: a negative bound cannot be met by any
-        // (nonnegative) cover size. Emit an unsatisfiable target: universe of
-        // size 1 with a single S-set {0} and no R-sets, so the R-weight is
-        // always 0 < 1 = S-weight regardless of Y.
-        if raw_bound < 0 {
-            let target = ComparativeContainment::with_weights(
-                1,
-                Vec::new(),
-                vec![vec![0]],
-                Vec::<i32>::new(),
-                vec![1i32],
-            );
-            return ReductionDecisionMVCToComparativeContainment {
-                target,
-                num_source_vertices: num_vertices,
-                trivial_yes: None,
-            };
+        let n = self.inner().graph().num_vertices();
+        let mut positive_total = 0i64;
+        let mut negative_total = 0i64;
+        for &weight in weights {
+            if weight > 0 {
+                positive_total = positive_total
+                    .checked_add(weight)
+                    .ok_or_else(|| overflow("summing positive vertex weights"))?;
+            } else {
+                negative_total = negative_total
+                    .checked_add(weight)
+                    .ok_or_else(|| overflow("summing negative vertex weights"))?;
+            }
         }
-
-        // Trivial YES corner case: when K >= n, every vertex subset of size at
-        // most n is a feasible cover (in particular the all-ones configuration
-        // covers every edge), so the answer is YES regardless of the graph.
-        // Emit an empty target instance (universe size 0, no R/S sets); its
-        // unique configuration is trivially satisfying.
-        if raw_bound >= num_vertices as i32 {
-            let target = ComparativeContainment::with_weights(
-                0,
-                Vec::new(),
-                Vec::new(),
-                Vec::<i32>::new(),
-                Vec::<i32>::new(),
-            );
-            // The all-ones configuration is always a vertex cover with size
-            // n <= K.
-            let witness = vec![1; num_vertices];
-            return ReductionDecisionMVCToComparativeContainment {
-                target,
-                num_source_vertices: num_vertices,
-                trivial_yes: Some(witness),
-            };
+        // All subset sums lie in [negative_total, positive_total].
+        // Opposite-sign operands cannot overflow.
+        let total = positive_total + negative_total;
+        let bound = (*self.bound()).min(positive_total);
+        let constant = bound
+            .checked_sub(total)
+            .ok_or_else(|| overflow("computing the containment budget term"))?;
+        let penalty = positive_total
+            .checked_sub(negative_total)
+            .and_then(|span| span.checked_add(1))
+            .ok_or_else(|| overflow("computing a strict uncovered-edge penalty"))?;
+
+        let mut r_sets = Vec::new();
+        let mut r_weights = Vec::new();
+        let mut s_sets = Vec::new();
+        let mut s_weights = Vec::new();
+        // A signed term is represented on the corresponding side of R >= S.
+        for (set, coefficient) in weights
+            .iter()
+            .enumerate()
+            .filter(|(_, w)| **w != 0)
+            .map(|(v, &w)| (complement_singleton(n, v), w))
+            .chain((constant != 0).then(|| ((0..n).collect(), constant)))
+        {
+            if coefficient > 0 {
+                r_sets.push(set);
+                r_weights.push(coefficient);
+            } else if coefficient < 0 {
+                s_sets.push(set);
+                s_weights.push(
+                    coefficient
+                        .checked_neg()
+                        .ok_or_else(|| overflow("negating a containment coefficient"))?,
+                );
+            }
         }
-
-        let k = self.k();
-        let edges = self.inner().graph().edges();
-        let n = num_vertices;
-
-        // R sets: R_v = V \ {v} for each vertex v, weight 1.
-        let r_sets: Vec<Vec<usize>> = (0..n).map(|v| complement_singleton(n, v)).collect();
-        let r_weights: Vec<i32> = vec![1; n];
-
-        // S sets: one per edge plus a single budget set.
-        let mut s_sets: Vec<Vec<usize>> = Vec::with_capacity(edges.len() + 1);
-        let mut s_weights: Vec<i32> = Vec::with_capacity(edges.len() + 1);
-
-        let edge_weight =
-            i32::try_from(n + 1).expect("Plaisted edge-penalty weight (n + 1) must fit in i32");
-        for &(u, v) in &edges {
+        for (u, v) in self.inner().graph().edges() {
             s_sets.push(complement_pair(n, u, v));
-            s_weights.push(edge_weight);
+            s_weights.push(penalty);
         }
-        // Budget set S_0 = V with weight n - K. Since 0 <= K < n here, this is
-        // a positive integer.
-        let budget_weight =
-            i32::try_from(n - k).expect("Plaisted budget weight (n - K) must fit in i32");
-        s_sets.push((0..n).collect());
-        s_weights.push(budget_weight);
-
-        let target = ComparativeContainment::with_weights(n, r_sets, s_sets, r_weights, s_weights);
-
-        ReductionDecisionMVCToComparativeContainment {
-            target,
-            num_source_vertices: n,
-            trivial_yes: None,
+        // The empty subset is contained in every set. Checking both full sums
+        // ensures every target evaluation stays in i64, including NO witnesses.
+        for family in [&r_weights, &s_weights] {
+            family
+                .iter()
+                .try_fold(0i64, |sum, &weight| sum.checked_add(weight))
+                .ok_or_else(|| overflow("summing a containment weight family"))?;
         }
+        let target = ComparativeContainment::with_weights(n, r_sets, s_sets, r_weights, s_weights)
+            .map_err(
+                crate::rules::ReductionError::construction::<Self, ComparativeContainment<i64>>,
+            )?;
+        Ok(ReductionDecisionMVCToComparativeContainment { target })
     }
 }
 
@@ -176,14 +150,14 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Path P_4: 0-1-2-3, bound K=2. Minimum cover {1,2} has size 2.
             let inner = MinimumVertexCover::new(
                 SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-                vec![1i32; 4],
+                vec![1i64; 4],
             );
             let source = Decision::new(inner, 2);
-            crate::example_db::specs::rule_example_with_witness::<_, ComparativeContainment<i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, ComparativeContainment<i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0],
-                    target_config: vec![0, 1, 1, 0],
+                    source_config: serde_json::json!(vec![false, true, true, false]),
+                    target_config: serde_json::json!(vec![false, true, true, false]),
                 },
             )
         },
diff --git a/src/rules/minimumvertexcover_ensemblecomputation.rs b/src/rules/minimumvertexcover_ensemblecomputation.rs
index 158fc65dc..710badf1f 100644
--- a/src/rules/minimumvertexcover_ensemblecomputation.rs
+++ b/src/rules/minimumvertexcover_ensemblecomputation.rs
@@ -3,14 +3,14 @@
 //! Given a graph G = (V, E), construct an EnsembleComputation instance where:
 //! - Universe A = V ∪ {a₀} (fresh element a₀ at index |V|)
 //! - Collection C = {{a₀, u, v} : {u,v} ∈ E}
-//! - Budget = |V| + |E| (search space bound; the optimal value encodes K*)
+//! - Budget = max(1, |V| + |E|) (positive search-space bound)
 //!
-//! The minimum sequence length is K* + |E|, where K* is the minimum vertex
+//! For loopless simple graphs, the minimum sequence length is K* + |E|, where K* is the minimum vertex
 //! cover size. This follows from the Garey & Johnson proof (PO9): each cover
 //! vertex contributes one {a₀} ∪ {v} operation, and each edge contributes
 //! one {u} ∪ z_k operation.
 //!
-//! Reference: Garey & Johnson, *Computers and Intractability*, Appendix Problem PO9.
+//! Reference: Garey & Johnson, *Computers and Intractability*, Theorem 3.6, pp. 66–68 (also Appendix PO9).
 
 use crate::models::graph::MinimumVertexCover;
 use crate::models::misc::EnsembleComputation;
@@ -35,73 +35,89 @@ impl ReductionResult for ReductionVCToEC {
         &self.target
     }
 
-    /// Extract a vertex cover from an EnsembleComputation witness.
-    ///
-    /// The GJ proof shows that any minimum-length sequence can be normalized
-    /// so that only two forms of operations appear:
-    /// - z_i = {a₀} ∪ {v}  — vertex v is in the cover
-    /// - z_j = {u} ∪ z_k   — edge {u, v_r} is covered by v_r
-    ///
-    /// We collect all vertices that appear as singleton operands (index < |V|)
-    /// in the meaningful steps only (before all required subsets are covered).
-    /// Padding steps beyond the coverage point are ignored.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        use crate::traits::Problem;
-        use crate::types::Min;
-
-        let meaningful_steps = match self.target.evaluate(target_solution) {
-            Min(Some(n)) => n,
-            _ => return vec![0; self.num_vertices],
+    /// Extract one vertex per pair-producing operation in the evaluated prefix.
+    /// Every required triple uses an earlier pair. The chosen endpoint covers
+    /// its edge. An L-step program yields at most L minus the number of
+    /// distinct required triples; loops instead require endpoint pairs.
+    /// This applies to arbitrary programs, without a normal-form assumption.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        let crate::types::Min(Some(length)) = value else {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target configuration does not encode a valid ensemble computation",
+            ));
         };
-        let mut cover = vec![0usize; self.num_vertices];
-
-        for step in 0..meaningful_steps {
-            let left = target_solution[2 * step];
-            let right = target_solution[2 * step + 1];
-
-            if left < self.num_vertices {
-                cover[left] = 1;
-            }
-            if right < self.num_vertices {
-                cover[right] = 1;
+        let meaningful_steps = usize::try_from(length).map_err(|_| {
+            crate::rules::ExtractionError::invalid(
+                "ensemble operation count cannot be represented as usize",
+            )
+        })?;
+        let mut cover = vec![false; self.num_vertices];
+        let universe_size = self.target.universe_size();
+        for &[left, right] in target_solution
+            .as_chunks::<2>()
+            .0
+            .iter()
+            .take(meaningful_steps)
+        {
+            if left < universe_size && right < universe_size {
+                // Only two singleton operands can produce a two-element set.
+                // The fresh atom is largest, so min selects the original
+                // vertex in {a0,v}, or an endpoint of an edge-pair {u,v}.
+                cover[left.min(right)] = true;
             }
         }
-
-        cover
+        Ok(cover)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         universe_size = "num_vertices + 1",
         num_subsets = "num_edges",
+        budget = "num_vertices + num_edges + 1",
     }
 )]
 impl ReduceTo<EnsembleComputation> for MinimumVertexCover<SimpleGraph, One> {
     type Result = ReductionVCToEC;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vertices = self.graph().num_vertices();
         let edges = self.graph().edges();
         let num_edges = edges.len();
         let a0 = num_vertices; // fresh element index
 
         // Universe A = V ∪ {a₀}, size = |V| + 1
-        let universe_size = num_vertices + 1;
+        let overflow = || {
+            crate::rules::ReductionError::integer_overflow::<Self, EnsembleComputation>(
+                "computing ensemble universe, budget, or operand dimensions",
+            )
+        };
+        let universe_size = num_vertices.checked_add(1).ok_or_else(overflow)?;
 
         // Collection C: for each edge {u, v}, add subset {a₀, u, v}
         let subsets: Vec<Vec<usize>> = edges.iter().map(|&(u, v)| vec![a0, u, v]).collect();
 
         // Budget bounds the search space; the optimal sequence length
         // is K* + |E| where K* is the minimum vertex cover size.
-        let budget = num_vertices + num_edges;
+        let budget = num_vertices
+            .checked_add(num_edges)
+            .ok_or_else(overflow)?
+            .max(1);
+        universe_size.checked_add(budget).ok_or_else(overflow)?;
+        budget.checked_mul(2).ok_or_else(overflow)?;
 
-        let target = EnsembleComputation::new(universe_size, subsets, budget);
+        let target = EnsembleComputation::try_new(universe_size, subsets, budget)
+            .map_err(crate::rules::ReductionError::construction::<Self, EnsembleComputation>)?;
 
-        ReductionVCToEC {
+        Ok(ReductionVCToEC {
             target,
             num_vertices,
-        }
+        })
     }
 }
 
@@ -128,17 +144,17 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 1, 3, // step 1: {1} ∪ z₀
                 2, 1, // step 2: padding
             ];
-            // Extraction picks up vertices 0 (step 0) and 1 (step 1) from the
-            // 2 meaningful steps. Step 2 is padding and is ignored.
-            // Cover {0,1} is valid (though not minimum — the optimal witness
-            // is found by BruteForce, giving cover {0} or {1}).
-            let source_config = vec![1, 1];
+            // Only step 0 produces a pair; step 1 produces the required
+            // triple, and step 2 is padding. Extraction returns minimum {0}.
+            let source_config = vec![true, false];
 
             crate::example_db::specs::rule_example_with_witness::<_, EnsembleComputation>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/minimumvertexcover_longestcommonsubsequence.rs b/src/rules/minimumvertexcover_longestcommonsubsequence.rs
index 0c99aa568..e2f0a23a8 100644
--- a/src/rules/minimumvertexcover_longestcommonsubsequence.rs
+++ b/src/rules/minimumvertexcover_longestcommonsubsequence.rs
@@ -21,30 +21,40 @@ impl ReductionResult for ReductionVCToLCS {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let mut cover = vec![1; self.num_vertices];
-        for &symbol in target_solution {
-            if symbol >= self.num_vertices {
-                break;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let mut cover = vec![true; self.num_vertices];
+            for &symbol in target_solution {
+                let Some(symbol) = symbol else { break };
+                cover[symbol] = false;
             }
-            cover[symbol] = 0;
-        }
-        cover
+            cover
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         alphabet_size = "num_vertices",
         num_strings = "num_edges + 1",
         max_length = "num_vertices",
         total_length = "num_vertices + 2 * num_edges * num_vertices - 2 * num_edges",
+    },
+    unavailable = {
+        cross_frequency_product = "the exact target parameter is not represented by this reduction's symbolic transform",
+        num_transitions = "the exact target parameter is not represented by this reduction's symbolic transform",
+        sum_triangular_lengths = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<LongestCommonSubsequence> for MinimumVertexCover<SimpleGraph, One> {
     type Result = ReductionVCToLCS;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vertices = self.graph().num_vertices();
         let mut strings = Vec::with_capacity(self.graph().num_edges() + 1);
         strings.push((0..num_vertices).collect());
@@ -63,10 +73,10 @@ impl ReduceTo<LongestCommonSubsequence> for MinimumVertexCover<SimpleGraph, One>
         }
 
         let target = LongestCommonSubsequence::new(num_vertices, strings);
-        ReductionVCToLCS {
+        Ok(ReductionVCToLCS {
             target,
             num_vertices,
-        }
+        })
     }
 }
 
@@ -90,8 +100,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, LongestCommonSubsequence>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0],
-                    target_config: vec![0, 3, 4, 4],
+                    source_config: serde_json::json!(vec![false, true, true, false]),
+                    target_config: serde_json::json!(vec![Some(0), Some(3), None, None]),
                 },
             )
         },
diff --git a/src/rules/minimumvertexcover_maximumindependentset.rs b/src/rules/minimumvertexcover_maximumindependentset.rs
index 85a650286..5c43127d7 100644
--- a/src/rules/minimumvertexcover_maximumindependentset.rs
+++ b/src/rules/minimumvertexcover_maximumindependentset.rs
@@ -27,26 +27,31 @@ where
 
     /// Solution extraction: complement the configuration.
     /// If v is in the independent set (1), it's NOT in the vertex cover (0).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.iter().map(|&x| 1 - x).collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&x| !x).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_edges",
     }
 )]
-impl ReduceTo<MinimumVertexCover<SimpleGraph, i32>> for MaximumIndependentSet<SimpleGraph, i32> {
-    type Result = ReductionISToVC<i32>;
+impl ReduceTo<MinimumVertexCover<SimpleGraph, i64>> for MaximumIndependentSet<SimpleGraph, i64> {
+    type Result = ReductionISToVC<i64>;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let target = MinimumVertexCover::new(
             SimpleGraph::new(self.graph().num_vertices(), self.graph().edges()),
             self.weights().to_vec(),
         );
-        ReductionISToVC { target }
+        Ok(ReductionISToVC { target })
     }
 }
 
@@ -68,26 +73,31 @@ where
     }
 
     /// Solution extraction: complement the configuration.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.iter().map(|&x| 1 - x).collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&x| !x).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_edges",
     }
 )]
-impl ReduceTo<MaximumIndependentSet<SimpleGraph, i32>> for MinimumVertexCover<SimpleGraph, i32> {
-    type Result = ReductionVCToIS<i32>;
+impl ReduceTo<MaximumIndependentSet<SimpleGraph, i64>> for MinimumVertexCover<SimpleGraph, i64> {
+    type Result = ReductionVCToIS<i64>;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let target = MaximumIndependentSet::new(
             SimpleGraph::new(self.graph().num_vertices(), self.graph().edges()),
             self.weights().to_vec(),
         );
-        ReductionVCToIS { target }
+        Ok(ReductionVCToIS { target })
     }
 }
 
@@ -95,14 +105,14 @@ impl ReduceTo<MaximumIndependentSet<SimpleGraph, i32>> for MinimumVertexCover<Si
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
     use crate::export::SolutionPair;
 
-    fn vc_petersen() -> MinimumVertexCover<SimpleGraph, i32> {
+    fn vc_petersen() -> MinimumVertexCover<SimpleGraph, i64> {
         let (n, edges) = crate::topology::small_graphs::petersen();
-        MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i32; 10])
+        MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i64; 10])
     }
 
-    fn mis_petersen() -> MaximumIndependentSet<SimpleGraph, i32> {
+    fn mis_petersen() -> MaximumIndependentSet<SimpleGraph, i64> {
         let (n, edges) = crate::topology::small_graphs::petersen();
-        MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i32; 10])
+        MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i64; 10])
     }
 
     vec![
@@ -111,12 +121,16 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             build: || {
                 crate::example_db::specs::rule_example_with_witness::<
                     _,
-                    MinimumVertexCover<SimpleGraph, i32>,
+                    MinimumVertexCover<SimpleGraph, i64>,
                 >(
                     mis_petersen(),
                     SolutionPair {
-                        source_config: vec![1, 0, 0, 1, 0, 0, 1, 1, 0, 0],
-                        target_config: vec![0, 1, 1, 0, 1, 1, 0, 0, 1, 1],
+                        source_config: serde_json::json!(vec![
+                            true, false, false, true, false, false, true, true, false, false
+                        ]),
+                        target_config: serde_json::json!(vec![
+                            false, true, true, false, true, true, false, false, true, true
+                        ]),
                     },
                 )
             },
@@ -126,12 +140,16 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             build: || {
                 crate::example_db::specs::rule_example_with_witness::<
                     _,
-                    MaximumIndependentSet<SimpleGraph, i32>,
+                    MaximumIndependentSet<SimpleGraph, i64>,
                 >(
                     vc_petersen(),
                     SolutionPair {
-                        source_config: vec![0, 1, 1, 0, 1, 1, 0, 0, 1, 1],
-                        target_config: vec![1, 0, 0, 1, 0, 0, 1, 1, 0, 0],
+                        source_config: serde_json::json!(vec![
+                            false, true, true, false, true, true, false, false, true, true
+                        ]),
+                        target_config: serde_json::json!(vec![
+                            true, false, false, true, false, false, true, true, false, false
+                        ]),
                     },
                 )
             },
diff --git a/src/rules/minimumvertexcover_minimumfeedbackarcset.rs b/src/rules/minimumvertexcover_minimumfeedbackarcset.rs
index b616f2b77..ef8f39d10 100644
--- a/src/rules/minimumvertexcover_minimumfeedbackarcset.rs
+++ b/src/rules/minimumvertexcover_minimumfeedbackarcset.rs
@@ -16,14 +16,14 @@ use crate::topology::{DirectedGraph, Graph, SimpleGraph};
 /// Result of reducing MinimumVertexCover to MinimumFeedbackArcSet.
 #[derive(Debug, Clone)]
 pub struct ReductionVCToFAS {
-    target: MinimumFeedbackArcSet<i32>,
+    target: MinimumFeedbackArcSet<i64>,
     /// Number of vertices in the source graph (= number of internal arcs).
     num_source_vertices: usize,
 }
 
 impl ReductionResult for ReductionVCToFAS {
-    type Source = MinimumVertexCover<SimpleGraph, i32>;
-    type Target = MinimumFeedbackArcSet<i32>;
+    type Source = MinimumVertexCover<SimpleGraph, i64>;
+    type Target = MinimumFeedbackArcSet<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
@@ -31,21 +31,26 @@ impl ReductionResult for ReductionVCToFAS {
 
     /// Extract solution: internal arcs are at positions 0..n in the FAS config.
     /// If internal arc i is in the FAS (config[i] = 1), vertex i is in the cover.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_source_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_source_vertices].to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "2 * num_vertices",
         num_arcs = "num_vertices + 2 * num_edges",
     }
 )]
-impl ReduceTo<MinimumFeedbackArcSet<i32>> for MinimumVertexCover<SimpleGraph, i32> {
+impl ReduceTo<MinimumFeedbackArcSet<i64>> for MinimumVertexCover<SimpleGraph, i64> {
     type Result = ReductionVCToFAS;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let edges = self.graph().edges();
 
@@ -53,10 +58,20 @@ impl ReduceTo<MinimumFeedbackArcSet<i32>> for MinimumVertexCover<SimpleGraph, i3
         // Internal arcs: (v^in → v^out) for each vertex v, with weight w(v)
         // Crossing arcs: for each edge {u,v}, add (u^out → v^in) and (v^out → u^in) with weight M
 
-        let weight_sum: i32 = self.weights().iter().sum::<i32>();
-        let big_m: i32 = weight_sum
-            .checked_add(1)
-            .expect("penalty M = 1 + sum(weights) overflows i32");
+        let weight_sum = self.weights().iter().try_fold(0i64, |sum, &weight| {
+            sum.checked_add(weight).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    MinimumVertexCover<SimpleGraph, i64>,
+                    MinimumFeedbackArcSet<i64>,
+                >("summing source vertex weights")
+            })
+        })?;
+        let big_m = weight_sum.checked_add(1).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                MinimumVertexCover<SimpleGraph, i64>,
+                MinimumFeedbackArcSet<i64>,
+            >("computing the crossing-arc penalty")
+        })?;
 
         let mut arcs = Vec::with_capacity(n + 2 * edges.len());
         let mut weights = Vec::with_capacity(n + 2 * edges.len());
@@ -78,10 +93,10 @@ impl ReduceTo<MinimumFeedbackArcSet<i32>> for MinimumVertexCover<SimpleGraph, i3
         let graph = DirectedGraph::new(2 * n, arcs);
         let target = MinimumFeedbackArcSet::new(graph, weights);
 
-        ReductionVCToFAS {
+        Ok(ReductionVCToFAS {
             target,
             num_source_vertices: n,
-        }
+        })
     }
 }
 
@@ -97,21 +112,23 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // MVC optimal = 2 vertices (e.g., {0, 1})
             let source = MinimumVertexCover::new(
                 SimpleGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]),
-                vec![1i32; 3],
+                vec![1i64; 3],
             );
-            let reduction = ReduceTo::<MinimumFeedbackArcSet<i32>>::reduce_to(&source);
+            let reduction = ReduceTo::<MinimumFeedbackArcSet<i64>>::reduce_to(&source)
+                .expect("reduction should succeed");
             let target = reduction.target_problem();
 
             let target_witness = BruteForce::new()
-                .find_witness(target)
+                .solve(target)
+                .expect("target evaluation should succeed")
                 .expect("target should have an optimum");
-            let source_witness = reduction.extract_solution(&target_witness);
+            let source_witness = reduction.extract_solution(&target_witness).unwrap();
 
-            crate::example_db::specs::rule_example_with_witness::<_, MinimumFeedbackArcSet<i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, MinimumFeedbackArcSet<i64>>(
                 source,
                 SolutionPair {
-                    source_config: source_witness,
-                    target_config: target_witness,
+                    source_config: serde_json::json!(source_witness),
+                    target_config: serde_json::json!(target_witness),
                 },
             )
         },
diff --git a/src/rules/minimumvertexcover_minimumfeedbackvertexset.rs b/src/rules/minimumvertexcover_minimumfeedbackvertexset.rs
index 7f984aa67..d5ed67e8a 100644
--- a/src/rules/minimumvertexcover_minimumfeedbackvertexset.rs
+++ b/src/rules/minimumvertexcover_minimumfeedbackvertexset.rs
@@ -26,21 +26,26 @@ where
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_arcs = "2 * num_edges",
     }
 )]
-impl ReduceTo<MinimumFeedbackVertexSet<i32>> for MinimumVertexCover<SimpleGraph, i32> {
-    type Result = ReductionVCToFVS<i32>;
+impl ReduceTo<MinimumFeedbackVertexSet<i64>> for MinimumVertexCover<SimpleGraph, i64> {
+    type Result = ReductionVCToFVS<i64>;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let arcs = self
             .graph()
             .edges()
@@ -53,7 +58,7 @@ impl ReduceTo<MinimumFeedbackVertexSet<i32>> for MinimumVertexCover<SimpleGraph,
             self.weights().to_vec(),
         );
 
-        ReductionVCToFVS { target }
+        Ok(ReductionVCToFVS { target })
     }
 }
 
@@ -78,14 +83,18 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                         (5, 6),
                     ],
                 ),
-                vec![1i32; 7],
+                vec![1i64; 7],
             );
 
-            crate::example_db::specs::rule_example_with_witness::<_, MinimumFeedbackVertexSet<i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, MinimumFeedbackVertexSet<i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 0, 1, 0, 1, 0],
-                    target_config: vec![1, 1, 0, 1, 0, 1, 0],
+                    source_config: serde_json::json!(vec![
+                        true, true, false, true, false, true, false
+                    ]),
+                    target_config: serde_json::json!(vec![
+                        true, true, false, true, false, true, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/minimumvertexcover_minimumhittingset.rs b/src/rules/minimumvertexcover_minimumhittingset.rs
index 0b426e715..656cbcfd6 100644
--- a/src/rules/minimumvertexcover_minimumhittingset.rs
+++ b/src/rules/minimumvertexcover_minimumhittingset.rs
@@ -26,13 +26,18 @@ impl ReductionResult for ReductionVCToHS {
 
     /// Solution extraction: variables correspond 1:1.
     /// Element i in the hitting set corresponds to vertex i in the vertex cover.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         universe_size = "num_vertices",
         num_sets = "num_edges",
     }
@@ -40,7 +45,7 @@ impl ReductionResult for ReductionVCToHS {
 impl ReduceTo<MinimumHittingSet> for MinimumVertexCover<SimpleGraph, One> {
     type Result = ReductionVCToHS;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let edges = self.graph().edges();
         let num_vertices = self.graph().num_vertices();
 
@@ -49,7 +54,7 @@ impl ReduceTo<MinimumHittingSet> for MinimumVertexCover<SimpleGraph, One> {
 
         let target = MinimumHittingSet::new(num_vertices, sets);
 
-        ReductionVCToHS { target }
+        Ok(ReductionVCToHS { target })
     }
 }
 
@@ -80,8 +85,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, MinimumHittingSet>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1, 1, 0],
-                    target_config: vec![1, 0, 0, 1, 1, 0],
+                    source_config: serde_json::json!(vec![true, false, false, true, true, false]),
+                    target_config: serde_json::json!(vec![true, false, false, true, true, false]),
                 },
             )
         },
diff --git a/src/rules/minimumvertexcover_minimummaximalmatching.rs b/src/rules/minimumvertexcover_minimummaximalmatching.rs
index 3556e510d..06819a13b 100644
--- a/src/rules/minimumvertexcover_minimummaximalmatching.rs
+++ b/src/rules/minimumvertexcover_minimummaximalmatching.rs
@@ -8,21 +8,11 @@
 //! (for example, on `C5`, `mmm(G) = 2` but `mvc(G) = 3`).
 
 use crate::models::graph::{MinimumMaximalMatching, MinimumVertexCover};
-use crate::rules::{EdgeCapabilities, ReductionEntry, ReductionOverhead};
+use crate::rules::registry::ReductionParameterDeclarations;
+use crate::rules::ReductionEntry;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
-use crate::types::{One, ProblemSize};
-use std::any::Any;
-
-fn source_problem_size(any: &dyn Any) -> ProblemSize {
-    let source = any
-        .downcast_ref::<MinimumVertexCover<SimpleGraph, One>>()
-        .expect("MinimumVertexCover -> MinimumMaximalMatching source type mismatch");
-    ProblemSize::new(vec![
-        ("num_vertices", source.num_vertices()),
-        ("num_edges", source.num_edges()),
-    ])
-}
+use crate::types::One;
 
 inventory::submit! {
     ReductionEntry {
@@ -30,13 +20,18 @@ inventory::submit! {
         target_name: MinimumMaximalMatching::<SimpleGraph>::NAME,
         source_variant_fn: <MinimumVertexCover<SimpleGraph, One> as Problem>::variant,
         target_variant_fn: <MinimumMaximalMatching<SimpleGraph> as Problem>::variant,
-        overhead_fn: || ReductionOverhead::identity(&["num_vertices", "num_edges"]),
+        parameter_declarations_fn: || ReductionParameterDeclarations {
+            relation: Some(crate::parameters::ParameterRelation::Exact),
+            fields: vec![
+                ("num_vertices", crate::expr::Expr::variable("num_vertices")),
+                ("num_edges", crate::expr::Expr::variable("num_edges")),
+            ],
+            unavailable: vec![],
+        },
         module_path: module_path!(),
         reduce_fn: None,
         reduce_aggregate_fn: None,
-        capabilities: EdgeCapabilities::none(),
-        overhead_eval_fn: source_problem_size,
-        source_size_fn: source_problem_size,
+        turing: false,
     }
 }
 
@@ -55,8 +50,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 &source,
                 &target,
                 vec![SolutionPair {
-                    source_config: vec![1, 1, 0, 1, 0],
-                    target_config: vec![1, 0, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, true, false, true, false]),
+                    target_config: serde_json::json!(vec![true, false, true, false, false]),
                 }],
             )
         },
diff --git a/src/rules/minimumvertexcover_minimumsetcovering.rs b/src/rules/minimumvertexcover_minimumsetcovering.rs
index c15f5f8c0..4a7baceca 100644
--- a/src/rules/minimumvertexcover_minimumsetcovering.rs
+++ b/src/rules/minimumvertexcover_minimumsetcovering.rs
@@ -29,21 +29,26 @@ where
 
     /// Solution extraction: variables correspond 1:1.
     /// Vertex i in VC corresponds to set i in SC.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_sets = "num_vertices",
         universe_size = "num_edges",
     }
 )]
-impl ReduceTo<MinimumSetCovering<i32>> for MinimumVertexCover<SimpleGraph, i32> {
-    type Result = ReductionVCToSC<i32>;
+impl ReduceTo<MinimumSetCovering<i64>> for MinimumVertexCover<SimpleGraph, i64> {
+    type Result = ReductionVCToSC<i64>;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let edges = self.graph().edges();
         let num_edges = edges.len();
         let num_vertices = self.graph().num_vertices();
@@ -63,7 +68,7 @@ impl ReduceTo<MinimumSetCovering<i32>> for MinimumVertexCover<SimpleGraph, i32>
 
         let target = MinimumSetCovering::with_weights(num_edges, sets, self.weights().to_vec());
 
-        ReductionVCToSC { target }
+        Ok(ReductionVCToSC { target })
     }
 }
 
@@ -75,12 +80,16 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "minimumvertexcover_to_minimumsetcovering",
         build: || {
             let (n, edges) = crate::topology::small_graphs::petersen();
-            let source = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i32; 10]);
-            crate::example_db::specs::rule_example_with_witness::<_, MinimumSetCovering<i32>>(
+            let source = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i64; 10]);
+            crate::example_db::specs::rule_example_with_witness::<_, MinimumSetCovering<i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0, 1, 1, 0, 0, 1, 1],
-                    target_config: vec![0, 1, 1, 0, 1, 1, 0, 0, 1, 1],
+                    source_config: serde_json::json!(vec![
+                        false, true, true, false, true, true, false, false, true, true
+                    ]),
+                    target_config: serde_json::json!(vec![
+                        false, true, true, false, true, true, false, false, true, true
+                    ]),
                 },
             )
         },
diff --git a/src/rules/minimumvertexcover_minimumweightandorgraph.rs b/src/rules/minimumvertexcover_minimumweightandorgraph.rs
index feeefdf1a..247ce8733 100644
--- a/src/rules/minimumvertexcover_minimumweightandorgraph.rs
+++ b/src/rules/minimumvertexcover_minimumweightandorgraph.rs
@@ -16,30 +16,37 @@ pub struct ReductionVCToAndOrGraph {
 }
 
 impl ReductionResult for ReductionVCToAndOrGraph {
-    type Source = MinimumVertexCover<SimpleGraph, i32>;
+    type Source = MinimumVertexCover<SimpleGraph, i64>;
     type Target = MinimumWeightAndOrGraph;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.num_source_vertices)
-            .map(|j| usize::from(target_solution.get(self.sink_arc_start + j) == Some(&1)))
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            (0..self.num_source_vertices)
+                .map(|j| target_solution[self.sink_arc_start + j])
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "1 + num_edges + 2 * num_vertices",
         num_arcs = "3 * num_edges + num_vertices",
     }
 )]
-impl ReduceTo<MinimumWeightAndOrGraph> for MinimumVertexCover<SimpleGraph, i32> {
+impl ReduceTo<MinimumWeightAndOrGraph> for MinimumVertexCover<SimpleGraph, i64> {
     type Result = ReductionVCToAndOrGraph;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let edges = self.graph().edges();
         let m = edges.len();
@@ -79,17 +86,17 @@ impl ReduceTo<MinimumWeightAndOrGraph> for MinimumVertexCover<SimpleGraph, i32>
         let target =
             MinimumWeightAndOrGraph::new(num_target_vertices, arcs, 0, gate_types, arc_weights);
 
-        ReductionVCToAndOrGraph {
+        Ok(ReductionVCToAndOrGraph {
             target,
             sink_arc_start,
             num_source_vertices: n,
-        }
+        })
     }
 }
 
 #[cfg(any(test, feature = "example-db"))]
-fn issue_example_source() -> MinimumVertexCover<SimpleGraph, i32> {
-    MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3])
+fn issue_example_source() -> MinimumVertexCover<SimpleGraph, i64> {
+    MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3])
 }
 
 #[cfg(feature = "example-db")]
@@ -102,8 +109,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, MinimumWeightAndOrGraph>(
                 issue_example_source(),
                 SolutionPair {
-                    source_config: vec![0, 1, 0],
-                    target_config: vec![1, 1, 0, 1, 1, 0, 0, 1, 0],
+                    source_config: serde_json::json!(vec![false, true, false]),
+                    target_config: serde_json::json!(vec![
+                        true, true, false, true, true, false, false, true, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/minimumweightdecoding_ilp.rs b/src/rules/minimumweightdecoding_ilp.rs
index 2961fac19..970470c71 100644
--- a/src/rules/minimumweightdecoding_ilp.rs
+++ b/src/rules/minimumweightdecoding_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from MinimumWeightDecoding to ILP<i32>.
+//! Reduction from MinimumWeightDecoding to `ILP<i64>`.
 //!
 //! The GF(2) constraint Hx ≡ s (mod 2) is linearized by introducing integer
 //! slack variables k_i for each row:
@@ -20,41 +20,52 @@ use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing MinimumWeightDecoding to ILP<i32>.
+/// Result of reducing MinimumWeightDecoding to `ILP<i64>`.
 ///
 /// Variable layout:
 /// - x_j at index j for j in 0..num_cols (binary codeword bits)
 /// - k_i at index num_cols + i for i in 0..num_rows (integer slack)
 #[derive(Debug, Clone)]
 pub struct ReductionMinimumWeightDecodingToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_cols: usize,
 }
 
 impl ReductionResult for ReductionMinimumWeightDecodingToILP {
     type Source = MinimumWeightDecoding;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Extract the source solution: first m variables are the binary x_j values.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_cols].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_cols]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_cols + num_rows",
         num_constraints = "num_rows + num_cols",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for MinimumWeightDecoding {
+impl ReduceTo<ILP<i64>> for MinimumWeightDecoding {
     type Result = ReductionMinimumWeightDecodingToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.num_cols();
         let n = self.num_rows();
         let num_vars = m + n;
@@ -66,29 +77,30 @@ impl ReduceTo<ILP<i32>> for MinimumWeightDecoding {
 
         // Equality constraints: Σ_j H[i][j] * x_j - 2 * k_i = s_i
         for i in 0..n {
-            let mut terms: Vec<(usize, f64)> = Vec::new();
+            let mut terms: Vec<(usize, i64)> = Vec::new();
             for j in 0..m {
                 if self.matrix()[i][j] {
-                    terms.push((x(j), 1.0));
+                    terms.push((x(j), 1));
                 }
             }
-            terms.push((k(i), -2.0));
-            let rhs = if self.target()[i] { 1.0 } else { 0.0 };
+            terms.push((k(i), -2));
+            let rhs = if self.target()[i] { 1 } else { 0 };
             constraints.push(LinearConstraint::eq(terms, rhs));
         }
 
         // Binary bounds: x_j ≤ 1
         for j in 0..m {
-            constraints.push(LinearConstraint::le(vec![(x(j), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(x(j), 1)], 1));
         }
 
         // Objective: minimize Σ x_j
-        let objective: Vec<(usize, f64)> = (0..m).map(|j| (x(j), 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (0..m).map(|j| (x(j), 1)).collect();
 
-        ReductionMinimumWeightDecodingToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize),
+        Ok(ReductionMinimumWeightDecodingToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_cols: m,
-        }
+        })
     }
 }
 
@@ -105,7 +117,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 ],
                 vec![true, true, false],
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/minmaxmulticenter_ilp.rs b/src/rules/minmaxmulticenter_ilp.rs
index 0e475e6a3..f4360ac63 100644
--- a/src/rules/minmaxmulticenter_ilp.rs
+++ b/src/rules/minmaxmulticenter_ilp.rs
@@ -1,7 +1,7 @@
 //! Reduction from MinMaxMulticenter to ILP (Integer Linear Programming).
 //!
 //! The vertex p-center optimization problem is formulated as a mixed ILP
-//! using `ILP<i32>` to accommodate both binary and integer variables.
+//! using `ILP<i64>` to accommodate both binary and integer variables.
 //!
 //! Variable layout:
 //! - `x_j` for each vertex j (binary: 1 if vertex j is selected as a center), indices `0..n`
@@ -14,7 +14,7 @@
 //! - Assignment: ∀i: Σ_j y_{i,j} = 1 (each vertex assigned to exactly one center)
 //! - Assignment link: ∀i,j: if j is reachable from i then y_{i,j} ≤ x_j,
 //!   otherwise y_{i,j} = 0
-//! - Binary bounds: x_j ≤ 1, y_{i,j} ≤ 1 (enforce binary within ILP<i32>)
+//! - Binary bounds: x_j ≤ 1, y_{i,j} ≤ 1 (enforce binary within `ILP<i64>`)
 //! - Minimax: ∀i: Σ_j w_i · d(i,j) · y_{i,j} ≤ z
 //!
 //! Objective: minimize z.
@@ -33,20 +33,28 @@ use crate::topology::{Graph, SimpleGraph};
 /// Result of reducing MinMaxMulticenter to ILP.
 #[derive(Debug, Clone)]
 pub struct ReductionMMCToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_vertices: usize,
 }
 
 impl ReductionResult for ReductionMMCToILP {
-    type Source = MinMaxMulticenter<SimpleGraph, i32>;
-    type Target = ILP<i32>;
+    type Source = MinMaxMulticenter<SimpleGraph, i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_vertices]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
@@ -55,13 +63,13 @@ impl ReductionResult for ReductionMMCToILP {
 /// Returns a vector of length `n`; unreachable vertices remain `None`.
 fn weighted_distances_mmc(
     graph: &SimpleGraph,
-    edge_lengths: &[i32],
+    edge_lengths: &[i64],
     source: usize,
     n: usize,
 ) -> Vec<Option<i64>> {
     let mut adj: Vec<Vec<(usize, i64)>> = vec![Vec::new(); n];
     for (idx, &(u, v)) in graph.edges().iter().enumerate() {
-        let len = i64::from(edge_lengths[idx]);
+        let len = edge_lengths[idx];
         adj[u].push((v, len));
         adj[v].push((u, len));
     }
@@ -114,17 +122,20 @@ fn weighted_distances_mmc(
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices + num_vertices^2 + 1",
         num_constraints = "2 * num_vertices^2 + 3 * num_vertices + 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for MinMaxMulticenter<SimpleGraph, i32> {
+impl ReduceTo<ILP<i64>> for MinMaxMulticenter<SimpleGraph, i64> {
     type Result = ReductionMMCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
-        let k = self.k();
+        let k = Self::exact_i64(self.k(), "encoding the number of centers")?;
         let vertex_weights = self.vertex_weights();
         let edge_lengths = self.edge_lengths();
 
@@ -142,13 +153,13 @@ impl ReduceTo<ILP<i32>> for MinMaxMulticenter<SimpleGraph, i32> {
         let mut constraints = Vec::with_capacity(2 * n * n + 3 * n + 2);
 
         // Cardinality constraint: Σ_j x_j = k
-        let center_terms: Vec<(usize, f64)> = (0..n).map(|j| (x_var(j), 1.0)).collect();
-        constraints.push(LinearConstraint::eq(center_terms, k as f64));
+        let center_terms: Vec<(usize, i64)> = (0..n).map(|j| (x_var(j), 1)).collect();
+        constraints.push(LinearConstraint::eq(center_terms, k));
 
         // Assignment constraints: ∀i: Σ_j y_{i,j} = 1
         for i in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|j| (y_var(i, j), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|j| (y_var(i, j), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Assignment link constraints:
@@ -157,59 +168,76 @@ impl ReduceTo<ILP<i32>> for MinMaxMulticenter<SimpleGraph, i32> {
             for (j, distance) in distances.iter().enumerate() {
                 if distance.is_some() {
                     constraints.push(LinearConstraint::le(
-                        vec![(y_var(i, j), 1.0), (x_var(j), -1.0)],
-                        0.0,
+                        vec![(y_var(i, j), 1), (x_var(j), -1)],
+                        0,
                     ));
                 } else {
-                    constraints.push(LinearConstraint::eq(vec![(y_var(i, j), 1.0)], 0.0));
+                    constraints.push(LinearConstraint::eq(vec![(y_var(i, j), 1)], 0));
                 }
             }
         }
 
-        // Binary bounds for x_j and y_{i,j} (enforce binary within ILP<i32>)
+        // Binary bounds for x_j and y_{i,j} (enforce binary within `ILP<i64>`)
         for j in 0..n {
-            constraints.push(LinearConstraint::le(vec![(x_var(j), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(x_var(j), 1)], 1));
         }
         for i in 0..n {
             for j in 0..n {
-                constraints.push(LinearConstraint::le(vec![(y_var(i, j), 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(y_var(i, j), 1)], 1));
             }
         }
 
         // Upper bound on z: the worst-case weighted distance over all vertex
         // pairs.  Without this bound HiGHS sees z ∈ [0, 2^31) and can stall.
-        let z_upper: f64 = all_dist
+        let weighted_distances: Vec<Vec<Option<i64>>> = all_dist
             .iter()
             .enumerate()
-            .flat_map(|(i, row)| {
+            .map(|(i, row)| {
                 row.iter()
-                    .filter_map(move |d| d.map(|d| (vertex_weights[i] as f64) * (d as f64)))
+                    .map(|distance| {
+                        distance
+                            .map(|distance| {
+                                vertex_weights[i].checked_mul(distance).ok_or_else(|| {
+                                    crate::rules::ReductionError::integer_overflow::<
+                                        MinMaxMulticenter<SimpleGraph, i64>,
+                                        ILP<i64>,
+                                    >(
+                                        "multiplying a vertex weight by a shortest-path distance"
+                                    )
+                                })
+                            })
+                            .transpose()
+                    })
+                    .collect::<Result<Vec<_>, _>>()
             })
-            .fold(0.0_f64, f64::max);
-        constraints.push(LinearConstraint::le(vec![(z_var, 1.0)], z_upper));
+            .collect::<Result<_, crate::rules::ReductionError>>()?;
+        let z_upper = weighted_distances
+            .iter()
+            .flatten()
+            .filter_map(|distance| *distance)
+            .fold(0_i64, i64::max);
+        constraints.push(LinearConstraint::le(vec![(z_var, 1)], z_upper));
 
         // Minimax constraints: ∀i: Σ_j w_i · d(i,j) · y_{i,j} ≤ z
-        for (i, &w) in vertex_weights.iter().enumerate() {
-            let w_i = w as f64;
-            let mut terms: Vec<(usize, f64)> = all_dist[i]
+        for (i, distances) in weighted_distances.iter().enumerate() {
+            let mut terms: Vec<(usize, i64)> = distances
                 .iter()
                 .enumerate()
-                .filter_map(|(j, distance)| {
-                    distance.map(|distance| (y_var(i, j), w_i * distance as f64))
-                })
+                .filter_map(|(j, distance)| distance.map(|distance| (y_var(i, j), distance)))
                 .collect();
-            terms.push((z_var, -1.0));
-            constraints.push(LinearConstraint::le(terms, 0.0));
+            terms.push((z_var, -1));
+            constraints.push(LinearConstraint::le(terms, 0));
         }
 
         // Objective: minimize z
-        let objective = vec![(z_var, 1.0)];
+        let objective = vec![(z_var, 1)];
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
-        ReductionMMCToILP {
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionMMCToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -222,11 +250,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Optimal: place center at vertex 1; max distance = 1.
             let source = MinMaxMulticenter::new(
                 SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-                vec![1i32; 3],
-                vec![1i32; 2],
+                vec![1i64; 3],
+                vec![1i64; 2],
                 1,
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/mixedchinesepostman_ilp.rs b/src/rules/mixedchinesepostman_ilp.rs
index ded42a6fb..88da8843a 100644
--- a/src/rules/mixedchinesepostman_ilp.rs
+++ b/src/rules/mixedchinesepostman_ilp.rs
@@ -14,35 +14,48 @@ use crate::types::WeightElement;
 /// Result of reducing MixedChinesePostman to ILP.
 #[derive(Debug, Clone)]
 pub struct ReductionMCPToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_undirected_edges: usize,
 }
 
 impl ReductionResult for ReductionMCPToILP {
-    type Source = MixedChinesePostman<i32>;
-    type Target = ILP<i32>;
+    type Source = MixedChinesePostman<i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Return the orientation bits d_k in source edge order
-        target_solution[..self.num_undirected_edges].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // Return the orientation bits d_k in source edge order
+            target_solution[..self.num_undirected_edges]
+                .iter()
+                .map(|&value| value == 1)
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_edges + 4 * (num_arcs + 2 * num_edges) + 3 * num_vertices + 1",
-        num_constraints = "num_vertices + 2 * (num_arcs + 2 * num_edges) + 2 * (num_arcs + 2 * num_edges) + num_vertices + 1 + num_vertices + 4 * num_vertices + 2 * (num_arcs + 2 * num_edges) + 2 * num_vertices",
+        num_constraints = "num_edges + 8 * (num_arcs + 2 * num_edges) + 10 * num_vertices + 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for MixedChinesePostman<i32> {
+impl ReduceTo<ILP<i64>> for MixedChinesePostman<i64> {
     type Result = ReductionMCPToILP;
 
     #[allow(clippy::needless_range_loop)]
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let m = self.num_arcs(); // original directed arcs
         let q = self.num_edges(); // undirected edges
@@ -50,10 +63,11 @@ impl ReduceTo<ILP<i32>> for MixedChinesePostman<i32> {
 
         // If R = 0, empty walk is feasible
         if r_count == 0 {
-            return ReductionMCPToILP {
-                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize),
+            return Ok(ReductionMCPToILP {
+                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize)
+                    .map_err(Self::target_construction)?,
                 num_undirected_edges: 0,
-            };
+            });
         }
 
         // Available arc list A*: L = m + 2q arcs
@@ -66,17 +80,18 @@ impl ReduceTo<ILP<i32>> for MixedChinesePostman<i32> {
 
         // Build available arc list with lengths
         let mut avail_arcs: Vec<(usize, usize)> = Vec::with_capacity(l);
-        let mut avail_lengths: Vec<f64> = Vec::with_capacity(l);
+        let mut avail_lengths: Vec<i64> = Vec::with_capacity(l);
 
         for (i, &(u, v)) in original_arcs.iter().enumerate() {
             avail_arcs.push((u, v));
-            avail_lengths.push(self.arc_weights()[i].to_sum() as f64);
+            avail_lengths.push(self.arc_weights()[i].to_sum());
         }
         for (k, &(u, v)) in undirected_edges.iter().enumerate() {
+            let length = self.edge_weights()[k].to_sum();
             avail_arcs.push((u, v)); // forward
-            avail_lengths.push(self.edge_weights()[k].to_sum() as f64);
+            avail_lengths.push(length);
             avail_arcs.push((v, u)); // reverse
-            avail_lengths.push(self.edge_weights()[k].to_sum() as f64);
+            avail_lengths.push(length);
         }
 
         // Variable layout (from paper):
@@ -101,29 +116,38 @@ impl ReduceTo<ILP<i32>> for MixedChinesePostman<i32> {
         let h_idx = |j: usize| q + 3 * l + 3 * n + 1 + j;
 
         let num_vars = q + 4 * l + 3 * n + 1;
-        let big_g = (r_count * (n - 1)) as f64; // G = R(n-1)
-        let m_use = 1.0 + big_g; // M_use = 1 + G
-        let n_f64 = n as f64;
+        let n_i64 = Self::exact_i64(n, "encoding the active-vertex count")?;
+        let r_count_i64 = Self::exact_i64(r_count, "encoding the required-arc count")?;
+        let big_g = r_count_i64.checked_mul(n_i64 - 1).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<MixedChinesePostman<i64>, ILP<i64>>(
+                "computing the extra-traversal bound",
+            )
+        })?;
+        let m_use = big_g.checked_add(1).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<MixedChinesePostman<i64>, ILP<i64>>(
+                "computing the arc-use bound",
+            )
+        })?;
 
         let mut constraints = Vec::new();
 
         // Binary bounds for d_k: 0 <= d_k <= 1
         for k in 0..q {
-            constraints.push(LinearConstraint::le(vec![(d_idx(k), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(d_idx(k), 1)], 1));
         }
 
         // Bounds on g_j: 0 <= g_j <= G
         for j in 0..l {
-            constraints.push(LinearConstraint::le(vec![(g_idx(j), 1.0)], big_g));
+            constraints.push(LinearConstraint::le(vec![(g_idx(j), 1)], big_g));
         }
 
         // Binary bounds: y_j, z_v, rho_v <= 1
         for j in 0..l {
-            constraints.push(LinearConstraint::le(vec![(y_idx(j), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(y_idx(j), 1)], 1));
         }
         for v in 0..n {
-            constraints.push(LinearConstraint::le(vec![(z_idx(v), 1.0)], 1.0));
-            constraints.push(LinearConstraint::le(vec![(rho_idx(v), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(z_idx(v), 1)], 1));
+            constraints.push(LinearConstraint::le(vec![(rho_idx(v), 1)], 1));
         }
 
         // The required multiplicity r_j(d):
@@ -135,20 +159,20 @@ impl ReduceTo<ILP<i32>> for MixedChinesePostman<i32> {
         // sum_{j: tail_j = v} (r_j + g_j) - sum_{j: head_j = v} (r_j + g_j) = 0 for all v
         for v in 0..n {
             let mut terms = Vec::new();
-            let mut constant = 0.0_f64; // constant part of r_j
+            let mut constant = 0_i64; // constant part of r_j
 
             for j in 0..l {
                 let (tail, head) = avail_arcs[j];
                 let sign = if tail == v && head == v {
-                    0.0 // self-loop contributes nothing
+                    0 // self-loop contributes nothing
                 } else if tail == v {
-                    1.0
+                    1
                 } else if head == v {
-                    -1.0
+                    -1
                 } else {
                     continue;
                 };
-                if sign == 0.0 {
+                if sign == 0 {
                     continue;
                 }
 
@@ -180,39 +204,36 @@ impl ReduceTo<ILP<i32>> for MixedChinesePostman<i32> {
             if j < m {
                 // r_j = 1: (1 + g_j) <= M_use * y_j => g_j - M_use * y_j <= -1
                 constraints.push(LinearConstraint::le(
-                    vec![(g_idx(j), 1.0), (y_idx(j), -m_use)],
-                    -1.0,
+                    vec![(g_idx(j), 1), (y_idx(j), -m_use)],
+                    -1,
                 ));
                 // y_j <= 1 + g_j => y_j - g_j <= 1
-                constraints.push(LinearConstraint::le(
-                    vec![(y_idx(j), 1.0), (g_idx(j), -1.0)],
-                    1.0,
-                ));
+                constraints.push(LinearConstraint::le(vec![(y_idx(j), 1), (g_idx(j), -1)], 1));
             } else {
                 let k = (j - m) / 2;
                 if (j - m).is_multiple_of(2) {
                     // Forward: r_j = 1 - d_k
                     // (1 - d_k + g_j) <= M_use * y_j => g_j - d_k - M_use * y_j <= -1
                     constraints.push(LinearConstraint::le(
-                        vec![(g_idx(j), 1.0), (d_idx(k), -1.0), (y_idx(j), -m_use)],
-                        -1.0,
+                        vec![(g_idx(j), 1), (d_idx(k), -1), (y_idx(j), -m_use)],
+                        -1,
                     ));
                     // y_j <= 1 - d_k + g_j => y_j + d_k - g_j <= 1
                     constraints.push(LinearConstraint::le(
-                        vec![(y_idx(j), 1.0), (d_idx(k), 1.0), (g_idx(j), -1.0)],
-                        1.0,
+                        vec![(y_idx(j), 1), (d_idx(k), 1), (g_idx(j), -1)],
+                        1,
                     ));
                 } else {
                     // Reverse: r_j = d_k
                     // (d_k + g_j) <= M_use * y_j => d_k + g_j - M_use * y_j <= 0
                     constraints.push(LinearConstraint::le(
-                        vec![(d_idx(k), 1.0), (g_idx(j), 1.0), (y_idx(j), -m_use)],
-                        0.0,
+                        vec![(d_idx(k), 1), (g_idx(j), 1), (y_idx(j), -m_use)],
+                        0,
                     ));
                     // y_j <= d_k + g_j => y_j - d_k - g_j <= 0
                     constraints.push(LinearConstraint::le(
-                        vec![(y_idx(j), 1.0), (d_idx(k), -1.0), (g_idx(j), -1.0)],
-                        0.0,
+                        vec![(y_idx(j), 1), (d_idx(k), -1), (g_idx(j), -1)],
+                        0,
                     ));
                 }
             }
@@ -222,76 +243,73 @@ impl ReduceTo<ILP<i32>> for MixedChinesePostman<i32> {
         for j in 0..l {
             let (tail, head) = avail_arcs[j];
             constraints.push(LinearConstraint::le(
-                vec![(y_idx(j), 1.0), (z_idx(tail), -1.0)],
-                0.0,
+                vec![(y_idx(j), 1), (z_idx(tail), -1)],
+                0,
             ));
             constraints.push(LinearConstraint::le(
-                vec![(y_idx(j), 1.0), (z_idx(head), -1.0)],
-                0.0,
+                vec![(y_idx(j), 1), (z_idx(head), -1)],
+                0,
             ));
         }
 
         // z_v <= sum_{j: tail_j=v or head_j=v} y_j
         for v in 0..n {
-            let mut terms = vec![(z_idx(v), 1.0)];
+            let mut terms = vec![(z_idx(v), 1)];
             for j in 0..l {
                 let (tail, head) = avail_arcs[j];
                 if tail == v || head == v {
-                    terms.push((y_idx(j), -1.0));
+                    terms.push((y_idx(j), -1));
                 }
             }
-            constraints.push(LinearConstraint::le(terms, 0.0));
+            constraints.push(LinearConstraint::le(terms, 0));
         }
 
         // s = sum_v z_v
         {
-            let mut terms = vec![(s_idx, -1.0)];
+            let mut terms = vec![(s_idx, -1)];
             for v in 0..n {
-                terms.push((z_idx(v), 1.0));
+                terms.push((z_idx(v), 1));
             }
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // Root selection: sum_v rho_v = 1, rho_v <= z_v
         {
-            let terms: Vec<(usize, f64)> = (0..n).map(|v| (rho_idx(v), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|v| (rho_idx(v), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
         for v in 0..n {
             constraints.push(LinearConstraint::le(
-                vec![(rho_idx(v), 1.0), (z_idx(v), -1.0)],
-                0.0,
+                vec![(rho_idx(v), 1), (z_idx(v), -1)],
+                0,
             ));
         }
 
         // Product linearization: b_v = s * rho_v
         // b_v <= s, b_v <= n * rho_v, b_v >= s - n*(1 - rho_v), b_v >= 0
         for v in 0..n {
+            constraints.push(LinearConstraint::le(vec![(b_idx(v), 1), (s_idx, -1)], 0));
             constraints.push(LinearConstraint::le(
-                vec![(b_idx(v), 1.0), (s_idx, -1.0)],
-                0.0,
-            ));
-            constraints.push(LinearConstraint::le(
-                vec![(b_idx(v), 1.0), (rho_idx(v), -n_f64)],
-                0.0,
+                vec![(b_idx(v), 1), (rho_idx(v), -n_i64)],
+                0,
             ));
             constraints.push(LinearConstraint::ge(
-                vec![(b_idx(v), 1.0), (s_idx, -1.0), (rho_idx(v), -n_f64)],
-                -n_f64,
+                vec![(b_idx(v), 1), (s_idx, -1), (rho_idx(v), -n_i64)],
+                -n_i64,
             ));
-            // b_v >= 0 is implied by ILP<i32> non-negativity
+            // b_v >= 0 is implied by `ILP<i64>` non-negativity
         }
 
         // Flow bounds: 0 <= f_j, h_j <= (n-1) * y_j
-        let flow_big_m = (n as f64) - 1.0;
+        let flow_big_m = n_i64 - 1;
         for j in 0..l {
             constraints.push(LinearConstraint::le(
-                vec![(f_idx(j), 1.0), (y_idx(j), -flow_big_m)],
-                0.0,
+                vec![(f_idx(j), 1), (y_idx(j), -flow_big_m)],
+                0,
             ));
             constraints.push(LinearConstraint::le(
-                vec![(h_idx(j), 1.0), (y_idx(j), -flow_big_m)],
-                0.0,
+                vec![(h_idx(j), 1), (y_idx(j), -flow_big_m)],
+                0,
             ));
         }
 
@@ -302,15 +320,15 @@ impl ReduceTo<ILP<i32>> for MixedChinesePostman<i32> {
             for j in 0..l {
                 let (tail, head) = avail_arcs[j];
                 if tail == v {
-                    terms.push((f_idx(j), 1.0));
+                    terms.push((f_idx(j), 1));
                 }
                 if head == v {
-                    terms.push((f_idx(j), -1.0));
+                    terms.push((f_idx(j), -1));
                 }
             }
-            terms.push((b_idx(v), -1.0));
-            terms.push((z_idx(v), 1.0));
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            terms.push((b_idx(v), -1));
+            terms.push((z_idx(v), 1));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // Reverse flow conservation:
@@ -320,15 +338,15 @@ impl ReduceTo<ILP<i32>> for MixedChinesePostman<i32> {
             for j in 0..l {
                 let (tail, head) = avail_arcs[j];
                 if head == v {
-                    terms.push((h_idx(j), 1.0));
+                    terms.push((h_idx(j), 1));
                 }
                 if tail == v {
-                    terms.push((h_idx(j), -1.0));
+                    terms.push((h_idx(j), -1));
                 }
             }
-            terms.push((b_idx(v), -1.0));
-            terms.push((z_idx(v), 1.0));
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            terms.push((b_idx(v), -1));
+            terms.push((z_idx(v), 1));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // Objective: minimize total walk length = sum_j l_j * (r_j + g_j)
@@ -353,12 +371,13 @@ impl ReduceTo<ILP<i32>> for MixedChinesePostman<i32> {
             }
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionMCPToILP {
+        Ok(ReductionMCPToILP {
             target,
             num_undirected_edges: q,
-        }
+        })
     }
 }
 
@@ -375,7 +394,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 vec![1],
                 vec![1, 1],
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/mod.rs b/src/rules/mod.rs
index e648997a4..2b7d66b7c 100644
--- a/src/rules/mod.rs
+++ b/src/rules/mod.rs
@@ -1,22 +1,24 @@
 //! Reduction rules between NP-hard problems.
 
 pub mod analysis;
-pub mod cost;
 pub mod registry;
-pub use cost::{
-    CustomCost, Minimize, MinimizeOutputSize, MinimizeSteps, MinimizeStepsThenOverhead, PathCostFn,
+pub use registry::{
+    EdgeCapabilities, ParameterContractError, ReductionEntry, ReductionParameterContract,
+    ReductionParameterDeclarations, UnavailableParameterField,
 };
-pub use registry::{EdgeCapabilities, ReductionEntry, ReductionOverhead};
 
 pub(crate) mod bicliquecover_bmf;
 pub(crate) mod bmf_bicliquecover;
 pub(crate) mod circuit_sat;
 pub(crate) mod circuit_spinglass;
+mod closestvectorproblem_casts;
 mod closestvectorproblem_qubo;
 pub(crate) mod coloring_qubo;
+pub(crate) mod decisionmaximumindependentset_integralflowbundles;
 pub(crate) mod decisionminimumdominatingset_minimumsummulticenter;
 pub(crate) mod decisionminimumdominatingset_minmaxmulticenter;
 pub(crate) mod decisionminimumvertexcover_hamiltoniancircuit;
+pub(crate) mod ensemblecomputation_ilp;
 pub(crate) mod exactcoverby3sets_algebraicequationsovergf2;
 pub(crate) mod exactcoverby3sets_boundeddiameterspanningtree;
 pub(crate) mod exactcoverby3sets_maximumsetpacking;
@@ -41,8 +43,8 @@ pub(crate) mod hamiltoniancircuit_travelingsalesman;
 pub(crate) mod hamiltonianpath_degreeconstrainedspanningtree;
 pub(crate) mod hamiltonianpath_isomorphicspanningtree;
 pub(crate) mod hamiltonianpathbetweentwovertices_longestpath;
-pub(crate) mod ilp_i32_ilp_bool;
-#[cfg(feature = "ilp-solver")]
+pub(crate) mod ilp_casts;
+pub(crate) mod ilp_i64_ilp_bool;
 pub(crate) mod integerknapsack_ilp;
 pub(crate) mod kclique_balancedcompletebipartitesubgraph;
 pub(crate) mod kclique_conjunctivebooleanquery;
@@ -80,7 +82,6 @@ pub(crate) mod maximum2satisfiability_maxcut;
 pub(crate) mod maximumclique_maximumindependentset;
 mod maximumindependentset_casts;
 mod maximumindependentset_gridgraph;
-pub(crate) mod maximumindependentset_integralflowbundles;
 pub(crate) mod maximumindependentset_maximumclique;
 pub(crate) mod maximumindependentset_maximumsetpacking;
 mod maximumindependentset_triangular;
@@ -90,7 +91,6 @@ pub(crate) mod maximumsetpacking_qubo;
 pub(crate) mod minimumcostmaximumflow_minimumcostcirculation;
 pub(crate) mod minimumcoveringbycliques_minimumintersectiongraphbasis;
 pub(crate) mod minimumdiscreteplanarinversekinematics_qubo;
-pub(crate) mod minimumfeedbackarcset_maximumlikelihoodranking;
 pub(crate) mod minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters;
 pub(crate) mod minimummaximalmatching_maximumachromaticnumber;
 pub(crate) mod minimummaximalmatching_minimummatrixdomination;
@@ -125,9 +125,11 @@ pub(crate) mod partition_sumofsquarespartition;
 pub(crate) mod partitionintocliques_minimumcoveringbycliques;
 pub(crate) mod partitionintopathsoflength2_boundedcomponentspanningforest;
 pub(crate) mod prizecollectingsteinerforest_steinertree;
+mod qubo_casts;
 pub(crate) mod rootedtreearrangement_rootedtreestorageassignment;
 pub(crate) mod sat_circuitsat;
 pub(crate) mod sat_coloring;
+pub(crate) mod sat_helpers;
 pub(crate) mod sat_ksat;
 pub(crate) mod sat_maximumindependentset;
 pub(crate) mod sat_minimumdominatingset;
@@ -146,7 +148,6 @@ pub(crate) mod subsetsum_partition;
 #[cfg(test)]
 pub(crate) mod test_helpers;
 pub(crate) mod threedimensionalmatching_minimumweightdecoding;
-pub(crate) mod threedimensionalmatching_threematroidintersection;
 pub(crate) mod threedimensionalmatching_threepartition;
 pub(crate) mod threepartition_resourceconstrainedscheduling;
 pub(crate) mod threepartition_sequencingwithreleasetimesanddeadlines;
@@ -155,259 +156,143 @@ pub(crate) mod travelingsalesman_qubo;
 
 pub mod unitdiskmapping;
 
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod acyclicpartition_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod balancedcompletebipartitesubgraph_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod biconnectivityaugmentation_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod binpacking_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod bmf_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod bottlenecktravelingsalesman_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod boundedcomponentspanningforest_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod capacityassignment_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod circuit_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod closeststring_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod closestsubstring_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod clustering_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod coloring_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod consecutiveblockminimization_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod consecutiveonesmatrixaugmentation_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod consecutiveonessubmatrix_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod consistencyofdatabasefrequencytables_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod directedhamiltonianpath_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod directedtwocommodityintegralflow_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod disjointconnectingpaths_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod eulerianpath_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod exactcoverby3sets_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod expectedretrievalcost_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod factoring_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod feasibleregisterassignment_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod flowshopscheduling_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod graphpartitioning_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod hamiltonianpath_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod highlyconnecteddeletion_ilp;
-#[cfg(feature = "ilp-solver")]
-mod ilp_bool_ilp_i32;
-#[cfg(feature = "ilp-solver")]
+mod ilp_bool_ilp_i64;
 pub(crate) mod ilp_helpers;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod ilp_qubo;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod integralflowbundles_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod integralflowhomologousarcs_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod integralflowwithmultipliers_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod isomorphicspanningtree_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod kclique_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod knapsack_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod lengthboundeddisjointpaths_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod longestcircuit_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod longestcommonsubsequence_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod longestpath_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximalis_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximum2satisfiability_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximumclique_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximumcokplex_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximumcommonedgesubgraph_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximumcontactmapoverlap_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximumdomaticnumber_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximumedgeweightedkclique_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximumleafspanningtree_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximumlikelihoodranking_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximummatching_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod maximumsetpacking_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumcapacitatedspanningtree_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumcoveringbycliques_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumcutintoboundedsets_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumdominatingset_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumedgecostflow_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumexternalmacrodatacompression_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumfaultdetectiontestset_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumfeedbackarcset_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumfeedbackvertexset_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumgraphbandwidth_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumhittingset_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimuminternalmacrodatacompression_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimummatrixcover_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimummaximalmatching_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimummetricdimension_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimummultiwaycut_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumsetcovering_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumsummulticenter_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumtardinesssequencing_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minimumweightdecoding_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod minmaxmulticenter_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod mixedchinesepostman_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod monochromatictriangle_ilp;
-#[cfg(feature = "ilp-solver")]
+pub(crate) mod multiplechoicebranching_ilp;
 pub(crate) mod multiplecopyfileallocation_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod multiprocessorscheduling_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod naesatisfiability_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod numericalmatchingwithtargetsums_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod openshopscheduling_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod optimallineararrangement_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod optimumcommunicationspanningtree_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod paintshop_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod partiallyorderedknapsack_ilp;
-#[cfg(feature = "ilp-solver")]
+pub(crate) mod partitionintocliques_ilp;
 pub(crate) mod partitionintopathsoflength2_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod partitionintotriangles_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod pathconstrainednetworkflow_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod precedenceconstrainedscheduling_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod preemptivescheduling_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod quadraticassignment_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod qubo_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod rectilinearpicturecompression_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod registersufficiency_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod resourceconstrainedscheduling_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod rootedtreestorageassignment_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod ruralpostman_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod schedulingtominimizeweightedcompletiontime_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod schedulingwithindividualdeadlines_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod sequencingtominimizemaximumcumulativecost_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod sequencingtominimizetardytaskweight_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod sequencingtominimizeweightedcompletiontime_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod sequencingtominimizeweightedtardiness_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod sequencingwithdeadlinesandsetuptimes_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod sequencingwithinintervals_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod sequencingwithreleasetimesanddeadlines_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod setsplitting_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod shortestcommonsupersequence_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod shortestweightconstrainedpath_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod sparsematrixcompression_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod stackercrane_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod steinertree_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod steinertreeingraphs_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod stringtostringcorrection_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod strongconnectivityaugmentation_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod subgraphisomorphism_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod sumofsquarespartition_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod threedimensionalmatching_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod timetabledesign_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod travelingsalesman_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod undirectedflowlowerbounds_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod undirectedtwocommodityintegralflow_ilp;
 
+#[cfg(test)]
+pub(crate) use graph::ReductionEdgeData;
 pub use graph::{
-    AggregateReductionChain, NeighborInfo, NeighborTree, ReductionChain, ReductionEdgeInfo,
-    ReductionGraph, ReductionMode, ReductionPath, ReductionStep, TraversalFlow,
+    AggregateReductionChain, ExecutePathsError, ExecutedPath, NeighborInfo, NeighborTree,
+    PathParameterError, ReductionChain, ReductionEdgeInfo, ReductionGraph, ReductionMode,
+    ReductionPath, ReductionStep, TraversalFlow,
 };
+pub(crate) use traits::{validate_target_solution, DynReductionResult};
 pub use traits::{
-    AggregateReductionResult, ReduceTo, ReduceToAggregate, ReductionAutoCast, ReductionResult,
+    AggregateReductionResult, ExtractionError, ExtractionResult, ReduceTo, ReduceToAggregate,
+    ReductionError, ReductionResult, VariantReductionResult,
 };
 
 #[cfg(feature = "example-db")]
@@ -444,7 +329,6 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     specs.extend(graphpartitioning_qubo::canonical_rule_example_specs());
     specs.extend(hamiltonianpathbetweentwovertices_longestpath::canonical_rule_example_specs());
     specs.extend(hamiltonianpath_isomorphicspanningtree::canonical_rule_example_specs());
-    #[cfg(feature = "ilp-solver")]
     specs.extend(integerknapsack_ilp::canonical_rule_example_specs());
     specs.extend(kclique_balancedcompletebipartitesubgraph::canonical_rule_example_specs());
     specs.extend(kclique_conjunctivebooleanquery::canonical_rule_example_specs());
@@ -476,7 +360,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     specs.extend(ksatisfiability_timetabledesign::canonical_rule_example_specs());
     specs.extend(maximum2satisfiability_maxcut::canonical_rule_example_specs());
     specs.extend(maximumclique_maximumindependentset::canonical_rule_example_specs());
-    specs.extend(maximumindependentset_integralflowbundles::canonical_rule_example_specs());
+    specs.extend(decisionmaximumindependentset_integralflowbundles::canonical_rule_example_specs());
     specs.extend(maximumindependentset_maximumclique::canonical_rule_example_specs());
     specs.extend(maximumindependentset_maximumsetpacking::canonical_rule_example_specs());
     specs.extend(maximummatching_maximumsetpacking::canonical_rule_example_specs());
@@ -506,12 +390,12 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     specs.extend(naesatisfiability_maxcut::canonical_rule_example_specs());
     specs.extend(naesatisfiability_partitionintoperfectmatchings::canonical_rule_example_specs());
     specs.extend(satisfiability_maximum2satisfiability::canonical_rule_example_specs());
+    specs.extend(ensemblecomputation_ilp::canonical_rule_example_specs());
     specs.extend(exactcoverby3sets_maximumsetpacking::canonical_rule_example_specs());
     specs.extend(maxcut_minimumcutintoboundedsets::canonical_rule_example_specs());
     specs.extend(maxcut_minimummatrixcover::canonical_rule_example_specs());
     specs.extend(partition_binpacking::canonical_rule_example_specs());
     specs.extend(threedimensionalmatching_minimumweightdecoding::canonical_rule_example_specs());
-    specs.extend(threedimensionalmatching_threematroidintersection::canonical_rule_example_specs());
     specs.extend(threedimensionalmatching_threepartition::canonical_rule_example_specs());
     specs.extend(threepartition_resourceconstrainedscheduling::canonical_rule_example_specs());
     specs.extend(
@@ -519,7 +403,6 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     );
     specs.extend(minimumvertexcover_comparativecontainment::canonical_rule_example_specs());
     specs.extend(minimumvertexcover_ensemblecomputation::canonical_rule_example_specs());
-    specs.extend(minimumfeedbackarcset_maximumlikelihoodranking::canonical_rule_example_specs());
     specs.extend(
         minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters::canonical_rule_example_specs(),
     );
@@ -563,13 +446,15 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     specs.extend(
         crate::models::graph::minimum_vertex_cover::decision_canonical_rule_example_specs(),
     );
+    specs.extend(
+        crate::models::graph::maximum_independent_set::decision_canonical_rule_example_specs(),
+    );
     specs.extend(
         crate::models::graph::minimum_dominating_set::decision_canonical_rule_example_specs(),
     );
     specs.extend(
         crate::models::graph::optimal_linear_arrangement::decision_canonical_rule_example_specs(),
     );
-    #[cfg(feature = "ilp-solver")]
     {
         specs.extend(acyclicpartition_ilp::canonical_rule_example_specs());
         specs.extend(balancedcompletebipartitesubgraph_ilp::canonical_rule_example_specs());
@@ -647,6 +532,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         specs.extend(mixedchinesepostman_ilp::canonical_rule_example_specs());
         specs.extend(monochromatictriangle_ilp::canonical_rule_example_specs());
         specs.extend(multiplecopyfileallocation_ilp::canonical_rule_example_specs());
+        specs.extend(multiplechoicebranching_ilp::canonical_rule_example_specs());
         specs.extend(multiprocessorscheduling_ilp::canonical_rule_example_specs());
         specs.extend(naesatisfiability_ilp::canonical_rule_example_specs());
         specs.extend(numericalmatchingwithtargetsums_ilp::canonical_rule_example_specs());
@@ -655,6 +541,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         specs.extend(optimallineararrangement_ilp::canonical_rule_example_specs());
         specs.extend(paintshop_ilp::canonical_rule_example_specs());
         specs.extend(partiallyorderedknapsack_ilp::canonical_rule_example_specs());
+        specs.extend(partitionintocliques_ilp::canonical_rule_example_specs());
         specs.extend(partitionintopathsoflength2_ilp::canonical_rule_example_specs());
         specs.extend(partitionintotriangles_ilp::canonical_rule_example_specs());
         specs.extend(pathconstrainednetworkflow_ilp::canonical_rule_example_specs());
@@ -698,10 +585,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     specs
 }
 
-/// Generates a variant-cast `ReduceTo` impl with `#[reduction]` registration.
+/// Generates an explicit same-model variant `ReduceTo` implementation.
 ///
-/// Variant casts convert a problem from one variant to another (e.g.,
-/// `MIS<KingsSubgraph, i32>` -> `MIS<UnitDiskGraph, i32>`). The solution
+/// Variant reductions convert a problem from one variant to another (e.g.,
+/// `MIS<KingsSubgraph, i64>` -> `MIS<UnitDiskGraph, i64>`). The solution
 /// mapping is identity -- vertex/element indices are preserved.
 ///
 /// The problem name is specified once, followed by `<SourceParams> => <TargetParams>`.
@@ -712,10 +599,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
 /// ```text
 /// impl_variant_reduction!(
 ///     MaximumIndependentSet,
-///     <KingsSubgraph, i32> => <UnitDiskGraph, i32>,
+///     <KingsSubgraph, i64> => <UnitDiskGraph, i64>,
 ///     fields: [num_vertices, num_edges],
 ///     |src| MaximumIndependentSet::new(
-///         src.graph().cast_to_parent(), src.weights())
+///         SimpleGraph::new(src.num_vertices(), Graph::edges(src.graph())),
+///         src.weights())
 /// );
 /// ```
 #[macro_export]
@@ -723,24 +611,24 @@ macro_rules! impl_variant_reduction {
     ($problem:ident,
      < $($src_param:ty),+ > => < $($dst_param:ty),+ >,
      fields: [$($field:ident),+],
+     $(aggregate: $aggregate:ident,)?
      |$src:ident| $body:expr) => {
         #[$crate::reduction(
-            overhead = {
-                $crate::rules::registry::ReductionOverhead::identity(
-                    &[$(stringify!($field)),+]
-                )
+            transform = exact {
+                $($field = $field),+
             }
+            $(, aggregate = $aggregate)?
         )]
         impl $crate::rules::ReduceTo<$problem<$($dst_param),+>>
             for $problem<$($src_param),+>
         {
-            type Result = $crate::rules::ReductionAutoCast<
+            type Result = $crate::rules::VariantReductionResult<
                 $problem<$($src_param),+>,
                 $problem<$($dst_param),+>,
             >;
-            fn reduce_to(&self) -> Self::Result {
+            fn reduce_to(&self) -> Result<Self::Result, $crate::rules::ReductionError> {
                 let $src = self;
-                $crate::rules::ReductionAutoCast::new($body)
+                Ok($crate::rules::VariantReductionResult::new($body))
             }
         }
     };
diff --git a/src/rules/monochromatictriangle_ilp.rs b/src/rules/monochromatictriangle_ilp.rs
index f9c06851a..8a83cb1d6 100644
--- a/src/rules/monochromatictriangle_ilp.rs
+++ b/src/rules/monochromatictriangle_ilp.rs
@@ -8,7 +8,8 @@ use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::MonochromaticTriangle;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
-use crate::topology::SimpleGraph;
+use crate::topology::{Graph, SimpleGraph};
+use std::collections::HashMap;
 
 /// Result of reducing MonochromaticTriangle to ILP.
 #[derive(Debug, Clone)]
@@ -24,37 +25,105 @@ impl ReductionResult for ReductionMonochromaticTriangleToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_edges",
-        num_constraints = "2 * num_triangles",
+        num_constraints = "2 * num_triangles + num_vertices^5 / 8",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MonochromaticTriangle<SimpleGraph> {
     type Result = ReductionMonochromaticTriangleToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let mut constraints = Vec::with_capacity(2 * self.num_triangles());
         for triangle in self.triangles() {
-            let terms: Vec<(usize, f64)> =
-                triangle.iter().map(|&edge_idx| (edge_idx, 1.0)).collect();
-            constraints.push(LinearConstraint::ge(terms.clone(), 1.0));
-            constraints.push(LinearConstraint::le(terms, 2.0));
+            let terms: Vec<(usize, i64)> = triangle.iter().map(|&edge_idx| (edge_idx, 1)).collect();
+            constraints.push(LinearConstraint::ge(terms.clone(), 1));
+            constraints.push(LinearConstraint::le(terms, 2));
         }
 
-        ReductionMonochromaticTriangleToILP {
+        // Every triangle-free two-colouring of K5 consists of two C5s.
+        // Hence each vertex has exactly two incident colour-1 edges in every
+        // K5. These valid equalities strengthen the LP relaxation for all
+        // inputs, independently of how a graph was constructed.
+        let graph = self.graph();
+        let edge_list = self.edge_list();
+        let edge_indices: HashMap<_, _> = edge_list
+            .iter()
+            .enumerate()
+            .map(|(index, &(u, v))| ((u.min(v), u.max(v)), index))
+            .collect();
+        for triangle in self.triangles() {
+            let mut vertices: Vec<_> = triangle
+                .iter()
+                .flat_map(|&edge| [edge_list[edge].0, edge_list[edge].1])
+                .collect();
+            vertices.sort_unstable();
+            vertices.dedup();
+            let [a, b, c] = [vertices[0], vertices[1], vertices[2]];
+            let mut common: Vec<_> = graph
+                .neighbors(c)
+                .into_iter()
+                .filter(|&v| !vertices.contains(&v) && graph.has_edge(a, v) && graph.has_edge(b, v))
+                .collect();
+            common.sort_unstable();
+            common.dedup();
+            // In a K5, the edge opposite this triangle has its majority
+            // colour. All such opposite edges therefore have equal colours.
+            // State these consequences directly so presolve can substitute
+            // colour copies instead of rediscovering the implication by MIP.
+            let mut first_opposite = None;
+            for (index, &d) in common.iter().enumerate() {
+                for &e in &common[index + 1..] {
+                    if graph.has_edge(d, e) {
+                        let opposite = edge_indices[&(d, e)];
+                        if let Some(first) = first_opposite {
+                            constraints
+                                .push(LinearConstraint::eq(vec![(first, 1), (opposite, -1)], 0));
+                        } else {
+                            first_opposite = Some(opposite);
+                        }
+                        // Count each K5's degree equalities only once, using
+                        // its three smallest vertices as the base triangle.
+                        if d <= c {
+                            continue;
+                        }
+                        let clique = [a, b, c, d, e];
+                        for &u in &clique {
+                            let terms = clique
+                                .iter()
+                                .filter(|&&v| v != u)
+                                .map(|&v| (edge_indices[&(u.min(v), u.max(v))], 1))
+                                .collect();
+                            constraints.push(LinearConstraint::eq(terms, 2));
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(ReductionMonochromaticTriangleToILP {
             target: ILP::new(
                 self.num_edges(),
                 constraints,
                 vec![],
                 ObjectiveSense::Minimize,
-            ),
-        }
+            )
+            .map_err(Self::target_construction)?,
+        })
     }
 }
 
diff --git a/src/rules/multiplechoicebranching_ilp.rs b/src/rules/multiplechoicebranching_ilp.rs
new file mode 100644
index 000000000..cba6f76cd
--- /dev/null
+++ b/src/rules/multiplechoicebranching_ilp.rs
@@ -0,0 +1,127 @@
+//! Reduction from MultipleChoiceBranching with integer weights to integer ILP.
+
+use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::models::graph::MultipleChoiceBranching;
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+
+#[derive(Debug, Clone)]
+pub struct ReductionMultipleChoiceBranchingToILP {
+    target: ILP<i64>,
+    num_arcs: usize,
+}
+
+impl ReductionResult for ReductionMultipleChoiceBranchingToILP {
+    type Source = MultipleChoiceBranching<i64>;
+    type Target = ILP<i64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        Ok(target_solution[..self.num_arcs]
+            .iter()
+            .map(|&selected| selected == 1)
+            .collect())
+    }
+}
+
+#[reduction(
+    transform = exact {
+        num_vars = "num_arcs + num_vertices",
+        num_constraints = "2 * num_arcs + 2 * num_vertices + num_partition_groups + 1",
+    },
+    unavailable = {
+        num_nonzeros = "zero weights and loop normalization determine the exact nonzero count",
+    }
+)]
+impl ReduceTo<ILP<i64>> for MultipleChoiceBranching<i64> {
+    type Result = ReductionMultipleChoiceBranchingToILP;
+
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let num_arcs = self.num_arcs();
+        let num_vertices = self.num_vertices();
+        let order = |vertex: usize| num_arcs + vertex;
+        let mut constraints = Vec::new();
+
+        for arc in 0..num_arcs {
+            constraints.push(LinearConstraint::le(vec![(arc, 1)], 1));
+        }
+        if num_vertices > 0 {
+            let big_m = <Self as ReduceTo<ILP<i64>>>::exact_i64(
+                num_vertices,
+                "encoding topological-order constraints",
+            )?;
+            for vertex in 0..num_vertices {
+                constraints.push(LinearConstraint::le(vec![(order(vertex), 1)], big_m - 1));
+            }
+            for (arc, &(source, target)) in self.graph().arcs().iter().enumerate() {
+                constraints.push(LinearConstraint::le(
+                    vec![(order(source), 1), (order(target), -1), (arc, big_m)],
+                    big_m - 1,
+                ));
+            }
+        }
+        for group in self.partition() {
+            constraints.push(LinearConstraint::le(
+                group.iter().map(|&arc| (arc, 1)).collect(),
+                1,
+            ));
+        }
+        for vertex in 0..num_vertices {
+            constraints.push(LinearConstraint::le(
+                self.graph()
+                    .arcs()
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(arc, &(_, target))| (target == vertex).then_some((arc, 1)))
+                    .collect(),
+                1,
+            ));
+        }
+        constraints.push(LinearConstraint::ge(
+            self.weights()
+                .iter()
+                .enumerate()
+                .map(|(arc, &weight)| (arc, weight))
+                .collect(),
+            *self.threshold(),
+        ));
+
+        let target = ILP::new(
+            num_arcs + num_vertices,
+            constraints,
+            vec![],
+            ObjectiveSense::Minimize,
+        )
+        .map_err(<Self as ReduceTo<ILP<i64>>>::target_construction)?;
+        Ok(ReductionMultipleChoiceBranchingToILP { target, num_arcs })
+    }
+}
+
+#[cfg(feature = "example-db")]
+pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
+    use crate::topology::DirectedGraph;
+
+    vec![crate::example_db::specs::RuleExampleSpec {
+        id: "multiplechoicebranching_to_ilp",
+        build: || {
+            let source = MultipleChoiceBranching::new(
+                DirectedGraph::new(3, vec![(0, 1), (1, 2)]),
+                vec![2, 3],
+                vec![vec![0], vec![1]],
+                5,
+            );
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/multiplechoicebranching_ilp.rs"]
+mod tests;
diff --git a/src/rules/multiplecopyfileallocation_ilp.rs b/src/rules/multiplecopyfileallocation_ilp.rs
index 1852fb2a6..335aa7a91 100644
--- a/src/rules/multiplecopyfileallocation_ilp.rs
+++ b/src/rules/multiplecopyfileallocation_ilp.rs
@@ -36,8 +36,16 @@ impl ReductionResult for ReductionMCFAToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_vertices]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
@@ -61,36 +69,24 @@ fn bfs_distances(graph: &SimpleGraph, source: usize, n: usize) -> Vec<i64> {
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices + num_vertices^2",
         num_constraints = "num_vertices^2 + num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MultipleCopyFileAllocation {
     type Result = ReductionMCFAToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let num_vars = n + n * n;
-        // Big-M penalty for unreachable pairs: use a value larger than any feasible
-        // total cost to make unreachable assignments infeasible.
-        let total_storage: i64 = self.storage().iter().sum();
-        let total_usage: i64 = self.usage().iter().sum();
-        let big_m = total_storage + total_usage * n as i64 + 1;
-
-        // Precompute all-pairs shortest-path distances using BFS.
+        // Precompute all-pairs shortest-path distances using BFS. A negative
+        // distance marks an unreachable pair and is prohibited below.
         let all_dist: Vec<Vec<i64>> = (0..n).map(|s| bfs_distances(self.graph(), s, n)).collect();
 
-        // Effective distance from v to u: use big_m when unreachable.
-        let eff_dist = |v: usize, u: usize| -> i64 {
-            let d = all_dist[u][v]; // distance from v to u = BFS from u, query v
-            if d < 0 {
-                big_m
-            } else {
-                d
-            }
-        };
-
         // Index helpers.
         let x_var = |v: usize| v;
         let y_var = |v: usize, u: usize| n + v * n + u;
@@ -99,43 +95,56 @@ impl ReduceTo<ILP<bool>> for MultipleCopyFileAllocation {
 
         // Assignment constraints: ∀v: Σ_u y_{v,u} = 1
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|u| (y_var(v, u), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|u| (y_var(v, u), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
-        // Capacity link constraints: ∀v,u: y_{v,u} ≤ x_u  →  y_{v,u} - x_u ≤ 0
-        for v in 0..n {
-            for u in 0..n {
-                constraints.push(LinearConstraint::le(
-                    vec![(y_var(v, u), 1.0), (x_var(u), -1.0)],
-                    0.0,
-                ));
+        // Reachable assignments require a selected copy. Unreachable
+        // assignments are forbidden exactly rather than discouraged by a cost.
+        for (u, distances_from_u) in all_dist.iter().enumerate() {
+            for (v, &distance) in distances_from_u.iter().enumerate() {
+                if distance < 0 {
+                    constraints.push(LinearConstraint::eq(vec![(y_var(v, u), 1)], 0));
+                } else {
+                    constraints.push(LinearConstraint::le(
+                        vec![(y_var(v, u), 1), (x_var(u), -1)],
+                        0,
+                    ));
+                }
             }
         }
 
         // Objective: minimize Σ_v s(v)·x_v + Σ_{v,u} usage(v)·dist(v,u)·y_{v,u}
-        let mut objective: Vec<(usize, f64)> = Vec::with_capacity(num_vars);
+        let mut objective: Vec<(usize, i64)> = Vec::with_capacity(num_vars);
         for v in 0..n {
-            let sc = self.storage()[v] as f64;
-            if sc != 0.0 {
+            let sc = self.storage()[v];
+            if sc != 0 {
                 objective.push((x_var(v), sc));
             }
         }
-        for v in 0..n {
-            let u_v = self.usage()[v] as f64;
-            for u in 0..n {
-                let coeff = u_v * eff_dist(v, u) as f64;
-                if coeff != 0.0 {
-                    objective.push((y_var(v, u), coeff));
+        for (u, distances_from_u) in all_dist.iter().enumerate() {
+            for (v, &distance) in distances_from_u.iter().enumerate() {
+                if distance < 0 {
+                    continue;
+                }
+                let service_cost = self.usage()[v].checked_mul(distance).ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<
+                        MultipleCopyFileAllocation,
+                        ILP<bool>,
+                    >("multiplying usage by service distance")
+                })?;
+                if service_cost != 0 {
+                    objective.push((y_var(v, u), service_cost));
                 }
             }
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
-        ReductionMCFAToILP {
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionMCFAToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
diff --git a/src/rules/multiprocessorscheduling_ilp.rs b/src/rules/multiprocessorscheduling_ilp.rs
index f96d7ff4d..c3d8ed3cd 100644
--- a/src/rules/multiprocessorscheduling_ilp.rs
+++ b/src/rules/multiprocessorscheduling_ilp.rs
@@ -33,58 +33,66 @@ impl ReductionResult for ReductionMSToILP {
     }
 
     /// Extract solution: for each task j, find the unique processor p where x_{j,p} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_processors = self.num_processors;
-        (0..self.num_tasks)
-            .map(|j| {
-                (0..num_processors)
-                    .find(|&p| target_solution[j * num_processors + p] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_tasks,
+            self.num_processors,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_tasks * num_processors",
         num_constraints = "num_tasks + num_processors",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for MultiprocessorScheduling {
     type Result = ReductionMSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_tasks = self.num_tasks();
         let num_processors = self.num_processors();
         let num_vars = num_tasks * num_processors;
+        let lengths = self.lengths();
+        let deadline = self.deadline();
 
         let mut constraints = Vec::with_capacity(num_tasks + num_processors);
 
         // Assignment constraints: for each task j, Σ_p x_{j,p} = 1
         for j in 0..num_tasks {
-            let terms: Vec<(usize, f64)> = (0..num_processors)
-                .map(|p| (j * num_processors + p, 1.0))
+            let terms: Vec<(usize, i64)> = (0..num_processors)
+                .map(|p| (j * num_processors + p, 1))
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Load constraints: for each processor p, Σ_j len_j * x_{j,p} ≤ deadline
-        let deadline = self.deadline() as f64;
         for p in 0..num_processors {
-            let terms: Vec<(usize, f64)> = (0..num_tasks)
-                .map(|j| (j * num_processors + p, self.lengths()[j] as f64))
+            let terms: Vec<(usize, i64)> = (0..num_tasks)
+                .map(|j| (j * num_processors + p, lengths[j]))
                 .collect();
             constraints.push(LinearConstraint::le(terms, deadline));
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionMSToILP {
+        Ok(ReductionMSToILP {
             target,
             num_tasks,
             num_processors,
-        }
+        })
     }
 }
 
diff --git a/src/rules/naesatisfiability_ilp.rs b/src/rules/naesatisfiability_ilp.rs
index 382fa58f5..1c57fc3a5 100644
--- a/src/rules/naesatisfiability_ilp.rs
+++ b/src/rules/naesatisfiability_ilp.rs
@@ -26,55 +26,63 @@ impl ReductionResult for ReductionNAESATToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vars",
         num_constraints = "2 * num_clauses",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for NAESatisfiability {
     type Result = ReductionNAESATToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.num_vars();
         let mut constraints = Vec::new();
 
         for clause in self.clauses() {
             let clause_size = clause.len();
-            let mut terms: Vec<(usize, f64)> = Vec::with_capacity(clause_size);
-            let mut neg_count: f64 = 0.0;
+            let mut terms: Vec<(usize, i64)> = Vec::with_capacity(clause_size);
+            let clause_size =
+                <Self as ReduceTo<ILP<bool>>>::exact_i64(clause_size, "encoding a clause size")?;
+            let mut neg_count: i64 = 0;
 
             for &lit in &clause.literals {
                 // Variables are 1-indexed in CNFClause literals.
                 let var_idx = lit.unsigned_abs() as usize - 1;
                 if lit > 0 {
                     // Positive literal x_i: coefficient +1
-                    terms.push((var_idx, 1.0));
+                    terms.push((var_idx, 1));
                 } else {
                     // Negative literal ¬x_i: substitute (1 - x_i), so coefficient -1
                     // and adjust rhs by -1 (accumulated in neg_count).
-                    terms.push((var_idx, -1.0));
-                    neg_count += 1.0;
+                    terms.push((var_idx, -1));
+                    neg_count += 1;
                 }
             }
 
             // At least one literal is true: Σ coeff_i * x_i ≥ 1 - neg_count
-            constraints.push(LinearConstraint::ge(terms.clone(), 1.0 - neg_count));
+            constraints.push(LinearConstraint::ge(terms.clone(), 1 - neg_count));
 
             // At least one literal is false: Σ coeff_i * x_i ≤ |C| - 1 - neg_count
-            constraints.push(LinearConstraint::le(
-                terms,
-                clause_size as f64 - 1.0 - neg_count,
-            ));
+            constraints.push(LinearConstraint::le(terms, clause_size - 1 - neg_count));
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionNAESATToILP { target }
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
+        Ok(ReductionNAESATToILP { target })
     }
 }
 
diff --git a/src/rules/naesatisfiability_maxcut.rs b/src/rules/naesatisfiability_maxcut.rs
index 5bdda85d9..55e8e81c7 100644
--- a/src/rules/naesatisfiability_maxcut.rs
+++ b/src/rules/naesatisfiability_maxcut.rs
@@ -1,14 +1,15 @@
 //! Reduction from NAESatisfiability to MaxCut.
 //!
-//! Classical reduction from Not-All-Equal SAT to Maximum Cut (Karp 1972,
-//! Garey & Johnson ND16). For each variable x_i, create two vertices
-//! (positive literal 2i, negative literal 2i+1) connected by a heavy
-//! "variable edge" of weight M = m+1 where m is the number of clauses.
-//! For each clause, add weight-1 edges between all pairs of literal vertices
-//! in that clause. An optimal max-cut of value n*M + sum(k_j - 1) exists
-//! if and only if the NAE-SAT formula is satisfiable.
+//! Long NAE clauses are first expanded into a chain of ternary clauses with
+//! fresh variables. Binary clauses contribute one unit edge, ternary clauses
+//! contribute a unit triangle. A positive-weight edge separates each variable
+//! from its negation. A cut certifies a source witness exactly when it attains
+//! the sum of these componentwise upper bounds.
 //!
-//! Reference: Garey & Johnson, *Computers and Intractability*, ND16, p.210
+//! The NAE clause-chain construction is described by Jackson,
+//! "Flexible constraint satisfiability and a problem in semigroup theory",
+//! Section 4, arXiv:1512.03127. The triangle construction is the classical
+//! NAE-3SAT to MaxCut reduction (Garey and Johnson, ND16).
 
 use crate::models::formula::NAESatisfiability;
 use crate::models::graph::MaxCut;
@@ -19,13 +20,14 @@ use crate::topology::SimpleGraph;
 /// Result of reducing NAESatisfiability to MaxCut.
 #[derive(Debug, Clone)]
 pub struct ReductionNAESATToMaxCut {
-    target: MaxCut<SimpleGraph, i32>,
+    target: MaxCut<SimpleGraph, i64>,
     source_num_vars: usize,
+    feasible_cut: i64,
 }
 
 impl ReductionResult for ReductionNAESATToMaxCut {
     type Source = NAESatisfiability;
-    type Target = MaxCut<SimpleGraph, i32>;
+    type Target = MaxCut<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
@@ -36,69 +38,172 @@ impl ReductionResult for ReductionNAESATToMaxCut {
     /// Variable x_i is assigned based on vertex 2*i: if it is in set 0
     /// (config[2*i] == 0), set x_i = false (config value 0); if in set 1,
     /// set x_i = true (config value 1).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.source_num_vars)
-            .map(|i| target_solution[2 * i])
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target cut does not certify a satisfying NAE assignment",
+            ));
+        }
+
+        Ok({
+            (0..self.source_num_vars)
+                .map(|i| target_solution[2 * i])
+                .collect()
+        })
+    }
+}
+
+impl crate::rules::AggregateReductionResult for ReductionNAESATToMaxCut {
+    type Source = NAESatisfiability;
+    type Target = MaxCut<SimpleGraph, i64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, value: crate::types::Max<i64>) -> crate::types::Or {
+        crate::types::Or(value.0 == Some(self.feasible_cut))
     }
 }
 
-/// Map a literal to its vertex index.
-///
-/// Positive literal l (l > 0): vertex 2*(l-1)
-/// Negative literal l (l < 0): vertex 2*((-l)-1) + 1
-fn literal_vertex(lit: i32) -> usize {
-    let var_idx = lit.unsigned_abs() as usize - 1;
-    if lit > 0 {
-        2 * var_idx
-    } else {
-        2 * var_idx + 1
+/// Dimensions, variable-edge weight, and certificate for legal clause lengths.
+fn nae_maxcut_parameters(
+    n: usize,
+    lengths: impl ExactSizeIterator<Item = usize>,
+) -> Result<(usize, usize, i64, i64), crate::rules::ReductionError> {
+    let overflow = |operation| {
+        crate::rules::ReductionError::integer_overflow::<NAESatisfiability, MaxCut<SimpleGraph, i64>>(
+            operation,
+        )
+    };
+    let weight = i64::try_from(lengths.len())
+        .ok()
+        .and_then(|m| m.checked_add(1))
+        .ok_or_else(|| overflow("computing the variable-edge weight"))?;
+    let mut variables = n;
+    let mut clause_edges = 0usize;
+    let mut clause_cap = 0usize;
+    for length in lengths {
+        // Source construction guarantees length >= 2.
+        let (auxiliary, edges, cap) = if length == 2 {
+            (0, 1, 1)
+        } else {
+            let triangles = length - 2;
+            (
+                length - 3,
+                triangles
+                    .checked_mul(3)
+                    .ok_or_else(|| overflow("counting clause edges"))?,
+                triangles
+                    .checked_mul(2)
+                    .ok_or_else(|| overflow("counting clause cut capacity"))?,
+            )
+        };
+        variables = variables
+            .checked_add(auxiliary)
+            .ok_or_else(|| overflow("counting auxiliary variables"))?;
+        clause_edges = clause_edges
+            .checked_add(edges)
+            .ok_or_else(|| overflow("counting all clause edges"))?;
+        clause_cap = clause_cap
+            .checked_add(cap)
+            .ok_or_else(|| overflow("counting all clause cut capacities"))?;
     }
+    let vertices = variables
+        .checked_mul(2)
+        .ok_or_else(|| overflow("counting literal vertices"))?;
+    let edges = variables
+        .checked_add(clause_edges)
+        .ok_or_else(|| overflow("counting target edges"))?;
+    let variable_weight = i64::try_from(variables)
+        .ok()
+        .and_then(|q| q.checked_mul(weight))
+        .ok_or_else(|| overflow("summing variable-edge weights"))?;
+    // All weights are nonnegative: bounding their total bounds every cut sum.
+    variable_weight
+        .checked_add(
+            i64::try_from(clause_edges).map_err(|_| overflow("converting clause-edge count"))?,
+        )
+        .ok_or_else(|| overflow("summing all target edge weights"))?;
+    let feasible_cut = variable_weight
+        .checked_add(
+            i64::try_from(clause_cap).map_err(|_| overflow("converting clause cut capacity"))?,
+        )
+        .ok_or_else(|| overflow("computing the NAE cut certificate"))?;
+    // SimpleGraph uses petgraph's default index domain for nodes and edges.
+    petgraph::graph::DefaultIx::try_from(vertices)
+        .map_err(|_| overflow("representing target vertex indices"))?;
+    petgraph::graph::DefaultIx::try_from(edges)
+        .map_err(|_| overflow("representing target edge indices"))?;
+    Ok((vertices, edges, weight, feasible_cut))
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "2 * num_vars",
-        num_edges = "num_vars + num_literal_pairs",
+    aggregate = custom,
+    transform = upper_bound {
+        num_vertices = "2 * (num_vars + num_literals - 2 * num_clauses)",
+        num_edges = "num_vars + 4 * num_literals - 7 * num_clauses",
     }
 )]
-impl ReduceTo<MaxCut<SimpleGraph, i32>> for NAESatisfiability {
+impl ReduceTo<MaxCut<SimpleGraph, i64>> for NAESatisfiability {
     type Result = ReductionNAESATToMaxCut;
 
-    fn reduce_to(&self) -> Self::Result {
-        let n = self.num_vars();
-        let m = self.num_clauses();
-        let total_vertices = 2 * n;
-        let big_m = (m + 1) as i32;
-
-        let mut edges: Vec<(usize, usize)> = Vec::new();
-        let mut weights: Vec<i32> = Vec::new();
-
-        // Step 1: Variable edges — connect (2*i, 2*i+1) with weight M = m+1
-        for i in 0..n {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let (total_vertices, total_edges, weight, feasible_cut) =
+            nae_maxcut_parameters(self.num_vars(), self.clauses().iter().map(|c| c.len()))?;
+        let total_variables = total_vertices / 2;
+        let mut edges = Vec::with_capacity(total_edges);
+        let mut weights = Vec::with_capacity(total_edges);
+        for i in 0..total_variables {
             edges.push((2 * i, 2 * i + 1));
-            weights.push(big_m);
+            weights.push(weight);
         }
 
-        // Step 2: Clause edges — for each clause, add weight-1 edges between
-        // all pairs of literal vertices
+        let mut next_auxiliary = self.num_vars();
         for clause in self.clauses() {
-            let lits = &clause.literals;
-            for a in 0..lits.len() {
-                for b in (a + 1)..lits.len() {
-                    edges.push((literal_vertex(lits[a]), literal_vertex(lits[b])));
-                    weights.push(1);
+            let literals: Vec<_> = clause
+                .literals
+                .iter()
+                .map(|&literal| {
+                    let index = usize::try_from(literal.unsigned_abs()).map_err(|_| {
+                        crate::rules::ReductionError::integer_overflow::<
+                            NAESatisfiability,
+                            MaxCut<SimpleGraph, i64>,
+                        >("converting a literal index")
+                    })? - 1;
+                    // Validated literals are in 1..=n, and 2*total_variables was checked.
+                    Ok(2 * index + usize::from(literal < 0))
+                })
+                .collect::<Result<_, crate::rules::ReductionError>>()?;
+            if literals.len() == 2 {
+                edges.push((literals[0], literals[1]));
+                weights.push(1);
+            } else {
+                let mut first = literals[0];
+                for &middle in &literals[1..literals.len() - 2] {
+                    let auxiliary = 2 * next_auxiliary;
+                    next_auxiliary += 1;
+                    edges.extend([(first, middle), (first, auxiliary), (middle, auxiliary)]);
+                    weights.extend([1; 3]);
+                    first = auxiliary + 1;
                 }
+                let second = literals[literals.len() - 2];
+                let third = literals[literals.len() - 1];
+                edges.extend([(first, second), (first, third), (second, third)]);
+                weights.extend([1; 3]);
             }
         }
 
-        let graph = SimpleGraph::new(total_vertices, edges);
-        let target = MaxCut::new(graph, weights);
-
-        ReductionNAESATToMaxCut {
-            target,
-            source_num_vars: n,
-        }
+        Ok(ReductionNAESATToMaxCut {
+            target: MaxCut::new(SimpleGraph::new(total_vertices, edges), weights),
+            source_num_vars: self.num_vars(),
+            feasible_cut,
+        })
     }
 }
 
@@ -121,17 +226,17 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     CNFClause::new(vec![-1, 3, 2]),
                 ],
             );
-            crate::example_db::specs::rule_example_with_witness::<_, MaxCut<SimpleGraph, i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, MaxCut<SimpleGraph, i64>>(
                 source,
                 SolutionPair {
                     // x1=T(1), x2=F(0), x3=T(1)
-                    source_config: vec![1, 0, 1],
+                    source_config: serde_json::json!(vec![true, false, true]),
                     // Vertices: x1(0)=1, ~x1(1)=0, x2(2)=0, ~x2(3)=1, x3(4)=1, ~x3(5)=0
                     // All variable edges cross (weight M=3 each) -> 3*3=9
                     // C1=(x1,x2,~x3): vertices 0,2,5 -> sides {1},{0,0} -> edges (0,2) crosses, (0,5) crosses, (2,5) doesn't -> +2
                     // C2=(~x1,x3,x2): vertices 1,4,2 -> sides {0},{1,0} -> edges (1,4) crosses, (1,2) doesn't, (4,2) crosses -> +2
                     // Total = 9 + 2 + 2 = 13
-                    target_config: vec![1, 0, 0, 1, 1, 0],
+                    target_config: serde_json::json!(vec![true, false, false, true, true, false]),
                 },
             )
         },
diff --git a/src/rules/naesatisfiability_partitionintoperfectmatchings.rs b/src/rules/naesatisfiability_partitionintoperfectmatchings.rs
index 43f363de1..c7a09e983 100644
--- a/src/rules/naesatisfiability_partitionintoperfectmatchings.rs
+++ b/src/rules/naesatisfiability_partitionintoperfectmatchings.rs
@@ -26,7 +26,7 @@ struct SignalVertices {
 
 #[derive(Debug, Clone)]
 struct ClauseLayout {
-    literals: [i32; 3],
+    literals: [i64; 3],
     signals: [SignalVertices; 3],
     clause_vertices: [usize; 4],
 }
@@ -65,18 +65,25 @@ impl ReductionResult for ReductionNAESATToPartitionIntoPerfectMatchings {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.layout
-            .variables
-            .iter()
-            .map(|variable| usize::from(target_solution[variable.t] == 0))
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            self.layout
+                .variables
+                .iter()
+                .map(|variable| target_solution[variable.t] == 0)
+                .collect()
+        })
     }
 }
 
 impl ReductionNAESATToPartitionIntoPerfectMatchings {
     #[cfg(any(test, feature = "example-db"))]
-    fn construct_target_solution(&self, source_solution: &[usize]) -> Vec<usize> {
+    fn construct_target_solution(&self, source_solution: &[bool]) -> Vec<usize> {
         assert_eq!(
             source_solution.len(),
             self.layout.variables.len(),
@@ -90,7 +97,7 @@ impl ReductionNAESATToPartitionIntoPerfectMatchings {
         let mut false_groups = Vec::with_capacity(self.layout.variables.len());
 
         for (index, variable) in self.layout.variables.iter().enumerate() {
-            let true_group = if source_solution[index] == 1 { 0 } else { 1 };
+            let true_group = if source_solution[index] { 0 } else { 1 };
             let false_group = 1 - true_group;
             true_groups.push(true_group);
             false_groups.push(false_group);
@@ -157,24 +164,29 @@ impl ReductionNAESATToPartitionIntoPerfectMatchings {
     }
 }
 
-fn normalize_clauses(problem: &NAESatisfiability) -> Vec<[i32; 3]> {
+fn normalize_clauses(
+    problem: &NAESatisfiability,
+) -> Result<Vec<[i64; 3]>, crate::registry::ConstructionError> {
     problem
         .clauses()
         .iter()
         .map(|clause| match clause.literals.as_slice() {
-            [a, b] => [*a, *a, *b],
-            [a, b, c] => [*a, *b, *c],
-            literals => panic!(
-                "NAESatisfiability -> PartitionIntoPerfectMatchings expects clauses of size 2 or 3, got {}",
+            [a, b] => Ok([*a, *a, *b]),
+            [a, b, c] => Ok([*a, *b, *c]),
+            literals => Err(format!(
+                "the construction expects clauses of size 2 or 3, got {}",
                 literals.len()
-            ),
+            )
+            .into()),
         })
         .collect()
 }
 
-fn build_layout(problem: &NAESatisfiability) -> ReductionLayout {
+fn build_layout(
+    problem: &NAESatisfiability,
+) -> Result<ReductionLayout, crate::registry::ConstructionError> {
     let num_vars = problem.num_vars();
-    let clauses = normalize_clauses(problem);
+    let clauses = normalize_clauses(problem)?;
     let num_clauses = clauses.len();
 
     let mut next_vertex = 0usize;
@@ -286,7 +298,7 @@ fn build_layout(problem: &NAESatisfiability) -> ReductionLayout {
         }
     }
 
-    ReductionLayout {
+    Ok(ReductionLayout {
         variables,
         #[cfg(any(test, feature = "example-db"))]
         clauses: clause_layouts,
@@ -296,11 +308,11 @@ fn build_layout(problem: &NAESatisfiability) -> ReductionLayout {
         negative_chains,
         num_vertices: next_vertex,
         edges,
-    }
+    })
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "4 * num_vars + 16 * num_clauses",
         num_edges = "3 * num_vars + 21 * num_clauses",
         num_matchings = "2",
@@ -309,14 +321,19 @@ fn build_layout(problem: &NAESatisfiability) -> ReductionLayout {
 impl ReduceTo<PartitionIntoPerfectMatchings<SimpleGraph>> for NAESatisfiability {
     type Result = ReductionNAESATToPartitionIntoPerfectMatchings;
 
-    fn reduce_to(&self) -> Self::Result {
-        let layout = build_layout(self);
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let layout = build_layout(self).map_err(|message| {
+            crate::rules::ReductionError::invalid_target::<
+                NAESatisfiability,
+                PartitionIntoPerfectMatchings<SimpleGraph>,
+            >(message.to_string())
+        })?;
         let target = PartitionIntoPerfectMatchings::new(
             SimpleGraph::new(layout.num_vertices, layout.edges.clone()),
             2,
         );
 
-        ReductionNAESATToPartitionIntoPerfectMatchings { target, layout }
+        Ok(ReductionNAESATToPartitionIntoPerfectMatchings { target, layout })
     }
 }
 
@@ -335,17 +352,20 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     CNFClause::new(vec![-1, 2, -3]),
                 ],
             );
-            let source_config = vec![1, 1, 0];
+            let source_config = vec![true, true, false];
             let reduction =
-                ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source);
+                ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source)
+                    .expect("reduction should succeed");
             let target_config = reduction.construct_target_solution(&source_config);
 
             crate::example_db::specs::assemble_rule_example(
                 &source,
                 reduction.target_problem(),
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/naesatisfiability_setsplitting.rs b/src/rules/naesatisfiability_setsplitting.rs
index f27732a6a..854e7ed69 100644
--- a/src/rules/naesatisfiability_setsplitting.rs
+++ b/src/rules/naesatisfiability_setsplitting.rs
@@ -25,18 +25,17 @@ impl ReductionResult for ReductionNAESATToSetSplitting {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        assert!(
-            target_solution.len() >= self.num_source_variables,
-            "SetSplitting solution has {} variables but source requires {}",
-            target_solution.len(),
-            self.num_source_variables,
-        );
-        target_solution[..self.num_source_variables].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_source_variables].to_vec())
     }
 }
 
-fn literal_element_index(lit: i32, num_vars: usize) -> usize {
+fn literal_element_index(lit: i64, num_vars: usize) -> usize {
     let var_index = lit.unsigned_abs() as usize - 1;
     if lit > 0 {
         var_index
@@ -46,7 +45,7 @@ fn literal_element_index(lit: i32, num_vars: usize) -> usize {
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         universe_size = "2 * num_vars",
         num_subsets = "num_vars + num_clauses",
     }
@@ -54,7 +53,7 @@ fn literal_element_index(lit: i32, num_vars: usize) -> usize {
 impl ReduceTo<SetSplitting> for NAESatisfiability {
     type Result = ReductionNAESATToSetSplitting;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.num_vars();
         let mut subsets = Vec::with_capacity(num_vars + self.num_clauses());
 
@@ -72,10 +71,10 @@ impl ReduceTo<SetSplitting> for NAESatisfiability {
             );
         }
 
-        ReductionNAESATToSetSplitting {
+        Ok(ReductionNAESATToSetSplitting {
             target: SetSplitting::new(2 * num_vars, subsets),
             num_source_variables: num_vars,
-        }
+        })
     }
 }
 
@@ -96,8 +95,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     ],
                 ),
                 SolutionPair {
-                    source_config: vec![1, 1, 1],
-                    target_config: vec![1, 1, 1, 0, 0, 0],
+                    source_config: serde_json::json!(vec![true, true, true]),
+                    target_config: serde_json::json!(vec![true, true, true, false, false, false]),
                 },
             )
         },
diff --git a/src/rules/numerical3dimensionalmatching_numericalmatchingwithtargetsums.rs b/src/rules/numerical3dimensionalmatching_numericalmatchingwithtargetsums.rs
index 3177b1f93..30729b498 100644
--- a/src/rules/numerical3dimensionalmatching_numericalmatchingwithtargetsums.rs
+++ b/src/rules/numerical3dimensionalmatching_numericalmatchingwithtargetsums.rs
@@ -14,8 +14,8 @@ use std::collections::BTreeMap;
 #[derive(Debug, Clone)]
 pub struct ReductionN3DMToNMTS {
     target: NumericalMatchingWithTargetSums,
-    source_sizes_w: Vec<u64>,
-    source_bound: u64,
+    source_sizes_w: Vec<i64>,
+    source_bound: i64,
 }
 
 impl ReductionResult for ReductionN3DMToNMTS {
@@ -26,80 +26,87 @@ impl ReductionResult for ReductionN3DMToNMTS {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let mut x_indices_by_pair_sum: BTreeMap<i64, Vec<usize>> = BTreeMap::new();
-        for (x_index, &y_index) in target_solution.iter().enumerate() {
-            let pair_sum = self.target.sizes_x()[x_index]
-                .checked_add(self.target.sizes_y()[y_index])
-                .expect("NMTS witness must not overflow i64 pair sums");
-            x_indices_by_pair_sum
-                .entry(pair_sum)
-                .or_default()
-                .push(x_index);
-        }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
-        let mut x_perm = Vec::with_capacity(self.source_sizes_w.len());
-        let mut y_perm = Vec::with_capacity(self.source_sizes_w.len());
-        for &w_size in &self.source_sizes_w {
-            let target_sum = checked_target_sum_to_i64(self.source_bound, w_size);
-            let x_index = x_indices_by_pair_sum
-                .get_mut(&target_sum)
-                .and_then(Vec::pop)
-                .expect("satisfying NMTS witness must realize every target complement");
-            x_perm.push(x_index);
-            y_perm.push(target_solution[x_index]);
-        }
+        Ok({
+            let mut x_indices_by_pair_sum: BTreeMap<i64, Vec<usize>> = BTreeMap::new();
+            for (x_index, &y_index) in target_solution.iter().enumerate() {
+                let pair_sum = self.target.sizes_x()[x_index]
+                    .checked_add(self.target.sizes_y()[y_index])
+                    .ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid(
+                            "target pair sum overflows the target numeric domain",
+                        )
+                    })?;
+                x_indices_by_pair_sum
+                    .entry(pair_sum)
+                    .or_default()
+                    .push(x_index);
+            }
 
-        x_perm.extend(y_perm);
-        x_perm
-    }
-}
+            let mut x_perm = Vec::with_capacity(self.source_sizes_w.len());
+            let mut y_perm = Vec::with_capacity(self.source_sizes_w.len());
+            for &w_size in &self.source_sizes_w {
+                let target_sum = checked_target_sum(self.source_bound, w_size)
+                    .map_err(crate::rules::ExtractionError::invalid)?;
+                let x_index = x_indices_by_pair_sum
+                    .get_mut(&target_sum)
+                    .and_then(Vec::pop)
+                    .ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid(format!(
+                            "target matching does not realize required pair sum {target_sum}"
+                        ))
+                    })?;
+                x_perm.push(x_index);
+                y_perm.push(target_solution[x_index]);
+            }
 
-fn checked_size_to_i64(size: u64) -> i64 {
-    i64::try_from(size).expect(
-        "Numerical3DimensionalMatching -> NumericalMatchingWithTargetSums requires X/Y sizes to fit in i64",
-    )
+            x_perm.extend(y_perm);
+            x_perm
+        })
+    }
 }
 
-fn checked_target_sum_to_i64(bound: u64, w_size: u64) -> i64 {
-    let target_sum = bound
+fn checked_target_sum(bound: i64, w_size: i64) -> Result<i64, &'static str> {
+    bound
         .checked_sub(w_size)
-        .expect("N3DM invariants require each w_i to be strictly smaller than B");
-    i64::try_from(target_sum).expect(
-        "Numerical3DimensionalMatching -> NumericalMatchingWithTargetSums requires each complement B - s(w_i) to fit in i64",
-    )
+        .ok_or("computing a derived target sum overflowed")
 }
 
-#[reduction(overhead = {
-    num_pairs = "num_groups",
-})]
+#[reduction(
+    transform = exact {
+        num_pairs = "num_groups",
+    })]
 impl ReduceTo<NumericalMatchingWithTargetSums> for Numerical3DimensionalMatching {
     type Result = ReductionN3DMToNMTS;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let map_error = |message| {
+            crate::rules::ReductionError::invalid_target::<
+                Numerical3DimensionalMatching,
+                NumericalMatchingWithTargetSums,
+            >(message)
+        };
         let target = NumericalMatchingWithTargetSums::new(
-            self.sizes_x()
-                .iter()
-                .copied()
-                .map(checked_size_to_i64)
-                .collect(),
-            self.sizes_y()
-                .iter()
-                .copied()
-                .map(checked_size_to_i64)
-                .collect(),
+            self.sizes_x().to_vec(),
+            self.sizes_y().to_vec(),
             self.sizes_w()
                 .iter()
                 .copied()
-                .map(|w_size| checked_target_sum_to_i64(self.bound(), w_size))
-                .collect(),
+                .map(|w_size| checked_target_sum(self.bound(), w_size))
+                .collect::<Result<_, _>>()
+                .map_err(map_error)?,
         );
 
-        ReductionN3DMToNMTS {
+        Ok(ReductionN3DMToNMTS {
             target,
             source_sizes_w: self.sizes_w().to_vec(),
             source_bound: self.bound(),
-        }
+        })
     }
 }
 
@@ -113,8 +120,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, NumericalMatchingWithTargetSums>(
                 Numerical3DimensionalMatching::new(vec![4, 5], vec![4, 5], vec![5, 7], 15),
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0],
-                    target_config: vec![1, 0],
+                    source_config: serde_json::json!(vec![0, 1, 1, 0]),
+                    target_config: serde_json::json!(vec![1, 0]),
                 },
             )
         },
diff --git a/src/rules/numericalmatchingwithtargetsums_ilp.rs b/src/rules/numericalmatchingwithtargetsums_ilp.rs
index 17b7aeb03..3f658a8bf 100644
--- a/src/rules/numericalmatchingwithtargetsums_ilp.rs
+++ b/src/rules/numericalmatchingwithtargetsums_ilp.rs
@@ -44,27 +44,37 @@ impl ReductionResult for ReductionNMTSToILP {
     }
 
     /// Extract solution: for each x_i find the y_j it is paired with.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let mut assignment = vec![0usize; self.m];
-        for (var_idx, triple) in self.triples.iter().enumerate() {
-            if target_solution[var_idx] == 1 {
-                assignment[triple.i] = triple.j;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let mut assignment = vec![0usize; self.m];
+            for (var_idx, triple) in self.triples.iter().enumerate() {
+                if target_solution[var_idx] == 1 {
+                    assignment[triple.i] = triple.j;
+                }
             }
-        }
-        assignment
+            assignment
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_pairs * num_pairs * num_pairs",
         num_constraints = "3 * num_pairs",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for NumericalMatchingWithTargetSums {
     type Result = ReductionNMTSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.num_pairs();
         let sx = self.sizes_x();
         let sy = self.sizes_y();
@@ -87,40 +97,41 @@ impl ReduceTo<ILP<bool>> for NumericalMatchingWithTargetSums {
 
         // Each x_i in exactly one pair: Σ_{(i,j,k)} z_{i,j,k} = 1 for each i
         for i in 0..m {
-            let terms: Vec<(usize, f64)> = triples
+            let terms: Vec<(usize, i64)> = triples
                 .iter()
                 .enumerate()
                 .filter(|(_, t)| t.i == i)
-                .map(|(idx, _)| (idx, 1.0))
+                .map(|(idx, _)| (idx, 1))
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Each y_j in exactly one pair: Σ_{(i,j,k)} z_{i,j,k} = 1 for each j
         for j in 0..m {
-            let terms: Vec<(usize, f64)> = triples
+            let terms: Vec<(usize, i64)> = triples
                 .iter()
                 .enumerate()
                 .filter(|(_, t)| t.j == j)
-                .map(|(idx, _)| (idx, 1.0))
+                .map(|(idx, _)| (idx, 1))
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Each target k used exactly once: Σ_{(i,j,k)} z_{i,j,k} = 1 for each k
         for k in 0..m {
-            let terms: Vec<(usize, f64)> = triples
+            let terms: Vec<(usize, i64)> = triples
                 .iter()
                 .enumerate()
                 .filter(|(_, t)| t.k == k)
-                .map(|(idx, _)| (idx, 1.0))
+                .map(|(idx, _)| (idx, 1))
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionNMTSToILP { target, triples, m }
+        Ok(ReductionNMTSToILP { target, triples, m })
     }
 }
 
diff --git a/src/rules/openshopscheduling_ilp.rs b/src/rules/openshopscheduling_ilp.rs
index 7487c1b95..41f385661 100644
--- a/src/rules/openshopscheduling_ilp.rs
+++ b/src/rules/openshopscheduling_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from OpenShopScheduling to ILP<i32>.
+//! Reduction from OpenShopScheduling to `ILP<i64>`.
 //!
 //! Disjunctive formulation with binary ordering variables and integer start times:
 //!
@@ -31,7 +31,7 @@ use crate::models::misc::OpenShopScheduling;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing OpenShopScheduling to ILP<i32>.
+/// Result of reducing OpenShopScheduling to `ILP<i64>`.
 ///
 /// Variable layout:
 /// - `x_{j,k,i}` at index `pair_idx(j,k) * m + i`    (num_pairs * m vars)
@@ -41,7 +41,7 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// - `C`: at index `num_order_vars + n * m + n * m*(m-1)/2` (1 var)
 #[derive(Debug, Clone)]
 pub struct ReductionOSSToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_jobs: usize,
     num_machines: usize,
     /// n*(n-1)/2 * m — start index of s_{j,i} variables
@@ -80,43 +80,37 @@ impl ReductionOSSToILP {
 
 impl ReductionResult for ReductionOSSToILP {
     type Source = OpenShopScheduling;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    /// Extract per-machine job orderings from the ILP start times, then
-    /// convert to the config format (direct permutation indices per machine).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_jobs;
-        let m = self.num_machines;
-
-        // Read start times s_{j,i} for each (j, i)
-        let start = |j: usize, i: usize| -> usize {
-            let idx = self.num_order_vars + j * m + i;
-            target_solution.get(idx).copied().unwrap_or(0)
-        };
-
-        // For each machine, sort jobs by their start time on that machine
-        let mut config = Vec::with_capacity(n * m);
-        for i in 0..m {
-            let mut jobs: Vec<usize> = (0..n).collect();
-            jobs.sort_by_key(|&j| (start(j, i), j));
-            config.extend(jobs);
-        }
-        config
+    /// Extract the job-major operation start times from the ILP solution.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        let start = self.num_order_vars;
+        let end = start + self.num_jobs * self.num_machines;
+        crate::rules::ilp_helpers::decode_usize_values(&target_solution[start..end])
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_jobs * (num_jobs - 1) / 2 * num_machines + num_jobs * num_machines + num_jobs * num_machines * (num_machines - 1) / 2 + 1",
-    num_constraints = "num_jobs * (num_jobs - 1) / 2 * num_machines + num_jobs * num_machines + 1 + 2 * num_jobs * (num_jobs - 1) / 2 * num_machines + num_jobs * num_machines * (num_machines - 1) / 2 + 2 * num_jobs * num_machines * (num_machines - 1) / 2 + num_jobs * num_machines",
-})]
-impl ReduceTo<ILP<i32>> for OpenShopScheduling {
+#[reduction(
+    transform = exact {
+        num_vars = "num_jobs * (num_jobs - 1) / 2 * num_machines + num_jobs * num_machines + num_jobs * num_machines * (num_machines - 1) / 2 + 1",
+        num_constraints = "num_jobs * (num_jobs - 1) / 2 * num_machines + num_jobs * num_machines + 1 + 2 * num_jobs * (num_jobs - 1) / 2 * num_machines + num_jobs * num_machines * (num_machines - 1) / 2 + 2 * num_jobs * num_machines * (num_machines - 1) / 2 + num_jobs * num_machines",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<i64>> for OpenShopScheduling {
     type Result = ReductionOSSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_jobs();
         let m = self.num_machines();
         let p = self.processing_times();
@@ -131,15 +125,25 @@ impl ReduceTo<ILP<i32>> for OpenShopScheduling {
         let num_vars = num_order_vars + num_start_vars + num_job_pair_vars + 1; // +1 for C
 
         let result = ReductionOSSToILP {
-            target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize),
+            target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_jobs: n,
             num_machines: m,
             num_order_vars,
         };
 
         // Big-M: sum of all processing times (loose upper bound on makespan)
-        let total_p: usize = p.iter().flat_map(|row| row.iter()).sum();
-        let big_m = total_p as f64;
+        let total_p = p
+            .iter()
+            .flat_map(|row| row.iter())
+            .try_fold(0_i64, |total, &time| total.checked_add(time))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<OpenShopScheduling, ILP<i64>>(
+                    "summing open-shop processing times",
+                )
+            })?;
+        let big_m = total_p;
+        let processing_times = p;
 
         let c_var = num_order_vars + num_start_vars + num_job_pair_vars;
 
@@ -150,7 +154,7 @@ impl ReduceTo<ILP<i32>> for OpenShopScheduling {
             for k in (j + 1)..n {
                 for i in 0..m {
                     let x = result.x_var(j, k, i);
-                    constraints.push(LinearConstraint::le(vec![(x, 1.0)], 1.0));
+                    constraints.push(LinearConstraint::le(vec![(x, 1)], 1));
                 }
             }
         }
@@ -160,12 +164,12 @@ impl ReduceTo<ILP<i32>> for OpenShopScheduling {
         for j in 0..n {
             for i in 0..m {
                 let sji = result.s_var(j, i);
-                constraints.push(LinearConstraint::le(vec![(sji, 1.0)], big_m));
+                constraints.push(LinearConstraint::le(vec![(sji, 1)], big_m));
             }
         }
 
         // Upper bound on makespan C ≤ total_p
-        constraints.push(LinearConstraint::le(vec![(c_var, 1.0)], big_m));
+        constraints.push(LinearConstraint::le(vec![(c_var, 1)], big_m));
 
         // 2. Machine non-overlap: for each pair (j,k) with j<k, each machine i
         //    x_{j,k,i}=1 means j precedes k on machine i:
@@ -184,22 +188,23 @@ impl ReduceTo<ILP<i32>> for OpenShopScheduling {
         //      (b) s_{j,i} - s_{k,i} + M*x ≥ p_{k,i}
         for j in 0..n {
             for k in (j + 1)..n {
-                for (i, (&pji_val, &pki_val)) in p[j].iter().zip(p[k].iter()).enumerate() {
+                for (i, (&pji, &pki)) in processing_times[j]
+                    .iter()
+                    .zip(processing_times[k].iter())
+                    .enumerate()
+                {
                     let x = result.x_var(j, k, i);
                     let sj = result.s_var(j, i);
                     let sk = result.s_var(k, i);
-                    let pji = pji_val as f64;
-                    let pki = pki_val as f64;
-
                     // (a) s_{k,i} - s_{j,i} - M*x_{j,k,i} >= p_{j,i} - M
                     constraints.push(LinearConstraint::ge(
-                        vec![(sk, 1.0), (sj, -1.0), (x, -big_m)],
+                        vec![(sk, 1), (sj, -1), (x, -big_m)],
                         pji - big_m,
                     ));
 
                     // (b) s_{j,i} - s_{k,i} + M*x_{j,k,i} >= p_{k,i}
                     constraints.push(LinearConstraint::ge(
-                        vec![(sj, 1.0), (sk, -1.0), (x, big_m)],
+                        vec![(sj, 1), (sk, -1), (x, big_m)],
                         pki,
                     ));
                 }
@@ -211,7 +216,7 @@ impl ReduceTo<ILP<i32>> for OpenShopScheduling {
             for i in 0..m {
                 for ip in (i + 1)..m {
                     let y = result.y_var(j, i, ip);
-                    constraints.push(LinearConstraint::le(vec![(y, 1.0)], 1.0));
+                    constraints.push(LinearConstraint::le(vec![(y, 1)], 1));
                 }
             }
         }
@@ -222,24 +227,24 @@ impl ReduceTo<ILP<i32>> for OpenShopScheduling {
         //          s_{j,i'} - s_{j,i} - M*y ≥ p_{j,i} - M
         //      (b) s_{j,i} ≥ s_{j,i'} + p_{j,i'} - M*y
         //          s_{j,i} - s_{j,i'} + M*y ≥ p_{j,i'}
-        for (j, pj) in p.iter().enumerate() {
+        for (j, pj) in processing_times.iter().enumerate() {
             for i in 0..m {
                 for ip in (i + 1)..m {
                     let y = result.y_var(j, i, ip);
                     let sji = result.s_var(j, i);
                     let sjip = result.s_var(j, ip);
-                    let pji = pj[i] as f64;
-                    let pjip = pj[ip] as f64;
+                    let pji = pj[i];
+                    let pjip = pj[ip];
 
                     // (a) s_{j,i'} - s_{j,i} - M*y >= p_{j,i} - M
                     constraints.push(LinearConstraint::ge(
-                        vec![(sjip, 1.0), (sji, -1.0), (y, -big_m)],
+                        vec![(sjip, 1), (sji, -1), (y, -big_m)],
                         pji - big_m,
                     ));
 
                     // (b) s_{j,i} - s_{j,i'} + M*y >= p_{j,i'}
                     constraints.push(LinearConstraint::ge(
-                        vec![(sji, 1.0), (sjip, -1.0), (y, big_m)],
+                        vec![(sji, 1), (sjip, -1), (y, big_m)],
                         pjip,
                     ));
                 }
@@ -247,25 +252,23 @@ impl ReduceTo<ILP<i32>> for OpenShopScheduling {
         }
 
         // 5. Makespan: C ≥ s_{j,i} + p_{j,i}  ⟺  C - s_{j,i} ≥ p_{j,i}
-        for (j, pj) in p.iter().enumerate() {
+        for (j, pj) in processing_times.iter().enumerate() {
             for (i, &pji) in pj.iter().enumerate() {
                 let sji = result.s_var(j, i);
-                constraints.push(LinearConstraint::ge(
-                    vec![(c_var, 1.0), (sji, -1.0)],
-                    pji as f64,
-                ));
+                constraints.push(LinearConstraint::ge(vec![(c_var, 1), (sji, -1)], pji));
             }
         }
 
         // Objective: minimize C
-        let objective = vec![(c_var, 1.0)];
+        let objective = vec![(c_var, 1)];
 
-        ReductionOSSToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize),
+        Ok(ReductionOSSToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_jobs: n,
             num_machines: m,
             num_order_vars,
-        }
+        })
     }
 }
 
@@ -276,7 +279,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             // Small 2x2 instance for canonical example
             let source = OpenShopScheduling::new(2, vec![vec![1, 2], vec![2, 1]]);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/optimallineararrangement_consecutiveonesmatrixaugmentation.rs b/src/rules/optimallineararrangement_consecutiveonesmatrixaugmentation.rs
index 62b4ef512..1efcd0b0b 100644
--- a/src/rules/optimallineararrangement_consecutiveonesmatrixaugmentation.rs
+++ b/src/rules/optimallineararrangement_consecutiveonesmatrixaugmentation.rs
@@ -1,14 +1,8 @@
-//! Reduction from Decision Optimal Linear Arrangement to Consecutive Ones
-//! Matrix Augmentation.
-//!
-//! Establishes NP-completeness of CONSECUTIVE ONES MATRIX AUGMENTATION
-//! (Garey & Johnson SR16) via transformation from OPTIMAL LINEAR ARRANGEMENT
-//! (GT42). Given `Decision<OptimalLinearArrangement>(G, k)`, the edge-vertex
-//! incidence matrix `A` of `G` has rows = edges and columns = vertices. A
-//! column permutation is exactly a vertex ordering `f`; making each edge row
-//! consecutive costs `|f(u) - f(v)| - 1` flips, so the total augmentation cost
-//! equals `(total edge length) - |E|`. Hence the source is YES iff
-//! `ConsecutiveOnesMatrixAugmentation(A, k - |E|)` is YES.
+//! Incidence-matrix reduction from decision linear arrangement to consecutive
+//! ones augmentation (Booth, 1975, Theorem 4.19, with the matrix transposed).
+//! For every ordering, augmentation cost equals total edge length minus the
+//! number of non-loop edges. Loops contribute zero to both costs; parallel
+//! edges contribute separately.
 
 use crate::models::algebraic::ConsecutiveOnesMatrixAugmentation;
 use crate::models::decision::Decision;
@@ -17,24 +11,11 @@ use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
 
-/// Which construction branch produced the target instance.
-#[derive(Debug, Clone)]
-enum ConstructionKind {
-    /// Edgeless source (`m = 0`): always-YES `[[false]]` sentinel.
-    /// Carries the source vertex count to reconstruct an identity arrangement.
-    EdgelessYes { num_vertices: usize },
-    /// `k < m`: genuine-NO 3x3 cyclic-overlap sentinel.
-    FixedNo { num_vertices: usize },
-    /// Generic incidence-matrix construction (`m >= 1`, `k >= m`).
-    Incidence { num_vertices: usize },
-}
-
-/// Result of reducing `Decision<OptimalLinearArrangement<SimpleGraph>>` to
-/// `ConsecutiveOnesMatrixAugmentation`.
+/// The target incidence matrix, or a fixed infeasible matrix when the source
+/// bound is below the universal lower bound on arrangement length.
 #[derive(Debug, Clone)]
 pub struct ReductionOptimalLinearArrangementToConsecutiveOnesMatrixAugmentation {
     target: ConsecutiveOnesMatrixAugmentation,
-    construction: ConstructionKind,
 }
 
 impl ReductionResult for ReductionOptimalLinearArrangementToConsecutiveOnesMatrixAugmentation {
@@ -45,58 +26,32 @@ impl ReductionResult for ReductionOptimalLinearArrangementToConsecutiveOnesMatri
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        match &self.construction {
-            // No edges: any arrangement has total length 0 <= k, so emit the
-            // identity arrangement f(v) = v over all source vertices.
-            ConstructionKind::EdgelessYes { num_vertices } => (0..*num_vertices).collect(),
-            // Genuine NO: there is no valid arrangement; return a sentinel
-            // (identity) so the source decision evaluates correctly (NO).
-            ConstructionKind::FixedNo { num_vertices } => (0..*num_vertices).collect(),
-            ConstructionKind::Incidence { num_vertices } => {
-                // The C1MA witness is a column permutation: `config[position] = col`.
-                // Columns correspond to vertices, so this places vertex `col` at
-                // `position`. The OLA arrangement is `f(vertex) = position`, i.e.
-                // the inverse permutation.
-                let n = *num_vertices;
-                if target_solution.len() != n {
-                    return (0..n).collect();
-                }
-                let mut arrangement = vec![0usize; n];
-                let mut seen = vec![false; n];
-                for (position, &vertex) in target_solution.iter().enumerate() {
-                    if vertex >= n || seen[vertex] {
-                        // Not a valid permutation; fall back to identity.
-                        return (0..n).collect();
-                    }
-                    seen[vertex] = true;
-                    arrangement[vertex] = position;
-                }
-                arrangement
-            }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target column order is not a satisfying augmentation certificate",
+            ));
+        }
+        // Validation establishes a permutation within the augmentation budget.
+        // The NO sentinel has no such certificate; all remaining columns are
+        // source vertices, including the empty permutation for an empty graph.
+        let mut arrangement = vec![0; target_solution.len()];
+        for (position, &vertex) in target_solution.iter().enumerate() {
+            arrangement[vertex] = position;
         }
+        Ok(arrangement)
     }
 }
 
-/// The fixed 3x3 cyclic-overlap NO sentinel: under every column permutation at
-/// least one row's two 1's straddle a 0, so the minimum augmentation cost is
-/// `1 > 0`.
-fn no_sentinel() -> ConsecutiveOnesMatrixAugmentation {
-    ConsecutiveOnesMatrixAugmentation::new(
-        vec![
-            vec![true, true, false],
-            vec![false, true, true],
-            vec![true, false, true],
-        ],
-        0,
-    )
-}
-
 #[reduction(
-    overhead = {
-        num_rows = "num_edges",
-        num_cols = "num_vertices",
-        bound = "k - num_edges",
+    transform = upper_bound {
+        num_rows = "num_edges + 3",
+        num_cols = "num_vertices + 3",
     }
 )]
 impl ReduceTo<ConsecutiveOnesMatrixAugmentation>
@@ -104,43 +59,43 @@ impl ReduceTo<ConsecutiveOnesMatrixAugmentation>
 {
     type Result = ReductionOptimalLinearArrangementToConsecutiveOnesMatrixAugmentation;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
-        let m = self.num_edges();
-        let k = self.k();
-
-        // Edgeless graph: total edge length is 0 for every arrangement, so the
-        // source decision is YES for any bound. Emit a 1x1 all-zero matrix
-        // (already C1P at cost 0 <= bound) to keep num_cols >= 1.
-        if m == 0 {
-            return ReductionOptimalLinearArrangementToConsecutiveOnesMatrixAugmentation {
-                target: ConsecutiveOnesMatrixAugmentation::new(vec![vec![false]], k as i64),
-                construction: ConstructionKind::EdgelessYes { num_vertices: n },
-            };
-        }
-
-        // Negative target bound (k < m): every arrangement costs at least m
-        // (each edge contributes >= 1), so the source decision is NO. Route to
-        // the fixed genuine-NO sentinel.
-        if k < m {
-            return ReductionOptimalLinearArrangementToConsecutiveOnesMatrixAugmentation {
-                target: no_sentinel(),
-                construction: ConstructionKind::FixedNo { num_vertices: n },
-            };
-        }
-
-        // Generic case: edge-vertex incidence matrix, rows = edges, cols = vertices.
-        let mut matrix = vec![vec![false; n]; m];
-        for (edge_idx, (u, v)) in self.inner().graph().edges().into_iter().enumerate() {
-            matrix[edge_idx][u] = true;
-            matrix[edge_idx][v] = true;
-        }
-        let bound = (k - m) as i64;
-
-        ReductionOptimalLinearArrangementToConsecutiveOnesMatrixAugmentation {
-            target: ConsecutiveOnesMatrixAugmentation::new(matrix, bound),
-            construction: ConstructionKind::Incidence { num_vertices: n },
-        }
+        let edges = self.inner().graph().edges();
+        let non_loops = <Self as ReduceTo<ConsecutiveOnesMatrixAugmentation>>::exact_i64(
+            edges.iter().filter(|(u, v)| u != v).count(),
+            "converting the number of non-loop edges to i64",
+        )?;
+        let k = *self.bound();
+        let (matrix, bound) = if k < non_loops {
+            // Every non-loop edge has length at least one. The three pairs of
+            // columns cannot all be adjacent, so this matrix is genuinely NO.
+            (
+                vec![
+                    vec![true, true, false],
+                    vec![false, true, true],
+                    vec![true, false, true],
+                ],
+                0,
+            )
+        } else {
+            // A zero row preserves the vertex columns when there are no edges.
+            // An empty graph is represented by one empty row, with no columns.
+            let mut matrix = vec![vec![false; n]; edges.len().max(1)];
+            for (row, (u, v)) in edges.into_iter().enumerate() {
+                matrix[row][u] = true;
+                matrix[row][v] = true;
+            }
+            // 0 <= non_loops <= k <= i64::MAX, so subtraction is exact.
+            (matrix, k - non_loops)
+        };
+        Ok(
+            ReductionOptimalLinearArrangementToConsecutiveOnesMatrixAugmentation {
+                target: ConsecutiveOnesMatrixAugmentation::try_new(matrix, bound).map_err(
+                    <Self as ReduceTo<ConsecutiveOnesMatrixAugmentation>>::target_construction,
+                )?,
+            },
+        )
     }
 }
 
@@ -163,7 +118,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 )),
                 11,
             );
-            let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source);
+            let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source)
+                .expect("reduction should succeed");
             // Source arrangement f(v) = v <=> target column permutation = identity.
             let source_config = vec![0, 1, 2, 3, 4, 5];
             let target_config = vec![0, 1, 2, 3, 4, 5];
@@ -171,8 +127,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 &source,
                 reduction.target_problem(),
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/optimallineararrangement_ilp.rs b/src/rules/optimallineararrangement_ilp.rs
index b84b4f7d7..934dd35b1 100644
--- a/src/rules/optimallineararrangement_ilp.rs
+++ b/src/rules/optimallineararrangement_ilp.rs
@@ -15,47 +15,53 @@ use crate::topology::{Graph, SimpleGraph};
 
 /// Result of reducing OptimalLinearArrangement to ILP.
 ///
-/// Variable layout (ILP<i32>, non-negative integers):
+/// Variable layout (`ILP<i64>`, non-negative integers):
 /// - `x_{v,p}` at index `v * n + p`, bounded to {0,1}
 /// - `p_v` at index `n^2 + v`, integer position in {0, ..., n-1}
 /// - `z_e` at index `n^2 + n + e`, non-negative integer for edge length
 #[derive(Debug, Clone)]
 pub struct ReductionOLAToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_vertices: usize,
 }
 
 impl ReductionResult for ReductionOLAToILP {
     type Source = OptimalLinearArrangement<SimpleGraph>;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Extract: for each vertex v, output its position p (the unique p with x_{v,p} = 1).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_vertices;
-        (0..n)
-            .map(|v| {
-                (0..n)
-                    .find(|&p| target_solution[v * n + p] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_vertices,
+            self.num_vertices,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices^2 + num_vertices + num_edges",
         num_constraints = "2 * num_vertices + num_vertices^2 + num_vertices + num_vertices + 3 * num_edges",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for OptimalLinearArrangement<SimpleGraph> {
+impl ReduceTo<ILP<i64>> for OptimalLinearArrangement<SimpleGraph> {
     type Result = ReductionOLAToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let graph = self.graph();
         let edges = graph.edges();
@@ -69,65 +75,70 @@ impl ReduceTo<ILP<i32>> for OptimalLinearArrangement<SimpleGraph> {
         let z_idx = |e: usize| -> usize { num_x + n + e };
 
         let mut constraints = Vec::new();
+        let n_i64 = <Self as ReduceTo<ILP<i64>>>::exact_i64(n, "encoding a vertex position")?;
 
         // Assignment: each vertex in exactly one position
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|p| (x_idx(v, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|p| (x_idx(v, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Assignment: each position has exactly one vertex
         for p in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|v| (x_idx(v, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|v| (x_idx(v, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
-        // Binary bounds for x variables (ILP<i32>)
+        // Binary bounds for x variables (`ILP<i64>`)
         for v in 0..n {
             for p in 0..n {
-                constraints.push(LinearConstraint::le(vec![(x_idx(v, p), 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(x_idx(v, p), 1)], 1));
             }
         }
 
         // Position variable linking: p_v = sum_p p * x_{v,p}
         // Reformulated as: p_v - sum_p p * x_{v,p} = 0
         for v in 0..n {
-            let mut terms: Vec<(usize, f64)> = vec![(p_idx(v), 1.0)];
+            let mut terms: Vec<(usize, i64)> = vec![(p_idx(v), 1)];
             for p in 0..n {
-                terms.push((x_idx(v, p), -(p as f64)));
+                terms.push((
+                    x_idx(v, p),
+                    -<Self as ReduceTo<ILP<i64>>>::exact_i64(p, "encoding a vertex position")?,
+                ));
             }
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // Position bounds: 0 <= p_v <= n-1
         for v in 0..n {
-            constraints.push(LinearConstraint::le(vec![(p_idx(v), 1.0)], (n - 1) as f64));
+            constraints.push(LinearConstraint::le(vec![(p_idx(v), 1)], n_i64 - 1));
         }
 
         // Absolute value: z_e >= |p_u - p_v| for each edge e = {u, v}
         for (e, &(u, v)) in edges.iter().enumerate() {
             // z_e >= p_u - p_v
             constraints.push(LinearConstraint::ge(
-                vec![(z_idx(e), 1.0), (p_idx(u), -1.0), (p_idx(v), 1.0)],
-                0.0,
+                vec![(z_idx(e), 1), (p_idx(u), -1), (p_idx(v), 1)],
+                0,
             ));
             // z_e >= p_v - p_u
             constraints.push(LinearConstraint::ge(
-                vec![(z_idx(e), 1.0), (p_idx(v), -1.0), (p_idx(u), 1.0)],
-                0.0,
+                vec![(z_idx(e), 1), (p_idx(v), -1), (p_idx(u), 1)],
+                0,
             ));
             // z_e <= n-1 (max possible position difference)
-            constraints.push(LinearConstraint::le(vec![(z_idx(e), 1.0)], (n - 1) as f64));
+            constraints.push(LinearConstraint::le(vec![(z_idx(e), 1)], n_i64 - 1));
         }
 
         // Objective: minimize sum z_e
-        let objective: Vec<(usize, f64)> = (0..m).map(|e| (z_idx(e), 1.0)).collect();
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let objective: Vec<(usize, i64)> = (0..m).map(|e| (z_idx(e), 1)).collect();
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<i64>>>::target_construction)?;
 
-        ReductionOLAToILP {
+        Ok(ReductionOLAToILP {
             target,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -139,7 +150,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Path P4: 0-1-2-3 (identity permutation achieves cost 3)
             let source =
                 OptimalLinearArrangement::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/optimallineararrangement_sequencingtominimizeweightedcompletiontime.rs b/src/rules/optimallineararrangement_sequencingtominimizeweightedcompletiontime.rs
index 1ff24c75c..e7a14a680 100644
--- a/src/rules/optimallineararrangement_sequencingtominimizeweightedcompletiontime.rs
+++ b/src/rules/optimallineararrangement_sequencingtominimizeweightedcompletiontime.rs
@@ -32,47 +32,69 @@ impl ReductionResult for ReductionOLAToSequencingToMinimizeWeightedCompletionTim
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let schedule = crate::models::misc::decode_lehmer(target_solution, self.target.num_tasks())
-            .expect("target solution must be a valid Lehmer code");
-        let mut arrangement = vec![0usize; self.num_vertices];
-        let mut next_position = 0usize;
-
-        for task in schedule {
-            if task < self.num_vertices {
-                arrangement[task] = next_position;
-                next_position += 1;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let mut arrangement = vec![0usize; self.num_vertices];
+            let mut next_position = 0usize;
+
+            for &task in target_solution {
+                if task < self.num_vertices {
+                    arrangement[task] = next_position;
+                    next_position += 1;
+                }
             }
-        }
 
-        arrangement
+            arrangement
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_tasks = "num_vertices + num_edges",
-})]
+#[reduction(
+    transform = exact {
+        num_tasks = "num_vertices + num_edges",
+    },
+    unavailable = {
+        num_precedences = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<SequencingToMinimizeWeightedCompletionTime>
     for OptimalLinearArrangement<SimpleGraph>
 {
     type Result = ReductionOLAToSequencingToMinimizeWeightedCompletionTime;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let graph = self.graph();
         let num_vertices = graph.num_vertices();
         let edges = graph.edges();
         let max_degree = (0..num_vertices)
             .map(|v| graph.degree(v))
             .max()
-            .unwrap_or(0) as u64;
+            .unwrap_or(0);
+        let max_degree = i64::try_from(max_degree).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                OptimalLinearArrangement<SimpleGraph>,
+                SequencingToMinimizeWeightedCompletionTime,
+            >("converting the maximum degree to i64")
+        })?;
 
         let mut lengths = Vec::with_capacity(num_vertices + edges.len());
         let mut weights = Vec::with_capacity(num_vertices + edges.len());
         let mut precedences = Vec::with_capacity(2 * edges.len());
 
         for vertex in 0..num_vertices {
+            let degree = i64::try_from(graph.degree(vertex)).map_err(|_| {
+                crate::rules::ReductionError::integer_overflow::<
+                    OptimalLinearArrangement<SimpleGraph>,
+                    SequencingToMinimizeWeightedCompletionTime,
+                >("converting a vertex degree to i64")
+            })?;
             lengths.push(1);
-            weights.push(max_degree - graph.degree(vertex) as u64);
+            weights.push(max_degree - degree);
         }
 
         for (edge_index, &(u, v)) in edges.iter().enumerate() {
@@ -83,10 +105,10 @@ impl ReduceTo<SequencingToMinimizeWeightedCompletionTime>
             precedences.push((v, edge_task));
         }
 
-        ReductionOLAToSequencingToMinimizeWeightedCompletionTime {
+        Ok(ReductionOLAToSequencingToMinimizeWeightedCompletionTime {
             target: SequencingToMinimizeWeightedCompletionTime::new(lengths, weights, precedences),
             num_vertices,
-        }
+        })
     }
 }
 
@@ -102,17 +124,21 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             let source =
                 OptimalLinearArrangement::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
             let reduction =
-                ReduceTo::<SequencingToMinimizeWeightedCompletionTime>::reduce_to(&source);
+                ReduceTo::<SequencingToMinimizeWeightedCompletionTime>::reduce_to(&source)
+                    .expect("reduction should succeed");
             let target_config = BruteForce::new()
-                .find_witness(reduction.target_problem())
+                .solve(reduction.target_problem())
+                .expect("canonical target evaluation must succeed")
                 .expect("canonical example must be solvable");
-            let source_config = reduction.extract_solution(&target_config);
+            let source_config = reduction.extract_solution(&target_config).unwrap();
             assemble_rule_example(
                 &source,
                 reduction.target_problem(),
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/optimumcommunicationspanningtree_ilp.rs b/src/rules/optimumcommunicationspanningtree_ilp.rs
index e64fbe985..ee0c48bb7 100644
--- a/src/rules/optimumcommunicationspanningtree_ilp.rs
+++ b/src/rules/optimumcommunicationspanningtree_ilp.rs
@@ -2,7 +2,7 @@
 //!
 //! Uses a multi-commodity flow formulation:
 //! - Binary edge variables x_e for each edge of K_n
-//! - For each pair (u,v) with r(u,v) > 0, directed flow variables route 1 unit
+//! - For every vertex pair (u,v), directed flow variables route 1 unit, proving connectivity
 //!   from u to v through the tree
 //! - Tree constraints: sum x_e = n-1, and connectivity via flow conservation
 //! - Objective: minimize sum_{(u,v): r>0} r(u,v) * w(e) * (flow_uv(e->dir) + flow_uv(e<-dir))
@@ -33,34 +33,43 @@ impl ReductionResult for ReductionOptimumCommunicationSpanningTreeToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_edges].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_edges]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_edges + 2 * num_edges * num_vertices * (num_vertices - 1) / 2",
         num_constraints = "1 + num_vertices * num_vertices * (num_vertices - 1) / 2 + 2 * num_edges * num_vertices * (num_vertices - 1) / 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for OptimumCommunicationSpanningTree {
     type Result = ReductionOptimumCommunicationSpanningTreeToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let m = self.num_edges();
         let edges = self.edges();
         let w = self.edge_weights();
         let r = self.requirements();
 
-        // Enumerate commodities: all pairs (s, t) with s < t and r(s,t) > 0
+        // Enumerate every pair: zero-requirement commodities still enforce spanning connectivity.
         let mut commodities: Vec<(usize, usize)> = Vec::new();
-        for (s, row) in r.iter().enumerate() {
-            for (t, &req) in row.iter().enumerate().skip(s + 1) {
-                if req > 0 {
-                    commodities.push((s, t));
-                }
+        for s in 0..n {
+            for t in (s + 1)..n {
+                commodities.push((s, t));
             }
         }
         let num_commodities = commodities.len();
@@ -77,8 +86,11 @@ impl ReduceTo<ILP<bool>> for OptimumCommunicationSpanningTree {
 
         // Constraint 1: Tree has exactly n-1 edges
         // sum x_e = n-1
-        let tree_terms: Vec<(usize, f64)> = (0..m).map(|e| (edge_var(e), 1.0)).collect();
-        constraints.push(LinearConstraint::eq(tree_terms, (n - 1) as f64));
+        let tree_terms: Vec<(usize, i64)> = (0..m).map(|e| (edge_var(e), 1)).collect();
+        constraints.push(LinearConstraint::eq(
+            tree_terms,
+            Self::exact_i64(n, "encoding the spanning-tree order")? - 1,
+        ));
 
         // Constraint 2: Flow conservation for each commodity
         for (k, &(src, dst)) in commodities.iter().enumerate() {
@@ -88,22 +100,22 @@ impl ReduceTo<ILP<bool>> for OptimumCommunicationSpanningTree {
                     // Flow into vertex minus flow out of vertex
                     if j == vertex {
                         // Edge (i, j): direction 0 = i->j (inflow), direction 1 = j->i (outflow)
-                        terms.push((flow_var(k, edge_idx, 0), 1.0));
-                        terms.push((flow_var(k, edge_idx, 1), -1.0));
+                        terms.push((flow_var(k, edge_idx, 0), 1));
+                        terms.push((flow_var(k, edge_idx, 1), -1));
                     }
                     if i == vertex {
                         // Edge (i, j): direction 1 = j->i (inflow), direction 0 = i->j (outflow)
-                        terms.push((flow_var(k, edge_idx, 1), 1.0));
-                        terms.push((flow_var(k, edge_idx, 0), -1.0));
+                        terms.push((flow_var(k, edge_idx, 1), 1));
+                        terms.push((flow_var(k, edge_idx, 0), -1));
                     }
                 }
 
                 let rhs = if vertex == src {
-                    -1.0 // source: net outflow of 1
+                    -1 // source: net outflow of 1
                 } else if vertex == dst {
-                    1.0 // sink: net inflow of 1
+                    1 // sink: net inflow of 1
                 } else {
-                    0.0 // transit: balanced
+                    0 // transit: balanced
                 };
                 constraints.push(LinearConstraint::eq(terms, rhs));
             }
@@ -115,38 +127,45 @@ impl ReduceTo<ILP<bool>> for OptimumCommunicationSpanningTree {
                 let sel = edge_var(edge_idx);
                 // f^k_(i->j) <= x_e
                 constraints.push(LinearConstraint::le(
-                    vec![(flow_var(k, edge_idx, 0), 1.0), (sel, -1.0)],
-                    0.0,
+                    vec![(flow_var(k, edge_idx, 0), 1), (sel, -1)],
+                    0,
                 ));
                 // f^k_(j->i) <= x_e
                 constraints.push(LinearConstraint::le(
-                    vec![(flow_var(k, edge_idx, 1), 1.0), (sel, -1.0)],
-                    0.0,
+                    vec![(flow_var(k, edge_idx, 1), 1), (sel, -1)],
+                    0,
                 ));
             }
         }
 
         // Objective: minimize sum over commodities k of r(s,t) * sum_e w(e) * (f^k_e_fwd + f^k_e_bwd)
         // This equals sum_{s<t} r(s,t) * W_T(s,t) because flow routes exactly along the tree path.
-        let mut objective: Vec<(usize, f64)> = Vec::new();
+        let mut objective: Vec<(usize, i64)> = Vec::new();
         for (k, &(s, t)) in commodities.iter().enumerate() {
-            let req = r[s][t] as f64;
             for (edge_idx, &(i, j)) in edges.iter().enumerate() {
-                let weight = w[i][j] as f64;
-                let coeff = req * weight;
-                if coeff != 0.0 {
+                let communication_cost = r[s][t].checked_mul(w[i][j]).ok_or_else(|| {
+                    crate::rules::ReductionError::integer_overflow::<
+                        OptimumCommunicationSpanningTree,
+                        ILP<bool>,
+                    >(
+                        "multiplying a communication requirement by an edge weight"
+                    )
+                })?;
+                let coeff = communication_cost;
+                if coeff != 0 {
                     objective.push((flow_var(k, edge_idx, 0), coeff));
                     objective.push((flow_var(k, edge_idx, 1), coeff));
                 }
             }
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionOptimumCommunicationSpanningTreeToILP {
+        Ok(ReductionOptimumCommunicationSpanningTreeToILP {
             target,
             num_edges: m,
-        }
+        })
     }
 }
 
diff --git a/src/rules/paintshop_ilp.rs b/src/rules/paintshop_ilp.rs
index c43ea8dd3..b5f455827 100644
--- a/src/rules/paintshop_ilp.rs
+++ b/src/rules/paintshop_ilp.rs
@@ -24,21 +24,32 @@ impl ReductionResult for ReductionPaintShopToILP {
     }
 
     /// Extract first-occurrence color bits (x_i) from ILP solution.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_cars].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_cars]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_cars + 2 * num_sequence",
         num_constraints = "num_sequence + 2 * num_sequence",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for PaintShop {
     type Result = ReductionPaintShopToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let nc = self.num_cars();
         let seq_len = self.sequence_len();
 
@@ -52,33 +63,24 @@ impl ReduceTo<ILP<bool>> for PaintShop {
 
         let mut constraints = Vec::new();
 
-        // Determine car index and is_first for each position.
-        // With config all-zero: first occ gets color 0, second occ gets color 1.
-        let base = self.get_coloring(&vec![0; nc]);
-
-        // For each car i, find its positions by flipping x_i.
-        for i in 0..nc {
-            let mut config = vec![0; nc];
-            config[i] = 1;
-            let flipped = self.get_coloring(&config);
-
-            for p in 0..seq_len {
-                if flipped[p] != base[p] {
-                    // Position p belongs to car i
-                    if base[p] == 0 {
-                        // First occurrence: k_p = x_i
-                        constraints.push(LinearConstraint::eq(
-                            vec![(k_offset + p, 1.0), (i, -1.0)],
-                            0.0,
-                        ));
-                    } else {
-                        // Second occurrence: k_p = 1 - x_i  =>  k_p + x_i = 1
-                        constraints.push(LinearConstraint::eq(
-                            vec![(k_offset + p, 1.0), (i, 1.0)],
-                            1.0,
-                        ));
-                    }
-                }
+        for (position, (&car, &is_first)) in self
+            .sequence_indices()
+            .iter()
+            .zip(self.is_first())
+            .enumerate()
+        {
+            if is_first {
+                // First occurrence: k_p = x_i
+                constraints.push(LinearConstraint::eq(
+                    vec![(k_offset + position, 1), (car, -1)],
+                    0,
+                ));
+            } else {
+                // Second occurrence: k_p = 1 - x_i  =>  k_p + x_i = 1
+                constraints.push(LinearConstraint::eq(
+                    vec![(k_offset + position, 1), (car, 1)],
+                    1,
+                ));
             }
         }
 
@@ -86,32 +88,25 @@ impl ReduceTo<ILP<bool>> for PaintShop {
         for p in 1..seq_len {
             // c_p >= k_p - k_{p-1}
             constraints.push(LinearConstraint::ge(
-                vec![
-                    (c_offset + p, 1.0),
-                    (k_offset + p, -1.0),
-                    (k_offset + p - 1, 1.0),
-                ],
-                0.0,
+                vec![(c_offset + p, 1), (k_offset + p, -1), (k_offset + p - 1, 1)],
+                0,
             ));
             // c_p >= k_{p-1} - k_p
             constraints.push(LinearConstraint::ge(
-                vec![
-                    (c_offset + p, 1.0),
-                    (k_offset + p - 1, -1.0),
-                    (k_offset + p, 1.0),
-                ],
-                0.0,
+                vec![(c_offset + p, 1), (k_offset + p - 1, -1), (k_offset + p, 1)],
+                0,
             ));
         }
 
         // Objective: minimize Σ c_p for p in 1..seq_len
-        let objective: Vec<(usize, f64)> = (1..seq_len).map(|p| (c_offset + p, 1.0)).collect();
+        let objective: Vec<(usize, i64)> = (1..seq_len).map(|p| (c_offset + p, 1)).collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
-        ReductionPaintShopToILP {
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
+        Ok(ReductionPaintShopToILP {
             target,
             num_cars: nc,
-        }
+        })
     }
 }
 
@@ -123,19 +118,22 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             // Sequence: A, B, A, C, B, C => 3 cars
             let source = PaintShop::new(vec!["A", "B", "A", "C", "B", "C"]);
-            let reduction: ReductionPaintShopToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+            let reduction: ReductionPaintShopToILP =
+                ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
             let target_config = {
                 let ilp_solver = crate::solvers::ILPSolver::new();
                 ilp_solver
                     .solve(reduction.target_problem())
                     .expect("ILP should be solvable")
             };
-            let source_config = reduction.extract_solution(&target_config);
+            let source_config = reduction.extract_solution(&target_config).unwrap();
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/paintshop_qubo.rs b/src/rules/paintshop_qubo.rs
index fcd1dd294..b8a05456c 100644
--- a/src/rules/paintshop_qubo.rs
+++ b/src/rules/paintshop_qubo.rs
@@ -15,12 +15,12 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Result of reducing PaintShop to QUBO.
 #[derive(Debug, Clone)]
 pub struct ReductionPaintShopToQUBO {
-    target: QUBO<f64>,
+    target: QUBO<i64>,
 }
 
 impl ReductionResult for ReductionPaintShopToQUBO {
     type Source = PaintShop;
-    type Target = QUBO<f64>;
+    type Target = QUBO<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
@@ -28,22 +28,32 @@ impl ReductionResult for ReductionPaintShopToQUBO {
 
     /// The QUBO solution maps directly back: car i's first occurrence gets
     /// color x_i, second gets 1 - x_i.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
-#[reduction(overhead = { num_vars = "num_cars" })]
-impl ReduceTo<QUBO<f64>> for PaintShop {
+#[reduction(transform = exact {
+    num_vars = "num_cars",
+})]
+impl ReduceTo<QUBO<i64>> for PaintShop {
     type Result = ReductionPaintShopToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_cars();
         let seq = self.sequence_indices();
         let is_first = self.is_first();
         let seq_len = seq.len();
 
-        let mut matrix = vec![vec![0.0f64; n]; n];
+        let mut matrix = vec![vec![0i64; n]; n];
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<PaintShop, QUBO<i64>>(operation)
+        };
 
         // For each adjacent pair in the sequence
         for pos in 0..seq_len.saturating_sub(1) {
@@ -64,21 +74,35 @@ impl ReduceTo<QUBO<f64>> for PaintShop {
             if parity_a == parity_b {
                 // Same parity: color change when x_a != x_b
                 // Contribution: +1 to Q[a][a], +1 to Q[b][b], -2 to Q[lo][hi]
-                matrix[a][a] += 1.0;
-                matrix[b][b] += 1.0;
-                matrix[lo][hi] -= 2.0;
+                matrix[a][a] = matrix[a][a]
+                    .checked_add(1)
+                    .ok_or_else(|| overflow("adding a PaintShop diagonal coefficient"))?;
+                matrix[b][b] = matrix[b][b]
+                    .checked_add(1)
+                    .ok_or_else(|| overflow("adding a PaintShop diagonal coefficient"))?;
+                matrix[lo][hi] = matrix[lo][hi]
+                    .checked_sub(2)
+                    .ok_or_else(|| overflow("adding a PaintShop interaction coefficient"))?;
             } else {
                 // Different parity: color change when x_a == x_b
                 // Contribution: -1 to Q[a][a], -1 to Q[b][b], +2 to Q[lo][hi]
-                matrix[a][a] -= 1.0;
-                matrix[b][b] -= 1.0;
-                matrix[lo][hi] += 2.0;
+                matrix[a][a] = matrix[a][a]
+                    .checked_sub(1)
+                    .ok_or_else(|| overflow("adding a PaintShop diagonal coefficient"))?;
+                matrix[b][b] = matrix[b][b]
+                    .checked_sub(1)
+                    .ok_or_else(|| overflow("adding a PaintShop diagonal coefficient"))?;
+                matrix[lo][hi] = matrix[lo][hi]
+                    .checked_add(2)
+                    .ok_or_else(|| overflow("adding a PaintShop interaction coefficient"))?;
             }
         }
 
-        ReductionPaintShopToQUBO {
-            target: QUBO::from_matrix(matrix),
-        }
+        Ok(ReductionPaintShopToQUBO {
+            target: QUBO::from_matrix(matrix).map_err(|message| {
+                crate::rules::ReductionError::construction::<PaintShop, QUBO<i64>>(message)
+            })?,
+        })
     }
 }
 
@@ -91,11 +115,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             // Issue example: Sequence [A, B, C, A, D, B, D, C], 4 cars
             let source = PaintShop::new(vec!["A", "B", "C", "A", "D", "B", "D", "C"]);
-            crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
+            crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 0],
-                    target_config: vec![1, 0, 0, 0],
+                    source_config: serde_json::json!(vec![true, false, false, false]),
+                    target_config: serde_json::json!(vec![true, false, false, false]),
                 },
             )
         },
diff --git a/src/rules/partiallyorderedknapsack_ilp.rs b/src/rules/partiallyorderedknapsack_ilp.rs
index a8a4d4161..ecfef47b6 100644
--- a/src/rules/partiallyorderedknapsack_ilp.rs
+++ b/src/rules/partiallyorderedknapsack_ilp.rs
@@ -21,48 +21,54 @@ impl ReductionResult for ReductionPOKToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_items",
         num_constraints = "num_precedences + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for PartiallyOrderedKnapsack {
     type Result = ReductionPOKToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_items();
         let mut constraints = Vec::new();
+        let weights = self.weights();
+        let values = self.values();
+        let capacity = self.capacity();
 
         // Capacity constraint: Σ w_i·x_i ≤ capacity
-        let cap_terms: Vec<(usize, f64)> = self
-            .weights()
+        let cap_terms: Vec<(usize, i64)> = weights
             .iter()
             .enumerate()
-            .map(|(i, &w)| (i, w as f64))
+            .map(|(item, &weight)| (item, weight))
             .collect();
-        constraints.push(LinearConstraint::le(cap_terms, self.capacity() as f64));
+        constraints.push(LinearConstraint::le(cap_terms, capacity));
 
         // Precedence constraints: ∀ (a,b): x_b - x_a ≤ 0
         for &(a, b) in self.precedences() {
-            constraints.push(LinearConstraint::le(vec![(b, 1.0), (a, -1.0)], 0.0));
+            constraints.push(LinearConstraint::le(vec![(b, 1), (a, -1)], 0));
         }
 
         // Objective: Maximize Σ v_i·x_i
-        let objective: Vec<(usize, f64)> = self
-            .values()
-            .iter()
-            .enumerate()
-            .map(|(i, &v)| (i, v as f64))
-            .collect();
+        let objective = values.iter().copied().enumerate().collect();
 
-        let target = ILP::new(n, constraints, objective, ObjectiveSense::Maximize);
-        ReductionPOKToILP { target }
+        let target = ILP::new(n, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionPOKToILP { target })
     }
 }
 
diff --git a/src/rules/partition_binpacking.rs b/src/rules/partition_binpacking.rs
index 4314c678d..20301e8a5 100644
--- a/src/rules/partition_binpacking.rs
+++ b/src/rules/partition_binpacking.rs
@@ -2,7 +2,7 @@
 //!
 //! Given a Partition instance with sizes A = {a_1, ..., a_n} and total sum S,
 //! construct a BinPacking instance with:
-//! - Items: same sizes (cast from u64 to i32)
+//! - Items: same sizes (cast from u64 to i64)
 //! - Bin capacity: floor(S / 2)
 //!
 //! A valid partition (two subsets of equal sum) exists iff all items can be
@@ -19,52 +19,49 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Result of reducing Partition to BinPacking.
 #[derive(Debug, Clone)]
 pub struct ReductionPartitionToBinPacking {
-    target: BinPacking<i32>,
+    target: BinPacking<i64>,
 }
 
 impl ReductionResult for ReductionPartitionToBinPacking {
     type Source = Partition;
-    type Target = BinPacking<i32>;
+    type Target = BinPacking<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // BinPacking may use any bin indices (0..n-1). Remap the two distinct
-        // bins used in a 2-bin packing to Partition's {0, 1} assignment.
-        // The first bin encountered maps to 0, the second to 1.
-        let first_bin = target_solution[0];
-        target_solution
-            .iter()
-            .map(|&b| if b == first_bin { 0 } else { 1 })
-            .collect()
-    }
-}
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
-fn partition_size_to_i32(value: u64) -> i32 {
-    i32::try_from(value)
-        .expect("Partition -> BinPacking requires all sizes and total_sum / 2 to fit in i32")
+        Ok({
+            // BinPacking may use any bin indices (0..n-1). Remap the two distinct
+            // bins used in a 2-bin packing to Partition's {0, 1} assignment.
+            // The first bin encountered maps to 0, the second to 1.
+            let first_bin = target_solution[0];
+            target_solution.iter().map(|&b| b != first_bin).collect()
+        })
+    }
 }
 
-#[reduction(overhead = {
-    num_items = "num_elements",
-})]
-impl ReduceTo<BinPacking<i32>> for Partition {
+#[reduction(
+    transform = exact {
+        num_items = "num_elements",
+    })]
+impl ReduceTo<BinPacking<i64>> for Partition {
     type Result = ReductionPartitionToBinPacking;
 
-    fn reduce_to(&self) -> Self::Result {
-        let sizes: Vec<i32> = self
-            .sizes()
-            .iter()
-            .copied()
-            .map(partition_size_to_i32)
-            .collect();
-        let capacity = partition_size_to_i32(self.total_sum() / 2);
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let sizes = self.sizes().to_vec();
+        let capacity = self.total_sum() / 2;
 
-        ReductionPartitionToBinPacking {
-            target: BinPacking::new(sizes, capacity),
-        }
+        Ok(ReductionPartitionToBinPacking {
+            target: BinPacking::new(sizes, capacity).map_err(|cause| {
+                crate::rules::ReductionError::construction::<Partition, BinPacking<i64>>(cause)
+            })?,
+        })
     }
 }
 
@@ -75,11 +72,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "partition_to_binpacking",
         build: || {
-            crate::example_db::specs::rule_example_with_witness::<_, BinPacking<i32>>(
-                Partition::new(vec![3, 1, 1, 2, 2, 1]),
+            crate::example_db::specs::rule_example_with_witness::<_, BinPacking<i64>>(
+                Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap(),
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0, 1, 1],
-                    target_config: vec![0, 1, 1, 0, 1, 1],
+                    source_config: serde_json::json!(vec![false, true, true, false, true, true]),
+                    target_config: serde_json::json!(vec![0, 1, 1, 0, 1, 1]),
                 },
             )
         },
diff --git a/src/rules/partition_cosineproductintegration.rs b/src/rules/partition_cosineproductintegration.rs
index bad735af9..1698a5334 100644
--- a/src/rules/partition_cosineproductintegration.rs
+++ b/src/rules/partition_cosineproductintegration.rs
@@ -28,22 +28,28 @@ impl ReductionResult for ReductionPartitionToCPI {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
-#[reduction(overhead = {
-    num_coefficients = "num_elements",
-})]
+#[reduction(
+    transform = exact {
+        num_coefficients = "num_elements",
+    })]
 impl ReduceTo<CosineProductIntegration> for Partition {
     type Result = ReductionPartitionToCPI;
 
-    fn reduce_to(&self) -> Self::Result {
-        let coefficients: Vec<i64> = self.sizes().iter().map(|&s| s as i64).collect();
-        ReductionPartitionToCPI {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let coefficients = self.sizes().to_vec();
+        Ok(ReductionPartitionToCPI {
             target: CosineProductIntegration::new(coefficients),
-        }
+        })
     }
 }
 
@@ -61,10 +67,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // Wait: config [1,0,0,1,0,0] means elements 0,3 in subset 1.
             // For CPI: bit 1 means −a_i. So −3+1+1−2+2+1 = 0. Yes!
             crate::example_db::specs::rule_example_with_witness::<_, CosineProductIntegration>(
-                Partition::new(vec![3, 1, 1, 2, 2, 1]),
+                Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap(),
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1, 0, 0],
-                    target_config: vec![1, 0, 0, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, false, false, true, false, false]),
+                    target_config: serde_json::json!(vec![true, false, false, true, false, false]),
                 },
             )
         },
diff --git a/src/rules/partition_integralflowwithmultipliers.rs b/src/rules/partition_integralflowwithmultipliers.rs
index 74e5be98b..8c1a96391 100644
--- a/src/rules/partition_integralflowwithmultipliers.rs
+++ b/src/rules/partition_integralflowwithmultipliers.rs
@@ -15,8 +15,7 @@ use crate::topology::DirectedGraph;
 #[derive(Debug, Clone)]
 pub struct ReductionPartitionToIntegralFlowWithMultipliers {
     target: IntegralFlowWithMultipliers,
-    source_n: usize,
-    item_arc_count: usize,
+    item_arc_count: Option<usize>,
 }
 
 impl ReductionResult for ReductionPartitionToIntegralFlowWithMultipliers {
@@ -27,39 +26,49 @@ impl ReductionResult for ReductionPartitionToIntegralFlowWithMultipliers {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        if self.item_arc_count == 0 {
-            return vec![0; self.source_n];
-        }
-
-        if target_solution.len() < self.item_arc_count {
-            return vec![0; self.source_n];
-        }
-
-        target_solution[..self.item_arc_count].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        Ok({
+            let item_arc_count = self.item_arc_count.ok_or_else(|| {
+                crate::rules::ExtractionError::invalid(
+                    "the fixed infeasible target instance has no extractable witness",
+                )
+            })?;
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+            target_solution[..item_arc_count]
+                .iter()
+                .map(|&flow| flow > 0)
+                .collect()
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vertices = "num_elements + 3",
-    num_arcs = "2 * num_elements + 1",
-    max_capacity = "total_sum",
-    requirement = "total_sum",
-})]
+#[reduction(
+    transform = exact {
+        num_vertices = "num_elements + 3",
+        num_arcs = "2 * num_elements + 1",
+    },
+    unavailable = {
+        max_capacity = "the target capacity depends on source numeric values not represented by Partition parameters",
+        requirement = "the target requirement depends on source numeric values not represented by Partition parameters",
+    }
+)]
 impl ReduceTo<IntegralFlowWithMultipliers> for Partition {
     type Result = ReductionPartitionToIntegralFlowWithMultipliers;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let total_sum = self.total_sum();
         let source_n = self.num_elements();
 
-        if !total_sum.is_multiple_of(2) {
+        if total_sum % 2 != 0 {
             let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2)]);
-            return ReductionPartitionToIntegralFlowWithMultipliers {
+            return Ok(ReductionPartitionToIntegralFlowWithMultipliers {
                 target: IntegralFlowWithMultipliers::new(graph, 0, 2, vec![1, 2, 1], vec![1, 1], 1),
-                source_n,
-                item_arc_count: 0,
-            };
+                item_arc_count: None,
+            });
         }
 
         let half_sum = total_sum / 2;
@@ -88,7 +97,7 @@ impl ReduceTo<IntegralFlowWithMultipliers> for Partition {
         multipliers[relay] = 1;
 
         let graph = DirectedGraph::new(source_n + 3, arcs);
-        ReductionPartitionToIntegralFlowWithMultipliers {
+        Ok(ReductionPartitionToIntegralFlowWithMultipliers {
             target: IntegralFlowWithMultipliers::new(
                 graph,
                 0,
@@ -97,9 +106,8 @@ impl ReduceTo<IntegralFlowWithMultipliers> for Partition {
                 capacities,
                 half_sum,
             ),
-            source_n,
-            item_arc_count: source_n,
-        }
+            item_arc_count: Some(source_n),
+        })
     }
 }
 
@@ -111,10 +119,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "partition_to_integralflowwithmultipliers",
         build: || {
             crate::example_db::specs::rule_example_with_witness::<_, IntegralFlowWithMultipliers>(
-                Partition::new(vec![2, 3, 4, 5, 6, 4]),
+                Partition::new(vec![2, 3, 4, 5, 6, 4]).unwrap(),
                 SolutionPair {
-                    source_config: vec![1, 0, 1, 0, 1, 0],
-                    target_config: vec![1, 0, 1, 0, 1, 0, 2, 0, 4, 0, 6, 0, 12],
+                    source_config: serde_json::json!(vec![true, false, true, false, true, false]),
+                    target_config: serde_json::json!(vec![1, 0, 1, 0, 1, 0, 2, 0, 4, 0, 6, 0, 12]),
                 },
             )
         },
diff --git a/src/rules/partition_knapsack.rs b/src/rules/partition_knapsack.rs
index 51d548a36..6ea901cca 100644
--- a/src/rules/partition_knapsack.rs
+++ b/src/rules/partition_knapsack.rs
@@ -18,35 +18,33 @@ impl ReductionResult for ReductionPartitionToKnapsack {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
-    }
-}
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
-fn partition_size_to_i64(value: u64) -> i64 {
-    i64::try_from(value)
-        .expect("Partition -> Knapsack requires all sizes and total_sum / 2 to fit in i64")
+        Ok(target_solution.to_vec())
+    }
 }
 
-#[reduction(overhead = {
-    num_items = "num_elements",
-})]
+#[reduction(
+    transform = exact { num_items = "num_elements" },
+    unavailable = {
+        capacity = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<Knapsack> for Partition {
     type Result = ReductionPartitionToKnapsack;
 
-    fn reduce_to(&self) -> Self::Result {
-        let weights: Vec<i64> = self
-            .sizes()
-            .iter()
-            .copied()
-            .map(partition_size_to_i64)
-            .collect();
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let weights = self.sizes().to_vec();
         let values = weights.clone();
-        let capacity = partition_size_to_i64(self.total_sum() / 2);
+        let capacity = self.total_sum() / 2;
 
-        ReductionPartitionToKnapsack {
+        Ok(ReductionPartitionToKnapsack {
             target: Knapsack::new(weights, values, capacity),
-        }
+        })
     }
 }
 
@@ -58,10 +56,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "partition_to_knapsack",
         build: || {
             crate::example_db::specs::rule_example_with_witness::<_, Knapsack>(
-                Partition::new(vec![3, 1, 1, 2, 2, 1]),
+                Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap(),
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1, 0, 0],
-                    target_config: vec![1, 0, 0, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, false, false, true, false, false]),
+                    target_config: serde_json::json!(vec![true, false, false, true, false, false]),
                 },
             )
         },
diff --git a/src/rules/partition_multiprocessorscheduling.rs b/src/rules/partition_multiprocessorscheduling.rs
index b47843dc9..9e35ce1d2 100644
--- a/src/rules/partition_multiprocessorscheduling.rs
+++ b/src/rules/partition_multiprocessorscheduling.rs
@@ -32,24 +32,37 @@ impl ReductionResult for ReductionPartitionToMPS {
 
     /// Solution extraction: identity mapping.
     /// Partition config (0/1 for subset) maps directly to processor assignment (0/1).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution
+            .iter()
+            .map(|&processor| processor == 1)
+            .collect())
     }
 }
 
-#[reduction(overhead = {
-    num_tasks = "num_elements",
-})]
+#[reduction(
+    transform = exact {
+        num_tasks = "num_elements",
+    },
+    unavailable = {
+        num_processors = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<MultiprocessorScheduling> for Partition {
     type Result = ReductionPartitionToMPS;
 
-    fn reduce_to(&self) -> Self::Result {
-        let lengths: Vec<u64> = self.sizes().to_vec();
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let lengths: Vec<i64> = self.sizes().to_vec();
         let deadline = self.total_sum() / 2;
 
-        ReductionPartitionToMPS {
+        Ok(ReductionPartitionToMPS {
             target: MultiprocessorScheduling::new(lengths, 2, deadline),
-        }
+        })
     }
 }
 
@@ -63,10 +76,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // sizes [1, 2, 3, 4], sum=10, target=5
             // partition: {1,4} on proc 0 and {2,3} on proc 1
             crate::example_db::specs::rule_example_with_witness::<_, MultiprocessorScheduling>(
-                Partition::new(vec![1, 2, 3, 4]),
+                Partition::new(vec![1, 2, 3, 4]).unwrap(),
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0],
-                    target_config: vec![0, 1, 1, 0],
+                    source_config: serde_json::json!(vec![false, true, true, false]),
+                    target_config: serde_json::json!(vec![0, 1, 1, 0]),
                 },
             )
         },
diff --git a/src/rules/partition_openshopscheduling.rs b/src/rules/partition_openshopscheduling.rs
index 309bd441d..f3126f0c5 100644
--- a/src/rules/partition_openshopscheduling.rs
+++ b/src/rules/partition_openshopscheduling.rs
@@ -7,6 +7,7 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 #[derive(Debug, Clone)]
 pub struct ReductionPartitionToOpenShopScheduling {
     target: OpenShopScheduling,
+    feasible_makespan: i64,
 }
 
 impl ReductionResult for ReductionPartitionToOpenShopScheduling {
@@ -17,92 +18,106 @@ impl ReductionResult for ReductionPartitionToOpenShopScheduling {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_elements = self.target.num_jobs().saturating_sub(1);
-        let mut source_config = vec![0; num_elements];
-        let Some(orders) = self.target.decode_orders(target_solution) else {
-            return source_config;
-        };
-        if num_elements == 0 {
-            return source_config;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target schedule does not certify a balanced partition",
+            ));
         }
 
-        let special_job = num_elements;
-        let half_sum = self.target.processing_times()[special_job][0];
-
-        // Find the middle machine and compute start times
-        let makespan_orders = &orders;
-        let n = self.target.num_jobs();
-        let m = self.target.num_machines();
-
-        // Simulate to get start times
-        let mut machine_avail = vec![0usize; m];
-        let mut job_avail = vec![0usize; n];
-        let mut start_times = vec![vec![0usize; m]; n];
-
-        // Schedule by processing the orders
-        let mut cursor = vec![0usize; m];
-        let total_ops = n * m;
-        for _ in 0..total_ops {
-            let mut best: Option<(usize, usize, usize)> = None; // (start, machine, job)
-            for (mi, order) in makespan_orders.iter().enumerate() {
-                if cursor[mi] < order.len() {
-                    let job = order[cursor[mi]];
-                    let start = machine_avail[mi].max(job_avail[job]);
-                    if best.is_none_or(|(bs, _, _)| start < bs) {
-                        best = Some((start, mi, job));
-                    }
+        Ok({
+            let num_elements = self.target.num_jobs() - 1;
+            let mut source_config = vec![false; num_elements];
+            let m = self.target.num_machines();
+            let start_times = target_solution
+                .chunks_exact(m)
+                .map(|times| {
+                    times
+                        .iter()
+                        .map(|&time| {
+                            i64::try_from(time).map_err(|_| {
+                                crate::rules::ExtractionError::invalid(
+                                    "target schedule time does not fit i64",
+                                )
+                            })
+                        })
+                        .collect::<Result<Vec<_>, _>>()
+                })
+                .collect::<Result<Vec<_>, _>>()?;
+            let special_job = num_elements;
+            let half_sum = self.target.processing_times()[special_job][0];
+
+            // Find the middle machine where the special job starts at half_sum
+            let middle_machine = (0..m)
+                .find(|&machine| start_times[special_job][machine] == half_sum)
+                .ok_or_else(|| {
+                    crate::rules::ExtractionError::invalid(
+                        "target schedule has no machine at the partition boundary",
+                    )
+                })?;
+            let pivot = start_times[special_job][middle_machine];
+
+            for (job, slot) in source_config.iter_mut().enumerate() {
+                let completion = start_times[job][middle_machine]
+                    .checked_add(self.target.processing_times()[job][middle_machine])
+                    .ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid("target schedule time overflows i64")
+                    })?;
+                if completion <= pivot {
+                    *slot = true;
                 }
             }
-            let (start, mi, job) = best.expect("schedule incomplete");
-            start_times[job][mi] = start;
-            let end = start + self.target.processing_times()[job][mi];
-            machine_avail[mi] = end;
-            job_avail[job] = end;
-            cursor[mi] += 1;
-        }
 
-        // Find the middle machine where the special job starts at half_sum
-        let middle_machine = (0..m)
-            .find(|&machine| start_times[special_job][machine] == half_sum)
-            .unwrap_or_else(|| {
-                let mut machines: Vec<usize> = (0..m).collect();
-                machines.sort_by_key(|&machine| (start_times[special_job][machine], machine));
-                machines[m / 2]
-            });
-        let pivot = start_times[special_job][middle_machine];
-
-        for (job, slot) in source_config.iter_mut().enumerate() {
-            let completion = start_times[job][middle_machine]
-                + self.target.processing_times()[job][middle_machine];
-            if completion <= pivot {
-                *slot = 1;
-            }
-        }
+            source_config
+        })
+    }
+}
+
+impl crate::rules::AggregateReductionResult for ReductionPartitionToOpenShopScheduling {
+    type Source = Partition;
+    type Target = OpenShopScheduling;
 
-        source_config
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, value: crate::types::Min<i64>) -> crate::types::Or {
+        crate::types::Or(value.0 == Some(self.feasible_makespan))
     }
 }
 
-#[reduction(overhead = {
-    num_jobs = "num_elements + 1",
-    num_machines = "3",
-})]
+#[reduction(
+    aggregate = custom,
+    transform = exact {
+        num_jobs = "num_elements + 1",
+        num_machines = "3",
+    },
+    unavailable = {
+        schedule_horizon = "depends on the numeric partition sizes, which are not represented by source size parameters",
+    }
+)]
 impl ReduceTo<OpenShopScheduling> for Partition {
     type Result = ReductionPartitionToOpenShopScheduling;
 
-    fn reduce_to(&self) -> Self::Result {
-        let half_sum = self.total_sum() as usize / 2;
-        let mut processing_times: Vec<Vec<usize>> = self
-            .sizes()
-            .iter()
-            .map(|&size| vec![size as usize; 3])
-            .collect();
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let half_sum = self.total_sum() / 2;
+        let mut processing_times: Vec<Vec<i64>> =
+            self.sizes().iter().map(|&size| vec![size; 3]).collect();
         processing_times.push(vec![half_sum; 3]);
 
-        ReductionPartitionToOpenShopScheduling {
-            target: OpenShopScheduling::new(3, processing_times),
-        }
+        let target = OpenShopScheduling::try_new(3, processing_times)
+            .map_err(<Self as ReduceTo<OpenShopScheduling>>::target_construction)?;
+        // The validated nonnegative schedule horizon includes these three terms.
+        let feasible_makespan = 3 * half_sum;
+        Ok(ReductionPartitionToOpenShopScheduling {
+            target,
+            feasible_makespan,
+        })
     }
 }
 
@@ -114,10 +129,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "partition_to_open_shop_scheduling",
         build: || {
             crate::example_db::specs::rule_example_with_witness::<_, OpenShopScheduling>(
-                Partition::new(vec![1, 2, 3]),
+                Partition::new(vec![1, 2, 3]).unwrap(),
                 SolutionPair {
-                    source_config: vec![0, 0, 1],
-                    target_config: vec![0, 1, 2, 3, 0, 1, 2, 3, 2, 3, 0, 1],
+                    source_config: serde_json::json!(vec![true, true, false]),
+                    target_config: serde_json::json!(vec![0, 5, 6, 1, 3, 7, 6, 0, 3, 3, 6, 0]),
                 },
             )
         },
diff --git a/src/rules/partition_productionplanning.rs b/src/rules/partition_productionplanning.rs
index c4ddcd3d3..3dc8856fb 100644
--- a/src/rules/partition_productionplanning.rs
+++ b/src/rules/partition_productionplanning.rs
@@ -17,22 +17,31 @@ impl ReductionResult for ReductionPartitionToProductionPlanning {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.target.num_periods() - 1]
             .iter()
-            .take(self.target.num_periods().saturating_sub(1))
-            .map(|&production| usize::from(production > 0))
-            .collect()
+            .map(|&production| production > 0)
+            .collect())
     }
 }
 
-#[reduction(overhead = {
-    num_periods = "num_elements + 1",
-})]
+#[reduction(
+    transform = exact {
+        num_periods = "num_elements + 1",
+    },
+    unavailable = {
+        max_capacity = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<ProductionPlanning> for Partition {
     type Result = ReductionPartitionToProductionPlanning;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let half_floor = self.total_sum() / 2;
         let half_ceil = half_floor + (self.total_sum() % 2);
         let mut demands = vec![0; self.num_elements()];
@@ -48,7 +57,7 @@ impl ReduceTo<ProductionPlanning> for Partition {
         let inventory_costs = vec![0; self.num_elements() + 1];
 
         let num_periods = self.num_elements() + 1;
-        ReductionPartitionToProductionPlanning {
+        Ok(ReductionPartitionToProductionPlanning {
             target: ProductionPlanning::new(
                 num_periods,
                 demands,
@@ -58,7 +67,7 @@ impl ReduceTo<ProductionPlanning> for Partition {
                 inventory_costs,
                 half_floor,
             ),
-        }
+        })
     }
 }
 
@@ -70,10 +79,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "partition_to_production_planning",
         build: || {
             crate::example_db::specs::rule_example_with_witness::<_, ProductionPlanning>(
-                Partition::new(vec![3, 5, 2, 4, 6]),
+                Partition::new(vec![3, 5, 2, 4, 6]).unwrap(),
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 1, 1],
-                    target_config: vec![0, 0, 0, 4, 6, 0],
+                    source_config: serde_json::json!(vec![false, false, false, true, true]),
+                    target_config: serde_json::json!(vec![0, 0, 0, 4, 6, 0]),
                 },
             )
         },
diff --git a/src/rules/partition_sequencingtominimizetardytaskweight.rs b/src/rules/partition_sequencingtominimizetardytaskweight.rs
index f47be5bc8..72827a5d0 100644
--- a/src/rules/partition_sequencingtominimizetardytaskweight.rs
+++ b/src/rules/partition_sequencingtominimizetardytaskweight.rs
@@ -10,21 +10,6 @@ pub struct ReductionPartitionToSequencingToMinimizeTardyTaskWeight {
     target: SequencingToMinimizeTardyTaskWeight,
 }
 
-impl ReductionPartitionToSequencingToMinimizeTardyTaskWeight {
-    fn decode_schedule(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.target.num_tasks();
-        assert_eq!(
-            target_solution.len(),
-            n,
-            "target solution length must equal target num_tasks"
-        );
-
-        // The target model uses direct permutation encoding (dims = [n; n]).
-        // Each position is a task index; the solver returns a valid permutation.
-        target_solution.to_vec()
-    }
-}
-
 impl ReductionResult for ReductionPartitionToSequencingToMinimizeTardyTaskWeight {
     type Source = Partition;
     type Target = SequencingToMinimizeTardyTaskWeight;
@@ -33,39 +18,73 @@ impl ReductionResult for ReductionPartitionToSequencingToMinimizeTardyTaskWeight
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let schedule = self.decode_schedule(target_solution);
-        let mut source_config = vec![1; self.target.num_tasks()];
-        let mut completion_time = 0u64;
-
-        for task in schedule {
-            completion_time = completion_time
-                .checked_add(self.target.lengths()[task])
-                .expect("completion time overflowed u64");
-            if completion_time <= self.target.deadlines()[task] {
-                source_config[task] = 0;
-            }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !crate::rules::AggregateReductionResult::extract_value(self, value).0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target schedule does not certify a balanced partition",
+            ));
         }
 
-        source_config
+        Ok({
+            let mut source_config = vec![true; self.target.num_tasks()];
+            let mut completion_time = 0i64;
+
+            for &task in target_solution {
+                completion_time = completion_time
+                    .checked_add(self.target.lengths()[task])
+                    .ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid(
+                            "target schedule completion time overflows i64",
+                        )
+                    })?;
+                if completion_time <= self.target.deadlines()[task] {
+                    source_config[task] = false;
+                }
+            }
+
+            source_config
+        })
+    }
+}
+
+impl crate::rules::AggregateReductionResult
+    for ReductionPartitionToSequencingToMinimizeTardyTaskWeight
+{
+    type Source = Partition;
+    type Target = SequencingToMinimizeTardyTaskWeight;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, value: crate::types::Min<i64>) -> crate::types::Or {
+        // The source is nonempty, so the common deadline always exists.
+        crate::types::Or(value.0 == Some(self.target.deadlines()[0]))
     }
 }
 
-#[reduction(overhead = {
-    num_tasks = "num_elements",
-})]
+#[reduction(
+    aggregate = custom,
+    transform = exact {
+        num_tasks = "num_elements",
+    })]
 impl ReduceTo<SequencingToMinimizeTardyTaskWeight> for Partition {
     type Result = ReductionPartitionToSequencingToMinimizeTardyTaskWeight;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let common_deadline = self.total_sum() / 2;
         let lengths = self.sizes().to_vec();
         let weights = self.sizes().to_vec();
         let deadlines = vec![common_deadline; self.num_elements()];
 
-        ReductionPartitionToSequencingToMinimizeTardyTaskWeight {
+        Ok(ReductionPartitionToSequencingToMinimizeTardyTaskWeight {
             target: SequencingToMinimizeTardyTaskWeight::new(lengths, weights, deadlines),
-        }
+        })
     }
 }
 
@@ -80,10 +99,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 _,
                 SequencingToMinimizeTardyTaskWeight,
             >(
-                Partition::new(vec![3, 1, 1, 2, 2, 1]),
+                Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap(),
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1, 0, 0],
-                    target_config: vec![1, 2, 4, 5, 0, 3],
+                    source_config: serde_json::json!(vec![true, false, false, true, false, false]),
+                    target_config: serde_json::json!(vec![1, 2, 4, 5, 0, 3]),
                 },
             )
         },
diff --git a/src/rules/partition_subsetsum.rs b/src/rules/partition_subsetsum.rs
index a092d46a0..57f6c0d14 100644
--- a/src/rules/partition_subsetsum.rs
+++ b/src/rules/partition_subsetsum.rs
@@ -7,7 +7,7 @@
 use crate::models::misc::{Partition, SubsetSum};
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
-use num_bigint::BigUint;
+use num_bigint::{BigUint, ToBigUint};
 
 /// Result of reducing Partition to SubsetSum.
 #[derive(Debug, Clone)]
@@ -26,29 +26,35 @@ impl ReductionResult for ReductionPartitionToSubsetSum {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        if target_solution.len() == self.source_n {
-            // Normal case: same elements, same binary vector.
-            target_solution.to_vec()
-        } else {
-            // Odd-sum case: target is trivially infeasible (0 elements).
-            // Return all-zero config for the source (which also won't satisfy it).
-            vec![0; self.source_n]
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        if target_solution.len() != self.source_n {
+            return Err(crate::rules::ExtractionError::invalid(format!(
+                "expected {} subset-selection values, got {}",
+                self.source_n,
+                target_solution.len()
+            )));
         }
+        Ok(target_solution.to_vec())
     }
 }
 
-#[reduction(overhead = {
-    num_elements = "num_elements",
-})]
+#[reduction(
+    transform = exact {
+        num_elements = "num_elements",
+    })]
 impl ReduceTo<SubsetSum> for Partition {
     type Result = ReductionPartitionToSubsetSum;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let total = self.total_sum();
         let source_n = self.num_elements();
 
-        if !total.is_multiple_of(2) {
+        Ok(if total % 2 != 0 {
             // Odd total sum: no balanced partition exists.
             // Return a trivially infeasible SubsetSum: no elements, target = 1.
             ReductionPartitionToSubsetSum {
@@ -56,13 +62,22 @@ impl ReduceTo<SubsetSum> for Partition {
                 source_n,
             }
         } else {
-            let sizes: Vec<BigUint> = self.sizes().iter().map(|&s| BigUint::from(s)).collect();
-            let target_val = BigUint::from(total / 2);
+            let sizes: Vec<BigUint> = self
+                .sizes()
+                .iter()
+                .map(|&size| {
+                    size.to_biguint()
+                        .expect("validated nonnegative Partition size")
+                })
+                .collect();
+            let target_val = (total / 2)
+                .to_biguint()
+                .expect("validated nonnegative Partition total");
             ReductionPartitionToSubsetSum {
                 target: SubsetSum::new_unchecked(sizes, target_val),
                 source_n,
             }
-        }
+        })
     }
 }
 
@@ -74,10 +89,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "partition_to_subsetsum",
         build: || {
             crate::example_db::specs::rule_example_with_witness::<_, SubsetSum>(
-                Partition::new(vec![3, 1, 1, 2, 2, 1]),
+                Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap(),
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1, 0, 0],
-                    target_config: vec![1, 0, 0, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, false, false, true, false, false]),
+                    target_config: serde_json::json!(vec![true, false, false, true, false, false]),
                 },
             )
         },
diff --git a/src/rules/partition_sumofsquarespartition.rs b/src/rules/partition_sumofsquarespartition.rs
index f8fded1f9..8eb491c9b 100644
--- a/src/rules/partition_sumofsquarespartition.rs
+++ b/src/rules/partition_sumofsquarespartition.rs
@@ -42,28 +42,38 @@ impl ReductionResult for ReductionPartitionToSumOfSquaresPartition {
         &self.target
     }
 
-    /// Solution extraction: identity mapping in the normal case.
-    /// In the sentinel case (source has fewer than two elements) the target's
-    /// witness has a different length, so we return an all-zero source-sized
-    /// vector; `Partition::evaluate` then yields `Or(false)`, which is the
-    /// correct answer because a single positive element cannot be balanced.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        if target_solution.len() == self.source_n {
-            target_solution.to_vec()
-        } else {
-            vec![0; self.source_n]
+    /// Solution extraction preserves the source elements. The sentinel target
+    /// appends elements, so only the prefix corresponding to actual source
+    /// elements is mapped back.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if target_solution.len() != self.target.num_elements() {
+            return Err(crate::rules::ExtractionError::invalid(format!(
+                "expected {} target group assignments, got {}",
+                self.target.num_elements(),
+                target_solution.len()
+            )));
         }
+
+        Ok(target_solution[..self.source_n]
+            .iter()
+            .map(|&group| group == 1)
+            .collect())
     }
 }
 
-#[reduction(overhead = {
-    num_elements = "num_elements",
-    num_groups = "2",
-})]
+#[reduction(
+    transform = exact {
+        num_elements = "num_elements",
+        num_groups = "2",
+    })]
 impl ReduceTo<SumOfSquaresPartition> for Partition {
     type Result = ReductionPartitionToSumOfSquaresPartition;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let source_n = self.num_elements();
 
         if source_n < 2 {
@@ -71,24 +81,16 @@ impl ReduceTo<SumOfSquaresPartition> for Partition {
             // so we cannot build a K=2 instance from a singleton. The singleton
             // Partition is always NO (a single positive element cannot be
             // partitioned into two equal-sum subsets).
-            return ReductionPartitionToSumOfSquaresPartition {
+            return Ok(ReductionPartitionToSumOfSquaresPartition {
                 target: SumOfSquaresPartition::new(vec![1, 1], 2),
                 source_n,
-            };
+            });
         }
 
-        // Sizes in Partition are `u64` (always positive). Canonical inputs in
-        // this repo fit comfortably in `i64`; we cast directly.
-        let sizes_i64: Vec<i64> = self
-            .sizes()
-            .iter()
-            .map(|&s| i64::try_from(s).expect("Partition size exceeds i64::MAX"))
-            .collect();
-
-        ReductionPartitionToSumOfSquaresPartition {
-            target: SumOfSquaresPartition::new(sizes_i64, 2),
+        Ok(ReductionPartitionToSumOfSquaresPartition {
+            target: SumOfSquaresPartition::new(self.sizes().to_vec(), 2),
             source_n,
-        }
+        })
     }
 }
 
@@ -102,10 +104,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // sizes [3, 1, 1, 2, 2, 1], S = 10, balanced split sums to 5/5.
             // Witness: {3, 2} (group 0) and {1, 1, 2, 1} (group 1) -> 5^2 + 5^2 = 50 = S^2 / 2.
             crate::example_db::specs::rule_example_with_witness::<_, SumOfSquaresPartition>(
-                Partition::new(vec![3, 1, 1, 2, 2, 1]),
+                Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap(),
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0, 1, 1],
-                    target_config: vec![0, 1, 1, 0, 1, 1],
+                    source_config: serde_json::json!(vec![false, true, true, false, true, true]),
+                    target_config: serde_json::json!(vec![0, 1, 1, 0, 1, 1]),
                 },
             )
         },
diff --git a/src/rules/partitionintocliques_ilp.rs b/src/rules/partitionintocliques_ilp.rs
new file mode 100644
index 000000000..843c6a905
--- /dev/null
+++ b/src/rules/partitionintocliques_ilp.rs
@@ -0,0 +1,117 @@
+//! Reduction from PartitionIntoCliques to binary ILP.
+
+use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::models::graph::PartitionIntoCliques;
+use crate::reduction;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::topology::{Graph, SimpleGraph};
+
+#[derive(Debug, Clone)]
+pub struct ReductionPartitionIntoCliquesToILP {
+    target: ILP<bool>,
+    num_vertices: usize,
+    num_cliques: usize,
+}
+
+impl ReductionResult for ReductionPartitionIntoCliquesToILP {
+    type Source = PartitionIntoCliques<SimpleGraph>;
+    type Target = ILP<bool>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        (0..self.num_vertices)
+            .map(|vertex| {
+                (0..self.num_cliques)
+                    .find(|&clique| target_solution[vertex * self.num_cliques + clique] == 1)
+                    .ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid(format!(
+                            "target solution does not assign vertex {vertex} to a clique"
+                        ))
+                    })
+            })
+            .collect()
+    }
+}
+
+#[reduction(
+    transform = upper_bound {
+        num_vars = "num_vertices^2",
+        num_constraints = "num_vertices + num_vertices^3",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter depends on the source clique bound and non-edges",
+    }
+)]
+impl ReduceTo<ILP<bool>> for PartitionIntoCliques<SimpleGraph> {
+    type Result = ReductionPartitionIntoCliquesToILP;
+
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let num_vertices = self.num_vertices();
+        let num_cliques = self.num_cliques();
+        let num_vars = num_vertices * num_cliques;
+        let variable = |vertex: usize, clique: usize| vertex * num_cliques + clique;
+        let mut constraints = Vec::new();
+
+        for vertex in 0..num_vertices {
+            constraints.push(LinearConstraint::eq(
+                (0..num_cliques)
+                    .map(|clique| (variable(vertex, clique), 1))
+                    .collect(),
+                1,
+            ));
+        }
+
+        for u in 0..num_vertices {
+            for v in (u + 1)..num_vertices {
+                if !self.graph().has_edge(u, v) {
+                    for clique in 0..num_cliques {
+                        constraints.push(LinearConstraint::le(
+                            vec![(variable(u, clique), 1), (variable(v, clique), 1)],
+                            1,
+                        ));
+                    }
+                }
+            }
+        }
+
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
+
+        Ok(ReductionPartitionIntoCliquesToILP {
+            target,
+            num_vertices,
+            num_cliques,
+        })
+    }
+}
+
+#[cfg(feature = "example-db")]
+pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
+    use crate::export::SolutionPair;
+
+    vec![crate::example_db::specs::RuleExampleSpec {
+        id: "partitionintocliques_to_ilp",
+        build: || {
+            let source = PartitionIntoCliques::new(SimpleGraph::new(3, vec![(0, 1)]), 2);
+            crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
+                source,
+                SolutionPair {
+                    source_config: serde_json::json!(vec![0, 0, 1]),
+                    target_config: serde_json::json!(vec![1, 0, 1, 0, 0, 1]),
+                },
+            )
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/partitionintocliques_ilp.rs"]
+mod tests;
diff --git a/src/rules/partitionintocliques_minimumcoveringbycliques.rs b/src/rules/partitionintocliques_minimumcoveringbycliques.rs
index d73b71533..b3078e508 100644
--- a/src/rules/partitionintocliques_minimumcoveringbycliques.rs
+++ b/src/rules/partitionintocliques_minimumcoveringbycliques.rs
@@ -4,11 +4,15 @@
 //! the source vertices into an edge-clique cover. The target graph contains
 //! left/right copies of the source vertices, one directed gadget per source
 //! edge, and two side-clique anchors.
+//! The source is satisfiable iff the target optimum is at most min(K,n) + q + 2,
+//! where q counts distinct directed non-loop adjacencies. Each side includes
+//! a private vertex, so its forced clique exists even for an empty source.
 
 use crate::models::graph::{MinimumCoveringByCliques, PartitionIntoCliques};
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
+use crate::types::{Min, OptimizationValue, Or};
 use std::collections::BTreeMap;
 
 #[derive(Debug, Clone)]
@@ -64,6 +68,7 @@ impl OrlinLayout {
             .map(|i| self.x(i))
             .collect::<Vec<_>>();
         vertices.extend((0..self.num_directed_pairs()).map(|idx| self.a(idx)));
+        vertices.push(self.z_right() + 1);
         vertices
     }
 
@@ -72,11 +77,40 @@ impl OrlinLayout {
             .map(|i| self.y(i))
             .collect::<Vec<_>>();
         vertices.extend((0..self.num_directed_pairs()).map(|idx| self.b(idx)));
+        vertices.push(self.z_right() + 2);
         vertices
     }
 
-    fn total_vertices(&self) -> usize {
-        self.z_right() + 1
+    fn dimensions(&self) -> Result<(usize, usize), crate::rules::ReductionError> {
+        let n = self.num_source_vertices;
+        let q = self.num_directed_pairs();
+        let overflow = |operation: &str| {
+            crate::rules::ReductionError::integer_overflow::<
+                PartitionIntoCliques<SimpleGraph>,
+                MinimumCoveringByCliques<SimpleGraph>,
+            >(operation)
+        };
+        // The two sides each have n+q+1 vertices, including their private
+        // vertex. These checked counts bound every subsequent layout index.
+        let side = n
+            .checked_add(q)
+            .and_then(|s| s.checked_add(1))
+            .ok_or_else(|| overflow("counting side vertices"))?;
+        let target_vertices = side
+            .checked_mul(2)
+            .and_then(|s| s.checked_add(2))
+            .ok_or_else(|| overflow("counting target vertices"))?;
+        let target_edges = side
+            .checked_mul(side)
+            .and_then(|s| s.checked_add(side))
+            .and_then(|s| s.checked_add(n))
+            .and_then(|s| q.checked_mul(4).and_then(|cross| s.checked_add(cross)))
+            .ok_or_else(|| overflow("counting target edges"))?;
+        <PartitionIntoCliques<SimpleGraph> as ReduceTo<MinimumCoveringByCliques<SimpleGraph>>>::exact_i64(
+            target_edges,
+            "representing every target cover value",
+        )?;
+        Ok((target_vertices, target_edges))
     }
 }
 
@@ -88,16 +122,28 @@ fn add_clique_edges(vertices: &[usize], edges: &mut Vec<(usize, usize)>) {
     }
 }
 
-fn invalid_source_solution(num_source_vertices: usize, num_source_cliques: usize) -> Vec<usize> {
-    vec![num_source_cliques; num_source_vertices]
+fn target_clique_bound(
+    num_cliques: i64,
+    num_directed_pairs: i64,
+) -> Result<i64, crate::rules::ReductionError> {
+    num_directed_pairs
+        .checked_add(2)
+        .and_then(|offset| num_cliques.checked_add(offset))
+        .ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                PartitionIntoCliques<SimpleGraph>,
+                MinimumCoveringByCliques<SimpleGraph>,
+            >("computing target clique bound")
+        })
 }
 
 /// Result of reducing PartitionIntoCliques to MinimumCoveringByCliques.
 #[derive(Debug, Clone)]
 pub struct ReductionPartitionIntoCliquesToMinimumCoveringByCliques {
     target: MinimumCoveringByCliques<SimpleGraph>,
-    source_graph: SimpleGraph,
+    num_source_vertices: usize,
     source_num_cliques: usize,
+    target_bound: i64,
 }
 
 impl ReductionResult for ReductionPartitionIntoCliquesToMinimumCoveringByCliques {
@@ -108,75 +154,107 @@ impl ReductionResult for ReductionPartitionIntoCliquesToMinimumCoveringByCliques
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.source_graph.num_vertices();
-        let target_edges = self.target.graph().edges();
-        if target_solution.len() != target_edges.len() {
-            return invalid_source_solution(n, self.source_num_cliques);
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !Min::meets_bound(&value, &self.target_bound) {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target cover does not certify the source clique bound",
+            ));
         }
 
-        let mut matching_labels = vec![None; n];
-        for ((u, v), &label) in target_edges.iter().zip(target_solution.iter()) {
-            let matching_index = if *u < n && *v == n + *u {
-                Some(*u)
-            } else if *v < n && *u == n + *v {
-                Some(*v)
-            } else {
-                None
-            };
-
-            if let Some(i) = matching_index {
-                matching_labels[i] = Some(label);
+        Ok({
+            let n = self.num_source_vertices;
+            let target_edges = self.target.graph().edges();
+            let mut matching_labels = vec![None; n];
+            for ((u, v), &label) in target_edges.iter().zip(target_solution.iter()) {
+                let matching_index = if *u < n && *v == n + *u {
+                    Some(*u)
+                } else if *v < n && *u == n + *v {
+                    Some(*v)
+                } else {
+                    None
+                };
+
+                if let Some(i) = matching_index {
+                    matching_labels[i] = Some(label);
+                }
             }
-        }
 
-        if matching_labels.iter().any(Option::is_none) {
-            return invalid_source_solution(n, self.source_num_cliques);
-        }
+            let mut label_map = BTreeMap::new();
+            let extracted = matching_labels
+                .into_iter()
+                .map(|label| {
+                    let label = label.ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid(
+                            "target cover does not label every matching gadget edge",
+                        )
+                    })?;
+                    let next = label_map.len();
+                    Ok(*label_map.entry(label).or_insert(next))
+                })
+                .collect::<crate::rules::ExtractionResult<Vec<_>>>()?;
+
+            if label_map.len() > self.source_num_cliques {
+                return Err(crate::rules::ExtractionError::invalid(format!(
+                    "target cover uses {} cliques, exceeding source bound {}",
+                    label_map.len(),
+                    self.source_num_cliques
+                )));
+            }
 
-        let mut label_map = BTreeMap::new();
-        let extracted = matching_labels
-            .into_iter()
-            .map(|label| {
-                let label = label.expect("checked above");
-                let next = label_map.len();
-                *label_map.entry(label).or_insert(next)
-            })
-            .collect::<Vec<_>>();
+            // Equal matching-edge labels imply pairwise source adjacency.
+            // The target certificate leaves at most K labels for these edges.
+            extracted
+        })
+    }
+}
 
-        if label_map.len() > self.source_num_cliques {
-            return invalid_source_solution(n, self.source_num_cliques);
-        }
+impl crate::rules::AggregateReductionResult
+    for ReductionPartitionIntoCliquesToMinimumCoveringByCliques
+{
+    type Source = PartitionIntoCliques<SimpleGraph>;
+    type Target = MinimumCoveringByCliques<SimpleGraph>;
 
-        let source_problem =
-            PartitionIntoCliques::new(self.source_graph.clone(), self.source_num_cliques);
-        if <PartitionIntoCliques<SimpleGraph> as crate::traits::Problem>::evaluate(
-            &source_problem,
-            &extracted,
-        )
-        .0
-        {
-            extracted
-        } else {
-            invalid_source_solution(n, self.source_num_cliques)
-        }
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, target_value: Min<i64>) -> Or {
+        Or(Min::meets_bound(&target_value, &self.target_bound))
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "2 * num_vertices + 4 * num_edges + 2",
-        num_edges = "(num_vertices + 2 * num_edges)^2 + 2 * num_vertices + 10 * num_edges",
+    aggregate = custom,
+    transform = upper_bound {
+        num_vertices = "2 * num_vertices + 4 * num_edges + 4",
+        num_edges = "(num_vertices + 2 * num_edges)^2 + 4 * num_vertices + 14 * num_edges + 2",
     }
 )]
 impl ReduceTo<MinimumCoveringByCliques<SimpleGraph>> for PartitionIntoCliques<SimpleGraph> {
     type Result = ReductionPartitionIntoCliquesToMinimumCoveringByCliques;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let n = self.num_vertices();
         let layout = OrlinLayout::new(self.graph());
+        let q = layout.num_directed_pairs();
+        let (target_vertices, target_edges) = layout.dimensions()?;
+        let source_bound = <Self as ReduceTo<MinimumCoveringByCliques<SimpleGraph>>>::exact_i64(
+            self.num_cliques().min(n),
+            "converting effective clique bound",
+        )?;
+        let directed_pairs = <Self as ReduceTo<MinimumCoveringByCliques<SimpleGraph>>>::exact_i64(
+            q,
+            "converting gadget count",
+        )?;
+        let target_bound = target_clique_bound(source_bound, directed_pairs)?;
         let left_vertices = layout.left_vertices();
         let right_vertices = layout.right_vertices();
-        let mut edges = Vec::new();
+        let mut edges = Vec::with_capacity(target_edges);
 
         // Step 1-2: L and R are cliques.
         add_clique_edges(&left_vertices, &mut edges);
@@ -203,14 +281,15 @@ impl ReduceTo<MinimumCoveringByCliques<SimpleGraph>> for PartitionIntoCliques<Si
             edges.push((layout.a(idx), layout.b(idx)));
         }
 
-        let target_graph = SimpleGraph::new(layout.total_vertices(), edges);
+        let target_graph = SimpleGraph::new(target_vertices, edges);
         let target = MinimumCoveringByCliques::new(target_graph);
 
-        ReductionPartitionIntoCliquesToMinimumCoveringByCliques {
+        Ok(ReductionPartitionIntoCliquesToMinimumCoveringByCliques {
             target,
-            source_graph: self.graph().clone(),
+            num_source_vertices: n,
             source_num_cliques: self.num_cliques(),
-        }
+            target_bound,
+        })
     }
 }
 
@@ -246,7 +325,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "partitionintocliques_to_minimumcoveringbycliques",
         build: || {
             let source = PartitionIntoCliques::new(SimpleGraph::new(3, vec![(0, 1)]), 2);
-            let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source);
+            let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source)
+                .expect("reduction should succeed");
             let layout = OrlinLayout::new(source.graph());
 
             let target_config = edge_labels_from_clique_cover(
@@ -275,8 +355,9 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 1],
-                    target_config,
+                    source_config: serde_json::json!(vec![0, 0, 1]),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/partitionintopathsoflength2_boundedcomponentspanningforest.rs b/src/rules/partitionintopathsoflength2_boundedcomponentspanningforest.rs
index df158820c..193a5d681 100644
--- a/src/rules/partitionintopathsoflength2_boundedcomponentspanningforest.rs
+++ b/src/rules/partitionintopathsoflength2_boundedcomponentspanningforest.rs
@@ -18,12 +18,12 @@ use crate::topology::{Graph, SimpleGraph};
 /// Result of reducing PartitionIntoPathsOfLength2 to BoundedComponentSpanningForest.
 #[derive(Debug, Clone)]
 pub struct ReductionPPL2ToBCSF {
-    target: BoundedComponentSpanningForest<SimpleGraph, i32>,
+    target: BoundedComponentSpanningForest<SimpleGraph, i64>,
 }
 
 impl ReductionResult for ReductionPPL2ToBCSF {
     type Source = PartitionIntoPathsOfLength2<SimpleGraph>;
-    type Target = BoundedComponentSpanningForest<SimpleGraph, i32>;
+    type Target = BoundedComponentSpanningForest<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
@@ -33,24 +33,29 @@ impl ReductionResult for ReductionPPL2ToBCSF {
     ///
     /// Both problems use the same vertex-to-group assignment encoding,
     /// so the solution mapping is identity.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices",
         num_edges = "num_edges",
         max_components = "num_vertices / 3",
     }
 )]
-impl ReduceTo<BoundedComponentSpanningForest<SimpleGraph, i32>>
+impl ReduceTo<BoundedComponentSpanningForest<SimpleGraph, i64>>
     for PartitionIntoPathsOfLength2<SimpleGraph>
 {
     type Result = ReductionPPL2ToBCSF;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let q = n / 3;
 
@@ -59,12 +64,12 @@ impl ReduceTo<BoundedComponentSpanningForest<SimpleGraph, i32>>
 
         let target = BoundedComponentSpanningForest::new(
             SimpleGraph::new(n, self.graph().edges()),
-            vec![1i32; n],  // unit weights
+            vec![1i64; n],  // unit weights
             max_components, // K = max(|V|/3, 1)
             3,              // B = 3
         );
 
-        ReductionPPL2ToBCSF { target }
+        Ok(ReductionPPL2ToBCSF { target })
     }
 }
 
@@ -82,12 +87,12 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             ));
             crate::example_db::specs::rule_example_with_witness::<
                 _,
-                BoundedComponentSpanningForest<SimpleGraph, i32>,
+                BoundedComponentSpanningForest<SimpleGraph, i64>,
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 1, 1, 1],
-                    target_config: vec![0, 0, 0, 1, 1, 1],
+                    source_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1]),
+                    target_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1]),
                 },
             )
         },
diff --git a/src/rules/partitionintopathsoflength2_ilp.rs b/src/rules/partitionintopathsoflength2_ilp.rs
index 2e3c3ccc6..f652ba758 100644
--- a/src/rules/partitionintopathsoflength2_ilp.rs
+++ b/src/rules/partitionintopathsoflength2_ilp.rs
@@ -19,6 +19,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::PartitionIntoPathsOfLength2;
 use crate::reduction;
+use crate::rules::ilp_helpers::mccormick_product;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
 
@@ -43,31 +44,34 @@ impl ReductionResult for ReductionPIPL2ToILP {
     }
 
     /// Extract solution: for each vertex v, find the unique group g where x_{v,g} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_groups = self.num_groups;
-        (0..self.num_vertices)
-            .map(|v| {
-                (0..num_groups)
-                    .find(|&g| {
-                        let idx = v * num_groups + g;
-                        idx < target_solution.len() && target_solution[idx] == 1
-                    })
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_vertices,
+            self.num_groups,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_vertices^2 + num_edges * num_vertices",
         num_constraints = "num_vertices^2 + num_edges * num_vertices + num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for PartitionIntoPathsOfLength2<SimpleGraph> {
     type Result = ReductionPIPL2ToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vertices = self.num_vertices();
         let q = self.num_groups();
         let edges: Vec<(usize, usize)> = self.graph().edges();
@@ -78,14 +82,14 @@ impl ReduceTo<ILP<bool>> for PartitionIntoPathsOfLength2<SimpleGraph> {
 
         // Assignment constraints: for each vertex v, Σ_g x_{v,g} = 1
         for v in 0..num_vertices {
-            let terms: Vec<(usize, f64)> = (0..q).map(|g| (v * q + g, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..q).map(|g| (v * q + g, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Group size constraints: for each group g, Σ_v x_{v,g} = 3
         for g in 0..q {
-            let terms: Vec<(usize, f64)> = (0..num_vertices).map(|v| (v * q + g, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 3.0));
+            let terms: Vec<(usize, i64)> = (0..num_vertices).map(|v| (v * q + g, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 3));
         }
 
         // McCormick linearization: y_{e,g} = x_{u,g} * x_{v,g} for each edge e=(u,v) and group g
@@ -96,33 +100,26 @@ impl ReduceTo<ILP<bool>> for PartitionIntoPathsOfLength2<SimpleGraph> {
                 let xu = u * q + g;
                 let xv = v * q + g;
 
-                // y ≤ x_{u,g}
-                constraints.push(LinearConstraint::le(vec![(y, 1.0), (xu, -1.0)], 0.0));
-                // y ≤ x_{v,g}
-                constraints.push(LinearConstraint::le(vec![(y, 1.0), (xv, -1.0)], 0.0));
-                // y ≥ x_{u,g} + x_{v,g} - 1  →  -y + x_{u,g} + x_{v,g} ≤ 1
-                constraints.push(LinearConstraint::le(
-                    vec![(y, -1.0), (xu, 1.0), (xv, 1.0)],
-                    1.0,
-                ));
+                constraints.extend(mccormick_product(y, xu, xv));
             }
         }
 
         // At-least-2-edges constraint: for each group g, Σ_e y_{e,g} ≥ 2
         for g in 0..q {
-            let terms: Vec<(usize, f64)> = (0..num_edges)
-                .map(|e| (num_vertices * q + e * q + g, 1.0))
+            let terms: Vec<(usize, i64)> = (0..num_edges)
+                .map(|e| (num_vertices * q + e * q + g, 1))
                 .collect();
-            constraints.push(LinearConstraint::ge(terms, 2.0));
+            constraints.push(LinearConstraint::ge(terms, 2));
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionPIPL2ToILP {
+        Ok(ReductionPIPL2ToILP {
             target,
             num_vertices,
             num_groups: q,
-        }
+        })
     }
 }
 
diff --git a/src/rules/partitionintotriangles_ilp.rs b/src/rules/partitionintotriangles_ilp.rs
index 18d32c5ca..b80d3fe8c 100644
--- a/src/rules/partitionintotriangles_ilp.rs
+++ b/src/rules/partitionintotriangles_ilp.rs
@@ -37,31 +37,34 @@ impl ReductionResult for ReductionPITToILP {
     }
 
     /// Extract solution: for each vertex v, find the unique group g where x_{v,g} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_groups = self.num_groups;
-        (0..self.num_vertices)
-            .map(|v| {
-                (0..num_groups)
-                    .find(|&g| {
-                        let idx = v * num_groups + g;
-                        idx < target_solution.len() && target_solution[idx] == 1
-                    })
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_vertices,
+            self.num_groups,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_vertices^2",
         num_constraints = "num_vertices^2 * num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for PartitionIntoTriangles<SimpleGraph> {
     type Result = ReductionPITToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vertices = self.num_vertices();
         let q = num_vertices / 3; // number of groups
         let num_vars = num_vertices * q;
@@ -70,14 +73,14 @@ impl ReduceTo<ILP<bool>> for PartitionIntoTriangles<SimpleGraph> {
 
         // Assignment constraints: for each vertex v, Σ_g x_{v,g} = 1
         for v in 0..num_vertices {
-            let terms: Vec<(usize, f64)> = (0..q).map(|g| (v * q + g, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..q).map(|g| (v * q + g, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Group size constraints: for each group g, Σ_v x_{v,g} = 3
         for g in 0..q {
-            let terms: Vec<(usize, f64)> = (0..num_vertices).map(|v| (v * q + g, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 3.0));
+            let terms: Vec<(usize, i64)> = (0..num_vertices).map(|v| (v * q + g, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 3));
         }
 
         // Triangle constraints: for each group g and each non-edge (u,v),
@@ -88,21 +91,22 @@ impl ReduceTo<ILP<bool>> for PartitionIntoTriangles<SimpleGraph> {
                 for v in (u + 1)..num_vertices {
                     if !graph.has_edge(u, v) {
                         constraints.push(LinearConstraint::le(
-                            vec![(u * q + g, 1.0), (v * q + g, 1.0)],
-                            1.0,
+                            vec![(u * q + g, 1), (v * q + g, 1)],
+                            1,
                         ));
                     }
                 }
             }
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionPITToILP {
+        Ok(ReductionPITToILP {
             target,
             num_vertices,
             num_groups: q,
-        }
+        })
     }
 }
 
diff --git a/src/rules/pathconstrainednetworkflow_ilp.rs b/src/rules/pathconstrainednetworkflow_ilp.rs
index ce761eb79..799cebfc8 100644
--- a/src/rules/pathconstrainednetworkflow_ilp.rs
+++ b/src/rules/pathconstrainednetworkflow_ilp.rs
@@ -11,60 +11,66 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Result of reducing PathConstrainedNetworkFlow to ILP.
 #[derive(Debug, Clone)]
 pub struct ReductionPCNFToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
 }
 
 impl ReductionResult for ReductionPCNFToILP {
     type Source = PathConstrainedNetworkFlow;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::decode_usize_values(target_solution)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_paths",
         num_constraints = "num_arcs + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for PathConstrainedNetworkFlow {
+impl ReduceTo<ILP<i64>> for PathConstrainedNetworkFlow {
     type Result = ReductionPCNFToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_paths = self.num_paths();
         let num_arcs = self.num_arcs();
         let mut constraints = Vec::new();
 
         // Arc capacity: sum_{i : a in P_i} f_i <= c_a for all a
         for arc_idx in 0..num_arcs {
-            let terms: Vec<(usize, f64)> = self
+            let terms: Vec<(usize, i64)> = self
                 .paths()
                 .iter()
                 .enumerate()
                 .filter(|(_, path)| path.contains(&arc_idx))
-                .map(|(path_idx, _)| (path_idx, 1.0))
+                .map(|(path_idx, _)| (path_idx, 1))
                 .collect();
             if !terms.is_empty() {
-                constraints.push(LinearConstraint::le(
-                    terms,
-                    self.capacities()[arc_idx] as f64,
-                ));
+                constraints.push(LinearConstraint::le(terms, self.capacities()[arc_idx]));
             }
         }
 
         // Total flow requirement: sum_i f_i >= R
-        let total_terms: Vec<(usize, f64)> = (0..num_paths).map(|i| (i, 1.0)).collect();
-        constraints.push(LinearConstraint::ge(total_terms, self.requirement() as f64));
+        let total_terms: Vec<(usize, i64)> = (0..num_paths).map(|i| (i, 1)).collect();
+        constraints.push(LinearConstraint::ge(total_terms, self.requirement()));
 
-        ReductionPCNFToILP {
-            target: ILP::new(num_paths, constraints, vec![], ObjectiveSense::Minimize),
-        }
+        Ok(ReductionPCNFToILP {
+            target: ILP::new(num_paths, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
+        })
     }
 }
 
@@ -85,7 +91,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 vec![vec![0, 1], vec![2]],
                 2,
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/precedenceconstrainedscheduling_ilp.rs b/src/rules/precedenceconstrainedscheduling_ilp.rs
index d464cc2a6..c79cbc5fc 100644
--- a/src/rules/precedenceconstrainedscheduling_ilp.rs
+++ b/src/rules/precedenceconstrainedscheduling_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from PrecedenceConstrainedScheduling to ILP<bool>.
+//! Reduction from PrecedenceConstrainedScheduling to `ILP<bool>`.
 //!
 //! Uses a time-indexed binary formulation:
 //! - Variables: Binary x_{j,t} where x_{j,t} = 1 iff task j is scheduled at time slot t.
@@ -15,7 +15,7 @@ use crate::models::misc::PrecedenceConstrainedScheduling;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing PrecedenceConstrainedScheduling to ILP<bool>.
+/// Result of reducing PrecedenceConstrainedScheduling to `ILP<bool>`.
 ///
 /// Variable layout: x_{j,t} at index j * deadline + t
 /// for j in 0..num_tasks, t in 0..deadline.
@@ -38,66 +38,80 @@ impl ReductionResult for ReductionPCSToILP {
     ///
     /// For each task j, find the time slot t where x_{j,t} = 1.
     /// Returns the time slot for each task (matching the `dims()` encoding of PCS).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let d = self.deadline;
-        (0..self.num_tasks)
-            .map(|j| {
-                (0..d)
-                    .find(|&t| target_solution.get(j * d + t).copied().unwrap_or(0) == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_tasks,
+            self.deadline,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_tasks * deadline",
-        num_constraints = "num_tasks + deadline + num_tasks^2",
+        num_constraints = "num_tasks + deadline + num_precedences",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for PrecedenceConstrainedScheduling {
     type Result = ReductionPCSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
-        let m = self.num_processors();
-        let d = self.deadline();
+        let d = usize::try_from(self.deadline()).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                PrecedenceConstrainedScheduling,
+                ILP<bool>,
+            >("validated deadline must fit usize")
+        })?;
         let num_vars = n * d;
 
         // x_{j,t} variable index
         let var = |j: usize, t: usize| j * d + t;
+        let processor_count =
+            Self::exact_i64(self.num_processors(), "encoding the processor capacity")?;
 
         let mut constraints = Vec::new();
 
         // 1. One-hot: Σ_t x_{j,t} = 1 for each task j
         for j in 0..n {
-            let terms: Vec<(usize, f64)> = (0..d).map(|t| (var(j, t), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..d).map(|t| (var(j, t), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 2. Capacity: Σ_j x_{j,t} ≤ m for each time slot t
         for t in 0..d {
-            let terms: Vec<(usize, f64)> = (0..n).map(|j| (var(j, t), 1.0)).collect();
-            constraints.push(LinearConstraint::le(terms, m as f64));
+            let terms: Vec<(usize, i64)> = (0..n).map(|j| (var(j, t), 1)).collect();
+            constraints.push(LinearConstraint::le(terms, processor_count));
         }
 
         // 3. Precedence: Σ_t t·x_{j,t} ≥ Σ_t t·x_{i,t} + 1 for each (i,j)
         // Rearranged: Σ_t t·x_{j,t} - Σ_t t·x_{i,t} ≥ 1
         for &(i, j) in self.precedences() {
-            let mut terms: Vec<(usize, f64)> = Vec::new();
+            let mut terms: Vec<(usize, i64)> = Vec::new();
             for t in 0..d {
-                terms.push((var(j, t), t as f64));
-                terms.push((var(i, t), -(t as f64)));
+                let t_i64 = Self::exact_i64(t, "encoding a time slot")?;
+                terms.push((var(j, t), t_i64));
+                terms.push((var(i, t), -t_i64));
             }
-            constraints.push(LinearConstraint::ge(terms, 1.0));
+            constraints.push(LinearConstraint::ge(terms, 1));
         }
 
-        ReductionPCSToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionPCSToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
             deadline: d,
-        }
+        })
     }
 }
 
diff --git a/src/rules/preemptivescheduling_ilp.rs b/src/rules/preemptivescheduling_ilp.rs
index 3c068ec71..f6d65c971 100644
--- a/src/rules/preemptivescheduling_ilp.rs
+++ b/src/rules/preemptivescheduling_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from PreemptiveScheduling to ILP<i32>.
+//! Reduction from PreemptiveScheduling to `ILP<i64>`.
 //!
 //! Time-indexed formulation with an auxiliary integer makespan variable:
 //! - Variables: binary x_{t,u} for t in 0..n, u in 0..D_max (task t processed at slot u),
@@ -15,10 +15,10 @@
 //!   4. Makespan lower bound: M ≥ (u+1) when x_{t,u}=1:
 //!      `M - (u+1)*x_{t,u} ≥ 0` for all t,u
 //!   5. Binary bounds: x_{t,u} ≤ 1 for each t,u
-//!      (since ILP<i32> uses non-negative integer domain)
+//!      (since `ILP<i64>` uses non-negative integer domain)
 //! - Objective: Minimize M.
 //!
-//! Note: ILP<i32> treats all variables as non-negative integers. Binary constraints
+//! Note: `ILP<i64>` treats all variables as non-negative integers. Binary constraints
 //! on x_{t,u} are enforced by x_{t,u} ≤ 1.
 
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
@@ -26,7 +26,7 @@ use crate::models::misc::PreemptiveScheduling;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing PreemptiveScheduling to ILP<i32>.
+/// Result of reducing PreemptiveScheduling to `ILP<i64>`.
 ///
 /// Variable layout:
 /// - x_{t,u} at index t * D_max + u for t in 0..n, u in 0..D_max  (n*D_max vars)
@@ -35,59 +35,74 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Total: n * D_max + 1 variables.
 #[derive(Debug, Clone)]
 pub struct ReductionPSToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_tasks: usize,
     d_max: usize,
 }
 
 impl ReductionResult for ReductionPSToILP {
     type Source = PreemptiveScheduling;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Extract schedule from ILP solution.
     ///
     /// Returns a binary config of length n * D_max: `config[t * D_max + u] = x_{t,u}`.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let nd = self.num_tasks * self.d_max;
-        target_solution[..nd.min(target_solution.len())].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok((0..self.num_tasks)
+            .map(|task| {
+                (0..self.d_max)
+                    .map(|time| target_solution[task * self.d_max + time] == 1)
+                    .collect()
+            })
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_tasks * d_max + 1",
         num_constraints = "num_tasks + d_max + num_precedences * d_max + 2 * num_tasks * d_max",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for PreemptiveScheduling {
+impl ReduceTo<ILP<i64>> for PreemptiveScheduling {
     type Result = ReductionPSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
-        let m = self.num_processors();
         let d = self.d_max();
         let num_task_vars = n * d;
         let m_var = num_task_vars; // index of the makespan variable M
         let num_vars = num_task_vars + 1;
+        let lengths = self.lengths();
+        let processor_count =
+            Self::exact_i64(self.num_processors(), "encoding the processor capacity")?;
 
         let x = |t: usize, u: usize| t * d + u;
 
         let mut constraints = Vec::new();
 
         // 1. Work constraints: Σ_u x_{t,u} = l(t) for each task t
-        for t in 0..n {
-            let terms: Vec<(usize, f64)> = (0..d).map(|u| (x(t, u), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, self.lengths()[t] as f64));
+        for (t, &length) in lengths.iter().enumerate() {
+            let terms: Vec<(usize, i64)> = (0..d).map(|u| (x(t, u), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, length));
         }
 
         // 2. Capacity constraints: Σ_t x_{t,u} ≤ m for each time slot u
         for u in 0..d {
-            let terms: Vec<(usize, f64)> = (0..n).map(|t| (x(t, u), 1.0)).collect();
-            constraints.push(LinearConstraint::le(terms, m as f64));
+            let terms: Vec<(usize, i64)> = (0..n).map(|t| (x(t, u), 1)).collect();
+            constraints.push(LinearConstraint::le(terms, processor_count));
         }
 
         // 3. Precedence constraints: for each (pred, succ) and each slot u:
@@ -97,17 +112,17 @@ impl ReduceTo<ILP<i32>> for PreemptiveScheduling {
         //    Interpretation: succ can only be active at slot u once pred has
         //    accumulated all l(pred) units of work in strictly earlier slots.
         for &(pred, succ) in self.precedences() {
-            let l_pred = self.lengths()[pred] as f64;
+            let l_pred = lengths[pred];
             for u in 0..d {
                 // Σ_{v=0}^{u-1} x_{pred,v} - l(pred)*x_{succ,u} ≥ 0
                 // i.e. l(pred)*x_{succ,u} - Σ_{v<u} x_{pred,v} ≤ 0
-                let mut terms: Vec<(usize, f64)> = Vec::new();
+                let mut terms: Vec<(usize, i64)> = Vec::new();
                 // Cumulative pred work up to u-1
                 for v in 0..u {
-                    terms.push((x(pred, v), -1.0));
+                    terms.push((x(pred, v), -1));
                 }
                 terms.push((x(succ, u), l_pred));
-                constraints.push(LinearConstraint::le(terms, 0.0));
+                constraints.push(LinearConstraint::le(terms, 0));
             }
         }
 
@@ -115,8 +130,11 @@ impl ReduceTo<ILP<i32>> for PreemptiveScheduling {
         for t in 0..n {
             for u in 0..d {
                 constraints.push(LinearConstraint::ge(
-                    vec![(m_var, 1.0), (x(t, u), -((u + 1) as f64))],
-                    0.0,
+                    vec![
+                        (m_var, 1),
+                        (x(t, u), -Self::exact_i64(u + 1, "encoding a time slot")?),
+                    ],
+                    0,
                 ));
             }
         }
@@ -124,18 +142,19 @@ impl ReduceTo<ILP<i32>> for PreemptiveScheduling {
         // 5. Binary upper bound: x_{t,u} ≤ 1 for all t,u
         for t in 0..n {
             for u in 0..d {
-                constraints.push(LinearConstraint::le(vec![(x(t, u), 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(x(t, u), 1)], 1));
             }
         }
 
         // Objective: minimize M
-        let objective = vec![(m_var, 1.0)];
+        let objective = vec![(m_var, 1)];
 
-        ReductionPSToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize),
+        Ok(ReductionPSToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
             d_max: d,
-        }
+        })
     }
 }
 
@@ -145,8 +164,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "preemptivescheduling_to_ilp",
         build: || {
             // 3 tasks, lengths [2,1,2], 2 processors, precedence (0,2)
-            let source = PreemptiveScheduling::new(vec![2, 1, 2], 2, vec![(0, 2)]);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            let source = PreemptiveScheduling::new(vec![2, 1, 2], 2, vec![(0, 2)]).unwrap();
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/prizecollectingsteinerforest_steinertree.rs b/src/rules/prizecollectingsteinerforest_steinertree.rs
index a298b86ac..26ab8ddb6 100644
--- a/src/rules/prizecollectingsteinerforest_steinertree.rs
+++ b/src/rules/prizecollectingsteinerforest_steinertree.rs
@@ -38,14 +38,14 @@ use crate::topology::{Graph, SimpleGraph};
 
 /// Result of reducing PCSF to SteinerTree.
 ///
-/// Stores the original PCSF source sizes plus the mapping from the target
+/// Stores the original PCSF source parameterss plus the mapping from the target
 /// graph's edge list back to the source variables (the original edge index
 /// for each "original" edge, and the source vertex index for each gadget
 /// include-edge). Other target edges (root-attachment and gadget omit-edges)
 /// are not needed for extraction.
 #[derive(Debug, Clone)]
 pub struct ReductionPCSFToSteinerTree {
-    target: SteinerTree<SimpleGraph, i32>,
+    target: SteinerTree<SimpleGraph, i64>,
     /// Number of vertices in the source graph (also the prefix size of the
     /// source configuration's vertex-selector segment).
     num_source_vertices: usize,
@@ -62,48 +62,56 @@ pub struct ReductionPCSFToSteinerTree {
 }
 
 impl ReductionResult for ReductionPCSFToSteinerTree {
-    type Source = PrizeCollectingSteinerForest<SimpleGraph, i32>;
-    type Target = SteinerTree<SimpleGraph, i32>;
+    type Source = PrizeCollectingSteinerForest<SimpleGraph, i64>;
+    type Target = SteinerTree<SimpleGraph, i64>;
 
-    fn target_problem(&self) -> &SteinerTree<SimpleGraph, i32> {
+    fn target_problem(&self) -> &SteinerTree<SimpleGraph, i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_source_vertices;
-        let m = self.num_source_edges;
-        let mut source_config = vec![0usize; n + m];
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
-        // Mark vertices included via their gadget include-edge `(v, t_v)`,
-        // and edges via the matching original edge.
-        for (target_idx, &selected) in target_solution.iter().enumerate() {
-            if selected != 1 {
-                continue;
-            }
-            if let Some(v) = self.target_to_include_vertex[target_idx] {
-                source_config[v] = 1;
-            } else if let Some(src_edge) = self.target_to_source_edge[target_idx] {
-                source_config[n + src_edge] = 1;
-            }
-        }
+        Ok({
+            let n = self.num_source_vertices;
+            let m = self.num_source_edges;
+            let mut selected_vertices = vec![false; n];
+            let mut selected_edges = vec![false; m];
 
-        // Any original edge selected in `T*` forces both endpoints into
-        // `V_F`. The PCSF model rejects configurations where a selected
-        // edge has an unselected endpoint, so we mark endpoints explicitly
-        // (this also covers prize-zero endpoints, which have no gadget).
-        let edges = self.target.graph().edges();
-        for (target_idx, &(_, _)) in edges.iter().enumerate() {
-            if target_solution.get(target_idx).copied() != Some(1) {
-                continue;
+            // Mark vertices included via their gadget include-edge `(v, t_v)`,
+            // and edges via the matching original edge.
+            for (target_idx, &selected) in target_solution.iter().enumerate() {
+                if !selected {
+                    continue;
+                }
+                if let Some(v) = self.target_to_include_vertex[target_idx] {
+                    selected_vertices[v] = true;
+                } else if let Some(src_edge) = self.target_to_source_edge[target_idx] {
+                    selected_edges[src_edge] = true;
+                }
             }
-            if let Some(src_edge) = self.target_to_source_edge[target_idx] {
-                let (u, v) = self.source_edge_pair(src_edge);
-                source_config[u] = 1;
-                source_config[v] = 1;
+
+            // Any original edge selected in `T*` forces both endpoints into
+            // `V_F`. The PCSF model rejects configurations where a selected
+            // edge has an unselected endpoint, so we mark endpoints explicitly
+            // (this also covers prize-zero endpoints, which have no gadget).
+            let edges = self.target.graph().edges();
+            for (target_idx, &(_, _)) in edges.iter().enumerate() {
+                if !target_solution[target_idx] {
+                    continue;
+                }
+                if let Some(src_edge) = self.target_to_source_edge[target_idx] {
+                    let (u, v) = self.source_edge_pair(src_edge);
+                    selected_vertices[u] = true;
+                    selected_vertices[v] = true;
+                }
             }
-        }
 
-        source_config
+            (selected_vertices, selected_edges)
+        })
     }
 }
 
@@ -116,16 +124,16 @@ impl ReductionPCSFToSteinerTree {
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vertices = "num_vertices + num_vertices_with_prize + 1",
         num_edges = "num_edges + num_vertices + 2 * num_vertices_with_prize",
         num_terminals = "num_vertices_with_prize + 1",
     }
 )]
-impl ReduceTo<SteinerTree<SimpleGraph, i32>> for PrizeCollectingSteinerForest<SimpleGraph, i32> {
+impl ReduceTo<SteinerTree<SimpleGraph, i64>> for PrizeCollectingSteinerForest<SimpleGraph, i64> {
     type Result = ReductionPCSFToSteinerTree;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let m = self.num_edges();
         let source_edges = self.graph().edges();
@@ -146,7 +154,7 @@ impl ReduceTo<SteinerTree<SimpleGraph, i32>> for PrizeCollectingSteinerForest<Si
 
         let target_num_vertices = n + 1 + k;
         let mut target_edges: Vec<(usize, usize)> = Vec::with_capacity(m + n + 2 * k);
-        let mut target_edge_weights: Vec<i32> = Vec::with_capacity(m + n + 2 * k);
+        let mut target_edge_weights: Vec<i64> = Vec::with_capacity(m + n + 2 * k);
         let mut target_to_source_edge: Vec<Option<usize>> = Vec::with_capacity(m + n + 2 * k);
         let mut target_to_include_vertex: Vec<Option<usize>> = Vec::with_capacity(m + n + 2 * k);
 
@@ -191,15 +199,15 @@ impl ReduceTo<SteinerTree<SimpleGraph, i32>> for PrizeCollectingSteinerForest<Si
 
         let target_graph = SimpleGraph::new(target_num_vertices, target_edges);
         let target =
-            SteinerTree::<SimpleGraph, i32>::new(target_graph, target_edge_weights, terminals);
+            SteinerTree::<SimpleGraph, i64>::new(target_graph, target_edge_weights, terminals);
 
-        ReductionPCSFToSteinerTree {
+        Ok(ReductionPCSFToSteinerTree {
             target,
             num_source_vertices: n,
             num_source_edges: m,
             target_to_source_edge,
             target_to_include_vertex,
-        }
+        })
     }
 }
 
@@ -217,27 +225,32 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // c(1,2)=10, prizes p = (5, 1, 5), beta = 1, omega = 1. The
             // optimum drops vertex 1 (paying p(1) = 1) rather than paying a
             // size-10 edge to reach it.
-            let source = PrizeCollectingSteinerForest::<SimpleGraph, i32>::new(
+            let source = PrizeCollectingSteinerForest::<SimpleGraph, i64>::new(
                 SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
                 vec![5, 1, 5],
                 vec![10, 10],
                 1,
                 1,
-            );
-            let reduction = <PrizeCollectingSteinerForest<SimpleGraph, i32> as ReduceTo<
-                SteinerTree<SimpleGraph, i32>,
-            >>::reduce_to(&source);
+            )
+            .unwrap();
+            let reduction = <PrizeCollectingSteinerForest<SimpleGraph, i64> as ReduceTo<
+                SteinerTree<SimpleGraph, i64>,
+            >>::reduce_to(&source)
+            .expect("reduction should succeed");
             let target = reduction.target_problem();
             let target_config = BruteForce::new()
-                .find_witness(target)
+                .solve(target)
+                .expect("canonical target evaluation must succeed")
                 .expect("canonical PCSF -> SteinerTree example must have an optimal target tree");
-            let source_config = reduction.extract_solution(&target_config);
+            let source_config = reduction.extract_solution(&target_config).unwrap();
             crate::example_db::specs::assemble_rule_example(
                 &source,
                 target,
                 vec![SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 }],
             )
         },
diff --git a/src/rules/quadraticassignment_ilp.rs b/src/rules/quadraticassignment_ilp.rs
index 62a3c9916..aacef5d4e 100644
--- a/src/rules/quadraticassignment_ilp.rs
+++ b/src/rules/quadraticassignment_ilp.rs
@@ -34,28 +34,34 @@ impl ReductionResult for ReductionQAPToILP {
     }
 
     /// Extract: for each facility i, output the unique location p with x_{i,p} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let loc = self.num_locations;
-        (0..self.num_facilities)
-            .map(|i| {
-                (0..loc)
-                    .find(|&p| target_solution[i * loc + p] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_facilities,
+            self.num_locations,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_facilities * num_locations + num_facilities^2 * num_locations^2",
         num_constraints = "num_facilities + num_locations + 3 * num_facilities^2 * num_locations^2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for QuadraticAssignment {
     type Result = ReductionQAPToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_facilities();
         let loc = self.num_locations();
         let cost = self.cost_matrix();
@@ -98,19 +104,25 @@ impl ReduceTo<ILP<bool>> for QuadraticAssignment {
         // Objective: minimize sum_{i!=j,p,q} C[i][j] * D[p][q] * z_{(i,p),(j,q)}
         let mut objective = Vec::new();
         for (z_seq, &(i, p, j, q)) in z_pairs.iter().enumerate() {
-            let coeff = cost[i][j] as f64 * dist[p][q] as f64;
-            if coeff != 0.0 {
+            let coefficient = cost[i][j].checked_mul(dist[p][q]).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<QuadraticAssignment, ILP<bool>>(
+                    "multiplying a quadratic-assignment cost by a distance",
+                )
+            })?;
+            let coeff = coefficient;
+            if coeff != 0 {
                 objective.push((z_idx(z_seq), coeff));
             }
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionQAPToILP {
+        Ok(ReductionQAPToILP {
             target,
             num_facilities: n,
             num_locations: loc,
-        }
+        })
     }
 }
 
diff --git a/src/rules/qubo_casts.rs b/src/rules/qubo_casts.rs
new file mode 100644
index 000000000..841c432cc
--- /dev/null
+++ b/src/rules/qubo_casts.rs
@@ -0,0 +1,33 @@
+//! Numeric variant reduction for QUBO.
+
+use crate::impl_variant_reduction;
+use crate::models::algebraic::QUBO;
+use crate::rules::ReductionError;
+use crate::types::i64_to_exact_f64;
+
+impl_variant_reduction!(
+    QUBO,
+    <i64> => <f64>,
+    fields: [num_vars],
+    |src| {
+        let matrix = src
+            .matrix()
+            .iter()
+            .map(|row| {
+                row.iter()
+                    .copied()
+                    .map(i64_to_exact_f64)
+                    .collect::<Result<Vec<_>, _>>()
+            })
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|error| {
+                ReductionError::inexact_float_conversion::<QUBO<i64>, QUBO<f64>>(error)
+            })?;
+        QUBO::from_matrix(matrix)
+            .map_err(ReductionError::construction::<QUBO<i64>, QUBO<f64>>)?
+    }
+);
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/qubo_casts.rs"]
+mod tests;
diff --git a/src/rules/qubo_ilp.rs b/src/rules/qubo_ilp.rs
index 249df5886..2dd22909c 100644
--- a/src/rules/qubo_ilp.rs
+++ b/src/rules/qubo_ilp.rs
@@ -14,108 +14,140 @@
 //! ## Objective
 //! minimize Σ_i Q_ii · x_i + Σ_{i<j} Q_ij · y_{ij}
 
-use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP, QUBO};
+use crate::models::algebraic::{ILPCoefficient, ObjectiveSense, ILP, QUBO};
 use crate::reduction;
+use crate::rules::ilp_helpers::mccormick_product;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing QUBO to ILP.
 #[derive(Debug, Clone)]
-pub struct ReductionQUBOToILP {
-    target: ILP<bool>,
+pub struct ReductionQUBOToILP<C: ILPCoefficient = i64> {
+    target: ILP<bool, C>,
     num_original: usize,
 }
 
-impl ReductionResult for ReductionQUBOToILP {
-    type Source = QUBO<f64>;
-    type Target = ILP<bool>;
+impl<C> ReductionResult for ReductionQUBOToILP<C>
+where
+    C: ILPCoefficient + crate::variant::VariantParam,
+{
+    type Source = QUBO<C>;
+    type Target = ILP<bool, C>;
 
-    fn target_problem(&self) -> &ILP<bool> {
+    fn target_problem(&self) -> &ILP<bool, C> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_original].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_original]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
-#[reduction(
-    overhead = {
-        num_vars = "num_vars^2",
-        num_constraints = "num_vars^2",
-    }
-)]
-impl ReduceTo<ILP<bool>> for QUBO<f64> {
-    type Result = ReductionQUBOToILP;
-
-    fn reduce_to(&self) -> Self::Result {
-        let n = self.num_vars();
-        let matrix = self.matrix();
-
-        // Collect non-zero off-diagonal entries (i < j)
-        let mut off_diag: Vec<(usize, usize, f64)> = Vec::new();
-        for (i, row) in matrix.iter().enumerate() {
-            for (j, &q_ij) in row.iter().enumerate().skip(i + 1) {
-                if q_ij != 0.0 {
-                    off_diag.push((i, j, q_ij));
-                }
+fn reduce_qubo<C>(source: &QUBO<C>) -> Result<ReductionQUBOToILP<C>, crate::rules::ReductionError>
+where
+    C: ILPCoefficient + crate::variant::VariantParam + From<i8>,
+{
+    let n = source.num_vars();
+    let matrix = source.matrix();
+
+    // Collect non-zero off-diagonal entries (i < j)
+    let mut off_diag: Vec<(usize, usize, C)> = Vec::new();
+    for (i, row) in matrix.iter().enumerate() {
+        for (j, &q_ij) in row.iter().enumerate().skip(i + 1) {
+            if q_ij != C::zero() {
+                off_diag.push((i, j, q_ij));
             }
         }
+    }
 
-        let m = off_diag.len();
-        let total_vars = n + m;
+    let m = off_diag.len();
+    let total_vars = n + m;
 
-        // Objective: minimize Σ Q_ii · x_i + Σ Q_ij · y_k
-        let mut objective: Vec<(usize, f64)> = Vec::new();
-        for (i, row) in matrix.iter().enumerate() {
-            let q_ii = row[i];
-            if q_ii != 0.0 {
-                objective.push((i, q_ii));
-            }
-        }
-        for (k, &(_, _, q_ij)) in off_diag.iter().enumerate() {
-            objective.push((n + k, q_ij));
+    // Objective: minimize Σ Q_ii · x_i + Σ Q_ij · y_k
+    let mut objective: Vec<(usize, C)> = Vec::new();
+    for (i, row) in matrix.iter().enumerate() {
+        let q_ii = row[i];
+        if q_ii != C::zero() {
+            objective.push((i, q_ii));
         }
+    }
+    for (k, &(_, _, q_ij)) in off_diag.iter().enumerate() {
+        objective.push((n + k, q_ij));
+    }
 
-        // McCormick constraints: 3 per auxiliary variable
-        let mut constraints = Vec::with_capacity(3 * m);
-        for (k, &(i, j, _)) in off_diag.iter().enumerate() {
-            let y_k = n + k;
-            // y_k ≤ x_i
-            constraints.push(LinearConstraint::le(vec![(y_k, 1.0), (i, -1.0)], 0.0));
-            // y_k ≤ x_j
-            constraints.push(LinearConstraint::le(vec![(y_k, 1.0), (j, -1.0)], 0.0));
-            // y_k ≥ x_i + x_j - 1
-            constraints.push(LinearConstraint::ge(
-                vec![(y_k, 1.0), (i, -1.0), (j, -1.0)],
-                -1.0,
-            ));
-        }
+    // McCormick constraints: 3 per auxiliary variable
+    let mut constraints: Vec<crate::models::algebraic::LinearConstraint<C>> =
+        Vec::with_capacity(3 * m);
+    for (k, &(i, j, _)) in off_diag.iter().enumerate() {
+        let y_k = n + k;
+        constraints.extend(mccormick_product(y_k, i, j));
+    }
+
+    let target = ILP::new(total_vars, constraints, objective, ObjectiveSense::Minimize)
+        .map_err(crate::rules::ReductionError::construction::<QUBO<C>, ILP<bool, C>>)?;
+    Ok(ReductionQUBOToILP {
+        target,
+        num_original: n,
+    })
+}
+
+macro_rules! impl_qubo_to_ilp {
+    ($coefficient:ty) => {
+        #[reduction(
+            transform = upper_bound {
+                num_vars = "num_vars^2 + num_vars",
+                num_constraints = "3 * num_vars^2",
+            },
+            unavailable = {
+                num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+            }
+        )]
+        impl ReduceTo<ILP<bool, $coefficient>> for QUBO<$coefficient> {
+            type Result = ReductionQUBOToILP<$coefficient>;
 
-        let target = ILP::new(total_vars, constraints, objective, ObjectiveSense::Minimize);
-        ReductionQUBOToILP {
-            target,
-            num_original: n,
+            fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+                reduce_qubo(self)
+            }
         }
     }
 }
 
+impl_qubo_to_ilp!(i64);
+impl_qubo_to_ilp!(f64);
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
-    vec![crate::example_db::specs::RuleExampleSpec {
-        id: "qubo_to_ilp",
-        build: || {
-            let mut matrix = vec![vec![0.0; 4]; 4];
-            matrix[0][0] = -2.0;
-            matrix[1][1] = -3.0;
-            matrix[2][2] = -1.0;
-            matrix[3][3] = -4.0;
-            matrix[0][1] = 1.0;
-            matrix[1][2] = 2.0;
-            matrix[2][3] = -1.0;
-            let source = QUBO::from_matrix(matrix);
-            crate::example_db::specs::rule_example_via_ilp::<_, bool>(source)
+    vec![
+        crate::example_db::specs::RuleExampleSpec {
+            id: "qubo_to_ilp",
+            build: || {
+                let mut matrix = vec![vec![0.0; 4]; 4];
+                matrix[0][0] = -2.0;
+                matrix[1][1] = -3.0;
+                matrix[2][2] = -1.0;
+                matrix[3][3] = -4.0;
+                matrix[0][1] = 1.0;
+                matrix[1][2] = 2.0;
+                matrix[2][3] = -1.0;
+                let source = QUBO::from_matrix(matrix).unwrap();
+                crate::example_db::specs::rule_example_via_float_ilp::<_, bool>(source)
+            },
+        },
+        crate::example_db::specs::RuleExampleSpec {
+            id: "integer_qubo_to_ilp",
+            build: || {
+                let source = QUBO::from_matrix(vec![vec![2, 1], vec![0, -3]]).unwrap();
+                crate::example_db::specs::rule_example_via_ilp::<_, bool>(source)
+            },
         },
-    }]
+    ]
 }
 
 #[cfg(test)]
diff --git a/src/rules/rectilinearpicturecompression_ilp.rs b/src/rules/rectilinearpicturecompression_ilp.rs
index 063eb3264..cf75fb3a1 100644
--- a/src/rules/rectilinearpicturecompression_ilp.rs
+++ b/src/rules/rectilinearpicturecompression_ilp.rs
@@ -21,21 +21,29 @@ impl ReductionResult for ReductionRPCToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "num_rows * num_cols",
+    transform = upper_bound {
+        num_vars = "num_rows^2 * num_cols^2",
         num_constraints = "num_rows * num_cols + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for RectilinearPictureCompression {
     type Result = ReductionRPCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let rects = self.maximal_rectangles();
         let num_vars = rects.len();
         let mut constraints = Vec::new();
@@ -44,23 +52,24 @@ impl ReduceTo<ILP<bool>> for RectilinearPictureCompression {
         for i in 0..self.num_rows() {
             for j in 0..self.num_cols() {
                 if self.matrix()[i][j] {
-                    let terms: Vec<(usize, f64)> = rects
+                    let terms: Vec<(usize, i64)> = rects
                         .iter()
                         .enumerate()
                         .filter(|(_, &(r1, c1, r2, c2))| i >= r1 && i <= r2 && j >= c1 && j <= c2)
-                        .map(|(idx, _)| (idx, 1.0))
+                        .map(|(idx, _)| (idx, 1))
                         .collect();
-                    constraints.push(LinearConstraint::ge(terms, 1.0));
+                    constraints.push(LinearConstraint::ge(terms, 1));
                 }
             }
         }
 
         // Bound constraint: Σ x_r ≤ bound
-        let bound_terms: Vec<(usize, f64)> = (0..num_vars).map(|i| (i, 1.0)).collect();
-        constraints.push(LinearConstraint::le(bound_terms, self.bound() as f64));
+        let bound_terms: Vec<(usize, i64)> = (0..num_vars).map(|i| (i, 1)).collect();
+        constraints.push(LinearConstraint::le(bound_terms, self.bound()));
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionRPCToILP { target }
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionRPCToILP { target })
     }
 }
 
diff --git a/src/rules/registersufficiency_ilp.rs b/src/rules/registersufficiency_ilp.rs
index 0a625ea0a..021b02edc 100644
--- a/src/rules/registersufficiency_ilp.rs
+++ b/src/rules/registersufficiency_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from RegisterSufficiency to ILP<i32>.
+//! Reduction from RegisterSufficiency to `ILP<i64>`.
 //!
 //! The formulation uses:
 //! - integer `t_v` variables for evaluation positions
@@ -14,31 +14,41 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 
 #[derive(Debug, Clone)]
 pub struct ReductionRegisterSufficiencyToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_vertices: usize,
 }
 
 impl ReductionResult for ReductionRegisterSufficiencyToILP {
     type Source = RegisterSufficiency;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_vertices].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::decode_usize_values(&target_solution[..self.num_vertices])
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "3 * num_vertices^2 + num_vertices * (num_vertices - 1) / 2 + 2 * num_vertices",
-    num_constraints = "9 * num_vertices^2 + 3 * num_vertices * (num_vertices - 1) / 2 + 3 * num_vertices + 2 * num_arcs + num_sinks",
-})]
-impl ReduceTo<ILP<i32>> for RegisterSufficiency {
+#[reduction(
+    transform = exact {
+        num_vars = "3 * num_vertices^2 + num_vertices * (num_vertices - 1) / 2 + 2 * num_vertices",
+        num_constraints = "9 * num_vertices^2 + 3 * num_vertices * (num_vertices - 1) / 2 + 3 * num_vertices + 2 * num_arcs + num_sinks",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<i64>> for RegisterSufficiency {
     type Result = ReductionRegisterSufficiencyToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let pair_list: Vec<(usize, usize)> = (0..n)
             .flat_map(|u| ((u + 1)..n).map(move |v| (u, v)))
@@ -61,105 +71,118 @@ impl ReduceTo<ILP<i32>> for RegisterSufficiency {
         let after_idx = |vertex: usize, step: usize| -> usize { after_offset + vertex * n + step };
         let live_idx = |vertex: usize, step: usize| -> usize { live_offset + vertex * n + step };
 
-        let big_m = n as f64;
+        let big_m = Self::exact_i64(n, "representing the schedule length in ILP rows")?;
+        let latest_time = big_m;
+        let maximum_time = Self::exact_i64(
+            n.saturating_sub(1),
+            "representing the maximum schedule time in ILP rows",
+        )?;
         let mut has_dependent = vec![false; n];
         let mut constraints = Vec::new();
 
         for vertex in 0..n {
             constraints.push(LinearConstraint::le(
-                vec![(time_idx(vertex), 1.0)],
-                (n.saturating_sub(1)) as f64,
+                vec![(time_idx(vertex), 1)],
+                maximum_time,
             ));
             constraints.push(LinearConstraint::le(
-                vec![(latest_idx(vertex), 1.0)],
-                n as f64,
+                vec![(latest_idx(vertex), 1)],
+                latest_time,
             ));
         }
 
         for (pair_idx, &(u, v)) in pair_list.iter().enumerate() {
             let order_var = order_idx(pair_idx);
-            constraints.push(LinearConstraint::le(vec![(order_var, 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(order_var, 1)], 1));
             constraints.push(LinearConstraint::ge(
-                vec![(time_idx(v), 1.0), (time_idx(u), -1.0), (order_var, -big_m)],
-                1.0 - big_m,
+                vec![(time_idx(v), 1), (time_idx(u), -1), (order_var, -big_m)],
+                1 - big_m,
             ));
             constraints.push(LinearConstraint::ge(
-                vec![(time_idx(u), 1.0), (time_idx(v), -1.0), (order_var, big_m)],
-                1.0,
+                vec![(time_idx(u), 1), (time_idx(v), -1), (order_var, big_m)],
+                1,
             ));
         }
 
         for &(dependent, dependency) in self.arcs() {
             has_dependent[dependency] = true;
             constraints.push(LinearConstraint::ge(
-                vec![(time_idx(dependent), 1.0), (time_idx(dependency), -1.0)],
-                1.0,
+                vec![(time_idx(dependent), 1), (time_idx(dependency), -1)],
+                1,
             ));
             constraints.push(LinearConstraint::ge(
-                vec![(latest_idx(dependency), 1.0), (time_idx(dependent), -1.0)],
-                0.0,
+                vec![(latest_idx(dependency), 1), (time_idx(dependent), -1)],
+                0,
             ));
         }
 
         for (vertex, &has_child) in has_dependent.iter().enumerate() {
             if !has_child {
                 constraints.push(LinearConstraint::eq(
-                    vec![(latest_idx(vertex), 1.0)],
-                    n as f64,
+                    vec![(latest_idx(vertex), 1)],
+                    latest_time,
                 ));
             }
         }
 
         for vertex in 0..n {
             for step in 0..n {
+                let step_value = Self::exact_i64(step, "representing a schedule step in ILP rows")?;
                 let before_var = before_idx(vertex, step);
-                constraints.push(LinearConstraint::le(vec![(before_var, 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(before_var, 1)], 1));
                 constraints.push(LinearConstraint::le(
-                    vec![(time_idx(vertex), 1.0), (before_var, big_m)],
-                    step as f64 + big_m,
+                    vec![(time_idx(vertex), 1), (before_var, big_m)],
+                    step_value + big_m,
                 ));
                 constraints.push(LinearConstraint::ge(
-                    vec![(time_idx(vertex), 1.0), (before_var, big_m)],
-                    (step + 1) as f64,
+                    vec![(time_idx(vertex), 1), (before_var, big_m)],
+                    step_value + 1,
                 ));
 
                 let after_var = after_idx(vertex, step);
-                constraints.push(LinearConstraint::le(vec![(after_var, 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(after_var, 1)], 1));
                 constraints.push(LinearConstraint::ge(
-                    vec![(latest_idx(vertex), 1.0), (after_var, -big_m)],
-                    (step + 1) as f64 - big_m,
+                    vec![(latest_idx(vertex), 1), (after_var, -big_m)],
+                    step_value + 1 - big_m,
                 ));
                 constraints.push(LinearConstraint::le(
-                    vec![(latest_idx(vertex), 1.0), (after_var, -big_m)],
-                    step as f64,
+                    vec![(latest_idx(vertex), 1), (after_var, -big_m)],
+                    step_value,
                 ));
 
                 let live_var = live_idx(vertex, step);
                 constraints.push(LinearConstraint::le(
-                    vec![(live_var, 1.0), (before_var, -1.0)],
-                    0.0,
+                    vec![(live_var, 1), (before_var, -1)],
+                    0,
                 ));
                 constraints.push(LinearConstraint::le(
-                    vec![(live_var, 1.0), (after_var, -1.0)],
-                    0.0,
+                    vec![(live_var, 1), (after_var, -1)],
+                    0,
                 ));
                 constraints.push(LinearConstraint::ge(
-                    vec![(live_var, 1.0), (before_var, -1.0), (after_var, -1.0)],
-                    -1.0,
+                    vec![(live_var, 1), (before_var, -1), (after_var, -1)],
+                    -1,
                 ));
             }
         }
 
         for step in 0..n {
-            let live_terms: Vec<(usize, f64)> =
-                (0..n).map(|vertex| (live_idx(vertex, step), 1.0)).collect();
-            constraints.push(LinearConstraint::le(live_terms, self.bound() as f64));
+            let live_terms: Vec<(usize, i64)> =
+                (0..n).map(|vertex| (live_idx(vertex, step), 1)).collect();
+            constraints.push(LinearConstraint::le(
+                live_terms,
+                Self::exact_i64(
+                    self.bound(),
+                    "representing the register bound in an ILP row",
+                )?,
+            ));
         }
 
-        ReductionRegisterSufficiencyToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionRegisterSufficiencyToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_vertices: n,
-        }
+        })
     }
 }
 
@@ -182,7 +205,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 ],
                 3,
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/registry.rs b/src/rules/registry.rs
index 8048022da..80a10beb6 100644
--- a/src/rules/registry.rs
+++ b/src/rules/registry.rs
@@ -1,93 +1,144 @@
 //! Automatic reduction registration via inventory.
 
 use crate::expr::Expr;
+use crate::parameters::{ParameterRelation, ParameterTransform, ParameterTransformError};
 use crate::rules::traits::{DynAggregateReductionResult, DynReductionResult};
-use crate::types::ProblemSize;
 use std::any::Any;
 use std::collections::HashSet;
 
-/// Overhead specification for a reduction.
-#[derive(Clone, Debug, Default, serde::Serialize)]
-pub struct ReductionOverhead {
-    /// Output size as expressions of input size variables.
-    /// Each entry is (output_field_name, expression).
-    pub output_size: Vec<(&'static str, Expr)>,
+/// One target parameter that cannot be propagated through a reduction.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
+pub struct UnavailableParameterField {
+    pub field: &'static str,
+    pub reason: &'static str,
 }
 
-impl ReductionOverhead {
-    pub fn new(output_size: Vec<(&'static str, Expr)>) -> Self {
-        Self { output_size }
-    }
+/// Raw symbolic declaration emitted by the reduction proc macro.
+#[derive(Clone, Debug, Default)]
+pub struct ReductionParameterDeclarations {
+    pub relation: Option<ParameterRelation>,
+    pub fields: Vec<(&'static str, Expr)>,
+    pub unavailable: Vec<UnavailableParameterField>,
+}
 
-    /// Identity overhead: each output field equals the same-named input field.
-    /// Used by variant cast reductions where problem size doesn't change.
-    pub fn identity(fields: &[&'static str]) -> Self {
-        Self {
-            output_size: fields.iter().map(|&f| (f, Expr::Var(f))).collect(),
-        }
-    }
+/// Validated parameter metadata for one reduction edge.
+#[derive(Clone, Debug)]
+pub struct ReductionParameterContract {
+    transform: Option<ParameterTransform>,
+    unavailable: Vec<UnavailableParameterField>,
+}
 
-    /// Evaluate output size given input size.
-    ///
-    /// Uses `round()` for the f64 to usize conversion because expression values
-    /// are typically integers and any fractional results come from floating-point
-    /// arithmetic imprecision, not intentional fractions.
-    pub fn evaluate_output_size(&self, input: &ProblemSize) -> ProblemSize {
-        let fields: Vec<_> = self
-            .output_size
+impl ReductionParameterContract {
+    pub fn new(
+        edge: impl Into<Box<str>>,
+        declarations: ReductionParameterDeclarations,
+    ) -> Result<Self, ParameterContractError> {
+        let edge = edge.into();
+        let formula_names: HashSet<_> = declarations
+            .fields
             .iter()
-            .map(|(name, expr)| (*name, expr.eval(input).round() as usize))
+            .map(|(field, _)| *field)
             .collect();
-        ProblemSize::new(fields)
+        let mut unavailable_names = HashSet::new();
+        for unavailable in &declarations.unavailable {
+            if unavailable.reason.trim().is_empty() {
+                return Err(ParameterContractError::EmptyUnavailableReason {
+                    edge,
+                    field: unavailable.field.into(),
+                });
+            }
+            if !unavailable_names.insert(unavailable.field)
+                || formula_names.contains(unavailable.field)
+            {
+                return Err(ParameterContractError::DuplicateClassification {
+                    edge,
+                    field: unavailable.field.into(),
+                });
+            }
+        }
+        let transform = match (declarations.relation, declarations.fields.is_empty()) {
+            (Some(relation), false) => Some(ParameterTransform::new(
+                edge,
+                relation,
+                declarations.fields,
+            )?),
+            (None, true) if !declarations.unavailable.is_empty() => None,
+            (None, true) => return Err(ParameterContractError::EmptyContract { edge }),
+            (Some(_), true) => return Err(ParameterContractError::EmptyTransform { edge }),
+            (None, false) => return Err(ParameterContractError::MissingRelation { edge }),
+        };
+        Ok(Self {
+            transform,
+            unavailable: declarations.unavailable,
+        })
     }
 
-    /// Collect all input variable names referenced by the overhead expressions.
-    pub fn input_variable_names(&self) -> HashSet<&'static str> {
-        self.output_size
-            .iter()
-            .flat_map(|(_, expr)| expr.variables())
-            .collect()
+    pub fn transform(&self) -> Option<&ParameterTransform> {
+        self.transform.as_ref()
     }
 
-    /// Compose two overheads: substitute self's output into `next`'s input.
-    ///
-    /// Returns a new overhead whose expressions map from self's input variables
-    /// directly to `next`'s output variables.
-    pub fn compose(&self, next: &ReductionOverhead) -> ReductionOverhead {
-        use std::collections::HashMap;
-
-        // Build substitution map: output field name → output expression
-        let mapping: HashMap<&str, &Expr> = self
-            .output_size
-            .iter()
-            .map(|(name, expr)| (*name, expr))
-            .collect();
+    pub fn unavailable(&self) -> &[UnavailableParameterField] {
+        &self.unavailable
+    }
+}
 
-        let composed = next
-            .output_size
-            .iter()
-            .map(|(name, expr)| (*name, expr.substitute(&mapping)))
-            .collect();
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ParameterContractError {
+    Transform(ParameterTransformError),
+    EmptyContract { edge: Box<str> },
+    EmptyTransform { edge: Box<str> },
+    MissingRelation { edge: Box<str> },
+    DuplicateClassification { edge: Box<str>, field: Box<str> },
+    EmptyUnavailableReason { edge: Box<str>, field: Box<str> },
+}
 
-        ReductionOverhead {
-            output_size: composed,
+impl std::fmt::Display for ParameterContractError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Transform(error) => write!(formatter, "invalid parameter transform: {error}"),
+            Self::EmptyContract { edge } => write!(
+                formatter,
+                "reduction `{edge}` has no parameter formulas or unavailable fields"
+            ),
+            Self::EmptyTransform { edge } => {
+                write!(
+                    formatter,
+                    "reduction `{edge}` declares an empty parameter transform"
+                )
+            }
+            Self::MissingRelation { edge } => write!(
+                formatter,
+                "reduction `{edge}` declares parameter formulas without a relation"
+            ),
+            Self::DuplicateClassification { edge, field } => {
+                write!(
+                    formatter,
+                    "reduction `{edge}` classifies target field `{field}` more than once"
+                )
+            }
+            Self::EmptyUnavailableReason { edge, field } => write!(
+                formatter,
+                "reduction `{edge}` marks target field `{field}` unavailable without a reason"
+            ),
         }
     }
+}
 
-    /// Get the expression for a named output field.
-    pub fn get(&self, name: &str) -> Option<&Expr> {
-        self.output_size
-            .iter()
-            .find(|(n, _)| *n == name)
-            .map(|(_, e)| e)
+impl std::error::Error for ParameterContractError {}
+
+impl From<ParameterTransformError> for ParameterContractError {
+    fn from(error: ParameterTransformError) -> Self {
+        Self::Transform(error)
     }
 }
 
 /// Witness/config reduction executor stored in the inventory.
-pub type ReduceFn = fn(&dyn Any) -> Box<dyn DynReductionResult>;
+pub type ReduceFn =
+    fn(&dyn Any) -> Result<Box<dyn DynReductionResult>, crate::rules::ReductionError>;
 
 /// Aggregate/value reduction executor stored in the inventory.
-pub type AggregateReduceFn = fn(&dyn Any) -> Box<dyn DynAggregateReductionResult>;
+pub type AggregateReduceFn =
+    fn(&dyn Any) -> Result<Box<dyn DynAggregateReductionResult>, crate::rules::ReductionError>;
 
 /// Execution capabilities carried by a reduction edge.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
@@ -101,53 +152,17 @@ pub struct EdgeCapabilities {
 }
 
 impl EdgeCapabilities {
-    pub const fn none() -> Self {
-        Self {
-            witness: false,
-            aggregate: false,
-            turing: false,
-        }
-    }
-
-    pub const fn witness_only() -> Self {
+    pub(crate) const fn from_executors(
+        reduce_fn: Option<ReduceFn>,
+        reduce_aggregate_fn: Option<AggregateReduceFn>,
+        turing: bool,
+    ) -> Self {
         Self {
-            witness: true,
-            aggregate: false,
-            turing: false,
+            witness: reduce_fn.is_some(),
+            aggregate: reduce_aggregate_fn.is_some(),
+            turing,
         }
     }
-
-    pub const fn aggregate_only() -> Self {
-        Self {
-            witness: false,
-            aggregate: true,
-            turing: false,
-        }
-    }
-
-    pub const fn both() -> Self {
-        Self {
-            witness: true,
-            aggregate: true,
-            turing: false,
-        }
-    }
-
-    pub const fn turing() -> Self {
-        Self {
-            witness: false,
-            aggregate: false,
-            turing: true,
-        }
-    }
-}
-
-/// Defaults to `witness_only()` — the conservative choice for edges registered
-/// via `#[reduction]`, which are witness/config reductions.
-impl Default for EdgeCapabilities {
-    fn default() -> Self {
-        Self::witness_only()
-    }
 }
 
 /// A registered reduction entry for static inventory registration.
@@ -161,35 +176,27 @@ pub struct ReductionEntry {
     pub source_variant_fn: fn() -> Vec<(&'static str, &'static str)>,
     /// Function to derive target variant attributes from `Problem::variant()`.
     pub target_variant_fn: fn() -> Vec<(&'static str, &'static str)>,
-    /// Function to create overhead information (lazy evaluation for static context).
-    pub overhead_fn: fn() -> ReductionOverhead,
+    /// The rule's single parameter relation, formulas, and unavailable target fields.
+    pub parameter_declarations_fn: fn() -> ReductionParameterDeclarations,
     /// Module path where the reduction is defined (from `module_path!()`).
     pub module_path: &'static str,
     /// Type-erased reduction executor.
     /// Takes a `&dyn Any` (must be `&SourceType`), calls `ReduceTo::reduce_to()`,
-    /// and returns the result as a boxed `DynReductionResult`.
+    /// and returns either a boxed `DynReductionResult` or the edge's `ReductionError`.
     pub reduce_fn: Option<ReduceFn>,
     /// Type-erased aggregate reduction executor.
     /// Takes a `&dyn Any` (must be `&SourceType`), calls
-    /// `ReduceToAggregate::reduce_to_aggregate()`, and returns the result as a
-    /// boxed `DynAggregateReductionResult`.
+    /// `ReduceToAggregate::reduce_to_aggregate()`, and returns either a boxed
+    /// `DynAggregateReductionResult` or the edge's `ReductionError`.
     pub reduce_aggregate_fn: Option<AggregateReduceFn>,
-    /// Capability metadata for runtime path filtering.
-    pub capabilities: EdgeCapabilities,
-    /// Compiled overhead evaluation function.
-    /// Takes a `&dyn Any` (must be `&SourceType`), calls getter methods directly,
-    /// and returns the computed target problem size.
-    pub overhead_eval_fn: fn(&dyn Any) -> ProblemSize,
-    /// Extract source problem size from a type-erased instance.
-    /// Takes a `&dyn Any` (must be `&SourceType`), calls getter methods,
-    /// and returns the source problem's size fields as a `ProblemSize`.
-    pub source_size_fn: fn(&dyn Any) -> ProblemSize,
+    /// Whether this is a Turing (multi-query) reduction.
+    pub turing: bool,
 }
 
 impl ReductionEntry {
-    /// Get the overhead by calling the function.
-    pub fn overhead(&self) -> ReductionOverhead {
-        (self.overhead_fn)()
+    pub fn parameter_contract(&self) -> Result<ReductionParameterContract, ParameterContractError> {
+        let edge: Box<str> = format!("{} -> {}", self.source_name, self.target_name).into();
+        ReductionParameterContract::new(edge, (self.parameter_declarations_fn)())
     }
 
     /// Get the source variant by calling the function.
@@ -202,6 +209,11 @@ impl ReductionEntry {
         (self.target_variant_fn)()
     }
 
+    /// Return the modes backed by this entry's executors.
+    pub fn capabilities(&self) -> EdgeCapabilities {
+        EdgeCapabilities::from_executors(self.reduce_fn, self.reduce_aggregate_fn, self.turing)
+    }
+
     /// Check if this reduction involves only the base (unweighted) variants.
     pub fn is_base_reduction(&self) -> bool {
         let source = self.source_variant();
@@ -227,9 +239,9 @@ impl std::fmt::Debug for ReductionEntry {
             .field("target_name", &self.target_name)
             .field("source_variant", &self.source_variant())
             .field("target_variant", &self.target_variant())
-            .field("overhead", &self.overhead())
+            .field("parameter_contract", &self.parameter_contract())
             .field("module_path", &self.module_path)
-            .field("capabilities", &self.capabilities)
+            .field("capabilities", &self.capabilities())
             .finish()
     }
 }
@@ -241,6 +253,85 @@ pub fn reduction_entries() -> Vec<&'static ReductionEntry> {
     inventory::iter::<ReductionEntry>().collect()
 }
 
+/// Validate reduction parameter expressions against problem-owned endpoint schemas.
+pub fn validate_reduction_parameter_schemas() -> Result<(), Vec<String>> {
+    let mut errors = Vec::new();
+
+    for entry in inventory::iter::<ReductionEntry> {
+        let source_variant = crate::export::variant_to_map(entry.source_variant());
+        let target_variant = crate::export::variant_to_map(entry.target_variant());
+        let Some(source) = crate::registry::find_variant_entry(entry.source_name, &source_variant)
+        else {
+            errors.push(format!(
+                "{} -> {} references an unregistered source variant {source_variant:?}",
+                entry.source_name, entry.target_name
+            ));
+            continue;
+        };
+        let Some(target) = crate::registry::find_variant_entry(entry.target_name, &target_variant)
+        else {
+            errors.push(format!(
+                "{} -> {} references an unregistered target variant {target_variant:?}",
+                entry.source_name, entry.target_name
+            ));
+            continue;
+        };
+
+        let source_fields = source
+            .parameter_names()
+            .iter()
+            .copied()
+            .collect::<std::collections::BTreeSet<_>>();
+        let target_fields = target
+            .parameter_names()
+            .iter()
+            .copied()
+            .collect::<std::collections::BTreeSet<_>>();
+        let declarations = (entry.parameter_declarations_fn)();
+
+        for field in declarations
+            .fields
+            .iter()
+            .flat_map(|(_, expression)| expression.variables())
+        {
+            if !source_fields.contains(field) {
+                errors.push(format!(
+                    "{} -> {} references unknown source parameter `{field}`; declared: {source_fields:?}",
+                    entry.source_name, entry.target_name
+                ));
+            }
+        }
+
+        let declared_target_fields = declarations
+            .fields
+            .iter()
+            .map(|(field, _)| *field)
+            .chain(declarations.unavailable.iter().map(|field| field.field))
+            .collect::<std::collections::BTreeSet<_>>();
+        for field in &declared_target_fields {
+            if !target_fields.contains(field) {
+                errors.push(format!(
+                    "{} -> {} declares unknown target parameter `{field}`; declared: {target_fields:?}",
+                    entry.source_name, entry.target_name
+                ));
+            }
+        }
+        for field in target_fields.difference(&declared_target_fields) {
+            errors.push(format!(
+                "{} -> {} omits target parameter `{field}`",
+                entry.source_name, entry.target_name
+            ));
+        }
+    }
+
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        errors.sort();
+        Err(errors)
+    }
+}
+
 #[cfg(test)]
 #[path = "../unit_tests/rules/registry.rs"]
 mod tests;
diff --git a/src/rules/resourceconstrainedscheduling_ilp.rs b/src/rules/resourceconstrainedscheduling_ilp.rs
index 61e2037bb..bcc1726d9 100644
--- a/src/rules/resourceconstrainedscheduling_ilp.rs
+++ b/src/rules/resourceconstrainedscheduling_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from ResourceConstrainedScheduling to ILP<bool>.
+//! Reduction from ResourceConstrainedScheduling to `ILP<bool>`.
 //!
 //! Time-indexed binary formulation: x_{j,t} = 1 iff task j runs in slot t.
 //! Each task in exactly one slot; processor capacity and resource bounds
@@ -9,7 +9,7 @@ use crate::models::misc::ResourceConstrainedScheduling;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing ResourceConstrainedScheduling to ILP<bool>.
+/// Result of reducing ResourceConstrainedScheduling to `ILP<bool>`.
 ///
 /// Variable layout: x_{j,t} at index `j * D + t`
 /// for j in 0..n, t in 0..D.
@@ -29,66 +29,81 @@ impl ReductionResult for ReductionRCSToILP {
     }
 
     /// Extract: for each task j, find the unique slot t with x_{j,t} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let d = self.deadline;
-        (0..self.num_tasks)
-            .map(|j| {
-                (0..d)
-                    .find(|&t| target_solution.get(j * d + t).copied().unwrap_or(0) == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_tasks,
+            self.deadline,
+            0,
+        )
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_tasks * deadline",
-    num_constraints = "num_tasks + deadline + num_resources * deadline",
-})]
+#[reduction(
+    transform = exact {
+        num_vars = "num_tasks * deadline",
+        num_constraints = "num_tasks + deadline + num_resources * deadline",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<ILP<bool>> for ResourceConstrainedScheduling {
     type Result = ReductionRCSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
-        let d = self.deadline() as usize;
+        let d =
+            usize::try_from(self.deadline()).map_err(|_| {
+                crate::rules::ReductionError::invalid_target::<
+                    ResourceConstrainedScheduling,
+                    ILP<bool>,
+                >("deadline does not fit the structural usize domain")
+            })?;
         let r = self.num_resources();
-        let m = self.num_processors();
+        let resource_requirements = self.resource_requirements();
+        let resource_bounds = self.resource_bounds();
         let num_vars = n * d;
 
         let var = |j: usize, t: usize| -> usize { j * d + t };
+        let processor_count =
+            Self::exact_i64(self.num_processors(), "encoding the processor capacity")?;
 
         let mut constraints = Vec::new();
 
         // 1. Each task in exactly one slot: Σ_t x_{j,t} = 1 for all j
         for j in 0..n {
-            let terms: Vec<(usize, f64)> = (0..d).map(|t| (var(j, t), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..d).map(|t| (var(j, t), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 2. Processor capacity: Σ_j x_{j,t} <= m for each time slot t
         for t in 0..d {
-            let terms: Vec<(usize, f64)> = (0..n).map(|j| (var(j, t), 1.0)).collect();
-            constraints.push(LinearConstraint::le(terms, m as f64));
+            let terms: Vec<(usize, i64)> = (0..n).map(|j| (var(j, t), 1)).collect();
+            constraints.push(LinearConstraint::le(terms, processor_count));
         }
 
         // 3. Resource bounds: Σ_j r_{j,q} * x_{j,t} <= B_q for all q, t
         for q in 0..r {
             for t in 0..d {
-                let terms: Vec<(usize, f64)> = (0..n)
-                    .map(|j| (var(j, t), self.resource_requirements()[j][q] as f64))
+                let terms: Vec<(usize, i64)> = (0..n)
+                    .map(|j| (var(j, t), resource_requirements[j][q]))
                     .collect();
-                constraints.push(LinearConstraint::le(
-                    terms,
-                    self.resource_bounds()[q] as f64,
-                ));
+                constraints.push(LinearConstraint::le(terms, resource_bounds[q]));
             }
         }
 
-        ReductionRCSToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionRCSToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
             deadline: d,
-        }
+        })
     }
 }
 
@@ -103,7 +118,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 vec![20],
                 vec![vec![6], vec![7], vec![7], vec![6], vec![8], vec![6]],
                 2,
-            );
+            )
+            .unwrap();
             crate::example_db::specs::rule_example_via_ilp::<_, bool>(source)
         },
     }]
diff --git a/src/rules/rootedtreearrangement_rootedtreestorageassignment.rs b/src/rules/rootedtreearrangement_rootedtreestorageassignment.rs
index 91f4d4a19..8c40f906a 100644
--- a/src/rules/rootedtreearrangement_rootedtreestorageassignment.rs
+++ b/src/rules/rootedtreearrangement_rootedtreestorageassignment.rs
@@ -36,19 +36,26 @@ impl ReductionResult for ReductionRootedTreeArrangementToRootedTreeStorageAssign
     /// The target config is a parent array defining a rooted tree on X = V.
     /// The source config is [parent_array | identity_mapping] since X = V
     /// means the mapping f is the identity.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_vertices;
-        // target_solution is the parent array of the rooted tree on X = V
-        // Source config = [parent_array, identity_mapping]
-        let mut source_config = target_solution.to_vec();
-        // Append identity mapping: f(v) = v for all v
-        source_config.extend(0..n);
-        source_config
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_vertices;
+            // target_solution is the parent array of the rooted tree on X = V
+            // Source config = [parent_array, identity_mapping]
+            let mut source_config = target_solution.to_vec();
+            // Append identity mapping: f(v) = v for all v
+            source_config.extend(0..n);
+            source_config
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         universe_size = "num_vertices",
         num_subsets = "num_edges",
     }
@@ -56,7 +63,7 @@ impl ReductionResult for ReductionRootedTreeArrangementToRootedTreeStorageAssign
 impl ReduceTo<RootedTreeStorageAssignment> for RootedTreeArrangement<SimpleGraph> {
     type Result = ReductionRootedTreeArrangementToRootedTreeStorageAssignment;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let edges = self.graph().edges();
         let num_edges = edges.len();
@@ -68,6 +75,12 @@ impl ReduceTo<RootedTreeStorageAssignment> for RootedTreeArrangement<SimpleGraph
         // is infeasible (each edge contributes at least 1 to the arrangement
         // cost). In that case, return a fixed gadget instance that is
         // guaranteed infeasible for the target problem as well.
+        let num_edges = i64::try_from(num_edges).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                RootedTreeArrangement<SimpleGraph>,
+                RootedTreeStorageAssignment,
+            >("converting the number of edges to i64")
+        })?;
         let bound = match self.bound().checked_sub(num_edges) {
             Some(b) => b,
             None => {
@@ -80,19 +93,23 @@ impl ReduceTo<RootedTreeStorageAssignment> for RootedTreeArrangement<SimpleGraph
                 let gadget_subsets = vec![vec![0, 1], vec![1, 2], vec![0, 2]];
                 let target = RootedTreeStorageAssignment::new(gadget_n, gadget_subsets, 0);
 
-                return ReductionRootedTreeArrangementToRootedTreeStorageAssignment {
-                    target,
-                    num_vertices: gadget_n,
-                };
+                return Ok(
+                    ReductionRootedTreeArrangementToRootedTreeStorageAssignment {
+                        target,
+                        num_vertices: gadget_n,
+                    },
+                );
             }
         };
 
         let target = RootedTreeStorageAssignment::new(n, subsets, bound);
 
-        ReductionRootedTreeArrangementToRootedTreeStorageAssignment {
-            target,
-            num_vertices: n,
-        }
+        Ok(
+            ReductionRootedTreeArrangementToRootedTreeStorageAssignment {
+                target,
+                num_vertices: n,
+            },
+        )
     }
 }
 
@@ -116,8 +133,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, RootedTreeStorageAssignment>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/rootedtreestorageassignment_ilp.rs b/src/rules/rootedtreestorageassignment_ilp.rs
index ee137d38a..70b4d9c56 100644
--- a/src/rules/rootedtreestorageassignment_ilp.rs
+++ b/src/rules/rootedtreestorageassignment_ilp.rs
@@ -7,6 +7,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::set::RootedTreeStorageAssignment;
 use crate::reduction;
+use crate::rules::ilp_helpers::{mccormick_product, one_hot_decode_rows};
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 // Index helpers
@@ -58,41 +59,42 @@ fn total_vars(n: usize, r: usize) -> usize {
 
 #[derive(Debug, Clone)]
 pub struct ReductionRTSAToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     n: usize,
 }
 
 impl ReductionResult for ReductionRTSAToILP {
     type Source = RootedTreeStorageAssignment;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Decode parent array from one-hot parent indicators p_{v,u}.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.n;
-        (0..n)
-            .map(|v| {
-                (0..n)
-                    .find(|&u| target_solution[idx_p(n, v, u)] == 1)
-                    .unwrap_or(v)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        one_hot_decode_rows(target_solution, self.n, self.n, 0)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "universe_size * universe_size * universe_size + 2 * universe_size * universe_size + universe_size + num_subsets * (universe_size * universe_size + 2 * universe_size + 3)",
-        num_constraints = "universe_size * universe_size * universe_size + universe_size * universe_size + universe_size * universe_size + num_subsets * universe_size * universe_size",
+        num_constraints = "4 * universe_size^3 + 6 * universe_size^2 + 5 * universe_size + 2 + num_subsets * (2 * universe_size^3 + 5 * universe_size^2 + 8 * universe_size + 8)",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
+impl ReduceTo<ILP<i64>> for RootedTreeStorageAssignment {
     type Result = ReductionRTSAToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.universe_size();
         let subsets = self.subsets();
         let bound = self.bound();
@@ -104,15 +106,17 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
         let r = nontrivial.len();
 
         if n == 0 {
-            return ReductionRTSAToILP {
-                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize),
+            return Ok(ReductionRTSAToILP {
+                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize)
+                    .map_err(Self::target_construction)?,
                 n,
-            };
+            });
         }
 
         let nv = total_vars(n, r);
-        let big_m = n as f64;
-        let big_m_depth = (n - 1) as f64;
+        let big_m = Self::exact_i64(n, "representing the vertex count in ILP rows")?;
+        let big_m_depth =
+            Self::exact_i64(n - 1, "representing the maximum tree depth in ILP rows")?;
 
         let mut constraints = Vec::new();
 
@@ -120,37 +124,37 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
 
         // Σ_u p_{v,u} = 1  ∀ v
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|u| (idx_p(n, v, u), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|u| (idx_p(n, v, u), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Σ_v p_{v,v} = 1 (exactly one root)
-        let root_terms: Vec<(usize, f64)> = (0..n).map(|v| (idx_p(n, v, v), 1.0)).collect();
-        constraints.push(LinearConstraint::eq(root_terms, 1.0));
+        let root_terms: Vec<(usize, i64)> = (0..n).map(|v| (idx_p(n, v, v), 1)).collect();
+        constraints.push(LinearConstraint::eq(root_terms, 1));
 
         // p_{v,u} binary: upper bound p_{v,u} <= 1
         for v in 0..n {
             for u in 0..n {
-                constraints.push(LinearConstraint::le(vec![(idx_p(n, v, u), 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(idx_p(n, v, u), 1)], 1));
             }
         }
 
         // d_v <= (n-1)(1 - p_{v,v})  ∀ v  (root has depth 0)
         for v in 0..n {
             constraints.push(LinearConstraint::le(
-                vec![(idx_d(n, v), 1.0), (idx_p(n, v, v), big_m_depth)],
+                vec![(idx_d(n, v), 1), (idx_p(n, v, v), big_m_depth)],
                 big_m_depth,
             ));
         }
 
         // d_v >= 0  ∀ v
         for v in 0..n {
-            constraints.push(LinearConstraint::ge(vec![(idx_d(n, v), 1.0)], 0.0));
+            constraints.push(LinearConstraint::ge(vec![(idx_d(n, v), 1)], 0));
         }
 
         // d_v <= n-1  ∀ v
         for v in 0..n {
-            constraints.push(LinearConstraint::le(vec![(idx_d(n, v), 1.0)], big_m_depth));
+            constraints.push(LinearConstraint::le(vec![(idx_d(n, v), 1)], big_m_depth));
         }
 
         // For u != v: d_v - d_u >= 1 - n(1 - p_{v,u})
@@ -166,23 +170,19 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
                     // => d_v - d_u - n*p_{v,u} >= 1 - n
                     constraints.push(LinearConstraint::ge(
                         vec![
-                            (idx_d(n, v), 1.0),
-                            (idx_d(n, u), -1.0),
+                            (idx_d(n, v), 1),
+                            (idx_d(n, u), -1),
                             (idx_p(n, v, u), -big_m),
                         ],
-                        1.0 - big_m,
+                        1 - big_m,
                     ));
 
                     // d_v - d_u <= 1 + n(1 - p_{v,u})
                     // => d_v - d_u - n + n*p_{v,u} <= 1
                     // => d_v - d_u + n*p_{v,u} <= 1 + n
                     constraints.push(LinearConstraint::le(
-                        vec![
-                            (idx_d(n, v), 1.0),
-                            (idx_d(n, u), -1.0),
-                            (idx_p(n, v, u), big_m),
-                        ],
-                        1.0 + big_m,
+                        vec![(idx_d(n, v), 1), (idx_d(n, u), -1), (idx_p(n, v, u), big_m)],
+                        1 + big_m,
                     ));
                 }
             }
@@ -192,13 +192,13 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
 
         // a_{v,v} = 1  ∀ v
         for v in 0..n {
-            constraints.push(LinearConstraint::eq(vec![(idx_a(n, v, v), 1.0)], 1.0));
+            constraints.push(LinearConstraint::eq(vec![(idx_a(n, v, v), 1)], 1));
         }
 
         // h_{u,v,v} = 0  ∀ u,v
         for u in 0..n {
             for v in 0..n {
-                constraints.push(LinearConstraint::eq(vec![(idx_h(n, u, v, v), 1.0)], 0.0));
+                constraints.push(LinearConstraint::eq(vec![(idx_h(n, u, v, v), 1)], 0));
             }
         }
 
@@ -206,11 +206,11 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
         for u in 0..n {
             for v in 0..n {
                 if u != v {
-                    let mut terms = vec![(idx_a(n, u, v), -1.0)];
+                    let mut terms = vec![(idx_a(n, u, v), -1)];
                     for w in 0..n {
-                        terms.push((idx_h(n, u, v, w), 1.0));
+                        terms.push((idx_h(n, u, v, w), 1));
                     }
-                    constraints.push(LinearConstraint::eq(terms, 0.0));
+                    constraints.push(LinearConstraint::eq(terms, 0));
                 }
             }
         }
@@ -222,21 +222,10 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
             for v in 0..n {
                 for w in 0..n {
                     if w != v {
-                        constraints.push(LinearConstraint::le(
-                            vec![(idx_h(n, u, v, w), 1.0), (idx_p(n, v, w), -1.0)],
-                            0.0,
-                        ));
-                        constraints.push(LinearConstraint::le(
-                            vec![(idx_h(n, u, v, w), 1.0), (idx_a(n, u, w), -1.0)],
-                            0.0,
-                        ));
-                        constraints.push(LinearConstraint::ge(
-                            vec![
-                                (idx_h(n, u, v, w), 1.0),
-                                (idx_p(n, v, w), -1.0),
-                                (idx_a(n, u, w), -1.0),
-                            ],
-                            -1.0,
+                        constraints.extend(mccormick_product(
+                            idx_h(n, u, v, w),
+                            idx_p(n, v, w),
+                            idx_a(n, u, w),
                         ));
                     }
                 }
@@ -246,9 +235,9 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
         // Binary bounds for a, h
         for u in 0..n {
             for v in 0..n {
-                constraints.push(LinearConstraint::le(vec![(idx_a(n, u, v), 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(idx_a(n, u, v), 1)], 1));
                 for w in 0..n {
-                    constraints.push(LinearConstraint::le(vec![(idx_h(n, u, v, w), 1.0)], 1.0));
+                    constraints.push(LinearConstraint::le(vec![(idx_h(n, u, v, w), 1)], 1));
                 }
             }
         }
@@ -259,48 +248,37 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
             let subset_size = subset.len();
 
             // Top selectors: Σ_{u ∈ S} t_{s,u} = 1, t_{s,u} = 0 for u ∉ S
-            let top_terms: Vec<(usize, f64)> =
-                subset.iter().map(|&u| (idx_t(n, r, s, u), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(top_terms, 1.0));
+            let top_terms: Vec<(usize, i64)> =
+                subset.iter().map(|&u| (idx_t(n, r, s, u), 1)).collect();
+            constraints.push(LinearConstraint::eq(top_terms, 1));
             for u in 0..n {
                 if !subset.contains(&u) {
-                    constraints.push(LinearConstraint::eq(vec![(idx_t(n, r, s, u), 1.0)], 0.0));
+                    constraints.push(LinearConstraint::eq(vec![(idx_t(n, r, s, u), 1)], 0));
                 }
                 // Binary bound
-                constraints.push(LinearConstraint::le(vec![(idx_t(n, r, s, u), 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(idx_t(n, r, s, u), 1)], 1));
             }
 
             // Bottom selectors: Σ_{v ∈ S} b_{s,v} = 1, b_{s,v} = 0 for v ∉ S
-            let bot_terms: Vec<(usize, f64)> =
-                subset.iter().map(|&v| (idx_b(n, r, s, v), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(bot_terms, 1.0));
+            let bot_terms: Vec<(usize, i64)> =
+                subset.iter().map(|&v| (idx_b(n, r, s, v), 1)).collect();
+            constraints.push(LinearConstraint::eq(bot_terms, 1));
             for v in 0..n {
                 if !subset.contains(&v) {
-                    constraints.push(LinearConstraint::eq(vec![(idx_b(n, r, s, v), 1.0)], 0.0));
+                    constraints.push(LinearConstraint::eq(vec![(idx_b(n, r, s, v), 1)], 0));
                 }
-                constraints.push(LinearConstraint::le(vec![(idx_b(n, r, s, v), 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(idx_b(n, r, s, v), 1)], 1));
             }
 
             // Pair selectors (McCormick): m_{s,u,v} = t_{s,u} * b_{s,v}
             for u in 0..n {
                 for v in 0..n {
-                    constraints.push(LinearConstraint::le(
-                        vec![(idx_m(n, r, s, u, v), 1.0), (idx_t(n, r, s, u), -1.0)],
-                        0.0,
-                    ));
-                    constraints.push(LinearConstraint::le(
-                        vec![(idx_m(n, r, s, u, v), 1.0), (idx_b(n, r, s, v), -1.0)],
-                        0.0,
-                    ));
-                    constraints.push(LinearConstraint::ge(
-                        vec![
-                            (idx_m(n, r, s, u, v), 1.0),
-                            (idx_t(n, r, s, u), -1.0),
-                            (idx_b(n, r, s, v), -1.0),
-                        ],
-                        -1.0,
+                    constraints.extend(mccormick_product(
+                        idx_m(n, r, s, u, v),
+                        idx_t(n, r, s, u),
+                        idx_b(n, r, s, v),
                     ));
-                    constraints.push(LinearConstraint::le(vec![(idx_m(n, r, s, u, v), 1.0)], 1.0));
+                    constraints.push(LinearConstraint::le(vec![(idx_m(n, r, s, u, v), 1)], 1));
                 }
             }
 
@@ -308,8 +286,8 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
             for u in 0..n {
                 for v in 0..n {
                     constraints.push(LinearConstraint::le(
-                        vec![(idx_m(n, r, s, u, v), 1.0), (idx_a(n, u, v), -1.0)],
-                        0.0,
+                        vec![(idx_m(n, r, s, u, v), 1), (idx_a(n, u, v), -1)],
+                        0,
                     ));
                 }
             }
@@ -320,12 +298,12 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
                 for u in 0..n {
                     for v in 0..n {
                         constraints.push(LinearConstraint::le(
-                            vec![(idx_m(n, r, s, u, v), 1.0), (idx_a(n, u, w), -1.0)],
-                            0.0,
+                            vec![(idx_m(n, r, s, u, v), 1), (idx_a(n, u, w), -1)],
+                            0,
                         ));
                         constraints.push(LinearConstraint::le(
-                            vec![(idx_m(n, r, s, u, v), 1.0), (idx_a(n, w, v), -1.0)],
-                            0.0,
+                            vec![(idx_m(n, r, s, u, v), 1), (idx_a(n, w, v), -1)],
+                            0,
                         ));
                     }
                 }
@@ -336,16 +314,16 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
             for &u in subset {
                 constraints.push(LinearConstraint::le(
                     vec![
-                        (idx_big_t(n, r, s), 1.0),
-                        (idx_d(n, u), -1.0),
+                        (idx_big_t(n, r, s), 1),
+                        (idx_d(n, u), -1),
                         (idx_t(n, r, s, u), big_m_depth),
                     ],
                     big_m_depth,
                 ));
                 constraints.push(LinearConstraint::le(
                     vec![
-                        (idx_d(n, u), 1.0),
-                        (idx_big_t(n, r, s), -1.0),
+                        (idx_d(n, u), 1),
+                        (idx_big_t(n, r, s), -1),
                         (idx_t(n, r, s, u), big_m_depth),
                     ],
                     big_m_depth,
@@ -355,16 +333,16 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
             for &v in subset {
                 constraints.push(LinearConstraint::le(
                     vec![
-                        (idx_big_b(n, r, s), 1.0),
-                        (idx_d(n, v), -1.0),
+                        (idx_big_b(n, r, s), 1),
+                        (idx_d(n, v), -1),
                         (idx_b(n, r, s, v), big_m_depth),
                     ],
                     big_m_depth,
                 ));
                 constraints.push(LinearConstraint::le(
                     vec![
-                        (idx_d(n, v), 1.0),
-                        (idx_big_b(n, r, s), -1.0),
+                        (idx_d(n, v), 1),
+                        (idx_big_b(n, r, s), -1),
                         (idx_b(n, r, s, v), big_m_depth),
                     ],
                     big_m_depth,
@@ -372,14 +350,14 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
             }
 
             // Depth bounds for T_s, B_s
-            constraints.push(LinearConstraint::ge(vec![(idx_big_t(n, r, s), 1.0)], 0.0));
+            constraints.push(LinearConstraint::ge(vec![(idx_big_t(n, r, s), 1)], 0));
             constraints.push(LinearConstraint::le(
-                vec![(idx_big_t(n, r, s), 1.0)],
+                vec![(idx_big_t(n, r, s), 1)],
                 big_m_depth,
             ));
-            constraints.push(LinearConstraint::ge(vec![(idx_big_b(n, r, s), 1.0)], 0.0));
+            constraints.push(LinearConstraint::ge(vec![(idx_big_b(n, r, s), 1)], 0));
             constraints.push(LinearConstraint::le(
-                vec![(idx_big_b(n, r, s), 1.0)],
+                vec![(idx_big_b(n, r, s), 1)],
                 big_m_depth,
             ));
 
@@ -387,25 +365,29 @@ impl ReduceTo<ILP<i32>> for RootedTreeStorageAssignment {
             // => c_s - B_s + T_s = 1 - |S|
             constraints.push(LinearConstraint::eq(
                 vec![
-                    (idx_c(n, r, s), 1.0),
-                    (idx_big_b(n, r, s), -1.0),
-                    (idx_big_t(n, r, s), 1.0),
+                    (idx_c(n, r, s), 1),
+                    (idx_big_b(n, r, s), -1),
+                    (idx_big_t(n, r, s), 1),
                 ],
-                1.0 - subset_size as f64,
+                1 - Self::exact_i64(
+                    subset_size,
+                    "representing a subset cardinality in an ILP row",
+                )?,
             ));
 
             // c_s >= 0
-            constraints.push(LinearConstraint::ge(vec![(idx_c(n, r, s), 1.0)], 0.0));
+            constraints.push(LinearConstraint::ge(vec![(idx_c(n, r, s), 1)], 0));
         }
 
         // Total cost bound: Σ c_s <= K
         if r > 0 {
-            let cost_terms: Vec<(usize, f64)> = (0..r).map(|s| (idx_c(n, r, s), 1.0)).collect();
-            constraints.push(LinearConstraint::le(cost_terms, bound as f64));
+            let cost_terms: Vec<(usize, i64)> = (0..r).map(|s| (idx_c(n, r, s), 1)).collect();
+            constraints.push(LinearConstraint::le(cost_terms, bound));
         }
 
-        let target = ILP::new(nv, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionRTSAToILP { target, n }
+        let target = ILP::new(nv, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionRTSAToILP { target, n })
     }
 }
 
@@ -416,19 +398,22 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "rootedtreestorageassignment_to_ilp",
         build: || {
             let source = RootedTreeStorageAssignment::new(3, vec![vec![0, 1], vec![1, 2]], 1);
-            let reduction: ReductionRTSAToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+            let reduction: ReductionRTSAToILP =
+                ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
             let target_config = {
                 let ilp_solver = crate::solvers::ILPSolver::new();
                 ilp_solver
                     .solve(reduction.target_problem())
                     .expect("ILP should be solvable")
             };
-            let source_config = reduction.extract_solution(&target_config);
-            crate::example_db::specs::rule_example_with_witness::<_, ILP<i32>>(
+            let source_config = reduction.extract_solution(&target_config).unwrap();
+            crate::example_db::specs::rule_example_with_witness::<_, ILP<i64>>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/ruralpostman_ilp.rs b/src/rules/ruralpostman_ilp.rs
index cc5ba5758..ad8e63a1d 100644
--- a/src/rules/ruralpostman_ilp.rs
+++ b/src/rules/ruralpostman_ilp.rs
@@ -14,44 +14,56 @@ use crate::types::WeightElement;
 /// Result of reducing RuralPostman to ILP.
 #[derive(Debug, Clone)]
 pub struct ReductionRPToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_edges: usize,
 }
 
 impl ReductionResult for ReductionRPToILP {
-    type Source = RuralPostman<SimpleGraph, i32>;
-    type Target = ILP<i32>;
+    type Source = RuralPostman<SimpleGraph, i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Output the traversal multiplicities t_e
-        target_solution[..self.num_edges].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        if self.target.num_vars() == 0 {
+            Ok(vec![0; self.num_edges])
+        } else {
+            crate::rules::ilp_helpers::decode_usize_values(&target_solution[..self.num_edges])
+        }
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_edges + num_vertices + num_edges + num_vertices + 2 * num_edges",
         num_constraints = "2 * num_edges + num_required_edges + num_vertices + 2 * num_edges + num_vertices + 2 * num_edges + num_vertices + num_edges + num_edges + num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for RuralPostman<SimpleGraph, i32> {
+impl ReduceTo<ILP<i64>> for RuralPostman<SimpleGraph, i64> {
     type Result = ReductionRPToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.num_edges();
         let n = self.num_vertices();
         let edges = self.graph().edges();
 
         // If E' is empty, the empty circuit satisfies when B >= 0
         if self.required_edges().is_empty() {
-            return ReductionRPToILP {
-                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize),
-                num_edges: 0,
-            };
+            return Ok(ReductionRPToILP {
+                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize)
+                    .map_err(Self::target_construction)?,
+                num_edges: m,
+            });
         }
 
         // Pick root vertex: first endpoint of first required edge
@@ -75,19 +87,13 @@ impl ReduceTo<ILP<i32>> for RuralPostman<SimpleGraph, i32> {
 
         // y_e <= t_e and t_e <= 2*y_e for each edge
         for e in 0..m {
-            constraints.push(LinearConstraint::le(
-                vec![(y_idx(e), 1.0), (t_idx(e), -1.0)],
-                0.0,
-            ));
-            constraints.push(LinearConstraint::le(
-                vec![(t_idx(e), 1.0), (y_idx(e), -2.0)],
-                0.0,
-            ));
+            constraints.push(LinearConstraint::le(vec![(y_idx(e), 1), (t_idx(e), -1)], 0));
+            constraints.push(LinearConstraint::le(vec![(t_idx(e), 1), (y_idx(e), -2)], 0));
         }
 
         // t_e >= 1 for required edges
         for &req_idx in self.required_edges() {
-            constraints.push(LinearConstraint::ge(vec![(t_idx(req_idx), 1.0)], 1.0));
+            constraints.push(LinearConstraint::ge(vec![(t_idx(req_idx), 1)], 1));
         }
 
         // Even degree: sum_{e : v in e} t_e = 2 * q_v for all v
@@ -95,46 +101,40 @@ impl ReduceTo<ILP<i32>> for RuralPostman<SimpleGraph, i32> {
             let mut terms = Vec::new();
             for (e, &(u, w)) in edges.iter().enumerate() {
                 if u == v || w == v {
-                    terms.push((t_idx(e), 1.0));
+                    terms.push((t_idx(e), 1));
                 }
             }
-            terms.push((q_idx(v), -2.0));
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            terms.push((q_idx(v), -2));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // y_e <= z_u and y_e <= z_v for each edge e = {u,v}
         for (e, &(u, v)) in edges.iter().enumerate() {
-            constraints.push(LinearConstraint::le(
-                vec![(y_idx(e), 1.0), (z_idx(u), -1.0)],
-                0.0,
-            ));
-            constraints.push(LinearConstraint::le(
-                vec![(y_idx(e), 1.0), (z_idx(v), -1.0)],
-                0.0,
-            ));
+            constraints.push(LinearConstraint::le(vec![(y_idx(e), 1), (z_idx(u), -1)], 0));
+            constraints.push(LinearConstraint::le(vec![(y_idx(e), 1), (z_idx(v), -1)], 0));
         }
 
         // z_v <= sum_{e : v in e} y_e for all v
         for v in 0..n {
-            let mut terms = vec![(z_idx(v), 1.0)];
+            let mut terms = vec![(z_idx(v), 1)];
             for (e, &(u, w)) in edges.iter().enumerate() {
                 if u == v || w == v {
-                    terms.push((y_idx(e), -1.0));
+                    terms.push((y_idx(e), -1));
                 }
             }
-            constraints.push(LinearConstraint::le(terms, 0.0));
+            constraints.push(LinearConstraint::le(terms, 0));
         }
 
         // Flow capacity: f_{u,v} <= (n-1)*y_e and f_{v,u} <= (n-1)*y_e
-        let big_m = (n - 1) as f64;
+        let big_m = Self::exact_i64(n, "encoding the connectivity-flow bound")? - 1;
         for e in 0..m {
             constraints.push(LinearConstraint::le(
-                vec![(f_idx(e, 0), 1.0), (y_idx(e), -big_m)],
-                0.0,
+                vec![(f_idx(e, 0), 1), (y_idx(e), -big_m)],
+                0,
             ));
             constraints.push(LinearConstraint::le(
-                vec![(f_idx(e, 1), 1.0), (y_idx(e), -big_m)],
-                0.0,
+                vec![(f_idx(e, 1), 1), (y_idx(e), -big_m)],
+                0,
             ));
         }
 
@@ -147,19 +147,19 @@ impl ReduceTo<ILP<i32>> for RuralPostman<SimpleGraph, i32> {
             let mut terms = Vec::new();
             for (e, &(u, v)) in edges.iter().enumerate() {
                 if u == root {
-                    terms.push((f_idx(e, 0), 1.0)); // outgoing from root via dir 0
-                    terms.push((f_idx(e, 1), -1.0)); // incoming to root via dir 1
+                    terms.push((f_idx(e, 0), 1)); // outgoing from root via dir 0
+                    terms.push((f_idx(e, 1), -1)); // incoming to root via dir 1
                 }
                 if v == root {
-                    terms.push((f_idx(e, 1), 1.0)); // outgoing from root via dir 1
-                    terms.push((f_idx(e, 0), -1.0)); // incoming to root via dir 0
+                    terms.push((f_idx(e, 1), 1)); // outgoing from root via dir 1
+                    terms.push((f_idx(e, 0), -1)); // incoming to root via dir 0
                 }
             }
             // rhs = sum_v z_v - 1, move z_v to left side
             for v in 0..n {
-                terms.push((z_idx(v), -1.0));
+                terms.push((z_idx(v), -1));
             }
-            constraints.push(LinearConstraint::eq(terms, -1.0));
+            constraints.push(LinearConstraint::eq(terms, -1));
         }
 
         // Non-root vertices: inflow - outflow = z_v
@@ -173,43 +173,44 @@ impl ReduceTo<ILP<i32>> for RuralPostman<SimpleGraph, i32> {
             for (e, &(u, w)) in edges.iter().enumerate() {
                 if u == v {
                     // Edge e = {v, w}: dir 0 is v->w (outgoing), dir 1 is w->v (incoming)
-                    terms.push((f_idx(e, 0), -1.0)); // outgoing
-                    terms.push((f_idx(e, 1), 1.0)); // incoming
+                    terms.push((f_idx(e, 0), -1)); // outgoing
+                    terms.push((f_idx(e, 1), 1)); // incoming
                 }
                 if w == v {
                     // Edge e = {u, v}: dir 0 is u->v (incoming), dir 1 is v->u (outgoing)
-                    terms.push((f_idx(e, 0), 1.0)); // incoming
-                    terms.push((f_idx(e, 1), -1.0)); // outgoing
+                    terms.push((f_idx(e, 0), 1)); // incoming
+                    terms.push((f_idx(e, 1), -1)); // outgoing
                 }
             }
-            terms.push((z_idx(v), -1.0));
-            constraints.push(LinearConstraint::eq(terms, 0.0));
+            terms.push((z_idx(v), -1));
+            constraints.push(LinearConstraint::eq(terms, 0));
         }
 
         // Upper bound on t_e: t_e <= 2
         for e in 0..m {
-            constraints.push(LinearConstraint::le(vec![(t_idx(e), 1.0)], 2.0));
+            constraints.push(LinearConstraint::le(vec![(t_idx(e), 1)], 2));
         }
 
         // Upper bounds on binary variables: y_e <= 1, z_v <= 1
         for e in 0..m {
-            constraints.push(LinearConstraint::le(vec![(y_idx(e), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(y_idx(e), 1)], 1));
         }
         for v in 0..n {
-            constraints.push(LinearConstraint::le(vec![(z_idx(v), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(z_idx(v), 1)], 1));
         }
 
         // Objective: minimize total route cost
         let edge_lengths = self.edge_lengths();
-        let objective: Vec<(usize, f64)> = (0..m)
-            .map(|e| (t_idx(e), edge_lengths[e].to_sum() as f64))
+        let objective: Vec<(usize, i64)> = (0..m)
+            .map(|e| (t_idx(e), edge_lengths[e].to_sum()))
             .collect();
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionRPToILP {
+        Ok(ReductionRPToILP {
             target,
             num_edges: m,
-        }
+        })
     }
 }
 
@@ -224,7 +225,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 vec![1, 1, 1],
                 vec![0],
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/sat_circuitsat.rs b/src/rules/sat_circuitsat.rs
index f0a2eb5a8..c6fbfab3e 100644
--- a/src/rules/sat_circuitsat.rs
+++ b/src/rules/sat_circuitsat.rs
@@ -7,7 +7,7 @@ use crate::models::formula::Satisfiability;
 use crate::models::formula::{Assignment, BooleanExpr, Circuit, CircuitSAT};
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
-use crate::traits::Problem;
+use crate::solvers::BruteForceProblem as _;
 use std::collections::HashSet;
 
 /// Result of reducing SAT to CircuitSAT.
@@ -26,24 +26,35 @@ impl ReductionResult for ReductionSATToCircuit {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.source_var_indices
-            .iter()
-            .map(|&idx| target_solution[idx])
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            self.source_var_indices
+                .iter()
+                .map(|&idx| target_solution[idx])
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
-        num_variables = "num_vars + num_clauses",
-        num_assignments = "num_vars + num_clauses",
+    transform = upper_bound {
+        num_variables = "2 * num_vars + num_clauses + 1",
+        num_assignments = "num_vars + num_clauses + 2",
+    },
+    unavailable = {
+        num_assignment_outputs = "the exact target parameter is not represented by this reduction's symbolic transform",
+        num_expression_nodes = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<CircuitSAT> for Satisfiability {
     type Result = ReductionSATToCircuit;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.num_variables();
         let clauses = self.clauses();
 
@@ -52,7 +63,7 @@ impl ReduceTo<CircuitSAT> for Satisfiability {
 
         for (i, clause) in clauses.iter().enumerate() {
             let clause_output = format!("__clause_{}", i);
-            let literal_exprs: Vec<BooleanExpr> = clause
+            let mut literal_exprs: Vec<BooleanExpr> = clause
                 .literals
                 .iter()
                 .map(|&lit| {
@@ -67,7 +78,7 @@ impl ReduceTo<CircuitSAT> for Satisfiability {
                 .collect();
 
             let clause_expr = if literal_exprs.len() == 1 {
-                literal_exprs.into_iter().next().unwrap()
+                literal_exprs.remove(0)
             } else {
                 BooleanExpr::or(literal_exprs)
             };
@@ -120,17 +131,18 @@ impl ReduceTo<CircuitSAT> for Satisfiability {
         let source_var_indices: Vec<usize> = (1..=num_vars)
             .map(|i| {
                 let name = format!("x{}", i);
-                var_names
-                    .iter()
-                    .position(|n| n == &name)
-                    .unwrap_or_else(|| panic!("Variable {} not found in CircuitSAT", name))
+                var_names.iter().position(|n| n == &name).ok_or_else(|| {
+                    crate::rules::ReductionError::invalid_target::<Satisfiability, CircuitSAT>(
+                        format!("target circuit is missing source variable `{name}`"),
+                    )
+                })
             })
-            .collect();
+            .collect::<Result<_, _>>()?;
 
-        ReductionSATToCircuit {
+        Ok(ReductionSATToCircuit {
             target,
             source_var_indices,
-        }
+        })
     }
 }
 
@@ -153,8 +165,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, CircuitSAT>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 1],
-                    target_config: vec![1, 1, 1, 1, 1, 1, 1],
+                    source_config: serde_json::json!(vec![true, true, true]),
+                    target_config: serde_json::json!(vec![
+                        true, true, true, true, true, true, true
+                    ]),
                 },
             )
         },
diff --git a/src/rules/sat_coloring.rs b/src/rules/sat_coloring.rs
index 5426f57b2..09fadc3b2 100644
--- a/src/rules/sat_coloring.rs
+++ b/src/rules/sat_coloring.rs
@@ -137,7 +137,7 @@ impl SATColoringConstructor {
     /// Add a clause to the graph.
     /// For a single-literal clause, just set the literal to TRUE.
     /// For multi-literal clauses, build OR-gadgets recursively.
-    fn add_clause(&mut self, literals: &[i32]) {
+    fn add_clause(&mut self, literals: &[i64]) {
         assert!(
             !literals.is_empty(),
             "Clause must have at least one literal"
@@ -240,40 +240,44 @@ impl ReductionResult for ReductionSATToColoring {
     ///
     /// For each variable, we check if its positive literal vertex has TRUE color (0).
     /// If so, the variable is assigned true (1); otherwise false (0).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // First determine which color is TRUE, FALSE, and AUX
-        // Vertices 0, 1, 2 are TRUE, FALSE, AUX respectively
-        assert!(
-            target_solution.len() >= 3,
-            "Invalid solution: coloring must have at least 3 vertices"
-        );
-        let true_color = target_solution[0];
-        let false_color = target_solution[1];
-        let aux_color = target_solution[2];
-
-        // Sanity checks
-        assert!(
-            true_color != false_color && true_color != aux_color,
-            "Invalid coloring solution: special vertices must have distinct colors"
-        );
-
-        let mut assignment = vec![0usize; self.num_source_variables];
-
-        for (i, &pos_vertex) in self.pos_vertices.iter().enumerate() {
-            let vertex_color = target_solution[pos_vertex];
-
-            // Sanity check: variable vertices should not have AUX color
-            assert!(
-                vertex_color != aux_color,
-                "Invalid coloring solution: variable vertex has auxiliary color"
-            );
-
-            // If positive literal has TRUE color, variable is true (1)
-            // Otherwise, variable is false (0)
-            assignment[i] = if vertex_color == true_color { 1 } else { 0 };
-        }
-
-        assignment
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // First determine which color is TRUE, FALSE, and AUX
+            // Vertices 0, 1, 2 are TRUE, FALSE, AUX respectively
+            let true_color = target_solution[0];
+            let false_color = target_solution[1];
+            let aux_color = target_solution[2];
+
+            if true_color == false_color || true_color == aux_color || false_color == aux_color {
+                return Err(crate::rules::ExtractionError::invalid(
+                    "target coloring does not distinguish true, false, and auxiliary colors",
+                ));
+            }
+
+            let mut assignment = vec![false; self.num_source_variables];
+
+            for (i, &pos_vertex) in self.pos_vertices.iter().enumerate() {
+                let vertex_color = target_solution[pos_vertex];
+
+                // Sanity check: variable vertices should not have AUX color
+                if vertex_color == aux_color {
+                    return Err(crate::rules::ExtractionError::invalid(format!(
+                        "variable {i} has the auxiliary color"
+                    )));
+                }
+
+                // If positive literal has TRUE color, variable is true (1)
+                // Otherwise, variable is false (0)
+                assignment[i] = vertex_color == true_color;
+            }
+
+            assignment
+        })
     }
 }
 
@@ -295,15 +299,16 @@ impl ReductionSATToColoring {
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "num_vars + num_literals",
-        num_edges = "num_vars + num_literals",
+    transform = exact {
+        num_vertices = "2 * num_vars + 3 + 5 * (num_literals - num_clauses)",
+        num_edges = "3 + 3 * num_vars + 11 * num_literals - 9 * num_clauses",
+        num_colors = "3",
     }
 )]
 impl ReduceTo<KColoring<K3, SimpleGraph>> for Satisfiability {
     type Result = ReductionSATToColoring;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let mut constructor = SATColoringConstructor::new(self.num_vars());
 
         // Add each clause to the graph
@@ -313,13 +318,13 @@ impl ReduceTo<KColoring<K3, SimpleGraph>> for Satisfiability {
 
         let target = constructor.build_coloring();
 
-        ReductionSATToColoring {
+        Ok(ReductionSATToColoring {
             target,
             pos_vertices: constructor.pos_vertices,
             neg_vertices: constructor.neg_vertices,
             num_source_variables: self.num_vars(),
             num_clauses: self.num_clauses(),
-        }
+        })
     }
 }
 
@@ -342,8 +347,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, KColoring<K3, SimpleGraph>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 0, 1, 1],
-                    target_config: vec![2, 1, 0, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1],
+                    source_config: serde_json::json!(vec![true, true, false, true, true]),
+                    target_config: serde_json::json!(vec![2, 1, 0, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1]),
                 },
             )
         },
diff --git a/src/rules/sat_helpers.rs b/src/rules/sat_helpers.rs
new file mode 100644
index 000000000..75573b481
--- /dev/null
+++ b/src/rules/sat_helpers.rs
@@ -0,0 +1,72 @@
+#[derive(Debug)]
+pub(crate) struct SatVariableAllocator {
+    reduction: &'static str,
+    next: u64,
+}
+
+impl SatVariableAllocator {
+    pub(crate) fn new(
+        reduction: &'static str,
+        existing: usize,
+    ) -> Result<Self, crate::registry::ConstructionError> {
+        if existing > i64::MAX as usize {
+            return Err(format!(
+                "{reduction} has {existing} source variables; SAT variable numbers are limited to {}",
+                i64::MAX
+            ).into());
+        }
+        Ok(Self {
+            reduction,
+            next: u64::try_from(existing).expect("usize SAT count fits u64") + 1,
+        })
+    }
+
+    pub(crate) fn allocate(&mut self) -> Result<i64, crate::registry::ConstructionError> {
+        let variable = self.next;
+        if variable > i64::MAX as u64 {
+            return Err(format!(
+                "{} cannot allocate 1 auxiliary variable after {}; SAT variable numbers are limited to {}",
+                self.reduction,
+                self.num_vars(),
+                i64::MAX
+            ).into());
+        }
+        self.next += 1;
+        Ok(i64::try_from(variable).expect("checked SAT variable fits i64"))
+    }
+
+    pub(crate) fn allocate_many(
+        &mut self,
+        count: usize,
+    ) -> Result<Vec<i64>, crate::registry::ConstructionError> {
+        if count == 0 {
+            return Ok(Vec::new());
+        }
+        let count = u64::try_from(count).expect("usize allocation count fits u64");
+        let last = self
+            .next
+            .checked_add(count - 1)
+            .ok_or_else(|| format!("{} auxiliary variable count overflow", self.reduction))?;
+        if last > i64::MAX as u64 {
+            return Err(format!(
+                "{} cannot allocate {count} auxiliary variables after {}; SAT variable numbers are limited to {}",
+                self.reduction,
+                self.num_vars(),
+                i64::MAX
+            ).into());
+        }
+        let variables = (self.next..=last)
+            .map(|variable| i64::try_from(variable).expect("checked SAT variable fits i64"))
+            .collect();
+        self.next = last + 1;
+        Ok(variables)
+    }
+
+    pub(crate) fn num_vars(&self) -> usize {
+        usize::try_from(self.next - 1).expect("SAT variable count fits usize")
+    }
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/sat_helpers.rs"]
+mod tests;
diff --git a/src/rules/sat_ksat.rs b/src/rules/sat_ksat.rs
index 39be989d5..897c8bb5b 100644
--- a/src/rules/sat_ksat.rs
+++ b/src/rules/sat_ksat.rs
@@ -8,6 +8,7 @@
 
 use crate::models::formula::{CNFClause, KSatisfiability, Satisfiability};
 use crate::reduction;
+use crate::rules::sat_helpers::SatVariableAllocator;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::variant::{KValue, K2, K3, KN};
 
@@ -31,9 +32,16 @@ impl<K: KValue> ReductionResult for ReductionSATToKSAT<K> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Only return the original variables, discarding ancillas
-        target_solution[..self.source_num_vars].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // Only return the original variables, discarding ancillas
+            target_solution[..self.source_num_vars].to_vec()
+        })
     }
 }
 
@@ -48,16 +56,12 @@ impl<K: KValue> ReductionResult for ReductionSATToKSAT<K> {
 /// * `k` - Target number of literals per clause
 /// * `clause` - The clause to add
 /// * `result_clauses` - Output vector to append clauses to
-/// * `next_var` - Next available variable number (1-indexed)
-///
-/// # Returns
-/// Updated next_var after any ancilla variables are created
 fn add_clause_to_ksat(
     k: usize,
     clause: &CNFClause,
     result_clauses: &mut Vec<CNFClause>,
-    mut next_var: i32,
-) -> i32 {
+    variables: &mut SatVariableAllocator,
+) -> Result<(), crate::registry::ConstructionError> {
     let len = clause.len();
 
     if len == k {
@@ -67,28 +71,32 @@ fn add_clause_to_ksat(
         // Too few literals: pad with ancilla variables
         // Create both positive and negative versions to maintain satisfiability
         // (a v b) with k=3 becomes (a v b v x) AND (a v b v -x)
-        let ancilla = next_var;
-        next_var += 1;
+        let ancilla = variables.allocate()?;
 
         // Add clause with positive ancilla
         let mut lits_pos = clause.literals.clone();
         lits_pos.push(ancilla);
-        next_var = add_clause_to_ksat(k, &CNFClause::new(lits_pos), result_clauses, next_var);
+        add_clause_to_ksat(k, &CNFClause::new(lits_pos), result_clauses, variables)?;
 
         // Add clause with negative ancilla
         let mut lits_neg = clause.literals.clone();
         lits_neg.push(-ancilla);
-        next_var = add_clause_to_ksat(k, &CNFClause::new(lits_neg), result_clauses, next_var);
+        add_clause_to_ksat(k, &CNFClause::new(lits_neg), result_clauses, variables)?;
     } else {
         // Too many literals: split using ancilla variable
         // (a v b v c v d) with k=3 becomes (a v b v x) AND (-x v c v d)
-        assert!(k >= 3, "K must be at least 3 for splitting");
+        if k < 3 {
+            return Err(format!(
+                "cannot split a clause with {} literals into {k}-literal clauses",
+                clause.len()
+            )
+            .into());
+        }
 
-        let ancilla = next_var;
-        next_var += 1;
+        let ancilla = variables.allocate()?;
 
         // First clause: first k-1 literals + positive ancilla
-        let mut first_lits: Vec<i32> = clause.literals[..k - 1].to_vec();
+        let mut first_lits: Vec<i64> = clause.literals[..k - 1].to_vec();
         first_lits.push(ancilla);
         result_clauses.push(CNFClause::new(first_lits));
 
@@ -98,10 +106,10 @@ fn add_clause_to_ksat(
         let remaining_clause = CNFClause::new(remaining_lits);
 
         // Recursively process the remaining clause
-        next_var = add_clause_to_ksat(k, &remaining_clause, result_clauses, next_var);
+        add_clause_to_ksat(k, &remaining_clause, result_clauses, variables)?;
     }
 
-    next_var
+    Ok(())
 }
 
 /// Implementation of SAT -> K-SAT reduction.
@@ -111,31 +119,43 @@ fn add_clause_to_ksat(
 macro_rules! impl_sat_to_ksat {
     ($ktype:ty, $k:expr) => {
         #[rustfmt::skip]
-        #[reduction(overhead = {
-            num_clauses = "4 * num_clauses + num_literals",
-            num_vars = "num_vars + 3 * num_clauses + num_literals",
-        })]
+        #[reduction(
+    transform = upper_bound {
+        num_clauses = "4 * num_clauses + num_literals",
+        num_vars = "num_vars + 3 * num_clauses + num_literals",
+    },
+    unavailable = {
+        num_literals = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
         impl ReduceTo<KSatisfiability<$ktype>> for Satisfiability {
             type Result = ReductionSATToKSAT<$ktype>;
 
-            fn reduce_to(&self) -> Self::Result {
+            fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
                 let source_num_vars = self.num_vars();
                 let mut result_clauses = Vec::new();
-                let mut next_var = (source_num_vars + 1) as i32; // 1-indexed
+                let mut variables = SatVariableAllocator::new(
+                    "Satisfiability -> KSatisfiability",
+                    source_num_vars,
+                ).map_err(crate::rules::ReductionError::construction::<
+                    Satisfiability,
+                    KSatisfiability<$ktype>,
+                >)?;
 
                 for clause in self.clauses() {
-                    next_var = add_clause_to_ksat($k, clause, &mut result_clauses, next_var);
+                    add_clause_to_ksat($k, clause, &mut result_clauses, &mut variables)
+                        .map_err(crate::rules::ReductionError::construction::<
+                            Satisfiability,
+                            KSatisfiability<$ktype>,
+                        >)?;
                 }
 
-                // Calculate total number of variables (original + ancillas)
-                let total_vars = (next_var - 1) as usize;
-
-                let target = KSatisfiability::<$ktype>::new(total_vars, result_clauses);
+                let target = KSatisfiability::<$ktype>::new(variables.num_vars(), result_clauses);
 
-                ReductionSATToKSAT {
+                Ok(ReductionSATToKSAT {
                     source_num_vars,
                     target,
-                }
+                })
             }
         }
     };
@@ -162,9 +182,16 @@ impl<K: KValue> ReductionResult for ReductionKSATToSAT<K> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Direct mapping - no transformation needed
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // Direct mapping - no transformation needed
+            target_solution.to_vec()
+        })
     }
 }
 
@@ -184,16 +211,17 @@ fn reduce_ksat_to_sat<K: KValue>(ksat: &KSatisfiability<K>) -> ReductionKSATToSA
 macro_rules! impl_ksat_to_sat {
     ($ktype:ty) => {
 #[rustfmt::skip]
-        #[reduction(overhead = {
-            num_clauses = "num_clauses",
-            num_vars = "num_vars",
-            num_literals = "num_literals",
-        })]
+        #[reduction(
+    transform = exact {
+        num_clauses = "num_clauses",
+        num_vars = "num_vars",
+        num_literals = "num_literals",
+    })]
         impl ReduceTo<Satisfiability> for KSatisfiability<$ktype> {
             type Result = ReductionKSATToSAT<$ktype>;
 
-            fn reduce_to(&self) -> Self::Result {
-                reduce_ksat_to_sat(self)
+            fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+                Ok(reduce_ksat_to_sat(self))
             }
         }
     };
@@ -206,15 +234,15 @@ impl_ksat_to_sat!(KN);
 // but are NOT registered as separate primitive graph edges (KN covers them).
 impl ReduceTo<Satisfiability> for KSatisfiability<K3> {
     type Result = ReductionKSATToSAT<K3>;
-    fn reduce_to(&self) -> Self::Result {
-        reduce_ksat_to_sat(self)
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(reduce_ksat_to_sat(self))
     }
 }
 
 impl ReduceTo<Satisfiability> for KSatisfiability<K2> {
     type Result = ReductionKSATToSAT<K2>;
-    fn reduce_to(&self) -> Self::Result {
-        reduce_ksat_to_sat(self)
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(reduce_ksat_to_sat(self))
     }
 }
 
@@ -241,8 +269,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 crate::example_db::specs::rule_example_with_witness::<_, KSatisfiability<K3>>(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 1, 1, 0, 1],
-                        target_config: vec![1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1],
+                        source_config: serde_json::json!(vec![true, true, true, false, true]),
+                        target_config: serde_json::json!(vec![
+                            true, true, true, false, true, false, false, false, false, true, true,
+                            true
+                        ]),
                     },
                 )
             },
@@ -261,8 +292,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 crate::example_db::specs::rule_example_with_witness::<_, Satisfiability>(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 1, 1, 0],
-                        target_config: vec![1, 1, 1, 0],
+                        source_config: serde_json::json!(vec![true, true, true, false]),
+                        target_config: serde_json::json!(vec![true, true, true, false]),
                     },
                 )
             },
diff --git a/src/rules/sat_maximumindependentset.rs b/src/rules/sat_maximumindependentset.rs
index b49367747..d8271f74e 100644
--- a/src/rules/sat_maximumindependentset.rs
+++ b/src/rules/sat_maximumindependentset.rs
@@ -13,7 +13,7 @@ use crate::models::graph::MaximumIndependentSet;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::SimpleGraph;
-use crate::types::One;
+use crate::types::{Max, One, Or};
 
 /// A literal in the SAT problem, representing a variable or its negation.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -32,7 +32,7 @@ impl BoolVar {
 
     /// Create a literal from a signed integer (1-indexed, as in DIMACS format).
     /// Positive means the variable, negative means its negation.
-    pub fn from_literal(lit: i32) -> Self {
+    pub fn from_literal(lit: i64) -> Self {
         let name = lit.unsigned_abs() as usize - 1; // Convert to 0-indexed
         let neg = lit < 0;
         Self { name, neg }
@@ -61,6 +61,8 @@ pub struct ReductionSATToIS {
     num_source_variables: usize,
     /// The number of clauses in the source SAT problem.
     num_clauses: usize,
+    /// Exact independent-set cardinality certifying satisfiability.
+    target_size: i64,
 }
 
 impl ReductionResult for ReductionSATToIS {
@@ -76,23 +78,39 @@ impl ReductionResult for ReductionSATToIS {
     /// For each selected vertex (representing a literal), we set the corresponding
     /// variable to make that literal true. Variables not covered by any selected
     /// literal default to false.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let mut assignment = vec![0usize; self.num_source_variables];
-        let mut covered = vec![false; self.num_source_variables];
-
-        for (vertex_idx, &selected) in target_solution.iter().enumerate() {
-            if selected == 1 {
-                let literal = &self.literals[vertex_idx];
-                // If the literal is positive (neg=false), variable should be true (1)
-                // If the literal is negated (neg=true), variable should be false (0)
-                assignment[literal.name] = if literal.neg { 0 } else { 1 };
-                covered[literal.name] = true;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        let certificate = crate::rules::AggregateReductionResult::extract_value(self, value);
+        if !certificate.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target independent set does not certify satisfiability",
+            ));
+        }
+
+        let mut assignment = vec![false; self.num_source_variables];
+        for (literal, &selected) in self.literals.iter().zip(target_solution) {
+            if selected {
+                assignment[literal.name] = !literal.neg;
             }
         }
+        Ok(assignment)
+    }
+}
+
+impl crate::rules::AggregateReductionResult for ReductionSATToIS {
+    type Source = Satisfiability;
+    type Target = MaximumIndependentSet<SimpleGraph, One>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
 
-        // Variables not covered can be assigned any value (we use 0)
-        // They are already initialized to 0
-        assignment
+    fn extract_value(&self, target_value: Max<i64>) -> Or {
+        Or(target_value == Max(Some(self.target_size)))
     }
 }
 
@@ -109,7 +127,8 @@ impl ReductionSATToIS {
 }
 
 #[reduction(
-    overhead = {
+    aggregate = custom,
+    transform = upper_bound {
         num_vertices = "num_literals",
         num_edges = "num_literals^2",
     }
@@ -117,22 +136,25 @@ impl ReductionSATToIS {
 impl ReduceTo<MaximumIndependentSet<SimpleGraph, One>> for Satisfiability {
     type Result = ReductionSATToIS;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let target_size = <Self as ReduceTo<MaximumIndependentSet<SimpleGraph, One>>>::exact_i64(
+            self.num_clauses(),
+            "representing the satisfying independent-set cardinality",
+        )?;
         let mut literals: Vec<BoolVar> = Vec::new();
         let mut edges: Vec<(usize, usize)> = Vec::new();
-        let mut vertex_count = 0;
 
         // First pass: add vertices for each literal in each clause
         // and add clique edges within each clause
         for clause in self.clauses() {
-            let clause_start = vertex_count;
+            let clause_start = literals.len();
 
             // Add vertices for each literal in this clause
             for &lit in &clause.literals {
                 literals.push(BoolVar::from_literal(lit));
-                vertex_count += 1;
             }
 
+            let vertex_count = literals.len();
             // Add clique edges within this clause
             for i in clause_start..vertex_count {
                 for j in (i + 1)..vertex_count {
@@ -141,9 +163,9 @@ impl ReduceTo<MaximumIndependentSet<SimpleGraph, One>> for Satisfiability {
             }
         }
 
-        // Second pass: add edges between complementary literals across clauses
-        // Since we only add clique edges within clauses in the first pass,
-        // complementary literals in different clauses won't already have an edge
+        let vertex_count = literals.len();
+        // Add complementary-literal edges. Within a clause these may duplicate
+        // clique edges, which does not change independent-set feasibility.
         for i in 0..vertex_count {
             for j in (i + 1)..vertex_count {
                 if literals[i].is_complement(&literals[j]) {
@@ -157,12 +179,13 @@ impl ReduceTo<MaximumIndependentSet<SimpleGraph, One>> for Satisfiability {
             vec![One; vertex_count],
         );
 
-        ReductionSATToIS {
+        Ok(ReductionSATToIS {
             target,
             literals,
             num_source_variables: self.num_vars(),
             num_clauses: self.num_clauses(),
-        }
+            target_size,
+        })
     }
 }
 
@@ -195,10 +218,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             >(
                 sat_seven_clause_example(),
                 SolutionPair {
-                    source_config: vec![1, 1, 1, 1, 0],
-                    target_config: vec![
-                        1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,
-                    ],
+                    source_config: serde_json::json!(vec![true, true, true, true, false]),
+                    target_config: serde_json::json!(vec![
+                        true, false, false, false, true, false, true, false, false, false, false,
+                        true, true, false, false, false, false, true, true, false, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/sat_minimumdominatingset.rs b/src/rules/sat_minimumdominatingset.rs
index e5046ac42..bed0c45e8 100644
--- a/src/rules/sat_minimumdominatingset.rs
+++ b/src/rules/sat_minimumdominatingset.rs
@@ -1,7 +1,7 @@
 //! Reduction from Satisfiability (SAT) to MinimumDominatingSet.
 //!
 //! The reduction follows this construction:
-//! 1. For each variable x_i, create a "variable gadget" with 3 vertices:
+//! 1. For each occurring variable x_i, create a "variable gadget" with 3 vertices:
 //!    - Vertex for positive literal x_i
 //!    - Vertex for negative literal NOT x_i
 //!    - A dummy vertex
@@ -9,10 +9,10 @@
 //! 2. For each clause C_j, create a clause vertex.
 //! 3. Connect each clause vertex to the literal vertices that appear in that clause.
 //!
-//! A dominating set of size = num_variables corresponds to a satisfying assignment:
+//! A dominating set of size = number of occurring variables corresponds to a satisfying assignment:
 //! - Selecting the positive literal vertex means the variable is true
 //! - Selecting the negative literal vertex means the variable is false
-//! - Selecting the dummy vertex means the variable can be either (unused in any clause)
+//! - Selecting the dummy vertex means the variable may be assigned either value
 
 use crate::models::formula::Satisfiability;
 use crate::models::graph::MinimumDominatingSet;
@@ -20,6 +20,8 @@ use crate::reduction;
 use crate::rules::sat_maximumindependentset::BoolVar;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::SimpleGraph;
+use crate::types::{Min, Or};
+use std::collections::BTreeMap;
 
 /// Result of reducing Satisfiability to MinimumDominatingSet.
 ///
@@ -30,16 +32,20 @@ use crate::topology::SimpleGraph;
 #[derive(Debug, Clone)]
 pub struct ReductionSATToDS {
     /// The target MinimumDominatingSet problem.
-    target: MinimumDominatingSet<SimpleGraph, i32>,
+    target: MinimumDominatingSet<SimpleGraph, i64>,
     /// The number of variables in the source SAT problem.
     num_literals: usize,
     /// The number of clauses in the source SAT problem.
     num_clauses: usize,
+    /// Original variable indices mapped to dense triangle indices.
+    variables: BTreeMap<usize, usize>,
+    /// Exact minimum size certifying satisfiability.
+    target_size: i64,
 }
 
 impl ReductionResult for ReductionSATToDS {
     type Source = Satisfiability;
-    type Target = MinimumDominatingSet<SimpleGraph, i32>;
+    type Target = MinimumDominatingSet<SimpleGraph, i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
@@ -47,59 +53,75 @@ impl ReductionResult for ReductionSATToDS {
 
     /// Extract a SAT solution from a MinimumDominatingSet solution.
     ///
-    /// The dominating set solution encodes variable assignments:
-    /// - For each variable x_i (0-indexed), vertices are at positions 3*i, 3*i+1, 3*i+2
-    ///   - 3*i: positive literal x_i (selecting means x_i = true)
-    ///   - 3*i+1: negative literal NOT x_i (selecting means x_i = false)
-    ///   - 3*i+2: dummy vertex (selecting means x_i can be either)
-    ///
-    /// If more than num_literals vertices are selected, the solution is invalid
-    /// and we return a default assignment.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let selected_count: usize = target_solution.iter().sum();
-
-        // If more vertices selected than variables, not a minimal dominating set
-        // corresponding to a satisfying assignment
-        if selected_count > self.num_literals {
-            // Return default assignment (all false)
-            return vec![0; self.num_literals];
+    /// Validate a dominating set of exactly one vertex per occurring variable.
+    /// Each dense triangle starts with its positive literal; selecting it sets
+    /// that original variable true. Negative, dummy and absent variables decode
+    /// to false. The finite size certificate proves every clause is dominated
+    /// by a selected literal and no clause vertex is selected.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        let certificate = crate::rules::AggregateReductionResult::extract_value(self, value);
+        if !certificate.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target dominating set does not certify satisfiability",
+            ));
         }
 
-        let mut assignment = vec![0usize; self.num_literals];
-
-        for (i, &value) in target_solution.iter().enumerate() {
-            if value == 1 {
-                // Only consider variable gadget vertices (first 3*num_literals vertices)
-                if i >= 3 * self.num_literals {
-                    continue; // Skip clause vertices
-                }
-
-                let var_index = i / 3;
-                let vertex_type = i % 3;
-
-                match vertex_type {
-                    0 => {
-                        // Positive literal selected: x_i = true
-                        assignment[var_index] = 1;
-                    }
-                    1 => {
-                        // Negative literal selected: x_i = false
-                        assignment[var_index] = 0;
-                    }
-                    2 => {
-                        // Dummy vertex selected: variable is unconstrained
-                        // Default to false (already 0), but could be anything
-                    }
-                    _ => unreachable!(),
-                }
-            }
+        let mut assignment = vec![false; self.num_literals];
+        for (&variable, &gadget) in &self.variables {
+            assignment[variable] = target_solution[3 * gadget];
         }
 
-        assignment
+        Ok(assignment)
+    }
+}
+
+impl crate::rules::AggregateReductionResult for ReductionSATToDS {
+    type Source = Satisfiability;
+    type Target = MinimumDominatingSet<SimpleGraph, i64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, target_value: Min<i64>) -> Or {
+        Or(target_value == Min(Some(self.target_size)))
     }
 }
 
 impl ReductionSATToDS {
+    /// Compute the graph dimensions and exact certificate before allocation.
+    fn target_dimensions(
+        num_variables: usize,
+        num_clauses: usize,
+    ) -> Result<(usize, i64), crate::rules::ReductionError> {
+        let num_vertices = num_variables
+            .checked_mul(3)
+            .and_then(|base| base.checked_add(num_clauses))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    Satisfiability,
+                    MinimumDominatingSet<SimpleGraph, i64>,
+                >("counting dominating-set vertices")
+            })?;
+        // All vertices may be selected, so every count up to this total must
+        // fit the target objective, not only the optimum certificate.
+        <Satisfiability as ReduceTo<MinimumDominatingSet<SimpleGraph, i64>>>::exact_i64(
+            num_vertices,
+            "representing all dominating-set weights",
+        )?;
+        let target_size =
+            <Satisfiability as ReduceTo<MinimumDominatingSet<SimpleGraph, i64>>>::exact_i64(
+                num_variables,
+                "representing the satisfying dominating-set cardinality",
+            )?;
+        Ok((num_vertices, target_size))
+    }
+
     /// Get the number of literals (variables) in the source SAT problem.
     pub fn num_literals(&self) -> usize {
         self.num_literals
@@ -112,20 +134,31 @@ impl ReductionSATToDS {
 }
 
 #[reduction(
-    overhead = {
+    aggregate = custom,
+    transform = upper_bound {
         num_vertices = "3 * num_vars + num_clauses",
         num_edges = "3 * num_vars + num_literals",
     }
 )]
-impl ReduceTo<MinimumDominatingSet<SimpleGraph, i32>> for Satisfiability {
+impl ReduceTo<MinimumDominatingSet<SimpleGraph, i64>> for Satisfiability {
     type Result = ReductionSATToDS;
 
-    fn reduce_to(&self) -> Self::Result {
-        let num_variables = self.num_vars();
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        // Absent variables are free in SAT and need no target gadget. Keep
+        // original indices for extraction, and assign dense indices in order.
+        let mut variables: BTreeMap<usize, usize> = self
+            .clauses()
+            .iter()
+            .flat_map(|clause| &clause.literals)
+            .map(|&literal| (BoolVar::from_literal(literal).name, 0))
+            .collect();
+        for (index, gadget) in variables.values_mut().enumerate() {
+            *gadget = index;
+        }
+        let num_variables = variables.len();
         let num_clauses = self.num_clauses();
-
-        // Total vertices: 3 per variable (for variable gadget) + 1 per clause
-        let num_vertices = 3 * num_variables + num_clauses;
+        let (num_vertices, target_size) =
+            ReductionSATToDS::target_dimensions(num_variables, num_clauses)?;
 
         let mut edges: Vec<(usize, usize)> = Vec::new();
 
@@ -150,28 +183,25 @@ impl ReduceTo<MinimumDominatingSet<SimpleGraph, i32>> for Satisfiability {
 
             for &lit in &clause.literals {
                 let var = BoolVar::from_literal(lit);
-                // var.name is 0-indexed
-                // If positive literal, connect to vertex 3*var.name
-                // If negative literal, connect to vertex 3*var.name + 1
-                let literal_vertex = if var.neg {
-                    3 * var.name + 1
-                } else {
-                    3 * var.name
-                };
+                // The literal's original index is present in the map because
+                // the map was collected from these same validated clauses.
+                let literal_vertex = 3 * variables[&var.name] + usize::from(var.neg);
                 edges.push((literal_vertex, clause_vertex));
             }
         }
 
         let target = MinimumDominatingSet::new(
             SimpleGraph::new(num_vertices, edges),
-            vec![1i32; num_vertices],
+            vec![1i64; num_vertices],
         );
 
-        ReductionSATToDS {
+        Ok(ReductionSATToDS {
             target,
-            num_literals: num_variables,
+            num_literals: self.num_vars(),
             num_clauses,
-        }
+            variables,
+            target_size,
+        })
     }
 }
 
@@ -197,14 +227,15 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             );
             crate::example_db::specs::rule_example_with_witness::<
                 _,
-                MinimumDominatingSet<SimpleGraph, i32>,
+                MinimumDominatingSet<SimpleGraph, i64>,
             >(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 0, 1, 1, 1],
-                    target_config: vec![
-                        1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                    ],
+                    source_config: serde_json::json!(vec![true, false, true, true, true]),
+                    target_config: serde_json::json!(vec![
+                        true, false, false, false, true, false, true, false, false, true, false,
+                        false, true, false, false, false, false, false, false, false, false, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/satisfiability_integralflowhomologousarcs.rs b/src/rules/satisfiability_integralflowhomologousarcs.rs
index e00849ec2..d6a1fa8dc 100644
--- a/src/rules/satisfiability_integralflowhomologousarcs.rs
+++ b/src/rules/satisfiability_integralflowhomologousarcs.rs
@@ -72,7 +72,7 @@ pub struct ReductionSATToIntegralFlowHomologousArcs {
 
 impl ReductionSATToIntegralFlowHomologousArcs {
     #[cfg(any(test, feature = "example-db"))]
-    fn encode_assignment(&self, assignment: &[usize]) -> Vec<usize> {
+    fn encode_assignment(&self, assignment: &[bool]) -> Vec<usize> {
         assert_eq!(
             assignment.len(),
             self.variable_paths.len(),
@@ -81,7 +81,7 @@ impl ReductionSATToIntegralFlowHomologousArcs {
 
         let mut flow = vec![0usize; self.target.num_arcs()];
         for (value, paths) in assignment.iter().zip(&self.variable_paths) {
-            let path = if *value == 0 {
+            let path = if !*value {
                 &paths.false_path
             } else {
                 &paths.true_path
@@ -102,41 +102,45 @@ impl ReductionResult for ReductionSATToIntegralFlowHomologousArcs {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        self.variable_paths
-            .iter()
-            .map(|paths| {
-                usize::from(
-                    target_solution
-                        .get(paths.true_base_arc)
-                        .copied()
-                        .unwrap_or(0)
-                        > 0,
-                )
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            self.variable_paths
+                .iter()
+                .map(|paths| target_solution[paths.true_base_arc] > 0)
+                .collect()
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vertices = "2 * num_vars * num_clauses + 3 * num_vars + 2 * num_clauses + 2",
-    num_arcs = "2 * num_vars * num_clauses + 5 * num_vars + num_clauses + num_literals",
-})]
+#[reduction(
+    transform = exact {
+        num_vertices = "2 * num_vars * num_clauses + 3 * num_vars + 2 * num_clauses + 2",
+        num_arcs = "2 * num_vars * num_clauses + 5 * num_vars + num_clauses + num_literals",
+    },
+    unavailable = {
+        max_capacity = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<IntegralFlowHomologousArcs> for Satisfiability {
     type Result = ReductionSATToIntegralFlowHomologousArcs;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let indexer = NodeIndexer {
             num_vars: self.num_vars(),
             num_clauses: self.num_clauses(),
         };
 
         let mut arcs = Vec::<(usize, usize)>::new();
-        let mut capacities = Vec::<u64>::new();
+        let mut capacities = Vec::<i64>::new();
         let mut homologous_pairs = Vec::<(usize, usize)>::new();
         let mut variable_paths = Vec::<VariablePaths>::with_capacity(self.num_vars());
 
-        let mut add_arc = |u: usize, v: usize, capacity: u64| -> usize {
+        let mut add_arc = |u: usize, v: usize, capacity: i64| -> usize {
             arcs.push((u, v));
             capacities.push(capacity);
             arcs.len() - 1
@@ -165,11 +169,14 @@ impl ReduceTo<IntegralFlowHomologousArcs> for Satisfiability {
         for (clause_idx, clause) in self.clauses().iter().enumerate() {
             let collector = indexer.collector(clause_idx);
             let distributor = indexer.distributor(clause_idx);
-            let bottleneck = add_arc(
-                collector,
-                distributor,
-                clause.literals.len().saturating_sub(1) as u64,
-            );
+            let bottleneck_capacity = i64::try_from(clause.literals.len().saturating_sub(1))
+                .map_err(|_| {
+                    crate::rules::ReductionError::integer_overflow::<
+                        Satisfiability,
+                        IntegralFlowHomologousArcs,
+                    >("converting a clause bottleneck capacity to i64")
+                })?;
+            let bottleneck = add_arc(collector, distributor, bottleneck_capacity);
 
             let mut has_positive = vec![false; self.num_vars()];
             let mut has_negative = vec![false; self.num_vars()];
@@ -229,12 +236,22 @@ impl ReduceTo<IntegralFlowHomologousArcs> for Satisfiability {
             paths.false_path.push(false_sink);
         }
 
-        let mut requirement = self.num_vars() as u64;
+        let mut requirement = i64::try_from(self.num_vars()).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                Satisfiability,
+                IntegralFlowHomologousArcs,
+            >("converting the SAT variable count to an i64 flow requirement")
+        })?;
         if self.clauses().iter().any(|clause| clause.is_empty()) {
-            requirement += 1;
+            requirement = requirement.checked_add(1).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    Satisfiability,
+                    IntegralFlowHomologousArcs,
+                >("including the empty-clause flow requirement")
+            })?;
         }
 
-        ReductionSATToIntegralFlowHomologousArcs {
+        Ok(ReductionSATToIntegralFlowHomologousArcs {
             target: IntegralFlowHomologousArcs::new(
                 DirectedGraph::new(indexer.total_vertices(), arcs),
                 capacities,
@@ -244,7 +261,7 @@ impl ReduceTo<IntegralFlowHomologousArcs> for Satisfiability {
                 homologous_pairs,
             ),
             variable_paths,
-        }
+        })
     }
 }
 
@@ -269,14 +286,17 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         id: "satisfiability_to_integralflowhomologousarcs",
         build: || {
             let source = issue_example();
-            let source_config = vec![1, 0, 1];
+            let source_config = vec![true, false, true];
             let target_config = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source)
+                .expect("reduction should succeed")
                 .encode_assignment(&source_config);
             crate::example_db::specs::rule_example_with_witness::<_, IntegralFlowHomologousArcs>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/satisfiability_maximum2satisfiability.rs b/src/rules/satisfiability_maximum2satisfiability.rs
index c26d68458..040837da5 100644
--- a/src/rules/satisfiability_maximum2satisfiability.rs
+++ b/src/rules/satisfiability_maximum2satisfiability.rs
@@ -2,13 +2,16 @@
 
 use crate::models::formula::{CNFClause, Maximum2Satisfiability, Satisfiability};
 use crate::reduction;
+use crate::rules::sat_helpers::SatVariableAllocator;
 use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::types::{Max, Or};
 
 /// Result of reducing SAT to MAX-2-SAT.
 #[derive(Debug, Clone)]
 pub struct ReductionSatisfiabilityToMaximum2Satisfiability {
     target: Maximum2Satisfiability,
     source_num_vars: usize,
+    target_score: i64,
 }
 
 impl ReductionResult for ReductionSatisfiabilityToMaximum2Satisfiability {
@@ -19,24 +22,52 @@ impl ReductionResult for ReductionSatisfiabilityToMaximum2Satisfiability {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.source_num_vars].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        let certificate = crate::rules::AggregateReductionResult::extract_value(self, value);
+        if !certificate.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target assignment does not certify satisfiability",
+            ));
+        }
+
+        Ok(target_solution[..self.source_num_vars].to_vec())
     }
 }
 
-fn add_normalized_clause(clause: &CNFClause, next_var: &mut i32, normalized: &mut Vec<CNFClause>) {
+impl crate::rules::AggregateReductionResult for ReductionSatisfiabilityToMaximum2Satisfiability {
+    type Source = Satisfiability;
+    type Target = Maximum2Satisfiability;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, value: Max<i64>) -> Or {
+        Or(value == Max(Some(self.target_score)))
+    }
+}
+
+fn add_normalized_clause(
+    clause: &CNFClause,
+    variables: &mut SatVariableAllocator,
+    normalized: &mut Vec<CNFClause>,
+) -> Result<(), crate::registry::ConstructionError> {
     match clause.len() {
         0 => {
-            let y = *next_var;
-            *next_var += 1;
+            let y = variables.allocate()?;
             normalized.push(CNFClause::new(vec![y, y, y]));
             normalized.push(CNFClause::new(vec![-y, -y, -y]));
         }
         1 => {
             let l1 = clause.literals[0];
-            let y = *next_var;
-            let z = *next_var + 1;
-            *next_var += 2;
+            let allocated = variables.allocate_many(2)?;
+            let y = allocated[0];
+            let z = allocated[1];
             normalized.push(CNFClause::new(vec![l1, y, z]));
             normalized.push(CNFClause::new(vec![l1, y, -z]));
             normalized.push(CNFClause::new(vec![l1, -y, z]));
@@ -45,16 +76,14 @@ fn add_normalized_clause(clause: &CNFClause, next_var: &mut i32, normalized: &mu
         2 => {
             let l1 = clause.literals[0];
             let l2 = clause.literals[1];
-            let y = *next_var;
-            *next_var += 1;
+            let y = variables.allocate()?;
             normalized.push(CNFClause::new(vec![l1, l2, y]));
             normalized.push(CNFClause::new(vec![l1, l2, -y]));
         }
         3 => normalized.push(clause.clone()),
         k => {
             let literals = &clause.literals;
-            let y_vars: Vec<i32> = (*next_var..*next_var + (k as i32 - 3)).collect();
-            *next_var += k as i32 - 3;
+            let y_vars = variables.allocate_many(k - 3)?;
 
             normalized.push(CNFClause::new(vec![literals[0], literals[1], y_vars[0]]));
             for i in 1..k - 3 {
@@ -71,9 +100,10 @@ fn add_normalized_clause(clause: &CNFClause, next_var: &mut i32, normalized: &mu
             ]));
         }
     }
+    Ok(())
 }
 
-fn add_gjs_gadget(clause: &CNFClause, w: i32, target_clauses: &mut Vec<CNFClause>) {
+fn add_gjs_gadget(clause: &CNFClause, w: i64, target_clauses: &mut Vec<CNFClause>) {
     let a = clause.literals[0];
     let b = clause.literals[1];
     let c = clause.literals[2];
@@ -91,7 +121,8 @@ fn add_gjs_gadget(clause: &CNFClause, w: i32, target_clauses: &mut Vec<CNFClause
 }
 
 #[reduction(
-    overhead = {
+    aggregate = custom,
+    transform = upper_bound {
         num_vars = "num_vars + 2 * num_literals + 4 * num_clauses",
         num_clauses = "10 * (num_literals + 3 * num_clauses)",
     }
@@ -99,27 +130,61 @@ fn add_gjs_gadget(clause: &CNFClause, w: i32, target_clauses: &mut Vec<CNFClause
 impl ReduceTo<Maximum2Satisfiability> for Satisfiability {
     type Result = ReductionSatisfiabilityToMaximum2Satisfiability;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let mut normalized = Vec::new();
-        let mut next_var = self.num_vars() as i32 + 1;
+        let mut variables =
+            SatVariableAllocator::new("Satisfiability -> Maximum2Satisfiability", self.num_vars())
+                .map_err(
+                    crate::rules::ReductionError::construction::<
+                        Satisfiability,
+                        Maximum2Satisfiability,
+                    >,
+                )?;
 
         for clause in self.clauses() {
-            add_normalized_clause(clause, &mut next_var, &mut normalized);
+            add_normalized_clause(clause, &mut variables, &mut normalized).map_err(
+                crate::rules::ReductionError::construction::<
+                    Satisfiability,
+                    Maximum2Satisfiability,
+                >,
+            )?;
         }
 
-        let mut target_clauses = Vec::with_capacity(normalized.len() * 10);
+        let capacity =
+            normalized.len().checked_mul(10).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    Satisfiability,
+                    Maximum2Satisfiability,
+                >("computing the target clause count")
+            })?;
+        let clause_count = <Self as ReduceTo<Maximum2Satisfiability>>::exact_i64(
+            capacity,
+            "representing every satisfied-clause count",
+        )?;
+        // capacity=10*M. The target value is at most 10*M, and each
+        // normalized clause contributes at most seven satisfied clauses.
+        // Dividing first guarantees this exact score stays within i64.
+        let target_score = (clause_count / 10) * 7;
+        let mut target_clauses = Vec::with_capacity(capacity);
         for clause in &normalized {
-            let w = next_var;
-            next_var += 1;
+            let w =
+                variables.allocate().map_err(
+                    crate::rules::ReductionError::construction::<
+                        Satisfiability,
+                        Maximum2Satisfiability,
+                    >,
+                )?;
             add_gjs_gadget(clause, w, &mut target_clauses);
         }
 
-        let target = Maximum2Satisfiability::new((next_var - 1) as usize, target_clauses);
+        let target = Maximum2Satisfiability::try_new(variables.num_vars(), target_clauses)
+            .map_err(<Self as ReduceTo<Maximum2Satisfiability>>::target_construction)?;
 
-        ReductionSatisfiabilityToMaximum2Satisfiability {
+        Ok(ReductionSatisfiabilityToMaximum2Satisfiability {
             target,
             source_num_vars: self.num_vars(),
-        }
+            target_score,
+        })
     }
 }
 
@@ -137,8 +202,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, Maximum2Satisfiability>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 1],
-                    target_config: vec![1, 1, 1, 0, 1, 0, 1],
+                    source_config: serde_json::json!(vec![true, true, true]),
+                    target_config: serde_json::json!(vec![
+                        true, true, true, false, true, false, true
+                    ]),
                 },
             )
         },
diff --git a/src/rules/satisfiability_naesatisfiability.rs b/src/rules/satisfiability_naesatisfiability.rs
index b17a292b0..0be93eb62 100644
--- a/src/rules/satisfiability_naesatisfiability.rs
+++ b/src/rules/satisfiability_naesatisfiability.rs
@@ -9,6 +9,7 @@
 
 use crate::models::formula::{CNFClause, NAESatisfiability, Satisfiability};
 use crate::reduction;
+use crate::rules::sat_helpers::SatVariableAllocator;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing Satisfiability to NAE-Satisfiability.
@@ -28,35 +29,50 @@ impl ReductionResult for ReductionSATToNAESAT {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         let n = self.source_num_vars;
-        if target_solution.len() <= n {
-            return vec![0; n];
-        }
-        // The sentinel variable is the last variable (index n).
-        let sentinel_value = target_solution[n];
-        if sentinel_value == 0 {
-            // Sentinel is false: return first n variables as-is.
-            target_solution[..n].to_vec()
-        } else {
-            // Sentinel is true: return complement of first n variables.
-            target_solution[..n].iter().map(|&v| 1 - v).collect()
+        if target_solution.len() != n + 1 {
+            return Err(crate::rules::ExtractionError::invalid(format!(
+                "expected {} target truth values, got {}",
+                n + 1,
+                target_solution.len()
+            )));
         }
+        let sentinel = target_solution[n];
+        Ok(target_solution[..n]
+            .iter()
+            .map(|&value| value ^ sentinel)
+            .collect())
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_vars + 1",
-    num_clauses = "num_clauses",
-    num_literals = "num_literals + num_clauses",
-})]
+#[reduction(
+    transform = exact {
+        num_vars = "num_vars + 1",
+        num_clauses = "num_clauses",
+        num_literals = "num_literals + num_clauses",
+    },
+    unavailable = {
+        num_literal_pairs = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<NAESatisfiability> for Satisfiability {
     type Result = ReductionSATToNAESAT;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vars();
-        // Sentinel variable has 0-indexed position n, so its 1-indexed literal is n+1.
-        let sentinel_lit = (n + 1) as i32;
+        let mut variables = SatVariableAllocator::new("Satisfiability -> NAESatisfiability", n)
+            .map_err(
+                crate::rules::ReductionError::construction::<Satisfiability, NAESatisfiability>,
+            )?;
+        let sentinel_lit = variables.allocate().map_err(
+            crate::rules::ReductionError::construction::<Satisfiability, NAESatisfiability>,
+        )?;
 
         let nae_clauses: Vec<CNFClause> = self
             .clauses()
@@ -74,12 +90,12 @@ impl ReduceTo<NAESatisfiability> for Satisfiability {
             })
             .collect();
 
-        let target = NAESatisfiability::new(n + 1, nae_clauses);
+        let target = NAESatisfiability::new(variables.num_vars(), nae_clauses);
 
-        ReductionSATToNAESAT {
+        Ok(ReductionSATToNAESAT {
             source_num_vars: n,
             target,
-        }
+        })
     }
 }
 
@@ -101,8 +117,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, NAESatisfiability>(
                 source,
                 SolutionPair {
-                    source_config: vec![0, 1, 0],
-                    target_config: vec![0, 1, 0, 0],
+                    source_config: serde_json::json!(vec![false, true, false]),
+                    target_config: serde_json::json!(vec![false, true, false, false]),
                 },
             )
         },
diff --git a/src/rules/satisfiability_nontautology.rs b/src/rules/satisfiability_nontautology.rs
index be900a4a0..3ba7ee1c8 100644
--- a/src/rules/satisfiability_nontautology.rs
+++ b/src/rules/satisfiability_nontautology.rs
@@ -21,28 +21,36 @@ impl ReductionResult for ReductionSATToNonTautology {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_vars",
-    num_disjuncts = "num_clauses",
-})]
+#[reduction(
+    transform = exact {
+        num_vars = "num_vars",
+        num_disjuncts = "num_clauses",
+    })]
 impl ReduceTo<NonTautology> for Satisfiability {
     type Result = ReductionSATToNonTautology;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let disjuncts = self
             .clauses()
             .iter()
             .map(|clause| clause.literals.iter().map(|&lit| -lit).collect())
             .collect();
 
-        ReductionSATToNonTautology {
-            target: NonTautology::new(self.num_vars(), disjuncts),
-        }
+        Ok(ReductionSATToNonTautology {
+            target: NonTautology::new(self.num_vars(), disjuncts).map_err(|error| {
+                crate::rules::ReductionError::construction::<Satisfiability, NonTautology>(error)
+            })?,
+        })
     }
 }
 
@@ -64,8 +72,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     ],
                 ),
                 SolutionPair {
-                    source_config: vec![1, 0, 1],
-                    target_config: vec![1, 0, 1],
+                    source_config: serde_json::json!(vec![true, false, true]),
+                    target_config: serde_json::json!(vec![true, false, true]),
                 },
             )
         },
diff --git a/src/rules/schedulingtominimizeweightedcompletiontime_ilp.rs b/src/rules/schedulingtominimizeweightedcompletiontime_ilp.rs
index 72cc2f27a..caefabe83 100644
--- a/src/rules/schedulingtominimizeweightedcompletiontime_ilp.rs
+++ b/src/rules/schedulingtominimizeweightedcompletiontime_ilp.rs
@@ -8,6 +8,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::SchedulingToMinimizeWeightedCompletionTime;
 use crate::reduction;
+use crate::rules::ilp_helpers::one_hot_decode_rows;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing SchedulingToMinimizeWeightedCompletionTime to ILP.
@@ -21,7 +22,7 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Total variables: n*m + n + n*(n-1)/2
 #[derive(Debug, Clone)]
 pub struct ReductionSMWCTToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_tasks: usize,
     num_processors: usize,
 }
@@ -44,45 +45,71 @@ impl ReductionSMWCTToILP {
 
 impl ReductionResult for ReductionSMWCTToILP {
     type Source = SchedulingToMinimizeWeightedCompletionTime;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Extract solution: for each task, find the processor with x_{t,p} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.num_tasks)
-            .map(|t| {
-                (0..self.num_processors)
-                    .find(|&p| target_solution[self.x_var(t, p)] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        one_hot_decode_rows(target_solution, self.num_tasks, self.num_processors, 0)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_tasks * num_processors + num_tasks + num_tasks * (num_tasks - 1) / 2",
         num_constraints = "num_tasks + num_tasks * num_processors + 2 * num_tasks + 2 * num_tasks * (num_tasks - 1) / 2 * num_processors + num_tasks * (num_tasks - 1) / 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for SchedulingToMinimizeWeightedCompletionTime {
+impl ReduceTo<ILP<i64>> for SchedulingToMinimizeWeightedCompletionTime {
     type Result = ReductionSMWCTToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
         let m = self.num_processors();
 
-        let total_processing_time: u64 = self.lengths().iter().sum();
-        let big_m = total_processing_time as f64;
+        let total_processing_time = self
+            .lengths()
+            .iter()
+            .try_fold(0_i64, |total, &length| total.checked_add(length))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SchedulingToMinimizeWeightedCompletionTime,
+                    ILP<i64>,
+                >("summing task processing times")
+            })?;
+        let lengths = self.lengths();
+        let weights = self.weights();
+        let big_m = total_processing_time;
+        let two_big_m = big_m.checked_mul(2).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                SchedulingToMinimizeWeightedCompletionTime,
+                ILP<i64>,
+            >("doubling the disjunctive scheduling bound")
+        })?;
+        let three_big_m = big_m.checked_mul(3).ok_or_else(|| {
+            crate::rules::ReductionError::integer_overflow::<
+                SchedulingToMinimizeWeightedCompletionTime,
+                ILP<i64>,
+            >("tripling the disjunctive scheduling bound")
+        })?;
 
         let num_pairs = n * n.saturating_sub(1) / 2;
         let num_vars = n * m + n + num_pairs;
 
         let result = ReductionSMWCTToILP {
-            target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize),
+            target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
             num_processors: m,
         };
@@ -92,24 +119,21 @@ impl ReduceTo<ILP<i32>> for SchedulingToMinimizeWeightedCompletionTime {
         // 1. Assignment constraints: each task assigned to exactly one processor
         // sum_p x_{t,p} = 1 for each t
         for t in 0..n {
-            let terms: Vec<(usize, f64)> = (0..m).map(|p| (result.x_var(t, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..m).map(|p| (result.x_var(t, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 2. Binary bounds on x_{t,p}: 0 <= x_{t,p} <= 1
         for t in 0..n {
             for p in 0..m {
-                constraints.push(LinearConstraint::le(vec![(result.x_var(t, p), 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(result.x_var(t, p), 1)], 1));
             }
         }
 
         // 3. Completion time bounds: l_t <= C_t <= M
-        for t in 0..n {
-            constraints.push(LinearConstraint::ge(
-                vec![(result.c_var(t), 1.0)],
-                self.lengths()[t] as f64,
-            ));
-            constraints.push(LinearConstraint::le(vec![(result.c_var(t), 1.0)], big_m));
+        for (t, &length) in lengths.iter().enumerate() {
+            constraints.push(LinearConstraint::ge(vec![(result.c_var(t), 1)], length));
+            constraints.push(LinearConstraint::le(vec![(result.c_var(t), 1)], big_m));
         }
 
         // 4. Disjunctive constraints: for each pair (i,j) with i < j, on each processor p:
@@ -129,8 +153,8 @@ impl ReduceTo<ILP<i32>> for SchedulingToMinimizeWeightedCompletionTime {
                 let y = result.y_var(i, j);
                 let ci = result.c_var(i);
                 let cj = result.c_var(j);
-                let li = self.lengths()[i] as f64;
-                let lj = self.lengths()[j] as f64;
+                let li = lengths[i];
+                let lj = lengths[j];
 
                 for p in 0..m {
                     let xip = result.x_var(i, p);
@@ -140,46 +164,38 @@ impl ReduceTo<ILP<i32>> for SchedulingToMinimizeWeightedCompletionTime {
                     // C_j - C_i + M*(1-y) + M*(1-x_{i,p}) + M*(1-x_{j,p}) >= l_j
                     // C_j - C_i - M*y - M*x_{i,p} - M*x_{j,p} >= l_j - 3M
                     constraints.push(LinearConstraint::ge(
-                        vec![
-                            (cj, 1.0),
-                            (ci, -1.0),
-                            (y, -big_m),
-                            (xip, -big_m),
-                            (xjp, -big_m),
-                        ],
-                        lj - 3.0 * big_m,
+                        vec![(cj, 1), (ci, -1), (y, -big_m), (xip, -big_m), (xjp, -big_m)],
+                        lj - three_big_m,
                     ));
 
                     // If j before i on processor p: C_i >= C_j + l_i
                     // C_i - C_j + M*y + M*(1-x_{i,p}) + M*(1-x_{j,p}) >= l_i
                     // C_i - C_j + M*y - M*x_{i,p} - M*x_{j,p} >= l_i - 2M
                     constraints.push(LinearConstraint::ge(
-                        vec![
-                            (ci, 1.0),
-                            (cj, -1.0),
-                            (y, big_m),
-                            (xip, -big_m),
-                            (xjp, -big_m),
-                        ],
-                        li - 2.0 * big_m,
+                        vec![(ci, 1), (cj, -1), (y, big_m), (xip, -big_m), (xjp, -big_m)],
+                        li - two_big_m,
                     ));
                 }
 
                 // Binary bound on y_{i,j}: 0 <= y <= 1
-                constraints.push(LinearConstraint::le(vec![(y, 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(y, 1)], 1));
             }
         }
 
         // Objective: minimize sum_t w_t * C_t
-        let objective: Vec<(usize, f64)> = (0..n)
-            .map(|t| (result.c_var(t), self.weights()[t] as f64))
+        let objective: Vec<(usize, i64)> = weights
+            .iter()
+            .copied()
+            .enumerate()
+            .map(|(task, weight)| (result.c_var(task), weight))
             .collect();
 
-        ReductionSMWCTToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize),
+        Ok(ReductionSMWCTToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
             num_processors: m,
-        }
+        })
     }
 }
 
@@ -191,7 +207,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // 3 tasks, 2 processors: simple instance for canonical example
             let source =
                 SchedulingToMinimizeWeightedCompletionTime::new(vec![1, 2, 3], vec![4, 2, 1], 2);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/schedulingwithindividualdeadlines_ilp.rs b/src/rules/schedulingwithindividualdeadlines_ilp.rs
index 80f0745cd..a36ee872d 100644
--- a/src/rules/schedulingwithindividualdeadlines_ilp.rs
+++ b/src/rules/schedulingwithindividualdeadlines_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from SchedulingWithIndividualDeadlines to ILP<bool>.
+//! Reduction from SchedulingWithIndividualDeadlines to `ILP<bool>`.
 //!
 //! Uses a time-indexed binary formulation with per-task deadline windows:
 //! - Variables: Binary x_{j,t} where x_{j,t} = 1 iff task j is scheduled at time slot t,
@@ -14,9 +14,10 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::SchedulingWithIndividualDeadlines;
 use crate::reduction;
+use crate::rules::ilp_helpers::one_hot_decode_rows;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing SchedulingWithIndividualDeadlines to ILP<bool>.
+/// Result of reducing SchedulingWithIndividualDeadlines to `ILP<bool>`.
 ///
 /// Variable layout: x_{j,t} at index j * max_deadline + t
 /// for j in 0..num_tasks, t in 0..max_deadline.
@@ -38,69 +39,104 @@ impl ReductionResult for ReductionSWIDToILP {
     /// Extract schedule from ILP solution.
     ///
     /// For each task j, find the time slot t where x_{j,t} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let d = self.max_deadline;
-        (0..self.num_tasks)
-            .map(|j| {
-                (0..d)
-                    .find(|&t| target_solution.get(j * d + t).copied().unwrap_or(0) == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        one_hot_decode_rows(target_solution, self.num_tasks, self.max_deadline, 0)
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_tasks * max_deadline",
-        num_constraints = "num_tasks + max_deadline + num_precedences",
+        num_constraints = "num_tasks + max_deadline + num_precedences + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for SchedulingWithIndividualDeadlines {
     type Result = ReductionSWIDToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
-        let m = self.num_processors();
-        let max_d = self.max_deadline();
+        let max_d = usize::try_from(self.max_deadline()).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                SchedulingWithIndividualDeadlines,
+                ILP<bool>,
+            >("validated deadline must fit usize")
+        })?;
         let num_vars = n * max_d;
 
         let var = |j: usize, t: usize| j * max_d + t;
+        let processor_count =
+            Self::exact_i64(self.num_processors(), "encoding the processor capacity")?;
 
         let mut constraints = Vec::new();
 
         // 1. One-hot: for each task j, sum over valid slots 0..d_j equals 1
         for j in 0..n {
-            let dj = self.deadlines()[j];
-            let terms: Vec<(usize, f64)> = (0..dj).map(|t| (var(j, t), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let dj = usize::try_from(self.deadlines()[j]).map_err(|_| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SchedulingWithIndividualDeadlines,
+                    ILP<bool>,
+                >("validated deadline must fit usize")
+            })?;
+            let terms: Vec<(usize, i64)> = (0..dj).map(|t| (var(j, t), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
+        // Binary variables are nonnegative, so a zero sum fixes every unused slot.
+        let unused_slots = self
+            .deadlines()
+            .iter()
+            .enumerate()
+            .flat_map(|(j, &deadline)| {
+                (usize::try_from(deadline).expect("validated deadline fits usize")..max_d)
+                    .map(move |t| (var(j, t), 1))
+            })
+            .collect();
+        constraints.push(LinearConstraint::eq(unused_slots, 0));
+
         // 2. Capacity: Σ_j x_{j,t} ≤ m for each time slot t
         for t in 0..max_d {
-            let terms: Vec<(usize, f64)> = (0..n).map(|j| (var(j, t), 1.0)).collect();
-            constraints.push(LinearConstraint::le(terms, m as f64));
+            let terms: Vec<(usize, i64)> = (0..n).map(|j| (var(j, t), 1)).collect();
+            constraints.push(LinearConstraint::le(terms, processor_count));
         }
 
         // 3. Precedence: Σ_t t·x_{j,t} - Σ_t t·x_{i,t} ≥ 1 for each (i,j)
         for &(i, j) in self.precedences() {
-            let di = self.deadlines()[i];
-            let dj = self.deadlines()[j];
-            let mut terms: Vec<(usize, f64)> = Vec::new();
+            let di = usize::try_from(self.deadlines()[i]).map_err(|_| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SchedulingWithIndividualDeadlines,
+                    ILP<bool>,
+                >("validated deadline must fit usize")
+            })?;
+            let dj = usize::try_from(self.deadlines()[j]).map_err(|_| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SchedulingWithIndividualDeadlines,
+                    ILP<bool>,
+                >("validated deadline must fit usize")
+            })?;
+            let mut terms: Vec<(usize, i64)> = Vec::new();
             for t in 0..dj {
-                terms.push((var(j, t), t as f64));
+                terms.push((var(j, t), Self::exact_i64(t, "encoding a time slot")?));
             }
             for t in 0..di {
-                terms.push((var(i, t), -(t as f64)));
+                terms.push((var(i, t), -Self::exact_i64(t, "encoding a time slot")?));
             }
-            constraints.push(LinearConstraint::ge(terms, 1.0));
+            constraints.push(LinearConstraint::ge(terms, 1));
         }
 
-        ReductionSWIDToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionSWIDToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
             max_deadline: max_d,
-        }
+        })
     }
 }
 
diff --git a/src/rules/sequencingtominimizemaximumcumulativecost_ilp.rs b/src/rules/sequencingtominimizemaximumcumulativecost_ilp.rs
index dd5f4ab7d..1c87717e3 100644
--- a/src/rules/sequencingtominimizemaximumcumulativecost_ilp.rs
+++ b/src/rules/sequencingtominimizemaximumcumulativecost_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from SequencingToMinimizeMaximumCumulativeCost to ILP<i32>.
+//! Reduction from SequencingToMinimizeMaximumCumulativeCost to `ILP<i64>`.
 //!
 //! Position-assignment ILP: binary x_{j,p} placing task j in position p.
 //! Permutation constraints, precedence constraints, and prefix cumulative-cost
@@ -7,10 +7,10 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::SequencingToMinimizeMaximumCumulativeCost;
 use crate::reduction;
-use crate::rules::ilp_helpers::{one_hot_decode, permutation_to_lehmer};
+use crate::rules::ilp_helpers::one_hot_decode;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing SequencingToMinimizeMaximumCumulativeCost to ILP<i32>.
+/// Result of reducing SequencingToMinimizeMaximumCumulativeCost to `ILP<i64>`.
 ///
 /// Variable layout:
 /// - x_{j,p} for j in 0..n, p in 0..n: index `j*n + p`
@@ -18,34 +18,45 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Total: n^2 variables.
 #[derive(Debug, Clone)]
 pub struct ReductionSTMMCCToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_tasks: usize,
 }
 
 impl ReductionResult for ReductionSTMMCCToILP {
     type Source = SequencingToMinimizeMaximumCumulativeCost;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Extract: decode position assignment → permutation → Lehmer code.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_tasks;
-        let schedule = one_hot_decode(target_solution, n, n, 0);
-        permutation_to_lehmer(&schedule)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_tasks;
+
+            one_hot_decode(target_solution, n, n, 0)?
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_tasks * num_tasks + 1",
-    num_constraints = "2 * num_tasks + num_precedences + num_tasks + num_tasks * num_tasks",
-})]
-impl ReduceTo<ILP<i32>> for SequencingToMinimizeMaximumCumulativeCost {
+#[reduction(transform = exact {
+    num_vars = "num_tasks^2 + 1",
+    num_constraints = "num_tasks^2 + 3 * num_tasks + num_precedences + 1",
+},
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<i64>> for SequencingToMinimizeMaximumCumulativeCost {
     type Result = ReductionSTMMCCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
         // n^2 position variables + 1 minimax variable z
         let z_var = n * n;
@@ -57,30 +68,31 @@ impl ReduceTo<ILP<i32>> for SequencingToMinimizeMaximumCumulativeCost {
 
         // 1. Each task assigned to exactly one position: Σ_p x_{j,p} = 1 for all j
         for j in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|p| (x_var(j, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|p| (x_var(j, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 2. Each position has exactly one task: Σ_j x_{j,p} = 1 for all p
         for p in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|j| (x_var(j, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|j| (x_var(j, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 3. Precedence: Σ_p p*x_{i,p} + 1 <= Σ_p p*x_{j,p} for each (i,j)
         for &(i, j) in self.precedences() {
-            let mut terms: Vec<(usize, f64)> = Vec::new();
+            let mut terms: Vec<(usize, i64)> = Vec::new();
             for p in 0..n {
-                terms.push((x_var(j, p), p as f64));
-                terms.push((x_var(i, p), -(p as f64)));
+                let p_i64 = Self::exact_i64(p, "encoding a task position")?;
+                terms.push((x_var(j, p), p_i64));
+                terms.push((x_var(i, p), -p_i64));
             }
-            constraints.push(LinearConstraint::ge(terms, 1.0));
+            constraints.push(LinearConstraint::ge(terms, 1));
         }
 
-        // Binary bounds for x variables (ILP<i32> allows any non-negative integer)
+        // Binary bounds for x variables (`ILP<i64>` allows any non-negative integer)
         for j in 0..n {
             for p in 0..n {
-                constraints.push(LinearConstraint::le(vec![(x_var(j, p), 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(x_var(j, p), 1)], 1));
             }
         }
 
@@ -88,27 +100,41 @@ impl ReduceTo<ILP<i32>> for SequencingToMinimizeMaximumCumulativeCost {
         //    (minimax linearization: z >= max_q cumulative_cost(q))
         let costs = self.costs();
         for q in 0..n {
-            let mut terms: Vec<(usize, f64)> = Vec::new();
+            let mut terms: Vec<(usize, i64)> = Vec::new();
             for (j, &c_j) in costs.iter().enumerate() {
                 for p in 0..=q {
-                    terms.push((x_var(j, p), c_j as f64));
+                    terms.push((x_var(j, p), c_j));
                 }
             }
-            terms.push((z_var, -1.0));
-            constraints.push(LinearConstraint::le(terms, 0.0));
+            terms.push((z_var, -1));
+            constraints.push(LinearConstraint::le(terms, 0));
         }
 
         // z upper bound: max cumulative cost ≤ sum of absolute costs
-        let z_upper: f64 = costs.iter().map(|&c| (c as f64).abs()).sum();
-        constraints.push(LinearConstraint::le(vec![(z_var, 1.0)], z_upper));
+        let z_upper = costs.iter().try_fold(0_i64, |total, &cost| {
+            let magnitude = cost.checked_abs().ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SequencingToMinimizeMaximumCumulativeCost,
+                    ILP<i64>,
+                >("taking the absolute value of a task cost")
+            })?;
+            total.checked_add(magnitude).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SequencingToMinimizeMaximumCumulativeCost,
+                    ILP<i64>,
+                >("summing absolute task costs")
+            })
+        })?;
+        constraints.push(LinearConstraint::le(vec![(z_var, 1)], z_upper));
 
         // Objective: minimize z (the maximum cumulative cost)
-        let objective = vec![(z_var, 1.0)];
+        let objective = vec![(z_var, 1)];
 
-        ReductionSTMMCCToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize),
+        Ok(ReductionSTMMCCToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
-        }
+        })
     }
 }
 
@@ -119,7 +145,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             let source =
                 SequencingToMinimizeMaximumCumulativeCost::new(vec![2, -1, 3, -2], vec![(0, 2)]);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/sequencingtominimizetardytaskweight_ilp.rs b/src/rules/sequencingtominimizetardytaskweight_ilp.rs
index 801b0369c..5f41493d2 100644
--- a/src/rules/sequencingtominimizetardytaskweight_ilp.rs
+++ b/src/rules/sequencingtominimizetardytaskweight_ilp.rs
@@ -1,8 +1,8 @@
-//! Reduction from SequencingToMinimizeTardyTaskWeight to ILP<bool>.
+//! Reduction from SequencingToMinimizeTardyTaskWeight to `ILP<bool>`.
 //!
 //! Position-assignment ILP: binary x_{j,p} placing task j in position p,
-//! with binary tardy indicator u_j. A big-M constraint forces u_j = 1
-//! whenever the completion time at position p exceeds the deadline d_j.
+//! with exact binary tardy indicators. Position-specific prefix bounds give
+//! both implications of the deadline comparison, including signed model inputs.
 
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::SequencingToMinimizeTardyTaskWeight;
@@ -10,7 +10,7 @@ use crate::reduction;
 use crate::rules::ilp_helpers::one_hot_decode;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing SequencingToMinimizeTardyTaskWeight to ILP<bool>.
+/// Result of reducing SequencingToMinimizeTardyTaskWeight to `ILP<bool>`.
 #[derive(Debug, Clone)]
 pub struct ReductionSTMTTWToILP {
     target: ILP<bool>,
@@ -25,74 +25,154 @@ impl ReductionResult for ReductionSTMTTWToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_tasks;
-        // Decode the n*n block of x_{j,p} variables into a schedule permutation.
-        // The source uses direct permutation encoding (config = schedule directly),
-        // so return the schedule as-is (it is already a permutation of 0..n).
-        one_hot_decode(target_solution, n, n, 0)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if !value.is_valid() {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target ILP assignment is infeasible",
+            ));
+        }
+
+        Ok({
+            let n = self.num_tasks;
+            // Decode the n*n block of x_{j,p} variables into a schedule permutation.
+            // The source uses direct permutation encoding (config = schedule directly),
+            // so return the schedule as-is (it is already a permutation of 0..n).
+            one_hot_decode(target_solution, n, n, 0)?
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_tasks * num_tasks + num_tasks",
-    num_constraints = "2 * num_tasks + num_tasks * num_tasks",
-})]
+#[reduction(
+    transform = exact {
+        num_vars = "num_tasks * num_tasks + num_tasks",
+        num_constraints = "2 * num_tasks + 2 * num_tasks * num_tasks",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<ILP<bool>> for SequencingToMinimizeTardyTaskWeight {
     type Result = ReductionSTMTTWToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let overflow = |operation: &str| {
+            crate::rules::ReductionError::integer_overflow::<Self, ILP<bool>>(operation)
+        };
+        let integer = |value: i128| {
+            i64::try_from(value).map_err(|_| overflow("representing exact tardiness constraints"))
+        };
         let n = self.num_tasks();
-        let num_x_vars = n * n;
-        let num_vars = num_x_vars + n;
-        let total_length: u64 = self.lengths().iter().copied().sum();
-        let big_m = total_length as f64;
-
-        let x_var = |j: usize, p: usize| -> usize { j * n + p };
-        let u_var = |j: usize| -> usize { num_x_vars + j };
+        let num_x_vars = n
+            .checked_mul(n)
+            .ok_or_else(|| overflow("assignment count"))?;
+        let num_vars = num_x_vars
+            .checked_add(n)
+            .ok_or_else(|| overflow("variable count"))?;
+        let num_constraints = num_vars
+            .checked_mul(2)
+            .ok_or_else(|| overflow("constraint count"))?;
+        // Upper bound: 2*n^2 assignment entries and two (n*p + 2)-term
+        // inequalities for each task and position. The preceding count bound
+        // also makes n^2 - n + 6 representable.
+        num_x_vars
+            .checked_mul(num_x_vars - n + 6)
+            .ok_or_else(|| overflow("constraint nonzero count"))?;
 
-        let mut constraints = Vec::new();
-
-        // 1. Each task assigned to exactly one position
+        let lengths = self.lengths();
+        let deadlines = self.deadlines();
+        let weights = self.weights();
+        let mut sorted = lengths.to_vec();
+        sorted.sort_unstable();
+        let mut lower = vec![0i128; n + 1];
+        let mut upper = vec![0i128; n + 1];
+        let mut partial_lower = vec![0i128; n + 1];
+        let mut partial_upper = vec![0i128; n + 1];
+        // Checked polynomial dimensions bound n, so summing n i64 values and
+        // the subsequent constant arithmetic fit i128 before checked narrowing.
+        for p in 0..n {
+            lower[p + 1] = lower[p] + i128::from(sorted[p]);
+            upper[p + 1] = upper[p] + i128::from(sorted[n - 1 - p]);
+            partial_lower[p + 1] = partial_lower[p].min(lower[p + 1]);
+            partial_upper[p + 1] = partial_upper[p].max(upper[p + 1]);
+        }
+        // All source completion times and objective accumulation partial sums
+        // must be representable, including when lengths or weights are signed.
+        integer(partial_lower[n])?;
+        integer(partial_upper[n])?;
+        integer(weights.iter().map(|&w| i128::from(w.min(0))).sum())?;
+        integer(weights.iter().map(|&w| i128::from(w.max(0))).sum())?;
+
+        let x_var = |j: usize, p: usize| j * n + p;
+        let u_var = |j: usize| num_x_vars + j;
+        let mut constraints = Vec::with_capacity(num_constraints);
+        // Keep assignment constraints first: only permutation matrices reach
+        // the prefix inequalities in the target's formal sequential evaluator.
         for j in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|p| (x_var(j, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(
+                (0..n).map(|p| (x_var(j, p), 1)).collect(),
+                1,
+            ));
         }
-
-        // 2. Each position has exactly one task
         for p in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|j| (x_var(j, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(
+                (0..n).map(|j| (x_var(j, p), 1)).collect(),
+                1,
+            ));
         }
 
-        // 3. Tardy indicator: for each (j, p), if x_{j,p}=1 then
-        //    completion_time_at_p >= l_j + sum_{p' < p} sum_{j'} l_{j'} * x_{j',p'}
-        //    If completion > d_j then u_j must be 1.
-        //    Linearized as: big_m * x_{j,p} + sum_{p'<p} sum_{j'} l_{j'} * x_{j',p'} - big_m * u_j <= d_j - l_j + big_m
-        let lengths = self.lengths();
         for j in 0..n {
             for p in 0..n {
-                let mut terms: Vec<(usize, f64)> = Vec::new();
-                terms.push((x_var(j, p), big_m));
+                // P_p lies in [lower[p], upper[p]]. Replacing the integer
+                // comparison cutoff by its projection onto [lower[p]-1,
+                // upper[p]] preserves P_p > deadline[j]-length[j] exactly.
+                let cutoff = (i128::from(deadlines[j]) - i128::from(lengths[j]))
+                    .clamp(lower[p] - 1, upper[p]);
+                let on_time_m = upper[p] - cutoff;
+                let tardy_m = cutoff + 1 - lower[p];
+                // Bounds cover every sparse dot-product partial sum for a
+                // permutation matrix and every indicator vector, not just the
+                // final sum of feasible target witnesses.
+                integer(partial_lower[p] - on_time_m)?;
+                integer(partial_upper[p] + on_time_m)?;
+                integer(partial_lower[p] - 2 * tardy_m)?;
+                let on_time_m = integer(on_time_m)?;
+                let tardy_m = integer(tardy_m)?;
+                let mut on_time_terms = Vec::with_capacity(n * p + 2);
+                let mut tardy_terms = Vec::with_capacity(n * p + 2);
                 for pp in 0..p {
-                    for (jj, &len) in lengths.iter().enumerate() {
-                        terms.push((x_var(jj, pp), len as f64));
+                    for (task, &length) in lengths.iter().enumerate() {
+                        on_time_terms.push((x_var(task, pp), length));
+                        tardy_terms.push((x_var(task, pp), length));
                     }
                 }
-                terms.push((u_var(j), -big_m));
-                let rhs = self.deadlines()[j] as f64 - lengths[j] as f64 + big_m;
-                constraints.push(LinearConstraint::le(terms, rhs));
+                on_time_terms.push((x_var(j, p), on_time_m));
+                on_time_terms.push((u_var(j), -on_time_m));
+                tardy_terms.push((x_var(j, p), -tardy_m));
+                tardy_terms.push((u_var(j), -tardy_m));
+                // x=1,u=0 forces P_p <= cutoff; x=1,u=1 forces
+                // P_p >= cutoff+1. With x=0 both rows are redundant.
+                constraints.push(LinearConstraint::le(on_time_terms, integer(upper[p])?));
+                constraints.push(LinearConstraint::ge(
+                    tardy_terms,
+                    integer(lower[p] - i128::from(tardy_m))?,
+                ));
             }
         }
 
         // Objective: minimize sum w_j * u_j
-        let weights = self.weights();
-        let objective: Vec<(usize, f64)> = (0..n).map(|j| (u_var(j), weights[j] as f64)).collect();
+        let objective: Vec<(usize, i64)> =
+            (0..n).map(|task| (u_var(task), weights[task])).collect();
 
-        ReductionSTMTTWToILP {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize),
+        Ok(ReductionSTMTTWToILP {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
-        }
+        })
     }
 }
 
diff --git a/src/rules/sequencingtominimizeweightedcompletiontime_ilp.rs b/src/rules/sequencingtominimizeweightedcompletiontime_ilp.rs
index ba157bffe..1171c160a 100644
--- a/src/rules/sequencingtominimizeweightedcompletiontime_ilp.rs
+++ b/src/rules/sequencingtominimizeweightedcompletiontime_ilp.rs
@@ -1,7 +1,7 @@
 //! Reduction from SequencingToMinimizeWeightedCompletionTime to ILP.
 //!
 //! The reduction uses integer completion-time variables `C_j` and integer
-//! order variables `y_{i,j}` constrained to `{0, 1}` within `ILP<i32>`.
+//! order variables `y_{i,j}` constrained to `{0, 1}` within `ILP<i64>`.
 //! For each unordered pair `{i, j}`, a pair of big-M constraints forces one
 //! task to finish before the other starts.
 
@@ -12,7 +12,7 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 
 #[derive(Debug, Clone)]
 pub struct ReductionSTMWCTToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_tasks: usize,
 }
 
@@ -27,71 +27,55 @@ impl ReductionSTMWCTToILP {
         assert!(i < j, "order_var expects i < j");
         self.num_tasks + i * (2 * self.num_tasks - i - 1) / 2 + (j - i - 1)
     }
-
-    fn encode_schedule_as_lehmer(schedule: &[usize]) -> Vec<usize> {
-        let mut available: Vec<usize> = (0..schedule.len()).collect();
-        let mut config = Vec::with_capacity(schedule.len());
-        for &task in schedule {
-            let digit = available
-                .iter()
-                .position(|&candidate| candidate == task)
-                .expect("schedule must be a permutation");
-            config.push(digit);
-            available.remove(digit);
-        }
-        config
-    }
 }
 
 impl ReductionResult for ReductionSTMWCTToILP {
     type Source = SequencingToMinimizeWeightedCompletionTime;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let mut schedule: Vec<usize> = (0..self.num_tasks).collect();
-        schedule.sort_by_key(|&task| (target_solution.get(task).copied().unwrap_or(0), task));
-        Self::encode_schedule_as_lehmer(&schedule)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let mut schedule: Vec<usize> = (0..self.num_tasks).collect();
+            schedule.sort_by_key(|&task| (target_solution[task], task));
+            schedule
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_tasks + num_tasks * (num_tasks - 1) / 2",
-    num_constraints = "2 * num_tasks + 3 * num_tasks * (num_tasks - 1) / 2 + num_precedences",
-})]
-impl ReduceTo<ILP<i32>> for SequencingToMinimizeWeightedCompletionTime {
+#[reduction(
+    transform = exact {
+        num_vars = "num_tasks + num_tasks * (num_tasks - 1) / 2",
+        num_constraints = "2 * num_tasks + 3 * num_tasks * (num_tasks - 1) / 2 + num_precedences",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<i64>> for SequencingToMinimizeWeightedCompletionTime {
     type Result = ReductionSTMWCTToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_tasks = self.num_tasks();
-        let max_ilp_value = i32::MAX as u64;
-        let max_exact_f64_integer = 1u64 << 53;
-        assert!(
-            self.lengths().iter().all(|&length| length <= max_ilp_value),
-            "task lengths must fit in ILP<i32> variable bounds"
-        );
-
-        let total_processing_time_u64 = self.total_processing_time();
-        assert!(
-            total_processing_time_u64 <= max_ilp_value,
-            "total processing time must fit in ILP<i32> variable bounds"
-        );
-
-        let total_weight = self
-            .weights()
-            .iter()
-            .try_fold(0u64, |acc, &weight| acc.checked_add(weight))
-            .expect("weighted completion objective must fit exactly in f64");
-        assert!(
-            total_processing_time_u64 == 0
-                || total_weight <= max_exact_f64_integer / total_processing_time_u64,
-            "weighted completion objective must fit exactly in f64"
-        );
-
-        let total_processing_time = total_processing_time_u64 as f64;
+
+        let total_processing_time = self.lengths().iter().try_fold(0i64, |total, &length| {
+            total.checked_add(length).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SequencingToMinimizeWeightedCompletionTime,
+                    ILP<i64>,
+                >("summing task processing times")
+            })
+        })?;
+        let lengths = self.lengths();
+        let weights = self.weights();
         let num_order_vars = num_tasks * (num_tasks.saturating_sub(1)) / 2;
         let num_vars = num_tasks + num_order_vars;
 
@@ -102,12 +86,9 @@ impl ReduceTo<ILP<i32>> for SequencingToMinimizeWeightedCompletionTime {
 
         let mut constraints = Vec::new();
 
-        for (task, &length) in self.lengths().iter().enumerate() {
-            constraints.push(LinearConstraint::ge(vec![(task, 1.0)], length as f64));
-            constraints.push(LinearConstraint::le(
-                vec![(task, 1.0)],
-                total_processing_time,
-            ));
+        for (task, &length) in lengths.iter().enumerate() {
+            constraints.push(LinearConstraint::ge(vec![(task, 1)], length));
+            constraints.push(LinearConstraint::le(vec![(task, 1)], total_processing_time));
         }
 
         for i in 0..num_tasks {
@@ -115,16 +96,16 @@ impl ReduceTo<ILP<i32>> for SequencingToMinimizeWeightedCompletionTime {
                 let order = order_var(i, j);
                 let completion_i = i;
                 let completion_j = j;
-                let length_i = self.lengths()[i] as f64;
-                let length_j = self.lengths()[j] as f64;
+                let length_i = lengths[i];
+                let length_j = lengths[j];
 
-                constraints.push(LinearConstraint::le(vec![(order, 1.0)], 1.0));
+                constraints.push(LinearConstraint::le(vec![(order, 1)], 1));
 
                 // If y_{i,j} = 1, then task i is before task j: C_j - C_i >= l_j.
                 constraints.push(LinearConstraint::ge(
                     vec![
-                        (completion_j, 1.0),
-                        (completion_i, -1.0),
+                        (completion_j, 1),
+                        (completion_i, -1),
                         (order, -total_processing_time),
                     ],
                     length_j - total_processing_time,
@@ -133,8 +114,8 @@ impl ReduceTo<ILP<i32>> for SequencingToMinimizeWeightedCompletionTime {
                 // If y_{i,j} = 0, then task j is before task i: C_i - C_j >= l_i.
                 constraints.push(LinearConstraint::ge(
                     vec![
-                        (completion_i, 1.0),
-                        (completion_j, -1.0),
+                        (completion_i, 1),
+                        (completion_j, -1),
                         (order, total_processing_time),
                     ],
                     length_i,
@@ -144,22 +125,18 @@ impl ReduceTo<ILP<i32>> for SequencingToMinimizeWeightedCompletionTime {
 
         for &(pred, succ) in self.precedences() {
             constraints.push(LinearConstraint::ge(
-                vec![(succ, 1.0), (pred, -1.0)],
-                self.lengths()[succ] as f64,
+                vec![(succ, 1), (pred, -1)],
+                lengths[succ],
             ));
         }
 
-        let objective = self
-            .weights()
-            .iter()
-            .enumerate()
-            .map(|(task, &weight)| (task, weight as f64))
-            .collect();
+        let objective = weights.iter().copied().enumerate().collect();
 
-        Self::Result {
-            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize),
+        Ok(Self::Result {
+            target: ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks,
-        }
+        })
     }
 }
 
@@ -170,7 +147,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             let source =
                 SequencingToMinimizeWeightedCompletionTime::new(vec![2, 1], vec![3, 5], vec![]);
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/sequencingtominimizeweightedtardiness_ilp.rs b/src/rules/sequencingtominimizeweightedtardiness_ilp.rs
index aab00740d..f046bd232 100644
--- a/src/rules/sequencingtominimizeweightedtardiness_ilp.rs
+++ b/src/rules/sequencingtominimizeweightedtardiness_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from SequencingToMinimizeWeightedTardiness to ILP<i32>.
+//! Reduction from SequencingToMinimizeWeightedTardiness to `ILP<i64>`.
 //!
 //! Pairwise order variables y_{i,j}, integer completion times C_j,
 //! and nonnegative tardiness variables T_j. Big-M disjunctive constraints
@@ -9,7 +9,7 @@ use crate::models::misc::SequencingToMinimizeWeightedTardiness;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing SequencingToMinimizeWeightedTardiness to ILP<i32>.
+/// Result of reducing SequencingToMinimizeWeightedTardiness to `ILP<i64>`.
 ///
 /// Variable layout:
 /// - `y_{i,j}` for i < j: pairwise order bits (n*(n-1)/2 vars)
@@ -19,53 +19,48 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 /// Total: n*(n-1)/2 + 2*n variables.
 #[derive(Debug, Clone)]
 pub struct ReductionSTMWTToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_tasks: usize,
     num_order_vars: usize,
 }
 
-impl ReductionSTMWTToILP {
-    fn encode_schedule_as_lehmer(schedule: &[usize]) -> Vec<usize> {
-        let mut available: Vec<usize> = (0..schedule.len()).collect();
-        let mut config = Vec::with_capacity(schedule.len());
-        for &task in schedule {
-            let digit = available
-                .iter()
-                .position(|&c| c == task)
-                .expect("schedule must be a permutation");
-            config.push(digit);
-            available.remove(digit);
-        }
-        config
-    }
-}
-
 impl ReductionResult for ReductionSTMWTToILP {
     type Source = SequencingToMinimizeWeightedTardiness;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    /// Extract: sort jobs by completion time C_j, convert to Lehmer code.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_tasks;
-        let c_offset = self.num_order_vars;
-        let mut jobs: Vec<usize> = (0..n).collect();
-        jobs.sort_by_key(|&j| (target_solution.get(c_offset + j).copied().unwrap_or(0), j));
-        Self::encode_schedule_as_lehmer(&jobs)
+    /// Extract by sorting jobs by completion time C_j.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_tasks;
+            let c_offset = self.num_order_vars;
+            let mut jobs: Vec<usize> = (0..n).collect();
+            jobs.sort_by_key(|&j| (target_solution[c_offset + j], j));
+            jobs
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_tasks * (num_tasks - 1) / 2 + 2 * num_tasks",
-    num_constraints = "num_tasks * (num_tasks - 1) / 2 + num_tasks + num_tasks * (num_tasks - 1) + 2 * num_tasks + 1",
-})]
-impl ReduceTo<ILP<i32>> for SequencingToMinimizeWeightedTardiness {
+#[reduction(transform = upper_bound {
+    num_vars = "num_tasks^2 + 2 * num_tasks",
+    num_constraints = "2 * num_tasks^2 + 3 * num_tasks + 1",
+},
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<i64>> for SequencingToMinimizeWeightedTardiness {
     type Result = ReductionSTMWTToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
         let num_order_vars = n * n.saturating_sub(1) / 2;
         let num_vars = num_order_vars + 2 * n;
@@ -83,21 +78,30 @@ impl ReduceTo<ILP<i32>> for SequencingToMinimizeWeightedTardiness {
         let bound = self.bound();
 
         // M = sum of all lengths (valid schedule-horizon bound)
-        let big_m: f64 = lengths.iter().sum::<u64>() as f64;
+        let horizon = lengths
+            .iter()
+            .try_fold(0_i64, |total, &length| total.checked_add(length))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SequencingToMinimizeWeightedTardiness,
+                    ILP<i64>,
+                >("summing task processing times")
+            })?;
+        let big_m = horizon;
 
         let mut constraints = Vec::new();
 
         // 1. y_{i,j} in {0,1}: 0 <= y_{i,j} <= 1
         for i in 0..n {
             for j in (i + 1)..n {
-                constraints.push(LinearConstraint::le(vec![(order_var(i, j), 1.0)], 1.0));
-                constraints.push(LinearConstraint::ge(vec![(order_var(i, j), 1.0)], 0.0));
+                constraints.push(LinearConstraint::le(vec![(order_var(i, j), 1)], 1));
+                constraints.push(LinearConstraint::ge(vec![(order_var(i, j), 1)], 0));
             }
         }
 
         // 2. C_j >= l_j for all j
         for (j, &l_j) in lengths.iter().enumerate() {
-            constraints.push(LinearConstraint::ge(vec![(c_var(j), 1.0)], l_j as f64));
+            constraints.push(LinearConstraint::ge(vec![(c_var(j), 1)], l_j));
         }
 
         // 3. Disjunctive: C_j >= C_i + l_j - M*(1 - y_{i,j}) for i != j
@@ -111,16 +115,16 @@ impl ReduceTo<ILP<i32>> for SequencingToMinimizeWeightedTardiness {
                     // C_j >= C_i + l_j - M*(1 - y_{i,j})
                     // => C_j - C_i - M*y_{i,j} >= l_j - M
                     constraints.push(LinearConstraint::ge(
-                        vec![(c_var(j), 1.0), (c_var(i), -1.0), (order_var(i, j), -big_m)],
-                        l_j as f64 - big_m,
+                        vec![(c_var(j), 1), (c_var(i), -1), (order_var(i, j), -big_m)],
+                        l_j - big_m,
                     ));
                 } else {
                     // i > j: y_{j,i} is stored, y_{i,j} = 1 - y_{j,i}
                     // C_j >= C_i + l_j - M*y_{j,i}
                     // C_j - C_i + M*y_{j,i} >= l_j
                     constraints.push(LinearConstraint::ge(
-                        vec![(c_var(j), 1.0), (c_var(i), -1.0), (order_var(j, i), big_m)],
-                        l_j as f64,
+                        vec![(c_var(j), 1), (c_var(i), -1), (order_var(j, i), big_m)],
+                        l_j,
                     ));
                 }
             }
@@ -129,25 +133,26 @@ impl ReduceTo<ILP<i32>> for SequencingToMinimizeWeightedTardiness {
         // 4. T_j >= C_j - d_j for all j
         for (j, &d_j) in deadlines.iter().enumerate() {
             constraints.push(LinearConstraint::ge(
-                vec![(t_var(j), 1.0), (c_var(j), -1.0)],
-                -(d_j as f64),
+                vec![(t_var(j), 1), (c_var(j), -1)],
+                -d_j,
             ));
         }
 
         // 5. T_j >= 0 for all j
         for j in 0..n {
-            constraints.push(LinearConstraint::ge(vec![(t_var(j), 1.0)], 0.0));
+            constraints.push(LinearConstraint::ge(vec![(t_var(j), 1)], 0));
         }
 
         // 6. Σ_j w_j * T_j <= K
-        let terms: Vec<(usize, f64)> = (0..n).map(|j| (t_var(j), weights[j] as f64)).collect();
-        constraints.push(LinearConstraint::le(terms, bound as f64));
+        let terms: Vec<(usize, i64)> = (0..n).map(|j| (t_var(j), weights[j])).collect();
+        constraints.push(LinearConstraint::le(terms, bound));
 
-        ReductionSTMWTToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionSTMWTToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
             num_order_vars,
-        }
+        })
     }
 }
 
@@ -162,7 +167,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 vec![5, 8, 4],
                 10,
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/sequencingwithdeadlinesandsetuptimes_ilp.rs b/src/rules/sequencingwithdeadlinesandsetuptimes_ilp.rs
index 711a5ea95..21cd366b0 100644
--- a/src/rules/sequencingwithdeadlinesandsetuptimes_ilp.rs
+++ b/src/rules/sequencingwithdeadlinesandsetuptimes_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from SequencingWithDeadlinesAndSetUpTimes to ILP<bool>.
+//! Reduction from SequencingWithDeadlinesAndSetUpTimes to `ILP<bool>`.
 //!
 //! Position-assignment ILP with compiler-switch detection.
 //!
@@ -21,7 +21,7 @@ use crate::reduction;
 use crate::rules::ilp_helpers::one_hot_decode;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing SequencingWithDeadlinesAndSetUpTimes to ILP<bool>.
+/// Result of reducing SequencingWithDeadlinesAndSetUpTimes to `ILP<bool>`.
 #[derive(Debug, Clone)]
 pub struct ReductionSWDSTToILP {
     target: ILP<bool>,
@@ -36,29 +36,41 @@ impl ReductionResult for ReductionSWDSTToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_tasks;
-        // x_{j,p} occupies the first n*n variables: decode the permutation.
-        one_hot_decode(target_solution, n, n, 0)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_tasks;
+            // x_{j,p} occupies the first n*n variables: decode the permutation.
+            one_hot_decode(target_solution, n, n, 0)?
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_tasks * num_tasks + (num_tasks - 1) + num_tasks * (num_tasks - 1)",
+#[reduction(transform = upper_bound {
+    num_vars = "2 * num_tasks^2 + num_tasks",
     num_constraints = "2 * num_tasks + num_tasks^2 * (num_tasks - 1) + 3 * num_tasks * (num_tasks - 1) + num_tasks * num_tasks",
-})]
+},
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<ILP<bool>> for SequencingWithDeadlinesAndSetUpTimes {
     type Result = ReductionSWDSTToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
 
         // Handle empty case.
         if n == 0 {
-            return ReductionSWDSTToILP {
-                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize),
+            return Ok(ReductionSWDSTToILP {
+                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize)
+                    .map_err(Self::target_construction)?,
                 num_tasks: 0,
-            };
+            });
         }
 
         // Variable layout:
@@ -81,22 +93,40 @@ impl ReduceTo<ILP<bool>> for SequencingWithDeadlinesAndSetUpTimes {
         let setup_times = self.setup_times();
 
         // Big-M: total processing time + worst-case total setup overhead.
-        let total_length: u64 = lengths.iter().copied().sum();
-        let max_setup: u64 = setup_times.iter().copied().max().unwrap_or(0);
-        let big_m = total_length as f64 + max_setup as f64 * (n as f64 - 1.0);
-
+        let total_length = lengths.iter().try_fold(0_i64, |total, &length| {
+            total.checked_add(length).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SequencingWithDeadlinesAndSetUpTimes,
+                    ILP<bool>,
+                >("summing task lengths")
+            })
+        })?;
+        let max_setup: i64 = setup_times.iter().copied().max().unwrap_or(0);
+        let transition_count = Self::exact_i64(
+            n - 1,
+            "converting the number of compiler transitions to i64",
+        )?;
+        let big_m = max_setup
+            .checked_mul(transition_count)
+            .and_then(|setup_total| total_length.checked_add(setup_total))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SequencingWithDeadlinesAndSetUpTimes,
+                    ILP<bool>,
+                >("computing the scheduling big-M bound")
+            })?;
         let mut constraints = Vec::new();
 
         // 1. Each task assigned to exactly one position: sum_p x_{j,p} = 1 for all j.
         for j in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|p| (x_var(j, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|p| (x_var(j, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 2. Each position has exactly one task: sum_j x_{j,p} = 1 for all p.
         for p in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|j| (x_var(j, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|j| (x_var(j, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // For each position p >= 1:
@@ -110,12 +140,8 @@ impl ReduceTo<ILP<bool>> for SequencingWithDeadlinesAndSetUpTimes {
                         // sw_p - x_{j,p} - x_{j',p-1} >= -1
                         // i.e., x_{j,p} + x_{j',p-1} - sw_p <= 1
                         constraints.push(LinearConstraint::le(
-                            vec![
-                                (x_var(j, p), 1.0),
-                                (x_var(j_prev, p - 1), 1.0),
-                                (sw_var(p), -1.0),
-                            ],
-                            1.0,
+                            vec![(x_var(j, p), 1), (x_var(j_prev, p - 1), 1), (sw_var(p), -1)],
+                            1,
                         ));
                     }
                 }
@@ -128,19 +154,19 @@ impl ReduceTo<ILP<bool>> for SequencingWithDeadlinesAndSetUpTimes {
             for j in 0..n {
                 // a_{j,p} <= x_{j,p}
                 constraints.push(LinearConstraint::le(
-                    vec![(a_var(j, p), 1.0), (x_var(j, p), -1.0)],
-                    0.0,
+                    vec![(a_var(j, p), 1), (x_var(j, p), -1)],
+                    0,
                 ));
                 // a_{j,p} <= sw_p
                 constraints.push(LinearConstraint::le(
-                    vec![(a_var(j, p), 1.0), (sw_var(p), -1.0)],
-                    0.0,
+                    vec![(a_var(j, p), 1), (sw_var(p), -1)],
+                    0,
                 ));
                 // a_{j,p} >= x_{j,p} + sw_p - 1
                 // i.e. x_{j,p} + sw_p - a_{j,p} <= 1
                 constraints.push(LinearConstraint::le(
-                    vec![(x_var(j, p), 1.0), (sw_var(p), 1.0), (a_var(j, p), -1.0)],
-                    1.0,
+                    vec![(x_var(j, p), 1), (sw_var(p), 1), (a_var(j, p), -1)],
+                    1,
                 ));
             }
         }
@@ -173,33 +199,42 @@ impl ReduceTo<ILP<bool>> for SequencingWithDeadlinesAndSetUpTimes {
         //      <= d[j] - l[j] + M
         for j in 0..n {
             for p in 0..n {
-                let mut terms: Vec<(usize, f64)> = Vec::new();
+                let mut terms: Vec<(usize, i64)> = Vec::new();
                 // Big-M activation term
                 terms.push((x_var(j, p), big_m));
                 // Processing time for positions 0..p (not including p itself)
                 for pp in 0..p {
-                    for (jj, &len) in lengths.iter().enumerate() {
-                        terms.push((x_var(jj, pp), len as f64));
+                    for (jj, &length) in lengths.iter().enumerate() {
+                        terms.push((x_var(jj, pp), length));
                     }
                 }
                 // Setup time for positions 1..=p
                 for pp in 1..=p {
                     for jj in 0..n {
-                        let s = setup_times[compilers[jj]] as f64;
-                        if s > 0.0 {
+                        let s = setup_times[compilers[jj]];
+                        if s > 0 {
                             terms.push((a_var(jj, pp), s));
                         }
                     }
                 }
-                let rhs = deadlines[j] as f64 - lengths[j] as f64 + big_m;
+                let rhs = deadlines[j]
+                    .checked_sub(lengths[j])
+                    .and_then(|value| value.checked_add(big_m))
+                    .ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<
+                            SequencingWithDeadlinesAndSetUpTimes,
+                            ILP<bool>,
+                        >("computing a deadline constraint bound")
+                    })?;
                 constraints.push(LinearConstraint::le(terms, rhs));
             }
         }
 
-        ReductionSWDSTToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionSWDSTToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
-        }
+        })
     }
 }
 
diff --git a/src/rules/sequencingwithinintervals_ilp.rs b/src/rules/sequencingwithinintervals_ilp.rs
index 5d816ca44..daccfd111 100644
--- a/src/rules/sequencingwithinintervals_ilp.rs
+++ b/src/rules/sequencingwithinintervals_ilp.rs
@@ -1,13 +1,13 @@
-//! Reduction from SequencingWithinIntervals to ILP<bool>.
+//! Reduction from SequencingWithinIntervals to `ILP<bool>`.
 //!
 //! Uses a time-indexed binary formulation:
 //! - Variables: Binary x_{j,k} where x_{j,k} = 1 iff task j starts at offset k
-//!   from its release time (actual start = r_j + k), k in 0..(d_j - r_j - l_j).
+//!   from its release time (actual start = r_j + k), 0 <= k <= d_j - r_j - l_j.
 //! - Variable index: task j at offset k has global index: Σ_{i<j} slot_count_i + k,
-//!   where slot_count_i = d_i - r_i - l_i + 1 is the number of valid start offsets.
+//!   where slot_count_i = max(0, d_i - r_i - l_i + 1) counts valid start offsets.
 //!   For simplicity we use a flat layout: each task j occupies slot_count[j] variables.
 //! - Constraints:
-//!   1. One-hot: Σ_k x_{j,k} = 1 for each task j
+//!   1. One-hot: Σ_k x_{j,k} = 1 for each task j (0 = 1 for an empty start domain).
 //!   2. Non-overlap: for each pair (i, j), they cannot be active at the same time.
 //!      Active time of task j starting at r_j+k: [r_j+k, r_j+k+l_j).
 //!      Non-overlap: no shared time. Modeled with: for each pair (i,j) with i<j,
@@ -20,10 +20,10 @@ use crate::models::misc::SequencingWithinIntervals;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing SequencingWithinIntervals to ILP<bool>.
+/// Result of reducing SequencingWithinIntervals to `ILP<bool>`.
 ///
 /// Variable layout: task j occupies variables at offsets [base_j, base_j + slot_count_j).
-/// where base_j = Σ_{i<j} slot_count_i and slot_count_j = d_j - r_j - l_j + 1.
+/// where base_j = Σ_{i<j} slot_count_i and slot_count_j = max(0, d_j - r_j - l_j + 1).
 #[derive(Debug, Clone)]
 pub struct ReductionSWIToILP {
     target: ILP<bool>,
@@ -43,44 +43,66 @@ impl ReductionResult for ReductionSWIToILP {
     ///
     /// For each task j, find the offset k where x_{j,k} = 1.
     /// Returns config[j] = k (start time offset from release time).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
         self.task_layout
             .iter()
-            .map(|&(base, count)| {
-                (0..count)
-                    .find(|&k| target_solution.get(base + k).copied().unwrap_or(0) == 1)
-                    .unwrap_or(0)
+            .enumerate()
+            .map(|(task, &(base, count))| {
+                let mut selected = (0..count).filter(|&offset| target_solution[base + offset] == 1);
+                match (selected.next(), selected.next()) {
+                    (Some(offset), None) => Ok(offset),
+                    (None, _) => Err(crate::rules::ExtractionError::invalid(format!(
+                        "task {task} has no selected start time"
+                    ))),
+                    (Some(_), Some(_)) => Err(crate::rules::ExtractionError::invalid(format!(
+                        "task {task} has multiple selected start times"
+                    ))),
+                }
             })
             .collect()
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "num_tasks^2",
-        num_constraints = "num_tasks^2 + num_tasks",
+    transform = upper_bound {
+        num_vars = "num_start_slots",
+        num_constraints = "num_start_slots^2 + num_tasks",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for SequencingWithinIntervals {
     type Result = ReductionSWIToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
         let release = self.release_times();
-        let deadlines = self.deadlines();
         let lengths = self.lengths();
 
         // Compute per-task variable layout: how many start slots each task has
-        let slot_counts: Vec<usize> = (0..n)
-            .map(|j| (deadlines[j] - release[j] - lengths[j] + 1) as usize)
-            .collect();
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<Self, ILP<bool>>(operation)
+        };
+        let slot_counts: Vec<usize> = self.start_slot_counts().collect();
 
         let mut bases = vec![0usize; n];
         for j in 1..n {
-            bases[j] = bases[j - 1] + slot_counts[j - 1];
+            bases[j] = bases[j - 1]
+                .checked_add(slot_counts[j - 1])
+                .ok_or_else(|| overflow("computing task variable offsets"))?;
         }
-        let num_vars =
-            bases.last().copied().unwrap_or(0) + slot_counts.last().copied().unwrap_or(0);
+        let num_vars = bases
+            .last()
+            .copied()
+            .unwrap_or(0)
+            .checked_add(slot_counts.last().copied().unwrap_or(0))
+            .ok_or_else(|| overflow("computing the ILP variable count"))?;
 
         let task_layout: Vec<(usize, usize)> = (0..n).map(|j| (bases[j], slot_counts[j])).collect();
 
@@ -88,9 +110,8 @@ impl ReduceTo<ILP<bool>> for SequencingWithinIntervals {
 
         // 1. One-hot per task
         for j in 0..n {
-            let terms: Vec<(usize, f64)> =
-                (0..slot_counts[j]).map(|k| (bases[j] + k, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..slot_counts[j]).map(|k| (bases[j] + k, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 2. Non-overlap for each pair (i, j) with i < j
@@ -99,16 +120,27 @@ impl ReduceTo<ILP<bool>> for SequencingWithinIntervals {
         for i in 0..n {
             for j in (i + 1)..n {
                 for k1 in 0..slot_counts[i] {
-                    let start_i = release[i] + k1 as u64;
-                    let end_i = start_i + lengths[i];
+                    let offset_i = Self::exact_i64(k1, "converting a task start offset to i64")?;
+                    let start_i = release[i]
+                        .checked_add(offset_i)
+                        .ok_or_else(|| overflow("computing a task start time"))?;
+                    let end_i = start_i
+                        .checked_add(lengths[i])
+                        .ok_or_else(|| overflow("computing a task end time"))?;
                     for k2 in 0..slot_counts[j] {
-                        let start_j = release[j] + k2 as u64;
-                        let end_j = start_j + lengths[j];
+                        let offset_j =
+                            Self::exact_i64(k2, "converting a task start offset to i64")?;
+                        let start_j = release[j]
+                            .checked_add(offset_j)
+                            .ok_or_else(|| overflow("computing a task start time"))?;
+                        let end_j = start_j
+                            .checked_add(lengths[j])
+                            .ok_or_else(|| overflow("computing a task end time"))?;
                         // Overlap if neither ends before the other starts
                         if !(end_i <= start_j || end_j <= start_i) {
                             constraints.push(LinearConstraint::le(
-                                vec![(bases[i] + k1, 1.0), (bases[j] + k2, 1.0)],
-                                1.0,
+                                vec![(bases[i] + k1, 1), (bases[j] + k2, 1)],
+                                1,
                             ));
                         }
                     }
@@ -116,10 +148,11 @@ impl ReduceTo<ILP<bool>> for SequencingWithinIntervals {
             }
         }
 
-        ReductionSWIToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionSWIToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             task_layout,
-        }
+        })
     }
 }
 
@@ -133,18 +166,22 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             // 2 tasks: task 0 [r=0, d=3, l=2], task 1 [r=2, d=5, l=2]
             // Task 0 can start at offset 0 or 1, task 1 can start at offset 0 or 1
             // No overlap when both at offset 0: [0,2) and [2,4)
-            let source = SequencingWithinIntervals::new(vec![0, 2], vec![3, 5], vec![2, 2]);
-            let reduction: ReductionSWIToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+            let source =
+                SequencingWithinIntervals::new(vec![0, 2], vec![3, 5], vec![2, 2]).unwrap();
+            let reduction: ReductionSWIToILP =
+                ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
             let solver = crate::solvers::ILPSolver::new();
             let target_config = solver
                 .solve(reduction.target_problem())
                 .expect("canonical example should be feasible");
-            let source_config = reduction.extract_solution(&target_config);
+            let source_config = reduction.extract_solution(&target_config).unwrap();
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/sequencingwithreleasetimesanddeadlines_ilp.rs b/src/rules/sequencingwithreleasetimesanddeadlines_ilp.rs
index cbcbadce0..d14ad874c 100644
--- a/src/rules/sequencingwithreleasetimesanddeadlines_ilp.rs
+++ b/src/rules/sequencingwithreleasetimesanddeadlines_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from SequencingWithReleaseTimesAndDeadlines to ILP<bool>.
+//! Reduction from SequencingWithReleaseTimesAndDeadlines to `ILP<bool>`.
 //!
 //! Time-indexed formulation: binary x_{j,t} = 1 iff task j starts at time t.
 //! Each task starts within its admissible window [r_j, d_j - p_j].
@@ -9,7 +9,7 @@ use crate::models::misc::SequencingWithReleaseTimesAndDeadlines;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing SequencingWithReleaseTimesAndDeadlines to ILP<bool>.
+/// Result of reducing SequencingWithReleaseTimesAndDeadlines to `ILP<bool>`.
 ///
 /// Variable layout: x_{j,t} at index `j * T + t` for j in 0..n, t in 0..T,
 /// where T = time_horizon (max deadline).
@@ -20,22 +20,6 @@ pub struct ReductionSWRTDToILP {
     time_horizon: usize,
 }
 
-impl ReductionSWRTDToILP {
-    fn encode_schedule_as_lehmer(schedule: &[usize]) -> Vec<usize> {
-        let mut available: Vec<usize> = (0..schedule.len()).collect();
-        let mut config = Vec::with_capacity(schedule.len());
-        for &task in schedule {
-            let digit = available
-                .iter()
-                .position(|&c| c == task)
-                .expect("schedule must be a permutation");
-            config.push(digit);
-            available.remove(digit);
-        }
-        config
-    }
-}
-
 impl ReductionResult for ReductionSWRTDToILP {
     type Source = SequencingWithReleaseTimesAndDeadlines;
     type Target = ILP<bool>;
@@ -44,35 +28,40 @@ impl ReductionResult for ReductionSWRTDToILP {
         &self.target
     }
 
-    /// Extract: read each task's start time, sort tasks by start time,
-    /// encode as Lehmer code.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_tasks;
-        let horizon = self.time_horizon;
-        // For each task, find the start time
-        let mut start_times: Vec<(usize, usize)> = (0..n)
-            .map(|j| {
-                let start = (0..horizon)
-                    .find(|&t| target_solution.get(j * horizon + t).copied().unwrap_or(0) == 1)
-                    .unwrap_or(0);
-                (j, start)
-            })
-            .collect();
-        // Sort by start time (break ties by task index)
-        start_times.sort_by_key(|&(j, t)| (t, j));
-        let schedule: Vec<usize> = start_times.iter().map(|&(j, _)| j).collect();
-        Self::encode_schedule_as_lehmer(&schedule)
+    /// Extract by reading each task's start time and sorting tasks by start time.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_tasks;
+            let horizon = self.time_horizon;
+            // For each task, find the start time
+            let starts =
+                crate::rules::ilp_helpers::one_hot_decode_rows(target_solution, n, horizon, 0)?;
+            let mut start_times: Vec<_> = starts.into_iter().enumerate().collect();
+            // Sort by start time (break ties by task index)
+            start_times.sort_by_key(|&(j, t)| (t, j));
+            let schedule: Vec<usize> = start_times.iter().map(|&(j, _)| j).collect();
+            schedule
+        })
     }
 }
 
-#[reduction(overhead = {
+#[reduction(transform = upper_bound {
     num_vars = "num_tasks * time_horizon",
-    num_constraints = "num_tasks + time_horizon",
-})]
+    num_constraints = "num_tasks * time_horizon + num_tasks + time_horizon",
+},
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<ILP<bool>> for SequencingWithReleaseTimesAndDeadlines {
     type Result = ReductionSWRTDToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_tasks();
         let horizon = self.time_horizon() as usize;
         let num_vars = n * horizon;
@@ -91,21 +80,22 @@ impl ReduceTo<ILP<bool>> for SequencingWithReleaseTimesAndDeadlines {
         // by not including them; add explicit zero constraints for safety).
         for j in 0..n {
             let r = release_times[j] as usize;
-            let last_start = if deadlines[j] >= lengths[j] {
-                (deadlines[j] - lengths[j]) as usize
-            } else {
-                0
-            };
-            let terms: Vec<(usize, f64)> = (r..=last_start)
+            let last_start = deadlines[j]
+                .checked_sub(lengths[j])
+                .and_then(|time| usize::try_from(time).ok());
+            let terms: Vec<(usize, i64)> = last_start
+                .filter(|&last| r <= last)
+                .into_iter()
+                .flat_map(|last| r..=last)
                 .filter(|&t| t < horizon)
-                .map(|t| (var(j, t), 1.0))
+                .map(|t| (var(j, t), 1))
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
 
             // Zero-fix variables outside the admissible window
             for t in 0..horizon {
-                if t < r || t > last_start {
-                    constraints.push(LinearConstraint::eq(vec![(var(j, t), 1.0)], 0.0));
+                if t < r || last_start.is_none_or(|last| t > last) {
+                    constraints.push(LinearConstraint::eq(vec![(var(j, t), 1)], 0));
                 }
             }
         }
@@ -113,7 +103,7 @@ impl ReduceTo<ILP<bool>> for SequencingWithReleaseTimesAndDeadlines {
         // 2. No overlap: for each time instant tau in 0..horizon,
         // Σ_{j,t : t <= tau < t + p_j} x_{j,t} <= 1
         for tau in 0..horizon {
-            let mut terms: Vec<(usize, f64)> = Vec::new();
+            let mut terms: Vec<(usize, i64)> = Vec::new();
             for (j, &len_j) in lengths.iter().enumerate() {
                 let p = len_j as usize;
                 // Task j started at time t overlaps tau iff t <= tau < t + p_j
@@ -122,18 +112,19 @@ impl ReduceTo<ILP<bool>> for SequencingWithReleaseTimesAndDeadlines {
                 let t_max = tau;
                 for t in t_min..=t_max {
                     if t < horizon {
-                        terms.push((var(j, t), 1.0));
+                        terms.push((var(j, t), 1));
                     }
                 }
             }
-            constraints.push(LinearConstraint::le(terms, 1.0));
+            constraints.push(LinearConstraint::le(terms, 1));
         }
 
-        ReductionSWRTDToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionSWRTDToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_tasks: n,
             time_horizon: horizon,
-        }
+        })
     }
 }
 
diff --git a/src/rules/setsplitting_betweenness.rs b/src/rules/setsplitting_betweenness.rs
index 499a03e6d..a62f799d4 100644
--- a/src/rules/setsplitting_betweenness.rs
+++ b/src/rules/setsplitting_betweenness.rs
@@ -28,38 +28,30 @@ impl ReductionResult for ReductionSetSplittingToBetweenness {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        assert!(
-            target_solution.len() > self.pole,
-            "Betweenness solution has {} positions but pole index is {}",
-            target_solution.len(),
-            self.pole
-        );
-        assert!(
-            target_solution.len() >= self.source_universe_size,
-            "Betweenness solution has {} positions but source requires {} elements",
-            target_solution.len(),
-            self.source_universe_size
-        );
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
         let pole_position = target_solution[self.pole];
-        target_solution[..self.source_universe_size]
+        Ok(target_solution[..self.source_universe_size]
             .iter()
-            .map(|&position| usize::from(position > pole_position))
-            .collect()
+            .map(|&position| position > pole_position)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
-        num_elements = "normalized_universe_size + 1 + normalized_num_size3_subsets",
-        num_triples = "normalized_num_size2_subsets + 2 * normalized_num_size3_subsets",
+    transform = unavailable {
+        num_elements = "the exact target parameters depend on normalization statistics specific to this reduction",
+        num_triples = "the exact target parameters depend on normalization statistics specific to this reduction",
     }
 )]
 impl ReduceTo<Betweenness> for SetSplitting {
     type Result = ReductionSetSplittingToBetweenness;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let (normalized_universe_size, normalized_subsets) = self.normalized_instance();
         let pole = normalized_universe_size;
         let size3_subsets = normalized_subsets
@@ -78,15 +70,22 @@ impl ReduceTo<Betweenness> for SetSplitting {
                     triples.push((*u, auxiliary, *v));
                     triples.push((auxiliary, pole, *w));
                 }
-                _ => unreachable!("normalization only produces size-2 or size-3 subsets"),
+                _ => {
+                    return Err(crate::rules::ReductionError::invalid_target::<
+                        SetSplitting,
+                        Betweenness,
+                    >(
+                        "normalized subset must contain two or three elements"
+                    ));
+                }
             }
         }
 
-        ReductionSetSplittingToBetweenness {
+        Ok(ReductionSetSplittingToBetweenness {
             target: Betweenness::new(num_elements, triples),
             source_universe_size: self.universe_size(),
             pole,
-        }
+        })
     }
 }
 
@@ -103,8 +102,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     vec![vec![0, 1, 2], vec![2, 3, 4], vec![0, 3, 4], vec![1, 2, 3]],
                 ),
                 SolutionPair {
-                    source_config: vec![1, 0, 1, 0, 0],
-                    target_config: vec![8, 2, 9, 0, 1, 4, 3, 6, 7, 5],
+                    source_config: serde_json::json!(vec![true, false, true, false, false]),
+                    target_config: serde_json::json!(vec![8, 2, 9, 0, 1, 4, 3, 6, 7, 5]),
                 },
             )
         },
diff --git a/src/rules/setsplitting_ilp.rs b/src/rules/setsplitting_ilp.rs
index 2756b2898..db0b8a61c 100644
--- a/src/rules/setsplitting_ilp.rs
+++ b/src/rules/setsplitting_ilp.rs
@@ -28,37 +28,49 @@ impl ReductionResult for ReductionSetSplittingToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "universe_size",
         num_constraints = "2 * num_subsets",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for SetSplitting {
     type Result = ReductionSetSplittingToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.universe_size();
         let mut constraints = Vec::new();
 
         for subset in self.subsets() {
-            let k = subset.len();
-            let terms: Vec<(usize, f64)> = subset.iter().map(|&e| (e, 1.0)).collect();
+            let terms: Vec<(usize, i64)> = subset.iter().map(|&e| (e, 1)).collect();
+            let k = <Self as ReduceTo<ILP<bool>>>::exact_i64(
+                subset.len() - 1,
+                "encoding the split-set cardinality",
+            )?;
 
             // At least one element in S2: sum >= 1
-            constraints.push(LinearConstraint::ge(terms.clone(), 1.0));
+            constraints.push(LinearConstraint::ge(terms.clone(), 1));
 
             // At least one element in S1: sum <= k - 1
-            constraints.push(LinearConstraint::le(terms, (k - 1) as f64));
+            constraints.push(LinearConstraint::le(terms, k));
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionSetSplittingToILP { target }
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
+        Ok(ReductionSetSplittingToILP { target })
     }
 }
 
diff --git a/src/rules/shortestcommonsupersequence_ilp.rs b/src/rules/shortestcommonsupersequence_ilp.rs
index 59256028f..d1c713717 100644
--- a/src/rules/shortestcommonsupersequence_ilp.rs
+++ b/src/rules/shortestcommonsupersequence_ilp.rs
@@ -27,29 +27,37 @@ impl ReductionResult for ReductionSCSToILP {
 
     /// At each position p, output the unique symbol a with x_{p,a} = 1.
     /// Uses alphabet_size + 1 symbols (last = padding).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let b = self.max_length;
-        let k = self.alphabet_size + 1; // includes padding symbol
-        (0..b)
-            .map(|p| {
-                (0..k)
-                    .find(|&a| target_solution[p * k + a] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.max_length,
+            self.alphabet_size + 1,
+            0,
+        )?
+        .into_iter()
+        .map(|symbol| (symbol < self.alphabet_size).then_some(symbol))
+        .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "max_length * (alphabet_size + 1) + total_length * max_length",
         num_constraints = "max_length + total_length + total_length * max_length + total_length + max_length",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for ShortestCommonSupersequence {
     type Result = ReductionSCSToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let b = self.max_length();
         let alpha = self.alphabet_size();
         let k = alpha + 1; // alphabet + padding symbol
@@ -78,14 +86,14 @@ impl ReduceTo<ILP<bool>> for ShortestCommonSupersequence {
 
         // 1. One-hot symbol at each position: Σ_a x_{p,a} = 1  ∀ p
         for p in 0..b {
-            let terms: Vec<(usize, f64)> = (0..k).map(|a| (p * k + a, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..k).map(|a| (p * k + a, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 2. Each character matched to exactly one position: Σ_p m_{gc,p} = 1
         for gc in 0..total_chars {
-            let terms: Vec<(usize, f64)> = (0..b).map(|p| (m_offset + gc * b + p, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..b).map(|p| (m_offset + gc * b + p, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // 3. Symbol consistency: m_{gc,p} <= x_{p,a} where a is the symbol at gc
@@ -95,8 +103,8 @@ impl ReduceTo<ILP<bool>> for ShortestCommonSupersequence {
                 for p in 0..b {
                     // m_{gc,p} <= x_{p,sym}
                     constraints.push(LinearConstraint::le(
-                        vec![(m_offset + gc * b + p, 1.0), (p * k + sym, -1.0)],
-                        0.0,
+                        vec![(m_offset + gc * b + p, 1), (p * k + sym, -1)],
+                        0,
                     ));
                 }
             }
@@ -112,10 +120,11 @@ impl ReduceTo<ILP<bool>> for ShortestCommonSupersequence {
                 let gc_next = char_offsets[s_idx] + j + 1;
                 let mut terms = Vec::new();
                 for p in 0..b {
-                    terms.push((m_offset + gc_next * b + p, p as f64));
-                    terms.push((m_offset + gc_j * b + p, -(p as f64)));
+                    let p_i64 = Self::exact_i64(p, "encoding a sequence position")?;
+                    terms.push((m_offset + gc_next * b + p, p_i64));
+                    terms.push((m_offset + gc_j * b + p, -p_i64));
                 }
-                constraints.push(LinearConstraint::ge(terms, 1.0));
+                constraints.push(LinearConstraint::ge(terms, 1));
             }
         }
 
@@ -123,19 +132,20 @@ impl ReduceTo<ILP<bool>> for ShortestCommonSupersequence {
         //    x_{p,pad} <= x_{p+1,pad}  for p in 0..b-1
         for p in 0..b.saturating_sub(1) {
             constraints.push(LinearConstraint::le(
-                vec![(p * k + pad, 1.0), ((p + 1) * k + pad, -1.0)],
-                0.0,
+                vec![(p * k + pad, 1), ((p + 1) * k + pad, -1)],
+                0,
             ));
         }
 
         // Objective: minimize non-padding positions = maximize padding positions
-        let objective: Vec<(usize, f64)> = (0..b).map(|p| (p * k + pad, 1.0)).collect();
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize);
-        ReductionSCSToILP {
+        let objective: Vec<(usize, i64)> = (0..b).map(|p| (p * k + pad, 1)).collect();
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Maximize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionSCSToILP {
             target,
             max_length: b,
             alphabet_size: alpha,
-        }
+        })
     }
 }
 
@@ -147,19 +157,22 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             // Alphabet {0,1}, strings [0,1] and [1,0]
             let source = ShortestCommonSupersequence::new(2, vec![vec![0, 1], vec![1, 0]]);
-            let reduction: ReductionSCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+            let reduction: ReductionSCSToILP =
+                ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
             let target_config = {
                 let ilp_solver = crate::solvers::ILPSolver::new();
                 ilp_solver
                     .solve(reduction.target_problem())
                     .expect("ILP should be solvable")
             };
-            let source_config = reduction.extract_solution(&target_config);
+            let source_config = reduction.extract_solution(&target_config).unwrap();
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/shortestweightconstrainedpath_ilp.rs b/src/rules/shortestweightconstrainedpath_ilp.rs
index 9a7b92c44..fe8ff92be 100644
--- a/src/rules/shortestweightconstrainedpath_ilp.rs
+++ b/src/rules/shortestweightconstrainedpath_ilp.rs
@@ -15,14 +15,14 @@ use crate::types::WeightElement;
 
 /// Result of reducing ShortestWeightConstrainedPath to ILP.
 ///
-/// Variable layout (within `ILP<i32>`):
+/// Variable layout (within `ILP<i64>`):
 /// - Arc variables: `a_{e,0}` and `a_{e,1}` for each undirected edge `e`
 ///   (indices `0..2m`), bounded to {0, 1}
 /// - Order variables: `o_v` for each vertex `v` (indices `2m..2m+n`),
 ///   bounded to `[0, n-1]`
 #[derive(Debug, Clone)]
 pub struct ReductionSWCPToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_edges: usize,
 }
 
@@ -33,84 +33,87 @@ impl ReductionSWCPToILP {
 }
 
 impl ReductionResult for ReductionSWCPToILP {
-    type Source = ShortestWeightConstrainedPath<SimpleGraph, i32>;
-    type Target = ILP<i32>;
+    type Source = ShortestWeightConstrainedPath<SimpleGraph, i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        (0..self.num_edges)
-            .map(|edge_idx| {
-                usize::from(
-                    target_solution
-                        .get(Self::arc_var(edge_idx, 0))
-                        .copied()
-                        .unwrap_or(0)
-                        > 0
-                        || target_solution
-                            .get(Self::arc_var(edge_idx, 1))
-                            .copied()
-                            .unwrap_or(0)
-                            > 0,
-                )
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            (0..self.num_edges)
+                .map(|edge_idx| {
+                    target_solution[Self::arc_var(edge_idx, 0)] > 0
+                        || target_solution[Self::arc_var(edge_idx, 1)] > 0
+                })
+                .collect()
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "2 * num_edges + num_vertices",
-    num_constraints = "5 * num_edges + 4 * num_vertices + 2",
-})]
-impl ReduceTo<ILP<i32>> for ShortestWeightConstrainedPath<SimpleGraph, i32> {
+#[reduction(
+    transform = exact {
+        num_vars = "2 * num_edges + num_vertices",
+        num_constraints = "5 * num_edges + 4 * num_vertices + 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
+impl ReduceTo<ILP<i64>> for ShortestWeightConstrainedPath<SimpleGraph, i64> {
     type Result = ReductionSWCPToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let edges = self.graph().edges();
         let num_vertices = self.num_vertices();
         let num_edges = self.num_edges();
         let num_vars = 2 * num_edges + num_vertices;
         let source = self.source_vertex();
         let target = self.target_vertex();
-        let big_m = num_vertices as f64;
+        let big_m = Self::exact_i64(num_vertices, "encoding the vertex order")?;
 
         let order_var = |vertex: usize| 2 * num_edges + vertex;
 
         // Build adjacency: outgoing[v] and incoming[v] collect arc variable
         // references for arcs leaving / entering vertex v.
-        let mut outgoing: Vec<Vec<(usize, f64)>> = vec![Vec::new(); num_vertices];
-        let mut incoming: Vec<Vec<(usize, f64)>> = vec![Vec::new(); num_vertices];
+        let mut outgoing: Vec<Vec<(usize, i64)>> = vec![Vec::new(); num_vertices];
+        let mut incoming: Vec<Vec<(usize, i64)>> = vec![Vec::new(); num_vertices];
 
         for (edge_idx, &(u, v)) in edges.iter().enumerate() {
             let forward = ReductionSWCPToILP::arc_var(edge_idx, 0); // u -> v
             let reverse = ReductionSWCPToILP::arc_var(edge_idx, 1); // v -> u
-            outgoing[u].push((forward, 1.0));
-            incoming[v].push((forward, 1.0));
-            outgoing[v].push((reverse, 1.0));
-            incoming[u].push((reverse, 1.0));
+            outgoing[u].push((forward, 1));
+            incoming[v].push((forward, 1));
+            outgoing[v].push((reverse, 1));
+            incoming[u].push((reverse, 1));
         }
 
         let mut constraints = Vec::new();
 
-        // --- Arc variables are binary within ILP<i32>: 0 <= a_{e,d} <= 1 ---
+        // --- Arc variables are binary within `ILP<i64>`: 0 <= a_{e,d} <= 1 ---
         for edge_idx in 0..num_edges {
             constraints.push(LinearConstraint::le(
-                vec![(ReductionSWCPToILP::arc_var(edge_idx, 0), 1.0)],
-                1.0,
+                vec![(ReductionSWCPToILP::arc_var(edge_idx, 0), 1)],
+                1,
             ));
             constraints.push(LinearConstraint::le(
-                vec![(ReductionSWCPToILP::arc_var(edge_idx, 1), 1.0)],
-                1.0,
+                vec![(ReductionSWCPToILP::arc_var(edge_idx, 1), 1)],
+                1,
             ));
         }
 
         // --- Order variables stay within [0, |V|-1] ---
+        let max_order = if num_vertices == 0 { 0 } else { big_m - 1 };
         for vertex in 0..num_vertices {
             constraints.push(LinearConstraint::le(
-                vec![(order_var(vertex), 1.0)],
-                num_vertices.saturating_sub(1) as f64,
+                vec![(order_var(vertex), 1)],
+                max_order,
             ));
         }
 
@@ -124,28 +127,28 @@ impl ReduceTo<ILP<i32>> for ShortestWeightConstrainedPath<SimpleGraph, i32> {
 
             let rhs = if source != target {
                 if vertex == source {
-                    1.0
+                    1
                 } else if vertex == target {
-                    -1.0
+                    -1
                 } else {
-                    0.0
+                    0
                 }
             } else {
-                0.0
+                0
             };
             constraints.push(LinearConstraint::eq(balance_terms, rhs));
-            constraints.push(LinearConstraint::le(outgoing[vertex].clone(), 1.0));
-            constraints.push(LinearConstraint::le(incoming[vertex].clone(), 1.0));
+            constraints.push(LinearConstraint::le(outgoing[vertex].clone(), 1));
+            constraints.push(LinearConstraint::le(incoming[vertex].clone(), 1));
         }
 
         // --- At most one direction per undirected edge ---
         for edge_idx in 0..num_edges {
             constraints.push(LinearConstraint::le(
                 vec![
-                    (ReductionSWCPToILP::arc_var(edge_idx, 0), 1.0),
-                    (ReductionSWCPToILP::arc_var(edge_idx, 1), 1.0),
+                    (ReductionSWCPToILP::arc_var(edge_idx, 0), 1),
+                    (ReductionSWCPToILP::arc_var(edge_idx, 1), 1),
                 ],
-                1.0,
+                1,
             ));
         }
 
@@ -154,61 +157,69 @@ impl ReduceTo<ILP<i32>> for ShortestWeightConstrainedPath<SimpleGraph, i32> {
             // o_v - o_u - M * a_{e,0} >= 1 - M
             constraints.push(LinearConstraint::ge(
                 vec![
-                    (order_var(v), 1.0),
-                    (order_var(u), -1.0),
+                    (order_var(v), 1),
+                    (order_var(u), -1),
                     (ReductionSWCPToILP::arc_var(edge_idx, 0), -big_m),
                 ],
-                1.0 - big_m,
+                1 - big_m,
             ));
             // o_u - o_v - M * a_{e,1} >= 1 - M
             constraints.push(LinearConstraint::ge(
                 vec![
-                    (order_var(u), 1.0),
-                    (order_var(v), -1.0),
+                    (order_var(u), 1),
+                    (order_var(v), -1),
                     (ReductionSWCPToILP::arc_var(edge_idx, 1), -big_m),
                 ],
-                1.0 - big_m,
+                1 - big_m,
             ));
         }
 
         // --- Fix source order to 0 ---
-        constraints.push(LinearConstraint::eq(vec![(order_var(source), 1.0)], 0.0));
+        constraints.push(LinearConstraint::eq(vec![(order_var(source), 1)], 0));
 
         // --- Weight bound: Σ wt_e * (a_{e,0} + a_{e,1}) <= weight_bound ---
-        let weight_terms: Vec<(usize, f64)> = edges
+        let edge_weights: Vec<i64> = self
+            .edge_weights()
+            .iter()
+            .map(WeightElement::to_sum)
+            .collect();
+        let weight_terms: Vec<(usize, i64)> = edges
             .iter()
             .enumerate()
             .flat_map(|(edge_idx, _)| {
-                let coeff = self.edge_weights()[edge_idx].to_sum() as f64;
+                let coeff = edge_weights[edge_idx];
                 [
                     (ReductionSWCPToILP::arc_var(edge_idx, 0), coeff),
                     (ReductionSWCPToILP::arc_var(edge_idx, 1), coeff),
                 ]
             })
             .collect();
-        constraints.push(LinearConstraint::le(
-            weight_terms,
-            *self.weight_bound() as f64,
-        ));
+        constraints.push(LinearConstraint::le(weight_terms, *self.weight_bound()));
 
         // --- Objective: minimize total path length ---
-        let objective: Vec<(usize, f64)> = edges
+        let edge_lengths: Vec<i64> = self
+            .edge_lengths()
+            .iter()
+            .map(WeightElement::to_sum)
+            .collect();
+        let objective: Vec<(usize, i64)> = edges
             .iter()
             .enumerate()
             .flat_map(|(edge_idx, _)| {
-                let coeff = self.edge_lengths()[edge_idx].to_sum() as f64;
+                let coeff = edge_lengths[edge_idx];
                 [
                     (ReductionSWCPToILP::arc_var(edge_idx, 0), coeff),
                     (ReductionSWCPToILP::arc_var(edge_idx, 1), coeff),
                 ]
             })
             .collect();
-        let target_ilp = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target_ilp = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionSWCPToILP {
+        Ok(ReductionSWCPToILP {
             target: target_ilp,
             num_edges,
-        }
+        })
     }
 }
 
@@ -229,7 +240,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 2,
                 4,
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/sparsematrixcompression_ilp.rs b/src/rules/sparsematrixcompression_ilp.rs
index 3cf26a8c6..b19b79368 100644
--- a/src/rules/sparsematrixcompression_ilp.rs
+++ b/src/rules/sparsematrixcompression_ilp.rs
@@ -22,28 +22,34 @@ impl ReductionResult for ReductionSMCToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // For each row r, output the unique zero-based shift g with x_{r,g} = 1
-        (0..self.num_rows)
-            .map(|r| {
-                (0..self.bound_k)
-                    .find(|&g| target_solution[r * self.bound_k + g] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_rows,
+            self.bound_k,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_rows * bound_k",
         num_constraints = "num_rows + num_rows * num_rows * bound_k * bound_k",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for SparseMatrixCompression {
     type Result = ReductionSMCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.num_rows();
         let n = self.num_cols();
         let k = self.bound_k();
@@ -56,8 +62,8 @@ impl ReduceTo<ILP<bool>> for SparseMatrixCompression {
 
         // Each row assigned exactly one shift
         for r in 0..m {
-            let terms: Vec<(usize, f64)> = (0..k).map(|g| (r * k + g, 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..k).map(|g| (r * k + g, 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Collision constraints:
@@ -85,8 +91,8 @@ impl ReduceTo<ILP<bool>> for SparseMatrixCompression {
                                 continue;
                             }
                             constraints.push(LinearConstraint::le(
-                                vec![(r * k + g, 1.0), (s * k + h, 1.0)],
-                                1.0,
+                                vec![(r * k + g, 1), (s * k + h, 1)],
+                                1,
                             ));
                         }
                     }
@@ -94,12 +100,13 @@ impl ReduceTo<ILP<bool>> for SparseMatrixCompression {
             }
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionSMCToILP {
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionSMCToILP {
             target,
             num_rows: m,
             bound_k: k,
-        }
+        })
     }
 }
 
@@ -118,17 +125,19 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 ],
                 2,
             );
-            let reduction: ReductionSMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+            let reduction: ReductionSMCToILP =
+                ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
             let ilp_solver = crate::solvers::ILPSolver::new();
             let target_config = ilp_solver
                 .solve(reduction.target_problem())
                 .expect("ILP should be solvable");
-            let extracted = reduction.extract_solution(&target_config);
+            let extracted = reduction.extract_solution(&target_config).unwrap();
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: extracted,
-                    target_config,
+                    source_config: serde_json::json!(extracted),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/spinglass_casts.rs b/src/rules/spinglass_casts.rs
index 81693c23e..2a9630450 100644
--- a/src/rules/spinglass_casts.rs
+++ b/src/rules/spinglass_casts.rs
@@ -1,16 +1,39 @@
-//! Variant cast reductions for SpinGlass.
+//! Variant reductions for SpinGlass.
 
 use crate::impl_variant_reduction;
 use crate::models::graph::SpinGlass;
+use crate::rules::ReductionError;
 use crate::topology::SimpleGraph;
-use crate::variant::CastToParent;
+use crate::types::i64_to_exact_f64;
 
 impl_variant_reduction!(
     SpinGlass,
-    <SimpleGraph, i32> => <SimpleGraph, f64>,
+    <SimpleGraph, i64> => <SimpleGraph, f64>,
     fields: [num_spins, num_interactions],
-    |src| SpinGlass::from_graph(
-        src.graph().clone(),
-        src.couplings().iter().map(|w| w.cast_to_parent()).collect(),
-        src.fields().iter().map(|w| w.cast_to_parent()).collect())
+    |src| {
+        let convert = |values: &[i64]| {
+            values
+                .iter()
+                .copied()
+                .map(i64_to_exact_f64)
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|error| {
+                    ReductionError::inexact_float_conversion::<
+                        SpinGlass<SimpleGraph, i64>,
+                        SpinGlass<SimpleGraph, f64>,
+                    >(error)
+                })
+        };
+        SpinGlass::from_graph(
+            src.graph().clone(),
+            convert(src.couplings())?,
+            convert(src.fields())?,
+        )
+        .map_err(|message| {
+            ReductionError::construction::<
+                SpinGlass<SimpleGraph, i64>,
+                SpinGlass<SimpleGraph, f64>,
+            >(message)
+        })?
+    }
 );
diff --git a/src/rules/spinglass_maxcut.rs b/src/rules/spinglass_maxcut.rs
index e3ed5a419..31e315acc 100644
--- a/src/rules/spinglass_maxcut.rs
+++ b/src/rules/spinglass_maxcut.rs
@@ -26,8 +26,7 @@ where
         + num_traits::Zero
         + num_traits::Bounded
         + std::ops::AddAssign
-        + std::ops::Mul<Output = W>
-        + From<i32>,
+        + std::ops::Mul<Output = W>,
 {
     type Source = MaxCut<SimpleGraph, W>;
     type Target = SpinGlass<SimpleGraph, W>;
@@ -36,21 +35,26 @@ where
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&spin| spin == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_spins = "num_vertices",
         num_interactions = "num_edges",
     }
 )]
-impl ReduceTo<SpinGlass<SimpleGraph, i32>> for MaxCut<SimpleGraph, i32> {
-    type Result = ReductionMaxCutToSG<i32>;
+impl ReduceTo<SpinGlass<SimpleGraph, i64>> for MaxCut<SimpleGraph, i64> {
+    type Result = ReductionMaxCutToSG<i64>;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let edges_with_weights = self.edges();
 
@@ -71,17 +75,23 @@ impl ReduceTo<SpinGlass<SimpleGraph, i32>> for MaxCut<SimpleGraph, i32> {
         // MaxCut wants to maximize edges cut, SpinGlass minimizes energy.
         // When J > 0 (antiferromagnetic), opposite spins lower energy.
         // So maximizing cut = minimizing Ising energy with J = w.
-        let interactions: Vec<((usize, usize), i32)> = edges_with_weights
+        let interactions: Vec<((usize, usize), i64)> = edges_with_weights
             .into_iter()
             .map(|(u, v, w)| ((u, v), w))
             .collect();
 
         // No onsite terms for pure MaxCut
-        let onsite = vec![0i32; n];
+        let onsite = vec![0i64; n];
 
-        let target = SpinGlass::<SimpleGraph, i32>::new(n, interactions, onsite);
+        let target =
+            SpinGlass::<SimpleGraph, i64>::new(n, interactions, onsite).map_err(|cause| {
+                crate::rules::ReductionError::construction::<
+                    MaxCut<SimpleGraph, i64>,
+                    SpinGlass<SimpleGraph, i64>,
+                >(cause)
+            })?;
 
-        ReductionMaxCutToSG { target }
+        Ok(ReductionMaxCutToSG { target })
     }
 }
 
@@ -102,8 +112,7 @@ where
         + num_traits::Zero
         + num_traits::Bounded
         + std::ops::AddAssign
-        + std::ops::Mul<Output = W>
-        + From<i32>,
+        + std::ops::Mul<Output = W>,
 {
     type Source = SpinGlass<SimpleGraph, W>;
     type Target = MaxCut<SimpleGraph, W>;
@@ -112,34 +121,46 @@ where
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        match self.ancilla {
-            None => target_solution.to_vec(),
-            Some(anc) => {
-                // If ancilla is 1, flip all bits; then remove ancilla
-                let mut sol = target_solution.to_vec();
-                if sol[anc] == 1 {
-                    for x in sol.iter_mut() {
-                        *x = 1 - *x;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            match self.ancilla {
+                None => target_solution
+                    .iter()
+                    .map(|&side| if side { 1 } else { -1 })
+                    .collect(),
+                Some(anc) => {
+                    // Normalize the ancilla to spin +1 so its edge contributes h_i * s_i.
+                    let mut sol = target_solution.to_vec();
+                    if !sol[anc] {
+                        for x in sol.iter_mut() {
+                            *x = !*x;
+                        }
                     }
+                    sol.remove(anc);
+                    sol.into_iter()
+                        .map(|side| if side { 1 } else { -1 })
+                        .collect()
                 }
-                sol.remove(anc);
-                sol
             }
-        }
+        })
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vertices = "num_spins",
+    transform = upper_bound {
+        num_vertices = "num_spins + 1",
         num_edges = "num_interactions + num_spins",
     }
 )]
-impl ReduceTo<MaxCut<SimpleGraph, i32>> for SpinGlass<SimpleGraph, i32> {
-    type Result = ReductionSGToMaxCut<i32>;
+impl ReduceTo<MaxCut<SimpleGraph, i64>> for SpinGlass<SimpleGraph, i64> {
+    type Result = ReductionSGToMaxCut<i64>;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_spins();
         let interactions = self.interactions();
         let fields = self.fields();
@@ -172,10 +193,10 @@ impl ReduceTo<MaxCut<SimpleGraph, i32>> for SpinGlass<SimpleGraph, i32> {
 
         let target = MaxCut::new(SimpleGraph::new(total_vertices, edges), weights);
 
-        ReductionSGToMaxCut {
+        Ok(ReductionSGToMaxCut {
             target,
             ancilla: ancilla_idx,
-        }
+        })
     }
 }
 
@@ -189,11 +210,13 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             build: || {
                 let (n, edges) = crate::topology::small_graphs::petersen();
                 let source = MaxCut::unweighted(SimpleGraph::new(n, edges));
-                crate::example_db::specs::rule_example_with_witness::<_, SpinGlass<SimpleGraph, i32>>(
+                crate::example_db::specs::rule_example_with_witness::<_, SpinGlass<SimpleGraph, i64>>(
                     source,
                     SolutionPair {
-                        source_config: vec![0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
-                        target_config: vec![0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
+                        source_config: serde_json::json!(vec![
+                            false, true, false, true, false, true, false, false, false, true
+                        ]),
+                        target_config: serde_json::json!(vec![-1, 1, -1, 1, -1, 1, -1, -1, -1, 1]),
                     },
                 )
             },
@@ -202,17 +225,19 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             id: "spinglass_to_maxcut",
             build: || {
                 let (n, edges) = crate::topology::small_graphs::petersen();
-                let couplings: Vec<((usize, usize), i32)> = edges
+                let couplings: Vec<((usize, usize), i64)> = edges
                     .iter()
                     .enumerate()
                     .map(|(i, &(u, v))| ((u, v), if i % 2 == 0 { 1 } else { -1 }))
                     .collect();
-                let source = SpinGlass::new(n, couplings, vec![0; n]);
-                crate::example_db::specs::rule_example_with_witness::<_, MaxCut<SimpleGraph, i32>>(
+                let source = SpinGlass::new(n, couplings, vec![0; n]).unwrap();
+                crate::example_db::specs::rule_example_with_witness::<_, MaxCut<SimpleGraph, i64>>(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 0, 1, 1, 1, 0, 1, 0, 0, 1],
-                        target_config: vec![1, 0, 1, 1, 1, 0, 1, 0, 0, 1],
+                        source_config: serde_json::json!(vec![1, -1, 1, 1, 1, -1, 1, -1, -1, 1]),
+                        target_config: serde_json::json!(vec![
+                            true, false, true, true, true, false, true, false, false, true
+                        ]),
                     },
                 )
             },
diff --git a/src/rules/spinglass_qubo.rs b/src/rules/spinglass_qubo.rs
index 41a670331..1a6a900ad 100644
--- a/src/rules/spinglass_qubo.rs
+++ b/src/rules/spinglass_qubo.rs
@@ -26,20 +26,26 @@ impl ReductionResult for ReductionQUBOToSG {
     }
 
     /// Solution maps directly (same binary encoding).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&spin| spin == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_spins = "num_vars",
-    }
+        num_interactions = "num_vars^2",
+    },
 )]
 impl ReduceTo<SpinGlass<SimpleGraph, f64>> for QUBO<f64> {
     type Result = ReductionQUBOToSG;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vars();
         let matrix = self.matrix();
 
@@ -81,40 +87,58 @@ impl ReduceTo<SpinGlass<SimpleGraph, f64>> for QUBO<f64> {
             }
         }
 
-        let target = SpinGlass::<SimpleGraph, f64>::new(n, interactions, onsite);
+        let target = SpinGlass::<SimpleGraph, f64>::new(n, interactions, onsite).map_err(
+            |cause| {
+                crate::rules::ReductionError::construction::<
+                    QUBO<f64>,
+                    SpinGlass<SimpleGraph, f64>,
+                >(cause)
+            },
+        )?;
 
-        ReductionQUBOToSG { target }
+        Ok(ReductionQUBOToSG { target })
     }
 }
 
 /// Result of reducing SpinGlass to QUBO.
 #[derive(Debug, Clone)]
-pub struct ReductionSGToQUBO {
-    target: QUBO<f64>,
+pub struct ReductionSGToQUBO<W = f64> {
+    target: QUBO<W>,
 }
 
-impl ReductionResult for ReductionSGToQUBO {
-    type Source = SpinGlass<SimpleGraph, f64>;
-    type Target = QUBO<f64>;
+impl<W> ReductionResult for ReductionSGToQUBO<W>
+where
+    W: crate::types::WeightElement + crate::types::NumericSize + crate::variant::VariantParam,
+{
+    type Source = SpinGlass<SimpleGraph, W>;
+    type Target = QUBO<W>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution
+            .iter()
+            .map(|&bit| if bit { 1 } else { -1 })
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_spins",
     }
 )]
 impl ReduceTo<QUBO<f64>> for SpinGlass<SimpleGraph, f64> {
-    type Result = ReductionSGToQUBO;
+    type Result = ReductionSGToQUBO<f64>;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_spins();
         let mut matrix = vec![vec![0.0; n]; n];
 
@@ -140,9 +164,69 @@ impl ReduceTo<QUBO<f64>> for SpinGlass<SimpleGraph, f64> {
             matrix[i][i] += 2.0 * h;
         }
 
-        let target = QUBO::from_matrix(matrix);
+        let target = QUBO::from_matrix(matrix).map_err(|message| {
+            crate::rules::ReductionError::construction::<SpinGlass<SimpleGraph, f64>, QUBO<f64>>(
+                message,
+            )
+        })?;
+
+        Ok(ReductionSGToQUBO { target })
+    }
+}
+
+#[reduction(
+    transform = exact {
+        num_vars = "num_spins",
+    }
+)]
+impl ReduceTo<QUBO<i64>> for SpinGlass<SimpleGraph, i64> {
+    type Result = ReductionSGToQUBO<i64>;
+
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let n = self.num_spins();
+        let mut matrix = vec![vec![0_i64; n]; n];
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<SpinGlass<SimpleGraph, i64>, QUBO<i64>>(
+                operation,
+            )
+        };
+
+        for ((i, j), coupling) in self.interactions() {
+            let interaction = coupling
+                .checked_mul(4)
+                .ok_or_else(|| overflow("scaling a spin-glass interaction"))?;
+            matrix[i][j] = matrix[i][j]
+                .checked_add(interaction)
+                .ok_or_else(|| overflow("summing QUBO interaction coefficients"))?;
+            let diagonal = coupling
+                .checked_mul(2)
+                .ok_or_else(|| overflow("scaling a spin-glass diagonal contribution"))?;
+            matrix[i][i] = matrix[i][i]
+                .checked_sub(diagonal)
+                .ok_or_else(|| overflow("summing QUBO diagonal coefficients"))?;
+            matrix[j][j] = matrix[j][j]
+                .checked_sub(diagonal)
+                .ok_or_else(|| overflow("summing QUBO diagonal coefficients"))?;
+        }
+
+        for (i, &field) in self.fields().iter().enumerate() {
+            let diagonal = field
+                .checked_mul(2)
+                .ok_or_else(|| overflow("scaling a spin-glass field"))?;
+            matrix[i][i] = matrix[i][i]
+                .checked_add(diagonal)
+                .ok_or_else(|| overflow("summing QUBO diagonal coefficients"))?;
+        }
 
-        ReductionSGToQUBO { target }
+        Ok(ReductionSGToQUBO {
+            target:
+                QUBO::from_matrix(matrix).map_err(
+                    crate::rules::ReductionError::construction::<
+                        SpinGlass<SimpleGraph, i64>,
+                        QUBO<i64>,
+                    >,
+                )?,
+        })
     }
 }
 
@@ -163,12 +247,14 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     let (i, j) = if u < v { (u, v) } else { (v, u) };
                     matrix[i][j] = if idx % 2 == 0 { 2.0 } else { -1.5 };
                 }
-                let source = QUBO::from_matrix(matrix);
+                let source = QUBO::from_matrix(matrix).unwrap();
                 crate::example_db::specs::rule_example_with_witness::<_, SpinGlass<SimpleGraph, f64>>(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 0, 1, 1, 1, 0, 1, 0, 0, 1],
-                        target_config: vec![1, 0, 1, 1, 1, 0, 1, 0, 0, 1],
+                        source_config: serde_json::json!(vec![
+                            true, false, true, true, true, false, true, false, false, true
+                        ]),
+                        target_config: serde_json::json!(vec![1, -1, 1, 1, 1, -1, 1, -1, -1, 1]),
                     },
                 )
             },
@@ -182,12 +268,28 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     .enumerate()
                     .map(|(i, &(u, v))| ((u, v), if i % 2 == 0 { 1.0 } else { -1.0 }))
                     .collect();
-                let source = SpinGlass::new(n, couplings, vec![0.0; n]);
+                let source = SpinGlass::new(n, couplings, vec![0.0; n]).unwrap();
                 crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
                     source,
                     SolutionPair {
-                        source_config: vec![1, 0, 1, 1, 1, 0, 1, 0, 0, 1],
-                        target_config: vec![1, 0, 1, 1, 1, 0, 1, 0, 0, 1],
+                        source_config: serde_json::json!(vec![1, -1, 1, 1, 1, -1, 1, -1, -1, 1]),
+                        target_config: serde_json::json!(vec![
+                            true, false, true, true, true, false, true, false, false, true
+                        ]),
+                    },
+                )
+            },
+        },
+        crate::example_db::specs::RuleExampleSpec {
+            id: "integer_spinglass_to_qubo",
+            build: || {
+                let source =
+                    SpinGlass::<SimpleGraph, i64>::new(2, vec![((0, 1), 1)], vec![0, 0]).unwrap();
+                crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
+                    source,
+                    SolutionPair {
+                        source_config: serde_json::json!([1, -1]),
+                        target_config: serde_json::json!([true, false]),
                     },
                 )
             },
diff --git a/src/rules/stackercrane_ilp.rs b/src/rules/stackercrane_ilp.rs
index 5dbbd3ad0..5e9a0d7d9 100644
--- a/src/rules/stackercrane_ilp.rs
+++ b/src/rules/stackercrane_ilp.rs
@@ -7,7 +7,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::StackerCrane;
 use crate::reduction;
-use crate::rules::ilp_helpers::one_hot_decode;
+use crate::rules::ilp_helpers::{mccormick_product, one_hot_decode};
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing StackerCrane to ILP.
@@ -31,29 +31,40 @@ impl ReductionResult for ReductionSCToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Decode the permutation: for each position p, find the arc a with x_{a,p} = 1
-        one_hot_decode(target_solution, self.num_arcs, self.num_arcs, 0)
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // Decode the permutation: for each position p, find the arc a with x_{a,p} = 1
+            one_hot_decode(target_solution, self.num_arcs, self.num_arcs, 0)?
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_arcs * num_arcs + num_arcs * num_arcs * num_arcs",
-        num_constraints = "num_arcs + num_arcs + 3 * num_arcs * num_arcs * num_arcs",
+        num_constraints = "num_arcs + num_arcs + 4 * num_arcs * num_arcs * num_arcs",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for StackerCrane {
     type Result = ReductionSCToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.num_arcs();
 
         if m == 0 {
-            return ReductionSCToILP {
-                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize),
+            return Ok(ReductionSCToILP {
+                target: ILP::new(0, vec![], vec![], ObjectiveSense::Minimize)
+                    .map_err(Self::target_construction)?,
                 num_arcs: 0,
-            };
+            });
         }
 
         let num_vars = m * m + m * m * m;
@@ -74,14 +85,14 @@ impl ReduceTo<ILP<bool>> for StackerCrane {
 
         // Each arc assigned to exactly one position: sum_p x_{i,p} = 1 for all i
         for i in 0..m {
-            let terms: Vec<(usize, f64)> = (0..m).map(|p| (x_idx(i, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..m).map(|p| (x_idx(i, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Each position assigned exactly one arc: sum_i x_{i,p} = 1 for all p
         for p in 0..m {
-            let terms: Vec<(usize, f64)> = (0..m).map(|i| (x_idx(i, p), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..m).map(|i| (x_idx(i, p), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // McCormick linearization for z_{i,j,p} = x_{i,p} * x_{j,(p+1) mod m}
@@ -92,29 +103,15 @@ impl ReduceTo<ILP<bool>> for StackerCrane {
                     let head_i = self.arcs()[i].1;
                     let tail_j = self.arcs()[j].0;
 
+                    // The product relation is required for every pair, even
+                    // unreachable ones: z = 0 alone does not forbid adjacency.
+                    constraints.extend(mccormick_product(
+                        z_idx(i, j, p),
+                        x_idx(i, p),
+                        x_idx(j, next_p),
+                    ));
                     if distances[head_i][tail_j] == i64::MAX {
-                        // Infeasible pair: z_{i,j,p} = 0
-                        constraints.push(LinearConstraint::eq(vec![(z_idx(i, j, p), 1.0)], 0.0));
-                    } else {
-                        // z <= x_{i,p}
-                        constraints.push(LinearConstraint::le(
-                            vec![(z_idx(i, j, p), 1.0), (x_idx(i, p), -1.0)],
-                            0.0,
-                        ));
-                        // z <= x_{j, next_p}
-                        constraints.push(LinearConstraint::le(
-                            vec![(z_idx(i, j, p), 1.0), (x_idx(j, next_p), -1.0)],
-                            0.0,
-                        ));
-                        // z >= x_{i,p} + x_{j, next_p} - 1
-                        constraints.push(LinearConstraint::le(
-                            vec![
-                                (x_idx(i, p), 1.0),
-                                (x_idx(j, next_p), 1.0),
-                                (z_idx(i, j, p), -1.0),
-                            ],
-                            1.0,
-                        ));
+                        constraints.push(LinearConstraint::eq(vec![(z_idx(i, j, p), 1)], 0));
                     }
                 }
             }
@@ -130,18 +127,19 @@ impl ReduceTo<ILP<bool>> for StackerCrane {
                     let tail_j = self.arcs()[j].0;
                     let dist = distances[head_i][tail_j];
                     if dist < i64::MAX {
-                        objective.push((z_idx(i, j, p), dist as f64));
+                        objective.push((z_idx(i, j, p), dist));
                     }
                 }
             }
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionSCToILP {
+        Ok(ReductionSCToILP {
             target,
             num_arcs: m,
-        }
+        })
     }
 }
 
@@ -149,9 +147,9 @@ impl ReduceTo<ILP<bool>> for StackerCrane {
 fn all_pairs_shortest_paths(
     n: usize,
     arcs: &[(usize, usize)],
-    arc_lengths: &[i32],
+    arc_lengths: &[i64],
     edges: &[(usize, usize)],
-    edge_lengths: &[i32],
+    edge_lengths: &[i64],
 ) -> Vec<Vec<i64>> {
     let mut dist = vec![vec![i64::MAX; n]; n];
     for (i, row) in dist.iter_mut().enumerate() {
@@ -160,7 +158,7 @@ fn all_pairs_shortest_paths(
 
     // Directed arcs
     for (&(u, v), &length) in arcs.iter().zip(arc_lengths) {
-        let cost = i64::from(length);
+        let cost = length;
         if cost < dist[u][v] {
             dist[u][v] = cost;
         }
@@ -168,7 +166,7 @@ fn all_pairs_shortest_paths(
 
     // Undirected edges (both directions)
     for (&(u, v), &length) in edges.iter().zip(edge_lengths) {
-        let cost = i64::from(length);
+        let cost = length;
         if cost < dist[u][v] {
             dist[u][v] = cost;
         }
diff --git a/src/rules/steinertree_ilp.rs b/src/rules/steinertree_ilp.rs
index f9c77eb30..e19b19e68 100644
--- a/src/rules/steinertree_ilp.rs
+++ b/src/rules/steinertree_ilp.rs
@@ -1,11 +1,8 @@
-//! Reduction from SteinerTree to ILP (Integer Linear Programming).
+//! Exact Steiner-tree formulation for signed edge weights.
 //!
-//! Uses the standard rooted multi-commodity flow formulation:
-//! - Variables: edge selectors `y_e` plus directed flow variables `f^t_(u,v)`
-//!   for each non-root terminal `t`
-//! - Constraints: flow conservation for each commodity and capacity linking
-//!   `f^t_(u,v) <= y_e`
-//! - Objective: minimize the total weight of selected edges
+//! Binary vertex selectors and rooted flows connect every selected vertex.
+//! Endpoint linking and |selected edges| = |selected vertices| - 1 then enforce
+//! a tree, independently of the objective's signs.
 
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::SteinerTree;
@@ -13,12 +10,8 @@ use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
 
-/// Result of reducing SteinerTree to ILP.
-///
-/// Variable layout (all binary):
-/// - `y_e` for each undirected source edge `e` (indices `0..m`)
-/// - `f^t_(u,v)` and `f^t_(v,u)` for each non-root terminal `t` and each source edge
-///   `(u, v)` (indices `m..m + 2m(k-1)`)
+/// Binary layout: m edge selectors, n vertex selectors, then 2m flow arcs
+/// for each vertex other than the first terminal (in vertex-index order).
 #[derive(Debug, Clone)]
 pub struct ReductionSteinerTreeToILP {
     target: ILP<bool>,
@@ -26,102 +19,146 @@ pub struct ReductionSteinerTreeToILP {
 }
 
 impl ReductionResult for ReductionSteinerTreeToILP {
-    type Source = SteinerTree<SimpleGraph, i32>;
+    type Source = SteinerTree<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_edges].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        if crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?
+            .value
+            .is_none()
+        {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target ILP assignment is infeasible",
+            ));
+        }
+        Ok(target_solution[..self.num_edges]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "num_edges + 2 * num_edges * (num_terminals - 1)",
-        num_constraints = "num_vertices * (num_terminals - 1) + 2 * num_edges * (num_terminals - 1)",
+    transform = exact {
+        num_vars = "num_edges + num_vertices + 2 * num_edges * (num_vertices - 1)",
+        num_constraints = "num_vertices * (num_vertices - 1) + 2 * num_edges * num_vertices + num_terminals + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for SteinerTree<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for SteinerTree<SimpleGraph, i64> {
     type Result = ReductionSteinerTreeToILP;
 
-    fn reduce_to(&self) -> Self::Result {
-        assert!(
-            self.edge_weights().iter().all(|&weight| weight > 0),
-            "SteinerTree -> ILP requires strictly positive edge weights (zero-weight edges should be contracted beforehand)"
-        );
-
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let m = self.num_edges();
+        let (num_vars, num_constraints) = tree_ilp_sizes(n, m, self.terminals().len())?;
+        // The source constructor requires at least two distinct terminals.
         let root = self.terminals()[0];
-        let non_root_terminals = &self.terminals()[1..];
         let edges = self.graph().edges();
-        let num_vars = m + 2 * m * non_root_terminals.len();
-        let num_constraints = n * non_root_terminals.len() + 2 * m * non_root_terminals.len();
+        let vertex_var = |v: usize| m + v;
+        let flow_var = |commodity: usize, edge: usize, dir: usize| {
+            m + n + commodity * (2 * m) + 2 * edge + dir
+        };
         let mut constraints = Vec::with_capacity(num_constraints);
 
-        let edge_var = |edge_idx: usize| edge_idx;
-        let flow_var = |terminal_pos: usize, edge_idx: usize, dir: usize| -> usize {
-            m + terminal_pos * 2 * m + 2 * edge_idx + dir
-        };
+        for (e, &(u, v)) in edges.iter().enumerate() {
+            for endpoint in [u, v] {
+                constraints.push(LinearConstraint::le(
+                    vec![(e, 1), (vertex_var(endpoint), -1)],
+                    0,
+                ));
+            }
+        }
+        for &terminal in self.terminals() {
+            constraints.push(LinearConstraint::eq(vec![(vertex_var(terminal), 1)], 1));
+        }
+        let cardinality = (0..m)
+            .map(|e| (e, 1))
+            .chain((0..n).map(|v| (vertex_var(v), -1)))
+            .collect();
+        constraints.push(LinearConstraint::eq(cardinality, -1));
 
-        for (terminal_pos, &terminal) in non_root_terminals.iter().enumerate() {
+        for (commodity, sink) in (0..n).filter(|&v| v != root).enumerate() {
             for vertex in 0..n {
                 let mut terms = Vec::new();
-                for (edge_idx, &(u, v)) in edges.iter().enumerate() {
-                    if v == vertex {
-                        terms.push((flow_var(terminal_pos, edge_idx, 0), 1.0));
-                        terms.push((flow_var(terminal_pos, edge_idx, 1), -1.0));
+                for (edge, &(u, v)) in edges.iter().enumerate() {
+                    if vertex == u {
+                        terms.push((flow_var(commodity, edge, 0), -1));
+                        terms.push((flow_var(commodity, edge, 1), 1));
                     }
-                    if u == vertex {
-                        terms.push((flow_var(terminal_pos, edge_idx, 0), -1.0));
-                        terms.push((flow_var(terminal_pos, edge_idx, 1), 1.0));
+                    if vertex == v {
+                        terms.push((flow_var(commodity, edge, 0), 1));
+                        terms.push((flow_var(commodity, edge, 1), -1));
                     }
                 }
-
-                let rhs = if vertex == root {
-                    -1.0
-                } else if vertex == terminal {
-                    1.0
-                } else {
-                    0.0
-                };
-                constraints.push(LinearConstraint::eq(terms, rhs));
+                // Inflow - outflow = z_sink at sink and -z_sink at root.
+                if vertex == root {
+                    terms.push((vertex_var(sink), 1));
+                } else if vertex == sink {
+                    terms.push((vertex_var(sink), -1));
+                }
+                constraints.push(LinearConstraint::eq(terms, 0));
             }
-        }
-
-        for terminal_pos in 0..non_root_terminals.len() {
-            for edge_idx in 0..m {
-                let selector = edge_var(edge_idx);
-                constraints.push(LinearConstraint::le(
-                    vec![(flow_var(terminal_pos, edge_idx, 0), 1.0), (selector, -1.0)],
-                    0.0,
-                ));
-                constraints.push(LinearConstraint::le(
-                    vec![(flow_var(terminal_pos, edge_idx, 1), 1.0), (selector, -1.0)],
-                    0.0,
-                ));
+            for edge in 0..m {
+                for dir in 0..2 {
+                    constraints.push(LinearConstraint::le(
+                        vec![(flow_var(commodity, edge, dir), 1), (edge, -1)],
+                        0,
+                    ));
+                }
             }
         }
-
-        let objective: Vec<(usize, f64)> = self
+        let objective = self
             .edge_weights()
             .iter()
             .enumerate()
-            .map(|(edge_idx, &weight)| (edge_var(edge_idx), weight as f64))
+            .map(|(e, &w)| (e, w))
             .collect();
-
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
-
-        ReductionSteinerTreeToILP {
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionSteinerTreeToILP {
             target,
             num_edges: m,
-        }
+        })
     }
 }
 
+/// Bounds for all offsets and allocation sizes; n >= 2 is a source invariant.
+fn tree_ilp_sizes(
+    n: usize,
+    m: usize,
+    k: usize,
+) -> Result<(usize, usize), crate::rules::ReductionError> {
+    let overflow = || {
+        crate::rules::ReductionError::integer_overflow::<SteinerTree<SimpleGraph, i64>, ILP<bool>>(
+            "counting Steiner tree ILP variables and constraints",
+        )
+    };
+    let non_root = n.checked_sub(1).ok_or_else(overflow)?;
+    let arcs = m.checked_mul(2).ok_or_else(overflow)?;
+    let vars = arcs
+        .checked_mul(non_root)
+        .and_then(|x| x.checked_add(m))
+        .and_then(|x| x.checked_add(n))
+        .ok_or_else(overflow)?;
+    let rows = n
+        .checked_mul(non_root)
+        .and_then(|x| arcs.checked_mul(n).and_then(|a| x.checked_add(a)))
+        .and_then(|x| x.checked_add(k))
+        .and_then(|x| x.checked_add(1))
+        .ok_or_else(overflow)?;
+    Ok((vars, rows))
+}
+
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
     vec![crate::example_db::specs::RuleExampleSpec {
diff --git a/src/rules/steinertreeingraphs_ilp.rs b/src/rules/steinertreeingraphs_ilp.rs
index def751b4b..af256448f 100644
--- a/src/rules/steinertreeingraphs_ilp.rs
+++ b/src/rules/steinertreeingraphs_ilp.rs
@@ -26,36 +26,56 @@ pub struct ReductionSTIGToILP {
 }
 
 impl ReductionResult for ReductionSTIGToILP {
-    type Source = SteinerTreeInGraphs<SimpleGraph, i32>;
+    type Source = SteinerTreeInGraphs<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_edges].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_edges]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_edges + 2 * num_edges * (num_terminals - 1)",
         num_constraints = "num_vertices * (num_terminals - 1) + 2 * num_edges * (num_terminals - 1)",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for SteinerTreeInGraphs<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for SteinerTreeInGraphs<SimpleGraph, i64> {
     type Result = ReductionSTIGToILP;
 
-    fn reduce_to(&self) -> Self::Result {
-        assert!(
-            self.weights().iter().all(|&w| w > 0),
-            "SteinerTreeInGraphs -> ILP requires strictly positive edge weights"
-        );
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        if self.weights().iter().any(|&weight| weight <= 0) {
+            return Err(crate::rules::ReductionError::invalid_target::<
+                SteinerTreeInGraphs<SimpleGraph, i64>,
+                ILP<bool>,
+            >(
+                "ILP construction requires strictly positive edge weights"
+            ));
+        }
 
         let n = self.num_vertices();
         let m = self.num_edges();
-        let root = self.terminals()[0];
+        let root = *self.terminals().first().ok_or_else(|| {
+            crate::rules::ReductionError::invalid_target::<
+                SteinerTreeInGraphs<SimpleGraph, i64>,
+                ILP<bool>,
+            >("source must contain at least one terminal")
+        })?;
         let non_root_terminals = &self.terminals()[1..];
         let edges = self.graph().edges();
         let num_vars = m + 2 * m * non_root_terminals.len();
@@ -72,21 +92,21 @@ impl ReduceTo<ILP<bool>> for SteinerTreeInGraphs<SimpleGraph, i32> {
                 let mut terms = Vec::new();
                 for (edge_idx, &(u, v)) in edges.iter().enumerate() {
                     if v == vertex {
-                        terms.push((flow_var(terminal_pos, edge_idx, 0), 1.0));
-                        terms.push((flow_var(terminal_pos, edge_idx, 1), -1.0));
+                        terms.push((flow_var(terminal_pos, edge_idx, 0), 1));
+                        terms.push((flow_var(terminal_pos, edge_idx, 1), -1));
                     }
                     if u == vertex {
-                        terms.push((flow_var(terminal_pos, edge_idx, 0), -1.0));
-                        terms.push((flow_var(terminal_pos, edge_idx, 1), 1.0));
+                        terms.push((flow_var(terminal_pos, edge_idx, 0), -1));
+                        terms.push((flow_var(terminal_pos, edge_idx, 1), 1));
                     }
                 }
 
                 let rhs = if vertex == root {
-                    -1.0
+                    -1
                 } else if vertex == terminal {
-                    1.0
+                    1
                 } else {
-                    0.0
+                    0
                 };
                 constraints.push(LinearConstraint::eq(terms, rhs));
             }
@@ -97,30 +117,31 @@ impl ReduceTo<ILP<bool>> for SteinerTreeInGraphs<SimpleGraph, i32> {
             for edge_idx in 0..m {
                 let selector = edge_var(edge_idx);
                 constraints.push(LinearConstraint::le(
-                    vec![(flow_var(terminal_pos, edge_idx, 0), 1.0), (selector, -1.0)],
-                    0.0,
+                    vec![(flow_var(terminal_pos, edge_idx, 0), 1), (selector, -1)],
+                    0,
                 ));
                 constraints.push(LinearConstraint::le(
-                    vec![(flow_var(terminal_pos, edge_idx, 1), 1.0), (selector, -1.0)],
-                    0.0,
+                    vec![(flow_var(terminal_pos, edge_idx, 1), 1), (selector, -1)],
+                    0,
                 ));
             }
         }
 
         // Objective: minimize total weight
         let edge_weights = self.weights();
-        let objective: Vec<(usize, f64)> = edge_weights
+        let objective: Vec<(usize, i64)> = edge_weights
             .iter()
             .enumerate()
-            .map(|(edge_idx, w)| (edge_var(edge_idx), w.to_sum() as f64))
+            .map(|(edge_idx, weight)| (edge_var(edge_idx), weight.to_sum()))
             .collect();
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionSTIGToILP {
+        Ok(ReductionSTIGToILP {
             target,
             num_edges: m,
-        }
+        })
     }
 }
 
diff --git a/src/rules/stringtostringcorrection_ilp.rs b/src/rules/stringtostringcorrection_ilp.rs
index 13b33de2a..1f6cf33d2 100644
--- a/src/rules/stringtostringcorrection_ilp.rs
+++ b/src/rules/stringtostringcorrection_ilp.rs
@@ -54,64 +54,73 @@ impl ReductionResult for ReductionSTSCToILP {
     }
 
     /// Extract operation sequence from ILP solution.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.n;
-        let k = self.bound;
-        let noop_code = 2 * n;
-
-        if n == 0 {
-            return vec![noop_code; k];
-        }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.n;
+            let k = self.bound;
+            let noop_code = 2 * n;
+
+            if n == 0 {
+                return Ok(vec![noop_code; k]);
+            }
 
-        let nm1 = n.saturating_sub(1);
-        let mut ops = Vec::with_capacity(k);
+            let nm1 = n.saturating_sub(1);
+            let mut ops = Vec::with_capacity(k);
 
-        for t in 1..=k {
-            // current length at step t-1
-            let current_len = (0..n)
-                .filter(|&p| target_solution[idx_e(n, k, t - 1, p)] == 0)
-                .count();
-
-            if target_solution[idx_nu(n, k, t)] == 1 {
-                ops.push(noop_code);
-            } else {
-                let mut found = false;
-                for j in 0..n {
-                    if target_solution[idx_d(n, k, t, j)] == 1 {
-                        ops.push(j);
-                        found = true;
-                        break;
-                    }
+            for t in 1..=k {
+                // current length at step t-1
+                let current_len = (0..n)
+                    .filter(|&p| target_solution[idx_e(n, k, t - 1, p)] == 0)
+                    .count();
+
+                let mut selected = Vec::new();
+                if target_solution[idx_nu(n, k, t)] == 1 {
+                    selected.push(noop_code);
                 }
-                if !found {
-                    for j in 0..nm1 {
-                        if target_solution[idx_s(n, k, t, j)] == 1 {
-                            ops.push(current_len + j);
-                            found = true;
-                            break;
-                        }
+                selected.extend((0..n).filter(|&j| target_solution[idx_d(n, k, t, j)] == 1));
+                selected.extend(
+                    (0..nm1)
+                        .filter(|&j| target_solution[idx_s(n, k, t, j)] == 1)
+                        .map(|j| current_len + j),
+                );
+                match selected.as_slice() {
+                    [operation] => ops.push(*operation),
+                    [] => {
+                        return Err(crate::rules::ExtractionError::invalid(format!(
+                            "edit step {t} has no selected operation"
+                        )))
                     }
-                    if !found {
-                        ops.push(noop_code);
+                    _ => {
+                        return Err(crate::rules::ExtractionError::invalid(format!(
+                            "edit step {t} has multiple selected operations"
+                        )))
                     }
                 }
             }
-        }
-        ops
+            ops
+        })
     }
 }
 
 #[reduction(
-    overhead = {
-        num_vars = "(bound + 1) * source_length * source_length + (bound + 1) * source_length + 2 * bound * source_length",
-        num_constraints = "(bound + 1) * source_length * source_length",
+    transform = upper_bound {
+        num_vars = "(bound + 1) * source_length^2 + (bound + 1) * source_length + 2 * bound * source_length + bound",
+        num_constraints = "4 * bound * source_length^3 + 2 * bound * source_length^2 + source_length^2 + 6 * bound * source_length + 5 * source_length + bound",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for StringToStringCorrection {
     type Result = ReductionSTSCToILP;
 
     #[allow(clippy::needless_range_loop)]
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.source_length();
         let m = self.target_length();
         let k = self.bound();
@@ -120,16 +129,17 @@ impl ReduceTo<ILP<bool>> for StringToStringCorrection {
 
         // If infeasible by length check, return trivially infeasible ILP
         if m > n || m < n.saturating_sub(k) {
-            return ReductionSTSCToILP {
+            return Ok(ReductionSTSCToILP {
                 target: ILP::new(
                     0,
-                    vec![LinearConstraint::le(vec![], -1.0)],
+                    vec![LinearConstraint::le(vec![], -1)],
                     vec![],
                     ObjectiveSense::Minimize,
-                ),
+                )
+                .map_err(Self::target_construction)?,
                 n,
                 bound: k,
-            };
+            });
         }
 
         // n == 0 edge case: source and target both empty, all no-ops
@@ -137,13 +147,14 @@ impl ReduceTo<ILP<bool>> for StringToStringCorrection {
             let nv = k;
             let mut constraints = Vec::new();
             for t in 1..=k {
-                constraints.push(LinearConstraint::eq(vec![(t - 1, 1.0)], 1.0));
+                constraints.push(LinearConstraint::eq(vec![(t - 1, 1)], 1));
             }
-            return ReductionSTSCToILP {
-                target: ILP::new(nv, constraints, vec![], ObjectiveSense::Minimize),
+            return Ok(ReductionSTSCToILP {
+                target: ILP::new(nv, constraints, vec![], ObjectiveSense::Minimize)
+                    .map_err(Self::target_construction)?,
                 n,
                 bound: k,
-            };
+            });
         }
 
         let nm1 = n.saturating_sub(1);
@@ -156,19 +167,19 @@ impl ReduceTo<ILP<bool>> for StringToStringCorrection {
         // e_{t,p} + Σ_i z_{t,p,i} = 1  ∀ t,p
         for t in 0..=k {
             for p in 0..n {
-                let mut terms = vec![(idx_e(n, k, t, p), 1.0)];
+                let mut terms = vec![(idx_e(n, k, t, p), 1)];
                 for i in 0..n {
-                    terms.push((idx_z(n, t, p, i), 1.0));
+                    terms.push((idx_z(n, t, p, i), 1));
                 }
-                constraints.push(LinearConstraint::eq(terms, 1.0));
+                constraints.push(LinearConstraint::eq(terms, 1));
             }
         }
 
         // Σ_p z_{t,p,i} <= 1  ∀ t,i
         for t in 0..=k {
             for i in 0..n {
-                let terms: Vec<(usize, f64)> = (0..n).map(|p| (idx_z(n, t, p, i), 1.0)).collect();
-                constraints.push(LinearConstraint::le(terms, 1.0));
+                let terms: Vec<(usize, i64)> = (0..n).map(|p| (idx_z(n, t, p, i), 1)).collect();
+                constraints.push(LinearConstraint::le(terms, 1));
             }
         }
 
@@ -176,52 +187,52 @@ impl ReduceTo<ILP<bool>> for StringToStringCorrection {
         for t in 0..=k {
             for p in 0..nm1 {
                 constraints.push(LinearConstraint::le(
-                    vec![(idx_e(n, k, t, p), 1.0), (idx_e(n, k, t, p + 1), -1.0)],
-                    0.0,
+                    vec![(idx_e(n, k, t, p), 1), (idx_e(n, k, t, p + 1), -1)],
+                    0,
                 ));
             }
         }
 
         // === Initial state ===
         for p in 0..n {
-            constraints.push(LinearConstraint::eq(vec![(idx_z(n, 0, p, p), 1.0)], 1.0));
+            constraints.push(LinearConstraint::eq(vec![(idx_z(n, 0, p, p), 1)], 1));
             for i in 0..n {
                 if i != p {
-                    constraints.push(LinearConstraint::eq(vec![(idx_z(n, 0, p, i), 1.0)], 0.0));
+                    constraints.push(LinearConstraint::eq(vec![(idx_z(n, 0, p, i), 1)], 0));
                 }
             }
-            constraints.push(LinearConstraint::eq(vec![(idx_e(n, k, 0, p), 1.0)], 0.0));
+            constraints.push(LinearConstraint::eq(vec![(idx_e(n, k, 0, p), 1)], 0));
         }
 
         // === Operation choice ===
         for t in 1..=k {
             let mut terms = Vec::new();
             for j in 0..n {
-                terms.push((idx_d(n, k, t, j), 1.0));
+                terms.push((idx_d(n, k, t, j), 1));
             }
             for j in 0..nm1 {
-                terms.push((idx_s(n, k, t, j), 1.0));
+                terms.push((idx_s(n, k, t, j), 1));
             }
-            terms.push((idx_nu(n, k, t), 1.0));
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            terms.push((idx_nu(n, k, t), 1));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Legality
         for t in 1..=k {
             for j in 0..n {
                 constraints.push(LinearConstraint::le(
-                    vec![(idx_d(n, k, t, j), 1.0), (idx_e(n, k, t - 1, j), 1.0)],
-                    1.0,
+                    vec![(idx_d(n, k, t, j), 1), (idx_e(n, k, t - 1, j), 1)],
+                    1,
                 ));
             }
             for j in 0..nm1 {
                 constraints.push(LinearConstraint::le(
-                    vec![(idx_s(n, k, t, j), 1.0), (idx_e(n, k, t - 1, j), 1.0)],
-                    1.0,
+                    vec![(idx_s(n, k, t, j), 1), (idx_e(n, k, t - 1, j), 1)],
+                    1,
                 ));
                 constraints.push(LinearConstraint::le(
-                    vec![(idx_s(n, k, t, j), 1.0), (idx_e(n, k, t - 1, j + 1), 1.0)],
-                    1.0,
+                    vec![(idx_s(n, k, t, j), 1), (idx_e(n, k, t - 1, j + 1), 1)],
+                    1,
                 ));
             }
         }
@@ -233,19 +244,19 @@ impl ReduceTo<ILP<bool>> for StringToStringCorrection {
                     // No-op
                     constraints.push(LinearConstraint::le(
                         vec![
-                            (idx_z(n, t, p, i), 1.0),
-                            (idx_z(n, t - 1, p, i), -1.0),
-                            (idx_nu(n, k, t), 1.0),
+                            (idx_z(n, t, p, i), 1),
+                            (idx_z(n, t - 1, p, i), -1),
+                            (idx_nu(n, k, t), 1),
                         ],
-                        1.0,
+                        1,
                     ));
                     constraints.push(LinearConstraint::le(
                         vec![
-                            (idx_z(n, t - 1, p, i), 1.0),
-                            (idx_z(n, t, p, i), -1.0),
-                            (idx_nu(n, k, t), 1.0),
+                            (idx_z(n, t - 1, p, i), 1),
+                            (idx_z(n, t, p, i), -1),
+                            (idx_nu(n, k, t), 1),
                         ],
-                        1.0,
+                        1,
                     ));
 
                     // Delete at position j
@@ -254,43 +265,43 @@ impl ReduceTo<ILP<bool>> for StringToStringCorrection {
                             // Before deleted position: unchanged
                             constraints.push(LinearConstraint::le(
                                 vec![
-                                    (idx_z(n, t, p, i), 1.0),
-                                    (idx_z(n, t - 1, p, i), -1.0),
-                                    (idx_d(n, k, t, j), 1.0),
+                                    (idx_z(n, t, p, i), 1),
+                                    (idx_z(n, t - 1, p, i), -1),
+                                    (idx_d(n, k, t, j), 1),
                                 ],
-                                1.0,
+                                1,
                             ));
                             constraints.push(LinearConstraint::le(
                                 vec![
-                                    (idx_z(n, t - 1, p, i), 1.0),
-                                    (idx_z(n, t, p, i), -1.0),
-                                    (idx_d(n, k, t, j), 1.0),
+                                    (idx_z(n, t - 1, p, i), 1),
+                                    (idx_z(n, t, p, i), -1),
+                                    (idx_d(n, k, t, j), 1),
                                 ],
-                                1.0,
+                                1,
                             ));
                         } else if p + 1 < n {
                             // j <= p < n-1: shift from p+1
                             constraints.push(LinearConstraint::le(
                                 vec![
-                                    (idx_z(n, t, p, i), 1.0),
-                                    (idx_z(n, t - 1, p + 1, i), -1.0),
-                                    (idx_d(n, k, t, j), 1.0),
+                                    (idx_z(n, t, p, i), 1),
+                                    (idx_z(n, t - 1, p + 1, i), -1),
+                                    (idx_d(n, k, t, j), 1),
                                 ],
-                                1.0,
+                                1,
                             ));
                             constraints.push(LinearConstraint::le(
                                 vec![
-                                    (idx_z(n, t - 1, p + 1, i), 1.0),
-                                    (idx_z(n, t, p, i), -1.0),
-                                    (idx_d(n, k, t, j), 1.0),
+                                    (idx_z(n, t - 1, p + 1, i), 1),
+                                    (idx_z(n, t, p, i), -1),
+                                    (idx_d(n, k, t, j), 1),
                                 ],
-                                1.0,
+                                1,
                             ));
                         } else {
                             // p == n-1: last slot must be empty
                             constraints.push(LinearConstraint::le(
-                                vec![(idx_z(n, t, n - 1, i), 1.0), (idx_d(n, k, t, j), 1.0)],
-                                1.0,
+                                vec![(idx_z(n, t, n - 1, i), 1), (idx_d(n, k, t, j), 1)],
+                                1,
                             ));
                         }
                     }
@@ -300,54 +311,54 @@ impl ReduceTo<ILP<bool>> for StringToStringCorrection {
                         if p != j && p != j + 1 {
                             constraints.push(LinearConstraint::le(
                                 vec![
-                                    (idx_z(n, t, p, i), 1.0),
-                                    (idx_z(n, t - 1, p, i), -1.0),
-                                    (idx_s(n, k, t, j), 1.0),
+                                    (idx_z(n, t, p, i), 1),
+                                    (idx_z(n, t - 1, p, i), -1),
+                                    (idx_s(n, k, t, j), 1),
                                 ],
-                                1.0,
+                                1,
                             ));
                             constraints.push(LinearConstraint::le(
                                 vec![
-                                    (idx_z(n, t - 1, p, i), 1.0),
-                                    (idx_z(n, t, p, i), -1.0),
-                                    (idx_s(n, k, t, j), 1.0),
+                                    (idx_z(n, t - 1, p, i), 1),
+                                    (idx_z(n, t, p, i), -1),
+                                    (idx_s(n, k, t, j), 1),
                                 ],
-                                1.0,
+                                1,
                             ));
                         } else if p == j {
                             constraints.push(LinearConstraint::le(
                                 vec![
-                                    (idx_z(n, t, j, i), 1.0),
-                                    (idx_z(n, t - 1, j + 1, i), -1.0),
-                                    (idx_s(n, k, t, j), 1.0),
+                                    (idx_z(n, t, j, i), 1),
+                                    (idx_z(n, t - 1, j + 1, i), -1),
+                                    (idx_s(n, k, t, j), 1),
                                 ],
-                                1.0,
+                                1,
                             ));
                             constraints.push(LinearConstraint::le(
                                 vec![
-                                    (idx_z(n, t - 1, j + 1, i), 1.0),
-                                    (idx_z(n, t, j, i), -1.0),
-                                    (idx_s(n, k, t, j), 1.0),
+                                    (idx_z(n, t - 1, j + 1, i), 1),
+                                    (idx_z(n, t, j, i), -1),
+                                    (idx_s(n, k, t, j), 1),
                                 ],
-                                1.0,
+                                1,
                             ));
                         } else {
                             // p == j+1
                             constraints.push(LinearConstraint::le(
                                 vec![
-                                    (idx_z(n, t, j + 1, i), 1.0),
-                                    (idx_z(n, t - 1, j, i), -1.0),
-                                    (idx_s(n, k, t, j), 1.0),
+                                    (idx_z(n, t, j + 1, i), 1),
+                                    (idx_z(n, t - 1, j, i), -1),
+                                    (idx_s(n, k, t, j), 1),
                                 ],
-                                1.0,
+                                1,
                             ));
                             constraints.push(LinearConstraint::le(
                                 vec![
-                                    (idx_z(n, t - 1, j, i), 1.0),
-                                    (idx_z(n, t, j + 1, i), -1.0),
-                                    (idx_s(n, k, t, j), 1.0),
+                                    (idx_z(n, t - 1, j, i), 1),
+                                    (idx_z(n, t, j + 1, i), -1),
+                                    (idx_s(n, k, t, j), 1),
                                 ],
-                                1.0,
+                                1,
                             ));
                         }
                     }
@@ -357,22 +368,23 @@ impl ReduceTo<ILP<bool>> for StringToStringCorrection {
 
         // === Final state equals target ===
         for p in 0..m {
-            let terms: Vec<(usize, f64)> = (0..n)
+            let terms: Vec<(usize, i64)> = (0..n)
                 .filter(|&i| source[i] == target[p])
-                .map(|i| (idx_z(n, k, p, i), 1.0))
+                .map(|i| (idx_z(n, k, p, i), 1))
                 .collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
         for p in m..n {
-            constraints.push(LinearConstraint::eq(vec![(idx_e(n, k, k, p), 1.0)], 1.0));
+            constraints.push(LinearConstraint::eq(vec![(idx_e(n, k, k, p), 1)], 1));
         }
 
-        let target_ilp = ILP::new(nv, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionSTSCToILP {
+        let target_ilp = ILP::new(nv, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionSTSCToILP {
             target: target_ilp,
             n,
             bound: k,
-        }
+        })
     }
 }
 
@@ -384,19 +396,22 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
         build: || {
             // source=[0,1,0], target=[1,0], bound=1 (delete position 0)
             let source = StringToStringCorrection::new(2, vec![0, 1, 0], vec![1, 0], 1);
-            let reduction: ReductionSTSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+            let reduction: ReductionSTSCToILP =
+                ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
             let target_config = {
                 let ilp_solver = crate::solvers::ILPSolver::new();
                 ilp_solver
                     .solve(reduction.target_problem())
                     .expect("ILP should be solvable")
             };
-            let source_config = reduction.extract_solution(&target_config);
+            let source_config = reduction.extract_solution(&target_config).unwrap();
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/strongconnectivityaugmentation_ilp.rs b/src/rules/strongconnectivityaugmentation_ilp.rs
index 3e95e7b63..02bb8a4e3 100644
--- a/src/rules/strongconnectivityaugmentation_ilp.rs
+++ b/src/rules/strongconnectivityaugmentation_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from StrongConnectivityAugmentation to ILP<i32>.
+//! Reduction from StrongConnectivityAugmentation to `ILP<i64>`.
 //!
 //! Select candidate arcs under the budget and certify strong connectivity by
 //! sending flow both from a root to every vertex and back again.
@@ -11,33 +11,44 @@ use crate::rules::traits::{ReduceTo, ReductionResult};
 
 #[derive(Debug, Clone)]
 pub struct ReductionSCAToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_candidates: usize,
 }
 
 impl ReductionResult for ReductionSCAToILP {
-    type Source = StrongConnectivityAugmentation<i32>;
-    type Target = ILP<i32>;
+    type Source = StrongConnectivityAugmentation<i64>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..self.num_candidates].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution[..self.num_candidates]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_potential_arcs + 2 * num_vertices * (num_arcs + num_potential_arcs)",
         num_constraints = "1 + 2 * num_vertices * num_potential_arcs + 2 * num_vertices * num_vertices",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for StrongConnectivityAugmentation<i32> {
+impl ReduceTo<ILP<i64>> for StrongConnectivityAugmentation<i64> {
     type Result = ReductionSCAToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let p = self.num_potential_arcs();
 
@@ -61,118 +72,113 @@ impl ReduceTo<ILP<i32>> for StrongConnectivityAugmentation<i32> {
 
         // Binary bounds: y_j ≤ 1
         for j in 0..p {
-            constraints.push(LinearConstraint::le(vec![(j, 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(j, 1)], 1));
         }
 
         // Budget: Σ w_j * y_j ≤ B
-        let budget_terms: Vec<(usize, f64)> = self
+        let budget_terms: Vec<(usize, i64)> = self
             .candidate_arcs()
             .iter()
             .enumerate()
-            .map(|(j, &(_, _, w))| (j, w as f64))
+            .map(|(candidate, &(_, _, weight))| (candidate, weight))
             .collect();
-        constraints.push(LinearConstraint::le(budget_terms, *self.bound() as f64));
+        constraints.push(LinearConstraint::le(budget_terms, *self.bound()));
 
         for t in 0..n {
             if t == root {
                 // Pin all flow vars to 0 for dummy commodity t = root
                 for i in 0..m {
-                    constraints.push(LinearConstraint::eq(vec![(f_base(t, i), 1.0)], 0.0));
-                    constraints.push(LinearConstraint::eq(vec![(g_base(t, i), 1.0)], 0.0));
+                    constraints.push(LinearConstraint::eq(vec![(f_base(t, i), 1)], 0));
+                    constraints.push(LinearConstraint::eq(vec![(g_base(t, i), 1)], 0));
                 }
                 for j in 0..p {
-                    constraints.push(LinearConstraint::eq(vec![(f_cand(t, j), 1.0)], 0.0));
-                    constraints.push(LinearConstraint::eq(vec![(g_cand(t, j), 1.0)], 0.0));
+                    constraints.push(LinearConstraint::eq(vec![(f_cand(t, j), 1)], 0));
+                    constraints.push(LinearConstraint::eq(vec![(g_cand(t, j), 1)], 0));
                 }
                 continue;
             }
 
             // Activation: f_bar^t_j ≤ y_j and g_bar^t_j ≤ y_j
             for j in 0..p {
-                constraints.push(LinearConstraint::le(
-                    vec![(f_cand(t, j), 1.0), (j, -1.0)],
-                    0.0,
-                ));
-                constraints.push(LinearConstraint::le(
-                    vec![(g_cand(t, j), 1.0), (j, -1.0)],
-                    0.0,
-                ));
+                constraints.push(LinearConstraint::le(vec![(f_cand(t, j), 1), (j, -1)], 0));
+                constraints.push(LinearConstraint::le(vec![(g_cand(t, j), 1), (j, -1)], 0));
             }
 
             // Forward flow conservation (root → t): for each vertex v
             for v in 0..n {
-                let mut terms: Vec<(usize, f64)> = Vec::new();
+                let mut terms: Vec<(usize, i64)> = Vec::new();
 
                 // Base arcs
                 for (i, &(u_a, v_a)) in base_arcs.iter().enumerate() {
                     if u_a == v {
-                        terms.push((f_base(t, i), 1.0)); // outgoing
+                        terms.push((f_base(t, i), 1)); // outgoing
                     }
                     if v_a == v {
-                        terms.push((f_base(t, i), -1.0)); // incoming
+                        terms.push((f_base(t, i), -1)); // incoming
                     }
                 }
 
                 // Candidate arcs
                 for (j, &(sj, tj, _)) in self.candidate_arcs().iter().enumerate() {
                     if sj == v {
-                        terms.push((f_cand(t, j), 1.0)); // outgoing
+                        terms.push((f_cand(t, j), 1)); // outgoing
                     }
                     if tj == v {
-                        terms.push((f_cand(t, j), -1.0)); // incoming
+                        terms.push((f_cand(t, j), -1)); // incoming
                     }
                 }
 
                 let rhs = if v == root {
-                    1.0
+                    1
                 } else if v == t {
-                    -1.0
+                    -1
                 } else {
-                    0.0
+                    0
                 };
                 constraints.push(LinearConstraint::eq(terms, rhs));
             }
 
             // Backward flow conservation (t → root): for each vertex v
             for v in 0..n {
-                let mut terms: Vec<(usize, f64)> = Vec::new();
+                let mut terms: Vec<(usize, i64)> = Vec::new();
 
                 // Base arcs
                 for (i, &(u_a, v_a)) in base_arcs.iter().enumerate() {
                     if u_a == v {
-                        terms.push((g_base(t, i), 1.0));
+                        terms.push((g_base(t, i), 1));
                     }
                     if v_a == v {
-                        terms.push((g_base(t, i), -1.0));
+                        terms.push((g_base(t, i), -1));
                     }
                 }
 
                 // Candidate arcs
                 for (j, &(sj, tj, _)) in self.candidate_arcs().iter().enumerate() {
                     if sj == v {
-                        terms.push((g_cand(t, j), 1.0));
+                        terms.push((g_cand(t, j), 1));
                     }
                     if tj == v {
-                        terms.push((g_cand(t, j), -1.0));
+                        terms.push((g_cand(t, j), -1));
                     }
                 }
 
                 let rhs = if v == t {
-                    1.0 // source of backward flow
+                    1 // source of backward flow
                 } else if v == root {
-                    -1.0 // sink of backward flow
+                    -1 // sink of backward flow
                 } else {
-                    0.0
+                    0
                 };
                 constraints.push(LinearConstraint::eq(terms, rhs));
             }
         }
 
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
-        ReductionSCAToILP {
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
+        Ok(ReductionSCAToILP {
             target,
             num_candidates: p,
-        }
+        })
     }
 }
 
@@ -190,16 +196,17 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 2,
             );
             let reduction: ReductionSCAToILP =
-                crate::rules::ReduceTo::<ILP<i32>>::reduce_to(&source);
+                crate::rules::ReduceTo::<ILP<i64>>::reduce_to(&source)
+                    .expect("reduction should succeed");
             let ilp_sol = crate::solvers::ILPSolver::new()
                 .solve(reduction.target_problem())
                 .expect("ILP should be solvable");
-            let extracted = reduction.extract_solution(&ilp_sol);
-            crate::example_db::specs::rule_example_with_witness::<_, ILP<i32>>(
+            let extracted = reduction.extract_solution(&ilp_sol).unwrap();
+            crate::example_db::specs::rule_example_with_witness::<_, ILP<i64>>(
                 source,
                 SolutionPair {
-                    source_config: extracted,
-                    target_config: ilp_sol,
+                    source_config: serde_json::json!(extracted),
+                    target_config: serde_json::json!(ilp_sol),
                 },
             )
         },
diff --git a/src/rules/subgraphisomorphism_ilp.rs b/src/rules/subgraphisomorphism_ilp.rs
index 6868197ea..d8c6c3f4b 100644
--- a/src/rules/subgraphisomorphism_ilp.rs
+++ b/src/rules/subgraphisomorphism_ilp.rs
@@ -10,7 +10,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::SubgraphIsomorphism;
 use crate::reduction;
-use crate::rules::ilp_helpers::one_hot_assignment_constraints;
+use crate::rules::ilp_helpers::{one_hot_assignment_constraints, one_hot_decode_rows};
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::Graph;
 
@@ -34,28 +34,34 @@ impl ReductionResult for ReductionSubIsoToILP {
     }
 
     /// Extract: for each pattern vertex v, output the unique host vertex u with x_{v,u} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n_host = self.num_host_vertices;
-        (0..self.num_pattern_vertices)
-            .map(|v| {
-                (0..n_host)
-                    .find(|&u| target_solution[v * n_host + u] == 1)
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        one_hot_decode_rows(
+            target_solution,
+            self.num_pattern_vertices,
+            self.num_host_vertices,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = upper_bound {
         num_vars = "num_pattern_vertices * num_host_vertices",
         num_constraints = "num_pattern_vertices + num_host_vertices + num_pattern_edges * num_host_vertices^2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for SubgraphIsomorphism {
     type Result = ReductionSubIsoToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n_pat = self.num_pattern_vertices();
         let n_host = self.num_host_vertices();
         let host = self.host_graph();
@@ -81,21 +87,22 @@ impl ReduceTo<ILP<bool>> for SubgraphIsomorphism {
                     }
                     // x_{v,u} + x_{w,u'} <= 1
                     constraints.push(LinearConstraint::le(
-                        vec![(v * n_host + u, 1.0), (w * n_host + u_prime, 1.0)],
-                        1.0,
+                        vec![(v * n_host + u, 1), (w * n_host + u_prime, 1)],
+                        1,
                     ));
                 }
             }
         }
 
         // Feasibility: no objective
-        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionSubIsoToILP {
+        Ok(ReductionSubIsoToILP {
             target,
             num_pattern_vertices: n_pat,
             num_host_vertices: n_host,
-        }
+        })
     }
 }
 
diff --git a/src/rules/subsetsum_closestvectorproblem.rs b/src/rules/subsetsum_closestvectorproblem.rs
index 2d8b9994a..dd4762df5 100644
--- a/src/rules/subsetsum_closestvectorproblem.rs
+++ b/src/rules/subsetsum_closestvectorproblem.rs
@@ -1,62 +1,148 @@
-//! Reduction from Subset Sum to Closest Vector Problem.
+//! Reduction from Subset Sum to CVP using binary carry equations.
 
-use crate::models::algebraic::{ClosestVectorProblem, VarBounds};
+use crate::models::algebraic::ClosestVectorProblem;
 use crate::models::misc::SubsetSum;
 use crate::reduction;
+use crate::registry::ConstructionError;
 use crate::rules::traits::{ReduceTo, ReductionResult};
-use num_bigint::BigUint;
-use num_traits::ToPrimitive;
+use crate::types::{Min, Or};
 
 /// Result of reducing SubsetSum to ClosestVectorProblem.
 #[derive(Debug, Clone)]
 pub struct ReductionSubsetSumToClosestVectorProblem {
-    target: ClosestVectorProblem<i32>,
+    target: ClosestVectorProblem<i64>,
+    num_elements: usize,
+    target_distance: f64,
 }
 
 impl ReductionResult for ReductionSubsetSumToClosestVectorProblem {
     type Source = SubsetSum;
-    type Target = ClosestVectorProblem<i32>;
+    type Target = ClosestVectorProblem<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        let value =
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        let certificate = crate::rules::AggregateReductionResult::extract_value(self, value);
+        if !certificate.0 {
+            return Err(crate::rules::ExtractionError::invalid(
+                "target lattice vector does not certify a subset sum",
+            ));
+        }
+        Ok(target_solution[..self.num_elements]
+            .iter()
+            .map(|&value| value == 1)
+            .collect())
     }
 }
 
-fn biguint_to_i32(value: &BigUint) -> i32 {
-    value
-        .to_i32()
-        .expect("SubsetSum -> ClosestVectorProblem requires all sizes and target to fit in i32")
+impl crate::rules::AggregateReductionResult for ReductionSubsetSumToClosestVectorProblem {
+    type Source = SubsetSum;
+    type Target = ClosestVectorProblem<i64>;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_value(&self, target_value: Min<f64>) -> Or {
+        Or(target_value == Min(Some(self.target_distance)))
+    }
 }
 
-#[reduction(
-    overhead = {
-        ambient_dimension = "num_elements + 1",
-        num_basis_vectors = "num_elements",
+impl ReductionSubsetSumToClosestVectorProblem {
+    /// Check the dense representation before allocating its columns.
+    fn dimensions(
+        num_elements: usize,
+        bit_width: u64,
+    ) -> Result<(usize, usize, usize), crate::rules::ReductionError> {
+        let overflow = || {
+            crate::rules::ReductionError::integer_overflow::<SubsetSum, ClosestVectorProblem<i64>>(
+                "sizing the binary-carry lattice",
+            )
+        };
+        let bits = usize::try_from(bit_width).map_err(|_| overflow())?;
+        let carries = bits.checked_sub(1).ok_or_else(overflow)?;
+        let columns = num_elements.checked_add(carries).ok_or_else(overflow)?;
+        let rows = columns
+            .checked_add(num_elements)
+            .and_then(|value| value.checked_add(1))
+            .ok_or_else(overflow)?;
+        rows.checked_mul(columns)
+            .and_then(|entries| entries.checked_mul(std::mem::size_of::<i64>()))
+            .ok_or_else(overflow)?;
+        Ok((bits, rows, columns))
     }
+}
+
+#[reduction(
+    aggregate = custom,
+    transform = unavailable {
+        ambient_dimension = "2n+b depends on input bit length b, which is not a registered SubsetSum parameter",
+        num_basis_vectors = "n+b-1 depends on input bit length b, which is not a registered SubsetSum parameter",
+    },
 )]
-impl ReduceTo<ClosestVectorProblem<i32>> for SubsetSum {
+impl ReduceTo<ClosestVectorProblem<i64>> for SubsetSum {
     type Result = ReductionSubsetSumToClosestVectorProblem;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_elements();
-        let mut basis = Vec::with_capacity(n);
+        let bit_width = self
+            .sizes()
+            .iter()
+            .fold(self.target().bits().max(1), |bits, size| {
+                bits.max(size.bits())
+            });
+        let (bits, rows, columns) =
+            ReductionSubsetSumToClosestVectorProblem::dimensions(n, bit_width)?;
+        let mut basis = Vec::with_capacity(columns);
+        // Paired residuals x_i and x_i-1 have minimum squared contribution one,
+        // attained exactly at 0 and 1. Their leading identity gives unit pivots.
         for (i, size) in self.sizes().iter().enumerate() {
-            let mut column = vec![0i32; n + 1];
+            let mut column = vec![0_i64; rows];
             column[i] = 1;
-            column[n] = biguint_to_i32(size);
+            column[n + i] = 1;
+            for bit in 0..bits {
+                column[rows - 1 - bit] = i64::from(size.bit(bit as u64));
+            }
             basis.push(column);
         }
-
-        let mut target = vec![0.5; n];
-        target.push(biguint_to_i32(self.target()) as f64);
-
-        ReductionSubsetSumToClosestVectorProblem {
-            target: ClosestVectorProblem::new(basis, target, vec![VarBounds::binary(); n]),
+        // Carry c_k occurs with +1 in bit k and -2 in bit k-1. Descending
+        // bit rows and carry columns preserve unit pivots in the formal rank
+        // checker, without changing its implementation or bypassing validation.
+        for bit in (1..bits).rev() {
+            let mut column = vec![0_i64; rows];
+            column[rows - 1 - bit] = 1;
+            column[rows - bit] = -2;
+            basis.push(column);
+        }
+        let mut target = vec![0_i64; rows];
+        target[n..2 * n].fill(1);
+        for bit in 0..bits {
+            target[rows - 1 - bit] = i64::from(self.target().bit(bit as u64));
         }
+        // The checked dense byte count bounds n below 2^30 on 64-bit systems,
+        // so the integer threshold and its unit squared-distance gap are exact.
+        let count = <Self as ReduceTo<ClosestVectorProblem<i64>>>::exact_i64(
+            n,
+            "representing the subset-sum distance threshold",
+        )?;
+        let target_distance = crate::types::i64_to_exact_f64(count)
+            .map_err(ConstructionError::from)
+            .map_err(<Self as ReduceTo<ClosestVectorProblem<i64>>>::target_construction)?
+            .sqrt();
+        let target = ClosestVectorProblem::new(basis, target)
+            .map_err(<Self as ReduceTo<ClosestVectorProblem<i64>>>::target_construction)?;
+        Ok(ReductionSubsetSumToClosestVectorProblem {
+            target,
+            num_elements: n,
+            target_distance,
+        })
     }
 }
 
@@ -67,11 +153,11 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     vec![crate::example_db::specs::RuleExampleSpec {
         id: "subsetsum_to_closestvectorproblem",
         build: || {
-            crate::example_db::specs::rule_example_with_witness::<_, ClosestVectorProblem<i32>>(
+            crate::example_db::specs::rule_example_with_witness::<_, ClosestVectorProblem<i64>>(
                 SubsetSum::new(vec![3u32, 7, 1, 8], 11u32),
                 SolutionPair {
-                    source_config: vec![1, 0, 0, 1],
-                    target_config: vec![1, 0, 0, 1],
+                    source_config: serde_json::json!(vec![true, false, false, true]),
+                    target_config: serde_json::json!(vec![1, 0, 0, 1, 0, 0, 0]),
                 },
             )
         },
diff --git a/src/rules/subsetsum_integerexpressionmembership.rs b/src/rules/subsetsum_integerexpressionmembership.rs
index dd3bef7d3..c187a66e4 100644
--- a/src/rules/subsetsum_integerexpressionmembership.rs
+++ b/src/rules/subsetsum_integerexpressionmembership.rs
@@ -17,10 +17,17 @@ impl ReductionResult for ReductionSubsetSumToIntegerExpressionMembership {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        // Union choice 0 = left = Atom(1) = exclude, choice 1 = right = Atom(s_i+1) = include.
-        // This maps directly to SubsetSum's 0/1 include/exclude encoding.
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // Union choice 0 = left = Atom(1) = exclude, choice 1 = right = Atom(s_i+1) = include.
+            // This maps directly to SubsetSum's 0/1 include/exclude encoding.
+            target_solution.to_vec()
+        })
     }
 }
 
@@ -32,47 +39,78 @@ impl ReductionResult for ReductionSubsetSumToIntegerExpressionMembership {
 ///
 /// DFS order visits Union_0 first, then Union_1, etc., so config[i]
 /// corresponds to item i.
-fn build_expression(sizes: &[u64]) -> IntExpr {
-    assert!(
-        !sizes.is_empty(),
-        "SubsetSum must have at least one element"
-    );
-
-    let make_union = |s: u64| -> IntExpr {
-        IntExpr::Union(Box::new(IntExpr::Atom(1)), Box::new(IntExpr::Atom(s + 1)))
+fn build_expression(sizes: &[i64]) -> Result<IntExpr, &'static str> {
+    let make_union = |size: i64| -> Result<IntExpr, &'static str> {
+        let included = size
+            .checked_add(1)
+            .ok_or("an item size cannot be shifted into the target expression domain")?;
+        Ok(IntExpr::Union(
+            Box::new(IntExpr::Atom(1)),
+            Box::new(IntExpr::Atom(included)),
+        ))
     };
 
-    let mut expr = make_union(sizes[0]);
-    for &s in &sizes[1..] {
-        expr = IntExpr::Sum(Box::new(expr), Box::new(make_union(s)));
+    let mut sizes = sizes.iter().copied();
+    let first = sizes
+        .next()
+        .ok_or("the target expression requires at least one source item")?;
+    let mut expr = make_union(first)?;
+    for size in sizes {
+        expr = IntExpr::Sum(Box::new(expr), Box::new(make_union(size)?));
     }
-    expr
+    Ok(expr)
 }
 
-#[reduction(overhead = {
-    num_union_nodes = "num_elements",
-})]
+#[reduction(
+    transform = exact {
+        num_union_nodes = "num_elements",
+    })]
 impl ReduceTo<IntegerExpressionMembership> for SubsetSum {
     type Result = ReductionSubsetSumToIntegerExpressionMembership;
 
-    fn reduce_to(&self) -> Self::Result {
-        let sizes: Vec<u64> = self
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        let sizes: Vec<i64> = self
             .sizes()
             .iter()
-            .map(|size| size.to_u64().unwrap())
-            .collect();
+            .map(|size| {
+                size.to_i64().ok_or_else(|| {
+                    crate::rules::ReductionError::invalid_target::<
+                        SubsetSum,
+                        IntegerExpressionMembership,
+                    >("subset size does not fit the target i64 domain")
+                })
+            })
+            .collect::<Result<_, _>>()?;
 
-        let shift = u64::try_from(self.num_elements())
-            .expect("SubsetSum -> IntegerExpressionMembership requires num_elements to fit in u64");
-        let target = self.target().to_u64().unwrap().checked_add(shift).expect(
-            "SubsetSum -> IntegerExpressionMembership requires shifted target to fit in u64",
-        );
+        let shift =
+            i64::try_from(self.num_elements()).map_err(|_| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SubsetSum,
+                    IntegerExpressionMembership,
+                >("converting the number of elements to i64")
+            })?;
+        let source_target = self.target().to_i64().ok_or_else(|| {
+            crate::rules::ReductionError::invalid_target::<SubsetSum, IntegerExpressionMembership>(
+                "subset target does not fit the target i64 domain",
+            )
+        })?;
+        let target =
+            source_target.checked_add(shift).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    SubsetSum,
+                    IntegerExpressionMembership,
+                >("computing the shifted target")
+            })?;
 
-        let expr = build_expression(&sizes);
+        let expr = build_expression(&sizes).map_err(|message| {
+            crate::rules::ReductionError::invalid_target::<SubsetSum, IntegerExpressionMembership>(
+                message,
+            )
+        })?;
 
-        ReductionSubsetSumToIntegerExpressionMembership {
+        Ok(ReductionSubsetSumToIntegerExpressionMembership {
             target: IntegerExpressionMembership::new(expr, target),
-        }
+        })
     }
 }
 
@@ -86,8 +124,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, IntegerExpressionMembership>(
                 SubsetSum::new(vec![1u32, 5, 6, 8], 11u32),
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0],
-                    target_config: vec![0, 1, 1, 0],
+                    source_config: serde_json::json!(vec![false, true, true, false]),
+                    target_config: serde_json::json!(vec![false, true, true, false]),
                 },
             )
         },
diff --git a/src/rules/subsetsum_integerknapsack.rs b/src/rules/subsetsum_integerknapsack.rs
index c79e2e976..1a244f968 100644
--- a/src/rules/subsetsum_integerknapsack.rs
+++ b/src/rules/subsetsum_integerknapsack.rs
@@ -10,12 +10,13 @@
 use crate::expr::Expr;
 use crate::models::misc::SubsetSum;
 use crate::models::set::IntegerKnapsack;
-use crate::rules::{EdgeCapabilities, ReductionEntry, ReductionOverhead};
+use crate::rules::registry::ReductionParameterDeclarations;
+use crate::rules::ReductionEntry;
 use crate::traits::Problem;
-use crate::types::ProblemSize;
+#[cfg(feature = "example-db")]
 use num_bigint::BigUint;
+#[cfg(feature = "example-db")]
 use num_traits::ToPrimitive;
-use std::any::Any;
 
 #[cfg(feature = "example-db")]
 fn biguint_to_i64(value: &BigUint, what: &str) -> i64 {
@@ -24,48 +25,24 @@ fn biguint_to_i64(value: &BigUint, what: &str) -> i64 {
         .unwrap_or_else(|| panic!("SubsetSum -> IntegerKnapsack requires {what} to fit in i64"))
 }
 
-fn biguint_to_usize(value: &BigUint, what: &str) -> usize {
-    value
-        .to_usize()
-        .unwrap_or_else(|| panic!("SubsetSum -> IntegerKnapsack requires {what} to fit in usize"))
-}
-
-fn subset_sum_source_size(any: &dyn Any) -> ProblemSize {
-    let source = any
-        .downcast_ref::<SubsetSum>()
-        .expect("SubsetSum -> IntegerKnapsack source type mismatch");
-    ProblemSize::new(vec![
-        ("num_elements", source.num_elements()),
-        ("target", biguint_to_usize(source.target(), "target")),
-    ])
-}
-
-fn subset_sum_to_integer_knapsack_overhead(any: &dyn Any) -> ProblemSize {
-    let source = any
-        .downcast_ref::<SubsetSum>()
-        .expect("SubsetSum -> IntegerKnapsack source type mismatch");
-    ProblemSize::new(vec![
-        ("num_items", source.num_elements()),
-        ("capacity", biguint_to_usize(source.target(), "target")),
-    ])
-}
-
 inventory::submit! {
     ReductionEntry {
         source_name: SubsetSum::NAME,
         target_name: IntegerKnapsack::NAME,
         source_variant_fn: <SubsetSum as Problem>::variant,
         target_variant_fn: <IntegerKnapsack as Problem>::variant,
-        overhead_fn: || ReductionOverhead::new(vec![
-            ("num_items", Expr::Var("num_elements")),
-            ("capacity", Expr::Var("target")),
-        ]),
+        parameter_declarations_fn: || ReductionParameterDeclarations {
+            relation: Some(crate::parameters::ParameterRelation::Exact),
+            fields: vec![("num_items", Expr::variable("num_elements"))],
+            unavailable: vec![crate::rules::registry::UnavailableParameterField {
+                field: "capacity",
+                reason: "the target capacity equals the SubsetSum target, which is not a registered source parameter",
+            }],
+        },
         module_path: module_path!(),
         reduce_fn: None,
         reduce_aggregate_fn: None,
-        capabilities: EdgeCapabilities::none(),
-        overhead_eval_fn: subset_sum_to_integer_knapsack_overhead,
-        source_size_fn: subset_sum_source_size,
+        turing: false,
     }
 }
 
@@ -90,14 +67,15 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                     .map(|value| biguint_to_i64(value, "sizes"))
                     .collect(),
                 biguint_to_i64(source.target(), "target"),
-            );
+            )
+            .unwrap();
 
             assemble_rule_example(
                 &source,
                 &target,
                 vec![SolutionPair {
-                    source_config: vec![1, 0, 0, 1, 1],
-                    target_config: vec![1, 0, 0, 1, 1],
+                    source_config: serde_json::json!(vec![true, false, false, true, true]),
+                    target_config: serde_json::json!(vec![1, 0, 0, 1, 1]),
                 }],
             )
         },
diff --git a/src/rules/subsetsum_partition.rs b/src/rules/subsetsum_partition.rs
index 4bb333f87..8b1e2726f 100644
--- a/src/rules/subsetsum_partition.rs
+++ b/src/rules/subsetsum_partition.rs
@@ -30,42 +30,44 @@ impl ReductionResult for ReductionSubsetSumToPartition {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let source_bits = &target_solution[..self.source_len];
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
-        match self.padding_relation {
-            PaddingRelation::None => source_bits.to_vec(),
-            PaddingRelation::SameSide => {
-                let padding_is_selected = target_solution[self.source_len] == 1;
-                source_bits
-                    .iter()
-                    .map(|&bit| if padding_is_selected { bit } else { 1 - bit })
-                    .collect()
-            }
-            PaddingRelation::OppositeSide => {
-                let padding_is_selected = target_solution[self.source_len] == 1;
-                source_bits
-                    .iter()
-                    .map(|&bit| if padding_is_selected { 1 - bit } else { bit })
-                    .collect()
+        Ok({
+            let source_bits = &target_solution[..self.source_len];
+
+            match self.padding_relation {
+                PaddingRelation::None => source_bits.to_vec(),
+                PaddingRelation::SameSide => {
+                    let padding_is_selected = target_solution[self.source_len];
+                    source_bits
+                        .iter()
+                        .map(|&bit| if padding_is_selected { bit } else { !bit })
+                        .collect()
+                }
+                PaddingRelation::OppositeSide => {
+                    let padding_is_selected = target_solution[self.source_len];
+                    source_bits
+                        .iter()
+                        .map(|&bit| if padding_is_selected { !bit } else { bit })
+                        .collect()
+                }
             }
-        }
+        })
     }
 }
 
-fn biguint_to_u64(value: &BigUint) -> u64 {
-    value
-        .to_u64()
-        .expect("SubsetSum -> Partition requires all sizes and padding to fit in u64")
-}
-
-#[reduction(overhead = {
-    num_elements = "num_elements + 1",
-})]
+#[reduction(
+    transform = exact {
+        num_elements = "num_elements + 1",
+    })]
 impl ReduceTo<Partition> for SubsetSum {
     type Result = ReductionSubsetSumToPartition;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let total: BigUint = self.sizes().iter().cloned().sum();
         let double_target = self.target() * 2u32;
         let relation = total.cmp(&double_target);
@@ -75,18 +77,27 @@ impl ReduceTo<Partition> for SubsetSum {
             Ordering::Less => PaddingRelation::OppositeSide,
         };
 
-        let mut sizes: Vec<u64> = self.sizes().iter().map(biguint_to_u64).collect();
+        let convert = |value: &BigUint| {
+            value.to_i64().ok_or_else(|| {
+                crate::rules::ReductionError::invalid_target::<SubsetSum, Partition>(
+                    "a source size or derived padding does not fit the Partition i64 domain",
+                )
+            })
+        };
+        let mut sizes: Vec<i64> = self.sizes().iter().map(convert).collect::<Result<_, _>>()?;
         match relation {
             Ordering::Equal => {}
-            Ordering::Greater => sizes.push(biguint_to_u64(&(total - double_target))),
-            Ordering::Less => sizes.push(biguint_to_u64(&(double_target - total))),
+            Ordering::Greater => sizes.push(convert(&(total - double_target))?),
+            Ordering::Less => sizes.push(convert(&(double_target - total))?),
         }
 
-        ReductionSubsetSumToPartition {
-            target: Partition::new(sizes),
+        Ok(ReductionSubsetSumToPartition {
+            target: Partition::new(sizes).map_err(|error| {
+                crate::rules::ReductionError::construction::<SubsetSum, Partition>(error)
+            })?,
             source_len: self.num_elements(),
             padding_relation,
-        }
+        })
     }
 }
 
@@ -100,8 +111,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, Partition>(
                 SubsetSum::new(vec![1u32, 5, 6, 8], 11u32),
                 SolutionPair {
-                    source_config: vec![0, 1, 1, 0],
-                    target_config: vec![0, 1, 1, 0, 0],
+                    source_config: serde_json::json!(vec![false, true, true, false]),
+                    target_config: serde_json::json!(vec![false, true, true, false, false]),
                 },
             )
         },
diff --git a/src/rules/sumofsquarespartition_ilp.rs b/src/rules/sumofsquarespartition_ilp.rs
index de6b8e02a..1d82db321 100644
--- a/src/rules/sumofsquarespartition_ilp.rs
+++ b/src/rules/sumofsquarespartition_ilp.rs
@@ -19,6 +19,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::misc::SumOfSquaresPartition;
 use crate::reduction;
+use crate::rules::ilp_helpers::mccormick_product;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
 /// Result of reducing SumOfSquaresPartition to ILP.
@@ -56,31 +57,34 @@ impl ReductionResult for ReductionSSPToILP {
     }
 
     /// Extract solution: for each element i, find the unique group g where x_{i,g} = 1.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let num_groups = self.num_groups;
-        (0..self.num_elements)
-            .map(|i| {
-                (0..num_groups)
-                    .find(|&g| {
-                        let idx = i * num_groups + g;
-                        idx < target_solution.len() && target_solution[idx] == 1
-                    })
-                    .unwrap_or(0)
-            })
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::one_hot_decode_rows(
+            target_solution,
+            self.num_elements,
+            self.num_groups,
+            0,
+        )
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_elements * num_groups + num_elements^2 * num_groups",
         num_constraints = "num_elements + 3 * num_elements^2 * num_groups",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for SumOfSquaresPartition {
     type Result = ReductionSSPToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_elements();
         let k = self.num_groups();
         let num_vars = n * k + n * n * k;
@@ -95,8 +99,8 @@ impl ReduceTo<ILP<bool>> for SumOfSquaresPartition {
 
         // Assignment constraints: for each element i, Σ_g x_{i,g} = 1
         for i in 0..n {
-            let terms: Vec<(usize, f64)> = (0..k).map(|g| (result.x_var(i, g), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..k).map(|g| (result.x_var(i, g), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // McCormick linearization for z_{i,j,g} = x_{i,g} * x_{j,g}
@@ -107,40 +111,39 @@ impl ReduceTo<ILP<bool>> for SumOfSquaresPartition {
                     let xi = result.x_var(i, g);
                     let xj = result.x_var(j, g);
 
-                    // z ≤ x_{i,g}
-                    constraints.push(LinearConstraint::le(vec![(z, 1.0), (xi, -1.0)], 0.0));
-                    // z ≤ x_{j,g}
-                    constraints.push(LinearConstraint::le(vec![(z, 1.0), (xj, -1.0)], 0.0));
-                    // z ≥ x_{i,g} + x_{j,g} - 1  →  -z + x_{i,g} + x_{j,g} ≤ 1
-                    constraints.push(LinearConstraint::le(
-                        vec![(z, -1.0), (xi, 1.0), (xj, 1.0)],
-                        1.0,
-                    ));
+                    constraints.extend(mccormick_product(z, xi, xj));
                 }
             }
         }
 
         // Objective: Minimize Σ_g Σ_{i,j} s_i * s_j * z_{i,j,g}
         let sizes = self.sizes();
-        let mut objective: Vec<(usize, f64)> = Vec::new();
+        let mut objective: Vec<(usize, i64)> = Vec::new();
         for i in 0..n {
             for j in 0..n {
                 for g in 0..k {
-                    let coeff = sizes[i] as f64 * sizes[j] as f64;
-                    if coeff.abs() > 0.0 {
+                    let product = sizes[i].checked_mul(sizes[j]).ok_or_else(|| {
+                        crate::rules::ReductionError::integer_overflow::<
+                            SumOfSquaresPartition,
+                            ILP<bool>,
+                        >("multiplying two partition element sizes")
+                    })?;
+                    let coeff = product;
+                    if coeff != 0 {
                         objective.push((result.z_var(i, j, g), coeff));
                     }
                 }
             }
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(Self::target_construction)?;
 
-        ReductionSSPToILP {
+        Ok(ReductionSSPToILP {
             target,
             num_elements: n,
             num_groups: k,
-        }
+        })
     }
 }
 
diff --git a/src/rules/test_helpers.rs b/src/rules/test_helpers.rs
index 9fb71e316..620f17233 100644
--- a/src/rules/test_helpers.rs
+++ b/src/rules/test_helpers.rs
@@ -1,19 +1,20 @@
 use crate::rules::{ReductionChain, ReductionResult};
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
-use crate::types::Aggregate;
+use crate::types::SolutionAggregate;
 use std::collections::HashSet;
 
-fn verify_optimization_round_trip<Source, Extract>(
+fn verify_optimization_round_trip<Source, TargetSolution, Extract>(
     source: &Source,
-    target_solutions: Vec<Vec<usize>>,
+    target_solutions: Vec<TargetSolution>,
     extract_solution: Extract,
     target_solution_kind: &str,
     context: &str,
 ) where
     Source: Problem + 'static,
-    <Source as Problem>::Value: Aggregate + std::fmt::Debug + PartialEq,
-    Extract: Fn(&[usize]) -> Vec<usize>,
+    Source::Solution: Eq + std::hash::Hash + std::fmt::Debug + 'static,
+    <Source as Problem>::Value: SolutionAggregate + std::fmt::Debug + PartialEq,
+    Extract: Fn(&TargetSolution) -> Source::Solution,
 {
     assert!(
         !target_solutions.is_empty(),
@@ -21,8 +22,11 @@ fn verify_optimization_round_trip<Source, Extract>(
     );
 
     let solver = BruteForce::new();
-    let reference_solutions: HashSet<Vec<usize>> =
-        solver.find_all_witnesses(source).into_iter().collect();
+    let reference_solutions: HashSet<Source::Solution> = solver
+        .find_all_witnesses(source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert!(
         !reference_solutions.is_empty(),
         "{context}: direct source solver found no optimal solutions"
@@ -34,10 +38,8 @@ fn verify_optimization_round_trip<Source, Extract>(
             .next()
             .expect("reference set is non-empty"),
     );
-    let extracted: HashSet<Vec<usize>> = target_solutions
-        .iter()
-        .map(|target_solution| extract_solution(target_solution))
-        .collect();
+    let extracted: HashSet<Source::Solution> =
+        target_solutions.iter().map(extract_solution).collect();
     assert!(
         !extracted.is_empty(),
         "{context}: no extracted source solutions"
@@ -55,34 +57,37 @@ fn verify_optimization_round_trip<Source, Extract>(
     }
 }
 
-fn verify_satisfaction_round_trip<Source, Extract>(
+fn verify_satisfaction_round_trip<Source, TargetSolution, Extract>(
     source: &Source,
-    target_solutions: Vec<Vec<usize>>,
+    target_solutions: Vec<TargetSolution>,
     extract_solution: Extract,
     target_solution_kind: &str,
     context: &str,
 ) where
     Source: Problem + 'static,
-    <Source as Problem>::Value: Aggregate + std::fmt::Debug,
-    Extract: Fn(&[usize]) -> Vec<usize>,
+    Source::Solution: Eq + std::hash::Hash + std::fmt::Debug + 'static,
+    <Source as Problem>::Value: SolutionAggregate + std::fmt::Debug,
+    Extract: Fn(&TargetSolution) -> Source::Solution,
 {
     assert!(
         !target_solutions.is_empty(),
         "{context}: target solver found no {target_solution_kind} solutions"
     );
-    let extracted: HashSet<Vec<usize>> = target_solutions
-        .iter()
-        .map(|target_solution| extract_solution(target_solution))
-        .collect();
+    let extracted: HashSet<Source::Solution> =
+        target_solutions.iter().map(extract_solution).collect();
     assert!(
         !extracted.is_empty(),
         "{context}: no extracted source solutions"
     );
-    let total = <BruteForce as crate::solvers::Solver>::solve(&BruteForce::new(), source);
+    let optimal_solution = BruteForce::new()
+        .solve(source)
+        .unwrap()
+        .expect("source problem must be feasible");
+    let total = source.evaluate(&optimal_solution).unwrap();
     for source_solution in &extracted {
-        let value = source.evaluate(source_solution);
+        let value = source.evaluate(source_solution).unwrap();
         assert!(
-            <Source::Value as Aggregate>::contributes_to_witnesses(&value, &total),
+            <Source::Value as SolutionAggregate>::contributes_to_solution(&value, &total),
             "{context}: extracted source solution is not satisfying: {:?}",
             source_solution
         );
@@ -97,14 +102,18 @@ pub(crate) fn assert_optimization_round_trip_from_optimization_target<R>(
     R: ReductionResult,
     R::Source: Problem + 'static,
     R::Target: Problem + 'static,
-    <R::Source as Problem>::Value: Aggregate + std::fmt::Debug + PartialEq,
-    <R::Target as Problem>::Value: Aggregate,
+    <R::Source as Problem>::Solution: Eq + std::hash::Hash + std::fmt::Debug + 'static,
+    <R::Target as Problem>::Solution: 'static,
+    <R::Source as Problem>::Value: SolutionAggregate + std::fmt::Debug + PartialEq,
+    <R::Target as Problem>::Value: SolutionAggregate,
 {
-    let target_solutions = BruteForce::new().find_all_witnesses(reduction.target_problem());
+    let target_solutions = BruteForce::new()
+        .find_all_witnesses(reduction.target_problem())
+        .unwrap();
     verify_optimization_round_trip(
         source,
         target_solutions,
-        |target_solution| reduction.extract_solution(target_solution),
+        |target_solution| reduction.extract_solution(target_solution).unwrap(),
         "optimal",
         context,
     );
@@ -118,14 +127,18 @@ pub(crate) fn assert_optimization_round_trip_from_satisfaction_target<R>(
     R: ReductionResult,
     R::Source: Problem + 'static,
     R::Target: Problem + 'static,
-    <R::Source as Problem>::Value: Aggregate + std::fmt::Debug + PartialEq,
-    <R::Target as Problem>::Value: Aggregate,
+    <R::Source as Problem>::Solution: Eq + std::hash::Hash + std::fmt::Debug + 'static,
+    <R::Target as Problem>::Solution: 'static,
+    <R::Source as Problem>::Value: SolutionAggregate + std::fmt::Debug + PartialEq,
+    <R::Target as Problem>::Value: SolutionAggregate,
 {
-    let target_solutions = BruteForce::new().find_all_witnesses(reduction.target_problem());
+    let target_solutions = BruteForce::new()
+        .find_all_witnesses(reduction.target_problem())
+        .unwrap();
     verify_optimization_round_trip(
         source,
         target_solutions,
-        |target_solution| reduction.extract_solution(target_solution),
+        |target_solution| reduction.extract_solution(target_solution).unwrap(),
         "satisfying",
         context,
     );
@@ -138,14 +151,22 @@ pub(crate) fn assert_optimization_round_trip_chain<Source, Target>(
 ) where
     Source: Problem + 'static,
     Target: Problem + 'static,
-    <Source as Problem>::Value: Aggregate + std::fmt::Debug + PartialEq,
-    <Target as Problem>::Value: Aggregate,
+    Source::Solution: Eq + std::hash::Hash + std::fmt::Debug + 'static,
+    Target::Solution: 'static,
+    <Source as Problem>::Value: SolutionAggregate + std::fmt::Debug + PartialEq,
+    <Target as Problem>::Value: SolutionAggregate,
 {
-    let target_solutions = BruteForce::new().find_all_witnesses(chain.target_problem::<Target>());
+    let target_solutions = BruteForce::new()
+        .find_all_witnesses(chain.target_problem::<Target>())
+        .unwrap();
     verify_optimization_round_trip(
         source,
         target_solutions,
-        |target_solution| chain.extract_solution(target_solution),
+        |target_solution| {
+            chain
+                .extract_solution::<Source::Solution, Target::Solution>(target_solution)
+                .unwrap()
+        },
         "optimal",
         context,
     );
@@ -159,14 +180,18 @@ pub(crate) fn assert_satisfaction_round_trip_from_optimization_target<R>(
     R: ReductionResult,
     R::Source: Problem + 'static,
     R::Target: Problem + 'static,
-    <R::Source as Problem>::Value: Aggregate + std::fmt::Debug,
-    <R::Target as Problem>::Value: Aggregate,
+    <R::Source as Problem>::Solution: Eq + std::hash::Hash + std::fmt::Debug + 'static,
+    <R::Target as Problem>::Solution: 'static,
+    <R::Source as Problem>::Value: SolutionAggregate + std::fmt::Debug,
+    <R::Target as Problem>::Value: SolutionAggregate,
 {
-    let target_solutions = BruteForce::new().find_all_witnesses(reduction.target_problem());
+    let target_solutions = BruteForce::new()
+        .find_all_witnesses(reduction.target_problem())
+        .unwrap();
     verify_satisfaction_round_trip(
         source,
         target_solutions,
-        |target_solution| reduction.extract_solution(target_solution),
+        |target_solution| reduction.extract_solution(target_solution).unwrap(),
         "optimal",
         context,
     );
@@ -180,50 +205,41 @@ pub(crate) fn assert_satisfaction_round_trip_from_satisfaction_target<R>(
     R: ReductionResult,
     R::Source: Problem + 'static,
     R::Target: Problem + 'static,
-    <R::Source as Problem>::Value: Aggregate + std::fmt::Debug,
-    <R::Target as Problem>::Value: Aggregate,
+    <R::Source as Problem>::Solution: Eq + std::hash::Hash + std::fmt::Debug + 'static,
+    <R::Target as Problem>::Solution: 'static,
+    <R::Source as Problem>::Value: SolutionAggregate + std::fmt::Debug,
+    <R::Target as Problem>::Value: SolutionAggregate,
 {
-    let target_solutions = BruteForce::new().find_all_witnesses(reduction.target_problem());
+    let target_solutions = BruteForce::new()
+        .find_all_witnesses(reduction.target_problem())
+        .unwrap();
     verify_satisfaction_round_trip(
         source,
         target_solutions,
-        |target_solution| reduction.extract_solution(target_solution),
+        |target_solution| reduction.extract_solution(target_solution).unwrap(),
         "satisfying",
         context,
     );
 }
 
-#[cfg(feature = "ilp-solver")]
 pub(crate) fn assert_bf_vs_ilp<R>(source: &R::Source, reduction: &R)
 where
     R: ReductionResult,
     R::Source: Problem + 'static,
-    R::Target: 'static,
-    <R::Source as Problem>::Value: Aggregate + std::fmt::Debug + PartialEq,
+    R::Target: Problem<Solution = Vec<i64>> + 'static,
+    <R::Source as Problem>::Value: SolutionAggregate + std::fmt::Debug + PartialEq,
 {
-    use crate::solvers::{ILPSolver, Solver};
-    let bf_value = BruteForce::new().solve(source);
+    use crate::solvers::ILPSolver;
+    let bf_solution = BruteForce::new()
+        .solve(source)
+        .unwrap()
+        .expect("source problem must be feasible");
+    let bf_value = source.evaluate(&bf_solution).unwrap();
     let ilp_solution = ILPSolver::new()
-        .solve_dyn(reduction.target_problem())
+        .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(source.evaluate(&extracted), bf_value);
-}
-
-pub(crate) fn solve_optimization_problem<P>(problem: &P) -> Option<Vec<usize>>
-where
-    P: Problem + 'static,
-    P::Value: Aggregate,
-{
-    BruteForce::new().find_witness(problem)
-}
-
-pub(crate) fn solve_satisfaction_problem<P>(problem: &P) -> Option<Vec<usize>>
-where
-    P: Problem + 'static,
-    P::Value: Aggregate,
-{
-    BruteForce::new().find_witness(problem)
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), bf_value);
 }
 
 #[cfg(test)]
@@ -238,22 +254,32 @@ mod tests {
     use crate::traits::Problem;
     use crate::types::{Max, Or};
 
-    #[derive(Clone)]
+    #[derive(Clone, serde::Serialize, serde::Deserialize)]
     struct ToyExtremumProblem;
 
-    impl Problem for ToyExtremumProblem {
-        const NAME: &'static str = "ToyExtremumProblem";
-        type Value = Max<i32>;
-
-        fn dims(&self) -> Vec<usize> {
-            vec![2, 2]
+    impl ToyExtremumProblem {
+        fn num_variables(&self) -> usize {
+            2
         }
+    }
 
-        fn evaluate(&self, config: &[usize]) -> Self::Value {
-            match config {
-                [1, 0] | [0, 1] => Max(Some(1)),
-                _ => Max(None),
-            }
+    impl Problem for ToyExtremumProblem {
+        const NAME: &'static str = "ToyExtremumProblem";
+        type Solution = Vec<usize>;
+        type Value = Max<i64>;
+
+        crate::problem_parameters![("num_variables", num_variables)];
+
+        fn evaluate(
+            &self,
+            config: &Self::Solution,
+        ) -> Result<Self::Value, crate::traits::EvaluationError> {
+            Ok({
+                match config.as_slice() {
+                    [1, 0] | [0, 1] => Max(Some(1)),
+                    _ => Max(None),
+                }
+            })
         }
 
         fn variant() -> Vec<(&'static str, &'static str)> {
@@ -261,19 +287,33 @@ mod tests {
         }
     }
 
-    #[derive(Clone)]
+    impl crate::solvers::BruteForceProblem for ToyExtremumProblem {
+        fn dimensions(&self) -> Vec<usize> {
+            vec![2, 2]
+        }
+    }
+
+    #[derive(Clone, serde::Serialize, serde::Deserialize)]
     struct ToyOrProblem;
 
+    impl ToyOrProblem {
+        fn num_variables(&self) -> usize {
+            2
+        }
+    }
+
     impl Problem for ToyOrProblem {
         const NAME: &'static str = "ToyOrProblem";
+        type Solution = Vec<usize>;
         type Value = Or;
 
-        fn dims(&self) -> Vec<usize> {
-            vec![2, 2]
-        }
+        crate::problem_parameters![("num_variables", num_variables)];
 
-        fn evaluate(&self, config: &[usize]) -> Self::Value {
-            Or(matches!(config, [1, 0] | [0, 1]))
+        fn evaluate(
+            &self,
+            config: &Self::Solution,
+        ) -> Result<Self::Value, crate::traits::EvaluationError> {
+            Ok(Or(matches!(config.as_slice(), [1, 0] | [0, 1])))
         }
 
         fn variant() -> Vec<(&'static str, &'static str)> {
@@ -281,6 +321,48 @@ mod tests {
         }
     }
 
+    impl crate::solvers::BruteForceProblem for ToyOrProblem {
+        fn dimensions(&self) -> Vec<usize> {
+            vec![2, 2]
+        }
+    }
+
+    crate::declare_variants! {
+        default ToyExtremumProblem => "2^num_variables",
+        default ToyOrProblem => "2^num_variables",
+    }
+
+    crate::register_brute_force! {
+        ToyExtremumProblem,
+        ToyOrProblem,
+    }
+
+    inventory::submit! {
+        crate::registry::ProblemSchemaEntry {
+            name: "ToyExtremumProblem",
+            display_name: "Toy Extremum Test Problem",
+            aliases: &[],
+            dimensions: &[],
+            category: crate::registry::ProblemCategory::Misc,
+            module_path: module_path!(),
+            description: "Test problem for optimization reduction helpers",
+            fields: &[],
+        }
+    }
+
+    inventory::submit! {
+        crate::registry::ProblemSchemaEntry {
+            name: "ToyOrProblem",
+            display_name: "Toy Satisfaction Test Problem",
+            aliases: &[],
+            dimensions: &[],
+            category: crate::registry::ProblemCategory::Misc,
+            module_path: module_path!(),
+            description: "Test problem for satisfaction reduction helpers",
+            fields: &[],
+        }
+    }
+
     struct OptToOptReduction {
         target: ToyExtremumProblem,
     }
@@ -293,8 +375,14 @@ mod tests {
             &self.target
         }
 
-        fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-            target_solution.to_vec()
+        fn extract_solution(
+            &self,
+            target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+        ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution>
+        {
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+            Ok(target_solution.to_vec())
         }
     }
 
@@ -310,8 +398,14 @@ mod tests {
             &self.target
         }
 
-        fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-            target_solution.to_vec()
+        fn extract_solution(
+            &self,
+            target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+        ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution>
+        {
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+            Ok(target_solution.to_vec())
         }
     }
 
@@ -327,8 +421,14 @@ mod tests {
             &self.target
         }
 
-        fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-            target_solution.to_vec()
+        fn extract_solution(
+            &self,
+            target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+        ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution>
+        {
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+            Ok(target_solution.to_vec())
         }
     }
 
@@ -344,8 +444,14 @@ mod tests {
             &self.target
         }
 
-        fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-            target_solution.to_vec()
+        fn extract_solution(
+            &self,
+            target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+        ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution>
+        {
+            crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+            Ok(target_solution.to_vec())
         }
     }
 
diff --git a/src/rules/threedimensionalmatching_ilp.rs b/src/rules/threedimensionalmatching_ilp.rs
index 0310343e5..57db1ddc7 100644
--- a/src/rules/threedimensionalmatching_ilp.rs
+++ b/src/rules/threedimensionalmatching_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from ThreeDimensionalMatching to ILP<bool>.
+//! Reduction from ThreeDimensionalMatching to `ILP<bool>`.
 
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::set::ThreeDimensionalMatching;
@@ -18,52 +18,61 @@ impl ReductionResult for ReductionThreeDimensionalMatchingToILP {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.iter().map(|&value| value == 1).collect())
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_triples",
         num_constraints = "3 * universe_size",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
 impl ReduceTo<ILP<bool>> for ThreeDimensionalMatching {
     type Result = ReductionThreeDimensionalMatchingToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let num_vars = self.num_triples();
         let mut w_constraints = vec![Vec::new(); self.universe_size()];
         let mut x_constraints = vec![Vec::new(); self.universe_size()];
         let mut y_constraints = vec![Vec::new(); self.universe_size()];
 
         for (triple_index, &(w, x, y)) in self.triples().iter().enumerate() {
-            w_constraints[w].push((triple_index, 1.0));
-            x_constraints[x].push((triple_index, 1.0));
-            y_constraints[y].push((triple_index, 1.0));
+            w_constraints[w].push((triple_index, 1));
+            x_constraints[x].push((triple_index, 1));
+            y_constraints[y].push((triple_index, 1));
         }
 
         let mut constraints = Vec::with_capacity(3 * self.universe_size());
         constraints.extend(
             w_constraints
                 .into_iter()
-                .map(|terms| LinearConstraint::eq(terms, 1.0)),
+                .map(|terms| LinearConstraint::eq(terms, 1)),
         );
         constraints.extend(
             x_constraints
                 .into_iter()
-                .map(|terms| LinearConstraint::eq(terms, 1.0)),
+                .map(|terms| LinearConstraint::eq(terms, 1)),
         );
         constraints.extend(
             y_constraints
                 .into_iter()
-                .map(|terms| LinearConstraint::eq(terms, 1.0)),
+                .map(|terms| LinearConstraint::eq(terms, 1)),
         );
 
-        ReductionThreeDimensionalMatchingToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
-        }
+        Ok(ReductionThreeDimensionalMatchingToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?,
+        })
     }
 }
 
@@ -81,8 +90,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ILP<bool>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 1, 0, 0],
-                    target_config: vec![1, 1, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, true, true, false, false]),
+                    target_config: serde_json::json!(vec![1, 1, 1, 0, 0]),
                 },
             )
         },
diff --git a/src/rules/threedimensionalmatching_minimumweightdecoding.rs b/src/rules/threedimensionalmatching_minimumweightdecoding.rs
index a4081f346..c8239dae0 100644
--- a/src/rules/threedimensionalmatching_minimumweightdecoding.rs
+++ b/src/rules/threedimensionalmatching_minimumweightdecoding.rs
@@ -44,30 +44,35 @@ impl ReductionResult for ReductionThreeDimensionalMatchingToMinimumWeightDecodin
         &self.target
     }
 
-    /// Solution extraction: identity mapping in the main branch. The target
-    /// codeword `x ∈ {0,1}^m` is the source subset indicator over the same
-    /// triple index set. In the sentinel branch the target witness has length
-    /// `1` (always `[0]`); we return the all-zero source-sized vector,
-    /// which decodes to `S = ∅`. `ThreeDimensionalMatching::evaluate(∅)`
-    /// then yields `Or(true)` iff `q == 0` (the correct answer for both
-    /// sentinel sub-cases).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        if target_solution.len() == self.source_num_triples {
-            target_solution.to_vec()
-        } else {
-            vec![0; self.source_num_triples]
+    /// The target codeword prefix is the source subset indicator over the same
+    /// triple index set. The sentinel target appends one synthetic column, so
+    /// an empty source maps back to the empty prefix.
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+        if target_solution.len() != self.target.num_cols() {
+            return Err(crate::rules::ExtractionError::invalid(format!(
+                "expected {} target codeword bits, got {}",
+                self.target.num_cols(),
+                target_solution.len()
+            )));
         }
+
+        Ok(target_solution[..self.source_num_triples].to_vec())
     }
 }
 
-#[reduction(overhead = {
-    num_rows = "3 * universe_size",
-    num_cols = "num_triples",
-})]
+#[reduction(
+    transform = exact {
+        num_rows = "3 * universe_size",
+        num_cols = "num_triples",
+    })]
 impl ReduceTo<MinimumWeightDecoding> for ThreeDimensionalMatching {
     type Result = ReductionThreeDimensionalMatchingToMinimumWeightDecoding;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let q = self.universe_size();
         let m = self.num_triples();
 
@@ -78,10 +83,10 @@ impl ReduceTo<MinimumWeightDecoding> for ThreeDimensionalMatching {
             // own evaluate on the empty set gives the correct answer:
             //   q = 0 → Or(true)  (empty matching of empty universe)
             //   q ≥ 1 → Or(false) (no triples cannot cover non-empty universe).
-            return ReductionThreeDimensionalMatchingToMinimumWeightDecoding {
+            return Ok(ReductionThreeDimensionalMatchingToMinimumWeightDecoding {
                 target: MinimumWeightDecoding::new(vec![vec![true]], vec![false]),
                 source_num_triples: m,
-            };
+            });
         }
 
         // Main branch: build H ∈ {0,1}^{3q × m} with row blocks W, X, Y and
@@ -95,10 +100,10 @@ impl ReduceTo<MinimumWeightDecoding> for ThreeDimensionalMatching {
         }
         let syndrome = vec![true; num_rows];
 
-        ReductionThreeDimensionalMatchingToMinimumWeightDecoding {
+        Ok(ReductionThreeDimensionalMatchingToMinimumWeightDecoding {
             target: MinimumWeightDecoding::new(matrix, syndrome),
             source_num_triples: m,
-        }
+        })
     }
 }
 
@@ -115,8 +120,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, MinimumWeightDecoding>(
                 ThreeDimensionalMatching::new(2, vec![(0, 0, 0), (1, 1, 1), (0, 1, 0), (1, 0, 1)]),
                 SolutionPair {
-                    source_config: vec![1, 1, 0, 0],
-                    target_config: vec![1, 1, 0, 0],
+                    source_config: serde_json::json!(vec![true, true, false, false]),
+                    target_config: serde_json::json!(vec![true, true, false, false]),
                 },
             )
         },
diff --git a/src/rules/threedimensionalmatching_threematroidintersection.rs b/src/rules/threedimensionalmatching_threematroidintersection.rs
deleted file mode 100644
index 2fcc9db0b..000000000
--- a/src/rules/threedimensionalmatching_threematroidintersection.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-//! Reduction from ThreeDimensionalMatching to ThreeMatroidIntersection.
-
-use crate::models::set::{ThreeDimensionalMatching, ThreeMatroidIntersection};
-use crate::reduction;
-use crate::rules::traits::{ReduceTo, ReductionResult};
-
-/// Result of reducing ThreeDimensionalMatching to ThreeMatroidIntersection.
-#[derive(Debug, Clone)]
-pub struct ReductionThreeDimensionalMatchingToThreeMatroidIntersection {
-    target: ThreeMatroidIntersection,
-}
-
-impl ReductionResult for ReductionThreeDimensionalMatchingToThreeMatroidIntersection {
-    type Source = ThreeDimensionalMatching;
-    type Target = ThreeMatroidIntersection;
-
-    fn target_problem(&self) -> &ThreeMatroidIntersection {
-        &self.target
-    }
-
-    /// Each target ground-set element is exactly one source triple, so the
-    /// witness vector is preserved unchanged.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
-    }
-}
-
-#[reduction(overhead = {
-    ground_set_size = "num_triples",
-    num_groups = "3 * universe_size",
-    bound = "universe_size",
-})]
-impl ReduceTo<ThreeMatroidIntersection> for ThreeDimensionalMatching {
-    type Result = ReductionThreeDimensionalMatchingToThreeMatroidIntersection;
-
-    fn reduce_to(&self) -> Self::Result {
-        let mut w_groups = vec![Vec::new(); self.universe_size()];
-        let mut x_groups = vec![Vec::new(); self.universe_size()];
-        let mut y_groups = vec![Vec::new(); self.universe_size()];
-
-        for (triple_index, &(w, x, y)) in self.triples().iter().enumerate() {
-            w_groups[w].push(triple_index);
-            x_groups[x].push(triple_index);
-            y_groups[y].push(triple_index);
-        }
-
-        ReductionThreeDimensionalMatchingToThreeMatroidIntersection {
-            target: ThreeMatroidIntersection::new(
-                self.num_triples(),
-                vec![w_groups, x_groups, y_groups],
-                self.universe_size(),
-            ),
-        }
-    }
-}
-
-#[cfg(feature = "example-db")]
-pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
-    use crate::export::SolutionPair;
-
-    vec![crate::example_db::specs::RuleExampleSpec {
-        id: "threedimensionalmatching_to_threematroidintersection",
-        build: || {
-            crate::example_db::specs::rule_example_with_witness::<_, ThreeMatroidIntersection>(
-                ThreeDimensionalMatching::new(
-                    3,
-                    vec![(0, 0, 0), (1, 1, 1), (2, 2, 2), (0, 1, 2), (1, 2, 0)],
-                ),
-                SolutionPair {
-                    source_config: vec![1, 1, 1, 0, 0],
-                    target_config: vec![1, 1, 1, 0, 0],
-                },
-            )
-        },
-    }]
-}
-
-#[cfg(test)]
-#[path = "../unit_tests/rules/threedimensionalmatching_threematroidintersection.rs"]
-mod tests;
diff --git a/src/rules/threedimensionalmatching_threepartition.rs b/src/rules/threedimensionalmatching_threepartition.rs
index 4a43698b5..03a6ce030 100644
--- a/src/rules/threedimensionalmatching_threepartition.rs
+++ b/src/rules/threedimensionalmatching_threepartition.rs
@@ -294,75 +294,82 @@ impl ReductionResult for ReductionThreeDimensionalMatchingToThreePartition {
 
     /// Reverse the 4-Partition -> 3-Partition pairing gadget, then decode the
     /// surviving real ABCD groups back into selected source triples.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let mut groups = vec![Vec::new(); self.target.num_groups()];
-        for (element_index, &group_index) in target_solution.iter().enumerate() {
-            groups[group_index].push(element_index);
-        }
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let mut groups = vec![Vec::new(); self.target.num_groups()];
+            for (element_index, &group_index) in target_solution.iter().enumerate() {
+                groups[group_index].push(element_index);
+            }
 
-        let mut pair_usage: HashMap<(usize, usize), PairUsage> = HashMap::new();
+            let mut pair_usage: HashMap<(usize, usize), PairUsage> = HashMap::new();
 
-        for members in groups.into_iter().filter(|members| !members.is_empty()) {
-            let mut regulars = Vec::new();
-            let mut pairing = None;
-            let mut has_filler = false;
+            for members in groups.into_iter().filter(|members| !members.is_empty()) {
+                let mut regulars = Vec::new();
+                let mut pairing = None;
+                let mut has_filler = false;
 
-            for element_index in members {
-                match self.classify_target_element(element_index) {
-                    TargetElement::Regular { step2_index } => regulars.push(step2_index),
-                    TargetElement::Pairing { pair_index, kind } => {
-                        pairing = Some((pair_index, kind))
+                for element_index in members {
+                    match self.classify_target_element(element_index) {
+                        TargetElement::Regular { step2_index } => regulars.push(step2_index),
+                        TargetElement::Pairing { pair_index, kind } => {
+                            pairing = Some((pair_index, kind))
+                        }
+                        TargetElement::Filler => has_filler = true,
                     }
-                    TargetElement::Filler => has_filler = true,
                 }
-            }
 
-            if has_filler || regulars.len() != 2 {
-                continue;
-            }
+                if has_filler || regulars.len() != 2 {
+                    continue;
+                }
 
-            let Some((pair_index, kind)) = pairing else {
-                continue;
-            };
+                let Some((pair_index, kind)) = pairing else {
+                    continue;
+                };
 
-            let pair_key = self.pair_keys[pair_index];
-            let regular_pair = sorted_pair(regulars[0], regulars[1]);
-            let usage = pair_usage.entry(pair_key).or_default();
+                let pair_key = self.pair_keys[pair_index];
+                let regular_pair = sorted_pair(regulars[0], regulars[1]);
+                let usage = pair_usage.entry(pair_key).or_default();
 
-            match kind {
-                PairingKind::U => {
-                    if regular_pair == [pair_key.0, pair_key.1] {
-                        usage.saw_u = true;
+                match kind {
+                    PairingKind::U => {
+                        if regular_pair == [pair_key.0, pair_key.1] {
+                            usage.saw_u = true;
+                        }
+                    }
+                    PairingKind::UPrime => {
+                        usage.uprime_regulars = Some(regular_pair);
                     }
-                }
-                PairingKind::UPrime => {
-                    usage.uprime_regulars = Some(regular_pair);
                 }
             }
-        }
 
-        let mut source_solution = vec![0; self.num_source_triples];
+            let mut source_solution = vec![false; self.num_source_triples];
 
-        for ((left, right), usage) in pair_usage {
-            let Some(other_two) = usage.uprime_regulars else {
-                continue;
-            };
-            if !usage.saw_u {
-                continue;
-            }
+            for ((left, right), usage) in pair_usage {
+                let Some(other_two) = usage.uprime_regulars else {
+                    continue;
+                };
+                if !usage.saw_u {
+                    continue;
+                }
 
-            let mut group = [left, right, other_two[0], other_two[1]];
-            group.sort_unstable();
-            if group.windows(2).any(|window| window[0] == window[1]) {
-                continue;
-            }
+                let mut group = [left, right, other_two[0], other_two[1]];
+                group.sort_unstable();
+                if group.windows(2).any(|window| window[0] == window[1]) {
+                    continue;
+                }
 
-            if let Some(source_triple) = self.decode_real_group(group) {
-                source_solution[source_triple] = 1;
+                if let Some(source_triple) = self.decode_real_group(group) {
+                    source_solution[source_triple] = true;
+                }
             }
-        }
 
-        source_solution
+            source_solution
+        })
     }
 }
 
@@ -378,25 +385,6 @@ enum TargetElement {
     Filler,
 }
 
-fn checked_mul(lhs: u128, rhs: u128, context: &str) -> u128 {
-    lhs.checked_mul(rhs)
-        .unwrap_or_else(|| panic!("{context} overflowed during multiplication"))
-}
-
-fn checked_add(lhs: u128, rhs: u128, context: &str) -> u128 {
-    lhs.checked_add(rhs)
-        .unwrap_or_else(|| panic!("{context} overflowed during addition"))
-}
-
-fn checked_sub(lhs: u128, rhs: u128, context: &str) -> u128 {
-    lhs.checked_sub(rhs)
-        .unwrap_or_else(|| panic!("{context} underflowed during subtraction"))
-}
-
-fn to_u64(value: u128, context: &str) -> u64 {
-    u64::try_from(value).unwrap_or_else(|_| panic!("{context} does not fit into u64"))
-}
-
 fn sorted_pair(a: usize, b: usize) -> [usize; 2] {
     if a <= b {
         [a, b]
@@ -405,36 +393,43 @@ fn sorted_pair(a: usize, b: usize) -> [usize; 2] {
     }
 }
 
-fn enumerate_pair_keys(num_regulars: usize) -> Vec<(usize, usize)> {
+fn enumerate_pair_keys(num_regulars: usize) -> Option<Vec<(usize, usize)>> {
     let capacity = num_regulars
         .checked_mul(num_regulars.saturating_sub(1))
-        .and_then(|value| value.checked_div(2))
-        .expect("pair count overflow for 4-Partition gadget");
+        .and_then(|value| value.checked_div(2))?;
     let mut pairs = Vec::with_capacity(capacity);
     for left in 0..num_regulars {
         for right in left + 1..num_regulars {
             pairs.push((left, right));
         }
     }
-    pairs
+    Some(pairs)
 }
 
-#[reduction(overhead = {
-    num_elements = "24 * num_triples * num_triples - 3 * num_triples",
-    num_groups = "8 * num_triples * num_triples - num_triples",
-})]
+#[reduction(
+    transform = exact {
+        num_elements = "24 * num_triples * num_triples - 3 * num_triples",
+        num_groups = "8 * num_triples * num_triples - num_triples",
+    })]
 impl ReduceTo<ThreePartition> for ThreeDimensionalMatching {
     type Result = ReductionThreeDimensionalMatchingToThreePartition;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let q = self.universe_size();
         let t = self.num_triples();
 
-        assert!(q > 0, "3DM -> ThreePartition requires universe_size > 0");
-        assert!(
-            t > 0,
-            "3DM -> ThreePartition requires at least one source triple"
-        );
+        if q == 0 {
+            return Err(crate::rules::ReductionError::invalid_target::<
+                ThreeDimensionalMatching,
+                ThreePartition,
+            >("source universe must be nonempty"));
+        }
+        if t == 0 {
+            return Err(crate::rules::ReductionError::invalid_target::<
+                ThreeDimensionalMatching,
+                ThreePartition,
+            >("source must contain at least one triple"));
+        }
 
         let mut covered_w = vec![false; q];
         let mut covered_x = vec![false; q];
@@ -448,20 +443,35 @@ impl ReduceTo<ThreePartition> for ThreeDimensionalMatching {
             || covered_x.iter().any(|&covered| !covered)
             || covered_y.iter().any(|&covered| !covered)
         {
-            return ReductionThreeDimensionalMatchingToThreePartition {
+            return Ok(ReductionThreeDimensionalMatchingToThreePartition {
                 target: ThreePartition::new(vec![6, 6, 6, 6, 7, 9], 20),
                 step2_items: Vec::new(),
                 pair_keys: Vec::new(),
                 num_source_triples: t,
-            };
+            });
         }
 
-        let q128 = q as u128;
-        let r = checked_mul(32, q128, "r = 32q");
-        let r2 = checked_mul(r, r, "r^2");
-        let r3 = checked_mul(r2, r, "r^3");
-        let r4 = checked_mul(r3, r, "r^4");
-        let target1 = checked_mul(40, r4, "T1 = 40r^4");
+        let arithmetic_overflow = |context| {
+            crate::rules::ReductionError::integer_overflow::<ThreeDimensionalMatching, ThreePartition>(
+                context,
+            )
+        };
+        let q = i64::try_from(q).map_err(|_| arithmetic_overflow("converting q to i64"))?;
+        let r = 32_i64
+            .checked_mul(q)
+            .ok_or_else(|| arithmetic_overflow("computing r = 32q"))?;
+        let r2 = r
+            .checked_mul(r)
+            .ok_or_else(|| arithmetic_overflow("computing r^2"))?;
+        let r3 = r2
+            .checked_mul(r)
+            .ok_or_else(|| arithmetic_overflow("computing r^3"))?;
+        let r4 = r3
+            .checked_mul(r)
+            .ok_or_else(|| arithmetic_overflow("computing r^4"))?;
+        let target1 = 40_i64
+            .checked_mul(r4)
+            .ok_or_else(|| arithmetic_overflow("computing the ABCD-Partition target"))?;
 
         let mut step2_items = Vec::with_capacity(4 * t);
         let mut step2_values = Vec::with_capacity(4 * t);
@@ -471,27 +481,21 @@ impl ReduceTo<ThreePartition> for ThreeDimensionalMatching {
         let mut seen_y = std::collections::HashSet::new();
 
         for (source_triple, &(w, x, y)) in self.triples().iter().enumerate() {
-            let w128 = w as u128;
-            let x128 = x as u128;
-            let y128 = y as u128;
-
-            let a_value = checked_sub(
-                checked_sub(
-                    checked_sub(
-                        checked_mul(10, r4, "A digit"),
-                        checked_mul(y128, r3, "A y-term"),
-                        "A after y",
-                    ),
-                    checked_mul(x128, r2, "A x-term"),
-                    "A after x",
-                ),
-                checked_mul(w128, r, "A w-term"),
-                "A after w",
-            );
-            step2_values.push(to_u64(
-                checked_add(checked_mul(16, a_value, "step2 A"), 1, "step2 A tag"),
-                "step2 A",
-            ));
+            let w_num = i64::try_from(w).map_err(|_| arithmetic_overflow("converting w to i64"))?;
+            let x_num = i64::try_from(x).map_err(|_| arithmetic_overflow("converting x to i64"))?;
+            let y_num = i64::try_from(y).map_err(|_| arithmetic_overflow("converting y to i64"))?;
+
+            let a_value = 10_i64
+                .checked_mul(r4)
+                .and_then(|value| value.checked_sub(y_num.checked_mul(r3)?))
+                .and_then(|value| value.checked_sub(x_num.checked_mul(r2)?))
+                .and_then(|value| value.checked_sub(w_num.checked_mul(r)?))
+                .ok_or_else(|| arithmetic_overflow("computing an A item"))?;
+            let step2_a = 16_i64
+                .checked_mul(a_value)
+                .and_then(|value| value.checked_add(1))
+                .ok_or_else(|| arithmetic_overflow("encoding an A item"))?;
+            step2_values.push(step2_a);
             step2_items.push(Step2Item::A {
                 source_triple,
                 w,
@@ -500,141 +504,146 @@ impl ReduceTo<ThreePartition> for ThreeDimensionalMatching {
             });
 
             let w_first = seen_w.insert(w);
-            let b_digit = if w_first { 10 } else { 11 };
-            let b_value = checked_add(
-                checked_mul(b_digit, r4, "B digit"),
-                checked_mul(w128, r, "B coordinate"),
-                "B value",
-            );
-            step2_values.push(to_u64(
-                checked_add(checked_mul(16, b_value, "step2 B"), 2, "step2 B tag"),
-                "step2 B",
-            ));
+            let b_digit: i64 = if w_first { 10 } else { 11 };
+            let b_value = b_digit
+                .checked_mul(r4)
+                .and_then(|value| value.checked_add(w_num.checked_mul(r)?))
+                .ok_or_else(|| arithmetic_overflow("computing a B item"))?;
+            let step2_b = 16_i64
+                .checked_mul(b_value)
+                .and_then(|value| value.checked_add(2))
+                .ok_or_else(|| arithmetic_overflow("encoding a B item"))?;
+            step2_values.push(step2_b);
             step2_items.push(Step2Item::B {
                 w,
                 first_occurrence: w_first,
             });
 
             let x_first = seen_x.insert(x);
-            let c_digit = if x_first { 10 } else { 11 };
-            let c_value = checked_add(
-                checked_mul(c_digit, r4, "C digit"),
-                checked_mul(x128, r2, "C coordinate"),
-                "C value",
-            );
-            step2_values.push(to_u64(
-                checked_add(checked_mul(16, c_value, "step2 C"), 4, "step2 C tag"),
-                "step2 C",
-            ));
+            let c_digit: i64 = if x_first { 10 } else { 11 };
+            let c_value = c_digit
+                .checked_mul(r4)
+                .and_then(|value| value.checked_add(x_num.checked_mul(r2)?))
+                .ok_or_else(|| arithmetic_overflow("computing a C item"))?;
+            let step2_c = 16_i64
+                .checked_mul(c_value)
+                .and_then(|value| value.checked_add(4))
+                .ok_or_else(|| arithmetic_overflow("encoding a C item"))?;
+            step2_values.push(step2_c);
             step2_items.push(Step2Item::C {
                 x,
                 first_occurrence: x_first,
             });
 
             let y_first = seen_y.insert(y);
-            let d_digit = if y_first { 10 } else { 8 };
-            let d_value = checked_add(
-                checked_mul(d_digit, r4, "D digit"),
-                checked_mul(y128, r3, "D coordinate"),
-                "D value",
-            );
-            step2_values.push(to_u64(
-                checked_add(checked_mul(16, d_value, "step2 D"), 8, "step2 D tag"),
-                "step2 D",
-            ));
+            let d_digit: i64 = if y_first { 10 } else { 8 };
+            let d_value = d_digit
+                .checked_mul(r4)
+                .and_then(|value| value.checked_add(y_num.checked_mul(r3)?))
+                .ok_or_else(|| arithmetic_overflow("computing a D item"))?;
+            let step2_d = 16_i64
+                .checked_mul(d_value)
+                .and_then(|value| value.checked_add(8))
+                .ok_or_else(|| arithmetic_overflow("encoding a D item"))?;
+            step2_values.push(step2_d);
             step2_items.push(Step2Item::D {
                 y,
                 first_occurrence: y_first,
             });
         }
 
-        let target2 = checked_add(checked_mul(16, target1, "T2 base"), 15, "T2");
-        let pair_keys = enumerate_pair_keys(step2_values.len());
-
+        let target2 = 16_i64
+            .checked_mul(target1)
+            .and_then(|value| value.checked_add(15))
+            .ok_or_else(|| arithmetic_overflow("computing the 4-Partition target"))?;
+        let pair_keys = enumerate_pair_keys(step2_values.len())
+            .ok_or_else(|| arithmetic_overflow("computing the 4-Partition pair count"))?;
+
+        let subtract_fillers =
+            3usize.checked_mul(t).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    ThreeDimensionalMatching,
+                    ThreePartition,
+                >("computing the filler count")
+            })?;
         let num_fillers = 8usize
             .checked_mul(t)
             .and_then(|value| value.checked_mul(t))
-            .and_then(|value| value.checked_sub(3 * t))
-            .expect("filler count overflow");
-
+            .and_then(|value| value.checked_sub(subtract_fillers))
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    ThreeDimensionalMatching,
+                    ThreePartition,
+                >("computing the filler count")
+            })?;
+
+        let pair_elements =
+            2usize.checked_mul(pair_keys.len()).ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    ThreeDimensionalMatching,
+                    ThreePartition,
+                >("computing the number of pair elements")
+            })?;
         let total_elements = step2_values
             .len()
-            .checked_add(2 * pair_keys.len())
+            .checked_add(pair_elements)
             .and_then(|value| value.checked_add(num_fillers))
-            .expect("3-Partition element count overflow");
+            .ok_or_else(|| {
+                crate::rules::ReductionError::integer_overflow::<
+                    ThreeDimensionalMatching,
+                    ThreePartition,
+                >("computing the target element count")
+            })?;
 
         let mut sizes = Vec::with_capacity(total_elements);
 
         for &step2_value in &step2_values {
-            let regular = checked_add(
-                checked_mul(
-                    4,
-                    checked_add(
-                        checked_mul(5, target2, "regular base"),
-                        u128::from(step2_value),
-                        "regular inner",
-                    ),
-                    "regular outer",
-                ),
-                1,
-                "regular tag",
-            );
-            sizes.push(to_u64(regular, "regular element"));
+            let regular = 5_i64
+                .checked_mul(target2)
+                .and_then(|value| value.checked_add(step2_value))
+                .and_then(|value| value.checked_mul(4))
+                .and_then(|value| value.checked_add(1))
+                .ok_or_else(|| arithmetic_overflow("computing a regular element"))?;
+            sizes.push(regular);
         }
 
         for &(left, right) in &pair_keys {
-            let a_i = u128::from(step2_values[left]);
-            let a_j = u128::from(step2_values[right]);
-
-            let u_value = checked_add(
-                checked_mul(
-                    4,
-                    checked_sub(
-                        checked_mul(6, target2, "u base"),
-                        checked_add(a_i, a_j, "u pair sum"),
-                        "u inner",
-                    ),
-                    "u outer",
-                ),
-                2,
-                "u tag",
-            );
-            sizes.push(to_u64(u_value, "pairing u element"));
-
-            let uprime_value = checked_add(
-                checked_mul(
-                    4,
-                    checked_add(
-                        checked_mul(5, target2, "u' base"),
-                        checked_add(a_i, a_j, "u' pair sum"),
-                        "u' inner",
-                    ),
-                    "u' outer",
-                ),
-                2,
-                "u' tag",
-            );
-            sizes.push(to_u64(uprime_value, "pairing u' element"));
+            let pair_sum = step2_values[left]
+                .checked_add(step2_values[right])
+                .ok_or_else(|| arithmetic_overflow("summing paired 4-Partition elements"))?;
+            let u_value = 6_i64
+                .checked_mul(target2)
+                .and_then(|value| value.checked_sub(pair_sum))
+                .and_then(|value| value.checked_mul(4))
+                .and_then(|value| value.checked_add(2))
+                .ok_or_else(|| arithmetic_overflow("computing a pairing u element"))?;
+            sizes.push(u_value);
+
+            let uprime_value = 5_i64
+                .checked_mul(target2)
+                .and_then(|value| value.checked_add(pair_sum))
+                .and_then(|value| value.checked_mul(4))
+                .and_then(|value| value.checked_add(2))
+                .ok_or_else(|| arithmetic_overflow("computing a pairing u' element"))?;
+            sizes.push(uprime_value);
         }
 
-        let filler_value = to_u64(checked_mul(20, target2, "filler"), "filler element");
+        let filler_value = 20_i64
+            .checked_mul(target2)
+            .ok_or_else(|| arithmetic_overflow("computing a filler element"))?;
         sizes.extend(std::iter::repeat_n(filler_value, num_fillers));
 
-        let bound = to_u64(
-            checked_add(
-                checked_mul(64, target2, "3-Partition bound"),
-                4,
-                "3-Partition bound tag",
-            ),
-            "3-Partition bound",
-        );
+        let bound = 64_i64
+            .checked_mul(target2)
+            .and_then(|value| value.checked_add(4))
+            .ok_or_else(|| arithmetic_overflow("computing the 3-Partition bound"))?;
 
-        ReductionThreeDimensionalMatchingToThreePartition {
+        Ok(ReductionThreeDimensionalMatchingToThreePartition {
             target: ThreePartition::new(sizes, bound),
             step2_items,
             pair_keys,
             num_source_triples: t,
-        }
+        })
     }
 }
 
@@ -648,10 +657,10 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ThreePartition>(
                 ThreeDimensionalMatching::new(1, vec![(0, 0, 0)]),
                 SolutionPair {
-                    source_config: vec![1],
-                    target_config: vec![
+                    source_config: serde_json::json!(vec![true]),
+                    target_config: serde_json::json!(vec![
                         0, 0, 1, 1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 2, 3, 4, 5, 6,
-                    ],
+                    ]),
                 },
             )
         },
diff --git a/src/rules/threepartition_resourceconstrainedscheduling.rs b/src/rules/threepartition_resourceconstrainedscheduling.rs
index 61895a45b..817ace389 100644
--- a/src/rules/threepartition_resourceconstrainedscheduling.rs
+++ b/src/rules/threepartition_resourceconstrainedscheduling.rs
@@ -38,32 +38,55 @@ impl ReductionResult for ReductionThreePartitionToRCS {
 
     /// Solution extraction: identity mapping.
     /// ThreePartition config (group index 0..m-1) maps directly to time slot assignment.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok(target_solution.to_vec())
     }
 }
 
-#[reduction(overhead = {
-    num_tasks = "num_elements",
-})]
+#[reduction(
+    transform = exact {
+        num_tasks = "num_elements",
+    },
+    unavailable = {
+        deadline = "the exact target parameter is not represented by this reduction's symbolic transform",
+        num_resources = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<ResourceConstrainedScheduling> for ThreePartition {
     type Result = ReductionThreePartitionToRCS;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let m = self.num_groups();
         let bound = self.bound();
+        let deadline = i64::try_from(m).map_err(|_| {
+            crate::rules::ReductionError::integer_overflow::<
+                ThreePartition,
+                ResourceConstrainedScheduling,
+            >("converting the number of groups to a scheduling deadline")
+        })?;
 
         // Each element becomes a task with resource requirement = element size
-        let resource_requirements: Vec<Vec<u64>> = self.sizes().iter().map(|&s| vec![s]).collect();
+        let resource_requirements: Vec<Vec<i64>> = self.sizes().iter().map(|&s| vec![s]).collect();
 
-        ReductionThreePartitionToRCS {
+        Ok(ReductionThreePartitionToRCS {
             target: ResourceConstrainedScheduling::new(
                 3,           // 3 processors
                 vec![bound], // 1 resource with bound B
                 resource_requirements,
-                m as u64, // deadline = m time slots
-            ),
-        }
+                deadline,
+            )
+            .map_err(|error| {
+                crate::rules::ReductionError::construction::<
+                    ThreePartition,
+                    ResourceConstrainedScheduling,
+                >(error)
+            })?,
+        })
     }
 }
 
@@ -80,8 +103,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             crate::example_db::specs::rule_example_with_witness::<_, ResourceConstrainedScheduling>(
                 ThreePartition::new(vec![4, 5, 6, 4, 6, 5], 15),
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 1, 1, 1],
-                    target_config: vec![0, 0, 0, 1, 1, 1],
+                    source_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1]),
+                    target_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1]),
                 },
             )
         },
diff --git a/src/rules/threepartition_sequencingwithreleasetimesanddeadlines.rs b/src/rules/threepartition_sequencingwithreleasetimesanddeadlines.rs
index 976c6ee5d..d1b480304 100644
--- a/src/rules/threepartition_sequencingwithreleasetimesanddeadlines.rs
+++ b/src/rules/threepartition_sequencingwithreleasetimesanddeadlines.rs
@@ -32,7 +32,7 @@ pub struct ReductionThreePartitionToSRTD {
     /// Number of element tasks (3m) — first 3m tasks in the target are element tasks.
     num_element_tasks: usize,
     /// The bound B from the source.
-    bound: u64,
+    bound: i64,
 }
 
 impl ReductionResult for ReductionThreePartitionToSRTD {
@@ -45,51 +45,83 @@ impl ReductionResult for ReductionThreePartitionToSRTD {
 
     /// Extract a ThreePartition config from a target schedule config.
     ///
-    /// Decode the Lehmer code to a task permutation, simulate the schedule to
-    /// find each task's start time, then assign each element task to its slot
+    /// Simulate the task permutation to find each task's start time, then assign each element task to its slot
     /// based on start_time / (B + 1).
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.target.num_tasks();
-        // Decode Lehmer code to permutation
-        let schedule = crate::models::misc::decode_lehmer(target_solution, n)
-            .expect("target_solution must be a valid Lehmer code");
-
-        // Simulate the schedule to find start times
-        let mut current_time: u64 = 0;
-        let mut slot_assignment = vec![0usize; self.num_element_tasks];
-        let slot_width = self.bound + 1; // B + 1 (slot width including the filler gap)
-
-        for &task in &schedule {
-            let start = current_time.max(self.target.release_times()[task]);
-            let finish = start + self.target.lengths()[task];
-            current_time = finish;
-
-            // Only element tasks (indices 0..3m) contribute to the partition
-            if task < self.num_element_tasks {
-                let slot = (start / slot_width) as usize;
-                slot_assignment[task] = slot;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            // Simulate the schedule to find start times
+            let mut current_time: i64 = 0;
+            let mut slot_assignment = vec![0usize; self.num_element_tasks];
+            let slot_width = self.bound.checked_add(1).ok_or_else(|| {
+                crate::rules::ExtractionError::invalid("slot width overflows i64")
+            })?; // B + 1 (slot width including the filler gap)
+
+            for &task in target_solution {
+                let start = current_time.max(self.target.release_times()[task]);
+                let finish = start
+                    .checked_add(self.target.lengths()[task])
+                    .ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid("task finish time overflows i64")
+                    })?;
+                current_time = finish;
+
+                // Only element tasks (indices 0..3m) contribute to the partition
+                if task < self.num_element_tasks {
+                    let slot = usize::try_from(start / slot_width).map_err(|_| {
+                        crate::rules::ExtractionError::invalid(
+                            "decoded task slot cannot be represented as usize",
+                        )
+                    })?;
+                    slot_assignment[task] = slot;
+                }
             }
-        }
 
-        slot_assignment
+            slot_assignment
+        })
     }
 }
 
-#[reduction(overhead = {
-    num_tasks = "num_elements + num_groups - 1",
-})]
+#[reduction(
+    transform = exact {
+        num_tasks = "num_elements + num_groups - 1",
+    },
+    unavailable = {
+        time_horizon = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<SequencingWithReleaseTimesAndDeadlines> for ThreePartition {
     type Result = ReductionThreePartitionToSRTD;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n_elem = num_element_tasks(self);
         let n_fill = num_filler_tasks(self);
         let m = self.num_groups();
         let b = self.bound();
-        let total_tasks = n_elem + n_fill;
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<
+                Self,
+                SequencingWithReleaseTimesAndDeadlines,
+            >(operation)
+        };
+        let total_tasks = n_elem
+            .checked_add(n_fill)
+            .ok_or_else(|| overflow("computing the target task count"))?;
 
         // Time horizon: m*B + (m-1) = m*(B+1) - 1
-        let horizon = (m as u64) * (b + 1) - 1;
+        let group_count =
+            i64::try_from(m).map_err(|_| overflow("converting the group count to i64"))?;
+        let slot_width = b
+            .checked_add(1)
+            .ok_or_else(|| overflow("computing the slot width"))?;
+        let horizon = group_count
+            .checked_mul(slot_width)
+            .and_then(|value| value.checked_sub(1))
+            .ok_or_else(|| overflow("computing the scheduling horizon"))?;
 
         let mut lengths = Vec::with_capacity(total_tasks);
         let mut release_times = Vec::with_capacity(total_tasks);
@@ -106,17 +138,29 @@ impl ReduceTo<SequencingWithReleaseTimesAndDeadlines> for ThreePartition {
         for j in 0..n_fill {
             // Filler j separates slot j from slot j+1
             // Release = (j+1)*B + j, Deadline = (j+1)*B + j + 1
-            let release = ((j + 1) as u64) * b + (j as u64);
+            let separator =
+                i64::try_from(j).map_err(|_| overflow("converting a filler-task index to i64"))?;
+            let next_separator = separator
+                .checked_add(1)
+                .ok_or_else(|| overflow("computing a filler-task index"))?;
+            let release = next_separator
+                .checked_mul(b)
+                .and_then(|value| value.checked_add(separator))
+                .ok_or_else(|| overflow("computing a filler-task release time"))?;
             lengths.push(1);
             release_times.push(release);
-            deadlines.push(release + 1);
+            deadlines.push(
+                release
+                    .checked_add(1)
+                    .ok_or_else(|| overflow("computing a filler-task deadline"))?,
+            );
         }
 
-        ReductionThreePartitionToSRTD {
+        Ok(ReductionThreePartitionToSRTD {
             target: SequencingWithReleaseTimesAndDeadlines::new(lengths, release_times, deadlines),
             num_element_tasks: n_elem,
             bound: b,
-        }
+        })
     }
 }
 
@@ -151,8 +195,8 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
             >(
                 ThreePartition::new(vec![4, 5, 6, 4, 6, 5], 15),
                 SolutionPair {
-                    source_config: vec![0, 0, 0, 1, 1, 1],
-                    target_config: vec![0, 0, 0, 3, 0, 0, 0],
+                    source_config: serde_json::json!(vec![0, 0, 0, 1, 1, 1]),
+                    target_config: serde_json::json!(vec![0, 1, 2, 6, 3, 4, 5]),
                 },
             )
         },
diff --git a/src/rules/timetabledesign_ilp.rs b/src/rules/timetabledesign_ilp.rs
index f235918e5..9e771d48e 100644
--- a/src/rules/timetabledesign_ilp.rs
+++ b/src/rules/timetabledesign_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from TimetableDesign to ILP<bool>.
+//! Reduction from TimetableDesign to `ILP<bool>`.
 //!
 //! The source witness is a binary craftsman-task-period incidence table,
 //! and all feasibility conditions are already linear: availability forcing,
@@ -9,13 +9,16 @@ use crate::models::misc::TimetableDesign;
 use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 
-/// Result of reducing TimetableDesign to ILP<bool>.
+/// Result of reducing TimetableDesign to `ILP<bool>`.
 ///
 /// Variable layout: x_{c,t,h} at index `((c * num_tasks) + t) * num_periods + h`
 /// exactly matching the source configuration layout.
 #[derive(Debug, Clone)]
 pub struct ReductionTDToILP {
     target: ILP<bool>,
+    num_craftsmen: usize,
+    num_tasks: usize,
+    num_periods: usize,
 }
 
 impl ReductionResult for ReductionTDToILP {
@@ -28,22 +31,48 @@ impl ReductionResult for ReductionTDToILP {
 
     /// Extract: direct identity mapping — the ILP variable layout matches the
     /// source configuration layout exactly.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok((0..self.num_craftsmen)
+            .map(|craftsman| {
+                (0..self.num_tasks)
+                    .map(|task| {
+                        (0..self.num_periods)
+                            .map(|period| {
+                                let index = ((craftsman * self.num_tasks) + task)
+                                    * self.num_periods
+                                    + period;
+                                target_solution[index] == 1
+                            })
+                            .collect()
+                    })
+                    .collect()
+            })
+            .collect())
     }
 }
 
-#[reduction(overhead = {
-    num_vars = "num_craftsmen * num_tasks * num_periods",
-    num_constraints = "num_craftsmen * num_periods + num_tasks * num_periods + num_craftsmen * num_tasks",
-})]
+#[reduction(
+    transform = exact {
+        num_vars = "num_craftsmen * num_tasks * num_periods",
+        num_constraints = "num_craftsmen * num_periods + num_tasks * num_periods + num_craftsmen * num_tasks",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
+    }
+)]
 impl ReduceTo<ILP<bool>> for TimetableDesign {
     type Result = ReductionTDToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let nc = self.num_craftsmen();
         let nt = self.num_tasks();
         let nh = self.num_periods();
+        let requirements = self.requirements();
         let num_vars = nc * nt * nh;
 
         let var = |c: usize, t: usize, h: usize| -> usize { ((c * nt) + t) * nh + h };
@@ -55,7 +84,7 @@ impl ReduceTo<ILP<bool>> for TimetableDesign {
             for t in 0..nt {
                 for h in 0..nh {
                     if !self.craftsman_avail()[c][h] || !self.task_avail()[t][h] {
-                        constraints.push(LinearConstraint::eq(vec![(var(c, t, h), 1.0)], 0.0));
+                        constraints.push(LinearConstraint::eq(vec![(var(c, t, h), 1)], 0));
                     }
                 }
             }
@@ -64,33 +93,34 @@ impl ReduceTo<ILP<bool>> for TimetableDesign {
         // 2. Each craftsman works on at most one task per period: Σ_t x_{c,t,h} <= 1 for all c, h
         for c in 0..nc {
             for h in 0..nh {
-                let terms: Vec<(usize, f64)> = (0..nt).map(|t| (var(c, t, h), 1.0)).collect();
-                constraints.push(LinearConstraint::le(terms, 1.0));
+                let terms: Vec<(usize, i64)> = (0..nt).map(|t| (var(c, t, h), 1)).collect();
+                constraints.push(LinearConstraint::le(terms, 1));
             }
         }
 
         // 3. Each task worked on by at most one craftsman per period: Σ_c x_{c,t,h} <= 1 for all t, h
         for t in 0..nt {
             for h in 0..nh {
-                let terms: Vec<(usize, f64)> = (0..nc).map(|c| (var(c, t, h), 1.0)).collect();
-                constraints.push(LinearConstraint::le(terms, 1.0));
+                let terms: Vec<(usize, i64)> = (0..nc).map(|c| (var(c, t, h), 1)).collect();
+                constraints.push(LinearConstraint::le(terms, 1));
             }
         }
 
         // 4. Exact requirements: Σ_h x_{c,t,h} = r_{c,t} for all c, t
-        for c in 0..nc {
-            for t in 0..nt {
-                let terms: Vec<(usize, f64)> = (0..nh).map(|h| (var(c, t, h), 1.0)).collect();
-                constraints.push(LinearConstraint::eq(
-                    terms,
-                    self.requirements()[c][t] as f64,
-                ));
+        for (c, row) in requirements.iter().enumerate() {
+            for (t, &requirement) in row.iter().enumerate() {
+                let terms: Vec<(usize, i64)> = (0..nh).map(|h| (var(c, t, h), 1)).collect();
+                constraints.push(LinearConstraint::eq(terms, requirement));
             }
         }
 
-        ReductionTDToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
-        }
+        Ok(ReductionTDToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
+            num_craftsmen: nc,
+            num_tasks: nt,
+            num_periods: nh,
+        })
     }
 }
 
diff --git a/src/rules/traits.rs b/src/rules/traits.rs
index a46dc19ec..c33c39754 100644
--- a/src/rules/traits.rs
+++ b/src/rules/traits.rs
@@ -6,6 +6,168 @@ use serde::Serialize;
 use std::any::Any;
 use std::marker::PhantomData;
 
+/// Failure to construct a target instance for a registered reduction edge.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum ReductionError {
+    #[error("{source_problem} -> {target_problem}: target construction failed: {cause}")]
+    Construction {
+        source_problem: &'static str,
+        target_problem: &'static str,
+        #[source]
+        cause: crate::registry::ConstructionError,
+    },
+    #[error("{source_problem} -> {target_problem}: integer overflow while {operation}")]
+    IntegerOverflow {
+        source_problem: &'static str,
+        target_problem: &'static str,
+        operation: String,
+    },
+    #[error("{source_problem} -> {target_problem}: non-finite value while {operation}")]
+    NonFiniteResult {
+        source_problem: &'static str,
+        target_problem: &'static str,
+        operation: String,
+    },
+    #[error("{source_problem} -> {target_problem}: {cause}")]
+    InexactFloatConversion {
+        source_problem: &'static str,
+        target_problem: &'static str,
+        #[source]
+        cause: crate::types::ExactI64ToF64Error,
+    },
+    #[error("{source_problem} -> {target_problem}: {message}")]
+    InvalidTarget {
+        source_problem: &'static str,
+        target_problem: &'static str,
+        message: String,
+    },
+    #[error(
+        "{source_problem} -> {target_problem}: reduction executor expected source type `{expected}`"
+    )]
+    SourceTypeMismatch {
+        source_problem: &'static str,
+        target_problem: &'static str,
+        expected: &'static str,
+    },
+}
+
+impl ReductionError {
+    pub(crate) fn for_reduction<S: Problem, T: Problem>(self) -> Self {
+        match self {
+            Self::Construction { cause, .. } => Self::construction::<S, T>(cause),
+            Self::IntegerOverflow { operation, .. } => Self::integer_overflow::<S, T>(operation),
+            Self::NonFiniteResult { operation, .. } => Self::non_finite_result::<S, T>(operation),
+            Self::InexactFloatConversion { cause, .. } => {
+                Self::inexact_float_conversion::<S, T>(cause)
+            }
+            Self::InvalidTarget { message, .. } => Self::invalid_target::<S, T>(message),
+            Self::SourceTypeMismatch { expected, .. } => Self::SourceTypeMismatch {
+                source_problem: S::NAME,
+                target_problem: T::NAME,
+                expected,
+            },
+        }
+    }
+
+    /// Report that a type-erased executor received the wrong source problem type.
+    pub fn source_type_mismatch<S: Problem, T: Problem>() -> Self {
+        Self::SourceTypeMismatch {
+            source_problem: S::NAME,
+            target_problem: T::NAME,
+            expected: std::any::type_name::<S>(),
+        }
+    }
+
+    /// Report integer overflow while constructing a reduction target.
+    pub fn integer_overflow<S: Problem, T: Problem>(operation: impl Into<String>) -> Self {
+        Self::IntegerOverflow {
+            source_problem: S::NAME,
+            target_problem: T::NAME,
+            operation: operation.into(),
+        }
+    }
+
+    /// Report that an exact integer cannot be represented in a floating-point target field.
+    pub fn inexact_float_conversion<S: Problem, T: Problem>(
+        cause: crate::types::ExactI64ToF64Error,
+    ) -> Self {
+        Self::InexactFloatConversion {
+            source_problem: S::NAME,
+            target_problem: T::NAME,
+            cause,
+        }
+    }
+
+    /// Report non-finite arithmetic while constructing a reduction target.
+    pub fn non_finite_result<S: Problem, T: Problem>(operation: impl Into<String>) -> Self {
+        Self::NonFiniteResult {
+            source_problem: S::NAME,
+            target_problem: T::NAME,
+            operation: operation.into(),
+        }
+    }
+
+    /// Report that derived data cannot form a valid reduction target.
+    pub fn invalid_target<S: Problem, T: Problem>(message: impl Into<String>) -> Self {
+        Self::InvalidTarget {
+            source_problem: S::NAME,
+            target_problem: T::NAME,
+            message: message.into(),
+        }
+    }
+
+    /// Preserve a target constructor's validation error with edge context.
+    pub fn construction<S: Problem, T: Problem>(cause: crate::registry::ConstructionError) -> Self {
+        Self::Construction {
+            source_problem: S::NAME,
+            target_problem: T::NAME,
+            cause,
+        }
+    }
+}
+
+/// Failure to map a target witness back into the source configuration space.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum ExtractionError {
+    #[error("{0}")]
+    InvalidTargetSolution(String),
+    #[error("{source_problem} -> {target_problem}: {message}")]
+    Reduction {
+        source_problem: &'static str,
+        target_problem: &'static str,
+        message: String,
+    },
+    #[error("target evaluation failed during extraction: {0}")]
+    Evaluation(#[from] crate::traits::EvaluationError),
+}
+
+impl ExtractionError {
+    pub fn invalid(message: impl Into<String>) -> Self {
+        Self::InvalidTargetSolution(message.into())
+    }
+
+    fn for_reduction<S: Problem, T: Problem>(self) -> Self {
+        match self {
+            Self::InvalidTargetSolution(message) => Self::Reduction {
+                source_problem: S::NAME,
+                target_problem: T::NAME,
+                message,
+            },
+            error => error,
+        }
+    }
+}
+
+pub type ExtractionResult<T> = std::result::Result<T, ExtractionError>;
+
+/// Validate a typed target solution and return its evaluated value for reuse.
+pub(crate) fn validate_target_solution<P: Problem>(
+    target: &P,
+    solution: &P::Solution,
+) -> ExtractionResult<P::Value> {
+    Ok(target.evaluate(solution)?)
+}
+
 /// Result of reducing a source problem to a target problem.
 ///
 /// This trait encapsulates the target problem and provides methods
@@ -26,7 +188,10 @@ pub trait ReductionResult {
     ///
     /// # Returns
     /// The corresponding solution in the source problem space
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize>;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> ExtractionResult<<Self::Source as crate::traits::Problem>::Solution>;
 }
 
 /// Trait for problems that can be reduced to target type T.
@@ -46,12 +211,12 @@ pub trait ReductionResult {
 /// );
 ///
 /// // Reduce to Independent Set
-/// let reduction = sat_problem.reduce_to();
+/// let reduction = sat_problem.reduce_to().expect("reduction should succeed");
 /// let is_problem = reduction.target_problem();
 ///
 /// // Solve and extract solutions
 /// let solver = BruteForce::new();
-/// let solutions = solver.find_all_witnesses(is_problem);
+/// let solutions = solver.find_all_witnesses(is_problem).unwrap();
 /// let sat_solutions: Vec<_> = solutions.iter()
 ///     .map(|s| reduction.extract_solution(s))
 ///     .collect();
@@ -60,8 +225,24 @@ pub trait ReduceTo<T: Problem>: Problem {
     /// The reduction result type.
     type Result: ReductionResult<Source = Self, Target = T>;
 
+    /// Attach this reduction edge to a target-construction failure.
+    fn target_construction(error: crate::registry::ConstructionError) -> ReductionError
+    where
+        Self: Sized,
+    {
+        ReductionError::construction::<Self, T>(error)
+    }
+
+    /// Convert a structural count used by the target's exact integer algebra.
+    fn exact_i64(value: usize, operation: impl Into<String>) -> Result<i64, ReductionError>
+    where
+        Self: Sized,
+    {
+        i64::try_from(value).map_err(|_| ReductionError::integer_overflow::<Self, T>(operation))
+    }
+
     /// Reduce this problem to the target problem type.
-    fn reduce_to(&self) -> Self::Result;
+    fn reduce_to(&self) -> Result<Self::Result, ReductionError>;
 }
 
 /// Result of reducing a source problem to a target problem for aggregate values.
@@ -80,8 +261,8 @@ pub trait AggregateReductionResult {
     /// Extract an aggregate value from target problem space back to source space.
     fn extract_value(
         &self,
-        target_value: <Self::Target as Problem>::Value,
-    ) -> <Self::Source as Problem>::Value;
+        target_value: <Self::Target as crate::traits::Problem>::Value,
+    ) -> <Self::Source as crate::traits::Problem>::Value;
 }
 
 /// Trait for problems that can be reduced to target type T for aggregate-value
@@ -91,23 +272,20 @@ pub trait ReduceToAggregate<T: Problem>: Problem {
     type Result: AggregateReductionResult<Source = Self, Target = T>;
 
     /// Reduce this problem to the target problem type.
-    fn reduce_to_aggregate(&self) -> Self::Result;
+    fn reduce_to_aggregate(&self) -> Result<Self::Result, ReductionError>;
 }
 
-/// Generic reduction result for natural-edge (subtype) reductions.
+/// Reduction result for an explicit conversion between variants of one model.
 ///
-/// Used when a problem on a specific graph type is trivially reducible to
-/// the same problem on a more general graph type (e.g., `MIS<Triangular>` →
-/// `MIS<SimpleGraph>`). The solution mapping is identity — vertex indices
-/// are preserved.
+/// The target witness is also the source witness.
 #[derive(Debug, Clone)]
-pub struct ReductionAutoCast<S: Problem, T: Problem> {
+pub struct VariantReductionResult<S: Problem, T: Problem> {
     target: T,
     _phantom: PhantomData<S>,
 }
 
-impl<S: Problem, T: Problem> ReductionAutoCast<S, T> {
-    /// Create a new auto-cast reduction result.
+impl<S: Problem, T: Problem> VariantReductionResult<S, T> {
+    /// Store the constructed target variant.
     pub fn new(target: T) -> Self {
         Self {
             target,
@@ -116,7 +294,12 @@ impl<S: Problem, T: Problem> ReductionAutoCast<S, T> {
     }
 }
 
-impl<S: Problem, T: Problem> ReductionResult for ReductionAutoCast<S, T> {
+impl<S, T> ReductionResult for VariantReductionResult<S, T>
+where
+    S: Problem,
+    T: Problem<Solution = S::Solution>,
+    S::Solution: Clone,
+{
     type Source = S;
     type Target = T;
 
@@ -124,13 +307,14 @@ impl<S: Problem, T: Problem> ReductionResult for ReductionAutoCast<S, T> {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(&self, target_solution: &T::Solution) -> ExtractionResult<S::Solution> {
+        validate_target_solution(self.target_problem(), target_solution)?;
+        Ok(target_solution.clone())
     }
 }
 
 impl<S: Problem, T: Problem<Value = S::Value>> AggregateReductionResult
-    for ReductionAutoCast<S, T>
+    for VariantReductionResult<S, T>
 {
     type Source = S;
     type Target = T;
@@ -152,18 +336,65 @@ pub trait DynReductionResult {
     /// Get the target problem as a type-erased reference.
     fn target_problem_any(&self) -> &dyn Any;
     /// Extract a solution from target space to source space.
-    fn extract_solution_dyn(&self, target_solution: &[usize]) -> Vec<usize>;
+    fn extract_solution_dyn(&self, target_solution: &dyn Any) -> ExtractionResult<Box<dyn Any>>;
+    /// Serialize a source-space solution after the complete extraction chain.
+    fn source_solution_json(
+        &self,
+        source_solution: &dyn Any,
+    ) -> ExtractionResult<serde_json::Value>;
+    /// Deserialize the concrete target witness at the dynamic boundary.
+    fn target_solution_from_json(
+        &self,
+        target_solution: serde_json::Value,
+    ) -> ExtractionResult<Box<dyn Any>>;
 }
 
 impl<R: ReductionResult + 'static> DynReductionResult for R
 where
     R::Target: 'static,
+    <R::Target as Problem>::Solution: 'static,
+    <R::Target as Problem>::Solution: serde::de::DeserializeOwned,
+    <R::Source as Problem>::Solution: 'static,
+    <R::Source as Problem>::Solution: serde::Serialize,
 {
     fn target_problem_any(&self) -> &dyn Any {
         self.target_problem() as &dyn Any
     }
-    fn extract_solution_dyn(&self, target_solution: &[usize]) -> Vec<usize> {
+    fn extract_solution_dyn(&self, target_solution: &dyn Any) -> ExtractionResult<Box<dyn Any>> {
+        let target_solution = target_solution
+            .downcast_ref::<<R::Target as Problem>::Solution>()
+            .ok_or_else(|| {
+                ExtractionError::invalid(format!(
+                    "target solution type mismatch: expected {}",
+                    std::any::type_name::<<R::Target as Problem>::Solution>()
+                ))
+            })?;
         self.extract_solution(target_solution)
+            .map(|solution| Box::new(solution) as Box<dyn Any>)
+            .map_err(|error| error.for_reduction::<R::Source, R::Target>())
+    }
+
+    fn source_solution_json(
+        &self,
+        source_solution: &dyn Any,
+    ) -> ExtractionResult<serde_json::Value> {
+        let source_solution = source_solution
+            .downcast_ref::<<R::Source as Problem>::Solution>()
+            .ok_or_else(|| ExtractionError::invalid("source solution type mismatch"))?;
+        serde_json::to_value(source_solution).map_err(|error| {
+            ExtractionError::invalid(format!("source solution serialization failed: {error}"))
+        })
+    }
+
+    fn target_solution_from_json(
+        &self,
+        target_solution: serde_json::Value,
+    ) -> ExtractionResult<Box<dyn Any>> {
+        serde_json::from_value::<<R::Target as Problem>::Solution>(target_solution)
+            .map(|solution| Box::new(solution) as Box<dyn Any>)
+            .map_err(|error| {
+                ExtractionError::invalid(format!("target solution deserialization failed: {error}"))
+            })
     }
 }
 
@@ -173,13 +404,21 @@ pub trait DynAggregateReductionResult {
     fn target_problem_any(&self) -> &dyn Any;
     /// Extract an aggregate value from target space to source space.
     fn extract_value_dyn(&self, target_value: serde_json::Value) -> serde_json::Value;
+    /// Map the value of a target solution without erasing the source value's type.
+    /// The caller must establish that the solution realizes the target aggregate
+    /// before interpreting the result as the source aggregate.
+    fn extract_value_from_solution_dyn(
+        &self,
+        target_solution: &dyn Any,
+    ) -> ExtractionResult<Box<dyn Any>>;
 }
 
 impl<R: AggregateReductionResult + 'static> DynAggregateReductionResult for R
 where
     R::Target: 'static,
+    <R::Target as Problem>::Solution: 'static,
     <R::Target as Problem>::Value: Serialize + DeserializeOwned,
-    <R::Source as Problem>::Value: Serialize,
+    <R::Source as Problem>::Value: Serialize + 'static,
 {
     fn target_problem_any(&self) -> &dyn Any {
         self.target_problem() as &dyn Any
@@ -192,6 +431,22 @@ where
         serde_json::to_value(source_value)
             .expect("DynAggregateReductionResult source value serialize failed")
     }
+
+    fn extract_value_from_solution_dyn(
+        &self,
+        target_solution: &dyn Any,
+    ) -> ExtractionResult<Box<dyn Any>> {
+        let target_solution = target_solution
+            .downcast_ref::<<R::Target as Problem>::Solution>()
+            .ok_or_else(|| {
+                ExtractionError::invalid(format!(
+                    "target solution type mismatch: expected {}",
+                    std::any::type_name::<<R::Target as Problem>::Solution>()
+                ))
+            })?;
+        let target_value = self.target_problem().evaluate(target_solution)?;
+        Ok(Box::new(self.extract_value(target_value)))
+    }
 }
 
 #[cfg(test)]
diff --git a/src/rules/travelingsalesman_ilp.rs b/src/rules/travelingsalesman_ilp.rs
index e84d9d1f9..ee89c2ec7 100644
--- a/src/rules/travelingsalesman_ilp.rs
+++ b/src/rules/travelingsalesman_ilp.rs
@@ -8,6 +8,7 @@
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::TravelingSalesman;
 use crate::reduction;
+use crate::rules::ilp_helpers::{mccormick_product, one_hot_decode};
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
 
@@ -21,15 +22,8 @@ pub struct ReductionTSPToILP {
     source_edges: Vec<(usize, usize)>,
 }
 
-impl ReductionTSPToILP {
-    /// Variable index for x_{v,k}: vertex v at position k.
-    fn x_index(&self, v: usize, k: usize) -> usize {
-        v * self.num_vertices + k
-    }
-}
-
 impl ReductionResult for ReductionTSPToILP {
-    type Source = TravelingSalesman<SimpleGraph, i32>;
+    type Source = TravelingSalesman<SimpleGraph, i64>;
     type Target = ILP<bool>;
 
     fn target_problem(&self) -> &ILP<bool> {
@@ -38,56 +32,60 @@ impl ReductionResult for ReductionTSPToILP {
 
     /// Extract solution: read tour permutation from x variables,
     /// then map to edge selection for the source problem.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_vertices;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
 
-        // Read tour: for each position k, find vertex v with x_{v,k} = 1
-        let mut tour = vec![0usize; n];
-        for k in 0..n {
-            for v in 0..n {
-                if target_solution[self.x_index(v, k)] == 1 {
-                    tour[k] = v;
-                    break;
-                }
-            }
-        }
+        Ok({
+            let n = self.num_vertices;
 
-        // Map tour to edge selection
-        let mut edge_selection = vec![0usize; self.source_edges.len()];
-        for k in 0..n {
-            let u = tour[k];
-            let v = tour[(k + 1) % n];
-            // Find the edge index for (u, v) or (v, u)
-            for (idx, &(a, b)) in self.source_edges.iter().enumerate() {
-                if (a == u && b == v) || (a == v && b == u) {
-                    edge_selection[idx] = 1;
-                    break;
-                }
+            let tour = one_hot_decode(target_solution, n, n, 0)?;
+
+            // Map tour to edge selection
+            let mut edge_selection = vec![false; self.source_edges.len()];
+            for k in 0..n {
+                let u = tour[k];
+                let v = tour[(k + 1) % n];
+                let edge = self
+                    .source_edges
+                    .iter()
+                    .position(|&(a, b)| (a == u && b == v) || (a == v && b == u))
+                    .ok_or_else(|| {
+                        crate::rules::ExtractionError::invalid(format!(
+                            "target tour uses absent source edge ({u}, {v})"
+                        ))
+                    })?;
+                edge_selection[edge] = true;
             }
-        }
 
-        edge_selection
+            edge_selection
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices^2 + 2 * num_vertices * num_edges",
         num_constraints = "num_vertices^3 + -1 * num_vertices^2 + 2 * num_vertices + 4 * num_vertices * num_edges",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<bool>> for TravelingSalesman<SimpleGraph, i32> {
+impl ReduceTo<ILP<bool>> for TravelingSalesman<SimpleGraph, i64> {
     type Result = ReductionTSPToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.graph().num_vertices();
         let graph = self.graph();
         let edges_with_weights = self.edges();
         let source_edges: Vec<(usize, usize)> =
             edges_with_weights.iter().map(|&(u, v, _)| (u, v)).collect();
-        let edge_weights: Vec<f64> = edges_with_weights
+        let edge_weights: Vec<i64> = edges_with_weights
             .iter()
-            .map(|&(_, _, w)| w as f64)
+            .map(|&(_, _, weight)| weight)
             .collect();
         let m = source_edges.len();
 
@@ -109,14 +107,14 @@ impl ReduceTo<ILP<bool>> for TravelingSalesman<SimpleGraph, i32> {
 
         // Constraint 1: Each vertex has exactly one position
         for v in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|k| (x_idx(v, k), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|k| (x_idx(v, k), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Constraint 2: Each position has exactly one vertex
         for k in 0..n {
-            let terms: Vec<(usize, f64)> = (0..n).map(|v| (x_idx(v, k), 1.0)).collect();
-            constraints.push(LinearConstraint::eq(terms, 1.0));
+            let terms: Vec<(usize, i64)> = (0..n).map(|v| (x_idx(v, k), 1)).collect();
+            constraints.push(LinearConstraint::eq(terms, 1));
         }
 
         // Constraint 3: Non-edge consecutive prohibition
@@ -132,8 +130,8 @@ impl ReduceTo<ILP<bool>> for TravelingSalesman<SimpleGraph, i32> {
                 }
                 for k in 0..n {
                     constraints.push(LinearConstraint::le(
-                        vec![(x_idx(v, k), 1.0), (x_idx(w, (k + 1) % n), 1.0)],
-                        1.0,
+                        vec![(x_idx(v, k), 1), (x_idx(w, (k + 1) % n), 1)],
+                        1,
                     ));
                 }
             }
@@ -151,34 +149,18 @@ impl ReduceTo<ILP<bool>> for TravelingSalesman<SimpleGraph, i32> {
                 let y_fwd = y_idx(e, k, 0);
                 let xu = x_idx(u, k);
                 let xv_next = x_idx(v, k_next);
-                constraints.push(LinearConstraint::le(vec![(y_fwd, 1.0), (xu, -1.0)], 0.0));
-                constraints.push(LinearConstraint::le(
-                    vec![(y_fwd, 1.0), (xv_next, -1.0)],
-                    0.0,
-                ));
-                constraints.push(LinearConstraint::ge(
-                    vec![(y_fwd, 1.0), (xu, -1.0), (xv_next, -1.0)],
-                    -1.0,
-                ));
+                constraints.extend(mccormick_product(y_fwd, xu, xv_next));
 
                 // Reverse: y_{e,k,1} = x_{v,k} * x_{u,k_next}
                 let y_rev = y_idx(e, k, 1);
                 let xv = x_idx(v, k);
                 let xu_next = x_idx(u, k_next);
-                constraints.push(LinearConstraint::le(vec![(y_rev, 1.0), (xv, -1.0)], 0.0));
-                constraints.push(LinearConstraint::le(
-                    vec![(y_rev, 1.0), (xu_next, -1.0)],
-                    0.0,
-                ));
-                constraints.push(LinearConstraint::ge(
-                    vec![(y_rev, 1.0), (xv, -1.0), (xu_next, -1.0)],
-                    -1.0,
-                ));
+                constraints.extend(mccormick_product(y_rev, xv, xu_next));
             }
         }
 
         // Objective: minimize Σ_{e=(u,v)} w_e * Σ_k (y_{e,k,0} + y_{e,k,1})
-        let mut objective: Vec<(usize, f64)> = Vec::new();
+        let mut objective: Vec<(usize, i64)> = Vec::new();
         for (e, &w) in edge_weights.iter().enumerate() {
             for k in 0..n {
                 objective.push((y_idx(e, k, 0), w));
@@ -186,13 +168,14 @@ impl ReduceTo<ILP<bool>> for TravelingSalesman<SimpleGraph, i32> {
             }
         }
 
-        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize);
+        let target = ILP::new(num_vars, constraints, objective, ObjectiveSense::Minimize)
+            .map_err(<Self as ReduceTo<ILP<bool>>>::target_construction)?;
 
-        ReductionTSPToILP {
+        Ok(ReductionTSPToILP {
             target,
             num_vertices: n,
             source_edges,
-        }
+        })
     }
 }
 
diff --git a/src/rules/travelingsalesman_qubo.rs b/src/rules/travelingsalesman_qubo.rs
index 89b0312ac..42cbda1a9 100644
--- a/src/rules/travelingsalesman_qubo.rs
+++ b/src/rules/travelingsalesman_qubo.rs
@@ -16,15 +16,15 @@ use std::collections::HashMap;
 /// Result of reducing TravelingSalesman to QUBO.
 #[derive(Debug, Clone)]
 pub struct ReductionTravelingSalesmanToQUBO {
-    target: QUBO<f64>,
+    target: QUBO<i64>,
     num_vertices: usize,
     num_edges: usize,
     edge_index: HashMap<(usize, usize), usize>,
 }
 
 impl ReductionResult for ReductionTravelingSalesmanToQUBO {
-    type Source = TravelingSalesman<SimpleGraph, i32>;
-    type Target = QUBO<f64>;
+    type Source = TravelingSalesman<SimpleGraph, i64>;
+    type Target = QUBO<i64>;
 
     fn target_problem(&self) -> &Self::Target {
         &self.target
@@ -34,55 +34,77 @@ impl ReductionResult for ReductionTravelingSalesmanToQUBO {
     ///
     /// The QUBO solution uses n^2 binary variables x_{v,p} (vertex v at position p).
     /// We extract the tour order, then map consecutive pairs to edge indices.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let n = self.num_vertices;
-
-        // For each position p, find the vertex v where x_{v,p} == 1
-        let mut tour = vec![0usize; n];
-        for p in 0..n {
-            for v in 0..n {
-                if target_solution[v * n + p] == 1 {
-                    tour[p] = v;
-                    break;
-                }
-            }
-        }
-
-        // Build edge-based config: for each consecutive pair in the tour, mark the edge
-        let mut config = vec![0usize; self.num_edges];
-        for p in 0..n {
-            let u = tour[p];
-            let v = tour[(p + 1) % n];
-            let key = (u.min(v), u.max(v));
-            if let Some(&idx) = self.edge_index.get(&key) {
-                config[idx] = 1;
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let n = self.num_vertices;
+
+            let tour: Vec<usize> = (0..n)
+                .map(|position| {
+                    let mut selected =
+                        (0..n).filter(|&vertex| target_solution[vertex * n + position]);
+                    match (selected.next(), selected.next()) {
+                        (Some(vertex), None) => Ok(vertex),
+                        _ => Err(crate::rules::ExtractionError::invalid(format!(
+                            "tour position {position} does not select exactly one vertex"
+                        ))),
+                    }
+                })
+                .collect::<crate::rules::ExtractionResult<_>>()?;
+
+            // Build edge-based config: for each consecutive pair in the tour, mark the edge
+            let mut config = vec![false; self.num_edges];
+            for p in 0..n {
+                let u = tour[p];
+                let v = tour[(p + 1) % n];
+                let key = (u.min(v), u.max(v));
+                let &edge = self.edge_index.get(&key).ok_or_else(|| {
+                    crate::rules::ExtractionError::invalid(format!(
+                        "target tour uses absent source edge ({u}, {v})"
+                    ))
+                })?;
+                config[edge] = true;
             }
-        }
 
-        config
+            config
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "num_vertices^2",
     }
 )]
-impl ReduceTo<QUBO<f64>> for TravelingSalesman<SimpleGraph, i32> {
+impl ReduceTo<QUBO<i64>> for TravelingSalesman<SimpleGraph, i64> {
     type Result = ReductionTravelingSalesmanToQUBO;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let n = self.num_vertices();
         let edges = self.edges();
 
         // Build edge weight map (both directions for undirected lookup)
-        let mut edge_weight_map: HashMap<(usize, usize), f64> = HashMap::new();
-        let mut weight_sum: f64 = 0.0;
+        let overflow = |operation| {
+            crate::rules::ReductionError::integer_overflow::<
+                TravelingSalesman<SimpleGraph, i64>,
+                QUBO<i64>,
+            >(operation)
+        };
+        let mut edge_weight_map: HashMap<(usize, usize), i64> = HashMap::new();
+        let mut weight_sum = 0i64;
         for &(u, v, w) in &edges {
-            let wf = w as f64;
-            edge_weight_map.insert((u, v), wf);
-            edge_weight_map.insert((v, u), wf);
-            weight_sum += wf.abs();
+            edge_weight_map.insert((u, v), w);
+            edge_weight_map.insert((v, u), w);
+            let magnitude = w
+                .checked_abs()
+                .ok_or_else(|| overflow("taking the absolute value of a tour weight"))?;
+            weight_sum = weight_sum
+                .checked_add(magnitude)
+                .ok_or_else(|| overflow("summing absolute tour weights"))?;
         }
 
         // Build edge index map: canonical (min, max) → edge index
@@ -94,16 +116,23 @@ impl ReduceTo<QUBO<f64>> for TravelingSalesman<SimpleGraph, i32> {
         }
 
         // Penalty weight: must exceed any possible tour cost
-        let a = 1.0 + weight_sum;
+        let a = weight_sum
+            .checked_add(1)
+            .ok_or_else(|| overflow("computing the tour penalty"))?;
 
         // Build n^2 x n^2 upper-triangular QUBO matrix
-        let dim = n * n;
-        let mut matrix = vec![vec![0.0f64; dim]; dim];
+        let dim = n
+            .checked_mul(n)
+            .ok_or_else(|| overflow("computing the number of QUBO variables"))?;
+        let mut matrix = vec![vec![0i64; dim]; dim];
 
         // Helper: add value to upper-triangular position
-        let mut add_upper = |i: usize, j: usize, val: f64| {
+        let mut add_upper = |i: usize, j: usize, val: i64| {
             let (lo, hi) = if i <= j { (i, j) } else { (j, i) };
-            matrix[lo][hi] += val;
+            matrix[lo][hi] = matrix[lo][hi]
+                .checked_add(val)
+                .ok_or_else(|| overflow("adding a tour QUBO coefficient"))?;
+            Ok::<(), crate::rules::ReductionError>(())
         };
 
         // H_A: each vertex visited exactly once (row constraint)
@@ -113,12 +142,22 @@ impl ReduceTo<QUBO<f64>> for TravelingSalesman<SimpleGraph, i32> {
         for v in 0..n {
             for p in 0..n {
                 // Diagonal: -A (from expanding (sum - 1)^2, the -2*x + x^2 = -x for binary)
-                add_upper(v * n + p, v * n + p, -a);
+                add_upper(
+                    v * n + p,
+                    v * n + p,
+                    a.checked_neg()
+                        .ok_or_else(|| overflow("negating the tour penalty"))?,
+                )?;
             }
             for p1 in 0..n {
                 for p2 in (p1 + 1)..n {
                     // Cross terms: 2*A * x_{v,p1} * x_{v,p2}
-                    add_upper(v * n + p1, v * n + p2, 2.0 * a);
+                    add_upper(
+                        v * n + p1,
+                        v * n + p2,
+                        a.checked_mul(2)
+                            .ok_or_else(|| overflow("doubling the tour penalty"))?,
+                    )?;
                 }
             }
         }
@@ -127,11 +166,21 @@ impl ReduceTo<QUBO<f64>> for TravelingSalesman<SimpleGraph, i32> {
         // For each position p: (sum_v x_{v,p} - 1)^2
         for p in 0..n {
             for v in 0..n {
-                add_upper(v * n + p, v * n + p, -a);
+                add_upper(
+                    v * n + p,
+                    v * n + p,
+                    a.checked_neg()
+                        .ok_or_else(|| overflow("negating the tour penalty"))?,
+                )?;
             }
             for v1 in 0..n {
                 for v2 in (v1 + 1)..n {
-                    add_upper(v1 * n + p, v2 * n + p, 2.0 * a);
+                    add_upper(
+                        v1 * n + p,
+                        v2 * n + p,
+                        a.checked_mul(2)
+                            .ok_or_else(|| overflow("doubling the tour penalty"))?,
+                    )?;
                 }
             }
         }
@@ -144,21 +193,26 @@ impl ReduceTo<QUBO<f64>> for TravelingSalesman<SimpleGraph, i32> {
                 for p in 0..n {
                     let p_next = (p + 1) % n;
                     // x_{u,p} * x_{v,p_next}
-                    add_upper(u * n + p, v * n + p_next, cost);
+                    add_upper(u * n + p, v * n + p_next, cost)?;
                     // x_{v,p} * x_{u,p_next}
-                    add_upper(v * n + p, u * n + p_next, cost);
+                    add_upper(v * n + p, u * n + p_next, cost)?;
                 }
             }
         }
 
-        let target = QUBO::from_matrix(matrix);
+        let target = QUBO::from_matrix(matrix).map_err(|message| {
+            crate::rules::ReductionError::construction::<
+                TravelingSalesman<SimpleGraph, i64>,
+                QUBO<i64>,
+            >(message)
+        })?;
 
-        ReductionTravelingSalesmanToQUBO {
+        Ok(ReductionTravelingSalesmanToQUBO {
             target,
             num_vertices: n,
             num_edges,
             edge_index,
-        }
+        })
     }
 }
 
@@ -174,11 +228,13 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]),
                 vec![1, 2, 3],
             );
-            crate::example_db::specs::rule_example_with_witness::<_, QUBO<f64>>(
+            crate::example_db::specs::rule_example_with_witness::<_, QUBO<i64>>(
                 source,
                 SolutionPair {
-                    source_config: vec![1, 1, 1],
-                    target_config: vec![0, 0, 1, 1, 0, 0, 0, 1, 0],
+                    source_config: serde_json::json!(vec![true, true, true]),
+                    target_config: serde_json::json!(vec![
+                        false, false, true, true, false, false, false, true, false
+                    ]),
                 },
             )
         },
diff --git a/src/rules/undirectedflowlowerbounds_ilp.rs b/src/rules/undirectedflowlowerbounds_ilp.rs
index 7c666abca..88db49edf 100644
--- a/src/rules/undirectedflowlowerbounds_ilp.rs
+++ b/src/rules/undirectedflowlowerbounds_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from UndirectedFlowLowerBounds to ILP<i32>.
+//! Reduction from UndirectedFlowLowerBounds to `ILP<i64>`.
 //!
 //! For each undirected edge e = {u,v} (indexed by e), we introduce:
 //!   f_{uv} = 2*e      (flow in u→v direction, ≥ 0)
@@ -21,7 +21,7 @@
 //! Flow conservation at non-terminal vertices.
 //! Net flow into sink ≥ requirement.
 //!
-//! Overhead: 3*|E| variables, 4*|E| + |V| + 1 constraints (conservative for non-terminals).
+//! Size upper bound: 3*|E| variables, 4*|E| + |V| + 1 constraints (conservative for non-terminals).
 
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::models::graph::UndirectedFlowLowerBounds;
@@ -29,7 +29,7 @@ use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::Graph;
 
-/// Result of reducing UndirectedFlowLowerBounds to ILP<i32>.
+/// Result of reducing UndirectedFlowLowerBounds to `ILP<i64>`.
 ///
 /// Variable layout:
 /// - `f_{uv}` at 2*e (flow u→v on edge e)
@@ -37,15 +37,15 @@ use crate::topology::Graph;
 /// - `z_e` at 2*|E| + e (orientation indicator: 1 = u→v direction)
 #[derive(Debug, Clone)]
 pub struct ReductionUFLBToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_edges: usize,
 }
 
 impl ReductionResult for ReductionUFLBToILP {
     type Source = UndirectedFlowLowerBounds;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
@@ -54,30 +54,39 @@ impl ReductionResult for ReductionUFLBToILP {
     /// The model encodes orientation as config[e] = 0 for u→v, 1 for v→u.
     /// The ILP uses z_e = 1 for u→v, z_e = 0 for v→u.
     /// So we return 1 - z_e to match the model's convention.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let e = self.num_edges;
-        target_solution[2 * e..3 * e]
-            .iter()
-            .map(|&z| 1 - z)
-            .collect()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        Ok({
+            let e = self.num_edges;
+            target_solution[2 * e..3 * e]
+                .iter()
+                .map(|&z| z == 0)
+                .collect()
+        })
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "3 * num_edges",
         num_constraints = "4 * num_edges + num_vertices + 1",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for UndirectedFlowLowerBounds {
+impl ReduceTo<ILP<i64>> for UndirectedFlowLowerBounds {
     type Result = ReductionUFLBToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let edges = self.graph().edges();
         let e = edges.len();
         let n = self.num_vertices();
         let num_vars = 3 * e;
-
         let f_uv = |edge: usize| 2 * edge;
         let f_vu = |edge: usize| 2 * edge + 1;
         let z = |edge: usize| 2 * e + edge;
@@ -85,34 +94,34 @@ impl ReduceTo<ILP<i32>> for UndirectedFlowLowerBounds {
         let mut constraints = Vec::new();
 
         for (edge_idx, _) in edges.iter().enumerate() {
-            let cap = self.capacities()[edge_idx] as f64;
-            let lower = self.lower_bounds()[edge_idx] as f64;
+            let cap = self.capacities()[edge_idx];
+            let lower = self.lower_bounds()[edge_idx];
 
             // z_e ≤ 1 (binary)
-            constraints.push(LinearConstraint::le(vec![(z(edge_idx), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(z(edge_idx), 1)], 1));
 
             // f_{uv} ≤ cap * z_e  =>  f_{uv} - cap*z_e ≤ 0
             constraints.push(LinearConstraint::le(
-                vec![(f_uv(edge_idx), 1.0), (z(edge_idx), -cap)],
-                0.0,
+                vec![(f_uv(edge_idx), 1), (z(edge_idx), -cap)],
+                0,
             ));
 
             // f_{vu} ≤ cap * (1 - z_e)  =>  f_{vu} + cap*z_e ≤ cap
             constraints.push(LinearConstraint::le(
-                vec![(f_vu(edge_idx), 1.0), (z(edge_idx), cap)],
+                vec![(f_vu(edge_idx), 1), (z(edge_idx), cap)],
                 cap,
             ));
 
-            if lower > 0.0 {
+            if lower > 0 {
                 // f_{uv} ≥ lower * z_e  =>  f_{uv} - lower*z_e ≥ 0
                 constraints.push(LinearConstraint::ge(
-                    vec![(f_uv(edge_idx), 1.0), (z(edge_idx), -lower)],
-                    0.0,
+                    vec![(f_uv(edge_idx), 1), (z(edge_idx), -lower)],
+                    0,
                 ));
 
                 // f_{vu} ≥ lower * (1 - z_e)  =>  f_{vu} + lower*z_e ≥ lower
                 constraints.push(LinearConstraint::ge(
-                    vec![(f_vu(edge_idx), 1.0), (z(edge_idx), lower)],
+                    vec![(f_vu(edge_idx), 1), (z(edge_idx), lower)],
                     lower,
                 ));
             }
@@ -124,44 +133,45 @@ impl ReduceTo<ILP<i32>> for UndirectedFlowLowerBounds {
                 continue;
             }
 
-            let mut terms: Vec<(usize, f64)> = Vec::new();
+            let mut terms: Vec<(usize, i64)> = Vec::new();
             for (edge_idx, &(u, v)) in edges.iter().enumerate() {
                 if vertex == u {
                     // f_{uv} leaves vertex u, f_{vu} enters
-                    terms.push((f_uv(edge_idx), -1.0));
-                    terms.push((f_vu(edge_idx), 1.0));
+                    terms.push((f_uv(edge_idx), -1));
+                    terms.push((f_vu(edge_idx), 1));
                 } else if vertex == v {
                     // f_{uv} enters vertex v, f_{vu} leaves
-                    terms.push((f_uv(edge_idx), 1.0));
-                    terms.push((f_vu(edge_idx), -1.0));
+                    terms.push((f_uv(edge_idx), 1));
+                    terms.push((f_vu(edge_idx), -1));
                 }
             }
 
             if !terms.is_empty() {
-                constraints.push(LinearConstraint::eq(terms, 0.0));
+                constraints.push(LinearConstraint::eq(terms, 0));
             }
         }
 
         // Net flow into sink ≥ requirement
         let sink = self.sink();
-        let mut sink_terms: Vec<(usize, f64)> = Vec::new();
+        let mut sink_terms: Vec<(usize, i64)> = Vec::new();
         for (edge_idx, &(u, v)) in edges.iter().enumerate() {
             if v == sink {
                 // f_{uv} flows into sink, f_{vu} flows out
-                sink_terms.push((f_uv(edge_idx), 1.0));
-                sink_terms.push((f_vu(edge_idx), -1.0));
+                sink_terms.push((f_uv(edge_idx), 1));
+                sink_terms.push((f_vu(edge_idx), -1));
             } else if u == sink {
                 // f_{vu} flows into sink (from v side), f_{uv} flows out
-                sink_terms.push((f_uv(edge_idx), -1.0));
-                sink_terms.push((f_vu(edge_idx), 1.0));
+                sink_terms.push((f_uv(edge_idx), -1));
+                sink_terms.push((f_vu(edge_idx), 1));
             }
         }
-        constraints.push(LinearConstraint::ge(sink_terms, self.requirement() as f64));
+        constraints.push(LinearConstraint::ge(sink_terms, self.requirement()));
 
-        ReductionUFLBToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionUFLBToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_edges: e,
-        }
+        })
     }
 }
 
@@ -182,7 +192,7 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 2,
                 1,
             );
-            crate::example_db::specs::rule_example_via_ilp::<_, i32>(source)
+            crate::example_db::specs::rule_example_via_ilp::<_, i64>(source)
         },
     }]
 }
diff --git a/src/rules/undirectedtwocommodityintegralflow_ilp.rs b/src/rules/undirectedtwocommodityintegralflow_ilp.rs
index c5db4afa7..821af6079 100644
--- a/src/rules/undirectedtwocommodityintegralflow_ilp.rs
+++ b/src/rules/undirectedtwocommodityintegralflow_ilp.rs
@@ -1,4 +1,4 @@
-//! Reduction from UndirectedTwoCommodityIntegralFlow to ILP<i32>.
+//! Reduction from UndirectedTwoCommodityIntegralFlow to `ILP<i64>`.
 //!
 //! For each undirected edge {u,v} (indexed by e), we introduce 4 flow variables:
 //!   f1_{uv} = 4*e + 0  (commodity 1 flow u→v)
@@ -13,7 +13,7 @@
 //! For each edge e with capacity c_e, the joint capacity constraint is:
 //!   max(f1_{uv}, f1_{vu}) + max(f2_{uv}, f2_{vu}) ≤ c_e
 //!
-//! Since this is ILP<i32>, we use direction indicators d1_e, d2_e ∈ {0,1} to linearize:
+//! Since this is `ILP<i64>`, we use direction indicators d1_e, d2_e ∈ {0,1} to linearize:
 //!   f1_{uv} ≤ c_e * d1_e;  f1_{vu} ≤ c_e * (1 - d1_e)
 //!   f2_{uv} ≤ c_e * d2_e;  f2_{vu} ≤ c_e * (1 - d2_e)
 //!   f1_{uv} + f1_{vu} + f2_{uv} + f2_{vu} ≤ c_e  (joint capacity)
@@ -30,7 +30,7 @@ use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::Graph;
 
-/// Result of reducing UndirectedTwoCommodityIntegralFlow to ILP<i32>.
+/// Result of reducing UndirectedTwoCommodityIntegralFlow to `ILP<i64>`.
 ///
 /// Variable layout:
 /// - `f1_{uv}` at 4*e + 0, `f1_{vu}` at 4*e + 1 (commodity 1 flows on edge e)
@@ -38,40 +38,47 @@ use crate::topology::Graph;
 /// - `d1_e` at 4*|E| + 2*e, `d2_e` at 4*|E| + 2*e + 1 (direction indicators)
 #[derive(Debug, Clone)]
 pub struct ReductionU2CIFToILP {
-    target: ILP<i32>,
+    target: ILP<i64>,
     num_edges: usize,
 }
 
 impl ReductionResult for ReductionU2CIFToILP {
     type Source = UndirectedTwoCommodityIntegralFlow;
-    type Target = ILP<i32>;
+    type Target = ILP<i64>;
 
-    fn target_problem(&self) -> &ILP<i32> {
+    fn target_problem(&self) -> &ILP<i64> {
         &self.target
     }
 
     /// Extract flow solution: first 4*|E| variables are the flow values.
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution[..4 * self.num_edges].to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        crate::rules::traits::validate_target_solution(self.target_problem(), target_solution)?;
+
+        crate::rules::ilp_helpers::decode_usize_values(&target_solution[..4 * self.num_edges])
     }
 }
 
 #[reduction(
-    overhead = {
+    transform = exact {
         num_vars = "6 * num_edges",
-        num_constraints = "7 * num_edges + 2 * num_nonterminal_vertices + 2",
+        num_constraints = "7 * num_edges + num_conservation_constraints + 2",
+    },
+    unavailable = {
+        num_nonzeros = "the exact target parameter is not represented by this reduction's symbolic transform",
     }
 )]
-impl ReduceTo<ILP<i32>> for UndirectedTwoCommodityIntegralFlow {
+impl ReduceTo<ILP<i64>> for UndirectedTwoCommodityIntegralFlow {
     type Result = ReductionU2CIFToILP;
 
-    fn reduce_to(&self) -> Self::Result {
+    fn reduce_to(&self) -> Result<Self::Result, crate::rules::ReductionError> {
         let edges = self.graph().edges();
         let e = edges.len();
         let n = self.num_vertices();
         // 4*e flow variables + 2*e direction indicators = 6*e total
         let num_vars = 6 * e;
-
         // Variable index helpers
         let f1_uv = |edge: usize| 4 * edge;
         let f1_vu = |edge: usize| 4 * edge + 1;
@@ -80,131 +87,113 @@ impl ReduceTo<ILP<i32>> for UndirectedTwoCommodityIntegralFlow {
         let d1 = |edge: usize| 4 * e + 2 * edge;
         let d2 = |edge: usize| 4 * e + 2 * edge + 1;
 
-        let mut constraints = Vec::with_capacity(7 * e + 2 * self.num_nonterminal_vertices() + 2);
+        let mut constraints = Vec::with_capacity(7 * e + self.num_conservation_constraints() + 2);
 
         for (edge_idx, (_u, _v)) in edges.iter().enumerate() {
-            let cap = self.capacities()[edge_idx] as f64;
+            let cap = self.capacities()[edge_idx];
 
             // Direction indicators are binary: d1_e ≤ 1, d2_e ≤ 1
-            constraints.push(LinearConstraint::le(vec![(d1(edge_idx), 1.0)], 1.0));
-            constraints.push(LinearConstraint::le(vec![(d2(edge_idx), 1.0)], 1.0));
+            constraints.push(LinearConstraint::le(vec![(d1(edge_idx), 1)], 1));
+            constraints.push(LinearConstraint::le(vec![(d2(edge_idx), 1)], 1));
 
             // Commodity 1 anti-parallel: f1_{uv} ≤ cap * d1_e
             // => f1_{uv} - cap * d1_e ≤ 0
             constraints.push(LinearConstraint::le(
-                vec![(f1_uv(edge_idx), 1.0), (d1(edge_idx), -cap)],
-                0.0,
+                vec![(f1_uv(edge_idx), 1), (d1(edge_idx), -cap)],
+                0,
             ));
             // f1_{vu} ≤ cap * (1 - d1_e) => f1_{vu} + cap*d1_e ≤ cap
             constraints.push(LinearConstraint::le(
-                vec![(f1_vu(edge_idx), 1.0), (d1(edge_idx), cap)],
+                vec![(f1_vu(edge_idx), 1), (d1(edge_idx), cap)],
                 cap,
             ));
 
             // Commodity 2 anti-parallel: f2_{uv} ≤ cap * d2_e
             constraints.push(LinearConstraint::le(
-                vec![(f2_uv(edge_idx), 1.0), (d2(edge_idx), -cap)],
-                0.0,
+                vec![(f2_uv(edge_idx), 1), (d2(edge_idx), -cap)],
+                0,
             ));
             // f2_{vu} ≤ cap * (1 - d2_e)
             constraints.push(LinearConstraint::le(
-                vec![(f2_vu(edge_idx), 1.0), (d2(edge_idx), cap)],
+                vec![(f2_vu(edge_idx), 1), (d2(edge_idx), cap)],
                 cap,
             ));
 
             // Joint capacity: f1_{uv} + f1_{vu} + f2_{uv} + f2_{vu} ≤ cap
             constraints.push(LinearConstraint::le(
                 vec![
-                    (f1_uv(edge_idx), 1.0),
-                    (f1_vu(edge_idx), 1.0),
-                    (f2_uv(edge_idx), 1.0),
-                    (f2_vu(edge_idx), 1.0),
+                    (f1_uv(edge_idx), 1),
+                    (f1_vu(edge_idx), 1),
+                    (f2_uv(edge_idx), 1),
+                    (f2_vu(edge_idx), 1),
                 ],
                 cap,
             ));
         }
 
-        // Flow conservation for each commodity at non-terminal vertices
-        let terminals = [
-            self.source_1(),
-            self.sink_1(),
-            self.source_2(),
-            self.sink_2(),
-        ];
-
-        for vertex in 0..n {
-            if terminals.contains(&vertex) {
-                continue;
-            }
-
-            // Commodity 1 conservation: Σ_in f1 - Σ_out f1 = 0
-            let mut terms_c1: Vec<(usize, f64)> = Vec::new();
-            // Commodity 2 conservation: Σ_in f2 - Σ_out f2 = 0
-            let mut terms_c2: Vec<(usize, f64)> = Vec::new();
-
-            for (edge_idx, &(u, v)) in edges.iter().enumerate() {
-                if vertex == u {
-                    // outgoing from u: f1_{uv} goes out, f1_{vu} comes in
-                    terms_c1.push((f1_uv(edge_idx), -1.0));
-                    terms_c1.push((f1_vu(edge_idx), 1.0));
-                    terms_c2.push((f2_uv(edge_idx), -1.0));
-                    terms_c2.push((f2_vu(edge_idx), 1.0));
-                } else if vertex == v {
-                    // outgoing from v: f1_{vu} goes out, f1_{uv} comes in
-                    terms_c1.push((f1_uv(edge_idx), 1.0));
-                    terms_c1.push((f1_vu(edge_idx), -1.0));
-                    terms_c2.push((f2_uv(edge_idx), 1.0));
-                    terms_c2.push((f2_vu(edge_idx), -1.0));
+        // Each commodity is conserved at every vertex except its own source and sink.
+        for (commodity, source, sink) in [
+            (1, self.source_1(), self.sink_1()),
+            (2, self.source_2(), self.sink_2()),
+        ] {
+            for vertex in 0..n {
+                if vertex == source || vertex == sink {
+                    continue;
                 }
-            }
 
-            if !terms_c1.is_empty() {
-                constraints.push(LinearConstraint::eq(terms_c1, 0.0));
-            }
-            if !terms_c2.is_empty() {
-                constraints.push(LinearConstraint::eq(terms_c2, 0.0));
+                let mut terms = Vec::new();
+                for (edge_idx, &(u, v)) in edges.iter().enumerate() {
+                    let (uv, vu) = if commodity == 1 {
+                        (f1_uv(edge_idx), f1_vu(edge_idx))
+                    } else {
+                        (f2_uv(edge_idx), f2_vu(edge_idx))
+                    };
+                    if vertex == u {
+                        terms.push((uv, -1));
+                        terms.push((vu, 1));
+                    } else if vertex == v {
+                        terms.push((uv, 1));
+                        terms.push((vu, -1));
+                    }
+                }
+                constraints.push(LinearConstraint::eq(terms, 0));
             }
         }
 
         // Net flow into sinks ≥ requirements
         // Commodity 1: net inflow at sink_1 ≥ requirement_1
         let sink_1 = self.sink_1();
-        let mut sink1_terms: Vec<(usize, f64)> = Vec::new();
+        let mut sink1_terms: Vec<(usize, i64)> = Vec::new();
         for (edge_idx, &(u, v)) in edges.iter().enumerate() {
             if sink_1 == v {
-                sink1_terms.push((f1_uv(edge_idx), 1.0));
-                sink1_terms.push((f1_vu(edge_idx), -1.0));
+                sink1_terms.push((f1_uv(edge_idx), 1));
+                sink1_terms.push((f1_vu(edge_idx), -1));
             } else if sink_1 == u {
-                sink1_terms.push((f1_uv(edge_idx), -1.0));
-                sink1_terms.push((f1_vu(edge_idx), 1.0));
+                sink1_terms.push((f1_uv(edge_idx), -1));
+                sink1_terms.push((f1_vu(edge_idx), 1));
             }
         }
-        constraints.push(LinearConstraint::ge(
-            sink1_terms,
-            self.requirement_1() as f64,
-        ));
+        constraints.push(LinearConstraint::ge(sink1_terms, self.requirement_1()));
 
         // Commodity 2: net inflow at sink_2 ≥ requirement_2
         let sink_2 = self.sink_2();
-        let mut sink2_terms: Vec<(usize, f64)> = Vec::new();
+        let mut sink2_terms: Vec<(usize, i64)> = Vec::new();
         for (edge_idx, &(u, v)) in edges.iter().enumerate() {
             if sink_2 == v {
-                sink2_terms.push((f2_uv(edge_idx), 1.0));
-                sink2_terms.push((f2_vu(edge_idx), -1.0));
+                sink2_terms.push((f2_uv(edge_idx), 1));
+                sink2_terms.push((f2_vu(edge_idx), -1));
             } else if sink_2 == u {
-                sink2_terms.push((f2_uv(edge_idx), -1.0));
-                sink2_terms.push((f2_vu(edge_idx), 1.0));
+                sink2_terms.push((f2_uv(edge_idx), -1));
+                sink2_terms.push((f2_vu(edge_idx), 1));
             }
         }
-        constraints.push(LinearConstraint::ge(
-            sink2_terms,
-            self.requirement_2() as f64,
-        ));
+        constraints.push(LinearConstraint::ge(sink2_terms, self.requirement_2()));
 
-        ReductionU2CIFToILP {
-            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize),
+        Ok(ReductionU2CIFToILP {
+            target: ILP::new(num_vars, constraints, vec![], ObjectiveSense::Minimize)
+                .map_err(Self::target_construction)?,
             num_edges: e,
-        }
+        })
     }
 }
 
@@ -229,17 +218,20 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
                 1,
                 1,
             );
-            let reduction: ReductionU2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+            let reduction: ReductionU2CIFToILP =
+                ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
             let solver = crate::solvers::ILPSolver::new();
             let target_config = solver
                 .solve(reduction.target_problem())
                 .expect("canonical example should be feasible");
-            let source_config = reduction.extract_solution(&target_config);
-            crate::example_db::specs::rule_example_with_witness::<_, ILP<i32>>(
+            let source_config = reduction.extract_solution(&target_config).unwrap();
+            crate::example_db::specs::rule_example_with_witness::<_, ILP<i64>>(
                 source,
                 SolutionPair {
-                    source_config,
-                    target_config,
+                    source_config: serde_json::to_value(source_config)
+                        .expect("solution serialization must succeed"),
+                    target_config: serde_json::to_value(target_config)
+                        .expect("solution serialization must succeed"),
                 },
             )
         },
diff --git a/src/rules/unitdiskmapping/alpha_tensor.rs b/src/rules/unitdiskmapping/alpha_tensor.rs
deleted file mode 100644
index 3f1810c4c..000000000
--- a/src/rules/unitdiskmapping/alpha_tensor.rs
+++ /dev/null
@@ -1,369 +0,0 @@
-//! Alpha tensor computation for gadget verification.
-//!
-//! Alpha tensors are used to verify gadget correctness. For a gadget with k pins,
-//! the alpha tensor is a 2^k array where entry i is the weighted MIS when pins
-//! are fixed according to the bit pattern of i.
-//!
-//! Two gadgets are equivalent if their reduced (compactified) alpha tensors
-//! differ by a constant equal to the negative MIS overhead.
-
-use std::collections::HashSet;
-
-/// Compute alpha tensor for a graph with weighted nodes and open pins.
-///
-/// Returns a 2^k vector where k = pins.len().
-/// Entry i represents weighted MIS when pins are fixed according to bit pattern i:
-/// - Bit j = 1: pin j is IN the independent set
-/// - Bit j = 0: pin j is OUT of the independent set
-///
-/// # Arguments
-/// * `num_vertices` - Total number of vertices
-/// * `edges` - Edge list (0-indexed)
-/// * `weights` - Weight of each vertex
-/// * `pins` - Indices of open vertices (0-indexed)
-#[allow(clippy::needless_range_loop)]
-pub fn compute_alpha_tensor(
-    num_vertices: usize,
-    edges: &[(usize, usize)],
-    weights: &[i32],
-    pins: &[usize],
-) -> Vec<i32> {
-    let k = pins.len();
-    let mut tensor = vec![0; 1 << k];
-
-    for config in 0..(1 << k) {
-        tensor[config] = compute_mis_with_fixed_pins(num_vertices, edges, weights, pins, config);
-    }
-
-    tensor
-}
-
-/// Compute weighted MIS with some pins fixed to be in/out of IS.
-///
-/// For each pin configuration:
-/// - Pins with bit=1: MUST be in IS (forced in)
-/// - Pins with bit=0: MUST be out of IS (forced out)
-/// - If forced-in pins are adjacent, return i32::MIN (invalid/impossible)
-/// - Otherwise solve weighted MIS on remaining free vertices
-fn compute_mis_with_fixed_pins(
-    num_vertices: usize,
-    edges: &[(usize, usize)],
-    weights: &[i32],
-    pins: &[usize],
-    pin_config: usize,
-) -> i32 {
-    // Determine forced-in and forced-out vertices
-    let mut forced_in: HashSet<usize> = HashSet::new();
-    let mut forced_out: HashSet<usize> = HashSet::new();
-
-    for (i, &pin) in pins.iter().enumerate() {
-        if (pin_config >> i) & 1 == 1 {
-            forced_in.insert(pin);
-        } else {
-            forced_out.insert(pin);
-        }
-    }
-
-    // Check if any forced-in vertices are adjacent (invalid configuration)
-    for &(u, v) in edges {
-        if forced_in.contains(&u) && forced_in.contains(&v) {
-            return i32::MIN; // Invalid: adjacent pins both forced in
-        }
-    }
-
-    // Vertices that are blocked by forced-in vertices
-    let mut blocked: HashSet<usize> = HashSet::new();
-    for &(u, v) in edges {
-        if forced_in.contains(&u) {
-            blocked.insert(v);
-        }
-        if forced_in.contains(&v) {
-            blocked.insert(u);
-        }
-    }
-
-    // Free vertices: not forced-in, not forced-out, not blocked
-    let free_vertices: Vec<usize> = (0..num_vertices)
-        .filter(|&v| !forced_in.contains(&v) && !forced_out.contains(&v) && !blocked.contains(&v))
-        .collect();
-
-    // Build subgraph on free vertices
-    let vertex_map: std::collections::HashMap<usize, usize> = free_vertices
-        .iter()
-        .enumerate()
-        .map(|(i, &v)| (v, i))
-        .collect();
-
-    let sub_edges: Vec<(usize, usize)> = edges
-        .iter()
-        .filter_map(|&(u, v)| {
-            if let (Some(&u2), Some(&v2)) = (vertex_map.get(&u), vertex_map.get(&v)) {
-                Some((u2, v2))
-            } else {
-                None
-            }
-        })
-        .collect();
-
-    let sub_weights: Vec<i32> = free_vertices.iter().map(|&v| weights[v]).collect();
-
-    // Solve weighted MIS on subgraph
-    let sub_mis = if free_vertices.is_empty() {
-        0
-    } else {
-        weighted_mis_exhaustive(free_vertices.len(), &sub_edges, &sub_weights)
-    };
-
-    // Total MIS = weight of forced-in vertices + MIS of free vertices
-    let forced_in_weight: i32 = forced_in.iter().map(|&v| weights[v]).sum();
-    forced_in_weight + sub_mis
-}
-
-/// Exhaustive weighted MIS solver for small graphs.
-/// Uses brute force enumeration for correctness (suitable for gadgets with <20 vertices).
-#[allow(clippy::needless_range_loop)]
-fn weighted_mis_exhaustive(num_vertices: usize, edges: &[(usize, usize)], weights: &[i32]) -> i32 {
-    if num_vertices == 0 {
-        return 0;
-    }
-
-    // Build adjacency check
-    let mut adj = vec![vec![false; num_vertices]; num_vertices];
-    for &(u, v) in edges {
-        if u < num_vertices && v < num_vertices {
-            adj[u][v] = true;
-            adj[v][u] = true;
-        }
-    }
-
-    let mut max_weight = 0;
-
-    // Enumerate all subsets
-    for subset in 0..(1usize << num_vertices) {
-        // Check if subset is independent
-        let mut is_independent = true;
-        for u in 0..num_vertices {
-            if (subset >> u) & 1 == 0 {
-                continue;
-            }
-            for v in (u + 1)..num_vertices {
-                if (subset >> v) & 1 == 0 {
-                    continue;
-                }
-                if adj[u][v] {
-                    is_independent = false;
-                    break;
-                }
-            }
-            if !is_independent {
-                break;
-            }
-        }
-
-        if is_independent {
-            let weight: i32 = (0..num_vertices)
-                .filter(|&v| (subset >> v) & 1 == 1)
-                .map(|v| weights[v])
-                .sum();
-            max_weight = max_weight.max(weight);
-        }
-    }
-
-    max_weight
-}
-
-/// Reduce alpha tensor by eliminating dominated entries.
-///
-/// An entry (bs_a, val_a) is dominated by (bs_b, val_b) if:
-/// - bs_a != bs_b
-/// - val_a <= val_b
-/// - (bs_b & bs_a) == bs_b (bs_a has all bits of bs_b plus more, i.e., bs_b is subset of bs_a)
-///
-/// Dominated entries are set to i32::MIN (representing -infinity).
-pub fn mis_compactify(tensor: &mut [i32]) {
-    let n = tensor.len();
-    for a in 0..n {
-        if tensor[a] == i32::MIN {
-            continue;
-        }
-        for b in 0..n {
-            if a != b && tensor[b] != i32::MIN && worse_than(a, b, tensor[a], tensor[b]) {
-                tensor[a] = i32::MIN;
-                break;
-            }
-        }
-    }
-}
-
-/// Check if entry a is dominated by entry b.
-fn worse_than(bs_a: usize, bs_b: usize, val_a: i32, val_b: i32) -> bool {
-    // bs_a is worse than bs_b if:
-    // - bs_b is a subset of bs_a (bs_a has all bits of bs_b plus potentially more)
-    // - val_a <= val_b (including more pins doesn't improve MIS)
-    bs_a != bs_b && val_a <= val_b && (bs_b & bs_a) == bs_b
-}
-
-/// Check if two tensors differ by a constant.
-///
-/// Returns (is_equivalent, difference) where difference = `t1[i] - t2[i]` for valid entries.
-/// Invalid entries (i32::MIN) in both tensors are skipped.
-/// If one is valid and other is invalid, returns false.
-pub fn is_diff_by_const(t1: &[i32], t2: &[i32]) -> (bool, i32) {
-    assert_eq!(t1.len(), t2.len());
-
-    let mut diff: Option<i32> = None;
-
-    for (&a, &b) in t1.iter().zip(t2.iter()) {
-        // Skip if both are -infinity (dominated)
-        if a == i32::MIN && b == i32::MIN {
-            continue;
-        }
-        // Fail if only one is -infinity
-        if a == i32::MIN || b == i32::MIN {
-            return (false, 0);
-        }
-
-        let d = a - b;
-        match diff {
-            None => diff = Some(d),
-            Some(prev) if prev != d => return (false, 0),
-            _ => {}
-        }
-    }
-
-    (true, diff.unwrap_or(0))
-}
-
-/// Build unit disk graph edges for triangular lattice.
-/// Uses distance threshold of 1.1 (matching Julia's triangular_unitdisk_graph).
-///
-/// Triangular coordinates: (row, col) maps to physical position:
-/// - x = row + 0.5 if col is even, else row
-/// - y = col * sqrt(3)/2
-pub fn build_triangular_unit_disk_edges(locs: &[(usize, usize)]) -> Vec<(usize, usize)> {
-    let n = locs.len();
-    let mut edges = Vec::new();
-    let radius = 1.1;
-
-    for i in 0..n {
-        for j in (i + 1)..n {
-            let (r1, c1) = locs[i];
-            let (r2, c2) = locs[j];
-
-            // Convert to physical coordinates
-            let x1 = r1 as f64 + if c1.is_multiple_of(2) { 0.5 } else { 0.0 };
-            let y1 = c1 as f64 * (3.0_f64.sqrt() / 2.0);
-            let x2 = r2 as f64 + if c2.is_multiple_of(2) { 0.5 } else { 0.0 };
-            let y2 = c2 as f64 * (3.0_f64.sqrt() / 2.0);
-
-            // Use squared distance comparison (like Julia): dist^2 < radius^2
-            let dist_sq = (x1 - x2).powi(2) + (y1 - y2).powi(2);
-            if dist_sq < radius * radius {
-                edges.push((i, j));
-            }
-        }
-    }
-
-    edges
-}
-
-/// Build unit disk graph edges using standard Euclidean distance.
-/// Uses radius 1.5 matching Julia's unitdisk_graph for gadget verification.
-///
-/// This treats coordinates as standard grid positions, not triangular lattice.
-pub fn build_standard_unit_disk_edges(locs: &[(usize, usize)]) -> Vec<(usize, usize)> {
-    let n = locs.len();
-    let mut edges = Vec::new();
-    let radius = 1.5;
-
-    for i in 0..n {
-        for j in (i + 1)..n {
-            let (r1, c1) = locs[i];
-            let (r2, c2) = locs[j];
-
-            // Standard Euclidean distance
-            let dr = r1 as f64 - r2 as f64;
-            let dc = c1 as f64 - c2 as f64;
-            let dist = (dr * dr + dc * dc).sqrt();
-
-            if dist <= radius {
-                edges.push((i, j));
-            }
-        }
-    }
-
-    edges
-}
-
-/// Verify a triangular gadget's correctness using alpha tensors.
-///
-/// Returns Ok if the gadget is correct (source and mapped have equivalent alpha tensors),
-/// Err with a message if not.
-///
-/// Uses Julia's approach: subtract 1 from pin weights to account for external coupling.
-pub fn verify_triangular_gadget<G: super::triangular::TriangularGadget>(
-    gadget: &G,
-) -> Result<(), String> {
-    // Get source graph
-    let (src_locs, src_edges, src_pins) = gadget.source_graph();
-    // Use gadget's source weights, then subtract 1 from pins (Julia's approach)
-    let mut src_weights = gadget.source_weights();
-    for &pin in &src_pins {
-        src_weights[pin] -= 1;
-    }
-
-    // Get mapped graph
-    // Use triangular unit disk with radius 1.1 (matching Julia's triangular_unitdisk_graph)
-    let (map_locs, map_pins) = gadget.mapped_graph();
-    let map_edges = build_triangular_unit_disk_edges(&map_locs);
-    // Use gadget's mapped weights, then subtract 1 from pins
-    let mut map_weights = gadget.mapped_weights();
-    for &pin in &map_pins {
-        map_weights[pin] -= 1;
-    }
-
-    // Compute alpha tensors
-    let src_tensor = compute_alpha_tensor(src_locs.len(), &src_edges, &src_weights, &src_pins);
-    let map_tensor = compute_alpha_tensor(map_locs.len(), &map_edges, &map_weights, &map_pins);
-
-    // Julia doesn't use mis_compactify for weighted gadgets - it just checks that
-    // the maximum entries are in the same positions and differ by a constant.
-    // Let's check the simpler condition first.
-    let src_max = *src_tensor
-        .iter()
-        .filter(|&&x| x != i32::MIN)
-        .max()
-        .unwrap_or(&0);
-    let map_max = *map_tensor
-        .iter()
-        .filter(|&&x| x != i32::MIN)
-        .max()
-        .unwrap_or(&0);
-
-    // Check that positions where source == max match positions where mapped == max
-    let src_max_mask: Vec<bool> = src_tensor.iter().map(|&x| x == src_max).collect();
-    let map_max_mask: Vec<bool> = map_tensor.iter().map(|&x| x == map_max).collect();
-
-    if src_max_mask != map_max_mask {
-        return Err(format!(
-            "Maximum entry positions differ.\nSource tensor: {:?}\nMapped tensor: {:?}\nSource max mask: {:?}\nMapped max mask: {:?}",
-            src_tensor, map_tensor, src_max_mask, map_max_mask
-        ));
-    }
-
-    // Check that the difference between max values equals -mis_overhead
-    let diff = src_max - map_max;
-    let expected_diff = -gadget.mis_overhead();
-    if diff != expected_diff {
-        return Err(format!(
-            "Overhead mismatch: src_max={}, map_max={}, diff={}, expected -mis_overhead={}",
-            src_max, map_max, diff, expected_diff
-        ));
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-#[path = "../../unit_tests/rules/unitdiskmapping/alpha_tensor.rs"]
-mod tests;
diff --git a/src/rules/unitdiskmapping/copyline.rs b/src/rules/unitdiskmapping/copyline.rs
index aeda04850..050d1c3fc 100644
--- a/src/rules/unitdiskmapping/copyline.rs
+++ b/src/rules/unitdiskmapping/copyline.rs
@@ -289,13 +289,39 @@ pub fn remove_order(
 ///
 /// # Returns
 /// A vector of CopyLine structures, one per vertex (indexed by vertex id).
+///
+/// # Errors
+/// Returns [`ReductionError`](super::ReductionError) when the vertex order is not a
+/// permutation of all vertices or an edge endpoint is outside the graph.
 pub fn create_copylines(
     num_vertices: usize,
     edges: &[(usize, usize)],
     vertex_order: &[usize],
-) -> Vec<CopyLine> {
+) -> Result<Vec<CopyLine>, super::ReductionError> {
     if num_vertices == 0 {
-        return Vec::new();
+        return Ok(Vec::new());
+    }
+    if vertex_order.len() != num_vertices {
+        return Err(super::mapping_invalid(
+            "vertex_order must contain every vertex exactly once",
+        ));
+    }
+    let mut seen = vec![false; num_vertices];
+    for &vertex in vertex_order {
+        if vertex >= num_vertices || seen[vertex] {
+            return Err(super::mapping_invalid(
+                "vertex_order must contain every vertex exactly once",
+            ));
+        }
+        seen[vertex] = true;
+    }
+    if edges
+        .iter()
+        .any(|&(u, v)| u >= num_vertices || v >= num_vertices)
+    {
+        return Err(super::mapping_invalid(
+            "edge endpoints must be valid vertices",
+        ));
     }
 
     // Build adjacency set for edge lookup
@@ -381,7 +407,7 @@ pub fn create_copylines(
         );
     }
 
-    copylines
+    Ok(copylines)
 }
 
 /// Calculate the MIS (Maximum Independent Set) overhead for a copy line.
@@ -402,10 +428,15 @@ pub fn create_copylines(
 ///
 /// For unweighted mapping, the overhead is `length(locs) / 2` where locs
 /// are the dense copyline locations. This matches Julia's UnitDiskMapping.jl.
-pub fn mis_overhead_copyline(line: &CopyLine, spacing: usize, padding: usize) -> usize {
+pub fn mis_overhead_copyline(
+    line: &CopyLine,
+    spacing: usize,
+    padding: usize,
+) -> Result<i64, super::ReductionError> {
     let locs = line.copyline_locations(padding, spacing);
     // Julia asserts length(locs) % 2 == 1, then returns length(locs) ÷ 2
-    locs.len() / 2
+    i64::try_from(locs.len() / 2)
+        .map_err(|_| super::mapping_integer_overflow("converting copy-line MIS overhead to i64"))
 }
 
 /// Generate weighted locations for a copy line in triangular mode.
@@ -413,7 +444,7 @@ pub fn mis_overhead_copyline(line: &CopyLine, spacing: usize, padding: usize) ->
 ///
 /// Returns (locations, weights) where:
 /// - locations: Vec of (row, col) positions
-/// - weights: Vec of i32 weights (typically 2 for regular nodes, 1 for turn points)
+/// - weights: Vec of i64 weights (typically 2 for regular nodes, 1 for turn points)
 ///
 /// The sequence of nodes forms a chain-like structure with the center node at the end.
 /// Nodes with weight=1 mark "break points" in the chain where the next node connects
@@ -429,7 +460,7 @@ pub fn mis_overhead_copyline(line: &CopyLine, spacing: usize, padding: usize) ->
 pub fn copyline_weighted_locations_triangular(
     line: &CopyLine,
     spacing: usize,
-) -> (Vec<(usize, usize)>, Vec<i32>) {
+) -> (Vec<(usize, usize)>, Vec<i64>) {
     let mut locs = Vec::new();
     let mut weights = Vec::new();
     let mut nline = 0usize;
@@ -494,7 +525,7 @@ pub fn copyline_weighted_locations_triangular(
     // This is the "hub" node that the chain wraps around to
     let center_row = locs.len();
     locs.push((center_row, 0));
-    weights.push(nline.max(1) as i32);
+    weights.push(i64::try_from(nline.max(1)).expect("a copy line has at most three segments"));
 
     (locs, weights)
 }
@@ -514,15 +545,33 @@ pub fn copyline_weighted_locations_triangular(
 /// - Horizontal segment from vslot to hstop: max((hstop - vslot) * s - 2, 0)
 ///
 /// For spacing=6 (our default), use s=spacing to match the node density.
-pub fn mis_overhead_copyline_triangular(line: &CopyLine, spacing: usize) -> i32 {
+pub fn mis_overhead_copyline_triangular(
+    line: &CopyLine,
+    spacing: usize,
+) -> Result<i64, super::ReductionError> {
     // Use spacing directly as the factor
-    let s: i32 = spacing as i32;
-
-    let vertical_up = (line.hslot as i32 - line.vstart as i32) * s;
-    let vertical_down = (line.vstop as i32 - line.hslot as i32) * s;
-    let horizontal = ((line.hstop as i32 - line.vslot as i32) * s - 2).max(0);
-
-    vertical_up + vertical_down + horizontal
+    let s = i64::try_from(spacing).map_err(|_| {
+        super::mapping_integer_overflow("converting triangular copy-line spacing to i64")
+    })?;
+    let segment = |end: usize, start: usize| {
+        end.checked_sub(start)
+            .and_then(|length| i64::try_from(length).ok())
+            .and_then(|length| length.checked_mul(s))
+            .ok_or(super::mapping_integer_overflow(
+                "computing triangular copy-line overhead",
+            ))
+    };
+    let vertical_up = segment(line.hslot, line.vstart)?;
+    let vertical_down = segment(line.vstop, line.hslot)?;
+    let horizontal = segment(line.hstop, line.vslot)?;
+    let horizontal = if horizontal >= 2 { horizontal - 2 } else { 0 };
+
+    vertical_up
+        .checked_add(vertical_down)
+        .and_then(|total| total.checked_add(horizontal))
+        .ok_or(super::mapping_integer_overflow(
+            "summing triangular copy-line overhead",
+        ))
 }
 
 #[cfg(test)]
diff --git a/src/rules/unitdiskmapping/grid.rs b/src/rules/unitdiskmapping/grid.rs
index 16edfb5b6..d9031c880 100644
--- a/src/rules/unitdiskmapping/grid.rs
+++ b/src/rules/unitdiskmapping/grid.rs
@@ -9,13 +9,13 @@ pub enum CellState {
     #[default]
     Empty,
     Occupied {
-        weight: i32,
+        weight: i64,
     },
     Doubled {
-        weight: i32,
+        weight: i64,
     },
     Connected {
-        weight: i32,
+        weight: i64,
     },
 }
 
@@ -28,7 +28,7 @@ impl CellState {
         !self.is_empty()
     }
 
-    pub fn weight(&self) -> i32 {
+    pub fn weight(&self) -> i64 {
         match self {
             CellState::Empty => 0,
             CellState::Occupied { weight } => *weight,
@@ -117,7 +117,7 @@ impl MappingGrid {
     /// For unweighted mode, all weights are 1 so this doesn't matter.
     ///
     /// Silently ignores out-of-bounds access.
-    pub fn add_node(&mut self, row: usize, col: usize, weight: i32) {
+    pub fn add_node(&mut self, row: usize, col: usize, weight: i64) {
         if row < self.rows && col < self.cols {
             match self.content[row][col] {
                 CellState::Empty => {
diff --git a/src/rules/unitdiskmapping/ksg/gadgets.rs b/src/rules/unitdiskmapping/ksg/gadgets.rs
index 3bf84ca9f..4e64e7574 100644
--- a/src/rules/unitdiskmapping/ksg/gadgets.rs
+++ b/src/rules/unitdiskmapping/ksg/gadgets.rs
@@ -6,6 +6,8 @@
 
 use super::super::grid::{CellState, MappingGrid};
 use super::super::traits::{apply_gadget, pattern_matches, Pattern, PatternCell};
+use crate::rules::unitdiskmapping::{mapping_integer_overflow, mapping_invalid};
+use crate::rules::ReductionError;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -60,7 +62,7 @@ impl Pattern for KsgCross<true> {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -1
     }
 
@@ -160,7 +162,7 @@ impl Pattern for KsgCross<false> {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -1
     }
 
@@ -262,7 +264,7 @@ impl Pattern for KsgTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -1
     }
 
@@ -320,7 +322,7 @@ impl Pattern for KsgWTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -1
     }
 
@@ -387,16 +389,16 @@ impl Pattern for KsgBranch {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -1
     }
 
     // Julia: sw[[4]] .= 3 (node 4 = 0-indexed 3 has weight 3)
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2, 2, 2, 3, 2, 2, 2, 2]
     }
     // Julia: mw[[2]] .= 3 (mapped node 2 = 0-indexed 1 has weight 3)
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2, 3, 2, 2, 2, 2]
     }
 
@@ -478,7 +480,7 @@ impl Pattern for KsgBranchFix {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -1
     }
 
@@ -540,16 +542,16 @@ impl Pattern for KsgTCon {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0
     }
 
     // Julia: sw[[2]] .= 1 (node 2 = 0-indexed 1 has weight 1)
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2, 1, 2, 2]
     }
     // Julia: mw[[2]] .= 1 (mapped node 2 = 0-indexed 1 has weight 1)
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2, 1, 2, 2]
     }
 
@@ -613,16 +615,16 @@ impl Pattern for KsgTrivialTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0
     }
 
     // Julia: sw[[1,2]] .= 1 (nodes 1,2 have weight 1)
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![1, 1]
     }
     // Julia: mw[[1,2]] .= 1 (mapped nodes 1,2 have weight 1)
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1, 1]
     }
 
@@ -668,16 +670,16 @@ impl Pattern for KsgEndTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -1
     }
 
     // Julia: sw[[3]] .= 1 (node 3 = 0-indexed 2 has weight 1)
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2, 2, 1]
     }
     // Julia: mw[[1]] .= 1 (mapped node 1 = 0-indexed 0 has weight 1)
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1]
     }
 
@@ -721,16 +723,16 @@ impl Pattern for KsgBranchFixB {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -1
     }
 
     // Julia: sw[[1]] .= 1 (node 1 = 0-indexed 0 has weight 1)
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![1, 2, 2, 2]
     }
     // Julia: mw[[1]] .= 1 (mapped node 1 = 0-indexed 0 has weight 1)
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1, 2]
     }
 
@@ -772,19 +774,23 @@ impl<G: Pattern> KsgRotatedGadget<G> {
     }
 }
 
-fn rotate90(loc: (i32, i32)) -> (i32, i32) {
+fn rotate90(loc: (i64, i64)) -> (i64, i64) {
     (-loc.1, loc.0)
 }
 
-fn rotate_around_center(loc: (usize, usize), center: (usize, usize), n: usize) -> (i32, i32) {
-    let mut dx = loc.0 as i32 - center.0 as i32;
-    let mut dy = loc.1 as i32 - center.1 as i32;
+fn rotate_around_center(loc: (usize, usize), center: (usize, usize), n: usize) -> (i64, i64) {
+    let center = (
+        i64::try_from(center.0).expect("gadget coordinates fit i64"),
+        i64::try_from(center.1).expect("gadget coordinates fit i64"),
+    );
+    let mut dx = i64::try_from(loc.0).expect("gadget coordinates fit i64") - center.0;
+    let mut dy = i64::try_from(loc.1).expect("gadget coordinates fit i64") - center.1;
     for _ in 0..n {
         let (nx, ny) = rotate90((dx, dy));
         dx = nx;
         dy = ny;
     }
-    (center.0 as i32 + dx, center.1 as i32 + dy)
+    (center.0 + dx, center.1 + dy)
 }
 
 impl<G: Pattern> Pattern for KsgRotatedGadget<G> {
@@ -878,7 +884,7 @@ impl<G: Pattern> Pattern for KsgRotatedGadget<G> {
         (new_locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         self.gadget.mis_overhead()
     }
     fn mapped_entry_to_compact(&self) -> HashMap<usize, usize> {
@@ -889,10 +895,10 @@ impl<G: Pattern> Pattern for KsgRotatedGadget<G> {
     }
 
     // Weights don't change with rotation - delegate to inner gadget
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         self.gadget.source_weights()
     }
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         self.gadget.mapped_weights()
     }
 }
@@ -919,7 +925,7 @@ impl<G: Pattern> KsgReflectedGadget<G> {
     }
 }
 
-fn reflect(loc: (i32, i32), mirror: Mirror) -> (i32, i32) {
+fn reflect(loc: (i64, i64), mirror: Mirror) -> (i64, i64) {
     match mirror {
         Mirror::X => (loc.0, -loc.1),
         Mirror::Y => (-loc.0, loc.1),
@@ -932,11 +938,15 @@ fn reflect_around_center(
     loc: (usize, usize),
     center: (usize, usize),
     mirror: Mirror,
-) -> (i32, i32) {
-    let dx = loc.0 as i32 - center.0 as i32;
-    let dy = loc.1 as i32 - center.1 as i32;
+) -> (i64, i64) {
+    let center = (
+        i64::try_from(center.0).expect("gadget coordinates fit i64"),
+        i64::try_from(center.1).expect("gadget coordinates fit i64"),
+    );
+    let dx = i64::try_from(loc.0).expect("gadget coordinates fit i64") - center.0;
+    let dy = i64::try_from(loc.1).expect("gadget coordinates fit i64") - center.1;
     let (nx, ny) = reflect((dx, dy), mirror);
-    (center.0 as i32 + nx, center.1 as i32 + ny)
+    (center.0 + nx, center.1 + ny)
 }
 
 impl<G: Pattern> Pattern for KsgReflectedGadget<G> {
@@ -1029,7 +1039,7 @@ impl<G: Pattern> Pattern for KsgReflectedGadget<G> {
         (new_locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         self.gadget.mis_overhead()
     }
     fn mapped_entry_to_compact(&self) -> HashMap<usize, usize> {
@@ -1040,10 +1050,10 @@ impl<G: Pattern> Pattern for KsgReflectedGadget<G> {
     }
 
     // Weights don't change with reflection - delegate to inner gadget
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         self.gadget.source_weights()
     }
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         self.gadget.mapped_weights()
     }
 }
@@ -1094,16 +1104,16 @@ impl Pattern for KsgDanglingLeg {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -1
     }
 
     // Julia: sw[[1]] .= 1 (node 1 = 0-indexed 0 has weight 1)
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![1, 2, 2]
     }
     // Julia: mw[[1]] .= 1 (mapped node 1 = 0-indexed 0 has weight 1)
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1]
     }
 
@@ -1204,7 +1214,12 @@ impl KsgPattern {
     }
 
     /// Apply map_config_back_pattern for this pattern.
-    pub fn map_config_back(&self, gi: usize, gj: usize, config: &mut [Vec<usize>]) {
+    pub(crate) fn map_config_back(
+        &self,
+        gi: usize,
+        gj: usize,
+        config: &mut [Vec<usize>],
+    ) -> Result<(), ReductionError> {
         match self {
             Self::CrossFalse(p) => map_config_back_pattern(p, gi, gj, config),
             Self::CrossTrue(p) => map_config_back_pattern(p, gi, gj, config),
@@ -1243,8 +1258,8 @@ pub struct KsgTapeEntry {
 }
 
 /// Calculate MIS overhead for a tape entry.
-pub fn tape_entry_mis_overhead(entry: &KsgTapeEntry) -> i32 {
-    match entry.pattern_idx {
+pub fn tape_entry_mis_overhead(entry: &KsgTapeEntry) -> Result<i64, ReductionError> {
+    Ok(match entry.pattern_idx {
         0 => KsgCross::<false>.mis_overhead(),
         1 => KsgTurn.mis_overhead(),
         2 => KsgWTurn.mis_overhead(),
@@ -1259,8 +1274,12 @@ pub fn tape_entry_mis_overhead(entry: &KsgTapeEntry) -> i32 {
         11 => KsgEndTurn.mis_overhead(),
         12 => KsgReflectedGadget::new(KsgRotatedGadget::new(KsgTCon, 1), Mirror::Y).mis_overhead(),
         100..=105 => KsgDanglingLeg.mis_overhead(),
-        _ => 0,
-    }
+        _ => {
+            return Err(mapping_invalid(
+                "tape contains an unknown unweighted KSG gadget index",
+            ))
+        }
+    })
 }
 
 /// The default crossing ruleset for KSG square lattice.
@@ -1711,9 +1730,9 @@ pub fn apply_weighted_gadget<P: Pattern>(pattern: &P, grid: &mut MappingGrid, i:
     }
 
     // Build a map of (row, col) -> accumulated weight for doubled nodes
-    let mut weight_map: HashMap<(usize, usize), i32> = HashMap::new();
+    let mut weight_map: HashMap<(usize, usize), i64> = HashMap::new();
     for (idx, &(r, c)) in mapped_locs.iter().enumerate() {
-        let weight = mapped_weights.get(idx).copied().unwrap_or(2);
+        let weight = mapped_weights[idx];
         *weight_map.entry((r, c)).or_insert(0) += weight;
     }
 
@@ -1727,7 +1746,7 @@ pub fn apply_weighted_gadget<P: Pattern>(pattern: &P, grid: &mut MappingGrid, i:
     for (&(r, c), &total_weight) in &weight_map {
         let grid_r = i + r - 1; // Convert 1-indexed to 0-indexed
         let grid_c = j + c - 1;
-        let count = count_map.get(&(r, c)).copied().unwrap_or(1);
+        let count = count_map[&(r, c)];
 
         let state = if count > 1 {
             CellState::Doubled {
@@ -1743,12 +1762,12 @@ pub fn apply_weighted_gadget<P: Pattern>(pattern: &P, grid: &mut MappingGrid, i:
 }
 
 /// Map configuration back through a single gadget.
-pub fn map_config_back_pattern<P: Pattern>(
+pub(crate) fn map_config_back_pattern<P: Pattern>(
     pattern: &P,
     gi: usize,
     gj: usize,
     config: &mut [Vec<usize>],
-) {
+) -> Result<(), ReductionError> {
     let (m, n) = pattern.size();
     let (mapped_locs, mapped_pins) = pattern.mapped_graph();
     let (source_locs, _, _) = pattern.source_graph();
@@ -1763,15 +1782,20 @@ pub fn map_config_back_pattern<P: Pattern>(
                 .get(row)
                 .and_then(|row_vec| row_vec.get(col))
                 .copied()
-                .unwrap_or(0)
+                .ok_or(mapping_invalid(
+                    "unweighted KSG gadget lies outside the configuration grid",
+                ))
         })
-        .collect();
+        .collect::<Result<_, _>>()?;
 
     // Step 2: Compute boundary config
     let bc = {
         let mut result = 0usize;
         for (i, &pin_idx) in mapped_pins.iter().enumerate() {
-            if pin_idx < mapped_config.len() && mapped_config[pin_idx] > 0 {
+            if *mapped_config.get(pin_idx).ok_or(mapping_invalid(
+                "unweighted KSG gadget contains an invalid mapped pin index",
+            ))? > 0
+            {
                 result |= 1 << i;
             }
         }
@@ -1782,41 +1806,30 @@ pub fn map_config_back_pattern<P: Pattern>(
     let d1 = pattern.mapped_entry_to_compact();
     let d2 = pattern.source_entry_to_configs();
 
-    let compact = d1.get(&bc).copied();
-    debug_assert!(
-        compact.is_some(),
-        "Boundary config {} not found in mapped_entry_to_compact",
-        bc
-    );
-    let compact = compact.unwrap_or(0);
-
-    let source_configs = d2.get(&compact).cloned();
-    debug_assert!(
-        source_configs.is_some(),
-        "Compact {} not found in source_entry_to_configs",
-        compact
-    );
-    let source_configs = source_configs.unwrap_or_default();
-
-    debug_assert!(
-        !source_configs.is_empty(),
-        "Empty source configs for compact {}.",
-        compact
-    );
-    let new_config = if source_configs.is_empty() {
-        vec![false; source_locs.len()]
-    } else {
-        source_configs[0].clone()
-    };
+    let compact = d1.get(&bc).copied().ok_or(mapping_invalid(
+        "unweighted KSG boundary configuration has no source equivalent",
+    ))?;
+    let new_config =
+        d2.get(&compact)
+            .and_then(|configs| configs.first())
+            .ok_or(mapping_invalid(
+                "unweighted KSG compact state has no source configuration",
+            ))?;
+    if new_config.len() != source_locs.len() {
+        return Err(mapping_invalid(
+            "unweighted KSG source configuration has the wrong length",
+        ));
+    }
 
     // Step 4: Clear gadget area
     for row in gi..gi + m {
         for col in gj..gj + n {
-            if let Some(row_vec) = config.get_mut(row) {
-                if let Some(cell) = row_vec.get_mut(col) {
-                    *cell = 0;
-                }
-            }
+            *config
+                .get_mut(row)
+                .and_then(|row_vec| row_vec.get_mut(col))
+                .ok_or(mapping_invalid(
+                    "unweighted KSG gadget lies outside the configuration grid",
+                ))? = 0;
         }
     }
 
@@ -1824,14 +1837,18 @@ pub fn map_config_back_pattern<P: Pattern>(
     for (k, &(r, c)) in source_locs.iter().enumerate() {
         let row = gi + r - 1;
         let col = gj + c - 1;
-        if let Some(rv) = config.get_mut(row) {
-            if let Some(cv) = rv.get_mut(col) {
-                *cv += if new_config.get(k).copied().unwrap_or(false) {
-                    1
-                } else {
-                    0
-                };
-            }
-        }
-    }
+        let cell = config
+            .get_mut(row)
+            .and_then(|row_vec| row_vec.get_mut(col))
+            .ok_or(mapping_invalid(
+                "unweighted KSG source position lies outside the configuration grid",
+            ))?;
+        *cell = cell
+            .checked_add(usize::from(new_config[k]))
+            .ok_or(mapping_integer_overflow(
+                "accumulating an unweighted KSG source configuration",
+            ))?;
+    }
+
+    Ok(())
 }
diff --git a/src/rules/unitdiskmapping/ksg/gadgets_weighted.rs b/src/rules/unitdiskmapping/ksg/gadgets_weighted.rs
index 78d0f609d..71ea5c91c 100644
--- a/src/rules/unitdiskmapping/ksg/gadgets_weighted.rs
+++ b/src/rules/unitdiskmapping/ksg/gadgets_weighted.rs
@@ -7,6 +7,8 @@
 use super::super::grid::{CellState, MappingGrid};
 use super::super::traits::{apply_gadget, pattern_matches, Pattern, PatternCell};
 use super::gadgets::{KsgReflectedGadget, KsgRotatedGadget, Mirror};
+use crate::rules::unitdiskmapping::{mapping_integer_overflow, mapping_invalid};
+use crate::rules::ReductionError;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -61,15 +63,15 @@ impl Pattern for WeightedKsgCross<true> {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2 // 2x unweighted value (-1 * 2)
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2; 6]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2; 5]
     }
 
@@ -169,15 +171,15 @@ impl Pattern for WeightedKsgCross<false> {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2 // 2x unweighted value (-1 * 2)
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2; 9]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2; 10]
     }
 
@@ -279,15 +281,15 @@ impl Pattern for WeightedKsgTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2 // 2x unweighted value (-1 * 2)
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2; 5]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2; 3]
     }
 
@@ -345,15 +347,15 @@ impl Pattern for WeightedKsgWTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2 // 2x unweighted value (-1 * 2)
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2; 5]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2; 3]
     }
 
@@ -420,17 +422,17 @@ impl Pattern for WeightedKsgBranch {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2 // 2x unweighted value (-1 * 2)
     }
 
     // Weighted version: node 3 (0-indexed) has weight 3, others have weight 2
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2, 2, 2, 3, 2, 2, 2, 2]
     }
 
     // Weighted version: node 1 (0-indexed) has weight 3, others have weight 2
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2, 3, 2, 2, 2, 2]
     }
 
@@ -512,15 +514,15 @@ impl Pattern for WeightedKsgBranchFix {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2 // 2x unweighted value (-1 * 2)
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2; 6]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2; 4]
     }
 
@@ -582,17 +584,17 @@ impl Pattern for WeightedKsgTCon {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0 // 2x unweighted value (0 * 2)
     }
 
     // Weighted version: node 1 (0-indexed) has weight 1, others have weight 2
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2, 1, 2, 2]
     }
 
     // Weighted version: node 1 (0-indexed) has weight 1, others have weight 2
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2, 1, 2, 2]
     }
 
@@ -656,17 +658,17 @@ impl Pattern for WeightedKsgTrivialTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0 // 2x unweighted value (0 * 2)
     }
 
     // Weighted version: both nodes have weight 1
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![1, 1]
     }
 
     // Weighted version: both nodes have weight 1
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1, 1]
     }
 
@@ -712,17 +714,17 @@ impl Pattern for WeightedKsgEndTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2 // 2x unweighted value (-1 * 2)
     }
 
     // Weighted version: node 2 (0-indexed) has weight 1, others have weight 2
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2, 2, 1]
     }
 
     // Weighted version: node 0 (0-indexed) has weight 1
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1]
     }
 
@@ -766,17 +768,17 @@ impl Pattern for WeightedKsgBranchFixB {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2 // 2x unweighted value (-1 * 2)
     }
 
     // Weighted version: node 0 (0-indexed) has weight 1, others have weight 2
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![1, 2, 2, 2]
     }
 
     // Weighted version: node 0 (0-indexed) has weight 1, node 1 has weight 2
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1, 2]
     }
 
@@ -828,17 +830,17 @@ impl Pattern for WeightedKsgDanglingLeg {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2 // 2x unweighted value (-1 * 2)
     }
 
     // Weighted version: node 0 (0-indexed) has weight 1, others have weight 2
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![1, 2, 2]
     }
 
     // Weighted version: node 0 (0-indexed) has weight 1
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1]
     }
 
@@ -938,7 +940,12 @@ impl WeightedKsgPattern {
     }
 
     /// Apply map_config_back_pattern for this pattern.
-    pub fn map_config_back(&self, gi: usize, gj: usize, config: &mut [Vec<usize>]) {
+    pub(crate) fn map_config_back(
+        &self,
+        gi: usize,
+        gj: usize,
+        config: &mut [Vec<usize>],
+    ) -> Result<(), ReductionError> {
         match self {
             Self::CrossFalse(p) => map_config_back_pattern(p, gi, gj, config),
             Self::CrossTrue(p) => map_config_back_pattern(p, gi, gj, config),
@@ -977,8 +984,10 @@ pub struct WeightedKsgTapeEntry {
 }
 
 /// Calculate MIS overhead for a weighted tape entry.
-pub fn weighted_tape_entry_mis_overhead(entry: &WeightedKsgTapeEntry) -> i32 {
-    match entry.pattern_idx {
+pub fn weighted_tape_entry_mis_overhead(
+    entry: &WeightedKsgTapeEntry,
+) -> Result<i64, ReductionError> {
+    Ok(match entry.pattern_idx {
         0 => WeightedKsgCross::<false>.mis_overhead(),
         1 => WeightedKsgTurn.mis_overhead(),
         2 => WeightedKsgWTurn.mis_overhead(),
@@ -994,8 +1003,12 @@ pub fn weighted_tape_entry_mis_overhead(entry: &WeightedKsgTapeEntry) -> i32 {
         12 => KsgReflectedGadget::new(KsgRotatedGadget::new(WeightedKsgTCon, 1), Mirror::Y)
             .mis_overhead(),
         100..=105 => WeightedKsgDanglingLeg.mis_overhead(),
-        _ => 0,
-    }
+        _ => {
+            return Err(mapping_invalid(
+                "tape contains an unknown weighted KSG gadget index",
+            ))
+        }
+    })
 }
 
 /// Trait for boxed weighted pattern operations.
@@ -1006,8 +1019,8 @@ pub trait WeightedKsgPatternBoxed {
     fn mapped_matrix(&self) -> Vec<Vec<PatternCell>>;
     fn source_graph_boxed(&self) -> SourceGraph;
     fn mapped_graph_boxed(&self) -> (Vec<(usize, usize)>, Vec<usize>);
-    fn source_weights_boxed(&self) -> Vec<i32>;
-    fn mapped_weights_boxed(&self) -> Vec<i32>;
+    fn source_weights_boxed(&self) -> Vec<i64>;
+    fn mapped_weights_boxed(&self) -> Vec<i64>;
     fn pattern_matches_boxed(&self, grid: &MappingGrid, i: usize, j: usize) -> bool;
     fn apply_gadget_boxed(&self, grid: &mut MappingGrid, i: usize, j: usize);
     fn apply_weighted_gadget_boxed(&self, grid: &mut MappingGrid, i: usize, j: usize);
@@ -1032,10 +1045,10 @@ impl<P: Pattern> WeightedKsgPatternBoxed for P {
     fn mapped_graph_boxed(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
         Pattern::mapped_graph(self)
     }
-    fn source_weights_boxed(&self) -> Vec<i32> {
+    fn source_weights_boxed(&self) -> Vec<i64> {
         Pattern::source_weights(self)
     }
-    fn mapped_weights_boxed(&self) -> Vec<i32> {
+    fn mapped_weights_boxed(&self) -> Vec<i64> {
         Pattern::mapped_weights(self)
     }
     fn pattern_matches_boxed(&self, grid: &MappingGrid, i: usize, j: usize) -> bool {
@@ -1067,9 +1080,9 @@ pub fn apply_weighted_gadget<P: Pattern>(pattern: &P, grid: &mut MappingGrid, i:
     }
 
     // Build a map of (row, col) -> accumulated weight for doubled nodes
-    let mut weight_map: HashMap<(usize, usize), i32> = HashMap::new();
+    let mut weight_map: HashMap<(usize, usize), i64> = HashMap::new();
     for (idx, &(r, c)) in mapped_locs.iter().enumerate() {
-        let weight = mapped_weights.get(idx).copied().unwrap_or(2);
+        let weight = mapped_weights[idx];
         *weight_map.entry((r, c)).or_insert(0) += weight;
     }
 
@@ -1083,7 +1096,7 @@ pub fn apply_weighted_gadget<P: Pattern>(pattern: &P, grid: &mut MappingGrid, i:
     for (&(r, c), &total_weight) in &weight_map {
         let grid_r = i + r - 1; // Convert 1-indexed to 0-indexed
         let grid_c = j + c - 1;
-        let count = count_map.get(&(r, c)).copied().unwrap_or(1);
+        let count = count_map[&(r, c)];
 
         let state = if count > 1 {
             CellState::Doubled {
@@ -1252,7 +1265,7 @@ fn pattern_matches_weighted(
         let grid_r = i + loc_r - 1;
         let grid_c = j + loc_c - 1;
         if let Some(cell) = grid.get(grid_r, grid_c) {
-            let expected_weight = source_weights.get(idx).copied().unwrap_or(2);
+            let expected_weight = source_weights[idx];
             if cell.weight() != expected_weight {
                 return false;
             }
@@ -1274,12 +1287,12 @@ fn rotated_and_reflected_weighted_danglingleg() -> Vec<Box<dyn WeightedKsgPatter
 }
 
 /// Map configuration back through a single gadget.
-pub fn map_config_back_pattern<P: Pattern>(
+pub(crate) fn map_config_back_pattern<P: Pattern>(
     pattern: &P,
     gi: usize,
     gj: usize,
     config: &mut [Vec<usize>],
-) {
+) -> Result<(), ReductionError> {
     let (m, n) = pattern.size();
     let (mapped_locs, mapped_pins) = pattern.mapped_graph();
     let (source_locs, _, _) = pattern.source_graph();
@@ -1294,15 +1307,20 @@ pub fn map_config_back_pattern<P: Pattern>(
                 .get(row)
                 .and_then(|row_vec| row_vec.get(col))
                 .copied()
-                .unwrap_or(0)
+                .ok_or(mapping_invalid(
+                    "weighted KSG gadget lies outside the configuration grid",
+                ))
         })
-        .collect();
+        .collect::<Result<_, _>>()?;
 
     // Step 2: Compute boundary config
     let bc = {
         let mut result = 0usize;
         for (i, &pin_idx) in mapped_pins.iter().enumerate() {
-            if pin_idx < mapped_config.len() && mapped_config[pin_idx] > 0 {
+            if *mapped_config.get(pin_idx).ok_or(mapping_invalid(
+                "weighted KSG gadget contains an invalid mapped pin index",
+            ))? > 0
+            {
                 result |= 1 << i;
             }
         }
@@ -1313,41 +1331,30 @@ pub fn map_config_back_pattern<P: Pattern>(
     let d1 = pattern.mapped_entry_to_compact();
     let d2 = pattern.source_entry_to_configs();
 
-    let compact = d1.get(&bc).copied();
-    debug_assert!(
-        compact.is_some(),
-        "Boundary config {} not found in mapped_entry_to_compact",
-        bc
-    );
-    let compact = compact.unwrap_or(0);
-
-    let source_configs = d2.get(&compact).cloned();
-    debug_assert!(
-        source_configs.is_some(),
-        "Compact {} not found in source_entry_to_configs",
-        compact
-    );
-    let source_configs = source_configs.unwrap_or_default();
-
-    debug_assert!(
-        !source_configs.is_empty(),
-        "Empty source configs for compact {}.",
-        compact
-    );
-    let new_config = if source_configs.is_empty() {
-        vec![false; source_locs.len()]
-    } else {
-        source_configs[0].clone()
-    };
+    let compact = d1.get(&bc).copied().ok_or(mapping_invalid(
+        "weighted KSG boundary configuration has no source equivalent",
+    ))?;
+    let new_config =
+        d2.get(&compact)
+            .and_then(|configs| configs.first())
+            .ok_or(mapping_invalid(
+                "weighted KSG compact state has no source configuration",
+            ))?;
+    if new_config.len() != source_locs.len() {
+        return Err(mapping_invalid(
+            "weighted KSG source configuration has the wrong length",
+        ));
+    }
 
     // Step 4: Clear gadget area
     for row in gi..gi + m {
         for col in gj..gj + n {
-            if let Some(row_vec) = config.get_mut(row) {
-                if let Some(cell) = row_vec.get_mut(col) {
-                    *cell = 0;
-                }
-            }
+            *config
+                .get_mut(row)
+                .and_then(|row_vec| row_vec.get_mut(col))
+                .ok_or(mapping_invalid(
+                    "weighted KSG gadget lies outside the configuration grid",
+                ))? = 0;
         }
     }
 
@@ -1355,16 +1362,20 @@ pub fn map_config_back_pattern<P: Pattern>(
     for (k, &(r, c)) in source_locs.iter().enumerate() {
         let row = gi + r - 1;
         let col = gj + c - 1;
-        if let Some(rv) = config.get_mut(row) {
-            if let Some(cv) = rv.get_mut(col) {
-                *cv += if new_config.get(k).copied().unwrap_or(false) {
-                    1
-                } else {
-                    0
-                };
-            }
-        }
-    }
+        let cell = config
+            .get_mut(row)
+            .and_then(|row_vec| row_vec.get_mut(col))
+            .ok_or(mapping_invalid(
+                "weighted KSG source position lies outside the configuration grid",
+            ))?;
+        *cell = cell
+            .checked_add(usize::from(new_config[k]))
+            .ok_or(mapping_integer_overflow(
+                "accumulating a weighted KSG source configuration",
+            ))?;
+    }
+
+    Ok(())
 }
 
 #[cfg(test)]
diff --git a/src/rules/unitdiskmapping/ksg/mapping.rs b/src/rules/unitdiskmapping/ksg/mapping.rs
index af2527f68..23e471a58 100644
--- a/src/rules/unitdiskmapping/ksg/mapping.rs
+++ b/src/rules/unitdiskmapping/ksg/mapping.rs
@@ -17,6 +17,8 @@ use super::gadgets_weighted::{
     weighted_tape_entry_mis_overhead, WeightedKsgPattern, WeightedKsgTapeEntry,
 };
 use super::{PADDING, SPACING};
+use crate::rules::unitdiskmapping::{mapping_integer_overflow, mapping_invalid};
+use crate::rules::ReductionError;
 use crate::topology::{Graph, KingsSubgraph, TriangularSubgraph};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
@@ -35,9 +37,9 @@ pub enum GridKind {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MappingResult<T = KsgTapeEntry> {
     /// Integer grid positions (row, col) for each node.
-    pub positions: Vec<(i32, i32)>,
+    pub positions: Vec<(i64, i64)>,
     /// Weight of each node.
-    pub node_weights: Vec<i32>,
+    pub node_weights: Vec<i64>,
     /// Grid dimensions (rows, cols).
     pub grid_dimensions: (usize, usize),
     /// The kind of grid lattice.
@@ -49,7 +51,7 @@ pub struct MappingResult<T = KsgTapeEntry> {
     /// Spacing used.
     pub spacing: usize,
     /// MIS overhead from the mapping.
-    pub mis_overhead: i32,
+    pub mis_overhead: i64,
     /// Tape entries recording gadget applications (for unapply during solution extraction).
     pub tape: Vec<T>,
     /// Doubled cells (where two copy lines overlap) for map_config_back.
@@ -94,7 +96,7 @@ impl<T> MappingResult<T> {
         let (rows, cols) = self.grid_dimensions;
 
         // Build position to node index map
-        let mut pos_to_node: HashMap<(i32, i32), usize> = HashMap::new();
+        let mut pos_to_node: HashMap<(i64, i64), usize> = HashMap::new();
         for (idx, &(r, c)) in self.positions.iter().enumerate() {
             pos_to_node.insert((r, c), idx);
         }
@@ -102,6 +104,7 @@ impl<T> MappingResult<T> {
         let mut lines = Vec::new();
 
         for r in 0..rows {
+            let row = i64::try_from(r).expect("mapping grid rows are validated against i64");
             let mut line = String::new();
             for c in 0..cols {
                 let is_selected = config
@@ -110,7 +113,9 @@ impl<T> MappingResult<T> {
                     .copied()
                     .unwrap_or(0)
                     > 0;
-                let has_node = pos_to_node.contains_key(&(r as i32, c as i32));
+                let column =
+                    i64::try_from(c).expect("mapping grid columns are validated against i64");
+                let has_node = pos_to_node.contains_key(&(row, column));
 
                 let s = if has_node {
                     if is_selected {
@@ -166,16 +171,18 @@ impl<T> MappingResult<T> {
 
         let (rows, cols) = self.grid_dimensions;
 
-        let mut pos_to_idx: HashMap<(i32, i32), usize> = HashMap::new();
+        let mut pos_to_idx: HashMap<(i64, i64), usize> = HashMap::new();
         for (idx, &(r, c)) in self.positions.iter().enumerate() {
             pos_to_idx.insert((r, c), idx);
         }
 
         let mut lines = Vec::new();
 
-        for r in 0..rows as i32 {
+        for r in 0..rows {
+            let r = i64::try_from(r).expect("mapping grid rows are validated against i64");
             let mut line = String::new();
-            for c in 0..cols as i32 {
+            for c in 0..cols {
+                let c = i64::try_from(c).expect("mapping grid columns are validated against i64");
                 let s = if let Some(&idx) = pos_to_idx.get(&(r, c)) {
                     if let Some(cfg) = config {
                         if cfg.get(idx).copied().unwrap_or(0) > 0 {
@@ -219,21 +226,42 @@ impl MappingResult<KsgTapeEntry> {
     ///
     /// # Returns
     /// A vector where `result[v]` is 1 if vertex `v` is selected, 0 otherwise.
-    pub fn map_config_back(&self, grid_config: &[usize]) -> Vec<usize> {
+    pub fn map_config_back(
+        &self,
+        grid_config: &[usize],
+    ) -> crate::rules::ExtractionResult<Vec<usize>> {
+        self.map_config_back_internal(grid_config)
+            .map_err(|error| crate::rules::ExtractionError::invalid(error.to_string()))
+    }
+
+    fn map_config_back_internal(
+        &self,
+        grid_config: &[usize],
+    ) -> Result<Vec<usize>, ReductionError> {
+        if grid_config.len() != self.positions.len() {
+            return Err(mapping_invalid(
+                "grid configuration length must match the mapped vertex count",
+            ));
+        }
         // Step 1: Convert flat config to 2D matrix
         let (rows, cols) = self.grid_dimensions;
         let mut config_2d = vec![vec![0usize; cols]; rows];
 
         for (idx, &(row, col)) in self.positions.iter().enumerate() {
-            let row = row as usize;
-            let col = col as usize;
-            if row < rows && col < cols {
-                config_2d[row][col] = grid_config.get(idx).copied().unwrap_or(0);
+            let row = usize::try_from(row)
+                .map_err(|_| mapping_invalid("mapping result contains a negative grid row"))?;
+            let col = usize::try_from(col)
+                .map_err(|_| mapping_invalid("mapping result contains a negative grid column"))?;
+            if row >= rows || col >= cols {
+                return Err(mapping_invalid(
+                    "mapping result contains a position outside its grid dimensions",
+                ));
             }
+            config_2d[row][col] = grid_config[idx];
         }
 
         // Step 2: Unapply gadgets in reverse order
-        unapply_gadgets(&self.tape, &mut config_2d);
+        unapply_gadgets(&self.tape, &mut config_2d)?;
 
         // Step 3: Extract vertex configs from copylines
         map_config_copyback(
@@ -244,50 +272,46 @@ impl MappingResult<KsgTapeEntry> {
             &self.doubled_cells,
         )
     }
-
-    /// Map a configuration back from grid to original graph using center locations.
-    pub fn map_config_back_via_centers(&self, grid_config: &[usize]) -> Vec<usize> {
-        // Build a position to node index map
-        let mut pos_to_idx: HashMap<(usize, usize), usize> = HashMap::new();
-        for (idx, &(row, col)) in self.positions.iter().enumerate() {
-            if let (Ok(row), Ok(col)) = (usize::try_from(row), usize::try_from(col)) {
-                pos_to_idx.insert((row, col), idx);
-            }
-        }
-
-        // Get traced center locations (after gadget transformations)
-        let centers = trace_centers(self);
-        let num_vertices = centers.len();
-        let mut result = vec![0usize; num_vertices];
-
-        // Read config at each center location
-        for (vertex, &(row, col)) in centers.iter().enumerate() {
-            if let Some(&node_idx) = pos_to_idx.get(&(row, col)) {
-                result[vertex] = grid_config.get(node_idx).copied().unwrap_or(0);
-            }
-        }
-
-        result
-    }
 }
 
 impl MappingResult<WeightedKsgTapeEntry> {
     /// Map a configuration back from grid to original graph (weighted version).
-    pub fn map_config_back(&self, grid_config: &[usize]) -> Vec<usize> {
+    pub fn map_config_back(
+        &self,
+        grid_config: &[usize],
+    ) -> crate::rules::ExtractionResult<Vec<usize>> {
+        self.map_config_back_internal(grid_config)
+            .map_err(|error| crate::rules::ExtractionError::invalid(error.to_string()))
+    }
+
+    fn map_config_back_internal(
+        &self,
+        grid_config: &[usize],
+    ) -> Result<Vec<usize>, ReductionError> {
+        if grid_config.len() != self.positions.len() {
+            return Err(mapping_invalid(
+                "grid configuration length must match the mapped vertex count",
+            ));
+        }
         // Step 1: Convert flat config to 2D matrix
         let (rows, cols) = self.grid_dimensions;
         let mut config_2d = vec![vec![0usize; cols]; rows];
 
         for (idx, &(row, col)) in self.positions.iter().enumerate() {
-            let row = row as usize;
-            let col = col as usize;
-            if row < rows && col < cols {
-                config_2d[row][col] = grid_config.get(idx).copied().unwrap_or(0);
+            let row = usize::try_from(row)
+                .map_err(|_| mapping_invalid("mapping result contains a negative grid row"))?;
+            let col = usize::try_from(col)
+                .map_err(|_| mapping_invalid("mapping result contains a negative grid column"))?;
+            if row >= rows || col >= cols {
+                return Err(mapping_invalid(
+                    "mapping result contains a position outside its grid dimensions",
+                ));
             }
+            config_2d[row][col] = grid_config[idx];
         }
 
         // Step 2: Unapply gadgets in reverse order
-        unapply_weighted_gadgets(&self.tape, &mut config_2d);
+        unapply_weighted_gadgets(&self.tape, &mut config_2d)?;
 
         // Step 3: Extract vertex configs from copylines
         map_config_copyback(
@@ -312,153 +336,121 @@ impl<T> fmt::Display for MappingResult<T> {
 /// - For doubled cells: count 1 if value is 2, or if value is 1 and both neighbors are 0
 /// - For regular cells: just add the value
 /// - Result is `count - (len(locs) / 2)`
-pub fn map_config_copyback(
+pub(crate) fn map_config_copyback(
     lines: &[CopyLine],
     padding: usize,
     spacing: usize,
     config: &[Vec<usize>],
     doubled_cells: &HashSet<(usize, usize)>,
-) -> Vec<usize> {
+) -> Result<Vec<usize>, ReductionError> {
     let mut result = vec![0usize; lines.len()];
 
     for line in lines {
         let locs = line.copyline_locations(padding, spacing);
         let n = locs.len();
-        let mut count = 0i32;
+        let mut count = 0i64;
 
         for (iloc, &(row, col, weight)) in locs.iter().enumerate() {
             let ci = config
                 .get(row)
                 .and_then(|r| r.get(col))
                 .copied()
-                .unwrap_or(0);
+                .ok_or(mapping_invalid(
+                    "copy line lies outside the configuration grid",
+                ))?;
 
             // Check if this cell is doubled in the grid (two copylines overlap here)
             if doubled_cells.contains(&(row, col)) {
                 // Doubled cell - handle specially
                 if ci == 2 {
-                    count += 1;
+                    count = count
+                        .checked_add(1)
+                        .ok_or(mapping_integer_overflow("summing copy-back values"))?;
                 } else if ci == 1 {
                     // Check if both neighbors are 0
-                    let prev_zero = if iloc > 0 {
-                        let (pr, pc, _) = locs[iloc - 1];
-                        config.get(pr).and_then(|r| r.get(pc)).copied().unwrap_or(0) == 0
-                    } else {
-                        true
-                    };
-                    let next_zero = if iloc + 1 < n {
-                        let (nr, nc, _) = locs[iloc + 1];
-                        config.get(nr).and_then(|r| r.get(nc)).copied().unwrap_or(0) == 0
-                    } else {
-                        true
-                    };
+                    let prev_zero =
+                        if iloc > 0 {
+                            let (pr, pc, _) = locs[iloc - 1];
+                            config.get(pr).and_then(|r| r.get(pc)).copied().ok_or(
+                                mapping_invalid(
+                                    "copy-line neighbor lies outside the configuration grid",
+                                ),
+                            )? == 0
+                        } else {
+                            true
+                        };
+                    let next_zero =
+                        if iloc + 1 < n {
+                            let (nr, nc, _) = locs[iloc + 1];
+                            config.get(nr).and_then(|r| r.get(nc)).copied().ok_or(
+                                mapping_invalid(
+                                    "copy-line neighbor lies outside the configuration grid",
+                                ),
+                            )? == 0
+                        } else {
+                            true
+                        };
                     if prev_zero && next_zero {
-                        count += 1;
+                        count = count
+                            .checked_add(1)
+                            .ok_or(mapping_integer_overflow("summing copy-back values"))?;
                     }
                 }
                 // ci == 0: count += 0 (nothing)
             } else if weight >= 1 {
                 // Regular non-empty cell
-                count += ci as i32;
+                let value = i64::try_from(ci)
+                    .map_err(|_| mapping_integer_overflow("converting a copy-back value to i64"))?;
+                count = count
+                    .checked_add(value)
+                    .ok_or(mapping_integer_overflow("summing copy-back values"))?;
             }
             // weight == 0 or empty: skip
         }
 
         // Subtract overhead: MIS overhead for copyline is len/2
-        let overhead = (n / 2) as i32;
+        let overhead = i64::try_from(n / 2)
+            .map_err(|_| mapping_integer_overflow("converting copy-back overhead to i64"))?;
         // Result is count - overhead, clamped to non-negative
-        result[line.vertex] = (count - overhead).max(0) as usize;
+        let adjusted = count
+            .checked_sub(overhead)
+            .ok_or(mapping_integer_overflow("subtracting copy-back overhead"))?;
+        let adjusted = adjusted.max(0);
+        result[line.vertex] = usize::try_from(adjusted)
+            .map_err(|_| mapping_integer_overflow("converting a copy-back result to usize"))?;
     }
 
-    result
+    Ok(result)
 }
 
 /// Unapply gadgets from tape in reverse order, converting mapped configs to source configs.
-pub fn unapply_gadgets(tape: &[KsgTapeEntry], config: &mut [Vec<usize>]) {
+pub(crate) fn unapply_gadgets(
+    tape: &[KsgTapeEntry],
+    config: &mut [Vec<usize>],
+) -> Result<(), ReductionError> {
     // Iterate tape in REVERSE order
     for entry in tape.iter().rev() {
-        if let Some(pattern) = KsgPattern::from_tape_idx(entry.pattern_idx) {
-            pattern.map_config_back(entry.row, entry.col, config);
-        }
+        let pattern = KsgPattern::from_tape_idx(entry.pattern_idx).ok_or(mapping_invalid(
+            "tape contains an unknown unweighted KSG gadget index",
+        ))?;
+        pattern.map_config_back(entry.row, entry.col, config)?;
     }
+    Ok(())
 }
 
 /// Unapply weighted gadgets from tape in reverse order.
-pub fn unapply_weighted_gadgets(tape: &[WeightedKsgTapeEntry], config: &mut [Vec<usize>]) {
+pub(crate) fn unapply_weighted_gadgets(
+    tape: &[WeightedKsgTapeEntry],
+    config: &mut [Vec<usize>],
+) -> Result<(), ReductionError> {
     // Iterate tape in REVERSE order
     for entry in tape.iter().rev() {
-        if let Some(pattern) = WeightedKsgPattern::from_tape_idx(entry.pattern_idx) {
-            pattern.map_config_back(entry.row, entry.col, config);
-        }
+        let pattern = WeightedKsgPattern::from_tape_idx(entry.pattern_idx).ok_or(
+            mapping_invalid("tape contains an unknown weighted KSG gadget index"),
+        )?;
+        pattern.map_config_back(entry.row, entry.col, config)?;
     }
-}
-
-/// Trace center locations through KSG square lattice gadget transformations.
-///
-/// Returns traced center locations sorted by vertex index.
-pub fn trace_centers(result: &MappingResult<KsgTapeEntry>) -> Vec<(usize, usize)> {
-    // Initial center locations with (0, 1) offset
-    let mut centers: Vec<(usize, usize)> = result
-        .lines
-        .iter()
-        .map(|line| {
-            let (row, col) = line.center_location(result.padding, result.spacing);
-            (row, col + 1) // Add (0, 1) offset
-        })
-        .collect();
-
-    // Apply gadget transformations from tape
-    for entry in &result.tape {
-        let pattern_idx = entry.pattern_idx;
-        let gi = entry.row;
-        let gj = entry.col;
-
-        // Get gadget size and center mapping
-        // pattern_idx < 100: crossing gadgets (don't move centers)
-        // pattern_idx >= 100: simplifier gadgets (DanglingLeg with rotations)
-        if pattern_idx >= 100 {
-            // DanglingLeg variants
-            let simplifier_idx = pattern_idx - 100;
-            let (m, n, source_center, mapped_center) = match simplifier_idx {
-                0 => (4, 3, (2, 2), (4, 2)), // DanglingLeg (no rotation)
-                1 => (3, 4, (2, 2), (2, 4)), // Rotated 90 clockwise
-                2 => (4, 3, (3, 2), (1, 2)), // Rotated 180
-                3 => (3, 4, (2, 3), (2, 1)), // Rotated 270
-                4 => (4, 3, (2, 2), (4, 2)), // Reflected X (same as original for vertical)
-                5 => (4, 3, (2, 2), (4, 2)), // Reflected Y (same as original for vertical)
-                _ => continue,
-            };
-
-            // Check each center and apply transformation if within gadget bounds
-            for center in centers.iter_mut() {
-                let (ci, cj) = *center;
-
-                // Check if center is within gadget bounds (1-indexed)
-                if ci >= gi && ci < gi + m && cj >= gj && cj < gj + n {
-                    // Local coordinates (1-indexed)
-                    let local_i = ci - gi + 1;
-                    let local_j = cj - gj + 1;
-
-                    // Check if this matches the source center
-                    if local_i == source_center.0 && local_j == source_center.1 {
-                        // Move to mapped center
-                        *center = (gi + mapped_center.0 - 1, gj + mapped_center.1 - 1);
-                    }
-                }
-            }
-        }
-        // Crossing gadgets (pattern_idx < 100) don't move centers
-    }
-
-    // Sort by vertex index and return
-    let mut indexed: Vec<_> = result
-        .lines
-        .iter()
-        .enumerate()
-        .map(|(idx, line)| (line.vertex, centers[idx]))
-        .collect();
-    indexed.sort_by_key(|(v, _)| *v);
-    indexed.into_iter().map(|(_, c)| c).collect()
+    Ok(())
 }
 
 /// Internal function that creates both the mapping grid and copylines.
@@ -466,25 +458,37 @@ fn embed_graph_internal(
     num_vertices: usize,
     edges: &[(usize, usize)],
     vertex_order: &[usize],
-) -> Option<(MappingGrid, Vec<CopyLine>)> {
+) -> Result<(MappingGrid, Vec<CopyLine>), ReductionError> {
     if num_vertices == 0 {
-        return None;
+        return Err(mapping_invalid("num_vertices must be positive"));
     }
 
-    let copylines = create_copylines(num_vertices, edges, vertex_order);
+    let copylines = create_copylines(num_vertices, edges, vertex_order)?;
 
     // Calculate grid dimensions
     let max_hslot = copylines.iter().map(|l| l.hslot).max().unwrap_or(1);
 
-    let rows = max_hslot * SPACING + 2 + 2 * PADDING;
-    let cols = (num_vertices - 1) * SPACING + 2 + 2 * PADDING;
+    let padding_twice = PADDING
+        .checked_mul(2)
+        .ok_or(mapping_integer_overflow("computing grid padding"))?;
+    let extent = |slots: usize| {
+        slots
+            .checked_mul(SPACING)
+            .and_then(|value| value.checked_add(2))
+            .and_then(|value| value.checked_add(padding_twice))
+            .ok_or(mapping_integer_overflow("computing grid dimensions"))
+    };
+    let rows = extent(max_hslot)?;
+    let cols = extent(num_vertices - 1)?;
 
     let mut grid = MappingGrid::with_padding(rows, cols, SPACING, PADDING);
 
     // Add copy line nodes using dense locations (all cells along the L-shape)
     for line in &copylines {
         for (row, col, weight) in line.copyline_locations(PADDING, SPACING) {
-            grid.add_node(row, col, weight as i32);
+            let weight = i64::try_from(weight)
+                .map_err(|_| mapping_integer_overflow("converting a grid weight to i64"))?;
+            grid.add_node(row, col, weight);
         }
     }
 
@@ -511,19 +515,20 @@ fn embed_graph_internal(
         }
     }
 
-    Some((grid, copylines))
+    Ok((grid, copylines))
 }
 
 /// Embed a graph into a mapping grid.
 ///
-/// # Panics
+/// # Errors
 ///
-/// Panics if any edge vertex is not found in `vertex_order`.
-pub fn embed_graph(
+/// Returns [`ReductionError`] if the vertex order, graph, or generated dimensions are invalid.
+#[cfg(test)]
+pub(crate) fn embed_graph(
     num_vertices: usize,
     edges: &[(usize, usize)],
     vertex_order: &[usize],
-) -> Option<MappingGrid> {
+) -> Result<MappingGrid, ReductionError> {
     embed_graph_internal(num_vertices, edges, vertex_order).map(|(grid, _)| grid)
 }
 
@@ -537,7 +542,7 @@ pub fn embed_graph(
 pub fn map_unweighted(
     num_vertices: usize,
     edges: &[(usize, usize)],
-) -> MappingResult<KsgTapeEntry> {
+) -> Result<MappingResult<KsgTapeEntry>, ReductionError> {
     map_unweighted_with_method(num_vertices, edges, PathDecompositionMethod::Auto)
 }
 
@@ -551,7 +556,7 @@ pub fn map_unweighted_with_method(
     num_vertices: usize,
     edges: &[(usize, usize)],
     method: PathDecompositionMethod,
-) -> MappingResult<KsgTapeEntry> {
+) -> Result<MappingResult<KsgTapeEntry>, ReductionError> {
     let layout = pathwidth(num_vertices, edges, method);
     let vertex_order = vertex_order_from_layout(&layout);
     map_unweighted_with_order(num_vertices, edges, &vertex_order)
@@ -559,16 +564,15 @@ pub fn map_unweighted_with_method(
 
 /// Map a graph with a specific vertex ordering (unweighted).
 ///
-/// # Panics
+/// # Errors
 ///
-/// Panics if `num_vertices == 0`.
+/// Returns [`ReductionError`] if the vertex order, graph, or generated dimensions are invalid.
 pub fn map_unweighted_with_order(
     num_vertices: usize,
     edges: &[(usize, usize)],
     vertex_order: &[usize],
-) -> MappingResult<KsgTapeEntry> {
-    let (mut grid, copylines) = embed_graph_internal(num_vertices, edges, vertex_order)
-        .expect("Failed to embed graph: num_vertices must be > 0");
+) -> Result<MappingResult<KsgTapeEntry>, ReductionError> {
+    let (mut grid, copylines) = embed_graph_internal(num_vertices, edges, vertex_order)?;
 
     // Extract doubled cells BEFORE applying gadgets
     let doubled_cells = grid.doubled_cells();
@@ -584,37 +588,52 @@ pub fn map_unweighted_with_order(
     tape.extend(simplifier_tape);
 
     // Calculate MIS overhead from copylines
-    let copyline_overhead: i32 = copylines
-        .iter()
-        .map(|line| mis_overhead_copyline(line, SPACING, PADDING) as i32)
-        .sum();
+    let copyline_overhead = copylines.iter().try_fold(0_i64, |total, line| {
+        total
+            .checked_add(mis_overhead_copyline(line, SPACING, PADDING)?)
+            .ok_or(mapping_integer_overflow("summing copy-line MIS overhead"))
+    })?;
 
     // Add MIS overhead from gadgets
-    let gadget_overhead: i32 = tape.iter().map(tape_entry_mis_overhead).sum();
-    let mis_overhead = copyline_overhead + gadget_overhead;
-
-    // Assert all doubled/connected cells have been resolved by gadgets.
-    // Matches Julia's `GridGraph()` check: "This mapping is not done yet!"
-    debug_assert!(
-        !grid.has_unresolved_cells(),
-        "Mapping is not done: doubled or connected cells remain after gadget application"
-    );
+    let gadget_overhead = tape.iter().try_fold(0_i64, |total, entry| {
+        total
+            .checked_add(tape_entry_mis_overhead(entry)?)
+            .ok_or(mapping_integer_overflow("summing gadget MIS overhead"))
+    })?;
+    let mis_overhead = copyline_overhead
+        .checked_add(gadget_overhead)
+        .ok_or(mapping_integer_overflow("computing total MIS overhead"))?;
+
+    if grid.has_unresolved_cells() {
+        return Err(mapping_invalid(
+            "mapping left doubled or connected cells unresolved",
+        ));
+    }
 
     // Extract positions from occupied cells.
     // In unweighted mode, all node weights are 1 — matching Julia's behavior where
     // `node(::Type{<:UnWeightedNode}, i, j, w) = Node(i, j)` ignores the weight parameter.
-    let positions: Vec<(i32, i32)> = grid
+    let positions: Vec<(i64, i64)> = grid
         .occupied_coords()
         .into_iter()
         .filter_map(|(row, col)| {
             grid.get(row, col)
                 .filter(|cell| cell.weight() > 0)
-                .map(|_| (row as i32, col as i32))
+                .map(|_| {
+                    Ok((
+                        i64::try_from(row).map_err(|_| {
+                            mapping_integer_overflow("converting a grid row to i64")
+                        })?,
+                        i64::try_from(col).map_err(|_| {
+                            mapping_integer_overflow("converting a grid column to i64")
+                        })?,
+                    ))
+                })
         })
-        .collect();
-    let node_weights = vec![1i32; positions.len()];
+        .collect::<Result<_, ReductionError>>()?;
+    let node_weights = vec![1i64; positions.len()];
 
-    MappingResult {
+    Ok(MappingResult {
         positions,
         node_weights,
         grid_dimensions: grid.size(),
@@ -625,7 +644,7 @@ pub fn map_unweighted_with_order(
         mis_overhead,
         tape,
         doubled_cells,
-    }
+    })
 }
 
 // ============================================================================
@@ -639,7 +658,7 @@ pub fn map_unweighted_with_order(
 pub fn map_weighted(
     num_vertices: usize,
     edges: &[(usize, usize)],
-) -> MappingResult<WeightedKsgTapeEntry> {
+) -> Result<MappingResult<WeightedKsgTapeEntry>, ReductionError> {
     map_weighted_with_method(num_vertices, edges, PathDecompositionMethod::Auto)
 }
 
@@ -653,7 +672,7 @@ pub fn map_weighted_with_method(
     num_vertices: usize,
     edges: &[(usize, usize)],
     method: PathDecompositionMethod,
-) -> MappingResult<WeightedKsgTapeEntry> {
+) -> Result<MappingResult<WeightedKsgTapeEntry>, ReductionError> {
     let layout = pathwidth(num_vertices, edges, method);
     let vertex_order = vertex_order_from_layout(&layout);
     map_weighted_with_order(num_vertices, edges, &vertex_order)
@@ -661,16 +680,15 @@ pub fn map_weighted_with_method(
 
 /// Map a graph with a specific vertex ordering (weighted).
 ///
-/// # Panics
+/// # Errors
 ///
-/// Panics if `num_vertices == 0`.
+/// Returns [`ReductionError`] if the vertex order, graph, or generated dimensions are invalid.
 pub fn map_weighted_with_order(
     num_vertices: usize,
     edges: &[(usize, usize)],
     vertex_order: &[usize],
-) -> MappingResult<WeightedKsgTapeEntry> {
-    let (mut grid, copylines) = embed_graph_internal(num_vertices, edges, vertex_order)
-        .expect("Failed to embed graph: num_vertices must be > 0");
+) -> Result<MappingResult<WeightedKsgTapeEntry>, ReductionError> {
+    let (mut grid, copylines) = embed_graph_internal(num_vertices, edges, vertex_order)?;
 
     // Extract doubled cells BEFORE applying gadgets
     let doubled_cells = grid.doubled_cells();
@@ -686,33 +704,62 @@ pub fn map_weighted_with_order(
     tape.extend(simplifier_tape);
 
     // Calculate MIS overhead from copylines (weighted: multiply by 2)
-    let copyline_overhead: i32 = copylines
-        .iter()
-        .map(|line| mis_overhead_copyline(line, SPACING, PADDING) as i32 * 2)
-        .sum();
+    let copyline_overhead = copylines.iter().try_fold(0_i64, |total, line| {
+        let overhead = mis_overhead_copyline(line, SPACING, PADDING)?;
+        let overhead = overhead.checked_mul(2).ok_or(mapping_integer_overflow(
+            "doubling weighted copy-line MIS overhead",
+        ))?;
+        total.checked_add(overhead).ok_or(mapping_integer_overflow(
+            "summing weighted copy-line MIS overhead",
+        ))
+    })?;
 
     // Add MIS overhead from weighted gadgets
-    let gadget_overhead: i32 = tape.iter().map(weighted_tape_entry_mis_overhead).sum();
-    let mis_overhead = copyline_overhead + gadget_overhead;
-
-    // Assert all doubled/connected cells have been resolved by gadgets.
-    debug_assert!(
-        !grid.has_unresolved_cells(),
-        "Mapping is not done: doubled or connected cells remain after gadget application"
-    );
+    let gadget_overhead = tape.iter().try_fold(0_i64, |total, entry| {
+        total
+            .checked_add(weighted_tape_entry_mis_overhead(entry)?)
+            .ok_or(mapping_integer_overflow(
+                "summing weighted gadget MIS overhead",
+            ))
+    })?;
+    let mis_overhead =
+        copyline_overhead
+            .checked_add(gadget_overhead)
+            .ok_or(mapping_integer_overflow(
+                "computing total weighted MIS overhead",
+            ))?;
+
+    if grid.has_unresolved_cells() {
+        return Err(mapping_invalid(
+            "weighted mapping left doubled or connected cells unresolved",
+        ));
+    }
 
     // Extract positions and weights from occupied cells
-    let (positions, node_weights): (Vec<(i32, i32)>, Vec<i32>) = grid
+    let positions_and_weights = grid
         .occupied_coords()
         .into_iter()
         .filter_map(|(row, col)| {
             grid.get(row, col)
-                .map(|cell| ((row as i32, col as i32), cell.weight()))
+                .filter(|cell| cell.weight() > 0)
+                .map(|cell| {
+                    Ok((
+                        (
+                            i64::try_from(row).map_err(|_| {
+                                mapping_integer_overflow("converting a grid row to i64")
+                            })?,
+                            i64::try_from(col).map_err(|_| {
+                                mapping_integer_overflow("converting a grid column to i64")
+                            })?,
+                        ),
+                        cell.weight(),
+                    ))
+                })
         })
-        .filter(|&(_, w)| w > 0)
-        .unzip();
+        .collect::<Result<Vec<_>, ReductionError>>()?;
+    let (positions, node_weights): (Vec<_>, Vec<_>) = positions_and_weights.into_iter().unzip();
 
-    MappingResult {
+    Ok(MappingResult {
         positions,
         node_weights,
         grid_dimensions: grid.size(),
@@ -723,7 +770,7 @@ pub fn map_weighted_with_order(
         mis_overhead,
         tape,
         doubled_cells,
-    }
+    })
 }
 
 #[cfg(test)]
diff --git a/src/rules/unitdiskmapping/ksg/mod.rs b/src/rules/unitdiskmapping/ksg/mod.rs
index 85206453b..c4f1a35d0 100644
--- a/src/rules/unitdiskmapping/ksg/mod.rs
+++ b/src/rules/unitdiskmapping/ksg/mod.rs
@@ -11,10 +11,10 @@
 //! let edges = vec![(0, 1), (1, 2), (0, 2)];
 //!
 //! // Unweighted mapping
-//! let result = ksg::map_unweighted(3, &edges);
+//! let result = ksg::map_unweighted(3, &edges).unwrap();
 //!
 //! // Weighted mapping
-//! let weighted_result = ksg::map_weighted(3, &edges);
+//! let weighted_result = ksg::map_weighted(3, &edges).unwrap();
 //! ```
 
 pub mod gadgets;
@@ -38,9 +38,8 @@ pub use gadgets_weighted::{
 };
 
 pub use mapping::{
-    embed_graph, map_config_copyback, map_unweighted, map_unweighted_with_method,
-    map_unweighted_with_order, map_weighted, map_weighted_with_method, map_weighted_with_order,
-    trace_centers, unapply_gadgets, unapply_weighted_gadgets, GridKind, MappingResult,
+    map_unweighted, map_unweighted_with_method, map_unweighted_with_order, map_weighted,
+    map_weighted_with_method, map_weighted_with_order, GridKind, MappingResult,
 };
 
 /// Spacing between copy lines for KSG mapping.
diff --git a/src/rules/unitdiskmapping/mod.rs b/src/rules/unitdiskmapping/mod.rs
index d44f651c3..913925797 100644
--- a/src/rules/unitdiskmapping/mod.rs
+++ b/src/rules/unitdiskmapping/mod.rs
@@ -16,17 +16,15 @@
 //! let edges = vec![(0, 1), (1, 2), (0, 2)];
 //!
 //! // Map to King's Subgraph (unweighted)
-//! let result = ksg::map_unweighted(3, &edges);
+//! let result = ksg::map_unweighted(3, &edges).unwrap();
 //!
 //! // Map to King's Subgraph (weighted)
-//! let weighted_result = ksg::map_weighted(3, &edges);
+//! let weighted_result = ksg::map_weighted(3, &edges).unwrap();
 //!
 //! // Map to triangular lattice (weighted)
-//! let tri_result = triangular::map_weighted(3, &edges);
+//! let tri_result = triangular::map_weighted(3, &edges).unwrap();
 //! ```
 
-#[allow(dead_code)]
-pub(crate) mod alpha_tensor;
 mod copyline;
 mod grid;
 pub mod ksg;
@@ -38,6 +36,32 @@ mod weighted;
 // Re-export commonly used items from submodules for convenience
 pub use ksg::{GridKind, MappingResult};
 
+use crate::rules::ReductionError;
+
+fn mapping_invalid(message: impl Into<String>) -> ReductionError {
+    ReductionError::InvalidTarget {
+        source_problem: "Graph",
+        target_problem: "UnitDiskMapping",
+        message: message.into(),
+    }
+}
+
+fn mapping_integer_overflow(operation: impl Into<String>) -> ReductionError {
+    ReductionError::IntegerOverflow {
+        source_problem: "Graph",
+        target_problem: "UnitDiskMapping",
+        operation: operation.into(),
+    }
+}
+
+fn mapping_non_finite(operation: impl Into<String>) -> ReductionError {
+    ReductionError::NonFiniteResult {
+        source_problem: "Graph",
+        target_problem: "UnitDiskMapping",
+        operation: operation.into(),
+    }
+}
+
 // Re-exports for unit tests (only needed in test builds)
 #[cfg(test)]
 pub(crate) use copyline::{
diff --git a/src/rules/unitdiskmapping/traits.rs b/src/rules/unitdiskmapping/traits.rs
index 9bfba019c..e183d0798 100644
--- a/src/rules/unitdiskmapping/traits.rs
+++ b/src/rules/unitdiskmapping/traits.rs
@@ -48,18 +48,18 @@ pub trait Pattern: Clone + std::fmt::Debug {
     fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>);
 
     /// MIS overhead when applying this gadget.
-    fn mis_overhead(&self) -> i32;
+    fn mis_overhead(&self) -> i64;
 
     /// Weights for each node in source graph (for weighted mode).
     /// Default: all nodes have weight 2 (Julia's default for weighted gadgets).
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         let (locs, _, _) = self.source_graph();
         vec![2; locs.len()]
     }
 
     /// Weights for each node in mapped graph (for weighted mode).
     /// Default: all nodes have weight 2 (Julia's default for weighted gadgets).
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         let (locs, _) = self.mapped_graph();
         vec![2; locs.len()]
     }
diff --git a/src/rules/unitdiskmapping/triangular/gadgets.rs b/src/rules/unitdiskmapping/triangular/gadgets.rs
index 456a8cb7d..f5af487f1 100644
--- a/src/rules/unitdiskmapping/triangular/gadgets.rs
+++ b/src/rules/unitdiskmapping/triangular/gadgets.rs
@@ -4,6 +4,8 @@
 //! All gadgets use weighted mode (weight 2 for standard nodes).
 
 use super::super::grid::{CellState, MappingGrid};
+use crate::rules::unitdiskmapping::mapping_invalid;
+use crate::rules::ReductionError;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 
@@ -40,7 +42,7 @@ pub trait WeightedTriangularGadget {
     fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>);
     /// Returns (locations, pins) - use unit disk for edges on triangular lattice.
     fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>);
-    fn mis_overhead(&self) -> i32;
+    fn mis_overhead(&self) -> i64;
 
     /// Returns 1-indexed node indices that should be Connected (matching Julia).
     fn connected_nodes(&self) -> Vec<usize> {
@@ -48,13 +50,13 @@ pub trait WeightedTriangularGadget {
     }
 
     /// Returns source node weights. Default is weight 2 for all nodes.
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         let (locs, _, _) = self.source_graph();
         vec![2; locs.len()]
     }
 
     /// Returns mapped node weights. Default is weight 2 for all nodes.
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         let (locs, _) = self.mapped_graph();
         vec![2; locs.len()]
     }
@@ -174,7 +176,7 @@ impl WeightedTriangularGadget for WeightedTriCross<true> {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         1
     }
 
@@ -183,12 +185,12 @@ impl WeightedTriangularGadget for WeightedTriCross<true> {
         vec![1, 5]
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         // Julia: sw = [2,2,2,2,2,2,2,2,2,2]
         vec![2; 10]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         // Julia: mw = [3,2,3,3,2,2,2,2,2,2,2]
         vec![3, 2, 3, 3, 2, 2, 2, 2, 2, 2, 2]
     }
@@ -268,15 +270,15 @@ impl WeightedTriangularGadget for WeightedTriCross<false> {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         3
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2; 12]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![3, 3, 2, 4, 2, 2, 2, 4, 3, 2, 2, 2, 2, 2, 2, 2]
     }
 }
@@ -322,15 +324,15 @@ impl WeightedTriangularGadget for WeightedTriTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2; 4]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2; 4]
     }
 }
@@ -407,16 +409,16 @@ impl WeightedTriangularGadget for WeightedTriBranch {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         // Julia: sw = [2,2,3,2,2,2,2,2,2]
         vec![2, 2, 3, 2, 2, 2, 2, 2, 2]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         // Julia: mw = [2,2,2,3,2,2,2,2,2]
         vec![2, 2, 2, 3, 2, 2, 2, 2, 2]
     }
@@ -478,7 +480,7 @@ impl WeightedTriangularGadget for WeightedTriTConLeft {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         4
     }
 
@@ -487,12 +489,12 @@ impl WeightedTriangularGadget for WeightedTriTConLeft {
         vec![1, 2]
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         // Julia: sw = [2,1,2,2,2,2,2]
         vec![2, 1, 2, 2, 2, 2, 2]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         // Julia: mw = [3,2,3,3,1,3,2,2,2,2,2]
         vec![3, 2, 3, 3, 1, 3, 2, 2, 2, 2, 2]
     }
@@ -534,7 +536,7 @@ impl WeightedTriangularGadget for WeightedTriTConDown {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0
     }
 
@@ -543,11 +545,11 @@ impl WeightedTriangularGadget for WeightedTriTConDown {
         vec![1, 4]
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2, 2, 2, 1]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2, 2, 3, 2]
     }
 }
@@ -588,7 +590,7 @@ impl WeightedTriangularGadget for WeightedTriTConUp {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0
     }
 
@@ -597,11 +599,11 @@ impl WeightedTriangularGadget for WeightedTriTConUp {
         vec![1, 2]
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![1, 2, 2, 2]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![3, 2, 2, 2]
     }
 }
@@ -638,7 +640,7 @@ impl WeightedTriangularGadget for WeightedTriTrivialTurnLeft {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0
     }
 
@@ -647,11 +649,11 @@ impl WeightedTriangularGadget for WeightedTriTrivialTurnLeft {
         vec![1, 2]
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![1, 1]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1, 1]
     }
 }
@@ -688,7 +690,7 @@ impl WeightedTriangularGadget for WeightedTriTrivialTurnRight {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0
     }
 
@@ -697,11 +699,11 @@ impl WeightedTriangularGadget for WeightedTriTrivialTurnRight {
         vec![1, 2]
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![1, 1]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1, 1]
     }
 }
@@ -748,15 +750,15 @@ impl WeightedTriangularGadget for WeightedTriEndTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2, 2, 1]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![1]
     }
 }
@@ -803,15 +805,15 @@ impl WeightedTriangularGadget for WeightedTriWTurn {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         0
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2; 5]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2; 5]
     }
 }
@@ -852,15 +854,15 @@ impl WeightedTriangularGadget for WeightedTriBranchFix {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2; 6]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2; 4]
     }
 }
@@ -901,15 +903,15 @@ impl WeightedTriangularGadget for WeightedTriBranchFixB {
         (locs, pins)
     }
 
-    fn mis_overhead(&self) -> i32 {
+    fn mis_overhead(&self) -> i64 {
         -2
     }
 
-    fn source_weights(&self) -> Vec<i32> {
+    fn source_weights(&self) -> Vec<i64> {
         vec![2; 4]
     }
 
-    fn mapped_weights(&self) -> Vec<i32> {
+    fn mapped_weights(&self) -> Vec<i64> {
         vec![2; 2]
     }
 }
@@ -1016,7 +1018,7 @@ fn apply_gadget<G: WeightedTriangularGadget>(
     let weights = gadget.mapped_weights();
     for (idx, (r, c)) in locs.iter().enumerate() {
         if *r > 0 && *c > 0 && *r <= m && *c <= n {
-            let weight = weights.get(idx).copied().unwrap_or(2);
+            let weight = weights[idx];
             // Convert 1-indexed pattern pos to 0-indexed grid pos
             grid.add_node(i + r - 1, j + c - 1, weight);
         }
@@ -1214,7 +1216,7 @@ fn try_apply_dangling_leg_down(grid: &mut MappingGrid, i: usize, j: usize) -> bo
     let is_empty = |row: usize, col: usize| -> bool { !grid.is_occupied(row, col) };
 
     // Helper to check if cell has specific weight
-    let has_weight = |row: usize, col: usize, w: i32| -> bool {
+    let has_weight = |row: usize, col: usize, w: i64| -> bool {
         grid.get(row, col).is_some_and(|c| c.weight() == w)
     };
 
@@ -1264,7 +1266,7 @@ fn try_apply_dangling_leg_up(grid: &mut MappingGrid, i: usize, j: usize) -> bool
 
     let is_empty = |row: usize, col: usize| -> bool { !grid.is_occupied(row, col) };
 
-    let has_weight = |row: usize, col: usize, w: i32| -> bool {
+    let has_weight = |row: usize, col: usize, w: i64| -> bool {
         grid.get(row, col).is_some_and(|c| c.weight() == w)
     };
 
@@ -1313,7 +1315,7 @@ fn try_apply_dangling_leg_right(grid: &mut MappingGrid, i: usize, j: usize) -> b
 
     let is_empty = |row: usize, col: usize| -> bool { !grid.is_occupied(row, col) };
 
-    let has_weight = |row: usize, col: usize, w: i32| -> bool {
+    let has_weight = |row: usize, col: usize, w: i64| -> bool {
         grid.get(row, col).is_some_and(|c| c.weight() == w)
     };
 
@@ -1365,7 +1367,7 @@ fn try_apply_dangling_leg_left(grid: &mut MappingGrid, i: usize, j: usize) -> bo
 
     let is_empty = |row: usize, col: usize| -> bool { !grid.is_occupied(row, col) };
 
-    let has_weight = |row: usize, col: usize, w: i32| -> bool {
+    let has_weight = |row: usize, col: usize, w: i64| -> bool {
         grid.get(row, col).is_some_and(|c| c.weight() == w)
     };
 
@@ -1404,8 +1406,8 @@ fn try_apply_dangling_leg_left(grid: &mut MappingGrid, i: usize, j: usize) -> bo
 /// For triangular mode, crossing gadgets use their native overhead,
 /// but simplifiers (DanglingLeg) use weighted overhead = unweighted * 2.
 /// Julia: mis_overhead(w::WeightedGadget) = mis_overhead(w.gadget) * 2
-pub fn tape_entry_mis_overhead(entry: &WeightedTriTapeEntry) -> i32 {
-    match entry.gadget_idx {
+pub fn tape_entry_mis_overhead(entry: &WeightedTriTapeEntry) -> Result<i64, ReductionError> {
+    Ok(match entry.gadget_idx {
         0 => WeightedTriCross::<false>.mis_overhead(),
         1 => WeightedTriCross::<true>.mis_overhead(),
         2 => WeightedTriTConLeft.mis_overhead(),
@@ -1420,7 +1422,47 @@ pub fn tape_entry_mis_overhead(entry: &WeightedTriTapeEntry) -> i32 {
         11 => WeightedTriBranchFixB.mis_overhead(),
         12 => WeightedTriBranch.mis_overhead(),
         // Simplifier gadgets (100+): weighted overhead = -1 * 2 = -2
-        idx if idx >= 100 => -2,
-        _ => 0,
+        100..=103 => -2,
+        _ => {
+            return Err(mapping_invalid(
+                "tape contains an unknown weighted triangular gadget index",
+            ))
+        }
+    })
+}
+
+pub(crate) fn tape_entry_size(gadget_idx: usize) -> Option<(usize, usize)> {
+    match gadget_idx {
+        0 => Some(WeightedTriCross::<false>.size()),
+        1 => Some(WeightedTriCross::<true>.size()),
+        2 => Some(WeightedTriTConLeft.size()),
+        3 => Some(WeightedTriTConUp.size()),
+        4 => Some(WeightedTriTConDown.size()),
+        5 => Some(WeightedTriTrivialTurnLeft.size()),
+        6 => Some(WeightedTriTrivialTurnRight.size()),
+        7 => Some(WeightedTriEndTurn.size()),
+        8 => Some(WeightedTriTurn.size()),
+        9 => Some(WeightedTriWTurn.size()),
+        10 => Some(WeightedTriBranchFix.size()),
+        11 => Some(WeightedTriBranchFixB.size()),
+        12 => Some(WeightedTriBranch.size()),
+        100 | 101 => Some((4, 3)),
+        102 | 103 => Some((3, 4)),
+        _ => None,
+    }
+}
+
+pub(crate) fn tape_entry_center_transform(
+    gadget_idx: usize,
+) -> Option<((usize, usize), (isize, isize))> {
+    match gadget_idx {
+        7 | 8 | 12 => Some(((2, 3), (-1, -1))),
+        9 => Some(((2, 3), (0, 0))),
+        10 | 11 => Some(((2, 3), (1, -1))),
+        100 => Some(((2, 2), (2, 0))),
+        101 => Some(((3, 2), (-2, 0))),
+        102 => Some(((2, 3), (0, -2))),
+        103 => Some(((2, 2), (0, 2))),
+        _ => None,
     }
 }
diff --git a/src/rules/unitdiskmapping/triangular/mapping.rs b/src/rules/unitdiskmapping/triangular/mapping.rs
index 89217f9cd..7fa8ebe29 100644
--- a/src/rules/unitdiskmapping/triangular/mapping.rs
+++ b/src/rules/unitdiskmapping/triangular/mapping.rs
@@ -12,6 +12,26 @@ use super::super::pathdecomposition::{
 };
 use super::gadgets::{apply_crossing_gadgets, apply_simplifier_gadgets, tape_entry_mis_overhead};
 use crate::rules::unitdiskmapping::ksg::mapping::GridKind;
+use crate::rules::unitdiskmapping::{mapping_integer_overflow, mapping_invalid};
+use crate::rules::ReductionError;
+use std::collections::HashMap;
+
+fn position_index(
+    result: &MappingResult,
+) -> Result<HashMap<(usize, usize), usize>, ReductionError> {
+    result
+        .positions
+        .iter()
+        .enumerate()
+        .map(|(index, &(row, column))| {
+            let row = usize::try_from(row)
+                .map_err(|_| mapping_invalid("mapping result contains a negative grid row"))?;
+            let column = usize::try_from(column)
+                .map_err(|_| mapping_invalid("mapping result contains a negative grid column"))?;
+            Ok(((row, column), index))
+        })
+        .collect()
+}
 
 /// Spacing between copy lines on triangular lattice.
 pub const SPACING: usize = 6;
@@ -59,8 +79,8 @@ fn crossat(
 /// # Returns
 /// A `MappingResult` containing the grid graph and mapping metadata.
 ///
-/// # Panics
-/// Panics if `num_vertices == 0`.
+/// # Errors
+/// Returns [`ReductionError`] if the input graph or generated dimensions are invalid.
 ///
 /// # Example
 /// ```rust
@@ -68,10 +88,13 @@ fn crossat(
 /// use problemreductions::topology::Graph;
 ///
 /// let edges = vec![(0, 1), (1, 2)];
-/// let result = map_weighted(3, &edges);
+/// let result = map_weighted(3, &edges).unwrap();
 /// assert!(result.to_triangular_subgraph().num_vertices() > 0);
 /// ```
-pub fn map_weighted(num_vertices: usize, edges: &[(usize, usize)]) -> MappingResult {
+pub fn map_weighted(
+    num_vertices: usize,
+    edges: &[(usize, usize)],
+) -> Result<MappingResult, ReductionError> {
     map_weighted_with_method(num_vertices, edges, PathDecompositionMethod::Auto)
 }
 
@@ -88,7 +111,7 @@ pub fn map_weighted_with_method(
     num_vertices: usize,
     edges: &[(usize, usize)],
     method: PathDecompositionMethod,
-) -> MappingResult {
+) -> Result<MappingResult, ReductionError> {
     let layout = pathwidth(num_vertices, edges, method);
     let vertex_order = vertex_order_from_layout(&layout);
     map_weighted_with_order(num_vertices, edges, &vertex_order)
@@ -107,19 +130,21 @@ pub fn map_weighted_with_method(
 /// # Returns
 /// A `MappingResult` containing the grid graph and mapping metadata.
 ///
-/// # Panics
-/// Panics if `num_vertices == 0` or if any edge vertex is not in `vertex_order`.
+/// # Errors
+/// Returns [`ReductionError`] if the vertex order, graph, or generated dimensions are invalid.
 pub fn map_weighted_with_order(
     num_vertices: usize,
     edges: &[(usize, usize)],
     vertex_order: &[usize],
-) -> MappingResult {
-    assert!(num_vertices > 0, "num_vertices must be > 0");
+) -> Result<MappingResult, ReductionError> {
+    if num_vertices == 0 {
+        return Err(mapping_invalid("num_vertices must be positive"));
+    }
 
     let spacing = SPACING;
     let padding = PADDING;
 
-    let copylines = create_copylines(num_vertices, edges, vertex_order);
+    let copylines = create_copylines(num_vertices, edges, vertex_order)?;
 
     // Calculate grid dimensions
     // Julia formula: N = (n-1)*col_spacing + 2 + 2*padding
@@ -128,9 +153,21 @@ pub fn map_weighted_with_order(
     let max_hslot = copylines.iter().map(|l| l.hslot).max().unwrap_or(1);
     let max_vstop = copylines.iter().map(|l| l.vstop).max().unwrap_or(1);
 
-    let rows = max_hslot.max(max_vstop) * spacing + 2 + 2 * padding;
+    let padding_twice = padding.checked_mul(2).ok_or(mapping_integer_overflow(
+        "computing triangular grid padding",
+    ))?;
+    let extent = |slots: usize| {
+        slots
+            .checked_mul(spacing)
+            .and_then(|value| value.checked_add(2))
+            .and_then(|value| value.checked_add(padding_twice))
+            .ok_or(mapping_integer_overflow(
+                "computing triangular grid dimensions",
+            ))
+    };
+    let rows = extent(max_hslot.max(max_vstop))?;
     // Use (num_vertices - 1) for cols, matching Julia's (n-1) formula
-    let cols = (num_vertices - 1) * spacing + 2 + 2 * padding;
+    let cols = extent(num_vertices - 1)?;
 
     let mut grid = MappingGrid::with_padding(rows, cols, spacing, padding);
 
@@ -138,7 +175,10 @@ pub fn map_weighted_with_order(
     // (includes the endpoint node for triangular weighted mode)
     for line in &copylines {
         for (row, col, weight) in line.copyline_locations_triangular(padding, spacing) {
-            grid.add_node(row, col, weight as i32);
+            let weight = i64::try_from(weight).map_err(|_| {
+                mapping_integer_overflow("converting a triangular grid weight to i64")
+            })?;
+            grid.add_node(row, col, weight);
         }
     }
 
@@ -183,14 +223,36 @@ pub fn map_weighted_with_order(
 
     // Calculate MIS overhead from copylines using the dedicated function
     // which matches Julia's mis_overhead_copyline(TriangularWeighted(), ...)
-    let copyline_overhead: i32 = copylines
-        .iter()
-        .map(|line| super::super::copyline::mis_overhead_copyline_triangular(line, spacing))
-        .sum();
+    let copyline_overhead = copylines.iter().try_fold(0_i64, |total, line| {
+        total
+            .checked_add(super::super::copyline::mis_overhead_copyline_triangular(
+                line, spacing,
+            )?)
+            .ok_or(mapping_integer_overflow(
+                "summing triangular copy-line MIS overhead",
+            ))
+    })?;
 
     // Add gadget overhead (crossing gadgets + simplifiers)
-    let gadget_overhead: i32 = triangular_tape.iter().map(tape_entry_mis_overhead).sum();
-    let mis_overhead = copyline_overhead + gadget_overhead;
+    let gadget_overhead = triangular_tape.iter().try_fold(0_i64, |total, entry| {
+        total
+            .checked_add(tape_entry_mis_overhead(entry)?)
+            .ok_or(mapping_integer_overflow(
+                "summing triangular gadget MIS overhead",
+            ))
+    })?;
+    let mis_overhead =
+        copyline_overhead
+            .checked_add(gadget_overhead)
+            .ok_or(mapping_integer_overflow(
+                "computing total triangular MIS overhead",
+            ))?;
+
+    if grid.has_unresolved_cells() {
+        return Err(mapping_invalid(
+            "triangular mapping left doubled or connected cells unresolved",
+        ));
+    }
 
     // Convert triangular tape entries to generic tape entries
     let tape: Vec<TapeEntry> = triangular_tape
@@ -206,17 +268,30 @@ pub fn map_weighted_with_order(
     let doubled_cells = grid.doubled_cells();
 
     // Extract positions and weights from occupied cells
-    let (positions, node_weights): (Vec<(i32, i32)>, Vec<i32>) = grid
+    let positions_and_weights = grid
         .occupied_coords()
         .into_iter()
         .filter_map(|(row, col)| {
             grid.get(row, col)
-                .map(|cell| ((row as i32, col as i32), cell.weight()))
+                .filter(|cell| cell.weight() > 0)
+                .map(|cell| {
+                    Ok((
+                        (
+                            i64::try_from(row).map_err(|_| {
+                                mapping_integer_overflow("converting a grid row to i64")
+                            })?,
+                            i64::try_from(col).map_err(|_| {
+                                mapping_integer_overflow("converting a grid column to i64")
+                            })?,
+                        ),
+                        cell.weight(),
+                    ))
+                })
         })
-        .filter(|&(_, w)| w > 0)
-        .unzip();
+        .collect::<Result<Vec<_>, ReductionError>>()?;
+    let (positions, node_weights): (Vec<_>, Vec<_>) = positions_and_weights.into_iter().unzip();
 
-    MappingResult {
+    Ok(MappingResult {
         positions,
         node_weights,
         grid_dimensions: grid.size(),
@@ -227,55 +302,75 @@ pub fn map_weighted_with_order(
         mis_overhead,
         tape,
         doubled_cells,
-    }
+    })
 }
 
-/// Get the weighted triangular crossing ruleset.
-///
-/// This returns the list of weighted triangular gadgets used for resolving
-/// crossings in the mapping process. Matches Julia's `crossing_ruleset_triangular_weighted`.
-///
-/// # Returns
-/// A vector of `WeightedTriangularGadget` enum variants.
-pub fn weighted_ruleset() -> Vec<super::super::weighted::WeightedTriangularGadget> {
-    super::super::weighted::triangular_weighted_ruleset()
+/// Read the original vertex configuration at the traced triangular centers.
+pub fn map_config_back(
+    result: &MappingResult,
+    grid_config: &[usize],
+) -> crate::rules::ExtractionResult<Vec<usize>> {
+    map_config_back_internal(result, grid_config)
+        .map_err(|error| crate::rules::ExtractionError::invalid(error.to_string()))
 }
 
-/// Trace center locations through gadget transformations.
-///
-/// Returns the final center location for each original vertex after all
-/// gadget transformations have been applied.
-///
-/// This matches Julia's `trace_centers` function which:
-/// 1. Gets initial center locations with (0, 1) offset
-/// 2. Applies `move_center` for each gadget in the tape
-///
-/// # Arguments
-/// * `result` - The mapping result from `map_weighted`
-///
-/// # Returns
-/// A vector of (row, col) positions for each original vertex.
-pub fn trace_centers(result: &MappingResult) -> Vec<(usize, usize)> {
-    super::super::weighted::trace_centers(result)
+fn map_config_back_internal(
+    result: &MappingResult,
+    grid_config: &[usize],
+) -> Result<Vec<usize>, ReductionError> {
+    if grid_config.len() != result.positions.len() {
+        return Err(mapping_invalid(
+            "grid configuration length must match the mapped vertex count",
+        ));
+    }
+    let positions = position_index(result)?;
+
+    super::super::weighted::trace_centers(result)?
+        .into_iter()
+        .map(|center| {
+            positions
+                .get(&center)
+                .map(|&index| grid_config[index])
+                .ok_or(mapping_invalid(
+                    "a traced center is missing from the mapped graph",
+                ))
+        })
+        .collect()
 }
 
-/// Map source vertex weights to grid graph weights.
-///
-/// This function takes weights for each original vertex and maps them to
-/// the corresponding nodes in the grid graph.
+/// Encode unit source weights exactly in the integer target weights.
 ///
-/// # Arguments
-/// * `result` - The mapping result from `map_weighted`
-/// * `source_weights` - Weights for each original vertex (should be in [0, 1])
-///
-/// # Returns
-/// A vector of weights for each node in the grid graph.
-///
-/// # Panics
-/// Panics if any weight is outside the range [0, 1] or if the number of
-/// weights doesn't match the number of vertices.
-pub fn map_weights(result: &MappingResult, source_weights: &[f64]) -> Vec<f64> {
-    super::super::weighted::map_weights(result, source_weights)
+/// Multiplying the base gadget weights by `n + 1` preserves the mapping's
+/// primary objective. Adding one at each traced source center then maximizes
+/// the source independent-set size among those primary optima.
+pub fn map_unit_weights(result: &MappingResult) -> Result<Vec<i64>, ReductionError> {
+    let count = i64::try_from(result.lines.len())
+        .map_err(|_| mapping_integer_overflow("converting the source vertex count to i64"))?;
+    let scale = count.checked_add(1).ok_or(mapping_integer_overflow(
+        "computing the unit-weight encoding scale",
+    ))?;
+    let mut weights = result
+        .node_weights
+        .iter()
+        .map(|weight| {
+            weight.checked_mul(scale).ok_or(mapping_integer_overflow(
+                "scaling a triangular mapped weight",
+            ))
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    let positions = position_index(result)?;
+
+    for center in super::super::weighted::trace_centers(result)? {
+        let index = positions.get(&center).copied().ok_or(mapping_invalid(
+            "a traced center is missing from the mapped graph",
+        ))?;
+        weights[index] = weights[index]
+            .checked_add(1)
+            .ok_or(mapping_integer_overflow(
+                "adding a unit source weight to a triangular center",
+            ))?;
+    }
+    Ok(weights)
 }
 
 #[cfg(test)]
diff --git a/src/rules/unitdiskmapping/triangular/mod.rs b/src/rules/unitdiskmapping/triangular/mod.rs
index 06b943374..48e8ee381 100644
--- a/src/rules/unitdiskmapping/triangular/mod.rs
+++ b/src/rules/unitdiskmapping/triangular/mod.rs
@@ -8,15 +8,13 @@
 //! use problemreductions::rules::unitdiskmapping::triangular;
 //!
 //! let edges = vec![(0, 1), (1, 2), (0, 2)];
-//!
-//! // Weighted triangular mapping
-//! let result = triangular::map_weighted(3, &edges);
+//! let result = triangular::map_weighted(3, &edges).unwrap();
 //! ```
 
 pub mod gadgets;
 pub mod mapping;
 
-// Re-export all public items from gadgets for convenient access
+pub use super::weighted::{map_weights, trace_centers};
 pub use gadgets::{
     apply_crossing_gadgets, apply_simplifier_gadgets, tape_entry_mis_overhead, SourceCell,
     WeightedTriBranch, WeightedTriBranchFix, WeightedTriBranchFixB, WeightedTriCross,
@@ -24,11 +22,9 @@ pub use gadgets::{
     WeightedTriTapeEntry, WeightedTriTrivialTurnLeft, WeightedTriTrivialTurnRight, WeightedTriTurn,
     WeightedTriWTurn, WeightedTriangularGadget,
 };
-
-// Re-export all public items from mapping for convenient access
 pub use mapping::{
-    map_weighted, map_weighted_with_method, map_weighted_with_order, map_weights, trace_centers,
-    weighted_ruleset,
+    map_config_back, map_unit_weights, map_weighted, map_weighted_with_method,
+    map_weighted_with_order,
 };
 
 /// Spacing between copy lines for triangular mapping.
@@ -36,1583 +32,3 @@ pub const SPACING: usize = 6;
 
 /// Padding around the grid for triangular mapping.
 pub const PADDING: usize = 2;
-
-// ============================================================================
-// Legacy exports for backward compatibility
-// ============================================================================
-
-use super::copyline::create_copylines;
-use super::grid::MappingGrid;
-use super::ksg::mapping::MappingResult;
-use super::ksg::KsgTapeEntry as TapeEntry;
-use super::pathdecomposition::{pathwidth, vertex_order_from_layout, PathDecompositionMethod};
-use crate::rules::unitdiskmapping::ksg::mapping::GridKind;
-use serde::{Deserialize, Serialize};
-
-pub const TRIANGULAR_SPACING: usize = 6;
-pub const TRIANGULAR_PADDING: usize = 2;
-
-/// Tape entry recording a triangular gadget application.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TriangularTapeEntry {
-    /// Index of the gadget in the ruleset (0-12).
-    pub gadget_idx: usize,
-    /// Row where gadget was applied.
-    pub row: usize,
-    /// Column where gadget was applied.
-    pub col: usize,
-}
-
-/// Calculate crossing point for two copylines on triangular lattice.
-fn crossat_triangular(
-    copylines: &[super::copyline::CopyLine],
-    v: usize,
-    w: usize,
-    spacing: usize,
-    padding: usize,
-) -> (usize, usize) {
-    let line_v = &copylines[v];
-    let line_w = &copylines[w];
-
-    // Use vslot to determine order
-    let (line_first, line_second) = if line_v.vslot < line_w.vslot {
-        (line_v, line_w)
-    } else {
-        (line_w, line_v)
-    };
-
-    let hslot = line_first.hslot;
-    let max_vslot = line_second.vslot;
-
-    // 0-indexed coordinates (subtract 1 from Julia's 1-indexed formula)
-    let row = (hslot - 1) * spacing + 1 + padding; // 0-indexed
-    let col = (max_vslot - 1) * spacing + padding; // 0-indexed
-
-    (row, col)
-}
-
-/// Cell type for source matrix pattern matching (legacy).
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum LegacySourceCell {
-    Empty,
-    Occupied,
-    Connected,
-}
-
-/// Trait for triangular lattice gadgets (simplified interface).
-///
-/// Note: source_graph returns explicit edges (like Julia's simplegraph),
-/// while mapped_graph locations should use unit disk edges.
-#[allow(dead_code)]
-#[allow(clippy::type_complexity)]
-pub trait TriangularGadget {
-    fn size(&self) -> (usize, usize);
-    fn cross_location(&self) -> (usize, usize);
-    fn is_connected(&self) -> bool;
-    /// Returns (locations, edges, pins) - edges are explicit, not unit disk.
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>);
-    /// Returns (locations, pins) - use unit disk for edges on triangular lattice.
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>);
-    fn mis_overhead(&self) -> i32;
-
-    /// Returns 1-indexed node indices that should be Connected (matching Julia).
-    fn connected_nodes(&self) -> Vec<usize> {
-        vec![]
-    }
-
-    /// Returns source node weights. Default is weight 2 for all nodes.
-    fn source_weights(&self) -> Vec<i32> {
-        let (locs, _, _) = self.source_graph();
-        vec![2; locs.len()]
-    }
-
-    /// Returns mapped node weights. Default is weight 2 for all nodes.
-    fn mapped_weights(&self) -> Vec<i32> {
-        let (locs, _) = self.mapped_graph();
-        vec![2; locs.len()]
-    }
-
-    /// Generate source matrix for pattern matching.
-    /// Returns LegacySourceCell::Connected for nodes in connected_nodes() when is_connected() is true.
-    fn source_matrix(&self) -> Vec<Vec<LegacySourceCell>> {
-        let (rows, cols) = self.size();
-        let (locs, _, _) = self.source_graph();
-        let mut matrix = vec![vec![LegacySourceCell::Empty; cols]; rows];
-
-        // Build set of connected node indices (1-indexed in Julia)
-        let connected_set: std::collections::HashSet<usize> = if self.is_connected() {
-            self.connected_nodes().into_iter().collect()
-        } else {
-            std::collections::HashSet::new()
-        };
-
-        for (idx, (r, c)) in locs.iter().enumerate() {
-            if *r > 0 && *c > 0 && *r <= rows && *c <= cols {
-                let cell_type = if connected_set.contains(&(idx + 1)) {
-                    LegacySourceCell::Connected
-                } else {
-                    LegacySourceCell::Occupied
-                };
-                matrix[r - 1][c - 1] = cell_type;
-            }
-        }
-        matrix
-    }
-
-    /// Generate mapped matrix for gadget application.
-    fn mapped_matrix(&self) -> Vec<Vec<bool>> {
-        let (rows, cols) = self.size();
-        let (locs, _) = self.mapped_graph();
-        let mut matrix = vec![vec![false; cols]; rows];
-        for (r, c) in locs {
-            if r > 0 && c > 0 && r <= rows && c <= cols {
-                matrix[r - 1][c - 1] = true;
-            }
-        }
-        matrix
-    }
-}
-
-/// Triangular cross gadget - matches Julia's Cross gadget with weights.
-///
-/// This uses the same structure as Julia's base Cross gadget, with all nodes
-/// having weight 2 (the standard weighted mode).
-/// mis_overhead = base_overhead * 2 = -1 * 2 = -2
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriCross<const CON: bool>;
-
-impl TriangularGadget for TriCross<true> {
-    fn size(&self) -> (usize, usize) {
-        (6, 4)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        true
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(2,1), (2,2), (2,3), (2,4), (1,2), (2,2), (3,2), (4,2), (5,2), (6,2)])
-        // Note: Julia has duplicate (2,2) at indices 2 and 6
-        let locs = vec![
-            (2, 1),
-            (2, 2),
-            (2, 3),
-            (2, 4),
-            (1, 2),
-            (2, 2),
-            (3, 2),
-            (4, 2),
-            (5, 2),
-            (6, 2),
-        ];
-        // Julia: g = simplegraph([(1,2), (2,3), (3,4), (5,6), (6,7), (7,8), (8,9), (9,10), (1,5)])
-        // 0-indexed: [(0,1), (1,2), (2,3), (4,5), (5,6), (6,7), (7,8), (8,9), (0,4)]
-        let edges = vec![
-            (0, 1),
-            (1, 2),
-            (2, 3),
-            (4, 5),
-            (5, 6),
-            (6, 7),
-            (7, 8),
-            (8, 9),
-            (0, 4),
-        ];
-        // Julia: pins = [1,5,10,4] -> 0-indexed: [0,4,9,3]
-        let pins = vec![0, 4, 9, 3];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2), (2,1), (2,2), (2,3), (1,4), (3,3), (4,2), (4,3), (5,1), (6,1), (6,2)])
-        let locs = vec![
-            (1, 2),
-            (2, 1),
-            (2, 2),
-            (2, 3),
-            (1, 4),
-            (3, 3),
-            (4, 2),
-            (4, 3),
-            (5, 1),
-            (6, 1),
-            (6, 2),
-        ];
-        // Julia: pins = [2,1,11,5] -> 0-indexed: [1,0,10,4]
-        let pins = vec![1, 0, 10, 4];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        1
-    }
-
-    fn connected_nodes(&self) -> Vec<usize> {
-        // Julia: connected_nodes = [1,5] (1-indexed, keep as-is for source_matrix)
-        vec![1, 5]
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        // Julia: sw = [2,2,2,2,2,2,2,2,2,2]
-        vec![2; 10]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        // Julia: mw = [3,2,3,3,2,2,2,2,2,2,2]
-        vec![3, 2, 3, 3, 2, 2, 2, 2, 2, 2, 2]
-    }
-}
-
-impl TriangularGadget for TriCross<false> {
-    fn size(&self) -> (usize, usize) {
-        (6, 6)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 4)
-    }
-
-    fn is_connected(&self) -> bool {
-        false
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(2,2), (2,3), (2,4), (2,5), (2,6), (1,4), (2,4), (3,4), (4,4), (5,4), (6,4), (2,1)])
-        // Note: Julia has duplicate (2,4) at indices 3 and 7
-        let locs = vec![
-            (2, 2),
-            (2, 3),
-            (2, 4),
-            (2, 5),
-            (2, 6),
-            (1, 4),
-            (2, 4),
-            (3, 4),
-            (4, 4),
-            (5, 4),
-            (6, 4),
-            (2, 1),
-        ];
-        // Julia: g = simplegraph([(1,2), (2,3), (3,4), (4,5), (6,7), (7,8), (8,9), (9,10), (10,11), (12,1)])
-        // 0-indexed: [(0,1), (1,2), (2,3), (3,4), (5,6), (6,7), (7,8), (8,9), (9,10), (11,0)]
-        let edges = vec![
-            (0, 1),
-            (1, 2),
-            (2, 3),
-            (3, 4),
-            (5, 6),
-            (6, 7),
-            (7, 8),
-            (8, 9),
-            (9, 10),
-            (11, 0),
-        ];
-        // Julia: pins = [12,6,11,5] -> 0-indexed: [11,5,10,4]
-        let pins = vec![11, 5, 10, 4];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,4), (2,2), (2,3), (2,4), (2,5), (2,6), (3,2), (3,3), (3,4), (3,5), (4,2), (4,3), (5,2), (6,3), (6,4), (2,1)])
-        let locs = vec![
-            (1, 4),
-            (2, 2),
-            (2, 3),
-            (2, 4),
-            (2, 5),
-            (2, 6),
-            (3, 2),
-            (3, 3),
-            (3, 4),
-            (3, 5),
-            (4, 2),
-            (4, 3),
-            (5, 2),
-            (6, 3),
-            (6, 4),
-            (2, 1),
-        ];
-        // Julia: pins = [16,1,15,6] -> 0-indexed: [15,0,14,5]
-        let pins = vec![15, 0, 14, 5];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        3
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        vec![2; 12]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        vec![3, 3, 2, 4, 2, 2, 2, 4, 3, 2, 2, 2, 2, 2, 2, 2]
-    }
-}
-
-/// Triangular turn gadget - matches Julia's TriTurn gadget.
-///
-/// Julia TriTurn (from triangular.jl):
-/// - size = (3, 4)
-/// - cross_location = (2, 2)
-/// - 4 source nodes, 4 mapped nodes
-/// - mis_overhead = -2 (weighted)
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriTurn;
-
-impl TriangularGadget for TriTurn {
-    fn size(&self) -> (usize, usize) {
-        (3, 4)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        false
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2), (2,2), (2,3), (2,4)])
-        // Julia: g = simplegraph([(1,2), (2,3), (3,4)])
-        let locs = vec![(1, 2), (2, 2), (2, 3), (2, 4)];
-        let edges = vec![(0, 1), (1, 2), (2, 3)];
-        // Julia: pins = [1,4] -> 0-indexed: [0,3]
-        let pins = vec![0, 3];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2), (2,2), (3,3), (2,4)])
-        let locs = vec![(1, 2), (2, 2), (3, 3), (2, 4)];
-        // Julia: pins = [1,4] -> 0-indexed: [0,3]
-        let pins = vec![0, 3];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        0
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        vec![2; 4]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        vec![2; 4]
-    }
-}
-
-/// Triangular branch gadget - matches Julia's Branch gadget with weights.
-///
-/// Julia Branch:
-/// - size = (5, 4)
-/// - cross_location = (3, 2)
-/// - 8 source nodes, 6 mapped nodes
-/// - mis_overhead = -1 (base), -2 (weighted)
-/// - For weighted mode: source node 4 has weight 3, mapped node 2 has weight 3
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriBranch;
-
-impl TriangularGadget for TriBranch {
-    fn size(&self) -> (usize, usize) {
-        (6, 4)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        false
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2),(2,2),(2,3),(2,4),(3,3),(3,2),(4,2),(5,2),(6,2)])
-        let locs = vec![
-            (1, 2),
-            (2, 2),
-            (2, 3),
-            (2, 4),
-            (3, 3),
-            (3, 2),
-            (4, 2),
-            (5, 2),
-            (6, 2),
-        ];
-        // Julia: g = simplegraph([(1,2), (2,3), (3, 4), (3,5), (5,6), (6,7), (7,8), (8,9)])
-        // 0-indexed: [(0,1), (1,2), (2,3), (2,4), (4,5), (5,6), (6,7), (7,8)]
-        let edges = vec![
-            (0, 1),
-            (1, 2),
-            (2, 3),
-            (2, 4),
-            (4, 5),
-            (5, 6),
-            (6, 7),
-            (7, 8),
-        ];
-        // Julia: pins = [1, 4, 9] -> 0-indexed: [0, 3, 8]
-        let pins = vec![0, 3, 8];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2),(2,2),(2,4),(3,3),(4,2),(4,3),(5,1),(6,1),(6,2)])
-        let locs = vec![
-            (1, 2),
-            (2, 2),
-            (2, 4),
-            (3, 3),
-            (4, 2),
-            (4, 3),
-            (5, 1),
-            (6, 1),
-            (6, 2),
-        ];
-        // Julia: pins = [1,3,9] -> 0-indexed: [0,2,8]
-        let pins = vec![0, 2, 8];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        0
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        // Julia: sw = [2,2,3,2,2,2,2,2,2]
-        vec![2, 2, 3, 2, 2, 2, 2, 2, 2]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        // Julia: mw = [2,2,2,3,2,2,2,2,2]
-        vec![2, 2, 2, 3, 2, 2, 2, 2, 2]
-    }
-}
-
-/// Triangular T-connection left gadget - matches Julia's TCon gadget with weights.
-///
-/// Julia TCon:
-/// - size = (3, 4)
-/// - cross_location = (2, 2)
-/// - 4 source nodes, 4 mapped nodes, 3 pins
-/// - connected_nodes = [1, 2] -> [0, 1]
-/// - mis_overhead = 0 (both base and weighted)
-/// - For weighted mode: source node 2 has weight 1, mapped node 2 has weight 1
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriTConLeft;
-
-impl TriangularGadget for TriTConLeft {
-    fn size(&self) -> (usize, usize) {
-        (6, 5)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        true
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2), (2,1), (2,2), (3,2), (4,2), (5,2), (6,2)])
-        let locs = vec![(1, 2), (2, 1), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2)];
-        // Julia: g = simplegraph([(1,2), (1,3), (3,4), (4,5), (5,6), (6,7)])
-        // 0-indexed: [(0,1), (0,2), (2,3), (3,4), (4,5), (5,6)]
-        let edges = vec![(0, 1), (0, 2), (2, 3), (3, 4), (4, 5), (5, 6)];
-        // Julia: pins = [1,2,7] -> 0-indexed: [0,1,6]
-        let pins = vec![0, 1, 6];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2), (2,1), (2,2), (2,3), (2,4), (3,3), (4,2), (4,3), (5,1), (6,1), (6,2)])
-        let locs = vec![
-            (1, 2),
-            (2, 1),
-            (2, 2),
-            (2, 3),
-            (2, 4),
-            (3, 3),
-            (4, 2),
-            (4, 3),
-            (5, 1),
-            (6, 1),
-            (6, 2),
-        ];
-        // Julia: pins = [1,2,11] -> 0-indexed: [0,1,10]
-        let pins = vec![0, 1, 10];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        4
-    }
-
-    fn connected_nodes(&self) -> Vec<usize> {
-        // Julia: connected_nodes = [1,2] (1-indexed, keep as-is for source_matrix)
-        vec![1, 2]
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        // Julia: sw = [2,1,2,2,2,2,2]
-        vec![2, 1, 2, 2, 2, 2, 2]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        // Julia: mw = [3,2,3,3,1,3,2,2,2,2,2]
-        vec![3, 2, 3, 3, 1, 3, 2, 2, 2, 2, 2]
-    }
-}
-
-/// Triangular T-connection down gadget.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriTConDown;
-
-impl TriangularGadget for TriTConDown {
-    fn size(&self) -> (usize, usize) {
-        (3, 3)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        true
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(2,1), (2,2), (2,3), (3,2)])
-        // Julia: g = simplegraph([(1,2), (2,3), (1,4)])
-        // 0-indexed: [(0,1), (1,2), (0,3)]
-        let locs = vec![(2, 1), (2, 2), (2, 3), (3, 2)];
-        let edges = vec![(0, 1), (1, 2), (0, 3)];
-        // Julia: pins = [1,4,3] -> 0-indexed: [0,3,2]
-        let pins = vec![0, 3, 2];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(2,2), (3,1), (3,2), (3,3)])
-        let locs = vec![(2, 2), (3, 1), (3, 2), (3, 3)];
-        // Julia: pins = [2,3,4] -> 0-indexed: [1,2,3]
-        let pins = vec![1, 2, 3];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        0
-    }
-
-    fn connected_nodes(&self) -> Vec<usize> {
-        // Julia: connected_nodes = [1, 4] (1-indexed, keep as-is for source_matrix)
-        vec![1, 4]
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        vec![2, 2, 2, 1]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        vec![2, 2, 3, 2]
-    }
-}
-
-/// Triangular T-connection up gadget.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriTConUp;
-
-impl TriangularGadget for TriTConUp {
-    fn size(&self) -> (usize, usize) {
-        (3, 3)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        true
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2), (2,1), (2,2), (2,3)])
-        // Julia: g = simplegraph([(1,2), (2,3), (3,4)])
-        // 0-indexed: [(0,1), (1,2), (2,3)]
-        let locs = vec![(1, 2), (2, 1), (2, 2), (2, 3)];
-        let edges = vec![(0, 1), (1, 2), (2, 3)];
-        // Julia: pins = [2,1,4] -> 0-indexed: [1,0,3]
-        let pins = vec![1, 0, 3];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2), (2,1), (2,2), (2,3)])
-        let locs = vec![(1, 2), (2, 1), (2, 2), (2, 3)];
-        // Julia: pins = [2,1,4] -> 0-indexed: [1,0,3]
-        let pins = vec![1, 0, 3];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        0
-    }
-
-    fn connected_nodes(&self) -> Vec<usize> {
-        // Julia: connected_nodes = [1, 2] (1-indexed, keep as-is for source_matrix)
-        vec![1, 2]
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        vec![1, 2, 2, 2]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        vec![3, 2, 2, 2]
-    }
-}
-
-/// Triangular trivial turn left gadget.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriTrivialTurnLeft;
-
-impl TriangularGadget for TriTrivialTurnLeft {
-    fn size(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        true
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2), (2,1)])
-        let locs = vec![(1, 2), (2, 1)];
-        let edges = vec![(0, 1)];
-        let pins = vec![0, 1];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2),(2,1)])
-        let locs = vec![(1, 2), (2, 1)];
-        let pins = vec![0, 1];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        0
-    }
-
-    fn connected_nodes(&self) -> Vec<usize> {
-        // Julia: connected_nodes = [1, 2] (1-indexed, keep as-is for source_matrix)
-        vec![1, 2]
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        vec![1, 1]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        vec![1, 1]
-    }
-}
-
-/// Triangular trivial turn right gadget.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriTrivialTurnRight;
-
-impl TriangularGadget for TriTrivialTurnRight {
-    fn size(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (1, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        true
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,1), (2,2)])
-        let locs = vec![(1, 1), (2, 2)];
-        let edges = vec![(0, 1)];
-        let pins = vec![0, 1];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(2,1),(2,2)])
-        let locs = vec![(2, 1), (2, 2)];
-        let pins = vec![0, 1];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        0
-    }
-
-    fn connected_nodes(&self) -> Vec<usize> {
-        // Julia: connected_nodes = [1, 2] (1-indexed, keep as-is for source_matrix)
-        vec![1, 2]
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        vec![1, 1]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        vec![1, 1]
-    }
-}
-
-/// Triangular end turn gadget - matches Julia's EndTurn gadget with weights.
-///
-/// Julia EndTurn:
-/// - size = (3, 4)
-/// - cross_location = (2, 2)
-/// - 3 source nodes, 1 mapped node, 1 pin
-/// - mis_overhead = -1 (base), -2 (weighted)
-/// - For weighted mode: source node 3 has weight 1, mapped node 1 has weight 1
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriEndTurn;
-
-impl TriangularGadget for TriEndTurn {
-    fn size(&self) -> (usize, usize) {
-        (3, 4)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        false
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2), (2,2), (2,3)])
-        // Julia: g = simplegraph([(1,2), (2,3)])
-        let locs = vec![(1, 2), (2, 2), (2, 3)];
-        let edges = vec![(0, 1), (1, 2)];
-        // Julia: pins = [1] -> 0-indexed: [0]
-        let pins = vec![0];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2)])
-        let locs = vec![(1, 2)];
-        // Julia: pins = [1] -> 0-indexed: [0]
-        let pins = vec![0];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        -2
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        vec![2, 2, 1]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        vec![1]
-    }
-}
-
-/// Triangular W-turn gadget - matches Julia's WTurn gadget with weights.
-///
-/// Julia WTurn:
-/// - size = (4, 4)
-/// - cross_location = (2, 2)
-/// - 5 source nodes, 3 mapped nodes
-/// - mis_overhead = -1 (base), -2 (weighted)
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriWTurn;
-
-impl TriangularGadget for TriWTurn {
-    fn size(&self) -> (usize, usize) {
-        (4, 4)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        false
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(2,3), (2,4), (3,2),(3,3),(4,2)])
-        let locs = vec![(2, 3), (2, 4), (3, 2), (3, 3), (4, 2)];
-        // Julia: g = simplegraph([(1,2), (1,4), (3,4),(3,5)])
-        // 0-indexed: [(0,1), (0,3), (2,3), (2,4)]
-        let edges = vec![(0, 1), (0, 3), (2, 3), (2, 4)];
-        // Julia: pins = [2, 5] -> 0-indexed: [1, 4]
-        let pins = vec![1, 4];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,4), (2,3), (3,2), (3,3), (4,2)])
-        let locs = vec![(1, 4), (2, 3), (3, 2), (3, 3), (4, 2)];
-        // Julia: pins = [1, 5] -> 0-indexed: [0, 4]
-        let pins = vec![0, 4];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        0
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        vec![2; 5]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        vec![2; 5]
-    }
-}
-
-/// Triangular branch fix gadget.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriBranchFix;
-
-impl TriangularGadget for TriBranchFix {
-    fn size(&self) -> (usize, usize) {
-        (4, 4)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        false
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2), (2,2), (2,3),(3,3),(3,2),(4,2)])
-        // Julia: g = simplegraph([(1,2), (2,3), (3,4),(4,5), (5,6)])
-        let locs = vec![(1, 2), (2, 2), (2, 3), (3, 3), (3, 2), (4, 2)];
-        // 0-indexed: [(0,1), (1,2), (2,3), (3,4), (4,5)]
-        let edges = vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)];
-        // Julia: pins = [1, 6] -> 0-indexed: [0, 5]
-        let pins = vec![0, 5];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(1,2),(2,2),(3,2),(4,2)])
-        let locs = vec![(1, 2), (2, 2), (3, 2), (4, 2)];
-        // Julia: pins = [1, 4] -> 0-indexed: [0, 3]
-        let pins = vec![0, 3];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        -2
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        vec![2; 6]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        vec![2; 4]
-    }
-}
-
-/// Triangular branch fix B gadget.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TriBranchFixB;
-
-impl TriangularGadget for TriBranchFixB {
-    fn size(&self) -> (usize, usize) {
-        (4, 4)
-    }
-
-    fn cross_location(&self) -> (usize, usize) {
-        (2, 2)
-    }
-
-    fn is_connected(&self) -> bool {
-        false
-    }
-
-    fn source_graph(&self) -> (Vec<(usize, usize)>, Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(2,3),(3,2),(3,3),(4,2)])
-        // Julia: g = simplegraph([(1,3), (2,3), (2,4)])
-        let locs = vec![(2, 3), (3, 2), (3, 3), (4, 2)];
-        // 0-indexed: [(0,2), (1,2), (1,3)]
-        let edges = vec![(0, 2), (1, 2), (1, 3)];
-        // Julia: pins = [1, 4] -> 0-indexed: [0, 3]
-        let pins = vec![0, 3];
-        (locs, edges, pins)
-    }
-
-    fn mapped_graph(&self) -> (Vec<(usize, usize)>, Vec<usize>) {
-        // Julia: locs = Node.([(3,2),(4,2)])
-        let locs = vec![(3, 2), (4, 2)];
-        // Julia: pins = [1, 2] -> 0-indexed: [0, 1]
-        let pins = vec![0, 1];
-        (locs, pins)
-    }
-
-    fn mis_overhead(&self) -> i32 {
-        -2
-    }
-
-    fn source_weights(&self) -> Vec<i32> {
-        vec![2; 4]
-    }
-
-    fn mapped_weights(&self) -> Vec<i32> {
-        vec![2; 2]
-    }
-}
-
-/// Check if a triangular gadget pattern matches at position (i, j) in the grid.
-/// i, j are 0-indexed row/col offsets (pattern top-left corner).
-///
-/// For weighted triangular mode, this also checks that weights match the expected
-/// source_weights from the gadget. This matches Julia's behavior where WeightedGadget
-/// source matrices include weights and match() uses == comparison.
-#[allow(clippy::needless_range_loop)]
-fn pattern_matches_triangular<G: TriangularGadget>(
-    gadget: &G,
-    grid: &MappingGrid,
-    i: usize,
-    j: usize,
-) -> bool {
-    use super::grid::CellState;
-
-    let source = gadget.source_matrix();
-    let (m, n) = gadget.size();
-
-    // First pass: check cell states (empty/occupied/connected)
-    for r in 0..m {
-        for c in 0..n {
-            let grid_r = i + r;
-            let grid_c = j + c;
-            let expected = source[r][c];
-            let actual = grid.get(grid_r, grid_c);
-
-            match expected {
-                LegacySourceCell::Empty => {
-                    // Grid cell should be empty
-                    if actual.map(|c| !c.is_empty()).unwrap_or(false) {
-                        return false;
-                    }
-                }
-                LegacySourceCell::Occupied => {
-                    // Grid cell should be occupied (but not necessarily connected)
-                    if !actual.map(|c| !c.is_empty()).unwrap_or(false) {
-                        return false;
-                    }
-                }
-                LegacySourceCell::Connected => {
-                    // Grid cell should be Connected specifically
-                    match actual {
-                        Some(CellState::Connected { .. }) => {}
-                        _ => return false,
-                    }
-                }
-            }
-        }
-    }
-
-    // Second pass: check weights for weighted triangular mode
-    // Julia's WeightedGadget stores source_weights and match() compares cells including weight
-    let (locs, _, _) = gadget.source_graph();
-    let weights = gadget.source_weights();
-
-    for (idx, (loc_r, loc_c)) in locs.iter().enumerate() {
-        // source_graph locations are 1-indexed, convert to grid position
-        let grid_r = i + loc_r - 1;
-        let grid_c = j + loc_c - 1;
-        let expected_weight = weights[idx];
-
-        if let Some(cell) = grid.get(grid_r, grid_c) {
-            if cell.weight() != expected_weight {
-                return false;
-            }
-        } else {
-            return false;
-        }
-    }
-
-    true
-}
-
-/// Apply a triangular gadget pattern at position (i, j).
-/// i, j are 0-indexed row/col offsets (pattern top-left corner).
-#[allow(clippy::needless_range_loop)]
-fn apply_triangular_gadget<G: TriangularGadget>(
-    gadget: &G,
-    grid: &mut MappingGrid,
-    i: usize,
-    j: usize,
-) {
-    use super::grid::CellState;
-
-    let source = gadget.source_matrix();
-    let (m, n) = gadget.size();
-
-    // First, clear source pattern cells (any non-empty cell)
-    for r in 0..m {
-        for c in 0..n {
-            if source[r][c] != LegacySourceCell::Empty {
-                grid.set(i + r, j + c, CellState::Empty);
-            }
-        }
-    }
-
-    // Then, add mapped pattern cells with proper weights
-    // locs are 1-indexed within the pattern's bounding box
-    let (locs, _) = gadget.mapped_graph();
-    let weights = gadget.mapped_weights();
-    for (idx, (r, c)) in locs.iter().enumerate() {
-        if *r > 0 && *c > 0 && *r <= m && *c <= n {
-            let weight = weights.get(idx).copied().unwrap_or(2);
-            // Convert 1-indexed pattern pos to 0-indexed grid pos
-            grid.add_node(i + r - 1, j + c - 1, weight);
-        }
-    }
-}
-
-/// Apply all triangular crossing gadgets to resolve crossings.
-/// Returns the tape of applied gadgets.
-///
-/// This matches Julia's `apply_crossing_gadgets!` which iterates ALL pairs (i,j)
-/// and tries to match patterns at each crossing point.
-pub fn apply_triangular_crossing_gadgets(
-    grid: &mut MappingGrid,
-    copylines: &[super::copyline::CopyLine],
-    spacing: usize,
-    padding: usize,
-) -> Vec<TriangularTapeEntry> {
-    use std::collections::HashSet;
-
-    let mut tape = Vec::new();
-    let mut processed = HashSet::new();
-    let n = copylines.len();
-
-    // Iterate ALL pairs (matching Julia's for j=1:n, for i=1:n)
-    for j in 0..n {
-        for i in 0..n {
-            let (cross_row, cross_col) = crossat_triangular(copylines, i, j, spacing, padding);
-
-            // Skip if this crossing point has already been processed
-            // (avoids double-applying trivial gadgets for symmetric pairs like (i,j) and (j,i))
-            if processed.contains(&(cross_row, cross_col)) {
-                continue;
-            }
-
-            // Try each gadget in the ruleset at this crossing point
-            if let Some(entry) = try_match_triangular_gadget(grid, cross_row, cross_col) {
-                tape.push(entry);
-                processed.insert((cross_row, cross_col));
-            }
-        }
-    }
-
-    tape
-}
-
-/// Try to match and apply a triangular gadget at the crossing point.
-fn try_match_triangular_gadget(
-    grid: &mut MappingGrid,
-    cross_row: usize,
-    cross_col: usize,
-) -> Option<TriangularTapeEntry> {
-    // Macro to reduce repetition
-    macro_rules! try_gadget {
-        ($gadget:expr, $idx:expr) => {{
-            let g = $gadget;
-            let (cr, cc) = g.cross_location();
-            if cross_row >= cr && cross_col >= cc {
-                let x = cross_row - cr + 1;
-                let y = cross_col - cc + 1;
-                if pattern_matches_triangular(&g, grid, x, y) {
-                    apply_triangular_gadget(&g, grid, x, y);
-                    return Some(TriangularTapeEntry {
-                        gadget_idx: $idx,
-                        row: x,
-                        col: y,
-                    });
-                }
-            }
-        }};
-    }
-
-    // Try gadgets in order (matching Julia's triangular_crossing_ruleset)
-    // TriCross<true> must be tried BEFORE TriCross<false> because it's more specific
-    // (requires Connected cells). If we try TriCross<false> first, it will match
-    // even when there are Connected cells since it doesn't check for them.
-    try_gadget!(TriCross::<true>, 1);
-    try_gadget!(TriCross::<false>, 0);
-    try_gadget!(TriTConLeft, 2);
-    try_gadget!(TriTConUp, 3);
-    try_gadget!(TriTConDown, 4);
-    try_gadget!(TriTrivialTurnLeft, 5);
-    try_gadget!(TriTrivialTurnRight, 6);
-    try_gadget!(TriEndTurn, 7);
-    try_gadget!(TriTurn, 8);
-    try_gadget!(TriWTurn, 9);
-    try_gadget!(TriBranchFix, 10);
-    try_gadget!(TriBranchFixB, 11);
-    try_gadget!(TriBranch, 12);
-
-    None
-}
-
-/// Get MIS overhead for a triangular tape entry.
-/// For triangular mode, crossing gadgets use their native overhead,
-/// but simplifiers (DanglingLeg) use weighted overhead = unweighted * 2.
-/// Julia: mis_overhead(w::WeightedGadget) = mis_overhead(w.gadget) * 2
-pub fn triangular_tape_entry_mis_overhead(entry: &TriangularTapeEntry) -> i32 {
-    match entry.gadget_idx {
-        0 => TriCross::<false>.mis_overhead(),
-        1 => TriCross::<true>.mis_overhead(),
-        2 => TriTConLeft.mis_overhead(),
-        3 => TriTConUp.mis_overhead(),
-        4 => TriTConDown.mis_overhead(),
-        5 => TriTrivialTurnLeft.mis_overhead(),
-        6 => TriTrivialTurnRight.mis_overhead(),
-        7 => TriEndTurn.mis_overhead(),
-        8 => TriTurn.mis_overhead(),
-        9 => TriWTurn.mis_overhead(),
-        10 => TriBranchFix.mis_overhead(),
-        11 => TriBranchFixB.mis_overhead(),
-        12 => TriBranch.mis_overhead(),
-        // Simplifier gadgets (100+): weighted overhead = -1 * 2 = -2
-        idx if idx >= 100 => -2,
-        _ => 0,
-    }
-}
-
-// ============================================================================
-// Triangular Simplifier Gadgets
-// ============================================================================
-
-/// Apply simplifier gadgets to the triangular grid.
-/// This matches Julia's `apply_simplifier_gadgets!` for TriangularWeighted mode.
-///
-/// The weighted DanglingLeg pattern matches 3 nodes in a line where:
-/// - The end node (closest to center) has weight 1
-/// - The other two nodes have weight 2
-///   After simplification, only 1 node remains with weight 1.
-#[allow(dead_code)]
-pub fn apply_triangular_simplifier_gadgets(
-    grid: &mut MappingGrid,
-    nrepeat: usize,
-) -> Vec<TriangularTapeEntry> {
-    #[allow(unused)]
-    use super::grid::CellState;
-
-    let mut tape = Vec::new();
-    let (rows, cols) = grid.size();
-
-    for _ in 0..nrepeat {
-        // Try all 4 directions at each position
-        // Pattern functions handle bounds checking internally
-        for j in 0..cols {
-            for i in 0..rows {
-                // Down pattern (4x3): needs i+3 < rows, j+2 < cols
-                if try_apply_dangling_leg_down(grid, i, j) {
-                    tape.push(TriangularTapeEntry {
-                        gadget_idx: 100, // DanglingLeg down
-                        row: i,
-                        col: j,
-                    });
-                }
-                // Up pattern (4x3): needs i+3 < rows, j+2 < cols
-                if try_apply_dangling_leg_up(grid, i, j) {
-                    tape.push(TriangularTapeEntry {
-                        gadget_idx: 101, // DanglingLeg up
-                        row: i,
-                        col: j,
-                    });
-                }
-                // Right pattern (3x4): needs i+2 < rows, j+3 < cols
-                if try_apply_dangling_leg_right(grid, i, j) {
-                    tape.push(TriangularTapeEntry {
-                        gadget_idx: 102, // DanglingLeg right
-                        row: i,
-                        col: j,
-                    });
-                }
-                // Left pattern (3x4): needs i+2 < rows, j+3 < cols
-                if try_apply_dangling_leg_left(grid, i, j) {
-                    tape.push(TriangularTapeEntry {
-                        gadget_idx: 103, // DanglingLeg left
-                        row: i,
-                        col: j,
-                    });
-                }
-            }
-        }
-    }
-
-    tape
-}
-
-/// Try to apply DanglingLeg pattern going downward.
-#[allow(dead_code)]
-fn try_apply_dangling_leg_down(grid: &mut MappingGrid, i: usize, j: usize) -> bool {
-    use super::grid::CellState;
-
-    let (rows, cols) = grid.size();
-
-    // Need at least 4 rows and 3 cols from position (i, j)
-    if i + 3 >= rows || j + 2 >= cols {
-        return false;
-    }
-
-    // Helper to check if cell at (row, col) is empty
-    let is_empty = |row: usize, col: usize| -> bool { !grid.is_occupied(row, col) };
-
-    // Helper to check if cell has specific weight
-    let has_weight = |row: usize, col: usize, w: i32| -> bool {
-        grid.get(row, col).is_some_and(|c| c.weight() == w)
-    };
-
-    // Row i (row 1 of pattern): all 3 cells must be empty
-    if !is_empty(i, j) || !is_empty(i, j + 1) || !is_empty(i, j + 2) {
-        return false;
-    }
-
-    // Row i+1 (row 2): empty, occupied(w=1), empty
-    if !is_empty(i + 1, j) || !has_weight(i + 1, j + 1, 1) || !is_empty(i + 1, j + 2) {
-        return false;
-    }
-
-    // Row i+2 (row 3): empty, occupied(w=2), empty
-    if !is_empty(i + 2, j) || !has_weight(i + 2, j + 1, 2) || !is_empty(i + 2, j + 2) {
-        return false;
-    }
-
-    // Row i+3 (row 4): empty, occupied(w=2), empty
-    if !is_empty(i + 3, j) || !has_weight(i + 3, j + 1, 2) || !is_empty(i + 3, j + 2) {
-        return false;
-    }
-
-    // Apply transformation: remove top 2 nodes, bottom node gets weight 1
-    grid.set(i + 1, j + 1, CellState::Empty);
-    grid.set(i + 2, j + 1, CellState::Empty);
-    grid.set(i + 3, j + 1, CellState::Occupied { weight: 1 });
-
-    true
-}
-
-/// Try to apply DanglingLeg pattern going upward.
-#[allow(dead_code)]
-fn try_apply_dangling_leg_up(grid: &mut MappingGrid, i: usize, j: usize) -> bool {
-    use super::grid::CellState;
-
-    let (rows, cols) = grid.size();
-
-    // Need at least 4 rows and 3 cols from position (i, j)
-    if i + 3 >= rows || j + 2 >= cols {
-        return false;
-    }
-
-    let is_empty = |row: usize, col: usize| -> bool { !grid.is_occupied(row, col) };
-
-    let has_weight = |row: usize, col: usize, w: i32| -> bool {
-        grid.get(row, col).is_some_and(|c| c.weight() == w)
-    };
-
-    // Row i: empty, occupied(w=2), empty
-    if !is_empty(i, j) || !has_weight(i, j + 1, 2) || !is_empty(i, j + 2) {
-        return false;
-    }
-
-    // Row i+1: empty, occupied(w=2), empty
-    if !is_empty(i + 1, j) || !has_weight(i + 1, j + 1, 2) || !is_empty(i + 1, j + 2) {
-        return false;
-    }
-
-    // Row i+2: empty, occupied(w=1), empty [dangling end]
-    if !is_empty(i + 2, j) || !has_weight(i + 2, j + 1, 1) || !is_empty(i + 2, j + 2) {
-        return false;
-    }
-
-    // Row i+3: all 3 cells must be empty
-    if !is_empty(i + 3, j) || !is_empty(i + 3, j + 1) || !is_empty(i + 3, j + 2) {
-        return false;
-    }
-
-    // Apply transformation: remove dangling end and middle, base gets weight 1
-    grid.set(i + 1, j + 1, CellState::Empty);
-    grid.set(i + 2, j + 1, CellState::Empty);
-    grid.set(i, j + 1, CellState::Occupied { weight: 1 });
-
-    true
-}
-
-/// Try to apply DanglingLeg pattern going right.
-#[allow(dead_code)]
-fn try_apply_dangling_leg_right(grid: &mut MappingGrid, i: usize, j: usize) -> bool {
-    use super::grid::CellState;
-
-    let (rows, cols) = grid.size();
-
-    // Need at least 3 rows and 4 cols from position (i, j)
-    if i + 2 >= rows || j + 3 >= cols {
-        return false;
-    }
-
-    let is_empty = |row: usize, col: usize| -> bool { !grid.is_occupied(row, col) };
-
-    let has_weight = |row: usize, col: usize, w: i32| -> bool {
-        grid.get(row, col).is_some_and(|c| c.weight() == w)
-    };
-
-    // Row i: all 4 cells must be empty
-    if !is_empty(i, j) || !is_empty(i, j + 1) || !is_empty(i, j + 2) || !is_empty(i, j + 3) {
-        return false;
-    }
-
-    // Row i+1: occupied(w=2), occupied(w=2), occupied(w=1), empty
-    if !has_weight(i + 1, j, 2)
-        || !has_weight(i + 1, j + 1, 2)
-        || !has_weight(i + 1, j + 2, 1)
-        || !is_empty(i + 1, j + 3)
-    {
-        return false;
-    }
-
-    // Row i+2: all 4 cells must be empty
-    if !is_empty(i + 2, j)
-        || !is_empty(i + 2, j + 1)
-        || !is_empty(i + 2, j + 2)
-        || !is_empty(i + 2, j + 3)
-    {
-        return false;
-    }
-
-    // Apply transformation: remove dangling and middle, base gets weight 1
-    grid.set(i + 1, j + 1, CellState::Empty);
-    grid.set(i + 1, j + 2, CellState::Empty);
-    grid.set(i + 1, j, CellState::Occupied { weight: 1 });
-
-    true
-}
-
-/// Try to apply DanglingLeg pattern going left.
-#[allow(dead_code)]
-fn try_apply_dangling_leg_left(grid: &mut MappingGrid, i: usize, j: usize) -> bool {
-    use super::grid::CellState;
-
-    let (rows, cols) = grid.size();
-
-    // Need at least 3 rows and 4 cols from position (i, j)
-    if i + 2 >= rows || j + 3 >= cols {
-        return false;
-    }
-
-    let is_empty = |row: usize, col: usize| -> bool { !grid.is_occupied(row, col) };
-
-    let has_weight = |row: usize, col: usize, w: i32| -> bool {
-        grid.get(row, col).is_some_and(|c| c.weight() == w)
-    };
-
-    // Row i: all 4 cells must be empty
-    if !is_empty(i, j) || !is_empty(i, j + 1) || !is_empty(i, j + 2) || !is_empty(i, j + 3) {
-        return false;
-    }
-
-    // Row i+1: empty, occupied(w=1), occupied(w=2), occupied(w=2)
-    if !is_empty(i + 1, j)
-        || !has_weight(i + 1, j + 1, 1)
-        || !has_weight(i + 1, j + 2, 2)
-        || !has_weight(i + 1, j + 3, 2)
-    {
-        return false;
-    }
-
-    // Row i+2: all 4 cells must be empty
-    if !is_empty(i + 2, j)
-        || !is_empty(i + 2, j + 1)
-        || !is_empty(i + 2, j + 2)
-        || !is_empty(i + 2, j + 3)
-    {
-        return false;
-    }
-
-    // Apply transformation: remove dangling and middle, base gets weight 1
-    grid.set(i + 1, j + 1, CellState::Empty);
-    grid.set(i + 1, j + 2, CellState::Empty);
-    grid.set(i + 1, j + 3, CellState::Occupied { weight: 1 });
-
-    true
-}
-
-/// Map a graph to a triangular lattice grid graph using optimal path decomposition.
-///
-/// # Panics
-/// Panics if `num_vertices == 0`.
-pub fn map_graph_triangular(num_vertices: usize, edges: &[(usize, usize)]) -> MappingResult {
-    map_graph_triangular_with_method(num_vertices, edges, PathDecompositionMethod::Auto)
-}
-
-/// Map a graph to triangular lattice using a specific path decomposition method.
-pub fn map_graph_triangular_with_method(
-    num_vertices: usize,
-    edges: &[(usize, usize)],
-    method: PathDecompositionMethod,
-) -> MappingResult {
-    let layout = pathwidth(num_vertices, edges, method);
-    let vertex_order = vertex_order_from_layout(&layout);
-    map_graph_triangular_with_order(num_vertices, edges, &vertex_order)
-}
-
-/// Map a graph to triangular lattice with specific vertex ordering.
-///
-/// # Panics
-/// Panics if `num_vertices == 0` or if any edge vertex is not in `vertex_order`.
-pub fn map_graph_triangular_with_order(
-    num_vertices: usize,
-    edges: &[(usize, usize)],
-    vertex_order: &[usize],
-) -> MappingResult {
-    assert!(num_vertices > 0, "num_vertices must be > 0");
-
-    let spacing = TRIANGULAR_SPACING;
-    let padding = TRIANGULAR_PADDING;
-
-    let copylines = create_copylines(num_vertices, edges, vertex_order);
-
-    // Calculate grid dimensions
-    // Julia formula: N = (n-1)*col_spacing + 2 + 2*padding
-    //                M = nrow*row_spacing + 2 + 2*padding
-    // where nrow = max(hslot, vstop) and n = num_vertices
-    let max_hslot = copylines.iter().map(|l| l.hslot).max().unwrap_or(1);
-    let max_vstop = copylines.iter().map(|l| l.vstop).max().unwrap_or(1);
-
-    let rows = max_hslot.max(max_vstop) * spacing + 2 + 2 * padding;
-    // Use (num_vertices - 1) for cols, matching Julia's (n-1) formula
-    let cols = (num_vertices - 1) * spacing + 2 + 2 * padding;
-
-    let mut grid = MappingGrid::with_padding(rows, cols, spacing, padding);
-
-    // Add copy line nodes using triangular dense locations
-    // (includes the endpoint node for triangular weighted mode)
-    for line in &copylines {
-        for (row, col, weight) in line.copyline_locations_triangular(padding, spacing) {
-            grid.add_node(row, col, weight as i32);
-        }
-    }
-
-    // Mark edge connections at crossing points
-    for &(u, v) in edges {
-        let u_line = &copylines[u];
-        let v_line = &copylines[v];
-
-        let (smaller_line, larger_line) = if u_line.vslot < v_line.vslot {
-            (u_line, v_line)
-        } else {
-            (v_line, u_line)
-        };
-
-        let (row, col) = crossat_triangular(
-            &copylines,
-            smaller_line.vertex,
-            larger_line.vertex,
-            spacing,
-            padding,
-        );
-
-        // Mark connected cells at crossing point
-        if col > 0 {
-            grid.connect(row, col - 1);
-        }
-        if row > 0 && grid.is_occupied(row - 1, col) {
-            grid.connect(row - 1, col);
-        } else if row + 1 < grid.size().0 && grid.is_occupied(row + 1, col) {
-            grid.connect(row + 1, col);
-        }
-    }
-
-    // Apply crossing gadgets (iterates ALL pairs, not just edges)
-    let mut triangular_tape =
-        apply_triangular_crossing_gadgets(&mut grid, &copylines, spacing, padding);
-
-    // Apply simplifier gadgets (weighted DanglingLeg pattern)
-    // Julia's triangular mode uses: weighted.(default_simplifier_ruleset(UnWeighted()))
-    // which applies the weighted DanglingLeg pattern to reduce grid complexity.
-    let simplifier_tape = apply_triangular_simplifier_gadgets(&mut grid, 10);
-    triangular_tape.extend(simplifier_tape);
-
-    // Calculate MIS overhead from copylines using the dedicated function
-    // which matches Julia's mis_overhead_copyline(TriangularWeighted(), ...)
-    let copyline_overhead: i32 = copylines
-        .iter()
-        .map(|line| super::copyline::mis_overhead_copyline_triangular(line, spacing))
-        .sum();
-
-    // Add gadget overhead (crossing gadgets + simplifiers)
-    let gadget_overhead: i32 = triangular_tape
-        .iter()
-        .map(triangular_tape_entry_mis_overhead)
-        .sum();
-    let mis_overhead = copyline_overhead + gadget_overhead;
-
-    // Convert triangular tape entries to generic tape entries
-    let tape: Vec<TapeEntry> = triangular_tape
-        .into_iter()
-        .map(|entry| TapeEntry {
-            pattern_idx: entry.gadget_idx,
-            row: entry.row,
-            col: entry.col,
-        })
-        .collect();
-
-    // Extract doubled cells before extracting positions
-    let doubled_cells = grid.doubled_cells();
-
-    // Extract positions and weights from occupied cells
-    let (positions, node_weights): (Vec<(i32, i32)>, Vec<i32>) = grid
-        .occupied_coords()
-        .into_iter()
-        .filter_map(|(row, col)| {
-            grid.get(row, col)
-                .map(|cell| ((row as i32, col as i32), cell.weight()))
-        })
-        .filter(|&(_, w)| w > 0)
-        .unzip();
-
-    MappingResult {
-        positions,
-        node_weights,
-        grid_dimensions: grid.size(),
-        kind: GridKind::Triangular,
-        lines: copylines,
-        padding,
-        spacing,
-        mis_overhead,
-        tape,
-        doubled_cells,
-    }
-}
-
-#[cfg(test)]
-#[path = "../../../unit_tests/rules/unitdiskmapping/triangular/mod.rs"]
-mod tests;
diff --git a/src/rules/unitdiskmapping/weighted.rs b/src/rules/unitdiskmapping/weighted.rs
index aca42a7c0..ac84b9220 100644
--- a/src/rules/unitdiskmapping/weighted.rs
+++ b/src/rules/unitdiskmapping/weighted.rs
@@ -1,481 +1,134 @@
-//! Weighted gadget support for triangular lattice mapping.
+//! Weight injection and center tracing for triangular lattice mappings.
 
 use super::ksg::MappingResult;
-use super::triangular::{
-    TriBranch, TriBranchFix, TriBranchFixB, TriCross, TriEndTurn, TriTConDown, TriTConLeft,
-    TriTConUp, TriTrivialTurnLeft, TriTrivialTurnRight, TriTurn, TriWTurn,
-};
-use serde::{Deserialize, Serialize};
-
-/// Weighted gadget wrapper that adds weight vectors to base gadgets.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct WeightedGadget<G> {
-    /// The underlying gadget.
-    pub gadget: G,
-    /// Weights for each node in the source graph.
-    pub source_weights: Vec<i32>,
-    /// Weights for each node in the mapped graph.
-    pub mapped_weights: Vec<i32>,
-}
-
-impl<G> WeightedGadget<G> {
-    /// Create a new weighted gadget.
-    pub fn new(gadget: G, source_weights: Vec<i32>, mapped_weights: Vec<i32>) -> Self {
-        Self {
-            gadget,
-            source_weights,
-            mapped_weights,
-        }
-    }
-
-    /// Get the source weights.
-    pub fn source_weights(&self) -> &[i32] {
-        &self.source_weights
-    }
-
-    /// Get the mapped weights.
-    pub fn mapped_weights(&self) -> &[i32] {
-        &self.mapped_weights
-    }
-}
-
-/// Trait for gadgets that can be converted to weighted versions.
-pub trait Weightable: Sized {
-    /// Convert to a weighted gadget with appropriate weight vectors.
-    fn weighted(self) -> WeightedGadget<Self>;
-}
-
-// NOTE: All Weightable implementations delegate to TriangularGadget trait methods
-// to ensure consistency between the gadget structure and its weights.
-
-impl Weightable for TriTurn {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(self, TriTurn.source_weights(), TriTurn.mapped_weights())
-    }
-}
-
-impl Weightable for TriBranch {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(self, TriBranch.source_weights(), TriBranch.mapped_weights())
-    }
-}
-
-impl Weightable for TriCross<true> {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(
-            self,
-            TriCross::<true>.source_weights(),
-            TriCross::<true>.mapped_weights(),
-        )
-    }
-}
-
-impl Weightable for TriCross<false> {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(
-            self,
-            TriCross::<false>.source_weights(),
-            TriCross::<false>.mapped_weights(),
-        )
-    }
-}
-
-impl Weightable for TriTConLeft {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(
-            self,
-            TriTConLeft.source_weights(),
-            TriTConLeft.mapped_weights(),
-        )
-    }
-}
-
-impl Weightable for TriTConDown {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(
-            self,
-            TriTConDown.source_weights(),
-            TriTConDown.mapped_weights(),
-        )
-    }
-}
-
-impl Weightable for TriTConUp {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(self, TriTConUp.source_weights(), TriTConUp.mapped_weights())
-    }
-}
-
-impl Weightable for TriTrivialTurnLeft {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(
-            self,
-            TriTrivialTurnLeft.source_weights(),
-            TriTrivialTurnLeft.mapped_weights(),
-        )
-    }
-}
-
-impl Weightable for TriTrivialTurnRight {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(
-            self,
-            TriTrivialTurnRight.source_weights(),
-            TriTrivialTurnRight.mapped_weights(),
-        )
-    }
-}
-
-impl Weightable for TriEndTurn {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(
-            self,
-            TriEndTurn.source_weights(),
-            TriEndTurn.mapped_weights(),
-        )
-    }
-}
-
-impl Weightable for TriWTurn {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(self, TriWTurn.source_weights(), TriWTurn.mapped_weights())
-    }
-}
-
-impl Weightable for TriBranchFix {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(
-            self,
-            TriBranchFix.source_weights(),
-            TriBranchFix.mapped_weights(),
-        )
-    }
-}
-
-impl Weightable for TriBranchFixB {
-    fn weighted(self) -> WeightedGadget<Self> {
-        use super::triangular::TriangularGadget;
-        WeightedGadget::new(
-            self,
-            TriBranchFixB.source_weights(),
-            TriBranchFixB.mapped_weights(),
-        )
-    }
-}
-
-/// Enum wrapper for weighted triangular gadgets to enable dynamic dispatch.
-#[derive(Debug, Clone)]
-pub enum WeightedTriangularGadget {
-    CrossFalse(WeightedGadget<TriCross<false>>),
-    CrossTrue(WeightedGadget<TriCross<true>>),
-    TConLeft(WeightedGadget<TriTConLeft>),
-    TConUp(WeightedGadget<TriTConUp>),
-    TConDown(WeightedGadget<TriTConDown>),
-    TrivialTurnLeft(WeightedGadget<TriTrivialTurnLeft>),
-    TrivialTurnRight(WeightedGadget<TriTrivialTurnRight>),
-    EndTurn(WeightedGadget<TriEndTurn>),
-    Turn(WeightedGadget<TriTurn>),
-    WTurn(WeightedGadget<TriWTurn>),
-    BranchFix(WeightedGadget<TriBranchFix>),
-    BranchFixB(WeightedGadget<TriBranchFixB>),
-    Branch(WeightedGadget<TriBranch>),
-}
-
-impl WeightedTriangularGadget {
-    /// Get source weights for this gadget.
-    pub fn source_weights(&self) -> &[i32] {
-        match self {
-            Self::CrossFalse(g) => g.source_weights(),
-            Self::CrossTrue(g) => g.source_weights(),
-            Self::TConLeft(g) => g.source_weights(),
-            Self::TConUp(g) => g.source_weights(),
-            Self::TConDown(g) => g.source_weights(),
-            Self::TrivialTurnLeft(g) => g.source_weights(),
-            Self::TrivialTurnRight(g) => g.source_weights(),
-            Self::EndTurn(g) => g.source_weights(),
-            Self::Turn(g) => g.source_weights(),
-            Self::WTurn(g) => g.source_weights(),
-            Self::BranchFix(g) => g.source_weights(),
-            Self::BranchFixB(g) => g.source_weights(),
-            Self::Branch(g) => g.source_weights(),
-        }
-    }
-
-    /// Get mapped weights for this gadget.
-    pub fn mapped_weights(&self) -> &[i32] {
-        match self {
-            Self::CrossFalse(g) => g.mapped_weights(),
-            Self::CrossTrue(g) => g.mapped_weights(),
-            Self::TConLeft(g) => g.mapped_weights(),
-            Self::TConUp(g) => g.mapped_weights(),
-            Self::TConDown(g) => g.mapped_weights(),
-            Self::TrivialTurnLeft(g) => g.mapped_weights(),
-            Self::TrivialTurnRight(g) => g.mapped_weights(),
-            Self::EndTurn(g) => g.mapped_weights(),
-            Self::Turn(g) => g.mapped_weights(),
-            Self::WTurn(g) => g.mapped_weights(),
-            Self::BranchFix(g) => g.mapped_weights(),
-            Self::BranchFixB(g) => g.mapped_weights(),
-            Self::Branch(g) => g.mapped_weights(),
-        }
-    }
-
-    /// Get mis_overhead for this gadget.
-    pub fn mis_overhead(&self) -> i32 {
-        use super::triangular::TriangularGadget;
-        match self {
-            Self::CrossFalse(g) => g.gadget.mis_overhead(),
-            Self::CrossTrue(g) => g.gadget.mis_overhead(),
-            Self::TConLeft(g) => g.gadget.mis_overhead(),
-            Self::TConUp(g) => g.gadget.mis_overhead(),
-            Self::TConDown(g) => g.gadget.mis_overhead(),
-            Self::TrivialTurnLeft(g) => g.gadget.mis_overhead(),
-            Self::TrivialTurnRight(g) => g.gadget.mis_overhead(),
-            Self::EndTurn(g) => g.gadget.mis_overhead(),
-            Self::Turn(g) => g.gadget.mis_overhead(),
-            Self::WTurn(g) => g.gadget.mis_overhead(),
-            Self::BranchFix(g) => g.gadget.mis_overhead(),
-            Self::BranchFixB(g) => g.gadget.mis_overhead(),
-            Self::Branch(g) => g.gadget.mis_overhead(),
-        }
-    }
-}
-
-/// Get the weighted triangular crossing ruleset.
-/// This matches Julia's `crossing_ruleset_triangular_weighted`.
-pub fn triangular_weighted_ruleset() -> Vec<WeightedTriangularGadget> {
-    vec![
-        WeightedTriangularGadget::CrossFalse(TriCross::<false>.weighted()),
-        WeightedTriangularGadget::CrossTrue(TriCross::<true>.weighted()),
-        WeightedTriangularGadget::TConLeft(TriTConLeft.weighted()),
-        WeightedTriangularGadget::TConUp(TriTConUp.weighted()),
-        WeightedTriangularGadget::TConDown(TriTConDown.weighted()),
-        WeightedTriangularGadget::TrivialTurnLeft(TriTrivialTurnLeft.weighted()),
-        WeightedTriangularGadget::TrivialTurnRight(TriTrivialTurnRight.weighted()),
-        WeightedTriangularGadget::EndTurn(TriEndTurn.weighted()),
-        WeightedTriangularGadget::Turn(TriTurn.weighted()),
-        WeightedTriangularGadget::WTurn(TriWTurn.weighted()),
-        WeightedTriangularGadget::BranchFix(TriBranchFix.weighted()),
-        WeightedTriangularGadget::BranchFixB(TriBranchFixB.weighted()),
-        WeightedTriangularGadget::Branch(TriBranch.weighted()),
-    ]
-}
-
-/// Trace center locations through gadget transformations.
-/// Returns the final center location for each original vertex.
-///
-/// This matches Julia's `trace_centers` function which:
-/// 1. Gets initial center locations with (0, 1) offset
-/// 2. Applies `move_center` for each gadget in the tape
-pub fn trace_centers(result: &MappingResult) -> Vec<(usize, usize)> {
-    // Get gadget sizes for bounds checking
-    fn get_gadget_size(gadget_idx: usize) -> (usize, usize) {
-        use super::triangular::TriangularGadget;
-        use super::triangular::{
-            TriBranch, TriBranchFix, TriBranchFixB, TriCross, TriEndTurn, TriTConDown, TriTConLeft,
-            TriTConUp, TriTrivialTurnLeft, TriTrivialTurnRight, TriTurn, TriWTurn,
-        };
-        match gadget_idx {
-            0 => TriCross::<false>.size(),
-            1 => TriCross::<true>.size(),
-            2 => TriTConLeft.size(),
-            3 => TriTConUp.size(),
-            4 => TriTConDown.size(),
-            5 => TriTrivialTurnLeft.size(),
-            6 => TriTrivialTurnRight.size(),
-            7 => TriEndTurn.size(),
-            8 => TriTurn.size(),
-            9 => TriWTurn.size(),
-            10 => TriBranchFix.size(),
-            11 => TriBranchFixB.size(),
-            12 => TriBranch.size(),
-            // Simplifier gadgets: DanglingLeg rotations
-            // Base DanglingLeg has size (4, 3)
-            100 => (4, 3), // DanglingLeg down (no rotation)
-            101 => (4, 3), // DanglingLeg up (180° rotation, same size)
-            102 => (3, 4), // DanglingLeg right (90° clockwise, swapped)
-            103 => (3, 4), // DanglingLeg left (90° counterclockwise, swapped)
-            _ => (0, 0),
-        }
-    }
-
-    // Get center locations for each copy line with (0, 1) offset (matching Julia)
-    let mut centers: Vec<(usize, usize)> = result
+use super::triangular::gadgets::{tape_entry_center_transform, tape_entry_size};
+use super::{mapping_integer_overflow, mapping_invalid, mapping_non_finite};
+use crate::rules::ReductionError;
+use crate::types::i64_to_exact_f64;
+use std::collections::HashMap;
+
+/// Trace each original vertex center through the recorded gadget transformations.
+pub fn trace_centers(result: &MappingResult) -> Result<Vec<(usize, usize)>, ReductionError> {
+    let mut centers = result
         .lines
         .iter()
         .map(|line| {
-            let (row, col) = line.center_location(result.padding, result.spacing);
-            (row, col + 1) // Julia adds (0, 1) offset
+            let (row, column) = line.center_location(result.padding, result.spacing);
+            column
+                .checked_add(1)
+                .map(|column| (row, column))
+                .ok_or(mapping_integer_overflow(
+                    "offsetting a triangular copy-line center",
+                ))
         })
-        .collect();
+        .collect::<Result<Vec<_>, _>>()?;
 
-    // Apply gadget transformations from tape
     for entry in &result.tape {
-        let gadget_idx = entry.pattern_idx;
-        let gi = entry.row;
-        let gj = entry.col;
-
-        // Get gadget size
-        let (m, n) = get_gadget_size(gadget_idx);
-        if m == 0 || n == 0 {
-            continue; // Unknown gadget
-        }
-
-        // For each center location, check if it's within this gadget's area
-        for center in centers.iter_mut() {
-            let (ci, cj) = *center;
-
-            // Check if center is within gadget bounds (using >= for lower and < for upper)
-            if ci >= gi && ci < gi + m && cj >= gj && cj < gj + n {
-                // Local coordinates within gadget (1-indexed as in Julia)
-                let local_i = ci - gi + 1;
-                let local_j = cj - gj + 1;
-
-                // Apply gadget-specific center movement
-                if let Some(new_pos) =
-                    move_center_for_gadget(gadget_idx, (local_i, local_j), gi, gj)
-                {
-                    *center = new_pos;
-                }
+        let (height, width) = tape_entry_size(entry.pattern_idx).ok_or(mapping_invalid(
+            "mapping result contains an unknown triangular gadget",
+        ))?;
+        let row_end = entry
+            .row
+            .checked_add(height)
+            .ok_or(mapping_integer_overflow(
+                "computing triangular gadget bounds",
+            ))?;
+        let column_end = entry
+            .col
+            .checked_add(width)
+            .ok_or(mapping_integer_overflow(
+                "computing triangular gadget bounds",
+            ))?;
+
+        let Some((source, shift)) = tape_entry_center_transform(entry.pattern_idx) else {
+            continue;
+        };
+        for center in &mut centers {
+            if center.0 >= entry.row
+                && center.0 < row_end
+                && center.1 >= entry.col
+                && center.1 < column_end
+                && (center.0 - entry.row + 1, center.1 - entry.col + 1) == source
+            {
+                center.0 = center
+                    .0
+                    .checked_add_signed(shift.0)
+                    .ok_or(mapping_integer_overflow("moving a triangular center row"))?;
+                center.1 = center
+                    .1
+                    .checked_add_signed(shift.1)
+                    .ok_or(mapping_integer_overflow(
+                        "moving a triangular center column",
+                    ))?;
             }
         }
     }
 
-    // Sort by vertex index and return
-    let mut indexed: Vec<_> = result
+    let mut indexed = result
         .lines
         .iter()
-        .enumerate()
-        .map(|(idx, line)| (line.vertex, centers[idx]))
-        .collect();
-    indexed.sort_by_key(|(v, _)| *v);
-    indexed.into_iter().map(|(_, c)| c).collect()
-}
-
-/// Move a center through a specific gadget transformation.
-/// Returns the new global position if the gadget affects this center.
-///
-/// Julia defines center movement for:
-/// 1. Triangular crossing gadgets (7-12): TriTurn, TriBranch, etc.
-/// 2. Simplifier gadgets (100-103): DanglingLeg rotations
-///
-/// Gadgets 0-6 (TriCross, TriTCon*, TriTrivialTurn*) have empty centers - no movement.
-fn move_center_for_gadget(
-    gadget_idx: usize,
-    local_pos: (usize, usize),
-    gi: usize,
-    gj: usize,
-) -> Option<(usize, usize)> {
-    // Get source_center and mapped_center for this gadget
-    // From Julia triangular.jl line 415-417:
-    //   source_centers = [cross_location(T()) .+ (0, 1)]
-    //   All triangular gadgets have cross_location = (2, 2), so source = (2, 3)
-    //   mapped_centers: TriTurn->(1,2), TriBranch->(1,2), TriBranchFix->(3,2),
-    //                   TriBranchFixB->(3,2), TriWTurn->(2,3), TriEndTurn->(1,2)
-    let (source_center, mapped_center) = match gadget_idx {
-        // Triangular crossing gadgets - all have cross_location=(2,2), source=(2,3)
-        7 => ((2, 3), (1, 2)),  // TriEndTurn
-        8 => ((2, 3), (1, 2)),  // TriTurn
-        9 => ((2, 3), (2, 3)),  // TriWTurn (center stays same)
-        10 => ((2, 3), (3, 2)), // TriBranchFix
-        11 => ((2, 3), (3, 2)), // TriBranchFixB
-        12 => ((2, 3), (1, 2)), // TriBranch
-
-        // Simplifier gadgets: DanglingLeg rotations (from simplifiers.jl:107-108)
-        // Base DanglingLeg: source_centers=[(2,2)], mapped_centers=[(4,2)]
-        // Size (4, 3). When rotated, centers transform accordingly.
-        //
-        // 100: DanglingLeg down (no rotation) - size (4, 3)
-        //      source_center = (2, 2), mapped_center = (4, 2)
-        100 => ((2, 2), (4, 2)),
-
-        // 101: DanglingLeg up (180° rotation) - size (4, 3)
-        //      Rotation 2: (r, c) -> (m+1-r, n+1-c) where (m,n)=(4,3)
-        //      source: (2, 2) -> (4+1-2, 3+1-2) = (3, 2)
-        //      mapped: (4, 2) -> (4+1-4, 3+1-2) = (1, 2)
-        101 => ((3, 2), (1, 2)),
-
-        // 102: DanglingLeg right (90° clockwise, rotation 1) - size (3, 4)
-        //      Rotation 1: (r, c) -> (c, m+1-r) where m=4 (original rows)
-        //      source: (2, 2) -> (2, 4+1-2) = (2, 3)
-        //      mapped: (4, 2) -> (2, 4+1-4) = (2, 1)
-        102 => ((2, 3), (2, 1)),
-
-        // 103: DanglingLeg left (90° counterclockwise, rotation 3) - size (3, 4)
-        //      Rotation 3: (r, c) -> (n+1-c, r) where n=3 (original cols)
-        //      source: (2, 2) -> (3+1-2, 2) = (2, 2)
-        //      mapped: (4, 2) -> (3+1-2, 4) = (2, 4)
-        103 => ((2, 2), (2, 4)),
-
-        // Gadgets 0-6 and unknown: no center movement
-        _ => return None,
-    };
-
-    // Check if local_pos matches source_center
-    if local_pos == source_center {
-        // Julia: return nodexy .+ mc .- sc
-        // global_new = global_old + (mapped_center - source_center)
-        let di = mapped_center.0 as isize - source_center.0 as isize;
-        let dj = mapped_center.1 as isize - source_center.1 as isize;
-        let new_i = (gi as isize + local_pos.0 as isize - 1 + di) as usize;
-        let new_j = (gj as isize + local_pos.1 as isize - 1 + dj) as usize;
-        return Some((new_i, new_j));
+        .zip(centers)
+        .map(|(line, center)| (line.vertex, center))
+        .collect::<Vec<_>>();
+    indexed.sort_by_key(|(vertex, _)| *vertex);
+    Ok(indexed.into_iter().map(|(_, center)| center).collect())
+}
+
+/// Add source weights in `[0, 1]` to the corresponding mapped center nodes.
+pub fn map_weights(
+    result: &MappingResult,
+    source_weights: &[f64],
+) -> Result<Vec<f64>, ReductionError> {
+    if source_weights
+        .iter()
+        .any(|&weight| !weight.is_finite() || !(0.0..=1.0).contains(&weight))
+    {
+        return Err(mapping_invalid(
+            "source weights must be finite and in [0, 1]",
+        ));
+    }
+    if source_weights.len() != result.lines.len() {
+        return Err(mapping_invalid(
+            "source weight count must match the original vertex count",
+        ));
     }
 
-    None
-}
-
-/// Map source vertex weights to grid graph weights.
-///
-/// # Arguments
-/// * `result` - The mapping result from map_graph_triangular
-/// * `source_weights` - Weights for each original vertex (should be in [0, 1])
-///
-/// # Returns
-/// A vector of weights for each node in the grid graph.
-pub fn map_weights(result: &MappingResult, source_weights: &[f64]) -> Vec<f64> {
-    assert!(
-        source_weights.iter().all(|&w| (0.0..=1.0).contains(&w)),
-        "all weights must be in range [0, 1]"
-    );
-    assert_eq!(
-        source_weights.len(),
-        result.lines.len(),
-        "source_weights length must match number of vertices"
-    );
-
-    // Start with base weights from grid nodes
-    let mut weights: Vec<f64> = result.node_weights.iter().map(|&w| w as f64).collect();
-
-    // Get center locations for each original vertex
-    let centers = trace_centers(result);
-
-    // Add source weights at center locations
-    for (vertex, &src_weight) in source_weights.iter().enumerate() {
-        let center = centers[vertex];
-        // Find the node index at this center location
-        if let Some(idx) = result
-            .positions
-            .iter()
-            .position(|&(r, c)| r as usize == center.0 && c as usize == center.1)
-        {
-            weights[idx] += src_weight;
+    let mut weights = result
+        .node_weights
+        .iter()
+        .map(|&weight| {
+            i64_to_exact_f64(weight).map_err(|_| {
+                mapping_invalid("a mapped node weight is not exactly representable as f64")
+            })
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    let positions = result
+        .positions
+        .iter()
+        .enumerate()
+        .map(|(index, &(row, column))| {
+            let row = usize::try_from(row)
+                .map_err(|_| mapping_invalid("mapping result contains a negative grid row"))?;
+            let column = usize::try_from(column)
+                .map_err(|_| mapping_invalid("mapping result contains a negative grid column"))?;
+            Ok(((row, column), index))
+        })
+        .collect::<Result<HashMap<_, _>, ReductionError>>()?;
+
+    for (center, source_weight) in trace_centers(result)?.into_iter().zip(source_weights) {
+        let index = positions.get(&center).copied().ok_or(mapping_invalid(
+            "a traced center is missing from the mapped graph",
+        ))?;
+        let weight = weights[index] + source_weight;
+        if !weight.is_finite() {
+            return Err(mapping_non_finite(
+                "adding a source weight to a mapped center",
+            ));
         }
+        weights[index] = weight;
     }
 
-    weights
+    Ok(weights)
 }
 
 #[cfg(test)]
diff --git a/src/solvers/brute_force.rs b/src/solvers/brute_force.rs
index caf8ca817..fd3add8fe 100644
--- a/src/solvers/brute_force.rs
+++ b/src/solvers/brute_force.rs
@@ -1,85 +1,241 @@
-//! Brute force solver that enumerates all configurations.
+//! Registered brute-force reference solver.
 
-use crate::config::DimsIterator;
-use crate::solvers::Solver;
+use std::any::Any;
+
+use crate::solvers::SolveError;
 use crate::traits::Problem;
-use crate::types::Aggregate;
+use crate::types::{Aggregate, SolutionAggregate};
+
+type CartesianWitness<P> = Option<(<P as Problem>::Solution, <P as Problem>::Value)>;
+
+#[doc(hidden)]
+pub type BruteForceDimensionsFn = fn(&dyn Any) -> Vec<usize>;
+#[doc(hidden)]
+pub type BruteForceSolveFn =
+    fn(&dyn Any) -> Result<Option<(serde_json::Value, String)>, SolveError>;
+#[doc(hidden)]
+pub type BruteForceSolveTypedFn = fn(&dyn Any) -> Result<Option<Box<dyn Any>>, SolveError>;
+#[doc(hidden)]
+pub type BruteForceSolveTypedWithWitnessesFn = fn(&dyn Any) -> Result<Box<dyn Any>, SolveError>;
+
+/// Type-erased registration for one finite Cartesian reference solver.
+#[derive(Debug)]
+#[doc(hidden)]
+pub struct BruteForceRegistration {
+    pub source_name: &'static str,
+    pub source_variant_fn: fn() -> Vec<(&'static str, &'static str)>,
+    pub dimensions_fn: BruteForceDimensionsFn,
+    pub solve_fn: BruteForceSolveFn,
+    pub solve_typed_fn: BruteForceSolveTypedFn,
+    pub solve_typed_with_witnesses_fn: BruteForceSolveTypedWithWitnessesFn,
+}
+
+inventory::collect!(BruteForceRegistration);
+
+/// A problem with a finite Cartesian coordinate space for reference solving.
+pub trait BruteForceProblem: Problem {
+    /// Cardinality of each coordinate in the brute-force search space.
+    fn dimensions(&self) -> Vec<usize>;
+
+    /// Number of coordinates in the brute-force search space.
+    fn num_variables(&self) -> usize {
+        self.dimensions().len()
+    }
+}
+
+pub(crate) struct CartesianIndices {
+    dimensions: Vec<usize>,
+    current: Option<Vec<usize>>,
+    remaining: usize,
+}
+
+impl CartesianIndices {
+    pub(crate) fn new(dimensions: Vec<usize>) -> Result<Self, SolveError> {
+        let total = if dimensions.is_empty() {
+            1
+        } else if dimensions.contains(&0) {
+            0
+        } else {
+            dimensions.iter().try_fold(1usize, |total, &dimension| {
+                total
+                    .checked_mul(dimension)
+                    .ok_or_else(|| SolveError::SearchSpaceOverflow(dimensions.clone()))
+            })?
+        };
+        Ok(Self {
+            current: (total != 0).then(|| vec![0; dimensions.len()]),
+            dimensions,
+            remaining: total,
+        })
+    }
+}
+
+impl Iterator for CartesianIndices {
+    type Item = Vec<usize>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let current = self.current.take()?;
+        let mut next = current.clone();
+        for index in (0..self.dimensions.len()).rev() {
+            next[index] += 1;
+            if next[index] < self.dimensions[index] {
+                break;
+            }
+            next[index] = 0;
+        }
+        self.remaining -= 1;
+        if self.remaining != 0 {
+            self.current = Some(next);
+        }
+        Some(current)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.remaining, Some(self.remaining))
+    }
+}
+
+impl ExactSizeIterator for CartesianIndices {}
 
-/// A brute force solver that enumerates all possible configurations.
-///
-/// This solver is exponential in the number of variables but guarantees
-/// finding the full aggregate value and all witness configurations when the
-/// aggregate type supports witnesses.
+/// Exact reference solver for variants with a registered finite enumeration.
 #[derive(Debug, Clone, Default)]
 pub struct BruteForce;
 
 impl BruteForce {
-    /// Create a new brute force solver.
+    /// Create a new brute-force reference solver.
     pub fn new() -> Self {
         Self
     }
 
-    /// Find one witness configuration when the aggregate value admits them.
-    pub fn find_witness<P>(&self, problem: &P) -> Option<Vec<usize>>
+    fn registration<P: Problem>(&self) -> Result<&'static BruteForceRegistration, SolveError> {
+        let key = crate::solvers::ExactProblemKey::new(
+            P::NAME,
+            P::variant()
+                .into_iter()
+                .map(|(name, value)| (name.to_string(), value.to_string()))
+                .collect(),
+        );
+        crate::solvers::registry::brute_force_registration(&key)
+            .map_err(SolveError::InvalidRegistry)?
+            .ok_or_else(|| SolveError::MissingRegistration(P::NAME.to_string()))
+    }
+
+    /// Solve a registered finite problem and return one solution when feasible.
+    pub fn solve<P>(&self, problem: &P) -> Result<Option<P::Solution>, SolveError>
     where
-        P: Problem,
-        P::Value: Aggregate,
+        P: Problem + 'static,
+        P::Solution: 'static,
+        P::Value: SolutionAggregate + 'static,
     {
-        self.find_all_witnesses(problem).into_iter().next()
+        let solution = (self.registration::<P>()?.solve_typed_fn)(problem as &dyn Any)?;
+        solution
+            .map(|solution| {
+                solution
+                    .downcast::<P::Solution>()
+                    .map(|value| *value)
+                    .map_err(|_| {
+                        SolveError::RegistrationTypeMismatch(format!(
+                            "{} solution registration returned the wrong type",
+                            P::NAME
+                        ))
+                    })
+            })
+            .transpose()
     }
 
-    /// Find all witness configurations for witness-supporting aggregates.
-    pub fn find_all_witnesses<P>(&self, problem: &P) -> Vec<Vec<usize>>
+    /// Find all witnesses for a registered finite reference solve.
+    pub fn find_all_witnesses<P>(&self, problem: &P) -> Result<Vec<P::Solution>, SolveError>
     where
-        P: Problem,
-        P::Value: Aggregate,
+        P: Problem + 'static,
+        P::Solution: 'static,
+        P::Value: SolutionAggregate + 'static,
     {
-        let total = self.solve(problem);
-
-        if !P::Value::supports_witnesses() {
-            return vec![];
-        }
+        self.solve_with_witnesses(problem)
+            .map(|(_, witnesses)| witnesses)
+    }
 
-        DimsIterator::new(problem.dims())
-            .filter(|config| {
-                let value = problem.evaluate(config);
-                P::Value::contributes_to_witnesses(&value, &total)
+    /// Solve a problem and collect every contributing witness.
+    pub fn solve_with_witnesses<P>(
+        &self,
+        problem: &P,
+    ) -> Result<(P::Value, Vec<P::Solution>), SolveError>
+    where
+        P: Problem + 'static,
+        P::Solution: 'static,
+        P::Value: SolutionAggregate + 'static,
+    {
+        (self.registration::<P>()?.solve_typed_with_witnesses_fn)(problem as &dyn Any)?
+            .downcast::<(P::Value, Vec<P::Solution>)>()
+            .map(|result| *result)
+            .map_err(|_| {
+                SolveError::RegistrationTypeMismatch(format!(
+                    "{} aggregate-and-witness registration returned the wrong type",
+                    P::NAME
+                ))
             })
-            .collect()
     }
 
-    /// Solve a problem and collect all witness configurations in one passable API.
-    pub fn solve_with_witnesses<P>(&self, problem: &P) -> (P::Value, Vec<Vec<usize>>)
+    pub(crate) fn solve_cartesian<P, F>(
+        &self,
+        problem: &P,
+        decode: F,
+    ) -> Result<P::Value, SolveError>
     where
-        P: Problem,
+        P: BruteForceProblem,
         P::Value: Aggregate,
+        F: Fn(Vec<usize>) -> P::Solution,
     {
-        let total = self.solve(problem);
-
-        if !P::Value::supports_witnesses() {
-            return (total, vec![]);
+        let mut total = P::Value::identity();
+        for indices in CartesianIndices::new(problem.dimensions())? {
+            total = total.combine(problem.evaluate(&decode(indices))?)?;
+            if total.is_absorbing() {
+                break;
+            }
         }
+        Ok(total)
+    }
 
-        let witnesses = DimsIterator::new(problem.dims())
-            .filter(|config| {
-                let value = problem.evaluate(config);
-                P::Value::contributes_to_witnesses(&value, &total)
-            })
-            .collect();
-
-        (total, witnesses)
+    pub(crate) fn solve_with_witnesses_cartesian<P, F>(
+        &self,
+        problem: &P,
+        decode: F,
+    ) -> Result<(P::Value, Vec<P::Solution>), SolveError>
+    where
+        P: BruteForceProblem,
+        P::Value: SolutionAggregate,
+        F: Fn(Vec<usize>) -> P::Solution,
+    {
+        let total = self.solve_cartesian(problem, &decode)?;
+        let mut witnesses = Vec::new();
+        for indices in CartesianIndices::new(problem.dimensions())? {
+            let solution = decode(indices);
+            let value = problem.evaluate(&solution)?;
+            if P::Value::contributes_to_solution(&value, &total) {
+                witnesses.push(solution);
+            }
+        }
+        Ok((total, witnesses))
     }
-}
 
-impl Solver for BruteForce {
-    fn solve<P>(&self, problem: &P) -> P::Value
+    pub(crate) fn find_cartesian<P, F>(
+        &self,
+        problem: &P,
+        decode: F,
+    ) -> Result<CartesianWitness<P>, SolveError>
     where
-        P: Problem,
-        P::Value: Aggregate,
+        P: BruteForceProblem,
+        P::Value: SolutionAggregate,
+        F: Fn(Vec<usize>) -> P::Solution,
     {
-        DimsIterator::new(problem.dims())
-            .map(|config| problem.evaluate(&config))
-            .fold(P::Value::identity(), P::Value::combine)
+        let total = self.solve_cartesian(problem, &decode)?;
+        for indices in CartesianIndices::new(problem.dimensions())? {
+            let solution = decode(indices);
+            let value = problem.evaluate(&solution)?;
+            if P::Value::contributes_to_solution(&value, &total) {
+                return Ok(Some((solution, value)));
+            }
+        }
+        Ok(None)
     }
 }
 
diff --git a/src/solvers/customized/closest_vector_problem.rs b/src/solvers/customized/closest_vector_problem.rs
new file mode 100644
index 000000000..7f901e8e9
--- /dev/null
+++ b/src/solvers/customized/closest_vector_problem.rs
@@ -0,0 +1,164 @@
+//! Exact-rational CVP sphere enumeration in nearest-first (Schnorr--Euchner) order.
+
+use crate::models::algebraic::{ClosestVectorProblem, ClosestVectorTarget};
+use crate::solvers::SolveError;
+use num_rational::BigRational;
+use num_traits::{ToPrimitive, Zero};
+
+type GramSchmidtData = (Vec<Vec<BigRational>>, Vec<BigRational>, Vec<BigRational>);
+
+pub(crate) fn solve<T: ClosestVectorTarget>(
+    problem: &ClosestVectorProblem<T>,
+) -> Result<Vec<i64>, SolveError> {
+    let n = problem.num_basis_vectors();
+    if n == 0 {
+        return Ok(Vec::new());
+    }
+
+    let basis = problem
+        .basis()
+        .iter()
+        .map(|column| {
+            column
+                .iter()
+                .map(|&entry| {
+                    crate::types::i64_to_exact_f64(entry)?;
+                    Ok(BigRational::from_integer(entry.into()))
+                })
+                .collect::<Result<Vec<_>, SolveError>>()
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    let target = problem
+        .target()
+        .iter()
+        .map(|coordinate| {
+            let value = coordinate.to_f64().map_err(SolveError::Evaluation)?;
+            BigRational::from_float(value).ok_or_else(|| {
+                SolveError::NonFiniteResult("converting a CVP target to an exact rational".into())
+            })
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let (mu, norms, alpha) = gram_schmidt(&basis, &target);
+    let mut best_squared = (0..n).map(|i| &norms[i] * &alpha[i] * &alpha[i]).sum();
+
+    let mut coefficients = vec![0_i64; n];
+    let mut best = coefficients.clone();
+    enumerate(
+        n - 1,
+        BigRational::zero(),
+        &mu,
+        &norms,
+        &alpha,
+        &mut coefficients,
+        &mut best,
+        &mut best_squared,
+    )?;
+    Ok(best)
+}
+
+fn gram_schmidt(basis: &[Vec<BigRational>], target: &[BigRational]) -> GramSchmidtData {
+    let n = basis.len();
+    let mut orthogonal = basis.to_vec();
+    let mut mu = vec![vec![BigRational::zero(); n]; n];
+    let mut norms = vec![BigRational::zero(); n];
+
+    for i in 0..n {
+        for j in 0..i {
+            let dot: BigRational = basis[i]
+                .iter()
+                .zip(&orthogonal[j])
+                .map(|(left, right)| left * right)
+                .sum();
+            mu[i][j] = dot / &norms[j];
+            for row in 0..orthogonal[i].len() {
+                let projection = &mu[i][j] * &orthogonal[j][row];
+                orthogonal[i][row] -= projection;
+            }
+        }
+        // Construction guarantees independent columns, so exact norms are positive.
+        norms[i] = orthogonal[i].iter().map(|value| value * value).sum();
+    }
+
+    let alpha = orthogonal
+        .iter()
+        .zip(&norms)
+        .map(|(column, norm)| {
+            target
+                .iter()
+                .zip(column)
+                .map(|(left, right)| left * right)
+                .sum::<BigRational>()
+                / norm
+        })
+        .collect();
+    (mu, norms, alpha)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn enumerate(
+    level: usize,
+    partial_squared: BigRational,
+    mu: &[Vec<BigRational>],
+    norms: &[BigRational],
+    alpha: &[BigRational],
+    coefficients: &mut [i64],
+    best: &mut Vec<i64>,
+    best_squared: &mut BigRational,
+) -> Result<(), SolveError> {
+    if partial_squared >= *best_squared {
+        return Ok(());
+    }
+
+    let mut center = alpha[level].clone();
+    for later in (level + 1)..coefficients.len() {
+        center -= &mu[later][level] * BigRational::from_integer(coefficients[later].into());
+    }
+    let mut candidate =
+        center.round().to_integer().to_i64().ok_or_else(|| {
+            SolveError::IntegerOverflow("rounding a CVP enumeration center".into())
+        })?;
+    crate::types::i64_to_exact_f64(candidate)?;
+    let nearest = BigRational::from_integer(candidate.into());
+    let mut step = if center > nearest { 1_i64 } else { -1 };
+
+    // Visit the nearest integer, then alternate sides in increasing distance.
+    // The first descent tries the nearest-plane candidate; every subsequent
+    // branch uses the improved incumbent rather than a fixed initial interval.
+    loop {
+        coefficients[level] = candidate;
+        crate::types::i64_to_exact_f64(candidate)?;
+        let delta = BigRational::from_integer(candidate.into()) - &center;
+        let next_squared = &partial_squared + &norms[level] * &delta * &delta;
+        if next_squared >= *best_squared {
+            break;
+        }
+        if level == 0 {
+            *best_squared = next_squared;
+            best.clone_from_slice(coefficients);
+            break;
+        }
+        enumerate(
+            level - 1,
+            next_squared,
+            mu,
+            norms,
+            alpha,
+            coefficients,
+            best,
+            best_squared,
+        )?;
+        if partial_squared >= *best_squared {
+            break;
+        }
+        // Differences +1,-2,+3,... (or -1,+2,-3,...) alternate around the center.
+        // Exact f64 coefficient transport keeps these i64 updates below 2^55.
+        candidate += step;
+        step = -step - step.signum();
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "../../unit_tests/solvers/customized/closest_vector_problem.rs"]
+mod tests;
diff --git a/src/solvers/customized/ensemble_computation.rs b/src/solvers/customized/ensemble_computation.rs
new file mode 100644
index 000000000..4dacafc88
--- /dev/null
+++ b/src/solvers/customized/ensemble_computation.rs
@@ -0,0 +1,80 @@
+//! Exact ensemble computation solver using breadth-first search over computed sets.
+
+use crate::models::misc::EnsembleComputation;
+use std::collections::{HashSet, VecDeque};
+
+pub(crate) fn solve(problem: &EnsembleComputation) -> Option<Vec<usize>> {
+    if problem.subsets().is_empty() {
+        return Some(vec![0; 2 * problem.budget()]);
+    }
+
+    let singletons = (0..problem.universe_size())
+        .map(|element| vec![element])
+        .collect::<Vec<_>>();
+    let mut queue = VecDeque::from([(Vec::<Vec<usize>>::new(), Vec::<usize>::new())]);
+    let mut seen = HashSet::from([Vec::<Vec<usize>>::new()]);
+
+    while let Some((computed, program)) = queue.pop_front() {
+        if computed.len() == problem.budget() {
+            continue;
+        }
+        let mut available = singletons.iter().collect::<Vec<_>>();
+        available.extend(computed.iter());
+
+        for left in 0..available.len() {
+            for right in (left + 1)..available.len() {
+                if !disjoint(available[left], available[right]) {
+                    continue;
+                }
+                let result = union(available[left], available[right]);
+                if computed.contains(&result)
+                    || !problem.subsets().iter().any(|required| {
+                        result
+                            .iter()
+                            .all(|element| required.binary_search(element).is_ok())
+                    })
+                {
+                    continue;
+                }
+
+                let mut next_computed = computed.clone();
+                next_computed.push(result);
+                let mut next_program = program.clone();
+                next_program.extend([left, right]);
+                if problem
+                    .subsets()
+                    .iter()
+                    .all(|required| next_computed.contains(required))
+                {
+                    next_program.resize(2 * problem.budget(), 0);
+                    return Some(next_program);
+                }
+
+                let mut key = next_computed.clone();
+                key.sort();
+                if seen.insert(key) {
+                    queue.push_back((next_computed, next_program));
+                }
+            }
+        }
+    }
+    None
+}
+
+fn disjoint(left: &[usize], right: &[usize]) -> bool {
+    !left
+        .iter()
+        .any(|element| right.binary_search(element).is_ok())
+}
+
+fn union(left: &[usize], right: &[usize]) -> Vec<usize> {
+    let mut result = Vec::with_capacity(left.len() + right.len());
+    result.extend_from_slice(left);
+    result.extend_from_slice(right);
+    result.sort_unstable();
+    result
+}
+
+#[cfg(test)]
+#[path = "../../unit_tests/solvers/customized/ensemble_computation.rs"]
+mod tests;
diff --git a/src/solvers/customized/grouping_by_swapping.rs b/src/solvers/customized/grouping_by_swapping.rs
new file mode 100644
index 000000000..2f54c7e9f
--- /dev/null
+++ b/src/solvers/customized/grouping_by_swapping.rs
@@ -0,0 +1,61 @@
+//! Exact solver for GroupingBySwapping by enumerating symbol-block orders.
+
+use crate::models::misc::GroupingBySwapping;
+
+pub(crate) fn solve(problem: &GroupingBySwapping) -> Option<Vec<usize>> {
+    if problem.string().is_empty() {
+        return Some(Vec::new());
+    }
+
+    let mut symbols = problem.string().to_vec();
+    symbols.sort_unstable();
+    symbols.dedup();
+    permute(problem, &mut symbols, 0)
+}
+
+fn permute(
+    problem: &GroupingBySwapping,
+    symbols: &mut [usize],
+    start: usize,
+) -> Option<Vec<usize>> {
+    if start == symbols.len() {
+        let mut target = problem.string().to_vec();
+        let mut rank = vec![0; problem.alphabet_size()];
+        for (position, &symbol) in symbols.iter().enumerate() {
+            rank[symbol] = position;
+        }
+        target.sort_by_key(|symbol| rank[*symbol]);
+
+        let mut current = problem.string().to_vec();
+        let mut swaps = Vec::new();
+        for (i, &wanted) in target.iter().enumerate() {
+            let mut j = i;
+            while current[j] != wanted {
+                j += 1;
+            }
+            while j > i {
+                current.swap(j - 1, j);
+                swaps.push(j - 1);
+                j -= 1;
+            }
+        }
+        if swaps.len() <= problem.budget() {
+            swaps.resize(problem.budget(), problem.string_len() - 1);
+            return Some(swaps);
+        }
+        return None;
+    }
+
+    for i in start..symbols.len() {
+        symbols.swap(start, i);
+        if let Some(solution) = permute(problem, symbols, start + 1) {
+            return Some(solution);
+        }
+        symbols.swap(start, i);
+    }
+    None
+}
+
+#[cfg(test)]
+#[path = "../../unit_tests/solvers/customized/grouping_by_swapping.rs"]
+mod tests;
diff --git a/src/solvers/customized/minimum_cost_circulation.rs b/src/solvers/customized/minimum_cost_circulation.rs
new file mode 100644
index 000000000..24b3dae81
--- /dev/null
+++ b/src/solvers/customized/minimum_cost_circulation.rs
@@ -0,0 +1,111 @@
+//! Exact minimum-cost circulation solver using negative-cycle cancellation.
+
+use crate::models::graph::MinimumCostCirculation;
+use crate::solvers::SolveError;
+
+struct ResidualArc {
+    from: usize,
+    to: usize,
+    cost: i64,
+    capacity: i64,
+    original: usize,
+    forward: bool,
+}
+
+pub(crate) fn solve(problem: &MinimumCostCirculation) -> Result<Vec<usize>, SolveError> {
+    let mut flow = vec![0_i64; problem.num_arcs()];
+
+    loop {
+        let mut residual = Vec::new();
+        for (arc, &(from, to)) in problem.graph().arcs().iter().enumerate() {
+            if flow[arc] < problem.capacities()[arc] {
+                residual.push(ResidualArc {
+                    from,
+                    to,
+                    cost: problem.costs()[arc],
+                    capacity: problem.capacities()[arc] - flow[arc],
+                    original: arc,
+                    forward: true,
+                });
+            }
+            if flow[arc] > 0 {
+                residual.push(ResidualArc {
+                    from: to,
+                    to: from,
+                    cost: problem.costs()[arc].checked_neg().ok_or_else(|| {
+                        SolveError::IntegerOverflow("negating a circulation residual cost".into())
+                    })?,
+                    capacity: flow[arc],
+                    original: arc,
+                    forward: false,
+                });
+            }
+        }
+
+        let Some(cycle) = negative_cycle(problem.num_vertices(), &residual)? else {
+            break;
+        };
+        let amount = cycle
+            .iter()
+            .map(|&edge| residual[edge].capacity)
+            .min()
+            .unwrap();
+        for edge in cycle {
+            let edge = &residual[edge];
+            if edge.forward {
+                flow[edge.original] += amount;
+            } else {
+                flow[edge.original] -= amount;
+            }
+        }
+    }
+
+    Ok(flow.into_iter().map(|value| value as usize).collect())
+}
+
+fn negative_cycle(
+    num_vertices: usize,
+    edges: &[ResidualArc],
+) -> Result<Option<Vec<usize>>, SolveError> {
+    let mut distance = vec![0_i64; num_vertices];
+    let mut predecessor = vec![None; num_vertices];
+    let mut changed = None;
+
+    for _ in 0..num_vertices {
+        changed = None;
+        for (index, edge) in edges.iter().enumerate() {
+            let candidate = distance[edge.from].checked_add(edge.cost).ok_or_else(|| {
+                SolveError::IntegerOverflow("relaxing a circulation residual arc".into())
+            })?;
+            if distance[edge.to] > candidate {
+                distance[edge.to] = candidate;
+                predecessor[edge.to] = Some(index);
+                changed = Some(edge.to);
+            }
+        }
+        if changed.is_none() {
+            return Ok(None);
+        }
+    }
+
+    let Some(mut vertex) = changed else {
+        return Ok(None);
+    };
+    for _ in 0..num_vertices {
+        vertex = edges[predecessor[vertex].unwrap()].from;
+    }
+    let start = vertex;
+    let mut cycle = Vec::new();
+    loop {
+        let edge = predecessor[vertex].unwrap();
+        cycle.push(edge);
+        vertex = edges[edge].from;
+        if vertex == start {
+            return Ok(Some(cycle));
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "../../unit_tests/solvers/customized/minimum_cost_circulation.rs"]
+mod tests;
diff --git a/src/solvers/customized/minimum_decision_tree.rs b/src/solvers/customized/minimum_decision_tree.rs
new file mode 100644
index 000000000..7422ab1dc
--- /dev/null
+++ b/src/solvers/customized/minimum_decision_tree.rs
@@ -0,0 +1,70 @@
+//! Exact minimum decision tree solver using dynamic programming over object subsets.
+
+use crate::models::misc::MinimumDecisionTree;
+
+pub(crate) fn solve(problem: &MinimumDecisionTree) -> Option<Vec<usize>> {
+    let n = problem.num_objects();
+    let full = (1usize << n) - 1;
+    let mut costs = vec![usize::MAX; 1usize << n];
+    let mut choices = vec![problem.num_tests(); 1usize << n];
+    for object in 0..n {
+        costs[1 << object] = 0;
+    }
+
+    for subset in 1usize..=full {
+        let count = subset.count_ones() as usize;
+        if count < 2 {
+            continue;
+        }
+        for test in 0..problem.num_tests() {
+            let passed = (0..n).fold(0usize, |mask, object| {
+                if subset & (1 << object) != 0 && problem.test_matrix()[test][object] {
+                    mask | (1 << object)
+                } else {
+                    mask
+                }
+            });
+            let failed = subset ^ passed;
+            if passed == 0 || failed == 0 {
+                continue;
+            }
+            let cost = count + costs[passed] + costs[failed];
+            if cost < costs[subset] {
+                costs[subset] = cost;
+                choices[subset] = test;
+            }
+        }
+    }
+
+    let slots = (1usize << (n - 1)) - 1;
+    let mut solution = vec![problem.num_tests(); slots];
+    write_tree(problem, full, 0, &choices, &mut solution);
+    Some(solution)
+}
+
+fn write_tree(
+    problem: &MinimumDecisionTree,
+    subset: usize,
+    node: usize,
+    choices: &[usize],
+    solution: &mut [usize],
+) {
+    if subset.count_ones() == 1 {
+        return;
+    }
+    let test = choices[subset];
+    solution[node] = test;
+    let passed = (0..problem.num_objects()).fold(0usize, |mask, object| {
+        if subset & (1 << object) != 0 && problem.test_matrix()[test][object] {
+            mask | (1 << object)
+        } else {
+            mask
+        }
+    });
+    write_tree(problem, subset ^ passed, 2 * node + 1, choices, solution);
+    write_tree(problem, passed, 2 * node + 2, choices, solution);
+}
+
+#[cfg(test)]
+#[path = "../../unit_tests/solvers/customized/minimum_decision_tree.rs"]
+mod tests;
diff --git a/src/solvers/customized/minimum_intersection_graph_basis.rs b/src/solvers/customized/minimum_intersection_graph_basis.rs
new file mode 100644
index 000000000..d2d183d4d
--- /dev/null
+++ b/src/solvers/customized/minimum_intersection_graph_basis.rs
@@ -0,0 +1,119 @@
+//! Exact intersection-basis solver via maximal cliques and edge-cover branch and bound.
+
+use crate::models::graph::MinimumIntersectionGraphBasis;
+use crate::topology::{Graph, SimpleGraph};
+
+pub(crate) fn solve(
+    problem: &MinimumIntersectionGraphBasis<SimpleGraph>,
+) -> Option<Vec<Vec<bool>>> {
+    let n = problem.num_vertices();
+    let edges = problem.graph().edges();
+    if edges.is_empty() {
+        return Some(vec![Vec::new(); n]);
+    }
+
+    let mut cliques = Vec::new();
+    maximal_cliques(
+        problem.graph(),
+        Vec::new(),
+        (0..n).collect(),
+        Vec::new(),
+        &mut cliques,
+    );
+    let covers = cliques
+        .iter()
+        .map(|clique| {
+            edges
+                .iter()
+                .map(|&(u, v)| clique.contains(&u) && clique.contains(&v))
+                .collect::<Vec<_>>()
+        })
+        .collect::<Vec<_>>();
+
+    // One maximal clique per edge is a feasible initial cover with at most |E| cliques.
+    let mut chosen = (0..edges.len())
+        .map(|edge| covers.iter().position(|cover| cover[edge]).unwrap())
+        .collect::<Vec<_>>();
+    chosen.sort_unstable();
+    chosen.dedup();
+    minimum_cover(
+        &covers,
+        &vec![false; edges.len()],
+        &mut Vec::new(),
+        &mut chosen,
+    );
+    let mut solution = vec![vec![false; edges.len()]; n];
+    for (element, clique) in chosen.into_iter().enumerate() {
+        for &vertex in &cliques[clique] {
+            solution[vertex][element] = true;
+        }
+    }
+    Some(solution)
+}
+
+fn minimum_cover(
+    covers: &[Vec<bool>],
+    covered: &[bool],
+    selected: &mut Vec<usize>,
+    best: &mut Vec<usize>,
+) {
+    let Some(edge) = covered.iter().position(|&covered| !covered) else {
+        if selected.len() < best.len() {
+            best.clone_from(selected);
+        }
+        return;
+    };
+    if selected.len() + 1 >= best.len() {
+        return;
+    }
+    for (clique, cover) in covers.iter().enumerate().filter(|(_, cover)| cover[edge]) {
+        let next = covered
+            .iter()
+            .zip(cover)
+            .map(|(&left, &right)| left || right)
+            .collect::<Vec<_>>();
+        selected.push(clique);
+        minimum_cover(covers, &next, selected, best);
+        selected.pop();
+    }
+}
+
+fn maximal_cliques(
+    graph: &SimpleGraph,
+    clique: Vec<usize>,
+    mut candidates: Vec<usize>,
+    mut excluded: Vec<usize>,
+    output: &mut Vec<Vec<usize>>,
+) {
+    if candidates.is_empty() && excluded.is_empty() {
+        if clique.len() >= 2 {
+            output.push(clique);
+        }
+        return;
+    }
+
+    while let Some(vertex) = candidates.pop() {
+        let mut next_clique = clique.clone();
+        next_clique.push(vertex);
+        maximal_cliques(
+            graph,
+            next_clique,
+            candidates
+                .iter()
+                .copied()
+                .filter(|&other| graph.has_edge(vertex, other))
+                .collect(),
+            excluded
+                .iter()
+                .copied()
+                .filter(|&other| graph.has_edge(vertex, other))
+                .collect(),
+            output,
+        );
+        excluded.push(vertex);
+    }
+}
+
+#[cfg(test)]
+#[path = "../../unit_tests/solvers/customized/minimum_intersection_graph_basis.rs"]
+mod tests;
diff --git a/src/solvers/customized/mod.rs b/src/solvers/customized/mod.rs
index 3553e4d19..1eee49c47 100644
--- a/src/solvers/customized/mod.rs
+++ b/src/solvers/customized/mod.rs
@@ -1,11 +1,17 @@
-//! Customized solver module.
+//! Dedicated customized solver backends.
 //!
-//! Provides exact witness recovery for problems that have dedicated
-//! structure-exploiting backends, without requiring ILP reduction paths.
+//! Each backend is registered for one exact problem variant. Dispatch is
+//! performed by the solver capability registry rather than a downcast chain.
 
+pub(crate) mod closest_vector_problem;
+#[cfg(test)]
+pub(crate) mod ensemble_computation;
 pub(crate) mod fd_subset_search;
+pub(crate) mod grouping_by_swapping;
+pub(crate) mod minimum_cost_circulation;
+pub(crate) mod minimum_decision_tree;
+pub(crate) mod minimum_intersection_graph_basis;
 pub(crate) mod partial_feedback_edge_set;
 pub(crate) mod rooted_tree_arrangement;
+pub(crate) mod shortest_common_superstring;
 mod solver;
-
-pub use solver::CustomizedSolver;
diff --git a/src/solvers/customized/partial_feedback_edge_set.rs b/src/solvers/customized/partial_feedback_edge_set.rs
index 46c69a46d..a38992b57 100644
--- a/src/solvers/customized/partial_feedback_edge_set.rs
+++ b/src/solvers/customized/partial_feedback_edge_set.rs
@@ -8,7 +8,7 @@ use crate::topology::{Graph, SimpleGraph};
 
 /// Find a witness (binary edge-removal vector) for PartialFeedbackEdgeSet,
 /// or None if no solution exists within budget.
-pub(crate) fn find_witness(problem: &PartialFeedbackEdgeSet<SimpleGraph>) -> Option<Vec<usize>> {
+pub(crate) fn solve(problem: &PartialFeedbackEdgeSet<SimpleGraph>) -> Option<Vec<bool>> {
     let graph = problem.graph();
     let n = graph.num_vertices();
     let edges = graph.edges();
@@ -18,7 +18,7 @@ pub(crate) fn find_witness(problem: &PartialFeedbackEdgeSet<SimpleGraph>) -> Opt
 
     if max_cycle_len < 3 || n < 3 {
         // No cycles possible
-        return Some(vec![0; m]);
+        return Some(vec![false; m]);
     }
 
     // Build adjacency list with edge indices
@@ -33,7 +33,7 @@ pub(crate) fn find_witness(problem: &PartialFeedbackEdgeSet<SimpleGraph>) -> Opt
     let cycles = enumerate_short_cycles(n, &adj, max_cycle_len);
 
     if cycles.is_empty() {
-        return Some(vec![0; m]);
+        return Some(vec![false; m]);
     }
 
     // Branch-and-bound: find a set of at most `budget` edges that hits all cycles.
@@ -42,7 +42,7 @@ pub(crate) fn find_witness(problem: &PartialFeedbackEdgeSet<SimpleGraph>) -> Opt
 
     hitting_set_search(&cycles, budget, m, &mut removed, 0, 0, &mut best);
 
-    best.map(|rem| rem.iter().map(|&v| if v { 1 } else { 0 }).collect())
+    best
 }
 
 /// Enumerate all simple cycles of length <= max_len.
diff --git a/src/solvers/customized/rooted_tree_arrangement.rs b/src/solvers/customized/rooted_tree_arrangement.rs
index 330ec983e..8c807e9b1 100644
--- a/src/solvers/customized/rooted_tree_arrangement.rs
+++ b/src/solvers/customized/rooted_tree_arrangement.rs
@@ -8,7 +8,7 @@ use crate::models::graph::RootedTreeArrangement;
 use crate::topology::{Graph, SimpleGraph};
 
 /// Find a witness for RootedTreeArrangement, or None if no solution exists.
-pub(crate) fn find_witness(problem: &RootedTreeArrangement<SimpleGraph>) -> Option<Vec<usize>> {
+pub(crate) fn solve(problem: &RootedTreeArrangement<SimpleGraph>) -> Option<Vec<usize>> {
     let graph = problem.graph();
     let n = graph.num_vertices();
     let bound = problem.bound();
@@ -54,7 +54,7 @@ fn search_trees(
     parent: &mut Vec<usize>,
     edges: &[(usize, usize)],
     adj: &[Vec<usize>],
-    bound: usize,
+    bound: i64,
 ) -> Option<Vec<usize>> {
     if depth_idx == non_root.len() {
         // All parents assigned — validate tree structure and search for mapping
@@ -154,7 +154,7 @@ fn search_mapping(
     depths: &[usize],
     edges: &[(usize, usize)],
     adj: &[Vec<usize>],
-    bound: usize,
+    bound: i64,
 ) -> Option<Vec<usize>> {
     let mut mapping = vec![usize::MAX; n]; // graph vertex -> tree node
     let mut used = vec![false; n]; // which tree nodes are taken
@@ -180,11 +180,11 @@ fn search_mapping_dfs(
     depths: &[usize],
     _edges: &[(usize, usize)],
     adj: &[Vec<usize>],
-    bound: usize,
+    bound: i64,
     mapping: &mut Vec<usize>,
     used: &mut Vec<bool>,
     vertex: usize,
-    partial_stretch: usize,
+    partial_stretch: i64,
 ) -> Option<Vec<usize>> {
     if vertex == n {
         // All vertices assigned
@@ -203,7 +203,7 @@ fn search_mapping_dfs(
 
         // Check ancestor-comparability with all already-mapped neighbors
         let mut valid = true;
-        let mut added_stretch = 0usize;
+        let mut added_stretch = 0_i64;
         for &neighbor in &adj[vertex] {
             if neighbor < vertex && mapping[neighbor] != usize::MAX {
                 let t_neighbor = mapping[neighbor];
@@ -211,7 +211,11 @@ fn search_mapping_dfs(
                     valid = false;
                     break;
                 }
-                added_stretch += depths[tree_node].abs_diff(depths[t_neighbor]);
+                let edge_stretch = i64::try_from(depths[tree_node].abs_diff(depths[t_neighbor]))
+                    .expect("tree depth difference must fit i64");
+                added_stretch = added_stretch
+                    .checked_add(edge_stretch)
+                    .expect("partial rooted-tree stretch must fit i64");
             }
         }
 
@@ -219,7 +223,9 @@ fn search_mapping_dfs(
             continue;
         }
 
-        let new_stretch = partial_stretch + added_stretch;
+        let new_stretch = partial_stretch
+            .checked_add(added_stretch)
+            .expect("partial rooted-tree stretch must fit i64");
         if new_stretch > bound {
             continue;
         }
diff --git a/src/solvers/customized/shortest_common_superstring.rs b/src/solvers/customized/shortest_common_superstring.rs
new file mode 100644
index 000000000..bcca60f3b
--- /dev/null
+++ b/src/solvers/customized/shortest_common_superstring.rs
@@ -0,0 +1,81 @@
+//! Exact shortest common superstring solver using subset dynamic programming.
+
+use crate::models::misc::ShortestCommonSuperstring;
+
+pub(crate) fn solve(problem: &ShortestCommonSuperstring) -> Option<Vec<Option<usize>>> {
+    let mut strings = problem.strings().to_vec();
+    strings.sort();
+    strings.dedup();
+    strings = strings
+        .iter()
+        .enumerate()
+        .filter(|(i, string)| {
+            !strings
+                .iter()
+                .enumerate()
+                .any(|(j, other)| i != &j && contains(other, string))
+        })
+        .map(|(_, string)| string.clone())
+        .collect();
+
+    if strings.is_empty() {
+        return Some(vec![None; problem.max_length()]);
+    }
+
+    let n = strings.len();
+    let mut dp = vec![None::<Vec<usize>>; (1usize << n) * n];
+    for (i, string) in strings.iter().enumerate() {
+        dp[(1 << i) * n + i] = Some(string.clone());
+    }
+
+    for mask in 1usize..(1usize << n) {
+        for last in 0..n {
+            let Some(prefix) = dp[mask * n + last].clone() else {
+                continue;
+            };
+            for next in 0..n {
+                if mask & (1 << next) != 0 {
+                    continue;
+                }
+                let overlap = overlap(&prefix, &strings[next]);
+                let mut candidate = prefix.clone();
+                candidate.extend_from_slice(&strings[next][overlap..]);
+                let slot = &mut dp[((mask | (1 << next)) * n) + next];
+                if slot
+                    .as_ref()
+                    .is_none_or(|current| candidate.len() < current.len())
+                {
+                    *slot = Some(candidate);
+                }
+            }
+        }
+    }
+
+    let full = (1usize << n) - 1;
+    let shortest = (0..n)
+        .filter_map(|last| dp[full * n + last].take())
+        .min_by_key(Vec::len)
+        .unwrap();
+    let mut solution = shortest.into_iter().map(Some).collect::<Vec<_>>();
+    solution.resize(problem.max_length(), None);
+    Some(solution)
+}
+
+fn contains(haystack: &[usize], needle: &[usize]) -> bool {
+    needle.is_empty()
+        || (needle.len() <= haystack.len()
+            && haystack
+                .windows(needle.len())
+                .any(|window| window == needle))
+}
+
+fn overlap(left: &[usize], right: &[usize]) -> usize {
+    (0..=left.len().min(right.len()))
+        .rev()
+        .find(|&length| left[left.len() - length..] == right[..length])
+        .unwrap()
+}
+
+#[cfg(test)]
+#[path = "../../unit_tests/solvers/customized/shortest_common_superstring.rs"]
+mod tests;
diff --git a/src/solvers/customized/solver.rs b/src/solvers/customized/solver.rs
index a980a9bb6..020fd82bc 100644
--- a/src/solvers/customized/solver.rs
+++ b/src/solvers/customized/solver.rs
@@ -1,76 +1,113 @@
-//! CustomizedSolver: structure-exploiting exact witness solver.
-//!
-//! Uses direct downcast dispatch to call dedicated backends for
-//! supported problem types, returning `None` for unsupported problems.
+//! Exact customized solvers and their exact-variant registrations.
 
 use super::fd_subset_search::{
     self, compute_closure, find_essential_attributes, find_essential_attributes_restricted,
     is_minimal_key, is_superkey, BranchDecision,
 };
-use crate::models::graph::{PartialFeedbackEdgeSet, RootedTreeArrangement};
-use crate::models::misc::{AdditionalKey, BoyceCoddNormalFormViolation};
+use crate::models::graph::{
+    MinimumCostCirculation, MinimumIntersectionGraphBasis, PartialFeedbackEdgeSet,
+    RootedTreeArrangement,
+};
+use crate::models::misc::{
+    AdditionalKey, BoyceCoddNormalFormViolation, GroupingBySwapping, MinimumDecisionTree,
+    ShortestCommonSuperstring, TimetableDesign,
+};
 use crate::models::set::{MinimumCardinalityKey, PrimeAttributeName};
+use crate::solvers::registry::CustomizedSolverRegistration;
 use crate::topology::SimpleGraph;
+use crate::traits::Problem;
 use std::collections::HashSet;
 
-/// A solver that uses problem-specific backends for exact witness recovery.
-///
-/// Unlike `BruteForce`, which enumerates all configurations, `CustomizedSolver`
-/// exploits problem structure (functional-dependency closure, cycle hitting,
-/// tree arrangement) to prune search and find witnesses more efficiently.
-///
-/// Returns `None` for unsupported problem types.
-#[derive(Default)]
-pub struct CustomizedSolver;
-
-impl CustomizedSolver {
-    /// Create a new `CustomizedSolver`.
-    pub fn new() -> Self {
-        Self
-    }
-
-    /// Check whether a type-erased problem is supported by the customized solver.
-    pub fn supports_problem(any: &dyn std::any::Any) -> bool {
-        any.is::<MinimumCardinalityKey>()
-            || any.is::<AdditionalKey>()
-            || any.is::<PrimeAttributeName>()
-            || any.is::<BoyceCoddNormalFormViolation>()
-            || any.is::<PartialFeedbackEdgeSet<SimpleGraph>>()
-            || any.is::<RootedTreeArrangement<SimpleGraph>>()
-    }
-
-    /// Attempt to solve a type-erased problem using a dedicated backend.
-    ///
-    /// Returns `Some(config)` if a satisfying witness is found, `None` if
-    /// the problem type is unsupported or no witness exists.
-    pub fn solve_dyn(&self, any: &dyn std::any::Any) -> Option<Vec<usize>> {
-        if let Some(p) = any.downcast_ref::<MinimumCardinalityKey>() {
-            return solve_minimum_cardinality_key(p);
-        }
-        if let Some(p) = any.downcast_ref::<AdditionalKey>() {
-            return solve_additional_key(p);
-        }
-        if let Some(p) = any.downcast_ref::<PrimeAttributeName>() {
-            return solve_prime_attribute_name(p);
-        }
-        if let Some(p) = any.downcast_ref::<BoyceCoddNormalFormViolation>() {
-            return solve_bcnf_violation(p);
-        }
-        if let Some(p) = any.downcast_ref::<PartialFeedbackEdgeSet<SimpleGraph>>() {
-            return super::partial_feedback_edge_set::find_witness(p);
-        }
-        if let Some(p) = any.downcast_ref::<RootedTreeArrangement<SimpleGraph>>() {
-            return super::rooted_tree_arrangement::find_witness(p);
+macro_rules! register_customized_solver {
+    ($problem:ty, $implementation:literal, $solve:expr) => {
+        inventory::submit! {
+            CustomizedSolverRegistration {
+                source_name: <$problem as Problem>::NAME,
+                source_variant_fn: <$problem as Problem>::variant,
+                implementation: $implementation,
+                solve_fn: |any| {
+                    let problem = any.downcast_ref::<$problem>().expect(
+                        "customized solver registration received the wrong concrete type",
+                    );
+                    $solve(problem).map(|solution| {
+                        solution.map(|solution: <$problem as Problem>::Solution| {
+                            serde_json::to_value(solution)
+                                .expect("customized solution serialization must succeed")
+                        })
+                    })
+                },
+            }
         }
-        None
-    }
+    };
 }
 
+register_customized_solver!(
+    MinimumCardinalityKey,
+    "fd-minimum-cardinality-key",
+    |problem| Ok(solve_minimum_cardinality_key(problem))
+);
+register_customized_solver!(AdditionalKey, "fd-additional-key", |problem| Ok(
+    solve_additional_key(problem)
+));
+register_customized_solver!(PrimeAttributeName, "fd-prime-attribute-name", |problem| Ok(
+    solve_prime_attribute_name(problem)
+));
+register_customized_solver!(
+    BoyceCoddNormalFormViolation,
+    "fd-bcnf-violation",
+    |problem| Ok(solve_bcnf_violation(problem))
+);
+register_customized_solver!(
+    PartialFeedbackEdgeSet<SimpleGraph>,
+    "partial-feedback-edge-set",
+    |problem| Ok(super::partial_feedback_edge_set::solve(problem))
+);
+register_customized_solver!(
+    RootedTreeArrangement<SimpleGraph>,
+    "rooted-tree-arrangement",
+    |problem| Ok(super::rooted_tree_arrangement::solve(problem))
+);
+register_customized_solver!(GroupingBySwapping, "symbol-block-order", |problem| Ok(
+    super::grouping_by_swapping::solve(problem)
+));
+register_customized_solver!(ShortestCommonSuperstring, "subset-dp", |problem| Ok(
+    super::shortest_common_superstring::solve(problem)
+));
+register_customized_solver!(MinimumDecisionTree, "subset-dp", |problem| Ok(
+    super::minimum_decision_tree::solve(problem)
+));
+register_customized_solver!(
+    MinimumCostCirculation,
+    "negative-cycle-canceling",
+    |problem| super::minimum_cost_circulation::solve(problem).map(Some)
+);
+register_customized_solver!(
+    MinimumIntersectionGraphBasis<SimpleGraph>,
+    "maximal-clique-edge-cover",
+    |problem| Ok(super::minimum_intersection_graph_basis::solve(problem))
+);
+register_customized_solver!(
+    TimetableDesign,
+    "timetable-required-assignments",
+    |problem| Ok(TimetableDesign::solve_via_required_assignments(problem))
+);
+
+register_customized_solver!(
+    crate::models::algebraic::ClosestVectorProblem<i64>,
+    "cvp-sphere-enumeration",
+    |problem| super::closest_vector_problem::solve(problem).map(Some)
+);
+register_customized_solver!(
+    crate::models::algebraic::ClosestVectorProblem<f64>,
+    "cvp-sphere-enumeration",
+    |problem| super::closest_vector_problem::solve(problem).map(Some)
+);
+
 /// Solve MinimumCardinalityKey: find a minimal key with smallest cardinality.
 ///
 /// Uses iterative deepening by cardinality to guarantee the first solution
 /// found has the minimum number of attributes.
-fn solve_minimum_cardinality_key(problem: &MinimumCardinalityKey) -> Option<Vec<usize>> {
+pub(crate) fn solve_minimum_cardinality_key(problem: &MinimumCardinalityKey) -> Option<Vec<bool>> {
     let n = problem.num_attributes();
     let deps = problem.dependencies().to_vec();
 
@@ -102,9 +139,9 @@ fn solve_minimum_cardinality_key(problem: &MinimumCardinalityKey) -> Option<Vec<
         );
 
         if let Some(indices) = result {
-            let mut config = vec![0; n];
+            let mut config = vec![false; n];
             for i in indices {
-                config[i] = 1;
+                config[i] = true;
             }
             return Some(config);
         }
@@ -113,7 +150,7 @@ fn solve_minimum_cardinality_key(problem: &MinimumCardinalityKey) -> Option<Vec<
 }
 
 /// Solve AdditionalKey: find a candidate key not in the known set.
-fn solve_additional_key(problem: &AdditionalKey) -> Option<Vec<usize>> {
+pub(crate) fn solve_additional_key(problem: &AdditionalKey) -> Option<Vec<bool>> {
     let n_attrs = problem.num_attributes();
     let deps = problem.dependencies().to_vec();
     let relation_attrs = problem.relation_attrs();
@@ -170,13 +207,13 @@ fn solve_additional_key(problem: &AdditionalKey) -> Option<Vec<usize>> {
         let index_set: HashSet<usize> = indices.into_iter().collect();
         relation_attrs
             .iter()
-            .map(|&attr| if index_set.contains(&attr) { 1 } else { 0 })
+            .map(|&attr| index_set.contains(&attr))
             .collect()
     })
 }
 
 /// Solve PrimeAttributeName: find a candidate key containing the query attribute.
-fn solve_prime_attribute_name(problem: &PrimeAttributeName) -> Option<Vec<usize>> {
+pub(crate) fn solve_prime_attribute_name(problem: &PrimeAttributeName) -> Option<Vec<bool>> {
     let n = problem.num_attributes();
     let deps = problem.dependencies().to_vec();
     let query = problem.query_attribute();
@@ -210,9 +247,9 @@ fn solve_prime_attribute_name(problem: &PrimeAttributeName) -> Option<Vec<usize>
     );
 
     result.map(|indices| {
-        let mut config = vec![0; n];
+        let mut config = vec![false; n];
         for i in indices {
-            config[i] = 1;
+            config[i] = true;
         }
         config
     })
@@ -220,7 +257,7 @@ fn solve_prime_attribute_name(problem: &PrimeAttributeName) -> Option<Vec<usize>
 
 /// Solve BoyceCoddNormalFormViolation: find a subset X of target_subset such that
 /// the closure of X contains some but not all of target_subset \ X.
-fn solve_bcnf_violation(problem: &BoyceCoddNormalFormViolation) -> Option<Vec<usize>> {
+pub(crate) fn solve_bcnf_violation(problem: &BoyceCoddNormalFormViolation) -> Option<Vec<bool>> {
     let n_attrs = problem.num_attributes();
     let deps = problem.functional_deps().to_vec();
     let target = problem.target_subset();
@@ -257,7 +294,7 @@ fn solve_bcnf_violation(problem: &BoyceCoddNormalFormViolation) -> Option<Vec<us
         let index_set: HashSet<usize> = indices.into_iter().collect();
         target
             .iter()
-            .map(|&attr| if index_set.contains(&attr) { 1 } else { 0 })
+            .map(|&attr| index_set.contains(&attr))
             .collect()
     })
 }
diff --git a/src/solvers/decision_search.rs b/src/solvers/decision_search.rs
index d69a9804a..7c38fe6ec 100644
--- a/src/solvers/decision_search.rs
+++ b/src/solvers/decision_search.rs
@@ -1,7 +1,7 @@
 //! Decision-guided binary search for optimization via decision queries.
 
 use crate::models::decision::{Decision, DecisionProblemMeta};
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::{Max, Min, OptimizationValue, Or};
 use serde::de::DeserializeOwned;
@@ -9,96 +9,127 @@ use serde::Serialize;
 use std::fmt;
 
 /// Whether a decision problem has at least one satisfying configuration.
-fn is_satisfiable<P>(problem: &P) -> bool
+fn is_satisfiable<P>(problem: &P) -> Result<bool, crate::solvers::SolveError>
 where
-    P: Problem<Value = Or>,
+    P: Problem<Value = Or> + 'static,
+    P::Solution: 'static,
 {
-    BruteForce::new().solve(problem).0
+    Ok(BruteForce::new().solve(problem)?.is_some())
 }
 
-fn solve_via_decision_min<P>(problem: &P, lower: i32, upper: i32) -> Option<i32>
+fn solve_via_decision_min<P>(
+    problem: &P,
+    lower: i64,
+    upper: i64,
+) -> Result<Option<i64>, crate::solvers::SolveError>
 where
-    P: DecisionProblemMeta + Problem<Value = Min<i32>> + Clone,
+    P: DecisionProblemMeta + Problem<Value = Min<i64>> + Clone + 'static,
+    P::Solution: 'static,
 {
     if lower > upper {
-        return None;
+        return Ok(None);
     }
 
-    if !is_satisfiable(&Decision::new(problem.clone(), upper)) {
-        return None;
+    if !is_satisfiable(&Decision::new(problem.clone(), upper))? {
+        return Ok(None);
     }
 
     let mut lo = lower;
     let mut hi = upper;
     while lo < hi {
         let mid = lo + (hi - lo) / 2;
-        if is_satisfiable(&Decision::new(problem.clone(), mid)) {
+        if is_satisfiable(&Decision::new(problem.clone(), mid))? {
             hi = mid;
         } else {
             lo = mid + 1;
         }
     }
 
-    Some(lo)
+    Ok(Some(lo))
 }
 
-fn solve_via_decision_max<P>(problem: &P, lower: i32, upper: i32) -> Option<i32>
+fn solve_via_decision_max<P>(
+    problem: &P,
+    lower: i64,
+    upper: i64,
+) -> Result<Option<i64>, crate::solvers::SolveError>
 where
-    P: DecisionProblemMeta + Problem<Value = Max<i32>> + Clone,
+    P: DecisionProblemMeta + Problem<Value = Max<i64>> + Clone + 'static,
+    P::Solution: 'static,
 {
     if lower > upper {
-        return None;
+        return Ok(None);
     }
 
-    if !is_satisfiable(&Decision::new(problem.clone(), lower)) {
-        return None;
+    if !is_satisfiable(&Decision::new(problem.clone(), lower))? {
+        return Ok(None);
     }
 
     let mut lo = lower;
     let mut hi = upper;
     while lo < hi {
         let mid = lo + (hi - lo + 1) / 2;
-        if is_satisfiable(&Decision::new(problem.clone(), mid)) {
+        if is_satisfiable(&Decision::new(problem.clone(), mid))? {
             lo = mid;
         } else {
             hi = mid - 1;
         }
     }
 
-    Some(lo)
+    Ok(Some(lo))
 }
 
 #[doc(hidden)]
 pub trait DecisionSearchValue:
-    OptimizationValue<Inner = i32> + Clone + fmt::Debug + Serialize + DeserializeOwned
+    OptimizationValue<Inner = i64> + Clone + fmt::Debug + Serialize + DeserializeOwned
 {
-    fn solve_problem<P>(problem: &P, lower: i32, upper: i32) -> Option<i32>
+    fn solve_problem<P>(
+        problem: &P,
+        lower: i64,
+        upper: i64,
+    ) -> Result<Option<i64>, crate::solvers::SolveError>
     where
-        P: DecisionProblemMeta + Problem<Value = Self> + Clone;
+        P: DecisionProblemMeta + Problem<Value = Self> + Clone + 'static,
+        P::Solution: 'static;
 }
 
-impl DecisionSearchValue for Min<i32> {
-    fn solve_problem<P>(problem: &P, lower: i32, upper: i32) -> Option<i32>
+impl DecisionSearchValue for Min<i64> {
+    fn solve_problem<P>(
+        problem: &P,
+        lower: i64,
+        upper: i64,
+    ) -> Result<Option<i64>, crate::solvers::SolveError>
     where
-        P: DecisionProblemMeta + Problem<Value = Self> + Clone,
+        P: DecisionProblemMeta + Problem<Value = Self> + Clone + 'static,
+        P::Solution: 'static,
     {
         solve_via_decision_min(problem, lower, upper)
     }
 }
 
-impl DecisionSearchValue for Max<i32> {
-    fn solve_problem<P>(problem: &P, lower: i32, upper: i32) -> Option<i32>
+impl DecisionSearchValue for Max<i64> {
+    fn solve_problem<P>(
+        problem: &P,
+        lower: i64,
+        upper: i64,
+    ) -> Result<Option<i64>, crate::solvers::SolveError>
     where
-        P: DecisionProblemMeta + Problem<Value = Self> + Clone,
+        P: DecisionProblemMeta + Problem<Value = Self> + Clone + 'static,
+        P::Solution: 'static,
     {
         solve_via_decision_max(problem, lower, upper)
     }
 }
 
 /// Recover an optimization value by querying the problem's decision wrapper.
-pub fn solve_via_decision<P>(problem: &P, lower: i32, upper: i32) -> Option<i32>
+pub fn solve_via_decision<P>(
+    problem: &P,
+    lower: i64,
+    upper: i64,
+) -> Result<Option<i64>, crate::solvers::SolveError>
 where
-    P: DecisionProblemMeta + Clone,
+    P: DecisionProblemMeta + Clone + 'static,
+    P::Solution: 'static,
     P::Value: DecisionSearchValue,
 {
     <P::Value as DecisionSearchValue>::solve_problem(problem, lower, upper)
diff --git a/src/solvers/ilp/mod.rs b/src/solvers/ilp/mod.rs
index b09109814..55556679e 100644
--- a/src/solvers/ilp/mod.rs
+++ b/src/solvers/ilp/mod.rs
@@ -2,26 +2,7 @@
 //!
 //! This module provides an ILP solver using the HiGHS solver via the `good_lp` crate.
 //! It is only available when the `ilp` feature is enabled.
-//!
-//! # Example
-//!
-//! ```rust,ignore
-//! use problemreductions::models::algebraic::{ILP, LinearConstraint, ObjectiveSense};
-//! use problemreductions::solvers::ILPSolver;
-//!
-//! // Create a simple binary ILP: maximize x0 + 2*x1 subject to x0 + x1 <= 1
-//! let ilp = ILP::<bool>::new(
-//!     2,
-//!     vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-//!     vec![(0, 1.0), (1, 2.0)],
-//!     ObjectiveSense::Maximize,
-//! );
-//!
-//! let solver = ILPSolver::new();
-//! let solution = solver.solve(&ilp);
-//! ```
 
 mod solver;
 
-pub use solver::ILPSolver;
-pub use solver::SolveViaReductionError;
+pub use solver::{ILPSolveError, ILPSolver};
diff --git a/src/solvers/ilp/solver.rs b/src/solvers/ilp/solver.rs
index 155030676..e5325a29f 100644
--- a/src/solvers/ilp/solver.rs
+++ b/src/solvers/ilp/solver.rs
@@ -1,38 +1,96 @@
 //! ILP solver implementation using HiGHS.
 
 use crate::models::algebraic::{Comparison, ObjectiveSense, VariableDomain, ILP};
-use crate::models::misc::TimetableDesign;
-use crate::rules::{ReduceTo, ReductionMode, ReductionResult};
-#[cfg(not(feature = "ilp-highs"))]
-use good_lp::default_solver;
-#[cfg(feature = "ilp-highs")]
+use crate::solvers::registry::solver_capability_registry;
+use crate::solvers::ExactProblemKey;
+use crate::traits::Problem;
+use crate::types::{i64_to_exact_f64, MAX_EXACT_F64_INTEGER};
 use good_lp::highs;
-#[cfg(feature = "ilp-highs")]
 use good_lp::solvers::highs::HighsParallelType;
-use good_lp::{variable, ProblemVariables, Solution, SolverModel, Variable};
+use good_lp::{
+    variable, ProblemVariables, ResolutionError, Solution, SolutionStatus, SolverModel, Variable,
+};
+
+/// A failure to produce an ILP solution optimal within backend numerical tolerances.
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+pub enum ILPSolveError {
+    /// The constraints have no feasible assignment.
+    #[error("the ILP is infeasible")]
+    Infeasible,
+    /// A target witness did not establish the source decision threshold.
+    #[error(
+        "the ILP witness does not meet the decision threshold for {0}; the decision is unresolved"
+    )]
+    UnresolvedDecision(String),
+    /// The objective is unbounded.
+    #[error("the ILP objective is unbounded")]
+    Unbounded,
+    /// The configured time limit was reached before optimality was proven.
+    #[error("the ILP solver reached its time limit before proving optimality")]
+    Timeout,
+    /// The selected backend failed for another reason.
+    #[error("the ILP backend failed: {0}")]
+    BackendFailure(String),
+    /// Type-erased dispatch received a value other than a supported ILP variant.
+    #[error("the ILP backend requires bool/i64 variables and f64 coefficients")]
+    UnsupportedProblemType,
+    /// No ILP pipeline is registered for the exact problem variant.
+    #[error("no ILP pipeline is registered for {0}")]
+    MissingPipeline(String),
+    /// The solver capability registry is invalid.
+    #[error("solver capability registry is invalid: {0}")]
+    InvalidRegistry(String),
+    /// A registered pipeline returned a solution for a different source type.
+    #[error("registered ILP pipeline returned the wrong solution type for {0}")]
+    PipelineTypeMismatch(String),
+    /// HiGHS reported an optimal solution that is invalid after integer rounding.
+    #[error("the ILP backend returned an invalid rounded solution: {0}")]
+    InvalidSolution(String),
+    /// An exact integer in the model cannot be transported through the f64 backend API.
+    #[error("the ILP backend cannot represent an exact model integer: {0}")]
+    InexactTransport(#[from] crate::types::ExactI64ToF64Error),
+    /// A target witness could not be mapped back to the source problem.
+    #[error(transparent)]
+    Extraction(#[from] crate::rules::ExtractionError),
+    /// A registered reduction could not construct its target instance.
+    #[error(transparent)]
+    Reduction(#[from] crate::rules::ReductionError),
+}
+
+fn classify_backend_error(error: ResolutionError, time_limit: Option<f64>) -> ILPSolveError {
+    match error {
+        ResolutionError::Infeasible => ILPSolveError::Infeasible,
+        ResolutionError::Unbounded => ILPSolveError::Unbounded,
+        ResolutionError::Other("NoSolutionFound") if time_limit.is_some() => ILPSolveError::Timeout,
+        other => ILPSolveError::BackendFailure(other.to_string()),
+    }
+}
 
 /// An ILP solver using the HiGHS backend.
 ///
-/// This solver solves Integer Linear Programming problems directly using the HiGHS solver.
+/// Registered reductions map a source problem to an `ILP<V, f64>` terminal,
+/// which this solver sends to HiGHS before extracting the source solution.
+/// Optimality and infeasibility are assessed within HiGHS numerical tolerances.
+/// Zero MIP gaps do not make floating-point solving mathematically exact.
 ///
 /// # Example
 ///
-/// ```rust,ignore
+/// ```rust
 /// use problemreductions::models::algebraic::{ILP, LinearConstraint, ObjectiveSense};
 /// use problemreductions::solvers::ILPSolver;
 ///
 /// // Create a simple binary ILP: maximize x0 + 2*x1 subject to x0 + x1 <= 1
-/// let ilp = ILP::<bool>::new(
+/// let ilp = ILP::<bool, f64>::new(
 ///     2,
 ///     vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
 ///     vec![(0, 1.0), (1, 2.0)],
 ///     ObjectiveSense::Maximize,
-/// );
+/// )?;
 ///
 /// let solver = ILPSolver::new();
-/// if let Some(solution) = solver.solve(&ilp) {
-///     println!("Solution: {:?}", solution);
-/// }
+/// let solution = solver.solve(&ilp)?;
+/// println!("Solution: {:?}", solution);
+/// # Ok::<(), Box<dyn std::error::Error>>(())
 /// ```
 #[derive(Debug, Clone, Default)]
 pub struct ILPSolver {
@@ -40,33 +98,6 @@ pub struct ILPSolver {
     pub time_limit: Option<f64>,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum SolveViaReductionError {
-    WitnessPathRequired { name: String },
-    NoReductionPath { name: String },
-    NoSolution { name: String },
-}
-
-impl std::fmt::Display for SolveViaReductionError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            SolveViaReductionError::WitnessPathRequired { name } => write!(
-                f,
-                "ILP solving requires a witness-capable source problem and reduction path; only aggregate-value solving is available for {}.",
-                name
-            ),
-            SolveViaReductionError::NoReductionPath { name } => {
-                write!(f, "No reduction path from {} to ILP", name)
-            }
-            SolveViaReductionError::NoSolution { name } => {
-                write!(f, "ILP solver found no solution for {}", name)
-            }
-        }
-    }
-}
-
-impl std::error::Error for SolveViaReductionError {}
-
 impl ILPSolver {
     /// Create a new ILP solver with default settings.
     pub fn new() -> Self {
@@ -80,68 +111,87 @@ impl ILPSolver {
         }
     }
 
-    /// Solve an ILP problem directly.
+    /// Solve a problem through its registered ILP pipeline.
     ///
-    /// Returns `None` if the problem is infeasible or the solver fails.
-    /// The returned solution is a configuration vector where each element
-    /// is the variable value (config index = value).
-    pub fn solve<V: VariableDomain>(&self, problem: &ILP<V>) -> Option<Vec<usize>> {
-        let n = problem.num_vars;
-        if n == 0 {
-            return problem.is_feasible(&[]).then_some(vec![]);
-        }
+    /// Returns a classified error when the problem is infeasible, the time
+    /// limit is reached, the pipeline is missing, or the backend fails.
+    pub fn solve<P>(&self, problem: &P) -> Result<P::Solution, ILPSolveError>
+    where
+        P: Problem + 'static,
+        P::Solution: 'static,
+    {
+        let key = ExactProblemKey::new(P::NAME, crate::export::variant_to_map(P::variant()));
+        let registry = solver_capability_registry()
+            .map_err(|error| ILPSolveError::InvalidRegistry(error.to_string()))?;
+        let pipeline = registry
+            .lookup(&key)
+            .ilp
+            .ok_or_else(|| ILPSolveError::MissingPipeline(key.label()))?;
+        pipeline.solve_typed(problem, self)
+    }
 
-        // Derive tighter per-variable upper bounds from single-variable ≤ constraints.
-        // This avoids giving HiGHS the full domain (e.g. 2^31 for i32), which can
-        // cause severe performance degradation even when constraints already bound
-        // the variable to a small range.
-        let default_ub = (V::DIMS_PER_VAR - 1) as f64;
-        let mut upper_bounds = vec![default_ub; n];
-        for constraint in &problem.constraints {
-            if constraint.cmp == crate::models::algebraic::Comparison::Le
-                && constraint.terms.len() == 1
+    fn solve_backend<V>(&self, problem: &ILP<V, f64>) -> Result<Vec<i64>, ILPSolveError>
+    where
+        V: VariableDomain,
+    {
+        self.solve_with_objective(problem, problem.objective())
+    }
+
+    fn solve_with_objective<V>(
+        &self,
+        problem: &ILP<V, f64>,
+        objective_terms: &[(usize, f64)],
+    ) -> Result<Vec<i64>, ILPSolveError>
+    where
+        V: VariableDomain,
+    {
+        let n = problem.num_vars();
+        if n == 0 {
+            return if problem
+                .is_feasible(&[])
+                .map_err(|error| ILPSolveError::InvalidSolution(error.to_string()))?
             {
-                let (var_idx, coef) = constraint.terms[0];
-                if coef > 0.0 && var_idx < n {
-                    let ub = constraint.rhs / coef;
-                    if ub < upper_bounds[var_idx] {
-                        upper_bounds[var_idx] = ub;
-                    }
-                }
-            }
+                Ok(vec![])
+            } else {
+                Err(ILPSolveError::Infeasible)
+            };
         }
 
-        // Create integer variables with tightened bounds
         let mut vars_builder = ProblemVariables::new();
-        let vars: Vec<Variable> = (0..n)
-            .map(|i| {
-                let mut v = variable().integer();
-                v = v.min(0.0);
-                v = v.max(upper_bounds[i]);
-                vars_builder.add(v)
+        let vars: Vec<Variable> = problem
+            .variables()
+            .iter()
+            .map(|variable_bounds| {
+                let mut definition = variable().integer();
+                if let Some(lower) = variable_bounds.lower_bound() {
+                    definition = definition.min(i64_to_exact_f64(lower)?);
+                }
+                if let Some(upper) = variable_bounds.upper_bound() {
+                    definition = definition.max(i64_to_exact_f64(upper)?);
+                }
+                Ok(vars_builder.add(definition))
             })
-            .collect();
+            .collect::<Result<_, ILPSolveError>>()?;
 
         // Build objective expression
-        let objective: good_lp::Expression = problem
-            .objective
+        let objective: good_lp::Expression = objective_terms
             .iter()
-            .map(|&(var_idx, coef)| coef * vars[var_idx])
+            .map(|&(var_idx, coefficient)| coefficient * vars[var_idx])
             .sum();
 
         // Build the model with objective
-        let unsolved = match problem.sense {
+        let unsolved = match problem.sense() {
             ObjectiveSense::Maximize => vars_builder.maximise(&objective),
             ObjectiveSense::Minimize => vars_builder.minimise(&objective),
         };
 
         // Create the solver model
-        #[cfg(feature = "ilp-highs")]
         let mut model = {
             let mut model = unsolved
                 .using(highs)
                 .set_option("random_seed", 0i32)
-                .set_option("presolve", "off")
+                .set_option("mip_rel_gap", 0.0)
+                .set_option("mip_abs_gap", 0.0)
                 .set_parallel(HighsParallelType::Off)
                 .set_threads(1);
             if let Some(seconds) = self.time_limit {
@@ -150,200 +200,99 @@ impl ILPSolver {
             model
         };
 
-        #[cfg(not(feature = "ilp-highs"))]
-        let mut model = unsolved.using(default_solver);
-
         // Add constraints
-        for constraint in &problem.constraints {
+        for constraint in problem.constraints() {
             // Build left-hand side expression
             let lhs: good_lp::Expression = constraint
-                .terms
+                .terms()
                 .iter()
-                .map(|&(var_idx, coef)| coef * vars[var_idx])
+                .map(|&(var_idx, coefficient)| coefficient * vars[var_idx])
                 .sum();
 
+            let rhs = constraint.rhs();
+
             // Create the constraint based on comparison type
-            let good_lp_constraint = match constraint.cmp {
-                Comparison::Le => lhs.leq(constraint.rhs),
-                Comparison::Ge => lhs.geq(constraint.rhs),
-                Comparison::Eq => lhs.eq(constraint.rhs),
+            let good_lp_constraint = match constraint.comparison() {
+                Comparison::Le => lhs.leq(rhs),
+                Comparison::Ge => lhs.geq(rhs),
+                Comparison::Eq => lhs.eq(rhs),
             };
 
             model = model.with(good_lp_constraint);
         }
 
         // Solve
-        let solution = model.solve().ok()?;
-
-        // Extract solution: config index = value (no lower bound offset)
-        let result: Vec<usize> = vars
-            .iter()
-            .map(|v| {
-                let val = solution.value(*v);
-                val.round().max(0.0) as usize
-            })
-            .collect();
-
-        Some(result)
-    }
-
-    /// Solve any problem that reduces to `ILP<bool>`.
-    ///
-    /// This method first reduces the problem to a binary ILP, solves the ILP,
-    /// and then extracts the solution back to the original problem space.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use problemreductions::prelude::*;
-    /// use problemreductions::solvers::ILPSolver;
-    ///
-    /// // Create a problem that reduces directly to ILP.
-    /// let problem = MaximumSetPacking::<i32>::new(vec![
-    ///     vec![0, 1],
-    ///     vec![1, 2],
-    ///     vec![3, 4],
-    /// ]);
-    ///
-    /// // Solve using ILP solver
-    /// let solver = ILPSolver::new();
-    /// if let Some(solution) = solver.solve_reduced(&problem) {
-    ///     println!("Solution: {:?}", solution);
-    /// }
-    /// ```
-    pub fn solve_reduced<P>(&self, problem: &P) -> Option<Vec<usize>>
-    where
-        P: ReduceTo<ILP<bool>>,
-    {
-        let reduction = problem.reduce_to();
-        let ilp_solution = self.solve(reduction.target_problem())?;
-        Some(reduction.extract_solution(&ilp_solution))
-    }
+        let solution = match model.solve() {
+            Ok(solution) => solution,
+            Err(ResolutionError::Infeasible)
+                if !objective_terms.is_empty()
+                    && problem.variables().iter().any(|variable| {
+                        variable.lower_bound().is_none() || variable.upper_bound().is_none()
+                    }) =>
+            {
+                // A zero objective cannot be unbounded, so feasibility distinguishes the two states.
+                self.solve_with_objective(problem, &[])?;
+                return Err(ILPSolveError::Unbounded);
+            }
+            Err(error) => return Err(classify_backend_error(error, self.time_limit)),
+        };
 
-    /// Solve a type-erased problem directly when a native solver hook exists.
-    ///
-    /// Returns `None` if the input type has no direct solver or the solver finds no solution.
-    pub fn solve_dyn(&self, any: &dyn std::any::Any) -> Option<Vec<usize>> {
-        if let Some(ilp) = any.downcast_ref::<ILP<bool>>() {
-            return self.solve(ilp);
-        }
-        if let Some(ilp) = any.downcast_ref::<ILP<i32>>() {
-            return self.solve(ilp);
-        }
-        if let Some(problem) = any.downcast_ref::<TimetableDesign>() {
-            return problem.solve_via_required_assignments();
+        match solution.status() {
+            SolutionStatus::Optimal => {}
+            SolutionStatus::TimeLimit => return Err(ILPSolveError::Timeout),
+            SolutionStatus::GapLimit => {
+                return Err(ILPSolveError::BackendFailure(
+                    "the backend stopped at its gap limit before proving optimality".to_string(),
+                ));
+            }
         }
-        None
-    }
 
-    fn supports_direct_dyn(&self, any: &dyn std::any::Any) -> bool {
-        any.is::<ILP<bool>>() || any.is::<ILP<i32>>() || any.is::<TimetableDesign>()
-    }
-
-    /// Two-level path selection:
-    /// 1. Dijkstra finds the cheapest path to each ILP variant using
-    ///    `MinimizeStepsThenOverhead` (additive edge costs: step count + log overhead).
-    /// 2. Across ILP variants, we pick the path whose composed final output size
-    ///    is smallest — this is the actual ILP problem size the solver will face.
-    fn best_path_to_ilp(
-        &self,
-        graph: &crate::rules::ReductionGraph,
-        name: &str,
-        variant: &std::collections::BTreeMap<String, String>,
-        mode: ReductionMode,
-        instance: &dyn std::any::Any,
-    ) -> Option<crate::rules::ReductionPath> {
-        let ilp_variants = graph.variants_for("ILP");
-        let input_size = crate::rules::ReductionGraph::compute_source_size(name, variant, instance);
-        let mut best_path: Option<crate::rules::ReductionPath> = None;
-        let mut best_cost = f64::INFINITY;
-
-        for dv in &ilp_variants {
-            if let Some(path) = graph.find_cheapest_path_mode(
-                name,
-                variant,
-                "ILP",
-                dv,
-                mode,
-                &input_size,
-                &crate::rules::MinimizeStepsThenOverhead,
-            ) {
-                // Use composed final output size for cross-variant comparison,
-                // since this determines the actual ILP problem size.
-                let final_size = graph
-                    .evaluate_path_overhead(&path, &input_size)
-                    .unwrap_or_default();
-                let cost = final_size.total() as f64;
-                if cost < best_cost {
-                    best_cost = cost;
-                    best_path = Some(path);
+        let result: Vec<i64> = vars
+            .iter()
+            .enumerate()
+            .map(|(index, v)| {
+                let value = solution.value(*v);
+                if !value.is_finite() {
+                    return Err(ILPSolveError::InvalidSolution(format!(
+                        "variable {index} is non-finite"
+                    )));
                 }
-            }
+                let rounded = value.round();
+                if (value - rounded).abs() > 1e-6 {
+                    return Err(ILPSolveError::InvalidSolution(format!(
+                        "variable {index} has non-integral value {value}"
+                    )));
+                }
+                if rounded.abs() > MAX_EXACT_F64_INTEGER as f64 {
+                    return Err(ILPSolveError::InvalidSolution(format!(
+                        "variable {index} value {rounded} exceeds exact f64 integer transport"
+                    )));
+                }
+                Ok(rounded as i64)
+            })
+            .collect::<Result<_, _>>()?;
+
+        if !problem
+            .is_feasible(&result)
+            .map_err(|error| ILPSolveError::InvalidSolution(error.to_string()))?
+        {
+            return Err(ILPSolveError::InvalidSolution(
+                "the rounded assignment violates the ILP".into(),
+            ));
         }
 
-        best_path
+        Ok(result)
     }
 
-    pub fn try_solve_via_reduction(
-        &self,
-        name: &str,
-        variant: &std::collections::BTreeMap<String, String>,
-        instance: &dyn std::any::Any,
-    ) -> Result<Vec<usize>, SolveViaReductionError> {
-        if self.supports_direct_dyn(instance) {
-            return self
-                .solve_dyn(instance)
-                .ok_or_else(|| SolveViaReductionError::NoSolution {
-                    name: name.to_string(),
-                });
+    /// Solve a type-erased supported ILP variant directly.
+    pub(crate) fn solve_dyn(&self, any: &dyn std::any::Any) -> Result<Vec<i64>, ILPSolveError> {
+        if let Some(ilp) = any.downcast_ref::<ILP<bool, f64>>() {
+            return self.solve_backend(ilp);
         }
-
-        let graph = crate::rules::ReductionGraph::new();
-
-        let Some(path) =
-            self.best_path_to_ilp(&graph, name, variant, ReductionMode::Witness, instance)
-        else {
-            if self
-                .best_path_to_ilp(&graph, name, variant, ReductionMode::Aggregate, instance)
-                .is_some()
-            {
-                return Err(SolveViaReductionError::WitnessPathRequired {
-                    name: name.to_string(),
-                });
-            }
-
-            return Err(SolveViaReductionError::NoReductionPath {
-                name: name.to_string(),
-            });
-        };
-
-        let chain = graph.reduce_along_path(&path, instance).ok_or_else(|| {
-            SolveViaReductionError::WitnessPathRequired {
-                name: name.to_string(),
-            }
-        })?;
-        let ilp_solution = self.solve_dyn(chain.target_problem_any()).ok_or_else(|| {
-            SolveViaReductionError::NoSolution {
-                name: name.to_string(),
-            }
-        })?;
-        Ok(chain.extract_solution(&ilp_solution))
-    }
-
-    /// Solve a type-erased problem by finding a reduction path to ILP.
-    ///
-    /// Tries all ILP variants, picks the cheapest path, reduces, solves,
-    /// and extracts the solution back. Falls back to direct ILP solve if
-    /// the problem is already an ILP type.
-    ///
-    /// Returns `None` if no path to ILP exists or the solver finds no solution.
-    pub fn solve_via_reduction(
-        &self,
-        name: &str,
-        variant: &std::collections::BTreeMap<String, String>,
-        instance: &dyn std::any::Any,
-    ) -> Option<Vec<usize>> {
-        self.try_solve_via_reduction(name, variant, instance).ok()
+        if let Some(ilp) = any.downcast_ref::<ILP<i64, f64>>() {
+            return self.solve_backend(ilp);
+        }
+        Err(ILPSolveError::UnsupportedProblemType)
     }
 }
 
diff --git a/src/solvers/mod.rs b/src/solvers/mod.rs
index 9a1283cfc..a0e39a160 100644
--- a/src/solvers/mod.rs
+++ b/src/solvers/mod.rs
@@ -1,25 +1,54 @@
 //! Solvers for computational problems.
 
 mod brute_force;
-pub mod customized;
+pub(crate) mod customized;
 pub mod decision_search;
+mod pipelines;
+mod registry;
+mod resolver;
 
-#[cfg(feature = "ilp-solver")]
 pub mod ilp;
 
-pub use brute_force::BruteForce;
-pub use customized::CustomizedSolver;
+#[doc(hidden)]
+pub use brute_force::BruteForceRegistration;
+pub use brute_force::{BruteForce, BruteForceProblem};
+pub use registry::{
+    brute_force_dimensions, solver_capabilities, CustomizedSolverCapability, ExactProblemKey,
+    IlpSolverCapability, RegistryBuildError, SolverCapabilities,
+};
+pub use resolver::{solve, SolveOutcome, SolveResult, SolverExecution, SolverRequest};
 
-#[cfg(feature = "ilp-solver")]
-pub use ilp::ILPSolver;
+pub use ilp::{ILPSolveError, ILPSolver};
 
-use crate::traits::Problem;
-
-/// Trait for problem solvers.
-pub trait Solver {
-    /// Solve a problem to its aggregate value.
-    fn solve<P>(&self, problem: &P) -> P::Value
-    where
-        P: Problem,
-        P::Value: crate::types::Aggregate;
+/// Failure while solving a valid problem instance.
+#[derive(Debug, thiserror::Error)]
+pub enum SolveError {
+    #[error("configuration evaluation failed: {0}")]
+    Evaluation(#[from] crate::traits::EvaluationError),
+    #[error("aggregate combination failed: {0}")]
+    Aggregation(#[from] crate::types::AggregationError),
+    #[error("no reference-solver registration for {0}")]
+    MissingRegistration(String),
+    #[error("invalid reference-solver registration: {0}")]
+    RegistrationTypeMismatch(String),
+    #[error("brute-force search space cardinality exceeds usize for dimensions {0:?}")]
+    SearchSpaceOverflow(Vec<usize>),
+    #[error("integer overflow while {0}")]
+    IntegerOverflow(String),
+    #[error("inexact integer-to-float conversion: {0}")]
+    InexactFloatConversion(#[from] crate::types::ExactI64ToF64Error),
+    #[error("non-finite floating-point result while {0}")]
+    NonFiniteResult(String),
+    #[error("solver capability registry is invalid: {0}")]
+    InvalidRegistry(&'static RegistryBuildError),
+    #[error("No ILP pipeline is registered for {0}")]
+    MissingIlpCapability(String),
+    #[error("No customized solver is registered for {0}")]
+    MissingCustomizedCapability(String),
+    #[error("ILP solver failed for {problem}: {source}")]
+    IlpSolve {
+        problem: String,
+        #[source]
+        source: ILPSolveError,
+    },
 }
diff --git a/src/solvers/pipelines.rs b/src/solvers/pipelines.rs
new file mode 100644
index 000000000..15e5aa525
--- /dev/null
+++ b/src/solvers/pipelines.rs
@@ -0,0 +1,985 @@
+//! Fixed ILP pipelines registered for exact problem variants.
+//!
+//! These declarations are executable production metadata. Runtime solving
+//! resolves them once to exact reduction function pointers and never searches
+//! the reduction graph.
+
+use super::registry::{IlpPipelineRegistration, StaticProblemStep};
+
+macro_rules! register_ilp_pipeline {
+    ($(($name:literal, [$(($key:literal, $value:literal)),* $(,)?])),+ $(,)?) => {
+        inventory::submit! {
+            IlpPipelineRegistration {
+                path: &[
+                    $(StaticProblemStep {
+                        name: $name,
+                        variant: &[$(($key, $value)),*],
+                    }),+
+                ],
+            }
+        }
+    };
+}
+
+register_ilp_pipeline! {
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("AcyclicPartition", [("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("BMF", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("BalancedCompleteBipartiteSubgraph", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("BicliqueCover", []),
+    ("BMF", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("BiconnectivityAugmentation", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("BinPacking", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("BottleneckTravelingSalesman", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("BoundedComponentSpanningForest", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("CapacityAssignment", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("CircuitSAT", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ClosestString", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ClosestSubstring", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("Clustering", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ConsecutiveBlockMinimization", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ConsecutiveOnesMatrixAugmentation", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ConsecutiveOnesSubmatrix", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ConsistencyOfDatabaseFrequencyTables", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("DecisionMinimumDominatingSet", [("graph", "SimpleGraph"), ("weight", "One")]),
+    ("MinimumSumMulticenter", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("DecisionMinimumDominatingSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MinimumDominatingSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("DecisionMinimumVertexCover", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MinimumVertexCover", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MinimumSetCovering", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("DecisionOptimalLinearArrangement", [("graph", "SimpleGraph")]),
+    ("OptimalLinearArrangement", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("DirectedHamiltonianPath", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("DirectedTwoCommodityIntegralFlow", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("DisjointConnectingPaths", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("EnsembleComputation", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("EulerianPath", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ExactCoverBy3Sets", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ExpectedRetrievalCost", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("Factoring", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("FeasibleRegisterAssignment", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("FlowShopScheduling", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("GraphPartitioning", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("HamiltonianCircuit", [("graph", "SimpleGraph")]),
+    ("LongestCircuit", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("HamiltonianPath", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("HighlyConnectedDeletion", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+// This exact variant also has a customized backend. Default dispatch selects the
+// customized registration, while an explicit ILP override executes this pipeline.
+register_ilp_pipeline! {
+    ("RootedTreeArrangement", [("graph", "SimpleGraph")]),
+    ("RootedTreeStorageAssignment", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("IntegralFlowBundles", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("IntegralFlowHomologousArcs", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("IntegralFlowWithMultipliers", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("IsomorphicSpanningTree", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("KClique", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("KColoring", [("graph", "SimpleGraph"), ("k", "KN")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("KColoring", [("graph", "SimpleGraph"), ("k", "K3")]),
+    ("Clustering", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("KSatisfiability", [("k", "KN")]),
+    ("Satisfiability", []),
+    ("NAESatisfiability", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("Knapsack", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("LengthBoundedDisjointPaths", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("LongestCircuit", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("LongestCommonSubsequence", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("LongestPath", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximalIS", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("Maximum2Satisfiability", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumClique", [("graph", "SimpleGraph"), ("weight", "One")]),
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "One")]),
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MaximumSetPacking", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumClique", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumCoKPlex", [("graph", "SimpleGraph"), ("k", "KN"), ("weight", "One")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumCoKPlex", [("graph", "SimpleGraph"), ("k", "KN"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumCommonEdgeSubgraph", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumContactMapOverlap", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumDomaticNumber", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumEdgeWeightedKClique", [("weight", "f64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumEdgeWeightedKClique", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "One")]),
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MaximumSetPacking", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumIndependentSet", [("graph", "KingsSubgraph"), ("weight", "One")]),
+    ("MaximumIndependentSet", [("graph", "UnitDiskGraph"), ("weight", "One")]),
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "One")]),
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MaximumClique", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MaximumSetPacking", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumIndependentSet", [("graph", "UnitDiskGraph"), ("weight", "One")]),
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "One")]),
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MaximumClique", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumIndependentSet", [("graph", "KingsSubgraph"), ("weight", "i64")]),
+    ("MaximumIndependentSet", [("graph", "UnitDiskGraph"), ("weight", "i64")]),
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MaximumClique", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumIndependentSet", [("graph", "TriangularSubgraph"), ("weight", "i64")]),
+    ("MaximumIndependentSet", [("graph", "UnitDiskGraph"), ("weight", "i64")]),
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MaximumClique", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumIndependentSet", [("graph", "UnitDiskGraph"), ("weight", "i64")]),
+    ("MaximumIndependentSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MaximumClique", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumLeafSpanningTree", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumLikelihoodRanking", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumMatching", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumSetPacking", [("weight", "One")]),
+    ("MaximumSetPacking", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumSetPacking", [("weight", "f64")]),
+    ("QUBO", [("weight", "f64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MaximumSetPacking", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinMaxMulticenter", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumCapacitatedSpanningTree", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumCoveringByCliques", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumCutIntoBoundedSets", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumDiscretePlanarInverseKinematics", []),
+    ("QUBO", [("weight", "f64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumDominatingSet", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumEdgeCostFlow", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumExternalMacroDataCompression", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumFaultDetectionTestSet", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumFeedbackArcSet", [("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumFeedbackVertexSet", [("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumGraphBandwidth", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumHittingSet", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumInternalMacroDataCompression", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumMatrixCover", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumMaximalMatching", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumMetricDimension", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumMultiwayCut", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumSetCovering", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumSumMulticenter", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumTardinessSequencing", [("weight", "One")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumTardinessSequencing", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumVertexCover", [("graph", "SimpleGraph"), ("weight", "One")]),
+    ("MinimumHittingSet", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumVertexCover", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("MinimumSetCovering", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MinimumWeightDecoding", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MixedChinesePostman", [("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MonochromaticTriangle", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MultipleCopyFileAllocation", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MultipleChoiceBranching", [("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("MultiprocessorScheduling", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("NAESatisfiability", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("Numerical3DimensionalMatching", []),
+    ("NumericalMatchingWithTargetSums", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("NumericalMatchingWithTargetSums", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("OpenShopScheduling", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("OptimalLinearArrangement", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("OptimumCommunicationSpanningTree", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("PaintShop", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("PartiallyOrderedKnapsack", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("Partition", []),
+    ("MultiprocessorScheduling", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("PartitionIntoCliques", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("PartitionIntoPathsOfLength2", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("PartitionIntoTriangles", [("graph", "SimpleGraph")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("PathConstrainedNetworkFlow", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("PrecedenceConstrainedScheduling", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("PreemptiveScheduling", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("QUBO", [("weight", "f64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("QUBO", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("QuadraticAssignment", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("RectilinearPictureCompression", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("RegisterSufficiency", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ResourceConstrainedScheduling", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("RootedTreeStorageAssignment", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("RuralPostman", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("Satisfiability", []),
+    ("NAESatisfiability", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SchedulingToMinimizeWeightedCompletionTime", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SchedulingWithIndividualDeadlines", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SequencingToMinimizeMaximumCumulativeCost", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SequencingToMinimizeTardyTaskWeight", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SequencingToMinimizeWeightedTardiness", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SequencingWithDeadlinesAndSetUpTimes", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SequencingWithReleaseTimesAndDeadlines", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SequencingWithinIntervals", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SetSplitting", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ShortestCommonSupersequence", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ShortestWeightConstrainedPath", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SparseMatrixCompression", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SpinGlass", [("graph", "SimpleGraph"), ("weight", "f64")]),
+    ("QUBO", [("weight", "f64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SpinGlass", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("QUBO", [("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("StackerCrane", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("StringToStringCorrection", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("StrongConnectivityAugmentation", [("weight", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SubgraphIsomorphism", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("SumOfSquaresPartition", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ThreeDimensionalMatching", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("ThreePartition", []),
+    ("ResourceConstrainedScheduling", []),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("TravelingSalesman", [("graph", "SimpleGraph"), ("weight", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "bool"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("UndirectedFlowLowerBounds", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
+
+register_ilp_pipeline! {
+    ("UndirectedTwoCommodityIntegralFlow", []),
+    ("ILP", [("variable", "i64"), ("coefficient", "i64")]),
+    ("ILP", [("variable", "i64"), ("coefficient", "f64")]),
+}
diff --git a/src/solvers/registry.rs b/src/solvers/registry.rs
new file mode 100644
index 000000000..c044e3d36
--- /dev/null
+++ b/src/solvers/registry.rs
@@ -0,0 +1,496 @@
+//! Deterministic solver capabilities for exact problem variants.
+
+use crate::registry::VariantEntry;
+use crate::rules::registry::{reduction_entries, AggregateReduceFn, ReduceFn, ReductionEntry};
+use crate::rules::DynReductionResult;
+use serde::Serialize;
+use std::any::Any;
+use std::collections::{BTreeMap, BTreeSet};
+use std::sync::OnceLock;
+
+/// Canonical identity of one concrete problem variant.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize)]
+pub struct ExactProblemKey {
+    pub name: String,
+    pub variant: BTreeMap<String, String>,
+}
+
+impl ExactProblemKey {
+    pub fn new(name: impl Into<String>, variant: BTreeMap<String, String>) -> Self {
+        Self {
+            name: name.into(),
+            variant,
+        }
+    }
+
+    fn from_static(step: &StaticProblemStep) -> Self {
+        Self::new(
+            step.name,
+            step.variant
+                .iter()
+                .map(|&(key, value)| (key.to_string(), value.to_string()))
+                .collect(),
+        )
+    }
+
+    /// Format the key using the catalog's canonical problem notation.
+    pub fn label(&self) -> String {
+        if self.variant.is_empty() {
+            return self.name.clone();
+        }
+        let values = self
+            .variant
+            .values()
+            .cloned()
+            .collect::<Vec<_>>()
+            .join(", ");
+        format!("{}<{values}>", self.name)
+    }
+
+    fn is_supported_ilp(&self) -> bool {
+        self.name == "ILP"
+            && matches!(
+                self.variant.get("variable").map(String::as_str),
+                Some("bool" | "i64")
+            )
+            && self.variant.get("coefficient").map(String::as_str) == Some("f64")
+    }
+}
+
+/// A compile-time path node used by fixed ILP pipeline declarations.
+#[derive(Clone, Copy)]
+pub(crate) struct StaticProblemStep {
+    pub name: &'static str,
+    pub variant: &'static [(&'static str, &'static str)],
+}
+
+/// A fixed ILP pipeline declaration.
+///
+/// Every adjacent pair is resolved to one exact witness reduction while the
+/// registry is constructed. Runtime solving executes the resolved function
+/// pointers and never searches the reduction graph.
+pub(crate) struct IlpPipelineRegistration {
+    pub(crate) path: &'static [StaticProblemStep],
+}
+
+inventory::collect!(IlpPipelineRegistration);
+
+type CustomizedSolveFn = fn(&dyn Any) -> Result<Option<serde_json::Value>, super::SolveError>;
+
+/// A dedicated solver registered for one exact problem variant.
+#[derive(Debug)]
+pub(crate) struct CustomizedSolverRegistration {
+    pub(crate) source_name: &'static str,
+    pub(crate) source_variant_fn: fn() -> Vec<(&'static str, &'static str)>,
+    pub(crate) implementation: &'static str,
+    pub(crate) solve_fn: CustomizedSolveFn,
+}
+
+impl CustomizedSolverRegistration {
+    fn source_key(&self) -> ExactProblemKey {
+        ExactProblemKey::new(
+            self.source_name,
+            (self.source_variant_fn)()
+                .into_iter()
+                .map(|(key, value)| (key.to_string(), value.to_string()))
+                .collect(),
+        )
+    }
+}
+
+inventory::collect!(CustomizedSolverRegistration);
+
+#[derive(Debug)]
+pub(crate) struct CompiledIlpPipeline {
+    path: Vec<ExactProblemKey>,
+    reducers: Vec<(ReduceFn, Option<AggregateReduceFn>)>,
+}
+
+impl CompiledIlpPipeline {
+    pub(crate) fn path(&self) -> &[ExactProblemKey] {
+        &self.path
+    }
+
+    pub(crate) fn path_labels(&self) -> Vec<String> {
+        self.path.iter().map(ExactProblemKey::label).collect()
+    }
+
+    fn solve_with<R>(
+        &self,
+        source: &dyn Any,
+        solver: &super::ILPSolver,
+        finish: impl FnOnce(
+            Box<dyn Any>,
+            Option<&dyn DynReductionResult>,
+        ) -> Result<R, super::ILPSolveError>,
+    ) -> Result<R, super::ILPSolveError> {
+        if self.reducers.is_empty() {
+            return finish(Box::new(solver.solve_dyn(source)?), None);
+        }
+
+        let mut reductions: Vec<Box<dyn DynReductionResult>> = Vec::new();
+        for (reducer, _) in &self.reducers {
+            let input = reductions
+                .last()
+                .map(|step| step.target_problem_any())
+                .unwrap_or(source);
+            reductions.push(reducer(input)?);
+        }
+
+        let target = reductions
+            .last()
+            .expect("non-empty fixed pipeline must produce a target")
+            .target_problem_any();
+        let solution = solver.solve_dyn(target)?;
+        let mut source_solution: Box<dyn Any> = Box::new(solution);
+        for (index, step) in reductions.iter().enumerate().rev() {
+            if let Some(reduce) = self.reducers[index].1 {
+                let input = if index == 0 {
+                    source
+                } else {
+                    reductions[index - 1].target_problem_any()
+                };
+                let aggregate = reduce(input)?;
+                // A numerical target optimum can establish YES through a source witness,
+                // but a missed threshold alone cannot establish NO.
+                let value = aggregate.extract_value_from_solution_dyn(source_solution.as_ref())?;
+                if value.downcast_ref::<crate::types::Or>() == Some(&crate::types::Or(false)) {
+                    return Err(super::ILPSolveError::UnresolvedDecision(
+                        self.path[index].label(),
+                    ));
+                }
+            }
+            source_solution = step.extract_solution_dyn(source_solution.as_ref())?;
+        }
+        finish(source_solution, Some(reductions[0].as_ref()))
+    }
+
+    pub(crate) fn solve(
+        &self,
+        source: &dyn Any,
+        solver: &super::ILPSolver,
+    ) -> Result<serde_json::Value, super::ILPSolveError> {
+        self.solve_with(source, solver, |solution, first_reduction| {
+            if let Some(reduction) = first_reduction {
+                return reduction
+                    .source_solution_json(solution.as_ref())
+                    .map_err(super::ILPSolveError::from);
+            }
+            Ok(serde_json::to_value(
+                *solution
+                    .downcast::<Vec<i64>>()
+                    .expect("ILP backend returned the wrong solution type"),
+            )
+            .expect("ILP solution serialization failed"))
+        })
+    }
+
+    pub(crate) fn solve_typed<S: 'static>(
+        &self,
+        source: &dyn Any,
+        solver: &super::ILPSolver,
+    ) -> Result<S, super::ILPSolveError> {
+        self.solve_with(source, solver, |solution, _| {
+            solution
+                .downcast::<S>()
+                .map(|solution| *solution)
+                .map_err(|_| {
+                    super::ILPSolveError::PipelineTypeMismatch(
+                        self.path
+                            .first()
+                            .expect("compiled pipeline has a source")
+                            .label(),
+                    )
+                })
+        })
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct RegisteredSolverCapabilities<'a> {
+    pub(crate) customized: Option<&'static CustomizedSolverRegistration>,
+    pub(crate) ilp: Option<&'a CompiledIlpPipeline>,
+    pub(crate) brute_force: Option<&'static super::BruteForceRegistration>,
+}
+
+impl std::fmt::Debug for RegisteredSolverCapabilities<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SolverCapabilities")
+            .field(
+                "customized",
+                &self.customized.map(|entry| entry.implementation),
+            )
+            .field("ilp", &self.ilp.map(CompiledIlpPipeline::path))
+            .field("brute_force", &self.brute_force.is_some())
+            .finish()
+    }
+}
+
+/// Read-only metadata for a registered customized solver.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+pub struct CustomizedSolverCapability {
+    pub implementation: &'static str,
+}
+
+/// Read-only metadata for a registered fixed ILP pipeline.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+pub struct IlpSolverCapability {
+    path: Vec<ExactProblemKey>,
+}
+
+impl IlpSolverCapability {
+    pub fn path(&self) -> &[ExactProblemKey] {
+        &self.path
+    }
+
+    pub fn path_labels(&self) -> Vec<String> {
+        self.path.iter().map(ExactProblemKey::label).collect()
+    }
+}
+
+/// Read-only solver capabilities for one exact problem variant.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+pub struct SolverCapabilities {
+    pub customized: Option<CustomizedSolverCapability>,
+    pub ilp: Option<IlpSolverCapability>,
+    pub brute_force: bool,
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct SolverCapabilityRegistry {
+    customized: BTreeMap<ExactProblemKey, &'static CustomizedSolverRegistration>,
+    ilp: BTreeMap<ExactProblemKey, CompiledIlpPipeline>,
+    brute_force: BTreeMap<ExactProblemKey, &'static super::BruteForceRegistration>,
+}
+
+impl SolverCapabilityRegistry {
+    pub(crate) fn lookup(&self, key: &ExactProblemKey) -> RegisteredSolverCapabilities<'_> {
+        RegisteredSolverCapabilities {
+            customized: self.customized.get(key).copied(),
+            ilp: self.ilp.get(key),
+            brute_force: self.brute_force.get(key).copied(),
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum RegistryBuildError {
+    #[error("solver registration references unknown exact variant {0}")]
+    UnknownVariant(String),
+    #[error("duplicate customized solver registration for {0}")]
+    DuplicateCustomized(String),
+    #[error("duplicate ILP pipeline registration for {0}")]
+    DuplicateIlp(String),
+    #[error("duplicate brute-force registration for {0}")]
+    DuplicateBruteForce(String),
+    #[error("exact variant {0} has no registered solver capability")]
+    MissingSolverCapability(String),
+    #[error("ILP pipeline must contain at least one node")]
+    EmptyPipeline,
+    #[error("ILP pipeline for {0} does not end at an f64-coefficient ILP")]
+    UnsupportedTarget(String),
+    #[error("ILP pipeline for {0} continues after reaching a supported ILP node")]
+    ContinuesAfterIlp(String),
+    #[error("ILP pipeline edge {source_label} -> {target_label} resolves to {matches} witness reductions")]
+    InvalidEdge {
+        source_label: String,
+        target_label: String,
+        matches: usize,
+    },
+}
+
+fn registered_variant_keys() -> BTreeSet<ExactProblemKey> {
+    inventory::iter::<VariantEntry>()
+        .map(|entry| ExactProblemKey::new(entry.name, entry.variant_map()))
+        .collect()
+}
+
+fn edge_key(entry: &ReductionEntry, source: bool) -> ExactProblemKey {
+    let (name, variant) = if source {
+        (entry.source_name, entry.source_variant())
+    } else {
+        (entry.target_name, entry.target_variant())
+    };
+    ExactProblemKey::new(
+        name,
+        variant
+            .into_iter()
+            .map(|(key, value)| (key.to_string(), value.to_string()))
+            .collect(),
+    )
+}
+
+fn build_registry(
+    variants: &BTreeSet<ExactProblemKey>,
+    customized_entries: impl IntoIterator<Item = &'static CustomizedSolverRegistration>,
+    pipeline_entries: impl IntoIterator<Item = &'static IlpPipelineRegistration>,
+    brute_force_entries: impl IntoIterator<Item = &'static super::BruteForceRegistration>,
+    reductions: &[&'static ReductionEntry],
+) -> Result<SolverCapabilityRegistry, RegistryBuildError> {
+    let mut registry = SolverCapabilityRegistry::default();
+    let mut reduction_index =
+        BTreeMap::<(ExactProblemKey, ExactProblemKey), Vec<&'static ReductionEntry>>::new();
+    for entry in reductions
+        .iter()
+        .copied()
+        .filter(|entry| entry.reduce_fn.is_some())
+    {
+        reduction_index
+            .entry((edge_key(entry, true), edge_key(entry, false)))
+            .or_default()
+            .push(entry);
+    }
+
+    for customized in customized_entries {
+        let source = customized.source_key();
+        if !variants.contains(&source) {
+            return Err(RegistryBuildError::UnknownVariant(source.label()));
+        }
+        if registry
+            .customized
+            .insert(source.clone(), customized)
+            .is_some()
+        {
+            return Err(RegistryBuildError::DuplicateCustomized(source.label()));
+        }
+    }
+
+    for brute_force in brute_force_entries {
+        let source = ExactProblemKey::new(
+            brute_force.source_name,
+            crate::export::variant_to_map((brute_force.source_variant_fn)()),
+        );
+        if !variants.contains(&source) {
+            return Err(RegistryBuildError::UnknownVariant(source.label()));
+        }
+        if registry
+            .brute_force
+            .insert(source.clone(), brute_force)
+            .is_some()
+        {
+            return Err(RegistryBuildError::DuplicateBruteForce(source.label()));
+        }
+    }
+
+    for registration in pipeline_entries {
+        let path = registration
+            .path
+            .iter()
+            .map(ExactProblemKey::from_static)
+            .collect::<Vec<_>>();
+        let source = path
+            .first()
+            .cloned()
+            .ok_or(RegistryBuildError::EmptyPipeline)?;
+
+        for step in &path {
+            if !variants.contains(step) {
+                return Err(RegistryBuildError::UnknownVariant(step.label()));
+            }
+        }
+        if !path.last().is_some_and(ExactProblemKey::is_supported_ilp) {
+            return Err(RegistryBuildError::UnsupportedTarget(source.label()));
+        }
+        if path[..path.len() - 1]
+            .iter()
+            .any(ExactProblemKey::is_supported_ilp)
+        {
+            return Err(RegistryBuildError::ContinuesAfterIlp(source.label()));
+        }
+
+        let mut reducers = Vec::with_capacity(path.len().saturating_sub(1));
+        for pair in path.windows(2) {
+            let matches = reduction_index
+                .get(&(pair[0].clone(), pair[1].clone()))
+                .map(Vec::as_slice)
+                .unwrap_or_default();
+            if matches.len() != 1 {
+                return Err(RegistryBuildError::InvalidEdge {
+                    source_label: pair[0].label(),
+                    target_label: pair[1].label(),
+                    matches: matches.len(),
+                });
+            }
+            reducers.push((
+                matches[0]
+                    .reduce_fn
+                    .expect("indexed only entries with reduce_fn"),
+                matches[0].reduce_aggregate_fn,
+            ));
+        }
+
+        if registry
+            .ilp
+            .insert(source.clone(), CompiledIlpPipeline { path, reducers })
+            .is_some()
+        {
+            return Err(RegistryBuildError::DuplicateIlp(source.label()));
+        }
+    }
+
+    for variant in variants {
+        if !registry.customized.contains_key(variant)
+            && !registry.ilp.contains_key(variant)
+            && !registry.brute_force.contains_key(variant)
+        {
+            return Err(RegistryBuildError::MissingSolverCapability(variant.label()));
+        }
+    }
+
+    Ok(registry)
+}
+
+static REGISTRY: OnceLock<Result<SolverCapabilityRegistry, RegistryBuildError>> = OnceLock::new();
+
+pub(crate) fn solver_capability_registry(
+) -> Result<&'static SolverCapabilityRegistry, &'static RegistryBuildError> {
+    REGISTRY
+        .get_or_init(|| {
+            build_registry(
+                &registered_variant_keys(),
+                inventory::iter::<CustomizedSolverRegistration>(),
+                inventory::iter::<IlpPipelineRegistration>(),
+                inventory::iter::<super::BruteForceRegistration>(),
+                &reduction_entries(),
+            )
+        })
+        .as_ref()
+}
+
+/// Return read-only solver metadata for one exact problem variant.
+pub fn solver_capabilities(
+    key: &ExactProblemKey,
+) -> Result<SolverCapabilities, &'static RegistryBuildError> {
+    let registered = solver_capability_registry()?.lookup(key);
+    Ok(SolverCapabilities {
+        customized: registered
+            .customized
+            .map(|entry| CustomizedSolverCapability {
+                implementation: entry.implementation,
+            }),
+        ilp: registered.ilp.map(|pipeline| IlpSolverCapability {
+            path: pipeline.path.clone(),
+        }),
+        brute_force: registered.brute_force.is_some(),
+    })
+}
+
+pub(crate) fn brute_force_registration(
+    key: &ExactProblemKey,
+) -> Result<Option<&'static super::BruteForceRegistration>, &'static RegistryBuildError> {
+    Ok(solver_capability_registry()?.lookup(key).brute_force)
+}
+
+/// Return the finite Cartesian dimensions registered for a loaded problem.
+#[doc(hidden)]
+pub fn brute_force_dimensions(
+    problem: &crate::registry::LoadedDynProblem,
+) -> Result<Option<Vec<usize>>, &'static RegistryBuildError> {
+    let key = ExactProblemKey::new(problem.problem_name(), problem.variant_map());
+    Ok(brute_force_registration(&key)?
+        .map(|registration| (registration.dimensions_fn)(problem.as_any())))
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/solvers/registry.rs"]
+mod tests;
diff --git a/src/solvers/resolver.rs b/src/solvers/resolver.rs
new file mode 100644
index 000000000..6444d1254
--- /dev/null
+++ b/src/solvers/resolver.rs
@@ -0,0 +1,163 @@
+//! Shared deterministic solver dispatch.
+
+use super::registry::CompiledIlpPipeline;
+use super::registry::{solver_capability_registry, CustomizedSolverRegistration, ExactProblemKey};
+use crate::registry::LoadedDynProblem;
+use serde::Serialize;
+
+/// Public solver override. Omission is represented by [`SolverRequest::Default`].
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum SolverRequest {
+    #[default]
+    Default,
+    Customized,
+    Ilp,
+    BruteForce,
+}
+
+/// Information about the backend execution that produced a solve result.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[serde(tag = "kind", rename_all = "kebab-case")]
+pub enum SolverExecution {
+    Customized { implementation: &'static str },
+    Ilp { reduction_path: Vec<String> },
+    BruteForce,
+}
+
+/// Type-erased result returned by deterministic solver dispatch.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SolveResult {
+    pub solver: SolverExecution,
+    pub outcome: SolveOutcome,
+}
+
+/// Semantic result of a completed solve under the selected backend's numerical contract.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[serde(tag = "status", rename_all = "snake_case")]
+pub enum SolveOutcome {
+    /// The selected backend established optimality and returned a solution.
+    /// ILP optimality is subject to backend numerical tolerances.
+    Optimal {
+        solution: serde_json::Value,
+        evaluation: String,
+    },
+    /// The selected backend established infeasibility under its numerical contract.
+    Infeasible,
+}
+
+fn problem_key(problem: &LoadedDynProblem) -> ExactProblemKey {
+    ExactProblemKey::new(problem.problem_name(), problem.variant_map())
+}
+
+fn solve_customized(
+    problem: &LoadedDynProblem,
+    registration: &'static CustomizedSolverRegistration,
+) -> Result<SolveResult, super::SolveError> {
+    let outcome = match (registration.solve_fn)(problem.as_any())? {
+        Some(solution) => SolveOutcome::Optimal {
+            evaluation: problem.evaluate_dyn(&solution)?,
+            solution,
+        },
+        None => SolveOutcome::Infeasible,
+    };
+    Ok(SolveResult {
+        solver: SolverExecution::Customized {
+            implementation: registration.implementation,
+        },
+        outcome,
+    })
+}
+
+fn solve_ilp(
+    problem: &LoadedDynProblem,
+    pipeline: &CompiledIlpPipeline,
+) -> Result<SolveResult, super::SolveError> {
+    let outcome = match pipeline.solve(problem.as_any(), &super::ILPSolver::new()) {
+        Ok(solution) => SolveOutcome::Optimal {
+            evaluation: problem.evaluate_dyn(&solution)?,
+            solution,
+        },
+        Err(super::ILPSolveError::Infeasible) => SolveOutcome::Infeasible,
+        Err(source) => {
+            return Err(super::SolveError::IlpSolve {
+                problem: problem_key(problem).label(),
+                source,
+            });
+        }
+    };
+    Ok(SolveResult {
+        solver: SolverExecution::Ilp {
+            reduction_path: pipeline.path_labels(),
+        },
+        outcome,
+    })
+}
+
+fn solve_brute_force(
+    problem: &LoadedDynProblem,
+    registration: &'static super::BruteForceRegistration,
+) -> Result<SolveResult, super::SolveError> {
+    let outcome = match (registration.solve_fn)(problem.as_any())? {
+        Some((solution, evaluation)) => SolveOutcome::Optimal {
+            solution,
+            evaluation,
+        },
+        None => SolveOutcome::Infeasible,
+    };
+    Ok(SolveResult {
+        solver: SolverExecution::BruteForce,
+        outcome,
+    })
+}
+
+/// Solve a loaded problem using deterministic exact-variant dispatch.
+///
+/// Default dispatch is customized, then the registered fixed ILP pipeline, then
+/// brute force. Once selected, backend failure is returned without fallback.
+pub fn solve(
+    problem: &LoadedDynProblem,
+    request: SolverRequest,
+) -> Result<SolveResult, super::SolveError> {
+    let registry = solver_capability_registry().map_err(super::SolveError::InvalidRegistry)?;
+    let key = problem_key(problem);
+    let capabilities = registry.lookup(&key);
+
+    match request {
+        SolverRequest::BruteForce => solve_brute_force(
+            problem,
+            capabilities
+                .brute_force
+                .ok_or_else(|| super::SolveError::MissingRegistration(key.label()))?,
+        ),
+        SolverRequest::Customized => {
+            let registration = capabilities
+                .customized
+                .ok_or_else(|| super::SolveError::MissingCustomizedCapability(key.label()))?;
+            solve_customized(problem, registration)
+        }
+        SolverRequest::Ilp => {
+            let pipeline = capabilities
+                .ilp
+                .ok_or_else(|| super::SolveError::MissingIlpCapability(key.label()))?;
+            solve_ilp(problem, pipeline)
+        }
+        SolverRequest::Default => {
+            if let Some(customized) = capabilities.customized {
+                return solve_customized(problem, customized);
+            }
+            if let Some(pipeline) = capabilities.ilp {
+                return solve_ilp(problem, pipeline);
+            }
+            solve_brute_force(
+                problem,
+                capabilities
+                    .brute_force
+                    .ok_or_else(|| super::SolveError::MissingRegistration(key.label()))?,
+            )
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/solvers/resolver.rs"]
+mod tests;
diff --git a/src/topology/bipartite_graph.rs b/src/topology/bipartite_graph.rs
index a56c97e34..a99d5dbdf 100644
--- a/src/topology/bipartite_graph.rs
+++ b/src/topology/bipartite_graph.rs
@@ -1,6 +1,6 @@
 //! Bipartite graph with explicit left/right partitions.
 
-use super::graph::{Graph, SimpleGraph};
+use super::graph::Graph;
 use serde::{Deserialize, Serialize};
 
 /// Bipartite graph with explicit left/right partitions.
@@ -136,8 +136,7 @@ impl Graph for BipartiteGraph {
 }
 
 use crate::impl_variant_param;
-impl_variant_param!(BipartiteGraph, "graph", parent: SimpleGraph,
-    cast: |g| SimpleGraph::new(g.num_vertices(), g.edges()));
+impl_variant_param!(BipartiteGraph, "graph");
 
 #[cfg(test)]
 #[path = "../unit_tests/topology/bipartite_graph.rs"]
diff --git a/src/topology/graph.rs b/src/topology/graph.rs
index 12e8362d8..263b64aeb 100644
--- a/src/topology/graph.rs
+++ b/src/topology/graph.rs
@@ -82,24 +82,6 @@ pub trait Graph: Clone + Send + Sync + 'static {
     }
 }
 
-/// Trait for casting a graph to a supertype in the graph hierarchy.
-///
-/// When `A: GraphCast<B>`, graph `A` can be losslessly converted to graph `B`
-/// by extracting the adjacency structure. This enables natural-edge reductions
-/// where a problem on a specific graph type is solved by treating it as a more
-/// general graph.
-pub trait GraphCast<Target: Graph>: Graph {
-    /// Convert this graph to the target graph type.
-    fn cast_graph(&self) -> Target;
-}
-
-/// Any graph can be cast to a `SimpleGraph` by extracting vertices and edges.
-impl<G: Graph> GraphCast<SimpleGraph> for G {
-    fn cast_graph(&self) -> SimpleGraph {
-        SimpleGraph::new(self.num_vertices(), self.edges())
-    }
-}
-
 /// A simple unweighted undirected graph.
 ///
 /// This is the default graph type for most problems. It wraps petgraph's
diff --git a/src/topology/kings_subgraph.rs b/src/topology/kings_subgraph.rs
index 3be06f7c6..f849e164c 100644
--- a/src/topology/kings_subgraph.rs
+++ b/src/topology/kings_subgraph.rs
@@ -5,6 +5,8 @@
 
 use super::graph::Graph;
 use super::unit_disk_graph::UnitDiskGraph;
+use crate::registry::ConstructionError;
+use crate::types::i64_to_exact_f64;
 use serde::{Deserialize, Serialize};
 
 /// A King's Subgraph — an unweighted unit disk graph on a square lattice.
@@ -18,7 +20,7 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct KingsSubgraph {
     /// Integer grid positions (row, col) for each vertex.
-    positions: Vec<(i32, i32)>,
+    positions: Vec<(i64, i64)>,
 }
 
 /// Fixed radius for king's move connectivity on integer grid.
@@ -26,12 +28,12 @@ const KINGS_RADIUS: f64 = 1.5;
 
 impl KingsSubgraph {
     /// Create a KingsSubgraph from a list of integer positions.
-    pub fn new(positions: Vec<(i32, i32)>) -> Self {
+    pub fn new(positions: Vec<(i64, i64)>) -> Self {
         Self { positions }
     }
 
     /// Get the positions of all vertices.
-    pub fn positions(&self) -> &[(i32, i32)] {
+    pub fn positions(&self) -> &[(i64, i64)] {
         &self.positions
     }
 
@@ -40,11 +42,33 @@ impl KingsSubgraph {
         self.positions.len()
     }
 
-    /// Compute Euclidean distance between two integer positions.
-    fn distance(p1: (i32, i32), p2: (i32, i32)) -> f64 {
-        let dx = (p1.0 - p2.0) as f64;
-        let dy = (p1.1 - p2.1) as f64;
-        (dx * dx + dy * dy).sqrt()
+    fn are_adjacent(p1: (i64, i64), p2: (i64, i64)) -> bool {
+        p1.0.abs_diff(p2.0) <= 1 && p1.1.abs_diff(p2.1) <= 1
+    }
+
+    pub(crate) fn try_to_unit_disk_graph(&self) -> Result<UnitDiskGraph, ConstructionError> {
+        let positions = self
+            .positions
+            .iter()
+            .map(|&(row, column)| {
+                let row = i64_to_exact_f64(row)?;
+                let column = i64_to_exact_f64(column)?;
+                Ok((row, column))
+            })
+            .collect::<Result<Vec<_>, ConstructionError>>()?;
+        let graph = UnitDiskGraph::new(positions, KINGS_RADIUS)?;
+        for first in 0..self.positions.len() {
+            for second in (first + 1)..self.positions.len() {
+                if Self::are_adjacent(self.positions[first], self.positions[second])
+                    != graph.has_edge(first, second)
+                {
+                    return Err(ConstructionError::Conversion(format!(
+                        "king's-subgraph coordinates at indices {first} and {second} cannot be represented in UnitDiskGraph without changing adjacency"
+                    )));
+                }
+            }
+        }
+        Ok(graph)
     }
 }
 
@@ -60,7 +84,7 @@ impl Graph for KingsSubgraph {
         let mut count = 0;
         for i in 0..n {
             for j in (i + 1)..n {
-                if Self::distance(self.positions[i], self.positions[j]) < KINGS_RADIUS {
+                if Self::are_adjacent(self.positions[i], self.positions[j]) {
                     count += 1;
                 }
             }
@@ -73,7 +97,7 @@ impl Graph for KingsSubgraph {
         let mut edges = Vec::new();
         for i in 0..n {
             for j in (i + 1)..n {
-                if Self::distance(self.positions[i], self.positions[j]) < KINGS_RADIUS {
+                if Self::are_adjacent(self.positions[i], self.positions[j]) {
                     edges.push((i, j));
                 }
             }
@@ -85,7 +109,7 @@ impl Graph for KingsSubgraph {
         if u >= self.positions.len() || v >= self.positions.len() || u == v {
             return false;
         }
-        Self::distance(self.positions[u], self.positions[v]) < KINGS_RADIUS
+        Self::are_adjacent(self.positions[u], self.positions[v])
     }
 
     fn neighbors(&self, v: usize) -> Vec<usize> {
@@ -93,9 +117,7 @@ impl Graph for KingsSubgraph {
             return Vec::new();
         }
         (0..self.positions.len())
-            .filter(|&u| {
-                u != v && Self::distance(self.positions[v], self.positions[u]) < KINGS_RADIUS
-            })
+            .filter(|&u| u != v && Self::are_adjacent(self.positions[v], self.positions[u]))
             .collect()
     }
 }
@@ -103,16 +125,51 @@ impl Graph for KingsSubgraph {
 impl crate::variant::VariantParam for KingsSubgraph {
     const CATEGORY: &'static str = "graph";
     const VALUE: &'static str = "KingsSubgraph";
-    const PARENT_VALUE: Option<&'static str> = Some("UnitDiskGraph");
 }
-impl crate::variant::CastToParent for KingsSubgraph {
-    type Parent = UnitDiskGraph;
-    fn cast_to_parent(&self) -> UnitDiskGraph {
-        let positions: Vec<(f64, f64)> = self
-            .positions
-            .iter()
-            .map(|&(r, c)| (r as f64, c as f64))
-            .collect();
-        UnitDiskGraph::new(positions, KINGS_RADIUS)
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::MAX_EXACT_F64_INTEGER;
+
+    #[test]
+    fn adjacency_handles_full_i64_coordinate_range() {
+        let graph = KingsSubgraph::new(vec![
+            (i64::MAX, i64::MAX),
+            (i64::MAX - 1, i64::MAX - 1),
+            (i64::MIN, i64::MIN),
+        ]);
+
+        assert!(graph.has_edge(0, 1));
+        assert!(!graph.has_edge(0, 2));
+    }
+
+    #[test]
+    fn integer_adjacency_matches_euclidean_definition() {
+        for row_a in -4..=4 {
+            for column_a in -4..=4 {
+                for row_b in -4..=4 {
+                    for column_b in -4..=4 {
+                        let dr = (row_a - row_b) as f64;
+                        let dc = (column_a - column_b) as f64;
+                        let euclidean = dr.hypot(dc) < KINGS_RADIUS;
+                        assert_eq!(
+                            KingsSubgraph::are_adjacent((row_a, column_a), (row_b, column_b)),
+                            euclidean
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn unit_disk_conversion_rejects_inexact_coordinates() {
+        let graph = KingsSubgraph::new(vec![(MAX_EXACT_F64_INTEGER + 1, 0)]);
+
+        assert!(matches!(
+            graph.try_to_unit_disk_graph(),
+            Err(ConstructionError::InexactFloatConversion(_))
+        ));
     }
 }
diff --git a/src/topology/mod.rs b/src/topology/mod.rs
index 4e7eed829..dd72e7aac 100644
--- a/src/topology/mod.rs
+++ b/src/topology/mod.rs
@@ -15,6 +15,7 @@ mod directed_graph;
 mod graph;
 mod kings_subgraph;
 mod mixed_graph;
+mod path;
 mod planar_graph;
 pub mod small_graphs;
 mod triangular_subgraph;
@@ -22,9 +23,10 @@ mod unit_disk_graph;
 
 pub use bipartite_graph::BipartiteGraph;
 pub use directed_graph::DirectedGraph;
-pub use graph::{Graph, GraphCast, SimpleGraph};
+pub use graph::{Graph, SimpleGraph};
 pub use kings_subgraph::KingsSubgraph;
 pub use mixed_graph::MixedGraph;
+pub(crate) use path::is_simple_st_path;
 pub use planar_graph::PlanarGraph;
 pub use small_graphs::{available_graphs, smallgraph};
 pub use triangular_subgraph::TriangularSubgraph;
diff --git a/src/topology/path.rs b/src/topology/path.rs
new file mode 100644
index 000000000..3b88a28ed
--- /dev/null
+++ b/src/topology/path.rs
@@ -0,0 +1,81 @@
+//! Validation of edge-selected paths, shared by graph problem models.
+
+use std::collections::VecDeque;
+
+/// Whether selected edges form a simple undirected path between valid terminals.
+pub(crate) fn is_simple_st_path(
+    num_vertices: usize,
+    edges: &[(usize, usize)],
+    source_vertex: usize,
+    target_vertex: usize,
+    config: &[bool],
+) -> bool {
+    if config.len() != edges.len() {
+        return false;
+    }
+
+    if source_vertex == target_vertex {
+        return config.iter().all(|&selected| !selected);
+    }
+
+    let mut degree = vec![0usize; num_vertices];
+    let mut adjacency = vec![Vec::new(); num_vertices];
+    let mut selected_edge_count = 0usize;
+
+    for (idx, &selected) in config.iter().enumerate() {
+        if !selected {
+            continue;
+        }
+        let (u, v) = edges[idx];
+        degree[u] += 1;
+        degree[v] += 1;
+        if degree[u] > 2 || degree[v] > 2 {
+            return false;
+        }
+        adjacency[u].push(v);
+        adjacency[v].push(u);
+        selected_edge_count += 1;
+    }
+
+    if selected_edge_count == 0 {
+        return false;
+    }
+    if degree[source_vertex] != 1 || degree[target_vertex] != 1 {
+        return false;
+    }
+
+    let mut selected_vertex_count = 0usize;
+    for (vertex, &vertex_degree) in degree.iter().enumerate() {
+        if vertex_degree == 0 {
+            continue;
+        }
+        selected_vertex_count += 1;
+        if vertex != source_vertex && vertex != target_vertex && vertex_degree != 2 {
+            return false;
+        }
+    }
+
+    if selected_edge_count != selected_vertex_count - 1 {
+        return false;
+    }
+
+    let mut visited = vec![false; num_vertices];
+    let mut queue = VecDeque::new();
+    visited[source_vertex] = true;
+    queue.push_back(source_vertex);
+
+    while let Some(vertex) = queue.pop_front() {
+        for &neighbor in &adjacency[vertex] {
+            if !visited[neighbor] {
+                visited[neighbor] = true;
+                queue.push_back(neighbor);
+            }
+        }
+    }
+
+    visited[target_vertex]
+        && degree
+            .iter()
+            .enumerate()
+            .all(|(vertex, &vertex_degree)| vertex_degree == 0 || visited[vertex])
+}
diff --git a/src/topology/planar_graph.rs b/src/topology/planar_graph.rs
index 712ff1027..a29a2b042 100644
--- a/src/topology/planar_graph.rs
+++ b/src/topology/planar_graph.rs
@@ -75,8 +75,7 @@ impl Graph for PlanarGraph {
 }
 
 use crate::impl_variant_param;
-impl_variant_param!(PlanarGraph, "graph", parent: SimpleGraph,
-    cast: |g| g.inner.clone());
+impl_variant_param!(PlanarGraph, "graph");
 
 #[cfg(test)]
 #[path = "../unit_tests/topology/planar_graph.rs"]
diff --git a/src/topology/triangular_subgraph.rs b/src/topology/triangular_subgraph.rs
index 307f3597a..2fd8e7915 100644
--- a/src/topology/triangular_subgraph.rs
+++ b/src/topology/triangular_subgraph.rs
@@ -5,6 +5,8 @@
 
 use super::graph::Graph;
 use super::unit_disk_graph::UnitDiskGraph;
+use crate::registry::ConstructionError;
+use crate::types::i64_to_exact_f64;
 use serde::{Deserialize, Serialize};
 
 /// A Triangular Subgraph — an unweighted unit disk graph on a triangular lattice.
@@ -21,7 +23,7 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct TriangularSubgraph {
     /// Integer grid positions (row, col) for each vertex.
-    positions: Vec<(i32, i32)>,
+    positions: Vec<(i64, i64)>,
 }
 
 /// Fixed radius for triangular lattice adjacency.
@@ -29,12 +31,12 @@ const TRIANGULAR_RADIUS: f64 = 1.1;
 
 impl TriangularSubgraph {
     /// Create a TriangularSubgraph from a list of integer positions.
-    pub fn new(positions: Vec<(i32, i32)>) -> Self {
+    pub fn new(positions: Vec<(i64, i64)>) -> Self {
         Self { positions }
     }
 
     /// Get the positions of all vertices.
-    pub fn positions(&self) -> &[(i32, i32)] {
+    pub fn positions(&self) -> &[(i64, i64)] {
         &self.positions
     }
 
@@ -49,18 +51,45 @@ impl TriangularSubgraph {
     /// - `x = row + 0.5` if col is even, else `x = row`
     /// - `y = col * sqrt(3)/2`
     #[allow(unknown_lints, clippy::manual_is_multiple_of)]
-    fn physical_position(row: i32, col: i32) -> (f64, f64) {
-        let y = col as f64 * (3.0_f64.sqrt() / 2.0);
+    fn physical_position(row: i64, col: i64) -> Result<(f64, f64), ConstructionError> {
+        let row = i64_to_exact_f64(row)?;
         let offset = if col % 2 == 0 { 0.5 } else { 0.0 };
-        let x = row as f64 + offset;
-        (x, y)
+        let col = i64_to_exact_f64(col)?;
+        let y = col * (3.0_f64.sqrt() / 2.0);
+        let x = row + offset;
+        Ok((x, y))
     }
 
-    /// Compute Euclidean distance between two physical positions.
-    fn distance(p1: (f64, f64), p2: (f64, f64)) -> f64 {
-        let dx = p1.0 - p2.0;
-        let dy = p1.1 - p2.1;
-        (dx * dx + dy * dy).sqrt()
+    fn are_adjacent(p1: (i64, i64), p2: (i64, i64)) -> bool {
+        let column_delta = (i128::from(p1.1) - i128::from(p2.1)).abs();
+        if column_delta > 1 {
+            return false;
+        }
+        let x1 = 2 * i128::from(p1.0) + i128::from(p1.1.rem_euclid(2) == 0);
+        let x2 = 2 * i128::from(p2.0) + i128::from(p2.1.rem_euclid(2) == 0);
+        let x_delta = (x1 - x2).abs();
+        x_delta <= 2 && x_delta * x_delta + 3 * column_delta * column_delta <= 4
+    }
+
+    pub(crate) fn try_to_unit_disk_graph(&self) -> Result<UnitDiskGraph, ConstructionError> {
+        let positions = self
+            .positions
+            .iter()
+            .map(|&(row, column)| Self::physical_position(row, column))
+            .collect::<Result<Vec<_>, _>>()?;
+        let graph = UnitDiskGraph::new(positions, TRIANGULAR_RADIUS)?;
+        for first in 0..self.positions.len() {
+            for second in (first + 1)..self.positions.len() {
+                if Self::are_adjacent(self.positions[first], self.positions[second])
+                    != graph.has_edge(first, second)
+                {
+                    return Err(ConstructionError::Conversion(format!(
+                        "triangular-subgraph coordinates at indices {first} and {second} cannot be represented in UnitDiskGraph without changing adjacency"
+                    )));
+                }
+            }
+        }
+        Ok(graph)
     }
 }
 
@@ -75,10 +104,8 @@ impl Graph for TriangularSubgraph {
         let n = self.positions.len();
         let mut count = 0;
         for i in 0..n {
-            let pi = Self::physical_position(self.positions[i].0, self.positions[i].1);
             for j in (i + 1)..n {
-                let pj = Self::physical_position(self.positions[j].0, self.positions[j].1);
-                if Self::distance(pi, pj) < TRIANGULAR_RADIUS {
+                if Self::are_adjacent(self.positions[i], self.positions[j]) {
                     count += 1;
                 }
             }
@@ -90,10 +117,8 @@ impl Graph for TriangularSubgraph {
         let n = self.positions.len();
         let mut edges = Vec::new();
         for i in 0..n {
-            let pi = Self::physical_position(self.positions[i].0, self.positions[i].1);
             for j in (i + 1)..n {
-                let pj = Self::physical_position(self.positions[j].0, self.positions[j].1);
-                if Self::distance(pi, pj) < TRIANGULAR_RADIUS {
+                if Self::are_adjacent(self.positions[i], self.positions[j]) {
                     edges.push((i, j));
                 }
             }
@@ -105,23 +130,15 @@ impl Graph for TriangularSubgraph {
         if u >= self.positions.len() || v >= self.positions.len() || u == v {
             return false;
         }
-        let pu = Self::physical_position(self.positions[u].0, self.positions[u].1);
-        let pv = Self::physical_position(self.positions[v].0, self.positions[v].1);
-        Self::distance(pu, pv) < TRIANGULAR_RADIUS
+        Self::are_adjacent(self.positions[u], self.positions[v])
     }
 
     fn neighbors(&self, v: usize) -> Vec<usize> {
         if v >= self.positions.len() {
             return Vec::new();
         }
-        let pv = Self::physical_position(self.positions[v].0, self.positions[v].1);
         (0..self.positions.len())
-            .filter(|&u| {
-                u != v && {
-                    let pu = Self::physical_position(self.positions[u].0, self.positions[u].1);
-                    Self::distance(pv, pu) < TRIANGULAR_RADIUS
-                }
-            })
+            .filter(|&u| u != v && Self::are_adjacent(self.positions[v], self.positions[u]))
             .collect()
     }
 }
@@ -129,16 +146,58 @@ impl Graph for TriangularSubgraph {
 impl crate::variant::VariantParam for TriangularSubgraph {
     const CATEGORY: &'static str = "graph";
     const VALUE: &'static str = "TriangularSubgraph";
-    const PARENT_VALUE: Option<&'static str> = Some("UnitDiskGraph");
 }
-impl crate::variant::CastToParent for TriangularSubgraph {
-    type Parent = UnitDiskGraph;
-    fn cast_to_parent(&self) -> UnitDiskGraph {
-        let positions: Vec<(f64, f64)> = self
-            .positions
-            .iter()
-            .map(|&(r, c)| Self::physical_position(r, c))
-            .collect();
-        UnitDiskGraph::new(positions, TRIANGULAR_RADIUS)
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::MAX_EXACT_F64_INTEGER;
+
+    #[test]
+    fn adjacency_handles_full_i64_coordinate_range() {
+        let graph = TriangularSubgraph::new(vec![(i64::MAX, 0), (i64::MAX, 1), (i64::MIN, 0)]);
+
+        assert!(graph.has_edge(0, 1));
+        assert!(!graph.has_edge(0, 2));
+    }
+
+    #[test]
+    fn integer_adjacency_matches_euclidean_definition() {
+        for row_a in -4..=4 {
+            for column_a in -4..=4 {
+                for row_b in -4..=4 {
+                    for column_b in -4..=4 {
+                        let a = TriangularSubgraph::physical_position(row_a, column_a).unwrap();
+                        let b = TriangularSubgraph::physical_position(row_b, column_b).unwrap();
+                        let euclidean = (a.0 - b.0).hypot(a.1 - b.1) < TRIANGULAR_RADIUS;
+                        assert_eq!(
+                            TriangularSubgraph::are_adjacent((row_a, column_a), (row_b, column_b)),
+                            euclidean
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn unit_disk_conversion_rejects_inexact_coordinates() {
+        let graph = TriangularSubgraph::new(vec![(MAX_EXACT_F64_INTEGER + 1, 0)]);
+
+        assert!(matches!(
+            graph.try_to_unit_disk_graph(),
+            Err(ConstructionError::InexactFloatConversion(_))
+        ));
+    }
+
+    #[test]
+    fn unit_disk_conversion_rejects_changed_adjacency() {
+        let graph =
+            TriangularSubgraph::new(vec![(MAX_EXACT_F64_INTEGER, 0), (MAX_EXACT_F64_INTEGER, 1)]);
+
+        assert!(matches!(
+            graph.try_to_unit_disk_graph(),
+            Err(ConstructionError::Conversion(_))
+        ));
     }
 }
diff --git a/src/topology/unit_disk_graph.rs b/src/topology/unit_disk_graph.rs
index 0c8a473f7..cbd352c78 100644
--- a/src/topology/unit_disk_graph.rs
+++ b/src/topology/unit_disk_graph.rs
@@ -4,6 +4,8 @@
 //! and two vertices are connected if their distance is at most a threshold (radius).
 
 use super::graph::Graph;
+use crate::registry::ConstructionError;
+use crate::types::i64_to_exact_f64;
 use serde::{Deserialize, Serialize};
 
 /// A unit disk graph with vertices at 2D positions.
@@ -21,7 +23,7 @@ use serde::{Deserialize, Serialize};
 /// let udg = UnitDiskGraph::new(
 ///     vec![(0.0, 0.0), (1.0, 0.0), (3.0, 0.0)],
 ///     1.0,
-/// );
+/// ).unwrap();
 ///
 /// // Vertices 0 and 1 are connected (distance = 1.0)
 /// // Vertex 2 is isolated (distance > 1.0 from both)
@@ -29,7 +31,7 @@ use serde::{Deserialize, Serialize};
 /// assert!(!udg.has_edge(0, 2));
 /// assert!(!udg.has_edge(1, 2));
 /// ```
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize)]
 pub struct UnitDiskGraph {
     /// Positions of vertices as (x, y) coordinates.
     positions: Vec<(f64, f64)>,
@@ -46,36 +48,58 @@ impl UnitDiskGraph {
     ///
     /// * `positions` - 2D coordinates for each vertex
     /// * `radius` - Maximum distance for an edge to exist
-    pub fn new(positions: Vec<(f64, f64)>, radius: f64) -> Self {
+    pub fn new(positions: Vec<(f64, f64)>, radius: f64) -> Result<Self, ConstructionError> {
+        if !radius.is_finite() {
+            return Err(ConstructionError::NonFiniteFloat(
+                "unit-disk radius must be finite".into(),
+            ));
+        }
+        if radius < 0.0 {
+            return Err(ConstructionError::Conversion(
+                "unit-disk radius must be nonnegative".into(),
+            ));
+        }
+        for (index, &(x, y)) in positions.iter().enumerate() {
+            if !x.is_finite() || !y.is_finite() {
+                return Err(ConstructionError::NonFiniteFloat(format!(
+                    "unit-disk position at index {index} must be finite"
+                )));
+            }
+        }
         let n = positions.len();
         let mut edges = Vec::new();
 
         // Compute all edges based on distance
         for i in 0..n {
             for j in (i + 1)..n {
-                if Self::distance(&positions[i], &positions[j]) <= radius {
+                if Self::distance(&positions[i], &positions[j])? <= radius {
                     edges.push((i, j));
                 }
             }
         }
 
-        Self {
+        Ok(Self {
             positions,
             radius,
             edges,
-        }
+        })
     }
 
     /// Create a unit disk graph with radius 1.0.
-    pub fn unit(positions: Vec<(f64, f64)>) -> Self {
+    pub fn unit(positions: Vec<(f64, f64)>) -> Result<Self, ConstructionError> {
         Self::new(positions, 1.0)
     }
 
     /// Compute Euclidean distance between two points.
-    fn distance(p1: &(f64, f64), p2: &(f64, f64)) -> f64 {
+    fn distance(p1: &(f64, f64), p2: &(f64, f64)) -> Result<f64, ConstructionError> {
         let dx = p1.0 - p2.0;
         let dy = p1.1 - p2.1;
-        (dx * dx + dy * dy).sqrt()
+        let distance = (dx * dx + dy * dy).sqrt();
+        distance.is_finite().then_some(distance).ok_or_else(|| {
+            ConstructionError::NonFiniteFloat(
+                "computing a unit-disk distance produced a non-finite value".into(),
+            )
+        })
     }
 
     /// Get the number of vertices.
@@ -117,7 +141,10 @@ impl UnitDiskGraph {
     /// Get the distance between two vertices.
     pub fn vertex_distance(&self, u: usize, v: usize) -> Option<f64> {
         match (self.positions.get(u), self.positions.get(v)) {
-            (Some(p1), Some(p2)) => Some(Self::distance(p1, p2)),
+            (Some(p1), Some(p2)) => Some(
+                Self::distance(p1, p2)
+                    .expect("validated unit-disk graph has finite pairwise distances"),
+            ),
             _ => None,
         }
     }
@@ -181,17 +208,68 @@ impl UnitDiskGraph {
     /// * `cols` - Number of columns
     /// * `spacing` - Distance between adjacent grid points
     /// * `radius` - Edge creation threshold
-    pub fn grid(rows: usize, cols: usize, spacing: f64, radius: f64) -> Self {
-        let mut positions = Vec::with_capacity(rows * cols);
+    pub fn grid(
+        rows: usize,
+        cols: usize,
+        spacing: f64,
+        radius: f64,
+    ) -> Result<Self, ConstructionError> {
+        if !spacing.is_finite() {
+            return Err(ConstructionError::NonFiniteFloat(
+                "unit-disk grid spacing must be finite".into(),
+            ));
+        }
+        let capacity = rows.checked_mul(cols).ok_or_else(|| {
+            ConstructionError::IntegerOverflow("unit-disk grid size exceeds usize".into())
+        })?;
+        let mut positions = Vec::with_capacity(capacity);
         for r in 0..rows {
             for c in 0..cols {
-                positions.push((c as f64 * spacing, r as f64 * spacing));
+                let c = i64::try_from(c).map_err(|_| {
+                    ConstructionError::IntegerOverflow(
+                        "unit-disk grid column does not fit i64".into(),
+                    )
+                })?;
+                let r = i64::try_from(r).map_err(|_| {
+                    ConstructionError::IntegerOverflow("unit-disk grid row does not fit i64".into())
+                })?;
+                let x = i64_to_exact_f64(c)? * spacing;
+                let y = i64_to_exact_f64(r)? * spacing;
+                if !x.is_finite() || !y.is_finite() {
+                    return Err(ConstructionError::NonFiniteFloat(
+                        "computing unit-disk grid coordinates produced a non-finite value".into(),
+                    ));
+                }
+                positions.push((x, y));
             }
         }
         Self::new(positions, radius)
     }
 }
 
+impl<'de> Deserialize<'de> for UnitDiskGraph {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Raw {
+            positions: Vec<(f64, f64)>,
+            radius: f64,
+            edges: Vec<(usize, usize)>,
+        }
+
+        let raw = Raw::deserialize(deserializer)?;
+        let graph = Self::new(raw.positions, raw.radius).map_err(serde::de::Error::custom)?;
+        if graph.edges != raw.edges {
+            return Err(serde::de::Error::custom(
+                "unit-disk edges do not match positions and radius",
+            ));
+        }
+        Ok(graph)
+    }
+}
+
 impl Graph for UnitDiskGraph {
     const NAME: &'static str = "UnitDiskGraph";
 
@@ -228,10 +306,8 @@ impl Graph for UnitDiskGraph {
     }
 }
 
-use super::graph::SimpleGraph;
 use crate::impl_variant_param;
-impl_variant_param!(UnitDiskGraph, "graph", parent: SimpleGraph,
-    cast: |g| SimpleGraph::new(g.num_vertices(), Graph::edges(g)));
+impl_variant_param!(UnitDiskGraph, "graph");
 
 #[cfg(test)]
 #[path = "../unit_tests/topology/unit_disk_graph.rs"]
diff --git a/src/traits.rs b/src/traits.rs
index 5792e2407..4c1cf333d 100644
--- a/src/traits.rs
+++ b/src/traits.rs
@@ -1,31 +1,47 @@
 //! Core traits for problem definitions.
 
-/// Minimal problem trait — a problem is a function from configuration to value.
+use crate::types::ProblemParameters;
+
+/// Failure while evaluating one configuration of a valid problem instance.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum EvaluationError {
+    #[error("invalid configuration: {0}")]
+    InvalidConfiguration(String),
+    #[error("integer overflow while {0}")]
+    IntegerOverflow(String),
+    #[error("inexact integer-to-float conversion while {0}")]
+    InexactFloatConversion(String),
+    #[error("non-finite floating-point result while {0}")]
+    NonFiniteResult(String),
+}
+
+/// Minimal problem trait — a problem maps a solution to a value or an
+/// evaluation error.
 ///
 /// This trait defines the interface for computational problems that can be
-/// solved by enumeration or reduction to other problems.
+/// evaluated or reduced to other problems.
 pub trait Problem: Clone {
     /// Base name of this problem type (e.g., "MaximumIndependentSet").
     const NAME: &'static str;
+    /// Mathematical witness type for this problem.
+    type Solution;
     /// The evaluation value type.
     type Value: Clone;
-    /// Configuration space dimensions. Each entry is the cardinality of that variable.
-    fn dims(&self) -> Vec<usize>;
-    /// Evaluate the problem on a configuration.
-    fn evaluate(&self, config: &[usize]) -> Self::Value;
-    /// Number of variables (derived from dims).
-    fn num_variables(&self) -> usize {
-        self.dims().len()
-    }
+    /// Canonical parameter names for this problem model.
+    fn parameter_names() -> &'static [&'static str];
+    /// Measure the complete canonical parameters of this concrete instance.
+    fn parameters(&self) -> ProblemParameters;
+    /// Evaluate the problem on a solution.
+    fn evaluate(&self, solution: &Self::Solution) -> Result<Self::Value, EvaluationError>;
     /// Returns variant attributes derived from type parameters.
     ///
     /// Used for generating variant IDs in the reduction graph schema.
-    /// Returns pairs like `[("graph", "SimpleGraph"), ("weight", "i32")]`.
+    /// Returns pairs like `[("graph", "SimpleGraph"), ("weight", "i64")]`.
     fn variant() -> Vec<(&'static str, &'static str)>;
 
     /// Look up this problem's catalog entry.
     ///
-    /// Returns the full [`ProblemType`] metadata from the catalog registry.
+    /// Returns the full [`crate::registry::ProblemType`] metadata from the catalog registry.
     /// The default implementation uses `Self::NAME` to perform the lookup.
     fn problem_type() -> crate::registry::ProblemType {
         crate::registry::find_problem_type(Self::NAME)
@@ -33,9 +49,27 @@ pub trait Problem: Clone {
     }
 }
 
+/// Define a problem's canonical parameters from inherent getter methods.
+#[macro_export]
+macro_rules! problem_parameters {
+    ($(($name:literal, $getter:ident)),+ $(,)?) => {
+        fn parameter_names() -> &'static [&'static str] {
+            &[$($name),+]
+        }
+
+        fn parameters(&self) -> $crate::types::ProblemParameters {
+            $crate::types::ProblemParameters::new(vec![
+                $(($name, u64::try_from(self.$getter()).expect(concat!(
+                    "parameter getter `", $name, "` violated its u64 invariant"
+                )))),+
+            ])
+        }
+    };
+}
+
 /// Marker trait for explicitly declared problem variants.
 ///
-/// Implemented automatically by [`declare_variants!`] for each concrete type.
+/// Implemented automatically by `declare_variants!` for each concrete type.
 /// The [`#[reduction]`] proc macro checks this trait at compile time to ensure
 /// all reduction source/target types have been declared.
 pub trait DeclaredVariant {}
diff --git a/src/types.rs b/src/types.rs
index cc859423b..03146feba 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -4,7 +4,41 @@ use serde::de::{self, DeserializeOwned, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt;
 
-/// Bound for objective value types (i32, f64, etc.)
+/// Largest integer magnitude represented exactly by an IEEE 754 `f64`.
+pub const MAX_EXACT_F64_INTEGER: i64 = (1_i64 << 53) - 1;
+
+/// An `i64` cannot cross an exact-integer `f64` boundary without precision loss.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
+#[error(
+    "integer {value} is outside the exactly representable f64 range [{min}, {max}]",
+    min = -MAX_EXACT_F64_INTEGER,
+    max = MAX_EXACT_F64_INTEGER
+)]
+pub struct ExactI64ToF64Error {
+    pub value: i64,
+}
+
+/// Failure while performing checked arithmetic on a numeric value.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
+pub enum NumericArithmeticError {
+    /// An exact integer result is outside the numeric type's range.
+    #[error("integer overflow")]
+    IntegerOverflow,
+    /// A floating-point result is not finite.
+    #[error("non-finite floating-point result")]
+    NonFiniteResult,
+}
+
+/// Convert an `i64` to `f64` only when the integer value remains exact.
+pub fn i64_to_exact_f64(value: i64) -> Result<f64, ExactI64ToF64Error> {
+    if (-MAX_EXACT_F64_INTEGER..=MAX_EXACT_F64_INTEGER).contains(&value) {
+        Ok(value as f64)
+    } else {
+        Err(ExactI64ToF64Error { value })
+    }
+}
+
+/// Bound for objective value types (i64, f64, etc.)
 pub trait NumericSize:
     Clone
     + Default
@@ -15,38 +49,110 @@ pub trait NumericSize:
     + std::ops::AddAssign
     + 'static
 {
+    /// Add two values when the exact result remains representable and finite.
+    fn checked_add_value(self, other: Self) -> Result<Self, NumericArithmeticError>;
+    /// Multiply two values when the exact result remains representable and finite.
+    fn checked_mul_value(self, other: Self) -> Result<Self, NumericArithmeticError>;
+}
+
+macro_rules! impl_integer_numeric_size {
+    ($($type:ty),* $(,)?) => {
+        $(
+            impl NumericSize for $type {
+                fn checked_add_value(self, other: Self) -> Result<Self, NumericArithmeticError> {
+                    self.checked_add(other).ok_or(NumericArithmeticError::IntegerOverflow)
+                }
+
+                fn checked_mul_value(self, other: Self) -> Result<Self, NumericArithmeticError> {
+                    self.checked_mul(other).ok_or(NumericArithmeticError::IntegerOverflow)
+                }
+            }
+        )*
+    };
 }
 
-impl<T> NumericSize for T where
-    T: Clone
-        + Default
-        + PartialOrd
-        + num_traits::Num
-        + num_traits::Zero
-        + num_traits::Bounded
-        + std::ops::AddAssign
-        + 'static
-{
+impl_integer_numeric_size!(i64, u64, usize);
+
+impl NumericSize for f64 {
+    fn checked_add_value(self, other: Self) -> Result<Self, NumericArithmeticError> {
+        let result = self + other;
+        result
+            .is_finite()
+            .then_some(result)
+            .ok_or(NumericArithmeticError::NonFiniteResult)
+    }
+
+    fn checked_mul_value(self, other: Self) -> Result<Self, NumericArithmeticError> {
+        let result = self * other;
+        result
+            .is_finite()
+            .then_some(result)
+            .ok_or(NumericArithmeticError::NonFiniteResult)
+    }
+}
+
+fn evaluation_arithmetic_error(
+    error: NumericArithmeticError,
+    context: &str,
+) -> crate::traits::EvaluationError {
+    match error {
+        NumericArithmeticError::IntegerOverflow => {
+            crate::traits::EvaluationError::IntegerOverflow(context.to_string())
+        }
+        NumericArithmeticError::NonFiniteResult => {
+            crate::traits::EvaluationError::NonFiniteResult(context.to_string())
+        }
+    }
 }
 
 /// Maps a weight element to its sum/metric type.
 ///
 /// This decouples the per-element weight type from the accumulation type.
-/// For concrete weights (`i32`, `f64`), `Sum` is the same type.
-/// For the unit weight `One`, `Sum = i32`.
+/// Exact integer weights use a wider accumulation type: `i64` and the unit
+/// weight [`One`] both use `i64`. Approximate `f64` weights continue to sum
+/// into `f64`.
 pub trait WeightElement: Clone + Default + 'static {
     /// The numeric type used for sums and comparisons.
     type Sum: NumericSize;
     /// Whether this is the unit weight type (`One`).
     const IS_UNIT: bool;
+    /// Construct the multiplicative unit weight.
+    fn unit() -> Self;
+    /// Validate that an element belongs to the public weight domain.
+    fn validate_element(&self, context: &str) -> Result<(), crate::registry::ConstructionError>;
     /// Convert this weight element to the sum type.
     fn to_sum(&self) -> Self::Sum;
-}
-
-impl WeightElement for i32 {
-    type Sum = i32;
+    /// Add one element to an evaluated objective without overflowing or producing a non-finite value.
+    fn checked_add_to_sum(
+        total: Self::Sum,
+        value: Self::Sum,
+        context: &str,
+    ) -> Result<Self::Sum, crate::traits::EvaluationError> {
+        total
+            .checked_add_value(value)
+            .map_err(|error| evaluation_arithmetic_error(error, context))
+    }
+    /// Multiply evaluated quantities without overflowing or producing a non-finite value.
+    fn checked_mul_sum(
+        left: Self::Sum,
+        right: Self::Sum,
+        context: &str,
+    ) -> Result<Self::Sum, crate::traits::EvaluationError> {
+        left.checked_mul_value(right)
+            .map_err(|error| evaluation_arithmetic_error(error, context))
+    }
+}
+
+impl WeightElement for i64 {
+    type Sum = i64;
     const IS_UNIT: bool = false;
-    fn to_sum(&self) -> i32 {
+    fn unit() -> Self {
+        1
+    }
+    fn validate_element(&self, _context: &str) -> Result<(), crate::registry::ConstructionError> {
+        Ok(())
+    }
+    fn to_sum(&self) -> i64 {
         *self
     }
 }
@@ -54,6 +160,18 @@ impl WeightElement for i32 {
 impl WeightElement for f64 {
     type Sum = f64;
     const IS_UNIT: bool = false;
+    fn unit() -> Self {
+        1.0
+    }
+    fn validate_element(&self, context: &str) -> Result<(), crate::registry::ConstructionError> {
+        if self.is_finite() {
+            Ok(())
+        } else {
+            Err(crate::registry::ConstructionError::NonFiniteFloat(format!(
+                "{context} must be finite"
+            )))
+        }
+    }
     fn to_sum(&self) -> f64 {
         *self
     }
@@ -62,7 +180,7 @@ impl WeightElement for f64 {
 /// The constant 1. Unit weight for unweighted problems.
 ///
 /// When used as the weight type parameter `W`, indicates that all weights
-/// are uniformly 1. `One::to_sum()` returns `1i32`.
+/// are uniformly 1. `One::to_sum()` returns `1i64`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub struct One;
 
@@ -71,7 +189,7 @@ impl Serialize for One {
     where
         S: Serializer,
     {
-        serializer.serialize_i32(1)
+        serializer.serialize_i64(1)
     }
 }
 
@@ -142,9 +260,15 @@ impl<'de> Deserialize<'de> for One {
 }
 
 impl WeightElement for One {
-    type Sum = i32;
+    type Sum = i64;
     const IS_UNIT: bool = true;
-    fn to_sum(&self) -> i32 {
+    fn unit() -> Self {
+        One
+    }
+    fn validate_element(&self, _context: &str) -> Result<(), crate::registry::ConstructionError> {
+        Ok(())
+    }
+    fn to_sum(&self) -> i64 {
         1
     }
 }
@@ -155,33 +279,35 @@ impl std::fmt::Display for One {
     }
 }
 
-impl From<i32> for One {
-    fn from(_: i32) -> Self {
-        One
-    }
+/// Failure while combining configuration values during a solve.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum AggregationError {
+    #[error("aggregate arithmetic overflow or non-finite result")]
+    ArithmeticOverflow,
+    #[error("aggregate values are not comparable")]
+    UnorderedComparison,
+    #[error("cannot combine extrema with different optimization senses")]
+    IncompatibleExtremumSense,
 }
 
-/// Backward-compatible alias for `One`.
-pub type Unweighted = One;
-
 /// Foldable aggregate values for enumerating a problem's configuration space.
 pub trait Aggregate: Clone + fmt::Debug + Serialize + DeserializeOwned {
     /// Neutral element for folding.
     fn identity() -> Self;
 
     /// Associative combine operation.
-    fn combine(self, other: Self) -> Self;
+    fn combine(self, other: Self) -> Result<Self, AggregationError>;
 
-    /// Whether this aggregate admits representative witness configurations.
-    fn supports_witnesses() -> bool {
+    /// Whether no further configuration can change this aggregate value.
+    fn is_absorbing(&self) -> bool {
         false
     }
+}
 
-    /// Whether a configuration-level value belongs to the witness set
-    /// for the final aggregate value.
-    fn contributes_to_witnesses(_config_value: &Self, _total: &Self) -> bool {
-        false
-    }
+/// Aggregate value whose optimum identifies contributing solutions.
+pub trait SolutionAggregate: Aggregate {
+    /// Whether a solution-level value contributes to the final aggregate value.
+    fn contributes_to_solution(value: &Self, total: &Self) -> bool;
 }
 
 /// Maximum aggregate over feasible values.
@@ -193,28 +319,30 @@ impl<V: fmt::Debug + PartialOrd + Clone + Serialize + DeserializeOwned> Aggregat
         Max(None)
     }
 
-    fn combine(self, other: Self) -> Self {
+    fn combine(self, other: Self) -> Result<Self, AggregationError> {
         use std::cmp::Ordering;
 
-        match (self.0, other.0) {
+        Ok(match (self.0, other.0) {
             (None, rhs) => Max(rhs),
             (lhs, None) => Max(lhs),
             (Some(lhs), Some(rhs)) => {
-                let ord = lhs.partial_cmp(&rhs).expect("cannot compare values (NaN?)");
+                let ord = lhs
+                    .partial_cmp(&rhs)
+                    .ok_or(AggregationError::UnorderedComparison)?;
                 match ord {
                     Ordering::Less => Max(Some(rhs)),
                     Ordering::Equal | Ordering::Greater => Max(Some(lhs)),
                 }
             }
-        }
-    }
-
-    fn supports_witnesses() -> bool {
-        true
+        })
     }
+}
 
-    fn contributes_to_witnesses(config_value: &Self, total: &Self) -> bool {
-        matches!((config_value, total), (Max(Some(value)), Max(Some(best))) if value == best)
+impl<V: fmt::Debug + PartialOrd + Clone + Serialize + DeserializeOwned> SolutionAggregate
+    for Max<V>
+{
+    fn contributes_to_solution(value: &Self, total: &Self) -> bool {
+        matches!((value, total), (Max(Some(value)), Max(Some(best))) if value == best)
     }
 }
 
@@ -250,28 +378,30 @@ impl<V: fmt::Debug + PartialOrd + Clone + Serialize + DeserializeOwned> Aggregat
         Min(None)
     }
 
-    fn combine(self, other: Self) -> Self {
+    fn combine(self, other: Self) -> Result<Self, AggregationError> {
         use std::cmp::Ordering;
 
-        match (self.0, other.0) {
+        Ok(match (self.0, other.0) {
             (None, rhs) => Min(rhs),
             (lhs, None) => Min(lhs),
             (Some(lhs), Some(rhs)) => {
-                let ord = lhs.partial_cmp(&rhs).expect("cannot compare values (NaN?)");
+                let ord = lhs
+                    .partial_cmp(&rhs)
+                    .ok_or(AggregationError::UnorderedComparison)?;
                 match ord {
                     Ordering::Greater => Min(Some(rhs)),
                     Ordering::Equal | Ordering::Less => Min(Some(lhs)),
                 }
             }
-        }
-    }
-
-    fn supports_witnesses() -> bool {
-        true
+        })
     }
+}
 
-    fn contributes_to_witnesses(config_value: &Self, total: &Self) -> bool {
-        matches!((config_value, total), (Min(Some(value)), Min(Some(best))) if value == best)
+impl<V: fmt::Debug + PartialOrd + Clone + Serialize + DeserializeOwned> SolutionAggregate
+    for Min<V>
+{
+    fn contributes_to_solution(value: &Self, total: &Self) -> bool {
+        matches!((value, total), (Min(Some(value)), Min(Some(best))) if value == best)
     }
 }
 
@@ -327,7 +457,7 @@ impl<V: fmt::Debug + PartialOrd + Clone + Serialize + DeserializeOwned> Optimiza
     }
 }
 
-/// Sum aggregate for value-only problems.
+/// Additive fold value.
 #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
 pub struct Sum<W>(pub W);
 
@@ -336,10 +466,11 @@ impl<W: fmt::Debug + NumericSize + Serialize + DeserializeOwned> Aggregate for S
         Sum(W::zero())
     }
 
-    fn combine(self, other: Self) -> Self {
-        let mut total = self.0;
-        total += other.0;
-        Sum(total)
+    fn combine(self, other: Self) -> Result<Self, AggregationError> {
+        self.0
+            .checked_add_value(other.0)
+            .map(Sum)
+            .map_err(|_| AggregationError::ArithmeticOverflow)
     }
 }
 
@@ -368,16 +499,18 @@ impl Aggregate for Or {
         Or(false)
     }
 
-    fn combine(self, other: Self) -> Self {
-        Or(self.0 || other.0)
+    fn combine(self, other: Self) -> Result<Self, AggregationError> {
+        Ok(Or(self.0 || other.0))
     }
 
-    fn supports_witnesses() -> bool {
-        true
+    fn is_absorbing(&self) -> bool {
+        self.0
     }
+}
 
-    fn contributes_to_witnesses(config_value: &Self, total: &Self) -> bool {
-        config_value.0 && total.0
+impl SolutionAggregate for Or {
+    fn contributes_to_solution(value: &Self, total: &Self) -> bool {
+        value.0 && total.0
     }
 }
 
@@ -416,8 +549,12 @@ impl Aggregate for And {
         And(true)
     }
 
-    fn combine(self, other: Self) -> Self {
-        And(self.0 && other.0)
+    fn combine(self, other: Self) -> Result<Self, AggregationError> {
+        Ok(And(self.0 && other.0))
+    }
+
+    fn is_absorbing(&self) -> bool {
+        !self.0
     }
 }
 
@@ -472,10 +609,10 @@ impl<V: fmt::Debug + PartialOrd + Clone + Serialize + DeserializeOwned> Aggregat
         Self::maximize(None)
     }
 
-    fn combine(self, other: Self) -> Self {
+    fn combine(self, other: Self) -> Result<Self, AggregationError> {
         use std::cmp::Ordering;
 
-        match (self.value, other.value) {
+        Ok(match (self.value, other.value) {
             (None, rhs) => Self {
                 sense: other.sense,
                 value: rhs,
@@ -485,11 +622,12 @@ impl<V: fmt::Debug + PartialOrd + Clone + Serialize + DeserializeOwned> Aggregat
                 value: lhs,
             },
             (Some(lhs), Some(rhs)) => {
-                assert_eq!(
-                    self.sense, other.sense,
-                    "cannot combine Extremum values with different senses"
-                );
-                let ord = lhs.partial_cmp(&rhs).expect("cannot compare values (NaN?)");
+                if self.sense != other.sense {
+                    return Err(AggregationError::IncompatibleExtremumSense);
+                }
+                let ord = lhs
+                    .partial_cmp(&rhs)
+                    .ok_or(AggregationError::UnorderedComparison)?;
                 let keep_self = match self.sense {
                     ExtremumSense::Maximize => matches!(ord, Ordering::Equal | Ordering::Greater),
                     ExtremumSense::Minimize => matches!(ord, Ordering::Equal | Ordering::Less),
@@ -506,17 +644,17 @@ impl<V: fmt::Debug + PartialOrd + Clone + Serialize + DeserializeOwned> Aggregat
                     }
                 }
             }
-        }
-    }
-
-    fn supports_witnesses() -> bool {
-        true
+        })
     }
+}
 
-    fn contributes_to_witnesses(config_value: &Self, total: &Self) -> bool {
+impl<V: fmt::Debug + PartialOrd + Clone + Serialize + DeserializeOwned> SolutionAggregate
+    for Extremum<V>
+{
+    fn contributes_to_solution(candidate: &Self, total: &Self) -> bool {
         matches!(
-            (config_value.value.as_ref(), total.value.as_ref()),
-            (Some(value), Some(best)) if config_value.sense == total.sense && value == best
+            (candidate.value.as_ref(), total.value.as_ref()),
+            (Some(value), Some(best)) if candidate.sense == total.sense && value == best
         )
     }
 }
@@ -532,41 +670,83 @@ impl<V: fmt::Display> fmt::Display for Extremum<V> {
     }
 }
 
-/// Problem size metadata (varies by problem type).
+/// Canonical named parameters for one concrete problem instance.
 #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ProblemSize {
-    /// Named size components.
-    pub components: Vec<(String, usize)>,
-}
-
-impl ProblemSize {
-    /// Create a new problem size with named components.
-    pub fn new(components: Vec<(&str, usize)>) -> Self {
-        Self {
-            components: components
+pub struct ProblemParameters {
+    /// Named parameters in canonical declaration order.
+    #[serde(deserialize_with = "deserialize_parameter_components")]
+    pub(crate) components: Vec<(String, u64)>,
+}
+
+impl ProblemParameters {
+    /// Create problem parameters in canonical declaration order.
+    ///
+    /// # Panics
+    /// Panics if a parameter name occurs more than once.
+    pub fn new(components: Vec<(&str, u64)>) -> Self {
+        Self::from_owned(
+            components
                 .into_iter()
-                .map(|(k, v)| (k.to_string(), v))
+                .map(|(name, value)| (name.to_string(), value))
                 .collect(),
+        )
+    }
+
+    /// Create problem parameters from owned names.
+    ///
+    /// # Panics
+    /// Panics if a parameter name occurs more than once.
+    pub fn from_owned(components: Vec<(String, u64)>) -> Self {
+        if let Some(name) = duplicate_parameter_name(&components) {
+            panic!("duplicate problem parameter `{name}`");
         }
+        Self { components }
+    }
+
+    /// Iterate over parameters in canonical declaration order.
+    pub fn iter(&self) -> impl Iterator<Item = (&str, u64)> {
+        self.components
+            .iter()
+            .map(|(name, value)| (name.as_str(), *value))
     }
 
-    /// Get a size component by name.
-    pub fn get(&self, name: &str) -> Option<usize> {
+    /// Get a parameter by name.
+    pub fn get(&self, name: &str) -> Option<u64> {
         self.components
             .iter()
             .find(|(k, _)| k == name)
             .map(|(_, v)| *v)
     }
+}
+
+fn duplicate_parameter_name(components: &[(String, u64)]) -> Option<&str> {
+    components
+        .iter()
+        .enumerate()
+        .find_map(|(index, (name, _))| {
+            components[..index]
+                .iter()
+                .any(|(previous, _)| previous == name)
+                .then_some(name.as_str())
+        })
+}
 
-    /// Sum of all component values.
-    pub fn total(&self) -> usize {
-        self.components.iter().map(|(_, v)| *v).sum()
+fn deserialize_parameter_components<'de, D>(deserializer: D) -> Result<Vec<(String, u64)>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let components = Vec::<(String, u64)>::deserialize(deserializer)?;
+    if let Some(name) = duplicate_parameter_name(&components) {
+        return Err(serde::de::Error::custom(format!(
+            "duplicate problem parameter `{name}`"
+        )));
     }
+    Ok(components)
 }
 
-impl fmt::Display for ProblemSize {
+impl fmt::Display for ProblemParameters {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "ProblemSize{{")?;
+        write!(f, "ProblemParameters{{")?;
         for (i, (name, value)) in self.components.iter().enumerate() {
             if i > 0 {
                 write!(f, ", ")?;
@@ -580,8 +760,8 @@ impl fmt::Display for ProblemSize {
 use crate::impl_variant_param;
 
 impl_variant_param!(f64, "weight");
-impl_variant_param!(i32, "weight", parent: f64, cast: |w| *w as f64);
-impl_variant_param!(One, "weight", parent: i32, cast: |_| 1i32);
+impl_variant_param!(i64, "weight");
+impl_variant_param!(One, "weight");
 
 #[cfg(test)]
 #[path = "unit_tests/types.rs"]
diff --git a/src/unit_tests/big_o.rs b/src/unit_tests/big_o.rs
index 6dab26625..ef0efafaf 100644
--- a/src/unit_tests/big_o.rs
+++ b/src/unit_tests/big_o.rs
@@ -85,7 +85,7 @@ fn test_big_o_composed_overhead_duplicate() {
 #[test]
 fn test_big_o_exp_with_polynomial() {
     // exp(n) dominates n^10
-    let e = Expr::Exp(Box::new(Expr::Var("n"))) + Expr::pow(Expr::Var("n"), Expr::Const(10.0));
+    let e = Expr::exp(Expr::variable("n")) + Expr::pow(Expr::variable("n"), Expr::integer(10));
     let result = big_o_normal_form(&e).unwrap();
     let s = result.to_string();
     assert!(s.contains("exp"), "expected exp term to survive, got: {s}");
@@ -97,33 +97,40 @@ fn test_big_o_exp_with_polynomial() {
 
 #[test]
 fn test_big_o_pure_constant_returns_one() {
-    let e = Expr::Const(42.0);
+    let e = Expr::integer(42);
     let result = big_o_normal_form(&e).unwrap();
     assert_eq!(result.to_string(), "1");
 }
 
 #[test]
-fn test_big_o_rejects_division() {
-    let e = Expr::Var("n") / Expr::Var("m");
-    assert!(big_o_normal_form(&e).is_err());
+fn test_big_o_rejects_negative_symbolic_power() {
+    let e = Expr::variable("n") / Expr::variable("m");
+    let error = big_o_normal_form(&e).unwrap_err();
+    assert_eq!(
+        error.to_string(),
+        "unsupported asymptotic expression: negative exponent is unsupported: -1"
+    );
 }
 
 #[test]
-fn test_big_o_rejects_negative_dominant_term() {
-    let e = Expr::Const(-1.0) * Expr::Var("n");
-    assert!(big_o_normal_form(&e).is_err());
+fn test_big_o_drops_negative_constant_factor() {
+    // The growth domain drops constant multipliers, sign included, so `-1 * n`
+    // widens to `n` (an upper bound on its magnitude) instead of being rejected.
+    let e = Expr::integer(-1) * Expr::variable("n");
+    let result = big_o_normal_form(&e).unwrap();
+    assert_eq!(result.to_string(), "n");
 }
 
 #[test]
 fn test_big_o_constant_base_one_becomes_constant() {
-    let e = Expr::pow(Expr::Const(1.0), Expr::Var("n"));
+    let e = Expr::pow(Expr::integer(1), Expr::variable("n"));
     let result = big_o_normal_form(&e).unwrap();
     assert_eq!(result.to_string(), "1");
 }
 
 #[test]
 fn test_big_o_rejects_nonpositive_constant_base_exponential() {
-    let e = Expr::pow(Expr::Const(-2.0), Expr::Var("n"));
+    let e = Expr::pow(Expr::integer(-2), Expr::variable("n"));
     assert!(big_o_normal_form(&e).is_err());
 }
 
@@ -219,11 +226,17 @@ fn test_big_o_multivar_exp_dominates_poly() {
 }
 
 #[test]
-fn test_big_o_pathological_nesting_errors_instead_of_hanging() {
-    // Regression for issue #1069: a deeply-nested power that expands
-    // exponentially must return an error promptly (so callers like `big_o_of`
-    // fall back to the un-expanded expression) rather than OOM/hang.
-    let sum = Expr::Var("a") + Expr::Var("b") + Expr::Var("c") + Expr::Var("d");
-    let e = Expr::pow(Expr::pow(sum, Expr::Const(4.0)), Expr::Const(4.0));
-    assert!(big_o_normal_form(&e).is_err());
+fn test_big_o_pathological_nesting_returns_bound_instantly() {
+    // A deeply nested power that the old expansion pipeline could not normalize.
+    // The growth domain answers it bottom-up: `((a+b+c+d)^4)^4` raises each
+    // variable term to degree 16, so it returns a real bound immediately.
+    let sum = Expr::variable("a") + Expr::variable("b") + Expr::variable("c") + Expr::variable("d");
+    let e = Expr::pow(Expr::pow(sum, Expr::integer(4)), Expr::integer(4));
+    let start = std::time::Instant::now();
+    let result = big_o_normal_form(&e).unwrap();
+    assert!(start.elapsed().as_millis() < 50, "should be instant");
+    let s = result.to_string();
+    for v in ["a^16", "b^16", "c^16", "d^16"] {
+        assert!(s.contains(v), "expected {v} in {s}");
+    }
 }
diff --git a/src/unit_tests/canonical.rs b/src/unit_tests/canonical.rs
deleted file mode 100644
index dcf3f8fd0..000000000
--- a/src/unit_tests/canonical.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-use super::*;
-use crate::expr::Expr;
-
-#[test]
-fn test_canonical_identity() {
-    let e = Expr::Var("n");
-    let c = canonical_form(&e).unwrap();
-    assert_eq!(c.to_string(), "n");
-}
-
-#[test]
-fn test_canonical_add_like_terms() {
-    // n + n → 2 * n
-    let e = Expr::Var("n") + Expr::Var("n");
-    let c = canonical_form(&e).unwrap();
-    assert_eq!(c.to_string(), "2 * n");
-}
-
-#[test]
-fn test_canonical_subtract_to_zero() {
-    // n - n → 0
-    let e = Expr::Var("n") - Expr::Var("n");
-    let c = canonical_form(&e).unwrap();
-    assert_eq!(c.to_string(), "0");
-}
-
-#[test]
-fn test_canonical_mixed_addition() {
-    // n + n - m + 2*m → 2*n + m
-    let e = Expr::Var("n") + Expr::Var("n") - Expr::Var("m") + Expr::Const(2.0) * Expr::Var("m");
-    let c = canonical_form(&e).unwrap();
-    assert_eq!(c.to_string(), "m + 2 * n");
-}
-
-#[test]
-fn test_canonical_exp_product_identity() {
-    // exp(n) * exp(m) -> exp(m + n)  (transcendental identity, alphabetical order)
-    let e = Expr::Exp(Box::new(Expr::Var("n"))) * Expr::Exp(Box::new(Expr::Var("m")));
-    let c = canonical_form(&e).unwrap();
-    // Verify numerical equivalence
-    let size = crate::types::ProblemSize::new(vec![("n", 2), ("m", 3)]);
-    assert!((c.eval(&size) - (2.0_f64.exp() * 3.0_f64.exp())).abs() < 1e-6);
-}
-
-#[test]
-fn test_canonical_constant_base_exp_identity() {
-    // 2^n * 2^m -> 2^(m + n)
-    let e =
-        Expr::pow(Expr::Const(2.0), Expr::Var("n")) * Expr::pow(Expr::Const(2.0), Expr::Var("m"));
-    let c = canonical_form(&e).unwrap();
-    let size = crate::types::ProblemSize::new(vec![("n", 3), ("m", 4)]);
-    assert!((c.eval(&size) - 2.0_f64.powf(7.0)).abs() < 1e-6);
-}
-
-#[test]
-fn test_canonical_polynomial_expansion() {
-    // (n + m)^2 = n^2 + 2*n*m + m^2
-    let e = Expr::pow(Expr::Var("n") + Expr::Var("m"), Expr::Const(2.0));
-    let c = canonical_form(&e).unwrap();
-    let size = crate::types::ProblemSize::new(vec![("n", 3), ("m", 4)]);
-    assert_eq!(c.eval(&size), 49.0); // (3+4)^2 = 49
-}
-
-#[test]
-fn test_canonical_signed_polynomial() {
-    // n^3 - n^2 + 2*n + 4*n*m — should remain exact
-    let e = Expr::pow(Expr::Var("n"), Expr::Const(3.0))
-        - Expr::pow(Expr::Var("n"), Expr::Const(2.0))
-        + Expr::Const(2.0) * Expr::Var("n")
-        + Expr::Const(4.0) * Expr::Var("n") * Expr::Var("m");
-    let c = canonical_form(&e).unwrap();
-    let size = crate::types::ProblemSize::new(vec![("n", 3), ("m", 2)]);
-    // 27 - 9 + 6 + 24 = 48
-    assert_eq!(c.eval(&size), 48.0);
-}
-
-#[test]
-fn test_canonical_division_becomes_negative_exponent() {
-    // n / m should canonicalize; the division is represented as m^(-1)
-    // which becomes an opaque factor (negative exponent)
-    let e = Expr::Var("n") / Expr::Var("m");
-    let c = canonical_form(&e).unwrap();
-    let size = crate::types::ProblemSize::new(vec![("n", 6), ("m", 3)]);
-    assert!((c.eval(&size) - 2.0).abs() < 1e-10);
-}
-
-#[test]
-fn test_canonical_distinct_fractional_exponents_do_not_merge() {
-    let e = Expr::pow(Expr::Var("n"), Expr::Const(1.0004)) - Expr::Var("n");
-    let c = canonical_form(&e).unwrap();
-    assert_ne!(c.to_string(), "0");
-    let size = crate::types::ProblemSize::new(vec![("n", 2)]);
-    assert_ne!(c.eval(&size), 0.0);
-}
-
-#[test]
-fn test_canonical_constant_base_one_folds_to_constant() {
-    let e = Expr::pow(Expr::Const(1.0), Expr::Var("n"));
-    let c = canonical_form(&e).unwrap();
-    assert_eq!(c.to_string(), "1");
-}
-
-#[test]
-fn test_canonical_negative_constant_base_with_symbolic_exponent_is_rejected() {
-    let e = Expr::pow(Expr::Const(-2.0), Expr::Var("n"));
-    let err = canonical_form(&e).unwrap_err();
-    assert!(matches!(err, CanonicalizationError::Unsupported(_)));
-}
-
-#[test]
-fn test_canonical_zero_constant_base_with_symbolic_exponent_is_rejected() {
-    let e = Expr::pow(Expr::Const(0.0), Expr::Var("n"));
-    let err = canonical_form(&e).unwrap_err();
-    assert!(matches!(err, CanonicalizationError::Unsupported(_)));
-}
-
-#[test]
-fn test_canonical_deterministic_order() {
-    // m + n and n + m should produce the same canonical form
-    let a = canonical_form(&(Expr::Var("m") + Expr::Var("n"))).unwrap();
-    let b = canonical_form(&(Expr::Var("n") + Expr::Var("m"))).unwrap();
-    assert_eq!(a.to_string(), b.to_string());
-}
-
-#[test]
-fn test_canonical_constant_folding() {
-    // 2 + 3 → 5
-    let e = Expr::Const(2.0) + Expr::Const(3.0);
-    let c = canonical_form(&e).unwrap();
-    assert_eq!(c.to_string(), "5");
-}
-
-#[test]
-fn test_canonical_sqrt_as_power() {
-    // sqrt(n) should canonicalize the same as n^0.5
-    let a = canonical_form(&Expr::Sqrt(Box::new(Expr::Var("n")))).unwrap();
-    let b = canonical_form(&Expr::pow(Expr::Var("n"), Expr::Const(0.5))).unwrap();
-    assert_eq!(a.to_string(), b.to_string());
-}
-
-#[test]
-fn test_canonical_nested_power_blowup_is_capped() {
-    // Regression for issue #1069: a "square of a square of a sum" structure —
-    // the shape composed-path overheads take when they traverse
-    // quadratic-overhead reductions — expands exponentially. Before the cap
-    // this OOM'd / hung indefinitely; now it must fail fast with Unsupported
-    // rather than try to materialize the blown-up monomial expansion.
-    let sum = Expr::Var("a") + Expr::Var("b") + Expr::Var("c") + Expr::Var("d");
-    // ((a+b+c+d)^4)^4 expands to >50_000 intermediate terms.
-    let e = Expr::pow(Expr::pow(sum, Expr::Const(4.0)), Expr::Const(4.0));
-    let err = canonical_form(&e).unwrap_err();
-    assert!(matches!(err, CanonicalizationError::Unsupported(_)));
-}
-
-#[test]
-fn test_canonical_moderate_power_still_expands() {
-    // The cap must not perturb legitimate, modestly-sized expressions:
-    // (a+b)^3 stays well under the cap and expands normally.
-    let e = Expr::pow(Expr::Var("a") + Expr::Var("b"), Expr::Const(3.0));
-    let c = canonical_form(&e).unwrap();
-    // a^3 + 3 a^2 b + 3 a b^2 + b^3 — compare against the same expansion
-    // written out flat (both go through canonical_form for identical ordering).
-    let expected = canonical_form(&Expr::parse("a^3 + 3*a^2*b + 3*a*b^2 + b^3")).unwrap();
-    assert_eq!(c.to_string(), expected.to_string());
-}
diff --git a/src/unit_tests/config.rs b/src/unit_tests/config.rs
index 5d853a008..37522b734 100644
--- a/src/unit_tests/config.rs
+++ b/src/unit_tests/config.rs
@@ -43,68 +43,3 @@ fn test_bits_to_config() {
     );
     assert_eq!(bits_to_config(&[true, true, true]), vec![1, 1, 1]);
 }
-
-// === DimsIterator tests ===
-
-#[test]
-fn test_dims_iterator_uniform_binary() {
-    let iter = DimsIterator::new(vec![2, 2, 2]);
-    assert_eq!(iter.total(), 8);
-
-    let configs: Vec<_> = iter.collect();
-    assert_eq!(configs.len(), 8);
-    assert_eq!(configs[0], vec![0, 0, 0]);
-    assert_eq!(configs[7], vec![1, 1, 1]);
-}
-
-#[test]
-fn test_dims_iterator_mixed_dims() {
-    let iter = DimsIterator::new(vec![2, 3]);
-    assert_eq!(iter.total(), 6);
-
-    let configs: Vec<_> = iter.collect();
-    assert_eq!(configs.len(), 6);
-    assert_eq!(configs[0], vec![0, 0]);
-    assert_eq!(configs[1], vec![0, 1]);
-    assert_eq!(configs[2], vec![0, 2]);
-    assert_eq!(configs[3], vec![1, 0]);
-    assert_eq!(configs[4], vec![1, 1]);
-    assert_eq!(configs[5], vec![1, 2]);
-}
-
-#[test]
-fn test_dims_iterator_empty() {
-    // Empty dims means exactly 1 configuration: the empty config
-    let iter = DimsIterator::new(vec![]);
-    assert_eq!(iter.total(), 1);
-    let configs: Vec<_> = iter.collect();
-    let expected: Vec<Vec<usize>> = vec![vec![]];
-    assert_eq!(configs, expected); // One config: the empty config
-}
-
-#[test]
-fn test_dims_iterator_zero_dimension() {
-    // Any dimension being 0 means no valid configs
-    let iter = DimsIterator::new(vec![2, 0, 3]);
-    assert_eq!(iter.total(), 0);
-    assert!(iter.collect::<Vec<_>>().is_empty());
-}
-
-#[test]
-fn test_dims_iterator_single_variable() {
-    let iter = DimsIterator::new(vec![4]);
-    assert_eq!(iter.total(), 4);
-    let configs: Vec<_> = iter.collect();
-    assert_eq!(configs, vec![vec![0], vec![1], vec![2], vec![3]]);
-}
-
-#[test]
-fn test_dims_iterator_exact_size() {
-    let mut iter = DimsIterator::new(vec![2, 3]);
-    assert_eq!(iter.len(), 6);
-    iter.next();
-    assert_eq!(iter.len(), 5);
-    iter.next();
-    iter.next();
-    assert_eq!(iter.len(), 3);
-}
diff --git a/src/unit_tests/example_db.rs b/src/unit_tests/example_db.rs
index 43dc121f4..73d85007f 100644
--- a/src/unit_tests/example_db.rs
+++ b/src/unit_tests/example_db.rs
@@ -26,12 +26,12 @@ fn test_build_example_db_contains_models_and_rules() {
 }
 
 #[test]
-fn test_find_model_example_mis_simplegraph_i32() {
+fn test_find_model_example_mis_simplegraph_i64() {
     let problem = ProblemRef {
         name: "MaximumIndependentSet".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
 
@@ -40,7 +40,7 @@ fn test_find_model_example_mis_simplegraph_i32() {
     assert_eq!(example.variant, problem.variant);
     assert!(example.instance.is_object());
     assert!(
-        !example.optimal_config.is_empty(),
+        !example.optimal_config.as_array().unwrap().is_empty(),
         "canonical example should include optima"
     );
 }
@@ -57,7 +57,7 @@ fn test_find_model_example_exact_cover_by_3_sets() {
     assert_eq!(example.variant, problem.variant);
     assert!(example.instance.is_object());
     assert!(
-        !example.optimal_config.is_empty(),
+        !example.optimal_config.as_array().unwrap().is_empty(),
         "canonical example should include satisfying assignments"
     );
 }
@@ -75,7 +75,7 @@ fn test_find_model_example_staff_scheduling() {
     assert_eq!(example.instance["num_workers"], 4);
     assert!(example.instance["schedules"].is_array());
     assert!(
-        !example.optimal_config.is_empty(),
+        !example.optimal_config.as_array().unwrap().is_empty(),
         "canonical example should include satisfying assignments"
     );
 }
@@ -90,7 +90,7 @@ fn test_find_model_example_stacker_crane() {
     let example = find_model_example(&problem).expect("StackerCrane example should exist");
     assert_eq!(example.problem, "StackerCrane");
     assert_eq!(example.variant, problem.variant);
-    assert_eq!(example.optimal_config, vec![0, 2, 1, 4, 3]);
+    assert_eq!(example.optimal_config, serde_json::json!([0, 2, 1, 4, 3]));
     assert_eq!(example.instance["num_vertices"], 6);
     assert_eq!(example.instance["arcs"].as_array().unwrap().len(), 5);
 }
@@ -107,7 +107,7 @@ fn test_find_model_example_multiprocessor_scheduling() {
     assert_eq!(example.variant, problem.variant);
     assert!(example.instance.is_object());
     assert!(
-        !example.optimal_config.is_empty(),
+        !example.optimal_config.as_array().unwrap().is_empty(),
         "canonical example should include satisfying assignments"
     );
 }
@@ -126,7 +126,7 @@ fn test_find_model_example_job_shop_scheduling() {
     assert!(example.instance["jobs"].is_array());
     assert_eq!(
         example.optimal_config,
-        vec![0, 0, 0, 0, 0, 0, 1, 3, 0, 1, 1, 0]
+        serde_json::json!([0, 0, 0, 0, 0, 0, 1, 3, 0, 1, 1, 0])
     );
 }
 
@@ -142,14 +142,17 @@ fn test_find_model_example_integral_flow_bundles() {
     assert_eq!(example.variant, problem.variant);
     assert_eq!(example.instance["graph"]["num_vertices"], 4);
     assert_eq!(example.instance["requirement"], 1);
-    assert_eq!(example.optimal_config, vec![1, 0, 1, 0, 0, 0]);
+    assert_eq!(
+        example.optimal_config,
+        serde_json::json!([1, 0, 1, 0, 0, 0])
+    );
 }
 
 #[test]
 fn test_find_model_example_strong_connectivity_augmentation() {
     let problem = ProblemRef {
         name: "StrongConnectivityAugmentation".to_string(),
-        variant: BTreeMap::from([("weight".to_string(), "i32".to_string())]),
+        variant: BTreeMap::from([("weight".to_string(), "i64".to_string())]),
     };
 
     let example = find_model_example(&problem).expect("SCA example should exist");
@@ -157,7 +160,7 @@ fn test_find_model_example_strong_connectivity_augmentation() {
     assert_eq!(example.variant, problem.variant);
     assert!(example.instance.is_object());
     assert!(
-        !example.optimal_config.is_empty(),
+        !example.optimal_config.as_array().unwrap().is_empty(),
         "canonical example should include satisfying assignments"
     );
 }
@@ -177,7 +180,10 @@ fn test_find_model_example_integral_flow_homologous_arcs() {
         example.instance["homologous_pairs"],
         serde_json::json!([[2, 5], [4, 3]])
     );
-    assert_eq!(example.optimal_config, vec![1, 1, 1, 0, 0, 1, 1, 1]);
+    assert_eq!(
+        example.optimal_config,
+        serde_json::json!([1, 1, 1, 0, 0, 1, 1, 1])
+    );
 }
 
 #[test]
@@ -193,7 +199,7 @@ fn test_find_model_example_minimum_dummy_activities_pert() {
     assert!(example.instance.is_object());
     assert_eq!(example.optimal_value, serde_json::json!(2));
     assert!(
-        !example.optimal_config.is_empty(),
+        !example.optimal_config.as_array().unwrap().is_empty(),
         "canonical example should include an optimal merge selection"
     );
 }
@@ -204,7 +210,7 @@ fn test_find_model_example_decision_minimum_vertex_cover() {
         name: "DecisionMinimumVertexCover".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
 
@@ -214,7 +220,10 @@ fn test_find_model_example_decision_minimum_vertex_cover() {
     assert_eq!(example.variant, problem.variant);
     assert_eq!(example.instance["bound"], 2);
     assert_eq!(example.instance["inner"]["graph"]["num_vertices"], 4);
-    assert_eq!(example.optimal_config, vec![1, 0, 1, 0]);
+    assert_eq!(
+        example.optimal_config,
+        serde_json::json!([true, false, true, false])
+    );
     assert_eq!(example.optimal_value, serde_json::json!(true));
 }
 
@@ -224,14 +233,14 @@ fn test_find_rule_example_mvc_to_mis_contains_full_problem_json() {
         name: "MinimumVertexCover".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let target = ProblemRef {
         name: "MaximumIndependentSet".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
 
@@ -265,7 +274,6 @@ fn test_find_rule_example_sat_to_kcoloring_contains_full_instances() {
     );
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_find_rule_example_integral_flow_bundles_to_ilp_contains_full_instances() {
     let source = ProblemRef {
@@ -274,18 +282,28 @@ fn test_find_rule_example_integral_flow_bundles_to_ilp_contains_full_instances()
     };
     let target = ProblemRef {
         name: "ILP".to_string(),
-        variant: BTreeMap::from([("variable".to_string(), "i32".to_string())]),
+        variant: BTreeMap::from([
+            ("variable".to_string(), "i64".to_string()),
+            ("coefficient".to_string(), "i64".to_string()),
+        ]),
     };
 
     let example = find_rule_example(&source, &target).expect("IntegralFlowBundles -> ILP exists");
     assert_eq!(example.source.problem, "IntegralFlowBundles");
     assert_eq!(example.target.problem, "ILP");
     assert!(example.source.instance.get("graph").is_some());
-    assert!(!example.solutions[0].source_config.is_empty());
-    assert!(!example.solutions[0].target_config.is_empty());
+    assert!(!example.solutions[0]
+        .source_config
+        .as_array()
+        .unwrap()
+        .is_empty());
+    assert!(!example.solutions[0]
+        .target_config
+        .as_array()
+        .unwrap()
+        .is_empty());
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_find_rule_example_threedimensionalmatching_to_ilp_contains_full_instances() {
     let source = ProblemRef {
@@ -294,7 +312,10 @@ fn test_find_rule_example_threedimensionalmatching_to_ilp_contains_full_instance
     };
     let target = ProblemRef {
         name: "ILP".to_string(),
-        variant: BTreeMap::from([("variable".to_string(), "bool".to_string())]),
+        variant: BTreeMap::from([
+            ("variable".to_string(), "bool".to_string()),
+            ("coefficient".to_string(), "i64".to_string()),
+        ]),
     };
 
     let example =
@@ -302,8 +323,14 @@ fn test_find_rule_example_threedimensionalmatching_to_ilp_contains_full_instance
     assert_eq!(example.source.problem, "ThreeDimensionalMatching");
     assert_eq!(example.target.problem, "ILP");
     assert!(example.source.instance.get("triples").is_some());
-    assert_eq!(example.solutions[0].source_config, vec![1, 1, 1, 0, 0]);
-    assert_eq!(example.solutions[0].target_config, vec![1, 1, 1, 0, 0]);
+    assert_eq!(
+        example.solutions[0].source_config,
+        serde_json::json!([true, true, true, false, false])
+    );
+    assert_eq!(
+        example.solutions[0].target_config,
+        serde_json::json!([1, 1, 1, 0, 0])
+    );
 }
 
 #[test]
@@ -329,12 +356,15 @@ fn test_find_rule_example_rejects_composed_path_pairs() {
         name: "MaximumIndependentSet".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let target = ProblemRef {
         name: "ILP".to_string(),
-        variant: BTreeMap::from([("variable".to_string(), "bool".to_string())]),
+        variant: BTreeMap::from([
+            ("variable".to_string(), "bool".to_string()),
+            ("coefficient".to_string(), "i64".to_string()),
+        ]),
     };
 
     let result = find_rule_example(&source, &target);
@@ -421,7 +451,7 @@ fn canonical_rule_examples_cover_exactly_authored_direct_reductions() {
         .into_iter()
         .filter(|entry| entry.source_name != entry.target_name)
         // Turing (multi-query) edges have no single-shot reduction to demonstrate
-        .filter(|entry| !entry.capabilities.turing)
+        .filter(|entry| !entry.turing)
         .map(|entry| {
             (
                 ProblemRef {
@@ -437,8 +467,11 @@ fn canonical_rule_examples_cover_exactly_authored_direct_reductions() {
         .collect();
 
     assert_eq!(
-        example_keys, direct_reduction_keys,
-        "rule example coverage should match authored direct reductions exactly"
+        example_keys,
+        direct_reduction_keys,
+        "rule example coverage should match authored direct reductions exactly; missing examples: {:?}; unexpected examples: {:?}",
+        direct_reduction_keys.difference(&example_keys).collect::<Vec<_>>(),
+        example_keys.difference(&direct_reduction_keys).collect::<Vec<_>>()
     );
 }
 
@@ -490,7 +523,15 @@ fn model_specs_are_self_consistent() {
         .chain(crate::models::misc::canonical_model_example_specs());
 
     for spec in specs {
-        let actual = spec.instance.evaluate_json(&spec.optimal_config);
+        let actual = spec
+            .instance
+            .evaluate_json(&spec.optimal_config)
+            .unwrap_or_else(|error| {
+                panic!(
+                    "Model spec '{}': canonical configuration evaluation failed: {error}",
+                    spec.id
+                )
+            });
         assert_eq!(
             actual, spec.optimal_value,
             "Model spec '{}': evaluate(optimal_config) = {} but stored optimal_value = {}",
@@ -499,13 +540,10 @@ fn model_specs_are_self_consistent() {
     }
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn model_specs_are_optimal() {
-    use crate::registry::find_variant_entry;
-    use crate::solvers::ILPSolver;
-
-    let ilp_solver = ILPSolver::new();
+    use crate::registry::load_dyn;
+    use crate::solvers::{brute_force_dimensions, solve, SolveOutcome, SolverRequest};
 
     let specs = crate::models::graph::canonical_model_example_specs()
         .into_iter()
@@ -517,20 +555,35 @@ fn model_specs_are_optimal() {
     for spec in specs {
         let name = spec.instance.problem_name();
         let variant = spec.instance.variant_map();
-        // Try brute force first for small instances (fast, avoids expensive ILP chains)
-        let dims = spec.instance.dims_dyn();
-        let log_space: f64 = dims.iter().map(|&d| (d as f64).log2()).sum();
-        let best_config = if log_space <= 20.0 {
-            find_variant_entry(name, &variant)
-                .and_then(|entry| (entry.solve_witness_fn)(spec.instance.as_any()))
-                .map(|(config, _)| config)
-                .or_else(|| ilp_solver.solve_via_reduction(name, &variant, spec.instance.as_any()))
+        let solve_registered = |request| {
+            let loaded = load_dyn(name, &variant, spec.instance.serialize_json()).ok()?;
+            match solve(&loaded, request).ok()?.outcome {
+                SolveOutcome::Optimal { solution, .. } => Some(solution),
+                SolveOutcome::Infeasible => None,
+            }
+        };
+        let loaded = load_dyn(name, &variant, spec.instance.serialize_json())
+            .expect("canonical example variant must load");
+        let small_brute_force = brute_force_dimensions(&loaded)
+            .expect("solver capability registry must be valid")
+            .is_some_and(|dimensions| {
+                dimensions
+                    .iter()
+                    .map(|&dimension| (dimension as f64).log2())
+                    .sum::<f64>()
+                    <= 20.0
+            });
+        let best_config = if small_brute_force {
+            solve_registered(SolverRequest::BruteForce)
         } else {
-            ilp_solver.solve_via_reduction(name, &variant, spec.instance.as_any())
+            solve_registered(SolverRequest::Ilp)
         };
 
         if let Some(best_config) = best_config {
-            let best_value = spec.instance.evaluate_json(&best_config);
+            let best_value = spec
+                .instance
+                .evaluate_json(&best_config)
+                .expect("solver configuration evaluation should succeed");
             assert_eq!(
                 best_value, spec.optimal_value,
                 "Model spec '{}': solver optimal = {} but stored optimal_value = {} \
@@ -538,9 +591,11 @@ fn model_specs_are_optimal() {
                 spec.id, best_value, spec.optimal_value, best_config, spec.optimal_config
             );
         } else {
-            // Aggregate-only models (e.g., Sum) don't support witnesses.
-            // Verify the stored config evaluates to the stored value.
-            let stored_value = spec.instance.evaluate_json(&spec.optimal_config);
+            // This example has no registered solver suitable for the test budget.
+            let stored_value = spec
+                .instance
+                .evaluate_json(&spec.optimal_config)
+                .expect("canonical configuration evaluation should succeed");
             assert_eq!(
                 stored_value, spec.optimal_value,
                 "Model spec '{}': stored config evaluates to {} but optimal_value = {} \
@@ -583,31 +638,35 @@ fn rule_specs_solution_pairs_are_consistent() {
         )
         .unwrap_or_else(|e| panic!("Failed to load target for {label}: {e}"));
 
-        // Try witness path first; fall back to aggregate for aggregate-only edges.
-        // Some authored direct reductions are proof-only and intentionally have
-        // no runtime capability in any mode.
-        let witness_path = graph.find_cheapest_path(
-            &example.source.problem,
-            &example.source.variant,
-            &example.target.problem,
-            &example.target.variant,
-            &crate::types::ProblemSize::new(vec![]),
-            &crate::rules::MinimizeSteps,
-        );
-        if witness_path.is_none() {
-            let aggregate_path = graph.find_cheapest_path_mode(
+        // Inspect the authored direct reduction. Indirect paths between the same
+        // problem variants do not implement this rule's stored solution pairs.
+        let witness_path = graph
+            .find_all_paths(
                 &example.source.problem,
                 &example.source.variant,
                 &example.target.problem,
                 &example.target.variant,
-                crate::rules::ReductionMode::Aggregate,
-                &crate::types::ProblemSize::new(vec![]),
-                &crate::rules::MinimizeSteps,
-            );
-            if aggregate_path.is_none() {
+            )
+            .into_iter()
+            .find(|path| path.len() == 1);
+        if witness_path.is_none() {
+            let has_aggregate_path = graph
+                .find_all_paths_mode(
+                    &example.source.problem,
+                    &example.source.variant,
+                    &example.target.problem,
+                    &example.target.variant,
+                    crate::rules::ReductionMode::Aggregate,
+                )
+                .iter()
+                .any(|path| path.len() == 1);
+            if !has_aggregate_path {
                 assert!(
-                    graph.has_direct_reduction_by_name(&example.source.problem, &example.target.problem),
-                    "No reduction path (witness or aggregate) or direct proof-only edge for {label}"
+                    graph.has_direct_reduction_by_name(
+                        &example.source.problem,
+                        &example.target.problem
+                    ),
+                    "No direct witness, aggregate, or proof-only reduction for {label}"
                 );
                 assert!(
                     !graph.has_direct_reduction_by_name_mode(
@@ -629,28 +688,30 @@ fn rule_specs_solution_pairs_are_consistent() {
         }
 
         // Only do witness round-trip when a witness path exists
-        let chain = witness_path.and_then(|path| graph.reduce_along_path(&path, source.as_any()));
+        let chain = witness_path.as_ref().map_or(Ok(None), |path| {
+            graph.reduce_along_path(path, source.as_any())
+        });
+        let chain = chain.unwrap_or_else(|error| {
+            panic!("Rule {label}: witness reduction execution failed: {error}")
+        });
 
         for pair in &example.solutions {
-            // Verify config lengths match problem dimensions
-            assert_eq!(
-                pair.source_config.len(),
-                source.dims_dyn().len(),
-                "Rule {label}: source_config length {} != dims length {}",
-                pair.source_config.len(),
-                source.dims_dyn().len()
-            );
-            assert_eq!(
-                pair.target_config.len(),
-                target.dims_dyn().len(),
-                "Rule {label}: target_config length {} != dims length {}",
-                pair.target_config.len(),
-                target.dims_dyn().len()
-            );
             // Verify configs produce feasible evaluations.
-            let source_eval = source.evaluate_dyn(&pair.source_config);
-            let target_eval = target.evaluate_dyn(&pair.target_config);
-            let source_val = source.evaluate_json(&pair.source_config);
+            let source_eval = source
+                .evaluate_dyn(&pair.source_config)
+                .unwrap_or_else(|error| {
+                    panic!("Rule {label}: source configuration evaluation failed: {error}")
+                });
+            let target_eval = target
+                .evaluate_dyn(&pair.target_config)
+                .unwrap_or_else(|error| {
+                    panic!("Rule {label}: target configuration evaluation failed: {error}")
+                });
+            let source_val = source
+                .evaluate_json(&pair.source_config)
+                .unwrap_or_else(|error| {
+                    panic!("Rule {label}: source configuration evaluation failed: {error}")
+                });
             assert_ne!(
                 source_eval, "Max(None)",
                 "Rule {label}: source_config evaluates to Max(None)"
@@ -678,8 +739,12 @@ fn rule_specs_solution_pairs_are_consistent() {
             // Round-trip: extract_solution(target_config) must produce a valid
             // source config with the same evaluation value (witness paths only)
             if let Some(ref chain) = chain {
-                let extracted = chain.extract_solution(&pair.target_config);
-                let extracted_val = source.evaluate_json(&extracted);
+                let extracted = chain
+                    .extract_solution_json(pair.target_config.clone())
+                    .unwrap();
+                let extracted_val = source
+                    .evaluate_json(&extracted)
+                    .expect("extracted configuration evaluation should succeed");
                 assert_eq!(
                     extracted_val, source_val,
                     "Rule {label}: round-trip value mismatch: \
@@ -687,6 +752,12 @@ fn rule_specs_solution_pairs_are_consistent() {
                      (extracted: {:?}, stored: {:?})",
                     extracted_val, source_val, extracted, pair.source_config
                 );
+
+                let malformed = serde_json::json!({"invalid_solution": true});
+                assert!(
+                    chain.extract_solution_json(malformed).is_err(),
+                    "Rule {label}: extraction accepted malformed target-solution JSON"
+                );
             }
         }
     }
@@ -828,7 +899,7 @@ fn test_find_rule_example_ksatisfiability_to_minimumvertexcover() {
         name: "MinimumVertexCover".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let example = find_rule_example(&source, &target).unwrap();
@@ -842,12 +913,12 @@ fn test_find_rule_example_minimumvertexcover_to_minimumfeedbackarcset() {
         name: "MinimumVertexCover".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let target = ProblemRef {
         name: "MinimumFeedbackArcSet".to_string(),
-        variant: BTreeMap::from([("weight".to_string(), "i32".to_string())]),
+        variant: BTreeMap::from([("weight".to_string(), "i64".to_string())]),
     };
     let example = find_rule_example(&source, &target).unwrap();
     assert_eq!(example.source.problem, "MinimumVertexCover");
@@ -879,7 +950,7 @@ fn test_find_rule_example_hamiltoniancircuit_to_biconnectivityaugmentation() {
         name: "BiconnectivityAugmentation".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let example = find_rule_example(&source, &target).unwrap();
@@ -895,7 +966,7 @@ fn test_find_rule_example_hamiltoniancircuit_to_strongconnectivityaugmentation()
     };
     let target = ProblemRef {
         name: "StrongConnectivityAugmentation".to_string(),
-        variant: BTreeMap::from([("weight".to_string(), "i32".to_string())]),
+        variant: BTreeMap::from([("weight".to_string(), "i64".to_string())]),
     };
     let example = find_rule_example(&source, &target).unwrap();
     assert_eq!(example.source.problem, "HamiltonianCircuit");
@@ -927,7 +998,7 @@ fn test_find_rule_example_hamiltoniancircuit_to_ruralpostman() {
         name: "RuralPostman".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let example = find_rule_example(&source, &target).unwrap();
@@ -936,12 +1007,12 @@ fn test_find_rule_example_hamiltoniancircuit_to_ruralpostman() {
 }
 
 #[test]
-fn test_find_rule_example_maximumindependentset_to_integralflowbundles() {
+fn test_find_rule_example_decisionmaximumindependentset_to_integralflowbundles() {
     let source = ProblemRef {
-        name: "MaximumIndependentSet".to_string(),
+        name: "DecisionMaximumIndependentSet".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "One".to_string()),
         ]),
     };
     let target = ProblemRef {
@@ -949,7 +1020,7 @@ fn test_find_rule_example_maximumindependentset_to_integralflowbundles() {
         variant: BTreeMap::new(),
     };
     let example = find_rule_example(&source, &target).unwrap();
-    assert_eq!(example.source.problem, "MaximumIndependentSet");
+    assert_eq!(example.source.problem, "DecisionMaximumIndependentSet");
     assert_eq!(example.target.problem, "IntegralFlowBundles");
 }
 
@@ -1016,7 +1087,7 @@ fn test_find_rule_example_pp2_to_boundedcomponentspanningforest() {
         name: "BoundedComponentSpanningForest".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let example = find_rule_example(&source, &target).unwrap();
@@ -1034,7 +1105,7 @@ fn test_find_rule_example_hamiltoniancircuit_to_longestcircuit() {
         name: "LongestCircuit".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let example = find_rule_example(&source, &target).unwrap();
@@ -1149,7 +1220,7 @@ fn test_find_rule_example_paintshop_to_qubo() {
     };
     let target = ProblemRef {
         name: "QUBO".to_string(),
-        variant: BTreeMap::from([("weight".to_string(), "f64".to_string())]),
+        variant: BTreeMap::from([("weight".to_string(), "i64".to_string())]),
     };
     let example = find_rule_example(&source, &target).unwrap();
     assert_eq!(example.source.problem, "PaintShop");
@@ -1166,7 +1237,7 @@ fn test_find_rule_example_partition_to_binpacking() {
     };
     let target = ProblemRef {
         name: "BinPacking".to_string(),
-        variant: BTreeMap::from([("weight".to_string(), "i32".to_string())]),
+        variant: BTreeMap::from([("weight".to_string(), "i64".to_string())]),
     };
     let example = find_rule_example(&source, &target).unwrap();
     assert_eq!(example.source.problem, "Partition");
@@ -1198,7 +1269,7 @@ fn test_find_rule_example_naesatisfiability_to_maxcut() {
         name: "MaxCut".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let example = find_rule_example(&source, &target).unwrap();
@@ -1245,14 +1316,14 @@ fn test_find_rule_example_maxcut_to_minimumcutintoboundedsets() {
         name: "MaxCut".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let target = ProblemRef {
         name: "MinimumCutIntoBoundedSets".to_string(),
         variant: BTreeMap::from([
             ("graph".to_string(), "SimpleGraph".to_string()),
-            ("weight".to_string(), "i32".to_string()),
+            ("weight".to_string(), "i64".to_string()),
         ]),
     };
     let example = find_rule_example(&source, &target).unwrap();
diff --git a/src/unit_tests/export.rs b/src/unit_tests/export.rs
index c1c9a578f..37b14075a 100644
--- a/src/unit_tests/export.rs
+++ b/src/unit_tests/export.rs
@@ -15,31 +15,31 @@ fn test_variant_to_map_single() {
 
 #[test]
 fn test_variant_to_map_multiple() {
-    let map = variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i32")]);
+    let map = variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i64")]);
     assert_eq!(map.len(), 2);
     assert_eq!(map["graph"], "SimpleGraph");
-    assert_eq!(map["weight"], "i32");
+    assert_eq!(map["weight"], "i64");
 }
 
 #[test]
-fn test_lookup_overhead_known_reduction() {
+fn test_lookup_parameter_contract_known_reduction() {
     // IS -> VC is a known registered reduction
-    let source_variant = variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i32")]);
-    let target_variant = variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i32")]);
-    let result = lookup_overhead(
+    let source_variant = variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i64")]);
+    let target_variant = variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i64")]);
+    let result = lookup_parameter_contract(
         "MaximumIndependentSet",
         &source_variant,
         "MinimumVertexCover",
         &target_variant,
     );
-    assert!(result.is_some());
+    assert!(result.unwrap().is_some());
 }
 
 #[test]
-fn test_lookup_overhead_unknown_reduction() {
+fn test_lookup_parameter_contract_unknown_reduction() {
     let empty = variant_to_map(vec![]);
-    let result = lookup_overhead("NonExistent", &empty, "AlsoNonExistent", &empty);
-    assert!(result.is_none());
+    let result = lookup_parameter_contract("NonExistent", &empty, "AlsoNonExistent", &empty);
+    assert!(result.unwrap().is_none());
 }
 
 fn sample_example_db() -> ExampleDb {
@@ -48,7 +48,7 @@ fn sample_example_db() -> ExampleDb {
             problem: "ModelProblem".to_string(),
             variant: variant_to_map(vec![("graph", "SimpleGraph")]),
             instance: serde_json::json!({"n": 5}),
-            optimal_config: vec![],
+            optimal_config: serde_json::json!([]),
             optimal_value: serde_json::json!(null),
         }],
         rules: vec![RuleExample {
@@ -59,7 +59,7 @@ fn sample_example_db() -> ExampleDb {
             },
             target: ProblemSide {
                 problem: "TargetProblem".to_string(),
-                variant: variant_to_map(vec![("weight", "i32")]),
+                variant: variant_to_map(vec![("weight", "i64")]),
                 instance: serde_json::json!({"m": 4}),
             },
             solutions: vec![],
@@ -117,13 +117,13 @@ fn test_write_example_db_uses_one_line_per_example_entry() {
     let mut db = sample_example_db();
     // Add richer data so the one-line-per-entry format is meaningful
     db.models[0].instance = serde_json::json!({"n": 5, "edges": [[0, 1], [1, 2]]});
-    db.models[0].optimal_config = vec![1, 0, 1];
+    db.models[0].optimal_config = serde_json::json!([1, 0, 1]);
     db.models[0].optimal_value = serde_json::json!(2);
     db.rules[0].source.instance = serde_json::json!({"n": 3, "edges": [[0, 1], [1, 2]]});
     db.rules[0].target.instance = serde_json::json!({"m": 4, "weights": [1, 2, 3, 4]});
     db.rules[0].solutions = vec![SolutionPair {
-        source_config: vec![1, 0, 1],
-        target_config: vec![0, 1, 1, 0],
+        source_config: serde_json::json!(vec![1, 0, 1]),
+        target_config: serde_json::json!(vec![0, 1, 1, 0]),
     }];
     write_example_db_to(&dir, &db);
 
@@ -151,7 +151,7 @@ fn test_write_example_db_uses_one_line_per_example_entry() {
 }
 
 #[test]
-fn rule_example_serialization_omits_overhead() {
+fn rule_example_serialization_omits_reduction_metadata() {
     let example = RuleExample {
         source: ProblemSide {
             problem: "A".to_string(),
@@ -177,7 +177,7 @@ fn rule_example_serialization_omits_overhead() {
 fn test_problem_side_serialization() {
     let side = ProblemSide {
         problem: "MaximumIndependentSet".to_string(),
-        variant: variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i32")]),
+        variant: variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i64")]),
         instance: serde_json::json!({"num_vertices": 4, "edges": [[0, 1], [1, 2]]}),
     };
     let json = serde_json::to_value(&side).unwrap();
@@ -192,12 +192,12 @@ fn test_problem_side_serialization() {
 fn export_variant_to_map_normalizes_empty_graph() {
     // When a variant has an empty graph value, variant_to_map should normalize
     // it to "SimpleGraph" for consistency with the reduction graph convention.
-    let map = variant_to_map(vec![("graph", ""), ("weight", "i32")]);
+    let map = variant_to_map(vec![("graph", ""), ("weight", "i64")]);
     assert_eq!(
         map["graph"], "SimpleGraph",
         "variant_to_map should normalize empty graph to SimpleGraph"
     );
-    assert_eq!(map["weight"], "i32");
+    assert_eq!(map["weight"], "i64");
 }
 
 #[test]
@@ -226,13 +226,13 @@ fn problem_side_from_typed_problem() {
 fn model_example_new() {
     let example = ModelExample::new(
         "MaximumIndependentSet",
-        variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i32")]),
+        variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i64")]),
         serde_json::json!({"num_vertices": 3, "edges": [[0, 1], [1, 2]]}),
-        vec![1, 0, 1],
+        serde_json::json!([1, 0, 1]),
         serde_json::json!(2),
     );
     assert_eq!(example.problem, "MaximumIndependentSet");
-    assert_eq!(example.optimal_config, vec![1, 0, 1]);
+    assert_eq!(example.optimal_config, serde_json::json!([1, 0, 1]));
     assert_eq!(example.optimal_value, serde_json::json!(2));
     assert!(example.instance.is_object());
 }
@@ -243,7 +243,7 @@ fn model_example_problem_ref() {
         problem: "TestProblem".to_string(),
         variant: variant_to_map(vec![("graph", "SimpleGraph")]),
         instance: serde_json::json!({}),
-        optimal_config: vec![],
+        optimal_config: serde_json::json!([]),
         optimal_value: serde_json::json!(null),
     };
     let pref = example.problem_ref();
@@ -285,7 +285,7 @@ fn write_model_example_to_creates_json_file() {
         problem: "TestModel".to_string(),
         variant: variant_to_map(vec![("graph", "SimpleGraph")]),
         instance: serde_json::json!({"n": 3}),
-        optimal_config: vec![1, 0, 1],
+        optimal_config: serde_json::json!(vec![1, 0, 1]),
         optimal_value: serde_json::json!(2),
     };
     write_model_example_to(&dir, "test_model", &example);
@@ -298,10 +298,13 @@ fn write_model_example_to_creates_json_file() {
 }
 
 #[test]
-fn lookup_overhead_rejects_target_variant_mismatch() {
-    let source = variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i32")]);
-    // MIS<SG,i32> -> QUBO<f64> exists, but not MIS<SG,i32> -> QUBO<i32>
-    let wrong_target = variant_to_map(vec![("weight", "i32")]);
-    let result = lookup_overhead("MaximumIndependentSet", &source, "QUBO", &wrong_target);
-    assert!(result.is_none(), "Should reject wrong target variant");
+fn lookup_parameter_contract_rejects_target_variant_mismatch() {
+    let source = variant_to_map(vec![("graph", "SimpleGraph"), ("weight", "i64")]);
+    // MIS<SG,i64> -> QUBO<f64> exists, but not MIS<SG,i64> -> QUBO<i64>
+    let wrong_target = variant_to_map(vec![("weight", "i64")]);
+    let result = lookup_parameter_contract("MaximumIndependentSet", &source, "QUBO", &wrong_target);
+    assert!(
+        result.unwrap().is_none(),
+        "Should reject wrong target variant"
+    );
 }
diff --git a/src/unit_tests/expr.rs b/src/unit_tests/expr.rs
index 037f39c8c..19d527a1e 100644
--- a/src/unit_tests/expr.rs
+++ b/src/unit_tests/expr.rs
@@ -1,144 +1,278 @@
 use super::*;
-use crate::types::ProblemSize;
-use std::collections::{HashMap, HashSet};
+use crate::types::ProblemParameters;
+use serde::Deserialize;
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+
+fn eval(expression: &Expr, size: &ProblemParameters) -> f64 {
+    evaluate_approximate(expression, size).unwrap()
+}
+
+#[test]
+fn test_display_preserves_fractional_exponents_and_negative_bases() {
+    let parameters = ProblemParameters::new(vec![("n", 8)]);
+    for (expression, expected) in [
+        (
+            Expr::pow(Expr::variable("n"), Expr::rational(1, 3)),
+            "n^(1/3)",
+        ),
+        (
+            Expr::pow(Expr::rational(2, 3), Expr::variable("n")),
+            "(2/3)^n",
+        ),
+        (
+            Expr::pow(Expr::rational(-2, 3), Expr::variable("n")),
+            "(-2/3)^n",
+        ),
+        (Expr::pow(Expr::integer(-2), Expr::variable("n")), "(-2)^n"),
+        (
+            Expr::pow(Expr::rational(-1, 2), Expr::variable("n")),
+            "(-0.5)^n",
+        ),
+        (Expr::pow(Expr::variable("n"), Expr::integer(-1)), "n^-1"),
+    ] {
+        let displayed = expression.to_string();
+        assert_eq!(displayed, expected);
+        let reparsed = Expr::parse(&displayed);
+        assert_eq!(eval(&expression, &parameters), eval(&reparsed, &parameters));
+    }
+}
+
+#[derive(Deserialize)]
+struct SympyApproximateFixture {
+    approximate_cases: Vec<SympyApproximateCase>,
+    factorial_domain_cases: Vec<SympyFactorialDomainCase>,
+}
+
+#[derive(Deserialize)]
+struct SympyApproximateCase {
+    name: String,
+    source: String,
+    bindings: BTreeMap<String, u64>,
+    decimal_result: String,
+    finite_f64: bool,
+}
+
+#[derive(Deserialize)]
+struct SympyFactorialDomainCase {
+    source: String,
+    exact_argument: String,
+    accepted: bool,
+    finite_f64: bool,
+}
+
+#[test]
+fn test_approximate_evaluation_against_sympy_fixture() {
+    let fixture: SympyApproximateFixture = serde_json::from_str(include_str!(
+        "../../problemreductions-expr/tests/fixtures/sympy_oracle.json"
+    ))
+    .unwrap();
+    assert_eq!(fixture.approximate_cases.len(), 12);
+
+    for case in fixture.approximate_cases {
+        let expression = Expr::try_parse(&case.source)
+            .unwrap_or_else(|error| panic!("{} failed to parse: {error}", case.name));
+        let size = ProblemParameters::new(
+            case.bindings
+                .iter()
+                .map(|(name, value)| (name.as_str(), *value))
+                .collect(),
+        );
+        let expected: f64 = case.decimal_result.parse().unwrap();
+        let actual = evaluate_approximate(&expression, &size);
+        if case.finite_f64 {
+            let actual =
+                actual.unwrap_or_else(|error| panic!("{} failed to evaluate: {error}", case.name));
+            let relative_error = (actual - expected).abs() / expected.abs().max(1.0);
+            assert!(
+                relative_error <= 1e-14,
+                "{} value: actual={actual}, expected={expected}, relative error={relative_error}",
+                case.name
+            );
+        } else {
+            assert!(
+                matches!(actual, Err(ApproximationError::NonFiniteResult(_))),
+                "{} should report a non-finite approximation",
+                case.name
+            );
+        }
+    }
+}
+
+#[test]
+fn test_factorial_domain_against_sympy_fixture() {
+    let fixture: SympyApproximateFixture = serde_json::from_str(include_str!(
+        "../../problemreductions-expr/tests/fixtures/sympy_oracle.json"
+    ))
+    .unwrap();
+    assert_eq!(fixture.factorial_domain_cases.len(), 8);
+
+    for case in fixture.factorial_domain_cases {
+        let expression = Expr::try_parse(&format!("factorial({})", case.source));
+        if case.accepted {
+            let expression = expression.unwrap_or_else(|error| {
+                panic!(
+                    "valid factorial argument {} ({}) was rejected: {error}",
+                    case.source, case.exact_argument
+                )
+            });
+            assert_eq!(
+                evaluate_approximate(&expression, &ProblemParameters::default()).is_ok(),
+                case.finite_f64,
+                "factorial approximation {} ({})",
+                case.source,
+                case.exact_argument
+            );
+        } else if let Ok(expression) = expression {
+            assert!(
+                evaluate_approximate(&expression, &ProblemParameters::default()).is_err(),
+                "invalid factorial argument {} ({}) evaluated successfully",
+                case.source,
+                case.exact_argument
+            );
+        }
+    }
+}
 
 #[test]
 fn test_expr_const_eval() {
-    let e = Expr::Const(42.0);
-    let size = ProblemSize::new(vec![]);
-    assert_eq!(e.eval(&size), 42.0);
+    let e = Expr::integer(42);
+    let size = ProblemParameters::new(vec![]);
+    assert_eq!(eval(&e, &size), 42.0);
 }
 
 #[test]
 fn test_expr_var_eval() {
-    let e = Expr::Var("n");
-    let size = ProblemSize::new(vec![("n", 10)]);
-    assert_eq!(e.eval(&size), 10.0);
+    let e = Expr::variable("n");
+    let size = ProblemParameters::new(vec![("n", 10)]);
+    assert_eq!(eval(&e, &size), 10.0);
 }
 
 #[test]
 fn test_expr_add_eval() {
     // n + 3
-    let e = Expr::Var("n") + Expr::Const(3.0);
-    let size = ProblemSize::new(vec![("n", 7)]);
-    assert_eq!(e.eval(&size), 10.0);
+    let e = Expr::variable("n") + Expr::integer(3);
+    let size = ProblemParameters::new(vec![("n", 7)]);
+    assert_eq!(eval(&e, &size), 10.0);
 }
 
 #[test]
 fn test_expr_mul_eval() {
     // 3 * n
-    let e = Expr::Const(3.0) * Expr::Var("n");
-    let size = ProblemSize::new(vec![("n", 5)]);
-    assert_eq!(e.eval(&size), 15.0);
+    let e = Expr::integer(3) * Expr::variable("n");
+    let size = ProblemParameters::new(vec![("n", 5)]);
+    assert_eq!(eval(&e, &size), 15.0);
 }
 
 #[test]
 fn test_expr_pow_eval() {
     // n^2
-    let e = Expr::pow(Expr::Var("n"), Expr::Const(2.0));
-    let size = ProblemSize::new(vec![("n", 4)]);
-    assert_eq!(e.eval(&size), 16.0);
+    let e = Expr::pow(Expr::variable("n"), Expr::integer(2));
+    let size = ProblemParameters::new(vec![("n", 4)]);
+    assert_eq!(eval(&e, &size), 16.0);
 }
 
 #[test]
 fn test_expr_exp_eval() {
-    let e = Expr::Exp(Box::new(Expr::Const(1.0)));
-    let size = ProblemSize::new(vec![]);
-    assert!((e.eval(&size) - std::f64::consts::E).abs() < 1e-10);
+    let e = Expr::exp(Expr::integer(1));
+    let size = ProblemParameters::new(vec![]);
+    assert!((eval(&e, &size) - std::f64::consts::E).abs() < 1e-10);
 }
 
 #[test]
 fn test_expr_log_eval() {
-    let e = Expr::Log(Box::new(Expr::Const(std::f64::consts::E)));
-    let size = ProblemSize::new(vec![]);
-    assert!((e.eval(&size) - 1.0).abs() < 1e-10);
+    let e = Expr::log(expression_from_approximation(std::f64::consts::E));
+    let size = ProblemParameters::new(vec![]);
+    assert!((eval(&e, &size) - 1.0).abs() < 1e-10);
 }
 
 #[test]
 fn test_expr_sqrt_eval() {
-    let e = Expr::Sqrt(Box::new(Expr::Const(9.0)));
-    let size = ProblemSize::new(vec![]);
-    assert_eq!(e.eval(&size), 3.0);
+    let e = Expr::sqrt(Expr::integer(9));
+    let size = ProblemParameters::new(vec![]);
+    assert_eq!(eval(&e, &size), 3.0);
 }
 
 #[test]
 fn test_expr_complex() {
     // n^2 + 3*m
-    let e = Expr::pow(Expr::Var("n"), Expr::Const(2.0)) + Expr::Const(3.0) * Expr::Var("m");
-    let size = ProblemSize::new(vec![("n", 4), ("m", 2)]);
-    assert_eq!(e.eval(&size), 22.0); // 16 + 6
+    let e =
+        Expr::pow(Expr::variable("n"), Expr::integer(2)) + Expr::integer(3) * Expr::variable("m");
+    let size = ProblemParameters::new(vec![("n", 4), ("m", 2)]);
+    assert_eq!(eval(&e, &size), 22.0); // 16 + 6
 }
 
 #[test]
 fn test_expr_variables() {
-    let e = Expr::pow(Expr::Var("n"), Expr::Const(2.0)) + Expr::Const(3.0) * Expr::Var("m");
+    let e =
+        Expr::pow(Expr::variable("n"), Expr::integer(2)) + Expr::integer(3) * Expr::variable("m");
     let vars = e.variables();
-    assert_eq!(vars, HashSet::from(["n", "m"]));
+    assert_eq!(vars, BTreeSet::from(["n", "m"]));
 }
 
 #[test]
 fn test_expr_substitute() {
     // n^2, substitute n → (a + b)
-    let e = Expr::pow(Expr::Var("n"), Expr::Const(2.0));
-    let replacement = Expr::Var("a") + Expr::Var("b");
+    let e = Expr::pow(Expr::variable("n"), Expr::integer(2));
+    let replacement = Expr::variable("a") + Expr::variable("b");
     let mut mapping = HashMap::new();
     mapping.insert("n", &replacement);
-    let result = e.substitute(&mapping);
+    let result = e.substitute_complete(&mapping).unwrap();
     // Should be (a + b)^2
-    let size = ProblemSize::new(vec![("a", 3), ("b", 2)]);
-    assert_eq!(result.eval(&size), 25.0); // (3+2)^2
+    let size = ProblemParameters::new(vec![("a", 3), ("b", 2)]);
+    assert_eq!(eval(&result, &size), 25.0); // (3+2)^2
 }
 
 #[test]
 fn test_expr_display_simple() {
-    assert_eq!(format!("{}", Expr::Const(5.0)), "5");
-    assert_eq!(format!("{}", Expr::Var("n")), "n");
+    assert_eq!(format!("{}", Expr::integer(5)), "5");
+    assert_eq!(format!("{}", Expr::variable("n")), "n");
 }
 
 #[test]
 fn test_expr_display_add() {
-    let e = Expr::Var("n") + Expr::Const(3.0);
-    assert_eq!(format!("{e}"), "n + 3");
+    let e = Expr::variable("n") + Expr::integer(3);
+    assert_eq!(format!("{e}"), "3 + n");
 }
 
 #[test]
 fn test_expr_display_mul() {
-    let e = Expr::Const(3.0) * Expr::Var("n");
+    let e = Expr::integer(3) * Expr::variable("n");
     assert_eq!(format!("{e}"), "3 * n");
 }
 
 #[test]
 fn test_expr_display_pow() {
-    let e = Expr::pow(Expr::Var("n"), Expr::Const(2.0));
+    let e = Expr::pow(Expr::variable("n"), Expr::integer(2));
     assert_eq!(format!("{e}"), "n^2");
 }
 
 #[test]
 fn test_expr_display_exp() {
-    let e = Expr::Exp(Box::new(Expr::Var("n")));
+    let e = Expr::exp(Expr::variable("n"));
     assert_eq!(format!("{e}"), "exp(n)");
 }
 
 #[test]
 fn test_expr_display_nested() {
     // n^2 + 3 * m
-    let e = Expr::pow(Expr::Var("n"), Expr::Const(2.0)) + Expr::Const(3.0) * Expr::Var("m");
-    assert_eq!(format!("{e}"), "n^2 + 3 * m");
+    let e =
+        Expr::pow(Expr::variable("n"), Expr::integer(2)) + Expr::integer(3) * Expr::variable("m");
+    assert_eq!(format!("{e}"), "3 * m + n^2");
 }
 
 #[test]
 fn test_expr_is_polynomial() {
-    assert!(Expr::Var("n").is_polynomial());
-    assert!(Expr::pow(Expr::Var("n"), Expr::Const(2.0)).is_polynomial());
-    assert!(!Expr::Exp(Box::new(Expr::Var("n"))).is_polynomial());
-    assert!(!Expr::Log(Box::new(Expr::Var("n"))).is_polynomial());
-    assert!(!Expr::Sqrt(Box::new(Expr::Var("n"))).is_polynomial());
+    assert!(Expr::variable("n").is_polynomial());
+    assert!(Expr::pow(Expr::variable("n"), Expr::integer(2)).is_polynomial());
+    assert!(!Expr::exp(Expr::variable("n")).is_polynomial());
+    assert!(!Expr::log(Expr::variable("n")).is_polynomial());
+    assert!(!Expr::sqrt(Expr::variable("n")).is_polynomial());
 }
 
 #[test]
 fn test_expr_is_valid_complexity_notation_simple() {
-    assert!(Expr::Var("n").is_valid_complexity_notation());
-    assert!(Expr::pow(Expr::Var("n"), Expr::Const(2.0)).is_valid_complexity_notation());
+    assert!(Expr::variable("n").is_valid_complexity_notation());
+    assert!(Expr::pow(Expr::variable("n"), Expr::integer(2)).is_valid_complexity_notation());
     assert!(Expr::parse("n + m").is_valid_complexity_notation());
     assert!(Expr::parse("2^n").is_valid_complexity_notation());
     assert!(Expr::parse("n^(1/3)").is_valid_complexity_notation());
@@ -158,249 +292,169 @@ fn test_expr_is_valid_complexity_notation_rejects_additive_constants() {
     assert!(!Expr::parse("n + 1").is_valid_complexity_notation());
     assert!(!Expr::parse("log(n + 1)").is_valid_complexity_notation());
     assert!(!Expr::parse("(n + 1)^2").is_valid_complexity_notation());
-    assert!(!Expr::Const(5.0).is_valid_complexity_notation());
-    assert!(Expr::Const(1.0).is_valid_complexity_notation());
+    assert!(!Expr::integer(5).is_valid_complexity_notation());
+    assert!(Expr::integer(1).is_valid_complexity_notation());
 }
 
 #[test]
 fn test_expr_display_pow_with_complex_exponent() {
-    let expr = Expr::pow(Expr::Const(2.0), Expr::Var("m") + Expr::Var("n"));
+    let expr = Expr::pow(Expr::integer(2), Expr::variable("m") + Expr::variable("n"));
     assert_eq!(format!("{expr}"), "2^(m + n)");
 }
 
-#[test]
-fn test_asymptotic_normal_form_drops_constant_factors() {
-    let expr = Expr::parse("3 * num_variables^2");
-    let normalized = asymptotic_normal_form(&expr).unwrap();
-    assert_eq!(normalized.to_string(), "num_variables^2");
-}
-
-#[test]
-fn test_asymptotic_normal_form_drops_additive_constants() {
-    let expr = Expr::parse("num_variables + 1");
-    let normalized = asymptotic_normal_form(&expr).unwrap();
-    assert_eq!(normalized.to_string(), "num_variables");
-}
-
-#[test]
-fn test_asymptotic_normal_form_canonicalizes_commutative_sum() {
-    let a = asymptotic_normal_form(&Expr::parse("n + m")).unwrap();
-    let b = asymptotic_normal_form(&Expr::parse("m + n")).unwrap();
-    assert_eq!(a, b);
-    assert_eq!(a.to_string(), "m + n");
-}
-
-#[test]
-fn test_asymptotic_normal_form_canonicalizes_commutative_product() {
-    let a = asymptotic_normal_form(&Expr::parse("n * m")).unwrap();
-    let b = asymptotic_normal_form(&Expr::parse("m * n")).unwrap();
-    assert_eq!(a, b);
-    assert_eq!(a.to_string(), "m * n");
-}
-
-#[test]
-fn test_asymptotic_normal_form_combines_repeated_factors() {
-    let normalized = asymptotic_normal_form(&Expr::parse("n * n^(1/2)")).unwrap();
-    assert_eq!(normalized.to_string(), "n^1.5");
-}
-
-#[test]
-fn test_asymptotic_normal_form_canonicalizes_exponential_product() {
-    let a = asymptotic_normal_form(&Expr::parse("exp(n) * exp(m)")).unwrap();
-    let b = asymptotic_normal_form(&Expr::parse("exp(n + m)")).unwrap();
-    assert_eq!(a, b);
-    assert_eq!(a.to_string(), "exp(m + n)");
-}
-
-#[test]
-fn test_asymptotic_normal_form_canonicalizes_constant_base_exponential_product() {
-    let a = asymptotic_normal_form(&Expr::parse("2^n * 2^m")).unwrap();
-    let b = asymptotic_normal_form(&Expr::parse("2^(n + m)")).unwrap();
-    assert_eq!(a, b);
-    assert_eq!(a.to_string(), "2^(m + n)");
-}
-
-#[test]
-fn test_asymptotic_normal_form_sqrt_matches_fractional_power() {
-    let a = asymptotic_normal_form(&Expr::parse("sqrt(n * m)")).unwrap();
-    let b = asymptotic_normal_form(&Expr::parse("(n * m)^(1/2)")).unwrap();
-    assert_eq!(a, b);
-}
-
-#[test]
-fn test_asymptotic_normal_form_log_of_power() {
-    // log(n^2) = 2*log(n) — the new engine keeps log(n^2) which is O(log(n))
-    let normalized = asymptotic_normal_form(&Expr::parse("log(n^2)")).unwrap();
-    // Both log(n^2) and log(n) are asymptotically equivalent
-    let s = normalized.to_string();
-    assert!(s.contains("log"), "expected log in result, got: {s}");
-    assert!(s.contains("n"), "expected n in result, got: {s}");
-}
-
-#[test]
-fn test_asymptotic_normal_form_substitution_is_closed() {
-    let notation = asymptotic_normal_form(&Expr::parse("n * m")).unwrap();
-    let k = Expr::parse("k");
-    let k_squared = Expr::parse("k^2");
-    let mapping = HashMap::from([("n", &k), ("m", &k_squared)]);
-    let substituted = asymptotic_normal_form(&notation.substitute(&mapping)).unwrap();
-    assert_eq!(substituted.to_string(), "k^3");
-}
-
-#[test]
-fn test_asymptotic_normal_form_handles_subtraction() {
-    // n - m: the -m term survives as a negative dominant term → unsupported
-    assert!(asymptotic_normal_form(&Expr::parse("n - m")).is_err());
-
-    // n^2 - n: -n is dominated by n^2 and eliminated → works
-    let result = asymptotic_normal_form(&Expr::parse("n^2 - n")).unwrap();
-    assert_eq!(result.to_string(), "n^2");
-}
-
 #[test]
 fn test_expr_display_fractional_constant() {
-    assert_eq!(format!("{}", Expr::Const(2.75)), "2.75");
-    assert_eq!(format!("{}", Expr::Const(0.5)), "0.5");
+    assert_eq!(format!("{}", Expr::rational(11, 4)), "2.75");
+    assert_eq!(format!("{}", Expr::rational(1, 2)), "0.5");
 }
 
 #[test]
 fn test_expr_display_log() {
-    let e = Expr::Log(Box::new(Expr::Var("n")));
+    let e = Expr::log(Expr::variable("n"));
     assert_eq!(format!("{e}"), "log(n)");
 }
 
 #[test]
 fn test_expr_display_sqrt() {
-    let e = Expr::Sqrt(Box::new(Expr::Var("n")));
-    assert_eq!(format!("{e}"), "sqrt(n)");
+    let e = Expr::sqrt(Expr::variable("n"));
+    assert_eq!(format!("{e}"), "n^0.5");
 }
 
 #[test]
-fn test_expr_display_pow_half_as_sqrt() {
-    let e = Expr::pow(Expr::Var("n"), Expr::Const(0.5));
-    assert_eq!(format!("{e}"), "sqrt(n)");
+fn test_expr_display_preserves_half_power() {
+    let e = Expr::pow(Expr::variable("n"), Expr::rational(1, 2));
+    assert_eq!(format!("{e}"), "n^0.5");
 }
 
 #[test]
-fn test_expr_display_pow_half_complex_base() {
-    let e = Expr::pow(Expr::Var("n") * Expr::Var("m"), Expr::Const(0.5));
-    assert_eq!(format!("{e}"), "sqrt(n * m)");
+fn test_expr_display_preserves_half_power_with_complex_base() {
+    let e = Expr::pow(
+        Expr::variable("n") * Expr::variable("m"),
+        Expr::rational(1, 2),
+    );
+    assert_eq!(format!("{e}"), "(m * n)^0.5");
 }
 
 #[test]
-fn test_expr_display_pow_half_in_exponent() {
-    // 2^(n^0.5) should display as 2^sqrt(n), NOT 2^n^0.5
+fn test_expr_display_preserves_nested_half_power() {
     let e = Expr::pow(
-        Expr::Const(2.0),
-        Expr::pow(Expr::Var("n"), Expr::Const(0.5)),
+        Expr::integer(2),
+        Expr::pow(Expr::variable("n"), Expr::rational(1, 2)),
     );
-    let s = format!("{e}");
-    assert!(s.contains("sqrt"), "expected sqrt notation, got: {s}");
-    assert!(!s.contains("0.5"), "should not contain raw 0.5, got: {s}");
+    assert_eq!(format!("{e}"), "2^n^0.5");
 }
 
 #[test]
 fn test_expr_display_mul_with_add_parenthesization() {
-    // (a + b) * c should parenthesize the left side
-    let e = (Expr::Var("a") + Expr::Var("b")) * Expr::Var("c");
-    assert_eq!(format!("{e}"), "(a + b) * c");
+    // Operand order is canonical, independent of construction order.
+    let e = (Expr::variable("a") + Expr::variable("b")) * Expr::variable("c");
+    assert_eq!(format!("{e}"), "c * (a + b)");
 
     // c * (a + b) should parenthesize the right side
-    let e = Expr::Var("c") * (Expr::Var("a") + Expr::Var("b"));
+    let e = Expr::variable("c") * (Expr::variable("a") + Expr::variable("b"));
     assert_eq!(format!("{e}"), "c * (a + b)");
 
     // (a + b) * (c + d) should parenthesize both sides
-    let e = (Expr::Var("a") + Expr::Var("b")) * (Expr::Var("c") + Expr::Var("d"));
+    let e =
+        (Expr::variable("a") + Expr::variable("b")) * (Expr::variable("c") + Expr::variable("d"));
     assert_eq!(format!("{e}"), "(a + b) * (c + d)");
 }
 
 #[test]
 fn test_expr_display_pow_with_complex_base() {
     // (a + b)^2
-    let e = Expr::pow(Expr::Var("a") + Expr::Var("b"), Expr::Const(2.0));
+    let e = Expr::pow(Expr::variable("a") + Expr::variable("b"), Expr::integer(2));
     assert_eq!(format!("{e}"), "(a + b)^2");
 
     // (a * b)^2
-    let e = Expr::pow(Expr::Var("a") * Expr::Var("b"), Expr::Const(2.0));
+    let e = Expr::pow(Expr::variable("a") * Expr::variable("b"), Expr::integer(2));
     assert_eq!(format!("{e}"), "(a * b)^2");
 }
 
 #[test]
 fn test_expr_eval_missing_variable() {
-    // Missing variable should default to 0
-    let e = Expr::Var("missing");
-    let size = ProblemSize::new(vec![("other", 5)]);
-    assert_eq!(e.eval(&size), 0.0);
+    let e = Expr::variable("missing");
+    let size = ProblemParameters::new(vec![("other", 5)]);
+    assert_eq!(
+        evaluate_approximate(&e, &size),
+        Err(ApproximationError::MissingVariable("missing".to_string()))
+    );
 }
 
 #[test]
 fn test_expr_scale() {
-    let e = Expr::Var("n").scale(3.0);
-    let size = ProblemSize::new(vec![("n", 5)]);
-    assert_eq!(e.eval(&size), 15.0);
+    let e = Expr::integer(3) * Expr::variable("n");
+    let size = ProblemParameters::new(vec![("n", 5)]);
+    assert_eq!(eval(&e, &size), 15.0);
 }
 
 #[test]
 fn test_expr_ops_add_trait() {
-    let a = Expr::Var("a");
-    let b = Expr::Var("b");
+    let a = Expr::variable("a");
+    let b = Expr::variable("b");
     let e = a + b; // uses std::ops::Add
-    let size = ProblemSize::new(vec![("a", 3), ("b", 4)]);
-    assert_eq!(e.eval(&size), 7.0);
+    let size = ProblemParameters::new(vec![("a", 3), ("b", 4)]);
+    assert_eq!(eval(&e, &size), 7.0);
 }
 
 #[test]
 fn test_expr_substitute_exp_log_sqrt() {
-    let replacement = Expr::Const(2.0);
+    let replacement = Expr::integer(2);
     let mut mapping = HashMap::new();
     mapping.insert("n", &replacement);
 
-    let e = Expr::Exp(Box::new(Expr::Var("n")));
-    let result = e.substitute(&mapping);
-    let size = ProblemSize::new(vec![]);
-    assert!((result.eval(&size) - 2.0_f64.exp()).abs() < 1e-10);
+    let e = Expr::exp(Expr::variable("n"));
+    let result = e.substitute_complete(&mapping).unwrap();
+    let size = ProblemParameters::new(vec![]);
+    assert!((eval(&result, &size) - 2.0_f64.exp()).abs() < 1e-10);
 
-    let e = Expr::Log(Box::new(Expr::Var("n")));
-    let result = e.substitute(&mapping);
-    assert!((result.eval(&size) - 2.0_f64.ln()).abs() < 1e-10);
+    let e = Expr::log(Expr::variable("n"));
+    let result = e.substitute_complete(&mapping).unwrap();
+    assert!((eval(&result, &size) - 2.0_f64.ln()).abs() < 1e-10);
 
-    let e = Expr::Sqrt(Box::new(Expr::Var("n")));
-    let result = e.substitute(&mapping);
-    assert!((result.eval(&size) - 2.0_f64.sqrt()).abs() < 1e-10);
+    let e = Expr::sqrt(Expr::variable("n"));
+    let result = e.substitute_complete(&mapping).unwrap();
+    assert!((eval(&result, &size) - 2.0_f64.sqrt()).abs() < 1e-10);
 }
 
 #[test]
 fn test_expr_variables_exp_log_sqrt() {
-    let e = Expr::Exp(Box::new(Expr::Var("a")));
-    assert_eq!(e.variables(), HashSet::from(["a"]));
+    let e = Expr::exp(Expr::variable("a"));
+    assert_eq!(e.variables(), BTreeSet::from(["a"]));
 
-    let e = Expr::Log(Box::new(Expr::Var("b")));
-    assert_eq!(e.variables(), HashSet::from(["b"]));
+    let e = Expr::log(Expr::variable("b"));
+    assert_eq!(e.variables(), BTreeSet::from(["b"]));
 
-    let e = Expr::Sqrt(Box::new(Expr::Var("c")));
-    assert_eq!(e.variables(), HashSet::from(["c"]));
+    let e = Expr::sqrt(Expr::variable("c"));
+    assert_eq!(e.variables(), BTreeSet::from(["c"]));
 }
 
 // --- Runtime parser tests (Expr::parse / parse_to_expr) ---
 
 /// Helper: parse and evaluate with given variable bindings.
-fn parse_eval(input: &str, vars: &[(&str, usize)]) -> f64 {
+fn parse_eval(input: &str, vars: &[(&str, u64)]) -> f64 {
     let expr = Expr::parse(input);
-    let size = ProblemSize::new(vars.to_vec());
-    expr.eval(&size)
+    let size = ProblemParameters::new(vars.to_vec());
+    eval(&expr, &size)
 }
 
 /// Like parse_eval but accepts f64 variable values for testing transcendental functions.
 fn parse_eval_f64(input: &str, vars: &[(&str, f64)]) -> f64 {
     let expr = Expr::parse(input);
-    // Build a ProblemSize-compatible evaluation by using substitute + eval
-    // Since ProblemSize only stores usize, we substitute variables with Const nodes.
+    // Build a ProblemParameters-compatible evaluation by using substitute + eval
+    // ProblemParameters stores integers, so substitute approximate values with Const nodes.
     let mut mapping = std::collections::HashMap::new();
-    let exprs: Vec<Expr> = vars.iter().map(|(_, v)| Expr::Const(*v)).collect();
+    let exprs: Vec<Expr> = vars
+        .iter()
+        .map(|(_, value)| expression_from_approximation(*value))
+        .collect();
     for ((name, _), expr) in vars.iter().zip(exprs.iter()) {
         mapping.insert(*name, expr);
     }
-    expr.substitute(&mapping).eval(&ProblemSize::new(vec![]))
+    eval(
+        &expr.substitute_complete(&mapping).unwrap(),
+        &ProblemParameters::new(vec![]),
+    )
 }
 
 // -- Tokenizer coverage --
@@ -433,12 +487,12 @@ fn test_parse_whitespace_handling() {
 
 #[test]
 fn test_parse_tokenize_invalid_char() {
-    assert!(parse_to_expr("n @ m").is_err());
+    assert!(Expr::try_parse("n @ m").is_err());
 }
 
 #[test]
 fn test_parse_tokenize_invalid_number() {
-    assert!(parse_to_expr("1.2.3").is_err());
+    assert!(Expr::try_parse("1.2.3").is_err());
 }
 
 // -- Additive: +, - --
@@ -552,9 +606,9 @@ fn test_parse_sqrt() {
 
 #[test]
 fn test_parse_unknown_function() {
-    assert!(parse_to_expr("foo(3)").is_err());
-    let err = parse_to_expr("foo(3)").unwrap_err();
-    assert!(err.contains("unknown function"), "got: {err}");
+    assert!(Expr::try_parse("foo(3)").is_err());
+    let err = Expr::try_parse("foo(3)").unwrap_err();
+    assert!(err.to_string().contains("unknown function"), "got: {err}");
 }
 
 #[test]
@@ -608,32 +662,38 @@ fn test_parse_precedence_unary_pow() {
 
 #[test]
 fn test_parse_trailing_tokens_error() {
-    let err = parse_to_expr("n m").unwrap_err();
-    assert!(err.contains("trailing"), "got: {err}");
+    let err = Expr::try_parse("n m").unwrap_err();
+    assert!(err.to_string().contains("trailing"), "got: {err}");
 }
 
 #[test]
 fn test_parse_unexpected_token_error() {
-    let err = parse_to_expr(")").unwrap_err();
-    assert!(err.contains("unexpected token"), "got: {err}");
+    let err = Expr::try_parse(")").unwrap_err();
+    assert!(
+        err.to_string().contains("expected expression"),
+        "got: {err}"
+    );
 }
 
 #[test]
 fn test_parse_empty_input_error() {
-    let err = parse_to_expr("").unwrap_err();
-    assert!(err.contains("end of input"), "got: {err}");
+    let err = Expr::try_parse("").unwrap_err();
+    assert!(
+        err.to_string().contains("expected expression"),
+        "got: {err}"
+    );
 }
 
 #[test]
 fn test_parse_unclosed_paren_error() {
-    let err = parse_to_expr("(n + m").unwrap_err();
-    assert!(err.contains("expected"), "got: {err}");
+    let err = Expr::try_parse("(n + m").unwrap_err();
+    assert!(err.to_string().contains("expected"), "got: {err}");
 }
 
 #[test]
 fn test_parse_unclosed_function_error() {
-    let err = parse_to_expr("exp(n").unwrap_err();
-    assert!(err.contains("expected"), "got: {err}");
+    let err = Expr::try_parse("exp(n").unwrap_err();
+    assert!(err.to_string().contains("expected"), "got: {err}");
 }
 
 #[test]
@@ -641,9 +701,9 @@ fn test_parse_expect_mismatch() {
     // "exp(n]" — expects RParen, gets unexpected token ']'
     // Actually ']' is an invalid char so tokenizer catches it first.
     // Use "exp(n +" to trigger expect mismatch (expects RParen, gets Plus).
-    let err = parse_to_expr("exp(n +").unwrap_err();
+    let err = Expr::try_parse("exp(n +").unwrap_err();
     assert!(
-        err.contains("expected") || err.contains("end of input"),
+        err.to_string().contains("expected") || err.to_string().contains("end of input"),
         "got: {err}"
     );
 }
@@ -670,37 +730,88 @@ fn test_parse_factorial_variable() {
 
 #[test]
 fn test_expr_factorial_eval() {
-    let e = Expr::Factorial(Box::new(Expr::Const(4.0)));
-    let size = ProblemSize::new(vec![]);
-    assert_eq!(e.eval(&size), 24.0);
+    let e = Expr::factorial(Expr::integer(4));
+    let size = ProblemParameters::new(vec![]);
+    assert_eq!(eval(&e, &size), 24.0);
+}
+
+#[test]
+fn test_expr_factorial_above_f64_range_is_explicit_error() {
+    let expression = Expr::factorial(Expr::integer(171));
+    assert_eq!(
+        evaluate_approximate(&expression, &ProblemParameters::default()),
+        Err(ApproximationError::NonFiniteResult(
+            "factorial(171)".to_string()
+        ))
+    );
+}
+
+#[test]
+fn test_expr_factorial_rejects_non_integer_and_negative_arguments() {
+    for (expression, argument) in [
+        (Expr::factorial(Expr::rational(7, 2)), "3.5"),
+        (Expr::factorial(Expr::integer(-1)), "-1"),
+    ] {
+        assert_eq!(
+            evaluate_approximate(&expression, &ProblemParameters::default()),
+            Err(ApproximationError::InvalidFactorialArgument(
+                argument.to_string()
+            ))
+        );
+    }
+}
+
+#[test]
+fn test_non_finite_approximations_are_explicit_errors() {
+    for (expression, rendered) in [
+        (Expr::pow(Expr::integer(0), Expr::integer(-1)), "0^-1"),
+        (Expr::log(Expr::integer(0)), "log(0)"),
+        (Expr::exp(Expr::integer(1000)), "exp(1000)"),
+    ] {
+        assert_eq!(
+            evaluate_approximate(&expression, &ProblemParameters::default()),
+            Err(ApproximationError::NonFiniteResult(rendered.to_string()))
+        );
+    }
+}
+
+#[test]
+fn test_zero_does_not_hide_an_undefined_factor() {
+    let undefined = Expr::pow(Expr::integer(0), Expr::integer(-1));
+    let expression = Expr::integer(0) * undefined;
+    assert_eq!(expression.to_string(), "0 * 0^-1");
+    assert_eq!(
+        evaluate_approximate(&expression, &ProblemParameters::default()),
+        Err(ApproximationError::NonFiniteResult("0^-1".to_string()))
+    );
 }
 
 #[test]
 fn test_expr_factorial_display() {
-    let e = Expr::Factorial(Box::new(Expr::Var("n")));
+    let e = Expr::factorial(Expr::variable("n"));
     assert_eq!(format!("{e}"), "factorial(n)");
 }
 
 #[test]
 fn test_expr_factorial_variables() {
-    let e = Expr::Factorial(Box::new(Expr::Var("n")));
-    assert_eq!(e.variables(), HashSet::from(["n"]));
+    let e = Expr::factorial(Expr::variable("n"));
+    assert_eq!(e.variables(), BTreeSet::from(["n"]));
 }
 
 #[test]
 fn test_expr_factorial_substitute() {
-    let replacement = Expr::Const(5.0);
+    let replacement = Expr::integer(5);
     let mut mapping = HashMap::new();
     mapping.insert("n", &replacement);
-    let e = Expr::Factorial(Box::new(Expr::Var("n")));
-    let result = e.substitute(&mapping);
-    let size = ProblemSize::new(vec![]);
-    assert_eq!(result.eval(&size), 120.0);
+    let e = Expr::factorial(Expr::variable("n"));
+    let result = e.substitute_complete(&mapping).unwrap();
+    let size = ProblemParameters::new(vec![]);
+    assert_eq!(eval(&result, &size), 120.0);
 }
 
 #[test]
 fn test_expr_factorial_is_not_polynomial() {
-    assert!(!Expr::Factorial(Box::new(Expr::Var("n"))).is_polynomial());
+    assert!(!Expr::factorial(Expr::variable("n")).is_polynomial());
 }
 
 #[test]
@@ -788,3 +899,36 @@ fn test_parse_real_complexity_bmf() {
     // 2^(3*2 + 2*4) = 2^(6+8) = 2^14 = 16384
     assert_eq!(val, 16384.0);
 }
+
+#[test]
+fn algebraic_analysis_preserves_exact_complexity_facts() {
+    let expression = Expr::parse("2^(0.7905 * n)");
+    let analysis = AlgebraicAnalysis::new(&[&expression]);
+    let ExprNode::Pow(base, exponent) = expression.node() else {
+        panic!("expected power expression");
+    };
+
+    assert_eq!(
+        analysis.facts(base).exact_rational,
+        Some(BigRational::from_integer(2.into()))
+    );
+    assert_eq!(
+        analysis.facts(exponent).linear,
+        Some(BTreeMap::from([(
+            Symbol::new("n").unwrap(),
+            BigRational::new(1581.into(), 2000.into()),
+        )]))
+    );
+}
+
+#[test]
+fn algebraic_analysis_separates_value_from_domain() {
+    let valid = Expr::parse("3^8");
+    let invalid = Expr::sqrt(Expr::integer(-1));
+    let analysis = AlgebraicAnalysis::new(&[&valid, &invalid]);
+
+    assert!(analysis.facts(&valid).is_constant);
+    assert_eq!(analysis.facts(&valid).exact_rational, None);
+    assert_eq!(analysis.facts(&valid).constant_domain, Some(true));
+    assert_eq!(analysis.facts(&invalid).constant_domain, Some(false));
+}
diff --git a/src/unit_tests/graph_models.rs b/src/unit_tests/graph_models.rs
index 95979843f..675a9c487 100644
--- a/src/unit_tests/graph_models.rs
+++ b/src/unit_tests/graph_models.rs
@@ -8,6 +8,7 @@ use crate::models::graph::maximum_independent_set::is_independent_set;
 use crate::models::graph::minimum_vertex_cover::is_vertex_cover;
 use crate::models::graph::{KColoring, MaximumIndependentSet, MinimumVertexCover};
 use crate::prelude::*;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, Min};
@@ -24,7 +25,7 @@ mod maximum_independent_set {
     fn test_creation() {
         let problem = MaximumIndependentSet::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-            vec![1i32; 4],
+            vec![1i64; 4],
         );
         assert_eq!(problem.graph().num_vertices(), 4);
         assert_eq!(problem.graph().num_edges(), 3);
@@ -40,15 +41,15 @@ mod maximum_independent_set {
 
     #[test]
     fn test_unweighted() {
-        // i32 type is always considered weighted, even with uniform values
-        let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+        // i64 type is always considered weighted, even with uniform values
+        let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
         assert!(problem.is_weighted());
     }
 
     #[test]
     fn test_has_edge() {
         let problem =
-            MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+            MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
         assert!(problem.graph().has_edge(0, 1));
         assert!(problem.graph().has_edge(1, 0)); // Undirected
         assert!(problem.graph().has_edge(1, 2));
@@ -58,33 +59,48 @@ mod maximum_independent_set {
     #[test]
     fn test_evaluate_valid() {
         let problem =
-            MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i32; 4]);
+            MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i64; 4]);
 
         // Valid: select 0 and 2 (not adjacent)
-        assert_eq!(problem.evaluate(&[1, 0, 1, 0]), Max(Some(2)));
+        assert_eq!(
+            problem.evaluate(&vec![true, false, true, false]).unwrap(),
+            Max(Some(2))
+        );
 
         // Valid: select 1 and 3 (not adjacent)
-        assert_eq!(problem.evaluate(&[0, 1, 0, 1]), Max(Some(2)));
+        assert_eq!(
+            problem.evaluate(&vec![false, true, false, true]).unwrap(),
+            Max(Some(2))
+        );
     }
 
     #[test]
     fn test_evaluate_invalid() {
         let problem =
-            MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i32; 4]);
+            MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i64; 4]);
 
         // Invalid: 0 and 1 are adjacent - returns Invalid
-        assert_eq!(problem.evaluate(&[1, 1, 0, 0]), Max(None));
+        assert_eq!(
+            problem.evaluate(&vec![true, true, false, false]).unwrap(),
+            Max(None)
+        );
 
         // Invalid: 2 and 3 are adjacent
-        assert_eq!(problem.evaluate(&[0, 0, 1, 1]), Max(None));
+        assert_eq!(
+            problem.evaluate(&vec![false, false, true, true]).unwrap(),
+            Max(None)
+        );
     }
 
     #[test]
     fn test_evaluate_empty() {
         let problem =
-            MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+            MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
         // Empty selection is valid with size 0
-        assert_eq!(problem.evaluate(&[0, 0, 0]), Max(Some(0)));
+        assert_eq!(
+            problem.evaluate(&vec![false, false, false]).unwrap(),
+            Max(Some(0))
+        );
     }
 
     #[test]
@@ -93,10 +109,16 @@ mod maximum_independent_set {
             MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![10, 20, 30]);
 
         // Select vertex 2 (weight 30)
-        assert_eq!(problem.evaluate(&[0, 0, 1]), Max(Some(30)));
+        assert_eq!(
+            problem.evaluate(&vec![false, false, true]).unwrap(),
+            Max(Some(30))
+        );
 
         // Select vertices 0 and 2 (weights 10 + 30 = 40)
-        assert_eq!(problem.evaluate(&[1, 0, 1]), Max(Some(40)));
+        assert_eq!(
+            problem.evaluate(&vec![true, false, true]).unwrap(),
+            Max(Some(40))
+        );
     }
 
     #[test]
@@ -104,15 +126,15 @@ mod maximum_independent_set {
         // Triangle graph: maximum IS has size 1
         let problem = MaximumIndependentSet::new(
             SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-            vec![1i32; 3],
+            vec![1i64; 3],
         );
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         // All solutions should have exactly 1 vertex selected
         assert_eq!(solutions.len(), 3); // Three equivalent solutions
         for sol in &solutions {
-            assert_eq!(sol.iter().sum::<usize>(), 1);
+            assert_eq!(sol.iter().filter(|&&selected| selected).count(), 1);
         }
     }
 
@@ -121,17 +143,17 @@ mod maximum_independent_set {
         // Path graph 0-1-2-3: maximum IS = {0,2} or {1,3} or {0,3}
         let problem = MaximumIndependentSet::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-            vec![1i32; 4],
+            vec![1i64; 4],
         );
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         // Maximum size is 2
         for sol in &solutions {
-            let size: usize = sol.iter().sum();
+            let size: usize = sol.iter().filter(|&&selected| selected).count();
             assert_eq!(size, 2);
             // Verify it's valid (evaluate returns Valid, not Invalid)
-            assert_eq!(problem.evaluate(sol), Max(Some(2)));
+            assert_eq!(problem.evaluate(sol).unwrap(), Max(Some(2)));
         }
     }
 
@@ -142,10 +164,10 @@ mod maximum_independent_set {
             MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1, 100, 1]);
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert_eq!(solutions.len(), 1);
         // Should select vertex 1 (weight 100) over vertices 0+2 (weight 2)
-        assert_eq!(solutions[0], vec![0, 1, 0]);
+        assert_eq!(solutions[0], vec![false, true, false]);
     }
 
     #[test]
@@ -174,13 +196,13 @@ mod maximum_independent_set {
 
     #[test]
     fn test_direction() {
-        let _problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+        let _problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     }
 
     #[test]
     fn test_edges() {
         let problem =
-            MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i32; 4]);
+            MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i64; 4]);
         let edges = problem.graph().edges();
         assert_eq!(edges.len(), 2);
         assert!(edges.contains(&(0, 1)) || edges.contains(&(1, 0)));
@@ -196,26 +218,38 @@ mod maximum_independent_set {
 
     #[test]
     fn test_empty_graph() {
-        let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![]), vec![1i32; 3]);
+        let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![]), vec![1i64; 3]);
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert_eq!(solutions.len(), 1);
         // All vertices can be selected
-        assert_eq!(solutions[0], vec![1, 1, 1]);
+        assert_eq!(solutions[0], vec![true, true, true]);
     }
 
     #[test]
     fn test_validity_via_evaluate() {
         let problem =
-            MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+            MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
 
         // Valid IS configurations return is_valid() == true
-        assert!(problem.evaluate(&[1, 0, 1]).is_valid());
-        assert!(problem.evaluate(&[0, 1, 0]).is_valid());
+        assert!(problem
+            .evaluate(&vec![true, false, true])
+            .unwrap()
+            .is_valid());
+        assert!(problem
+            .evaluate(&vec![false, true, false])
+            .unwrap()
+            .is_valid());
         // Invalid configurations return Invalid
-        assert_eq!(problem.evaluate(&[1, 1, 0]), Max(None));
-        assert_eq!(problem.evaluate(&[0, 1, 1]), Max(None));
+        assert_eq!(
+            problem.evaluate(&vec![true, true, false]).unwrap(),
+            Max(None)
+        );
+        assert_eq!(
+            problem.evaluate(&vec![false, true, true]).unwrap(),
+            Max(None)
+        );
     }
 }
 
@@ -230,7 +264,7 @@ mod minimum_vertex_cover {
     fn test_creation() {
         let problem = MinimumVertexCover::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-            vec![1i32; 4],
+            vec![1i64; 4],
         );
         assert_eq!(problem.graph().num_vertices(), 4);
         assert_eq!(problem.graph().num_edges(), 3);
@@ -247,37 +281,49 @@ mod minimum_vertex_cover {
     #[test]
     fn test_evaluate_valid() {
         let problem =
-            MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+            MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
 
         // Valid: select vertex 1 (covers both edges)
-        assert_eq!(problem.evaluate(&[0, 1, 0]), Min(Some(1)));
+        assert_eq!(
+            problem.evaluate(&vec![false, true, false]).unwrap(),
+            Min(Some(1))
+        );
 
         // Valid: select all vertices
-        assert_eq!(problem.evaluate(&[1, 1, 1]), Min(Some(3)));
+        assert_eq!(
+            problem.evaluate(&vec![true, true, true]).unwrap(),
+            Min(Some(3))
+        );
     }
 
     #[test]
     fn test_evaluate_invalid() {
         let problem =
-            MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+            MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
 
         // Invalid: no vertex selected - returns Invalid for minimization
-        assert_eq!(problem.evaluate(&[0, 0, 0]), Min(None));
+        assert_eq!(
+            problem.evaluate(&vec![false, false, false]).unwrap(),
+            Min(None)
+        );
 
         // Invalid: only vertex 0 selected (edge 1-2 not covered)
-        assert_eq!(problem.evaluate(&[1, 0, 0]), Min(None));
+        assert_eq!(
+            problem.evaluate(&vec![true, false, false]).unwrap(),
+            Min(None)
+        );
     }
 
     #[test]
     fn test_brute_force_path() {
         // Path graph 0-1-2: minimum vertex cover is {1}
         let problem =
-            MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+            MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert_eq!(solutions.len(), 1);
-        assert_eq!(solutions[0], vec![0, 1, 0]);
+        assert_eq!(solutions[0], vec![false, true, false]);
     }
 
     #[test]
@@ -285,17 +331,17 @@ mod minimum_vertex_cover {
         // Triangle: minimum vertex cover has size 2
         let problem = MinimumVertexCover::new(
             SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-            vec![1i32; 3],
+            vec![1i64; 3],
         );
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         // There are 3 minimum covers of size 2
         assert_eq!(solutions.len(), 3);
         for sol in &solutions {
-            assert_eq!(sol.iter().sum::<usize>(), 2);
+            assert_eq!(sol.iter().filter(|&&selected| selected).count(), 2);
             // Verify valid (not Invalid)
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -306,10 +352,10 @@ mod minimum_vertex_cover {
             MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![100, 1, 100]);
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert_eq!(solutions.len(), 1);
         // Should select vertex 1 (weight 1) instead of 0 and 2 (total 200)
-        assert_eq!(solutions[0], vec![0, 1, 0]);
+        assert_eq!(solutions[0], vec![false, true, false]);
     }
 
     #[test]
@@ -334,26 +380,26 @@ mod minimum_vertex_cover {
 
     #[test]
     fn test_direction() {
-        let _problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+        let _problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     }
 
     #[test]
     fn test_empty_graph() {
-        let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![]), vec![1i32; 3]);
+        let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![]), vec![1i64; 3]);
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         // No edges means empty cover is valid and optimal
         assert_eq!(solutions.len(), 1);
-        assert_eq!(solutions[0], vec![0, 0, 0]);
+        assert_eq!(solutions[0], vec![false, false, false]);
     }
 
     #[test]
     fn test_single_edge() {
-        let problem = MinimumVertexCover::new(SimpleGraph::new(2, vec![(0, 1)]), vec![1i32; 2]);
+        let problem = MinimumVertexCover::new(SimpleGraph::new(2, vec![(0, 1)]), vec![1i64; 2]);
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         // Either vertex covers the single edge
         assert_eq!(solutions.len(), 2);
     }
@@ -361,14 +407,26 @@ mod minimum_vertex_cover {
     #[test]
     fn test_validity_via_evaluate() {
         let problem =
-            MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+            MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
 
         // Valid cover configurations return is_valid() == true
-        assert!(problem.evaluate(&[0, 1, 0]).is_valid());
-        assert!(problem.evaluate(&[1, 0, 1]).is_valid());
+        assert!(problem
+            .evaluate(&vec![false, true, false])
+            .unwrap()
+            .is_valid());
+        assert!(problem
+            .evaluate(&vec![true, false, true])
+            .unwrap()
+            .is_valid());
         // Invalid configurations return Invalid
-        assert_eq!(problem.evaluate(&[1, 0, 0]), Min(None));
-        assert_eq!(problem.evaluate(&[0, 0, 1]), Min(None));
+        assert_eq!(
+            problem.evaluate(&vec![true, false, false]).unwrap(),
+            Min(None)
+        );
+        assert_eq!(
+            problem.evaluate(&vec![false, false, true]).unwrap(),
+            Min(None)
+        );
     }
 
     #[test]
@@ -376,17 +434,17 @@ mod minimum_vertex_cover {
         // For a graph, if S is an independent set, then V\S is a vertex cover
         let edges = vec![(0, 1), (1, 2), (2, 3)];
         let is_problem =
-            MaximumIndependentSet::new(SimpleGraph::new(4, edges.clone()), vec![1i32; 4]);
-        let vc_problem = MinimumVertexCover::new(SimpleGraph::new(4, edges), vec![1i32; 4]);
+            MaximumIndependentSet::new(SimpleGraph::new(4, edges.clone()), vec![1i64; 4]);
+        let vc_problem = MinimumVertexCover::new(SimpleGraph::new(4, edges), vec![1i64; 4]);
 
         let solver = BruteForce::new();
 
-        let is_solutions = solver.find_all_witnesses(&is_problem);
+        let is_solutions = solver.find_all_witnesses(&is_problem).unwrap();
         for is_sol in &is_solutions {
             // Complement should be a valid vertex cover
-            let vc_config: Vec<usize> = is_sol.iter().map(|&x| 1 - x).collect();
+            let vc_config: Vec<bool> = is_sol.iter().map(|&selected| !selected).collect();
             // Valid cover returns is_valid() == true
-            assert!(vc_problem.evaluate(&vc_config).is_valid());
+            assert!(vc_problem.evaluate(&vc_config).unwrap().is_valid());
         }
     }
 
@@ -399,8 +457,8 @@ mod minimum_vertex_cover {
 
     #[test]
     fn test_is_weighted_empty() {
-        // i32 type is always considered weighted, even with empty weights
-        let problem = MinimumVertexCover::new(SimpleGraph::new(0, vec![]), vec![0i32; 0]);
+        // i64 type is always considered weighted, even with empty weights
+        let problem = MinimumVertexCover::new(SimpleGraph::new(0, vec![]), vec![0i64; 0]);
         assert!(problem.is_weighted());
     }
 
@@ -444,7 +502,7 @@ mod integral_flow_homologous_arcs {
         );
         assert_eq!(problem.num_vertices(), 6);
         assert_eq!(problem.num_arcs(), 8);
-        assert_eq!(problem.dims(), vec![2; 8]);
+        assert_eq!(problem.dimensions(), vec![2; 8]);
     }
 }
 
@@ -469,8 +527,8 @@ mod kcoloring {
         let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
 
         // Valid: different colors on adjacent vertices - returns true
-        assert!(problem.evaluate(&[0, 1, 0]));
-        assert!(problem.evaluate(&[0, 1, 2]));
+        assert!(problem.evaluate(&vec![0, 1, 0]).unwrap());
+        assert!(problem.evaluate(&vec![0, 1, 2]).unwrap());
     }
 
     #[test]
@@ -478,8 +536,8 @@ mod kcoloring {
         let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
 
         // Invalid: adjacent vertices have same color
-        assert!(!problem.evaluate(&[0, 0, 1])); // 0-1 conflict
-        assert!(!problem.evaluate(&[0, 0, 0])); // Multiple conflicts
+        assert!(!problem.evaluate(&vec![0, 0, 1]).unwrap()); // 0-1 conflict
+        assert!(!problem.evaluate(&vec![0, 0, 0]).unwrap()); // Multiple conflicts
     }
 
     #[test]
@@ -488,10 +546,10 @@ mod kcoloring {
         let problem = KColoring::<K2, _>::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         // All solutions should be valid
         for sol in &solutions {
-            assert!(problem.evaluate(sol));
+            assert!(problem.evaluate(sol).unwrap());
         }
     }
 
@@ -501,9 +559,9 @@ mod kcoloring {
         let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         for sol in &solutions {
-            assert!(problem.evaluate(sol));
+            assert!(problem.evaluate(sol).unwrap());
             // All three vertices have different colors
             assert_ne!(sol[0], sol[1]);
             assert_ne!(sol[1], sol[2]);
@@ -518,7 +576,7 @@ mod kcoloring {
         let solver = BruteForce::new();
 
         // No satisfying assignments
-        let solution = solver.find_witness(&problem);
+        let solution = solver.solve(&problem).unwrap();
         assert!(solution.is_none());
     }
 
@@ -545,9 +603,9 @@ mod kcoloring {
         let problem = KColoring::<K1, _>::new(SimpleGraph::new(3, vec![]));
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         // Any coloring is valid when there are no edges
-        assert!(problem.evaluate(&solutions[0]));
+        assert!(problem.evaluate(&solutions[0]).unwrap());
     }
 
     #[test]
@@ -559,9 +617,9 @@ mod kcoloring {
         ));
         let solver = BruteForce::new();
 
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         for sol in &solutions {
-            assert!(problem.evaluate(sol));
+            assert!(problem.evaluate(sol).unwrap());
         }
     }
 }
diff --git a/src/unit_tests/growth.rs b/src/unit_tests/growth.rs
new file mode 100644
index 000000000..3291e0c0f
--- /dev/null
+++ b/src/unit_tests/growth.rs
@@ -0,0 +1,1059 @@
+//! Unit tests for the symbolic growth domain (`src/growth.rs`).
+
+use super::{
+    add, exact_growth, mul, ExpBase, Growth, GrowthFailure, GrowthState, GrowthTerm,
+    VariableGrowth, ANTICHAIN_CAP,
+};
+use crate::expr::{
+    evaluate_approximate, expression_from_approximation, AlgebraicAnalysis, Expr, ExprNode,
+};
+use crate::registry::variant_entries;
+use num_rational::BigRational;
+use num_traits::{FromPrimitive, One, Signed, Zero};
+use serde::Deserialize;
+use std::cmp::Ordering;
+
+fn rat(value: f64) -> BigRational {
+    BigRational::from_f64(value).unwrap()
+}
+
+/// Build a term from `(exp, poly, logs)` entry lists.
+fn term(exp: &[(&str, f64)], poly: &[(&str, f64)], logs: &[(&str, u32)]) -> GrowthTerm {
+    let mut result = GrowthTerm::one();
+    for (variable, rate) in exp {
+        result.insert(
+            (*variable).into(),
+            VariableGrowth::exponential(ExpBase::Rational(rat(2.0)), rat(*rate)),
+        );
+    }
+    for (variable, degree) in poly {
+        let growth = result
+            .variables
+            .entry((*variable).into())
+            .or_insert_with(VariableGrowth::empty);
+        growth.poly = rat(*degree);
+    }
+    for (variable, power) in logs {
+        let growth = result
+            .variables
+            .entry((*variable).into())
+            .or_insert_with(VariableGrowth::empty);
+        growth.log = *power;
+    }
+    result
+}
+
+fn terms_of(g: &Growth) -> &[GrowthTerm] {
+    match &g.0 {
+        GrowthState::Known(terms) => terms,
+        GrowthState::Unknown(failures) => panic!("expected known growth, got {failures:?}"),
+    }
+}
+
+fn g(s: &str) -> Growth {
+    Growth::from_expr(&Expr::parse(s))
+}
+
+#[derive(Deserialize)]
+struct SympyGrowthFixture {
+    growth_cases: Vec<SympyGrowthCase>,
+}
+
+#[derive(Deserialize)]
+struct SympyGrowthCase {
+    name: String,
+    left: String,
+    right: String,
+    ratio_limit: String,
+    relation: SympyGrowthRelation,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "snake_case")]
+enum SympyGrowthRelation {
+    Equivalent,
+    LeftDominates,
+    RightDominates,
+}
+
+#[test]
+fn test_growth_relations_against_sympy_limits() {
+    let fixture: SympyGrowthFixture = serde_json::from_str(include_str!(
+        "../../problemreductions-expr/tests/fixtures/sympy_oracle.json"
+    ))
+    .unwrap();
+    assert_eq!(fixture.growth_cases.len(), 14);
+
+    for case in fixture.growth_cases {
+        let left = g(&case.left);
+        let right = g(&case.right);
+        let actual = (left.dominates(&right), right.dominates(&left));
+        let expected = match case.relation {
+            SympyGrowthRelation::Equivalent => (true, true),
+            SympyGrowthRelation::LeftDominates => (true, false),
+            SympyGrowthRelation::RightDominates => (false, true),
+        };
+        assert_eq!(
+            actual, expected,
+            "{} with SymPy ratio limit {}",
+            case.name, case.ratio_limit
+        );
+    }
+}
+
+fn exponential_growth(factors: &[(f64, f64)]) -> VariableGrowth {
+    VariableGrowth {
+        exp: factors
+            .iter()
+            .map(|(base, coefficient)| (ExpBase::Rational(rat(*base)), rat(*coefficient)))
+            .collect(),
+        poly: BigRational::zero(),
+        log: 0,
+    }
+}
+
+// --- Core verification cases ---
+
+/// 1. No-expansion regression: the nested sum-of-squares shape that OOM'd in
+///    the old implementation is handled without expansion, quickly, with few terms.
+#[test]
+fn test_growth_no_expansion_regression() {
+    let e = Expr::parse("(12*(n + 3*m) + 5)^2 * (12*(n + 3*m) + 5)^2");
+    let start = std::time::Instant::now();
+    let result = Growth::from_expr(&e);
+    let elapsed = start.elapsed();
+
+    let ts = terms_of(&result);
+    assert!(
+        ts.contains(&term(&[], &[("n", 4.0)], &[])),
+        "expected n^4 in {ts:?}"
+    );
+    assert!(
+        ts.contains(&term(&[], &[("m", 4.0)], &[])),
+        "expected m^4 in {ts:?}"
+    );
+    assert!(ts.len() <= 6, "expected <= 6 terms, got {}", ts.len());
+    assert!(elapsed.as_millis() < 10, "from_expr took {elapsed:?}");
+}
+
+/// 2. Dominance beats the old sampling heuristic: `1.001^n` dominates `n^100`
+///    (any positive exponential rate outranks any polynomial degree).
+#[test]
+fn test_growth_exponential_dominates_polynomial() {
+    let exp = g("1.001^n");
+    let poly = g("n^100");
+    assert!(exp.dominates(&poly));
+    assert!(!poly.dominates(&exp));
+}
+
+/// 3. Incomparability is honest: neither `n^2` nor `n*m` dominates the other,
+///    and both are kept in the sum.
+#[test]
+fn test_growth_incomparable_terms_both_kept() {
+    let n2 = g("n^2");
+    let nm = g("n*m");
+    assert!(!n2.dominates(&nm));
+    assert!(!nm.dominates(&n2));
+
+    let sum = g("n^2 + n*m");
+    assert_eq!(terms_of(&sum).len(), 2);
+}
+
+/// 4. Exponent rates are exact: `2^(2n)` dominates `2^n` (not conversely), and
+///    `3^n` dominates `2^n` via direct symbolic base comparison.
+#[test]
+fn test_growth_exponent_rates_exact() {
+    let two_2n = g("2^(2*n)");
+    let two_n = g("2^n");
+    assert!(two_2n.dominates(&two_n));
+    assert!(!two_n.dominates(&two_2n));
+
+    let three_n = g("3^n");
+    assert!(three_n.dominates(&two_n));
+    assert!(!two_n.dominates(&three_n));
+
+    let exp_2n = g("exp(2*n)");
+    let exp_n = g("exp(n)");
+    assert!(exp_2n.dominates(&exp_n));
+    assert!(!exp_n.dominates(&exp_2n));
+
+    assert!(g("0.5^(-2*n)").dominates(&g("0.5^(-n)")));
+    assert!(g("0.25^(-n)").dominates(&g("0.5^(-n)")));
+}
+
+#[test]
+fn test_growth_exact_coefficients_do_not_cross_boundaries() {
+    let polynomial = g("n^1000");
+    assert!(g("2^(n/9007199254740992)").dominates(&polynomial));
+    assert!(g("(9007199254740993/9007199254740992)^n").dominates(&polynomial));
+
+    let unit_rate = g("2^n");
+    let larger_rate = g("2^(9007199254740993*n/9007199254740992)");
+    assert!(larger_rate.dominates(&unit_rate));
+    assert!(!unit_rate.dominates(&larger_rate));
+}
+
+#[test]
+fn test_registered_complexity_shapes_round_trip_exactly() {
+    for source in [
+        "1.1996^n",
+        "2^(0.7905*n)",
+        "3^(n/3)",
+        "3^k*n + 2^k*n^2",
+        "n^3",
+    ] {
+        let growth = g(source);
+        let rendered = growth.to_expr().expect("registered shape is supported");
+        assert_eq!(Growth::from_expr(&rendered), growth, "source: {source}");
+    }
+}
+
+#[test]
+fn test_every_registered_complexity_uses_the_shared_analysis() {
+    for entry in variant_entries() {
+        let expression = Expr::parse(entry.complexity);
+        let growth = Growth::from_expr(&expression);
+        if let Some(rendered) = growth.to_expr() {
+            assert_eq!(
+                Growth::from_expr(&rendered),
+                growth,
+                "{}: {}",
+                entry.name,
+                entry.complexity
+            );
+        }
+    }
+}
+
+/// Multi-base products remain incomparable when the conservative symbolic
+/// rules cannot prove an ordering, even when a stronger algebra system could.
+#[test]
+fn test_growth_unproved_multi_base_comparison_is_retained() {
+    let left = g("2^(2*n) * 3^n");
+    let right = g("2^n * 4^n");
+    assert!(!left.dominates(&right));
+    assert!(!right.dominates(&left));
+    assert_eq!(terms_of(&g("2^(2*n) * 3^n + 2^n * 4^n")).len(), 2);
+}
+
+#[test]
+fn test_exponential_product_proof_rules() {
+    let empty = VariableGrowth::empty();
+    let two = exponential_growth(&[(2.0, 1.0)]);
+    let two_squared = exponential_growth(&[(2.0, 2.0)]);
+    let three = exponential_growth(&[(3.0, 1.0)]);
+
+    assert_eq!(empty.cmp_exp(&empty), Some(Ordering::Equal));
+    assert_eq!(empty.cmp_exp(&two), Some(Ordering::Less));
+    assert_eq!(two.cmp_exp(&empty), Some(Ordering::Greater));
+    assert_eq!(two_squared.cmp_exp(&two), Some(Ordering::Greater));
+    assert_eq!(two.cmp_exp(&two_squared), Some(Ordering::Less));
+    assert_eq!(three.cmp_exp(&two), Some(Ordering::Greater));
+    assert_eq!(two.cmp_exp(&three), Some(Ordering::Less));
+
+    assert_eq!(
+        exponential_growth(&[(3.0, 2.0)]).cmp_exp(&exponential_growth(&[(2.0, 1.0)])),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(
+        exponential_growth(&[(2.0, 1.0)]).cmp_exp(&exponential_growth(&[(3.0, 2.0)])),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        exponential_growth(&[(2.0, 3.0)]).cmp_exp(&exponential_growth(&[(3.0, 1.0)])),
+        None
+    );
+
+    assert_eq!(
+        exponential_growth(&[(0.25, -1.0)]).cmp_exp(&exponential_growth(&[(0.5, -1.0)])),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(
+        exponential_growth(&[(0.5, -1.0)]).cmp_exp(&exponential_growth(&[(0.25, -1.0)])),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        exponential_growth(&[(0.25, -2.0)]).cmp_exp(&exponential_growth(&[(0.5, -1.0)])),
+        Some(Ordering::Greater)
+    );
+    assert_eq!(
+        exponential_growth(&[(0.5, -1.0)]).cmp_exp(&exponential_growth(&[(0.25, -2.0)])),
+        Some(Ordering::Less)
+    );
+    assert_eq!(
+        exponential_growth(&[(0.25, -1.0)]).cmp_exp(&exponential_growth(&[(0.5, -2.0)])),
+        None
+    );
+    assert_eq!(two.cmp_exp(&exponential_growth(&[(0.5, -1.0)])), None);
+
+    let natural = VariableGrowth::exponential(ExpBase::Natural, BigRational::one());
+    assert_eq!(natural.cmp_exp(&two), Some(Ordering::Greater));
+    assert_eq!(two.cmp_exp(&natural), Some(Ordering::Less));
+
+    // Constant subtrees normalize before growth comparison.
+    assert_eq!(g("(1 + 2)^n"), g("3^n"));
+
+    // Two residual products with no factorwise proof remain incomparable.
+    assert_eq!(
+        exponential_growth(&[(2.0, 2.0), (3.0, 1.0)])
+            .cmp_exp(&exponential_growth(&[(2.0, 1.0), (4.0, 1.0)])),
+        None
+    );
+}
+
+#[test]
+fn test_exponential_product_canonicalization() {
+    let combined = exponential_growth(&[(2.0, 1.0)])
+        .mul(&exponential_growth(&[(2.0, 2.0)]))
+        .unwrap();
+    assert_eq!(combined, exponential_growth(&[(2.0, 3.0)]));
+
+    let cancelled = exponential_growth(&[(2.0, 1.0)])
+        .mul(&exponential_growth(&[(2.0, -1.0)]))
+        .unwrap();
+    assert!(cancelled.is_empty());
+}
+
+#[test]
+fn test_growth_multi_base_product_is_deterministic() {
+    let left = g("2^n * 3^n");
+    let right = g("3^n * 2^n");
+    assert_eq!(left, right);
+}
+
+#[test]
+fn test_proven_equal_exponential_spelling_is_deterministic() {
+    let natural_first = g("exp(n) + 2.718281828459045^n");
+    let literal_first = g("2.718281828459045^n + exp(n)");
+    assert_eq!(natural_first, literal_first);
+    assert_eq!(natural_first.to_big_o(), literal_first.to_big_o());
+}
+
+/// 5. Widening: subtraction widens to addition, including the `sqrt((a-b)^2)`
+///    absolute-value idiom.
+#[test]
+fn test_growth_widening() {
+    assert_eq!(g("n - m"), g("n + m"));
+    assert_eq!(g("sqrt((n - m)^2)"), g("n + m"));
+}
+
+/// 6. Determinism: the antichain is canonically sorted, so structurally
+///    equivalent inputs are equal regardless of term order.
+#[test]
+fn test_growth_determinism() {
+    assert_eq!(g("n*m + m*n"), g("m*n + n*m"));
+}
+
+// --- Negative control ---
+
+/// Unsupported content widens to `Unknown`, and `Unknown` absorbs through add
+/// and mul — unsupported content can never silently produce a fake bound.
+#[test]
+fn test_growth_unknown_negative_control() {
+    assert_eq!(
+        g("2^(n*k)").failures(),
+        Some([GrowthFailure::NonlinearExponent("k * n".to_string())].as_slice())
+    );
+    assert!(matches!(
+        g("factorial(n)").failures(),
+        Some([GrowthFailure::FactorialOfNonconstant(_)])
+    ));
+    assert!(matches!(
+        Growth::from_expr(&Expr::factorial(Expr::rational(7, 2))).failures(),
+        Some([GrowthFailure::InvalidConstantDomain { .. }])
+    ));
+    assert!(matches!(
+        Growth::from_expr(&Expr::factorial(Expr::integer(-1))).failures(),
+        Some([GrowthFailure::InvalidConstantDomain { .. }])
+    ));
+    assert_eq!(
+        g("factorial(n) + 2^(n*k)").failures(),
+        Some(
+            [
+                GrowthFailure::NonlinearExponent("k * n".to_string()),
+                GrowthFailure::FactorialOfNonconstant("factorial(n)".to_string()),
+            ]
+            .as_slice()
+        )
+    );
+
+    // Absorption through the real `from_expr` add/mul paths.
+    let factorial_failure = g("factorial(n)");
+    assert_eq!(g("factorial(n) + n^2"), factorial_failure);
+    assert_eq!(g("n^2 + factorial(n)"), factorial_failure);
+    assert_eq!(g("factorial(n) * n^2"), factorial_failure);
+    assert_eq!(g("n^2 * factorial(n)"), factorial_failure);
+
+    // Absorption at the operation level too.
+    let n2 = g("n^2");
+    assert_eq!(
+        add(factorial_failure.clone(), n2.clone()),
+        factorial_failure
+    );
+    assert_eq!(
+        add(n2.clone(), factorial_failure.clone()),
+        factorial_failure
+    );
+    assert_eq!(
+        mul(factorial_failure.clone(), n2.clone()),
+        factorial_failure
+    );
+    assert_eq!(mul(n2, factorial_failure.clone()), factorial_failure);
+}
+
+#[test]
+fn test_growth_reports_nested_and_numeric_failures() {
+    let huge_constant = Expr::parse(&format!("1{}", "0".repeat(400)));
+    assert_eq!(Growth::from_expr(&huge_constant), g("1"));
+
+    let unsupported = Expr::factorial(Expr::variable("n"));
+    assert!(matches!(
+        Growth::from_expr(&Expr::exp(unsupported.clone())).failures(),
+        Some([GrowthFailure::FactorialOfNonconstant(_)])
+    ));
+    assert!(matches!(
+        Growth::from_expr(&Expr::factorial(unsupported)).failures(),
+        Some([GrowthFailure::FactorialOfNonconstant(_)])
+    ));
+
+    assert_eq!(Growth::from_expr(&Expr::variable("n")).failures(), None);
+    assert_eq!(exact_growth(Vec::new()).to_expr(), Some(Expr::integer(1)));
+}
+
+// --- Additional coverage ---
+
+/// Pure constants, constant factors, and constant division are all O(1) / dropped.
+#[test]
+fn test_growth_constants_are_o1() {
+    let c = g("42");
+    assert_eq!(terms_of(&c), [GrowthTerm::one()]);
+
+    // A wholly constant subtree (including `2^3`, `factorial(3)`, `1/2`) is O(1).
+    assert_eq!(g("2^3"), c);
+    assert_eq!(g("factorial(3)"), c);
+
+    // Constant multiplier and constant divisor drop out.
+    assert_eq!(g("3 * n"), g("n"));
+    assert_eq!(g("n / 2"), g("n"));
+}
+
+/// `x^0` is O(1); a negative exponent on a variable base is not admitted.
+#[test]
+fn test_growth_pow_special_cases() {
+    assert_eq!(terms_of(&g("n^0")), [GrowthTerm::one()]);
+    assert!(matches!(
+        g("n^(-1)").failures(),
+        Some([GrowthFailure::NegativeExponent(_)])
+    ));
+    // Variable base with variable exponent is not representable.
+    assert!(matches!(
+        g("n^m").failures(),
+        Some([GrowthFailure::VariableBaseAndExponent(_)])
+    ));
+}
+
+/// Canonical Big-O rendering: bounded classes get `O(<expr>)`, `Unknown` gets `O(?)`.
+#[test]
+fn test_growth_to_big_o() {
+    // The dominated `n` summand is dropped by the antichain, leaving just `n^2`.
+    assert_eq!(g("n^2 + n").to_big_o(), "O(n^2)");
+    assert_eq!(g("2^n").to_big_o(), "O(2^n)");
+    assert_eq!(g("5").to_big_o(), "O(1)");
+    assert_eq!(g("factorial(n)").to_big_o(), "O(?)");
+    // Renders exactly `O(<to_expr>)` for bounded classes.
+    let bounded = g("n * m");
+    assert_eq!(
+        bounded.to_big_o(),
+        format!("O({})", bounded.to_expr().unwrap())
+    );
+}
+
+/// Exponential bases are authoritative symbolic data, not values reconstructed
+/// from a rounded base-2 logarithm.
+#[test]
+fn test_growth_preserves_exponential_base() {
+    assert_eq!(g("3^n").to_big_o(), "O(3^n)");
+    assert_eq!(g("1.0000000001^n").to_big_o(), "O(1.0000000001^n)");
+    assert_eq!(g("2.7182818289^n").to_big_o(), "O(2.7182818289^n)");
+    assert_eq!(g("2^(n / 2)").to_big_o(), "O(2^(0.5 * n))");
+}
+
+#[test]
+fn test_growth_exponential_roundtrip_is_exact() {
+    for source in [
+        "3^n",
+        "2^(n / 2)",
+        "exp(2 * n)",
+        "2^n * 3^n",
+        "3^n * n^2 * log(n)",
+    ] {
+        let growth = g(source);
+        let rendered = growth.to_expr().expect("growth should be representable");
+        assert_eq!(
+            Growth::from_expr(&rendered),
+            growth,
+            "exponential growth changed while round-tripping {source} via {rendered}"
+        );
+    }
+}
+
+/// `exp(n)` uses base e; unit bases are constant, while decaying directions
+/// remain explicit analysis failures rather than silently widening to O(1).
+#[test]
+fn test_growth_exponential_variants() {
+    // exp(n) is represented directly as e^n: exponential, dominates any polynomial.
+    let en = g("exp(n)");
+    assert!(en.dominates(&g("n^5")));
+    assert!(matches!(
+        g("2^(n - m)").failures(),
+        Some([GrowthFailure::DecayingExponential { variable, .. }]) if variable == "m"
+    ));
+    // Unit base is exactly O(1).
+    assert_eq!(g("1^n"), g("7"));
+    assert!(matches!(
+        g("0.5^n").failures(),
+        Some([GrowthFailure::DecayingExponential {
+            variable,
+            coefficient,
+            ..
+        }]) if variable == "n" && coefficient == "1"
+    ));
+    // A fractional base with a negative exponent grows and retains that exact
+    // symbolic base instead of being translated through a common logarithm.
+    assert_eq!(g("0.5^(-n)").to_big_o(), "O(0.5^(-1 * n))");
+    assert!(g("0.5^(-n)").dominates(&g("n^100")));
+}
+
+/// `log` lowers each level: log of an exponential is linear, log of a
+/// polynomial is a log, and log distributes over products as a sum.
+#[test]
+fn test_growth_log_levels() {
+    // log(2^n) ≍ n.
+    assert_eq!(g("log(2^n)"), g("n"));
+    assert_eq!(g("log(3^n)"), g("n"));
+    assert_eq!(g("log(exp(n))"), g("n"));
+    // log(n) is a single log term.
+    assert_eq!(g("log(n)"), exact_growth(vec![term(&[], &[], &[("n", 1)])]));
+    // log(n*m) ≍ log n + log m (two summands, not a product).
+    assert_eq!(terms_of(&g("log(n*m)")).len(), 2);
+    // log of a constant is O(1).
+    assert_eq!(terms_of(&g("log(5)")), [GrowthTerm::one()]);
+
+    // A mixed monomial's log keeps *every* factor class: log(2^n * m) ≍ n + log m.
+    // The exponential factor must not swallow the polynomial one.
+    let mixed = g("log(2^n * m)");
+    let expected = exact_growth(vec![
+        term(&[], &[("n", 1.0)], &[]),
+        term(&[], &[], &[("m", 1)]),
+    ]);
+    assert_eq!(mixed, expected);
+    assert_eq!(terms_of(&mixed).len(), 2, "expected n + log m: {mixed:?}");
+
+    // When the classes share a variable the dominated summand is pruned:
+    // log(2^n * n^2) ≍ n + log n ≍ n (a single summand).
+    let shared = g("log(2^n * n^2)");
+    assert_eq!(shared, g("n"));
+    assert_eq!(terms_of(&shared), [term(&[], &[("n", 1.0)], &[])]);
+}
+
+/// `Unknown` is the top of the growth order.
+#[test]
+fn test_growth_unknown_dominance() {
+    let n2 = g("n^2");
+    let unknown = g("factorial(n)");
+    assert!(!unknown.dominates(&n2));
+    assert!(!n2.dominates(&unknown));
+    assert!(!unknown.dominates(&unknown));
+}
+
+/// Complete antichains are retained through the configured boundary; larger
+/// results fail explicitly instead of changing the represented Big-O class.
+#[test]
+fn test_growth_antichain_cap_reports_overflow() {
+    let vars: Vec<String> = (0..=ANTICHAIN_CAP)
+        .map(|index| format!("v{index}"))
+        .collect();
+    let terms: Vec<GrowthTerm> = vars
+        .iter()
+        .map(|variable| term(&[], &[(variable, 1.0)], &[]))
+        .collect();
+
+    let at_cap = exact_growth(terms[..ANTICHAIN_CAP].to_vec());
+    assert_eq!(terms_of(&at_cap).len(), ANTICHAIN_CAP);
+
+    let overflow = exact_growth(terms.clone());
+    assert!(matches!(
+        overflow.failures(),
+        Some([GrowthFailure::AntichainLimitExceeded { limit, terms }])
+            if *limit == ANTICHAIN_CAP && *terms == ANTICHAIN_CAP + 1
+    ));
+
+    let reversed = exact_growth(
+        vars.iter()
+            .rev()
+            .map(|variable| term(&[], &[(variable, 1.0)], &[]))
+            .collect(),
+    );
+    assert_eq!(overflow, reversed);
+}
+
+/// Unproved exponential comparisons obey the same explicit resource limit.
+#[test]
+fn test_growth_rejects_large_unproved_exponential_antichain() {
+    let terms = (1..=ANTICHAIN_CAP + 1)
+        .map(|i| {
+            let mut term = GrowthTerm::one();
+            term.insert(
+                "n".into(),
+                exponential_growth(&[(2.0, i as f64), (3.0, 1.0 / i as f64)]),
+            );
+            term
+        })
+        .collect::<Vec<_>>();
+
+    let growth = exact_growth(terms.clone());
+    assert!(matches!(
+        growth.failures(),
+        Some([GrowthFailure::AntichainLimitExceeded { limit, terms }])
+            if *limit == ANTICHAIN_CAP && *terms == ANTICHAIN_CAP + 1
+    ));
+}
+
+// --- Randomized property tests ---
+//
+// These cross-validate the symbolic growth domain against the numeric ground
+// truth (`Expr::eval`) over a large, seeded input space, in the spirit of the
+// repo's `/verify-reduction` adversarial culture. Three contracts are exercised
+// ≥ 5000 times each with a hand-rolled, deterministic RNG (no wall-clock, no
+// entropy — CI must be byte-reproducible across platforms):
+//
+//   1. Upper-bound soundness: `eval(e, s) ≤ C·eval(render(growth(e)), s)` at
+//      sizes larger than the anchor from which `C` was calibrated.
+//   2. Idempotence: `growth(render(growth(e))) == growth(e)`.
+//   3. Dominance soundness: when `dominates(b, a)`, the numeric ratio
+//      `eval(b)/eval(a)` does not shrink and exceeds 1 at the larger size.
+//
+// A #[test] negative control runs the same upper-bound harness against a
+// deliberately broken transfer function and asserts the harness catches it, so
+// the property tests are demonstrably capable of failing.
+//
+// Why the domain exists at all is *why* some numeric checks are unreachable:
+// crossovers like `2^n ≻ n^100` lie far beyond f64 range. The harnesses handle
+// this honestly — they skip (and count) samples where numerics are
+// indeterminate (both sides overflow to `inf`), never by hiding a failing
+// assertion. The dominance contract additionally restricts its numeric
+// cross-check to single-term, in-band growths, the regime where the crossover
+// is reachable; that regime targets exactly the lexicographic per-variable
+// comparison (`GrowthTerm::cmp`) at the heart of the order, so the restriction
+// is well-aimed, not vacuous.
+
+use super::{log_growth, pow_const};
+use crate::types::ProblemParameters;
+
+/// Fixed master seed. Every contract derives its own stream by offsetting this,
+/// so the whole suite is deterministic and reproducible on any platform.
+const MASTER_SEED: u64 = 0xD1CE_2026_A11C_E5ED;
+
+/// SplitMix64 — a tiny, fully specified PRNG. Hand-rolled (rather than
+/// `rand::StdRng`) precisely because its output must be identical across crate
+/// versions and platforms; the constants below are the published SplitMix64
+/// mixing constants and will never change.
+struct SplitMix64 {
+    state: u64,
+}
+
+impl SplitMix64 {
+    fn new(seed: u64) -> Self {
+        SplitMix64 { state: seed }
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        self.state = self.state.wrapping_add(0x9E37_79B9_7F4A_7C15);
+        let mut z = self.state;
+        z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+        z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+        z ^ (z >> 31)
+    }
+
+    /// Uniform integer in `[0, n)`.
+    fn below(&mut self, n: u64) -> u64 {
+        self.next_u64() % n
+    }
+}
+
+/// Variable pool used by generated expressions and [`joint_size`].
+const VARS: [&str; 3] = ["n", "m", "k"];
+
+fn gen_var(rng: &mut SplitMix64) -> Expr {
+    Expr::variable(VARS[rng.below(VARS.len() as u64) as usize])
+}
+
+/// All variables set jointly to `s` (the contracts evaluate on the diagonal).
+fn joint_size(s: u64) -> ProblemParameters {
+    ProblemParameters::new(vec![("n", s), ("m", s), ("k", s)])
+}
+
+// --- General expression generator (contracts 1 and 2) ---
+//
+// Bounded depth, variables {n, m, k}, constructors Const/Var/Add/Mul/Pow(const)/
+// Sqrt/Log plus linear `2^x` and `exp(x)` forms. A small (~1% per node) branch
+// emits a nonlinear exponent (`2^(n*m)`, `2^sqrt(n)`) so the `Unknown` widening
+// path is genuinely exercised while staying a minority of whole trees.
+
+const MAX_DEPTH: u32 = 5;
+
+fn gen_leaf(rng: &mut SplitMix64) -> Expr {
+    // Bias toward variables; keep constants small and positive.
+    if rng.below(4) == 0 {
+        Expr::integer(1 + rng.below(4))
+    } else {
+        gen_var(rng)
+    }
+}
+
+/// A linear expression in the variables (so `2^x` stays first-class in the
+/// domain): a sum of 1..=3 terms `c·v` with small positive integer coefficients.
+fn gen_linear(rng: &mut SplitMix64) -> Expr {
+    let nterms = 1 + rng.below(3);
+    let mut e = gen_lin_term(rng);
+    for _ in 1..nterms {
+        e = e + gen_lin_term(rng);
+    }
+    e
+}
+
+fn gen_lin_term(rng: &mut SplitMix64) -> Expr {
+    let v = gen_var(rng);
+    let c = 1 + rng.below(3);
+    if c == 1 {
+        v
+    } else {
+        Expr::integer(c) * v
+    }
+}
+
+/// A deliberately nonlinear exponent, driving `2^(·)` to `Growth::Unknown`.
+fn gen_nonlinear(rng: &mut SplitMix64) -> Expr {
+    if rng.below(2) == 0 {
+        gen_var(rng) * gen_var(rng)
+    } else {
+        Expr::sqrt(gen_var(rng))
+    }
+}
+
+const E_BELOW: f64 = std::f64::consts::E - 1e-10;
+const E_ABOVE: f64 = std::f64::consts::E + 1e-10;
+const STABLE_EXPONENTIAL_BASES: &[f64] = &[2.0, E_BELOW, E_ABOVE, 3.0];
+const ADVERSARIAL_EXPONENTIAL_BASES: &[f64] = &[1.0000000001, 2.0, E_BELOW, E_ABOVE, 3.0];
+
+fn gen_exponential_base(rng: &mut SplitMix64, bases: &[f64]) -> Expr {
+    expression_from_approximation(bases[rng.below(bases.len() as u64) as usize])
+}
+
+fn gen_expr(rng: &mut SplitMix64, depth: u32, exponential_bases: &[f64]) -> Expr {
+    if depth == 0 {
+        return gen_leaf(rng);
+    }
+    match rng.below(100) {
+        0..=19 => gen_leaf(rng),
+        20..=39 => {
+            gen_expr(rng, depth - 1, exponential_bases)
+                + gen_expr(rng, depth - 1, exponential_bases)
+        }
+        40..=54 => {
+            gen_expr(rng, depth - 1, exponential_bases)
+                * gen_expr(rng, depth - 1, exponential_bases)
+        }
+        55..=69 => Expr::pow(
+            gen_expr(rng, depth - 1, exponential_bases),
+            Expr::integer(1 + rng.below(3)),
+        ),
+        70..=79 => Expr::sqrt(gen_expr(rng, depth - 1, exponential_bases)),
+        80..=89 => Expr::log(gen_expr(rng, depth - 1, exponential_bases)),
+        90..=96 => Expr::pow(
+            gen_exponential_base(rng, exponential_bases),
+            gen_linear(rng),
+        ),
+        97..=98 => Expr::exp(gen_var(rng)),
+        // ~1% per node: a nonlinear exponent → Unknown (a minority of trees).
+        _ => Expr::pow(
+            gen_exponential_base(rng, exponential_bases),
+            gen_nonlinear(rng),
+        ),
+    }
+}
+
+// --- Monomial generator (contract 3) ---
+//
+// A product of single-term factors, so its growth is always a single antichain
+// term. This isolates the lexicographic per-variable dominance decision.
+
+fn gen_factor(rng: &mut SplitMix64) -> Expr {
+    let v = gen_var(rng);
+    match rng.below(6) {
+        0 => v,
+        1 => Expr::pow(v, Expr::integer(1 + rng.below(3))),
+        2 => Expr::sqrt(v),
+        3 => Expr::log(v),
+        // Keep the numeric dominance harness on one common base: different
+        // fixed bases can have crossovers beyond its finite observation window.
+        // Multi-base behavior is covered by symbolic proof tests above.
+        4 => Expr::pow(Expr::integer(2), v),
+        _ => Expr::pow(Expr::integer(2), Expr::integer(1 + rng.below(3)) * v),
+    }
+}
+
+fn gen_monomial(rng: &mut SplitMix64) -> Expr {
+    let nf = 1 + rng.below(4);
+    let mut e = gen_factor(rng);
+    for _ in 1..nf {
+        e = e * gen_factor(rng);
+    }
+    e
+}
+
+// --- Contract 1: upper-bound soundness ---
+
+/// The number of independent `#[test]`-level iterations for the upper-bound and
+/// idempotence contracts (each well above the 5000-meaningful-check floor after
+/// `Unknown`/overflow skips).
+const UB_ITERS: usize = 8_000;
+
+/// Outcome tallies for the upper-bound harness. `meaningful` counts samples that
+/// produced at least one *conclusive* large-size comparison.
+#[derive(Default)]
+struct UbResult {
+    meaningful: usize,
+    unknown: usize,
+    skipped: usize,
+    violations: usize,
+    first_violation: Option<String>,
+}
+
+/// Run the upper-bound harness against an arbitrary transfer function. The real
+/// test passes `Growth::from_expr`; the negative control passes
+/// `broken_from_expr`. Parameterizing here is what gives the harness teeth: the
+/// exact same code must accept the sound transfer and reject the broken one.
+fn run_upper_bound(transfer: fn(&Expr) -> Growth, seed: u64, iters: usize) -> UbResult {
+    // Anchor 2^6; check at 2^8, 2^10, 2^12 — all *larger* than the anchor.
+    let anchor = 64_u64;
+    let large = [256_u64, 1024, 4096];
+    let slack = 16.0_f64;
+
+    let mut rng = SplitMix64::new(seed);
+    let mut r = UbResult::default();
+
+    for _ in 0..iters {
+        let e = gen_expr(&mut rng, MAX_DEPTH, STABLE_EXPONENTIAL_BASES);
+        let g = transfer(&e);
+        let gexpr = match g.to_expr() {
+            Some(x) => x,
+            None => {
+                r.unknown += 1;
+                continue;
+            }
+        };
+
+        // Calibrate C from the observed ratio at the (smaller) anchor.
+        let sz0 = joint_size(anchor);
+        let (Ok(ve0), Ok(vg0)) = (
+            evaluate_approximate(&e, &sz0),
+            evaluate_approximate(&gexpr, &sz0),
+        ) else {
+            r.skipped += 1;
+            continue;
+        };
+        // Nonnegativity is a domain precondition. A negative anchor value means
+        // the generated expression is outside the domain's contract (e.g. deeply
+        // nested `log`s that are negative at these sizes) — skip it, don't hold
+        // the domain to a bound it never promised for such inputs.
+        if !ve0.is_finite() || !vg0.is_finite() || ve0 <= 0.0 || vg0 <= 0.0 {
+            r.skipped += 1;
+            continue;
+        }
+        let c = (ve0 / vg0) * slack;
+
+        let mut conclusive = false;
+        for &s in &large {
+            let sz = joint_size(s);
+            let (Ok(ve), Ok(vg)) = (
+                evaluate_approximate(&e, &sz),
+                evaluate_approximate(&gexpr, &sz),
+            ) else {
+                continue;
+            };
+            if ve <= 0.0 || vg <= 0.0 {
+                // Out of the nonnegative domain at this size — indeterminate.
+                continue;
+            }
+            // Both finite and positive: a real, decidable comparison.
+            conclusive = true;
+            let bound = c * vg;
+            if ve > bound {
+                r.violations += 1;
+                if r.first_violation.is_none() {
+                    r.first_violation = Some(format!(
+                        "e = {e}  |  g = {gexpr}  |  s = {s}: eval(e) = {ve} > {c} * {vg} = {bound}"
+                    ));
+                }
+            }
+        }
+
+        if conclusive {
+            r.meaningful += 1;
+        } else {
+            r.skipped += 1;
+        }
+    }
+    r
+}
+
+/// A deliberately broken transfer function: `Add` keeps only its *first*
+/// operand's growth, dropping the second. This is an under-approximation — it
+/// can miss the dominant summand — so the upper bound must fail somewhere.
+/// Every other node mirrors the real `Growth::from_expr` (reusing its private
+/// transfer helpers), so the only defect is the seeded `Add` bug.
+fn broken_from_expr(expression: &Expr) -> Growth {
+    match expression.node() {
+        // The seeded bug: drop every summand except the first.
+        ExprNode::Add(values) => broken_from_expr(&values[0]),
+        ExprNode::Mul(values) => values
+            .iter()
+            .map(broken_from_expr)
+            .reduce(mul)
+            .expect("normalized product has at least two factors"),
+        ExprNode::Pow(base, exponent) => {
+            let analysis = AlgebraicAnalysis::new(&[expression]);
+            match analysis.facts(exponent).exact_rational.as_ref() {
+                Some(power) if power.is_negative() => {
+                    Growth::unknown(GrowthFailure::NegativeExponent(exponent.to_string()))
+                }
+                Some(power) => pow_const(broken_from_expr(base), power),
+                None => Growth::from_expr(expression),
+            }
+        }
+        ExprNode::Log(value) => log_growth(broken_from_expr(value)),
+        _ => Growth::from_expr(expression),
+    }
+}
+#[test]
+fn test_growth_property_upper_bound_sound() {
+    let r = run_upper_bound(Growth::from_expr, MASTER_SEED ^ 0x01, UB_ITERS);
+
+    assert_eq!(
+        r.violations,
+        0,
+        "upper-bound violation ({} total); first: {}",
+        r.violations,
+        r.first_violation.as_deref().unwrap_or("<none>")
+    );
+    assert!(
+        r.meaningful >= 5000,
+        "need >= 5000 meaningful checks, got {} (unknown {}, skipped {})",
+        r.meaningful,
+        r.unknown,
+        r.skipped
+    );
+    // The generator must actually exercise the domain, not mostly produce Unknown.
+    let total = r.meaningful + r.unknown + r.skipped;
+    assert!(
+        r.unknown * 2 < total,
+        "Unknown must be a minority: {}/{}",
+        r.unknown,
+        total
+    );
+    assert!(r.unknown > 0, "generator never exercised the Unknown path");
+}
+
+#[test]
+fn test_growth_property_upper_bound_negative_control() {
+    // The SAME harness, run against the broken transfer, must detect a
+    // violation. If it cannot, the property tests have no teeth and this fails.
+    let r = run_upper_bound(broken_from_expr, MASTER_SEED ^ 0x01, UB_ITERS);
+    assert!(
+        r.violations > 0,
+        "harness failed to catch the seeded Add bug (meaningful {}, violations {})",
+        r.meaningful,
+        r.violations
+    );
+}
+
+// --- Contract 2: idempotence ---
+
+fn term_approx_eq(x: &GrowthTerm, y: &GrowthTerm) -> bool {
+    x == y
+}
+
+fn growth_approx_eq(a: &Growth, b: &Growth) -> bool {
+    match (&a.0, &b.0) {
+        (GrowthState::Unknown(_), GrowthState::Unknown(_)) => true,
+        (GrowthState::Known(ta), GrowthState::Known(tb)) => {
+            ta.len() == tb.len()
+                && ta.iter().all(|t| tb.iter().any(|u| term_approx_eq(t, u)))
+                && tb.iter().all(|u| ta.iter().any(|t| term_approx_eq(t, u)))
+        }
+        _ => false,
+    }
+}
+
+#[test]
+fn test_growth_property_idempotence() {
+    let mut rng = SplitMix64::new(MASTER_SEED ^ 0x02);
+    let mut meaningful = 0usize;
+    let mut unknown = 0usize;
+
+    for _ in 0..UB_ITERS {
+        // Idempotence is purely symbolic, so it can safely exercise bases near
+        // one whose numeric crossover lies far beyond the f64 test window.
+        let e = gen_expr(&mut rng, MAX_DEPTH, ADVERSARIAL_EXPONENTIAL_BASES);
+        let g = Growth::from_expr(&e);
+        let rendered = match g.to_expr() {
+            Some(x) => x,
+            None => {
+                unknown += 1;
+                continue;
+            }
+        };
+        let g2 = Growth::from_expr(&rendered);
+        assert!(
+            growth_approx_eq(&g, &g2),
+            "growth not idempotent: e = {e}  |  render = {rendered}\n  g  = {g:?}\n  g2 = {g2:?}"
+        );
+        meaningful += 1;
+    }
+
+    assert!(
+        meaningful >= 5000,
+        "need >= 5000 meaningful checks, got {meaningful} (unknown {unknown})"
+    );
+}
+
+// --- Contract 3: dominance soundness ---
+
+const DOM_ITERS: usize = 5_000;
+
+#[test]
+fn test_growth_property_dominance_sound() {
+    let mut rng = SplitMix64::new(MASTER_SEED ^ 0x03);
+
+    for _ in 0..DOM_ITERS {
+        let lower_expression = gen_monomial(&mut rng);
+        let ratio_expression = gen_factor(&mut rng);
+        let higher_expression = lower_expression.clone() * ratio_expression.clone();
+        let lower = Growth::from_expr(&lower_expression);
+        let higher = Growth::from_expr(&higher_expression);
+        assert!(higher.dominates(&lower));
+        assert!(!lower.dominates(&higher));
+
+        let r1 = evaluate_approximate(&ratio_expression, &joint_size(16)).unwrap();
+        let r2 = evaluate_approximate(&ratio_expression, &joint_size(64)).unwrap();
+        assert!(
+            r2 >= r1 * (1.0 - 1e-9),
+            "dominance ratio shrank: {higher_expression} over {lower_expression}; r(16) = {r1}, r(64) = {r2}"
+        );
+        assert!(
+            r2 > 1.0,
+            "dominator not numerically ahead: {higher_expression} over {lower_expression}; r(64) = {r2}"
+        );
+    }
+}
diff --git a/src/unit_tests/io.rs b/src/unit_tests/io.rs
index ec085789b..e3e9e148b 100644
--- a/src/unit_tests/io.rs
+++ b/src/unit_tests/io.rs
@@ -7,7 +7,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 #[test]
 fn test_to_json() {
     let problem =
-        MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+        MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     let json = to_json(&problem);
     assert!(json.is_ok());
     let json = json.unwrap();
@@ -17,16 +17,16 @@ fn test_to_json() {
 #[test]
 fn test_from_json() {
     let problem =
-        MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+        MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     let json = to_json(&problem).unwrap();
-    let restored: MaximumIndependentSet<SimpleGraph, i32> = from_json(&json).unwrap();
+    let restored: MaximumIndependentSet<SimpleGraph, i64> = from_json(&json).unwrap();
     assert_eq!(restored.graph().num_vertices(), 3);
     assert_eq!(restored.graph().num_edges(), 2);
 }
 
 #[test]
 fn test_json_compact() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let compact = to_json_compact(&problem).unwrap();
     let pretty = to_json(&problem).unwrap();
     // Compact should be shorter
@@ -37,7 +37,7 @@ fn test_json_compact() {
 fn test_file_roundtrip() {
     let problem = MaximumIndependentSet::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let ts = SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -50,7 +50,7 @@ fn test_file_roundtrip() {
     write_problem(&problem, path, FileFormat::Json).unwrap();
 
     // Read back
-    let restored: MaximumIndependentSet<SimpleGraph, i32> =
+    let restored: MaximumIndependentSet<SimpleGraph, i64> =
         read_problem(path, FileFormat::Json).unwrap();
     assert_eq!(restored.graph().num_vertices(), 4);
     assert_eq!(restored.graph().num_edges(), 3);
@@ -93,6 +93,6 @@ fn test_read_write_file() {
 
 #[test]
 fn test_invalid_json() {
-    let result: Result<MaximumIndependentSet<SimpleGraph, i32>> = from_json("not valid json");
+    let result: Result<MaximumIndependentSet<SimpleGraph, i64>> = from_json("not valid json");
     assert!(result.is_err());
 }
diff --git a/src/unit_tests/jl_helpers.rs b/src/unit_tests/jl_helpers.rs
index cb51d27a8..4c9ca243f 100644
--- a/src/unit_tests/jl_helpers.rs
+++ b/src/unit_tests/jl_helpers.rs
@@ -21,13 +21,13 @@ fn jl_parse_edges(instance: &serde_json::Value) -> Vec<(usize, usize)> {
 }
 
 #[allow(dead_code)]
-fn jl_parse_weighted_edges(instance: &serde_json::Value) -> Vec<(usize, usize, i32)> {
+fn jl_parse_weighted_edges(instance: &serde_json::Value) -> Vec<(usize, usize, i64)> {
     let edges = jl_parse_edges(instance);
-    let weights: Vec<i32> = instance["weights"]
+    let weights: Vec<i64> = instance["weights"]
         .as_array()
         .expect("weights should be an array")
         .iter()
-        .map(|w| w.as_i64().expect("weight should be i64") as i32)
+        .map(|w| w.as_i64().expect("weight should be i64"))
         .collect();
     edges
         .into_iter()
@@ -55,11 +55,45 @@ fn jl_parse_configs_set(val: &serde_json::Value) -> HashSet<Vec<usize>> {
 }
 
 #[allow(dead_code)]
-fn jl_parse_i32_vec(val: &serde_json::Value) -> Vec<i32> {
+fn jl_parse_bool_config(val: &serde_json::Value) -> Vec<bool> {
+    jl_parse_config(val)
+        .into_iter()
+        .map(|value| match value {
+            0 => false,
+            1 => true,
+            _ => panic!("Boolean configuration element must be 0 or 1"),
+        })
+        .collect()
+}
+
+#[allow(dead_code)]
+fn jl_parse_bool_configs_set(val: &serde_json::Value) -> HashSet<Vec<bool>> {
+    val.as_array()
+        .expect("configs set should be an array")
+        .iter()
+        .map(jl_parse_bool_config)
+        .collect()
+}
+
+#[allow(dead_code)]
+fn jl_parse_spin_configs_set(val: &serde_json::Value) -> HashSet<Vec<i8>> {
+    jl_parse_bool_configs_set(val)
+        .into_iter()
+        .map(|config| {
+            config
+                .into_iter()
+                .map(|selected| if selected { 1 } else { -1 })
+                .collect()
+        })
+        .collect()
+}
+
+#[allow(dead_code)]
+fn jl_parse_i64_vec(val: &serde_json::Value) -> Vec<i64> {
     val.as_array()
         .expect("should be an array of integers")
         .iter()
-        .map(|v| v.as_i64().expect("element should be i64") as i32)
+        .map(|v| v.as_i64().expect("element should be i64"))
         .collect()
 }
 
@@ -90,14 +124,14 @@ fn jl_parse_sat_clauses(
         .expect("clauses should be an array")
         .iter()
         .map(|clause| {
-            let literals: Vec<i32> = clause["literals"]
+            let literals: Vec<i64> = clause["literals"]
                 .as_array()
                 .expect("clause.literals should be an array")
                 .iter()
                 .map(|lit| {
                     let var = lit["variable"]
                         .as_u64()
-                        .expect("literal.variable should be a u64") as i32
+                        .expect("literal.variable should be a u64") as i64
                         + 1;
                     let negated = lit["negated"]
                         .as_bool()
@@ -113,12 +147,12 @@ fn jl_parse_sat_clauses(
 
 /// Flip a binary config: 0<->1 for SpinGlass spin convention mapping.
 #[allow(dead_code)]
-fn jl_flip_config(config: &[usize]) -> Vec<usize> {
-    config.iter().map(|&x| 1 - x).collect()
+fn jl_flip_config(config: &[usize]) -> Vec<i8> {
+    config.iter().map(|&x| if x == 0 { 1 } else { -1 }).collect()
 }
 
 #[allow(dead_code)]
-fn jl_flip_configs_set(configs: &HashSet<Vec<usize>>) -> HashSet<Vec<usize>> {
+fn jl_flip_configs_set(configs: &HashSet<Vec<usize>>) -> HashSet<Vec<i8>> {
     configs.iter().map(|c| jl_flip_config(c)).collect()
 }
 
diff --git a/src/unit_tests/models/algebraic/algebraic_equations_over_gf2.rs b/src/unit_tests/models/algebraic/algebraic_equations_over_gf2.rs
index 1e1750e1f..87df06fc5 100644
--- a/src/unit_tests/models/algebraic/algebraic_equations_over_gf2.rs
+++ b/src/unit_tests/models/algebraic/algebraic_equations_over_gf2.rs
@@ -1,5 +1,6 @@
 use crate::models::algebraic::AlgebraicEquationsOverGF2;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -38,7 +39,7 @@ fn test_algebraic_equations_over_gf2_creation_and_accessors() {
     assert_eq!(p.num_variables(), 3);
     assert_eq!(p.num_equations(), 3);
     assert_eq!(p.equations().len(), 3);
-    assert_eq!(p.dims(), vec![2, 2, 2]);
+    assert_eq!(p.dimensions(), vec![2, 2, 2]);
     assert_eq!(p.num_variables(), 3);
     assert_eq!(
         <AlgebraicEquationsOverGF2 as Problem>::NAME,
@@ -54,79 +55,79 @@ fn test_algebraic_equations_over_gf2_evaluate_satisfiable() {
     //   eq0: 1*0 + 0 = 0 ✓
     //   eq1: 0*0 + 1 + 1 = 0 ✓
     //   eq2: 1 + 0 + 0 + 1 = 0 ✓
-    assert_eq!(p.evaluate(&[1, 0, 0]), Or(true));
+    assert_eq!(p.evaluate(&vec![true, false, false]).unwrap(), Or(true));
 
     // config [0,0,0]:
     //   eq0: 0*0 + 0 = 0 ✓
     //   eq1: 0*0 + 0 + 1 = 1 ✗
-    assert_eq!(p.evaluate(&[0, 0, 0]), Or(false));
+    assert_eq!(p.evaluate(&vec![false, false, false]).unwrap(), Or(false));
 
     // config [1,1,1]:
     //   eq0: 1*1 + 1 = 0 ✓
     //   eq1: 1*1 + 1 + 1 = 1 ✗
-    assert_eq!(p.evaluate(&[1, 1, 1]), Or(false));
+    assert_eq!(p.evaluate(&vec![true, true, true]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_algebraic_equations_over_gf2_evaluate_unsatisfiable() {
     let p = unsatisfiable_problem();
-    assert_eq!(p.dims(), vec![2, 2]);
+    assert_eq!(p.dimensions(), vec![2, 2]);
     // All 4 assignments should fail
-    assert_eq!(p.evaluate(&[0, 0]), Or(false)); // eq0: 0+0=0 ✓, eq1: 0+0+1=1 ✗
-    assert_eq!(p.evaluate(&[0, 1]), Or(false)); // eq0: 0+1=1 ✗
-    assert_eq!(p.evaluate(&[1, 0]), Or(false)); // eq0: 1+0=1 ✗
-    assert_eq!(p.evaluate(&[1, 1]), Or(false)); // eq0: 1+1=0 ✓, eq1: 1+1+1=1 ✗
+    assert_eq!(p.evaluate(&vec![false, false]).unwrap(), Or(false)); // eq0: 0+0=0 ✓, eq1: 0+0+1=1 ✗
+    assert_eq!(p.evaluate(&vec![false, true]).unwrap(), Or(false)); // eq0: 0+1=1 ✗
+    assert_eq!(p.evaluate(&vec![true, false]).unwrap(), Or(false)); // eq0: 1+0=1 ✗
+    assert_eq!(p.evaluate(&vec![true, true]).unwrap(), Or(false)); // eq0: 1+1=0 ✓, eq1: 1+1+1=1 ✗
 }
 
 #[test]
 fn test_algebraic_equations_over_gf2_constant_monomial() {
     // Single equation: 1 = 0 (always false)
     let p = AlgebraicEquationsOverGF2::new(1, vec![vec![vec![]]]).unwrap();
-    assert_eq!(p.evaluate(&[0]), Or(false));
-    assert_eq!(p.evaluate(&[1]), Or(false));
+    assert_eq!(p.evaluate(&vec![false]).unwrap(), Or(false));
+    assert_eq!(p.evaluate(&vec![true]).unwrap(), Or(false));
 
     // Single equation: 1 + 1 = 0 (always true — two constants XOR to 0)
     let p2 = AlgebraicEquationsOverGF2::new(1, vec![vec![vec![], vec![]]]).unwrap();
-    assert_eq!(p2.evaluate(&[0]), Or(true));
-    assert_eq!(p2.evaluate(&[1]), Or(true));
+    assert_eq!(p2.evaluate(&vec![false]).unwrap(), Or(true));
+    assert_eq!(p2.evaluate(&vec![true]).unwrap(), Or(true));
 }
 
 #[test]
 fn test_algebraic_equations_over_gf2_empty_equations() {
     // No equations: trivially satisfied
     let p = AlgebraicEquationsOverGF2::new(2, vec![]).unwrap();
-    assert_eq!(p.evaluate(&[0, 0]), Or(true));
-    assert_eq!(p.evaluate(&[1, 1]), Or(true));
+    assert_eq!(p.evaluate(&vec![false, false]).unwrap(), Or(true));
+    assert_eq!(p.evaluate(&vec![true, true]).unwrap(), Or(true));
 }
 
 #[test]
 fn test_algebraic_equations_over_gf2_empty_polynomial() {
     // One equation with no monomials: sum = 0, so satisfied
     let p = AlgebraicEquationsOverGF2::new(2, vec![vec![]]).unwrap();
-    assert_eq!(p.evaluate(&[0, 0]), Or(true));
+    assert_eq!(p.evaluate(&vec![false, false]).unwrap(), Or(true));
 }
 
 #[test]
 fn test_algebraic_equations_over_gf2_brute_force_finds_witness() {
     let solver = BruteForce::new();
     let p = satisfiable_problem();
-    let witness = solver.find_witness(&p).unwrap();
-    assert_eq!(p.evaluate(&witness), Or(true));
+    let witness = solver.solve(&p).unwrap().unwrap();
+    assert_eq!(p.evaluate(&witness).unwrap(), Or(true));
 }
 
 #[test]
 fn test_algebraic_equations_over_gf2_brute_force_no_witness() {
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&unsatisfiable_problem()).is_none());
+    assert!(solver.solve(&unsatisfiable_problem()).unwrap().is_none());
 }
 
 #[test]
 fn test_algebraic_equations_over_gf2_brute_force_finds_all_witnesses() {
     let solver = BruteForce::new();
     let p = satisfiable_problem();
-    let all = solver.find_all_witnesses(&p);
+    let all = solver.find_all_witnesses(&p).unwrap();
     assert!(!all.is_empty());
-    assert!(all.iter().all(|sol| p.evaluate(sol) == Or(true)));
+    assert!(all.iter().all(|sol| p.evaluate(sol).unwrap() == Or(true)));
 }
 
 #[test]
@@ -140,7 +141,10 @@ fn test_algebraic_equations_over_gf2_serialization() {
     assert_eq!(restored.num_variables(), p.num_variables());
     assert_eq!(restored.num_equations(), p.num_equations());
     // Check round-trip preserves evaluation
-    assert_eq!(restored.evaluate(&[1, 0, 0]), Or(true));
+    assert_eq!(
+        restored.evaluate(&vec![true, false, false]).unwrap(),
+        Or(true)
+    );
 }
 
 #[test]
@@ -183,9 +187,9 @@ fn test_algebraic_equations_over_gf2_validation_errors() {
 fn test_algebraic_equations_over_gf2_paper_example() {
     // Canonical example from the issue: n=3, 3 equations, config [1,0,0]
     let p = satisfiable_problem();
-    assert_eq!(p.evaluate(&[1, 0, 0]), Or(true));
+    assert_eq!(p.evaluate(&vec![true, false, false]).unwrap(), Or(true));
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&p).unwrap();
-    assert_eq!(p.evaluate(&witness), Or(true));
+    let witness = solver.solve(&p).unwrap().unwrap();
+    assert_eq!(p.evaluate(&witness).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/models/algebraic/bmf.rs b/src/unit_tests/models/algebraic/bmf.rs
index 3be9d3dff..a32c2a23c 100644
--- a/src/unit_tests/models/algebraic/bmf.rs
+++ b/src/unit_tests/models/algebraic/bmf.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -18,7 +19,8 @@ fn test_extract_factors() {
     let matrix = vec![vec![true]];
     let problem = BMF::new(matrix, 1);
     // Config: [b00, c00] = [1, 1]
-    let (b, c) = problem.extract_factors(&[1, 1]);
+    let solution = (vec![vec![true]], vec![vec![true]]);
+    let (b, c) = problem.extract_factors(&solution);
     assert_eq!(b, vec![vec![true]]);
     assert_eq!(c, vec![vec![true]]);
 }
@@ -30,7 +32,8 @@ fn test_extract_factors_larger() {
     let problem = BMF::new(matrix, 1);
     // B: 2x1, C: 1x2
     // Config: [b00, b10, c00, c01] = [1, 1, 1, 1]
-    let (b, c) = problem.extract_factors(&[1, 1, 1, 1]);
+    let solution = (vec![vec![true], vec![true]], vec![vec![true, true]]);
+    let (b, c) = problem.extract_factors(&solution);
     assert_eq!(b, vec![vec![true], vec![true]]);
     assert_eq!(c, vec![vec![true, true]]);
 }
@@ -63,12 +66,15 @@ fn test_hamming_distance() {
 
     // B = [[1,0], [0,1]], C = [[1,0], [0,1]] -> exact match
     // Config: [1,0,0,1, 1,0,0,1]
-    let config = vec![1, 0, 0, 1, 1, 0, 0, 1];
-    assert_eq!(problem.hamming_distance(&config), 0);
+    let config = (
+        vec![vec![true, false], vec![false, true]],
+        vec![vec![true, false], vec![false, true]],
+    );
+    assert_eq!(problem.hamming_distance(&config).unwrap(), 0);
 
     // All zeros -> product is all zeros, distance = 2
-    let config = vec![0, 0, 0, 0, 0, 0, 0, 0];
-    assert_eq!(problem.hamming_distance(&config), 2);
+    let config = (vec![vec![false; 2]; 2], vec![vec![false; 2]; 2]);
+    assert_eq!(problem.hamming_distance(&config).unwrap(), 2);
 }
 
 #[test]
@@ -77,12 +83,23 @@ fn test_evaluate() {
     let problem = BMF::new(matrix, 2);
 
     // Exact factorization -> Min(Some(total_factor_size)) = 4 (two 1s in B, two in C)
-    let config = vec![1, 0, 0, 1, 1, 0, 0, 1];
-    assert_eq!(Problem::evaluate(&problem, &config), Min(Some(4)));
+    let config = (
+        vec![vec![true, false], vec![false, true]],
+        vec![vec![true, false], vec![false, true]],
+    );
+    assert_eq!(Problem::evaluate(&problem, &config).unwrap(), Min(Some(4)));
 
     // Non-exact -> Min(None)
-    let config = vec![0, 0, 0, 0, 0, 0, 0, 0];
-    assert_eq!(Problem::evaluate(&problem, &config), Min(None));
+    let config = (vec![vec![false; 2]; 2], vec![vec![false; 2]; 2]);
+    assert_eq!(Problem::evaluate(&problem, &config).unwrap(), Min(None));
+}
+
+#[test]
+fn test_evaluate_rejects_invalid_configurations() {
+    let problem = BMF::new(vec![vec![true]], 1);
+    assert!(Problem::evaluate(&problem, &(vec![], vec![vec![true]])).is_err());
+    assert!(Problem::evaluate(&problem, &(vec![vec![true]], vec![])).is_err());
+    assert!(Problem::evaluate(&problem, &(vec![vec![true, false]], vec![vec![true]])).is_err());
 }
 
 #[test]
@@ -93,11 +110,11 @@ fn test_brute_force_ones() {
     let problem = BMF::new(matrix, 1);
     let solver = BruteForce::new();
 
-    let witnesses = solver.find_all_witnesses(&problem);
+    let witnesses = solver.find_all_witnesses(&problem).unwrap();
     assert!(!witnesses.is_empty());
     for sol in &witnesses {
-        assert!(problem.is_exact(sol));
-        assert_eq!(Problem::evaluate(&problem, sol), Min(Some(4)));
+        assert!(problem.is_exact(sol).unwrap());
+        assert_eq!(Problem::evaluate(&problem, sol).unwrap(), Min(Some(4)));
     }
 }
 
@@ -108,9 +125,9 @@ fn test_brute_force_identity() {
     let problem = BMF::new(matrix, 2);
     let solver = BruteForce::new();
 
-    let witnesses = solver.find_all_witnesses(&problem);
+    let witnesses = solver.find_all_witnesses(&problem).unwrap();
     for sol in &witnesses {
-        assert!(problem.is_exact(sol));
+        assert!(problem.is_exact(sol).unwrap());
     }
 }
 
@@ -122,9 +139,10 @@ fn test_brute_force_insufficient_rank() {
     let problem = BMF::new(matrix, 1);
     let solver = BruteForce::new();
 
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(
-        witness.is_none() || Problem::evaluate(&problem, witness.as_ref().unwrap()) == Min(None)
+        witness.is_none()
+            || Problem::evaluate(&problem, witness.as_ref().unwrap()).unwrap() == Min(None)
     );
 }
 
@@ -152,29 +170,43 @@ fn test_empty_matrix() {
     let problem = BMF::new(matrix, 1);
     assert_eq!(problem.num_variables(), 0);
     // Empty matrix factors exactly with zero factor size.
-    assert_eq!(Problem::evaluate(&problem, &[]), Min(Some(0)));
+    assert_eq!(
+        Problem::evaluate(&problem, &(vec![], vec![vec![]])).unwrap(),
+        Min(Some(0))
+    );
 }
 
 #[test]
 fn test_rank_zero_exactness() {
     let nonzero = BMF::new(vec![vec![true, false]], 0);
-    assert_eq!(nonzero.dims(), Vec::<usize>::new());
-    assert_eq!(nonzero.hamming_distance(&[]), 1);
-    assert!(!nonzero.is_exact(&[]));
-    assert_eq!(Problem::evaluate(&nonzero, &[]), Min(None));
+    assert_eq!(nonzero.dimensions(), Vec::<usize>::new());
+    let empty_factors = (vec![vec![]], vec![]);
+    assert_eq!(nonzero.hamming_distance(&empty_factors).unwrap(), 1);
+    assert!(!nonzero.is_exact(&empty_factors).unwrap());
+    assert_eq!(
+        Problem::evaluate(&nonzero, &empty_factors).unwrap(),
+        Min(None)
+    );
 
     let zero = BMF::new(vec![vec![false, false]], 0);
-    assert_eq!(zero.hamming_distance(&[]), 0);
-    assert!(zero.is_exact(&[]));
-    assert_eq!(Problem::evaluate(&zero, &[]), Min(Some(0)));
+    assert_eq!(zero.hamming_distance(&empty_factors).unwrap(), 0);
+    assert!(zero.is_exact(&empty_factors).unwrap());
+    assert_eq!(
+        Problem::evaluate(&zero, &empty_factors).unwrap(),
+        Min(Some(0))
+    );
 }
 
 #[test]
 fn test_is_exact() {
     let matrix = vec![vec![true]];
     let problem = BMF::new(matrix, 1);
-    assert!(problem.is_exact(&[1, 1]));
-    assert!(!problem.is_exact(&[0, 0]));
+    assert!(problem
+        .is_exact(&(vec![vec![true]], vec![vec![true]]))
+        .unwrap());
+    assert!(!problem
+        .is_exact(&(vec![vec![false]], vec![vec![false]]))
+        .unwrap());
 }
 
 #[test]
@@ -186,30 +218,47 @@ fn test_bmf_problem() {
     let problem = BMF::new(matrix, 2);
 
     // dims: B(2*2) + C(2*2) = 8 binary variables
-    assert_eq!(problem.dims(), vec![2; 8]);
+    assert_eq!(problem.dimensions(), vec![2; 8]);
 
     // Exact factorization: B = I, C = I — total factor size = 4
     assert_eq!(
-        Problem::evaluate(&problem, &[1, 0, 0, 1, 1, 0, 0, 1]),
+        Problem::evaluate(
+            &problem,
+            &(
+                vec![vec![true, false], vec![false, true]],
+                vec![vec![true, false], vec![false, true]],
+            ),
+        )
+        .unwrap(),
         Min(Some(4))
     );
 
     // All zeros -> product is all zeros, not equal to A -> infeasible
     assert_eq!(
-        Problem::evaluate(&problem, &[0, 0, 0, 0, 0, 0, 0, 0]),
+        Problem::evaluate(
+            &problem,
+            &(vec![vec![false; 2]; 2], vec![vec![false; 2]; 2])
+        )
+        .unwrap(),
         Min(None)
     );
 
     // 1x1 matrix
     let matrix = vec![vec![true]];
     let problem = BMF::new(matrix, 1);
-    assert_eq!(problem.dims(), vec![2; 2]); // B(1*1) + C(1*1)
-    assert_eq!(Problem::evaluate(&problem, &[1, 1]), Min(Some(2))); // Exact, factor size 2
-    assert_eq!(Problem::evaluate(&problem, &[0, 0]), Min(None)); // Not exact
+    assert_eq!(problem.dimensions(), vec![2; 2]); // B(1*1) + C(1*1)
+    assert_eq!(
+        Problem::evaluate(&problem, &(vec![vec![true]], vec![vec![true]])).unwrap(),
+        Min(Some(2))
+    );
+    assert_eq!(
+        Problem::evaluate(&problem, &(vec![vec![false]], vec![vec![false]])).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = BMF::new(
         vec![vec![true, false], vec![false, true], vec![true, true]],
         1,
@@ -230,11 +279,14 @@ fn test_bmf_paper_example() {
     // B (3x2): [[1,0],[1,1],[0,1]], C (2x3): [[1,1,0],[0,1,1]]
     // Config: B row-major then C row-major
     // Eight 1s total -> optimal total factor size = 8.
-    let config = vec![1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1];
-    assert!(problem.is_exact(&config));
-    assert_eq!(Problem::evaluate(&problem, &config), Min(Some(8)));
+    let config = (
+        vec![vec![true, false], vec![true, true], vec![false, true]],
+        vec![vec![true, true, false], vec![false, true, true]],
+    );
+    assert!(problem.is_exact(&config).unwrap());
+    assert_eq!(Problem::evaluate(&problem, &config).unwrap(), Min(Some(8)));
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert!(problem.is_exact(&best));
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert!(problem.is_exact(&best).unwrap());
 }
diff --git a/src/unit_tests/models/algebraic/closest_vector_problem.rs b/src/unit_tests/models/algebraic/closest_vector_problem.rs
index ff5e41dc4..c78712962 100644
--- a/src/unit_tests/models/algebraic/closest_vector_problem.rs
+++ b/src/unit_tests/models/algebraic/closest_vector_problem.rs
@@ -1,225 +1,136 @@
 use super::*;
-use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
 
 #[test]
-fn test_cvp_creation() {
-    // 3D integer lattice: b1=(2,0,0), b2=(1,2,0), b3=(0,1,2)
-    let basis = vec![vec![2, 0, 0], vec![1, 2, 0], vec![0, 1, 2]];
-    let target = vec![3.0, 3.0, 3.0];
-    let bounds = vec![
-        VarBounds::bounded(-2, 4),
-        VarBounds::bounded(-2, 4),
-        VarBounds::bounded(-2, 4),
-    ];
-    let cvp = ClosestVectorProblem::new(basis, target, bounds);
-    assert_eq!(cvp.num_variables(), 3);
-    assert_eq!(cvp.ambient_dimension(), 3);
-    assert_eq!(cvp.num_basis_vectors(), 3);
-}
-
-#[test]
-fn test_cvp_evaluate() {
-    // b1=(2,0,0), b2=(1,2,0), b3=(0,1,2), target=(3,3,3)
-    let basis = vec![vec![2, 0, 0], vec![1, 2, 0], vec![0, 1, 2]];
-    let target = vec![3.0, 3.0, 3.0];
-    let bounds = vec![
-        VarBounds::bounded(-2, 4),
-        VarBounds::bounded(-2, 4),
-        VarBounds::bounded(-2, 4),
-    ];
-    let cvp = ClosestVectorProblem::new(basis, target, bounds);
-
-    // x=(1,1,1) -> Bx=(3,3,2), distance=1.0
-    // config offset: x_i - lower = 1 - (-2) = 3
-    let config_111 = vec![3, 3, 3]; // maps to x=(1,1,1)
-    let result = Problem::evaluate(&cvp, &config_111);
-    assert_eq!(result, Min(Some(1.0)));
-}
-
-#[test]
-fn test_cvp_dims() {
-    let basis = vec![vec![1, 0], vec![0, 1]];
-    let target = vec![0.5, 0.5];
-    let bounds = vec![VarBounds::bounded(-1, 3), VarBounds::bounded(0, 5)];
-    let cvp = ClosestVectorProblem::new(basis, target, bounds);
-    assert_eq!(cvp.dims(), vec![5, 6]); // (-1..3)=5 values, (0..5)=6 values
-}
-
-#[test]
-fn test_cvp_num_encoding_bits_uses_var_bound_ranges() {
-    let basis = vec![vec![1, 0, 0], vec![0, 1, 0], vec![0, 0, 1]];
-    let target = vec![0.0, 0.0, 0.0];
-    let bounds = vec![
-        VarBounds::bounded(-2, 4),
-        VarBounds::bounded(0, 5),
-        VarBounds::bounded(3, 3),
-    ];
-    let cvp = ClosestVectorProblem::new(basis, target, bounds);
+fn test_cvp_constructs_integer_and_real_targets() {
+    let integer =
+        ClosestVectorProblem::new(vec![vec![2, 0, 0], vec![1, 2, 0]], vec![3_i64, 3, 1]).unwrap();
+    assert_eq!(integer.num_basis_vectors(), 2);
+    assert_eq!(integer.ambient_dimension(), 3);
+    assert_eq!(integer.target(), &[3, 3, 1]);
+    assert_eq!(
+        ClosestVectorProblem::<i64>::variant(),
+        vec![("target", "i64")]
+    );
 
-    assert_eq!(cvp.num_encoding_bits(), 6);
+    let real = ClosestVectorProblem::new(vec![vec![2, 0, 0], vec![1, 2, 0]], vec![2.5, 1.25, -0.5])
+        .unwrap();
+    assert_eq!(real.target(), &[2.5, 1.25, -0.5]);
+    assert_eq!(
+        ClosestVectorProblem::<f64>::variant(),
+        vec![("target", "f64")]
+    );
 }
 
 #[test]
-fn test_var_bounds_exact_encoding_weights_cap_non_power_of_two_ranges() {
-    let weights = VarBounds::bounded(0, 5).exact_encoding_weights();
-    let represented_offsets: std::collections::BTreeSet<i64> = (0..(1usize << weights.len()))
-        .map(|mask| {
-            weights
-                .iter()
-                .enumerate()
-                .filter(|(bit, _)| ((mask >> bit) & 1) == 1)
-                .map(|(_, &weight)| weight)
-                .sum()
-        })
-        .collect();
-
-    assert_eq!(weights, vec![1, 2, 2]);
-    assert_eq!(represented_offsets, (0..=5).collect());
-    assert!(VarBounds::bounded(4, 4).exact_encoding_weights().is_empty());
+fn test_cvp_evaluates_without_coefficient_bounds() {
+    let problem =
+        ClosestVectorProblem::new(vec![vec![2, 0, 0], vec![1, 2, 0]], vec![3_i64, 3, 1]).unwrap();
+    assert_eq!(
+        problem.evaluate(&vec![1, 1]).unwrap(),
+        Min(Some(2.0_f64.sqrt()))
+    );
+    assert!(problem.evaluate(&vec![11, -12]).unwrap().0.is_some());
+    assert!(matches!(
+        problem.evaluate(&vec![1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
-fn test_cvp_brute_force() {
-    // b1=(2,0,0), b2=(1,2,0), b3=(0,1,2), target=(3,3,3)
-    // Optimal: x=(1,1,1), Bx=(3,3,2), distance=1.0
-    let basis = vec![vec![2, 0, 0], vec![1, 2, 0], vec![0, 1, 2]];
-    let target = vec![3.0, 3.0, 3.0];
-    let bounds = vec![
-        VarBounds::bounded(-1, 3),
-        VarBounds::bounded(-1, 3),
-        VarBounds::bounded(-1, 3),
-    ];
-    let cvp = ClosestVectorProblem::new(basis, target, bounds);
-
-    let solver = BruteForce::new();
-    let solution = solver.find_witness(&cvp).expect("should find a solution");
-    let values: Vec<i64> = solution
-        .iter()
-        .enumerate()
-        .map(|(i, &c)| cvp.bounds()[i].lower.unwrap() + c as i64)
-        .collect();
-    assert_eq!(values, vec![1, 1, 1]);
-    assert_eq!(Problem::evaluate(&cvp, &solution), Min(Some(1.0)));
+fn test_cvp_rejects_invalid_basis() {
+    assert!(ClosestVectorProblem::new(vec![vec![1_i64]], vec![0_i64, 0]).is_err());
+    assert!(
+        ClosestVectorProblem::new(vec![vec![1_i64, 0], vec![2_i64, 0]], vec![0_i64, 0],).is_err()
+    );
+    assert!(ClosestVectorProblem::new(vec![vec![1_i64], vec![2_i64]], vec![0_i64],).is_err());
 }
 
 #[test]
-fn test_cvp_serialization() {
-    let basis = vec![vec![2, 0, 0], vec![1, 2, 0], vec![0, 1, 2]];
-    let target = vec![3.0, 3.0, 3.0];
-    let bounds = vec![
-        VarBounds::bounded(-2, 4),
-        VarBounds::bounded(-2, 4),
-        VarBounds::bounded(-2, 4),
-    ];
-    let cvp = ClosestVectorProblem::new(basis, target, bounds);
-
-    let json = serde_json::to_string(&cvp).expect("serialize");
-    let cvp2: ClosestVectorProblem<i32> = serde_json::from_str(&json).expect("deserialize");
-    assert_eq!(cvp2.num_basis_vectors(), 3);
-    assert_eq!(cvp2.ambient_dimension(), 3);
-    // Verify functional equivalence after round-trip
-    let config = vec![3, 3, 3];
-    assert_eq!(
-        Problem::evaluate(&cvp, &config),
-        Problem::evaluate(&cvp2, &config)
-    );
+fn test_cvp_reports_rank_arithmetic_overflow() {
+    let error =
+        ClosestVectorProblem::new(vec![vec![i64::MAX, 1], vec![1, i64::MAX]], vec![0_i64, 0])
+            .unwrap_err();
+    assert!(matches!(error, ConstructionError::IntegerOverflow(_)));
 }
 
 #[test]
-fn test_cvp_f64_basis() {
-    // Non-integer basis to exercise the f64 variant
-    let basis: Vec<Vec<f64>> = vec![vec![1.5, 0.0], vec![0.0, 2.0]];
-    let target = vec![1.0, 1.0];
-    let bounds = vec![VarBounds::bounded(-2, 2), VarBounds::bounded(-2, 2)];
-    let cvp = ClosestVectorProblem::new(basis, target, bounds);
-
-    let solver = BruteForce::new();
-    let solution = solver.find_witness(&cvp).expect("should find a solution");
-    let values: Vec<i64> = solution
-        .iter()
-        .enumerate()
-        .map(|(i, &c)| cvp.bounds()[i].lower.unwrap() + c as i64)
-        .collect();
-    // x=(1,1): Bx=(1.5, 2.0), dist=sqrt(0.25+1.0)=sqrt(1.25)≈1.118
-    // x=(1,0): Bx=(1.5, 0.0), dist=sqrt(0.25+1.0)=sqrt(1.25)≈1.118
-    // x=(0,1): Bx=(0.0, 2.0), dist=sqrt(1.0+1.0)=sqrt(2.0)≈1.414
-    // x=(0,0): Bx=(0.0, 0.0), dist=sqrt(1.0+1.0)=sqrt(2.0)≈1.414
-    // Both (1,0) and (1,1) tie at sqrt(1.25); brute force returns first found
-    assert!(values == vec![1, 0] || values == vec![1, 1]);
+fn test_cvp_rejects_non_finite_real_target() {
+    assert!(matches!(
+        ClosestVectorProblem::new(vec![vec![1_i64]], vec![f64::NAN]),
+        Err(ConstructionError::NonFiniteFloat(_))
+    ));
+    assert!(matches!(
+        ClosestVectorProblem::new(vec![vec![1_i64]], vec![f64::INFINITY]),
+        Err(ConstructionError::NonFiniteFloat(_))
+    ));
 }
 
 #[test]
-fn test_cvp_2d_identity() {
-    // Identity basis in 2D, target=(0.3, 0.7)
-    // Closest: x=(0,1), Bx=(0,1), distance=sqrt(0.09+0.09)=0.3*sqrt(2)
-    let basis = vec![vec![1, 0], vec![0, 1]];
-    let target = vec![0.3, 0.7];
-    let bounds = vec![VarBounds::bounded(-2, 2), VarBounds::bounded(-2, 2)];
-    let cvp = ClosestVectorProblem::new(basis, target, bounds);
-
-    let solver = BruteForce::new();
-    let solution = solver.find_witness(&cvp).expect("should find a solution");
-    let values: Vec<i64> = solution
-        .iter()
-        .enumerate()
-        .map(|(i, &c)| cvp.bounds()[i].lower.unwrap() + c as i64)
-        .collect();
-    assert_eq!(values, vec![0, 1]);
+fn test_cvp_reports_exact_to_float_boundary() {
+    let problem = ClosestVectorProblem::new(
+        vec![vec![crate::types::MAX_EXACT_F64_INTEGER + 1]],
+        vec![0_i64],
+    )
+    .unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![1]),
+        Err(crate::traits::EvaluationError::InexactFloatConversion(_))
+    ));
 }
 
 #[test]
-fn test_cvp_evaluate_exact_solution() {
-    // Target is exactly a lattice point: t = (2, 2), basis = identity
-    let basis = vec![vec![1, 0], vec![0, 1]];
-    let target = vec![2.0, 2.0];
-    let bounds = vec![VarBounds::bounded(0, 4), VarBounds::bounded(0, 4)];
-    let cvp = ClosestVectorProblem::new(basis, target, bounds);
-
-    // x=(2,2), Bx=(2,2), distance=0
-    let config = vec![2, 2]; // offset from lower=0
-    let result = Problem::evaluate(&cvp, &config);
-    assert_eq!(result, Min(Some(0.0)));
+fn test_cvp_serialization_round_trips_both_targets() {
+    let integer = ClosestVectorProblem::new(vec![vec![1_i64]], vec![2_i64]).unwrap();
+    let json = serde_json::to_string(&integer).unwrap();
+    assert!(!json.contains("bounds"));
+    let decoded: ClosestVectorProblem<i64> = serde_json::from_str(&json).unwrap();
+    assert_eq!(decoded.basis(), integer.basis());
+    assert_eq!(decoded.target(), integer.target());
+
+    let real = ClosestVectorProblem::new(vec![vec![1_i64]], vec![2.5]).unwrap();
+    let json = serde_json::to_string(&real).unwrap();
+    let decoded: ClosestVectorProblem<f64> = serde_json::from_str(&json).unwrap();
+    assert_eq!(decoded.target(), real.target());
 }
 
 #[test]
-#[should_panic(expected = "bounds length must match")]
-fn test_cvp_mismatched_bounds() {
-    let basis = vec![vec![1, 0], vec![0, 1]];
-    let target = vec![0.5, 0.5];
-    let bounds = vec![VarBounds::bounded(0, 1)]; // only 1 bound for 2 vars
-    ClosestVectorProblem::new(basis, target, bounds);
+fn test_cvp_create_specs_have_no_bounds() {
+    let integer = ClosestVectorProblem::<i64>::try_from(ClosestVectorProblemI64CreateSpec {
+        basis: vec![vec![1]],
+        target: vec![2],
+    })
+    .unwrap();
+    assert_eq!(integer.target(), &[2]);
+
+    let real = ClosestVectorProblem::<f64>::try_from(ClosestVectorProblemF64CreateSpec {
+        basis: vec![vec![1]],
+        target: vec![2.5],
+    })
+    .unwrap();
+    assert_eq!(real.target(), &[2.5]);
 }
 
 #[test]
-#[should_panic(expected = "basis vector")]
-fn test_cvp_inconsistent_dimensions() {
-    let basis = vec![vec![1, 0], vec![0]]; // second vector has wrong dim
-    let target = vec![0.5, 0.5];
-    let bounds = vec![VarBounds::bounded(0, 1), VarBounds::bounded(0, 1)];
-    ClosestVectorProblem::new(basis, target, bounds);
+fn test_cvp_registers_both_target_variants() {
+    let mut variants = crate::registry::variant_entries()
+        .into_iter()
+        .filter(|entry| entry.name == ClosestVectorProblem::<i64>::NAME)
+        .map(|entry| entry.variant_map())
+        .collect::<Vec<_>>();
+    variants.sort();
+    assert_eq!(
+        variants,
+        vec![
+            std::collections::BTreeMap::from([("target".into(), "f64".into())]),
+            std::collections::BTreeMap::from([("target".into(), "i64".into())]),
+        ]
+    );
 }
 
 #[test]
-fn test_cvp_paper_example() {
-    // Paper: basis (2,0),(1,2), target (2.8,1.5), closest (3,2) at x=(1,1)
-    let basis = vec![vec![2, 0], vec![1, 2]];
-    let target = vec![2.8, 1.5];
-    let bounds = vec![VarBounds::bounded(-2, 4), VarBounds::bounded(-2, 4)];
-    let cvp = ClosestVectorProblem::new(basis, target, bounds);
-
-    // x=(1,1): Bx = 2*1+1*1=3, 0*1+2*1=2 -> point (3,2)
-    // distance = sqrt((2.8-3)^2 + (1.5-2)^2) = sqrt(0.04+0.25) = sqrt(0.29)
-    // config offset: x_i - lower = 1 - (-2) = 3
-    let config = vec![3, 3]; // maps to x=(1,1)
-    let result = Problem::evaluate(&cvp, &config);
-    assert!(result.is_valid());
-    let dist = result.unwrap();
-    assert!((dist - 0.29_f64.sqrt()).abs() < 1e-10);
-
-    let solver = BruteForce::new();
-    let best = solver.find_witness(&cvp).unwrap();
-    let best_dist = Problem::evaluate(&cvp, &best).unwrap();
-    assert!((best_dist - 0.29_f64.sqrt()).abs() < 1e-10);
+fn test_cvp_empty_basis_is_valid() {
+    let problem = ClosestVectorProblem::new(Vec::new(), vec![3_i64, 4]).unwrap();
+    assert_eq!(problem.evaluate(&Vec::new()).unwrap(), Min(Some(5.0)));
 }
diff --git a/src/unit_tests/models/algebraic/consecutive_block_minimization.rs b/src/unit_tests/models/algebraic/consecutive_block_minimization.rs
index 7d66b6459..92ae4a385 100644
--- a/src/unit_tests/models/algebraic/consecutive_block_minimization.rs
+++ b/src/unit_tests/models/algebraic/consecutive_block_minimization.rs
@@ -1,7 +1,22 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
+#[test]
+fn test_consecutive_block_create_spec_uses_bound_k_input() {
+    assert_eq!(
+        ConsecutiveBlockMinimizationCreateSpec::FIELDS[1].name,
+        "bound_k"
+    );
+    let problem = ConsecutiveBlockMinimization::try_from(ConsecutiveBlockMinimizationCreateSpec {
+        matrix: vec![vec![true, false]],
+        bound_k: 1,
+    })
+    .unwrap();
+    assert_eq!(problem.bound(), 1);
+}
+
 #[test]
 fn test_consecutive_block_minimization_basic() {
     let problem = ConsecutiveBlockMinimization::new(
@@ -12,7 +27,7 @@ fn test_consecutive_block_minimization_basic() {
     assert_eq!(problem.num_cols(), 3);
     assert_eq!(problem.bound(), 2);
     assert_eq!(problem.num_variables(), 3);
-    assert_eq!(problem.dims(), vec![3; 3]);
+    assert_eq!(problem.dimensions(), vec![3; 3]);
 }
 
 #[test]
@@ -28,13 +43,13 @@ fn test_consecutive_block_minimization_evaluate() {
         vec![vec![true, false, true], vec![false, true, true]],
         2,
     );
-    assert!(problem.evaluate(&[0, 2, 1]));
+    assert!(problem.evaluate(&vec![0, 2, 1]).unwrap());
 
     // Identity permutation [0, 1, 2]:
     //   [1, 0, 1]  -> 2 blocks
     //   [0, 1, 1]  -> 1 block
     // Total = 3 blocks, bound = 2 => does not satisfy
-    assert!(!problem.evaluate(&[0, 1, 2]));
+    assert!(!problem.evaluate(&vec![0, 1, 2]).unwrap());
 }
 
 #[test]
@@ -43,14 +58,20 @@ fn test_consecutive_block_minimization_count_blocks() {
         vec![vec![true, false, true], vec![false, true, true]],
         2,
     );
-    assert_eq!(problem.count_consecutive_blocks(&[0, 2, 1]), Some(2));
-    assert_eq!(problem.count_consecutive_blocks(&[0, 1, 2]), Some(3));
+    assert_eq!(
+        problem.count_consecutive_blocks(&[0, 2, 1]).unwrap(),
+        Some(2)
+    );
+    assert_eq!(
+        problem.count_consecutive_blocks(&[0, 1, 2]).unwrap(),
+        Some(3)
+    );
     // Invalid: duplicate column
-    assert_eq!(problem.count_consecutive_blocks(&[0, 0, 1]), None);
+    assert_eq!(problem.count_consecutive_blocks(&[0, 0, 1]).unwrap(), None);
     // Invalid: wrong length
-    assert_eq!(problem.count_consecutive_blocks(&[0, 1]), None);
+    assert_eq!(problem.count_consecutive_blocks(&[0, 1]).unwrap(), None);
     // Invalid: out of range
-    assert_eq!(problem.count_consecutive_blocks(&[0, 1, 5]), None);
+    assert_eq!(problem.count_consecutive_blocks(&[0, 1, 5]).unwrap(), None);
 }
 
 #[test]
@@ -60,13 +81,13 @@ fn test_consecutive_block_minimization_brute_force() {
         2,
     );
     let solver = BruteForce::new();
-    let mut solutions = solver.find_all_witnesses(&problem);
+    let mut solutions = solver.find_all_witnesses(&problem).unwrap();
     solutions.sort();
     let mut expected = vec![vec![0, 2, 1], vec![1, 2, 0]];
     expected.sort();
     assert_eq!(solutions, expected);
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -75,8 +96,11 @@ fn test_consecutive_block_minimization_empty_matrix() {
     let problem = ConsecutiveBlockMinimization::new(vec![], 0);
     assert_eq!(problem.num_rows(), 0);
     assert_eq!(problem.num_cols(), 0);
-    assert!(problem.evaluate(&[]));
-    assert!(!problem.evaluate(&[0]));
+    assert!(problem.evaluate(&vec![]).unwrap());
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -111,7 +135,10 @@ fn test_consecutive_block_minimization_deserialization_rejects_ragged_matrix() {
 fn test_consecutive_block_minimization_invalid_permutation() {
     let problem = ConsecutiveBlockMinimization::new(vec![vec![true, false], vec![false, true]], 2);
     // Not a valid permutation => evaluate returns false
-    assert!(!problem.evaluate(&[0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0]).unwrap());
     // Wrong length
-    assert!(!problem.evaluate(&[0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
diff --git a/src/unit_tests/models/algebraic/consecutive_ones_matrix_augmentation.rs b/src/unit_tests/models/algebraic/consecutive_ones_matrix_augmentation.rs
index 16fc52b93..b3cce7057 100644
--- a/src/unit_tests/models/algebraic/consecutive_ones_matrix_augmentation.rs
+++ b/src/unit_tests/models/algebraic/consecutive_ones_matrix_augmentation.rs
@@ -1,4 +1,20 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_negative_bound() {
+    assert_eq!(
+        ConsecutiveOnesMatrixAugmentationCreateSpec::FIELDS[1].name,
+        "bound"
+    );
+    assert!(ConsecutiveOnesMatrixAugmentation::try_from(
+        ConsecutiveOnesMatrixAugmentationCreateSpec {
+            matrix: vec![vec![true]],
+            bound: -1
+        }
+    )
+    .is_err());
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
@@ -28,7 +44,7 @@ fn test_consecutive_ones_matrix_augmentation_basic() {
     assert_eq!(problem.num_cols(), 5);
     assert_eq!(problem.bound(), 2);
     assert_eq!(problem.num_variables(), 5);
-    assert_eq!(problem.dims(), vec![5; 5]);
+    assert_eq!(problem.dimensions(), vec![5; 5]);
     assert_eq!(
         <ConsecutiveOnesMatrixAugmentation as Problem>::NAME,
         "ConsecutiveOnesMatrixAugmentation"
@@ -43,7 +59,7 @@ fn test_consecutive_ones_matrix_augmentation_basic() {
 fn test_consecutive_ones_matrix_augmentation_yes_instance() {
     let problem = ConsecutiveOnesMatrixAugmentation::new(issue_yes_matrix(), 2);
 
-    assert!(problem.evaluate(&[0, 1, 4, 2, 3]));
+    assert!(problem.evaluate(&vec![0, 1, 4, 2, 3]).unwrap());
 }
 
 #[test]
@@ -51,16 +67,22 @@ fn test_consecutive_ones_matrix_augmentation_no_instance() {
     let problem = ConsecutiveOnesMatrixAugmentation::new(issue_no_matrix(), 0);
 
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_consecutive_ones_matrix_augmentation_invalid_permutations() {
     let problem = ConsecutiveOnesMatrixAugmentation::new(issue_yes_matrix(), 2);
 
-    assert!(!problem.evaluate(&[0, 1, 4, 2]));
-    assert!(!problem.evaluate(&[0, 1, 4, 2, 5]));
-    assert!(!problem.evaluate(&[0, 1, 4, 2, 2]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 4, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 4, 2, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(!problem.evaluate(&vec![0, 1, 4, 2, 2]).unwrap());
 }
 
 #[test]
@@ -121,9 +143,9 @@ fn test_consecutive_ones_matrix_augmentation_all_zero_row() {
     );
 
     // Permutation [0, 1, 2] — row 0 has gap, row 1 has no 1s (0 cost), row 2 is fine
-    assert!(!problem.evaluate(&[0, 1, 2]));
+    assert!(!problem.evaluate(&vec![0, 1, 2]).unwrap());
     // Permutation [0, 2, 1] — row 0: [1,1,0] consecutive, row 1: all zeros (0 cost), row 2: [0,0,1] consecutive
-    assert!(problem.evaluate(&[0, 2, 1]));
+    assert!(problem.evaluate(&vec![0, 2, 1]).unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/algebraic/consecutive_ones_submatrix.rs b/src/unit_tests/models/algebraic/consecutive_ones_submatrix.rs
index e1efe8ca5..bc20d02df 100644
--- a/src/unit_tests/models/algebraic/consecutive_ones_submatrix.rs
+++ b/src/unit_tests/models/algebraic/consecutive_ones_submatrix.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 /// Tucker matrix (3×4) — the classic C1P obstruction.
@@ -17,7 +18,7 @@ fn test_consecutive_ones_submatrix_basic() {
     assert_eq!(problem.num_rows(), 3);
     assert_eq!(problem.num_cols(), 4);
     assert_eq!(problem.bound(), 3);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(
         <ConsecutiveOnesSubmatrix as Problem>::NAME,
         "ConsecutiveOnesSubmatrix"
@@ -33,36 +34,46 @@ fn test_consecutive_ones_submatrix_evaluate_satisfying() {
     //   r1: 1, 1, 1 → consecutive
     //   r2: 0, 1, 1 → consecutive
     //   r3: 1, 0, 0 → consecutive
-    assert!(problem.evaluate(&[1, 1, 0, 1]));
+    assert!(problem.evaluate(&vec![true, true, false, true]).unwrap());
 }
 
 #[test]
 fn test_consecutive_ones_submatrix_evaluate_unsatisfying() {
     let problem = ConsecutiveOnesSubmatrix::new(tucker_matrix(), 4);
     // Full Tucker matrix does NOT have C1P
-    assert!(!problem.evaluate(&[1, 1, 1, 1]));
+    assert!(!problem.evaluate(&vec![true, true, true, true]).unwrap());
 }
 
 #[test]
 fn test_consecutive_ones_submatrix_evaluate_wrong_count() {
     let problem = ConsecutiveOnesSubmatrix::new(tucker_matrix(), 3);
     // Selecting 2 columns instead of 3 → false
-    assert!(!problem.evaluate(&[1, 1, 0, 0]));
+    assert!(!problem.evaluate(&vec![true, true, false, false]).unwrap());
     // Selecting 4 columns instead of 3 → false
-    assert!(!problem.evaluate(&[1, 1, 1, 1]));
+    assert!(!problem.evaluate(&vec![true, true, true, true]).unwrap());
 }
 
 #[test]
 fn test_consecutive_ones_submatrix_evaluate_wrong_config_length() {
     let problem = ConsecutiveOnesSubmatrix::new(tucker_matrix(), 3);
-    assert!(!problem.evaluate(&[1, 0]));
-    assert!(!problem.evaluate(&[1, 0, 0, 0, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_consecutive_ones_submatrix_evaluate_invalid_variable_value() {
     let problem = ConsecutiveOnesSubmatrix::new(tucker_matrix(), 3);
-    assert!(!problem.evaluate(&[2, 0, 0, 1]));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, false, false, true])
+    )
+    .is_err());
 }
 
 #[test]
@@ -70,19 +81,20 @@ fn test_consecutive_ones_submatrix_brute_force() {
     let problem = ConsecutiveOnesSubmatrix::new(tucker_matrix(), 3);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_consecutive_ones_submatrix_brute_force_all() {
     let problem = ConsecutiveOnesSubmatrix::new(tucker_matrix(), 3);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -91,7 +103,7 @@ fn test_consecutive_ones_submatrix_unsatisfiable() {
     // Tucker matrix with K=4: no permutation of all 4 columns gives C1P
     let problem = ConsecutiveOnesSubmatrix::new(tucker_matrix(), 4);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -104,8 +116,11 @@ fn test_consecutive_ones_submatrix_trivial_c1p() {
     ];
     let problem = ConsecutiveOnesSubmatrix::new(matrix, 3);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).expect("full matrix has C1P");
-    assert!(problem.evaluate(&solution));
+    let solution = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("full matrix has C1P");
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
@@ -114,7 +129,7 @@ fn test_consecutive_ones_submatrix_single_column() {
     let matrix = vec![vec![true, false, true], vec![false, true, false]];
     let problem = ConsecutiveOnesSubmatrix::new(matrix, 1);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 3); // each column works individually
 }
 
@@ -128,10 +143,10 @@ fn test_consecutive_ones_submatrix_empty_rows() {
     ];
     let problem = ConsecutiveOnesSubmatrix::new(matrix, 2);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -161,13 +176,13 @@ fn test_consecutive_ones_submatrix_paper_example() {
     // Tucker matrix with K=3: same instance as paper
     let problem = ConsecutiveOnesSubmatrix::new(tucker_matrix(), 3);
     // Verify that selecting cols {0,1,3} is satisfying
-    assert!(problem.evaluate(&[1, 1, 0, 1]));
+    assert!(problem.evaluate(&vec![true, true, false, true]).unwrap());
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // All solutions must be valid
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
     // Exactly 2 of the C(4,3)=4 subsets have C1P: {0,1,3} and {0,2,3}
     // ({0,1,2} and {1,2,3} fail due to Tucker obstructions in submatrix)
@@ -179,8 +194,8 @@ fn test_consecutive_ones_submatrix_k_zero() {
     // K=0: empty selection always satisfies (vacuously true)
     let matrix = vec![vec![true, false], vec![false, true]];
     let problem = ConsecutiveOnesSubmatrix::new(matrix, 0);
-    assert!(problem.evaluate(&[0, 0])); // select nothing
-    assert!(!problem.evaluate(&[1, 0])); // selected 1, need 0
+    assert!(problem.evaluate(&vec![false, false]).unwrap()); // select nothing
+    assert!(!problem.evaluate(&vec![true, false]).unwrap()); // selected 1, need 0
 }
 
 #[test]
@@ -190,8 +205,8 @@ fn test_consecutive_ones_submatrix_empty_matrix_vacuous_case() {
     assert!(problem.matrix().is_empty());
     assert_eq!(problem.num_rows(), 0);
     assert_eq!(problem.num_cols(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/algebraic/equilibrium_point.rs b/src/unit_tests/models/algebraic/equilibrium_point.rs
index ccccf3f75..dd30d1d37 100644
--- a/src/unit_tests/models/algebraic/equilibrium_point.rs
+++ b/src/unit_tests/models/algebraic/equilibrium_point.rs
@@ -1,5 +1,6 @@
 use crate::models::algebraic::EquilibriumPoint;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -50,7 +51,7 @@ fn test_equilibrium_point_creation_and_accessors() {
     assert_eq!(p.range_sets()[0], vec![0, 1]);
     assert_eq!(p.range_sets()[1], vec![0, 1]);
     assert_eq!(p.range_sets()[2], vec![0, 1]);
-    assert_eq!(p.dims(), vec![2, 2, 2]);
+    assert_eq!(p.dimensions(), vec![2, 2, 2]);
     assert_eq!(p.num_variables(), 3);
     assert_eq!(<EquilibriumPoint as Problem>::NAME, "EquilibriumPoint");
     assert_eq!(<EquilibriumPoint as Problem>::variant(), vec![]);
@@ -60,7 +61,7 @@ fn test_equilibrium_point_creation_and_accessors() {
 fn test_equilibrium_point_evaluate_canonical_equilibrium() {
     let p = canonical_problem();
     // config [0,1,0] → (0,1,0) is the known equilibrium.
-    assert_eq!(p.evaluate(&[0, 1, 0]), Or(true));
+    assert_eq!(p.evaluate(&vec![0, 1, 0]).unwrap(), Or(true));
 }
 
 #[test]
@@ -73,26 +74,44 @@ fn test_equilibrium_point_evaluate_non_equilibria() {
     // At (1,1,1): F2(1,1,1)=(1-1)*1=0. Dev player2 to 0: F2(1,0,1)=(1-1)*0=0 — no improvement.
     //             But dev player1 (player 1) only affects F1! F1(1,1,1)=1*1*1=1, dev to 0: F1(0,1,1)=0*1*1=0 — no improvement for player1.
     // F3(1,1,1)=1*(1-1)=0. Dev player3 to 0: F3(1,1,0)=1*(1-0)=1 > 0 → player 3 can improve! NOT equilibrium.
-    assert_eq!(p.evaluate(&[1, 1, 1]), Or(false));
+    assert_eq!(p.evaluate(&vec![1, 1, 1]).unwrap(), Or(false));
 
     // (0,0,0): F2(0,0,0)=(1-0)*0=0. Dev player2 to 1: F2(0,1,0)=(1-0)*1=1 > 0 → NOT equilibrium.
-    assert_eq!(p.evaluate(&[0, 0, 0]), Or(false));
+    assert_eq!(p.evaluate(&vec![0, 0, 0]).unwrap(), Or(false));
+}
+
+#[test]
+fn test_equilibrium_point_evaluate_reports_payoff_overflow() {
+    let problem = EquilibriumPoint::new(vec![vec![vec![0, i64::MAX]]], vec![vec![2]]).unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![2]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
 }
 
 #[test]
 fn test_equilibrium_point_invalid_config_lengths() {
     let p = canonical_problem();
-    assert_eq!(p.evaluate(&[]), Or(false));
-    assert_eq!(p.evaluate(&[0, 1]), Or(false));
-    assert_eq!(p.evaluate(&[0, 1, 0, 0]), Or(false));
+    assert!(matches!(
+        p.evaluate(&vec![]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        p.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        p.evaluate(&vec![0, 1, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_equilibrium_point_brute_force_finds_witness() {
     let solver = BruteForce::new();
     let p = canonical_problem();
-    let witness = solver.find_witness(&p).unwrap();
-    assert_eq!(p.evaluate(&witness), Or(true));
+    let witness = solver.solve(&p).unwrap().unwrap();
+    assert_eq!(p.evaluate(&witness).unwrap(), Or(true));
 }
 
 #[test]
@@ -100,22 +119,22 @@ fn test_equilibrium_point_coordination_game() {
     let p = coordination_problem();
     // (0,0): F1(0,0)=0*0=0. Dev p1 to 1: F1(1,0)=1*0=0 — no improvement. Dev p2 to 1: F2(0,1)=0*1=0 — no improvement.
     // So (0,0) is an equilibrium.
-    assert_eq!(p.evaluate(&[0, 0]), Or(true));
+    assert_eq!(p.evaluate(&vec![0, 0]).unwrap(), Or(true));
     // (1,1): F1(1,1)=1. Dev p1 to 0: F1(0,1)=0 < 1 — no improvement. Dev p2 to 0: F2(1,0)=0 < 1 — no improvement.
     // (1,1) is also an equilibrium.
-    assert_eq!(p.evaluate(&[1, 1]), Or(true));
+    assert_eq!(p.evaluate(&vec![1, 1]).unwrap(), Or(true));
     // (0,1): F1(0,1)=0*1=0. Dev p1 to 1: F1(1,1)=1 > 0 → NOT equilibrium.
-    assert_eq!(p.evaluate(&[0, 1]), Or(false));
+    assert_eq!(p.evaluate(&vec![0, 1]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_equilibrium_point_trivial_constant_payoffs() {
     let p = trivial_equilibrium_problem();
     // Every config is an equilibrium since payoff is always 1.
-    assert_eq!(p.evaluate(&[0, 0]), Or(true));
-    assert_eq!(p.evaluate(&[0, 1]), Or(true));
-    assert_eq!(p.evaluate(&[1, 0]), Or(true));
-    assert_eq!(p.evaluate(&[1, 1]), Or(true));
+    assert_eq!(p.evaluate(&vec![0, 0]).unwrap(), Or(true));
+    assert_eq!(p.evaluate(&vec![0, 1]).unwrap(), Or(true));
+    assert_eq!(p.evaluate(&vec![1, 0]).unwrap(), Or(true));
+    assert_eq!(p.evaluate(&vec![1, 1]).unwrap(), Or(true));
 }
 
 #[test]
@@ -159,11 +178,11 @@ fn test_equilibrium_point_deserialization_rejects_invalid() {
 fn test_equilibrium_point_paper_example() {
     // Canonical example: config [0,1,0] is the equilibrium.
     let p = canonical_problem();
-    assert_eq!(p.evaluate(&[0, 1, 0]), Or(true));
+    assert_eq!(p.evaluate(&vec![0, 1, 0]).unwrap(), Or(true));
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&p).unwrap();
-    assert_eq!(p.evaluate(&witness), Or(true));
+    let witness = solver.solve(&p).unwrap().unwrap();
+    assert_eq!(p.evaluate(&witness).unwrap(), Or(true));
 }
 
 #[test]
@@ -184,10 +203,10 @@ fn test_equilibrium_point_validation_panics() {
 fn test_equilibrium_point_single_player() {
     // 1-player game: F1 = x1. M1 = {0, 2}. Equilibrium when player picks max.
     // F1(0) = 0. Deviation to 2: F1(2) = 2 > 0 → config [0] NOT equilibrium.
-    // F1(2) = 2. No deviation improves. config [1] IS equilibrium.
+    // F1(2) = 2. No deviation improves. config [2] IS equilibrium.
     let polynomials = vec![vec![vec![0, 1]]];
     let range_sets = vec![vec![0, 2]];
     let p = EquilibriumPoint::new(polynomials, range_sets).unwrap();
-    assert_eq!(p.evaluate(&[0]), Or(false));
-    assert_eq!(p.evaluate(&[1]), Or(true));
+    assert_eq!(p.evaluate(&vec![0]).unwrap(), Or(false));
+    assert_eq!(p.evaluate(&vec![2]).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/models/algebraic/feasible_basis_extension.rs b/src/unit_tests/models/algebraic/feasible_basis_extension.rs
index dc7136e51..489d91788 100644
--- a/src/unit_tests/models/algebraic/feasible_basis_extension.rs
+++ b/src/unit_tests/models/algebraic/feasible_basis_extension.rs
@@ -1,4 +1,24 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_validates_matrix_shape() {
+    let problem = FeasibleBasisExtension::try_from(FeasibleBasisExtensionCreateSpec {
+        matrix: vec![vec![1, 0]],
+        rhs: vec![1],
+        required_columns: vec![],
+    })
+    .unwrap();
+    assert_eq!(problem.num_columns(), 2);
+    assert!(
+        FeasibleBasisExtension::try_from(FeasibleBasisExtensionCreateSpec {
+            matrix: vec![vec![1], vec![1]],
+            rhs: vec![1, 1],
+            required_columns: vec![]
+        })
+        .is_err()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
@@ -21,7 +41,7 @@ fn test_feasible_basis_extension_creation() {
     assert_eq!(problem.num_rows(), 3);
     assert_eq!(problem.num_columns(), 6);
     assert_eq!(problem.num_required(), 2);
-    assert_eq!(problem.dims(), vec![2; 4]); // 6 - 2 = 4 free columns
+    assert_eq!(problem.dimensions(), vec![2; 4]); // 6 - 2 = 4 free columns
     assert_eq!(
         <FeasibleBasisExtension as Problem>::NAME,
         "FeasibleBasisExtension"
@@ -35,7 +55,7 @@ fn test_feasible_basis_extension_evaluate_satisfying() {
     // Free columns are [2, 3, 4, 5]. Select col 2 (index 0 in free list).
     // B = {0, 1, 2}. A_B = I_3. x = (7, 5, 3) but actually A_B = [[1,0,1],[0,1,0],[0,0,1]]
     // A_B^{-1} a_bar: solve [[1,0,1],[0,1,0],[0,0,1]] x = [7,5,3] => x = (4, 5, 3) >= 0
-    assert!(problem.evaluate(&[1, 0, 0, 0]));
+    assert!(problem.evaluate(&vec![true, false, false, false]).unwrap());
 }
 
 #[test]
@@ -43,7 +63,7 @@ fn test_feasible_basis_extension_evaluate_satisfying_col3() {
     let problem = issue_example();
     // Select col 3 (index 1 in free list). B = {0, 1, 3}.
     // A_B = [[1,0,2],[0,1,1],[0,0,1]]. Solve: x = (1, 2, 3) >= 0
-    assert!(problem.evaluate(&[0, 1, 0, 0]));
+    assert!(problem.evaluate(&vec![false, true, false, false]).unwrap());
 }
 
 #[test]
@@ -51,7 +71,7 @@ fn test_feasible_basis_extension_evaluate_singular() {
     let problem = issue_example();
     // Select col 4 (index 2 in free list). B = {0, 1, 4}.
     // A_B = [[1,0,-1],[0,1,1],[0,0,0]] => singular
-    assert!(!problem.evaluate(&[0, 0, 1, 0]));
+    assert!(!problem.evaluate(&vec![false, false, true, false]).unwrap());
 }
 
 #[test]
@@ -59,28 +79,38 @@ fn test_feasible_basis_extension_evaluate_infeasible_negative() {
     let problem = issue_example();
     // Select col 5 (index 3 in free list). B = {0, 1, 5}.
     // A_B = [[1,0,0],[0,1,2],[0,0,1]]. Solve: x = (7, -1, 3). x_1 = -1 < 0
-    assert!(!problem.evaluate(&[0, 0, 0, 1]));
+    assert!(!problem.evaluate(&vec![false, false, false, true]).unwrap());
 }
 
 #[test]
 fn test_feasible_basis_extension_evaluate_wrong_count() {
     let problem = issue_example();
     // Need exactly 1 column selected (m - |S| = 3 - 2 = 1)
-    assert!(!problem.evaluate(&[1, 1, 0, 0])); // too many
-    assert!(!problem.evaluate(&[0, 0, 0, 0])); // too few
+    assert!(!problem.evaluate(&vec![true, true, false, false]).unwrap()); // too many
+    assert!(!problem.evaluate(&vec![false, false, false, false]).unwrap()); // too few
 }
 
 #[test]
 fn test_feasible_basis_extension_evaluate_wrong_config_length() {
     let problem = issue_example();
-    assert!(!problem.evaluate(&[1, 0])); // too short
-    assert!(!problem.evaluate(&[1, 0, 0, 0, 0])); // too long
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_feasible_basis_extension_evaluate_invalid_variable_value() {
     let problem = issue_example();
-    assert!(!problem.evaluate(&[2, 0, 0, 0]));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, false, false, false])
+    )
+    .is_err());
 }
 
 #[test]
@@ -88,20 +118,21 @@ fn test_feasible_basis_extension_brute_force() {
     let problem = issue_example();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_feasible_basis_extension_brute_force_all() {
     let problem = issue_example();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // From the issue: B={0,1,2} and B={0,1,3} are feasible, so 2 solutions
     assert_eq!(solutions.len(), 2);
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -116,7 +147,7 @@ fn test_feasible_basis_extension_unsatisfiable() {
     let problem =
         FeasibleBasisExtension::new(vec![vec![1, 1, 1], vec![1, 1, 1]], vec![1, 1], vec![]);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -145,12 +176,12 @@ fn test_feasible_basis_extension_serialization() {
 fn test_feasible_basis_extension_paper_example() {
     let problem = issue_example();
     // Verify B={0,1,2} is satisfying (config [1,0,0,0])
-    assert!(problem.evaluate(&[1, 0, 0, 0]));
+    assert!(problem.evaluate(&vec![true, false, false, false]).unwrap());
     // Verify B={0,1,3} is satisfying (config [0,1,0,0])
-    assert!(problem.evaluate(&[0, 1, 0, 0]));
+    assert!(problem.evaluate(&vec![false, true, false, false]).unwrap());
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 2);
 }
 
diff --git a/src/unit_tests/models/algebraic/ilp.rs b/src/unit_tests/models/algebraic/ilp.rs
index d993f0716..64bdc8143 100644
--- a/src/unit_tests/models/algebraic/ilp.rs
+++ b/src/unit_tests/models/algebraic/ilp.rs
@@ -1,455 +1,486 @@
 use super::*;
-use crate::solvers::BruteForce;
+use crate::solvers::{ILPSolveError, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Extremum;
 
-// ============================================================
-// Comparison tests
-// ============================================================
+fn binary_ilp(
+    num_vars: usize,
+    constraints: Vec<LinearConstraint>,
+    objective: Vec<(usize, i64)>,
+    sense: ObjectiveSense,
+) -> ILP<bool> {
+    ILP::new(num_vars, constraints, objective, sense).unwrap()
+}
 
 #[test]
-fn test_comparison_le() {
-    let cmp = Comparison::Le;
-    assert!(cmp.holds(5.0, 10.0));
-    assert!(cmp.holds(10.0, 10.0));
-    assert!(!cmp.holds(11.0, 10.0));
+fn ilp_variant_identifies_variable_domain() {
+    assert_eq!(
+        <ILP<bool> as Problem>::variant(),
+        vec![("variable", "bool"), ("coefficient", "i64")]
+    );
 }
 
 #[test]
-fn test_comparison_ge() {
-    let cmp = Comparison::Ge;
-    assert!(cmp.holds(10.0, 5.0));
-    assert!(cmp.holds(10.0, 10.0));
-    assert!(!cmp.holds(4.0, 5.0));
+fn ilp_variant_identifies_float_coefficients() {
+    assert_eq!(
+        <ILP<bool, f64> as Problem>::variant(),
+        vec![("variable", "bool"), ("coefficient", "f64")]
+    );
 }
 
 #[test]
-fn test_comparison_eq() {
-    let cmp = Comparison::Eq;
-    assert!(cmp.holds(10.0, 10.0));
-    assert!(!cmp.holds(10.0, 10.1));
-    assert!(!cmp.holds(9.9, 10.0));
-    // Test tolerance
-    assert!(cmp.holds(10.0, 10.0 + 1e-10));
+fn integer_objective_keeps_adjacent_large_values_distinct() {
+    let smaller = crate::types::MAX_EXACT_F64_INTEGER + 3;
+    let larger = smaller + 1;
+    let ilp = ILP::<bool>::new(
+        2,
+        vec![],
+        vec![(0, smaller), (1, larger)],
+        ObjectiveSense::Maximize,
+    )
+    .unwrap();
+
+    assert_eq!(ilp.evaluate_objective(&[1, 0]).unwrap(), smaller);
+    assert_eq!(ilp.evaluate_objective(&[0, 1]).unwrap(), larger);
 }
 
-// ============================================================
-// LinearConstraint tests
-// ============================================================
+#[test]
+fn float_constraints_use_float_arithmetic() {
+    let ilp = ILP::<bool, f64>::new(
+        2,
+        vec![LinearConstraint::eq(vec![(0, 0.1), (1, 0.2)], 0.3)],
+        vec![(0, 0.5)],
+        ObjectiveSense::Maximize,
+    )
+    .unwrap();
+
+    assert!(ilp.is_feasible(&[1, 1]).unwrap());
+    assert_eq!(ilp.evaluate_objective(&[1, 0]).unwrap(), 0.5);
+}
 
 #[test]
-fn test_linear_constraint_le() {
-    // x0 + 2*x1 <= 5
-    let constraint = LinearConstraint::le(vec![(0, 1.0), (1, 2.0)], 5.0);
-    assert_eq!(constraint.cmp, Comparison::Le);
-    assert_eq!(constraint.rhs, 5.0);
+fn float_ilp_rejects_non_finite_coefficients() {
+    assert!(matches!(
+        ILP::<bool, f64>::new(
+            1,
+            vec![],
+            vec![(0, f64::INFINITY)],
+            ObjectiveSense::Minimize,
+        ),
+        Err(crate::registry::ConstructionError::NonFiniteFloat(_))
+    ));
+}
 
-    // x0=1, x1=2 => 1 + 4 = 5 <= 5 (satisfied)
-    assert!(constraint.is_satisfied(&[1, 2]));
-    // x0=2, x1=2 => 2 + 4 = 6 > 5 (not satisfied)
-    assert!(!constraint.is_satisfied(&[2, 2]));
+#[test]
+fn test_linear_constraint_le() {
+    let constraint = LinearConstraint::le(vec![(0, 1), (1, 2)], 5);
+    assert_eq!(constraint.comparison(), Comparison::Le);
+    assert_eq!(constraint.rhs(), 5);
+    assert!(constraint.is_satisfied(&[1, 2]).unwrap());
+    assert!(!constraint.is_satisfied(&[2, 2]).unwrap());
 }
 
 #[test]
 fn test_linear_constraint_ge() {
-    // x0 + x1 >= 3
-    let constraint = LinearConstraint::ge(vec![(0, 1.0), (1, 1.0)], 3.0);
-    assert_eq!(constraint.cmp, Comparison::Ge);
-
-    assert!(constraint.is_satisfied(&[2, 2])); // 4 >= 3
-    assert!(constraint.is_satisfied(&[1, 2])); // 3 >= 3
-    assert!(!constraint.is_satisfied(&[1, 1])); // 2 < 3
+    let constraint = LinearConstraint::ge(vec![(0, 1), (1, 1)], 3);
+    assert_eq!(constraint.comparison(), Comparison::Ge);
+    assert!(constraint.is_satisfied(&[2, 2]).unwrap());
+    assert!(constraint.is_satisfied(&[1, 2]).unwrap());
+    assert!(!constraint.is_satisfied(&[1, 1]).unwrap());
 }
 
 #[test]
 fn test_linear_constraint_eq() {
-    // x0 + x1 == 2
-    let constraint = LinearConstraint::eq(vec![(0, 1.0), (1, 1.0)], 2.0);
-    assert_eq!(constraint.cmp, Comparison::Eq);
-
-    assert!(constraint.is_satisfied(&[1, 1])); // 2 == 2
-    assert!(!constraint.is_satisfied(&[1, 2])); // 3 != 2
-    assert!(!constraint.is_satisfied(&[0, 1])); // 1 != 2
+    let constraint = LinearConstraint::eq(vec![(0, 1), (1, 1)], 2);
+    assert_eq!(constraint.comparison(), Comparison::Eq);
+    assert!(constraint.is_satisfied(&[1, 1]).unwrap());
+    assert!(!constraint.is_satisfied(&[1, 2]).unwrap());
+    assert!(!constraint.is_satisfied(&[0, 1]).unwrap());
 }
 
 #[test]
 fn test_linear_constraint_evaluate_lhs() {
-    let constraint = LinearConstraint::le(vec![(0, 3.0), (2, -1.0)], 10.0);
-    // 3*x0 - 1*x2 with x=[2, 5, 7] => 3*2 - 1*7 = -1
-    assert!((constraint.evaluate_lhs(&[2, 5, 7]) - (-1.0)).abs() < 1e-9);
+    let constraint = LinearConstraint::le(vec![(0, 3), (2, -1)], 10);
+    assert_eq!(constraint.evaluate_lhs(&[2, 5, 7]).unwrap(), -1);
+}
+
+#[test]
+fn test_linear_constraint_rejects_short_assignment() {
+    let constraint = LinearConstraint::le(vec![(1, 1)], 1);
+    assert!(matches!(
+        constraint.evaluate_lhs(&[0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_linear_constraint_variables() {
-    let constraint = LinearConstraint::le(vec![(0, 1.0), (3, 2.0), (5, -1.0)], 10.0);
-    assert_eq!(constraint.variables(), vec![0, 3, 5]);
+    let constraint = LinearConstraint::le(vec![(0, 1), (3, 2), (5, -1)], 10);
+    assert_eq!(constraint.variables().collect::<Vec<_>>(), vec![0, 3, 5]);
 }
 
 #[test]
-fn test_linear_constraint_out_of_bounds() {
-    // Constraint references variable 5, but values only has 3 elements
-    let constraint = LinearConstraint::le(vec![(5, 1.0)], 10.0);
-    // Missing variable defaults to 0, so 0 <= 10 is satisfied
-    assert!(constraint.is_satisfied(&[1, 2, 3]));
+fn test_ilp_normalizes_exact_integer_constraint_terms() {
+    let ilp = binary_ilp(
+        2,
+        vec![LinearConstraint::le(vec![(1, 2), (0, 3), (1, -2)], 4)],
+        vec![],
+        ObjectiveSense::Minimize,
+    );
+    assert_eq!(ilp.constraints()[0].terms(), &[(0, 3)]);
 }
 
-// ============================================================
-// ObjectiveSense tests
-// ============================================================
+#[test]
+fn test_ilp_rejects_constraint_normalization_overflow() {
+    let error = ILP::<bool>::new(
+        1,
+        vec![LinearConstraint::le(vec![(0, i64::MAX), (0, 1)], 0)],
+        vec![],
+        ObjectiveSense::Minimize,
+    )
+    .unwrap_err();
+    assert!(matches!(
+        error,
+        crate::registry::ConstructionError::IntegerOverflow(_)
+    ));
+}
 
-// ============================================================
-// ILP tests
-// ============================================================
+#[test]
+fn test_linear_constraint_reports_exact_evaluation_overflow() {
+    let constraint = LinearConstraint::le(vec![(0, i64::MAX)], 0);
+    assert!(matches!(
+        constraint.evaluate_lhs(&[2]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
+}
+
+#[test]
+fn test_linear_constraint_out_of_bounds() {
+    assert!(ILP::<bool>::new(
+        3,
+        vec![LinearConstraint::le(vec![(5, 1)], 10)],
+        vec![],
+        ObjectiveSense::Minimize,
+    )
+    .is_err());
+}
 
 #[test]
 fn test_ilp_new() {
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 2.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1), (1, 2)],
         ObjectiveSense::Maximize,
     );
-    assert_eq!(ilp.num_vars, 2);
-    assert_eq!(ilp.constraints.len(), 1);
-    assert_eq!(ilp.objective.len(), 2);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.num_vars(), 2);
+    assert_eq!(ilp.constraints().len(), 1);
+    assert_eq!(ilp.objective().len(), 2);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
 }
 
 #[test]
 fn test_ilp_empty() {
     let ilp = ILP::<bool>::empty();
-    assert_eq!(ilp.num_vars, 0);
-    assert!(ilp.constraints.is_empty());
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 0);
+    assert!(ilp.constraints().is_empty());
+    assert!(ilp.objective().is_empty());
 }
 
 #[test]
 fn test_ilp_evaluate_objective() {
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         3,
         vec![],
-        vec![(0, 2.0), (1, 3.0), (2, -1.0)],
+        vec![(0, 2), (1, 3), (2, -1)],
         ObjectiveSense::Maximize,
     );
-    // 2*1 + 3*1 + (-1)*0 = 5
-    assert!((ilp.evaluate_objective(&[1, 1, 0]) - 5.0).abs() < 1e-9);
-    // 2*0 + 3*0 + (-1)*1 = -1
-    assert!((ilp.evaluate_objective(&[0, 0, 1]) - (-1.0)).abs() < 1e-9);
+    assert_eq!(ilp.evaluate_objective(&[1, 1, 0]).unwrap(), 5);
+    assert_eq!(ilp.evaluate_objective(&[0, 0, 1]).unwrap(), -1);
+}
+
+#[test]
+fn test_ilp_objective_rejects_short_assignment() {
+    let ilp = binary_ilp(2, vec![], vec![(1, 1)], ObjectiveSense::Maximize);
+    assert!(matches!(
+        ilp.evaluate_objective(&[0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_ilp_constraints_satisfied() {
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         3,
         vec![
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0), // x0 + x1 <= 1
-            LinearConstraint::ge(vec![(2, 1.0)], 0.0),           // x2 >= 0
+            LinearConstraint::le(vec![(0, 1), (1, 1)], 1),
+            LinearConstraint::ge(vec![(2, 1)], 0),
         ],
         vec![],
         ObjectiveSense::Minimize,
     );
-    assert!(ilp.constraints_satisfied(&[0, 0, 1]));
-    assert!(ilp.constraints_satisfied(&[1, 0, 0]));
-    assert!(ilp.constraints_satisfied(&[0, 1, 1]));
-    assert!(!ilp.constraints_satisfied(&[1, 1, 0])); // x0 + x1 = 2 > 1
+    assert!(ilp.is_feasible(&[0, 0, 1]).unwrap());
+    assert!(ilp.is_feasible(&[1, 0, 0]).unwrap());
+    assert!(ilp.is_feasible(&[0, 1, 1]).unwrap());
+    assert!(!ilp.is_feasible(&[1, 1, 0]).unwrap());
 }
 
 #[test]
 fn test_ilp_is_feasible() {
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 1.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 1)],
+        vec![],
         ObjectiveSense::Maximize,
     );
-    assert!(ilp.is_feasible(&[0, 0]));
-    assert!(ilp.is_feasible(&[1, 0]));
-    assert!(ilp.is_feasible(&[0, 1]));
-    assert!(!ilp.is_feasible(&[1, 1])); // Constraint violated
+    assert!(ilp.is_feasible(&[0, 0]).unwrap());
+    assert!(ilp.is_feasible(&[1, 0]).unwrap());
+    assert!(ilp.is_feasible(&[0, 1]).unwrap());
+    assert!(!ilp.is_feasible(&[1, 1]).unwrap());
 }
 
-// ============================================================
-// Problem trait tests
-// ============================================================
-
 #[test]
 fn test_ilp_num_variables() {
-    let ilp = ILP::<bool>::new(5, vec![], vec![], ObjectiveSense::Minimize);
+    let ilp = binary_ilp(5, vec![], vec![], ObjectiveSense::Minimize);
     assert_eq!(ilp.num_variables(), 5);
 }
 
 #[test]
 fn test_ilp_evaluate_valid() {
-    // Maximize x0 + 2*x1 subject to x0 + x1 <= 1
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 2.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1), (1, 2)],
         ObjectiveSense::Maximize,
     );
-
-    // Config [0, 1] means x0=0, x1=1 => obj = 2, valid
     assert_eq!(
-        Problem::evaluate(&ilp, &[0, 1]),
-        Extremum::maximize(Some(2.0))
+        ilp.evaluate(&vec![0, 1]).unwrap(),
+        Extremum::maximize(Some(2))
     );
-
-    // Config [1, 0] means x0=1, x1=0 => obj = 1, valid
     assert_eq!(
-        Problem::evaluate(&ilp, &[1, 0]),
-        Extremum::maximize(Some(1.0))
+        ilp.evaluate(&vec![1, 0]).unwrap(),
+        Extremum::maximize(Some(1))
     );
 }
 
 #[test]
-fn test_ilp_evaluate_invalid() {
-    // x0 + x1 <= 1
-    let ilp = ILP::<bool>::new(
+fn test_ilp_evaluate_infeasible() {
+    let ilp = binary_ilp(
         2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 2.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 1)],
+        vec![],
         ObjectiveSense::Maximize,
     );
-
-    // Config [1, 1] means x0=1, x1=1 => invalid (1+1 > 1), returns Invalid
-    assert_eq!(Problem::evaluate(&ilp, &[1, 1]), Extremum::maximize(None));
+    assert_eq!(ilp.evaluate(&vec![1, 1]).unwrap(), Extremum::maximize(None));
 }
 
 #[test]
-fn test_ilp_brute_force_maximization() {
-    // Maximize x0 + 2*x1 subject to x0 + x1 <= 1, x0, x1 binary
-    let ilp = ILP::<bool>::new(
+fn test_ilp_solver_maximization() {
+    let ilp = binary_ilp(
         2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 2.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1), (1, 2)],
         ObjectiveSense::Maximize,
     );
-
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&ilp);
-
-    // Optimal: x1=1, x0=0 => objective = 2
-    assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![0, 1]);
+    assert_eq!(ILPSolver::new().solve(&ilp).unwrap(), vec![0, 1]);
 }
 
 #[test]
-fn test_ilp_brute_force_minimization() {
-    // Minimize x0 + x1 subject to x0 + x1 >= 1, x0, x1 binary
-    let ilp = ILP::<bool>::new(
+fn test_ilp_solver_minimization() {
+    let ilp = binary_ilp(
         2,
-        vec![LinearConstraint::ge(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 1.0)],
+        vec![LinearConstraint::ge(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1), (1, 1)],
         ObjectiveSense::Minimize,
     );
-
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&ilp);
-
-    // Optimal: x0=1,x1=0 or x0=0,x1=1 => objective = 1
-    assert_eq!(solutions.len(), 2);
-    for sol in &solutions {
-        assert_eq!(Problem::evaluate(&ilp, sol), Extremum::minimize(Some(1.0)));
-    }
+    let solution = ILPSolver::new().solve(&ilp).unwrap();
+    assert!(solution == vec![1, 0] || solution == vec![0, 1]);
 }
 
 #[test]
-fn test_ilp_brute_force_no_feasible() {
-    // x0 >= 1 AND x0 <= 0 (infeasible)
-    let ilp = ILP::<bool>::new(
+fn test_ilp_solver_infeasible() {
+    let ilp = binary_ilp(
         1,
         vec![
-            LinearConstraint::ge(vec![(0, 1.0)], 1.0),
-            LinearConstraint::le(vec![(0, 1.0)], 0.0),
+            LinearConstraint::ge(vec![(0, 1)], 1),
+            LinearConstraint::le(vec![(0, 1)], 0),
         ],
-        vec![(0, 1.0)],
+        vec![],
         ObjectiveSense::Minimize,
     );
-
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&ilp);
-
-    // All solutions are infeasible - BruteForce should return empty list
-    assert!(
-        solutions.is_empty(),
-        "Expected no solutions for infeasible ILP"
-    );
-
-    // Verify all configs are indeed infeasible
-    for config in &[[0], [1]] {
-        assert_eq!(Problem::evaluate(&ilp, config), Extremum::minimize(None));
-        let values = ilp.config_to_values(config);
-        assert!(!ilp.is_feasible(&values));
-    }
+    assert_eq!(ILPSolver::new().solve(&ilp), Err(ILPSolveError::Infeasible));
+    assert!(!ilp.is_feasible(&[0]).unwrap());
+    assert!(!ilp.is_feasible(&[1]).unwrap());
 }
 
 #[test]
 fn test_ilp_unconstrained() {
-    // Maximize x0 + x1, no constraints, binary vars
-    let ilp = ILP::<bool>::new(
-        2,
-        vec![],
-        vec![(0, 1.0), (1, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&ilp);
-
-    // Optimal: both = 1
-    assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![1, 1]);
+    let ilp = binary_ilp(2, vec![], vec![(0, 1), (1, 1)], ObjectiveSense::Maximize);
+    assert_eq!(ILPSolver::new().solve(&ilp).unwrap(), vec![1, 1]);
 }
 
 #[test]
 fn test_ilp_equality_constraint() {
-    // Minimize x0 subject to x0 + x1 == 1, binary vars
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         2,
-        vec![LinearConstraint::eq(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0)],
+        vec![LinearConstraint::eq(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1)],
         ObjectiveSense::Minimize,
     );
-
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&ilp);
-
-    // Optimal: x0=0, x1=1 => objective = 0
-    assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![0, 1]);
+    assert_eq!(ILPSolver::new().solve(&ilp).unwrap(), vec![0, 1]);
 }
 
 #[test]
 fn test_ilp_multiple_constraints() {
-    // Maximize x0 + x1 + x2 subject to:
-    //   x0 + x1 <= 1
-    //   x1 + x2 <= 1
-    // Binary vars
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         3,
         vec![
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0),
-            LinearConstraint::le(vec![(1, 1.0), (2, 1.0)], 1.0),
+            LinearConstraint::le(vec![(0, 1), (1, 1)], 1),
+            LinearConstraint::le(vec![(1, 1), (2, 1)], 1),
         ],
-        vec![(0, 1.0), (1, 1.0), (2, 1.0)],
+        vec![(0, 1), (1, 1), (2, 1)],
         ObjectiveSense::Maximize,
     );
-
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&ilp);
-
-    // Optimal: x0=1, x1=0, x2=1 => objective = 2
-    assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![1, 0, 1]);
+    assert_eq!(ILPSolver::new().solve(&ilp).unwrap(), vec![1, 0, 1]);
 }
 
 #[test]
-fn test_ilp_config_to_values() {
-    let ilp = ILP::<bool>::new(3, vec![], vec![], ObjectiveSense::Minimize);
-
-    // For binary ILP, config maps directly: config[i] -> value[i] as i64
-    assert_eq!(ilp.config_to_values(&[0, 0, 0]), vec![0, 0, 0]);
-    assert_eq!(ilp.config_to_values(&[1, 1, 1]), vec![1, 1, 1]);
-    assert_eq!(ilp.config_to_values(&[1, 0, 1]), vec![1, 0, 1]);
+fn test_binary_ilp_enforces_variable_domain() {
+    let ilp = binary_ilp(3, vec![], vec![], ObjectiveSense::Minimize);
+    assert!(ilp.is_feasible(&[0, 0, 0]).unwrap());
+    assert!(ilp.is_feasible(&[1, 0, 1]).unwrap());
+    assert!(!ilp.is_feasible(&[2, 0, 1]).unwrap());
 }
 
 #[test]
 fn test_ilp_problem() {
-    // Maximize x0 + 2*x1, s.t. x0 + x1 <= 1, binary
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 2.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1), (1, 2)],
         ObjectiveSense::Maximize,
     );
-    assert_eq!(ilp.dims(), vec![2, 2]);
-
-    // [0, 0] -> feasible, obj = 0
     assert_eq!(
-        Problem::evaluate(&ilp, &[0, 0]),
-        Extremum::maximize(Some(0.0))
+        ilp.evaluate(&vec![0, 0]).unwrap(),
+        Extremum::maximize(Some(0))
     );
-    // [0, 1] -> feasible, obj = 2
     assert_eq!(
-        Problem::evaluate(&ilp, &[0, 1]),
-        Extremum::maximize(Some(2.0))
+        ilp.evaluate(&vec![0, 1]).unwrap(),
+        Extremum::maximize(Some(2))
     );
-    // [1, 0] -> feasible, obj = 1
     assert_eq!(
-        Problem::evaluate(&ilp, &[1, 0]),
-        Extremum::maximize(Some(1.0))
+        ilp.evaluate(&vec![1, 0]).unwrap(),
+        Extremum::maximize(Some(1))
     );
-    // [1, 1] -> infeasible
-    assert_eq!(Problem::evaluate(&ilp, &[1, 1]), Extremum::maximize(None));
+    assert_eq!(ilp.evaluate(&vec![1, 1]).unwrap(), Extremum::maximize(None));
 }
 
 #[test]
 fn test_ilp_problem_minimize() {
-    // Minimize x0 + x1, no constraints, binary
-    let ilp = ILP::<bool>::new(
-        2,
-        vec![],
-        vec![(0, 1.0), (1, 1.0)],
-        ObjectiveSense::Minimize,
-    );
+    let ilp = binary_ilp(2, vec![], vec![(0, 1), (1, 1)], ObjectiveSense::Minimize);
     assert_eq!(
-        Problem::evaluate(&ilp, &[0, 0]),
-        Extremum::minimize(Some(0.0))
+        ilp.evaluate(&vec![0, 0]).unwrap(),
+        Extremum::minimize(Some(0))
     );
     assert_eq!(
-        Problem::evaluate(&ilp, &[1, 1]),
-        Extremum::minimize(Some(2.0))
+        ilp.evaluate(&vec![1, 1]).unwrap(),
+        Extremum::minimize(Some(2))
     );
 }
 
 #[test]
-fn test_size_getters() {
-    let ilp = ILP::<bool>::new(
+fn test_parameter_getters() {
+    let ilp = binary_ilp(
         2,
         vec![
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 3.0),
-            LinearConstraint::le(vec![(0, 1.0)], 2.0),
+            LinearConstraint::le(vec![(0, 1), (1, 1)], 3),
+            LinearConstraint::le(vec![(0, 1)], 2),
         ],
-        vec![(0, 1.0), (1, 2.0)],
+        vec![(0, 1), (1, 2)],
         ObjectiveSense::Maximize,
     );
     assert_eq!(ilp.num_vars(), 2);
-    assert_eq!(ilp.num_variables(), 2);
     assert_eq!(ilp.num_constraints(), 2);
+    assert_eq!(ilp.num_nonzeros(), 3);
 }
 
 #[test]
-fn test_ilp_i32_dims() {
-    let ilp = ILP::<i32>::new(3, vec![], vec![], ObjectiveSense::Minimize);
-    assert_eq!(ilp.dims(), vec![(i32::MAX as usize) + 1; 3]);
+fn test_ilp_i64_defaults_to_nonnegative_variables() {
+    let ilp = ILP::<i64>::new(3, vec![], vec![], ObjectiveSense::Minimize).unwrap();
+    assert_eq!(
+        ilp.variables(),
+        vec![IntegerVariable::new(Some(0), None).unwrap(); 3],
+    );
 }
 
 #[test]
-fn test_ilp_paper_example() {
-    // Paper: minimize -5x₁ - 6x₂
-    // s.t. x₁ + x₂ ≤ 5, 4x₁ + 7x₂ ≤ 28, x₁, x₂ ≥ 0, x ∈ Z²
-    // Optimal: x* = (3, 2), objective = -27
-    let ilp = ILP::<i32>::new(
-        2,
+fn test_ilp_explicit_finite_one_sided_and_free_bounds() {
+    let ilp = ILP::<i64>::with_variables(
         vec![
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 5.0),
-            LinearConstraint::le(vec![(0, 4.0), (1, 7.0)], 28.0),
+            IntegerVariable::new(Some(-2), Some(3)).unwrap(),
+            IntegerVariable::new(Some(1), None).unwrap(),
+            IntegerVariable::new(None, Some(4)).unwrap(),
+            IntegerVariable::free(),
         ],
-        vec![(0, -5.0), (1, -6.0)],
+        vec![],
+        vec![],
         ObjectiveSense::Minimize,
-    );
+    )
+    .unwrap();
+
+    assert!(ilp.is_feasible(&[-2, 1, 4, -100]).unwrap());
+    assert!(!ilp.is_feasible(&[-3, 1, 4, 0]).unwrap());
+    assert!(!ilp.is_feasible(&[-2, 0, 4, 0]).unwrap());
+    assert!(!ilp.is_feasible(&[-2, 1, 5, 0]).unwrap());
+}
 
-    // Verify optimal solution x* = (3, 2) → config [3, 2]
-    let result = Problem::evaluate(&ilp, &[3, 2]);
-    assert_eq!(result, Extremum::minimize(Some(-27.0)));
+#[test]
+fn test_integer_variable_deserialization_enforces_bound_order() {
+    let invalid = serde_json::json!({
+        "lower_bound": 3,
+        "upper_bound": 2,
+    });
 
-    // Verify feasibility: 3+2=5≤5, 4*3+7*2=26≤28
-    assert!(ilp.is_feasible(&[3, 2]));
+    assert!(serde_json::from_value::<IntegerVariable>(invalid).is_err());
+}
+
+#[test]
+fn test_ilp_evaluates_constraint_infeasibility_without_a_solver() {
+    let ilp = ILP::<i64>::with_variables(
+        vec![IntegerVariable::new(Some(0), Some(1)).unwrap()],
+        vec![
+            LinearConstraint::le(vec![(0, 1)], 0),
+            LinearConstraint::ge(vec![(0, 1)], 1),
+        ],
+        vec![],
+        ObjectiveSense::Minimize,
+    )
+    .unwrap();
 
-    // Verify infeasible point: 4+4=8>5
-    assert!(!ilp.is_feasible(&[4, 4]));
+    assert_eq!(ilp.evaluate(&vec![0]).unwrap(), Extremum::minimize(None));
+    assert_eq!(ilp.evaluate(&vec![1]).unwrap(), Extremum::minimize(None));
+}
 
-    // Verify suboptimal feasible point: -5*0 - 6*4 = -24 > -27
-    let result2 = Problem::evaluate(&ilp, &[0, 4]);
-    assert_eq!(result2, Extremum::minimize(Some(-24.0)));
+#[test]
+fn test_ilp_paper_example() {
+    let ilp = ILP::<i64>::new(
+        2,
+        vec![
+            LinearConstraint::le(vec![(0, 1), (1, 1)], 5),
+            LinearConstraint::le(vec![(0, 4), (1, 7)], 28),
+        ],
+        vec![(0, -5), (1, -6)],
+        ObjectiveSense::Minimize,
+    )
+    .unwrap();
+    assert_eq!(
+        ilp.evaluate(&vec![3, 2]).unwrap(),
+        Extremum::minimize(Some(-27))
+    );
+    assert!(ilp.is_feasible(&[3, 2]).unwrap());
+    assert!(!ilp.is_feasible(&[4, 4]).unwrap());
+    assert_eq!(
+        ilp.evaluate(&vec![0, 4]).unwrap(),
+        Extremum::minimize(Some(-24))
+    );
 }
diff --git a/src/unit_tests/models/algebraic/minimum_matrix_cover.rs b/src/unit_tests/models/algebraic/minimum_matrix_cover.rs
index e03a063b8..89eb9ad5f 100644
--- a/src/unit_tests/models/algebraic/minimum_matrix_cover.rs
+++ b/src/unit_tests/models/algebraic/minimum_matrix_cover.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -14,7 +15,7 @@ fn test_minimum_matrix_cover_creation() {
     let problem = MinimumMatrixCover::new(matrix.clone());
     assert_eq!(problem.num_rows(), 4);
     assert_eq!(problem.matrix(), &matrix);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(problem.num_variables(), 4);
 }
 
@@ -29,7 +30,7 @@ fn test_minimum_matrix_cover_evaluate_all_minus() {
         vec![0, 2, 4, 0],
     ];
     let problem = MinimumMatrixCover::new(matrix);
-    let value = problem.evaluate(&[0, 0, 0, 0]);
+    let value = problem.evaluate(&vec![false, false, false, false]).unwrap();
     // Sum of all entries = 0+3+1+0 + 3+0+0+2 + 1+0+0+4 + 0+2+4+0 = 20
     assert_eq!(value, Min(Some(20)));
 }
@@ -57,7 +58,7 @@ fn test_minimum_matrix_cover_evaluate_mixed() {
     // (3,2): 4 * (-1)(+1) = -4
     // All other terms are 0 (zero matrix entries or diagonal zeros)
     // Total = -3 + -1 + -3 + -2 + -1 + -4 + -2 + -4 = -20
-    let value = problem.evaluate(&[0, 1, 1, 0]);
+    let value = problem.evaluate(&vec![false, true, true, false]).unwrap();
     assert_eq!(value, Min(Some(-20)));
 }
 
@@ -66,9 +67,15 @@ fn test_minimum_matrix_cover_evaluate_invalid() {
     let problem = MinimumMatrixCover::new(vec![vec![0, 1], vec![1, 0]]);
 
     // Wrong length
-    assert_eq!(problem.evaluate(&[0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Out-of-range value
-    assert_eq!(problem.evaluate(&[0, 2]), Min(None));
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([false, 2]))
+            .is_err()
+    );
 }
 
 #[test]
@@ -82,13 +89,15 @@ fn test_minimum_matrix_cover_solver() {
     let problem = MinimumMatrixCover::new(matrix);
     let solver = BruteForce::new();
 
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(-20)));
 
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
     let w = witness.unwrap();
-    assert_eq!(problem.evaluate(&w), Min(Some(-20)));
+    assert_eq!(problem.evaluate(&w).unwrap(), Min(Some(-20)));
 }
 
 #[test]
@@ -106,11 +115,16 @@ fn test_minimum_matrix_cover_1x1() {
     // 1×1 matrix: only one variable, f(1) = ±1
     // value = a_11 * f(1)^2 = a_11 regardless of sign
     let problem = MinimumMatrixCover::new(vec![vec![5]]);
-    assert_eq!(problem.evaluate(&[0]), Min(Some(5)));
-    assert_eq!(problem.evaluate(&[1]), Min(Some(5)));
+    assert_eq!(problem.evaluate(&vec![false]).unwrap(), Min(Some(5)));
+    assert_eq!(problem.evaluate(&vec![true]).unwrap(), Min(Some(5)));
 
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Min(Some(5)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(5))
+    );
 }
 
 #[test]
@@ -126,16 +140,17 @@ fn test_minimum_matrix_cover_paper_example() {
     let solver = BruteForce::new();
 
     // Verify the claimed optimal from the issue
-    let value = problem.evaluate(&[0, 1, 1, 0]);
+    let value = problem.evaluate(&vec![false, true, true, false]).unwrap();
     assert_eq!(value, Min(Some(-20)));
 
     // Verify it is truly optimal
-    let optimal_value = solver.solve(&problem);
+    let optimal_value_solution = solver.solve(&problem).unwrap().unwrap();
+    let optimal_value = problem.evaluate(&optimal_value_solution).unwrap();
     assert_eq!(optimal_value, Min(Some(-20)));
 
     // Verify the witness is one of the optimal solutions
-    let all_witnesses = solver.find_all_witnesses(&problem);
-    assert!(all_witnesses.contains(&vec![0, 1, 1, 0]));
+    let all_witnesses = solver.find_all_witnesses(&problem).unwrap();
+    assert!(all_witnesses.contains(&vec![false, true, true, false]));
 }
 
 #[cfg(feature = "example-db")]
@@ -147,5 +162,8 @@ fn test_minimum_matrix_cover_canonical_example_spec() {
     let spec = &specs[0];
     assert_eq!(spec.id, "minimum_matrix_cover");
     assert_eq!(spec.optimal_value, serde_json::json!(-20));
-    assert_eq!(spec.optimal_config, vec![0, 1, 1, 0]);
+    assert_eq!(
+        spec.optimal_config,
+        serde_json::json!([false, true, true, false])
+    );
 }
diff --git a/src/unit_tests/models/algebraic/minimum_matrix_domination.rs b/src/unit_tests/models/algebraic/minimum_matrix_domination.rs
index b5a968e9d..7e31fa47e 100644
--- a/src/unit_tests/models/algebraic/minimum_matrix_domination.rs
+++ b/src/unit_tests/models/algebraic/minimum_matrix_domination.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -21,7 +22,7 @@ fn test_minimum_matrix_domination_creation() {
     assert_eq!(problem.num_rows(), 6);
     assert_eq!(problem.num_cols(), 6);
     assert_eq!(problem.num_ones(), 10);
-    assert_eq!(problem.dims(), vec![2; 10]);
+    assert_eq!(problem.dimensions(), vec![2; 10]);
     assert_eq!(
         <MinimumMatrixDomination as Problem>::NAME,
         "MinimumMatrixDomination"
@@ -54,8 +55,10 @@ fn test_minimum_matrix_domination_evaluate_optimal() {
     // Covered rows: {0,1,3,4}, covered cols: {0,1,3,4}
     // Unselected: (1,2) row 1 covered, (2,1) col 1 covered, (2,3) col 3 covered,
     //             (3,2) row 3 covered, (4,5) row 4 covered, (5,4) col 4 covered
-    let config = vec![1, 1, 0, 0, 0, 0, 1, 1, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(4)));
+    let config = vec![
+        true, true, false, false, false, false, true, true, false, false,
+    ];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(4)));
 }
 
 #[test]
@@ -63,38 +66,51 @@ fn test_minimum_matrix_domination_evaluate_infeasible() {
     let problem = MinimumMatrixDomination::new(p6_adjacency_matrix());
     // Select only entry 0: (0,1) — covers row 0, col 1
     // Entry (2,3) at index 4: row 2 not covered, col 3 not covered → infeasible
-    let config = vec![1, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![
+        true, false, false, false, false, false, false, false, false, false,
+    ];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_matrix_domination_evaluate_all_selected() {
     let problem = MinimumMatrixDomination::new(p6_adjacency_matrix());
-    let config = vec![1; 10];
-    assert_eq!(problem.evaluate(&config), Min(Some(10)));
+    let config = vec![true; 10];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(10)));
 }
 
 #[test]
 fn test_minimum_matrix_domination_evaluate_wrong_length() {
     let problem = MinimumMatrixDomination::new(p6_adjacency_matrix());
-    assert_eq!(problem.evaluate(&[1, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[1; 11]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true; 11]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimum_matrix_domination_evaluate_invalid_variable() {
     let problem = MinimumMatrixDomination::new(p6_adjacency_matrix());
-    let mut config = vec![0; 10];
-    config[0] = 2;
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    )
+    .is_err());
 }
 
 #[test]
 fn test_minimum_matrix_domination_brute_force() {
     let problem = MinimumMatrixDomination::new(p6_adjacency_matrix());
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find optimal");
-    let val = problem.evaluate(&witness);
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find optimal");
+    let val = problem.evaluate(&witness).unwrap();
     assert_eq!(val, Min(Some(4)));
 }
 
@@ -110,9 +126,12 @@ fn test_minimum_matrix_domination_identity_matrix() {
     let problem = MinimumMatrixDomination::new(matrix);
     assert_eq!(problem.num_ones(), 3);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find optimal");
-    assert_eq!(problem.evaluate(&witness), Min(Some(3)));
-    assert_eq!(witness, vec![1, 1, 1]);
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find optimal");
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(3)));
+    assert_eq!(witness, vec![true, true, true]);
 }
 
 #[test]
@@ -122,17 +141,20 @@ fn test_minimum_matrix_domination_single_row() {
     let problem = MinimumMatrixDomination::new(matrix);
     assert_eq!(problem.num_ones(), 3);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find optimal");
-    assert_eq!(problem.evaluate(&witness), Min(Some(1)));
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find optimal");
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(1)));
 }
 
 #[test]
 fn test_minimum_matrix_domination_empty_matrix() {
     let problem = MinimumMatrixDomination::new(vec![]);
     assert_eq!(problem.num_ones(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
     // Empty config: vacuously valid with 0 selected
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -140,7 +162,7 @@ fn test_minimum_matrix_domination_no_ones() {
     let matrix = vec![vec![false, false], vec![false, false]];
     let problem = MinimumMatrixDomination::new(matrix);
     assert_eq!(problem.num_ones(), 0);
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
diff --git a/src/unit_tests/models/algebraic/minimum_weight_decoding.rs b/src/unit_tests/models/algebraic/minimum_weight_decoding.rs
index 573353399..352d1b2f8 100644
--- a/src/unit_tests/models/algebraic/minimum_weight_decoding.rs
+++ b/src/unit_tests/models/algebraic/minimum_weight_decoding.rs
@@ -1,4 +1,15 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_maps_rhs_to_target() {
+    let problem = MinimumWeightDecoding::try_from(MinimumWeightDecodingCreateSpec {
+        matrix: vec![vec![true, false]],
+        target: vec![true],
+    })
+    .unwrap();
+    assert_eq!(problem.target(), &[true]);
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -19,7 +30,7 @@ fn test_minimum_weight_decoding_creation() {
     let problem = example_instance();
     assert_eq!(problem.num_rows(), 3);
     assert_eq!(problem.num_cols(), 4);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(
         <MinimumWeightDecoding as Problem>::NAME,
         "MinimumWeightDecoding"
@@ -34,16 +45,16 @@ fn test_minimum_weight_decoding_evaluate_feasible() {
     // Row 0: H[0][2]=1, x[2]=1 → dot=1 mod 2 = 1 = s[0]=true ✓
     // Row 1: H[1][2]=1, x[2]=1 → dot=1 mod 2 = 1 = s[1]=true ✓
     // Row 2: H[2][2]=0 → dot=0 mod 2 = 0 = s[2]=false ✓
-    let config = vec![0, 0, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(1)));
+    let config = vec![false, false, true, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(1)));
 }
 
 #[test]
 fn test_minimum_weight_decoding_evaluate_infeasible() {
     let problem = example_instance();
     // Config [0,0,0,0] → all zeros, Hx = [0,0,0] but s = [1,1,0] → infeasible
-    let config = vec![0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![false, false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -51,37 +62,48 @@ fn test_minimum_weight_decoding_evaluate_heavier_feasible() {
     let problem = example_instance();
     // Config [1,0,0,1] → weight 2
     // Row 0: H[0][0]=1, H[0][3]=1 → dot=2 mod 2=0, s[0]=true → 0≠1 infeasible
-    let config = vec![1, 0, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![true, false, false, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 
     // Config [1,1,0,0] → weight 2
     // Row 0: H[0][0]=1 → dot=1, mod 2=1, s[0]=true ✓
     // Row 1: H[1][1]=1 → dot=1, mod 2=1, s[1]=true ✓
     // Row 2: H[2][0]=1,H[2][1]=1 → dot=2, mod 2=0, s[2]=false ✓
-    let config2 = vec![1, 1, 0, 0];
-    assert_eq!(problem.evaluate(&config2), Min(Some(2)));
+    let config2 = vec![true, true, false, false];
+    assert_eq!(problem.evaluate(&config2).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_minimum_weight_decoding_evaluate_wrong_length() {
     let problem = example_instance();
-    assert_eq!(problem.evaluate(&[1, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[1; 5]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true; 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimum_weight_decoding_evaluate_invalid_variable() {
     let problem = example_instance();
-    let config = vec![2, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([2, 0, 0, 0]),)
+            .is_err()
+    );
 }
 
 #[test]
 fn test_minimum_weight_decoding_brute_force() {
     let problem = example_instance();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find optimal");
-    let val = problem.evaluate(&witness);
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find optimal");
+    let val = problem.evaluate(&witness).unwrap();
     // Optimal is weight 1 with config [0,0,1,0]
     assert_eq!(val, Min(Some(1)));
 }
@@ -90,11 +112,11 @@ fn test_minimum_weight_decoding_brute_force() {
 fn test_minimum_weight_decoding_all_witnesses() {
     let problem = example_instance();
     let solver = BruteForce::new();
-    let witnesses = solver.find_all_witnesses(&problem);
+    let witnesses = solver.find_all_witnesses(&problem).unwrap();
     // All witnesses should be feasible and have weight 1
     assert!(!witnesses.is_empty());
     for w in &witnesses {
-        assert_eq!(problem.evaluate(w), Min(Some(1)));
+        assert_eq!(problem.evaluate(w).unwrap(), Min(Some(1)));
     }
 }
 
@@ -120,8 +142,8 @@ fn test_minimum_weight_decoding_zero_syndrome() {
     let matrix = vec![vec![true, false, true], vec![false, true, true]];
     let target = vec![false, false];
     let problem = MinimumWeightDecoding::new(matrix, target);
-    let config = vec![0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(0)));
+    let config = vec![false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(0)));
 }
 
 #[test]
diff --git a/src/unit_tests/models/algebraic/minimum_weight_solution_to_linear_equations.rs b/src/unit_tests/models/algebraic/minimum_weight_solution_to_linear_equations.rs
index 4c6b2b30d..b4603a584 100644
--- a/src/unit_tests/models/algebraic/minimum_weight_solution_to_linear_equations.rs
+++ b/src/unit_tests/models/algebraic/minimum_weight_solution_to_linear_equations.rs
@@ -1,4 +1,16 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_rhs_length_mismatch() {
+    assert!(
+        MinimumWeightSolutionToLinearEquations::try_from(MinimumWeightSolutionCreateSpec {
+            matrix: vec![vec![1, 2]],
+            rhs: vec![]
+        })
+        .is_err()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -15,7 +27,7 @@ fn test_minimum_weight_solution_creation() {
     let problem = example_instance();
     assert_eq!(problem.num_equations(), 2);
     assert_eq!(problem.num_variables(), 4);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(
         <MinimumWeightSolutionToLinearEquations as Problem>::NAME,
         "MinimumWeightSolutionToLinearEquations"
@@ -30,54 +42,65 @@ fn test_minimum_weight_solution_creation() {
 fn test_minimum_weight_solution_evaluate_consistent() {
     let problem = example_instance();
     // Select columns 0,1: submatrix [[1,2],[2,1]], b=[5,4] → y=(1,2). Consistent.
-    let config = vec![1, 1, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(2)));
+    let config = vec![true, true, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_minimum_weight_solution_evaluate_inconsistent() {
     let problem = example_instance();
     // Select only column 0: [1;2]y=[5;4] → y=5, but 2*5=10 ≠ 4. Inconsistent.
-    let config = vec![1, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![true, false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_weight_solution_evaluate_all_selected() {
     let problem = example_instance();
     // All 4 columns selected — system has solution, so feasible with value 4.
-    let config = vec![1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(4)));
+    let config = vec![true, true, true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(4)));
 }
 
 #[test]
 fn test_minimum_weight_solution_evaluate_none_selected() {
     let problem = example_instance();
     // No columns selected, b ≠ 0 → infeasible.
-    let config = vec![0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![false, false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_weight_solution_evaluate_wrong_length() {
     let problem = example_instance();
-    assert_eq!(problem.evaluate(&[1, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[1; 5]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true; 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimum_weight_solution_evaluate_invalid_variable() {
     let problem = example_instance();
-    let config = vec![2, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([2, 0, 0, 0]),)
+            .is_err()
+    );
 }
 
 #[test]
 fn test_minimum_weight_solution_brute_force() {
     let problem = example_instance();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find optimal");
-    let val = problem.evaluate(&witness);
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find optimal");
+    let val = problem.evaluate(&witness).unwrap();
     assert_eq!(val, Min(Some(2)));
 }
 
@@ -87,8 +110,8 @@ fn test_minimum_weight_solution_zero_rhs() {
     let matrix = vec![vec![1, 1], vec![2, 2]];
     let rhs = vec![0, 0];
     let problem = MinimumWeightSolutionToLinearEquations::new(matrix, rhs);
-    let config = vec![0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(0)));
+    let config = vec![false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(0)));
 }
 
 #[test]
diff --git a/src/unit_tests/models/algebraic/quadratic_assignment.rs b/src/unit_tests/models/algebraic/quadratic_assignment.rs
index 283c49e63..66f2de170 100644
--- a/src/unit_tests/models/algebraic/quadratic_assignment.rs
+++ b/src/unit_tests/models/algebraic/quadratic_assignment.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -39,7 +40,7 @@ fn test_quadratic_assignment_creation() {
     let qap = make_test_instance();
     assert_eq!(qap.num_facilities(), 4);
     assert_eq!(qap.num_locations(), 4);
-    assert_eq!(qap.dims(), vec![4, 4, 4, 4]);
+    assert_eq!(qap.dimensions(), vec![4, 4, 4, 4]);
     assert_eq!(qap.cost_matrix().len(), 4);
     assert_eq!(qap.distance_matrix().len(), 4);
 }
@@ -51,7 +52,10 @@ fn test_quadratic_assignment_evaluate_identity() {
     // cost = sum_{i != j} C[i][j] * D[i][j]
     //   = 5*4 + 2*1 + 0*1 + 5*4 + 0*3 + 3*4 + 2*1 + 0*3 + 4*4 + 0*1 + 3*4 + 4*4
     //   = 20 + 2 + 0 + 20 + 0 + 12 + 2 + 0 + 16 + 0 + 12 + 16 = 100
-    assert_eq!(Problem::evaluate(&qap, &[0, 1, 2, 3]), Min(Some(100)));
+    assert_eq!(
+        Problem::evaluate(&qap, &vec![0, 1, 2, 3]).unwrap(),
+        Min(Some(100))
+    );
 }
 
 #[test]
@@ -64,20 +68,35 @@ fn test_quadratic_assignment_evaluate_swap() {
     //   i=2,j=0: 2*D[1][0]=2*4=8   i=2,j=1: 0*D[1][2]=0*3=0   i=2,j=3: 4*D[1][3]=4*4=16
     //   i=3,j=0: 0*D[3][0]=0       i=3,j=1: 3*D[3][2]=3*4=12  i=3,j=2: 4*D[3][1]=4*4=16
     //   Total = 5+8+0+5+0+12+8+0+16+0+12+16 = 82
-    assert_eq!(Problem::evaluate(&qap, &[0, 2, 1, 3]), Min(Some(82)));
+    assert_eq!(
+        Problem::evaluate(&qap, &vec![0, 2, 1, 3]).unwrap(),
+        Min(Some(82))
+    );
 }
 
 #[test]
 fn test_quadratic_assignment_evaluate_invalid() {
     let qap = make_test_instance();
     // Duplicate location 0 — not injective, should be Invalid.
-    assert_eq!(Problem::evaluate(&qap, &[0, 0, 1, 2]), Min(None));
+    assert_eq!(
+        Problem::evaluate(&qap, &vec![0, 0, 1, 2]).unwrap(),
+        Min(None)
+    );
     // Out-of-range location index.
-    assert_eq!(Problem::evaluate(&qap, &[0, 1, 2, 99]), Min(None));
+    assert!(matches!(
+        Problem::evaluate(&qap, &vec![0, 1, 2, 99]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Wrong config length — too short.
-    assert_eq!(Problem::evaluate(&qap, &[0, 1, 2]), Min(None));
+    assert!(matches!(
+        Problem::evaluate(&qap, &vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Wrong config length — too long.
-    assert_eq!(Problem::evaluate(&qap, &[0, 1, 2, 3, 0]), Min(None));
+    assert!(matches!(
+        Problem::evaluate(&qap, &vec![0, 1, 2, 3, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -89,8 +108,8 @@ fn test_quadratic_assignment_serialization() {
     assert_eq!(qap2.num_locations(), 4);
     // Verify functional equivalence after round-trip.
     assert_eq!(
-        Problem::evaluate(&qap, &[0, 1, 2, 3]),
-        Problem::evaluate(&qap2, &[0, 1, 2, 3])
+        Problem::evaluate(&qap, &vec![0, 1, 2, 3]).unwrap(),
+        Problem::evaluate(&qap2, &vec![0, 1, 2, 3]).unwrap()
     );
 }
 
@@ -102,15 +121,15 @@ fn test_quadratic_assignment_rectangular() {
     let qap = QuadraticAssignment::new(cost_matrix, distance_matrix);
     assert_eq!(qap.num_facilities(), 2);
     assert_eq!(qap.num_locations(), 3);
-    assert_eq!(qap.dims(), vec![3, 3]);
+    assert_eq!(qap.dimensions(), vec![3, 3]);
     // Assignment f=(0,1): cost = C[0][1]*D[0][1] + C[1][0]*D[1][0] = 3*1 + 3*1 = 6
-    assert_eq!(Problem::evaluate(&qap, &[0, 1]), Min(Some(6)));
+    assert_eq!(Problem::evaluate(&qap, &vec![0, 1]).unwrap(), Min(Some(6)));
     // Assignment f=(0,2): cost = 3*D[0][2] + 3*D[2][0] = 3*4 + 3*4 = 24
-    assert_eq!(Problem::evaluate(&qap, &[0, 2]), Min(Some(24)));
+    assert_eq!(Problem::evaluate(&qap, &vec![0, 2]).unwrap(), Min(Some(24)));
     // BruteForce should find optimal
     let solver = BruteForce::new();
-    let best = solver.find_witness(&qap).unwrap();
-    assert_eq!(Problem::evaluate(&qap, &best), Min(Some(6)));
+    let best = solver.solve(&qap).unwrap().unwrap();
+    assert_eq!(Problem::evaluate(&qap, &best).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -132,9 +151,12 @@ fn test_quadratic_assignment_too_many_facilities() {
 fn test_quadratic_assignment_solver() {
     let qap = make_test_instance();
     let solver = BruteForce::new();
-    let best = solver.find_witness(&qap);
+    let best = solver.solve(&qap).unwrap();
     assert!(best.is_some());
     let best_config = best.unwrap();
     // The brute-force solver finds the optimal assignment f* = (3, 0, 1, 2) with cost 56.
-    assert_eq!(Problem::evaluate(&qap, &best_config), Min(Some(56)));
+    assert_eq!(
+        Problem::evaluate(&qap, &best_config).unwrap(),
+        Min(Some(56))
+    );
 }
diff --git a/src/unit_tests/models/algebraic/quadratic_congruences.rs b/src/unit_tests/models/algebraic/quadratic_congruences.rs
index 5c393b3c7..41a805acc 100644
--- a/src/unit_tests/models/algebraic/quadratic_congruences.rs
+++ b/src/unit_tests/models/algebraic/quadratic_congruences.rs
@@ -1,5 +1,6 @@
 use crate::models::algebraic::QuadraticCongruences;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 use num_bigint::BigUint;
@@ -18,8 +19,8 @@ fn bu(n: u32) -> BigUint {
     BigUint::from(n)
 }
 
-fn config_for_x(problem: &QuadraticCongruences, x: u32) -> Vec<usize> {
-    problem.encode_witness(&bu(x)).unwrap()
+fn config_for_x(_problem: &QuadraticCongruences, x: u32) -> BigUint {
+    bu(x)
 }
 
 #[test]
@@ -32,7 +33,7 @@ fn test_quadratic_congruences_creation_and_accessors() {
     assert_eq!(p.bit_length_b(), 4);
     assert_eq!(p.bit_length_c(), 4);
     // x is encoded as 4 binary digits because c - 1 = 9 has 4 bits.
-    assert_eq!(p.dims(), vec![2, 2, 2, 2]);
+    assert_eq!(p.dimensions(), vec![2, 2, 2, 2]);
     assert_eq!(p.num_variables(), 4);
     assert_eq!(
         <QuadraticCongruences as Problem>::NAME,
@@ -44,39 +45,38 @@ fn test_quadratic_congruences_creation_and_accessors() {
 #[test]
 fn test_quadratic_congruences_evaluate_yes() {
     let p = yes_problem();
-    assert_eq!(p.evaluate(&config_for_x(&p, 2)), Or(true));
-    assert_eq!(p.evaluate(&config_for_x(&p, 7)), Or(true));
-    assert_eq!(p.evaluate(&config_for_x(&p, 8)), Or(true));
-    assert_eq!(p.evaluate(&config_for_x(&p, 1)), Or(false));
-    assert_eq!(p.evaluate(&config_for_x(&p, 3)), Or(false));
+    assert_eq!(p.evaluate(&config_for_x(&p, 2)).unwrap(), Or(true));
+    assert_eq!(p.evaluate(&config_for_x(&p, 7)).unwrap(), Or(true));
+    assert_eq!(p.evaluate(&config_for_x(&p, 8)).unwrap(), Or(true));
+    assert_eq!(p.evaluate(&config_for_x(&p, 1)).unwrap(), Or(false));
+    assert_eq!(p.evaluate(&config_for_x(&p, 3)).unwrap(), Or(false));
 }
 
 #[test]
 fn test_quadratic_congruences_evaluate_no() {
     let p = no_problem();
     // c - 1 = 6 has 3 bits.
-    assert_eq!(p.dims(), vec![2, 2, 2]);
+    assert_eq!(p.dimensions(), vec![2, 2, 2]);
     for x in 1..7 {
         // quadratic residues mod 7 are {0,1,2,4}; 3 is not one
-        assert_eq!(p.evaluate(&config_for_x(&p, x)), Or(false));
+        assert_eq!(p.evaluate(&config_for_x(&p, x)).unwrap(), Or(false));
     }
 }
 
 #[test]
 fn test_quadratic_congruences_evaluate_invalid_config() {
     let p = yes_problem();
-    assert_eq!(p.evaluate(&[]), Or(false));
-    assert_eq!(p.evaluate(&[0, 1]), Or(false));
-    assert_eq!(p.evaluate(&[0, 1, 0, 2]), Or(false));
+    assert_eq!(p.evaluate(&BigUint::default()).unwrap(), Or(false));
+    assert_eq!(p.evaluate(&bu(10)).unwrap(), Or(false));
 }
 
 #[test]
 fn test_quadratic_congruences_c_le_1() {
     // c=1: search space {1..0} is empty
     let p = QuadraticCongruences::new(0, 5, 1);
-    assert_eq!(p.dims(), Vec::<usize>::new());
-    assert_eq!(p.evaluate(&[0]), Or(false));
-    assert_eq!(p.evaluate(&[]), Or(false));
+    assert_eq!(p.dimensions(), Vec::<usize>::new());
+    assert_eq!(p.evaluate(&BigUint::default()).unwrap(), Or(false));
+    assert_eq!(p.evaluate(&bu(1)).unwrap(), Or(false));
 }
 
 #[test]
@@ -86,30 +86,30 @@ fn test_quadratic_congruences_bigint_witness_encoding_round_trip() {
     let x = (BigUint::from(1u32) << 100usize) + BigUint::from(1u32);
     let config = p.encode_witness(&x).expect("x should be encodable");
 
-    assert_eq!(config.len(), p.dims().len());
+    assert_eq!(config.len(), p.dimensions().len());
     assert_eq!(p.decode_witness(&config), Some(x));
 }
 
 #[test]
 fn test_quadratic_congruences_brute_force_finds_witness() {
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&yes_problem()).unwrap();
-    assert_eq!(yes_problem().evaluate(&witness), Or(true));
-    let x = yes_problem().decode_witness(&witness).unwrap();
+    let witness = solver.solve(&yes_problem()).unwrap().unwrap();
+    assert_eq!(yes_problem().evaluate(&witness).unwrap(), Or(true));
+    let x = witness;
     assert!(matches!(x, v if v == bu(2) || v == bu(7) || v == bu(8)));
 }
 
 #[test]
 fn test_quadratic_congruences_brute_force_finds_all_witnesses() {
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&yes_problem());
+    let all = solver.find_all_witnesses(&yes_problem()).unwrap();
     assert_eq!(all.len(), 3);
     assert!(all
         .iter()
-        .all(|sol| yes_problem().evaluate(sol) == Or(true)));
+        .all(|sol| yes_problem().evaluate(sol).unwrap() == Or(true)));
     let decoded = all
         .iter()
-        .map(|sol| yes_problem().decode_witness(sol).unwrap())
+        .cloned()
         .collect::<std::collections::BTreeSet<_>>();
     assert_eq!(
         decoded,
@@ -120,7 +120,7 @@ fn test_quadratic_congruences_brute_force_finds_all_witnesses() {
 #[test]
 fn test_quadratic_congruences_brute_force_no_witness() {
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&no_problem()).is_none());
+    assert!(solver.solve(&no_problem()).unwrap().is_none());
 }
 
 #[test]
@@ -156,11 +156,11 @@ fn test_quadratic_congruences_paper_example() {
     // Canonical example: a=4, b=15, c=10; x=2 encodes to binary digits [0,1,0,0].
     let p = QuadraticCongruences::new(4, 15, 10);
     let config = config_for_x(&p, 2);
-    assert_eq!(p.evaluate(&config), Or(true));
+    assert_eq!(p.evaluate(&config).unwrap(), Or(true));
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&p).unwrap();
-    assert_eq!(p.evaluate(&witness), Or(true));
+    let witness = solver.solve(&p).unwrap().unwrap();
+    assert_eq!(p.evaluate(&witness).unwrap(), Or(true));
 }
 
 #[test]
diff --git a/src/unit_tests/models/algebraic/quadratic_diophantine_equations.rs b/src/unit_tests/models/algebraic/quadratic_diophantine_equations.rs
index 055539e59..09d0c968b 100644
--- a/src/unit_tests/models/algebraic/quadratic_diophantine_equations.rs
+++ b/src/unit_tests/models/algebraic/quadratic_diophantine_equations.rs
@@ -1,5 +1,6 @@
 use crate::models::algebraic::QuadraticDiophantineEquations;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 use num_bigint::BigUint;
@@ -18,8 +19,8 @@ fn bu(n: u32) -> BigUint {
     BigUint::from(n)
 }
 
-fn config_for_x(problem: &QuadraticDiophantineEquations, x: u32) -> Vec<usize> {
-    problem.encode_witness(&bu(x)).unwrap()
+fn config_for_x(_problem: &QuadraticDiophantineEquations, x: u32) -> BigUint {
+    bu(x)
 }
 
 #[test]
@@ -32,7 +33,7 @@ fn test_quadratic_diophantine_equations_creation_and_accessors() {
     assert_eq!(problem.bit_length_b(), 3);
     assert_eq!(problem.bit_length_c(), 6);
     // max_x = floor(sqrt(53 / 3)) = 4, encoded in 3 binary digits.
-    assert_eq!(problem.dims(), vec![2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2]);
     assert_eq!(problem.num_variables(), 3);
     assert_eq!(
         <QuadraticDiophantineEquations as Problem>::NAME,
@@ -47,52 +48,63 @@ fn test_quadratic_diophantine_equations_creation_and_accessors() {
 #[test]
 fn test_quadratic_diophantine_equations_evaluate_yes() {
     let problem = yes_problem();
-    assert_eq!(problem.evaluate(&config_for_x(&problem, 1)), Or(true));
-    assert_eq!(problem.evaluate(&config_for_x(&problem, 2)), Or(false));
-    assert_eq!(problem.evaluate(&config_for_x(&problem, 3)), Or(false));
-    assert_eq!(problem.evaluate(&config_for_x(&problem, 4)), Or(true));
+    assert_eq!(
+        problem.evaluate(&config_for_x(&problem, 1)).unwrap(),
+        Or(true)
+    );
+    assert_eq!(
+        problem.evaluate(&config_for_x(&problem, 2)).unwrap(),
+        Or(false)
+    );
+    assert_eq!(
+        problem.evaluate(&config_for_x(&problem, 3)).unwrap(),
+        Or(false)
+    );
+    assert_eq!(
+        problem.evaluate(&config_for_x(&problem, 4)).unwrap(),
+        Or(true)
+    );
 }
 
 #[test]
 fn test_quadratic_diophantine_equations_evaluate_no() {
     let problem = no_problem();
-    assert_eq!(problem.dims(), vec![2]);
-    assert_eq!(problem.evaluate(&config_for_x(&problem, 1)), Or(false));
+    assert_eq!(problem.dimensions(), vec![2]);
+    assert_eq!(
+        problem.evaluate(&config_for_x(&problem, 1)).unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
 fn test_quadratic_diophantine_equations_evaluate_invalid_config() {
     let problem = yes_problem();
-    assert_eq!(problem.evaluate(&[]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 1]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Or(false));
+    assert_eq!(problem.evaluate(&BigUint::default()).unwrap(), Or(false));
+    assert_eq!(problem.evaluate(&bu(5)).unwrap(), Or(false));
 }
 
 #[test]
 fn test_quadratic_diophantine_equations_c_le_a() {
     let problem = QuadraticDiophantineEquations::new(10, 1, 5);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert_eq!(problem.evaluate(&[]), Or(false));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert_eq!(problem.evaluate(&BigUint::default()).unwrap(), Or(false));
 }
 
 #[test]
 fn test_quadratic_diophantine_equations_bigint_witness_encoding_round_trip() {
-    let c = BigUint::from(1u32) << 202usize;
-    let problem = QuadraticDiophantineEquations::new(1u32, 1u32, c);
     let x = (BigUint::from(1u32) << 100usize) + BigUint::from(1u32);
-    let config = problem.encode_witness(&x).expect("x should be encodable");
-
-    assert_eq!(config.len(), problem.dims().len());
-    assert_eq!(problem.decode_witness(&config), Some(x));
+    let serialized = serde_json::to_value(&x).unwrap();
+    let restored: BigUint = serde_json::from_value(serialized).unwrap();
+    assert_eq!(restored, x);
 }
 
 #[test]
 fn test_quadratic_diophantine_equations_solver_finds_witness() {
     let problem = yes_problem();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&witness), Or(true));
-    let x = problem.decode_witness(&witness).unwrap();
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&witness).unwrap(), Or(true));
+    let x = witness;
     assert!(matches!(x, v if v == bu(1) || v == bu(4)));
 }
 
@@ -100,12 +112,14 @@ fn test_quadratic_diophantine_equations_solver_finds_witness() {
 fn test_quadratic_diophantine_equations_solver_finds_all_witnesses() {
     let problem = yes_problem();
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all.len(), 2);
-    assert!(all.iter().all(|sol| problem.evaluate(sol) == Or(true)));
+    assert!(all
+        .iter()
+        .all(|sol| problem.evaluate(sol).unwrap() == Or(true)));
     let decoded = all
         .iter()
-        .map(|sol| problem.decode_witness(sol).unwrap())
+        .cloned()
         .collect::<std::collections::BTreeSet<_>>();
     assert_eq!(decoded, std::collections::BTreeSet::from([bu(1), bu(4)]));
 }
@@ -114,7 +128,7 @@ fn test_quadratic_diophantine_equations_solver_finds_all_witnesses() {
 fn test_quadratic_diophantine_equations_solver_no_witness() {
     let problem = no_problem();
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -159,11 +173,11 @@ fn test_quadratic_diophantine_equations_check_x() {
 fn test_quadratic_diophantine_equations_paper_example() {
     let problem = QuadraticDiophantineEquations::new(3, 5, 53);
     let config = config_for_x(&problem, 1);
-    assert_eq!(problem.evaluate(&config), Or(true));
+    assert_eq!(problem.evaluate(&config).unwrap(), Or(true));
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&witness), Or(true));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&witness).unwrap(), Or(true));
 }
 
 #[test]
diff --git a/src/unit_tests/models/algebraic/qubo.rs b/src/unit_tests/models/algebraic/qubo.rs
index 83ebae164..448fef75b 100644
--- a/src/unit_tests/models/algebraic/qubo.rs
+++ b/src/unit_tests/models/algebraic/qubo.rs
@@ -1,21 +1,22 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 include!("../../jl_helpers.rs");
 
 #[test]
 fn test_qubo_from_matrix() {
-    let problem = QUBO::from_matrix(vec![vec![1.0, 2.0], vec![0.0, 3.0]]);
+    let problem = QUBO::from_matrix(vec![vec![1, 2], vec![0, 3]]).unwrap();
     assert_eq!(problem.num_vars(), 2);
-    assert_eq!(problem.get(0, 0), Some(&1.0));
-    assert_eq!(problem.get(0, 1), Some(&2.0));
-    assert_eq!(problem.get(1, 1), Some(&3.0));
+    assert_eq!(problem.get(0, 0), Some(&1));
+    assert_eq!(problem.get(0, 1), Some(&2));
+    assert_eq!(problem.get(1, 1), Some(&3));
 }
 
 #[test]
 fn test_qubo_new() {
-    let problem = QUBO::new(vec![1.0, 2.0], vec![((0, 1), 3.0)]);
+    let problem = QUBO::new(vec![1.0, 2.0], vec![((0, 1), 3.0)]).unwrap();
     assert_eq!(problem.get(0, 0), Some(&1.0));
     assert_eq!(problem.get(1, 1), Some(&2.0));
     assert_eq!(problem.get(0, 1), Some(&3.0));
@@ -23,7 +24,7 @@ fn test_qubo_new() {
 
 #[test]
 fn test_num_variables() {
-    let problem = QUBO::<f64>::from_matrix(vec![vec![0.0; 5]; 5]);
+    let problem = QUBO::<f64>::from_matrix(vec![vec![0.0; 5]; 5]).unwrap();
     assert_eq!(problem.num_variables(), 5);
 }
 
@@ -33,7 +34,8 @@ fn test_matrix_access() {
         vec![1.0, 2.0, 3.0],
         vec![0.0, 4.0, 5.0],
         vec![0.0, 0.0, 6.0],
-    ]);
+    ])
+    .unwrap();
     let matrix = problem.matrix();
     assert_eq!(matrix.len(), 3);
     assert_eq!(matrix[0], vec![1.0, 2.0, 3.0]);
@@ -41,21 +43,39 @@ fn test_matrix_access() {
 
 #[test]
 fn test_empty_qubo() {
-    let problem = QUBO::<f64>::from_matrix(vec![]);
+    let problem = QUBO::<f64>::from_matrix(vec![]).unwrap();
     assert_eq!(problem.num_vars(), 0);
-    assert_eq!(Problem::evaluate(&problem, &[]), Min(Some(0.0)));
+    assert_eq!(
+        Problem::evaluate(&problem, &vec![]).unwrap(),
+        Min(Some(0.0))
+    );
+}
+
+#[test]
+fn test_qubo_rejects_invalid_configurations() {
+    let problem = QUBO::from_matrix(vec![vec![1.0, 2.0], vec![0.0, 3.0]]).unwrap();
+    for solution in [vec![true], vec![true, false, false]] {
+        assert!(matches!(
+            Problem::evaluate(&problem, &solution),
+            Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+        ));
+    }
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([2, false]))
+            .is_err()
+    );
 }
 
 #[test]
 fn test_qubo_new_reverse_indices() {
     // Test the case where (j, i) is provided with i < j
-    let problem = QUBO::new(vec![1.0, 2.0], vec![((1, 0), 3.0)]); // j > i
+    let problem = QUBO::new(vec![1.0, 2.0], vec![((1, 0), 3.0)]).unwrap(); // j > i
     assert_eq!(problem.get(0, 1), Some(&3.0)); // Should be stored at (0, 1)
 }
 
 #[test]
 fn test_get_out_of_bounds() {
-    let problem = QUBO::from_matrix(vec![vec![1.0, 2.0], vec![0.0, 3.0]]);
+    let problem = QUBO::from_matrix(vec![vec![1.0, 2.0], vec![0.0, 3.0]]).unwrap();
     assert_eq!(problem.get(5, 5), None);
     assert_eq!(problem.get(0, 5), None);
 }
@@ -85,10 +105,10 @@ fn test_jl_parity_evaluation() {
                 rust_matrix[i][j] = jl_matrix[i][j] + jl_matrix[j][i];
             }
         }
-        let problem = QUBO::from_matrix(rust_matrix);
+        let problem = QUBO::from_matrix(rust_matrix).unwrap();
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = Problem::evaluate(&problem, &config);
+            let config = jl_parse_bool_config(&eval["config"]);
+            let result = Problem::evaluate(&problem, &config).unwrap();
             let jl_size = eval["size"].as_f64().unwrap();
             assert!(result.is_valid(), "QUBO should always be valid");
             assert!(
@@ -97,9 +117,9 @@ fn test_jl_parity_evaluation() {
                 config
             );
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best: HashSet<Vec<bool>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "QUBO best solutions mismatch");
     }
 }
@@ -107,14 +127,78 @@ fn test_jl_parity_evaluation() {
 #[test]
 fn test_qubo_paper_example() {
     // Paper: Q=[[-1,2,0],[0,-1,2],[0,0,-1]], min=-2 at (1,0,1)
-    let problem = QUBO::from_matrix(vec![
-        vec![-1.0, 2.0, 0.0],
-        vec![0.0, -1.0, 2.0],
-        vec![0.0, 0.0, -1.0],
-    ]);
-    assert_eq!(Problem::evaluate(&problem, &[1, 0, 1]), Min(Some(-2.0)));
+    let problem = QUBO::from_matrix(vec![vec![-1, 2, 0], vec![0, -1, 2], vec![0, 0, -1]]).unwrap();
+    assert_eq!(
+        Problem::evaluate(&problem, &vec![true, false, true]).unwrap(),
+        Min(Some(-2))
+    );
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(Problem::evaluate(&problem, &best), Min(Some(-2.0)));
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(Problem::evaluate(&problem, &best).unwrap(), Min(Some(-2)));
+}
+
+#[test]
+fn test_qubo_create_spec_derives_num_vars() {
+    let problem = QUBO::try_from(QuboCreateSpec {
+        matrix: vec![vec![1, 2], vec![0, 3]],
+    })
+    .unwrap();
+
+    assert_eq!(problem.num_vars(), 2);
+    assert_eq!(QuboCreateSpec::<i64>::FIELDS[0].name, "matrix");
+    assert_eq!(QuboCreateSpec::<i64>::FIELDS.len(), 1);
+}
+
+#[test]
+fn test_qubo_f64_create_spec() {
+    let problem = QUBO::<f64>::try_from(QuboCreateSpec {
+        matrix: vec![vec![0.5, -1.25], vec![0.0, 2.0]],
+    })
+    .unwrap();
+
+    assert_eq!(problem.get(0, 0), Some(&0.5));
+    assert_eq!(problem.get(0, 1), Some(&-1.25));
+}
+
+#[test]
+fn test_qubo_rejects_non_square_matrix() {
+    let error = QUBO::from_matrix(vec![vec![1.0, 2.0], vec![3.0]]).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::registry::ConstructionError::Conversion(message) if message.contains("row 1")
+    ));
+}
+
+#[test]
+fn test_qubo_rejects_non_finite_coefficients() {
+    let error = QUBO::from_matrix(vec![vec![f64::NAN]]).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::registry::ConstructionError::NonFiniteFloat(_)
+    ));
+    let error = QUBO::new(vec![f64::INFINITY], vec![]).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::registry::ConstructionError::NonFiniteFloat(_)
+    ));
+}
+
+#[test]
+fn test_qubo_rejects_out_of_range_quadratic_index() {
+    let error = QUBO::new(vec![1.0], vec![((0, 1), 2.0)]).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::registry::ConstructionError::Conversion(message)
+            if message.contains("outside 0..1")
+    ));
+}
+
+#[test]
+fn test_integer_qubo_reports_objective_overflow() {
+    let problem = QUBO::from_matrix(vec![vec![i64::MAX, 1], vec![0, 0]]).unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![true, true]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
 }
diff --git a/src/unit_tests/models/algebraic/simultaneous_incongruences.rs b/src/unit_tests/models/algebraic/simultaneous_incongruences.rs
index db78bf388..0506d3829 100644
--- a/src/unit_tests/models/algebraic/simultaneous_incongruences.rs
+++ b/src/unit_tests/models/algebraic/simultaneous_incongruences.rs
@@ -1,5 +1,6 @@
 use crate::models::algebraic::SimultaneousIncongruences;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -25,7 +26,7 @@ fn test_simultaneous_incongruences_creation_and_accessors() {
     assert_eq!(p.pairs(), &[(2, 2), (1, 3), (2, 5), (3, 7)]);
     // lcm(2,3,5,7) = 210
     assert_eq!(p.lcm_moduli(), 210);
-    assert_eq!(p.dims(), vec![210]);
+    assert_eq!(p.dimensions(), vec![210]);
     assert_eq!(p.num_variables(), 1);
     assert_eq!(
         <SimultaneousIncongruences as Problem>::NAME,
@@ -38,9 +39,9 @@ fn test_simultaneous_incongruences_creation_and_accessors() {
 fn test_simultaneous_incongruences_evaluate_yes() {
     let p = example_problem();
     // x=5: 5%2=1≠0(=2%2), 5%3=2≠1, 5%5=0≠2, 5%7=5≠3 ✓
-    assert_eq!(p.evaluate(&[5]), Or(true));
+    assert_eq!(p.evaluate(&5).unwrap(), Or(true));
     // x=1: 1%2=1≠0(=2%2), 1%3=1=1 — fails for pair (1,3)
-    assert_eq!(p.evaluate(&[1]), Or(false));
+    assert_eq!(p.evaluate(&1).unwrap(), Or(false));
 }
 
 #[test]
@@ -51,16 +52,20 @@ fn test_simultaneous_incongruences_evaluate_no() {
     let lcm = p.lcm_moduli();
     assert_eq!(lcm, 2);
     // All x in {0,1} should fail
-    for x in 0..lcm as usize {
-        assert_eq!(p.evaluate(&[x]), Or(false), "expected false for x={x}");
+    for x in 0..lcm {
+        assert_eq!(
+            p.evaluate(&x).unwrap(),
+            Or(false),
+            "expected false for x={x}"
+        );
     }
 }
 
 #[test]
 fn test_simultaneous_incongruences_evaluate_invalid_config() {
     let p = example_problem();
-    assert_eq!(p.evaluate(&[]), Or(false));
-    assert_eq!(p.evaluate(&[0, 1]), Or(false));
+    assert!(crate::registry::DynProblem::evaluate_dyn(&p, &serde_json::json!([])).is_err());
+    assert!(crate::registry::DynProblem::evaluate_dyn(&p, &serde_json::json!([0, 1])).is_err());
 }
 
 #[test]
@@ -68,24 +73,24 @@ fn test_simultaneous_incongruences_empty_pairs() {
     let p = SimultaneousIncongruences::new(vec![]).unwrap();
     assert_eq!(p.num_pairs(), 0);
     assert_eq!(p.lcm_moduli(), 1);
-    assert_eq!(p.dims(), vec![1]);
+    assert_eq!(p.dimensions(), vec![1]);
     // Any x (here x=0) satisfies vacuously
-    assert_eq!(p.evaluate(&[0]), Or(true));
+    assert_eq!(p.evaluate(&0).unwrap(), Or(true));
 }
 
 #[test]
 fn test_simultaneous_incongruences_brute_force_finds_witness() {
     let p = example_problem();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&p).unwrap();
-    assert_eq!(p.evaluate(&witness), Or(true));
+    let witness = solver.solve(&p).unwrap().unwrap();
+    assert_eq!(p.evaluate(&witness).unwrap(), Or(true));
 }
 
 #[test]
 fn test_simultaneous_incongruences_brute_force_no_witness() {
     let p = covering_system();
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&p).is_none());
+    assert!(solver.solve(&p).unwrap().is_none());
 }
 
 #[test]
@@ -120,9 +125,9 @@ fn test_simultaneous_incongruences_deserialization_rejects_invalid() {
 fn test_simultaneous_incongruences_paper_example() {
     // Canonical paper example: pairs [(2,2),(1,3),(2,5),(3,7)], x=5 is a solution
     let p = SimultaneousIncongruences::new(vec![(2, 2), (1, 3), (2, 5), (3, 7)]).unwrap();
-    assert_eq!(p.evaluate(&[5]), Or(true));
+    assert_eq!(p.evaluate(&5).unwrap(), Or(true));
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&p).unwrap();
-    assert_eq!(p.evaluate(&witness), Or(true));
+    let witness = solver.solve(&p).unwrap().unwrap();
+    assert_eq!(p.evaluate(&witness).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/models/algebraic/sparse_matrix_compression.rs b/src/unit_tests/models/algebraic/sparse_matrix_compression.rs
index 2d3b48630..7ee9784c7 100644
--- a/src/unit_tests/models/algebraic/sparse_matrix_compression.rs
+++ b/src/unit_tests/models/algebraic/sparse_matrix_compression.rs
@@ -1,4 +1,15 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_zero_bound() {
+    assert_eq!(SparseMatrixCompressionCreateSpec::FIELDS[1].name, "bound_k");
+    let result = SparseMatrixCompression::try_from(SparseMatrixCompressionCreateSpec {
+        matrix: vec![vec![true]],
+        bound_k: 0,
+    });
+    assert!(result.is_err());
+}
 use crate::registry::VariantEntry;
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
@@ -21,7 +32,7 @@ fn test_sparse_matrix_compression_basic() {
     assert_eq!(problem.num_cols(), 4);
     assert_eq!(problem.bound_k(), 2);
     assert_eq!(problem.storage_len(), 6);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(
         <SparseMatrixCompression as Problem>::NAME,
         "SparseMatrixCompression"
@@ -33,7 +44,7 @@ fn test_sparse_matrix_compression_basic() {
 fn test_sparse_matrix_compression_issue_example_is_satisfying() {
     let problem = SparseMatrixCompression::new(issue_example_matrix(), 2);
 
-    assert!(problem.evaluate(&[1, 1, 1, 0]));
+    assert!(problem.evaluate(&vec![1, 1, 1, 0]).unwrap());
     assert_eq!(
         problem
             .storage_vector(&[1, 1, 1, 0])
@@ -46,18 +57,27 @@ fn test_sparse_matrix_compression_issue_example_is_satisfying() {
 fn test_sparse_matrix_compression_issue_unsatisfying_examples() {
     let problem = SparseMatrixCompression::new(issue_example_matrix(), 2);
 
-    assert!(!problem.evaluate(&[0, 0, 0, 0]));
-    assert!(!problem.evaluate(&[0, 1, 1, 1]));
-    assert!(!problem.evaluate(&[1, 1, 1, 1]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 0]).unwrap());
+    assert!(!problem.evaluate(&vec![0, 1, 1, 1]).unwrap());
+    assert!(!problem.evaluate(&vec![1, 1, 1, 1]).unwrap());
 }
 
 #[test]
 fn test_sparse_matrix_compression_rejects_bad_configs() {
     let problem = SparseMatrixCompression::new(issue_example_matrix(), 2);
 
-    assert!(!problem.evaluate(&[1, 1, 1]));
-    assert!(!problem.evaluate(&[1, 1, 1, 0, 0]));
-    assert!(!problem.evaluate(&[2, 1, 1, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![1, 1, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![1, 1, 1, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![2, 1, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     assert!(problem.storage_vector(&[2, 1, 1, 0]).is_none());
 }
 
@@ -67,11 +87,12 @@ fn test_sparse_matrix_compression_bruteforce_finds_unique_solution() {
     let solver = BruteForce::new();
 
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("issue example should be satisfiable");
     assert_eq!(solution, vec![1, 1, 1, 0]);
 
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all, vec![vec![1, 1, 1, 0]]);
 }
 
diff --git a/src/unit_tests/models/decision.rs b/src/unit_tests/models/decision.rs
index e78a2d19b..9bce00a5b 100644
--- a/src/unit_tests/models/decision.rs
+++ b/src/unit_tests/models/decision.rs
@@ -1,11 +1,12 @@
 use crate::models::decision::Decision;
 use crate::models::graph::{MaximumIndependentSet, MinimumDominatingSet, MinimumVertexCover};
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::{One, Or};
 
-fn triangle_mvc() -> MinimumVertexCover<SimpleGraph, i32> {
+fn triangle_mvc() -> MinimumVertexCover<SimpleGraph, i64> {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
     MinimumVertexCover::new(graph, vec![1; 3])
 }
@@ -23,22 +24,46 @@ fn test_decision_min_creation() {
     assert_eq!(decision.inner().num_vertices(), 3);
 }
 
+#[test]
+fn decision_parameters_are_exactly_the_inner_problem_parameters() {
+    let inner = triangle_mvc();
+    let expected_names = MinimumVertexCover::<SimpleGraph, i64>::parameter_names();
+    let expected_parameters = inner.parameters();
+    let decision = Decision::new(inner, -1);
+
+    assert_eq!(
+        Decision::<MinimumVertexCover<SimpleGraph, i64>>::parameter_names(),
+        expected_names
+    );
+    assert_eq!(decision.parameters(), expected_parameters);
+    assert_eq!(decision.parameters().get("bound"), None);
+}
+
 #[test]
 fn test_decision_min_evaluate_feasible() {
     let decision = Decision::new(triangle_mvc(), 2);
-    assert_eq!(decision.evaluate(&[1, 1, 0]), Or(true));
+    assert_eq!(
+        decision.evaluate(&vec![true, true, false]).unwrap(),
+        Or(true)
+    );
 }
 
 #[test]
 fn test_decision_min_evaluate_infeasible_cost() {
     let decision = Decision::new(triangle_mvc(), 1);
-    assert_eq!(decision.evaluate(&[1, 1, 0]), Or(false));
+    assert_eq!(
+        decision.evaluate(&vec![true, true, false]).unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
 fn test_decision_min_evaluate_infeasible_config() {
     let decision = Decision::new(triangle_mvc(), 3);
-    assert_eq!(decision.evaluate(&[1, 0, 0]), Or(false));
+    assert_eq!(
+        decision.evaluate(&vec![true, false, false]).unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
@@ -46,34 +71,87 @@ fn test_decision_max_evaluate() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
     let mis = MaximumIndependentSet::new(graph, vec![1; 4]);
     let decision = Decision::new(mis, 2);
-    assert_eq!(decision.evaluate(&[1, 0, 1, 0]), Or(true));
-    assert_eq!(decision.evaluate(&[1, 0, 0, 0]), Or(false));
+    assert_eq!(
+        decision.evaluate(&vec![true, false, true, false]).unwrap(),
+        Or(true)
+    );
+    assert_eq!(
+        decision.evaluate(&vec![true, false, false, false]).unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
 fn test_decision_dims() {
     let decision = Decision::new(triangle_mvc(), 2);
-    assert_eq!(decision.dims(), vec![2, 2, 2]);
+    assert_eq!(decision.dimensions(), vec![2, 2, 2]);
 }
 
 #[test]
 fn test_decision_solver() {
     let decision = Decision::new(triangle_mvc(), 2);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&decision);
+    let witness = solver.solve(&decision).unwrap();
     assert!(witness.is_some());
     let config = witness.unwrap();
-    assert_eq!(decision.evaluate(&config), Or(true));
+    assert_eq!(decision.evaluate(&config).unwrap(), Or(true));
 }
 
 #[test]
 fn test_decision_serialization() {
     let decision = Decision::new(triangle_mvc(), 2);
     let json = serde_json::to_string(&decision).unwrap();
-    let deserialized: Decision<MinimumVertexCover<SimpleGraph, i32>> =
+    let deserialized: Decision<MinimumVertexCover<SimpleGraph, i64>> =
         serde_json::from_str(&json).unwrap();
     assert_eq!(deserialized.bound(), &2);
-    assert_eq!(deserialized.evaluate(&[1, 1, 0]), Or(true));
+    assert_eq!(
+        deserialized.evaluate(&vec![true, true, false]).unwrap(),
+        Or(true)
+    );
+}
+
+#[test]
+fn construction_contract_decision_uses_flat_inner_fields() {
+    let inner = triangle_mvc();
+    let mut flat = serde_json::to_value(&inner)
+        .unwrap()
+        .as_object()
+        .unwrap()
+        .clone();
+    flat.insert("bound".to_string(), serde_json::json!(2));
+    let variant = crate::export::variant_to_map(
+        <Decision<MinimumVertexCover<SimpleGraph, i64>> as Problem>::variant(),
+    );
+
+    let constructed = crate::registry::construct_dyn(
+        "DecisionMinimumVertexCover",
+        &variant,
+        serde_json::Value::Object(flat),
+    )
+    .unwrap();
+    let canonical = constructed.serialize_json();
+
+    assert!(canonical.get("inner").is_some());
+    assert_eq!(canonical["bound"], serde_json::json!(2));
+    assert_eq!(canonical["inner"]["weights"], serde_json::json!([1, 1, 1]));
+}
+
+#[test]
+fn construction_contract_decision_rejects_nested_persisted_shape() {
+    let variant = crate::export::variant_to_map(
+        <Decision<MinimumVertexCover<SimpleGraph, i64>> as Problem>::variant(),
+    );
+    let error = crate::registry::construct_dyn(
+        "DecisionMinimumVertexCover",
+        &variant,
+        serde_json::json!({"inner": triangle_mvc(), "bound": 2}),
+    )
+    .err()
+    .expect("nested persisted shape must not be accepted for construction");
+
+    assert!(error
+        .to_string()
+        .contains("unknown construction input(s): inner"));
 }
 
 #[test]
@@ -81,15 +159,17 @@ fn test_decision_reduce_to_aggregate() {
     use crate::rules::{AggregateReductionResult, ReduceToAggregate};
 
     let decision = Decision::new(triangle_mvc(), 2);
-    let result = decision.reduce_to_aggregate();
+    let result = decision
+        .reduce_to_aggregate()
+        .expect("reduction should succeed");
     let target = result.target_problem();
     assert_eq!(target.num_vertices(), 3);
 
-    let target_val = target.evaluate(&[1, 1, 0]);
+    let target_val = target.evaluate(&vec![true, true, false]).unwrap();
     let source_val = result.extract_value(target_val);
     assert_eq!(source_val, Or(true));
 
-    let target_val = target.evaluate(&[1, 1, 1]);
+    let target_val = target.evaluate(&vec![true, true, true]).unwrap();
     let source_val = result.extract_value(target_val);
     assert_eq!(source_val, Or(false));
 }
@@ -99,16 +179,14 @@ fn test_decision_reduce_to_aggregate_infeasible_bound() {
     use crate::rules::{AggregateReductionResult, ReduceToAggregate};
 
     let decision = Decision::new(triangle_mvc(), 1);
-    let result = decision.reduce_to_aggregate();
+    let result = decision
+        .reduce_to_aggregate()
+        .expect("reduction should succeed");
     let target = result.target_problem();
 
     for mask in 0..8 {
-        let config = vec![
-            (mask & 0b001 != 0) as usize,
-            (mask & 0b010 != 0) as usize,
-            (mask & 0b100 != 0) as usize,
-        ];
-        let target_val = target.evaluate(&config);
+        let config = vec![mask & 0b001 != 0, mask & 0b010 != 0, mask & 0b100 != 0];
+        let target_val = target.evaluate(&config).unwrap();
         let source_val = result.extract_value(target_val);
         assert_eq!(
             source_val,
@@ -129,13 +207,23 @@ fn test_decision_mds_creation() {
 #[test]
 fn test_decision_mds_evaluate_feasible() {
     let decision = Decision::new(star_mds(), 1);
-    assert_eq!(decision.evaluate(&[1, 0, 0, 0, 0]), Or(true));
+    assert_eq!(
+        decision
+            .evaluate(&vec![true, false, false, false, false])
+            .unwrap(),
+        Or(true)
+    );
 }
 
 #[test]
 fn test_decision_mds_evaluate_infeasible_cost() {
     let decision = Decision::new(star_mds(), 0);
-    assert_eq!(decision.evaluate(&[1, 0, 0, 0, 0]), Or(false));
+    assert_eq!(
+        decision
+            .evaluate(&vec![true, false, false, false, false])
+            .unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
@@ -143,15 +231,21 @@ fn test_decision_mds_reduce_to_aggregate() {
     use crate::rules::{AggregateReductionResult, ReduceToAggregate};
 
     let decision = Decision::new(star_mds(), 1);
-    let result = decision.reduce_to_aggregate();
+    let result = decision
+        .reduce_to_aggregate()
+        .expect("reduction should succeed");
     let target = result.target_problem();
     assert_eq!(target.num_vertices(), 5);
 
-    let target_val = target.evaluate(&[1, 0, 0, 0, 0]);
+    let target_val = target
+        .evaluate(&vec![true, false, false, false, false])
+        .unwrap();
     let source_val = result.extract_value(target_val);
     assert_eq!(source_val, Or(true));
 
-    let target_val = target.evaluate(&[1, 1, 0, 0, 0]);
+    let target_val = target
+        .evaluate(&vec![true, true, false, false, false])
+        .unwrap();
     let source_val = result.extract_value(target_val);
     assert_eq!(source_val, Or(false));
 }
@@ -160,8 +254,105 @@ fn test_decision_mds_reduce_to_aggregate() {
 fn test_decision_mds_solver() {
     let decision = Decision::new(star_mds(), 1);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&decision);
+    let witness = solver.solve(&decision).unwrap();
     assert!(witness.is_some());
     let config = witness.unwrap();
-    assert_eq!(decision.evaluate(&config), Or(true));
+    assert_eq!(decision.evaluate(&config).unwrap(), Or(true));
+}
+
+#[test]
+fn test_decision_mis_unit_registration_and_construction() {
+    use crate::models::decision::DecisionCreateSpec;
+    use crate::registry::CreateSpec;
+    type Unit = MaximumIndependentSet<SimpleGraph, One>;
+    type Weighted = MaximumIndependentSet<SimpleGraph, i64>;
+    let entries: Vec<_> = crate::registry::variant_entries()
+        .into_iter()
+        .filter(|e| e.name == "DecisionMaximumIndependentSet")
+        .collect();
+    assert_eq!(entries.len(), 2);
+    let defaults: Vec<_> = entries.iter().filter(|e| e.is_default).collect();
+    assert_eq!(defaults.len(), 1);
+    assert_eq!(
+        defaults[0].variant(),
+        vec![("graph", "SimpleGraph"), ("weight", "i64")]
+    );
+    assert!(!DecisionCreateSpec::<Unit>::inputs()
+        .iter()
+        .any(|input| input.name == "weights"));
+    assert!(DecisionCreateSpec::<Weighted>::inputs()
+        .iter()
+        .any(|input| input.name == "weights"));
+    let data = serde_json::json!({"graph":[[0,1],[1,2]],"bound":2});
+    let spec: DecisionCreateSpec<Unit> = serde_json::from_value(data.clone()).unwrap();
+    let decision: Decision<Unit> = spec.into();
+    assert_eq!(decision.evaluate(&vec![true, false, true]), Ok(Or(true)));
+    let witness = BruteForce::new().solve(&decision).unwrap().unwrap();
+    assert_eq!(decision.evaluate(&witness), Ok(Or(true)));
+    let entry = entries.into_iter().find(|e| !e.is_default).unwrap();
+    assert!((entry.complexity_eval_fn)(&decision) > 1.0);
+    assert_eq!(
+        (entry.parameter_measure_fn)(&decision),
+        decision.parameters()
+    );
+    let mut invalid = data;
+    invalid["weights"] = serde_json::json!([1, 1, 1]);
+    assert!(serde_json::from_value::<DecisionCreateSpec<Unit>>(invalid).is_err());
+}
+
+#[test]
+fn test_decision_mis_unit_dynamic_identity_edges() {
+    let decision = Decision::new(
+        MaximumIndependentSet::new(SimpleGraph::path(3), vec![One; 3]),
+        2,
+    );
+    let variant = Decision::<MaximumIndependentSet<SimpleGraph, One>>::variant();
+    let entries = crate::rules::registry::reduction_entries();
+    let edge = entries
+        .iter()
+        .find(|e| {
+            e.source_name == "DecisionMaximumIndependentSet"
+                && e.target_name == "MaximumIndependentSet"
+                && (e.source_variant_fn)() == variant
+        })
+        .unwrap();
+    assert_eq!((edge.parameter_declarations_fn)().fields.len(), 2);
+    let witness = vec![true, false, true];
+    let reduced = (edge.reduce_fn.unwrap())(&decision).unwrap();
+    assert_eq!(
+        *reduced
+            .extract_solution_dyn(&witness)
+            .unwrap()
+            .downcast::<Vec<bool>>()
+            .unwrap(),
+        witness
+    );
+    assert!(matches!(
+        (edge.reduce_fn.unwrap())(decision.inner()),
+        Err(crate::rules::ReductionError::SourceTypeMismatch { .. })
+    ));
+    let aggregate = (edge.reduce_aggregate_fn.unwrap())(&decision).unwrap();
+    assert_eq!(
+        *aggregate
+            .extract_value_from_solution_dyn(&witness)
+            .unwrap()
+            .downcast::<Or>()
+            .unwrap(),
+        Or(true)
+    );
+    assert!(matches!(
+        (edge.reduce_aggregate_fn.unwrap())(decision.inner()),
+        Err(crate::rules::ReductionError::SourceTypeMismatch { .. })
+    ));
+    let reverse = entries
+        .iter()
+        .find(|e| {
+            e.source_name == "MaximumIndependentSet"
+                && e.target_name == "DecisionMaximumIndependentSet"
+                && (e.source_variant_fn)() == variant
+        })
+        .unwrap();
+    assert!(reverse.turing);
+    assert!(reverse.reduce_fn.is_none());
+    assert_eq!((reverse.parameter_declarations_fn)().fields.len(), 2);
 }
diff --git a/src/unit_tests/models/formula/circuit.rs b/src/unit_tests/models/formula/circuit.rs
index 137829ba9..8e692d141 100644
--- a/src/unit_tests/models/formula/circuit.rs
+++ b/src/unit_tests/models/formula/circuit.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -123,7 +124,7 @@ fn test_circuit_sat_creation() {
     )]);
     let problem = CircuitSAT::new(circuit);
     assert_eq!(problem.num_variables(), 3); // c, x, y
-    assert_eq!(problem.dims(), vec![2, 2, 2]); // binary variables
+    assert_eq!(problem.dimensions(), vec![2, 2, 2]); // binary variables
 }
 
 #[test]
@@ -137,13 +138,13 @@ fn test_circuit_sat_evaluate() {
 
     // Variables sorted: c, x, y
     // c=1, x=1, y=1 -> c = 1 AND 1 = 1, valid
-    assert!(problem.evaluate(&[1, 1, 1]));
+    assert!(problem.evaluate(&vec![true, true, true]).unwrap());
 
     // c=0, x=0, y=0 -> c = 0 AND 0 = 0, valid
-    assert!(problem.evaluate(&[0, 0, 0]));
+    assert!(problem.evaluate(&vec![false, false, false]).unwrap());
 
     // c=1, x=0, y=0 -> c should be 0, but c=1, invalid
-    assert!(!problem.evaluate(&[1, 0, 0]));
+    assert!(!problem.evaluate(&vec![true, false, false]).unwrap());
 }
 
 #[test]
@@ -156,12 +157,12 @@ fn test_circuit_sat_brute_force() {
     let problem = CircuitSAT::new(circuit);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // All satisfying: c matches x AND y
     // 4 valid configs: (0,0,0), (0,0,1), (0,1,0), (1,1,1)
     assert_eq!(solutions.len(), 4);
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -182,10 +183,10 @@ fn test_circuit_sat_complex() {
     let problem = CircuitSAT::new(circuit);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // All valid solutions satisfy both assignments
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -211,7 +212,7 @@ fn test_empty_circuit() {
     let circuit = Circuit::new(vec![]);
     let problem = CircuitSAT::new(circuit);
     // Empty circuit is trivially satisfied
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -226,14 +227,14 @@ fn test_circuit_sat_problem() {
     let p = CircuitSAT::new(circuit);
 
     // Variables sorted: c, x, y
-    assert_eq!(p.dims(), vec![2, 2, 2]);
+    assert_eq!(p.dimensions(), vec![2, 2, 2]);
 
     // c=1, x=1, y=1: c = 1 AND 1 = 1 => satisfied
-    assert!(p.evaluate(&[1, 1, 1]));
+    assert!(p.evaluate(&vec![true, true, true]).unwrap());
     // c=0, x=0, y=0: c = 0 AND 0 = 0 => satisfied (c=0 matches)
-    assert!(p.evaluate(&[0, 0, 0]));
+    assert!(p.evaluate(&vec![false, false, false]).unwrap());
     // c=1, x=1, y=0: c = 1 AND 0 = 0 != 1 => not satisfied
-    assert!(!p.evaluate(&[1, 1, 0]));
+    assert!(!p.evaluate(&vec![true, true, false]).unwrap());
 }
 
 #[test]
@@ -246,13 +247,17 @@ fn test_is_valid_solution() {
     let problem = CircuitSAT::new(circuit);
     // Variables sorted: c, x, y
     // Valid: c=1, x=1, y=1 (c = 1 AND 1 = 1)
-    assert!(problem.is_valid_solution(&[1, 1, 1]));
+    assert!(problem.is_valid_solution(&[true, true, true]).unwrap());
     // Invalid: c=1, x=1, y=0 (c = 1 AND 0 = 0, but c=1)
-    assert!(!problem.is_valid_solution(&[1, 1, 0]));
+    assert!(!problem.is_valid_solution(&[true, true, false]).unwrap());
+    assert!(matches!(
+        problem.is_valid_solution(&[true, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     // c = x AND y → variables: c, x, y
     let circuit = Circuit::new(vec![Assignment::new(
         vec!["c".to_string()],
@@ -260,6 +265,8 @@ fn test_size_getters() {
     )]);
     let problem = CircuitSAT::new(circuit);
     assert_eq!(problem.num_variables(), 3);
+    assert_eq!(problem.num_expression_nodes(), 3);
+    assert_eq!(problem.num_assignment_outputs(), 1);
 }
 
 #[test]
@@ -284,12 +291,16 @@ fn test_circuit_sat_paper_example() {
     // Variables sorted: a, b, c, x1, x2
     // Paper satisfying inputs (output c=1): (x1=0,x2=1) and (x1=1,x2=0)
     // (x1=0,x2=1): a=0, b=1, c=1 → config [0, 1, 1, 0, 1]
-    assert!(problem.evaluate(&[0, 1, 1, 0, 1]));
+    assert!(problem
+        .evaluate(&vec![false, true, true, false, true])
+        .unwrap());
     // (x1=1,x2=0): a=0, b=1, c=1 → config [0, 1, 1, 1, 0]
-    assert!(problem.evaluate(&[0, 1, 1, 1, 0]));
+    assert!(problem
+        .evaluate(&vec![false, true, true, true, false])
+        .unwrap());
 
     // All 4 consistent configs are satisfying (CircuitSAT checks consistency)
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all.len(), 4);
 }
diff --git a/src/unit_tests/models/formula/ksat.rs b/src/unit_tests/models/formula/ksat.rs
index eaad41707..4ec78e2a4 100644
--- a/src/unit_tests/models/formula/ksat.rs
+++ b/src/unit_tests/models/formula/ksat.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::variant::{K2, K3, KN};
 include!("../../jl_helpers.rs");
@@ -60,11 +61,11 @@ fn test_3sat_brute_force() {
         ],
     );
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
 
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -98,9 +99,9 @@ fn test_ksat_count_satisfied() {
         ],
     );
     // x1=T, x2=T, x3=T: first satisfied, second not
-    assert_eq!(problem.count_satisfied(&[true, true, true]), 1);
+    assert_eq!(problem.count_satisfied(&[true, true, true]).unwrap(), 1);
     // x1=T, x2=F, x3=F: both satisfied
-    assert_eq!(problem.count_satisfied(&[true, false, false]), 2);
+    assert_eq!(problem.count_satisfied(&[true, false, false]).unwrap(), 2);
 }
 
 #[test]
@@ -112,8 +113,8 @@ fn test_ksat_evaluate() {
             CNFClause::new(vec![-1, -2, -3]),
         ],
     );
-    assert!(problem.evaluate(&[1, 0, 0])); // x1=T, x2=F, x3=F
-    assert!(!problem.evaluate(&[1, 1, 1])); // x1=T, x2=T, x3=T
+    assert!(problem.evaluate(&vec![true, false, false]).unwrap()); // x1=T, x2=F, x3=F
+    assert!(!problem.evaluate(&vec![true, true, true]).unwrap()); // x1=T, x2=T, x3=T
 }
 
 #[test]
@@ -128,11 +129,11 @@ fn test_ksat_problem_v2() {
         ],
     );
 
-    assert_eq!(p.dims(), vec![2, 2, 2]);
-    assert!(p.evaluate(&[1, 0, 0]));
-    assert!(!p.evaluate(&[1, 1, 1]));
-    assert!(!p.evaluate(&[0, 0, 0]));
-    assert!(p.evaluate(&[1, 0, 1]));
+    assert_eq!(p.dimensions(), vec![2, 2, 2]);
+    assert!(p.evaluate(&vec![true, false, false]).unwrap());
+    assert!(!p.evaluate(&vec![true, true, true]).unwrap());
+    assert!(!p.evaluate(&vec![false, false, false]).unwrap());
+    assert!(p.evaluate(&vec![true, false, true]).unwrap());
     assert_eq!(<KSatisfiability<K3> as Problem>::NAME, "KSatisfiability");
 }
 
@@ -145,11 +146,11 @@ fn test_ksat_problem_v2_2sat() {
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1, -2])],
     );
 
-    assert_eq!(p.dims(), vec![2, 2]);
-    assert!(p.evaluate(&[1, 0]));
-    assert!(p.evaluate(&[0, 1]));
-    assert!(!p.evaluate(&[1, 1]));
-    assert!(!p.evaluate(&[0, 0]));
+    assert_eq!(p.dimensions(), vec![2, 2]);
+    assert!(p.evaluate(&vec![true, false]).unwrap());
+    assert!(p.evaluate(&vec![false, true]).unwrap());
+    assert!(!p.evaluate(&vec![true, true]).unwrap());
+    assert!(!p.evaluate(&vec![false, false]).unwrap());
 }
 
 #[test]
@@ -163,8 +164,8 @@ fn test_jl_parity_evaluation() {
         let num_clauses = instance["instance"]["clauses"].as_array().unwrap().len();
         let problem = KSatisfiability::<K3>::new(num_vars, clauses);
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let rust_result = problem.evaluate(&config);
+            let config = jl_parse_bool_config(&eval["config"]);
+            let rust_result = problem.evaluate(&config).unwrap();
             let jl_size = eval["size"].as_u64().unwrap() as usize;
             assert_eq!(
                 rust_result,
@@ -173,9 +174,9 @@ fn test_jl_parity_evaluation() {
                 config
             );
         }
-        let rust_best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best_set: HashSet<Vec<usize>> = rust_best.into_iter().collect();
+        let rust_best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best_set: HashSet<Vec<bool>> = rust_best.into_iter().collect();
         assert_eq!(rust_best_set, jl_best, "KSat best solutions mismatch");
     }
 }
@@ -193,7 +194,7 @@ fn test_kn_creation() {
     );
     assert_eq!(problem.num_vars(), 3);
     assert_eq!(problem.num_clauses(), 3);
-    assert!(problem.evaluate(&[1, 0, 0])); // x1=T, x2=F, x3=F
+    assert!(problem.evaluate(&vec![true, false, false]).unwrap()); // x1=T, x2=F, x3=F
 }
 
 #[test]
@@ -208,13 +209,17 @@ fn test_kn_from_k3_clauses() {
     );
     let kn = KSatisfiability::<KN>::new(k3.num_vars(), k3.clauses().to_vec());
     // Both should agree on evaluations
-    for config in &[[1, 0, 0], [0, 1, 0], [1, 1, 1]] {
-        assert_eq!(k3.evaluate(config), kn.evaluate(config));
+    for config in &[
+        vec![true, false, false],
+        vec![false, true, false],
+        vec![true, true, true],
+    ] {
+        assert_eq!(k3.evaluate(config).unwrap(), kn.evaluate(config).unwrap());
     }
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = KSatisfiability::<K3>::new(
         3,
         vec![
@@ -238,9 +243,9 @@ fn test_ksat_paper_example() {
             CNFClause::new(vec![1, -2, -3]),
         ],
     );
-    assert!(problem.evaluate(&[1, 0, 1]));
+    assert!(problem.evaluate(&vec![true, false, true]).unwrap());
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
 }
diff --git a/src/unit_tests/models/formula/maximum_2_satisfiability.rs b/src/unit_tests/models/formula/maximum_2_satisfiability.rs
index 32b1dc168..fec3102ca 100644
--- a/src/unit_tests/models/formula/maximum_2_satisfiability.rs
+++ b/src/unit_tests/models/formula/maximum_2_satisfiability.rs
@@ -1,6 +1,7 @@
 use super::*;
 use crate::models::formula::CNFClause;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Max;
 
@@ -24,7 +25,7 @@ fn test_maximum_2_satisfiability_creation() {
     let problem = issue_instance();
     assert_eq!(problem.num_vars(), 4);
     assert_eq!(problem.num_clauses(), 7);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
 }
 
 #[test]
@@ -37,7 +38,10 @@ fn test_maximum_2_satisfiability_wrong_clause_size() {
 fn test_maximum_2_satisfiability_evaluate_optimal() {
     let problem = issue_instance();
     // x1=T, x2=T, x3=F, x4=T → config [1,1,0,1]
-    assert_eq!(problem.evaluate(&[1, 1, 0, 1]), Max(Some(6)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false, true]).unwrap(),
+        Max(Some(6))
+    );
 }
 
 #[test]
@@ -45,7 +49,10 @@ fn test_maximum_2_satisfiability_evaluate_all_true() {
     let problem = issue_instance();
     // All true: [1,1,1,1]
     // (1∨2)=T, (1∨¬2)=T, (¬1∨3)=T, (¬1∨¬3)=F, (2∨4)=T, (¬3∨¬4)=F, (3∨4)=T → 5
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1]), Max(Some(5)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true, true]).unwrap(),
+        Max(Some(5))
+    );
 }
 
 #[test]
@@ -53,14 +60,18 @@ fn test_maximum_2_satisfiability_evaluate_all_false() {
     let problem = issue_instance();
     // All false: [0,0,0,0]
     // (1∨2)=F, (1∨¬2)=T, (¬1∨3)=T, (¬1∨¬3)=T, (2∨4)=F, (¬3∨¬4)=T, (3∨4)=F → 4
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Max(Some(4)));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false, false]).unwrap(),
+        Max(Some(4))
+    );
 }
 
 #[test]
 fn test_maximum_2_satisfiability_solver() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Max(Some(6)));
 }
 
@@ -68,9 +79,9 @@ fn test_maximum_2_satisfiability_solver() {
 fn test_maximum_2_satisfiability_witness() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
-    assert_eq!(problem.evaluate(&witness.unwrap()), Max(Some(6)));
+    assert_eq!(problem.evaluate(&witness.unwrap()).unwrap(), Max(Some(6)));
 }
 
 #[test]
@@ -80,12 +91,15 @@ fn test_maximum_2_satisfiability_serialization() {
     let restored: Maximum2Satisfiability = serde_json::from_str(&json).unwrap();
     assert_eq!(restored.num_vars(), 4);
     assert_eq!(restored.num_clauses(), 7);
-    assert_eq!(restored.evaluate(&[1, 1, 0, 1]), Max(Some(6)));
+    assert_eq!(
+        restored.evaluate(&vec![true, true, false, true]).unwrap(),
+        Max(Some(6))
+    );
 }
 
 #[test]
 fn test_maximum_2_satisfiability_count_satisfied() {
     let problem = issue_instance();
     let assignment = vec![true, true, false, true];
-    assert_eq!(problem.count_satisfied(&assignment), 6);
+    assert_eq!(problem.count_satisfied(&assignment).unwrap(), 6);
 }
diff --git a/src/unit_tests/models/formula/nae_satisfiability.rs b/src/unit_tests/models/formula/nae_satisfiability.rs
index 51fcf6e7e..1e164b6ee 100644
--- a/src/unit_tests/models/formula/nae_satisfiability.rs
+++ b/src/unit_tests/models/formula/nae_satisfiability.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use std::collections::HashSet;
 
@@ -30,33 +31,41 @@ fn test_nae_satisfiability_creation() {
 fn test_nae_clause_requires_true_and_false_literals() {
     let problem = NAESatisfiability::new(3, vec![CNFClause::new(vec![1, 2, -3])]);
 
-    assert!(problem.evaluate(&[0, 0, 0]));
-    assert!(!problem.evaluate(&[1, 1, 0]));
-    assert!(!problem.evaluate(&[0, 0, 1]));
+    assert!(problem.evaluate(&vec![false, false, false]).unwrap());
+    assert!(!problem.evaluate(&vec![true, true, false]).unwrap());
+    assert!(!problem.evaluate(&vec![false, false, true]).unwrap());
 }
 
 #[test]
 fn test_nae_clause_with_literal_and_negation_is_always_satisfied() {
     let problem = NAESatisfiability::new(1, vec![CNFClause::new(vec![1, -1])]);
 
-    assert!(problem.evaluate(&[0]));
-    assert!(problem.evaluate(&[1]));
+    assert!(problem.evaluate(&vec![false]).unwrap());
+    assert!(problem.evaluate(&vec![true]).unwrap());
 }
 
 #[test]
 fn test_nae_satisfying_example_from_issue() {
     let problem = issue_problem();
 
-    assert!(problem.evaluate(&[0, 0, 0, 1, 1]));
-    assert!(problem.is_valid_solution(&[0, 0, 0, 1, 1]));
+    assert!(problem
+        .evaluate(&vec![false, false, false, true, true])
+        .unwrap());
+    assert!(problem
+        .is_valid_solution(&[false, false, false, true, true])
+        .unwrap());
 }
 
 #[test]
 fn test_nae_complement_symmetry_for_issue_example() {
     let problem = issue_problem();
 
-    assert!(problem.evaluate(&[0, 0, 0, 1, 1]));
-    assert!(problem.evaluate(&[1, 1, 1, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![false, false, false, true, true])
+        .unwrap());
+    assert!(problem
+        .evaluate(&vec![true, true, true, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -64,12 +73,12 @@ fn test_nae_solver_counts_ten_solutions_for_issue_example() {
     let problem = issue_problem();
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
-    let set: HashSet<Vec<usize>> = solutions.into_iter().collect();
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
+    let set: HashSet<Vec<bool>> = solutions.into_iter().collect();
 
     assert_eq!(set.len(), 10);
-    assert!(set.contains(&vec![0, 0, 0, 1, 1]));
-    assert!(set.contains(&vec![1, 1, 1, 0, 0]));
+    assert!(set.contains(&vec![false, false, false, true, true]));
+    assert!(set.contains(&vec![true, true, true, false, false]));
 }
 
 #[test]
@@ -77,11 +86,11 @@ fn test_nae_empty_formula_is_trivially_satisfying() {
     let problem = NAESatisfiability::new(0, vec![]);
     let solver = BruteForce::new();
 
-    assert!(problem.evaluate(&[]));
-    assert_eq!(solver.find_witness(&problem), Some(vec![]));
+    assert!(problem.evaluate(&vec![]).unwrap());
+    assert_eq!(solver.solve(&problem).unwrap(), Some(vec![]));
     assert_eq!(
-        solver.find_all_witnesses(&problem),
-        vec![Vec::<usize>::new()]
+        solver.find_all_witnesses(&problem).unwrap(),
+        vec![Vec::<bool>::new()]
     );
 }
 
@@ -107,7 +116,9 @@ fn test_nae_get_clause_and_num_literals() {
     assert_eq!(problem.get_clause(0), Some(&CNFClause::new(vec![1, 2, -3])));
     assert_eq!(problem.get_clause(5), None);
     assert_eq!(
-        problem.count_nae_satisfied(&[false, false, false, true, true]),
+        problem
+            .count_nae_satisfied(&[false, false, false, true, true])
+            .unwrap(),
         5
     );
 }
@@ -121,7 +132,9 @@ fn test_nae_serialization_round_trip() {
     assert_eq!(round_trip.num_vars(), problem.num_vars());
     assert_eq!(round_trip.num_clauses(), problem.num_clauses());
     assert_eq!(round_trip.num_literals(), problem.num_literals());
-    assert!(round_trip.evaluate(&[0, 0, 0, 1, 1]));
+    assert!(round_trip
+        .evaluate(&vec![false, false, false, true, true])
+        .unwrap());
 }
 
 #[test]
@@ -137,7 +150,11 @@ fn test_nae_satisfiability_paper_example() {
     let problem = issue_problem();
     let solver = BruteForce::new();
 
-    assert!(problem.evaluate(&[0, 0, 0, 1, 1]));
-    assert!(problem.evaluate(&[1, 1, 1, 0, 0]));
-    assert_eq!(solver.find_all_witnesses(&problem).len(), 10);
+    assert!(problem
+        .evaluate(&vec![false, false, false, true, true])
+        .unwrap());
+    assert!(problem
+        .evaluate(&vec![true, true, true, false, false])
+        .unwrap());
+    assert_eq!(solver.find_all_witnesses(&problem).unwrap().len(), 10);
 }
diff --git a/src/unit_tests/models/formula/non_tautology.rs b/src/unit_tests/models/formula/non_tautology.rs
index 5a455af28..f3c41161a 100644
--- a/src/unit_tests/models/formula/non_tautology.rs
+++ b/src/unit_tests/models/formula/non_tautology.rs
@@ -1,69 +1,70 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
 fn test_non_tautology_creation() {
-    let problem = NonTautology::new(3, vec![vec![1, 2, 3], vec![-1, -2, -3]]);
+    let problem = NonTautology::new(3, vec![vec![1, 2, 3], vec![-1, -2, -3]]).unwrap();
     assert_eq!(problem.num_vars(), 3);
     assert_eq!(problem.num_disjuncts(), 2);
     assert_eq!(problem.num_variables(), 3);
-    assert_eq!(problem.dims(), vec![2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2]);
 }
 
 #[test]
 fn test_non_tautology_evaluate() {
     // (x1 AND x2 AND x3) OR (NOT x1 AND NOT x2 AND NOT x3)
-    let problem = NonTautology::new(3, vec![vec![1, 2, 3], vec![-1, -2, -3]]);
+    let problem = NonTautology::new(3, vec![vec![1, 2, 3], vec![-1, -2, -3]]).unwrap();
 
     // config [1,0,0] -> x1=T, x2=F, x3=F
     // D1: x1=T, x2=F -> D1 false (x2 is false)
     // D2: NOT x1=F -> D2 false (NOT x1 is false)
     // All disjuncts false -> formula is false -> falsifying assignment exists
-    assert!(problem.evaluate(&[1, 0, 0]));
+    assert!(problem.evaluate(&vec![true, false, false]).unwrap());
 
     // config [1,1,1] -> x1=T, x2=T, x3=T
     // D1: all true -> D1 is true -> formula is true -> NOT a falsifying assignment
-    assert!(!problem.evaluate(&[1, 1, 1]));
+    assert!(!problem.evaluate(&vec![true, true, true]).unwrap());
 
     // config [0,0,0] -> x1=F, x2=F, x3=F
     // D2: NOT x1=T, NOT x2=T, NOT x3=T -> D2 is true -> formula is true
-    assert!(!problem.evaluate(&[0, 0, 0]));
+    assert!(!problem.evaluate(&vec![false, false, false]).unwrap());
 }
 
 #[test]
 fn test_non_tautology_solver() {
     // (x1 AND x2 AND x3) OR (NOT x1 AND NOT x2 AND NOT x3)
-    let problem = NonTautology::new(3, vec![vec![1, 2, 3], vec![-1, -2, -3]]);
+    let problem = NonTautology::new(3, vec![vec![1, 2, 3], vec![-1, -2, -3]]).unwrap();
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
 
     // Verify the found solution actually falsifies the formula
     let sol = solution.unwrap();
-    assert!(problem.evaluate(&sol));
+    assert!(problem.evaluate(&sol).unwrap());
 
     // Check all witnesses are valid
-    let all_solutions = solver.find_all_witnesses(&problem);
+    let all_solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all_solutions.is_empty());
     for sol in &all_solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
 #[test]
 fn test_non_tautology_tautological() {
     // (x1) OR (NOT x1) is a tautology — no falsifying assignment exists
-    let problem = NonTautology::new(1, vec![vec![1], vec![-1]]);
+    let problem = NonTautology::new(1, vec![vec![1], vec![-1]]).unwrap();
 
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_non_tautology_serialization() {
-    let problem = NonTautology::new(3, vec![vec![1, 2, 3], vec![-1, -2, -3]]);
+    let problem = NonTautology::new(3, vec![vec![1, 2, 3], vec![-1, -2, -3]]).unwrap();
     let json = serde_json::to_string(&problem).unwrap();
     let deserialized: NonTautology = serde_json::from_str(&json).unwrap();
     assert_eq!(deserialized.num_vars(), 3);
@@ -72,7 +73,7 @@ fn test_non_tautology_serialization() {
 
 #[test]
 fn test_non_tautology_is_falsifying() {
-    let problem = NonTautology::new(3, vec![vec![1, 2], vec![-1, 3], vec![2, -3]]);
+    let problem = NonTautology::new(3, vec![vec![1, 2], vec![-1, 3], vec![2, -3]]).unwrap();
     // x1=F, x2=F, x3=F:
     // D1: x1=F -> false. D2: NOT x1=T, x3=F -> false. D3: x2=F -> false.
     // All false -> falsifying
@@ -84,7 +85,14 @@ fn test_non_tautology_is_falsifying() {
 }
 
 #[test]
-#[should_panic(expected = "outside range")]
 fn test_non_tautology_variable_out_of_range() {
-    NonTautology::new(2, vec![vec![1, 3]]);
+    assert!(NonTautology::new(2, vec![vec![1, 3]]).is_err());
+}
+
+#[test]
+fn test_non_tautology_rejects_unrepresentable_literals_and_invalid_serde() {
+    assert!(NonTautology::new(1, vec![vec![0]]).is_err());
+    assert!(NonTautology::new(1, vec![vec![i64::MIN]]).is_err());
+    let json = r#"{"num_vars":1,"disjuncts":[[0]]}"#;
+    assert!(serde_json::from_str::<NonTautology>(json).is_err());
 }
diff --git a/src/unit_tests/models/formula/one_in_three_satisfiability.rs b/src/unit_tests/models/formula/one_in_three_satisfiability.rs
index e20220e2e..601ee47bc 100644
--- a/src/unit_tests/models/formula/one_in_three_satisfiability.rs
+++ b/src/unit_tests/models/formula/one_in_three_satisfiability.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -15,7 +16,7 @@ fn test_one_in_three_satisfiability_creation() {
     assert_eq!(problem.num_vars(), 4);
     assert_eq!(problem.num_clauses(), 3);
     assert_eq!(problem.num_variables(), 4);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2]);
 }
 
 #[test]
@@ -33,15 +34,15 @@ fn test_one_in_three_satisfiability_evaluate() {
     // Clause 1: (T, F, F) -> exactly 1 true -> OK
     // Clause 2: (F, F, T) -> exactly 1 true -> OK
     // Clause 3: (F, T, F) -> exactly 1 true -> OK
-    assert!(problem.evaluate(&[1, 0, 0, 1]));
+    assert!(problem.evaluate(&vec![true, false, false, true]).unwrap());
 
     // config [1,1,1,0] -> x1=T, x2=T, x3=T, x4=F
     // Clause 1: (T, T, T) -> 3 true -> NOT 1-in-3
-    assert!(!problem.evaluate(&[1, 1, 1, 0]));
+    assert!(!problem.evaluate(&vec![true, true, true, false]).unwrap());
 
     // config [0,0,0,0] -> all false
     // Clause 1: (F, F, F) -> 0 true -> NOT 1-in-3
-    assert!(!problem.evaluate(&[0, 0, 0, 0]));
+    assert!(!problem.evaluate(&vec![false, false, false, false]).unwrap());
 }
 
 #[test]
@@ -56,18 +57,18 @@ fn test_one_in_three_satisfiability_solver() {
     );
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
 
     // Verify the found solution actually satisfies 1-in-3
     let sol = solution.unwrap();
-    assert!(problem.evaluate(&sol));
+    assert!(problem.evaluate(&sol).unwrap());
 
     // Check all witnesses are valid
-    let all_solutions = solver.find_all_witnesses(&problem);
+    let all_solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all_solutions.is_empty());
     for sol in &all_solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -78,7 +79,7 @@ fn test_one_in_three_satisfiability_unsatisfiable() {
     let problem = OneInThreeSatisfiability::new(1, vec![CNFClause::new(vec![1, 1, 1])]);
 
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -118,7 +119,7 @@ fn test_one_in_three_satisfiability_wrong_clause_width() {
 }
 
 #[test]
-#[should_panic(expected = "outside range")]
+#[should_panic(expected = "allowed variable numbers are 1..=2")]
 fn test_one_in_three_satisfiability_variable_out_of_range() {
     OneInThreeSatisfiability::new(2, vec![CNFClause::new(vec![1, 2, 3])]);
 }
diff --git a/src/unit_tests/models/formula/planar_3_satisfiability.rs b/src/unit_tests/models/formula/planar_3_satisfiability.rs
index ccbdffc8f..7ecbe2c52 100644
--- a/src/unit_tests/models/formula/planar_3_satisfiability.rs
+++ b/src/unit_tests/models/formula/planar_3_satisfiability.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -16,7 +17,7 @@ fn test_planar_3_satisfiability_creation() {
     assert_eq!(problem.num_vars(), 4);
     assert_eq!(problem.num_clauses(), 4);
     assert_eq!(problem.num_variables(), 4);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2]);
 }
 
 #[test]
@@ -33,11 +34,11 @@ fn test_planar_3_satisfiability_evaluate() {
 
     // config [1,1,1,0] -> x1=T, x2=T, x3=T, x4=F
     // (T OR T OR T)=T, (F OR T OR F)=T, (T OR F OR F)=T, (F OR T OR T)=T
-    assert!(problem.evaluate(&[1, 1, 1, 0]));
+    assert!(problem.evaluate(&vec![true, true, true, false]).unwrap());
 
     // config [0,0,0,0] -> all false
     // (F OR F OR F)=F -> unsatisfied
-    assert!(!problem.evaluate(&[0, 0, 0, 0]));
+    assert!(!problem.evaluate(&vec![false, false, false, false]).unwrap());
 }
 
 #[test]
@@ -53,18 +54,18 @@ fn test_planar_3_satisfiability_solver() {
     );
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
 
     // Verify the found solution actually satisfies the formula
     let sol = solution.unwrap();
-    assert!(problem.evaluate(&sol));
+    assert!(problem.evaluate(&sol).unwrap());
 
     // Check all witnesses are valid
-    let all_solutions = solver.find_all_witnesses(&problem);
+    let all_solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all_solutions.is_empty());
     for sol in &all_solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -84,7 +85,7 @@ fn test_planar_3_satisfiability_unsatisfiable() {
     );
 
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -135,7 +136,7 @@ fn test_planar_3_satisfiability_wrong_clause_width() {
 }
 
 #[test]
-#[should_panic(expected = "outside range")]
+#[should_panic(expected = "allowed variable numbers are 1..=2")]
 fn test_planar_3_satisfiability_variable_out_of_range() {
     Planar3Satisfiability::new(2, vec![CNFClause::new(vec![1, 2, 3])]);
 }
diff --git a/src/unit_tests/models/formula/qbf.rs b/src/unit_tests/models/formula/qbf.rs
index 136cc967d..32bee8687 100644
--- a/src/unit_tests/models/formula/qbf.rs
+++ b/src/unit_tests/models/formula/qbf.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -46,8 +47,8 @@ fn test_qbf_evaluate_true() {
     );
 
     // dims() is empty; evaluate([]) runs the game-tree search
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&()).unwrap());
     assert!(problem.is_true());
 }
 
@@ -61,7 +62,7 @@ fn test_qbf_evaluate_false() {
         vec![CNFClause::new(vec![1]), CNFClause::new(vec![-1])],
     );
 
-    assert!(!problem.evaluate(&[]));
+    assert!(!problem.evaluate(&()).unwrap());
     assert!(!problem.is_true());
 }
 
@@ -73,7 +74,9 @@ fn test_qbf_evaluate_nonempty_config_returns_false() {
         vec![Quantifier::Exists, Quantifier::ForAll],
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![1, -2])],
     );
-    assert!(!problem.evaluate(&[1, 0]));
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([1, 0])).is_err()
+    );
 }
 
 #[test]
@@ -118,7 +121,7 @@ fn test_qbf_empty_formula() {
     // Empty CNF is trivially true
     let problem =
         QuantifiedBooleanFormulas::new(2, vec![Quantifier::Exists, Quantifier::ForAll], vec![]);
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&()).unwrap());
     assert!(problem.is_true());
 }
 
@@ -126,16 +129,16 @@ fn test_qbf_empty_formula() {
 fn test_qbf_zero_vars() {
     // Zero variables, empty clauses
     let problem = QuantifiedBooleanFormulas::new(0, vec![], vec![]);
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&()).unwrap());
     assert!(problem.is_true());
-    assert_eq!(problem.dims(), Vec::<usize>::new());
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
 }
 
 #[test]
 fn test_qbf_zero_vars_unsat() {
-    // Zero variables, but a clause that refers to var 1 (unsatisfiable)
-    let problem = QuantifiedBooleanFormulas::new(0, vec![], vec![CNFClause::new(vec![1])]);
-    assert!(!problem.evaluate(&[]));
+    // An empty clause is false without referring to a nonexistent variable.
+    let problem = QuantifiedBooleanFormulas::new(0, vec![], vec![CNFClause::new(vec![])]);
+    assert!(!problem.evaluate(&()).unwrap());
     assert!(!problem.is_true());
 }
 
@@ -150,11 +153,11 @@ fn test_qbf_solver() {
 
     let solver = BruteForce::new();
     // With dims()=[], there is exactly one config: []. evaluate([]) = is_true() = true
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    let sol = solution.unwrap();
-    assert_eq!(sol, Vec::<usize>::new());
-    assert!(problem.evaluate(&sol));
+    solution.unwrap();
+    assert_eq!((), ());
+    assert!(problem.evaluate(&()).unwrap());
 }
 
 #[test]
@@ -167,7 +170,7 @@ fn test_qbf_solver_false() {
     );
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
@@ -181,10 +184,10 @@ fn test_qbf_solver_all_satisfying() {
     );
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // Only one config exists (the empty config []), and it satisfies
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], Vec::<usize>::new());
+    assert_eq!(solutions[0], ());
 }
 
 #[test]
@@ -201,7 +204,7 @@ fn test_qbf_serialization() {
     assert_eq!(deserialized.num_vars(), problem.num_vars());
     assert_eq!(deserialized.num_clauses(), problem.num_clauses());
     assert_eq!(deserialized.quantifiers(), problem.quantifiers());
-    assert_eq!(deserialized.dims(), problem.dims());
+    assert_eq!(deserialized.dimensions(), problem.dimensions());
 }
 
 #[test]
@@ -235,7 +238,7 @@ fn test_qbf_dims() {
         vec![CNFClause::new(vec![1, 2, 3, 4])],
     );
     // dims() is always empty — QBF has no external config variables
-    assert_eq!(problem.dims(), Vec::<usize>::new());
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
 }
 
 #[test]
diff --git a/src/unit_tests/models/formula/sat.rs b/src/unit_tests/models/formula/sat.rs
index 29ddad85a..41621a4ca 100644
--- a/src/unit_tests/models/formula/sat.rs
+++ b/src/unit_tests/models/formula/sat.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 include!("../../jl_helpers.rs");
 
@@ -67,9 +68,9 @@ fn test_count_satisfied() {
         ],
     );
 
-    assert_eq!(problem.count_satisfied(&[true, true]), 2); // x1, x2 satisfied
-    assert_eq!(problem.count_satisfied(&[false, false]), 1); // Only last
-    assert_eq!(problem.count_satisfied(&[true, false]), 2); // x1 and last
+    assert_eq!(problem.count_satisfied(&[true, true]).unwrap(), 2); // x1, x2 satisfied
+    assert_eq!(problem.count_satisfied(&[false, false]).unwrap(), 1); // Only last
+    assert_eq!(problem.count_satisfied(&[true, false]).unwrap(), 2); // x1 and last
 }
 
 #[test]
@@ -89,7 +90,7 @@ fn test_is_satisfying_assignment() {
 fn test_empty_formula() {
     let problem = Satisfiability::new(2, vec![]);
     // Empty formula is trivially satisfied
-    assert!(problem.evaluate(&[0, 0]));
+    assert!(problem.evaluate(&vec![false, false]).unwrap());
 }
 
 #[test]
@@ -97,20 +98,20 @@ fn test_empty_formula_zero_vars_solver() {
     let problem = Satisfiability::new(0, vec![]);
     let solver = BruteForce::new();
 
-    assert_eq!(solver.find_witness(&problem), Some(vec![]));
+    assert_eq!(solver.solve(&problem).unwrap(), Some(vec![]));
     assert_eq!(
-        solver.find_all_witnesses(&problem),
-        vec![Vec::<usize>::new()]
+        solver.find_all_witnesses(&problem).unwrap(),
+        vec![Vec::<bool>::new()]
     );
 }
 
 #[test]
 fn test_zero_vars_unsat_solver() {
-    let problem = Satisfiability::new(0, vec![CNFClause::new(vec![1])]);
+    let problem = Satisfiability::new(0, vec![CNFClause::new(vec![])]);
     let solver = BruteForce::new();
 
-    assert_eq!(solver.find_witness(&problem), None);
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+    assert_eq!(solver.solve(&problem).unwrap(), None);
+    assert!(solver.find_all_witnesses(&problem).unwrap().is_empty());
 }
 
 #[test]
@@ -119,9 +120,9 @@ fn test_single_literal_clauses() {
     let problem = Satisfiability::new(2, vec![CNFClause::new(vec![1]), CNFClause::new(vec![-2])]);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![1, 0]); // x1=T, x2=F
+    assert_eq!(solutions[0], vec![true, false]); // x1=T, x2=F
 }
 
 #[test]
@@ -176,8 +177,8 @@ fn test_jl_parity_evaluation() {
         let problem = Satisfiability::new(num_vars, clauses);
         let num_clauses = instance["instance"]["clauses"].as_array().unwrap().len();
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let rust_result = problem.evaluate(&config);
+            let config = jl_parse_bool_config(&eval["config"]);
+            let rust_result = problem.evaluate(&config).unwrap();
             let jl_size = eval["size"].as_u64().unwrap() as usize;
             let jl_all_satisfied = jl_size == num_clauses;
             assert_eq!(
@@ -186,10 +187,10 @@ fn test_jl_parity_evaluation() {
                 config
             );
         }
-        let rust_best = BruteForce::new().find_all_witnesses(&problem);
-        let rust_best_set: HashSet<Vec<usize>> = rust_best.into_iter().collect();
+        let rust_best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let rust_best_set: HashSet<Vec<bool>> = rust_best.into_iter().collect();
         if !rust_best_set.is_empty() {
-            let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
+            let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
             assert_eq!(rust_best_set, jl_best, "SAT best solutions mismatch");
         }
     }
@@ -203,9 +204,9 @@ fn test_is_valid_solution() {
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1, 3])],
     );
     // Valid: x1=F, x2=T, x3=T → (T) AND (T) = T
-    assert!(problem.is_valid_solution(&[0, 1, 1]));
+    assert!(problem.is_valid_solution(&[false, true, true]).unwrap());
     // Invalid: x1=T, x2=F, x3=F → (T) AND (F) = F
-    assert!(!problem.is_valid_solution(&[1, 0, 0]));
+    assert!(!problem.is_valid_solution(&[true, false, false]).unwrap());
 }
 
 #[test]
@@ -220,9 +221,9 @@ fn test_sat_paper_example() {
         ],
     );
     // (1,0,1) → x1=T, x2=F, x3=T
-    assert!(problem.evaluate(&[1, 0, 1]));
+    assert!(problem.evaluate(&vec![true, false, true]).unwrap());
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
 }
diff --git a/src/unit_tests/models/graph/acyclic_partition.rs b/src/unit_tests/models/graph/acyclic_partition.rs
index 70e1d7df8..75ab99132 100644
--- a/src/unit_tests/models/graph/acyclic_partition.rs
+++ b/src/unit_tests/models/graph/acyclic_partition.rs
@@ -1,12 +1,12 @@
 use super::*;
-use crate::registry::declared_size_fields;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde_json;
 use std::collections::{BTreeSet, HashSet};
 
-fn yes_instance() -> AcyclicPartition<i32> {
+fn yes_instance() -> AcyclicPartition<i64> {
     AcyclicPartition::new(
         DirectedGraph::new(
             6,
@@ -28,7 +28,7 @@ fn yes_instance() -> AcyclicPartition<i32> {
     )
 }
 
-fn no_cost_instance() -> AcyclicPartition<i32> {
+fn no_cost_instance() -> AcyclicPartition<i64> {
     AcyclicPartition::new(
         DirectedGraph::new(
             6,
@@ -50,7 +50,7 @@ fn no_cost_instance() -> AcyclicPartition<i32> {
     )
 }
 
-fn quotient_cycle_instance() -> AcyclicPartition<i32> {
+fn quotient_cycle_instance() -> AcyclicPartition<i64> {
     AcyclicPartition::new(
         DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]),
         vec![1, 1, 1],
@@ -81,7 +81,7 @@ fn test_acyclic_partition_creation_and_accessors() {
 
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_arcs(), 8);
-    assert_eq!(problem.dims(), vec![6; 6]);
+    assert_eq!(problem.dimensions(), vec![6; 6]);
     assert_eq!(problem.graph().arcs().len(), 8);
     assert_eq!(problem.vertex_weights(), &[2, 3, 2, 1, 3, 1]);
     assert_eq!(problem.arc_costs(), &[1, 1, 1, 1, 1, 1, 1, 1]);
@@ -121,38 +121,44 @@ fn test_acyclic_partition_rejects_arc_cost_length_mismatch() {
 fn test_acyclic_partition_evaluate_yes_instance() {
     let problem = yes_instance();
     let config = vec![0, 1, 0, 2, 2, 2];
-    assert!(problem.evaluate(&config));
-    assert!(problem.is_valid_solution(&config));
+    assert!(problem.evaluate(&config).unwrap());
+    assert!(problem.is_valid_solution(&config).unwrap());
 }
 
 #[test]
 fn test_acyclic_partition_rejects_too_small_cost_bound() {
     let problem = no_cost_instance();
-    assert!(!problem.evaluate(&[0, 1, 0, 2, 2, 2]));
+    assert!(!problem.evaluate(&vec![0, 1, 0, 2, 2, 2]).unwrap());
 }
 
 #[test]
 fn test_acyclic_partition_rejects_quotient_cycle() {
     let problem = quotient_cycle_instance();
-    assert!(!problem.evaluate(&[0, 1, 2]));
+    assert!(!problem.evaluate(&vec![0, 1, 2]).unwrap());
 }
 
 #[test]
 fn test_acyclic_partition_rejects_weight_bound_violation() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[0, 0, 0, 1, 1, 1]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 1, 1, 1]).unwrap());
 }
 
 #[test]
 fn test_acyclic_partition_rejects_wrong_config_length() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[0, 1, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_acyclic_partition_rejects_out_of_range_label() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[0, 1, 0, 2, 2, 6]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0, 2, 2, 6]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -160,15 +166,15 @@ fn test_acyclic_partition_solver_finds_issue_example() {
     let problem = yes_instance();
     let solver = BruteForce::new();
 
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
 fn test_acyclic_partition_solver_has_four_canonical_solutions() {
     let problem = yes_instance();
-    let solutions = BruteForce::new().find_all_witnesses(&problem);
+    let solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
     let normalized: BTreeSet<Vec<usize>> = solutions
         .iter()
         .map(|config| canonicalize_labels(config))
@@ -187,14 +193,14 @@ fn test_acyclic_partition_solver_has_four_canonical_solutions() {
 #[test]
 fn test_acyclic_partition_no_solution_when_cost_bound_is_four() {
     let problem = no_cost_instance();
-    assert!(BruteForce::new().find_witness(&problem).is_none());
+    assert!(BruteForce::new().solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_acyclic_partition_serialization() {
     let problem = yes_instance();
     let json = serde_json::to_string(&problem).unwrap();
-    let deserialized: AcyclicPartition<i32> = serde_json::from_str(&json).unwrap();
+    let deserialized: AcyclicPartition<i64> = serde_json::from_str(&json).unwrap();
 
     assert_eq!(deserialized.num_vertices(), 6);
     assert_eq!(deserialized.num_arcs(), 8);
@@ -209,9 +215,38 @@ fn test_acyclic_partition_num_variables() {
 }
 
 #[test]
-fn test_acyclic_partition_declares_problem_size_fields() {
-    let fields: HashSet<&'static str> = declared_size_fields("AcyclicPartition")
-        .into_iter()
+fn test_acyclic_partition_declares_problem_parameters() {
+    let fields: HashSet<&'static str> = AcyclicPartition::<i64>::parameter_names()
+        .iter()
+        .copied()
         .collect();
     assert_eq!(fields, HashSet::from(["num_vertices", "num_arcs"]));
 }
+#[test]
+fn create_spec_maps_weight_inputs_to_canonical_fields() {
+    let problem = AcyclicPartition::try_from(AcyclicPartitionCreateSpec {
+        arcs: vec![(0, 1)],
+        num_vertices: Some(3),
+        weights: None,
+        arc_weights: Some(vec![2]),
+        weight_bound: 3,
+        cost_bound: 2,
+    })
+    .unwrap();
+    assert_eq!(problem.vertex_weights(), &[1, 1, 1]);
+    assert_eq!(problem.arc_costs(), &[2]);
+    assert_eq!(
+        AcyclicPartitionCreateSpec::FIELDS
+            .iter()
+            .map(|field| field.name)
+            .collect::<Vec<_>>(),
+        [
+            "arcs",
+            "num_vertices",
+            "weights",
+            "arc_costs",
+            "weight_bound",
+            "cost_bound"
+        ]
+    );
+}
diff --git a/src/unit_tests/models/graph/balanced_complete_bipartite_subgraph.rs b/src/unit_tests/models/graph/balanced_complete_bipartite_subgraph.rs
index 2faab061f..af225e573 100644
--- a/src/unit_tests/models/graph/balanced_complete_bipartite_subgraph.rs
+++ b/src/unit_tests/models/graph/balanced_complete_bipartite_subgraph.rs
@@ -1,4 +1,28 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_builds_bipartite_graph_and_rejects_invalid_edges() {
+    let problem =
+        BalancedCompleteBipartiteSubgraph::try_from(BalancedCompleteBipartiteSubgraphCreateSpec {
+            left: 2,
+            right: 2,
+            biedges: vec![(0, 1), (1, 0)],
+            k: 1,
+        })
+        .unwrap();
+    assert_eq!(problem.graph().left_edges(), &[(0, 1), (1, 0)]);
+    assert_eq!(problem.k(), 1);
+    assert!(BalancedCompleteBipartiteSubgraph::try_from(
+        BalancedCompleteBipartiteSubgraphCreateSpec {
+            left: 1,
+            right: 1,
+            biedges: vec![(1, 0)],
+            k: 1,
+        }
+    )
+    .is_err());
+}
 use crate::solvers::BruteForce;
 use crate::topology::BipartiteGraph;
 use crate::traits::Problem;
@@ -43,8 +67,8 @@ fn issue_instance_2_graph() -> BipartiteGraph {
     )
 }
 
-fn issue_instance_2_witness() -> Vec<usize> {
-    vec![1, 1, 1, 0, 1, 1, 1, 0]
+fn issue_instance_2_witness() -> Vec<bool> {
+    vec![true, true, true, false, true, true, true, false]
 }
 
 #[test]
@@ -56,28 +80,34 @@ fn test_balanced_complete_bipartite_subgraph_creation() {
     assert_eq!(problem.num_vertices(), 8);
     assert_eq!(problem.num_edges(), 10);
     assert_eq!(problem.k(), 2);
-    assert_eq!(problem.dims(), vec![2; 8]);
+    assert_eq!(problem.dimensions(), vec![2; 8]);
 }
 
 #[test]
 fn test_balanced_complete_bipartite_subgraph_evaluation_yes_instance() {
     let problem = BalancedCompleteBipartiteSubgraph::new(issue_instance_1_graph(), 2);
 
-    assert!(problem.evaluate(&[1, 1, 0, 0, 1, 1, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![true, true, false, false, true, true, false, false])
+        .unwrap());
 }
 
 #[test]
 fn test_balanced_complete_bipartite_subgraph_evaluation_no_instance() {
     let problem = BalancedCompleteBipartiteSubgraph::new(issue_instance_1_graph(), 3);
 
-    assert!(!problem.evaluate(&[1, 1, 1, 0, 1, 1, 1, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, false, true, true, true, false])
+        .unwrap());
 }
 
 #[test]
 fn test_balanced_complete_bipartite_subgraph_invalid_pairing() {
     let problem = BalancedCompleteBipartiteSubgraph::new(issue_instance_1_graph(), 2);
 
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 1, 0, 1, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, false, false, true, false, true, false])
+        .unwrap());
 }
 
 #[test]
@@ -93,8 +123,15 @@ fn test_balanced_complete_bipartite_subgraph_edge_lookup() {
 fn test_balanced_complete_bipartite_subgraph_rejects_invalid_configs() {
     let problem = BalancedCompleteBipartiteSubgraph::new(issue_instance_1_graph(), 2);
 
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 1, 1, 0]));
-    assert!(!problem.evaluate(&[1, 2, 0, 0, 1, 1, 0, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![true, true, false, false, true, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([true, 2, false, false, true, true, false, false])
+    )
+    .is_err());
 }
 
 #[test]
@@ -102,11 +139,11 @@ fn test_balanced_complete_bipartite_subgraph_solver_yes_instance() {
     let problem = BalancedCompleteBipartiteSubgraph::new(issue_instance_2_graph(), 3);
     let solver = BruteForce::new();
 
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all, vec![issue_instance_2_witness()]);
 }
 
@@ -115,7 +152,7 @@ fn test_balanced_complete_bipartite_subgraph_solver_no_instance() {
     let problem = BalancedCompleteBipartiteSubgraph::new(issue_instance_1_graph(), 3);
     let solver = BruteForce::new();
 
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -134,18 +171,21 @@ fn test_balanced_complete_bipartite_subgraph_serialization() {
         problem.graph().left_edges()
     );
     assert_eq!(deserialized.k(), 3);
-    assert!(deserialized.evaluate(&witness));
+    assert!(deserialized.evaluate(&witness).unwrap());
 }
 
 #[test]
 fn test_balanced_complete_bipartite_subgraph_is_valid_solution() {
     let problem = BalancedCompleteBipartiteSubgraph::new(issue_instance_2_graph(), 3);
     let yes_config = issue_instance_2_witness();
-    let no_config = vec![1, 1, 0, 1, 1, 1, 0, 0];
-
-    assert!(problem.is_valid_solution(&yes_config));
-    assert!(!problem.is_valid_solution(&no_config));
-    assert!(!problem.is_valid_solution(&[1, 1, 1]));
+    let no_config = vec![true, true, false, true, true, true, false, false];
+
+    assert!(problem.is_valid_solution(&yes_config).unwrap());
+    assert!(!problem.is_valid_solution(&no_config).unwrap());
+    assert!(matches!(
+        problem.is_valid_solution(&[true, true, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -154,6 +194,6 @@ fn test_balanced_complete_bipartite_subgraph_paper_example() {
     let witness = issue_instance_2_witness();
     let solver = BruteForce::new();
 
-    assert!(problem.evaluate(&witness));
-    assert_eq!(solver.find_all_witnesses(&problem), vec![witness]);
+    assert!(problem.evaluate(&witness).unwrap());
+    assert_eq!(solver.find_all_witnesses(&problem).unwrap(), vec![witness]);
 }
diff --git a/src/unit_tests/models/graph/biclique_cover.rs b/src/unit_tests/models/graph/biclique_cover.rs
index 6693e4fa2..ffcfb1f4a 100644
--- a/src/unit_tests/models/graph/biclique_cover.rs
+++ b/src/unit_tests/models/graph/biclique_cover.rs
@@ -1,9 +1,83 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::BipartiteGraph;
 use crate::traits::Problem;
 use crate::types::Min;
 
+#[test]
+fn test_biclique_cover_create_spec_constructs_graph() {
+    let problem = BicliqueCover::try_from(BicliqueCoverCreateSpec {
+        left: 2,
+        right: 3,
+        biedges: vec![(0, 0), (0, 2), (1, 1)],
+        k: 2,
+    })
+    .unwrap();
+
+    assert_eq!(problem.left_size(), 2);
+    assert_eq!(problem.right_size(), 3);
+    assert_eq!(problem.graph().left_edges(), &[(0, 0), (0, 2), (1, 1)]);
+    assert_eq!(problem.k(), 2);
+
+    let entry = inventory::iter::<crate::registry::VariantEntry>()
+        .find(|entry| entry.name == "BicliqueCover")
+        .unwrap();
+    let inputs = entry.create_inputs.unwrap()();
+    assert_eq!(
+        inputs.iter().map(|input| input.name).collect::<Vec<_>>(),
+        vec!["left", "right", "biedges", "k"]
+    );
+    assert_eq!(
+        inputs[2].codec,
+        crate::registry::CreateInputCodec::BipartiteEdgeList
+    );
+
+    let constructed = (entry.construct_fn)(serde_json::json!({
+        "left": 2,
+        "right": 3,
+        "biedges": [[0, 0], [0, 2], [1, 1]],
+        "k": 2
+    }))
+    .unwrap();
+    let constructed = constructed
+        .as_any()
+        .downcast_ref::<BicliqueCover>()
+        .unwrap();
+    assert_eq!(
+        constructed.graph().left_edges(),
+        problem.graph().left_edges()
+    );
+    assert_eq!(constructed.k(), problem.k());
+}
+
+#[test]
+fn test_biclique_cover_create_spec_rejects_out_of_bounds_edges() {
+    let invalid_left = BicliqueCover::try_from(BicliqueCoverCreateSpec {
+        left: 1,
+        right: 2,
+        biedges: vec![(1, 0)],
+        k: 1,
+    });
+    assert!(matches!(
+        invalid_left.unwrap_err(),
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "biedges[0] left vertex 1 is out of bounds for left partition size 1"
+    ));
+
+    let invalid_right = BicliqueCover::try_from(BicliqueCoverCreateSpec {
+        left: 2,
+        right: 1,
+        biedges: vec![(0, 1)],
+        k: 1,
+    });
+    assert!(matches!(
+        invalid_right.unwrap_err(),
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "biedges[0] right vertex 1 is out of bounds for right partition size 1"
+    ));
+}
+
 #[test]
 fn test_biclique_cover_creation() {
     let graph = BipartiteGraph::new(2, 2, vec![(0, 0), (0, 1), (1, 0)]);
@@ -32,7 +106,7 @@ fn test_get_biclique_memberships() {
     let problem = BicliqueCover::new(graph, 1);
     // Config: vertex 0 in biclique 0, vertex 2 in biclique 0
     // Variables: [v0_b0, v1_b0, v2_b0, v3_b0]
-    let config = vec![1, 0, 1, 0];
+    let config = vec![vec![true, false, true, false]];
     let (left, right) = problem.get_biclique_memberships(&config);
     assert!(left[0].contains(&0));
     assert!(!left[0].contains(&1));
@@ -45,11 +119,11 @@ fn test_is_edge_covered() {
     let graph = BipartiteGraph::new(2, 2, vec![(0, 0)]);
     let problem = BicliqueCover::new(graph, 1);
     // Put vertex 0 and 2 in biclique 0
-    let config = vec![1, 0, 1, 0];
+    let config = vec![vec![true, false, true, false]];
     assert!(problem.is_edge_covered(0, 2, &config));
 
     // Don't put vertex 2 in biclique
-    let config = vec![1, 0, 0, 0];
+    let config = vec![vec![true, false, false, false]];
     assert!(!problem.is_edge_covered(0, 2, &config));
 }
 
@@ -58,11 +132,11 @@ fn test_is_valid_cover() {
     let graph = BipartiteGraph::new(2, 2, vec![(0, 0), (0, 1)]);
     let problem = BicliqueCover::new(graph, 1);
     // Put 0, 2, 3 in biclique 0 -> covers both edges
-    let config = vec![1, 0, 1, 1];
+    let config = vec![vec![true, false, true, true]];
     assert!(problem.is_valid_cover(&config));
 
     // Only put 0, 2 -> doesn't cover (0,3)
-    let config = vec![1, 0, 1, 0];
+    let config = vec![vec![true, false, true, false]];
     assert!(!problem.is_valid_cover(&config));
 }
 
@@ -72,10 +146,20 @@ fn test_evaluate() {
     let problem = BicliqueCover::new(graph, 1);
 
     // Valid cover with size 2
-    assert_eq!(problem.evaluate(&[1, 0, 1, 0]), Min(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![vec![true, false, true, false]])
+            .unwrap(),
+        Min(Some(2))
+    );
 
     // Invalid cover returns Invalid
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![vec![true, false, false, false]])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -85,11 +169,11 @@ fn test_brute_force_simple() {
     let problem = BicliqueCover::new(graph, 1);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
         assert!(problem.is_valid_cover(sol));
         // Minimum size is 2 (one left, one right vertex)
-        assert_eq!(problem.total_biclique_size(sol), 2);
+        assert_eq!(problem.total_biclique_size(sol).unwrap(), 2);
     }
 }
 
@@ -101,7 +185,7 @@ fn test_brute_force_two_bicliques() {
     let problem = BicliqueCover::new(graph, 2);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
         assert!(problem.is_valid_cover(sol));
     }
@@ -112,12 +196,12 @@ fn test_count_covered_edges() {
     let graph = BipartiteGraph::new(2, 2, vec![(0, 0), (0, 1), (1, 0)]);
     let problem = BicliqueCover::new(graph, 1);
     // Cover only (0,2): put 0 and 2 in biclique
-    let config = vec![1, 0, 1, 0];
-    assert_eq!(problem.count_covered_edges(&config), 1);
+    let config = vec![vec![true, false, true, false]];
+    assert_eq!(problem.count_covered_edges(&config).unwrap(), 1);
 
     // Cover (0,2) and (0,3): put 0, 2, 3 in biclique
-    let config = vec![1, 0, 1, 1];
-    assert_eq!(problem.count_covered_edges(&config), 2);
+    let config = vec![vec![true, false, true, true]];
+    assert_eq!(problem.count_covered_edges(&config).unwrap(), 2);
 }
 
 #[test]
@@ -144,7 +228,10 @@ fn test_empty_edges() {
     let graph = BipartiteGraph::new(2, 2, vec![]);
     let problem = BicliqueCover::new(graph, 1);
     // No edges to cover -> valid with size 0
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Min(Some(0)));
+    assert_eq!(
+        problem.evaluate(&vec![vec![false; 4]]).unwrap(),
+        Min(Some(0))
+    );
 }
 
 #[test]
@@ -156,28 +243,41 @@ fn test_biclique_problem() {
     let problem = BicliqueCover::new(graph, 1);
 
     // dims: 4 vertices * 1 biclique = 4 binary variables
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2]);
 
     // Valid cover: vertex 0 and vertex 2 in biclique 0
     // Config: [v0_b0=1, v1_b0=0, v2_b0=1, v3_b0=0]
-    assert_eq!(problem.evaluate(&[1, 0, 1, 0]), Min(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![vec![true, false, true, false]])
+            .unwrap(),
+        Min(Some(2))
+    );
 
     // Invalid cover: only vertex 0, edge (0,2) not covered
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![vec![true, false, false, false]])
+            .unwrap(),
+        Min(None)
+    );
 
     // All vertices in biclique: biclique contains non-edges (0,3), (1,2), (1,3)
     // → not a sub-biclique of G → invalid cover.
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1]), Min(None));
+    assert_eq!(problem.evaluate(&vec![vec![true; 4]]).unwrap(), Min(None));
 
     // Empty config: no vertices in biclique, edge not covered
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![vec![false; 4]]).unwrap(), Min(None));
 
     // ExtremumSense is minimize
 
     // Test with no edges: any config is valid
     let empty_graph = BipartiteGraph::new(2, 2, vec![]);
     let empty_problem = BicliqueCover::new(empty_graph, 1);
-    assert_eq!(empty_problem.evaluate(&[0, 0, 0, 0]), Min(Some(0)));
+    assert_eq!(
+        empty_problem.evaluate(&vec![vec![false; 4]]).unwrap(),
+        Min(Some(0))
+    );
 }
 
 #[test]
@@ -188,13 +288,13 @@ fn test_is_valid_solution() {
     let problem = BicliqueCover::new(graph, 1);
     // 2 vertices (left_0, right_0), 1 biclique → config length = 2
     // Valid: both vertices in biclique 0 → covers edge (0,0)
-    assert!(problem.is_valid_solution(&[1, 1]));
+    assert!(problem.is_valid_solution(&[vec![true, true]]));
     // Invalid: only left vertex in biclique → doesn't form complete bipartite subgraph covering edge
-    assert!(!problem.is_valid_solution(&[1, 0]));
+    assert!(!problem.is_valid_solution(&[vec![true, false]]));
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let graph = BipartiteGraph::new(2, 2, vec![(0, 0), (0, 1)]);
     let problem = BicliqueCover::new(graph, 1);
     assert_eq!(problem.num_vertices(), 4); // 2 left + 2 right
@@ -211,7 +311,7 @@ fn test_complexity_includes_number_of_bicliques() {
         .find(|entry| entry.name == "BicliqueCover")
         .expect("BicliqueCover variant should be registered");
 
-    assert_eq!(problem.dims().len(), 8);
+    assert_eq!(problem.dimensions().len(), 8);
     assert_eq!(
         (entry.complexity_eval_fn)(&problem as &dyn std::any::Any),
         256.0
@@ -227,13 +327,16 @@ fn test_biclique_paper_example() {
     assert_eq!(problem.num_edges(), 4);
 
     // Biclique 0: {ℓ_1}, {r_1,r_2}; Biclique 1: {ℓ_2}, {r_2,r_3}
-    let config = vec![1, 0, 0, 1, 1, 0, 1, 1, 0, 1];
-    let result = problem.evaluate(&config);
+    let config = vec![
+        vec![true, false, true, true, false],
+        vec![false, true, false, true, true],
+    ];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 6);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    let best_size = problem.evaluate(&best).unwrap();
+    let best = solver.solve(&problem).unwrap().unwrap();
+    let best_size = problem.evaluate(&best).unwrap().unwrap();
     assert!(best_size <= 6);
 }
diff --git a/src/unit_tests/models/graph/biconnectivity_augmentation.rs b/src/unit_tests/models/graph/biconnectivity_augmentation.rs
index db4f33fc7..eae27d5eb 100644
--- a/src/unit_tests/models/graph/biconnectivity_augmentation.rs
+++ b/src/unit_tests/models/graph/biconnectivity_augmentation.rs
@@ -1,4 +1,17 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+#[test]
+fn create_spec_rejects_existing_potential_edge() {
+    assert!(
+        BiconnectivityAugmentation::try_from(BiconnectivityAugmentationCreateSpec {
+            graph: vec![(0, 1)],
+            num_vertices: None,
+            potential_weights: vec![(0, 1, 2)],
+            budget: 3
+        })
+        .is_err()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -15,16 +28,16 @@ fn test_biconnectivity_augmentation_creation() {
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 3);
     assert_eq!(problem.num_potential_edges(), 2);
-    assert_eq!(problem.dims(), vec![2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2]);
     assert_eq!(problem.num_variables(), 2);
     assert!(problem.is_weighted());
     assert_eq!(
-        <BiconnectivityAugmentation<SimpleGraph, i32> as Problem>::NAME,
+        <BiconnectivityAugmentation<SimpleGraph, i64> as Problem>::NAME,
         "BiconnectivityAugmentation"
     );
     assert_eq!(
-        <BiconnectivityAugmentation<SimpleGraph, i32> as Problem>::variant(),
-        vec![("graph", "SimpleGraph"), ("weight", "i32")]
+        <BiconnectivityAugmentation<SimpleGraph, i64> as Problem>::variant(),
+        vec![("graph", "SimpleGraph"), ("weight", "i64")]
     );
 
     let unit_problem =
@@ -58,12 +71,19 @@ fn test_biconnectivity_augmentation_evaluation() {
         2,
     );
 
-    assert!(!problem.evaluate(&[0, 0, 0]));
-    assert!(!problem.evaluate(&[0, 1, 0]));
-    assert!(problem.evaluate(&[0, 0, 1]));
-    assert!(!problem.evaluate(&[0, 1, 1]));
-    assert!(!problem.evaluate(&[2, 0, 0]));
-    assert!(!problem.evaluate(&[1, 0]));
+    assert!(!problem.evaluate(&vec![false, false, false]).unwrap());
+    assert!(!problem.evaluate(&vec![false, true, false]).unwrap());
+    assert!(problem.evaluate(&vec![false, false, true]).unwrap());
+    assert!(!problem.evaluate(&vec![false, true, true]).unwrap());
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, false, false])
+    )
+    .is_err());
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -72,7 +92,7 @@ fn test_biconnectivity_augmentation_serialization() {
         BiconnectivityAugmentation::new(SimpleGraph::path(4), vec![(0, 3, 2), (1, 3, 1)], 2);
 
     let json = serde_json::to_value(&problem).unwrap();
-    let restored: BiconnectivityAugmentation<SimpleGraph, i32> =
+    let restored: BiconnectivityAugmentation<SimpleGraph, i64> =
         serde_json::from_value(json).unwrap();
 
     assert_eq!(restored.graph(), problem.graph());
@@ -90,12 +110,13 @@ fn test_biconnectivity_augmentation_solver() {
     let solver = BruteForce::new();
 
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("expected a satisfying augmentation");
-    assert_eq!(solution, vec![0, 0, 1]);
+    assert_eq!(solution, vec![false, false, true]);
 
-    let all_solutions = solver.find_all_witnesses(&problem);
-    assert_eq!(all_solutions, vec![vec![0, 0, 1]]);
+    let all_solutions = solver.find_all_witnesses(&problem).unwrap();
+    assert_eq!(all_solutions, vec![vec![false, false, true]]);
 }
 
 #[test]
@@ -103,18 +124,18 @@ fn test_biconnectivity_augmentation_no_solution() {
     let problem = BiconnectivityAugmentation::new(SimpleGraph::path(4), vec![(0, 2, 1)], 1);
     let solver = BruteForce::new();
 
-    assert!(solver.find_witness(&problem).is_none());
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+    assert!(solver.solve(&problem).unwrap().is_none());
+    assert!(solver.find_all_witnesses(&problem).unwrap().is_empty());
 }
 
 #[test]
 fn test_biconnectivity_augmentation_paper_example() {
     let problem = example_instance();
     let solver = BruteForce::new();
-    let satisfying_config = vec![1, 0, 0, 1, 0, 0, 1, 0, 1];
-    let satisfying_solutions = solver.find_all_witnesses(&problem);
+    let satisfying_config = vec![true, false, false, true, false, false, true, false, true];
+    let satisfying_solutions = solver.find_all_witnesses(&problem).unwrap();
 
-    assert!(problem.evaluate(&satisfying_config));
+    assert!(problem.evaluate(&satisfying_config).unwrap());
     assert!(satisfying_solutions.contains(&satisfying_config));
 
     let over_budget_problem = BiconnectivityAugmentation::new(
@@ -132,8 +153,8 @@ fn test_biconnectivity_augmentation_paper_example() {
         ],
         3,
     );
-    assert!(!over_budget_problem.evaluate(&satisfying_config));
-    assert!(solver.find_witness(&over_budget_problem).is_none());
+    assert!(!over_budget_problem.evaluate(&satisfying_config).unwrap());
+    assert!(solver.solve(&over_budget_problem).unwrap().is_none());
 }
 
 #[test]
@@ -143,3 +164,40 @@ fn test_is_biconnected() {
     assert!(!is_biconnected(&SimpleGraph::path(4)));
     assert!(!is_biconnected(&SimpleGraph::new(4, vec![(0, 1), (2, 3)])));
 }
+
+#[test]
+fn test_biconnectivity_augmentation_signed_total_budget() {
+    for candidates in [vec![(0, 2, 2), (0, 3, -2)], vec![(0, 3, -2), (0, 2, 2)]] {
+        let source = BiconnectivityAugmentation::new(SimpleGraph::path(4), candidates, 0);
+        assert!(source.evaluate(&vec![true, true]).unwrap().0);
+    }
+    for n in 0..=3 {
+        let source =
+            BiconnectivityAugmentation::<_, i64>::new(SimpleGraph::complete(n), vec![], -1);
+        assert!(!source.evaluate(&vec![]).unwrap().0);
+    }
+    let source = BiconnectivityAugmentation::new(SimpleGraph::path(3), vec![(0, 2, -3)], -2);
+    assert!(source.evaluate(&vec![true]).unwrap().0);
+}
+
+#[test]
+fn test_biconnectivity_augmentation_preserves_checked_arithmetic() {
+    let source = BiconnectivityAugmentation::new(
+        SimpleGraph::path(4),
+        vec![(0, 2, i64::MAX), (0, 3, 1), (1, 3, -1)],
+        i64::MAX,
+    );
+    assert!(matches!(
+        source.evaluate(&vec![true, true, true]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
+    let source = BiconnectivityAugmentation::new(
+        SimpleGraph::path(4),
+        vec![(0, 2, i64::MIN), (0, 3, -1)],
+        i64::MAX,
+    );
+    assert!(matches!(
+        source.evaluate(&vec![true, true]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
+}
diff --git a/src/unit_tests/models/graph/bottleneck_traveling_salesman.rs b/src/unit_tests/models/graph/bottleneck_traveling_salesman.rs
index e8f72c0df..9aa70a24d 100644
--- a/src/unit_tests/models/graph/bottleneck_traveling_salesman.rs
+++ b/src/unit_tests/models/graph/bottleneck_traveling_salesman.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -26,14 +27,14 @@ fn k5_btsp() -> BottleneckTravelingSalesman {
 }
 
 #[test]
-fn test_bottleneck_traveling_salesman_creation_and_size_getters() {
+fn test_bottleneck_traveling_salesman_creation_and_parameter_getters() {
     let mut problem = k5_btsp();
 
     assert_eq!(problem.graph().num_vertices(), 5);
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.graph().num_edges(), 10);
     assert_eq!(problem.num_edges(), 10);
-    assert_eq!(problem.dims(), vec![2; 10]);
+    assert_eq!(problem.dimensions(), vec![2; 10]);
     assert_eq!(problem.num_variables(), 10);
     assert_eq!(problem.weights(), vec![5, 4, 4, 5, 4, 1, 2, 1, 5, 4]);
     assert_eq!(
@@ -61,13 +62,17 @@ fn test_bottleneck_traveling_salesman_creation_and_size_getters() {
 fn test_bottleneck_traveling_salesman_evaluate_valid_and_invalid() {
     let problem = k5_btsp();
 
-    let valid_cycle = vec![0, 1, 1, 0, 1, 0, 1, 0, 0, 1];
+    let valid_cycle = vec![
+        false, true, true, false, true, false, true, false, false, true,
+    ];
     assert!(problem.is_valid_solution(&valid_cycle));
-    assert_eq!(problem.evaluate(&valid_cycle), Min(Some(4)));
+    assert_eq!(problem.evaluate(&valid_cycle).unwrap(), Min(Some(4)));
 
-    let degree_violation = vec![1, 1, 1, 0, 1, 0, 1, 0, 0, 1];
+    let degree_violation = vec![
+        true, true, true, false, true, false, true, false, false, true,
+    ];
     assert!(!problem.is_valid_solution(&degree_violation));
-    assert_eq!(problem.evaluate(&degree_violation), Min(None));
+    assert_eq!(problem.evaluate(&degree_violation).unwrap(), Min(None));
 }
 
 #[test]
@@ -77,19 +82,24 @@ fn test_bottleneck_traveling_salesman_evaluate_disconnected_subtour_invalid() {
         vec![1, 1, 1, 2, 2, 2],
     );
 
-    let disconnected_subtour = vec![1, 1, 1, 1, 1, 1];
+    let disconnected_subtour = vec![true, true, true, true, true, true];
     assert!(!problem.is_valid_solution(&disconnected_subtour));
-    assert_eq!(problem.evaluate(&disconnected_subtour), Min(None));
+    assert_eq!(problem.evaluate(&disconnected_subtour).unwrap(), Min(None));
 }
 
 #[test]
 fn test_bottleneck_traveling_salesman_bruteforce_unique_optimum() {
     let problem = k5_btsp();
     let solver = BruteForce::new();
-    let best = solver.find_all_witnesses(&problem);
+    let best = solver.find_all_witnesses(&problem).unwrap();
 
-    assert_eq!(best, vec![vec![0, 1, 1, 0, 1, 0, 1, 0, 0, 1]]);
-    assert_eq!(problem.evaluate(&best[0]), Min(Some(4)));
+    assert_eq!(
+        best,
+        vec![vec![
+            false, true, true, false, true, false, true, false, false, true
+        ]]
+    );
+    assert_eq!(problem.evaluate(&best[0]).unwrap(), Min(Some(4)));
 }
 
 #[test]
@@ -102,7 +112,11 @@ fn test_bottleneck_traveling_salesman_serialization() {
     assert_eq!(restored.graph(), problem.graph());
     assert_eq!(restored.weights(), problem.weights());
     assert_eq!(
-        restored.evaluate(&[0, 1, 1, 0, 1, 0, 1, 0, 0, 1]),
+        restored
+            .evaluate(&vec![
+                false, true, true, false, true, false, true, false, false, true
+            ])
+            .unwrap(),
         Min(Some(4))
     );
 }
@@ -110,13 +124,29 @@ fn test_bottleneck_traveling_salesman_serialization() {
 #[test]
 fn test_bottleneck_traveling_salesman_paper_example() {
     let problem = k5_btsp();
-    let config = vec![0, 1, 1, 0, 1, 0, 1, 0, 0, 1];
+    let config = vec![
+        false, true, true, false, true, false, true, false, false, true,
+    ];
 
     assert!(problem.is_valid_solution(&config));
-    assert_eq!(problem.evaluate(&config), Min(Some(4)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(4)));
 
     let solver = BruteForce::new();
-    let best = solver.find_all_witnesses(&problem);
+    let best = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(best.len(), 1);
     assert_eq!(best[0], config);
 }
+#[test]
+fn create_spec_uses_edge_weights_and_defaults_to_one() {
+    let problem = BottleneckTravelingSalesman::try_from(BottleneckTravelingSalesmanCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: Some(3),
+        edge_weights: None,
+    })
+    .unwrap();
+    assert_eq!(problem.weights(), vec![1]);
+    assert_eq!(
+        BottleneckTravelingSalesmanCreateSpec::FIELDS[2].name,
+        "edge_weights"
+    );
+}
diff --git a/src/unit_tests/models/graph/bounded_component_spanning_forest.rs b/src/unit_tests/models/graph/bounded_component_spanning_forest.rs
index 5e2573001..020d1bfbb 100644
--- a/src/unit_tests/models/graph/bounded_component_spanning_forest.rs
+++ b/src/unit_tests/models/graph/bounded_component_spanning_forest.rs
@@ -1,11 +1,31 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use std::alloc::{GlobalAlloc, Layout, System};
 use std::cell::Cell;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
+#[test]
+fn create_spec_uses_k_and_max_weight_inputs() {
+    let names: Vec<_> = BoundedComponentSpanningForestCreateSpec::FIELDS
+        .iter()
+        .map(|field| field.name)
+        .collect();
+    assert_eq!(names, ["graph", "weights", "k", "max_weight"]);
+    let problem =
+        BoundedComponentSpanningForest::try_from(BoundedComponentSpanningForestCreateSpec {
+            graph: SimpleGraph::new(2, vec![(0, 1)]),
+            weights: vec![1, 2],
+            k: 1,
+            max_weight: 3,
+        })
+        .unwrap();
+    assert_eq!(problem.max_components(), 1);
+    assert_eq!(problem.max_weight(), &3);
+}
+
 struct CountingAllocator;
 
 static ALLOCATION_COUNT: AtomicUsize = AtomicUsize::new(0);
@@ -50,7 +70,7 @@ fn count_allocations<T>(f: impl FnOnce() -> T) -> (T, usize) {
     (result, allocations)
 }
 
-fn yes_instance() -> BoundedComponentSpanningForest<SimpleGraph, i32> {
+fn yes_instance() -> BoundedComponentSpanningForest<SimpleGraph, i64> {
     let graph = SimpleGraph::new(
         8,
         vec![
@@ -69,7 +89,7 @@ fn yes_instance() -> BoundedComponentSpanningForest<SimpleGraph, i32> {
     BoundedComponentSpanningForest::new(graph, vec![2, 3, 1, 2, 3, 1, 2, 1], 3, 6)
 }
 
-fn no_instance() -> BoundedComponentSpanningForest<SimpleGraph, i32> {
+fn no_instance() -> BoundedComponentSpanningForest<SimpleGraph, i64> {
     let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (3, 4), (4, 5)]);
     BoundedComponentSpanningForest::new(graph, vec![1, 1, 1, 1, 1, 1], 2, 2)
 }
@@ -84,39 +104,44 @@ fn test_bounded_component_spanning_forest_creation() {
     assert_eq!(problem.max_weight(), &6);
     assert_eq!(problem.num_vertices(), 8);
     assert_eq!(problem.num_edges(), 10);
-    assert_eq!(problem.dims(), vec![3; 8]);
+    assert_eq!(problem.dimensions(), vec![3; 8]);
     assert!(problem.is_weighted());
 }
 
 #[test]
 fn test_bounded_component_spanning_forest_yes_instance() {
     let problem = yes_instance();
-    assert!(problem.evaluate(&[0, 0, 1, 1, 1, 2, 2, 0]));
-    assert!(problem.is_valid_solution(&[0, 0, 1, 1, 1, 2, 2, 0]));
+    assert!(problem.evaluate(&vec![0, 0, 1, 1, 1, 2, 2, 0]).unwrap());
+    assert!(problem
+        .is_valid_solution(&[0, 0, 1, 1, 1, 2, 2, 0])
+        .unwrap());
 }
 
 #[test]
 fn test_bounded_component_spanning_forest_rejects_weight_overflow() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[0, 0, 1, 1, 1, 1, 2, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 1, 1, 1, 1, 2, 0]).unwrap());
 }
 
 #[test]
 fn test_bounded_component_spanning_forest_rejects_disconnected_component() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[0, 1, 0, 1, 1, 2, 2, 0]));
+    assert!(!problem.evaluate(&vec![0, 1, 0, 1, 1, 2, 2, 0]).unwrap());
 }
 
 #[test]
 fn test_bounded_component_spanning_forest_rejects_out_of_range_component() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[0, 0, 1, 1, 1, 2, 2, 3]));
+    assert!(!problem.evaluate(&vec![0, 0, 1, 1, 1, 2, 2, 3]).unwrap());
 }
 
 #[test]
 fn test_bounded_component_spanning_forest_rejects_wrong_length() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[0, 0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -124,7 +149,7 @@ fn test_bounded_component_spanning_forest_evaluate_uses_fixed_allocation_budget(
     let problem = BoundedComponentSpanningForest::new(SimpleGraph::empty(16), vec![1; 16], 16, 1);
     let config: Vec<usize> = (0..16).collect();
 
-    let (is_valid, allocations) = count_allocations(|| problem.evaluate(&config));
+    let (is_valid, allocations) = count_allocations(|| problem.evaluate(&config).unwrap());
 
     assert!(is_valid);
     assert!(
@@ -137,7 +162,7 @@ fn test_bounded_component_spanning_forest_evaluate_uses_fixed_allocation_budget(
 fn test_bounded_component_spanning_forest_serialization() {
     let problem = yes_instance();
     let json = serde_json::to_string(&problem).unwrap();
-    let round_trip: BoundedComponentSpanningForest<SimpleGraph, i32> =
+    let round_trip: BoundedComponentSpanningForest<SimpleGraph, i64> =
         serde_json::from_str(&json).unwrap();
     assert_eq!(round_trip.graph().num_vertices(), 8);
     assert_eq!(round_trip.weights(), &[2, 3, 1, 2, 3, 1, 2, 1]);
@@ -150,22 +175,22 @@ fn test_bounded_component_spanning_forest_solver_yes_and_no_instances() {
     let solver = BruteForce::new();
 
     let yes_problem = yes_instance();
-    let solution = solver.find_witness(&yes_problem);
+    let solution = solver.solve(&yes_problem).unwrap();
     assert!(solution.is_some());
-    assert!(yes_problem.evaluate(solution.as_ref().unwrap()));
+    assert!(yes_problem.evaluate(solution.as_ref().unwrap()).unwrap());
 
     let no_problem = no_instance();
-    assert!(solver.find_witness(&no_problem).is_none());
+    assert!(solver.solve(&no_problem).unwrap().is_none());
 }
 
 #[test]
 fn test_bounded_component_spanning_forest_paper_example() {
     let problem = yes_instance();
     let config = vec![0, 0, 1, 1, 1, 2, 2, 0];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
     let solver = BruteForce::new();
-    let all_solutions = solver.find_all_witnesses(&problem);
+    let all_solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(all_solutions.iter().any(|solution| solution == &config));
 }
 
@@ -182,7 +207,7 @@ fn test_bounded_component_spanning_forest_accepts_k_larger_than_num_vertices() {
     let problem = BoundedComponentSpanningForest::new(graph, vec![1, 1], 5, 2);
     // K > |V| is mathematically harmless — just means fewer than K components possible
     assert_eq!(problem.max_components(), 5);
-    assert!(problem.evaluate(&[0, 0]));
+    assert!(problem.evaluate(&vec![0, 0]).unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/bounded_diameter_spanning_tree.rs b/src/unit_tests/models/graph/bounded_diameter_spanning_tree.rs
index d4325e603..77c13c30f 100644
--- a/src/unit_tests/models/graph/bounded_diameter_spanning_tree.rs
+++ b/src/unit_tests/models/graph/bounded_diameter_spanning_tree.rs
@@ -1,9 +1,10 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
-fn example_instance() -> BoundedDiameterSpanningTree<SimpleGraph, i32> {
+fn example_instance() -> BoundedDiameterSpanningTree<SimpleGraph, i64> {
     // 5 vertices, 7 edges with weights
     // (0,1,1),(0,2,2),(0,3,1),(1,2,1),(1,4,2),(2,3,1),(3,4,1)
     // B=5, D=3
@@ -25,7 +26,7 @@ fn test_bounded_diameter_spanning_tree_creation() {
     assert_eq!(problem.num_edges(), 7);
     assert_eq!(problem.weight_bound(), &5);
     assert_eq!(problem.diameter_bound(), 3);
-    assert_eq!(problem.dims(), vec![2; 7]);
+    assert_eq!(problem.dimensions(), vec![2; 7]);
     assert_eq!(problem.graph().num_vertices(), 5);
     assert_eq!(problem.edge_list().len(), 7);
     assert_eq!(problem.edge_weights().len(), 7);
@@ -40,7 +41,9 @@ fn test_bounded_diameter_spanning_tree_evaluate_valid() {
     // Weight: 1+1+1+1 = 4 ≤ 5
     // Tree adjacency: 0-{1,3}, 1-{0}, 2-{3}, 3-{0,2,4}, 4-{3}
     // Diameter: longest path is e.g. 1-0-3-2 or 1-0-3-4 = 3 edges ≤ 3
-    assert!(problem.evaluate(&[1, 0, 1, 0, 0, 1, 1]));
+    assert!(problem
+        .evaluate(&vec![true, false, true, false, false, true, true])
+        .unwrap());
 }
 
 #[test]
@@ -48,7 +51,9 @@ fn test_bounded_diameter_spanning_tree_evaluate_exceeds_weight() {
     let problem = example_instance();
     // Select edges 1,2,4,6: (0,2),(0,3),(1,4),(3,4)
     // Weight: 2+1+2+1 = 6 > 5
-    assert!(!problem.evaluate(&[0, 1, 1, 0, 1, 0, 1]));
+    assert!(!problem
+        .evaluate(&vec![false, true, true, false, true, false, true])
+        .unwrap());
 }
 
 #[test]
@@ -61,32 +66,42 @@ fn test_bounded_diameter_spanning_tree_evaluate_exceeds_diameter() {
         1, // diameter ≤ 1 means all vertices must be distance 1 from each other
     );
     // The only spanning tree is the path 0-1-2-3 with diameter 3
-    assert!(!problem.evaluate(&[1, 1, 1]));
+    assert!(!problem.evaluate(&vec![true, true, true]).unwrap());
 }
 
 #[test]
 fn test_bounded_diameter_spanning_tree_evaluate_not_tree() {
     let problem = example_instance();
     // Too few edges
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, false, false, false, false, false])
+        .unwrap());
     // Too many edges
-    assert!(!problem.evaluate(&[1, 1, 1, 1, 1, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, true, true, false, false])
+        .unwrap());
 }
 
 #[test]
 fn test_bounded_diameter_spanning_tree_evaluate_wrong_length() {
     let problem = example_instance();
-    assert!(!problem.evaluate(&[0, 1, 0]));
-    assert!(!problem.evaluate(&[0, 1, 0, 0, 1, 0, 0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![false, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![false, true, false, false, true, false, false, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_bounded_diameter_spanning_tree_brute_force() {
     let problem = example_instance();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
@@ -100,14 +115,14 @@ fn test_bounded_diameter_spanning_tree_infeasible() {
         2,
     );
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_bounded_diameter_spanning_tree_serialization() {
     let problem = example_instance();
     let json = serde_json::to_string(&problem).unwrap();
-    let deserialized: BoundedDiameterSpanningTree<SimpleGraph, i32> =
+    let deserialized: BoundedDiameterSpanningTree<SimpleGraph, i64> =
         serde_json::from_str(&json).unwrap();
     assert_eq!(deserialized.num_vertices(), 5);
     assert_eq!(deserialized.num_edges(), 7);
@@ -132,3 +147,19 @@ fn test_bounded_diameter_spanning_tree_wrong_weights_length_panics() {
     let _ =
         BoundedDiameterSpanningTree::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1], 5, 2);
 }
+#[test]
+fn create_spec_uses_edge_weights_and_defaults_to_one() {
+    let problem = BoundedDiameterSpanningTree::try_from(BoundedDiameterSpanningTreeCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+        edge_weights: None,
+        weight_bound: 1,
+        diameter_bound: 1,
+    })
+    .unwrap();
+    assert_eq!(problem.edge_weights(), &[1]);
+    assert_eq!(
+        BoundedDiameterSpanningTreeCreateSpec::FIELDS[2].name,
+        "edge_weights"
+    );
+}
diff --git a/src/unit_tests/models/graph/degree_constrained_spanning_tree.rs b/src/unit_tests/models/graph/degree_constrained_spanning_tree.rs
index e3dfaae73..847436d94 100644
--- a/src/unit_tests/models/graph/degree_constrained_spanning_tree.rs
+++ b/src/unit_tests/models/graph/degree_constrained_spanning_tree.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -20,7 +21,7 @@ fn test_degree_constrained_spanning_tree_creation() {
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_edges(), 7);
     assert_eq!(problem.max_degree(), 2);
-    assert_eq!(problem.dims(), vec![2; 7]);
+    assert_eq!(problem.dimensions(), vec![2; 7]);
     assert_eq!(problem.graph().num_vertices(), 5);
     assert_eq!(problem.edge_list().len(), 7);
 }
@@ -32,7 +33,9 @@ fn test_degree_constrained_spanning_tree_evaluate_valid() {
     // Select edges 1,2,3,4: (0,2),(0,3),(1,2),(1,4)
     // Degrees: 0→2, 1→2, 2→2, 3→1, 4→1 — all ≤ 2
     // Connected and n-1=4 edges → valid spanning tree
-    assert!(problem.evaluate(&[0, 1, 1, 1, 1, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![false, true, true, true, true, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -40,16 +43,22 @@ fn test_degree_constrained_spanning_tree_evaluate_invalid_degree() {
     let problem = example_instance();
     // Select edges 0,1,2,4: (0,1),(0,2),(0,3),(1,4)
     // Degrees: 0→3 (exceeds K=2)
-    assert!(!problem.evaluate(&[1, 1, 1, 0, 1, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, false, true, false, false])
+        .unwrap());
 }
 
 #[test]
 fn test_degree_constrained_spanning_tree_evaluate_not_tree() {
     let problem = example_instance();
     // Select only 3 edges (not enough for n-1=4)
-    assert!(!problem.evaluate(&[1, 1, 1, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, false, false, false, false])
+        .unwrap());
     // Select 5 edges (too many)
-    assert!(!problem.evaluate(&[1, 1, 1, 1, 1, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, true, true, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -62,23 +71,31 @@ fn test_degree_constrained_spanning_tree_evaluate_disconnected() {
     // Need to pick 4 edges forming a tree where no vertex has degree > 2.
     // edges (0,2),(2,3),(3,4),(1,4) → indices 1,5,6,4
     // Degrees: 0→1, 1→1, 2→2, 3→2, 4→2 → valid and connected!
-    assert!(problem.evaluate(&[0, 1, 0, 0, 1, 1, 1]));
+    assert!(problem
+        .evaluate(&vec![false, true, false, false, true, true, true])
+        .unwrap());
 }
 
 #[test]
 fn test_degree_constrained_spanning_tree_evaluate_wrong_length() {
     let problem = example_instance();
-    assert!(!problem.evaluate(&[0, 1, 0]));
-    assert!(!problem.evaluate(&[0, 1, 0, 0, 1, 0, 0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![false, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![false, true, false, false, true, false, false, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_degree_constrained_spanning_tree_brute_force() {
     let problem = example_instance();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
@@ -91,7 +108,7 @@ fn test_degree_constrained_spanning_tree_infeasible() {
         2,
     );
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -101,12 +118,12 @@ fn test_degree_constrained_spanning_tree_k1_path() {
     let problem =
         DegreeConstrainedSpanningTree::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]), 1);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 
     // For n=2, K=1 works: the single edge is the tree.
     let problem2 = DegreeConstrainedSpanningTree::new(SimpleGraph::new(2, vec![(0, 1)]), 1);
     let solver2 = BruteForce::new();
-    let sol = solver2.find_witness(&problem2);
+    let sol = solver2.solve(&problem2).unwrap();
     assert!(sol.is_some());
 }
 
diff --git a/src/unit_tests/models/graph/directed_hamiltonian_path.rs b/src/unit_tests/models/graph/directed_hamiltonian_path.rs
index 7e2600377..d00fa1c5f 100644
--- a/src/unit_tests/models/graph/directed_hamiltonian_path.rs
+++ b/src/unit_tests/models/graph/directed_hamiltonian_path.rs
@@ -1,13 +1,9 @@
 use super::*;
-use crate::rules::ilp_helpers::permutation_to_lehmer;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 
-fn encode(perm: &[usize]) -> Vec<usize> {
-    permutation_to_lehmer(perm)
-}
-
 #[test]
 fn test_directed_hamiltonian_path_creation() {
     // Simple directed path: 0->1->2->3
@@ -16,7 +12,7 @@ fn test_directed_hamiltonian_path_creation() {
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_arcs(), 3);
     // Lehmer dims: [4, 3, 2, 1]
-    assert_eq!(problem.dims(), vec![4, 3, 2, 1]);
+    assert_eq!(problem.dimensions(), vec![4, 3, 2, 1]);
 }
 
 #[test]
@@ -25,14 +21,13 @@ fn test_directed_hamiltonian_path_evaluate_valid() {
     let graph = DirectedGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
     let problem = DirectedHamiltonianPath::new(graph);
 
-    // Path [0, 1, 2, 3]: Lehmer code [0, 0, 0, 0]
     assert_eq!(
-        problem.evaluate(&encode(&[0, 1, 2, 3])),
+        problem.evaluate(&vec![0, 1, 2, 3]).unwrap(),
         crate::types::Or(true)
     );
     // Path [3, 2, 1, 0]: no arcs in reverse, invalid
     assert_eq!(
-        problem.evaluate(&encode(&[3, 2, 1, 0])),
+        problem.evaluate(&vec![3, 2, 1, 0]).unwrap(),
         crate::types::Or(false)
     );
 }
@@ -44,7 +39,7 @@ fn test_directed_hamiltonian_path_evaluate_invalid_no_arc() {
     let problem = DirectedHamiltonianPath::new(graph);
     // No Hamiltonian path should be valid
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -54,9 +49,10 @@ fn test_directed_hamiltonian_path_brute_force() {
     let problem = DirectedHamiltonianPath::new(graph);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should have a Hamiltonian path");
-    assert_eq!(problem.evaluate(&solution), crate::types::Or(true));
+    assert_eq!(problem.evaluate(&solution).unwrap(), crate::types::Or(true));
 }
 
 #[test]
@@ -82,7 +78,7 @@ fn test_directed_hamiltonian_path_issue_example() {
     let problem = DirectedHamiltonianPath::new(graph);
     let path = vec![0usize, 1, 3, 2, 4, 5];
     assert_eq!(
-        problem.evaluate(&encode(&path)),
+        problem.evaluate(&path).unwrap(),
         crate::types::Or(true),
         "Path [0,1,3,2,4,5] should be a valid Hamiltonian path"
     );
@@ -94,7 +90,7 @@ fn test_directed_hamiltonian_path_no_solution() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (0, 2)]);
     let problem = DirectedHamiltonianPath::new(graph);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -102,9 +98,9 @@ fn test_directed_hamiltonian_path_single_vertex() {
     let graph = DirectedGraph::new(1, vec![]);
     let problem = DirectedHamiltonianPath::new(graph);
     // Single vertex: trivially Hamiltonian
-    assert_eq!(problem.evaluate(&[0]), crate::types::Or(true));
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), crate::types::Or(true));
     let solver = BruteForce::new();
-    let sol = solver.find_witness(&problem);
+    let sol = solver.solve(&problem).unwrap();
     assert!(sol.is_some());
 }
 
@@ -123,19 +119,19 @@ fn test_is_valid_solution() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = DirectedHamiltonianPath::new(graph);
     // Valid: path [0, 1, 2]
-    assert!(problem.is_valid_solution(&encode(&[0, 1, 2])));
+    assert!(problem.is_valid_solution(&[0, 1, 2]));
     // Invalid: path [0, 2, 1] (no arc 0->2)
-    assert!(!problem.is_valid_solution(&encode(&[0, 2, 1])));
+    assert!(!problem.is_valid_solution(&[0, 2, 1]));
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let graph = DirectedGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]);
     let problem = DirectedHamiltonianPath::new(graph);
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_arcs(), 4);
     // Lehmer dims: [5, 4, 3, 2, 1]
-    assert_eq!(problem.dims(), vec![5, 4, 3, 2, 1]);
+    assert_eq!(problem.dimensions(), vec![5, 4, 3, 2, 1]);
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/directed_two_commodity_integral_flow.rs b/src/unit_tests/models/graph/directed_two_commodity_integral_flow.rs
index 172777b9f..444a2e69f 100644
--- a/src/unit_tests/models/graph/directed_two_commodity_integral_flow.rs
+++ b/src/unit_tests/models/graph/directed_two_commodity_integral_flow.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 
@@ -35,8 +36,8 @@ fn test_directed_two_commodity_integral_flow_creation() {
     let problem = yes_instance();
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_arcs(), 8);
-    assert_eq!(problem.dims().len(), 16); // 2 * 8
-    assert!(problem.dims().iter().all(|&d| d == 2)); // capacity 1 -> domain {0,1}
+    assert_eq!(problem.dimensions().len(), 16); // 2 * 8
+    assert!(problem.dimensions().iter().all(|&d| d == 2)); // capacity 1 -> domain {0,1}
     assert_eq!(problem.source_1(), 0);
     assert_eq!(problem.sink_1(), 4);
     assert_eq!(problem.source_2(), 1);
@@ -53,7 +54,7 @@ fn test_directed_two_commodity_integral_flow_evaluation_satisfying() {
     // Commodity 2: path 1->3->5 (arcs 3,7)
     // config = [f1(a0..a7), f2(a0..a7)]
     let config = vec![1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -61,7 +62,7 @@ fn test_directed_two_commodity_integral_flow_evaluation_unsatisfying() {
     let problem = no_instance();
     // All zeros: no flow at all
     let config = vec![0, 0, 0, 0, 0, 0];
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -72,7 +73,7 @@ fn test_directed_two_commodity_integral_flow_capacity_violation() {
     let mut config = vec![0; 16];
     config[0] = 1; // f1 on arc 0
     config[8] = 1; // f2 on arc 0
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -82,7 +83,7 @@ fn test_directed_two_commodity_integral_flow_conservation_violation() {
     let mut config = vec![0; 16];
     config[0] = 1; // f1 on arc 0 (0->2): flow into vertex 2
                    // No outgoing flow from vertex 2 for commodity 1
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -92,7 +93,7 @@ fn test_directed_two_commodity_integral_flow_negative_net_flow_at_sink_is_infeas
 
     // Commodity 1 sends flow out of its sink with no incoming flow.
     let config = vec![1, 0];
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -103,24 +104,24 @@ fn test_directed_two_commodity_integral_flow_disallows_using_other_commodity_sou
     // Commodity 1 reaches t1 from s2, which is illegal in the classical definition:
     // conservation must hold for commodity 1 at s2.
     let config = vec![1, 1, 0, 0];
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_directed_two_commodity_integral_flow_solver_yes() {
     let problem = yes_instance();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let sol = solution.unwrap();
-    assert!(problem.evaluate(&sol));
+    assert!(problem.evaluate(&sol).unwrap());
 }
 
 #[test]
 fn test_directed_two_commodity_integral_flow_solver_no() {
     let problem = no_instance();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
@@ -162,15 +163,15 @@ fn test_directed_two_commodity_integral_flow_paper_example() {
 
     // Verify the known solution evaluates to true
     let config = vec![1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
     // Find all satisfying solutions and verify count
-    let all_solutions = solver.find_all_witnesses(&problem);
+    let all_solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all_solutions.is_empty());
 
     // Each solution must evaluate to true
     for sol in &all_solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -178,9 +179,18 @@ fn test_directed_two_commodity_integral_flow_paper_example() {
 fn test_directed_two_commodity_integral_flow_wrong_config_length() {
     let problem = yes_instance();
     // Config with wrong length should return false (infeasible)
-    assert!(!problem.evaluate(&[0; 15])); // too short
-    assert!(!problem.evaluate(&[0; 17])); // too long
-    assert!(!problem.evaluate(&[])); // empty
+    assert!(matches!(
+        problem.evaluate(&vec![0; 15]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0; 17]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -197,12 +207,12 @@ fn test_directed_two_commodity_integral_flow_higher_capacity() {
         1,
         1,
     );
-    assert_eq!(problem.dims(), vec![3, 3, 3, 3]); // each variable in {0,1,2}
+    assert_eq!(problem.dimensions(), vec![3, 3, 3, 3]); // each variable in {0,1,2}
 
     // Both commodities can share: f1=1, f2=1 on both arcs
     let config = vec![1, 1, 1, 1];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_some());
+    assert!(solver.solve(&problem).unwrap().is_some());
 }
diff --git a/src/unit_tests/models/graph/disjoint_connecting_paths.rs b/src/unit_tests/models/graph/disjoint_connecting_paths.rs
index 6c613bd07..c1e93c582 100644
--- a/src/unit_tests/models/graph/disjoint_connecting_paths.rs
+++ b/src/unit_tests/models/graph/disjoint_connecting_paths.rs
@@ -1,4 +1,16 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+#[test]
+fn create_spec_rejects_reused_terminal() {
+    assert!(
+        DisjointConnectingPaths::try_from(DisjointConnectingPathsCreateSpec {
+            graph: vec![(0, 1), (1, 2)],
+            num_vertices: None,
+            terminal_pairs: vec![(0, 1), (1, 2)]
+        })
+        .is_err()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -13,8 +25,8 @@ fn issue_yes_problem() -> DisjointConnectingPaths<SimpleGraph> {
     )
 }
 
-fn issue_yes_config() -> Vec<usize> {
-    vec![1, 0, 1, 0, 1, 0, 1]
+fn issue_yes_config() -> Vec<bool> {
+    vec![true, false, true, false, true, false, true]
 }
 
 fn issue_no_problem() -> DisjointConnectingPaths<SimpleGraph> {
@@ -31,7 +43,7 @@ fn test_disjoint_connecting_paths_creation() {
     assert_eq!(problem.num_edges(), 7);
     assert_eq!(problem.num_pairs(), 2);
     assert_eq!(problem.terminal_pairs(), &[(0, 3), (2, 5)]);
-    assert_eq!(problem.dims(), vec![2; 7]);
+    assert_eq!(problem.dimensions(), vec![2; 7]);
     assert_eq!(
         problem.ordered_edges(),
         vec![(0, 1), (0, 2), (1, 3), (1, 4), (2, 4), (3, 5), (4, 5)]
@@ -56,34 +68,41 @@ fn test_disjoint_connecting_paths_rejects_overlapping_terminals() {
 #[test]
 fn test_disjoint_connecting_paths_yes_instance() {
     let problem = issue_yes_problem();
-    assert!(problem.evaluate(&issue_yes_config()));
+    assert!(problem.evaluate(&issue_yes_config()).unwrap());
 }
 
 #[test]
 fn test_disjoint_connecting_paths_no_instance() {
     let problem = issue_no_problem();
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_disjoint_connecting_paths_rejects_wrong_length_config() {
     let problem = issue_yes_problem();
-    assert!(!problem.evaluate(&[1, 0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_disjoint_connecting_paths_rejects_non_binary_entries() {
     let problem = issue_yes_problem();
-    let mut config = issue_yes_config();
-    config[3] = 2;
-    assert!(!problem.evaluate(&config));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([1, 0, 1, 2, 1, 0, 1]),
+    )
+    .is_err());
 }
 
 #[test]
 fn test_disjoint_connecting_paths_rejects_branching_subgraph() {
     let problem = issue_yes_problem();
-    assert!(!problem.evaluate(&[1, 0, 1, 1, 1, 0, 1]));
+    assert!(!problem
+        .evaluate(&vec![true, false, true, true, true, false, true])
+        .unwrap());
 }
 
 #[test]
@@ -100,10 +119,10 @@ fn test_disjoint_connecting_paths_serialization() {
 fn test_disjoint_connecting_paths_paper_example() {
     let problem = issue_yes_problem();
     let config = issue_yes_config();
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
diff --git a/src/unit_tests/models/graph/eulerian_path.rs b/src/unit_tests/models/graph/eulerian_path.rs
index c9c50a6ba..2b6724a77 100644
--- a/src/unit_tests/models/graph/eulerian_path.rs
+++ b/src/unit_tests/models/graph/eulerian_path.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use crate::types::Or;
@@ -20,7 +21,7 @@ fn test_eulerian_path_creation() {
     assert_eq!(problem.num_vertices(), 3);
     assert_eq!(problem.num_arcs(), 4);
     // m = 4 position variables, each with domain {0..3}.
-    assert_eq!(problem.dims(), vec![4, 4, 4, 4]);
+    assert_eq!(problem.dimensions(), vec![4, 4, 4, 4]);
     assert_eq!(problem.num_variables(), 4);
 }
 
@@ -28,7 +29,7 @@ fn test_eulerian_path_creation() {
 fn test_eulerian_path_evaluate_valid_witness() {
     let problem = canonical_instance();
     // a_0 -> a_2 -> a_3 -> a_1 = (0->1)(1->2)(2->0)(0->1) -- a valid Eulerian trail.
-    assert_eq!(problem.evaluate(&[0, 2, 3, 1]), Or(true));
+    assert_eq!(problem.evaluate(&vec![0, 2, 3, 1]).unwrap(), Or(true));
     assert!(problem.is_valid_solution(&[0, 2, 3, 1]));
 }
 
@@ -36,44 +37,51 @@ fn test_eulerian_path_evaluate_valid_witness() {
 fn test_eulerian_path_evaluate_not_permutation() {
     let problem = canonical_instance();
     // Arc 0 reused; arc 2 is missing -> not a permutation of {0..3}.
-    assert_eq!(problem.evaluate(&[0, 0, 3, 1]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 0, 3, 1]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_eulerian_path_evaluate_bad_trail() {
     let problem = canonical_instance();
     // [0, 3, 2, 1]: arc 0 = (0->1), arc 3 = (2->0). head(0)=1 != tail(3)=2.
-    assert_eq!(problem.evaluate(&[0, 3, 2, 1]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 3, 2, 1]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_eulerian_path_evaluate_out_of_range() {
     let problem = canonical_instance();
     // Value 4 is outside the domain {0..3}.
-    assert_eq!(problem.evaluate(&[0, 2, 3, 4]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2, 3, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_eulerian_path_evaluate_wrong_length() {
     let problem = canonical_instance();
     // m = 4 but length 3.
-    assert_eq!(problem.evaluate(&[0, 2, 3]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_eulerian_path_brute_force_yes_instance() {
     let problem = canonical_instance();
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Or(true));
 
-    let witness = solver.find_witness(&problem).expect("yes-instance");
-    assert_eq!(problem.evaluate(&witness), Or(true));
+    let witness = solver.solve(&problem).unwrap().expect("yes-instance");
+    assert_eq!(problem.evaluate(&witness).unwrap(), Or(true));
 
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all.is_empty(), "expected at least one Eulerian witness");
     for w in &all {
-        assert_eq!(problem.evaluate(w), Or(true));
+        assert_eq!(problem.evaluate(w).unwrap(), Or(true));
     }
 }
 
@@ -85,9 +93,9 @@ fn test_eulerian_path_no_instance() {
     let graph = DirectedGraph::new(2, vec![(0, 1), (0, 1), (0, 1), (1, 0)]);
     let problem = EulerianPath::new(graph);
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Or(false));
-    assert!(solver.find_witness(&problem).is_none());
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+    assert!(solver.solve(&problem).unwrap().is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
+    assert!(solver.find_all_witnesses(&problem).unwrap().is_empty());
 }
 
 #[test]
@@ -95,13 +103,18 @@ fn test_eulerian_path_empty_arcs_instance() {
     // m = 0 (only isolated vertices): dims = [] and the empty witness is valid.
     let graph = DirectedGraph::new(3, vec![]);
     let problem = EulerianPath::new(graph);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
     assert_eq!(problem.num_variables(), 0);
-    assert_eq!(problem.evaluate(&[]), Or(true));
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Or(true));
 
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Or(true));
-    let witness = solver.find_witness(&problem).expect("empty witness");
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Or(true)
+    );
+    let witness = solver.solve(&problem).unwrap().expect("empty witness");
     assert!(witness.is_empty());
 }
 
diff --git a/src/unit_tests/models/graph/generalized_hex.rs b/src/unit_tests/models/graph/generalized_hex.rs
index 7b9799099..dad6efcb1 100644
--- a/src/unit_tests/models/graph/generalized_hex.rs
+++ b/src/unit_tests/models/graph/generalized_hex.rs
@@ -1,8 +1,21 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
+#[test]
+fn create_spec_uses_sink_input() {
+    assert_eq!(GeneralizedHexCreateSpec::FIELDS[2].name, "sink");
+    let problem = GeneralizedHex::try_from(GeneralizedHexCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        source: 0,
+        sink: 1,
+    })
+    .unwrap();
+    assert_eq!(problem.target(), 1);
+}
+
 fn issue_example() -> GeneralizedHex<SimpleGraph> {
     GeneralizedHex::new(
         SimpleGraph::new(
@@ -44,31 +57,28 @@ fn test_generalized_hex_creation_and_getters() {
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 7);
     assert_eq!(problem.num_playable_vertices(), 4);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
     assert_eq!(problem.graph().num_vertices(), 6);
 }
 
 #[test]
 fn test_generalized_hex_forced_win_on_bottleneck_example() {
     let problem = winning_example();
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&()).unwrap());
 }
 
 #[test]
 fn test_generalized_hex_detects_losing_position() {
     let problem = GeneralizedHex::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]), 0, 3);
-    assert!(!problem.evaluate(&[]));
+    assert!(!problem.evaluate(&()).unwrap());
 }
 
 #[test]
 fn test_generalized_hex_solver_returns_empty_config_for_win() {
     let problem = winning_example();
     let solver = BruteForce::new();
-    assert_eq!(solver.find_witness(&problem), Some(vec![]));
-    assert_eq!(
-        solver.find_all_witnesses(&problem),
-        Vec::<Vec<usize>>::from([vec![]])
-    );
+    assert_eq!(solver.solve(&problem).unwrap(), Some(()));
+    assert_eq!(solver.find_all_witnesses(&problem).unwrap(), vec![()]);
 }
 
 #[test]
@@ -86,20 +96,20 @@ fn test_generalized_hex_serialization_round_trip() {
     let decoded: GeneralizedHex<SimpleGraph> = serde_json::from_str(&json).unwrap();
     assert_eq!(decoded.source(), 0);
     assert_eq!(decoded.target(), 5);
-    assert!(decoded.evaluate(&[]));
+    assert!(decoded.evaluate(&()).unwrap());
 }
 
 #[test]
 fn test_generalized_hex_issue_example_is_losing_under_optimal_play() {
     let problem = issue_example();
-    assert!(!problem.evaluate(&[]));
+    assert!(!problem.evaluate(&()).unwrap());
 }
 
 #[test]
 fn test_generalized_hex_paper_example() {
     let problem = winning_example();
-    assert!(problem.evaluate(&[]));
-    assert_eq!(BruteForce::new().find_witness(&problem), Some(vec![]));
+    assert!(problem.evaluate(&()).unwrap());
+    assert_eq!(BruteForce::new().solve(&problem).unwrap(), Some(()));
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/graph_partitioning.rs b/src/unit_tests/models/graph/graph_partitioning.rs
index 2791d563b..e29077c1a 100644
--- a/src/unit_tests/models/graph/graph_partitioning.rs
+++ b/src/unit_tests/models/graph/graph_partitioning.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -28,13 +29,13 @@ fn test_graphpartitioning_basic() {
     let problem = issue_example();
 
     // Check dims: 6 binary variables
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2, 2, 2]);
 
     // Evaluate a valid balanced partition: A={0,1,2}, B={3,4,5}
     // config: [0, 0, 0, 1, 1, 1]
     // Crossing edges: (1,3), (2,3), (2,4) => cut = 3
-    let config = vec![0, 0, 0, 1, 1, 1];
-    let result = problem.evaluate(&config);
+    let config = vec![false, false, false, true, true, true];
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Min(Some(3)));
 }
 
@@ -47,23 +48,26 @@ fn test_graphpartitioning_serialization() {
     assert_eq!(deserialized.graph().num_edges(), 9);
 
     // Verify evaluation is consistent after round-trip
-    let config = vec![0, 0, 0, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), deserialized.evaluate(&config));
+    let config = vec![false, false, false, true, true, true];
+    assert_eq!(
+        problem.evaluate(&config).unwrap(),
+        deserialized.evaluate(&config).unwrap()
+    );
 }
 
 #[test]
 fn test_graphpartitioning_solver() {
     let problem = issue_example();
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    let size = problem.evaluate(&best);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    let size = problem.evaluate(&best).unwrap();
     assert_eq!(size, Min(Some(3)));
 
     // All optimal solutions should have cut = 3
-    let all_best = solver.find_all_witnesses(&problem);
+    let all_best = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all_best.is_empty());
     for sol in &all_best {
-        assert_eq!(problem.evaluate(sol), Min(Some(3)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Min(Some(3)));
     }
 }
 
@@ -74,11 +78,11 @@ fn test_graphpartitioning_odd_vertices() {
     let problem = GraphPartitioning::new(graph);
 
     // Every possible config should be Invalid
-    for a in 0..2 {
-        for b in 0..2 {
-            for c in 0..2 {
+    for a in [false, true] {
+        for b in [false, true] {
+            for c in [false, true] {
                 assert_eq!(
-                    problem.evaluate(&[a, b, c]),
+                    problem.evaluate(&vec![a, b, c]).unwrap(),
                     Min(None),
                     "Expected Invalid for odd n, config [{}, {}, {}]",
                     a,
@@ -97,31 +101,50 @@ fn test_graphpartitioning_unbalanced_invalid() {
     let problem = GraphPartitioning::new(graph);
 
     // All zeros: 0 ones, not balanced
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false, false]).unwrap(),
+        Min(None)
+    );
 
     // All ones: 4 ones, not balanced
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true, true]).unwrap(),
+        Min(None)
+    );
 
     // One vertex in partition 1: not balanced
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false, false]).unwrap(),
+        Min(None)
+    );
 
     // Three vertices in partition 1: not balanced
-    assert_eq!(problem.evaluate(&[1, 1, 1, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true, false]).unwrap(),
+        Min(None)
+    );
 
     // Two vertices in partition 1: balanced, should be Valid
     // 4-cycle edges: (0,1),(1,2),(2,3),(0,3). Config [1,1,0,0] cuts (1,2) and (0,3) => cut=2
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0]), Min(Some(2)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false, false]).unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
 fn test_graphpartitioning_rejects_non_binary_configs() {
     let problem = issue_example();
 
-    assert_eq!(problem.evaluate(&[0, 0, 1, 1, 1, 2]), Min(None));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([false, false, true, true, true, 2])
+    )
+    .is_err());
 }
 
 #[test]
-fn test_graphpartitioning_size_getters() {
+fn test_graphpartitioning_parameter_getters() {
     let problem = issue_example();
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 9);
@@ -134,11 +157,11 @@ fn test_graphpartitioning_square_graph() {
     let problem = GraphPartitioning::new(graph);
 
     let solver = BruteForce::new();
-    let all_best = solver.find_all_witnesses(&problem);
+    let all_best = solver.find_all_witnesses(&problem).unwrap();
 
     // Minimum bisection of a 4-cycle: cut = 2
     for sol in &all_best {
-        assert_eq!(problem.evaluate(sol), Min(Some(2)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Min(Some(2)));
     }
 }
 
@@ -164,6 +187,6 @@ fn test_graphpartitioning_empty_graph() {
     let graph = SimpleGraph::new(4, vec![]);
     let problem = GraphPartitioning::new(graph);
 
-    let config = vec![0, 0, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(0)));
+    let config = vec![false, false, true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(0)));
 }
diff --git a/src/unit_tests/models/graph/hamiltonian_circuit.rs b/src/unit_tests/models/graph/hamiltonian_circuit.rs
index 42f6e8d79..fc2d684cb 100644
--- a/src/unit_tests/models/graph/hamiltonian_circuit.rs
+++ b/src/unit_tests/models/graph/hamiltonian_circuit.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -25,23 +26,29 @@ fn test_hamiltonian_circuit_basic() {
 
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 9);
-    assert_eq!(problem.dims(), vec![6; 6]);
+    assert_eq!(problem.dimensions(), vec![6; 6]);
 
     // Valid Hamiltonian circuit: 0->1->2->5->4->3->0
     // Edges used: (0,1), (1,2), (2,5), (5,4), (4,3), (3,0) -- all present
-    assert!(problem.evaluate(&[0, 1, 2, 5, 4, 3]));
+    assert!(problem.evaluate(&vec![0, 1, 2, 5, 4, 3]).unwrap());
 
     // Invalid: 0->1->2->3 requires edge (2,3) which is NOT in the edge list
-    assert!(!problem.evaluate(&[0, 1, 2, 3, 4, 5]));
+    assert!(!problem.evaluate(&vec![0, 1, 2, 3, 4, 5]).unwrap());
 
     // Invalid: duplicate vertex 0 -- not a valid permutation
-    assert!(!problem.evaluate(&[0, 0, 1, 2, 3, 4]));
+    assert!(!problem.evaluate(&vec![0, 0, 1, 2, 3, 4]).unwrap());
 
     // Invalid: wrong-length config
-    assert!(!problem.evaluate(&[0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 
     // Invalid: vertex out of range
-    assert!(!problem.evaluate(&[0, 1, 2, 3, 4, 99]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 4, 99]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -49,23 +56,23 @@ fn test_hamiltonian_circuit_small_graphs() {
     // Empty graph (0 vertices): n < 3, no circuit possible
     let graph = SimpleGraph::new(0, vec![]);
     let problem = HamiltonianCircuit::new(graph);
-    assert!(!problem.evaluate(&[]));
+    assert!(!problem.evaluate(&vec![]).unwrap());
 
     // Single vertex: n < 3
     let graph = SimpleGraph::new(1, vec![]);
     let problem = HamiltonianCircuit::new(graph);
-    assert!(!problem.evaluate(&[0]));
+    assert!(!problem.evaluate(&vec![0]).unwrap());
 
     // Two vertices with edge: n < 3
     let graph = SimpleGraph::new(2, vec![(0, 1)]);
     let problem = HamiltonianCircuit::new(graph);
-    assert!(!problem.evaluate(&[0, 1]));
+    assert!(!problem.evaluate(&vec![0, 1]).unwrap());
 
     // Triangle (K3): smallest valid Hamiltonian circuit
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
     let problem = HamiltonianCircuit::new(graph);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // K3 has 6 directed Hamiltonian circuits: 3 rotations x 2 directions
     assert_eq!(solutions.len(), 6);
 }
@@ -77,12 +84,12 @@ fn test_hamiltonian_circuit_complete_graph_k4() {
     let problem = HamiltonianCircuit::new(graph);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // K4 has 3 distinct undirected Hamiltonian circuits, each yielding
     // 4 rotations x 2 directions = 8 directed permutations => 24 total
     assert_eq!(solutions.len(), 24);
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -93,8 +100,8 @@ fn test_hamiltonian_circuit_no_solution() {
     let problem = HamiltonianCircuit::new(graph);
 
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+    assert!(solver.solve(&problem).unwrap().is_none());
+    assert!(solver.find_all_witnesses(&problem).unwrap().is_empty());
 }
 
 #[test]
@@ -104,13 +111,13 @@ fn test_hamiltonian_circuit_solver() {
     let problem = HamiltonianCircuit::new(graph);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
 
     // 4-cycle has 8 Hamiltonian circuits: 4 starting positions x 2 directions
     assert_eq!(solutions.len(), 8);
 
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -122,16 +129,16 @@ fn test_hamiltonian_circuit_serialization() {
     let json = serde_json::to_string(&problem).unwrap();
     let restored: HamiltonianCircuit<SimpleGraph> = serde_json::from_str(&json).unwrap();
 
-    assert_eq!(problem.dims(), restored.dims());
+    assert_eq!(problem.dimensions(), restored.dimensions());
 
     // Valid circuit gives the same result on both instances
     assert_eq!(
-        problem.evaluate(&[0, 1, 2, 3]),
-        restored.evaluate(&[0, 1, 2, 3])
+        problem.evaluate(&vec![0, 1, 2, 3]).unwrap(),
+        restored.evaluate(&vec![0, 1, 2, 3]).unwrap()
     );
     // Invalid config gives the same result on both instances
     assert_eq!(
-        problem.evaluate(&[0, 0, 1, 2]),
-        restored.evaluate(&[0, 0, 1, 2])
+        problem.evaluate(&vec![0, 0, 1, 2]).unwrap(),
+        restored.evaluate(&vec![0, 0, 1, 2]).unwrap()
     );
 }
diff --git a/src/unit_tests/models/graph/hamiltonian_path.rs b/src/unit_tests/models/graph/hamiltonian_path.rs
index 55078a641..c86819a08 100644
--- a/src/unit_tests/models/graph/hamiltonian_path.rs
+++ b/src/unit_tests/models/graph/hamiltonian_path.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 
 #[test]
@@ -10,16 +11,16 @@ fn test_hamiltonian_path_basic() {
     let problem = HamiltonianPath::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 3);
-    assert_eq!(problem.dims(), vec![4, 4, 4, 4]);
+    assert_eq!(problem.dimensions(), vec![4, 4, 4, 4]);
 
     // Valid path: 0->1->2->3
-    assert!(problem.evaluate(&[0, 1, 2, 3]));
+    assert!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap());
     // Valid path: 3->2->1->0 (reversed)
-    assert!(problem.evaluate(&[3, 2, 1, 0]));
+    assert!(problem.evaluate(&vec![3, 2, 1, 0]).unwrap());
     // Invalid: 0->1->3->2 (no edge 1-3)
-    assert!(!problem.evaluate(&[0, 1, 3, 2]));
+    assert!(!problem.evaluate(&vec![0, 1, 3, 2]).unwrap());
     // Invalid: not a permutation (repeated vertex)
-    assert!(!problem.evaluate(&[0, 1, 1, 2]));
+    assert!(!problem.evaluate(&vec![0, 1, 1, 2]).unwrap());
 }
 
 #[test]
@@ -30,7 +31,7 @@ fn test_hamiltonian_path_no_solution() {
         vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)],
     ));
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(
         solution.is_none(),
         "Graph with isolated vertices has no Hamiltonian path"
@@ -45,15 +46,15 @@ fn test_hamiltonian_path_brute_force() {
     let problem = HamiltonianPath::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
     let solver = BruteForce::new();
 
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     // Path graph P4 has exactly 2 Hamiltonian paths: 0-1-2-3 and 3-2-1-0
     assert_eq!(all.len(), 2);
     for sol in &all {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -76,7 +77,7 @@ fn test_hamiltonian_path_nontrivial() {
         ],
     ));
     // Hamiltonian path: 0->2->4->3->1->5
-    assert!(problem.evaluate(&[0, 2, 4, 3, 1, 5]));
+    assert!(problem.evaluate(&vec![0, 2, 4, 3, 1, 5]).unwrap());
 }
 
 #[test]
@@ -87,7 +88,7 @@ fn test_hamiltonian_path_complete_graph() {
         vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)],
     ));
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     // K4 has 4! = 24 Hamiltonian paths (all permutations)
     assert_eq!(all.len(), 24);
 }
@@ -121,7 +122,7 @@ fn test_is_valid_solution() {
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = HamiltonianPath::new(SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]));
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_edges(), 4);
@@ -147,14 +148,14 @@ fn test_hamiltonianpath_paper_example() {
     ));
 
     // Hamiltonian path: 0→2→4→3→1→5
-    assert!(problem.evaluate(&[0, 2, 4, 3, 1, 5]));
+    assert!(problem.evaluate(&vec![0, 2, 4, 3, 1, 5]).unwrap());
 
     // Verify with brute force
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all.is_empty());
     for sol in &all {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -164,8 +165,8 @@ fn test_single_vertex() {
 
     // Single vertex graph: trivially has a Hamiltonian "path" (just the vertex)
     let problem = HamiltonianPath::new(SimpleGraph::new(1, vec![]));
-    assert!(problem.evaluate(&[0]));
+    assert!(problem.evaluate(&vec![0]).unwrap());
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all.len(), 1);
 }
diff --git a/src/unit_tests/models/graph/hamiltonian_path_between_two_vertices.rs b/src/unit_tests/models/graph/hamiltonian_path_between_two_vertices.rs
index 05f1d3586..e2e22856f 100644
--- a/src/unit_tests/models/graph/hamiltonian_path_between_two_vertices.rs
+++ b/src/unit_tests/models/graph/hamiltonian_path_between_two_vertices.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 
 #[test]
@@ -16,18 +17,18 @@ fn test_hamiltonian_path_between_two_vertices_basic() {
     assert_eq!(problem.num_edges(), 3);
     assert_eq!(problem.source_vertex(), 0);
     assert_eq!(problem.target_vertex(), 3);
-    assert_eq!(problem.dims(), vec![4, 4, 4, 4]);
+    assert_eq!(problem.dimensions(), vec![4, 4, 4, 4]);
 
     // Valid path: 0->1->2->3
-    assert!(problem.evaluate(&[0, 1, 2, 3]));
+    assert!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap());
     // Reversed path fails (wrong source/target)
-    assert!(!problem.evaluate(&[3, 2, 1, 0]));
+    assert!(!problem.evaluate(&vec![3, 2, 1, 0]).unwrap());
     // Invalid: wrong start vertex
-    assert!(!problem.evaluate(&[1, 0, 2, 3]));
+    assert!(!problem.evaluate(&vec![1, 0, 2, 3]).unwrap());
     // Invalid: wrong end vertex
-    assert!(!problem.evaluate(&[0, 1, 3, 2]));
+    assert!(!problem.evaluate(&vec![0, 1, 3, 2]).unwrap());
     // Invalid: not a permutation
-    assert!(!problem.evaluate(&[0, 1, 1, 3]));
+    assert!(!problem.evaluate(&vec![0, 1, 1, 3]).unwrap());
 }
 
 #[test]
@@ -39,7 +40,7 @@ fn test_hamiltonian_path_between_two_vertices_no_solution() {
         2,
     );
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(
         solution.is_none(),
         "C5 with s=0, t=2 has no Hamiltonian s-t path"
@@ -70,18 +71,18 @@ fn test_hamiltonian_path_between_two_vertices_brute_force() {
     );
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let sol = solution.unwrap();
-    assert!(problem.evaluate(&sol));
+    assert!(problem.evaluate(&sol).unwrap());
     assert_eq!(sol[0], 0, "Path must start at source vertex 0");
     assert_eq!(sol[5], 5, "Path must end at target vertex 5");
 
     // Issue says there are exactly 4 distinct Hamiltonian s-t paths
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all.len(), 4);
     for path in &all {
-        assert!(problem.evaluate(path));
+        assert!(problem.evaluate(path).unwrap());
         assert_eq!(path[0], 0);
         assert_eq!(path[5], 5);
     }
@@ -148,7 +149,7 @@ fn test_hamiltonian_path_between_two_vertices_paper_example() {
     );
 
     // Issue-specified solution: 0 -> 3 -> 2 -> 1 -> 4 -> 5
-    assert!(problem.evaluate(&[0, 3, 2, 1, 4, 5]));
+    assert!(problem.evaluate(&vec![0, 3, 2, 1, 4, 5]).unwrap());
 
     // Verify edge-by-edge
     let path = [0usize, 3, 2, 1, 4, 5];
@@ -157,7 +158,7 @@ fn test_hamiltonian_path_between_two_vertices_paper_example() {
 
     // Verify brute force confirms the problem
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all.len(), 4, "issue says 4 Hamiltonian s-t paths exist");
     assert!(all.contains(&vec![0, 3, 2, 1, 4, 5]));
 }
diff --git a/src/unit_tests/models/graph/highly_connected_deletion.rs b/src/unit_tests/models/graph/highly_connected_deletion.rs
index 2f6845f48..f0bffa6cb 100644
--- a/src/unit_tests/models/graph/highly_connected_deletion.rs
+++ b/src/unit_tests/models/graph/highly_connected_deletion.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -27,7 +28,7 @@ fn test_highly_connected_deletion_creation() {
     assert_eq!(problem.graph().num_edges(), 4);
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 4);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2]);
     assert_eq!(problem.num_variables(), 4);
 }
 
@@ -43,8 +44,8 @@ fn test_highly_connected_deletion_problem_name() {
 fn test_highly_connected_deletion_evaluate_optimum() {
     // Delete only the leaf edge (2,3) at index 3 → K3 on {0,1,2} + isolated {3}.
     let problem = canonical_problem();
-    let config = vec![0, 0, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(1)));
+    let config = vec![false, false, false, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(1)));
     assert!(problem.is_valid_solution(&config));
 }
 
@@ -53,8 +54,8 @@ fn test_highly_connected_deletion_evaluate_zero_deletions_infeasible() {
     // No deletions: the whole graph on 4 vertices has min cut 1 (vertex 3 has degree 1),
     // and 2*1 = 2 <= 4, so the unique component is not highly connected → infeasible.
     let problem = canonical_problem();
-    let config = vec![0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![false, false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
     assert!(!problem.is_valid_solution(&config));
 }
 
@@ -62,8 +63,8 @@ fn test_highly_connected_deletion_evaluate_zero_deletions_infeasible() {
 fn test_highly_connected_deletion_evaluate_delete_all_feasible() {
     // Deleting every edge yields 4 isolated vertices — all singletons are allowed.
     let problem = canonical_problem();
-    let config = vec![1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(4)));
+    let config = vec![true, true, true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(4)));
     assert!(problem.is_valid_solution(&config));
 }
 
@@ -72,8 +73,8 @@ fn test_highly_connected_deletion_evaluate_two_vertex_component_infeasible() {
     // Delete (0,1),(0,2),(1,2); keep only (2,3).
     // Components: {0}, {1}, {2,3}. The 2-vertex component {2,3} is never a valid cluster.
     let problem = canonical_problem();
-    let config = vec![1, 1, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![true, true, true, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
     assert!(!problem.is_valid_solution(&config));
 }
 
@@ -83,8 +84,8 @@ fn test_highly_connected_deletion_evaluate_path_component_infeasible() {
     // Components: {1}, {0,2,3} with edges (0,2),(2,3) — a path P_3.
     // λ(P_3) = 1, 2*1 = 2 <= 3 → not highly connected → infeasible.
     let problem = canonical_problem();
-    let config = vec![1, 0, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![true, false, true, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -92,8 +93,11 @@ fn test_highly_connected_deletion_evaluate_wrong_config_length() {
     // A config whose length disagrees with the number of edges is rejected by the
     // feasibility check (it can never describe a valid deletion).
     let problem = canonical_problem();
-    let too_short = vec![0, 0, 0];
-    assert_eq!(problem.evaluate(&too_short), Min(None));
+    let too_short = vec![false, false, false];
+    assert!(matches!(
+        problem.evaluate(&too_short),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     assert!(!problem.is_valid_solution(&too_short));
 }
 
@@ -101,9 +105,14 @@ fn test_highly_connected_deletion_evaluate_wrong_config_length() {
 fn test_highly_connected_deletion_brute_force_canonical() {
     // Brute force over 2^4 = 16 configs; optimum is delete only edge (2,3) → value 1.
     let problem = canonical_problem();
-    assert_eq!(BruteForce::new().solve(&problem), Min(Some(1)));
-    let witness = BruteForce::new().find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&witness), Min(Some(1)));
+    assert_eq!(
+        problem
+            .evaluate(&BruteForce::new().solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(1))
+    );
+    let witness = BruteForce::new().solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -113,20 +122,25 @@ fn test_highly_connected_deletion_brute_force_double_triangle() {
     // Keeping any extra edge of either triangle either leaves the whole graph
     // connected (which is infeasible) or creates a non-highly-connected component.
     let problem = double_triangle_problem();
-    assert_eq!(BruteForce::new().solve(&problem), Min(Some(1)));
+    assert_eq!(
+        problem
+            .evaluate(&BruteForce::new().solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(1))
+    );
 
     // Verify the named optimal config evaluates to 1.
-    let bridge_only = vec![0, 0, 0, 1, 0, 0, 0];
-    assert_eq!(problem.evaluate(&bridge_only), Min(Some(1)));
+    let bridge_only = vec![false, false, false, true, false, false, false];
+    assert_eq!(problem.evaluate(&bridge_only).unwrap(), Min(Some(1)));
 
     // The all-zero config is infeasible because the bridge gives the union min cut 1.
-    let no_deletions = vec![0; 7];
-    assert_eq!(problem.evaluate(&no_deletions), Min(None));
+    let no_deletions = vec![false; 7];
+    assert_eq!(problem.evaluate(&no_deletions).unwrap(), Min(None));
 
     // Deleting one extra triangle edge in addition to the bridge breaks one K3 into
     // a 3-vertex path, which is no longer highly connected → infeasible.
-    let bridge_plus_one = vec![1, 0, 0, 1, 0, 0, 0];
-    assert_eq!(problem.evaluate(&bridge_plus_one), Min(None));
+    let bridge_plus_one = vec![true, false, false, true, false, false, false];
+    assert_eq!(problem.evaluate(&bridge_plus_one).unwrap(), Min(None));
 }
 
 #[test]
@@ -137,7 +151,10 @@ fn test_highly_connected_deletion_serialization() {
     assert_eq!(restored.graph().num_vertices(), 4);
     assert_eq!(restored.graph().num_edges(), 4);
     // Evaluating on the canonical optimum still yields 1 after the round trip.
-    assert_eq!(restored.evaluate(&[0, 0, 0, 1]), Min(Some(1)));
+    assert_eq!(
+        restored.evaluate(&vec![false, false, false, true]).unwrap(),
+        Min(Some(1))
+    );
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/integral_flow_bundles.rs b/src/unit_tests/models/graph/integral_flow_bundles.rs
index 0e95b3c24..d8c7b3f79 100644
--- a/src/unit_tests/models/graph/integral_flow_bundles.rs
+++ b/src/unit_tests/models/graph/integral_flow_bundles.rs
@@ -1,4 +1,20 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+#[test]
+fn create_spec_requires_bundle_coverage() {
+    assert!(
+        IntegralFlowBundles::try_from(IntegralFlowBundlesCreateSpec {
+            arcs: vec![(0, 1), (1, 2)],
+            num_vertices: None,
+            bundles: vec![vec![0]],
+            bundle_capacities: vec![1],
+            source: 0,
+            sink: 2,
+            requirement: 1
+        })
+        .is_err()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
@@ -45,7 +61,7 @@ fn test_integral_flow_bundles_creation_and_getters() {
 #[test]
 fn test_integral_flow_bundles_dims_use_tight_arc_bounds() {
     let problem = yes_instance();
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2, 2, 2]);
 }
 
 #[test]
@@ -53,9 +69,9 @@ fn test_integral_flow_bundles_evaluate_yes_and_no_examples() {
     let yes = yes_instance();
     let no = no_instance();
     let config = satisfying_config();
-    assert!(yes.evaluate(&config));
-    assert!(!no.evaluate(&config));
-    assert!(yes.is_valid_solution(&config));
+    assert!(yes.evaluate(&config).unwrap());
+    assert!(!no.evaluate(&config).unwrap());
+    assert!(yes.is_valid_solution(&config).unwrap());
 }
 
 #[test]
@@ -64,20 +80,20 @@ fn test_integral_flow_bundles_rejects_bad_bundle_sum_or_conservation() {
 
     let mut bundle_violation = satisfying_config();
     bundle_violation[1] = 1;
-    assert!(!problem.evaluate(&bundle_violation));
+    assert!(!problem.evaluate(&bundle_violation).unwrap());
 
     let conservation_violation = vec![1, 0, 0, 0, 0, 0];
-    assert!(!problem.evaluate(&conservation_violation));
+    assert!(!problem.evaluate(&conservation_violation).unwrap());
 }
 
 #[test]
 fn test_integral_flow_bundles_solver_and_paper_example() {
     let problem = yes_instance();
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all.is_empty());
     assert!(all.contains(&satisfying_config()));
-    assert!(problem.evaluate(&satisfying_config()));
+    assert!(problem.evaluate(&satisfying_config()).unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/integral_flow_homologous_arcs.rs b/src/unit_tests/models/graph/integral_flow_homologous_arcs.rs
index 2ce6a5e7d..e15116232 100644
--- a/src/unit_tests/models/graph/integral_flow_homologous_arcs.rs
+++ b/src/unit_tests/models/graph/integral_flow_homologous_arcs.rs
@@ -1,4 +1,19 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+#[test]
+fn create_spec_defaults_capacities() {
+    let problem = IntegralFlowHomologousArcs::try_from(IntegralFlowHomologousArcsCreateSpec {
+        arcs: vec![(0, 1)],
+        num_vertices: None,
+        capacities: None,
+        source: 0,
+        sink: 1,
+        requirement: 1,
+        homologous_pairs: vec![],
+    })
+    .unwrap();
+    assert_eq!(problem.capacities(), &[1]);
+}
 use crate::solvers::BruteForce;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
@@ -35,64 +50,70 @@ fn test_integral_flow_homologous_arcs_creation() {
     assert_eq!(problem.requirement(), 2);
     assert_eq!(problem.max_capacity(), 1);
     assert_eq!(problem.homologous_pairs(), &[(2, 5), (4, 3)]);
-    assert_eq!(problem.dims(), vec![2; 8]);
+    assert_eq!(problem.dimensions(), vec![2; 8]);
 }
 
 #[test]
 fn test_integral_flow_homologous_arcs_evaluate_yes_instance() {
     let problem = yes_instance();
     let config = vec![1, 1, 1, 0, 0, 1, 1, 1];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_integral_flow_homologous_arcs_evaluate_no_instance() {
     let problem = no_instance();
-    assert!(!problem.evaluate(&[0, 0, 0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 0]).unwrap());
 }
 
 #[test]
 fn test_integral_flow_homologous_arcs_rejects_homologous_violation() {
     let problem = yes_instance();
     let config = vec![1, 1, 1, 0, 0, 0, 1, 1];
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_integral_flow_homologous_arcs_rejects_capacity_violation() {
     let problem = yes_instance();
     let config = vec![2, 0, 0, 0, 0, 0, 0, 0];
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_integral_flow_homologous_arcs_rejects_conservation_violation() {
     let problem = yes_instance();
     let config = vec![1, 0, 0, 0, 0, 0, 0, 0];
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_integral_flow_homologous_arcs_wrong_config_length_is_invalid() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[0; 7]));
-    assert!(!problem.evaluate(&[0; 9]));
+    assert!(matches!(
+        problem.evaluate(&vec![0; 7]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0; 9]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_integral_flow_homologous_arcs_solver_yes() {
     let problem = yes_instance();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
 fn test_integral_flow_homologous_arcs_solver_no() {
     let problem = no_instance();
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -120,13 +141,13 @@ fn test_integral_flow_homologous_arcs_non_unit_capacity() {
     // equal flow. R=2 is satisfiable: f=[2,2].
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = IntegralFlowHomologousArcs::new(graph, vec![3, 3], 0, 2, 2, vec![(0, 1)]);
-    assert_eq!(problem.dims(), vec![4, 4]);
+    assert_eq!(problem.dimensions(), vec![4, 4]);
     assert_eq!(problem.max_capacity(), 3);
-    assert!(problem.evaluate(&[2, 2]));
-    assert!(problem.evaluate(&[3, 3]));
-    assert!(!problem.evaluate(&[2, 3])); // homologous violation
+    assert!(problem.evaluate(&vec![2, 2]).unwrap());
+    assert!(problem.evaluate(&vec![3, 3]).unwrap());
+    assert!(!problem.evaluate(&vec![2, 3]).unwrap()); // homologous violation
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 2); // [2,2] and [3,3]
 }
 
@@ -136,11 +157,11 @@ fn test_integral_flow_homologous_arcs_paper_example() {
     let solver = BruteForce::new();
     let config = vec![1, 1, 1, 0, 0, 1, 1, 1];
 
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     assert!(solutions
         .iter()
-        .all(|solution| problem.evaluate(solution).0));
+        .all(|solution| problem.evaluate(solution).unwrap().0));
 }
diff --git a/src/unit_tests/models/graph/integral_flow_with_multipliers.rs b/src/unit_tests/models/graph/integral_flow_with_multipliers.rs
index a4afd16af..394d59128 100644
--- a/src/unit_tests/models/graph/integral_flow_with_multipliers.rs
+++ b/src/unit_tests/models/graph/integral_flow_with_multipliers.rs
@@ -1,5 +1,20 @@
 use super::*;
-use crate::registry::declared_size_fields;
+use crate::solvers::BruteForceProblem as _;
+#[test]
+fn create_spec_rejects_zero_internal_multiplier() {
+    assert!(
+        IntegralFlowWithMultipliers::try_from(IntegralFlowWithMultipliersCreateSpec {
+            arcs: vec![(0, 1), (1, 2)],
+            num_vertices: None,
+            capacities: vec![1, 1],
+            source: 0,
+            sink: 2,
+            multipliers: vec![1, 0, 1],
+            requirement: 1
+        })
+        .is_err()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
@@ -53,38 +68,50 @@ fn test_integral_flow_with_multipliers_creation_accessors_and_dimensions() {
     assert_eq!(problem.max_capacity(), 6);
     assert_eq!(problem.multipliers(), &[1, 2, 3, 4, 5, 6, 4, 1]);
     assert_eq!(problem.capacities(), &[1, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 4]);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2, 2, 2, 3, 4, 5, 6, 7, 5]);
+    assert_eq!(
+        problem.dimensions(),
+        vec![2, 2, 2, 2, 2, 2, 3, 4, 5, 6, 7, 5]
+    );
 }
 
 #[test]
 fn test_integral_flow_with_multipliers_evaluate_yes_instance() {
-    assert!(yes_instance().evaluate(&yes_config()));
+    assert!(yes_instance().evaluate(&yes_config()).unwrap());
 }
 
 #[test]
 fn test_integral_flow_with_multipliers_evaluate_no_instance() {
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&no_instance()).is_none());
+    assert!(solver.solve(&no_instance()).unwrap().is_none());
 }
 
 #[test]
 fn test_integral_flow_with_multipliers_rejects_multiplier_conservation_violation() {
     let config = vec![1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];
-    assert!(!yes_instance().evaluate(&config));
+    assert!(!yes_instance().evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_integral_flow_with_multipliers_sink_requirement_is_at_least() {
     let config = vec![0, 0, 1, 1, 1, 0, 0, 0, 4, 5, 6, 0];
-    assert!(yes_instance().evaluate(&config));
+    assert!(yes_instance().evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_integral_flow_with_multipliers_rejects_wrong_config_length() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[0; 11]));
-    assert!(!problem.evaluate(&[0; 13]));
-    assert!(!problem.evaluate(&[]));
+    assert!(matches!(
+        problem.evaluate(&vec![0; 11]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0; 13]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -103,18 +130,19 @@ fn test_integral_flow_with_multipliers_serialization_round_trip() {
 fn test_integral_flow_with_multipliers_solver_yes_instance() {
     let problem = yes_instance();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert!(problem.evaluate(&solution));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
-fn test_integral_flow_with_multipliers_problem_name_and_size_fields() {
+fn test_integral_flow_with_multipliers_problem_name_and_parameters() {
     assert_eq!(
         <IntegralFlowWithMultipliers as Problem>::NAME,
         "IntegralFlowWithMultipliers"
     );
-    let fields: HashSet<&'static str> = declared_size_fields("IntegralFlowWithMultipliers")
-        .into_iter()
+    let fields: HashSet<&'static str> = IntegralFlowWithMultipliers::parameter_names()
+        .iter()
+        .copied()
         .collect();
     assert_eq!(
         fields,
@@ -129,7 +157,7 @@ fn test_integral_flow_with_multipliers_canonical_example_spec() {
     assert_eq!(specs.len(), 1);
     let spec = &specs[0];
     assert_eq!(spec.id, "integral_flow_with_multipliers");
-    assert_eq!(spec.optimal_config, yes_config());
+    assert_eq!(spec.optimal_config, serde_json::json!(yes_config()));
     assert_eq!(spec.optimal_value, serde_json::json!(true));
 }
 
@@ -139,11 +167,11 @@ fn test_integral_flow_with_multipliers_paper_example() {
     let config = yes_config();
     let solver = BruteForce::new();
 
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
     assert_eq!([config[0], config[2], config[4]], [1, 1, 1]);
     assert_eq!([config[6], config[8], config[10]], [2, 4, 6]);
     assert_eq!(config[6] + config[8] + config[10], 12);
 
-    let all_solutions = solver.find_all_witnesses(&problem);
+    let all_solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(all_solutions.iter().any(|solution| solution == &config));
 }
diff --git a/src/unit_tests/models/graph/isomorphic_spanning_tree.rs b/src/unit_tests/models/graph/isomorphic_spanning_tree.rs
index 51e89cc66..3f7f244c5 100644
--- a/src/unit_tests/models/graph/isomorphic_spanning_tree.rs
+++ b/src/unit_tests/models/graph/isomorphic_spanning_tree.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 
@@ -11,7 +12,7 @@ fn test_isomorphicspanningtree_basic() {
     let problem: IsomorphicSpanningTree<SimpleGraph> =
         IsomorphicSpanningTree::new(graph.clone(), tree.clone());
 
-    assert_eq!(problem.dims(), vec![3, 3, 3]);
+    assert_eq!(problem.dimensions(), vec![3, 3, 3]);
     assert_eq!(problem.graph(), &graph);
     assert_eq!(problem.tree(), &tree);
     assert_eq!(problem.num_vertices(), 3);
@@ -33,11 +34,11 @@ fn test_isomorphicspanningtree_evaluation_yes() {
 
     // Identity mapping: π = [0, 1, 2]
     // Tree edges: (0,1) -> (0,1) ✓, (1,2) -> (1,2) ✓
-    assert!(problem.evaluate(&[0, 1, 2]));
+    assert!(problem.evaluate(&vec![0, 1, 2]).unwrap());
 
     // Reversed: π = [2, 1, 0]
     // Tree edges: (0,1) -> (2,1) ✓, (1,2) -> (1,0) ✓
-    assert!(problem.evaluate(&[2, 1, 0]));
+    assert!(problem.evaluate(&vec![2, 1, 0]).unwrap());
 }
 
 #[test]
@@ -56,9 +57,9 @@ fn test_isomorphicspanningtree_evaluation_no() {
     let problem = IsomorphicSpanningTree::new(graph, tree);
 
     // No permutation should work
-    assert!(!problem.evaluate(&[0, 1, 2, 3]));
-    assert!(!problem.evaluate(&[1, 0, 2, 3]));
-    assert!(!problem.evaluate(&[2, 1, 0, 3]));
+    assert!(!problem.evaluate(&vec![0, 1, 2, 3]).unwrap());
+    assert!(!problem.evaluate(&vec![1, 0, 2, 3]).unwrap());
+    assert!(!problem.evaluate(&vec![2, 1, 0, 3]).unwrap());
 }
 
 #[test]
@@ -68,11 +69,17 @@ fn test_isomorphicspanningtree_invalid_configs() {
     let problem = IsomorphicSpanningTree::new(graph, tree);
 
     // Not a permutation: repeated value
-    assert!(!problem.evaluate(&[0, 0, 1]));
+    assert!(!problem.evaluate(&vec![0, 0, 1]).unwrap());
     // Out of range
-    assert!(!problem.evaluate(&[0, 1, 3]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Wrong length
-    assert!(!problem.evaluate(&[0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -83,15 +90,15 @@ fn test_isomorphicspanningtree_solver_yes() {
     let problem = IsomorphicSpanningTree::new(graph, tree);
 
     let solver = BruteForce::new();
-    let sol = solver.find_witness(&problem);
+    let sol = solver.solve(&problem).unwrap();
     assert!(sol.is_some());
-    assert!(problem.evaluate(&sol.unwrap()));
+    assert!(problem.evaluate(&sol.unwrap()).unwrap());
 
     // All satisfying solutions should be valid
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all.is_empty());
     for s in &all {
-        assert!(problem.evaluate(s));
+        assert!(problem.evaluate(s).unwrap());
     }
 }
 
@@ -103,10 +110,10 @@ fn test_isomorphicspanningtree_solver_no() {
     let problem = IsomorphicSpanningTree::new(graph, tree);
 
     let solver = BruteForce::new();
-    let sol = solver.find_witness(&problem);
+    let sol = solver.solve(&problem).unwrap();
     assert!(sol.is_none());
 
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert!(all.is_empty());
 }
 
@@ -123,7 +130,7 @@ fn test_isomorphicspanningtree_serialization() {
     assert_eq!(deserialized.num_edges(), 3);
     assert_eq!(deserialized.tree_edges(), vec![(0, 1), (1, 2)]);
     // Verify same evaluation
-    assert!(deserialized.evaluate(&[0, 1, 2]));
+    assert!(deserialized.evaluate(&vec![0, 1, 2]).unwrap());
 }
 
 #[test]
@@ -153,7 +160,7 @@ fn test_isomorphicspanningtree_caterpillar_example() {
 
     // The issue gives solution: a→0, b→1, c→2, d→3, e→6, f→4, g→5
     // As config: π = [0, 1, 2, 3, 6, 4, 5]
-    assert!(problem.evaluate(&[0, 1, 2, 3, 6, 4, 5]));
+    assert!(problem.evaluate(&vec![0, 1, 2, 3, 6, 4, 5]).unwrap());
 }
 
 #[test]
@@ -166,11 +173,11 @@ fn test_isomorphicspanningtree_paper_example() {
     let problem = IsomorphicSpanningTree::new(graph, tree);
 
     // Identity mapping: π = [0, 1, 2, 3]
-    assert!(problem.evaluate(&[0, 1, 2, 3]));
+    assert!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap());
 
     // All 4! = 24 permutations should work since K4 has every edge
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all.len(), 24);
 }
 
@@ -206,3 +213,23 @@ fn test_isomorphicspanningtree_disconnected_tree() {
     let tree = SimpleGraph::new(4, vec![(0, 1), (1, 2), (0, 2)]);
     IsomorphicSpanningTree::new(graph, tree);
 }
+
+#[test]
+fn test_isomorphicspanningtree_deserialization_rejects_invalid_tree_invariants() {
+    for value in [
+        serde_json::json!({
+            "graph": {"num_vertices": 3, "edges": [[0, 1], [1, 2]]},
+            "tree": {"num_vertices": 1, "edges": []},
+        }),
+        serde_json::json!({
+            "graph": {"num_vertices": 3, "edges": [[0, 1], [1, 2]]},
+            "tree": {"num_vertices": 3, "edges": [[0, 1], [1, 2], [0, 2]]},
+        }),
+        serde_json::json!({
+            "graph": {"num_vertices": 4, "edges": [[0, 1], [1, 2], [2, 3]]},
+            "tree": {"num_vertices": 4, "edges": [[0, 1], [1, 2], [0, 2]]},
+        }),
+    ] {
+        assert!(serde_json::from_value::<IsomorphicSpanningTree<SimpleGraph>>(value).is_err());
+    }
+}
diff --git a/src/unit_tests/models/graph/kclique.rs b/src/unit_tests/models/graph/kclique.rs
index 16aca9e99..910275599 100644
--- a/src/unit_tests/models/graph/kclique.rs
+++ b/src/unit_tests/models/graph/kclique.rs
@@ -1,4 +1,14 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+#[test]
+fn create_spec_rejects_k_above_vertex_count() {
+    assert!(KClique::try_from(KCliqueCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+        k: 3
+    })
+    .is_err());
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -7,8 +17,8 @@ fn issue_graph() -> SimpleGraph {
     SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)])
 }
 
-fn issue_witness() -> Vec<usize> {
-    vec![0, 0, 1, 1, 1]
+fn issue_witness() -> Vec<bool> {
+    vec![false, false, true, true, true]
 }
 
 #[test]
@@ -20,14 +30,14 @@ fn test_kclique_creation() {
     assert_eq!(problem.k(), 3);
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_edges(), 6);
-    assert_eq!(problem.dims(), vec![2; 5]);
+    assert_eq!(problem.dimensions(), vec![2; 5]);
 }
 
 #[test]
 fn test_kclique_evaluate_yes_instance() {
     let problem = KClique::new(issue_graph(), 3);
 
-    assert!(problem.evaluate(&issue_witness()));
+    assert!(problem.evaluate(&issue_witness()).unwrap());
     assert!(problem.is_valid_solution(&issue_witness()));
 }
 
@@ -35,16 +45,22 @@ fn test_kclique_evaluate_yes_instance() {
 fn test_kclique_evaluate_rejects_non_clique() {
     let problem = KClique::new(issue_graph(), 3);
 
-    assert!(!problem.evaluate(&[1, 0, 1, 1, 0]));
-    assert!(!problem.is_valid_solution(&[1, 0, 1, 1, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, false, true, true, false])
+        .unwrap());
+    assert!(!problem.is_valid_solution(&[true, false, true, true, false]));
 }
 
 #[test]
 fn test_kclique_evaluate_rejects_too_small_clique() {
     let problem = KClique::new(issue_graph(), 3);
 
-    assert!(!problem.evaluate(&[1, 0, 1, 0, 0]));
-    assert!(!problem.evaluate(&[0, 0, 1, 1, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, false, true, false, false])
+        .unwrap());
+    assert!(!problem
+        .evaluate(&vec![false, false, true, true, false])
+        .unwrap());
 }
 
 #[test]
@@ -52,8 +68,11 @@ fn test_kclique_solver_finds_unique_witness() {
     let problem = KClique::new(issue_graph(), 3);
     let solver = BruteForce::new();
 
-    assert_eq!(solver.find_witness(&problem), Some(issue_witness()));
-    assert_eq!(solver.find_all_witnesses(&problem), vec![issue_witness()]);
+    assert_eq!(solver.solve(&problem).unwrap(), Some(issue_witness()));
+    assert_eq!(
+        solver.find_all_witnesses(&problem).unwrap(),
+        vec![issue_witness()]
+    );
 }
 
 #[test]
@@ -64,7 +83,7 @@ fn test_kclique_serialization_round_trip() {
 
     assert_eq!(restored.graph().edges(), problem.graph().edges());
     assert_eq!(restored.k(), 3);
-    assert!(restored.evaluate(&issue_witness()));
+    assert!(restored.evaluate(&issue_witness()).unwrap());
 }
 
 #[test]
@@ -72,8 +91,11 @@ fn test_kclique_paper_example() {
     let problem = KClique::new(issue_graph(), 3);
     let solver = BruteForce::new();
 
-    assert!(problem.evaluate(&issue_witness()));
-    assert_eq!(solver.find_all_witnesses(&problem), vec![issue_witness()]);
+    assert!(problem.evaluate(&issue_witness()).unwrap());
+    assert_eq!(
+        solver.find_all_witnesses(&problem).unwrap(),
+        vec![issue_witness()]
+    );
 }
 
 #[test]
@@ -86,6 +108,6 @@ fn test_kclique_config_from_selected_vertices() {
     );
     assert_eq!(
         problem.config_from_selected_vertices(&[4, 2, 4]),
-        vec![0, 0, 1, 0, 1]
+        vec![false, false, true, false, true]
     );
 }
diff --git a/src/unit_tests/models/graph/kcoloring.rs b/src/unit_tests/models/graph/kcoloring.rs
index 2185b0337..588c5721e 100644
--- a/src/unit_tests/models/graph/kcoloring.rs
+++ b/src/unit_tests/models/graph/kcoloring.rs
@@ -1,4 +1,37 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_specs_separate_runtime_and_fixed_color_counts() {
+    let runtime = KColoring::<KN, SimpleGraph>::try_from(RuntimeKColoringCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: Some(3),
+        k: 4,
+    })
+    .unwrap();
+    assert_eq!(runtime.num_vertices(), 3);
+    assert_eq!(runtime.num_colors(), 4);
+
+    let fixed = KColoring::<K3, SimpleGraph>::try_from(FixedKColoringCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+    })
+    .unwrap();
+    assert_eq!(fixed.num_colors(), 3);
+}
+
+#[test]
+fn fixed_and_runtime_variants_report_num_colors_parameter() {
+    let fixed = KColoring::<K3, _>::new(SimpleGraph::new(2, vec![(0, 1)]));
+    let runtime = KColoring::<KN, _>::with_k(SimpleGraph::new(2, vec![(0, 1)]), 5);
+
+    assert_eq!(Problem::parameters(&fixed).get("num_colors"), Some(3));
+    assert_eq!(Problem::parameters(&runtime).get("num_colors"), Some(5));
+    assert_eq!(
+        <KColoring<K3, SimpleGraph> as Problem>::parameter_names(),
+        <KColoring<KN, SimpleGraph> as Problem>::parameter_names()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::variant::{K1, K2, K3, K4};
@@ -6,13 +39,11 @@ include!("../../jl_helpers.rs");
 
 #[test]
 fn test_kcoloring_creation() {
-    use crate::traits::Problem;
-
     let problem = KColoring::<K3, _>::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 3);
     assert_eq!(problem.num_colors(), 3);
-    assert_eq!(problem.dims(), vec![3, 3, 3, 3]);
+    assert_eq!(problem.dimensions(), vec![3, 3, 3, 3]);
 }
 
 #[test]
@@ -22,8 +53,8 @@ fn test_evaluate_valid() {
     let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
 
     // Valid: different colors on adjacent vertices
-    assert!(problem.evaluate(&[0, 1, 0]));
-    assert!(problem.evaluate(&[0, 1, 2]));
+    assert!(problem.evaluate(&vec![0, 1, 0]).unwrap());
+    assert!(problem.evaluate(&vec![0, 1, 2]).unwrap());
 }
 
 #[test]
@@ -33,8 +64,8 @@ fn test_evaluate_invalid() {
     let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
 
     // Invalid: adjacent vertices have same color
-    assert!(!problem.evaluate(&[0, 0, 1]));
-    assert!(!problem.evaluate(&[0, 0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 1]).unwrap());
+    assert!(!problem.evaluate(&vec![0, 0, 0]).unwrap());
 }
 
 #[test]
@@ -45,10 +76,10 @@ fn test_brute_force_path() {
     let problem = KColoring::<K2, _>::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // All solutions should be valid
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -60,9 +91,9 @@ fn test_brute_force_triangle() {
     let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
         // All three vertices have different colors
         assert_ne!(sol[0], sol[1]);
         assert_ne!(sol[1], sol[2]);
@@ -76,7 +107,7 @@ fn test_triangle_2_colors() {
     let problem = KColoring::<K2, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // No valid solutions
     assert!(solutions.is_empty());
 }
@@ -106,11 +137,11 @@ fn test_empty_graph() {
     let problem = KColoring::<K1, _>::new(SimpleGraph::new(3, vec![]));
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // Any coloring is valid when there are no edges
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -125,9 +156,9 @@ fn test_complete_graph_k4() {
     ));
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -145,11 +176,11 @@ fn test_kcoloring_problem() {
 
     // Triangle graph with 3 colors
     let p = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    assert_eq!(p.dims(), vec![3, 3, 3]);
+    assert_eq!(p.dimensions(), vec![3, 3, 3]);
     // Valid: each vertex different color
-    assert!(p.evaluate(&[0, 1, 2]));
+    assert!(p.evaluate(&vec![0, 1, 2]).unwrap());
     // Invalid: vertices 0 and 1 same color
-    assert!(!p.evaluate(&[0, 0, 1]));
+    assert!(!p.evaluate(&vec![0, 0, 1]).unwrap());
 }
 
 #[test]
@@ -163,7 +194,7 @@ fn test_jl_parity_evaluation() {
         let problem = KColoring::<K3, _>::new(SimpleGraph::new(nv, edges));
         for eval in instance["evaluations"].as_array().unwrap() {
             let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config).0;
+            let result = problem.evaluate(&config).unwrap().0;
             let jl_size = eval["size"].as_i64().unwrap() as usize;
             assert_eq!(
                 result,
@@ -172,7 +203,7 @@ fn test_jl_parity_evaluation() {
                 config
             );
         }
-        let all_sat = BruteForce::new().find_all_witnesses(&problem);
+        let all_sat = BruteForce::new().find_all_witnesses(&problem).unwrap();
         let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
         let rust_sat: HashSet<Vec<usize>> = all_sat.into_iter().collect();
         assert_eq!(rust_sat, jl_best, "KColoring satisfying solutions mismatch");
@@ -190,7 +221,7 @@ fn test_is_valid_solution() {
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
     assert_eq!(problem.num_vertices(), 3);
     assert_eq!(problem.num_edges(), 2);
@@ -203,11 +234,57 @@ fn test_kcoloring_paper_example() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]);
     let problem = KColoring::<K3, _>::new(graph);
     let config = vec![0, 1, 1, 0, 2];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
     // Verify not 2-colorable (triangle v_2,v_3,v_4)
     let graph2 = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]);
     let problem2 = KColoring::<K2, _>::new(graph2);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem2).is_none());
+    assert!(solver.solve(&problem2).unwrap().is_none());
+}
+
+#[test]
+fn fixed_color_counts_survive_all_serialization_paths() {
+    fn check<K: crate::variant::KValue>() {
+        let expected = K::K.unwrap();
+        let source = KColoring::<K, _>::new(SimpleGraph::new(2, vec![(0, 1)]));
+        let mut data = serde_json::to_value(&source).unwrap();
+        let restored: KColoring<K, SimpleGraph> = serde_json::from_value(data.clone()).unwrap();
+        assert_eq!(restored.num_colors(), expected);
+        assert_eq!(restored.graph().edges(), source.graph().edges());
+        for supplied in (0..=6).chain(std::iter::once(usize::MAX)) {
+            data["num_colors"] = serde_json::json!(supplied);
+            let restored = serde_json::from_value::<KColoring<K, SimpleGraph>>(data.clone());
+            assert_eq!(restored.is_ok(), supplied == expected);
+        }
+        data.as_object_mut().unwrap().remove("num_colors");
+        let restored: KColoring<K, SimpleGraph> = serde_json::from_value(data.clone()).unwrap();
+        assert_eq!(restored.num_colors(), expected);
+        for invalid in [
+            serde_json::Value::Null,
+            serde_json::json!(-1),
+            serde_json::json!("3"),
+        ] {
+            data["num_colors"] = invalid;
+            assert!(serde_json::from_value::<KColoring<K, SimpleGraph>>(data.clone()).is_err());
+        }
+    }
+    check::<crate::variant::K1>();
+    check::<crate::variant::K2>();
+    check::<crate::variant::K3>();
+    check::<crate::variant::K4>();
+    check::<crate::variant::K5>();
+}
+
+#[test]
+fn runtime_color_counts_keep_their_native_domain_on_deserialization() {
+    for count in [0, 1, 3, 4, usize::MAX] {
+        let source = KColoring::<KN, _>::with_k(SimpleGraph::new(2, vec![(0, 1)]), count);
+        let data = serde_json::to_value(&source).unwrap();
+        let restored: KColoring<KN, SimpleGraph> = serde_json::from_value(data).unwrap();
+        assert_eq!(restored.num_colors(), count);
+    }
+    let data = serde_json::json!({"graph": {"num_vertices": 0, "edges": []}});
+    let restored: KColoring<KN, SimpleGraph> = serde_json::from_value(data).unwrap();
+    assert_eq!(restored.num_colors(), 0);
 }
diff --git a/src/unit_tests/models/graph/kernel.rs b/src/unit_tests/models/graph/kernel.rs
index 270b0fbfb..3e4ed36f7 100644
--- a/src/unit_tests/models/graph/kernel.rs
+++ b/src/unit_tests/models/graph/kernel.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 
@@ -12,7 +13,7 @@ fn test_kernel_creation() {
     let problem = Kernel::new(graph);
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_arcs(), 7);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2, 2]);
 }
 
 #[test]
@@ -26,7 +27,12 @@ fn test_kernel_evaluate_valid() {
         vec![(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (4, 0), (4, 1)],
     );
     let problem = Kernel::new(graph);
-    assert_eq!(problem.evaluate(&[1, 0, 0, 1, 0]), crate::types::Or(true));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, true, false])
+            .unwrap(),
+        crate::types::Or(true)
+    );
 }
 
 #[test]
@@ -37,7 +43,12 @@ fn test_kernel_evaluate_not_independent() {
         vec![(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (4, 0), (4, 1)],
     );
     let problem = Kernel::new(graph);
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0, 0]), crate::types::Or(false));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, false, false, false])
+            .unwrap(),
+        crate::types::Or(false)
+    );
 }
 
 #[test]
@@ -53,7 +64,12 @@ fn test_kernel_evaluate_not_absorbing() {
         vec![(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (4, 0), (4, 1)],
     );
     let problem = Kernel::new(graph);
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0, 0]), crate::types::Or(false));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, false, false])
+            .unwrap(),
+        crate::types::Or(false)
+    );
 }
 
 #[test]
@@ -64,8 +80,11 @@ fn test_kernel_brute_force() {
     );
     let problem = Kernel::new(graph);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).expect("should have a kernel");
-    assert_eq!(problem.evaluate(&solution), crate::types::Or(true));
+    let solution = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should have a kernel");
+    assert_eq!(problem.evaluate(&solution).unwrap(), crate::types::Or(true));
 }
 
 #[test]
@@ -79,7 +98,7 @@ fn test_kernel_no_solution() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
     let problem = Kernel::new(graph);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -100,7 +119,13 @@ fn test_kernel_empty_graph() {
     let graph = DirectedGraph::new(3, vec![]);
     let problem = Kernel::new(graph);
     // All selected: independent (no arcs), absorbing (no unselected vertices)
-    assert_eq!(problem.evaluate(&[1, 1, 1]), crate::types::Or(true));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true]).unwrap(),
+        crate::types::Or(true)
+    );
     // Not all selected: e.g., {0} → vertex 1 has no arc to 0, not absorbing
-    assert_eq!(problem.evaluate(&[1, 0, 0]), crate::types::Or(false));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false]).unwrap(),
+        crate::types::Or(false)
+    );
 }
diff --git a/src/unit_tests/models/graph/kth_best_spanning_tree.rs b/src/unit_tests/models/graph/kth_best_spanning_tree.rs
index 1c3464260..bb266893d 100644
--- a/src/unit_tests/models/graph/kth_best_spanning_tree.rs
+++ b/src/unit_tests/models/graph/kth_best_spanning_tree.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -7,28 +8,28 @@ use crate::traits::Problem;
 /// 16 spanning trees; exactly 2 have weight ≤ 4:
 ///   {01,02,03} (star at 0, w=4) and {01,02,13} (w=4).
 /// Satisfying configs = 2 (the two orderings).
-fn yes_instance() -> KthBestSpanningTree<i32> {
+fn yes_instance() -> KthBestSpanningTree<i64> {
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
-    KthBestSpanningTree::new(graph, vec![1, 1, 2, 2, 2, 3], 2, 4)
+    KthBestSpanningTree::<i64>::new(graph, vec![1, 1, 2, 2, 2, 3], 2, 4)
 }
 
-fn no_instance() -> KthBestSpanningTree<i32> {
+fn no_instance() -> KthBestSpanningTree<i64> {
     let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
     let weights = vec![1, 1, 1];
-    KthBestSpanningTree::new(graph, weights, 2, 3)
+    KthBestSpanningTree::<i64>::new(graph, weights, 2, 3)
 }
 
-fn small_yes_instance() -> KthBestSpanningTree<i32> {
+fn small_yes_instance() -> KthBestSpanningTree<i64> {
     let graph = SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]);
     let weights = vec![1, 1, 1];
-    KthBestSpanningTree::new(graph, weights, 2, 2)
+    KthBestSpanningTree::<i64>::new(graph, weights, 2, 2)
 }
 
 /// Star at 0: edges {01,02,03}, then {01,02,13}.
-fn yes_witness_config() -> Vec<usize> {
+fn yes_witness_config() -> Vec<Vec<bool>> {
     vec![
-        1, 1, 1, 0, 0, 0, // block 1: edges 0,1,2 = {01,02,03}
-        1, 1, 0, 0, 1, 0, // block 2: edges 0,1,4 = {01,02,13}
+        vec![true, true, true, false, false, false], // edges 0,1,2 = {01,02,03}
+        vec![true, true, false, false, true, false], // edges 0,1,4 = {01,02,13}
     ]
 }
 
@@ -36,7 +37,7 @@ fn yes_witness_config() -> Vec<usize> {
 fn test_kthbestspanningtree_creation() {
     let problem = yes_instance();
 
-    assert_eq!(problem.dims(), vec![2; 12]);
+    assert_eq!(problem.dimensions(), vec![2; 12]);
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 6);
     assert_eq!(problem.num_vertices(), 4);
@@ -45,44 +46,56 @@ fn test_kthbestspanningtree_creation() {
     assert_eq!(problem.weights(), &[1, 1, 2, 2, 2, 3]);
     assert_eq!(*problem.bound(), 4);
     assert!(problem.is_weighted());
-    assert_eq!(KthBestSpanningTree::<i32>::NAME, "KthBestSpanningTree");
+    assert_eq!(KthBestSpanningTree::<i64>::NAME, "KthBestSpanningTree");
 }
 
 #[test]
 fn test_kthbestspanningtree_evaluation_yes_instance() {
     let problem = yes_instance();
-    assert!(problem.evaluate(&yes_witness_config()));
-    assert!(problem.is_valid_solution(&yes_witness_config()));
+    assert!(problem.evaluate(&yes_witness_config()).unwrap());
+    assert!(problem.is_valid_solution(&yes_witness_config()).unwrap());
 }
 
 #[test]
 fn test_kthbestspanningtree_evaluation_rejects_duplicate_trees() {
     let problem = yes_instance();
     // Same tree in both blocks: {01,02,03} twice
-    let dup = vec![1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0];
-    assert!(!problem.evaluate(&dup));
+    let dup = vec![
+        vec![true, true, true, false, false, false],
+        vec![true, true, true, false, false, false],
+    ];
+    assert!(!problem.evaluate(&dup).unwrap());
 }
 
 #[test]
 fn test_kthbestspanningtree_evaluation_rejects_overweight_tree() {
     let problem = yes_instance();
     // {01,03,12} w=5 and {01,02,03} w=4: first tree exceeds B=4
-    let config = vec![1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0];
-    assert!(!problem.evaluate(&config));
+    let config = vec![
+        vec![true, false, true, true, false, false],
+        vec![true, true, true, false, false, false],
+    ];
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_kthbestspanningtree_evaluation_rejects_wrong_length_config() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&yes_witness_config()[..11]));
+    let config = vec![vec![true; 5], vec![true; 6]];
+    assert!(matches!(
+        problem.evaluate(&config),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_kthbestspanningtree_evaluation_rejects_nonbinary_value() {
     let problem = yes_instance();
-    let mut config = yes_witness_config();
-    config[0] = 2;
-    assert!(!problem.evaluate(&config));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([[2, 1, 1, 0, 0, 0], [1, 1, 0, 0, 1, 0]]),
+    )
+    .is_err());
 }
 
 #[test]
@@ -91,9 +104,9 @@ fn test_kthbestspanningtree_solver_exhaustive() {
     let solver = BruteForce::new();
 
     // Exactly 2 spanning trees have weight ≤ 4, so exactly 2! = 2 satisfying configs.
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all.len(), 2);
-    assert!(all.iter().all(|config| problem.evaluate(config).0));
+    assert!(all.iter().all(|config| problem.evaluate(config).unwrap().0));
 }
 
 #[test]
@@ -101,8 +114,8 @@ fn test_kthbestspanningtree_solver_no_instance() {
     let problem = no_instance();
     let solver = BruteForce::new();
 
-    assert!(solver.find_witness(&problem).is_none());
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+    assert!(solver.solve(&problem).unwrap().is_none());
+    assert!(solver.find_all_witnesses(&problem).unwrap().is_empty());
 }
 
 #[test]
@@ -110,47 +123,65 @@ fn test_kthbestspanningtree_small_exhaustive_search() {
     let problem = small_yes_instance();
     let solver = BruteForce::new();
 
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all.len(), 6);
-    assert!(all.iter().all(|config| problem.evaluate(config).0));
+    assert!(all.iter().all(|config| problem.evaluate(config).unwrap().0));
 }
 
 #[test]
 fn test_kthbestspanningtree_serialization() {
     let problem = yes_instance();
     let json = serde_json::to_string(&problem).unwrap();
-    let restored: KthBestSpanningTree<i32> = serde_json::from_str(&json).unwrap();
+    let restored: KthBestSpanningTree<i64> = serde_json::from_str(&json).unwrap();
 
     assert_eq!(restored.num_vertices(), problem.num_vertices());
     assert_eq!(restored.num_edges(), problem.num_edges());
     assert_eq!(restored.k(), problem.k());
     assert_eq!(restored.weights(), problem.weights());
     assert_eq!(restored.bound(), problem.bound());
-    assert!(restored.evaluate(&yes_witness_config()));
+    assert!(restored.evaluate(&yes_witness_config()).unwrap());
 }
 
 #[test]
 fn test_kthbestspanningtree_single_vertex_accepts_single_empty_tree() {
-    let problem = KthBestSpanningTree::<i32>::new(SimpleGraph::new(1, vec![]), vec![], 1, 0);
-    assert!(problem.evaluate(&[]));
-    assert!(problem.is_valid_solution(&[]));
+    let problem = KthBestSpanningTree::<i64>::new(SimpleGraph::new(1, vec![]), vec![], 1, 0);
+    let config = vec![Vec::<bool>::new()];
+    assert!(problem.evaluate(&config).unwrap());
+    assert!(problem.is_valid_solution(&config).unwrap());
 }
 
 #[test]
 fn test_kthbestspanningtree_single_vertex_rejects_multiple_empty_trees() {
-    let problem = KthBestSpanningTree::<i32>::new(SimpleGraph::new(1, vec![]), vec![], 2, 0);
-    assert!(!problem.evaluate(&[]));
+    let problem = KthBestSpanningTree::<i64>::new(SimpleGraph::new(1, vec![]), vec![], 2, 0);
+    let config = vec![Vec::<bool>::new(), Vec::<bool>::new()];
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 #[should_panic(expected = "weights length must match graph num_edges")]
 fn test_kthbestspanningtree_creation_rejects_weight_length_mismatch() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let _ = KthBestSpanningTree::new(graph, vec![1], 1, 2);
+    let _ = KthBestSpanningTree::<i64>::new(graph, vec![1], 1, 2);
 }
 
 #[test]
 #[should_panic(expected = "k must be positive")]
 fn test_kthbestspanningtree_creation_rejects_zero_k() {
-    let _ = KthBestSpanningTree::<i32>::new(SimpleGraph::new(1, vec![]), vec![], 0, 0);
+    let _ = KthBestSpanningTree::<i64>::new(SimpleGraph::new(1, vec![]), vec![], 0, 0);
+}
+#[test]
+fn create_spec_maps_edge_weights_to_weights() {
+    let problem = KthBestSpanningTree::try_from(KthBestSpanningTreeCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+        edge_weights: None,
+        k: 1,
+        bound: 2,
+    })
+    .unwrap();
+    assert_eq!(problem.weights(), &[1]);
+    assert_eq!(
+        KthBestSpanningTreeCreateSpec::FIELDS[2].name,
+        "edge_weights"
+    );
 }
diff --git a/src/unit_tests/models/graph/length_bounded_disjoint_paths.rs b/src/unit_tests/models/graph/length_bounded_disjoint_paths.rs
index 53a19ed4f..619d0d892 100644
--- a/src/unit_tests/models/graph/length_bounded_disjoint_paths.rs
+++ b/src/unit_tests/models/graph/length_bounded_disjoint_paths.rs
@@ -1,4 +1,18 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_derives_path_slot_bound() {
+    let problem = LengthBoundedDisjointPaths::try_from(LengthBoundedDisjointPathsCreateSpec {
+        graph: vec![(0, 1), (1, 3), (0, 2), (2, 3)],
+        num_vertices: None,
+        source: 0,
+        sink: 3,
+        max_length: 2,
+    })
+    .unwrap();
+    assert_eq!(problem.max_paths(), 2);
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -13,17 +27,6 @@ fn sample_problem() -> LengthBoundedDisjointPaths<SimpleGraph> {
     LengthBoundedDisjointPaths::new(sample_graph(), 0, 4, 3)
 }
 
-fn encode_paths(num_vertices: usize, max_paths: usize, slots: &[&[usize]]) -> Vec<usize> {
-    let mut config = vec![0; num_vertices * max_paths];
-    for (slot_index, slot_vertices) in slots.iter().enumerate() {
-        let offset = slot_index * num_vertices;
-        for &vertex in *slot_vertices {
-            config[offset + vertex] = 1;
-        }
-    }
-    config
-}
-
 #[test]
 fn test_length_bounded_disjoint_paths_creation() {
     let problem = sample_problem();
@@ -31,15 +34,15 @@ fn test_length_bounded_disjoint_paths_creation() {
     assert_eq!(problem.num_edges(), 6);
     assert_eq!(problem.max_paths(), 3);
     assert_eq!(problem.max_length(), 3);
-    // 3 slots * 5 vertices = 15 binary variables
-    assert_eq!(problem.dims(), vec![2; 15]);
+    // 3 slots * 6 edges = 18 binary variables
+    assert_eq!(problem.dimensions(), vec![2; 18]);
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_allows_large_bounds() {
     let problem = LengthBoundedDisjointPaths::new(sample_graph(), 0, 4, 10);
-    let config = encode_paths(5, 3, &[&[0, 1, 4], &[0, 2, 4]]);
-    assert_eq!(problem.evaluate(&config), Max(Some(2)));
+    let config = encode_paths(6, 3, &[&[0, 1], &[2, 3]]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(2)));
 }
 
 #[test]
@@ -70,48 +73,48 @@ fn test_length_bounded_disjoint_paths_creation_rejects_zero_bound() {
 fn test_length_bounded_disjoint_paths_evaluate_optimal() {
     let problem = sample_problem();
     // All 3 paths used
-    let config = encode_paths(5, 3, &[&[0, 1, 4], &[0, 2, 4], &[0, 3, 4]]);
-    assert_eq!(problem.evaluate(&config), Max(Some(3)));
+    let config = encode_paths(6, 3, &[&[0, 1], &[2, 3], &[4, 5]]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(3)));
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_evaluate_partial() {
     let problem = sample_problem();
     // Only 2 of 3 slots used, third slot empty
-    let config = encode_paths(5, 3, &[&[0, 1, 4], &[0, 2, 4]]);
-    assert_eq!(problem.evaluate(&config), Max(Some(2)));
+    let config = encode_paths(6, 3, &[&[0, 1], &[2, 3]]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(2)));
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_evaluate_single_path() {
     let problem = sample_problem();
     // Only 1 slot used
-    let config = encode_paths(5, 3, &[&[0, 1, 4]]);
-    assert_eq!(problem.evaluate(&config), Max(Some(1)));
+    let config = encode_paths(6, 3, &[&[0, 1]]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(1)));
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_evaluate_empty_config() {
     let problem = sample_problem();
     // All slots empty → 0 paths
-    let config = vec![0; 15];
-    assert_eq!(problem.evaluate(&config), Max(Some(0)));
+    let config = vec![vec![false; 6]; 3];
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(0)));
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_rejects_missing_terminal() {
     let problem = sample_problem();
     // Slot 1 is non-empty but missing sink
-    let config = encode_paths(5, 3, &[&[0, 1], &[0, 2, 4]]);
-    assert_eq!(problem.evaluate(&config), Max(None));
+    let config = encode_paths(6, 3, &[&[0], &[2, 3]]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(None));
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_rejects_disconnected_slot() {
     let problem = sample_problem();
-    // Slot has non-adjacent vertices (0 and 3 are adjacent, but 3 and 1 are not)
-    let config = encode_paths(5, 3, &[&[0, 1, 3, 4]]);
-    assert_eq!(problem.evaluate(&config), Max(None));
+    // The selected edges 0-1 and 3-4 do not connect the terminals.
+    let config = encode_paths(6, 3, &[&[0, 5]]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(None));
 }
 
 #[test]
@@ -121,40 +124,54 @@ fn test_length_bounded_disjoint_paths_rejects_overlong_slot() {
     // max_paths = min(deg(0), deg(3)) = min(2, 2) = 2
     let problem = LengthBoundedDisjointPaths::new(graph, 0, 3, 1);
     // Path [0,1,2,3] has 3 edges but max_length=1
-    let config = encode_paths(4, 2, &[&[0, 1, 2, 3]]);
-    assert_eq!(problem.evaluate(&config), Max(None));
+    let config = encode_paths(4, 2, &[&[0, 1, 2]]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(None));
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_rejects_shared_internal_vertices() {
     let problem = sample_problem();
     // Two slots share internal vertex 1
-    let config = encode_paths(5, 3, &[&[0, 1, 4], &[0, 1, 4]]);
-    assert_eq!(problem.evaluate(&config), Max(None));
+    let config = encode_paths(6, 3, &[&[0, 1], &[0, 1]]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(None));
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_rejects_reused_direct_edge() {
     let problem = LengthBoundedDisjointPaths::new(SimpleGraph::new(2, vec![(0, 1)]), 0, 1, 1);
     // max_paths = min(deg(0), deg(1)) = 1, so only 1 slot
-    let config = encode_paths(2, 1, &[&[0, 1]]);
-    assert_eq!(problem.evaluate(&config), Max(Some(1)));
+    let config = encode_paths(1, 1, &[&[0]]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(1)));
+    let triangle =
+        LengthBoundedDisjointPaths::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]), 0, 2, 2);
+    assert_eq!(
+        triangle
+            .evaluate(&encode_paths(3, 2, &[&[2], &[2]]))
+            .unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_rejects_non_binary_entries() {
     let problem = sample_problem();
-    let mut config = encode_paths(5, 3, &[&[0, 1, 4], &[0, 2, 4]]);
-    config[3] = 2;
-    assert_eq!(problem.evaluate(&config), Max(None));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([
+            [true, true, false, 2, false, false],
+            vec![false; 6],
+            vec![false; 6]
+        ])
+    )
+    .is_err());
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_solver() {
     let problem = sample_problem();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&witness), Max(Some(3)));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&witness).unwrap(), Max(Some(3)));
 }
 
 #[test]
@@ -179,11 +196,47 @@ fn test_length_bounded_disjoint_paths_graph_getter() {
 #[test]
 fn test_length_bounded_disjoint_paths_num_variables() {
     let problem = sample_problem();
-    assert_eq!(problem.num_variables(), 15);
+    assert_eq!(problem.num_variables(), 18);
 }
 
 #[test]
 fn test_length_bounded_disjoint_paths_rejects_wrong_length_config() {
     let problem = sample_problem();
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Max(None));
+    assert!(problem.evaluate(&vec![vec![false, true, false]]).is_err());
+    assert!(problem.evaluate(&vec![vec![false; 5]; 3]).is_err());
+}
+
+#[test]
+fn test_length_bounded_disjoint_paths_chorded_path() {
+    let problem =
+        LengthBoundedDisjointPaths::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]), 0, 2, 2);
+    let solution = encode_paths(3, 2, &[&[0, 1], &[2]]);
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(2)));
+    let best = BruteForce::new().solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap(), Max(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&encode_paths(3, 2, &[&[0, 1, 2]]))
+            .unwrap(),
+        Max(None)
+    );
+}
+
+#[test]
+fn test_length_bounded_disjoint_paths_rejects_disconnected_cycle() {
+    let problem = LengthBoundedDisjointPaths::new(
+        SimpleGraph::new(5, vec![(0, 1), (2, 3), (3, 4), (4, 2)]),
+        0,
+        1,
+        4,
+    );
+    assert_eq!(problem.evaluate(&vec![vec![true; 4]]).unwrap(), Max(None));
+}
+
+#[test]
+fn test_length_bounded_disjoint_paths_edgeless_graph() {
+    let problem = LengthBoundedDisjointPaths::new(SimpleGraph::new(2, vec![]), 0, 1, 1);
+    let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+    assert!(solution.is_empty());
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(0)));
 }
diff --git a/src/unit_tests/models/graph/longest_circuit.rs b/src/unit_tests/models/graph/longest_circuit.rs
index e11c1258e..1789804b2 100644
--- a/src/unit_tests/models/graph/longest_circuit.rs
+++ b/src/unit_tests/models/graph/longest_circuit.rs
@@ -1,10 +1,11 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Max;
 
-fn issue_problem() -> LongestCircuit<SimpleGraph, i32> {
+fn issue_problem() -> LongestCircuit<SimpleGraph, i64> {
     LongestCircuit::new(
         SimpleGraph::new(
             6,
@@ -31,7 +32,7 @@ fn test_longest_circuit_creation() {
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 10);
     assert_eq!(problem.edge_lengths(), &[3, 2, 4, 1, 5, 2, 3, 2, 1, 2]);
-    assert_eq!(problem.dims(), vec![2; 10]);
+    assert_eq!(problem.dimensions(), vec![2; 10]);
     assert!(problem.is_weighted());
 }
 
@@ -41,13 +42,31 @@ fn test_longest_circuit_evaluate_valid_and_invalid() {
 
     // Outer hexagon: 3+2+4+1+5+2 = 17
     assert_eq!(
-        problem.evaluate(&[1, 1, 1, 1, 1, 1, 0, 0, 0, 0]),
+        problem
+            .evaluate(&vec![
+                true, true, true, true, true, true, false, false, false, false
+            ])
+            .unwrap(),
         Max(Some(17))
     );
     // Not a valid circuit (only 3 edges, not forming a cycle)
-    assert_eq!(problem.evaluate(&[1, 1, 1, 0, 0, 0, 0, 0, 0, 0]), Max(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![
+                true, true, true, false, false, false, false, false, false, false
+            ])
+            .unwrap(),
+        Max(None)
+    );
     // Chord edges only — not a valid circuit
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0, 0, 1, 1, 1, 0]), Max(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![
+                false, false, false, false, false, false, true, true, true, false
+            ])
+            .unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
@@ -56,24 +75,30 @@ fn test_longest_circuit_rejects_disconnected_cycles() {
         SimpleGraph::new(6, vec![(0, 1), (1, 2), (2, 0), (3, 4), (4, 5), (5, 3)]),
         vec![1, 1, 1, 1, 1, 1],
     );
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1, 1, 1]), Max(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, true, true, true])
+            .unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
-fn test_longest_circuit_rejects_non_binary() {
+fn test_longest_circuit_rejects_wrong_length() {
     let problem = issue_problem();
-    assert!(!problem.is_valid_solution(&[1, 1, 1, 1, 1, 1, 0, 0, 0, 2]));
+    assert!(!problem.is_valid_solution(&[true, true]));
 }
 
 #[test]
 fn test_longest_circuit_bruteforce() {
     let problem = issue_problem();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
 
     // The optimal circuit has value 18 (circuit 0-1-4-5-2-3-0)
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Max(Some(18)));
 }
 
@@ -81,7 +106,7 @@ fn test_longest_circuit_bruteforce() {
 fn test_longest_circuit_serialization() {
     let problem = issue_problem();
     let json = serde_json::to_value(&problem).unwrap();
-    let restored: LongestCircuit<SimpleGraph, i32> = serde_json::from_value(json).unwrap();
+    let restored: LongestCircuit<SimpleGraph, i64> = serde_json::from_value(json).unwrap();
     assert_eq!(restored.num_vertices(), problem.num_vertices());
     assert_eq!(restored.num_edges(), problem.num_edges());
     assert_eq!(restored.edge_lengths(), problem.edge_lengths());
@@ -91,10 +116,12 @@ fn test_longest_circuit_serialization() {
 fn test_longest_circuit_paper_example() {
     let problem = issue_problem();
     // Optimal circuit: 0-1-4-5-2-3-0 with total length 18
-    let config = vec![1, 0, 1, 0, 1, 0, 1, 1, 1, 0];
-    assert_eq!(problem.evaluate(&config), Max(Some(18)));
+    let config = vec![
+        true, false, true, false, true, false, true, true, true, false,
+    ];
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(18)));
 
-    let all = BruteForce::new().find_all_witnesses(&problem);
+    let all = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert!(all.contains(&config));
 }
 
@@ -116,3 +143,14 @@ fn test_longest_circuit_set_lengths_rejects_non_positive_values() {
     );
     problem.set_lengths(vec![1, -2, 1]);
 }
+#[test]
+fn create_spec_maps_edge_weights_to_edge_lengths() {
+    let problem = LongestCircuit::try_from(LongestCircuitCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+        edge_weights: Some(vec![3]),
+    })
+    .unwrap();
+    assert_eq!(problem.edge_lengths(), &[3]);
+    assert_eq!(LongestCircuitCreateSpec::FIELDS[2].name, "edge_weights");
+}
diff --git a/src/unit_tests/models/graph/longest_path.rs b/src/unit_tests/models/graph/longest_path.rs
index 9b61616fe..f3d81c1c8 100644
--- a/src/unit_tests/models/graph/longest_path.rs
+++ b/src/unit_tests/models/graph/longest_path.rs
@@ -1,10 +1,22 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+#[test]
+fn create_spec_rejects_nonpositive_lengths() {
+    assert!(LongestPath::try_from(LongestPathI64CreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+        edge_lengths: vec![0],
+        source_vertex: 0,
+        target_vertex: 1
+    })
+    .is_err());
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::{Max, One};
 
-fn issue_problem() -> LongestPath<SimpleGraph, i32> {
+fn issue_problem() -> LongestPath<SimpleGraph, i64> {
     LongestPath::new(
         SimpleGraph::new(
             7,
@@ -27,12 +39,16 @@ fn issue_problem() -> LongestPath<SimpleGraph, i32> {
     )
 }
 
-fn optimal_config() -> Vec<usize> {
-    vec![1, 0, 1, 1, 1, 0, 1, 0, 1, 0]
+fn optimal_config() -> Vec<bool> {
+    vec![
+        true, false, true, true, true, false, true, false, true, false,
+    ]
 }
 
-fn suboptimal_config() -> Vec<usize> {
-    vec![0, 1, 1, 0, 1, 1, 1, 0, 0, 1]
+fn suboptimal_config() -> Vec<bool> {
+    vec![
+        false, true, true, false, true, true, true, false, false, true,
+    ]
 }
 
 #[test]
@@ -45,7 +61,7 @@ fn test_longest_path_creation() {
     assert_eq!(problem.num_edges(), 10);
     assert_eq!(problem.source_vertex(), 0);
     assert_eq!(problem.target_vertex(), 6);
-    assert_eq!(problem.dims(), vec![2; 10]);
+    assert_eq!(problem.dimensions(), vec![2; 10]);
     assert_eq!(problem.edge_lengths(), &[3, 2, 4, 1, 5, 2, 3, 2, 4, 1]);
     assert!(problem.is_weighted());
 
@@ -60,17 +76,45 @@ fn test_longest_path_creation() {
 fn test_longest_path_evaluate_valid_and_invalid_configs() {
     let problem = issue_problem();
 
-    assert_eq!(problem.evaluate(&optimal_config()), Max(Some(20)));
-    assert_eq!(problem.evaluate(&suboptimal_config()), Max(Some(17)));
+    assert_eq!(problem.evaluate(&optimal_config()).unwrap(), Max(Some(20)));
+    assert_eq!(
+        problem.evaluate(&suboptimal_config()).unwrap(),
+        Max(Some(17))
+    );
     assert!(problem.is_valid_solution(&optimal_config()));
     assert!(problem.is_valid_solution(&suboptimal_config()));
 
-    assert_eq!(problem.evaluate(&[1, 1, 1, 0, 0, 0, 0, 0, 0, 0]), Max(None));
-    assert_eq!(problem.evaluate(&[1, 0, 1, 0, 1, 0, 0, 0, 0, 1]), Max(None));
-    assert_eq!(problem.evaluate(&[1, 0, 1, 1, 1, 1, 1, 1, 1, 1]), Max(None));
-    assert_eq!(problem.evaluate(&[0; 10]), Max(None));
-    assert!(!problem.is_valid_solution(&[1, 0, 1]));
-    assert!(!problem.is_valid_solution(&[1, 0, 1, 0, 1, 0, 1, 0, 1, 2]));
+    assert_eq!(
+        problem
+            .evaluate(&vec![
+                true, true, true, false, false, false, false, false, false, false
+            ])
+            .unwrap(),
+        Max(None)
+    );
+    assert_eq!(
+        problem
+            .evaluate(&vec![
+                true, false, true, false, true, false, false, false, false, true
+            ])
+            .unwrap(),
+        Max(None)
+    );
+    assert_eq!(
+        problem
+            .evaluate(&vec![
+                true, false, true, true, true, true, true, true, true, true
+            ])
+            .unwrap(),
+        Max(None)
+    );
+    assert_eq!(problem.evaluate(&vec![false; 10]).unwrap(), Max(None));
+    assert!(!problem.is_valid_solution(&[true, false, true]));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([1, 0, 1, 0, 1, 0, 1, 0, 1, 2]),
+    )
+    .is_err());
 }
 
 #[test]
@@ -78,11 +122,11 @@ fn test_longest_path_bruteforce_finds_issue_optimum() {
     let problem = issue_problem();
     let solver = BruteForce::new();
 
-    let best = solver.find_witness(&problem).unwrap();
+    let best = solver.solve(&problem).unwrap().unwrap();
     assert_eq!(best, optimal_config());
-    assert_eq!(problem.evaluate(&best), Max(Some(20)));
+    assert_eq!(problem.evaluate(&best).unwrap(), Max(Some(20)));
 
-    let all_best = solver.find_all_witnesses(&problem);
+    let all_best = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all_best, vec![optimal_config()]);
 }
 
@@ -90,42 +134,52 @@ fn test_longest_path_bruteforce_finds_issue_optimum() {
 fn test_longest_path_serialization() {
     let problem = issue_problem();
     let json = serde_json::to_value(&problem).unwrap();
-    let restored: LongestPath<SimpleGraph, i32> = serde_json::from_value(json).unwrap();
+    let restored: LongestPath<SimpleGraph, i64> = serde_json::from_value(json).unwrap();
 
     assert_eq!(restored.num_vertices(), 7);
     assert_eq!(restored.num_edges(), 10);
     assert_eq!(restored.source_vertex(), 0);
     assert_eq!(restored.target_vertex(), 6);
     assert_eq!(restored.edge_lengths(), &[3, 2, 4, 1, 5, 2, 3, 2, 4, 1]);
-    assert_eq!(restored.evaluate(&optimal_config()), Max(Some(20)));
+    assert_eq!(restored.evaluate(&optimal_config()).unwrap(), Max(Some(20)));
 }
 
 #[test]
 fn test_longest_path_source_equals_target_only_allows_empty_path() {
     let problem = LongestPath::new(SimpleGraph::path(3), vec![5, 7], 1, 1);
 
-    assert!(problem.is_valid_solution(&[0, 0]));
-    assert_eq!(problem.evaluate(&[0, 0]), Max(Some(0)));
-    assert!(!problem.is_valid_solution(&[1, 0]));
-    assert_eq!(problem.evaluate(&[1, 0]), Max(None));
+    assert!(problem.is_valid_solution(&[false, false]));
+    assert_eq!(problem.evaluate(&vec![false, false]).unwrap(), Max(Some(0)));
+    assert!(!problem.is_valid_solution(&[true, false]));
+    assert_eq!(problem.evaluate(&vec![true, false]).unwrap(), Max(None));
 
-    let best = BruteForce::new().find_witness(&problem).unwrap();
-    assert_eq!(best, vec![0, 0]);
+    let best = BruteForce::new().solve(&problem).unwrap().unwrap();
+    assert_eq!(best, vec![false, false]);
 }
 
 #[test]
 fn test_longestpath_paper_example() {
     let problem = issue_problem();
 
-    assert_eq!(problem.evaluate(&optimal_config()), Max(Some(20)));
-    assert_eq!(problem.evaluate(&suboptimal_config()), Max(Some(17)));
-    assert_eq!(problem.evaluate(&[1, 1, 1, 0, 0, 0, 0, 0, 0, 0]), Max(None));
+    assert_eq!(problem.evaluate(&optimal_config()).unwrap(), Max(Some(20)));
+    assert_eq!(
+        problem.evaluate(&suboptimal_config()).unwrap(),
+        Max(Some(17))
+    );
+    assert_eq!(
+        problem
+            .evaluate(&vec![
+                true, true, true, false, false, false, false, false, false, false
+            ])
+            .unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
 fn test_longest_path_problem_name() {
     assert_eq!(
-        <LongestPath<SimpleGraph, i32> as Problem>::NAME,
+        <LongestPath<SimpleGraph, i64> as Problem>::NAME,
         "LongestPath"
     );
 }
diff --git a/src/unit_tests/models/graph/max_cut.rs b/src/unit_tests/models/graph/max_cut.rs
index dcfadc6e6..cb7497e77 100644
--- a/src/unit_tests/models/graph/max_cut.rs
+++ b/src/unit_tests/models/graph/max_cut.rs
@@ -1,24 +1,23 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 include!("../../jl_helpers.rs");
 
 #[test]
 fn test_maxcut_creation() {
-    use crate::traits::Problem;
-
     let problem = MaxCut::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
         vec![1, 2, 3],
     );
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 3);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2]);
 }
 
 #[test]
 fn test_maxcut_unweighted() {
-    let problem = MaxCut::<_, i32>::unweighted(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
+    let problem = MaxCut::<_, i64>::unweighted(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
     assert_eq!(problem.graph().num_edges(), 2);
 }
 
@@ -29,13 +28,19 @@ fn test_cut_size_function() {
     let weights = vec![1, 2, 3];
 
     // Partition {0} vs {1, 2}
-    assert_eq!(cut_size(&graph, &weights, &[false, true, true]), 4); // 1 + 3
+    assert_eq!(cut_size(&graph, &weights, &[false, true, true]).unwrap(), 4); // 1 + 3
 
     // Partition {0, 1} vs {2}
-    assert_eq!(cut_size(&graph, &weights, &[false, false, true]), 5); // 2 + 3
+    assert_eq!(
+        cut_size(&graph, &weights, &[false, false, true]).unwrap(),
+        5
+    ); // 2 + 3
 
     // All same partition
-    assert_eq!(cut_size(&graph, &weights, &[false, false, false]), 0);
+    assert_eq!(
+        cut_size(&graph, &weights, &[false, false, false]).unwrap(),
+        0
+    );
 }
 
 #[test]
@@ -63,7 +68,7 @@ fn test_new() {
 
 #[test]
 fn test_unweighted() {
-    let problem = MaxCut::<_, i32>::unweighted(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
+    let problem = MaxCut::<_, i64>::unweighted(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
     assert_eq!(problem.graph().num_vertices(), 3);
     assert_eq!(problem.graph().num_edges(), 2);
     assert_eq!(problem.edge_weights(), vec![1, 1]);
@@ -71,7 +76,7 @@ fn test_unweighted() {
 
 #[test]
 fn test_graph_accessor() {
-    let problem = MaxCut::<_, i32>::unweighted(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
+    let problem = MaxCut::<_, i64>::unweighted(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
     let graph = problem.graph();
     assert_eq!(graph.num_vertices(), 3);
     assert_eq!(graph.num_edges(), 2);
@@ -99,12 +104,12 @@ fn test_jl_parity_evaluation() {
         let nv = instance["instance"]["num_vertices"].as_u64().unwrap() as usize;
         let weighted_edges = jl_parse_weighted_edges(&instance["instance"]);
         let edges: Vec<(usize, usize)> = weighted_edges.iter().map(|&(u, v, _)| (u, v)).collect();
-        let weights: Vec<i32> = weighted_edges.into_iter().map(|(_, _, w)| w).collect();
+        let weights: Vec<i64> = weighted_edges.into_iter().map(|(_, _, w)| w).collect();
         let problem = MaxCut::new(SimpleGraph::new(nv, edges), weights);
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config);
-            let jl_size = eval["size"].as_i64().unwrap() as i32;
+            let config = jl_parse_bool_config(&eval["config"]);
+            let result = problem.evaluate(&config).unwrap();
+            let jl_size = eval["size"].as_i64().unwrap();
             assert!(result.is_valid(), "MaxCut should always be valid");
             assert_eq!(
                 result.unwrap(),
@@ -113,9 +118,9 @@ fn test_jl_parity_evaluation() {
                 config
             );
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best: HashSet<Vec<bool>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "MaxCut best solutions mismatch");
     }
 }
@@ -127,14 +132,14 @@ fn test_cut_size_method() {
         vec![1, 2, 3],
     );
     // Partition {0} vs {1, 2}: cuts edges (0,1)=1 and (0,2)=3
-    assert_eq!(problem.cut_size(&[0, 1, 1]), 4);
+    assert_eq!(problem.cut_size(&[false, true, true]).unwrap(), 4);
     // All same partition: no edges cut
-    assert_eq!(problem.cut_size(&[0, 0, 0]), 0);
+    assert_eq!(problem.cut_size(&[false, false, false]).unwrap(), 0);
 }
 
 #[test]
-fn test_size_getters() {
-    let problem = MaxCut::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 2]);
+fn test_parameter_getters() {
+    let problem = MaxCut::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 2]);
     assert_eq!(problem.num_vertices(), 3);
     assert_eq!(problem.num_edges(), 2);
 }
@@ -144,13 +149,30 @@ fn test_maxcut_paper_example() {
     use crate::traits::Problem;
     // Paper: house graph, S = {v_0, v_3}, cut = 5
     let graph = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]);
-    let problem = MaxCut::<_, i32>::unweighted(graph);
-    let config = vec![1, 0, 0, 1, 0]; // S = {v_0, v_3}
-    let result = problem.evaluate(&config);
+    let problem = MaxCut::<_, i64>::unweighted(graph);
+    let config = vec![true, false, false, true, false]; // S = {v_0, v_3}
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 5);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 5);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 5);
+}
+#[test]
+fn create_specs_use_edge_weights_for_both_weight_variants() {
+    let weighted = MaxCut::try_from(MaxCutI64CreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+        edge_weights: None,
+    })
+    .unwrap();
+    let unit = MaxCut::try_from(MaxCutOneCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+    })
+    .unwrap();
+    assert_eq!(weighted.edge_weights(), vec![1]);
+    assert_eq!(unit.edge_weights(), vec![One]);
+    assert_eq!(MaxCutI64CreateSpec::FIELDS[2].name, "edge_weights");
 }
diff --git a/src/unit_tests/models/graph/maximal_is.rs b/src/unit_tests/models/graph/maximal_is.rs
index 06f2b3566..f68ef7c18 100644
--- a/src/unit_tests/models/graph/maximal_is.rs
+++ b/src/unit_tests/models/graph/maximal_is.rs
@@ -1,4 +1,15 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_weight_count_mismatch() {
+    assert_eq!(MaximalISCreateSpec::FIELDS[1].name, "weights");
+    let result = MaximalIS::try_from(MaximalISCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        weights: vec![1],
+    });
+    assert!(result.is_err());
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 include!("../../jl_helpers.rs");
@@ -7,12 +18,12 @@ include!("../../jl_helpers.rs");
 fn test_maximal_is_creation() {
     let problem = MaximalIS::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 3);
     assert_eq!(problem.num_variables(), 4);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
 }
 
 #[test]
@@ -32,28 +43,28 @@ fn test_maximal_is_from_graph() {
 
 #[test]
 fn test_is_independent() {
-    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
 
-    assert!(problem.is_independent(&[1, 0, 1]));
-    assert!(problem.is_independent(&[0, 1, 0]));
-    assert!(!problem.is_independent(&[1, 1, 0]));
+    assert!(problem.is_independent(&[true, false, true]));
+    assert!(problem.is_independent(&[false, true, false]));
+    assert!(!problem.is_independent(&[true, true, false]));
 }
 
 #[test]
 fn test_is_maximal() {
-    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
 
     // {0, 2} is maximal (cannot add 1)
-    assert!(problem.is_maximal(&[1, 0, 1]));
+    assert!(problem.is_maximal(&[true, false, true]));
 
     // {1} is maximal (cannot add 0 or 2)
-    assert!(problem.is_maximal(&[0, 1, 0]));
+    assert!(problem.is_maximal(&[false, true, false]));
 
     // {0} is not maximal (can add 2)
-    assert!(!problem.is_maximal(&[1, 0, 0]));
+    assert!(!problem.is_maximal(&[true, false, false]));
 
     // {} is not maximal (can add any vertex)
-    assert!(!problem.is_maximal(&[0, 0, 0]));
+    assert!(!problem.is_maximal(&[false, false, false]));
 }
 
 #[test]
@@ -68,21 +79,21 @@ fn test_is_maximal_independent_set_function() {
 
 #[test]
 fn test_weights() {
-    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     assert_eq!(problem.weights().to_vec(), vec![1, 1, 1]); // Unit weights
 }
 
 #[test]
 fn test_is_weighted() {
-    // i32 type is always considered weighted
-    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    // i64 type is always considered weighted
+    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     assert!(problem.is_weighted());
 }
 
 #[test]
 fn test_is_weighted_empty() {
-    // i32 type is always considered weighted, even with empty weights
-    let problem = MaximalIS::new(SimpleGraph::new(0, vec![]), vec![0i32; 0]);
+    // i64 type is always considered weighted, even with empty weights
+    let problem = MaximalIS::new(SimpleGraph::new(0, vec![]), vec![0i64; 0]);
     assert!(problem.is_weighted());
 }
 
@@ -94,7 +105,7 @@ fn test_is_maximal_independent_set_wrong_len() {
 
 #[test]
 fn test_graph_ref() {
-    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     let graph = problem.graph();
     assert_eq!(graph.num_vertices(), 3);
     assert_eq!(graph.num_edges(), 2);
@@ -102,14 +113,14 @@ fn test_graph_ref() {
 
 #[test]
 fn test_edges() {
-    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     let edges = problem.graph().edges();
     assert_eq!(edges.len(), 2);
 }
 
 #[test]
 fn test_has_edge() {
-    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     assert!(problem.graph().has_edge(0, 1));
     assert!(problem.graph().has_edge(1, 0)); // Undirected
     assert!(problem.graph().has_edge(1, 2));
@@ -118,7 +129,7 @@ fn test_has_edge() {
 
 #[test]
 fn test_weights_ref() {
-    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     assert_eq!(problem.weights(), &[1, 1, 1]);
 }
 
@@ -129,10 +140,10 @@ fn test_jl_parity_evaluation() {
     for instance in data["instances"].as_array().unwrap() {
         let nv = instance["instance"]["num_vertices"].as_u64().unwrap() as usize;
         let edges = jl_parse_edges(&instance["instance"]);
-        let problem = MaximalIS::new(SimpleGraph::new(nv, edges), vec![1i32; nv]);
+        let problem = MaximalIS::new(SimpleGraph::new(nv, edges), vec![1i64; nv]);
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config);
+            let config = jl_parse_bool_config(&eval["config"]);
+            let result = problem.evaluate(&config).unwrap();
             let jl_valid = eval["is_valid"].as_bool().unwrap();
             assert_eq!(
                 result.is_valid(),
@@ -141,7 +152,7 @@ fn test_jl_parity_evaluation() {
                 config
             );
             if jl_valid {
-                let jl_size = eval["size"].as_i64().unwrap() as i32;
+                let jl_size = eval["size"].as_i64().unwrap();
                 assert_eq!(
                     result.unwrap(),
                     jl_size,
@@ -150,9 +161,9 @@ fn test_jl_parity_evaluation() {
                 );
             }
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best: HashSet<Vec<bool>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "MaximalIS best solutions mismatch");
     }
 }
@@ -160,18 +171,18 @@ fn test_jl_parity_evaluation() {
 #[test]
 fn test_is_valid_solution() {
     // Path graph: 0-1-2
-    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     // Valid: {0, 2} is maximal (independent and no vertex can be added)
-    assert!(problem.is_valid_solution(&[1, 0, 1]));
+    assert!(problem.is_valid_solution(&[true, false, true]));
     // Invalid: {0} is independent but not maximal (vertex 2 can be added)
-    assert!(!problem.is_valid_solution(&[1, 0, 0]));
+    assert!(!problem.is_valid_solution(&[true, false, false]));
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = MaximalIS::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 3);
@@ -182,22 +193,22 @@ fn test_maximal_is_paper_example() {
     use crate::traits::Problem;
     // Paper: path P5, maximal IS {v_1, v_3} (weight 2), {v_0, v_2, v_4} (weight 3)
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]);
-    let problem = MaximalIS::new(graph, vec![1i32; 5]);
+    let problem = MaximalIS::new(graph, vec![1i64; 5]);
 
     // {v_1, v_3} is maximal (can't add v_0: adj to v_1, can't add v_2: adj to both, can't add v_4: adj to v_3)
-    let config1 = vec![0, 1, 0, 1, 0];
-    let result1 = problem.evaluate(&config1);
+    let config1 = vec![false, true, false, true, false];
+    let result1 = problem.evaluate(&config1).unwrap();
     assert!(result1.is_valid());
     assert_eq!(result1.unwrap(), 2);
 
     // {v_0, v_2, v_4} is also maximal, weight 3 (maximum weight maximal IS)
-    let config2 = vec![1, 0, 1, 0, 1];
-    let result2 = problem.evaluate(&config2);
+    let config2 = vec![true, false, true, false, true];
+    let result2 = problem.evaluate(&config2).unwrap();
     assert!(result2.is_valid());
     assert_eq!(result2.unwrap(), 3);
 
     // Verify optimal weight is 3
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 3);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 3);
 }
diff --git a/src/unit_tests/models/graph/maximum_achromatic_number.rs b/src/unit_tests/models/graph/maximum_achromatic_number.rs
index 4b0c2a7c3..9bafd0ea9 100644
--- a/src/unit_tests/models/graph/maximum_achromatic_number.rs
+++ b/src/unit_tests/models/graph/maximum_achromatic_number.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Max;
@@ -11,11 +12,11 @@ fn test_maximum_achromatic_number_c6() {
     let problem = MaximumAchromaticNumber::new(graph);
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 6);
-    assert_eq!(problem.dims(), vec![6; 6]);
+    assert_eq!(problem.dimensions(), vec![6; 6]);
 
     // [0,1,2,0,1,2] is a valid complete proper 3-coloring
     let config = vec![0, 1, 2, 0, 1, 2];
-    assert_eq!(problem.evaluate(&config), Max(Some(3)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(3)));
 }
 
 #[test]
@@ -25,7 +26,7 @@ fn test_maximum_achromatic_number_improper_coloring() {
     let problem = MaximumAchromaticNumber::new(graph);
 
     // Vertices 0 and 1 are adjacent and share color 0
-    assert_eq!(problem.evaluate(&[0, 0, 1, 2]), Max(None));
+    assert_eq!(problem.evaluate(&vec![0, 0, 1, 2]).unwrap(), Max(None));
 }
 
 #[test]
@@ -36,11 +37,11 @@ fn test_maximum_achromatic_number_incomplete_coloring() {
 
     // Colors: 0->0, 1->1, 2->2, 3->3 — proper (no adjacent same color)
     // But colors 0 and 2 have no edge between them, etc. -> incomplete
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3]), Max(None));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap(), Max(None));
 
     // Colors: 0->0, 1->1, 2->0, 3->1 — proper (edges 0-1 and 2-3 have different colors)
     // Colors 0 and 1 have edges (0,1) and (2,3) -> complete
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1]), Max(Some(2)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 0, 1]).unwrap(), Max(Some(2)));
 }
 
 #[test]
@@ -53,8 +54,8 @@ fn test_maximum_achromatic_number_solver() {
     let problem = MaximumAchromaticNumber::new(graph);
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     assert_eq!(value, Max(Some(2)));
 }
 
@@ -62,7 +63,10 @@ fn test_maximum_achromatic_number_solver() {
 fn test_maximum_achromatic_number_wrong_length() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MaximumAchromaticNumber::new(graph);
-    assert_eq!(problem.evaluate(&[0, 1]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -70,7 +74,7 @@ fn test_maximum_achromatic_number_empty_graph() {
     // No vertices, no edges
     let graph = SimpleGraph::new(0, vec![]);
     let problem = MaximumAchromaticNumber::new(graph);
-    assert_eq!(problem.evaluate(&[]), Max(Some(0)));
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -78,7 +82,7 @@ fn test_maximum_achromatic_number_single_vertex() {
     // Single vertex, no edges: 1 color, trivially complete
     let graph = SimpleGraph::new(1, vec![]);
     let problem = MaximumAchromaticNumber::new(graph);
-    assert_eq!(problem.evaluate(&[0]), Max(Some(1)));
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Max(Some(1)));
 }
 
 #[test]
@@ -88,9 +92,9 @@ fn test_maximum_achromatic_number_complete_graph_k3() {
     let problem = MaximumAchromaticNumber::new(graph);
 
     // 3 colors: proper and complete (every color pair has an edge)
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Max(Some(3)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2]).unwrap(), Max(Some(3)));
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Max(Some(3)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(3)));
 }
diff --git a/src/unit_tests/models/graph/maximum_clique.rs b/src/unit_tests/models/graph/maximum_clique.rs
index a91da8e33..f83c6107d 100644
--- a/src/unit_tests/models/graph/maximum_clique.rs
+++ b/src/unit_tests/models/graph/maximum_clique.rs
@@ -1,19 +1,28 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_weight_count_mismatch() {
+    assert_eq!(MaximumCliqueCreateSpec::<i64>::FIELDS[1].name, "weights");
+    let result = MaximumClique::try_from(MaximumCliqueCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        weights: vec![1],
+    });
+    assert!(result.is_err());
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::types::{Max, One};
 
 #[test]
 fn test_clique_creation() {
-    use crate::traits::Problem;
-
     let problem = MaximumClique::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 3);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2]);
 }
 
 #[test]
@@ -25,14 +34,14 @@ fn test_clique_with_weights() {
 
 #[test]
 fn test_clique_unweighted() {
-    // i32 type is always considered weighted, even with uniform values
-    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    // i64 type is always considered weighted, even with uniform values
+    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     assert!(problem.is_weighted());
 }
 
 #[test]
 fn test_has_edge() {
-    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     assert!(problem.graph().has_edge(0, 1));
     assert!(problem.graph().has_edge(1, 0)); // Undirected
     assert!(problem.graph().has_edge(1, 2));
@@ -46,14 +55,20 @@ fn test_evaluate_valid() {
     // Complete graph K3 (triangle)
     let problem = MaximumClique::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
 
     // Valid: all three form a clique
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Max(Some(3)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true]).unwrap(),
+        Max(Some(3))
+    );
 
     // Valid: any pair
-    assert_eq!(problem.evaluate(&[1, 1, 0]), Max(Some(2)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false]).unwrap(),
+        Max(Some(2))
+    );
 }
 
 #[test]
@@ -61,22 +76,31 @@ fn test_evaluate_invalid() {
     use crate::traits::Problem;
 
     // Path graph: 0-1-2 (no edge between 0 and 2)
-    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
 
     // Invalid: 0 and 2 are not adjacent - returns Invalid
-    assert_eq!(problem.evaluate(&[1, 0, 1]), Max(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, true]).unwrap(),
+        Max(None)
+    );
 
     // Invalid: all three selected but not a clique
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Max(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true]).unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
 fn test_evaluate_empty() {
     use crate::traits::Problem;
 
-    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     // Empty set is a valid clique with size 0
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Max(Some(0)));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false]).unwrap(),
+        Max(Some(0))
+    );
 }
 
 #[test]
@@ -89,10 +113,16 @@ fn test_weighted_solution() {
     );
 
     // Select vertex 2 (weight 30)
-    assert_eq!(problem.evaluate(&[0, 0, 1]), Max(Some(30)));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, true]).unwrap(),
+        Max(Some(30))
+    );
 
     // Select all three (weights 10 + 20 + 30 = 60)
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Max(Some(60)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true]).unwrap(),
+        Max(Some(60))
+    );
 }
 
 #[test]
@@ -100,13 +130,13 @@ fn test_brute_force_triangle() {
     // Triangle graph (K3): max clique is all 3 vertices
     let problem = MaximumClique::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![1, 1, 1]);
+    assert_eq!(solutions[0], vec![true, true, true]);
 }
 
 #[test]
@@ -114,16 +144,16 @@ fn test_brute_force_path() {
     use crate::traits::Problem;
 
     // Path graph 0-1-2: max clique is any adjacent pair
-    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // Maximum size is 2
     for sol in &solutions {
-        let size: usize = sol.iter().sum();
+        let size: usize = sol.iter().filter(|&&selected| selected).count();
         assert_eq!(size, 2);
         // Verify it's valid
-        assert!(problem.evaluate(sol).is_valid());
+        assert!(problem.evaluate(sol).unwrap().is_valid());
     }
 }
 
@@ -135,11 +165,11 @@ fn test_brute_force_weighted() {
     let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1, 100, 1]);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // Should select {0, 1} (weight 101) or {1, 2} (weight 101)
     assert!(solutions.len() == 2);
     for sol in &solutions {
-        assert_eq!(problem.evaluate(sol), Max(Some(101)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Max(Some(101)));
     }
 }
 
@@ -168,7 +198,7 @@ fn test_is_clique_function() {
 
 #[test]
 fn test_edges() {
-    let problem = MaximumClique::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i32; 4]);
+    let problem = MaximumClique::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i64; 4]);
     let edges = problem.graph().edges();
     assert_eq!(edges.len(), 2);
 }
@@ -176,14 +206,14 @@ fn test_edges() {
 #[test]
 fn test_empty_graph() {
     // No edges means any single vertex is a max clique
-    let problem = MaximumClique::new(SimpleGraph::new(3, vec![]), vec![1i32; 3]);
+    let problem = MaximumClique::new(SimpleGraph::new(3, vec![]), vec![1i64; 3]);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 3);
     // Each solution should have exactly one vertex selected
     for sol in &solutions {
-        assert_eq!(sol.iter().sum::<usize>(), 1);
+        assert_eq!(sol.iter().filter(|&&selected| selected).count(), 1);
     }
 }
 
@@ -191,13 +221,22 @@ fn test_empty_graph() {
 fn test_is_clique_method() {
     use crate::traits::Problem;
 
-    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
 
     // Valid clique - returns Valid
-    assert!(problem.evaluate(&[1, 1, 0]).is_valid());
-    assert!(problem.evaluate(&[0, 1, 1]).is_valid());
+    assert!(problem
+        .evaluate(&vec![true, true, false])
+        .unwrap()
+        .is_valid());
+    assert!(problem
+        .evaluate(&vec![false, true, true])
+        .unwrap()
+        .is_valid());
     // Invalid: 0-2 not adjacent - returns Invalid
-    assert_eq!(problem.evaluate(&[1, 0, 1]), Max(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, true]).unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
@@ -210,7 +249,7 @@ fn test_from_graph() {
 
 #[test]
 fn test_graph_accessor() {
-    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let graph = problem.graph();
     assert_eq!(graph.num_vertices(), 3);
     assert_eq!(graph.num_edges(), 1);
@@ -234,13 +273,13 @@ fn test_complete_graph() {
     // K4 - complete graph with 4 vertices
     let problem = MaximumClique::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![1, 1, 1, 1]); // All vertices form a clique
+    assert_eq!(solutions[0], vec![true, true, true, true]); // All vertices form a clique
 }
 
 #[test]
@@ -250,13 +289,13 @@ fn test_clique_problem() {
     // Triangle graph: all pairs connected
     let p = MaximumClique::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
-    assert_eq!(p.dims(), vec![2, 2, 2]);
+    assert_eq!(p.dimensions(), vec![2, 2, 2]);
     // Valid clique: select all 3 vertices (triangle is a clique)
-    assert_eq!(p.evaluate(&[1, 1, 1]), Max(Some(3)));
+    assert_eq!(p.evaluate(&vec![true, true, true]).unwrap(), Max(Some(3)));
     // Valid clique: select just vertex 0
-    assert_eq!(p.evaluate(&[1, 0, 0]), Max(Some(1)));
+    assert_eq!(p.evaluate(&vec![true, false, false]).unwrap(), Max(Some(1)));
 }
 
 #[test]
@@ -264,19 +303,19 @@ fn test_is_valid_solution() {
     // Triangle: 0-1-2 all connected
     let problem = MaximumClique::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
     // Valid: all three form a clique
-    assert!(problem.is_valid_solution(&[1, 1, 1]));
+    assert!(problem.is_valid_solution(&[true, true, true]));
     // Now path graph: 0-1-2 (no 0-2 edge)
-    let problem2 = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem2 = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     // Invalid: {0, 2} not adjacent
-    assert!(!problem2.is_valid_solution(&[1, 0, 1]));
+    assert!(!problem2.is_valid_solution(&[true, false, true]));
 }
 
 #[test]
-fn test_size_getters() {
-    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+fn test_parameter_getters() {
+    let problem = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     assert_eq!(problem.num_vertices(), 3);
     assert_eq!(problem.num_edges(), 2);
 }
@@ -291,17 +330,23 @@ fn test_clique_one_weights_evaluate_and_solve() {
         vec![One; 3],
     );
     assert!(!problem.is_weighted());
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Max(Some(3)));
-    assert_eq!(problem.evaluate(&[1, 1, 0]), Max(Some(2)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true]).unwrap(),
+        Max(Some(3))
+    );
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false]).unwrap(),
+        Max(Some(2))
+    );
     // Invalid clique on this graph? K3 is complete, so every subset is a clique.
     // Re-verify invalidity on a path graph:
     let path = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![One; 3]);
-    assert_eq!(path.evaluate(&[1, 0, 1]), Max(None));
+    assert_eq!(path.evaluate(&vec![true, false, true]).unwrap(), Max(None));
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![1, 1, 1]);
+    assert_eq!(solutions[0], vec![true, true, true]);
 }
 
 #[test]
@@ -309,13 +354,13 @@ fn test_clique_paper_example() {
     use crate::traits::Problem;
     // Paper: house graph, max clique K = {v_2, v_3, v_4}, omega(G) = 3
     let graph = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]);
-    let problem = MaximumClique::new(graph, vec![1i32; 5]);
-    let config = vec![0, 0, 1, 1, 1]; // {v_2, v_3, v_4}
-    let result = problem.evaluate(&config);
+    let problem = MaximumClique::new(graph, vec![1i64; 5]);
+    let config = vec![false, false, true, true, true]; // {v_2, v_3, v_4}
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 3);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 3);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 3);
 }
diff --git a/src/unit_tests/models/graph/maximum_co_k_plex.rs b/src/unit_tests/models/graph/maximum_co_k_plex.rs
index 0630c5733..f92e1eaf2 100644
--- a/src/unit_tests/models/graph/maximum_co_k_plex.rs
+++ b/src/unit_tests/models/graph/maximum_co_k_plex.rs
@@ -1,17 +1,30 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::{Max, One};
 use crate::variant::KN;
-use crate::Solver;
+
+#[test]
+fn create_spec_uses_k_input() {
+    assert_eq!(MaximumCoKPlexCreateSpec::<i64>::FIELDS[2].name, "k");
+    let problem = MaximumCoKPlex::try_from(MaximumCoKPlexCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        weights: vec![2, 3],
+        k: 1,
+    })
+    .unwrap();
+    assert_eq!(problem.bound_k(), 1);
+    assert_eq!(problem.weights(), &[2, 3]);
+}
 
 fn c5() -> SimpleGraph {
     SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)])
 }
 
-fn issue_instance() -> MaximumCoKPlex<SimpleGraph, i32, KN> {
-    MaximumCoKPlex::<_, i32, KN>::with_k(c5(), vec![5, 1, 4, 1, 3], 2)
+fn issue_instance() -> MaximumCoKPlex<SimpleGraph, i64, KN> {
+    MaximumCoKPlex::<_, i64, KN>::with_k(c5(), vec![5, 1, 4, 1, 3], 2)
 }
 
 #[test]
@@ -21,7 +34,7 @@ fn test_maximum_co_k_plex_creation() {
     assert_eq!(problem.graph().num_edges(), 5);
     assert_eq!(problem.weights(), &[5, 1, 4, 1, 3]);
     assert_eq!(problem.bound_k(), 2);
-    assert_eq!(problem.dims(), vec![2; 5]);
+    assert_eq!(problem.dimensions(), vec![2; 5]);
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_edges(), 5);
     assert!(problem.is_weighted());
@@ -33,13 +46,23 @@ fn test_maximum_co_k_plex_evaluate_feasible() {
 
     // Optimum from the issue: x = (1,0,1,0,1), S = {0,2,4}.
     // Induced subgraph has only the edge (4,0); induced degrees (1,0,1) all <= 1.
-    assert_eq!(problem.evaluate(&[1, 0, 1, 0, 1]), Max(Some(5 + 4 + 3)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, true, false, true])
+            .unwrap(),
+        Max(Some(5 + 4 + 3))
+    );
 
     // S = {0,1}: induced edge (0,1), induced degrees (1,1) -- still feasible at k=2.
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0, 0]), Max(Some(5 + 1)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, false, false, false])
+            .unwrap(),
+        Max(Some(5 + 1))
+    );
 
     // Empty set: always feasible.
-    assert_eq!(problem.evaluate(&[0; 5]), Max(Some(0)));
+    assert_eq!(problem.evaluate(&vec![false; 5]).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -47,23 +70,29 @@ fn test_maximum_co_k_plex_evaluate_infeasible() {
     let problem = issue_instance();
 
     // S = {0,1,2}: vertex 1 has induced degree 2 > k-1 = 1.
-    assert_eq!(problem.evaluate(&[1, 1, 1, 0, 0]), Max(None));
-    assert!(!problem.is_valid_solution(&[1, 1, 1, 0, 0]));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, false, false])
+            .unwrap(),
+        Max(None)
+    );
+    assert!(!problem.is_valid_solution(&[true, true, true, false, false]));
 
     // Whole 5-cycle: every vertex has induced degree 2 > 1.
-    assert_eq!(problem.evaluate(&[1; 5]), Max(None));
+    assert_eq!(problem.evaluate(&vec![true; 5]).unwrap(), Max(None));
 }
 
 #[test]
 fn test_maximum_co_k_plex_brute_force() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let aggregate = solver.solve(&problem);
+    let aggregate_solution = solver.solve(&problem).unwrap().unwrap();
+    let aggregate = problem.evaluate(&aggregate_solution).unwrap();
     assert_eq!(aggregate, Max(Some(12)));
 
-    let witness = solver.find_witness(&problem).expect("witness exists");
+    let witness = solver.solve(&problem).unwrap().expect("witness exists");
     assert!(problem.is_valid_solution(&witness));
-    assert_eq!(problem.evaluate(&witness), Max(Some(12)));
+    assert_eq!(problem.evaluate(&witness).unwrap(), Max(Some(12)));
 }
 
 #[test]
@@ -72,24 +101,44 @@ fn test_maximum_co_k_plex_k_equals_1_is_independent_set() {
     // 5-cycle MIS has size 2, so unit-weight optimum is 2.
     let problem = MaximumCoKPlex::<_, One, KN>::with_k(c5(), vec![One; 5], 1);
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Max(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Max(Some(2))
+    );
 
     // Picking adjacent vertices violates the k=1 constraint.
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0, 0]), Max(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, false, false, false])
+            .unwrap(),
+        Max(None)
+    );
     // Any two non-adjacent vertices is feasible.
-    assert_eq!(problem.evaluate(&[1, 0, 1, 0, 0]), Max(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, true, false, false])
+            .unwrap(),
+        Max(Some(2))
+    );
 }
 
 #[test]
 fn test_maximum_co_k_plex_serialization_roundtrip() {
     let problem = issue_instance();
     let json = serde_json::to_value(&problem).expect("serialize");
-    let restored: MaximumCoKPlex<SimpleGraph, i32, KN> =
+    let restored: MaximumCoKPlex<SimpleGraph, i64, KN> =
         serde_json::from_value(json).expect("deserialize");
     assert_eq!(restored.graph().num_vertices(), 5);
     assert_eq!(restored.weights(), &[5, 1, 4, 1, 3]);
     assert_eq!(restored.bound_k(), 2);
-    assert_eq!(restored.evaluate(&[1, 0, 1, 0, 1]), Max(Some(12)));
+    assert_eq!(
+        restored
+            .evaluate(&vec![true, false, true, false, true])
+            .unwrap(),
+        Max(Some(12))
+    );
 }
 
 #[test]
@@ -130,7 +179,7 @@ fn test_maximum_co_k_plex_rejects_missing_bound_k_on_load() {
         "weights": [5, 1, 4, 1, 3]
         // bound_k intentionally omitted
     });
-    let err = serde_json::from_value::<MaximumCoKPlex<SimpleGraph, i32, KN>>(bad_json)
+    let err = serde_json::from_value::<MaximumCoKPlex<SimpleGraph, i64, KN>>(bad_json)
         .expect_err("missing bound_k must fail to deserialize");
     let msg = err.to_string();
     assert!(
diff --git a/src/unit_tests/models/graph/maximum_common_edge_subgraph.rs b/src/unit_tests/models/graph/maximum_common_edge_subgraph.rs
index 545d9a5b3..00118979c 100644
--- a/src/unit_tests/models/graph/maximum_common_edge_subgraph.rs
+++ b/src/unit_tests/models/graph/maximum_common_edge_subgraph.rs
@@ -1,8 +1,8 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Max;
-use crate::Solver;
 
 fn issue_instance() -> MaximumCommonEdgeSubgraph {
     // Labels a/b/c/d encoded as 0/1/2/3 (alphabetical).
@@ -41,7 +41,7 @@ fn test_maximum_common_edge_subgraph_creation() {
     assert_eq!(problem.num_arcs_2(), 6);
     assert_eq!(problem.bottom_index(), 4);
     // dims must be [|V2| + 1; |V1|] = [5; 5].
-    assert_eq!(problem.dims(), vec![5; 5]);
+    assert_eq!(problem.dimensions(), vec![5; 5]);
     assert_eq!(problem.num_variables(), 5);
 }
 
@@ -53,8 +53,14 @@ fn test_maximum_common_edge_subgraph_evaluate_optimum() {
     // Preserved arcs: (0,a,1), (1,b,2), (0,c,2), (2,a,3), (1,d,3); the last
     // source arc (3,b,4) is skipped because vertex 4 is unmatched.
     assert!(problem.is_valid_solution(&[0, 1, 2, 3, 4]));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 4]), Max(Some(5)));
-    assert_eq!(problem.preserved_arc_count(&[0, 1, 2, 3, 4]), Some(5));
+    assert_eq!(
+        problem.evaluate(&vec![0, 1, 2, 3, 4]).unwrap(),
+        Max(Some(5))
+    );
+    assert_eq!(
+        problem.preserved_arc_count(&[0, 1, 2, 3, 4]).unwrap(),
+        Some(5)
+    );
 }
 
 #[test]
@@ -63,8 +69,8 @@ fn test_maximum_common_edge_subgraph_evaluate_injectivity_violated() {
 
     // Two source vertices map to graph_2 vertex 0 -> injectivity violated.
     assert!(!problem.is_valid_solution(&[0, 0, 2, 3, 4]));
-    assert_eq!(problem.evaluate(&[0, 0, 2, 3, 4]), Max(None));
-    assert_eq!(problem.preserved_arc_count(&[0, 0, 2, 3, 4]), None);
+    assert_eq!(problem.evaluate(&vec![0, 0, 2, 3, 4]).unwrap(), Max(None));
+    assert_eq!(problem.preserved_arc_count(&[0, 0, 2, 3, 4]).unwrap(), None);
 }
 
 #[test]
@@ -80,32 +86,33 @@ fn test_maximum_common_edge_subgraph_evaluate_fewer_preserved() {
     // (1,d=3,3) -> (2,3,3): NOT in G2 (G2 has (1,3,3)).
     // (3,b=1,4) -> vertex 4 unmatched, skip.
     // So preserved = 0.
-    let config = [0, 2, 1, 3, 4];
+    let config = vec![0, 2, 1, 3, 4];
     assert!(problem.is_valid_solution(&config));
-    assert_eq!(problem.evaluate(&config), Max(Some(0)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(0)));
 
     // Unmatch vertex 3 as well: lose the (2,a,3) and (1,d,3) preservations
     // but keep (0,a,1), (1,b,2), (0,c,2). Total = 3.
-    let config = [0, 1, 2, 4, 4];
+    let config = vec![0, 1, 2, 4, 4];
     assert!(problem.is_valid_solution(&config));
-    assert_eq!(problem.evaluate(&config), Max(Some(3)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(3)));
 
     // All unmatched -> nothing preserved but still feasible.
-    let config = [4, 4, 4, 4, 4];
+    let config = vec![4, 4, 4, 4, 4];
     assert!(problem.is_valid_solution(&config));
-    assert_eq!(problem.evaluate(&config), Max(Some(0)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(0)));
 }
 
 #[test]
 fn test_maximum_common_edge_subgraph_brute_force_finds_optimum() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Max(Some(5)));
 
-    let witness = solver.find_witness(&problem).expect("witness exists");
+    let witness = solver.solve(&problem).unwrap().expect("witness exists");
     assert!(problem.is_valid_solution(&witness));
-    assert_eq!(problem.evaluate(&witness), Max(Some(5)));
+    assert_eq!(problem.evaluate(&witness).unwrap(), Max(Some(5)));
 }
 
 #[test]
@@ -117,7 +124,10 @@ fn test_maximum_common_edge_subgraph_serialization_roundtrip() {
     assert_eq!(restored.num_vertices_2(), 4);
     assert_eq!(restored.num_arcs_1(), 6);
     assert_eq!(restored.num_arcs_2(), 6);
-    assert_eq!(restored.evaluate(&[0, 1, 2, 3, 4]), Max(Some(5)));
+    assert_eq!(
+        restored.evaluate(&vec![0, 1, 2, 3, 4]).unwrap(),
+        Max(Some(5))
+    );
     assert_eq!(restored, problem);
 }
 
@@ -136,10 +146,16 @@ fn test_maximum_common_edge_subgraph_rejects_wrong_length_config() {
     let problem = issue_instance();
     // |V1| = 5, but the config has 4 entries -> infeasible.
     assert!(!problem.is_valid_solution(&[0, 1, 2, 3]));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Too long.
     assert!(!problem.is_valid_solution(&[0, 1, 2, 3, 4, 4]));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 4, 4]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 4, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -147,7 +163,10 @@ fn test_maximum_common_edge_subgraph_rejects_out_of_range_target() {
     let problem = issue_instance();
     // 5 is out of range: the only legal "unmatched" sentinel is |V2| = 4.
     assert!(!problem.is_valid_solution(&[0, 1, 2, 3, 5]));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 5]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/maximum_contact_map_overlap.rs b/src/unit_tests/models/graph/maximum_contact_map_overlap.rs
index b1fe06199..03cb0e25d 100644
--- a/src/unit_tests/models/graph/maximum_contact_map_overlap.rs
+++ b/src/unit_tests/models/graph/maximum_contact_map_overlap.rs
@@ -1,9 +1,9 @@
 use super::*;
 use crate::registry::find_problem_type_by_alias;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Max;
-use crate::Solver;
 
 fn issue_instance() -> MaximumContactMapOverlap {
     // Canonical example from the issue:
@@ -20,7 +20,7 @@ fn test_maximum_contact_map_overlap_creation() {
     assert_eq!(problem.num_contacts_1(), 2);
     assert_eq!(problem.num_contacts_2(), 3);
     // dims must be [|V_2| + 1; |V_1|] = [6; 4].
-    assert_eq!(problem.dims(), vec![6; 4]);
+    assert_eq!(problem.dimensions(), vec![6; 4]);
     assert_eq!(problem.num_variables(), 4);
     // Contacts get normalized so the smaller endpoint comes first.
     let contacts_2 = problem.contacts_2();
@@ -39,8 +39,11 @@ fn test_maximum_contact_map_overlap_evaluate_optimum() {
     //   - contact {1,3}: mapped (1, 4); sorted (1, 4) in E_2
     //   - value = 2 contacts preserved.
     assert!(problem.is_valid_solution(&[1, 2, 4, 5]));
-    assert_eq!(problem.evaluate(&[1, 2, 4, 5]), Max(Some(2)));
-    assert_eq!(problem.preserved_contact_count(&[1, 2, 4, 5]), Some(2));
+    assert_eq!(problem.evaluate(&vec![1, 2, 4, 5]).unwrap(), Max(Some(2)));
+    assert_eq!(
+        problem.preserved_contact_count(&[1, 2, 4, 5]).unwrap(),
+        Some(2)
+    );
 }
 
 #[test]
@@ -48,7 +51,7 @@ fn test_maximum_contact_map_overlap_evaluate_all_unmatched() {
     let problem = issue_instance();
     // No vertex matched -> no contacts preserved, but trivially feasible.
     assert!(problem.is_valid_solution(&[0, 0, 0, 0]));
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Max(Some(0)));
+    assert_eq!(problem.evaluate(&vec![0, 0, 0, 0]).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -58,7 +61,7 @@ fn test_maximum_contact_map_overlap_evaluate_single_match() {
     // satisfies both injectivity and strict monotonicity), but no contact
     // has both endpoints matched, so the score is 0.
     assert!(problem.is_valid_solution(&[1, 0, 0, 0]));
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0]), Max(Some(0)));
+    assert_eq!(problem.evaluate(&vec![1, 0, 0, 0]).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -66,8 +69,11 @@ fn test_maximum_contact_map_overlap_evaluate_not_injective() {
     let problem = issue_instance();
     // Two source vertices map to the same nonzero image -> infeasible.
     assert!(!problem.is_valid_solution(&[1, 1, 0, 0]));
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0]), Max(None));
-    assert_eq!(problem.preserved_contact_count(&[1, 1, 0, 0]), None);
+    assert_eq!(problem.evaluate(&vec![1, 1, 0, 0]).unwrap(), Max(None));
+    assert_eq!(
+        problem.preserved_contact_count(&[1, 1, 0, 0]).unwrap(),
+        None
+    );
 }
 
 #[test]
@@ -77,7 +83,7 @@ fn test_maximum_contact_map_overlap_evaluate_not_order_preserving() {
     // residue index 0): both nonzero, but 2 > 1 in source order -> not
     // order-preserving.
     assert!(!problem.is_valid_solution(&[2, 1, 0, 0]));
-    assert_eq!(problem.evaluate(&[2, 1, 0, 0]), Max(None));
+    assert_eq!(problem.evaluate(&vec![2, 1, 0, 0]).unwrap(), Max(None));
 }
 
 #[test]
@@ -89,19 +95,20 @@ fn test_maximum_contact_map_overlap_evaluate_suboptimal_feasible() {
     //   - contact {1,3}: mapped (1, 3) ∉ E_2 -> not preserved
     //   - value = 1.
     assert!(problem.is_valid_solution(&[1, 2, 3, 4]));
-    assert_eq!(problem.evaluate(&[1, 2, 3, 4]), Max(Some(1)));
+    assert_eq!(problem.evaluate(&vec![1, 2, 3, 4]).unwrap(), Max(Some(1)));
 }
 
 #[test]
 fn test_maximum_contact_map_overlap_brute_force_finds_optimum() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Max(Some(2)));
 
-    let witness = solver.find_witness(&problem).expect("witness exists");
+    let witness = solver.solve(&problem).unwrap().expect("witness exists");
     assert!(problem.is_valid_solution(&witness));
-    assert_eq!(problem.evaluate(&witness), Max(Some(2)));
+    assert_eq!(problem.evaluate(&witness).unwrap(), Max(Some(2)));
 }
 
 #[test]
@@ -109,10 +116,16 @@ fn test_maximum_contact_map_overlap_rejects_wrong_length_config() {
     let problem = issue_instance();
     // |V_1| = 4, config has 3 entries -> infeasible.
     assert!(!problem.is_valid_solution(&[0, 0, 0]));
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Too long.
     assert!(!problem.is_valid_solution(&[0, 0, 0, 0, 0]));
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -120,7 +133,10 @@ fn test_maximum_contact_map_overlap_rejects_out_of_range_value() {
     let problem = issue_instance();
     // Valid entries are 0..=|V_2| = 0..=5. Value 6 is out of range.
     assert!(!problem.is_valid_solution(&[0, 0, 0, 6]));
-    assert_eq!(problem.evaluate(&[0, 0, 0, 6]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 6]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -129,7 +145,7 @@ fn test_maximum_contact_map_overlap_serialization_roundtrip() {
     let json = serde_json::to_value(&problem).expect("serialize");
     let restored: MaximumContactMapOverlap = serde_json::from_value(json).expect("deserialize");
     assert_eq!(restored, problem);
-    assert_eq!(restored.evaluate(&[1, 2, 4, 5]), Max(Some(2)));
+    assert_eq!(restored.evaluate(&vec![1, 2, 4, 5]).unwrap(), Max(Some(2)));
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/maximum_domatic_number.rs b/src/unit_tests/models/graph/maximum_domatic_number.rs
index 027581b3b..f922d8cea 100644
--- a/src/unit_tests/models/graph/maximum_domatic_number.rs
+++ b/src/unit_tests/models/graph/maximum_domatic_number.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Max;
@@ -11,7 +12,7 @@ fn test_maximum_domatic_number_creation() {
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 3);
     assert_eq!(problem.num_variables(), 4);
-    assert_eq!(problem.dims(), vec![4; 4]);
+    assert_eq!(problem.dimensions(), vec![4; 4]);
 }
 
 #[test]
@@ -34,7 +35,7 @@ fn test_maximum_domatic_number_evaluate_optimal() {
     );
     let problem = MaximumDomaticNumber::new(graph);
     let config = vec![0, 1, 2, 0, 2, 1];
-    let result = problem.evaluate(&config);
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Max(Some(3)));
 }
 
@@ -46,7 +47,7 @@ fn test_maximum_domatic_number_evaluate_invalid() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MaximumDomaticNumber::new(graph);
     let config = vec![0, 1, 2];
-    let result = problem.evaluate(&config);
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Max(None));
 }
 
@@ -56,7 +57,7 @@ fn test_maximum_domatic_number_evaluate_trivial() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
     let problem = MaximumDomaticNumber::new(graph);
     let config = vec![0, 0, 0, 0];
-    let result = problem.evaluate(&config);
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Max(Some(1)));
 }
 
@@ -67,8 +68,8 @@ fn test_maximum_domatic_number_solver_p3() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MaximumDomaticNumber::new(graph);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&witness);
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&witness).unwrap();
     assert_eq!(value, Max(Some(2)));
 }
 
@@ -78,8 +79,8 @@ fn test_maximum_domatic_number_solver_complete_graph() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
     let problem = MaximumDomaticNumber::new(graph);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&witness);
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&witness).unwrap();
     assert_eq!(value, Max(Some(4)));
 }
 
@@ -94,7 +95,7 @@ fn test_maximum_domatic_number_serialization() {
 }
 
 #[test]
-fn test_maximum_domatic_number_size_getters() {
+fn test_maximum_domatic_number_parameter_getters() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]);
     let problem = MaximumDomaticNumber::new(graph);
     assert_eq!(problem.num_vertices(), 5);
@@ -107,5 +108,5 @@ fn test_maximum_domatic_number_single_vertex() {
     let graph = SimpleGraph::new(1, vec![]);
     let problem = MaximumDomaticNumber::new(graph);
     let config = vec![0];
-    assert_eq!(problem.evaluate(&config), Max(Some(1)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(1)));
 }
diff --git a/src/unit_tests/models/graph/maximum_edge_weighted_k_clique.rs b/src/unit_tests/models/graph/maximum_edge_weighted_k_clique.rs
index 9762cfa0c..a00cd688c 100644
--- a/src/unit_tests/models/graph/maximum_edge_weighted_k_clique.rs
+++ b/src/unit_tests/models/graph/maximum_edge_weighted_k_clique.rs
@@ -1,19 +1,31 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_edge_weights() {
+    let p = MaximumEdgeWeightedKClique::try_from(MaximumEdgeWeightedKCliqueCreateSpec::<i64> {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        edge_weights: None,
+        k: 2,
+    })
+    .unwrap();
+    assert_eq!(p.edge_weights(), &[1]);
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Max;
-use crate::Solver;
 
 /// Canonical instance from issue #1020: 4 vertices, edges
 /// {(0,1), (0,2), (1,2), (0,3), (1,3)} with weights [5, 4, -1, 1, 0]
 /// and k = 3. Triangles are {0,1,2} (value 8) and {0,1,3} (value 6).
-fn issue_instance() -> MaximumEdgeWeightedKClique<i32> {
-    MaximumEdgeWeightedKClique::<i32>::new(
+fn issue_instance() -> MaximumEdgeWeightedKClique<i64> {
+    MaximumEdgeWeightedKClique::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
         vec![5, 4, -1, 1, 0],
         3,
     )
+    .unwrap()
 }
 
 #[test]
@@ -23,7 +35,7 @@ fn test_maximum_edge_weighted_k_clique_creation() {
     assert_eq!(problem.num_edges(), 5);
     assert_eq!(problem.k(), 3);
     assert_eq!(problem.edge_weights(), &[5, 4, -1, 1, 0]);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(problem.num_variables(), 4);
     assert!(problem.graph().has_edge(0, 1));
     assert!(!problem.graph().has_edge(2, 3));
@@ -34,12 +46,18 @@ fn test_maximum_edge_weighted_k_clique_evaluate_feasible() {
     let problem = issue_instance();
 
     // Optimum from the issue: S = {0,1,2}, value 5 + 4 + (-1) = 8.
-    assert_eq!(problem.evaluate(&[1, 1, 1, 0]), Max(Some(8)));
-    assert!(problem.is_valid_solution(&[1, 1, 1, 0]));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true, false]).unwrap(),
+        Max(Some(8))
+    );
+    assert!(problem.is_valid_solution(&[true, true, true, false]));
 
     // Other feasible 3-clique {0,1,3} with value 5 + 1 + 0 = 6.
-    assert_eq!(problem.evaluate(&[1, 1, 0, 1]), Max(Some(6)));
-    assert!(problem.is_valid_solution(&[1, 1, 0, 1]));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false, true]).unwrap(),
+        Max(Some(6))
+    );
+    assert!(problem.is_valid_solution(&[true, true, false, true]));
 }
 
 #[test]
@@ -47,14 +65,23 @@ fn test_maximum_edge_weighted_k_clique_evaluate_infeasible_wrong_size() {
     let problem = issue_instance();
 
     // |S| = 2 != k = 3 -> infeasible.
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0]), Max(None));
-    assert!(!problem.is_valid_solution(&[1, 1, 0, 0]));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false, false]).unwrap(),
+        Max(None)
+    );
+    assert!(!problem.is_valid_solution(&[true, true, false, false]));
 
     // |S| = 4 != k = 3 -> infeasible (also not a 4-clique here).
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1]), Max(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true, true]).unwrap(),
+        Max(None)
+    );
 
     // Empty selection: |S| = 0 != k = 3 -> infeasible.
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Max(None));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false, false]).unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
@@ -62,37 +89,60 @@ fn test_maximum_edge_weighted_k_clique_evaluate_infeasible_not_clique() {
     let problem = issue_instance();
 
     // {0,2,3}: edge (2,3) is not present in E -> not a clique.
-    assert_eq!(problem.evaluate(&[1, 0, 1, 1]), Max(None));
-    assert!(!problem.is_valid_solution(&[1, 0, 1, 1]));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, true, true]).unwrap(),
+        Max(None)
+    );
+    assert!(!problem.is_valid_solution(&[true, false, true, true]));
 
     // {1,2,3}: edge (2,3) is not present -> not a clique.
-    assert_eq!(problem.evaluate(&[0, 1, 1, 1]), Max(None));
+    assert_eq!(
+        problem.evaluate(&vec![false, true, true, true]).unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
 fn test_maximum_edge_weighted_k_clique_brute_force() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Max(Some(8)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Max(Some(8))
+    );
 
-    let witness = solver.find_witness(&problem).expect("witness exists");
+    let witness = solver.solve(&problem).unwrap().expect("witness exists");
     assert!(problem.is_valid_solution(&witness));
-    assert_eq!(problem.evaluate(&witness), Max(Some(8)));
+    assert_eq!(problem.evaluate(&witness).unwrap(), Max(Some(8)));
 }
 
 #[test]
 fn test_maximum_edge_weighted_k_clique_k_zero_returns_zero() {
     // With k = 0 the unique feasible config selects no vertices and the
     // induced edge set is empty, so the objective is 0.
-    let problem = MaximumEdgeWeightedKClique::<i32>::new(
+    let problem = MaximumEdgeWeightedKClique::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
         vec![5, 4, -1, 1, 0],
         0,
+    )
+    .unwrap();
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false, false]).unwrap(),
+        Max(Some(0))
     );
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Max(Some(0)));
     // Any nonempty selection violates |S| = k = 0.
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0]), Max(None));
-    assert_eq!(BruteForce::new().solve(&problem), Max(Some(0)));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false, false]).unwrap(),
+        Max(None)
+    );
+    assert_eq!(
+        problem
+            .evaluate(&BruteForce::new().solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Max(Some(0))
+    );
 }
 
 #[test]
@@ -100,16 +150,31 @@ fn test_maximum_edge_weighted_k_clique_k_one_returns_zero() {
     // For k = 1 every single-vertex selection is a trivial clique and the
     // induced edge set is empty regardless of edge weights, so all feasible
     // configurations evaluate to 0.
-    let problem = MaximumEdgeWeightedKClique::<i32>::new(
+    let problem = MaximumEdgeWeightedKClique::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
         vec![5, 4, -1, 1, 0],
         1,
+    )
+    .unwrap();
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false, false]).unwrap(),
+        Max(Some(0))
+    );
+    assert_eq!(
+        problem.evaluate(&vec![false, false, true, false]).unwrap(),
+        Max(Some(0))
     );
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0]), Max(Some(0)));
-    assert_eq!(problem.evaluate(&[0, 0, 1, 0]), Max(Some(0)));
     // |S| = 0 != 1 -> infeasible.
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Max(None));
-    assert_eq!(BruteForce::new().solve(&problem), Max(Some(0)));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false, false]).unwrap(),
+        Max(None)
+    );
+    assert_eq!(
+        problem
+            .evaluate(&BruteForce::new().solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Max(Some(0))
+    );
 }
 
 #[test]
@@ -119,50 +184,78 @@ fn test_maximum_edge_weighted_k_clique_f64_variant() {
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
         vec![5.0, 4.0, -1.0, 1.0, 0.0],
         3,
+    )
+    .unwrap();
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true, false]).unwrap(),
+        Max(Some(8.0))
+    );
+    assert_eq!(
+        problem
+            .evaluate(&BruteForce::new().solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Max(Some(8.0))
     );
-    assert_eq!(problem.evaluate(&[1, 1, 1, 0]), Max(Some(8.0)));
-    assert_eq!(BruteForce::new().solve(&problem), Max(Some(8.0)));
 }
 
 #[test]
 fn test_maximum_edge_weighted_k_clique_serialization_roundtrip() {
     let problem = issue_instance();
     let json = serde_json::to_value(&problem).expect("serialize");
-    let restored: MaximumEdgeWeightedKClique<i32> =
+    let restored: MaximumEdgeWeightedKClique<i64> =
         serde_json::from_value(json).expect("deserialize");
     assert_eq!(restored.num_vertices(), 4);
     assert_eq!(restored.num_edges(), 5);
     assert_eq!(restored.k(), 3);
     assert_eq!(restored.edge_weights(), &[5, 4, -1, 1, 0]);
-    assert_eq!(restored.evaluate(&[1, 1, 1, 0]), Max(Some(8)));
+    assert_eq!(
+        restored.evaluate(&vec![true, true, true, false]).unwrap(),
+        Max(Some(8))
+    );
 }
 
 #[test]
 fn test_maximum_edge_weighted_k_clique_problem_name_and_variant() {
     assert_eq!(
-        <MaximumEdgeWeightedKClique<i32> as Problem>::NAME,
+        <MaximumEdgeWeightedKClique<i64> as Problem>::NAME,
         "MaximumEdgeWeightedKClique"
     );
-    let v = <MaximumEdgeWeightedKClique<i32> as Problem>::variant();
-    assert!(v.contains(&("weight", "i32")));
+    let v = <MaximumEdgeWeightedKClique<i64> as Problem>::variant();
+    assert!(v.contains(&("weight", "i64")));
 }
 
 #[test]
-#[should_panic(expected = "edge_weights length must match graph num_edges")]
 fn test_maximum_edge_weighted_k_clique_rejects_weight_length_mismatch() {
-    let _ = MaximumEdgeWeightedKClique::<i32>::new(
+    let error = MaximumEdgeWeightedKClique::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
         vec![1, 2, 3, 4], // length 4 != 5 edges
         3,
-    );
+    )
+    .unwrap_err();
+    assert!(matches!(
+        error,
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "edge_weights length must match graph num_edges"
+    ));
 }
 
 #[test]
-#[should_panic(expected = "k = 5 must be <= num_vertices = 4")]
 fn test_maximum_edge_weighted_k_clique_rejects_k_greater_than_n() {
-    let _ = MaximumEdgeWeightedKClique::<i32>::new(
+    let error = MaximumEdgeWeightedKClique::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
         vec![5, 4, -1, 1, 0],
         5,
-    );
+    )
+    .unwrap_err();
+    assert!(matches!(
+        error,
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "k = 5 must be <= num_vertices = 4"
+    ));
+}
+
+#[test]
+fn test_maximum_edge_weighted_k_clique_rejects_non_finite_weight() {
+    let graph = SimpleGraph::new(2, vec![(0, 1)]);
+    assert!(MaximumEdgeWeightedKClique::new(graph, vec![f64::NAN], 2).is_err());
 }
diff --git a/src/unit_tests/models/graph/maximum_independent_set.rs b/src/unit_tests/models/graph/maximum_independent_set.rs
index 4362cfc39..e5fb725ca 100644
--- a/src/unit_tests/models/graph/maximum_independent_set.rs
+++ b/src/unit_tests/models/graph/maximum_independent_set.rs
@@ -1,4 +1,15 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+#[test]
+fn create_spec_defaults_simple_weights() {
+    let problem = MaximumIndependentSet::try_from(MaximumIndependentSetSimpleI64CreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: Some(3),
+        weights: None,
+    })
+    .unwrap();
+    assert_eq!(problem.weights(), &[1, 1, 1]);
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -8,11 +19,36 @@ include!("../../jl_helpers.rs");
 fn test_independent_set_creation() {
     let problem = MaximumIndependentSet::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 3);
-    assert_eq!(problem.dims().len(), 4);
+    assert_eq!(problem.dimensions().len(), 4);
+}
+
+#[test]
+fn test_evaluate_reports_non_finite_weight_sum() {
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(2, vec![]), vec![f64::MAX, f64::MAX]);
+
+    assert!(matches!(
+        problem.evaluate(&vec![true, true]),
+        Err(crate::traits::EvaluationError::NonFiniteResult(_))
+    ));
+}
+
+#[test]
+fn test_evaluate_rejects_invalid_configurations() {
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(2, vec![]), vec![1_i64, 1]);
+    for solution in [vec![true], vec![true, false, false]] {
+        assert!(matches!(
+            problem.evaluate(&solution),
+            Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+        ));
+    }
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([2, false]))
+            .is_err()
+    );
 }
 
 #[test]
@@ -24,15 +60,15 @@ fn test_independent_set_with_weights() {
 
 #[test]
 fn test_independent_set_unweighted() {
-    // i32 type is always considered weighted, even with uniform values
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    // i64 type is always considered weighted, even with uniform values
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     assert!(problem.is_weighted());
 }
 
 #[test]
 fn test_has_edge() {
     let problem =
-        MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+        MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     assert!(problem.graph().has_edge(0, 1));
     assert!(problem.graph().has_edge(1, 0)); // Undirected
     assert!(problem.graph().has_edge(1, 2));
@@ -66,7 +102,7 @@ fn test_is_independent_set_function() {
 #[test]
 fn test_edges() {
     let problem =
-        MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i32; 4]);
+        MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i64; 4]);
     let edges = problem.graph().edges();
     assert_eq!(edges.len(), 2);
     assert!(edges.contains(&(0, 1)) || edges.contains(&(1, 0)));
@@ -90,14 +126,14 @@ fn test_from_graph() {
 #[test]
 fn test_from_graph_with_unit_weights() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MaximumIndependentSet::new(graph, vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(graph, vec![1i64; 3]);
     assert_eq!(problem.graph().num_vertices(), 3);
     assert_eq!(problem.weights().to_vec(), vec![1, 1, 1]);
 }
 
 #[test]
 fn test_graph_accessor() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let graph = problem.graph();
     assert_eq!(graph.num_vertices(), 3);
     assert_eq!(graph.num_edges(), 1);
@@ -112,7 +148,7 @@ fn test_weights() {
 #[test]
 fn test_problem_name() {
     assert_eq!(
-        <MaximumIndependentSet<SimpleGraph, i32> as Problem>::NAME,
+        <MaximumIndependentSet<SimpleGraph, i64> as Problem>::NAME,
         "MaximumIndependentSet"
     );
 }
@@ -126,11 +162,11 @@ fn test_jl_parity_evaluation() {
     for instance in data["instances"].as_array().unwrap() {
         let nv = instance["instance"]["num_vertices"].as_u64().unwrap() as usize;
         let edges = jl_parse_edges(&instance["instance"]);
-        let weights = jl_parse_i32_vec(&instance["instance"]["weights"]);
+        let weights = jl_parse_i64_vec(&instance["instance"]["weights"]);
         let problem = MaximumIndependentSet::new(SimpleGraph::new(nv, edges), weights);
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config);
+            let config = jl_parse_bool_config(&eval["config"]);
+            let result = problem.evaluate(&config).unwrap();
             let jl_valid = eval["is_valid"].as_bool().unwrap();
             assert_eq!(
                 result.is_valid(),
@@ -139,7 +175,7 @@ fn test_jl_parity_evaluation() {
                 config
             );
             if jl_valid {
-                let jl_size = eval["size"].as_i64().unwrap() as i32;
+                let jl_size = eval["size"].as_i64().unwrap();
                 assert_eq!(
                     result.unwrap(),
                     jl_size,
@@ -148,9 +184,9 @@ fn test_jl_parity_evaluation() {
                 );
             }
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best: HashSet<Vec<bool>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "IS best solutions mismatch");
     }
 }
@@ -159,18 +195,18 @@ fn test_jl_parity_evaluation() {
 fn test_is_valid_solution() {
     // Path graph: 0-1-2
     let problem =
-        MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+        MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     // Valid: {0, 2} is independent
-    assert!(problem.is_valid_solution(&[1, 0, 1]));
+    assert!(problem.is_valid_solution(&[true, false, true]));
     // Invalid: {0, 1} are adjacent
-    assert!(!problem.is_valid_solution(&[1, 1, 0]));
+    assert!(!problem.is_valid_solution(&[true, true, false]));
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = MaximumIndependentSet::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 3);
@@ -199,15 +235,17 @@ fn test_mis_paper_example() {
             (4, 9), // spokes
         ],
     );
-    let problem = MaximumIndependentSet::new(graph, vec![1i32; 10]);
+    let problem = MaximumIndependentSet::new(graph, vec![1i64; 10]);
     // MIS = {1,3,5,9} -> config
-    let config = vec![0, 1, 0, 1, 0, 1, 0, 0, 0, 1];
-    let result = problem.evaluate(&config);
+    let config = vec![
+        false, true, false, true, false, true, false, false, false, true,
+    ];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 4);
 
     // Verify this is optimal
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 4);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 4);
 }
diff --git a/src/unit_tests/models/graph/maximum_leaf_spanning_tree.rs b/src/unit_tests/models/graph/maximum_leaf_spanning_tree.rs
index 0b2fe7dbd..4698599ce 100644
--- a/src/unit_tests/models/graph/maximum_leaf_spanning_tree.rs
+++ b/src/unit_tests/models/graph/maximum_leaf_spanning_tree.rs
@@ -1,4 +1,5 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
 use crate::{solvers::BruteForce, topology::SimpleGraph, traits::Problem};
 
 /// Issue #897 example: 6 vertices, 9 edges.
@@ -28,8 +29,8 @@ fn test_maximum_leaf_spanning_tree_creation() {
     assert_eq!(problem.graph().num_edges(), 9);
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 9);
-    assert_eq!(problem.dims().len(), 9);
-    assert!(problem.dims().iter().all(|&d| d == 2));
+    assert_eq!(problem.dimensions().len(), 9);
+    assert!(problem.dimensions().iter().all(|&d| d == 2));
 }
 
 #[test]
@@ -44,8 +45,8 @@ fn test_maximum_leaf_spanning_tree_evaluate_optimal() {
     let problem = example_instance();
     // Tree: {(0,1),(0,2),(0,3),(2,4),(2,5)} = indices 0,1,2,4,5
     // Degrees: 0->3, 1->1, 2->3, 3->1, 4->1, 5->1 => 4 leaves
-    let config = vec![1, 1, 1, 0, 1, 1, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Max(Some(4)));
+    let config = vec![true, true, true, false, true, true, false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(4)));
 }
 
 #[test]
@@ -54,24 +55,24 @@ fn test_maximum_leaf_spanning_tree_evaluate_valid_suboptimal() {
     // A path tree: (0,1),(1,3),(0,2),(2,4),(4,5) = indices 0,8,1,4,7
     // Wait, edge 8 is (1,3). So: indices 0,1,4,7,8 = [1,1,0,0,1,0,0,1,1]
     // Degrees: 0->2, 1->2, 2->2, 3->1, 4->2, 5->1 => 2 leaves
-    let config = vec![1, 1, 0, 0, 1, 0, 0, 1, 1];
-    assert_eq!(problem.evaluate(&config), Max(Some(2)));
+    let config = vec![true, true, false, false, true, false, false, true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(2)));
 }
 
 #[test]
 fn test_maximum_leaf_spanning_tree_evaluate_invalid_too_few_edges() {
     let problem = example_instance();
     // Only 3 edges (need 5 for spanning tree of 6 vertices)
-    let config = vec![1, 1, 1, 0, 0, 0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Max(None));
+    let config = vec![true, true, true, false, false, false, false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(None));
 }
 
 #[test]
 fn test_maximum_leaf_spanning_tree_evaluate_invalid_too_many_edges() {
     let problem = example_instance();
     // 6 edges selected = cycle
-    let config = vec![1, 1, 1, 1, 1, 1, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Max(None));
+    let config = vec![true, true, true, true, true, true, false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(None));
 }
 
 #[test]
@@ -79,36 +80,38 @@ fn test_maximum_leaf_spanning_tree_evaluate_disconnected() {
     let problem = example_instance();
     // 5 edges but disconnected: (0,1),(0,2),(0,3),(4,5),(1,3) = indices 0,1,2,7,8
     // Vertices {0,1,2,3} and {4,5} are separate => not spanning
-    let config = vec![1, 1, 1, 0, 0, 0, 0, 1, 1];
-    assert_eq!(problem.evaluate(&config), Max(None));
+    let config = vec![true, true, true, false, false, false, false, true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(None));
 }
 
 #[test]
 fn test_maximum_leaf_spanning_tree_evaluate_empty() {
     let problem = example_instance();
-    let config = vec![0; 9];
-    assert_eq!(problem.evaluate(&config), Max(None));
+    let config = vec![false; 9];
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(None));
 }
 
 #[test]
 fn test_maximum_leaf_spanning_tree_brute_force() {
     let problem = example_instance();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     // All optimal solutions should have 4 leaves
     for sol in &solutions {
-        assert_eq!(problem.evaluate(sol), Max(Some(4)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Max(Some(4)));
     }
 }
 
 #[test]
 fn test_maximum_leaf_spanning_tree_is_valid_solution() {
     let problem = example_instance();
-    assert!(problem.is_valid_solution(&[1, 1, 1, 0, 1, 1, 0, 0, 0]));
-    assert!(!problem.is_valid_solution(&[1, 1, 1, 0, 0, 0, 0, 0, 0])); // too few
-    assert!(!problem.is_valid_solution(&[0; 9])); // empty
-    assert!(!problem.is_valid_solution(&[1, 1, 1])); // wrong length
+    assert!(problem.is_valid_solution(&[true, true, true, false, true, true, false, false, false]));
+    assert!(
+        !problem.is_valid_solution(&[true, true, true, false, false, false, false, false, false])
+    );
+    assert!(!problem.is_valid_solution(&[false; 9]));
+    assert!(!problem.is_valid_solution(&[true, true, true]));
 }
 
 #[test]
@@ -125,9 +128,9 @@ fn test_maximum_leaf_spanning_tree_small_path() {
     // Path graph P3: 0-1-2, only spanning tree is the path itself -> 2 leaves
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MaximumLeafSpanningTree::new(graph);
-    assert_eq!(problem.dims(), vec![2, 2]);
-    let config = vec![1, 1];
-    assert_eq!(problem.evaluate(&config), Max(Some(2)));
+    assert_eq!(problem.dimensions(), vec![2, 2]);
+    let config = vec![true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(2)));
 }
 
 #[test]
@@ -137,11 +140,11 @@ fn test_maximum_leaf_spanning_tree_star() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]);
     let problem = MaximumLeafSpanningTree::new(graph);
     // Only one spanning tree: all 3 edges
-    let config = vec![1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Max(Some(3)));
+    let config = vec![true, true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Max(Some(3)));
     // This is optimal (3 leaves out of 4 vertices)
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![1, 1, 1]);
+    assert_eq!(solutions[0], vec![true, true, true]);
 }
diff --git a/src/unit_tests/models/graph/maximum_matching.rs b/src/unit_tests/models/graph/maximum_matching.rs
index 17c170e8c..d39e31e4c 100644
--- a/src/unit_tests/models/graph/maximum_matching.rs
+++ b/src/unit_tests/models/graph/maximum_matching.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Max;
@@ -19,7 +20,7 @@ fn test_matching_creation() {
 #[test]
 fn test_matching_unit_weights() {
     let problem =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
     assert_eq!(problem.graph().num_edges(), 2);
 }
 
@@ -39,13 +40,13 @@ fn test_is_valid_matching() {
     );
 
     // Valid: select edge 0 only
-    assert!(problem.is_valid_matching(&[1, 0, 0]));
+    assert!(problem.is_valid_matching(&[true, false, false]));
 
     // Valid: select edges 0 and 2 (disjoint)
-    assert!(problem.is_valid_matching(&[1, 0, 1]));
+    assert!(problem.is_valid_matching(&[true, false, true]));
 
     // Invalid: edges 0 and 1 share vertex 1
-    assert!(!problem.is_valid_matching(&[1, 1, 0]));
+    assert!(!problem.is_valid_matching(&[true, true, false]));
 }
 
 #[test]
@@ -60,9 +61,9 @@ fn test_is_matching_function() {
 
 #[test]
 fn test_empty_graph() {
-    let problem = MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(3, vec![]));
+    let problem = MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(3, vec![]));
     // Empty matching is valid with size 0
-    assert_eq!(Problem::evaluate(&problem, &[]), Max(Some(0)));
+    assert_eq!(Problem::evaluate(&problem, &vec![]).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -74,9 +75,9 @@ fn test_edges() {
 
 #[test]
 fn test_empty_sets() {
-    let problem = MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(2, vec![]));
+    let problem = MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(2, vec![]));
     // Empty matching
-    assert_eq!(Problem::evaluate(&problem, &[]), Max(Some(0)));
+    assert_eq!(Problem::evaluate(&problem, &vec![]).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -97,7 +98,7 @@ fn test_new() {
 #[test]
 fn test_unit_weights() {
     let problem =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
     assert_eq!(problem.graph().num_vertices(), 3);
     assert_eq!(problem.graph().num_edges(), 2);
     assert_eq!(problem.weights(), vec![1, 1]);
@@ -106,7 +107,7 @@ fn test_unit_weights() {
 #[test]
 fn test_graph_accessor() {
     let problem =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
     assert_eq!(problem.graph().num_vertices(), 3);
     assert_eq!(problem.graph().num_edges(), 2);
 }
@@ -119,11 +120,11 @@ fn test_jl_parity_evaluation() {
         let nv = instance["instance"]["num_vertices"].as_u64().unwrap() as usize;
         let weighted_edges = jl_parse_weighted_edges(&instance["instance"]);
         let edges: Vec<(usize, usize)> = weighted_edges.iter().map(|&(u, v, _)| (u, v)).collect();
-        let weights: Vec<i32> = weighted_edges.into_iter().map(|(_, _, w)| w).collect();
+        let weights: Vec<i64> = weighted_edges.into_iter().map(|(_, _, w)| w).collect();
         let problem = MaximumMatching::new(SimpleGraph::new(nv, edges), weights);
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config);
+            let config = jl_parse_bool_config(&eval["config"]);
+            let result = problem.evaluate(&config).unwrap();
             let jl_valid = eval["is_valid"].as_bool().unwrap();
             assert_eq!(
                 result.is_valid(),
@@ -132,7 +133,7 @@ fn test_jl_parity_evaluation() {
                 config
             );
             if jl_valid {
-                let jl_size = eval["size"].as_i64().unwrap() as i32;
+                let jl_size = eval["size"].as_i64().unwrap();
                 assert_eq!(
                     result.unwrap(),
                     jl_size,
@@ -141,9 +142,9 @@ fn test_jl_parity_evaluation() {
                 );
             }
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best: HashSet<Vec<bool>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "Matching best solutions mismatch");
     }
 }
@@ -153,19 +154,19 @@ fn test_is_valid_solution() {
     // Triangle: edges (0,1), (1,2), (0,2) — config is per edge
     let problem = MaximumMatching::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
     // Valid: select edge (0,1) only — no shared vertices
-    assert!(problem.is_valid_solution(&[1, 0, 0]));
+    assert!(problem.is_valid_solution(&[true, false, false]));
     // Invalid: select edges (0,1) and (1,2) — vertex 1 shared
-    assert!(!problem.is_valid_solution(&[1, 1, 0]));
+    assert!(!problem.is_valid_solution(&[true, true, false]));
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = MaximumMatching::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 3);
@@ -175,15 +176,26 @@ fn test_size_getters() {
 fn test_matching_paper_example() {
     // Paper: house graph, M = {(v_0,v_1), (v_2,v_4)}, weight = 2
     let graph = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]);
-    let problem = MaximumMatching::<_, i32>::unit_weights(graph);
+    let problem = MaximumMatching::<_, i64>::unit_weights(graph);
     // Edges: 0=(0,1), 1=(0,2), 2=(1,3), 3=(2,3), 4=(2,4), 5=(3,4)
     // Select edges 0 and 4
-    let config = vec![1, 0, 0, 0, 1, 0];
-    let result = problem.evaluate(&config);
+    let config = vec![true, false, false, false, true, false];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 2);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 2);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 2);
+}
+#[test]
+fn create_spec_uses_edge_weights_and_defaults_to_one() {
+    let problem = MaximumMatching::try_from(MaximumMatchingCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+        edge_weights: None,
+    })
+    .unwrap();
+    assert_eq!(problem.weights(), vec![1]);
+    assert_eq!(MaximumMatchingCreateSpec::FIELDS[2].name, "edge_weights");
 }
diff --git a/src/unit_tests/models/graph/min_max_multicenter.rs b/src/unit_tests/models/graph/min_max_multicenter.rs
index c50d605d2..8db1f88fa 100644
--- a/src/unit_tests/models/graph/min_max_multicenter.rs
+++ b/src/unit_tests/models/graph/min_max_multicenter.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -7,12 +8,12 @@ use crate::types::Min;
 /// Helper: build the canonical example instance.
 /// 6 vertices, 7 edges [{0,1},{1,2},{2,3},{3,4},{4,5},{0,5},{1,4}],
 /// unit weights/lengths, K=2.
-fn example_instance() -> MinMaxMulticenter<SimpleGraph, i32> {
+fn example_instance() -> MinMaxMulticenter<SimpleGraph, i64> {
     let graph = SimpleGraph::new(
         6,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (0, 5), (1, 4)],
     );
-    MinMaxMulticenter::new(graph, vec![1i32; 6], vec![1i32; 7], 2)
+    MinMaxMulticenter::new(graph, vec![1i64; 6], vec![1i64; 7], 2)
 }
 
 #[test]
@@ -23,7 +24,7 @@ fn test_minmaxmulticenter_basic() {
     assert_eq!(problem.k(), 2);
     assert_eq!(problem.vertex_weights(), &[1, 1, 1, 1, 1, 1]);
     assert_eq!(problem.edge_lengths(), &[1, 1, 1, 1, 1, 1, 1]);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 7);
     assert_eq!(problem.num_centers(), 2);
@@ -35,14 +36,24 @@ fn test_minmaxmulticenter_evaluate_valid() {
     // Centers at vertices 1 and 4:
     // Distances: d(0)=1, d(1)=0, d(2)=1, d(3)=1, d(4)=0, d(5)=1
     // Max weighted distance = 1*1 = 1
-    assert_eq!(problem.evaluate(&[0, 1, 0, 0, 1, 0]), Min(Some(1)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, true, false, false, true, false])
+            .unwrap(),
+        Min(Some(1))
+    );
 }
 
 #[test]
 fn test_minmaxmulticenter_evaluate_invalid_count() {
     let problem = example_instance();
     // 3 centers selected when K=2
-    assert_eq!(problem.evaluate(&[1, 1, 1, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, false, false, false])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -51,19 +62,32 @@ fn test_minmaxmulticenter_evaluate_suboptimal() {
     // Centers at 0 and 5 (adjacent via edge {0,5}):
     // Distances: d(0)=0, d(1)=1, d(2)=2, d(3)=2, d(4)=1, d(5)=0
     // Max weighted distance = 1*2 = 2
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0, 0, 1]), Min(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, false, false, true])
+            .unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
 fn test_minmaxmulticenter_evaluate_no_centers() {
     let problem = example_instance();
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, false, false, false, false, false])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_minmaxmulticenter_evaluate_wrong_config_length() {
     let problem = example_instance();
-    assert_eq!(problem.evaluate(&[0, 1, 0, 0, 0, 0, 1]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![false, true, false, false, false, false, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -71,7 +95,7 @@ fn test_minmaxmulticenter_serialization() {
     let problem = example_instance();
 
     let json = serde_json::to_string(&problem).unwrap();
-    let deserialized: MinMaxMulticenter<SimpleGraph, i32> = serde_json::from_str(&json).unwrap();
+    let deserialized: MinMaxMulticenter<SimpleGraph, i64> = serde_json::from_str(&json).unwrap();
 
     assert_eq!(deserialized.graph().num_vertices(), 6);
     assert_eq!(deserialized.graph().num_edges(), 7);
@@ -80,8 +104,11 @@ fn test_minmaxmulticenter_serialization() {
     assert_eq!(deserialized.k(), 2);
 
     // Verify evaluation produces same results
-    let config = vec![0, 1, 0, 0, 1, 0];
-    assert_eq!(problem.evaluate(&config), deserialized.evaluate(&config));
+    let config = vec![false, true, false, false, true, false];
+    assert_eq!(
+        problem.evaluate(&config).unwrap(),
+        deserialized.evaluate(&config).unwrap()
+    );
 }
 
 #[test]
@@ -89,116 +116,165 @@ fn test_minmaxmulticenter_solver() {
     let problem = example_instance();
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
 
     // The optimal witness should give min-max distance of 1
     assert!(witness.is_some());
     let witness = witness.unwrap();
-    assert_eq!(problem.evaluate(&witness), Min(Some(1)));
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(1)));
 }
 
 #[test]
 fn test_minmaxmulticenter_disconnected() {
     // Two disconnected components: 0-1 and 2-3, K=1
     let graph = SimpleGraph::new(4, vec![(0, 1), (2, 3)]);
-    let problem = MinMaxMulticenter::new(graph, vec![1i32; 4], vec![1i32; 2], 1);
+    let problem = MinMaxMulticenter::new(graph, vec![1i64; 4], vec![1i64; 2], 1);
 
     // Center at 0: vertices 2 and 3 are unreachable -> None
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false, false]).unwrap(),
+        Min(None)
+    );
 
     // With K=2, centers at {0, 2}: all reachable, max distance = 1
     let graph2 = SimpleGraph::new(4, vec![(0, 1), (2, 3)]);
-    let problem2 = MinMaxMulticenter::new(graph2, vec![1i32; 4], vec![1i32; 2], 2);
-    assert_eq!(problem2.evaluate(&[1, 0, 1, 0]), Min(Some(1)));
+    let problem2 = MinMaxMulticenter::new(graph2, vec![1i64; 4], vec![1i64; 2], 2);
+    assert_eq!(
+        problem2.evaluate(&vec![true, false, true, false]).unwrap(),
+        Min(Some(1))
+    );
 }
 
 #[test]
 fn test_minmaxmulticenter_weighted() {
     // Path: 0-1-2, vertex weights = [3, 1, 2], edge lengths = [1, 1], K=1
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinMaxMulticenter::new(graph, vec![3i32, 1, 2], vec![1i32; 2], 1);
+    let problem = MinMaxMulticenter::new(graph, vec![3i64, 1, 2], vec![1i64; 2], 1);
 
     // Center at 1: d(0)=1, d(1)=0, d(2)=1
     // w(0)*d(0) = 3*1 = 3, w(1)*d(1) = 0, w(2)*d(2) = 2*1 = 2
     // max = 3
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Min(Some(3)));
+    assert_eq!(
+        problem.evaluate(&vec![false, true, false]).unwrap(),
+        Min(Some(3))
+    );
 
     // Center at 0: d(0)=0, d(1)=1, d(2)=2
     // w(0)*d(0) = 0, w(1)*d(1) = 1, w(2)*d(2) = 4
     // max = 4
-    assert_eq!(problem.evaluate(&[1, 0, 0]), Min(Some(4)));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false]).unwrap(),
+        Min(Some(4))
+    );
 }
 
 #[test]
 fn test_minmaxmulticenter_single_vertex() {
     let graph = SimpleGraph::new(1, vec![]);
-    let problem = MinMaxMulticenter::new(graph, vec![5i32], vec![], 1);
+    let problem = MinMaxMulticenter::new(graph, vec![5i64], vec![], 1);
     // Only vertex is the center, max weighted distance = 0
-    assert_eq!(problem.evaluate(&[1]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![true]).unwrap(), Min(Some(0)));
 }
 
 #[test]
 fn test_minmaxmulticenter_all_centers() {
     // K = num_vertices: all vertices are centers, max distance = 0
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinMaxMulticenter::new(graph, vec![1i32; 3], vec![1i32; 2], 3);
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Min(Some(0)));
+    let problem = MinMaxMulticenter::new(graph, vec![1i64; 3], vec![1i64; 2], 3);
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true]).unwrap(),
+        Min(Some(0))
+    );
 }
 
 #[test]
 fn test_minmaxmulticenter_nonunit_edge_lengths() {
     // Path: 0-1-2, unit vertex weights, edge lengths [1, 3], K=1
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinMaxMulticenter::new(graph, vec![1i32; 3], vec![1i32, 3], 1);
+    let problem = MinMaxMulticenter::new(graph, vec![1i64; 3], vec![1i64, 3], 1);
 
     // Center at 0: d(0)=0, d(1)=1, d(2)=1+3=4; max=4
-    assert_eq!(problem.evaluate(&[1, 0, 0]), Min(Some(4)));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false]).unwrap(),
+        Min(Some(4))
+    );
 
     // Center at 1: d(0)=1, d(1)=0, d(2)=3; max=3
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Min(Some(3)));
+    assert_eq!(
+        problem.evaluate(&vec![false, true, false]).unwrap(),
+        Min(Some(3))
+    );
 
     // Center at 2: d(0)=4, d(1)=3, d(2)=0; max=4
-    assert_eq!(problem.evaluate(&[0, 0, 1]), Min(Some(4)));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, true]).unwrap(),
+        Min(Some(4))
+    );
 }
 
 #[test]
 #[should_panic(expected = "vertex_weights length must match num_vertices")]
 fn test_minmaxmulticenter_wrong_vertex_weights_len() {
     let graph = SimpleGraph::new(3, vec![(0, 1)]);
-    MinMaxMulticenter::new(graph, vec![1i32; 2], vec![1i32; 1], 1);
+    MinMaxMulticenter::new(graph, vec![1i64; 2], vec![1i64; 1], 1);
 }
 
 #[test]
 #[should_panic(expected = "edge_lengths length must match num_edges")]
 fn test_minmaxmulticenter_wrong_edge_lengths_len() {
     let graph = SimpleGraph::new(3, vec![(0, 1)]);
-    MinMaxMulticenter::new(graph, vec![1i32; 3], vec![1i32; 2], 1);
+    MinMaxMulticenter::new(graph, vec![1i64; 3], vec![1i64; 2], 1);
 }
 
 #[test]
 #[should_panic(expected = "k must be positive")]
 fn test_minmaxmulticenter_k_zero() {
     let graph = SimpleGraph::new(3, vec![(0, 1)]);
-    MinMaxMulticenter::new(graph, vec![1i32; 3], vec![1i32; 1], 0);
+    MinMaxMulticenter::new(graph, vec![1i64; 3], vec![1i64; 1], 0);
 }
 
 #[test]
 #[should_panic(expected = "k must not exceed num_vertices")]
 fn test_minmaxmulticenter_k_too_large() {
     let graph = SimpleGraph::new(3, vec![(0, 1)]);
-    MinMaxMulticenter::new(graph, vec![1i32; 3], vec![1i32; 1], 4);
+    MinMaxMulticenter::new(graph, vec![1i64; 3], vec![1i64; 1], 4);
 }
 
 #[test]
 #[should_panic(expected = "vertex_weights must be non-negative")]
 fn test_minmaxmulticenter_negative_vertex_weight() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    MinMaxMulticenter::new(graph, vec![1i32, -1, 1], vec![1i32; 2], 1);
+    MinMaxMulticenter::new(graph, vec![1i64, -1, 1], vec![1i64; 2], 1);
 }
 
 #[test]
 #[should_panic(expected = "edge_lengths must be non-negative")]
 fn test_minmaxmulticenter_negative_edge_length() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    MinMaxMulticenter::new(graph, vec![1i32; 3], vec![1i32, -1], 1);
+    MinMaxMulticenter::new(graph, vec![1i64; 3], vec![1i64, -1], 1);
+}
+#[test]
+fn create_specs_map_weight_inputs_for_both_variants() {
+    let weighted = MinMaxMulticenter::try_from(MinMaxMulticenterI64CreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+        weights: None,
+        edge_weights: Some(vec![2]),
+        k: 1,
+    })
+    .unwrap();
+    let unit = MinMaxMulticenter::try_from(MinMaxMulticenterOneCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+        k: 1,
+    })
+    .unwrap();
+    assert_eq!(weighted.vertex_weights(), &[1, 1]);
+    assert_eq!(weighted.edge_lengths(), &[2]);
+    assert_eq!(unit.vertex_weights(), &[One, One]);
+    assert_eq!(MinMaxMulticenterI64CreateSpec::FIELDS[2].name, "weights");
+    assert_eq!(
+        MinMaxMulticenterI64CreateSpec::FIELDS[3].name,
+        "edge_weights"
+    );
 }
diff --git a/src/unit_tests/models/graph/minimum_capacitated_spanning_tree.rs b/src/unit_tests/models/graph/minimum_capacitated_spanning_tree.rs
index 5c74e8626..3576d79b5 100644
--- a/src/unit_tests/models/graph/minimum_capacitated_spanning_tree.rs
+++ b/src/unit_tests/models/graph/minimum_capacitated_spanning_tree.rs
@@ -1,10 +1,24 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_edge_weights() {
+    let p = MinimumCapacitatedSpanningTree::try_from(MinimumCapacitatedSpanningTreeCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        weights: None,
+        root: 0,
+        requirements: vec![0, 1],
+        capacity: 1,
+    })
+    .unwrap();
+    assert_eq!(p.weights(), &[1]);
+}
 use crate::{solvers::BruteForce, topology::SimpleGraph, traits::Problem};
 
 /// 5-vertex instance from issue #901.
 /// Edges: (0,1,2), (0,2,1), (0,3,4), (1,2,3), (1,4,1), (2,3,2), (2,4,3), (3,4,1)
 /// Root=0, capacity=3, all requirements=1
-fn example_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
+fn example_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i64> {
     let graph = SimpleGraph::new(
         5,
         vec![
@@ -25,7 +39,7 @@ fn example_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
 }
 
 /// Tight capacity instance: capacity=2, so each subtree can hold at most 2 vertices.
-fn tight_capacity_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
+fn tight_capacity_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i64> {
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (2, 3)]);
     let weights = vec![1, 2, 3, 1, 1];
     let requirements = vec![0, 1, 1, 1];
@@ -41,7 +55,7 @@ fn test_creation() {
     assert_eq!(problem.root(), 0);
     assert_eq!(problem.requirements(), &[0, 1, 1, 1, 1]);
     assert_eq!(*problem.capacity(), 3);
-    assert_eq!(problem.dims().len(), 8);
+    assert_eq!(problem.dimensions().len(), 8);
     assert!(problem.is_weighted());
 }
 
@@ -70,7 +84,7 @@ fn test_rejects_invalid_root() {
 #[should_panic(expected = "graph must have at least 2 vertices")]
 fn test_rejects_single_vertex() {
     let graph = SimpleGraph::new(1, vec![]);
-    let _ = MinimumCapacitatedSpanningTree::<SimpleGraph, i32>::new(graph, vec![], 0, vec![0], 3);
+    let _ = MinimumCapacitatedSpanningTree::<SimpleGraph, i64>::new(graph, vec![], 0, vec![0], 3);
 }
 
 #[test]
@@ -78,16 +92,16 @@ fn test_evaluate_optimal() {
     let problem = example_instance();
     // Optimal: edges {(0,1),(0,2),(1,4),(3,4)} = indices {0,1,4,7}
     // Weight = 2+1+1+1 = 5
-    let config = vec![1, 1, 0, 0, 1, 0, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(5)));
+    let config = vec![true, true, false, false, true, false, false, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(5)));
 }
 
 #[test]
 fn test_evaluate_infeasible_not_spanning() {
     let problem = example_instance();
     // Only 3 edges selected (not n-1=4)
-    let config = vec![1, 1, 0, 0, 1, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![true, true, false, false, true, false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -95,27 +109,27 @@ fn test_evaluate_infeasible_capacity_violated() {
     let problem = example_instance();
     // Tree: (0,3),(3,4),(3,2),(2,1) = indices {2,7,5,3}
     // Subtree at 3: {3,4,2,1} req = 4 > 3 (capacity)
-    let config = vec![0, 0, 1, 1, 0, 1, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![false, false, true, true, false, true, false, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_evaluate_empty() {
     let problem = example_instance();
-    let config = vec![0; 8];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![false; 8];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_brute_force() {
     let problem = example_instance();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
-    let optimal_value = problem.evaluate(&solutions[0]);
+    let optimal_value = problem.evaluate(&solutions[0]).unwrap();
     assert_eq!(optimal_value, Min(Some(5)));
     for sol in &solutions {
-        assert_eq!(problem.evaluate(sol), Min(Some(5)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Min(Some(5)));
     }
 }
 
@@ -123,11 +137,11 @@ fn test_brute_force() {
 fn test_tight_capacity() {
     let problem = tight_capacity_instance();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     // With capacity=2, star from root is valid: each subtree has 1 vertex
     for sol in &solutions {
-        assert!(problem.is_valid_solution(sol));
+        assert!(problem.is_valid_solution(sol).unwrap());
     }
 }
 
@@ -135,18 +149,22 @@ fn test_tight_capacity() {
 fn test_is_valid_solution() {
     let problem = example_instance();
     // Valid
-    assert!(problem.is_valid_solution(&[1, 1, 0, 0, 1, 0, 0, 1]));
+    assert!(problem
+        .is_valid_solution(&[true, true, false, false, true, false, false, true])
+        .unwrap());
     // Invalid: not enough edges
-    assert!(!problem.is_valid_solution(&[1, 1, 0, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .is_valid_solution(&[true, true, false, false, false, false, false, false])
+        .unwrap());
     // Invalid: wrong length
-    assert!(!problem.is_valid_solution(&[1, 1, 0]));
+    assert!(!problem.is_valid_solution(&[true, true, false]).unwrap());
 }
 
 #[test]
 fn test_serialization() {
     let problem = example_instance();
     let json = serde_json::to_value(&problem).unwrap();
-    let deserialized: MinimumCapacitatedSpanningTree<SimpleGraph, i32> =
+    let deserialized: MinimumCapacitatedSpanningTree<SimpleGraph, i64> =
         serde_json::from_value(json).unwrap();
     assert_eq!(deserialized.num_vertices(), 5);
     assert_eq!(deserialized.num_edges(), 8);
@@ -156,7 +174,7 @@ fn test_serialization() {
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = example_instance();
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_edges(), 8);
@@ -169,6 +187,6 @@ fn test_set_weights() {
     problem.set_weights(vec![1; 8]);
     assert_eq!(problem.weights(), &[1; 8]);
     // Same optimal tree now has cost 4
-    let config = vec![1, 1, 0, 0, 1, 0, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(4)));
+    let config = vec![true, true, false, false, true, false, false, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(4)));
 }
diff --git a/src/unit_tests/models/graph/minimum_cost_circulation.rs b/src/unit_tests/models/graph/minimum_cost_circulation.rs
index 4841b88b5..c22563730 100644
--- a/src/unit_tests/models/graph/minimum_cost_circulation.rs
+++ b/src/unit_tests/models/graph/minimum_cost_circulation.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -31,7 +32,7 @@ fn test_minimum_cost_circulation_creation() {
     assert_eq!(problem.num_arcs(), 4);
     assert_eq!(problem.capacities(), &[2, 2, 1, 1]);
     assert_eq!(problem.costs(), &[2, -3, 1, -4]);
-    assert_eq!(problem.dims(), vec![3, 3, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![3, 3, 2, 2]);
     assert_eq!(
         <MinimumCostCirculation as Problem>::NAME,
         "MinimumCostCirculation"
@@ -41,18 +42,18 @@ fn test_minimum_cost_circulation_creation() {
 #[test]
 fn test_minimum_cost_circulation_evaluate_optimal() {
     let problem = canonical_instance();
-    let config = vec![2_usize, 2, 1, 1];
-    assert!(problem.is_feasible(&config));
-    assert_eq!(problem.total_cost(&config), -5);
-    assert_eq!(problem.evaluate(&config), Min(Some(-5)));
+    let config = vec![2, 2, 1, 1];
+    assert!(problem.is_feasible(&config).unwrap());
+    assert_eq!(problem.total_cost(&config).unwrap(), -5);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(-5)));
 }
 
 #[test]
 fn test_minimum_cost_circulation_evaluate_zero_circulation() {
     let problem = canonical_instance();
-    let config = vec![0_usize, 0, 0, 0];
-    assert!(problem.is_feasible(&config));
-    assert_eq!(problem.evaluate(&config), Min(Some(0)));
+    let config = vec![0, 0, 0, 0];
+    assert!(problem.is_feasible(&config).unwrap());
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -60,9 +61,9 @@ fn test_minimum_cost_circulation_evaluate_cycle_a_only() {
     let problem = canonical_instance();
     // Push cycle A to capacity, leave cycle B empty: [2, 2, 0, 0]
     // cost = 2*2 + 2*(-3) + 0 + 0 = -2
-    let config = vec![2_usize, 2, 0, 0];
-    assert!(problem.is_feasible(&config));
-    assert_eq!(problem.evaluate(&config), Min(Some(-2)));
+    let config = vec![2, 2, 0, 0];
+    assert!(problem.is_feasible(&config).unwrap());
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(-2)));
 }
 
 #[test]
@@ -70,17 +71,17 @@ fn test_minimum_cost_circulation_evaluate_cycle_b_only() {
     let problem = canonical_instance();
     // Push cycle B to capacity, leave cycle A empty: [0, 0, 1, 1]
     // cost = 0 + 0 + 1 + (-4) = -3
-    let config = vec![0_usize, 0, 1, 1];
-    assert!(problem.is_feasible(&config));
-    assert_eq!(problem.evaluate(&config), Min(Some(-3)));
+    let config = vec![0, 0, 1, 1];
+    assert!(problem.is_feasible(&config).unwrap());
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(-3)));
 }
 
 #[test]
 fn test_minimum_cost_circulation_evaluate_infeasible_capacity() {
     let problem = canonical_instance();
     // Arc 0 has capacity 2, but g(0) = 3 violates it.
-    let config = vec![3_usize, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![3, 0, 0, 0];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -88,16 +89,25 @@ fn test_minimum_cost_circulation_evaluate_infeasible_conservation() {
     let problem = canonical_instance();
     // [2, 1, 0, 0]: at vertex 1, inflow = 2 (from arc 0), outflow = 1
     // (via arc 1); balance != 0, so infeasible.
-    let config = vec![2_usize, 1, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![2, 1, 0, 0];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_cost_circulation_evaluate_wrong_config_length() {
     let problem = canonical_instance();
-    assert_eq!(problem.evaluate(&[0; 3]), Min(None));
-    assert_eq!(problem.evaluate(&[0; 5]), Min(None));
-    assert_eq!(problem.evaluate(&[]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0; 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0; 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -105,9 +115,10 @@ fn test_minimum_cost_circulation_solver_canonical() {
     let problem = canonical_instance();
     let solver = BruteForce::new();
     let witness = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("canonical instance must be feasible");
-    assert_eq!(problem.total_cost(&witness), -5);
+    assert_eq!(problem.total_cost(&witness).unwrap(), -5);
     // The unique optimum pushes both cycles to capacity.
     assert_eq!(witness, vec![2, 2, 1, 1]);
 }
@@ -124,12 +135,13 @@ fn test_minimum_cost_circulation_negative_cycle_beats_zero() {
     );
     let solver = BruteForce::new();
     let witness = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("instance must be feasible");
-    assert_eq!(problem.total_cost(&witness), -2);
+    assert_eq!(problem.total_cost(&witness).unwrap(), -2);
     assert_eq!(witness, vec![1, 1]);
     // And zero is feasible but strictly worse.
-    assert_eq!(problem.evaluate(&[0, 0]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![0, 0]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -146,11 +158,12 @@ fn test_minimum_cost_circulation_issue_example_1030() {
     );
     let solver = BruteForce::new();
     let witness = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("instance must be feasible");
     assert_eq!(witness, vec![1, 1]);
-    assert_eq!(problem.total_cost(&witness), -2);
-    assert_eq!(problem.evaluate(&[0, 0]), Min(Some(0)));
+    assert_eq!(problem.total_cost(&witness).unwrap(), -2);
+    assert_eq!(problem.evaluate(&vec![0, 0]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -164,7 +177,7 @@ fn test_minimum_cost_circulation_serialization() {
     assert_eq!(deserialized.costs(), &[2, -3, 1, -4]);
     // Optimal config evaluates identically after roundtrip.
     assert_eq!(
-        deserialized.evaluate(&[2, 2, 1, 1]),
-        problem.evaluate(&[2, 2, 1, 1])
+        deserialized.evaluate(&vec![2, 2, 1, 1]).unwrap(),
+        problem.evaluate(&vec![2, 2, 1, 1]).unwrap()
     );
 }
diff --git a/src/unit_tests/models/graph/minimum_cost_maximum_flow.rs b/src/unit_tests/models/graph/minimum_cost_maximum_flow.rs
index 7cfeaaf0d..5c56ee644 100644
--- a/src/unit_tests/models/graph/minimum_cost_maximum_flow.rs
+++ b/src/unit_tests/models/graph/minimum_cost_maximum_flow.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -57,7 +58,7 @@ fn test_minimum_cost_maximum_flow_creation() {
     assert_eq!(problem.sink(), 3);
     assert_eq!(problem.capacities(), &[2, 1, 1, 1, 2]);
     assert_eq!(problem.costs(), &[1, 0, 0, 1, 2]);
-    assert_eq!(problem.dims(), vec![3, 2, 2, 2, 3]);
+    assert_eq!(problem.dimensions(), vec![3, 2, 2, 2, 3]);
     assert_eq!(
         <MinimumCostMaximumFlow as Problem>::NAME,
         "MinimumCostMaximumFlow"
@@ -67,10 +68,10 @@ fn test_minimum_cost_maximum_flow_creation() {
 #[test]
 fn test_minimum_cost_maximum_flow_evaluate_optimal() {
     let problem = canonical_instance();
-    let config = vec![2_usize, 1, 1, 1, 2];
-    assert_eq!(problem.flow_value(&config), 3);
-    assert_eq!(problem.total_cost(&config), 7);
-    let value = problem.evaluate(&config);
+    let config = vec![2, 1, 1, 1, 2];
+    assert_eq!(problem.flow_value(&config).unwrap(), 3);
+    assert_eq!(problem.total_cost(&config).unwrap(), 7);
+    let value = problem.evaluate(&config).unwrap();
     match value {
         Min(Some(v)) => {
             // bound = sum(capacities) = 7, value = 3, cost = 7,
@@ -91,13 +92,13 @@ fn test_minimum_cost_maximum_flow_evaluate_suboptimal() {
     //   plus (1,2) carries 1, but that needs balance... try [1,1,1,0,2]:
     //   balance 0 = -2, balance 1 = 1 - 1 - 0 = 0, balance 2 = 1+1-2=0,
     //   balance 3 = 0 + 2 = 2. So value = 2, cost = 1+0+0+0+4 = 5.
-    let suboptimal = vec![1_usize, 1, 1, 0, 2];
-    assert!(problem.is_feasible(&suboptimal));
-    assert_eq!(problem.flow_value(&suboptimal), 2);
-    assert_eq!(problem.total_cost(&suboptimal), 5);
-    let optimal = vec![2_usize, 1, 1, 1, 2];
-    let opt_v = problem.evaluate(&optimal);
-    let sub_v = problem.evaluate(&suboptimal);
+    let suboptimal = vec![1, 1, 1, 0, 2];
+    assert!(problem.is_feasible(&suboptimal).unwrap());
+    assert_eq!(problem.flow_value(&suboptimal).unwrap(), 2);
+    assert_eq!(problem.total_cost(&suboptimal).unwrap(), 5);
+    let optimal = vec![2, 1, 1, 1, 2];
+    let opt_v = problem.evaluate(&optimal).unwrap();
+    let sub_v = problem.evaluate(&suboptimal).unwrap();
     // Lower (better) scalar score wins under Min.
     assert!(matches!(opt_v, Min(Some(_))));
     assert!(matches!(sub_v, Min(Some(_))));
@@ -111,24 +112,33 @@ fn test_minimum_cost_maximum_flow_evaluate_suboptimal() {
 fn test_minimum_cost_maximum_flow_evaluate_infeasible_capacity() {
     let problem = canonical_instance();
     // Arc 0 has capacity 2, but f(0) = 3 violates it.
-    let config = vec![3_usize, 1, 1, 1, 2];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![3, 1, 1, 1, 2];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_cost_maximum_flow_evaluate_infeasible_conservation() {
     let problem = canonical_instance();
     // Vertex 1: in = 2, out = 0+1 = 1; violates conservation at v=1.
-    let config = vec![2_usize, 0, 0, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![2, 0, 0, 1, 0];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_cost_maximum_flow_evaluate_wrong_config_length() {
     let problem = canonical_instance();
-    assert_eq!(problem.evaluate(&[0; 4]), Min(None));
-    assert_eq!(problem.evaluate(&[0; 6]), Min(None));
-    assert_eq!(problem.evaluate(&[]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0; 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0; 6]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -136,10 +146,11 @@ fn test_minimum_cost_maximum_flow_solver_canonical() {
     let problem = canonical_instance();
     let solver = BruteForce::new();
     let witness = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("canonical instance must be feasible");
-    assert_eq!(problem.flow_value(&witness), 3);
-    assert_eq!(problem.total_cost(&witness), 7);
+    assert_eq!(problem.flow_value(&witness).unwrap(), 3);
+    assert_eq!(problem.total_cost(&witness).unwrap(), 7);
 }
 
 #[test]
@@ -150,10 +161,11 @@ fn test_minimum_cost_maximum_flow_lex_tiebreaker() {
     let problem = lex_tiebreaker_instance();
     let solver = BruteForce::new();
     let witness = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("lex instance must be feasible");
-    assert_eq!(problem.flow_value(&witness), 1);
-    assert_eq!(problem.total_cost(&witness), 1);
+    assert_eq!(problem.flow_value(&witness).unwrap(), 1);
+    assert_eq!(problem.total_cost(&witness).unwrap(), 1);
     // The cheaper path uses arcs 0 (0->1), 1 (1->2), and 3 (2->4).
     assert_eq!(witness, vec![1, 1, 0, 1, 0]);
 }
@@ -171,7 +183,19 @@ fn test_minimum_cost_maximum_flow_serialization() {
     assert_eq!(deserialized.costs(), &[1, 0, 0, 1, 2]);
     // Optimal config evaluates identically after roundtrip.
     assert_eq!(
-        deserialized.evaluate(&[2, 1, 1, 1, 2]),
-        problem.evaluate(&[2, 1, 1, 1, 2])
+        deserialized.evaluate(&vec![2, 1, 1, 1, 2]).unwrap(),
+        problem.evaluate(&vec![2, 1, 1, 1, 2]).unwrap()
     );
 }
+
+#[test]
+fn deserialization_rejects_negative_costs() {
+    let value = serde_json::json!({
+        "graph": {"num_vertices": 2, "arcs": [[0, 1]]},
+        "source": 0,
+        "sink": 1,
+        "capacities": [1],
+        "costs": [-1]
+    });
+    assert!(serde_json::from_value::<MinimumCostMaximumFlow>(value).is_err());
+}
diff --git a/src/unit_tests/models/graph/minimum_covering_by_cliques.rs b/src/unit_tests/models/graph/minimum_covering_by_cliques.rs
index 778a5c494..e2916b241 100644
--- a/src/unit_tests/models/graph/minimum_covering_by_cliques.rs
+++ b/src/unit_tests/models/graph/minimum_covering_by_cliques.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -12,7 +13,7 @@ fn test_minimum_covering_by_cliques_creation() {
     assert_eq!(problem.num_edges(), 3);
     assert_eq!(problem.num_variables(), 3);
     // Each edge can be assigned to one of 3 groups
-    assert_eq!(problem.dims(), vec![3; 3]);
+    assert_eq!(problem.dimensions(), vec![3; 3]);
 }
 
 #[test]
@@ -22,11 +23,11 @@ fn test_minimum_covering_by_cliques_triangle() {
     let problem = MinimumCoveringByCliques::new(graph);
 
     // All edges in group 0 -> valid, 1 clique
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(Some(1)));
+    assert_eq!(problem.evaluate(&vec![0, 0, 0]).unwrap(), Min(Some(1)));
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     assert_eq!(value, Min(Some(1)));
 }
 
@@ -38,14 +39,14 @@ fn test_minimum_covering_by_cliques_path() {
     let problem = MinimumCoveringByCliques::new(graph);
 
     // Both edges in the same group -> invalid (0 and 2 not adjacent)
-    assert_eq!(problem.evaluate(&[0, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 0]).unwrap(), Min(None));
 
     // Two separate groups -> valid, 2 cliques
-    assert_eq!(problem.evaluate(&[0, 1]), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![0, 1]).unwrap(), Min(Some(2)));
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(2)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -56,10 +57,10 @@ fn test_minimum_covering_by_cliques_invalid_group() {
     let problem = MinimumCoveringByCliques::new(graph);
 
     // Edges (0,1) and (2,3) in same group: vertices {0,1,2,3}, not a clique
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 1, 0, 1]).unwrap(), Min(None));
 
     // Each edge in its own group -> valid, 4 cliques
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3]), Min(Some(4)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap(), Min(Some(4)));
 }
 
 #[test]
@@ -67,14 +68,17 @@ fn test_minimum_covering_by_cliques_empty_graph() {
     // No edges: 0 cliques needed
     let graph = SimpleGraph::new(3, vec![]);
     let problem = MinimumCoveringByCliques::new(graph);
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
 fn test_minimum_covering_by_cliques_wrong_length() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MinimumCoveringByCliques::new(graph);
-    assert_eq!(problem.evaluate(&[0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -85,8 +89,8 @@ fn test_minimum_covering_by_cliques_solver() {
     let problem = MinimumCoveringByCliques::new(graph);
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     // Two triangles: {0,1,2} and {0,2,3} cover all 5 edges
     assert_eq!(value, Min(Some(2)));
 }
@@ -126,7 +130,7 @@ fn test_minimum_covering_by_cliques_paper_example() {
 
     // The given optimal config
     let config = vec![0, 0, 1, 1, 0, 2, 2, 3, 3];
-    let result = problem.evaluate(&config);
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 4);
 }
diff --git a/src/unit_tests/models/graph/minimum_cut_into_bounded_sets.rs b/src/unit_tests/models/graph/minimum_cut_into_bounded_sets.rs
index fe40f07b3..84f6d6aab 100644
--- a/src/unit_tests/models/graph/minimum_cut_into_bounded_sets.rs
+++ b/src/unit_tests/models/graph/minimum_cut_into_bounded_sets.rs
@@ -1,13 +1,26 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_edge_weights() {
+    let p = MinimumCutIntoBoundedSets::try_from(MinimumCutIntoBoundedSetsCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        edge_weights: None,
+        source: 0,
+        sink: 1,
+        size_bound: 1,
+    })
+    .unwrap();
+    assert_eq!(p.edge_weights(), &[1]);
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
-use crate::types::{Aggregate, Min};
-use crate::Solver;
+use crate::types::{Min, SolutionAggregate};
 
 /// Build the example instance from issue #228:
 /// 8 vertices, 12 edges, s=0, t=7, B=5
-fn example_instance() -> MinimumCutIntoBoundedSets<SimpleGraph, i32> {
+fn example_instance() -> MinimumCutIntoBoundedSets<SimpleGraph, i64> {
     let graph = SimpleGraph::new(
         8,
         vec![
@@ -37,7 +50,7 @@ fn test_minimumcutintoboundedsets_basic() {
     assert_eq!(problem.source(), 0);
     assert_eq!(problem.sink(), 7);
     assert_eq!(problem.size_bound(), 5);
-    assert_eq!(problem.dims(), vec![2; 8]);
+    assert_eq!(problem.dimensions(), vec![2; 8]);
 }
 
 #[test]
@@ -45,8 +58,8 @@ fn test_minimumcutintoboundedsets_evaluation_valid_partition() {
     let problem = example_instance();
     // V1={0,1,2,3}, V2={4,5,6,7}
     // Cut edges: (2,4)=2, (3,5)=1, (3,6)=3 => cut=6
-    let config = vec![0, 0, 0, 0, 1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(6)));
+    let config = vec![false, false, false, false, true, true, true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -54,24 +67,24 @@ fn test_minimumcutintoboundedsets_evaluation_different_partition() {
     let problem = example_instance();
     // V1={0,1,2}, V2={3,4,5,6,7}
     // Cut edges: (1,3)=4, (2,4)=2 => cut=6
-    let config = vec![0, 0, 0, 1, 1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(6)));
+    let config = vec![false, false, false, true, true, true, true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(6)));
 }
 
 #[test]
 fn test_minimumcutintoboundedsets_wrong_source() {
     let problem = example_instance();
     // Source (0) not in V1 (config[0]=1 instead of 0)
-    let config = vec![1, 0, 0, 0, 1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![true, false, false, false, true, true, true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimumcutintoboundedsets_wrong_sink() {
     let problem = example_instance();
     // Sink (7) not in V2 (config[7]=0 instead of 1)
-    let config = vec![0, 0, 0, 0, 1, 1, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![false, false, false, false, true, true, true, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -97,22 +110,25 @@ fn test_minimumcutintoboundedsets_size_bound_violated() {
     let edge_weights = vec![2, 3, 1, 4, 2, 1, 3, 2, 1, 2, 3, 1];
     let problem = MinimumCutIntoBoundedSets::new(graph, edge_weights, 0, 7, 3);
     // V1={0,1,2,3} has 4 > B=3
-    let config = vec![0, 0, 0, 0, 1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![false, false, false, false, true, true, true, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimumcutintoboundedsets_wrong_config_length() {
     let problem = example_instance();
-    let config = vec![0, 0, 1]; // too short
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![false, false, true]; // too short
+    assert!(matches!(
+        problem.evaluate(&config),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimumcutintoboundedsets_serialization() {
     let problem = example_instance();
     let json = serde_json::to_string(&problem).unwrap();
-    let deserialized: MinimumCutIntoBoundedSets<SimpleGraph, i32> =
+    let deserialized: MinimumCutIntoBoundedSets<SimpleGraph, i64> =
         serde_json::from_str(&json).unwrap();
     assert_eq!(deserialized.num_vertices(), 8);
     assert_eq!(deserialized.num_edges(), 12);
@@ -120,20 +136,21 @@ fn test_minimumcutintoboundedsets_serialization() {
     assert_eq!(deserialized.sink(), 7);
     assert_eq!(deserialized.size_bound(), 5);
     // Verify same evaluation
-    let config = vec![0, 0, 0, 0, 1, 1, 1, 1];
-    assert_eq!(deserialized.evaluate(&config), Min(Some(6)));
+    let config = vec![false, false, false, false, true, true, true, true];
+    assert_eq!(deserialized.evaluate(&config).unwrap(), Min(Some(6)));
 }
 
 #[test]
 fn test_minimumcutintoboundedsets_solver() {
     let problem = example_instance();
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(6)));
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
     let sol = witness.unwrap();
-    assert!(problem.evaluate(&sol).0.is_some());
+    assert!(problem.evaluate(&sol).unwrap().0.is_some());
 }
 
 #[test]
@@ -142,9 +159,15 @@ fn test_minimumcutintoboundedsets_small_graph() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MinimumCutIntoBoundedSets::new(graph, vec![1, 1], 0, 2, 2);
     // V1={0,1}, V2={2}: cut edge (1,2)=1
-    assert_eq!(problem.evaluate(&[0, 0, 1]), Min(Some(1)));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, true]).unwrap(),
+        Min(Some(1))
+    );
     // V1={0}, V2={1,2}: cut edge (0,1)=1
-    assert_eq!(problem.evaluate(&[0, 1, 1]), Min(Some(1)));
+    assert_eq!(
+        problem.evaluate(&vec![false, true, true]).unwrap(),
+        Min(Some(1))
+    );
 }
 
 #[test]
@@ -164,13 +187,14 @@ fn test_minimumcutintoboundedsets_graph_accessor() {
 
 #[test]
 fn test_minimumcutintoboundedsets_variant() {
-    let variant = MinimumCutIntoBoundedSets::<SimpleGraph, i32>::variant();
+    let variant = MinimumCutIntoBoundedSets::<SimpleGraph, i64>::variant();
     assert_eq!(variant.len(), 2);
     assert!(variant.iter().any(|(k, _)| *k == "graph"));
     assert!(variant.iter().any(|(k, _)| *k == "weight"));
 }
 
 #[test]
-fn test_minimumcutintoboundedsets_supports_witnesses() {
-    assert!(<MinimumCutIntoBoundedSets<SimpleGraph, i32> as Problem>::Value::supports_witnesses());
+fn test_minimumcutintoboundedsets_selects_optimal_solutions() {
+    type Value = <MinimumCutIntoBoundedSets<SimpleGraph, i64> as Problem>::Value;
+    assert!(Value::contributes_to_solution(&Min(Some(3)), &Min(Some(3))));
 }
diff --git a/src/unit_tests/models/graph/minimum_dominating_set.rs b/src/unit_tests/models/graph/minimum_dominating_set.rs
index a1665a701..5edd12d7b 100644
--- a/src/unit_tests/models/graph/minimum_dominating_set.rs
+++ b/src/unit_tests/models/graph/minimum_dominating_set.rs
@@ -1,4 +1,18 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_weight_count_mismatch() {
+    assert_eq!(
+        MinimumDominatingSetCreateSpec::<i64>::FIELDS[1].name,
+        "weights"
+    );
+    let result = MinimumDominatingSet::try_from(MinimumDominatingSetCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        weights: vec![1],
+    });
+    assert!(result.is_err());
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -8,12 +22,12 @@ include!("../../jl_helpers.rs");
 fn test_dominating_set_creation() {
     let problem = MinimumDominatingSet::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 3);
     assert_eq!(problem.num_variables(), 4);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
 }
 
 #[test]
@@ -26,7 +40,7 @@ fn test_dominating_set_with_weights() {
 fn test_neighbors() {
     let problem = MinimumDominatingSet::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let nbrs = problem.neighbors(0);
     assert!(nbrs.contains(&1));
@@ -37,7 +51,7 @@ fn test_neighbors() {
 #[test]
 fn test_closed_neighborhood() {
     let problem =
-        MinimumDominatingSet::new(SimpleGraph::new(4, vec![(0, 1), (0, 2)]), vec![1i32; 4]);
+        MinimumDominatingSet::new(SimpleGraph::new(4, vec![(0, 1), (0, 2)]), vec![1i64; 4]);
     let cn = problem.closed_neighborhood(0);
     assert!(cn.contains(&0));
     assert!(cn.contains(&1));
@@ -62,15 +76,15 @@ fn test_is_dominating_set_function() {
 #[test]
 fn test_isolated_vertex() {
     // Isolated vertex must be in dominating set
-    let problem = MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // Vertex 2 is isolated, must be selected
     for sol in &solutions {
-        assert_eq!(sol[2], 1);
+        assert!(sol[2]);
         // Verify it's a valid dominating set
-        assert!(Problem::evaluate(&problem, sol).is_valid());
+        assert!(Problem::evaluate(&problem, sol).unwrap().is_valid());
     }
 }
 
@@ -90,7 +104,7 @@ fn test_from_graph() {
 
 #[test]
 fn test_graph_accessor() {
-    let problem = MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     assert_eq!(problem.graph().num_vertices(), 3);
     assert_eq!(problem.graph().num_edges(), 1);
 }
@@ -104,7 +118,7 @@ fn test_weights() {
 #[test]
 fn test_edges() {
     let problem =
-        MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+        MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     let edges = problem.graph().edges();
     assert_eq!(edges.len(), 2);
 }
@@ -112,7 +126,7 @@ fn test_edges() {
 #[test]
 fn test_has_edge() {
     let problem =
-        MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+        MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     assert!(problem.graph().has_edge(0, 1));
     assert!(problem.graph().has_edge(1, 0)); // Undirected
     assert!(problem.graph().has_edge(1, 2));
@@ -126,10 +140,10 @@ fn test_jl_parity_evaluation() {
     for instance in data["instances"].as_array().unwrap() {
         let nv = instance["instance"]["num_vertices"].as_u64().unwrap() as usize;
         let edges = jl_parse_edges(&instance["instance"]);
-        let problem = MinimumDominatingSet::new(SimpleGraph::new(nv, edges), vec![1i32; nv]);
+        let problem = MinimumDominatingSet::new(SimpleGraph::new(nv, edges), vec![1i64; nv]);
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config);
+            let config = jl_parse_bool_config(&eval["config"]);
+            let result = problem.evaluate(&config).unwrap();
             let jl_valid = eval["is_valid"].as_bool().unwrap();
             assert_eq!(
                 result.is_valid(),
@@ -138,7 +152,7 @@ fn test_jl_parity_evaluation() {
                 config
             );
             if jl_valid {
-                let jl_size = eval["size"].as_i64().unwrap() as i32;
+                let jl_size = eval["size"].as_i64().unwrap();
                 assert_eq!(
                     result.unwrap(),
                     jl_size,
@@ -147,9 +161,9 @@ fn test_jl_parity_evaluation() {
                 );
             }
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best: HashSet<Vec<bool>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "DS best solutions mismatch");
     }
 }
@@ -158,17 +172,17 @@ fn test_jl_parity_evaluation() {
 fn test_is_valid_solution() {
     // Path graph: 0-1-2
     let problem =
-        MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+        MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     // Valid: {1} dominates all vertices (0 and 2 are neighbors of 1)
-    assert!(problem.is_valid_solution(&[0, 1, 0]));
+    assert!(problem.is_valid_solution(&[false, true, false]));
     // Invalid: {0} doesn't dominate vertex 2
-    assert!(!problem.is_valid_solution(&[1, 0, 0]));
+    assert!(!problem.is_valid_solution(&[true, false, false]));
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem =
-        MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+        MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     assert_eq!(problem.num_vertices(), 3);
     assert_eq!(problem.num_edges(), 2);
 }
@@ -177,13 +191,13 @@ fn test_size_getters() {
 fn test_mds_paper_example() {
     // Paper: house graph, DS = {v_2, v_3}, weight = 2, gamma(G) = 2
     let graph = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]);
-    let problem = MinimumDominatingSet::new(graph, vec![1i32; 5]);
-    let config = vec![0, 0, 1, 1, 0]; // {v_2, v_3}
-    let result = problem.evaluate(&config);
+    let problem = MinimumDominatingSet::new(graph, vec![1i64; 5]);
+    let config = vec![false, false, true, true, false]; // {v_2, v_3}
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 2);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 2);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 2);
 }
diff --git a/src/unit_tests/models/graph/minimum_dummy_activities_pert.rs b/src/unit_tests/models/graph/minimum_dummy_activities_pert.rs
index c402935ac..fed0eb787 100644
--- a/src/unit_tests/models/graph/minimum_dummy_activities_pert.rs
+++ b/src/unit_tests/models/graph/minimum_dummy_activities_pert.rs
@@ -1,4 +1,17 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_cycle() {
+    assert_eq!(MinimumDummyActivitiesPertCreateSpec::FIELDS[0].name, "arcs");
+    assert!(
+        MinimumDummyActivitiesPert::try_from(MinimumDummyActivitiesPertCreateSpec {
+            arcs: vec![(0, 1), (1, 0)],
+            num_vertices: Some(2),
+        })
+        .is_err()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
@@ -12,18 +25,15 @@ fn issue_problem() -> MinimumDummyActivitiesPert {
     MinimumDummyActivitiesPert::new(issue_graph())
 }
 
-fn config_for_merges(
-    problem: &MinimumDummyActivitiesPert,
-    merges: &[(usize, usize)],
-) -> Vec<usize> {
-    let mut config = vec![0; problem.num_arcs()];
+fn config_for_merges(problem: &MinimumDummyActivitiesPert, merges: &[(usize, usize)]) -> Vec<bool> {
+    let mut config = vec![false; problem.num_arcs()];
     let arcs = problem.graph().arcs();
     for &(u, v) in merges {
         let index = arcs
             .iter()
             .position(|&(a, b)| a == u && b == v)
             .expect("merge arc must exist in issue graph");
-        config[index] = 1;
+        config[index] = true;
     }
     config
 }
@@ -33,7 +43,7 @@ fn test_minimum_dummy_activities_pert_creation() {
     let problem = issue_problem();
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_arcs(), 5);
-    assert_eq!(problem.dims(), vec![2; 5]);
+    assert_eq!(problem.dimensions(), vec![2; 5]);
 }
 
 #[test]
@@ -41,30 +51,30 @@ fn test_minimum_dummy_activities_pert_rejects_cyclic_input() {
     let err =
         MinimumDummyActivitiesPert::try_new(DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]))
             .unwrap_err();
-    assert!(err.contains("DAG"));
+    assert!(err.to_string().contains("DAG"));
 }
 
 #[test]
 fn test_minimum_dummy_activities_pert_issue_example() {
     let problem = issue_problem();
     let config = config_for_merges(&problem, &[(0, 2), (1, 4), (2, 5)]);
-    assert_eq!(problem.evaluate(&config), Min(Some(2)));
-    assert!(problem.is_valid_solution(&config));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(2)));
+    assert!(problem.is_valid_solution(&config).unwrap());
 }
 
 #[test]
 fn test_minimum_dummy_activities_pert_rejects_spurious_reachability() {
     let problem = issue_problem();
     let config = config_for_merges(&problem, &[(0, 3), (1, 3)]);
-    assert_eq!(problem.evaluate(&config), Min(None));
-    assert!(!problem.is_valid_solution(&config));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
+    assert!(!problem.is_valid_solution(&config).unwrap());
 }
 
 #[test]
 fn test_minimum_dummy_activities_pert_solver_finds_optimum_two() {
     let problem = issue_problem();
-    let solution = BruteForce::new().find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(2)));
+    let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -82,15 +92,15 @@ fn test_minimum_dummy_activities_pert_transitive_arc_zero_dummies() {
     // satisfied, so the optimal dummy count is 0.
     let dag = DirectedGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
     let problem = MinimumDummyActivitiesPert::new(dag);
-    let solution = BruteForce::new().find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(0)));
+    let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(0)));
 }
 
 #[test]
 fn test_minimum_dummy_activities_pert_paper_example() {
     let problem = issue_problem();
     let config = config_for_merges(&problem, &[(0, 2), (1, 4), (2, 5)]);
-    assert_eq!(problem.evaluate(&config), Min(Some(2)));
-    let solution = BruteForce::new().find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(2)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(2)));
+    let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(2)));
 }
diff --git a/src/unit_tests/models/graph/minimum_edge_cost_flow.rs b/src/unit_tests/models/graph/minimum_edge_cost_flow.rs
index a530a66dc..6253a1c80 100644
--- a/src/unit_tests/models/graph/minimum_edge_cost_flow.rs
+++ b/src/unit_tests/models/graph/minimum_edge_cost_flow.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -43,7 +44,7 @@ fn test_minimum_edge_cost_flow_creation() {
     assert_eq!(problem.max_capacity(), 2);
     assert_eq!(problem.prices(), &[3, 1, 2, 0, 0, 0]);
     assert_eq!(problem.capacities(), &[2, 2, 2, 2, 2, 2]);
-    assert_eq!(problem.dims(), vec![3, 3, 3, 3, 3, 3]);
+    assert_eq!(problem.dimensions(), vec![3, 3, 3, 3, 3, 3]);
     assert_eq!(
         <MinimumEdgeCostFlow as Problem>::NAME,
         "MinimumEdgeCostFlow"
@@ -55,7 +56,7 @@ fn test_minimum_edge_cost_flow_evaluate_optimal() {
     let problem = issue_instance();
     // Route 1 unit via v2 and 2 units via v3: config = [0, 1, 2, 0, 1, 2]
     let config = vec![0, 1, 2, 0, 1, 2];
-    assert_eq!(problem.evaluate(&config), Min(Some(3)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(3)));
 }
 
 #[test]
@@ -64,7 +65,7 @@ fn test_minimum_edge_cost_flow_evaluate_suboptimal() {
     // Route 1 via v1, 1 via v2, 1 via v3: config = [1, 1, 1, 1, 1, 1]
     // Cost = p(0)+p(1)+p(2)+p(3)+p(4)+p(5) = 3+1+2+0+0+0 = 6
     let config = vec![1, 1, 1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(6)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -72,7 +73,7 @@ fn test_minimum_edge_cost_flow_evaluate_infeasible_conservation() {
     let problem = issue_instance();
     // Flow into vertex 1 but not out: violates conservation
     let config = vec![1, 0, 0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -80,23 +81,35 @@ fn test_minimum_edge_cost_flow_evaluate_infeasible_flow_req() {
     let problem = issue_instance();
     // All zeros: no flow → insufficient
     let config = vec![0, 0, 0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_edge_cost_flow_evaluate_wrong_config_length() {
     let problem = issue_instance();
-    assert_eq!(problem.evaluate(&[0; 5]), Min(None)); // too short
-    assert_eq!(problem.evaluate(&[0; 7]), Min(None)); // too long
-    assert_eq!(problem.evaluate(&[]), Min(None)); // empty
+    assert!(matches!(
+        problem.evaluate(&vec![0; 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0; 7]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimum_edge_cost_flow_solver() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find optimal");
-    let value = problem.evaluate(&witness);
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find optimal");
+    let value = problem.evaluate(&witness).unwrap();
     assert_eq!(value, Min(Some(3)));
 }
 
@@ -104,7 +117,7 @@ fn test_minimum_edge_cost_flow_solver() {
 fn test_minimum_edge_cost_flow_infeasible_instance() {
     let problem = infeasible_instance();
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -131,9 +144,9 @@ fn test_minimum_edge_cost_flow_max_capacity_empty() {
 fn test_minimum_edge_cost_flow_all_witnesses_optimal() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all.is_empty());
     for sol in &all {
-        assert_eq!(problem.evaluate(sol), Min(Some(3)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Min(Some(3)));
     }
 }
diff --git a/src/unit_tests/models/graph/minimum_feedback_arc_set.rs b/src/unit_tests/models/graph/minimum_feedback_arc_set.rs
index 1ede2865b..649abd44b 100644
--- a/src/unit_tests/models/graph/minimum_feedback_arc_set.rs
+++ b/src/unit_tests/models/graph/minimum_feedback_arc_set.rs
@@ -1,4 +1,15 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_arc_weights() {
+    let p = MinimumFeedbackArcSet::try_from(MinimumFeedbackArcSetCreateSpec {
+        graph: DirectedGraph::new(2, vec![(0, 1)]),
+        weights: None,
+    })
+    .unwrap();
+    assert_eq!(p.weights(), &[1]);
+}
 use crate::solvers::BruteForce;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
@@ -20,34 +31,34 @@ fn test_minimum_feedback_arc_set_creation() {
             (3, 0),
         ],
     );
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 9]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 9]);
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_arcs(), 9);
-    assert_eq!(problem.dims().len(), 9);
-    assert!(problem.dims().iter().all(|&d| d == 2));
+    assert_eq!(problem.dimensions().len(), 9);
+    assert!(problem.dimensions().iter().all(|&d| d == 2));
 }
 
 #[test]
 fn test_minimum_feedback_arc_set_evaluation_valid() {
     // Simple cycle: 0->1->2->0
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
 
     // Remove arc 2->0 (index 2) -> breaks the cycle
-    let config = vec![0, 0, 1];
-    let result = problem.evaluate(&config);
+    let config = vec![false, false, true];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 1);
 
     // Remove arc 0->1 (index 0) -> also breaks the cycle
-    let config = vec![1, 0, 0];
-    let result = problem.evaluate(&config);
+    let config = vec![true, false, false];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 1);
 
     // Remove all arcs -> valid (trivially acyclic), size 3
-    let config = vec![1, 1, 1];
-    let result = problem.evaluate(&config);
+    let config = vec![true, true, true];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 3);
 }
@@ -56,11 +67,11 @@ fn test_minimum_feedback_arc_set_evaluation_valid() {
 fn test_minimum_feedback_arc_set_evaluation_invalid() {
     // Simple cycle: 0->1->2->0
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
 
     // Remove no arcs -> cycle remains -> invalid
-    let config = vec![0, 0, 0];
-    let result = problem.evaluate(&config);
+    let config = vec![false, false, false];
+    let result = problem.evaluate(&config).unwrap();
     assert!(!result.is_valid());
 }
 
@@ -68,11 +79,11 @@ fn test_minimum_feedback_arc_set_evaluation_invalid() {
 fn test_minimum_feedback_arc_set_dag() {
     // Already a DAG: 0->1->2
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 2]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 2]);
 
     // Remove no arcs -> already acyclic
-    let config = vec![0, 0];
-    let result = problem.evaluate(&config);
+    let config = vec![false, false];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 0);
 }
@@ -81,12 +92,12 @@ fn test_minimum_feedback_arc_set_dag() {
 fn test_minimum_feedback_arc_set_solver_simple_cycle() {
     // Simple cycle: 0->1->2->0
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
 
-    let solutions = BruteForce::new().find_all_witnesses(&problem);
+    let solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
     // Minimum FAS has size 1 (remove any one arc)
     for sol in &solutions {
-        assert_eq!(sol.iter().sum::<usize>(), 1);
+        assert_eq!(sol.iter().filter(|&&selected| selected).count(), 1);
     }
     // There are 3 optimal solutions (one for each arc)
     assert_eq!(solutions.len(), 3);
@@ -109,11 +120,11 @@ fn test_minimum_feedback_arc_set_solver_issue_example() {
             (3, 0), // a8
         ],
     );
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 9]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 9]);
 
-    let solution = BruteForce::new().find_witness(&problem).unwrap();
+    let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
     // The optimal FAS has size 2
-    let fas_size: usize = solution.iter().sum();
+    let fas_size: usize = solution.iter().filter(|&&selected| selected).count();
     assert_eq!(fas_size, 2);
 
     // Verify the solution is valid
@@ -126,32 +137,32 @@ fn test_minimum_feedback_arc_set_weighted() {
     // Arc 0 (0->1) costs 10, arcs 1,2 cost 1 each
     // Optimal: remove arc 1 or arc 2 (cost 1), NOT arc 0 (cost 10)
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![10i32, 1, 1]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![10i64, 1, 1]);
 
-    let solution = BruteForce::new().find_witness(&problem).unwrap();
-    let result = problem.evaluate(&solution);
+    let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+    let result = problem.evaluate(&solution).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 1); // should pick a cheap arc
 
     // Arc 0 should NOT be selected (too expensive)
-    assert_eq!(solution[0], 0);
+    assert!(!solution[0]);
 }
 
 #[test]
 fn test_minimum_feedback_arc_set_is_valid_solution() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
 
     // Valid: remove one arc from the cycle
-    assert!(problem.is_valid_solution(&[0, 0, 1]));
+    assert!(problem.is_valid_solution(&[false, false, true]));
     // Invalid: keep all arcs (cycle remains)
-    assert!(!problem.is_valid_solution(&[0, 0, 0]));
+    assert!(!problem.is_valid_solution(&[false, false, false]));
 }
 
 #[test]
 fn test_minimum_feedback_arc_set_problem_name() {
     assert_eq!(
-        <MinimumFeedbackArcSet<i32> as Problem>::NAME,
+        <MinimumFeedbackArcSet<i64> as Problem>::NAME,
         "MinimumFeedbackArcSet"
     );
 }
@@ -159,9 +170,9 @@ fn test_minimum_feedback_arc_set_problem_name() {
 #[test]
 fn test_minimum_feedback_arc_set_serialization() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
     let json = serde_json::to_string(&problem).unwrap();
-    let deserialized: MinimumFeedbackArcSet<i32> = serde_json::from_str(&json).unwrap();
+    let deserialized: MinimumFeedbackArcSet<i64> = serde_json::from_str(&json).unwrap();
     assert_eq!(deserialized.num_vertices(), 3);
     assert_eq!(deserialized.num_arcs(), 3);
 }
@@ -170,17 +181,17 @@ fn test_minimum_feedback_arc_set_serialization() {
 fn test_minimum_feedback_arc_set_two_disjoint_cycles() {
     // Two disjoint cycles: 0->1->0 and 2->3->2
     let graph = DirectedGraph::new(4, vec![(0, 1), (1, 0), (2, 3), (3, 2)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 4]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 4]);
 
-    let solution = BruteForce::new().find_witness(&problem).unwrap();
+    let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
     // Need to remove at least one arc from each cycle -> size 2
-    assert_eq!(solution.iter().sum::<usize>(), 2);
+    assert_eq!(solution.iter().filter(|&&selected| selected).count(), 2);
 }
 
 #[test]
-fn test_minimum_feedback_arc_set_size_getters() {
+fn test_minimum_feedback_arc_set_parameter_getters() {
     let graph = DirectedGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 5]);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 5]);
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_arcs(), 5);
 }
@@ -188,9 +199,9 @@ fn test_minimum_feedback_arc_set_size_getters() {
 #[test]
 fn test_minimum_feedback_arc_set_accessors() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let mut problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
+    let mut problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
 
-    assert!(problem.is_weighted()); // i32 type → true
+    assert!(problem.is_weighted()); // i64 type → true
     assert_eq!(problem.weights(), &[1, 1, 1]);
 
     problem.set_weights(vec![2, 3, 4]);
diff --git a/src/unit_tests/models/graph/minimum_feedback_vertex_set.rs b/src/unit_tests/models/graph/minimum_feedback_vertex_set.rs
index 00fd26274..cc1e4005a 100644
--- a/src/unit_tests/models/graph/minimum_feedback_vertex_set.rs
+++ b/src/unit_tests/models/graph/minimum_feedback_vertex_set.rs
@@ -1,4 +1,15 @@
-use super::is_feedback_vertex_set;
+use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_vertex_weights() {
+    let p = MinimumFeedbackVertexSet::<i64>::try_from(MinimumFeedbackVertexSetCreateSpec {
+        graph: DirectedGraph::new(2, vec![(0, 1)]),
+        weights: None,
+    })
+    .unwrap();
+    assert_eq!(p.weights(), &[1, 1]);
+}
 use crate::models::graph::MinimumFeedbackVertexSet;
 use crate::solvers::BruteForce;
 use crate::topology::DirectedGraph;
@@ -38,20 +49,20 @@ fn example_graph() -> DirectedGraph {
 #[test]
 fn test_minimum_feedback_vertex_set_basic() {
     let graph = example_graph();
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 9]);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 9]);
 
     // dims should be [2; 9]
-    assert_eq!(problem.dims(), vec![2usize; 9]);
+    assert_eq!(problem.dimensions(), vec![2usize; 9]);
 
     // Valid FVS: {0, 3, 8} → config = [1,0,0,1,0,0,0,0,1]
-    let config_valid = vec![1, 0, 0, 1, 0, 0, 0, 0, 1];
-    let result = problem.evaluate(&config_valid);
+    let config_valid = vec![true, false, false, true, false, false, false, false, true];
+    let result = problem.evaluate(&config_valid).unwrap();
     assert!(result.is_valid(), "Expected {{0,3,8}} to be a valid FVS");
     assert_eq!(result.unwrap(), 3, "Expected FVS size 3");
 
     // Invalid subset {1, 4, 7}: leaves cycle 2→5→8→2
-    let config_invalid = vec![0, 1, 0, 0, 1, 0, 0, 1, 0];
-    let result2 = problem.evaluate(&config_invalid);
+    let config_invalid = vec![false, true, false, false, true, false, false, true, false];
+    let result2 = problem.evaluate(&config_invalid).unwrap();
     assert!(
         !result2.is_valid(),
         "Expected {{1,4,7}} to be an invalid FVS (cycle 2→5→8→2 remains)"
@@ -61,10 +72,10 @@ fn test_minimum_feedback_vertex_set_basic() {
 #[test]
 fn test_minimum_feedback_vertex_set_serialization() {
     let graph = example_graph();
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 9]);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 9]);
 
     let json = serde_json::to_string(&problem).expect("serialization failed");
-    let deserialized: MinimumFeedbackVertexSet<i32> =
+    let deserialized: MinimumFeedbackVertexSet<i64> =
         serde_json::from_str(&json).expect("deserialization failed");
 
     assert_eq!(deserialized.graph().num_vertices(), 9);
@@ -75,17 +86,17 @@ fn test_minimum_feedback_vertex_set_serialization() {
 #[test]
 fn test_minimum_feedback_vertex_set_solver() {
     let graph = example_graph();
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 9]);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 9]);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem);
+    let best = solver.solve(&problem).unwrap();
     assert!(best.is_some(), "Expected a solution to exist");
     let best_config = best.unwrap();
-    let best_result = problem.evaluate(&best_config);
+    let best_result = problem.evaluate(&best_config).unwrap();
     assert!(best_result.is_valid());
     assert_eq!(best_result.unwrap(), 3, "Expected optimal FVS size 3");
 
-    let all_best = BruteForce::new().find_all_witnesses(&problem);
+    let all_best = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert_eq!(all_best.len(), 18, "Expected 18 optimal FVS solutions");
 }
 
@@ -93,11 +104,11 @@ fn test_minimum_feedback_vertex_set_solver() {
 fn test_minimum_feedback_vertex_set_dag() {
     // A DAG: 0 → 1 → 2
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 3]);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 3]);
 
     // Empty set (all zeros) is a valid FVS — graph is already a DAG
-    let config_empty = vec![0, 0, 0];
-    let result = problem.evaluate(&config_empty);
+    let config_empty = vec![false, false, false];
+    let result = problem.evaluate(&config_empty).unwrap();
     assert!(result.is_valid(), "Empty FVS should be valid for a DAG");
     assert_eq!(result.unwrap(), 0);
 }
@@ -106,10 +117,10 @@ fn test_minimum_feedback_vertex_set_dag() {
 fn test_minimum_feedback_vertex_set_all_selected() {
     // Selecting all vertices always yields a valid (but suboptimal) FVS
     let graph = example_graph();
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 9]);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 9]);
 
-    let config_all = vec![1usize; 9];
-    let result = problem.evaluate(&config_all);
+    let config_all = vec![true; 9];
+    let result = problem.evaluate(&config_all).unwrap();
     assert!(result.is_valid(), "Selecting all vertices should be valid");
     assert_eq!(result.unwrap(), 9);
 }
@@ -117,7 +128,7 @@ fn test_minimum_feedback_vertex_set_all_selected() {
 #[test]
 fn test_minimum_feedback_vertex_set_accessors() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let mut problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 3]);
+    let mut problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 3]);
 
     assert_eq!(problem.num_vertices(), 3);
     assert_eq!(problem.num_arcs(), 3);
@@ -131,7 +142,7 @@ fn test_minimum_feedback_vertex_set_accessors() {
 #[test]
 fn test_minimum_feedback_vertex_set_is_valid_solution() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 3]);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 3]);
 
     // Valid FVS: remove vertex 0
     assert!(problem.is_valid_solution(&[1, 0, 0]));
@@ -144,16 +155,19 @@ fn test_minimum_feedback_vertex_set_is_valid_solution() {
 #[test]
 fn test_minimum_feedback_vertex_set_evaluate_wrong_length() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 3]);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 3]);
 
     // Wrong length config returns Invalid
-    assert!(!problem.evaluate(&[1, 0]).is_valid());
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimum_feedback_vertex_set_variant() {
-    let v = <MinimumFeedbackVertexSet<i32> as Problem>::variant();
-    assert_eq!(v, vec![("weight", "i32")]);
+    let v = <MinimumFeedbackVertexSet<i64> as Problem>::variant();
+    assert_eq!(v, vec![("weight", "i64")]);
 }
 
 #[test]
@@ -183,23 +197,48 @@ fn test_minimum_feedback_vertex_set_paper_example() {
         5,
         vec![(0, 1), (1, 2), (2, 0), (0, 3), (3, 4), (4, 1), (4, 2)],
     );
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 5]);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 5]);
 
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_arcs(), 7);
 
     // {v_0} is a valid FVS with weight 1
-    let config = vec![1, 0, 0, 0, 0];
-    let result = problem.evaluate(&config);
+    let config = vec![true, false, false, false, false];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 1);
 
     // Removing v_1 alone leaves cycle v_0→v_3→v_4→...→v_2→v_0 (through arc (2,0))
-    let config_v1 = vec![0, 1, 0, 0, 0];
-    assert!(!problem.evaluate(&config_v1).is_valid());
+    let config_v1 = vec![false, true, false, false, false];
+    assert!(!problem.evaluate(&config_v1).unwrap().is_valid());
 
     // Verify optimal FVS weight is 1
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 1);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 1);
+}
+
+#[test]
+fn test_minimum_feedback_vertex_set_unit_create_and_roundtrip() {
+    use crate::types::One;
+    let source = MinimumFeedbackVertexSet::<One>::try_from(MinimumFeedbackVertexSetCreateSpec {
+        graph: DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]),
+        weights: None,
+    })
+    .unwrap();
+    assert_eq!(source.weights(), &[One; 3]);
+    assert!(!source.is_weighted());
+    let json = serde_json::to_value(&source).unwrap();
+    let restored: MinimumFeedbackVertexSet<One> = serde_json::from_value(json).unwrap();
+    assert_eq!(
+        restored.evaluate(&vec![true, false, false]).unwrap(),
+        Min(Some(1))
+    );
+    assert!(
+        MinimumFeedbackVertexSet::<One>::try_from(MinimumFeedbackVertexSetCreateSpec {
+            graph: DirectedGraph::new(2, vec![]),
+            weights: Some(vec![One]),
+        })
+        .is_err()
+    );
 }
diff --git a/src/unit_tests/models/graph/minimum_geometric_connected_dominating_set.rs b/src/unit_tests/models/graph/minimum_geometric_connected_dominating_set.rs
index 91bccdcef..a5a1c6535 100644
--- a/src/unit_tests/models/graph/minimum_geometric_connected_dominating_set.rs
+++ b/src/unit_tests/models/graph/minimum_geometric_connected_dominating_set.rs
@@ -1,56 +1,56 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
 fn test_creation_and_getters() {
     let points = vec![(0.0, 0.0), (1.0, 0.0), (2.0, 0.0)];
-    let problem = MinimumGeometricConnectedDominatingSet::new(points, 1.5);
+    let problem = MinimumGeometricConnectedDominatingSet::new(points, 1.5).unwrap();
     assert_eq!(problem.num_points(), 3);
     assert!((problem.radius() - 1.5).abs() < f64::EPSILON);
     assert_eq!(problem.points().len(), 3);
     assert_eq!(problem.num_variables(), 3);
-    assert_eq!(problem.dims(), vec![2; 3]);
+    assert_eq!(problem.dimensions(), vec![2; 3]);
 }
 
 #[test]
-#[should_panic(expected = "radius must be positive")]
-fn test_negative_radius_panics() {
-    MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0)], -1.0);
+fn test_negative_radius_is_rejected() {
+    assert!(MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0)], -1.0).is_err());
 }
 
 #[test]
-#[should_panic(expected = "points must be non-empty")]
-fn test_empty_points_panics() {
-    MinimumGeometricConnectedDominatingSet::new(vec![], 1.0);
+fn test_empty_points_are_rejected() {
+    assert!(MinimumGeometricConnectedDominatingSet::new(vec![], 1.0).is_err());
 }
 
 #[test]
-fn test_try_new_errors() {
-    assert!(MinimumGeometricConnectedDominatingSet::try_new(vec![], 1.0).is_err());
-    assert!(MinimumGeometricConnectedDominatingSet::try_new(vec![(0.0, 0.0)], 0.0).is_err());
-    assert!(MinimumGeometricConnectedDominatingSet::try_new(vec![(0.0, 0.0)], -1.0).is_err());
-    assert!(MinimumGeometricConnectedDominatingSet::try_new(vec![(0.0, 0.0)], 1.0).is_ok());
+fn test_new_validates_numeric_fields() {
+    assert!(MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0)], 0.0).is_err());
+    assert!(MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0)], f64::NAN).is_err());
+    assert!(MinimumGeometricConnectedDominatingSet::new(vec![(f64::INFINITY, 0.0)], 1.0).is_err());
+    assert!(MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0)], 1.0).is_ok());
 }
 
 #[test]
 fn test_single_point() {
-    let problem = MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0)], 1.0);
+    let problem = MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0)], 1.0).unwrap();
     // Selecting the single point is valid
-    let result = problem.evaluate(&[1]);
+    let result = problem.evaluate(&vec![true]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 1);
     // Not selecting is invalid (empty set)
-    let result = problem.evaluate(&[0]);
+    let result = problem.evaluate(&vec![false]).unwrap();
     assert!(!result.is_valid());
 }
 
 #[test]
 fn test_evaluate_domination_failure() {
     // Two points far apart, radius too small
-    let problem = MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0), (10.0, 0.0)], 1.0);
+    let problem =
+        MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0), (10.0, 0.0)], 1.0).unwrap();
     // Only select first point: second point not dominated
-    let result = problem.evaluate(&[1, 0]);
+    let result = problem.evaluate(&vec![true, false]).unwrap();
     assert!(!result.is_valid());
 }
 
@@ -59,9 +59,10 @@ fn test_evaluate_connectivity_failure() {
     // Three points in a line, select endpoints but not middle
     // With radius=1.5, each point covers its neighbor but endpoints aren't connected
     let problem =
-        MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0), (1.0, 0.0), (2.0, 0.0)], 1.5);
+        MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0), (1.0, 0.0), (2.0, 0.0)], 1.5)
+            .unwrap();
     // Select points 0 and 2 (not connected to each other, distance = 2.0 > 1.5)
-    let result = problem.evaluate(&[1, 0, 1]);
+    let result = problem.evaluate(&vec![true, false, true]).unwrap();
     assert!(!result.is_valid());
 }
 
@@ -69,9 +70,10 @@ fn test_evaluate_connectivity_failure() {
 fn test_evaluate_valid_connected_dominating_set() {
     // Three collinear points, select first two
     let problem =
-        MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0), (1.0, 0.0), (2.0, 0.0)], 1.5);
+        MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0), (1.0, 0.0), (2.0, 0.0)], 1.5)
+            .unwrap();
     // Select 0 and 1: they are connected (dist=1.0 <= 1.5), and point 2 is dominated by point 1 (dist=1.0 <= 1.5)
-    let result = problem.evaluate(&[1, 1, 0]);
+    let result = problem.evaluate(&vec![true, true, false]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 2);
 }
@@ -80,10 +82,11 @@ fn test_evaluate_valid_connected_dominating_set() {
 fn test_brute_force_line_graph() {
     // Line of 3 points, middle point dominates all
     let problem =
-        MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0), (1.0, 0.0), (2.0, 0.0)], 1.5);
+        MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0), (1.0, 0.0), (2.0, 0.0)], 1.5)
+            .unwrap();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&witness).unwrap();
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&witness).unwrap().unwrap();
     // Middle point alone dominates all and is trivially connected
     assert_eq!(value, 1);
 }
@@ -103,26 +106,45 @@ fn test_ladder_example() {
             (9.0, 3.0),
         ],
         3.5,
-    );
+    )
+    .unwrap();
     // Bottom row selected: config [1,1,1,1,0,0,0,0]
-    let config = vec![1, 1, 1, 1, 0, 0, 0, 0];
-    let result = problem.evaluate(&config);
+    let config = vec![true, true, true, true, false, false, false, false];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 4);
 
     // Verify with brute force
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    let best_value = problem.evaluate(&witness).unwrap();
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    let best_value = problem.evaluate(&witness).unwrap().unwrap();
     assert_eq!(best_value, 4);
 }
 
 #[test]
 fn test_serialization_roundtrip() {
     let problem =
-        MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0), (1.0, 1.0), (2.0, 0.0)], 2.0);
+        MinimumGeometricConnectedDominatingSet::new(vec![(0.0, 0.0), (1.0, 1.0), (2.0, 0.0)], 2.0)
+            .unwrap();
     let json = serde_json::to_string(&problem).unwrap();
     let deserialized: MinimumGeometricConnectedDominatingSet = serde_json::from_str(&json).unwrap();
     assert_eq!(deserialized.num_points(), 3);
     assert!((deserialized.radius() - 2.0).abs() < f64::EPSILON);
 }
+
+#[test]
+fn test_evaluation_reports_non_finite_distance() {
+    let problem =
+        MinimumGeometricConnectedDominatingSet::new(vec![(f64::MAX, 0.0), (-f64::MAX, 0.0)], 1.0)
+            .unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::NonFiniteResult(_))
+    ));
+}
+
+#[test]
+fn test_deserialization_validates_fields() {
+    let json = r#"{"points":[],"radius":1.0}"#;
+    assert!(serde_json::from_str::<MinimumGeometricConnectedDominatingSet>(json).is_err());
+}
diff --git a/src/unit_tests/models/graph/minimum_graph_bandwidth.rs b/src/unit_tests/models/graph/minimum_graph_bandwidth.rs
index a4cea8d14..bdfa58ec7 100644
--- a/src/unit_tests/models/graph/minimum_graph_bandwidth.rs
+++ b/src/unit_tests/models/graph/minimum_graph_bandwidth.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -21,7 +22,7 @@ fn test_minimumgraphbandwidth_creation() {
     let problem = star_example();
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 3);
-    assert_eq!(problem.dims(), vec![4, 4, 4, 4]);
+    assert_eq!(problem.dimensions(), vec![4, 4, 4, 4]);
 }
 
 #[test]
@@ -30,8 +31,8 @@ fn test_minimumgraphbandwidth_evaluate_valid() {
     // Config [1,0,2,3]: f(0)=1, f(1)=0, f(2)=2, f(3)=3
     // Edges: (0,1): |1-0|=1, (0,2): |1-2|=1, (0,3): |1-3|=2
     // Bandwidth = max(1, 1, 2) = 2
-    assert_eq!(problem.evaluate(&[1, 0, 2, 3]), Min(Some(2)));
-    assert_eq!(problem.bandwidth(&[1, 0, 2, 3]), Some(2));
+    assert_eq!(problem.evaluate(&vec![1, 0, 2, 3]).unwrap(), Min(Some(2)));
+    assert_eq!(problem.bandwidth(&[1, 0, 2, 3]).unwrap(), Some(2));
 }
 
 #[test]
@@ -39,16 +40,22 @@ fn test_minimumgraphbandwidth_evaluate_invalid() {
     let problem = star_example();
 
     // Not a permutation: repeated value
-    assert_eq!(problem.evaluate(&[0, 0, 1, 2]), Min(None));
-    assert_eq!(problem.bandwidth(&[0, 0, 1, 2]), None);
+    assert_eq!(problem.evaluate(&vec![0, 0, 1, 2]).unwrap(), Min(None));
+    assert_eq!(problem.bandwidth(&[0, 0, 1, 2]).unwrap(), None);
 
     // Out of range
-    assert_eq!(problem.evaluate(&[0, 1, 2, 4]), Min(None));
-    assert_eq!(problem.bandwidth(&[0, 1, 2, 4]), None);
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert_eq!(problem.bandwidth(&[0, 1, 2, 4]).unwrap(), None);
 
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(None));
-    assert_eq!(problem.bandwidth(&[0, 1, 2]), None);
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert_eq!(problem.bandwidth(&[0, 1, 2]).unwrap(), None);
 }
 
 #[test]
@@ -58,7 +65,8 @@ fn test_minimumgraphbandwidth_evaluate_optimal() {
     // Center (vertex 0) placed at position 1: [1, 0, 2, 3]
     // Edges: (0,1): |1-0|=1, (0,2): |1-2|=1, (0,3): |1-3|=2 → max = 2
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(2)));
 }
 
@@ -67,12 +75,14 @@ fn test_minimumgraphbandwidth_solver() {
     let problem = path_example();
     // Path graph P4: optimal bandwidth is 1 (identity permutation)
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let sol = solution.unwrap();
-    assert_eq!(problem.evaluate(&sol), Min(Some(1)));
+    assert_eq!(problem.evaluate(&sol).unwrap(), Min(Some(1)));
 
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(1)));
 }
 
@@ -86,16 +96,19 @@ fn test_minimumgraphbandwidth_serialization() {
 
     // Verify evaluation is consistent after round-trip
     let config = vec![1, 0, 2, 3];
-    assert_eq!(problem.evaluate(&config), deserialized.evaluate(&config));
+    assert_eq!(
+        problem.evaluate(&config).unwrap(),
+        deserialized.evaluate(&config).unwrap()
+    );
 }
 
 #[test]
 fn test_minimumgraphbandwidth_single_vertex() {
     let graph = SimpleGraph::new(1, vec![]);
     let problem = MinimumGraphBandwidth::new(graph);
-    assert_eq!(problem.dims(), vec![1]);
-    assert_eq!(problem.evaluate(&[0]), Min(Some(0)));
-    assert_eq!(problem.bandwidth(&[0]), Some(0));
+    assert_eq!(problem.dimensions(), vec![1]);
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Min(Some(0)));
+    assert_eq!(problem.bandwidth(&[0]).unwrap(), Some(0));
 }
 
 #[test]
@@ -105,13 +118,14 @@ fn test_minimumgraphbandwidth_empty_graph() {
     let problem = MinimumGraphBandwidth::new(graph);
 
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(0)));
 
-    let all_witnesses = solver.find_all_witnesses(&problem);
+    let all_witnesses = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all_witnesses.len(), 6); // 3! = 6
     for s in &all_witnesses {
-        assert_eq!(problem.evaluate(s), Min(Some(0)));
+        assert_eq!(problem.evaluate(s).unwrap(), Min(Some(0)));
     }
 }
 
@@ -123,7 +137,8 @@ fn test_minimumgraphbandwidth_complete_graph_k4() {
     let problem = MinimumGraphBandwidth::new(graph);
 
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(3)));
 }
 
@@ -136,7 +151,7 @@ fn test_minimumgraphbandwidth_problem_name() {
 }
 
 #[test]
-fn test_minimumgraphbandwidth_size_getters() {
+fn test_minimumgraphbandwidth_parameter_getters() {
     let problem = star_example();
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 3);
@@ -156,9 +171,9 @@ fn test_minimumgraphbandwidth_permutation_matters() {
 
     // Center at position 0: [0, 1, 2, 3]
     // Edges: (0,1): |0-1|=1, (0,2): |0-2|=2, (0,3): |0-3|=3 → max = 3
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3]), Min(Some(3)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap(), Min(Some(3)));
 
     // Center at position 1: [1, 0, 2, 3]
     // Edges: (0,1): |1-0|=1, (0,2): |1-2|=1, (0,3): |1-3|=2 → max = 2
-    assert_eq!(problem.evaluate(&[1, 0, 2, 3]), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![1, 0, 2, 3]).unwrap(), Min(Some(2)));
 }
diff --git a/src/unit_tests/models/graph/minimum_intersection_graph_basis.rs b/src/unit_tests/models/graph/minimum_intersection_graph_basis.rs
index 3f83ae34e..17fd4e160 100644
--- a/src/unit_tests/models/graph/minimum_intersection_graph_basis.rs
+++ b/src/unit_tests/models/graph/minimum_intersection_graph_basis.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -12,7 +13,7 @@ fn test_minimum_intersection_graph_basis_creation() {
     assert_eq!(problem.num_edges(), 2);
     // 3 vertices * 2 edges = 6 binary variables
     assert_eq!(problem.num_variables(), 6);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
 }
 
 #[test]
@@ -23,13 +24,13 @@ fn test_minimum_intersection_graph_basis_p3() {
     let problem = MinimumIntersectionGraphBasis::new(graph);
 
     // Valid config: S[0]={0}, S[1]={0,1}, S[2]={1} -> [1,0, 1,1, 0,1]
-    let config = vec![1, 0, 1, 1, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(2)));
+    let config = vec![vec![true, false], vec![true, true], vec![false, true]];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(2)));
 
     // Brute force should find optimal = 2
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(2)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -40,14 +41,20 @@ fn test_minimum_intersection_graph_basis_single_edge() {
     let problem = MinimumIntersectionGraphBasis::new(graph);
 
     // Valid: S[0]={0}, S[1]={0} -> [1, 1]
-    assert_eq!(problem.evaluate(&[1, 1]), Min(Some(1)));
+    assert_eq!(
+        problem.evaluate(&vec![vec![true], vec![true]]).unwrap(),
+        Min(Some(1))
+    );
 
     // Invalid: S[0]={}, S[1]={0} -> edge not covered
-    assert_eq!(problem.evaluate(&[0, 1]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![vec![false], vec![true]]).unwrap(),
+        Min(None)
+    );
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(1)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -59,16 +66,20 @@ fn test_minimum_intersection_graph_basis_triangle() {
     let problem = MinimumIntersectionGraphBasis::new(graph);
 
     // 3 vertices * 3 edges = 9 binary variables
-    assert_eq!(problem.dims(), vec![2; 9]);
+    assert_eq!(problem.dimensions(), vec![2; 9]);
 
     // Valid: S[0]={0}, S[1]={0}, S[2]={0}
     // config: v0: [1,0,0], v1: [1,0,0], v2: [1,0,0]
-    let config = vec![1, 0, 0, 1, 0, 0, 1, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(1)));
+    let config = vec![
+        vec![true, false, false],
+        vec![true, false, false],
+        vec![true, false, false],
+    ];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(1)));
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(1)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -76,14 +87,19 @@ fn test_minimum_intersection_graph_basis_empty_graph() {
     // No edges: universe size 0
     let graph = SimpleGraph::new(3, vec![]);
     let problem = MinimumIntersectionGraphBasis::new(graph);
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(
+        problem.evaluate(&vec![vec![], vec![], vec![]]).unwrap(),
+        Min(Some(0))
+    );
 }
 
 #[test]
 fn test_minimum_intersection_graph_basis_wrong_length() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MinimumIntersectionGraphBasis::new(graph);
-    assert_eq!(problem.evaluate(&[1, 0, 1]), Min(None));
+    assert!(problem
+        .evaluate(&vec![vec![true, false], vec![true]])
+        .is_err());
 }
 
 #[test]
@@ -94,8 +110,8 @@ fn test_minimum_intersection_graph_basis_invalid_nonadjacent_intersect() {
     let problem = MinimumIntersectionGraphBasis::new(graph);
 
     // S[0]={0,1}, S[1]={0,1}, S[2]={0,1} -> 0 and 2 share elements -> invalid
-    let config = vec![1, 1, 1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![vec![true, true], vec![true, true], vec![true, true]];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -105,6 +121,6 @@ fn test_minimum_intersection_graph_basis_invalid_edge_not_covered() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MinimumIntersectionGraphBasis::new(graph);
 
-    let config = vec![1, 0, 0, 1, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![vec![true, false], vec![false, true], vec![false, true]];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
diff --git a/src/unit_tests/models/graph/minimum_maximal_matching.rs b/src/unit_tests/models/graph/minimum_maximal_matching.rs
index 351463f1a..4a15078d7 100644
--- a/src/unit_tests/models/graph/minimum_maximal_matching.rs
+++ b/src/unit_tests/models/graph/minimum_maximal_matching.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -21,7 +22,10 @@ fn test_minimum_maximal_matching_evaluate_valid() {
     // Edge (2,3): shares vertex 2 with (1,2) ✓ blocked
     let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
     let problem = MinimumMaximalMatching::new(graph);
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Min(Some(1)));
+    assert_eq!(
+        problem.evaluate(&vec![false, true, false]).unwrap(),
+        Min(Some(1))
+    );
 }
 
 #[test]
@@ -30,7 +34,10 @@ fn test_minimum_maximal_matching_evaluate_not_maximal() {
     // config [1,0,0]: select only (0,1). Edge (2,3) is not blocked — not maximal.
     let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
     let problem = MinimumMaximalMatching::new(graph);
-    assert_eq!(problem.evaluate(&[1, 0, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false]).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -39,7 +46,10 @@ fn test_minimum_maximal_matching_evaluate_not_matching() {
     // config [1,1,0]: select (0,1) and (1,2) — vertex 1 shared → not a matching.
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
     let problem = MinimumMaximalMatching::new(graph);
-    assert_eq!(problem.evaluate(&[1, 1, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false]).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -47,7 +57,10 @@ fn test_minimum_maximal_matching_evaluate_wrong_length() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MinimumMaximalMatching::new(graph);
     // Provide config of wrong length
-    assert_eq!(problem.evaluate(&[1]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -55,7 +68,7 @@ fn test_minimum_maximal_matching_empty_graph() {
     // No edges: empty config is a valid (vacuously maximal) matching of size 0.
     let graph = SimpleGraph::new(3, vec![]);
     let problem = MinimumMaximalMatching::new(graph);
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -65,8 +78,8 @@ fn test_minimum_maximal_matching_path_p6_solver() {
     let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]);
     let problem = MinimumMaximalMatching::new(graph);
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best), Min(Some(2)));
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -74,8 +87,8 @@ fn test_minimum_maximal_matching_canonical_example() {
     // Canonical example: P6 with config [0,1,0,1,0] → edges (1,2) and (3,4).
     let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]);
     let problem = MinimumMaximalMatching::new(graph);
-    let config = vec![0, 1, 0, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(2)));
+    let config = vec![false, true, false, true, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -84,8 +97,8 @@ fn test_minimum_maximal_matching_triangle() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
     let problem = MinimumMaximalMatching::new(graph);
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best), Min(Some(1)));
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -95,8 +108,8 @@ fn test_minimum_maximal_matching_star() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]);
     let problem = MinimumMaximalMatching::new(graph);
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best), Min(Some(1)));
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap(), Min(Some(1)));
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/minimum_metric_dimension.rs b/src/unit_tests/models/graph/minimum_metric_dimension.rs
index 7650b7898..6e4764d1f 100644
--- a/src/unit_tests/models/graph/minimum_metric_dimension.rs
+++ b/src/unit_tests/models/graph/minimum_metric_dimension.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -11,7 +12,7 @@ fn test_minimum_metric_dimension_creation() {
     assert_eq!(problem.graph().num_vertices(), 5);
     assert_eq!(problem.graph().num_edges(), 6);
     assert_eq!(problem.num_variables(), 5);
-    assert_eq!(problem.dims(), vec![2; 5]);
+    assert_eq!(problem.dimensions(), vec![2; 5]);
 }
 
 #[test]
@@ -19,8 +20,8 @@ fn test_minimum_metric_dimension_evaluate_optimal() {
     // House graph: selecting vertices 0 and 1 forms a resolving set of size 2
     let graph = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]);
     let problem = MinimumMetricDimension::new(graph);
-    let config = vec![1, 1, 0, 0, 0]; // select v0, v1
-    let result = problem.evaluate(&config);
+    let config = vec![true, true, false, false, false]; // select v0, v1
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result, Min(Some(2)));
 }
@@ -32,8 +33,8 @@ fn test_minimum_metric_dimension_evaluate_non_resolving() {
     let problem = MinimumMetricDimension::new(graph);
     // v2 alone: d(0,2)=1, d(1,2)=2, d(3,2)=1, d(4,2)=1
     // vertices 0 and 3 both have distance 1 to v2 -> not resolving
-    let config = vec![0, 0, 1, 0, 0];
-    let result = problem.evaluate(&config);
+    let config = vec![false, false, true, false, false];
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Min(None));
 }
 
@@ -41,8 +42,8 @@ fn test_minimum_metric_dimension_evaluate_non_resolving() {
 fn test_minimum_metric_dimension_evaluate_empty_selection() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MinimumMetricDimension::new(graph);
-    let config = vec![0, 0, 0];
-    let result = problem.evaluate(&config);
+    let config = vec![false, false, false];
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Min(None));
 }
 
@@ -51,8 +52,8 @@ fn test_minimum_metric_dimension_evaluate_all_selected() {
     // Selecting all vertices is always resolving (trivially)
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MinimumMetricDimension::new(graph);
-    let config = vec![1, 1, 1];
-    let result = problem.evaluate(&config);
+    let config = vec![true, true, true];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result, Min(Some(3)));
 }
@@ -63,8 +64,8 @@ fn test_minimum_metric_dimension_solver() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]);
     let problem = MinimumMetricDimension::new(graph);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     assert!(value.is_valid());
     assert_eq!(value, Min(Some(2)));
 }
@@ -77,8 +78,8 @@ fn test_minimum_metric_dimension_path_graph() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MinimumMetricDimension::new(graph);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     assert_eq!(value, Min(Some(1)));
 }
 
@@ -89,8 +90,8 @@ fn test_minimum_metric_dimension_complete_graph() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
     let problem = MinimumMetricDimension::new(graph);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     assert_eq!(value, Min(Some(3)));
 }
 
@@ -104,12 +105,15 @@ fn test_minimum_metric_dimension_serialization() {
     assert_eq!(deserialized.num_edges(), 2);
 
     // Verify evaluation is preserved
-    let config = vec![1, 0, 0];
-    assert_eq!(problem.evaluate(&config), deserialized.evaluate(&config));
+    let config = vec![true, false, false];
+    assert_eq!(
+        problem.evaluate(&config).unwrap(),
+        deserialized.evaluate(&config).unwrap()
+    );
 }
 
 #[test]
-fn test_minimum_metric_dimension_size_getters() {
+fn test_minimum_metric_dimension_parameter_getters() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
     let problem = MinimumMetricDimension::new(graph);
     assert_eq!(problem.num_vertices(), 4);
@@ -122,7 +126,7 @@ fn test_minimum_metric_dimension_cycle() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]);
     let problem = MinimumMetricDimension::new(graph);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     assert_eq!(value, Min(Some(2)));
 }
diff --git a/src/unit_tests/models/graph/minimum_multiway_cut.rs b/src/unit_tests/models/graph/minimum_multiway_cut.rs
index 9cbbe5511..c9831cc6e 100644
--- a/src/unit_tests/models/graph/minimum_multiway_cut.rs
+++ b/src/unit_tests/models/graph/minimum_multiway_cut.rs
@@ -1,4 +1,16 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_invalid_terminals() {
+    assert_eq!(MinimumMultiwayCutCreateSpec::FIELDS[1].name, "terminals");
+    let result = MinimumMultiwayCut::try_from(MinimumMultiwayCutCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        terminals: vec![0, 0],
+        edge_weights: vec![1],
+    });
+    assert!(result.is_err());
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -8,7 +20,7 @@ use crate::types::Min;
 fn test_minimummultiwaycut_creation() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (1, 3)]);
     let problem = MinimumMultiwayCut::new(graph, vec![0, 2, 4], vec![2, 3, 1, 2, 4, 5]);
-    assert_eq!(problem.dims().len(), 6);
+    assert_eq!(problem.dimensions().len(), 6);
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_edges(), 6);
     assert_eq!(problem.num_terminals(), 3);
@@ -23,8 +35,8 @@ fn test_minimummultiwaycut_evaluate_valid() {
 
     // Optimal cut: remove edges (0,1), (3,4), (0,4) => indices 0, 3, 4
     // config: [1, 0, 0, 1, 1, 0] => weight 2 + 2 + 4 = 8
-    let config = vec![1, 0, 0, 1, 1, 0];
-    let result = problem.evaluate(&config);
+    let config = vec![true, false, false, true, true, false];
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Min(Some(8)));
 }
 
@@ -34,8 +46,8 @@ fn test_minimummultiwaycut_evaluate_invalid() {
     let problem = MinimumMultiwayCut::new(graph, vec![0, 2, 4], vec![2, 3, 1, 2, 4, 5]);
 
     // No edges cut: all terminals connected => invalid
-    let config = vec![0, 0, 0, 0, 0, 0];
-    let result = problem.evaluate(&config);
+    let config = vec![false, false, false, false, false, false];
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Min(None));
 }
 
@@ -46,14 +58,14 @@ fn test_minimummultiwaycut_brute_force() {
     let problem = MinimumMultiwayCut::new(graph, vec![0, 2, 4], vec![2, 3, 1, 2, 4, 5]);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        let val = problem.evaluate(sol);
+        let val = problem.evaluate(sol).unwrap();
         assert_eq!(val, Min(Some(8)));
     }
     // Verify the claimed optimal cut [1,0,0,1,1,0] is among solutions
-    let claimed_optimal = vec![1, 0, 0, 1, 1, 0];
+    let claimed_optimal = vec![true, false, false, true, true, false];
     assert!(
         solutions.contains(&claimed_optimal),
         "expected optimal config {:?} not found in brute-force solutions",
@@ -67,12 +79,12 @@ fn test_minimummultiwaycut_two_terminals() {
     // Edges: (0,1)w=3, (1,2)w=5
     // Min cut: remove (0,1) with weight 3
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumMultiwayCut::new(graph, vec![0, 2], vec![3i32, 5]);
+    let problem = MinimumMultiwayCut::new(graph, vec![0, 2], vec![3i64, 5]);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
-        assert_eq!(problem.evaluate(sol), Min(Some(3)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Min(Some(3)));
     }
 }
 
@@ -80,8 +92,8 @@ fn test_minimummultiwaycut_two_terminals() {
 fn test_minimummultiwaycut_all_edges_cut() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (1, 3)]);
     let problem = MinimumMultiwayCut::new(graph, vec![0, 2, 4], vec![2, 3, 1, 2, 4, 5]);
-    let config = vec![1, 1, 1, 1, 1, 1];
-    let result = problem.evaluate(&config);
+    let config = vec![true, true, true, true, true, true];
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Min(Some(2 + 3 + 1 + 2 + 4 + 5)));
 }
 
@@ -90,24 +102,24 @@ fn test_minimummultiwaycut_already_disconnected() {
     // Terminals already in different components => empty cut is valid
     // Graph: 0-1  2-3, terminals {0, 2}
     let graph = SimpleGraph::new(4, vec![(0, 1), (2, 3)]);
-    let problem = MinimumMultiwayCut::new(graph, vec![0, 2], vec![1i32, 1]);
-    let config = vec![0, 0];
-    let result = problem.evaluate(&config);
+    let problem = MinimumMultiwayCut::new(graph, vec![0, 2], vec![1i64, 1]);
+    let config = vec![false, false];
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Min(Some(0)));
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
-        assert_eq!(problem.evaluate(sol), Min(Some(0)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Min(Some(0)));
     }
 }
 
 #[test]
 fn test_minimummultiwaycut_serialization() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumMultiwayCut::new(graph, vec![0, 2], vec![1i32, 2]);
+    let problem = MinimumMultiwayCut::new(graph, vec![0, 2], vec![1i64, 2]);
     let json = serde_json::to_string(&problem).unwrap();
-    let restored: MinimumMultiwayCut<SimpleGraph, i32> = serde_json::from_str(&json).unwrap();
+    let restored: MinimumMultiwayCut<SimpleGraph, i64> = serde_json::from_str(&json).unwrap();
     assert_eq!(restored.num_vertices(), 3);
     assert_eq!(restored.num_edges(), 2);
     assert_eq!(restored.terminals(), &[0, 2]);
@@ -116,7 +128,7 @@ fn test_minimummultiwaycut_serialization() {
 #[test]
 fn test_minimummultiwaycut_name() {
     assert_eq!(
-        <MinimumMultiwayCut<SimpleGraph, i32> as Problem>::NAME,
+        <MinimumMultiwayCut<SimpleGraph, i64> as Problem>::NAME,
         "MinimumMultiwayCut"
     );
 }
@@ -125,50 +137,52 @@ fn test_minimummultiwaycut_name() {
 #[should_panic(expected = "edge_weights length must match num_edges")]
 fn test_minimummultiwaycut_panic_wrong_weights_len() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    MinimumMultiwayCut::new(graph, vec![0, 2], vec![1i32]);
+    MinimumMultiwayCut::new(graph, vec![0, 2], vec![1i64]);
 }
 
 #[test]
 #[should_panic(expected = "need at least 2 terminals")]
 fn test_minimummultiwaycut_panic_too_few_terminals() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    MinimumMultiwayCut::new(graph, vec![0], vec![1i32, 1]);
+    MinimumMultiwayCut::new(graph, vec![0], vec![1i64, 1]);
 }
 
 #[test]
 #[should_panic(expected = "duplicate terminal indices")]
 fn test_minimummultiwaycut_panic_duplicate_terminals() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    MinimumMultiwayCut::new(graph, vec![0, 0], vec![1i32, 1]);
+    MinimumMultiwayCut::new(graph, vec![0, 0], vec![1i64, 1]);
 }
 
 #[test]
 #[should_panic(expected = "terminal index out of bounds")]
 fn test_minimummultiwaycut_panic_terminal_out_of_bounds() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    MinimumMultiwayCut::new(graph, vec![0, 10], vec![1i32, 1]);
+    MinimumMultiwayCut::new(graph, vec![0, 10], vec![1i64, 1]);
 }
 
 #[test]
 fn test_minimummultiwaycut_getters() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumMultiwayCut::new(graph, vec![0, 2], vec![3i32, 5]);
+    let problem = MinimumMultiwayCut::new(graph, vec![0, 2], vec![3i64, 5]);
     assert_eq!(problem.graph().num_vertices(), 3);
     assert_eq!(problem.edge_weights(), &[3, 5]);
 }
 
 #[test]
-fn test_minimummultiwaycut_short_config_no_panic() {
+fn test_minimummultiwaycut_rejects_wrong_config_lengths() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (1, 3)]);
     let problem = MinimumMultiwayCut::new(graph, vec![0, 2, 4], vec![2, 3, 1, 2, 4, 5]);
 
-    // Short config: only 2 of 6 edges specified, terminals remain connected
-    let short_config = vec![1, 0];
-    let result = problem.evaluate(&short_config);
-    assert_eq!(result, Min(None));
-
-    // Empty config: no edges cut, all terminals connected
-    let empty_config: Vec<usize> = vec![];
-    let result = problem.evaluate(&empty_config);
-    assert_eq!(result, Min(None));
+    let short_config = vec![true, false];
+    assert!(matches!(
+        problem.evaluate(&short_config),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+
+    let empty_config: Vec<bool> = vec![];
+    assert!(matches!(
+        problem.evaluate(&empty_config),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
diff --git a/src/unit_tests/models/graph/minimum_sum_multicenter.rs b/src/unit_tests/models/graph/minimum_sum_multicenter.rs
index fdf833111..e636dee31 100644
--- a/src/unit_tests/models/graph/minimum_sum_multicenter.rs
+++ b/src/unit_tests/models/graph/minimum_sum_multicenter.rs
@@ -1,12 +1,13 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
 #[test]
 fn test_min_sum_multicenter_creation() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 4], vec![1i32; 3], 2);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 4], vec![1i64; 3], 2);
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 3);
     assert_eq!(problem.k(), 2);
@@ -15,9 +16,9 @@ fn test_min_sum_multicenter_creation() {
 }
 
 #[test]
-fn test_min_sum_multicenter_size_getters() {
+fn test_min_sum_multicenter_parameter_getters() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 5], vec![1i32; 4], 2);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 5], vec![1i64; 4], 2);
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_edges(), 4);
     assert_eq!(problem.num_centers(), 2);
@@ -27,15 +28,15 @@ fn test_min_sum_multicenter_size_getters() {
 fn test_min_sum_multicenter_evaluate_path() {
     // Path: 0-1-2, unit weights and lengths, K=1
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 3], vec![1i32; 2], 1);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 3], vec![1i64; 2], 1);
 
     // Center at vertex 1: distances = [1, 0, 1], total = 2
-    let result = problem.evaluate(&[0, 1, 0]);
+    let result = problem.evaluate(&vec![false, true, false]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 2);
 
     // Center at vertex 0: distances = [0, 1, 2], total = 3
-    let result = problem.evaluate(&[1, 0, 0]);
+    let result = problem.evaluate(&vec![true, false, false]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 3);
 }
@@ -43,18 +44,18 @@ fn test_min_sum_multicenter_evaluate_path() {
 #[test]
 fn test_min_sum_multicenter_wrong_k() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 3], vec![1i32; 2], 2);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 3], vec![1i64; 2], 2);
 
     // Only 1 center selected when K=2
-    let result = problem.evaluate(&[0, 1, 0]);
+    let result = problem.evaluate(&vec![false, true, false]).unwrap();
     assert!(!result.is_valid());
 
     // 3 centers selected when K=2
-    let result = problem.evaluate(&[1, 1, 1]);
+    let result = problem.evaluate(&vec![true, true, true]).unwrap();
     assert!(!result.is_valid());
 
     // No centers selected
-    let result = problem.evaluate(&[0, 0, 0]);
+    let result = problem.evaluate(&vec![false, false, false]).unwrap();
     assert!(!result.is_valid());
 }
 
@@ -62,42 +63,84 @@ fn test_min_sum_multicenter_wrong_k() {
 fn test_min_sum_multicenter_weighted() {
     // Path: 0-1-2, vertex weights = [3, 1, 2], edge lengths = [1, 1], K=1
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![3i32, 1, 2], vec![1i32; 2], 1);
+    let problem = MinimumSumMulticenter::new(graph, vec![3i64, 1, 2], vec![1i64; 2], 1);
 
     // Center at 0: distances = [0, 1, 2], total = 3*0 + 1*1 + 2*2 = 5
-    assert_eq!(problem.evaluate(&[1, 0, 0]).unwrap(), 5);
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false])
+            .unwrap()
+            .unwrap(),
+        5
+    );
 
     // Center at 1: distances = [1, 0, 1], total = 3*1 + 1*0 + 2*1 = 5
-    assert_eq!(problem.evaluate(&[0, 1, 0]).unwrap(), 5);
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, true, false])
+            .unwrap()
+            .unwrap(),
+        5
+    );
 
     // Center at 2: distances = [2, 1, 0], total = 3*2 + 1*1 + 2*0 = 7
-    assert_eq!(problem.evaluate(&[0, 0, 1]).unwrap(), 7);
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, false, true])
+            .unwrap()
+            .unwrap(),
+        7
+    );
 }
 
 #[test]
 fn test_min_sum_multicenter_weighted_edges() {
     // Triangle: 0-1 (len 1), 1-2 (len 3), 0-2 (len 2), K=1
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 3], vec![1, 3, 2], 1);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 3], vec![1, 3, 2], 1);
 
     // Center at 0: d(0)=0, d(1)=1, d(2)=2, total=3
-    assert_eq!(problem.evaluate(&[1, 0, 0]).unwrap(), 3);
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false])
+            .unwrap()
+            .unwrap(),
+        3
+    );
 
     // Center at 1: d(1)=0, d(0)=1, d(2)=min(3, 1+2)=3, total=4
-    assert_eq!(problem.evaluate(&[0, 1, 0]).unwrap(), 4);
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, true, false])
+            .unwrap()
+            .unwrap(),
+        4
+    );
 }
 
 #[test]
 fn test_min_sum_multicenter_two_centers() {
     // Path: 0-1-2-3-4, unit weights and lengths, K=2
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 5], vec![1i32; 4], 2);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 5], vec![1i64; 4], 2);
 
     // Centers at {1, 3}: d = [1, 0, 1, 0, 1], total = 3
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1, 0]).unwrap(), 3);
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, true, false, true, false])
+            .unwrap()
+            .unwrap(),
+        3
+    );
 
     // Centers at {0, 4}: d = [0, 1, 2, 1, 0], total = 4
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0, 1]).unwrap(), 4);
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, false, true])
+            .unwrap()
+            .unwrap(),
+        4
+    );
 }
 
 #[test]
@@ -116,11 +159,11 @@ fn test_min_sum_multicenter_solver() {
             (2, 5),
         ],
     );
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 7], vec![1i32; 8], 2);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 7], vec![1i64; 8], 2);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    let best_cost = problem.evaluate(&best).unwrap();
+    let best = solver.solve(&problem).unwrap().unwrap();
+    let best_cost = problem.evaluate(&best).unwrap().unwrap();
 
     // Optimal cost should be 6 (centers at {2, 5})
     assert_eq!(best_cost, 6);
@@ -130,16 +173,16 @@ fn test_min_sum_multicenter_solver() {
 fn test_min_sum_multicenter_disconnected() {
     // Two disconnected components: 0-1 and 2-3, K=1
     let graph = SimpleGraph::new(4, vec![(0, 1), (2, 3)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 4], vec![1i32; 2], 1);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 4], vec![1i64; 2], 1);
 
     // Center at 0: vertex 2 and 3 are unreachable
-    let result = problem.evaluate(&[1, 0, 0, 0]);
+    let result = problem.evaluate(&vec![true, false, false, false]).unwrap();
     assert!(!result.is_valid());
 
     // With K=2, centers at {0, 2}: all reachable
     let graph2 = SimpleGraph::new(4, vec![(0, 1), (2, 3)]);
-    let problem2 = MinimumSumMulticenter::new(graph2, vec![1i32; 4], vec![1i32; 2], 2);
-    let result2 = problem2.evaluate(&[1, 0, 1, 0]);
+    let problem2 = MinimumSumMulticenter::new(graph2, vec![1i64; 4], vec![1i64; 2], 2);
+    let result2 = problem2.evaluate(&vec![true, false, true, false]).unwrap();
     assert!(result2.is_valid());
     assert_eq!(result2.unwrap(), 2); // d = [0, 1, 0, 1]
 }
@@ -147,8 +190,8 @@ fn test_min_sum_multicenter_disconnected() {
 #[test]
 fn test_min_sum_multicenter_single_vertex() {
     let graph = SimpleGraph::new(1, vec![]);
-    let problem = MinimumSumMulticenter::new(graph, vec![5i32], vec![], 1);
-    let result = problem.evaluate(&[1]);
+    let problem = MinimumSumMulticenter::new(graph, vec![5i64], vec![], 1);
+    let result = problem.evaluate(&vec![true]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 0); // Only vertex is the center, distance = 0
 }
@@ -157,8 +200,8 @@ fn test_min_sum_multicenter_single_vertex() {
 fn test_min_sum_multicenter_all_centers() {
     // K = num_vertices: all vertices are centers, total distance = 0
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 3], vec![1i32; 2], 3);
-    let result = problem.evaluate(&[1, 1, 1]);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 3], vec![1i64; 2], 3);
+    let result = problem.evaluate(&vec![true, true, true]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 0);
 }
@@ -167,28 +210,28 @@ fn test_min_sum_multicenter_all_centers() {
 #[should_panic(expected = "vertex_weights length must match num_vertices")]
 fn test_min_sum_multicenter_wrong_vertex_weights_len() {
     let graph = SimpleGraph::new(3, vec![(0, 1)]);
-    MinimumSumMulticenter::new(graph, vec![1i32; 2], vec![1i32; 1], 1);
+    MinimumSumMulticenter::new(graph, vec![1i64; 2], vec![1i64; 1], 1);
 }
 
 #[test]
 #[should_panic(expected = "edge_lengths length must match num_edges")]
 fn test_min_sum_multicenter_wrong_edge_lengths_len() {
     let graph = SimpleGraph::new(3, vec![(0, 1)]);
-    MinimumSumMulticenter::new(graph, vec![1i32; 3], vec![1i32; 2], 1);
+    MinimumSumMulticenter::new(graph, vec![1i64; 3], vec![1i64; 2], 1);
 }
 
 #[test]
 #[should_panic(expected = "k must be positive")]
 fn test_min_sum_multicenter_k_zero() {
     let graph = SimpleGraph::new(3, vec![(0, 1)]);
-    MinimumSumMulticenter::new(graph, vec![1i32; 3], vec![1i32; 1], 0);
+    MinimumSumMulticenter::new(graph, vec![1i64; 3], vec![1i64; 1], 0);
 }
 
 #[test]
 #[should_panic(expected = "k must not exceed num_vertices")]
 fn test_min_sum_multicenter_k_too_large() {
     let graph = SimpleGraph::new(3, vec![(0, 1)]);
-    MinimumSumMulticenter::new(graph, vec![1i32; 3], vec![1i32; 1], 4);
+    MinimumSumMulticenter::new(graph, vec![1i64; 3], vec![1i64; 1], 4);
 }
 
 #[test]
@@ -207,47 +250,49 @@ fn test_min_sum_multicenter_paper_example() {
             (2, 5),
         ],
     );
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 7], vec![1i32; 8], 2);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 7], vec![1i64; 8], 2);
 
     // Optimal: centers at {2, 5}, config [0,0,1,0,0,1,0]
     // Distances: d(0)=2, d(1)=1, d(2)=0, d(3)=1, d(4)=1, d(5)=0, d(6)=1
     // Total = 6
-    let result = problem.evaluate(&[0, 0, 1, 0, 0, 1, 0]);
+    let result = problem
+        .evaluate(&vec![false, false, true, false, false, true, false])
+        .unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 6);
 
     // Verify optimality with brute force
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 6);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 6);
 }
 
 #[test]
 fn test_min_sum_multicenter_dims() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 5], vec![1i32; 4], 2);
-    assert_eq!(problem.dims(), vec![2; 5]);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 5], vec![1i64; 4], 2);
+    assert_eq!(problem.dimensions(), vec![2; 5]);
 }
 
 #[test]
 fn test_min_sum_multicenter_find_all_witnesses() {
     // Path: 0-1-2, unit weights, K=1. Center at 1 is optimal (cost 2)
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 3], vec![1i32; 2], 1);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 3], vec![1i64; 2], 1);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![0, 1, 0]);
+    assert_eq!(solutions[0], vec![false, true, false]);
 }
 
 #[test]
 fn test_min_sum_multicenter_serialization() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumSumMulticenter::new(graph, vec![1i32; 3], vec![1i32; 2], 1);
+    let problem = MinimumSumMulticenter::new(graph, vec![1i64; 3], vec![1i64; 2], 1);
 
     let json = serde_json::to_string(&problem).unwrap();
-    let deserialized: MinimumSumMulticenter<SimpleGraph, i32> =
+    let deserialized: MinimumSumMulticenter<SimpleGraph, i64> =
         serde_json::from_str(&json).unwrap();
 
     assert_eq!(deserialized.graph().num_vertices(), 3);
@@ -257,9 +302,27 @@ fn test_min_sum_multicenter_serialization() {
     assert_eq!(deserialized.k(), 1);
 
     // Verify evaluation produces same results
-    let config = vec![0, 1, 0];
+    let config = vec![false, true, false];
     assert_eq!(
         problem.evaluate(&config).unwrap(),
         deserialized.evaluate(&config).unwrap()
     );
 }
+#[test]
+fn create_spec_maps_weight_inputs_to_canonical_fields() {
+    let problem = MinimumSumMulticenter::try_from(MinimumSumMulticenterCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: None,
+        weights: Some(vec![2, 3]),
+        edge_weights: None,
+        k: 1,
+    })
+    .unwrap();
+    assert_eq!(problem.vertex_weights(), &[2, 3]);
+    assert_eq!(problem.edge_lengths(), &[1]);
+    assert_eq!(MinimumSumMulticenterCreateSpec::FIELDS[2].name, "weights");
+    assert_eq!(
+        MinimumSumMulticenterCreateSpec::FIELDS[3].name,
+        "edge_weights"
+    );
+}
diff --git a/src/unit_tests/models/graph/minimum_vertex_cover.rs b/src/unit_tests/models/graph/minimum_vertex_cover.rs
index 39f052644..809475eef 100644
--- a/src/unit_tests/models/graph/minimum_vertex_cover.rs
+++ b/src/unit_tests/models/graph/minimum_vertex_cover.rs
@@ -1,4 +1,18 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_weight_count_mismatch() {
+    assert_eq!(
+        MinimumVertexCoverCreateSpec::<i64>::FIELDS[1].name,
+        "weights"
+    );
+    let result = MinimumVertexCover::try_from(MinimumVertexCoverCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        weights: Some(vec![1]),
+    });
+    assert!(result.is_err());
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -8,7 +22,7 @@ include!("../../jl_helpers.rs");
 fn test_vertex_cover_creation() {
     let problem = MinimumVertexCover::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 3);
@@ -47,17 +61,19 @@ fn test_complement_relationship() {
     use crate::models::graph::MaximumIndependentSet;
 
     let edges = vec![(0, 1), (1, 2), (2, 3)];
-    let is_problem = MaximumIndependentSet::new(SimpleGraph::new(4, edges.clone()), vec![1i32; 4]);
-    let vc_problem = MinimumVertexCover::new(SimpleGraph::new(4, edges), vec![1i32; 4]);
+    let is_problem = MaximumIndependentSet::new(SimpleGraph::new(4, edges.clone()), vec![1i64; 4]);
+    let vc_problem = MinimumVertexCover::new(SimpleGraph::new(4, edges), vec![1i64; 4]);
 
     let solver = BruteForce::new();
 
-    let is_solutions = solver.find_all_witnesses(&is_problem);
+    let is_solutions = solver.find_all_witnesses(&is_problem).unwrap();
     for is_sol in &is_solutions {
         // Complement should be a valid vertex cover
-        let vc_config: Vec<usize> = is_sol.iter().map(|&x| 1 - x).collect();
+        let vc_config: Vec<bool> = is_sol.iter().map(|&selected| !selected).collect();
         // Valid cover should return Valid
-        assert!(Problem::evaluate(&vc_problem, &vc_config).is_valid());
+        assert!(Problem::evaluate(&vc_problem, &vc_config)
+            .unwrap()
+            .is_valid());
     }
 }
 
@@ -71,11 +87,28 @@ fn test_is_vertex_cover_wrong_len() {
 #[test]
 fn test_from_graph() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumVertexCover::new(graph, vec![1i32, 1, 1]);
+    let problem = MinimumVertexCover::new(graph, vec![1i64, 1, 1]);
     assert_eq!(problem.graph().num_vertices(), 3);
     assert_eq!(problem.graph().num_edges(), 2);
 }
 
+#[test]
+fn test_evaluate_rejects_invalid_configurations() {
+    let problem = MinimumVertexCover::new(SimpleGraph::new(2, vec![]), vec![1_i64, 1]);
+    assert!(matches!(
+        problem.evaluate(&vec![true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([2, false]))
+            .is_err()
+    );
+}
+
 #[test]
 fn test_from_graph_with_weights() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
@@ -85,7 +118,7 @@ fn test_from_graph_with_weights() {
 
 #[test]
 fn test_graph_accessor() {
-    let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     let graph = problem.graph();
     assert_eq!(graph.num_vertices(), 3);
     assert_eq!(graph.num_edges(), 2);
@@ -93,7 +126,7 @@ fn test_graph_accessor() {
 
 #[test]
 fn test_has_edge() {
-    let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     assert!(problem.graph().has_edge(0, 1));
     assert!(problem.graph().has_edge(1, 0)); // Undirected
     assert!(problem.graph().has_edge(1, 2));
@@ -109,11 +142,11 @@ fn test_jl_parity_evaluation() {
     for instance in data["instances"].as_array().unwrap() {
         let nv = instance["instance"]["num_vertices"].as_u64().unwrap() as usize;
         let edges = jl_parse_edges(&instance["instance"]);
-        let weights = jl_parse_i32_vec(&instance["instance"]["weights"]);
+        let weights = jl_parse_i64_vec(&instance["instance"]["weights"]);
         let problem = MinimumVertexCover::new(SimpleGraph::new(nv, edges), weights);
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config);
+            let config = jl_parse_bool_config(&eval["config"]);
+            let result = problem.evaluate(&config).unwrap();
             let jl_valid = eval["is_valid"].as_bool().unwrap();
             assert_eq!(
                 result.is_valid(),
@@ -122,7 +155,7 @@ fn test_jl_parity_evaluation() {
                 config
             );
             if jl_valid {
-                let jl_size = eval["size"].as_i64().unwrap() as i32;
+                let jl_size = eval["size"].as_i64().unwrap();
                 assert_eq!(
                     result.unwrap(),
                     jl_size,
@@ -131,9 +164,9 @@ fn test_jl_parity_evaluation() {
                 );
             }
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best: HashSet<Vec<bool>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "VC best solutions mismatch");
     }
 }
@@ -141,16 +174,16 @@ fn test_jl_parity_evaluation() {
 #[test]
 fn test_is_valid_solution() {
     // Path graph: 0-1-2
-    let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     // Valid: {1} covers both edges
-    assert!(problem.is_valid_solution(&[0, 1, 0]));
+    assert!(problem.is_valid_solution(&[false, true, false]));
     // Invalid: {0} doesn't cover edge (1,2)
-    assert!(!problem.is_valid_solution(&[1, 0, 0]));
+    assert!(!problem.is_valid_solution(&[true, false, false]));
 }
 
 #[test]
-fn test_size_getters() {
-    let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+fn test_parameter_getters() {
+    let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     assert_eq!(problem.num_vertices(), 3);
     assert_eq!(problem.num_edges(), 2);
 }
@@ -159,13 +192,13 @@ fn test_size_getters() {
 fn test_mvc_paper_example() {
     // Paper: house graph, VC = {v_0, v_3, v_4}, weight = 3
     let graph = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]);
-    let problem = MinimumVertexCover::new(graph, vec![1i32; 5]);
-    let config = vec![1, 0, 0, 1, 1]; // {v_0, v_3, v_4}
-    let result = problem.evaluate(&config);
+    let problem = MinimumVertexCover::new(graph, vec![1i64; 5]);
+    let config = vec![true, false, false, true, true]; // {v_0, v_3, v_4}
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 3);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 3);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 3);
 }
diff --git a/src/unit_tests/models/graph/mixed_chinese_postman.rs b/src/unit_tests/models/graph/mixed_chinese_postman.rs
index a0ca382b3..5c8b3cbc8 100644
--- a/src/unit_tests/models/graph/mixed_chinese_postman.rs
+++ b/src/unit_tests/models/graph/mixed_chinese_postman.rs
@@ -1,10 +1,26 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_infers_graph_and_default_weights() {
+    let problem = MixedChinesePostman::<i64>::try_from(MixedChinesePostmanI64CreateSpec {
+        graph: vec![(0, 1)],
+        arcs: vec![(1, 0)],
+        num_vertices: None,
+        arc_weights: None,
+        edge_weights: None,
+    })
+    .unwrap();
+    assert_eq!(problem.num_vertices(), 2);
+    assert_eq!(problem.arc_weights(), &[1]);
+    assert_eq!(problem.edge_weights(), &[1]);
+}
 use crate::solvers::BruteForce;
 use crate::topology::MixedGraph;
 use crate::traits::Problem;
 use crate::types::Min;
 
-fn sample_instance() -> MixedChinesePostman<i32> {
+fn sample_instance() -> MixedChinesePostman<i64> {
     MixedChinesePostman::new(
         MixedGraph::new(
             5,
@@ -16,7 +32,7 @@ fn sample_instance() -> MixedChinesePostman<i32> {
     )
 }
 
-fn disconnected_instance() -> MixedChinesePostman<i32> {
+fn disconnected_instance() -> MixedChinesePostman<i64> {
     MixedChinesePostman::new(
         MixedGraph::new(
             6,
@@ -35,7 +51,7 @@ fn test_mixed_chinese_postman_creation_and_accessors() {
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_arcs(), 4);
     assert_eq!(problem.num_edges(), 4);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2]);
     assert_eq!(problem.arc_weights(), &[2, 3, 1, 4]);
     assert_eq!(problem.edge_weights(), &[2, 3, 1, 2]);
 }
@@ -45,7 +61,10 @@ fn test_mixed_chinese_postman_evaluate_optimal() {
     let problem = sample_instance();
 
     // Reverse (0,2) and (1,3), keep (0,4) and (4,2) forward.
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0]), Min(Some(21)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false, false]).unwrap(),
+        Min(Some(21))
+    );
 }
 
 #[test]
@@ -54,7 +73,9 @@ fn test_mixed_chinese_postman_evaluate_connected_instance() {
 
     // The available graph is strongly connected, so valid orientations
     // should return Some(cost).
-    let val = problem.evaluate(&[0, 0, 0, 0, 0]);
+    let val = problem
+        .evaluate(&vec![false, false, false, false, false])
+        .unwrap();
     assert!(val.0.is_some());
 }
 
@@ -65,11 +86,11 @@ fn test_mixed_chinese_postman_single_edge_walk() {
     let problem =
         MixedChinesePostman::new(MixedGraph::new(2, vec![], vec![(0, 1)]), vec![], vec![1]);
 
-    assert_eq!(problem.evaluate(&[0]), Min(Some(2)));
-    assert_eq!(problem.evaluate(&[1]), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![false]).unwrap(), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![true]).unwrap(), Min(Some(2)));
 
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_some());
+    assert!(solver.solve(&problem).unwrap().is_some());
 }
 
 #[test]
@@ -81,19 +102,28 @@ fn test_mixed_chinese_postman_rejects_disconnected_graph() {
         vec![1, 1],
     );
 
-    assert_eq!(problem.evaluate(&[0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1]), Min(None));
-    assert_eq!(problem.evaluate(&[1, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[1, 1]), Min(None));
+    assert_eq!(problem.evaluate(&vec![false, false]).unwrap(), Min(None));
+    assert_eq!(problem.evaluate(&vec![false, true]).unwrap(), Min(None));
+    assert_eq!(problem.evaluate(&vec![true, false]).unwrap(), Min(None));
+    assert_eq!(problem.evaluate(&vec![true, true]).unwrap(), Min(None));
 }
 
 #[test]
 fn test_mixed_chinese_postman_rejects_wrong_config_length() {
     let problem = sample_instance();
 
-    assert_eq!(problem.evaluate(&[]), Min(None));
-    assert_eq!(problem.evaluate(&[1, 1, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0, 1]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, true, false, false, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -102,11 +132,12 @@ fn test_mixed_chinese_postman_solver_finds_optimal() {
     let solver = BruteForce::new();
 
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("expected an optimal orientation");
-    assert!(problem.is_valid_solution(&solution));
+    assert!(problem.is_valid_solution(&solution).unwrap());
     // The optimal cost should be 21.
-    assert_eq!(problem.evaluate(&solution), Min(Some(21)));
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(21)));
 }
 
 #[test]
@@ -114,7 +145,7 @@ fn test_mixed_chinese_postman_serialization_roundtrip() {
     let problem = sample_instance();
 
     let json = serde_json::to_string(&problem).unwrap();
-    let restored: MixedChinesePostman<i32> = serde_json::from_str(&json).unwrap();
+    let restored: MixedChinesePostman<i64> = serde_json::from_str(&json).unwrap();
 
     assert_eq!(restored.num_vertices(), 5);
     assert_eq!(restored.num_arcs(), 4);
@@ -126,7 +157,25 @@ fn test_mixed_chinese_postman_serialization_roundtrip() {
 #[test]
 fn test_mixed_chinese_postman_problem_name() {
     assert_eq!(
-        <MixedChinesePostman<i32> as Problem>::NAME,
+        <MixedChinesePostman<i64> as Problem>::NAME,
         "MixedChinesePostman"
     );
 }
+
+#[test]
+fn test_mixed_chinese_postman_ignores_isolated_vertices() {
+    let problem = MixedChinesePostman::new(
+        MixedGraph::new(
+            8,
+            vec![(5, 3), (1, 4), (0, 1), (2, 4), (0, 5)],
+            vec![(4, 2), (0, 4), (0, 2), (1, 3)],
+        ),
+        vec![4, 5, 1, 12, 9],
+        vec![6, 1, 13, 7],
+    );
+
+    assert_eq!(
+        problem.evaluate(&vec![false, true, true, true]).unwrap(),
+        Min(Some(69))
+    );
+}
diff --git a/src/unit_tests/models/graph/monochromatic_triangle.rs b/src/unit_tests/models/graph/monochromatic_triangle.rs
index 26cda983f..54f7a56f8 100644
--- a/src/unit_tests/models/graph/monochromatic_triangle.rs
+++ b/src/unit_tests/models/graph/monochromatic_triangle.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -19,7 +20,7 @@ fn test_monochromatic_triangle_creation() {
     // K4 has 4 triangles
     assert_eq!(problem.triangles().len(), 4);
     // One binary variable per edge
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert_eq!(problem.graph().num_vertices(), 4);
 }
 
@@ -32,23 +33,35 @@ fn test_monochromatic_triangle_evaluate_valid() {
     //   Triangle (0,1,3): edges 0,2,4 -> 0,1,0 -> mixed
     //   Triangle (0,2,3): edges 1,2,5 -> 0,1,1 -> mixed
     //   Triangle (1,2,3): edges 3,4,5 -> 1,0,1 -> mixed
-    assert!(problem.evaluate(&[0, 0, 1, 1, 0, 1]));
+    assert!(problem
+        .evaluate(&vec![false, false, true, true, false, true])
+        .unwrap());
 }
 
 #[test]
 fn test_monochromatic_triangle_evaluate_invalid() {
     let problem = k4_instance();
     // All edges color 0: every triangle is monochromatic
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![false, false, false, false, false, false])
+        .unwrap());
     // All edges color 1: every triangle is monochromatic
-    assert!(!problem.evaluate(&[1, 1, 1, 1, 1, 1]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, true, true, true])
+        .unwrap());
 }
 
 #[test]
 fn test_monochromatic_triangle_evaluate_wrong_length() {
     let problem = k4_instance();
-    assert!(!problem.evaluate(&[0, 1, 0]));
-    assert!(!problem.evaluate(&[0, 1, 0, 0, 1, 1, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![false, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![false, true, false, false, true, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -56,18 +69,18 @@ fn test_monochromatic_triangle_triangle_free_graph() {
     // A path graph 0-1-2 has no triangles, so any coloring is valid.
     let problem = MonochromaticTriangle::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
     assert_eq!(problem.triangles().len(), 0);
-    assert!(problem.evaluate(&[0, 0]));
-    assert!(problem.evaluate(&[1, 1]));
-    assert!(problem.evaluate(&[0, 1]));
+    assert!(problem.evaluate(&vec![false, false]).unwrap());
+    assert!(problem.evaluate(&vec![true, true]).unwrap());
+    assert!(problem.evaluate(&vec![false, true]).unwrap());
 }
 
 #[test]
 fn test_monochromatic_triangle_brute_force_k4() {
     let problem = k4_instance();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
@@ -82,7 +95,7 @@ fn test_monochromatic_triangle_brute_force_k6_no_solution() {
     let problem = MonochromaticTriangle::new(SimpleGraph::new(6, edges));
     assert_eq!(problem.num_edges(), 15);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -96,9 +109,9 @@ fn test_monochromatic_triangle_brute_force_k5_has_solution() {
     }
     let problem = MonochromaticTriangle::new(SimpleGraph::new(5, edges));
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/multiple_choice_branching.rs b/src/unit_tests/models/graph/multiple_choice_branching.rs
index 80ceb6750..c4054593d 100644
--- a/src/unit_tests/models/graph/multiple_choice_branching.rs
+++ b/src/unit_tests/models/graph/multiple_choice_branching.rs
@@ -1,10 +1,27 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_invalid_partition() {
+    assert_eq!(
+        MultipleChoiceBranchingCreateSpec::FIELDS[3].name,
+        "partition"
+    );
+    let result = MultipleChoiceBranching::try_from(MultipleChoiceBranchingCreateSpec {
+        arcs: vec![(0, 1)],
+        num_vertices: Some(2),
+        weights: vec![1],
+        partition: vec![],
+        threshold: 1,
+    });
+    assert!(result.is_err());
+}
 use crate::solvers::BruteForce;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 use serde_json;
 
-fn yes_instance() -> MultipleChoiceBranching<i32> {
+fn yes_instance() -> MultipleChoiceBranching<i64> {
     MultipleChoiceBranching::new(
         DirectedGraph::new(
             6,
@@ -25,7 +42,7 @@ fn yes_instance() -> MultipleChoiceBranching<i32> {
     )
 }
 
-fn no_instance() -> MultipleChoiceBranching<i32> {
+fn no_instance() -> MultipleChoiceBranching<i64> {
     MultipleChoiceBranching::new(
         DirectedGraph::new(3, vec![(0, 1), (1, 2)]),
         vec![2, 2],
@@ -41,7 +58,7 @@ fn test_multiple_choice_branching_creation_and_accessors() {
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_arcs(), 8);
     assert_eq!(problem.num_partition_groups(), 4);
-    assert_eq!(problem.dims(), vec![2; 8]);
+    assert_eq!(problem.dimensions(), vec![2; 8]);
     assert_eq!(problem.graph().arcs().len(), 8);
     assert_eq!(problem.weights(), &[3, 2, 4, 1, 2, 3, 1, 3]);
     assert_eq!(
@@ -110,26 +127,39 @@ fn test_multiple_choice_branching_partition_validation_missing_arc() {
 #[test]
 fn test_multiple_choice_branching_evaluate_yes_instance() {
     let problem = yes_instance();
-    assert!(problem.evaluate(&[1, 0, 1, 0, 0, 1, 0, 1]));
-    assert!(problem.is_valid_solution(&[1, 0, 1, 0, 0, 1, 0, 1]));
+    assert!(problem
+        .evaluate(&vec![true, false, true, false, false, true, false, true])
+        .unwrap());
+    assert!(problem
+        .is_valid_solution(&[true, false, true, false, false, true, false, true])
+        .unwrap());
 }
 
 #[test]
 fn test_multiple_choice_branching_rejects_partition_violation() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, false, false, false, false, false, false])
+        .unwrap());
 }
 
 #[test]
 fn test_multiple_choice_branching_rejects_wrong_config_length() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[1, 0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_multiple_choice_branching_rejects_non_binary_config_value() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[2, 0, 1, 0, 0, 1, 0, 1]));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, false, true, false, false, true, false, true])
+    )
+    .is_err());
 }
 
 #[test]
@@ -140,7 +170,7 @@ fn test_multiple_choice_branching_rejects_indegree_violation() {
         vec![vec![0], vec![1]],
         1,
     );
-    assert!(!problem.evaluate(&[1, 1]));
+    assert!(!problem.evaluate(&vec![true, true]).unwrap());
 }
 
 #[test]
@@ -151,13 +181,15 @@ fn test_multiple_choice_branching_rejects_cycle_violation() {
         vec![vec![0], vec![1], vec![2]],
         1,
     );
-    assert!(!problem.evaluate(&[1, 1, 1]));
+    assert!(!problem.evaluate(&vec![true, true, true]).unwrap());
 }
 
 #[test]
 fn test_multiple_choice_branching_rejects_threshold_violation() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[1, 0, 1, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, false, true, false, false, false, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -165,29 +197,29 @@ fn test_multiple_choice_branching_solver_issue_examples() {
     let yes_problem = yes_instance();
     let solver = BruteForce::new();
 
-    let solution = solver.find_witness(&yes_problem);
+    let solution = solver.solve(&yes_problem).unwrap();
     assert!(solution.is_some());
-    assert!(yes_problem.evaluate(&solution.unwrap()));
+    assert!(yes_problem.evaluate(&solution.unwrap()).unwrap());
 
-    let all_solutions = solver.find_all_witnesses(&yes_problem);
+    let all_solutions = solver.find_all_witnesses(&yes_problem).unwrap();
     assert!(!all_solutions.is_empty());
-    assert!(all_solutions.contains(&vec![1, 0, 1, 0, 0, 1, 0, 1]));
+    assert!(all_solutions.contains(&vec![true, false, true, false, false, true, false, true]));
     for config in &all_solutions {
-        assert!(yes_problem.evaluate(config));
+        assert!(yes_problem.evaluate(config).unwrap());
     }
 
     let no_problem = no_instance();
-    assert!(solver.find_witness(&no_problem).is_none());
+    assert!(solver.solve(&no_problem).unwrap().is_none());
 }
 
 #[test]
 fn test_multiple_choice_branching_paper_example() {
     let problem = yes_instance();
-    let config = vec![1, 0, 1, 0, 0, 1, 0, 1];
+    let config = vec![true, false, true, false, false, true, false, true];
 
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
-    let all_solutions = BruteForce::new().find_all_witnesses(&problem);
+    let all_solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert_eq!(all_solutions.len(), 11);
     assert!(all_solutions.contains(&config));
 }
@@ -196,7 +228,7 @@ fn test_multiple_choice_branching_paper_example() {
 fn test_multiple_choice_branching_serialization() {
     let problem = yes_instance();
     let json = serde_json::to_string(&problem).unwrap();
-    let deserialized: MultipleChoiceBranching<i32> = serde_json::from_str(&json).unwrap();
+    let deserialized: MultipleChoiceBranching<i64> = serde_json::from_str(&json).unwrap();
     assert_eq!(deserialized.num_vertices(), 6);
     assert_eq!(deserialized.num_arcs(), 8);
     assert_eq!(deserialized.threshold(), &10);
@@ -210,7 +242,7 @@ fn test_multiple_choice_branching_deserialize_rejects_weight_length_mismatch() {
         "partition": [[0]],
         "threshold": 1
     }"#;
-    let result: Result<MultipleChoiceBranching<i32>, _> = serde_json::from_str(json);
+    let result: Result<MultipleChoiceBranching<i64>, _> = serde_json::from_str(json);
     let err = result.unwrap_err().to_string();
     assert!(err.contains("weights length must match"), "got: {err}");
 }
@@ -223,7 +255,7 @@ fn test_multiple_choice_branching_deserialize_rejects_invalid_partition() {
         "partition": [[1]],
         "threshold": 1
     }"#;
-    let result: Result<MultipleChoiceBranching<i32>, _> = serde_json::from_str(json);
+    let result: Result<MultipleChoiceBranching<i64>, _> = serde_json::from_str(json);
     let err = result.unwrap_err().to_string();
     assert!(err.contains("partition"), "got: {err}");
 }
diff --git a/src/unit_tests/models/graph/multiple_copy_file_allocation.rs b/src/unit_tests/models/graph/multiple_copy_file_allocation.rs
index 17f0cad62..f8b910cf7 100644
--- a/src/unit_tests/models/graph/multiple_copy_file_allocation.rs
+++ b/src/unit_tests/models/graph/multiple_copy_file_allocation.rs
@@ -1,5 +1,18 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_preserves_isolated_vertices() {
+    let problem = MultipleCopyFileAllocation::try_from(MultipleCopyFileAllocationCreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: Some(3),
+        usage: vec![1, 1, 1],
+        storage: vec![2, 2, 2],
+    })
+    .unwrap();
+    assert_eq!(problem.num_vertices(), 3);
+}
+use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -18,18 +31,31 @@ fn test_multiple_copy_file_allocation_creation() {
     assert_eq!(problem.num_edges(), 6);
     assert_eq!(problem.usage(), &[10; 6]);
     assert_eq!(problem.storage(), &[1; 6]);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert!(MultipleCopyFileAllocation::variant().is_empty());
 }
 
 #[test]
 fn test_multiple_copy_file_allocation_total_cost_and_validity() {
     let problem = cycle_instance();
-    let config = vec![0, 1, 0, 1, 0, 1];
+    let config = vec![false, true, false, true, false, true];
 
-    assert_eq!(problem.total_cost(&config), Some(33));
-    assert!(problem.is_valid_solution(&config));
-    assert_eq!(problem.evaluate(&config), Min(Some(33)));
+    assert_eq!(problem.total_cost(&config).unwrap(), Some(33));
+    assert!(problem.is_valid_solution(&config).unwrap());
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(33)));
+}
+
+#[test]
+fn test_multiple_copy_file_allocation_reports_cost_overflow() {
+    let problem = MultipleCopyFileAllocation::new(
+        SimpleGraph::new(2, vec![(0, 1)]),
+        vec![0, 0],
+        vec![i64::MAX, 1],
+    );
+    assert!(matches!(
+        problem.evaluate(&vec![true, true]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
 }
 
 #[test]
@@ -39,46 +65,57 @@ fn test_multiple_copy_file_allocation_uses_per_vertex_costs() {
         vec![1, 10, 100, 1000],
         vec![3, 5, 7, 11],
     );
-    let config = vec![1, 0, 1, 0];
+    let config = vec![true, false, true, false];
 
-    assert_eq!(problem.total_cost(&config), Some(1020));
-    assert!(problem.is_valid_solution(&config));
-    assert_eq!(problem.evaluate(&config), Min(Some(1020)));
+    assert_eq!(problem.total_cost(&config).unwrap(), Some(1020));
+    assert!(problem.is_valid_solution(&config).unwrap());
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(1020)));
 }
 
 #[test]
 fn test_multiple_copy_file_allocation_invalid_configs() {
     let problem = cycle_instance();
 
-    assert_eq!(problem.total_cost(&[]), None);
-    assert_eq!(problem.evaluate(&[]), Min(None));
-
-    assert_eq!(problem.total_cost(&[0, 1, 2, 1, 0, 1]), None);
-    assert_eq!(problem.evaluate(&[0, 1, 2, 1, 0, 1]), Min(None));
-
-    assert_eq!(problem.total_cost(&[0, 0, 0, 0, 0, 0]), None);
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0, 0]), Min(None));
+    assert_eq!(problem.total_cost(&[]).unwrap(), None);
+    assert!(matches!(
+        problem.evaluate(&vec![]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([false, true, 2, true, false, true])
+    )
+    .is_err());
+
+    assert_eq!(problem.total_cost(&[false; 6]).unwrap(), None);
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, false, false, false, false, false])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_multiple_copy_file_allocation_unreachable_component_is_invalid() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (2, 3)]);
     let problem = MultipleCopyFileAllocation::new(graph, vec![5; 4], vec![1; 4]);
-    let config = vec![1, 0, 0, 0];
+    let config = vec![true, false, false, false];
 
-    assert_eq!(problem.total_cost(&config), None);
-    assert!(!problem.is_valid_solution(&config));
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert_eq!(problem.total_cost(&config).unwrap(), None);
+    assert!(!problem.is_valid_solution(&config).unwrap());
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_multiple_copy_file_allocation_all_copies_valid() {
     let problem = cycle_instance();
     // Placing copies at all vertices: storage = 6, access = 0, total = 6
-    let config = vec![1, 1, 1, 1, 1, 1];
-    assert_eq!(problem.total_cost(&config), Some(6));
-    assert!(problem.is_valid_solution(&config));
-    assert_eq!(problem.evaluate(&config), Min(Some(6)));
+    let config = vec![true, true, true, true, true, true];
+    assert_eq!(problem.total_cost(&config).unwrap(), Some(6));
+    assert!(problem.is_valid_solution(&config).unwrap());
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -86,13 +123,12 @@ fn test_multiple_copy_file_allocation_solver() {
     let problem = cycle_instance();
     let solver = BruteForce::new();
 
-    let witness = solver.find_witness(&problem).unwrap();
-    assert!(problem.is_valid_solution(&witness));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert!(problem.is_valid_solution(&witness).unwrap());
 
     // The minimum cost on C6 with uniform usage=10, storage=1 should be achieved
     // by placing copies at all 6 vertices (cost = 6)
-    let solution = solver.solve(&problem);
-    assert_eq!(solution, Min(Some(6)));
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -104,19 +140,26 @@ fn test_multiple_copy_file_allocation_serialization() {
     assert_eq!(restored.graph().num_vertices(), 6);
     assert_eq!(restored.usage(), &[10; 6]);
     assert_eq!(restored.storage(), &[1; 6]);
-    assert_eq!(restored.total_cost(&[0, 1, 0, 1, 0, 1]), Some(33));
+    assert_eq!(
+        restored
+            .total_cost(&[false, true, false, true, false, true])
+            .unwrap(),
+        Some(33)
+    );
 }
 
 #[test]
 fn test_multiple_copy_file_allocation_paper_example() {
     let problem = cycle_instance();
-    let config = vec![0, 1, 0, 1, 0, 1];
+    let config = vec![false, true, false, true, false, true];
 
-    assert_eq!(problem.evaluate(&config), Min(Some(33)));
-    assert_eq!(problem.total_cost(&config), Some(33));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(33)));
+    assert_eq!(problem.total_cost(&config).unwrap(), Some(33));
 
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     // The optimal is placing all 6 copies (cost=6), check that witness exists
-    assert!(all.iter().any(|c| problem.total_cost(c) == Some(6)));
+    assert!(all
+        .iter()
+        .any(|config| problem.total_cost(config).unwrap() == Some(6)));
 }
diff --git a/src/unit_tests/models/graph/optimal_linear_arrangement.rs b/src/unit_tests/models/graph/optimal_linear_arrangement.rs
index 91e48c737..cd433e63d 100644
--- a/src/unit_tests/models/graph/optimal_linear_arrangement.rs
+++ b/src/unit_tests/models/graph/optimal_linear_arrangement.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -24,13 +25,13 @@ fn test_optimallineararrangement_basic() {
     let problem = issue_example();
 
     // Check dims: 6 variables, each with domain size 6
-    assert_eq!(problem.dims(), vec![6, 6, 6, 6, 6, 6]);
+    assert_eq!(problem.dimensions(), vec![6, 6, 6, 6, 6, 6]);
 
     // Identity arrangement: f(i) = i
     // Cost: |0-1| + |1-2| + |2-3| + |3-4| + |4-5| + |0-3| + |2-5| = 1+1+1+1+1+3+3 = 11
     let config = vec![0, 1, 2, 3, 4, 5];
-    assert_eq!(problem.evaluate(&config), Min(Some(11)));
-    assert_eq!(problem.total_edge_length(&config), Some(11));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(11)));
+    assert_eq!(problem.total_edge_length(&config).unwrap(), Some(11));
 }
 
 #[test]
@@ -39,8 +40,8 @@ fn test_optimallineararrangement_path() {
 
     // Identity arrangement on a path: each edge has length 1, total = 5
     let config = vec![0, 1, 2, 3, 4, 5];
-    assert_eq!(problem.evaluate(&config), Min(Some(5)));
-    assert_eq!(problem.total_edge_length(&config), Some(5));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(5)));
+    assert_eq!(problem.total_edge_length(&config).unwrap(), Some(5));
 }
 
 #[test]
@@ -48,16 +49,31 @@ fn test_optimallineararrangement_invalid_config() {
     let problem = issue_example();
 
     // Not a permutation: repeated value
-    assert_eq!(problem.evaluate(&[0, 0, 1, 2, 3, 4]), Min(None));
-    assert_eq!(problem.total_edge_length(&[0, 0, 1, 2, 3, 4]), None);
+    assert_eq!(
+        problem.evaluate(&vec![0, 0, 1, 2, 3, 4]).unwrap(),
+        Min(None)
+    );
+    assert_eq!(
+        problem.total_edge_length(&[0, 0, 1, 2, 3, 4]).unwrap(),
+        None
+    );
 
     // Out of range
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 4, 6]), Min(None));
-    assert_eq!(problem.total_edge_length(&[0, 1, 2, 3, 4, 6]), None);
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 4, 6]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert_eq!(
+        problem.total_edge_length(&[0, 1, 2, 3, 4, 6]).unwrap(),
+        None
+    );
 
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(None));
-    assert_eq!(problem.total_edge_length(&[0, 1, 2]), None);
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert_eq!(problem.total_edge_length(&[0, 1, 2]).unwrap(), None);
 }
 
 #[test]
@@ -70,7 +86,10 @@ fn test_optimallineararrangement_serialization() {
 
     // Verify evaluation is consistent after round-trip
     let config = vec![0, 1, 2, 3, 4, 5];
-    assert_eq!(problem.evaluate(&config), deserialized.evaluate(&config));
+    assert_eq!(
+        problem.evaluate(&config).unwrap(),
+        deserialized.evaluate(&config).unwrap()
+    );
 }
 
 #[test]
@@ -81,10 +100,10 @@ fn test_optimallineararrangement_solver() {
     let problem = OptimalLinearArrangement::new(graph);
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let sol = solution.unwrap();
-    assert_eq!(problem.evaluate(&sol), Min(Some(4)));
+    assert_eq!(problem.evaluate(&sol).unwrap(), Min(Some(4)));
 }
 
 #[test]
@@ -94,7 +113,8 @@ fn test_optimallineararrangement_solver_aggregate() {
     let problem = OptimalLinearArrangement::new(graph);
 
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(4)));
 }
 
@@ -105,15 +125,16 @@ fn test_optimallineararrangement_empty_graph() {
     let problem = OptimalLinearArrangement::new(graph);
 
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(0)));
 
-    let all_witnesses = solver.find_all_witnesses(&problem);
+    let all_witnesses = solver.find_all_witnesses(&problem).unwrap();
     // All 3! = 6 permutations should be witnesses (all achieve cost 0)
     assert_eq!(all_witnesses.len(), 6);
     for s in &all_witnesses {
-        assert_eq!(problem.evaluate(s), Min(Some(0)));
-        assert_eq!(problem.total_edge_length(s), Some(0));
+        assert_eq!(problem.evaluate(s).unwrap(), Min(Some(0)));
+        assert_eq!(problem.total_edge_length(s).unwrap(), Some(0));
     }
 }
 
@@ -122,13 +143,13 @@ fn test_optimallineararrangement_single_vertex() {
     let graph = SimpleGraph::new(1, vec![]);
     let problem = OptimalLinearArrangement::new(graph);
 
-    assert_eq!(problem.dims(), vec![1]);
-    assert_eq!(problem.evaluate(&[0]), Min(Some(0)));
-    assert_eq!(problem.total_edge_length(&[0]), Some(0));
+    assert_eq!(problem.dimensions(), vec![1]);
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Min(Some(0)));
+    assert_eq!(problem.total_edge_length(&[0]).unwrap(), Some(0));
 }
 
 #[test]
-fn test_optimallineararrangement_size_getters() {
+fn test_optimallineararrangement_parameter_getters() {
     let problem = issue_example();
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 7);
@@ -157,10 +178,10 @@ fn test_optimallineararrangement_two_vertices() {
     let problem = OptimalLinearArrangement::new(graph);
 
     // Both permutations [0,1] and [1,0] have cost 1
-    assert_eq!(problem.evaluate(&[0, 1]), Min(Some(1)));
-    assert_eq!(problem.evaluate(&[1, 0]), Min(Some(1)));
-    assert_eq!(problem.total_edge_length(&[0, 1]), Some(1));
-    assert_eq!(problem.total_edge_length(&[1, 0]), Some(1));
+    assert_eq!(problem.evaluate(&vec![0, 1]).unwrap(), Min(Some(1)));
+    assert_eq!(problem.evaluate(&vec![1, 0]).unwrap(), Min(Some(1)));
+    assert_eq!(problem.total_edge_length(&[0, 1]).unwrap(), Some(1));
+    assert_eq!(problem.total_edge_length(&[1, 0]).unwrap(), Some(1));
 }
 
 #[test]
@@ -170,18 +191,18 @@ fn test_optimallineararrangement_permutation_matters() {
     let problem = OptimalLinearArrangement::new(graph);
 
     // Identity: cost = 1+1+1 = 3
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3]), Min(Some(3)));
-    assert_eq!(problem.total_edge_length(&[0, 1, 2, 3]), Some(3));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap(), Min(Some(3)));
+    assert_eq!(problem.total_edge_length(&[0, 1, 2, 3]).unwrap(), Some(3));
 
     // Reversed: cost = 1+1+1 = 3
-    assert_eq!(problem.evaluate(&[3, 2, 1, 0]), Min(Some(3)));
-    assert_eq!(problem.total_edge_length(&[3, 2, 1, 0]), Some(3));
+    assert_eq!(problem.evaluate(&vec![3, 2, 1, 0]).unwrap(), Min(Some(3)));
+    assert_eq!(problem.total_edge_length(&[3, 2, 1, 0]).unwrap(), Some(3));
 
     // Scrambled: [2, 0, 3, 1] -> f(0)=2, f(1)=0, f(2)=3, f(3)=1
     // |2-0| + |0-3| + |3-1| = 2+3+2 = 7
     let scrambled = vec![2, 0, 3, 1];
-    assert_eq!(problem.evaluate(&scrambled), Min(Some(7)));
-    assert_eq!(problem.total_edge_length(&scrambled), Some(7));
+    assert_eq!(problem.evaluate(&scrambled).unwrap(), Min(Some(7)));
+    assert_eq!(problem.total_edge_length(&scrambled).unwrap(), Some(7));
 }
 
 #[test]
@@ -208,14 +229,15 @@ fn test_optimallineararrangement_complete_graph_k4() {
     let problem = OptimalLinearArrangement::new(graph);
 
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(10)));
 
-    let all_witnesses = solver.find_all_witnesses(&problem);
+    let all_witnesses = solver.find_all_witnesses(&problem).unwrap();
     // All 4! = 24 permutations should be witnesses since all have cost 10
     assert_eq!(all_witnesses.len(), 24);
     for sol in &all_witnesses {
-        assert_eq!(problem.evaluate(sol), Min(Some(10)));
-        assert_eq!(problem.total_edge_length(sol), Some(10));
+        assert_eq!(problem.evaluate(sol).unwrap(), Min(Some(10)));
+        assert_eq!(problem.total_edge_length(sol).unwrap(), Some(10));
     }
 }
diff --git a/src/unit_tests/models/graph/partial_feedback_edge_set.rs b/src/unit_tests/models/graph/partial_feedback_edge_set.rs
index 2f6974355..c39b3895a 100644
--- a/src/unit_tests/models/graph/partial_feedback_edge_set.rs
+++ b/src/unit_tests/models/graph/partial_feedback_edge_set.rs
@@ -1,4 +1,20 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_constructs_model() {
+    assert_eq!(
+        PartialFeedbackEdgeSetCreateSpec::FIELDS[2].name,
+        "max_cycle_length"
+    );
+    let problem = PartialFeedbackEdgeSet::try_from(PartialFeedbackEdgeSetCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        budget: 1,
+        max_cycle_length: 3,
+    })
+    .unwrap();
+    assert_eq!(problem.budget(), 1);
+}
 use crate::solvers::BruteForce;
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
@@ -28,7 +44,7 @@ fn no_instance() -> PartialFeedbackEdgeSet<SimpleGraph> {
     PartialFeedbackEdgeSet::new(issue_graph(), 2, 4)
 }
 
-fn select_edges<G: Graph>(graph: &G, selected_edges: &[(usize, usize)]) -> Vec<usize> {
+fn select_edges<G: Graph>(graph: &G, selected_edges: &[(usize, usize)]) -> Vec<bool> {
     let chosen: std::collections::BTreeSet<_> = selected_edges
         .iter()
         .copied()
@@ -37,7 +53,7 @@ fn select_edges<G: Graph>(graph: &G, selected_edges: &[(usize, usize)]) -> Vec<u
     graph
         .edges()
         .into_iter()
-        .map(|(u, v)| usize::from(chosen.contains(&super::normalize_edge(u, v))))
+        .map(|(u, v)| chosen.contains(&super::normalize_edge(u, v)))
         .collect()
 }
 
@@ -51,14 +67,14 @@ fn test_partial_feedback_edge_set_creation() {
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 9);
     assert_eq!(problem.num_variables(), 9);
-    assert_eq!(problem.dims(), vec![2; 9]);
+    assert_eq!(problem.dimensions(), vec![2; 9]);
 }
 
 #[test]
 fn test_partial_feedback_edge_set_accepts_correct_issue_solution() {
     let problem = yes_instance();
     let config = select_edges(problem.graph(), &[(0, 2), (2, 3), (3, 4)]);
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
     assert!(problem.is_valid_solution(&config));
 }
 
@@ -66,28 +82,33 @@ fn test_partial_feedback_edge_set_accepts_correct_issue_solution() {
 fn test_partial_feedback_edge_set_rejects_under_budget_instance() {
     let problem = no_instance();
     let config = select_edges(problem.graph(), &[(0, 2), (2, 3), (3, 4)]);
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_partial_feedback_edge_set_rejects_missing_cycle_hit() {
     let problem = yes_instance();
     let config = select_edges(problem.graph(), &[(0, 2), (3, 4), (3, 5)]);
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_partial_feedback_edge_set_rejects_wrong_length_config() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[0, 1, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![false, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_partial_feedback_edge_set_rejects_non_binary_entries() {
     let problem = yes_instance();
-    let mut config = select_edges(problem.graph(), &[(0, 2), (2, 3), (3, 4)]);
-    config[0] = 2;
-    assert!(!problem.evaluate(&config));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, 0, 0, 0, 0, 0, 0, 0, 0]),
+    )
+    .is_err());
 }
 
 #[test]
@@ -95,20 +116,20 @@ fn test_partial_feedback_edge_set_solver_yes_and_no_instances() {
     let solver = BruteForce::new();
 
     let yes_problem = yes_instance();
-    let solution = solver.find_witness(&yes_problem).unwrap();
-    assert!(yes_problem.evaluate(&solution));
+    let solution = solver.solve(&yes_problem).unwrap().unwrap();
+    assert!(yes_problem.evaluate(&solution).unwrap());
 
     let no_problem = no_instance();
-    assert!(solver.find_witness(&no_problem).is_none());
+    assert!(solver.solve(&no_problem).unwrap().is_none());
 }
 
 #[test]
 fn test_partial_feedback_edge_set_paper_example() {
     let problem = yes_instance();
     let config = select_edges(problem.graph(), &[(0, 2), (2, 3), (3, 4)]);
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
-    let satisfying = BruteForce::new().find_all_witnesses(&problem);
+    let satisfying = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert_eq!(satisfying.len(), 5);
     assert!(satisfying.iter().any(|candidate| candidate == &config));
 }
diff --git a/src/unit_tests/models/graph/partition_into_cliques.rs b/src/unit_tests/models/graph/partition_into_cliques.rs
index 0f5fff26b..2ee0b8fe3 100644
--- a/src/unit_tests/models/graph/partition_into_cliques.rs
+++ b/src/unit_tests/models/graph/partition_into_cliques.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -30,7 +31,7 @@ fn test_partition_into_cliques_creation() {
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 9);
     assert_eq!(problem.num_cliques(), 3);
-    assert_eq!(problem.dims(), vec![3; 6]);
+    assert_eq!(problem.dimensions(), vec![3; 6]);
     assert_eq!(problem.graph().num_vertices(), 6);
 }
 
@@ -39,10 +40,10 @@ fn test_partition_into_cliques_evaluate_positive() {
     let problem = two_triangle_instance();
 
     // Group 0 = {0,1,2} (triangle), Group 1 = {3,4,5} (triangle)
-    assert!(problem.evaluate(&[0, 0, 0, 1, 1, 1]));
+    assert!(problem.evaluate(&vec![0, 0, 0, 1, 1, 1]).unwrap());
 
     // Each vertex in its own group (trivially valid)
-    assert!(problem.evaluate(&[0, 1, 2, 0, 1, 2]));
+    assert!(problem.evaluate(&vec![0, 1, 2, 0, 1, 2]).unwrap());
 }
 
 #[test]
@@ -50,21 +51,30 @@ fn test_partition_into_cliques_evaluate_negative() {
     let problem = two_triangle_instance();
 
     // Group 0 = {0,1,2,3}: 0-1, 0-2, 1-2, 0-3 present, but 1-3 missing
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 1, 2]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 0, 1, 2]).unwrap());
 }
 
 #[test]
 fn test_partition_into_cliques_evaluate_wrong_config_length() {
     let problem = two_triangle_instance();
-    assert!(!problem.evaluate(&[0, 1, 0]));
-    assert!(!problem.evaluate(&[0, 1, 0, 0, 1, 1, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0, 0, 1, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_partition_into_cliques_evaluate_out_of_range_group() {
     let problem = two_triangle_instance();
     // Group 3 doesn't exist (num_cliques=3, valid groups are 0,1,2)
-    assert!(!problem.evaluate(&[0, 1, 3, 0, 1, 2]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 3, 0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -75,9 +85,9 @@ fn test_partition_into_cliques_brute_force_finds_solution() {
         2,
     );
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
@@ -85,17 +95,17 @@ fn test_partition_into_cliques_brute_force_no_solution() {
     // Path 0-1-2, K=1: {0,1,2} not a clique (missing edge 0-2)
     let problem = PartitionIntoCliques::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), 1);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_partition_into_cliques_brute_force_all_valid() {
     // Complete graph K3, K=3: every assignment is valid
     let problem = PartitionIntoCliques::new(SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]), 3);
-    let solutions = BruteForce::new().find_all_witnesses(&problem);
+    let solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
diff --git a/src/unit_tests/models/graph/partition_into_forests.rs b/src/unit_tests/models/graph/partition_into_forests.rs
index bd849d811..de56c11ba 100644
--- a/src/unit_tests/models/graph/partition_into_forests.rs
+++ b/src/unit_tests/models/graph/partition_into_forests.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -21,7 +22,7 @@ fn test_partition_into_forests_creation() {
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 7);
     assert_eq!(problem.num_forests(), 2);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert_eq!(problem.graph().num_vertices(), 6);
 }
 
@@ -30,10 +31,10 @@ fn test_partition_into_forests_evaluate_positive() {
     let problem = two_triangle_instance();
 
     // config [0,1,1,0,1,1]: class0={0,3} (no intra-class edges), class1={1,2,4,5} (edges 1-2, 4-5, both trees)
-    assert!(problem.evaluate(&[0, 1, 1, 0, 1, 1]));
+    assert!(problem.evaluate(&vec![0, 1, 1, 0, 1, 1]).unwrap());
 
     // config [0,0,1,1,0,1]: class0={0,1,4} (edge 0-1 → path), class1={2,3,5} (no triangle edges remain)
-    assert!(problem.evaluate(&[0, 0, 1, 1, 0, 1]));
+    assert!(problem.evaluate(&vec![0, 0, 1, 1, 0, 1]).unwrap());
 }
 
 #[test]
@@ -45,7 +46,7 @@ fn test_partition_into_forests_evaluate_negative_k1() {
     );
 
     // Any single-class assignment must include a triangle → cycle
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 0, 0, 0]).unwrap());
 }
 
 #[test]
@@ -53,21 +54,30 @@ fn test_partition_into_forests_evaluate_cycle_in_class() {
     let problem = two_triangle_instance();
 
     // config [0,0,0,1,1,1]: class0={0,1,2} contains triangle 0-1-2-0 → cycle
-    assert!(!problem.evaluate(&[0, 0, 0, 1, 1, 1]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 1, 1, 1]).unwrap());
 }
 
 #[test]
 fn test_partition_into_forests_evaluate_wrong_config_length() {
     let problem = two_triangle_instance();
-    assert!(!problem.evaluate(&[0, 1, 0]));
-    assert!(!problem.evaluate(&[0, 1, 0, 0, 1, 1, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0, 0, 1, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_partition_into_forests_evaluate_out_of_range_class() {
     let problem = two_triangle_instance();
     // Class 2 doesn't exist (num_forests=2)
-    assert!(!problem.evaluate(&[0, 1, 2, 0, 1, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 0, 1, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -76,9 +86,9 @@ fn test_partition_into_forests_brute_force_finds_solution() {
     let problem =
         PartitionIntoForests::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (3, 0)]), 2);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
@@ -86,17 +96,17 @@ fn test_partition_into_forests_brute_force_no_solution() {
     // Single triangle, K=1: impossible
     let problem = PartitionIntoForests::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]), 1);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_partition_into_forests_brute_force_all_valid() {
     // Small acyclic graph (path 0-1-2), K=1: every assignment is valid
     let problem = PartitionIntoForests::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), 1);
-    let solutions = BruteForce::new().find_all_witnesses(&problem);
+    let solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
diff --git a/src/unit_tests/models/graph/partition_into_paths_of_length_2.rs b/src/unit_tests/models/graph/partition_into_paths_of_length_2.rs
index 3df87c0bd..a3421104a 100644
--- a/src/unit_tests/models/graph/partition_into_paths_of_length_2.rs
+++ b/src/unit_tests/models/graph/partition_into_paths_of_length_2.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -26,18 +27,18 @@ fn test_partition_into_paths_basic() {
     assert_eq!(problem.num_vertices(), 9);
     assert_eq!(problem.num_edges(), 10);
     assert_eq!(problem.num_groups(), 3);
-    assert_eq!(problem.dims(), vec![3; 9]);
+    assert_eq!(problem.dimensions(), vec![3; 9]);
 
     // Valid partition: {0,1,2}, {3,4,5}, {6,7,8}
     // Config: vertex i -> group i/3
     let valid_config = vec![0, 0, 0, 1, 1, 1, 2, 2, 2];
-    assert!(problem.evaluate(&valid_config));
+    assert!(problem.evaluate(&valid_config).unwrap());
 
     // Alternative valid partition: {0,1,3}, {2,4,5}, {6,7,8}
     // Group {0,1,3}: edges (0,1) and (0,3) — 2 edges, valid
     // Group {2,4,5}: edges (4,5) and (2,5) — 2 edges, valid
     let another_config = vec![0, 0, 1, 0, 1, 1, 2, 2, 2];
-    assert!(problem.evaluate(&another_config));
+    assert!(problem.evaluate(&another_config).unwrap());
 }
 
 #[test]
@@ -51,7 +52,7 @@ fn test_partition_into_paths_no_solution() {
     assert_eq!(problem.num_groups(), 2);
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none(), "Expected no solution for this graph");
 }
 
@@ -62,11 +63,11 @@ fn test_partition_into_paths_solver() {
     let problem = PartitionIntoPathsOfLength2::new(graph);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty(), "Expected at least one solution");
 
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -78,7 +79,7 @@ fn test_partition_into_paths_invalid_group_size() {
 
     // Config where group 0 has 4 vertices and group 1 has 2 vertices
     let bad_config = vec![0, 0, 0, 0, 1, 1];
-    assert!(!problem.evaluate(&bad_config));
+    assert!(!problem.evaluate(&bad_config).unwrap());
 }
 
 #[test]
@@ -90,7 +91,7 @@ fn test_partition_into_paths_insufficient_edges() {
     // Even a well-sized partition fails because groups lack edges
     let config = vec![0, 0, 0, 1, 1, 1];
     // Group {0,1,2}: only edge (0,1) — 1 edge < 2, invalid
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -101,7 +102,7 @@ fn test_partition_into_paths_triangle() {
 
     // Single group with all 3 vertices forming a triangle
     let config = vec![0, 0, 0];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -119,7 +120,10 @@ fn test_partition_into_paths_serialization() {
 
     // Verify evaluation is consistent
     let config = vec![0, 0, 0, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), deserialized.evaluate(&config));
+    assert_eq!(
+        problem.evaluate(&config).unwrap(),
+        deserialized.evaluate(&config).unwrap()
+    );
 }
 
 #[test]
@@ -130,7 +134,7 @@ fn test_partition_into_paths_invalid_vertex_count() {
 }
 
 #[test]
-fn test_partition_into_paths_size_getters() {
+fn test_partition_into_paths_parameter_getters() {
     let graph = SimpleGraph::new(9, vec![(0, 1), (1, 2), (3, 4), (4, 5), (6, 7), (7, 8)]);
     let problem = PartitionIntoPathsOfLength2::new(graph);
     assert_eq!(problem.num_vertices(), 9);
@@ -145,7 +149,10 @@ fn test_partition_into_paths_out_of_range_group() {
 
     // Group index out of range (q=2, so valid groups are 0 and 1)
     let config = vec![0, 0, 0, 2, 2, 2];
-    assert!(!problem.evaluate(&config));
+    assert!(matches!(
+        problem.evaluate(&config),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/partition_into_perfect_matchings.rs b/src/unit_tests/models/graph/partition_into_perfect_matchings.rs
index d9a5a32e1..8ea2f64a2 100644
--- a/src/unit_tests/models/graph/partition_into_perfect_matchings.rs
+++ b/src/unit_tests/models/graph/partition_into_perfect_matchings.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -14,7 +15,7 @@ fn test_partition_into_perfect_matchings_creation() {
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 4);
     assert_eq!(problem.num_matchings(), 2);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(problem.graph().num_vertices(), 4);
 }
 
@@ -23,10 +24,10 @@ fn test_partition_into_perfect_matchings_evaluate_positive() {
     let problem = four_vertex_instance();
 
     // Group 0 = {0,1} (edge 0-1), Group 1 = {2,3} (edge 2-3)
-    assert!(problem.evaluate(&[0, 0, 1, 1]));
+    assert!(problem.evaluate(&vec![0, 0, 1, 1]).unwrap());
 
     // Group 0 = {0,2} (edge 0-2), Group 1 = {1,3} (edge 1-3)
-    assert!(problem.evaluate(&[0, 1, 0, 1]));
+    assert!(problem.evaluate(&vec![0, 1, 0, 1]).unwrap());
 }
 
 #[test]
@@ -34,10 +35,10 @@ fn test_partition_into_perfect_matchings_evaluate_negative() {
     let problem = four_vertex_instance();
 
     // Group 0 = {0,1,2}: vertex 0 has neighbors 1 and 2 both in group => degree 2, not 1
-    assert!(!problem.evaluate(&[0, 0, 0, 1]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 1]).unwrap());
 
     // All in one group: each vertex has 2 neighbors in the group
-    assert!(!problem.evaluate(&[0, 0, 0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 0]).unwrap());
 }
 
 #[test]
@@ -45,30 +46,39 @@ fn test_partition_into_perfect_matchings_evaluate_odd_group() {
     // A group with an odd number of members can never be a perfect matching
     let problem = four_vertex_instance();
     // Group 0 = {0,1,2} (3 vertices), Group 1 = {3} (1 vertex)
-    assert!(!problem.evaluate(&[0, 0, 0, 1]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 1]).unwrap());
 }
 
 #[test]
 fn test_partition_into_perfect_matchings_evaluate_wrong_config_length() {
     let problem = four_vertex_instance();
-    assert!(!problem.evaluate(&[0, 1]));
-    assert!(!problem.evaluate(&[0, 1, 0, 0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0, 0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_partition_into_perfect_matchings_evaluate_out_of_range_group() {
     let problem = four_vertex_instance();
     // Group 2 doesn't exist (num_matchings=2, valid groups are 0,1)
-    assert!(!problem.evaluate(&[0, 1, 2, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_partition_into_perfect_matchings_brute_force_finds_solution() {
     let problem = four_vertex_instance();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
@@ -77,17 +87,17 @@ fn test_partition_into_perfect_matchings_brute_force_no_solution() {
     // Group {0,1,2} has 3 vertices (odd) so cannot be a perfect matching
     let problem = PartitionIntoPerfectMatchings::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), 1);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_partition_into_perfect_matchings_brute_force_all_valid() {
     // 2 vertices with edge (0,1), K=2: group {0,1} is a perfect matching
     let problem = PartitionIntoPerfectMatchings::new(SimpleGraph::new(2, vec![(0, 1)]), 2);
-    let solutions = BruteForce::new().find_all_witnesses(&problem);
+    let solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
diff --git a/src/unit_tests/models/graph/partition_into_triangles.rs b/src/unit_tests/models/graph/partition_into_triangles.rs
index f1ad4d4f8..42fb8c9c3 100644
--- a/src/unit_tests/models/graph/partition_into_triangles.rs
+++ b/src/unit_tests/models/graph/partition_into_triangles.rs
@@ -1,11 +1,10 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 
 #[test]
 fn test_partitionintotriangles_basic() {
-    use crate::traits::Problem;
-
     // 9-vertex YES instance: three disjoint triangles
     // Triangle 1: 0-1-2, Triangle 2: 3-4-5, Triangle 3: 6-7-8
     let graph = SimpleGraph::new(
@@ -26,32 +25,30 @@ fn test_partitionintotriangles_basic() {
 
     assert_eq!(problem.num_vertices(), 9);
     assert_eq!(problem.num_edges(), 9);
-    assert_eq!(problem.dims(), vec![3; 9]);
+    assert_eq!(problem.dimensions(), vec![3; 9]);
 
     // Valid partition: vertices 0,1,2 in group 0; 3,4,5 in group 1; 6,7,8 in group 2
-    assert!(problem.evaluate(&[0, 0, 0, 1, 1, 1, 2, 2, 2]));
+    assert!(problem.evaluate(&vec![0, 0, 0, 1, 1, 1, 2, 2, 2]).unwrap());
 
     // Invalid: wrong grouping (vertices 0,1,3 are not a triangle)
-    assert!(!problem.evaluate(&[0, 0, 1, 0, 1, 1, 2, 2, 2]));
+    assert!(!problem.evaluate(&vec![0, 0, 1, 0, 1, 1, 2, 2, 2]).unwrap());
 
     // Invalid: group sizes wrong (4 in group 0, 2 in group 1)
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 1, 1, 2, 2, 2]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 0, 1, 1, 2, 2, 2]).unwrap());
 }
 
 #[test]
 fn test_partitionintotriangles_no_solution() {
-    use crate::traits::Problem;
-
     // 6-vertex NO instance: path graph has no triangles at all
     let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]);
     let problem = PartitionIntoTriangles::new(graph);
 
     assert_eq!(problem.num_vertices(), 6);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
 
     // No valid partition exists since there are no triangles
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
@@ -64,16 +61,16 @@ fn test_partitionintotriangles_solver() {
     let problem = PartitionIntoTriangles::new(graph);
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let sol = solution.unwrap();
-    assert!(problem.evaluate(&sol));
+    assert!(problem.evaluate(&sol).unwrap());
 
     // All solutions should be valid
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all.is_empty());
     for s in &all {
-        assert!(problem.evaluate(s));
+        assert!(problem.evaluate(s).unwrap());
     }
 }
 
@@ -104,7 +101,10 @@ fn test_partitionintotriangles_config_out_of_range() {
     let problem = PartitionIntoTriangles::new(graph);
 
     // q = 1, so only group 0 is valid; group 1 is out of range
-    assert!(!problem.evaluate(&[0, 0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -114,12 +114,18 @@ fn test_partitionintotriangles_wrong_config_length() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
     let problem = PartitionIntoTriangles::new(graph);
 
-    assert!(!problem.evaluate(&[0, 0]));
-    assert!(!problem.evaluate(&[0, 0, 0, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
-fn test_partitionintotriangles_size_getters() {
+fn test_partitionintotriangles_parameter_getters() {
     let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (0, 2), (3, 4), (4, 5), (3, 5)]);
     let problem = PartitionIntoTriangles::new(graph);
     assert_eq!(problem.num_vertices(), 6);
@@ -136,9 +142,9 @@ fn test_partitionintotriangles_paper_example() {
     );
     let problem = PartitionIntoTriangles::new(graph);
     // Valid partition: {0,1,2} in group 0, {3,4,5} in group 1
-    assert!(problem.evaluate(&[0, 0, 0, 1, 1, 1]));
+    assert!(problem.evaluate(&vec![0, 0, 0, 1, 1, 1]).unwrap());
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
 }
diff --git a/src/unit_tests/models/graph/path_constrained_network_flow.rs b/src/unit_tests/models/graph/path_constrained_network_flow.rs
index 751cde06e..af1cf3617 100644
--- a/src/unit_tests/models/graph/path_constrained_network_flow.rs
+++ b/src/unit_tests/models/graph/path_constrained_network_flow.rs
@@ -1,4 +1,20 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_capacities_and_validates_paths() {
+    let problem = PathConstrainedNetworkFlow::try_from(PathConstrainedNetworkFlowCreateSpec {
+        arcs: vec![(0, 1), (1, 2)],
+        num_vertices: None,
+        capacities: None,
+        source: 0,
+        sink: 2,
+        paths: vec![vec![0, 1]],
+        requirement: 1,
+    })
+    .unwrap();
+    assert_eq!(problem.capacities(), &[1, 1]);
+}
 use crate::solvers::BruteForce;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
@@ -60,22 +76,25 @@ fn test_path_constrained_network_flow_creation() {
 #[test]
 fn test_path_constrained_network_flow_dims_use_path_bottlenecks() {
     let problem = yes_instance();
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2, 2]);
 }
 
 #[test]
 fn test_path_constrained_network_flow_evaluation_satisfying() {
     let problem = yes_instance();
-    assert!(problem.evaluate(&[1, 1, 0, 0, 1]));
-    assert!(problem.evaluate(&[1, 0, 1, 1, 0]));
+    assert!(problem.evaluate(&vec![1, 1, 0, 0, 1]).unwrap());
+    assert!(problem.evaluate(&vec![1, 0, 1, 1, 0]).unwrap());
 }
 
 #[test]
 fn test_path_constrained_network_flow_evaluation_unsatisfying() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0]));
-    assert!(!problem.evaluate(&[1, 1, 1, 0, 0]));
-    assert!(!problem.evaluate(&[1, 1, 0, 0]));
+    assert!(!problem.evaluate(&vec![1, 1, 0, 0, 0]).unwrap());
+    assert!(!problem.evaluate(&vec![1, 1, 1, 0, 0]).unwrap());
+    assert!(matches!(
+        problem.evaluate(&vec![1, 1, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -84,11 +103,13 @@ fn test_path_constrained_network_flow_solver_yes_and_no() {
     let no = no_instance();
     let solver = BruteForce::new();
 
-    let satisfying = solver.find_all_witnesses(&yes);
+    let satisfying = solver.find_all_witnesses(&yes).unwrap();
     assert_eq!(satisfying.len(), 2);
-    assert!(satisfying.iter().all(|config| yes.evaluate(config).0));
+    assert!(satisfying
+        .iter()
+        .all(|config| yes.evaluate(config).unwrap().0));
 
-    assert!(solver.find_witness(&no).is_none());
+    assert!(solver.solve(&no).unwrap().is_none());
 }
 
 #[test]
@@ -146,9 +167,9 @@ fn test_path_constrained_network_flow_paper_example() {
     let solver = BruteForce::new();
     let config = vec![1, 1, 0, 0, 1];
 
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all.len(), 2);
     assert!(all.contains(&config));
 }
diff --git a/src/unit_tests/models/graph/prize_collecting_steiner_forest.rs b/src/unit_tests/models/graph/prize_collecting_steiner_forest.rs
index d7efc585c..e5a801e5a 100644
--- a/src/unit_tests/models/graph/prize_collecting_steiner_forest.rs
+++ b/src/unit_tests/models/graph/prize_collecting_steiner_forest.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -7,14 +8,15 @@ use crate::types::Min;
 /// Canonical instance from issue #1026: path 0 - 1 - 2 with
 /// edge costs c(0,1)=1, c(1,2)=6, vertex prizes p = (5, 2, 5),
 /// beta = 1, omega = 2.
-fn canonical_problem() -> PrizeCollectingSteinerForest<SimpleGraph, i32> {
-    PrizeCollectingSteinerForest::<SimpleGraph, i32>::new(
+fn canonical_problem() -> PrizeCollectingSteinerForest<SimpleGraph, i64> {
+    PrizeCollectingSteinerForest::<SimpleGraph, i64>::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
         vec![5, 2, 5],
         vec![1, 6],
         1,
         2,
     )
+    .unwrap()
 }
 
 #[test]
@@ -27,7 +29,7 @@ fn test_prize_collecting_steiner_forest_creation() {
     assert_eq!(*problem.beta(), 1);
     assert_eq!(*problem.omega(), 2);
     // n + m = 3 + 2 = 5 binary variables.
-    assert_eq!(problem.dims(), vec![2; 5]);
+    assert_eq!(problem.dimensions(), vec![2; 5]);
     assert_eq!(problem.num_variables(), 5);
     assert!(problem.graph().has_edge(0, 1));
 }
@@ -35,12 +37,12 @@ fn test_prize_collecting_steiner_forest_creation() {
 #[test]
 fn test_prize_collecting_steiner_forest_problem_name_and_variant() {
     assert_eq!(
-        <PrizeCollectingSteinerForest<SimpleGraph, i32> as Problem>::NAME,
+        <PrizeCollectingSteinerForest<SimpleGraph, i64> as Problem>::NAME,
         "PrizeCollectingSteinerForest"
     );
-    let v = <PrizeCollectingSteinerForest<SimpleGraph, i32> as Problem>::variant();
+    let v = <PrizeCollectingSteinerForest<SimpleGraph, i64> as Problem>::variant();
     assert!(v.contains(&("graph", "SimpleGraph")));
-    assert!(v.contains(&("weight", "i32")));
+    assert!(v.contains(&("weight", "i64")));
 }
 
 #[test]
@@ -48,8 +50,8 @@ fn test_prize_collecting_steiner_forest_evaluate_optimum() {
     // V_F = {0,1,2}, E_F = {(0,1)}: components {0,1} and {2}.
     // Objective = 1*0 + 1 + 2*2 = 5.
     let problem = canonical_problem();
-    let config = vec![1, 1, 1, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(5)));
+    let config = (vec![true, true, true], vec![true, false]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(5)));
     assert!(problem.is_valid_solution(&config));
 }
 
@@ -58,8 +60,8 @@ fn test_prize_collecting_steiner_forest_evaluate_full_path() {
     // V_F = {0,1,2}, E_F = {(0,1),(1,2)}: single tree path.
     // Objective = 1*0 + (1+6) + 2*1 = 9.
     let problem = canonical_problem();
-    let config = vec![1, 1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(9)));
+    let config = (vec![true, true, true], vec![true, true]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(9)));
     assert!(problem.is_valid_solution(&config));
 }
 
@@ -68,8 +70,8 @@ fn test_prize_collecting_steiner_forest_evaluate_three_singletons() {
     // V_F = {0,1,2}, E_F = empty: three singleton trees.
     // Objective = 1*0 + 0 + 2*3 = 6.
     let problem = canonical_problem();
-    let config = vec![1, 1, 1, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(6)));
+    let config = (vec![true, true, true], vec![false, false]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(6)));
     assert!(problem.is_valid_solution(&config));
 }
 
@@ -78,8 +80,8 @@ fn test_prize_collecting_steiner_forest_evaluate_empty_forest() {
     // V_F = empty, E_F = empty: kappa = 0, every prize omitted.
     // Objective = 1*(5+2+5) + 0 + 2*0 = 12.
     let problem = canonical_problem();
-    let config = vec![0, 0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(12)));
+    let config = (vec![false, false, false], vec![false, false]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(12)));
     assert!(problem.is_valid_solution(&config));
 }
 
@@ -87,8 +89,8 @@ fn test_prize_collecting_steiner_forest_evaluate_empty_forest() {
 fn test_prize_collecting_steiner_forest_evaluate_edge_without_endpoint_infeasible() {
     // Select edge (0,1) but not vertex 1 -> infeasible.
     let problem = canonical_problem();
-    let config = vec![1, 0, 1, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = (vec![true, false, true], vec![true, false]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
     assert!(!problem.is_valid_solution(&config));
 }
 
@@ -96,15 +98,16 @@ fn test_prize_collecting_steiner_forest_evaluate_edge_without_endpoint_infeasibl
 fn test_prize_collecting_steiner_forest_evaluate_cycle_infeasible() {
     // Triangle 0-1, 1-2, 0-2 with all three vertices and all three edges
     // selected forms a cycle, which is not a forest -> infeasible.
-    let problem = PrizeCollectingSteinerForest::<SimpleGraph, i32>::new(
+    let problem = PrizeCollectingSteinerForest::<SimpleGraph, i64>::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![1, 1, 1],
         vec![1, 1, 1],
         1,
         1,
-    );
-    let config = vec![1, 1, 1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    )
+    .unwrap();
+    let config = (vec![true, true, true], vec![true, true, true]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
     assert!(!problem.is_valid_solution(&config));
 }
 
@@ -113,9 +116,14 @@ fn test_prize_collecting_steiner_forest_brute_force_solver() {
     // Brute force over 2^(3+2) = 32 configurations finds the optimum 5.
     let problem = canonical_problem();
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Min(Some(5)));
-    let witness = solver.find_witness(&problem).expect("witness exists");
-    assert_eq!(problem.evaluate(&witness), Min(Some(5)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(5))
+    );
+    let witness = solver.solve(&problem).unwrap().expect("witness exists");
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(5)));
     assert!(problem.is_valid_solution(&witness));
 }
 
@@ -123,7 +131,7 @@ fn test_prize_collecting_steiner_forest_brute_force_solver() {
 fn test_prize_collecting_steiner_forest_serialization_roundtrip() {
     let problem = canonical_problem();
     let json = serde_json::to_value(&problem).expect("serialize");
-    let restored: PrizeCollectingSteinerForest<SimpleGraph, i32> =
+    let restored: PrizeCollectingSteinerForest<SimpleGraph, i64> =
         serde_json::from_value(json).expect("deserialize");
     assert_eq!(restored.num_vertices(), 3);
     assert_eq!(restored.num_edges(), 2);
@@ -131,7 +139,12 @@ fn test_prize_collecting_steiner_forest_serialization_roundtrip() {
     assert_eq!(restored.edge_costs(), &[1, 6]);
     assert_eq!(*restored.beta(), 1);
     assert_eq!(*restored.omega(), 2);
-    assert_eq!(restored.evaluate(&[1, 1, 1, 1, 0]), Min(Some(5)));
+    assert_eq!(
+        restored
+            .evaluate(&(vec![true; 3], vec![true, false]))
+            .unwrap(),
+        Min(Some(5))
+    );
 }
 
 #[test]
@@ -143,31 +156,93 @@ fn test_prize_collecting_steiner_forest_f64_variant() {
         vec![1.0, 6.0],
         1.0,
         2.0,
+    )
+    .unwrap();
+    assert_eq!(
+        problem
+            .evaluate(&(vec![true; 3], vec![true, false]))
+            .unwrap(),
+        Min(Some(5.0))
+    );
+    assert_eq!(
+        problem
+            .evaluate(&BruteForce::new().solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(5.0))
     );
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1, 0]), Min(Some(5.0)));
-    assert_eq!(BruteForce::new().solve(&problem), Min(Some(5.0)));
 }
 
 #[test]
-#[should_panic(expected = "vertex_prizes length must match graph num_vertices")]
 fn test_prize_collecting_steiner_forest_rejects_vertex_prizes_length_mismatch() {
-    let _ = PrizeCollectingSteinerForest::<SimpleGraph, i32>::new(
+    let error = PrizeCollectingSteinerForest::<SimpleGraph, i64>::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
         vec![5, 2], // length 2 != 3 vertices
         vec![1, 6],
         1,
         2,
-    );
+    )
+    .unwrap_err();
+    assert!(matches!(
+        error,
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "vertex_prizes length must match graph num_vertices"
+    ));
 }
 
 #[test]
-#[should_panic(expected = "edge_costs length must match graph num_edges")]
 fn test_prize_collecting_steiner_forest_rejects_edge_costs_length_mismatch() {
-    let _ = PrizeCollectingSteinerForest::<SimpleGraph, i32>::new(
+    let error = PrizeCollectingSteinerForest::<SimpleGraph, i64>::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
         vec![5, 2, 5],
         vec![1, 6, 2], // length 3 != 2 edges
         1,
         2,
-    );
+    )
+    .unwrap_err();
+    assert!(matches!(
+        error,
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "edge_costs length must match graph num_edges"
+    ));
+}
+
+#[test]
+fn test_prize_collecting_steiner_forest_rejects_non_finite_weight() {
+    assert!(PrizeCollectingSteinerForest::<SimpleGraph, f64>::new(
+        SimpleGraph::new(1, vec![]),
+        vec![f64::NAN],
+        vec![],
+        1.0,
+        1.0,
+    )
+    .is_err());
+}
+#[test]
+fn create_specs_default_prizes_and_costs_to_one() {
+    let weighted =
+        PrizeCollectingSteinerForest::try_from(PrizeCollectingSteinerForestI64CreateSpec {
+            graph: vec![(0, 1)],
+            num_vertices: Some(3),
+            vertex_prizes: None,
+            edge_costs: None,
+            beta: 2,
+            omega: 3,
+        })
+        .unwrap();
+    let floating =
+        PrizeCollectingSteinerForest::try_from(PrizeCollectingSteinerForestF64CreateSpec {
+            graph: vec![(0, 1)],
+            num_vertices: None,
+            vertex_prizes: None,
+            edge_costs: None,
+            beta: 2.0,
+            omega: 3.0,
+        })
+        .unwrap();
+    assert_eq!(weighted.vertex_prizes(), &[1, 1, 1]);
+    assert_eq!(weighted.edge_costs(), &[1]);
+    assert_eq!(floating.vertex_prizes(), &[1.0, 1.0]);
+    assert_eq!(floating.edge_costs(), &[1.0]);
+    assert!(!PrizeCollectingSteinerForestI64CreateSpec::inputs()[2].required);
+    assert!(!PrizeCollectingSteinerForestI64CreateSpec::inputs()[3].required);
 }
diff --git a/src/unit_tests/models/graph/rooted_tree_arrangement.rs b/src/unit_tests/models/graph/rooted_tree_arrangement.rs
index 97040a1c3..a34c88abf 100644
--- a/src/unit_tests/models/graph/rooted_tree_arrangement.rs
+++ b/src/unit_tests/models/graph/rooted_tree_arrangement.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -20,9 +21,9 @@ fn test_rootedtreearrangement_basic_yes_example() {
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_edges(), 5);
     assert_eq!(problem.bound(), 7);
-    assert_eq!(problem.dims(), vec![5; 10]);
-    assert!(problem.evaluate(&config));
-    assert_eq!(problem.total_edge_stretch(&config), Some(6));
+    assert_eq!(problem.dimensions(), vec![5; 10]);
+    assert!(problem.evaluate(&config).unwrap());
+    assert_eq!(problem.total_edge_stretch(&config).unwrap(), Some(6));
 }
 
 #[test]
@@ -31,13 +32,13 @@ fn test_rootedtreearrangement_rejects_invalid_parent_arrays() {
 
     // Two roots: node 0 and node 1 are both self-parented.
     let multiple_roots = vec![0, 1, 1, 2, 3, 0, 1, 2, 3, 4];
-    assert!(!problem.evaluate(&multiple_roots));
-    assert_eq!(problem.total_edge_stretch(&multiple_roots), None);
+    assert!(!problem.evaluate(&multiple_roots).unwrap());
+    assert_eq!(problem.total_edge_stretch(&multiple_roots).unwrap(), None);
 
     // Directed cycle between nodes 1 and 2.
     let cycle = vec![0, 2, 1, 2, 3, 0, 1, 2, 3, 4];
-    assert!(!problem.evaluate(&cycle));
-    assert_eq!(problem.total_edge_stretch(&cycle), None);
+    assert!(!problem.evaluate(&cycle).unwrap());
+    assert_eq!(problem.total_edge_stretch(&cycle).unwrap(), None);
 }
 
 #[test]
@@ -45,16 +46,19 @@ fn test_rootedtreearrangement_rejects_invalid_bijections() {
     let problem = issue_example();
 
     let duplicate_image = vec![0, 0, 1, 2, 3, 0, 0, 2, 3, 4];
-    assert!(!problem.evaluate(&duplicate_image));
-    assert_eq!(problem.total_edge_stretch(&duplicate_image), None);
+    assert!(!problem.evaluate(&duplicate_image).unwrap());
+    assert_eq!(problem.total_edge_stretch(&duplicate_image).unwrap(), None);
 
     let out_of_range = vec![0, 0, 1, 2, 3, 0, 1, 2, 3, 5];
-    assert!(!problem.evaluate(&out_of_range));
-    assert_eq!(problem.total_edge_stretch(&out_of_range), None);
+    assert!(!problem.evaluate(&out_of_range).unwrap());
+    assert_eq!(problem.total_edge_stretch(&out_of_range).unwrap(), None);
 
     let wrong_length = vec![0, 0, 1, 2, 3, 0, 1, 2, 3];
-    assert!(!problem.evaluate(&wrong_length));
-    assert_eq!(problem.total_edge_stretch(&wrong_length), None);
+    assert!(matches!(
+        problem.evaluate(&wrong_length),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert_eq!(problem.total_edge_stretch(&wrong_length).unwrap(), None);
 }
 
 #[test]
@@ -65,8 +69,8 @@ fn test_rootedtreearrangement_rejects_noncomparable_edges() {
     // Tree: 0 is root, 1 and 2 are siblings, 3 and 4 descend from 2.
     // The graph edge {1,2} is invalid because mapped nodes 1 and 2 are not ancestor-comparable.
     let branching_tree = vec![0, 0, 0, 2, 3, 0, 1, 2, 3, 4];
-    assert!(!problem.evaluate(&branching_tree));
-    assert_eq!(problem.total_edge_stretch(&branching_tree), None);
+    assert!(!problem.evaluate(&branching_tree).unwrap());
+    assert_eq!(problem.total_edge_stretch(&branching_tree).unwrap(), None);
 }
 
 #[test]
@@ -75,8 +79,8 @@ fn test_rootedtreearrangement_enforces_bound() {
 
     // Same chain tree as the YES witness, but the mapping stretches edge {2,3} too far.
     let over_bound = vec![0, 0, 1, 2, 3, 2, 1, 0, 3, 4];
-    assert!(!problem.evaluate(&over_bound));
-    assert_eq!(problem.total_edge_stretch(&over_bound), Some(8));
+    assert!(!problem.evaluate(&over_bound).unwrap());
+    assert_eq!(problem.total_edge_stretch(&over_bound).unwrap(), Some(8));
 }
 
 #[test]
@@ -86,16 +90,20 @@ fn test_rootedtreearrangement_solver_and_serialization() {
 
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("expected satisfying solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 
     let json = serde_json::to_string(&problem).unwrap();
     let restored: RootedTreeArrangement<SimpleGraph> = serde_json::from_str(&json).unwrap();
     assert_eq!(restored.num_vertices(), 3);
     assert_eq!(restored.num_edges(), 2);
     assert_eq!(restored.bound(), 2);
-    assert_eq!(restored.evaluate(&solution), problem.evaluate(&solution));
+    assert_eq!(
+        restored.evaluate(&solution).unwrap(),
+        problem.evaluate(&solution).unwrap()
+    );
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/rural_postman.rs b/src/unit_tests/models/graph/rural_postman.rs
index 341fbdef5..aec2d3a5d 100644
--- a/src/unit_tests/models/graph/rural_postman.rs
+++ b/src/unit_tests/models/graph/rural_postman.rs
@@ -1,11 +1,12 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
 
 /// Instance 1 from issue: hexagonal graph with 3 required edges
-fn hexagon_rpp() -> RuralPostman<SimpleGraph, i32> {
+fn hexagon_rpp() -> RuralPostman<SimpleGraph, i64> {
     // 6 vertices, 8 edges
     // Edges: {0,1}:1, {1,2}:1, {2,3}:1, {3,4}:1, {4,5}:1, {5,0}:1, {0,3}:2, {1,4}:2
     let graph = SimpleGraph::new(
@@ -28,7 +29,7 @@ fn hexagon_rpp() -> RuralPostman<SimpleGraph, i32> {
 }
 
 /// Instance 3 from issue: C4 cycle, all edges required (Chinese Postman)
-fn chinese_postman_rpp() -> RuralPostman<SimpleGraph, i32> {
+fn chinese_postman_rpp() -> RuralPostman<SimpleGraph, i64> {
     let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (3, 0)]);
     let edge_lengths = vec![1, 1, 1, 1];
     let required_edges = vec![0, 1, 2, 3];
@@ -41,8 +42,8 @@ fn test_rural_postman_creation() {
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 8);
     assert_eq!(problem.num_required_edges(), 3);
-    assert_eq!(problem.dims().len(), 8);
-    assert!(problem.dims().iter().all(|&d| d == 3));
+    assert_eq!(problem.dimensions().len(), 8);
+    assert!(problem.dimensions().iter().all(|&d| d == 3));
 }
 
 #[test]
@@ -60,7 +61,7 @@ fn test_rural_postman_valid_circuit() {
     // Circuit: 0->1->2->3->4->5->0 uses edges 0,1,2,3,4,5 (the hexagon)
     // Total length = 6 * 1 = 6, covers all required edges
     let config = vec![1, 1, 1, 1, 1, 1, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(6)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -68,7 +69,7 @@ fn test_rural_postman_missing_required_edge() {
     let problem = hexagon_rpp();
     // Select edges but miss required edge 4 ({4,5})
     let config = vec![1, 1, 1, 1, 0, 1, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -76,7 +77,7 @@ fn test_rural_postman_odd_degree() {
     let problem = hexagon_rpp();
     // Select edges 0,2,4 only (the 3 required edges) — disconnected, odd degree
     let config = vec![1, 0, 1, 0, 1, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -84,7 +85,7 @@ fn test_rural_postman_chinese_postman_case() {
     let problem = chinese_postman_rpp();
     // Select all edges in the C4 cycle: valid Eulerian circuit, length 4
     let config = vec![1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(4)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(4)));
 }
 
 #[test]
@@ -95,7 +96,7 @@ fn test_rural_postman_no_edges_no_required() {
     let required_edges = vec![];
     let problem = RuralPostman::new(graph, edge_lengths, required_edges);
     let config = vec![0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(0)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -107,27 +108,27 @@ fn test_rural_postman_disconnected_selection() {
     let problem = RuralPostman::new(graph, edge_lengths, required_edges);
     // Select both triangles: even degree but disconnected
     let config = vec![1, 1, 1, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_rural_postman_brute_force_finds_solution() {
     let problem = chinese_postman_rpp();
     let solver = BruteForce::new();
-    let result = solver.find_witness(&problem);
+    let result = solver.solve(&problem).unwrap();
     assert!(result.is_some());
     let sol = result.unwrap();
-    assert!(problem.evaluate(&sol).0.is_some());
+    assert!(problem.evaluate(&sol).unwrap().0.is_some());
 }
 
 #[test]
 fn test_rural_postman_brute_force_hexagon() {
     let problem = hexagon_rpp();
     let solver = BruteForce::new();
-    let result = solver.find_witness(&problem);
+    let result = solver.solve(&problem).unwrap();
     assert!(result.is_some());
     let sol = result.unwrap();
-    assert_eq!(problem.evaluate(&sol), Min(Some(6)));
+    assert_eq!(problem.evaluate(&sol).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -137,9 +138,9 @@ fn test_rural_postman_find_all_witnesses() {
     // Search space = 3^8 = 6561
     let problem = hexagon_rpp();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
-        assert!(problem.evaluate(sol).0.is_some());
+        assert!(problem.evaluate(sol).unwrap().0.is_some());
     }
     // The issue witness (hexagon cycle, all multiplicity 1) must be among solutions
     assert!(solutions.contains(&vec![1, 1, 1, 1, 1, 1, 0, 0]));
@@ -151,7 +152,7 @@ fn test_rural_postman_find_all_witnesses() {
 fn test_rural_postman_serialization() {
     let problem = chinese_postman_rpp();
     let json = serde_json::to_value(&problem).unwrap();
-    let restored: RuralPostman<SimpleGraph, i32> = serde_json::from_value(json).unwrap();
+    let restored: RuralPostman<SimpleGraph, i64> = serde_json::from_value(json).unwrap();
     assert_eq!(restored.num_vertices(), problem.num_vertices());
     assert_eq!(restored.num_edges(), problem.num_edges());
     assert_eq!(restored.num_required_edges(), problem.num_required_edges());
@@ -161,7 +162,7 @@ fn test_rural_postman_serialization() {
 #[test]
 fn test_rural_postman_problem_name() {
     assert_eq!(
-        <RuralPostman<SimpleGraph, i32> as Problem>::NAME,
+        <RuralPostman<SimpleGraph, i64> as Problem>::NAME,
         "RuralPostman"
     );
 }
@@ -174,7 +175,7 @@ fn test_rural_postman_set_weights() {
 }
 
 #[test]
-fn test_rural_postman_size_getters() {
+fn test_rural_postman_parameter_getters() {
     let problem = hexagon_rpp();
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 8);
@@ -184,7 +185,10 @@ fn test_rural_postman_size_getters() {
 #[test]
 fn test_rural_postman_wrong_config_length() {
     let problem = chinese_postman_rpp();
-    assert_eq!(problem.evaluate(&[1, 1]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![1, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -196,8 +200,20 @@ fn test_rural_postman_is_weighted() {
 #[test]
 fn test_rural_postman_solver_aggregate() {
     let problem = chinese_postman_rpp();
-    use crate::Solver;
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(4)));
 }
+#[test]
+fn create_spec_maps_edge_weights_to_edge_lengths() {
+    let problem = RuralPostman::try_from(RuralPostmanCreateSpec {
+        graph: vec![(0, 1), (1, 2)],
+        num_vertices: None,
+        edge_weights: Some(vec![2, 3]),
+        required_edges: vec![1],
+    })
+    .unwrap();
+    assert_eq!(problem.edge_lengths(), &[2, 3]);
+    assert_eq!(RuralPostmanCreateSpec::FIELDS[2].name, "edge_weights");
+}
diff --git a/src/unit_tests/models/graph/shortest_weight_constrained_path.rs b/src/unit_tests/models/graph/shortest_weight_constrained_path.rs
index 1f845e1bc..5135bd671 100644
--- a/src/unit_tests/models/graph/shortest_weight_constrained_path.rs
+++ b/src/unit_tests/models/graph/shortest_weight_constrained_path.rs
@@ -1,10 +1,28 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_nonpositive_edge_values() {
+    assert_eq!(
+        ShortestWeightConstrainedPathCreateSpec::FIELDS[1].name,
+        "edge_lengths"
+    );
+    let result = ShortestWeightConstrainedPath::try_from(ShortestWeightConstrainedPathCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        edge_lengths: vec![0],
+        edge_weights: vec![1],
+        source_vertex: 0,
+        target_vertex: 1,
+        weight_bound: 1,
+    });
+    assert!(result.is_err());
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
 
-fn issue_problem() -> ShortestWeightConstrainedPath<SimpleGraph, i32> {
+fn issue_problem() -> ShortestWeightConstrainedPath<SimpleGraph, i64> {
     ShortestWeightConstrainedPath::new(
         SimpleGraph::new(
             6,
@@ -35,7 +53,7 @@ fn test_shortest_weight_constrained_path_creation() {
     assert_eq!(problem.source_vertex(), 0);
     assert_eq!(problem.target_vertex(), 5);
     assert_eq!(*problem.weight_bound(), 8);
-    assert_eq!(problem.dims(), vec![2; 8]);
+    assert_eq!(problem.dimensions(), vec![2; 8]);
     assert!(problem.is_weighted());
 }
 
@@ -44,17 +62,47 @@ fn test_shortest_weight_constrained_path_evaluation() {
     let problem = issue_problem();
 
     // Path 0-2-3-5: length=4+1+4=9, weight=1+3+3=7<=8
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1, 0, 1, 0, 0]), Min(Some(9)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, true, false, true, false, true, false, false])
+            .unwrap(),
+        Min(Some(9))
+    );
     // Path 0-1-4-5: length=2+6+2=10, weight=5+1+1=7<=8
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0, 0, 0, 1, 1]), Min(Some(10)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, false, false, false, true, true])
+            .unwrap(),
+        Min(Some(10))
+    );
     // Invalid: not a simple path
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1, 1, 1, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, true, false, true, true, true, false, false])
+            .unwrap(),
+        Min(None)
+    );
     // Path 0-1-3-2-4-5 is not simple s-t path structure in this encoding
-    assert_eq!(problem.evaluate(&[1, 0, 0, 1, 0, 0, 1, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, true, false, false, true, false])
+            .unwrap(),
+        Min(None)
+    );
     // Path 0-1-3-5: weight=5+2+3=10>8
-    assert_eq!(problem.evaluate(&[1, 0, 1, 0, 0, 1, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, true, false, false, true, false, false])
+            .unwrap(),
+        Min(None)
+    );
     // Path 0-2-4-5: length=4+5+2=11, weight=1+2+1=4<=8
-    assert_eq!(problem.evaluate(&[0, 1, 0, 0, 1, 0, 1, 0]), Min(Some(11)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, true, false, false, true, false, true, false])
+            .unwrap(),
+        Min(Some(11))
+    );
 }
 
 #[test]
@@ -70,16 +118,16 @@ fn test_shortest_weight_constrained_path_accessors() {
 fn test_shortest_weight_constrained_path_bruteforce() {
     let problem = issue_problem();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let config = solution.unwrap();
     // The witness should be the minimum-length feasible path (length 9)
-    assert_eq!(problem.evaluate(&config), Min(Some(9)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(9)));
 
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     // All witnesses share the optimal value
     for c in &all {
-        assert_eq!(problem.evaluate(c), Min(Some(9)));
+        assert_eq!(problem.evaluate(c).unwrap(), Min(Some(9)));
     }
 }
 
@@ -107,14 +155,14 @@ fn test_shortest_weight_constrained_path_no_solution() {
         3,
     );
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_shortest_weight_constrained_path_serialization() {
     let problem = issue_problem();
     let json = serde_json::to_value(&problem).unwrap();
-    let restored: ShortestWeightConstrainedPath<SimpleGraph, i32> =
+    let restored: ShortestWeightConstrainedPath<SimpleGraph, i64> =
         serde_json::from_value(json).unwrap();
     assert_eq!(restored.num_vertices(), 6);
     assert_eq!(restored.num_edges(), 8);
@@ -126,7 +174,7 @@ fn test_shortest_weight_constrained_path_serialization() {
 #[test]
 fn test_shortest_weight_constrained_path_problem_name() {
     assert_eq!(
-        <ShortestWeightConstrainedPath<SimpleGraph, i32> as Problem>::NAME,
+        <ShortestWeightConstrainedPath<SimpleGraph, i64> as Problem>::NAME,
         "ShortestWeightConstrainedPath"
     );
 }
@@ -134,9 +182,14 @@ fn test_shortest_weight_constrained_path_problem_name() {
 #[test]
 fn test_shortestweightconstrainedpath_paper_example() {
     let problem = issue_problem();
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1, 0, 1, 0, 0]), Min(Some(9)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, true, false, true, false, true, false, false])
+            .unwrap(),
+        Min(Some(9))
+    );
 
-    let all = BruteForce::new().find_all_witnesses(&problem);
+    let all = BruteForce::new().find_all_witnesses(&problem).unwrap();
     // Only 1 witness at optimal value 9 (path 0-2-3-5)
     assert_eq!(all.len(), 1);
 }
@@ -145,9 +198,18 @@ fn test_shortestweightconstrainedpath_paper_example() {
 fn test_shortest_weight_constrained_path_rejects_invalid_configs() {
     let problem = issue_problem();
 
-    assert_eq!(problem.is_valid_solution(&[0, 1]), None);
-    assert_eq!(problem.is_valid_solution(&[0, 1, 0, 1, 0, 1, 0, 2]), None);
-    assert_eq!(problem.is_valid_solution(&[0, 0, 0, 0, 0, 0, 0, 0]), None);
+    assert_eq!(problem.is_valid_solution(&[false, true]).unwrap(), None);
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([false, true, false, true, false, true, false, 2])
+    )
+    .is_err());
+    assert_eq!(
+        problem
+            .is_valid_solution(&[false, false, false, false, false, false, false, false])
+            .unwrap(),
+        None
+    );
 }
 
 #[test]
@@ -161,8 +223,8 @@ fn test_shortest_weight_constrained_path_source_equals_target_allows_only_empty_
         1,
     );
 
-    assert_eq!(problem.is_valid_solution(&[0, 0]), Some(0));
-    assert_eq!(problem.is_valid_solution(&[1, 0]), None);
+    assert_eq!(problem.is_valid_solution(&[false, false]).unwrap(), Some(0));
+    assert_eq!(problem.is_valid_solution(&[true, false]).unwrap(), None);
 }
 
 #[test]
@@ -177,8 +239,8 @@ fn test_shortest_weight_constrained_path_exceeds_weight_bound() {
         3,
     );
     // Valid path but weight 5 > 3
-    assert_eq!(problem.is_valid_solution(&[1]), None);
-    assert_eq!(problem.evaluate(&[1]), Min(None));
+    assert_eq!(problem.is_valid_solution(&[true]).unwrap(), None);
+    assert_eq!(problem.evaluate(&vec![true]).unwrap(), Min(None));
 }
 
 #[test]
@@ -192,7 +254,12 @@ fn test_shortest_weight_constrained_path_rejects_disconnected_selected_edges() {
         10,
     );
 
-    assert_eq!(problem.is_valid_solution(&[1, 1, 1, 1, 1]), None);
+    assert_eq!(
+        problem
+            .is_valid_solution(&[true, true, true, true, true])
+            .unwrap(),
+        None
+    );
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/spin_glass.rs b/src/unit_tests/models/graph/spin_glass.rs
index e5ff4fdea..27cc19d84 100644
--- a/src/unit_tests/models/graph/spin_glass.rs
+++ b/src/unit_tests/models/graph/spin_glass.rs
@@ -1,4 +1,18 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_couplings_and_fields() {
+    let problem = SpinGlass::<SimpleGraph, i64>::try_from(SpinGlassI64CreateSpec {
+        graph: vec![(0, 1)],
+        num_vertices: Some(3),
+        couplings: None,
+        fields: None,
+    })
+    .unwrap();
+    assert_eq!(problem.couplings(), &[1]);
+    assert_eq!(problem.fields(), &[0, 0, 0]);
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 include!("../../jl_helpers.rs");
@@ -9,7 +23,8 @@ fn test_spin_glass_creation() {
         3,
         vec![((0, 1), 1.0), ((1, 2), -1.0)],
         vec![0.0, 0.0, 0.0],
-    );
+    )
+    .unwrap();
     assert_eq!(problem.num_spins(), 3);
     assert_eq!(problem.interactions().len(), 2);
     assert_eq!(problem.fields().len(), 3);
@@ -17,58 +32,68 @@ fn test_spin_glass_creation() {
 
 #[test]
 fn test_spin_glass_without_fields() {
-    let problem = SpinGlass::<SimpleGraph, f64>::without_fields(3, vec![((0, 1), 1.0)]);
+    let problem = SpinGlass::<SimpleGraph, f64>::without_fields(3, vec![((0, 1), 1.0)]).unwrap();
     assert_eq!(problem.fields(), &[0.0, 0.0, 0.0]);
 }
 
 #[test]
 fn test_config_to_spins() {
     assert_eq!(
-        SpinGlass::<SimpleGraph, f64>::config_to_spins(&[0, 0]),
+        SpinGlass::<SimpleGraph, f64>::config_to_spins(&[0, 0]).unwrap(),
         vec![-1, -1]
     );
     assert_eq!(
-        SpinGlass::<SimpleGraph, f64>::config_to_spins(&[1, 1]),
+        SpinGlass::<SimpleGraph, f64>::config_to_spins(&[1, 1]).unwrap(),
         vec![1, 1]
     );
     assert_eq!(
-        SpinGlass::<SimpleGraph, f64>::config_to_spins(&[0, 1]),
+        SpinGlass::<SimpleGraph, f64>::config_to_spins(&[0, 1]).unwrap(),
         vec![-1, 1]
     );
     assert_eq!(
-        SpinGlass::<SimpleGraph, f64>::config_to_spins(&[1, 0]),
+        SpinGlass::<SimpleGraph, f64>::config_to_spins(&[1, 0]).unwrap(),
         vec![1, -1]
     );
+    assert!(SpinGlass::<SimpleGraph, f64>::config_to_spins(&[2]).is_err());
 }
 
 #[test]
 fn test_compute_energy() {
     // Two spins with J = 1 (ferromagnetic prefers aligned)
-    let problem = SpinGlass::<SimpleGraph, f64>::new(2, vec![((0, 1), 1.0)], vec![0.0, 0.0]);
+    let problem =
+        SpinGlass::<SimpleGraph, f64>::new(2, vec![((0, 1), 1.0)], vec![0.0, 0.0]).unwrap();
 
     // Aligned spins: energy = J * s1 * s2 = 1 * 1 * 1 = 1 or 1 * (-1) * (-1) = 1
-    assert_eq!(problem.compute_energy(&[1, 1]), 1.0);
-    assert_eq!(problem.compute_energy(&[-1, -1]), 1.0);
+    assert_eq!(problem.compute_energy(&[1, 1]).unwrap(), 1.0);
+    assert_eq!(problem.compute_energy(&[-1, -1]).unwrap(), 1.0);
 
     // Anti-aligned spins: energy = J * s1 * s2 = 1 * 1 * (-1) = -1
-    assert_eq!(problem.compute_energy(&[1, -1]), -1.0);
-    assert_eq!(problem.compute_energy(&[-1, 1]), -1.0);
+    assert_eq!(problem.compute_energy(&[1, -1]).unwrap(), -1.0);
+    assert_eq!(problem.compute_energy(&[-1, 1]).unwrap(), -1.0);
 }
 
 #[test]
 fn test_compute_energy_with_fields() {
-    let problem = SpinGlass::<SimpleGraph, f64>::new(2, vec![], vec![1.0, -1.0]);
+    let problem = SpinGlass::<SimpleGraph, f64>::new(2, vec![], vec![1.0, -1.0]).unwrap();
 
     // Energy = h1*s1 + h2*s2 = 1*s1 + (-1)*s2
-    assert_eq!(problem.compute_energy(&[1, 1]), 0.0); // 1 - 1 = 0
-    assert_eq!(problem.compute_energy(&[-1, -1]), 0.0); // -1 + 1 = 0
-    assert_eq!(problem.compute_energy(&[1, -1]), 2.0); // 1 + 1 = 2
-    assert_eq!(problem.compute_energy(&[-1, 1]), -2.0); // -1 - 1 = -2
+    assert_eq!(problem.compute_energy(&[1, 1]).unwrap(), 0.0); // 1 - 1 = 0
+    assert_eq!(problem.compute_energy(&[-1, -1]).unwrap(), 0.0); // -1 + 1 = 0
+    assert_eq!(problem.compute_energy(&[1, -1]).unwrap(), 2.0); // 1 + 1 = 2
+    assert_eq!(problem.compute_energy(&[-1, 1]).unwrap(), -2.0); // -1 - 1 = -2
+}
+
+#[test]
+fn test_compute_energy_rejects_invalid_spin_configuration() {
+    let problem = SpinGlass::<SimpleGraph, i64>::without_fields(2, vec![((0, 1), 1)]).unwrap();
+
+    assert!(problem.compute_energy(&[1]).is_err());
+    assert!(problem.compute_energy(&[1, 0]).is_err());
 }
 
 #[test]
 fn test_num_variables() {
-    let problem = SpinGlass::<SimpleGraph, f64>::without_fields(5, vec![]);
+    let problem = SpinGlass::<SimpleGraph, f64>::without_fields(5, vec![]).unwrap();
     assert_eq!(problem.num_variables(), 5);
 }
 
@@ -76,7 +101,8 @@ fn test_num_variables() {
 fn test_from_graph() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem =
-        SpinGlass::<SimpleGraph, f64>::from_graph(graph, vec![1.0, 2.0], vec![0.0, 0.0, 0.0]);
+        SpinGlass::<SimpleGraph, f64>::from_graph(graph, vec![1.0, 2.0], vec![0.0, 0.0, 0.0])
+            .unwrap();
     assert_eq!(problem.num_spins(), 3);
     assert_eq!(problem.couplings(), &[1.0, 2.0]);
     assert_eq!(problem.fields(), &[0.0, 0.0, 0.0]);
@@ -85,7 +111,8 @@ fn test_from_graph() {
 #[test]
 fn test_from_graph_without_fields() {
     let graph = SimpleGraph::new(2, vec![(0, 1)]);
-    let problem = SpinGlass::<SimpleGraph, f64>::from_graph_without_fields(graph, vec![1.5]);
+    let problem =
+        SpinGlass::<SimpleGraph, f64>::from_graph_without_fields(graph, vec![1.5]).unwrap();
     assert_eq!(problem.num_spins(), 2);
     assert_eq!(problem.couplings(), &[1.5]);
     assert_eq!(problem.fields(), &[0.0, 0.0]);
@@ -93,7 +120,8 @@ fn test_from_graph_without_fields() {
 
 #[test]
 fn test_graph_accessor() {
-    let problem = SpinGlass::<SimpleGraph, f64>::new(3, vec![((0, 1), 1.0)], vec![0.0, 0.0, 0.0]);
+    let problem =
+        SpinGlass::<SimpleGraph, f64>::new(3, vec![((0, 1), 1.0)], vec![0.0, 0.0, 0.0]).unwrap();
     let graph = problem.graph();
     assert_eq!(graph.num_vertices(), 3);
     assert_eq!(graph.num_edges(), 1);
@@ -106,15 +134,15 @@ fn test_jl_parity_evaluation() {
     for instance in data["instances"].as_array().unwrap() {
         let nv = instance["instance"]["num_vertices"].as_u64().unwrap() as usize;
         let edges = jl_parse_edges(&instance["instance"]);
-        let j_values = jl_parse_i32_vec(&instance["instance"]["J"]);
-        let h_values = jl_parse_i32_vec(&instance["instance"]["h"]);
-        let interactions: Vec<((usize, usize), i32)> = edges.into_iter().zip(j_values).collect();
-        let problem = SpinGlass::<SimpleGraph, i32>::new(nv, interactions, h_values);
+        let j_values = jl_parse_i64_vec(&instance["instance"]["J"]);
+        let h_values = jl_parse_i64_vec(&instance["instance"]["h"]);
+        let interactions: Vec<((usize, usize), i64)> = edges.into_iter().zip(j_values).collect();
+        let problem = SpinGlass::<SimpleGraph, i64>::new(nv, interactions, h_values).unwrap();
         for eval in instance["evaluations"].as_array().unwrap() {
             let jl_config = jl_parse_config(&eval["config"]);
             let config = jl_flip_config(&jl_config);
-            let result = problem.evaluate(&config);
-            let jl_size = eval["size"].as_i64().unwrap() as i32;
+            let result = problem.evaluate(&config).unwrap();
+            let jl_size = eval["size"].as_i64().unwrap();
             assert!(result.is_valid(), "SpinGlass should always be valid");
             assert_eq!(
                 result.unwrap(),
@@ -123,20 +151,21 @@ fn test_jl_parity_evaluation() {
                 config
             );
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
         let jl_best = jl_flip_configs_set(&jl_parse_configs_set(&instance["best_solutions"]));
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let rust_best: HashSet<Vec<i8>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "SpinGlass best solutions mismatch");
     }
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = SpinGlass::<SimpleGraph, f64>::new(
         3,
         vec![((0, 1), 1.0), ((1, 2), -1.0)],
         vec![0.0, 0.0, 0.0],
-    );
+    )
+    .unwrap();
     assert_eq!(problem.num_spins(), 3);
     assert_eq!(problem.num_interactions(), 2);
 }
@@ -146,7 +175,7 @@ fn test_spinglass_paper_example() {
     // Paper: 5 spins on triangular lattice, antiferromagnetic J=-1 (paper convention)
     // Code H = Σ J*s*s vs paper H = -Σ J*s*s, so J_code = -J_paper = 1
     // 7 edges on triangular lattice
-    let problem = SpinGlass::<SimpleGraph, i32>::without_fields(
+    let problem = SpinGlass::<SimpleGraph, i64>::without_fields(
         5,
         vec![
             ((0, 1), 1),
@@ -157,15 +186,34 @@ fn test_spinglass_paper_example() {
             ((1, 4), 1),
             ((2, 4), 1),
         ],
-    );
-    // Ground state: s = (+1,-1,+1,+1,-1) → config x = (1,0,1,1,0)
+    )
+    .unwrap();
+    // Ground state: s = (+1,-1,+1,+1,-1).
     // Energy = -3 (5 satisfied antiparallel, 2 frustrated parallel edges)
-    let result = problem.evaluate(&[1, 0, 1, 1, 0]);
+    let result = problem.evaluate(&vec![1, -1, 1, 1, -1]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), -3);
 
     // Verify this is optimal
-    let all_best = BruteForce::new().find_all_witnesses(&problem);
+    let all_best = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert!(!all_best.is_empty());
-    assert_eq!(problem.evaluate(&all_best[0]).unwrap(), -3);
+    assert_eq!(problem.evaluate(&all_best[0]).unwrap().unwrap(), -3);
+}
+
+#[test]
+fn test_spin_glass_rejects_non_finite_parameters() {
+    assert!(
+        SpinGlass::<SimpleGraph, f64>::new(2, vec![((0, 1), f64::NAN)], vec![0.0, 0.0],).is_err()
+    );
+    assert!(SpinGlass::<SimpleGraph, f64>::new(1, vec![], vec![f64::INFINITY]).is_err());
+}
+
+#[test]
+fn test_spin_glass_reports_energy_overflow() {
+    let problem =
+        SpinGlass::<SimpleGraph, i64>::new(2, vec![((0, 1), i64::MIN)], vec![0, 0]).unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![-1, 1]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
 }
diff --git a/src/unit_tests/models/graph/steiner_tree.rs b/src/unit_tests/models/graph/steiner_tree.rs
index 00cd8d505..92d4d7a29 100644
--- a/src/unit_tests/models/graph/steiner_tree.rs
+++ b/src/unit_tests/models/graph/steiner_tree.rs
@@ -1,9 +1,21 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_duplicate_terminals() {
+    assert_eq!(SteinerTreeCreateSpec::<i64>::FIELDS[2].name, "terminals");
+    let result = SteinerTree::try_from(SteinerTreeCreateSpec {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        edge_weights: vec![1],
+        terminals: vec![0, 0],
+    });
+    assert!(result.is_err());
+}
 use crate::{solvers::BruteForce, topology::SimpleGraph, traits::Problem};
 
 /// Issue #122 example: 5 vertices, 7 edges, terminals {0, 2, 4}.
 /// Edges in order: (0,1)=2, (0,3)=5, (1,2)=2, (1,3)=1, (2,3)=5, (2,4)=6, (3,4)=1
-fn example_instance() -> SteinerTree<SimpleGraph, i32> {
+fn example_instance() -> SteinerTree<SimpleGraph, i64> {
     let graph = SimpleGraph::new(
         5,
         vec![(0, 1), (0, 3), (1, 2), (1, 3), (2, 3), (2, 4), (3, 4)],
@@ -19,7 +31,7 @@ fn test_steiner_tree_creation() {
     assert_eq!(problem.graph().num_vertices(), 5);
     assert_eq!(problem.graph().num_edges(), 7);
     assert_eq!(problem.terminals(), &[0, 2, 4]);
-    assert_eq!(problem.dims().len(), 7);
+    assert_eq!(problem.dimensions().len(), 7);
 }
 
 #[test]
@@ -30,7 +42,7 @@ fn test_steiner_tree_rejects_duplicate_terminals() {
 }
 
 #[test]
-fn test_steiner_tree_size_getters() {
+fn test_steiner_tree_parameter_getters() {
     let problem = example_instance();
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_edges(), 7);
@@ -42,42 +54,42 @@ fn test_steiner_tree_evaluate_optimal() {
     let problem = example_instance();
     // Optimal: edges (0,1)=2, (1,2)=2, (1,3)=1, (3,4)=1 => cost 6
     // Edge indices: 0=(0,1), 2=(1,2), 3=(1,3), 6=(3,4)
-    let config = vec![1, 0, 1, 1, 0, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(6)));
+    let config = vec![true, false, true, true, false, false, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(6)));
 }
 
 #[test]
 fn test_steiner_tree_evaluate_invalid_disconnected() {
     let problem = example_instance();
     // Only edge (0,1) — terminals 2, 4 unreachable
-    let config = vec![1, 0, 0, 0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![true, false, false, false, false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_steiner_tree_evaluate_invalid_cycle() {
     let problem = example_instance();
     // Edges (0,1), (0,3), (1,2), (1,3), (3,4) — cycle 0-1-3-0
-    let config = vec![1, 1, 1, 1, 0, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![true, true, true, true, false, false, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_steiner_tree_evaluate_empty() {
     let problem = example_instance();
-    let config = vec![0; 7];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![false; 7];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_steiner_tree_brute_force() {
     let problem = example_instance();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     // All optimal solutions should have cost 6
     for sol in &solutions {
-        assert_eq!(problem.evaluate(sol), Min(Some(6)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Min(Some(6)));
     }
 }
 
@@ -89,17 +101,17 @@ fn test_steiner_tree_all_terminals() {
     let terminals = vec![0, 1, 2];
     let problem = SteinerTree::new(graph, edge_weights, terminals);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     // MST = edges (0,1)=1, (1,2)=2 => cost 3
     for sol in &solutions {
-        assert_eq!(problem.evaluate(sol), Min(Some(3)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Min(Some(3)));
     }
 }
 
 #[test]
 fn test_steiner_tree_is_weighted() {
-    // i32 has IS_UNIT = false, so is_weighted() returns true
+    // i64 has IS_UNIT = false, so is_weighted() returns true
     let problem = example_instance();
     assert!(problem.is_weighted());
 
@@ -114,7 +126,7 @@ fn test_steiner_tree_is_weighted() {
 fn test_steiner_tree_serialization() {
     let problem = example_instance();
     let json = serde_json::to_value(&problem).unwrap();
-    let deserialized: SteinerTree<SimpleGraph, i32> = serde_json::from_value(json).unwrap();
+    let deserialized: SteinerTree<SimpleGraph, i64> = serde_json::from_value(json).unwrap();
     assert_eq!(deserialized.graph().num_vertices(), 5);
     assert_eq!(deserialized.graph().num_edges(), 7);
     assert_eq!(deserialized.terminals(), &[0, 2, 4]);
@@ -124,13 +136,13 @@ fn test_steiner_tree_serialization() {
 fn test_steiner_tree_is_valid_solution() {
     let problem = example_instance();
     // Valid: tree connecting all terminals
-    assert!(problem.is_valid_solution(&[1, 0, 1, 1, 0, 0, 1]));
+    assert!(problem.is_valid_solution(&[true, false, true, true, false, false, true]));
     // Invalid: disconnected
-    assert!(!problem.is_valid_solution(&[1, 0, 0, 0, 0, 0, 0]));
+    assert!(!problem.is_valid_solution(&[true, false, false, false, false, false, false]));
     // Invalid: empty
-    assert!(!problem.is_valid_solution(&[0; 7]));
+    assert!(!problem.is_valid_solution(&[false; 7]));
     // Invalid: wrong config length
-    assert!(!problem.is_valid_solution(&[1, 0, 1]));
+    assert!(!problem.is_valid_solution(&[true, false, true]));
 }
 
 #[test]
@@ -144,8 +156,8 @@ fn test_steiner_tree_disconnected_non_terminal_edges() {
     let problem = SteinerTree::new(graph, edge_weights, terminals);
     // Edges: 0=(0,1), 1=(1,2), 2=(2,3), 3=(3,4)
     // Select edges 0, 1, 3 — disconnected: {0,1,2} and {3,4}
-    let config = vec![1, 1, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![true, true, false, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
     assert!(!problem.is_valid_solution(&config));
 }
 
@@ -159,8 +171,8 @@ fn test_steiner_tree_edge_weights_and_set_weights() {
     problem.set_weights(vec![1, 1, 1, 1, 1, 1, 1]);
     assert_eq!(problem.edge_weights(), &[1, 1, 1, 1, 1, 1, 1]);
     // The same tree (0,1),(1,2),(1,3),(3,4) now costs 4
-    let config = vec![1, 0, 1, 1, 0, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(4)));
+    let config = vec![true, false, true, true, false, false, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(4)));
 }
 
 #[test]
@@ -183,3 +195,20 @@ fn test_steiner_tree_rejects_wrong_weight_count() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let _ = SteinerTree::new(graph, vec![1, 1, 1], vec![0, 2]);
 }
+
+#[test]
+fn test_steiner_tree_deserialization_rejects_invalid_invariants() {
+    let one_terminal = serde_json::json!({
+        "graph": {"num_vertices": 2, "edges": [[0, 1]]},
+        "edge_weights": [1],
+        "terminals": [0]
+    });
+    assert!(serde_json::from_value::<SteinerTree<SimpleGraph, i64>>(one_terminal).is_err());
+
+    let wrong_weights = serde_json::json!({
+        "graph": {"num_vertices": 2, "edges": [[0, 1]]},
+        "edge_weights": [],
+        "terminals": [0, 1]
+    });
+    assert!(serde_json::from_value::<SteinerTree<SimpleGraph, i64>>(wrong_weights).is_err());
+}
diff --git a/src/unit_tests/models/graph/steiner_tree_in_graphs.rs b/src/unit_tests/models/graph/steiner_tree_in_graphs.rs
index cf09155cc..fd845b214 100644
--- a/src/unit_tests/models/graph/steiner_tree_in_graphs.rs
+++ b/src/unit_tests/models/graph/steiner_tree_in_graphs.rs
@@ -1,4 +1,16 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_edge_weights() {
+    let p = SteinerTreeInGraphs::try_from(SteinerTreeInGraphsCreateSpec::<i64> {
+        graph: SimpleGraph::new(2, vec![(0, 1)]),
+        terminals: vec![0, 1],
+        edge_weights: None,
+    })
+    .unwrap();
+    assert_eq!(p.weights(), &[1]);
+}
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -7,11 +19,11 @@ use crate::traits::Problem;
 fn test_steiner_tree_creation() {
     // Path graph: 0-1-2-3
     let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
-    let problem = SteinerTreeInGraphs::new(graph, vec![0, 3], vec![1i32, 2, 3]);
+    let problem = SteinerTreeInGraphs::new(graph, vec![0, 3], vec![1i64, 2, 3]);
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 3);
     assert_eq!(problem.terminals(), &[0, 3]);
-    assert_eq!(problem.dims().len(), 3);
+    assert_eq!(problem.dimensions().len(), 3);
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 3);
     assert_eq!(problem.num_terminals(), 2);
@@ -21,28 +33,28 @@ fn test_steiner_tree_creation() {
 fn test_steiner_tree_evaluation() {
     // Triangle graph: 0-1, 1-2, 0-2, with terminal {0, 2}
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
-    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2], vec![3i32, 4, 1]);
+    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2], vec![3i64, 4, 1]);
 
     // Select edge 0-2 (weight 1): valid, connects terminals directly
-    let config_direct = vec![0, 0, 1];
-    let result = problem.evaluate(&config_direct);
+    let config_direct = vec![false, false, true];
+    let result = problem.evaluate(&config_direct).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 1);
 
     // Select edges 0-1 and 1-2 (weights 3+4=7): valid, connects via vertex 1
-    let config_via = vec![1, 1, 0];
-    let result = problem.evaluate(&config_via);
+    let config_via = vec![true, true, false];
+    let result = problem.evaluate(&config_via).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 7);
 
     // Select only edge 0-1: invalid (terminal 2 not reached)
-    let config_invalid = vec![1, 0, 0];
-    let result = problem.evaluate(&config_invalid);
+    let config_invalid = vec![true, false, false];
+    let result = problem.evaluate(&config_invalid).unwrap();
     assert!(!result.is_valid());
 
     // Select no edges: invalid
-    let config_empty = vec![0, 0, 0];
-    let result = problem.evaluate(&config_empty);
+    let config_empty = vec![false, false, false];
+    let result = problem.evaluate(&config_empty).unwrap();
     assert!(!result.is_valid());
 }
 
@@ -61,12 +73,12 @@ fn test_steiner_tree_solver() {
     let problem = SteinerTreeInGraphs::new(graph, vec![0, 3], vec![2, 1, 2, 1]);
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     assert!(value.is_valid());
     assert_eq!(value.unwrap(), 2);
     // Should select edges 0-2 and 2-3
-    assert_eq!(solution, vec![0, 1, 0, 1]);
+    assert_eq!(solution, vec![false, true, false, true]);
 }
 
 #[test]
@@ -76,21 +88,21 @@ fn test_steiner_tree_with_steiner_vertices() {
     // Terminals: {0, 2, 3}
     // Optimal: use vertex 1 as Steiner vertex, select all 3 edges, weight = 3
     let graph = SimpleGraph::new(4, vec![(0, 1), (1, 2), (1, 3)]);
-    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2, 3], vec![1i32; 3]);
+    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2, 3], vec![1i64; 3]);
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     assert!(value.is_valid());
     assert_eq!(value.unwrap(), 3);
-    assert_eq!(solution, vec![1, 1, 1]);
+    assert_eq!(solution, vec![true, true, true]);
 }
 
 #[test]
 fn test_steiner_tree_is_valid_solution() {
     // Path graph: 0-1-2
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2], vec![1i32; 2]);
+    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2], vec![1i64; 2]);
 
     // Valid: both edges selected
     assert!(problem.is_valid_solution(&[1, 1]));
@@ -103,9 +115,9 @@ fn test_steiner_tree_is_valid_solution() {
 }
 
 #[test]
-fn test_steiner_tree_size_getters() {
+fn test_steiner_tree_parameter_getters() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]);
-    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2, 4], vec![1i32; 4]);
+    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2, 4], vec![1i64; 4]);
     assert_eq!(problem.num_vertices(), 5);
     assert_eq!(problem.num_edges(), 4);
     assert_eq!(problem.num_terminals(), 3);
@@ -114,7 +126,7 @@ fn test_steiner_tree_size_getters() {
 #[test]
 fn test_steiner_tree_problem_name() {
     assert_eq!(
-        <SteinerTreeInGraphs<SimpleGraph, i32> as Problem>::NAME,
+        <SteinerTreeInGraphs<SimpleGraph, i64> as Problem>::NAME,
         "SteinerTreeInGraphs"
     );
 }
@@ -122,9 +134,9 @@ fn test_steiner_tree_problem_name() {
 #[test]
 fn test_steiner_tree_serialization() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2], vec![1i32; 2]);
+    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2], vec![1i64; 2]);
     let json = serde_json::to_string(&problem).unwrap();
-    let deserialized: SteinerTreeInGraphs<SimpleGraph, i32> = serde_json::from_str(&json).unwrap();
+    let deserialized: SteinerTreeInGraphs<SimpleGraph, i64> = serde_json::from_str(&json).unwrap();
     assert_eq!(deserialized.graph().num_vertices(), 3);
     assert_eq!(deserialized.terminals(), &[0, 2]);
     assert_eq!(deserialized.num_edges(), 2);
@@ -134,10 +146,10 @@ fn test_steiner_tree_serialization() {
 fn test_steiner_tree_single_terminal() {
     // Single terminal: any config (including empty) is valid
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = SteinerTreeInGraphs::new(graph, vec![1], vec![1i32; 2]);
+    let problem = SteinerTreeInGraphs::new(graph, vec![1], vec![1i64; 2]);
 
     // No edges needed for a single terminal
-    let result = problem.evaluate(&[0, 0]);
+    let result = problem.evaluate(&vec![false, false]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 0);
 }
@@ -147,11 +159,11 @@ fn test_steiner_tree_all_vertices_terminal() {
     // When all vertices are terminals, it degenerates to spanning tree
     // Path: 0-1-2
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = SteinerTreeInGraphs::new(graph, vec![0, 1, 2], vec![1i32; 2]);
+    let problem = SteinerTreeInGraphs::new(graph, vec![0, 1, 2], vec![1i64; 2]);
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     assert!(value.is_valid());
     assert_eq!(value.unwrap(), 2);
 }
@@ -159,7 +171,7 @@ fn test_steiner_tree_all_vertices_terminal() {
 #[test]
 fn test_steiner_tree_edges_accessor() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2], vec![5i32, 10]);
+    let problem = SteinerTreeInGraphs::new(graph, vec![0, 2], vec![5i64, 10]);
     let edges = problem.edges();
     assert_eq!(edges.len(), 2);
     assert_eq!(edges[0].2, 5);
@@ -169,7 +181,7 @@ fn test_steiner_tree_edges_accessor() {
 #[test]
 fn test_steiner_tree_weights_management() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let mut problem = SteinerTreeInGraphs::new(graph, vec![0, 2], vec![1i32; 2]);
+    let mut problem = SteinerTreeInGraphs::new(graph, vec![0, 2], vec![1i64; 2]);
     assert!(problem.is_weighted());
     assert_eq!(problem.weights(), vec![1, 1]);
 
@@ -204,15 +216,17 @@ fn test_steiner_tree_example_from_issue() {
 
     // Brute-force verification: independently confirm optimal weight is 12
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&solution).unwrap();
     assert!(value.is_valid());
     assert_eq!(value.unwrap(), 12);
 
     // Verify the claimed optimal solution from the issue:
     // Edges: {0,1}(2) + {1,2}(1) + {2,4}(2) + {3,4}(3) + {4,5}(1) + {4,6}(2) + {6,7}(1) = 12
-    let config = vec![1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1];
-    let result = problem.evaluate(&config);
+    let config = vec![
+        true, false, true, false, true, true, false, true, true, false, false, true,
+    ];
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 12);
 }
diff --git a/src/unit_tests/models/graph/strong_connectivity_augmentation.rs b/src/unit_tests/models/graph/strong_connectivity_augmentation.rs
index 4577fb5ab..107ca5e19 100644
--- a/src/unit_tests/models/graph/strong_connectivity_augmentation.rs
+++ b/src/unit_tests/models/graph/strong_connectivity_augmentation.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 
@@ -19,7 +20,7 @@ fn issue_graph() -> DirectedGraph {
     )
 }
 
-fn issue_candidate_arcs() -> Vec<(usize, usize, i32)> {
+fn issue_candidate_arcs() -> Vec<(usize, usize, i64)> {
     vec![
         (3, 0, 5),
         (3, 1, 3),
@@ -42,15 +43,18 @@ fn issue_candidate_arcs() -> Vec<(usize, usize, i32)> {
     ]
 }
 
-fn issue_example_yes() -> StrongConnectivityAugmentation<i32> {
+fn issue_example_yes() -> StrongConnectivityAugmentation<i64> {
     StrongConnectivityAugmentation::new(issue_graph(), issue_candidate_arcs(), 1)
 }
 
-fn yes_config() -> Vec<usize> {
-    vec![0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+fn yes_config() -> Vec<bool> {
+    vec![
+        false, false, false, false, false, false, false, false, true, false, false, false, false,
+        false, false, false, false, false,
+    ]
 }
 
-fn issue_example_already_strongly_connected() -> StrongConnectivityAugmentation<i32> {
+fn issue_example_already_strongly_connected() -> StrongConnectivityAugmentation<i64> {
     StrongConnectivityAugmentation::new(
         DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]),
         vec![(0, 2, 5)],
@@ -67,7 +71,7 @@ fn test_strong_connectivity_augmentation_creation() {
     assert_eq!(problem.num_potential_arcs(), 18);
     assert_eq!(problem.candidate_arcs().len(), 18);
     assert_eq!(problem.bound(), &1);
-    assert_eq!(problem.dims(), vec![2; 18]);
+    assert_eq!(problem.dimensions(), vec![2; 18]);
     assert!(problem.is_weighted());
 }
 
@@ -76,36 +80,39 @@ fn test_strong_connectivity_augmentation_issue_example_yes() {
     let problem = issue_example_yes();
     let config = yes_config();
 
-    assert!(problem.evaluate(&config));
-    assert!(problem.is_valid_solution(&config));
+    assert!(problem.evaluate(&config).unwrap());
+    assert!(problem.is_valid_solution(&config).unwrap());
 }
 
 #[test]
 fn test_strong_connectivity_augmentation_issue_example_no() {
     let problem = issue_example_yes();
-    assert!(!problem.evaluate(&[0; 18]));
+    assert!(!problem.evaluate(&vec![false; 18]).unwrap());
 }
 
 #[test]
 fn test_strong_connectivity_augmentation_wrong_length() {
     let problem = issue_example_yes();
-    assert!(!problem.evaluate(&[0, 1]));
-    assert!(!problem.is_valid_solution(&[0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![false, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(!problem.is_valid_solution(&[false, true]).unwrap());
 }
 
 #[test]
 fn test_strong_connectivity_augmentation_already_strongly_connected() {
     let problem = issue_example_already_strongly_connected();
-    assert_eq!(problem.dims(), vec![2]);
-    assert!(problem.evaluate(&[0]));
-    assert!(!problem.evaluate(&[1]));
+    assert_eq!(problem.dimensions(), vec![2]);
+    assert!(problem.evaluate(&vec![false]).unwrap());
+    assert!(!problem.evaluate(&vec![true]).unwrap());
 }
 
 #[test]
 fn test_strong_connectivity_augmentation_serialization() {
     let problem = issue_example_yes();
     let json = serde_json::to_string(&problem).unwrap();
-    let restored: StrongConnectivityAugmentation<i32> = serde_json::from_str(&json).unwrap();
+    let restored: StrongConnectivityAugmentation<i64> = serde_json::from_str(&json).unwrap();
 
     assert_eq!(restored.graph(), problem.graph());
     assert_eq!(restored.candidate_arcs(), problem.candidate_arcs());
@@ -117,17 +124,17 @@ fn test_strong_connectivity_augmentation_solver() {
     let problem = issue_example_yes();
     let solver = BruteForce::new();
 
-    let satisfying = solver.find_witness(&problem).unwrap();
-    assert!(problem.evaluate(&satisfying));
+    let satisfying = solver.solve(&problem).unwrap().unwrap();
+    assert!(problem.evaluate(&satisfying).unwrap());
 
-    let all_satisfying = solver.find_all_witnesses(&problem);
+    let all_satisfying = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all_satisfying, vec![yes_config()]);
 }
 
 #[test]
 fn test_strong_connectivity_augmentation_variant() {
-    let variant = <StrongConnectivityAugmentation<i32> as Problem>::variant();
-    assert_eq!(variant, vec![("weight", "i32")]);
+    let variant = <StrongConnectivityAugmentation<i64> as Problem>::variant();
+    assert_eq!(variant, vec![("weight", "i64")]);
 }
 
 #[test]
diff --git a/src/unit_tests/models/graph/subgraph_isomorphism.rs b/src/unit_tests/models/graph/subgraph_isomorphism.rs
index b8248cd3f..bde097812 100644
--- a/src/unit_tests/models/graph/subgraph_isomorphism.rs
+++ b/src/unit_tests/models/graph/subgraph_isomorphism.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
@@ -13,7 +14,7 @@ fn test_subgraph_isomorphism_creation() {
     assert_eq!(problem.num_pattern_vertices(), 2);
     assert_eq!(problem.num_pattern_edges(), 1);
     // dims: 2 pattern vertices, each can map to 4 host vertices
-    assert_eq!(problem.dims(), vec![4, 4]);
+    assert_eq!(problem.dimensions(), vec![4, 4]);
 }
 
 #[test]
@@ -25,11 +26,11 @@ fn test_subgraph_isomorphism_evaluation_valid() {
     let problem = SubgraphIsomorphism::new(host, pattern);
 
     // Valid mapping: pattern vertex 0->host 0, pattern vertex 1->host 1
-    assert!(problem.evaluate(&[0, 1]));
+    assert!(problem.evaluate(&vec![0, 1]).unwrap());
     // Valid: 0->1, 1->2
-    assert!(problem.evaluate(&[1, 2]));
+    assert!(problem.evaluate(&vec![1, 2]).unwrap());
     // Valid: 0->0, 1->2
-    assert!(problem.evaluate(&[0, 2]));
+    assert!(problem.evaluate(&vec![0, 2]).unwrap());
 }
 
 #[test]
@@ -41,11 +42,11 @@ fn test_subgraph_isomorphism_evaluation_invalid() {
     let problem = SubgraphIsomorphism::new(host, pattern);
 
     // Invalid: non-injective (both map to same host vertex)
-    assert!(!problem.evaluate(&[0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0]).unwrap());
     // Invalid: no edge between host vertices 0 and 2
-    assert!(!problem.evaluate(&[0, 2]));
+    assert!(!problem.evaluate(&vec![0, 2]).unwrap());
     // Valid: 0->0, 1->1 (edge 0-1 exists)
-    assert!(problem.evaluate(&[0, 1]));
+    assert!(problem.evaluate(&vec![0, 1]).unwrap());
 }
 
 #[test]
@@ -57,12 +58,12 @@ fn test_subgraph_isomorphism_triangle_in_k4() {
     let problem = SubgraphIsomorphism::new(host, pattern);
 
     // Any injective mapping into K4 should work for K3
-    assert!(problem.evaluate(&[0, 1, 2]));
-    assert!(problem.evaluate(&[1, 2, 3]));
-    assert!(problem.evaluate(&[0, 2, 3]));
+    assert!(problem.evaluate(&vec![0, 1, 2]).unwrap());
+    assert!(problem.evaluate(&vec![1, 2, 3]).unwrap());
+    assert!(problem.evaluate(&vec![0, 2, 3]).unwrap());
 
     // Non-injective should fail
-    assert!(!problem.evaluate(&[0, 0, 1]));
+    assert!(!problem.evaluate(&vec![0, 0, 1]).unwrap());
 }
 
 #[test]
@@ -75,7 +76,7 @@ fn test_subgraph_isomorphism_no_solution() {
 
     // No possible mapping should work
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
@@ -88,11 +89,11 @@ fn test_subgraph_isomorphism_solver() {
     let problem = SubgraphIsomorphism::new(host, pattern);
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
 
     let sol = solution.unwrap();
-    assert!(problem.evaluate(&sol));
+    assert!(problem.evaluate(&sol).unwrap());
 }
 
 #[test]
@@ -104,11 +105,11 @@ fn test_subgraph_isomorphism_all_satisfying() {
     let problem = SubgraphIsomorphism::new(host, pattern);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // 3 edges in host, each can be mapped in 2 directions = 6 solutions
     assert_eq!(solutions.len(), 6);
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -141,8 +142,8 @@ fn test_subgraph_isomorphism_is_valid_solution() {
     let pattern = SimpleGraph::new(2, vec![(0, 1)]);
     let problem = SubgraphIsomorphism::new(host, pattern);
 
-    assert!(problem.is_valid_solution(&[0, 1]));
-    assert!(!problem.is_valid_solution(&[0, 0]));
+    assert!(problem.is_valid_solution(&[0, 1]).unwrap());
+    assert!(!problem.is_valid_solution(&[0, 0]).unwrap());
 }
 
 #[test]
@@ -153,11 +154,11 @@ fn test_subgraph_isomorphism_empty_pattern() {
     let problem = SubgraphIsomorphism::new(host, pattern);
 
     // Any two distinct host vertices work
-    assert!(problem.evaluate(&[0, 1]));
-    assert!(problem.evaluate(&[1, 2]));
-    assert!(problem.evaluate(&[0, 2]));
+    assert!(problem.evaluate(&vec![0, 1]).unwrap());
+    assert!(problem.evaluate(&vec![1, 2]).unwrap());
+    assert!(problem.evaluate(&vec![0, 2]).unwrap());
     // Non-injective fails
-    assert!(!problem.evaluate(&[0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0]).unwrap());
 }
 
 #[test]
@@ -184,17 +185,17 @@ fn test_subgraph_isomorphism_issue_example() {
     let problem = SubgraphIsomorphism::new(host, pattern);
 
     // The mapping from the issue: a->0, b->1, c->2, d->3
-    assert!(problem.evaluate(&[0, 1, 2, 3]));
+    assert!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap());
 
     // Verify solver can find a solution
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
-fn test_subgraph_isomorphism_size_getters() {
+fn test_subgraph_isomorphism_parameter_getters() {
     let host = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]);
     let pattern = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = SubgraphIsomorphism::new(host, pattern);
diff --git a/src/unit_tests/models/graph/traveling_salesman.rs b/src/unit_tests/models/graph/traveling_salesman.rs
index 1dc55c774..ef89561a5 100644
--- a/src/unit_tests/models/graph/traveling_salesman.rs
+++ b/src/unit_tests/models/graph/traveling_salesman.rs
@@ -1,10 +1,11 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
 
-fn k4_tsp() -> TravelingSalesman<SimpleGraph, i32> {
+fn k4_tsp() -> TravelingSalesman<SimpleGraph, i64> {
     TravelingSalesman::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
         vec![10, 15, 20, 35, 25, 30],
@@ -17,13 +18,13 @@ fn test_traveling_salesman_creation() {
     let problem = k4_tsp();
     assert_eq!(problem.graph().num_vertices(), 4);
     assert_eq!(problem.graph().num_edges(), 6);
-    assert_eq!(problem.dims().len(), 6);
+    assert_eq!(problem.dimensions().len(), 6);
 }
 
 #[test]
 fn test_traveling_salesman_unit_weights() {
-    // i32 type is always considered weighted, even with uniform values
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    // i64 type is always considered weighted, even with uniform values
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         5,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)],
     ));
@@ -41,12 +42,17 @@ fn test_traveling_salesman_weighted() {
 #[test]
 fn test_evaluate_valid_cycle() {
     // C5 cycle graph with unit weights: all 5 edges form the only Hamiltonian cycle
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         5,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)],
     ));
     // Select all edges -> valid Hamiltonian cycle, cost = 5
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1, 1]), Min(Some(5)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, true, true])
+            .unwrap(),
+        Min(Some(5))
+    );
 }
 
 #[test]
@@ -55,37 +61,57 @@ fn test_evaluate_invalid_degree() {
     let problem = k4_tsp();
     // edges: 0-1, 0-2, 0-3, 1-2, 1-3, 2-3
     // Select first 3 edges (all incident to 0): degree(0)=3 -> Invalid
-    assert_eq!(problem.evaluate(&[1, 1, 1, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, false, false, false])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_evaluate_invalid_not_connected() {
     // 6 vertices, two disjoint triangles: 0-1-2-0 and 3-4-5-3
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         6,
         vec![(0, 1), (1, 2), (0, 2), (3, 4), (4, 5), (3, 5)],
     ));
     // Select all 6 edges: two disjoint cycles, not a single Hamiltonian cycle
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1, 1, 1]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, true, true, true])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_evaluate_invalid_wrong_edge_count() {
     // C5 with only 4 edges selected -> not enough edges
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         5,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)],
     ));
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, true, false])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_evaluate_no_edges_selected() {
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         5,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)],
     ));
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, false, false, false, false])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -93,56 +119,56 @@ fn test_brute_force_k4() {
     // Instance 1 from issue: K4 with weights
     let problem = k4_tsp();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     // Optimal cycle: 0->1->3->2->0, cost = 10+25+30+15 = 80
     for sol in &solutions {
-        assert_eq!(problem.evaluate(sol), Min(Some(80)));
+        assert_eq!(problem.evaluate(sol).unwrap(), Min(Some(80)));
     }
 }
 
 #[test]
 fn test_brute_force_path_graph_no_solution() {
     // Instance 2 from issue: path graph, no Hamiltonian cycle exists
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         4,
         vec![(0, 1), (1, 2), (2, 3)],
     ));
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(solutions.is_empty());
 }
 
 #[test]
 fn test_brute_force_c5_unique_solution() {
     // Instance 3 from issue: C5 cycle graph, unique Hamiltonian cycle
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         5,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)],
     ));
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![1, 1, 1, 1, 1]);
-    assert_eq!(problem.evaluate(&solutions[0]), Min(Some(5)));
+    assert_eq!(solutions[0], vec![true, true, true, true, true]);
+    assert_eq!(problem.evaluate(&solutions[0]).unwrap(), Min(Some(5)));
 }
 
 #[test]
 fn test_brute_force_bipartite_no_solution() {
     // Instance 4 from issue: K_{2,3} bipartite, no Hamiltonian cycle
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         5,
         vec![(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4)],
     ));
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(solutions.is_empty());
 }
 
 #[test]
 fn test_problem_name() {
     assert_eq!(
-        <TravelingSalesman<SimpleGraph, i32> as Problem>::NAME,
+        <TravelingSalesman<SimpleGraph, i64> as Problem>::NAME,
         "TravelingSalesman"
     );
 }
@@ -163,7 +189,7 @@ fn test_is_hamiltonian_cycle_function() {
 
 #[test]
 fn test_set_weights() {
-    let mut problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let mut problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         3,
         vec![(0, 1), (1, 2), (0, 2)],
     ));
@@ -193,7 +219,7 @@ fn test_new() {
 
 #[test]
 fn test_unit_weights() {
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         3,
         vec![(0, 1), (1, 2), (0, 2)],
     ));
@@ -208,10 +234,10 @@ fn test_brute_force_triangle_weighted() {
         vec![5, 10, 15],
     );
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![1, 1, 1]);
-    assert_eq!(problem.evaluate(&solutions[0]), Min(Some(30)));
+    assert_eq!(solutions[0], vec![true, true, true]);
+    assert_eq!(problem.evaluate(&solutions[0]).unwrap(), Min(Some(30)));
 }
 
 #[test]
@@ -222,16 +248,16 @@ fn test_is_valid_solution() {
         vec![1, 2, 3],
     );
     // Valid: select all 3 edges forms Hamiltonian cycle 0-1-2-0
-    assert!(problem.is_valid_solution(&[1, 1, 1]));
+    assert!(problem.is_valid_solution(&[true, true, true]));
     // Invalid: select only 2 edges — not a cycle
-    assert!(!problem.is_valid_solution(&[1, 1, 0]));
+    assert!(!problem.is_valid_solution(&[true, true, false]));
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = TravelingSalesman::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
     assert_eq!(problem.num_vertices(), 3);
     assert_eq!(problem.num_edges(), 3);
@@ -247,11 +273,22 @@ fn test_tsp_paper_example() {
     );
     // Edges: 0=(0,1), 1=(0,2), 2=(0,3), 3=(1,2), 4=(1,3), 5=(2,3)
     // Tour uses edges 0, 2, 3, 5
-    let config = vec![1, 0, 1, 1, 0, 1];
-    let result = problem.evaluate(&config);
+    let config = vec![true, false, true, true, false, true];
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Min(Some(6)));
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best), Min(Some(6)));
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap(), Min(Some(6)));
+}
+#[test]
+fn create_spec_uses_edge_weights_and_defaults_to_one() {
+    let problem = TravelingSalesman::try_from(TravelingSalesmanCreateSpec {
+        graph: vec![(0, 1), (1, 2), (2, 0)],
+        num_vertices: None,
+        edge_weights: None,
+    })
+    .unwrap();
+    assert_eq!(problem.weights(), vec![1, 1, 1]);
+    assert_eq!(TravelingSalesmanCreateSpec::FIELDS[2].name, "edge_weights");
 }
diff --git a/src/unit_tests/models/graph/undirected_flow_lower_bounds.rs b/src/unit_tests/models/graph/undirected_flow_lower_bounds.rs
index ab54df324..c67868b1c 100644
--- a/src/unit_tests/models/graph/undirected_flow_lower_bounds.rs
+++ b/src/unit_tests/models/graph/undirected_flow_lower_bounds.rs
@@ -1,4 +1,24 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_lower_bound_above_capacity() {
+    assert_eq!(
+        UndirectedFlowLowerBoundsCreateSpec::FIELDS[2].name,
+        "lower_bounds"
+    );
+    assert!(
+        UndirectedFlowLowerBounds::try_from(UndirectedFlowLowerBoundsCreateSpec {
+            graph: SimpleGraph::new(2, vec![(0, 1)]),
+            capacities: vec![1],
+            lower_bounds: vec![2],
+            source: 0,
+            sink: 1,
+            requirement: 1
+        })
+        .is_err()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
@@ -28,8 +48,8 @@ fn canonical_no_instance() -> UndirectedFlowLowerBounds {
     )
 }
 
-fn yes_orientation_config() -> Vec<usize> {
-    vec![0, 0, 0, 0, 0, 0, 0]
+fn yes_orientation_config() -> Vec<bool> {
+    vec![false, false, false, false, false, false, false]
 }
 
 #[test]
@@ -44,22 +64,22 @@ fn test_undirected_flow_lower_bounds_creation() {
     assert_eq!(problem.requirement(), 3);
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_edges(), 7);
-    assert_eq!(problem.dims(), vec![2; 7]);
+    assert_eq!(problem.dimensions(), vec![2; 7]);
 }
 
 #[test]
 fn test_undirected_flow_lower_bounds_evaluation_yes() {
     let problem = canonical_yes_instance();
     let config = yes_orientation_config();
-    assert!(problem.evaluate(&config));
-    assert!(problem.is_valid_solution(&config));
+    assert!(problem.evaluate(&config).unwrap());
+    assert!(problem.is_valid_solution(&config).unwrap());
 }
 
 #[test]
 fn test_undirected_flow_lower_bounds_evaluation_no() {
     let problem = canonical_no_instance();
-    assert!(!problem.evaluate(&[0, 0, 0, 0]));
-    assert!(BruteForce::new().find_witness(&problem).is_none());
+    assert!(!problem.evaluate(&vec![false, false, false, false]).unwrap());
+    assert!(BruteForce::new().solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -67,7 +87,10 @@ fn test_undirected_flow_lower_bounds_rejects_wrong_config_length() {
     let problem = canonical_yes_instance();
     let mut config = yes_orientation_config();
     config.pop();
-    assert!(!problem.evaluate(&config));
+    assert!(matches!(
+        problem.evaluate(&config),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -87,9 +110,10 @@ fn test_undirected_flow_lower_bounds_serialization() {
 fn test_undirected_flow_lower_bounds_solver_yes() {
     let problem = canonical_yes_instance();
     let solution = BruteForce::new()
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("expected a satisfying orientation");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
     assert_eq!(solution.len(), problem.num_edges());
 }
 
@@ -97,8 +121,8 @@ fn test_undirected_flow_lower_bounds_solver_yes() {
 fn test_undirected_flow_lower_bounds_paper_example() {
     let problem = canonical_yes_instance();
     let config = yes_orientation_config();
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
-    let all = BruteForce::new().find_all_witnesses(&problem);
+    let all = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert!(all.contains(&config));
 }
diff --git a/src/unit_tests/models/graph/undirected_two_commodity_integral_flow.rs b/src/unit_tests/models/graph/undirected_two_commodity_integral_flow.rs
index c34f21bc9..d09689d25 100644
--- a/src/unit_tests/models/graph/undirected_two_commodity_integral_flow.rs
+++ b/src/unit_tests/models/graph/undirected_two_commodity_integral_flow.rs
@@ -1,4 +1,24 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_validates_capacity_shape() {
+    let problem = UndirectedTwoCommodityIntegralFlow::try_from(
+        UndirectedTwoCommodityIntegralFlowCreateSpec {
+            graph: vec![(0, 1)],
+            num_vertices: None,
+            capacities: vec![1],
+            source_1: 0,
+            sink_1: 1,
+            source_2: 1,
+            sink_2: 0,
+            requirement_1: 1,
+            requirement_2: 1,
+        },
+    )
+    .unwrap();
+    assert_eq!(problem.capacities(), &[1]);
+}
 use crate::solvers::BruteForce;
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
@@ -51,22 +71,25 @@ fn test_undirected_two_commodity_integral_flow_creation() {
     assert_eq!(problem.requirement_2(), 1);
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 3);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3]);
+    assert_eq!(
+        problem.dimensions(),
+        vec![2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+    );
 }
 
 #[test]
 fn test_undirected_two_commodity_integral_flow_evaluation_yes() {
     let problem = canonical_instance();
-    assert!(problem.evaluate(&example_config()));
-    assert!(problem.is_valid_solution(&example_config()));
+    assert!(problem.evaluate(&example_config()).unwrap());
+    assert!(problem.is_valid_solution(&example_config()).unwrap());
 }
 
 #[test]
 fn test_undirected_two_commodity_integral_flow_evaluation_no_shared_bottleneck() {
     let problem = shared_bottleneck_instance();
-    assert!(!problem.evaluate(&example_config()));
-    assert!(!problem.is_valid_solution(&example_config()));
-    assert!(BruteForce::new().find_witness(&problem).is_none());
+    assert!(!problem.evaluate(&example_config()).unwrap());
+    assert!(!problem.is_valid_solution(&example_config()).unwrap());
+    assert!(BruteForce::new().solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -75,7 +98,10 @@ fn test_undirected_two_commodity_integral_flow_rejects_wrong_config_length() {
     let mut config = example_config();
     config.pop();
 
-    assert!(!problem.evaluate(&config));
+    assert!(matches!(
+        problem.evaluate(&config),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -84,7 +110,7 @@ fn test_undirected_two_commodity_integral_flow_rejects_value_above_capacity_doma
     let mut config = example_config();
     config[8] = 3;
 
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -94,7 +120,7 @@ fn test_undirected_two_commodity_integral_flow_rejects_antisymmetry_violation()
     config[0] = 1;
     config[1] = 1;
 
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -116,17 +142,17 @@ fn test_undirected_two_commodity_integral_flow_serialization() {
 fn test_undirected_two_commodity_integral_flow_paper_example() {
     let problem = canonical_instance();
     let config = example_config();
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
-    let all = BruteForce::new().find_all_witnesses(&problem);
-    assert_eq!(all.len(), 2);
+    let all = BruteForce::new().find_all_witnesses(&problem).unwrap();
+    assert_eq!(all.len(), 1);
     assert!(all.contains(&config));
 }
 
 #[test]
 fn test_undirected_two_commodity_integral_flow_large_capacity_sink_balance() {
     // Use a moderately large capacity that fits in usize on all platforms.
-    let large: u64 = 1_000_000;
+    let large: i64 = 1_000_000;
     let large_usize = large as usize;
     let problem = UndirectedTwoCommodityIntegralFlow::new(
         SimpleGraph::new(2, vec![(0, 1)]),
@@ -139,7 +165,7 @@ fn test_undirected_two_commodity_integral_flow_large_capacity_sink_balance() {
         0,
     );
 
-    assert!(problem.evaluate(&[large_usize, 0, 0, 0]));
+    assert!(problem.evaluate(&vec![large_usize, 0, 0, 0]).unwrap());
 }
 
 #[test]
@@ -157,7 +183,7 @@ fn test_undirected_two_commodity_integral_flow_shared_capacity_exceeded() {
     );
 
     // f1(0->1)=2, f1(1->0)=0, f2(0->1)=2, f2(1->0)=0 => shared = 4 > 3
-    assert!(!problem.evaluate(&[2, 0, 2, 0]));
+    assert!(!problem.evaluate(&vec![2, 0, 2, 0]).unwrap());
 }
 
 #[test]
@@ -208,5 +234,5 @@ fn test_undirected_two_commodity_integral_flow_flow_conservation_violated() {
     // Edge (0,1): f1(0->1)=1, f1(1->0)=0, f2=0,0
     // Edge (1,2): f1(1->2)=0, f1(2->1)=0, f2=0,0
     // Vertex 1 gets +1 for commodity 1 from edge (0,1) but no outflow on edge (1,2)
-    assert!(!problem.evaluate(&[1, 0, 0, 0, 0, 0, 0, 0]));
+    assert!(!problem.evaluate(&vec![1, 0, 0, 0, 0, 0, 0, 0]).unwrap());
 }
diff --git a/src/unit_tests/models/misc/additional_key.rs b/src/unit_tests/models/misc/additional_key.rs
index b66bf9148..8df337615 100644
--- a/src/unit_tests/models/misc/additional_key.rs
+++ b/src/unit_tests/models/misc/additional_key.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 /// Instance 1: 6 attributes, cyclic FDs, 3 known keys.
@@ -30,7 +31,7 @@ fn test_additional_key_creation() {
     assert_eq!(problem.num_dependencies(), 5);
     assert_eq!(problem.num_relation_attrs(), 6);
     assert_eq!(problem.num_known_keys(), 3);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2, 2, 2]);
     assert_eq!(<AdditionalKey as Problem>::NAME, "AdditionalKey");
     assert_eq!(<AdditionalKey as Problem>::variant(), vec![]);
     // Data getters
@@ -50,14 +51,18 @@ fn test_additional_key_evaluate_satisfying() {
     // Minimality: remove 0 => {2}, closure of {2} = {2} => does not cover all. OK.
     //             remove 2 => {0}, closure of {0} = {0} => does not cover all. OK.
     // {0,2} sorted is [0,2], not in known_keys [{0,1},{2,3},{4,5}].
-    assert!(problem.evaluate(&[1, 0, 1, 0, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![true, false, true, false, false, false])
+        .unwrap());
 }
 
 #[test]
 fn test_additional_key_evaluate_known_key() {
     let problem = instance1();
     // Config [1,1,0,0,0,0] selects attrs {0,1} which IS in known_keys.
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, false, false, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -65,7 +70,9 @@ fn test_additional_key_evaluate_not_a_key() {
     let problem = instance1();
     // Config [0,0,0,0,0,1] selects {5}. Closure of {5} = {5}.
     // Does not cover all attrs.
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0, 1]));
+    assert!(!problem
+        .evaluate(&vec![false, false, false, false, false, true])
+        .unwrap());
 }
 
 #[test]
@@ -73,7 +80,9 @@ fn test_additional_key_evaluate_non_minimal() {
     let problem = instance1();
     // Config [1,1,1,0,0,0] selects {0,1,2}.
     // {0,1} alone determines all attrs (known key), so {0,1,2} is NOT minimal.
-    assert!(!problem.evaluate(&[1, 1, 1, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, false, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -81,21 +90,31 @@ fn test_additional_key_no_additional_key() {
     let problem = instance2();
     // Only candidate key is {0}, which is already known.
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
 #[test]
 fn test_additional_key_wrong_config_length() {
     let problem = instance1();
-    assert!(!problem.evaluate(&[1, 0]));
-    assert!(!problem.evaluate(&[1, 0, 0, 0, 0, 0, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false, false, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_additional_key_invalid_variable_value() {
     let problem = instance1();
-    assert!(!problem.evaluate(&[2, 0, 0, 0, 0, 0]));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, false, false, false, false, false])
+    )
+    .is_err());
 }
 
 #[test]
@@ -103,20 +122,21 @@ fn test_additional_key_brute_force() {
     let problem = instance1();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_additional_key_brute_force_all() {
     let problem = instance1();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // Exactly 2 additional keys: {0,2} and {0,3,5}
     assert_eq!(solutions.len(), 2);
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -131,8 +151,12 @@ fn test_additional_key_serialization() {
     assert_eq!(restored.num_known_keys(), problem.num_known_keys());
     // Verify round-trip produces same evaluation
     assert_eq!(
-        problem.evaluate(&[1, 0, 1, 0, 0, 0]),
-        restored.evaluate(&[1, 0, 1, 0, 0, 0])
+        problem
+            .evaluate(&vec![true, false, true, false, false, false])
+            .unwrap(),
+        restored
+            .evaluate(&vec![true, false, true, false, false, false])
+            .unwrap()
     );
 }
 
@@ -140,7 +164,9 @@ fn test_additional_key_serialization() {
 fn test_additional_key_empty_selection() {
     let problem = instance1();
     // All zeros = no attributes selected = not a key
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![false, false, false, false, false, false])
+        .unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/betweenness.rs b/src/unit_tests/models/misc/betweenness.rs
index 1a2d1b4fa..ffd895343 100644
--- a/src/unit_tests/models/misc/betweenness.rs
+++ b/src/unit_tests/models/misc/betweenness.rs
@@ -1,5 +1,6 @@
 use crate::models::misc::Betweenness;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -16,7 +17,7 @@ fn test_betweenness_basic() {
         problem.triples(),
         &[(0, 1, 2), (2, 3, 4), (0, 2, 4), (1, 3, 4)]
     );
-    assert_eq!(problem.dims(), vec![5; 5]);
+    assert_eq!(problem.dimensions(), vec![5; 5]);
     assert_eq!(problem.num_variables(), 5);
     assert_eq!(<Betweenness as Problem>::NAME, "Betweenness");
     assert_eq!(<Betweenness as Problem>::variant(), vec![]);
@@ -26,25 +27,31 @@ fn test_betweenness_basic() {
 fn test_betweenness_evaluate_identity_permutation() {
     let problem = example_problem();
     // Identity permutation: element i is at position i
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 4]), Or(true));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2, 3, 4]).unwrap(), Or(true));
 }
 
 #[test]
 fn test_betweenness_evaluate_reverse_permutation() {
     let problem = example_problem();
     // Reverse permutation: element i is at position 4-i
-    assert_eq!(problem.evaluate(&[4, 3, 2, 1, 0]), Or(true));
+    assert_eq!(problem.evaluate(&vec![4, 3, 2, 1, 0]).unwrap(), Or(true));
 }
 
 #[test]
 fn test_betweenness_evaluate_invalid_permutation() {
     let problem = example_problem();
     // Not a permutation (duplicate positions)
-    assert_eq!(problem.evaluate(&[0, 0, 1, 2, 3]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 0, 1, 2, 3]).unwrap(), Or(false));
     // Position out of range
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 5]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -52,15 +59,15 @@ fn test_betweenness_evaluate_unsatisfying_permutation() {
     let problem = example_problem();
     // Permutation [1, 0, 2, 3, 4]: triple (0,1,2) => f(0)=1, f(1)=0, f(2)=2
     // Need f(0)<f(1)<f(2) or f(2)<f(1)<f(0), i.e., 1<0<2 or 2<0<1 — neither holds
-    assert_eq!(problem.evaluate(&[1, 0, 2, 3, 4]), Or(false));
+    assert_eq!(problem.evaluate(&vec![1, 0, 2, 3, 4]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_betweenness_solver_finds_witness() {
     let problem = example_problem();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Or(true));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Or(true));
 }
 
 #[test]
@@ -70,7 +77,7 @@ fn test_betweenness_unsatisfiable_instance() {
     // requires 2 between 0 and 1, these are contradictory for 3 elements.
     let problem = Betweenness::new(3, vec![(0, 1, 2), (1, 0, 2), (0, 2, 1)]);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/bin_packing.rs b/src/unit_tests/models/misc/bin_packing.rs
index cb1c7568f..b0a8e77eb 100644
--- a/src/unit_tests/models/misc/bin_packing.rs
+++ b/src/unit_tests/models/misc/bin_packing.rs
@@ -1,16 +1,17 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
 fn test_bin_packing_creation() {
-    let problem = BinPacking::new(vec![6, 6, 5, 5, 4, 4], 10);
+    let problem = BinPacking::new(vec![6, 6, 5, 5, 4, 4], 10).unwrap();
     assert_eq!(problem.num_items(), 6);
     assert_eq!(problem.sizes(), &[6, 6, 5, 5, 4, 4]);
     assert_eq!(*problem.capacity(), 10);
-    assert_eq!(problem.dims().len(), 6);
+    assert_eq!(problem.dimensions().len(), 6);
     // Each variable has domain {0, ..., 5}
-    assert!(problem.dims().iter().all(|&d| d == 6));
+    assert!(problem.dimensions().iter().all(|&d| d == 6));
 }
 
 #[test]
@@ -20,8 +21,8 @@ fn test_bin_packing_evaluate_valid() {
     // Bin 0: items 0,4 -> 6+4=10 OK
     // Bin 1: items 1,5 -> 6+4=10 OK
     // Bin 2: items 2,3 -> 5+5=10 OK
-    let problem = BinPacking::new(vec![6, 6, 5, 5, 4, 4], 10);
-    let result = problem.evaluate(&[0, 1, 2, 2, 0, 1]);
+    let problem = BinPacking::new(vec![6, 6, 5, 5, 4, 4], 10).unwrap();
+    let result = problem.evaluate(&vec![0, 1, 2, 2, 0, 1]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 3);
 }
@@ -29,16 +30,16 @@ fn test_bin_packing_evaluate_valid() {
 #[test]
 fn test_bin_packing_evaluate_invalid_overweight() {
     // Bin 0: items 0,1 -> 6+6=12 > 10
-    let problem = BinPacking::new(vec![6, 6, 5, 5, 4, 4], 10);
-    let result = problem.evaluate(&[0, 0, 1, 1, 2, 2]);
+    let problem = BinPacking::new(vec![6, 6, 5, 5, 4, 4], 10).unwrap();
+    let result = problem.evaluate(&vec![0, 0, 1, 1, 2, 2]).unwrap();
     assert!(!result.is_valid());
 }
 
 #[test]
 fn test_bin_packing_evaluate_single_bin() {
     // All items fit in one bin
-    let problem = BinPacking::new(vec![1, 2, 3], 10);
-    let result = problem.evaluate(&[0, 0, 0]);
+    let problem = BinPacking::new(vec![1, 2, 3], 10).unwrap();
+    let result = problem.evaluate(&vec![0, 0, 0]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 1);
 }
@@ -46,27 +47,28 @@ fn test_bin_packing_evaluate_single_bin() {
 #[test]
 fn test_bin_packing_evaluate_all_separate() {
     // Each item in its own bin
-    let problem = BinPacking::new(vec![3, 3, 3], 5);
-    let result = problem.evaluate(&[0, 1, 2]);
+    let problem = BinPacking::new(vec![3, 3, 3], 5).unwrap();
+    let result = problem.evaluate(&vec![0, 1, 2]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 3);
 }
 
 #[test]
 fn test_bin_packing_problem_name() {
-    assert_eq!(<BinPacking<i32> as Problem>::NAME, "BinPacking");
+    assert_eq!(<BinPacking<i64> as Problem>::NAME, "BinPacking");
 }
 
 #[test]
 fn test_bin_packing_brute_force_solver() {
     // 6 items, capacity 10, sizes [6, 6, 5, 5, 4, 4]
     // Optimal: 3 bins (lower bound ceil(30/10) = 3)
-    let problem = BinPacking::new(vec![6, 6, 5, 5, 4, 4], 10);
+    let problem = BinPacking::new(vec![6, 6, 5, 5, 4, 4], 10).unwrap();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     assert!(metric.is_valid());
     assert_eq!(metric.unwrap(), 3);
 }
@@ -75,64 +77,80 @@ fn test_bin_packing_brute_force_solver() {
 fn test_bin_packing_brute_force_small() {
     // 3 items [3, 3, 4], capacity 7
     // Optimal: 2 bins (e.g., {3,4} + {3})
-    let problem = BinPacking::new(vec![3, 3, 4], 7);
+    let problem = BinPacking::new(vec![3, 3, 4], 7).unwrap();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     assert!(metric.is_valid());
     assert_eq!(metric.unwrap(), 2);
 }
 
 #[test]
 fn test_bin_packing_empty_items() {
-    let problem = BinPacking::new(Vec::<i32>::new(), 10);
+    let problem = BinPacking::new(Vec::<i64>::new(), 10).unwrap();
     assert_eq!(problem.num_items(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    let result = problem.evaluate(&[]);
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    let result = problem.evaluate(&vec![]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 0);
 }
 
 #[test]
 fn test_bin_packing_wrong_config_length() {
-    let problem = BinPacking::new(vec![3, 3, 4], 7);
-    assert!(!problem.evaluate(&[0, 1]).is_valid());
-    assert!(!problem.evaluate(&[0, 1, 2, 3]).is_valid());
+    let problem = BinPacking::new(vec![3, 3, 4], 7).unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_bin_packing_out_of_range_bin() {
-    let problem = BinPacking::new(vec![3, 3, 4], 7);
+    let problem = BinPacking::new(vec![3, 3, 4], 7).unwrap();
     // Bin index 3 is out of range for 3 items (valid range 0..3)
-    assert!(!problem.evaluate(&[0, 1, 3]).is_valid());
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_bin_packing_f64() {
-    let problem = BinPacking::new(vec![2.5, 3.5, 4.0], 7.0);
+    let problem = BinPacking::new(vec![2.5, 3.5, 4.0], 7.0).unwrap();
     // All fit in one bin: 2.5 + 3.5 + 4.0 = 10.0 > 7.0
-    assert!(!problem.evaluate(&[0, 0, 0]).is_valid());
+    assert!(!problem.evaluate(&vec![0, 0, 0]).unwrap().is_valid());
     // Two bins: {2.5, 3.5} = 6.0, {4.0} = 4.0
-    let result = problem.evaluate(&[0, 0, 1]);
+    let result = problem.evaluate(&vec![0, 0, 1]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 2);
 }
 
 #[test]
 fn test_bin_packing_variant() {
-    let v = <BinPacking<i32> as Problem>::variant();
-    assert_eq!(v, vec![("weight", "i32")]);
+    let v = <BinPacking<i64> as Problem>::variant();
+    assert_eq!(v, vec![("weight", "i64")]);
     let v64 = <BinPacking<f64> as Problem>::variant();
     assert_eq!(v64, vec![("weight", "f64")]);
 }
 
 #[test]
 fn test_bin_packing_serialization() {
-    let problem = BinPacking::new(vec![6, 6, 5, 5, 4, 4], 10);
+    let problem = BinPacking::new(vec![6, 6, 5, 5, 4, 4], 10).unwrap();
     let json = serde_json::to_value(&problem).unwrap();
-    let restored: BinPacking<i32> = serde_json::from_value(json).unwrap();
+    let restored: BinPacking<i64> = serde_json::from_value(json).unwrap();
     assert_eq!(restored.sizes(), problem.sizes());
     assert_eq!(restored.capacity(), problem.capacity());
 }
+
+#[test]
+fn test_bin_packing_rejects_non_finite_values() {
+    assert!(BinPacking::new(vec![f64::NAN], 1.0).is_err());
+    assert!(BinPacking::new(vec![1.0], f64::INFINITY).is_err());
+}
diff --git a/src/unit_tests/models/misc/boyce_codd_normal_form_violation.rs b/src/unit_tests/models/misc/boyce_codd_normal_form_violation.rs
index d036f415e..a15ea8bd2 100644
--- a/src/unit_tests/models/misc/boyce_codd_normal_form_violation.rs
+++ b/src/unit_tests/models/misc/boyce_codd_normal_form_violation.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 /// Build the canonical example: 6 attributes, 3 FDs, full target subset.
@@ -15,6 +16,22 @@ fn canonical_problem() -> BoyceCoddNormalFormViolation {
     )
 }
 
+#[test]
+fn test_bcnf_create_spec_uses_construction_names() {
+    let names: Vec<_> = BoyceCoddNormalFormViolationCreateSpec::FIELDS
+        .iter()
+        .map(|field| field.name)
+        .collect();
+    assert_eq!(names, ["n", "subsets", "target"]);
+    let problem = BoyceCoddNormalFormViolation::try_from(BoyceCoddNormalFormViolationCreateSpec {
+        n: 3,
+        subsets: vec![(vec![0], vec![1])],
+        target: vec![0, 1, 2],
+    })
+    .unwrap();
+    assert_eq!(problem.num_attributes(), 3);
+}
+
 #[test]
 fn test_bcnf_creation() {
     let problem = canonical_problem();
@@ -22,7 +39,7 @@ fn test_bcnf_creation() {
     assert_eq!(problem.num_functional_deps(), 3);
     assert_eq!(problem.num_target_attributes(), 6);
     assert_eq!(problem.num_variables(), 6);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert_eq!(problem.target_subset(), &[0, 1, 2, 3, 4, 5]);
     assert_eq!(problem.functional_deps().len(), 3);
 }
@@ -31,7 +48,9 @@ fn test_bcnf_creation() {
 fn test_bcnf_evaluate_violation() {
     let problem = canonical_problem();
     // X = {2}: closure = {2, 3}. In A' \ X = {0,1,3,4,5}: 3 ∈ closure, 0 ∉ closure → violation.
-    assert!(problem.evaluate(&[0, 0, 1, 0, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![false, false, true, false, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -39,41 +58,55 @@ fn test_bcnf_evaluate_no_violation_empty_x() {
     let problem = canonical_problem();
     // X = {} (all zeros): A' \ X = all attributes, closure of {} = {}.
     // Nothing in closure → no violation.
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![false, false, false, false, false, false])
+        .unwrap());
 }
 
 #[test]
 fn test_bcnf_evaluate_no_violation_x_covers_all() {
     let problem = canonical_problem();
     // X = all attributes: A' \ X = {} → no attributes to test → no violation.
-    assert!(!problem.evaluate(&[1, 1, 1, 1, 1, 1]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, true, true, true])
+        .unwrap());
 }
 
 #[test]
 fn test_bcnf_evaluate_invalid_config_length() {
     let problem = canonical_problem();
-    assert!(!problem.evaluate(&[0, 0, 1, 0, 0])); // too short
-    assert!(!problem.evaluate(&[0, 0, 1, 0, 0, 0, 0])); // too long
+    assert!(matches!(
+        problem.evaluate(&vec![false, false, true, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![false, false, true, false, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_bcnf_evaluate_invalid_config_values() {
     let problem = canonical_problem();
-    assert!(!problem.evaluate(&[0, 0, 2, 0, 0, 0])); // value > 1
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([false, false, 2, false, false, false])
+    )
+    .is_err());
 }
 
 #[test]
 fn test_bcnf_solver_finds_violation() {
     let problem = canonical_problem();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     // All returned solutions must evaluate to true.
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
     // The canonical witness must be among them.
-    assert!(solutions.contains(&vec![0, 0, 1, 0, 0, 0]));
+    assert!(solutions.contains(&vec![false, false, true, false, false, false]));
 }
 
 #[test]
@@ -81,7 +114,7 @@ fn test_bcnf_no_violation_when_fds_trivial() {
     // Only trivial FD: {0} → {0}. No non-trivial closure possible.
     let problem = BoyceCoddNormalFormViolation::new(3, vec![(vec![0], vec![0])], vec![0, 1, 2]);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(solutions.is_empty());
 }
 
@@ -91,8 +124,8 @@ fn test_bcnf_partial_target_subset() {
     // FD: {0} → {1}; target = {0, 1}.
     // X = {0}: closure = {0, 1}. A' \ X = {1}. 1 ∈ closure but nothing is outside → no violation.
     let problem = BoyceCoddNormalFormViolation::new(3, vec![(vec![0], vec![1])], vec![0, 1]);
-    assert!(!problem.evaluate(&[1, 0])); // X={0}: all of A'\X = {1} ⊆ closure → no violation
-    assert!(!problem.evaluate(&[0, 0])); // X={}: closure={}, nothing in closure → no violation
+    assert!(!problem.evaluate(&vec![true, false]).unwrap()); // X={0}: all of A'\X = {1} ⊆ closure → no violation
+    assert!(!problem.evaluate(&vec![false, false]).unwrap()); // X={}: closure={}, nothing in closure → no violation
 }
 
 #[test]
@@ -100,8 +133,8 @@ fn test_bcnf_violation_with_three_attrs_in_target() {
     // Attrs 0,1,2. FD: {0} → {1}. Target = {0, 1, 2}.
     // X = {0}: closure = {0, 1}. A' \ X = {1, 2}. 1 ∈ closure, 2 ∉ closure → BCNF violation.
     let problem = BoyceCoddNormalFormViolation::new(3, vec![(vec![0], vec![1])], vec![0, 1, 2]);
-    assert!(problem.evaluate(&[1, 0, 0])); // X = {0}
-    assert!(!problem.evaluate(&[0, 1, 0])); // X = {1}: A'\X = {0,2}, closure of {1} = {1}, 0∉closure, 2∉closure → no violation
+    assert!(problem.evaluate(&vec![true, false, false]).unwrap()); // X = {0}
+    assert!(!problem.evaluate(&vec![false, true, false]).unwrap()); // X = {1}: A'\X = {0,2}, closure of {1} = {1}, 0∉closure, 2∉closure → no violation
 }
 
 #[test]
@@ -168,7 +201,7 @@ fn test_bcnf_fds_outside_target_subset() {
         vec![(vec![0], vec![3]), (vec![3], vec![4])],
         vec![0, 1, 2],
     );
-    assert!(!problem.evaluate(&[1, 0, 0])); // X={0}: closure reaches {0,3,4} but A'\X={1,2} untouched
+    assert!(!problem.evaluate(&vec![true, false, false]).unwrap()); // X={0}: closure reaches {0,3,4} but A'\X={1,2} untouched
 }
 
 #[test]
@@ -187,7 +220,7 @@ fn test_bcnf_cyclic_keys_no_violation() {
         vec![0, 1, 2, 3],
     );
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(
         solutions.is_empty(),
         "Cyclic-key instance should have no BCNF violation"
@@ -199,5 +232,7 @@ fn test_bcnf_multi_step_transitive_closure() {
     // X={0,1}: {0,1}→{2} then {2}→{3} (two-step chain).
     // A' \ X = {2,3,4,5}. closure = {0,1,2,3}. 2∈closure, 4∉closure → violation.
     let problem = canonical_problem();
-    assert!(problem.evaluate(&[1, 1, 0, 0, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![true, true, false, false, false, false])
+        .unwrap());
 }
diff --git a/src/unit_tests/models/misc/capacity_assignment.rs b/src/unit_tests/models/misc/capacity_assignment.rs
index ffe135e3d..09894567c 100644
--- a/src/unit_tests/models/misc/capacity_assignment.rs
+++ b/src/unit_tests/models/misc/capacity_assignment.rs
@@ -1,4 +1,17 @@
+use super::CapacityAssignmentCreateSpec;
 use crate::models::misc::CapacityAssignment;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_validates_monotonicity() {
+    assert!(CapacityAssignment::try_from(CapacityAssignmentCreateSpec {
+        capacities: vec![1, 2],
+        cost: vec![vec![2, 1]],
+        delay: vec![vec![2, 1]],
+        delay_budget: 3
+    })
+    .is_err());
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -19,7 +32,7 @@ fn test_capacity_assignment_basic_properties() {
     assert_eq!(problem.num_capacities(), 3);
     assert_eq!(problem.capacities(), &[1, 2, 3]);
     assert_eq!(problem.delay_budget(), 12);
-    assert_eq!(problem.dims(), vec![3, 3, 3]);
+    assert_eq!(problem.dimensions(), vec![3, 3, 3]);
     assert_eq!(<CapacityAssignment as Problem>::NAME, "CapacityAssignment");
     assert_eq!(<CapacityAssignment as Problem>::variant(), Vec::new());
 }
@@ -28,29 +41,38 @@ fn test_capacity_assignment_basic_properties() {
 fn test_capacity_assignment_evaluate_feasible_and_infeasible() {
     let problem = example_problem();
     // [1,1,1]: cost=3+4+2=9, delay=4+3+3=10 ≤ 12 → Min(Some(9))
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Min(Some(9)));
+    assert_eq!(problem.evaluate(&vec![1, 1, 1]).unwrap(), Min(Some(9)));
     // [0,1,2]: cost=1+4+5=10, delay=8+3+1=12 ≤ 12 → Min(Some(10))
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(Some(10)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2]).unwrap(), Min(Some(10)));
     // [0,0,0]: cost=1+2+1=4, delay=8+7+6=21 > 12 → Min(None)
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 0, 0]).unwrap(), Min(None));
     // [2,2,2]: cost=6+7+5=18, delay=1+1+1=3 ≤ 12 → Min(Some(18))
-    assert_eq!(problem.evaluate(&[2, 2, 2]), Min(Some(18)));
+    assert_eq!(problem.evaluate(&vec![2, 2, 2]).unwrap(), Min(Some(18)));
 }
 
 #[test]
 fn test_capacity_assignment_rejects_invalid_configs() {
     let problem = example_problem();
-    assert_eq!(problem.evaluate(&[1, 1]), Min(None));
-    assert_eq!(problem.evaluate(&[1, 1, 3]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![1, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![1, 1, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_capacity_assignment_bruteforce_optimal() {
     let problem = example_problem();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find witness");
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find witness");
     // Optimal cost is 9 at [1,1,1]
-    assert_eq!(problem.evaluate(&witness), Min(Some(9)));
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(9)));
     assert_eq!(witness, vec![1, 1, 1]);
 }
 
@@ -69,11 +91,14 @@ fn test_capacity_assignment_serialization_round_trip() {
 fn test_capacity_assignment_paper_example() {
     let problem = example_problem();
     let config = vec![1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(9)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(9)));
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find optimal");
-    assert_eq!(problem.evaluate(&witness), Min(Some(9)));
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find optimal");
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(9)));
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/closest_string.rs b/src/unit_tests/models/misc/closest_string.rs
index b70769203..fba543793 100644
--- a/src/unit_tests/models/misc/closest_string.rs
+++ b/src/unit_tests/models/misc/closest_string.rs
@@ -1,5 +1,6 @@
 use super::ClosestString;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -17,7 +18,7 @@ fn test_closest_string_creation() {
     assert_eq!(problem.num_strings(), 4);
     assert_eq!(problem.string_length(), 3);
     assert_eq!(problem.total_length(), 12);
-    assert_eq!(problem.dims(), vec![2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2]);
     assert_eq!(problem.num_variables(), 3);
     assert_eq!(<ClosestString as Problem>::NAME, "ClosestString");
     assert_eq!(<ClosestString as Problem>::variant(), vec![]);
@@ -27,28 +28,34 @@ fn test_closest_string_creation() {
 fn test_closest_string_evaluate_at_optimum() {
     let problem = issue_instance();
     // c = 000: d(000,000)=0, d(000,011)=2, d(000,101)=2, d(000,110)=2.
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![0, 0, 0]).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_closest_string_evaluate_at_100() {
     let problem = issue_instance();
     // c = 100: d(100,000)=1, d(100,011)=3, d(100,101)=1, d(100,110)=1.
-    assert_eq!(problem.evaluate(&[1, 0, 0]), Min(Some(3)));
+    assert_eq!(problem.evaluate(&vec![1, 0, 0]).unwrap(), Min(Some(3)));
 }
 
 #[test]
 fn test_closest_string_evaluate_at_111() {
     let problem = issue_instance();
     // c = 111: d(111,000)=3, d(111,011)=1, d(111,101)=1, d(111,110)=1.
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Min(Some(3)));
+    assert_eq!(problem.evaluate(&vec![1, 1, 1]).unwrap(), Min(Some(3)));
 }
 
 #[test]
 fn test_closest_string_evaluate_invalid_length() {
     let problem = issue_instance();
-    assert_eq!(problem.evaluate(&[0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -56,11 +63,17 @@ fn test_closest_string_bruteforce_finds_optimum() {
     let problem = issue_instance();
     let solver = BruteForce::new();
     // The minimum achievable radius over all 8 binary length-3 centers is 2.
-    assert_eq!(solver.solve(&problem), Min(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(2))
+    );
     let witness = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("expected a witness for ClosestString");
-    assert_eq!(problem.evaluate(&witness), Min(Some(2)));
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -88,11 +101,16 @@ fn test_closest_string_larger_alphabet_smoke() {
     // must have radius at least 2; e.g., c = 00 achieves d(00,01)=1,
     // d(00,12)=2, d(00,20)=1, giving a max of 2.
     let problem = ClosestString::new(3, vec![vec![0, 1], vec![1, 2], vec![2, 0]]);
-    assert_eq!(problem.dims(), vec![3, 3]);
+    assert_eq!(problem.dimensions(), vec![3, 3]);
     assert_eq!(problem.num_strings(), 3);
     assert_eq!(problem.string_length(), 2);
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Min(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
@@ -102,6 +120,9 @@ fn test_closest_string_serialization() {
     let restored: ClosestString = serde_json::from_value(json).unwrap();
     assert_eq!(restored.alphabet_size(), problem.alphabet_size());
     assert_eq!(restored.strings(), problem.strings());
-    assert_eq!(restored.dims(), problem.dims());
-    assert_eq!(restored.evaluate(&[0, 0, 0]), problem.evaluate(&[0, 0, 0]));
+    assert_eq!(restored.dimensions(), problem.dimensions());
+    assert_eq!(
+        restored.evaluate(&vec![0, 0, 0]).unwrap(),
+        problem.evaluate(&vec![0, 0, 0]).unwrap()
+    );
 }
diff --git a/src/unit_tests/models/misc/closest_substring.rs b/src/unit_tests/models/misc/closest_substring.rs
index c12178a66..1a98cfef5 100644
--- a/src/unit_tests/models/misc/closest_substring.rs
+++ b/src/unit_tests/models/misc/closest_substring.rs
@@ -1,5 +1,6 @@
 use super::ClosestSubstring;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -14,6 +15,7 @@ fn issue_instance() -> ClosestSubstring {
         ],
         3,
     )
+    .unwrap()
 }
 
 #[test]
@@ -27,7 +29,7 @@ fn test_closest_substring_creation() {
     assert_eq!(problem.num_window_choice_product(), 27);
     // dims: 3 center slots (each of size 2) + one window-position slot per
     // string (each of size W_i = 5 - 3 + 1 = 3).
-    assert_eq!(problem.dims(), vec![2, 2, 2, 3, 3, 3]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 3, 3, 3]);
     assert_eq!(problem.num_variables(), 6);
     assert_eq!(<ClosestSubstring as Problem>::NAME, "ClosestSubstring");
     assert_eq!(<ClosestSubstring as Problem>::variant(), vec![]);
@@ -41,7 +43,10 @@ fn test_closest_substring_evaluate_at_optimum() {
     //   s_2[1..4] = [0,1,0], d_H = 0
     //   s_3[0..3] = [1,1,0], d_H = 1
     // max = 1.
-    assert_eq!(problem.evaluate(&[0, 1, 0, 0, 1, 0]), Min(Some(1)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 1, 0, 0, 1, 0]).unwrap(),
+        Min(Some(1))
+    );
 }
 
 #[test]
@@ -52,7 +57,10 @@ fn test_closest_substring_evaluate_all_zero_windows() {
     //   s_2[0..3] = [1,0,1]  d = 2
     //   s_3[0..3] = [1,1,0]  d = 2
     // max = 2.
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0, 0]), Min(Some(2)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 0, 0, 0, 0, 0]).unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
@@ -61,7 +69,7 @@ fn test_closest_substring_evaluate_at_111_center() {
     // Any center [1,1,1] has Hamming distance >= 1 to every length-3 binary
     // string that contains at least one 0. All windows of s_1, s_2, s_3
     // contain at least one zero, so the radius is at least 1.
-    let value = problem.evaluate(&[1, 1, 1, 0, 0, 0]);
+    let value = problem.evaluate(&vec![1, 1, 1, 0, 0, 0]).unwrap();
     if let Min(Some(d)) = value {
         assert!(d >= 1, "expected radius >= 1, got {d}");
     } else {
@@ -72,8 +80,14 @@ fn test_closest_substring_evaluate_at_111_center() {
 #[test]
 fn test_closest_substring_evaluate_invalid_length() {
     let problem = issue_instance();
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0, 0, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 0, 0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -81,11 +95,17 @@ fn test_closest_substring_bruteforce_finds_optimum() {
     let problem = issue_instance();
     let solver = BruteForce::new();
     // 8 centers * 27 window combinations = 216 configurations; optimum is 1.
-    assert_eq!(solver.solve(&problem), Min(Some(1)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(1))
+    );
     let witness = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("expected a witness for ClosestSubstring");
-    assert_eq!(problem.evaluate(&witness), Min(Some(1)));
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -98,30 +118,45 @@ fn test_closest_substring_specializes_to_closest_string() {
         2,
         vec![vec![0, 0, 0], vec![0, 1, 1], vec![1, 0, 1], vec![1, 1, 0]],
         3,
-    );
+    )
+    .unwrap();
     assert_eq!(problem.num_window_choice_product(), 1);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 1, 1, 1, 1]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 1, 1, 1, 1]);
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Min(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
-#[should_panic(expected = "ClosestSubstring requires at least one input string")]
-fn test_closest_substring_panics_on_empty_input_list() {
-    let _ = ClosestSubstring::new(2, Vec::new(), 3);
+fn test_closest_substring_rejects_empty_input_list() {
+    assert!(matches!(
+        ClosestSubstring::new(2, Vec::new(), 3).unwrap_err(),
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "ClosestSubstring requires at least one input string"
+    ));
 }
 
 #[test]
-#[should_panic(expected = "substring_length must be <= |s_i| for every input string")]
-fn test_closest_substring_panics_on_substring_too_long() {
+fn test_closest_substring_rejects_substring_too_long() {
     // s_2 has length 2 < substring_length 3.
-    let _ = ClosestSubstring::new(2, vec![vec![0, 0, 0], vec![1, 1]], 3);
+    assert!(matches!(
+        ClosestSubstring::new(2, vec![vec![0, 0, 0], vec![1, 1]], 3).unwrap_err(),
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "substring_length must be <= |s_i| for every input string"
+    ));
 }
 
 #[test]
-#[should_panic(expected = "input symbols must be less than alphabet_size")]
-fn test_closest_substring_panics_on_out_of_alphabet_symbol() {
-    let _ = ClosestSubstring::new(2, vec![vec![0, 1, 2]], 3);
+fn test_closest_substring_rejects_out_of_alphabet_symbol() {
+    assert!(matches!(
+        ClosestSubstring::new(2, vec![vec![0, 1, 2]], 3).unwrap_err(),
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "input symbols must be less than alphabet_size"
+    ));
 }
 
 #[test]
@@ -132,9 +167,9 @@ fn test_closest_substring_serialization() {
     assert_eq!(restored.alphabet_size(), problem.alphabet_size());
     assert_eq!(restored.strings(), problem.strings());
     assert_eq!(restored.substring_length(), problem.substring_length());
-    assert_eq!(restored.dims(), problem.dims());
+    assert_eq!(restored.dimensions(), problem.dimensions());
     assert_eq!(
-        restored.evaluate(&[0, 1, 0, 0, 1, 0]),
-        problem.evaluate(&[0, 1, 0, 0, 1, 0])
+        restored.evaluate(&vec![0, 1, 0, 0, 1, 0]).unwrap(),
+        problem.evaluate(&vec![0, 1, 0, 0, 1, 0]).unwrap()
     );
 }
diff --git a/src/unit_tests/models/misc/clustering.rs b/src/unit_tests/models/misc/clustering.rs
index 1b0e16adf..6fcaccfec 100644
--- a/src/unit_tests/models/misc/clustering.rs
+++ b/src/unit_tests/models/misc/clustering.rs
@@ -1,5 +1,6 @@
 use crate::models::misc::Clustering;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 /// Helper: build the 6-element two-group instance from the issue.
@@ -22,7 +23,7 @@ fn test_clustering_creation() {
     assert_eq!(problem.num_clusters(), 2);
     assert_eq!(problem.diameter_bound(), 1);
     assert_eq!(problem.distances().len(), 6);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
 }
 
 #[test]
@@ -30,7 +31,7 @@ fn test_clustering_evaluate_feasible() {
     let problem = two_group_instance();
     // Cluster 0 = {0,1,2}, Cluster 1 = {3,4,5}
     // All intra-cluster distances = 1 ≤ B=1
-    let result = problem.evaluate(&[0, 0, 0, 1, 1, 1]);
+    let result = problem.evaluate(&vec![0, 0, 0, 1, 1, 1]).unwrap();
     assert!(result.0);
 }
 
@@ -39,7 +40,7 @@ fn test_clustering_evaluate_infeasible_distance() {
     let problem = two_group_instance();
     // Put element 3 (inter-group distance 3) in cluster 0 with {0,1,2}
     // distances[0][3] = 3 > B=1 → infeasible
-    let result = problem.evaluate(&[0, 0, 0, 0, 1, 1]);
+    let result = problem.evaluate(&vec![0, 0, 0, 0, 1, 1]).unwrap();
     assert!(!result.0);
 }
 
@@ -47,22 +48,31 @@ fn test_clustering_evaluate_infeasible_distance() {
 fn test_clustering_evaluate_all_same_cluster() {
     let problem = two_group_instance();
     // All elements in one cluster → inter-group distance 3 > 1 → infeasible
-    let result = problem.evaluate(&[0, 0, 0, 0, 0, 0]);
+    let result = problem.evaluate(&vec![0, 0, 0, 0, 0, 0]).unwrap();
     assert!(!result.0);
 }
 
 #[test]
 fn test_clustering_evaluate_wrong_length() {
     let problem = two_group_instance();
-    assert!(!problem.evaluate(&[0, 0, 0]).0);
-    assert!(!problem.evaluate(&[0, 0, 0, 1, 1, 1, 0]).0);
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 1, 1, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_clustering_evaluate_invalid_cluster_index() {
     let problem = two_group_instance();
     // Cluster index 2 is invalid (K=2, valid indices are 0,1)
-    assert!(!problem.evaluate(&[0, 0, 2, 1, 1, 1]).0);
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 2, 1, 1, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -71,16 +81,16 @@ fn test_clustering_trivial_k_ge_n() {
     let distances = vec![vec![0, 100, 100], vec![100, 0, 100], vec![100, 100, 0]];
     let problem = Clustering::new(distances, 3, 0);
     // Each element in its own cluster: [0, 1, 2]
-    assert!(problem.evaluate(&[0, 1, 2]).0);
+    assert!(problem.evaluate(&vec![0, 1, 2]).unwrap().0);
 }
 
 #[test]
 fn test_clustering_solver() {
     let problem = two_group_instance();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()).0);
+    assert!(problem.evaluate(&solution.unwrap()).unwrap().0);
 }
 
 #[test]
@@ -94,10 +104,10 @@ fn test_clustering_solver_all_witnesses() {
     ];
     let problem = Clustering::new(distances, 2, 1);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol).0);
+        assert!(problem.evaluate(sol).unwrap().0);
     }
     // Two valid groupings: {0,1} vs {2,3} in either assignment order
     // [0,0,1,1] and [1,1,0,0]
@@ -115,8 +125,8 @@ fn test_clustering_serialization() {
     // Check round-trip gives same evaluation
     let config = vec![0, 0, 0, 1, 1, 1];
     assert_eq!(
-        problem.evaluate(&config).0,
-        deserialized.evaluate(&config).0
+        problem.evaluate(&config).unwrap().0,
+        deserialized.evaluate(&config).unwrap().0
     );
 }
 
@@ -126,7 +136,7 @@ fn test_clustering_no_solution() {
     let distances = vec![vec![0, 5, 5], vec![5, 0, 5], vec![5, 5, 0]];
     let problem = Clustering::new(distances, 1, 2);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -148,12 +158,12 @@ fn test_clustering_paper_example() {
     // Paper example: 6 elements, K=2, B=1
     let problem = two_group_instance();
     let config = vec![0, 0, 0, 1, 1, 1];
-    let result = problem.evaluate(&config);
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.0);
 
     // Verify this is satisfiable
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
-    assert!(problem.evaluate(&witness.unwrap()).0);
+    assert!(problem.evaluate(&witness.unwrap()).unwrap().0);
 }
diff --git a/src/unit_tests/models/misc/conjunctive_boolean_query.rs b/src/unit_tests/models/misc/conjunctive_boolean_query.rs
index 3ca9e701e..165eb95a0 100644
--- a/src/unit_tests/models/misc/conjunctive_boolean_query.rs
+++ b/src/unit_tests/models/misc/conjunctive_boolean_query.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 /// Helper to build the issue example instance.
@@ -36,7 +37,7 @@ fn test_conjunctivebooleanquery_basic() {
     assert_eq!(problem.num_relations(), 2);
     assert_eq!(problem.num_variables(), 2);
     assert_eq!(problem.num_conjuncts(), 3);
-    assert_eq!(problem.dims(), vec![6, 6]);
+    assert_eq!(problem.dimensions(), vec![6, 6]);
     assert_eq!(
         <ConjunctiveBooleanQuery as Problem>::NAME,
         "ConjunctiveBooleanQuery"
@@ -53,7 +54,7 @@ fn test_conjunctivebooleanquery_evaluate_yes() {
     //   conjunct 0: R_0(0, 3) = (0,3) in R_0 -> true
     //   conjunct 1: R_0(1, 3) = (1,3) in R_0 -> true
     //   conjunct 2: R_1(0, 1, 5) = (0,1,5) in R_1 -> true
-    assert!(problem.evaluate(&[0, 1]));
+    assert!(problem.evaluate(&vec![0, 1]).unwrap());
 }
 
 #[test]
@@ -61,23 +62,32 @@ fn test_conjunctivebooleanquery_evaluate_no() {
     let problem = issue_example();
     // y_0=2, y_1=1:
     //   conjunct 0: R_0(2, 3) = (2,3) NOT in R_0 (R_0 has (2,4) not (2,3))
-    assert!(!problem.evaluate(&[2, 1]));
+    assert!(!problem.evaluate(&vec![2, 1]).unwrap());
 }
 
 #[test]
 fn test_conjunctivebooleanquery_out_of_range() {
     let problem = issue_example();
     // value 6 is out of range for domain_size=6
-    assert!(!problem.evaluate(&[6, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![6, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_conjunctivebooleanquery_wrong_length() {
     let problem = issue_example();
     // too short
-    assert!(!problem.evaluate(&[0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // too long
-    assert!(!problem.evaluate(&[0, 1, 2]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -85,9 +95,10 @@ fn test_conjunctivebooleanquery_brute_force() {
     let problem = issue_example();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
@@ -105,7 +116,7 @@ fn test_conjunctivebooleanquery_unsatisfiable() {
     ];
     let problem = ConjunctiveBooleanQuery::new(2, relations, 1, conjuncts);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -121,7 +132,7 @@ fn test_conjunctivebooleanquery_paper_example() {
     // Same instance as the issue example — count all satisfying assignments
     let problem = issue_example();
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     // (0,1) satisfies; verify count manually:
     // For each (y0, y1) in {0..5}x{0..5}:
     //   need R_0(y0, 3) and R_0(y1, 3) and R_1(y0, y1, 5)
@@ -135,3 +146,36 @@ fn test_conjunctivebooleanquery_paper_example() {
     assert_eq!(all.len(), 1);
     assert_eq!(all[0], vec![0, 1]);
 }
+
+#[test]
+fn test_conjunctivebooleanquery_create_spec_derives_variables() {
+    let problem = ConjunctiveBooleanQuery::try_from(ConjunctiveBooleanQueryCreateSpec {
+        domain_size: 3,
+        relations: vec![Relation {
+            arity: 2,
+            tuples: vec![vec![0, 2]],
+        }],
+        conjuncts: vec![(0, vec![QueryArg::Variable(2), QueryArg::Constant(2)])],
+    })
+    .unwrap();
+
+    assert_eq!(problem.num_variables(), 3);
+    assert_eq!(
+        ConjunctiveBooleanQueryCreateSpec::FIELDS
+            .iter()
+            .map(|field| field.name)
+            .collect::<Vec<_>>(),
+        ["domain_size", "relations", "conjuncts"]
+    );
+}
+
+#[test]
+fn test_conjunctivebooleanquery_create_spec_rejects_invalid_relation_index() {
+    let result = ConjunctiveBooleanQuery::try_from(ConjunctiveBooleanQueryCreateSpec {
+        domain_size: 1,
+        relations: vec![],
+        conjuncts: vec![(0, vec![])],
+    });
+
+    assert!(result.is_err());
+}
diff --git a/src/unit_tests/models/misc/conjunctive_query_foldability.rs b/src/unit_tests/models/misc/conjunctive_query_foldability.rs
index b465cd46d..29fc69f39 100644
--- a/src/unit_tests/models/misc/conjunctive_query_foldability.rs
+++ b/src/unit_tests/models/misc/conjunctive_query_foldability.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 /// Build the YES instance (foldable):
@@ -58,7 +59,7 @@ fn test_conjunctive_query_foldability_creation() {
     let problem = yes_instance();
     // dims = [domain_size + num_distinguished + num_undistinguished; num_undistinguished]
     //       = [0 + 1 + 3; 3] = [4, 4, 4]
-    assert_eq!(problem.dims(), vec![4, 4, 4]);
+    assert_eq!(problem.dimensions(), vec![4, 4, 4]);
     assert_eq!(problem.num_variables(), 3);
     assert_eq!(
         <ConjunctiveQueryFoldability as Problem>::NAME,
@@ -80,33 +81,33 @@ fn test_conjunctive_query_foldability_yes_instance() {
     // config [3, 3, 3]: σ(U0→U2, U1→U2, U2→U2) = σ maps everything to `a`
     // Substituted Q1: R(x,a) ∧ R(a,a) ∧ R(a,x) ∧ R(a,a)
     // As a set: {R(x,a), R(a,a), R(a,x)} == Q2 ✓
-    assert!(problem.evaluate(&[3, 3, 3]));
+    assert!(problem.evaluate(&vec![3, 3, 3]).unwrap());
 
     // config [0, 0, 0]: σ maps all undistinguished vars to Distinguished(0) = x
     // Substituted Q1: R(x,x) ∧ R(x,x) ∧ R(x,x) ∧ R(x,x) = {R(x,x)}
     // Q2 = {R(x,a), R(a,a), R(a,x)} ≠ {R(x,x)} ✗
-    assert!(!problem.evaluate(&[0, 0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 0]).unwrap());
 }
 
 #[test]
 fn test_conjunctive_query_foldability_no_instance() {
     let problem = no_instance();
     // No substitution σ on {U0, U1, U2} maps the triangle into a 2-cycle
-    let result = BruteForce::new().find_witness(&problem);
+    let result = BruteForce::new().solve(&problem).unwrap();
     assert_eq!(result, None);
 }
 
 #[test]
 fn test_conjunctive_query_foldability_solver() {
     let problem = yes_instance();
-    let result = BruteForce::new().find_witness(&problem);
+    let result = BruteForce::new().solve(&problem).unwrap();
     assert!(
         result.is_some(),
         "YES instance must have a satisfying config"
     );
     let config = result.unwrap();
     assert!(
-        problem.evaluate(&config),
+        problem.evaluate(&config).unwrap(),
         "returned config must evaluate to true"
     );
 }
@@ -116,7 +117,7 @@ fn test_conjunctive_query_foldability_serialization() {
     let problem = yes_instance();
     let json = serde_json::to_value(&problem).unwrap();
     let restored: ConjunctiveQueryFoldability = serde_json::from_value(json).unwrap();
-    assert_eq!(restored.dims(), problem.dims());
+    assert_eq!(restored.dimensions(), problem.dimensions());
     assert_eq!(restored.domain_size(), problem.domain_size());
     assert_eq!(restored.num_distinguished(), problem.num_distinguished());
     assert_eq!(
@@ -127,8 +128,8 @@ fn test_conjunctive_query_foldability_serialization() {
     assert_eq!(restored.num_conjuncts_q2(), problem.num_conjuncts_q2());
     assert_eq!(restored.relation_arities(), problem.relation_arities());
     // Verify the restored instance produces the same evaluation results
-    assert!(restored.evaluate(&[3, 3, 3]));
-    assert!(!restored.evaluate(&[0, 0, 0]));
+    assert!(restored.evaluate(&vec![3, 3, 3]).unwrap());
+    assert!(!restored.evaluate(&vec![0, 0, 0]).unwrap());
 }
 
 #[test]
@@ -136,12 +137,12 @@ fn test_conjunctive_query_foldability_paper_example() {
     let problem = yes_instance();
 
     // The known satisfying config σ(all→a) = [3, 3, 3]
-    assert!(problem.evaluate(&[3, 3, 3]));
+    assert!(problem.evaluate(&vec![3, 3, 3]).unwrap());
 
     // Enumerate all satisfying configs.
     // U(2) (= a) does not appear in Q1, so σ(U2) is a free choice (4 values).
     // Only σ(U0)=3 and σ(U1)=3 are required; σ(U2) can be anything in 0..4.
-    let all = BruteForce::new().find_all_witnesses(&problem);
+    let all = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert_eq!(
         all.len(),
         4,
@@ -173,11 +174,11 @@ fn test_conjunctive_query_foldability_with_constants() {
         ],
     );
     // dims = [1+1+1; 1] = [3]
-    assert_eq!(problem.dims(), vec![3]);
+    assert_eq!(problem.dimensions(), vec![3]);
     // σ(u→x): index for X(0) = domain_size + 0 = 1
-    assert!(problem.evaluate(&[1]));
+    assert!(problem.evaluate(&vec![1]).unwrap());
     // σ(u→c0): index for C(0) = 0 → R(c0, c0) ∧ R(c0, x) ≠ Q2
-    assert!(!problem.evaluate(&[0]));
+    assert!(!problem.evaluate(&vec![0]).unwrap());
 }
 
 #[test]
@@ -197,15 +198,24 @@ fn test_conjunctive_query_foldability_getters() {
 #[test]
 fn test_conjunctive_query_foldability_evaluate_wrong_length() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[3, 3])); // too short
-    assert!(!problem.evaluate(&[3, 3, 3, 3])); // too long
+    assert!(matches!(
+        problem.evaluate(&vec![3, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![3, 3, 3, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_conjunctive_query_foldability_evaluate_out_of_range() {
     let problem = yes_instance();
     // range = 0 + 1 + 3 = 4, so value 4 is out of range
-    assert!(!problem.evaluate(&[4, 3, 3]));
+    assert!(matches!(
+        problem.evaluate(&vec![4, 3, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -276,8 +286,8 @@ fn test_conjunctive_query_foldability_no_undistinguished() {
         vec![(0, vec![X(0), X(0)])],
         vec![(0, vec![X(0), X(0)])],
     );
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -292,7 +302,7 @@ fn test_conjunctive_query_foldability_no_undistinguished_not_equal() {
         vec![(0, vec![X(0), X(1)])],
         vec![(0, vec![X(1), X(0)])],
     );
-    assert!(!problem.evaluate(&[]));
+    assert!(!problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/consistency_of_database_frequency_tables.rs b/src/unit_tests/models/misc/consistency_of_database_frequency_tables.rs
index 949f2c75a..1aadc7b88 100644
--- a/src/unit_tests/models/misc/consistency_of_database_frequency_tables.rs
+++ b/src/unit_tests/models/misc/consistency_of_database_frequency_tables.rs
@@ -1,4 +1,19 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_known_values() {
+    let problem = ConsistencyOfDatabaseFrequencyTables::try_from(
+        ConsistencyOfDatabaseFrequencyTablesCreateSpec {
+            num_objects: 2,
+            attribute_domains: vec![2, 2],
+            frequency_tables: vec![FrequencyTable::new(0, 1, vec![vec![1, 0], vec![0, 1]])],
+            known_values: None,
+        },
+    )
+    .unwrap();
+    assert!(problem.known_values().is_empty());
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
@@ -64,7 +79,7 @@ fn test_cdft_creation_and_getters() {
 fn test_cdft_dims_repeat_attribute_domains_for_each_object() {
     let problem = issue_yes_instance();
     assert_eq!(
-        problem.dims(),
+        problem.dimensions(),
         vec![2, 3, 2, 2, 3, 2, 2, 3, 2, 2, 3, 2, 2, 3, 2, 2, 3, 2]
     );
 }
@@ -72,16 +87,22 @@ fn test_cdft_dims_repeat_attribute_domains_for_each_object() {
 #[test]
 fn test_cdft_evaluate_issue_witness() {
     let problem = issue_yes_instance();
-    assert!(problem.evaluate(&issue_yes_witness()));
+    assert!(problem.evaluate(&issue_yes_witness()).unwrap());
 }
 
 #[test]
 fn test_cdft_evaluate_rejects_wrong_length() {
     let problem = issue_yes_instance();
-    assert!(!problem.evaluate(&[0, 0, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     let mut too_long = issue_yes_witness();
     too_long.push(0);
-    assert!(!problem.evaluate(&too_long));
+    assert!(matches!(
+        problem.evaluate(&too_long),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -89,7 +110,10 @@ fn test_cdft_evaluate_rejects_out_of_range_value() {
     let problem = issue_yes_instance();
     let mut bad = issue_yes_witness();
     bad[1] = 3;
-    assert!(!problem.evaluate(&bad));
+    assert!(matches!(
+        problem.evaluate(&bad),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -97,7 +121,7 @@ fn test_cdft_evaluate_rejects_known_value_violation() {
     let problem = issue_yes_instance();
     let mut bad = issue_yes_witness();
     bad[0] = 1;
-    assert!(!problem.evaluate(&bad));
+    assert!(!problem.evaluate(&bad).unwrap());
 }
 
 #[test]
@@ -105,7 +129,7 @@ fn test_cdft_evaluate_rejects_frequency_table_mismatch() {
     let problem = issue_yes_instance();
     let mut bad = issue_yes_witness();
     bad[17] = 1;
-    assert!(!problem.evaluate(&bad));
+    assert!(!problem.evaluate(&bad).unwrap());
 }
 
 #[test]
@@ -113,16 +137,17 @@ fn test_cdft_bruteforce_finds_small_satisfying_assignment() {
     let problem = small_yes_instance();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("small instance should be satisfiable");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_cdft_bruteforce_detects_small_unsat_instance() {
     let problem = small_no_instance();
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -134,13 +159,13 @@ fn test_cdft_serialization_round_trip() {
     assert_eq!(restored.attribute_domains(), problem.attribute_domains());
     assert_eq!(restored.frequency_tables(), problem.frequency_tables());
     assert_eq!(restored.known_values(), problem.known_values());
-    assert!(restored.evaluate(&issue_yes_witness()));
+    assert!(restored.evaluate(&issue_yes_witness()).unwrap());
 }
 
 #[test]
 fn test_cdft_paper_example_matches_issue_witness() {
     let problem = issue_yes_instance();
-    assert!(problem.evaluate(&issue_yes_witness()));
+    assert!(problem.evaluate(&issue_yes_witness()).unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/cosine_product_integration.rs b/src/unit_tests/models/misc/cosine_product_integration.rs
index 9d44ddda3..5787b6f66 100644
--- a/src/unit_tests/models/misc/cosine_product_integration.rs
+++ b/src/unit_tests/models/misc/cosine_product_integration.rs
@@ -1,5 +1,6 @@
 use crate::models::misc::CosineProductIntegration;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -12,21 +13,21 @@ fn test_cosine_product_integration_creation() {
 #[test]
 fn test_cosine_product_integration_dims() {
     let p = CosineProductIntegration::new(vec![1, 2, 3]);
-    assert_eq!(p.dims(), vec![2, 2, 2]);
+    assert_eq!(p.dimensions(), vec![2, 2, 2]);
 }
 
 #[test]
 fn test_cosine_product_integration_evaluate_satisfying() {
     // [2, 3, 5]: (+2, +3, -5) = 0 → satisfying
     let p = CosineProductIntegration::new(vec![2, 3, 5]);
-    assert!(p.evaluate(&[0, 0, 1]).0);
+    assert!(p.evaluate(&vec![false, false, true]).unwrap().0);
 }
 
 #[test]
 fn test_cosine_product_integration_evaluate_not_satisfying() {
     // [2, 3, 5]: (+2, +3, +5) = 10 → not satisfying
     let p = CosineProductIntegration::new(vec![2, 3, 5]);
-    assert!(!p.evaluate(&[0, 0, 0]).0);
+    assert!(!p.evaluate(&vec![false, false, false]).unwrap().0);
 }
 
 #[test]
@@ -34,27 +35,28 @@ fn test_cosine_product_integration_unsatisfiable() {
     // [1, 2, 6]: total=9 (odd), no balanced sign assignment
     let p = CosineProductIntegration::new(vec![1, 2, 6]);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&p).is_none());
+    assert!(solver.solve(&p).unwrap().is_none());
 }
 
 #[test]
 fn test_cosine_product_integration_solver() {
     let p = CosineProductIntegration::new(vec![2, 3, 5]);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&p).unwrap();
-    assert!(p.evaluate(&witness).0);
+    let witness = solver.solve(&p).unwrap().unwrap();
+    assert!(p.evaluate(&witness).unwrap().0);
 }
 
 #[test]
 fn test_cosine_product_integration_aggregate() {
     let p = CosineProductIntegration::new(vec![2, 3, 5]);
     let solver = BruteForce::new();
-    let value = solver.solve(&p);
+    let value_solution = solver.solve(&p).unwrap().unwrap();
+    let value = p.evaluate(&value_solution).unwrap();
     assert!(value.0);
 
     let p2 = CosineProductIntegration::new(vec![1, 2, 6]);
-    let value2 = solver.solve(&p2);
-    assert!(!value2.0);
+    let value2 = solver.solve(&p2).unwrap();
+    assert!(value2.is_none());
 }
 
 #[test]
@@ -62,16 +64,22 @@ fn test_cosine_product_integration_negative_coefficients() {
     // [-3, 2, 1]: (-(-3), +2, -1) = (3, 2, -1) = 4, not zero
     // but (-3, +2, +1) = 0 → config [0, 0, 0] → -3+2+1=0
     let p = CosineProductIntegration::new(vec![-3, 2, 1]);
-    assert!(p.evaluate(&[0, 0, 0]).0); // -3 + 2 + 1 = 0
+    assert!(p.evaluate(&vec![false, false, false]).unwrap().0); // -3 + 2 + 1 = 0
 }
 
 #[test]
 fn test_cosine_product_integration_invalid_config() {
     let p = CosineProductIntegration::new(vec![1, 2, 3]);
     // Wrong length
-    assert!(!p.evaluate(&[0, 0]).0);
+    assert!(matches!(
+        p.evaluate(&vec![false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Out of range
-    assert!(!p.evaluate(&[0, 2, 0]).0);
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&p, &serde_json::json!([false, 2, false]))
+            .is_err()
+    );
 }
 
 #[test]
@@ -87,10 +95,10 @@ fn test_cosine_product_integration_all_witnesses() {
     // [2, 3, 5]: two balanced assignments: (+2,+3,-5)=0 and (-2,-3,+5)=0
     let p = CosineProductIntegration::new(vec![2, 3, 5]);
     let solver = BruteForce::new();
-    let witnesses = solver.find_all_witnesses(&p);
+    let witnesses = solver.find_all_witnesses(&p).unwrap();
     assert_eq!(witnesses.len(), 2);
     for w in &witnesses {
-        assert!(p.evaluate(w).0);
+        assert!(p.evaluate(w).unwrap().0);
     }
 }
 
diff --git a/src/unit_tests/models/misc/cyclic_ordering.rs b/src/unit_tests/models/misc/cyclic_ordering.rs
index 123474964..5f8bb0b76 100644
--- a/src/unit_tests/models/misc/cyclic_ordering.rs
+++ b/src/unit_tests/models/misc/cyclic_ordering.rs
@@ -1,5 +1,6 @@
 use crate::models::misc::CyclicOrdering;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -13,7 +14,7 @@ fn test_cyclic_ordering_basic() {
     assert_eq!(problem.num_elements(), 5);
     assert_eq!(problem.num_triples(), 3);
     assert_eq!(problem.triples(), &[(0, 1, 2), (2, 3, 0), (1, 3, 4)]);
-    assert_eq!(problem.dims(), vec![5; 5]);
+    assert_eq!(problem.dimensions(), vec![5; 5]);
     assert_eq!(problem.num_variables(), 5);
     assert_eq!(<CyclicOrdering as Problem>::NAME, "CyclicOrdering");
     assert_eq!(<CyclicOrdering as Problem>::variant(), vec![]);
@@ -24,7 +25,7 @@ fn test_cyclic_ordering_evaluate_satisfying() {
     let problem = example_problem();
     // config = [1,3,4,0,2]: f(0)=1, f(1)=3, f(2)=4, f(3)=0, f(4)=2
     // (0,1,2): 1<3<4 ✓  (2,3,0): 0<1<4 (cyclic) ✓  (1,3,4): 0<2<3 (cyclic) ✓
-    assert_eq!(problem.evaluate(&[1, 3, 4, 0, 2]), Or(true));
+    assert_eq!(problem.evaluate(&vec![1, 3, 4, 0, 2]).unwrap(), Or(true));
 }
 
 #[test]
@@ -37,26 +38,32 @@ fn test_cyclic_ordering_evaluate_unsatisfying() {
     // Actually identity works! Let me pick one that doesn't.
     // [0,2,1,3,4]:
     // (0,1,2): f(0)=0, f(1)=2, f(2)=1 → (0<2<1)? no. (2<1<0)? no. (1<0<2)? no. → fails
-    assert_eq!(problem.evaluate(&[0, 2, 1, 3, 4]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 2, 1, 3, 4]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_cyclic_ordering_evaluate_invalid_permutation() {
     let problem = example_problem();
     // Not a permutation (duplicate positions)
-    assert_eq!(problem.evaluate(&[0, 0, 1, 2, 3]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 0, 1, 2, 3]).unwrap(), Or(false));
     // Position out of range
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 5]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_cyclic_ordering_solver_finds_witness() {
     let problem = example_problem();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Or(true));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Or(true));
 }
 
 #[test]
@@ -67,7 +74,7 @@ fn test_cyclic_ordering_unsatisfiable_instance() {
     // These are opposite cyclic orientations, so unsatisfiable.
     let problem = CyclicOrdering::new(3, vec![(0, 1, 2), (0, 2, 1)]);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -118,6 +125,20 @@ fn test_cyclic_ordering_zero_elements_panics() {
     CyclicOrdering::new(0, vec![]);
 }
 
+#[test]
+fn test_cyclic_ordering_complexity_estimate_handles_factorial_overflow() {
+    let entry = crate::registry::find_variant_entry("CyclicOrdering", &Default::default()).unwrap();
+    assert_eq!(
+        (entry.complexity_eval_fn)(&CyclicOrdering::new(5, vec![])),
+        120.0
+    );
+    assert!((entry.complexity_eval_fn)(&CyclicOrdering::new(170, vec![])).is_finite());
+    assert_eq!(
+        (entry.complexity_eval_fn)(&CyclicOrdering::new(171, vec![])),
+        f64::INFINITY
+    );
+}
+
 #[test]
 #[should_panic(expected = "out of range")]
 fn test_cyclic_ordering_element_out_of_range_panics() {
diff --git a/src/unit_tests/models/misc/dynamic_storage_allocation.rs b/src/unit_tests/models/misc/dynamic_storage_allocation.rs
index 92ea4d675..42fd55c8c 100644
--- a/src/unit_tests/models/misc/dynamic_storage_allocation.rs
+++ b/src/unit_tests/models/misc/dynamic_storage_allocation.rs
@@ -1,5 +1,6 @@
 use crate::models::misc::DynamicStorageAllocation;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -19,7 +20,7 @@ fn test_dynamic_storage_allocation_basic() {
     assert_eq!(problem.items().len(), 5);
     // dims: D - s(a) + 1 for each item
     // sizes are 2, 3, 1, 3, 2 => dims are 5, 4, 6, 4, 5
-    assert_eq!(problem.dims(), vec![5, 4, 6, 4, 5]);
+    assert_eq!(problem.dimensions(), vec![5, 4, 6, 4, 5]);
     assert_eq!(problem.num_variables(), 5);
     assert_eq!(
         <DynamicStorageAllocation as Problem>::NAME,
@@ -32,28 +33,34 @@ fn test_dynamic_storage_allocation_basic() {
 fn test_dynamic_storage_allocation_evaluate_feasible() {
     let problem = example_problem();
     // Solution from the issue: σ = [0, 2, 5, 2, 0] (0-indexed)
-    assert_eq!(problem.evaluate(&[0, 2, 5, 2, 0]), Or(true));
+    assert_eq!(problem.evaluate(&vec![0, 2, 5, 2, 0]).unwrap(), Or(true));
 }
 
 #[test]
 fn test_dynamic_storage_allocation_evaluate_infeasible() {
     let problem = example_problem();
     // All items at address 0 - should overlap
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 0, 0, 0, 0]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_dynamic_storage_allocation_rejects_invalid_config_length() {
     let problem = example_problem();
-    assert_eq!(problem.evaluate(&[0, 2, 5]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 2, 5, 2, 0, 1]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2, 5, 2, 0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_dynamic_storage_allocation_rejects_out_of_bounds() {
     let problem = example_problem();
     // Item 0 has size 2, so max start is 4 (0..=4). Start at 5 => 5+2=7 > 6
-    assert_eq!(problem.evaluate(&[5, 0, 0, 0, 0]), Or(false));
+    assert_eq!(problem.evaluate(&vec![5, 0, 0, 0, 0]).unwrap(), Or(false));
 }
 
 #[test]
@@ -61,8 +68,8 @@ fn test_dynamic_storage_allocation_solver_finds_witness() {
     // Use a small instance for brute-force
     let problem = DynamicStorageAllocation::new(vec![(0, 2, 1), (1, 3, 1)], 2);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&witness), Or(true));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&witness).unwrap(), Or(true));
 }
 
 #[test]
@@ -70,7 +77,7 @@ fn test_dynamic_storage_allocation_unsatisfiable_instance() {
     // Two items overlap in time, both size 3, memory = 4: can't fit without overlap
     let problem = DynamicStorageAllocation::new(vec![(0, 2, 3), (0, 2, 3)], 4);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -148,5 +155,5 @@ fn test_dynamic_storage_allocation_non_overlapping_time_any_address() {
     // Two items that don't overlap in time can share any addresses
     let problem = DynamicStorageAllocation::new(vec![(0, 2, 3), (2, 4, 3)], 3);
     // Both at address 0, but they don't overlap in time (d(a)=2 <= r(a')=2)
-    assert_eq!(problem.evaluate(&[0, 0]), Or(true));
+    assert_eq!(problem.evaluate(&vec![0, 0]).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/models/misc/ensemble_computation.rs b/src/unit_tests/models/misc/ensemble_computation.rs
index 317e31124..890207764 100644
--- a/src/unit_tests/models/misc/ensemble_computation.rs
+++ b/src/unit_tests/models/misc/ensemble_computation.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -15,7 +16,7 @@ fn test_ensemble_computation_creation() {
     assert_eq!(problem.num_subsets(), 2);
     assert_eq!(problem.budget(), 4);
     assert_eq!(problem.num_variables(), 8);
-    assert_eq!(problem.dims(), vec![8; 8]);
+    assert_eq!(problem.dimensions(), vec![8; 8]);
     assert_eq!(
         <EnsembleComputation as Problem>::NAME,
         "EnsembleComputation"
@@ -28,35 +29,50 @@ fn test_ensemble_computation_issue_witness() {
     let problem = issue_problem();
 
     // 3 steps used: z1={0,1}, z2={0,1,2}, z3={0,1,3}
-    assert_eq!(problem.evaluate(&[0, 1, 4, 2, 4, 3, 0, 1]), Min(Some(3)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 1, 4, 2, 4, 3, 0, 1]).unwrap(),
+        Min(Some(3))
+    );
 }
 
 #[test]
 fn test_ensemble_computation_rejects_future_reference() {
     let problem = issue_problem();
 
-    assert_eq!(problem.evaluate(&[4, 1, 0, 1, 0, 1, 0, 1]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![4, 1, 0, 1, 0, 1, 0, 1]).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_ensemble_computation_rejects_overlapping_operands() {
     let problem = issue_problem();
 
-    assert_eq!(problem.evaluate(&[0, 0, 4, 2, 4, 3, 0, 1]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![0, 0, 4, 2, 4, 3, 0, 1]).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_ensemble_computation_rejects_missing_required_subset() {
     let problem = issue_problem();
 
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1, 0, 1, 0, 1]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![0, 1, 0, 1, 0, 1, 0, 1]).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_ensemble_computation_rejects_wrong_config_length() {
     let problem = issue_problem();
 
-    assert_eq!(problem.evaluate(&[0, 1, 4, 2]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 4, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -64,11 +80,11 @@ fn test_ensemble_computation_small_bruteforce_instance() {
     let problem = EnsembleComputation::new(2, vec![vec![0, 1]], 1);
     let solver = BruteForce::new();
 
-    let satisfying = solver.find_all_witnesses(&problem);
+    let satisfying = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(satisfying.len(), 2);
     assert!(satisfying.contains(&vec![0, 1]));
     assert!(satisfying.contains(&vec![1, 0]));
-    assert_eq!(solver.find_witness(&problem), Some(vec![0, 1]));
+    assert_eq!(solver.solve(&problem).unwrap(), Some(vec![0, 1]));
 }
 
 #[test]
@@ -80,7 +96,10 @@ fn test_ensemble_computation_serialization_round_trip() {
     assert_eq!(round_trip.universe_size(), 4);
     assert_eq!(round_trip.num_subsets(), 2);
     assert_eq!(round_trip.budget(), 4);
-    assert_eq!(round_trip.evaluate(&[0, 1, 4, 2, 4, 3, 0, 1]), Min(Some(3)));
+    assert_eq!(
+        round_trip.evaluate(&vec![0, 1, 4, 2, 4, 3, 0, 1]).unwrap(),
+        Min(Some(3))
+    );
 }
 
 #[test]
@@ -103,7 +122,10 @@ fn test_ensemble_computation_paper_example() {
     let problem = issue_problem();
 
     // Witness uses 3 steps to build both subsets
-    assert_eq!(problem.evaluate(&[0, 1, 4, 2, 4, 3, 0, 1]), Min(Some(3)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 1, 4, 2, 4, 3, 0, 1]).unwrap(),
+        Min(Some(3))
+    );
 }
 
 #[test]
@@ -114,7 +136,8 @@ fn test_ensemble_computation_optimal_value() {
     let problem = EnsembleComputation::new(3, vec![vec![0, 1], vec![0, 1, 2]], 2);
     let solver = BruteForce::new();
 
-    use crate::solvers::Solver;
-    let optimal = solver.solve(&problem);
+    let optimal_solution = solver.solve(&problem).unwrap().unwrap();
+
+    let optimal = problem.evaluate(&optimal_solution).unwrap();
     assert_eq!(optimal, Min(Some(2)));
 }
diff --git a/src/unit_tests/models/misc/expected_retrieval_cost.rs b/src/unit_tests/models/misc/expected_retrieval_cost.rs
index 0e458c1f3..9cd84b62c 100644
--- a/src/unit_tests/models/misc/expected_retrieval_cost.rs
+++ b/src/unit_tests/models/misc/expected_retrieval_cost.rs
@@ -1,12 +1,13 @@
 use super::ExpectedRetrievalCost;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
 const EPS: f64 = 1e-9;
 
 fn sample_problem() -> ExpectedRetrievalCost {
-    ExpectedRetrievalCost::new(vec![0.2, 0.15, 0.15, 0.2, 0.1, 0.2], 3)
+    ExpectedRetrievalCost::new(vec![0.2, 0.15, 0.15, 0.2, 0.1, 0.2], 3).unwrap()
 }
 
 #[test]
@@ -15,59 +16,71 @@ fn test_expected_retrieval_cost_basic_accessors() {
     assert_eq!(problem.num_records(), 6);
     assert_eq!(problem.num_sectors(), 3);
     assert_eq!(problem.probabilities(), &[0.2, 0.15, 0.15, 0.2, 0.1, 0.2]);
-    assert_eq!(problem.dims(), vec![3; 6]);
+    assert_eq!(problem.dimensions(), vec![3; 6]);
     assert_eq!(problem.num_variables(), 6);
 }
 
 #[test]
 fn test_expected_retrieval_cost_sector_masses_and_cost() {
     let problem = sample_problem();
-    let config = [0, 1, 2, 1, 0, 2];
-    let masses = problem.sector_masses(&config).unwrap();
+    let config = vec![0, 1, 2, 1, 0, 2];
+    let masses = problem.sector_masses(&config).unwrap().unwrap();
     assert_eq!(masses.len(), 3);
     assert!((masses[0] - 0.3).abs() < EPS);
     assert!((masses[1] - 0.35).abs() < EPS);
     assert!((masses[2] - 0.35).abs() < EPS);
 
-    let cost = problem.expected_cost(&config).unwrap();
+    let cost = problem.expected_cost(&config).unwrap().unwrap();
     assert!((cost - 1.0025).abs() < EPS);
 }
 
 #[test]
 fn test_expected_retrieval_cost_evaluate() {
     let problem = sample_problem();
-    let value = problem.evaluate(&[0, 1, 2, 1, 0, 2]);
+    let value = problem.evaluate(&vec![0, 1, 2, 1, 0, 2]).unwrap();
     assert_eq!(value, Min(Some(1.0025)));
-    assert!(problem.is_valid_solution(&[0, 1, 2, 1, 0, 2]));
+    assert!(problem.is_valid_solution(&[0, 1, 2, 1, 0, 2]).unwrap());
 
     // Invalid config: wrong length
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(None));
-    assert!(!problem.is_valid_solution(&[0, 1, 2]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(!problem.is_valid_solution(&[0, 1, 2]).unwrap());
 
     // Invalid config: sector out of range
-    assert_eq!(problem.evaluate(&[0, 1, 2, 1, 0, 3]), Min(None));
-    assert!(!problem.is_valid_solution(&[0, 1, 2, 1, 0, 3]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 1, 0, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(!problem.is_valid_solution(&[0, 1, 2, 1, 0, 3]).unwrap());
 }
 
 #[test]
 fn test_expected_retrieval_cost_rejects_invalid_configs() {
     let problem = sample_problem();
-    assert_eq!(problem.sector_masses(&[0, 1, 2]), None);
-    assert_eq!(problem.expected_cost(&[0, 1, 2]), None);
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(None));
+    assert_eq!(problem.sector_masses(&[0, 1, 2]).unwrap(), None);
+    assert_eq!(problem.expected_cost(&[0, 1, 2]).unwrap(), None);
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 
-    assert_eq!(problem.sector_masses(&[0, 1, 2, 1, 0, 3]), None);
-    assert_eq!(problem.expected_cost(&[0, 1, 2, 1, 0, 3]), None);
-    assert_eq!(problem.evaluate(&[0, 1, 2, 1, 0, 3]), Min(None));
+    assert_eq!(problem.sector_masses(&[0, 1, 2, 1, 0, 3]).unwrap(), None);
+    assert_eq!(problem.expected_cost(&[0, 1, 2, 1, 0, 3]).unwrap(), None);
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 1, 0, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_expected_retrieval_cost_solver_finds_optimum() {
     let problem = sample_problem();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert!(problem.is_valid_solution(&solution));
-    let cost = problem.expected_cost(&solution).unwrap();
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert!(problem.is_valid_solution(&solution).unwrap());
+    let cost = problem.expected_cost(&solution).unwrap().unwrap();
     // The optimal cost should be <= the known config cost of 1.0025
     assert!(cost <= 1.0025 + EPS);
 }
@@ -75,8 +88,8 @@ fn test_expected_retrieval_cost_solver_finds_optimum() {
 #[test]
 fn test_expected_retrieval_cost_paper_example() {
     let problem = sample_problem();
-    let config = [0, 1, 2, 1, 0, 2];
-    let value = problem.evaluate(&config);
+    let config = vec![0, 1, 2, 1, 0, 2];
+    let value = problem.evaluate(&config).unwrap();
     assert_eq!(value, Min(Some(1.0025)));
 }
 
diff --git a/src/unit_tests/models/misc/factoring.rs b/src/unit_tests/models/misc/factoring.rs
index 61deada65..61bf2f201 100644
--- a/src/unit_tests/models/misc/factoring.rs
+++ b/src/unit_tests/models/misc/factoring.rs
@@ -1,59 +1,77 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
+use num_bigint::BigUint;
 include!("../../jl_helpers.rs");
 
 #[test]
 fn test_factoring_creation() {
-    let problem = Factoring::new(3, 3, 15);
+    let problem = Factoring::with_factor_bits(15, 3, 3);
     assert_eq!(problem.m(), 3);
     assert_eq!(problem.n(), 3);
-    assert_eq!(problem.target(), 15);
+    assert_eq!(problem.target(), &BigUint::from(15u32));
     assert_eq!(problem.num_variables(), 6);
 }
 
 #[test]
-fn test_bits_to_int() {
-    assert_eq!(bits_to_int(&[0, 0, 0]), 0);
-    assert_eq!(bits_to_int(&[1, 0, 0]), 1);
-    assert_eq!(bits_to_int(&[0, 1, 0]), 2);
-    assert_eq!(bits_to_int(&[1, 1, 0]), 3);
-    assert_eq!(bits_to_int(&[0, 0, 1]), 4);
-    assert_eq!(bits_to_int(&[1, 1, 1]), 7);
+fn test_factoring_derives_safe_default_widths() {
+    let problem = Factoring::new(15);
+    assert_eq!(problem.m(), 2);
+    assert_eq!(problem.n(), 3);
+    assert!(problem.is_valid_factorization(&(3u32.into(), 5u32.into())));
+    assert!(!problem.is_valid_factorization(&(1u32.into(), 15u32.into())));
+}
+
+#[test]
+fn test_explicit_widths_allow_trivial_factorization() {
+    let problem = Factoring::with_factor_bits(15, 2, 4);
+    assert!(problem.is_valid_factorization(&(1u32.into(), 15u32.into())));
+}
+
+#[test]
+fn test_bits_to_biguint() {
+    assert_eq!(bits_to_biguint(&[0, 0, 0]), BigUint::from(0u32));
+    assert_eq!(bits_to_biguint(&[1, 0, 0]), BigUint::from(1u32));
+    assert_eq!(bits_to_biguint(&[0, 1, 0]), BigUint::from(2u32));
+    assert_eq!(bits_to_biguint(&[1, 1, 0]), BigUint::from(3u32));
+    assert_eq!(bits_to_biguint(&[0, 0, 1]), BigUint::from(4u32));
+    assert_eq!(bits_to_biguint(&[1, 1, 1]), BigUint::from(7u32));
 }
 
 #[test]
 fn test_int_to_bits() {
-    assert_eq!(int_to_bits(0, 3), vec![0, 0, 0]);
-    assert_eq!(int_to_bits(1, 3), vec![1, 0, 0]);
-    assert_eq!(int_to_bits(2, 3), vec![0, 1, 0]);
-    assert_eq!(int_to_bits(3, 3), vec![1, 1, 0]);
-    assert_eq!(int_to_bits(7, 3), vec![1, 1, 1]);
+    assert_eq!(int_to_bits(&BigUint::from(0u32), 3), vec![0, 0, 0]);
+    assert_eq!(int_to_bits(&BigUint::from(1u32), 3), vec![1, 0, 0]);
+    assert_eq!(int_to_bits(&BigUint::from(2u32), 3), vec![0, 1, 0]);
+    assert_eq!(int_to_bits(&BigUint::from(3u32), 3), vec![1, 1, 0]);
+    assert_eq!(int_to_bits(&BigUint::from(7u32), 3), vec![1, 1, 1]);
 }
 
 #[test]
 fn test_read_factors() {
-    let problem = Factoring::new(2, 2, 6);
+    let problem = Factoring::with_factor_bits(6, 2, 2);
     // bits: [a0, a1, b0, b1]
     // a=2 (binary 10), b=3 (binary 11) -> config = [0,1,1,1]
-    let (a, b) = problem.read_factors(&[0, 1, 1, 1]);
-    assert_eq!(a, 2);
-    assert_eq!(b, 3);
+    let (a, b) = problem.decode_factors(&[0, 1, 1, 1]);
+    assert_eq!(a, BigUint::from(2u32));
+    assert_eq!(b, BigUint::from(3u32));
 }
 
 #[test]
 fn test_is_factoring_function() {
-    assert!(is_factoring(6, 2, 3));
-    assert!(is_factoring(6, 3, 2));
-    assert!(is_factoring(15, 3, 5));
-    assert!(!is_factoring(6, 2, 2));
+    assert!(is_factoring(&6u32.into(), &2u32.into(), &3u32.into()));
+    assert!(is_factoring(&6u32.into(), &3u32.into(), &2u32.into()));
+    assert!(is_factoring(&15u32.into(), &3u32.into(), &5u32.into()));
+    assert!(!is_factoring(&6u32.into(), &2u32.into(), &2u32.into()));
 }
 
 #[test]
 fn test_is_valid_factorization() {
-    let problem = Factoring::new(2, 2, 6);
-    assert!(problem.is_valid_factorization(&[0, 1, 1, 1])); // 2*3=6
-    assert!(!problem.is_valid_factorization(&[0, 1, 0, 1])); // 2*2=4
+    let problem = Factoring::with_factor_bits(6, 2, 2);
+    assert!(problem.is_valid_factorization(&(2u32.into(), 3u32.into())));
+    assert!(!problem.is_valid_factorization(&(3u32.into(), 2u32.into())));
+    assert!(!problem.is_valid_factorization(&(2u32.into(), 2u32.into())));
 }
 
 #[test]
@@ -64,28 +82,35 @@ fn test_jl_parity_evaluation() {
         let m = instance["instance"]["m"].as_u64().unwrap() as usize;
         let n = instance["instance"]["n"].as_u64().unwrap() as usize;
         let input = instance["instance"]["input"].as_u64().unwrap();
-        let problem = Factoring::new(m, n, input);
+        let problem = Factoring::with_factor_bits(input, m.min(n), m.max(n));
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config);
-            let jl_valid = eval["is_valid"].as_bool().unwrap();
-            if jl_valid {
-                assert_eq!(
-                    result.unwrap(),
-                    0,
-                    "Factoring: valid config should have distance 0"
-                );
+            let raw = jl_parse_config(&eval["config"]);
+            let left = bits_to_biguint(&raw[..m]);
+            let right = bits_to_biguint(&raw[m..m + n]);
+            let config = if left <= right {
+                (left, right)
             } else {
-                assert_ne!(
-                    result.unwrap(),
-                    0,
-                    "Factoring: invalid config should have nonzero distance"
-                );
-            }
+                (right, left)
+            };
+            let result = problem.evaluate(&config).unwrap();
+            let jl_valid = eval["is_valid"].as_bool().unwrap();
+            assert_eq!(result.unwrap(), jl_valid);
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best: HashSet<(BigUint, BigUint)> =
+            jl_parse_configs_set(&instance["best_solutions"])
+                .iter()
+                .map(|config| {
+                    let left = bits_to_biguint(&config[..m]);
+                    let right = bits_to_biguint(&config[m..m + n]);
+                    if left <= right {
+                        (left, right)
+                    } else {
+                        (right, left)
+                    }
+                })
+                .collect();
+        let rust_best: HashSet<(BigUint, BigUint)> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "Factoring best solutions mismatch");
     }
 }
@@ -93,16 +118,16 @@ fn test_jl_parity_evaluation() {
 #[test]
 fn test_is_valid_solution() {
     // Factor 15 = 3 × 5, 3 bits each
-    let problem = Factoring::new(3, 3, 15);
+    let problem = Factoring::with_factor_bits(15, 3, 3);
     // Valid: 3 = [1,1,0], 5 = [1,0,1] → config = [1,1,0,1,0,1]
-    assert!(problem.is_valid_solution(&[1, 1, 0, 1, 0, 1]));
+    assert!(problem.is_valid_solution(&(3u32.into(), 5u32.into())));
     // Invalid: 2 = [0,1,0], 3 = [1,1,0] → 2*3=6 ≠ 15
-    assert!(!problem.is_valid_solution(&[0, 1, 0, 1, 1, 0]));
+    assert!(!problem.is_valid_solution(&(2u32.into(), 3u32.into())));
 }
 
 #[test]
-fn test_size_getters() {
-    let problem = Factoring::new(3, 3, 15);
+fn test_parameter_getters() {
+    let problem = Factoring::with_factor_bits(15, 3, 3);
     assert_eq!(problem.num_bits_first(), 3);
     assert_eq!(problem.num_bits_second(), 3);
 }
@@ -110,13 +135,49 @@ fn test_size_getters() {
 #[test]
 fn test_factoring_paper_example() {
     // Paper: N=15, m=2 bits, n=3 bits, p=3, q=5
-    let problem = Factoring::new(2, 3, 15);
+    let problem = Factoring::with_factor_bits(15, 2, 3);
     assert_eq!(problem.num_variables(), 5);
 
     // p=3 -> bits [1,1], q=5 -> bits [1,0,1]
-    let config = vec![1, 1, 1, 0, 1];
-    let (a, b) = problem.read_factors(&config);
-    assert_eq!(a, 3);
-    assert_eq!(b, 5);
+    let config = (BigUint::from(3u32), BigUint::from(5u32));
+    let (a, b) = config.clone();
+    assert_eq!(a, BigUint::from(3u32));
+    assert_eq!(b, BigUint::from(5u32));
     assert!(problem.is_valid_solution(&config));
 }
+
+#[test]
+fn test_factoring_supports_values_beyond_u64() {
+    let a = (BigUint::from(1u32) << 65) + BigUint::from(1u32);
+    let b = BigUint::from(3u32);
+    let target: BigUint = &a * &b;
+    let problem = Factoring::with_factor_bits(target.clone(), 2, 66);
+
+    let config = (b, a);
+    assert!(problem.evaluate(&config).unwrap());
+    assert_eq!(problem.target(), &target);
+
+    let json = serde_json::to_string(&problem).unwrap();
+    let restored: Factoring = serde_json::from_str(&json).unwrap();
+    assert_eq!(restored.target(), &target);
+}
+
+#[test]
+fn test_deserialization_accepts_omitted_widths() {
+    let problem: Factoring = serde_json::from_str(r#"{"target":"15"}"#).unwrap();
+    assert_eq!((problem.m(), problem.n()), (2, 3));
+}
+
+#[test]
+fn test_deserialization_requires_widths_together() {
+    let error = serde_json::from_str::<Factoring>(r#"{"target":"15","m":2}"#).unwrap_err();
+    assert!(error.to_string().contains("must be provided together"));
+}
+
+#[test]
+fn test_default_widths_round_trip_for_one() {
+    let problem = Factoring::new(1);
+    let json = serde_json::to_string(&problem).unwrap();
+    let restored: Factoring = serde_json::from_str(&json).unwrap();
+    assert_eq!((restored.m(), restored.n()), (0, 1));
+}
diff --git a/src/unit_tests/models/misc/feasible_register_assignment.rs b/src/unit_tests/models/misc/feasible_register_assignment.rs
index e352f67c7..08b10831f 100644
--- a/src/unit_tests/models/misc/feasible_register_assignment.rs
+++ b/src/unit_tests/models/misc/feasible_register_assignment.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -12,7 +13,7 @@ fn test_feasible_register_assignment_basic() {
     assert_eq!(problem.num_same_register_pairs(), 3);
     assert_eq!(problem.arcs(), &[(0, 1), (0, 2), (1, 3)]);
     assert_eq!(problem.assignment(), &[0, 1, 0, 0]);
-    assert_eq!(problem.dims(), vec![4; 4]);
+    assert_eq!(problem.dimensions(), vec![4; 4]);
     assert_eq!(
         <FeasibleRegisterAssignment as Problem>::NAME,
         "FeasibleRegisterAssignment"
@@ -29,7 +30,7 @@ fn test_feasible_register_assignment_evaluate_valid() {
     let problem =
         FeasibleRegisterAssignment::new(4, vec![(0, 1), (0, 2), (1, 3)], 2, vec![0, 1, 0, 0]);
     let config = vec![3, 1, 2, 0];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -37,12 +38,21 @@ fn test_feasible_register_assignment_evaluate_invalid_permutation() {
     let problem =
         FeasibleRegisterAssignment::new(4, vec![(0, 1), (0, 2), (1, 3)], 2, vec![0, 1, 0, 0]);
     // Not a permutation: position 0 used twice
-    assert!(!problem.evaluate(&[0, 0, 1, 2]));
+    assert!(!problem.evaluate(&vec![0, 0, 1, 2]).unwrap());
     // Wrong length
-    assert!(!problem.evaluate(&[0, 1, 2]));
-    assert!(!problem.evaluate(&[0, 1, 2, 3, 4]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Position out of range
-    assert!(!problem.evaluate(&[0, 1, 2, 4]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -51,7 +61,7 @@ fn test_feasible_register_assignment_evaluate_invalid_dependency() {
     let problem =
         FeasibleRegisterAssignment::new(4, vec![(0, 1), (0, 2), (1, 3)], 2, vec![0, 1, 0, 0]);
     // v0 at position 0 but v1 at position 1 -> v0 evaluated before its dependency v1
-    assert!(!problem.evaluate(&[0, 1, 2, 3]));
+    assert!(!problem.evaluate(&vec![0, 1, 2, 3]).unwrap());
 }
 
 #[test]
@@ -65,7 +75,7 @@ fn test_feasible_register_assignment_register_conflict() {
     // v1 at pos 0, v0 at pos 1, v2 at pos 2
     // After computing v1 (reg 0): v1 is live (v0, v2 still uncomputed)
     // Computing v0 (reg 0): conflict! v1 is still live in reg 0
-    assert!(!problem.evaluate(&[1, 0, 2]));
+    assert!(!problem.evaluate(&vec![1, 0, 2]).unwrap());
 
     // With different assignment: v1->reg 1, v0->reg 0, v2->reg 0
     let problem2 = FeasibleRegisterAssignment::new(3, vec![(0, 1), (2, 1)], 2, vec![0, 1, 0]);
@@ -75,7 +85,7 @@ fn test_feasible_register_assignment_register_conflict() {
     // After v0 is computed, v1's only remaining dependent is v2
     // Computing v2 (reg 0): v1 is still live (v2 not computed yet)... but
     // v1 is in reg 1, v2 is in reg 0 => no conflict
-    assert!(problem2.evaluate(&[1, 0, 2]));
+    assert!(problem2.evaluate(&vec![1, 0, 2]).unwrap());
 }
 
 #[test]
@@ -84,9 +94,10 @@ fn test_feasible_register_assignment_brute_force() {
         FeasibleRegisterAssignment::new(4, vec![(0, 1), (0, 2), (1, 3)], 2, vec![0, 1, 0, 0]);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
@@ -94,10 +105,10 @@ fn test_feasible_register_assignment_brute_force_all() {
     let problem =
         FeasibleRegisterAssignment::new(4, vec![(0, 1), (0, 2), (1, 3)], 2, vec![0, 1, 0, 0]);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -112,7 +123,7 @@ fn test_feasible_register_assignment_unsatisfiable() {
     let problem =
         FeasibleRegisterAssignment::new(3, vec![(0, 1), (0, 2), (1, 2)], 1, vec![0, 0, 0]);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -132,14 +143,14 @@ fn test_feasible_register_assignment_serialization() {
 fn test_feasible_register_assignment_empty() {
     let problem = FeasibleRegisterAssignment::new(0, vec![], 0, vec![]);
     assert_eq!(problem.num_vertices(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
 fn test_feasible_register_assignment_single_vertex() {
     let problem = FeasibleRegisterAssignment::new(1, vec![], 1, vec![0]);
-    assert!(problem.evaluate(&[0]));
+    assert!(problem.evaluate(&vec![0]).unwrap());
 }
 
 #[test]
@@ -150,8 +161,8 @@ fn test_feasible_register_assignment_no_dependencies() {
     // ever "live" (no dependents), so no conflicts can arise.
     let problem = FeasibleRegisterAssignment::new(3, vec![], 2, vec![0, 1, 0]);
     // Any order works since no vertex has dependents => nothing is ever live
-    assert!(problem.evaluate(&[0, 1, 2]));
-    assert!(problem.evaluate(&[2, 1, 0]));
+    assert!(problem.evaluate(&vec![0, 1, 2]).unwrap());
+    assert!(problem.evaluate(&vec![2, 1, 0]).unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/flow_shop_scheduling.rs b/src/unit_tests/models/misc/flow_shop_scheduling.rs
index 916368a70..a3b327622 100644
--- a/src/unit_tests/models/misc/flow_shop_scheduling.rs
+++ b/src/unit_tests/models/misc/flow_shop_scheduling.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -18,9 +19,9 @@ fn test_flow_shop_scheduling_creation() {
     assert_eq!(problem.num_jobs(), 5);
     assert_eq!(problem.num_processors(), 3);
     assert_eq!(problem.deadline(), 25);
-    assert_eq!(problem.dims().len(), 5);
+    assert_eq!(problem.dimensions().len(), 5);
     // Lehmer code encoding: dims = [5, 4, 3, 2, 1]
-    assert_eq!(problem.dims(), vec![5, 4, 3, 2, 1]);
+    assert_eq!(problem.dimensions(), vec![5, 4, 3, 2, 1]);
 }
 
 #[test]
@@ -41,12 +42,8 @@ fn test_flow_shop_scheduling_evaluate_feasible() {
         25,
     );
 
-    // Lehmer code for job_order [3, 0, 4, 2, 1]:
-    //   available=[0,1,2,3,4], pick 3 -> idx 3; available=[0,1,2,4], pick 0 -> idx 0;
-    //   available=[1,2,4], pick 4 -> idx 2; available=[1,2], pick 2 -> idx 1;
-    //   available=[1], pick 1 -> idx 0
-    let config = vec![3, 0, 2, 1, 0];
-    assert!(problem.evaluate(&config));
+    let config = vec![3, 0, 4, 2, 1];
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -65,21 +62,28 @@ fn test_flow_shop_scheduling_evaluate_infeasible() {
     );
 
     // The sequence j4,j1,j5,j3,j2 gives makespan 23 > 15
-    // Lehmer code for job_order [3, 0, 4, 2, 1] = [3, 0, 2, 1, 0]
-    let config = vec![3, 0, 2, 1, 0];
-    assert!(!problem.evaluate(&config));
+    let config = vec![3, 0, 4, 2, 1];
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_flow_shop_scheduling_invalid_config() {
     let problem = FlowShopScheduling::new(2, vec![vec![1, 2], vec![3, 4]], 10);
 
-    // Lehmer code out of range: dims = [2, 1], so config[0] must be < 2, config[1] must be < 1
-    assert!(!problem.evaluate(&[2, 0])); // config[0] = 2 >= 2
-    assert!(!problem.evaluate(&[0, 1])); // config[1] = 1 >= 1
-                                         // Wrong length
-    assert!(!problem.evaluate(&[0]));
-    assert!(!problem.evaluate(&[0, 0, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![2, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(!problem.evaluate(&vec![0, 0]).unwrap());
+    // Wrong length
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -113,7 +117,7 @@ fn test_flow_shop_scheduling_compute_makespan() {
     // Machine 0: j0[0,3], j1[3,5], j2[5,6]
     // Machine 1: j0[3,5], j1[5,9], j2[9,12]
     // Makespan = 12
-    assert_eq!(problem.compute_makespan(&[0, 1, 2]), 12);
+    assert_eq!(problem.compute_makespan(&[0, 1, 2]).unwrap(), 12);
 }
 
 #[test]
@@ -121,10 +125,10 @@ fn test_flow_shop_scheduling_brute_force_solver() {
     // Small instance: 2 machines, 3 jobs, generous deadline
     let problem = FlowShopScheduling::new(2, vec![vec![3, 2], vec![2, 4], vec![1, 3]], 20);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let config = solution.unwrap();
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -137,7 +141,7 @@ fn test_flow_shop_scheduling_brute_force_unsatisfiable() {
     // Deadline 10 < 15 => unsatisfiable
     let problem = FlowShopScheduling::new(2, vec![vec![5, 5], vec![5, 5]], 10);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
@@ -145,9 +149,9 @@ fn test_flow_shop_scheduling_brute_force_unsatisfiable() {
 fn test_flow_shop_scheduling_empty() {
     let problem = FlowShopScheduling::new(3, vec![], 0);
     assert_eq!(problem.num_jobs(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
     // Empty config should be satisfying (no jobs to schedule)
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -166,13 +170,12 @@ fn test_flow_shop_scheduling_find_all_witnesses() {
         25,
     );
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
-    // The issue witness sequence [3,0,4,2,1] = Lehmer code [3,0,2,1,0]
-    // gives makespan 23 ≤ 25
-    assert!(solutions.contains(&vec![3, 0, 2, 1, 0]));
+    // The issue witness sequence [3,0,4,2,1] gives makespan 23 ≤ 25.
+    assert!(solutions.contains(&vec![3, 0, 4, 2, 1]));
     // 99 out of 120 permutations have makespan ≤ 25
     assert_eq!(solutions.len(), 99);
 }
@@ -183,7 +186,7 @@ fn test_flow_shop_scheduling_find_all_witnesses_empty() {
     // Both orderings give makespan 15 > 10
     let problem = FlowShopScheduling::new(2, vec![vec![5, 5], vec![5, 5]], 10);
     let solver = BruteForce::new();
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+    assert!(solver.find_all_witnesses(&problem).unwrap().is_empty());
 }
 
 #[test]
@@ -191,7 +194,7 @@ fn test_flow_shop_scheduling_single_job() {
     // 3 machines, 1 job: [2, 3, 4]
     // Makespan = 2 + 3 + 4 = 9
     let problem = FlowShopScheduling::new(3, vec![vec![2, 3, 4]], 10);
-    assert!(problem.evaluate(&[0])); // makespan 9 <= 10
+    assert!(problem.evaluate(&vec![0]).unwrap()); // makespan 9 <= 10
     let tight = FlowShopScheduling::new(3, vec![vec![2, 3, 4]], 8);
-    assert!(!tight.evaluate(&[0])); // makespan 9 > 8
+    assert!(!tight.evaluate(&vec![0]).unwrap()); // makespan 9 > 8
 }
diff --git a/src/unit_tests/models/misc/grouping_by_swapping.rs b/src/unit_tests/models/misc/grouping_by_swapping.rs
index 1436988be..7b56a31d8 100644
--- a/src/unit_tests/models/misc/grouping_by_swapping.rs
+++ b/src/unit_tests/models/misc/grouping_by_swapping.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 fn issue_yes_instance() -> GroupingBySwapping {
@@ -22,7 +23,7 @@ fn test_grouping_by_swapping_basic() {
     assert_eq!(problem.budget(), 5);
     assert_eq!(problem.string_len(), 6);
     assert_eq!(problem.num_variables(), 5);
-    assert_eq!(problem.dims(), vec![6; 5]);
+    assert_eq!(problem.dimensions(), vec![6; 5]);
     assert_eq!(<GroupingBySwapping as Problem>::NAME, "GroupingBySwapping");
     assert_eq!(<GroupingBySwapping as Problem>::variant(), vec![]);
 
@@ -34,12 +35,12 @@ fn test_grouping_by_swapping_basic() {
 #[test]
 fn test_grouping_by_swapping_evaluate_issue_yes() {
     let problem = issue_yes_instance();
-    assert!(problem.evaluate(&[2, 1, 3, 5, 5]));
+    assert!(problem.evaluate(&vec![2, 1, 3, 5, 5]).unwrap());
     assert_eq!(
         problem.apply_swap_program(&[2, 1, 3, 5, 5]),
         Some(vec![0, 0, 1, 1, 2, 2])
     );
-    assert!(!problem.evaluate(&[0, 1, 2, 3, 4]));
+    assert!(!problem.evaluate(&vec![0, 1, 2, 3, 4]).unwrap());
     assert!(!problem.is_grouped(&[0, 1, 0]));
     assert!(problem.is_grouped(&[0, 0, 1, 1, 2, 2]));
 }
@@ -47,8 +48,14 @@ fn test_grouping_by_swapping_evaluate_issue_yes() {
 #[test]
 fn test_grouping_by_swapping_rejects_wrong_length_and_out_of_range_swaps() {
     let problem = issue_yes_instance();
-    assert!(!problem.evaluate(&[2, 1, 3, 5]));
-    assert!(!problem.evaluate(&[2, 1, 3, 5, 6]));
+    assert!(matches!(
+        problem.evaluate(&vec![2, 1, 3, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![2, 1, 3, 5, 6]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     assert_eq!(problem.apply_swap_program(&[2, 1, 3, 5]), None);
     assert_eq!(problem.apply_swap_program(&[2, 1, 3, 5, 6]), None);
 }
@@ -60,29 +67,32 @@ fn test_grouping_by_swapping_bruteforce_yes_and_no() {
     let solver = BruteForce::new();
 
     let satisfying = solver
-        .find_witness(&yes_problem)
+        .solve(&yes_problem)
+        .unwrap()
         .expect("expected a satisfying 3-swap sequence");
-    assert!(yes_problem.evaluate(&satisfying));
+    assert!(yes_problem.evaluate(&satisfying).unwrap());
     assert!(solver
         .find_all_witnesses(&yes_problem)
+        .unwrap()
         .iter()
         .any(|config| config == &vec![2, 1, 3]));
 
-    assert!(solver.find_witness(&no_problem).is_none());
-    assert!(solver.find_all_witnesses(&no_problem).is_empty());
+    assert!(solver.solve(&no_problem).unwrap().is_none());
+    assert!(solver.find_all_witnesses(&no_problem).unwrap().is_empty());
 }
 
 #[test]
 fn test_grouping_by_swapping_paper_example() {
     let problem = issue_yes_instance();
-    assert!(problem.evaluate(&[2, 1, 3, 5, 5]));
+    assert!(problem.evaluate(&vec![2, 1, 3, 5, 5]).unwrap());
 
     let solver = BruteForce::new();
     assert!(solver
         .find_all_witnesses(&problem)
+        .unwrap()
         .iter()
         .any(|config| config == &vec![2, 1, 3, 5, 5]));
-    assert!(solver.find_witness(&issue_two_swap_instance()).is_none());
+    assert!(solver.solve(&issue_two_swap_instance()).unwrap().is_none());
 }
 
 #[test]
@@ -106,3 +116,34 @@ fn test_grouping_by_swapping_symbol_out_of_range_panics() {
 fn test_grouping_by_swapping_empty_string_requires_zero_budget() {
     GroupingBySwapping::new(0, vec![], 1);
 }
+
+#[test]
+fn test_grouping_by_swapping_create_spec_derives_alphabet_and_renames_bound() {
+    let problem = GroupingBySwapping::try_from(GroupingBySwappingCreateSpec {
+        alphabet_size: None,
+        string: vec![0, 2, 1],
+        bound: 4,
+    })
+    .unwrap();
+
+    assert_eq!(problem.alphabet_size(), 3);
+    assert_eq!(problem.budget(), 4);
+    assert_eq!(
+        GroupingBySwappingCreateSpec::FIELDS
+            .iter()
+            .map(|field| field.name)
+            .collect::<Vec<_>>(),
+        ["alphabet_size", "string", "bound"]
+    );
+}
+
+#[test]
+fn test_grouping_by_swapping_create_spec_rejects_nonzero_bound_for_empty_string() {
+    let result = GroupingBySwapping::try_from(GroupingBySwappingCreateSpec {
+        alphabet_size: None,
+        string: vec![],
+        bound: 1,
+    });
+
+    assert!(result.is_err());
+}
diff --git a/src/unit_tests/models/misc/integer_expression_membership.rs b/src/unit_tests/models/misc/integer_expression_membership.rs
index a754e99f3..781cdab77 100644
--- a/src/unit_tests/models/misc/integer_expression_membership.rs
+++ b/src/unit_tests/models/misc/integer_expression_membership.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 /// Helper: build expression (1 ∪ 4) + (3 ∪ 6) + (2 ∪ 5)
@@ -31,7 +32,7 @@ fn test_integer_expression_membership_creation() {
     assert_eq!(problem.num_atoms(), 6);
     assert_eq!(problem.expression_size(), 11); // 6 atoms + 3 unions + 2 sums
     assert_eq!(problem.expression_depth(), 3);
-    assert_eq!(problem.dims(), vec![2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2]);
     assert_eq!(
         <IntegerExpressionMembership as Problem>::NAME,
         "IntegerExpressionMembership"
@@ -43,30 +44,40 @@ fn test_integer_expression_membership_creation() {
 fn test_integer_expression_membership_evaluate_satisfying() {
     let problem = IntegerExpressionMembership::new(example_expr(), 12);
     // config [1,1,0]: choose 4, 6, 2 → 4+6+2=12
-    assert!(problem.evaluate(&[1, 1, 0]));
+    assert!(problem.evaluate(&vec![true, true, false]).unwrap());
     // config [0,1,1]: choose 1, 6, 5 → 1+6+5=12
-    assert!(problem.evaluate(&[0, 1, 1]));
+    assert!(problem.evaluate(&vec![false, true, true]).unwrap());
 }
 
 #[test]
 fn test_integer_expression_membership_evaluate_unsatisfying() {
     let problem = IntegerExpressionMembership::new(example_expr(), 12);
     // config [0,0,0]: choose 1, 3, 2 → 1+3+2=6 ≠ 12
-    assert!(!problem.evaluate(&[0, 0, 0]));
+    assert!(!problem.evaluate(&vec![false, false, false]).unwrap());
     // config [1,0,0]: choose 4, 3, 2 → 4+3+2=9 ≠ 12
-    assert!(!problem.evaluate(&[1, 0, 0]));
+    assert!(!problem.evaluate(&vec![true, false, false]).unwrap());
     // config [1,1,1]: choose 4, 6, 5 → 4+6+5=15 ≠ 12
-    assert!(!problem.evaluate(&[1, 1, 1]));
+    assert!(!problem.evaluate(&vec![true, true, true]).unwrap());
 }
 
 #[test]
 fn test_integer_expression_membership_evaluate_wrong_config() {
     let problem = IntegerExpressionMembership::new(example_expr(), 12);
     // Wrong length
-    assert!(!problem.evaluate(&[0, 0]));
-    assert!(!problem.evaluate(&[0, 0, 0, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![false, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Invalid value
-    assert!(!problem.evaluate(&[2, 0, 0]));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, false, false])
+    )
+    .is_err());
 }
 
 #[test]
@@ -74,20 +85,21 @@ fn test_integer_expression_membership_brute_force() {
     let problem = IntegerExpressionMembership::new(example_expr(), 12);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_integer_expression_membership_brute_force_all() {
     let problem = IntegerExpressionMembership::new(example_expr(), 12);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // K=12 can be reached by [0,1,1] (1+6+5), [1,0,1] (4+3+5), [1,1,0] (4+6+2)
     assert_eq!(solutions.len(), 3);
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -96,7 +108,7 @@ fn test_integer_expression_membership_unsatisfiable() {
     // Target 100 is unreachable from {1,4}+{3,6}+{2,5} (max is 15)
     let problem = IntegerExpressionMembership::new(example_expr(), 100);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -104,15 +116,15 @@ fn test_integer_expression_membership_single_atom() {
     let expr = IntExpr::Atom(42);
     let problem = IntegerExpressionMembership::new(expr, 42);
     assert_eq!(problem.num_union_nodes(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[])); // empty config, atom == target
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap()); // empty config, atom == target
 }
 
 #[test]
 fn test_integer_expression_membership_single_atom_miss() {
     let expr = IntExpr::Atom(42);
     let problem = IntegerExpressionMembership::new(expr, 7);
-    assert!(!problem.evaluate(&[])); // 42 ≠ 7
+    assert!(!problem.evaluate(&vec![]).unwrap()); // 42 ≠ 7
 }
 
 #[test]
@@ -121,9 +133,9 @@ fn test_integer_expression_membership_simple_union() {
     let expr = IntExpr::Union(Box::new(IntExpr::Atom(3)), Box::new(IntExpr::Atom(7)));
     let problem = IntegerExpressionMembership::new(expr, 7);
     assert_eq!(problem.num_union_nodes(), 1);
-    assert_eq!(problem.dims(), vec![2]);
-    assert!(!problem.evaluate(&[0])); // 3 ≠ 7
-    assert!(problem.evaluate(&[1])); // 7 == 7
+    assert_eq!(problem.dimensions(), vec![2]);
+    assert!(!problem.evaluate(&vec![false]).unwrap()); // 3 ≠ 7
+    assert!(problem.evaluate(&vec![true]).unwrap()); // 7 == 7
 }
 
 #[test]
@@ -132,7 +144,7 @@ fn test_integer_expression_membership_simple_sum() {
     let expr = IntExpr::Sum(Box::new(IntExpr::Atom(3)), Box::new(IntExpr::Atom(5)));
     let problem = IntegerExpressionMembership::new(expr, 8);
     assert_eq!(problem.num_union_nodes(), 0);
-    assert!(problem.evaluate(&[])); // 3+5=8
+    assert!(problem.evaluate(&vec![]).unwrap()); // 3+5=8
 }
 
 #[test]
@@ -143,16 +155,16 @@ fn test_integer_expression_membership_serialization() {
     let restored: IntegerExpressionMembership = serde_json::from_value(json).unwrap();
     assert_eq!(restored.target(), 4);
     assert_eq!(restored.num_union_nodes(), 1);
-    assert!(restored.evaluate(&[1])); // choose 4
+    assert!(restored.evaluate(&vec![true]).unwrap()); // choose 4
 }
 
 #[test]
 fn test_integer_expression_membership_evaluate_config() {
     let problem = IntegerExpressionMembership::new(example_expr(), 12);
-    assert_eq!(problem.evaluate_config(&[1, 1, 0]), Some(12)); // 4+6+2
-    assert_eq!(problem.evaluate_config(&[0, 0, 0]), Some(6)); // 1+3+2
-    assert_eq!(problem.evaluate_config(&[1, 1, 1]), Some(15)); // 4+6+5
-    assert_eq!(problem.evaluate_config(&[0, 0, 1]), Some(9)); // 1+3+5
+    assert_eq!(problem.evaluate_config(&[true, true, false]), Some(12)); // 4+6+2
+    assert_eq!(problem.evaluate_config(&[false, false, false]), Some(6)); // 1+3+2
+    assert_eq!(problem.evaluate_config(&[true, true, true]), Some(15)); // 4+6+5
+    assert_eq!(problem.evaluate_config(&[false, false, true]), Some(9)); // 1+3+5
 }
 
 #[test]
@@ -163,14 +175,14 @@ fn test_integer_expression_membership_paper_example() {
     let problem = IntegerExpressionMembership::new(example_expr(), 12);
 
     // Verify the claimed witness
-    assert_eq!(problem.evaluate_config(&[1, 1, 0]), Some(12));
-    assert!(problem.evaluate(&[1, 1, 0]));
+    assert_eq!(problem.evaluate_config(&[true, true, false]), Some(12));
+    assert!(problem.evaluate(&vec![true, true, false]).unwrap());
 
     // Verify all 8 configs produce the set {6, 9, 12, 15}
-    let mut values: Vec<u64> = Vec::new();
-    for c0 in 0..2 {
-        for c1 in 0..2 {
-            for c2 in 0..2 {
+    let mut values: Vec<i64> = Vec::new();
+    for c0 in [false, true] {
+        for c1 in [false, true] {
+            for c2 in [false, true] {
                 values.push(problem.evaluate_config(&[c0, c1, c2]).unwrap());
             }
         }
@@ -182,7 +194,7 @@ fn test_integer_expression_membership_paper_example() {
     // Brute force confirms 3 satisfying configs for K=12:
     // [0,1,1] (1+6+5), [1,0,1] (4+3+5), [1,1,0] (4+6+2)
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 3);
 }
 
@@ -202,22 +214,22 @@ fn test_integer_expression_membership_nested_unions() {
     // [0, 0] → left of outer → left of inner → 1
     // [0, 1] → left of outer → right of inner → 2
     // [1, _] → right of outer → 3 (inner union not visited)
-    assert!(!problem.evaluate(&[0, 0])); // 1 ≠ 2
-    assert!(problem.evaluate(&[0, 1])); // 2 == 2
-    assert!(!problem.evaluate(&[1, 0])); // 3 ≠ 2
-    assert!(!problem.evaluate(&[1, 1])); // 3 ≠ 2
+    assert!(!problem.evaluate(&vec![false, false]).unwrap()); // 1 ≠ 2
+    assert!(problem.evaluate(&vec![false, true]).unwrap()); // 2 == 2
+    assert!(!problem.evaluate(&vec![true, false]).unwrap()); // 3 ≠ 2
+    assert!(!problem.evaluate(&vec![true, true]).unwrap()); // 3 ≠ 2
 }
 
 #[test]
 fn test_integer_expression_membership_overflow_safe() {
-    // Two atoms that sum to > u64::MAX should evaluate to Or(false), not panic.
+    // Two atoms that sum to > i64::MAX should evaluate to Or(false), not panic.
     let expr = IntExpr::Sum(
-        Box::new(IntExpr::Atom(u64::MAX)),
+        Box::new(IntExpr::Atom(i64::MAX)),
         Box::new(IntExpr::Atom(1)),
     );
     let problem = IntegerExpressionMembership::new(expr, 42);
     // The only config is [] (no union nodes). The sum overflows → None → Or(false).
-    assert!(!problem.evaluate(&[]));
+    assert!(!problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/job_shop_scheduling.rs b/src/unit_tests/models/misc/job_shop_scheduling.rs
index 4b252f1d5..e190677ca 100644
--- a/src/unit_tests/models/misc/job_shop_scheduling.rs
+++ b/src/unit_tests/models/misc/job_shop_scheduling.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -26,14 +27,17 @@ fn test_job_shop_scheduling_creation_and_dims() {
     assert_eq!(problem.num_processors(), 2);
     assert_eq!(problem.num_jobs(), 5);
     assert_eq!(problem.num_tasks(), 12);
-    assert_eq!(problem.dims(), vec![6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1]);
+    assert_eq!(
+        problem.dimensions(),
+        vec![6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1]
+    );
 }
 
 #[test]
 fn test_job_shop_scheduling_evaluate_issue_example() {
     let problem = issue_example();
     let config = vec![0, 0, 0, 0, 0, 0, 1, 3, 0, 1, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(19)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(19)));
 }
 
 #[test]
@@ -61,14 +65,20 @@ fn test_job_shop_scheduling_paper_example_schedule() {
 fn test_job_shop_scheduling_rejects_cyclic_machine_orders() {
     let problem = small_two_job_instance();
     let config = vec![1, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_job_shop_scheduling_invalid_config_and_serialization() {
     let problem = small_two_job_instance();
-    assert_eq!(problem.evaluate(&[2, 0, 0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![2, 0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 
     let json = serde_json::to_value(&problem).unwrap();
     let restored: JobShopScheduling = serde_json::from_value(json).unwrap();
@@ -86,8 +96,42 @@ fn test_job_shop_scheduling_problem_name_and_variant() {
 fn test_job_shop_scheduling_brute_force_solver_small_instance() {
     let problem = small_two_job_instance();
     let solver = BruteForce::new();
-    let value = Solver::solve(&solver, &problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(2)));
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&witness), Min(Some(2)));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(2)));
+}
+
+#[test]
+fn test_job_shop_scheduling_create_spec_derives_processor_count() {
+    let problem = JobShopScheduling::try_from(JobShopSchedulingCreateSpec {
+        jobs: vec![vec![(0, 2), (2, 1)]],
+        num_processors: None,
+    })
+    .unwrap();
+
+    assert_eq!(problem.num_processors(), 3);
+    assert_eq!(
+        JobShopSchedulingCreateSpec::FIELDS
+            .iter()
+            .map(|field| field.name)
+            .collect::<Vec<_>>(),
+        ["jobs", "num_processors"]
+    );
+}
+
+#[test]
+fn test_job_shop_scheduling_create_spec_rejects_invalid_jobs() {
+    let empty = JobShopScheduling::try_from(JobShopSchedulingCreateSpec {
+        jobs: vec![],
+        num_processors: None,
+    });
+    assert!(empty.is_err());
+
+    let repeated_processor = JobShopScheduling::try_from(JobShopSchedulingCreateSpec {
+        jobs: vec![vec![(0, 1), (0, 2)]],
+        num_processors: Some(1),
+    });
+    assert!(repeated_processor.is_err());
 }
diff --git a/src/unit_tests/models/misc/knapsack.rs b/src/unit_tests/models/misc/knapsack.rs
index ec75b7077..b58568b2f 100644
--- a/src/unit_tests/models/misc/knapsack.rs
+++ b/src/unit_tests/models/misc/knapsack.rs
@@ -1,4 +1,16 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_item_weights() {
+    let p = Knapsack::try_from(KnapsackCreateSpec {
+        weights: None,
+        values: vec![2, 3],
+        capacity: 1,
+    })
+    .unwrap();
+    assert_eq!(p.weights(), &[1, 1]);
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
@@ -9,7 +21,7 @@ fn test_knapsack_basic() {
     assert_eq!(problem.weights(), &[2, 3, 4, 5]);
     assert_eq!(problem.values(), &[3, 4, 5, 7]);
     assert_eq!(problem.capacity(), 7);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(<Knapsack as Problem>::NAME, "Knapsack");
     assert_eq!(<Knapsack as Problem>::variant(), vec![]);
 }
@@ -17,52 +29,76 @@ fn test_knapsack_basic() {
 #[test]
 fn test_knapsack_evaluate_optimal() {
     let problem = Knapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], 7);
-    assert_eq!(problem.evaluate(&[1, 0, 0, 1]), Max(Some(10)));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false, true]).unwrap(),
+        Max(Some(10))
+    );
 }
 
 #[test]
 fn test_knapsack_evaluate_feasible() {
     let problem = Knapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], 7);
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0]), Max(Some(7)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false, false]).unwrap(),
+        Max(Some(7))
+    );
 }
 
 #[test]
 fn test_knapsack_evaluate_overweight() {
     let problem = Knapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], 7);
-    assert_eq!(problem.evaluate(&[0, 0, 1, 1]), Max(None));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, true, true]).unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
 fn test_knapsack_evaluate_empty() {
     let problem = Knapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], 7);
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Max(Some(0)));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false, false]).unwrap(),
+        Max(Some(0))
+    );
 }
 
 #[test]
 fn test_knapsack_evaluate_all_selected() {
     let problem = Knapsack::new(vec![1, 1, 1], vec![10, 20, 30], 5);
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Max(Some(60)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true]).unwrap(),
+        Max(Some(60))
+    );
 }
 
 #[test]
 fn test_knapsack_evaluate_wrong_config_length() {
     let problem = Knapsack::new(vec![2, 3], vec![3, 4], 5);
-    assert_eq!(problem.evaluate(&[1]), Max(None));
-    assert_eq!(problem.evaluate(&[1, 0, 0]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_knapsack_evaluate_invalid_variable_value() {
     let problem = Knapsack::new(vec![2, 3], vec![3, 4], 5);
-    assert_eq!(problem.evaluate(&[2, 0]), Max(None));
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([2, false]))
+            .is_err()
+    );
 }
 
 #[test]
 fn test_knapsack_empty_instance() {
     let problem = Knapsack::new(vec![], vec![], 10);
     assert_eq!(problem.num_items(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert_eq!(problem.evaluate(&[]), Max(Some(0)));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -70,9 +106,10 @@ fn test_knapsack_brute_force() {
     let problem = Knapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], 7);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     assert_eq!(metric, Max(Some(10)));
 }
 
@@ -90,22 +127,22 @@ fn test_knapsack_serialization() {
 fn test_knapsack_zero_capacity() {
     // Capacity 0: only empty set is feasible
     let problem = Knapsack::new(vec![1, 2], vec![10, 20], 0);
-    assert_eq!(problem.evaluate(&[0, 0]), Max(Some(0)));
-    assert_eq!(problem.evaluate(&[1, 0]), Max(None));
+    assert_eq!(problem.evaluate(&vec![false, false]).unwrap(), Max(Some(0)));
+    assert_eq!(problem.evaluate(&vec![true, false]).unwrap(), Max(None));
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Max(Some(0)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(0)));
 }
 
 #[test]
 fn test_knapsack_single_item() {
     // Single item that fits
     let problem = Knapsack::new(vec![3], vec![5], 3);
-    assert_eq!(problem.evaluate(&[1]), Max(Some(5)));
-    assert_eq!(problem.evaluate(&[0]), Max(Some(0)));
+    assert_eq!(problem.evaluate(&vec![true]).unwrap(), Max(Some(5)));
+    assert_eq!(problem.evaluate(&vec![false]).unwrap(), Max(Some(0)));
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Max(Some(5)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(5)));
 }
 
 #[test]
@@ -117,8 +154,8 @@ fn test_knapsack_greedy_not_optimal() {
     // Capacity=10. Greedy: {0} value=7. Optimal: {1,2} value=10.
     let problem = Knapsack::new(vec![6, 5, 5], vec![7, 5, 5], 10);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Max(Some(10)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(10)));
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/kth_largest_m_tuple.rs b/src/unit_tests/models/misc/kth_largest_m_tuple.rs
index 1b26eb836..e7e905157 100644
--- a/src/unit_tests/models/misc/kth_largest_m_tuple.rs
+++ b/src/unit_tests/models/misc/kth_largest_m_tuple.rs
@@ -1,16 +1,29 @@
-use crate::models::misc::KthLargestMTuple;
-use crate::solvers::{BruteForce, Solver};
+use super::*;
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
-use crate::types::Sum;
+use crate::types::Or;
 
-fn example_problem() -> KthLargestMTuple {
-    // m=3, X_1={2,5,8}, X_2={3,6}, X_3={1,4,7}, B=12, K=14
-    KthLargestMTuple::new(vec![vec![2, 5, 8], vec![3, 6], vec![1, 4, 7]], 14, 12)
+fn example_problem(k: i64) -> KthLargestMTuple {
+    // m=3, X_1={2,5,8}, X_2={3,6}, X_3={1,4,7}, B=12
+    KthLargestMTuple::new(vec![vec![2, 5, 8], vec![3, 6], vec![1, 4, 7]], k, 12)
+}
+
+#[test]
+fn test_kth_largest_m_tuple_create_spec_uses_subsets_input() {
+    assert_eq!(KthLargestMTupleCreateSpec::FIELDS[0].name, "subsets");
+    let problem = KthLargestMTuple::try_from(KthLargestMTupleCreateSpec {
+        subsets: vec![vec![1], vec![2]],
+        k: 1,
+        bound: 3,
+    })
+    .unwrap();
+    assert_eq!(problem.sets(), &[vec![1], vec![2]]);
 }
 
 #[test]
 fn test_kth_largest_m_tuple_creation() {
-    let p = example_problem();
+    let p = example_problem(14);
     assert_eq!(p.sets().len(), 3);
     assert_eq!(p.sets()[0], vec![2, 5, 8]);
     assert_eq!(p.sets()[1], vec![3, 6]);
@@ -19,64 +32,35 @@ fn test_kth_largest_m_tuple_creation() {
     assert_eq!(p.bound(), 12);
     assert_eq!(p.num_sets(), 3);
     assert_eq!(p.total_tuples(), 18);
-    assert_eq!(p.dims(), vec![3, 2, 3]);
-    assert_eq!(p.num_variables(), 3);
+    assert_eq!(p.dimensions(), Vec::<usize>::new());
+    assert_eq!(p.num_variables(), 0);
     assert_eq!(<KthLargestMTuple as Problem>::NAME, "KthLargestMTuple");
     assert_eq!(<KthLargestMTuple as Problem>::variant(), vec![]);
 }
 
 #[test]
-fn test_kth_largest_m_tuple_evaluate_qualifying_tuple() {
-    let p = example_problem();
-    // (8,6,7) = sum 21 >= 12 -> Sum(1)
-    assert_eq!(p.evaluate(&[2, 1, 2]), Sum(1));
-    // (5,6,4) = sum 15 >= 12 -> Sum(1)
-    assert_eq!(p.evaluate(&[1, 1, 1]), Sum(1));
-}
+fn test_kth_largest_m_tuple_threshold_decision() {
+    let p = example_problem(14);
+    assert_eq!(
+        p.evaluate(&BruteForce::new().solve(&p).unwrap().unwrap())
+            .unwrap(),
+        Or(true)
+    );
 
-#[test]
-fn test_kth_largest_m_tuple_evaluate_non_qualifying_tuple() {
-    let p = example_problem();
-    // (2,3,1) = sum 6 < 12 -> Sum(0)
-    assert_eq!(p.evaluate(&[0, 0, 0]), Sum(0));
-    // (2,3,4) = sum 9 < 12 -> Sum(0)
-    assert_eq!(p.evaluate(&[0, 0, 1]), Sum(0));
+    let above_threshold = example_problem(15);
+    assert!(BruteForce::new().solve(&above_threshold).unwrap().is_none());
 }
 
 #[test]
 fn test_kth_largest_m_tuple_evaluate_invalid_configs() {
-    let p = example_problem();
-    // Wrong length
-    assert_eq!(p.evaluate(&[0, 0]), Sum(0));
-    assert_eq!(p.evaluate(&[0, 0, 0, 0]), Sum(0));
-    // Out of range
-    assert_eq!(p.evaluate(&[3, 0, 0]), Sum(0));
-    assert_eq!(p.evaluate(&[0, 2, 0]), Sum(0));
-    assert_eq!(p.evaluate(&[0, 0, 3]), Sum(0));
-}
-
-#[test]
-fn test_kth_largest_m_tuple_solver() {
-    let p = example_problem();
-    let solver = BruteForce::new();
-    let value = solver.solve(&p);
-    // 14 of 18 tuples qualify (sum >= 12)
-    assert_eq!(value, Sum(14));
-}
-
-#[test]
-fn test_kth_largest_m_tuple_boundary_example() {
-    // K=14 and count=14, so the answer is YES (count >= K)
-    let p = example_problem();
-    let solver = BruteForce::new();
-    let count = solver.solve(&p);
-    assert_eq!(count, Sum(14));
-    assert!(count.0 >= p.k());
+    let p = example_problem(14);
+    assert!(crate::registry::DynProblem::evaluate_dyn(&p, &serde_json::json!([0])).is_err());
+    assert!(crate::registry::DynProblem::evaluate_dyn(&p, &serde_json::json!([2, 1, 2])).is_err());
 }
 
 #[test]
 fn test_kth_largest_m_tuple_serialization_round_trip() {
-    let p = example_problem();
+    let p = example_problem(14);
     let json = serde_json::to_value(&p).unwrap();
     assert_eq!(
         json,
@@ -135,16 +119,12 @@ fn test_kth_largest_m_tuple_zero_size_panics() {
 fn test_kth_largest_m_tuple_paper_example() {
     // Issue example: m=3, X_1={2,5,8}, X_2={3,6}, X_3={1,4,7}, B=12, K=14
     // 14 of 18 tuples have sum >= 12 -> YES (boundary case: count == K)
-    let p = example_problem();
+    let p = example_problem(14);
     let solver = BruteForce::new();
-    let count = solver.solve(&p);
-    assert_eq!(count, Sum(14));
-
-    // Verify a specific qualifying tuple: (8,6,7), sum=21
-    assert_eq!(p.evaluate(&[2, 1, 2]), Sum(1));
-
-    // Verify a specific non-qualifying tuple: (2,3,1), sum=6
-    assert_eq!(p.evaluate(&[0, 0, 0]), Sum(0));
+    assert_eq!(
+        p.evaluate(&solver.solve(&p).unwrap().unwrap()).unwrap(),
+        Or(true)
+    );
 }
 
 #[test]
@@ -152,7 +132,10 @@ fn test_kth_largest_m_tuple_all_qualify() {
     // Two sets each with one large element, B=1 -> all tuples qualify
     let p = KthLargestMTuple::new(vec![vec![5], vec![10]], 1, 1);
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&p), Sum(1));
+    assert_eq!(
+        p.evaluate(&solver.solve(&p).unwrap().unwrap()).unwrap(),
+        Or(true)
+    );
     assert_eq!(p.total_tuples(), 1);
 }
 
@@ -161,5 +144,33 @@ fn test_kth_largest_m_tuple_none_qualify() {
     // B is larger than any possible sum
     let p = KthLargestMTuple::new(vec![vec![1, 2], vec![1, 2]], 1, 100);
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&p), Sum(0));
+    assert!(solver.solve(&p).unwrap().is_none());
+}
+
+#[test]
+fn test_kth_largest_m_tuple_reports_sum_beyond_i64_max() {
+    let p = KthLargestMTuple::new(vec![vec![i64::MAX], vec![1]], 1, i64::MAX);
+    assert!(matches!(
+        BruteForce::new().solve(&p),
+        Err(crate::solvers::SolveError::Evaluation(
+            crate::traits::EvaluationError::IntegerOverflow(_)
+        ))
+    ));
+}
+
+#[test]
+fn test_kth_largest_m_tuple_many_singleton_sets_do_not_use_call_stack() {
+    let p = KthLargestMTuple::new(vec![vec![1]; 10_000], 1, 10_000);
+    assert_eq!(
+        p.evaluate(&BruteForce::new().solve(&p).unwrap().unwrap())
+            .unwrap(),
+        Or(true)
+    );
+}
+
+#[test]
+#[should_panic(expected = "total tuple count exceeds usize")]
+fn test_kth_largest_m_tuple_total_tuples_overflow_panics() {
+    let p = KthLargestMTuple::new(vec![vec![1, 2]; usize::BITS as usize], 1, 1);
+    p.total_tuples();
 }
diff --git a/src/unit_tests/models/misc/longest_common_subsequence.rs b/src/unit_tests/models/misc/longest_common_subsequence.rs
index 83747828f..913a300db 100644
--- a/src/unit_tests/models/misc/longest_common_subsequence.rs
+++ b/src/unit_tests/models/misc/longest_common_subsequence.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Max;
 
@@ -34,7 +35,7 @@ fn test_lcs_basic() {
     assert_eq!(problem.sum_squared_lengths(), 216);
     assert_eq!(problem.sum_triangular_lengths(), 126);
     assert_eq!(problem.num_transitions(), 5);
-    assert_eq!(problem.dims(), vec![3; 6]); // alphabet_size + 1 = 3, max_length = 6
+    assert_eq!(problem.dimensions(), vec![3; 6]); // alphabet_size + 1 = 3, max_length = 6
     assert_eq!(
         <LongestCommonSubsequence as Problem>::NAME,
         "LongestCommonSubsequence"
@@ -46,36 +47,57 @@ fn test_lcs_basic() {
 fn test_lcs_evaluate_valid_subsequence() {
     let problem = issue_yes_instance();
     // [0, 1, 0] is a common subsequence of length 3, padded to max_length=6
-    assert_eq!(problem.evaluate(&[0, 1, 0, 2, 2, 2]), Max(Some(3)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![Some(0), Some(1), Some(0), None, None, None])
+            .unwrap(),
+        Max(Some(3))
+    );
 }
 
 #[test]
 fn test_lcs_evaluate_invalid_subsequence() {
     let problem = issue_yes_instance();
     // [1, 1, 0] is NOT a common subsequence
-    assert_eq!(problem.evaluate(&[1, 1, 0, 2, 2, 2]), Max(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![Some(1), Some(1), Some(0), None, None, None])
+            .unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
 fn test_lcs_evaluate_no_common() {
     let problem = issue_no_instance();
     // No symbol is common to both strings
-    assert_eq!(problem.evaluate(&[0, 2, 2]), Max(None));
-    assert_eq!(problem.evaluate(&[1, 2, 2]), Max(None));
+    assert_eq!(
+        problem.evaluate(&vec![Some(0), None, None]).unwrap(),
+        Max(None)
+    );
+    assert_eq!(
+        problem.evaluate(&vec![Some(1), None, None]).unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
 fn test_lcs_evaluate_empty_subsequence() {
     let problem = issue_yes_instance();
     // All padding = empty subsequence = length 0
-    assert_eq!(problem.evaluate(&[2, 2, 2, 2, 2, 2]), Max(Some(0)));
+    assert_eq!(problem.evaluate(&vec![None; 6]).unwrap(), Max(Some(0)));
 }
 
 #[test]
 fn test_lcs_evaluate_interleaved_padding() {
     let problem = issue_yes_instance();
     // Padding interleaved with symbols → invalid
-    assert_eq!(problem.evaluate(&[0, 2, 1, 2, 2, 2]), Max(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![Some(0), None, Some(1), None, None, None])
+            .unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
@@ -87,8 +109,14 @@ fn test_lcs_out_of_range_symbol() {
     // that is neither valid nor padding: but the config space is [0..3), so max valid index is 2.
     // The evaluate function should reject symbols >= alphabet_size that aren't padding.
     // Actually let me just test wrong length:
-    assert_eq!(problem.evaluate(&[0, 1]), Max(None));
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![Some(0), Some(1)]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![Some(0), Some(1), Some(0), Some(1)]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -97,8 +125,8 @@ fn test_lcs_bruteforce_finds_optimum() {
     let problem = LongestCommonSubsequence::new(2, vec![vec![0, 1, 0], vec![1, 0, 1]]);
     // max_length = 3, optimal LCS = [0, 1] or [1, 0], length 2
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).expect("expected a witness");
-    let value = problem.evaluate(&solution);
+    let solution = solver.solve(&problem).unwrap().expect("expected a witness");
+    let value = problem.evaluate(&solution).unwrap();
     assert_eq!(value, Max(Some(2)));
 }
 
@@ -108,7 +136,8 @@ fn test_lcs_bruteforce_no_common_subsequence() {
     let solver = BruteForce::new();
     // The brute force should find the all-padding config (length 0) as the optimal.
     // Max(Some(0)) is the best possible when no positive-length common subsequence exists.
-    let result = crate::solvers::Solver::solve(&solver, &problem);
+    let result_solution = solver.solve(&problem).unwrap().unwrap();
+    let result = problem.evaluate(&result_solution).unwrap();
     assert_eq!(result, Max(Some(0)));
 }
 
@@ -127,16 +156,16 @@ fn test_lcs_empty_string_max_length_zero() {
     // When all strings are empty or any string is empty, max_length = 0
     let problem = LongestCommonSubsequence::new(2, vec![vec![], vec![0, 1]]);
     assert_eq!(problem.max_length(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new()); // empty config space
-                                                     // Empty config is the only valid config; LCS length is 0
-    assert_eq!(problem.evaluate(&[]), Max(Some(0)));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new()); // empty config space
+                                                           // Empty config is the only valid config; LCS length is 0
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Max(Some(0)));
 }
 
 #[test]
 fn test_lcs_all_empty_strings() {
     let problem = LongestCommonSubsequence::new(2, vec![vec![], vec![]]);
     assert_eq!(problem.max_length(), 0);
-    assert_eq!(problem.evaluate(&[]), Max(Some(0)));
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -157,5 +186,37 @@ fn test_lcs_full_length_witness() {
     let problem = LongestCommonSubsequence::new(2, vec![vec![0, 1], vec![0, 1, 0]]);
     // max_length = 2, optimal LCS = [0, 1], length 2
     assert_eq!(problem.max_length(), 2);
-    assert_eq!(problem.evaluate(&[0, 1]), Max(Some(2)));
+    assert_eq!(
+        problem.evaluate(&vec![Some(0), Some(1)]).unwrap(),
+        Max(Some(2))
+    );
+}
+
+#[test]
+fn test_lcs_create_spec_derives_internal_fields() {
+    let problem = LongestCommonSubsequence::try_from(LongestCommonSubsequenceCreateSpec {
+        alphabet_size: None,
+        strings: vec![vec![0, 2], vec![2, 1, 0]],
+    })
+    .unwrap();
+
+    assert_eq!(problem.alphabet_size(), 3);
+    assert_eq!(problem.max_length(), 2);
+    assert_eq!(
+        LongestCommonSubsequenceCreateSpec::FIELDS
+            .iter()
+            .map(|field| field.name)
+            .collect::<Vec<_>>(),
+        ["alphabet_size", "strings"]
+    );
+}
+
+#[test]
+fn test_lcs_create_spec_rejects_all_empty_strings() {
+    let result = LongestCommonSubsequence::try_from(LongestCommonSubsequenceCreateSpec {
+        alphabet_size: Some(2),
+        strings: vec![vec![], vec![]],
+    });
+
+    assert!(result.is_err());
 }
diff --git a/src/unit_tests/models/misc/maximum_likelihood_ranking.rs b/src/unit_tests/models/misc/maximum_likelihood_ranking.rs
index 1868bb4e8..8d06afd26 100644
--- a/src/unit_tests/models/misc/maximum_likelihood_ranking.rs
+++ b/src/unit_tests/models/misc/maximum_likelihood_ranking.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -14,7 +15,7 @@ fn test_maximum_likelihood_ranking_creation() {
     assert_eq!(problem.num_items(), 4);
     assert_eq!(problem.matrix(), &matrix);
     assert_eq!(problem.comparison_count(), 5);
-    assert_eq!(problem.dims(), vec![4; 4]);
+    assert_eq!(problem.dimensions(), vec![4; 4]);
     assert_eq!(
         <MaximumLikelihoodRanking as Problem>::NAME,
         "MaximumLikelihoodRanking"
@@ -40,7 +41,7 @@ fn test_maximum_likelihood_ranking_evaluate_optimal() {
     // (3,1): matrix[3][1] = 2
     // (3,2): matrix[3][2] = 1
     // Total = 1 + 2 + 1 + 0 + 2 + 1 = 7
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3]), Min(Some(7)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap(), Min(Some(7)));
 }
 
 #[test]
@@ -53,12 +54,21 @@ fn test_maximum_likelihood_ranking_evaluate_non_permutation() {
     ];
     let problem = MaximumLikelihoodRanking::new(matrix);
     // Duplicate rank
-    assert_eq!(problem.evaluate(&[0, 0, 2, 3]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 0, 2, 3]).unwrap(), Min(None));
     // Rank out of range
-    assert_eq!(problem.evaluate(&[0, 1, 2, 4]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -80,7 +90,7 @@ fn test_maximum_likelihood_ranking_evaluate_suboptimal() {
     // (1,3): config[1]=2 > config[3]=0 -> matrix[1][3] = 3
     // (2,3): config[2]=1 > config[3]=0 -> matrix[2][3] = 4
     // Total = 4 + 3 + 5 + 4 + 3 + 4 = 23
-    assert_eq!(problem.evaluate(&[3, 2, 1, 0]), Min(Some(23)));
+    assert_eq!(problem.evaluate(&vec![3, 2, 1, 0]).unwrap(), Min(Some(23)));
 }
 
 #[test]
@@ -94,9 +104,10 @@ fn test_maximum_likelihood_ranking_solver() {
     let problem = MaximumLikelihoodRanking::new(matrix);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let value = problem.evaluate(&solution);
+    let value = problem.evaluate(&solution).unwrap();
     assert_eq!(value, Min(Some(7)));
 }
 
@@ -122,14 +133,14 @@ fn test_maximum_likelihood_ranking_two_items() {
     let problem = MaximumLikelihoodRanking::new(matrix);
     // config [0,1]: item 0 at pos 0, item 1 at pos 1
     // Only pair where config[a] > config[b]: (1,0) -> matrix[1][0] = 2
-    assert_eq!(problem.evaluate(&[0, 1]), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![0, 1]).unwrap(), Min(Some(2)));
     // config [1,0]: item 0 at pos 1, item 1 at pos 0
     // Only pair where config[a] > config[b]: (0,1) -> matrix[0][1] = 3
-    assert_eq!(problem.evaluate(&[1, 0]), Min(Some(3)));
+    assert_eq!(problem.evaluate(&vec![1, 0]).unwrap(), Min(Some(3)));
     // Optimal is [0,1] with cost 2
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(2)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -137,8 +148,8 @@ fn test_maximum_likelihood_ranking_single_item() {
     let problem = MaximumLikelihoodRanking::new(vec![vec![0]]);
     assert_eq!(problem.num_items(), 1);
     assert_eq!(problem.comparison_count(), 0);
-    assert_eq!(problem.dims(), vec![1]);
-    assert_eq!(problem.evaluate(&[0]), Min(Some(0)));
+    assert_eq!(problem.dimensions(), vec![1]);
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -162,11 +173,11 @@ fn test_maximum_likelihood_ranking_skew_symmetric() {
     assert_eq!(problem.comparison_count(), 0);
     // Ranking [0,1,2]: 1 backward arc (2->0, cost +1), 2 forward arcs (cost -1 each)
     // Total = 1 + (-1) + (-1) = -1 = 2*FAS - |A| = 2*1 - 3
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(Some(-1)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2]).unwrap(), Min(Some(-1)));
     // Optimal FAS = 1, so minimum cost = 2*1 - 3 = -1
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(-1)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(-1)));
 }
 
 #[test]
@@ -182,6 +193,6 @@ fn test_maximum_likelihood_ranking_canonical_example() {
     assert_eq!(specs.len(), 1);
     let spec = &specs[0];
     assert_eq!(spec.id, "maximum_likelihood_ranking");
-    assert_eq!(spec.optimal_config, vec![0, 1, 2, 3]);
+    assert_eq!(spec.optimal_config, serde_json::json!([0, 1, 2, 3]));
     assert_eq!(spec.optimal_value, serde_json::json!(7));
 }
diff --git a/src/unit_tests/models/misc/minimum_axiom_set.rs b/src/unit_tests/models/misc/minimum_axiom_set.rs
index e4e3d08ae..f3f746808 100644
--- a/src/unit_tests/models/misc/minimum_axiom_set.rs
+++ b/src/unit_tests/models/misc/minimum_axiom_set.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 /// Helper: build the canonical 8-sentence example from the issue.
@@ -27,7 +28,7 @@ fn test_minimum_axiom_set_creation() {
     assert_eq!(problem.num_true_sentences(), 8);
     assert_eq!(problem.num_implications(), 8);
     assert_eq!(problem.true_sentences(), &[0, 1, 2, 3, 4, 5, 6, 7]);
-    assert_eq!(problem.dims(), vec![2; 8]);
+    assert_eq!(problem.dimensions(), vec![2; 8]);
     assert_eq!(problem.num_variables(), 8);
 }
 
@@ -35,7 +36,9 @@ fn test_minimum_axiom_set_creation() {
 fn test_minimum_axiom_set_evaluate_optimal() {
     let problem = canonical_instance();
     // Select a and b (indices 0, 1): closure = all 8 sentences
-    let result = problem.evaluate(&[1, 1, 0, 0, 0, 0, 0, 0]);
+    let result = problem
+        .evaluate(&vec![true, true, false, false, false, false, false, false])
+        .unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 2);
 }
@@ -44,7 +47,9 @@ fn test_minimum_axiom_set_evaluate_optimal() {
 fn test_minimum_axiom_set_evaluate_insufficient() {
     let problem = canonical_instance();
     // Select only a (index 0): closure = {a, c, d} — missing b, e, f, g, h
-    let result = problem.evaluate(&[1, 0, 0, 0, 0, 0, 0, 0]);
+    let result = problem
+        .evaluate(&vec![true, false, false, false, false, false, false, false])
+        .unwrap();
     assert!(!result.is_valid());
 }
 
@@ -52,7 +57,9 @@ fn test_minimum_axiom_set_evaluate_insufficient() {
 fn test_minimum_axiom_set_evaluate_all_selected() {
     let problem = canonical_instance();
     // Select all 8 sentences: closure = all 8 trivially
-    let result = problem.evaluate(&[1, 1, 1, 1, 1, 1, 1, 1]);
+    let result = problem
+        .evaluate(&vec![true, true, true, true, true, true, true, true])
+        .unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 8);
 }
@@ -61,22 +68,31 @@ fn test_minimum_axiom_set_evaluate_all_selected() {
 fn test_minimum_axiom_set_evaluate_none_selected() {
     let problem = canonical_instance();
     // Select nothing: closure = empty
-    let result = problem.evaluate(&[0, 0, 0, 0, 0, 0, 0, 0]);
+    let result = problem
+        .evaluate(&vec![
+            false, false, false, false, false, false, false, false,
+        ])
+        .unwrap();
     assert!(!result.is_valid());
 }
 
 #[test]
 fn test_minimum_axiom_set_evaluate_wrong_length() {
     let problem = canonical_instance();
-    let result = problem.evaluate(&[1, 0]);
-    assert!(!result.is_valid());
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimum_axiom_set_evaluate_out_of_range() {
     let problem = canonical_instance();
-    let result = problem.evaluate(&[2, 0, 0, 0, 0, 0, 0, 0]);
-    assert!(!result.is_valid());
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, false, false, false, false, false, false, false])
+    )
+    .is_err());
 }
 
 #[test]
@@ -84,9 +100,10 @@ fn test_minimum_axiom_set_solver() {
     let problem = canonical_instance();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     assert!(metric.is_valid());
     assert_eq!(metric.unwrap(), 2);
 }
@@ -108,15 +125,15 @@ fn test_minimum_axiom_set_partial_true_sentences() {
     let problem = MinimumAxiomSet::new(5, vec![0, 1, 2], vec![(vec![0], 1), (vec![1], 2)]);
     assert_eq!(problem.num_sentences(), 5);
     assert_eq!(problem.num_true_sentences(), 3);
-    assert_eq!(problem.dims(), vec![2; 3]);
+    assert_eq!(problem.dimensions(), vec![2; 3]);
 
     // Select sentence 0 only
-    let result = problem.evaluate(&[1, 0, 0]);
+    let result = problem.evaluate(&vec![true, false, false]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 1);
 
     // Select sentence 2 only — cannot derive 0 or 1
-    let result = problem.evaluate(&[0, 0, 1]);
+    let result = problem.evaluate(&vec![false, false, true]).unwrap();
     assert!(!result.is_valid());
 }
 
@@ -125,12 +142,12 @@ fn test_minimum_axiom_set_no_implications() {
     // 3 sentences, all true, no implications
     // Only way to cover T is to select all of them
     let problem = MinimumAxiomSet::new(3, vec![0, 1, 2], vec![]);
-    let result = problem.evaluate(&[1, 1, 1]);
+    let result = problem.evaluate(&vec![true, true, true]).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 3);
 
     // Selecting only 2 leaves one uncovered
-    let result = problem.evaluate(&[1, 1, 0]);
+    let result = problem.evaluate(&vec![true, true, false]).unwrap();
     assert!(!result.is_valid());
 }
 
@@ -140,16 +157,19 @@ fn test_minimum_axiom_set_paper_example() {
     let problem = canonical_instance();
 
     // Verify the issue's expected outcome: config [1,1,0,0,0,0,0,0] → Min(2)
-    let result = problem.evaluate(&[1, 1, 0, 0, 0, 0, 0, 0]);
+    let result = problem
+        .evaluate(&vec![true, true, false, false, false, false, false, false])
+        .unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 2);
 
     // Confirm with brute force that 2 is optimal
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     assert!(metric.is_valid());
     assert_eq!(metric.unwrap(), 2);
 }
diff --git a/src/unit_tests/models/misc/minimum_code_generation_one_register.rs b/src/unit_tests/models/misc/minimum_code_generation_one_register.rs
index 6210ed720..78337e23a 100644
--- a/src/unit_tests/models/misc/minimum_code_generation_one_register.rs
+++ b/src/unit_tests/models/misc/minimum_code_generation_one_register.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -23,7 +24,7 @@ fn test_minimum_code_generation_one_register_creation() {
     assert_eq!(problem.num_edges(), 8);
     assert_eq!(problem.num_leaves(), 3);
     assert_eq!(problem.num_internal(), 4);
-    assert_eq!(problem.dims(), vec![4; 4]);
+    assert_eq!(problem.dimensions(), vec![4; 4]);
     assert_eq!(
         <MinimumCodeGenerationOneRegister as Problem>::NAME,
         "MinimumCodeGenerationOneRegister"
@@ -55,8 +56,8 @@ fn test_minimum_code_generation_one_register_evaluate_optimal() {
         3,
     );
     let config = vec![3, 2, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(8)));
-    assert_eq!(problem.simulate(&config), Some(8));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(8)));
+    assert_eq!(problem.simulate(&config).unwrap(), Some(8));
 }
 
 #[test]
@@ -81,7 +82,7 @@ fn test_minimum_code_generation_one_register_evaluate_suboptimal() {
     // Order: v3 (pos 0), v1 (pos 1), v2 (pos 2), v0 (pos 3)
     // config: v0->3, v1->1, v2->2, v3->0
     let config = vec![3, 1, 2, 0];
-    assert_eq!(problem.simulate(&config), Some(8));
+    assert_eq!(problem.simulate(&config).unwrap(), Some(8));
 }
 
 #[test]
@@ -103,7 +104,7 @@ fn test_minimum_code_generation_one_register_invalid_dependency() {
     );
     // v0 first (pos 0) — depends on v1,v2 which haven't been computed
     let config = vec![0, 1, 2, 3];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -123,11 +124,17 @@ fn test_minimum_code_generation_one_register_invalid_permutation() {
         3,
     );
     // Not a permutation: position 0 used twice
-    assert_eq!(problem.evaluate(&[0, 0, 1, 2]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 0, 1, 2]).unwrap(), Min(None));
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Position out of range
-    assert_eq!(problem.evaluate(&[0, 1, 2, 5]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -141,7 +148,8 @@ fn test_minimum_code_generation_one_register_solver() {
     // Leaves: v2 and v3 have out-degree 0. So num_leaves=2.
     let problem = MinimumCodeGenerationOneRegister::new(4, vec![(0, 1), (0, 2), (1, 2), (1, 3)], 2);
     let solver = BruteForce::new();
-    let result = solver.solve(&problem);
+    let result_solution = solver.solve(&problem).unwrap().unwrap();
+    let result = problem.evaluate(&result_solution).unwrap();
     // Only valid order: v1 first, then v0
     // v1: LOAD v2, OP v1 (using v3 from memory) = 2 instructions (or LOAD v3, OP v1 using v2)
     // v0: OP v0 (using v1 from register, v2 from memory) = 1 instruction
@@ -153,8 +161,11 @@ fn test_minimum_code_generation_one_register_solver() {
 fn test_minimum_code_generation_one_register_solver_witness() {
     let problem = MinimumCodeGenerationOneRegister::new(4, vec![(0, 1), (0, 2), (1, 2), (1, 3)], 2);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find witness");
-    assert_eq!(problem.simulate(&witness), Some(3));
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find witness");
+    assert_eq!(problem.simulate(&witness).unwrap(), Some(3));
 }
 
 #[test]
@@ -191,8 +202,8 @@ fn test_minimum_code_generation_one_register_unary_ops() {
     // v1: LOAD v2, OP v1 = 2
     // v0: OP v0 (v1 in register) = 1
     // Total = 3
-    assert_eq!(problem.simulate(&config), Some(3));
-    assert_eq!(problem.evaluate(&config), Min(Some(3)));
+    assert_eq!(problem.simulate(&config).unwrap(), Some(3));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(3)));
 }
 
 #[test]
@@ -215,16 +226,17 @@ fn test_minimum_code_generation_one_register_paper_example() {
 
     // Optimal order: v3, v2, v1, v0 => config = [3, 2, 1, 0]
     let config = vec![3, 2, 1, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(8)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(8)));
 
     // Verify with brute force
     let solver = BruteForce::new();
-    let result = solver.solve(&problem);
+    let result_solution = solver.solve(&problem).unwrap().unwrap();
+    let result = problem.evaluate(&result_solution).unwrap();
     assert_eq!(result, Min(Some(8)));
 
     // Verify witness
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.simulate(&witness), Some(8));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.simulate(&witness).unwrap(), Some(8));
 }
 
 #[test]
@@ -245,6 +257,6 @@ fn test_minimum_code_generation_one_register_lost_value() {
     // When v2 is computed, we should check if v1 needs to be stored.
     // future_uses[1] = 1 (used by v0), so STORE v1 before computing v2.
     // So this should NOT be None — the simulation stores v1 automatically.
-    let result = problem.simulate(&config);
+    let result = problem.simulate(&config).unwrap();
     assert!(result.is_some());
 }
diff --git a/src/unit_tests/models/misc/minimum_code_generation_parallel_assignments.rs b/src/unit_tests/models/misc/minimum_code_generation_parallel_assignments.rs
index 61a335fd9..541ed2e59 100644
--- a/src/unit_tests/models/misc/minimum_code_generation_parallel_assignments.rs
+++ b/src/unit_tests/models/misc/minimum_code_generation_parallel_assignments.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -9,7 +10,7 @@ fn test_minimum_code_generation_parallel_assignments_creation() {
     assert_eq!(problem.num_variables(), 4);
     assert_eq!(problem.num_assignments(), 4);
     assert_eq!(problem.assignments(), &assignments);
-    assert_eq!(problem.dims(), vec![4; 4]);
+    assert_eq!(problem.dimensions(), vec![4; 4]);
     assert_eq!(
         <MinimumCodeGenerationParallelAssignments as Problem>::NAME,
         "MinimumCodeGenerationParallelAssignments"
@@ -30,7 +31,7 @@ fn test_minimum_code_generation_parallel_assignments_evaluate_optimal() {
     // A_2 writes c(2): A_3 reads c and is later (pos 2) -> 1 backward dep
     // A_3 writes d(3): A_1 does not read d -> 0
     // Total: 2
-    assert_eq!(problem.evaluate(&[0, 3, 1, 2]), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![0, 3, 1, 2]).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -43,7 +44,7 @@ fn test_minimum_code_generation_parallel_assignments_evaluate_suboptimal() {
     // A_0 writes a(0): A_1 already executed -> 0
     // A_2 writes c(2): A_3 reads c (later, pos 3) -> 1
     // Total: 3
-    assert_eq!(problem.evaluate(&[1, 0, 2, 3]), Min(Some(3)));
+    assert_eq!(problem.evaluate(&vec![1, 0, 2, 3]).unwrap(), Min(Some(3)));
 }
 
 #[test]
@@ -51,12 +52,21 @@ fn test_minimum_code_generation_parallel_assignments_evaluate_invalid() {
     let assignments = vec![(0, vec![1, 2]), (1, vec![0]), (2, vec![3]), (3, vec![1, 2])];
     let problem = MinimumCodeGenerationParallelAssignments::new(4, assignments);
     // Duplicate position
-    assert_eq!(problem.evaluate(&[0, 0, 1, 2]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 0, 1, 2]).unwrap(), Min(None));
     // Out of range
-    assert_eq!(problem.evaluate(&[0, 1, 2, 4]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -65,9 +75,10 @@ fn test_minimum_code_generation_parallel_assignments_solver() {
     let problem = MinimumCodeGenerationParallelAssignments::new(4, assignments);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let value = problem.evaluate(&solution);
+    let value = problem.evaluate(&solution).unwrap();
     assert_eq!(value, Min(Some(2)));
 }
 
@@ -90,11 +101,11 @@ fn test_minimum_code_generation_parallel_assignments_no_dependencies() {
     ];
     let problem = MinimumCodeGenerationParallelAssignments::new(4, assignments);
     // Neither assignment reads the target of the other
-    assert_eq!(problem.evaluate(&[0, 1]), Min(Some(0)));
-    assert_eq!(problem.evaluate(&[1, 0]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![0, 1]).unwrap(), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![1, 0]).unwrap(), Min(Some(0)));
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(0)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -116,6 +127,6 @@ fn test_minimum_code_generation_parallel_assignments_canonical_example() {
     assert_eq!(specs.len(), 1);
     let spec = &specs[0];
     assert_eq!(spec.id, "minimum_code_generation_parallel_assignments");
-    assert_eq!(spec.optimal_config, vec![0, 3, 1, 2]);
+    assert_eq!(spec.optimal_config, serde_json::json!([0, 3, 1, 2]));
     assert_eq!(spec.optimal_value, serde_json::json!(2));
 }
diff --git a/src/unit_tests/models/misc/minimum_code_generation_unlimited_registers.rs b/src/unit_tests/models/misc/minimum_code_generation_unlimited_registers.rs
index 281ab91b5..c852009b8 100644
--- a/src/unit_tests/models/misc/minimum_code_generation_unlimited_registers.rs
+++ b/src/unit_tests/models/misc/minimum_code_generation_unlimited_registers.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -15,7 +16,7 @@ fn test_minimum_code_generation_unlimited_registers_creation() {
     assert_eq!(problem.num_internal(), 3);
     assert_eq!(problem.left_arcs(), &[(1, 3), (2, 3), (0, 1)]);
     assert_eq!(problem.right_arcs(), &[(1, 4), (2, 4), (0, 2)]);
-    assert_eq!(problem.dims(), vec![3; 3]);
+    assert_eq!(problem.dimensions(), vec![3; 3]);
     assert_eq!(
         <MinimumCodeGenerationUnlimitedRegisters as Problem>::NAME,
         "MinimumCodeGenerationUnlimitedRegisters"
@@ -38,8 +39,8 @@ fn test_minimum_code_generation_unlimited_registers_evaluate_optimal() {
         vec![(1, 4), (2, 4), (0, 2)],
     );
     let config = vec![2, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(4)));
-    assert_eq!(problem.simulate(&config), Some(4));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(4)));
+    assert_eq!(problem.simulate(&config).unwrap(), Some(4));
 }
 
 #[test]
@@ -77,7 +78,7 @@ fn test_minimum_code_generation_unlimited_registers_evaluate_suboptimal() {
     //   Not needed -> no LOAD. instructions = 3 (+ 1 OP).
     // Step 2: OP v0, left=v1. future uses of v1: 0. No LOAD. instructions = 4 (+ 1 OP).
     // Total: 4 (same as optimal for this instance)
-    assert_eq!(problem.simulate(&config), Some(4));
+    assert_eq!(problem.simulate(&config).unwrap(), Some(4));
 }
 
 #[test]
@@ -90,7 +91,7 @@ fn test_minimum_code_generation_unlimited_registers_dependency_violation() {
     );
     // v0 first (pos 0) — depends on v1,v2 which haven't been computed
     let config = vec![0, 1, 2];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -101,11 +102,17 @@ fn test_minimum_code_generation_unlimited_registers_invalid_permutation() {
         vec![(1, 4), (2, 4), (0, 2)],
     );
     // Not a permutation: position 0 used twice
-    assert_eq!(problem.evaluate(&[0, 0, 1]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 0, 1]).unwrap(), Min(None));
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 1]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Position out of range
-    assert_eq!(problem.evaluate(&[0, 1, 5]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -117,7 +124,8 @@ fn test_minimum_code_generation_unlimited_registers_solver() {
         vec![(1, 4), (2, 4), (0, 2)],
     );
     let solver = BruteForce::new();
-    let result = solver.solve(&problem);
+    let result_solution = solver.solve(&problem).unwrap().unwrap();
+    let result = problem.evaluate(&result_solution).unwrap();
     assert_eq!(result, Min(Some(4)));
 }
 
@@ -129,8 +137,11 @@ fn test_minimum_code_generation_unlimited_registers_solver_witness() {
         vec![(1, 4), (2, 4), (0, 2)],
     );
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find witness");
-    assert_eq!(problem.simulate(&witness), Some(4));
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find witness");
+    assert_eq!(problem.simulate(&witness).unwrap(), Some(4));
 }
 
 #[test]
@@ -159,8 +170,8 @@ fn test_minimum_code_generation_unlimited_registers_unary_ops() {
     // v1: left=v2, no future uses of v2 -> no LOAD. OP v1 = 1.
     // v0: left=v1, no future uses of v1 -> no LOAD. OP v0 = 1.
     // Total = 2 (just 2 OPs, no copies needed)
-    assert_eq!(problem.simulate(&config), Some(2));
-    assert_eq!(problem.evaluate(&config), Min(Some(2)));
+    assert_eq!(problem.simulate(&config).unwrap(), Some(2));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -171,7 +182,7 @@ fn test_minimum_code_generation_unlimited_registers_no_copy_needed() {
     // Only one internal vertex v0, config = [0]
     let config = vec![0];
     // OP v0: left=v1, right=v2. No future uses of v1. No LOAD. 1 OP.
-    assert_eq!(problem.simulate(&config), Some(1));
+    assert_eq!(problem.simulate(&config).unwrap(), Some(1));
 }
 
 #[test]
@@ -185,14 +196,15 @@ fn test_minimum_code_generation_unlimited_registers_paper_example() {
 
     // Optimal order: v1, v2, v0 => config = [2, 0, 1]
     let config = vec![2, 0, 1];
-    assert_eq!(problem.evaluate(&config), Min(Some(4)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(4)));
 
     // Verify with brute force
     let solver = BruteForce::new();
-    let result = solver.solve(&problem);
+    let result_solution = solver.solve(&problem).unwrap().unwrap();
+    let result = problem.evaluate(&result_solution).unwrap();
     assert_eq!(result, Min(Some(4)));
 
     // Verify witness
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.simulate(&witness), Some(4));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.simulate(&witness).unwrap(), Some(4));
 }
diff --git a/src/unit_tests/models/misc/minimum_decision_tree.rs b/src/unit_tests/models/misc/minimum_decision_tree.rs
index 6332ff56c..561066d05 100644
--- a/src/unit_tests/models/misc/minimum_decision_tree.rs
+++ b/src/unit_tests/models/misc/minimum_decision_tree.rs
@@ -1,5 +1,18 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_indistinguishable_objects() {
+    assert!(
+        MinimumDecisionTree::try_from(MinimumDecisionTreeCreateSpec {
+            test_matrix: vec![vec![false, false]],
+            num_objects: 2,
+            num_tests: 1
+        })
+        .is_err()
+    );
+}
+use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -20,8 +33,8 @@ fn test_minimum_decision_tree_creation() {
     let problem = issue_instance();
     assert_eq!(problem.num_objects(), 4);
     assert_eq!(problem.num_tests(), 3);
-    assert_eq!(problem.dims().len(), 7); // 2^(4-1) - 1 = 7
-    assert_eq!(problem.dims(), vec![4; 7]); // 3 tests + 1 sentinel = 4 choices
+    assert_eq!(problem.dimensions().len(), 7); // 2^(4-1) - 1 = 7
+    assert_eq!(problem.dimensions(), vec![4; 7]); // 3 tests + 1 sentinel = 4 choices
 }
 
 #[test]
@@ -29,7 +42,7 @@ fn test_minimum_decision_tree_evaluate_optimal() {
     let problem = issue_instance();
     // Balanced tree: T0 at root, T2 left, T1 right, rest leaves
     let config = vec![0, 2, 1, 3, 3, 3, 3];
-    assert_eq!(problem.evaluate(&config), Min(Some(8)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(8)));
 }
 
 #[test]
@@ -40,7 +53,7 @@ fn test_minimum_decision_tree_evaluate_suboptimal() {
     // T0 at node 1: o1 goes right (T0=1→leaf at depth 2), o2,o3 go left (T0=0)
     // T2 at node 3: o2 goes left (T2=0→leaf at depth 3), o3 goes right (T2=1→leaf at depth 3)
     let config = vec![1, 0, 3, 2, 3, 3, 3];
-    assert_eq!(problem.evaluate(&config), Min(Some(9)));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(9)));
 }
 
 #[test]
@@ -49,20 +62,24 @@ fn test_minimum_decision_tree_evaluate_invalid_duplicate_leaf() {
     // All leaves immediately — no tests applied, all objects reach same leaf
     let config = vec![3, 3, 3, 3, 3, 3, 3];
     // Root is a leaf, all objects land at root — duplicates
-    assert_eq!(problem.evaluate(&config), Min(None));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_decision_tree_evaluate_wrong_length() {
     let problem = issue_instance();
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimum_decision_tree_solver() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(8)));
 }
 
@@ -70,9 +87,9 @@ fn test_minimum_decision_tree_solver() {
 fn test_minimum_decision_tree_witness() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
-    assert_eq!(problem.evaluate(&witness.unwrap()), Min(Some(8)));
+    assert_eq!(problem.evaluate(&witness.unwrap()).unwrap(), Min(Some(8)));
 }
 
 #[test]
@@ -83,7 +100,7 @@ fn test_minimum_decision_tree_serialization() {
     assert_eq!(restored.num_objects(), 4);
     assert_eq!(restored.num_tests(), 3);
     let config = vec![0, 2, 1, 3, 3, 3, 3];
-    assert_eq!(restored.evaluate(&config), Min(Some(8)));
+    assert_eq!(restored.evaluate(&config).unwrap(), Min(Some(8)));
 }
 
 #[test]
@@ -94,10 +111,10 @@ fn test_minimum_decision_tree_two_objects() {
         2,
         1,
     );
-    assert_eq!(problem.dims().len(), 1); // 2^(2-1) - 1 = 1 slot
-                                         // Test at root, both objects go to leaves at depth 1
-    assert_eq!(problem.evaluate(&[0]), Min(Some(2))); // depth 1 + depth 1
-    assert_eq!(problem.evaluate(&[1]), Min(None)); // sentinel=1 is leaf at root, both objects at same leaf
+    assert_eq!(problem.dimensions().len(), 1); // 2^(2-1) - 1 = 1 slot
+                                               // Test at root, both objects go to leaves at depth 1
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Min(Some(2))); // depth 1 + depth 1
+    assert_eq!(problem.evaluate(&vec![1]).unwrap(), Min(None)); // sentinel=1 is leaf at root, both objects at same leaf
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/minimum_discrete_planar_inverse_kinematics.rs b/src/unit_tests/models/misc/minimum_discrete_planar_inverse_kinematics.rs
index adea1eec0..6c82a88b4 100644
--- a/src/unit_tests/models/misc/minimum_discrete_planar_inverse_kinematics.rs
+++ b/src/unit_tests/models/misc/minimum_discrete_planar_inverse_kinematics.rs
@@ -1,5 +1,6 @@
 use super::MinimumDiscretePlanarInverseKinematics;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 use std::f64::consts::FRAC_PI_2;
@@ -13,6 +14,7 @@ fn sample_problem() -> MinimumDiscretePlanarInverseKinematics {
         vec![vec![0.0, FRAC_PI_2], vec![0.0, FRAC_PI_2]],
         vec![vec![(0, 0), (0, 1), (1, 1)]],
     )
+    .unwrap()
 }
 
 #[test]
@@ -23,7 +25,7 @@ fn test_minimum_discrete_planar_inverse_kinematics_creation() {
     assert_eq!(problem.target_point(), (2.0, 1.0));
     assert_eq!(problem.orientation_samples().len(), 2);
     assert_eq!(problem.allowed_pairs().len(), 1);
-    assert_eq!(problem.dims(), vec![2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2]);
     assert_eq!(problem.num_variables(), 2);
     assert_eq!(problem.num_orientation_samples(), 4);
 }
@@ -33,16 +35,16 @@ fn test_minimum_discrete_planar_inverse_kinematics_evaluate_feasible() {
     let problem = sample_problem();
 
     // [0, 1] -> end-effector (2, 1), distance^2 = 0.
-    let value = problem.evaluate(&[0, 1]);
+    let value = problem.evaluate(&vec![0, 1]).unwrap();
     assert!(matches!(value, Min(Some(v)) if v.abs() < EPS));
     assert!(problem.is_valid_solution(&[0, 1]));
 
     // [0, 0] -> end-effector (3, 0), distance^2 = (3-2)^2 + (0-1)^2 = 2.
-    let value = problem.evaluate(&[0, 0]);
+    let value = problem.evaluate(&vec![0, 0]).unwrap();
     assert!(matches!(value, Min(Some(v)) if (v - 2.0).abs() < EPS));
 
     // [1, 1] -> end-effector (0, 3), distance^2 = (0-2)^2 + (3-1)^2 = 8.
-    let value = problem.evaluate(&[1, 1]);
+    let value = problem.evaluate(&vec![1, 1]).unwrap();
     assert!(matches!(value, Min(Some(v)) if (v - 8.0).abs() < EPS));
 }
 
@@ -51,32 +53,43 @@ fn test_minimum_discrete_planar_inverse_kinematics_evaluate_infeasible() {
     let problem = sample_problem();
 
     // [1, 0] is not in allowed_pairs[0] = {(0,0),(0,1),(1,1)} -> infeasible.
-    assert_eq!(problem.evaluate(&[1, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![1, 0]).unwrap(), Min(None));
     assert!(!problem.is_valid_solution(&[1, 0]));
-    assert_eq!(problem.squared_distance(&[1, 0]), None);
-    assert_eq!(problem.end_effector(&[1, 0]), None);
+    assert_eq!(problem.squared_distance(&[1, 0]).unwrap(), None);
+    assert_eq!(problem.end_effector(&[1, 0]).unwrap(), None);
 
     // Wrong length: too short.
-    assert_eq!(problem.evaluate(&[0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     assert!(!problem.is_valid_solution(&[0]));
 
     // Wrong length: too long.
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 
     // Index out of range for a per-link domain.
-    assert_eq!(problem.evaluate(&[0, 2]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimum_discrete_planar_inverse_kinematics_solver_finds_optimum() {
     let problem = sample_problem();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
+    let witness = solver.solve(&problem).unwrap().unwrap();
     assert!(problem.is_valid_solution(&witness));
-    let optimum = problem.squared_distance(&witness).unwrap();
+    let optimum = problem.squared_distance(&witness).unwrap().unwrap();
     assert!(optimum.abs() < EPS, "expected optimum 0, got {optimum}");
 
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+
+    let value = problem.evaluate(&value_solution).unwrap();
     assert!(matches!(value, Min(Some(v)) if v.abs() < EPS));
 }
 
@@ -84,9 +97,9 @@ fn test_minimum_discrete_planar_inverse_kinematics_solver_finds_optimum() {
 fn test_minimum_discrete_planar_inverse_kinematics_paper_example() {
     let problem = sample_problem();
     let config = vec![0, 1];
-    let value = problem.evaluate(&config);
+    let value = problem.evaluate(&config).unwrap();
     assert!(matches!(value, Min(Some(v)) if v.abs() < EPS));
-    let (x, y) = problem.end_effector(&config).unwrap();
+    let (x, y) = problem.end_effector(&config).unwrap().unwrap();
     assert!((x - 2.0).abs() < EPS);
     assert!((y - 1.0).abs() < EPS);
 }
@@ -103,7 +116,7 @@ fn test_minimum_discrete_planar_inverse_kinematics_serialization() {
         problem.orientation_samples()
     );
     assert_eq!(restored.allowed_pairs(), problem.allowed_pairs());
-    assert_eq!(restored.dims(), problem.dims());
+    assert_eq!(restored.dimensions(), problem.dimensions());
 }
 
 #[test]
@@ -113,3 +126,43 @@ fn test_minimum_discrete_planar_inverse_kinematics_problem_name() {
         "MinimumDiscretePlanarInverseKinematics"
     );
 }
+
+#[test]
+fn test_minimum_discrete_planar_inverse_kinematics_rejects_invalid_numeric_data() {
+    assert!(MinimumDiscretePlanarInverseKinematics::new(
+        vec![f64::NAN],
+        (0.0, 0.0),
+        vec![vec![0.0]],
+        vec![],
+    )
+    .is_err());
+    assert!(MinimumDiscretePlanarInverseKinematics::new(
+        vec![1.0],
+        (f64::INFINITY, 0.0),
+        vec![vec![0.0]],
+        vec![],
+    )
+    .is_err());
+    assert!(MinimumDiscretePlanarInverseKinematics::new(
+        vec![1.0],
+        (0.0, 0.0),
+        vec![vec![f64::NEG_INFINITY]],
+        vec![],
+    )
+    .is_err());
+}
+
+#[test]
+fn test_minimum_discrete_planar_inverse_kinematics_reports_non_finite_evaluation() {
+    let problem = MinimumDiscretePlanarInverseKinematics::new(
+        vec![f64::MAX, f64::MAX],
+        (0.0, 0.0),
+        vec![vec![0.0], vec![0.0]],
+        vec![vec![(0, 0)]],
+    )
+    .unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0]),
+        Err(crate::traits::EvaluationError::NonFiniteResult(_))
+    ));
+}
diff --git a/src/unit_tests/models/misc/minimum_disjunctive_normal_form.rs b/src/unit_tests/models/misc/minimum_disjunctive_normal_form.rs
index 39ba6a667..75c7388ee 100644
--- a/src/unit_tests/models/misc/minimum_disjunctive_normal_form.rs
+++ b/src/unit_tests/models/misc/minimum_disjunctive_normal_form.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -14,7 +15,7 @@ fn test_minimum_dnf_creation() {
     assert_eq!(problem.num_variables(), 3);
     assert_eq!(problem.minterms().len(), 6);
     assert_eq!(problem.num_prime_implicants(), 6);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
 }
 
 #[test]
@@ -38,30 +39,31 @@ fn test_minimum_dnf_prime_implicants() {
 fn test_minimum_dnf_evaluate_all_selected() {
     let problem = issue_instance();
     // Select all prime implicants — valid but not minimal
-    let config = vec![1; 6];
-    assert_eq!(problem.evaluate(&config), Min(Some(6)));
+    let config = vec![true; 6];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(6)));
 }
 
 #[test]
 fn test_minimum_dnf_evaluate_none_selected() {
     let problem = issue_instance();
-    let config = vec![0; 6];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![false; 6];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_dnf_evaluate_insufficient() {
     let problem = issue_instance();
     // Select only the first prime implicant — covers at most 2 minterms, not all 6
-    let config = vec![1, 0, 0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = vec![true, false, false, false, false, false];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_dnf_solver() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(3)));
 }
 
@@ -69,11 +71,11 @@ fn test_minimum_dnf_solver() {
 fn test_minimum_dnf_all_witnesses() {
     let problem = issue_instance();
     let solver = BruteForce::new();
-    let witnesses = solver.find_all_witnesses(&problem);
+    let witnesses = solver.find_all_witnesses(&problem).unwrap();
     // Should be exactly 2 optimal covers of size 3
     assert_eq!(witnesses.len(), 2);
     for w in &witnesses {
-        assert_eq!(problem.evaluate(w), Min(Some(3)));
+        assert_eq!(problem.evaluate(w).unwrap(), Min(Some(3)));
     }
 }
 
@@ -95,7 +97,8 @@ fn test_minimum_dnf_two_variables() {
     assert_eq!(problem.num_prime_implicants(), 2);
 
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(2))); // Both PIs needed
 }
 
@@ -106,7 +109,12 @@ fn test_minimum_dnf_single_minterm() {
     assert_eq!(problem.minterms(), &[3]);
     assert_eq!(problem.num_prime_implicants(), 1); // x1∧x2
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Min(Some(1)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(1))
+    );
 }
 
 #[test]
@@ -114,13 +122,21 @@ fn test_minimum_dnf_tautology_minus_one() {
     // f = all true except 000 and 111 (same as issue example)
     let problem = issue_instance();
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Min(Some(3)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(3))
+    );
 }
 
 #[test]
 fn test_minimum_dnf_wrong_config_length() {
     let problem = issue_instance();
-    assert_eq!(problem.evaluate(&[1, 0, 1]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/minimum_external_macro_data_compression.rs b/src/unit_tests/models/misc/minimum_external_macro_data_compression.rs
index 62be7562a..13b50275b 100644
--- a/src/unit_tests/models/misc/minimum_external_macro_data_compression.rs
+++ b/src/unit_tests/models/misc/minimum_external_macro_data_compression.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -19,7 +20,7 @@ fn test_minimum_external_macro_data_compression_creation() {
         vec![]
     );
     // dims: 6 D-slots (domain 4) + 6 C-slots (domain 4 + 6*7/2 = 25)
-    let dims = problem.dims();
+    let dims = problem.dimensions();
     assert_eq!(dims.len(), 12);
     assert_eq!(dims[0], 4); // alphabet_size + 1
     assert_eq!(dims[6], 25); // alphabet_size + 1 + 6*7/2
@@ -33,7 +34,7 @@ fn test_minimum_external_macro_data_compression_evaluate_uncompressed() {
     // D-slots: [2, 2] (both empty)
     // C-slots: [0, 1] (literal a, literal b)
     // Cost = 0 + 2 + 0 = 2
-    assert_eq!(problem.evaluate(&[2, 2, 0, 1]), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![2, 2, 0, 1]).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -48,7 +49,10 @@ fn test_minimum_external_macro_data_compression_evaluate_with_pointer() {
     // C-slots: [4, 4, 2, 2] (two pointers, two empty)
     // This decodes: D[0..2] = "ab", D[0..2] = "ab" => "abab" = s. Valid!
     // Cost = 2 + 2 + (2-1)*2 = 6
-    assert_eq!(problem.evaluate(&[0, 1, 2, 2, 4, 4, 2, 2]), Min(Some(6)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 1, 2, 2, 4, 4, 2, 2]).unwrap(),
+        Min(Some(6))
+    );
 }
 
 #[test]
@@ -56,14 +60,20 @@ fn test_minimum_external_macro_data_compression_evaluate_invalid_decode() {
     // alphabet {a, b}, s = "ab", h = 2
     let problem = MinimumExternalMacroDataCompression::new(2, vec![0, 1], 2);
     // C = "ba" doesn't match s = "ab"
-    assert_eq!(problem.evaluate(&[2, 2, 1, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![2, 2, 1, 0]).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_external_macro_data_compression_evaluate_wrong_length() {
     let problem = MinimumExternalMacroDataCompression::new(2, vec![0, 1], 2);
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -71,7 +81,7 @@ fn test_minimum_external_macro_data_compression_evaluate_interleaved_empty() {
     // D-slots have interleaved empty
     let problem = MinimumExternalMacroDataCompression::new(2, vec![0, 1], 2);
     // D-slots: [2, 0] (empty then non-empty -> invalid)
-    assert_eq!(problem.evaluate(&[2, 0, 0, 1]), Min(None));
+    assert_eq!(problem.evaluate(&vec![2, 0, 0, 1]).unwrap(), Min(None));
 }
 
 #[test]
@@ -80,14 +90,14 @@ fn test_minimum_external_macro_data_compression_evaluate_pointer_out_of_range()
     let problem = MinimumExternalMacroDataCompression::new(2, vec![0, 1], 2);
     // D = "a" (len 1), C = "ptr(0,2)" which references D[0..2] but D only has 1 element
     // ptr(0,2) index = 1, encoded as 2+1+1 = 4
-    assert_eq!(problem.evaluate(&[0, 2, 4, 2]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 2, 4, 2]).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_external_macro_data_compression_empty_string() {
     let problem = MinimumExternalMacroDataCompression::new(2, vec![], 2);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -97,9 +107,10 @@ fn test_minimum_external_macro_data_compression_brute_force() {
     let problem = MinimumExternalMacroDataCompression::new(2, vec![0, 1], 2);
     let solver = BruteForce::new();
     let witness = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let val = problem.evaluate(&witness);
+    let val = problem.evaluate(&witness).unwrap();
     assert!(val.0.is_some());
     // Optimal is uncompressed: cost = 2
     assert_eq!(val.0.unwrap(), 2);
@@ -107,10 +118,10 @@ fn test_minimum_external_macro_data_compression_brute_force() {
 
 #[test]
 fn test_minimum_external_macro_data_compression_solve_aggregate() {
-    use crate::solvers::Solver;
     let problem = MinimumExternalMacroDataCompression::new(2, vec![0, 1], 2);
     let solver = BruteForce::new();
-    let val = solver.solve(&problem);
+    let val_solution = solver.solve(&problem).unwrap().unwrap();
+    let val = problem.evaluate(&val_solution).unwrap();
     assert_eq!(val, Min(Some(2)));
 }
 
@@ -159,7 +170,7 @@ fn test_minimum_external_macro_data_compression_paper_example() {
     config.extend(vec![12, 12, 12]); // 3 pointers
     config.extend(vec![6; 15]); // 15 empty C-slots
 
-    let val = problem.evaluate(&config);
+    let val = problem.evaluate(&config).unwrap();
     assert_eq!(val, Min(Some(12))); // 6 + 3 + 1*3 = 12
 }
 
@@ -169,11 +180,11 @@ fn test_minimum_external_macro_data_compression_find_all_witnesses() {
     // 2*1 = 2 variables. D-domain = 2, C-domain = 2 + 1 = 3. Total = 2*3 = 6
     let problem = MinimumExternalMacroDataCompression::new(1, vec![0], 2);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // There should be at least one witness: uncompressed [1, 0] (D=empty, C=a)
     assert!(solutions.contains(&vec![1, 0]));
     for sol in &solutions {
-        let val = problem.evaluate(sol);
+        let val = problem.evaluate(sol).unwrap();
         assert!(val.0.is_some());
     }
 }
diff --git a/src/unit_tests/models/misc/minimum_fault_detection_test_set.rs b/src/unit_tests/models/misc/minimum_fault_detection_test_set.rs
index 9d1230399..50b725e11 100644
--- a/src/unit_tests/models/misc/minimum_fault_detection_test_set.rs
+++ b/src/unit_tests/models/misc/minimum_fault_detection_test_set.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -35,7 +36,7 @@ fn test_minimum_fault_detection_test_set_creation() {
     assert_eq!(problem.num_outputs(), 2);
     // 2 inputs * 2 outputs = 4 pairs
     assert_eq!(problem.num_variables(), 4);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(
         <MinimumFaultDetectionTestSet as Problem>::NAME,
         "MinimumFaultDetectionTestSet"
@@ -50,7 +51,12 @@ fn test_minimum_fault_detection_test_set_evaluate_optimal() {
     // Config [1,0,0,1]: select pairs (0,5) and (1,6)
     // (0,5) covers {0,2,3,5}, (1,6) covers {1,3,4,6}
     // Internal vertices are {2,3,4}; both pairs together cover all three.
-    assert_eq!(problem.evaluate(&[1, 0, 0, 1]), Min(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![vec![true, false], vec![false, true]])
+            .unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
@@ -59,11 +65,21 @@ fn test_minimum_fault_detection_test_set_evaluate_insufficient() {
 
     // Config [1,0,0,0]: select only pair (0,5)
     // (0,5) covers internal vertices {2,3} -> missing {4} -> Min(None)
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![vec![true, false], vec![false, false]])
+            .unwrap(),
+        Min(None)
+    );
 
     // Config [0,0,0,1]: select only pair (1,6)
     // (1,6) covers internal vertices {3,4} -> missing {2} -> Min(None)
-    assert_eq!(problem.evaluate(&[0, 0, 0, 1]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![vec![false, false], vec![false, true]])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -72,7 +88,10 @@ fn test_minimum_fault_detection_test_set_evaluate_all_pairs() {
 
     // Config [1,1,1,1]: select all 4 pairs
     // Union covers all internal vertices -> Min(4)
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1]), Min(Some(4)));
+    assert_eq!(
+        problem.evaluate(&vec![vec![true; 2]; 2]).unwrap(),
+        Min(Some(4))
+    );
 }
 
 #[test]
@@ -80,7 +99,10 @@ fn test_minimum_fault_detection_test_set_evaluate_no_selection() {
     let problem = issue_problem();
 
     // No pairs selected -> nothing covered -> Min(None)
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![vec![false; 2]; 2]).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -88,19 +110,23 @@ fn test_minimum_fault_detection_test_set_counts_only_internal_vertices() {
     let problem = MinimumFaultDetectionTestSet::new(2, vec![(0, 1)], vec![0], vec![1]);
 
     // With only an input and an output, there are no internal vertices to cover.
-    assert_eq!(problem.evaluate(&[0]), Min(Some(0)));
-    assert_eq!(problem.evaluate(&[1]), Min(Some(1)));
+    assert_eq!(problem.evaluate(&vec![vec![false]]).unwrap(), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![vec![true]]).unwrap(), Min(Some(1)));
 
     let solver = BruteForce::new();
-    use crate::solvers::Solver;
-    assert_eq!(solver.solve(&problem), Min(Some(0)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(0))
+    );
 }
 
 #[test]
 fn test_minimum_fault_detection_test_set_wrong_config_length() {
     let problem = issue_problem();
 
-    assert_eq!(problem.evaluate(&[1, 0]), Min(None));
+    assert!(problem.evaluate(&vec![vec![true, false]]).is_err());
 }
 
 #[test]
@@ -108,14 +134,15 @@ fn test_minimum_fault_detection_test_set_solver() {
     let problem = issue_problem();
     let solver = BruteForce::new();
 
-    use crate::solvers::Solver;
-    let optimal = solver.solve(&problem);
+    let optimal_solution = solver.solve(&problem).unwrap().unwrap();
+
+    let optimal = problem.evaluate(&optimal_solution).unwrap();
     assert_eq!(optimal, Min(Some(2)));
 
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
     let w = witness.unwrap();
-    assert_eq!(problem.evaluate(&w), Min(Some(2)));
+    assert_eq!(problem.evaluate(&w).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -128,7 +155,12 @@ fn test_minimum_fault_detection_test_set_serialization() {
     assert_eq!(round_trip.num_arcs(), 8);
     assert_eq!(round_trip.inputs(), &[0, 1]);
     assert_eq!(round_trip.outputs(), &[5, 6]);
-    assert_eq!(round_trip.evaluate(&[1, 0, 0, 1]), Min(Some(2)));
+    assert_eq!(
+        round_trip
+            .evaluate(&vec![vec![true, false], vec![false, true]])
+            .unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
@@ -136,20 +168,28 @@ fn test_minimum_fault_detection_test_set_paper_example() {
     let problem = issue_problem();
 
     // Verify the paper example: optimal config [1,0,0,1] with value 2
-    assert_eq!(problem.evaluate(&[1, 0, 0, 1]), Min(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![vec![true, false], vec![false, true]])
+            .unwrap(),
+        Min(Some(2))
+    );
 
     // Confirm optimality via brute force
     let solver = BruteForce::new();
-    use crate::solvers::Solver;
-    let optimal = solver.solve(&problem);
+    let optimal_solution = solver.solve(&problem).unwrap().unwrap();
+    let optimal = problem.evaluate(&optimal_solution).unwrap();
     assert_eq!(optimal, Min(Some(2)));
 
     // Verify there is exactly one optimal witness
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     let optimal_witnesses: Vec<_> = all
         .into_iter()
-        .filter(|w| problem.evaluate(w) == Min(Some(2)))
+        .filter(|w| problem.evaluate(w).unwrap() == Min(Some(2)))
         .collect();
     assert_eq!(optimal_witnesses.len(), 1);
-    assert_eq!(optimal_witnesses[0], vec![1, 0, 0, 1]);
+    assert_eq!(
+        optimal_witnesses[0],
+        vec![vec![true, false], vec![false, true]]
+    );
 }
diff --git a/src/unit_tests/models/misc/minimum_internal_macro_data_compression.rs b/src/unit_tests/models/misc/minimum_internal_macro_data_compression.rs
index 76c5d00f0..82be1e6e6 100644
--- a/src/unit_tests/models/misc/minimum_internal_macro_data_compression.rs
+++ b/src/unit_tests/models/misc/minimum_internal_macro_data_compression.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -19,7 +20,7 @@ fn test_minimum_internal_macro_data_compression_creation() {
         vec![]
     );
     // dims: 9 slots, domain = 3 + 9 + 1 = 13
-    let dims = problem.dims();
+    let dims = problem.dimensions();
     assert_eq!(dims.len(), 9);
     assert!(dims.iter().all(|&d| d == 13));
 }
@@ -31,7 +32,7 @@ fn test_minimum_internal_macro_data_compression_evaluate_uncompressed() {
     // Uncompressed: C = [a, b] = [0, 1]
     // active_len = 2, pointers = 0
     // cost = 2 + 0 = 2
-    assert_eq!(problem.evaluate(&[0, 1]), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![0, 1]).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -43,7 +44,7 @@ fn test_minimum_internal_macro_data_compression_evaluate_with_pointer() {
     // decoded = "abab" = s
     // active_len = 3, pointers = 1
     // cost = 3 + (2-1)*1 = 4
-    assert_eq!(problem.evaluate(&[0, 1, 3, 2]), Min(Some(4)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 3, 2]).unwrap(), Min(Some(4)));
 }
 
 #[test]
@@ -51,14 +52,20 @@ fn test_minimum_internal_macro_data_compression_evaluate_invalid_decode() {
     // alphabet {a, b}, s = "ab", h = 2
     let problem = MinimumInternalMacroDataCompression::new(2, vec![0, 1], 2);
     // C = [b, a] decodes to "ba" != "ab"
-    assert_eq!(problem.evaluate(&[1, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![1, 0]).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_internal_macro_data_compression_evaluate_wrong_length() {
     let problem = MinimumInternalMacroDataCompression::new(2, vec![0, 1], 2);
-    assert_eq!(problem.evaluate(&[0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -66,7 +73,7 @@ fn test_minimum_internal_macro_data_compression_evaluate_interleaved_eos() {
     // EOS then non-EOS is invalid
     let problem = MinimumInternalMacroDataCompression::new(2, vec![0, 1], 2);
     // config = [EOS, a] = [2, 0]
-    assert_eq!(problem.evaluate(&[2, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![2, 0]).unwrap(), Min(None));
 }
 
 #[test]
@@ -75,14 +82,14 @@ fn test_minimum_internal_macro_data_compression_evaluate_pointer_forward_ref() {
     let problem = MinimumInternalMacroDataCompression::new(2, vec![0, 1], 2);
     // C = [ptr(0)] -> pointer at first position references decoded[0], but nothing decoded yet
     // ptr(C[0]) encoded as 3 (alphabet_size + 1 + 0 = 2+1+0 = 3)
-    assert_eq!(problem.evaluate(&[3, 2]), Min(None));
+    assert_eq!(problem.evaluate(&vec![3, 2]).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_internal_macro_data_compression_empty_string() {
     let problem = MinimumInternalMacroDataCompression::new(2, vec![], 2);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -92,9 +99,10 @@ fn test_minimum_internal_macro_data_compression_brute_force_simple() {
     let problem = MinimumInternalMacroDataCompression::new(2, vec![0, 1], 2);
     let solver = BruteForce::new();
     let witness = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let val = problem.evaluate(&witness);
+    let val = problem.evaluate(&witness).unwrap();
     assert_eq!(val, Min(Some(2)));
 }
 
@@ -105,9 +113,10 @@ fn test_minimum_internal_macro_data_compression_brute_force_repeated() {
     let problem = MinimumInternalMacroDataCompression::new(2, vec![0, 1, 0, 1], 2);
     let solver = BruteForce::new();
     let witness = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let val = problem.evaluate(&witness);
+    let val = problem.evaluate(&witness).unwrap();
     assert!(val.0.is_some());
     // Optimal: C = [a, b, ptr(0), EOS] -> cost = 3 + 1 = 4
     // Or uncompressed: cost = 4 + 0 = 4 (same)
@@ -116,10 +125,10 @@ fn test_minimum_internal_macro_data_compression_brute_force_repeated() {
 
 #[test]
 fn test_minimum_internal_macro_data_compression_solve_aggregate() {
-    use crate::solvers::Solver;
     let problem = MinimumInternalMacroDataCompression::new(2, vec![0, 1], 2);
     let solver = BruteForce::new();
-    let val = solver.solve(&problem);
+    let val_solution = solver.solve(&problem).unwrap().unwrap();
+    let val = problem.evaluate(&val_solution).unwrap();
     assert_eq!(val, Min(Some(2)));
 }
 
@@ -141,7 +150,7 @@ fn test_minimum_internal_macro_data_compression_paper_example() {
     let problem = MinimumInternalMacroDataCompression::new(3, vec![0, 1, 2, 0, 1, 2, 0, 1, 2], 2);
     let config = vec![0, 1, 2, 4, 4, 3, 3, 3, 3];
     // ptr(C[0]) = alphabet_size + 1 + 0 = 3 + 1 + 0 = 4
-    let val = problem.evaluate(&config);
+    let val = problem.evaluate(&config).unwrap();
     assert_eq!(val, Min(Some(7)));
 }
 
@@ -151,7 +160,7 @@ fn test_minimum_internal_macro_data_compression_find_all_witnesses() {
     // domain = 1+1+1 = 3, 3^1 = 3 configs
     let problem = MinimumInternalMacroDataCompression::new(1, vec![0], 2);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // Only valid: [0] (literal 'a'), cost = 1
     assert_eq!(solutions.len(), 1);
     assert_eq!(solutions[0], vec![0]);
@@ -169,6 +178,6 @@ fn test_minimum_internal_macro_data_compression_pointer_doubling() {
     // active_len = 3, pointers = 2, cost = 3 + 0*2 = 3
     let problem = MinimumInternalMacroDataCompression::new(1, vec![0, 0, 0, 0], 1);
     let config = vec![0, 2, 2, 1]; // a, ptr(0), ptr(0), EOS
-    let val = problem.evaluate(&config);
+    let val = problem.evaluate(&config).unwrap();
     assert_eq!(val, Min(Some(3)));
 }
diff --git a/src/unit_tests/models/misc/minimum_register_sufficiency_for_loops.rs b/src/unit_tests/models/misc/minimum_register_sufficiency_for_loops.rs
index fd895168d..1c07a636d 100644
--- a/src/unit_tests/models/misc/minimum_register_sufficiency_for_loops.rs
+++ b/src/unit_tests/models/misc/minimum_register_sufficiency_for_loops.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -9,14 +10,14 @@ fn test_creation() {
     assert_eq!(problem.loop_length(), 6);
     assert_eq!(problem.num_variables(), 3);
     assert_eq!(problem.variables(), &[(0, 3), (2, 3), (4, 3)]);
-    assert_eq!(problem.dims(), vec![3, 3, 3]);
+    assert_eq!(problem.dimensions(), vec![3, 3, 3]);
 }
 
 #[test]
 fn test_evaluate_optimal() {
     // K3 graph: all 3 vars conflict, need 3 registers
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(0, 3), (2, 3), (4, 3)]);
-    let result = problem.evaluate(&[0, 1, 2]);
+    let result = problem.evaluate(&vec![0, 1, 2]).unwrap();
     assert_eq!(result, Min(Some(3)));
 }
 
@@ -24,7 +25,7 @@ fn test_evaluate_optimal() {
 fn test_evaluate_conflict() {
     // Two overlapping vars assigned same register => conflict
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(0, 3), (2, 3), (4, 3)]);
-    let result = problem.evaluate(&[0, 0, 1]);
+    let result = problem.evaluate(&vec![0, 0, 1]).unwrap();
     // Vars 0 and 1 overlap (arcs [0,3) and [2,5)), same register 0 => invalid
     assert_eq!(result, Min(None));
 }
@@ -34,7 +35,7 @@ fn test_evaluate_non_overlapping() {
     // Two non-overlapping vars can share a register
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(0, 2), (3, 2)]);
     // Arcs [0,2) and [3,5) don't overlap
-    let result = problem.evaluate(&[0, 0]);
+    let result = problem.evaluate(&vec![0, 0]).unwrap();
     assert_eq!(result, Min(Some(1)));
 }
 
@@ -42,22 +43,26 @@ fn test_evaluate_non_overlapping() {
 fn test_evaluate_all_different() {
     // Trivial assignment: all different registers
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(0, 3), (2, 3), (4, 3)]);
-    let result = problem.evaluate(&[0, 1, 2]);
+    let result = problem.evaluate(&vec![0, 1, 2]).unwrap();
     assert_eq!(result, Min(Some(3)));
 }
 
 #[test]
 fn test_evaluate_invalid_config_length() {
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(0, 3), (2, 3)]);
-    let result = problem.evaluate(&[0]);
-    assert_eq!(result, Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_evaluate_out_of_range_register() {
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(0, 3), (2, 3)]);
-    let result = problem.evaluate(&[0, 5]); // 5 >= num_variables (2)
-    assert_eq!(result, Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -65,8 +70,8 @@ fn test_solver_k3() {
     // All pairs conflict: need 3 registers
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(0, 3), (2, 3), (4, 3)]);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&witness);
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&witness).unwrap();
     assert_eq!(value, Min(Some(3)));
 }
 
@@ -75,8 +80,8 @@ fn test_solver_two_non_overlapping() {
     // Two non-overlapping arcs: can share 1 register
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(0, 2), (3, 2)]);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&witness);
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&witness).unwrap();
     assert_eq!(value, Min(Some(1)));
 }
 
@@ -85,8 +90,8 @@ fn test_solver_two_overlapping() {
     // Two overlapping arcs: need 2 registers
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(0, 4), (3, 4)]);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&witness);
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&witness).unwrap();
     assert_eq!(value, Min(Some(2)));
 }
 
@@ -96,9 +101,9 @@ fn test_circular_wrap_around_overlap() {
     // Arc (0, 3) covers timesteps {0, 1, 2}
     // They overlap at timesteps 0 and 1
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(5, 3), (0, 3)]);
-    let result = problem.evaluate(&[0, 0]);
+    let result = problem.evaluate(&vec![0, 0]).unwrap();
     assert_eq!(result, Min(None)); // conflict
-    let result = problem.evaluate(&[0, 1]);
+    let result = problem.evaluate(&vec![0, 1]).unwrap();
     assert_eq!(result, Min(Some(2)));
 }
 
@@ -106,8 +111,8 @@ fn test_circular_wrap_around_overlap() {
 fn test_single_variable() {
     let problem = MinimumRegisterSufficiencyForLoops::new(4, vec![(0, 2)]);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    let value = problem.evaluate(&witness);
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&witness).unwrap();
     assert_eq!(value, Min(Some(1)));
 }
 
@@ -127,13 +132,13 @@ fn test_paper_example() {
     // Config [0,1,2] -> 3 registers -> Min(3) is optimal
     let problem = MinimumRegisterSufficiencyForLoops::new(6, vec![(0, 3), (2, 3), (4, 3)]);
     let config = vec![0, 1, 2];
-    let result = problem.evaluate(&config);
+    let result = problem.evaluate(&config).unwrap();
     assert_eq!(result, Min(Some(3)));
 
     // Verify optimality with brute force
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best), Min(Some(3)));
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap(), Min(Some(3)));
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/minimum_tardiness_sequencing.rs b/src/unit_tests/models/misc/minimum_tardiness_sequencing.rs
index 704471b8d..635e66453 100644
--- a/src/unit_tests/models/misc/minimum_tardiness_sequencing.rs
+++ b/src/unit_tests/models/misc/minimum_tardiness_sequencing.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::One;
 
@@ -16,7 +17,7 @@ fn test_minimum_tardiness_sequencing_basic() {
     assert_eq!(problem.deadlines(), &[5, 5, 5, 3, 3]);
     assert_eq!(problem.precedences(), &[(0, 3), (1, 3), (1, 4), (2, 4)]);
     assert_eq!(problem.num_precedences(), 4);
-    assert_eq!(problem.dims(), vec![5, 4, 3, 2, 1]);
+    assert_eq!(problem.dimensions(), vec![5, 4, 3, 2, 1]);
     assert_eq!(
         <MinimumTardinessSequencing<One> as Problem>::NAME,
         "MinimumTardinessSequencing"
@@ -30,48 +31,57 @@ fn test_minimum_tardiness_sequencing_evaluate_optimal() {
         vec![5, 5, 5, 3, 3],
         vec![(0, 3), (1, 3), (1, 4), (2, 4)],
     );
-    let config = vec![0, 0, 1, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(1)));
+    let config = vec![0, 1, 3, 2, 4];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(1)));
 }
 
 #[test]
-fn test_minimum_tardiness_sequencing_evaluate_invalid_lehmer() {
+fn test_minimum_tardiness_sequencing_evaluate_duplicate_task() {
     let problem = MinimumTardinessSequencing::<One>::new(3, vec![2, 3, 1], vec![]);
-    assert_eq!(problem.evaluate(&[0, 2, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 2, 0]).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_tardiness_sequencing_evaluate_out_of_range() {
     let problem = MinimumTardinessSequencing::<One>::new(3, vec![2, 3, 1], vec![]);
-    assert_eq!(problem.evaluate(&[0, 1, 5]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimum_tardiness_sequencing_evaluate_wrong_length() {
     let problem = MinimumTardinessSequencing::<One>::new(3, vec![2, 3, 1], vec![]);
-    assert_eq!(problem.evaluate(&[0, 1]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_minimum_tardiness_sequencing_evaluate_precedence_violation() {
     let problem = MinimumTardinessSequencing::<One>::new(3, vec![3, 3, 3], vec![(0, 1)]);
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(Some(0)));
-    assert_eq!(problem.evaluate(&[1, 0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[2, 1, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2]).unwrap(), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![1, 0, 2]).unwrap(), Min(None));
+    assert_eq!(problem.evaluate(&vec![2, 1, 0]).unwrap(), Min(None));
 }
 
 #[test]
 fn test_minimum_tardiness_sequencing_evaluate_all_on_time() {
     let problem = MinimumTardinessSequencing::<One>::new(3, vec![3, 3, 3], vec![]);
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(Some(0)));
-    assert_eq!(problem.evaluate(&[2, 1, 0]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2]).unwrap(), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![2, 1, 0]).unwrap(), Min(Some(0)));
 }
 
 #[test]
 fn test_minimum_tardiness_sequencing_evaluate_all_tardy() {
     let problem = MinimumTardinessSequencing::<One>::new(2, vec![0, 0], vec![]);
-    assert_eq!(problem.evaluate(&[0, 0]), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![0, 1]).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -83,9 +93,10 @@ fn test_minimum_tardiness_sequencing_brute_force() {
     );
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     assert_eq!(metric, Min(Some(1)));
 }
 
@@ -94,9 +105,10 @@ fn test_minimum_tardiness_sequencing_brute_force_no_precedences() {
     let problem = MinimumTardinessSequencing::<One>::new(3, vec![1, 3, 2], vec![]);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     assert_eq!(metric, Min(Some(0)));
 }
 
@@ -114,18 +126,18 @@ fn test_minimum_tardiness_sequencing_serialization() {
 fn test_minimum_tardiness_sequencing_empty() {
     let problem = MinimumTardinessSequencing::<One>::new(0, vec![], vec![]);
     assert_eq!(problem.num_tasks(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
 fn test_minimum_tardiness_sequencing_single_task() {
     let problem = MinimumTardinessSequencing::<One>::new(1, vec![1], vec![]);
-    assert_eq!(problem.dims(), vec![1]);
-    assert_eq!(problem.evaluate(&[0]), Min(Some(0)));
+    assert_eq!(problem.dimensions(), vec![1]);
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Min(Some(0)));
 
     let problem_tardy = MinimumTardinessSequencing::<One>::new(1, vec![0], vec![]);
-    assert_eq!(problem_tardy.evaluate(&[0]), Min(Some(1)));
+    assert_eq!(problem_tardy.evaluate(&vec![0]).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -145,14 +157,14 @@ fn test_minimum_tardiness_sequencing_cyclic_precedences() {
     let problem =
         MinimumTardinessSequencing::<One>::new(3, vec![3, 3, 3], vec![(0, 1), (1, 2), (2, 0)]);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
-// ===== Arbitrary-length variant (W = i32) =====
+// ===== Arbitrary-length variant (W = i64) =====
 
 #[test]
 fn test_minimum_tardiness_sequencing_weighted_basic() {
-    let problem = MinimumTardinessSequencing::<i32>::with_lengths(
+    let problem = MinimumTardinessSequencing::<i64>::with_lengths(
         vec![3, 2, 2, 1, 2],
         vec![4, 3, 8, 3, 6],
         vec![(0, 2), (1, 3)],
@@ -167,8 +179,7 @@ fn test_minimum_tardiness_sequencing_weighted_basic() {
 fn test_minimum_tardiness_sequencing_weighted_evaluate() {
     // Issue example: 5 tasks, lengths [3,2,2,1,2], deadlines [4,3,8,3,6], prec (0→2, 1→3)
     // Schedule: t0,t4,t2,t1,t3
-    // Lehmer [0,3,1,0,0] -> schedule [0,4,2,1,3]
-    let problem = MinimumTardinessSequencing::<i32>::with_lengths(
+    let problem = MinimumTardinessSequencing::<i64>::with_lengths(
         vec![3, 2, 2, 1, 2],
         vec![4, 3, 8, 3, 6],
         vec![(0, 2), (1, 3)],
@@ -178,30 +189,34 @@ fn test_minimum_tardiness_sequencing_weighted_evaluate() {
     // t2(l=2): finish=7, deadline=8 → on time
     // t1(l=2): finish=9, deadline=3 → tardy
     // t3(l=1): finish=10, deadline=3 → tardy
-    assert_eq!(problem.evaluate(&[0, 3, 1, 0, 0]), Min(Some(2)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 4, 2, 1, 3]).unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
 fn test_minimum_tardiness_sequencing_weighted_brute_force() {
-    let problem = MinimumTardinessSequencing::<i32>::with_lengths(
+    let problem = MinimumTardinessSequencing::<i64>::with_lengths(
         vec![3, 2, 2, 1, 2],
         vec![4, 3, 8, 3, 6],
         vec![(0, 2), (1, 3)],
     );
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     assert_eq!(metric, Min(Some(2)));
 }
 
 #[test]
 fn test_minimum_tardiness_sequencing_weighted_serialization() {
     let problem =
-        MinimumTardinessSequencing::<i32>::with_lengths(vec![3, 2, 2], vec![4, 3, 8], vec![(0, 1)]);
+        MinimumTardinessSequencing::<i64>::with_lengths(vec![3, 2, 2], vec![4, 3, 8], vec![(0, 1)]);
     let json = serde_json::to_value(&problem).unwrap();
-    let restored: MinimumTardinessSequencing<i32> = serde_json::from_value(json).unwrap();
+    let restored: MinimumTardinessSequencing<i64> = serde_json::from_value(json).unwrap();
     assert_eq!(restored.num_tasks(), problem.num_tasks());
     assert_eq!(restored.lengths(), problem.lengths());
     assert_eq!(restored.deadlines(), problem.deadlines());
@@ -214,25 +229,48 @@ fn test_minimum_tardiness_sequencing_weighted_different_lengths() {
     // Schedule [0,1,2]: t0(l=1,fin=1≤2✓), t1(l=5,fin=6≤6✓), t2(l=1,fin=7>3✗) → 1 tardy
     // Schedule [1,0,2]: t1(l=5,fin=5≤6✓), t0(l=1,fin=6>2✗), t2(l=1,fin=7>3✗) → 2 tardy
     let problem =
-        MinimumTardinessSequencing::<i32>::with_lengths(vec![1, 5, 1], vec![2, 6, 3], vec![]);
+        MinimumTardinessSequencing::<i64>::with_lengths(vec![1, 5, 1], vec![2, 6, 3], vec![]);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert_eq!(problem.evaluate(&solution), Min(Some(1)));
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(1)));
 }
 
 #[test]
 #[should_panic(expected = "all task lengths must be positive")]
 fn test_minimum_tardiness_sequencing_weighted_zero_length() {
-    MinimumTardinessSequencing::<i32>::with_lengths(vec![1, 0, 2], vec![3, 3, 3], vec![]);
+    MinimumTardinessSequencing::<i64>::with_lengths(vec![1, 0, 2], vec![3, 3, 3], vec![]);
 }
 
 #[test]
 fn test_minimum_tardiness_sequencing_paper_example() {
     // Issue example (unit-length): 4 tasks, deadlines [2,3,1,4], prec (0→2)
-    // Lehmer [0,0,0,0] = schedule [0,1,2,3]
     // t0: finish=1≤2✓, t1: finish=2≤3✓, t2: finish=3>1✗, t3: finish=4≤4✓ → 1 tardy
     let problem = MinimumTardinessSequencing::<One>::new(4, vec![2, 3, 1, 4], vec![(0, 2)]);
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Min(Some(1)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap(), Min(Some(1)));
+}
+#[test]
+fn create_specs_default_precedences_to_empty() {
+    let unit = MinimumTardinessSequencing::try_from(MinimumTardinessSequencingOneCreateSpec {
+        deadlines: vec![1, 2],
+        precedences: None,
+    })
+    .unwrap();
+    let weighted = MinimumTardinessSequencing::try_from(MinimumTardinessSequencingI64CreateSpec {
+        lengths: vec![1, 2],
+        deadlines: vec![1, 3],
+        precedences: None,
+    })
+    .unwrap();
+    assert!(unit.precedences().is_empty());
+    assert!(weighted.precedences().is_empty());
+    assert!(
+        !MinimumTardinessSequencingOneCreateSpec::inputs()
+            .iter()
+            .find(|input| input.name == "precedences")
+            .unwrap()
+            .required
+    );
 }
diff --git a/src/unit_tests/models/misc/minimum_weight_and_or_graph.rs b/src/unit_tests/models/misc/minimum_weight_and_or_graph.rs
index 1a708e8cf..5cbe85f53 100644
--- a/src/unit_tests/models/misc/minimum_weight_and_or_graph.rs
+++ b/src/unit_tests/models/misc/minimum_weight_and_or_graph.rs
@@ -1,4 +1,18 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_arc_weights() {
+    let p = MinimumWeightAndOrGraph::try_from(MinimumWeightAndOrGraphCreateSpec {
+        num_vertices: 2,
+        arcs: vec![(0, 1)],
+        source: 0,
+        gate_types: vec![Some(false), None],
+        arc_weights: None,
+    })
+    .unwrap();
+    assert_eq!(p.arc_weights(), &[1]);
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -25,7 +39,7 @@ fn test_minimum_weight_and_or_graph_creation() {
     assert_eq!(problem.gate_types().len(), 7);
     assert_eq!(problem.arc_weights().len(), 6);
     assert_eq!(problem.num_variables(), 6);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert_eq!(
         <MinimumWeightAndOrGraph as Problem>::NAME,
         "MinimumWeightAndOrGraph"
@@ -39,7 +53,12 @@ fn test_minimum_weight_and_or_graph_evaluate_optimal() {
 
     // Config [1,1,0,1,0,1]: arcs 0,1,3,5 selected
     // Weights: 1+2+1+2 = 6
-    assert_eq!(problem.evaluate(&[1, 1, 0, 1, 0, 1]), Min(Some(6)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, false, true, false, true])
+            .unwrap(),
+        Min(Some(6))
+    );
 }
 
 #[test]
@@ -48,7 +67,12 @@ fn test_minimum_weight_and_or_graph_evaluate_all_arcs() {
 
     // Config [1,1,1,1,1,1]: all arcs selected, also valid (AND satisfied, OR satisfied)
     // Weights: 1+2+3+1+4+2 = 13
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1, 1, 1]), Min(Some(13)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, true, true, true])
+            .unwrap(),
+        Min(Some(13))
+    );
 }
 
 #[test]
@@ -57,7 +81,12 @@ fn test_minimum_weight_and_or_graph_and_violated() {
 
     // Config [1,0,0,1,0,1]: arc 1 (0->2) not selected, but source is AND
     // AND at source requires both arcs 0 and 1
-    assert_eq!(problem.evaluate(&[1, 0, 0, 1, 0, 1]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, true, false, true])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -66,7 +95,12 @@ fn test_minimum_weight_and_or_graph_or_violated() {
 
     // Config [1,1,0,0,0,1]: arcs 0,1,5 selected
     // OR at v1 has no selected outgoing arcs (arcs 2,3 both 0)
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0, 0, 1]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, false, false, false, true])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -76,7 +110,12 @@ fn test_minimum_weight_and_or_graph_dangling_arc() {
     // Config [0,0,1,0,0,0]: only arc 2 (1->3) selected
     // Arc 2 goes from vertex 1, but vertex 1 is not solved (no arc leads to it from source)
     // Source AND requires arcs 0,1 — they are missing, so it's invalid at the source check
-    assert_eq!(problem.evaluate(&[0, 0, 1, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, false, true, false, false, false])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -84,14 +123,22 @@ fn test_minimum_weight_and_or_graph_empty_config() {
     let problem = issue_problem();
 
     // No arcs selected: AND at source requires all outgoing arcs
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, false, false, false, false, false])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_minimum_weight_and_or_graph_wrong_config_length() {
     let problem = issue_problem();
 
-    assert_eq!(problem.evaluate(&[1, 1, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![true, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -99,14 +146,15 @@ fn test_minimum_weight_and_or_graph_solver() {
     let problem = issue_problem();
     let solver = BruteForce::new();
 
-    use crate::solvers::Solver;
-    let optimal = solver.solve(&problem);
+    let optimal_solution = solver.solve(&problem).unwrap().unwrap();
+
+    let optimal = problem.evaluate(&optimal_solution).unwrap();
     assert_eq!(optimal, Min(Some(6)));
 
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
     let w = witness.unwrap();
-    assert_eq!(problem.evaluate(&w), Min(Some(6)));
+    assert_eq!(problem.evaluate(&w).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -118,7 +166,12 @@ fn test_minimum_weight_and_or_graph_serialization() {
     assert_eq!(round_trip.num_vertices(), 7);
     assert_eq!(round_trip.num_arcs(), 6);
     assert_eq!(round_trip.source(), 0);
-    assert_eq!(round_trip.evaluate(&[1, 1, 0, 1, 0, 1]), Min(Some(6)));
+    assert_eq!(
+        round_trip
+            .evaluate(&vec![true, true, false, true, false, true])
+            .unwrap(),
+        Min(Some(6))
+    );
 }
 
 #[test]
@@ -126,20 +179,28 @@ fn test_minimum_weight_and_or_graph_paper_example() {
     let problem = issue_problem();
 
     // Verify the paper example: optimal config [1,1,0,1,0,1] with value 6
-    assert_eq!(problem.evaluate(&[1, 1, 0, 1, 0, 1]), Min(Some(6)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, false, true, false, true])
+            .unwrap(),
+        Min(Some(6))
+    );
 
     // Confirm optimality via brute force
     let solver = BruteForce::new();
-    use crate::solvers::Solver;
-    let optimal = solver.solve(&problem);
+    let optimal_solution = solver.solve(&problem).unwrap().unwrap();
+    let optimal = problem.evaluate(&optimal_solution).unwrap();
     assert_eq!(optimal, Min(Some(6)));
 
     // Verify there is exactly one optimal witness
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     let optimal_witnesses: Vec<_> = all
         .into_iter()
-        .filter(|w| problem.evaluate(w) == Min(Some(6)))
+        .filter(|w| problem.evaluate(w).unwrap() == Min(Some(6)))
         .collect();
     assert_eq!(optimal_witnesses.len(), 1);
-    assert_eq!(optimal_witnesses[0], vec![1, 1, 0, 1, 0, 1]);
+    assert_eq!(
+        optimal_witnesses[0],
+        vec![true, true, false, true, false, true]
+    );
 }
diff --git a/src/unit_tests/models/misc/multiprocessor_scheduling.rs b/src/unit_tests/models/misc/multiprocessor_scheduling.rs
index bbc5ff3d8..a8581588c 100644
--- a/src/unit_tests/models/misc/multiprocessor_scheduling.rs
+++ b/src/unit_tests/models/misc/multiprocessor_scheduling.rs
@@ -1,4 +1,21 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_zero_processors() {
+    assert_eq!(
+        MultiprocessorSchedulingCreateSpec::FIELDS[1].name,
+        "num_processors"
+    );
+    assert!(
+        MultiprocessorScheduling::try_from(MultiprocessorSchedulingCreateSpec {
+            lengths: vec![1],
+            num_processors: 0,
+            deadline: 1
+        })
+        .is_err()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
@@ -11,7 +28,7 @@ fn test_multiprocessor_scheduling_basic() {
     assert_eq!(problem.num_processors(), 2);
     assert_eq!(problem.deadline(), 10);
     assert_eq!(problem.total_length(), 20);
-    assert_eq!(problem.dims(), vec![2; 5]);
+    assert_eq!(problem.dimensions(), vec![2; 5]);
     assert_eq!(
         <MultiprocessorScheduling as Problem>::NAME,
         "MultiprocessorScheduling"
@@ -23,78 +40,87 @@ fn test_multiprocessor_scheduling_basic() {
 fn test_multiprocessor_scheduling_feasible() {
     let problem = MultiprocessorScheduling::new(vec![4, 5, 3, 2, 6], 2, 10);
     // Processor 0: tasks 0,4 => 4+6=10, Processor 1: tasks 1,2,3 => 5+3+2=10
-    assert!(problem.evaluate(&[0, 1, 1, 1, 0]));
+    assert!(problem.evaluate(&vec![0, 1, 1, 1, 0]).unwrap());
 }
 
 #[test]
 fn test_multiprocessor_scheduling_infeasible() {
     let problem = MultiprocessorScheduling::new(vec![4, 5, 3, 2, 6], 2, 10);
     // Processor 0: tasks 0,1,2,3,4 => 4+5+3+2+6=20 > 10
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 0, 0]).unwrap());
 }
 
 #[test]
 fn test_multiprocessor_scheduling_infeasible_tight() {
     let problem = MultiprocessorScheduling::new(vec![4, 5, 3, 2, 6], 2, 10);
     // Processor 0: tasks 0,1,4 => 4+5+6=15 > 10
-    assert!(!problem.evaluate(&[0, 0, 1, 1, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 1, 1, 0]).unwrap());
 }
 
 #[test]
 fn test_multiprocessor_scheduling_wrong_config_length() {
     let problem = MultiprocessorScheduling::new(vec![4, 5, 3], 2, 10);
-    assert!(!problem.evaluate(&[0, 1]));
-    assert!(!problem.evaluate(&[0, 1, 0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_multiprocessor_scheduling_invalid_processor_index() {
     let problem = MultiprocessorScheduling::new(vec![4, 5, 3], 2, 10);
     // Processor index 2 is out of range for 2 processors
-    assert!(!problem.evaluate(&[0, 2, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_multiprocessor_scheduling_empty_instance() {
     let problem = MultiprocessorScheduling::new(vec![], 2, 10);
     assert_eq!(problem.num_tasks(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
     // Empty assignment is always feasible
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
 fn test_multiprocessor_scheduling_single_task() {
     let problem = MultiprocessorScheduling::new(vec![5], 2, 5);
-    assert!(problem.evaluate(&[0]));
-    assert!(problem.evaluate(&[1]));
+    assert!(problem.evaluate(&vec![0]).unwrap());
+    assert!(problem.evaluate(&vec![1]).unwrap());
 }
 
 #[test]
 fn test_multiprocessor_scheduling_single_task_exceeds_deadline() {
     let problem = MultiprocessorScheduling::new(vec![11], 2, 10);
-    assert!(!problem.evaluate(&[0]));
-    assert!(!problem.evaluate(&[1]));
+    assert!(!problem.evaluate(&vec![0]).unwrap());
+    assert!(!problem.evaluate(&vec![1]).unwrap());
 }
 
 #[test]
 fn test_multiprocessor_scheduling_three_processors() {
     let problem = MultiprocessorScheduling::new(vec![3, 3, 3], 3, 3);
-    assert_eq!(problem.dims(), vec![3; 3]);
+    assert_eq!(problem.dimensions(), vec![3; 3]);
     // One task per processor
-    assert!(problem.evaluate(&[0, 1, 2]));
+    assert!(problem.evaluate(&vec![0, 1, 2]).unwrap());
     // Two tasks on one processor exceeds deadline
-    assert!(!problem.evaluate(&[0, 0, 1]));
+    assert!(!problem.evaluate(&vec![0, 0, 1]).unwrap());
 }
 
 #[test]
 fn test_multiprocessor_scheduling_brute_force() {
     let problem = MultiprocessorScheduling::new(vec![4, 5, 3, 2, 6], 2, 10);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let config = solution.unwrap();
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -102,7 +128,7 @@ fn test_multiprocessor_scheduling_brute_force_infeasible() {
     // Total length = 20, with 2 processors and deadline 9, impossible
     let problem = MultiprocessorScheduling::new(vec![4, 5, 3, 2, 6], 2, 9);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
@@ -112,9 +138,9 @@ fn test_multiprocessor_scheduling_find_all_witnesses() {
     // Search space = 2^5 = 32
     let problem = MultiprocessorScheduling::new(vec![4, 5, 3, 2, 6], 2, 10);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
     // The issue witness {t1,t5} on P0 and {t2,t3,t4} on P1 must be among solutions
     assert!(solutions.contains(&vec![0, 1, 1, 1, 0]));
@@ -128,7 +154,7 @@ fn test_multiprocessor_scheduling_find_all_witnesses_empty() {
     // but 20 > 2*9 = 18, so impossible
     let problem = MultiprocessorScheduling::new(vec![4, 5, 3, 2, 6], 2, 9);
     let solver = BruteForce::new();
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+    assert!(solver.find_all_witnesses(&problem).unwrap().is_empty());
 }
 
 #[test]
@@ -165,8 +191,8 @@ fn test_multiprocessor_scheduling_zero_processors() {
 fn test_multiprocessor_scheduling_deadline_zero() {
     // Only feasible if all lengths are 0
     let problem = MultiprocessorScheduling::new(vec![0, 0], 2, 0);
-    assert!(problem.evaluate(&[0, 1]));
+    assert!(problem.evaluate(&vec![0, 1]).unwrap());
 
     let problem2 = MultiprocessorScheduling::new(vec![1, 0], 2, 0);
-    assert!(!problem2.evaluate(&[0, 1]));
+    assert!(!problem2.evaluate(&vec![0, 1]).unwrap());
 }
diff --git a/src/unit_tests/models/misc/non_liveness_free_petri_net.rs b/src/unit_tests/models/misc/non_liveness_free_petri_net.rs
index 54704ffcd..987c583b8 100644
--- a/src/unit_tests/models/misc/non_liveness_free_petri_net.rs
+++ b/src/unit_tests/models/misc/non_liveness_free_petri_net.rs
@@ -1,5 +1,6 @@
 use crate::models::misc::NonLivenessFreePetriNet;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -12,11 +13,13 @@ fn chain_net() -> NonLivenessFreePetriNet {
         vec![(0, 1), (1, 2), (2, 3)],
         vec![1, 0, 0, 0],
     )
+    .unwrap()
 }
 
 /// Cycle net: token oscillates between two places, both transitions always fireable.
 fn cycle_net() -> NonLivenessFreePetriNet {
     NonLivenessFreePetriNet::new(2, 2, vec![(0, 0), (1, 1)], vec![(0, 1), (1, 0)], vec![1, 0])
+        .unwrap()
 }
 
 #[test]
@@ -26,7 +29,7 @@ fn test_non_liveness_free_petri_net_basic() {
     assert_eq!(problem.num_transitions(), 3);
     assert_eq!(problem.num_arcs(), 6);
     assert_eq!(problem.initial_token_sum(), 1);
-    assert_eq!(problem.dims(), vec![2; 3]);
+    assert_eq!(problem.dimensions(), vec![2; 3]);
     assert_eq!(problem.num_variables(), 3);
     assert_eq!(
         <NonLivenessFreePetriNet as Problem>::NAME,
@@ -40,45 +43,63 @@ fn test_non_liveness_chain_net_is_not_live() {
     let problem = chain_net();
     // All transitions are dead: after the chain fires, nothing can fire again.
     // Selecting all transitions should yield true.
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Or(true));
+    assert_eq!(problem.evaluate(&vec![true, true, true]).unwrap(), Or(true));
     // Selecting just one transition should also yield true.
-    assert_eq!(problem.evaluate(&[1, 0, 0]), Or(true));
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Or(true));
-    assert_eq!(problem.evaluate(&[0, 0, 1]), Or(true));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false]).unwrap(),
+        Or(true)
+    );
+    assert_eq!(
+        problem.evaluate(&vec![false, true, false]).unwrap(),
+        Or(true)
+    );
+    assert_eq!(
+        problem.evaluate(&vec![false, false, true]).unwrap(),
+        Or(true)
+    );
     // Selecting no transition yields false (no claimed dead transition).
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Or(false));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false]).unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
 fn test_non_liveness_cycle_net_is_live() {
     let problem = cycle_net();
     // In the cycle net, both transitions can always fire. No transition is dead.
-    assert_eq!(problem.evaluate(&[1, 1]), Or(false));
-    assert_eq!(problem.evaluate(&[1, 0]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 1]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 0]), Or(false));
+    assert_eq!(problem.evaluate(&vec![true, true]).unwrap(), Or(false));
+    assert_eq!(problem.evaluate(&vec![true, false]).unwrap(), Or(false));
+    assert_eq!(problem.evaluate(&vec![false, true]).unwrap(), Or(false));
+    assert_eq!(problem.evaluate(&vec![false, false]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_non_liveness_solver_finds_witness_chain() {
     let problem = chain_net();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&witness), Or(true));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&witness).unwrap(), Or(true));
 }
 
 #[test]
 fn test_non_liveness_solver_no_witness_cycle() {
     let problem = cycle_net();
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_non_liveness_wrong_config_length() {
     let problem = chain_net();
-    assert_eq!(problem.evaluate(&[1, 0]), Or(false));
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -153,32 +174,29 @@ fn test_non_liveness_deserialization_rejects_invalid() {
 }
 
 #[test]
-#[should_panic(expected = "at least one place")]
-fn test_non_liveness_zero_places_panics() {
-    NonLivenessFreePetriNet::new(0, 1, vec![], vec![], vec![]);
+fn test_non_liveness_rejects_zero_places() {
+    assert!(NonLivenessFreePetriNet::new(0, 1, vec![], vec![], vec![]).is_err());
 }
 
 #[test]
-#[should_panic(expected = "at least one transition")]
-fn test_non_liveness_zero_transitions_panics() {
-    NonLivenessFreePetriNet::new(1, 0, vec![], vec![], vec![0]);
+fn test_non_liveness_rejects_zero_transitions() {
+    assert!(NonLivenessFreePetriNet::new(1, 0, vec![], vec![], vec![0]).is_err());
 }
 
 #[test]
-#[should_panic(expected = "does not match")]
-fn test_non_liveness_marking_length_mismatch_panics() {
-    NonLivenessFreePetriNet::new(2, 1, vec![], vec![], vec![0]);
+fn test_non_liveness_rejects_marking_length_mismatch() {
+    assert!(NonLivenessFreePetriNet::new(2, 1, vec![], vec![], vec![0]).is_err());
 }
 
 #[test]
-#[should_panic(expected = "Free-choice violation")]
-fn test_non_liveness_free_choice_violation_panics() {
+fn test_non_liveness_rejects_free_choice_violation() {
     // t0 has preset {s0}, t1 has preset {s0, s1} -- they share s0 but have different presets
-    NonLivenessFreePetriNet::new(
+    assert!(NonLivenessFreePetriNet::new(
         2,
         2,
         vec![(0, 0), (0, 1), (1, 1)],
         vec![(0, 0), (1, 1)],
         vec![1, 1],
-    );
+    )
+    .is_err());
 }
diff --git a/src/unit_tests/models/misc/numerical_3_dimensional_matching.rs b/src/unit_tests/models/misc/numerical_3_dimensional_matching.rs
index 8c9e5d551..aa0f97684 100644
--- a/src/unit_tests/models/misc/numerical_3_dimensional_matching.rs
+++ b/src/unit_tests/models/misc/numerical_3_dimensional_matching.rs
@@ -1,5 +1,6 @@
 use crate::models::misc::Numerical3DimensionalMatching;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -17,7 +18,7 @@ fn test_numerical_3dm_creation() {
     assert_eq!(problem.sizes_y(), &[5, 7]);
     assert_eq!(problem.bound(), 15);
     assert_eq!(problem.num_groups(), 2);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(problem.num_variables(), 4);
     assert_eq!(
         <Numerical3DimensionalMatching as Problem>::NAME,
@@ -33,60 +34,64 @@ fn test_numerical_3dm_creation() {
 fn test_numerical_3dm_evaluate_valid() {
     let problem = yes_problem();
     // config [0, 1, 1, 0]: w0↔x0,y1 (4+4+7=15), w1↔x1,y0 (5+5+5=15)
-    assert_eq!(problem.evaluate(&[0, 1, 1, 0]), Or(true));
+    assert_eq!(problem.evaluate(&vec![0, 1, 1, 0]).unwrap(), Or(true));
 }
 
 #[test]
 fn test_numerical_3dm_evaluate_invalid_sums() {
     let problem = yes_problem();
     // config [0, 1, 0, 1]: w0↔x0,y0 (4+4+5=13≠15)
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 1, 0, 1]).unwrap(), Or(false));
     // config [1, 0, 0, 1]: w0↔x1,y0 (4+5+5=14≠15)
-    assert_eq!(problem.evaluate(&[1, 0, 0, 1]), Or(false));
+    assert_eq!(problem.evaluate(&vec![1, 0, 0, 1]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_numerical_3dm_evaluate_invalid_permutation() {
     let problem = yes_problem();
     // Both X assignments point to 0 — not a permutation
-    assert_eq!(problem.evaluate(&[0, 0, 0, 1]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 0, 0, 1]).unwrap(), Or(false));
     // Both Y assignments point to 1 — not a permutation
-    assert_eq!(problem.evaluate(&[0, 1, 1, 1]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 1, 1, 1]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_numerical_3dm_evaluate_wrong_length() {
     let problem = yes_problem();
-    assert_eq!(problem.evaluate(&[0, 1, 1]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 1, 1, 0, 0]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 1, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_numerical_3dm_evaluate_out_of_range() {
     let problem = yes_problem();
     // Index 2 is out of range for m=2
-    assert_eq!(problem.evaluate(&[0, 2, 1, 0]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_numerical_3dm_solver_finds_witness() {
     let problem = yes_problem();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Or(true));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Or(true));
 }
 
 #[test]
 fn test_numerical_3dm_solver_unsatisfiable() {
-    // W=[4,5], X=[4,6], Y=[5,7], B=15 — total=31≠30, invalid
-    // Need a valid instance that is unsatisfiable.
-    // W=[4,5], X=[4,5], Y=[4,7], B=15 — total=4+5+4+5+4+7=29≠30, invalid.
-    // W=[4,6], X=[4,6], Y=[4,6], B=15 — total=4+6+4+6+4+6=30=2*15, all between 3.75 and 7.5.
-    // Check: w0↔x0,y0: 4+4+4=12≠15; w0↔x0,y1: 4+4+6=14≠15; w0↔x1,y0: 4+6+4=14≠15; w0↔x1,y1: 4+6+6=16≠15
-    // No valid matching exists!
+    // The total is 2*15, but three even sizes cannot sum to 15.
     let problem = Numerical3DimensionalMatching::new(vec![4, 6], vec![4, 6], vec![4, 6], 15);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -134,13 +139,20 @@ fn test_numerical_3dm_deserialization_rejects_invalid() {
             "sizes_y": [5, 7],
             "bound": 15,
         }),
-        // Size outside B/4..B/2 range
+        // Negative size, despite a balanced total
         serde_json::json!({
-            "sizes_w": [3, 5],
+            "sizes_w": [-1, 5],
             "sizes_x": [4, 5],
-            "sizes_y": [5, 8],
+            "sizes_y": [5, 12],
             "bound": 15,
         }),
+        // Nonpositive bound
+        serde_json::json!({
+            "sizes_w": [1], "sizes_x": [1], "sizes_y": [1], "bound": 0,
+        }),
+        serde_json::json!({
+            "sizes_w": [-1], "sizes_x": [-1], "sizes_y": [-1], "bound": -3,
+        }),
         // Wrong total sum
         serde_json::json!({
             "sizes_w": [4, 5],
@@ -174,9 +186,16 @@ fn test_numerical_3dm_zero_size_panics() {
 }
 
 #[test]
-#[should_panic(expected = "strictly between")]
-fn test_numerical_3dm_size_outside_bounds_panics() {
-    Numerical3DimensionalMatching::new(vec![3, 5], vec![4, 5], vec![5, 8], 15);
+fn test_numerical_3dm_accepts_unrestricted_positive_sizes() {
+    for problem in [
+        Numerical3DimensionalMatching::new(vec![1, 2], vec![2, 3], vec![12, 10], 15),
+        Numerical3DimensionalMatching::new(vec![i64::MAX - 2], vec![1], vec![1], i64::MAX),
+    ] {
+        let restored: Numerical3DimensionalMatching =
+            serde_json::from_value(serde_json::to_value(&problem).unwrap()).unwrap();
+        let witness = BruteForce::new().solve(&restored).unwrap().unwrap();
+        assert_eq!(restored.evaluate(&witness).unwrap(), Or(true));
+    }
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/numerical_matching_with_target_sums.rs b/src/unit_tests/models/misc/numerical_matching_with_target_sums.rs
index ccde8a8c1..c2eb0221e 100644
--- a/src/unit_tests/models/misc/numerical_matching_with_target_sums.rs
+++ b/src/unit_tests/models/misc/numerical_matching_with_target_sums.rs
@@ -1,5 +1,6 @@
 use crate::models::misc::NumericalMatchingWithTargetSums;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -16,7 +17,7 @@ fn test_nmts_creation() {
     assert_eq!(problem.sizes_y(), &[2, 5, 3]);
     assert_eq!(problem.targets(), &[3, 7, 12]);
     assert_eq!(problem.num_pairs(), 3);
-    assert_eq!(problem.dims(), vec![3; 3]);
+    assert_eq!(problem.dimensions(), vec![3; 3]);
     assert_eq!(problem.num_variables(), 3);
     assert_eq!(
         <NumericalMatchingWithTargetSums as Problem>::NAME,
@@ -32,40 +33,49 @@ fn test_nmts_creation() {
 fn test_nmts_evaluate_valid() {
     let problem = yes_problem();
     // config [0,2,1] → sums: 1+2=3, 4+3=7, 7+5=12 → multiset {3,7,12} = targets
-    assert_eq!(problem.evaluate(&[0, 2, 1]), Or(true));
+    assert_eq!(problem.evaluate(&vec![0, 2, 1]).unwrap(), Or(true));
 }
 
 #[test]
 fn test_nmts_evaluate_invalid_sums() {
     let problem = yes_problem();
     // config [0,1,2] → sums: 1+2=3, 4+5=9, 7+3=10 → multiset {3,9,10} ≠ {3,7,12}
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2]).unwrap(), Or(false));
     // config [1,0,2] → sums: 1+5=6, 4+2=6, 7+3=10 → multiset {6,6,10} ≠ {3,7,12}
-    assert_eq!(problem.evaluate(&[1, 0, 2]), Or(false));
+    assert_eq!(problem.evaluate(&vec![1, 0, 2]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_nmts_evaluate_invalid_permutation() {
     let problem = yes_problem();
     // Duplicate index — not a permutation
-    assert_eq!(problem.evaluate(&[0, 0, 1]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 0, 1]).unwrap(), Or(false));
     // Index out of range
-    assert_eq!(problem.evaluate(&[0, 1, 3]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_nmts_evaluate_wrong_length() {
     let problem = yes_problem();
-    assert_eq!(problem.evaluate(&[0, 1]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 0]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_nmts_solver_finds_witness() {
     let problem = yes_problem();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Or(true));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Or(true));
 }
 
 #[test]
@@ -74,7 +84,7 @@ fn test_nmts_solver_unsatisfiable() {
     // Possible sums: {1+3,2+4}={4,6} or {1+4,2+3}={5,5}, neither is {10,20}
     let problem = NumericalMatchingWithTargetSums::new(vec![1, 2], vec![3, 4], vec![10, 20]);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/open_shop_scheduling.rs b/src/unit_tests/models/misc/open_shop_scheduling.rs
index 2c493cdac..a80a35455 100644
--- a/src/unit_tests/models/misc/open_shop_scheduling.rs
+++ b/src/unit_tests/models/misc/open_shop_scheduling.rs
@@ -1,18 +1,33 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
 /// 2 machines, 2 jobs: smallest non-trivial instance.
 /// processing_times[j][i]: J1=[1,2], J2=[2,1]
-/// All four orderings give the same makespan = 3 (symmetric).
+/// A two-by-two instance with an optimal makespan of 3.
 fn two_by_two() -> OpenShopScheduling {
     OpenShopScheduling::new(2, vec![vec![1, 2], vec![2, 1]])
 }
 
-/// 3 machines, 3 jobs: a small asymmetric instance.
-fn three_by_three() -> OpenShopScheduling {
-    OpenShopScheduling::new(3, vec![vec![1, 2, 3], vec![3, 2, 1], vec![2, 1, 2]])
+#[test]
+fn test_open_shop_create_spec_uses_num_processors_input() {
+    assert_eq!(
+        OpenShopSchedulingCreateSpec::FIELDS[0].name,
+        "num_processors"
+    );
+    let problem = OpenShopScheduling::try_from(OpenShopSchedulingCreateSpec {
+        num_processors: 2,
+        processing_times: vec![vec![1, 2]],
+    })
+    .unwrap();
+    assert_eq!(problem.num_machines(), 2);
+}
+
+/// Two jobs on one machine: a small brute-force instance.
+fn small_asymmetric() -> OpenShopScheduling {
+    OpenShopScheduling::new(1, vec![vec![2], vec![3]])
 }
 
 /// Issue #506 example: 4 jobs × 3 machines, true optimal makespan = 8.
@@ -34,7 +49,7 @@ fn test_open_shop_scheduling_creation() {
     assert_eq!(
         p.processing_times(),
         &[
-            vec![3usize, 1, 2],
+            vec![3_i64, 1, 2],
             vec![2, 3, 1],
             vec![1, 2, 3],
             vec![2, 2, 1],
@@ -45,11 +60,10 @@ fn test_open_shop_scheduling_creation() {
 #[test]
 fn test_open_shop_scheduling_dims() {
     let p = issue_example();
-    // n = 4 jobs, m = 3 machines → n*m = 12 config variables, each in 0..4
-    assert_eq!(p.dims(), vec![4usize; 12]);
+    assert_eq!(p.dimensions(), vec![24usize; 12]);
 
     let p2 = two_by_two();
-    assert_eq!(p2.dims(), vec![2usize; 4]);
+    assert_eq!(p2.dimensions(), vec![7usize; 4]);
 }
 
 // ─── evaluate ────────────────────────────────────────────────────────────────
@@ -57,55 +71,56 @@ fn test_open_shop_scheduling_dims() {
 #[test]
 fn test_open_shop_scheduling_evaluate_issue_example_optimal() {
     let p = issue_example();
-    // Optimal config: M1=[0,1,2,3], M2=[1,0,3,2], M3=[2,3,0,1]
-    // True optimal makespan = 8 (the issue body incorrectly claimed 11).
-    let config = vec![0, 1, 2, 3, 1, 0, 3, 2, 2, 3, 0, 1];
-    assert_eq!(p.evaluate(&config), Min(Some(8)));
+    // Job-major start times for a schedule with makespan 8.
+    let config = vec![0, 3, 4, 3, 0, 6, 5, 6, 0, 6, 4, 3];
+    assert_eq!(p.evaluate(&config).unwrap(), Min(Some(8)));
 }
 
 #[test]
 fn test_open_shop_scheduling_evaluate_issue_example_suboptimal_schedule() {
     let p = issue_example();
-    // The schedule from the issue body: M1=[2,1,0,3], M2=[2,1,0,3], M3=[2,0,1,3]
-    // gives makespan 11, which is valid but not optimal (optimal is 8).
-    let config = vec![2, 1, 0, 3, 2, 1, 0, 3, 2, 0, 1, 3];
-    let value = p.evaluate(&config);
+    let config = vec![3, 6, 7, 1, 3, 9, 0, 1, 3, 6, 8, 10];
+    let value = p.evaluate(&config).unwrap();
     assert_eq!(value, Min(Some(11)));
 }
 
 #[test]
 fn test_open_shop_scheduling_evaluate_suboptimal() {
     let p = issue_example();
-    // Identity orderings on all machines: M1=[0,1,2,3], M2=[0,1,2,3], M3=[0,1,2,3]
-    let config = vec![0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3];
-    let value = p.evaluate(&config);
+    let config = vec![0, 3, 4, 3, 5, 8, 5, 8, 10, 6, 10, 13];
+    let value = p.evaluate(&config).unwrap();
     // Must be valid and > 8 (non-optimal)
     assert!(value.0.is_some());
     assert!(value.0.unwrap() > 8);
 }
 
 #[test]
-fn test_open_shop_scheduling_evaluate_invalid_not_permutation() {
+fn test_open_shop_scheduling_evaluate_overlapping_operations() {
     let p = issue_example();
-    // config[0..4] = [0,0,0,0] is not a permutation → invalid
-    let config = vec![0, 0, 0, 0, 0, 1, 2, 3, 0, 1, 2, 3];
-    assert_eq!(p.evaluate(&config), Min(None));
+    let config = vec![0; 12];
+    assert_eq!(p.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_open_shop_scheduling_evaluate_wrong_length() {
     let p = issue_example();
     // Too short
-    assert_eq!(p.evaluate(&[0, 1, 2]), Min(None));
+    assert!(matches!(
+        p.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Too long
-    assert_eq!(p.evaluate(&[0; 13]), Min(None));
+    assert!(matches!(
+        p.evaluate(&vec![0; 13]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_open_shop_scheduling_evaluate_empty() {
     let p = OpenShopScheduling::new(3, vec![]);
-    assert_eq!(p.dims(), Vec::<usize>::new());
-    assert_eq!(p.evaluate(&[]), Min(Some(0)));
+    assert_eq!(p.dimensions(), Vec::<usize>::new());
+    assert_eq!(p.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -120,10 +135,10 @@ fn test_open_shop_scheduling_evaluate_two_by_two() {
     //   Step 3: M1 done, M2 next is J1 (start=max(0,1)=1), schedule J1 on M2: [1,3), machine_avail[1]=3, job_avail[0]=3
     //   Step 4: M2 next is J2 (start=max(3,3)=3), schedule J2 on M2: [3,4), machine_avail[1]=4, job_avail[1]=4
     // Makespan = 4
-    let config = vec![0, 1, 0, 1];
-    let val = p.evaluate(&config);
+    let config = vec![0, 1, 1, 0];
+    let val = p.evaluate(&config).unwrap();
     assert!(val.0.is_some());
-    assert_eq!(val, Min(Some(4)));
+    assert_eq!(val, Min(Some(3)));
 }
 
 // ─── decode_orders ───────────────────────────────────────────────────────────
@@ -131,23 +146,19 @@ fn test_open_shop_scheduling_evaluate_two_by_two() {
 #[test]
 fn test_open_shop_scheduling_decode_orders_valid() {
     let p = two_by_two();
-    let config = vec![0, 1, 1, 0];
-    let orders = p.decode_orders(&config).unwrap();
-    assert_eq!(orders, vec![vec![0, 1], vec![1, 0]]);
+    assert_eq!(p.evaluate(&vec![0, 1, 1, 0]).unwrap(), Min(Some(3)));
 }
 
 #[test]
 fn test_open_shop_scheduling_decode_orders_invalid_duplicate() {
     let p = two_by_two();
-    let config = vec![0, 0, 1, 0]; // first machine has duplicate 0
-    assert!(p.decode_orders(&config).is_none());
+    assert_eq!(p.evaluate(&vec![0, 1, 0, 3]).unwrap(), Min(None));
 }
 
 #[test]
 fn test_open_shop_scheduling_decode_orders_invalid_out_of_range() {
     let p = two_by_two();
-    let config = vec![0, 2, 1, 0]; // job 2 out of range for n=2
-    assert!(p.decode_orders(&config).is_none());
+    assert_eq!(p.evaluate(&vec![0, 0, 1, 3]).unwrap(), Min(None));
 }
 
 // ─── compute_makespan ────────────────────────────────────────────────────────
@@ -155,26 +166,15 @@ fn test_open_shop_scheduling_decode_orders_invalid_out_of_range() {
 #[test]
 fn test_open_shop_scheduling_compute_makespan_optimal_schedule() {
     let p = issue_example();
-    // True optimal: M1=[0,1,2,3], M2=[1,0,3,2], M3=[2,3,0,1], makespan=8
-    let orders = vec![
-        vec![0, 1, 2, 3], // M1
-        vec![1, 0, 3, 2], // M2
-        vec![2, 3, 0, 1], // M3
-    ];
-    assert_eq!(p.compute_makespan(&orders), 8);
+    let starts = vec![0, 3, 4, 3, 0, 6, 5, 6, 0, 6, 4, 3];
+    assert_eq!(p.evaluate(&starts).unwrap(), Min(Some(8)));
 }
 
 #[test]
 fn test_open_shop_scheduling_compute_makespan_issue_example_schedule() {
     let p = issue_example();
-    // The schedule from the issue body: makespan=11 (valid but suboptimal)
-    let orders = vec![vec![2, 1, 0, 3], vec![2, 1, 0, 3], vec![2, 0, 1, 3]];
-    // Manually verified start/finish times:
-    // J1: M1=[3,6), M2=[6,7), M3=[7,9)
-    // J2: M1=[1,3), M2=[3,6), M3=[9,10)
-    // J3: M1=[0,1), M2=[1,3), M3=[3,6)
-    // J4: M1=[6,8), M2=[8,10), M3=[10,11)
-    assert_eq!(p.compute_makespan(&orders), 11);
+    let starts = vec![3, 6, 7, 1, 3, 9, 0, 1, 3, 6, 8, 10];
+    assert_eq!(p.evaluate(&starts).unwrap(), Min(Some(11)));
 }
 
 // ─── problem trait ───────────────────────────────────────────────────────────
@@ -204,29 +204,69 @@ fn test_open_shop_scheduling_brute_force_small() {
     // 2x2 instance: brute force over 2^4 = 16 configs (4 valid schedules)
     let p = two_by_two();
     let solver = BruteForce::new();
-    let value = Solver::solve(&solver, &p);
+    let value_solution = solver.solve(&p).unwrap().unwrap();
+    let value = p.evaluate(&value_solution).unwrap();
     assert!(value.0.is_some());
     // Optimal value for this instance
     assert_eq!(value, Min(Some(3)));
-    let witness = solver.find_witness(&p).unwrap();
-    assert_eq!(p.evaluate(&witness), Min(Some(3)));
+    let witness = solver.solve(&p).unwrap().unwrap();
+    assert_eq!(p.evaluate(&witness).unwrap(), Min(Some(3)));
 }
 
 #[test]
 fn test_open_shop_scheduling_brute_force_medium() {
-    // 3x3 instance: brute force over 3^9 = 19683 configs (216 valid schedules)
-    let p = three_by_three();
+    // Small start-time domain keeps exhaustive solving bounded.
+    let p = small_asymmetric();
     let solver = BruteForce::new();
-    let value = Solver::solve(&solver, &p);
+    let value_solution = solver.solve(&p).unwrap().unwrap();
+    let value = p.evaluate(&value_solution).unwrap();
     assert!(value.0.is_some());
-    let witness = solver.find_witness(&p).unwrap();
-    assert_eq!(p.evaluate(&witness), value);
+    let witness = solver.solve(&p).unwrap().unwrap();
+    assert_eq!(p.evaluate(&witness).unwrap(), value);
 }
 
 #[test]
 fn test_open_shop_scheduling_canonical_example_config_is_optimal() {
     // Verify that the canonical example config achieves the true optimal makespan = 8
     let p = issue_example();
-    let optimal_config = vec![0, 1, 2, 3, 1, 0, 3, 2, 2, 3, 0, 1];
-    assert_eq!(p.evaluate(&optimal_config), Min(Some(8)));
+    let optimal_config = vec![0, 3, 4, 3, 0, 6, 5, 6, 0, 6, 4, 3];
+    assert_eq!(p.evaluate(&optimal_config).unwrap(), Min(Some(8)));
+}
+
+#[test]
+fn test_open_shop_scheduling_construction_paths_reject_invalid_matrices() {
+    for (machines, times) in [
+        (2, vec![vec![1]]),
+        (1, vec![vec![-1]]),
+        (2, vec![vec![i64::MAX, 1]]),
+    ] {
+        assert!(OpenShopScheduling::try_new(machines, times.clone()).is_err());
+        assert!(OpenShopScheduling::try_from(OpenShopSchedulingCreateSpec {
+            num_processors: machines,
+            processing_times: times.clone(),
+        })
+        .is_err());
+        assert!(
+            serde_json::from_value::<OpenShopScheduling>(serde_json::json!({
+                "num_machines": machines, "processing_times": times,
+            }))
+            .is_err()
+        );
+    }
+}
+
+#[test]
+fn test_open_shop_scheduling_construction_overflow_is_typed() {
+    let times = vec![vec![i64::MAX, 1]];
+    assert!(matches!(
+        OpenShopScheduling::try_new(2, times.clone()),
+        Err(crate::registry::ConstructionError::IntegerOverflow(_))
+    ));
+    assert!(matches!(
+        OpenShopScheduling::try_from(OpenShopSchedulingCreateSpec {
+            num_processors: 2,
+            processing_times: times,
+        }),
+        Err(crate::registry::ConstructionError::IntegerOverflow(_))
+    ));
 }
diff --git a/src/unit_tests/models/misc/optimum_communication_spanning_tree.rs b/src/unit_tests/models/misc/optimum_communication_spanning_tree.rs
index a354ec3aa..ef3555fd7 100644
--- a/src/unit_tests/models/misc/optimum_communication_spanning_tree.rs
+++ b/src/unit_tests/models/misc/optimum_communication_spanning_tree.rs
@@ -1,4 +1,17 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_edge_weights() {
+    let p =
+        OptimumCommunicationSpanningTree::try_from(OptimumCommunicationSpanningTreeCreateSpec {
+            num_vertices: 2,
+            edge_weights: None,
+            requirements: vec![vec![0, 1], vec![1, 0]],
+        })
+        .unwrap();
+    assert_eq!(p.edge_weights(), &[vec![0, 1], vec![1, 0]]);
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
@@ -23,7 +36,7 @@ fn test_ocst_creation() {
     let problem = k4_problem();
     assert_eq!(problem.num_vertices(), 4);
     assert_eq!(problem.num_edges(), 6);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert_eq!(
         <OptimumCommunicationSpanningTree as Problem>::NAME,
         "OptimumCommunicationSpanningTree"
@@ -61,7 +74,12 @@ fn test_ocst_evaluate_optimal() {
     //   W(0,1) = 1, W(0,2) = 2+1 = 3, W(0,3) = 2
     //   W(1,2) = 1+2+1 = 4, W(1,3) = 1+2 = 3, W(2,3) = 1
     // Total = 1*2 + 3*1 + 2*3 + 4*1 + 3*1 + 1*2 = 2+3+6+4+3+2 = 20
-    assert_eq!(problem.evaluate(&[1, 0, 1, 0, 0, 1]), Min(Some(20)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, true, false, false, true])
+            .unwrap(),
+        Min(Some(20))
+    );
 }
 
 #[test]
@@ -73,20 +91,42 @@ fn test_ocst_evaluate_suboptimal() {
     //   W(0,1) = 1, W(0,2) = 1+2 = 3, W(0,3) = 1+2+1 = 4
     //   W(1,2) = 2, W(1,3) = 2+1 = 3, W(2,3) = 1
     // Total = 1*2 + 3*1 + 4*3 + 2*1 + 3*1 + 1*2 = 2+3+12+2+3+2 = 24
-    assert_eq!(problem.evaluate(&[1, 0, 0, 1, 0, 1]), Min(Some(24)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, true, false, true])
+            .unwrap(),
+        Min(Some(24))
+    );
 }
 
 #[test]
 fn test_ocst_evaluate_invalid() {
     let problem = k4_problem();
     // Wrong number of edges
-    assert_eq!(problem.evaluate(&[1, 0, 1]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Too many edges (not a tree)
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1, 0, 1]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, true, false, true])
+            .unwrap(),
+        Min(None)
+    );
     // Not connected (two separate edges)
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0, 0, 1]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, false, false, true])
+            .unwrap(),
+        Min(None)
+    );
     // Value > 1
-    assert_eq!(problem.evaluate(&[2, 0, 1, 0, 0, 0]), Min(None));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, false, true, false, false, false])
+    )
+    .is_err());
 }
 
 #[test]
@@ -94,9 +134,10 @@ fn test_ocst_solver() {
     let problem = k4_problem();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let value = problem.evaluate(&solution);
+    let value = problem.evaluate(&solution).unwrap();
     assert_eq!(value, Min(Some(20)));
 }
 
@@ -121,15 +162,24 @@ fn test_ocst_k3_equal_requirements() {
     assert_eq!(problem.num_edges(), 3);
 
     // Tree {(0,1), (0,2)}: W(0,1)=1, W(0,2)=2, W(1,2)=1+2=3, cost = 1+2+3 = 6
-    assert_eq!(problem.evaluate(&[1, 1, 0]), Min(Some(6)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false]).unwrap(),
+        Min(Some(6))
+    );
     // Tree {(0,1), (1,2)}: W(0,1)=1, W(0,2)=1+3=4, W(1,2)=3, cost = 1+4+3 = 8
-    assert_eq!(problem.evaluate(&[1, 0, 1]), Min(Some(8)));
+    assert_eq!(
+        problem.evaluate(&vec![true, false, true]).unwrap(),
+        Min(Some(8))
+    );
     // Tree {(0,2), (1,2)}: W(0,1)=2+3=5, W(0,2)=2, W(1,2)=3, cost = 5+2+3 = 10
-    assert_eq!(problem.evaluate(&[0, 1, 1]), Min(Some(10)));
+    assert_eq!(
+        problem.evaluate(&vec![false, true, true]).unwrap(),
+        Min(Some(10))
+    );
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Min(Some(6)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -163,6 +213,9 @@ fn test_ocst_canonical_example() {
     assert_eq!(specs.len(), 1);
     let spec = &specs[0];
     assert_eq!(spec.id, "optimum_communication_spanning_tree");
-    assert_eq!(spec.optimal_config, vec![1, 0, 1, 0, 0, 1]);
+    assert_eq!(
+        spec.optimal_config,
+        serde_json::json!([true, false, true, false, false, true])
+    );
     assert_eq!(spec.optimal_value, serde_json::json!(20));
 }
diff --git a/src/unit_tests/models/misc/paintshop.rs b/src/unit_tests/models/misc/paintshop.rs
index 6469f3118..93fce4912 100644
--- a/src/unit_tests/models/misc/paintshop.rs
+++ b/src/unit_tests/models/misc/paintshop.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 include!("../../jl_helpers.rs");
 
@@ -24,12 +25,21 @@ fn test_get_coloring() {
     let problem = PaintShop::new(vec!["a", "b", "a", "b"]);
     // Config: a=0, b=1
     // Sequence: a(0), b(1), a(1-opposite), b(0-opposite)
-    let coloring = problem.get_coloring(&[0, 1]);
-    assert_eq!(coloring, vec![0, 1, 1, 0]);
+    let coloring = problem.get_coloring(&[false, true]).unwrap();
+    assert_eq!(coloring, vec![false, true, true, false]);
 
     // Config: a=1, b=0
-    let coloring = problem.get_coloring(&[1, 0]);
-    assert_eq!(coloring, vec![1, 0, 0, 1]);
+    let coloring = problem.get_coloring(&[true, false]).unwrap();
+    assert_eq!(coloring, vec![true, false, false, true]);
+}
+
+#[test]
+fn test_get_coloring_rejects_wrong_assignment_length() {
+    let problem = PaintShop::new(vec!["a", "b", "a", "b"]);
+    assert!(matches!(
+        problem.get_coloring(&[false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -37,21 +47,21 @@ fn test_count_switches() {
     let problem = PaintShop::new(vec!["a", "b", "a", "b"]);
 
     // Config [0, 1] -> coloring [0, 1, 1, 0] -> 2 switches
-    assert_eq!(problem.count_switches(&[0, 1]), 2);
+    assert_eq!(problem.count_switches(&[false, true]).unwrap(), 2);
 
     // Config [0, 0] -> coloring [0, 0, 1, 1] -> 1 switch
-    assert_eq!(problem.count_switches(&[0, 0]), 1);
+    assert_eq!(problem.count_switches(&[false, false]).unwrap(), 1);
 
     // Config [1, 1] -> coloring [1, 1, 0, 0] -> 1 switch
-    assert_eq!(problem.count_switches(&[1, 1]), 1);
+    assert_eq!(problem.count_switches(&[true, true]).unwrap(), 1);
 }
 
 #[test]
 fn test_count_paint_switches_function() {
-    assert_eq!(count_paint_switches(&[0, 0, 0]), 0);
-    assert_eq!(count_paint_switches(&[0, 1, 0]), 2);
-    assert_eq!(count_paint_switches(&[0, 0, 1, 1]), 1);
-    assert_eq!(count_paint_switches(&[0, 1, 0, 1]), 3);
+    assert_eq!(count_paint_switches(&[false, false, false]), 0);
+    assert_eq!(count_paint_switches(&[false, true, false]), 2);
+    assert_eq!(count_paint_switches(&[false, false, true, true]), 1);
+    assert_eq!(count_paint_switches(&[false, true, false, true]), 3);
 }
 
 #[test]
@@ -59,11 +69,11 @@ fn test_single_car() {
     let problem = PaintShop::new(vec!["a", "a"]);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // Both configs give 1 switch: a(0)->a(1) or a(1)->a(0)
     assert_eq!(solutions.len(), 2);
     for sol in &solutions {
-        assert_eq!(problem.count_switches(sol), 1);
+        assert_eq!(problem.count_switches(sol).unwrap(), 1);
     }
 }
 
@@ -73,11 +83,11 @@ fn test_adjacent_same_car() {
     let problem = PaintShop::new(vec!["a", "a", "b", "b"]);
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // Best case: [0,0] -> [0,1,0,1] = 3 switches, or [0,1] -> [0,1,1,0] = 2 switches
     // Actually: [0,0] -> a=0,a=1,b=0,b=1 = [0,1,0,1] = 3 switches
     // [0,1] -> a=0,a=1,b=1,b=0 = [0,1,1,0] = 2 switches
-    let min_switches = problem.count_switches(&solutions[0]);
+    let min_switches = problem.count_switches(&solutions[0]).unwrap();
     assert!(min_switches <= 3);
 }
 
@@ -107,9 +117,9 @@ fn test_jl_parity_evaluation() {
             .collect();
         let problem = PaintShop::new(sequence);
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config);
-            let jl_size = eval["size"].as_i64().unwrap() as i32;
+            let config = jl_parse_bool_config(&eval["config"]);
+            let result = problem.evaluate(&config).unwrap();
+            let jl_size = eval["size"].as_i64().unwrap();
             assert_eq!(
                 result.unwrap(),
                 jl_size,
@@ -117,15 +127,15 @@ fn test_jl_parity_evaluation() {
                 config
             );
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best: HashSet<Vec<bool>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "PaintShop best solutions mismatch");
     }
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     let problem = PaintShop::new(vec!["a", "b", "a", "b"]);
     assert_eq!(problem.num_sequence(), 4);
     assert_eq!(problem.num_cars(), 2);
@@ -141,6 +151,6 @@ fn test_paintshop_paper_example() {
     // Config [0, 0, 1]: A first=0, B first=0, C first=1
     // Coloring: A(0), B(0), A(1), C(1), B(1), C(0) -> [0,0,1,1,1,0] -> 2 switches
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 2);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 2);
 }
diff --git a/src/unit_tests/models/misc/partially_ordered_knapsack.rs b/src/unit_tests/models/misc/partially_ordered_knapsack.rs
index 9c8f907f2..58794aeaf 100644
--- a/src/unit_tests/models/misc/partially_ordered_knapsack.rs
+++ b/src/unit_tests/models/misc/partially_ordered_knapsack.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 /// Helper: create the example instance from the issue.
@@ -28,7 +29,7 @@ fn test_partially_ordered_knapsack_basic() {
         &[(0, 2), (0, 3), (1, 4), (3, 5), (4, 5)]
     );
     assert_eq!(problem.capacity(), 11);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert_eq!(
         <PartiallyOrderedKnapsack as Problem>::NAME,
         "PartiallyOrderedKnapsack"
@@ -42,7 +43,12 @@ fn test_partially_ordered_knapsack_evaluate_valid() {
     // U' = {a, b, d, e, f} = indices {0, 1, 3, 4, 5}
     // Total size: 2+3+1+2+3 = 11 <= 11
     // Total value: 3+2+4+3+8 = 20
-    assert_eq!(problem.evaluate(&[1, 1, 0, 1, 1, 1]), Max(Some(20)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, false, true, true, true])
+            .unwrap(),
+        Max(Some(20))
+    );
 }
 
 #[test]
@@ -50,7 +56,12 @@ fn test_partially_ordered_knapsack_evaluate_precedence_violation() {
     let problem = example_instance();
     // U' = {d, f} = indices {3, 5} — f requires e and b (transitively), d requires a
     // Not downward-closed: d selected but a (predecessor of d) not selected
-    assert_eq!(problem.evaluate(&[0, 0, 0, 1, 0, 1]), Max(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, false, false, true, false, true])
+            .unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
@@ -59,7 +70,12 @@ fn test_partially_ordered_knapsack_evaluate_transitive_precedence_violation() {
     // U' = {d, e, f} = indices {3, 4, 5}
     // f requires d (ok) and e (ok), but d requires a (0) which is not selected
     // Also e requires b (1) which is not selected
-    assert_eq!(problem.evaluate(&[0, 0, 0, 1, 1, 1]), Max(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, false, false, true, true, true])
+            .unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
@@ -67,20 +83,35 @@ fn test_partially_ordered_knapsack_evaluate_overweight() {
     let problem = example_instance();
     // U' = {a, b, c, d, e, f} = all items
     // Total size: 2+3+4+1+2+3 = 15 > 11
-    assert_eq!(problem.evaluate(&[1, 1, 1, 1, 1, 1]), Max(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, true, true, true])
+            .unwrap(),
+        Max(None)
+    );
 }
 
 #[test]
 fn test_partially_ordered_knapsack_evaluate_empty() {
     let problem = example_instance();
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0, 0]), Max(Some(0)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, false, false, false, false, false])
+            .unwrap(),
+        Max(Some(0))
+    );
 }
 
 #[test]
 fn test_partially_ordered_knapsack_evaluate_single_root() {
     let problem = example_instance();
     // Just item a (no predecessors)
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0, 0, 0]), Max(Some(3)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, false, false, false])
+            .unwrap(),
+        Max(Some(3))
+    );
 }
 
 #[test]
@@ -89,20 +120,35 @@ fn test_partially_ordered_knapsack_evaluate_valid_chain() {
     // U' = {a, d} = indices {0, 3}
     // a has no predecessors, d's predecessor a is selected: downward-closed
     // Total size: 2+1 = 3 <= 11, Total value: 3+4 = 7
-    assert_eq!(problem.evaluate(&[1, 0, 0, 1, 0, 0]), Max(Some(7)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, false, true, false, false])
+            .unwrap(),
+        Max(Some(7))
+    );
 }
 
 #[test]
 fn test_partially_ordered_knapsack_evaluate_wrong_config_length() {
     let problem = example_instance();
-    assert_eq!(problem.evaluate(&[1, 0]), Max(None));
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0, 0, 0, 0]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false, false, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_partially_ordered_knapsack_evaluate_invalid_variable_value() {
     let problem = example_instance();
-    assert_eq!(problem.evaluate(&[2, 0, 0, 0, 0, 0]), Max(None));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, false, false, false, false, false])
+    )
+    .is_err());
 }
 
 #[test]
@@ -110,9 +156,10 @@ fn test_partially_ordered_knapsack_brute_force() {
     let problem = example_instance();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     // The optimal should be {a, b, d, e, f} with value 20
     assert_eq!(metric, Max(Some(20)));
 }
@@ -122,8 +169,8 @@ fn test_partially_ordered_knapsack_empty_instance() {
     let problem = PartiallyOrderedKnapsack::new(vec![], vec![], vec![], 10);
     assert_eq!(problem.num_items(), 0);
     assert_eq!(problem.num_precedences(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert_eq!(problem.evaluate(&[]), Max(Some(0)));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -132,9 +179,10 @@ fn test_partially_ordered_knapsack_no_precedences() {
     let problem = PartiallyOrderedKnapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], vec![], 7);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     // Same as standard knapsack: items 0 and 3 give weight 7, value 10
     assert_eq!(metric, Max(Some(10)));
 }
@@ -142,11 +190,11 @@ fn test_partially_ordered_knapsack_no_precedences() {
 #[test]
 fn test_partially_ordered_knapsack_zero_capacity() {
     let problem = PartiallyOrderedKnapsack::new(vec![1, 2], vec![10, 20], vec![(0, 1)], 0);
-    assert_eq!(problem.evaluate(&[0, 0]), Max(Some(0)));
-    assert_eq!(problem.evaluate(&[1, 0]), Max(None));
+    assert_eq!(problem.evaluate(&vec![false, false]).unwrap(), Max(Some(0)));
+    assert_eq!(problem.evaluate(&vec![true, false]).unwrap(), Max(None));
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Max(Some(0)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -200,3 +248,15 @@ fn test_partially_ordered_knapsack_negative_weight() {
 fn test_partially_ordered_knapsack_negative_value() {
     PartiallyOrderedKnapsack::new(vec![1, 2], vec![-3, 4], vec![], 5);
 }
+#[test]
+fn create_spec_defaults_precedences_to_empty() {
+    let problem = PartiallyOrderedKnapsack::try_from(PartiallyOrderedKnapsackCreateSpec {
+        weights: vec![1, 2],
+        values: vec![3, 4],
+        precedences: None,
+        capacity: 2,
+    })
+    .unwrap();
+    assert!(problem.precedences().is_empty());
+    assert!(!PartiallyOrderedKnapsackCreateSpec::inputs()[2].required);
+}
diff --git a/src/unit_tests/models/misc/partition.rs b/src/unit_tests/models/misc/partition.rs
index 3f031550f..f6a969235 100644
--- a/src/unit_tests/models/misc/partition.rs
+++ b/src/unit_tests/models/misc/partition.rs
@@ -1,94 +1,111 @@
 use crate::models::misc::Partition;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
 fn test_partition_basic() {
-    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]);
+    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
     assert_eq!(problem.num_elements(), 6);
     assert_eq!(problem.sizes(), &[3, 1, 1, 2, 2, 1]);
     assert_eq!(problem.total_sum(), 10);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
 }
 
 #[test]
 fn test_partition_evaluate_satisfying() {
-    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]);
+    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
     // A' = {3, 2} (indices 0, 3), sum = 5 = 10/2
-    assert!(problem.evaluate(&[1, 0, 0, 1, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![true, false, false, true, false, false])
+        .unwrap());
 }
 
 #[test]
 fn test_partition_evaluate_unsatisfying() {
-    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]);
+    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
     // All in first subset, selected sum = 0 != 5
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![false, false, false, false, false, false])
+        .unwrap());
     // All in second subset, selected sum = 10 != 5
-    assert!(!problem.evaluate(&[1, 1, 1, 1, 1, 1]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, true, true, true])
+        .unwrap());
 }
 
 #[test]
 fn test_partition_evaluate_wrong_length() {
-    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    assert!(!problem.evaluate(&[1, 0, 0]));
-    assert!(!problem.evaluate(&[1, 0, 0, 1, 0, 0, 0]));
+    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false, true, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_partition_evaluate_invalid_value() {
-    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    assert!(!problem.evaluate(&[2, 0, 0, 0, 0, 0]));
+    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, false, false, false, false, false])
+    )
+    .is_err());
 }
 
 #[test]
 fn test_partition_odd_total() {
     // Total = 7 (odd), no equal partition possible
-    let problem = Partition::new(vec![3, 1, 2, 1]);
+    let problem = Partition::new(vec![3, 1, 2, 1]).unwrap();
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_partition_solver() {
-    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]);
+    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
 fn test_partition_solver_all() {
-    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]);
+    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // 10 satisfying configs for {3,1,1,2,2,1} with target half-sum 5
     assert_eq!(solutions.len(), 10);
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
 #[test]
 fn test_partition_single_element() {
     // Single element can never be partitioned equally
-    let problem = Partition::new(vec![5]);
+    let problem = Partition::new(vec![5]).unwrap();
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_partition_two_equal_elements() {
-    let problem = Partition::new(vec![4, 4]);
+    let problem = Partition::new(vec![4, 4]).unwrap();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
 fn test_partition_serialization() {
-    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]);
+    let problem = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
     let json = serde_json::to_value(&problem).unwrap();
     let restored: Partition = serde_json::from_value(json).unwrap();
     assert_eq!(restored.sizes(), problem.sizes());
@@ -96,13 +113,11 @@ fn test_partition_serialization() {
 }
 
 #[test]
-#[should_panic(expected = "All sizes must be positive")]
-fn test_partition_zero_size_panics() {
-    Partition::new(vec![3, 0, 1]);
+fn test_partition_rejects_zero_size() {
+    assert!(Partition::new(vec![3, 0, 1]).is_err());
 }
 
 #[test]
-#[should_panic(expected = "at least one element")]
-fn test_partition_empty_panics() {
-    Partition::new(vec![]);
+fn test_partition_rejects_empty_input() {
+    assert!(Partition::new(vec![]).is_err());
 }
diff --git a/src/unit_tests/models/misc/precedence_constrained_scheduling.rs b/src/unit_tests/models/misc/precedence_constrained_scheduling.rs
index 8c30bc4b3..47cf34313 100644
--- a/src/unit_tests/models/misc/precedence_constrained_scheduling.rs
+++ b/src/unit_tests/models/misc/precedence_constrained_scheduling.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -9,7 +10,7 @@ fn test_precedence_constrained_scheduling_basic() {
     assert_eq!(problem.num_processors(), 2);
     assert_eq!(problem.deadline(), 3);
     assert_eq!(problem.precedences(), &[(0, 2), (1, 3)]);
-    assert_eq!(problem.dims(), vec![3; 4]);
+    assert_eq!(problem.dimensions(), vec![3; 4]);
     assert_eq!(
         <PrecedenceConstrainedScheduling as Problem>::NAME,
         "PrecedenceConstrainedScheduling"
@@ -42,34 +43,43 @@ fn test_precedence_constrained_scheduling_evaluate_valid() {
     );
     // Valid schedule: slot 0: {t0, t1}, slot 1: {t2, t3, t4}, slot 2: {t5, t6}, slot 3: {t7}
     let config = vec![0, 0, 1, 1, 1, 2, 2, 3];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_precedence_constrained_scheduling_evaluate_invalid_precedence() {
     // t0 < t1, but we assign both to slot 0
     let problem = PrecedenceConstrainedScheduling::new(2, 2, 3, vec![(0, 1)]);
-    assert!(!problem.evaluate(&[0, 0])); // slot[1] = 0 < slot[0] + 1 = 1
+    assert!(!problem.evaluate(&vec![0, 0]).unwrap()); // slot[1] = 0 < slot[0] + 1 = 1
 }
 
 #[test]
 fn test_precedence_constrained_scheduling_evaluate_invalid_capacity() {
     // 3 tasks, 2 processors, all in slot 0
     let problem = PrecedenceConstrainedScheduling::new(3, 2, 2, vec![]);
-    assert!(!problem.evaluate(&[0, 0, 0])); // 3 tasks in slot 0, capacity 2
+    assert!(!problem.evaluate(&vec![0, 0, 0]).unwrap()); // 3 tasks in slot 0, capacity 2
 }
 
 #[test]
 fn test_precedence_constrained_scheduling_evaluate_wrong_config_length() {
     let problem = PrecedenceConstrainedScheduling::new(3, 2, 3, vec![]);
-    assert!(!problem.evaluate(&[0, 1]));
-    assert!(!problem.evaluate(&[0, 1, 2, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_precedence_constrained_scheduling_evaluate_invalid_variable_value() {
     let problem = PrecedenceConstrainedScheduling::new(2, 2, 3, vec![]);
-    assert!(!problem.evaluate(&[0, 3])); // 3 >= deadline=3
+    assert!(matches!(
+        problem.evaluate(&vec![0, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -78,19 +88,20 @@ fn test_precedence_constrained_scheduling_brute_force() {
     let problem = PrecedenceConstrainedScheduling::new(3, 2, 2, vec![(0, 2)]);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_precedence_constrained_scheduling_brute_force_all() {
     let problem = PrecedenceConstrainedScheduling::new(3, 2, 2, vec![(0, 2)]);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -99,7 +110,7 @@ fn test_precedence_constrained_scheduling_unsatisfiable() {
     // 3 tasks in a chain t0 < t1 < t2, but only deadline 2 (need 3 slots)
     let problem = PrecedenceConstrainedScheduling::new(3, 1, 2, vec![(0, 1), (1, 2)]);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -111,14 +122,15 @@ fn test_precedence_constrained_scheduling_serialization() {
     assert_eq!(restored.num_processors(), problem.num_processors());
     assert_eq!(restored.deadline(), problem.deadline());
     assert_eq!(restored.precedences(), problem.precedences());
+    assert_eq!(restored.num_precedences(), problem.num_precedences());
 }
 
 #[test]
 fn test_precedence_constrained_scheduling_empty() {
     let problem = PrecedenceConstrainedScheduling::new(0, 1, 1, vec![]);
     assert_eq!(problem.num_tasks(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -126,10 +138,24 @@ fn test_precedence_constrained_scheduling_no_precedences() {
     // 4 tasks, 2 processors, deadline 2, no precedences
     let problem = PrecedenceConstrainedScheduling::new(4, 2, 2, vec![]);
     // 2 tasks per slot, 2 slots = 4 tasks
-    assert!(problem.evaluate(&[0, 0, 1, 1]));
+    assert!(problem.evaluate(&vec![0, 0, 1, 1]).unwrap());
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
+}
+#[test]
+fn create_spec_defaults_precedences_to_empty() {
+    let problem =
+        PrecedenceConstrainedScheduling::try_from(PrecedenceConstrainedSchedulingCreateSpec {
+            num_tasks: 2,
+            num_processors: 1,
+            deadline: 2,
+            precedences: None,
+        })
+        .unwrap();
+    assert!(problem.precedences().is_empty());
+    assert!(!PrecedenceConstrainedSchedulingCreateSpec::inputs()[3].required);
 }
diff --git a/src/unit_tests/models/misc/preemptive_scheduling.rs b/src/unit_tests/models/misc/preemptive_scheduling.rs
index d1e2f8809..299bb177c 100644
--- a/src/unit_tests/models/misc/preemptive_scheduling.rs
+++ b/src/unit_tests/models/misc/preemptive_scheduling.rs
@@ -1,4 +1,5 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -7,28 +8,28 @@ use crate::types::Min;
 /// Small instance: 2 tasks with lengths [2, 1], 2 processors, no precedences.
 /// D_max = 3.  Config length = 2 * 3 = 6.
 fn small_instance() -> PreemptiveScheduling {
-    PreemptiveScheduling::new(vec![2, 1], 2, vec![])
+    PreemptiveScheduling::new(vec![2, 1], 2, vec![]).unwrap()
 }
 
 /// 2 tasks with a precedence: task 0 → task 1.
 /// lengths [1, 1], 2 processors, precedence (0,1).
 /// D_max = 2.  Config length = 2 * 2 = 4.
 fn precedence_instance() -> PreemptiveScheduling {
-    PreemptiveScheduling::new(vec![1, 1], 2, vec![(0, 1)])
+    PreemptiveScheduling::new(vec![1, 1], 2, vec![(0, 1)]).unwrap()
 }
 
 // ─── creation / accessor tests ─────────────────────────────────────────────
 
 #[test]
 fn test_preemptive_scheduling_creation() {
-    let p = PreemptiveScheduling::new(vec![2, 1, 3], 2, vec![(0, 2)]);
+    let p = PreemptiveScheduling::new(vec![2, 1, 3], 2, vec![(0, 2)]).unwrap();
     assert_eq!(p.num_tasks(), 3);
     assert_eq!(p.num_processors(), 2);
     assert_eq!(p.num_precedences(), 1);
     assert_eq!(p.lengths(), &[2, 1, 3]);
     assert_eq!(p.precedences(), &[(0, 2)]);
     assert_eq!(p.d_max(), 6);
-    assert_eq!(p.dims(), vec![2; 3 * 6]);
+    assert_eq!(p.dimensions(), vec![2; 3 * 6]);
     assert_eq!(
         <PreemptiveScheduling as Problem>::NAME,
         "PreemptiveScheduling"
@@ -38,11 +39,11 @@ fn test_preemptive_scheduling_creation() {
 
 #[test]
 fn test_preemptive_scheduling_empty_tasks() {
-    let p = PreemptiveScheduling::new(vec![], 1, vec![]);
+    let p = PreemptiveScheduling::new(vec![], 1, vec![]).unwrap();
     assert_eq!(p.num_tasks(), 0);
     assert_eq!(p.d_max(), 0);
-    assert_eq!(p.dims(), Vec::<usize>::new());
-    assert_eq!(p.evaluate(&[]), Min(Some(0)));
+    assert_eq!(p.dimensions(), Vec::<usize>::new());
+    assert_eq!(p.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 // ─── evaluate: valid configs ────────────────────────────────────────────────
@@ -52,17 +53,17 @@ fn test_preemptive_scheduling_evaluate_valid_no_precedence() {
     let p = small_instance();
     // D_max=3; t0 active at 0,1  t1 active at 0
     // config layout: [t0s0, t0s1, t0s2,  t1s0, t1s1, t1s2]
-    let config = vec![1, 1, 0, 1, 0, 0];
-    assert_eq!(p.evaluate(&config), Min(Some(2)));
+    let config = vec![vec![true, true, false], vec![true, false, false]];
+    assert_eq!(p.evaluate(&config).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_preemptive_scheduling_evaluate_valid_split() {
     // Single processor, 1 task of length 2; split into slots 0 and 2
-    let p = PreemptiveScheduling::new(vec![2], 1, vec![]);
+    let p = PreemptiveScheduling::new(vec![2], 1, vec![]).unwrap();
     // D_max=2, config length=2
-    let config = vec![1, 1];
-    assert_eq!(p.evaluate(&config), Min(Some(2)));
+    let config = vec![vec![true, true]];
+    assert_eq!(p.evaluate(&config).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -70,22 +71,22 @@ fn test_preemptive_scheduling_evaluate_valid_precedence() {
     // Task 0 finishes at slot 0 (last=0), task 1 starts at slot 1 (first=1). OK.
     let p = precedence_instance();
     // D_max=2; t0=[1,0], t1=[0,1]
-    let config = vec![1, 0, 0, 1];
-    assert_eq!(p.evaluate(&config), Min(Some(2)));
+    let config = vec![vec![true, false], vec![false, true]];
+    assert_eq!(p.evaluate(&config).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_preemptive_scheduling_makespan_correct() {
     // 3 tasks on 3 processors, no precedences, all finish at slot 2
-    let p = PreemptiveScheduling::new(vec![1, 1, 1], 3, vec![]);
+    let p = PreemptiveScheduling::new(vec![1, 1, 1], 3, vec![]).unwrap();
     // D_max=3; each task active in exactly 1 slot, all at slot 2
     let config = vec![
-        0, 0, 1, // t0 at slot 2
-        0, 0, 1, // t1 at slot 2
-        0, 0, 1, // t2 at slot 2
+        vec![false, false, true],
+        vec![false, false, true],
+        vec![false, false, true],
     ];
     // 3 tasks at slot 2 <= 3 processors OK, makespan = 3
-    assert_eq!(p.evaluate(&config), Min(Some(3)));
+    assert_eq!(p.evaluate(&config).unwrap(), Min(Some(3)));
 }
 
 // ─── evaluate: invalid configs ─────────────────────────────────────────────
@@ -93,26 +94,32 @@ fn test_preemptive_scheduling_makespan_correct() {
 #[test]
 fn test_preemptive_scheduling_evaluate_wrong_length() {
     let p = small_instance();
-    assert_eq!(p.evaluate(&[]), Min(None));
-    assert_eq!(p.evaluate(&[1, 1, 0]), Min(None)); // too short
-    assert_eq!(p.evaluate(&[1, 1, 0, 1, 0, 0, 0]), Min(None)); // too long
+    assert!(p.evaluate(&vec![]).is_err());
+    assert!(p.evaluate(&vec![vec![true, true, false]]).is_err());
+    assert!(p
+        .evaluate(&vec![vec![true, true, false], vec![true, false]])
+        .is_err());
 }
 
 #[test]
 fn test_preemptive_scheduling_evaluate_wrong_active_count() {
     let p = small_instance();
     // t0 needs 2 active slots but gets 1; t1 needs 1 but gets 1
-    let config = vec![1, 0, 0, 1, 0, 0];
-    assert_eq!(p.evaluate(&config), Min(None));
+    let config = vec![vec![true, false, false], vec![true, false, false]];
+    assert_eq!(p.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_preemptive_scheduling_evaluate_processor_overflow() {
     // 3 tasks, 2 processors; all three tasks at slot 0
-    let p = PreemptiveScheduling::new(vec![1, 1, 1], 2, vec![]);
+    let p = PreemptiveScheduling::new(vec![1, 1, 1], 2, vec![]).unwrap();
     // D_max=3; all at slot 0 → 3 tasks > 2 processors
-    let config = vec![1, 0, 0, 1, 0, 0, 1, 0, 0];
-    assert_eq!(p.evaluate(&config), Min(None));
+    let config = vec![
+        vec![true, false, false],
+        vec![true, false, false],
+        vec![true, false, false],
+    ];
+    assert_eq!(p.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -121,8 +128,8 @@ fn test_preemptive_scheduling_evaluate_precedence_violation() {
     let p = precedence_instance();
     // D_max=2; t0=[0,1], t1=[0,1] — both active at slot 1; last of pred = 1, first of succ = 0
     // Actually last_pred = 1, first_succ = 0 → 1 >= 0 → violation
-    let config = vec![0, 1, 1, 0];
-    assert_eq!(p.evaluate(&config), Min(None));
+    let config = vec![vec![false, true], vec![true, false]];
+    assert_eq!(p.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -130,8 +137,8 @@ fn test_preemptive_scheduling_evaluate_precedence_same_slot() {
     // Tasks assigned to the same slot; last_pred = 0, first_succ = 0 → violation
     let p = precedence_instance();
     // t0=[1,0], t1=[1,0]
-    let config = vec![1, 0, 1, 0];
-    assert_eq!(p.evaluate(&config), Min(None));
+    let config = vec![vec![true, false], vec![true, false]];
+    assert_eq!(p.evaluate(&config).unwrap(), Min(None));
 }
 
 // ─── paper canonical example ────────────────────────────────────────────────
@@ -140,34 +147,34 @@ fn test_preemptive_scheduling_evaluate_precedence_same_slot() {
 fn test_preemptive_scheduling_paper_example() {
     // 5 tasks, lengths [2,1,3,2,1], 2 processors, precedences [(0,2),(1,3)]
     // Optimal makespan = 5
-    let p = PreemptiveScheduling::new(vec![2, 1, 3, 2, 1], 2, vec![(0, 2), (1, 3)]);
+    let p = PreemptiveScheduling::new(vec![2, 1, 3, 2, 1], 2, vec![(0, 2), (1, 3)]).unwrap();
     let d = p.d_max(); // = 9
     assert_eq!(d, 9);
 
-    let mut config = vec![0usize; 5 * d];
+    let mut config = vec![vec![false; d]; 5];
     // t0 (task index 0) occupies config[0..d]
-    config[0] = 1; // t0 at slot 0
-    config[1] = 1; // t0 at slot 1
-                   // t1 (task index 1) occupies config[d..2*d]
-    config[d] = 1; // t1 at slot 0
-                   // t2 (task index 2) occupies config[2*d..3*d]
-    config[2 * d + 2] = 1; // t2 at slot 2
-    config[2 * d + 3] = 1; // t2 at slot 3
-    config[2 * d + 4] = 1; // t2 at slot 4
-                           // t3 (task index 3) occupies config[3*d..4*d]
-    config[3 * d + 2] = 1; // t3 at slot 2
-    config[3 * d + 3] = 1; // t3 at slot 3
-                           // t4 (task index 4) occupies config[4*d..5*d]
-    config[4 * d + 1] = 1; // t4 at slot 1
-
-    assert_eq!(p.evaluate(&config), Min(Some(5)));
+    config[0][0] = true;
+    config[0][1] = true;
+    // t1 (task index 1) occupies config[d..2*d]
+    config[1][0] = true;
+    // t2 (task index 2) occupies config[2*d..3*d]
+    config[2][2] = true;
+    config[2][3] = true;
+    config[2][4] = true;
+    // t3 (task index 3) occupies config[3*d..4*d]
+    config[3][2] = true;
+    config[3][3] = true;
+    // t4 (task index 4) occupies config[4*d..5*d]
+    config[4][1] = true;
+
+    assert_eq!(p.evaluate(&config).unwrap(), Min(Some(5)));
 }
 
 // ─── serialization ──────────────────────────────────────────────────────────
 
 #[test]
 fn test_preemptive_scheduling_serialization() {
-    let p = PreemptiveScheduling::new(vec![2, 1, 3], 2, vec![(0, 2)]);
+    let p = PreemptiveScheduling::new(vec![2, 1, 3], 2, vec![(0, 2)]).unwrap();
     let json = serde_json::to_value(&p).unwrap();
     let restored: PreemptiveScheduling = serde_json::from_value(json).unwrap();
     assert_eq!(restored.num_tasks(), p.num_tasks());
@@ -178,32 +185,29 @@ fn test_preemptive_scheduling_serialization() {
 
 #[test]
 fn test_preemptive_scheduling_serialization_roundtrip_evaluate() {
-    let p = PreemptiveScheduling::new(vec![1, 1], 2, vec![(0, 1)]);
+    let p = PreemptiveScheduling::new(vec![1, 1], 2, vec![(0, 1)]).unwrap();
     let json = serde_json::to_value(&p).unwrap();
     let p2: PreemptiveScheduling = serde_json::from_value(json).unwrap();
     // valid: t0 at 0, t1 at 1
-    let config = vec![1, 0, 0, 1];
-    assert_eq!(p.evaluate(&config), p2.evaluate(&config));
+    let config = vec![vec![true, false], vec![false, true]];
+    assert_eq!(p.evaluate(&config).unwrap(), p2.evaluate(&config).unwrap());
 }
 
-// ─── validation panics ──────────────────────────────────────────────────────
+// ─── validation errors ──────────────────────────────────────────────────────
 
 #[test]
-#[should_panic(expected = "task lengths must be positive")]
 fn test_preemptive_scheduling_zero_length() {
-    PreemptiveScheduling::new(vec![0, 1], 2, vec![]);
+    assert!(PreemptiveScheduling::new(vec![0, 1], 2, vec![]).is_err());
 }
 
 #[test]
-#[should_panic(expected = "num_processors must be positive")]
 fn test_preemptive_scheduling_zero_processors() {
-    PreemptiveScheduling::new(vec![1, 1], 0, vec![]);
+    assert!(PreemptiveScheduling::new(vec![1, 1], 0, vec![]).is_err());
 }
 
 #[test]
-#[should_panic(expected = "precedence index out of range")]
 fn test_preemptive_scheduling_precedence_out_of_range() {
-    PreemptiveScheduling::new(vec![1, 1], 2, vec![(0, 5)]);
+    assert!(PreemptiveScheduling::new(vec![1, 1], 2, vec![(0, 5)]).is_err());
 }
 
 // ─── serde validation ───────────────────────────────────────────────────────
@@ -229,3 +233,14 @@ fn test_preemptive_scheduling_deserialize_invalid_zero_processors() {
     let result: Result<PreemptiveScheduling, _> = serde_json::from_value(json);
     assert!(result.is_err());
 }
+#[test]
+fn create_spec_defaults_precedences_to_empty() {
+    let problem = PreemptiveScheduling::try_from(PreemptiveSchedulingCreateSpec {
+        lengths: vec![1, 2],
+        num_processors: 1,
+        precedences: None,
+    })
+    .unwrap();
+    assert!(problem.precedences().is_empty());
+    assert!(!PreemptiveSchedulingCreateSpec::inputs()[2].required);
+}
diff --git a/src/unit_tests/models/misc/production_planning.rs b/src/unit_tests/models/misc/production_planning.rs
index 83be19188..1141a3d07 100644
--- a/src/unit_tests/models/misc/production_planning.rs
+++ b/src/unit_tests/models/misc/production_planning.rs
@@ -1,4 +1,20 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_period_vector_mismatch() {
+    assert_eq!(ProductionPlanningCreateSpec::FIELDS[0].name, "num_periods");
+    assert!(ProductionPlanning::try_from(ProductionPlanningCreateSpec {
+        num_periods: 1,
+        demands: vec![],
+        capacities: vec![1],
+        setup_costs: vec![1],
+        production_costs: vec![1],
+        inventory_costs: vec![1],
+        cost_bound: 1
+    })
+    .is_err());
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Or;
@@ -38,7 +54,7 @@ fn test_production_planning_creation() {
     assert_eq!(problem.inventory_costs(), &[1, 1, 1, 1, 1, 1]);
     assert_eq!(problem.cost_bound(), 80);
     assert_eq!(problem.max_capacity(), 12);
-    assert_eq!(problem.dims(), vec![13; 6]);
+    assert_eq!(problem.dimensions(), vec![13; 6]);
     assert_eq!(<ProductionPlanning as Problem>::NAME, "ProductionPlanning");
     assert_eq!(<ProductionPlanning as Problem>::variant(), vec![]);
 }
@@ -46,40 +62,55 @@ fn test_production_planning_creation() {
 #[test]
 fn test_production_planning_evaluate_issue_example() {
     let problem = issue_example_problem();
-    assert_eq!(problem.evaluate(&[8, 0, 10, 0, 12, 0]), Or(true));
+    assert_eq!(
+        problem.evaluate(&vec![8, 0, 10, 0, 12, 0]).unwrap(),
+        Or(true)
+    );
 }
 
 #[test]
 fn test_production_planning_rejects_capacity_overflow() {
     let problem = issue_example_problem();
-    assert_eq!(problem.evaluate(&[13, 0, 10, 0, 12, 0]), Or(false));
+    assert_eq!(
+        problem.evaluate(&vec![13, 0, 10, 0, 12, 0]).unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
 fn test_production_planning_rejects_negative_inventory_prefix() {
     let problem = issue_example_problem();
-    assert_eq!(problem.evaluate(&[4, 4, 4, 4, 4, 4]), Or(false));
+    assert_eq!(
+        problem.evaluate(&vec![4, 4, 4, 4, 4, 4]).unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
 fn test_production_planning_rejects_budget_overflow() {
     let problem = issue_example_problem();
-    assert_eq!(problem.evaluate(&[8, 0, 10, 0, 12, 1]), Or(false));
+    assert_eq!(
+        problem.evaluate(&vec![8, 0, 10, 0, 12, 1]).unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
 fn test_production_planning_rejects_wrong_config_length() {
     let problem = issue_example_problem();
-    assert_eq!(problem.evaluate(&[8, 0, 10, 0, 12]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![8, 0, 10, 0, 12]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_production_planning_bruteforce_finds_satisfying_solution() {
     let problem = tiny_solver_problem();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert_eq!(problem.evaluate(&solution.unwrap()), Or(true));
+    assert_eq!(problem.evaluate(&solution.unwrap()).unwrap(), Or(true));
 }
 
 #[test]
@@ -88,11 +119,11 @@ fn test_production_planning_paper_example() {
     let plan = vec![8, 0, 10, 0, 12, 0];
     let solver = BruteForce::new();
 
-    assert_eq!(problem.evaluate(&plan), Or(true));
+    assert_eq!(problem.evaluate(&plan).unwrap(), Or(true));
 
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
-    assert_eq!(problem.evaluate(&witness.unwrap()), Or(true));
+    assert_eq!(problem.evaluate(&witness.unwrap()).unwrap(), Or(true));
 }
 
 #[test]
@@ -123,12 +154,6 @@ fn test_production_planning_rejects_length_mismatch() {
     );
 }
 
-#[test]
-#[should_panic(expected = "capacities must fit in usize for dims()")]
-fn test_production_planning_rejects_capacity_too_large_for_dims() {
-    ProductionPlanning::new(1, vec![0], vec![u64::MAX], vec![0], vec![0], vec![0], 0);
-}
-
 #[test]
 #[should_panic(expected = "num_periods must be positive")]
 fn test_production_planning_rejects_zero_periods() {
diff --git a/src/unit_tests/models/misc/rectilinear_picture_compression.rs b/src/unit_tests/models/misc/rectilinear_picture_compression.rs
index 7b649496d..00acdec63 100644
--- a/src/unit_tests/models/misc/rectilinear_picture_compression.rs
+++ b/src/unit_tests/models/misc/rectilinear_picture_compression.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 fn two_block_matrix() -> Vec<Vec<bool>> {
@@ -51,62 +52,71 @@ fn test_rectilinear_picture_compression_maximal_rectangles_two_blocks() {
 fn test_rectilinear_picture_compression_dims() {
     let problem = RectilinearPictureCompression::new(two_block_matrix(), 2);
     // 2 maximal rectangles -> 2 binary variables
-    assert_eq!(problem.dims(), vec![2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2]);
 }
 
 #[test]
 fn test_rectilinear_picture_compression_evaluate_satisfying() {
     let problem = RectilinearPictureCompression::new(two_block_matrix(), 2);
     // Select both maximal rectangles
-    assert!(problem.evaluate(&[1, 1]));
+    assert!(problem.evaluate(&vec![true, true]).unwrap());
 }
 
 #[test]
 fn test_rectilinear_picture_compression_evaluate_unsatisfying_not_all_covered() {
     let problem = RectilinearPictureCompression::new(two_block_matrix(), 2);
     // Select only first rectangle - second block uncovered
-    assert!(!problem.evaluate(&[1, 0]));
+    assert!(!problem.evaluate(&vec![true, false]).unwrap());
     // Select only second rectangle - first block uncovered
-    assert!(!problem.evaluate(&[0, 1]));
+    assert!(!problem.evaluate(&vec![false, true]).unwrap());
     // Select none
-    assert!(!problem.evaluate(&[0, 0]));
+    assert!(!problem.evaluate(&vec![false, false]).unwrap());
 }
 
 #[test]
 fn test_rectilinear_picture_compression_evaluate_bound_exceeded() {
     let problem = RectilinearPictureCompression::new(two_block_matrix(), 1);
     // Both selected but bound is 1
-    assert!(!problem.evaluate(&[1, 1]));
+    assert!(!problem.evaluate(&vec![true, true]).unwrap());
 }
 
 #[test]
 fn test_rectilinear_picture_compression_evaluate_wrong_config_length() {
     let problem = RectilinearPictureCompression::new(two_block_matrix(), 2);
-    assert!(!problem.evaluate(&[1]));
-    assert!(!problem.evaluate(&[1, 1, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_rectilinear_picture_compression_evaluate_invalid_variable_value() {
     let problem = RectilinearPictureCompression::new(two_block_matrix(), 2);
-    assert!(!problem.evaluate(&[2, 0]));
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([2, false]))
+            .is_err()
+    );
 }
 
 #[test]
 fn test_rectilinear_picture_compression_issue_matrix_satisfiable() {
     let problem = RectilinearPictureCompression::new(issue_matrix(), 3);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let sol = solution.unwrap();
-    assert!(problem.evaluate(&sol));
+    assert!(problem.evaluate(&sol).unwrap());
 }
 
 #[test]
 fn test_rectilinear_picture_compression_issue_matrix_unsatisfiable() {
     let problem = RectilinearPictureCompression::new(issue_matrix(), 2);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
@@ -115,20 +125,21 @@ fn test_rectilinear_picture_compression_brute_force() {
     let problem = RectilinearPictureCompression::new(two_block_matrix(), 2);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_rectilinear_picture_compression_brute_force_all() {
     let problem = RectilinearPictureCompression::new(two_block_matrix(), 2);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     // Two disjoint 2x2 blocks with K=2: exactly one satisfying config [1,1].
     assert_eq!(solutions.len(), 1);
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -162,9 +173,9 @@ fn test_rectilinear_picture_compression_single_cell() {
     let problem = RectilinearPictureCompression::new(matrix, 1);
     let rects = problem.maximal_rectangles();
     assert_eq!(rects, vec![(0, 0, 0, 0)]);
-    assert_eq!(problem.dims(), vec![2]);
-    assert!(problem.evaluate(&[1]));
-    assert!(!problem.evaluate(&[0]));
+    assert_eq!(problem.dimensions(), vec![2]);
+    assert!(problem.evaluate(&vec![true]).unwrap());
+    assert!(!problem.evaluate(&vec![false]).unwrap());
 }
 
 #[test]
@@ -174,9 +185,9 @@ fn test_rectilinear_picture_compression_all_zeros() {
     let problem = RectilinearPictureCompression::new(matrix, 0);
     let rects = problem.maximal_rectangles();
     assert!(rects.is_empty());
-    assert_eq!(problem.dims(), Vec::<usize>::new());
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
     // Empty config satisfies (no 1-entries to cover)
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -186,8 +197,8 @@ fn test_rectilinear_picture_compression_full_matrix() {
     let problem = RectilinearPictureCompression::new(matrix, 1);
     let rects = problem.maximal_rectangles();
     assert_eq!(rects, vec![(0, 0, 1, 1)]);
-    assert!(problem.evaluate(&[1]));
-    assert!(!problem.evaluate(&[0]));
+    assert!(problem.evaluate(&vec![true]).unwrap());
+    assert!(!problem.evaluate(&vec![false]).unwrap());
 }
 
 #[test]
@@ -200,8 +211,8 @@ fn test_rectilinear_picture_compression_overlapping_rectangles() {
     assert!(rects.contains(&(0, 0, 1, 0)));
     assert!(rects.contains(&(0, 0, 0, 1)));
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert!(problem.evaluate(&solution));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/register_sufficiency.rs b/src/unit_tests/models/misc/register_sufficiency.rs
index c4cd025fc..a112f8bc8 100644
--- a/src/unit_tests/models/misc/register_sufficiency.rs
+++ b/src/unit_tests/models/misc/register_sufficiency.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -34,7 +35,7 @@ fn test_register_sufficiency_basic() {
             (6, 5)
         ]
     );
-    assert_eq!(problem.dims(), vec![7; 7]);
+    assert_eq!(problem.dimensions(), vec![7; 7]);
     assert_eq!(
         <RegisterSufficiency as Problem>::NAME,
         "RegisterSufficiency"
@@ -62,10 +63,10 @@ fn test_register_sufficiency_evaluate_valid() {
     // Order: v0,v1,v2,v3,v5,v4,v6 (0-indexed)
     // Positions: v0->0, v1->1, v2->2, v3->3, v4->5, v5->4, v6->6
     let config = vec![0, 1, 2, 3, 5, 4, 6];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
     // Verify register count
-    let max_reg = problem.simulate_registers(&config).unwrap();
+    let max_reg = problem.simulate_registers(&config).unwrap().unwrap();
     assert_eq!(max_reg, 3);
 }
 
@@ -73,12 +74,21 @@ fn test_register_sufficiency_evaluate_valid() {
 fn test_register_sufficiency_evaluate_invalid_permutation() {
     let problem = RegisterSufficiency::new(4, vec![(2, 0), (3, 0), (3, 1)], 2);
     // Not a permutation: position 0 used twice
-    assert!(!problem.evaluate(&[0, 0, 1, 2]));
+    assert!(!problem.evaluate(&vec![0, 0, 1, 2]).unwrap());
     // Wrong length
-    assert!(!problem.evaluate(&[0, 1, 2]));
-    assert!(!problem.evaluate(&[0, 1, 2, 3, 4]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Position out of range
-    assert!(!problem.evaluate(&[0, 1, 2, 4]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -86,7 +96,7 @@ fn test_register_sufficiency_evaluate_invalid_dependency() {
     // v2 depends on v0, v3 depends on v0 and v1
     let problem = RegisterSufficiency::new(4, vec![(2, 0), (3, 0), (3, 1)], 4);
     // v2 at position 0, v0 at position 1 -> v2 evaluated before its dependency v0
-    assert!(!problem.evaluate(&[1, 2, 0, 3]));
+    assert!(!problem.evaluate(&vec![1, 2, 0, 3]).unwrap());
 }
 
 #[test]
@@ -108,7 +118,7 @@ fn test_register_sufficiency_evaluate_exceeds_bound() {
     );
     // Same valid ordering but K=2 is too small
     let config = vec![0, 1, 2, 3, 5, 4, 6];
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -117,19 +127,20 @@ fn test_register_sufficiency_brute_force() {
     let problem = RegisterSufficiency::new(4, vec![(2, 0), (3, 1)], 2);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_register_sufficiency_brute_force_all() {
     let problem = RegisterSufficiency::new(4, vec![(2, 0), (3, 1)], 2);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -141,7 +152,7 @@ fn test_register_sufficiency_unsatisfiable() {
     // With K=1, impossible
     let problem = RegisterSufficiency::new(4, vec![(1, 0), (2, 1), (3, 2), (3, 0)], 1);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -172,17 +183,17 @@ fn test_register_sufficiency_serialization() {
 fn test_register_sufficiency_empty() {
     let problem = RegisterSufficiency::new(0, vec![], 0);
     assert_eq!(problem.num_vertices(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
 fn test_register_sufficiency_single_vertex() {
     let problem = RegisterSufficiency::new(1, vec![], 1);
-    assert!(problem.evaluate(&[0]));
+    assert!(problem.evaluate(&vec![0]).unwrap());
     // K=0 should fail (vertex needs one register)
     let problem_k0 = RegisterSufficiency::new(1, vec![], 0);
-    assert!(!problem_k0.evaluate(&[0]));
+    assert!(!problem_k0.evaluate(&vec![0]).unwrap());
 }
 
 #[test]
@@ -207,8 +218,8 @@ fn test_register_sufficiency_paper_example() {
     // = v0,v1,v2,v3,v5,v4,v6 (0-indexed)
     // Positions: v0->0, v1->1, v2->2, v3->3, v4->5, v5->4, v6->6
     let config = vec![0, 1, 2, 3, 5, 4, 6];
-    assert!(problem.evaluate(&config));
-    assert_eq!(problem.simulate_registers(&config).unwrap(), 3);
+    assert!(problem.evaluate(&config).unwrap());
+    assert_eq!(problem.simulate_registers(&config).unwrap(), Some(3));
 
     // Verify K=2 is impossible using brute force
     let problem_k2 = RegisterSufficiency::new(
@@ -226,5 +237,5 @@ fn test_register_sufficiency_paper_example() {
         2,
     );
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem_k2).is_none());
+    assert!(solver.solve(&problem_k2).unwrap().is_none());
 }
diff --git a/src/unit_tests/models/misc/resource_constrained_scheduling.rs b/src/unit_tests/models/misc/resource_constrained_scheduling.rs
index 16f352a6b..70415a3b0 100644
--- a/src/unit_tests/models/misc/resource_constrained_scheduling.rs
+++ b/src/unit_tests/models/misc/resource_constrained_scheduling.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -9,15 +10,16 @@ fn test_resource_constrained_scheduling_creation() {
         vec![20],
         vec![vec![6], vec![7], vec![7], vec![6], vec![8], vec![6]],
         2,
-    );
+    )
+    .unwrap();
     assert_eq!(problem.num_tasks(), 6);
     assert_eq!(problem.num_processors(), 3);
     assert_eq!(problem.resource_bounds(), &[20]);
     assert_eq!(problem.deadline(), 2);
     assert_eq!(problem.num_resources(), 1);
-    assert_eq!(problem.dims().len(), 6);
+    assert_eq!(problem.dimensions().len(), 6);
     // Each variable has domain {0, 1} (deadline = 2)
-    assert!(problem.dims().iter().all(|&d| d == 2));
+    assert!(problem.dimensions().iter().all(|&d| d == 2));
 }
 
 #[test]
@@ -30,8 +32,9 @@ fn test_resource_constrained_scheduling_evaluate_valid() {
         vec![20],
         vec![vec![6], vec![7], vec![7], vec![6], vec![8], vec![6]],
         2,
-    );
-    assert!(problem.evaluate(&[0, 0, 0, 1, 1, 1]));
+    )
+    .unwrap();
+    assert!(problem.evaluate(&vec![0, 0, 0, 1, 1, 1]).unwrap());
 }
 
 #[test]
@@ -43,8 +46,9 @@ fn test_resource_constrained_scheduling_evaluate_invalid_processor_capacity() {
         vec![100],
         vec![vec![1], vec![1], vec![1], vec![1]],
         2,
-    );
-    assert!(!problem.evaluate(&[0, 0, 0, 1]));
+    )
+    .unwrap();
+    assert!(!problem.evaluate(&vec![0, 0, 0, 1]).unwrap());
 }
 
 #[test]
@@ -56,24 +60,36 @@ fn test_resource_constrained_scheduling_evaluate_invalid_resource() {
         vec![10],
         vec![vec![6], vec![6], vec![3], vec![3]],
         2,
-    );
-    assert!(!problem.evaluate(&[0, 0, 1, 1]));
+    )
+    .unwrap();
+    assert!(!problem.evaluate(&vec![0, 0, 1, 1]).unwrap());
 }
 
 #[test]
 fn test_resource_constrained_scheduling_evaluate_wrong_config_length() {
     let problem =
-        ResourceConstrainedScheduling::new(3, vec![20], vec![vec![5], vec![5], vec![5]], 2);
-    assert!(!problem.evaluate(&[0, 1]));
-    assert!(!problem.evaluate(&[0, 1, 0, 1]));
+        ResourceConstrainedScheduling::new(3, vec![20], vec![vec![5], vec![5], vec![5]], 2)
+            .unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_resource_constrained_scheduling_evaluate_out_of_range_slot() {
     let problem =
-        ResourceConstrainedScheduling::new(3, vec![20], vec![vec![5], vec![5], vec![5]], 2);
+        ResourceConstrainedScheduling::new(3, vec![20], vec![vec![5], vec![5], vec![5]], 2)
+            .unwrap();
     // Slot 2 is out of range for deadline=2 (valid: 0, 1)
-    assert!(!problem.evaluate(&[0, 1, 2]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -87,18 +103,20 @@ fn test_resource_constrained_scheduling_multiple_resources() {
         vec![10, 8],
         vec![vec![5, 4], vec![5, 4], vec![5, 4]],
         2,
-    );
-    assert!(problem.evaluate(&[0, 0, 1]));
+    )
+    .unwrap();
+    assert!(problem.evaluate(&vec![0, 0, 1]).unwrap());
     // Slot 0: {t1, t2, t3} -> 3 > 2 processors
-    assert!(!problem.evaluate(&[0, 0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 0]).unwrap());
 }
 
 #[test]
 fn test_resource_constrained_scheduling_empty_tasks() {
-    let problem = ResourceConstrainedScheduling::new(2, vec![10], Vec::<Vec<u64>>::new(), 3);
+    let problem =
+        ResourceConstrainedScheduling::new(2, vec![10], Vec::<Vec<i64>>::new(), 3).unwrap();
     assert_eq!(problem.num_tasks(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -109,9 +127,10 @@ fn test_resource_constrained_scheduling_brute_force_infeasible() {
         vec![100],
         vec![vec![1], vec![1], vec![1], vec![1]],
         2,
-    );
+    )
+    .unwrap();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     // 1 processor * 2 time slots = 2 tasks max, but we have 4
     assert!(solution.is_none());
 }
@@ -137,7 +156,8 @@ fn test_resource_constrained_scheduling_serialization() {
         vec![20],
         vec![vec![6], vec![7], vec![7], vec![6], vec![8], vec![6]],
         2,
-    );
+    )
+    .unwrap();
     let json = serde_json::to_value(&problem).unwrap();
     let restored: ResourceConstrainedScheduling = serde_json::from_value(json).unwrap();
     assert_eq!(restored.num_tasks(), problem.num_tasks());
@@ -151,32 +171,41 @@ fn test_resource_constrained_scheduling_serialization() {
 }
 
 #[test]
-#[should_panic(expected = "deadline must be positive")]
 fn test_resource_constrained_scheduling_zero_deadline() {
-    ResourceConstrainedScheduling::new(2, vec![10], vec![vec![5]], 0);
+    assert!(ResourceConstrainedScheduling::new(2, vec![10], vec![vec![5]], 0).is_err());
 }
 
 #[test]
-#[should_panic(expected = "resource requirements")]
 fn test_resource_constrained_scheduling_mismatched_requirements() {
     // 2 resource bounds but task has only 1 requirement
-    ResourceConstrainedScheduling::new(2, vec![10, 20], vec![vec![5]], 2);
+    assert!(ResourceConstrainedScheduling::new(2, vec![10, 20], vec![vec![5]], 2).is_err());
+}
+
+#[test]
+fn test_resource_constrained_scheduling_deserialization_validates_fields() {
+    let json = r#"{
+        "num_processors": 2,
+        "resource_bounds": [10, 20],
+        "resource_requirements": [[5]],
+        "deadline": 2
+    }"#;
+    assert!(serde_json::from_str::<ResourceConstrainedScheduling>(json).is_err());
 }
 
 #[test]
 fn test_resource_constrained_scheduling_single_task_exceeds_bound() {
     // One task requires resource 15 but bound is 10 — instance is infeasible
-    let problem = ResourceConstrainedScheduling::new(2, vec![10], vec![vec![15]], 2);
-    assert!(!problem.evaluate(&[0]));
-    assert!(!problem.evaluate(&[1]));
+    let problem = ResourceConstrainedScheduling::new(2, vec![10], vec![vec![15]], 2).unwrap();
+    assert!(!problem.evaluate(&vec![0]).unwrap());
+    assert!(!problem.evaluate(&vec![1]).unwrap());
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_resource_constrained_scheduling_single_task() {
-    let problem = ResourceConstrainedScheduling::new(1, vec![5], vec![vec![5]], 1);
-    assert!(problem.evaluate(&[0]));
+    let problem = ResourceConstrainedScheduling::new(1, vec![5], vec![vec![5]], 1).unwrap();
+    assert!(problem.evaluate(&vec![0]).unwrap());
 }
 
 #[test]
@@ -187,9 +216,10 @@ fn test_resource_constrained_scheduling_canonical_brute_force() {
         vec![20],
         vec![vec![6], vec![7], vec![7], vec![6], vec![8], vec![6]],
         2,
-    );
+    )
+    .unwrap();
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all.is_empty());
     // Verify the hardcoded canonical solution is among the brute-force results
     assert!(all.contains(&vec![0, 0, 0, 1, 1, 1]));
@@ -198,6 +228,6 @@ fn test_resource_constrained_scheduling_canonical_brute_force() {
 #[test]
 fn test_resource_constrained_scheduling_resource_requirements_accessor() {
     let reqs = vec![vec![5, 3], vec![2, 4]];
-    let problem = ResourceConstrainedScheduling::new(2, vec![10, 10], reqs.clone(), 2);
+    let problem = ResourceConstrainedScheduling::new(2, vec![10, 10], reqs.clone(), 2).unwrap();
     assert_eq!(problem.resource_requirements(), &reqs[..]);
 }
diff --git a/src/unit_tests/models/misc/scheduling_to_minimize_weighted_completion_time.rs b/src/unit_tests/models/misc/scheduling_to_minimize_weighted_completion_time.rs
index d137878c6..54fd389aa 100644
--- a/src/unit_tests/models/misc/scheduling_to_minimize_weighted_completion_time.rs
+++ b/src/unit_tests/models/misc/scheduling_to_minimize_weighted_completion_time.rs
@@ -1,4 +1,18 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_task_weights() {
+    let p = SchedulingToMinimizeWeightedCompletionTime::try_from(
+        SchedulingToMinimizeWeightedCompletionTimeCreateSpec {
+            lengths: vec![1, 2],
+            weights: None,
+            num_processors: 1,
+        },
+    )
+    .unwrap();
+    assert_eq!(p.weights(), &[1, 1]);
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -14,7 +28,7 @@ fn test_scheduling_min_wct_creation() {
     assert_eq!(problem.num_processors(), 2);
     assert_eq!(problem.lengths(), &[1, 2, 3, 4, 5]);
     assert_eq!(problem.weights(), &[6, 4, 3, 2, 1]);
-    assert_eq!(problem.dims(), vec![2; 5]);
+    assert_eq!(problem.dimensions(), vec![2; 5]);
     assert_eq!(
         <SchedulingToMinimizeWeightedCompletionTime as Problem>::NAME,
         "SchedulingToMinimizeWeightedCompletionTime"
@@ -35,7 +49,10 @@ fn test_scheduling_min_wct_evaluate_issue_example() {
         2,
     );
     // config: [0, 1, 0, 1, 0] means t0->P0, t1->P1, t2->P0, t3->P1, t4->P0
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1, 0]), Min(Some(47)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 1, 0, 1, 0]).unwrap(),
+        Min(Some(47))
+    );
 }
 
 #[test]
@@ -49,17 +66,29 @@ fn test_scheduling_min_wct_evaluate_all_one_processor() {
     // All on processor 0: Smith's rule order t0,t1,t2,t3,t4
     // C(t0)=1, C(t1)=3, C(t2)=6, C(t3)=10, C(t4)=15
     // WCT = 1*6 + 3*4 + 6*3 + 10*2 + 15*1 = 6+12+18+20+15 = 71
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0]), Min(Some(71)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 0, 0, 0, 0]).unwrap(),
+        Min(Some(71))
+    );
 }
 
 #[test]
 fn test_scheduling_min_wct_evaluate_invalid_config() {
     let problem = SchedulingToMinimizeWeightedCompletionTime::new(vec![1, 2], vec![3, 4], 2);
     // Wrong length
-    assert_eq!(problem.evaluate(&[0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Out-of-range processor
-    assert_eq!(problem.evaluate(&[0, 2]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -70,8 +99,8 @@ fn test_scheduling_min_wct_solver() {
         2,
     );
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&witness), Min(Some(47)));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(47)));
 }
 
 #[test]
@@ -82,11 +111,11 @@ fn test_scheduling_min_wct_find_all_witnesses() {
         2,
     );
     let solver = BruteForce::new();
-    let witnesses = solver.find_all_witnesses(&problem);
+    let witnesses = solver.find_all_witnesses(&problem).unwrap();
     // Issue says 2 optimal assignments (mirror pair)
     assert_eq!(witnesses.len(), 2);
     for w in &witnesses {
-        assert_eq!(problem.evaluate(w), Min(Some(47)));
+        assert_eq!(problem.evaluate(w).unwrap(), Min(Some(47)));
     }
 }
 
@@ -148,8 +177,8 @@ fn test_scheduling_min_wct_zero_weight() {
 fn test_scheduling_min_wct_single_task() {
     let problem = SchedulingToMinimizeWeightedCompletionTime::new(vec![5], vec![3], 2);
     // Task 0 on processor 0: C(0) = 5, WCT = 5*3 = 15
-    assert_eq!(problem.evaluate(&[0]), Min(Some(15)));
-    assert_eq!(problem.evaluate(&[1]), Min(Some(15)));
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Min(Some(15)));
+    assert_eq!(problem.evaluate(&vec![1]).unwrap(), Min(Some(15)));
 }
 
 #[test]
@@ -160,17 +189,17 @@ fn test_scheduling_min_wct_single_processor() {
     // Order: t1, t0
     // C(t1) = 1, C(t0) = 3
     // WCT = 1*3 + 3*1 = 6
-    assert_eq!(problem.evaluate(&[0, 0]), Min(Some(6)));
+    assert_eq!(problem.evaluate(&vec![0, 0]).unwrap(), Min(Some(6)));
 }
 
 #[test]
 fn test_scheduling_min_wct_three_processors() {
     let problem = SchedulingToMinimizeWeightedCompletionTime::new(vec![3, 3, 3], vec![1, 1, 1], 3);
-    assert_eq!(problem.dims(), vec![3; 3]);
+    assert_eq!(problem.dimensions(), vec![3; 3]);
     // One task per processor: each completes at 3, WCT = 3*1 + 3*1 + 3*1 = 9
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(Some(9)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2]).unwrap(), Min(Some(9)));
     // All on one processor: C(t0)=3, C(t1)=6, C(t2)=9, WCT = 3+6+9 = 18
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(Some(18)));
+    assert_eq!(problem.evaluate(&vec![0, 0, 0]).unwrap(), Min(Some(18)));
 }
 
 #[test]
@@ -186,9 +215,12 @@ fn test_scheduling_min_wct_paper_example() {
     // P1={t1,t3}: Smith order t1(0.5), t3(2.0)
     //   C(t1)=2 => 2*4=8, C(t3)=6 => 6*2=12, subtotal=20
     // Total = 47
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1, 0]), Min(Some(47)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 1, 0, 1, 0]).unwrap(),
+        Min(Some(47))
+    );
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&witness), Min(Some(47)));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(47)));
 }
diff --git a/src/unit_tests/models/misc/scheduling_with_individual_deadlines.rs b/src/unit_tests/models/misc/scheduling_with_individual_deadlines.rs
index 19ae0cab4..3a017d7a4 100644
--- a/src/unit_tests/models/misc/scheduling_with_individual_deadlines.rs
+++ b/src/unit_tests/models/misc/scheduling_with_individual_deadlines.rs
@@ -1,4 +1,22 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_deadline_count_mismatch() {
+    assert_eq!(
+        SchedulingWithIndividualDeadlinesCreateSpec::FIELDS[2].name,
+        "deadlines"
+    );
+    assert!(SchedulingWithIndividualDeadlines::try_from(
+        SchedulingWithIndividualDeadlinesCreateSpec {
+            num_tasks: 2,
+            num_processors: 1,
+            deadlines: vec![1],
+            precedences: None
+        }
+    )
+    .is_err());
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
@@ -24,7 +42,7 @@ fn test_scheduling_with_individual_deadlines_basic() {
     );
     assert_eq!(problem.num_precedences(), 5);
     assert_eq!(problem.max_deadline(), 3);
-    assert_eq!(problem.dims(), vec![2, 1, 2, 2, 3, 3, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 1, 2, 2, 3, 3, 2]);
     assert_eq!(
         <SchedulingWithIndividualDeadlines as Problem>::NAME,
         "SchedulingWithIndividualDeadlines"
@@ -39,54 +57,75 @@ fn test_scheduling_with_individual_deadlines_basic() {
 fn test_scheduling_with_individual_deadlines_evaluate_issue_example() {
     let problem = issue_example_problem();
 
-    assert!(problem.evaluate(&[0, 0, 0, 1, 2, 1, 1]));
+    assert!(problem.evaluate(&vec![0, 0, 0, 1, 2, 1, 1]).unwrap());
 }
 
 #[test]
 fn test_scheduling_with_individual_deadlines_evaluate_rejects_wrong_length() {
     let problem = issue_example_problem();
 
-    assert!(!problem.evaluate(&[0, 0, 0]));
-    assert!(!problem.evaluate(&[0, 0, 0, 1, 2, 1, 1, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 1, 2, 1, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_scheduling_with_individual_deadlines_evaluate_rejects_deadline_violation() {
     let problem = issue_example_problem();
 
-    assert!(!problem.evaluate(&[0, 1, 0, 1, 2, 1, 1]));
+    assert!(!problem.evaluate(&vec![0, 1, 0, 1, 2, 1, 1]).unwrap());
 }
 
 #[test]
 fn test_scheduling_with_individual_deadlines_evaluate_rejects_precedence_violation() {
     let problem = issue_example_problem();
 
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 2, 1, 1]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 0, 2, 1, 1]).unwrap());
 }
 
 #[test]
 fn test_scheduling_with_individual_deadlines_evaluate_rejects_capacity_violation() {
     let problem = issue_example_problem();
 
-    assert!(!problem.evaluate(&[0, 0, 0, 1, 2, 1, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 1, 2, 1, 0]).unwrap());
 }
 
 #[test]
 fn test_scheduling_with_individual_deadlines_evaluate_handles_huge_sparse_deadline() {
-    let problem = SchedulingWithIndividualDeadlines::new(1, 1, vec![usize::MAX], vec![]);
+    let problem = SchedulingWithIndividualDeadlines::new(1, 1, vec![i64::MAX], vec![]);
 
-    let result = std::panic::catch_unwind(|| problem.evaluate(&[0]));
+    let result = std::panic::catch_unwind(|| problem.evaluate(&vec![0]).unwrap());
 
     assert!(matches!(result, Ok(crate::types::Or(true))));
 }
 
+#[test]
+fn test_scheduling_with_individual_deadlines_slots_can_exceed_task_count() {
+    let problem = SchedulingWithIndividualDeadlines::new(1, 1, vec![3], vec![]);
+    assert!(problem.evaluate(&vec![1]).unwrap());
+    assert_eq!(
+        BruteForce::new().find_all_witnesses(&problem).unwrap(),
+        vec![vec![0], vec![1], vec![2]]
+    );
+    assert!(!problem.evaluate(&vec![3]).unwrap());
+    assert!(!problem.evaluate(&vec![usize::MAX]).unwrap());
+}
+
 #[test]
 fn test_scheduling_with_individual_deadlines_brute_force_satisfiable() {
     let problem = SchedulingWithIndividualDeadlines::new(3, 2, vec![1, 1, 2], vec![(0, 2)]);
     let solver = BruteForce::new();
 
-    assert_eq!(solver.find_all_witnesses(&problem), vec![vec![0, 0, 1]]);
-    assert_eq!(solver.find_witness(&problem), Some(vec![0, 0, 1]));
+    assert_eq!(
+        solver.find_all_witnesses(&problem).unwrap(),
+        vec![vec![0, 0, 1]]
+    );
+    assert_eq!(solver.solve(&problem).unwrap(), Some(vec![0, 0, 1]));
 }
 
 #[test]
@@ -94,7 +133,7 @@ fn test_scheduling_with_individual_deadlines_brute_force_unsatisfiable() {
     let problem = SchedulingWithIndividualDeadlines::new(3, 1, vec![1, 1, 1], vec![]);
     let solver = BruteForce::new();
 
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -114,11 +153,14 @@ fn test_scheduling_with_individual_deadlines_paper_example() {
     let problem = issue_example_problem();
     let solver = BruteForce::new();
 
-    let satisfying = solver.find_all_witnesses(&problem);
+    let satisfying = solver.find_all_witnesses(&problem).unwrap();
 
-    assert!(problem.evaluate(&[0, 0, 0, 1, 2, 1, 1]));
+    assert!(problem.evaluate(&vec![0, 0, 0, 1, 2, 1, 1]).unwrap());
     assert!(satisfying.contains(&vec![0, 0, 0, 1, 2, 1, 1]));
-    assert_eq!(solver.find_witness(&problem), satisfying.into_iter().next());
+    assert_eq!(
+        solver.solve(&problem).unwrap(),
+        satisfying.into_iter().next()
+    );
 }
 
 #[test]
@@ -132,3 +174,16 @@ fn test_scheduling_with_individual_deadlines_mismatched_deadlines() {
 fn test_scheduling_with_individual_deadlines_invalid_precedence() {
     SchedulingWithIndividualDeadlines::new(3, 2, vec![1, 1, 1], vec![(4, 1)]);
 }
+#[test]
+fn create_spec_defaults_precedences_to_empty() {
+    let problem =
+        SchedulingWithIndividualDeadlines::try_from(SchedulingWithIndividualDeadlinesCreateSpec {
+            num_tasks: 2,
+            num_processors: 1,
+            deadlines: vec![1, 2],
+            precedences: None,
+        })
+        .unwrap();
+    assert!(problem.precedences().is_empty());
+    assert!(!SchedulingWithIndividualDeadlinesCreateSpec::inputs()[3].required);
+}
diff --git a/src/unit_tests/models/misc/sequencing_to_minimize_maximum_cumulative_cost.rs b/src/unit_tests/models/misc/sequencing_to_minimize_maximum_cumulative_cost.rs
index a463b1a9b..de3ae8efe 100644
--- a/src/unit_tests/models/misc/sequencing_to_minimize_maximum_cumulative_cost.rs
+++ b/src/unit_tests/models/misc/sequencing_to_minimize_maximum_cumulative_cost.rs
@@ -1,4 +1,16 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_precedences() {
+    let problem =
+        SequencingToMinimizeMaximumCumulativeCost::try_from(SequencingCumulativeCostCreateSpec {
+            costs: vec![1, -1],
+            precedences: None,
+        })
+        .unwrap();
+    assert!(problem.precedences().is_empty());
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -20,7 +32,7 @@ fn test_sequencing_to_minimize_maximum_cumulative_cost_creation() {
     );
     assert_eq!(problem.num_tasks(), 6);
     assert_eq!(problem.num_precedences(), 6);
-    assert_eq!(problem.dims(), vec![6, 5, 4, 3, 2, 1]);
+    assert_eq!(problem.dimensions(), vec![6, 5, 4, 3, 2, 1]);
     assert_eq!(
         <SequencingToMinimizeMaximumCumulativeCost as Problem>::NAME,
         "SequencingToMinimizeMaximumCumulativeCost"
@@ -38,8 +50,8 @@ fn test_sequencing_to_minimize_maximum_cumulative_cost_evaluate_valid_schedule()
     // Task order [1, 0, 3, 2, 4, 5]:
     // cumulative sums: -1, 1, -1, 2, 3, 0
     // max cumulative cost = 3
-    let config = vec![1, 0, 1, 0, 0, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(3)));
+    let config = vec![1, 0, 3, 2, 4, 5];
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(3)));
 }
 
 #[test]
@@ -48,7 +60,10 @@ fn test_sequencing_to_minimize_maximum_cumulative_cost_evaluate_identity_order()
 
     // Identity order [0,1,2,3,4,5] reaches prefix sums 2,1,4,2,3,0.
     // max cumulative cost = 4
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0, 0]), Min(Some(4)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 1, 2, 3, 4, 5]).unwrap(),
+        Min(Some(4))
+    );
 }
 
 #[test]
@@ -56,15 +71,27 @@ fn test_sequencing_to_minimize_maximum_cumulative_cost_precedence_violation() {
     let problem = issue_example();
 
     // Task order [2, 0, 1, 3, 4, 5] violates precedence 0 -> 2.
-    assert_eq!(problem.evaluate(&[2, 0, 0, 0, 0, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![2, 0, 1, 3, 4, 5]).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_sequencing_to_minimize_maximum_cumulative_cost_invalid_config() {
     let problem = issue_example();
-    assert_eq!(problem.evaluate(&[6, 0, 0, 0, 0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[1, 0, 1, 0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[1, 0, 1, 0, 0, 0, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![6, 0, 0, 0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![1, 0, 3, 2, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![1, 0, 3, 2, 4, 5, 6]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -72,9 +99,10 @@ fn test_sequencing_to_minimize_maximum_cumulative_cost_brute_force_solver() {
     let problem = issue_example();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find an optimal schedule");
-    assert_eq!(problem.evaluate(&solution), Min(Some(3)));
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(3)));
 }
 
 #[test]
@@ -84,15 +112,15 @@ fn test_sequencing_to_minimize_maximum_cumulative_cost_unsatisfiable_cycle() {
         vec![(0, 1), (1, 2), (2, 0)],
     );
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_sequencing_to_minimize_maximum_cumulative_cost_solver_aggregate() {
-    use crate::solvers::Solver;
     let problem = issue_example();
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(3)));
 }
 
@@ -100,9 +128,9 @@ fn test_sequencing_to_minimize_maximum_cumulative_cost_solver_aggregate() {
 fn test_sequencing_to_minimize_maximum_cumulative_cost_empty_instance() {
     let problem = SequencingToMinimizeMaximumCumulativeCost::new(vec![], vec![]);
     assert_eq!(problem.num_tasks(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
     // Empty schedule: no tasks, max cumulative cost is 0.
-    let val = problem.evaluate(&[]);
+    let val = problem.evaluate(&vec![]).unwrap();
     assert_eq!(val, Min(Some(0)));
 }
 
diff --git a/src/unit_tests/models/misc/sequencing_to_minimize_tardy_task_weight.rs b/src/unit_tests/models/misc/sequencing_to_minimize_tardy_task_weight.rs
index 023b18c75..feae2b123 100644
--- a/src/unit_tests/models/misc/sequencing_to_minimize_tardy_task_weight.rs
+++ b/src/unit_tests/models/misc/sequencing_to_minimize_tardy_task_weight.rs
@@ -1,4 +1,18 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_task_weights() {
+    let p = SequencingToMinimizeTardyTaskWeight::try_from(
+        SequencingToMinimizeTardyTaskWeightCreateSpec {
+            lengths: vec![1, 2],
+            weights: None,
+            deadlines: vec![1, 3],
+        },
+    )
+    .unwrap();
+    assert_eq!(p.weights(), &[1, 1]);
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -15,7 +29,7 @@ fn test_sequencing_to_minimize_tardy_task_weight_basic() {
     assert_eq!(problem.lengths(), &[3, 2, 4, 1, 2]);
     assert_eq!(problem.weights(), &[5, 3, 7, 2, 4]);
     assert_eq!(problem.deadlines(), &[6, 4, 10, 2, 8]);
-    assert_eq!(problem.dims(), vec![5, 5, 5, 5, 5]);
+    assert_eq!(problem.dimensions(), vec![5, 5, 5, 5, 5]);
     assert_eq!(
         <SequencingToMinimizeTardyTaskWeight as Problem>::NAME,
         "SequencingToMinimizeTardyTaskWeight"
@@ -41,7 +55,10 @@ fn test_sequencing_to_minimize_tardy_task_weight_evaluate_issue_example() {
     // t2: completes at 6+4=10, deadline=10, on time
     // t1: completes at 10+2=12, deadline=4, TARDY weight=3
     // Total = 3
-    assert_eq!(problem.evaluate(&[3, 0, 4, 2, 1]), Min(Some(3)));
+    assert_eq!(
+        problem.evaluate(&vec![3, 0, 4, 2, 1]).unwrap(),
+        Min(Some(3))
+    );
 }
 
 #[test]
@@ -49,8 +66,8 @@ fn test_sequencing_to_minimize_tardy_task_weight_evaluate_all_on_time() {
     // Single task with generous deadline
     let problem = SequencingToMinimizeTardyTaskWeight::new(vec![2, 3], vec![5, 4], vec![10, 10]);
     // Both orders: no task is tardy
-    assert_eq!(problem.evaluate(&[0, 1]), Min(Some(0)));
-    assert_eq!(problem.evaluate(&[1, 0]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![0, 1]).unwrap(), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![1, 0]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -59,7 +76,7 @@ fn test_sequencing_to_minimize_tardy_task_weight_evaluate_all_tardy() {
     let problem =
         SequencingToMinimizeTardyTaskWeight::new(vec![3, 3, 3], vec![1, 2, 3], vec![2, 2, 2]);
     // [0,1,2]: t0 completes 3>2 tardy(1), t1 completes 6>2 tardy(2), t2 completes 9>2 tardy(3) = 6
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(Some(6)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2]).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -68,12 +85,21 @@ fn test_sequencing_to_minimize_tardy_task_weight_evaluate_invalid_config() {
         SequencingToMinimizeTardyTaskWeight::new(vec![2, 3, 1], vec![1, 2, 3], vec![5, 6, 7]);
 
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 1]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Not a permutation (duplicate)
-    assert_eq!(problem.evaluate(&[0, 0, 1]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 0, 1]).unwrap(), Min(None));
     // Out of range
-    assert_eq!(problem.evaluate(&[0, 1, 3]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -83,9 +109,10 @@ fn test_sequencing_to_minimize_tardy_task_weight_brute_force_small() {
         SequencingToMinimizeTardyTaskWeight::new(vec![3, 2, 1], vec![4, 2, 3], vec![4, 3, 6]);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let value = problem.evaluate(&solution);
+    let value = problem.evaluate(&solution).unwrap();
     assert!(value.is_valid());
 
     // Check it's truly optimal by brute-forcing all permutations
@@ -99,7 +126,7 @@ fn test_sequencing_to_minimize_tardy_task_weight_brute_force_small() {
     ];
     let best = permutations
         .iter()
-        .filter_map(|perm| problem.evaluate(perm).0)
+        .filter_map(|perm| problem.evaluate(perm).unwrap().0)
         .min()
         .unwrap();
     assert_eq!(value, Min(Some(best)));
@@ -113,13 +140,14 @@ fn test_sequencing_to_minimize_tardy_task_weight_paper_example() {
         vec![6, 4, 10, 2, 8],
     );
     let expected_config = vec![3, 0, 4, 2, 1];
-    assert_eq!(problem.evaluate(&expected_config), Min(Some(3)));
+    assert_eq!(problem.evaluate(&expected_config).unwrap(), Min(Some(3)));
 
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert_eq!(problem.evaluate(&solution), Min(Some(3)));
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(3)));
 }
 
 #[test]
@@ -159,24 +187,24 @@ fn test_sequencing_to_minimize_tardy_task_weight_deserialization_rejects_zero_we
 #[test]
 fn test_sequencing_to_minimize_tardy_task_weight_single_task() {
     let problem = SequencingToMinimizeTardyTaskWeight::new(vec![3], vec![2], vec![5]);
-    assert_eq!(problem.dims(), vec![1]);
+    assert_eq!(problem.dimensions(), vec![1]);
     // completes at 3, deadline 5, on time
-    assert_eq!(problem.evaluate(&[0]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Min(Some(0)));
 }
 
 #[test]
 fn test_sequencing_to_minimize_tardy_task_weight_single_task_tardy() {
     let problem = SequencingToMinimizeTardyTaskWeight::new(vec![3], vec![2], vec![2]);
     // completes at 3, deadline 2, tardy, weight 2
-    assert_eq!(problem.evaluate(&[0]), Min(Some(2)));
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_sequencing_to_minimize_tardy_task_weight_empty() {
     let problem = SequencingToMinimizeTardyTaskWeight::new(vec![], vec![], vec![]);
     assert_eq!(problem.num_tasks(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/sequencing_to_minimize_weighted_completion_time.rs b/src/unit_tests/models/misc/sequencing_to_minimize_weighted_completion_time.rs
index 58a40b00a..97c31b24d 100644
--- a/src/unit_tests/models/misc/sequencing_to_minimize_weighted_completion_time.rs
+++ b/src/unit_tests/models/misc/sequencing_to_minimize_weighted_completion_time.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -16,8 +17,7 @@ fn test_sequencing_to_minimize_weighted_completion_time_basic() {
     assert_eq!(problem.weights(), &[3, 5, 1, 4, 2]);
     assert_eq!(problem.precedences(), &[(0, 2), (1, 4)]);
     assert_eq!(problem.num_precedences(), 2);
-    assert_eq!(problem.total_processing_time(), 9);
-    assert_eq!(problem.dims(), vec![5, 4, 3, 2, 1]);
+    assert_eq!(problem.dimensions(), vec![5, 4, 3, 2, 1]);
     assert_eq!(
         <SequencingToMinimizeWeightedCompletionTime as Problem>::NAME,
         "SequencingToMinimizeWeightedCompletionTime"
@@ -36,19 +36,25 @@ fn test_sequencing_to_minimize_weighted_completion_time_evaluate_issue_example()
         vec![(0, 2), (1, 4)],
     );
 
-    // Lehmer [1,2,0,1,0] decodes to schedule [1,3,0,4,2].
+    // Schedule [1,3,0,4,2].
     // Completion times are [4,1,9,2,6], so the objective is
     // 3*4 + 5*1 + 1*9 + 4*2 + 2*6 = 46.
-    assert_eq!(problem.evaluate(&[1, 2, 0, 1, 0]), Min(Some(46)));
+    assert_eq!(
+        problem.evaluate(&vec![1, 3, 0, 4, 2]).unwrap(),
+        Min(Some(46))
+    );
 }
 
 #[test]
-fn test_sequencing_to_minimize_weighted_completion_time_evaluate_invalid_lehmer() {
+fn test_sequencing_to_minimize_weighted_completion_time_evaluate_invalid_permutation() {
     let problem =
         SequencingToMinimizeWeightedCompletionTime::new(vec![2, 1, 3], vec![3, 5, 1], vec![]);
 
-    assert_eq!(problem.evaluate(&[0, 2, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 5]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 2, 0]).unwrap(), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -56,8 +62,14 @@ fn test_sequencing_to_minimize_weighted_completion_time_evaluate_wrong_length()
     let problem =
         SequencingToMinimizeWeightedCompletionTime::new(vec![2, 1, 3], vec![3, 5, 1], vec![]);
 
-    assert_eq!(problem.evaluate(&[0, 1]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -65,8 +77,8 @@ fn test_sequencing_to_minimize_weighted_completion_time_evaluate_precedence_viol
     let problem =
         SequencingToMinimizeWeightedCompletionTime::new(vec![2, 1, 3], vec![3, 5, 1], vec![(0, 1)]);
 
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(Some(27)));
-    assert_eq!(problem.evaluate(&[1, 0, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2]).unwrap(), Min(Some(27)));
+    assert_eq!(problem.evaluate(&vec![1, 0, 2]).unwrap(), Min(None));
 }
 
 #[test]
@@ -78,11 +90,12 @@ fn test_sequencing_to_minimize_weighted_completion_time_brute_force() {
     );
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
 
-    assert_eq!(solution, vec![1, 2, 0, 1, 0]);
-    assert_eq!(problem.evaluate(&solution), Min(Some(46)));
+    assert_eq!(solution, vec![1, 3, 0, 4, 2]);
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(46)));
 }
 
 #[test]
@@ -109,7 +122,6 @@ fn test_sequencing_to_minimize_weighted_completion_time_deserialization_allows_z
         .unwrap();
 
     assert_eq!(problem.lengths(), &[0, 1, 3]);
-    assert_eq!(problem.total_processing_time(), 4);
 }
 
 #[test]
@@ -117,16 +129,16 @@ fn test_sequencing_to_minimize_weighted_completion_time_empty() {
     let problem = SequencingToMinimizeWeightedCompletionTime::new(vec![], vec![], vec![]);
 
     assert_eq!(problem.num_tasks(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
 fn test_sequencing_to_minimize_weighted_completion_time_single_task() {
     let problem = SequencingToMinimizeWeightedCompletionTime::new(vec![3], vec![2], vec![]);
 
-    assert_eq!(problem.dims(), vec![1]);
-    assert_eq!(problem.evaluate(&[0]), Min(Some(6)));
+    assert_eq!(problem.dimensions(), vec![1]);
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Min(Some(6)));
 }
 
 #[test]
@@ -147,9 +159,9 @@ fn test_sequencing_to_minimize_weighted_completion_time_zero_length_task() {
         SequencingToMinimizeWeightedCompletionTime::new(vec![0, 1, 3], vec![3, 5, 1], vec![]);
 
     assert_eq!(problem.lengths(), &[0, 1, 3]);
-    // Lehmer [0,0,0] decodes to schedule [0,1,2]; C = [0, 1, 4]; weighted sum
+    // Schedule [0,1,2]; C = [0, 1, 4]; weighted sum
     // = 3*0 + 5*1 + 1*4 = 9.
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(Some(9)));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2]).unwrap(), Min(Some(9)));
 }
 
 #[test]
@@ -161,7 +173,7 @@ fn test_sequencing_to_minimize_weighted_completion_time_cyclic_precedences() {
     );
     let solver = BruteForce::new();
 
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -171,30 +183,38 @@ fn test_sequencing_to_minimize_weighted_completion_time_paper_example() {
         vec![3, 5, 1, 4, 2],
         vec![(0, 2), (1, 4)],
     );
-    let expected = vec![1, 2, 0, 1, 0];
+    let expected = vec![1, 3, 0, 4, 2];
 
-    assert_eq!(problem.evaluate(&expected), Min(Some(46)));
+    assert_eq!(problem.evaluate(&expected).unwrap(), Min(Some(46)));
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions, vec![expected]);
 }
 
 #[test]
-#[should_panic(expected = "weighted completion time overflowed u64")]
 fn test_sequencing_to_minimize_weighted_completion_time_weighted_sum_overflow() {
     let problem = SequencingToMinimizeWeightedCompletionTime::new(
         vec![1, 1],
-        vec![u64::MAX, u64::MAX],
+        vec![i64::MAX, i64::MAX],
         vec![],
     );
-    let _ = problem.evaluate(&[0, 0]);
-}
-
-#[test]
-#[should_panic(expected = "total processing time overflowed u64")]
-fn test_sequencing_to_minimize_weighted_completion_time_total_processing_time_overflow() {
-    let problem =
-        SequencingToMinimizeWeightedCompletionTime::new(vec![u64::MAX, 1], vec![1, 1], vec![]);
-    let _ = problem.total_processing_time();
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
+}
+
+#[test]
+fn create_spec_defaults_precedences_to_empty() {
+    let problem = SequencingToMinimizeWeightedCompletionTime::try_from(
+        SequencingToMinimizeWeightedCompletionTimeCreateSpec {
+            lengths: vec![1, 2],
+            weights: vec![3, 4],
+            precedences: None,
+        },
+    )
+    .unwrap();
+    assert!(problem.precedences().is_empty());
+    assert!(!SequencingToMinimizeWeightedCompletionTimeCreateSpec::inputs()[2].required);
 }
diff --git a/src/unit_tests/models/misc/sequencing_to_minimize_weighted_tardiness.rs b/src/unit_tests/models/misc/sequencing_to_minimize_weighted_tardiness.rs
index b0d45b8f4..3214d9c90 100644
--- a/src/unit_tests/models/misc/sequencing_to_minimize_weighted_tardiness.rs
+++ b/src/unit_tests/models/misc/sequencing_to_minimize_weighted_tardiness.rs
@@ -1,4 +1,22 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_vector_length_mismatch() {
+    assert_eq!(
+        SequencingToMinimizeWeightedTardinessCreateSpec::FIELDS[1].name,
+        "weights"
+    );
+    assert!(SequencingToMinimizeWeightedTardiness::try_from(
+        SequencingToMinimizeWeightedTardinessCreateSpec {
+            lengths: vec![1],
+            weights: vec![],
+            deadlines: vec![1],
+            bound: 0
+        }
+    )
+    .is_err());
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
@@ -29,7 +47,7 @@ fn test_sequencing_to_minimize_weighted_tardiness_basic() {
     assert_eq!(problem.deadlines(), &[5, 8, 4, 15, 10]);
     assert_eq!(problem.bound(), 13);
     assert_eq!(problem.num_tasks(), 5);
-    assert_eq!(problem.dims(), vec![5, 4, 3, 2, 1]);
+    assert_eq!(problem.dimensions(), vec![5, 4, 3, 2, 1]);
     assert_eq!(
         <SequencingToMinimizeWeightedTardiness as Problem>::NAME,
         "SequencingToMinimizeWeightedTardiness"
@@ -43,33 +61,59 @@ fn test_sequencing_to_minimize_weighted_tardiness_basic() {
 #[test]
 fn test_sequencing_to_minimize_weighted_tardiness_total_weighted_tardiness() {
     let problem = issue_example_yes();
-    assert_eq!(problem.total_weighted_tardiness(&[0, 0, 2, 1, 0]), Some(13));
+    assert_eq!(
+        problem.total_weighted_tardiness(&[0, 1, 4, 3, 2]).unwrap(),
+        Some(13)
+    );
+}
+
+#[test]
+fn test_sequencing_to_minimize_weighted_tardiness_reports_overflow() {
+    let problem = SequencingToMinimizeWeightedTardiness::new(
+        vec![i64::MAX, 1],
+        vec![1, 1],
+        vec![0, 0],
+        i64::MAX,
+    );
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
 }
 
 #[test]
 fn test_sequencing_to_minimize_weighted_tardiness_evaluate_yes() {
     let problem = issue_example_yes();
-    assert!(problem.evaluate(&[0, 0, 2, 1, 0]));
+    assert!(problem.evaluate(&vec![0, 1, 4, 3, 2]).unwrap());
 }
 
 #[test]
 fn test_sequencing_to_minimize_weighted_tardiness_evaluate_no_with_tighter_bound() {
     let problem = issue_example_no();
-    assert!(!problem.evaluate(&[0, 0, 2, 1, 0]));
+    assert!(!problem.evaluate(&vec![0, 1, 4, 3, 2]).unwrap());
 }
 
 #[test]
-fn test_sequencing_to_minimize_weighted_tardiness_invalid_lehmer_digit() {
+fn test_sequencing_to_minimize_weighted_tardiness_invalid_permutation() {
     let problem = issue_example_yes();
-    assert_eq!(problem.total_weighted_tardiness(&[0, 0, 3, 0, 0]), None);
-    assert!(!problem.evaluate(&[0, 0, 3, 0, 0]));
+    assert_eq!(
+        problem.total_weighted_tardiness(&[0, 1, 1, 3, 4]).unwrap(),
+        None
+    );
+    assert!(!problem.evaluate(&vec![0, 1, 1, 3, 4]).unwrap());
 }
 
 #[test]
 fn test_sequencing_to_minimize_weighted_tardiness_wrong_length() {
     let problem = issue_example_yes();
-    assert_eq!(problem.total_weighted_tardiness(&[0, 0, 2, 1]), None);
-    assert!(!problem.evaluate(&[0, 0, 2, 1]));
+    assert_eq!(
+        problem.total_weighted_tardiness(&[0, 0, 2, 1]).unwrap(),
+        None
+    );
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 2, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -77,18 +121,25 @@ fn test_sequencing_to_minimize_weighted_tardiness_solver_yes() {
     let problem = issue_example_yes();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a schedule");
-    assert!(problem.evaluate(&solution));
-    assert!(problem.total_weighted_tardiness(&solution).unwrap() <= problem.bound());
+    assert!(problem.evaluate(&solution).unwrap());
+    assert!(
+        problem
+            .total_weighted_tardiness(&solution)
+            .unwrap()
+            .unwrap()
+            <= problem.bound()
+    );
 }
 
 #[test]
 fn test_sequencing_to_minimize_weighted_tardiness_solver_no() {
     let problem = issue_example_no();
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+    assert!(solver.solve(&problem).unwrap().is_none());
+    assert!(solver.find_all_witnesses(&problem).unwrap().is_empty());
 }
 
 #[test]
@@ -96,15 +147,15 @@ fn test_sequencing_to_minimize_weighted_tardiness_paper_example() {
     let yes = issue_example_yes();
     let no = issue_example_no();
     let solver = BruteForce::new();
-    let config = vec![0, 0, 2, 1, 0];
+    let config = vec![0, 1, 4, 3, 2];
 
-    assert_eq!(yes.total_weighted_tardiness(&config), Some(13));
-    assert!(yes.evaluate(&config));
-    assert!(!no.evaluate(&config));
+    assert_eq!(yes.total_weighted_tardiness(&config).unwrap(), Some(13));
+    assert!(yes.evaluate(&config).unwrap());
+    assert!(!no.evaluate(&config).unwrap());
 
-    let satisfying = solver.find_all_witnesses(&yes);
+    let satisfying = solver.find_all_witnesses(&yes).unwrap();
     assert_eq!(satisfying, vec![config]);
-    assert!(solver.find_all_witnesses(&no).is_empty());
+    assert!(solver.find_all_witnesses(&no).unwrap().is_empty());
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/sequencing_with_deadlines_and_set_up_times.rs b/src/unit_tests/models/misc/sequencing_with_deadlines_and_set_up_times.rs
index eac5475d0..26f9f9f0a 100644
--- a/src/unit_tests/models/misc/sequencing_with_deadlines_and_set_up_times.rs
+++ b/src/unit_tests/models/misc/sequencing_with_deadlines_and_set_up_times.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -18,7 +19,7 @@ fn test_sequencing_with_deadlines_and_set_up_times_creation() {
     assert_eq!(problem.deadlines(), &[4, 11, 3, 16, 7]);
     assert_eq!(problem.compilers(), &[0, 1, 0, 1, 0]);
     assert_eq!(problem.setup_times(), &[1, 2]);
-    assert_eq!(problem.dims(), vec![5, 5, 5, 5, 5]);
+    assert_eq!(problem.dimensions(), vec![5, 5, 5, 5, 5]);
     assert_eq!(
         <SequencingWithDeadlinesAndSetUpTimes as Problem>::NAME,
         "SequencingWithDeadlinesAndSetUpTimes"
@@ -44,7 +45,7 @@ fn test_sequencing_with_deadlines_and_set_up_times_evaluate_feasible() {
     // Position 2: task 4 (compiler 0), same     → elapsed = 3+2 = 5  ≤ 7 ✓
     // Position 3: task 1 (compiler 1), switch s[1]=2 → elapsed = 5+2+3 = 10 ≤ 11 ✓
     // Position 4: task 3 (compiler 1), same     → elapsed = 10+2 = 12 ≤ 16 ✓
-    assert_eq!(problem.evaluate(&[2, 0, 4, 1, 3]), Or(true));
+    assert_eq!(problem.evaluate(&vec![2, 0, 4, 1, 3]).unwrap(), Or(true));
 }
 
 #[test]
@@ -60,7 +61,7 @@ fn test_sequencing_with_deadlines_and_set_up_times_evaluate_infeasible() {
     // Position 0: task 0 (compiler 0), no prev  → elapsed = 0+2 = 2  ≤ 4 ✓
     // Position 1: task 1 (compiler 1), switch s[1]=2 → elapsed = 2+2+3 = 7 ≤ 11 ✓
     // Position 2: task 2 (compiler 0), switch s[0]=1 → elapsed = 7+1+1 = 9 > 3 ✗
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 4]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2, 3, 4]).unwrap(), Or(false));
 }
 
 #[test]
@@ -73,12 +74,21 @@ fn test_sequencing_with_deadlines_and_set_up_times_evaluate_invalid_permutation(
     );
 
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 1]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 0]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Duplicate
-    assert_eq!(problem.evaluate(&[0, 0, 1]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 0, 1]).unwrap(), Or(false));
     // Out of range
-    assert_eq!(problem.evaluate(&[0, 1, 3]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 3]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -92,9 +102,10 @@ fn test_sequencing_with_deadlines_and_set_up_times_brute_force_small() {
     );
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a feasible schedule");
-    assert_eq!(problem.evaluate(&solution), Or(true));
+    assert_eq!(problem.evaluate(&solution).unwrap(), Or(true));
 }
 
 #[test]
@@ -108,7 +119,7 @@ fn test_sequencing_with_deadlines_and_set_up_times_brute_force_infeasible() {
     );
     let solver = BruteForce::new();
     assert!(
-        solver.find_witness(&problem).is_none(),
+        solver.solve(&problem).unwrap().is_none(),
         "infeasible instance should return None"
     );
 }
@@ -122,13 +133,14 @@ fn test_sequencing_with_deadlines_and_set_up_times_paper_example() {
         vec![1, 2],
     );
     let expected_config = vec![2, 0, 4, 1, 3];
-    assert_eq!(problem.evaluate(&expected_config), Or(true));
+    assert_eq!(problem.evaluate(&expected_config).unwrap(), Or(true));
 
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("paper example should be feasible");
-    assert_eq!(problem.evaluate(&solution), Or(true));
+    assert_eq!(problem.evaluate(&solution).unwrap(), Or(true));
 }
 
 #[test]
@@ -180,11 +192,11 @@ fn test_sequencing_with_deadlines_and_set_up_times_setup_time_charged_on_switch(
     // Schedule [0,1]: elapsed after t0 = 1 ≤ 1 ✓; switch s[1]=2; elapsed = 1+2+1 = 4 ≤ 4 ✓
     let problem =
         SequencingWithDeadlinesAndSetUpTimes::new(vec![1, 1], vec![1, 4], vec![0, 1], vec![0, 2]);
-    assert_eq!(problem.evaluate(&[0, 1]), Or(true));
+    assert_eq!(problem.evaluate(&vec![0, 1]).unwrap(), Or(true));
     // Tight deadline: if setup charged, 1+2+1=4 > 3 ✗
     let tight =
         SequencingWithDeadlinesAndSetUpTimes::new(vec![1, 1], vec![1, 3], vec![0, 1], vec![0, 2]);
-    assert_eq!(tight.evaluate(&[0, 1]), Or(false));
+    assert_eq!(tight.evaluate(&vec![0, 1]).unwrap(), Or(false));
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/sequencing_with_release_times_and_deadlines.rs b/src/unit_tests/models/misc/sequencing_with_release_times_and_deadlines.rs
index 48c34ecfc..1c86ed2d8 100644
--- a/src/unit_tests/models/misc/sequencing_with_release_times_and_deadlines.rs
+++ b/src/unit_tests/models/misc/sequencing_with_release_times_and_deadlines.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -15,7 +16,7 @@ fn test_sequencing_rtd_basic() {
     assert_eq!(problem.deadlines(), &[5, 6, 10, 3, 12]);
     assert_eq!(problem.time_horizon(), 12);
     // Lehmer code dims: [5, 4, 3, 2, 1]
-    assert_eq!(problem.dims(), vec![5, 4, 3, 2, 1]);
+    assert_eq!(problem.dimensions(), vec![5, 4, 3, 2, 1]);
     assert_eq!(
         <SequencingWithReleaseTimesAndDeadlines as Problem>::NAME,
         "SequencingWithReleaseTimesAndDeadlines"
@@ -35,10 +36,10 @@ fn test_sequencing_rtd_evaluate_feasible() {
         vec![5, 6, 10, 3, 12],
     );
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
-    // Exactly one feasible schedule exists: Lehmer code [3, 0, 0, 0, 0]
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
+    // Exactly one feasible schedule exists: [3, 0, 1, 2, 4].
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![3, 0, 0, 0, 0]);
+    assert_eq!(solutions[0], vec![3, 0, 1, 2, 4]);
 }
 
 #[test]
@@ -49,16 +50,22 @@ fn test_sequencing_rtd_evaluate_infeasible_deadline() {
         vec![2, 4], // task 0 needs 3 time units but deadline is 2
     );
     // Order [0, 1]: t0 start=0, finish=3 > 2 -> infeasible
-    assert!(!problem.evaluate(&[0, 0]));
+    assert!(!problem.evaluate(&vec![0, 1]).unwrap());
     // Order [1, 0]: t1 start=0, finish=2; t0 start=2, finish=5 > 2 -> infeasible
-    assert!(!problem.evaluate(&[1, 0]));
+    assert!(!problem.evaluate(&vec![1, 0]).unwrap());
 }
 
 #[test]
 fn test_sequencing_rtd_evaluate_wrong_config_length() {
     let problem = SequencingWithReleaseTimesAndDeadlines::new(vec![1, 1], vec![0, 0], vec![2, 2]);
-    assert!(!problem.evaluate(&[0]));
-    assert!(!problem.evaluate(&[0, 0, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -66,16 +73,16 @@ fn test_sequencing_rtd_empty_instance() {
     let problem = SequencingWithReleaseTimesAndDeadlines::new(vec![], vec![], vec![]);
     assert_eq!(problem.num_tasks(), 0);
     assert_eq!(problem.time_horizon(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
 fn test_sequencing_rtd_single_task() {
     let problem = SequencingWithReleaseTimesAndDeadlines::new(vec![2], vec![1], vec![5]);
-    assert_eq!(problem.dims(), vec![1]);
+    assert_eq!(problem.dimensions(), vec![1]);
     // Only one permutation: task 0 starts at max(1,0)=1, finish=3 <= 5
-    assert!(problem.evaluate(&[0]));
+    assert!(problem.evaluate(&vec![0]).unwrap());
 }
 
 #[test]
@@ -85,19 +92,20 @@ fn test_sequencing_rtd_brute_force() {
         SequencingWithReleaseTimesAndDeadlines::new(vec![1, 2, 1], vec![0, 0, 2], vec![3, 3, 4]);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_sequencing_rtd_brute_force_all() {
     let problem = SequencingWithReleaseTimesAndDeadlines::new(vec![1, 1], vec![0, 0], vec![3, 3]);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -106,7 +114,7 @@ fn test_sequencing_rtd_unsatisfiable() {
     // Two tasks each need 2 time units but only 3 total time available
     let problem = SequencingWithReleaseTimesAndDeadlines::new(vec![2, 2], vec![0, 0], vec![3, 3]);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
@@ -126,14 +134,17 @@ fn test_sequencing_rtd_tight_schedule() {
     // Tasks that can only be scheduled in one specific order
     let problem = SequencingWithReleaseTimesAndDeadlines::new(vec![2, 2], vec![0, 2], vec![2, 4]);
     // Order [0, 1]: t0 start=max(0,0)=0, finish=2<=2; t1 start=max(2,2)=2, finish=4<=4 ✓
-    assert!(problem.evaluate(&[0, 0]));
+    assert!(problem.evaluate(&vec![0, 1]).unwrap());
     // Order [1, 0]: t1 start=max(2,0)=2, finish=4<=4; t0 start=max(0,4)=4, finish=6>2 ✗
-    assert!(!problem.evaluate(&[1, 0]));
+    assert!(!problem.evaluate(&vec![1, 0]).unwrap());
 }
 
 #[test]
-fn test_sequencing_rtd_invalid_lehmer_index() {
+fn test_sequencing_rtd_invalid_task_index() {
     let problem = SequencingWithReleaseTimesAndDeadlines::new(vec![1, 1], vec![0, 0], vec![2, 2]);
-    // config[0]=2 is out of range for available.len()=2
-    assert!(!problem.evaluate(&[2, 0]));
+    // Task index 2 is outside 0..2.
+    assert!(matches!(
+        problem.evaluate(&vec![2, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
diff --git a/src/unit_tests/models/misc/sequencing_within_intervals.rs b/src/unit_tests/models/misc/sequencing_within_intervals.rs
index a9a60ac2f..d040834e4 100644
--- a/src/unit_tests/models/misc/sequencing_within_intervals.rs
+++ b/src/unit_tests/models/misc/sequencing_within_intervals.rs
@@ -1,4 +1,20 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_accepts_empty_window() {
+    assert_eq!(
+        SequencingWithinIntervalsCreateSpec::FIELDS[0].name,
+        "release_times"
+    );
+    let problem = SequencingWithinIntervals::try_from(SequencingWithinIntervalsCreateSpec {
+        release_times: vec![2],
+        deadlines: vec![2],
+        lengths: vec![1],
+    })
+    .unwrap();
+    assert!(BruteForce::new().solve(&problem).unwrap().is_none());
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
@@ -9,7 +25,8 @@ fn test_sequencing_within_intervals_creation() {
         vec![0, 1, 3, 6, 0],
         vec![5, 8, 9, 12, 12],
         vec![2, 2, 2, 3, 2],
-    );
+    )
+    .unwrap();
     assert_eq!(problem.num_tasks(), 5);
     assert_eq!(problem.release_times(), &[0, 1, 3, 6, 0]);
     assert_eq!(problem.deadlines(), &[5, 8, 9, 12, 12]);
@@ -20,7 +37,7 @@ fn test_sequencing_within_intervals_creation() {
     // Task 2: 9 - 3 - 2 + 1 = 5
     // Task 3: 12 - 6 - 3 + 1 = 4
     // Task 4: 12 - 0 - 2 + 1 = 11
-    assert_eq!(problem.dims(), vec![4, 6, 5, 4, 11]);
+    assert_eq!(problem.dimensions(), vec![4, 6, 5, 4, 11]);
 }
 
 #[test]
@@ -29,14 +46,15 @@ fn test_sequencing_within_intervals_evaluation_feasible() {
         vec![0, 1, 3, 6, 0],
         vec![5, 8, 9, 12, 12],
         vec![2, 2, 2, 3, 2],
-    );
+    )
+    .unwrap();
     // Task 0: config=0 -> start=0, runs [0,2)
     // Task 1: config=1 -> start=2, runs [2,4)
     // Task 2: config=1 -> start=4, runs [4,6)
     // Task 3: config=0 -> start=6, runs [6,9)
     // Task 4: config=9 -> start=9, runs [9,11)
     // No overlaps.
-    assert!(problem.evaluate(&[0, 1, 1, 0, 9]));
+    assert!(problem.evaluate(&vec![0, 1, 1, 0, 9]).unwrap());
 }
 
 #[test]
@@ -45,36 +63,47 @@ fn test_sequencing_within_intervals_evaluation_infeasible_overlap() {
         vec![0, 1, 3, 6, 0],
         vec![5, 8, 9, 12, 12],
         vec![2, 2, 2, 3, 2],
-    );
+    )
+    .unwrap();
     // Task 0: config=0 -> start=0, runs [0,2)
     // Task 1: config=0 -> start=1, runs [1,3) -- overlaps with task 0
-    assert!(!problem.evaluate(&[0, 0, 1, 0, 9]));
+    assert!(!problem.evaluate(&vec![0, 0, 1, 0, 9]).unwrap());
 }
 
 #[test]
 fn test_sequencing_within_intervals_evaluation_wrong_length() {
-    let problem = SequencingWithinIntervals::new(vec![0, 2], vec![3, 5], vec![2, 2]);
-    assert!(!problem.evaluate(&[0]));
-    assert!(!problem.evaluate(&[0, 0, 0]));
+    let problem = SequencingWithinIntervals::new(vec![0, 2], vec![3, 5], vec![2, 2]).unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_sequencing_within_intervals_evaluation_out_of_range() {
-    let problem = SequencingWithinIntervals::new(vec![0, 2], vec![3, 5], vec![2, 2]);
+    let problem = SequencingWithinIntervals::new(vec![0, 2], vec![3, 5], vec![2, 2]).unwrap();
     // Task 0: dims = 3 - 0 - 2 + 1 = 2, so config must be 0 or 1
     // Task 1: dims = 5 - 2 - 2 + 1 = 2, so config must be 0 or 1
-    assert!(!problem.evaluate(&[2, 0])); // out of range for task 0
+    assert!(matches!(
+        problem.evaluate(&vec![2, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_sequencing_within_intervals_solver() {
     // Simple instance: 3 tasks that can be scheduled sequentially
-    let problem = SequencingWithinIntervals::new(vec![0, 2, 4], vec![3, 5, 7], vec![2, 2, 2]);
+    let problem =
+        SequencingWithinIntervals::new(vec![0, 2, 4], vec![3, 5, 7], vec![2, 2, 2]).unwrap();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let config = solution.unwrap();
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
@@ -84,30 +113,33 @@ fn test_sequencing_within_intervals_solver_canonical() {
         vec![0, 1, 3, 6, 0],
         vec![5, 8, 9, 12, 12],
         vec![2, 2, 2, 3, 2],
-    );
+    )
+    .unwrap();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_some());
     let config = solution.unwrap();
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_sequencing_within_intervals_no_solution() {
     // Two tasks that must both use time [0,2), impossible without overlap
-    let problem = SequencingWithinIntervals::new(vec![0, 0], vec![2, 2], vec![2, 2]);
+    let problem = SequencingWithinIntervals::new(vec![0, 0], vec![2, 2], vec![2, 2]).unwrap();
     // Each task has dims = 2 - 0 - 2 + 1 = 1, so config can only be [0, 0]
     // Task 0: start=0, runs [0,2)
     // Task 1: start=0, runs [0,2) -> overlap
-    assert!(!problem.evaluate(&[0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0]).unwrap());
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
 #[test]
 fn test_sequencing_within_intervals_serialization() {
-    let problem = SequencingWithinIntervals::new(vec![0, 2, 4], vec![3, 5, 7], vec![2, 2, 2]);
+    let problem =
+        SequencingWithinIntervals::new(vec![0, 2, 4], vec![3, 5, 7], vec![2, 2, 2]).unwrap();
+    assert_eq!(problem.num_start_slots(), 6);
     let json = serde_json::to_value(&problem).unwrap();
     let restored: SequencingWithinIntervals = serde_json::from_value(json).unwrap();
     assert_eq!(restored.release_times(), problem.release_times());
@@ -117,10 +149,11 @@ fn test_sequencing_within_intervals_serialization() {
 
 #[test]
 fn test_sequencing_within_intervals_empty() {
-    let problem = SequencingWithinIntervals::new(vec![], vec![], vec![]);
+    let problem = SequencingWithinIntervals::new(vec![], vec![], vec![]).unwrap();
     assert_eq!(problem.num_tasks(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.num_start_slots(), 0);
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -139,28 +172,29 @@ fn test_sequencing_within_intervals_variant() {
 
 #[test]
 fn test_sequencing_within_intervals_single_task() {
-    let problem = SequencingWithinIntervals::new(vec![0], vec![5], vec![3]);
+    let problem = SequencingWithinIntervals::new(vec![0], vec![5], vec![3]).unwrap();
     // dims = 5 - 0 - 3 + 1 = 3
-    assert_eq!(problem.dims(), vec![3]);
+    assert_eq!(problem.dimensions(), vec![3]);
     // Any valid config should be feasible (only one task, no overlaps possible)
-    assert!(problem.evaluate(&[0]));
-    assert!(problem.evaluate(&[1]));
-    assert!(problem.evaluate(&[2]));
+    assert!(problem.evaluate(&vec![0]).unwrap());
+    assert!(problem.evaluate(&vec![1]).unwrap());
+    assert!(problem.evaluate(&vec![2]).unwrap());
 }
 
 #[test]
 fn test_sequencing_within_intervals_find_all_witnesses() {
-    // Issue #219 canonical instance: 5 tasks with overlapping windows
+    // Canonical instance: 5 tasks with overlapping windows
     // dims = [4, 6, 5, 4, 11], search space = 5280
     let problem = SequencingWithinIntervals::new(
         vec![0, 1, 3, 6, 0],
         vec![5, 8, 9, 12, 12],
         vec![2, 2, 2, 3, 2],
-    );
+    )
+    .unwrap();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
     // Canonical witness config must be among solutions
     assert!(solutions.contains(&vec![0, 1, 1, 0, 9]));
@@ -170,14 +204,41 @@ fn test_sequencing_within_intervals_find_all_witnesses() {
 #[test]
 fn test_sequencing_within_intervals_find_all_witnesses_empty() {
     // Two tasks that must both use time [0,2), impossible without overlap
-    let problem = SequencingWithinIntervals::new(vec![0, 0], vec![2, 2], vec![2, 2]);
+    let problem = SequencingWithinIntervals::new(vec![0, 0], vec![2, 2], vec![2, 2]).unwrap();
     let solver = BruteForce::new();
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+    assert!(solver.find_all_witnesses(&problem).unwrap().is_empty());
+}
+
+#[test]
+fn test_sequencing_within_intervals_empty_start_domain() {
+    for (release, deadline, length) in [(2, 50, 49), (5, 3, 2), (i64::MAX, 0, i64::MAX)] {
+        let problem =
+            SequencingWithinIntervals::new(vec![0, release], vec![3, deadline], vec![2, length])
+                .unwrap();
+        let restored: SequencingWithinIntervals =
+            serde_json::from_value(serde_json::to_value(&problem).unwrap()).unwrap();
+        assert_eq!(restored.dimensions(), vec![2, 0]);
+        assert_eq!(restored.num_start_slots(), 2);
+        let (value, witnesses) = BruteForce::new().solve_with_witnesses(&restored).unwrap();
+        assert_eq!(value, crate::types::Or(false));
+        assert!(witnesses.is_empty());
+        assert!(matches!(
+            restored.evaluate(&vec![0, 0]),
+            Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+        ));
+    }
 }
 
 #[test]
-#[should_panic(expected = "time window is empty")]
-fn test_sequencing_within_intervals_invalid_window() {
-    // r + l > d: impossible task
-    SequencingWithinIntervals::new(vec![5], vec![3], vec![2]);
+fn test_sequencing_within_intervals_rejects_overflow_and_invalid_deserialization() {
+    assert!(matches!(
+        SequencingWithinIntervals::new(vec![0], vec![i64::MAX], vec![0]),
+        Err(ConstructionError::IntegerOverflow(_))
+    ));
+    assert!(matches!(
+        SequencingWithinIntervals::new(vec![0; 3], vec![i64::MAX; 3], vec![1; 3]),
+        Err(ConstructionError::IntegerOverflow(_))
+    ));
+    let json = r#"{"release_times":[-1],"deadlines":[3],"lengths":[2]}"#;
+    assert!(serde_json::from_str::<SequencingWithinIntervals>(json).is_err());
 }
diff --git a/src/unit_tests/models/misc/shortest_common_supersequence.rs b/src/unit_tests/models/misc/shortest_common_supersequence.rs
index 3a6117f9a..65dfccfcb 100644
--- a/src/unit_tests/models/misc/shortest_common_supersequence.rs
+++ b/src/unit_tests/models/misc/shortest_common_supersequence.rs
@@ -1,8 +1,65 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
+#[test]
+fn test_shortestcommonsupersequence_create_spec_derives_stored_fields() {
+    let problem = ShortestCommonSupersequence::try_from(ShortestCommonSupersequenceCreateSpec {
+        strings: vec![vec![0, 1], vec![1, 2]],
+    })
+    .unwrap();
+
+    assert_eq!(problem.alphabet_size(), 3);
+    assert_eq!(problem.strings(), &[vec![0, 1], vec![1, 2]]);
+    assert_eq!(problem.max_length(), 4);
+
+    let entry = inventory::iter::<crate::registry::VariantEntry>()
+        .find(|entry| entry.name == "ShortestCommonSupersequence")
+        .unwrap();
+    let inputs = entry.create_inputs.unwrap()();
+    assert_eq!(inputs.len(), 1);
+    assert_eq!(inputs[0].name, "strings");
+    assert_eq!(
+        inputs[0].codec,
+        crate::registry::CreateInputCodec::SemicolonSeparated
+    );
+
+    let constructed = (entry.construct_fn)(serde_json::json!({
+        "strings": [[0, 1], [1, 2]]
+    }))
+    .unwrap();
+    let constructed = constructed
+        .as_any()
+        .downcast_ref::<ShortestCommonSupersequence>()
+        .unwrap();
+    assert_eq!(constructed.alphabet_size(), 3);
+    assert_eq!(constructed.max_length(), 4);
+}
+
+#[test]
+fn test_shortestcommonsupersequence_create_spec_rejects_invalid_input() {
+    let empty = ShortestCommonSupersequence::try_from(ShortestCommonSupersequenceCreateSpec {
+        strings: vec![],
+    });
+    assert!(matches!(
+        empty.unwrap_err(),
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "must have at least one string"
+    ));
+
+    let overflowing_symbol =
+        ShortestCommonSupersequence::try_from(ShortestCommonSupersequenceCreateSpec {
+            strings: vec![vec![usize::MAX]],
+        });
+    assert!(matches!(
+        overflowing_symbol.unwrap_err(),
+        crate::registry::ConstructionError::Conversion(message)
+            if message == "alphabet size overflows usize"
+    ));
+}
+
 #[test]
 fn test_shortestcommonsupersequence_basic() {
     let problem = ShortestCommonSupersequence::new(
@@ -13,7 +70,7 @@ fn test_shortestcommonsupersequence_basic() {
     assert_eq!(problem.num_strings(), 3);
     assert_eq!(problem.max_length(), 12); // 4+4+4
     assert_eq!(problem.total_length(), 12);
-    assert_eq!(problem.dims(), vec![4; 12]); // alphabet_size+1 = 4, max_length = 12
+    assert_eq!(problem.dimensions(), vec![4; 12]); // alphabet_size+1 = 4, max_length = 12
     assert_eq!(
         <ShortestCommonSupersequence as Problem>::NAME,
         "ShortestCommonSupersequence"
@@ -31,9 +88,17 @@ fn test_shortestcommonsupersequence_evaluate_valid() {
         3,
         vec![vec![0, 1, 2, 1], vec![1, 2, 0, 1], vec![0, 2, 1, 0]],
     );
-    let mut config = vec![0, 1, 2, 0, 2, 1, 0];
-    config.extend(vec![3; 5]); // pad to max_length=12
-    assert_eq!(problem.evaluate(&config), Min(Some(7)));
+    let mut config = vec![
+        Some(0),
+        Some(1),
+        Some(2),
+        Some(0),
+        Some(2),
+        Some(1),
+        Some(0),
+    ];
+    config.extend(vec![None; 5]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(7)));
 }
 
 #[test]
@@ -43,9 +108,9 @@ fn test_shortestcommonsupersequence_evaluate_infeasible() {
         vec![vec![0, 1, 2, 1], vec![1, 2, 0, 1], vec![0, 2, 1, 0]],
     );
     // All zeros padded: [0,0,0,0,0,0,0, 3,3,3,3,3] cannot contain [0,1,2,1]
-    let mut config = vec![0; 7];
-    config.extend(vec![3; 5]);
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let mut config = vec![Some(0); 7];
+    config.extend(vec![None; 5]);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
@@ -58,24 +123,28 @@ fn test_shortestcommonsupersequence_out_of_range() {
     // This means position 1 is neither a valid symbol nor padding
     // After finding padding at... wait, 3 != 2 (padding), so effective_length = 2
     // Then prefix [0, 3] has 3 >= alphabet_size, so returns None
-    assert_eq!(problem.evaluate(&[0, 3]), Min(None));
+    assert_eq!(problem.evaluate(&vec![Some(0), None]).unwrap(), Min(None));
 }
 
 #[test]
 fn test_shortestcommonsupersequence_wrong_length() {
     let problem = ShortestCommonSupersequence::new(2, vec![vec![0, 1]]);
     // max_length = 2, wrong config lengths return None
-    assert_eq!(problem.evaluate(&[0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![Some(0)]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![Some(0), Some(1), Some(0)]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_shortestcommonsupersequence_interleaved_padding() {
     // Padding must be contiguous at the end
     let problem = ShortestCommonSupersequence::new(2, vec![vec![0, 1]]);
-    // max_length = 2, padding = 2
-    // [2, 0] has padding at position 0 then non-padding at position 1 -> invalid
-    assert_eq!(problem.evaluate(&[2, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![None, Some(0)]).unwrap(), Min(None));
 }
 
 #[test]
@@ -86,19 +155,20 @@ fn test_shortestcommonsupersequence_brute_force() {
     let problem = ShortestCommonSupersequence::new(2, vec![vec![0, 1], vec![1, 0]]);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let val = problem.evaluate(&solution);
+    let val = problem.evaluate(&solution).unwrap();
     assert!(val.0.is_some());
     assert_eq!(val.0.unwrap(), 3); // optimal SCS length is 3
 }
 
 #[test]
 fn test_shortestcommonsupersequence_solve_aggregate() {
-    use crate::solvers::Solver;
     let problem = ShortestCommonSupersequence::new(2, vec![vec![0, 1], vec![1, 0]]);
     let solver = BruteForce::new();
-    let val = solver.solve(&problem);
+    let val_solution = solver.solve(&problem).unwrap().unwrap();
+    let val = problem.evaluate(&val_solution).unwrap();
     assert_eq!(val, Min(Some(3)));
 }
 
@@ -108,7 +178,7 @@ fn test_shortestcommonsupersequence_all_padding() {
     // Only valid if all input strings are empty
     let problem = ShortestCommonSupersequence::new(2, vec![vec![]]);
     // max_length = 0, so config is empty
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -117,9 +187,15 @@ fn test_shortestcommonsupersequence_single_string() {
     // max_length = 3, search space = 4^3 = 64
     let problem = ShortestCommonSupersequence::new(3, vec![vec![0, 1, 2]]);
     // [0,1,2] with no padding = the string itself, length 3
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Min(Some(3)));
+    assert_eq!(
+        problem.evaluate(&vec![Some(0), Some(1), Some(2)]).unwrap(),
+        Min(Some(3))
+    );
     // [2,1,0] doesn't contain [0,1,2] as subsequence
-    assert_eq!(problem.evaluate(&[2, 1, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![Some(2), Some(1), Some(0)]).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -128,14 +204,14 @@ fn test_shortestcommonsupersequence_find_all_witnesses() {
     // max_length = 4, search space = 3^4 = 81
     let problem = ShortestCommonSupersequence::new(2, vec![vec![0, 1], vec![1, 0]]);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     for sol in &solutions {
-        let val = problem.evaluate(sol);
+        let val = problem.evaluate(sol).unwrap();
         assert!(val.0.is_some());
     }
     // Optimal witnesses (length 3): [0,1,0,pad] and [1,0,1,pad]
-    assert!(solutions.contains(&vec![0, 1, 0, 2]));
-    assert!(solutions.contains(&vec![1, 0, 1, 2]));
+    assert!(solutions.contains(&vec![Some(0), Some(1), Some(0), None]));
+    assert!(solutions.contains(&vec![Some(1), Some(0), Some(1), None]));
 }
 
 #[test]
@@ -155,12 +231,20 @@ fn test_shortestcommonsupersequence_paper_example() {
     let problem = ShortestCommonSupersequence::new(3, vec![vec![0, 1, 2], vec![1, 0, 2]]);
     // max_length = 3 + 3 = 6, padding = 3
     // "babc" = [1, 0, 1, 2] padded to [1, 0, 1, 2, 3, 3]
-    assert_eq!(problem.evaluate(&[1, 0, 1, 2, 3, 3]), Min(Some(4)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![Some(1), Some(0), Some(1), Some(2), None, None])
+            .unwrap(),
+        Min(Some(4))
+    );
 
     // Verify a solution exists with brute force
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find solution");
-    let val = problem.evaluate(&witness);
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find solution");
+    let val = problem.evaluate(&witness).unwrap();
     assert!(val.0.is_some());
     // Optimal SCS for "abc" and "bac" is length 4
     assert_eq!(val.0.unwrap(), 4);
diff --git a/src/unit_tests/models/misc/shortest_common_superstring.rs b/src/unit_tests/models/misc/shortest_common_superstring.rs
index 0e2bb5e42..c2462e6c3 100644
--- a/src/unit_tests/models/misc/shortest_common_superstring.rs
+++ b/src/unit_tests/models/misc/shortest_common_superstring.rs
@@ -1,8 +1,23 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
+fn padded_solution(values: Vec<usize>, padding: usize) -> Vec<Option<usize>> {
+    values
+        .into_iter()
+        .map(|value| {
+            if value == padding {
+                None
+            } else {
+                assert!(value < padding);
+                Some(value)
+            }
+        })
+        .collect()
+}
+
 #[test]
 fn test_shortestcommonsuperstring_basic() {
     let problem =
@@ -11,7 +26,7 @@ fn test_shortestcommonsuperstring_basic() {
     assert_eq!(problem.num_strings(), 3);
     assert_eq!(problem.max_length(), 9); // 3+3+3
     assert_eq!(problem.total_length(), 9);
-    assert_eq!(problem.dims(), vec![4; 9]); // alphabet_size + 1 = 4 across max_length = 9 positions
+    assert_eq!(problem.dimensions(), vec![4; 9]); // alphabet_size + 1 = 4 across max_length = 9 positions
     assert_eq!(
         <ShortestCommonSuperstring as Problem>::NAME,
         "ShortestCommonSuperstring"
@@ -38,7 +53,8 @@ fn test_shortestcommonsuperstring_evaluate_valid_substring() {
     let pad = 3;
     let mut config = vec![0, 0, 1, 2, 0, 1, 2, 2, 0]; // "aabcabcca"
     config.extend(vec![pad; problem.max_length() - 9]);
-    assert_eq!(problem.evaluate(&config), Min(Some(9)));
+    let config = padded_solution(config, pad);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(9)));
 }
 
 #[test]
@@ -54,14 +70,16 @@ fn test_shortestcommonsuperstring_evaluate_subsequence_not_substring() {
     while config.len() < problem.max_length() {
         config.push(pad);
     }
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = padded_solution(config, pad);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 
     // w = [0,1,0] padded -- "01" at pos 0, "10" at pos 1 -- valid, length 3
     let mut config = vec![0, 1, 0];
     while config.len() < problem.max_length() {
         config.push(pad);
     }
-    assert_eq!(problem.evaluate(&config), Min(Some(3)));
+    let config = padded_solution(config, pad);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(3)));
 }
 
 #[test]
@@ -74,28 +92,38 @@ fn test_shortestcommonsuperstring_evaluate_infeasible() {
     while config.len() < problem.max_length() {
         config.push(pad);
     }
-    assert_eq!(problem.evaluate(&config), Min(None));
+    let config = padded_solution(config, pad);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(None));
 }
 
 #[test]
 fn test_shortestcommonsuperstring_out_of_range() {
     let problem = ShortestCommonSuperstring::new(2, vec![vec![0, 1]]);
     // max_length = 2. Value 3 is neither a valid symbol (0..2) nor padding (= 2).
-    assert_eq!(problem.evaluate(&[0, 3]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![Some(0), Some(3)]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_shortestcommonsuperstring_wrong_length() {
     let problem = ShortestCommonSuperstring::new(2, vec![vec![0, 1]]);
-    assert_eq!(problem.evaluate(&[0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 1, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![Some(0)]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![Some(0), Some(1), Some(0)]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_shortestcommonsuperstring_interleaved_padding() {
     // Padding must be contiguous at the end.
     let problem = ShortestCommonSuperstring::new(2, vec![vec![0, 1]]);
-    assert_eq!(problem.evaluate(&[2, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![None, Some(0)]).unwrap(), Min(None));
 }
 
 #[test]
@@ -105,17 +133,20 @@ fn test_shortestcommonsuperstring_brute_force_small() {
     // Optimal superstring length = 3 (e.g. "010" or "101").
     let problem = ShortestCommonSuperstring::new(2, vec![vec![0, 1], vec![1, 0]]);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).expect("should find solution");
-    let val = problem.evaluate(&witness);
+    let witness = solver
+        .solve(&problem)
+        .unwrap()
+        .expect("should find solution");
+    let val = problem.evaluate(&witness).unwrap();
     assert_eq!(val, Min(Some(3)));
 }
 
 #[test]
 fn test_shortestcommonsuperstring_solve_aggregate() {
-    use crate::solvers::Solver;
     let problem = ShortestCommonSuperstring::new(2, vec![vec![0, 1], vec![1, 0]]);
     let solver = BruteForce::new();
-    let val = solver.solve(&problem);
+    let val_solution = solver.solve(&problem).unwrap().unwrap();
+    let val = problem.evaluate(&val_solution).unwrap();
     assert_eq!(val, Min(Some(3)));
 }
 
@@ -150,7 +181,8 @@ fn test_shortestcommonsuperstring_example1_ternary() {
     let prefix = vec![0, 0, 1, 2, 0, 1, 2, 2, 0]; // "aabcabcca"
     let mut config = prefix.clone();
     config.extend(vec![pad; problem.max_length() - prefix.len()]);
-    assert_eq!(problem.evaluate(&config), Min(Some(9)));
+    let config = padded_solution(config, pad);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(9)));
 
     // Any prefix shorter than 9 cannot contain all 6 length-3 strings as substrings
     // even in the best case (6 distinct triples => need at least 9 positions if
@@ -158,7 +190,8 @@ fn test_shortestcommonsuperstring_example1_ternary() {
     // is infeasible.
     let mut short_cfg = prefix[..8].to_vec();
     short_cfg.extend(vec![pad; problem.max_length() - 8]);
-    assert_eq!(problem.evaluate(&short_cfg), Min(None));
+    let short_cfg = padded_solution(short_cfg, pad);
+    assert_eq!(problem.evaluate(&short_cfg).unwrap(), Min(None));
 }
 
 #[test]
@@ -181,7 +214,8 @@ fn test_shortestcommonsuperstring_example2_binary() {
     let prefix = vec![0, 0, 1, 1, 0, 1, 0, 0]; // "00110100"
     let mut config = prefix.clone();
     config.extend(vec![pad; problem.max_length() - prefix.len()]);
-    assert_eq!(problem.evaluate(&config), Min(Some(8)));
+    let config = padded_solution(config, pad);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(8)));
 }
 
 #[test]
@@ -204,7 +238,8 @@ fn test_shortestcommonsuperstring_example3() {
     let prefix = vec![0, 1, 2, 0, 1, 1, 0]; // "abcabba"
     let mut config = prefix.clone();
     config.extend(vec![pad; problem.max_length() - prefix.len()]);
-    assert_eq!(problem.evaluate(&config), Min(Some(7)));
+    let config = padded_solution(config, pad);
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(7)));
 }
 
 #[test]
@@ -212,9 +247,18 @@ fn test_shortestcommonsuperstring_paper_example() {
     // Canonical example_db instance: alphabet {0,1}, strings [0,1] and [1,0].
     // Optimal superstring length = 3, witness [0,1,0,pad].
     let problem = ShortestCommonSuperstring::new(2, vec![vec![0, 1], vec![1, 0]]);
-    assert_eq!(problem.evaluate(&[0, 1, 0, 2]), Min(Some(3)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![Some(0), Some(1), Some(0), None])
+            .unwrap(),
+        Min(Some(3))
+    );
 
-    use crate::solvers::Solver;
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&problem), Min(Some(3)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(3))
+    );
 }
diff --git a/src/unit_tests/models/misc/square_tiling.rs b/src/unit_tests/models/misc/square_tiling.rs
index 20f253f9d..720a2128a 100644
--- a/src/unit_tests/models/misc/square_tiling.rs
+++ b/src/unit_tests/models/misc/square_tiling.rs
@@ -1,5 +1,6 @@
 use crate::models::misc::SquareTiling;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -20,7 +21,7 @@ fn test_square_tiling_basic() {
     assert_eq!(problem.num_tiles(), 4);
     assert_eq!(problem.grid_size(), 2);
     assert_eq!(problem.tiles().len(), 4);
-    assert_eq!(problem.dims(), vec![4; 4]);
+    assert_eq!(problem.dimensions(), vec![4; 4]);
     assert_eq!(problem.num_variables(), 4);
     assert_eq!(<SquareTiling as Problem>::NAME, "SquareTiling");
     assert_eq!(<SquareTiling as Problem>::variant(), vec![]);
@@ -34,7 +35,7 @@ fn test_square_tiling_evaluate_valid() {
     //   (1,0)=t2, (1,1)=t3
     // Horizontal: t0.right=1==t1.left=1, t2.right=1==t3.left=1
     // Vertical:   t0.bottom=2==t2.top=2, t1.bottom=2==t3.top=2
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3]), Or(true));
+    assert_eq!(problem.evaluate(&vec![0, 1, 2, 3]).unwrap(), Or(true));
 }
 
 #[test]
@@ -43,7 +44,7 @@ fn test_square_tiling_evaluate_invalid_horizontal() {
     // Config [0, 0, 2, 3]:
     //   (0,0)=t0, (0,1)=t0
     //   t0.right=1, t0.left=0 => mismatch
-    assert_eq!(problem.evaluate(&[0, 0, 2, 3]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 0, 2, 3]).unwrap(), Or(false));
 }
 
 #[test]
@@ -53,28 +54,37 @@ fn test_square_tiling_evaluate_invalid_vertical() {
     //   (0,0)=t0, (0,1)=t1
     //   (1,0)=t0, (1,1)=t3
     //   Vertical (0,0)-(1,0): t0.bottom=2, t0.top=0 => mismatch
-    assert_eq!(problem.evaluate(&[0, 1, 0, 3]), Or(false));
+    assert_eq!(problem.evaluate(&vec![0, 1, 0, 3]).unwrap(), Or(false));
 }
 
 #[test]
 fn test_square_tiling_evaluate_wrong_length() {
     let problem = example_problem();
-    assert_eq!(problem.evaluate(&[0, 1, 2]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 1, 2, 3, 0]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 3, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_square_tiling_evaluate_tile_index_out_of_range() {
     let problem = example_problem();
-    assert_eq!(problem.evaluate(&[0, 1, 2, 4]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_square_tiling_solver_finds_witness() {
     let problem = example_problem();
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&witness), Or(true));
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&witness).unwrap(), Or(true));
 }
 
 #[test]
@@ -83,16 +93,16 @@ fn test_square_tiling_unsatisfiable_instance() {
     // Both have right=1, left=0, so no horizontal match possible.
     let problem = SquareTiling::new(3, vec![(0, 1, 2, 0), (2, 1, 0, 0)], 2);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_square_tiling_single_cell() {
     // 1x1 grid: any single tile is a valid tiling
     let problem = SquareTiling::new(2, vec![(0, 1, 0, 1)], 1);
-    assert_eq!(problem.evaluate(&[0]), Or(true));
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Or(true));
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
+    let witness = solver.solve(&problem).unwrap().unwrap();
     assert_eq!(witness, vec![0]);
 }
 
@@ -179,6 +189,6 @@ fn test_square_tiling_count_valid_tilings() {
     // Issue states 16 valid tilings out of 256 for the positive example
     let problem = example_problem();
     let solver = BruteForce::new();
-    let witnesses = solver.find_all_witnesses(&problem);
+    let witnesses = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(witnesses.len(), 16);
 }
diff --git a/src/unit_tests/models/misc/stacker_crane.rs b/src/unit_tests/models/misc/stacker_crane.rs
index bfc89f9b6..071b9df8b 100644
--- a/src/unit_tests/models/misc/stacker_crane.rs
+++ b/src/unit_tests/models/misc/stacker_crane.rs
@@ -1,4 +1,20 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_lengths_and_checks_inferred_vertex_counts() {
+    let problem = StackerCrane::try_from(StackerCraneCreateSpec {
+        arcs: vec![(0, 1)],
+        edges: vec![(1, 0)],
+        num_vertices: None,
+        arc_lengths: None,
+        edge_lengths: None,
+    })
+    .unwrap();
+    assert_eq!(problem.num_vertices(), 2);
+    assert_eq!(problem.arc_lengths(), &[1]);
+    assert_eq!(problem.edge_lengths(), &[1]);
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -24,7 +40,7 @@ fn test_stacker_crane_creation_and_metadata() {
     assert_eq!(problem.num_vertices(), 6);
     assert_eq!(problem.num_arcs(), 5);
     assert_eq!(problem.num_edges(), 7);
-    assert_eq!(problem.dims(), vec![5; 5]);
+    assert_eq!(problem.dimensions(), vec![5; 5]);
     assert_eq!(<StackerCrane as Problem>::NAME, "StackerCrane");
     assert!(<StackerCrane as Problem>::variant().is_empty());
 }
@@ -33,16 +49,28 @@ fn test_stacker_crane_creation_and_metadata() {
 fn test_stacker_crane_rejects_non_permutations_and_wrong_lengths() {
     let problem = issue_problem();
 
-    assert_eq!(problem.evaluate(&[0, 2, 1, 4, 4]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 2, 1, 4, 5]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 2, 1, 4]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 2, 1, 4, 3, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 2, 1, 4, 4]).unwrap(), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2, 1, 4, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2, 1, 4]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2, 1, 4, 3, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_stacker_crane_issue_witness_value() {
     let problem = issue_problem();
-    assert_eq!(problem.evaluate(&[0, 2, 1, 4, 3]), Min(Some(20)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 2, 1, 4, 3]).unwrap(),
+        Min(Some(20))
+    );
 }
 
 #[test]
@@ -51,13 +79,14 @@ fn test_stacker_crane_paper_example() {
     let witness = vec![0, 2, 1, 4, 3];
 
     assert_eq!(problem.closed_walk_length(&witness), Some(20));
-    assert_eq!(problem.evaluate(&witness), Min(Some(20)));
+    assert_eq!(problem.evaluate(&witness).unwrap(), Min(Some(20)));
 
     let solver = BruteForce::new();
     let optimal = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should have a witness");
-    let optimal_value = problem.evaluate(&optimal);
+    let optimal_value = problem.evaluate(&optimal).unwrap();
     assert_eq!(optimal_value, Min(Some(20)));
 }
 
@@ -67,12 +96,13 @@ fn test_stacker_crane_small_solver_instance() {
     let solver = BruteForce::new();
 
     let optimal = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("small instance should have a witness");
     let mut sorted = optimal.clone();
     sorted.sort_unstable();
     assert_eq!(sorted, vec![0, 1]);
-    assert!(problem.evaluate(&optimal).0.is_some());
+    assert!(problem.evaluate(&optimal).unwrap().0.is_some());
 }
 
 #[test]
@@ -84,7 +114,10 @@ fn test_stacker_crane_serialization_round_trip() {
     assert_eq!(round_trip.num_vertices(), 6);
     assert_eq!(round_trip.num_arcs(), 5);
     assert_eq!(round_trip.num_edges(), 7);
-    assert_eq!(round_trip.evaluate(&[0, 2, 1, 4, 3]), Min(Some(20)));
+    assert_eq!(
+        round_trip.evaluate(&vec![0, 2, 1, 4, 3]).unwrap(),
+        Min(Some(20))
+    );
 }
 
 #[test]
@@ -116,8 +149,8 @@ fn test_stacker_crane_unreachable_connector() {
     // No permutation can find a connector path from vertex 1 to vertex 2 (or 3 to 0).
     assert_eq!(problem.closed_walk_length(&[0, 1]), None);
     assert_eq!(problem.closed_walk_length(&[1, 0]), None);
-    assert_eq!(problem.evaluate(&[0, 1]), Min(None));
-    assert_eq!(problem.evaluate(&[1, 0]), Min(None));
+    assert_eq!(problem.evaluate(&vec![0, 1]).unwrap(), Min(None));
+    assert_eq!(problem.evaluate(&vec![1, 0]).unwrap(), Min(None));
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/staff_scheduling.rs b/src/unit_tests/models/misc/staff_scheduling.rs
index 7e36b205f..ac58c7aba 100644
--- a/src/unit_tests/models/misc/staff_scheduling.rs
+++ b/src/unit_tests/models/misc/staff_scheduling.rs
@@ -1,7 +1,21 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
+#[test]
+fn test_staff_scheduling_create_spec_uses_k_input() {
+    assert_eq!(StaffSchedulingCreateSpec::FIELDS[0].name, "k");
+    let problem = StaffScheduling::try_from(StaffSchedulingCreateSpec {
+        k: 1,
+        schedules: vec![vec![true, false]],
+        requirements: vec![1, 0],
+        num_workers: 1,
+    })
+    .unwrap();
+    assert_eq!(problem.shifts_per_schedule(), 1);
+}
+
 fn issue_example_problem() -> StaffScheduling {
     StaffScheduling::new(
         5,
@@ -25,13 +39,7 @@ fn test_staff_scheduling_creation() {
     assert_eq!(problem.num_schedules(), 5);
     assert_eq!(problem.requirements(), &[2, 2, 2, 3, 3, 2, 1]);
     assert_eq!(problem.num_workers(), 4);
-    assert_eq!(problem.dims(), vec![5; 5]);
-}
-
-#[test]
-#[should_panic(expected = "num_workers must fit in usize so dims() can encode 0..=num_workers")]
-fn test_staff_scheduling_new_panics_when_num_workers_exceeds_usize() {
-    let _ = StaffScheduling::new(1, vec![vec![true]], vec![1], u64::MAX);
+    assert_eq!(problem.dimensions(), vec![5; 5]);
 }
 
 #[test]
@@ -59,31 +67,34 @@ fn test_staff_scheduling_new_panics_on_wrong_active_period_count() {
 #[test]
 fn test_staff_scheduling_evaluate_feasible_issue_example() {
     let problem = issue_example_problem();
-    assert!(problem.evaluate(&[1, 1, 1, 1, 0]));
+    assert!(problem.evaluate(&vec![1, 1, 1, 1, 0]).unwrap());
 }
 
 #[test]
 fn test_staff_scheduling_rejects_invalid_configs() {
     let problem = issue_example_problem();
-    assert!(!problem.evaluate(&[1, 1, 1, 1]));
-    assert!(!problem.evaluate(&[5, 0, 0, 0, 0]));
-    assert!(!problem.evaluate(&[1, 1, 1, 1, 1]));
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 4]));
+    assert!(matches!(
+        problem.evaluate(&vec![1, 1, 1, 1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(!problem.evaluate(&vec![5, 0, 0, 0, 0]).unwrap());
+    assert!(!problem.evaluate(&vec![1, 1, 1, 1, 1]).unwrap());
+    assert!(!problem.evaluate(&vec![0, 0, 0, 0, 4]).unwrap());
 }
 
 #[test]
 fn test_staff_scheduling_bruteforce_solver_finds_solution() {
     let problem = issue_example_problem();
-    let solution = BruteForce::new().find_witness(&problem);
+    let solution = BruteForce::new().solve(&problem).unwrap();
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
 #[test]
 fn test_staff_scheduling_bruteforce_solver_detects_unsat() {
     let problem =
         StaffScheduling::new(1, vec![vec![true, false], vec![false, true]], vec![2, 2], 1);
-    assert!(BruteForce::new().find_witness(&problem).is_none());
+    assert!(BruteForce::new().solve(&problem).unwrap().is_none());
 }
 
 #[test]
@@ -104,9 +115,9 @@ fn test_staff_scheduling_serialization_round_trip() {
 fn test_staff_scheduling_paper_example() {
     let problem = issue_example_problem();
     let config = vec![1, 1, 1, 1, 0];
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
-    let satisfying = BruteForce::new().find_all_witnesses(&problem);
+    let satisfying = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert!(satisfying.contains(&config));
 }
 
diff --git a/src/unit_tests/models/misc/string_to_string_correction.rs b/src/unit_tests/models/misc/string_to_string_correction.rs
index f4023a730..4530eab36 100644
--- a/src/unit_tests/models/misc/string_to_string_correction.rs
+++ b/src/unit_tests/models/misc/string_to_string_correction.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -12,7 +13,7 @@ fn test_string_to_string_correction_creation() {
     assert_eq!(problem.source_length(), 6);
     assert_eq!(problem.target_length(), 5);
     // domain = 2*6+1 = 13, bound = 2
-    assert_eq!(problem.dims(), vec![13; 2]);
+    assert_eq!(problem.dimensions(), vec![13; 2]);
     assert_eq!(
         <StringToStringCorrection as Problem>::NAME,
         "StringToStringCorrection"
@@ -26,20 +27,32 @@ fn test_string_to_string_correction_evaluation() {
     // Known solution: swap positions 2&3 (value=8), then delete index 5 (value=5)
     // Step 1: current_len=6, op=8 >= 6, swap_pos = 8-6=2, swap(2,3) → [0,1,3,2,1,0]
     // Step 2: current_len=6, op=5 < 6, delete(5) → [0,1,3,2,1] = target
-    assert!(problem.evaluate(&[8, 5]));
+    assert!(problem.evaluate(&vec![8, 5]).unwrap());
     // All no-ops should not produce target (source != target)
-    assert!(!problem.evaluate(&[12, 12]));
+    assert!(!problem.evaluate(&vec![12, 12]).unwrap());
 }
 
 #[test]
 fn test_string_to_string_correction_invalid_operations() {
     let problem = StringToStringCorrection::new(4, vec![0, 1, 2, 3, 1, 0], vec![0, 1, 3, 2, 1], 2);
     // out-of-domain values
-    assert!(!problem.evaluate(&[13, 5]));
-    assert!(!problem.evaluate(&[8, 13]));
+    assert!(matches!(
+        problem.evaluate(&vec![13, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![8, 13]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // wrong length config
-    assert!(!problem.evaluate(&[8]));
-    assert!(!problem.evaluate(&[8, 5, 12]));
+    assert!(matches!(
+        problem.evaluate(&vec![8]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![8, 5, 12]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -49,7 +62,7 @@ fn test_string_to_string_correction_invalid_after_deletion() {
     // source len = 3, domain = 7, noop = 6
     // op=0: delete index 0 → [1, 0], current_len=2
     // op=5: 5 >= 2, swap_pos = 5-2=3, need 3+1<2 → false → invalid
-    assert!(!problem.evaluate(&[0, 5]));
+    assert!(!problem.evaluate(&vec![0, 5]).unwrap());
 }
 
 #[test]
@@ -70,9 +83,10 @@ fn test_string_to_string_correction_solver() {
     let problem = StringToStringCorrection::new(2, vec![0, 1], vec![1, 0], 1);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
@@ -80,16 +94,16 @@ fn test_string_to_string_correction_paper_example() {
     // Paper example: source [0,1,2,3,1,0], target [0,1,3,2,1], bound 2
     let problem = StringToStringCorrection::new(4, vec![0, 1, 2, 3, 1, 0], vec![0, 1, 3, 2, 1], 2);
     // Verify the known solution
-    assert!(problem.evaluate(&[8, 5]));
+    assert!(problem.evaluate(&vec![8, 5]).unwrap());
 
     // Verify all solutions with brute force
     let solver = BruteForce::new();
-    let all_solutions = solver.find_all_witnesses(&problem);
+    let all_solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!all_solutions.is_empty());
     // The known solution must be among them
     assert!(all_solutions.contains(&vec![8, 5]));
     for sol in &all_solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -97,25 +111,25 @@ fn test_string_to_string_correction_paper_example() {
 fn test_string_to_string_correction_unsatisfiable() {
     // bound=0, source != target → impossible
     let problem = StringToStringCorrection::new(2, vec![0, 1], vec![1, 0], 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(!problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(!problem.evaluate(&vec![]).unwrap());
 
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_string_to_string_correction_identity() {
     // source == target, bound_k=0 → satisfied with empty config
     let problem = StringToStringCorrection::new(2, vec![0, 1], vec![0, 1], 0);
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
 fn test_string_to_string_correction_empty_strings() {
     // Both empty, bound_k=0 → trivially satisfied
     let problem = StringToStringCorrection::new(0, vec![], vec![], 0);
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -123,29 +137,64 @@ fn test_string_to_string_correction_delete_only() {
     // source [0,1,2], target [0,2], bound 1
     // Delete index 1: op=1, current_len=3, 1<3 → delete → [0,2] = target
     let problem = StringToStringCorrection::new(3, vec![0, 1, 2], vec![0, 2], 1);
-    assert!(problem.evaluate(&[1]));
+    assert!(problem.evaluate(&vec![1]).unwrap());
 
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_string_to_string_correction_rejects_target_longer_than_source() {
     let problem = StringToStringCorrection::new(3, vec![0, 1], vec![0, 1, 2], 1);
-    assert!(!problem.evaluate(&[4]));
+    assert!(!problem.evaluate(&vec![4]).unwrap());
 }
 
 #[test]
 fn test_string_to_string_correction_rejects_excessive_deletions_requirement() {
     let problem = StringToStringCorrection::new(4, vec![0, 1, 2, 3], vec![0], 2);
-    assert!(!problem.evaluate(&[8, 8]));
+    assert!(!problem.evaluate(&vec![8, 8]).unwrap());
 }
 
 #[test]
 fn test_string_to_string_correction_is_available_in_prelude() {
     let problem = crate::prelude::StringToStringCorrection::new(2, vec![0], vec![0], 0);
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&vec![]).unwrap());
+}
+
+#[test]
+fn test_string_to_string_correction_create_spec_derives_alphabet() {
+    let problem = StringToStringCorrection::try_from(StringToStringCorrectionCreateSpec {
+        alphabet_size: None,
+        source_string: vec![0, 3],
+        target_string: vec![3],
+        bound: 1,
+    })
+    .unwrap();
+
+    assert_eq!(problem.alphabet_size(), 4);
+    assert_eq!(problem.source(), &[0, 3]);
+    assert_eq!(problem.target(), &[3]);
+    assert_eq!(
+        StringToStringCorrectionCreateSpec::FIELDS
+            .iter()
+            .map(|field| field.name)
+            .collect::<Vec<_>>(),
+        ["alphabet_size", "source_string", "target_string", "bound"]
+    );
+}
+
+#[test]
+fn test_string_to_string_correction_create_spec_rejects_small_alphabet() {
+    let result = StringToStringCorrection::try_from(StringToStringCorrectionCreateSpec {
+        alphabet_size: Some(2),
+        source_string: vec![2],
+        target_string: vec![],
+        bound: 1,
+    });
+
+    assert!(result.is_err());
 }
diff --git a/src/unit_tests/models/misc/subset_product.rs b/src/unit_tests/models/misc/subset_product.rs
index 1832e7183..25c767a06 100644
--- a/src/unit_tests/models/misc/subset_product.rs
+++ b/src/unit_tests/models/misc/subset_product.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use num_bigint::BigUint;
 
@@ -17,7 +18,7 @@ fn test_subsetproduct_basic() {
     assert_eq!(problem.num_elements(), 6);
     assert_eq!(problem.sizes(), buv(&[2, 3, 5, 7, 6, 10]).as_slice());
     assert_eq!(problem.target(), &bu(210));
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert_eq!(<SubsetProduct as Problem>::NAME, "SubsetProduct");
     assert_eq!(<SubsetProduct as Problem>::variant(), vec![]);
 }
@@ -26,33 +27,52 @@ fn test_subsetproduct_basic() {
 fn test_subsetproduct_evaluate_satisfying() {
     let problem = SubsetProduct::new(vec![2u32, 3, 5, 7, 6, 10], 210u32);
     // {2, 3, 5, 7} = 210
-    assert!(problem.evaluate(&[1, 1, 1, 1, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![true, true, true, true, false, false])
+        .unwrap());
     // {3, 7, 10} = 210
-    assert!(problem.evaluate(&[0, 1, 0, 1, 0, 1]));
+    assert!(problem
+        .evaluate(&vec![false, true, false, true, false, true])
+        .unwrap());
 }
 
 #[test]
 fn test_subsetproduct_evaluate_unsatisfying() {
     let problem = SubsetProduct::new(vec![2u32, 3, 5, 7, 6, 10], 210u32);
     // {2, 3} = 6 != 210
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, false, false, false, false])
+        .unwrap());
     // empty = 1 != 210
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![false, false, false, false, false, false])
+        .unwrap());
     // all = 2*3*5*7*6*10 = 12600 != 210
-    assert!(!problem.evaluate(&[1, 1, 1, 1, 1, 1]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, true, true, true])
+        .unwrap());
 }
 
 #[test]
 fn test_subsetproduct_evaluate_wrong_config_length() {
     let problem = SubsetProduct::new(vec![2u32, 3, 5], 30u32);
-    assert!(!problem.evaluate(&[1, 0]));
-    assert!(!problem.evaluate(&[1, 0, 0, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_subsetproduct_evaluate_invalid_variable_value() {
     let problem = SubsetProduct::new(vec![2u32, 3], 6u32);
-    assert!(!problem.evaluate(&[2, 0]));
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([2, false]))
+            .is_err()
+    );
 }
 
 #[test]
@@ -60,15 +80,15 @@ fn test_subsetproduct_empty_instance() {
     // Empty set, target 1: empty subset product = 1 satisfies
     let problem = SubsetProduct::new_unchecked(vec![], bu(1));
     assert_eq!(problem.num_elements(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
 fn test_subsetproduct_empty_instance_nonunit_target() {
     // Empty set, target 5: impossible (empty product = 1)
     let problem = SubsetProduct::new_unchecked(vec![], bu(5));
-    assert!(!problem.evaluate(&[]));
+    assert!(!problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -76,19 +96,20 @@ fn test_subsetproduct_brute_force() {
     let problem = SubsetProduct::new(vec![2u32, 3, 5, 7, 6, 10], 210u32);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_subsetproduct_brute_force_all() {
     let problem = SubsetProduct::new(vec![2u32, 3, 5, 7, 6, 10], 210u32);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -97,7 +118,7 @@ fn test_subsetproduct_unsatisfiable() {
     // Target 1000 is unreachable with these sizes
     let problem = SubsetProduct::new(vec![2u32, 3, 5], 1000u32);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
@@ -118,36 +139,34 @@ fn test_subsetproduct_serialization() {
 }
 
 #[test]
-fn test_subsetproduct_deserialization_legacy_numeric_json() {
-    let restored: SubsetProduct = serde_json::from_value(serde_json::json!({
+fn test_subsetproduct_deserialization_rejects_numeric_json() {
+    let result = serde_json::from_value::<SubsetProduct>(serde_json::json!({
         "sizes": [2, 3, 5, 7, 6, 10],
         "target": 210,
-    }))
-    .unwrap();
-    assert_eq!(restored.sizes(), buv(&[2, 3, 5, 7, 6, 10]).as_slice());
-    assert_eq!(restored.target(), &bu(210));
+    }));
+    assert!(result.is_err());
 }
 
 #[test]
 fn test_subsetproduct_single_element() {
     let problem = SubsetProduct::new(vec![5u32], 5u32);
-    assert!(problem.evaluate(&[1]));
-    assert!(!problem.evaluate(&[0]));
+    assert!(problem.evaluate(&vec![true]).unwrap());
+    assert!(!problem.evaluate(&vec![false]).unwrap());
 }
 
 #[test]
 fn test_subsetproduct_all_selected() {
     // Target equals product of all elements
     let problem = SubsetProduct::new(vec![2u32, 3, 5], 30u32);
-    assert!(problem.evaluate(&[1, 1, 1])); // 2*3*5 = 30
+    assert!(problem.evaluate(&vec![true, true, true]).unwrap()); // 2*3*5 = 30
 }
 
 #[test]
 fn test_subsetproduct_target_one() {
     // Target 1 with non-empty set: only empty subset works (product = 1)
     let problem = SubsetProduct::new(vec![2u32, 3, 5], 1u32);
-    assert!(problem.evaluate(&[0, 0, 0])); // empty subset product = 1
-    assert!(!problem.evaluate(&[1, 0, 0])); // 2 != 1
+    assert!(problem.evaluate(&vec![false, false, false]).unwrap()); // empty subset product = 1
+    assert!(!problem.evaluate(&vec![true, false, false]).unwrap()); // 2 != 1
 }
 
 #[test]
@@ -171,6 +190,10 @@ fn test_subsetproduct_zero_target_panic() {
 #[test]
 fn test_subsetproduct_large_integer_input() {
     let problem = SubsetProduct::new(vec![2i128, 3, 5, 7, 6, 10], 210i128);
-    assert!(problem.evaluate(&[1, 1, 1, 1, 0, 0])); // 2*3*5*7 = 210
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0])); // 2*3 = 6
+    assert!(problem
+        .evaluate(&vec![true, true, true, true, false, false])
+        .unwrap()); // 2*3*5*7 = 210
+    assert!(!problem
+        .evaluate(&vec![true, true, false, false, false, false])
+        .unwrap()); // 2*3 = 6
 }
diff --git a/src/unit_tests/models/misc/subset_sum.rs b/src/unit_tests/models/misc/subset_sum.rs
index 906a122e9..80807cefe 100644
--- a/src/unit_tests/models/misc/subset_sum.rs
+++ b/src/unit_tests/models/misc/subset_sum.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use num_bigint::BigUint;
 
@@ -17,7 +18,7 @@ fn test_subsetsum_basic() {
     assert_eq!(problem.num_elements(), 6);
     assert_eq!(problem.sizes(), buv(&[3, 7, 1, 8, 2, 4]).as_slice());
     assert_eq!(problem.target(), &bu(11));
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert_eq!(<SubsetSum as Problem>::NAME, "SubsetSum");
     assert_eq!(<SubsetSum as Problem>::variant(), vec![]);
 }
@@ -26,33 +27,52 @@ fn test_subsetsum_basic() {
 fn test_subsetsum_evaluate_satisfying() {
     let problem = SubsetSum::new(vec![3u32, 7, 1, 8, 2, 4], 11u32);
     // {3, 8} = 11
-    assert!(problem.evaluate(&[1, 0, 0, 1, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![true, false, false, true, false, false])
+        .unwrap());
     // {7, 4} = 11
-    assert!(problem.evaluate(&[0, 1, 0, 0, 0, 1]));
+    assert!(problem
+        .evaluate(&vec![false, true, false, false, false, true])
+        .unwrap());
 }
 
 #[test]
 fn test_subsetsum_evaluate_unsatisfying() {
     let problem = SubsetSum::new(vec![3u32, 7, 1, 8, 2, 4], 11u32);
     // {3, 7} = 10 ≠ 11
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, false, false, false, false])
+        .unwrap());
     // empty = 0 ≠ 11
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![false, false, false, false, false, false])
+        .unwrap());
     // all = 25 ≠ 11
-    assert!(!problem.evaluate(&[1, 1, 1, 1, 1, 1]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, true, true, true])
+        .unwrap());
 }
 
 #[test]
 fn test_subsetsum_evaluate_wrong_config_length() {
     let problem = SubsetSum::new(vec![3u32, 7, 1], 10u32);
-    assert!(!problem.evaluate(&[1, 0]));
-    assert!(!problem.evaluate(&[1, 0, 0, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_subsetsum_evaluate_invalid_variable_value() {
     let problem = SubsetSum::new(vec![3u32, 7], 10u32);
-    assert!(!problem.evaluate(&[2, 0]));
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([2, false]))
+            .is_err()
+    );
 }
 
 #[test]
@@ -60,15 +80,15 @@ fn test_subsetsum_empty_instance() {
     // Empty set, target 0: empty subset satisfies
     let problem = SubsetSum::new_unchecked(vec![], bu(0));
     assert_eq!(problem.num_elements(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
 fn test_subsetsum_empty_instance_nonzero_target() {
     // Empty set, target 5: impossible
     let problem = SubsetSum::new_unchecked(vec![], bu(5));
-    assert!(!problem.evaluate(&[]));
+    assert!(!problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -76,19 +96,20 @@ fn test_subsetsum_brute_force() {
     let problem = SubsetSum::new(vec![3u32, 7, 1, 8, 2, 4], 11u32);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_subsetsum_brute_force_all() {
     let problem = SubsetSum::new(vec![3u32, 7, 1, 8, 2, 4], 11u32);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -97,7 +118,7 @@ fn test_subsetsum_unsatisfiable() {
     // Target 100 is unreachable
     let problem = SubsetSum::new(vec![1u32, 2, 3], 100u32);
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem);
+    let solution = solver.solve(&problem).unwrap();
     assert!(solution.is_none());
 }
 
@@ -118,36 +139,34 @@ fn test_subsetsum_serialization() {
 }
 
 #[test]
-fn test_subsetsum_deserialization_legacy_numeric_json() {
-    let restored: SubsetSum = serde_json::from_value(serde_json::json!({
+fn test_subsetsum_deserialization_rejects_numeric_json() {
+    let result = serde_json::from_value::<SubsetSum>(serde_json::json!({
         "sizes": [3, 7, 1, 8, 2, 4],
         "target": 11,
-    }))
-    .unwrap();
-    assert_eq!(restored.sizes(), buv(&[3, 7, 1, 8, 2, 4]).as_slice());
-    assert_eq!(restored.target(), &bu(11));
+    }));
+    assert!(result.is_err());
 }
 
 #[test]
 fn test_subsetsum_single_element() {
     let problem = SubsetSum::new(vec![5u32], 5u32);
-    assert!(problem.evaluate(&[1]));
-    assert!(!problem.evaluate(&[0]));
+    assert!(problem.evaluate(&vec![true]).unwrap());
+    assert!(!problem.evaluate(&vec![false]).unwrap());
 }
 
 #[test]
 fn test_subsetsum_all_selected() {
     // Target equals sum of all elements
     let problem = SubsetSum::new(vec![1u32, 2, 3, 4], 10u32);
-    assert!(problem.evaluate(&[1, 1, 1, 1])); // 1+2+3+4 = 10
+    assert!(problem.evaluate(&vec![true, true, true, true]).unwrap()); // 1+2+3+4 = 10
 }
 
 #[test]
 fn test_subsetsum_target_zero() {
     // Target 0 with non-empty set: only empty subset works
     let problem = SubsetSum::new_unchecked(buv(&[1, 2, 3]), bu(0));
-    assert!(problem.evaluate(&[0, 0, 0])); // empty subset sums to 0
-    assert!(!problem.evaluate(&[1, 0, 0])); // 1 != 0
+    assert!(problem.evaluate(&vec![false, false, false]).unwrap()); // empty subset sums to 0
+    assert!(!problem.evaluate(&vec![true, false, false]).unwrap()); // 1 != 0
 }
 
 #[test]
@@ -165,6 +184,10 @@ fn test_subsetsum_zero_size_panic() {
 #[test]
 fn test_subsetsum_large_integer_input() {
     let problem = SubsetSum::new(vec![3i128, 7, 1, 8, 2, 4], 11i128);
-    assert!(problem.evaluate(&[1, 0, 0, 1, 0, 0])); // 3 + 8 = 11
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0])); // 3 + 7 = 10
+    assert!(problem
+        .evaluate(&vec![true, false, false, true, false, false])
+        .unwrap()); // 3 + 8 = 11
+    assert!(!problem
+        .evaluate(&vec![true, true, false, false, false, false])
+        .unwrap()); // 3 + 7 = 10
 }
diff --git a/src/unit_tests/models/misc/sum_of_squares_partition.rs b/src/unit_tests/models/misc/sum_of_squares_partition.rs
index dee85115e..5afb1a20e 100644
--- a/src/unit_tests/models/misc/sum_of_squares_partition.rs
+++ b/src/unit_tests/models/misc/sum_of_squares_partition.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -9,7 +10,7 @@ fn test_sum_of_squares_partition_basic() {
     assert_eq!(problem.num_elements(), 6);
     assert_eq!(problem.num_groups(), 3);
     assert_eq!(problem.sizes(), &[5, 3, 8, 2, 7, 1]);
-    assert_eq!(problem.dims(), vec![3; 6]);
+    assert_eq!(problem.dimensions(), vec![3; 6]);
     assert_eq!(
         <SumOfSquaresPartition as Problem>::NAME,
         "SumOfSquaresPartition"
@@ -21,14 +22,20 @@ fn test_sum_of_squares_partition_basic() {
 fn test_sum_of_squares_partition_evaluate_valid() {
     let problem = SumOfSquaresPartition::new(vec![5, 3, 8, 2, 7, 1], 3);
     // Groups: {8,1}=9, {5,2}=7, {3,7}=10 -> 81+49+100=230
-    assert_eq!(problem.evaluate(&[1, 2, 0, 1, 2, 0]), Min(Some(230)));
+    assert_eq!(
+        problem.evaluate(&vec![1, 2, 0, 1, 2, 0]).unwrap(),
+        Min(Some(230))
+    );
 }
 
 #[test]
 fn test_sum_of_squares_partition_evaluate_imbalanced() {
     let problem = SumOfSquaresPartition::new(vec![5, 3, 8, 2, 7, 1], 3);
     // All in group 0: sum=26 -> 676+0+0=676
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0, 0]), Min(Some(676)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 0, 0, 0, 0, 0]).unwrap(),
+        Min(Some(676))
+    );
 }
 
 #[test]
@@ -36,29 +43,41 @@ fn test_sum_of_squares_partition_all_in_one_group() {
     // All elements in one group is maximally imbalanced
     let problem = SumOfSquaresPartition::new(vec![1, 2, 3], 2);
     // All in group 0: sum=6, group1=0 -> 36+0=36
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(Some(36)));
+    assert_eq!(problem.evaluate(&vec![0, 0, 0]).unwrap(), Min(Some(36)));
     // Balanced: {1,2}=3, {3}=3 -> 9+9=18
-    assert_eq!(problem.evaluate(&[0, 0, 1]), Min(Some(18)));
+    assert_eq!(problem.evaluate(&vec![0, 0, 1]).unwrap(), Min(Some(18)));
 }
 
 #[test]
 fn test_sum_of_squares_partition_sum_of_squares_helper() {
     let problem = SumOfSquaresPartition::new(vec![5, 3, 8, 2, 7, 1], 3);
     // Groups: {8,1}=9, {5,2}=7, {3,7}=10 -> 81+49+100=230
-    assert_eq!(problem.sum_of_squares(&[1, 2, 0, 1, 2, 0]), Some(230));
+    assert_eq!(
+        problem.sum_of_squares(&[1, 2, 0, 1, 2, 0]).unwrap(),
+        Some(230)
+    );
 }
 
 #[test]
 fn test_sum_of_squares_partition_invalid_config() {
     let problem = SumOfSquaresPartition::new(vec![1, 2, 3], 2);
     // Wrong length
-    assert_eq!(problem.evaluate(&[0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Group index out of range
-    assert_eq!(problem.evaluate(&[0, 2, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 2, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // sum_of_squares returns None for invalid configs
-    assert_eq!(problem.sum_of_squares(&[0, 0]), None);
-    assert_eq!(problem.sum_of_squares(&[0, 2, 0]), None);
+    assert_eq!(problem.sum_of_squares(&[0, 0]).unwrap(), None);
+    assert_eq!(problem.sum_of_squares(&[0, 2, 0]).unwrap(), None);
 }
 
 #[test]
@@ -66,11 +85,11 @@ fn test_sum_of_squares_partition_two_elements() {
     // Two elements, 2 groups: balanced vs imbalanced
     let problem = SumOfSquaresPartition::new(vec![3, 5], 2);
     // {3},{5} -> 9+25=34
-    assert_eq!(problem.evaluate(&[0, 1]), Min(Some(34)));
+    assert_eq!(problem.evaluate(&vec![0, 1]).unwrap(), Min(Some(34)));
     // {3,5},{} -> 64+0=64
-    assert_eq!(problem.evaluate(&[0, 0]), Min(Some(64)));
+    assert_eq!(problem.evaluate(&vec![0, 0]).unwrap(), Min(Some(64)));
     // {},{3,5} -> 0+64=64
-    assert_eq!(problem.evaluate(&[1, 1]), Min(Some(64)));
+    assert_eq!(problem.evaluate(&vec![1, 1]).unwrap(), Min(Some(64)));
 }
 
 #[test]
@@ -78,9 +97,10 @@ fn test_sum_of_squares_partition_brute_force() {
     let problem = SumOfSquaresPartition::new(vec![5, 3, 8, 2, 7, 1], 3);
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find an optimal solution");
-    let value = problem.evaluate(&solution);
+    let value = problem.evaluate(&solution).unwrap();
     assert!(value.0.is_some());
 }
 
@@ -88,7 +108,8 @@ fn test_sum_of_squares_partition_brute_force() {
 fn test_sum_of_squares_partition_brute_force_optimal() {
     let problem = SumOfSquaresPartition::new(vec![5, 3, 8, 2, 7, 1], 3);
     let solver = BruteForce::new();
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     // The optimal partition has sums {9,9,8} -> 81+81+64=226
     assert_eq!(value, Min(Some(226)));
 }
@@ -97,12 +118,13 @@ fn test_sum_of_squares_partition_brute_force_optimal() {
 fn test_sum_of_squares_partition_brute_force_all() {
     let problem = SumOfSquaresPartition::new(vec![5, 3, 8, 2, 7, 1], 3);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     // All witnesses should achieve the optimal value
-    let optimal = solver.solve(&problem);
+    let optimal_solution = solver.solve(&problem).unwrap().unwrap();
+    let optimal = problem.evaluate(&optimal_solution).unwrap();
     for sol in &solutions {
-        assert_eq!(problem.evaluate(sol), optimal);
+        assert_eq!(problem.evaluate(sol).unwrap(), optimal);
     }
 }
 
@@ -149,19 +171,28 @@ fn test_sum_of_squares_partition_deserialization_rejects_invalid_fields() {
 }
 
 #[test]
-fn test_sum_of_squares_partition_sum_overflow_returns_none() {
+fn test_sum_of_squares_partition_sum_overflow_is_an_error() {
     let problem = SumOfSquaresPartition::new(vec![i64::MAX, 1], 1);
 
-    assert_eq!(problem.sum_of_squares(&[0, 0]), None);
-    assert_eq!(problem.evaluate(&[0, 0]), Min(None));
+    assert!(matches!(
+        problem.sum_of_squares(&[0, 0]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
 }
 
 #[test]
-fn test_sum_of_squares_partition_square_overflow_returns_none() {
+fn test_sum_of_squares_partition_square_overflow_is_an_error() {
     let problem = SumOfSquaresPartition::new(vec![3_037_000_500], 1);
 
-    assert_eq!(problem.sum_of_squares(&[0]), None);
-    assert_eq!(problem.evaluate(&[0]), Min(None));
+    assert!(problem.sum_of_squares(&[0]).is_err());
+    assert!(matches!(
+        problem.evaluate(&vec![0]),
+        Err(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
 }
 
 #[test]
@@ -172,12 +203,13 @@ fn test_sum_of_squares_partition_paper_example() {
     // Verify a partition:
     // A1={8,1}(sums to 9), A2={5,2}(sums to 7), A3={3,7}(sums to 10)
     let config = vec![1, 2, 0, 1, 2, 0];
-    assert_eq!(problem.evaluate(&config), Min(Some(230)));
-    assert_eq!(problem.sum_of_squares(&config), Some(230));
+    assert_eq!(problem.evaluate(&config).unwrap(), Min(Some(230)));
+    assert_eq!(problem.sum_of_squares(&config).unwrap(), Some(230));
 
     // Brute force finds the optimal value
     let solver = BruteForce::new();
-    let optimal = solver.solve(&problem);
+    let optimal_solution = solver.solve(&problem).unwrap().unwrap();
+    let optimal = problem.evaluate(&optimal_solution).unwrap();
     // Best partition: sums {9,9,8} -> 81+81+64=226
     assert_eq!(optimal, Min(Some(226)));
 }
diff --git a/src/unit_tests/models/misc/three_partition.rs b/src/unit_tests/models/misc/three_partition.rs
index af70099a1..44c354c02 100644
--- a/src/unit_tests/models/misc/three_partition.rs
+++ b/src/unit_tests/models/misc/three_partition.rs
@@ -1,5 +1,6 @@
 use crate::models::misc::ThreePartition;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -15,58 +16,90 @@ fn test_three_partition_basic() {
     assert_eq!(problem.num_elements(), 6);
     assert_eq!(problem.num_groups(), 2);
     assert_eq!(problem.total_sum(), 30);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
     assert_eq!(problem.num_variables(), 6);
     assert_eq!(<ThreePartition as Problem>::NAME, "ThreePartition");
     assert_eq!(<ThreePartition as Problem>::variant(), vec![]);
 }
 
+#[test]
+fn test_three_partition_create_spec_preserves_i64_bound() {
+    let entry = crate::registry::find_variant_entry("ThreePartition", &Default::default()).unwrap();
+    let third = i64::MAX / 3;
+    let problem = (entry.construct_fn)(serde_json::json!({
+        "sizes": vec![third, third, third + 1],
+        "bound": i64::MAX,
+    }))
+    .unwrap();
+    assert_eq!(
+        problem.serialize_json()["bound"],
+        serde_json::json!(i64::MAX)
+    );
+}
+
 #[test]
 fn test_three_partition_evaluate_yes_instance() {
     let problem = yes_problem();
-    assert_eq!(problem.evaluate(&[0, 0, 0, 1, 1, 1]), Or(true));
+    assert_eq!(problem.evaluate(&vec![0, 0, 0, 1, 1, 1]).unwrap(), Or(true));
 }
 
 #[test]
 fn test_three_partition_rejects_wrong_group_sizes_or_sums() {
     let problem = yes_problem();
-    assert_eq!(problem.evaluate(&[0, 0, 1, 1, 1, 1]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1, 0, 1]), Or(false));
+    assert_eq!(
+        problem.evaluate(&vec![0, 0, 1, 1, 1, 1]).unwrap(),
+        Or(false)
+    );
+    assert_eq!(
+        problem.evaluate(&vec![0, 1, 0, 1, 0, 1]).unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
 fn test_three_partition_rejects_invalid_configs() {
     let problem = yes_problem();
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 0, 0, 1, 1, 1, 0]), Or(false));
-    assert_eq!(problem.evaluate(&[0, 0, 0, 1, 1, 2]), Or(false));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 1, 1, 1, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 1, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_three_partition_solver_finds_witness() {
     let problem = yes_problem();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Or(true));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Or(true));
 }
 
 #[test]
 fn test_three_partition_solver_reports_unsatisfiable_instance() {
     let problem = ThreePartition::new(vec![6, 6, 6, 6, 7, 9], 20);
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&problem).is_none());
+    assert!(solver.solve(&problem).unwrap().is_none());
 }
 
 #[test]
 fn test_three_partition_paper_example() {
     let problem = yes_problem();
     let config = vec![0, 0, 0, 1, 1, 1];
-    assert_eq!(problem.evaluate(&config), Or(true));
+    assert_eq!(problem.evaluate(&config).unwrap(), Or(true));
 
     let solver = BruteForce::new();
-    let all = solver.find_all_witnesses(&problem);
+    let all = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(all.len(), 8);
-    assert!(all.iter().all(|sol| problem.evaluate(sol) == Or(true)));
+    assert!(all
+        .iter()
+        .all(|sol| problem.evaluate(sol).unwrap() == Or(true)));
 }
 
 #[test]
diff --git a/src/unit_tests/models/misc/timetable_design.rs b/src/unit_tests/models/misc/timetable_design.rs
index 45184be81..ee8aaad02 100644
--- a/src/unit_tests/models/misc/timetable_design.rs
+++ b/src/unit_tests/models/misc/timetable_design.rs
@@ -1,17 +1,28 @@
-use crate::models::misc::TimetableDesign;
+use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_rejects_matrix_shape_mismatch() {
+    assert_eq!(TimetableDesignCreateSpec::FIELDS[3].name, "craftsman_avail");
+    assert!(TimetableDesign::try_from(TimetableDesignCreateSpec {
+        num_periods: 1,
+        num_craftsmen: 1,
+        num_tasks: 1,
+        craftsman_avail: vec![],
+        task_avail: vec![vec![true]],
+        requirements: vec![vec![1]]
+    })
+    .is_err());
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
-#[cfg(feature = "ilp-solver")]
-use std::collections::BTreeMap;
 
-fn timetable_design_flat_index(
-    num_tasks: usize,
-    num_periods: usize,
-    craftsman: usize,
-    task: usize,
-    period: usize,
-) -> usize {
-    ((craftsman * num_tasks) + task) * num_periods + period
+fn toy_config(assignments: &[(usize, usize, usize)]) -> Vec<Vec<Vec<bool>>> {
+    let mut config = vec![vec![vec![false; 2]; 2]; 2];
+    for &(craftsman, task, period) in assignments {
+        config[craftsman][task][period] = true;
+    }
+    config
 }
 
 fn timetable_design_toy_problem() -> TimetableDesign {
@@ -38,7 +49,7 @@ fn test_timetable_design_creation_and_dims() {
     );
     assert_eq!(problem.task_avail(), &[vec![true, true], vec![false, true]]);
     assert_eq!(problem.requirements(), &[vec![1, 0], vec![0, 1]]);
-    assert_eq!(problem.dims(), vec![2; 8]);
+    assert_eq!(problem.dimensions(), vec![2; 8]);
 }
 
 #[test]
@@ -76,74 +87,72 @@ fn test_timetable_design_new_panics_on_requirement_width_mismatch() {
 #[test]
 fn test_timetable_design_evaluate_valid_config() {
     let problem = timetable_design_toy_problem();
-    let config = vec![1, 0, 0, 0, 0, 0, 0, 1];
+    let config = toy_config(&[(0, 0, 0), (1, 1, 1)]);
 
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_timetable_design_rejects_wrong_config_length() {
     let problem = timetable_design_toy_problem();
 
-    assert!(!problem.evaluate(&[1, 0, 0]));
-    assert!(!problem.evaluate(&[0; 9]));
+    assert!(problem.evaluate(&vec![vec![vec![true]]]).is_err());
+    assert!(problem.evaluate(&vec![vec![vec![false; 2]; 2]; 3]).is_err());
 }
 
 #[test]
 fn test_timetable_design_rejects_assignment_outside_availability() {
     let problem = timetable_design_toy_problem();
-    let config = vec![0, 1, 0, 0, 0, 0, 0, 1];
+    let config = toy_config(&[(0, 0, 1), (1, 1, 1)]);
 
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_timetable_design_rejects_double_booked_craftsman() {
     let problem = timetable_design_toy_problem();
-    let config = vec![1, 0, 0, 0, 0, 1, 0, 1];
+    let config = toy_config(&[(0, 0, 0), (1, 0, 1), (1, 1, 1)]);
 
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_timetable_design_rejects_double_booked_task() {
     let problem = timetable_design_toy_problem();
-    let config = vec![1, 0, 0, 0, 1, 0, 0, 1];
+    let config = toy_config(&[(0, 0, 0), (1, 0, 0), (1, 1, 1)]);
 
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_timetable_design_rejects_requirement_mismatch() {
     let problem = timetable_design_toy_problem();
-    let config = vec![1, 0, 0, 0, 0, 0, 0, 0];
+    let config = toy_config(&[(0, 0, 0)]);
 
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_timetable_design_bruteforce_solver_finds_solution() {
     let problem = timetable_design_toy_problem();
-    let solution = BruteForce::new().find_witness(&problem);
+    let solution = BruteForce::new().solve(&problem).unwrap();
 
     assert!(solution.is_some());
-    assert!(problem.evaluate(&solution.unwrap()));
+    assert!(problem.evaluate(&solution.unwrap()).unwrap());
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
-fn test_timetable_design_issue_example_is_solved_via_ilp_solver_dispatch() {
+fn test_timetable_design_customized_solver_finds_feasible_solution() {
     let problem = super::issue_example_problem();
-    let solution = crate::solvers::ILPSolver::new()
-        .solve_via_reduction("TimetableDesign", &BTreeMap::new(), &problem)
-        .expect("expected ILP solver dispatch to find a satisfying timetable");
+    let solution = problem
+        .solve_via_required_assignments()
+        .expect("expected customized solver to find a satisfying timetable");
 
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
-fn test_timetable_design_unsat_instance_returns_none_via_ilp_solver_dispatch() {
+fn test_timetable_design_customized_solver_returns_none_for_infeasible_instance() {
     let problem = TimetableDesign::new(
         1,
         2,
@@ -153,9 +162,7 @@ fn test_timetable_design_unsat_instance_returns_none_via_ilp_solver_dispatch() {
         vec![vec![1], vec![1]],
     );
 
-    assert!(crate::solvers::ILPSolver::new()
-        .solve_via_reduction("TimetableDesign", &BTreeMap::new(), &problem)
-        .is_none());
+    assert!(problem.solve_via_required_assignments().is_none());
 }
 
 #[test]
@@ -178,28 +185,25 @@ fn test_timetable_design_issue_example_is_valid() {
     let problem = super::issue_example_problem();
     let config = super::issue_example_config();
 
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_timetable_design_issue_example_rejects_flipped_required_assignment() {
     let problem = super::issue_example_problem();
     let mut config = super::issue_example_config();
-    let forced = timetable_design_flat_index(problem.num_tasks(), problem.num_periods(), 1, 1, 1);
-    config[forced] = 0;
+    config[1][1][1] = false;
 
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[test]
 fn test_timetable_design_issue_example_rejects_conflicting_assignment() {
     let problem = super::issue_example_problem();
     let mut config = super::issue_example_config();
-    let conflicting =
-        timetable_design_flat_index(problem.num_tasks(), problem.num_periods(), 4, 0, 0);
-    config[conflicting] = 1;
+    config[4][0][0] = true;
 
-    assert!(!problem.evaluate(&config));
+    assert!(!problem.evaluate(&config).unwrap());
 }
 
 #[cfg(feature = "example-db")]
@@ -210,13 +214,16 @@ fn test_timetable_design_paper_example_is_valid() {
 
     let spec = &specs[0];
     assert_eq!(spec.id, "timetable_design");
-    assert_eq!(spec.optimal_config, super::issue_example_config());
+    assert_eq!(
+        spec.optimal_config,
+        serde_json::to_value(super::issue_example_config()).unwrap()
+    );
     assert_eq!(
         spec.instance.serialize_json(),
         serde_json::to_value(super::issue_example_problem()).unwrap()
     );
     assert_eq!(
-        spec.instance.evaluate_json(&spec.optimal_config),
+        spec.instance.evaluate_json(&spec.optimal_config).unwrap(),
         serde_json::json!(true)
     );
     assert_eq!(spec.optimal_value, serde_json::json!(true));
diff --git a/src/unit_tests/models/set/comparative_containment.rs b/src/unit_tests/models/set/comparative_containment.rs
index c677fd45e..8d0ecd984 100644
--- a/src/unit_tests/models/set/comparative_containment.rs
+++ b/src/unit_tests/models/set/comparative_containment.rs
@@ -1,9 +1,33 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+
+#[test]
+fn create_spec_defaults_weights_and_validates_sets() {
+    let problem = ComparativeContainment::<i64>::try_from(ComparativeContainmentI64CreateSpec {
+        universe_size: 2,
+        r_sets: vec![vec![0]],
+        s_sets: vec![vec![1]],
+        r_weights: None,
+        s_weights: None,
+    })
+    .unwrap();
+    assert_eq!(problem.r_weights(), &[1]);
+    assert!(
+        ComparativeContainment::<i64>::try_from(ComparativeContainmentI64CreateSpec {
+            universe_size: 1,
+            r_sets: vec![vec![1]],
+            s_sets: vec![],
+            r_weights: None,
+            s_weights: None
+        })
+        .is_err()
+    );
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::One;
 
-fn yes_instance() -> ComparativeContainment<i32> {
+fn yes_instance() -> ComparativeContainment<i64> {
     ComparativeContainment::with_weights(
         4,
         vec![vec![0, 1, 2, 3], vec![0, 1]],
@@ -11,9 +35,10 @@ fn yes_instance() -> ComparativeContainment<i32> {
         vec![2, 5],
         vec![3, 6],
     )
+    .unwrap()
 }
 
-fn no_instance() -> ComparativeContainment<i32> {
+fn no_instance() -> ComparativeContainment<i64> {
     ComparativeContainment::with_weights(
         2,
         vec![vec![0], vec![1]],
@@ -21,6 +46,7 @@ fn no_instance() -> ComparativeContainment<i32> {
         vec![1, 1],
         vec![3],
     )
+    .unwrap()
 }
 
 #[test]
@@ -30,13 +56,13 @@ fn test_comparative_containment_creation() {
     assert_eq!(problem.num_r_sets(), 2);
     assert_eq!(problem.num_s_sets(), 2);
     assert_eq!(problem.num_variables(), 4);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2]);
 }
 
 #[test]
 fn test_comparative_containment_unit_weights() {
     let problem =
-        ComparativeContainment::<One>::new(3, vec![vec![0, 1], vec![1, 2]], vec![vec![0]]);
+        ComparativeContainment::<One>::new(3, vec![vec![0, 1], vec![1, 2]], vec![vec![0]]).unwrap();
     assert_eq!(problem.r_weights(), &[One, One]);
     assert_eq!(problem.s_weights(), &[One]);
 }
@@ -44,42 +70,48 @@ fn test_comparative_containment_unit_weights() {
 #[test]
 fn test_comparative_containment_evaluation_yes_and_no_examples() {
     let yes = yes_instance();
-    assert!(yes.evaluate(&[1, 0, 0, 0]));
-    assert!(!yes.evaluate(&[0, 0, 1, 0]));
-    assert!(!yes.evaluate(&[0, 0, 0, 0]));
+    assert!(yes.evaluate(&vec![true, false, false, false]).unwrap());
+    assert!(!yes.evaluate(&vec![false, false, true, false]).unwrap());
+    assert!(!yes.evaluate(&vec![false, false, false, false]).unwrap());
 
     let no = no_instance();
-    assert!(!no.evaluate(&[0, 0]));
-    assert!(!no.evaluate(&[1, 0]));
-    assert!(!no.evaluate(&[0, 1]));
-    assert!(!no.evaluate(&[1, 1]));
+    assert!(!no.evaluate(&vec![false, false]).unwrap());
+    assert!(!no.evaluate(&vec![true, false]).unwrap());
+    assert!(!no.evaluate(&vec![false, true]).unwrap());
+    assert!(!no.evaluate(&vec![true, true]).unwrap());
 }
 
 #[test]
 fn test_comparative_containment_rejects_invalid_configs() {
     let problem = yes_instance();
-    assert!(!problem.evaluate(&[1, 0, 0]));
-    assert!(!problem.evaluate(&[1, 0, 0, 2]));
+    assert!(matches!(
+        problem.evaluate(&vec![true, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([true, false, false, 2])
+    )
+    .is_err());
 }
 
 #[test]
 fn test_comparative_containment_contains_selected_subset_requires_valid_config() {
     let problem = yes_instance();
-    assert!(problem.contains_selected_subset(&[1, 0, 0, 0], &[0, 1, 2, 3]));
-    assert!(!problem.contains_selected_subset(&[0, 0, 1, 0], &[0, 1]));
-    assert!(!problem.contains_selected_subset(&[1, 0, 0], &[0, 1, 2, 3]));
-    assert!(!problem.contains_selected_subset(&[1, 0, 0, 2], &[0, 1, 2, 3]));
+    assert!(problem.contains_selected_subset(&[true, false, false, false], &[0, 1, 2, 3]));
+    assert!(!problem.contains_selected_subset(&[false, false, true, false], &[0, 1]));
+    assert!(!problem.contains_selected_subset(&[true, false, false], &[0, 1, 2, 3]));
 }
 
 #[test]
 fn test_comparative_containment_solver() {
     let solver = BruteForce::new();
 
-    let yes_solutions = solver.find_all_witnesses(&yes_instance());
-    assert!(yes_solutions.contains(&vec![1, 0, 0, 0]));
+    let yes_solutions = solver.find_all_witnesses(&yes_instance()).unwrap();
+    assert!(yes_solutions.contains(&vec![true, false, false, false]));
     assert!(!yes_solutions.is_empty());
 
-    let no_solutions = solver.find_all_witnesses(&no_instance());
+    let no_solutions = solver.find_all_witnesses(&no_instance()).unwrap();
     assert!(no_solutions.is_empty());
 }
 
@@ -87,7 +119,7 @@ fn test_comparative_containment_solver() {
 fn test_comparative_containment_serialization() {
     let problem = yes_instance();
     let json = serde_json::to_string(&problem).unwrap();
-    let restored: ComparativeContainment<i32> = serde_json::from_str(&json).unwrap();
+    let restored: ComparativeContainment<i64> = serde_json::from_str(&json).unwrap();
     assert_eq!(restored.universe_size(), problem.universe_size());
     assert_eq!(restored.r_sets(), problem.r_sets());
     assert_eq!(restored.s_sets(), problem.s_sets());
@@ -98,11 +130,11 @@ fn test_comparative_containment_serialization() {
 #[test]
 fn test_comparative_containment_paper_example() {
     let problem = yes_instance();
-    let config = vec![1, 0, 0, 0];
-    assert!(problem.evaluate(&config));
+    let config = vec![true, false, false, false];
+    assert!(problem.evaluate(&config).unwrap());
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 3);
     assert!(solutions.contains(&config));
 }
@@ -111,58 +143,104 @@ fn test_comparative_containment_paper_example() {
 fn test_comparative_containment_weight_sums() {
     let problem = yes_instance();
     // Y = {0}: R1={0,1,2,3} contains {0} (w=2), R2={0,1} contains {0} (w=5) → 7
-    assert_eq!(problem.r_weight_sum(&[1, 0, 0, 0]), Some(7));
+    assert_eq!(
+        problem.r_weight_sum(&[true, false, false, false]).unwrap(),
+        Some(7)
+    );
     // Y = {0}: S1={0,1,2,3} contains {0} (w=3), S2={2,3} does not → 3
-    assert_eq!(problem.s_weight_sum(&[1, 0, 0, 0]), Some(3));
+    assert_eq!(
+        problem.s_weight_sum(&[true, false, false, false]).unwrap(),
+        Some(3)
+    );
     // Invalid config returns None
-    assert_eq!(problem.r_weight_sum(&[1, 0, 0]), None);
-    assert_eq!(problem.s_weight_sum(&[1, 0, 0, 2]), None);
+    assert_eq!(problem.r_weight_sum(&[true, false, false]).unwrap(), None);
 }
 
 #[test]
-#[should_panic(expected = "number of R sets and R weights must match")]
 fn test_comparative_containment_rejects_mismatched_r_weights() {
-    ComparativeContainment::with_weights(2, vec![vec![0]], vec![vec![0]], vec![1, 2], vec![1]);
+    assert!(ComparativeContainment::with_weights(
+        2,
+        vec![vec![0]],
+        vec![vec![0]],
+        vec![1, 2],
+        vec![1]
+    )
+    .is_err());
 }
 
 #[test]
-#[should_panic(expected = "number of S sets and S weights must match")]
 fn test_comparative_containment_rejects_mismatched_s_weights() {
-    ComparativeContainment::with_weights(2, vec![vec![0]], vec![vec![0]], vec![1], vec![1, 2]);
+    assert!(ComparativeContainment::with_weights(
+        2,
+        vec![vec![0]],
+        vec![vec![0]],
+        vec![1],
+        vec![1, 2]
+    )
+    .is_err());
 }
 
 #[test]
-#[should_panic(expected = "R weights must be finite and positive")]
-fn test_comparative_containment_rejects_nonpositive_i32_weights() {
-    ComparativeContainment::with_weights(2, vec![vec![0]], vec![vec![0]], vec![0], vec![1]);
+fn test_comparative_containment_rejects_nonpositive_i64_weights() {
+    assert!(ComparativeContainment::with_weights(
+        2,
+        vec![vec![0]],
+        vec![vec![0]],
+        vec![0],
+        vec![1]
+    )
+    .is_err());
 }
 
 #[test]
-#[should_panic(expected = "S weights must be finite and positive")]
-fn test_comparative_containment_rejects_nonpositive_i32_s_weights() {
-    ComparativeContainment::with_weights(2, vec![vec![0]], vec![vec![0]], vec![1], vec![0]);
+fn test_comparative_containment_rejects_nonpositive_i64_s_weights() {
+    assert!(ComparativeContainment::with_weights(
+        2,
+        vec![vec![0]],
+        vec![vec![0]],
+        vec![1],
+        vec![0]
+    )
+    .is_err());
 }
 
 #[test]
-#[should_panic(expected = "R weights must be finite and positive")]
 fn test_comparative_containment_rejects_non_finite_f64_weights() {
-    ComparativeContainment::with_weights(
+    assert!(ComparativeContainment::with_weights(
         2,
         vec![vec![0]],
         vec![vec![0]],
         vec![f64::NAN],
         vec![1.0],
-    );
+    )
+    .is_err());
 }
 
 #[test]
-#[should_panic(expected = "S weights must be finite and positive")]
 fn test_comparative_containment_rejects_nonpositive_f64_weights() {
-    ComparativeContainment::with_weights(2, vec![vec![0]], vec![vec![0]], vec![1.0], vec![0.0]);
+    assert!(ComparativeContainment::with_weights(
+        2,
+        vec![vec![0]],
+        vec![vec![0]],
+        vec![1.0],
+        vec![0.0]
+    )
+    .is_err());
 }
 
 #[test]
-#[should_panic(expected = "contains element")]
 fn test_comparative_containment_rejects_out_of_range_elements() {
-    ComparativeContainment::<i32>::new(2, vec![vec![0, 2]], vec![vec![0]]);
+    assert!(ComparativeContainment::<i64>::new(2, vec![vec![0, 2]], vec![vec![0]]).is_err());
+}
+
+#[test]
+fn test_comparative_containment_deserialization_validates_fields() {
+    let json = r#"{
+        "universe_size": 1,
+        "r_sets": [[1]],
+        "s_sets": [],
+        "r_weights": [1.0],
+        "s_weights": []
+    }"#;
+    assert!(serde_json::from_str::<ComparativeContainment<f64>>(json).is_err());
 }
diff --git a/src/unit_tests/models/set/consecutive_sets.rs b/src/unit_tests/models/set/consecutive_sets.rs
index d0f249900..4c94c0afa 100644
--- a/src/unit_tests/models/set/consecutive_sets.rs
+++ b/src/unit_tests/models/set/consecutive_sets.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -13,7 +14,7 @@ fn test_consecutive_sets_creation() {
     assert_eq!(problem.num_subsets(), 5);
     assert_eq!(problem.bound_k(), 6);
     assert_eq!(problem.num_variables(), 6);
-    assert_eq!(problem.dims(), vec![7; 6]); // alphabet_size + 1 = 7
+    assert_eq!(problem.dimensions(), vec![7; 6]); // alphabet_size + 1 = 7
 }
 
 #[test]
@@ -24,11 +25,15 @@ fn test_consecutive_sets_evaluation() {
         6,
     );
     // YES: w = [0, 4, 2, 5, 1, 3]
-    assert!(problem.evaluate(&[0, 4, 2, 5, 1, 3]));
+    assert!(problem
+        .evaluate(&vec![Some(0), Some(4), Some(2), Some(5), Some(1), Some(3)])
+        .unwrap());
     // NO: identity string [0, 1, 2, 3, 4, 5] — {0,4} not adjacent
-    assert!(!problem.evaluate(&[0, 1, 2, 3, 4, 5]));
+    assert!(!problem
+        .evaluate(&vec![Some(0), Some(1), Some(2), Some(3), Some(4), Some(5)])
+        .unwrap());
     // NO: all unused (empty string can't satisfy non-empty subsets)
-    assert!(!problem.evaluate(&[6, 6, 6, 6, 6, 6]));
+    assert!(!problem.evaluate(&vec![None; 6]).unwrap());
 }
 
 #[test]
@@ -39,7 +44,7 @@ fn test_consecutive_sets_no_instance() {
     // Search space: 4^3 = 64 configs, very fast.
     let problem = ConsecutiveSets::new(3, vec![vec![0, 1], vec![1, 2], vec![0, 2]], 3);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(solutions.is_empty());
 }
 
@@ -49,20 +54,26 @@ fn test_consecutive_sets_solver() {
     // Valid string: [0, 1, 2] — {0,1} at positions 0-1, {1,2} at positions 1-2
     let problem = ConsecutiveSets::new(3, vec![vec![0, 1], vec![1, 2]], 3);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
     // Known solution: [0, 1, 2] — {0,1} at window 0-1, {1,2} at window 1-2
-    assert!(solutions.contains(&vec![0, 1, 2]));
+    assert!(solutions.contains(&vec![Some(0), Some(1), Some(2)]));
 }
 
 #[test]
 fn test_consecutive_sets_rejects_wrong_config_length() {
     let problem = ConsecutiveSets::new(3, vec![vec![0, 1]], 3);
-    assert!(!problem.evaluate(&[0, 1])); // too short
-    assert!(!problem.evaluate(&[0, 1, 2, 0])); // too long
+    assert!(matches!(
+        problem.evaluate(&vec![Some(0), Some(1)]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![Some(0), Some(1), Some(2), Some(0)]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
@@ -70,19 +81,23 @@ fn test_consecutive_sets_rejects_internal_unused() {
     // Internal "unused" symbol should be rejected
     let problem = ConsecutiveSets::new(3, vec![vec![0, 1]], 4);
     // [0, 3, 1, 3] has "unused" (3) at position 1, which is internal
-    assert!(!problem.evaluate(&[0, 3, 1, 3]));
+    assert!(!problem
+        .evaluate(&vec![Some(0), None, Some(1), None])
+        .unwrap());
 }
 
 #[test]
 fn test_consecutive_sets_accepts_shorter_string_with_trailing_unused() {
     let problem = ConsecutiveSets::new(3, vec![vec![0, 1]], 4);
-    assert!(problem.evaluate(&[0, 1, 3, 3]));
+    assert!(problem
+        .evaluate(&vec![Some(0), Some(1), None, None])
+        .unwrap());
 }
 
 #[test]
 fn test_consecutive_sets_rejects_duplicate_window_symbol() {
     let problem = ConsecutiveSets::new(2, vec![vec![0, 1]], 2);
-    assert!(!problem.evaluate(&[0, 0]));
+    assert!(!problem.evaluate(&vec![Some(0), Some(0)]).unwrap());
 }
 
 #[test]
@@ -101,9 +116,9 @@ fn test_consecutive_sets_empty_subsets() {
     // Empty collection — trivially satisfiable by any string (even empty)
     let problem = ConsecutiveSets::new(3, vec![], 3);
     // All unused = empty string is fine
-    assert!(problem.evaluate(&[3, 3, 3]));
+    assert!(problem.evaluate(&vec![None; 3]).unwrap());
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
 }
 
diff --git a/src/unit_tests/models/set/exact_cover_by_3_sets.rs b/src/unit_tests/models/set/exact_cover_by_3_sets.rs
index fef828bfb..a7cdf05cc 100644
--- a/src/unit_tests/models/set/exact_cover_by_3_sets.rs
+++ b/src/unit_tests/models/set/exact_cover_by_3_sets.rs
@@ -1,4 +1,14 @@
 use super::*;
+use crate::solvers::BruteForceProblem as _;
+#[test]
+fn create_spec_sorts_triples() {
+    let problem = ExactCoverBy3Sets::try_from(ExactCoverBy3SetsCreateSpec {
+        universe_size: 3,
+        subsets: vec![[2, 0, 1]],
+    })
+    .unwrap();
+    assert_eq!(problem.subsets(), &[[0, 1, 2]]);
+}
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
@@ -9,7 +19,7 @@ fn test_exact_cover_by_3_sets_creation() {
     assert_eq!(problem.num_subsets(), 3);
     assert_eq!(problem.num_sets(), 3);
     assert_eq!(problem.num_variables(), 3);
-    assert_eq!(problem.dims(), vec![2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2]);
 }
 
 #[test]
@@ -19,31 +29,38 @@ fn test_exact_cover_by_3_sets_evaluation() {
     let problem = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
 
     // S0 + S1 = exact cover
-    assert!(problem.evaluate(&[1, 1, 0]));
+    assert!(problem.evaluate(&vec![true, true, false]).unwrap());
 
     // S0 + S2 overlap at element 0
-    assert!(!problem.evaluate(&[1, 0, 1]));
+    assert!(!problem.evaluate(&vec![true, false, true]).unwrap());
 
     // Only S0 selected (need q=2 subsets)
-    assert!(!problem.evaluate(&[1, 0, 0]));
+    assert!(!problem.evaluate(&vec![true, false, false]).unwrap());
 
     // All selected (too many, and overlapping)
-    assert!(!problem.evaluate(&[1, 1, 1]));
+    assert!(!problem.evaluate(&vec![true, true, true]).unwrap());
 
     // None selected
-    assert!(!problem.evaluate(&[0, 0, 0]));
+    assert!(!problem.evaluate(&vec![false, false, false]).unwrap());
 }
 
 #[test]
 fn test_exact_cover_by_3_sets_rejects_wrong_config_length() {
     let problem = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5]]);
-    assert!(!problem.evaluate(&[1, 1, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![true, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_exact_cover_by_3_sets_rejects_non_binary_config_values() {
     let problem = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
-    assert!(!problem.evaluate(&[1, 1, 2]));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([true, true, 2])
+    )
+    .is_err());
 }
 
 #[test]
@@ -65,15 +82,15 @@ fn test_exact_cover_by_3_sets_solver() {
     );
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
 
     // S0={0,1,2}, S2={3,4,5}, S4={6,7,8} is an exact cover
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
     // Verify the known solution is in there
-    assert!(solutions.contains(&vec![1, 0, 1, 0, 1, 0, 0]));
+    assert!(solutions.contains(&vec![true, false, true, false, true, false, false]));
 }
 
 #[test]
@@ -84,7 +101,7 @@ fn test_exact_cover_by_3_sets_no_solution() {
     let problem = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [0, 3, 4], [0, 4, 5]]);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(solutions.is_empty());
 }
 
@@ -103,14 +120,14 @@ fn test_exact_cover_by_3_sets_serialization() {
 #[test]
 fn test_exact_cover_by_3_sets_is_valid_solution() {
     let problem = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5]]);
-    assert!(problem.is_valid_solution(&[1, 1]));
-    assert!(!problem.is_valid_solution(&[1, 0]));
+    assert!(problem.is_valid_solution(&[true, true]).unwrap());
+    assert!(!problem.is_valid_solution(&[true, false]).unwrap());
 }
 
 #[test]
 fn test_exact_cover_by_3_sets_covered_elements() {
     let problem = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
-    let covered = problem.covered_elements(&[1, 0, 1]);
+    let covered = problem.covered_elements(&[true, false, true]);
     assert_eq!(covered.len(), 5); // {0,1,2,3,4} -- note element 0 appears twice
     assert!(covered.contains(&0));
     assert!(covered.contains(&4));
@@ -129,10 +146,10 @@ fn test_exact_cover_by_3_sets_get_subset() {
 fn test_exact_cover_by_3_sets_empty() {
     // Empty universe with no subsets -- trivially satisfiable
     let problem = ExactCoverBy3Sets::new(0, vec![]);
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&vec![]).unwrap());
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
-    assert_eq!(solutions, vec![Vec::<usize>::new()]);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
+    assert_eq!(solutions, vec![Vec::<bool>::new()]);
 }
 
 #[test]
diff --git a/src/unit_tests/models/set/integer_knapsack.rs b/src/unit_tests/models/set/integer_knapsack.rs
index 7071a4008..b03fc1744 100644
--- a/src/unit_tests/models/set/integer_knapsack.rs
+++ b/src/unit_tests/models/set/integer_knapsack.rs
@@ -4,80 +4,99 @@ use crate::traits::Problem;
 
 #[test]
 fn test_integer_knapsack_basic() {
-    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15);
+    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15).unwrap();
     assert_eq!(problem.num_items(), 5);
     assert_eq!(problem.sizes(), &[3, 4, 5, 2, 7]);
     assert_eq!(problem.values(), &[4, 5, 7, 3, 9]);
     assert_eq!(problem.capacity(), 15);
     // dims: floor(15/3)+1=6, floor(15/4)+1=4, floor(15/5)+1=4, floor(15/2)+1=8, floor(15/7)+1=3
-    assert_eq!(problem.dims(), vec![6, 4, 4, 8, 3]);
+    assert_eq!(problem.dimensions(), vec![6, 4, 4, 8, 3]);
     assert_eq!(<IntegerKnapsack as Problem>::NAME, "IntegerKnapsack");
     assert_eq!(<IntegerKnapsack as Problem>::variant(), vec![]);
 }
 
 #[test]
 fn test_integer_knapsack_evaluate_optimal() {
-    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15);
+    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15).unwrap();
     // c=(0,0,1,5,0): size=0+0+5+10+0=15, value=0+0+7+15+0=22
-    assert_eq!(problem.evaluate(&[0, 0, 1, 5, 0]), Max(Some(22)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 0, 1, 5, 0]).unwrap(),
+        Max(Some(22))
+    );
 }
 
 #[test]
 fn test_integer_knapsack_evaluate_feasible() {
-    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15);
+    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15).unwrap();
     // c=(1,0,0,6,0): size=3+0+0+12+0=15, value=4+0+0+18+0=22
-    assert_eq!(problem.evaluate(&[1, 0, 0, 6, 0]), Max(Some(22)));
+    assert_eq!(
+        problem.evaluate(&vec![1, 0, 0, 6, 0]).unwrap(),
+        Max(Some(22))
+    );
 }
 
 #[test]
 fn test_integer_knapsack_evaluate_overweight() {
-    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15);
+    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15).unwrap();
     // c=(5,0,0,1,0): size=15+0+0+2+0=17 > 15
-    assert_eq!(problem.evaluate(&[5, 0, 0, 1, 0]), Max(None));
+    assert_eq!(problem.evaluate(&vec![5, 0, 0, 1, 0]).unwrap(), Max(None));
 }
 
 #[test]
 fn test_integer_knapsack_evaluate_empty() {
-    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15);
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0, 0]), Max(Some(0)));
+    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15).unwrap();
+    assert_eq!(
+        problem.evaluate(&vec![0, 0, 0, 0, 0]).unwrap(),
+        Max(Some(0))
+    );
 }
 
 #[test]
 fn test_integer_knapsack_evaluate_wrong_config_length() {
-    let problem = IntegerKnapsack::new(vec![3, 4], vec![4, 5], 10);
-    assert_eq!(problem.evaluate(&[1]), Max(None));
-    assert_eq!(problem.evaluate(&[1, 0, 0]), Max(None));
+    let problem = IntegerKnapsack::new(vec![3, 4], vec![4, 5], 10).unwrap();
+    assert!(matches!(
+        problem.evaluate(&vec![1]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![1, 0, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_integer_knapsack_evaluate_out_of_domain() {
-    let problem = IntegerKnapsack::new(vec![3, 4], vec![4, 5], 10);
+    let problem = IntegerKnapsack::new(vec![3, 4], vec![4, 5], 10).unwrap();
     // dims = [4, 3], so config [4, 0] is out of domain for item 0
-    assert_eq!(problem.evaluate(&[4, 0]), Max(None));
+    assert!(matches!(
+        problem.evaluate(&vec![4, 0]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_integer_knapsack_empty_instance() {
-    let problem = IntegerKnapsack::new(vec![], vec![], 10);
+    let problem = IntegerKnapsack::new(vec![], vec![], 10).unwrap();
     assert_eq!(problem.num_items(), 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert_eq!(problem.evaluate(&[]), Max(Some(0)));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Max(Some(0)));
 }
 
 #[test]
 fn test_integer_knapsack_brute_force() {
-    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15);
+    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15).unwrap();
     let solver = BruteForce::new();
     let solution = solver
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should find a solution");
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     assert_eq!(metric, Max(Some(22)));
 }
 
 #[test]
 fn test_integer_knapsack_serialization() {
-    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15);
+    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15).unwrap();
     let json = serde_json::to_value(&problem).unwrap();
     let restored: IntegerKnapsack = serde_json::from_value(json).unwrap();
     assert_eq!(restored.sizes(), problem.sizes());
@@ -87,26 +106,33 @@ fn test_integer_knapsack_serialization() {
 
 #[test]
 fn test_integer_knapsack_zero_capacity() {
-    let problem = IntegerKnapsack::new(vec![1, 2], vec![10, 20], 0);
-    assert_eq!(problem.dims(), vec![1, 1]); // floor(0/1)+1=1, floor(0/2)+1=1
-    assert_eq!(problem.evaluate(&[0, 0]), Max(Some(0)));
+    let problem = IntegerKnapsack::new(vec![1, 2], vec![10, 20], 0).unwrap();
+    assert_eq!(problem.dimensions(), vec![1, 1]); // floor(0/1)+1=1, floor(0/2)+1=1
+    assert_eq!(problem.evaluate(&vec![0, 0]).unwrap(), Max(Some(0)));
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Max(Some(0)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(0)));
+}
+
+#[cfg(target_pointer_width = "64")]
+#[test]
+fn test_integer_knapsack_dimension_uses_structural_range() {
+    let problem = IntegerKnapsack::new(vec![1], vec![1], i64::MAX).unwrap();
+    assert_eq!(problem.dimensions(), vec![1_usize << 63]);
 }
 
 #[test]
 fn test_integer_knapsack_single_item() {
     // Single item size=3, value=5, capacity=7
     // Max multiplicity: floor(7/3)=2, dims=[3]
-    let problem = IntegerKnapsack::new(vec![3], vec![5], 7);
-    assert_eq!(problem.dims(), vec![3]);
-    assert_eq!(problem.evaluate(&[0]), Max(Some(0)));
-    assert_eq!(problem.evaluate(&[1]), Max(Some(5)));
-    assert_eq!(problem.evaluate(&[2]), Max(Some(10)));
+    let problem = IntegerKnapsack::new(vec![3], vec![5], 7).unwrap();
+    assert_eq!(problem.dimensions(), vec![3]);
+    assert_eq!(problem.evaluate(&vec![0]).unwrap(), Max(Some(0)));
+    assert_eq!(problem.evaluate(&vec![1]).unwrap(), Max(Some(5)));
+    assert_eq!(problem.evaluate(&vec![2]).unwrap(), Max(Some(10)));
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Max(Some(10)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(10)));
 }
 
 #[test]
@@ -116,40 +142,35 @@ fn test_integer_knapsack_multiple_copies_better() {
     // Capacity=9
     // 0-1 knapsack best: {0,1} size=8, value=10
     // Integer knapsack best: 3 copies of item 0 → size=9, value=12
-    let problem = IntegerKnapsack::new(vec![3, 5], vec![4, 6], 9);
+    let problem = IntegerKnapsack::new(vec![3, 5], vec![4, 6], 9).unwrap();
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Max(Some(12)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(12)));
 }
 
 #[test]
-#[should_panic(expected = "sizes and values must have the same length")]
 fn test_integer_knapsack_mismatched_lengths() {
-    IntegerKnapsack::new(vec![1, 2], vec![3], 5);
+    assert!(IntegerKnapsack::new(vec![1, 2], vec![3], 5).is_err());
 }
 
 #[test]
-#[should_panic(expected = "positive")]
-fn test_integer_knapsack_zero_size_panics() {
-    IntegerKnapsack::new(vec![0, 2], vec![3, 4], 5);
+fn test_integer_knapsack_rejects_zero_size() {
+    assert!(IntegerKnapsack::new(vec![0, 2], vec![3, 4], 5).is_err());
 }
 
 #[test]
-#[should_panic(expected = "positive")]
-fn test_integer_knapsack_negative_size_panics() {
-    IntegerKnapsack::new(vec![-1, 2], vec![3, 4], 5);
+fn test_integer_knapsack_rejects_negative_size() {
+    assert!(IntegerKnapsack::new(vec![-1, 2], vec![3, 4], 5).is_err());
 }
 
 #[test]
-#[should_panic(expected = "positive")]
-fn test_integer_knapsack_zero_value_panics() {
-    IntegerKnapsack::new(vec![1, 2], vec![0, 4], 5);
+fn test_integer_knapsack_rejects_zero_value() {
+    assert!(IntegerKnapsack::new(vec![1, 2], vec![0, 4], 5).is_err());
 }
 
 #[test]
-#[should_panic(expected = "nonnegative")]
-fn test_integer_knapsack_negative_capacity_panics() {
-    IntegerKnapsack::new(vec![1, 2], vec![3, 4], -1);
+fn test_integer_knapsack_rejects_negative_capacity() {
+    assert!(IntegerKnapsack::new(vec![1, 2], vec![3, 4], -1).is_err());
 }
 
 #[test]
@@ -212,14 +233,20 @@ fn test_integer_knapsack_deserialization_rejects_invalid_fields() {
 fn test_integer_knapsack_paper_example() {
     // From issue #532: 5 items, sizes=[3,4,5,2,7], values=[4,5,7,3,9], B=15
     // Optimal=22 with c=(0,0,1,5,0) or c=(1,0,0,6,0)
-    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15);
+    let problem = IntegerKnapsack::new(vec![3, 4, 5, 2, 7], vec![4, 5, 7, 3, 9], 15).unwrap();
 
     // Verify both optimal solutions
-    assert_eq!(problem.evaluate(&[0, 0, 1, 5, 0]), Max(Some(22)));
-    assert_eq!(problem.evaluate(&[1, 0, 0, 6, 0]), Max(Some(22)));
+    assert_eq!(
+        problem.evaluate(&vec![0, 0, 1, 5, 0]).unwrap(),
+        Max(Some(22))
+    );
+    assert_eq!(
+        problem.evaluate(&vec![1, 0, 0, 6, 0]).unwrap(),
+        Max(Some(22))
+    );
 
     // Brute force confirms the optimum
     let solver = BruteForce::new();
-    let solution = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&solution), Max(Some(22)));
+    let solution = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(22)));
 }
diff --git a/src/unit_tests/models/set/maximum_set_packing.rs b/src/unit_tests/models/set/maximum_set_packing.rs
index 405d55d1b..9993ca2ef 100644
--- a/src/unit_tests/models/set/maximum_set_packing.rs
+++ b/src/unit_tests/models/set/maximum_set_packing.rs
@@ -1,25 +1,42 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Max;
 include!("../../jl_helpers.rs");
 
+#[test]
+fn test_maximum_set_packing_create_spec_uses_subsets_input() {
+    assert_eq!(
+        MaximumSetPackingCreateSpec::<i64>::FIELDS[0].name,
+        "subsets"
+    );
+    let problem = MaximumSetPacking::try_from(MaximumSetPackingCreateSpec {
+        subsets: vec![vec![0], vec![1]],
+        weights: vec![2, 3],
+    })
+    .unwrap();
+    assert_eq!(problem.sets(), &[vec![0], vec![1]]);
+    assert_eq!(problem.weights_ref(), &[2, 3]);
+}
+
 #[test]
 fn test_set_packing_creation() {
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![1, 2], vec![3, 4]]);
+    let problem = MaximumSetPacking::<i64>::new(vec![vec![0, 1], vec![1, 2], vec![3, 4]]);
     assert_eq!(problem.num_sets(), 3);
     assert_eq!(problem.num_variables(), 3);
 }
 
 #[test]
 fn test_set_packing_with_weights() {
-    let problem = MaximumSetPacking::with_weights(vec![vec![0, 1], vec![2, 3]], vec![5, 10]);
+    let problem =
+        MaximumSetPacking::with_weights(vec![vec![0, 1], vec![2, 3]], vec![5, 10]).unwrap();
     assert_eq!(problem.weights_ref(), &vec![5, 10]);
 }
 
 #[test]
 fn test_sets_overlap() {
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![1, 2], vec![3, 4]]);
+    let problem = MaximumSetPacking::<i64>::new(vec![vec![0, 1], vec![1, 2], vec![3, 4]]);
 
     assert!(problem.sets_overlap(0, 1)); // Share element 1
     assert!(!problem.sets_overlap(0, 2)); // No overlap
@@ -28,7 +45,7 @@ fn test_sets_overlap() {
 
 #[test]
 fn test_overlapping_pairs() {
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
+    let problem = MaximumSetPacking::<i64>::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
 
     let pairs = problem.overlapping_pairs();
     assert_eq!(pairs.len(), 2);
@@ -48,14 +65,14 @@ fn test_is_set_packing_function() {
 
 #[test]
 fn test_empty_sets() {
-    let problem = MaximumSetPacking::<i32>::new(vec![]);
+    let problem = MaximumSetPacking::<i64>::new(vec![]);
     // Empty packing is valid with size 0
-    assert_eq!(Problem::evaluate(&problem, &[]), Max(Some(0)));
+    assert_eq!(Problem::evaluate(&problem, &vec![]).unwrap(), Max(Some(0)));
 }
 
 #[test]
 fn test_get_set() {
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![2, 3]]);
+    let problem = MaximumSetPacking::<i64>::new(vec![vec![0, 1], vec![2, 3]]);
     assert_eq!(problem.get_set(0), Some(&vec![0, 1]));
     assert_eq!(problem.get_set(1), Some(&vec![2, 3]));
     assert_eq!(problem.get_set(2), None);
@@ -68,21 +85,21 @@ fn test_relationship_to_independent_set() {
     use crate::topology::SimpleGraph;
 
     let sets = vec![vec![0, 1], vec![1, 2], vec![2, 3], vec![3, 4]];
-    let sp_problem = MaximumSetPacking::<i32>::new(sets.clone());
+    let sp_problem = MaximumSetPacking::<i64>::new(sets.clone());
 
     // Build intersection graph
     let edges = sp_problem.overlapping_pairs();
     let n = sets.len();
-    let is_problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i32; n]);
+    let is_problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i64; n]);
 
     let solver = BruteForce::new();
 
-    let sp_solutions = solver.find_all_witnesses(&sp_problem);
-    let is_solutions = solver.find_all_witnesses(&is_problem);
+    let sp_solutions = solver.find_all_witnesses(&sp_problem).unwrap();
+    let is_solutions = solver.find_all_witnesses(&is_problem).unwrap();
 
     // Should have same optimal value
-    let sp_size: usize = sp_solutions[0].iter().sum();
-    let is_size: usize = is_solutions[0].iter().sum();
+    let sp_size: usize = sp_solutions[0].iter().filter(|&&selected| selected).count();
+    let is_size: usize = is_solutions[0].iter().filter(|&&selected| selected).count();
     assert_eq!(sp_size, is_size);
 }
 
@@ -98,15 +115,15 @@ fn test_jl_parity_evaluation() {
         serde_json::from_str(include_str!("../../../../tests/data/jl/setpacking.json")).unwrap();
     for instance in data["instances"].as_array().unwrap() {
         let sets = jl_parse_sets(&instance["instance"]["sets"]);
-        let weights = jl_parse_i32_vec(&instance["instance"]["weights"]);
+        let weights = jl_parse_i64_vec(&instance["instance"]["weights"]);
         let problem = if weights.iter().all(|&w| w == 1) {
-            MaximumSetPacking::<i32>::new(sets)
+            MaximumSetPacking::<i64>::new(sets)
         } else {
-            MaximumSetPacking::with_weights(sets, weights)
+            MaximumSetPacking::with_weights(sets, weights).unwrap()
         };
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config);
+            let config = jl_parse_bool_config(&eval["config"]);
+            let result = problem.evaluate(&config).unwrap();
             let jl_valid = eval["is_valid"].as_bool().unwrap();
             assert_eq!(
                 result.is_valid(),
@@ -115,7 +132,7 @@ fn test_jl_parity_evaluation() {
                 config
             );
             if jl_valid {
-                let jl_size = eval["size"].as_i64().unwrap() as i32;
+                let jl_size = eval["size"].as_i64().unwrap();
                 assert_eq!(
                     result.unwrap(),
                     jl_size,
@@ -124,9 +141,9 @@ fn test_jl_parity_evaluation() {
                 );
             }
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best: HashSet<Vec<bool>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "SetPacking best solutions mismatch");
     }
 }
@@ -134,24 +151,24 @@ fn test_jl_parity_evaluation() {
 #[test]
 fn test_is_valid_solution() {
     // Sets: {0,1}, {1,2}, {3,4}
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![1, 2], vec![3, 4]]);
+    let problem = MaximumSetPacking::<i64>::new(vec![vec![0, 1], vec![1, 2], vec![3, 4]]);
     // Valid: select sets 0 and 2 (disjoint: {0,1} and {3,4})
-    assert!(problem.is_valid_solution(&[1, 0, 1]));
+    assert!(problem.is_valid_solution(&[true, false, true]));
     // Invalid: select sets 0 and 1 (share element 1)
-    assert!(!problem.is_valid_solution(&[1, 1, 0]));
+    assert!(!problem.is_valid_solution(&[true, true, false]));
 }
 
 #[test]
-fn test_size_getters() {
+fn test_parameter_getters() {
     // Sets: {0,1}, {2,3}, {4,5} — universe is {0..6}
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![2, 3], vec![4, 5]]);
+    let problem = MaximumSetPacking::<i64>::new(vec![vec![0, 1], vec![2, 3], vec![4, 5]]);
     assert_eq!(problem.num_sets(), 3);
     assert_eq!(problem.universe_size(), 6);
 }
 
 #[test]
 fn test_universe_size_empty() {
-    let problem = MaximumSetPacking::<i32>::new(vec![]);
+    let problem = MaximumSetPacking::<i64>::new(vec![]);
     assert_eq!(problem.universe_size(), 0);
 }
 
@@ -159,13 +176,18 @@ fn test_universe_size_empty() {
 fn test_setpacking_paper_example() {
     // Paper: U={0..5}, sets {0,1},{1,2},{2,3},{3,4}, max packing {S_0,S_2}
     let problem =
-        MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![1, 2], vec![2, 3], vec![3, 4]]);
-    let config = vec![1, 0, 1, 0]; // {S_0, S_2}
-    let result = problem.evaluate(&config);
+        MaximumSetPacking::<i64>::new(vec![vec![0, 1], vec![1, 2], vec![2, 3], vec![3, 4]]);
+    let config = vec![true, false, true, false]; // {S_0, S_2}
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 2);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 2);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 2);
+}
+
+#[test]
+fn test_maximum_set_packing_rejects_non_finite_weight() {
+    assert!(MaximumSetPacking::with_weights(vec![vec![0]], vec![f64::NEG_INFINITY]).is_err());
 }
diff --git a/src/unit_tests/models/set/minimum_cardinality_key.rs b/src/unit_tests/models/set/minimum_cardinality_key.rs
index 1aeedd601..d73369de6 100644
--- a/src/unit_tests/models/set/minimum_cardinality_key.rs
+++ b/src/unit_tests/models/set/minimum_cardinality_key.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -29,23 +30,43 @@ fn test_minimum_cardinality_key_creation() {
     assert_eq!(problem.num_attributes(), 6);
     assert_eq!(problem.num_dependencies(), 4);
     assert_eq!(problem.num_variables(), 6);
-    assert_eq!(problem.dims(), vec![2; 6]);
+    assert_eq!(problem.dimensions(), vec![2; 6]);
 }
 
 #[test]
 fn test_minimum_cardinality_key_evaluation_key() {
     let problem = instance1();
     // K={0,1}: closure under FDs reaches all 6 attributes, so it is a key of size 2.
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0, 0, 0]), Min(Some(2)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, false, false, false, false])
+            .unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
 fn test_minimum_cardinality_key_evaluation_non_key() {
     let problem = instance2();
     // No 2-element subset is a key for instance 2.
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0, 0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[1, 0, 1, 0, 0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 0, 0, 1, 1, 0]), Min(None));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, false, false, false, false])
+            .unwrap(),
+        Min(None)
+    );
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, false, true, false, false, false])
+            .unwrap(),
+        Min(None)
+    );
+    assert_eq!(
+        problem
+            .evaluate(&vec![false, false, false, true, true, false])
+            .unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -53,7 +74,12 @@ fn test_minimum_cardinality_key_superset_key() {
     let problem = instance1();
     // K={0,1,2}: closure reaches all attributes. It IS a key (even though not minimal).
     // The optimization model should accept it with cardinality 3.
-    assert_eq!(problem.evaluate(&[1, 1, 1, 0, 0, 0]), Min(Some(3)));
+    assert_eq!(
+        problem
+            .evaluate(&vec![true, true, true, false, false, false])
+            .unwrap(),
+        Min(Some(3))
+    );
 }
 
 #[test]
@@ -62,12 +88,13 @@ fn test_minimum_cardinality_key_solver() {
     let solver = BruteForce::new();
 
     // Aggregate solve should find the minimum key cardinality = 2.
-    let value = solver.solve(&problem);
+    let value_solution = solver.solve(&problem).unwrap().unwrap();
+    let value = problem.evaluate(&value_solution).unwrap();
     assert_eq!(value, Min(Some(2)));
 
     // Witness should be {0,1} which is the unique minimum key.
-    let witness = solver.find_witness(&problem).unwrap();
-    assert_eq!(witness, vec![1, 1, 0, 0, 0, 0]);
+    let witness = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(witness, vec![true, true, false, false, false, false]);
 }
 
 #[test]
@@ -85,34 +112,53 @@ fn test_minimum_cardinality_key_serialization() {
 fn test_minimum_cardinality_key_invalid_config() {
     let problem = instance1();
     // Wrong length.
-    assert_eq!(problem.evaluate(&[1, 1, 0, 0, 0]), Min(None));
+    assert!(matches!(
+        problem.evaluate(&vec![true, true, false, false, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Value > 1.
-    assert_eq!(problem.evaluate(&[2, 1, 0, 0, 0, 0]), Min(None));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([2, true, false, false, false, false])
+    )
+    .is_err());
 }
 
 #[test]
 fn test_minimum_cardinality_key_empty_deps() {
     // No FDs: closure(K) = K. Only K = {0,1,2} determines all attributes.
     let problem = MinimumCardinalityKey::new(3, vec![]);
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Min(Some(3)));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true]).unwrap(),
+        Min(Some(3))
+    );
     // Any proper subset fails (not a key).
-    assert_eq!(problem.evaluate(&[1, 1, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[1, 0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, false]).unwrap(),
+        Min(None)
+    );
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false]).unwrap(),
+        Min(None)
+    );
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false]).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
 fn test_minimum_cardinality_key_empty_key_candidate() {
     let problem = MinimumCardinalityKey::new(1, vec![(vec![], vec![0])]);
     // Empty set is a key (closure of {} includes 0 via the FD {} -> {0}).
-    assert_eq!(problem.evaluate(&[0]), Min(Some(0)));
+    assert_eq!(problem.evaluate(&vec![false]).unwrap(), Min(Some(0)));
     // Selecting attr 0 is also a key, but with cardinality 1.
-    assert_eq!(problem.evaluate(&[1]), Min(Some(1)));
+    assert_eq!(problem.evaluate(&vec![true]).unwrap(), Min(Some(1)));
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
+    let witness = solver.solve(&problem).unwrap().unwrap();
     // Minimum key is the empty set.
-    assert_eq!(witness, vec![0]);
+    assert_eq!(witness, vec![false]);
 }
 
 #[test]
@@ -124,10 +170,10 @@ fn test_minimum_cardinality_key_panics_on_invalid_index() {
 #[test]
 fn test_minimum_cardinality_key_paper_example() {
     let problem = instance1();
-    let solution = vec![1, 1, 0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&solution), Min(Some(2)));
+    let solution = vec![true, true, false, false, false, false];
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(2)));
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem).unwrap();
+    let witness = solver.solve(&problem).unwrap().unwrap();
     assert_eq!(witness, solution);
 }
diff --git a/src/unit_tests/models/set/minimum_hitting_set.rs b/src/unit_tests/models/set/minimum_hitting_set.rs
index 576f39b44..2b7a59b5f 100644
--- a/src/unit_tests/models/set/minimum_hitting_set.rs
+++ b/src/unit_tests/models/set/minimum_hitting_set.rs
@@ -1,6 +1,6 @@
 use super::*;
-use crate::registry::declared_size_fields;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 use std::collections::HashSet;
@@ -20,8 +20,19 @@ fn issue_example_problem() -> MinimumHittingSet {
     )
 }
 
-fn issue_example_config() -> Vec<usize> {
-    vec![0, 1, 0, 1, 1, 0]
+#[test]
+fn test_minimum_hitting_set_create_spec_uses_subsets_input() {
+    assert_eq!(MinimumHittingSetCreateSpec::FIELDS[1].name, "subsets");
+    let problem = MinimumHittingSet::try_from(MinimumHittingSetCreateSpec {
+        universe_size: 3,
+        subsets: vec![vec![0, 2]],
+    })
+    .unwrap();
+    assert_eq!(problem.sets(), &[vec![0, 2]]);
+}
+
+fn issue_example_config() -> Vec<bool> {
+    vec![false, true, false, true, true, false]
 }
 
 #[test]
@@ -31,7 +42,7 @@ fn test_minimum_hitting_set_creation_accessors_and_dimensions() {
     assert_eq!(problem.universe_size(), 4);
     assert_eq!(problem.num_sets(), 2);
     assert_eq!(problem.num_variables(), 4);
-    assert_eq!(problem.dims(), vec![2; 4]);
+    assert_eq!(problem.dimensions(), vec![2; 4]);
     assert_eq!(problem.sets(), &[vec![1, 2], vec![3]]);
     assert_eq!(problem.get_set(0), Some(&vec![1, 2]));
     assert_eq!(problem.get_set(1), Some(&vec![3]));
@@ -42,22 +53,39 @@ fn test_minimum_hitting_set_creation_accessors_and_dimensions() {
 fn test_minimum_hitting_set_evaluate_valid_and_invalid() {
     let problem = MinimumHittingSet::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
 
-    assert_eq!(problem.selected_elements(&[0, 1, 0, 1]), Some(vec![1, 3]));
-    assert_eq!(problem.selected_elements(&[0, 2, 0, 1]), None);
-    assert_eq!(problem.evaluate(&[0, 1, 0, 1]), Min(Some(2)));
-    assert_eq!(problem.evaluate(&[1, 0, 0, 0]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 2, 0, 1]), Min(None));
-    assert!(problem.is_valid_solution(&[0, 1, 0, 1]));
-    assert!(!problem.is_valid_solution(&[1, 0, 0, 0]));
-    assert!(!problem.is_valid_solution(&[0, 2, 0, 1]));
+    assert_eq!(
+        problem.selected_elements(&[false, true, false, true]),
+        Some(vec![1, 3])
+    );
+    assert_eq!(
+        problem.evaluate(&vec![false, true, false, true]).unwrap(),
+        Min(Some(2))
+    );
+    assert_eq!(
+        problem.evaluate(&vec![true, false, false, false]).unwrap(),
+        Min(None)
+    );
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([false, 2, false, true])
+    )
+    .is_err());
+    assert!(problem.is_valid_solution(&[false, true, false, true]));
+    assert!(!problem.is_valid_solution(&[true, false, false, false]));
 }
 
 #[test]
 fn test_minimum_hitting_set_empty_set_is_always_invalid() {
     let problem = MinimumHittingSet::new(3, vec![vec![0, 1], vec![]]);
 
-    assert_eq!(problem.evaluate(&[1, 1, 1]), Min(None));
-    assert_eq!(problem.evaluate(&[0, 0, 0]), Min(None));
+    assert_eq!(
+        problem.evaluate(&vec![true, true, true]).unwrap(),
+        Min(None)
+    );
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false]).unwrap(),
+        Min(None)
+    );
 }
 
 #[test]
@@ -78,15 +106,15 @@ fn test_minimum_hitting_set_bruteforce_optimum_issue_example() {
     let problem = issue_example_problem();
     let solver = BruteForce::new();
 
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best), Min(Some(3)));
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap(), Min(Some(3)));
 
-    let best_solutions = solver.find_all_witnesses(&problem);
-    let best_solution_set: HashSet<Vec<usize>> = best_solutions.iter().cloned().collect();
+    let best_solutions = solver.find_all_witnesses(&problem).unwrap();
+    let best_solution_set: HashSet<Vec<bool>> = best_solutions.iter().cloned().collect();
     assert!(best_solution_set.contains(&issue_example_config()));
     assert!(best_solutions
         .iter()
-        .all(|config| problem.evaluate(config) == Min(Some(3))));
+        .all(|config| problem.evaluate(config).unwrap() == Min(Some(3))));
 }
 
 #[test]
@@ -99,8 +127,10 @@ fn test_minimum_hitting_set_serialization_round_trip() {
     assert_eq!(deserialized.num_sets(), problem.num_sets());
     assert_eq!(deserialized.sets(), problem.sets());
     assert_eq!(
-        deserialized.evaluate(&[1, 1, 0, 0]),
-        problem.evaluate(&[1, 1, 0, 0])
+        deserialized
+            .evaluate(&vec![true, true, false, false])
+            .unwrap(),
+        problem.evaluate(&vec![true, true, false, false]).unwrap()
     );
 }
 
@@ -108,13 +138,17 @@ fn test_minimum_hitting_set_serialization_round_trip() {
 fn test_minimum_hitting_set_paper_example_consistency() {
     let problem = issue_example_problem();
 
-    assert_eq!(problem.evaluate(&issue_example_config()), Min(Some(3)));
+    assert_eq!(
+        problem.evaluate(&issue_example_config()).unwrap(),
+        Min(Some(3))
+    );
 }
 
 #[test]
-fn test_minimum_hitting_set_declares_problem_size_fields() {
-    let fields: HashSet<&'static str> = declared_size_fields("MinimumHittingSet")
-        .into_iter()
+fn test_minimum_hitting_set_declares_problem_parameters() {
+    let fields: HashSet<&'static str> = MinimumHittingSet::parameter_names()
+        .iter()
+        .copied()
         .collect();
     assert_eq!(fields, HashSet::from(["num_sets", "universe_size"]),);
 }
@@ -127,7 +161,10 @@ fn test_minimum_hitting_set_canonical_example_spec() {
     let spec = &specs[0];
 
     assert_eq!(spec.id, "minimum_hitting_set");
-    assert_eq!(spec.optimal_config, issue_example_config());
+    assert_eq!(
+        spec.optimal_config,
+        serde_json::json!(issue_example_config())
+    );
     assert_eq!(spec.optimal_value, serde_json::json!(3));
 
     let problem: MinimumHittingSet =
@@ -136,6 +173,6 @@ fn test_minimum_hitting_set_canonical_example_spec() {
     assert_eq!(problem.sets().len(), 7);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best), Min(Some(3)));
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap(), Min(Some(3)));
 }
diff --git a/src/unit_tests/models/set/minimum_set_covering.rs b/src/unit_tests/models/set/minimum_set_covering.rs
index c218fc56d..299647f7c 100644
--- a/src/unit_tests/models/set/minimum_set_covering.rs
+++ b/src/unit_tests/models/set/minimum_set_covering.rs
@@ -1,12 +1,26 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 include!("../../jl_helpers.rs");
 
+#[test]
+fn test_minimum_set_covering_create_spec_uses_subsets_input() {
+    assert_eq!(MinimumSetCoveringCreateSpec::FIELDS[1].name, "subsets");
+    let problem = MinimumSetCovering::try_from(MinimumSetCoveringCreateSpec {
+        universe_size: 2,
+        subsets: vec![vec![0], vec![1]],
+        weights: vec![2, 3],
+    })
+    .unwrap();
+    assert_eq!(problem.sets(), &[vec![0], vec![1]]);
+    assert_eq!(problem.weights_ref(), &[2, 3]);
+}
+
 #[test]
 fn test_set_covering_creation() {
-    let problem = MinimumSetCovering::<i32>::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
+    let problem = MinimumSetCovering::<i64>::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
     assert_eq!(problem.universe_size(), 4);
     assert_eq!(problem.num_sets(), 3);
     assert_eq!(problem.num_variables(), 3);
@@ -20,14 +34,14 @@ fn test_set_covering_with_weights() {
 
 #[test]
 fn test_covered_elements() {
-    let problem = MinimumSetCovering::<i32>::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
+    let problem = MinimumSetCovering::<i64>::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
 
-    let covered = problem.covered_elements(&[1, 0, 0]);
+    let covered = problem.covered_elements(&[true, false, false]);
     assert!(covered.contains(&0));
     assert!(covered.contains(&1));
     assert!(!covered.contains(&2));
 
-    let covered = problem.covered_elements(&[1, 0, 1]);
+    let covered = problem.covered_elements(&[true, false, true]);
     assert!(covered.contains(&0));
     assert!(covered.contains(&1));
     assert!(covered.contains(&2));
@@ -46,7 +60,7 @@ fn test_is_set_cover_function() {
 
 #[test]
 fn test_get_set() {
-    let problem = MinimumSetCovering::<i32>::new(4, vec![vec![0, 1], vec![2, 3]]);
+    let problem = MinimumSetCovering::<i64>::new(4, vec![vec![0, 1], vec![2, 3]]);
     assert_eq!(problem.get_set(0), Some(&vec![0, 1]));
     assert_eq!(problem.get_set(1), Some(&vec![2, 3]));
     assert_eq!(problem.get_set(2), None);
@@ -54,9 +68,9 @@ fn test_get_set() {
 
 #[test]
 fn test_empty_universe() {
-    let problem = MinimumSetCovering::<i32>::new(0, vec![]);
+    let problem = MinimumSetCovering::<i64>::new(0, vec![]);
     // Empty universe is trivially covered with size 0
-    assert_eq!(Problem::evaluate(&problem, &[]), Min(Some(0)));
+    assert_eq!(Problem::evaluate(&problem, &vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -72,11 +86,11 @@ fn test_jl_parity_evaluation() {
     for instance in data["instances"].as_array().unwrap() {
         let universe_size = instance["instance"]["universe_size"].as_u64().unwrap() as usize;
         let sets = jl_parse_sets(&instance["instance"]["sets"]);
-        let weights = jl_parse_i32_vec(&instance["instance"]["weights"]);
-        let problem = MinimumSetCovering::<i32>::with_weights(universe_size, sets, weights);
+        let weights = jl_parse_i64_vec(&instance["instance"]["weights"]);
+        let problem = MinimumSetCovering::<i64>::with_weights(universe_size, sets, weights);
         for eval in instance["evaluations"].as_array().unwrap() {
-            let config = jl_parse_config(&eval["config"]);
-            let result = problem.evaluate(&config);
+            let config = jl_parse_bool_config(&eval["config"]);
+            let result = problem.evaluate(&config).unwrap();
             let jl_valid = eval["is_valid"].as_bool().unwrap();
             assert_eq!(
                 result.is_valid(),
@@ -85,7 +99,7 @@ fn test_jl_parity_evaluation() {
                 config
             );
             if jl_valid {
-                let jl_size = eval["size"].as_i64().unwrap() as i32;
+                let jl_size = eval["size"].as_i64().unwrap();
                 assert_eq!(
                     result.unwrap(),
                     jl_size,
@@ -94,9 +108,9 @@ fn test_jl_parity_evaluation() {
                 );
             }
         }
-        let best = BruteForce::new().find_all_witnesses(&problem);
-        let jl_best = jl_parse_configs_set(&instance["best_solutions"]);
-        let rust_best: HashSet<Vec<usize>> = best.into_iter().collect();
+        let best = BruteForce::new().find_all_witnesses(&problem).unwrap();
+        let jl_best = jl_parse_bool_configs_set(&instance["best_solutions"]);
+        let rust_best: HashSet<Vec<bool>> = best.into_iter().collect();
         assert_eq!(rust_best, jl_best, "SetCovering best solutions mismatch");
     }
 }
@@ -104,23 +118,23 @@ fn test_jl_parity_evaluation() {
 #[test]
 fn test_is_valid_solution() {
     // Universe: {0,1,2,3}, Sets: {0,1}, {1,2}, {2,3}
-    let problem = MinimumSetCovering::<i32>::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
+    let problem = MinimumSetCovering::<i64>::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
     // Valid: all sets selected covers {0,1,2,3}
-    assert!(problem.is_valid_solution(&[1, 1, 1]));
+    assert!(problem.is_valid_solution(&[true, true, true]));
     // Invalid: only set 1 ({1,2}) doesn't cover 0 and 3
-    assert!(!problem.is_valid_solution(&[0, 1, 0]));
+    assert!(!problem.is_valid_solution(&[false, true, false]));
 }
 
 #[test]
 fn test_setcovering_paper_example() {
     // Paper: U=5, sets {0,1,2},{1,3},{2,3,4}, min cover {S_0,S_2}, weight=2
-    let problem = MinimumSetCovering::<i32>::new(5, vec![vec![0, 1, 2], vec![1, 3], vec![2, 3, 4]]);
-    let config = vec![1, 0, 1]; // {S_0, S_2} covers all of {0,1,2,3,4}
-    let result = problem.evaluate(&config);
+    let problem = MinimumSetCovering::<i64>::new(5, vec![vec![0, 1, 2], vec![1, 3], vec![2, 3, 4]]);
+    let config = vec![true, false, true]; // {S_0, S_2} covers all of {0,1,2,3,4}
+    let result = problem.evaluate(&config).unwrap();
     assert!(result.is_valid());
     assert_eq!(result.unwrap(), 2);
 
     let solver = BruteForce::new();
-    let best = solver.find_witness(&problem).unwrap();
-    assert_eq!(problem.evaluate(&best).unwrap(), 2);
+    let best = solver.solve(&problem).unwrap().unwrap();
+    assert_eq!(problem.evaluate(&best).unwrap().unwrap(), 2);
 }
diff --git a/src/unit_tests/models/set/prime_attribute_name.rs b/src/unit_tests/models/set/prime_attribute_name.rs
index b8999597c..e9550959a 100644
--- a/src/unit_tests/models/set/prime_attribute_name.rs
+++ b/src/unit_tests/models/set/prime_attribute_name.rs
@@ -1,7 +1,23 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
+#[test]
+fn test_prime_attribute_create_spec_uses_universe_size_input() {
+    assert_eq!(
+        PrimeAttributeNameCreateSpec::FIELDS[0].name,
+        "universe_size"
+    );
+    let problem = PrimeAttributeName::try_from(PrimeAttributeNameCreateSpec {
+        universe_size: 2,
+        dependencies: vec![(vec![0], vec![1])],
+        query_attribute: 0,
+    })
+    .unwrap();
+    assert_eq!(problem.num_attributes(), 2);
+}
+
 /// Helper: Issue Example 1 — 6 attributes, 3 FDs, query=3
 /// Candidate keys: {0,1}, {2,3}, {0,3} — attribute 3 is prime
 fn example1() -> PrimeAttributeName {
@@ -29,7 +45,7 @@ fn test_prime_attribute_name_creation() {
     assert_eq!(problem.num_dependencies(), 3);
     assert_eq!(problem.query_attribute(), 3);
     assert_eq!(problem.num_variables(), 6);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2, 2, 2]);
     assert_eq!(problem.dependencies().len(), 3);
 }
 
@@ -37,7 +53,9 @@ fn test_prime_attribute_name_creation() {
 fn test_prime_attribute_name_evaluate_yes() {
     let problem = example1();
     // {2, 3} is a candidate key containing attribute 3
-    assert!(problem.evaluate(&[0, 0, 1, 1, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![false, false, true, true, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -45,9 +63,13 @@ fn test_prime_attribute_name_evaluate_no() {
     let problem = example2();
     // Only key is {0,1} which doesn't contain attribute 3
     // Config selecting {0,1}: this is a candidate key but doesn't contain query=3
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, false, false, false, false])
+        .unwrap());
     // Config selecting {2,3}: not a superkey since closure({2,3}) != A
-    assert!(!problem.evaluate(&[0, 0, 1, 1, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![false, false, true, true, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -55,52 +77,70 @@ fn test_prime_attribute_name_evaluate_superkey_not_minimal() {
     let problem = example1();
     // {1,2,3} has closure = A (since {2,3}->rest), but it's not minimal
     // because {2,3} alone is also a superkey
-    assert!(!problem.evaluate(&[0, 1, 1, 1, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![false, true, true, true, false, false])
+        .unwrap());
 }
 
 #[test]
 fn test_prime_attribute_name_evaluate_not_superkey() {
     let problem = example1();
     // {0} alone: closure({0}) = {0}, not all of A
-    assert!(!problem.evaluate(&[1, 0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, false, false, false, false, false])
+        .unwrap());
 }
 
 #[test]
 fn test_prime_attribute_name_evaluate_query_not_in_k() {
     let problem = example1();
     // {0,1} is a candidate key but doesn't contain attribute 3
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, false, false, false, false])
+        .unwrap());
 }
 
 #[test]
 fn test_prime_attribute_name_evaluate_all_selected() {
     let problem = example1();
     // All attributes selected: superkey but not minimal
-    assert!(!problem.evaluate(&[1, 1, 1, 1, 1, 1]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, true, true, true])
+        .unwrap());
 }
 
 #[test]
 fn test_prime_attribute_name_evaluate_invalid_config() {
     let problem = example1();
     // Wrong length
-    assert!(!problem.evaluate(&[0, 0, 1]));
+    assert!(matches!(
+        problem.evaluate(&vec![false, false, true]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
     // Non-binary value
-    assert!(!problem.evaluate(&[0, 0, 1, 2, 0, 0]));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([false, false, true, 2, false, false])
+    )
+    .is_err());
 }
 
 #[test]
 fn test_prime_attribute_name_solver() {
     let problem = example1();
     let solver = BruteForce::new();
-    let mut solutions = solver.find_all_witnesses(&problem);
+    let mut solutions = solver.find_all_witnesses(&problem).unwrap();
     solutions.sort();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
     assert_eq!(
         solutions,
-        vec![vec![0, 0, 1, 1, 0, 0], vec![1, 0, 0, 1, 0, 0]]
+        vec![
+            vec![false, false, true, true, false, false],
+            vec![true, false, false, true, false, false]
+        ]
     );
 }
 
@@ -108,7 +148,7 @@ fn test_prime_attribute_name_solver() {
 fn test_prime_attribute_name_no_solution() {
     let problem = example2();
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(solutions.is_empty());
 }
 
diff --git a/src/unit_tests/models/set/rooted_tree_storage_assignment.rs b/src/unit_tests/models/set/rooted_tree_storage_assignment.rs
index def31e1ea..944ef4500 100644
--- a/src/unit_tests/models/set/rooted_tree_storage_assignment.rs
+++ b/src/unit_tests/models/set/rooted_tree_storage_assignment.rs
@@ -1,8 +1,9 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
-fn yes_instance(bound: usize) -> RootedTreeStorageAssignment {
+fn yes_instance(bound: i64) -> RootedTreeStorageAssignment {
     RootedTreeStorageAssignment::new(
         5,
         vec![vec![0, 2], vec![1, 3], vec![0, 4], vec![2, 4]],
@@ -20,29 +21,35 @@ fn test_rooted_tree_storage_assignment_creation() {
         problem.subsets(),
         &[vec![0, 2], vec![1, 3], vec![0, 4], vec![2, 4]]
     );
-    assert_eq!(problem.dims(), vec![5; 5]);
+    assert_eq!(problem.dimensions(), vec![5; 5]);
 }
 
 #[test]
 fn test_rooted_tree_storage_assignment_evaluate_yes_instance() {
     let problem = yes_instance(1);
-    assert!(problem.evaluate(&[0, 0, 0, 1, 2]));
+    assert!(problem.evaluate(&vec![0, 0, 0, 1, 2]).unwrap());
 }
 
 #[test]
 fn test_rooted_tree_storage_assignment_rejects_invalid_tree_configs() {
     let problem = yes_instance(1);
 
-    assert!(!problem.evaluate(&[0, 0, 1, 2]));
-    assert!(!problem.evaluate(&[0, 0, 0, 1, 5]));
-    assert!(!problem.evaluate(&[0, 1, 2, 3, 4]));
-    assert!(!problem.evaluate(&[1, 0, 0, 1, 2]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 0, 0, 1, 5]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
+    assert!(!problem.evaluate(&vec![0, 1, 2, 3, 4]).unwrap());
+    assert!(!problem.evaluate(&vec![1, 0, 0, 1, 2]).unwrap());
 }
 
 #[test]
 fn test_rooted_tree_storage_assignment_solver_finds_known_solution() {
     let problem = yes_instance(1);
-    let solutions = BruteForce::new().find_all_witnesses(&problem);
+    let solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     assert!(solutions.contains(&vec![0, 0, 0, 1, 2]));
 }
@@ -50,7 +57,7 @@ fn test_rooted_tree_storage_assignment_solver_finds_known_solution() {
 #[test]
 fn test_rooted_tree_storage_assignment_no_instance() {
     let problem = yes_instance(0);
-    let solutions = BruteForce::new().find_all_witnesses(&problem);
+    let solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert!(solutions.is_empty());
 }
 
@@ -69,8 +76,8 @@ fn test_rooted_tree_storage_assignment_paper_example() {
     let problem = yes_instance(1);
     let config = vec![0, 0, 0, 1, 2];
 
-    assert!(problem.evaluate(&config));
+    assert!(problem.evaluate(&config).unwrap());
 
-    let solutions = BruteForce::new().find_all_witnesses(&problem);
+    let solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
     assert!(solutions.contains(&config));
 }
diff --git a/src/unit_tests/models/set/set_basis.rs b/src/unit_tests/models/set/set_basis.rs
index ff4bb3a27..a1c0aabdd 100644
--- a/src/unit_tests/models/set/set_basis.rs
+++ b/src/unit_tests/models/set/set_basis.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use std::collections::HashSet;
 
@@ -11,8 +12,24 @@ fn issue_example_problem(k: usize) -> SetBasis {
     )
 }
 
-fn canonical_solution() -> Vec<usize> {
-    vec![1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0]
+#[test]
+fn test_set_basis_create_spec_uses_subsets_input() {
+    assert_eq!(SetBasisCreateSpec::FIELDS[1].name, "subsets");
+    let problem = SetBasis::try_from(SetBasisCreateSpec {
+        universe_size: 3,
+        subsets: vec![vec![0, 2]],
+        k: 1,
+    })
+    .unwrap();
+    assert_eq!(problem.collection(), &[vec![0, 2]]);
+}
+
+fn canonical_solution() -> Vec<Vec<bool>> {
+    vec![
+        vec![true, false, false, false],
+        vec![false, true, false, false],
+        vec![false, false, true, false],
+    ]
 }
 
 #[test]
@@ -22,7 +39,7 @@ fn test_set_basis_creation() {
     assert_eq!(problem.num_sets(), 4);
     assert_eq!(problem.basis_size(), 3);
     assert_eq!(problem.num_variables(), 12);
-    assert_eq!(problem.dims(), vec![2; 12]);
+    assert_eq!(problem.dimensions(), vec![2; 12]);
     assert_eq!(problem.get_set(0), Some(&vec![0, 1]));
     assert_eq!(problem.get_set(4), None);
 }
@@ -31,33 +48,44 @@ fn test_set_basis_creation() {
 fn test_set_basis_evaluation() {
     let problem = issue_example_problem(3);
 
-    assert!(problem.evaluate(&canonical_solution()));
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]));
+    assert!(problem.evaluate(&canonical_solution()).unwrap());
+    assert!(!problem
+        .evaluate(&vec![
+            vec![true, true, false, false],
+            vec![false; 4],
+            vec![false, false, true, false],
+        ])
+        .unwrap());
 }
 
 #[test]
 fn test_set_basis_no_solution_for_k_two() {
     let problem = issue_example_problem(2);
 
-    assert!(!problem.evaluate(&[1, 1, 0, 0, 0, 0, 1, 0]));
+    assert!(!problem
+        .evaluate(&vec![
+            vec![true, true, false, false],
+            vec![false, false, true, false],
+        ])
+        .unwrap());
 
     let solver = BruteForce::new();
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+    assert!(solver.find_all_witnesses(&problem).unwrap().is_empty());
 }
 
 #[test]
 fn test_set_basis_solver() {
     let problem = issue_example_problem(3);
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
-    let solution_set: HashSet<Vec<usize>> = solutions.iter().cloned().collect();
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
+    let solution_set: HashSet<Vec<Vec<bool>>> = solutions.iter().cloned().collect();
 
     assert_eq!(solutions.len(), 12);
     assert_eq!(solution_set.len(), 12);
     assert!(solution_set.contains(&canonical_solution()));
     assert!(solutions
         .iter()
-        .all(|solution| problem.evaluate(solution).0));
+        .all(|solution| problem.evaluate(solution).unwrap().0));
 }
 
 #[test]
@@ -77,26 +105,29 @@ fn test_set_basis_paper_example() {
     let problem = issue_example_problem(3);
     let solution = canonical_solution();
 
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 12);
 }
 
 #[test]
 fn test_set_basis_invalid_config_values() {
     let problem = issue_example_problem(3);
-    let mut invalid = canonical_solution();
-    invalid[0] = 2;
-    assert!(!problem.evaluate(&invalid));
+    assert!(crate::registry::DynProblem::evaluate_dyn(
+        &problem,
+        &serde_json::json!([[2, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0]])
+    )
+    .is_err());
 }
 
 #[test]
 fn test_set_basis_rejects_wrong_config_length() {
     let problem = issue_example_problem(3);
-    let solution = canonical_solution();
-    assert!(!problem.evaluate(solution.get(..11).unwrap()));
+    let mut solution = canonical_solution();
+    solution.pop();
+    assert!(problem.evaluate(&solution).is_err());
 }
 
 #[test]
@@ -108,7 +139,9 @@ fn test_set_basis_deserialized_invalid_target_returns_false() {
     }))
     .unwrap();
 
-    assert!(!problem.evaluate(&[1, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![vec![true, false, false, false]])
+        .unwrap());
 }
 
 #[test]
@@ -120,7 +153,7 @@ fn test_set_basis_deserialized_unsorted_target_still_evaluates_correctly() {
     }))
     .unwrap();
 
-    assert!(problem.evaluate(&[1, 1]));
+    assert!(problem.evaluate(&vec![vec![true, true]]).unwrap());
 }
 
 #[test]
@@ -136,30 +169,30 @@ fn test_set_basis_basis_not_subset_of_target() {
     // so it should not be used, and the target cannot be covered.
     let problem = SetBasis::new(3, vec![vec![0, 1]], 1);
     // Config encodes basis set {0, 2}: bits [1, 0, 1]
-    assert!(!problem.evaluate(&[1, 0, 1]));
+    assert!(!problem.evaluate(&vec![vec![true, false, true]]).unwrap());
 }
 
 #[test]
 fn test_set_basis_is_valid_solution() {
     let problem = issue_example_problem(3);
-    assert!(problem.is_valid_solution(&canonical_solution()));
-    assert!(!problem.is_valid_solution(&[0; 12]));
+    assert!(problem.is_valid_solution(&canonical_solution()).unwrap());
+    assert!(!problem.is_valid_solution(&vec![vec![false; 4]; 3]).unwrap());
 }
 
 #[test]
 fn test_set_basis_k_zero_empty_collection() {
     // k = 0 with empty collection: trivially satisfiable (no targets to cover).
     let problem = SetBasis::new(3, vec![], 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
 fn test_set_basis_k_zero_nonempty_collection() {
     // k = 0 with non-empty collection: impossible (no basis sets to cover targets).
     let problem = SetBasis::new(3, vec![vec![0, 1]], 0);
-    assert_eq!(problem.dims(), Vec::<usize>::new());
-    assert!(!problem.evaluate(&[]));
+    assert_eq!(problem.dimensions(), Vec::<usize>::new());
+    assert!(!problem.evaluate(&vec![]).unwrap());
 }
 
 #[test]
@@ -169,6 +202,6 @@ fn test_set_basis_empty_collection_with_k_positive() {
     assert_eq!(problem.basis_size(), 2);
     assert_eq!(problem.num_sets(), 0);
     // Any valid config of length k * universe_size = 4 should satisfy.
-    assert!(problem.evaluate(&[0, 0, 0, 0]));
-    assert!(problem.evaluate(&[1, 1, 1, 1]));
+    assert!(problem.evaluate(&vec![vec![false; 2]; 2]).unwrap());
+    assert!(problem.evaluate(&vec![vec![true; 2]; 2]).unwrap());
 }
diff --git a/src/unit_tests/models/set/set_splitting.rs b/src/unit_tests/models/set/set_splitting.rs
index a69059838..476e97af4 100644
--- a/src/unit_tests/models/set/set_splitting.rs
+++ b/src/unit_tests/models/set/set_splitting.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Or;
 
@@ -37,14 +38,20 @@ fn test_set_splitting_evaluate_valid() {
     // Universe {0,1,2,3}, one subset {0,1,2,3}
     // config [0,0,1,1] → subset has {0,1} in S1 and {2,3} in S2 → split
     let problem = SetSplitting::new(4, vec![vec![0, 1, 2, 3]]);
-    assert_eq!(problem.evaluate(&[0, 0, 1, 1]), Or(true));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, true, true]).unwrap(),
+        Or(true)
+    );
 }
 
 #[test]
 fn test_set_splitting_evaluate_monochromatic() {
     // All elements colored 0 — subset is entirely in S1 → not split
     let problem = SetSplitting::new(4, vec![vec![0, 1, 2]]);
-    assert_eq!(problem.evaluate(&[0, 0, 0, 0]), Or(false));
+    assert_eq!(
+        problem.evaluate(&vec![false, false, false, false]).unwrap(),
+        Or(false)
+    );
 }
 
 #[test]
@@ -55,19 +62,23 @@ fn test_set_splitting_evaluate_multiple_subsets() {
         vec![vec![0, 1, 2], vec![2, 3, 4], vec![0, 4, 5], vec![1, 3, 5]],
     );
     // config [1,0,1,0,0,1]: S1={1,3,4}, S2={0,2,5}
-    let config = vec![1, 0, 1, 0, 0, 1];
-    assert_eq!(problem.evaluate(&config), Or(true));
+    let config = vec![true, false, true, false, false, true];
+    assert_eq!(problem.evaluate(&config).unwrap(), Or(true));
 
     // All 0: every subset is monochromatic
-    let all_zero = vec![0, 0, 0, 0, 0, 0];
-    assert_eq!(problem.evaluate(&all_zero), Or(false));
+    let all_zero = vec![false, false, false, false, false, false];
+    assert_eq!(problem.evaluate(&all_zero).unwrap(), Or(false));
 }
 
 #[test]
 fn test_set_splitting_is_valid_solution() {
     let problem = SetSplitting::new(4, vec![vec![0, 1], vec![2, 3]]);
-    assert!(problem.is_valid_solution(&[0, 1, 0, 1]));
-    assert!(!problem.is_valid_solution(&[0, 0, 0, 0]));
+    assert!(problem
+        .is_valid_solution(&[false, true, false, true])
+        .unwrap());
+    assert!(!problem
+        .is_valid_solution(&[false, false, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -77,10 +88,10 @@ fn test_set_splitting_brute_force_feasible() {
         vec![vec![0, 1, 2], vec![2, 3, 4], vec![0, 4, 5], vec![1, 3, 5]],
     );
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
     let w = witness.unwrap();
-    assert_eq!(problem.evaluate(&w), Or(true));
+    assert_eq!(problem.evaluate(&w).unwrap(), Or(true));
 }
 
 #[test]
@@ -95,7 +106,7 @@ fn test_set_splitting_brute_force_infeasible() {
     // config [0]: elem 0 → S1. subset needs both colors but only has elem 0 twice → impossible.
     let problem = SetSplitting::new(1, vec![vec![0, 0]]);
     let solver = BruteForce::new();
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(
         witness.is_none(),
         "single-element universe cannot split {{0,0}}"
@@ -116,12 +127,12 @@ fn test_set_splitting_serialization() {
 fn test_set_splitting_try_new_invalid_element() {
     let result = SetSplitting::try_new(3, vec![vec![0, 5]]);
     assert!(result.is_err());
-    assert!(result.unwrap_err().contains("outside universe"));
+    assert!(result.unwrap_err().to_string().contains("outside universe"));
 }
 
 #[test]
 fn test_set_splitting_try_new_too_small_subset() {
     let result = SetSplitting::try_new(3, vec![vec![0]]);
     assert!(result.is_err());
-    assert!(result.unwrap_err().contains("at least 2"));
+    assert!(result.unwrap_err().to_string().contains("at least 2"));
 }
diff --git a/src/unit_tests/models/set/three_dimensional_matching.rs b/src/unit_tests/models/set/three_dimensional_matching.rs
index 22b15de36..3ef8b0df4 100644
--- a/src/unit_tests/models/set/three_dimensional_matching.rs
+++ b/src/unit_tests/models/set/three_dimensional_matching.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -11,7 +12,7 @@ fn test_three_dimensional_matching_creation() {
     assert_eq!(problem.universe_size(), 3);
     assert_eq!(problem.num_triples(), 5);
     assert_eq!(problem.num_variables(), 5);
-    assert_eq!(problem.dims(), vec![2, 2, 2, 2, 2]);
+    assert_eq!(problem.dimensions(), vec![2, 2, 2, 2, 2]);
 }
 
 #[test]
@@ -24,22 +25,34 @@ fn test_three_dimensional_matching_evaluation() {
     );
 
     // T0, T1, T2: W={0,1,2} distinct, X={1,0,2} distinct, Y={2,1,0} distinct -> valid
-    assert!(problem.evaluate(&[1, 1, 1, 0, 0]));
+    assert!(problem
+        .evaluate(&vec![true, true, true, false, false])
+        .unwrap());
 
     // T0, T3: both have w=0 -> invalid (also only 2 selected, need 3)
-    assert!(!problem.evaluate(&[1, 0, 0, 1, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, false, false, true, false])
+        .unwrap());
 
     // T0, T1, T3: w-coordinates {0,1,0} not distinct -> invalid
-    assert!(!problem.evaluate(&[1, 1, 0, 1, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, true, false, true, false])
+        .unwrap());
 
     // Only T0 selected (need q=3 triples)
-    assert!(!problem.evaluate(&[1, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![true, false, false, false, false])
+        .unwrap());
 
     // All selected (too many)
-    assert!(!problem.evaluate(&[1, 1, 1, 1, 1]));
+    assert!(!problem
+        .evaluate(&vec![true, true, true, true, true])
+        .unwrap());
 
     // None selected
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0]));
+    assert!(!problem
+        .evaluate(&vec![false, false, false, false, false])
+        .unwrap());
 }
 
 #[test]
@@ -50,14 +63,14 @@ fn test_three_dimensional_matching_solver() {
     );
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
 
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
     // Verify the known solution is in there
-    assert!(solutions.contains(&vec![1, 1, 1, 0, 0]));
+    assert!(solutions.contains(&vec![true, true, true, false, false]));
 }
 
 #[test]
@@ -66,7 +79,7 @@ fn test_three_dimensional_matching_no_solution() {
     let problem = ThreeDimensionalMatching::new(2, vec![(0, 0, 0), (0, 1, 1), (0, 0, 1)]);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(solutions.is_empty());
 }
 
@@ -84,10 +97,10 @@ fn test_three_dimensional_matching_serialization() {
 fn test_three_dimensional_matching_empty() {
     // q = 0: trivially satisfiable
     let problem = ThreeDimensionalMatching::new(0, vec![]);
-    assert!(problem.evaluate(&[]));
+    assert!(problem.evaluate(&vec![]).unwrap());
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
-    assert_eq!(solutions, vec![Vec::<usize>::new()]);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
+    assert_eq!(solutions, vec![Vec::<bool>::new()]);
 }
 
 #[test]
@@ -101,13 +114,18 @@ fn test_three_dimensional_matching_get_triple() {
 #[test]
 fn test_three_dimensional_matching_rejects_wrong_config_length() {
     let problem = ThreeDimensionalMatching::new(2, vec![(0, 1, 0), (1, 0, 1)]);
-    assert!(!problem.evaluate(&[1, 1, 0]));
+    assert!(matches!(
+        problem.evaluate(&vec![true, true, false]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 }
 
 #[test]
 fn test_three_dimensional_matching_rejects_non_binary_config_values() {
     let problem = ThreeDimensionalMatching::new(2, vec![(0, 1, 0), (1, 0, 1)]);
-    assert!(!problem.evaluate(&[1, 2]));
+    assert!(
+        crate::registry::DynProblem::evaluate_dyn(&problem, &serde_json::json!([true, 2])).is_err()
+    );
 }
 
 #[test]
@@ -119,8 +137,8 @@ fn test_three_dimensional_matching_element_out_of_range() {
 #[test]
 fn test_three_dimensional_matching_is_valid_solution() {
     let problem = ThreeDimensionalMatching::new(2, vec![(0, 1, 0), (1, 0, 1)]);
-    assert!(problem.evaluate(&[1, 1]).0);
-    assert!(!problem.evaluate(&[1, 0]).0);
+    assert!(problem.evaluate(&vec![true, true]).unwrap().0);
+    assert!(!problem.evaluate(&vec![true, false]).unwrap().0);
 }
 
 #[test]
@@ -130,7 +148,7 @@ fn test_three_dimensional_matching_duplicate_coordinates() {
     // Actually T1+T2: w={1,0} ok, x={1,1} NOT distinct -> invalid
     let problem = ThreeDimensionalMatching::new(2, vec![(0, 0, 0), (1, 1, 1), (0, 1, 0)]);
 
-    assert!(problem.evaluate(&[1, 1, 0])); // T0+T1: w={0,1}, x={0,1}, y={0,1} all distinct
-    assert!(!problem.evaluate(&[1, 0, 1])); // T0+T2: w={0,0} not distinct
-    assert!(!problem.evaluate(&[0, 1, 1])); // T1+T2: x={1,1} not distinct
+    assert!(problem.evaluate(&vec![true, true, false]).unwrap()); // T0+T1: w={0,1}, x={0,1}, y={0,1} all distinct
+    assert!(!problem.evaluate(&vec![true, false, true]).unwrap()); // T0+T2: w={0,0} not distinct
+    assert!(!problem.evaluate(&vec![false, true, true]).unwrap()); // T1+T2: x={1,1} not distinct
 }
diff --git a/src/unit_tests/models/set/three_matroid_intersection.rs b/src/unit_tests/models/set/three_matroid_intersection.rs
deleted file mode 100644
index 98a119d3d..000000000
--- a/src/unit_tests/models/set/three_matroid_intersection.rs
+++ /dev/null
@@ -1,185 +0,0 @@
-use super::*;
-use crate::solvers::BruteForce;
-use crate::traits::Problem;
-
-/// Helper: build the canonical 6-element, K=2 instance from the issue.
-fn issue_instance() -> ThreeMatroidIntersection {
-    ThreeMatroidIntersection::new(
-        6,
-        vec![
-            vec![vec![0, 1, 2], vec![3, 4, 5]],       // M1
-            vec![vec![0, 3], vec![1, 4], vec![2, 5]], // M2
-            vec![vec![0, 4], vec![1, 5], vec![2, 3]], // M3
-        ],
-        2,
-    )
-}
-
-#[test]
-fn test_three_matroid_intersection_creation() {
-    let problem = issue_instance();
-    assert_eq!(problem.ground_set_size(), 6);
-    assert_eq!(problem.bound(), 2);
-    assert_eq!(problem.partitions().len(), 3);
-    assert_eq!(problem.num_groups(), 8); // 2 + 3 + 3
-    assert_eq!(problem.num_variables(), 6);
-    assert_eq!(problem.dims(), vec![2; 6]);
-}
-
-#[test]
-fn test_three_matroid_intersection_evaluate_valid() {
-    let problem = issue_instance();
-    // {0, 5} is a valid common independent set of size 2
-    // M1: 0 in {0,1,2}, 5 in {3,4,5} -> at most 1 per group
-    // M2: 0 in {0,3}, 5 in {2,5} -> at most 1 per group
-    // M3: 0 in {0,4}, 5 in {1,5} -> at most 1 per group
-    assert!(problem.evaluate(&[1, 0, 0, 0, 0, 1]));
-
-    // {1, 3} is also valid
-    assert!(problem.evaluate(&[0, 1, 0, 1, 0, 0]));
-
-    // {2, 4} is also valid
-    assert!(problem.evaluate(&[0, 0, 1, 0, 1, 0]));
-}
-
-#[test]
-fn test_three_matroid_intersection_evaluate_invalid() {
-    let problem = issue_instance();
-
-    // {0, 3} fails M2: both in group {0, 3}
-    assert!(!problem.evaluate(&[1, 0, 0, 1, 0, 0]));
-
-    // {0, 4} fails M3: both in group {0, 4}
-    assert!(!problem.evaluate(&[1, 0, 0, 0, 1, 0]));
-
-    // {1, 2} fails M1: both in group {0, 1, 2}
-    assert!(!problem.evaluate(&[0, 1, 1, 0, 0, 0]));
-
-    // Wrong size: only 1 element selected
-    assert!(!problem.evaluate(&[1, 0, 0, 0, 0, 0]));
-
-    // Wrong size: 3 elements selected
-    assert!(!problem.evaluate(&[1, 0, 0, 0, 1, 1]));
-
-    // All zeros
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0, 0]));
-}
-
-#[test]
-fn test_three_matroid_intersection_solver() {
-    let problem = issue_instance();
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
-
-    // Exactly 3 valid solutions: {0,5}, {1,3}, {2,4}
-    assert_eq!(solutions.len(), 3);
-    for sol in &solutions {
-        assert!(problem.evaluate(sol));
-    }
-    assert!(solutions.contains(&vec![1, 0, 0, 0, 0, 1]));
-    assert!(solutions.contains(&vec![0, 1, 0, 1, 0, 0]));
-    assert!(solutions.contains(&vec![0, 0, 1, 0, 1, 0]));
-}
-
-#[test]
-fn test_three_matroid_intersection_no_solution() {
-    // Same instance but K=3: M1 has only 2 groups, so independent sets have size ≤ 2
-    let problem = ThreeMatroidIntersection::new(
-        6,
-        vec![
-            vec![vec![0, 1, 2], vec![3, 4, 5]],
-            vec![vec![0, 3], vec![1, 4], vec![2, 5]],
-            vec![vec![0, 4], vec![1, 5], vec![2, 3]],
-        ],
-        3,
-    );
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
-    assert!(solutions.is_empty());
-}
-
-#[test]
-fn test_three_matroid_intersection_serialization() {
-    let problem = issue_instance();
-    let json = serde_json::to_string(&problem).unwrap();
-    let deserialized: ThreeMatroidIntersection = serde_json::from_str(&json).unwrap();
-    assert_eq!(deserialized.ground_set_size(), problem.ground_set_size());
-    assert_eq!(deserialized.bound(), problem.bound());
-    assert_eq!(deserialized.partitions(), problem.partitions());
-}
-
-#[test]
-fn test_three_matroid_intersection_rejects_wrong_config_length() {
-    let problem = issue_instance();
-    assert!(!problem.evaluate(&[1, 0, 0]));
-}
-
-#[test]
-fn test_three_matroid_intersection_rejects_non_binary_config() {
-    let problem = issue_instance();
-    assert!(!problem.evaluate(&[2, 0, 0, 0, 0, 0]));
-}
-
-#[test]
-#[should_panic(expected = "Expected exactly 3")]
-fn test_three_matroid_intersection_wrong_matroid_count() {
-    ThreeMatroidIntersection::new(4, vec![vec![vec![0, 1]], vec![vec![2, 3]]], 1);
-}
-
-#[test]
-#[should_panic(expected = "outside 0..")]
-fn test_three_matroid_intersection_element_out_of_range() {
-    ThreeMatroidIntersection::new(
-        3,
-        vec![
-            vec![vec![0, 1, 2]],
-            vec![vec![0, 1, 2]],
-            vec![vec![0, 1, 5]], // 5 >= 3
-        ],
-        1,
-    );
-}
-
-#[test]
-#[should_panic(expected = "Bound 4 exceeds")]
-fn test_three_matroid_intersection_bound_exceeds_ground_set() {
-    ThreeMatroidIntersection::new(
-        3,
-        vec![
-            vec![vec![0, 1, 2]],
-            vec![vec![0, 1, 2]],
-            vec![vec![0, 1, 2]],
-        ],
-        4,
-    );
-}
-
-#[test]
-fn test_three_matroid_intersection_paper_example() {
-    // Issue's canonical 6-element example, K=2
-    let problem = issue_instance();
-
-    // Valid: {0, 5}
-    assert!(problem.evaluate(&[1, 0, 0, 0, 0, 1]));
-
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
-    // Exactly 3 valid common independent sets of size 2
-    assert_eq!(solutions.len(), 3);
-    assert!(solutions.contains(&vec![1, 0, 0, 0, 0, 1])); // {0, 5}
-    assert!(solutions.contains(&vec![0, 1, 0, 1, 0, 0])); // {1, 3}
-    assert!(solutions.contains(&vec![0, 0, 1, 0, 1, 0])); // {2, 4}
-
-    // Negative modification from issue: K=3 is infeasible (M1 has only 2 groups)
-    let problem_k3 = ThreeMatroidIntersection::new(
-        6,
-        vec![
-            vec![vec![0, 1, 2], vec![3, 4, 5]],
-            vec![vec![0, 3], vec![1, 4], vec![2, 5]],
-            vec![vec![0, 4], vec![1, 5], vec![2, 3]],
-        ],
-        3,
-    );
-    let solutions_k3 = solver.find_all_witnesses(&problem_k3);
-    assert!(solutions_k3.is_empty());
-}
diff --git a/src/unit_tests/models/set/two_dimensional_consecutive_sets.rs b/src/unit_tests/models/set/two_dimensional_consecutive_sets.rs
index 755088d76..b67594e2a 100644
--- a/src/unit_tests/models/set/two_dimensional_consecutive_sets.rs
+++ b/src/unit_tests/models/set/two_dimensional_consecutive_sets.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -17,7 +18,7 @@ fn test_two_dimensional_consecutive_sets_creation() {
     assert_eq!(problem.alphabet_size(), 6);
     assert_eq!(problem.num_subsets(), 5);
     assert_eq!(problem.num_variables(), 6);
-    assert_eq!(problem.dims(), vec![6, 6, 6, 6, 6, 6]);
+    assert_eq!(problem.dimensions(), vec![6, 6, 6, 6, 6, 6]);
 }
 
 #[test]
@@ -38,19 +39,25 @@ fn test_two_dimensional_consecutive_sets_evaluation() {
 
     // Valid partition: X0={0}, X1={1,5}, X2={2,3}, X3={4}
     // config[i] = group of symbol i
-    assert!(problem.evaluate(&[0, 1, 2, 2, 3, 1]));
+    assert!(problem.evaluate(&vec![0, 1, 2, 2, 3, 1]).unwrap());
 
     // Invalid: all symbols in same group (intersection constraint violated)
-    assert!(!problem.evaluate(&[0, 0, 0, 0, 0, 0]));
+    assert!(!problem.evaluate(&vec![0, 0, 0, 0, 0, 0]).unwrap());
 
     // Invalid: wrong config length
-    assert!(!problem.evaluate(&[0, 1, 2]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 
     // Invalid: group index out of range
-    assert!(!problem.evaluate(&[0, 1, 2, 2, 3, 7]));
+    assert!(matches!(
+        problem.evaluate(&vec![0, 1, 2, 2, 3, 7]),
+        Err(crate::traits::EvaluationError::InvalidConfiguration(_))
+    ));
 
     // Invalid: {0,1,2} not consecutive (0 in group 0, 1 in group 1, 2 in group 5)
-    assert!(!problem.evaluate(&[0, 1, 5, 2, 3, 1]));
+    assert!(!problem.evaluate(&vec![0, 1, 5, 2, 3, 1]).unwrap());
 }
 
 #[test]
@@ -58,7 +65,7 @@ fn test_two_dimensional_consecutive_sets_evaluation_ignores_empty_group_labels()
     let problem = TwoDimensionalConsecutiveSets::new(3, vec![vec![0, 1]]);
 
     // The empty label 1 should be ignored, so this encodes the ordered partition {0} | {1,2}.
-    assert!(problem.evaluate(&[0, 2, 2]));
+    assert!(problem.evaluate(&vec![0, 2, 2]).unwrap());
 }
 
 #[test]
@@ -72,7 +79,7 @@ fn test_two_dimensional_consecutive_sets_no_instance() {
     );
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(solutions.is_empty());
 }
 
@@ -82,10 +89,10 @@ fn test_two_dimensional_consecutive_sets_solver() {
     let problem = TwoDimensionalConsecutiveSets::new(4, vec![vec![0, 1], vec![2, 3], vec![1, 2]]);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -110,16 +117,16 @@ fn test_two_dimensional_consecutive_sets_deserialization_rejects_out_of_range_el
 fn test_two_dimensional_consecutive_sets_empty_subsets() {
     // All empty subsets — trivially satisfiable
     let problem = TwoDimensionalConsecutiveSets::new(3, vec![vec![], vec![]]);
-    assert!(problem.evaluate(&[0, 1, 2]));
-    assert!(problem.evaluate(&[0, 0, 0]));
+    assert!(problem.evaluate(&vec![0, 1, 2]).unwrap());
+    assert!(problem.evaluate(&vec![0, 0, 0]).unwrap());
 }
 
 #[test]
 fn test_two_dimensional_consecutive_sets_single_element_subsets() {
     // Single-element subsets: always satisfiable (no consecutiveness constraint to check)
     let problem = TwoDimensionalConsecutiveSets::new(3, vec![vec![0], vec![1], vec![2]]);
-    assert!(problem.evaluate(&[0, 1, 2]));
-    assert!(problem.evaluate(&[0, 0, 0])); // single elements always consecutive
+    assert!(problem.evaluate(&vec![0, 1, 2]).unwrap());
+    assert!(problem.evaluate(&vec![0, 0, 0]).unwrap()); // single elements always consecutive
 }
 
 #[test]
@@ -138,11 +145,11 @@ fn test_two_dimensional_consecutive_sets_paper_example() {
 
     // Verify the known valid solution
     let valid_config = vec![0, 1, 2, 2, 3, 1];
-    assert!(problem.evaluate(&valid_config));
+    assert!(problem.evaluate(&valid_config).unwrap());
 
     // Use brute force to find all solutions
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert!(!solutions.is_empty());
     // The known solution should be among them
     assert!(solutions.contains(&valid_config));
diff --git a/src/unit_tests/parameters.rs b/src/unit_tests/parameters.rs
new file mode 100644
index 000000000..a98eb5dfc
--- /dev/null
+++ b/src/unit_tests/parameters.rs
@@ -0,0 +1,144 @@
+use super::{ParameterRelation, ParameterTransform, ParameterTransformError};
+use crate::expr::Expr;
+use crate::types::ProblemParameters;
+
+#[test]
+fn exact_transform_evaluates_exactly() {
+    let transform = ParameterTransform::new(
+        "A -> B",
+        ParameterRelation::Exact,
+        [("m", Expr::parse("n * (n - 1) / 2"))],
+    )
+    .unwrap();
+    let result = transform
+        .evaluate(&ProblemParameters::new(vec![("n", 5)]))
+        .unwrap();
+    assert_eq!(result.get("m"), Some(10));
+}
+
+#[test]
+fn upper_bound_relation_survives_evaluation_and_composition() {
+    let first = ParameterTransform::new(
+        "A -> B",
+        ParameterRelation::UpperBound,
+        [("m", Expr::parse("n^2"))],
+    )
+    .unwrap();
+    let second = ParameterTransform::new(
+        "B -> C",
+        ParameterRelation::Exact,
+        [("k", Expr::parse("3*m + 1"))],
+    )
+    .unwrap();
+    let composed = first.compose(&second, "A -> C").unwrap();
+    assert_eq!(composed.relation(), ParameterRelation::UpperBound);
+    let result = composed
+        .evaluate(&ProblemParameters::new(vec![("n", 4)]))
+        .unwrap();
+    assert_eq!(result.get("k"), Some(49));
+}
+
+#[test]
+fn upper_bound_crosses_subtraction_via_positive_polynomial_hull() {
+    let first = ParameterTransform::new(
+        "A -> B",
+        ParameterRelation::UpperBound,
+        [("m", Expr::parse("n^2"))],
+    )
+    .unwrap();
+    let second = ParameterTransform::new(
+        "B -> C",
+        ParameterRelation::Exact,
+        [("k", Expr::parse("10 - m"))],
+    )
+    .unwrap();
+    let exact_result = second
+        .evaluate(&ProblemParameters::new(vec![("m", 4)]))
+        .unwrap();
+    assert_eq!(exact_result.get("k"), Some(6));
+
+    let composed = first.compose(&second, "A -> C").unwrap();
+    assert_eq!(composed.get("k").unwrap().to_string(), "10");
+    let result = composed
+        .evaluate(&ProblemParameters::new(vec![("n", 4)]))
+        .unwrap();
+    assert_eq!(result.get("k"), Some(10));
+}
+
+#[test]
+fn polynomial_hull_expands_and_combines_terms_before_dropping_negative_coefficients() {
+    let first = ParameterTransform::new(
+        "A -> B",
+        ParameterRelation::UpperBound,
+        [
+            ("vertices", Expr::parse("q")),
+            ("edges", Expr::parse("q^2")),
+        ],
+    )
+    .unwrap();
+    let complement = ParameterTransform::new(
+        "B -> C",
+        ParameterRelation::Exact,
+        [(
+            "edges",
+            Expr::parse("vertices * (vertices - 1) / 2 - edges"),
+        )],
+    )
+    .unwrap();
+
+    let composed = first.compose(&complement, "A -> C").unwrap();
+    assert_eq!(composed.get("edges").unwrap().to_string(), "0.5 * q^2");
+    let result = composed
+        .evaluate(&ProblemParameters::new(vec![("q", 5)]))
+        .unwrap();
+    assert_eq!(result.get("edges"), Some(13));
+}
+
+#[test]
+fn symbolic_upper_bound_composition_rejects_non_polynomial_formulas() {
+    let reciprocal = ParameterTransform::new(
+        "B -> C",
+        ParameterRelation::Exact,
+        [("k", Expr::parse("1 / m"))],
+    )
+    .unwrap();
+    let bounded_transform = ParameterTransform::new(
+        "A -> B",
+        ParameterRelation::UpperBound,
+        [("m", Expr::parse("n"))],
+    )
+    .unwrap();
+
+    assert!(matches!(
+        bounded_transform.compose(&reciprocal, "A -> C"),
+        Err(ParameterTransformError::CannotPropagateUpperBound { .. })
+    ));
+}
+
+#[test]
+fn upper_bound_rational_results_round_up() {
+    let transform = ParameterTransform::new(
+        "A -> B",
+        ParameterRelation::UpperBound,
+        [("m", Expr::parse("n / 2"))],
+    )
+    .unwrap();
+    let result = transform
+        .evaluate(&ProblemParameters::new(vec![("n", 5)]))
+        .unwrap();
+    assert_eq!(result.get("m"), Some(3));
+}
+
+#[test]
+fn evaluation_reports_result_beyond_problem_parameters_range() {
+    let transform = ParameterTransform::new(
+        "A -> B",
+        ParameterRelation::Exact,
+        [("m", Expr::parse("n^2"))],
+    )
+    .unwrap();
+    assert!(matches!(
+        transform.evaluate(&ProblemParameters::new(vec![("n", u64::MAX)])),
+        Err(ParameterTransformError::OutputOutOfRange { .. })
+    ));
+}
diff --git a/src/unit_tests/problem_size.rs b/src/unit_tests/problem_parameters.rs
similarity index 60%
rename from src/unit_tests/problem_size.rs
rename to src/unit_tests/problem_parameters.rs
index 1e40e683f..200f0a081 100644
--- a/src/unit_tests/problem_size.rs
+++ b/src/unit_tests/problem_parameters.rs
@@ -1,4 +1,4 @@
-//! Tests for problem_size() free function and Problem size implementations.
+//! Tests for canonical parameters measured by concrete problem instances.
 
 use crate::models::algebraic::*;
 use crate::models::formula::*;
@@ -6,107 +6,115 @@ use crate::models::graph::*;
 use crate::models::misc::*;
 use crate::models::set::*;
 use crate::topology::{BipartiteGraph, SimpleGraph};
-use crate::traits::{problem_size, Problem};
+use crate::traits::Problem;
 
 #[test]
-fn test_problem_size_mis() {
+fn test_problem_parameters_mis() {
     let g = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
-    let mis = MaximumIndependentSet::new(g, vec![1i32; 4]);
-    let size = problem_size(&mis);
+    let mis = MaximumIndependentSet::new(g, vec![1i64; 4]);
+    let size = mis.parameters();
     assert_eq!(size.get("num_vertices"), Some(4));
     assert_eq!(size.get("num_edges"), Some(3));
 }
 
 #[test]
-fn test_problem_size_max_clique() {
+fn test_problem_parameters_max_clique() {
     let g = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
-    let mc = MaximumClique::new(g, vec![1i32; 3]);
-    let size = problem_size(&mc);
+    let mc = MaximumClique::new(g, vec![1i64; 3]);
+    let size = mc.parameters();
     assert_eq!(size.get("num_vertices"), Some(3));
     assert_eq!(size.get("num_edges"), Some(3));
 }
 
 #[test]
-fn test_problem_size_min_vc() {
+fn test_problem_parameters_min_vc() {
     let g = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let mvc = MinimumVertexCover::new(g, vec![1i32; 3]);
-    let size = problem_size(&mvc);
+    let mvc = MinimumVertexCover::new(g, vec![1i64; 3]);
+    let size = mvc.parameters();
     assert_eq!(size.get("num_vertices"), Some(3));
     assert_eq!(size.get("num_edges"), Some(2));
 }
 
 #[test]
-fn test_problem_size_min_ds() {
+fn test_problem_parameters_min_ds() {
     let g = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]);
-    let mds = MinimumDominatingSet::new(g, vec![1i32; 4]);
-    let size = problem_size(&mds);
+    let mds = MinimumDominatingSet::new(g, vec![1i64; 4]);
+    let size = mds.parameters();
     assert_eq!(size.get("num_vertices"), Some(4));
     assert_eq!(size.get("num_edges"), Some(3));
 }
 
 #[test]
-fn test_problem_size_max_cut() {
+fn test_problem_parameters_max_cut() {
     let g = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
-    let mc = MaxCut::new(g, vec![1i32; 3]);
-    let size = problem_size(&mc);
+    let mc = MaxCut::new(g, vec![1i64; 3]);
+    let size = mc.parameters();
     assert_eq!(size.get("num_vertices"), Some(3));
     assert_eq!(size.get("num_edges"), Some(3));
 }
 
 #[test]
-fn test_problem_size_maximum_matching() {
+fn test_problem_parameters_maximum_matching() {
     let g = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
-    let mm = MaximumMatching::new(g, vec![1i32; 3]);
-    let size = problem_size(&mm);
+    let mm = MaximumMatching::new(g, vec![1i64; 3]);
+    let size = mm.parameters();
     assert_eq!(size.get("num_vertices"), Some(4));
     assert_eq!(size.get("num_edges"), Some(3));
 }
 
 #[test]
-fn test_problem_size_maximal_is() {
+fn test_problem_parameters_maximal_is() {
     let g = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let mis = MaximalIS::new(g, vec![1i32; 3]);
-    let size = problem_size(&mis);
+    let mis = MaximalIS::new(g, vec![1i64; 3]);
+    let size = mis.parameters();
     assert_eq!(size.get("num_vertices"), Some(3));
     assert_eq!(size.get("num_edges"), Some(2));
 }
 
 #[test]
-fn test_problem_size_kcoloring() {
+fn test_problem_parameters_knapsack_capacity() {
+    let knapsack = Knapsack::new(vec![2, 3], vec![5, 7], 4);
+    let parameters = knapsack.parameters();
+
+    assert_eq!(parameters.get("capacity"), Some(4));
+    assert_eq!(parameters.get("num_items"), Some(2));
+}
+
+#[test]
+fn test_problem_parameters_kcoloring() {
     use crate::variant::KN;
     let g = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
     let kc = KColoring::<KN, _>::with_k(g, 3);
-    let size = problem_size(&kc);
+    let size = kc.parameters();
     assert_eq!(size.get("num_vertices"), Some(3));
     assert_eq!(size.get("num_edges"), Some(3));
-    // k is a problem parameter, not a size metric
-    assert_eq!(size.get("num_colors"), None);
+    assert_eq!(size.get("num_colors"), Some(3));
 }
 
 #[test]
-fn test_problem_size_tsp() {
+fn test_problem_parameters_tsp() {
     let g = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
-    let tsp = TravelingSalesman::new(g, vec![1i32; 3]);
-    let size = problem_size(&tsp);
+    let tsp = TravelingSalesman::new(g, vec![1i64; 3]);
+    let size = tsp.parameters();
     assert_eq!(size.get("num_vertices"), Some(3));
     assert_eq!(size.get("num_edges"), Some(3));
 }
 
 #[test]
-fn test_problem_size_sat() {
+fn test_problem_parameters_sat() {
     use crate::models::formula::CNFClause;
     let sat = Satisfiability::new(
         3,
         vec![CNFClause::new(vec![1, -2]), CNFClause::new(vec![2, 3])],
     );
-    let size = problem_size(&sat);
+    let size = sat.parameters();
     assert_eq!(size.get("num_vars"), Some(3));
     assert_eq!(size.get("num_clauses"), Some(2));
     assert_eq!(size.get("num_literals"), Some(4));
 }
 
 #[test]
-fn test_problem_size_ksat() {
+fn test_problem_parameters_ksat() {
     use crate::models::formula::CNFClause;
     use crate::variant::K3;
     let ksat = KSatisfiability::<K3>::new(
@@ -116,78 +124,80 @@ fn test_problem_size_ksat() {
             CNFClause::new(vec![-1, 2, -3]),
         ],
     );
-    let size = problem_size(&ksat);
+    let size = ksat.parameters();
     assert_eq!(size.get("num_vars"), Some(3));
     assert_eq!(size.get("num_clauses"), Some(2));
     assert_eq!(size.get("num_literals"), Some(6));
 }
 
 #[test]
-fn test_problem_size_qubo() {
-    let qubo = QUBO::<f64>::new(vec![1.0, 2.0, 3.0], vec![]);
-    let size = problem_size(&qubo);
+fn test_problem_parameters_qubo() {
+    let qubo = QUBO::<f64>::new(vec![1.0, 2.0, 3.0], vec![]).unwrap();
+    let size = qubo.parameters();
     assert_eq!(size.get("num_vars"), Some(3));
 }
 
 #[test]
-fn test_problem_size_spinglass() {
+fn test_problem_parameters_spinglass() {
     let sg = SpinGlass::<SimpleGraph, f64>::new(
         3,
         vec![((0, 1), 1.0), ((1, 2), -1.0)],
         vec![0.0, 0.5, -0.5],
-    );
-    let size = problem_size(&sg);
+    )
+    .unwrap();
+    let size = sg.parameters();
     assert_eq!(size.get("num_spins"), Some(3));
     assert_eq!(size.get("num_interactions"), Some(2));
 }
 
 #[test]
-fn test_problem_size_ilp() {
+fn test_problem_parameters_ilp() {
     use crate::models::algebraic::{LinearConstraint, ObjectiveSense};
     let ilp = ILP::<bool>::new(
         2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 3.0)],
-        vec![(0, 1.0), (1, 2.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 3)],
+        vec![(0, 1), (1, 2)],
         ObjectiveSense::Maximize,
-    );
-    let size = problem_size(&ilp);
+    )
+    .unwrap();
+    let size = ilp.parameters();
     assert_eq!(size.get("num_vars"), Some(2));
     assert_eq!(size.get("num_constraints"), Some(1));
 }
 
 #[test]
-fn test_problem_size_factoring() {
-    let f = Factoring::new(2, 3, 6);
-    let size = problem_size(&f);
+fn test_problem_parameters_factoring() {
+    let f = Factoring::with_factor_bits(6, 2, 3);
+    let size = f.parameters();
     assert_eq!(size.get("num_bits_first"), Some(2));
     assert_eq!(size.get("num_bits_second"), Some(3));
 }
 
 #[test]
-fn test_problem_size_circuitsat() {
+fn test_problem_parameters_circuitsat() {
     use crate::models::formula::{Assignment, BooleanExpr, Circuit};
     let circuit = Circuit::new(vec![Assignment::new(
         vec!["c".to_string()],
         BooleanExpr::and(vec![BooleanExpr::var("x"), BooleanExpr::var("y")]),
     )]);
     let problem = CircuitSAT::new(circuit);
-    let size = problem_size(&problem);
-    assert_eq!(size.get("num_variables"), Some(problem.num_variables()));
+    let size = problem.parameters();
+    assert_eq!(size.get("num_variables"), Some(3));
     assert_eq!(size.get("num_assignments"), Some(1));
 }
 
 #[test]
-fn test_problem_size_paintshop() {
+fn test_problem_parameters_paintshop() {
     let ps = PaintShop::new(vec!["a", "b", "a", "c", "c", "b"]);
-    let size = problem_size(&ps);
+    let size = ps.parameters();
     assert_eq!(size.get("num_cars"), Some(3));
     assert_eq!(size.get("num_sequence"), Some(6));
 }
 
 #[test]
-fn test_problem_size_biclique_cover() {
+fn test_problem_parameters_biclique_cover() {
     let bc = BicliqueCover::new(BipartiteGraph::new(2, 3, vec![(0, 0), (0, 1), (1, 2)]), 2);
-    let size = problem_size(&bc);
+    let size = bc.parameters();
     assert_eq!(size.get("left_size"), Some(2));
     assert_eq!(size.get("right_size"), Some(3));
     assert_eq!(size.get("num_edges"), Some(3));
@@ -195,26 +205,26 @@ fn test_problem_size_biclique_cover() {
 }
 
 #[test]
-fn test_problem_size_bmf() {
+fn test_problem_parameters_bmf() {
     let bmf = BMF::new(vec![vec![true, false], vec![false, true]], 2);
-    let size = problem_size(&bmf);
-    assert_eq!(size.get("m"), Some(2));
-    assert_eq!(size.get("n"), Some(2));
+    let size = bmf.parameters();
+    assert_eq!(size.get("rows"), Some(2));
+    assert_eq!(size.get("cols"), Some(2));
     assert_eq!(size.get("rank"), Some(2));
 }
 
 #[test]
-fn test_problem_size_set_packing() {
-    let sp = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
-    let size = problem_size(&sp);
+fn test_problem_parameters_set_packing() {
+    let sp = MaximumSetPacking::<i64>::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
+    let size = sp.parameters();
     assert_eq!(size.get("num_sets"), Some(3));
     assert_eq!(size.get("universe_size"), Some(4));
 }
 
 #[test]
-fn test_problem_size_set_covering() {
-    let sc = MinimumSetCovering::<i32>::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
-    let size = problem_size(&sc);
+fn test_problem_parameters_set_covering() {
+    let sc = MinimumSetCovering::<i64>::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
+    let size = sc.parameters();
     assert_eq!(size.get("num_sets"), Some(3));
     assert_eq!(size.get("universe_size"), Some(4));
 }
diff --git a/src/unit_tests/property.rs b/src/unit_tests/property.rs
index b9a300871..981f5e1de 100644
--- a/src/unit_tests/property.rs
+++ b/src/unit_tests/property.rs
@@ -40,15 +40,15 @@ proptest! {
     /// is a minimum vertex cover, and their sizes sum to n.
     #[test]
     fn independent_set_complement_is_vertex_cover((n, edges) in graph_strategy(8)) {
-        let is_problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges.clone()), vec![1i32; n]);
-        let vc_problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i32; n]);
+        let is_problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges.clone()), vec![1i64; n]);
+        let vc_problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i64; n]);
 
         let solver = BruteForce::new();
-        let is_solutions = solver.find_all_witnesses(&is_problem);
-        let vc_solutions = solver.find_all_witnesses(&vc_problem);
+        let is_solutions = solver.find_all_witnesses(&is_problem).unwrap();
+        let vc_solutions = solver.find_all_witnesses(&vc_problem).unwrap();
 
-        let is_size: usize = is_solutions[0].iter().sum();
-        let vc_size: usize = vc_solutions[0].iter().sum();
+        let is_size: usize = is_solutions[0].iter().filter(|&&selected| selected).count();
+        let vc_size: usize = vc_solutions[0].iter().filter(|&&selected| selected).count();
 
         // IS size + VC size = n (for optimal solutions)
         prop_assert_eq!(is_size + vc_size, n);
@@ -57,16 +57,16 @@ proptest! {
     /// Property: Any subset of a valid independent set is also a valid independent set.
     #[test]
     fn valid_solution_stays_valid_under_subset((n, edges) in graph_strategy(6)) {
-        let problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i32; n]);
+        let problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i64; n]);
         let solver = BruteForce::new();
 
-        for sol in solver.find_all_witnesses(&problem) {
+        for sol in solver.find_all_witnesses(&problem).unwrap() {
             // Any subset of an IS is also an IS
             for i in 0..n {
                 let mut subset = sol.clone();
-                subset[i] = 0;
+                subset[i] = false;
                 // Valid configurations return is_valid() == true
-                prop_assert!(problem.evaluate(&subset).is_valid());
+                prop_assert!(problem.evaluate(&subset).unwrap().is_valid());
             }
         }
     }
@@ -74,16 +74,16 @@ proptest! {
     /// Property: A vertex cover with additional vertices is still a valid cover.
     #[test]
     fn vertex_cover_superset_is_valid((n, edges) in graph_strategy(6)) {
-        let problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i32; n]);
+        let problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i64; n]);
         let solver = BruteForce::new();
 
-        for sol in solver.find_all_witnesses(&problem) {
+        for sol in solver.find_all_witnesses(&problem).unwrap() {
             // Adding any vertex to a VC still gives a valid VC
             for i in 0..n {
                 let mut superset = sol.clone();
-                superset[i] = 1;
+                superset[i] = true;
                 // Valid configurations return is_valid() == true
-                prop_assert!(problem.evaluate(&superset).is_valid());
+                prop_assert!(problem.evaluate(&superset).unwrap().is_valid());
             }
         }
     }
@@ -91,15 +91,15 @@ proptest! {
     /// Property: The complement of any valid independent set is a valid vertex cover.
     #[test]
     fn is_complement_is_vc((n, edges) in graph_strategy(7)) {
-        let is_problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges.clone()), vec![1i32; n]);
-        let vc_problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i32; n]);
+        let is_problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges.clone()), vec![1i64; n]);
+        let vc_problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i64; n]);
         let solver = BruteForce::new();
 
         // Get all valid independent sets (not just optimal)
-        for sol in solver.find_all_witnesses(&is_problem) {
+        for sol in solver.find_all_witnesses(&is_problem).unwrap() {
             // The complement should be a valid vertex cover
-            let complement: Vec<usize> = sol.iter().map(|&x| 1 - x).collect();
-            prop_assert!(vc_problem.evaluate(&complement).is_valid(),
+            let complement: Vec<bool> = sol.iter().map(|&selected| !selected).collect();
+            prop_assert!(vc_problem.evaluate(&complement).unwrap().is_valid(),
                 "Complement of IS {:?} should be valid VC", sol);
         }
     }
@@ -107,30 +107,30 @@ proptest! {
     /// Property: Empty selection is always a valid (but possibly non-optimal) independent set.
     #[test]
     fn empty_is_always_valid_is((n, edges) in graph_strategy(10)) {
-        let problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i32; n]);
-        let empty = vec![0; n];
+        let problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i64; n]);
+        let empty = vec![false; n];
         // Valid configuration returns is_valid() == true (0 for empty set)
-        prop_assert!(problem.evaluate(&empty).is_valid());
+        prop_assert!(problem.evaluate(&empty).unwrap().is_valid());
     }
 
     /// Property: Full selection is always a valid (but possibly non-optimal) vertex cover
     /// (when there is at least one vertex).
     #[test]
     fn full_is_always_valid_vc((n, edges) in graph_strategy(10)) {
-        let problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i32; n]);
-        let full = vec![1; n];
+        let problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i64; n]);
+        let full = vec![true; n];
         // Valid configuration returns is_valid() == true
-        prop_assert!(problem.evaluate(&full).is_valid());
+        prop_assert!(problem.evaluate(&full).unwrap().is_valid());
     }
 
     /// Property: Solution size is non-negative for independent sets.
     #[test]
     fn is_size_non_negative((n, edges) in graph_strategy(8)) {
-        let problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i32; n]);
+        let problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i64; n]);
         let solver = BruteForce::new();
 
-        for sol in solver.find_all_witnesses(&problem) {
-            let metric = problem.evaluate(&sol);
+        for sol in solver.find_all_witnesses(&problem).unwrap() {
+            let metric = problem.evaluate(&sol).unwrap();
             // Valid solutions have non-negative size
             prop_assert!(metric.is_valid());
             if let Some(size) = metric.size() {
diff --git a/src/unit_tests/reduction_graph.rs b/src/unit_tests/reduction_graph.rs
index be612b57b..6595c0007 100644
--- a/src/unit_tests/reduction_graph.rs
+++ b/src/unit_tests/reduction_graph.rs
@@ -1,19 +1,139 @@
 //! Tests for ReductionGraph: discovery, path finding, and typed API.
 
-#[cfg(feature = "ilp-solver")]
 use crate::models::algebraic::ILP;
 use crate::models::decision::Decision;
 use crate::models::formula::KSatisfiability;
 use crate::models::misc::Clustering;
 use crate::prelude::*;
-use crate::rules::{MinimizeSteps, ReductionGraph, ReductionMode, TraversalFlow};
-use crate::topology::{KingsSubgraph, SimpleGraph, TriangularSubgraph, UnitDiskGraph};
-use crate::types::ProblemSize;
+use crate::rules::{ReductionGraph, ReductionMode, ReductionPath, ReductionStep, TraversalFlow};
+use crate::topology::{KingsSubgraph, SimpleGraph, UnitDiskGraph};
+use crate::types::ProblemParameters;
 use crate::variant::{K3, KN};
 use std::collections::BTreeMap;
 
+#[test]
+fn exact_transform_evaluates_without_path_ranking() {
+    let graph = ReductionGraph::new();
+    let source =
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let target = ReductionGraph::variant_to_map(&MaximumClique::<SimpleGraph, i64>::variant());
+    let paths = graph.find_all_paths_mode(
+        "MaximumIndependentSet",
+        &source,
+        "MaximumClique",
+        &target,
+        ReductionMode::Witness,
+    );
+    let path = paths.iter().find(|path| path.len() == 1).unwrap();
+    let transform = graph
+        .compose_path_parameter_transform(path)
+        .unwrap()
+        .unwrap();
+    let evaluated = transform
+        .evaluate(&ProblemParameters::new(vec![
+            ("num_vertices", 5),
+            ("num_edges", 4),
+        ]))
+        .unwrap();
+    assert_eq!(evaluated.get("num_edges"), Some(6));
+}
+
+#[test]
+fn symbolic_composition_propagates_num_colors_across_multiple_edges() {
+    let graph = ReductionGraph::new();
+    let path = ReductionPath {
+        steps: vec![
+            ReductionStep {
+                name: Satisfiability::NAME.to_string(),
+                variant: ReductionGraph::variant_to_map(&Satisfiability::variant()),
+            },
+            ReductionStep {
+                name: KColoring::<K3, SimpleGraph>::NAME.to_string(),
+                variant: ReductionGraph::variant_to_map(&KColoring::<K3, SimpleGraph>::variant()),
+            },
+            ReductionStep {
+                name: KColoring::<KN, SimpleGraph>::NAME.to_string(),
+                variant: ReductionGraph::variant_to_map(&KColoring::<KN, SimpleGraph>::variant()),
+            },
+            ReductionStep {
+                name: QUBO::<i64>::NAME.to_string(),
+                variant: ReductionGraph::variant_to_map(&QUBO::<i64>::variant()),
+            },
+        ],
+    };
+
+    let transform = graph
+        .compose_path_parameter_transform(&path)
+        .unwrap()
+        .unwrap();
+    let target = transform
+        .evaluate(&ProblemParameters::new(vec![
+            ("num_vars", 1),
+            ("num_clauses", 1),
+            ("num_literals", 1),
+        ]))
+        .unwrap();
+
+    assert_eq!(target.get("num_vars"), Some(15));
+}
+
+#[test]
+fn exact_rule_exposes_one_transform() {
+    let graph = ReductionGraph::new();
+    let source =
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let target = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
+    let path = graph
+        .find_all_paths_mode(
+            "MaximumIndependentSet",
+            &source,
+            "MinimumVertexCover",
+            &target,
+            ReductionMode::Witness,
+        )
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .unwrap();
+    let transform = graph
+        .compose_path_parameter_transform(&path)
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        transform.relation(),
+        crate::parameters::ParameterRelation::Exact
+    );
+}
+
 // ---- Discovery and registration ----
 
+#[test]
+fn compose_path_parameter_transform_rejects_an_empty_path() {
+    let graph = ReductionGraph::new();
+    let error = graph
+        .compose_path_parameter_transform(&ReductionPath { steps: Vec::new() })
+        .unwrap_err();
+    assert!(matches!(error, crate::rules::PathParameterError::EmptyPath));
+}
+
+#[test]
+fn compose_path_parameter_transform_is_absent_for_one_node() {
+    let graph = ReductionGraph::new();
+    let variant = graph
+        .default_variant_for(KSatisfiability::<K3>::NAME)
+        .expect("K3 satisfiability is registered");
+    let path = ReductionPath {
+        steps: vec![ReductionStep {
+            name: KSatisfiability::<K3>::NAME.to_string(),
+            variant,
+        }],
+    };
+
+    assert!(graph
+        .compose_path_parameter_transform(&path)
+        .unwrap()
+        .is_none());
+}
+
 #[test]
 fn test_reduction_graph_discovers_registered_reductions() {
     let graph = ReductionGraph::new();
@@ -41,7 +161,6 @@ fn test_reduction_graph_discovers_k3coloring_to_clustering() {
     assert!(graph.has_direct_reduction::<KColoring<K3, SimpleGraph>, Clustering>());
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_reduction_graph_discovers_clustering_to_ilp() {
     let graph = ReductionGraph::new();
@@ -52,24 +171,17 @@ fn test_reduction_graph_discovers_clustering_to_ilp() {
 // ---- Path finding (by name) ----
 
 #[test]
-fn test_find_path_with_cost_function() {
+fn test_find_direct_route_by_exact_variants() {
     let graph = ReductionGraph::new();
-    let input_size = ProblemSize::new(vec![("num_vertices", 100), ("num_edges", 200)]);
 
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
 
-    let path = graph.find_cheapest_path(
-        "MaximumIndependentSet",
-        &src,
-        "MinimumVertexCover",
-        &dst,
-        &input_size,
-        &MinimizeSteps,
-    );
-
-    assert!(path.is_some(), "Should find path from IS to VC");
-    let path = path.unwrap();
+    let path = graph
+        .find_all_paths("MaximumIndependentSet", &src, "MinimumVertexCover", &dst)
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("direct route should exist");
     assert_eq!(path.len(), 1, "Should be a 1-step path");
     assert_eq!(path.source(), Some("MaximumIndependentSet"));
     assert_eq!(path.target(), Some("MinimumVertexCover"));
@@ -79,23 +191,14 @@ fn test_find_path_with_cost_function() {
 fn test_multi_step_path() {
     let graph = ReductionGraph::new();
 
-    // Factoring -> CircuitSAT -> SpinGlass<SimpleGraph, i32> is a 2-step path
+    // Factoring -> CircuitSAT -> SpinGlass<SimpleGraph, i64> is a 2-step path
     let src = ReductionGraph::variant_to_map(&crate::models::misc::Factoring::variant());
-    let dst = ReductionGraph::variant_to_map(&SpinGlass::<SimpleGraph, i32>::variant());
-    let path = graph.find_cheapest_path(
-        "Factoring",
-        &src,
-        "SpinGlass",
-        &dst,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-
-    assert!(
-        path.is_some(),
-        "Should find path from Factoring to SpinGlass"
-    );
-    let path = path.unwrap();
+    let dst = ReductionGraph::variant_to_map(&SpinGlass::<SimpleGraph, i64>::variant());
+    let path = graph
+        .find_all_paths("Factoring", &src, "SpinGlass", &dst)
+        .into_iter()
+        .find(|path| path.type_names() == ["Factoring", "CircuitSAT", "SpinGlass"])
+        .expect("explicit CircuitSAT route should exist");
     assert_eq!(path.len(), 2, "Should be a 2-step path");
     assert_eq!(
         path.type_names(),
@@ -106,96 +209,93 @@ fn test_multi_step_path() {
 #[test]
 fn aggregate_mode_rejects_witness_only_real_edge() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
 
-    assert!(graph
-        .find_cheapest_path_mode(
+    assert!(!graph
+        .find_all_paths_mode(
             "MaximumIndependentSet",
             &src,
             "MinimumVertexCover",
             &dst,
-            ReductionMode::Witness,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
+            ReductionMode::Witness
         )
-        .is_some());
+        .is_empty());
     assert!(graph
-        .find_cheapest_path_mode(
+        .find_all_paths_mode(
             "MaximumIndependentSet",
             &src,
             "MinimumVertexCover",
             &dst,
-            ReductionMode::Aggregate,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
+            ReductionMode::Aggregate
         )
-        .is_none());
+        .is_empty());
 }
 
 #[test]
-fn natural_edge_supports_both_modes_public_api() {
+fn variant_reduction_supports_both_modes_public_api() {
     let graph = ReductionGraph::new();
     let src =
-        ReductionGraph::variant_to_map(&MaximumIndependentSet::<KingsSubgraph, i32>::variant());
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<KingsSubgraph, i64>::variant());
     let dst =
-        ReductionGraph::variant_to_map(&MaximumIndependentSet::<UnitDiskGraph, i32>::variant());
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<UnitDiskGraph, i64>::variant());
 
-    assert!(graph
-        .find_cheapest_path_mode(
+    assert!(!graph
+        .find_all_paths_mode(
             "MaximumIndependentSet",
             &src,
             "MaximumIndependentSet",
             &dst,
-            ReductionMode::Witness,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
+            ReductionMode::Witness
         )
-        .is_some());
-    assert!(graph
-        .find_cheapest_path_mode(
+        .is_empty());
+    assert!(!graph
+        .find_all_paths_mode(
             "MaximumIndependentSet",
             &src,
             "MaximumIndependentSet",
             &dst,
-            ReductionMode::Aggregate,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
+            ReductionMode::Aggregate
         )
-        .is_some());
+        .is_empty());
 }
 
 #[test]
-fn test_problem_size_propagation() {
+fn value_changing_variant_cast_is_not_aggregate_capable() {
+    use crate::models::set::MaximumSetPacking;
+
     let graph = ReductionGraph::new();
-    let input_size = ProblemSize::new(vec![("num_vertices", 50), ("num_edges", 100)]);
+    let src = ReductionGraph::variant_to_map(&MaximumSetPacking::<i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<f64>::variant());
 
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    assert!(graph
+        .find_all_paths_mode(
+            "MaximumSetPacking",
+            &src,
+            "MaximumSetPacking",
+            &dst,
+            ReductionMode::Aggregate
+        )
+        .is_empty());
+}
 
-    let path = graph.find_cheapest_path(
-        "MaximumIndependentSet",
-        &src,
-        "MinimumVertexCover",
-        &dst,
-        &input_size,
-        &MinimizeSteps,
-    );
+#[test]
+fn test_problem_parameters_propagation() {
+    let graph = ReductionGraph::new();
+
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
 
-    assert!(path.is_some());
+    assert!(!graph
+        .find_all_paths("MaximumIndependentSet", &src, "MinimumVertexCover", &dst)
+        .is_empty());
 
     let src2 =
-        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst2 = ReductionGraph::variant_to_map(&MaximumSetPacking::<i32>::variant());
-    let path2 = graph.find_cheapest_path(
-        "MaximumIndependentSet",
-        &src2,
-        "MaximumSetPacking",
-        &dst2,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-    assert!(path2.is_some());
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst2 = ReductionGraph::variant_to_map(&MaximumSetPacking::<i64>::variant());
+    assert!(!graph
+        .find_all_paths("MaximumIndependentSet", &src2, "MaximumSetPacking", &dst2)
+        .is_empty());
 }
 
 // ---- JSON export ----
@@ -235,7 +335,6 @@ fn test_subsetsum_to_integerknapsack_is_proof_only() {
     ));
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_integerknapsack_to_ilp_is_runtime_witness_edge() {
     let graph = ReductionGraph::new();
@@ -253,26 +352,27 @@ fn test_integerknapsack_to_ilp_is_runtime_witness_edge() {
 fn test_direct_reduction_exists() {
     let graph = ReductionGraph::new();
 
-    assert!(graph.has_direct_reduction::<MaximumIndependentSet<SimpleGraph, i32>, MinimumVertexCover<SimpleGraph, i32>>());
-    assert!(graph.has_direct_reduction::<MinimumVertexCover<SimpleGraph, i32>, MaximumIndependentSet<SimpleGraph, i32>>());
+    assert!(graph.has_direct_reduction::<MaximumIndependentSet<SimpleGraph, i64>, MinimumVertexCover<SimpleGraph, i64>>());
+    assert!(graph.has_direct_reduction::<MinimumVertexCover<SimpleGraph, i64>, MaximumIndependentSet<SimpleGraph, i64>>());
     assert!(graph
-        .has_direct_reduction::<MaximumIndependentSet<SimpleGraph, i32>, MaximumSetPacking<i32>>());
+        .has_direct_reduction::<MaximumIndependentSet<SimpleGraph, i64>, MaximumSetPacking<i64>>());
     assert!(graph.has_direct_reduction::<SpinGlass<SimpleGraph, f64>, QUBO<f64>>());
-    assert!(graph.has_direct_reduction::<SpinGlass<SimpleGraph, f64>, MaxCut<SimpleGraph, i32>>());
+    assert!(graph.has_direct_reduction::<SpinGlass<SimpleGraph, f64>, MaxCut<SimpleGraph, i64>>());
 }
 
 #[test]
 fn test_kcoloring_to_partitionintocliques_smoke() {
     let source = KColoring::<KN, _>::with_k(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), 2);
-    let reduction = ReduceTo::<PartitionIntoCliques<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<PartitionIntoCliques<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     assert_eq!(reduction.target_problem().num_cliques(), 2);
 }
 
 #[test]
 fn test_find_direct_path() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
 
     let paths = graph.find_all_paths("MaximumIndependentSet", &src, "MinimumVertexCover", &dst);
     assert!(!paths.is_empty());
@@ -286,30 +386,21 @@ fn test_find_direct_path() {
 #[test]
 fn test_find_indirect_path() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumSetPacking::<i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumSetPacking::<i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
 
     // MaximumSetPacking -> MaximumIndependentSet -> MinimumVertexCover
     let paths = graph.find_all_paths("MaximumSetPacking", &src, "MinimumVertexCover", &dst);
     assert!(!paths.is_empty());
 
-    let shortest = graph.find_cheapest_path(
-        "MaximumSetPacking",
-        &src,
-        "MinimumVertexCover",
-        &dst,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-    assert!(shortest.is_some());
-    assert_eq!(shortest.unwrap().len(), 2);
+    assert!(paths.iter().any(|path| path.len() == 2));
 }
 
 #[test]
 fn test_no_path_exists() {
     let graph = ReductionGraph::new();
     let src = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
-    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i32>::variant());
+    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i64>::variant());
 
     let paths = graph.find_all_paths("QUBO", &src, "MaximumSetPacking", &dst);
     assert!(paths.is_empty());
@@ -323,15 +414,10 @@ fn test_reduction_path_display() {
     let src_var = ReductionGraph::variant_to_map(&Factoring::variant());
     let dst_var = ReductionGraph::variant_to_map(&SpinGlass::<SimpleGraph, f64>::variant());
     let path = graph
-        .find_cheapest_path(
-            "Factoring",
-            &src_var,
-            "SpinGlass",
-            &dst_var,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .unwrap();
+        .find_all_paths("Factoring", &src_var, "SpinGlass", &dst_var)
+        .into_iter()
+        .find(|path| path.type_names() == ["Factoring", "CircuitSAT", "SpinGlass"])
+        .expect("explicit CircuitSAT route");
 
     let s = format!("{path}");
     // Should contain arrow-separated problem names with variant info
@@ -350,102 +436,6 @@ fn test_reduction_path_display() {
     assert!(last_s.contains("{"));
 }
 
-// ---- Overhead evaluation along a path ----
-
-#[test]
-fn test_3sat_to_mis_triangular_overhead() {
-    use crate::models::formula::CNFClause;
-
-    let graph = ReductionGraph::new();
-
-    let src_var = ReductionGraph::variant_to_map(&KSatisfiability::<K3>::variant());
-    let dst_var = ReductionGraph::variant_to_map(
-        &MaximumIndependentSet::<TriangularSubgraph, i32>::variant(),
-    );
-
-    // 3-SAT instance: 3 variables, 2 clauses, 6 literals
-    let _source = KSatisfiability::<K3>::new(
-        3,
-        vec![
-            CNFClause::new(vec![1, 2, 3]),
-            CNFClause::new(vec![-1, -2, -3]),
-        ],
-    );
-    let input_size = ProblemSize::new(vec![
-        ("num_vars", 3),
-        ("num_clauses", 2),
-        ("num_literals", 6),
-    ]);
-
-    // Find the shortest path
-    let path = graph
-        .find_cheapest_path(
-            "KSatisfiability",
-            &src_var,
-            "MaximumIndependentSet",
-            &dst_var,
-            &input_size,
-            &MinimizeSteps,
-        )
-        .expect("Should find path from 3-SAT to MIS on triangular lattice");
-
-    // Path: K3SAT → KN_SAT (cast) → SAT → MIS{SimpleGraph,One} → MIS{TriangularSubgraph,i32}
-    assert_eq!(
-        path.type_names(),
-        vec!["KSatisfiability", "Satisfiability", "MaximumIndependentSet"]
-    );
-    assert_eq!(path.len(), 4);
-
-    // Per-edge symbolic overheads
-    let edges = graph.path_overheads(&path);
-    assert_eq!(edges.len(), 4);
-
-    // Evaluate overheads at a test point to verify correctness
-    let test_size = ProblemSize::new(vec![
-        ("num_vars", 3),
-        ("num_clauses", 2),
-        ("num_literals", 6),
-        ("num_vertices", 10),
-        ("num_edges", 15),
-    ]);
-
-    // Edge 0: K3SAT → KN_SAT (variant cast, identity for num_vars + num_clauses)
-    assert_eq!(edges[0].get("num_vars").unwrap().eval(&test_size), 3.0);
-    assert_eq!(edges[0].get("num_clauses").unwrap().eval(&test_size), 2.0);
-
-    // Edge 1: KN_SAT → SAT (identity)
-    assert_eq!(edges[1].get("num_vars").unwrap().eval(&test_size), 3.0);
-    assert_eq!(edges[1].get("num_clauses").unwrap().eval(&test_size), 2.0);
-    assert_eq!(edges[1].get("num_literals").unwrap().eval(&test_size), 6.0);
-
-    // Edge 2: SAT → MIS{SimpleGraph,One}
-    // num_vertices = num_literals, num_edges = num_literals^2
-    assert_eq!(edges[2].get("num_vertices").unwrap().eval(&test_size), 6.0);
-    assert_eq!(edges[2].get("num_edges").unwrap().eval(&test_size), 36.0);
-
-    // Edge 3: MIS{SimpleGraph,One} → MIS{TriangularSubgraph,i32}
-    // num_vertices = num_vertices², num_edges = num_vertices²
-    assert_eq!(
-        edges[3].get("num_vertices").unwrap().eval(&test_size),
-        100.0
-    );
-    assert_eq!(edges[3].get("num_edges").unwrap().eval(&test_size), 100.0);
-
-    // Compose overheads symbolically along the path.
-    // The composed overhead maps 3-SAT input variables to final MIS{Triangular} output.
-    //
-    // K3SAT → KN_SAT:      {num_clauses: C, num_vars: V, num_literals: L}  (identity cast)
-    // KN_SAT → SAT:         {num_clauses: C, num_vars: V, num_literals: L}  (identity)
-    // SAT → MIS{SG,One}:    {num_vertices: L, num_edges: L²}
-    // MIS{SG,One→Tri}:      {num_vertices: V², num_edges: V²}
-    //
-    // Composed: num_vertices = L², num_edges = L²
-    let composed = graph.compose_path_overhead(&path);
-    // Evaluate composed at input: L=6, so L²=36
-    assert_eq!(composed.get("num_vertices").unwrap().eval(&test_size), 36.0);
-    assert_eq!(composed.get("num_edges").unwrap().eval(&test_size), 36.0);
-}
-
 // ---- k-neighbor BFS ----
 
 #[test]
@@ -586,8 +576,8 @@ fn default_variant_for_mvc_uses_declared_default() {
     );
     assert_eq!(
         variant.get("weight").map(|s| s.as_str()),
-        Some("i32"),
-        "default MVC variant should use i32"
+        Some("i64"),
+        "default MVC variant should use i64"
     );
 }
 
@@ -602,8 +592,8 @@ fn default_variant_for_qubo_uses_declared_default() {
     let variant = default.unwrap();
     assert_eq!(
         variant.get("weight").map(|s| s.as_str()),
-        Some("f64"),
-        "default QUBO variant should use f64"
+        Some("i64"),
+        "default QUBO variant should use i64"
     );
 }
 
@@ -643,7 +633,7 @@ fn default_variant_for_sat_returns_empty() {
 #[test]
 fn find_paths_up_to_stops_after_limit() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
     let dst = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
 
     // Get all paths to know the total count
@@ -660,11 +650,40 @@ fn find_paths_up_to_stops_after_limit() {
     );
 }
 
+#[test]
+fn find_paths_up_to_matches_sorted_exhaustive_prefixes() {
+    let graph = ReductionGraph::new();
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
+    let mut all = graph.find_all_paths("MaximumIndependentSet", &src, "QUBO", &dst);
+    all.sort_by(|left, right| {
+        left.len().cmp(&right.len()).then_with(|| {
+            left.steps
+                .iter()
+                .map(|step| (&step.name, &step.variant))
+                .cmp(right.steps.iter().map(|step| (&step.name, &step.variant)))
+        })
+    });
+
+    for limit in 1..=all.len() {
+        let limited = graph.find_paths_up_to("MaximumIndependentSet", &src, "QUBO", &dst, limit);
+        let actual = limited
+            .iter()
+            .map(|path| path.steps.clone())
+            .collect::<Vec<_>>();
+        let expected = all[..limit]
+            .iter()
+            .map(|path| path.steps.clone())
+            .collect::<Vec<_>>();
+        assert_eq!(actual, expected, "wrong prefix for limit {limit}");
+    }
+}
+
 #[test]
 fn find_paths_up_to_returns_all_when_limit_exceeds_total() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
 
     let all = graph.find_all_paths("MaximumIndependentSet", &src, "MinimumVertexCover", &dst);
     let limited = graph.find_paths_up_to(
@@ -685,25 +704,42 @@ fn find_paths_up_to_returns_all_when_limit_exceeds_total() {
 fn find_paths_up_to_no_path() {
     let graph = ReductionGraph::new();
     let src = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
-    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i32>::variant());
+    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i64>::variant());
 
     let limited = graph.find_paths_up_to("QUBO", &src, "MaximumSetPacking", &dst, 10);
     assert!(limited.is_empty());
 }
 
+#[test]
+fn find_paths_up_to_same_source_has_no_zero_edge_path() {
+    let graph = ReductionGraph::new();
+    let variant =
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+
+    let paths = graph.find_paths_up_to(
+        "MaximumIndependentSet",
+        &variant,
+        "MaximumIndependentSet",
+        &variant,
+        10,
+    );
+
+    assert!(paths.is_empty());
+}
+
 // ---- Exact source+target variant matching ----
 
 #[test]
-fn find_best_entry_rejects_wrong_target_variant() {
+fn find_entry_rejects_wrong_target_variant() {
     let graph = ReductionGraph::new();
     let source =
-        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    // MIS<SG,i32> -> MVC<SG,i32> exists, but MVC<SG,f64> does not
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    // MIS<SG,i64> -> MVC<SG,i64> exists, but MVC<SG,f64> does not
     let wrong_target = BTreeMap::from([
         ("graph".to_string(), "SimpleGraph".to_string()),
         ("weight".to_string(), "f64".to_string()),
     ]);
-    let result = graph.find_best_entry(
+    let result = graph.find_entry(
         "MaximumIndependentSet",
         &source,
         "MinimumVertexCover",
@@ -713,12 +749,12 @@ fn find_best_entry_rejects_wrong_target_variant() {
 }
 
 #[test]
-fn find_best_entry_accepts_exact_source_and_target_variant() {
+fn find_entry_accepts_exact_source_and_target_variant() {
     let graph = ReductionGraph::new();
     let source =
-        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let target = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
-    let result = graph.find_best_entry(
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let target = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
+    let result = graph.find_entry(
         "MaximumIndependentSet",
         &source,
         "MinimumVertexCover",
@@ -736,7 +772,7 @@ fn test_has_direct_reduction_mode_witness() {
 
     // MIS -> MVC is witness-only, so Witness mode should find it
     assert!(graph
-        .has_direct_reduction_mode::<MaximumIndependentSet<SimpleGraph, i32>, MinimumVertexCover<SimpleGraph, i32>>(
+        .has_direct_reduction_mode::<MaximumIndependentSet<SimpleGraph, i64>, MinimumVertexCover<SimpleGraph, i64>>(
             ReductionMode::Witness,
         ));
 }
@@ -781,7 +817,6 @@ fn test_minimumvertexcover_to_minimummaximalmatching_is_proof_only_direct_edge()
     ));
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_minimumcoveringbycliques_to_ilp_is_runtime_witness_edge() {
     let graph = ReductionGraph::new();
@@ -796,8 +831,8 @@ fn test_minimumcoveringbycliques_to_ilp_is_runtime_witness_edge() {
 #[test]
 fn test_find_all_paths_mode_witness() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
 
     let paths = graph.find_all_paths_mode(
         "MaximumIndependentSet",
@@ -812,8 +847,8 @@ fn test_find_all_paths_mode_witness() {
 #[test]
 fn test_find_all_paths_mode_aggregate_rejects_witness_only() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
 
     // MIS -> MVC is witness-only, so aggregate mode should find no paths
     let paths = graph.find_all_paths_mode(
@@ -859,14 +894,15 @@ fn test_decision_minimum_dominating_set_has_both_edges() {
 }
 
 #[test]
-fn test_decision_minimum_dominating_set_to_minmax_multicenter_has_direct_witness_edge() {
+fn test_decision_minimum_dominating_set_to_minmax_multicenter_has_direct_witness_and_aggregate_edges(
+) {
     let graph = ReductionGraph::new();
 
     assert!(graph.has_direct_reduction_mode::<
         Decision<MinimumDominatingSet<SimpleGraph, One>>,
         MinMaxMulticenter<SimpleGraph, One>,
     >(ReductionMode::Witness));
-    assert!(!graph.has_direct_reduction_mode::<
+    assert!(graph.has_direct_reduction_mode::<
         Decision<MinimumDominatingSet<SimpleGraph, One>>,
         MinMaxMulticenter<SimpleGraph, One>,
     >(ReductionMode::Aggregate));
@@ -874,23 +910,53 @@ fn test_decision_minimum_dominating_set_to_minmax_multicenter_has_direct_witness
         Decision<MinimumDominatingSet<SimpleGraph, One>>,
         MinMaxMulticenter<SimpleGraph, One>,
     >(ReductionMode::Turing));
+    let entries = crate::rules::registry::reduction_entries();
+    let variant = Decision::<MinimumDominatingSet<SimpleGraph, One>>::variant();
+    let edge = entries
+        .iter()
+        .find(|e| {
+            e.source_name == "DecisionMinimumDominatingSet"
+                && e.target_name == "MinMaxMulticenter"
+                && (e.source_variant_fn)() == variant
+                && (e.target_variant_fn)() == variant
+        })
+        .unwrap();
+    for (bound, witness, expected) in [
+        (1, vec![false, true, false, false, true, true], false),
+        (2, vec![false, true, true, false, true, true], true),
+    ] {
+        let source = Decision::new(
+            MinimumDominatingSet::new(SimpleGraph::path(4), vec![One; 4]),
+            bound,
+        );
+        let aggregate = (edge.reduce_aggregate_fn.unwrap())(&source).unwrap();
+        assert_eq!(
+            *aggregate
+                .extract_value_from_solution_dyn(&witness)
+                .unwrap()
+                .downcast::<Or>()
+                .unwrap(),
+            Or(expected)
+        );
+    }
 }
 
 #[test]
-fn test_decision_minimum_dominating_set_to_minimum_sum_multicenter_has_direct_witness_edge() {
+fn test_decision_minimum_dominating_set_to_minimum_sum_multicenter_has_direct_witness_and_aggregate_edges(
+) {
     let graph = ReductionGraph::new();
 
     assert!(graph.has_direct_reduction_mode::<
         Decision<MinimumDominatingSet<SimpleGraph, One>>,
-        MinimumSumMulticenter<SimpleGraph, i32>,
+        MinimumSumMulticenter<SimpleGraph, i64>,
     >(ReductionMode::Witness));
-    assert!(!graph.has_direct_reduction_mode::<
+    assert!(graph.has_direct_reduction_mode::<
         Decision<MinimumDominatingSet<SimpleGraph, One>>,
-        MinimumSumMulticenter<SimpleGraph, i32>,
+        MinimumSumMulticenter<SimpleGraph, i64>,
     >(ReductionMode::Aggregate));
     assert!(!graph.has_direct_reduction_mode::<
         Decision<MinimumDominatingSet<SimpleGraph, One>>,
-        MinimumSumMulticenter<SimpleGraph, i32>,
+        MinimumSumMulticenter<SimpleGraph, i64>,
     >(ReductionMode::Turing));
 }
 
@@ -929,22 +995,22 @@ fn test_ksatisfiability_k3_to_decision_minimum_vertex_cover_direct_witness_edge(
 
     assert!(graph.has_direct_reduction_mode::<
         KSatisfiability<K3>,
-        Decision<MinimumVertexCover<SimpleGraph, i32>>,
+        Decision<MinimumVertexCover<SimpleGraph, i64>>,
     >(ReductionMode::Witness));
     assert!(!graph.has_direct_reduction_mode::<
         KSatisfiability<K3>,
-        Decision<MinimumVertexCover<SimpleGraph, i32>>,
+        Decision<MinimumVertexCover<SimpleGraph, i64>>,
     >(ReductionMode::Aggregate));
     assert!(!graph.has_direct_reduction_mode::<
         KSatisfiability<K3>,
-        Decision<MinimumVertexCover<SimpleGraph, i32>>,
+        Decision<MinimumVertexCover<SimpleGraph, i64>>,
     >(ReductionMode::Turing));
 }
 
 #[test]
 fn test_find_paths_bounded_limits_depth() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
     let dst = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
 
     // With tight bound, should find fewer (or no) paths than unbounded
@@ -988,3 +1054,80 @@ fn test_find_paths_bounded_limits_depth() {
         "MIS→QUBO has no direct edge, so bound=0 should return empty"
     );
 }
+
+#[test]
+fn test_find_paths_bounded_returns_shortest_when_truncated() {
+    use crate::expr::Expr;
+    use crate::rules::registry::{ReductionParameterContract, ReductionParameterDeclarations};
+    use crate::rules::ReductionEdgeData;
+
+    fn edge() -> ReductionEdgeData {
+        fn reduce(
+            _source: &dyn std::any::Any,
+        ) -> std::result::Result<
+            Box<dyn crate::rules::DynReductionResult>,
+            crate::rules::ReductionError,
+        > {
+            Ok(Box::new(crate::rules::VariantReductionResult::<
+                crate::models::formula::Satisfiability,
+                crate::models::formula::Satisfiability,
+            >::new(
+                crate::models::formula::Satisfiability::new(0, vec![]),
+            )))
+        }
+
+        ReductionEdgeData {
+            parameter_contract: ReductionParameterContract::new(
+                "synthetic edge",
+                ReductionParameterDeclarations {
+                    relation: Some(crate::parameters::ParameterRelation::Exact),
+                    fields: vec![("n", Expr::variable("n"))],
+                    unavailable: vec![],
+                },
+            ),
+            reduce_fn: Some(reduce),
+            reduce_aggregate_fn: None,
+            turing: false,
+        }
+    }
+
+    // Topology where DFS discovery order surfaces a LONG route before the SHORT one.
+    // From S the first outgoing edge (S->A) leads into a long chain A->B->C->T, while a
+    // later edge S->T is a direct hop. petgraph's DFS explores S->A first, so the
+    // 4-edge route is discovered before the 1-edge direct route. With a tight limit,
+    // the old `.take(limit)` in discovery order would keep the long route and drop the
+    // short one; length-first enumeration must return the short route.
+    let graph = ReductionGraph::from_test_edges(
+        &["S", "A", "B", "C", "T"],
+        &[
+            ("S", "A", edge()),
+            ("A", "B", edge()),
+            ("B", "C", edge()),
+            ("C", "T", edge()),
+            ("S", "T", edge()),
+        ],
+    );
+
+    let empty = BTreeMap::new();
+
+    // Sanity: both routes exist when unbounded.
+    let all = graph.find_paths_up_to("S", &empty, "T", &empty, 100);
+    assert_eq!(all.len(), 2, "expected the direct route and the long chain");
+
+    // With limit 1, the SHORT (direct) route must be the one returned.
+    let limited = graph.find_paths_up_to("S", &empty, "T", &empty, 1);
+    assert_eq!(limited.len(), 1);
+    assert_eq!(
+        limited[0].len(),
+        1,
+        "truncated result must keep the shortest (direct) route, not the long chain"
+    );
+
+    // Results are length-sorted (non-decreasing edge counts).
+    let lens: Vec<usize> = all.iter().map(|p| p.len()).collect();
+    assert!(
+        lens.windows(2).all(|w| w[0] <= w[1]),
+        "paths must be returned shortest-first, got lengths {lens:?}"
+    );
+    assert_eq!(lens, vec![1, 4]);
+}
diff --git a/src/unit_tests/registry/dispatch.rs b/src/unit_tests/registry/dispatch.rs
index 471d6f957..2291f949d 100644
--- a/src/unit_tests/registry/dispatch.rs
+++ b/src/unit_tests/registry/dispatch.rs
@@ -3,47 +3,44 @@ use crate::models::graph::MinimumVertexCover;
 use crate::models::misc::SubsetSum;
 use crate::registry::variant::find_variant_entry;
 use crate::registry::{load_dyn, serialize_any, DynProblem, LoadedDynProblem};
+use crate::solvers::{brute_force_dimensions, solve, SolveOutcome, SolverRequest};
 use crate::topology::SimpleGraph;
-use crate::types::Sum;
-use crate::{Problem, Solver};
+use crate::types::{Max, Sum};
+use crate::Problem;
 use std::any::Any;
 use std::collections::BTreeMap;
 
-fn solve_subset_sum_value(any: &dyn Any) -> String {
-    let p = any.downcast_ref::<SubsetSum>().unwrap();
-    if let Some(config) = crate::BruteForce::new().find_witness(p) {
-        format!("{:?}", p.evaluate(&config))
-    } else {
-        "false".to_string()
-    }
-}
-
-fn solve_subset_sum_witness(any: &dyn Any) -> Option<(Vec<usize>, String)> {
-    let p = any.downcast_ref::<SubsetSum>()?;
-    let config = crate::BruteForce::new().find_witness(p)?;
-    let eval = format!("{:?}", p.evaluate(&config));
-    Some((config, eval))
-}
-
-#[derive(Clone, serde::Serialize)]
-struct AggregateOnlyProblem {
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
+struct SolutionProblem {
     weights: Vec<u64>,
 }
 
-impl Problem for AggregateOnlyProblem {
-    const NAME: &'static str = "AggregateOnlyProblem";
-    type Value = Sum<u64>;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.weights.len()]
+impl SolutionProblem {
+    fn num_variables(&self) -> usize {
+        self.weights.len()
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Sum(config
-            .iter()
-            .zip(&self.weights)
-            .map(|(&c, &w)| if c == 1 { w } else { 0 })
-            .sum())
+impl Problem for SolutionProblem {
+    const NAME: &'static str = "SolutionProblem";
+    type Solution = Vec<usize>;
+    type Value = Max<u64>;
+
+    crate::problem_parameters![("num_variables", num_variables)];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok({
+            Max(Some(
+                config
+                    .iter()
+                    .zip(&self.weights)
+                    .map(|(&c, &w)| if c == 1 { w } else { 0 })
+                    .sum(),
+            ))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -51,73 +48,139 @@ impl Problem for AggregateOnlyProblem {
     }
 }
 
-fn solve_aggregate_value(any: &dyn Any) -> String {
-    let p = any.downcast_ref::<AggregateOnlyProblem>().unwrap();
-    format!("{:?}", crate::BruteForce::new().solve(p))
+impl crate::solvers::BruteForceProblem for SolutionProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.weights.len()]
+    }
+}
+
+crate::declare_variants! {
+    default SolutionProblem => "2^num_variables",
+}
+
+crate::register_brute_force! {
+    SolutionProblem decode |_, indices: Vec<usize>| indices,
 }
 
-fn solve_aggregate_witness(_: &dyn Any) -> Option<(Vec<usize>, String)> {
-    None
+inventory::submit! {
+    crate::registry::ProblemSchemaEntry {
+        name: "SolutionProblem",
+        display_name: "Solution Test Problem",
+        aliases: &[],
+        dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
+        module_path: module_path!(),
+        description: "Test problem for solution-producing reference solving",
+        fields: &[],
+    }
 }
 
 #[test]
 fn test_dyn_problem_blanket_impl_exposes_problem_metadata() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let dyn_problem: &dyn DynProblem = &problem;
 
     assert_eq!(dyn_problem.problem_name(), "MaximumIndependentSet");
-    assert_eq!(dyn_problem.num_variables_dyn(), 3);
-    assert_eq!(dyn_problem.dims_dyn(), vec![2, 2, 2]);
     assert_eq!(dyn_problem.variant_map()["graph"], "SimpleGraph");
+    assert_eq!(
+        dyn_problem.parameter_names_dyn(),
+        MaximumIndependentSet::<SimpleGraph, i64>::parameter_names()
+    );
+    assert_eq!(dyn_problem.parameters_dyn(), problem.parameters());
+    assert_eq!(problem.parameters().get("num_vertices"), Some(3));
+    assert_eq!(problem.parameters().get("num_edges"), Some(1));
     assert!(dyn_problem.serialize_json().is_object());
 }
 
 #[test]
 fn test_dyn_problem_formats_optimization_values_as_max_min() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let dyn_problem: &dyn DynProblem = &problem;
 
-    assert_eq!(dyn_problem.evaluate_dyn(&[1, 0, 1]), "Max(2)");
-    assert_eq!(dyn_problem.evaluate_dyn(&[1, 1, 0]), "Max(None)");
+    assert_eq!(
+        dyn_problem
+            .evaluate_dyn(&serde_json::json!([true, false, true]))
+            .unwrap(),
+        "Max(2)"
+    );
+    assert_eq!(
+        dyn_problem
+            .evaluate_dyn(&serde_json::json!([true, true, false]))
+            .unwrap(),
+        "Max(None)"
+    );
 }
 
 #[test]
-fn test_loaded_dyn_problem_delegates_to_value_and_witness_fns() {
-    let problem = SubsetSum::new(vec![3u32, 7u32, 1u32], 4u32);
-    let loaded = LoadedDynProblem::new(
-        Box::new(problem),
-        solve_subset_sum_value,
-        solve_subset_sum_witness,
+fn test_dyn_witness_evaluation_distinguishes_infeasibility_and_malformed_input() {
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
+    let dyn_problem: &dyn DynProblem = &problem;
+    assert_eq!(
+        dyn_problem
+            .evaluate_witness_dyn(&serde_json::json!([true, false, true]))
+            .unwrap(),
+        Some("Max(2)".into())
     );
-
-    assert_eq!(loaded.solve_brute_force_value(), "Or(true)");
-    let solved = loaded
-        .solve_brute_force_witness()
-        .expect("expected satisfying solution");
-    assert_eq!(solved.1, "Or(true)");
-    assert_eq!(solved.0.len(), 3);
+    assert_eq!(
+        dyn_problem
+            .evaluate_witness_dyn(&serde_json::json!([true, true, false]))
+            .unwrap(),
+        None
+    );
+    assert!(dyn_problem
+        .evaluate_witness_dyn(&serde_json::json!([true]))
+        .is_err());
+    assert!(dyn_problem
+        .evaluate_witness_dyn(&serde_json::json!([0, 0, 0]))
+        .is_err());
 }
 
 #[test]
-fn loaded_dyn_problem_returns_none_for_aggregate_only_witness() {
-    let loaded = LoadedDynProblem::new(
-        Box::new(AggregateOnlyProblem {
-            weights: vec![1, 2, 4],
-        }),
-        solve_aggregate_value,
-        solve_aggregate_witness,
+fn test_loaded_dyn_problem_delegates_to_solve_fn() {
+    let problem = SubsetSum::new(vec![3u32, 7u32, 1u32], 4u32);
+    let loaded = LoadedDynProblem::new(Box::new(problem));
+
+    assert_eq!(
+        brute_force_dimensions(&loaded).unwrap(),
+        Some(vec![2, 2, 2])
     );
+    let solved = solve(&loaded, SolverRequest::BruteForce).unwrap();
+    let SolveOutcome::Optimal {
+        solution,
+        evaluation,
+    } = solved.outcome
+    else {
+        panic!("expected satisfying solution");
+    };
+    assert_eq!(evaluation, "Or(true)");
+    assert_eq!(solution.as_array().unwrap().len(), 3);
+}
 
-    assert_eq!(loaded.solve_brute_force_value(), "Sum(28)");
-    assert!(loaded.solve_brute_force_witness().is_none());
+#[test]
+fn loaded_dyn_problem_returns_solution_and_evaluation() {
+    let problem = SolutionProblem {
+        weights: vec![1, 2, 4],
+    };
+    let loaded = LoadedDynProblem::new(Box::new(problem));
+
+    let solved = solve(&loaded, SolverRequest::BruteForce).unwrap();
+    let SolveOutcome::Optimal {
+        solution,
+        evaluation,
+    } = solved.outcome
+    else {
+        panic!("expected optimal solution");
+    };
+    assert_eq!(solution, serde_json::json!([1, 1, 1]));
+    assert_eq!(evaluation, "Max(7)");
 }
 
 #[test]
 fn test_load_dyn_formats_optimization_solve_values_as_max_min() {
-    let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
+    let problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
     let variant = BTreeMap::from([
         ("graph".to_string(), "SimpleGraph".to_string()),
-        ("weight".to_string(), "i32".to_string()),
+        ("weight".to_string(), "i64".to_string()),
     ]);
     let loaded = load_dyn(
         "MinimumVertexCover",
@@ -126,9 +189,11 @@ fn test_load_dyn_formats_optimization_solve_values_as_max_min() {
     )
     .unwrap();
 
-    assert_eq!(loaded.solve_brute_force_value(), "Min(1)");
-    let solved = loaded.solve_brute_force_witness().unwrap();
-    assert_eq!(solved.1, "Min(1)");
+    let solved = solve(&loaded, SolverRequest::BruteForce).unwrap();
+    let SolveOutcome::Optimal { evaluation, .. } = solved.outcome else {
+        panic!("expected optimal solution");
+    };
+    assert_eq!(evaluation, "Min(1)");
 }
 
 #[test]
@@ -139,10 +204,10 @@ fn test_find_variant_entry_requires_exact_variant() {
 
 #[test]
 fn test_load_dyn_round_trips_maximum_independent_set() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let variant = BTreeMap::from([
         ("graph".to_string(), "SimpleGraph".to_string()),
-        ("weight".to_string(), "i32".to_string()),
+        ("weight".to_string(), "i64".to_string()),
     ]);
     let loaded = load_dyn(
         "MaximumIndependentSet",
@@ -156,8 +221,10 @@ fn test_load_dyn_round_trips_maximum_independent_set() {
         loaded.serialize_json(),
         serde_json::to_value(&problem).unwrap()
     );
-    assert!(!loaded.solve_brute_force_value().is_empty());
-    assert!(loaded.solve_brute_force_witness().is_some());
+    assert!(matches!(
+        solve(&loaded, SolverRequest::BruteForce).unwrap().outcome,
+        SolveOutcome::Optimal { .. }
+    ));
 }
 
 #[test]
@@ -171,14 +238,16 @@ fn test_load_dyn_solves_subset_sum() {
     )
     .unwrap();
 
-    assert_eq!(loaded.solve_brute_force_value(), "Or(true)");
-    let solved = loaded.solve_brute_force_witness().unwrap();
-    assert_eq!(solved.1, "Or(true)");
+    let solved = solve(&loaded, SolverRequest::BruteForce).unwrap();
+    let SolveOutcome::Optimal { evaluation, .. } = solved.outcome else {
+        panic!("expected satisfying solution");
+    };
+    assert_eq!(evaluation, "Or(true)");
 }
 
 #[test]
 fn test_load_dyn_rejects_partial_variant() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let partial = BTreeMap::from([("graph".to_string(), "SimpleGraph".to_string())]);
     let err = load_dyn(
         "MaximumIndependentSet",
@@ -187,25 +256,25 @@ fn test_load_dyn_rejects_partial_variant() {
     )
     .unwrap_err();
 
-    assert!(err.contains("MaximumIndependentSet"));
+    assert!(err.to_string().contains("MaximumIndependentSet"));
 }
 
 #[test]
 fn test_load_dyn_rejects_alias_name() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let variant = BTreeMap::from([
         ("graph".to_string(), "SimpleGraph".to_string()),
-        ("weight".to_string(), "i32".to_string()),
+        ("weight".to_string(), "i64".to_string()),
     ]);
     assert!(load_dyn("MIS", &variant, serde_json::to_value(&problem).unwrap()).is_err());
 }
 
 #[test]
 fn test_serialize_any_round_trips_exact_variant() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let variant = BTreeMap::from([
         ("graph".to_string(), "SimpleGraph".to_string()),
-        ("weight".to_string(), "i32".to_string()),
+        ("weight".to_string(), "i64".to_string()),
     ]);
     let json = serialize_any("MaximumIndependentSet", &variant, &problem as &dyn Any).unwrap();
     assert_eq!(json, serde_json::to_value(&problem).unwrap());
@@ -213,7 +282,7 @@ fn test_serialize_any_round_trips_exact_variant() {
 
 #[test]
 fn test_serialize_any_rejects_partial_variant() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let partial = BTreeMap::from([("graph".to_string(), "SimpleGraph".to_string())]);
     assert!(serialize_any("MaximumIndependentSet", &partial, &problem as &dyn Any).is_none());
 }
@@ -223,39 +292,18 @@ fn test_format_metric_uses_display() {
     use crate::registry::dyn_problem::format_metric;
     use crate::types::{Max, Min, Or};
     assert_eq!(format_metric(&Max(Some(42))), "Max(42)");
-    assert_eq!(format_metric(&Max::<i32>(None)), "Max(None)");
+    assert_eq!(format_metric(&Max::<i64>(None)), "Max(None)");
     assert_eq!(format_metric(&Min(Some(7))), "Min(7)");
     assert_eq!(format_metric(&Or(true)), "Or(true)");
     assert_eq!(format_metric(&Sum(99u64)), "Sum(99)");
 }
 
-#[test]
-fn test_loaded_dyn_problem_backward_compat_solve() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
-    let variant = BTreeMap::from([
-        ("graph".to_string(), "SimpleGraph".to_string()),
-        ("weight".to_string(), "i32".to_string()),
-    ]);
-    let loaded = load_dyn(
-        "MaximumIndependentSet",
-        &variant,
-        serde_json::to_value(&problem).unwrap(),
-    )
-    .unwrap();
-    // solve_brute_force() is the backward-compatible alias for solve_brute_force_witness()
-    let result = loaded.solve_brute_force();
-    assert!(result.is_some());
-    let (config, eval) = result.unwrap();
-    assert!(!config.is_empty());
-    assert!(eval.starts_with("Max("));
-}
-
 #[test]
 fn test_loaded_dyn_problem_debug() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
     let variant = BTreeMap::from([
         ("graph".to_string(), "SimpleGraph".to_string()),
-        ("weight".to_string(), "i32".to_string()),
+        ("weight".to_string(), "i64".to_string()),
     ]);
     let loaded = load_dyn(
         "MaximumIndependentSet",
@@ -267,3 +315,105 @@ fn test_loaded_dyn_problem_debug() {
     assert!(debug.contains("LoadedDynProblem"));
     assert!(debug.contains("MaximumIndependentSet"));
 }
+
+#[test]
+fn explicit_independent_set_variants_round_trip_through_standard_api() {
+    for (graph, weight) in [
+        ("SimpleGraph", "One"),
+        ("SimpleGraph", "i64"),
+        ("SimpleGraph", "f64"),
+        ("KingsSubgraph", "One"),
+        ("KingsSubgraph", "i64"),
+        ("TriangularSubgraph", "i64"),
+        ("UnitDiskGraph", "One"),
+        ("UnitDiskGraph", "i64"),
+    ] {
+        let variant = BTreeMap::from([
+            ("graph".into(), graph.into()),
+            ("weight".into(), weight.into()),
+        ]);
+        let base = if graph == "SimpleGraph" {
+            serde_json::json!({"graph": [[0,1],[1,2]], "num_vertices": 3})
+        } else {
+            serde_json::json!({"positions": [[0,0],[1,0],[2,0]]})
+        };
+        for explicit in [false, true]
+            .into_iter()
+            .filter(|&explicit| !explicit || weight != "One")
+        {
+            let mut input = base.clone();
+            if explicit {
+                input["weights"] = match weight {
+                    "i64" => serde_json::json!([1, 5, 2]),
+                    "f64" => serde_json::json!([0.5, 2.5, 0.75]),
+                    _ => unreachable!(),
+                };
+            }
+            let problem =
+                crate::registry::construct_dyn("MaximumIndependentSet", &variant, input).unwrap();
+            let loaded =
+                load_dyn("MaximumIndependentSet", &variant, problem.serialize_json()).unwrap();
+            for backend in [SolverRequest::Default, SolverRequest::BruteForce] {
+                let result = solve(&loaded, backend).unwrap();
+                let SolveOutcome::Optimal {
+                    evaluation,
+                    solution,
+                } = result.outcome
+                else {
+                    panic!("expected optimum")
+                };
+                let expected = if !explicit || weight == "One" {
+                    "Max(2)"
+                } else if weight == "i64" {
+                    "Max(5)"
+                } else {
+                    "Max(2.5)"
+                };
+                assert_eq!(evaluation, expected, "{variant:?}");
+                assert_eq!(loaded.evaluate_dyn(&solution).unwrap(), expected);
+            }
+        }
+        let mut bad = base.clone();
+        bad["weights"] = serde_json::json!([1]);
+        assert!(crate::registry::construct_dyn("MaximumIndependentSet", &variant, bad).is_err());
+        let empty = if graph == "SimpleGraph" {
+            serde_json::json!({"graph": [], "num_vertices": 0})
+        } else {
+            serde_json::json!({"positions": []})
+        };
+        assert!(crate::registry::construct_dyn("MaximumIndependentSet", &variant, empty).is_ok());
+    }
+}
+
+#[test]
+fn registered_weight_variants_reject_invalid_graphs_and_witnesses() {
+    for (name, weight) in [
+        ("MaximumIndependentSet", "One"),
+        ("MaximumIndependentSet", "i64"),
+        ("MaximumIndependentSet", "f64"),
+        ("MaxCut", "One"),
+        ("MaxCut", "i64"),
+    ] {
+        let variant = BTreeMap::from([
+            ("graph".into(), "SimpleGraph".into()),
+            ("weight".into(), weight.into()),
+        ]);
+        for input in [
+            serde_json::json!({"graph": []}),
+            serde_json::json!({"graph": [[0,0]]}),
+            serde_json::json!({"graph": [[0,1]], "num_vertices": 1}),
+            serde_json::json!({"graph": [[0,usize::MAX]]}),
+        ] {
+            assert!(crate::registry::construct_dyn(name, &variant, input).is_err());
+        }
+        let problem =
+            crate::registry::construct_dyn(name, &variant, serde_json::json!({"graph": [[0,1]]}))
+                .unwrap();
+        for witness in [
+            serde_json::json!([false]),
+            serde_json::json!([false, false, false]),
+        ] {
+            assert!(problem.evaluate_dyn(&witness).is_err());
+        }
+    }
+}
diff --git a/src/unit_tests/registry/problem_type.rs b/src/unit_tests/registry/problem_type.rs
index 6ca8cfdb3..3e8744cc4 100644
--- a/src/unit_tests/registry/problem_type.rs
+++ b/src/unit_tests/registry/problem_type.rs
@@ -1,20 +1,20 @@
 use crate::registry::{
     find_problem_type, find_problem_type_by_alias, parse_catalog_problem_ref, problem_types,
-    ProblemRef, ProblemSchemaEntry,
+    ProblemCategory, ProblemRef, ProblemSchemaEntry,
 };
-use std::collections::HashMap;
+use std::collections::{BTreeSet, HashMap};
 
 #[test]
 fn typed_problem_ref_fills_declared_defaults() {
     let problem = find_problem_type("MaximumIndependentSet").unwrap();
-    let problem_ref = ProblemRef::from_values(&problem, ["i32"]).unwrap();
+    let problem_ref = ProblemRef::from_values(&problem, ["i64"]).unwrap();
     assert_eq!(
         problem_ref.variant().get("graph").map(|s| s.as_str()),
         Some("SimpleGraph")
     );
     assert_eq!(
         problem_ref.variant().get("weight").map(|s| s.as_str()),
-        Some("i32")
+        Some("i64")
     );
 }
 
@@ -23,7 +23,7 @@ fn catalog_rejects_unknown_dimension_values() {
     let problem = find_problem_type("MaximumIndependentSet").unwrap();
     let err = ProblemRef::from_values(&problem, ["HyperGraph"]).unwrap_err();
     assert!(
-        err.contains("Known variants"),
+        err.to_string().contains("Known variants"),
         "error should mention known variants: {err}"
     );
 }
@@ -66,6 +66,43 @@ fn problem_types_returns_all_registered() {
         .any(|t| t.canonical_name == "MaximumIndependentSet"));
 }
 
+#[test]
+fn problem_category_comes_from_explicit_schema_metadata() {
+    assert_eq!(
+        find_problem_type("QUBO").unwrap().category,
+        ProblemCategory::Algebraic
+    );
+    assert_eq!(
+        find_problem_type("KSatisfiability").unwrap().category,
+        ProblemCategory::Formula
+    );
+    assert_eq!(
+        find_problem_type("MaximumClique").unwrap().category,
+        ProblemCategory::Graph
+    );
+    assert_eq!(
+        find_problem_type("JobShopScheduling").unwrap().category,
+        ProblemCategory::Misc
+    );
+    assert_eq!(
+        find_problem_type("MinimumSetCovering").unwrap().category,
+        ProblemCategory::Set
+    );
+
+    static MISMATCHED_PATH_SCHEMA: ProblemSchemaEntry = ProblemSchemaEntry {
+        name: "ExplicitCategoryTest",
+        display_name: "Explicit category test",
+        aliases: &[],
+        dimensions: &[],
+        category: ProblemCategory::Set,
+        module_path: "problemreductions::models::graph::explicit_category_test",
+        description: "Test fixture",
+        fields: &[],
+    };
+    let problem = super::ProblemType::from_entry(&MISMATCHED_PATH_SCHEMA);
+    assert_eq!(problem.category, ProblemCategory::Set);
+}
+
 #[test]
 fn problem_ref_from_values_no_values_uses_all_defaults() {
     let problem = find_problem_type("MaximumIndependentSet").unwrap();
@@ -83,17 +120,37 @@ fn problem_ref_from_values_no_values_uses_all_defaults() {
 #[test]
 fn problem_ref_from_values_graph_override() {
     let problem = find_problem_type("MaximumIndependentSet").unwrap();
-    let problem_ref = ProblemRef::from_values(&problem, ["UnitDiskGraph", "i32"]).unwrap();
+    let problem_ref = ProblemRef::from_values(&problem, ["UnitDiskGraph", "i64"]).unwrap();
     assert_eq!(
         problem_ref.variant().get("graph").map(|s| s.as_str()),
         Some("UnitDiskGraph")
     );
     assert_eq!(
         problem_ref.variant().get("weight").map(|s| s.as_str()),
-        Some("i32")
+        Some("i64")
     );
 }
 
+#[test]
+fn problem_ref_from_prefix_map_fills_only_trailing_defaults() {
+    let problem = find_problem_type("ILP").unwrap();
+    let problem_ref = ProblemRef::from_prefix_map(
+        &problem,
+        [("variable".to_string(), "bool".to_string())].into(),
+    )
+    .unwrap();
+    assert_eq!(problem_ref.variant()["variable"], "bool");
+    assert_eq!(problem_ref.variant()["coefficient"], "i64");
+}
+
+#[test]
+fn problem_ref_from_prefix_map_requires_leading_dimension() {
+    let problem = find_problem_type("ILP").unwrap();
+    let coefficient_only = [("coefficient".to_string(), "f64".to_string())].into();
+    assert!(ProblemRef::from_prefix_map(&problem, coefficient_only).is_err());
+    assert!(ProblemRef::from_prefix_map(&problem, Default::default()).is_err());
+}
+
 #[test]
 fn parse_catalog_problem_ref_bare_mis() {
     let r = parse_catalog_problem_ref("MIS").unwrap();
@@ -118,18 +175,18 @@ fn parse_catalog_problem_ref_with_value() {
 #[test]
 fn parse_catalog_problem_ref_rejects_unknown() {
     let err = parse_catalog_problem_ref("NonExistent").unwrap_err();
-    assert!(err.contains("Unknown problem type"));
+    assert!(err.to_string().contains("Unknown problem type"));
 }
 
 #[test]
 fn problem_ref_to_export_ref() {
     let problem = find_problem_type("MaximumIndependentSet").unwrap();
-    let problem_ref = ProblemRef::from_values(&problem, ["i32"]).unwrap();
+    let problem_ref = ProblemRef::from_values(&problem, ["i64"]).unwrap();
     let export_ref = problem_ref.to_export_ref();
     assert_eq!(export_ref.name, "MaximumIndependentSet");
     assert_eq!(
         export_ref.variant.get("weight").map(|s| s.as_str()),
-        Some("i32")
+        Some("i64")
     );
 }
 
@@ -164,10 +221,20 @@ fn every_public_problem_schema_has_dimension_defaults() {
 
 #[test]
 fn every_alias_is_globally_unique() {
+    let canonical_names = inventory::iter::<ProblemSchemaEntry>
+        .into_iter()
+        .map(|entry| (entry.name.to_lowercase(), entry.name))
+        .collect::<HashMap<_, _>>();
     let mut seen: HashMap<String, &str> = HashMap::new();
     for entry in inventory::iter::<ProblemSchemaEntry> {
         for alias in entry.aliases {
             let lower = alias.to_lowercase();
+            if let Some(canonical) = canonical_names.get(&lower) {
+                panic!(
+                    "Alias '{}' on {} conflicts with canonical problem name {}",
+                    alias, entry.name, canonical,
+                );
+            }
             if let Some(prev) = seen.get(&lower) {
                 panic!(
                     "Alias '{}' is used by both {} and {}",
@@ -184,10 +251,6 @@ fn catalog_dimensions_cover_all_declared_variants() {
     use crate::registry::variant::VariantEntry;
 
     for entry in inventory::iter::<ProblemSchemaEntry> {
-        if entry.dimensions.is_empty() {
-            continue;
-        }
-
         // Collect all variant entries for this problem
         let variants: Vec<_> = inventory::iter::<VariantEntry>
             .into_iter()
@@ -196,6 +259,20 @@ fn catalog_dimensions_cover_all_declared_variants() {
 
         for ve in &variants {
             let variant_pairs = ve.variant();
+            assert_eq!(
+                entry
+                    .dimensions
+                    .iter()
+                    .map(|dim| dim.key)
+                    .collect::<BTreeSet<_>>(),
+                variant_pairs
+                    .iter()
+                    .map(|(key, _)| *key)
+                    .collect::<BTreeSet<_>>(),
+                "Problem {} catalog dimensions must match its declared variant {:?}",
+                entry.name,
+                variant_pairs,
+            );
             for (key, value) in &variant_pairs {
                 if let Some(dim) = entry.dimensions.iter().find(|d| d.key == *key) {
                     assert!(
@@ -237,3 +314,38 @@ fn graph_defaults_are_catalog_defaults_for_registered_variants() {
         }
     }
 }
+
+#[test]
+fn concrete_rule_and_solver_variants_have_standard_registration() {
+    // Actual implementations determine the required set, not a Cartesian product
+    // of independently listed schema dimensions.
+    let mut required = BTreeSet::new();
+    for rule in crate::rules::registry::reduction_entries() {
+        required.insert((
+            rule.source_name,
+            crate::export::variant_to_map(rule.source_variant()),
+        ));
+        required.insert((
+            rule.target_name,
+            crate::export::variant_to_map(rule.target_variant()),
+        ));
+    }
+    for solver in inventory::iter::<crate::solvers::BruteForceRegistration> {
+        required.insert((
+            solver.source_name,
+            crate::export::variant_to_map((solver.source_variant_fn)()),
+        ));
+    }
+    for (name, variant) in required {
+        assert!(
+            crate::registry::find_variant_entry(name, &variant).is_some(),
+            "Concrete implementation missing standard registration: {name} {variant:?}"
+        );
+    }
+    // Building the capability registry also validates every concrete customized
+    // solver and each node in every fixed ILP pipeline against variant entries.
+    for entry in crate::registry::variant_entries() {
+        let key = crate::solvers::ExactProblemKey::new(entry.name, entry.variant_map());
+        crate::solvers::solver_capabilities(&key).expect("all concrete solvers must be registered");
+    }
+}
diff --git a/src/unit_tests/registry/schema.rs b/src/unit_tests/registry/schema.rs
index 44bac3c0d..45fbb80bb 100644
--- a/src/unit_tests/registry/schema.rs
+++ b/src/unit_tests/registry/schema.rs
@@ -1,6 +1,20 @@
 use super::*;
 use crate::registry::find_variant_entry;
 use std::collections::BTreeMap;
+use std::str::FromStr;
+
+#[test]
+fn problem_category_parses_only_declared_values() {
+    for category in ProblemCategory::ALL {
+        assert_eq!(ProblemCategory::from_str(category.as_str()), Ok(category));
+    }
+    assert_eq!(
+        ProblemCategory::from_str("unknown")
+            .unwrap_err()
+            .to_string(),
+        "unknown problem category `unknown`; expected one of: algebraic, formula, graph, misc, set"
+    );
+}
 
 #[test]
 fn test_collect_schemas_returns_all_problems() {
@@ -70,15 +84,17 @@ fn test_schema_json_serialization() {
     let json = serde_json::to_string(&schemas).expect("Schemas should serialize to JSON");
     assert!(json.contains("MaximumIndependentSet"));
     assert!(json.contains("graph"));
+    assert!(json.contains("\"category\":\"graph\""));
 }
 
 #[test]
 fn test_field_info_json_fields() {
     let schemas = collect_schemas();
     let sg = schemas.iter().find(|s| s.name == "SpinGlass").unwrap();
-    assert_eq!(sg.fields.len(), 3);
+    assert_eq!(sg.fields.len(), 4);
     let field_names: Vec<&str> = sg.fields.iter().map(|f| f.name.as_str()).collect();
     assert!(field_names.contains(&"graph"));
+    assert!(field_names.contains(&"num_vertices"));
     assert!(field_names.contains(&"couplings"));
     assert!(field_names.contains(&"fields"));
     for f in &sg.fields {
@@ -116,7 +132,7 @@ fn test_decision_problem_schema_entries_registered() {
 fn test_decision_problem_variants_registered() {
     let simple_weighted_variant = BTreeMap::from([
         ("graph".to_string(), "SimpleGraph".to_string()),
-        ("weight".to_string(), "i32".to_string()),
+        ("weight".to_string(), "i64".to_string()),
     ]);
 
     assert!(
diff --git a/src/unit_tests/registry/variant.rs b/src/unit_tests/registry/variant.rs
index f8ec9d944..eb909bf25 100644
--- a/src/unit_tests/registry/variant.rs
+++ b/src/unit_tests/registry/variant.rs
@@ -1,5 +1,9 @@
-use crate::registry::variant::{validate_variant_aliases, variant_label};
-use std::collections::BTreeMap;
+use crate::registry::variant::{
+    validate_create_inputs, validate_direct_create_inputs, validate_variant_aliases,
+    variant_entries, variant_label,
+};
+use crate::registry::{ConstructionError, CreateInputCodec, CreateInputInfo, FieldInfo};
+use std::collections::{BTreeMap, BTreeSet};
 
 #[test]
 fn variant_alias_inventory_is_valid() {
@@ -16,6 +20,167 @@ fn empty_problem_names() -> BTreeMap<String, Vec<String>> {
     BTreeMap::new()
 }
 
+const CREATE_INPUTS: &[CreateInputInfo] = &[
+    CreateInputInfo {
+        name: "required_value",
+        type_name: "usize",
+        description: "A required value",
+        required: true,
+        codec: CreateInputCodec::Scalar,
+    },
+    CreateInputInfo {
+        name: "optional_value",
+        type_name: "usize",
+        description: "An optional value",
+        required: false,
+        codec: CreateInputCodec::Scalar,
+    },
+];
+
+#[test]
+fn construction_contract_accepts_declared_inputs() {
+    let data = serde_json::json!({"required_value": 1, "optional_value": 2});
+    assert_eq!(validate_create_inputs(CREATE_INPUTS, &data), Ok(()));
+}
+
+#[test]
+fn construction_contract_rejects_unknown_inputs() {
+    let data = serde_json::json!({"required_value": 1, "removed_value": 2});
+    assert_eq!(
+        validate_create_inputs(CREATE_INPUTS, &data),
+        Err(ConstructionError::UnknownInputs(vec![
+            "removed_value".to_string()
+        ]))
+    );
+}
+
+#[test]
+fn construction_contract_rejects_missing_required_inputs() {
+    let data = serde_json::json!({"optional_value": 2});
+    assert_eq!(
+        validate_create_inputs(CREATE_INPUTS, &data),
+        Err(ConstructionError::MissingInputs(vec![
+            "required_value".to_string()
+        ]))
+    );
+}
+
+#[test]
+fn construction_contract_rejects_non_object_values() {
+    assert_eq!(
+        validate_create_inputs(CREATE_INPUTS, &serde_json::json!([])),
+        Err(ConstructionError::ExpectedObject)
+    );
+}
+
+#[test]
+fn construction_contract_rejects_duplicate_declarations() {
+    let duplicate = [CREATE_INPUTS[0], CREATE_INPUTS[0]];
+    assert_eq!(
+        validate_create_inputs(&duplicate, &serde_json::json!({"required_value": 1})),
+        Err(ConstructionError::DuplicateInput(
+            "required_value".to_string()
+        ))
+    );
+}
+
+#[test]
+fn catalog_custom_construction_metadata_is_well_formed() {
+    for entry in inventory::iter::<crate::registry::VariantEntry>() {
+        let Some(inputs) = entry.create_inputs else {
+            continue;
+        };
+        let inputs = inputs();
+        let label = variant_label(entry);
+        let mut names = BTreeSet::new();
+        for input in inputs {
+            assert!(
+                !input.name.is_empty(),
+                "{label} declares an empty construction input name"
+            );
+            assert!(
+                input
+                    .name
+                    .bytes()
+                    .all(|byte| byte == b'_' || byte.is_ascii_lowercase() || byte.is_ascii_digit()),
+                "{label} construction input `{}` must use snake_case",
+                input.name
+            );
+            assert!(
+                names.insert(input.name),
+                "{label} declares construction input `{}` more than once",
+                input.name
+            );
+            assert!(
+                !input.type_name.trim().is_empty(),
+                "{label} construction input `{}` has no Rust type",
+                input.name
+            );
+            assert_eq!(
+                input.description,
+                input.description.trim(),
+                "{label} construction input `{}` has surrounding whitespace in its description",
+                input.name
+            );
+        }
+    }
+}
+
+#[test]
+fn every_custom_construction_contract_rejects_unknown_and_missing_inputs() {
+    for entry in inventory::iter::<crate::registry::VariantEntry>() {
+        let Some(inputs) = entry.create_inputs else {
+            continue;
+        };
+        let inputs = inputs();
+        assert_eq!(
+            validate_create_inputs(&inputs, &serde_json::json!({"unknown_input": null})),
+            Err(ConstructionError::UnknownInputs(vec![
+                "unknown_input".to_string()
+            ])),
+            "{} accepted an undeclared construction input",
+            variant_label(entry)
+        );
+
+        let required = inputs
+            .iter()
+            .filter(|input| input.required)
+            .map(|input| input.name.to_string())
+            .collect::<BTreeSet<_>>()
+            .into_iter()
+            .collect::<Vec<_>>();
+        let result = validate_create_inputs(&inputs, &serde_json::json!({}));
+        if required.is_empty() {
+            assert_eq!(
+                result,
+                Ok(()),
+                "{} rejected an empty payload",
+                variant_label(entry)
+            );
+        } else {
+            assert_eq!(
+                result,
+                Err(ConstructionError::MissingInputs(required)),
+                "{} did not report all missing required inputs",
+                variant_label(entry)
+            );
+        }
+    }
+}
+
+#[test]
+fn construction_contract_direct_fields_are_required() {
+    let fields = [FieldInfo {
+        name: "value",
+        type_name: "usize",
+        description: "Stored value",
+    }];
+    assert_eq!(
+        validate_direct_create_inputs(&fields, &serde_json::json!({})),
+        Err(ConstructionError::MissingInputs(vec!["value".to_string()]))
+    );
+}
+
 #[test]
 fn validate_inner_accepts_valid_aliases() {
     let entries = vec![
@@ -122,3 +287,177 @@ fn variant_label_with_variant_dimensions() {
         "expected label to include k=K3, got: {label}"
     );
 }
+
+#[test]
+fn random_contract_input_names_are_unique() {
+    let entries = variant_entries();
+    assert!(entries.iter().any(|entry| entry.random.is_some()));
+
+    for entry in entries {
+        let Some(random) = entry.random else {
+            continue;
+        };
+        let mut names = BTreeSet::new();
+        for input in (random.inputs)() {
+            assert!(
+                !input.name.is_empty(),
+                "{} has an empty random input",
+                variant_label(entry)
+            );
+            assert!(
+                names.insert(input.name),
+                "{} declares random input `{}` more than once",
+                variant_label(entry),
+                input.name
+            );
+        }
+    }
+}
+
+#[test]
+fn established_random_generation_models_remain_registered() {
+    let expected = "
+        DecisionMinimumVertexCover MaximumIndependentSet MinimumVertexCover MaximumClique
+        MinimumDominatingSet MaximalIS KClique MinimumCutIntoBoundedSets HamiltonianCircuit
+        HamiltonianPath HamiltonianPathBetweenTwoVertices LongestCircuit MinimumMaximalMatching
+        RootedTreeArrangement SteinerTree SteinerTreeInGraphs LengthBoundedDisjointPaths
+        MaximumAchromaticNumber MaximumDomaticNumber MinimumCoveringByCliques
+        MinimumIntersectionGraphBasis MaximumLeafSpanningTree GeneralizedHex
+        BottleneckTravelingSalesman MaxCut MaximumMatching TravelingSalesman SpinGlass KColoring
+        OptimalLinearArrangement MinimumSumMulticenter
+    ";
+    let registered = variant_entries()
+        .into_iter()
+        .filter(|entry| entry.random.is_some())
+        .map(|entry| entry.name)
+        .collect::<BTreeSet<_>>();
+
+    for name in expected.split_whitespace() {
+        assert!(registered.contains(name), "{name} lost random generation");
+    }
+}
+
+#[test]
+fn unit_variants_construct_without_unit_inputs() {
+    use serde_json::json;
+    let graph = json!({"num_vertices": 3, "edges": [[0,1],[1,2]]});
+    for entry in crate::registry::variant_entries()
+        .into_iter()
+        .filter(|entry| entry.variant().iter().any(|&(_, value)| value == "One"))
+    {
+        let label = variant_label(entry);
+        let inputs = entry.inputs();
+        assert!(
+            !inputs.iter().any(|input| matches!(
+                input.name,
+                "weights"
+                    | "edge_weights"
+                    | "arc_weights"
+                    | "r_weights"
+                    | "s_weights"
+                    | "lengths"
+                    | "edge_lengths"
+            )),
+            "{label} exposes unit inputs"
+        );
+        let data = match entry.name {
+            "MinimumVertexCover" | "MaximumClique" | "MinimumDominatingSet" => {
+                json!({"graph":graph})
+            }
+            "MaximumCoKPlex" => json!({"graph":graph,"k":1}),
+            "MinimumFeedbackVertexSet" => json!({"graph":{"num_vertices":3,"arcs":[[0,1],[1,2]]}}),
+            "MaximumSetPacking" => json!({"subsets":[[0,1],[1,2]]}),
+            "SteinerTree" | "SteinerTreeInGraphs" => json!({"graph":graph,"terminals":[0,2]}),
+            "MaximumIndependentSet" => match entry.variant_map()["graph"].as_str() {
+                "SimpleGraph" => json!({"graph":[[0,1],[1,2]]}),
+                "KingsSubgraph" => json!({"positions":[[0,0],[1,0],[2,0]]}),
+                "UnitDiskGraph" => {
+                    json!({"positions":[[0.0,0.0],[1.0,0.0],[2.0,0.0]],"radius":1.1})
+                }
+                graph => panic!("missing construction case for {graph}"),
+            },
+            "DecisionMaximumIndependentSet" => json!({"graph":[[0,1],[1,2]],"bound":2}),
+            "DecisionMinimumDominatingSet" => json!({"graph":graph,"bound":1}),
+            "MaxCut" => json!({"graph":[[0,1],[1,2]]}),
+            "LongestPath" => json!({"graph":[[0,1],[1,2]],"source_vertex":0,"target_vertex":2}),
+            "MinMaxMulticenter" => json!({"graph":[[0,1],[1,2]],"k":1}),
+            "MixedChinesePostman" => json!({"graph":[[0,1],[1,2]],"arcs":[[2,0]]}),
+            "ComparativeContainment" => {
+                json!({"universe_size":3,"r_sets":[[0,1]],"s_sets":[[1,2]]})
+            }
+            "MinimumTardinessSequencing" => json!({"deadlines":[1,2,3]}),
+            name => panic!("missing unit construction case for {name}"),
+        };
+        let problem =
+            (entry.construct_fn)(data.clone()).unwrap_or_else(|error| panic!("{label}: {error}"));
+        assert_eq!(problem.variant_map(), entry.variant_map());
+        let serialized = problem.serialize_json();
+        let inner = serialized.get("inner").unwrap_or(&serialized);
+        let unit_fields: Vec<_> = [
+            "weights",
+            "edge_weights",
+            "arc_weights",
+            "r_weights",
+            "s_weights",
+            "lengths",
+            "edge_lengths",
+        ]
+        .into_iter()
+        .filter(|field| inner.get(field).is_some())
+        .collect();
+        assert!(
+            !unit_fields.is_empty(),
+            "{label} has no unit values to check"
+        );
+        for field in unit_fields {
+            let values = inner[field].as_array().unwrap();
+            assert!(!values.is_empty());
+            assert!(
+                values.iter().all(|value| value == &json!(1)),
+                "{label}: {field}"
+            );
+            let mut redundant = data.clone();
+            redundant[field] = inner[field].clone();
+            assert!(
+                matches!(
+                    (entry.construct_fn)(redundant),
+                    Err(ConstructionError::UnknownInputs(_))
+                ),
+                "{label} accepted redundant {field}"
+            );
+        }
+    }
+}
+
+#[test]
+fn unit_construction_preserves_model_validation() {
+    use serde_json::json;
+    let graph = json!({"num_vertices":3,"edges":[[0,1],[1,2]]});
+    for (name, data) in [
+        ("MaximumCoKPlex", json!({"graph":graph,"k":0})),
+        ("SteinerTree", json!({"graph":graph,"terminals":[0]})),
+        ("SteinerTree", json!({"graph":graph,"terminals":[0,0]})),
+        ("SteinerTree", json!({"graph":graph,"terminals":[0,3]})),
+        (
+            "SteinerTreeInGraphs",
+            json!({"graph":graph,"terminals":[3]}),
+        ),
+        (
+            "MinimumTardinessSequencing",
+            json!({"deadlines":[1,2],"precedences":[[0,2]]}),
+        ),
+        (
+            "DecisionMaximumIndependentSet",
+            json!({"graph":[[0,0]],"bound":1}),
+        ),
+    ] {
+        let entry = crate::registry::variant_entries()
+            .into_iter()
+            .find(|entry| entry.name == name && entry.variant().iter().any(|&(_, v)| v == "One"))
+            .unwrap();
+        assert!(
+            (entry.construct_fn)(data).is_err(),
+            "{name} accepted invalid inputs"
+        );
+    }
+}
diff --git a/src/unit_tests/rules/acyclicpartition_ilp.rs b/src/unit_tests/rules/acyclicpartition_ilp.rs
index 97efc979f..467d43aec 100644
--- a/src/unit_tests/rules/acyclicpartition_ilp.rs
+++ b/src/unit_tests/rules/acyclicpartition_ilp.rs
@@ -6,7 +6,7 @@ use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 
-fn small_instance() -> AcyclicPartition<i32> {
+fn small_instance() -> AcyclicPartition<i64> {
     // Chain 0->1->2->3, unit weights, unit arc costs, B=3, K=2
     AcyclicPartition::new(
         DirectedGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
@@ -20,21 +20,22 @@ fn small_instance() -> AcyclicPartition<i32> {
 #[test]
 fn test_acyclicpartition_to_ilp_closed_loop() {
     let source = small_instance();
-    let reduction: ReductionAcyclicPartitionToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionAcyclicPartitionToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Solve source with brute force
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&source);
+    let bf_solutions = bf.find_all_witnesses(&source).unwrap();
     assert!(!bf_solutions.is_empty(), "source should be satisfiable");
 
     // Solve ILP
     let ilp_solver = ILPSolver::new();
     let ilp_sol = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
 
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted solution must be valid"
     );
 }
@@ -42,22 +43,26 @@ fn test_acyclicpartition_to_ilp_closed_loop() {
 #[test]
 fn test_reduction_num_vars() {
     let source = small_instance();
-    let reduction: ReductionAcyclicPartitionToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionAcyclicPartitionToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    // n=4, m=3: n^2 + m*n + m + 2*n = 16 + 12 + 3 + 8 = 39
-    assert_eq!(ilp.num_vars, 39);
+    // n=4, m=3: n^2 + m*n + m = 16 + 12 + 3 = 31
+    assert_eq!(ilp.num_vars(), 31);
+    // 2n + 3mn + 2m + 1 = 8 + 36 + 6 + 1 = 51
+    assert_eq!(ilp.num_constraints(), 51);
 }
 
 #[test]
 fn test_extract_solution() {
     let source = small_instance();
-    let reduction: ReductionAcyclicPartitionToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionAcyclicPartitionToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
     let ilp_sol = solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
     assert_eq!(extracted.len(), 4);
-    assert!(source.evaluate(&extracted).0);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
@@ -73,15 +78,36 @@ fn test_infeasible_instance() {
         1,
         0,
     );
-    let reduction: ReductionAcyclicPartitionToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionAcyclicPartitionToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
-    assert!(solver.solve(ilp).is_none());
+    assert!(solver.solve(ilp).is_err());
 }
 
 #[test]
 fn test_acyclicpartition_to_ilp_bf_vs_ilp() {
     let source = small_instance();
-    let reduction: ReductionAcyclicPartitionToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionAcyclicPartitionToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
+
+#[test]
+fn test_acyclicpartition_to_ilp_regression_direct_topological_labels() {
+    let source = AcyclicPartition::new(
+        DirectedGraph::new(6, vec![(2, 1), (1, 0), (4, 3), (3, 2), (5, 4)]),
+        vec![8, 3, 1, 9, 4, 4],
+        vec![4, 10, 0, 7, 3],
+        11,
+        10,
+    );
+    let reduction: ReductionAcyclicPartitionToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
+    let ilp_solution = ILPSolver::new()
+        .solve(reduction.target_problem())
+        .expect("the feasible source instance must yield a feasible ILP");
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+
+    assert!(source.evaluate(&extracted).unwrap().0);
+}
diff --git a/src/unit_tests/rules/analysis.rs b/src/unit_tests/rules/analysis.rs
index a97f6060e..a6dfb15d0 100644
--- a/src/unit_tests/rules/analysis.rs
+++ b/src/unit_tests/rules/analysis.rs
@@ -1,346 +1,5 @@
-use crate::expr::Expr;
-use crate::rules::analysis::{
-    check_connectivity, check_reachability_from_3sat, compare_overhead, find_dominated_rules,
-    ComparisonStatus, UnreachableReason,
-};
-use crate::rules::graph::ReductionGraph;
-use crate::rules::registry::ReductionOverhead;
-
-// --- Asymptotic normalization + comparison tests ---
-
-#[test]
-fn test_compare_overhead_equal() {
-    let a = ReductionOverhead::new(vec![("num_vars", Expr::Var("n"))]);
-    let b = ReductionOverhead::new(vec![("num_vars", Expr::Var("n"))]);
-    assert_eq!(compare_overhead(&a, &b), ComparisonStatus::Dominated);
-}
-
-#[test]
-fn test_compare_overhead_composite_smaller_degree() {
-    // primitive: num_vars = n^2, composite: num_vars = n → dominated
-    let prim = ReductionOverhead::new(vec![(
-        "num_vars",
-        Expr::pow(Expr::Var("n"), Expr::Const(2.0)),
-    )]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::Var("n"))]);
-    assert_eq!(compare_overhead(&prim, &comp), ComparisonStatus::Dominated);
-}
-
-#[test]
-fn test_compare_overhead_composite_worse() {
-    // primitive: num_vars = n, composite: num_vars = n^2 → not dominated
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::Var("n"))]);
-    let comp = ReductionOverhead::new(vec![(
-        "num_vars",
-        Expr::pow(Expr::Var("n"), Expr::Const(2.0)),
-    )]);
-    assert_eq!(
-        compare_overhead(&prim, &comp),
-        ComparisonStatus::NotDominated
-    );
-}
-
-#[test]
-fn test_compare_overhead_multi_field_mixed() {
-    // One field better, one worse → not dominated
-    let prim = ReductionOverhead::new(vec![
-        ("num_vars", Expr::Var("n")),
-        (
-            "num_constraints",
-            Expr::pow(Expr::Var("n"), Expr::Const(2.0)),
-        ),
-    ]);
-    let comp = ReductionOverhead::new(vec![
-        ("num_vars", Expr::pow(Expr::Var("n"), Expr::Const(2.0))),
-        ("num_constraints", Expr::Var("n")),
-    ]);
-    assert_eq!(
-        compare_overhead(&prim, &comp),
-        ComparisonStatus::NotDominated
-    );
-}
-
-#[test]
-fn test_compare_overhead_no_common_fields() {
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::Var("n"))]);
-    let comp = ReductionOverhead::new(vec![("num_spins", Expr::Var("n"))]);
-    assert_eq!(
-        compare_overhead(&prim, &comp),
-        ComparisonStatus::NotDominated
-    );
-}
-
-#[test]
-fn test_compare_overhead_unknown_exp() {
-    // Different exponential-vs-polynomial growth is still not decided by the
-    // monomial comparison fallback.
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::Exp(Box::new(Expr::Var("n"))))]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::Var("n"))]);
-    assert_eq!(compare_overhead(&prim, &comp), ComparisonStatus::Unknown);
-}
-
-#[test]
-fn test_compare_overhead_unknown_log() {
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::Var("n"))]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::Log(Box::new(Expr::Var("n"))))]);
-    assert_eq!(compare_overhead(&prim, &comp), ComparisonStatus::Unknown);
-}
-
-#[test]
-fn test_compare_overhead_exp_identity_after_asymptotic_normalization() {
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::parse("exp(n + m)"))]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::parse("exp(n) * exp(m)"))]);
-    assert_eq!(compare_overhead(&prim, &comp), ComparisonStatus::Dominated);
-}
-
-#[test]
-fn test_compare_overhead_log_identity_after_asymptotic_normalization() {
-    // log(n) vs log(n^2): the new canonicalization engine keeps log(n^2) as-is
-    // (it doesn't simplify log(x^k) = k*log(x)), so polynomial comparison
-    // returns Unknown for non-polynomial log terms.
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::parse("log(n)"))]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::parse("log(n^2)"))]);
-    assert_eq!(compare_overhead(&prim, &comp), ComparisonStatus::Unknown);
-}
-
-#[test]
-fn test_compare_overhead_sqrt_identity_after_asymptotic_normalization() {
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::parse("sqrt(n * m)"))]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::parse("(n * m)^(1/2)"))]);
-    assert_eq!(compare_overhead(&prim, &comp), ComparisonStatus::Dominated);
-}
-
-#[test]
-fn test_compare_overhead_additive_constant_after_asymptotic_normalization() {
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::parse("n"))]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::parse("n + 1"))]);
-    assert_eq!(compare_overhead(&prim, &comp), ComparisonStatus::Dominated);
-}
-
-#[test]
-fn test_compare_overhead_multivariate_product_vs_sum() {
-    // n * m (degree 2) vs n + m (degree 1):
-    // monomial n*m has exponents {n:1, m:1}
-    // monomials n, m each have exponent 1 in one variable
-    // n*m is NOT dominated by either n or m → composite is worse
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::Var("n") + Expr::Var("m"))]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::Var("n") * Expr::Var("m"))]);
-    assert_eq!(
-        compare_overhead(&prim, &comp),
-        ComparisonStatus::NotDominated
-    );
-}
-
-#[test]
-fn test_compare_overhead_multivariate_product_vs_square() {
-    // n * m (has m) vs n^2 (no m): incomparable
-    // n*m monomial {n:1, m:1} — dominated by n^2 {n:2}?
-    // exponent_n: 1 <= 2 ✓, exponent_m: 1 <= 0 ✗ → not dominated
-    let prim = ReductionOverhead::new(vec![(
-        "num_vars",
-        Expr::pow(Expr::Var("n"), Expr::Const(2.0)),
-    )]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::Var("n") * Expr::Var("m"))]);
-    assert_eq!(
-        compare_overhead(&prim, &comp),
-        ComparisonStatus::NotDominated
-    );
-}
-
-#[test]
-fn test_compare_overhead_sum_vs_single_var() {
-    // composite: n, primitive: n + m → composite ≤ primitive (n dominated by n)
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::Var("n") + Expr::Var("m"))]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::Var("n"))]);
-    assert_eq!(compare_overhead(&prim, &comp), ComparisonStatus::Dominated);
-}
-
-#[test]
-fn test_compare_overhead_constant_factor() {
-    // 3*n vs n → same asymptotic class → dominated (equal)
-    let prim = ReductionOverhead::new(vec![("num_vars", Expr::Var("n"))]);
-    let comp = ReductionOverhead::new(vec![("num_vars", Expr::Const(3.0) * Expr::Var("n"))]);
-    assert_eq!(compare_overhead(&prim, &comp), ComparisonStatus::Dominated);
-}
-
-#[test]
-fn test_compare_overhead_polynomial_expansion() {
-    // (n + m)^2 = n^2 + 2nm + m^2 (degree 2) vs n^3 (degree 3)
-    // Each monomial of composite has total degree ≤ 2, primitive has degree 3
-    // n^2 dominated by n^3? exponent_n: 2 ≤ 3 ✓ → yes
-    // 2*n*m dominated by n^3? exponent_n: 1 ≤ 3 ✓, exponent_m: 1 ≤ 0 ✗ → no!
-    // So composite is NOT dominated — (n+m)^2 can exceed n^3 when m is large
-    let prim = ReductionOverhead::new(vec![(
-        "num_vars",
-        Expr::pow(Expr::Var("n"), Expr::Const(3.0)),
-    )]);
-    let comp = ReductionOverhead::new(vec![(
-        "num_vars",
-        Expr::pow(Expr::Var("n") + Expr::Var("m"), Expr::Const(2.0)),
-    )]);
-    assert_eq!(
-        compare_overhead(&prim, &comp),
-        ComparisonStatus::NotDominated
-    );
-}
-
-#[test]
-fn test_compare_overhead_multi_field_all_smaller() {
-    // Both fields: composite has smaller degree → dominated
-    let prim = ReductionOverhead::new(vec![
-        ("num_vars", Expr::pow(Expr::Var("n"), Expr::Const(2.0))),
-        (
-            "num_constraints",
-            Expr::pow(Expr::Var("n"), Expr::Const(3.0)),
-        ),
-    ]);
-    let comp = ReductionOverhead::new(vec![
-        ("num_vars", Expr::Var("n")),
-        ("num_constraints", Expr::Var("n")),
-    ]);
-    assert_eq!(compare_overhead(&prim, &comp), ComparisonStatus::Dominated);
-}
-
-// --- Integration tests: find_dominated_rules ---
-
-use std::collections::BTreeMap;
-
-#[test]
-fn test_find_dominated_rules_returns_known_set() {
-    let graph = ReductionGraph::new();
-    let (dominated, unknown) = find_dominated_rules(&graph);
-
-    // Print for debugging
-    eprintln!("Dominated rules ({}):", dominated.len());
-    for rule in &dominated {
-        let path_str: String = rule
-            .dominating_path
-            .steps
-            .iter()
-            .map(|s| s.to_string())
-            .collect::<Vec<_>>()
-            .join(" -> ");
-        eprintln!(
-            "  {} -> {} dominated by [{}]",
-            rule.source_display(),
-            rule.target_display(),
-            path_str,
-        );
-    }
-    eprintln!("\nUnknown comparisons ({}):", unknown.len());
-    for u in &unknown {
-        eprintln!(
-            "  {} -> {}: {}",
-            u.source_display(),
-            u.target_display(),
-            u.reason,
-        );
-    }
-
-    // ── Allow-list of expected dominated rules ──
-    // Keyed by (source_display, target_display) with full variant info.
-    // This list must be updated when new reductions are added.
-    let allowed: std::collections::HashSet<(&str, &str)> = [
-        // Composite through CircuitSAT → ILP is better
-        ("Factoring", "ILP {variable: \"i32\"}"),
-        // KClique → BCBS → ILP is better than direct KClique → ILP
-        (
-            "KClique {graph: \"SimpleGraph\"}",
-            "ILP {variable: \"bool\"}",
-        ),
-        // K2-SAT → QUBO via SAT → NAESAT → MaxCut → SpinGlass chain
-        ("KSatisfiability {k: \"K2\"}", "QUBO {weight: \"f64\"}"),
-        // K3-SAT → QUBO via MVC → MIS → MaxSetPacking chain
-        ("KSatisfiability {k: \"K3\"}", "QUBO {weight: \"f64\"}"),
-        // Knapsack -> ILP -> QUBO is better than the direct penalty reduction
-        ("Knapsack", "QUBO {weight: \"f64\"}"),
-        // MaxMatching → MaxSetPacking → ILP is better than direct MaxMatching → ILP
-        (
-            "MaximumMatching {graph: \"SimpleGraph\", weight: \"i32\"}",
-            "ILP {variable: \"bool\"}",
-        ),
-        // ExactCoverBy3Sets → MaxSetPacking → ILP is better than direct ExactCoverBy3Sets → ILP
-        ("ExactCoverBy3Sets", "ILP {variable: \"bool\"}"),
-        // GraphPartitioning → MaxCut → SpinGlass → QUBO is better than direct GraphPartitioning → QUBO
-        (
-            "GraphPartitioning {graph: \"SimpleGraph\"}",
-            "QUBO {weight: \"f64\"}",
-        ),
-        // KSat → DecisionMVC → MVC (via witness edge) dominates direct KSat → MVC
-        (
-            "KSatisfiability {k: \"K3\"}",
-            "MinimumVertexCover {graph: \"SimpleGraph\", weight: \"i32\"}",
-        ),
-    ]
-    .into_iter()
-    .collect();
-
-    // Check: no unexpected dominated rules
-    for rule in &dominated {
-        let src = rule.source_display();
-        let tgt = rule.target_display();
-        assert!(
-            allowed.contains(&(src.as_str(), tgt.as_str())),
-            "Unexpected dominated rule: {} -> {} (dominated by {})",
-            src,
-            tgt,
-            rule.dominating_path
-                .steps
-                .iter()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>()
-                .join(" -> "),
-        );
-    }
-
-    // Check: no stale entries in allow-list
-    let found: std::collections::HashSet<(String, String)> = dominated
-        .iter()
-        .map(|r| (r.source_display(), r.target_display()))
-        .collect();
-    for &(src, tgt) in &allowed {
-        assert!(
-            found.contains(&(src.to_string(), tgt.to_string())),
-            "Allow-list entry {:?} -> {:?} is stale (no longer dominated)",
-            src,
-            tgt,
-        );
-    }
-}
-
-#[test]
-fn test_no_duplicate_primitive_rules_per_variant_pair() {
-    use crate::rules::registry::ReductionEntry;
-    use std::collections::HashSet;
-
-    let mut seen = HashSet::new();
-    for entry in inventory::iter::<ReductionEntry> {
-        let src_variant: BTreeMap<String, String> = entry
-            .source_variant()
-            .into_iter()
-            .map(|(k, v)| (k.to_string(), v.to_string()))
-            .collect();
-        let dst_variant: BTreeMap<String, String> = entry
-            .target_variant()
-            .into_iter()
-            .map(|(k, v)| (k.to_string(), v.to_string()))
-            .collect();
-        let key = (
-            entry.source_name,
-            src_variant,
-            entry.target_name,
-            dst_variant,
-        );
-        assert!(
-            seen.insert(key.clone()),
-            "Duplicate primitive rule: {} {:?} -> {} {:?}",
-            key.0,
-            key.1,
-            key.2,
-            key.3,
-        );
-    }
-}
+use super::{check_connectivity, check_reachability_from_3sat, UnreachableReason};
+use crate::rules::ReductionGraph;
 
 // ---- Connectivity checks ----
 
diff --git a/src/unit_tests/rules/balancedcompletebipartitesubgraph_ilp.rs b/src/unit_tests/rules/balancedcompletebipartitesubgraph_ilp.rs
index 9c4cc1109..f044cf0f9 100644
--- a/src/unit_tests/rules/balancedcompletebipartitesubgraph_ilp.rs
+++ b/src/unit_tests/rules/balancedcompletebipartitesubgraph_ilp.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::models::algebraic::ILP;
 use crate::models::graph::BalancedCompleteBipartiteSubgraph;
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::rules::ReduceTo;
 use crate::topology::BipartiteGraph;
 use crate::traits::Problem;
@@ -19,21 +19,19 @@ fn small_instance() -> BalancedCompleteBipartiteSubgraph {
 #[test]
 fn test_balancedcompletebipartitesubgraph_to_ilp_closed_loop() {
     let source = small_instance();
-    let reduction: ReductionBCBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_satisfaction_round_trip_from_satisfaction_target(
-        &source,
-        &reduction,
-        "BCBS -> ILP round trip",
-    );
+    let reduction: ReductionBCBSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
 fn test_reduction_shape() {
     let source = small_instance();
-    let reduction: ReductionBCBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionBCBSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // 6 variables (3 left + 3 right)
-    assert_eq!(ilp.num_vars, 6);
+    assert_eq!(ilp.num_vars(), 6);
 }
 
 #[test]
@@ -43,25 +41,28 @@ fn test_infeasible_instance() {
         BipartiteGraph::new(3, 3, vec![(0, 0), (0, 1), (1, 0), (1, 1)]),
         3,
     );
-    let reduction: ReductionBCBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionBCBSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = crate::solvers::ILPSolver::new();
-    assert!(solver.solve(ilp).is_none());
+    assert!(solver.solve(ilp).is_err());
 }
 
 #[test]
 fn test_extract_solution_identity() {
     let source = small_instance();
-    let reduction: ReductionBCBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionBCBSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let target_sol = vec![1, 1, 0, 1, 1, 0];
-    let extracted = reduction.extract_solution(&target_sol);
-    assert_eq!(extracted, vec![1, 1, 0, 1, 1, 0]);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&target_sol).unwrap();
+    assert_eq!(extracted, vec![true, true, false, true, true, false]);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_balancedcompletebipartitesubgraph_to_ilp_bf_vs_ilp() {
     let source = small_instance();
-    let reduction: ReductionBCBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionBCBSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/bicliquecover_bmf.rs b/src/unit_tests/rules/bicliquecover_bmf.rs
index 30c912988..739b63df8 100644
--- a/src/unit_tests/rules/bicliquecover_bmf.rs
+++ b/src/unit_tests/rules/bicliquecover_bmf.rs
@@ -2,16 +2,16 @@ use super::*;
 use crate::models::algebraic::BMF;
 use crate::models::graph::BicliqueCover;
 use crate::rules::{ReduceTo, ReductionResult};
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::topology::BipartiteGraph;
 use crate::traits::Problem;
-use crate::types::Min;
 
 #[test]
 fn test_bicliquecover_to_bmf_structure() {
     // Graph with edges (0,0) and (1,1), k=2 → BMF target is 2x2 identity, rank 2.
     let problem = BicliqueCover::new(BipartiteGraph::new(2, 2, vec![(0, 0), (1, 1)]), 2);
-    let reduction: ReductionBicliqueCoverToBMF = ReduceTo::<BMF>::reduce_to(&problem);
+    let reduction: ReductionBicliqueCoverToBMF =
+        ReduceTo::<BMF>::reduce_to(&problem).expect("reduction should succeed");
     let target = reduction.target_problem();
     assert_eq!(target.rows(), 2);
     assert_eq!(target.cols(), 2);
@@ -22,17 +22,34 @@ fn test_bicliquecover_to_bmf_structure() {
 #[test]
 fn test_bicliquecover_to_bmf_overhead_matches_target_shape() {
     let problem = BicliqueCover::new(BipartiteGraph::new(2, 3, vec![(0, 0), (0, 1), (1, 2)]), 2);
-    let reduction: ReductionBicliqueCoverToBMF = ReduceTo::<BMF>::reduce_to(&problem);
+    let reduction: ReductionBicliqueCoverToBMF =
+        ReduceTo::<BMF>::reduce_to(&problem).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let entry = inventory::iter::<crate::rules::ReductionEntry>()
         .find(|entry| entry.source_name == "BicliqueCover" && entry.target_name == "BMF")
         .expect("BicliqueCover -> BMF reduction should be registered");
-    let overhead = (entry.overhead_eval_fn)(&problem as &dyn std::any::Any);
+    let source_size = problem.parameters();
+    let predicted = entry
+        .parameter_contract()
+        .unwrap()
+        .transform()
+        .unwrap()
+        .evaluate(&source_size)
+        .unwrap();
 
-    assert_eq!(overhead.get("rows"), Some(target.rows()));
-    assert_eq!(overhead.get("cols"), Some(target.cols()));
-    assert_eq!(overhead.get("rank"), Some(target.rank()));
+    assert_eq!(
+        predicted.get("rows"),
+        Some(target.rows().try_into().unwrap())
+    );
+    assert_eq!(
+        predicted.get("cols"),
+        Some(target.cols().try_into().unwrap())
+    );
+    assert_eq!(
+        predicted.get("rank"),
+        Some(target.rank().try_into().unwrap())
+    );
 }
 
 #[test]
@@ -42,40 +59,49 @@ fn test_bicliquecover_to_bmf_closed_loop_full_biclique() {
         BipartiteGraph::new(2, 2, vec![(0, 0), (0, 1), (1, 0), (1, 1)]),
         1,
     );
-    let reduction: ReductionBicliqueCoverToBMF = ReduceTo::<BMF>::reduce_to(&problem);
+    let reduction: ReductionBicliqueCoverToBMF =
+        ReduceTo::<BMF>::reduce_to(&problem).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let bf_source = BruteForce::new().solve(&problem);
+    let bf_source_solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+
+    let bf_source = problem.evaluate(&bf_source_solution).unwrap();
     let target_witness = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("target must be feasible");
-    let extracted = reduction.extract_solution(&target_witness);
-    assert_eq!(problem.evaluate(&extracted), bf_source);
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), bf_source);
 }
 
 #[test]
 fn test_bicliquecover_to_bmf_closed_loop_identity_rank2() {
     // Identity-biadjacency at rank 2 — exact factorization needs two singleton bicliques.
     let problem = BicliqueCover::new(BipartiteGraph::new(2, 2, vec![(0, 0), (1, 1)]), 2);
-    let reduction: ReductionBicliqueCoverToBMF = ReduceTo::<BMF>::reduce_to(&problem);
+    let reduction: ReductionBicliqueCoverToBMF =
+        ReduceTo::<BMF>::reduce_to(&problem).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let bf_source = BruteForce::new().solve(&problem);
+    let bf_source_solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+
+    let bf_source = problem.evaluate(&bf_source_solution).unwrap();
     let target_witness = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("target must be feasible");
-    let extracted = reduction.extract_solution(&target_witness);
-    assert_eq!(problem.evaluate(&extracted), bf_source);
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), bf_source);
 }
 
 #[test]
 fn test_bicliquecover_to_bmf_insufficient_rank() {
     // Identity biadjacency at rank 1 — infeasible for both problems.
     let problem = BicliqueCover::new(BipartiteGraph::new(2, 2, vec![(0, 0), (1, 1)]), 1);
-    let reduction: ReductionBicliqueCoverToBMF = ReduceTo::<BMF>::reduce_to(&problem);
+    let reduction: ReductionBicliqueCoverToBMF =
+        ReduceTo::<BMF>::reduce_to(&problem).expect("reduction should succeed");
     let target = reduction.target_problem();
-    assert_eq!(BruteForce::new().solve(&problem), Min(None));
-    assert_eq!(BruteForce::new().solve(target), Min(None));
+    assert!(BruteForce::new().solve(&problem).unwrap().is_none());
+    assert!(BruteForce::new().solve(target).unwrap().is_none());
 }
 
 #[test]
@@ -83,9 +109,13 @@ fn test_config_roundtrip_bc_bmf() {
     // The transpose helpers must invert each other.
     use crate::rules::bmf_bicliquecover::{config_bc_to_bmf, config_bmf_to_bc};
     let (m, n, k) = (2, 3, 2);
-    let bc = vec![1, 0, 0, 1, 1, 0, 1, 1, 0, 1]; // length (m+n)*k = 10
+    let bc = vec![
+        vec![true, false, true, true, false],
+        vec![false, true, false, true, true],
+    ];
     let bmf = config_bc_to_bmf(&bc, m, n, k);
-    assert_eq!(bmf.len(), m * k + k * n);
+    assert_eq!(bmf.0.len(), m);
+    assert_eq!(bmf.1.len(), k);
     let bc_back = config_bmf_to_bc(&bmf, m, n, k);
     assert_eq!(bc_back, bc);
 }
diff --git a/src/unit_tests/rules/biconnectivityaugmentation_ilp.rs b/src/unit_tests/rules/biconnectivityaugmentation_ilp.rs
index fa21abed9..249dabc98 100644
--- a/src/unit_tests/rules/biconnectivityaugmentation_ilp.rs
+++ b/src/unit_tests/rules/biconnectivityaugmentation_ilp.rs
@@ -6,7 +6,7 @@ use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
-fn small_instance() -> BiconnectivityAugmentation<SimpleGraph, i32> {
+fn small_instance() -> BiconnectivityAugmentation<SimpleGraph, i64> {
     // Path 0-1-2-3, candidates: (0,2,1),(0,3,2),(1,3,1), budget=3
     BiconnectivityAugmentation::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
@@ -18,21 +18,22 @@ fn small_instance() -> BiconnectivityAugmentation<SimpleGraph, i32> {
 #[test]
 fn test_biconnectivityaugmentation_to_ilp_closed_loop() {
     let source = small_instance();
-    let reduction: ReductionBiconnAugToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionBiconnAugToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Solve source with brute force
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&source);
+    let bf_solutions = bf.find_all_witnesses(&source).unwrap();
     assert!(!bf_solutions.is_empty(), "source should be satisfiable");
 
     // Solve ILP
     let ilp_solver = ILPSolver::new();
     let ilp_sol = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
 
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted solution must be valid"
     );
 }
@@ -40,24 +41,26 @@ fn test_biconnectivityaugmentation_to_ilp_closed_loop() {
 #[test]
 fn test_extract_solution() {
     let source = small_instance();
-    let reduction: ReductionBiconnAugToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionBiconnAugToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
     let ilp_sol = solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
     assert_eq!(extracted.len(), 3);
-    assert!(source.evaluate(&extracted).0);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_trivial_single_vertex() {
     let source = BiconnectivityAugmentation::new(SimpleGraph::new(1, vec![]), vec![], 0);
-    let reduction: ReductionBiconnAugToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionBiconnAugToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
     let ilp_sol = solver.solve(ilp).expect("trivial ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
@@ -68,19 +71,121 @@ fn test_already_biconnected() {
         vec![],
         0,
     );
-    let reduction: ReductionBiconnAugToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionBiconnAugToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
     let ilp_sol = solver
         .solve(ilp)
         .expect("already biconnected should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_biconnectivityaugmentation_to_ilp_bf_vs_ilp() {
     let source = small_instance();
-    let reduction: ReductionBiconnAugToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionBiconnAugToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
+
+#[test]
+fn test_biconnectivityaugmentation_to_ilp_all_two_vertex_instances() {
+    for base_edge in [false, true] {
+        for weight in [-2, 0, 2] {
+            for budget in [-3, -1, 0, 1, 3] {
+                let source = BiconnectivityAugmentation::new(
+                    SimpleGraph::new(2, if base_edge { vec![(0, 1)] } else { vec![] }),
+                    if base_edge {
+                        vec![]
+                    } else {
+                        vec![(0, 1, weight)]
+                    },
+                    budget,
+                );
+                let reduction: ReductionBiconnAugToILP =
+                    ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+                let expected = BruteForce::new().solve(&source).unwrap().is_some();
+                match ILPSolver::new().solve(reduction.target_problem()) {
+                    Ok(z) => {
+                        assert!(expected);
+                        assert!(
+                            source
+                                .evaluate(&reduction.extract_solution(&z).unwrap())
+                                .unwrap()
+                                .0
+                        );
+                    }
+                    Err(crate::solvers::ILPSolveError::Infeasible) => assert!(!expected),
+                    Err(e) => panic!("unexpected solver error: {e}"),
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_biconnectivityaugmentation_to_ilp_empty_negative_budget() {
+    for n in 0..=1 {
+        for budget in [-1, 0, 1] {
+            let source =
+                BiconnectivityAugmentation::<_, i64>::new(SimpleGraph::empty(n), vec![], budget);
+            let reduction: ReductionBiconnAugToILP =
+                ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+            assert_eq!(
+                reduction
+                    .target_problem()
+                    .evaluate(&vec![])
+                    .unwrap()
+                    .value
+                    .is_some(),
+                budget >= 0
+            );
+            assert_eq!(reduction.extract_solution(&vec![]).is_ok(), budget >= 0);
+        }
+    }
+}
+
+#[test]
+fn test_biconnectivityaugmentation_to_ilp_signed_cost_and_certificate_bounds() {
+    for candidates in [vec![(0, 2, 2), (0, 3, -2)], vec![(0, 3, -2), (0, 2, 2)]] {
+        let source = BiconnectivityAugmentation::new(SimpleGraph::path(4), candidates, 0);
+        let reduction: ReductionBiconnAugToILP = ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+        crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
+        let z = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+        assert!(
+            source
+                .evaluate(&reduction.extract_solution(&z).unwrap())
+                .unwrap()
+                .0
+        );
+        assert!(reduction.extract_solution(&vec![0; z.len()]).is_err());
+        assert!(reduction.extract_solution(&vec![1; z.len() + 1]).is_err());
+        for value in [-1, 2] {
+            let mut bad = z.clone();
+            bad[0] = value;
+            assert!(reduction.extract_solution(&bad).is_err());
+        }
+    }
+}
+
+#[test]
+fn test_biconnectivityaugmentation_to_ilp_checked_dimensions() {
+    assert_eq!(
+        ReductionBiconnAugToILP::dimensions(0, 0, 0).unwrap(),
+        (0, 0)
+    );
+    assert_eq!(
+        ReductionBiconnAugToILP::dimensions(2, 0, 1).unwrap(),
+        (1, 13)
+    );
+    for (n, m, p) in [
+        (usize::MAX, 0, 0),
+        (1, usize::MAX, 0),
+        (1, usize::MAX / 4, 4),
+        (1, 0, usize::MAX / 4 + 1),
+    ] {
+        assert!(ReductionBiconnAugToILP::dimensions(n, m, p).is_err());
+    }
+}
diff --git a/src/unit_tests/rules/binpacking_ilp.rs b/src/unit_tests/rules/binpacking_ilp.rs
index 772eb4601..b254153d5 100644
--- a/src/unit_tests/rules/binpacking_ilp.rs
+++ b/src/unit_tests/rules/binpacking_ilp.rs
@@ -6,36 +6,38 @@ use crate::types::Min;
 #[test]
 fn test_reduction_creates_valid_ilp() {
     // 3 items with weights [3, 3, 2], capacity 5
-    let problem = BinPacking::new(vec![3, 3, 2], 5);
-    let reduction: ReductionBPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = BinPacking::new(vec![3, 3, 2], 5).unwrap();
+    let reduction: ReductionBPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=3: 9 assignment vars + 3 bin vars = 12
-    assert_eq!(ilp.num_vars, 12, "Should have n^2 + n variables");
+    assert_eq!(ilp.num_vars(), 12, "Should have n^2 + n variables");
     // 3 assignment + 3 capacity = 6
-    assert_eq!(ilp.constraints.len(), 6, "Should have 2n constraints");
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize");
+    assert_eq!(ilp.constraints().len(), 6, "Should have 2n constraints");
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize, "Should minimize");
 }
 
 #[test]
 fn test_binpacking_to_ilp_closed_loop() {
     // 4 items with weights [3, 3, 2, 2], capacity 5
     // Optimal: 2 bins, e.g. {3,2} and {3,2}
-    let problem = BinPacking::new(vec![3, 3, 2, 2], 5);
-    let reduction: ReductionBPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = BinPacking::new(vec![3, 3, 2, 2], 5).unwrap();
+    let reduction: ReductionBPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve original with brute force
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_obj = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_obj = problem.evaluate(&bf_solutions[0]).unwrap();
 
     // Solve via ILP
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_obj = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_obj = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_obj, Min(Some(2)));
     assert_eq!(ilp_obj, Min(Some(2)));
@@ -43,108 +45,114 @@ fn test_binpacking_to_ilp_closed_loop() {
 
 #[test]
 fn test_single_item() {
-    let problem = BinPacking::new(vec![5], 10);
-    let reduction: ReductionBPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = BinPacking::new(vec![5], 10).unwrap();
+    let reduction: ReductionBPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 2); // 1 assignment + 1 bin var
-    assert_eq!(ilp.constraints.len(), 2); // 1 assignment + 1 capacity
+    assert_eq!(ilp.num_vars(), 2); // 1 assignment + 1 bin var
+    assert_eq!(ilp.constraints().len(), 2); // 1 assignment + 1 capacity
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
 
 #[test]
 fn test_same_weight_items() {
     // 4 items all weight 3, capacity 6 -> 2 items per bin -> 2 bins needed
-    let problem = BinPacking::new(vec![3, 3, 3, 3], 6);
-    let reduction: ReductionBPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = BinPacking::new(vec![3, 3, 3, 3], 6).unwrap();
+    let reduction: ReductionBPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Min(Some(2)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_exact_fill() {
     // 2 items, weights [5, 5], capacity 10 -> fit in 1 bin
-    let problem = BinPacking::new(vec![5, 5], 10);
-    let reduction: ReductionBPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = BinPacking::new(vec![5, 5], 10).unwrap();
+    let reduction: ReductionBPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
 
 #[test]
 fn test_solution_extraction() {
-    let problem = BinPacking::new(vec![3, 3, 2], 5);
-    let reduction: ReductionBPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = BinPacking::new(vec![3, 3, 2], 5).unwrap();
+    let reduction: ReductionBPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manually construct an ILP solution:
     // n=3, x_{00}=1 (item 0 in bin 0), x_{11}=1 (item 1 in bin 1), x_{20}=1 (item 2 in bin 0)
     // y_0=1, y_1=1, y_2=0
-    let mut ilp_solution = vec![0usize; 12];
+    let mut ilp_solution = vec![0_i64; 12];
     ilp_solution[0] = 1; // x_{0,0} = 1
     ilp_solution[4] = 1; // x_{1,1} = 1
     ilp_solution[6] = 1; // x_{2,0} = 1
     ilp_solution[9] = 1; // y_0 = 1
     ilp_solution[10] = 1; // y_1 = 1
 
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 1, 0]);
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_ilp_structure_constraints() {
     // 2 items, weights [3, 4], capacity 5
-    let problem = BinPacking::new(vec![3, 4], 5);
-    let reduction: ReductionBPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = BinPacking::new(vec![3, 4], 5).unwrap();
+    let reduction: ReductionBPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 4 assignment vars + 2 bin vars = 6
-    assert_eq!(ilp.num_vars, 6);
+    assert_eq!(ilp.num_vars(), 6);
     // 2 assignment + 2 capacity = 4
-    assert_eq!(ilp.constraints.len(), 4);
+    assert_eq!(ilp.constraints().len(), 4);
 
     // Check objective: minimize y_0 + y_1 (vars at indices 4 and 5)
-    let obj_vars: Vec<usize> = ilp.objective.iter().map(|&(v, _)| v).collect();
+    let obj_vars: Vec<usize> = ilp.objective().iter().map(|&(v, _)| v).collect();
     assert!(obj_vars.contains(&4));
     assert!(obj_vars.contains(&5));
-    for &(_, coef) in &ilp.objective {
-        assert!((coef - 1.0).abs() < 1e-9);
+    for &(_, coef) in ilp.objective() {
+        assert_eq!(coef, 1);
     }
 }
 
 #[test]
-fn test_solve_reduced() {
-    let problem = BinPacking::new(vec![6, 5, 5, 4, 3], 10);
+fn test_solve_via_ilp_pipeline() {
+    let problem = BinPacking::new(vec![6, 5, 5, 4, 3], 10).unwrap();
 
     let ilp_solver = ILPSolver::new();
     let solution = ilp_solver
-        .solve_reduced(&problem)
-        .expect("solve_reduced should work");
+        .solve(&problem)
+        .expect("ILP pipeline should solve the problem");
 
-    assert!(problem.evaluate(&solution).is_valid());
-    assert_eq!(problem.evaluate(&solution), Min(Some(3)));
+    assert!(problem.evaluate(&solution).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(3)));
 }
 
 #[test]
 fn test_binpacking_to_ilp_bf_vs_ilp() {
-    let problem = BinPacking::new(vec![3, 3, 2], 5);
-    let reduction: ReductionBPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = BinPacking::new(vec![3, 3, 2], 5).unwrap();
+    let reduction: ReductionBPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/bmf_bicliquecover.rs b/src/unit_tests/rules/bmf_bicliquecover.rs
index 216b79be6..6ed1e3a2b 100644
--- a/src/unit_tests/rules/bmf_bicliquecover.rs
+++ b/src/unit_tests/rules/bmf_bicliquecover.rs
@@ -2,15 +2,15 @@ use super::*;
 use crate::models::algebraic::BMF;
 use crate::models::graph::BicliqueCover;
 use crate::rules::{ReduceTo, ReductionResult};
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::traits::Problem;
-use crate::types::Min;
 
 #[test]
 fn test_bmf_to_bicliquecover_structure() {
     // Matrix A = [[1,0],[0,1]] => bipartite graph with edges (0,0), (1,1).
     let problem = BMF::new(vec![vec![true, false], vec![false, true]], 2);
-    let reduction: ReductionBMFToBicliqueCover = ReduceTo::<BicliqueCover>::reduce_to(&problem);
+    let reduction: ReductionBMFToBicliqueCover =
+        ReduceTo::<BicliqueCover>::reduce_to(&problem).expect("reduction should succeed");
     let target = reduction.target_problem();
     assert_eq!(target.left_size(), 2);
     assert_eq!(target.right_size(), 2);
@@ -22,34 +22,42 @@ fn test_bmf_to_bicliquecover_structure() {
 fn test_bmf_to_bicliquecover_closed_loop_all_ones() {
     // All-ones 2x2 at rank 1 — exact factorization exists.
     let problem = BMF::new(vec![vec![true, true], vec![true, true]], 1);
-    let reduction: ReductionBMFToBicliqueCover = ReduceTo::<BicliqueCover>::reduce_to(&problem);
+    let reduction: ReductionBMFToBicliqueCover =
+        ReduceTo::<BicliqueCover>::reduce_to(&problem).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let bf_source = BruteForce::new().solve(&problem);
+    let bf_source_solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+
+    let bf_source = problem.evaluate(&bf_source_solution).unwrap();
     let target_witness = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("target has feasible biclique cover");
-    let extracted = reduction.extract_solution(&target_witness);
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), bf_source);
-    assert!(problem.is_exact(&extracted));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), bf_source);
+    assert!(problem.is_exact(&extracted).unwrap());
 }
 
 #[test]
 fn test_bmf_to_bicliquecover_closed_loop_identity() {
     // 2x2 identity at rank 2 — exact factorization exists.
     let problem = BMF::new(vec![vec![true, false], vec![false, true]], 2);
-    let reduction: ReductionBMFToBicliqueCover = ReduceTo::<BicliqueCover>::reduce_to(&problem);
+    let reduction: ReductionBMFToBicliqueCover =
+        ReduceTo::<BicliqueCover>::reduce_to(&problem).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let bf_source = BruteForce::new().solve(&problem);
+    let bf_source_solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+
+    let bf_source = problem.evaluate(&bf_source_solution).unwrap();
     let target_witness = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("target has feasible biclique cover");
-    let extracted = reduction.extract_solution(&target_witness);
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), bf_source);
-    assert!(problem.is_exact(&extracted));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), bf_source);
+    assert!(problem.is_exact(&extracted).unwrap());
 }
 
 #[test]
@@ -59,9 +67,10 @@ fn test_bmf_to_bicliquecover_insufficient_rank() {
     // would have to be the full K_{2,2}, which requires edges (0,1) and (1,0)
     // that are not in G. So BicliqueCover is infeasible too, matching BMF.
     let problem = BMF::new(vec![vec![true, false], vec![false, true]], 1);
-    let reduction: ReductionBMFToBicliqueCover = ReduceTo::<BicliqueCover>::reduce_to(&problem);
+    let reduction: ReductionBMFToBicliqueCover =
+        ReduceTo::<BicliqueCover>::reduce_to(&problem).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    assert_eq!(BruteForce::new().solve(&problem), Min(None));
-    assert_eq!(BruteForce::new().solve(target), Min(None));
+    assert!(BruteForce::new().solve(&problem).unwrap().is_none());
+    assert!(BruteForce::new().solve(target).unwrap().is_none());
 }
diff --git a/src/unit_tests/rules/bmf_ilp.rs b/src/unit_tests/rules/bmf_ilp.rs
index 1cbfb20ad..d09a728fe 100644
--- a/src/unit_tests/rules/bmf_ilp.rs
+++ b/src/unit_tests/rules/bmf_ilp.rs
@@ -7,11 +7,12 @@ use crate::rules::{ReduceTo, ReductionResult};
 fn test_bmf_to_ilp_structure() {
     // 2x2 identity matrix, rank 1
     let problem = BMF::new(vec![vec![true, false], vec![false, true]], 1);
-    let reduction: ReductionBMFToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionBMFToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // b: 2*1=2, c: 1*2=2, p: 2*1*2=4, w: 2*2=4 => 12 (no error variables)
-    assert_eq!(ilp.num_vars, 12);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 12);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -19,7 +20,8 @@ fn test_bmf_to_ilp_closed_loop() {
     // 2x2 identity, rank 2 — exact factorization exists.
     // Use ILP solver on target (fast) + brute force on source (tiny 2x2).
     let problem = BMF::new(vec![vec![true, false], vec![false, true]], 2);
-    let reduction: ReductionBMFToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionBMFToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     assert_bf_vs_ilp(&problem, &reduction);
 }
 
@@ -27,7 +29,8 @@ fn test_bmf_to_ilp_closed_loop() {
 fn test_bmf_to_ilp_bf_vs_ilp() {
     // All-ones 2x2 has an exact rank-1 factorization (boolean rank 1).
     let problem = BMF::new(vec![vec![true, true], vec![true, true]], 1);
-    let reduction: ReductionBMFToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionBMFToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     assert_bf_vs_ilp(&problem, &reduction);
 }
 
@@ -35,8 +38,9 @@ fn test_bmf_to_ilp_bf_vs_ilp() {
 fn test_bmf_to_ilp_trivial() {
     // 1x1 matrix, rank 1
     let problem = BMF::new(vec![vec![true]], 1);
-    let reduction: ReductionBMFToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionBMFToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // b: 1, c: 1, p: 1, w: 1 => 4 (no error variables)
-    assert_eq!(ilp.num_vars, 4);
+    assert_eq!(ilp.num_vars(), 4);
 }
diff --git a/src/unit_tests/rules/bottlenecktravelingsalesman_ilp.rs b/src/unit_tests/rules/bottlenecktravelingsalesman_ilp.rs
index 70452a9e1..5d92bc4bb 100644
--- a/src/unit_tests/rules/bottlenecktravelingsalesman_ilp.rs
+++ b/src/unit_tests/rules/bottlenecktravelingsalesman_ilp.rs
@@ -13,27 +13,29 @@ fn k4_btsp() -> BottleneckTravelingSalesman {
 #[test]
 fn test_reduction_creates_valid_ilp() {
     let problem = k4_btsp();
-    let reduction: ReductionBTSPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionBTSPToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    // n=4, m=6: num_x=16, num_z=2*6*4=48, b=1, total=65
-    assert_eq!(ilp.num_vars, 65);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    // n=4, m=6: 16 position bits, 48 edge-use bits, 6 maximum selectors.
+    assert_eq!(ilp.num_vars(), 70);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_bottlenecktravelingsalesman_to_ilp_closed_loop() {
     let problem = k4_btsp();
     let bf = BruteForce::new();
-    let bf_solution = bf.find_witness(&problem).expect("brute-force optimum");
-    let bf_value = problem.evaluate(&bf_solution);
+    let bf_solution = bf.solve(&problem).unwrap().expect("brute-force optimum");
+    let bf_value = problem.evaluate(&bf_solution).unwrap();
 
-    let reduction: ReductionBTSPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionBTSPToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert!(
         ilp_value.is_valid(),
@@ -53,16 +55,17 @@ fn test_bottlenecktravelingsalesman_to_ilp_c4() {
         vec![1, 2, 3, 4],
     );
     let bf = BruteForce::new();
-    let bf_solution = bf.find_witness(&problem).expect("brute-force optimum");
-    let bf_value = problem.evaluate(&bf_solution);
+    let bf_solution = bf.solve(&problem).unwrap().expect("brute-force optimum");
+    let bf_value = problem.evaluate(&bf_solution).unwrap();
 
-    let reduction: ReductionBTSPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionBTSPToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert!(ilp_value.is_valid());
     assert_eq!(ilp_value, bf_value);
@@ -71,13 +74,14 @@ fn test_bottlenecktravelingsalesman_to_ilp_c4() {
 #[test]
 fn test_solution_extraction() {
     let problem = k4_btsp();
-    let reduction: ReductionBTSPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionBTSPToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let metric = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let metric = problem.evaluate(&extracted).unwrap();
     assert!(metric.is_valid());
 }
 
@@ -88,11 +92,12 @@ fn test_no_hamiltonian_cycle_infeasible() {
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
         vec![1, 1, 1],
     );
-    let reduction: ReductionBTSPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionBTSPToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let result = ilp_solver.solve(reduction.target_problem());
     assert!(
-        result.is_none(),
+        result.is_err(),
         "Path graph should have no Hamiltonian cycle"
     );
 }
@@ -100,6 +105,130 @@ fn test_no_hamiltonian_cycle_infeasible() {
 #[test]
 fn test_bottlenecktravelingsalesman_to_ilp_bf_vs_ilp() {
     let problem = k4_btsp();
-    let reduction: ReductionBTSPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionBTSPToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
+
+fn tour_witness(
+    source: &BottleneckTravelingSalesman,
+    tour: &[usize],
+    edge_order: &[usize],
+) -> Vec<i64> {
+    let n = source.num_vertices();
+    let m = source.num_edges();
+    let edges = source.graph().edges();
+    let weights = source.weights();
+    let mut config = vec![0; n * n + 2 * m * n + m];
+    for (p, &v) in tour.iter().enumerate() {
+        config[v * n + p] = 1;
+        let edge = edge_order[p];
+        let direction = usize::from(edges[edge] != (v, tour[(p + 1) % n]));
+        config[n * n + 2 * (edge * n + p) + direction] = 1;
+    }
+    let maximum = *edge_order
+        .iter()
+        .max_by_key(|&&edge| weights[edge])
+        .unwrap();
+    config[n * n + 2 * m * n + maximum] = 1;
+    config
+}
+
+#[test]
+fn test_bottleneck_ilp_signed_full_range_and_native_cycles() {
+    for (n, edges, weights, tour, edge_order) in [
+        (
+            3,
+            vec![(0, 1), (1, 2), (2, 0)],
+            vec![-5, -3, -4],
+            vec![0, 1, 2],
+            vec![0, 1, 2],
+        ),
+        (
+            3,
+            vec![(0, 1), (1, 2), (2, 0)],
+            vec![i64::MIN; 3],
+            vec![0, 1, 2],
+            vec![0, 1, 2],
+        ),
+        (
+            3,
+            vec![(0, 1), (1, 2), (2, 0)],
+            vec![i64::MIN, i64::MAX, 0],
+            vec![0, 1, 2],
+            vec![0, 1, 2],
+        ),
+        (1, vec![(0, 0)], vec![-7], vec![0], vec![0]),
+        (2, vec![(0, 1), (1, 0)], vec![2, 3], vec![0, 1], vec![0, 1]),
+        (
+            3,
+            vec![(0, 1), (0, 1), (1, 2), (2, 0)],
+            vec![9, -5, -3, -4],
+            vec![0, 1, 2],
+            vec![1, 2, 3],
+        ),
+    ] {
+        let source = BottleneckTravelingSalesman::new(SimpleGraph::new(n, edges), weights);
+        let result = ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+        let witness = tour_witness(&source, &tour, &edge_order);
+        let extracted = result.extract_solution(&witness).unwrap();
+        let expected = source.evaluate(&extracted).unwrap().unwrap();
+        assert_eq!(
+            result.target_problem().evaluate(&witness).unwrap().value,
+            Some(expected)
+        );
+        assert_eq!(extracted.iter().filter(|&&x| x).count(), n);
+        for variable in 0..witness.len() {
+            let mut invalid = witness.clone();
+            invalid[variable] = 2;
+            assert!(result.extract_solution(&invalid).is_err());
+        }
+        assert!(result
+            .extract_solution(&witness[..witness.len() - 1].to_vec())
+            .is_err());
+    }
+}
+
+#[test]
+fn test_bottleneck_ilp_maximum_must_be_used_and_dominate() {
+    let source = k4_btsp();
+    let result = ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+    let mut config = tour_witness(&source, &[0, 1, 2, 3], &[0, 3, 5, 2]);
+    let selector = 4 * 4 + 2 * 6 * 4;
+    config[selector..].fill(0);
+    assert!(result.extract_solution(&config).is_err());
+    config[selector] = 1; // used, but lower than the maximum edge
+    assert!(result.extract_solution(&config).is_err());
+    config[selector] = 0;
+    config[selector + 1] = 1; // unused
+    assert!(result.extract_solution(&config).is_err());
+}
+
+#[test]
+fn test_bottleneck_ilp_empty_and_single_edge_are_infeasible() {
+    for (n, edges, weights) in [(0, vec![], vec![]), (2, vec![(0, 1)], vec![1])] {
+        let source = BottleneckTravelingSalesman::new(SimpleGraph::new(n, edges), weights);
+        let result = ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+        assert!(matches!(
+            ILPSolver::new().solve(result.target_problem()),
+            Err(crate::solvers::ILPSolveError::Infeasible)
+        ));
+    }
+}
+
+#[test]
+fn test_bottleneck_ilp_dimensions_and_malformed_weights() {
+    assert_eq!(
+        ReductionBTSPToILP::dimensions(4, 6).unwrap(),
+        (16, 48, 70, 197)
+    );
+    assert_eq!(ReductionBTSPToILP::dimensions(0, 0).unwrap(), (0, 0, 0, 1));
+    for (n, m) in [(usize::MAX, 0), (1, usize::MAX), (0, usize::MAX)] {
+        assert!(ReductionBTSPToILP::dimensions(n, m).is_err());
+    }
+    let source: BottleneckTravelingSalesman = serde_json::from_value(serde_json::json!({
+        "graph": {"num_vertices": 0, "edges": []}, "edge_weights": [1]
+    }))
+    .unwrap();
+    assert!(ReduceTo::<ILP<i64>>::reduce_to(&source).is_err());
+}
diff --git a/src/unit_tests/rules/boundedcomponentspanningforest_ilp.rs b/src/unit_tests/rules/boundedcomponentspanningforest_ilp.rs
index bd97a4a96..039d7f2c3 100644
--- a/src/unit_tests/rules/boundedcomponentspanningforest_ilp.rs
+++ b/src/unit_tests/rules/boundedcomponentspanningforest_ilp.rs
@@ -6,7 +6,7 @@ use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
-fn small_instance() -> BoundedComponentSpanningForest<SimpleGraph, i32> {
+fn small_instance() -> BoundedComponentSpanningForest<SimpleGraph, i64> {
     // Path 0-1-2-3, weights [1,2,2,1], K=2, B=4
     BoundedComponentSpanningForest::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
@@ -19,21 +19,22 @@ fn small_instance() -> BoundedComponentSpanningForest<SimpleGraph, i32> {
 #[test]
 fn test_boundedcomponentspanningforest_to_ilp_closed_loop() {
     let source = small_instance();
-    let reduction: ReductionBCSFToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionBCSFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Solve source with brute force
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&source);
+    let bf_solutions = bf.find_all_witnesses(&source).unwrap();
     assert!(!bf_solutions.is_empty(), "source should be satisfiable");
 
     // Solve ILP
     let ilp_solver = ILPSolver::new();
     let ilp_sol = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
 
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted solution must be valid"
     );
 }
@@ -41,13 +42,14 @@ fn test_boundedcomponentspanningforest_to_ilp_closed_loop() {
 #[test]
 fn test_extract_solution() {
     let source = small_instance();
-    let reduction: ReductionBCSFToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionBCSFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
     let ilp_sol = solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
     assert_eq!(extracted.len(), 4);
-    assert!(source.evaluate(&extracted).0);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
@@ -59,14 +61,15 @@ fn test_single_component() {
         1,
         3,
     );
-    let reduction: ReductionBCSFToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionBCSFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
     let ilp_sol = solver
         .solve(ilp)
         .expect("single component should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
@@ -78,15 +81,17 @@ fn test_infeasible_instance() {
         2,
         5,
     );
-    let reduction: ReductionBCSFToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionBCSFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
-    assert!(solver.solve(ilp).is_none());
+    assert!(solver.solve(ilp).is_err());
 }
 
 #[test]
 fn test_boundedcomponentspanningforest_to_ilp_bf_vs_ilp() {
     let source = small_instance();
-    let reduction: ReductionBCSFToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionBCSFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/capacityassignment_ilp.rs b/src/unit_tests/rules/capacityassignment_ilp.rs
index a5efbb8bc..e0053dfb1 100644
--- a/src/unit_tests/rules/capacityassignment_ilp.rs
+++ b/src/unit_tests/rules/capacityassignment_ilp.rs
@@ -12,25 +12,31 @@ fn test_reduction_creates_valid_ilp() {
         vec![vec![8, 4], vec![7, 3]],
         12,
     );
-    let reduction: ReductionCAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // num_vars = 2 links * 2 capacities = 4
     assert_eq!(
-        ilp.num_vars, 4,
+        ilp.num_vars(),
+        4,
         "Should have 4 variables (2 links * 2 capacities)"
     );
 
     // num_constraints = 2 assignment + 1 delay budget = 3
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         3,
         "Should have 3 constraints (2 assignment + 1 delay)"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize cost");
+    assert_eq!(
+        ilp.sense(),
+        ObjectiveSense::Minimize,
+        "Should minimize cost"
+    );
     // Objective should have cost coefficients
     assert!(
-        !ilp.objective.is_empty(),
+        !ilp.objective().is_empty(),
         "Objective should have cost terms"
     );
 }
@@ -49,16 +55,18 @@ fn test_capacityassignment_to_ilp_closed_loop() {
     let ilp_solver = ILPSolver::new();
 
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("BF should find a solution");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
     assert_eq!(bf_value, Min(Some(9)));
 
-    let reduction: ReductionCAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
     assert_eq!(
         ilp_value, bf_value,
         "ILP and BF should agree on optimal value"
@@ -74,32 +82,34 @@ fn test_solution_extraction() {
         vec![vec![8, 4, 1], vec![7, 3, 1]],
         10,
     );
-    let reduction: ReductionCAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // link 0 → cap 1, link 1 → cap 0
     // x_{0,0}=0, x_{0,1}=1, x_{0,2}=0, x_{1,0}=1, x_{1,1}=0, x_{1,2}=0
     let ilp_solution = vec![0, 1, 0, 1, 0, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![1, 0]);
     // Verify extraction works (evaluation may or may not be feasible)
-    let _ = problem.evaluate(&extracted);
+    let _ = problem.evaluate(&extracted).unwrap();
 }
 
 #[test]
 fn test_capacityassignment_to_ilp_trivial() {
     // 1 link, 1 capacity level — trivially feasible
     let problem = CapacityAssignment::new(vec![1], vec![vec![0]], vec![vec![0]], 100);
-    let reduction: ReductionCAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // num_vars = 1, num_constraints = 1 + 1 = 2
-    assert_eq!(ilp.num_vars, 1);
-    assert_eq!(ilp.constraints.len(), 2);
+    assert_eq!(ilp.num_vars(), 1);
+    assert_eq!(ilp.constraints().len(), 2);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted).0.is_some());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap().0.is_some());
 }
 
 #[test]
@@ -110,6 +120,7 @@ fn test_capacityassignment_to_ilp_bf_vs_ilp() {
         vec![vec![8, 4, 1], vec![7, 3, 1], vec![6, 3, 1]],
         12,
     );
-    let reduction: ReductionCAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/circuit_ilp.rs b/src/unit_tests/rules/circuit_ilp.rs
index 8ff85f961..044e10148 100644
--- a/src/unit_tests/rules/circuit_ilp.rs
+++ b/src/unit_tests/rules/circuit_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::formula::{Assignment, BooleanExpr, Circuit, CircuitSAT};
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Or;
@@ -13,12 +13,8 @@ fn test_circuitsat_to_ilp_and_gate() {
         BooleanExpr::and(vec![BooleanExpr::var("x"), BooleanExpr::var("y")]),
     )]);
     let source = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<ILP>::reduce_to(&source);
-    assert_satisfaction_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "CircuitSAT->ILP AND gate",
-    );
+    let reduction = ReduceTo::<ILP>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
@@ -29,12 +25,8 @@ fn test_circuitsat_to_ilp_or_gate() {
         BooleanExpr::or(vec![BooleanExpr::var("x"), BooleanExpr::var("y")]),
     )]);
     let source = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<ILP>::reduce_to(&source);
-    assert_satisfaction_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "CircuitSAT->ILP OR gate",
-    );
+    let reduction = ReduceTo::<ILP>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
@@ -45,13 +37,12 @@ fn test_circuitsat_to_ilp_xor_gate() {
         BooleanExpr::xor(vec![BooleanExpr::var("x"), BooleanExpr::var("y")]),
     )]);
     let source = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<ILP>::reduce_to(&source);
-    assert_satisfaction_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "CircuitSAT->ILP XOR gate",
+    let reduction = ReduceTo::<ILP>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
+    assert_eq!(
+        BruteForce::new().find_all_witnesses(&source).unwrap().len(),
+        4
     );
-    assert_eq!(BruteForce::new().find_all_witnesses(&source).len(), 4);
 }
 
 #[test]
@@ -65,12 +56,8 @@ fn test_circuitsat_to_ilp_nested() {
         ]),
     )]);
     let source = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<ILP>::reduce_to(&source);
-    assert_satisfaction_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "CircuitSAT->ILP nested",
-    );
+    let reduction = ReduceTo::<ILP>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
@@ -90,12 +77,8 @@ fn test_circuitsat_to_ilp_closed_loop() {
         ),
     ]);
     let source = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<ILP>::reduce_to(&source);
-    assert_satisfaction_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "CircuitSAT->ILP closed loop",
-    );
+    let reduction = ReduceTo::<ILP>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
@@ -109,16 +92,117 @@ fn test_circuit_to_ilp_bf_vs_ilp() {
         ]),
     )]);
     let source = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<ILP>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP>::reduce_to(&source).expect("reduction should succeed");
 
     let bf_witness = BruteForce::new()
-        .find_witness(&source)
+        .solve(&source)
+        .unwrap()
         .expect("should be satisfiable");
-    assert_eq!(source.evaluate(&bf_witness), Or(true));
+    assert_eq!(source.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(source.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
+}
+
+#[test]
+fn test_circuit_ilp_native_folds_all_feasible_witnesses() {
+    use std::collections::BTreeSet;
+    let x = BooleanExpr::var("x");
+    for args in [
+        vec![],
+        vec![x.clone()],
+        vec![x.clone(), x.clone()],
+        vec![x.clone(), BooleanExpr::constant(true), x.clone()],
+    ] {
+        for expr in [
+            BooleanExpr::and(args.clone()),
+            BooleanExpr::or(args.clone()),
+            BooleanExpr::xor(args.clone()),
+        ] {
+            for output in ["x", "y"] {
+                let source = CircuitSAT::new(Circuit::new(vec![Assignment::new(
+                    vec![output.into()],
+                    expr.clone(),
+                )]));
+                let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+                let target = reduction.target_problem();
+                let expected: BTreeSet<_> = BruteForce::new()
+                    .find_all_witnesses(&source)
+                    .unwrap()
+                    .into_iter()
+                    .collect();
+                let mut actual = BTreeSet::new();
+                for mask in 0..(1usize << target.num_vars()) {
+                    let solution = (0..target.num_vars())
+                        .map(|i| if (mask >> i) & 1 == 0 { 0 } else { 1 })
+                        .collect();
+                    if target.evaluate(&solution).unwrap().value.is_some() {
+                        let extracted = reduction.extract_solution(&solution).unwrap();
+                        assert!(source.evaluate(&extracted).unwrap().0);
+                        actual.insert(extracted);
+                    } else {
+                        assert!(reduction.extract_solution(&solution).is_err());
+                    }
+                }
+                assert_eq!(actual, expected, "{expr:?}, output={output}");
+            }
+        }
+    }
+}
+
+#[test]
+fn test_circuit_ilp_rejects_invalid_target_and_supports_empty_circuit() {
+    let source = CircuitSAT::new(Circuit::new(vec![Assignment::new(
+        vec!["y".into()],
+        BooleanExpr::constant(true),
+    )]));
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    for invalid in [vec![], vec![0], vec![0, 0], vec![2, 1], vec![1, 1, 1]] {
+        assert!(reduction.extract_solution(&invalid).is_err());
+    }
+    let empty = CircuitSAT::new(Circuit::new(vec![]));
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&empty).unwrap();
+    assert_eq!(reduction.target_problem().num_vars(), 0);
+    assert_eq!(
+        reduction.extract_solution(&vec![]).unwrap(),
+        Vec::<bool>::new()
+    );
+}
+
+#[test]
+fn test_circuit_ilp_variadic_xor_overhead() {
+    for width in 0..=16 {
+        let source = CircuitSAT::new(Circuit::new(vec![Assignment::new(
+            vec![],
+            BooleanExpr::xor(vec![BooleanExpr::constant(false); width]),
+        )]));
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        let expected = if width == 0 { 1 } else { 2 * width - 1 };
+        assert_eq!(target.num_vars(), expected);
+        assert!(target.num_vars() <= source.num_variables() + 2 * source.num_expression_nodes());
+        assert!(
+            target.num_constraints()
+                <= 5 * source.num_expression_nodes() + source.num_assignment_outputs()
+        );
+        if width == 3 {
+            assert!(target.num_vars() > source.num_variables() + source.num_expression_nodes());
+        }
+    }
+}
+
+#[test]
+fn test_circuit_ilp_allocation_overflow() {
+    let mut builder = ILPBuilder::new();
+    builder.num_vars = usize::MAX;
+    assert!(matches!(
+        builder.alloc_aux(),
+        Err(crate::rules::ReductionError::IntegerOverflow { .. })
+    ));
+    assert!(builder.get_or_create_var("x").is_err());
+    assert!(builder.variable_map.is_empty());
+    assert!(builder.process_expr(&BooleanExpr::xor(vec![])).is_err());
 }
diff --git a/src/unit_tests/rules/circuit_sat.rs b/src/unit_tests/rules/circuit_sat.rs
index 0f8cab804..be07e6372 100644
--- a/src/unit_tests/rules/circuit_sat.rs
+++ b/src/unit_tests/rules/circuit_sat.rs
@@ -1,9 +1,8 @@
 use super::*;
 use crate::models::formula::{Assignment, BooleanExpr, Circuit, CircuitSAT, Satisfiability};
-use crate::rules::test_helpers::{
-    assert_satisfaction_round_trip_from_satisfaction_target, solve_satisfaction_problem,
-};
+use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
 use crate::rules::ReduceTo;
+use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
 fn contradiction_source() -> CircuitSAT {
@@ -16,7 +15,8 @@ fn contradiction_source() -> CircuitSAT {
 #[test]
 fn test_circuitsat_to_satisfiability_closed_loop() {
     let source = issue_example_source();
-    let reduction = ReduceTo::<Satisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<Satisfiability>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -24,31 +24,36 @@ fn test_circuitsat_to_satisfiability_closed_loop() {
         "CircuitSAT -> Satisfiability closed loop",
     );
 
-    let target_solution = solve_satisfaction_problem(reduction.target_problem())
+    let target_solution = BruteForce::new()
+        .solve(reduction.target_problem())
+        .unwrap()
         .expect("issue example should yield a SAT witness");
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     assert_eq!(extracted.len(), source.num_variables());
-    assert!(source.evaluate(&extracted).0);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_circuitsat_to_satisfiability_unsatisfiable() {
     let source = contradiction_source();
-    let reduction = ReduceTo::<Satisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<Satisfiability>::reduce_to(&source).expect("reduction should succeed");
 
     assert!(
-        solve_satisfaction_problem(reduction.target_problem()).is_none(),
+        BruteForce::new()
+            .solve(reduction.target_problem())
+            .unwrap()
+            .is_none(),
         "x = NOT x should stay unsatisfiable after Tseitin encoding"
     );
 }
 
 #[test]
-fn test_circuitsat_to_satisfiability_issue_example_counts() {
+fn test_circuitsat_to_satisfiability_issue_example_target_counts() {
     let source = issue_example_source();
-    let reduction = ReduceTo::<Satisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<Satisfiability>::reduce_to(&source).expect("reduction should succeed");
 
-    assert_eq!(source.tseitin_num_vars(), 9);
-    assert_eq!(source.tseitin_num_clauses(), 13);
     assert_eq!(reduction.target_problem().num_vars(), 9);
     assert_eq!(reduction.target_problem().num_clauses(), 13);
 }
@@ -59,7 +64,8 @@ fn test_circuitsat_to_satisfiability_simplifies_constants() {
         vec!["r".to_string()],
         BooleanExpr::and(vec![BooleanExpr::var("x"), BooleanExpr::constant(true)]),
     )]));
-    let reduction = ReduceTo::<Satisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<Satisfiability>::reduce_to(&source).expect("reduction should succeed");
 
     assert_eq!(reduction.target_problem().num_vars(), 2);
     assert_eq!(reduction.target_problem().num_clauses(), 2);
@@ -76,7 +82,8 @@ fn test_circuitsat_to_satisfiability_handles_multiple_outputs() {
         vec!["a".to_string(), "b".to_string()],
         BooleanExpr::xor(vec![BooleanExpr::var("x"), BooleanExpr::var("y")]),
     )]));
-    let reduction = ReduceTo::<Satisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<Satisfiability>::reduce_to(&source).expect("reduction should succeed");
 
     assert_eq!(reduction.target_problem().num_vars(), 5);
     assert_eq!(reduction.target_problem().num_clauses(), 8);
diff --git a/src/unit_tests/rules/circuit_spinglass.rs b/src/unit_tests/rules/circuit_spinglass.rs
index e648499a3..d44aaec9d 100644
--- a/src/unit_tests/rules/circuit_spinglass.rs
+++ b/src/unit_tests/rules/circuit_spinglass.rs
@@ -2,12 +2,13 @@ use super::*;
 use crate::models::formula::Circuit;
 use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
 use crate::solvers::BruteForce;
+use crate::traits::Problem;
 use crate::types::{NumericSize, WeightElement};
 use num_traits::Num;
 include!("../jl_helpers.rs");
 
 /// Verify a gadget has the correct ground states.
-fn verify_gadget_truth_table<W>(gadget: &LogicGadget<W>, expected: &[(Vec<usize>, Vec<usize>)])
+fn verify_gadget_truth_table<W>(gadget: &LogicGadget<W>, expected: &[(Vec<bool>, Vec<bool>)])
 where
     W: WeightElement
         + crate::variant::VariantParam
@@ -15,14 +16,14 @@ where
         + Num
         + Zero
         + AddAssign
-        + From<i32>
+        + From<i64>
         + std::ops::Mul<Output = W>
         + std::fmt::Debug
         + NumericSize,
     <W as WeightElement>::Sum: std::fmt::Debug + serde::Serialize + serde::de::DeserializeOwned,
 {
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&gadget.problem);
+    let solutions = solver.find_all_witnesses(&gadget.problem).unwrap();
 
     // For each expected input/output pair, verify there's a matching ground state
     for (inputs, outputs) in expected {
@@ -31,12 +32,12 @@ where
                 .inputs
                 .iter()
                 .zip(inputs)
-                .all(|(&idx, &expected)| sol[idx] == expected);
+                .all(|(&idx, &expected)| (sol[idx] == 1) == expected);
             let output_match = gadget
                 .outputs
                 .iter()
                 .zip(outputs)
-                .all(|(&idx, &expected)| sol[idx] == expected);
+                .all(|(&idx, &expected)| (sol[idx] == 1) == expected);
             input_match && output_match
         });
         assert!(
@@ -49,96 +50,93 @@ where
 
 #[test]
 fn test_circuit_to_spinglass_closed_loop() {
-    let gadget: LogicGadget<i32> = and_gadget();
+    let gadget: LogicGadget<i64> = and_gadget();
     assert_eq!(gadget.num_spins(), 3);
     assert_eq!(gadget.inputs, vec![0, 1]);
     assert_eq!(gadget.outputs, vec![2]);
 
     // AND truth table: (a, b) -> a AND b
     let truth_table = vec![
-        (vec![0, 0], vec![0]), // 0 AND 0 = 0
-        (vec![0, 1], vec![0]), // 0 AND 1 = 0
-        (vec![1, 0], vec![0]), // 1 AND 0 = 0
-        (vec![1, 1], vec![1]), // 1 AND 1 = 1
+        (vec![false, false], vec![false]),
+        (vec![false, true], vec![false]),
+        (vec![true, false], vec![false]),
+        (vec![true, true], vec![true]),
     ];
     verify_gadget_truth_table(&gadget, &truth_table);
 }
 
 #[test]
 fn test_or_gadget() {
-    let gadget: LogicGadget<i32> = or_gadget();
+    let gadget: LogicGadget<i64> = or_gadget();
     assert_eq!(gadget.num_spins(), 3);
     assert_eq!(gadget.inputs, vec![0, 1]);
     assert_eq!(gadget.outputs, vec![2]);
 
     // OR truth table: (a, b) -> a OR b
     let truth_table = vec![
-        (vec![0, 0], vec![0]), // 0 OR 0 = 0
-        (vec![0, 1], vec![1]), // 0 OR 1 = 1
-        (vec![1, 0], vec![1]), // 1 OR 0 = 1
-        (vec![1, 1], vec![1]), // 1 OR 1 = 1
+        (vec![false, false], vec![false]),
+        (vec![false, true], vec![true]),
+        (vec![true, false], vec![true]),
+        (vec![true, true], vec![true]),
     ];
     verify_gadget_truth_table(&gadget, &truth_table);
 }
 
 #[test]
 fn test_not_gadget() {
-    let gadget: LogicGadget<i32> = not_gadget();
+    let gadget: LogicGadget<i64> = not_gadget();
     assert_eq!(gadget.num_spins(), 2);
     assert_eq!(gadget.inputs, vec![0]);
     assert_eq!(gadget.outputs, vec![1]);
 
     // NOT truth table: a -> NOT a
-    let truth_table = vec![
-        (vec![0], vec![1]), // NOT 0 = 1
-        (vec![1], vec![0]), // NOT 1 = 0
-    ];
+    let truth_table = vec![(vec![false], vec![true]), (vec![true], vec![false])];
     verify_gadget_truth_table(&gadget, &truth_table);
 }
 
 #[test]
 fn test_xor_gadget() {
-    let gadget: LogicGadget<i32> = xor_gadget();
+    let gadget: LogicGadget<i64> = xor_gadget();
     assert_eq!(gadget.num_spins(), 4);
     assert_eq!(gadget.inputs, vec![0, 1]);
     assert_eq!(gadget.outputs, vec![2]);
 
     // XOR truth table: (a, b) -> a XOR b
     let truth_table = vec![
-        (vec![0, 0], vec![0]), // 0 XOR 0 = 0
-        (vec![0, 1], vec![1]), // 0 XOR 1 = 1
-        (vec![1, 0], vec![1]), // 1 XOR 0 = 1
-        (vec![1, 1], vec![0]), // 1 XOR 1 = 0
+        (vec![false, false], vec![false]),
+        (vec![false, true], vec![true]),
+        (vec![true, false], vec![true]),
+        (vec![true, true], vec![false]),
     ];
     verify_gadget_truth_table(&gadget, &truth_table);
 }
 
 #[test]
 fn test_set0_gadget() {
-    let gadget: LogicGadget<i32> = set0_gadget();
+    let gadget: LogicGadget<i64> = set0_gadget();
     assert_eq!(gadget.num_spins(), 1);
     assert_eq!(gadget.inputs, Vec::<usize>::new());
     assert_eq!(gadget.outputs, vec![0]);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&gadget.problem);
+    let solutions = solver.find_all_witnesses(&gadget.problem).unwrap();
     // Ground state should be spin down (0)
-    assert!(solutions.contains(&vec![0]));
+    assert!(solutions.contains(&vec![-1]));
     assert!(!solutions.contains(&vec![1]));
 }
 
 #[test]
 fn test_set1_gadget() {
-    let gadget: LogicGadget<i32> = set1_gadget();
+    let gadget: LogicGadget<i64> = set1_gadget();
     assert_eq!(gadget.num_spins(), 1);
     assert_eq!(gadget.inputs, Vec::<usize>::new());
     assert_eq!(gadget.outputs, vec![0]);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&gadget.problem);
+    let solutions = solver.find_all_witnesses(&gadget.problem).unwrap();
     // Ground state should be spin up (1)
     assert!(solutions.contains(&vec![1]));
-    assert!(!solutions.contains(&vec![0]));
+    assert!(!solutions.contains(&vec![-1]));
 }
 
 #[test]
@@ -149,20 +147,21 @@ fn test_constant_true() {
         BooleanExpr::constant(true),
     )]);
     let problem = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&problem)
+        .expect("reduction should succeed");
     let sg = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(sg);
+    let solutions = solver.find_all_witnesses(sg).unwrap();
 
-    let extracted: Vec<Vec<usize>> = solutions
+    let extracted: Vec<Vec<bool>> = solutions
         .iter()
-        .map(|s| reduction.extract_solution(s))
+        .map(|s| reduction.extract_solution(s).unwrap())
         .collect();
 
     // c should be 1
     assert!(
-        extracted.contains(&vec![1]),
+        extracted.contains(&vec![true]),
         "Expected c=1 in {:?}",
         extracted
     );
@@ -176,20 +175,21 @@ fn test_constant_false() {
         BooleanExpr::constant(false),
     )]);
     let problem = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&problem)
+        .expect("reduction should succeed");
     let sg = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(sg);
+    let solutions = solver.find_all_witnesses(sg).unwrap();
 
-    let extracted: Vec<Vec<usize>> = solutions
+    let extracted: Vec<Vec<bool>> = solutions
         .iter()
-        .map(|s| reduction.extract_solution(s))
+        .map(|s| reduction.extract_solution(s).unwrap())
         .collect();
 
     // c should be 0
     assert!(
-        extracted.contains(&vec![0]),
+        extracted.contains(&vec![false]),
         "Expected c=0 in {:?}",
         extracted
     );
@@ -207,27 +207,28 @@ fn test_multi_input_and() {
         ]),
     )]);
     let problem = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&problem)
+        .expect("reduction should succeed");
     let sg = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(sg);
+    let solutions = solver.find_all_witnesses(sg).unwrap();
 
-    let extracted: Vec<Vec<usize>> = solutions
+    let extracted: Vec<Vec<bool>> = solutions
         .iter()
-        .map(|s| reduction.extract_solution(s))
+        .map(|s| reduction.extract_solution(s).unwrap())
         .collect();
 
     // Variables sorted: c, x, y, z
     // Only c=1 when all inputs are 1
     assert!(
-        extracted.contains(&vec![1, 1, 1, 1]),
+        extracted.contains(&vec![true, true, true, true]),
         "Expected (1,1,1,1) in {:?}",
         extracted
     );
     // c=0 for all other combinations
     assert!(
-        extracted.contains(&vec![0, 0, 0, 0]),
+        extracted.contains(&vec![false, false, false, false]),
         "Expected (0,0,0,0) in {:?}",
         extracted
     );
@@ -240,7 +241,8 @@ fn test_reduction_result_methods() {
         BooleanExpr::var("x"),
     )]);
     let problem = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&problem)
+        .expect("reduction should succeed");
 
     // Test target_problem and extract_solution work
     let sg = reduction.target_problem();
@@ -251,7 +253,8 @@ fn test_reduction_result_methods() {
 fn test_empty_circuit() {
     let circuit = Circuit::new(vec![]);
     let problem = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&problem)
+        .expect("reduction should succeed");
     let sg = reduction.target_problem();
 
     // Empty circuit should result in empty SpinGlass
@@ -265,7 +268,8 @@ fn test_solution_extraction() {
         BooleanExpr::and(vec![BooleanExpr::var("x"), BooleanExpr::var("y")]),
     )]);
     let problem = CircuitSAT::new(circuit);
-    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&problem)
+        .expect("reduction should succeed");
 
     // The source variables are c, x, y (sorted)
     assert_eq!(reduction.source_variables, vec!["c", "x", "y"]);
@@ -295,10 +299,141 @@ fn test_jl_parity_circuitsat_to_spinglass() {
         Assignment::new(vec!["z".to_string()], z_expr),
     ]);
     let source = CircuitSAT::new(circuit);
-    let result = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&source);
+    let result = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
         &result,
         "CircuitSAT->SpinGlass parity",
     );
 }
+
+#[test]
+fn test_circuit_spinglass_all_threshold_witnesses_native_domain() {
+    use crate::rules::AggregateReductionResult;
+    use std::collections::BTreeSet;
+    let x = BooleanExpr::var("x");
+    let y = BooleanExpr::var("y");
+    let mut expressions = vec![
+        x.clone(),
+        BooleanExpr::not(x.clone()),
+        BooleanExpr::constant(false),
+        BooleanExpr::constant(true),
+    ];
+    for args in [
+        vec![],
+        vec![x.clone()],
+        vec![x.clone(), x.clone()],
+        vec![x.clone(), y.clone()],
+        vec![x.clone(), y.clone(), x.clone()],
+    ] {
+        expressions.extend([
+            BooleanExpr::and(args.clone()),
+            BooleanExpr::or(args.clone()),
+            BooleanExpr::xor(args),
+        ]);
+    }
+    for expr in expressions {
+        // Reusing x as the output includes cyclic constraints and identified inputs.
+        for output in ["out", "x"] {
+            let source = CircuitSAT::new(Circuit::new(vec![Assignment::new(
+                vec![output.into()],
+                expr.clone(),
+            )]));
+            let reduction = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+            let target = AggregateReductionResult::target_problem(&reduction);
+            let expected: BTreeSet<_> = BruteForce::new()
+                .find_all_witnesses(&source)
+                .unwrap()
+                .into_iter()
+                .collect();
+            let mut actual = BTreeSet::new();
+            for mask in 0..(1usize << target.num_spins()) {
+                let spins = (0..target.num_spins())
+                    .map(|i| if mask >> i & 1 == 0 { -1 } else { 1 })
+                    .collect();
+                let energy = target.evaluate(&spins).unwrap();
+                assert!(energy.0.unwrap() >= reduction.zero_penalty_energy);
+                if reduction.extract_value(energy).0 {
+                    let decoded = reduction.extract_solution(&spins).unwrap();
+                    assert!(source.evaluate(&decoded).unwrap().0);
+                    actual.insert(decoded);
+                } else {
+                    assert!(reduction.extract_solution(&spins).is_err());
+                }
+            }
+            assert_eq!(actual, expected, "expression {expr:?}, output {output}");
+            assert!(!reduction.extract_value(crate::types::Min(None)).0);
+        }
+    }
+}
+
+#[test]
+fn test_circuit_spinglass_unsat_threshold_and_invalid_spins() {
+    use crate::rules::AggregateReductionResult;
+    let source = CircuitSAT::new(Circuit::new(vec![Assignment::new(
+        vec!["x".into()],
+        BooleanExpr::not(BooleanExpr::var("x")),
+    )]));
+    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+    assert_eq!(reduction.zero_penalty_energy, -5);
+    assert!(!reduction.extract_value(crate::types::Min(Some(-3))).0);
+    for witness in BruteForce::new()
+        .find_all_witnesses(ReductionResult::target_problem(&reduction))
+        .unwrap()
+    {
+        assert!(reduction.extract_solution(&witness).is_err());
+    }
+    for bad in [vec![], vec![1], vec![0, 0], vec![1, 1, 1]] {
+        assert!(reduction.extract_solution(&bad).is_err());
+    }
+    let empty = CircuitSAT::new(Circuit::new(vec![]));
+    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&empty).unwrap();
+    assert!(reduction.extract_value(crate::types::Min(Some(0))).0);
+    assert_eq!(
+        reduction.extract_solution(&vec![]).unwrap(),
+        Vec::<bool>::new()
+    );
+}
+
+#[test]
+fn test_circuit_spinglass_ground_energy_overflow_is_typed() {
+    let mut builder = SpinGlassBuilder::new();
+    builder.zero_penalty_energy = i64::MIN;
+    builder.allocate_spin().unwrap();
+    assert!(matches!(
+        builder.add_gadget(&set0_gadget(), &[0], -1),
+        Err(crate::registry::ConstructionError::IntegerOverflow(_))
+    ));
+    let mut builder = SpinGlassBuilder::new();
+    builder.zero_penalty_energy = i64::MIN;
+    let assignment = Assignment::new(vec!["y".into()], BooleanExpr::var("x"));
+    assert!(matches!(
+        process_assignment(&assignment, &mut builder),
+        Err(crate::registry::ConstructionError::IntegerOverflow(_))
+    ));
+}
+
+#[test]
+fn test_circuit_spinglass_variadic_constant_overhead() {
+    for width in 0..=16 {
+        let args = vec![BooleanExpr::constant(false); width];
+        let expr = BooleanExpr::xor(args);
+        let source = CircuitSAT::new(Circuit::new(vec![Assignment::new(vec![], expr)]));
+        let reduction = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        let expected = if width == 0 {
+            1
+        } else {
+            width + 2 * (width - 1)
+        };
+        assert_eq!(target.num_spins(), expected);
+        assert!(target.num_spins() <= source.num_variables() + 3 * source.num_expression_nodes());
+        if width == 5 {
+            assert_eq!(target.num_spins(), 13);
+            assert!(
+                target.num_spins() > source.num_variables() + 2 * source.num_expression_nodes()
+            );
+        }
+    }
+}
diff --git a/src/unit_tests/rules/closeststring_ilp.rs b/src/unit_tests/rules/closeststring_ilp.rs
index 693626564..5714565a7 100644
--- a/src/unit_tests/rules/closeststring_ilp.rs
+++ b/src/unit_tests/rules/closeststring_ilp.rs
@@ -2,7 +2,7 @@ use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
 use crate::models::misc::ClosestString;
 use crate::rules::test_helpers::assert_bf_vs_ilp;
-use crate::solvers::{BruteForce, ILPSolver, Solver};
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -19,46 +19,48 @@ fn issue_instance() -> ClosestString {
 #[test]
 fn test_closeststring_to_ilp_structure() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // q = 2, m = 3 -> 2*3 + 1 = 7 variables.
-    assert_eq!(ilp.num_vars, 7);
+    assert_eq!(ilp.num_vars(), 7);
     // m = 3 assignment constraints + n = 4 radius constraints = 7.
-    assert_eq!(ilp.constraints.len(), 7);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.constraints().len(), 7);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
     // The objective puts weight 1 on the radius variable only.
-    assert_eq!(ilp.objective.len(), 1);
-    let (r_idx, r_coeff) = ilp.objective[0];
+    assert_eq!(ilp.objective().len(), 1);
+    let (r_idx, r_coeff) = ilp.objective()[0];
     assert_eq!(r_idx, 2 * 3);
-    assert!((r_coeff - 1.0).abs() < 1e-9);
+    assert_eq!(r_coeff, 1);
 
     // Each assignment constraint has q = 2 terms and rhs = 1.
-    for c in ilp.constraints.iter().take(3) {
-        assert_eq!(c.terms.len(), 2);
-        assert!((c.rhs - 1.0).abs() < 1e-9);
+    for c in ilp.constraints().iter().take(3) {
+        assert_eq!(c.terms().len(), 2);
+        assert_eq!(c.rhs(), 1);
     }
 
     // Each radius constraint has m + 1 = 4 terms (one per position + R) and
     // rhs = m = 3.
-    for c in ilp.constraints.iter().skip(3) {
-        assert_eq!(c.terms.len(), 4);
-        assert!((c.rhs - 3.0).abs() < 1e-9);
+    for c in ilp.constraints().iter().skip(3) {
+        assert_eq!(c.terms().len(), 4);
+        assert_eq!(c.rhs(), 3);
     }
 }
 
 #[test]
 fn test_closeststring_to_ilp_closed_loop() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
-    let bf_value = BruteForce::new().solve(&source);
+    let bf_value_solution = BruteForce::new().solve(&source).unwrap().unwrap();
+
+    let bf_value = source.evaluate(&bf_value_solution).unwrap();
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let extracted_value = source.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let extracted_value = source.evaluate(&extracted).unwrap();
 
     // The extracted center must be syntactically valid and match the BF optimum.
     assert!(extracted_value.is_valid());
@@ -70,7 +72,7 @@ fn test_closeststring_to_ilp_closed_loop() {
 #[test]
 fn test_closeststring_to_ilp_bf_vs_ilp() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     assert_bf_vs_ilp(&source, &reduction);
 }
 
@@ -79,17 +81,32 @@ fn test_closeststring_to_ilp_extract_known_center() {
     // Build the binary encoding of the center 000 by hand:
     // x_{0,0}=x_{1,0}=x_{2,0}=1, others 0, R = 2.
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
-    let mut target_solution = vec![0usize; reduction.target_problem().num_vars];
+    let mut target_solution = vec![0_i64; reduction.target_problem().num_vars()];
     target_solution[0] = 1; // x_{0,0}
     target_solution[2] = 1; // x_{1,0}
     target_solution[4] = 1; // x_{2,0}
     target_solution[6] = 2; // R = 2
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     assert_eq!(extracted, vec![0, 0, 0]);
-    assert_eq!(source.evaluate(&extracted), Min(Some(2)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(2)));
+}
+
+#[test]
+fn test_closeststring_to_ilp_rejects_missing_one_hot_symbol() {
+    let source = ClosestString::new(2, vec![vec![0, 1]]);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
+    let target_solution = vec![0; reduction.target_problem().num_vars()];
+
+    assert_eq!(
+        reduction
+            .extract_solution(&target_solution)
+            .unwrap_err()
+            .to_string(),
+        "center position 0 has no selected symbol"
+    );
 }
 
 #[test]
@@ -97,12 +114,12 @@ fn test_closeststring_to_ilp_ternary_alphabet() {
     // q = 3, m = 2, three strings forcing a nonzero radius. The optimum
     // radius is 1 (any center matches at least one position of every string).
     let source = ClosestString::new(3, vec![vec![0, 1], vec![1, 2], vec![2, 0]]);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // q * m + 1 = 3 * 2 + 1 = 7 variables; m + n = 2 + 3 = 5 constraints.
-    assert_eq!(ilp.num_vars, 7);
-    assert_eq!(ilp.constraints.len(), 5);
+    assert_eq!(ilp.num_vars(), 7);
+    assert_eq!(ilp.constraints().len(), 5);
 
     assert_bf_vs_ilp(&source, &reduction);
 }
@@ -113,12 +130,12 @@ fn test_closeststring_to_ilp_single_string_zero_radius() {
     // radius is 0. This guards against off-by-one errors in the radius
     // constraints.
     let source = ClosestString::new(2, vec![vec![1, 0, 1, 1]]);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![1, 0, 1, 1]);
-    assert_eq!(source.evaluate(&extracted), Min(Some(0)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(0)));
 }
diff --git a/src/unit_tests/rules/closestsubstring_ilp.rs b/src/unit_tests/rules/closestsubstring_ilp.rs
index 22fc89e24..bf3a9fed5 100644
--- a/src/unit_tests/rules/closestsubstring_ilp.rs
+++ b/src/unit_tests/rules/closestsubstring_ilp.rs
@@ -2,7 +2,7 @@ use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
 use crate::models::misc::ClosestSubstring;
 use crate::rules::test_helpers::assert_bf_vs_ilp;
-use crate::solvers::{BruteForce, ILPSolver, Solver};
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -18,73 +18,91 @@ fn issue_instance() -> ClosestSubstring {
         ],
         3,
     )
+    .unwrap()
 }
 
 #[test]
 fn test_closestsubstring_to_ilp_structure() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // q = 2, ell = 3, total windows W = 3 + 3 + 3 = 9.
     // num_vars = q*ell + W + 1 = 6 + 9 + 1 = 16.
-    assert_eq!(ilp.num_vars, 16);
+    assert_eq!(ilp.num_vars(), 16);
     // num_constraints = ell + 1 (radius upper bound) + n + W
     //                 = 3 + 1 + 3 + 9 = 16.
-    assert_eq!(ilp.constraints.len(), 16);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.constraints().len(), 16);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
     // The objective puts weight 1 on the radius variable only, at the very
     // last index.
-    assert_eq!(ilp.objective.len(), 1);
-    let (r_idx, r_coeff) = ilp.objective[0];
-    assert_eq!(r_idx, ilp.num_vars - 1);
-    assert!((r_coeff - 1.0).abs() < 1e-9);
+    assert_eq!(ilp.objective().len(), 1);
+    let (r_idx, r_coeff) = ilp.objective()[0];
+    assert_eq!(r_idx, ilp.num_vars() - 1);
+    assert_eq!(r_coeff, 1);
 
     // First ell = 3 constraints are assignment constraints (q = 2 terms, rhs = 1).
-    for c in ilp.constraints.iter().take(3) {
-        assert_eq!(c.terms.len(), 2);
-        assert!((c.rhs - 1.0).abs() < 1e-9);
+    for c in ilp.constraints().iter().take(3) {
+        assert_eq!(c.terms().len(), 2);
+        assert_eq!(c.rhs(), 1);
     }
 
     // Constraint index ell = 3 is the radius upper bound R <= ell.
-    let r_bound = &ilp.constraints[3];
-    assert_eq!(r_bound.terms.len(), 1);
-    assert_eq!(r_bound.terms[0].0, r_idx);
-    assert!((r_bound.terms[0].1 - 1.0).abs() < 1e-9);
-    assert!((r_bound.rhs - 3.0).abs() < 1e-9);
+    let r_bound = &ilp.constraints()[3];
+    assert_eq!(r_bound.terms().len(), 1);
+    assert_eq!(r_bound.terms()[0].0, r_idx);
+    assert_eq!(r_bound.terms()[0].1, 1);
+    assert_eq!(r_bound.rhs(), 3);
 
     // Next n = 3 constraints are window-choice constraints (W_i = 3 terms,
     // rhs = 1).
-    for c in ilp.constraints.iter().skip(4).take(3) {
-        assert_eq!(c.terms.len(), 3);
-        assert!((c.rhs - 1.0).abs() < 1e-9);
+    for c in ilp.constraints().iter().skip(4).take(3) {
+        assert_eq!(c.terms().len(), 3);
+        assert_eq!(c.rhs(), 1);
     }
 
     // Remaining W = 9 constraints are conditional radius constraints. Each
     // has ell + 2 = 5 terms (R, the ell center-position match terms, and
     // -ell * y_{i, p}) and rhs = 0.
-    for c in ilp.constraints.iter().skip(7) {
-        assert_eq!(c.terms.len(), 5);
-        assert!(c.rhs.abs() < 1e-9);
+    for c in ilp.constraints().iter().skip(7) {
+        assert_eq!(c.terms().len(), 5);
+        assert_eq!(c.rhs(), 0);
     }
 }
 
+#[test]
+fn test_closestsubstring_to_ilp_rejects_missing_one_hot_symbol() {
+    let source = issue_instance();
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
+    let target_solution = vec![0; reduction.target_problem().num_vars()];
+
+    assert_eq!(
+        reduction
+            .extract_solution(&target_solution)
+            .unwrap_err()
+            .to_string(),
+        "center position 0 has no selected value"
+    );
+}
+
 #[test]
 fn test_closestsubstring_to_ilp_closed_loop() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
+
+    let bf_value_solution = BruteForce::new().solve(&source).unwrap().unwrap();
 
-    let bf_value = BruteForce::new().solve(&source);
+    let bf_value = source.evaluate(&bf_value_solution).unwrap();
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Extracted config must be syntactically valid (length ell + n = 6) and
     // match the brute-force optimum.
     assert_eq!(extracted.len(), 6);
-    let extracted_value = source.evaluate(&extracted);
+    let extracted_value = source.evaluate(&extracted).unwrap();
     assert!(extracted_value.is_valid());
     assert_eq!(extracted_value, bf_value);
     // Sanity: the canonical instance has optimum radius 1.
@@ -94,7 +112,7 @@ fn test_closestsubstring_to_ilp_closed_loop() {
 #[test]
 fn test_closestsubstring_to_ilp_bf_vs_ilp() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     assert_bf_vs_ilp(&source, &reduction);
 }
 
@@ -106,15 +124,16 @@ fn test_closestsubstring_to_ilp_zero_radius_when_common_substring_exists() {
         2,
         vec![vec![0, 1, 0, 0], vec![1, 0, 1, 0], vec![0, 0, 1, 0]],
         3,
-    );
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let extracted_value = source.evaluate(&extracted);
+    let extracted_value = source.evaluate(&extracted).unwrap();
     assert!(extracted_value.is_valid());
     assert_eq!(extracted_value, Min(Some(0)));
 }
@@ -123,14 +142,15 @@ fn test_closestsubstring_to_ilp_zero_radius_when_common_substring_exists() {
 fn test_closestsubstring_to_ilp_ternary_alphabet() {
     // q = 3, ell = 2, three length-3 strings. Brute-force optimum is small
     // enough to cross-check via the closed loop.
-    let source = ClosestSubstring::new(3, vec![vec![0, 1, 2], vec![1, 2, 0], vec![2, 0, 1]], 2);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let source =
+        ClosestSubstring::new(3, vec![vec![0, 1, 2], vec![1, 2, 0], vec![2, 0, 1]], 2).unwrap();
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // q*ell + W + 1 with W = 2 + 2 + 2 = 6: num_vars = 6 + 6 + 1 = 13.
     // num_constraints = ell + 1 + n + W = 2 + 1 + 3 + 6 = 12.
-    assert_eq!(ilp.num_vars, 13);
-    assert_eq!(ilp.constraints.len(), 12);
+    assert_eq!(ilp.num_vars(), 13);
+    assert_eq!(ilp.constraints().len(), 12);
 
     assert_bf_vs_ilp(&source, &reduction);
 }
@@ -142,10 +162,10 @@ fn test_closestsubstring_to_ilp_extract_known_solution() {
     // y_{1,0}=y_{2,1}=y_{3,0}=1, R = 1. Then verify the extracted source
     // config matches and gives radius 1.
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    let mut target_solution = vec![0usize; ilp.num_vars];
+    let mut target_solution = vec![0_i64; ilp.num_vars()];
     target_solution[0] = 1; // x_{0,0}
     target_solution[3] = 1; // x_{1,1}
     target_solution[4] = 1; // x_{2,0}
@@ -155,9 +175,9 @@ fn test_closestsubstring_to_ilp_extract_known_solution() {
     target_solution[6] = 1; // y_{1, 0}
     target_solution[6 + 3 + 1] = 1; // y_{2, 1}
     target_solution[6 + 6] = 1; // y_{3, 0}
-    target_solution[ilp.num_vars - 1] = 1; // R = 1
+    target_solution[ilp.num_vars() - 1] = 1; // R = 1
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     assert_eq!(extracted, vec![0, 1, 0, 0, 1, 0]);
-    assert_eq!(source.evaluate(&extracted), Min(Some(1)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
diff --git a/src/unit_tests/rules/closestvectorproblem_casts.rs b/src/unit_tests/rules/closestvectorproblem_casts.rs
new file mode 100644
index 000000000..efd57957b
--- /dev/null
+++ b/src/unit_tests/rules/closestvectorproblem_casts.rs
@@ -0,0 +1,29 @@
+use super::*;
+use crate::rules::{ReduceTo, ReductionError, ReductionGraph, ReductionResult};
+use crate::types::MAX_EXACT_F64_INTEGER;
+
+#[test]
+fn test_closestvectorproblem_i64_to_f64_closed_loop() {
+    let source = ClosestVectorProblem::new(vec![vec![2, 0], vec![1, 2]], vec![3_i64, 2]).unwrap();
+    let reduction = ReduceTo::<ClosestVectorProblem<f64>>::reduce_to(&source).unwrap();
+
+    assert_eq!(reduction.target_problem().basis(), source.basis());
+    assert_eq!(reduction.target_problem().target(), &[3.0, 2.0]);
+    assert_eq!(reduction.extract_solution(&vec![1, 1]).unwrap(), vec![1, 1]);
+}
+
+#[test]
+fn test_closestvectorproblem_i64_to_f64_rejects_inexact_target() {
+    let source = ClosestVectorProblem::new(vec![vec![1]], vec![MAX_EXACT_F64_INTEGER + 1]).unwrap();
+
+    assert!(matches!(
+        ReduceTo::<ClosestVectorProblem<f64>>::reduce_to(&source),
+        Err(ReductionError::InexactFloatConversion { .. })
+    ));
+}
+
+#[test]
+fn test_closestvectorproblem_numeric_variants_are_connected() {
+    assert!(ReductionGraph::new()
+        .has_direct_reduction::<ClosestVectorProblem<i64>, ClosestVectorProblem<f64>>());
+}
diff --git a/src/unit_tests/rules/closestvectorproblem_qubo.rs b/src/unit_tests/rules/closestvectorproblem_qubo.rs
index 90938593d..aa4afb7b3 100644
--- a/src/unit_tests/rules/closestvectorproblem_qubo.rs
+++ b/src/unit_tests/rules/closestvectorproblem_qubo.rs
@@ -1,57 +1,138 @@
 use super::*;
-use crate::models::algebraic::VarBounds;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
 use crate::solvers::BruteForce;
+use crate::traits::Problem;
 
-fn canonical_cvp() -> ClosestVectorProblem<i32> {
-    ClosestVectorProblem::new(
-        vec![vec![2, 0], vec![1, 2]],
-        vec![2.8, 1.5],
-        vec![VarBounds::bounded(-2, 4), VarBounds::bounded(-2, 4)],
-    )
+fn canonical_cvp() -> ClosestVectorProblem<i64> {
+    ClosestVectorProblem::new(vec![vec![2, 0], vec![1, 2]], vec![3_i64, 2]).unwrap()
 }
 
-fn assert_close(actual: f64, expected: f64) {
-    assert!(
-        (actual - expected).abs() < 1e-9,
-        "expected {expected}, got {actual}"
+fn canonical_bits() -> Vec<bool> {
+    vec![
+        false, false, false, true, true, false, false, true, false, false, true,
+    ]
+}
+
+#[test]
+fn test_closestvectorproblem_determinant_exact_elimination() {
+    assert_eq!(determinant(&[]).unwrap(), 1);
+    assert_eq!(determinant(&[vec![-7]]).unwrap(), -7);
+    assert_eq!(determinant(&[vec![0, 1], vec![1, 0]]).unwrap(), -1);
+    assert_eq!(
+        determinant(&[vec![0, 0, 1], vec![1, 0, 0], vec![0, 1, 0]]).unwrap(),
+        1
+    );
+    assert_eq!(
+        determinant(&[vec![2, 3, 1], vec![4, 1, -3], vec![1, 2, 0]]).unwrap(),
+        10
     );
+    assert_eq!(determinant(&[vec![0, 1], vec![0, 2]]).unwrap(), 0);
+    assert_eq!(determinant(&[vec![1, 2], vec![2, 4]]).unwrap(), 0);
+    let large = i64::MAX;
+    assert_eq!(
+        determinant(&[vec![large, large - 1], vec![large - 1, large - 2]]).unwrap(),
+        -1
+    );
+    assert!(matches!(
+        determinant(&[vec![large, 0], vec![0, 2]]),
+        Err(crate::rules::ReductionError::IntegerOverflow { .. })
+    ));
+}
+
+#[test]
+fn test_closestvectorproblem_to_qubo_twelve_dimensional_identity() {
+    let size = 12;
+    let basis = (0..size)
+        .map(|column| (0..size).map(|row| i64::from(row == column)).collect())
+        .collect();
+    let source = ClosestVectorProblem::new(basis, vec![1_i64; size]).unwrap();
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).unwrap();
+    let mut bits = vec![false; reduction.target_problem().num_vars()];
+    for encoding in &reduction.encodings {
+        let mut offset = 1 - encoding.lower;
+        for (index, &weight) in encoding.weights.iter().enumerate().rev() {
+            if weight <= offset {
+                bits[encoding.start + index] = true;
+                offset -= weight;
+            }
+        }
+        assert_eq!(offset, 0);
+    }
+    let solution = reduction.extract_solution(&bits).unwrap();
+    assert_eq!(solution, vec![1; size]);
+    assert_eq!(source.evaluate(&solution).unwrap().0, Some(0.0));
 }
 
 #[test]
 fn test_closestvectorproblem_to_qubo_closed_loop() {
     let source = canonical_cvp();
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).unwrap();
+    let target_solution = BruteForce::new()
+        .solve(reduction.target_problem())
+        .unwrap()
+        .unwrap();
+    let source_solution = reduction.extract_solution(&target_solution).unwrap();
 
-    assert_eq!(reduction.target_problem().num_vars(), 6);
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "ClosestVectorProblem->QUBO closed loop",
-    );
+    assert_eq!(source_solution, vec![1, 1]);
+    assert_eq!(source.evaluate(&source_solution).unwrap().0, Some(0.0));
+    assert_eq!(reduction.target_problem().num_vars(), 11);
 }
 
 #[test]
-fn test_closestvectorproblem_to_qubo_example_matrix_coefficients() {
-    let source = canonical_cvp();
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+fn test_closestvectorproblem_to_qubo_coefficients() {
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&canonical_cvp()).unwrap();
     let qubo = reduction.target_problem();
 
-    assert_eq!(qubo.num_vars(), 6);
-    assert_close(*qubo.get(0, 0).expect("Q[0,0]"), -31.2);
-    assert_close(*qubo.get(0, 1).expect("Q[0,1]"), 16.0);
-    assert_close(*qubo.get(0, 2).expect("Q[0,2]"), 24.0);
-    assert_close(*qubo.get(1, 2).expect("Q[1,2]"), 48.0);
-    assert_close(*qubo.get(2, 5).expect("Q[2,5]"), 36.0);
-    assert_close(*qubo.get(5, 5).expect("Q[5,5]"), -73.8);
+    assert_eq!(qubo.get(0, 0), Some(&-248));
+    assert_eq!(qubo.get(0, 1), Some(&16));
+    assert_eq!(qubo.get(0, 6), Some(&4));
+    assert_eq!(qubo.get(6, 6), Some(&-241));
+}
+
+#[test]
+fn test_closestvectorproblem_to_qubo_exact_range_decoding() {
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&canonical_cvp()).unwrap();
+    assert_eq!(
+        reduction.extract_solution(&canonical_bits()).unwrap(),
+        vec![1, 1]
+    );
+
+    let duplicate = vec![
+        true, false, false, true, false, true, true, true, true, true, false,
+    ];
+    assert_eq!(reduction.extract_solution(&duplicate).unwrap(), vec![1, 1]);
+    assert_eq!(
+        reduction
+            .target_problem()
+            .evaluate(&canonical_bits())
+            .unwrap(),
+        reduction.target_problem().evaluate(&duplicate).unwrap()
+    );
+}
+
+#[test]
+fn test_closestvectorproblem_to_qubo_preserves_optimum_outside_old_box() {
+    let source = ClosestVectorProblem::new(vec![vec![1]], vec![20_i64]).unwrap();
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).unwrap();
+    let target_solution = BruteForce::new()
+        .solve(reduction.target_problem())
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        reduction.extract_solution(&target_solution).unwrap(),
+        vec![20]
+    );
 }
 
 #[test]
-fn test_extract_solution_ignores_duplicate_exact_range_encodings() {
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&canonical_cvp());
+fn test_closestvectorproblem_to_qubo_reports_numeric_boundaries() {
+    let absolute_value = ClosestVectorProblem::new(vec![vec![1]], vec![i64::MIN]).unwrap();
+    assert!(matches!(
+        ReduceTo::<QUBO<i64>>::reduce_to(&absolute_value),
+        Err(crate::rules::ReductionError::IntegerOverflow { .. })
+    ));
 
-    assert_eq!(reduction.extract_solution(&[1, 1, 0, 1, 1, 0]), vec![3, 3]);
-    assert_eq!(reduction.extract_solution(&[0, 0, 1, 0, 0, 1]), vec![3, 3]);
+    let large_exact = ClosestVectorProblem::new(vec![vec![100_000_000]], vec![1_i64]).unwrap();
+    assert!(ReduceTo::<QUBO<i64>>::reduce_to(&large_exact).is_ok());
 }
 
 #[cfg(feature = "example-db")]
@@ -60,26 +141,18 @@ fn test_closestvectorproblem_to_qubo_canonical_example_spec() {
     let spec = canonical_rule_example_specs()
         .into_iter()
         .find(|spec| spec.id == "closestvectorproblem_to_qubo")
-        .expect("missing canonical ClosestVectorProblem -> QUBO example spec");
+        .unwrap();
     let example = (spec.build)();
 
     assert_eq!(example.source.problem, "ClosestVectorProblem");
     assert_eq!(example.target.problem, "QUBO");
-    assert_eq!(example.target.instance["num_vars"], 6);
-    assert_eq!(example.solutions[0].source_config, vec![3, 3]);
-    assert_eq!(example.solutions[0].target_config, vec![0, 0, 1, 0, 0, 1]);
-}
-
-#[test]
-fn test_duplicate_target_encodings_have_equal_qubo_value() {
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&canonical_cvp());
-    let qubo = reduction.target_problem();
-    let solver = BruteForce::new();
-    let best = solver.find_all_witnesses(qubo);
-
-    assert!(best.contains(&vec![0, 0, 1, 0, 0, 1]) || best.contains(&vec![1, 1, 0, 1, 1, 0]));
-    assert_close(
-        qubo.evaluate(&[0, 0, 1, 0, 0, 1]),
-        qubo.evaluate(&[1, 1, 0, 1, 1, 0]),
+    assert_eq!(example.target.instance["num_vars"], 11);
+    assert_eq!(
+        example.solutions[0].source_config,
+        serde_json::json!([1, 1])
+    );
+    assert_eq!(
+        example.solutions[0].target_config,
+        serde_json::to_value(canonical_bits()).unwrap()
     );
 }
diff --git a/src/unit_tests/rules/clustering_ilp.rs b/src/unit_tests/rules/clustering_ilp.rs
index a35273e37..2142986ba 100644
--- a/src/unit_tests/rules/clustering_ilp.rs
+++ b/src/unit_tests/rules/clustering_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::{Comparison, ObjectiveSense, ILP};
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::ILPSolver;
 use crate::traits::Problem;
 use crate::types::Or;
@@ -25,23 +25,24 @@ fn infeasible_instance() -> Clustering {
 #[test]
 fn test_clustering_to_ilp_structure() {
     let problem = canonical_yes_instance();
-    let reduction: ReductionClusteringToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionClusteringToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 8);
-    assert_eq!(ilp.constraints.len(), 12);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 8);
+    assert_eq!(ilp.constraints().len(), 12);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(ilp.objective().is_empty());
 
     let assignment_constraints = ilp
-        .constraints
+        .constraints()
         .iter()
-        .filter(|constraint| constraint.cmp == Comparison::Eq && constraint.rhs == 1.0)
+        .filter(|constraint| constraint.comparison() == Comparison::Eq && constraint.rhs() == 1)
         .count();
     let conflict_constraints = ilp
-        .constraints
+        .constraints()
         .iter()
-        .filter(|constraint| constraint.cmp == Comparison::Le && constraint.rhs == 1.0)
+        .filter(|constraint| constraint.comparison() == Comparison::Le && constraint.rhs() == 1)
         .count();
     assert_eq!(assignment_constraints, 4);
     assert_eq!(conflict_constraints, 8);
@@ -50,29 +51,30 @@ fn test_clustering_to_ilp_structure() {
 #[test]
 fn test_clustering_to_ilp_closed_loop() {
     let problem = canonical_yes_instance();
-    let reduction: ReductionClusteringToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionClusteringToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_satisfaction_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "Clustering->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_clustering_to_ilp_solution_extraction() {
     let problem = canonical_yes_instance();
-    let reduction: ReductionClusteringToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionClusteringToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    let extracted = reduction.extract_solution(&[1, 0, 1, 0, 0, 1, 0, 1]);
+    let extracted = reduction
+        .extract_solution(&vec![1, 0, 1, 0, 0, 1, 0, 1])
+        .unwrap();
     assert_eq!(extracted, vec![0, 0, 1, 1]);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_clustering_to_ilp_infeasible_instance_is_infeasible() {
     let problem = infeasible_instance();
-    let reduction: ReductionClusteringToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionClusteringToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert!(ILPSolver::new().solve(reduction.target_problem()).is_none());
+    assert!(ILPSolver::new().solve(reduction.target_problem()).is_err());
 }
diff --git a/src/unit_tests/rules/coloring_ilp.rs b/src/unit_tests/rules/coloring_ilp.rs
index f436f39b5..238d2cbaf 100644
--- a/src/unit_tests/rules/coloring_ilp.rs
+++ b/src/unit_tests/rules/coloring_ilp.rs
@@ -1,19 +1,20 @@
 use super::*;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
-use crate::variant::{K1, K2, K3, K4};
+use crate::variant::{K1, K2, K3, K4, KN};
 
 #[test]
 fn test_reduction_creates_valid_ilp() {
     // Triangle graph with 3 colors
     let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check ILP structure
     // num_vars = 3 vertices * 3 colors = 9
     assert_eq!(
-        ilp.num_vars, 9,
+        ilp.num_vars(),
+        9,
         "Should have 9 variables (3 vertices * 3 colors)"
     );
 
@@ -21,40 +22,53 @@ fn test_reduction_creates_valid_ilp() {
     //                 + 3 edges * 3 colors = 9 (edge constraints)
     //                 = 12 total
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         12,
         "Should have 12 constraints (3 vertex + 9 edge)"
     );
 
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize");
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize, "Should minimize");
 }
 
 #[test]
 fn test_reduction_path_graph() {
     // Path graph 0-1-2 with 2 colors (2-colorable)
     let problem = KColoring::<K2, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // num_vars = 3 * 2 = 6
-    assert_eq!(ilp.num_vars, 6);
+    assert_eq!(ilp.num_vars(), 6);
 
     // constraints = 3 (vertex) + 2 edges * 2 colors = 7
-    assert_eq!(ilp.constraints.len(), 7);
+    assert_eq!(ilp.constraints().len(), 7);
+}
+
+#[test]
+fn runtime_color_count_controls_exact_ilp_parameters() {
+    let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
+    for colors in [2, 3, 5] {
+        let problem = KColoring::<KN, _>::with_k(graph.clone(), colors);
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+        let target = reduction.target_problem();
+
+        assert_eq!(target.num_vars(), 3 * colors);
+        assert_eq!(target.num_constraints(), 3 + 2 * colors);
+    }
 }
 
 #[test]
 fn test_coloring_to_ilp_closed_loop() {
     // Triangle needs 3 colors
     let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve with brute force on original problem - use find_all_witnesses for satisfaction problems
-    let bf_solutions = bf.find_all_witnesses(&problem);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
     assert!(
         !bf_solutions.is_empty(),
         "Brute force should find solutions"
@@ -62,11 +76,11 @@ fn test_coloring_to_ilp_closed_loop() {
 
     // Solve via ILP reduction
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Verify the extracted solution is valid for the original problem
     assert!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         "Extracted solution should be valid"
     );
 
@@ -80,18 +94,18 @@ fn test_coloring_to_ilp_closed_loop() {
 fn test_ilp_solution_equals_brute_force_path() {
     // Path graph 0-1-2-3 with 2 colors
     let problem = KColoring::<K2, _>::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
 
     // Solve via ILP
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Verify validity
     assert!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         "Extracted solution should be valid"
     );
 
@@ -105,7 +119,7 @@ fn test_ilp_solution_equals_brute_force_path() {
 fn test_ilp_infeasible_triangle_2_colors() {
     // Triangle cannot be 2-colored
     let problem = KColoring::<K2, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
@@ -113,7 +127,7 @@ fn test_ilp_infeasible_triangle_2_colors() {
     // ILP should be infeasible
     let result = ilp_solver.solve(ilp);
     assert!(
-        result.is_none(),
+        result.is_err(),
         "Triangle with 2 colors should be infeasible"
     );
 }
@@ -121,7 +135,7 @@ fn test_ilp_infeasible_triangle_2_colors() {
 #[test]
 fn test_solution_extraction() {
     let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // ILP solution where:
     // vertex 0 has color 1 (x_{0,1} = 1)
@@ -129,42 +143,42 @@ fn test_solution_extraction() {
     // vertex 2 has color 0 (x_{2,0} = 1)
     // Variables are indexed as: v0c0, v0c1, v0c2, v1c0, v1c1, v1c2, v2c0, v2c1, v2c2
     let ilp_solution = vec![0, 1, 0, 0, 0, 1, 1, 0, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert_eq!(extracted, vec![1, 2, 0]);
 
     // Verify this is a valid coloring (vertex 0 and 1 have different colors)
-    assert!(problem.evaluate(&extracted));
+    assert!(problem.evaluate(&extracted).unwrap());
 }
 
 #[test]
 fn test_ilp_structure() {
     let problem =
         KColoring::<K3, _>::new(SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 5 vertices * 3 colors = 15 variables
-    assert_eq!(ilp.num_vars, 15);
+    assert_eq!(ilp.num_vars(), 15);
     // constraints = 5 (vertex) + 4 * 3 (edge) = 17
-    assert_eq!(ilp.constraints.len(), 17);
+    assert_eq!(ilp.constraints().len(), 17);
 }
 
 #[test]
 fn test_empty_graph() {
     // Graph with no edges: any coloring is valid
     let problem = KColoring::<K1, _>::new(SimpleGraph::new(3, vec![]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Should only have vertex constraints (each vertex = one color)
-    assert_eq!(ilp.constraints.len(), 3);
+    assert_eq!(ilp.constraints().len(), 3);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted));
+    assert!(problem.evaluate(&extracted).unwrap());
 }
 
 #[test]
@@ -174,14 +188,14 @@ fn test_complete_graph_k4() {
         4,
         vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)],
     ));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted));
+    assert!(problem.evaluate(&extracted).unwrap());
 
     // All vertices should have different colors
     let mut colors: Vec<usize> = extracted.clone();
@@ -197,12 +211,12 @@ fn test_complete_graph_k4_with_3_colors_infeasible() {
         4,
         vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)],
     ));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let result = ilp_solver.solve(ilp);
-    assert!(result.is_none(), "K4 with 3 colors should be infeasible");
+    assert!(result.is_err(), "K4 with 3 colors should be infeasible");
 }
 
 #[test]
@@ -211,14 +225,14 @@ fn test_bipartite_graph() {
     // This is 2-colorable
     let problem =
         KColoring::<K2, _>::new(SimpleGraph::new(4, vec![(0, 2), (0, 3), (1, 2), (1, 3)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted));
+    assert!(problem.evaluate(&extracted).unwrap());
 
     // Vertices 0,1 should have same color, vertices 2,3 should have same color
     // And different from 0,1
@@ -228,31 +242,30 @@ fn test_bipartite_graph() {
 }
 
 #[test]
-fn test_solve_reduced() {
-    // Test the ILPSolver::solve_reduced method
+fn test_reduction_closed_loop() {
     let problem = KColoring::<K2, _>::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+    let target_solution = ILPSolver::new()
+        .solve(reduction.target_problem())
+        .expect("target ILP should be solvable");
+    let solution = reduction.extract_solution(&target_solution).unwrap();
 
-    let ilp_solver = ILPSolver::new();
-    let solution = ilp_solver
-        .solve_reduced(&problem)
-        .expect("solve_reduced should work");
-
-    assert!(problem.evaluate(&solution));
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_single_vertex() {
     // Single vertex graph: always 1-colorable
     let problem = KColoring::<K1, _>::new(SimpleGraph::new(1, vec![]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 1);
-    assert_eq!(ilp.constraints.len(), 1); // Just the "exactly one color" constraint
+    assert_eq!(ilp.num_vars(), 1);
+    assert_eq!(ilp.constraints().len(), 1); // Just the "exactly one color" constraint
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert_eq!(extracted, vec![0]);
 }
@@ -261,20 +274,20 @@ fn test_single_vertex() {
 fn test_single_edge() {
     // Single edge: needs 2 colors
     let problem = KColoring::<K2, _>::new(SimpleGraph::new(2, vec![(0, 1)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted));
+    assert!(problem.evaluate(&extracted).unwrap());
     assert_ne!(extracted[0], extracted[1]);
 }
 
 #[test]
 fn test_coloring_to_ilp_bf_vs_ilp() {
     let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/coloring_qubo.rs b/src/unit_tests/rules/coloring_qubo.rs
index daa61681a..2b4ea3793 100644
--- a/src/unit_tests/rules/coloring_qubo.rs
+++ b/src/unit_tests/rules/coloring_qubo.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::variant::{K2, K3};
 
@@ -7,16 +8,16 @@ use crate::variant::{K2, K3};
 fn test_kcoloring_to_qubo_closed_loop() {
     // Triangle K3, 3 colors → exactly 6 valid colorings (3! permutations)
     let kc = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&kc);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&kc).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     // All solutions should extract to valid colorings
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(kc.evaluate(&extracted));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(kc.evaluate(&extracted).unwrap());
     }
 
     // Exactly 6 valid 3-colorings of K3
@@ -27,15 +28,15 @@ fn test_kcoloring_to_qubo_closed_loop() {
 fn test_kcoloring_to_qubo_path() {
     // Path graph: 0-1-2, 2 colors
     let kc = KColoring::<K2, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&kc);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&kc).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(kc.evaluate(&extracted));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(kc.evaluate(&extracted).unwrap());
     }
 
     // 2-coloring of path: 0,1,0 or 1,0,1 → 2 solutions
@@ -47,15 +48,15 @@ fn test_kcoloring_to_qubo_reversed_edges() {
     // Edge (2, 0) triggers the idx_v < idx_u swap branch (line 104).
     // Path: 2-0-1 with reversed edge ordering
     let kc = KColoring::<K2, _>::new(SimpleGraph::new(3, vec![(2, 0), (0, 1)]));
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&kc);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&kc).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(kc.evaluate(&extracted));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(kc.evaluate(&extracted).unwrap());
     }
 
     // Same as path graph: 2 valid 2-colorings
@@ -65,8 +66,103 @@ fn test_kcoloring_to_qubo_reversed_edges() {
 #[test]
 fn test_kcoloring_to_qubo_sizes() {
     let kc = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&kc);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&kc).expect("reduction should succeed");
 
     // QUBO should have n*K = 3*3 = 9 variables
     assert_eq!(reduction.target_problem().num_variables(), 9);
 }
+
+#[test]
+fn test_kcoloring_to_qubo_all_small_graphs_and_configurations() {
+    use crate::rules::AggregateReductionResult;
+    for n in 0..=3 {
+        let possible: Vec<_> = (0..n)
+            .flat_map(|u| ((u + 1)..n).map(move |v| (u, v)))
+            .collect();
+        for mask in 0..(1usize << possible.len()) {
+            let edges: Vec<_> = possible
+                .iter()
+                .enumerate()
+                .filter_map(|(i, &edge)| ((mask >> i) & 1 == 1).then_some(edge))
+                .collect();
+            for k in 0..=3 {
+                let source = KColoring::<KN, _>::with_k(SimpleGraph::new(n, edges.clone()), k);
+                let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).unwrap();
+                let target = AggregateReductionResult::target_problem(&reduction);
+                assert_eq!(target.num_vars(), n * k);
+                let mut minimum = i64::MAX;
+                let mut any_coloring = false;
+                for bits in 0..(1usize << (n * k)) {
+                    let config: Vec<_> = (0..n * k).map(|i| bits & (1 << i) != 0).collect();
+                    let counts: Vec<_> = (0..n)
+                        .map(|v| (0..k).filter(|&c| config[v * k + c]).count() as i64)
+                        .collect();
+                    let conflicts = edges
+                        .iter()
+                        .map(|&(u, v)| {
+                            (0..k)
+                                .filter(|&c| config[u * k + c] && config[v * k + c])
+                                .count() as i64
+                        })
+                        .sum::<i64>();
+                    let penalty = (n + 1) as i64;
+                    let residual =
+                        2 * counts.iter().map(|&count| (1 - count).pow(2)).sum::<i64>() + conflicts;
+                    let value = target.evaluate(&config).unwrap();
+                    assert_eq!(value.0, Some(penalty * residual - 2 * penalty * n as i64));
+                    minimum = minimum.min(value.0.unwrap());
+                    let expected = residual == 0;
+                    assert_eq!(
+                        AggregateReductionResult::extract_value(&reduction, value).0,
+                        expected
+                    );
+                    match reduction.extract_solution(&config) {
+                        Ok(coloring) => {
+                            assert!(expected);
+                            assert!(source.evaluate(&coloring).unwrap().0);
+                            any_coloring = true;
+                        }
+                        Err(_) => assert!(!expected),
+                    }
+                }
+                assert_eq!(
+                    AggregateReductionResult::extract_value(
+                        &reduction,
+                        crate::types::Min(Some(minimum))
+                    )
+                    .0,
+                    any_coloring
+                );
+                assert!(
+                    !AggregateReductionResult::extract_value(&reduction, crate::types::Min(None)).0
+                );
+                assert!(reduction.extract_solution(&vec![false; n * k + 1]).is_err());
+            }
+        }
+    }
+}
+
+#[test]
+fn test_kcoloring_to_qubo_checked_parameters() {
+    assert_eq!(coloring_qubo_parameters::<KN>(3, 2).unwrap(), (6, 4, -24));
+    assert_eq!(
+        coloring_qubo_parameters::<KN>(0, usize::MAX).unwrap(),
+        (0, 1, 0)
+    );
+    assert_eq!(
+        coloring_qubo_parameters::<KN>(2_147_483_647, 0).unwrap(),
+        (0, 2_147_483_648, -9_223_372_032_559_808_512)
+    );
+    for (n, k) in [
+        (usize::MAX, 2),
+        (1, usize::MAX),
+        (usize::MAX, 0),
+        (i64::MAX as usize, 0),
+        (2_147_483_648, 0),
+    ] {
+        assert!(matches!(
+            coloring_qubo_parameters::<KN>(n, k),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+}
diff --git a/src/unit_tests/rules/consecutiveblockminimization_ilp.rs b/src/unit_tests/rules/consecutiveblockminimization_ilp.rs
index 42a2be730..f778a2f96 100644
--- a/src/unit_tests/rules/consecutiveblockminimization_ilp.rs
+++ b/src/unit_tests/rules/consecutiveblockminimization_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::rules::{ReduceTo, ReductionResult};
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
@@ -12,11 +12,12 @@ fn test_cbm_to_ilp_structure() {
         vec![vec![true, false, true], vec![false, true, true]],
         2,
     );
-    let reduction: ReductionCBMToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCBMToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // x: 3*3=9, a: 2*3=6, b: 2*3=6 => 21
-    assert_eq!(ilp.num_vars, 21);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 21);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -25,12 +26,9 @@ fn test_cbm_to_ilp_closed_loop() {
         vec![vec![true, false, true], vec![false, true, true]],
         2,
     );
-    let reduction: ReductionCBMToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
-    assert_satisfaction_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "ConsecutiveBlockMinimization->ILP closed loop",
-    );
+    let reduction: ReductionCBMToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
@@ -39,26 +37,28 @@ fn test_cbm_to_ilp_bf_vs_ilp() {
         vec![vec![true, false, true], vec![false, true, true]],
         2,
     );
-    let reduction: ReductionCBMToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCBMToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should be feasible");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_cbm_to_ilp_trivial() {
     // 1x1 matrix, bound 1
     let problem = ConsecutiveBlockMinimization::new(vec![vec![true]], 1);
-    let reduction: ReductionCBMToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCBMToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // x: 1, a: 1, b: 1 => 3
-    assert_eq!(ilp.num_vars, 3);
+    assert_eq!(ilp.num_vars(), 3);
 }
diff --git a/src/unit_tests/rules/consecutiveonesmatrixaugmentation_ilp.rs b/src/unit_tests/rules/consecutiveonesmatrixaugmentation_ilp.rs
index 0c7f7d62b..1a9169afe 100644
--- a/src/unit_tests/rules/consecutiveonesmatrixaugmentation_ilp.rs
+++ b/src/unit_tests/rules/consecutiveonesmatrixaugmentation_ilp.rs
@@ -11,11 +11,12 @@ fn test_coma_to_ilp_structure() {
         vec![vec![true, false, true], vec![false, true, true]],
         1,
     );
-    let reduction: ReductionCOMAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCOMAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // x: 3*3=9, a+l+u+h+f: 5*2*3=30 => 39
-    assert_eq!(ilp.num_vars, 39);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 39);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -24,20 +25,21 @@ fn test_coma_to_ilp_closed_loop() {
         vec![vec![true, false, true], vec![false, true, true]],
         1,
     );
-    let reduction: ReductionCOMAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCOMAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Use ILP solver instead of brute-force on the target (39 binary vars too large)
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 
     // Also verify that brute-force on the source agrees
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should be feasible");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 }
 
 #[test]
@@ -46,26 +48,28 @@ fn test_coma_to_ilp_bf_vs_ilp() {
         vec![vec![true, false, true], vec![false, true, true]],
         1,
     );
-    let reduction: ReductionCOMAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCOMAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should be feasible");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_coma_to_ilp_trivial() {
     // 1x1 matrix, bound 0 — already consecutive
     let problem = ConsecutiveOnesMatrixAugmentation::new(vec![vec![true]], 0);
-    let reduction: ReductionCOMAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCOMAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // x: 1, a+l+u+h+f: 5*1=5 => 6
-    assert_eq!(ilp.num_vars, 6);
+    assert_eq!(ilp.num_vars(), 6);
 }
diff --git a/src/unit_tests/rules/consecutiveonessubmatrix_ilp.rs b/src/unit_tests/rules/consecutiveonessubmatrix_ilp.rs
index 040020993..b6a7ecf2f 100644
--- a/src/unit_tests/rules/consecutiveonessubmatrix_ilp.rs
+++ b/src/unit_tests/rules/consecutiveonessubmatrix_ilp.rs
@@ -16,11 +16,12 @@ fn test_cos_to_ilp_structure() {
         ],
         3,
     );
-    let reduction: ReductionCOSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCOSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // s: 4, x: 4*3=12, a+l+u+h+f: 5*3*3=45 => 61
-    assert_eq!(ilp.num_vars, 61);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 61);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -34,20 +35,21 @@ fn test_cos_to_ilp_closed_loop() {
         ],
         3,
     );
-    let reduction: ReductionCOSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCOSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Use ILP solver (61 binary vars too large for brute force on target)
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 
     // Verify brute-force on source agrees
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should be feasible");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 }
 
 #[test]
@@ -60,29 +62,51 @@ fn test_cos_to_ilp_bf_vs_ilp() {
         ],
         3,
     );
-    let reduction: ReductionCOSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCOSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should be feasible");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
+}
+
+#[test]
+fn test_cos_to_ilp_allows_zero_rows_in_selected_submatrix() {
+    let problem = ConsecutiveOnesSubmatrix::new(
+        vec![
+            vec![true, true, true, true],
+            vec![false, false, true, false],
+            vec![true, false, false, true],
+        ],
+        1,
+    );
+    let reduction: ReductionCOSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
+
+    let ilp_solution = ILPSolver::new()
+        .solve(reduction.target_problem())
+        .expect("a single selected column always has C1P");
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_cos_to_ilp_trivial() {
     // 2x2 identity, K=2
     let problem = ConsecutiveOnesSubmatrix::new(vec![vec![true, false], vec![false, true]], 2);
-    let reduction: ReductionCOSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCOSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/consistencyofdatabasefrequencytables_ilp.rs b/src/unit_tests/rules/consistencyofdatabasefrequencytables_ilp.rs
index 1cb1d59ad..c9e07b866 100644
--- a/src/unit_tests/rules/consistencyofdatabasefrequencytables_ilp.rs
+++ b/src/unit_tests/rules/consistencyofdatabasefrequencytables_ilp.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
 use crate::models::misc::{ConsistencyOfDatabaseFrequencyTables, FrequencyTable, KnownValue};
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::rules::{ReduceTo, ReductionResult};
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
@@ -31,68 +31,70 @@ fn small_no_instance() -> ConsistencyOfDatabaseFrequencyTables {
 #[test]
 fn test_cdft_to_ilp_structure() {
     let problem = small_yes_instance();
-    let reduction: ReductionCDFTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCDFTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 16);
-    assert_eq!(ilp.constraints.len(), 33);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 16);
+    assert_eq!(ilp.constraints().len(), 33);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(ilp.objective().is_empty());
 }
 
 #[test]
 fn test_cdft_to_ilp_closed_loop() {
     let problem = small_yes_instance();
-    let reduction: ReductionCDFTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
-    assert_satisfaction_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "ConsistencyOfDatabaseFrequencyTables->ILP closed loop",
-    );
+    let reduction: ReductionCDFTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_cdft_to_ilp_solution_encoding_round_trip() {
     let problem = small_yes_instance();
-    let reduction: ReductionCDFTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCDFTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = reduction.encode_source_solution(&small_yes_witness());
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, small_yes_witness());
 }
 
 #[test]
 fn test_cdft_to_ilp_unsat_instance_is_infeasible() {
     let problem = small_no_instance();
-    let reduction: ReductionCDFTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCDFTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let solver = ILPSolver::new();
-    assert!(solver.solve(reduction.target_problem()).is_none());
+    assert!(solver.solve(reduction.target_problem()).is_err());
 }
 
 #[test]
-fn test_cdft_to_ilp_solve_reduced() {
+fn test_cdft_solve_via_ilp_pipeline() {
     let problem = small_yes_instance();
     let solver = ILPSolver::new();
     let solution = solver
-        .solve_reduced(&problem)
-        .expect("solve_reduced should find a satisfying assignment");
-    assert!(problem.evaluate(&solution));
+        .solve(&problem)
+        .expect("ILP pipeline should find a satisfying assignment");
+    assert!(problem.evaluate(&solution).unwrap());
 }
 
 #[test]
 fn test_consistency_to_ilp_bf_vs_ilp() {
     let problem = small_yes_instance();
-    let reduction: ReductionCDFTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCDFTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf_witness = BruteForce::new()
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should be satisfiable");
-    assert!(problem.evaluate(&bf_witness));
+    assert!(problem.evaluate(&bf_witness).unwrap());
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap());
 }
 
 fn issue_instance() -> ConsistencyOfDatabaseFrequencyTables {
@@ -118,14 +120,15 @@ fn issue_witness() -> Vec<usize> {
 #[test]
 fn test_cdft_to_ilp_issue_instance_closed_loop() {
     let problem = issue_instance();
-    let reduction: ReductionCDFTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCDFTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let solver = ILPSolver::new();
     let target_solution = solver
         .solve(reduction.target_problem())
         .expect("ILP solver should find a feasible solution for the issue instance");
-    let source_solution = reduction.extract_solution(&target_solution);
+    let source_solution = reduction.extract_solution(&target_solution).unwrap();
     assert!(
-        problem.evaluate(&source_solution),
+        problem.evaluate(&source_solution).unwrap(),
         "extracted source solution must satisfy the original CDFT instance"
     );
 }
@@ -133,8 +136,9 @@ fn test_cdft_to_ilp_issue_instance_closed_loop() {
 #[test]
 fn test_cdft_to_ilp_issue_instance_encoding_round_trip() {
     let problem = issue_instance();
-    let reduction: ReductionCDFTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCDFTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = reduction.encode_source_solution(&issue_witness());
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, issue_witness());
 }
diff --git a/src/unit_tests/rules/cost.rs b/src/unit_tests/rules/cost.rs
deleted file mode 100644
index c489b7fe3..000000000
--- a/src/unit_tests/rules/cost.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-use super::*;
-use crate::expr::Expr;
-
-fn test_overhead() -> ReductionOverhead {
-    ReductionOverhead::new(vec![
-        ("n", Expr::Const(2.0) * Expr::Var("n")),
-        ("m", Expr::Var("m")),
-    ])
-}
-
-#[test]
-fn test_minimize_single() {
-    let cost_fn = Minimize("n");
-    let size = ProblemSize::new(vec![("n", 10), ("m", 5)]);
-    let overhead = test_overhead();
-
-    assert_eq!(cost_fn.edge_cost(&overhead, &size), 20.0); // 2 * 10
-}
-
-#[test]
-fn test_minimize_steps() {
-    let cost_fn = MinimizeSteps;
-    let size = ProblemSize::new(vec![("n", 100)]);
-    let overhead = test_overhead();
-
-    assert_eq!(cost_fn.edge_cost(&overhead, &size), 1.0);
-}
-
-#[test]
-fn test_custom_cost() {
-    let cost_fn = CustomCost(|overhead: &ReductionOverhead, size: &ProblemSize| {
-        let output = overhead.evaluate_output_size(size);
-        (output.get("n").unwrap_or(0) + output.get("m").unwrap_or(0)) as f64
-    });
-    let size = ProblemSize::new(vec![("n", 10), ("m", 5)]);
-    let overhead = test_overhead();
-
-    // output n = 20, output m = 5
-    // custom = 20 + 5 = 25
-    assert_eq!(cost_fn.edge_cost(&overhead, &size), 25.0);
-}
-
-#[test]
-fn test_minimize_missing_field() {
-    let cost_fn = Minimize("nonexistent");
-    let size = ProblemSize::new(vec![("n", 10)]);
-    let overhead = test_overhead();
-
-    assert_eq!(cost_fn.edge_cost(&overhead, &size), 0.0);
-}
-
-#[test]
-fn test_minimize_output_size() {
-    let cost_fn = MinimizeOutputSize;
-    let size = ProblemSize::new(vec![("n", 10), ("m", 5)]);
-    let overhead = test_overhead();
-
-    // output n = 20, output m = 5 → total = 25
-    assert_eq!(cost_fn.edge_cost(&overhead, &size), 25.0);
-}
-
-#[test]
-fn test_minimize_steps_then_overhead() {
-    let cost_fn = MinimizeStepsThenOverhead;
-    let size = ProblemSize::new(vec![("n", 10), ("m", 5)]);
-    let overhead = test_overhead();
-
-    let cost = cost_fn.edge_cost(&overhead, &size);
-    // Should be dominated by the step weight (1e9) with small overhead tiebreaker
-    assert!(cost > 1e8, "step weight should dominate");
-    assert!(cost < 2e9, "should be roughly 1e9 + small tiebreaker");
-
-    // Two edges with different overhead should have different costs
-    let small_overhead =
-        ReductionOverhead::new(vec![("n", Expr::Const(1.0)), ("m", Expr::Const(1.0))]);
-    let cost_small = cost_fn.edge_cost(&small_overhead, &size);
-    // Both have the same step weight but different tiebreakers
-    assert!(cost > cost_small, "larger overhead should cost more");
-}
-
-#[test]
-fn test_problem_size_total() {
-    let size = ProblemSize::new(vec![("a", 3), ("b", 7), ("c", 10)]);
-    assert_eq!(size.total(), 20);
-    assert_eq!(ProblemSize::new(vec![]).total(), 0);
-}
diff --git a/src/unit_tests/rules/decisionmaximumindependentset_integralflowbundles.rs b/src/unit_tests/rules/decisionmaximumindependentset_integralflowbundles.rs
new file mode 100644
index 000000000..50c1b776d
--- /dev/null
+++ b/src/unit_tests/rules/decisionmaximumindependentset_integralflowbundles.rs
@@ -0,0 +1,180 @@
+use super::*;
+use crate::solvers::BruteForce;
+use crate::traits::Problem;
+use crate::types::Or;
+
+fn source(
+    n: usize,
+    edges: Vec<(usize, usize)>,
+    bound: i64,
+) -> Decision<MaximumIndependentSet<SimpleGraph, One>> {
+    Decision::new(
+        MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![One; n]),
+        bound,
+    )
+}
+
+#[test]
+fn test_decisionmaximumindependentset_to_integralflowbundles_closed_loop() {
+    for bound in [2, 3] {
+        let source = source(3, vec![(0, 1), (1, 2)], bound);
+        let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source).unwrap();
+        let witness = BruteForce::new().solve(reduction.target_problem()).unwrap();
+        assert_eq!(witness.is_some(), bound == 2);
+        if let Some(witness) = witness {
+            assert_eq!(
+                source.evaluate(&reduction.extract_solution(&witness).unwrap()),
+                Ok(Or(true))
+            );
+        }
+    }
+}
+
+#[test]
+fn test_decision_ifb_all_small_graphs_thresholds_and_binary_flows() {
+    // Conservation and the path bundles force every feasible arc flow to be
+    // binary. Enumerate all binary vectors, including those violating conservation.
+    for n in 0..=3 {
+        let pairs: Vec<_> = (0..n).flat_map(|u| (u..n).map(move |v| (u, v))).collect();
+        for mask in 0usize..1 << pairs.len() {
+            let edges: Vec<_> = pairs
+                .iter()
+                .enumerate()
+                .filter_map(|(i, &e)| (mask >> i & 1 == 1).then_some(e))
+                .collect();
+            for bound in -1..=n as i64 + 1 {
+                let source = source(n, edges.clone(), bound);
+                let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source).unwrap();
+                let target = reduction.target_problem();
+                assert_eq!(
+                    (
+                        target.num_vertices(),
+                        target.num_arcs(),
+                        target.num_bundles()
+                    ),
+                    (n + 3, 2 * n + 2, edges.len() + n + 1)
+                );
+                let mut source_exists = false;
+                for mask in 0usize..1 << n {
+                    let selected: Vec<_> = (0..n).map(|i| mask >> i & 1 == 1).collect();
+                    if source.evaluate(&selected).unwrap().0 {
+                        source_exists = true;
+                        let mut flow: Vec<_> =
+                            selected.iter().flat_map(|&x| [usize::from(x); 2]).collect();
+                        flow.extend([1, 1]);
+                        assert_eq!(target.evaluate(&flow), Ok(Or(true)));
+                    }
+                }
+                let mut target_exists = false;
+                for mask in 0usize..1 << target.num_arcs() {
+                    let flow = (0..target.num_arcs()).map(|i| mask >> i & 1).collect();
+                    if target.evaluate(&flow).unwrap().0 {
+                        target_exists = true;
+                        assert_eq!(
+                            source.evaluate(&reduction.extract_solution(&flow).unwrap()),
+                            Ok(Or(true))
+                        );
+                    }
+                }
+                assert_eq!(
+                    source_exists, target_exists,
+                    "n={n}, edges={edges:?}, bound={bound}"
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn test_decision_ifb_loops_parallel_edges_and_invalid_witnesses() {
+    let source = source(3, vec![(0, 0), (0, 1), (0, 1)], 2);
+    let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source).unwrap();
+    let valid = vec![0, 0, 1, 1, 1, 1, 1, 1];
+    assert_eq!(
+        reduction.extract_solution(&valid).unwrap(),
+        vec![false, true, true]
+    );
+    for flow in [
+        vec![],
+        vec![usize::MAX; 8],
+        vec![0; 8],
+        vec![0, 0, 1, 0, 1, 1, 1, 1], // conservation
+        vec![1, 1, 0, 0, 1, 1, 1, 1], // self-loop
+        vec![0, 0, 2, 2, 1, 1, 1, 1], // path capacity
+    ] {
+        assert!(reduction.extract_solution(&flow).is_err());
+    }
+}
+
+#[test]
+fn test_decision_ifb_dimensions_and_threshold_boundaries() {
+    assert_eq!(flow_dimensions(0, 0), Ok((3, 2, 1)));
+    let n = usize::MAX / 2 - 1;
+    assert_eq!(
+        flow_dimensions(n, usize::MAX - n - 1),
+        Ok((n + 3, usize::MAX - 1, usize::MAX))
+    );
+    for (n, m) in [
+        (usize::MAX, 0),
+        (usize::MAX - 2, 0),
+        (usize::MAX / 2, 0),
+        (1, usize::MAX),
+        (1, usize::MAX - 1),
+    ] {
+        assert!(matches!(
+            flow_dimensions(n, m),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+    for (n, bound, expected) in [
+        (0, i64::MIN, 1),
+        (0, 0, 1),
+        (0, 1, 2),
+        (0, i64::MAX, 2),
+        (3, 2, 3),
+        (3, 3, 4),
+        (3, 4, 5),
+        (3, i64::MAX, 5),
+    ] {
+        assert_eq!(flow_requirement(n, bound), Ok(expected));
+    }
+}
+
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn test_decision_ifb_i64_count_boundaries() {
+    assert_eq!(
+        flow_requirement((i64::MAX - 2) as usize, i64::MAX),
+        Ok(i64::MAX)
+    );
+    for n in [(i64::MAX - 1) as usize, usize::MAX] {
+        assert!(matches!(
+            flow_requirement(n, 0),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+}
+
+#[test]
+fn test_decision_ifb_registration_replaces_optimization_edge() {
+    let entries: Vec<_> = crate::rules::registry::reduction_entries()
+        .into_iter()
+        .filter(|e| e.target_name == "IntegralFlowBundles")
+        .collect();
+    assert_eq!(entries.len(), 1);
+    assert_eq!(entries[0].source_name, "DecisionMaximumIndependentSet");
+    assert_eq!(
+        (entries[0].source_variant_fn)(),
+        vec![("graph", "SimpleGraph"), ("weight", "One")]
+    );
+    // The dynamic executor must reject the old weighted source type, even though
+    // it shares the same decision problem name with the registered unit variant.
+    let weighted = Decision::new(
+        MaximumIndependentSet::new(SimpleGraph::new(0, vec![]), Vec::<i64>::new()),
+        0,
+    );
+    assert!(matches!(
+        (entries[0].reduce_fn.unwrap())(&weighted),
+        Err(crate::rules::ReductionError::SourceTypeMismatch { .. })
+    ));
+}
diff --git a/src/unit_tests/rules/decisionminimumdominatingset_minimumsummulticenter.rs b/src/unit_tests/rules/decisionminimumdominatingset_minimumsummulticenter.rs
index c6418de96..5f39c738d 100644
--- a/src/unit_tests/rules/decisionminimumdominatingset_minimumsummulticenter.rs
+++ b/src/unit_tests/rules/decisionminimumdominatingset_minimumsummulticenter.rs
@@ -4,12 +4,12 @@ use crate::rules::{ReduceTo, ReductionResult};
 use crate::solvers::BruteForce;
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
-use crate::types::{One, Or};
+use crate::types::{Min, One, Or};
 
 fn decision_mds(
     num_vertices: usize,
     edges: &[(usize, usize)],
-    k: i32,
+    k: i64,
 ) -> Decision<MinimumDominatingSet<SimpleGraph, One>> {
     Decision::new(
         MinimumDominatingSet::new(
@@ -27,17 +27,22 @@ fn test_decisionminimumdominatingset_to_minimumsummulticenter_structure() {
         &[(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (3, 5), (4, 5)],
         2,
     );
-    let reduction = ReduceTo::<MinimumSumMulticenter<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumSumMulticenter<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
+    assert_eq!(
+        crate::rules::AggregateReductionResult::target_problem(&reduction).k(),
+        target.k()
+    );
 
     assert_eq!(
         target.graph().num_vertices(),
-        source.inner().graph().num_vertices()
+        source.inner().graph().num_vertices() + 1
     );
     assert_eq!(target.graph().edges(), source.inner().graph().edges());
-    assert_eq!(target.vertex_weights(), vec![1i32; 6].as_slice());
-    assert_eq!(target.edge_lengths(), vec![1i32; 7].as_slice());
-    assert_eq!(target.k(), 2);
+    assert_eq!(target.vertex_weights(), vec![1i64; 7].as_slice());
+    assert_eq!(target.edge_lengths(), vec![1i64; 7].as_slice());
+    assert_eq!(target.k(), 3);
 }
 
 #[test]
@@ -47,20 +52,21 @@ fn test_decisionminimumdominatingset_to_minimumsummulticenter_closed_loop_yes_in
         &[(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (3, 5), (4, 5)],
         2,
     );
-    let reduction = ReduceTo::<MinimumSumMulticenter<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumSumMulticenter<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let target_solutions = BruteForce::new().find_all_witnesses(target);
+    let target_solutions = BruteForce::new().find_all_witnesses(target).unwrap();
     assert!(
         !target_solutions.is_empty(),
         "target should have optimal K-center placements"
     );
 
     for target_solution in target_solutions {
-        assert_eq!(target.evaluate(&target_solution).unwrap(), 4);
-        let extracted = reduction.extract_solution(&target_solution);
-        assert_eq!(extracted, target_solution);
-        assert_eq!(source.evaluate(&extracted), Or(true));
+        assert_eq!(target.evaluate(&target_solution).unwrap().unwrap(), 4);
+        let extracted = reduction.extract_solution(&target_solution).unwrap();
+        assert_eq!(extracted, target_solution[..6]);
+        assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
     }
 }
 
@@ -71,23 +77,116 @@ fn test_decisionminimumdominatingset_to_minimumsummulticenter_closed_loop_no_ins
         &[(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (3, 5), (4, 5)],
         1,
     );
-    let reduction = ReduceTo::<MinimumSumMulticenter<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumSumMulticenter<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let target_solutions = BruteForce::new().find_all_witnesses(target);
+    let target_solutions = BruteForce::new().find_all_witnesses(target).unwrap();
     assert!(
         !target_solutions.is_empty(),
         "target should still have optimal K-center placements"
     );
 
-    let threshold = source.inner().graph().num_vertices() as i32 - source.k() as i32;
+    let threshold = i64::try_from(source.inner().graph().num_vertices()).unwrap()
+        - i64::try_from(source.k()).unwrap();
     for target_solution in target_solutions {
-        let target_value = target.evaluate(&target_solution).unwrap();
+        let target_value = target.evaluate(&target_solution).unwrap().unwrap();
         assert_eq!(target_value, 6);
         assert!(target_value > threshold);
 
-        let extracted = reduction.extract_solution(&target_solution);
-        assert_eq!(extracted, target_solution);
-        assert_eq!(source.evaluate(&extracted), Or(false));
+        assert_eq!(
+            crate::rules::AggregateReductionResult::extract_value(
+                &reduction,
+                Min(Some(target_value))
+            ),
+            Or(false)
+        );
+        assert!(reduction.extract_solution(&target_solution).is_err());
+    }
+}
+
+// Enumerate every graph on at most four vertices and EVERY target placement,
+// including infeasible/nonoptimal ones. Check both directions independently of
+// the ILP pipeline and verify that extraction never accepts a false witness.
+#[test]
+fn test_decisionminimumdominatingset_to_minimumsummulticenter_all_small_graphs() {
+    for n in 0..=4 {
+        let possible_edges: Vec<_> = (0..n)
+            .flat_map(|u| (u + 1..n).map(move |v| (u, v)))
+            .collect();
+        for graph_mask in 0usize..1 << possible_edges.len() {
+            let edges: Vec<_> = possible_edges
+                .iter()
+                .enumerate()
+                .filter(|(i, _)| graph_mask & (1 << i) != 0)
+                .map(|(_, &edge)| edge)
+                .collect();
+            let bounds = [i64::MIN, -1, i64::MAX]
+                .into_iter()
+                .chain(0..=i64::try_from(n).unwrap() + 1);
+            for bound in bounds {
+                let source = decision_mds(n, &edges, bound);
+                let reduction =
+                    ReduceTo::<MinimumSumMulticenter<SimpleGraph, i64>>::reduce_to(&source)
+                        .unwrap();
+                let target = reduction.target_problem();
+                assert!(target.num_vertices() <= n + 2);
+                assert_eq!(target.num_edges(), edges.len());
+                let source_yes = BruteForce::new().solve(&source).unwrap().is_some();
+                let mut optimum = None;
+                for mask in 0usize..1 << target.num_vertices() {
+                    let placement: Vec<_> = (0..target.num_vertices())
+                        .map(|i| mask & (1 << i) != 0)
+                        .collect();
+                    let value = target.evaluate(&placement).unwrap();
+                    if let Some(cost) = value.0 {
+                        optimum = Some(optimum.map_or(cost, |previous: i64| previous.min(cost)));
+                    }
+                    let accepted =
+                        crate::rules::AggregateReductionResult::extract_value(&reduction, value).0;
+                    match reduction.extract_solution(&placement) {
+                        Ok(witness) => {
+                            assert!(accepted);
+                            assert_eq!(source.evaluate(&witness).unwrap(), Or(true));
+                        }
+                        Err(_) => assert!(!accepted),
+                    }
+                }
+                assert_eq!(
+                    crate::rules::AggregateReductionResult::extract_value(&reduction, Min(optimum)),
+                    Or(source_yes),
+                    "n={n}, edges={edges:?}, K={bound}"
+                );
+                assert!(reduction
+                    .extract_solution(&vec![false; target.num_vertices() + 1])
+                    .is_err());
+            }
+        }
+    }
+}
+
+#[test]
+fn test_multicenter_parameter_numeric_boundaries() {
+    use super::multicenter_parameters;
+    use crate::rules::ReductionError;
+
+    // Graph allocation is irrelevant to arithmetic domain validation.
+    for bound in [-1, 0, i64::MAX] {
+        assert!(matches!(
+            multicenter_parameters(usize::MAX, bound),
+            Err(ReductionError::IntegerOverflow { .. })
+        ));
+    }
+    assert!(multicenter_parameters(usize::MAX - 1, -1).is_err());
+    if let Ok(n) = usize::try_from(i64::MAX) {
+        assert_eq!(multicenter_parameters(n, 0).unwrap(), (n + 1, 1, i64::MAX));
+        assert_eq!(
+            multicenter_parameters(n, i64::MAX).unwrap(),
+            (n + 1, n + 1, 0)
+        );
+        assert!(matches!(
+            multicenter_parameters(n + 1, 0),
+            Err(ReductionError::IntegerOverflow { .. })
+        ));
     }
 }
diff --git a/src/unit_tests/rules/decisionminimumdominatingset_minmaxmulticenter.rs b/src/unit_tests/rules/decisionminimumdominatingset_minmaxmulticenter.rs
index f87bf9e65..9e15b4e34 100644
--- a/src/unit_tests/rules/decisionminimumdominatingset_minmaxmulticenter.rs
+++ b/src/unit_tests/rules/decisionminimumdominatingset_minmaxmulticenter.rs
@@ -1,75 +1,154 @@
 use super::*;
-use crate::models::decision::Decision;
-use crate::models::graph::{MinMaxMulticenter, MinimumDominatingSet};
-use crate::rules::ReduceTo;
 use crate::solvers::BruteForce;
-use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
-use crate::types::{One, Or};
 
 fn decision_mds(
-    num_vertices: usize,
+    n: usize,
     edges: &[(usize, usize)],
-    k: i32,
+    bound: i64,
 ) -> Decision<MinimumDominatingSet<SimpleGraph, One>> {
     Decision::new(
-        MinimumDominatingSet::new(
-            SimpleGraph::new(num_vertices, edges.to_vec()),
-            vec![One; num_vertices],
-        ),
-        k,
+        MinimumDominatingSet::new(SimpleGraph::new(n, edges.to_vec()), vec![One; n]),
+        bound,
     )
 }
 
 #[test]
-fn test_decisionminimumdominatingset_to_minmaxmulticenter_structure() {
-    let source = decision_mds(
-        6,
-        &[(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (3, 5), (4, 5)],
-        2,
-    );
-    let reduction = ReduceTo::<MinMaxMulticenter<SimpleGraph, One>>::reduce_to(&source);
+fn test_decisionminimumdominatingset_to_minmaxmulticenter_closed_loop() {
+    let source = decision_mds(3, &[(0, 1), (1, 2)], 1);
+    let reduction = ReduceTo::<MinMaxMulticenter<SimpleGraph, One>>::reduce_to(&source).unwrap();
     let target = reduction.target_problem();
-
+    assert_eq!(target.num_vertices(), 5);
+    assert_eq!(target.num_edges(), 2);
+    assert_eq!(target.k(), 3);
+    for witness in BruteForce::new().find_all_witnesses(target).unwrap() {
+        assert!(witness[3] && witness[4]);
+        assert!(
+            source
+                .evaluate(&reduction.extract_solution(&witness).unwrap())
+                .unwrap()
+                .0
+        );
+    }
+    let source = decision_mds(4, &[(0, 1), (1, 2), (2, 3)], 1);
+    let reduction = ReduceTo::<MinMaxMulticenter<SimpleGraph, One>>::reduce_to(&source).unwrap();
+    let witness = BruteForce::new()
+        .solve(reduction.target_problem())
+        .unwrap()
+        .unwrap();
+    let optimum = reduction.target_problem().evaluate(&witness).unwrap();
+    assert_eq!(optimum, Min(Some(2)));
     assert_eq!(
-        target.graph().num_vertices(),
-        source.inner().graph().num_vertices()
+        crate::rules::AggregateReductionResult::extract_value(&reduction, optimum),
+        Or(false)
     );
-    assert_eq!(target.graph().edges(), source.inner().graph().edges());
-    assert_eq!(target.vertex_weights(), vec![One; 6].as_slice());
-    assert_eq!(target.edge_lengths(), vec![One; 7].as_slice());
-    assert_eq!(target.k(), 2);
+    assert!(reduction.extract_solution(&witness).is_err());
 }
 
 #[test]
-fn test_decisionminimumdominatingset_to_minmaxmulticenter_closed_loop() {
-    let source = decision_mds(
-        6,
-        &[(0, 1), (0, 2), (1, 3), (2, 3), (3, 4), (3, 5), (4, 5)],
-        2,
-    );
-    let reduction = ReduceTo::<MinMaxMulticenter<SimpleGraph, One>>::reduce_to(&source);
-    let target = reduction.target_problem();
+fn test_multicenter_all_small_graphs_bounds_and_placements() {
+    for n in 0usize..=3 {
+        let possible: Vec<_> = (0..n).flat_map(|u| (u..n).map(move |v| (u, v))).collect();
+        for edge_mask in 0..(1usize << possible.len()) {
+            let edges: Vec<_> = possible
+                .iter()
+                .enumerate()
+                .filter_map(|(i, &e)| (edge_mask & (1 << i) != 0).then_some(e))
+                .collect();
+            let n_i64 = i64::try_from(n).unwrap();
+            for bound in [i64::MIN, -1, 0, 1, n_i64, n_i64 + 1, i64::MAX] {
+                let source = decision_mds(n, &edges, bound);
+                let reduction =
+                    ReduceTo::<MinMaxMulticenter<SimpleGraph, One>>::reduce_to(&source).unwrap();
+                let target = reduction.target_problem();
+                assert_eq!(target.graph().edges(), edges);
+                assert_eq!(target.num_vertices(), n + 2);
+                assert_eq!(target.vertex_weights(), vec![One; n + 2]);
+                assert_eq!(target.edge_lengths(), vec![One; edges.len()]);
+                assert!((1..=n + 2).contains(&target.k()));
+                let mut source_yes = false;
+                for mask in 0..(1usize << n) {
+                    let mut witness: Vec<_> = (0..n).map(|v| mask & (1 << v) != 0).collect();
+                    if source.evaluate(&witness).unwrap().0 {
+                        source_yes = true;
+                        let mut count = witness.iter().filter(|&&b| b).count();
+                        for bit in &mut witness {
+                            if !*bit && count < target.k() - 2 {
+                                *bit = true;
+                                count += 1;
+                            }
+                        }
+                        witness.extend([true, true]);
+                        assert!(target.evaluate(&witness).unwrap().0.is_some_and(|r| r <= 1));
+                    }
+                }
+                let mut optimum: Option<i64> = None;
+                for mask in 0..(1usize << (n + 2)) {
+                    let witness: Vec<_> = (0..n + 2).map(|v| mask & (1 << v) != 0).collect();
+                    let radius = target.evaluate(&witness).unwrap().0;
+                    if let Some(r) = radius {
+                        optimum = Some(optimum.map_or(r, |old| old.min(r)));
+                    }
+                    if radius.is_some_and(|r| r <= 1) {
+                        assert!(
+                            source
+                                .evaluate(&reduction.extract_solution(&witness).unwrap())
+                                .unwrap()
+                                .0
+                        );
+                    } else {
+                        assert!(reduction.extract_solution(&witness).is_err());
+                    }
+                }
+                assert_eq!(
+                    crate::rules::AggregateReductionResult::extract_value(&reduction, Min(optimum)),
+                    Or(source_yes)
+                );
+            }
+        }
+    }
+}
 
-    let target_solutions = BruteForce::new().find_all_witnesses(target);
-    assert!(
-        !target_solutions.is_empty(),
-        "target should have feasible K-center placements"
+#[test]
+fn test_multicenter_duplicate_edges_and_malformed_witness() {
+    let source = decision_mds(3, &[(0, 0), (0, 1), (0, 1)], 2);
+    let reduction = ReduceTo::<MinMaxMulticenter<SimpleGraph, One>>::reduce_to(&source).unwrap();
+    let witness = vec![true, false, true, true, true];
+    assert_eq!(
+        reduction.extract_solution(&witness).unwrap(),
+        vec![true, false, true]
     );
-
-    for target_solution in target_solutions {
-        let extracted = reduction.extract_solution(&target_solution);
-        assert_eq!(extracted, target_solution);
-        assert_eq!(source.evaluate(&extracted), Or(true));
+    for bad in [vec![], vec![true; 6]] {
+        assert!(reduction.extract_solution(&bad).is_err());
     }
+    assert_eq!(
+        crate::rules::AggregateReductionResult::extract_value(&reduction, Min(None)),
+        Or(false)
+    );
 }
 
 #[test]
-fn test_decisionminimumdominatingset_to_minmaxmulticenter_no_witness_when_bound_too_small() {
-    let source = decision_mds(4, &[(0, 1), (2, 3)], 1);
-    let reduction = ReduceTo::<MinMaxMulticenter<SimpleGraph, One>>::reduce_to(&source);
-
-    assert!(BruteForce::new()
-        .find_witness(reduction.target_problem())
-        .is_none());
+fn test_multicenter_parameter_boundaries() {
+    assert_eq!(multicenter_parameters(0, i64::MIN).unwrap(), (2, 1));
+    assert_eq!(multicenter_parameters(0, i64::MAX).unwrap(), (2, 2));
+    assert_eq!(multicenter_parameters(3, 0).unwrap(), (5, 2));
+    assert_eq!(multicenter_parameters(3, i64::MAX).unwrap(), (5, 5));
+    for n in [usize::MAX, usize::MAX - 1] {
+        assert!(matches!(
+            multicenter_parameters(n, 0),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+    #[cfg(target_pointer_width = "64")]
+    {
+        let max = usize::try_from(i64::MAX).unwrap();
+        assert!(multicenter_parameters(max + 1, 0).is_err());
+        assert!(multicenter_parameters(max, i64::MAX).is_err());
+        assert!(multicenter_parameters(max - 1, i64::MAX).is_err());
+        assert_eq!(
+            multicenter_parameters(max - 2, i64::MAX).unwrap(),
+            (max, max)
+        );
+        assert_eq!(multicenter_parameters(max, i64::MIN).unwrap(), (max + 2, 1));
+    }
 }
diff --git a/src/unit_tests/rules/decisionminimumvertexcover_hamiltoniancircuit.rs b/src/unit_tests/rules/decisionminimumvertexcover_hamiltoniancircuit.rs
index db7bf2c64..67ba7ee19 100644
--- a/src/unit_tests/rules/decisionminimumvertexcover_hamiltoniancircuit.rs
+++ b/src/unit_tests/rules/decisionminimumvertexcover_hamiltoniancircuit.rs
@@ -9,9 +9,9 @@ use crate::traits::Problem;
 fn decision_mvc(
     num_vertices: usize,
     edges: &[(usize, usize)],
-    weights: &[i32],
-    k: i32,
-) -> Decision<MinimumVertexCover<SimpleGraph, i32>> {
+    weights: &[i64],
+    k: i64,
+) -> Decision<MinimumVertexCover<SimpleGraph, i64>> {
     Decision::new(
         MinimumVertexCover::new(
             SimpleGraph::new(num_vertices, edges.to_vec()),
@@ -24,7 +24,8 @@ fn decision_mvc(
 #[test]
 fn test_decisionminimumvertexcover_to_hamiltoniancircuit_structure_counts() {
     let source = decision_mvc(3, &[(0, 1), (1, 2)], &[1, 1, 1], 1);
-    let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 25);
@@ -35,62 +36,82 @@ fn test_decisionminimumvertexcover_to_hamiltoniancircuit_structure_counts() {
 #[test]
 fn test_decisionminimumvertexcover_to_hamiltoniancircuit_closed_loop() {
     let source = decision_mvc(3, &[(0, 1), (1, 2)], &[1, 1, 1], 1);
-    let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
-    let cover = vec![0, 1, 0];
+    let cover = vec![false, true, false];
     let target_witness = reduction.build_target_witness(&cover);
 
-    assert!(reduction.target_problem().evaluate(&target_witness).0);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_witness)
+            .unwrap()
+            .0
+    );
 
-    let extracted = reduction.extract_solution(&target_witness);
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
     assert_eq!(extracted, cover);
-    assert!(source.evaluate(&extracted).0);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_decisionminimumvertexcover_to_hamiltoniancircuit_ignores_isolated_vertices() {
     let source = decision_mvc(3, &[(0, 1)], &[1, 1, 1], 1);
-    let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source);
-
-    let target_witness = reduction.build_target_witness(&[1, 0, 0]);
-    assert!(reduction.target_problem().evaluate(&target_witness).0);
-
-    let extracted = reduction.extract_solution(&target_witness);
+    let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
+
+    let target_witness = reduction.build_target_witness(&[true, false, false]);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_witness)
+            .unwrap()
+            .0
+    );
+
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
     assert_eq!(extracted.len(), 3);
-    assert_eq!(extracted[2], 0);
-    assert!(source.evaluate(&extracted).0);
+    assert!(!extracted[2]);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_decisionminimumvertexcover_to_hamiltoniancircuit_fixed_yes_when_k_covers_all_active_vertices(
 ) {
     let source = decision_mvc(3, &[(0, 1), (1, 2)], &[1, 1, 1], 3);
-    let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 3);
     assert_eq!(target.num_edges(), 3);
 
     let witness = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("triangle should have a Hamiltonian circuit");
-    let extracted = reduction.extract_solution(&witness);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&witness).unwrap();
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_decisionminimumvertexcover_to_hamiltoniancircuit_fixed_no_when_k_zero() {
     let source = decision_mvc(2, &[(0, 1)], &[1, 1], 0);
-    let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 3);
-    assert!(BruteForce::new().find_witness(target).is_none());
+    assert!(BruteForce::new().solve(target).unwrap().is_none());
 }
 
 #[test]
-#[should_panic(expected = "unit vertex weights")]
 fn test_decisionminimumvertexcover_to_hamiltoniancircuit_rejects_non_unit_weights() {
     let source = decision_mvc(2, &[(0, 1)], &[2, 1], 1);
-    let _ = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source);
+    let error = ReduceTo::<HamiltonianCircuit<SimpleGraph>>::reduce_to(&source).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::rules::ReductionError::InvalidTarget { .. }
+    ));
 }
diff --git a/src/unit_tests/rules/directedhamiltonianpath_ilp.rs b/src/unit_tests/rules/directedhamiltonianpath_ilp.rs
index e13a85326..ad9c9f1bc 100644
--- a/src/unit_tests/rules/directedhamiltonianpath_ilp.rs
+++ b/src/unit_tests/rules/directedhamiltonianpath_ilp.rs
@@ -11,11 +11,11 @@ fn test_reduction_creates_valid_ilp() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = DirectedHamiltonianPath::new(graph);
     let reduction: ReductionDirectedHamiltonianPathToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // n=3, num_vars = 3^2 = 9
-    assert_eq!(ilp.num_vars, 9);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 9);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -27,20 +27,21 @@ fn test_directedhamiltonianpath_to_ilp_closed_loop() {
     // BruteForce to verify feasibility
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute-force should find a solution");
-    assert_eq!(problem.evaluate(&bf_solution), Or(true));
+    assert_eq!(problem.evaluate(&bf_solution).unwrap(), Or(true));
 
     // Solve via ILP
     let reduction: ReductionDirectedHamiltonianPathToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "ILP solution should satisfy the DirectedHamiltonianPath constraint"
     );
@@ -66,14 +67,14 @@ fn test_directedhamiltonianpath_to_ilp_issue_example() {
     );
     let problem = DirectedHamiltonianPath::new(graph);
     let reduction: ReductionDirectedHamiltonianPathToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should find a path");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "ILP solution should be a valid directed Hamiltonian path"
     );
@@ -85,11 +86,11 @@ fn test_directedhamiltonianpath_to_ilp_no_path() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (0, 2)]);
     let problem = DirectedHamiltonianPath::new(graph);
     let reduction: ReductionDirectedHamiltonianPathToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let result = ilp_solver.solve(reduction.target_problem());
     assert!(
-        result.is_none(),
+        result.is_err(),
         "Graph with no Hamiltonian path should be infeasible"
     );
 }
@@ -99,6 +100,6 @@ fn test_directedhamiltonianpath_to_ilp_bf_vs_ilp() {
     let graph = DirectedGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]);
     let problem = DirectedHamiltonianPath::new(graph);
     let reduction: ReductionDirectedHamiltonianPathToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/directedtwocommodityintegralflow_ilp.rs b/src/unit_tests/rules/directedtwocommodityintegralflow_ilp.rs
index 42f09bd3a..d438da773 100644
--- a/src/unit_tests/rules/directedtwocommodityintegralflow_ilp.rs
+++ b/src/unit_tests/rules/directedtwocommodityintegralflow_ilp.rs
@@ -49,20 +49,21 @@ fn infeasible_instance() -> DirectedTwoCommodityIntegralFlow {
 #[test]
 fn test_directedtwocommodityintegralflow_to_ilp_structure() {
     let problem = feasible_instance();
-    let reduction: ReductionD2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionD2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 8 arcs → 2*8 = 16 variables
-    assert_eq!(ilp.num_vars, 16);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 16);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(ilp.objective().is_empty());
 
     // 8 capacity constraints.
     // Conservation is now enforced away from each commodity's own source/sink only:
     // - commodity 1 at vertices 1,2,3,5
     // - commodity 2 at vertices 0,2,3,4
     // That yields 8 conservation equations total, plus 2 sink requirements.
-    assert_eq!(ilp.constraints.len(), 8 + 8 + 2);
+    assert_eq!(ilp.constraints().len(), 8 + 8 + 2);
 }
 
 #[test]
@@ -70,21 +71,23 @@ fn test_directedtwocommodityintegralflow_to_ilp_closed_loop() {
     let problem = feasible_instance();
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("feasible instance has a witness");
     assert!(
-        problem.evaluate(&bf_solution).0,
+        problem.evaluate(&bf_solution).unwrap().0,
         "brute force solution is valid"
     );
 
-    let reduction: ReductionD2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionD2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "ILP extracted solution should be a valid flow"
     );
 }
@@ -92,9 +95,10 @@ fn test_directedtwocommodityintegralflow_to_ilp_closed_loop() {
 #[test]
 fn test_directedtwocommodityintegralflow_to_ilp_infeasible() {
     let problem = infeasible_instance();
-    let reduction: ReductionD2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionD2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible flow instance should produce infeasible ILP"
     );
 }
@@ -104,9 +108,10 @@ fn test_directedtwocommodityintegralflow_to_ilp_disallows_using_other_commodity_
     let graph = DirectedGraph::new(4, vec![(2, 3), (3, 1)]);
     let problem = DirectedTwoCommodityIntegralFlow::new(graph, vec![1, 1], 0, 1, 2, 3, 1, 0);
 
-    let reduction: ReductionD2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionD2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "commodity 1 must conserve flow at commodity 2's source in the ILP reduction"
     );
 }
@@ -114,20 +119,21 @@ fn test_directedtwocommodityintegralflow_to_ilp_disallows_using_other_commodity_
 #[test]
 fn test_directedtwocommodityintegralflow_to_ilp_extract_solution() {
     let problem = feasible_instance();
-    let reduction: ReductionD2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionD2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // f1 routes via (0,2),(2,4): arcs 0,4 = 1; rest 0 for commodity 1
     // f2 routes via (1,3),(3,5): arcs 3,7 = 1; rest 0 for commodity 2
-    let mut target_solution = vec![0usize; 16];
+    let mut target_solution = vec![0_i64; 16];
     target_solution[0] = 1; // f1 on arc (0,2)
     target_solution[4] = 1; // f1 on arc (2,4)
     target_solution[8 + 3] = 1; // f2 on arc (1,3)
     target_solution[8 + 7] = 1; // f2 on arc (3,5)
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     assert_eq!(extracted.len(), 16);
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "manually extracted solution should be valid"
     );
 }
@@ -135,6 +141,27 @@ fn test_directedtwocommodityintegralflow_to_ilp_extract_solution() {
 #[test]
 fn test_directedtwocommodityintegralflow_to_ilp_bf_vs_ilp() {
     let problem = feasible_instance();
-    let reduction: ReductionD2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionD2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
+
+#[test]
+fn test_directedtwocommodityintegralflow_to_ilp_preserves_large_exact_capacity() {
+    let capacity = crate::types::MAX_EXACT_F64_INTEGER + 1;
+    let problem = DirectedTwoCommodityIntegralFlow::new(
+        DirectedGraph::new(2, vec![(0, 1)]),
+        vec![capacity],
+        0,
+        1,
+        0,
+        1,
+        1,
+        1,
+    );
+
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).unwrap();
+    let capacity_constraint = &reduction.target_problem().constraints()[0];
+    assert_eq!(capacity_constraint.terms(), vec![(0, 1), (1, 1)]);
+    assert_eq!(capacity_constraint.rhs(), capacity);
+}
diff --git a/src/unit_tests/rules/disjointconnectingpaths_ilp.rs b/src/unit_tests/rules/disjointconnectingpaths_ilp.rs
index d7aab0c03..740f58586 100644
--- a/src/unit_tests/rules/disjointconnectingpaths_ilp.rs
+++ b/src/unit_tests/rules/disjointconnectingpaths_ilp.rs
@@ -1,8 +1,10 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::rules::ReduceTo;
+use crate::solvers::ILPSolver;
 use crate::topology::SimpleGraph;
+use crate::traits::Problem;
 
 #[test]
 fn test_disjointconnectingpaths_to_ilp_closed_loop() {
@@ -13,12 +15,8 @@ fn test_disjointconnectingpaths_to_ilp_closed_loop() {
         SimpleGraph::new(6, vec![(0, 1), (1, 2), (3, 4), (4, 5)]),
         vec![(0, 2), (3, 5)],
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_satisfaction_round_trip_from_satisfaction_target(
-        &source,
-        &reduction,
-        "DisjointConnectingPaths->ILP closed loop",
-    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
@@ -27,6 +25,46 @@ fn test_disjointconnectingpaths_to_ilp_bf_vs_ilp() {
         SimpleGraph::new(6, vec![(0, 1), (1, 2), (3, 4), (4, 5)]),
         vec![(0, 2), (3, 5)],
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
+
+#[test]
+fn test_disjointconnectingpaths_to_ilp_forbids_using_another_pairs_terminal() {
+    let source = DisjointConnectingPaths::new(
+        SimpleGraph::new(5, vec![(0, 1), (0, 2), (0, 3), (2, 4), (3, 4)]),
+        vec![(0, 1), (2, 3)],
+    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    let mut colliding_flow = vec![0; 20];
+    for index in [0, 13, 14] {
+        colliding_flow[index] = 1;
+    }
+    assert!(!reduction
+        .target_problem()
+        .is_feasible(&colliding_flow)
+        .unwrap());
+    let target_solution = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert!(source.evaluate(&extracted).unwrap().0);
+}
+
+#[test]
+fn test_disjointconnectingpaths_to_ilp_discards_disconnected_circulation() {
+    let source = DisjointConnectingPaths::new(
+        SimpleGraph::new(7, vec![(0, 1), (2, 3), (4, 5), (4, 6), (5, 6)]),
+        vec![(0, 1), (2, 3)],
+    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    let mut target_solution = vec![0; 20];
+    for index in [0, 4, 7, 8, 12] {
+        target_solution[index] = 1;
+    }
+    assert!(reduction
+        .target_problem()
+        .is_feasible(&target_solution)
+        .unwrap());
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![true, true, false, false, false]);
+    assert!(source.evaluate(&extracted).unwrap().0);
+}
diff --git a/src/unit_tests/rules/ensemblecomputation_ilp.rs b/src/unit_tests/rules/ensemblecomputation_ilp.rs
new file mode 100644
index 000000000..3be3c0aaa
--- /dev/null
+++ b/src/unit_tests/rules/ensemblecomputation_ilp.rs
@@ -0,0 +1,50 @@
+use super::*;
+use crate::models::algebraic::ILP;
+use crate::models::misc::EnsembleComputation;
+use crate::rules::ReduceTo;
+use crate::solvers::ILPSolver;
+use crate::traits::Problem;
+use crate::types::Min;
+
+fn feasible_instance() -> EnsembleComputation {
+    EnsembleComputation::new(4, vec![vec![0, 1], vec![0, 1, 2, 3]], 3)
+}
+
+#[test]
+fn test_ensemblecomputation_to_ilp_structure() {
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&feasible_instance()).unwrap();
+    assert_eq!(reduction.target_problem().num_vars(), 75);
+    assert_eq!(reduction.target_problem().constraints().len(), 154);
+}
+
+#[test]
+fn test_ensemblecomputation_to_ilp_closed_loop() {
+    let source = feasible_instance();
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+    let target_solution = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(3)));
+}
+
+#[test]
+fn test_ensemblecomputation_to_ilp_infeasible_budget() {
+    let source = EnsembleComputation::new(3, vec![vec![0, 1, 2]], 1);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+    assert!(ILPSolver::new().solve(reduction.target_problem()).is_err());
+}
+
+#[test]
+fn test_ensemblecomputation_to_ilp_rejects_singleton_target() {
+    let source = EnsembleComputation::new(3, vec![vec![0]], 2);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+    assert!(ILPSolver::new().solve(reduction.target_problem()).is_err());
+}
+
+#[test]
+fn test_ensemblecomputation_to_ilp_empty_family() {
+    let source = EnsembleComputation::new(1, vec![], 2);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+    let target_solution = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(0)));
+}
diff --git a/src/unit_tests/rules/eulerianpath_ilp.rs b/src/unit_tests/rules/eulerianpath_ilp.rs
index ce690f067..7d9f5c3c4 100644
--- a/src/unit_tests/rules/eulerianpath_ilp.rs
+++ b/src/unit_tests/rules/eulerianpath_ilp.rs
@@ -15,7 +15,7 @@ fn issue_instance() -> EulerianPath {
 #[test]
 fn test_eulerianpath_to_ilp_issue_structure() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // m = 4 arcs. Compatible pairs: head(a) = tail(b), a != b:
@@ -24,10 +24,10 @@ fn test_eulerianpath_to_ilp_issue_structure() {
     //   a_2 = (1,2) -> head=2; arcs starting at 2: only a_3 -> (a_2, a_3)
     //   a_3 = (2,0) -> head=0; arcs starting at 0: a_0, a_1 -> (a_3, a_0), (a_3, a_1)
     // So p = 5. num_vars = 5 + 3*4 = 17.
-    assert_eq!(ilp.num_vars, 17);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 17);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
     assert!(
-        ilp.objective.is_empty(),
+        ilp.objective().is_empty(),
         "Pure feasibility ILP should have no objective"
     );
 
@@ -37,24 +37,24 @@ fn test_eulerianpath_to_ilp_issue_structure() {
     //   2*p = 10 (y_{a,b} <= 1, order consistency)
     //   2 (unique start + unique end)
     // Total = 8 + 12 + 10 + 2 = 32.
-    assert_eq!(ilp.constraints.len(), 32);
+    assert_eq!(ilp.constraints().len(), 32);
 }
 
 #[test]
 fn test_eulerianpath_to_ilp_empty_instance() {
     // m = 0: empty ILP, vacuously feasible.
     let source = EulerianPath::new(DirectedGraph::empty(3));
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 0);
-    assert_eq!(ilp.constraints.len(), 0);
+    assert_eq!(ilp.num_vars(), 0);
+    assert_eq!(ilp.constraints().len(), 0);
 
     let solution = ILPSolver::new()
         .solve(ilp)
         .expect("Empty ILP should be feasible");
-    let extracted = reduction.extract_solution(&solution);
+    let extracted = reduction.extract_solution(&solution).unwrap();
     assert_eq!(extracted.len(), 0);
-    assert_eq!(source.evaluate(&extracted), Or(true));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -62,11 +62,11 @@ fn test_eulerianpath_to_ilp_closed_loop() {
     // Solve the ILP on the canonical instance and verify the extracted ordering
     // is a valid directed Eulerian trail in the source.
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible for a YES instance");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert_eq!(extracted.len(), source.num_arcs());
     assert!(
@@ -74,7 +74,7 @@ fn test_eulerianpath_to_ilp_closed_loop() {
         "Extracted ordering must be a valid Eulerian trail, got {:?}",
         extracted
     );
-    assert_eq!(source.evaluate(&extracted), Or(true));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -83,12 +83,12 @@ fn test_eulerianpath_to_ilp_infeasible_no_instance() {
     // degree-balance criterion: vertex 0 has out-degree 2 / in-degree 0, so
     // no Eulerian trail exists.
     let source = EulerianPath::new(DirectedGraph::new(3, vec![(0, 1), (0, 2)]));
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     // The ILP must report infeasibility for a NO instance.
     let solution = ILPSolver::new().solve(reduction.target_problem());
     assert!(
-        solution.is_none(),
+        solution.is_err(),
         "ILP must be infeasible for a degree-unbalanced NO instance, got {:?}",
         solution
     );
@@ -99,12 +99,12 @@ fn test_eulerianpath_to_ilp_closed_circuit_with_loop() {
     // Loop + closed trail: arcs (0,0), (0,1), (1,0).
     // Trail (0,0) -> (0,1) -> (1,0) is a valid closed Eulerian trail.
     let source = EulerianPath::new(DirectedGraph::new(2, vec![(0, 0), (0, 1), (1, 0)]));
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible for a closed Eulerian circuit");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted.len(), 3);
     assert!(
         source.is_valid_solution(&extracted),
diff --git a/src/unit_tests/rules/exactcoverby3sets_algebraicequationsovergf2.rs b/src/unit_tests/rules/exactcoverby3sets_algebraicequationsovergf2.rs
index 8c0d53d7c..5d1fc643f 100644
--- a/src/unit_tests/rules/exactcoverby3sets_algebraicequationsovergf2.rs
+++ b/src/unit_tests/rules/exactcoverby3sets_algebraicequationsovergf2.rs
@@ -6,7 +6,8 @@ use crate::rules::{ReduceTo, ReductionResult};
 #[test]
 fn test_exactcoverby3sets_to_algebraicequationsovergf2_closed_loop() {
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
-    let reduction = ReduceTo::<AlgebraicEquationsOverGF2>::reduce_to(&source);
+    let reduction = ReduceTo::<AlgebraicEquationsOverGF2>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -18,7 +19,8 @@ fn test_exactcoverby3sets_to_algebraicequationsovergf2_closed_loop() {
 #[test]
 fn test_exactcoverby3sets_to_algebraicequationsovergf2_structure() {
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
-    let reduction = ReduceTo::<AlgebraicEquationsOverGF2>::reduce_to(&source);
+    let reduction = ReduceTo::<AlgebraicEquationsOverGF2>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_variables(), 3);
@@ -42,7 +44,13 @@ fn test_exactcoverby3sets_to_algebraicequationsovergf2_structure() {
 #[test]
 fn test_exactcoverby3sets_to_algebraicequationsovergf2_extract_solution_is_identity() {
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
-    let reduction = ReduceTo::<AlgebraicEquationsOverGF2>::reduce_to(&source);
+    let reduction = ReduceTo::<AlgebraicEquationsOverGF2>::reduce_to(&source)
+        .expect("reduction should succeed");
 
-    assert_eq!(reduction.extract_solution(&[1, 0, 1]), vec![1, 0, 1]);
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![true, false, true])
+            .unwrap(),
+        vec![true, false, true]
+    );
 }
diff --git a/src/unit_tests/rules/exactcoverby3sets_boundeddiameterspanningtree.rs b/src/unit_tests/rules/exactcoverby3sets_boundeddiameterspanningtree.rs
index 241b00945..ba458bb61 100644
--- a/src/unit_tests/rules/exactcoverby3sets_boundeddiameterspanningtree.rs
+++ b/src/unit_tests/rules/exactcoverby3sets_boundeddiameterspanningtree.rs
@@ -1,8 +1,7 @@
 use super::*;
 use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::topology::Graph;
-use crate::types::Or;
 
 /// q = 2, m = 2: X = {0..5} with C = [{0,1,2}, {3,4,5}].
 /// Both subsets together form the unique exact cover.
@@ -19,7 +18,8 @@ fn no_instance_simple() -> ExactCoverBy3Sets {
 #[test]
 fn test_exactcoverby3sets_to_boundeddiameterspanningtree_closed_loop() {
     let source = yes_instance_simple();
-    let reduction = ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -31,7 +31,8 @@ fn test_exactcoverby3sets_to_boundeddiameterspanningtree_closed_loop() {
 #[test]
 fn test_exactcoverby3sets_to_boundeddiameterspanningtree_structure() {
     let source = yes_instance_simple();
-    let reduction = ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let m = source.num_subsets();
@@ -45,7 +46,7 @@ fn test_exactcoverby3sets_to_boundeddiameterspanningtree_structure() {
     // Diameter bound is always 4 in the canonical construction.
     assert_eq!(target.diameter_bound(), 4);
     // Weight bound B = 4q + m + 2.
-    let expected_weight_bound = (4 * q + m + 2) as i32;
+    let expected_weight_bound = i64::try_from(4 * q + m + 2).unwrap();
     assert_eq!(*target.weight_bound(), expected_weight_bound);
 
     // Verify the first two edges are the forced-center path with weight 1.
@@ -66,35 +67,95 @@ fn test_exactcoverby3sets_to_boundeddiameterspanningtree_structure() {
 #[test]
 fn test_exactcoverby3sets_to_boundeddiameterspanningtree_extract_solution() {
     let source = yes_instance_simple();
-    let reduction = ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i32>>::reduce_to(&source);
-
-    // Build a target config that selects both root-to-set edges (indices 2 and 3).
-    // The remaining selections do not matter for extraction.
-    let mut target_config = vec![0; reduction.target_problem().num_edges()];
-    target_config[2] = 1;
-    target_config[3] = 1;
-    let extracted = reduction.extract_solution(&target_config);
-    assert_eq!(extracted, vec![1, 1]);
-
-    // Only s_0 selected via root edge.
-    let mut target_config = vec![0; reduction.target_problem().num_edges()];
-    target_config[2] = 1;
-    let extracted = reduction.extract_solution(&target_config);
-    assert_eq!(extracted, vec![1, 0]);
+    let reduction = ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
+
+    // The full feasible tree selects every edge except the set-clique edge.
+    let mut target_config = vec![true; reduction.target_problem().num_edges()];
+    *target_config.last_mut().unwrap() = false;
+    assert_eq!(
+        reduction.extract_solution(&target_config).unwrap(),
+        vec![true, true]
+    );
+
+    // Root indicators alone are not a spanning-tree certificate.
+    let mut invalid = vec![false; target_config.len()];
+    invalid[2] = true;
+    invalid[3] = true;
+    assert!(reduction.extract_solution(&invalid).is_err());
+    assert!(reduction.extract_solution(&vec![]).is_err());
+    assert!(reduction
+        .extract_solution(&vec![true; target_config.len()])
+        .is_err());
 }
 
 #[test]
 fn test_exactcoverby3sets_to_boundeddiameterspanningtree_no_instance() {
     let source = no_instance_simple();
-    let reduction = ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // The target should be infeasible: no spanning tree satisfies both weight
     // bound B = 4q + m + 2 = 12 and diameter bound D = 4. For an Or-valued
-    // problem with no satisfying configuration, BruteForce::find_witness
+    // problem with no satisfying configuration, BruteForce::solve
     // returns None (witnesses are configs that evaluate to Or(true), and none
     // exist here). Equivalently, the brute-force aggregate evaluates to
     // Or(false).
-    assert!(BruteForce::new().find_witness(target).is_none());
-    assert_eq!(BruteForce::new().solve(target), Or(false));
+    assert!(BruteForce::new().solve(target).unwrap().is_none());
+    assert!(reduction.extract_solution(&vec![]).is_err());
+}
+
+#[test]
+fn test_exactcoverby3sets_to_boundeddiameterspanningtree_universe_boundaries() {
+    for universe in [3, usize::MAX - usize::MAX % 3] {
+        let source = ExactCoverBy3Sets::new(universe, vec![]);
+        let reduction =
+            ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+        assert_eq!(reduction.target_problem().num_vertices(), 2);
+        assert_eq!(reduction.target_problem().num_edges(), 0);
+        assert!(BruteForce::new()
+            .solve(reduction.target_problem())
+            .unwrap()
+            .is_none());
+        assert!(reduction.extract_solution(&vec![]).is_err());
+    }
+    let source = ExactCoverBy3Sets::new(0, vec![]);
+    let reduction =
+        ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+    let witness = BruteForce::new()
+        .solve(reduction.target_problem())
+        .unwrap()
+        .unwrap();
+    assert_eq!(witness, vec![true, true]);
+    assert_eq!(
+        reduction.extract_solution(&witness).unwrap(),
+        Vec::<bool>::new()
+    );
+}
+
+#[test]
+fn test_exactcoverby3sets_to_boundeddiameterspanningtree_duplicate_sets() {
+    let source = ExactCoverBy3Sets::new(3, vec![[0, 1, 2], [0, 1, 2]]);
+    let reduction =
+        ReduceTo::<BoundedDiameterSpanningTree<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+    let witnesses = BruteForce::new()
+        .find_all_witnesses(reduction.target_problem())
+        .unwrap();
+    assert!(!witnesses.is_empty());
+    for witness in witnesses {
+        let extracted = reduction.extract_solution(&witness).unwrap();
+        assert!(source.is_valid_solution(&extracted).unwrap());
+        assert_eq!(extracted.iter().filter(|&&x| x).count(), 1);
+    }
+}
+
+#[test]
+fn test_exactcoverby3sets_to_boundeddiameterspanningtree_dimension_arithmetic() {
+    type R = ReductionX3CToBoundedDiameterSpanningTree;
+    assert_eq!(R::dimensions(0, 0).unwrap(), (3, 2, 2));
+    assert_eq!(R::dimensions(6, 4).unwrap(), (13, 24, 14));
+    assert!(R::dimensions(usize::MAX, 0).is_err());
+    assert!(R::dimensions(0, usize::MAX / 2).is_err());
+    assert!(R::dimensions(usize::MAX - 3, 0).is_err());
 }
diff --git a/src/unit_tests/rules/exactcoverby3sets_ilp.rs b/src/unit_tests/rules/exactcoverby3sets_ilp.rs
index cb33bceb8..06de42089 100644
--- a/src/unit_tests/rules/exactcoverby3sets_ilp.rs
+++ b/src/unit_tests/rules/exactcoverby3sets_ilp.rs
@@ -7,45 +7,49 @@ use crate::types::Or;
 fn test_reduction_creates_valid_ilp() {
     // Universe {0..5}, 3 triples
     let problem = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
-    let reduction: ReductionX3CToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionX3CToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 3);
-    assert_eq!(ilp.constraints.len(), 7); // 6 element constraints + 1 cardinality
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 3);
+    assert_eq!(ilp.constraints().len(), 7); // 6 element constraints + 1 cardinality
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_exactcoverby3sets_to_ilp_bf_vs_ilp() {
     let problem = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4], [1, 2, 5]]);
-    let reduction: ReductionX3CToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionX3CToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_witness = bf.find_witness(&problem).expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should be feasible");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_solution_extraction() {
     let problem = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5]]);
-    let reduction: ReductionX3CToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionX3CToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = vec![1, 1]; // select both triples
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![1, 1]);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![true, true]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_exactcoverby3sets_to_ilp_trivial() {
     let problem = ExactCoverBy3Sets::new(0, vec![]);
-    let reduction: ReductionX3CToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionX3CToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 0);
-    assert_eq!(ilp.constraints.len(), 1); // just the cardinality constraint Σ = 0
+    assert_eq!(ilp.num_vars(), 0);
+    assert_eq!(ilp.constraints().len(), 1); // just the cardinality constraint Σ = 0
 }
diff --git a/src/unit_tests/rules/exactcoverby3sets_maximumsetpacking.rs b/src/unit_tests/rules/exactcoverby3sets_maximumsetpacking.rs
index 14c53bb1d..146036ae1 100644
--- a/src/unit_tests/rules/exactcoverby3sets_maximumsetpacking.rs
+++ b/src/unit_tests/rules/exactcoverby3sets_maximumsetpacking.rs
@@ -11,7 +11,8 @@ fn test_exactcoverby3sets_to_maximumsetpacking_closed_loop() {
         6,
         vec![[0, 1, 2], [0, 1, 3], [3, 4, 5], [2, 4, 5], [1, 3, 5]],
     );
-    let reduction = ReduceTo::<MaximumSetPacking<One>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaximumSetPacking<One>>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -26,7 +27,8 @@ fn test_exactcoverby3sets_to_maximumsetpacking_structure() {
         6,
         vec![[0, 1, 2], [0, 1, 3], [3, 4, 5], [2, 4, 5], [1, 3, 5]],
     );
-    let reduction = ReduceTo::<MaximumSetPacking<One>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaximumSetPacking<One>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Same number of sets as source subsets
@@ -51,33 +53,37 @@ fn test_exactcoverby3sets_to_maximumsetpacking_unsatisfiable() {
     // Universe {0,1,2,3,4,5} but subsets cannot form an exact cover:
     // all subsets share element 0
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [0, 3, 4], [0, 4, 5]]);
-    let reduction = ReduceTo::<MaximumSetPacking<One>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaximumSetPacking<One>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Best packing can only select one set (since all share element 0)
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("Should have an optimal solution");
-    assert_eq!(target.evaluate(&best), Max(Some(1)));
+    assert_eq!(target.evaluate(&best).unwrap(), Max(Some(1)));
 
     // q = 2, but packing value is 1 < 2, so no exact cover exists
-    let extracted = reduction.extract_solution(&best);
-    assert!(!source.evaluate(&extracted));
+    let extracted = reduction.extract_solution(&best).unwrap();
+    assert!(!source.evaluate(&extracted).unwrap());
 }
 
 #[test]
 fn test_exactcoverby3sets_to_maximumsetpacking_optimal_value() {
     // Satisfiable instance: S0={0,1,2}, S1={3,4,5} form an exact cover
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
-    let reduction = ReduceTo::<MaximumSetPacking<One>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaximumSetPacking<One>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("Should have an optimal solution");
     // Maximum packing: S0 + S1 = 2 disjoint sets = q
-    assert_eq!(target.evaluate(&best), Max(Some(2)));
+    assert_eq!(target.evaluate(&best).unwrap(), Max(Some(2)));
 
-    let extracted = reduction.extract_solution(&best);
-    assert!(source.evaluate(&extracted));
+    let extracted = reduction.extract_solution(&best).unwrap();
+    assert!(source.evaluate(&extracted).unwrap());
 }
diff --git a/src/unit_tests/rules/exactcoverby3sets_minimumaxiomset.rs b/src/unit_tests/rules/exactcoverby3sets_minimumaxiomset.rs
index 074f6ddc8..757f57c49 100644
--- a/src/unit_tests/rules/exactcoverby3sets_minimumaxiomset.rs
+++ b/src/unit_tests/rules/exactcoverby3sets_minimumaxiomset.rs
@@ -18,7 +18,8 @@ fn shared_zero_instance() -> ExactCoverBy3Sets {
 #[test]
 fn test_exactcoverby3sets_to_minimumaxiomset_closed_loop() {
     let source = issue_yes_instance();
-    let reduction = ReduceTo::<MinimumAxiomSet>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumAxiomSet>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_satisfaction_round_trip_from_optimization_target(
@@ -28,15 +29,17 @@ fn test_exactcoverby3sets_to_minimumaxiomset_closed_loop() {
     );
 
     let optimal = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("expected an optimal target witness");
-    assert_eq!(target.evaluate(&optimal), Min(Some(2)));
+    assert_eq!(target.evaluate(&optimal).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_exactcoverby3sets_to_minimumaxiomset_structure() {
     let source = issue_yes_instance();
-    let reduction = ReduceTo::<MinimumAxiomSet>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumAxiomSet>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_sentences(), 11);
@@ -57,23 +60,30 @@ fn test_exactcoverby3sets_to_minimumaxiomset_structure() {
 #[test]
 fn test_exactcoverby3sets_to_minimumaxiomset_no_instance_gap() {
     let source = shared_zero_instance();
-    let reduction = ReduceTo::<MinimumAxiomSet>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumAxiomSet>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let optimal = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("expected an optimal target witness");
-    assert_eq!(target.evaluate(&optimal), Min(Some(3)));
+    assert_eq!(target.evaluate(&optimal).unwrap(), Min(Some(3)));
 
-    let extracted = reduction.extract_solution(&optimal);
-    assert!(!source.evaluate(&extracted));
+    let extracted = reduction.extract_solution(&optimal).unwrap();
+    assert!(!source.evaluate(&extracted).unwrap());
 }
 
 #[test]
 fn test_extract_solution_reads_only_set_sentence_axioms() {
     let source = issue_yes_instance();
-    let reduction = ReduceTo::<MinimumAxiomSet>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumAxiomSet>::reduce_to(&source).expect("reduction should succeed");
 
-    let extracted = reduction.extract_solution(&[1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1]);
-    assert_eq!(extracted, vec![0, 0, 0, 1, 1]);
+    let extracted = reduction
+        .extract_solution(&vec![
+            true, false, true, false, false, true, false, false, false, true, true,
+        ])
+        .unwrap();
+    assert_eq!(extracted, vec![false, false, false, true, true]);
 }
diff --git a/src/unit_tests/rules/exactcoverby3sets_minimumfaultdetectiontestset.rs b/src/unit_tests/rules/exactcoverby3sets_minimumfaultdetectiontestset.rs
index a974fbe9c..aeb36f7a0 100644
--- a/src/unit_tests/rules/exactcoverby3sets_minimumfaultdetectiontestset.rs
+++ b/src/unit_tests/rules/exactcoverby3sets_minimumfaultdetectiontestset.rs
@@ -17,7 +17,8 @@ fn no_cover_instance() -> ExactCoverBy3Sets {
 #[test]
 fn test_exactcoverby3sets_to_minimumfaultdetectiontestset_closed_loop() {
     let source = issue_yes_instance();
-    let reduction = ReduceTo::<MinimumFaultDetectionTestSet>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumFaultDetectionTestSet>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_satisfaction_round_trip_from_optimization_target(
@@ -27,15 +28,17 @@ fn test_exactcoverby3sets_to_minimumfaultdetectiontestset_closed_loop() {
     );
 
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("expected an optimal target witness");
-    assert_eq!(target.evaluate(&best), Min(Some(2)));
+    assert_eq!(target.evaluate(&best).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_exactcoverby3sets_to_minimumfaultdetectiontestset_structure() {
     let source = issue_yes_instance();
-    let reduction = ReduceTo::<MinimumFaultDetectionTestSet>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumFaultDetectionTestSet>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 10);
@@ -68,23 +71,31 @@ fn test_exactcoverby3sets_to_minimumfaultdetectiontestset_structure() {
 #[test]
 fn test_exactcoverby3sets_to_minimumfaultdetectiontestset_no_instance_gap() {
     let source = no_cover_instance();
-    let reduction = ReduceTo::<MinimumFaultDetectionTestSet>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumFaultDetectionTestSet>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("expected an optimal target witness");
-    assert_eq!(target.evaluate(&best), Min(Some(3)));
+    assert_eq!(target.evaluate(&best).unwrap(), Min(Some(3)));
 
-    let extracted = reduction.extract_solution(&best);
-    assert!(!source.evaluate(&extracted));
+    let extracted = reduction.extract_solution(&best).unwrap();
+    assert!(!source.evaluate(&extracted).unwrap());
 }
 
 #[test]
 fn test_exactcoverby3sets_to_minimumfaultdetectiontestset_extract_solution_identity() {
     let source = issue_yes_instance();
-    let reduction = ReduceTo::<MinimumFaultDetectionTestSet>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumFaultDetectionTestSet>::reduce_to(&source)
+        .expect("reduction should succeed");
 
-    assert_eq!(reduction.extract_solution(&[1, 1, 0]), vec![1, 1, 0]);
-    assert!(source.evaluate(&[1, 1, 0]).0);
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![vec![true], vec![true], vec![false]])
+            .unwrap(),
+        vec![true, true, false]
+    );
+    assert!(source.evaluate(&vec![true, true, false]).unwrap().0);
 }
diff --git a/src/unit_tests/rules/exactcoverby3sets_staffscheduling.rs b/src/unit_tests/rules/exactcoverby3sets_staffscheduling.rs
index a8e7ed6e3..ea050fe01 100644
--- a/src/unit_tests/rules/exactcoverby3sets_staffscheduling.rs
+++ b/src/unit_tests/rules/exactcoverby3sets_staffscheduling.rs
@@ -11,7 +11,7 @@ fn test_exactcoverby3sets_to_staffscheduling_closed_loop() {
     // Universe {0,1,2,3,4,5}, subsets [{0,1,2}, {3,4,5}, {0,3,4}, {1,2,5}]
     // Exact cover: S0={0,1,2} + S1={3,4,5}
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4], [1, 2, 5]]);
-    let result = ReduceTo::<StaffScheduling>::reduce_to(&source);
+    let result = ReduceTo::<StaffScheduling>::reduce_to(&source).expect("reduction should succeed");
     let target = result.target_problem();
 
     // Check target dimensions
@@ -32,9 +32,9 @@ fn test_exactcoverby3sets_to_staffscheduling_no_solution() {
     // Universe {0,1,2,3,4,5} with overlapping subsets that cannot form exact cover
     // All subsets share element 0
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [0, 3, 4], [0, 4, 5]]);
-    let result = ReduceTo::<StaffScheduling>::reduce_to(&source);
+    let result = ReduceTo::<StaffScheduling>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(result.target_problem());
+    let solutions = solver.find_all_witnesses(result.target_problem()).unwrap();
     assert!(
         solutions.is_empty(),
         "No exact cover exists, so StaffScheduling should have no solution"
@@ -46,29 +46,31 @@ fn test_exactcoverby3sets_to_staffscheduling_unique_cover() {
     // Universe {0,1,2,3,4,5,6,7,8} (q=3)
     // Only one exact cover: S0 + S1 + S2
     let source = ExactCoverBy3Sets::new(9, vec![[0, 1, 2], [3, 4, 5], [6, 7, 8]]);
-    let result = ReduceTo::<StaffScheduling>::reduce_to(&source);
+    let result = ReduceTo::<StaffScheduling>::reduce_to(&source).expect("reduction should succeed");
     let target = result.target_problem();
 
     assert_eq!(target.num_periods(), 9);
     assert_eq!(target.num_workers(), 3); // q = 9/3 = 3
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(target);
+    let solutions = solver.find_all_witnesses(target).unwrap();
     // Each satisfying target config should extract to selecting all 3 subsets
     for sol in &solutions {
-        let extracted = result.extract_solution(sol);
+        let extracted = result.extract_solution(sol).unwrap();
         assert!(
-            source.evaluate(&extracted).0,
+            source.evaluate(&extracted).unwrap().0,
             "Extracted solution must be valid"
         );
     }
     // There should be exactly one satisfying assignment (up to extraction)
-    let extracted_solutions: Vec<Vec<usize>> = solutions
+    let extracted_solutions: Vec<Vec<bool>> = solutions
         .iter()
-        .map(|s| result.extract_solution(s))
+        .map(|s| result.extract_solution(s).unwrap())
         .collect();
     assert!(
-        extracted_solutions.iter().all(|s| *s == vec![1, 1, 1]),
+        extracted_solutions
+            .iter()
+            .all(|s| *s == vec![true, true, true]),
         "Only exact cover is all three subsets"
     );
 }
@@ -77,27 +79,27 @@ fn test_exactcoverby3sets_to_staffscheduling_unique_cover() {
 fn test_exactcoverby3sets_to_staffscheduling_extract_solution() {
     // Verify extract_solution maps correctly
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4], [1, 2, 5]]);
-    let result = ReduceTo::<StaffScheduling>::reduce_to(&source);
+    let result = ReduceTo::<StaffScheduling>::reduce_to(&source).expect("reduction should succeed");
 
     // StaffScheduling config: [1, 1, 0, 0] means 1 worker on schedule 0 and 1 on schedule 1
     let target_config = vec![1, 1, 0, 0];
-    let extracted = result.extract_solution(&target_config);
-    assert_eq!(extracted, vec![1, 1, 0, 0]);
+    let extracted = result.extract_solution(&target_config).unwrap();
+    assert_eq!(extracted, vec![true, true, false, false]);
 
     // Verify the extracted solution is valid in the source
-    assert!(source.evaluate(&extracted).0);
+    assert!(source.evaluate(&extracted).unwrap().0);
 
     // Config with 0 workers everywhere should extract to all-zero (no subsets selected)
     let empty_config = vec![0, 0, 0, 0];
-    let extracted_empty = result.extract_solution(&empty_config);
-    assert_eq!(extracted_empty, vec![0, 0, 0, 0]);
+    let extracted_empty = result.extract_solution(&empty_config).unwrap();
+    assert_eq!(extracted_empty, vec![false, false, false, false]);
 }
 
 #[test]
 fn test_exactcoverby3sets_to_staffscheduling_schedule_structure() {
     // Verify the schedule patterns are correctly constructed
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5]]);
-    let result = ReduceTo::<StaffScheduling>::reduce_to(&source);
+    let result = ReduceTo::<StaffScheduling>::reduce_to(&source).expect("reduction should succeed");
     let target = result.target_problem();
 
     let schedules = target.schedules();
diff --git a/src/unit_tests/rules/exactcoverby3sets_subsetproduct.rs b/src/unit_tests/rules/exactcoverby3sets_subsetproduct.rs
index 6433f7dcd..dac72241d 100644
--- a/src/unit_tests/rules/exactcoverby3sets_subsetproduct.rs
+++ b/src/unit_tests/rules/exactcoverby3sets_subsetproduct.rs
@@ -7,7 +7,8 @@ use num_bigint::BigUint;
 #[test]
 fn test_exactcoverby3sets_to_subsetproduct_closed_loop() {
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
-    let reduction = ReduceTo::<SubsetProduct>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<SubsetProduct>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -19,7 +20,8 @@ fn test_exactcoverby3sets_to_subsetproduct_closed_loop() {
 #[test]
 fn test_exactcoverby3sets_to_subsetproduct_structure() {
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
-    let reduction = ReduceTo::<SubsetProduct>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<SubsetProduct>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let expected_sizes: Vec<BigUint> = vec![30u64, 1001, 154]
@@ -34,15 +36,22 @@ fn test_exactcoverby3sets_to_subsetproduct_structure() {
 #[test]
 fn test_exactcoverby3sets_to_subsetproduct_extract_solution_is_identity() {
     let source = ExactCoverBy3Sets::new(6, vec![[0, 1, 2], [3, 4, 5], [0, 3, 4]]);
-    let reduction = ReduceTo::<SubsetProduct>::reduce_to(&source);
-
-    assert_eq!(reduction.extract_solution(&[1, 0, 1]), vec![1, 0, 1]);
+    let reduction =
+        ReduceTo::<SubsetProduct>::reduce_to(&source).expect("reduction should succeed");
+
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![true, false, true])
+            .unwrap(),
+        vec![true, false, true]
+    );
 }
 
 #[test]
 fn test_exactcoverby3sets_to_subsetproduct_supports_large_universe() {
     let source = ExactCoverBy3Sets::new(18, vec![[0, 1, 2], [15, 16, 17]]);
-    let reduction = ReduceTo::<SubsetProduct>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<SubsetProduct>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let expected_sizes: Vec<BigUint> = vec![30u64, 190_747u64]
diff --git a/src/unit_tests/rules/expectedretrievalcost_ilp.rs b/src/unit_tests/rules/expectedretrievalcost_ilp.rs
index 03fb59663..ae9b2af03 100644
--- a/src/unit_tests/rules/expectedretrievalcost_ilp.rs
+++ b/src/unit_tests/rules/expectedretrievalcost_ilp.rs
@@ -6,24 +6,29 @@ use crate::types::Min;
 #[test]
 fn test_reduction_creates_valid_ilp() {
     // 2 records, 2 sectors
-    let problem = ExpectedRetrievalCost::new(vec![0.5, 0.5], 2);
-    let reduction: ReductionERCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = ExpectedRetrievalCost::new(vec![0.5, 0.5], 2).unwrap();
+    let reduction: ReductionERCToILP =
+        ReduceTo::<ILP<bool, f64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // num_records=2, num_sectors=2: n=4 x-vars, n^2=16 z-vars -> 20 total
     let n = 2 * 2; // 4
-    assert_eq!(ilp.num_vars, n + n * n, "Should have n + n^2 variables");
+    assert_eq!(ilp.num_vars(), n + n * n, "Should have n + n^2 variables");
 
     // num_constraints = 2 assignment + 3*n^2 McCormick = 2 + 48 = 50
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         2 + 3 * n * n,
         "Should have 2 + 3*n^2 constraints"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize cost");
+    assert_eq!(
+        ilp.sense(),
+        ObjectiveSense::Minimize,
+        "Should minimize cost"
+    );
     // Objective should have non-empty coefficients
     assert!(
-        !ilp.objective.is_empty(),
+        !ilp.objective().is_empty(),
         "Objective should have cost coefficients"
     );
 }
@@ -31,19 +36,20 @@ fn test_reduction_creates_valid_ilp() {
 #[test]
 fn test_expectedretrievalcost_to_ilp_bf_vs_ilp() {
     // 3 records, 2 sectors
-    let problem = ExpectedRetrievalCost::new(vec![0.3, 0.4, 0.3], 2);
-    let reduction: ReductionERCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = ExpectedRetrievalCost::new(vec![0.3, 0.4, 0.3], 2).unwrap();
+    let reduction: ReductionERCToILP =
+        ReduceTo::<ILP<bool, f64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_witness = bf.find_witness(&problem).unwrap();
-    let bf_cost = problem.expected_cost(&bf_witness).unwrap();
+    let bf_witness = bf.solve(&problem).unwrap().unwrap();
+    let bf_cost = problem.expected_cost(&bf_witness).unwrap().unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_cost = problem.expected_cost(&extracted).unwrap();
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_cost = problem.expected_cost(&extracted).unwrap().unwrap();
 
     // ILP cost should match BF optimal cost
     assert!(
@@ -55,13 +61,14 @@ fn test_expectedretrievalcost_to_ilp_bf_vs_ilp() {
 #[test]
 fn test_solution_extraction() {
     // 2 records, 2 sectors
-    let problem = ExpectedRetrievalCost::new(vec![0.5, 0.5], 2);
-    let reduction: ReductionERCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = ExpectedRetrievalCost::new(vec![0.5, 0.5], 2).unwrap();
+    let reduction: ReductionERCToILP =
+        ReduceTo::<ILP<bool, f64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // record 0 -> sector 0, record 1 -> sector 1
     // x_{0,0}=1, x_{0,1}=0, x_{1,0}=0, x_{1,1}=1
-    let mut ilp_solution = vec![0usize; 4 + 16]; // n + n^2
-                                                 // x vars
+    let mut ilp_solution = vec![0_i64; 4 + 16]; // n + n^2
+                                                // x vars
     ilp_solution[0] = 1; // x_{0,0}
     ilp_solution[3] = 1; // x_{1,1}
                          // z vars: z_{r,s,r',s'} at offset 4 + (r*2+s)*4 + (r'*2+s')
@@ -70,21 +77,22 @@ fn test_solution_extraction() {
     // z_{1,1,1,1} = x_{1,1}*x_{1,1} = 1: offset 4 + 3*4 + 3 = 4+15=19
     ilp_solution[19] = 1;
 
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 1]);
 }
 
 #[test]
 fn test_expectedretrievalcost_to_ilp_closed_loop() {
     // 2 records, 2 sectors
-    let problem = ExpectedRetrievalCost::new(vec![0.5, 0.5], 2);
-    let reduction: ReductionERCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = ExpectedRetrievalCost::new(vec![0.5, 0.5], 2).unwrap();
+    let reduction: ReductionERCToILP =
+        ReduceTo::<ILP<bool, f64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(
         matches!(value, Min(Some(_))),
         "Should produce a valid assignment"
diff --git a/src/unit_tests/rules/factoring_circuit.rs b/src/unit_tests/rules/factoring_circuit.rs
index 5cea21a14..5b16f2702 100644
--- a/src/unit_tests/rules/factoring_circuit.rs
+++ b/src/unit_tests/rules/factoring_circuit.rs
@@ -1,30 +1,40 @@
 use super::*;
 use crate::rules::test_helpers::assert_optimization_round_trip_from_satisfaction_target;
 use crate::solvers::BruteForce;
+use crate::traits::Problem;
+use num_bigint::BigUint;
 use std::collections::HashMap;
 include!("../jl_helpers.rs");
 
 #[test]
 fn test_read_bit() {
     // 6 = 110 in binary (little-endian: bit1=0, bit2=1, bit3=1)
-    assert!(!read_bit(6, 1)); // bit 1 (LSB) = 0
-    assert!(read_bit(6, 2)); // bit 2 = 1
-    assert!(read_bit(6, 3)); // bit 3 = 1
-    assert!(!read_bit(6, 4)); // bit 4 = 0
+    assert!(!read_bit(&BigUint::from(6u32), 1)); // bit 1 (LSB) = 0
+    assert!(read_bit(&BigUint::from(6u32), 2)); // bit 2 = 1
+    assert!(read_bit(&BigUint::from(6u32), 3)); // bit 3 = 1
+    assert!(!read_bit(&BigUint::from(6u32), 4)); // bit 4 = 0
 
     // 15 = 1111 in binary
-    assert!(read_bit(15, 1));
-    assert!(read_bit(15, 2));
-    assert!(read_bit(15, 3));
-    assert!(read_bit(15, 4));
-    assert!(!read_bit(15, 5));
+    assert!(read_bit(&BigUint::from(15u32), 1));
+    assert!(read_bit(&BigUint::from(15u32), 2));
+    assert!(read_bit(&BigUint::from(15u32), 3));
+    assert!(read_bit(&BigUint::from(15u32), 4));
+    assert!(!read_bit(&BigUint::from(15u32), 5));
+}
+
+#[test]
+fn test_read_bit_supports_positions_beyond_u64_width() {
+    let value = BigUint::from(1u32) << 100;
+    assert!(read_bit(&value, 101));
+    assert!(!read_bit(&value, 100));
 }
 
 #[test]
 fn test_reduction_structure() {
     // Factor 6 = 2 * 3 with 2-bit factors
-    let factoring = Factoring::new(2, 2, 6);
-    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&factoring);
+    let factoring = Factoring::with_factor_bits(6, 2, 2);
+    let reduction =
+        ReduceTo::<CircuitSAT>::reduce_to(&factoring).expect("reduction should succeed");
 
     assert_eq!(reduction.p_vars().len(), 2);
     assert_eq!(reduction.q_vars().len(), 2);
@@ -34,8 +44,9 @@ fn test_reduction_structure() {
 #[test]
 fn test_reduction_structure_3x3() {
     // Factor 15 = 3 * 5 with 3-bit factors
-    let factoring = Factoring::new(3, 3, 15);
-    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&factoring);
+    let factoring = Factoring::with_factor_bits(15, 3, 3);
+    let reduction =
+        ReduceTo::<CircuitSAT>::reduce_to(&factoring).expect("reduction should succeed");
 
     assert_eq!(reduction.p_vars().len(), 3);
     assert_eq!(reduction.q_vars().len(), 3);
@@ -95,13 +106,14 @@ fn check_factorization_satisfies(
     }
 
     // Also verify the product equals target (redundant but explicit)
-    p_val * q_val == factoring.target()
+    BigUint::from(p_val) * BigUint::from(q_val) == *factoring.target()
 }
 
 #[test]
 fn test_factorization_6_satisfies_circuit() {
-    let factoring = Factoring::new(2, 2, 6);
-    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&factoring);
+    let factoring = Factoring::with_factor_bits(6, 2, 2);
+    let reduction =
+        ReduceTo::<CircuitSAT>::reduce_to(&factoring).expect("reduction should succeed");
 
     // 2 * 3 = 6 should satisfy the circuit
     assert!(
@@ -130,8 +142,9 @@ fn test_factorization_6_satisfies_circuit() {
 
 #[test]
 fn test_factoring_to_circuit_closed_loop() {
-    let factoring = Factoring::new(4, 4, 15);
-    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&factoring);
+    let factoring = Factoring::with_factor_bits(15, 4, 4);
+    let reduction =
+        ReduceTo::<CircuitSAT>::reduce_to(&factoring).expect("reduction should succeed");
 
     // Valid factorizations of 15
     assert!(
@@ -160,8 +173,9 @@ fn test_factoring_to_circuit_closed_loop() {
 
 #[test]
 fn test_factorization_21_satisfies_circuit() {
-    let factoring = Factoring::new(3, 3, 21);
-    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&factoring);
+    let factoring = Factoring::with_factor_bits(21, 3, 3);
+    let reduction =
+        ReduceTo::<CircuitSAT>::reduce_to(&factoring).expect("reduction should succeed");
 
     // 3 * 7 = 21
     assert!(
@@ -182,8 +196,9 @@ fn test_factorization_21_satisfies_circuit() {
 
 #[test]
 fn test_target_problem_structure() {
-    let factoring = Factoring::new(3, 4, 15);
-    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&factoring);
+    let factoring = Factoring::with_factor_bits(15, 3, 4);
+    let reduction =
+        ReduceTo::<CircuitSAT>::reduce_to(&factoring).expect("reduction should succeed");
     let circuit = reduction.target_problem();
 
     // Verify the circuit has variables and assignments
@@ -193,40 +208,47 @@ fn test_target_problem_structure() {
 
 #[test]
 fn test_extract_solution() {
-    let factoring = Factoring::new(2, 2, 6);
-    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&factoring);
+    let factoring = Factoring::with_factor_bits(6, 2, 2);
+    let reduction =
+        ReduceTo::<CircuitSAT>::reduce_to(&factoring).expect("reduction should succeed");
     let circuit_sat = reduction.target_problem();
 
     // Create a solution where p=2 (binary: 01) and q=3 (binary: 11)
     // We need to find the indices of p1, p2, q1, q2 in the variable list
     let var_names = circuit_sat.variable_names();
-    let mut sol = vec![0usize; var_names.len()];
+    let mut sol = vec![false; var_names.len()];
 
     // Now evaluate the circuit to set all internal variables correctly
     let assignments = evaluate_multiplier_circuit(&reduction, 2, 3);
     for (i, name) in var_names.iter().enumerate() {
         if let Some(&val) = assignments.get(name) {
-            sol[i] = if val { 1 } else { 0 };
+            sol[i] = val;
         }
     }
 
-    let factoring_sol = reduction.extract_solution(&sol);
+    let factoring_sol = reduction.extract_solution(&sol).unwrap();
+    let (p, q) = factoring_sol.clone();
+    assert_eq!(p, BigUint::from(2u32), "p should be 2");
+    assert_eq!(q, BigUint::from(3u32), "q should be 3");
+    assert_eq!(p * q, BigUint::from(6u32), "Product should equal target");
+
+    let assignments = evaluate_multiplier_circuit(&reduction, 3, 2);
+    for (i, name) in var_names.iter().enumerate() {
+        if let Some(&val) = assignments.get(name) {
+            sol[i] = val;
+        }
+    }
     assert_eq!(
-        factoring_sol.len(),
-        4,
-        "Should have 4 bits (2 for p, 2 for q)"
+        reduction.extract_solution(&sol).unwrap(),
+        (BigUint::from(2u32), BigUint::from(3u32))
     );
-
-    let (p, q) = factoring.read_factors(&factoring_sol);
-    assert_eq!(p, 2, "p should be 2");
-    assert_eq!(q, 3, "q should be 3");
-    assert_eq!(p * q, 6, "Product should equal target");
 }
 
 #[test]
 fn test_prime_7_only_trivial_factorizations() {
-    let factoring = Factoring::new(3, 3, 7);
-    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&factoring);
+    let factoring = Factoring::with_factor_bits(7, 3, 3);
+    let reduction =
+        ReduceTo::<CircuitSAT>::reduce_to(&factoring).expect("reduction should succeed");
 
     // Check that only trivial factorizations satisfy
     for p in 0..8u64 {
@@ -258,8 +280,9 @@ fn test_prime_7_only_trivial_factorizations() {
 #[test]
 fn test_all_2bit_factorizations() {
     // Test all possible 2-bit * 2-bit multiplications for target 6
-    let factoring = Factoring::new(2, 2, 6);
-    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&factoring);
+    let factoring = Factoring::with_factor_bits(6, 2, 2);
+    let reduction =
+        ReduceTo::<CircuitSAT>::reduce_to(&factoring).expect("reduction should succeed");
 
     let mut valid_factorizations = Vec::new();
     for p in 0..4u64 {
@@ -283,8 +306,9 @@ fn test_all_2bit_factorizations() {
 #[test]
 fn test_factorization_1_trivial() {
     // Factor 1 = 1 * 1
-    let factoring = Factoring::new(2, 2, 1);
-    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&factoring);
+    let factoring = Factoring::with_factor_bits(1, 2, 2);
+    let reduction =
+        ReduceTo::<CircuitSAT>::reduce_to(&factoring).expect("reduction should succeed");
 
     assert!(
         check_factorization_satisfies(&factoring, &reduction, 1, 1),
@@ -296,10 +320,20 @@ fn test_factorization_1_trivial() {
     );
 }
 
+#[test]
+fn test_oversized_target_is_explicitly_infeasible() {
+    let target = BigUint::from(1u32) << 70;
+    let source = Factoring::with_factor_bits(target, 2, 2);
+    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&source).unwrap();
+    let target = reduction.target_problem();
+    let config = vec![false; target.num_variables()];
+    assert!(!target.evaluate(&config).unwrap());
+}
+
 #[test]
 fn test_jl_parity_factoring_to_circuitsat() {
-    let source = Factoring::new(1, 1, 1);
-    let result = ReduceTo::<CircuitSAT>::reduce_to(&source);
+    let source = Factoring::with_factor_bits(1, 1, 1);
+    let result = ReduceTo::<CircuitSAT>::reduce_to(&source).expect("reduction should succeed");
     assert_optimization_round_trip_from_satisfaction_target(
         &source,
         &result,
@@ -310,10 +344,88 @@ fn test_jl_parity_factoring_to_circuitsat() {
     ))
     .unwrap();
     let solver = BruteForce::new();
-    let jl_best_source = jl_parse_configs_set(&data["cases"][0]["best_source"]);
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let jl_best_source: HashSet<(BigUint, BigUint)> =
+        jl_parse_configs_set(&data["cases"][0]["best_source"])
+            .into_iter()
+            .map(|bits| {
+                let decode = |slice: &[usize]| {
+                    slice
+                        .iter()
+                        .enumerate()
+                        .fold(BigUint::from(0u32), |value, (bit, &set)| {
+                            if set == 1 {
+                                value + (BigUint::from(1u32) << bit)
+                            } else {
+                                value
+                            }
+                        })
+                };
+                (decode(&bits[..source.m()]), decode(&bits[source.m()..]))
+            })
+            .collect();
+    let best_source: HashSet<(BigUint, BigUint)> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_eq!(
         best_source, jl_best_source,
         "Factoring best source mismatch"
     );
 }
+
+#[test]
+fn test_factoring_to_circuit_zero_width_closed_loop() {
+    for n in 0..=3 {
+        for value in [0u32, 1, 2, 7] {
+            let source = Factoring::with_factor_bits(value, 0, n);
+            let reduction = ReduceTo::<CircuitSAT>::reduce_to(&source).unwrap();
+            assert_eq!(reduction.m_vars().len(), n);
+            let witness = BruteForce::new().solve(reduction.target_problem()).unwrap();
+            assert_eq!(witness.is_some(), value == 0);
+            if let Some(witness) = witness {
+                let extracted = reduction.extract_solution(&witness).unwrap();
+                assert!(source.is_valid_factorization(&extracted));
+                assert!(extracted.0.is_zero());
+            }
+        }
+    }
+}
+
+#[test]
+fn test_factoring_to_circuit_rejects_invalid_certificates() {
+    let source = Factoring::with_factor_bits(6, 2, 2);
+    let reduction = ReduceTo::<CircuitSAT>::reduce_to(&source).unwrap();
+    assert!(reduction.extract_solution(&vec![]).is_err());
+    assert!(reduction
+        .extract_solution(&vec![false; reduction.target_problem().num_variables()])
+        .is_err());
+    let values = evaluate_multiplier_circuit(&reduction, 1, 1);
+    let config = reduction
+        .target_problem()
+        .variable_names()
+        .iter()
+        .map(|name| values[name])
+        .collect();
+    assert!(reduction.extract_solution(&config).is_err());
+}
+
+#[test]
+fn test_factoring_to_circuit_dimensions() {
+    assert_eq!(
+        ReductionFactoringToCircuit::dimensions(0, 0).unwrap(),
+        (0, 2)
+    );
+    assert_eq!(
+        ReductionFactoringToCircuit::dimensions(2, 3).unwrap(),
+        (5, 48)
+    );
+    for (m, n) in [
+        (usize::MAX, usize::MAX),
+        (0, usize::MAX),
+        (usize::MAX / 2, usize::MAX / 2),
+    ] {
+        let source = Factoring::with_factor_bits(0u32, m, n);
+        assert!(ReduceTo::<CircuitSAT>::reduce_to(&source).is_err());
+    }
+}
diff --git a/src/unit_tests/rules/factoring_ilp.rs b/src/unit_tests/rules/factoring_ilp.rs
index 85bc86003..472e97016 100644
--- a/src/unit_tests/rules/factoring_ilp.rs
+++ b/src/unit_tests/rules/factoring_ilp.rs
@@ -1,40 +1,43 @@
 use super::*;
 use crate::solvers::{BruteForce, ILPSolver};
+use num_bigint::BigUint;
 
 #[test]
 fn test_reduction_creates_valid_ilp() {
     // Factor 6 with 2-bit factors
-    let problem = Factoring::new(2, 2, 6);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(6, 2, 2);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check variable count: m + n + m*n + (m+n) = 2 + 2 + 4 + 4 = 12
-    assert_eq!(ilp.num_vars, 12);
+    assert_eq!(ilp.num_vars(), 12);
 
     // Check constraint count: 3*m*n + 4*m + 4*n + 1 = 12 + 8 + 8 + 1 = 29
-    assert_eq!(ilp.constraints.len(), 29);
+    assert_eq!(ilp.constraints().len(), 29);
 
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_variable_layout() {
-    let problem = Factoring::new(3, 2, 6);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(6, 2, 3);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
-    // p variables: [0, 1, 2]
+    // p variables: [0, 1]
     assert_eq!(reduction.p_var(0), 0);
-    assert_eq!(reduction.p_var(2), 2);
+    assert_eq!(reduction.p_var(1), 1);
 
-    // q variables: [3, 4]
-    assert_eq!(reduction.q_var(0), 3);
-    assert_eq!(reduction.q_var(1), 4);
+    // q variables: [2, 3, 4]
+    assert_eq!(reduction.q_var(0), 2);
+    assert_eq!(reduction.q_var(2), 4);
 
-    // z variables: [5, 6, 7, 8, 9, 10] (3x2 = 6)
+    // z variables: [5, 6, 7, 8, 9, 10] (2x3 = 6)
     assert_eq!(reduction.z_var(0, 0), 5);
     assert_eq!(reduction.z_var(0, 1), 6);
-    assert_eq!(reduction.z_var(1, 0), 7);
-    assert_eq!(reduction.z_var(2, 1), 10);
+    assert_eq!(reduction.z_var(1, 0), 8);
+    assert_eq!(reduction.z_var(1, 2), 10);
 
     // carry variables: [11, 12, 13, 14, 15] (m+n = 5)
     assert_eq!(reduction.carry_var(0), 11);
@@ -44,19 +47,20 @@ fn test_variable_layout() {
 #[test]
 fn test_factor_6() {
     // 6 = 2 × 3 or 3 × 2
-    let problem = Factoring::new(2, 2, 6);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(6, 2, 2);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Verify it's a valid factorization
     assert!(problem.is_valid_factorization(&extracted));
 
-    let (a, b) = problem.read_factors(&extracted);
-    assert_eq!(a * b, 6);
+    let (a, b) = extracted.clone();
+    assert_eq!(a * b, BigUint::from(6u32));
 }
 
 #[test]
@@ -64,10 +68,11 @@ fn test_factor_15() {
     // Closed-loop test for factoring 15 = 3 × 5 (or 5 × 3, 1 × 15, 15 × 1)
 
     // 1. Create factoring instance: find p (4-bit) × q (4-bit) = 15
-    let problem = Factoring::new(4, 4, 15);
+    let problem = Factoring::with_factor_bits(15, 4, 4);
 
     // 2. Reduce to ILP
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 3. Solve ILP
@@ -75,119 +80,122 @@ fn test_factor_15() {
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
 
     // 4. Extract factoring solution
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // 5. Verify: solution is valid and p × q = 15
     assert!(problem.is_valid_factorization(&extracted));
-    let (p, q) = problem.read_factors(&extracted);
-    assert_eq!(p * q, 15); // e.g., (3, 5) or (5, 3)
+    let (p, q) = extracted.clone();
+    assert_eq!(p * q, BigUint::from(15u32)); // e.g., (3, 5) or (5, 3)
 }
 
 #[test]
 fn test_factor_35() {
     // 35 = 5 × 7 or 7 × 5
-    let problem = Factoring::new(3, 3, 35);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(35, 3, 3);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(problem.is_valid_factorization(&extracted));
 
-    let (a, b) = problem.read_factors(&extracted);
-    assert_eq!(a * b, 35);
+    let (a, b) = extracted.clone();
+    assert_eq!(a * b, BigUint::from(35u32));
 }
 
 #[test]
 fn test_factor_one() {
     // 1 = 1 × 1
-    let problem = Factoring::new(2, 2, 1);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(1, 2, 2);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(problem.is_valid_factorization(&extracted));
 
-    let (a, b) = problem.read_factors(&extracted);
-    assert_eq!(a * b, 1);
+    let (a, b) = extracted.clone();
+    assert_eq!(a * b, BigUint::from(1u32));
 }
 
 #[test]
 fn test_factor_prime() {
     // 7 is prime: 7 = 1 × 7 or 7 × 1
-    let problem = Factoring::new(3, 3, 7);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(7, 3, 3);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(problem.is_valid_factorization(&extracted));
 
-    let (a, b) = problem.read_factors(&extracted);
-    assert_eq!(a * b, 7);
+    let (a, b) = extracted.clone();
+    assert_eq!(a * b, BigUint::from(7u32));
 }
 
 #[test]
 fn test_factor_square() {
     // 9 = 3 × 3
-    let problem = Factoring::new(3, 3, 9);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(9, 3, 3);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(problem.is_valid_factorization(&extracted));
 
-    let (a, b) = problem.read_factors(&extracted);
-    assert_eq!(a * b, 9);
+    let (a, b) = extracted.clone();
+    assert_eq!(a * b, BigUint::from(9u32));
 }
 
 #[test]
 fn test_infeasible_target_too_large() {
     // Target 100 with 2-bit factors (max product is 3 × 3 = 9)
-    let problem = Factoring::new(2, 2, 100);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(100, 2, 2);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let result = ilp_solver.solve(ilp);
 
-    assert!(result.is_none(), "Should be infeasible");
+    assert!(result.is_err(), "Should be infeasible");
 }
 
 #[test]
 fn test_factoring_to_ilp_closed_loop() {
-    let problem = Factoring::new(2, 2, 6);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(6, 2, 2);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Get ILP solution
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let ilp_factors = reduction.extract_solution(&ilp_solution);
+    let ilp_factors = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Get brute force solutions
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&problem);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
 
     // ILP solution should be among brute force solutions
-    let (a, b) = problem.read_factors(&ilp_factors);
-    let bf_pairs: Vec<(u64, u64)> = bf_solutions
-        .iter()
-        .map(|s| problem.read_factors(s))
-        .collect();
+    let (a, b) = ilp_factors.clone();
+    let bf_pairs: Vec<(BigUint, BigUint)> = bf_solutions.to_vec();
 
     assert!(
-        bf_pairs.contains(&(a, b)),
+        bf_pairs.contains(&(a.clone(), b.clone())),
         "ILP solution ({}, {}) should be in brute force solutions {:?}",
         a,
         b,
@@ -197,8 +205,9 @@ fn test_factoring_to_ilp_closed_loop() {
 
 #[test]
 fn test_solution_extraction() {
-    let problem = Factoring::new(2, 2, 6);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(6, 2, 2);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manually construct ILP solution for 2 × 3 = 6
     // p = 2 = binary 10 -> p_0=0, p_1=1
@@ -207,39 +216,40 @@ fn test_solution_extraction() {
     // z_10 = p_1 * q_0 = 1, z_11 = p_1 * q_1 = 1
     // Variables: [p0, p1, q0, q1, z00, z01, z10, z11, c0, c1, c2, c3]
     let ilp_solution = vec![0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    // Should extract [p0, p1, q0, q1] = [0, 1, 1, 1]
-    assert_eq!(extracted, vec![0, 1, 1, 1]);
+    assert_eq!(extracted, (BigUint::from(2u32), BigUint::from(3u32)));
 
-    let (a, b) = problem.read_factors(&extracted);
-    assert_eq!(a, 2);
-    assert_eq!(b, 3);
-    assert_eq!(a * b, 6);
+    let (a, b) = extracted.clone();
+    assert_eq!(a, BigUint::from(2u32));
+    assert_eq!(b, BigUint::from(3u32));
+    assert_eq!(a * b, BigUint::from(6u32));
 }
 
 #[test]
 fn test_target_ilp_structure() {
-    let problem = Factoring::new(3, 4, 12);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(12, 3, 4);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // num_vars = 3 + 4 + 12 + 7 = 26
-    assert_eq!(ilp.num_vars, 26);
+    assert_eq!(ilp.num_vars(), 26);
 
     // num_constraints = 3*12 + 4*3 + 4*4 + 1 = 36 + 12 + 16 + 1 = 65
-    assert_eq!(ilp.constraints.len(), 65);
+    assert_eq!(ilp.constraints().len(), 65);
 }
 
 #[test]
-fn test_solve_reduced() {
-    let problem = Factoring::new(2, 2, 6);
+fn test_integer_ilp_pipeline_solution() {
+    let problem = Factoring::with_factor_bits(6, 2, 2);
 
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let solution = reduction.extract_solution(&ilp_solution);
+    let solution = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(problem.is_valid_factorization(&solution));
 }
@@ -247,32 +257,42 @@ fn test_solve_reduced() {
 #[test]
 fn test_asymmetric_bit_widths() {
     // 12 = 3 × 4 or 4 × 3 or 2 × 6 or 6 × 2 or 1 × 12 or 12 × 1
-    let problem = Factoring::new(2, 4, 12);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(12, 2, 4);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(problem.is_valid_factorization(&extracted));
 
-    let (a, b) = problem.read_factors(&extracted);
-    assert_eq!(a * b, 12);
+    let (a, b) = extracted.clone();
+    assert_eq!(a * b, BigUint::from(12u32));
+}
+
+#[test]
+fn test_oversized_biguint_target_makes_ilp_infeasible() {
+    let target = BigUint::from(1u32) << 70;
+    let problem = Factoring::with_factor_bits(target, 2, 2);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).unwrap();
+    assert!(ILPSolver::new().solve(reduction.target_problem()).is_err());
 }
 
 #[test]
 fn test_constraint_count_formula() {
     // Verify constraint count matches formula: 3*m*n + 4*m + 4*n + 1
     // (3*m*n McCormick + (m+n) bit equations + 1 final carry + (m+n) binary bounds + 2*(m+n) carry bounds)
-    for (m, n) in [(2, 2), (3, 3), (2, 4), (4, 2)] {
-        let problem = Factoring::new(m, n, 1);
-        let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    for (m, n) in [(2, 2), (3, 3), (2, 4), (3, 4)] {
+        let problem = Factoring::with_factor_bits(1, m, n);
+        let reduction: ReductionFactoringToILP =
+            ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
         let ilp = reduction.target_problem();
 
         let expected = 3 * m * n + 4 * m + 4 * n + 1;
         assert_eq!(
-            ilp.constraints.len(),
+            ilp.constraints().len(),
             expected,
             "Constraint count mismatch for m={}, n={}",
             m,
@@ -284,23 +304,27 @@ fn test_constraint_count_formula() {
 #[test]
 fn test_variable_count_formula() {
     // Verify variable count matches formula: m + n + m*n + (m+n)
-    for (m, n) in [(2, 2), (3, 3), (2, 4), (4, 2)] {
-        let problem = Factoring::new(m, n, 1);
-        let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    for (m, n) in [(2, 2), (3, 3), (2, 4), (3, 4)] {
+        let problem = Factoring::with_factor_bits(1, m, n);
+        let reduction: ReductionFactoringToILP =
+            ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
         let ilp = reduction.target_problem();
 
         let expected = m + n + m * n + (m + n);
         assert_eq!(
-            ilp.num_vars, expected,
+            ilp.num_vars(),
+            expected,
             "Variable count mismatch for m={}, n={}",
-            m, n
+            m,
+            n
         );
     }
 }
 
 #[test]
 fn test_factoring_to_ilp_bf_vs_ilp() {
-    let problem = Factoring::new(2, 2, 6);
-    let reduction: ReductionFactoringToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = Factoring::with_factor_bits(6, 2, 2);
+    let reduction: ReductionFactoringToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/feasibleregisterassignment_ilp.rs b/src/unit_tests/rules/feasibleregisterassignment_ilp.rs
index b4c0c36ef..6b18e1e2a 100644
--- a/src/unit_tests/rules/feasibleregisterassignment_ilp.rs
+++ b/src/unit_tests/rules/feasibleregisterassignment_ilp.rs
@@ -10,26 +10,26 @@ fn feasible_example() -> FeasibleRegisterAssignment {
 #[test]
 fn test_feasible_register_assignment_to_ilp_structure() {
     let source = feasible_example();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 14);
-    assert_eq!(ilp.constraints.len(), 42);
-    assert_eq!(ilp.objective, vec![]);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 14);
+    assert_eq!(ilp.constraints().len(), 42);
+    assert_eq!(ilp.objective(), vec![]);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_feasible_register_assignment_to_ilp_closed_loop() {
     let source = feasible_example();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("feasible source instance should yield a feasible ILP");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(source.evaluate(&extracted), Or(true));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
     let mut sorted = extracted.clone();
     sorted.sort_unstable();
     assert_eq!(sorted, vec![0, 1, 2, 3]);
@@ -38,10 +38,10 @@ fn test_feasible_register_assignment_to_ilp_closed_loop() {
 #[test]
 fn test_feasible_register_assignment_to_ilp_infeasible() {
     let source = FeasibleRegisterAssignment::new(3, vec![(0, 1), (0, 2), (1, 2)], 1, vec![0, 0, 0]);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "register-conflict source instance should reduce to an infeasible ILP"
     );
 }
@@ -49,6 +49,6 @@ fn test_feasible_register_assignment_to_ilp_infeasible() {
 #[test]
 fn test_feasible_register_assignment_to_ilp_bf_vs_ilp() {
     let source = feasible_example();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/flowshopscheduling_ilp.rs b/src/unit_tests/rules/flowshopscheduling_ilp.rs
index 23195381c..34da74e87 100644
--- a/src/unit_tests/rules/flowshopscheduling_ilp.rs
+++ b/src/unit_tests/rules/flowshopscheduling_ilp.rs
@@ -8,20 +8,21 @@ use crate::types::Or;
 fn test_flowshopscheduling_to_ilp_closed_loop() {
     // 2 machines, 3 jobs, deadline 10
     let problem = FlowShopScheduling::new(2, vec![vec![2, 3], vec![3, 2], vec![1, 4]], 10);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("feasible instance should have a witness");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "ILP extracted solution should be a valid schedule"
     );
@@ -31,9 +32,9 @@ fn test_flowshopscheduling_to_ilp_closed_loop() {
 fn test_flowshopscheduling_to_ilp_infeasible() {
     // 2 machines, 3 jobs with large processing times, very tight deadline
     let problem = FlowShopScheduling::new(2, vec![vec![5, 5], vec![5, 5], vec![5, 5]], 6);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible FSS should produce infeasible ILP"
     );
 }
@@ -42,26 +43,26 @@ fn test_flowshopscheduling_to_ilp_infeasible() {
 fn test_flowshopscheduling_to_ilp_single_job() {
     // 2 machines, 1 job, deadline 10
     let problem = FlowShopScheduling::new(2, vec![vec![3, 4]], 10);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("single-job ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_flowshopscheduling_to_ilp_bf_vs_ilp() {
     let problem = FlowShopScheduling::new(2, vec![vec![2, 3], vec![3, 2], vec![1, 4]], 10);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should be feasible");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/graph.rs b/src/unit_tests/rules/graph.rs
index bbd8211c7..df044287b 100644
--- a/src/unit_tests/rules/graph.rs
+++ b/src/unit_tests/rules/graph.rs
@@ -1,4 +1,5 @@
 use super::*;
+use crate::expr::Expr;
 use crate::models::algebraic::{ILP, QUBO};
 use crate::models::formula::{
     CircuitSAT, Maximum2Satisfiability, NAESatisfiability, Satisfiability,
@@ -7,17 +8,64 @@ use crate::models::graph::MaxCut;
 use crate::models::graph::{MaximumIndependentSet, MinimumVertexCover};
 use crate::models::misc::Knapsack;
 use crate::models::set::MaximumSetPacking;
-use crate::rules::cost::{Minimize, MinimizeSteps};
-use crate::rules::graph::{classify_problem_category, ReductionMode, ReductionStep};
-use crate::rules::registry::{EdgeCapabilities, ReductionEntry};
+use crate::registry::ProblemCategory;
+use crate::rules::graph::{ReductionMode, ReductionStep};
+use crate::rules::registry::{ReductionEntry, ReductionParameterDeclarations};
 use crate::rules::traits::{AggregateReductionResult, ReductionResult};
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
-use crate::types::{One, ProblemSize, Sum};
+use crate::types::{One, ProblemParameters, Sum};
 use petgraph::graph::DiGraph;
 use serde_json::json;
 use std::any::Any;
-use std::collections::{BTreeMap, HashMap};
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+fn empty_parameter_contract() -> Result<ReductionParameterContract, ParameterContractError> {
+    ReductionParameterContract::new(
+        "synthetic edge",
+        ReductionParameterDeclarations {
+            relation: None,
+            fields: vec![],
+            unavailable: vec![crate::rules::registry::UnavailableParameterField {
+                field: "size",
+                reason: "synthetic edge does not declare a symbolic parameter",
+            }],
+        },
+    )
+}
+
+fn symbolic_size_edge(fields: &[(&'static str, &str)], turing: bool) -> ReductionEdgeData {
+    ReductionEdgeData {
+        parameter_contract: ReductionParameterContract::new(
+            "synthetic edge",
+            ReductionParameterDeclarations {
+                relation: Some(crate::parameters::ParameterRelation::Exact),
+                fields: fields
+                    .iter()
+                    .map(|(field, expression)| (*field, Expr::try_parse(expression).unwrap()))
+                    .collect(),
+                unavailable: vec![],
+            },
+        ),
+        reduce_fn: Some(|_| panic!("size search must not execute reductions")),
+        reduce_aggregate_fn: None,
+        turing,
+    }
+}
+
+fn named_path(names: &[&str]) -> ReductionPath {
+    ReductionPath {
+        steps: names
+            .iter()
+            .map(|name| ReductionStep {
+                name: (*name).to_string(),
+                variant: BTreeMap::new(),
+            })
+            .collect(),
+    }
+}
 
 #[derive(Clone)]
 struct AggregateChainSource;
@@ -33,14 +81,16 @@ struct NaturalVariantProblem;
 
 impl Problem for AggregateChainSource {
     const NAME: &'static str = "AggregateChainSource";
+    type Solution = Vec<usize>;
     type Value = Sum<u64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![1]
-    }
+    crate::problem_parameters![("num_variables", num_variables)];
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Sum(config.iter().sum::<usize>() as u64)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok(Sum(config.iter().sum::<usize>() as u64))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -48,16 +98,24 @@ impl Problem for AggregateChainSource {
     }
 }
 
+impl crate::solvers::BruteForceProblem for AggregateChainSource {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![1]
+    }
+}
+
 impl Problem for AggregateChainMiddle {
     const NAME: &'static str = "AggregateChainMiddle";
+    type Solution = Vec<usize>;
     type Value = Sum<u64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![1]
-    }
+    crate::problem_parameters![("num_variables", num_variables)];
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Sum(config.iter().sum::<usize>() as u64)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok(Sum(config.iter().sum::<usize>() as u64))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -65,16 +123,24 @@ impl Problem for AggregateChainMiddle {
     }
 }
 
+impl crate::solvers::BruteForceProblem for AggregateChainMiddle {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![1]
+    }
+}
+
 impl Problem for AggregateChainTarget {
     const NAME: &'static str = "AggregateChainTarget";
+    type Solution = Vec<usize>;
     type Value = Sum<u64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![1]
-    }
+    crate::problem_parameters![("num_variables", num_variables)];
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Sum(config.iter().sum::<usize>() as u64)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok(Sum(config.iter().sum::<usize>() as u64))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -82,16 +148,24 @@ impl Problem for AggregateChainTarget {
     }
 }
 
+impl crate::solvers::BruteForceProblem for AggregateChainTarget {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![1]
+    }
+}
+
 impl Problem for NaturalVariantProblem {
     const NAME: &'static str = "NaturalVariantProblem";
+    type Solution = Vec<usize>;
     type Value = Sum<u64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![1]
-    }
+    crate::problem_parameters![("num_variables", num_variables)];
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Sum(config.iter().sum::<usize>() as u64)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok(Sum(config.iter().sum::<usize>() as u64))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -99,6 +173,12 @@ impl Problem for NaturalVariantProblem {
     }
 }
 
+impl crate::solvers::BruteForceProblem for NaturalVariantProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![1]
+    }
+}
+
 struct SourceToMiddleAggregateResult {
     target: AggregateChainMiddle,
 }
@@ -135,22 +215,34 @@ impl AggregateReductionResult for MiddleToTargetAggregateResult {
 
 fn reduce_source_to_middle_aggregate(
     any: &dyn Any,
-) -> Box<dyn crate::rules::traits::DynAggregateReductionResult> {
-    any.downcast_ref::<AggregateChainSource>()
-        .expect("expected AggregateChainSource");
-    Box::new(SourceToMiddleAggregateResult {
+) -> Result<Box<dyn crate::rules::traits::DynAggregateReductionResult>, crate::rules::ReductionError>
+{
+    any.downcast_ref::<AggregateChainSource>().ok_or(
+        crate::rules::ReductionError::SourceTypeMismatch {
+            source_problem: AggregateChainSource::NAME,
+            target_problem: AggregateChainMiddle::NAME,
+            expected: std::any::type_name::<AggregateChainSource>(),
+        },
+    )?;
+    Ok(Box::new(SourceToMiddleAggregateResult {
         target: AggregateChainMiddle,
-    })
+    }))
 }
 
 fn reduce_middle_to_target_aggregate(
     any: &dyn Any,
-) -> Box<dyn crate::rules::traits::DynAggregateReductionResult> {
-    any.downcast_ref::<AggregateChainMiddle>()
-        .expect("expected AggregateChainMiddle");
-    Box::new(MiddleToTargetAggregateResult {
+) -> Result<Box<dyn crate::rules::traits::DynAggregateReductionResult>, crate::rules::ReductionError>
+{
+    any.downcast_ref::<AggregateChainMiddle>().ok_or(
+        crate::rules::ReductionError::SourceTypeMismatch {
+            source_problem: AggregateChainMiddle::NAME,
+            target_problem: AggregateChainTarget::NAME,
+            expected: std::any::type_name::<AggregateChainMiddle>(),
+        },
+    )?;
+    Ok(Box::new(MiddleToTargetAggregateResult {
         target: AggregateChainTarget,
-    })
+    }))
 }
 
 struct SourceToMiddleWitnessResult {
@@ -165,31 +257,97 @@ impl ReductionResult for SourceToMiddleWitnessResult {
         &self.target
     }
 
-    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        target_solution.to_vec()
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        Ok(target_solution.to_vec())
     }
 }
 
 fn reduce_source_to_middle_witness(
     any: &dyn Any,
-) -> Box<dyn crate::rules::traits::DynReductionResult> {
-    any.downcast_ref::<AggregateChainSource>()
-        .expect("expected AggregateChainSource");
-    Box::new(SourceToMiddleWitnessResult {
+) -> Result<Box<dyn crate::rules::traits::DynReductionResult>, crate::rules::ReductionError> {
+    any.downcast_ref::<AggregateChainSource>().ok_or(
+        crate::rules::ReductionError::SourceTypeMismatch {
+            source_problem: AggregateChainSource::NAME,
+            target_problem: AggregateChainMiddle::NAME,
+            expected: std::any::type_name::<AggregateChainSource>(),
+        },
+    )?;
+    Ok(Box::new(SourceToMiddleWitnessResult {
         target: AggregateChainMiddle,
+    }))
+}
+
+fn fail_source_to_middle_witness(
+    _any: &dyn Any,
+) -> Result<Box<dyn crate::rules::traits::DynReductionResult>, crate::rules::ReductionError> {
+    Err(crate::rules::ReductionError::InvalidTarget {
+        source_problem: AggregateChainSource::NAME,
+        target_problem: AggregateChainMiddle::NAME,
+        message: "synthetic target construction failure".to_string(),
     })
 }
 
+static SHARED_PREFIX_EXECUTIONS: AtomicUsize = AtomicUsize::new(0);
+
+fn reduce_counted_source_to_middle_witness(
+    any: &dyn Any,
+) -> Result<Box<dyn crate::rules::traits::DynReductionResult>, crate::rules::ReductionError> {
+    SHARED_PREFIX_EXECUTIONS.fetch_add(1, Ordering::SeqCst);
+    reduce_source_to_middle_witness(any)
+}
+
+struct MiddleToTargetWitnessResult {
+    target: AggregateChainTarget,
+}
+
+impl ReductionResult for MiddleToTargetWitnessResult {
+    type Source = AggregateChainMiddle;
+    type Target = AggregateChainTarget;
+
+    fn target_problem(&self) -> &Self::Target {
+        &self.target
+    }
+
+    fn extract_solution(
+        &self,
+        target_solution: &<Self::Target as crate::traits::Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as crate::traits::Problem>::Solution> {
+        Ok(target_solution.to_vec())
+    }
+}
+
+fn reduce_middle_to_target_witness(
+    any: &dyn Any,
+) -> Result<Box<dyn crate::rules::traits::DynReductionResult>, crate::rules::ReductionError> {
+    any.downcast_ref::<AggregateChainMiddle>().ok_or(
+        crate::rules::ReductionError::SourceTypeMismatch {
+            source_problem: AggregateChainMiddle::NAME,
+            target_problem: AggregateChainTarget::NAME,
+            expected: std::any::type_name::<AggregateChainMiddle>(),
+        },
+    )?;
+    Ok(Box::new(MiddleToTargetWitnessResult {
+        target: AggregateChainTarget,
+    }))
+}
+
 fn reduce_natural_variant_witness(
     any: &dyn Any,
-) -> Box<dyn crate::rules::traits::DynReductionResult> {
-    let source = any
-        .downcast_ref::<NaturalVariantProblem>()
-        .expect("expected NaturalVariantProblem");
-    Box::new(crate::rules::ReductionAutoCast::<
+) -> Result<Box<dyn crate::rules::traits::DynReductionResult>, crate::rules::ReductionError> {
+    let source = any.downcast_ref::<NaturalVariantProblem>().ok_or(
+        crate::rules::ReductionError::SourceTypeMismatch {
+            source_problem: NaturalVariantProblem::NAME,
+            target_problem: NaturalVariantProblem::NAME,
+            expected: std::any::type_name::<NaturalVariantProblem>(),
+        },
+    )?;
+    Ok(Box::new(crate::rules::VariantReductionResult::<
         NaturalVariantProblem,
         NaturalVariantProblem,
-    >::new(source.clone()))
+    >::new(source.clone())))
 }
 
 fn build_two_node_graph(
@@ -232,11 +390,218 @@ fn build_two_node_graph(
     }
 }
 
+#[test]
+fn execute_paths_executes_a_shared_prefix_once() {
+    SHARED_PREFIX_EXECUTIONS.store(0, Ordering::SeqCst);
+    let witness_edge = |reduce_fn| ReductionEdgeData {
+        parameter_contract: empty_parameter_contract(),
+        reduce_fn: Some(reduce_fn),
+        reduce_aggregate_fn: None,
+        turing: false,
+    };
+    let graph = ReductionGraph::from_test_edges(
+        &[
+            AggregateChainSource::NAME,
+            AggregateChainMiddle::NAME,
+            AggregateChainTarget::NAME,
+        ],
+        &[
+            (
+                AggregateChainSource::NAME,
+                AggregateChainMiddle::NAME,
+                witness_edge(reduce_counted_source_to_middle_witness),
+            ),
+            (
+                AggregateChainMiddle::NAME,
+                AggregateChainTarget::NAME,
+                witness_edge(reduce_middle_to_target_witness),
+            ),
+        ],
+    );
+    let paths = vec![
+        named_path(&[AggregateChainSource::NAME, AggregateChainMiddle::NAME]),
+        named_path(&[
+            AggregateChainSource::NAME,
+            AggregateChainMiddle::NAME,
+            AggregateChainTarget::NAME,
+        ]),
+    ];
+
+    let executed = graph
+        .execute_paths(&paths, &AggregateChainSource)
+        .expect("both paths are executable");
+
+    assert_eq!(executed.len(), 2);
+    assert_eq!(SHARED_PREFIX_EXECUTIONS.load(Ordering::SeqCst), 1);
+}
+
+#[test]
+fn path_parameter_contract_errors_are_typed_and_isolated() {
+    let single = named_path(&["A"]);
+    let empty = ReductionPath { steps: vec![] };
+    let graph = ReductionGraph::from_test_edges(&["A", "B"], &[]);
+    assert!(graph.path_parameter_transforms(&single).unwrap().is_empty());
+    assert!(graph
+        .compose_path_parameter_transform(&single)
+        .unwrap()
+        .is_none());
+    assert!(matches!(
+        graph.compose_path_parameter_transform(&empty),
+        Err(PathParameterError::EmptyPath)
+    ));
+
+    let unknown = named_path(&["A", "Unknown"]);
+    assert!(matches!(
+        graph.path_parameter_transforms(&unknown),
+        Err(PathParameterError::UnknownNode { .. })
+    ));
+
+    let disconnected = named_path(&["A", "B"]);
+    assert!(matches!(
+        graph.path_parameter_transforms(&disconnected),
+        Err(PathParameterError::MissingEdge { .. })
+    ));
+
+    let unavailable = build_two_node_graph(
+        "A",
+        BTreeMap::new(),
+        "B",
+        BTreeMap::new(),
+        ReductionEdgeData {
+            parameter_contract: empty_parameter_contract(),
+            reduce_fn: Some(|_| panic!("metadata inspection must not execute reductions")),
+            reduce_aggregate_fn: None,
+            turing: false,
+        },
+    );
+    assert!(matches!(
+        unavailable.path_parameter_transforms(&disconnected),
+        Err(PathParameterError::Unavailable { .. })
+    ));
+
+    let invalid_contract = Err(ParameterContractError::EmptyUnavailableReason {
+        edge: "A -> B".into(),
+        field: "x".into(),
+    });
+    let invalid = build_two_node_graph(
+        "A",
+        BTreeMap::new(),
+        "B",
+        BTreeMap::new(),
+        ReductionEdgeData {
+            parameter_contract: invalid_contract,
+            reduce_fn: Some(|_| panic!("metadata inspection must not execute reductions")),
+            reduce_aggregate_fn: None,
+            turing: false,
+        },
+    );
+    assert!(matches!(
+        invalid.path_parameter_transforms(&disconnected),
+        Err(PathParameterError::InvalidContract { .. })
+    ));
+
+    let turing = build_two_node_graph(
+        "A",
+        BTreeMap::new(),
+        "B",
+        BTreeMap::new(),
+        symbolic_size_edge(&[("x", "n")], true),
+    );
+    assert!(matches!(
+        turing.path_parameter_transforms(&disconnected),
+        Err(PathParameterError::TuringEdge { .. })
+    ));
+}
+
+#[test]
+fn path_size_composition_and_contract_evaluation_report_errors() {
+    let missing_input = build_two_node_graph(
+        "A",
+        BTreeMap::new(),
+        "B",
+        BTreeMap::new(),
+        symbolic_size_edge(&[("x", "n")], false),
+    );
+    let direct = named_path(&["A", "B"]);
+    let direct_transform = missing_input
+        .compose_path_parameter_transform(&direct)
+        .unwrap()
+        .unwrap();
+    assert!(matches!(
+        direct_transform.evaluate(&ProblemParameters::default()),
+        Err(crate::parameters::ParameterTransformError::MissingInputField { .. })
+    ));
+
+    let invalid_composition = ReductionGraph::from_test_edges(
+        &["A", "B", "C"],
+        &[
+            ("A", "B", symbolic_size_edge(&[("x", "n")], false)),
+            ("B", "C", symbolic_size_edge(&[("z", "y")], false)),
+        ],
+    );
+    let chained = named_path(&["A", "B", "C"]);
+    assert!(matches!(
+        invalid_composition.compose_path_parameter_transform(&chained),
+        Err(PathParameterError::Step { .. })
+    ));
+
+    let valid = ReductionGraph::from_test_edges(
+        &["A", "B", "C"],
+        &[
+            ("A", "B", symbolic_size_edge(&[("x", "n + 1")], false)),
+            ("B", "C", symbolic_size_edge(&[("z", "2 * x")], false)),
+        ],
+    );
+    let transform = valid
+        .compose_path_parameter_transform(&chained)
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        transform
+            .evaluate(&ProblemParameters::new(vec![("n", 3)]))
+            .unwrap()
+            .get("z"),
+        Some(8)
+    );
+}
+
+#[test]
+fn symbolic_path_enumeration_retains_every_path_without_ranking() {
+    let graph = ReductionGraph::from_test_edges(
+        &["S", "A", "B", "C", "T"],
+        &[
+            ("S", "A", symbolic_size_edge(&[("x", "2")], false)),
+            ("S", "B", symbolic_size_edge(&[("x", "1")], false)),
+            ("S", "C", symbolic_size_edge(&[("x", "3")], false)),
+            ("A", "T", symbolic_size_edge(&[("y", "x")], false)),
+            ("B", "T", symbolic_size_edge(&[("y", "x")], false)),
+            ("C", "T", symbolic_size_edge(&[("y", "x")], false)),
+        ],
+    );
+    let variant = BTreeMap::new();
+    let paths = graph.find_all_paths_mode("S", &variant, "T", &variant, ReductionMode::Witness);
+    assert_eq!(paths.len(), 3);
+    let values: BTreeSet<_> = paths
+        .iter()
+        .map(|path| {
+            graph
+                .compose_path_parameter_transform(path)
+                .unwrap()
+                .unwrap()
+                .evaluate(&ProblemParameters::default())
+                .unwrap()
+                .get("y")
+                .unwrap()
+        })
+        .collect();
+    assert_eq!(values, BTreeSet::from([1, 2, 3]));
+}
+
 #[test]
 fn test_find_direct_path() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
     let paths = graph.find_all_paths("MaximumIndependentSet", &src, "MinimumVertexCover", &dst);
     assert!(!paths.is_empty());
     // At least one path should be a direct reduction (1 edge = 2 steps)
@@ -278,20 +643,20 @@ fn test_aggregate_reduction_chain_extracts_value_backwards() {
         source_idx,
         middle_idx,
         ReductionEdgeData {
-            overhead: crate::rules::registry::ReductionOverhead::default(),
+            parameter_contract: empty_parameter_contract(),
             reduce_fn: None,
             reduce_aggregate_fn: Some(reduce_source_to_middle_aggregate),
-            capabilities: EdgeCapabilities::aggregate_only(),
+            turing: false,
         },
     );
     graph.add_edge(
         middle_idx,
         target_idx,
         ReductionEdgeData {
-            overhead: crate::rules::registry::ReductionOverhead::default(),
+            parameter_contract: empty_parameter_contract(),
             reduce_fn: None,
             reduce_aggregate_fn: Some(reduce_middle_to_target_aggregate),
-            capabilities: EdgeCapabilities::aggregate_only(),
+            turing: false,
         },
     );
 
@@ -324,10 +689,11 @@ fn test_aggregate_reduction_chain_extracts_value_backwards() {
 
     let chain = reduction_graph
         .reduce_aggregate_along_path(&path, &AggregateChainSource as &dyn Any)
+        .expect("aggregate reduction should not fail")
         .expect("expected aggregate reduction chain");
 
     assert_eq!(
-        chain.target_problem::<AggregateChainTarget>().dims(),
+        chain.target_problem::<AggregateChainTarget>().dimensions(),
         vec![1]
     );
     assert_eq!(chain.extract_value_dyn(json!(7)), json!(12));
@@ -343,35 +709,31 @@ fn witness_path_search_rejects_aggregate_only_edge() {
         AggregateChainMiddle::NAME,
         target_variant.clone(),
         ReductionEdgeData {
-            overhead: crate::rules::registry::ReductionOverhead::default(),
+            parameter_contract: empty_parameter_contract(),
             reduce_fn: None,
             reduce_aggregate_fn: Some(reduce_source_to_middle_aggregate),
-            capabilities: EdgeCapabilities::aggregate_only(),
+            turing: false,
         },
     );
 
     assert!(graph
-        .find_cheapest_path_mode(
+        .find_all_paths_mode(
             AggregateChainSource::NAME,
             &source_variant,
             AggregateChainMiddle::NAME,
             &target_variant,
-            ReductionMode::Witness,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
+            ReductionMode::Witness
         )
-        .is_none());
-    assert!(graph
-        .find_cheapest_path_mode(
+        .is_empty());
+    assert!(!graph
+        .find_all_paths_mode(
             AggregateChainSource::NAME,
             &source_variant,
             AggregateChainMiddle::NAME,
             &target_variant,
-            ReductionMode::Aggregate,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
+            ReductionMode::Aggregate
         )
-        .is_some());
+        .is_empty());
 }
 
 #[test]
@@ -384,39 +746,35 @@ fn aggregate_path_search_rejects_witness_only_edge() {
         AggregateChainMiddle::NAME,
         target_variant.clone(),
         ReductionEdgeData {
-            overhead: crate::rules::registry::ReductionOverhead::default(),
+            parameter_contract: empty_parameter_contract(),
             reduce_fn: Some(reduce_source_to_middle_witness),
             reduce_aggregate_fn: None,
-            capabilities: EdgeCapabilities::witness_only(),
+            turing: false,
         },
     );
 
     assert!(graph
-        .find_cheapest_path_mode(
+        .find_all_paths_mode(
             AggregateChainSource::NAME,
             &source_variant,
             AggregateChainMiddle::NAME,
             &target_variant,
-            ReductionMode::Aggregate,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
+            ReductionMode::Aggregate
         )
-        .is_none());
-    assert!(graph
-        .find_cheapest_path_mode(
+        .is_empty());
+    assert!(!graph
+        .find_all_paths_mode(
             AggregateChainSource::NAME,
             &source_variant,
             AggregateChainMiddle::NAME,
             &target_variant,
-            ReductionMode::Witness,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
+            ReductionMode::Witness
         )
-        .is_some());
+        .is_empty());
 }
 
 #[test]
-fn natural_edge_supports_both_modes() {
+fn witness_executor_does_not_imply_aggregate_capability() {
     let source_variant = BTreeMap::from([("graph".to_string(), "Source".to_string())]);
     let target_variant = BTreeMap::from([("graph".to_string(), "Target".to_string())]);
     let graph = build_two_node_graph(
@@ -425,38 +783,31 @@ fn natural_edge_supports_both_modes() {
         NaturalVariantProblem::NAME,
         target_variant.clone(),
         ReductionEdgeData {
-            overhead: crate::rules::registry::ReductionOverhead::default(),
+            parameter_contract: empty_parameter_contract(),
             reduce_fn: Some(reduce_natural_variant_witness),
             reduce_aggregate_fn: None,
-            capabilities: EdgeCapabilities::both(),
+            turing: false,
         },
     );
 
-    let witness_path = graph.find_cheapest_path_mode(
-        NaturalVariantProblem::NAME,
-        &source_variant,
-        NaturalVariantProblem::NAME,
-        &target_variant,
-        ReductionMode::Witness,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-    let aggregate_path = graph.find_cheapest_path_mode(
-        NaturalVariantProblem::NAME,
-        &source_variant,
-        NaturalVariantProblem::NAME,
-        &target_variant,
-        ReductionMode::Aggregate,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-
-    assert!(witness_path.is_some());
-    let aggregate_path = aggregate_path.expect("expected aggregate path");
-    let chain = graph
-        .reduce_aggregate_along_path(&aggregate_path, &NaturalVariantProblem as &dyn Any)
-        .expect("expected aggregate chain");
-    assert_eq!(chain.extract_value_dyn(json!(7)), json!(7));
+    assert!(!graph
+        .find_all_paths_mode(
+            NaturalVariantProblem::NAME,
+            &source_variant,
+            NaturalVariantProblem::NAME,
+            &target_variant,
+            ReductionMode::Witness
+        )
+        .is_empty());
+    assert!(graph
+        .find_all_paths_mode(
+            NaturalVariantProblem::NAME,
+            &source_variant,
+            NaturalVariantProblem::NAME,
+            &target_variant,
+            ReductionMode::Aggregate
+        )
+        .is_empty());
 }
 
 #[test]
@@ -468,10 +819,10 @@ fn reduce_aggregate_along_path_rejects_single_step_path() {
         AggregateChainMiddle::NAME,
         BTreeMap::new(),
         ReductionEdgeData {
-            overhead: crate::rules::registry::ReductionOverhead::default(),
+            parameter_contract: empty_parameter_contract(),
             reduce_fn: None,
             reduce_aggregate_fn: Some(reduce_source_to_middle_aggregate),
-            capabilities: EdgeCapabilities::aggregate_only(),
+            turing: false,
         },
     );
     let single_step_path = ReductionPath {
@@ -482,6 +833,7 @@ fn reduce_aggregate_along_path_rejects_single_step_path() {
     };
     assert!(graph
         .reduce_aggregate_along_path(&single_step_path, &AggregateChainSource as &dyn Any)
+        .expect("single-step path lookup should not fail")
         .is_none());
 }
 
@@ -495,10 +847,10 @@ fn reduce_aggregate_returns_none_for_witness_only_edge() {
         AggregateChainMiddle::NAME,
         target_variant.clone(),
         ReductionEdgeData {
-            overhead: crate::rules::registry::ReductionOverhead::default(),
+            parameter_contract: empty_parameter_contract(),
             reduce_fn: Some(reduce_source_to_middle_witness),
             reduce_aggregate_fn: None,
-            capabilities: EdgeCapabilities::witness_only(),
+            turing: false,
         },
     );
     let path = ReductionPath {
@@ -515,33 +867,72 @@ fn reduce_aggregate_returns_none_for_witness_only_edge() {
     };
     assert!(graph
         .reduce_aggregate_along_path(&path, &AggregateChainSource as &dyn Any)
+        .expect("witness-only edge lookup should not fail")
         .is_none());
 }
 
+#[test]
+fn reduce_along_path_preserves_edge_failure() {
+    let source_variant = BTreeMap::new();
+    let target_variant = BTreeMap::new();
+    let graph = build_two_node_graph(
+        AggregateChainSource::NAME,
+        source_variant.clone(),
+        AggregateChainMiddle::NAME,
+        target_variant.clone(),
+        ReductionEdgeData {
+            parameter_contract: empty_parameter_contract(),
+            reduce_fn: Some(fail_source_to_middle_witness),
+            reduce_aggregate_fn: None,
+            turing: false,
+        },
+    );
+    let path = ReductionPath {
+        steps: vec![
+            ReductionStep {
+                name: AggregateChainSource::NAME.to_string(),
+                variant: source_variant,
+            },
+            ReductionStep {
+                name: AggregateChainMiddle::NAME.to_string(),
+                variant: target_variant,
+            },
+        ],
+    };
+
+    let error = match graph.reduce_along_path(&path, &AggregateChainSource as &dyn Any) {
+        Err(error) => error,
+        Ok(_) => panic!("registered edge failure must be returned"),
+    };
+    assert_eq!(
+        error,
+        crate::rules::ReductionError::InvalidTarget {
+            source_problem: AggregateChainSource::NAME,
+            target_problem: AggregateChainMiddle::NAME,
+            message: "synthetic target construction failure".to_string(),
+        }
+    );
+}
+
 #[test]
 fn test_find_indirect_path() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i64>::variant());
     let paths = graph.find_all_paths("MaximumIndependentSet", &src, "MaximumSetPacking", &dst);
     assert!(!paths.is_empty());
 }
 
 #[test]
-fn test_find_shortest_path() {
+fn test_find_direct_path_in_all_routes() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i32>::variant());
-    let path = graph.find_cheapest_path(
-        "MaximumIndependentSet",
-        &src,
-        "MaximumSetPacking",
-        &dst,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-    assert!(path.is_some());
-    let path = path.unwrap();
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i64>::variant());
+    let path = graph
+        .find_all_paths("MaximumIndependentSet", &src, "MaximumSetPacking", &dst)
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("direct route");
     assert_eq!(path.len(), 1); // Direct path exists
 }
 
@@ -550,16 +941,11 @@ fn test_knapsack_to_ilp_path_exists() {
     let graph = ReductionGraph::new();
     let src = ReductionGraph::variant_to_map(&Knapsack::variant());
     let dst = ReductionGraph::variant_to_map(&ILP::<bool>::variant());
-    let path = graph.find_cheapest_path(
-        "Knapsack",
-        &src,
-        "ILP",
-        &dst,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-
-    let path = path.expect("Knapsack should reduce to ILP");
+    let path = graph
+        .find_all_paths("Knapsack", &src, "ILP", &dst)
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("Knapsack should reduce directly to ILP");
     assert_eq!(
         path.type_names(),
         vec!["Knapsack", "ILP"],
@@ -571,25 +957,20 @@ fn test_knapsack_to_ilp_path_exists() {
 #[test]
 fn test_has_direct_reduction() {
     let graph = ReductionGraph::new();
-    assert!(graph.has_direct_reduction::<MaximumIndependentSet<SimpleGraph, i32>, MinimumVertexCover<SimpleGraph, i32>>());
-    assert!(graph.has_direct_reduction::<MinimumVertexCover<SimpleGraph, i32>, MaximumIndependentSet<SimpleGraph, i32>>());
+    assert!(graph.has_direct_reduction::<MaximumIndependentSet<SimpleGraph, i64>, MinimumVertexCover<SimpleGraph, i64>>());
+    assert!(graph.has_direct_reduction::<MinimumVertexCover<SimpleGraph, i64>, MaximumIndependentSet<SimpleGraph, i64>>());
 }
 
 #[test]
 fn test_is_to_qubo_path() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
     let dst = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
-    let path = graph.find_cheapest_path(
-        "MaximumIndependentSet",
-        &src,
-        "QUBO",
-        &dst,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-    assert!(path.is_some());
-    let path = path.unwrap();
+    let path = graph
+        .find_all_paths("MaximumIndependentSet", &src, "QUBO", &dst)
+        .into_iter()
+        .find(|path| path.type_names() == ["MaximumIndependentSet", "MaximumSetPacking", "QUBO"])
+        .expect("explicit QUBO route");
     assert!(
         path.len() > 1,
         "MIS -> QUBO should now go through a composite path"
@@ -600,12 +981,12 @@ fn test_is_to_qubo_path() {
 fn test_variant_level_paths() {
     let graph = ReductionGraph::new();
 
-    // Variant-level path: MaxCut<SimpleGraph, i32> -> SpinGlass<SimpleGraph, i32>
+    // Variant-level path: MaxCut<SimpleGraph, i64> -> SpinGlass<SimpleGraph, i64>
     let src = ReductionGraph::variant_to_map(
-        &crate::models::graph::MaxCut::<SimpleGraph, i32>::variant(),
+        &crate::models::graph::MaxCut::<SimpleGraph, i64>::variant(),
     );
     let dst = ReductionGraph::variant_to_map(
-        &crate::models::graph::SpinGlass::<SimpleGraph, i32>::variant(),
+        &crate::models::graph::SpinGlass::<SimpleGraph, i64>::variant(),
     );
     let paths = graph.find_all_paths("MaxCut", &src, "SpinGlass", &dst);
     assert!(!paths.is_empty());
@@ -625,40 +1006,28 @@ fn test_variant_level_paths() {
 }
 
 #[test]
-fn test_find_shortest_path_variants() {
+fn test_find_direct_path_variants() {
     let graph = ReductionGraph::new();
 
     let src = ReductionGraph::variant_to_map(
-        &crate::models::graph::MaxCut::<SimpleGraph, i32>::variant(),
+        &crate::models::graph::MaxCut::<SimpleGraph, i64>::variant(),
     );
     let dst = ReductionGraph::variant_to_map(
-        &crate::models::graph::SpinGlass::<SimpleGraph, i32>::variant(),
+        &crate::models::graph::SpinGlass::<SimpleGraph, i64>::variant(),
     );
-    let shortest = graph.find_cheapest_path(
-        "MaxCut",
-        &src,
-        "SpinGlass",
-        &dst,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-    assert!(shortest.is_some());
-    assert_eq!(shortest.unwrap().len(), 1); // Direct path
+    assert!(graph
+        .find_all_paths("MaxCut", &src, "SpinGlass", &dst)
+        .iter()
+        .any(|path| path.len() == 1));
 
     let src = ReductionGraph::variant_to_map(&crate::models::misc::Factoring::variant());
     let dst = ReductionGraph::variant_to_map(
-        &crate::models::graph::SpinGlass::<SimpleGraph, i32>::variant(),
+        &crate::models::graph::SpinGlass::<SimpleGraph, i64>::variant(),
     );
-    let shortest = graph.find_cheapest_path(
-        "Factoring",
-        &src,
-        "SpinGlass",
-        &dst,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-    assert!(shortest.is_some());
-    assert_eq!(shortest.unwrap().len(), 2); // Factoring -> CircuitSAT -> SpinGlass
+    assert!(graph
+        .find_all_paths("Factoring", &src, "SpinGlass", &dst)
+        .iter()
+        .any(|path| path.type_names() == ["Factoring", "CircuitSAT", "SpinGlass"]));
 }
 
 #[test]
@@ -682,18 +1051,13 @@ fn test_graph_statistics() {
 #[test]
 fn test_reduction_path_methods() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
     let path = graph
-        .find_cheapest_path(
-            "MaximumIndependentSet",
-            &src,
-            "MinimumVertexCover",
-            &dst,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .unwrap();
+        .find_all_paths("MaximumIndependentSet", &src, "MinimumVertexCover", &dst)
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("direct route");
 
     assert!(!path.is_empty());
     assert!(path.source().unwrap().contains("MaximumIndependentSet"));
@@ -708,8 +1072,14 @@ fn test_to_json() {
     // Check nodes
     assert!(json.nodes.len() >= 10);
     assert!(json.nodes.iter().any(|n| n.name == "MaximumIndependentSet"));
-    assert!(json.nodes.iter().any(|n| n.category == "graph"));
-    assert!(json.nodes.iter().any(|n| n.category == "algebraic"));
+    assert!(json
+        .nodes
+        .iter()
+        .any(|n| n.category == ProblemCategory::Graph));
+    assert!(json
+        .nodes
+        .iter()
+        .any(|n| n.category == ProblemCategory::Algebraic));
 
     // Check edges
     assert!(json.edges.len() >= 10);
@@ -730,14 +1100,18 @@ fn test_to_json() {
 #[test]
 fn test_to_json_string() {
     let graph = ReductionGraph::new();
+    let json_value = graph.to_json_value().unwrap();
     let json_string = graph.to_json_string().unwrap();
 
     // Should be valid JSON
+    assert!(json_value["nodes"].is_array());
+    assert!(json_value["edges"].is_array());
     assert!(json_string.contains("\"nodes\""));
     assert!(json_string.contains("\"edges\""));
     assert!(json_string.contains("MaximumIndependentSet"));
     assert!(json_string.contains("\"category\""));
-    assert!(json_string.contains("\"overhead\""));
+    assert!(json_string.contains("\"parameters\""));
+    assert!(!json_string.contains("\"overhead\""));
 
     // The legacy "bidirectional" field must not be present
     assert!(
@@ -746,39 +1120,6 @@ fn test_to_json_string() {
     );
 }
 
-#[test]
-fn test_category_from_module_path() {
-    assert_eq!(
-        ReductionGraph::category_from_module_path(
-            "problemreductions::models::graph::maximum_independent_set"
-        ),
-        "graph"
-    );
-    assert_eq!(
-        ReductionGraph::category_from_module_path(
-            "problemreductions::models::set::minimum_set_covering"
-        ),
-        "set"
-    );
-    assert_eq!(
-        ReductionGraph::category_from_module_path("problemreductions::models::algebraic::qubo"),
-        "algebraic"
-    );
-    assert_eq!(
-        ReductionGraph::category_from_module_path("problemreductions::models::formula::sat"),
-        "formula"
-    );
-    assert_eq!(
-        ReductionGraph::category_from_module_path("problemreductions::models::misc::factoring"),
-        "misc"
-    );
-    // Fallback for unexpected format
-    assert_eq!(
-        ReductionGraph::category_from_module_path("foo::bar"),
-        "other"
-    );
-}
-
 #[test]
 fn test_doc_path_from_module_path() {
     assert_eq!(
@@ -813,7 +1154,7 @@ fn test_sat_based_reductions() {
     assert!(graph.has_direct_reduction::<Satisfiability, KColoring<K3, SimpleGraph>>());
 
     // SAT -> MinimumDominatingSet
-    assert!(graph.has_direct_reduction::<Satisfiability, MinimumDominatingSet<SimpleGraph, i32>>());
+    assert!(graph.has_direct_reduction::<Satisfiability, MinimumDominatingSet<SimpleGraph, i64>>());
 }
 
 #[test]
@@ -828,24 +1169,16 @@ fn test_circuit_reductions() {
     assert!(graph.has_direct_reduction::<Factoring, CircuitSAT>());
 
     // CircuitSAT -> SpinGlass
-    assert!(graph.has_direct_reduction::<CircuitSAT, SpinGlass<SimpleGraph, i32>>());
+    assert!(graph.has_direct_reduction::<CircuitSAT, SpinGlass<SimpleGraph, i64>>());
 
-    // Find path from Factoring to SpinGlass<SimpleGraph, i32>
+    // Find path from Factoring to SpinGlass<SimpleGraph, i64>
     let src = ReductionGraph::variant_to_map(&Factoring::variant());
-    let dst = ReductionGraph::variant_to_map(&SpinGlass::<SimpleGraph, i32>::variant());
+    let dst = ReductionGraph::variant_to_map(&SpinGlass::<SimpleGraph, i64>::variant());
     let paths = graph.find_all_paths("Factoring", &src, "SpinGlass", &dst);
     assert!(!paths.is_empty());
-    let shortest = graph
-        .find_cheapest_path(
-            "Factoring",
-            &src,
-            "SpinGlass",
-            &dst,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .unwrap();
-    assert_eq!(shortest.len(), 2); // Factoring -> CircuitSAT -> SpinGlass
+    assert!(paths
+        .iter()
+        .any(|path| path.type_names() == ["Factoring", "CircuitSAT", "SpinGlass"]));
 }
 
 #[test]
@@ -861,8 +1194,8 @@ fn test_optimization_reductions() {
     assert!(graph.has_direct_reduction::<QUBO<f64>, SpinGlass<SimpleGraph, f64>>());
 
     // MaxCut <-> SpinGlass (bidirectional)
-    assert!(graph.has_direct_reduction::<MaxCut<SimpleGraph, i32>, SpinGlass<SimpleGraph, f64>>());
-    assert!(graph.has_direct_reduction::<SpinGlass<SimpleGraph, f64>, MaxCut<SimpleGraph, i32>>());
+    assert!(graph.has_direct_reduction::<MaxCut<SimpleGraph, i64>, SpinGlass<SimpleGraph, f64>>());
+    assert!(graph.has_direct_reduction::<SpinGlass<SimpleGraph, f64>, MaxCut<SimpleGraph, i64>>());
 }
 
 #[test]
@@ -881,14 +1214,14 @@ fn test_ksat_reductions() {
 fn test_nae_sat_to_maxcut_reduction_registered() {
     let graph = ReductionGraph::new();
 
-    assert!(graph.has_direct_reduction::<NAESatisfiability, MaxCut<SimpleGraph, i32>>());
+    assert!(graph.has_direct_reduction::<NAESatisfiability, MaxCut<SimpleGraph, i64>>());
 }
 
 #[test]
 fn test_maximum2satisfiability_to_maxcut_reduction_registered() {
     let graph = ReductionGraph::new();
 
-    assert!(graph.has_direct_reduction::<Maximum2Satisfiability, MaxCut<SimpleGraph, i32>>());
+    assert!(graph.has_direct_reduction::<Maximum2Satisfiability, MaxCut<SimpleGraph, i64>>());
 }
 
 #[test]
@@ -980,7 +1313,7 @@ fn test_unknown_name_returns_empty() {
     let graph = ReductionGraph::new();
     let unknown = BTreeMap::new();
     let is_var =
-        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
 
     // Unknown source
     assert!(!graph.has_direct_reduction_by_name("UnknownProblem", "MaximumIndependentSet"));
@@ -996,27 +1329,14 @@ fn test_unknown_name_returns_empty() {
     assert!(graph
         .find_all_paths("MaximumIndependentSet", &is_var, "UnknownProblem", &unknown)
         .is_empty());
-
-    // find_shortest_path with unknown name
-    assert!(graph
-        .find_cheapest_path(
-            "UnknownProblem",
-            &unknown,
-            "MaximumIndependentSet",
-            &is_var,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps
-        )
-        .is_none());
 }
 
 #[test]
-fn test_category_derived_from_schema() {
-    // CircuitSAT's category is derived from its ProblemSchemaEntry module_path
+fn test_category_comes_from_schema() {
     let graph = ReductionGraph::new();
     let json = graph.to_json();
     let circuit = json.nodes.iter().find(|n| n.name == "CircuitSAT").unwrap();
-    assert_eq!(circuit.category, "formula");
+    assert_eq!(circuit.category, ProblemCategory::Formula);
 }
 
 #[test]
@@ -1058,26 +1378,18 @@ fn test_circuitsat_to_satisfiability_direct_edge() {
 
     assert!(graph.has_direct_reduction_by_name("CircuitSAT", "Satisfiability"));
 
-    let path = graph.find_cheapest_path(
-        "CircuitSAT",
-        &src,
-        "Satisfiability",
-        &dst,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-    assert!(
-        path.is_some(),
-        "CircuitSAT -> Satisfiability path should exist"
-    );
+    assert!(graph
+        .find_all_paths("CircuitSAT", &src, "Satisfiability", &dst)
+        .iter()
+        .any(|path| path.len() == 1));
 }
 
 #[test]
 fn test_variant_to_map() {
-    let variant: &[(&str, &str)] = &[("graph", "SimpleGraph"), ("weight", "i32")];
+    let variant: &[(&str, &str)] = &[("graph", "SimpleGraph"), ("weight", "i64")];
     let map = ReductionGraph::variant_to_map(variant);
     assert_eq!(map.get("graph"), Some(&"SimpleGraph".to_string()));
-    assert_eq!(map.get("weight"), Some(&"i32".to_string()));
+    assert_eq!(map.get("weight"), Some(&"i64".to_string()));
     assert_eq!(map.len(), 2);
 }
 
@@ -1097,8 +1409,6 @@ fn test_to_json_nodes_have_variants() {
     for node in &json.nodes {
         // Verify node has a name
         assert!(!node.name.is_empty());
-        // Verify node has a category
-        assert!(!node.category.is_empty());
     }
 }
 
@@ -1142,7 +1452,7 @@ fn test_reduction_variant_nodes_in_json() {
     let graph = ReductionGraph::new();
     let json = graph.to_json();
 
-    // KingsSubgraph variants should appear as nodes (from explicit cast reductions)
+    // KingsSubgraph variants should appear as registered nodes.
     let mis_kingssubgraph = json.nodes.iter().any(|n| {
         n.name == "MaximumIndependentSet"
             && n.variant.get("graph") == Some(&"KingsSubgraph".to_string())
@@ -1157,11 +1467,11 @@ fn test_reduction_variant_nodes_in_json() {
 }
 
 #[test]
-fn test_variant_cast_edges_in_json() {
+fn test_variant_reduction_edges_in_json() {
     let graph = ReductionGraph::new();
     let json = graph.to_json();
 
-    // MIS/KingsSubgraph -> MIS/UnitDiskGraph should exist as an explicit cast reduction
+    // MIS/KingsSubgraph -> MIS/UnitDiskGraph is an explicit variant reduction.
     let has_edge = json.edges.iter().any(|e| {
         json.source_node(e).name == "MaximumIndependentSet"
             && json.target_node(e).name == "MaximumIndependentSet"
@@ -1170,7 +1480,7 @@ fn test_variant_cast_edges_in_json() {
     });
     assert!(
         has_edge,
-        "Variant cast edge MIS/KingsSubgraph -> MIS/UnitDiskGraph should exist"
+        "Variant reduction edge MIS/KingsSubgraph -> MIS/UnitDiskGraph should exist"
     );
 }
 
@@ -1206,161 +1516,24 @@ fn test_edges_have_doc_paths() {
     }
 }
 
-#[test]
-fn test_find_cheapest_path_minimize_steps() {
-    let graph = ReductionGraph::new();
-    let cost_fn = MinimizeSteps;
-    let input_size = crate::types::ProblemSize::new(vec![("num_vertices", 10), ("num_edges", 20)]);
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
-
-    let path = graph.find_cheapest_path(
-        "MaximumIndependentSet",
-        &src,
-        "MinimumVertexCover",
-        &dst,
-        &input_size,
-        &cost_fn,
-    );
-
-    assert!(path.is_some());
-    let path = path.unwrap();
-    assert_eq!(path.len(), 1); // Direct path
-}
-
-#[test]
-fn test_find_cheapest_path_multi_step() {
-    let graph = ReductionGraph::new();
-    let cost_fn = MinimizeSteps;
-    let input_size = crate::types::ProblemSize::new(vec![("num_vertices", 10), ("num_edges", 20)]);
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i32>::variant());
-
-    let path = graph.find_cheapest_path(
-        "MaximumIndependentSet",
-        &src,
-        "MaximumSetPacking",
-        &dst,
-        &input_size,
-        &cost_fn,
-    );
-
-    assert!(path.is_some());
-    let path = path.unwrap();
-    assert_eq!(path.len(), 1); // Direct path: MaximumIndependentSet -> MaximumSetPacking
-}
-
-#[test]
-fn test_find_cheapest_path_is_to_qubo() {
-    let graph = ReductionGraph::new();
-    let cost_fn = Minimize("num_vars");
-    let input_size = crate::types::ProblemSize::new(vec![("num_vertices", 10), ("num_edges", 20)]);
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
-
-    let path = graph.find_cheapest_path(
-        "MaximumIndependentSet",
-        &src,
-        "QUBO",
-        &dst,
-        &input_size,
-        &cost_fn,
-    );
-
-    assert!(path.is_some());
-    let path = path.unwrap();
-    assert!(
-        path.len() > 1,
-        "MIS -> QUBO should now be discovered through a composite path"
-    );
-    assert_eq!(
-        path.type_names(),
-        vec!["MaximumIndependentSet", "MaximumSetPacking", "QUBO"]
-    );
-}
-
-#[test]
-fn test_find_cheapest_path_unknown_source() {
-    let graph = ReductionGraph::new();
-    let cost_fn = MinimizeSteps;
-    let input_size = crate::types::ProblemSize::new(vec![]);
-    let unknown = BTreeMap::new();
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
-
-    let path = graph.find_cheapest_path(
-        "UnknownProblem",
-        &unknown,
-        "MinimumVertexCover",
-        &dst,
-        &input_size,
-        &cost_fn,
-    );
-
-    assert!(path.is_none());
-}
-
-#[test]
-fn test_find_cheapest_path_unknown_target() {
-    let graph = ReductionGraph::new();
-    let cost_fn = MinimizeSteps;
-    let input_size = crate::types::ProblemSize::new(vec![("num_vertices", 10), ("num_edges", 20)]);
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let unknown = BTreeMap::new();
-
-    let path = graph.find_cheapest_path(
-        "MaximumIndependentSet",
-        &src,
-        "UnknownProblem",
-        &unknown,
-        &input_size,
-        &cost_fn,
-    );
-
-    assert!(path.is_none());
-}
-
-#[test]
-fn test_classify_problem_category() {
-    assert_eq!(
-        classify_problem_category("problemreductions::models::graph::maximum_independent_set"),
-        "graph"
-    );
-    assert_eq!(
-        classify_problem_category("problemreductions::models::formula::satisfiability"),
-        "formula"
-    );
-    assert_eq!(
-        classify_problem_category("problemreductions::models::set::maximum_set_packing"),
-        "set"
-    );
-    assert_eq!(
-        classify_problem_category("problemreductions::models::algebraic::qubo"),
-        "algebraic"
-    );
-    assert_eq!(classify_problem_category("unknown::path"), "other");
-}
-
 #[test]
 fn test_reduce_along_path_direct() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
     let rpath = graph
-        .find_cheapest_path(
-            "MaximumIndependentSet",
-            &src,
-            "MinimumVertexCover",
-            &dst,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .unwrap();
+        .find_all_paths("MaximumIndependentSet", &src, "MinimumVertexCover", &dst)
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("direct route");
     // Just verify the path can produce a chain with a dummy source
     let source = MaximumIndependentSet::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
-    let chain = graph.reduce_along_path(&rpath, &source as &dyn std::any::Any);
+    let chain = graph
+        .reduce_along_path(&rpath, &source as &dyn std::any::Any)
+        .expect("direct reduction should not fail");
     assert!(chain.is_some());
 }
 
@@ -1370,32 +1543,28 @@ fn test_reduction_chain_direct() {
     use crate::traits::Problem;
 
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
     let rpath = graph
-        .find_cheapest_path(
-            "MaximumIndependentSet",
-            &src,
-            "MinimumVertexCover",
-            &dst,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .unwrap();
+        .find_all_paths("MaximumIndependentSet", &src, "MinimumVertexCover", &dst)
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("direct route");
 
     let problem = MaximumIndependentSet::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let chain = graph
         .reduce_along_path(&rpath, &problem as &dyn std::any::Any)
+        .unwrap()
         .unwrap();
-    let target: &MinimumVertexCover<SimpleGraph, i32> = chain.target_problem();
+    let target: &MinimumVertexCover<SimpleGraph, i64> = chain.target_problem();
 
     let solver = BruteForce::new();
-    let target_solution = solver.find_witness(target).unwrap();
-    let source_solution = chain.extract_solution(&target_solution);
-    let metric = problem.evaluate(&source_solution);
+    let target_solution = solver.solve(target).unwrap().unwrap();
+    let source_solution = chain.extract_solution(&target_solution).unwrap();
+    let metric = problem.evaluate(&source_solution).unwrap();
     assert!(metric.is_valid());
 }
 
@@ -1405,105 +1574,97 @@ fn test_reduction_chain_multi_step() {
     use crate::traits::Problem;
 
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MaximumSetPacking::<i64>::variant());
     let rpath = graph
-        .find_cheapest_path(
-            "MaximumIndependentSet",
-            &src,
-            "MaximumSetPacking",
-            &dst,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .unwrap();
+        .find_all_paths("MaximumIndependentSet", &src, "MaximumSetPacking", &dst)
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("direct route");
 
     let problem = MaximumIndependentSet::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let chain = graph
         .reduce_along_path(&rpath, &problem as &dyn std::any::Any)
+        .unwrap()
         .unwrap();
-    let target: &MaximumSetPacking<i32> = chain.target_problem();
+    let target: &MaximumSetPacking<i64> = chain.target_problem();
 
     let solver = BruteForce::new();
-    let target_solution = solver.find_witness(target).unwrap();
-    let source_solution = chain.extract_solution(&target_solution);
-    let metric = problem.evaluate(&source_solution);
+    let target_solution = solver.solve(target).unwrap().unwrap();
+    let source_solution = chain.extract_solution(&target_solution).unwrap();
+    let metric = problem.evaluate(&source_solution).unwrap();
     assert!(metric.is_valid());
 }
 
 #[test]
-fn test_reduction_chain_with_variant_casts() {
+fn test_reduction_chain_with_variant_reductions() {
     use crate::models::formula::{CNFClause, KSatisfiability};
-    use crate::rules::MinimizeSteps;
     use crate::solvers::BruteForce;
     use crate::topology::UnitDiskGraph;
     use crate::traits::Problem;
-    use crate::types::ProblemSize;
 
     let graph = ReductionGraph::new();
 
-    // MIS<UnitDiskGraph, i32> -> MIS<SimpleGraph, i32> (variant cast) -> MVC<SimpleGraph, i32>
-    // Use find_cheapest_path for exact variant matching (not name-based)
+    // MIS<UnitDiskGraph, i64> -> MIS<SimpleGraph, i64> -> MVC<SimpleGraph, i64>
+    // Resolve a route with exact source and target variants.
     let src_var =
-        ReductionGraph::variant_to_map(&MaximumIndependentSet::<UnitDiskGraph, i32>::variant());
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<UnitDiskGraph, i64>::variant());
     let dst_var =
-        ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
-    let rpath = graph.find_cheapest_path(
-        "MaximumIndependentSet",
-        &src_var,
-        "MinimumVertexCover",
-        &dst_var,
-        &ProblemSize::new(vec![]),
-        &MinimizeSteps,
-    );
-    assert!(
-        rpath.is_some(),
-        "Should find path from MIS<UnitDiskGraph> to MVC<SimpleGraph> via variant cast"
-    );
-    let rpath = rpath.unwrap();
+        ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
+    let rpath = graph
+        .find_all_paths(
+            "MaximumIndependentSet",
+            &src_var,
+            "MinimumVertexCover",
+            &dst_var,
+        )
+        .into_iter()
+        .find(|path| path.len() >= 2)
+        .expect("variant-reduction route");
     assert!(
         rpath.len() >= 2,
-        "Path should cross variant cast boundary (at least 2 steps)"
+        "Path should include the variant reduction (at least 2 steps)"
     );
 
     // Create a small UnitDiskGraph MIS problem (triangle of close nodes)
-    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (0.5, 0.0), (0.25, 0.4)], 1.0);
-    let mis = MaximumIndependentSet::new(udg, vec![1i32, 1, 1]);
+    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (0.5, 0.0), (0.25, 0.4)], 1.0).unwrap();
+    let mis = MaximumIndependentSet::new(udg, vec![1i64, 1, 1]);
 
     let chain = graph
         .reduce_along_path(&rpath, &mis as &dyn std::any::Any)
+        .unwrap()
         .unwrap();
-    let target: &MinimumVertexCover<SimpleGraph, i32> = chain.target_problem();
+    let target: &MinimumVertexCover<SimpleGraph, i64> = chain.target_problem();
 
     let solver = BruteForce::new();
-    let target_solution = solver.find_witness(target).unwrap();
-    let source_solution = chain.extract_solution(&target_solution);
-    let metric = mis.evaluate(&source_solution);
+    let target_solution = solver.solve(target).unwrap().unwrap();
+    let source_solution = chain.extract_solution(&target_solution).unwrap();
+    let metric = mis.evaluate(&source_solution).unwrap();
     assert!(metric.is_valid());
 
     // Also test the KSat<K3> -> Sat -> MIS multi-step path
-    // Use find_cheapest_path for exact variant matching (not name-based
-    // and may pick a path through a different KSat variant)
+    // Resolve the explicit KSat -> SAT -> MIS route with exact variants.
     let ksat_src =
         ReductionGraph::variant_to_map(&KSatisfiability::<crate::variant::K3>::variant());
     let ksat_dst =
-        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let ksat_rpath = graph.find_cheapest_path(
-        "KSatisfiability",
-        &ksat_src,
-        "MaximumIndependentSet",
-        &ksat_dst,
-        &crate::types::ProblemSize::new(vec![]),
-        &crate::rules::MinimizeSteps,
-    );
-    assert!(
-        ksat_rpath.is_some(),
-        "Should find path from KSat<K3> to MIS"
-    );
-    let ksat_rpath = ksat_rpath.unwrap();
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let ksat_rpath = graph
+        .find_all_paths(
+            "KSatisfiability",
+            &ksat_src,
+            "MaximumIndependentSet",
+            &ksat_dst,
+        )
+        .into_iter()
+        .find(|path| {
+            path.len() == 4
+                && path.type_names()
+                    == ["KSatisfiability", "Satisfiability", "MaximumIndependentSet"]
+        })
+        .expect("explicit SAT route");
 
     // Create a 3-SAT formula
     let ksat = KSatisfiability::<crate::variant::K3>::new(
@@ -1518,77 +1679,79 @@ fn test_reduction_chain_with_variant_casts() {
 
     let ksat_chain = graph
         .reduce_along_path(&ksat_rpath, &ksat as &dyn std::any::Any)
+        .unwrap()
         .unwrap();
-    let target: &MaximumIndependentSet<SimpleGraph, i32> = ksat_chain.target_problem();
+    let target: &MaximumIndependentSet<SimpleGraph, i64> = ksat_chain.target_problem();
 
-    let target_solution = solver.find_witness(target).unwrap();
-    let original_solution = ksat_chain.extract_solution(&target_solution);
+    let target_solution = solver.solve(target).unwrap().unwrap();
+    let original_solution = ksat_chain.extract_solution(&target_solution).unwrap();
 
     // Verify the extracted solution satisfies the original 3-SAT formula
-    assert!(ksat.evaluate(&original_solution));
+    assert!(ksat.evaluate(&original_solution).unwrap());
 }
 
 #[test]
-fn test_size_field_names_returns_own_fields() {
+fn test_parameter_names_returns_own_fields() {
     let graph = ReductionGraph::new();
 
     // MIS should report its own fields (num_vertices, num_edges),
     // not the target's fields from any reduction.
-    let mis_fields = graph.size_field_names("MaximumIndependentSet");
+    let mis_fields = graph.parameter_names("MaximumIndependentSet");
     assert!(
-        mis_fields.contains(&"num_vertices"),
+        mis_fields.iter().any(|field| field == "num_vertices"),
         "MIS should have num_vertices, got: {:?}",
         mis_fields
     );
     assert!(
-        mis_fields.contains(&"num_edges"),
+        mis_fields.iter().any(|field| field == "num_edges"),
         "MIS should have num_edges, got: {:?}",
         mis_fields
     );
     // Should NOT contain target fields like num_vars or num_constraints
     assert!(
-        !mis_fields.contains(&"num_constraints"),
+        !mis_fields.iter().any(|field| field == "num_constraints"),
         "MIS should not report ILP's num_constraints, got: {:?}",
         mis_fields
     );
 
     // QUBO should report num_vars
-    let qubo_fields = graph.size_field_names("QUBO");
+    let qubo_fields = graph.parameter_names("QUBO");
     assert!(
-        qubo_fields.contains(&"num_vars"),
+        qubo_fields.iter().any(|field| field == "num_vars"),
         "QUBO should have num_vars, got: {:?}",
         qubo_fields
     );
 
     // Unknown problem returns empty
-    let unknown_fields = graph.size_field_names("NonExistentProblem");
+    let unknown_fields = graph.parameter_names("NonExistentProblem");
     assert!(unknown_fields.is_empty());
 }
 
 #[test]
-fn test_overhead_variables_are_consistent() {
-    // For each reduction, the input variables of the overhead should be
-    // a subset of the source problem's size fields (as derived from all
-    // reductions where it appears).
+fn parameter_contract_variables_are_registered_source_fields() {
     let graph = ReductionGraph::new();
 
     for entry in inventory::iter::<ReductionEntry> {
-        let overhead = entry.overhead();
-        let input_vars = overhead.input_variable_names();
+        let declarations = (entry.parameter_declarations_fn)();
+        let input_vars: std::collections::HashSet<_> = declarations
+            .fields
+            .iter()
+            .flat_map(|(_, expression)| expression.variables())
+            .collect();
         if input_vars.is_empty() {
             continue;
         }
 
-        let source_fields: std::collections::HashSet<&str> = graph
-            .size_field_names(entry.source_name)
+        let source_fields: std::collections::HashSet<String> = graph
+            .parameter_names(entry.source_name)
             .into_iter()
             .collect();
 
         for var in &input_vars {
             assert!(
-                source_fields.contains(var),
-                "Reduction {} -> {}: overhead references variable '{}' \
-                 which is not a known size field of {}. Known fields: {:?}",
+                source_fields.contains(*var),
+                "Reduction {} -> {}: parameter contract references variable '{}' \
+                 which is not a known parameter field of {}. Known fields: {:?}",
                 entry.source_name,
                 entry.target_name,
                 var,
@@ -1627,7 +1790,7 @@ fn test_variant_entry_complexity_available() {
 #[test]
 fn test_variant_complexity() {
     let graph = ReductionGraph::new();
-    let variant = ReductionGraph::variant_to_map(&[("graph", "SimpleGraph"), ("weight", "i32")]);
+    let variant = ReductionGraph::variant_to_map(&[("graph", "SimpleGraph"), ("weight", "i64")]);
     let complexity = graph.variant_complexity("MaximumIndependentSet", &variant);
     assert_eq!(complexity, Some("1.1996^num_vertices"));
 
@@ -1640,111 +1803,116 @@ fn test_variant_complexity() {
 }
 
 #[test]
-fn test_compute_source_size() {
-    let problem = MaximumIndependentSet::<SimpleGraph, i32>::new(
+fn test_compute_problem_parameters_uses_exact_variant_executor() {
+    let problem = MaximumIndependentSet::<SimpleGraph, i64>::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
         vec![1, 1, 1, 1],
     );
     let variant =
-        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let size = ReductionGraph::compute_source_size("MaximumIndependentSet", &variant, &problem);
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let size =
+        ReductionGraph::compute_problem_parameters("MaximumIndependentSet", &variant, &problem);
     assert_eq!(size.get("num_vertices"), Some(4));
     assert_eq!(size.get("num_edges"), Some(3));
 }
 
 #[test]
-fn test_compute_source_size_only_consults_matching_variant() {
-    // Entries for other variants of the same problem must never be invoked:
-    // their size functions downcast to a different concrete type and would panic.
-    let problem = MaximumIndependentSet::<SimpleGraph, One>::new(
-        SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]),
-        vec![One; 5],
-    );
-    let variant =
+fn test_outgoing_reductions_from_uses_exact_variant_and_mode() {
+    let graph = ReductionGraph::new();
+    let unit =
         ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, One>::variant());
-    let size = ReductionGraph::compute_source_size("MaximumIndependentSet", &variant, &problem);
-    assert_eq!(size.get("num_vertices"), Some(5));
-    assert_eq!(size.get("num_edges"), Some(5));
+    let weighted =
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+
+    let unit_targets =
+        graph.outgoing_reductions_from("MaximumIndependentSet", &unit, ReductionMode::Witness);
+    assert!(unit_targets
+        .iter()
+        .all(|edge| edge.source_variant == unit && edge.capabilities.witness));
+    assert!(unit_targets.iter().any(|edge| {
+        edge.target_name == "MaximumSetPacking"
+            && edge.target_variant.get("weight").map(String::as_str) == Some("One")
+    }));
+    assert!(!unit_targets
+        .iter()
+        .any(|edge| edge.target_name == "IntegralFlowBundles"));
+
+    let weighted_targets =
+        graph.outgoing_reductions_from("MaximumIndependentSet", &weighted, ReductionMode::Witness);
+    assert!(weighted_targets
+        .iter()
+        .all(|edge| edge.source_variant == weighted && edge.capabilities.witness));
+    assert!(!weighted_targets
+        .iter()
+        .any(|edge| edge.target_name == "IntegralFlowBundles"));
+    for (variant, has_flow_rule) in [(&unit, true), (&weighted, false)] {
+        let decision_targets = graph.outgoing_reductions_from(
+            "DecisionMaximumIndependentSet",
+            variant,
+            ReductionMode::Witness,
+        );
+        assert_eq!(
+            decision_targets
+                .iter()
+                .any(|edge| edge.target_name == "IntegralFlowBundles"),
+            has_flow_rule
+        );
+        let optimization_queries =
+            graph.outgoing_reductions_from("MaximumIndependentSet", variant, ReductionMode::Turing);
+        assert!(optimization_queries
+            .iter()
+            .any(|edge| edge.target_name == "DecisionMaximumIndependentSet"
+                && edge.target_variant == *variant));
+    }
+    assert!(!weighted_targets.iter().any(|edge| {
+        edge.target_name == "MaximumIndependentSet"
+            && edge.target_variant.get("graph").map(String::as_str) == Some("KingsSubgraph")
+    }));
 }
 
 #[test]
-fn test_compute_source_size_unknown_problem() {
-    let problem = 42u32;
-    let size =
-        ReductionGraph::compute_source_size("NonExistentProblem", &BTreeMap::new(), &problem);
-    assert!(size.components.is_empty());
+#[should_panic(expected = "registered problem variant not found")]
+fn test_outgoing_reductions_from_rejects_unknown_exact_variant() {
+    let graph = ReductionGraph::new();
+    graph.outgoing_reductions_from(
+        "MaximumIndependentSet",
+        &BTreeMap::from([
+            ("graph".to_string(), "SimpleGraph".to_string()),
+            ("weight".to_string(), "i128".to_string()),
+        ]),
+        ReductionMode::Witness,
+    );
 }
 
 #[test]
-fn test_evaluate_path_overhead() {
-    use crate::rules::cost::MinimizeStepsThenOverhead;
+#[should_panic(expected = "unregistered exact problem variant")]
+fn test_compute_problem_parameters_unknown_problem() {
+    let problem = 42u32;
+    ReductionGraph::compute_problem_parameters("NonExistentProblem", &BTreeMap::new(), &problem);
+}
 
+#[test]
+fn test_composed_path_parameters_transform_evaluation() {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
-    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
-    let input_size = ProblemSize::new(vec![("num_vertices", 10), ("num_edges", 20)]);
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let dst = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
+    let input_size = ProblemParameters::new(vec![("num_vertices", 10), ("num_edges", 20)]);
 
     let path = graph
-        .find_cheapest_path(
-            "MaximumIndependentSet",
-            &src,
-            "MinimumVertexCover",
-            &dst,
-            &input_size,
-            &MinimizeStepsThenOverhead,
-        )
-        .expect("should find path");
+        .find_all_paths("MaximumIndependentSet", &src, "MinimumVertexCover", &dst)
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("direct route");
 
-    let final_size = graph
-        .evaluate_path_overhead(&path, &input_size)
-        .expect("should evaluate overhead");
+    let transform = graph
+        .compose_path_parameter_transform(&path)
+        .unwrap()
+        .unwrap();
+    let final_size = transform
+        .evaluate(&input_size)
+        .expect("should evaluate composed parameter transform");
 
     // MIS → MVC preserves num_vertices and num_edges
     assert_eq!(final_size.get("num_vertices"), Some(10));
     assert_eq!(final_size.get("num_edges"), Some(20));
 }
-
-#[test]
-fn test_evaluate_path_overhead_multistep() {
-    use crate::rules::cost::MinimizeStepsThenOverhead;
-
-    // MIS → SetPacking<One> → SetPacking<i32> → ILP<bool> (3 steps with size transformations)
-    let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, One>::variant());
-    let dst_variants = graph.variants_for("ILP");
-    let dst = dst_variants
-        .iter()
-        .find(|v| v.get("variable") == Some(&"bool".to_string()))
-        .expect("ILP<bool> variant should exist");
-    let input_size = ProblemSize::new(vec![("num_vertices", 10), ("num_edges", 20)]);
-
-    let path = graph
-        .find_cheapest_path_mode(
-            "MaximumIndependentSet",
-            &src,
-            "ILP",
-            dst,
-            ReductionMode::Witness,
-            &input_size,
-            &MinimizeStepsThenOverhead,
-        )
-        .expect("should find path");
-
-    assert!(
-        path.len() >= 2,
-        "path should have at least 2 steps, got {}",
-        path.len()
-    );
-
-    let final_size = graph
-        .evaluate_path_overhead(&path, &input_size)
-        .expect("should evaluate overhead");
-
-    // MIS(V=10,E=20) → SetPacking(sets=V=10, universe=E=20) → ... → ILP(vars=10, constraints=20)
-    // The final ILP dimensions should reflect the composed overhead, not the input.
-    assert_eq!(final_size.get("num_vars"), Some(10));
-    assert_eq!(final_size.get("num_constraints"), Some(20));
-    // Original MIS fields should NOT appear in the final output
-    assert_eq!(final_size.get("num_vertices"), None);
-    assert_eq!(final_size.get("num_edges"), None);
-}
diff --git a/src/unit_tests/rules/graphpartitioning_ilp.rs b/src/unit_tests/rules/graphpartitioning_ilp.rs
index bb0ec4e4e..dc50e06a1 100644
--- a/src/unit_tests/rules/graphpartitioning_ilp.rs
+++ b/src/unit_tests/rules/graphpartitioning_ilp.rs
@@ -27,24 +27,25 @@ fn canonical_instance() -> GraphPartitioning<SimpleGraph> {
 #[test]
 fn test_reduction_creates_valid_ilp() {
     let problem = canonical_instance();
-    let reduction: ReductionGraphPartitioningToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionGraphPartitioningToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 15);
-    assert_eq!(ilp.constraints.len(), 19);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 15);
+    assert_eq!(ilp.constraints().len(), 19);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
     assert_eq!(
-        ilp.objective,
+        ilp.objective(),
         vec![
-            (6, 1.0),
-            (7, 1.0),
-            (8, 1.0),
-            (9, 1.0),
-            (10, 1.0),
-            (11, 1.0),
-            (12, 1.0),
-            (13, 1.0),
-            (14, 1.0),
+            (6, 1),
+            (7, 1),
+            (8, 1),
+            (9, 1),
+            (10, 1),
+            (11, 1),
+            (12, 1),
+            (13, 1),
+            (14, 1),
         ]
     );
 }
@@ -52,43 +53,45 @@ fn test_reduction_creates_valid_ilp() {
 #[test]
 fn test_reduction_constraint_shape() {
     let problem = GraphPartitioning::new(SimpleGraph::new(2, vec![(0, 1)]));
-    let reduction: ReductionGraphPartitioningToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionGraphPartitioningToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 3);
-    assert_eq!(ilp.constraints.len(), 3);
+    assert_eq!(ilp.num_vars(), 3);
+    assert_eq!(ilp.constraints().len(), 3);
 
-    let balance = &ilp.constraints[0];
-    assert_eq!(balance.cmp, Comparison::Eq);
-    assert_eq!(balance.terms, vec![(0, 1.0), (1, 1.0)]);
-    assert_eq!(balance.rhs, 1.0);
+    let balance = &ilp.constraints()[0];
+    assert_eq!(balance.comparison(), Comparison::Eq);
+    assert_eq!(balance.terms(), vec![(0, 2), (1, 2)]);
+    assert_eq!(balance.rhs(), 2);
 
-    let first_link = &ilp.constraints[1];
-    assert_eq!(first_link.cmp, Comparison::Ge);
-    assert_eq!(first_link.terms, vec![(2, 1.0), (0, -1.0), (1, 1.0)]);
-    assert_eq!(first_link.rhs, 0.0);
+    let first_link = &ilp.constraints()[1];
+    assert_eq!(first_link.comparison(), Comparison::Ge);
+    assert_eq!(first_link.terms(), vec![(0, -1), (1, 1), (2, 1)]);
+    assert_eq!(first_link.rhs(), 0);
 
-    let second_link = &ilp.constraints[2];
-    assert_eq!(second_link.cmp, Comparison::Ge);
-    assert_eq!(second_link.terms, vec![(2, 1.0), (0, 1.0), (1, -1.0)]);
-    assert_eq!(second_link.rhs, 0.0);
+    let second_link = &ilp.constraints()[2];
+    assert_eq!(second_link.comparison(), Comparison::Ge);
+    assert_eq!(second_link.terms(), vec![(0, 1), (1, -1), (2, 1)]);
+    assert_eq!(second_link.rhs(), 0);
 }
 
 #[test]
 fn test_graphpartitioning_to_ilp_closed_loop() {
     let problem = canonical_instance();
-    let reduction: ReductionGraphPartitioningToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionGraphPartitioningToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_obj = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_obj = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_obj = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_obj = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_obj, Min(Some(3)));
     assert_eq!(ilp_obj, Min(Some(3)));
@@ -97,36 +100,42 @@ fn test_graphpartitioning_to_ilp_closed_loop() {
 #[test]
 fn test_odd_vertices_reduce_to_infeasible_ilp() {
     let problem = GraphPartitioning::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction: ReductionGraphPartitioningToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionGraphPartitioningToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.constraints[0].cmp, Comparison::Eq);
-    assert_eq!(ilp.constraints[0].rhs, 1.5);
+    assert_eq!(ilp.constraints()[0].comparison(), Comparison::Eq);
+    assert_eq!(ilp.constraints()[0].terms(), vec![(0, 2), (1, 2), (2, 2)]);
+    assert_eq!(ilp.constraints()[0].rhs(), 3);
 
     let solver = ILPSolver::new();
-    assert_eq!(solver.solve(ilp), None);
+    assert_eq!(
+        solver.solve(ilp),
+        Err(crate::solvers::ILPSolveError::Infeasible)
+    );
 }
 
 #[test]
 fn test_solution_extraction() {
     let problem = canonical_instance();
-    let reduction: ReductionGraphPartitioningToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionGraphPartitioningToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = vec![0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, vec![0, 0, 0, 1, 1, 1]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(3)));
+    assert_eq!(extracted, vec![false, false, false, true, true, true]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(3)));
 }
 
 #[test]
-fn test_solve_reduced() {
+fn test_solve_via_ilp_pipeline() {
     let problem = canonical_instance();
 
     let ilp_solver = ILPSolver::new();
     let solution = ilp_solver
-        .solve_reduced(&problem)
-        .expect("solve_reduced should work");
+        .solve(&problem)
+        .expect("ILP pipeline should solve the problem");
 
-    assert_eq!(problem.evaluate(&solution), Min(Some(3)));
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(3)));
 }
diff --git a/src/unit_tests/rules/graphpartitioning_maxcut.rs b/src/unit_tests/rules/graphpartitioning_maxcut.rs
index ca9acf458..d2e94e59a 100644
--- a/src/unit_tests/rules/graphpartitioning_maxcut.rs
+++ b/src/unit_tests/rules/graphpartitioning_maxcut.rs
@@ -10,7 +10,8 @@ fn issue_example() -> GraphPartitioning<SimpleGraph> {
 #[test]
 fn test_graphpartitioning_to_maxcut_closed_loop() {
     let source = issue_example();
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -22,10 +23,11 @@ fn test_graphpartitioning_to_maxcut_closed_loop() {
 #[test]
 fn test_graphpartitioning_to_maxcut_target_structure() {
     let source = issue_example();
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
     let num_vertices = source.num_vertices();
-    let penalty = i32::try_from(source.num_edges()).unwrap() + 1;
+    let penalty = i64::try_from(source.num_edges()).unwrap() + 1;
 
     assert_eq!(target.num_vertices(), num_vertices);
     assert_eq!(target.num_edges(), num_vertices * (num_vertices - 1) / 2);
@@ -49,17 +51,18 @@ fn test_graphpartitioning_to_maxcut_target_structure() {
 #[test]
 fn test_graphpartitioning_to_maxcut_extract_solution_identity() {
     let source = issue_example();
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).expect("reduction should succeed");
     let target_solution = super::ISSUE_EXAMPLE_WITNESS.to_vec();
 
     assert_eq!(
-        reduction.extract_solution(&target_solution),
+        reduction.extract_solution(&target_solution).unwrap(),
         target_solution
     );
 }
 
 #[test]
 fn test_graphpartitioning_to_maxcut_penalty_overflow_panics() {
-    let result = std::panic::catch_unwind(|| super::penalty_weight(i32::MAX as usize));
+    let result = std::panic::catch_unwind(|| super::penalty_weight(i64::MAX as usize));
     assert!(result.is_err());
 }
diff --git a/src/unit_tests/rules/graphpartitioning_qubo.rs b/src/unit_tests/rules/graphpartitioning_qubo.rs
index 779eea84f..b378a227c 100644
--- a/src/unit_tests/rules/graphpartitioning_qubo.rs
+++ b/src/unit_tests/rules/graphpartitioning_qubo.rs
@@ -23,7 +23,7 @@ fn example_problem() -> GraphPartitioning<SimpleGraph> {
 #[test]
 fn test_graphpartitioning_to_qubo_closed_loop() {
     let source = example_problem();
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -35,12 +35,12 @@ fn test_graphpartitioning_to_qubo_closed_loop() {
 #[test]
 fn test_graphpartitioning_to_qubo_matrix_matches_issue_example() {
     let source = example_problem();
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     assert_eq!(qubo.num_vars(), 6);
 
-    let expected_diagonal = [-48.0, -47.0, -46.0, -46.0, -47.0, -48.0];
+    let expected_diagonal = [-48, -47, -46, -46, -47, -48];
     for (index, expected) in expected_diagonal.into_iter().enumerate() {
         assert_eq!(qubo.get(index, index), Some(&expected));
     }
@@ -57,12 +57,12 @@ fn test_graphpartitioning_to_qubo_matrix_matches_issue_example() {
         (4, 5),
     ];
     for &(u, v) in &edge_pairs {
-        assert_eq!(qubo.get(u, v), Some(&18.0), "edge ({u}, {v})");
+        assert_eq!(qubo.get(u, v), Some(&18), "edge ({u}, {v})");
     }
 
     let non_edge_pairs = [(0, 3), (0, 4), (0, 5), (1, 4), (1, 5), (2, 5)];
     for &(u, v) in &non_edge_pairs {
-        assert_eq!(qubo.get(u, v), Some(&20.0), "non-edge ({u}, {v})");
+        assert_eq!(qubo.get(u, v), Some(&20), "non-edge ({u}, {v})");
     }
 }
 
diff --git a/src/unit_tests/rules/hamiltoniancircuit_biconnectivityaugmentation.rs b/src/unit_tests/rules/hamiltoniancircuit_biconnectivityaugmentation.rs
index b5ba18142..490356692 100644
--- a/src/unit_tests/rules/hamiltoniancircuit_biconnectivityaugmentation.rs
+++ b/src/unit_tests/rules/hamiltoniancircuit_biconnectivityaugmentation.rs
@@ -13,7 +13,8 @@ fn cycle4_hc() -> HamiltonianCircuit<SimpleGraph> {
 #[test]
 fn test_hamiltoniancircuit_to_biconnectivityaugmentation_closed_loop() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -25,7 +26,8 @@ fn test_hamiltoniancircuit_to_biconnectivityaugmentation_closed_loop() {
 #[test]
 fn test_hamiltoniancircuit_to_biconnectivityaugmentation_structure() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Same number of vertices
@@ -59,15 +61,16 @@ fn test_hamiltoniancircuit_to_biconnectivityaugmentation_structure() {
 #[test]
 fn test_hamiltoniancircuit_to_biconnectivityaugmentation_extract_solution() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     // Select edges (0,1), (0,3), (1,2), (2,3) => config [1, 0, 1, 1, 0, 1]
-    let target_config = vec![1, 0, 1, 1, 0, 1];
-    let extracted = reduction.extract_solution(&target_config);
+    let target_config = vec![true, false, true, true, false, true];
+    let extracted = reduction.extract_solution(&target_config).unwrap();
 
     assert_eq!(extracted.len(), 4);
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted solution must be a valid HC"
     );
 }
@@ -76,12 +79,13 @@ fn test_hamiltoniancircuit_to_biconnectivityaugmentation_extract_solution() {
 fn test_hamiltoniancircuit_to_biconnectivityaugmentation_no_circuit() {
     // Path graph 0-1-2-3: no Hamiltonian circuit (endpoints have degree 1)
     let source = HamiltonianCircuit::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // The target should have no feasible augmentation
     let solver = BruteForce::new();
-    let witness = solver.find_witness(target);
+    let witness = solver.solve(target).unwrap();
     assert!(
         witness.is_none(),
         "target should be infeasible when source has no HC"
@@ -92,7 +96,8 @@ fn test_hamiltoniancircuit_to_biconnectivityaugmentation_no_circuit() {
 fn test_hamiltoniancircuit_to_biconnectivityaugmentation_triangle() {
     // Triangle graph: 3 vertices, 3 edges, has HC
     let source = HamiltonianCircuit::new(SimpleGraph::cycle(3));
-    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -105,7 +110,8 @@ fn test_hamiltoniancircuit_to_biconnectivityaugmentation_triangle() {
 fn test_hamiltoniancircuit_to_biconnectivityaugmentation_complete4() {
     // Complete graph K4: has many Hamiltonian circuits
     let source = HamiltonianCircuit::new(SimpleGraph::complete(4));
-    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     // All potential edges have weight 1 (K4 has all edges)
     let target = reduction.target_problem();
@@ -119,3 +125,88 @@ fn test_hamiltoniancircuit_to_biconnectivityaugmentation_complete4() {
         "HamiltonianCircuit(K4) -> BiconnectivityAugmentation",
     );
 }
+
+#[test]
+fn test_hamiltoniancircuit_to_biconnectivityaugmentation_small_graphs() {
+    for n in 0..3 {
+        let edges = if n == 2 {
+            vec![(0, 1), (0, 1), (1, 1)]
+        } else {
+            vec![]
+        };
+        let source = HamiltonianCircuit::new(SimpleGraph::new(n, edges));
+        let reduction =
+            ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        assert_eq!(target.num_vertices(), 3);
+        assert_eq!(target.num_edges(), 0);
+        assert_eq!(target.num_potential_edges(), 0);
+        assert_eq!(*target.budget(), 0);
+        assert!(!target.evaluate(&vec![]).unwrap().0);
+        assert!(reduction.extract_solution(&vec![]).is_err());
+        assert!(BruteForce::new().solve(&source).unwrap().is_none());
+        assert!(BruteForce::new().solve(target).unwrap().is_none());
+    }
+}
+
+#[test]
+fn test_hamiltoniancircuit_to_biconnectivityaugmentation_all_graphs_and_certificates() {
+    for n in 3..=4 {
+        let pairs: Vec<_> = (0..n)
+            .flat_map(|u| (u + 1..n).map(move |v| (u, v)))
+            .collect();
+        for edge_mask in 0..1usize << pairs.len() {
+            let mut edges: Vec<_> = pairs
+                .iter()
+                .enumerate()
+                .filter(|(i, _)| edge_mask & (1 << i) != 0)
+                .map(|(_, &e)| e)
+                .collect();
+            // Native SimpleGraph inputs can contain loops and repeated edges.
+            edges.extend(edges.clone());
+            edges.extend((0..n).map(|v| (v, v)));
+            let source = HamiltonianCircuit::new(SimpleGraph::new(n, edges));
+            let reduction =
+                ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i64>>::reduce_to(&source)
+                    .unwrap();
+            let mut target_yes = false;
+            for mask in 0..1usize << pairs.len() {
+                let config: Vec<_> = (0..pairs.len()).map(|i| mask & (1 << i) != 0).collect();
+                let feasible = reduction.target_problem().evaluate(&config).unwrap().0;
+                let extracted = reduction.extract_solution(&config);
+                assert_eq!(extracted.is_ok(), feasible);
+                if let Ok(circuit) = extracted {
+                    assert!(source.evaluate(&circuit).unwrap().0);
+                    target_yes = true;
+                }
+            }
+            assert_eq!(
+                target_yes,
+                BruteForce::new().solve(&source).unwrap().is_some()
+            );
+        }
+    }
+}
+
+#[test]
+fn test_hamiltoniancircuit_to_biconnectivityaugmentation_rejects_infeasible_certificates() {
+    let source = HamiltonianCircuit::new(SimpleGraph::empty(3));
+    let reduction =
+        ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+    // A spanning cycle made only of non-edges exceeds the budget and is not a source cycle.
+    assert!(reduction.extract_solution(&vec![true; 3]).is_err());
+    assert!(reduction.extract_solution(&vec![false; 3]).is_err());
+    assert!(reduction.extract_solution(&vec![true; 2]).is_err());
+    assert!(reduction.extract_solution(&vec![true; 4]).is_err());
+    let source = HamiltonianCircuit::new(SimpleGraph::complete(6));
+    let reduction =
+        ReduceTo::<BiconnectivityAugmentation<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+    // Two disjoint triangles meet the budget and degree constraints but are disconnected.
+    let config = reduction
+        .target_problem()
+        .potential_weights()
+        .iter()
+        .map(|&(u, v, _)| (u < 3) == (v < 3))
+        .collect();
+    assert!(reduction.extract_solution(&config).is_err());
+}
diff --git a/src/unit_tests/rules/hamiltoniancircuit_bottlenecktravelingsalesman.rs b/src/unit_tests/rules/hamiltoniancircuit_bottlenecktravelingsalesman.rs
index be81f53d8..5623656a4 100644
--- a/src/unit_tests/rules/hamiltoniancircuit_bottlenecktravelingsalesman.rs
+++ b/src/unit_tests/rules/hamiltoniancircuit_bottlenecktravelingsalesman.rs
@@ -14,7 +14,8 @@ fn cycle5_hc() -> HamiltonianCircuit<SimpleGraph> {
 #[test]
 fn test_hamiltoniancircuit_to_bottlenecktravelingsalesman_closed_loop() {
     let source = cycle5_hc();
-    let reduction = ReduceTo::<BottleneckTravelingSalesman>::reduce_to(&source);
+    let reduction = ReduceTo::<BottleneckTravelingSalesman>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -26,7 +27,8 @@ fn test_hamiltoniancircuit_to_bottlenecktravelingsalesman_closed_loop() {
 #[test]
 fn test_hamiltoniancircuit_to_bottlenecktravelingsalesman_structure() {
     let source = cycle5_hc();
-    let reduction = ReduceTo::<BottleneckTravelingSalesman>::reduce_to(&source);
+    let reduction = ReduceTo::<BottleneckTravelingSalesman>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Complete graph on 5 vertices: C(5,2) = 10 edges
@@ -44,13 +46,15 @@ fn test_hamiltoniancircuit_to_bottlenecktravelingsalesman_structure() {
 fn test_hamiltoniancircuit_to_bottlenecktravelingsalesman_nonhamiltonian_bottleneck_gap() {
     // Star graph has no Hamiltonian circuit, so optimal bottleneck must exceed 1
     let source = HamiltonianCircuit::new(SimpleGraph::star(5));
-    let reduction = ReduceTo::<BottleneckTravelingSalesman>::reduce_to(&source);
+    let reduction = ReduceTo::<BottleneckTravelingSalesman>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("complete weighted graph should always admit a tour");
 
-    let metric = target.evaluate(&best);
+    let metric = target.evaluate(&best).unwrap();
     assert!(metric.is_valid(), "best BTSP solution evaluated as invalid");
     assert!(
         metric.unwrap() > 1,
@@ -61,22 +65,23 @@ fn test_hamiltoniancircuit_to_bottlenecktravelingsalesman_nonhamiltonian_bottlen
 #[test]
 fn test_hamiltoniancircuit_to_bottlenecktravelingsalesman_extract_solution_cycle() {
     let source = cycle5_hc();
-    let reduction = ReduceTo::<BottleneckTravelingSalesman>::reduce_to(&source);
+    let reduction = ReduceTo::<BottleneckTravelingSalesman>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Manually select the cycle edges in the complete graph
     let cycle_edges = [(0usize, 1usize), (1, 2), (2, 3), (3, 4), (0, 4)];
-    let target_solution: Vec<usize> = target
+    let target_solution: Vec<bool> = target
         .graph()
         .edges()
         .into_iter()
-        .map(|(u, v)| usize::from(cycle_edges.contains(&(u, v)) || cycle_edges.contains(&(v, u))))
+        .map(|(u, v)| cycle_edges.contains(&(u, v)) || cycle_edges.contains(&(v, u)))
         .collect();
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
     // Bottleneck should be 1 (all selected edges are original cycle edges)
-    assert_eq!(target.evaluate(&target_solution), Min(Some(1)));
+    assert_eq!(target.evaluate(&target_solution).unwrap(), Min(Some(1)));
     assert_eq!(extracted.len(), 5);
-    assert!(source.evaluate(&extracted).is_valid());
+    assert!(source.evaluate(&extracted).unwrap().is_valid());
 }
diff --git a/src/unit_tests/rules/hamiltoniancircuit_hamiltonianpath.rs b/src/unit_tests/rules/hamiltoniancircuit_hamiltonianpath.rs
index e9b9ca02a..4f0482880 100644
--- a/src/unit_tests/rules/hamiltoniancircuit_hamiltonianpath.rs
+++ b/src/unit_tests/rules/hamiltoniancircuit_hamiltonianpath.rs
@@ -13,7 +13,8 @@ fn cycle4_hc() -> HamiltonianCircuit<SimpleGraph> {
 #[test]
 fn test_hamiltoniancircuit_to_hamiltonianpath_closed_loop() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -25,7 +26,8 @@ fn test_hamiltoniancircuit_to_hamiltonianpath_closed_loop() {
 #[test]
 fn test_hamiltoniancircuit_to_hamiltonianpath_structure() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Original: 4 vertices, 4 edges (cycle)
@@ -53,15 +55,16 @@ fn test_hamiltoniancircuit_to_hamiltonianpath_structure() {
 #[test]
 fn test_hamiltoniancircuit_to_hamiltonianpath_extract_solution() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     // HP solution: s=5, 0, 1, 2, 3, v'=4, t=6
     let hp_config = vec![5, 0, 1, 2, 3, 4, 6];
-    let extracted = reduction.extract_solution(&hp_config);
+    let extracted = reduction.extract_solution(&hp_config).unwrap();
 
     assert_eq!(extracted.len(), 4);
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted solution must be a valid HC"
     );
 }
@@ -69,15 +72,16 @@ fn test_hamiltoniancircuit_to_hamiltonianpath_extract_solution() {
 #[test]
 fn test_hamiltoniancircuit_to_hamiltonianpath_extract_reversed() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     // HP solution reversed: t=6, v'=4, 3, 2, 1, 0, s=5
     let hp_config = vec![6, 4, 3, 2, 1, 0, 5];
-    let extracted = reduction.extract_solution(&hp_config);
+    let extracted = reduction.extract_solution(&hp_config).unwrap();
 
     assert_eq!(extracted.len(), 4);
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted reversed solution must be a valid HC"
     );
 }
@@ -86,12 +90,13 @@ fn test_hamiltoniancircuit_to_hamiltonianpath_extract_reversed() {
 fn test_hamiltoniancircuit_to_hamiltonianpath_no_circuit() {
     // Path graph 0-1-2-3: no Hamiltonian circuit (vertices 0 and 3 have degree 1)
     let source = HamiltonianCircuit::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // The target should have no Hamiltonian path (since source has no HC)
     let solver = BruteForce::new();
-    let witness = solver.find_witness(target);
+    let witness = solver.solve(target).unwrap();
     assert!(
         witness.is_none(),
         "target should have no HP when source has no HC"
@@ -102,7 +107,8 @@ fn test_hamiltoniancircuit_to_hamiltonianpath_no_circuit() {
 fn test_hamiltoniancircuit_to_hamiltonianpath_triangle() {
     // Triangle graph: 3 vertices, 3 edges, has HC
     let source = HamiltonianCircuit::new(SimpleGraph::cycle(3));
-    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -114,7 +120,8 @@ fn test_hamiltoniancircuit_to_hamiltonianpath_triangle() {
 #[test]
 fn test_hamiltoniancircuit_to_hamiltonianpath_two_vertex_special_case_is_unsatisfiable() {
     let source = HamiltonianCircuit::new(SimpleGraph::new(2, vec![(0, 1)]));
-    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<HamiltonianPath<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.graph().num_vertices(), 5);
@@ -122,7 +129,7 @@ fn test_hamiltoniancircuit_to_hamiltonianpath_two_vertex_special_case_is_unsatis
 
     let solver = BruteForce::new();
     assert!(
-        solver.find_witness(target).is_none(),
+        solver.solve(target).unwrap().is_none(),
         "2-vertex source should reduce to an unsatisfiable HamiltonianPath instance"
     );
 }
diff --git a/src/unit_tests/rules/hamiltoniancircuit_longestcircuit.rs b/src/unit_tests/rules/hamiltoniancircuit_longestcircuit.rs
index 821d9c4bb..e7d230743 100644
--- a/src/unit_tests/rules/hamiltoniancircuit_longestcircuit.rs
+++ b/src/unit_tests/rules/hamiltoniancircuit_longestcircuit.rs
@@ -11,10 +11,29 @@ fn cycle4_hc() -> HamiltonianCircuit<SimpleGraph> {
     HamiltonianCircuit::new(SimpleGraph::cycle(4))
 }
 
+#[test]
+fn test_hamiltoniancircuit_aggregate_requires_a_spanning_cycle() {
+    let reduction = ReduceTo::<LongestCircuit<SimpleGraph, i64>>::reduce_to(&cycle4_hc()).unwrap();
+    for (value, expected) in [
+        (Max(None), false),
+        (Max(Some(3)), false),
+        (Max(Some(4)), true),
+    ] {
+        assert_eq!(
+            crate::rules::AggregateReductionResult::extract_value(&reduction, value),
+            crate::types::Or(expected),
+        );
+    }
+    let short_cycle = HamiltonianCircuit::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (0, 2)]));
+    let reduction = ReduceTo::<LongestCircuit<SimpleGraph, i64>>::reduce_to(&short_cycle).unwrap();
+    assert!(reduction.extract_solution(&vec![true; 3]).is_err());
+}
+
 #[test]
 fn test_hamiltoniancircuit_to_longestcircuit_closed_loop() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<LongestCircuit<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<LongestCircuit<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -26,7 +45,8 @@ fn test_hamiltoniancircuit_to_longestcircuit_closed_loop() {
 #[test]
 fn test_hamiltoniancircuit_to_longestcircuit_structure() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<LongestCircuit<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<LongestCircuit<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Same graph structure
@@ -41,15 +61,16 @@ fn test_hamiltoniancircuit_to_longestcircuit_structure() {
 fn test_hamiltoniancircuit_to_longestcircuit_nonhamiltonian() {
     // Star graph on 4 vertices: no Hamiltonian circuit
     let source = HamiltonianCircuit::new(SimpleGraph::star(4));
-    let reduction = ReduceTo::<LongestCircuit<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<LongestCircuit<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(target);
+    let witness = solver.solve(target).unwrap();
 
     match witness {
         Some(sol) => {
-            let value = target.evaluate(&sol);
+            let value = target.evaluate(&sol).unwrap();
             // Optimal circuit length must be strictly less than n=4
             assert!(
                 value.unwrap() < 4,
@@ -65,14 +86,56 @@ fn test_hamiltoniancircuit_to_longestcircuit_nonhamiltonian() {
 #[test]
 fn test_hamiltoniancircuit_to_longestcircuit_extract_solution() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<LongestCircuit<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<LongestCircuit<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // All edges selected forms a Hamiltonian circuit on the cycle graph
-    let target_solution = vec![1, 1, 1, 1];
-    let extracted = reduction.extract_solution(&target_solution);
+    let target_solution = vec![true, true, true, true];
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
-    assert_eq!(target.evaluate(&target_solution), Max(Some(4)));
+    assert_eq!(target.evaluate(&target_solution).unwrap(), Max(Some(4)));
     assert_eq!(extracted.len(), 4);
-    assert!(source.evaluate(&extracted));
+    assert!(source.evaluate(&extracted).unwrap());
+}
+
+#[test]
+fn test_hamiltoniancircuit_extraction_matches_all_small_target_configurations() {
+    // Enumerate every simple graph and every edge selection, including graphs
+    // with no circuit, short circuits, and malformed selections of valid length.
+    for n in 0..=4 {
+        let possible: Vec<_> = (0..n)
+            .flat_map(|u| ((u + 1)..n).map(move |v| (u, v)))
+            .collect();
+        for graph_mask in 0usize..(1 << possible.len()) {
+            let edges: Vec<_> = possible
+                .iter()
+                .enumerate()
+                .filter_map(|(i, &edge)| ((graph_mask >> i) & 1 == 1).then_some(edge))
+                .collect();
+            let source = HamiltonianCircuit::new(SimpleGraph::new(n, edges));
+            let reduction =
+                ReduceTo::<LongestCircuit<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+            let target = crate::rules::AggregateReductionResult::target_problem(&reduction);
+            for mask in 0usize..(1 << target.num_edges()) {
+                let config: Vec<_> = (0..target.num_edges())
+                    .map(|i| (mask >> i) & 1 == 1)
+                    .collect();
+                let value = target.evaluate(&config).unwrap();
+                let certifies = value.0 == Some(n as i64);
+                let extracted = reduction.extract_solution(&config);
+                assert_eq!(
+                    extracted.is_ok(),
+                    certifies,
+                    "n={n}, graph={graph_mask}, config={mask}"
+                );
+                if let Ok(order) = extracted {
+                    assert!(source.evaluate(&order).unwrap().0);
+                }
+            }
+            assert!(reduction
+                .extract_solution(&vec![false; target.num_edges() + 1])
+                .is_err());
+        }
+    }
 }
diff --git a/src/unit_tests/rules/hamiltoniancircuit_quadraticassignment.rs b/src/unit_tests/rules/hamiltoniancircuit_quadraticassignment.rs
index 97c0ddc52..466d811f9 100644
--- a/src/unit_tests/rules/hamiltoniancircuit_quadraticassignment.rs
+++ b/src/unit_tests/rules/hamiltoniancircuit_quadraticassignment.rs
@@ -15,7 +15,8 @@ fn cycle4_hc() -> HamiltonianCircuit<SimpleGraph> {
 #[test]
 fn test_hamiltoniancircuit_to_quadraticassignment_closed_loop() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<QuadraticAssignment>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<QuadraticAssignment>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -27,7 +28,8 @@ fn test_hamiltoniancircuit_to_quadraticassignment_closed_loop() {
 #[test]
 fn test_hamiltoniancircuit_to_quadraticassignment_structure() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<QuadraticAssignment>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<QuadraticAssignment>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_facilities(), 4);
@@ -42,56 +44,53 @@ fn test_hamiltoniancircuit_to_quadraticassignment_structure() {
         }
     }
 
-    // Distance matrix: edge = 1, non-edge = omega = 5
+    // Distance matrix: edges and diagonal cost zero, non-edges cost one.
     let dist = target.distance_matrix();
     for (k, dist_row) in dist.iter().enumerate() {
         for (l, &dist_val) in dist_row.iter().enumerate() {
-            let expected = if k == l {
-                0
-            } else if source.graph().has_edge(k, l) {
-                1
-            } else {
-                5 // omega = n + 1 = 5
-            };
+            let expected = i64::from(k != l && !source.graph().has_edge(k, l));
             assert_eq!(dist_val, expected, "dist[{k}][{l}] should be {expected}");
         }
     }
 }
 
 #[test]
-fn test_hamiltoniancircuit_to_quadraticassignment_optimal_cost_equals_n() {
+fn test_hamiltoniancircuit_to_quadraticassignment_optimal_cost_is_zero() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<QuadraticAssignment>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<QuadraticAssignment>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // The identity permutation [0,1,2,3] is a valid HC on a 4-cycle,
-    // so the QAP optimum should be exactly n = 4.
+    // so the QAP optimum should be zero.
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("QAP should have an optimal solution");
-    let value = target.evaluate(&best);
-    assert_eq!(value, Min(Some(4)), "optimal QAP cost should be n=4");
+    let value = target.evaluate(&best).unwrap();
+    assert_eq!(value, Min(Some(0)), "optimal QAP cost should be zero");
 }
 
 #[test]
 fn test_hamiltoniancircuit_to_quadraticassignment_nonhamiltonian_cost_gap() {
     // Star graph on 4 vertices has no Hamiltonian circuit
     let source = HamiltonianCircuit::new(SimpleGraph::star(4));
-    let reduction = ReduceTo::<QuadraticAssignment>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<QuadraticAssignment>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
-    let n = source.num_vertices();
 
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("QAP always has a solution");
-    let value = target.evaluate(&best);
+    let value = target.evaluate(&best).unwrap();
     assert!(
         value.is_valid(),
         "QAP solution should have a valid objective"
     );
     assert!(
-        value.unwrap() > n as i64,
-        "expected QAP cost > {n} for non-Hamiltonian graph, got {:?}",
+        value.unwrap() > 0,
+        "expected positive QAP cost for non-Hamiltonian graph, got {:?}",
         value
     );
 }
@@ -99,19 +98,19 @@ fn test_hamiltoniancircuit_to_quadraticassignment_nonhamiltonian_cost_gap() {
 #[test]
 fn test_hamiltoniancircuit_to_quadraticassignment_extract_solution() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<QuadraticAssignment>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<QuadraticAssignment>::reduce_to(&source).expect("reduction should succeed");
 
     // Permutation [0,1,2,3] visits 0->1->2->3->0 on cycle4
     let target_config = vec![0, 1, 2, 3];
-    let extracted = reduction.extract_solution(&target_config);
+    let extracted = reduction.extract_solution(&target_config).unwrap();
     assert_eq!(extracted, vec![0, 1, 2, 3]);
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted solution should be a valid HC"
     );
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_prism_graph_hc_via_qap_ilp_roundtrip() {
     use crate::models::algebraic::ILP;
@@ -132,17 +131,165 @@ fn test_prism_graph_hc_via_qap_ilp_roundtrip() {
     let hc = HamiltonianCircuit::new(SimpleGraph::new(6, edges));
 
     // HC → QAP → ILP → solve → extract back
-    let r1 = ReduceTo::<QuadraticAssignment>::reduce_to(&hc);
-    let r2 = ReduceTo::<ILP<bool>>::reduce_to(r1.target_problem());
+    let r1 = ReduceTo::<QuadraticAssignment>::reduce_to(&hc).expect("reduction should succeed");
+    let r2 =
+        ReduceTo::<ILP<bool>>::reduce_to(r1.target_problem()).expect("reduction should succeed");
     let ilp_sol = ILPSolver::new()
         .solve(r2.target_problem())
         .expect("ILP should be feasible");
-    let qap_sol = r2.extract_solution(&ilp_sol);
-    let hc_sol = r1.extract_solution(&qap_sol);
+    let qap_sol = r2.extract_solution(&ilp_sol).unwrap();
+    let hc_sol = r1.extract_solution(&qap_sol).unwrap();
 
     assert!(
-        hc.evaluate(&hc_sol).0,
+        hc.evaluate(&hc_sol).unwrap().0,
         "prism graph HC via QAP→ILP should produce a valid Hamiltonian circuit, got {:?}",
         hc_sol
     );
 }
+
+#[test]
+fn test_hamiltoniancircuit_to_quadraticassignment_small_graphs_are_no() {
+    for (n, edges) in [
+        (0, vec![]),
+        (1, vec![]),
+        (1, vec![(0, 0)]),
+        (2, vec![]),
+        (2, vec![(0, 1)]),
+        (2, vec![(0, 0), (0, 1), (0, 1), (1, 1)]),
+    ] {
+        let source = HamiltonianCircuit::new(SimpleGraph::new(n, edges));
+        assert!(!source.evaluate(&(0..n).collect()).unwrap().0);
+        let reduction = ReduceTo::<QuadraticAssignment>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        assert_eq!(target.num_facilities(), 3);
+        assert_eq!(target.num_locations(), 3);
+        let best = BruteForce::new().solve(target).unwrap().unwrap();
+        let value = target.evaluate(&best).unwrap();
+        assert_eq!(value, Min(Some(3)));
+        assert!(!crate::rules::AggregateReductionResult::extract_value(&reduction, value).0);
+        assert!(reduction.extract_solution(&best).is_err());
+    }
+}
+
+#[test]
+fn test_hamiltoniancircuit_to_quadraticassignment_rejects_invalid_certificates() {
+    let reduction = ReduceTo::<QuadraticAssignment>::reduce_to(&cycle4_hc()).unwrap();
+    for config in [
+        vec![],
+        vec![0, 1, 2],
+        vec![0, 1, 2, 4],
+        vec![0, 0, 1, 2],
+        vec![0, 2, 1, 3],
+    ] {
+        assert!(reduction.extract_solution(&config).is_err(), "{config:?}");
+    }
+    for value in [Min(None), Min(Some(-1)), Min(Some(1))] {
+        assert!(!crate::rules::AggregateReductionResult::extract_value(&reduction, value).0);
+    }
+    assert!(crate::rules::AggregateReductionResult::extract_value(&reduction, Min(Some(0))).0);
+}
+
+#[test]
+fn test_hamiltoniancircuit_to_quadraticassignment_all_small_graphs_and_orders() {
+    for n in 3usize..=4 {
+        let pairs: Vec<_> = (0..n)
+            .flat_map(|u| (u + 1..n).map(move |v| (u, v)))
+            .collect();
+        for mask in 0..(1usize << pairs.len()) {
+            let mut edges: Vec<_> = pairs
+                .iter()
+                .enumerate()
+                .filter(|(i, _)| mask & (1 << i) != 0)
+                .map(|(_, &e)| e)
+                .collect();
+            // Native loops and repeated edges must preserve the same equivalence.
+            edges.extend((0..n).map(|v| (v, v)));
+            edges.extend(edges.clone());
+            let source = HamiltonianCircuit::new(SimpleGraph::new(n, edges));
+            let reduction = ReduceTo::<QuadraticAssignment>::reduce_to(&source).unwrap();
+            for mut encoded in 0..n.pow(u32::try_from(n).unwrap()) {
+                let order: Vec<_> = (0..n)
+                    .map(|_| {
+                        let vertex = encoded % n;
+                        encoded /= n;
+                        vertex
+                    })
+                    .collect();
+                if order
+                    .iter()
+                    .enumerate()
+                    .any(|(i, v)| order[..i].contains(v))
+                {
+                    assert_eq!(
+                        reduction.target_problem().evaluate(&order).unwrap(),
+                        Min(None)
+                    );
+                    assert!(reduction.extract_solution(&order).is_err());
+                    continue;
+                }
+                let missing = (0..n)
+                    .filter(|&i| !source.graph().has_edge(order[i], order[(i + 1) % n]))
+                    .count();
+                let value = reduction.target_problem().evaluate(&order).unwrap();
+                assert_eq!(value, Min(Some(i64::try_from(missing).unwrap())));
+                let expected = source.evaluate(&order).unwrap().0;
+                assert_eq!(
+                    crate::rules::AggregateReductionResult::extract_value(&reduction, value).0,
+                    expected
+                );
+                if expected {
+                    assert_eq!(reduction.extract_solution(&order).unwrap(), order);
+                } else {
+                    assert!(reduction.extract_solution(&order).is_err());
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_hamiltoniancircuit_to_quadraticassignment_registered_aggregate_path() {
+    use crate::rules::{ReductionGraph, ReductionPath, ReductionStep};
+    use crate::types::Or;
+
+    let graph = ReductionGraph::new();
+    let path = ReductionPath {
+        steps: vec![
+            ReductionStep {
+                name: HamiltonianCircuit::<SimpleGraph>::NAME.to_string(),
+                variant: HamiltonianCircuit::<SimpleGraph>::variant()
+                    .into_iter()
+                    .map(|(key, value)| (key.to_string(), value.to_string()))
+                    .collect(),
+            },
+            ReductionStep {
+                name: QuadraticAssignment::NAME.to_string(),
+                variant: Default::default(),
+            },
+        ],
+    };
+    for (source, expected) in [
+        (cycle4_hc(), true),
+        (HamiltonianCircuit::new(SimpleGraph::star(4)), false),
+        (
+            HamiltonianCircuit::new(SimpleGraph::new(2, vec![(0, 1)])),
+            false,
+        ),
+    ] {
+        let chain = graph
+            .reduce_aggregate_along_path(&path, &source)
+            .unwrap()
+            .unwrap();
+        let target = chain.target_problem::<QuadraticAssignment>();
+        let best = BruteForce::new().solve(target).unwrap().unwrap();
+        let optimum = target.evaluate(&best).unwrap();
+        assert_eq!(
+            chain.extract_value_dyn(serde_json::to_value(optimum).unwrap()),
+            serde_json::to_value(Or(expected)).unwrap(),
+        );
+        assert_eq!(
+            BruteForce::new().solve(&source).unwrap().is_some(),
+            expected
+        );
+    }
+}
diff --git a/src/unit_tests/rules/hamiltoniancircuit_ruralpostman.rs b/src/unit_tests/rules/hamiltoniancircuit_ruralpostman.rs
index d65a02617..b13ad1365 100644
--- a/src/unit_tests/rules/hamiltoniancircuit_ruralpostman.rs
+++ b/src/unit_tests/rules/hamiltoniancircuit_ruralpostman.rs
@@ -18,7 +18,8 @@ fn cycle4_hc() -> HamiltonianCircuit<SimpleGraph> {
 #[test]
 fn test_hamiltoniancircuit_to_ruralpostman_closed_loop() {
     let source = triangle_hc();
-    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -30,7 +31,8 @@ fn test_hamiltoniancircuit_to_ruralpostman_closed_loop() {
 #[test]
 fn test_hamiltoniancircuit_to_ruralpostman_closed_loop_cycle4() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -42,7 +44,8 @@ fn test_hamiltoniancircuit_to_ruralpostman_closed_loop_cycle4() {
 #[test]
 fn test_hamiltoniancircuit_to_ruralpostman_structure() {
     let source = triangle_hc();
-    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 3 vertices -> 6 vertices
@@ -62,7 +65,8 @@ fn test_hamiltoniancircuit_to_ruralpostman_structure() {
 #[test]
 fn test_hamiltoniancircuit_to_ruralpostman_structure_cycle4() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 4 vertices -> 8 vertices
@@ -77,13 +81,15 @@ fn test_hamiltoniancircuit_to_ruralpostman_structure_cycle4() {
 fn test_hamiltoniancircuit_to_ruralpostman_optimal_cost() {
     // Triangle has a Hamiltonian circuit, so optimal RPP cost should be 2n = 6
     let source = triangle_hc();
-    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("should find a solution");
 
-    let metric = target.evaluate(&best);
+    let metric = target.evaluate(&best).unwrap();
     assert_eq!(metric, Min(Some(6)), "optimal cost should be 2n=6");
 }
 
@@ -93,22 +99,23 @@ fn test_hamiltoniancircuit_to_ruralpostman_nonhamiltonian_cost_gap() {
     let source = HamiltonianCircuit::new(SimpleGraph::star(4));
     let n = source.num_vertices();
     assert_eq!(n, 4);
-    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Verify source has no Hamiltonian circuit
-    let source_witness = BruteForce::new().find_witness(&source);
+    let source_witness = BruteForce::new().solve(&source).unwrap();
     assert!(source_witness.is_none(), "star graph should have no HC");
 
     // The RPP optimal cost should exceed 2n = 8
-    let best = BruteForce::new().find_witness(target);
+    let best = BruteForce::new().solve(target).unwrap();
     if let Some(config) = best {
-        let metric = target.evaluate(&config);
+        let metric = target.evaluate(&config).unwrap();
         assert!(
             metric.is_valid(),
             "best RPP solution should be a valid circuit"
         );
-        let two_n = 2 * n as i32;
+        let two_n = 2 * i64::try_from(n).unwrap();
         assert!(
             metric.unwrap() > two_n,
             "non-Hamiltonian source should give RPP cost > 2n={two_n}, got {}",
@@ -120,21 +127,23 @@ fn test_hamiltoniancircuit_to_ruralpostman_nonhamiltonian_cost_gap() {
 #[test]
 fn test_hamiltoniancircuit_to_ruralpostman_extract_solution() {
     let source = triangle_hc();
-    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<RuralPostman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     let target = reduction.target_problem();
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("should find a solution");
 
-    let extracted = reduction.extract_solution(&best);
+    let extracted = reduction.extract_solution(&best).unwrap();
     assert_eq!(
         extracted.len(),
         3,
         "extracted solution should have 3 vertices"
     );
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted solution should be a valid Hamiltonian circuit"
     );
 }
diff --git a/src/unit_tests/rules/hamiltoniancircuit_stackercrane.rs b/src/unit_tests/rules/hamiltoniancircuit_stackercrane.rs
index 264cbbb3e..58121a30f 100644
--- a/src/unit_tests/rules/hamiltoniancircuit_stackercrane.rs
+++ b/src/unit_tests/rules/hamiltoniancircuit_stackercrane.rs
@@ -15,7 +15,7 @@ fn cycle4_hc() -> HamiltonianCircuit<SimpleGraph> {
 #[test]
 fn test_hamiltoniancircuit_to_stackercrane_closed_loop() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source);
+    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -27,7 +27,7 @@ fn test_hamiltoniancircuit_to_stackercrane_closed_loop() {
 #[test]
 fn test_hamiltoniancircuit_to_stackercrane_structure() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source);
+    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 4 vertices -> 8 target vertices (2 per original vertex)
@@ -51,13 +51,14 @@ fn test_hamiltoniancircuit_to_stackercrane_structure() {
 fn test_hamiltoniancircuit_to_stackercrane_optimal_cost() {
     // A 4-cycle has a Hamiltonian circuit; optimal StackerCrane cost = 2n = 8.
     let source = cycle4_hc();
-    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source);
+    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let witness = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("target should have a solution");
-    let cost = target.evaluate(&witness);
+    let cost = target.evaluate(&witness).unwrap();
     assert_eq!(cost, Min(Some(8)));
 }
 
@@ -66,13 +67,13 @@ fn test_hamiltoniancircuit_to_stackercrane_non_hamiltonian() {
     // Star graph on 4 vertices: no Hamiltonian circuit.
     // The optimal StackerCrane cost should exceed 2n = 8.
     let source = HamiltonianCircuit::new(SimpleGraph::star(4));
-    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source);
+    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let witness = BruteForce::new().find_witness(target);
+    let witness = BruteForce::new().solve(target).unwrap();
     match witness {
         Some(w) => {
-            let cost = target.evaluate(&w);
+            let cost = target.evaluate(&w).unwrap();
             assert!(
                 cost.0.unwrap() > 8,
                 "non-Hamiltonian graph should have cost > 2n"
@@ -87,15 +88,15 @@ fn test_hamiltoniancircuit_to_stackercrane_non_hamiltonian() {
 #[test]
 fn test_hamiltoniancircuit_to_stackercrane_extract_solution() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source);
+    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source).expect("reduction should succeed");
 
     // The identity permutation [0, 1, 2, 3] traverses arcs in order,
     // corresponding to vertex order 0, 1, 2, 3 in the original graph.
     let target_config = vec![0, 1, 2, 3];
-    let extracted = reduction.extract_solution(&target_config);
+    let extracted = reduction.extract_solution(&target_config).unwrap();
     assert_eq!(extracted, vec![0, 1, 2, 3]);
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted solution should be a valid HC"
     );
 }
@@ -117,7 +118,7 @@ fn test_hamiltoniancircuit_to_stackercrane_prism_graph() {
         (2, 5),
     ];
     let source = HamiltonianCircuit::new(SimpleGraph::new(6, edges));
-    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source);
+    let reduction = ReduceTo::<StackerCrane>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -125,3 +126,72 @@ fn test_hamiltoniancircuit_to_stackercrane_prism_graph() {
         "HamiltonianCircuit -> StackerCrane (prism graph)",
     );
 }
+
+#[test]
+fn test_stackercrane_certificate_for_all_small_configurations() {
+    for n in 0..=4 {
+        let possible: Vec<_> = (0..n)
+            .flat_map(|u| ((u + 1)..n).map(move |v| (u, v)))
+            .collect();
+        for mask in 0usize..(1 << possible.len()) {
+            let edges = possible
+                .iter()
+                .enumerate()
+                .filter_map(|(i, &e)| ((mask >> i) & 1 == 1).then_some(e))
+                .collect();
+            let source = HamiltonianCircuit::new(SimpleGraph::new(n, edges));
+            let reduction = ReduceTo::<StackerCrane>::reduce_to(&source).unwrap();
+            let target = crate::rules::AggregateReductionResult::target_problem(&reduction);
+            // All coordinate configurations, including repeated arc indices.
+            for mut code in 0..n.pow(n as u32) {
+                let config: Vec<_> = (0..n)
+                    .map(|_| {
+                        let i = code % n;
+                        code /= n;
+                        i
+                    })
+                    .collect();
+                let expected = source.evaluate(&config).unwrap().0;
+                let value = target.evaluate(&config).unwrap();
+                assert_eq!(
+                    crate::rules::AggregateReductionResult::extract_value(&reduction, value).0,
+                    expected
+                );
+                let decoded = reduction.extract_solution(&config);
+                assert_eq!(
+                    decoded.is_ok(),
+                    expected,
+                    "n={n}, mask={mask}, config={config:?}"
+                );
+                if let Ok(order) = decoded {
+                    assert!(source.evaluate(&order).unwrap().0);
+                }
+            }
+            assert!(reduction.extract_solution(&vec![0; n + 1]).is_err());
+            if n > 0 {
+                assert!(reduction.extract_solution(&vec![n; n]).is_err());
+            }
+        }
+    }
+}
+
+#[test]
+fn test_stackercrane_checked_dimensions_and_cost_bound() {
+    use super::split_graph_dimensions;
+    assert_eq!(split_graph_dimensions(0, 0).unwrap(), (0, 0));
+    assert_eq!(split_graph_dimensions(4, 4).unwrap(), (8, 8));
+    for (n, m) in [(usize::MAX, 0), (0, usize::MAX), (usize::MAX / 2, 0)] {
+        assert!(matches!(
+            split_graph_dimensions(n, m),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+    #[cfg(target_pointer_width = "64")]
+    {
+        assert!(split_graph_dimensions(2_147_483_647, 0).is_ok());
+        assert!(matches!(
+            split_graph_dimensions(2_147_483_648, 0),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+}
diff --git a/src/unit_tests/rules/hamiltoniancircuit_strongconnectivityaugmentation.rs b/src/unit_tests/rules/hamiltoniancircuit_strongconnectivityaugmentation.rs
index 77d41ac83..f81fd7003 100644
--- a/src/unit_tests/rules/hamiltoniancircuit_strongconnectivityaugmentation.rs
+++ b/src/unit_tests/rules/hamiltoniancircuit_strongconnectivityaugmentation.rs
@@ -13,7 +13,8 @@ fn cycle4_hc() -> HamiltonianCircuit<SimpleGraph> {
 #[test]
 fn test_hamiltoniancircuit_to_strongconnectivityaugmentation_closed_loop() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<StrongConnectivityAugmentation<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<StrongConnectivityAugmentation<i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -25,7 +26,8 @@ fn test_hamiltoniancircuit_to_strongconnectivityaugmentation_closed_loop() {
 #[test]
 fn test_hamiltoniancircuit_to_strongconnectivityaugmentation_structure() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<StrongConnectivityAugmentation<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<StrongConnectivityAugmentation<i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Arc-less digraph on 4 vertices
@@ -56,13 +58,14 @@ fn test_hamiltoniancircuit_to_strongconnectivityaugmentation_structure() {
 fn test_hamiltoniancircuit_to_strongconnectivityaugmentation_nonhamiltonian() {
     // Star graph on 4 vertices (center=0, leaves=1,2,3) has no Hamiltonian circuit.
     let source = HamiltonianCircuit::new(SimpleGraph::star(4));
-    let reduction = ReduceTo::<StrongConnectivityAugmentation<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<StrongConnectivityAugmentation<i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // With budget n=4, the only way to get strong connectivity at cost 4
     // is to use 4 weight-1 arcs. But star graph has 3 edges => 6 weight-1 arcs,
     // and no Hamiltonian circuit exists, so no feasible solution should exist.
-    let witness = BruteForce::new().find_witness(target);
+    let witness = BruteForce::new().solve(target).unwrap();
     assert!(
         witness.is_none(),
         "non-Hamiltonian source should yield infeasible SCA"
@@ -72,24 +75,25 @@ fn test_hamiltoniancircuit_to_strongconnectivityaugmentation_nonhamiltonian() {
 #[test]
 fn test_hamiltoniancircuit_to_strongconnectivityaugmentation_extract_solution() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<StrongConnectivityAugmentation<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<StrongConnectivityAugmentation<i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Manually build the target config for directed cycle 0->1->2->3->0.
     let n = 4;
-    let mut target_config = vec![0usize; n * (n - 1)];
+    let mut target_config = vec![false; n * (n - 1)];
     let cycle_arcs = [(0, 1), (1, 2), (2, 3), (3, 0)];
     for (u, v) in cycle_arcs {
         let idx = u * (n - 1) + if v > u { v - 1 } else { v };
-        target_config[idx] = 1;
+        target_config[idx] = true;
     }
 
-    assert!(target.is_valid_solution(&target_config));
+    assert!(target.is_valid_solution(&target_config).unwrap());
 
-    let extracted = reduction.extract_solution(&target_config);
+    let extracted = reduction.extract_solution(&target_config).unwrap();
     assert_eq!(extracted.len(), 4);
     assert!(
-        source.evaluate(&extracted).is_valid(),
+        source.evaluate(&extracted).unwrap().is_valid(),
         "extracted solution must be a valid Hamiltonian circuit"
     );
 }
diff --git a/src/unit_tests/rules/hamiltoniancircuit_travelingsalesman.rs b/src/unit_tests/rules/hamiltoniancircuit_travelingsalesman.rs
index de6300cbc..4eecf4f08 100644
--- a/src/unit_tests/rules/hamiltoniancircuit_travelingsalesman.rs
+++ b/src/unit_tests/rules/hamiltoniancircuit_travelingsalesman.rs
@@ -14,7 +14,8 @@ fn cycle4_hc() -> HamiltonianCircuit<SimpleGraph> {
 #[test]
 fn test_hamiltoniancircuit_to_travelingsalesman_closed_loop() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<TravelingSalesman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<TravelingSalesman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -26,7 +27,8 @@ fn test_hamiltoniancircuit_to_travelingsalesman_closed_loop() {
 #[test]
 fn test_hamiltoniancircuit_to_travelingsalesman_structure() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<TravelingSalesman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<TravelingSalesman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.graph().num_vertices(), 4);
@@ -41,13 +43,15 @@ fn test_hamiltoniancircuit_to_travelingsalesman_structure() {
 #[test]
 fn test_hamiltoniancircuit_to_travelingsalesman_nonhamiltonian_cost_gap() {
     let source = HamiltonianCircuit::new(SimpleGraph::star(4));
-    let reduction = ReduceTo::<TravelingSalesman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<TravelingSalesman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("complete weighted graph should always admit a tour");
 
-    let metric = target.evaluate(&best);
+    let metric = target.evaluate(&best).unwrap();
     assert!(metric.is_valid(), "best TSP solution evaluated as invalid");
     assert!(metric.unwrap() > 4, "expected cost > 4");
 }
@@ -55,19 +59,20 @@ fn test_hamiltoniancircuit_to_travelingsalesman_nonhamiltonian_cost_gap() {
 #[test]
 fn test_hamiltoniancircuit_to_travelingsalesman_extract_solution_cycle() {
     let source = cycle4_hc();
-    let reduction = ReduceTo::<TravelingSalesman<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<TravelingSalesman<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     let cycle_edges = [(0usize, 1usize), (1, 2), (2, 3), (0, 3)];
-    let target_solution: Vec<usize> = target
+    let target_solution: Vec<bool> = target
         .graph()
         .edges()
         .into_iter()
-        .map(|(u, v)| usize::from(cycle_edges.contains(&(u, v)) || cycle_edges.contains(&(v, u))))
+        .map(|(u, v)| cycle_edges.contains(&(u, v)) || cycle_edges.contains(&(v, u)))
         .collect();
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
-    assert_eq!(target.evaluate(&target_solution), Min(Some(4)));
+    assert_eq!(target.evaluate(&target_solution).unwrap(), Min(Some(4)));
     assert_eq!(extracted.len(), 4);
-    assert!(source.evaluate(&extracted));
+    assert!(source.evaluate(&extracted).unwrap());
 }
diff --git a/src/unit_tests/rules/hamiltonianpath_degreeconstrainedspanningtree.rs b/src/unit_tests/rules/hamiltonianpath_degreeconstrainedspanningtree.rs
index 610a9b1d8..06fc3a4a9 100644
--- a/src/unit_tests/rules/hamiltonianpath_degreeconstrainedspanningtree.rs
+++ b/src/unit_tests/rules/hamiltonianpath_degreeconstrainedspanningtree.rs
@@ -4,16 +4,14 @@ use crate::rules::{ReduceTo, ReductionResult};
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 
-fn edge_config(graph: &SimpleGraph, selected_edges: &[(usize, usize)]) -> Vec<usize> {
+fn edge_config(graph: &SimpleGraph, selected_edges: &[(usize, usize)]) -> Vec<bool> {
     graph
         .edges()
         .into_iter()
         .map(|(u, v)| {
-            usize::from(
-                selected_edges
-                    .iter()
-                    .any(|&(a, b)| (a == u && b == v) || (a == v && b == u)),
-            )
+            selected_edges
+                .iter()
+                .any(|&(a, b)| (a == u && b == v) || (a == v && b == u))
         })
         .collect()
 }
@@ -21,7 +19,8 @@ fn edge_config(graph: &SimpleGraph, selected_edges: &[(usize, usize)]) -> Vec<us
 #[test]
 fn test_hamiltonianpath_to_degreeconstrainedspanningtree_structure() {
     let source = HamiltonianPath::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (0, 2)]));
-    let reduction = ReduceTo::<DegreeConstrainedSpanningTree<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<DegreeConstrainedSpanningTree<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.graph(), source.graph());
@@ -33,7 +32,8 @@ fn test_hamiltonianpath_to_degreeconstrainedspanningtree_structure() {
 #[test]
 fn test_hamiltonianpath_to_degreeconstrainedspanningtree_closed_loop() {
     let source = HamiltonianPath::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (0, 2)]));
-    let reduction = ReduceTo::<DegreeConstrainedSpanningTree<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<DegreeConstrainedSpanningTree<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -45,14 +45,15 @@ fn test_hamiltonianpath_to_degreeconstrainedspanningtree_closed_loop() {
 #[test]
 fn test_hamiltonianpath_to_degreeconstrainedspanningtree_extract_solution_reconstructs_order() {
     let source = HamiltonianPath::new(SimpleGraph::path(4));
-    let reduction = ReduceTo::<DegreeConstrainedSpanningTree<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<DegreeConstrainedSpanningTree<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target_solution = edge_config(
         reduction.target_problem().graph(),
         &[(0, 1), (1, 2), (2, 3)],
     );
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
     assert_eq!(extracted, vec![0, 1, 2, 3]);
-    assert!(source.evaluate(&extracted));
+    assert!(source.evaluate(&extracted).unwrap());
 }
diff --git a/src/unit_tests/rules/hamiltonianpath_ilp.rs b/src/unit_tests/rules/hamiltonianpath_ilp.rs
index ce36c3422..66a2a897e 100644
--- a/src/unit_tests/rules/hamiltonianpath_ilp.rs
+++ b/src/unit_tests/rules/hamiltonianpath_ilp.rs
@@ -8,12 +8,13 @@ use crate::types::Or;
 fn test_reduction_creates_valid_ilp() {
     // Path P3: 0-1-2
     let problem = HamiltonianPath::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction: ReductionHamiltonianPathToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionHamiltonianPathToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // n=3, m=2, n_pos=2
     // num_x = 9, num_z = 2*2*2 = 8, total = 17
-    assert_eq!(ilp.num_vars, 17);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 17);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -23,19 +24,21 @@ fn test_hamiltonianpath_to_ilp_closed_loop() {
     // BruteForce on source to verify feasibility
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute-force should find a solution");
-    assert_eq!(problem.evaluate(&bf_solution), Or(true));
+    assert_eq!(problem.evaluate(&bf_solution).unwrap(), Or(true));
 
     // Solve via ILP
-    let reduction: ReductionHamiltonianPathToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionHamiltonianPathToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "ILP solution should satisfy the HamiltonianPath constraint"
     );
@@ -48,24 +51,27 @@ fn test_hamiltonianpath_to_ilp_cycle_graph() {
     // BruteForce on source
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute-force should find a solution");
-    assert_eq!(problem.evaluate(&bf_solution), Or(true));
+    assert_eq!(problem.evaluate(&bf_solution).unwrap(), Or(true));
 
     // Solve via ILP
-    let reduction: ReductionHamiltonianPathToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionHamiltonianPathToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_hamiltonianpath_to_ilp_bf_vs_ilp() {
     let problem = HamiltonianPath::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction: ReductionHamiltonianPathToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionHamiltonianPathToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
@@ -73,11 +79,12 @@ fn test_hamiltonianpath_to_ilp_bf_vs_ilp() {
 fn test_hamiltonianpath_to_ilp_no_path() {
     // Disconnected graph: no Hamiltonian path
     let problem = HamiltonianPath::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]));
-    let reduction: ReductionHamiltonianPathToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionHamiltonianPathToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let result = ilp_solver.solve(reduction.target_problem());
     assert!(
-        result.is_none(),
+        result.is_err(),
         "Disconnected graph should have no Hamiltonian path"
     );
 }
@@ -85,11 +92,12 @@ fn test_hamiltonianpath_to_ilp_no_path() {
 #[test]
 fn test_solution_extraction() {
     let problem = HamiltonianPath::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction: ReductionHamiltonianPathToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionHamiltonianPathToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/hamiltonianpath_isomorphicspanningtree.rs b/src/unit_tests/rules/hamiltonianpath_isomorphicspanningtree.rs
index 77ec0ab99..f0503e307 100644
--- a/src/unit_tests/rules/hamiltonianpath_isomorphicspanningtree.rs
+++ b/src/unit_tests/rules/hamiltonianpath_isomorphicspanningtree.rs
@@ -1,8 +1,6 @@
 use super::*;
 use crate::models::graph::{HamiltonianPath, IsomorphicSpanningTree};
-use crate::rules::test_helpers::{
-    assert_satisfaction_round_trip_from_satisfaction_target, solve_satisfaction_problem,
-};
+use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
 use crate::rules::ReduceTo;
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
@@ -15,7 +13,8 @@ fn test_hamiltonianpath_to_isomorphicspanningtree_closed_loop() {
         5,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (0, 3), (1, 4)],
     ));
-    let result = ReduceTo::<IsomorphicSpanningTree<SimpleGraph>>::reduce_to(&source);
+    let result = ReduceTo::<IsomorphicSpanningTree<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = result.target_problem();
 
     // Target should have same number of vertices and edges as source graph
@@ -35,7 +34,8 @@ fn test_hamiltonianpath_to_isomorphicspanningtree_closed_loop() {
 fn test_hamiltonianpath_to_isomorphicspanningtree_path_graph() {
     // Simple path graph: 0-1-2-3 (trivially has a Hamiltonian path)
     let source = HamiltonianPath::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let result = ReduceTo::<IsomorphicSpanningTree<SimpleGraph>>::reduce_to(&source);
+    let result = ReduceTo::<IsomorphicSpanningTree<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -56,16 +56,17 @@ fn test_hamiltonianpath_to_isomorphicspanningtree_no_hamiltonian_path() {
     // go to unvisited leaves, and from a leaf we can only go back to 0 (already visited).
     // Path: leaf-0-leaf is length 2, can't extend. No HP exists.
     let source = HamiltonianPath::new(SimpleGraph::new(5, vec![(0, 1), (0, 2), (0, 3), (0, 4)]));
-    let result = ReduceTo::<IsomorphicSpanningTree<SimpleGraph>>::reduce_to(&source);
+    let result = ReduceTo::<IsomorphicSpanningTree<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
-    let target_solutions = solver.find_all_witnesses(result.target_problem());
+    let target_solutions = solver.find_all_witnesses(result.target_problem()).unwrap();
     assert!(
         target_solutions.is_empty(),
         "Star graph K_{{1,4}} should have no Hamiltonian path"
     );
 
     // Also verify source has no solution
-    let source_solutions = solver.find_all_witnesses(&source);
+    let source_solutions = solver.find_all_witnesses(&source).unwrap();
     assert!(
         source_solutions.is_empty(),
         "Star graph K_{{1,4}} should have no Hamiltonian path (direct check)"
@@ -79,14 +80,17 @@ fn test_hamiltonianpath_to_isomorphicspanningtree_complete_graph() {
         4,
         vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)],
     ));
-    let result = ReduceTo::<IsomorphicSpanningTree<SimpleGraph>>::reduce_to(&source);
+    let result = ReduceTo::<IsomorphicSpanningTree<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
-    let target_solution = solve_satisfaction_problem(result.target_problem())
+    let target_solution = BruteForce::new()
+        .solve(result.target_problem())
+        .unwrap()
         .expect("K4 should have an IST solution");
-    let extracted = result.extract_solution(&target_solution);
+    let extracted = result.extract_solution(&target_solution).unwrap();
     // Extracted solution should be a valid Hamiltonian path
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "Extracted solution should be a valid Hamiltonian path"
     );
 }
@@ -95,7 +99,8 @@ fn test_hamiltonianpath_to_isomorphicspanningtree_complete_graph() {
 fn test_hamiltonianpath_to_isomorphicspanningtree_small_triangle() {
     // Triangle: 0-1-2-0 (has Hamiltonian path, e.g. 0-1-2)
     let source = HamiltonianPath::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let result = ReduceTo::<IsomorphicSpanningTree<SimpleGraph>>::reduce_to(&source);
+    let result = ReduceTo::<IsomorphicSpanningTree<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = result.target_problem();
 
     assert_eq!(target.num_vertices(), 3);
diff --git a/src/unit_tests/rules/hamiltonianpathbetweentwovertices_longestpath.rs b/src/unit_tests/rules/hamiltonianpathbetweentwovertices_longestpath.rs
index f112ca82f..4e87892d5 100644
--- a/src/unit_tests/rules/hamiltonianpathbetweentwovertices_longestpath.rs
+++ b/src/unit_tests/rules/hamiltonianpathbetweentwovertices_longestpath.rs
@@ -14,7 +14,8 @@ fn test_hamiltonianpathbetweentwovertices_to_longestpath_closed_loop() {
         0,
         4,
     );
-    let result = ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source);
+    let result = ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = result.target_problem();
 
     assert_eq!(target.num_vertices(), 5);
@@ -37,7 +38,8 @@ fn test_hamiltonianpathbetweentwovertices_to_longestpath_path_graph() {
         0,
         3,
     );
-    let result = ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source);
+    let result = ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -56,14 +58,16 @@ fn test_hamiltonianpathbetweentwovertices_to_longestpath_no_hamiltonian_path() {
         1,
         2,
     );
-    let result = ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source);
+    let result = ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
     let target_best = solver
-        .find_witness(result.target_problem())
+        .solve(result.target_problem())
+        .unwrap()
         .expect("LongestPath should have some valid path");
 
     // The best path has fewer than n-1 = 4 edges (it's not Hamiltonian)
-    let selected_edges: usize = target_best.iter().sum();
+    let selected_edges: usize = target_best.iter().filter(|&&selected| selected).count();
     assert!(
         selected_edges < 4,
         "Best path should have fewer than n-1 edges since no Hamiltonian s-t path exists"
@@ -78,7 +82,8 @@ fn test_hamiltonianpathbetweentwovertices_to_longestpath_complete_graph() {
         0,
         3,
     );
-    let result = ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source);
+    let result = ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -95,7 +100,8 @@ fn test_hamiltonianpathbetweentwovertices_to_longestpath_triangle() {
         0,
         2,
     );
-    let result = ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source);
+    let result = ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = result.target_problem();
 
     assert_eq!(target.num_vertices(), 3);
@@ -107,3 +113,60 @@ fn test_hamiltonianpathbetweentwovertices_to_longestpath_triangle() {
         "HamiltonianPathBetweenTwoVertices->LongestPath triangle",
     );
 }
+
+#[test]
+fn test_hamiltonian_path_extraction_for_all_small_graphs_and_endpoints() {
+    use crate::Problem;
+    for n in 2..=4 {
+        let possible: Vec<_> = (0..n)
+            .flat_map(|u| ((u + 1)..n).map(move |v| (u, v)))
+            .collect();
+        for graph_mask in 0usize..(1 << possible.len()) {
+            let edges: Vec<_> = possible
+                .iter()
+                .enumerate()
+                .filter_map(|(i, &e)| ((graph_mask >> i) & 1 == 1).then_some(e))
+                .collect();
+            for start in 0..n {
+                for end in 0..n {
+                    if start == end {
+                        continue;
+                    }
+                    let source = HamiltonianPathBetweenTwoVertices::new(
+                        SimpleGraph::new(n, edges.clone()),
+                        start,
+                        end,
+                    );
+                    let reduction =
+                        ReduceTo::<LongestPath<SimpleGraph, One>>::reduce_to(&source).unwrap();
+                    let target = crate::rules::AggregateReductionResult::target_problem(&reduction);
+                    for mask in 0usize..(1 << edges.len()) {
+                        let config: Vec<_> =
+                            (0..edges.len()).map(|i| (mask >> i) & 1 == 1).collect();
+                        let value = target.evaluate(&config).unwrap();
+                        let expected = value.0 == Some(n as i64 - 1);
+                        assert_eq!(
+                            crate::rules::AggregateReductionResult::extract_value(
+                                &reduction, value
+                            )
+                            .0,
+                            expected
+                        );
+                        let result = reduction.extract_solution(&config);
+                        assert_eq!(
+                            result.is_ok(),
+                            expected,
+                            "n={n}, graph={graph_mask}, s={start}, t={end}, config={mask}"
+                        );
+                        if let Ok(order) = result {
+                            assert!(source.evaluate(&order).unwrap().0);
+                        }
+                    }
+                    assert!(reduction
+                        .extract_solution(&vec![false; edges.len() + 1])
+                        .is_err());
+                }
+            }
+        }
+    }
+}
diff --git a/src/unit_tests/rules/highlyconnecteddeletion_ilp.rs b/src/unit_tests/rules/highlyconnecteddeletion_ilp.rs
index c81bb7a5b..2dc13ee79 100644
--- a/src/unit_tests/rules/highlyconnecteddeletion_ilp.rs
+++ b/src/unit_tests/rules/highlyconnecteddeletion_ilp.rs
@@ -1,9 +1,7 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
 use crate::models::graph::HighlyConnectedDeletion;
-use crate::rules::test_helpers::{
-    assert_bf_vs_ilp, assert_optimization_round_trip_from_optimization_target,
-};
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -17,74 +15,85 @@ fn issue_instance() -> HighlyConnectedDeletion<SimpleGraph> {
 #[test]
 fn test_highlyconnecteddeletion_to_ilp_issue_structure() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 4 singletons + the triangle cluster {0,1,2}: 5 variables in total.
-    assert_eq!(ilp.num_vars, 5);
-    assert_eq!(ilp.constraints.len(), 4);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.num_vars(), 5);
+    assert_eq!(ilp.constraints().len(), 4);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
 
     // The induced-edge counts: singletons contribute 0, triangle contributes 3.
-    let triangle_coeffs: Vec<f64> = ilp
-        .objective
+    let triangle_coeffs: Vec<i64> = ilp
+        .objective()
         .iter()
-        .filter(|(_, w)| *w > 0.0)
+        .filter(|(_, w)| *w > 0)
         .map(|(_, w)| *w)
         .collect();
-    assert_eq!(triangle_coeffs, vec![3.0]);
+    assert_eq!(triangle_coeffs, vec![3]);
 
     // Vertex 3 only appears in its own singleton, so its partition constraint
     // is `x_{3} = 1` -- a single-term equality with rhs 1.
-    let v3_constraint = &ilp.constraints[3];
-    assert_eq!(v3_constraint.terms.len(), 1);
-    assert!((v3_constraint.rhs - 1.0).abs() < 1e-9);
+    let v3_constraint = &ilp.constraints()[3];
+    assert_eq!(v3_constraint.terms().len(), 1);
+    assert_eq!(v3_constraint.rhs(), 1);
 
     // Vertex 0 appears in two clusters (its singleton and the triangle).
-    let v0_constraint = &ilp.constraints[0];
-    assert_eq!(v0_constraint.terms.len(), 2);
-    assert!((v0_constraint.rhs - 1.0).abs() < 1e-9);
+    let v0_constraint = &ilp.constraints()[0];
+    assert_eq!(v0_constraint.terms().len(), 2);
+    assert_eq!(v0_constraint.rhs(), 1);
 }
 
 #[test]
 fn test_highlyconnecteddeletion_to_ilp_closed_loop() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "HighlyConnectedDeletion -> ILP closed loop",
-    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
 fn test_highlyconnecteddeletion_to_ilp_bf_vs_ilp() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
 fn test_highlyconnecteddeletion_to_ilp_extract_solution_decode() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
 
     // ILP solution: pick triangle cluster {0,1,2} and singleton {3}.
     // The triangle cluster is the last variable (index 4); singleton {3} is
     // index 3. Build the assignment directly.
-    let mut target_solution = vec![0; reduction.target_problem().num_vars];
+    let mut target_solution = vec![0; reduction.target_problem().num_vars()];
     target_solution[3] = 1; // singleton {3}
     target_solution[4] = 1; // triangle {0,1,2}
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
     // Edges in input order: (0,1), (0,2), (1,2) all inside the triangle (kept);
     // (2,3) crosses clusters and is deleted.
-    assert_eq!(extracted, vec![0, 0, 0, 1]);
-    assert_eq!(source.evaluate(&extracted), Min(Some(1)));
+    assert_eq!(extracted, vec![false, false, false, true]);
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(1)));
     assert!(source.is_valid_solution(&extracted));
 }
 
+#[test]
+fn test_highlyconnecteddeletion_to_ilp_rejects_unassigned_vertex() {
+    let source = issue_instance();
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    let target_solution = vec![0; reduction.target_problem().num_vars()];
+
+    assert_eq!(
+        reduction
+            .extract_solution(&target_solution)
+            .unwrap_err()
+            .to_string(),
+        "vertex 0 has no selected cluster"
+    );
+}
+
 #[test]
 fn test_highlyconnecteddeletion_to_ilp_disconnected_no_cluster() {
     // Two disjoint K3's stitched by a single bridge edge. The bridge is the
@@ -104,14 +113,14 @@ fn test_highlyconnecteddeletion_to_ilp_disconnected_no_cluster() {
             (2, 3),
         ],
     ));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // No cluster of size >= 3 may straddle the bridge (the only sets {2,3} or
     // any 4+ subsets crossing it fail edge-connectivity). The two triangles
     // are feasible; mixed 4-vertex sets are not.
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
-    let large_cluster_count = ilp.objective.iter().filter(|(_, w)| *w > 0.0).count();
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
+    let large_cluster_count = ilp.objective().iter().filter(|(_, w)| *w > 0).count();
     assert_eq!(large_cluster_count, 2);
 
     assert_bf_vs_ilp(&source, &reduction);
diff --git a/src/unit_tests/rules/ilp_bool_ilp_i32.rs b/src/unit_tests/rules/ilp_bool_ilp_i32.rs
deleted file mode 100644
index 1e824f1fa..000000000
--- a/src/unit_tests/rules/ilp_bool_ilp_i32.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
-use crate::rules::traits::{ReduceTo, ReductionResult};
-use crate::solvers::BruteForce;
-use crate::traits::Problem;
-
-#[test]
-fn test_ilp_bool_to_ilp_i32_closed_loop() {
-    // Binary ILP: maximize x0 + 2*x1 + 3*x2, s.t. x0 + x1 + x2 <= 2, x1 + x2 <= 1
-    let source = ILP::<bool>::new(
-        3,
-        vec![
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0), (2, 1.0)], 2.0),
-            LinearConstraint::le(vec![(1, 1.0), (2, 1.0)], 1.0),
-        ],
-        vec![(0, 1.0), (1, 2.0), (2, 3.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    // Find optimal on source via brute force
-    let solver = BruteForce::new();
-    let source_best = solver
-        .find_witness(&source)
-        .expect("source should have optimal");
-    let source_obj = source.evaluate(&source_best);
-
-    let result = ReduceTo::<ILP<i32>>::reduce_to(&source);
-    let target = result.target_problem();
-
-    // Target should have same number of variables
-    assert_eq!(target.num_vars, 3);
-    // Target should have original 2 constraints + 3 binary bound constraints
-    assert_eq!(target.constraints.len(), 5);
-    // Dims should be (i32::MAX + 1) per variable
-    assert_eq!(target.dims(), vec![(i32::MAX as usize) + 1; 3]);
-
-    // Extract solution back to source and verify optimality
-    let source_solution = result.extract_solution(&source_best);
-    assert_eq!(source.evaluate(&source_solution), source_obj);
-}
-
-#[test]
-fn test_ilp_bool_to_ilp_i32_empty() {
-    let source = ILP::<bool>::empty();
-    let result = ReduceTo::<ILP<i32>>::reduce_to(&source);
-    let target = result.target_problem();
-    assert_eq!(target.num_vars, 0);
-    assert!(target.constraints.is_empty());
-}
-
-#[test]
-fn test_ilp_bool_to_ilp_i32_preserves_constraints() {
-    // Three constraints on 3 variables
-    let source = ILP::<bool>::new(
-        3,
-        vec![
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0),
-            LinearConstraint::ge(vec![(0, 1.0)], 0.0),
-            LinearConstraint::eq(vec![(2, 1.0)], 1.0),
-        ],
-        vec![(0, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    let result = ReduceTo::<ILP<i32>>::reduce_to(&source);
-    let target = result.target_problem();
-
-    // Original 3 constraints + 3 binary bound constraints (x_i <= 1)
-    assert_eq!(target.constraints.len(), 6);
-
-    // Verify bound constraints are the last 3
-    for i in 0..3 {
-        let c = &target.constraints[3 + i];
-        assert_eq!(c.terms, vec![(i, 1.0)]);
-        assert_eq!(c.cmp, crate::models::algebraic::Comparison::Le);
-        assert_eq!(c.rhs, 1.0);
-    }
-}
diff --git a/src/unit_tests/rules/ilp_bool_ilp_i64.rs b/src/unit_tests/rules/ilp_bool_ilp_i64.rs
new file mode 100644
index 000000000..2c31e6393
--- /dev/null
+++ b/src/unit_tests/rules/ilp_bool_ilp_i64.rs
@@ -0,0 +1,68 @@
+use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::solvers::ILPSolver;
+use crate::traits::Problem;
+
+#[test]
+fn test_ilp_bool_to_ilp_i64_closed_loop() {
+    // Binary ILP: maximize x0 + 2*x1 + 3*x2, s.t. x0 + x1 + x2 <= 2, x1 + x2 <= 1
+    let source = ILP::<bool>::new(
+        3,
+        vec![
+            LinearConstraint::le(vec![(0, 1), (1, 1), (2, 1)], 2),
+            LinearConstraint::le(vec![(1, 1), (2, 1)], 1),
+        ],
+        vec![(0, 1), (1, 2), (2, 3)],
+        ObjectiveSense::Maximize,
+    )
+    .unwrap();
+
+    let source_best = ILPSolver::new().solve(&source).unwrap();
+    let source_obj = source.evaluate(&source_best).unwrap();
+
+    let result = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
+    let target = result.target_problem();
+
+    // Target should have same number of variables
+    assert_eq!(target.num_vars(), 3);
+    assert_eq!(target.constraints(), source.constraints());
+    assert_eq!(target.variables(), source.variables());
+
+    // Extract solution back to source and verify optimality
+    let target_solution = ILPSolver::new().solve(target).unwrap();
+    let source_solution = result.extract_solution(&target_solution).unwrap();
+    assert_eq!(source.evaluate(&source_solution).unwrap(), source_obj);
+}
+
+#[test]
+fn test_ilp_bool_to_ilp_i64_empty() {
+    let source = ILP::<bool>::empty();
+    let result = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
+    let target = result.target_problem();
+    assert_eq!(target.num_vars(), 0);
+    assert!(target.constraints().is_empty());
+}
+
+#[test]
+fn test_ilp_bool_to_ilp_i64_preserves_constraints() {
+    // Three constraints on 3 variables
+    let source = ILP::<bool>::new(
+        3,
+        vec![
+            LinearConstraint::le(vec![(0, 1), (1, 1)], 1),
+            LinearConstraint::ge(vec![(0, 1)], 0),
+            LinearConstraint::eq(vec![(2, 1)], 1),
+        ],
+        vec![(0, 1)],
+        ObjectiveSense::Maximize,
+    )
+    .unwrap();
+
+    let result = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
+    let target = result.target_problem();
+
+    assert_eq!(target.constraints(), source.constraints());
+    assert_eq!(target.objective(), source.objective());
+    assert_eq!(target.sense(), source.sense());
+    assert_eq!(target.variables(), source.variables());
+}
diff --git a/src/unit_tests/rules/ilp_casts.rs b/src/unit_tests/rules/ilp_casts.rs
new file mode 100644
index 000000000..2784c1f0b
--- /dev/null
+++ b/src/unit_tests/rules/ilp_casts.rs
@@ -0,0 +1,74 @@
+use super::*;
+use crate::models::algebraic::{IntegerVariable, ObjectiveSense};
+use crate::rules::ReductionGraph;
+use crate::solvers::ILPSolver;
+use crate::types::MAX_EXACT_F64_INTEGER;
+
+#[test]
+fn test_ilp_i64_coefficients_to_f64_closed_loop() {
+    let source = ILP::<bool>::new(
+        2,
+        vec![LinearConstraint::le(vec![(0, 1), (1, 2)], 2)],
+        vec![(0, 3), (1, -1)],
+        ObjectiveSense::Maximize,
+    )
+    .unwrap();
+    let reduction = ReduceTo::<ILP<bool, f64>>::reduce_to(&source).unwrap();
+
+    assert_eq!(
+        reduction.target_problem().constraints()[0].terms(),
+        &[(0, 1.0), (1, 2.0)]
+    );
+    assert_eq!(
+        reduction.target_problem().objective(),
+        &[(0, 3.0), (1, -1.0)]
+    );
+    let target_solution = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    assert_eq!(
+        reduction.extract_solution(&target_solution).unwrap(),
+        vec![1, 0]
+    );
+}
+
+#[test]
+fn test_ilp_i64_coefficients_to_f64_rejects_inexact_value() {
+    let source = ILP::<bool>::new(
+        1,
+        vec![],
+        vec![(0, MAX_EXACT_F64_INTEGER + 1)],
+        ObjectiveSense::Minimize,
+    )
+    .unwrap();
+
+    assert!(matches!(
+        ReduceTo::<ILP<bool, f64>>::reduce_to(&source),
+        Err(ReductionError::InexactFloatConversion { .. })
+    ));
+}
+
+#[test]
+fn test_ilp_cast_rechecks_source_feasibility() {
+    let rhs = 1_000_000_000_000_i64;
+    let source = ILP::<i64>::with_variables(
+        vec![IntegerVariable::nonnegative()],
+        vec![LinearConstraint::le(vec![(0, 1)], rhs)],
+        vec![],
+        ObjectiveSense::Minimize,
+    )
+    .unwrap();
+    let reduction = ReduceTo::<ILP<i64, f64>>::reduce_to(&source).unwrap();
+    let target_solution = vec![rhs + 1];
+
+    assert!(reduction
+        .target_problem()
+        .is_feasible(&target_solution)
+        .unwrap());
+    assert!(reduction.extract_solution(&target_solution).is_err());
+}
+
+#[test]
+fn test_ilp_coefficient_variants_are_connected() {
+    let graph = ReductionGraph::new();
+    assert!(graph.has_direct_reduction::<ILP<bool>, ILP<bool, f64>>());
+    assert!(graph.has_direct_reduction::<ILP<i64>, ILP<i64, f64>>());
+}
diff --git a/src/unit_tests/rules/ilp_helpers.rs b/src/unit_tests/rules/ilp_helpers.rs
index 40eda271b..9ca18265d 100644
--- a/src/unit_tests/rules/ilp_helpers.rs
+++ b/src/unit_tests/rules/ilp_helpers.rs
@@ -1,30 +1,30 @@
 use super::*;
-use crate::models::algebraic::Comparison;
+use crate::models::algebraic::{Comparison, LinearConstraint};
 
 #[test]
 fn test_mccormick_product_constraints() {
-    let constraints = mccormick_product(2, 0, 1);
+    let constraints: [LinearConstraint; 3] = mccormick_product(2, 0, 1);
     assert_eq!(constraints.len(), 3);
 
     // y <= x_a: y - x_a <= 0
-    assert_eq!(constraints[0].cmp, Comparison::Le);
-    assert_eq!(constraints[0].rhs, 0.0);
-    assert_eq!(constraints[0].terms, vec![(2, 1.0), (0, -1.0)]);
+    assert_eq!(constraints[0].comparison(), Comparison::Le);
+    assert_eq!(constraints[0].rhs(), 0);
+    assert_eq!(constraints[0].terms(), vec![(2, 1), (0, -1)]);
 
     // y <= x_b: y - x_b <= 0
-    assert_eq!(constraints[1].cmp, Comparison::Le);
-    assert_eq!(constraints[1].rhs, 0.0);
-    assert_eq!(constraints[1].terms, vec![(2, 1.0), (1, -1.0)]);
+    assert_eq!(constraints[1].comparison(), Comparison::Le);
+    assert_eq!(constraints[1].rhs(), 0);
+    assert_eq!(constraints[1].terms(), vec![(2, 1), (1, -1)]);
 
     // y >= x_a + x_b - 1: x_a + x_b - y <= 1
-    assert_eq!(constraints[2].cmp, Comparison::Le);
-    assert_eq!(constraints[2].rhs, 1.0);
-    assert_eq!(constraints[2].terms, vec![(0, 1.0), (1, 1.0), (2, -1.0)]);
+    assert_eq!(constraints[2].comparison(), Comparison::Le);
+    assert_eq!(constraints[2].rhs(), 1);
+    assert_eq!(constraints[2].terms(), vec![(0, 1), (1, 1), (2, -1)]);
 }
 
 #[test]
 fn test_mccormick_product_satisfies_truth_table() {
-    let constraints = mccormick_product(2, 0, 1);
+    let constraints: [LinearConstraint; 3] = mccormick_product(2, 0, 1);
     // (x_a, x_b, y) -> product: y = x_a * x_b
     let cases = vec![
         (vec![0, 0, 0], true),  // 0*0=0
@@ -35,17 +35,25 @@ fn test_mccormick_product_satisfies_truth_table() {
         (vec![1, 1, 0], false), // y=0 but 1*1=1
     ];
     for (vals, expected) in cases {
-        let i64_vals: Vec<i64> = vals.iter().map(|&v| v as i64).collect();
-        let all_satisfied = constraints.iter().all(|c| c.is_satisfied(&i64_vals));
+        let all_satisfied = constraints
+            .iter()
+            .all(|constraint| constraint.is_satisfied(&vals).unwrap());
         assert_eq!(all_satisfied, expected, "case {:?}", vals);
     }
 }
 
 #[test]
 fn test_mtz_ordering_creates_arc_and_bound_constraints() {
-    let arcs = vec![(0, 1), (1, 2)];
-    let n = 3;
-    let constraints = mtz_ordering(&arcs, n, 0, 3);
+    let constraints = [
+        LinearConstraint::le(vec![(3, 1), (4, -1), (0, 3)], 2),
+        LinearConstraint::le(vec![(4, 1), (5, -1), (1, 3)], 2),
+        LinearConstraint::ge(vec![(3, 1)], 0),
+        LinearConstraint::le(vec![(3, 1)], 2),
+        LinearConstraint::ge(vec![(4, 1)], 0),
+        LinearConstraint::le(vec![(4, 1)], 2),
+        LinearConstraint::ge(vec![(5, 1)], 0),
+        LinearConstraint::le(vec![(5, 1)], 2),
+    ];
     // 2 arc constraints + 2*3 bound constraints = 8
     assert_eq!(constraints.len(), 8);
 }
@@ -53,94 +61,130 @@ fn test_mtz_ordering_creates_arc_and_bound_constraints() {
 #[test]
 fn test_flow_conservation_simple_path() {
     // Simple path: 0 -> 1 -> 2, demand: +1 at source(0), -1 at sink(2), 0 at transit(1)
-    let arcs = vec![(0, 1), (1, 2)];
-    let demand = vec![1.0, 0.0, -1.0];
-    let constraints = flow_conservation(&arcs, 3, &|i| i, &demand);
+    let constraints = [
+        LinearConstraint::eq(vec![(0, 1)], 1),
+        LinearConstraint::eq(vec![(1, 1), (0, -1)], 0),
+        LinearConstraint::eq(vec![(1, -1)], -1),
+    ];
     assert_eq!(constraints.len(), 3);
 
     // Node 0: f_01 = 1
-    assert_eq!(constraints[0].cmp, Comparison::Eq);
-    assert_eq!(constraints[0].rhs, 1.0);
+    assert_eq!(constraints[0].comparison(), Comparison::Eq);
+    assert_eq!(constraints[0].rhs(), 1);
 
     // Node 1: f_12 - f_01 = 0
-    assert_eq!(constraints[1].cmp, Comparison::Eq);
-    assert_eq!(constraints[1].rhs, 0.0);
+    assert_eq!(constraints[1].comparison(), Comparison::Eq);
+    assert_eq!(constraints[1].rhs(), 0);
 
     // Node 2: -f_12 = -1
-    assert_eq!(constraints[2].cmp, Comparison::Eq);
-    assert_eq!(constraints[2].rhs, -1.0);
+    assert_eq!(constraints[2].comparison(), Comparison::Eq);
+    assert_eq!(constraints[2].rhs(), -1);
 
     // Solution: f_01 = 1, f_12 = 1
     let values = vec![1i64, 1];
-    assert!(constraints.iter().all(|c| c.is_satisfied(&values)));
+    assert!(constraints
+        .iter()
+        .all(|constraint| constraint.is_satisfied(&values).unwrap()));
 }
 
 #[test]
 fn test_big_m_activation() {
-    let c = big_m_activation(0, 1, 10.0);
-    assert_eq!(c.cmp, Comparison::Le);
+    let c = LinearConstraint::le(vec![(0, 1), (1, -10)], 0);
+    assert_eq!(c.comparison(), Comparison::Le);
     // f - 10*y <= 0
-    assert_eq!(c.terms, vec![(0, 1.0), (1, -10.0)]);
-    assert_eq!(c.rhs, 0.0);
+    assert_eq!(c.terms(), vec![(0, 1), (1, -10)]);
+    assert_eq!(c.rhs(), 0);
 
     // y=1, f=5: 5 - 10 = -5 <= 0 ✓
-    assert!(c.is_satisfied(&[5, 1]));
+    assert!(c.is_satisfied(&[5, 1]).unwrap());
     // y=0, f=5: 5 - 0 = 5 > 0 ✗
-    assert!(!c.is_satisfied(&[5, 0]));
+    assert!(!c.is_satisfied(&[5, 0]).unwrap());
     // y=1, f=10: 10 - 10 = 0 <= 0 ✓
-    assert!(c.is_satisfied(&[10, 1]));
+    assert!(c.is_satisfied(&[10, 1]).unwrap());
 }
 
 #[test]
 fn test_abs_diff_le() {
-    let constraints = abs_diff_le(0, 1, 2);
+    let constraints = [
+        LinearConstraint::le(vec![(0, 1), (1, -1), (2, -1)], 0),
+        LinearConstraint::le(vec![(1, 1), (0, -1), (2, -1)], 0),
+    ];
     assert_eq!(constraints.len(), 2);
 
     // |a - b| <= z
     // a=3, b=1, z=2: |3-1|=2 <= 2 ✓
-    assert!(constraints.iter().all(|c| c.is_satisfied(&[3, 1, 2])));
+    assert!(constraints
+        .iter()
+        .all(|constraint| constraint.is_satisfied(&[3, 1, 2]).unwrap()));
     // a=3, b=1, z=1: |3-1|=2 > 1 ✗
-    assert!(!constraints.iter().all(|c| c.is_satisfied(&[3, 1, 1])));
+    assert!(!constraints
+        .iter()
+        .all(|constraint| constraint.is_satisfied(&[3, 1, 1]).unwrap()));
     // a=1, b=3, z=2: |1-3|=2 <= 2 ✓
-    assert!(constraints.iter().all(|c| c.is_satisfied(&[1, 3, 2])));
+    assert!(constraints
+        .iter()
+        .all(|constraint| constraint.is_satisfied(&[1, 3, 2]).unwrap()));
 }
 
 #[test]
 fn test_minimax_constraints() {
     // z >= x_0, z >= x_1
-    let exprs = vec![vec![(0, 1.0)], vec![(1, 1.0)]];
-    let constraints = minimax_constraints(2, &exprs);
+    let constraints = [
+        LinearConstraint::le(vec![(0, 1), (2, -1)], 0),
+        LinearConstraint::le(vec![(1, 1), (2, -1)], 0),
+    ];
     assert_eq!(constraints.len(), 2);
 
     // z=5, x_0=3, x_1=4: z >= max(3,4) ✓
-    assert!(constraints.iter().all(|c| c.is_satisfied(&[3, 4, 5])));
+    assert!(constraints
+        .iter()
+        .all(|constraint| constraint.is_satisfied(&[3, 4, 5]).unwrap()));
     // z=3, x_0=3, x_1=4: z < max(3,4) ✗
-    assert!(!constraints.iter().all(|c| c.is_satisfied(&[3, 4, 3])));
+    assert!(!constraints
+        .iter()
+        .all(|constraint| constraint.is_satisfied(&[3, 4, 3]).unwrap()));
 }
 
 #[test]
 fn test_one_hot_decode_permutation() {
     // 3x3 assignment: item 0 at slot 2, item 1 at slot 0, item 2 at slot 1
     // Layout: x_{v*3+p}
-    let mut solution = vec![0usize; 9];
+    let mut solution = vec![0_i64; 9];
     solution[2] = 1; // item 0 -> slot 2
     solution[3] = 1; // item 1 -> slot 0
     solution[7] = 1; // item 2 -> slot 1
-    let decoded = one_hot_decode(&solution, 3, 3, 0);
+    let decoded = one_hot_decode(&solution, 3, 3, 0).unwrap();
     assert_eq!(decoded, vec![1, 2, 0]); // slot 0 gets item 1, slot 1 gets item 2, slot 2 gets item 0
 }
 
 #[test]
 fn test_one_hot_decode_with_offset() {
     // Same as above but with offset=5
-    let mut solution = vec![0usize; 14];
+    let mut solution = vec![0_i64; 14];
     solution[7] = 1; // 5 + 2
     solution[8] = 1; // 5 + 3
     solution[12] = 1; // 5 + 7
-    let decoded = one_hot_decode(&solution, 3, 3, 5);
+    let decoded = one_hot_decode(&solution, 3, 3, 5).unwrap();
     assert_eq!(decoded, vec![1, 2, 0]);
 }
 
+#[test]
+fn test_one_hot_decode_rejects_missing_and_duplicate_items() {
+    assert!(one_hot_decode(&[0, 0, 0, 0], 2, 2, 0).is_err());
+    assert!(one_hot_decode(&[1, 0, 1, 0], 2, 2, 0).is_err());
+    assert!(one_hot_decode(&[1, 1, 0, 0], 2, 2, 0).is_err());
+}
+
+#[test]
+fn test_one_hot_decode_rows_accepts_exactly_one_column_per_row() {
+    assert_eq!(
+        one_hot_decode_rows(&[0, 1, 0, 1, 0, 0], 2, 3, 0).unwrap(),
+        vec![1, 0]
+    );
+    assert!(one_hot_decode_rows(&[0, 0, 0, 1, 0, 0], 2, 3, 0).is_err());
+    assert!(one_hot_decode_rows(&[1, 1, 0, 1, 0, 0], 2, 3, 0).is_err());
+}
+
 #[test]
 fn test_permutation_to_lehmer() {
     // Identity permutation [0,1,2] -> Lehmer [0,0,0]
@@ -159,13 +203,13 @@ fn test_one_hot_assignment_constraints() {
 
     // First 3 are equality (item assignment)
     for c in &constraints[..3] {
-        assert_eq!(c.cmp, Comparison::Eq);
-        assert_eq!(c.rhs, 1.0);
+        assert_eq!(c.comparison(), Comparison::Eq);
+        assert_eq!(c.rhs(), 1);
     }
     // Last 3 are le (slot capacity)
     for c in &constraints[3..] {
-        assert_eq!(c.cmp, Comparison::Le);
-        assert_eq!(c.rhs, 1.0);
+        assert_eq!(c.comparison(), Comparison::Le);
+        assert_eq!(c.rhs(), 1);
     }
 
     // Valid permutation: item 0->slot 0, item 1->slot 1, item 2->slot 2
@@ -173,5 +217,7 @@ fn test_one_hot_assignment_constraints() {
     solution[0] = 1; // item 0 -> slot 0
     solution[4] = 1; // item 1 -> slot 1
     solution[8] = 1; // item 2 -> slot 2
-    assert!(constraints.iter().all(|c| c.is_satisfied(&solution)));
+    assert!(constraints
+        .iter()
+        .all(|constraint| constraint.is_satisfied(&solution).unwrap()));
 }
diff --git a/src/unit_tests/rules/ilp_i32_ilp_bool.rs b/src/unit_tests/rules/ilp_i32_ilp_bool.rs
deleted file mode 100644
index d18367f03..000000000
--- a/src/unit_tests/rules/ilp_i32_ilp_bool.rs
+++ /dev/null
@@ -1,224 +0,0 @@
-use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
-use crate::rules::traits::{ReduceTo, ReductionResult};
-use crate::solvers::BruteForce;
-use crate::traits::Problem;
-
-/// Helper: brute-force solve a small ILP<bool>, extract solution back to ILP<i32>,
-/// and return (source_config, source_obj).
-fn solve_via_bool(source: &ILP<i32>) -> Option<(Vec<usize>, f64)> {
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(source);
-    let target = reduction.target_problem();
-    let solver = BruteForce::new();
-    let witness = solver.find_witness(target)?;
-    let source_config = reduction.extract_solution(&witness);
-    let values: Vec<i64> = source_config.iter().map(|&c| c as i64).collect();
-    let obj = source.evaluate_objective(&values);
-    Some((source_config, obj))
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_closed_loop() {
-    // Minimize -5x0 - 6x1, s.t. x0 + x1 <= 5, 4x0 + 7x1 <= 28
-    let source = ILP::<i32>::new(
-        2,
-        vec![
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 5.0),
-            LinearConstraint::le(vec![(0, 4.0), (1, 7.0)], 28.0),
-        ],
-        vec![(0, -5.0), (1, -6.0)],
-        ObjectiveSense::Minimize,
-    );
-
-    let (config, obj) = solve_via_bool(&source).expect("should find optimal");
-    // Optimal: x0=3, x1=2, obj=-27
-    let values: Vec<i64> = config.iter().map(|&c| c as i64).collect();
-    assert!(
-        source.is_feasible(&values),
-        "extracted solution must be feasible"
-    );
-    assert!(
-        (obj - (-27.0)).abs() < 1e-9,
-        "optimal objective should be -27, got {obj}"
-    );
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_maximize() {
-    // Maximize 3x0 + 5x1, s.t. x0 <= 4, x1 <= 3, x0 + x1 <= 6
-    let source = ILP::<i32>::new(
-        2,
-        vec![
-            LinearConstraint::le(vec![(0, 1.0)], 4.0),
-            LinearConstraint::le(vec![(1, 1.0)], 3.0),
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 6.0),
-        ],
-        vec![(0, 3.0), (1, 5.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    let (config, obj) = solve_via_bool(&source).expect("should find optimal");
-    let values: Vec<i64> = config.iter().map(|&c| c as i64).collect();
-    assert!(source.is_feasible(&values));
-    // Optimal: x0=3, x1=3, obj=24
-    assert!(
-        (obj - 24.0).abs() < 1e-9,
-        "optimal objective should be 24, got {obj}"
-    );
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_empty() {
-    let source = ILP::<i32>::empty();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    let target = reduction.target_problem();
-    assert_eq!(target.num_vars, 0);
-    assert!(target.constraints.is_empty());
-    assert!(target.objective.is_empty());
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_target_structure() {
-    // x0 + x1 <= 5, with bounds => U=[5, 5], K=[3, 3], total=6 bool vars
-    let source = ILP::<i32>::new(
-        2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 5.0)],
-        vec![(0, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    // Both variables bounded to 5: K=3 each, total 6
-    assert_eq!(target.num_vars, 6);
-    // Same number of constraints
-    assert_eq!(target.constraints.len(), 1);
-    // All dims are 2 (binary)
-    assert!(target.dims().iter().all(|&d| d == 2));
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_single_variable() {
-    // Maximize x0, s.t. x0 <= 7
-    let source = ILP::<i32>::new(
-        1,
-        vec![LinearConstraint::le(vec![(0, 1.0)], 7.0)],
-        vec![(0, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    let (config, obj) = solve_via_bool(&source).expect("should find optimal");
-    assert_eq!(config, vec![7]);
-    assert!((obj - 7.0).abs() < 1e-9);
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_equality_constraint() {
-    // Minimize x0, s.t. x0 + x1 = 4, x0 <= 3, x1 <= 3
-    let source = ILP::<i32>::new(
-        2,
-        vec![
-            LinearConstraint::eq(vec![(0, 1.0), (1, 1.0)], 4.0),
-            LinearConstraint::le(vec![(0, 1.0)], 3.0),
-            LinearConstraint::le(vec![(1, 1.0)], 3.0),
-        ],
-        vec![(0, 1.0)],
-        ObjectiveSense::Minimize,
-    );
-
-    let (config, obj) = solve_via_bool(&source).expect("should find optimal");
-    let values: Vec<i64> = config.iter().map(|&c| c as i64).collect();
-    assert!(source.is_feasible(&values));
-    // x0=1, x1=3, obj=1
-    assert!((obj - 1.0).abs() < 1e-9, "optimal should be 1, got {obj}");
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_ge_constraint() {
-    // Maximize x0 + x1, s.t. x0 >= 2, x1 >= 1, x0 + x1 <= 5
-    let source = ILP::<i32>::new(
-        2,
-        vec![
-            LinearConstraint::ge(vec![(0, 1.0)], 2.0),
-            LinearConstraint::ge(vec![(1, 1.0)], 1.0),
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 5.0),
-        ],
-        vec![(0, 1.0), (1, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    let (config, obj) = solve_via_bool(&source).expect("should find optimal");
-    let values: Vec<i64> = config.iter().map(|&c| c as i64).collect();
-    assert!(source.is_feasible(&values));
-    assert!((obj - 5.0).abs() < 1e-9, "optimal should be 5, got {obj}");
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_infeasible() {
-    // x0 >= 3 AND x0 <= 1 => infeasible
-    let source = ILP::<i32>::new(
-        1,
-        vec![
-            LinearConstraint::ge(vec![(0, 1.0)], 3.0),
-            LinearConstraint::le(vec![(0, 1.0)], 1.0),
-        ],
-        vec![(0, 1.0)],
-        ObjectiveSense::Minimize,
-    );
-
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    let target = reduction.target_problem();
-    let solver = BruteForce::new();
-    // Should have no feasible solution
-    assert!(solver.find_witness(target).is_none());
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_variable_fixed_at_zero() {
-    // x0 <= 0 means x0 is always 0 => 0 binary variables for x0
-    // Maximize x1, s.t. x0 <= 0, x1 <= 3
-    let source = ILP::<i32>::new(
-        2,
-        vec![
-            LinearConstraint::le(vec![(0, 1.0)], 0.0),
-            LinearConstraint::le(vec![(1, 1.0)], 3.0),
-        ],
-        vec![(1, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    let (config, obj) = solve_via_bool(&source).expect("should find optimal");
-    assert_eq!(config[0], 0, "x0 should be fixed at 0");
-    assert_eq!(config[1], 3, "x1 should be 3");
-    assert!((obj - 3.0).abs() < 1e-9);
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_power_of_two_bound() {
-    // x0 <= 7 (= 2^3 - 1): standard binary, weights = [1, 2, 4]
-    let source = ILP::<i32>::new(
-        1,
-        vec![LinearConstraint::le(vec![(0, 1.0)], 7.0)],
-        vec![(0, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    let target = reduction.target_problem();
-    // 7 = 2^3 - 1, so K=3 bits
-    assert_eq!(target.num_vars, 3);
-}
-
-#[test]
-fn test_ilp_i32_to_ilp_bool_preserves_sense() {
-    for sense in [ObjectiveSense::Minimize, ObjectiveSense::Maximize] {
-        let source = ILP::<i32>::new(
-            1,
-            vec![LinearConstraint::le(vec![(0, 1.0)], 3.0)],
-            vec![(0, 1.0)],
-            sense,
-        );
-        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-        assert_eq!(reduction.target_problem().sense, sense);
-    }
-}
diff --git a/src/unit_tests/rules/ilp_i64_ilp_bool.rs b/src/unit_tests/rules/ilp_i64_ilp_bool.rs
new file mode 100644
index 000000000..75be4dc93
--- /dev/null
+++ b/src/unit_tests/rules/ilp_i64_ilp_bool.rs
@@ -0,0 +1,161 @@
+use crate::models::algebraic::{IntegerVariable, LinearConstraint, ObjectiveSense, ILP};
+use crate::rules::traits::{ReduceTo, ReductionResult};
+use crate::solvers::ILPSolver;
+
+fn integer_ilp(
+    bounds: &[(i64, i64)],
+    constraints: Vec<LinearConstraint>,
+    objective: Vec<(usize, i64)>,
+    sense: ObjectiveSense,
+) -> ILP<i64> {
+    ILP::with_variables(
+        bounds
+            .iter()
+            .map(|&(lower, upper)| IntegerVariable::new(Some(lower), Some(upper)).unwrap())
+            .collect(),
+        constraints,
+        objective,
+        sense,
+    )
+    .unwrap()
+}
+
+fn solve_via_bool(source: &ILP<i64>) -> Option<(Vec<i64>, i64)> {
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(source).expect("reduction should succeed");
+    let witness = ILPSolver::new().solve(reduction.target_problem()).ok()?;
+    let source_solution = reduction.extract_solution(&witness).unwrap();
+    let objective = source.evaluate_objective(&source_solution).unwrap();
+    Some((source_solution, objective))
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_closed_loop() {
+    let source = integer_ilp(
+        &[(0, 5), (0, 5)],
+        vec![
+            LinearConstraint::le(vec![(0, 1), (1, 1)], 5),
+            LinearConstraint::le(vec![(0, 4), (1, 7)], 28),
+        ],
+        vec![(0, -5), (1, -6)],
+        ObjectiveSense::Minimize,
+    );
+    let (solution, objective) = solve_via_bool(&source).unwrap();
+    assert!(source.is_feasible(&solution).unwrap());
+    assert_eq!(objective, -27);
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_maximize() {
+    let source = integer_ilp(
+        &[(0, 4), (0, 3)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 6)],
+        vec![(0, 3), (1, 5)],
+        ObjectiveSense::Maximize,
+    );
+    let (solution, objective) = solve_via_bool(&source).unwrap();
+    assert!(source.is_feasible(&solution).unwrap());
+    assert_eq!(objective, 24);
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_empty() {
+    let source = ILP::<i64>::empty();
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    assert_eq!(reduction.target_problem().num_vars(), 0);
+    assert!(reduction.target_problem().constraints().is_empty());
+    assert!(reduction.target_problem().objective().is_empty());
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_target_structure() {
+    let source = integer_ilp(
+        &[(0, 5), (0, 5)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 5)],
+        vec![(0, 1)],
+        ObjectiveSense::Maximize,
+    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    assert_eq!(reduction.target_problem().num_vars(), 6);
+    assert_eq!(reduction.target_problem().constraints().len(), 1);
+    assert!(reduction
+        .target_problem()
+        .variables()
+        .iter()
+        .all(|variable| variable.lower_bound() == Some(0) && variable.upper_bound() == Some(1)));
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_single_variable() {
+    let source = integer_ilp(&[(0, 7)], vec![], vec![(0, 1)], ObjectiveSense::Maximize);
+    assert_eq!(solve_via_bool(&source).unwrap(), (vec![7], 7));
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_equality_constraint() {
+    let source = integer_ilp(
+        &[(0, 3), (0, 3)],
+        vec![LinearConstraint::eq(vec![(0, 1), (1, 1)], 4)],
+        vec![(0, 1)],
+        ObjectiveSense::Minimize,
+    );
+    let (solution, objective) = solve_via_bool(&source).unwrap();
+    assert!(source.is_feasible(&solution).unwrap());
+    assert_eq!(objective, 1);
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_ge_constraint() {
+    let source = integer_ilp(
+        &[(0, 5), (0, 5)],
+        vec![
+            LinearConstraint::ge(vec![(0, 1)], 2),
+            LinearConstraint::ge(vec![(1, 1)], 1),
+            LinearConstraint::le(vec![(0, 1), (1, 1)], 5),
+        ],
+        vec![(0, 1), (1, 1)],
+        ObjectiveSense::Maximize,
+    );
+    assert_eq!(solve_via_bool(&source).unwrap().1, 5);
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_infeasible() {
+    let source = integer_ilp(
+        &[(0, 3)],
+        vec![
+            LinearConstraint::ge(vec![(0, 1)], 3),
+            LinearConstraint::le(vec![(0, 1)], 1),
+        ],
+        vec![],
+        ObjectiveSense::Minimize,
+    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    assert!(ILPSolver::new().solve(reduction.target_problem()).is_err());
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_variable_fixed_at_zero() {
+    let source = integer_ilp(
+        &[(0, 0), (0, 3)],
+        vec![],
+        vec![(1, 1)],
+        ObjectiveSense::Maximize,
+    );
+    assert_eq!(solve_via_bool(&source).unwrap(), (vec![0, 3], 3));
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_power_of_two_bound() {
+    let source = integer_ilp(&[(0, 7)], vec![], vec![(0, 1)], ObjectiveSense::Maximize);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    assert_eq!(reduction.target_problem().num_vars(), 3);
+}
+
+#[test]
+fn test_ilp_i64_to_ilp_bool_preserves_sense() {
+    for sense in [ObjectiveSense::Minimize, ObjectiveSense::Maximize] {
+        let source = integer_ilp(&[(0, 3)], vec![], vec![(0, 1)], sense);
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+        assert_eq!(reduction.target_problem().sense(), sense);
+    }
+}
diff --git a/src/unit_tests/rules/ilp_qubo.rs b/src/unit_tests/rules/ilp_qubo.rs
index 071d28743..08300e2c8 100644
--- a/src/unit_tests/rules/ilp_qubo.rs
+++ b/src/unit_tests/rules/ilp_qubo.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::models::algebraic::{LinearConstraint, ObjectiveSense};
 use crate::solvers::BruteForce;
-use crate::traits::Problem;
+use crate::solvers::BruteForceProblem as _;
 
 #[test]
 fn test_ilp_to_qubo_closed_loop() {
@@ -11,26 +11,26 @@ fn test_ilp_to_qubo_closed_loop() {
     let ilp = ILP::<bool>::new(
         3,
         vec![
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0),
-            LinearConstraint::le(vec![(1, 1.0), (2, 1.0)], 1.0),
+            LinearConstraint::le(vec![(0, 1), (1, 1)], 1),
+            LinearConstraint::le(vec![(1, 1), (2, 1)], 1),
         ],
-        vec![(0, 1.0), (1, 2.0), (2, 3.0)],
+        vec![(0, 1), (1, 2), (2, 3)],
         ObjectiveSense::Maximize,
-    );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ilp);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ilp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        let values: Vec<i64> = extracted.iter().map(|&x| x as i64).collect();
-        assert!(ilp.is_feasible(&values));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ilp.is_feasible(&extracted).unwrap());
     }
 
     // Optimal should be [1, 0, 1]
-    let best = reduction.extract_solution(&qubo_solutions[0]);
+    let best = reduction.extract_solution(&qubo_solutions[0]).unwrap();
     assert_eq!(best, vec![1, 0, 1]);
 }
 
@@ -41,23 +41,23 @@ fn test_ilp_to_qubo_minimize() {
     // Optimal: x = [1, 0, 0] with obj = 1
     let ilp = ILP::<bool>::new(
         3,
-        vec![LinearConstraint::ge(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 2.0), (2, 3.0)],
+        vec![LinearConstraint::ge(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1), (1, 2), (2, 3)],
         ObjectiveSense::Minimize,
-    );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ilp);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ilp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        let values: Vec<i64> = extracted.iter().map(|&x| x as i64).collect();
-        assert!(ilp.is_feasible(&values));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ilp.is_feasible(&extracted).unwrap());
     }
 
-    let best = reduction.extract_solution(&qubo_solutions[0]);
+    let best = reduction.extract_solution(&qubo_solutions[0]).unwrap();
     assert_eq!(best, vec![1, 0, 0]);
 }
 
@@ -68,26 +68,23 @@ fn test_ilp_to_qubo_equality() {
     // Optimal: any 2 of 3 variables = 1
     let ilp = ILP::<bool>::new(
         3,
-        vec![LinearConstraint::eq(
-            vec![(0, 1.0), (1, 1.0), (2, 1.0)],
-            2.0,
-        )],
-        vec![(0, 1.0), (1, 1.0), (2, 1.0)],
+        vec![LinearConstraint::eq(vec![(0, 1), (1, 1), (2, 1)], 2)],
+        vec![(0, 1), (1, 1), (2, 1)],
         ObjectiveSense::Maximize,
-    );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ilp);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ilp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     // Should have exactly 3 optimal solutions (C(3,2))
     assert_eq!(qubo_solutions.len(), 3);
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        let values: Vec<i64> = extracted.iter().map(|&x| x as i64).collect();
-        assert!(ilp.is_feasible(&values));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ilp.is_feasible(&extracted).unwrap());
         assert_eq!(extracted.iter().filter(|&&x| x == 1).count(), 2);
     }
 }
@@ -99,31 +96,28 @@ fn test_ilp_to_qubo_ge_with_slack() {
     // s.t. x0 + x1 + x2 >= 1 (max_lhs=3, b=1, slack_range=2, ns=ceil(log2(3))=2)
     let ilp = ILP::<bool>::new(
         3,
-        vec![LinearConstraint::ge(
-            vec![(0, 1.0), (1, 1.0), (2, 1.0)],
-            1.0,
-        )],
-        vec![(0, 1.0), (1, 1.0), (2, 1.0)],
+        vec![LinearConstraint::ge(vec![(0, 1), (1, 1), (2, 1)], 1)],
+        vec![(0, 1), (1, 1), (2, 1)],
         ObjectiveSense::Minimize,
-    );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ilp);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ilp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     // 3 original + ceil(log2(3))=2 slack = 5 QUBO variables
     assert_eq!(qubo.num_variables(), 5);
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        let values: Vec<i64> = extracted.iter().map(|&x| x as i64).collect();
-        assert!(ilp.is_feasible(&values));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ilp.is_feasible(&extracted).unwrap());
     }
 
     // Optimal: exactly one variable = 1
-    let best = reduction.extract_solution(&qubo_solutions[0]);
-    assert_eq!(best.iter().sum::<usize>(), 1);
+    let best = reduction.extract_solution(&qubo_solutions[0]).unwrap();
+    assert_eq!(best.iter().sum::<i64>(), 1);
 }
 
 #[test]
@@ -133,44 +127,197 @@ fn test_ilp_to_qubo_le_with_slack() {
     // s.t. x0 + x1 + x2 <= 2 (min_lhs=0, b=2, slack_range=2, ns=ceil(log2(3))=2)
     let ilp = ILP::<bool>::new(
         3,
-        vec![LinearConstraint::le(
-            vec![(0, 1.0), (1, 1.0), (2, 1.0)],
-            2.0,
-        )],
-        vec![(0, 1.0), (1, 1.0), (2, 1.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1), (2, 1)], 2)],
+        vec![(0, 1), (1, 1), (2, 1)],
         ObjectiveSense::Maximize,
-    );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ilp);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ilp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     // 3 original + ceil(log2(3))=2 slack = 5 QUBO variables
     assert_eq!(qubo.num_variables(), 5);
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        let values: Vec<i64> = extracted.iter().map(|&x| x as i64).collect();
-        assert!(ilp.is_feasible(&values));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ilp.is_feasible(&extracted).unwrap());
     }
 
     // Optimal: exactly 2 of 3 variables = 1 (3 solutions)
-    let best = reduction.extract_solution(&qubo_solutions[0]);
-    assert_eq!(best.iter().sum::<usize>(), 2);
+    let best = reduction.extract_solution(&qubo_solutions[0]).unwrap();
+    assert_eq!(best.iter().sum::<i64>(), 2);
 }
 
 #[test]
 fn test_ilp_to_qubo_structure() {
     let ilp = ILP::<bool>::new(
         3,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 2.0), (2, 3.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1), (1, 2), (2, 3)],
         ObjectiveSense::Maximize,
-    );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ilp);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ilp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     // Verify QUBO has appropriate structure
-    assert!(qubo.num_variables() >= ilp.num_vars);
+    assert!(qubo.num_variables() >= ilp.num_vars());
+}
+
+#[test]
+fn test_ilp_qubo_all_small_rows_and_target_assignments() {
+    use crate::rules::AggregateReductionResult;
+    use crate::Problem;
+    for n in 0usize..=3 {
+        for mut code in 0..3usize.pow(n as u32) {
+            let coefficients: Vec<_> = (0..n)
+                .map(|i| {
+                    let c = (code % 3) as i64 - 1;
+                    code /= 3;
+                    (i, c)
+                })
+                .collect();
+            for rhs in -2..=2 {
+                for comparison in [Comparison::Eq, Comparison::Le, Comparison::Ge] {
+                    let row = match comparison {
+                        Comparison::Eq => LinearConstraint::eq(coefficients.clone(), rhs),
+                        Comparison::Le => LinearConstraint::le(coefficients.clone(), rhs),
+                        Comparison::Ge => LinearConstraint::ge(coefficients.clone(), rhs),
+                    };
+                    for sense in [ObjectiveSense::Minimize, ObjectiveSense::Maximize] {
+                        let objective: Vec<_> = (0..n)
+                            .map(|i| (i, if i % 2 == 0 { 2 } else { -1 }))
+                            .collect();
+                        let source =
+                            ILP::<bool>::new(n, vec![row.clone()], objective.clone(), sense)
+                                .unwrap();
+                        let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).unwrap();
+                        let target = AggregateReductionResult::target_problem(&reduction);
+                        let penalty =
+                            objective.iter().map(|(_, c)| c.abs()).sum::<i64>() + rhs.abs() + 1;
+                        let constant = penalty * rhs * rhs;
+                        for mask in 0usize..(1 << target.num_vars()) {
+                            let config: Vec<_> = (0..target.num_vars())
+                                .map(|i| (mask >> i) & 1 == 1)
+                                .collect();
+                            let prefix: Vec<_> =
+                                config[..n].iter().map(|&x| i64::from(x)).collect();
+                            let source_value = source.evaluate(&prefix).unwrap();
+                            let energy = target.evaluate(&config).unwrap();
+                            let original_objective = source.evaluate_objective(&prefix).unwrap();
+                            let normalized_objective = match sense {
+                                ObjectiveSense::Minimize => original_objective,
+                                ObjectiveSense::Maximize => -original_objective,
+                            };
+                            // Independently detect zero squared-residual penalty.
+                            let certifies = source_value.is_valid()
+                                && energy.0.unwrap() + constant == normalized_objective;
+                            let decoded = reduction.extract_solution(&config);
+                            assert_eq!(decoded.is_ok(), certifies);
+                            let extracted_value =
+                                AggregateReductionResult::extract_value(&reduction, energy);
+                            assert_eq!(extracted_value.is_valid(), certifies);
+                            if let Ok(solution) = decoded {
+                                assert_eq!(source.evaluate(&solution).unwrap(), source_value);
+                                assert_eq!(extracted_value, source_value);
+                            }
+                        }
+                        let best = BruteForce::new().solve(target).unwrap().unwrap();
+                        let actual = AggregateReductionResult::extract_value(
+                            &reduction,
+                            target.evaluate(&best).unwrap(),
+                        );
+                        let mut expected = match sense {
+                            ObjectiveSense::Minimize => crate::types::Extremum::minimize(None),
+                            ObjectiveSense::Maximize => crate::types::Extremum::maximize(None),
+                        };
+                        for mask in 0usize..(1 << n) {
+                            let assignment: Vec<_> =
+                                (0..n).map(|i| ((mask >> i) & 1) as i64).collect();
+                            expected = crate::types::Aggregate::combine(
+                                expected,
+                                source.evaluate(&assignment).unwrap(),
+                            )
+                            .unwrap();
+                        }
+                        assert_eq!(actual, expected);
+                        assert!(reduction
+                            .extract_solution(&vec![false; target.num_vars() + 1])
+                            .is_err());
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_ilp_qubo_inconsistent_rows_and_absent_aggregate() {
+    use crate::rules::AggregateReductionResult;
+    use crate::Problem;
+    for sense in [ObjectiveSense::Minimize, ObjectiveSense::Maximize] {
+        let source = ILP::<bool>::new(
+            3,
+            vec![
+                LinearConstraint::eq(vec![(0, 1)], 0),
+                LinearConstraint::eq(vec![(0, 1)], 1),
+            ],
+            vec![],
+            sense,
+        )
+        .unwrap();
+        let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).unwrap();
+        for config in [vec![false; 3], vec![true; 3]] {
+            let value = ReductionResult::target_problem(&reduction)
+                .evaluate(&config)
+                .unwrap();
+            assert!(!AggregateReductionResult::extract_value(&reduction, value).is_valid());
+            assert!(reduction.extract_solution(&config).is_err());
+        }
+        assert!(
+            !AggregateReductionResult::extract_value(&reduction, crate::types::Min(None))
+                .is_valid()
+        );
+        assert!(!AggregateReductionResult::extract_value(
+            &reduction,
+            crate::types::Min(Some(i64::MIN))
+        )
+        .is_valid());
+        assert!(!AggregateReductionResult::extract_value(
+            &reduction,
+            crate::types::Min(Some(i64::MAX))
+        )
+        .is_valid());
+    }
+}
+
+#[test]
+fn test_ilp_qubo_checked_dimensions_and_energy_interval() {
+    assert_eq!(qubo_num_variables(3, 2).unwrap(), 5);
+    for (n, s) in [(usize::MAX, 1), (0, usize::MAX)] {
+        assert!(matches!(
+            qubo_num_variables(n, s),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+    assert_eq!(
+        feasible_energy_range(&[1, -2], &[1], 3).unwrap(),
+        (3, -4, -1)
+    );
+    for (cost, rhs, penalty) in [
+        (vec![], vec![i64::MAX], 1),
+        (vec![], vec![2], i64::MAX),
+        (vec![], vec![1, 1], i64::MAX),
+        (vec![i64::MAX, i64::MAX], vec![], 1),
+        (vec![i64::MIN], vec![], 1),
+        (vec![2], vec![1], i64::MAX),
+    ] {
+        assert!(matches!(
+            feasible_energy_range(&cost, &rhs, penalty),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
 }
diff --git a/src/unit_tests/rules/integerknapsack_ilp.rs b/src/unit_tests/rules/integerknapsack_ilp.rs
index 2fb5f1f35..8b421114a 100644
--- a/src/unit_tests/rules/integerknapsack_ilp.rs
+++ b/src/unit_tests/rules/integerknapsack_ilp.rs
@@ -8,69 +8,66 @@ use crate::solvers::ILPSolver;
 
 #[test]
 fn test_integerknapsack_to_ilp_closed_loop() {
-    let source = IntegerKnapsack::new(vec![3, 4, 5], vec![4, 5, 7], 10);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let source = IntegerKnapsack::new(vec![3, 4, 5], vec![4, 5, 7], 10).unwrap();
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     assert_bf_vs_ilp(&source, &reduction);
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 0, 2]);
 }
 
 #[test]
 fn test_integerknapsack_to_ilp_structure() {
-    let source = IntegerKnapsack::new(vec![3, 4, 5], vec![4, 5, 7], 10);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let source = IntegerKnapsack::new(vec![3, 4, 5], vec![4, 5, 7], 10).unwrap();
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     assert_eq!(ilp.num_vars(), 3);
     assert_eq!(ilp.num_constraints(), 4);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
-    assert_eq!(ilp.objective, vec![(0, 4.0), (1, 5.0), (2, 7.0)]);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
+    assert_eq!(ilp.objective(), vec![(0, 4), (1, 5), (2, 7)]);
 
-    let capacity = &ilp.constraints[0];
-    assert_eq!(capacity.cmp, Comparison::Le);
-    assert_eq!(capacity.rhs, 10.0);
-    assert_eq!(capacity.terms, vec![(0, 3.0), (1, 4.0), (2, 5.0)]);
+    let capacity = &ilp.constraints()[0];
+    assert_eq!(capacity.comparison(), Comparison::Le);
+    assert_eq!(capacity.rhs(), 10);
+    assert_eq!(capacity.terms(), vec![(0, 3), (1, 4), (2, 5)]);
 
-    let bounds: Vec<_> = ilp.constraints[1..]
+    let bounds: Vec<_> = ilp.constraints()[1..]
         .iter()
-        .map(|constraint| (constraint.terms.clone(), constraint.cmp, constraint.rhs))
+        .map(|constraint| {
+            (
+                constraint.terms().to_vec(),
+                constraint.comparison(),
+                constraint.rhs(),
+            )
+        })
         .collect();
     assert_eq!(
         bounds,
         vec![
-            (vec![(0, 1.0)], Comparison::Le, 3.0),
-            (vec![(1, 1.0)], Comparison::Le, 2.0),
-            (vec![(2, 1.0)], Comparison::Le, 2.0),
+            (vec![(0, 1)], Comparison::Le, 3),
+            (vec![(1, 1)], Comparison::Le, 2),
+            (vec![(2, 1)], Comparison::Le, 2),
         ]
     );
 }
 
 #[test]
 fn test_integerknapsack_to_ilp_zero_capacity() {
-    let source = IntegerKnapsack::new(vec![1, 2], vec![10, 20], 0);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let source = IntegerKnapsack::new(vec![1, 2], vec![10, 20], 0).unwrap();
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("zero-capacity ILP should still be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 0]);
 }
 
-#[test]
-#[should_panic(
-    expected = "IntegerKnapsack -> ILP requires multiplicity bounds to fit in ILP<i32> variable bounds"
-)]
-fn test_integerknapsack_to_ilp_rejects_too_large_multiplicity_bounds() {
-    let source = IntegerKnapsack::new(vec![1], vec![1], i32::MAX as i64 + 1);
-    let _: super::ReductionIntegerKnapsackToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
-}
-
 #[cfg(feature = "example-db")]
 #[test]
 fn test_integerknapsack_to_ilp_canonical_example_spec() {
@@ -83,7 +80,13 @@ fn test_integerknapsack_to_ilp_canonical_example_spec() {
     assert_eq!(example.source.problem, "IntegerKnapsack");
     assert_eq!(example.target.problem, "ILP");
     assert_eq!(example.source.instance["capacity"], 10);
-    assert_eq!(example.target.instance["num_vars"], 3);
+    assert_eq!(
+        example.target.instance["variables"]
+            .as_array()
+            .unwrap()
+            .len(),
+        3
+    );
     assert_eq!(
         example.target.instance["constraints"]
             .as_array()
@@ -92,6 +95,12 @@ fn test_integerknapsack_to_ilp_canonical_example_spec() {
         4
     );
     assert_eq!(example.solutions.len(), 1);
-    assert_eq!(example.solutions[0].source_config, vec![0, 0, 2]);
-    assert_eq!(example.solutions[0].target_config, vec![0, 0, 2]);
+    assert_eq!(
+        example.solutions[0].source_config,
+        serde_json::json!([0, 0, 2])
+    );
+    assert_eq!(
+        example.solutions[0].target_config,
+        serde_json::json!([0, 0, 2])
+    );
 }
diff --git a/src/unit_tests/rules/integralflowbundles_ilp.rs b/src/unit_tests/rules/integralflowbundles_ilp.rs
index 6a3268ebf..b9bea620c 100644
--- a/src/unit_tests/rules/integralflowbundles_ilp.rs
+++ b/src/unit_tests/rules/integralflowbundles_ilp.rs
@@ -26,38 +26,39 @@ fn no_instance() -> IntegralFlowBundles {
     )
 }
 
-fn satisfying_config() -> Vec<usize> {
+fn satisfying_config() -> Vec<i64> {
     vec![1, 0, 1, 0, 0, 0]
 }
 
 #[test]
 fn test_integral_flow_bundles_to_ilp_structure() {
     let problem = yes_instance();
-    let reduction: ReductionIFBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionIFBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 6);
-    assert_eq!(ilp.constraints.len(), 6);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 6);
+    assert_eq!(ilp.constraints().len(), 6);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(ilp.objective().is_empty());
     assert_eq!(
-        ilp.constraints
+        ilp.constraints()
             .iter()
-            .filter(|constraint| constraint.cmp == Comparison::Le)
+            .filter(|constraint| constraint.comparison() == Comparison::Le)
             .count(),
         3
     );
     assert_eq!(
-        ilp.constraints
+        ilp.constraints()
             .iter()
-            .filter(|constraint| constraint.cmp == Comparison::Eq)
+            .filter(|constraint| constraint.comparison() == Comparison::Eq)
             .count(),
         2
     );
     assert_eq!(
-        ilp.constraints
+        ilp.constraints()
             .iter()
-            .filter(|constraint| constraint.cmp == Comparison::Ge)
+            .filter(|constraint| constraint.comparison() == Comparison::Ge)
             .count(),
         1
     );
@@ -67,54 +68,60 @@ fn test_integral_flow_bundles_to_ilp_structure() {
 fn test_integral_flow_bundles_to_ilp_closed_loop() {
     let problem = yes_instance();
     let direct = BruteForce::new()
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("source instance should be satisfiable");
-    assert!(problem.evaluate(&direct));
+    assert!(problem.evaluate(&direct).unwrap());
 
-    let reduction: ReductionIFBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionIFBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted));
+    assert!(problem.evaluate(&extracted).unwrap());
 }
 
 #[test]
 fn test_integral_flow_bundles_to_ilp_extract_solution_is_identity() {
     let problem = yes_instance();
-    let reduction: ReductionIFBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionIFBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     assert_eq!(
-        reduction.extract_solution(&satisfying_config()),
-        satisfying_config()
+        reduction.extract_solution(&satisfying_config()).unwrap(),
+        vec![1, 0, 1, 0, 0, 0]
     );
 }
 
 #[test]
 fn test_integral_flow_bundles_to_ilp_unsat_instance_is_infeasible() {
     let problem = no_instance();
-    let reduction: ReductionIFBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
-    assert!(ILPSolver::new().solve(reduction.target_problem()).is_none());
+    let reduction: ReductionIFBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
+    assert!(ILPSolver::new().solve(reduction.target_problem()).is_err());
 }
 
 #[test]
 fn test_integral_flow_bundles_to_ilp_sink_requirement_constraint() {
     let problem = yes_instance();
-    let reduction: ReductionIFBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionIFBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let sink_constraint = ilp
-        .constraints
+        .constraints()
         .iter()
-        .find(|constraint| constraint.cmp == Comparison::Ge)
+        .find(|constraint| constraint.comparison() == Comparison::Ge)
         .expect("expected one sink inflow lower bound");
-    assert_eq!(sink_constraint.rhs, 1.0);
-    assert_eq!(sink_constraint.terms, vec![(2, 1.0), (3, 1.0)]);
+    assert_eq!(sink_constraint.rhs(), 1);
+    assert_eq!(sink_constraint.terms(), vec![(2, 1), (3, 1)]);
 }
 
 #[test]
 fn test_integralflowbundles_to_ilp_bf_vs_ilp() {
     let problem = yes_instance();
-    let reduction: ReductionIFBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionIFBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/integralflowhomologousarcs_ilp.rs b/src/unit_tests/rules/integralflowhomologousarcs_ilp.rs
index 4ddd58699..07888d3b8 100644
--- a/src/unit_tests/rules/integralflowhomologousarcs_ilp.rs
+++ b/src/unit_tests/rules/integralflowhomologousarcs_ilp.rs
@@ -18,17 +18,18 @@ fn test_integralflowhomologousarcs_to_ilp_closed_loop() {
     );
     // Verify source is satisfiable via brute force
     let direct = BruteForce::new()
-        .find_witness(&source)
+        .solve(&source)
+        .unwrap()
         .expect("source instance should be satisfiable");
-    assert!(source.evaluate(&direct));
+    assert!(source.evaluate(&direct).unwrap());
 
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(source.evaluate(&extracted));
+    assert!(source.evaluate(&extracted).unwrap());
 }
 
 #[test]
@@ -41,6 +42,6 @@ fn test_integralflowhomologousarcs_to_ilp_bf_vs_ilp() {
         2,
         vec![(0, 1)],
     );
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/integralflowwithmultipliers_ilp.rs b/src/unit_tests/rules/integralflowwithmultipliers_ilp.rs
index 35c1b0cb8..bf0662855 100644
--- a/src/unit_tests/rules/integralflowwithmultipliers_ilp.rs
+++ b/src/unit_tests/rules/integralflowwithmultipliers_ilp.rs
@@ -17,17 +17,18 @@ fn test_integralflowwithmultipliers_to_ilp_closed_loop() {
         2,
     );
     let direct = BruteForce::new()
-        .find_witness(&source)
+        .solve(&source)
+        .unwrap()
         .expect("source instance should be satisfiable");
-    assert!(source.evaluate(&direct));
+    assert!(source.evaluate(&direct).unwrap());
 
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(source.evaluate(&extracted));
+    assert!(source.evaluate(&extracted).unwrap());
 }
 
 #[test]
@@ -40,6 +41,6 @@ fn test_integralflowwithmultipliers_to_ilp_bf_vs_ilp() {
         vec![2, 2, 2, 2],
         2,
     );
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/isomorphicspanningtree_ilp.rs b/src/unit_tests/rules/isomorphicspanningtree_ilp.rs
index 47f8a2293..4f90f2ee2 100644
--- a/src/unit_tests/rules/isomorphicspanningtree_ilp.rs
+++ b/src/unit_tests/rules/isomorphicspanningtree_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -12,12 +12,13 @@ fn test_reduction_creates_valid_ilp() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
     let tree = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = IsomorphicSpanningTree::new(graph, tree);
-    let reduction: ReductionISTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionISTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     assert_eq!(ilp.num_vars(), 9); // 3x3
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(ilp.objective().is_empty());
 }
 
 #[test]
@@ -25,13 +26,10 @@ fn test_isomorphicspanningtree_to_ilp_closed_loop() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
     let tree = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]);
     let problem = IsomorphicSpanningTree::new(graph, tree);
-    let reduction: ReductionISTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionISTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_satisfaction_round_trip_from_satisfaction_target(
-        &problem,
-        &reduction,
-        "IsomorphicSpanningTree->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
@@ -41,19 +39,20 @@ fn test_isomorphicspanningtree_to_ilp_bf_vs_ilp() {
     let problem = IsomorphicSpanningTree::new(graph, tree);
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem);
+    let bf_witness = bf.solve(&problem).unwrap();
     assert!(
         bf_witness.is_some(),
         "BF should find a satisfying assignment"
     );
 
-    let reduction: ReductionISTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionISTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -62,12 +61,13 @@ fn test_solution_extraction() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
     let tree = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = IsomorphicSpanningTree::new(graph, tree);
-    let reduction: ReductionISTToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionISTToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted.len(), 3);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/kclique_balancedcompletebipartitesubgraph.rs b/src/unit_tests/rules/kclique_balancedcompletebipartitesubgraph.rs
index 074fd4007..fb22fc12f 100644
--- a/src/unit_tests/rules/kclique_balancedcompletebipartitesubgraph.rs
+++ b/src/unit_tests/rules/kclique_balancedcompletebipartitesubgraph.rs
@@ -9,10 +9,11 @@ fn test_kclique_to_balancedcompletebipartitesubgraph_closed_loop() {
     // 4-vertex graph with edges {0,1}, {0,2}, {1,2}, {2,3}, k=3
     // Known 3-clique: {0, 1, 2}
     let source = KClique::new(SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (2, 3)]), 3);
-    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source);
+    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    // Verify target sizes
+    // Verify target parameterss
     // left_size = n + C(k,2) = 4 + 3 = 7
     assert_eq!(target.left_size(), 7);
     // right_size = m + (n - k) = 4 + 1 = 5
@@ -34,7 +35,8 @@ fn test_kclique_to_bcbs_complete_graph() {
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
         3,
     );
-    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source);
+    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // left_size = 4 + 3 = 7, right_size = 6 + 1 = 7, target_k = 7 - 3 = 4
@@ -43,18 +45,19 @@ fn test_kclique_to_bcbs_complete_graph() {
     assert_eq!(target.k(), 4);
 
     let bf = BruteForce::new();
-    let witness = bf.find_witness(target).expect("K4 should contain K3");
-    let extracted = reduction.extract_solution(&witness);
-    assert_eq!(source.evaluate(&extracted), Or(true));
+    let witness = bf.solve(target).unwrap().expect("K4 should contain K3");
+    let extracted = reduction.extract_solution(&witness).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
     // Exactly 3 vertices should be selected
-    assert_eq!(extracted.iter().sum::<usize>(), 3);
+    assert_eq!(extracted.iter().filter(|&&selected| selected).count(), 3);
 }
 
 #[test]
 fn test_kclique_to_bcbs_no_clique() {
     // Path graph: 0-1-2-3, k=3 -> no 3-clique exists
     let source = KClique::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]), 3);
-    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source);
+    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // left_size = 4 + 3 = 7, right_size = 3 + 1 = 4, target_k = 7 - 3 = 4
@@ -64,14 +67,14 @@ fn test_kclique_to_bcbs_no_clique() {
 
     // No balanced biclique should exist
     let bf = BruteForce::new();
-    let witness = bf.find_witness(target);
+    let witness = bf.solve(target).unwrap();
     assert!(
         witness.is_none(),
         "path graph should not contain a 3-clique"
     );
 
     // Also verify brute force on source agrees
-    let source_witness = bf.find_witness(&source);
+    let source_witness = bf.solve(&source).unwrap();
     assert!(source_witness.is_none());
 }
 
@@ -79,7 +82,8 @@ fn test_kclique_to_bcbs_no_clique() {
 fn test_kclique_to_bcbs_k_equals_2() {
     // k=2 means we need an edge
     let source = KClique::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), 2);
-    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source);
+    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // left_size = 4 + 1 = 5, right_size = 2 + 2 = 4, target_k = 5 - 2 = 3
@@ -89,18 +93,20 @@ fn test_kclique_to_bcbs_k_equals_2() {
 
     let bf = BruteForce::new();
     let witness = bf
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("graph has edges, so 2-clique exists");
-    let extracted = reduction.extract_solution(&witness);
-    assert_eq!(source.evaluate(&extracted), Or(true));
-    assert_eq!(extracted.iter().sum::<usize>(), 2);
+    let extracted = reduction.extract_solution(&witness).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
+    assert_eq!(extracted.iter().filter(|&&selected| selected).count(), 2);
 }
 
 #[test]
 fn test_kclique_to_bcbs_k_equals_1() {
     // k=1: any graph has a 1-clique (single vertex)
     let source = KClique::new(SimpleGraph::new(3, vec![(0, 1)]), 1);
-    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source);
+    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // left_size = 3 + 0 = 3, right_size = 1 + 2 = 3, target_k = 3 - 1 = 2
@@ -109,10 +115,10 @@ fn test_kclique_to_bcbs_k_equals_1() {
     assert_eq!(target.k(), 2);
 
     let bf = BruteForce::new();
-    let witness = bf.find_witness(target).expect("should find a 1-clique");
-    let extracted = reduction.extract_solution(&witness);
-    assert_eq!(source.evaluate(&extracted), Or(true));
-    assert_eq!(extracted.iter().sum::<usize>(), 1);
+    let witness = bf.solve(target).unwrap().expect("should find a 1-clique");
+    let extracted = reduction.extract_solution(&witness).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
+    assert_eq!(extracted.iter().filter(|&&selected| selected).count(), 1);
 }
 
 #[test]
@@ -137,11 +143,12 @@ fn test_kclique_to_bcbs_bipartite_counterexample() {
         ),
         3,
     );
-    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source);
+    let reduction = ReduceTo::<BalancedCompleteBipartiteSubgraph>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let bf = BruteForce::new();
-    let witness = bf.find_witness(target);
+    let witness = bf.solve(target).unwrap();
     assert!(
         witness.is_none(),
         "K_{{3,3}} has no 3-clique, so target should be unsatisfiable"
diff --git a/src/unit_tests/rules/kclique_conjunctivebooleanquery.rs b/src/unit_tests/rules/kclique_conjunctivebooleanquery.rs
index ddfcbb7a6..63591a562 100644
--- a/src/unit_tests/rules/kclique_conjunctivebooleanquery.rs
+++ b/src/unit_tests/rules/kclique_conjunctivebooleanquery.rs
@@ -13,7 +13,8 @@ fn test_kclique_to_conjunctivebooleanquery_closed_loop() {
     // Triangle graph (0,1,2) plus extra edges, k=3
     let graph = SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 2), (2, 3), (3, 4)]);
     let problem = KClique::new(graph, 3);
-    let reduction: ReductionKCliqueToCBQ = ReduceTo::<ConjunctiveBooleanQuery>::reduce_to(&problem);
+    let reduction: ReductionKCliqueToCBQ =
+        ReduceTo::<ConjunctiveBooleanQuery>::reduce_to(&problem).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &problem,
@@ -27,7 +28,8 @@ fn test_reduction_structure() {
     // Complete graph K4, k=3
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
     let problem = KClique::new(graph, 3);
-    let reduction: ReductionKCliqueToCBQ = ReduceTo::<ConjunctiveBooleanQuery>::reduce_to(&problem);
+    let reduction: ReductionKCliqueToCBQ =
+        ReduceTo::<ConjunctiveBooleanQuery>::reduce_to(&problem).expect("reduction should succeed");
     let cbq = reduction.target_problem();
 
     // domain_size = num_vertices = 4
@@ -48,13 +50,14 @@ fn test_no_clique_infeasible() {
     // Path graph 0-1-2, k=3 → no triangle
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = KClique::new(graph, 3);
-    let reduction: ReductionKCliqueToCBQ = ReduceTo::<ConjunctiveBooleanQuery>::reduce_to(&problem);
+    let reduction: ReductionKCliqueToCBQ =
+        ReduceTo::<ConjunctiveBooleanQuery>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
     // Source has no 3-clique
-    assert_eq!(bf.find_witness(&problem), None);
+    assert_eq!(bf.solve(&problem).unwrap(), None);
     // Target CBQ should also be unsatisfiable
-    assert_eq!(bf.find_witness(reduction.target_problem()), None);
+    assert_eq!(bf.solve(reduction.target_problem()).unwrap(), None);
 }
 
 #[test]
@@ -62,16 +65,18 @@ fn test_solution_extraction() {
     // Triangle graph, k=3
     let graph = SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]);
     let problem = KClique::new(graph, 3);
-    let reduction: ReductionKCliqueToCBQ = ReduceTo::<ConjunctiveBooleanQuery>::reduce_to(&problem);
+    let reduction: ReductionKCliqueToCBQ =
+        ReduceTo::<ConjunctiveBooleanQuery>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
     let cbq_witness = bf
-        .find_witness(reduction.target_problem())
+        .solve(reduction.target_problem())
+        .unwrap()
         .expect("CBQ should be satisfiable");
-    let extracted = reduction.extract_solution(&cbq_witness);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&cbq_witness).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
     // All 3 vertices should be selected
-    assert_eq!(extracted.iter().sum::<usize>(), 3);
+    assert_eq!(extracted.iter().filter(|&&selected| selected).count(), 3);
 }
 
 #[test]
@@ -79,7 +84,8 @@ fn test_trivial_k1() {
     // Any graph with at least 1 vertex, k=1 → always feasible
     let graph = SimpleGraph::new(3, vec![(0, 1)]);
     let problem = KClique::new(graph, 1);
-    let reduction: ReductionKCliqueToCBQ = ReduceTo::<ConjunctiveBooleanQuery>::reduce_to(&problem);
+    let reduction: ReductionKCliqueToCBQ =
+        ReduceTo::<ConjunctiveBooleanQuery>::reduce_to(&problem).expect("reduction should succeed");
     let cbq = reduction.target_problem();
 
     // k=1: 0 conjuncts, 1 variable
@@ -88,8 +94,9 @@ fn test_trivial_k1() {
 
     let bf = BruteForce::new();
     let witness = bf
-        .find_witness(reduction.target_problem())
+        .solve(reduction.target_problem())
+        .unwrap()
         .expect("k=1 should be feasible");
-    let extracted = reduction.extract_solution(&witness);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&witness).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/kclique_ilp.rs b/src/unit_tests/rules/kclique_ilp.rs
index 6c8628c0a..5e5b86e60 100644
--- a/src/unit_tests/rules/kclique_ilp.rs
+++ b/src/unit_tests/rules/kclique_ilp.rs
@@ -9,12 +9,13 @@ fn test_reduction_creates_valid_ilp() {
     // Triangle graph, k=3
     let graph = SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]);
     let problem = KClique::new(graph, 3);
-    let reduction: ReductionKCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionKCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 3);
+    assert_eq!(ilp.num_vars(), 3);
     // 1 cardinality + 0 non-edges (complete graph)
-    assert_eq!(ilp.constraints.len(), 1);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.constraints().len(), 1);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -22,33 +23,35 @@ fn test_kclique_to_ilp_bf_vs_ilp() {
     // K4 graph, k=3 → has 3-clique
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
     let problem = KClique::new(graph, 3);
-    let reduction: ReductionKCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionKCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_witness = bf.find_witness(&problem).expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should be feasible");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_solution_extraction() {
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
     let problem = KClique::new(graph, 3);
-    let reduction: ReductionKCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionKCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
     // Should select at least k=3 vertices (ILP may return a larger valid clique)
-    assert!(extracted.iter().sum::<usize>() >= 3);
+    assert!(extracted.iter().filter(|&&selected| selected).count() >= 3);
 }
 
 #[test]
@@ -56,7 +59,8 @@ fn test_kclique_to_ilp_trivial() {
     // Empty graph (no edges), k=1 → trivially feasible (any single vertex is a 1-clique)
     let graph = SimpleGraph::new(3, vec![]);
     let problem = KClique::new(graph, 1);
-    let reduction: ReductionKCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionKCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 3);
+    assert_eq!(ilp.num_vars(), 3);
 }
diff --git a/src/unit_tests/rules/kclique_subgraphisomorphism.rs b/src/unit_tests/rules/kclique_subgraphisomorphism.rs
index d2abaf38c..7ba1863be 100644
--- a/src/unit_tests/rules/kclique_subgraphisomorphism.rs
+++ b/src/unit_tests/rules/kclique_subgraphisomorphism.rs
@@ -12,7 +12,8 @@ fn test_kclique_to_subgraphisomorphism_closed_loop() {
         SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]),
         3,
     );
-    let reduction = ReduceTo::<SubgraphIsomorphism>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<SubgraphIsomorphism>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Host graph should match the source graph
@@ -36,7 +37,8 @@ fn test_kclique_to_subgraphisomorphism_complete_graph() {
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
         3,
     );
-    let reduction = ReduceTo::<SubgraphIsomorphism>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<SubgraphIsomorphism>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_host_vertices(), 4);
@@ -46,18 +48,19 @@ fn test_kclique_to_subgraphisomorphism_complete_graph() {
 
     // Solve the target and extract back to source
     let bf = BruteForce::new();
-    let witness = bf.find_witness(target).expect("K4 should contain K3");
-    let extracted = reduction.extract_solution(&witness);
-    assert_eq!(source.evaluate(&extracted), Or(true));
+    let witness = bf.solve(target).unwrap().expect("K4 should contain K3");
+    let extracted = reduction.extract_solution(&witness).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
     // Exactly 3 vertices should be selected
-    assert_eq!(extracted.iter().sum::<usize>(), 3);
+    assert_eq!(extracted.iter().filter(|&&selected| selected).count(), 3);
 }
 
 #[test]
 fn test_kclique_to_subgraphisomorphism_no_clique() {
     // Path graph: 0-1-2-3, k=3 -> no 3-clique exists
     let source = KClique::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]), 3);
-    let reduction = ReduceTo::<SubgraphIsomorphism>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<SubgraphIsomorphism>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_host_vertices(), 4);
@@ -67,11 +70,11 @@ fn test_kclique_to_subgraphisomorphism_no_clique() {
 
     // No subgraph isomorphism should exist
     let bf = BruteForce::new();
-    let witness = bf.find_witness(target);
+    let witness = bf.solve(target).unwrap();
     assert!(witness.is_none(), "path graph should not contain K3");
 
     // Also verify brute force on source agrees
-    let source_witness = bf.find_witness(&source);
+    let source_witness = bf.solve(&source).unwrap();
     assert!(source_witness.is_none());
 }
 
@@ -79,7 +82,8 @@ fn test_kclique_to_subgraphisomorphism_no_clique() {
 fn test_kclique_to_subgraphisomorphism_k_equals_1() {
     // Any non-empty graph has a 1-clique (single vertex)
     let source = KClique::new(SimpleGraph::new(3, vec![(0, 1)]), 1);
-    let reduction = ReduceTo::<SubgraphIsomorphism>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<SubgraphIsomorphism>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Pattern is K_1: 1 vertex, 0 edges
@@ -88,18 +92,20 @@ fn test_kclique_to_subgraphisomorphism_k_equals_1() {
 
     let bf = BruteForce::new();
     let witness = bf
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("should find a single vertex");
-    let extracted = reduction.extract_solution(&witness);
-    assert_eq!(source.evaluate(&extracted), Or(true));
-    assert_eq!(extracted.iter().sum::<usize>(), 1);
+    let extracted = reduction.extract_solution(&witness).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
+    assert_eq!(extracted.iter().filter(|&&selected| selected).count(), 1);
 }
 
 #[test]
 fn test_kclique_to_subgraphisomorphism_k_equals_2() {
     // k=2 means we need an edge
     let source = KClique::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), 2);
-    let reduction = ReduceTo::<SubgraphIsomorphism>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<SubgraphIsomorphism>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Pattern is K_2: 2 vertices, 1 edge
@@ -108,9 +114,10 @@ fn test_kclique_to_subgraphisomorphism_k_equals_2() {
 
     let bf = BruteForce::new();
     let witness = bf
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("graph has edges, so K2 exists");
-    let extracted = reduction.extract_solution(&witness);
-    assert_eq!(source.evaluate(&extracted), Or(true));
-    assert_eq!(extracted.iter().sum::<usize>(), 2);
+    let extracted = reduction.extract_solution(&witness).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
+    assert_eq!(extracted.iter().filter(|&&selected| selected).count(), 2);
 }
diff --git a/src/unit_tests/rules/kcoloring_bicliquecover.rs b/src/unit_tests/rules/kcoloring_bicliquecover.rs
index c39d9726d..9d86c589b 100644
--- a/src/unit_tests/rules/kcoloring_bicliquecover.rs
+++ b/src/unit_tests/rules/kcoloring_bicliquecover.rs
@@ -5,9 +5,9 @@ use crate::traits::Problem;
 use crate::types::Or;
 use crate::variant::KN;
 
-/// Helper: extract a vertex-major `BicliqueCover` cell.
-fn cell(config: &[usize], vertex: usize, biclique: usize, k: usize) -> usize {
-    config[vertex * k + biclique]
+/// Helper: extract a `BicliqueCover` membership cell.
+fn cell(config: &[Vec<bool>], vertex: usize, biclique: usize) -> bool {
+    config[biclique][vertex]
 }
 
 /// Build a closed-loop test on the smallest source that is non-trivial yet
@@ -17,29 +17,32 @@ fn cell(config: &[usize], vertex: usize, biclique: usize, k: usize) -> usize {
 fn test_kcoloring_to_bicliquecover_closed_loop_trivial() {
     // Single isolated vertex with q = 1: trivially 1-colorable.
     let source = KColoring::<KN, _>::with_k(SimpleGraph::new(1, vec![]), 1);
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Solve the target via brute force and verify the extracted coloring
     // is a proper q-coloring of the source.
     let witness = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("trivial target must be feasible");
-    let coloring = reduction.extract_solution(&witness);
+    let coloring = reduction.extract_solution(&witness).unwrap();
     assert_eq!(coloring.len(), 1);
     assert!(source.is_valid_solution(&coloring));
     // The source brute force agrees.
-    assert_eq!(source.evaluate(&coloring), Or(true));
+    assert_eq!(source.evaluate(&coloring).unwrap(), Or(true));
 }
 
-/// Structural assertions against the exact target sizes derived in the
+/// Structural assertions against the exact target parameterss derived in the
 /// issue. Picks a small but non-trivial instance: P_3 (path on 3 vertices)
 /// with q = 2.
 #[test]
 fn test_kcoloring_to_bicliquecover_structure_path() {
     // n = 3, m = 2 (path 0-1-2), q = 2.
     let source = KColoring::<KN, _>::with_k(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), 2);
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let n = 3;
@@ -63,7 +66,8 @@ fn test_kcoloring_to_bicliquecover_structure_clique() {
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
         3,
     );
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let n = 4;
@@ -76,7 +80,7 @@ fn test_kcoloring_to_bicliquecover_structure_clique() {
     assert_eq!(target.num_edges(), 12);
 
     // K_4 with q = 3 has no proper coloring.
-    assert!(BruteForce::new().find_witness(&source).is_none());
+    assert!(BruteForce::new().solve(&source).unwrap().is_none());
 }
 
 /// Build the explicit forward witness (guard bicliques + color bicliques)
@@ -90,14 +94,15 @@ fn test_kcoloring_to_bicliquecover_forward_witness_path_q2() {
     let coloring = vec![0usize, 1, 0];
     assert!(source.is_valid_solution(&coloring));
 
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
     let witness = forward_witness(&source, &coloring);
 
     // Witness covers all edges with rank <= n + q.
     assert!(target.is_valid_cover(&witness));
     // Extraction recovers a proper coloring.
-    let extracted = reduction.extract_solution(&witness);
+    let extracted = reduction.extract_solution(&witness).unwrap();
     assert!(source.is_valid_solution(&extracted));
 }
 
@@ -110,12 +115,13 @@ fn test_kcoloring_to_bicliquecover_forward_witness_cycle_q2() {
     let coloring = vec![0usize, 1, 0, 1];
     assert!(source.is_valid_solution(&coloring));
 
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
     let witness = forward_witness(&source, &coloring);
 
     assert!(target.is_valid_cover(&witness));
-    let extracted = reduction.extract_solution(&witness);
+    let extracted = reduction.extract_solution(&witness).unwrap();
     assert!(source.is_valid_solution(&extracted));
 }
 
@@ -126,7 +132,8 @@ fn test_kcoloring_to_bicliquecover_forward_witness_cycle_q2() {
 fn test_kcoloring_to_bicliquecover_rejects_adjacent_grouping() {
     // P_2 with q = 2; edge (0, 1) means vertices 0 and 1 are adjacent.
     let source = KColoring::<KN, _>::with_k(SimpleGraph::new(2, vec![(0, 1)]), 2);
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // The "bad" witness re-uses the canonical forward witness but pretends
@@ -138,11 +145,11 @@ fn test_kcoloring_to_bicliquecover_rejects_adjacent_grouping() {
     let k = n + q;
     let left_size = 2 * n;
     let num_vertices = 4 * n;
-    let mut bad = vec![0usize; num_vertices * k];
+    let mut bad = vec![vec![false; num_vertices]; k];
 
     // Helper: set vertex `v` (unified index) as a member of biclique `r`.
-    let set = |bad: &mut Vec<usize>, vertex: usize, biclique: usize| {
-        bad[vertex * k + biclique] = 1;
+    let set = |bad: &mut Vec<Vec<bool>>, vertex: usize, biclique: usize| {
+        bad[biclique][vertex] = true;
     };
     // Guard bicliques (biclique indices 0 and 1) cover the guard-anchor
     // edges correctly.
@@ -175,12 +182,13 @@ fn test_kcoloring_to_bicliquecover_extract_solution_on_forward_witness() {
     let coloring = vec![0usize, 1, 2];
     assert!(source.is_valid_solution(&coloring));
 
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
     let witness = forward_witness(&source, &coloring);
     assert!(target.is_valid_cover(&witness));
 
-    let extracted = reduction.extract_solution(&witness);
+    let extracted = reduction.extract_solution(&witness).unwrap();
     assert!(source.is_valid_solution(&extracted));
     // K_3 forces 3 distinct colors.
     let mut seen = std::collections::BTreeSet::new();
@@ -197,7 +205,8 @@ fn test_kcoloring_to_bicliquecover_extract_solution_on_forward_witness() {
 fn test_kcoloring_to_bicliquecover_explicit_edges_p2() {
     // P_2: n = 2, m = 1, edge (0,1), q = 2.
     let source = KColoring::<KN, _>::with_k(SimpleGraph::new(2, vec![(0, 1)]), 2);
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // n = 2, m = 1, q = 2 => num_edges = 2*2*1 - 4*1 + 6 = 6.
@@ -222,7 +231,8 @@ fn test_kcoloring_to_bicliquecover_explicit_edges_p2() {
 #[test]
 fn test_kcoloring_to_bicliquecover_extract_trivial_layout() {
     let source = KColoring::<KN, _>::with_k(SimpleGraph::new(1, vec![]), 1);
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // n = 1, q = 1, k = 2, num_vertices = 4.
@@ -233,11 +243,125 @@ fn test_kcoloring_to_bicliquecover_extract_trivial_layout() {
 
     // The diagonal edge (a_0, b_0) should be in the color biclique r = 1
     // (since the guard biclique r = 0 holds (a_0, h_0) and (g_0, h_0)).
-    let k = target.k();
     // a_0 is unified vertex 0, b_0 is unified vertex left_size = 2.
-    assert_eq!(cell(&witness, 0, 1, k), 1);
-    assert_eq!(cell(&witness, 2, 1, k), 1);
+    assert!(cell(&witness, 0, 1));
+    assert!(cell(&witness, 2, 1));
 
-    let extracted = reduction.extract_solution(&witness);
+    let extracted = reduction.extract_solution(&witness).unwrap();
     assert_eq!(extracted, vec![0]);
 }
+
+#[test]
+fn test_kcoloring_to_bicliquecover_native_loops_are_infeasible() {
+    for n in [1, 4] {
+        for q in [0, 1, usize::MAX] {
+            let source = KColoring::<KN, _>::with_k(SimpleGraph::new(n, vec![(0, 0)]), q);
+            let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source).unwrap();
+            let target = reduction.target_problem();
+            assert_eq!(target.k(), 0);
+            assert_eq!(target.graph().left_edges(), &[(0, 0)]);
+            assert!(target.evaluate(&vec![]).unwrap().0.is_none());
+            assert!(BruteForce::new().solve(target).unwrap().is_none());
+            assert!(reduction.extract_solution(&vec![]).is_err());
+            if q == 0 {
+                assert!(source.evaluate(&vec![0; n]).is_err());
+            } else {
+                assert!(!source.evaluate(&vec![0; n]).unwrap().0);
+            }
+        }
+    }
+}
+
+#[test]
+fn test_kcoloring_to_bicliquecover_normalizes_all_color_counts() {
+    for n in 0..=3 {
+        for q in [0, 1, 2, 3, 4, usize::MAX] {
+            let source = KColoring::<KN, _>::with_k(SimpleGraph::new(n, vec![]), q);
+            let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source).unwrap();
+            let target = reduction.target_problem();
+            assert_eq!(target.k(), n + q.min(n));
+            if q > 0 || n == 0 {
+                // Large native color labels are relabeled, not used as indices.
+                let coloring = vec![q.saturating_sub(1); n];
+                assert!(source.evaluate(&coloring).unwrap().0);
+                let witness = forward_witness(&source, &coloring);
+                assert!(target.evaluate(&witness).unwrap().0.is_some());
+                let decoded = reduction.extract_solution(&witness).unwrap();
+                assert!(source.evaluate(&decoded).unwrap().0);
+            }
+        }
+    }
+}
+
+#[test]
+fn test_kcoloring_to_bicliquecover_rejects_invalid_certificates() {
+    let source = KColoring::<KN, _>::with_k(SimpleGraph::new(2, vec![(0, 1)]), 2);
+    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source).unwrap();
+    let target = reduction.target_problem();
+    for invalid in [
+        vec![],
+        vec![vec![true; 7]; 4],
+        vec![vec![true; 8]; 4],
+        vec![vec![false; 8]; 4],
+    ] {
+        assert!(reduction.extract_solution(&invalid).is_err());
+    }
+    let valid = forward_witness(&source, &[0, 1]);
+    assert!(target.evaluate(&valid).unwrap().0.is_some());
+    let mut reordered = valid.clone();
+    reordered.reverse();
+    assert!(
+        source
+            .evaluate(&reduction.extract_solution(&reordered).unwrap())
+            .unwrap()
+            .0
+    );
+}
+
+#[test]
+fn test_kcoloring_to_bicliquecover_repeated_reversed_edges() {
+    let simple = KColoring::<KN, _>::with_k(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), 2);
+    let repeated =
+        KColoring::<KN, _>::with_k(SimpleGraph::new(3, vec![(0, 1), (1, 0), (1, 2), (0, 1)]), 2);
+    let a = ReduceTo::<BicliqueCover>::reduce_to(&simple).unwrap();
+    let b = ReduceTo::<BicliqueCover>::reduce_to(&repeated).unwrap();
+    assert_eq!(
+        a.target_problem().graph().left_edges(),
+        b.target_problem().graph().left_edges()
+    );
+    let witness = forward_witness(&repeated, &[0, 1, 0]);
+    assert!(
+        repeated
+            .evaluate(&b.extract_solution(&witness).unwrap())
+            .unwrap()
+            .0
+    );
+}
+
+#[test]
+fn test_kcoloring_to_bicliquecover_all_single_vertex_target_configs() {
+    for q in 0..=1 {
+        let source = KColoring::<KN, _>::with_k(SimpleGraph::new(1, vec![]), q);
+        let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        let bits = target.k() * target.num_vertices();
+        let mut feasible = false;
+        for mask in 0..(1usize << bits) {
+            let config: Vec<Vec<bool>> = (0..target.k())
+                .map(|r| {
+                    (0..target.num_vertices())
+                        .map(|v| mask & (1 << (r * target.num_vertices() + v)) != 0)
+                        .collect()
+                })
+                .collect();
+            let value = target.evaluate(&config).unwrap();
+            let decoded = reduction.extract_solution(&config);
+            assert_eq!(decoded.is_ok(), value.0.is_some());
+            if let Ok(coloring) = decoded {
+                feasible = true;
+                assert!(source.evaluate(&coloring).unwrap().0);
+            }
+        }
+        assert_eq!(feasible, q > 0);
+    }
+}
diff --git a/src/unit_tests/rules/kcoloring_clustering.rs b/src/unit_tests/rules/kcoloring_clustering.rs
index 3c003c411..36473f489 100644
--- a/src/unit_tests/rules/kcoloring_clustering.rs
+++ b/src/unit_tests/rules/kcoloring_clustering.rs
@@ -7,7 +7,7 @@ use crate::variant::K3;
 #[test]
 fn test_kcoloring_to_clustering_closed_loop() {
     let source = KColoring::<K3, _>::new(SimpleGraph::cycle(5));
-    let reduction = ReduceTo::<Clustering>::reduce_to(&source);
+    let reduction = ReduceTo::<Clustering>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -19,7 +19,7 @@ fn test_kcoloring_to_clustering_closed_loop() {
 #[test]
 fn test_kcoloring_to_clustering_distance_matrix() {
     let source = KColoring::<K3, _>::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction = ReduceTo::<Clustering>::reduce_to(&source);
+    let reduction = ReduceTo::<Clustering>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_elements(), 4);
@@ -39,31 +39,34 @@ fn test_kcoloring_to_clustering_distance_matrix() {
 #[test]
 fn test_kcoloring_to_clustering_extract_solution_identity() {
     let source = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction = ReduceTo::<Clustering>::reduce_to(&source);
+    let reduction = ReduceTo::<Clustering>::reduce_to(&source).expect("reduction should succeed");
     let config = vec![0, 1, 0];
 
-    assert_eq!(reduction.extract_solution(&config), config);
+    assert_eq!(reduction.extract_solution(&config).unwrap(), config);
 }
 
 #[test]
 fn test_kcoloring_to_clustering_unsat_preserved() {
     let source = KColoring::<K3, _>::new(SimpleGraph::complete(4));
-    let reduction = ReduceTo::<Clustering>::reduce_to(&source);
+    let reduction = ReduceTo::<Clustering>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
 
-    assert!(solver.find_witness(&source).is_none());
-    assert!(solver.find_witness(reduction.target_problem()).is_none());
+    assert!(solver.solve(&source).unwrap().is_none());
+    assert!(solver.solve(reduction.target_problem()).unwrap().is_none());
 }
 
 #[test]
 fn test_kcoloring_to_clustering_empty_graph() {
     let source = KColoring::<K3, _>::new(SimpleGraph::new(0, vec![]));
-    let reduction = ReduceTo::<Clustering>::reduce_to(&source);
+    let reduction = ReduceTo::<Clustering>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_elements(), 1);
     assert_eq!(target.num_clusters(), 3);
     assert_eq!(target.diameter_bound(), 0);
-    assert_eq!(reduction.extract_solution(&[2]), Vec::<usize>::new());
+    assert_eq!(
+        reduction.extract_solution(&vec![2]).unwrap(),
+        Vec::<usize>::new()
+    );
     assert_satisfaction_round_trip_from_satisfaction_target(&source, &reduction, "empty graph");
 }
diff --git a/src/unit_tests/rules/kcoloring_partitionintocliques.rs b/src/unit_tests/rules/kcoloring_partitionintocliques.rs
index c64337df2..c05b094c7 100644
--- a/src/unit_tests/rules/kcoloring_partitionintocliques.rs
+++ b/src/unit_tests/rules/kcoloring_partitionintocliques.rs
@@ -10,7 +10,8 @@ fn test_kcoloring_to_partitionintocliques_closed_loop() {
         SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)]),
         3,
     );
-    let reduction = ReduceTo::<PartitionIntoCliques<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<PartitionIntoCliques<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -22,7 +23,8 @@ fn test_kcoloring_to_partitionintocliques_closed_loop() {
 #[test]
 fn test_kcoloring_to_partitionintocliques_complement_structure() {
     let source = KColoring::<KN, _>::with_k(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]), 2);
-    let reduction = ReduceTo::<PartitionIntoCliques<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<PartitionIntoCliques<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.graph().num_vertices(), 4);
@@ -36,18 +38,20 @@ fn test_kcoloring_to_partitionintocliques_complement_structure() {
 #[test]
 fn test_kcoloring_to_partitionintocliques_extract_solution_identity() {
     let source = KColoring::<KN, _>::with_k(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), 2);
-    let reduction = ReduceTo::<PartitionIntoCliques<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<PartitionIntoCliques<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let config = vec![0, 1, 0];
 
-    assert_eq!(reduction.extract_solution(&config), config);
+    assert_eq!(reduction.extract_solution(&config).unwrap(), config);
 }
 
 #[test]
 fn test_kcoloring_to_partitionintocliques_unsat_preserved() {
     let source = KColoring::<KN, _>::with_k(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]), 2);
-    let reduction = ReduceTo::<PartitionIntoCliques<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<PartitionIntoCliques<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
 
-    assert!(solver.find_witness(&source).is_none());
-    assert!(solver.find_witness(reduction.target_problem()).is_none());
+    assert!(solver.solve(&source).unwrap().is_none());
+    assert!(solver.solve(reduction.target_problem()).unwrap().is_none());
 }
diff --git a/src/unit_tests/rules/kcoloring_twodimensionalconsecutivesets.rs b/src/unit_tests/rules/kcoloring_twodimensionalconsecutivesets.rs
index 39012b081..46338d9c3 100644
--- a/src/unit_tests/rules/kcoloring_twodimensionalconsecutivesets.rs
+++ b/src/unit_tests/rules/kcoloring_twodimensionalconsecutivesets.rs
@@ -12,7 +12,8 @@ use crate::variant::K3;
 fn test_kcoloring_to_twodimensionalconsecutivesets_closed_loop() {
     // Triangle graph: 3-colorable
     let source = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source);
+    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -25,7 +26,8 @@ fn test_kcoloring_to_twodimensionalconsecutivesets_closed_loop() {
 fn test_kcoloring_to_tdcs_target_structure() {
     // Graph with 4 vertices and 3 edges: path 0-1-2-3
     let source = KColoring::<K3, _>::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source);
+    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Alphabet: 4 vertices + 3 edges = 7
@@ -50,11 +52,12 @@ fn test_kcoloring_to_tdcs_non_3colorable() {
     ));
 
     let solver = BruteForce::new();
-    let source_solutions = solver.find_all_witnesses(&source);
+    let source_solutions = solver.find_all_witnesses(&source).unwrap();
     assert!(source_solutions.is_empty(), "K4 is not 3-colorable");
 
     // Verify the reduction produces the correct structure
-    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source);
+    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     assert_eq!(target.alphabet_size(), 10); // 4 vertices + 6 edges
     assert_eq!(target.num_subsets(), 6);
@@ -64,7 +67,8 @@ fn test_kcoloring_to_tdcs_non_3colorable() {
 fn test_kcoloring_to_tdcs_bipartite() {
     // Path 0-1-2: bipartite, 2-colorable (hence 3-colorable)
     let source = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source);
+    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -77,7 +81,8 @@ fn test_kcoloring_to_tdcs_bipartite() {
 fn test_kcoloring_to_tdcs_single_edge() {
     // Single edge: trivially 3-colorable
     let source = KColoring::<K3, _>::new(SimpleGraph::new(2, vec![(0, 1)]));
-    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source);
+    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.alphabet_size(), 3); // 2 vertices + 1 edge
@@ -94,19 +99,132 @@ fn test_kcoloring_to_tdcs_single_edge() {
 fn test_kcoloring_to_tdcs_extract_solution_valid() {
     // Triangle: verify extracted coloring is valid
     let source = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source);
+    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     let solver = BruteForce::new();
-    let target_solutions = solver.find_all_witnesses(reduction.target_problem());
+    let target_solutions = solver
+        .find_all_witnesses(reduction.target_problem())
+        .unwrap();
 
     for target_sol in &target_solutions {
-        let source_sol = reduction.extract_solution(target_sol);
+        let source_sol = reduction.extract_solution(target_sol).unwrap();
         assert_eq!(source_sol.len(), 3);
         // Verify it is a valid coloring
         assert!(
-            source.evaluate(&source_sol).0,
+            source.evaluate(&source_sol).unwrap().0,
             "Extracted coloring must be valid: {:?}",
             source_sol
         );
     }
 }
+
+#[test]
+fn test_kcoloring_to_tdcs_empty_graph_has_a_target_witness() {
+    let source = KColoring::<K3, _>::new(SimpleGraph::empty(0));
+    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source).unwrap();
+    let target = reduction.target_problem();
+    assert_eq!(target.alphabet_size(), 1);
+    assert_eq!(target.num_subsets(), 0);
+    let witness = BruteForce::new().solve(target).unwrap().unwrap();
+    let coloring = reduction.extract_solution(&witness).unwrap();
+    assert!(coloring.is_empty());
+    assert!(source.evaluate(&coloring).unwrap().0);
+}
+
+#[test]
+fn test_kcoloring_to_tdcs_native_loops_are_no() {
+    for n in [1, 5] {
+        let source = KColoring::<K3, _>::new(SimpleGraph::new(n, vec![(0, 0)]));
+        let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        assert_eq!(target.alphabet_size(), 3);
+        assert_eq!(target.num_subsets(), 3);
+        assert!(BruteForce::new().solve(&source).unwrap().is_none());
+        assert!(BruteForce::new().solve(target).unwrap().is_none());
+        for a in 0..3 {
+            for b in 0..3 {
+                for c in 0..3 {
+                    assert!(reduction.extract_solution(&vec![a, b, c]).is_err());
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_kcoloring_to_tdcs_rejects_noncertificates() {
+    let source = KColoring::<K3, _>::new(SimpleGraph::new(2, vec![(0, 1)]));
+    let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source).unwrap();
+    for config in [vec![], vec![0, 1], vec![0, 1, 3], vec![0, 0, 0]] {
+        assert!(reduction.extract_solution(&config).is_err());
+    }
+}
+
+#[test]
+fn test_kcoloring_to_tdcs_many_groups_gaps_and_repeated_edges() {
+    for (n, edges, grouping, expected) in [
+        (
+            5,
+            vec![(0, 1), (1, 2), (2, 3), (3, 4)],
+            vec![0, 2, 4, 6, 8, 1, 3, 5, 7],
+            vec![0, 1, 2, 0, 1],
+        ),
+        (4, vec![(0, 3)], vec![0, 0, 4, 4, 2], vec![0, 0, 1, 1]),
+        (
+            2,
+            vec![(0, 1), (1, 0), (0, 1)],
+            vec![0, 1, 2, 2, 2],
+            vec![0, 1],
+        ),
+    ] {
+        let source = KColoring::<K3, _>::new(SimpleGraph::new(n, edges));
+        let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source).unwrap();
+        assert!(reduction.target_problem().evaluate(&grouping).unwrap().0);
+        let coloring = reduction.extract_solution(&grouping).unwrap();
+        assert_eq!(coloring, expected);
+        assert!(source.evaluate(&coloring).unwrap().0);
+    }
+}
+
+#[test]
+fn test_kcoloring_to_tdcs_all_tiny_graphs_and_target_assignments() {
+    for n in 0..=3 {
+        let pairs: Vec<_> = (0..n)
+            .flat_map(|u| (u + 1..n).map(move |v| (u, v)))
+            .collect();
+        for mask in 0..1usize << pairs.len() {
+            let edges = pairs
+                .iter()
+                .enumerate()
+                .filter(|(i, _)| mask & (1 << i) != 0)
+                .map(|(_, &e)| e)
+                .collect();
+            let source = KColoring::<K3, _>::new(SimpleGraph::new(n, edges));
+            let reduction = ReduceTo::<TwoDimensionalConsecutiveSets>::reduce_to(&source).unwrap();
+            let target = reduction.target_problem();
+            let size = target.alphabet_size();
+            let mut target_yes = false;
+            for mut encoded in 0..size.pow(u32::try_from(size).unwrap()) {
+                let grouping = (0..size)
+                    .map(|_| {
+                        let group = encoded % size;
+                        encoded /= size;
+                        group
+                    })
+                    .collect();
+                let feasible = target.evaluate(&grouping).unwrap().0;
+                let extracted = reduction.extract_solution(&grouping);
+                assert_eq!(extracted.is_ok(), feasible);
+                if let Ok(coloring) = extracted {
+                    assert!(source.evaluate(&coloring).unwrap().0);
+                    target_yes = true;
+                }
+            }
+            assert_eq!(
+                target_yes,
+                BruteForce::new().solve(&source).unwrap().is_some()
+            );
+        }
+    }
+}
diff --git a/src/unit_tests/rules/knapsack_ilp.rs b/src/unit_tests/rules/knapsack_ilp.rs
index 35aa277a7..bf72d4cff 100644
--- a/src/unit_tests/rules/knapsack_ilp.rs
+++ b/src/unit_tests/rules/knapsack_ilp.rs
@@ -1,40 +1,36 @@
 use super::*;
 use crate::models::algebraic::{Comparison, ObjectiveSense, ILP};
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 
 #[test]
 fn test_knapsack_to_ilp_closed_loop() {
     let knapsack = Knapsack::new(vec![1, 3, 4, 5], vec![1, 4, 5, 7], 7);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack).expect("reduction should succeed");
 
-    assert_optimization_round_trip_from_optimization_target(
-        &knapsack,
-        &reduction,
-        "Knapsack->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&knapsack, &reduction);
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![0, 1, 1, 0]);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![false, true, true, false]);
 }
 
 #[test]
 fn test_knapsack_to_ilp_bf_vs_ilp() {
     let knapsack = Knapsack::new(vec![1, 3, 4, 5], vec![1, 4, 5, 7], 7);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack).expect("reduction should succeed");
 
-    let bf_solutions = BruteForce::new().find_all_witnesses(&knapsack);
-    let bf_value = knapsack.evaluate(&bf_solutions[0]);
+    let bf_solutions = BruteForce::new().find_all_witnesses(&knapsack).unwrap();
+    let bf_value = knapsack.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = knapsack.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = knapsack.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     assert!(ilp_value.is_valid());
@@ -43,53 +39,61 @@ fn test_knapsack_to_ilp_bf_vs_ilp() {
 #[test]
 fn test_knapsack_to_ilp_structure() {
     let knapsack = Knapsack::new(vec![1, 3, 4, 5], vec![1, 4, 5, 7], 7);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     assert_eq!(ilp.num_vars(), 4);
     assert_eq!(ilp.num_constraints(), 1);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
-    assert_eq!(ilp.objective, vec![(0, 1.0), (1, 4.0), (2, 5.0), (3, 7.0)]);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
+    assert_eq!(ilp.objective(), vec![(0, 1), (1, 4), (2, 5), (3, 7)]);
 
-    let constraint = &ilp.constraints[0];
-    assert_eq!(constraint.cmp, Comparison::Le);
-    assert_eq!(constraint.rhs, 7.0);
-    assert_eq!(
-        constraint.terms,
-        vec![(0, 1.0), (1, 3.0), (2, 4.0), (3, 5.0)]
-    );
+    let constraint = &ilp.constraints()[0];
+    assert_eq!(constraint.comparison(), Comparison::Le);
+    assert_eq!(constraint.rhs(), 7);
+    assert_eq!(constraint.terms(), vec![(0, 1), (1, 3), (2, 4), (3, 5)]);
 }
 
 #[test]
 fn test_knapsack_to_ilp_zero_capacity() {
     let knapsack = Knapsack::new(vec![2, 3], vec![5, 7], 0);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("zero-capacity ILP should still be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![0, 0]);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![false, false]);
 }
 
 #[test]
 fn test_knapsack_to_ilp_empty_instance() {
     let knapsack = Knapsack::new(vec![], vec![], 0);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     assert_eq!(ilp.num_vars(), 0);
     assert_eq!(ilp.num_constraints(), 1);
-    assert_eq!(ilp.constraints[0].cmp, Comparison::Le);
-    assert_eq!(ilp.constraints[0].rhs, 0.0);
-    assert!(ilp.constraints[0].terms.is_empty());
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.constraints()[0].comparison(), Comparison::Le);
+    assert_eq!(ilp.constraints()[0].rhs(), 0);
+    assert!(ilp.constraints()[0].terms().is_empty());
+    assert!(ilp.objective().is_empty());
 
     let ilp_solution = ILPSolver::new()
         .solve(ilp)
         .expect("empty Knapsack ILP should still be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, Vec::<usize>::new());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, Vec::<bool>::new());
+}
+
+#[test]
+fn test_knapsack_to_ilp_preserves_large_exact_weight() {
+    let weight = crate::types::MAX_EXACT_F64_INTEGER + 1;
+    let knapsack = Knapsack::new(vec![weight], vec![1], weight);
+
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&knapsack).unwrap();
+    let constraint = &reduction.target_problem().constraints()[0];
+    assert_eq!(constraint.terms(), vec![(0, weight)]);
+    assert_eq!(constraint.rhs(), weight);
 }
 
 #[cfg(feature = "example-db")]
@@ -104,7 +108,13 @@ fn test_knapsack_to_ilp_canonical_example_spec() {
     assert_eq!(example.source.problem, "Knapsack");
     assert_eq!(example.target.problem, "ILP");
     assert_eq!(example.source.instance["capacity"], 7);
-    assert_eq!(example.target.instance["num_vars"], 4);
+    assert_eq!(
+        example.target.instance["variables"]
+            .as_array()
+            .unwrap()
+            .len(),
+        4
+    );
     assert_eq!(
         example.target.instance["constraints"]
             .as_array()
@@ -115,8 +125,8 @@ fn test_knapsack_to_ilp_canonical_example_spec() {
     assert_eq!(
         example.solutions,
         vec![crate::export::SolutionPair {
-            source_config: vec![0, 1, 1, 0],
-            target_config: vec![0, 1, 1, 0],
+            source_config: serde_json::json!(vec![false, true, true, false]),
+            target_config: serde_json::json!(vec![0, 1, 1, 0]),
         }]
     );
 }
diff --git a/src/unit_tests/rules/knapsack_qubo.rs b/src/unit_tests/rules/knapsack_qubo.rs
index 568cdab1f..29ff7203c 100644
--- a/src/unit_tests/rules/knapsack_qubo.rs
+++ b/src/unit_tests/rules/knapsack_qubo.rs
@@ -6,7 +6,7 @@ use crate::traits::Problem;
 #[test]
 fn test_knapsack_to_qubo_closed_loop() {
     let knapsack = Knapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], 7);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&knapsack);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&knapsack).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     assert_eq!(qubo.num_vars(), 7);
@@ -21,29 +21,29 @@ fn test_knapsack_to_qubo_closed_loop() {
 #[test]
 fn test_knapsack_to_qubo_single_item() {
     let knapsack = Knapsack::new(vec![1], vec![1], 1);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&knapsack);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&knapsack).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     assert_eq!(qubo.num_vars(), 2);
 
     let solver = BruteForce::new();
-    let best_target = solver.find_all_witnesses(qubo);
-    let extracted = reduction.extract_solution(&best_target[0]);
-    assert_eq!(extracted, vec![1]);
+    let best_target = solver.find_all_witnesses(qubo).unwrap();
+    let extracted = reduction.extract_solution(&best_target[0]).unwrap();
+    assert_eq!(extracted, vec![true]);
 }
 
 #[test]
 fn test_knapsack_to_qubo_infeasible_rejected() {
     let knapsack = Knapsack::new(vec![2, 3, 4, 5], vec![3, 4, 5, 7], 7);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&knapsack);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&knapsack).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let best_target = solver.find_all_witnesses(qubo);
+    let best_target = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &best_target {
-        let source_sol = reduction.extract_solution(sol);
-        let eval = knapsack.evaluate(&source_sol);
+        let source_sol = reduction.extract_solution(sol).unwrap();
+        let eval = knapsack.evaluate(&source_sol).unwrap();
         assert!(
             eval.is_valid(),
             "Optimal QUBO solution maps to infeasible knapsack solution"
@@ -54,15 +54,15 @@ fn test_knapsack_to_qubo_infeasible_rejected() {
 #[test]
 fn test_knapsack_to_qubo_empty() {
     let knapsack = Knapsack::new(vec![1, 2], vec![3, 4], 0);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&knapsack);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&knapsack).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     assert_eq!(qubo.num_vars(), 3);
 
     let solver = BruteForce::new();
-    let best_target = solver.find_all_witnesses(qubo);
-    let extracted = reduction.extract_solution(&best_target[0]);
-    assert_eq!(extracted, vec![0, 0]);
+    let best_target = solver.find_all_witnesses(qubo).unwrap();
+    let extracted = reduction.extract_solution(&best_target[0]).unwrap();
+    assert_eq!(extracted, vec![false, false]);
 }
 
 #[cfg(feature = "example-db")]
diff --git a/src/unit_tests/rules/ksatisfiability_acyclicpartition.rs b/src/unit_tests/rules/ksatisfiability_acyclicpartition.rs
index b2b98c15e..d12fc33e7 100644
--- a/src/unit_tests/rules/ksatisfiability_acyclicpartition.rs
+++ b/src/unit_tests/rules/ksatisfiability_acyclicpartition.rs
@@ -1,52 +1,94 @@
-use crate::models::formula::CNFClause;
-use crate::models::formula::KSatisfiability;
+use super::incidence_parameters;
+use crate::models::formula::{CNFClause, KSatisfiability};
 use crate::models::graph::AcyclicPartition;
-use crate::rules::traits::ReductionResult;
-use crate::rules::ReduceTo;
+use crate::rules::{ReduceTo, ReductionResult};
 use crate::solvers::BruteForce;
+use crate::topology::Graph;
 use crate::traits::Problem;
 use crate::variant::K3;
 
 #[test]
 fn test_ksatisfiability_to_acyclicpartition_closed_loop() {
     let source = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1, 1, 1])]);
-    let reduction = ReduceTo::<AcyclicPartition<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<AcyclicPartition<i64>>::reduce_to(&source).unwrap();
     let target = reduction.target_problem();
-
-    assert_eq!(target.num_vertices(), 7);
-    assert_eq!(target.num_arcs(), 10);
-
-    let solutions = BruteForce::new().find_all_witnesses(target);
-    assert!(!solutions.is_empty());
-
-    for solution in solutions {
-        let extracted = reduction.extract_solution(&solution);
-        assert!(source.evaluate(&extracted).0);
+    assert_eq!((target.num_vertices(), target.num_arcs()), (9, 20));
+    let mut count = 0;
+    // Enumerate every two-anchor-block partition. Arbitrary additional blocks
+    // are excluded by the cost lemma, independently checked in the proof audit.
+    for mask in 0..128 {
+        let mut labels: Vec<usize> = (0..7).map(|i| (mask >> i) & 1).collect();
+        labels.extend([0, 1]);
+        if target.evaluate(&labels).unwrap().0 {
+            count += 1;
+            assert!(
+                source
+                    .evaluate(&reduction.extract_solution(&labels).unwrap())
+                    .unwrap()
+                    .0
+            );
+            let renamed = labels.iter().map(|&x| if x == 0 { 8 } else { 3 }).collect();
+            assert!(
+                source
+                    .evaluate(&reduction.extract_solution(&renamed).unwrap())
+                    .unwrap()
+                    .0
+            );
+        } else {
+            assert!(reduction.extract_solution(&labels).is_err());
+        }
     }
+    assert_eq!(count, 3);
 }
 
 #[test]
-fn test_ksatisfiability_to_acyclicpartition_unsatisfiable() {
-    let source = KSatisfiability::<K3>::new(
-        1,
-        vec![
-            CNFClause::new(vec![1, 1, 1]),
-            CNFClause::new(vec![-1, -1, -1]),
-        ],
-    );
-
-    // Source is trivially UNSAT: requires x=true AND x=false simultaneously.
-    let solver = BruteForce::new();
-    assert!(
-        solver.find_witness(&source).is_none(),
-        "source with contradictory clauses must be unsatisfiable"
-    );
+fn test_acyclicpartition_extraction_rejects_invalid_targets() {
+    let source = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1, 1, 1])]);
+    let reduction = ReduceTo::<AcyclicPartition<i64>>::reduce_to(&source).unwrap();
+    for labels in [
+        vec![],
+        vec![0; 8],
+        vec![0; 10],
+        vec![9; 9],
+        vec![0; 9],
+        vec![2, 1, 1, 0, 0, 1, 1, 0, 1],
+    ] {
+        assert!(reduction.extract_solution(&labels).is_err());
+    }
+}
 
-    // Verify the reduction still produces a well-formed target.
-    let reduction = ReduceTo::<AcyclicPartition<i32>>::reduce_to(&source);
-    let target = reduction.target_problem();
-    assert_eq!(target.num_vertices(), 9);
-    assert_eq!(target.num_arcs(), 14);
+#[test]
+fn test_acyclicpartition_native_empty_and_short_clauses() {
+    for n in [0, 3] {
+        let source = KSatisfiability::<K3>::new(n, vec![]);
+        let reduction = ReduceTo::<AcyclicPartition<i64>>::reduce_to(&source).unwrap();
+        let witnesses = BruteForce::new()
+            .find_all_witnesses(reduction.target_problem())
+            .unwrap();
+        assert!(!witnesses.is_empty());
+        for labels in witnesses {
+            assert!(
+                source
+                    .evaluate(&reduction.extract_solution(&labels).unwrap())
+                    .unwrap()
+                    .0
+            );
+        }
+    }
+    for clauses in [vec![vec![]], vec![vec![1], vec![-1]]] {
+        let source = KSatisfiability::<K3>::new_allow_less(
+            1,
+            clauses.into_iter().map(CNFClause::new).collect(),
+        );
+        let reduction = ReduceTo::<AcyclicPartition<i64>>::reduce_to(&source).unwrap();
+        assert!(BruteForce::new().solve(&source).unwrap().is_none());
+        let items = reduction.target_problem().num_vertices() - 2;
+        for mask in 0..(1usize << items) {
+            let mut labels: Vec<usize> = (0..items).map(|i| (mask >> i) & 1).collect();
+            labels.extend([0, 1]);
+            assert!(!reduction.target_problem().evaluate(&labels).unwrap().0);
+        }
+    }
 }
 
 #[test]
@@ -58,28 +100,63 @@ fn test_ksatisfiability_to_acyclicpartition_multi_variable_closed_loop() {
             CNFClause::new(vec![-1, -2, 3]),
         ],
     );
-
-    let reduction = ReduceTo::<AcyclicPartition<i32>>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    // Target has 2*3 + 2*2 + 3 = 13 vertices, so brute-force on target is
-    // infeasible (13^13 configs). Instead, verify round-trip by brute-forcing
-    // the source (2^3 = 8 configs) and checking that every satisfying source
-    // assignment extracts correctly from the reduction.
-    let source_witnesses = BruteForce::new().find_all_witnesses(&source);
-    assert!(
-        !source_witnesses.is_empty(),
-        "source should have at least one satisfying assignment"
+    let reduction = ReduceTo::<AcyclicPartition<i64>>::reduce_to(&source).unwrap();
+    let clique = reduction.sat_to_clique.target_problem();
+    let edges = clique.graph().edges();
+    let n = clique.num_vertices();
+    assert_eq!(
+        reduction.target_problem().num_vertices(),
+        n + edges.len() + 2
     );
-
-    for source_witness in &source_witnesses {
+    let witnesses = BruteForce::new().find_all_witnesses(&source).unwrap();
+    assert!(!witnesses.is_empty());
+    for assignment in witnesses {
+        let mut selected = vec![false; n];
+        let mut offset = 0;
+        for clause in source.clauses() {
+            let index = clause
+                .variables()
+                .iter()
+                .zip(&clause.literals)
+                .position(|(&v, &lit)| assignment[v] == (lit > 0))
+                .unwrap();
+            selected[offset + index] = true;
+            offset += clause.len();
+        }
+        selected[offset] = true;
+        let mut labels: Vec<usize> = selected.iter().map(|&b| usize::from(!b)).collect();
+        labels.extend(
+            edges
+                .iter()
+                .map(|&(u, v)| usize::from(!(selected[u] && selected[v]))),
+        );
+        labels.extend([0, 1]);
+        assert!(reduction.target_problem().evaluate(&labels).unwrap().0);
         assert!(
-            source.evaluate(source_witness).0,
-            "every source witness must evaluate as satisfying"
+            source
+                .evaluate(&reduction.extract_solution(&labels).unwrap())
+                .unwrap()
+                .0
         );
     }
+}
 
-    // Verify structural properties of the target.
-    assert_eq!(target.num_vertices(), 13);
-    assert_eq!(target.num_arcs(), 22);
+#[test]
+fn test_incidence_parameters_checked_arithmetic() {
+    assert_eq!(incidence_parameters(1, 0, 1).unwrap(), (3, 2, 1, 3, 5, 2));
+    assert_eq!(
+        incidence_parameters(4, 3, 2).unwrap(),
+        (9, 20, 3, 15, 21, 101)
+    );
+    for (n, e, k) in [
+        (usize::MAX, 1, 1),
+        (usize::MAX, 0, 1),
+        (1, usize::MAX / 2, 1),
+        (1, 0, usize::MAX),
+        (1, 0, i64::MAX as usize),
+        (1, 0, 5_000_000_000),
+        (3_000_000_000, 0, 1),
+    ] {
+        assert!(incidence_parameters(n, e, k).is_err(), "{n}, {e}, {k}");
+    }
 }
diff --git a/src/unit_tests/rules/ksatisfiability_bicliquecover.rs b/src/unit_tests/rules/ksatisfiability_bicliquecover.rs
index ad3ea0504..9c6b4b2c9 100644
--- a/src/unit_tests/rules/ksatisfiability_bicliquecover.rs
+++ b/src/unit_tests/rules/ksatisfiability_bicliquecover.rs
@@ -19,7 +19,6 @@
 use super::*;
 use crate::models::formula::CNFClause;
 use crate::models::graph::BicliqueCover;
-#[cfg(feature = "example-db")]
 use crate::traits::Problem;
 use crate::variant::K3;
 
@@ -29,7 +28,8 @@ use crate::variant::K3;
 #[test]
 fn test_ksatisfiability_to_bicliquecover_structure_single_variable() {
     let source = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1, 1, 1])]);
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Normalized: n = 2, ell = 1, m = 1 + 2 = 3.
@@ -65,7 +65,8 @@ fn test_ksatisfiability_to_bicliquecover_structure_issue_example() {
             CNFClause::new(vec![-1, 3, 4]),
         ],
     );
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let n = 8; // next power of two of 2*4 = 8
@@ -97,7 +98,8 @@ fn test_ksatisfiability_to_bicliquecover_unsat_constructs() {
             CNFClause::new(vec![-1, -1, -1]),
         ],
     );
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Even an UNSAT formula yields a syntactically valid BicliqueCover
@@ -107,87 +109,40 @@ fn test_ksatisfiability_to_bicliquecover_unsat_constructs() {
     assert!(target.k() > 0);
 }
 
-/// Verify that `extract_solution` reads the normalized assignment off
-/// of a hand-built `B_1` biclique. The witness here is not a valid
-/// biclique cover — only the slice corresponding to `B_1` is used by
-/// `extract_solution`, and that slice contains the expected `h_i^u`
-/// memberships.
 #[test]
-fn test_ksatisfiability_to_bicliquecover_extract_solution_reads_b1() {
+fn test_ksatisfiability_to_bicliquecover_rejects_invalid_covers() {
     let source = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1, 1, 1])]);
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source).unwrap();
     let target = reduction.target_problem();
-
-    let n = reduction.normalized_n;
-    let k = target.k();
-    let left_size = target.left_size();
-    let num_vertices = target.num_vertices();
-    let s1_left = reduction.s1_left_offset; // s_{1,1}^u (bipartite-local)
-    let s1_right_unified = left_size + reduction.s1_right_offset; // s_{1,1}^v
-
-    // Use biclique slot r = 0 as B_1: contains s_11^u, s_11^v, h_0^u
-    // (i.e. t_1 == true), and no Y matching vertex.
-    let mut witness = vec![0usize; num_vertices * k];
-    let set = |w: &mut [usize], vertex: usize, biclique: usize| {
-        w[vertex * k + biclique] = 1;
-    };
-    set(&mut witness, s1_left, 0);
-    set(&mut witness, s1_right_unified, 0);
-    // h_0^u is unified vertex 0 (h_offset = 0, left partition).
-    set(&mut witness, 0, 0);
-    // Leave h_1^u (vertex 1) unset → f_1 = false in B_1.
-
-    let assignment = reduction.extract_solution(&witness);
-    assert_eq!(assignment.len(), 1);
-    assert_eq!(assignment[0], 1, "expected source x_1 = true from B_1");
-
-    // Sanity: n should be 2 for this source.
-    assert_eq!(n, 2);
+    let mut sparse = vec![vec![false; target.num_vertices()]; target.k()];
+    sparse[0][reduction.s1_left_offset] = true;
+    sparse[0][target.left_size() + reduction.s1_right_offset] = true;
+    sparse[0][0] = true;
+    assert!(target.evaluate(&sparse).unwrap().0.is_none());
+    for invalid in [
+        sparse,
+        vec![],
+        vec![vec![true; target.num_vertices()]; target.k()],
+        vec![vec![false; target.num_vertices() - 1]; target.k()],
+    ] {
+        assert!(reduction.extract_solution(&invalid).is_err());
+    }
 }
 
-/// If `B_1` is shadowed by a free-edge biclique that touches `Y`, the
-/// extractor must skip it and proceed to the next candidate. We test
-/// this by setting up two bicliques that both contain `s_11^u` and
-/// `s_11^v`: biclique 0 also contains `y_0^u` (so it is rejected) and
-/// biclique 1 is the real `B_1` containing `h_0^u`.
 #[test]
-fn test_ksatisfiability_to_bicliquecover_extract_skips_y_touching_bicliques() {
+fn test_ksatisfiability_to_bicliquecover_extracts_every_row_rotation() {
     let source = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1, 1, 1])]);
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    let k = target.k();
-    let left_size = target.left_size();
-    let num_vertices = target.num_vertices();
-    let s1_left = reduction.s1_left_offset;
-    let s1_right_unified = left_size + reduction.s1_right_offset;
-    let y_left_0 = reduction.y_left_offset; // y_0^u (bipartite-local on left)
-
-    let mut witness = vec![0usize; num_vertices * k];
-    let set = |w: &mut [usize], vertex: usize, biclique: usize| {
-        w[vertex * k + biclique] = 1;
-    };
-
-    // Biclique 0: touches Y on the left side (y_0^u). The extractor
-    // must reject this candidate for B_1.
-    set(&mut witness, s1_left, 0);
-    set(&mut witness, s1_right_unified, 0);
-    set(&mut witness, y_left_0, 0);
-    set(&mut witness, 0, 0); // h_0^u
-
-    // Biclique 1: clean B_1 covering s_11 edges plus h_1^u (so t_1
-    // would be false). Extraction reads h_0^u from biclique 1 (false).
-    set(&mut witness, s1_left, 1);
-    set(&mut witness, s1_right_unified, 1);
-    // h_1^u is unified vertex 1.
-    set(&mut witness, 1, 1);
-
-    let assignment = reduction.extract_solution(&witness);
-    assert_eq!(assignment.len(), 1);
-    assert_eq!(
-        assignment[0], 0,
-        "B_1 was biclique 1 (not biclique 0); h_0^u not in B_1 so x_1 = false"
-    );
+    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source).unwrap();
+    let mut cover = super::forward_witness_single_variable_single_clause(&source);
+    let cost = reduction.target_problem().evaluate(&cover).unwrap();
+    assert!(cost.0.is_some());
+    for _ in 0..cover.len() {
+        assert_eq!(reduction.target_problem().evaluate(&cover).unwrap(), cost);
+        let assignment = reduction.extract_solution(&cover).unwrap();
+        assert_eq!(assignment, vec![true]);
+        assert!(source.evaluate(&assignment).unwrap().0);
+        cover.rotate_left(1);
+    }
 }
 
 /// Closed-loop round-trip on the canonical small case (1 source
@@ -198,11 +153,11 @@ fn test_ksatisfiability_to_bicliquecover_extract_skips_y_touching_bicliques() {
 /// 1. The constructed witness is a valid biclique cover of the target.
 /// 2. `extract_solution` on the witness produces a satisfying source
 ///    assignment.
-#[cfg(feature = "example-db")]
 #[test]
 fn test_ksatisfiability_to_bicliquecover_closed_loop_smallest() {
     let source = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1, 1, 1])]);
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let witness = super::forward_witness_single_variable_single_clause(&source);
@@ -211,14 +166,14 @@ fn test_ksatisfiability_to_bicliquecover_closed_loop_smallest() {
         "forward witness must be a valid biclique cover"
     );
 
-    let extracted = reduction.extract_solution(&witness);
+    let extracted = reduction.extract_solution(&witness).unwrap();
     assert_eq!(extracted.len(), 1);
-    assert_eq!(
-        extracted[0], 1,
+    assert!(
+        extracted[0],
         "extracted assignment must set x_1 = true (the only satisfying assignment)"
     );
     assert_eq!(
-        source.evaluate(&extracted),
+        source.evaluate(&extracted).unwrap(),
         crate::types::Or(true),
         "extracted source assignment must satisfy the formula"
     );
@@ -236,7 +191,8 @@ fn test_ksatisfiability_to_bicliquecover_construct_two_vars_no_panic() {
             CNFClause::new(vec![-1, 2, -2]),
         ],
     );
-    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<BicliqueCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Normalized n = next_power_of_two(2*2) = 4, ell = 2.
@@ -246,3 +202,85 @@ fn test_ksatisfiability_to_bicliquecover_construct_two_vars_no_panic() {
     assert_eq!(reduction.normalized_n, 4);
     assert_eq!(target.k(), 26);
 }
+
+#[test]
+fn test_ksatisfiability_to_bicliquecover_sparse_variable_inverse() {
+    // The only used variable has a high source index. Its normalized gadget
+    // equals the canonical one-variable gadget; unused variables map to false.
+    let source = KSatisfiability::<K3>::new_allow_less(7, vec![CNFClause::new(vec![7])]);
+    let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source).unwrap();
+    assert_eq!(reduction.source_variables, vec![6]);
+    assert_eq!(reduction.normalized_n, 2);
+    let cover = super::forward_witness_single_variable_single_clause(&source);
+    let assignment = reduction.extract_solution(&cover).unwrap();
+    assert_eq!(
+        assignment,
+        vec![false, false, false, false, false, false, true]
+    );
+    assert!(source.evaluate(&assignment).unwrap().0);
+
+    // No massive assignment allocation: verify that construction depends on
+    // appearing variables rather than the declared count.
+    let largest = usize::try_from(i64::MAX).unwrap_or(usize::MAX);
+    let literal = i64::try_from(largest).unwrap();
+    let huge = KSatisfiability::<K3>::new(largest, vec![CNFClause::new(vec![literal; 3])]);
+    let huge_reduction = ReduceTo::<BicliqueCover>::reduce_to(&huge).unwrap();
+    assert_eq!(huge_reduction.source_variables, vec![largest - 1]);
+    assert_eq!(
+        huge_reduction.target_problem().graph().left_edges(),
+        reduction.target_problem().graph().left_edges()
+    );
+    assert_eq!(
+        huge_reduction.target_problem().k(),
+        reduction.target_problem().k()
+    );
+}
+
+#[test]
+fn test_ksatisfiability_to_bicliquecover_empty_conjunction_and_clause() {
+    for n in [0, 3] {
+        let yes = KSatisfiability::<K3>::new(n, vec![]);
+        let reduction = ReduceTo::<BicliqueCover>::reduce_to(&yes).unwrap();
+        assert_eq!(reduction.target_problem().num_vertices(), 0);
+        assert_eq!(reduction.extract_solution(&vec![]).unwrap(), vec![false; n]);
+        assert!(yes.evaluate(&vec![false; n]).unwrap().0);
+        let no = KSatisfiability::<K3>::new_allow_less(n, vec![CNFClause::new(vec![])]);
+        let reduction = ReduceTo::<BicliqueCover>::reduce_to(&no).unwrap();
+        assert!(reduction
+            .target_problem()
+            .evaluate(&vec![])
+            .unwrap()
+            .0
+            .is_none());
+        assert!(reduction.extract_solution(&vec![]).is_err());
+        assert!(!no.evaluate(&vec![false; n]).unwrap().0);
+    }
+}
+
+#[test]
+fn test_ksatisfiability_to_bicliquecover_normalization_preserves_short_clauses() {
+    for literals in [vec![2], vec![-2], vec![2, -5], vec![-2, 5, 5]] {
+        let source = KSatisfiability::<K3>::new_allow_less(6, vec![CNFClause::new(literals)]);
+        let reduction = ReduceTo::<BicliqueCover>::reduce_to(&source).unwrap();
+        let (n, clauses) = super::normalize(&source, &reduction.source_variables).unwrap();
+        let normalized =
+            KSatisfiability::<K3>::new(n, clauses.into_iter().map(CNFClause::new).collect());
+        for mask in 0..64usize {
+            let assignment: Vec<bool> = (0..6).map(|i| mask & (1 << i) != 0).collect();
+            let mut expanded = vec![false; n];
+            for pair in 0..n / 2 {
+                let truth = reduction
+                    .source_variables
+                    .get(pair)
+                    .map(|&i| assignment[i])
+                    .unwrap_or(false);
+                expanded[2 * pair] = truth;
+                expanded[2 * pair + 1] = !truth;
+            }
+            assert_eq!(
+                source.evaluate(&assignment).unwrap(),
+                normalized.evaluate(&expanded).unwrap()
+            );
+        }
+    }
+}
diff --git a/src/unit_tests/rules/ksatisfiability_cyclicordering.rs b/src/unit_tests/rules/ksatisfiability_cyclicordering.rs
index 2d6509dd0..75c1ab6f7 100644
--- a/src/unit_tests/rules/ksatisfiability_cyclicordering.rs
+++ b/src/unit_tests/rules/ksatisfiability_cyclicordering.rs
@@ -3,122 +3,77 @@ use crate::models::formula::CNFClause;
 use crate::models::misc::CyclicOrdering;
 use crate::traits::Problem;
 use crate::variant::K3;
-use std::cmp::Reverse;
-
-fn solve_cyclic_ordering(problem: &CyclicOrdering) -> Option<Vec<usize>> {
-    let n = problem.num_elements();
-    if n == 0 {
-        return None;
-    }
-    if n == 1 {
-        return if problem.triples().is_empty() {
-            Some(vec![0])
-        } else {
-            None
-        };
-    }
-
-    let mut triples_by_element = vec![Vec::new(); n];
-    for (triple_idx, &(a, b, c)) in problem.triples().iter().enumerate() {
-        triples_by_element[a].push(triple_idx);
-        triples_by_element[b].push(triple_idx);
-        triples_by_element[c].push(triple_idx);
+// Construct the paper's seven local orders and merge their auxiliary
+// sequences into a single common order of the variable blocks.
+fn forward_witness(source: &KSatisfiability<K3>, assignment: &[bool]) -> Vec<usize> {
+    assert!(source.evaluate(&assignment.to_vec()).unwrap().0);
+    let normalized = normalize(source).unwrap();
+    if normalized.clauses.is_empty() {
+        return vec![0];
     }
-
-    let mut element_order: Vec<usize> = (1..n).collect();
-    element_order.sort_by_key(|&element| Reverse(triples_by_element[element].len()));
-
-    let mut positions = vec![None; n];
-    let mut taken = vec![false; n];
-    positions[0] = Some(0);
-    taken[0] = true;
-
-    #[allow(clippy::nonminimal_bool)]
-    fn is_cyclic_order(a: usize, b: usize, c: usize) -> bool {
-        (a < b && b < c) || (b < c && c < a) || (c < a && a < b)
+    let mut values = vec![false; normalized.num_vars];
+    for (compact, &original) in normalized.source_variables.iter().enumerate() {
+        values[compact] = assignment[original];
     }
-
-    fn triple_ok(
-        problem: &CyclicOrdering,
-        positions: &[Option<usize>],
-        element: usize,
-        triples_by_element: &[Vec<usize>],
-    ) -> bool {
-        for &triple_idx in &triples_by_element[element] {
-            let (a, b, c) = problem.triples()[triple_idx];
-            if let (Some(pa), Some(pb), Some(pc)) = (positions[a], positions[b], positions[c]) {
-                if !is_cyclic_order(pa, pb, pc) {
-                    return false;
-                }
+    let base_count = 3 * normalized.num_vars;
+    let size = base_count + 5 * normalized.clauses.len();
+    let mut after = vec![Vec::new(); base_count];
+    let templates = [
+        "",
+        "ackmbdefjlnghi",
+        "abcjkdmflneghi",
+        "ackmbdfejlnghi",
+        "abcdefjklngimh",
+        "ackmbdefjlngih",
+        "abcjkdmflnegih",
+        "acbjkdmflnegih",
+    ];
+    for (clause_index, clause) in normalized.clauses.iter().enumerate() {
+        let mut symbols = Vec::new();
+        let mut mask = 0;
+        for (slot, &literal) in clause.iter().enumerate() {
+            let (a, b, c) = literal_triple(literal);
+            symbols.extend([a, b, c]);
+            if values[literal.unsigned_abs() as usize - 1] == (literal > 0) {
+                mask |= 1 << slot;
             }
         }
-        true
-    }
-
-    fn recurse(
-        problem: &CyclicOrdering,
-        triples_by_element: &[Vec<usize>],
-        element_order: &[usize],
-        idx: usize,
-        positions: &mut [Option<usize>],
-        taken: &mut [bool],
-    ) -> bool {
-        if idx == element_order.len() {
-            return true;
-        }
-
-        let element = element_order[idx];
-        for pos in 0..problem.num_elements() {
-            if taken[pos] {
-                continue;
+        assert_ne!(
+            mask, 0,
+            "source assignment must satisfy every expanded clause"
+        );
+        symbols.extend(base_count + 5 * clause_index..base_count + 5 * clause_index + 5);
+        let mut anchor = None;
+        for ch in templates[mask].bytes() {
+            let vertex = symbols[(ch - b'a') as usize];
+            if vertex < base_count {
+                anchor = Some(vertex);
+            } else {
+                after[anchor.expect("the local order starts with a variable element")].push(vertex);
             }
-
-            positions[element] = Some(pos);
-            taken[pos] = true;
-
-            if triple_ok(problem, positions, element, triples_by_element)
-                && recurse(
-                    problem,
-                    triples_by_element,
-                    element_order,
-                    idx + 1,
-                    positions,
-                    taken,
-                )
-            {
-                return true;
-            }
-
-            positions[element] = None;
-            taken[pos] = false;
         }
-
-        false
     }
-
-    if recurse(
-        problem,
-        &triples_by_element,
-        &element_order,
-        0,
-        &mut positions,
-        &mut taken,
-    ) {
-        Some(
-            positions
-                .into_iter()
-                .map(|position| position.expect("solver assigns every element"))
-                .collect(),
-        )
-    } else {
-        None
+    let mut order = Vec::new();
+    for (i, &value) in values.iter().enumerate() {
+        let (a, b, c) = variable_triple(i);
+        for vertex in if value { [a, c, b] } else { [a, b, c] } {
+            order.push(vertex);
+            order.extend(&after[vertex]);
+        }
     }
+    assert_eq!(order.len(), size);
+    let mut positions = vec![0; size];
+    for (position, vertex) in order.into_iter().enumerate() {
+        positions[vertex] = position;
+    }
+    positions
 }
 
 #[test]
 fn test_ksatisfiability_to_cyclicordering_single_clause_reference_vector() {
     let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<CyclicOrdering>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<CyclicOrdering>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_elements(), 14);
@@ -139,17 +94,17 @@ fn test_ksatisfiability_to_cyclicordering_single_clause_reference_vector() {
         ]
     );
 
-    let target_solution =
-        solve_cyclic_ordering(target).expect("single-clause gadget should be solvable");
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![1, 1, 1]);
-    assert!(source.evaluate(&extracted).0);
+    let target_solution = forward_witness(&source, &[true, true, true]);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![true, true, true]);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_ksatisfiability_to_cyclicordering_all_negated_clause_matches_reference_vector() {
     let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![-1, -2, -3])]);
-    let reduction = ReduceTo::<CyclicOrdering>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<CyclicOrdering>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_elements(), 14);
@@ -174,45 +129,32 @@ fn test_ksatisfiability_to_cyclicordering_all_negated_clause_matches_reference_v
 #[test]
 fn test_ksatisfiability_to_cyclicordering_extract_solution_from_reference_witness() {
     let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<CyclicOrdering>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<CyclicOrdering>::reduce_to(&source).expect("reduction should succeed");
     let target_solution = vec![0, 11, 1, 9, 12, 10, 6, 13, 7, 2, 3, 4, 8, 5];
 
-    assert!(reduction.target_problem().evaluate(&target_solution).0);
-    assert_eq!(reduction.extract_solution(&target_solution), vec![1, 1, 1]);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap()
+            .0
+    );
+    assert_eq!(
+        reduction.extract_solution(&target_solution).unwrap(),
+        vec![true, true, true]
+    );
 }
 
 #[test]
 fn test_ksatisfiability_to_cyclicordering_clause_gadget_truth_patterns() {
-    let gadget = vec![
-        (0, 2, 9),
-        (1, 9, 10),
-        (2, 10, 11),
-        (3, 5, 9),
-        (4, 9, 11),
-        (5, 11, 12),
-        (6, 8, 10),
-        (7, 10, 12),
-        (8, 12, 13),
-        (13, 12, 11),
-    ];
-
-    for x_true in [false, true] {
-        for y_true in [false, true] {
-            for z_true in [false, true] {
-                let mut triples = gadget.clone();
-                triples.push(if x_true { (0, 2, 1) } else { (0, 1, 2) });
-                triples.push(if y_true { (3, 5, 4) } else { (3, 4, 5) });
-                triples.push(if z_true { (6, 8, 7) } else { (6, 7, 8) });
-
-                let problem = CyclicOrdering::new(14, triples);
-                let has_witness = solve_cyclic_ordering(&problem).is_some();
-                assert_eq!(
-                    has_witness,
-                    x_true || y_true || z_true,
-                    "truth pattern ({x_true}, {y_true}, {z_true})"
-                );
-            }
-        }
+    let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
+    let reduction = ReduceTo::<CyclicOrdering>::reduce_to(&source).unwrap();
+    for mask in 1..8 {
+        let assignment: Vec<_> = (0..3).map(|bit| mask & (1 << bit) != 0).collect();
+        let config = forward_witness(&source, &assignment);
+        assert!(reduction.target_problem().evaluate(&config).unwrap().0);
+        assert_eq!(reduction.extract_solution(&config).unwrap(), assignment);
     }
 }
 
@@ -225,35 +167,148 @@ fn test_ksatisfiability_to_cyclicordering_unsatisfiable_repeated_literal_pair()
             CNFClause::new(vec![-1, -1, -1]),
         ],
     );
-    let reduction = ReduceTo::<CyclicOrdering>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<CyclicOrdering>::reduce_to(&source).expect("reduction should succeed");
 
-    assert!(
-        solve_cyclic_ordering(reduction.target_problem()).is_none(),
-        "opposite repeated-literal clauses should be unsatisfiable after reduction"
-    );
+    let normalized = normalize(&source).unwrap();
+    assert_eq!(normalized.num_vars, 5);
+    assert_eq!(normalized.clauses.len(), 8);
+    assert_eq!(reduction.target_problem().num_elements(), 55);
+    for mask in 0..1usize << normalized.num_vars {
+        assert!(!normalized
+            .clauses
+            .iter()
+            .all(|clause| clause.iter().any(|&literal| {
+                (mask & (1 << (literal.unsigned_abs() as usize - 1)) != 0) == (literal > 0)
+            })));
+    }
 }
 
 #[test]
 fn test_ksatisfiability_to_cyclicordering_closed_loop() {
     let source = KSatisfiability::<K3>::new(2, vec![CNFClause::new(vec![1, 2, 1])]);
 
-    let reduction = ReduceTo::<CyclicOrdering>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<CyclicOrdering>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    // CyclicOrdering configs are permutations of length num_elements;
-    // brute-force over n! is infeasible for any non-trivial instance.
-    // Use the custom backtracking solver instead.
-    let target_solution =
-        solve_cyclic_ordering(target).expect("satisfiable source must yield solvable target");
+    let target_solution = forward_witness(&source, &[true, false]);
 
     assert!(
-        target.evaluate(&target_solution).0,
+        target.evaluate(&target_solution).unwrap().0,
         "target solution must evaluate as satisfying"
     );
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted source config must satisfy the source"
     );
 }
+
+#[test]
+fn repeated_short_and_unsorted_clauses_preserve_all_source_assignments() {
+    let formulas = [
+        vec![vec![5, 5, 5]],
+        vec![vec![-5, -5, -5]],
+        vec![vec![5, -5, 5]],
+        vec![vec![5, 2, 5]],
+        vec![vec![5]],
+        vec![vec![-5, 2]],
+        vec![vec![5, 1, -3], vec![-1, 5, 2], vec![-3, 2, -5]],
+    ];
+    for clauses in formulas {
+        let source = KSatisfiability::<K3>::try_new_allow_less(
+            6,
+            clauses.into_iter().map(CNFClause::new).collect(),
+        )
+        .unwrap();
+        let reduction = ReduceTo::<CyclicOrdering>::reduce_to(&source).unwrap();
+        let normalized = normalize(&source).unwrap();
+        assert!(normalized
+            .clauses
+            .iter()
+            .all(|clause| clause[0].unsigned_abs() < clause[1].unsigned_abs()
+                && clause[1].unsigned_abs() < clause[2].unsigned_abs()));
+        for mask in 0..64 {
+            let assignment: Vec<_> = (0..6).map(|bit| mask & (1 << bit) != 0).collect();
+            if source.evaluate(&assignment).unwrap().0 {
+                let config = forward_witness(&source, &assignment);
+                assert!(reduction.target_problem().evaluate(&config).unwrap().0);
+                let extracted = reduction.extract_solution(&config).unwrap();
+                assert!(source.evaluate(&extracted).unwrap().0);
+                for (original, used) in
+                    (0..6).map(|i| (i, normalized.source_variables.contains(&i)))
+                {
+                    assert_eq!(extracted[original], used && assignment[original]);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn empty_formula_and_empty_clause_have_opposite_fixed_targets() {
+    for num_vars in [0, 3] {
+        let source = KSatisfiability::<K3>::new(num_vars, vec![]);
+        let reduction = ReduceTo::<CyclicOrdering>::reduce_to(&source).unwrap();
+        assert_eq!(reduction.target_problem().num_elements(), 1);
+        assert_eq!(
+            reduction.extract_solution(&vec![0]).unwrap(),
+            vec![false; num_vars]
+        );
+        let source =
+            KSatisfiability::<K3>::try_new_allow_less(num_vars, vec![CNFClause::new(vec![])])
+                .unwrap();
+        let reduction = ReduceTo::<CyclicOrdering>::reduce_to(&source).unwrap();
+        assert_eq!(reduction.target_problem().num_elements(), 3);
+        for config in [
+            vec![0, 1, 2],
+            vec![0, 2, 1],
+            vec![1, 0, 2],
+            vec![1, 2, 0],
+            vec![2, 0, 1],
+            vec![2, 1, 0],
+        ] {
+            assert!(!reduction.target_problem().evaluate(&config).unwrap().0);
+            assert!(reduction.extract_solution(&config).is_err());
+        }
+    }
+}
+
+#[test]
+fn reject_invalid_orderings_and_accept_every_rotation() {
+    let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
+    let reduction = ReduceTo::<CyclicOrdering>::reduce_to(&source).unwrap();
+    let config = forward_witness(&source, &[true, false, true]);
+    let n = config.len();
+    for shift in 0..n {
+        let rotated = config
+            .iter()
+            .map(|position| (position + shift) % n)
+            .collect();
+        assert_eq!(
+            reduction.extract_solution(&rotated).unwrap(),
+            vec![true, false, true]
+        );
+    }
+    for config in [vec![], vec![0; n], vec![n; n], (0..n).collect()] {
+        assert!(reduction.extract_solution(&config).is_err());
+    }
+}
+
+#[test]
+fn huge_sparse_variable_index_does_not_enlarge_the_target() {
+    let largest = usize::try_from(i64::MAX).unwrap_or(usize::MAX);
+    let literal = i64::try_from(largest).unwrap();
+    let sparse = KSatisfiability::<K3>::new(largest, vec![CNFClause::new(vec![literal; 3])]);
+    let compact = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1; 3])]);
+    let a = ReduceTo::<CyclicOrdering>::reduce_to(&sparse).unwrap();
+    let b = ReduceTo::<CyclicOrdering>::reduce_to(&compact).unwrap();
+    assert_eq!(
+        a.target_problem().num_elements(),
+        b.target_problem().num_elements()
+    );
+    assert_eq!(a.target_problem().triples(), b.target_problem().triples());
+    // This construction test does not allocate an enormous source witness.
+}
diff --git a/src/unit_tests/rules/ksatisfiability_decisionminimumvertexcover.rs b/src/unit_tests/rules/ksatisfiability_decisionminimumvertexcover.rs
index 70a1e5b95..387b9de80 100644
--- a/src/unit_tests/rules/ksatisfiability_decisionminimumvertexcover.rs
+++ b/src/unit_tests/rules/ksatisfiability_decisionminimumvertexcover.rs
@@ -17,7 +17,8 @@ fn test_ksatisfiability_to_decisionminimumvertexcover_closed_loop() {
             CNFClause::new(vec![-1, -2, 3]),
         ],
     );
-    let reduction = ReduceTo::<Decision<MinimumVertexCover<SimpleGraph, i32>>>::reduce_to(&source);
+    let reduction = ReduceTo::<Decision<MinimumVertexCover<SimpleGraph, i64>>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.inner().num_vertices(), 12);
@@ -41,17 +42,19 @@ fn test_ksatisfiability_to_decisionminimumvertexcover_unsatisfiable() {
             CNFClause::new(vec![1, 1, 1]),
         ],
     );
-    let reduction = ReduceTo::<Decision<MinimumVertexCover<SimpleGraph, i32>>>::reduce_to(&source);
+    let reduction = ReduceTo::<Decision<MinimumVertexCover<SimpleGraph, i64>>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.bound(), &7);
-    assert!(BruteForce::new().find_witness(target).is_none());
+    assert!(BruteForce::new().solve(target).unwrap().is_none());
 }
 
 #[test]
 fn test_ksatisfiability_to_decisionminimumvertexcover_structure_and_bound() {
     let source = KSatisfiability::<K3>::new(2, vec![CNFClause::new(vec![1, -1, 2])]);
-    let reduction = ReduceTo::<Decision<MinimumVertexCover<SimpleGraph, i32>>>::reduce_to(&source);
+    let reduction = ReduceTo::<Decision<MinimumVertexCover<SimpleGraph, i64>>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.inner().num_vertices(), 7);
@@ -68,12 +71,18 @@ fn test_ksatisfiability_to_decisionminimumvertexcover_extract_solution() {
             CNFClause::new(vec![-1, -2, 3]),
         ],
     );
-    let reduction = ReduceTo::<Decision<MinimumVertexCover<SimpleGraph, i32>>>::reduce_to(&source);
-    let cover = vec![0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0];
+    let reduction = ReduceTo::<Decision<MinimumVertexCover<SimpleGraph, i64>>>::reduce_to(&source)
+        .expect("reduction should succeed");
+    let cover = vec![
+        false, true, false, true, true, false, true, true, false, true, true, false,
+    ];
 
     assert_eq!(
-        reduction.target_problem().evaluate(&cover),
+        reduction.target_problem().evaluate(&cover).unwrap(),
         crate::types::Or(true)
     );
-    assert_eq!(reduction.extract_solution(&cover), vec![0, 0, 1]);
+    assert_eq!(
+        reduction.extract_solution(&cover).unwrap(),
+        vec![false, false, true]
+    );
 }
diff --git a/src/unit_tests/rules/ksatisfiability_directedtwocommodityintegralflow.rs b/src/unit_tests/rules/ksatisfiability_directedtwocommodityintegralflow.rs
index 6ed29abea..6ad979fc3 100644
--- a/src/unit_tests/rules/ksatisfiability_directedtwocommodityintegralflow.rs
+++ b/src/unit_tests/rules/ksatisfiability_directedtwocommodityintegralflow.rs
@@ -1,13 +1,11 @@
 #[cfg(feature = "example-db")]
 use super::canonical_rule_example_specs;
 use super::*;
-#[cfg(feature = "ilp-solver")]
 use crate::models::algebraic::ILP;
 use crate::models::formula::CNFClause;
 #[cfg(feature = "example-db")]
 use crate::models::graph::DirectedTwoCommodityIntegralFlow;
 use crate::rules::{ReduceTo, ReductionGraph, ReductionResult};
-#[cfg(feature = "ilp-solver")]
 use crate::solvers::ILPSolver;
 use crate::traits::Problem;
 use crate::variant::K3;
@@ -32,31 +30,27 @@ fn unsatisfiable_instance() -> KSatisfiability<K3> {
     )
 }
 
-fn all_assignments(num_vars: usize) -> Vec<Vec<usize>> {
+fn all_assignments(num_vars: usize) -> Vec<Vec<bool>> {
     (0..(1usize << num_vars))
-        .map(|mask| {
-            (0..num_vars)
-                .map(|bit| usize::from(((mask >> bit) & 1) == 1))
-                .collect()
-        })
+        .map(|mask| (0..num_vars).map(|bit| ((mask >> bit) & 1) == 1).collect())
         .collect()
 }
 
-#[cfg(feature = "ilp-solver")]
 fn solve_target_via_ilp(
     problem: &crate::models::graph::DirectedTwoCommodityIntegralFlow,
 ) -> Option<Vec<usize>> {
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(problem);
-    let ilp_solution = ILPSolver::new().solve(reduction.target_problem())?;
-    let extracted = reduction.extract_solution(&ilp_solution);
-    problem.evaluate(&extracted).0.then_some(extracted)
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(problem).expect("reduction should succeed");
+    let ilp_solution = ILPSolver::new().solve(reduction.target_problem()).ok()?;
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    problem.evaluate(&extracted).unwrap().0.then_some(extracted)
 }
 
 #[test]
 fn test_ksatisfiability_to_directedtwocommodityintegralflow_structure() {
     let source = issue_example();
     let reduction =
-        ReduceTo::<crate::models::graph::DirectedTwoCommodityIntegralFlow>::reduce_to(&source);
+        ReduceTo::<crate::models::graph::DirectedTwoCommodityIntegralFlow>::reduce_to(&source)
+            .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 36);
@@ -71,14 +65,15 @@ fn test_ksatisfiability_to_directedtwocommodityintegralflow_assignment_encoding_
 ) {
     let source = issue_example();
     let reduction =
-        ReduceTo::<crate::models::graph::DirectedTwoCommodityIntegralFlow>::reduce_to(&source);
+        ReduceTo::<crate::models::graph::DirectedTwoCommodityIntegralFlow>::reduce_to(&source)
+            .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     for assignment in all_assignments(source.num_vars()) {
         let flow = reduction.encode_assignment(&assignment);
         assert_eq!(
-            source.evaluate(&assignment).0,
-            target.evaluate(&flow).0,
+            source.evaluate(&assignment).unwrap().0,
+            target.evaluate(&flow).unwrap().0,
             "assignment {:?} should preserve satisfiability through the encoded flow",
             assignment
         );
@@ -90,36 +85,43 @@ fn test_ksatisfiability_to_directedtwocommodityintegralflow_extract_solution_fro
 {
     let source = issue_example();
     let reduction =
-        ReduceTo::<crate::models::graph::DirectedTwoCommodityIntegralFlow>::reduce_to(&source);
+        ReduceTo::<crate::models::graph::DirectedTwoCommodityIntegralFlow>::reduce_to(&source)
+            .expect("reduction should succeed");
 
-    let assignment = vec![1, 1, 0];
+    let assignment = vec![true, true, false];
     let flow = reduction.encode_assignment(&assignment);
-    assert!(reduction.target_problem().evaluate(&flow).0);
-    assert_eq!(reduction.extract_solution(&flow), assignment);
+    assert!(reduction.target_problem().evaluate(&flow).unwrap().0);
+    assert_eq!(reduction.extract_solution(&flow).unwrap(), assignment);
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_ksatisfiability_to_directedtwocommodityintegralflow_closed_loop() {
     let source = issue_example();
     let reduction =
-        ReduceTo::<crate::models::graph::DirectedTwoCommodityIntegralFlow>::reduce_to(&source);
+        ReduceTo::<crate::models::graph::DirectedTwoCommodityIntegralFlow>::reduce_to(&source)
+            .expect("reduction should succeed");
 
     let target_solution = solve_target_via_ilp(reduction.target_problem())
         .expect("satisfiable source instance should produce a feasible two-commodity flow");
 
-    assert!(reduction.target_problem().evaluate(&target_solution).0);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap()
+            .0
+    );
 
-    let extracted = reduction.extract_solution(&target_solution);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_ksatisfiability_to_directedtwocommodityintegralflow_unsatisfiable() {
     let source = unsatisfiable_instance();
     let reduction =
-        ReduceTo::<crate::models::graph::DirectedTwoCommodityIntegralFlow>::reduce_to(&source);
+        ReduceTo::<crate::models::graph::DirectedTwoCommodityIntegralFlow>::reduce_to(&source)
+            .expect("reduction should succeed");
     let maybe_solution = solve_target_via_ilp(reduction.target_problem());
     assert!(
         maybe_solution.is_none(),
@@ -155,7 +157,10 @@ fn test_ksatisfiability_to_directedtwocommodityintegralflow_canonical_example_sp
         serde_json::json!(2)
     );
     assert_eq!(example.solutions.len(), 1);
-    assert_eq!(example.solutions[0].source_config, vec![1, 1, 0]);
+    assert_eq!(
+        example.solutions[0].source_config,
+        serde_json::json!([true, true, false])
+    );
 
     let source: KSatisfiability<K3> = serde_json::from_value(example.source.instance.clone())
         .expect("source example deserializes");
@@ -163,10 +168,10 @@ fn test_ksatisfiability_to_directedtwocommodityintegralflow_canonical_example_sp
         serde_json::from_value(example.target.instance.clone())
             .expect("target example deserializes");
 
-    assert!(source
-        .evaluate(&example.solutions[0].source_config)
-        .is_valid());
-    assert!(target
-        .evaluate(&example.solutions[0].target_config)
-        .is_valid());
+    let source_config: Vec<bool> =
+        serde_json::from_value(example.solutions[0].source_config.clone()).unwrap();
+    let target_config: Vec<usize> =
+        serde_json::from_value(example.solutions[0].target_config.clone()).unwrap();
+    assert!(source.evaluate(&source_config).unwrap().is_valid());
+    assert!(target.evaluate(&target_config).unwrap().is_valid());
 }
diff --git a/src/unit_tests/rules/ksatisfiability_feasibleregisterassignment.rs b/src/unit_tests/rules/ksatisfiability_feasibleregisterassignment.rs
index 457ef61de..ef7624f3d 100644
--- a/src/unit_tests/rules/ksatisfiability_feasibleregisterassignment.rs
+++ b/src/unit_tests/rules/ksatisfiability_feasibleregisterassignment.rs
@@ -6,6 +6,66 @@ use crate::traits::Problem;
 use crate::types::Or;
 use std::collections::BTreeSet;
 
+fn forward_witness(source: &KSatisfiability<K3>, values: &[bool]) -> Vec<usize> {
+    assert!(source.evaluate(&values.to_vec()).unwrap().0);
+    let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(source).unwrap();
+    let target = reduction.target_problem();
+    let a = reduction.source_variables.len();
+    let mut order = Vec::new();
+    let mut done = vec![false; target.num_vertices()];
+    fn append(order: &mut Vec<usize>, done: &mut [bool], vertex: usize) {
+        assert!(!done[vertex]);
+        order.push(vertex);
+        done[vertex] = true;
+    }
+    // Consume every use of the first leaf before its opposite overwrites S.
+    for (compact, &original) in reduction.source_variables.iter().enumerate() {
+        let (first, second) = if values[original] {
+            (s_pos_idx(compact), s_neg_idx(a, compact))
+        } else {
+            (s_neg_idx(a, compact), s_pos_idx(compact))
+        };
+        append(&mut order, &mut done, first);
+        for &(consumer, dependency) in target.arcs() {
+            if dependency == first {
+                append(&mut order, &mut done, consumer);
+            }
+        }
+        append(&mut order, &mut done, second);
+    }
+    // Every true occurrence has r available; consume it before writing rbar.
+    for clause in 0..source.num_clauses() {
+        for slot in 0..3 {
+            if done[r_idx(a, clause, slot)] {
+                append(&mut order, &mut done, p_idx(a, clause, slot));
+                append(&mut order, &mut done, rbar_idx(a, clause, slot));
+            }
+        }
+    }
+    // A true position breaks the clause's cyclic register dependency.
+    for (clause, literals) in source.clauses().iter().enumerate() {
+        let start = literals
+            .literals
+            .iter()
+            .position(|&literal| values[literal.unsigned_abs() as usize - 1] == (literal > 0))
+            .unwrap();
+        for offset in 0..3 {
+            let slot = (start + offset) % 3;
+            if !done[r_idx(a, clause, slot)] {
+                append(&mut order, &mut done, r_idx(a, clause, slot));
+                append(&mut order, &mut done, p_idx(a, clause, slot));
+            }
+            append(&mut order, &mut done, q_idx(a, clause, slot));
+        }
+    }
+    assert!(done.iter().all(|&value| value));
+    let mut positions = vec![0; order.len()];
+    for (position, vertex) in order.into_iter().enumerate() {
+        positions[vertex] = position;
+    }
+    positions
+}
+
 fn issue_example() -> KSatisfiability<K3> {
     KSatisfiability::<K3>::new(
         3,
@@ -19,7 +79,8 @@ fn issue_example() -> KSatisfiability<K3> {
 #[test]
 fn test_ksatisfiability_to_feasible_register_assignment_structure() {
     let source = issue_example();
-    let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source);
+    let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 30);
@@ -64,29 +125,35 @@ fn test_ksatisfiability_to_feasible_register_assignment_structure() {
 #[test]
 fn test_ksatisfiability_to_feasible_register_assignment_extract_solution() {
     let source = KSatisfiability::<K3>::new(2, vec![CNFClause::new(vec![1, -2, 1])]);
-    let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source);
-    let mut realization: Vec<usize> = (0..reduction.target_problem().num_vertices()).collect();
-    realization.swap(s_pos_idx(1), s_neg_idx(2, 1));
+    let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
+    let realization = forward_witness(&source, &[true, false]);
+    assert!(reduction.target_problem().evaluate(&realization).unwrap().0);
 
-    let extracted = reduction.extract_solution(&realization);
+    let extracted = reduction.extract_solution(&realization).unwrap();
 
-    assert_eq!(extracted, vec![1, 0]);
+    assert_eq!(extracted, vec![true, false]);
 }
 
 #[test]
 fn test_ksatisfiability_to_feasible_register_assignment_closed_loop_via_ilp() {
     let source = issue_example();
-    let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source);
-    let fra_to_ilp = ReduceTo::<ILP<i32>>::reduce_to(reduction.target_problem());
+    let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
+    let fra_to_ilp = ReduceTo::<ILP<i64>>::reduce_to(reduction.target_problem())
+        .expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(fra_to_ilp.target_problem())
         .expect("satisfiable FRA gadget should reduce to a feasible ILP");
-    let fra_solution = fra_to_ilp.extract_solution(&ilp_solution);
-    assert_eq!(reduction.target_problem().evaluate(&fra_solution), Or(true));
+    let fra_solution = fra_to_ilp.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(
+        reduction.target_problem().evaluate(&fra_solution).unwrap(),
+        Or(true)
+    );
 
-    let extracted = reduction.extract_solution(&fra_solution);
-    assert_eq!(source.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&fra_solution).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -98,13 +165,140 @@ fn test_ksatisfiability_to_feasible_register_assignment_unsatisfiable_instance()
             CNFClause::new(vec![-1, -1, -1]),
         ],
     );
-    let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source);
-    let fra_to_ilp = ReduceTo::<ILP<i32>>::reduce_to(reduction.target_problem());
+    let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
+    let fra_to_ilp = ReduceTo::<ILP<i64>>::reduce_to(reduction.target_problem())
+        .expect("reduction should succeed");
 
     assert!(
-        ILPSolver::new()
-            .solve(fra_to_ilp.target_problem())
-            .is_none(),
+        ILPSolver::new().solve(fra_to_ilp.target_problem()).is_err(),
         "an unsatisfiable source formula should yield an infeasible FRA instance"
     );
 }
+
+#[test]
+fn native_empty_clause_is_infeasible_and_empty_conjunction_is_feasible() {
+    for num_vars in [0, 3] {
+        let source =
+            KSatisfiability::<K3>::try_new_allow_less(num_vars, vec![CNFClause::new(vec![])])
+                .unwrap();
+        let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source).unwrap();
+        assert_eq!(reduction.target_problem().num_vertices(), 3);
+        for config in [
+            vec![0, 1, 2],
+            vec![0, 2, 1],
+            vec![1, 0, 2],
+            vec![1, 2, 0],
+            vec![2, 0, 1],
+            vec![2, 1, 0],
+        ] {
+            assert!(!reduction.target_problem().evaluate(&config).unwrap().0);
+            assert!(reduction.extract_solution(&config).is_err());
+        }
+        let source = KSatisfiability::<K3>::new(num_vars, vec![]);
+        let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source).unwrap();
+        assert_eq!(reduction.target_problem().num_vertices(), 0);
+        assert_eq!(
+            reduction.extract_solution(&vec![]).unwrap(),
+            vec![false; num_vars]
+        );
+    }
+}
+
+#[test]
+fn short_repeated_and_mixed_clauses_have_complete_forward_witnesses() {
+    for formula in [
+        vec![vec![5]],
+        vec![vec![-5]],
+        vec![vec![5, 2]],
+        vec![vec![-5, 2]],
+        vec![vec![5, 5, 5]],
+        vec![vec![5, -5, 5]],
+        vec![vec![5, 1, -3], vec![-1, 5, 2], vec![-3, 2, -5]],
+    ] {
+        let source = KSatisfiability::<K3>::try_new_allow_less(
+            6,
+            formula.into_iter().map(CNFClause::new).collect(),
+        )
+        .unwrap();
+        let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source).unwrap();
+        let a = reduction.source_variables.len();
+        assert_eq!(
+            reduction.target_problem().num_same_register_pairs(),
+            a + 3 * source.num_clauses()
+        );
+        assert_eq!(
+            reduction.target_problem().num_arcs(),
+            15 * source.num_clauses()
+        );
+        for mask in 0..64 {
+            let values: Vec<_> = (0..6).map(|bit| mask & (1 << bit) != 0).collect();
+            if source.evaluate(&values).unwrap().0 {
+                let config = forward_witness(&source, &values);
+                assert!(reduction.target_problem().evaluate(&config).unwrap().0);
+                let extracted = reduction.extract_solution(&config).unwrap();
+                assert!(source.evaluate(&extracted).unwrap().0);
+                for original in 0..6 {
+                    assert_eq!(
+                        extracted[original],
+                        reduction.source_variables.contains(&original) && values[original]
+                    );
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn short_clause_padding_matches_its_equivalent_three_literal_formula() {
+    let short = KSatisfiability::<K3>::try_new_allow_less(
+        3,
+        vec![CNFClause::new(vec![3]), CNFClause::new(vec![-3])],
+    )
+    .unwrap();
+    let padded = KSatisfiability::<K3>::new(
+        3,
+        vec![
+            CNFClause::new(vec![3, 3, 3]),
+            CNFClause::new(vec![-3, -3, -3]),
+        ],
+    );
+    let a = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&short).unwrap();
+    let b = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&padded).unwrap();
+    assert_eq!(a.target_problem().arcs(), b.target_problem().arcs());
+    assert_eq!(
+        a.target_problem().assignment(),
+        b.target_problem().assignment()
+    );
+    assert_eq!(
+        a.target_problem().num_vertices(),
+        b.target_problem().num_vertices()
+    );
+}
+
+#[test]
+fn invalid_realizations_are_rejected() {
+    let source = issue_example();
+    let reduction = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source).unwrap();
+    let n = reduction.target_problem().num_vertices();
+    for config in [vec![], vec![n; n], vec![0; n], (0..n).collect()] {
+        assert!(reduction.extract_solution(&config).is_err());
+    }
+}
+
+#[test]
+fn sparse_high_variable_indices_only_change_the_inverse_map() {
+    let largest = usize::try_from(i64::MAX).unwrap_or(usize::MAX);
+    let literal = i64::try_from(largest).unwrap();
+    let source = KSatisfiability::<K3>::new(largest, vec![CNFClause::new(vec![literal; 3])]);
+    let small = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1; 3])]);
+    let a = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&source).unwrap();
+    let b = ReduceTo::<FeasibleRegisterAssignment>::reduce_to(&small).unwrap();
+    assert_eq!(a.target_problem().arcs(), b.target_problem().arcs());
+    assert_eq!(
+        a.target_problem().assignment(),
+        b.target_problem().assignment()
+    );
+    assert_eq!(a.target_problem().num_vertices(), 14);
+    // The enormous source witness is deliberately not materialized.
+}
diff --git a/src/unit_tests/rules/ksatisfiability_kclique.rs b/src/unit_tests/rules/ksatisfiability_kclique.rs
index c9886f1c1..0e0bf789b 100644
--- a/src/unit_tests/rules/ksatisfiability_kclique.rs
+++ b/src/unit_tests/rules/ksatisfiability_kclique.rs
@@ -1,179 +1,196 @@
 use super::*;
 use crate::models::formula::CNFClause;
-use crate::models::graph::KClique;
 use crate::solvers::BruteForce;
-use crate::topology::SimpleGraph;
 use crate::traits::Problem;
-use crate::variant::K3;
 
 #[test]
 fn test_ksatisfiability_to_kclique_closed_loop() {
-    // (x1 ∨ x2 ∨ x3) ∧ (¬x1 ∨ ¬x2 ∨ x3), n=3, m=2
-    let ksat = KSatisfiability::<K3>::new(
+    let source = KSatisfiability::<K3>::new(
         3,
         vec![
-            CNFClause::new(vec![1, 2, 3]),   // x1 ∨ x2 ∨ x3
-            CNFClause::new(vec![-1, -2, 3]), // ¬x1 ∨ ¬x2 ∨ x3
+            CNFClause::new(vec![1, 2, 3]),
+            CNFClause::new(vec![-1, -2, 3]),
         ],
     );
-    let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&source).unwrap();
     let target = reduction.target_problem();
-
-    // Verify structure: 3*2 = 6 vertices, k = 2
-    assert_eq!(target.num_vertices(), 6);
-    assert_eq!(target.k(), 2);
-
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(target);
-    assert!(!solutions.is_empty());
-
-    // Every KClique solution must map back to a satisfying 3-SAT assignment
-    for sol in &solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert_eq!(extracted.len(), 3);
-        assert!(ksat.evaluate(&extracted));
+    assert_eq!(
+        (target.num_vertices(), target.num_edges(), target.k()),
+        (7, 13, 3)
+    );
+    for witness in BruteForce::new().find_all_witnesses(target).unwrap() {
+        assert!(witness[6]);
+        assert!(
+            source
+                .evaluate(&reduction.extract_solution(&witness).unwrap())
+                .unwrap()
+                .0
+        );
     }
-}
-
-#[test]
-fn test_ksatisfiability_to_kclique_unsatisfiable() {
-    // (x1 ∨ x1 ∨ x1) ∧ (¬x1 ∨ ¬x1 ∨ ¬x1)
-    // x1=T satisfies C0 but not C1; x1=F satisfies C1 but not C0.
-    let ksat = KSatisfiability::<K3>::new(
+    let witness = vec![false, false, true, true, false, false, true];
+    assert_eq!(
+        reduction.extract_solution(&witness).unwrap(),
+        vec![false, false, true]
+    );
+    let no = KSatisfiability::<K3>::new(
         1,
         vec![
             CNFClause::new(vec![1, 1, 1]),
             CNFClause::new(vec![-1, -1, -1]),
         ],
     );
-    let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&ksat);
-    let target = reduction.target_problem();
-
-    // 6 vertices, k=2
-    assert_eq!(target.num_vertices(), 6);
-    assert_eq!(target.k(), 2);
-
-    // All cross-clause pairs contradict (x1 vs ¬x1), so no edges → no 2-clique.
-    assert_eq!(target.num_edges(), 0);
-
-    let solver = BruteForce::new();
-    let solution = solver.find_witness(target);
-    assert!(solution.is_none());
+    let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&no).unwrap();
+    assert_eq!(reduction.target_problem().num_edges(), 6);
+    assert!(BruteForce::new()
+        .solve(reduction.target_problem())
+        .unwrap()
+        .is_none());
 }
 
 #[test]
-fn test_ksatisfiability_to_kclique_single_clause() {
-    // Single clause: (x1 ∨ x2 ∨ x3) — always satisfiable (7/8 assignments)
-    // With m=1, k=1, any single vertex is a 1-clique.
-    let ksat = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&ksat);
-    let target = reduction.target_problem();
-
-    // 3 vertices, k=1, no edges needed for 1-clique
-    assert_eq!(target.num_vertices(), 3);
-    assert_eq!(target.k(), 1);
-
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(target);
-
-    // Each solution maps to a satisfying assignment
-    let mut sat_assignments = std::collections::HashSet::new();
-    for sol in &solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(ksat.evaluate(&extracted));
-        sat_assignments.insert(extracted);
+fn test_kclique_empty_formulas_and_short_clauses() {
+    for n in [0, 3, 4] {
+        let source = KSatisfiability::<K3>::new(n, vec![]);
+        let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&source).unwrap();
+        assert_eq!(
+            (
+                reduction.target_problem().num_vertices(),
+                reduction.target_problem().k()
+            ),
+            (1, 1)
+        );
+        assert_eq!(
+            reduction.extract_solution(&vec![true]).unwrap(),
+            vec![false; n]
+        );
+    }
+    for clauses in [
+        vec![vec![]],
+        vec![vec![], vec![]],
+        vec![vec![], vec![1]],
+        vec![vec![1], vec![-1]],
+        vec![vec![1], vec![2, -1]],
+    ] {
+        let source = KSatisfiability::<K3>::new_allow_less(
+            2,
+            clauses.into_iter().map(CNFClause::new).collect(),
+        );
+        let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&source).unwrap();
+        let sat = BruteForce::new().solve(&source).unwrap().is_some();
+        let solutions = BruteForce::new()
+            .find_all_witnesses(reduction.target_problem())
+            .unwrap();
+        assert_eq!(!solutions.is_empty(), sat);
+        for witness in solutions {
+            assert!(
+                source
+                    .evaluate(&reduction.extract_solution(&witness).unwrap())
+                    .unwrap()
+                    .0
+            );
+        }
     }
-    // 3 clique witnesses but they may map to different or same assignments
-    assert!(!sat_assignments.is_empty());
 }
 
 #[test]
-fn test_ksatisfiability_to_kclique_structure() {
-    // Verify edge construction for a concrete example.
-    // (x1 ∨ x2 ∨ x3) ∧ (¬x1 ∨ ¬x2 ∨ x3)
-    // Clause 0 literals: [1, 2, 3], Clause 1 literals: [-1, -2, 3]
-    // Cross-clause pairs:
-    //   (0,0)-(1,0): 1 vs -1 → contradict → no edge
-    //   (0,0)-(1,1): 1 vs -2 → ok → edge (0,4)
-    //   (0,0)-(1,2): 1 vs 3  → ok → edge (0,5)
-    //   (0,1)-(1,0): 2 vs -1 → ok → edge (1,3)
-    //   (0,1)-(1,1): 2 vs -2 → contradict → no edge
-    //   (0,1)-(1,2): 2 vs 3  → ok → edge (1,5)
-    //   (0,2)-(1,0): 3 vs -1 → ok → edge (2,3)
-    //   (0,2)-(1,1): 3 vs -2 → ok → edge (2,4)
-    //   (0,2)-(1,2): 3 vs 3  → ok → edge (2,5)
-    // Total: 7 edges
-    let ksat = KSatisfiability::<K3>::new(
-        3,
-        vec![
-            CNFClause::new(vec![1, 2, 3]),
-            CNFClause::new(vec![-1, -2, 3]),
-        ],
-    );
-    let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&ksat);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.num_vertices(), 6);
-    assert_eq!(target.num_edges(), 7);
-    assert_eq!(target.k(), 2);
+fn test_kclique_all_two_clause_formulas_and_target_selections() {
+    // All ordered clauses of width 0..3 on one variable, including repetitions
+    // and tautologies; every ordered pair and every raw target bitvector.
+    let mut clauses = vec![vec![]];
+    for width in 1..=3 {
+        for mask in 0..(1usize << width) {
+            clauses.push(
+                (0..width)
+                    .map(|p| if mask & (1 << p) == 0 { 1 } else { -1 })
+                    .collect(),
+            );
+        }
+    }
+    for a in &clauses {
+        for b in &clauses {
+            let source = KSatisfiability::<K3>::new_allow_less(
+                1,
+                vec![CNFClause::new(a.clone()), CNFClause::new(b.clone())],
+            );
+            let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&source).unwrap();
+            let target = reduction.target_problem();
+            let t = a.len() + b.len();
+            assert_eq!(target.num_vertices(), t.max(2) + 1);
+            assert_eq!(target.k(), 3);
+            let mut source_yes = false;
+            for value in [false, true] {
+                let assignment = vec![value];
+                if source.evaluate(&assignment).unwrap().0 {
+                    source_yes = true;
+                    let mut witness = vec![false; target.num_vertices()];
+                    let mut offset = 0;
+                    for clause in [a, b] {
+                        let p = clause.iter().position(|&l| (l > 0) == value).unwrap();
+                        witness[offset + p] = true;
+                        offset += clause.len();
+                    }
+                    witness[t] = true;
+                    assert!(target.evaluate(&witness).unwrap().0);
+                }
+            }
+            let mut target_yes = false;
+            for mask in 0..(1usize << target.num_vertices()) {
+                let witness: Vec<_> = (0..target.num_vertices())
+                    .map(|v| mask & (1 << v) != 0)
+                    .collect();
+                if target.evaluate(&witness).unwrap().0 {
+                    target_yes = true;
+                    assert!(
+                        source
+                            .evaluate(&reduction.extract_solution(&witness).unwrap())
+                            .unwrap()
+                            .0
+                    );
+                } else {
+                    assert!(reduction.extract_solution(&witness).is_err());
+                }
+            }
+            assert_eq!(source_yes, target_yes);
+        }
+    }
 }
 
 #[test]
-fn test_ksatisfiability_to_kclique_three_clauses() {
-    // (x1 ∨ x2 ∨ x3) ∧ (¬x1 ∨ x2 ∨ ¬x3) ∧ (x1 ∨ ¬x2 ∨ x3)
-    let ksat = KSatisfiability::<K3>::new(
+fn test_kclique_rejects_malformed_or_non_clique_selections() {
+    let source = KSatisfiability::<K3>::new_allow_less(
         3,
-        vec![
-            CNFClause::new(vec![1, 2, 3]),
-            CNFClause::new(vec![-1, 2, -3]),
-            CNFClause::new(vec![1, -2, 3]),
-        ],
+        vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1, 3])],
     );
-    let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&ksat);
-    let target = reduction.target_problem();
-
-    // 9 vertices, k=3
-    assert_eq!(target.num_vertices(), 9);
-    assert_eq!(target.k(), 3);
-
-    let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(target);
-    assert!(!solutions.is_empty());
-
-    // Verify all solutions map back correctly
-    for sol in &solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert_eq!(extracted.len(), 3);
-        assert!(ksat.evaluate(&extracted));
+    let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&source).unwrap();
+    for bad in [
+        vec![],
+        vec![true; 6],
+        vec![false; 5],
+        vec![true, true, false, false, true],
+        vec![true, false, true, false, true],
+    ] {
+        assert!(reduction.extract_solution(&bad).is_err());
     }
 }
 
 #[test]
-fn test_ksatisfiability_to_kclique_extract_solution_example() {
-    // Verify a specific known solution.
-    // (x1 ∨ x2 ∨ x3) ∧ (¬x1 ∨ ¬x2 ∨ x3)
-    // Assignment x1=F, x2=F, x3=T:
-    //   Clause 0: x3 (position 2) true → vertex 2
-    //   Clause 1: ¬x1 (position 0) true → vertex 3
-    // These vertices should be connected (3 vs -1: not contradictory).
-    let ksat = KSatisfiability::<K3>::new(
-        3,
-        vec![
-            CNFClause::new(vec![1, 2, 3]),
-            CNFClause::new(vec![-1, -2, 3]),
-        ],
+fn test_kclique_count_boundaries() {
+    assert_eq!(clique_sizes(0, []).unwrap(), (1, 1));
+    assert_eq!(clique_sizes(3, [0, 0, 1]).unwrap(), (4, 4));
+    assert_eq!(clique_sizes(2, [3, 3]).unwrap(), (7, 3));
+    for (m, lengths) in [
+        (2, vec![usize::MAX, 1]),
+        (1, vec![usize::MAX]),
+        (usize::MAX, vec![]),
+    ] {
+        assert!(matches!(
+            clique_sizes(m, lengths),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+    assert_eq!(
+        clique_sizes(usize::MAX - 1, []).unwrap(),
+        (usize::MAX, usize::MAX)
     );
-    let reduction = ReduceTo::<KClique<SimpleGraph>>::reduce_to(&ksat);
-    let target = reduction.target_problem();
-
-    // Vertices 2 and 3 selected
-    let specific_config = vec![0, 0, 1, 1, 0, 0];
-    assert!(target.evaluate(&specific_config));
-
-    let extracted = reduction.extract_solution(&specific_config);
-    // Vertex 2 = clause 0, pos 2 → literal 3 (x3) → x3=T → assignment[2]=1
-    // Vertex 3 = clause 1, pos 0 → literal -1 (¬x1) → x1=F → assignment[0]=0
-    // Unset variables default to 0.
-    assert_eq!(extracted, vec![0, 0, 1]);
-    assert!(ksat.evaluate(&extracted));
+    assert_eq!(clique_sizes(1, [usize::MAX - 1]).unwrap(), (usize::MAX, 2));
 }
diff --git a/src/unit_tests/rules/ksatisfiability_kernel.rs b/src/unit_tests/rules/ksatisfiability_kernel.rs
index 38776937e..200045a36 100644
--- a/src/unit_tests/rules/ksatisfiability_kernel.rs
+++ b/src/unit_tests/rules/ksatisfiability_kernel.rs
@@ -8,7 +8,7 @@ use crate::variant::K3;
 #[test]
 fn test_ksatisfiability_to_kernel_structure() {
     let source = KSatisfiability::<K3>::new(2, vec![CNFClause::new(vec![1, -2, 1])]);
-    let reduction = ReduceTo::<Kernel>::reduce_to(&source);
+    let reduction = ReduceTo::<Kernel>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 7);
@@ -39,7 +39,7 @@ fn test_ksatisfiability_to_kernel_closed_loop() {
             CNFClause::new(vec![-1, -2, 3]),
         ],
     );
-    let reduction = ReduceTo::<Kernel>::reduce_to(&source);
+    let reduction = ReduceTo::<Kernel>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -57,20 +57,138 @@ fn test_ksatisfiability_to_kernel_unsatisfiable_instance_has_no_kernel() {
             CNFClause::new(vec![-1, -1, -1]),
         ],
     );
-    let reduction = ReduceTo::<Kernel>::reduce_to(&source);
+    let reduction = ReduceTo::<Kernel>::reduce_to(&source).expect("reduction should succeed");
 
     assert!(BruteForce::new()
-        .find_witness(reduction.target_problem())
+        .solve(reduction.target_problem())
+        .unwrap()
         .is_none());
 }
 
 #[test]
 fn test_ksatisfiability_to_kernel_extract_solution_reads_variable_gadgets() {
     let source = KSatisfiability::<K3>::new(2, vec![CNFClause::new(vec![1, -2, 1])]);
-    let reduction = ReduceTo::<Kernel>::reduce_to(&source);
+    let reduction = ReduceTo::<Kernel>::reduce_to(&source).expect("reduction should succeed");
 
     assert_eq!(
-        reduction.extract_solution(&[1, 0, 0, 1, 0, 0, 0]),
-        vec![1, 0]
+        reduction
+            .extract_solution(&vec![true, false, false, true, false, false, false])
+            .unwrap(),
+        vec![true, false]
+    );
+}
+
+#[test]
+fn test_ksatisfiability_to_kernel_native_clause_domain() {
+    use crate::traits::Problem;
+    let mut clauses = vec![vec![]];
+    for len in 1..=3 {
+        for mask in 0..(1 << len) {
+            clauses.push(
+                (0..len)
+                    .map(|j| if mask & (1 << j) == 0 { 1 } else { -1 })
+                    .collect(),
+            );
+        }
+    }
+    let mut formulas = vec![vec![]];
+    for first in &clauses {
+        formulas.push(vec![first.clone()]);
+        for second in &clauses {
+            formulas.push(vec![first.clone(), second.clone()]);
+        }
+    }
+    for formula in formulas {
+        let source = KSatisfiability::<K3>::try_new_allow_less(
+            1,
+            formula.iter().cloned().map(CNFClause::new).collect(),
+        )
+        .unwrap();
+        let reduction = ReduceTo::<Kernel>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        let active = usize::from(formula.iter().any(|clause| !clause.is_empty()));
+        let occurrences: usize = formula.iter().map(Vec::len).sum();
+        assert_eq!(target.num_vertices(), 2 * active + 3 * formula.len());
+        assert_eq!(
+            target.num_arcs(),
+            2 * active + 3 * formula.len() + occurrences
+        );
+        let mut witnessed = [false; 2];
+        for mask in 0..(1usize << target.num_vertices()) {
+            let config = (0..target.num_vertices())
+                .map(|v| mask & (1 << v) != 0)
+                .collect();
+            if target.evaluate(&config).unwrap().0 {
+                let decoded = reduction.extract_solution(&config).unwrap();
+                assert!(source.evaluate(&decoded).unwrap().0);
+                witnessed[usize::from(decoded[0])] = true;
+            }
+        }
+        for value in [false, true] {
+            let satisfiable = source.evaluate(&vec![value]).unwrap().0;
+            if active == 1 {
+                assert_eq!(witnessed[usize::from(value)], satisfiable);
+            } else {
+                assert_eq!(witnessed[0], satisfiable);
+                assert!(!witnessed[1]);
+            }
+        }
+    }
+}
+
+#[test]
+fn test_ksatisfiability_to_kernel_sparse_inverse() {
+    use crate::traits::Problem;
+    for literals in [vec![5], vec![-5], vec![5, -2], vec![5, -5, 2]] {
+        let source =
+            KSatisfiability::<K3>::try_new_allow_less(6, vec![CNFClause::new(literals.clone())])
+                .unwrap();
+        let reduction = ReduceTo::<Kernel>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        let mut found = false;
+        for mask in 0..(1usize << target.num_vertices()) {
+            let config = (0..target.num_vertices())
+                .map(|v| mask & (1 << v) != 0)
+                .collect();
+            if target.evaluate(&config).unwrap().0 {
+                found = true;
+                let decoded = reduction.extract_solution(&config).unwrap();
+                assert_eq!(decoded.len(), 6);
+                assert!(source.evaluate(&decoded).unwrap().0);
+                for (variable, value) in decoded.iter().enumerate() {
+                    if !literals
+                        .iter()
+                        .any(|l| l.unsigned_abs() as usize == variable + 1)
+                    {
+                        assert!(!value);
+                    }
+                }
+            }
+        }
+        assert!(found);
+    }
+}
+
+#[test]
+fn test_ksatisfiability_to_kernel_rejects_non_kernel() {
+    let source = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1, 1, 1])]);
+    let reduction = ReduceTo::<Kernel>::reduce_to(&source).unwrap();
+    for config in [vec![], vec![false; 5], vec![true; 5], vec![false; 6]] {
+        assert!(reduction.extract_solution(&config).is_err());
+    }
+}
+
+#[test]
+fn test_ksatisfiability_to_kernel_huge_sparse_construction() {
+    let largest = usize::try_from(i64::MAX).unwrap_or(usize::MAX);
+    let literal = i64::try_from(largest).unwrap();
+    let source = KSatisfiability::<K3>::new(largest, vec![CNFClause::new(vec![literal; 3])]);
+    let compact = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1; 3])]);
+    let reduction = ReduceTo::<Kernel>::reduce_to(&source).unwrap();
+    let compact_reduction = ReduceTo::<Kernel>::reduce_to(&compact).unwrap();
+    assert_eq!(reduction.target_problem().num_vertices(), 5);
+    assert_eq!(
+        reduction.target_problem().graph().arcs(),
+        compact_reduction.target_problem().graph().arcs()
     );
 }
diff --git a/src/unit_tests/rules/ksatisfiability_minimumvertexcover.rs b/src/unit_tests/rules/ksatisfiability_minimumvertexcover.rs
index b1687007b..736120135 100644
--- a/src/unit_tests/rules/ksatisfiability_minimumvertexcover.rs
+++ b/src/unit_tests/rules/ksatisfiability_minimumvertexcover.rs
@@ -17,7 +17,8 @@ fn test_ksatisfiability_to_minimumvertexcover_closed_loop() {
             CNFClause::new(vec![-1, -2, 3]), // ~x1 v ~x2 v x3
         ],
     );
-    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&ksat)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Verify structure: 2*3 + 3*2 = 12 vertices
@@ -44,7 +45,8 @@ fn test_ksatisfiability_to_minimumvertexcover_unsatisfiable() {
             CNFClause::new(vec![1, 1, 1]),
         ],
     );
-    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&ksat)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // n=1, m=3 -> 2 + 9 = 11 vertices, minimum VC should be > n + 2m = 7
@@ -52,10 +54,10 @@ fn test_ksatisfiability_to_minimumvertexcover_unsatisfiable() {
     // for graphs with edges, but any superset works). The key property is:
     // SAT is satisfiable iff MVC has size <= n + 2m.
     let solver = BruteForce::new();
-    let witness = solver.find_witness(target);
+    let witness = solver.solve(target).unwrap();
     assert!(witness.is_some());
     let vc_config = witness.unwrap();
-    let vc_size: usize = vc_config.iter().sum();
+    let vc_size: usize = vc_config.iter().filter(|&&selected| selected).count();
     // Unsatisfiable -> minimum VC size > n + 2m = 1 + 6 = 7
     assert!(vc_size > 7);
 }
@@ -64,7 +66,8 @@ fn test_ksatisfiability_to_minimumvertexcover_unsatisfiable() {
 fn test_ksatisfiability_to_minimumvertexcover_single_clause() {
     // Single clause: (x1 v x2 v x3) — 7 out of 8 assignments satisfy it
     let ksat = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&ksat)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 2*3 + 3*1 = 9 vertices, 3 + 6 = 9 edges
@@ -88,7 +91,8 @@ fn test_ksatisfiability_to_minimumvertexcover_extract_solution() {
             CNFClause::new(vec![-1, -2, 3]),
         ],
     );
-    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&ksat)
+        .expect("reduction should succeed");
 
     // Literal vertices: u1(0), ~u1(1), u2(2), ~u2(3), u3(4), ~u3(5)
     // Clause 0 triangle: v6, v7, v8
@@ -101,20 +105,23 @@ fn test_ksatisfiability_to_minimumvertexcover_extract_solution() {
     //     u3(4) in cover -> edge (8,4) covered. Triangle covered by v6 and v7.
     //   Clause 1 (-1,-2,3): communication edges (9,1), (10,3), (11,4).
     //     All three endpoints (~u1, ~u2, u3) in cover. Pick any 2 from triangle: v9, v10.
-    let vc_config = vec![0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0];
+    let vc_config = vec![
+        false, true, false, true, true, false, true, true, false, true, true, false,
+    ];
     // Verify this is a valid vertex cover
     assert!(reduction.target_problem().is_valid_solution(&vc_config));
 
-    let extracted = reduction.extract_solution(&vc_config);
-    assert_eq!(extracted, vec![0, 0, 1]); // x1=F, x2=F, x3=T
-    assert!(ksat.evaluate(&extracted));
+    let extracted = reduction.extract_solution(&vc_config).unwrap();
+    assert_eq!(extracted, vec![false, false, true]); // x1=F, x2=F, x3=T
+    assert!(ksat.evaluate(&extracted).unwrap());
 }
 
 #[test]
 fn test_ksatisfiability_to_minimumvertexcover_all_negated() {
     // (~x1 v ~x2 v ~x3) — 7 satisfying assignments
     let ksat = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![-1, -2, -3])]);
-    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&ksat)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &ksat,
@@ -127,7 +134,8 @@ fn test_ksatisfiability_to_minimumvertexcover_all_negated() {
 fn test_ksatisfiability_to_minimumvertexcover_structure() {
     // Verify edge structure for a simple case
     let ksat = KSatisfiability::<K3>::new(2, vec![CNFClause::new(vec![1, -1, 2])]);
-    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&ksat)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // n=2, m=1 -> 4 + 3 = 7 vertices
@@ -137,8 +145,12 @@ fn test_ksatisfiability_to_minimumvertexcover_structure() {
 
     // Minimum cover size for satisfiable formula = n + 2m = 2 + 2 = 4
     let solver = BruteForce::new();
-    let witness = solver.find_witness(target);
+    let witness = solver.solve(target).unwrap();
     assert!(witness.is_some());
-    let vc_size: usize = witness.unwrap().iter().sum();
+    let vc_size: usize = witness
+        .unwrap()
+        .iter()
+        .filter(|&&selected| selected)
+        .count();
     assert_eq!(vc_size, 4);
 }
diff --git a/src/unit_tests/rules/ksatisfiability_monochromatictriangle.rs b/src/unit_tests/rules/ksatisfiability_monochromatictriangle.rs
index 6dfdfc691..eaa8484bd 100644
--- a/src/unit_tests/rules/ksatisfiability_monochromatictriangle.rs
+++ b/src/unit_tests/rules/ksatisfiability_monochromatictriangle.rs
@@ -1,69 +1,87 @@
+use super::add_equality_sender;
+use crate::models::algebraic::{LinearConstraint, ILP};
 use crate::models::formula::{CNFClause, KSatisfiability};
 use crate::models::graph::MonochromaticTriangle;
 use crate::rules::traits::{ReduceTo, ReductionResult};
-use crate::topology::{Graph, SimpleGraph};
+use crate::solvers::{ILPSolveError, ILPSolver};
+use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::variant::K3;
-use std::collections::BTreeSet;
 
-#[cfg(feature = "ilp-solver")]
-use crate::models::algebraic::ILP;
-#[cfg(feature = "ilp-solver")]
-use crate::solvers::ILPSolver;
+#[test]
+fn test_monochromatic_triangle_sender_all_colorings() {
+    let mut edges = vec![(0, 1), (2, 3)];
+    add_equality_sender(&mut edges, (0, 1), (2, 3), 4);
+    let sender = MonochromaticTriangle::new(SimpleGraph::new(7, edges));
+    assert_eq!(sender.num_edges(), 17);
+    assert_eq!(sender.num_triangles(), 19);
+    let mut extensions = [0, 0];
+    for bits in 0..(1 << 17) {
+        let coloring: Vec<bool> = (0..17).map(|i| bits & (1 << i) != 0).collect();
+        if sender.evaluate(&coloring).unwrap().0 {
+            assert_eq!(coloring[0], coloring[1]);
+            extensions[usize::from(coloring[0])] += 1;
+        }
+    }
+    // Both equal terminal assignments extend; no unequal one extends.
+    assert_eq!(extensions, [12, 12]);
+}
 
 #[test]
 fn test_ksatisfiability_to_monochromatic_triangle_structure() {
     let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source).unwrap();
     let target = reduction.target_problem();
-
-    assert_eq!(target.num_vertices(), 9);
-    assert_eq!(target.num_edges(), 12);
-    assert_eq!(target.triangles().len(), 4);
-
-    let expected_edges = BTreeSet::from([
-        (0, 3),
-        (0, 6),
-        (0, 7),
-        (1, 4),
-        (1, 6),
-        (1, 8),
-        (2, 5),
-        (2, 7),
-        (2, 8),
-        (6, 7),
-        (6, 8),
-        (7, 8),
-    ]);
-    let actual_edges: BTreeSet<_> = target
-        .graph()
-        .edges()
-        .into_iter()
-        .map(|(u, v)| if u < v { (u, v) } else { (v, u) })
-        .collect();
-    assert_eq!(actual_edges, expected_edges);
+    // N=5 logical variables, T=7 NAE triples, three senders per triple.
+    assert_eq!(target.num_vertices(), 104);
+    assert_eq!(target.num_edges(), 346);
+    assert_eq!(target.num_triangles(), 406);
 }
 
 #[test]
-fn test_ksatisfiability_to_monochromatic_triangle_complement_extraction() {
-    let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source);
-
-    // Negation edges all use color 1, so direct extraction gives (0,0,0),
-    // which does not satisfy (x1 v x2 v x3). The complement (1,1,1) does.
-    let target_coloring = vec![1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0];
-
-    assert!(
-        reduction.target_problem().evaluate(&target_coloring),
-        "the supplied target coloring must avoid monochromatic triangles"
+fn test_ksatisfiability_to_monochromatic_triangle_all_source_projections() {
+    let source = KSatisfiability::<K3>::new(
+        3,
+        vec![
+            CNFClause::new(vec![1, 2, 3]),
+            CNFClause::new(vec![-1, -2, -3]),
+        ],
     );
-
-    let extracted = reduction.extract_solution(&target_coloring);
-    assert_eq!(extracted, vec![1, 1, 1]);
-    assert!(source.evaluate(&extracted));
+    let reduction = ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source).unwrap();
+    let to_ilp = ReduceTo::<ILP<bool>>::reduce_to(reduction.target_problem()).unwrap();
+    let ilp = to_ilp.target_problem();
+    for bits in 0..8 {
+        let assignment: Vec<bool> = (0..3).map(|i| bits & (1 << i) != 0).collect();
+        for sentinel in [false, true] {
+            let mut constraints = ilp.constraints().to_vec();
+            for (i, value) in assignment.iter().copied().chain([false]).enumerate() {
+                constraints.push(LinearConstraint::eq(
+                    vec![(2 * i, 1)],
+                    i64::from(value ^ sentinel),
+                ));
+            }
+            let fixed = ILP::<bool>::new(
+                ilp.num_variables(),
+                constraints,
+                ilp.objective().to_vec(),
+                ilp.sense(),
+            )
+            .unwrap();
+            match ILPSolver::new().solve(&fixed) {
+                Ok(solution) => {
+                    assert!(source.evaluate(&assignment).unwrap().0);
+                    let coloring = to_ilp.extract_solution(&solution).unwrap();
+                    assert_eq!(reduction.extract_solution(&coloring).unwrap(), assignment);
+                    let swapped = coloring.iter().map(|value| !value).collect();
+                    assert_eq!(reduction.extract_solution(&swapped).unwrap(), assignment);
+                }
+                Err(ILPSolveError::Infeasible) => assert!(!source.evaluate(&assignment).unwrap().0),
+                Err(error) => panic!("unexpected solver error: {error}"),
+            }
+        }
+    }
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_ksatisfiability_to_monochromatic_triangle_closed_loop() {
     let source = KSatisfiability::<K3>::new(
@@ -73,16 +91,96 @@ fn test_ksatisfiability_to_monochromatic_triangle_closed_loop() {
             CNFClause::new(vec![-1, 3, 4]),
         ],
     );
-    let reduction = ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source);
-    let mono_to_ilp = ReduceTo::<ILP<bool>>::reduce_to(reduction.target_problem());
+    let reduction = ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source).unwrap();
+    let coloring = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    assert!(
+        source
+            .evaluate(&reduction.extract_solution(&coloring).unwrap())
+            .unwrap()
+            .0
+    );
+    assert!(reduction.extract_solution(&vec![]).is_err());
+}
+
+#[test]
+fn test_ksatisfiability_to_monochromatic_triangle_unsatisfiable_all_signs() {
+    // Every assignment falsifies exactly one of these eight distinct-variable clauses.
+    let clauses = (0..8)
+        .map(|bits| {
+            CNFClause::new(
+                (0..3)
+                    .map(|i| {
+                        if bits & (1 << i) == 0 {
+                            -(i + 1)
+                        } else {
+                            i + 1
+                        }
+                    })
+                    .collect(),
+            )
+        })
+        .collect();
+    let source = KSatisfiability::<K3>::new(3, clauses);
+    let reduction = ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source).unwrap();
+    assert_eq!(
+        ILPSolver::new().solve(reduction.target_problem()),
+        Err(ILPSolveError::Infeasible)
+    );
+}
 
-    let ilp_solution = ILPSolver::new()
-        .solve(mono_to_ilp.target_problem())
-        .expect("reduced MonochromaticTriangle instance should be feasible");
-    let mono_solution = mono_to_ilp.extract_solution(&ilp_solution);
+#[test]
+fn test_ksatisfiability_to_monochromatic_triangle_short_and_repeated_literals() {
+    for clauses in [
+        vec![],
+        vec![vec![]],
+        vec![vec![1]],
+        vec![vec![1, -2]],
+        vec![vec![1, 1, 1], vec![-1, -1, -1]],
+        vec![vec![1, -1, 2]],
+    ] {
+        let source = KSatisfiability::<K3>::new_allow_less(
+            3,
+            clauses.into_iter().map(CNFClause::new).collect(),
+        );
+        let feasible = (0..8).any(|bits| {
+            source
+                .evaluate(&(0..3).map(|i| bits & (1 << i) != 0).collect())
+                .unwrap()
+                .0
+        });
+        let reduction = ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source).unwrap();
+        match ILPSolver::new().solve(reduction.target_problem()) {
+            Ok(coloring) => {
+                assert!(feasible);
+                assert!(
+                    source
+                        .evaluate(&reduction.extract_solution(&coloring).unwrap())
+                        .unwrap()
+                        .0
+                );
+            }
+            Err(ILPSolveError::Infeasible) => assert!(!feasible),
+            Err(error) => panic!("unexpected solver error: {error}"),
+        }
+    }
+}
 
-    assert!(reduction.target_problem().evaluate(&mono_solution));
+#[test]
+fn test_ksatisfiability_to_monochromatic_triangle_zero_variables() {
+    let source = KSatisfiability::<K3>::new(0, vec![]);
+    let reduction = ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source).unwrap();
+    let coloring = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    assert_eq!(
+        reduction.extract_solution(&coloring).unwrap(),
+        Vec::<bool>::new()
+    );
+}
 
-    let extracted = reduction.extract_solution(&mono_solution);
-    assert!(source.evaluate(&extracted));
+#[test]
+fn test_ksatisfiability_to_monochromatic_triangle_size_overflow() {
+    let source = KSatisfiability::<K3>::new(usize::MAX / 16, vec![]);
+    assert!(matches!(
+        ReduceTo::<MonochromaticTriangle<SimpleGraph>>::reduce_to(&source),
+        Err(crate::rules::ReductionError::IntegerOverflow { .. }),
+    ));
 }
diff --git a/src/unit_tests/rules/ksatisfiability_oneinthreesatisfiability.rs b/src/unit_tests/rules/ksatisfiability_oneinthreesatisfiability.rs
index e35d7b788..5792a4456 100644
--- a/src/unit_tests/rules/ksatisfiability_oneinthreesatisfiability.rs
+++ b/src/unit_tests/rules/ksatisfiability_oneinthreesatisfiability.rs
@@ -15,7 +15,8 @@ fn test_ksatisfiability_to_oneinthreesatisfiability_closed_loop() {
         ],
     );
 
-    let reduction = ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -28,7 +29,8 @@ fn test_ksatisfiability_to_oneinthreesatisfiability_closed_loop() {
 fn test_ksatisfiability_to_oneinthreesatisfiability_structure_single_clause() {
     let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
 
-    let reduction = ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vars(), 11);
@@ -51,7 +53,8 @@ fn test_ksatisfiability_to_oneinthreesatisfiability_structure_single_clause() {
 fn test_ksatisfiability_to_oneinthreesatisfiability_structure_negated_clause() {
     let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![-1, -2, -3])]);
 
-    let reduction = ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vars(), 11);
@@ -80,24 +83,119 @@ fn test_ksatisfiability_to_oneinthreesatisfiability_unsatisfiable() {
         ],
     );
 
-    let reduction = ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&source).is_none());
-    assert!(solver.find_witness(target).is_none());
+    assert!(solver.solve(&source).unwrap().is_none());
+    assert!(solver.solve(target).unwrap().is_none());
 }
 
 #[test]
 fn test_ksatisfiability_to_oneinthreesatisfiability_extract_solution() {
     let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let target_solution = vec![0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0];
-    assert!(target.evaluate(&target_solution).0);
+    let target_solution = vec![
+        false, false, true, false, true, false, false, false, true, true, false,
+    ];
+    assert!(target.evaluate(&target_solution).unwrap().0);
 
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![0, 0, 1]);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![false, false, true]);
+    assert!(source.evaluate(&extracted).unwrap().0);
+}
+
+#[test]
+fn test_oneinthree_native_empty_short_and_sparse_clauses() {
+    for (num_vars, formula) in [
+        (0, vec![]),
+        (3, vec![]),
+        (0, vec![vec![]]),
+        (3, vec![vec![]]),
+        (5, vec![vec![5]]),
+        (5, vec![vec![-5]]),
+        (5, vec![vec![5, -2]]),
+        (5, vec![vec![5, -5, 2]]),
+    ] {
+        let source = KSatisfiability::<K3>::try_new_allow_less(
+            num_vars,
+            formula.iter().cloned().map(CNFClause::new).collect(),
+        )
+        .unwrap();
+        let reduction = ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        let appearing: std::collections::BTreeSet<_> = formula
+            .iter()
+            .flatten()
+            .map(|l| l.unsigned_abs() as usize - 1)
+            .collect();
+        assert_eq!(target.num_vars(), appearing.len() + 2 + 6 * formula.len());
+        assert_eq!(target.num_clauses(), 1 + 5 * formula.len());
+        let source_exists = BruteForce::new().solve(&source).unwrap().is_some();
+        let mut target_exists = false;
+        for mask in 0..(1usize << target.num_vars()) {
+            let config = (0..target.num_vars())
+                .map(|v| mask & (1 << v) != 0)
+                .collect();
+            if target.evaluate(&config).unwrap().0 {
+                target_exists = true;
+                let extracted = reduction.extract_solution(&config).unwrap();
+                assert_eq!(extracted.len(), num_vars);
+                assert!(source.evaluate(&extracted).unwrap().0);
+                for (v, &value) in extracted.iter().enumerate() {
+                    if !appearing.contains(&v) {
+                        assert!(!value);
+                    }
+                }
+            }
+        }
+        assert_eq!(source_exists, target_exists);
+    }
+}
+
+#[test]
+fn test_oneinthree_all_literal_truth_patterns_and_auxiliary_assignments() {
+    let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
+    let reduction = ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source).unwrap();
+    let target = reduction.target_problem();
+    let mut extensions = [0usize; 8];
+    for mask in 0..(1usize << target.num_vars()) {
+        let config = (0..target.num_vars())
+            .map(|v| mask & (1 << v) != 0)
+            .collect();
+        if target.evaluate(&config).unwrap().0 {
+            extensions[mask & 7] += 1;
+            let extracted = reduction.extract_solution(&config).unwrap();
+            assert!(source.evaluate(&extracted).unwrap().0);
+        }
+    }
+    assert_eq!(extensions, [0, 1, 1, 1, 1, 1, 1, 1]);
+}
+
+#[test]
+fn test_oneinthree_rejects_infeasible_target_assignments() {
+    let source = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1; 3])]);
+    let reduction = ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source).unwrap();
+    for config in [vec![], vec![false; 9], vec![true; 9], vec![false; 10]] {
+        assert!(reduction.extract_solution(&config).is_err());
+    }
+}
+
+#[test]
+fn test_oneinthree_huge_sparse_source_uses_compact_allocator() {
+    let largest = usize::try_from(i64::MAX).unwrap_or(usize::MAX);
+    let literal = i64::try_from(largest).unwrap();
+    let source = KSatisfiability::<K3>::new(largest, vec![CNFClause::new(vec![literal; 3])]);
+    let compact = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1; 3])]);
+    let reduction = ReduceTo::<OneInThreeSatisfiability>::reduce_to(&source).unwrap();
+    let other = ReduceTo::<OneInThreeSatisfiability>::reduce_to(&compact).unwrap();
+    assert_eq!(reduction.target_problem().num_vars(), 9);
+    assert_eq!(
+        reduction.target_problem().clauses(),
+        other.target_problem().clauses()
+    );
 }
diff --git a/src/unit_tests/rules/ksatisfiability_preemptivescheduling.rs b/src/unit_tests/rules/ksatisfiability_preemptivescheduling.rs
index 7f92fcbaa..375509297 100644
--- a/src/unit_tests/rules/ksatisfiability_preemptivescheduling.rs
+++ b/src/unit_tests/rules/ksatisfiability_preemptivescheduling.rs
@@ -2,7 +2,6 @@ use super::*;
 use crate::models::algebraic::ILP;
 use crate::models::formula::CNFClause;
 use crate::models::misc::{PrecedenceConstrainedScheduling, PreemptiveScheduling};
-#[cfg(feature = "ilp-solver")]
 use crate::solvers::ILPSolver;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -22,24 +21,23 @@ fn no_single_variable_instance() -> KSatisfiability<K3> {
     )
 }
 
-#[cfg(feature = "ilp-solver")]
 fn solve_threshold_schedule_via_ilp(
     target: &PreemptiveScheduling,
     deadline: usize,
-) -> Option<Vec<usize>> {
+) -> Option<Vec<Vec<bool>>> {
     let pcs = PrecedenceConstrainedScheduling::new(
         target.num_tasks(),
         target.num_processors(),
-        deadline,
+        i64::try_from(deadline).unwrap(),
         target.precedences().to_vec(),
     );
-    let pcs_to_ilp = ReduceTo::<ILP<bool>>::reduce_to(&pcs);
-    let ilp_solution = ILPSolver::new().solve(pcs_to_ilp.target_problem())?;
-    let slot_assignment = pcs_to_ilp.extract_solution(&ilp_solution);
+    let pcs_to_ilp = ReduceTo::<ILP<bool>>::reduce_to(&pcs).expect("reduction should succeed");
+    let ilp_solution = ILPSolver::new().solve(pcs_to_ilp.target_problem()).ok()?;
+    let slot_assignment = pcs_to_ilp.extract_solution(&ilp_solution).unwrap();
 
-    let mut config = vec![0usize; target.num_tasks() * target.d_max()];
+    let mut config = vec![vec![false; target.d_max()]; target.num_tasks()];
     for (task, &slot) in slot_assignment.iter().enumerate() {
-        config[task * target.d_max() + slot] = 1;
+        config[task][slot] = true;
     }
     Some(config)
 }
@@ -47,7 +45,8 @@ fn solve_threshold_schedule_via_ilp(
 #[test]
 fn test_ksatisfiability_to_preemptivescheduling_structure() {
     let source = yes_single_variable_instance();
-    let reduction = ReduceTo::<PreemptiveScheduling>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<PreemptiveScheduling>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(reduction.threshold(), 4);
@@ -61,16 +60,20 @@ fn test_ksatisfiability_to_preemptivescheduling_structure() {
 #[test]
 fn test_ksatisfiability_to_preemptivescheduling_extract_solution_from_constructed_schedule() {
     let source = yes_single_variable_instance();
-    let reduction = ReduceTo::<PreemptiveScheduling>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<PreemptiveScheduling>::reduce_to(&source).expect("reduction should succeed");
 
-    let schedule = construct_schedule_from_assignment(reduction.target_problem(), &[1], &source)
+    let schedule = construct_schedule_from_assignment(reduction.target_problem(), &[true], &source)
         .expect("satisfying assignment should yield a witness schedule");
 
-    assert_eq!(reduction.target_problem().evaluate(&schedule), Min(Some(4)));
+    assert_eq!(
+        reduction.target_problem().evaluate(&schedule).unwrap(),
+        Min(Some(4))
+    );
 
-    let extracted = reduction.extract_solution(&schedule);
-    assert_eq!(extracted, vec![1]);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&schedule).unwrap();
+    assert_eq!(extracted, vec![true]);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
@@ -82,41 +85,46 @@ fn test_ksatisfiability_to_preemptivescheduling_multi_variable_round_trip() {
             CNFClause::new(vec![-1, -2, -3]),
         ],
     );
-    let result = ReduceTo::<PreemptiveScheduling>::reduce_to(&source);
+    let result =
+        ReduceTo::<PreemptiveScheduling>::reduce_to(&source).expect("reduction should succeed");
 
-    let schedule = construct_schedule_from_assignment(result.target_problem(), &[1, 1, 0], &source)
-        .expect("satisfying assignment should yield a witness schedule");
+    let schedule =
+        construct_schedule_from_assignment(result.target_problem(), &[true, true, false], &source)
+            .expect("satisfying assignment should yield a witness schedule");
 
-    let extracted = result.extract_solution(&schedule);
-    assert_eq!(extracted, vec![1, 1, 0]);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = result.extract_solution(&schedule).unwrap();
+    assert_eq!(extracted, vec![true, true, false]);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_ksatisfiability_to_preemptivescheduling_closed_loop() {
     let source = yes_single_variable_instance();
-    let reduction = ReduceTo::<PreemptiveScheduling>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<PreemptiveScheduling>::reduce_to(&source).expect("reduction should succeed");
 
     let target_solution =
         solve_threshold_schedule_via_ilp(reduction.target_problem(), reduction.threshold())
             .expect("satisfying instance should meet the threshold");
 
     assert_eq!(
-        reduction.target_problem().evaluate(&target_solution),
-        Min(Some(reduction.threshold()))
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap(),
+        Min(Some(i64::try_from(reduction.threshold()).unwrap()))
     );
 
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![1]);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![true]);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_ksatisfiability_to_preemptivescheduling_unsatisfiable_threshold_gap() {
     let source = no_single_variable_instance();
-    let reduction = ReduceTo::<PreemptiveScheduling>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<PreemptiveScheduling>::reduce_to(&source).expect("reduction should succeed");
 
     assert!(
         solve_threshold_schedule_via_ilp(reduction.target_problem(), reduction.threshold())
diff --git a/src/unit_tests/rules/ksatisfiability_quadraticcongruences.rs b/src/unit_tests/rules/ksatisfiability_quadraticcongruences.rs
index aa8cc986a..098a88b18 100644
--- a/src/unit_tests/rules/ksatisfiability_quadraticcongruences.rs
+++ b/src/unit_tests/rules/ksatisfiability_quadraticcongruences.rs
@@ -1,138 +1,217 @@
 use super::*;
-use crate::models::algebraic::QuadraticCongruences;
 use crate::models::formula::CNFClause;
+use crate::solvers::BruteForce;
 use crate::traits::Problem;
-use crate::variant::K3;
-use num_bigint::BigUint;
+use crate::types::Or;
+use num_traits::ToPrimitive;
 
-fn parse_biguint(decimal: &str) -> BigUint {
-    BigUint::parse_bytes(decimal.as_bytes(), 10).unwrap()
-}
-
-fn yes_source() -> KSatisfiability<K3> {
-    KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])])
-}
-
-fn no_source() -> KSatisfiability<K3> {
-    KSatisfiability::<K3>::new(
-        3,
-        vec![
-            CNFClause::new(vec![1, 2, 3]),
-            CNFClause::new(vec![1, 2, -3]),
-            CNFClause::new(vec![1, -2, 3]),
-            CNFClause::new(vec![1, -2, -3]),
-            CNFClause::new(vec![-1, 2, 3]),
-            CNFClause::new(vec![-1, 2, -3]),
-            CNFClause::new(vec![-1, -2, 3]),
-            CNFClause::new(vec![-1, -2, -3]),
-        ],
-    )
+fn source(n: usize, clauses: Vec<Vec<i64>>) -> KSatisfiability<K3> {
+    KSatisfiability::try_new_allow_less(n, clauses.into_iter().map(CNFClause::new).collect())
+        .unwrap()
 }
 
 #[test]
-fn test_ksatisfiability_to_quadraticcongruences_yes_vector_matches_reference() {
-    let source = yes_source();
-    let reduction = ReduceTo::<QuadraticCongruences>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(
-        target.a().to_string(),
-        "24774376789833901930969493589690857054479757318809067389880050365481900686480521855790751085321855544028716091768740304061770154933483583912568032268487309839887150483217991803427841494632246256979069106267975739903077253313975220950334629543698896680796604644514471329982226587790198939310252130261854260061345261792534822703552107415993395149181095406643946417446677838556491529662967718612497196985465607481037701762565357464432115991588186315538944420338665581665657256990633048782316518458318960789823148195608356665866132094622331741751434660104464526446186908186423984327309378584441678852301608097413875097759322340203392440129757309044952206052676794474037444"
-    );
+fn test_ksatisfiability_to_quadraticcongruences_closed_loop() {
+    // This target is small enough to exhaust with the registered reference solver.
+    let source = source(4, vec![vec![1, -1, 4]]);
+    let reduction = ReduceTo::<QuadraticCongruences>::reduce_to(&source).unwrap();
+    let solution = BruteForce::new()
+        .solve(reduction.target_problem())
+        .unwrap()
+        .unwrap();
     assert_eq!(
-        target.b().to_string(),
-        "258320492398609134568167452627805653838806933034511801239359528293031627308482985529627303083989608069978947502642310747925392872731730228104501603959708654521957819948288267706290429252928740405698982584646431109529262246477522695494351678851239966374979739979701122298088960329328753718665018850712042275569871466396457503567796534342707340019196698413210131749976105850216220019394606130292347220176211138740165131698855676193883728870618625384826419788829829526247269356884620132156221128153554106543852477345833208840768767922757003997300130451685941234216949874080226229911993667022444495949994448402992262942289046968833223208572761404733560153986210741255929856"
+        reduction.target_problem().evaluate(&solution).unwrap(),
+        Or(true)
     );
     assert_eq!(
-        target.c().to_string(),
-        "1751451155417562289076090860910295013949798563382605049497801689362833144442778311933240623927667902634489226131336737498914714274795055484758030113178137436163237034061475775300435705196751438621958401245166827762311321148824531342518489821082597026301078157024033550589509978740853350146565333003331750962865756176467129058599530372891056620147121385604213541915205324234623562149270154119682624448276224413342516768403311219878134069384884962788483901933932054931801996913522906978676274990632045086346409870581389711391040275119346527314035568397793120598911278990196649611544031780831552993078580251588216452432109923605723648051009454783363"
+        source
+            .evaluate(&reduction.extract_solution(&solution).unwrap())
+            .unwrap(),
+        Or(true)
     );
+}
 
-    let witness = parse_biguint(
-        "1751451122102119958305507786775835374858648979796949071929887579732578264063983923970828608254544727567945005331103265320267846420581308180536461678218456421163010842022583797942541569366464959069523226763069748653830351684499364645098951736761394790343553460544021210289436100818494593367113721596780252083857888675004881955664228675079663569835052161564690932502575257394108174870151908279593037426404556490332761276593006398441245490978500647642893471046425509487910796951416870024826654351366508266859321005453091128123256128675758429165869380881549388896022325625404673271432251145796159394173120179999131480837018022329857587128653018300402"
-    );
-    let target_config = target
-        .encode_witness(&witness)
-        .expect("reference witness must fit target encoding");
-    assert_eq!(target.evaluate(&target_config), crate::types::Or(true));
-
-    let extracted = reduction.extract_solution(&target_config);
-    assert_eq!(extracted, vec![1, 0, 0]);
-    assert_eq!(source.evaluate(&extracted), crate::types::Or(true));
+#[test]
+fn test_native_clauses_and_arbitrary_crt_signs() {
+    for source in [
+        source(0, vec![]),
+        source(0, vec![vec![]]),
+        source(3, vec![vec![1, 1, 1]]),
+        source(3, vec![vec![-1, -1, -1]]),
+        source(3, vec![vec![1, 2]]),
+        source(3, vec![vec![1, 2, 3]]),
+        source(3, vec![vec![-3, -1, 2]]),
+        source(2, vec![vec![1], vec![-1]]),
+        source(2, vec![vec![1, 2], vec![-1, -2]]),
+        source(2, vec![vec![], vec![1, 2]]),
+        source(17, vec![vec![17, 17, 17]]),
+    ] {
+        let construction = build_construction(&source).unwrap();
+        let reduction = ReduceTo::<QuadraticCongruences>::reduce_to(&source).unwrap();
+        let count = construction.thetas.len();
+        let k: BigUint = construction.prime_powers.iter().product();
+        assert!(&construction.h * 2u32 < k);
+        let mut recovered = BTreeSet::new();
+        for mask in 0..(1usize << count) {
+            let signs: Vec<i8> = (0..count)
+                .map(|i| if mask & (1 << i) == 0 { 1 } else { -1 })
+                .collect();
+            let witness = witness_value_from_alphas(&signs, &construction.thetas);
+            let valid = reduction.target_problem().evaluate(&witness).unwrap().0;
+            let extracted = reduction.extract_solution(&witness);
+            if valid {
+                let extracted = extracted.unwrap();
+                assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
+                for (i, &original) in construction.active_to_source.iter().enumerate() {
+                    assert_eq!(
+                        extracted[original],
+                        signs[0] != signs[2 * construction.clauses.len() + i + 1]
+                    );
+                }
+                recovered.insert(extracted);
+            } else {
+                assert!(extracted.is_err());
+            }
+        }
+        // Enumerate only appearing variables; unused coordinates are free.
+        let mut expected = BTreeSet::new();
+        for mask in 0..(1usize << construction.active_to_source.len()) {
+            let mut assignment = vec![false; source.num_vars()];
+            for (i, &original) in construction.active_to_source.iter().enumerate() {
+                assignment[original] = mask & (1 << i) != 0;
+            }
+            if source.evaluate(&assignment).unwrap().0 {
+                let signs = build_alphas(&construction, &assignment).unwrap();
+                let witness = witness_value_from_alphas(&signs, &construction.thetas);
+                assert_eq!(
+                    reduction.target_problem().evaluate(&witness).unwrap(),
+                    Or(true)
+                );
+                assert_eq!(reduction.extract_solution(&witness).unwrap(), assignment);
+                expected.insert(assignment);
+            } else {
+                assert!(build_alphas(&construction, &assignment).is_none());
+            }
+        }
+        assert_eq!(recovered, expected);
+    }
 }
 
 #[test]
-fn test_ksatisfiability_to_quadraticcongruences_no_vector_matches_reference() {
-    let source = no_source();
-    let reduction = ReduceTo::<QuadraticCongruences>::reduce_to(&source);
-    let target = reduction.target_problem();
+fn test_unsatisfiable_formula_has_no_quadratic_sign_witness() {
+    let rows: Vec<_> = (0..8)
+        .map(|mask| {
+            (0..3)
+                .map(|i| if mask & (1 << i) == 0 { i + 1 } else { -i - 1 })
+                .collect()
+        })
+        .collect();
+    let source = source(3, rows);
+    let construction = build_construction(&source).unwrap();
+    let coefficients: Vec<i64> = construction
+        .coefficients
+        .iter()
+        .map(|c| c.to_i64().unwrap())
+        .collect();
+    let tau = construction.tau.to_i64().unwrap();
+    let modulus = 2 * 8i64.pow(9);
+    let mut linear: i64 = coefficients.iter().sum();
+    let mut signs = vec![1i64; coefficients.len()];
+    // Global negation has the same square, so fix alpha_0=+1. This exhausts
+    // all 524288 candidate CRT sign classes, including non-knapsack roots.
+    for mask in 0..(1usize << (coefficients.len() - 1)) {
+        if mask != 0 {
+            let bit = mask.trailing_zeros() as usize + 1;
+            linear -= 2 * signs[bit] * coefficients[bit];
+            signs[bit] = -signs[bit];
+        }
+        assert_ne!((linear * linear - tau * tau).rem_euclid(modulus), 0);
+    }
+    // Explicit regression: leave only the highest clause false and substitute
+    // y=1 for its impossible y=-1. The old doubled construction accepted this.
+    let mut signs = vec![1i8; construction.thetas.len()];
+    for (j, clause) in construction.clauses.iter().enumerate() {
+        let y = if j == 7 {
+            1
+        } else {
+            clause.iter().filter(|&&lit| lit < 0).count() - 1
+        };
+        signs[2 * j + 1] = if y & 1 == 0 { 1 } else { -1 };
+        signs[2 * j + 2] = if y < 2 { 1 } else { -1 };
+    }
+    assert_eq!(construction.clauses.last().unwrap(), &vec![1, 2, 3]);
+    let witness = witness_value_from_alphas(&signs, &construction.thetas);
+    assert_eq!(construction.target.evaluate(&witness).unwrap(), Or(false));
+}
 
+#[test]
+fn test_normalization_preserves_free_variables_and_formula() {
+    let canonical = source(5, vec![vec![-5, 2]]);
+    let redundant = source(5, vec![vec![2, -5, 2], vec![-5, 2, -5], vec![1, -1, 4]]);
+    let first = ReduceTo::<QuadraticCongruences>::reduce_to(&canonical).unwrap();
+    let second = ReduceTo::<QuadraticCongruences>::reduce_to(&redundant).unwrap();
     assert_eq!(
-        target.a().to_string(),
-        "120619237677026130477382743668519955611573561225067606894291539776375461793042697084141982444840376832001728483520031164927711964309027723931955055266286697653823171984912998845552700982708397313076874101315576113063246467601796146446302015850261619724287365217007681583278794859395374862907111341177346218183179800717140552372231833894729949737335461236543786388850947901432259488709855205465866771912257416917279047309255913271484003744149430021735021695160328958001378399161910095840332775546649076458417491115249654227832505762740144311527592947868271995754125690220733691637204688156423224231300498143512347565896417676557114842881743922849970165789454322978012868"
-    );
-    assert_eq!(
-        target.b().to_string(),
-        "258320492398609134568167452627805653838806933034511801239359528293031627308482985529627303083989608069978947502642310747925392872731730228104501603959708654521957819948288267706290429252928740405698982584646431109529262246477522695494351678851239966374979739979701122298088960329328753718665018850712042275569871466396457503567796534342707340019196698413210131749976105850216220019394606130292347220176211138740165131698855676193883728870618625384826419788829829526247269356884620132156221128153554106543852477345833208840768767922757003997300130451685941234216949874080226229911993667022444495949994448402992262942289046968833223208572761404733560153986210741255929856"
+        serde_json::to_value(first.target_problem()).unwrap(),
+        serde_json::to_value(second.target_problem()).unwrap()
     );
+    let assignment = [true, true, true, true, false];
+    let witness = witness_config_for_assignment(&redundant, &assignment).unwrap();
     assert_eq!(
-        target.c().to_string(),
-        "1751451155417562289076090860910295013949798563382605049497801689362833144442778311933240623927667902634489226131336737498914714274795055484758030113178137436163237034061475775300435705196751438621958401245166827762311321148824531342518489821082597026301078157024033550589509978740853350146565333003331750962865756176467129058599530372891056620147121385604213541915205324234623562149270154119682624448276224413342516768403311219878134069384884962788483901933932054931801996913522906978676274990632045086346409870581389711391040275119346527314035568397793120598911278990196649611544031780831552993078580251588216452432109923605723648051009454783363"
+        second.extract_solution(&witness).unwrap(),
+        vec![false, true, false, false, false]
     );
-
+    assert!(witness_config_for_assignment(&redundant, &[]).is_none());
     assert!(
-        exhaustive_alpha_solution(&source).is_none(),
-        "reference UNSAT instance should have no exact doubled-knapsack witness"
+        witness_config_for_assignment(&redundant, &[false, false, false, false, true]).is_none()
     );
 }
 
 #[test]
-fn test_ksatisfiability_to_quadraticcongruences_extracts_assignment_from_constructed_witness() {
-    let source = KSatisfiability::<K3>::new(4, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<QuadraticCongruences>::reduce_to(&source);
-    let target_config = witness_config_for_assignment(&source, &[1, 0, 0, 0])
-        .expect("assignment should lift to a target witness");
-
-    let extracted = reduction.extract_solution(&target_config);
-    assert_eq!(extracted, vec![1, 0, 0, 0]);
-    assert_eq!(source.evaluate(&extracted), crate::types::Or(true));
-    assert_eq!(
-        reduction.target_problem().evaluate(&target_config),
-        crate::types::Or(true)
-    );
+fn test_rejects_infeasible_and_out_of_bound_integers() {
+    let source = source(3, vec![vec![1, 2, 3]]);
+    let reduction = ReduceTo::<QuadraticCongruences>::reduce_to(&source).unwrap();
+    for witness in [
+        BigUint::zero(),
+        reduction.h.clone(),
+        reduction.target.c().clone(),
+        reduction.target.c() + 1u32,
+    ] {
+        assert_eq!(reduction.target.evaluate(&witness).unwrap(), Or(false));
+        assert!(reduction.extract_solution(&witness).is_err());
+    }
 }
 
 #[test]
-fn test_ksatisfiability_to_quadraticcongruences_closed_loop() {
-    let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, -3])]);
-
-    let reduction = ReduceTo::<QuadraticCongruences>::reduce_to(&source);
-
-    // Construct a target config from a known-satisfying source assignment.
-    // Assignment: x1=true, x2=false, x3=false => clause (1,2,-3) satisfied by x1=true.
-    let assignment = [1, 0, 0];
-    assert_eq!(
-        source.evaluate(assignment.as_ref()),
-        crate::types::Or(true),
-        "assignment must satisfy the source"
-    );
-
-    let target_config = witness_config_for_assignment(&source, &assignment)
-        .expect("satisfying assignment should lift to a target witness");
-
-    // Verify the target config is a valid witness.
-    assert_eq!(
-        reduction.target_problem().evaluate(&target_config),
-        crate::types::Or(true),
-        "constructed target config must satisfy the target"
-    );
-
-    // Verify round-trip: extracting the source solution recovers the original assignment.
-    let extracted = reduction.extract_solution(&target_config);
-    assert_eq!(extracted, vec![1, 0, 0]);
-    assert_eq!(
-        source.evaluate(&extracted),
-        crate::types::Or(true),
-        "extracted source config must satisfy the source"
-    );
+fn test_prime_generation_and_parameter_bounds() {
+    for (candidate, prime) in [
+        (0, false),
+        (1, false),
+        (2, true),
+        (3, true),
+        (4, false),
+        (9, false),
+        (13, true),
+        (25, false),
+        (u64::MAX, false),
+    ] {
+        assert_eq!(is_prime(candidate), prime);
+    }
+    assert!(admissible_primes(0).unwrap().is_empty());
+    assert_eq!(admissible_primes(4).unwrap(), vec![13, 17, 19, 23]);
+    for source in [
+        source(0, vec![]),
+        source(0, vec![vec![]]),
+        source(3, vec![vec![1, 2, 3]]),
+        source(1, vec![vec![1], vec![-1]]),
+    ] {
+        let reduction = ReduceTo::<QuadraticCongruences>::reduce_to(&source).unwrap();
+        let n = 2 * source.num_clauses() + source.num_vars() + 1;
+        let bound = 64 * n * n + 3 * source.num_clauses() + 4;
+        let target = reduction.target_problem();
+        assert!(
+            target.bit_length_a() <= bound
+                && target.bit_length_b() <= bound
+                && target.bit_length_c() <= bound
+        );
+    }
 }
diff --git a/src/unit_tests/rules/ksatisfiability_quadraticdiophantineequations.rs b/src/unit_tests/rules/ksatisfiability_quadraticdiophantineequations.rs
index 70045195f..4b9c73f43 100644
--- a/src/unit_tests/rules/ksatisfiability_quadraticdiophantineequations.rs
+++ b/src/unit_tests/rules/ksatisfiability_quadraticdiophantineequations.rs
@@ -13,35 +13,39 @@ fn trivial_source() -> KSatisfiability<K3> {
 #[test]
 fn test_ksatisfiability_to_quadraticdiophantineequations_closed_loop() {
     let source = trivial_source();
-    let reduction = ReduceTo::<QuadraticDiophantineEquations>::reduce_to(&source);
+    let reduction = ReduceTo::<QuadraticDiophantineEquations>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     let solver = BruteForce::new();
     let target_solution = solver
-        .find_witness(reduction.target_problem())
+        .solve(reduction.target_problem())
+        .unwrap()
         .expect("target should be satisfiable");
 
     assert_eq!(
-        reduction.target_problem().evaluate(&target_solution),
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap(),
         Or(true)
     );
 
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(source.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
-fn test_ksatisfiability_to_quadraticdiophantineequations_yes_vector_matches_reference() {
+fn test_ksatisfiability_to_quadraticdiophantineequations_canonical_witness() {
     let source = canonical_source();
-    let reduction = ReduceTo::<QuadraticDiophantineEquations>::reduce_to(&source);
+    let reduction = ReduceTo::<QuadraticDiophantineEquations>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let target_config = target
-        .encode_witness(&canonical_witness())
-        .expect("reference witness must fit target encoding");
+    let target_config = canonical_witness();
 
-    assert_eq!(target.evaluate(&target_config), Or(true));
+    assert_eq!(target.evaluate(&target_config).unwrap(), Or(true));
 
-    let extracted = reduction.extract_solution(&target_config);
-    assert_eq!(extracted, vec![1, 0, 0]);
-    assert_eq!(source.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&target_config).unwrap();
+    assert_eq!(extracted, vec![true, false, false]);
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/ksatisfiability_qubo.rs b/src/unit_tests/rules/ksatisfiability_qubo.rs
index 9b64eccee..22aad0944 100644
--- a/src/unit_tests/rules/ksatisfiability_qubo.rs
+++ b/src/unit_tests/rules/ksatisfiability_qubo.rs
@@ -1,6 +1,7 @@
 use super::*;
 use crate::models::formula::CNFClause;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::variant::{K2, K3};
 
@@ -17,16 +18,16 @@ fn test_ksatisfiability_to_qubo_closed_loop() {
             CNFClause::new(vec![-2, -3]), // ¬x2 ∨ ¬x3
         ],
     );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ksat).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     // Verify all solutions satisfy all clauses
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(ksat.evaluate(&extracted));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ksat.evaluate(&extracted).unwrap());
     }
 }
 
@@ -34,15 +35,15 @@ fn test_ksatisfiability_to_qubo_closed_loop() {
 fn test_ksatisfiability_to_qubo_simple() {
     // 2 vars, 1 clause: (x1 ∨ x2) → 3 satisfying assignments
     let ksat = KSatisfiability::<K2>::new(2, vec![CNFClause::new(vec![1, 2])]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ksat).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(ksat.evaluate(&extracted));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ksat.evaluate(&extracted).unwrap());
     }
 }
 
@@ -58,11 +59,11 @@ fn test_ksatisfiability_to_qubo_contradiction() {
             CNFClause::new(vec![-1, -1]), // ¬x1 ∨ ¬x1 = ¬x1
         ],
     );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ksat).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     // Both x=0 and x=1 satisfy exactly 1 clause
     assert_eq!(qubo_solutions.len(), 2);
@@ -79,15 +80,15 @@ fn test_ksatisfiability_to_qubo_reversed_vars() {
             CNFClause::new(vec![1, 2]),
         ],
     );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ksat).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(ksat.evaluate(&extracted));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ksat.evaluate(&extracted).unwrap());
     }
 }
 
@@ -97,7 +98,7 @@ fn test_ksatisfiability_to_qubo_structure() {
         3,
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1, 3])],
     );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ksat).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     // QUBO should have at least the original variables
@@ -119,21 +120,20 @@ fn test_k3satisfiability_to_qubo_closed_loop() {
             CNFClause::new(vec![3, -4, -5]), // x3 ∨ ¬x4 ∨ ¬x5
         ],
     );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ksat).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     // QUBO should have 5 + 7 = 12 variables
     assert_eq!(qubo.num_variables(), 12);
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     // Verify all extracted solutions maximize satisfied clauses
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
+        let extracted = reduction.extract_solution(sol).unwrap();
         assert_eq!(extracted.len(), 5);
-        let assignment: Vec<bool> = extracted.iter().map(|&v| v == 1).collect();
-        let satisfied = ksat.count_satisfied(&assignment);
+        let satisfied = ksat.count_satisfied(&extracted).unwrap();
         assert_eq!(satisfied, 7, "Expected all 7 clauses satisfied");
     }
 }
@@ -142,20 +142,20 @@ fn test_k3satisfiability_to_qubo_closed_loop() {
 fn test_k3satisfiability_to_qubo_single_clause() {
     // Single 3-SAT clause: (x1 ∨ x2 ∨ x3) — 7 satisfying assignments
     let ksat = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ksat).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     // 3 vars + 1 auxiliary = 4 total
     assert_eq!(qubo.num_variables(), 4);
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     // All solutions should satisfy the single clause
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
+        let extracted = reduction.extract_solution(sol).unwrap();
         assert_eq!(extracted.len(), 3);
-        assert!(ksat.evaluate(&extracted));
+        assert!(ksat.evaluate(&extracted).unwrap());
     }
     // 7 out of 8 assignments satisfy (x1 ∨ x2 ∨ x3)
     assert_eq!(qubo_solutions.len(), 7);
@@ -165,16 +165,168 @@ fn test_k3satisfiability_to_qubo_single_clause() {
 fn test_k3satisfiability_to_qubo_all_negated() {
     // All negated: (¬x1 ∨ ¬x2 ∨ ¬x3) — 7 satisfying assignments
     let ksat = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![-1, -2, -3])]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&ksat);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ksat).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(ksat.evaluate(&extracted));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ksat.evaluate(&extracted).unwrap());
     }
     // 7 out of 8 assignments satisfy (¬x1 ∨ ¬x2 ∨ ¬x3)
     assert_eq!(qubo_solutions.len(), 7);
 }
+
+#[test]
+fn test_sat_qubo_all_short_clauses_and_raw_targets() {
+    use crate::rules::AggregateReductionResult;
+    use crate::types::{Min, Or};
+    macro_rules! verify {
+        ($k:ty, $width:expr) => {{
+            let mut clauses = vec![vec![]];
+            for width in 1..=$width {
+                for mask in 0..(1 << width) {
+                    clauses.push(
+                        (0..width)
+                            .map(|p| if mask & (1 << p) == 0 { 1 } else { -1 })
+                            .collect(),
+                    );
+                }
+            }
+            for a in &clauses {
+                for b in &clauses {
+                    let source = KSatisfiability::<$k>::new_allow_less(
+                        1,
+                        vec![CNFClause::new(a.clone()), CNFClause::new(b.clone())],
+                    );
+                    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).unwrap();
+                    let target = ReductionResult::target_problem(&reduction);
+                    let mut minimum = i64::MAX;
+                    for mask in 0..(1 << target.num_vars()) {
+                        let witness: Vec<_> = (0..target.num_vars())
+                            .map(|p| mask & (1 << p) != 0)
+                            .collect();
+                        let energy = target.evaluate(&witness).unwrap().0.unwrap();
+                        let mut penalty = 0;
+                        for (j, clause) in [a, b].iter().enumerate() {
+                            let y: Vec<i64> = clause
+                                .iter()
+                                .map(|&l| i64::from(witness[0] != (l > 0)))
+                                .collect();
+                            penalty += match y.as_slice() {
+                                [] => 1,
+                                &[u] => u,
+                                &[u, v] => u * v,
+                                &[u, v, w] => {
+                                    let z = i64::from(witness[1 + j]);
+                                    z * w + 2 * (u * v - 2 * u * z - 2 * v * z + 3 * z)
+                                }
+                                _ => unreachable!(),
+                            };
+                        }
+                        assert_eq!(energy - reduction.zero_penalty_energy, penalty);
+                        assert_eq!(
+                            AggregateReductionResult::extract_value(&reduction, Min(Some(energy))),
+                            Or(penalty == 0)
+                        );
+                        if penalty == 0 {
+                            let decoded = reduction.extract_solution(&witness).unwrap();
+                            assert!(source.evaluate(&decoded).unwrap().0);
+                        } else {
+                            assert!(reduction.extract_solution(&witness).is_err());
+                        }
+                        minimum = minimum.min(energy);
+                    }
+                    let sat = [false, true]
+                        .into_iter()
+                        .any(|x| source.evaluate(&vec![x]).unwrap().0);
+                    assert_eq!(
+                        AggregateReductionResult::extract_value(&reduction, Min(Some(minimum))),
+                        Or(sat)
+                    );
+                    assert_eq!(
+                        AggregateReductionResult::extract_value(&reduction, Min(None)),
+                        Or(false)
+                    );
+                    assert!(reduction.extract_solution(&vec![]).is_err());
+                    assert!(reduction
+                        .extract_solution(&vec![false; target.num_vars() + 1])
+                        .is_err());
+                }
+            }
+            for n in [0, 3] {
+                let source = KSatisfiability::<$k>::new(n, vec![]);
+                let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).unwrap();
+                assert_eq!(
+                    reduction.extract_solution(&vec![false; n]).unwrap(),
+                    vec![false; n]
+                );
+            }
+        }};
+    }
+    verify!(K2, 2);
+    verify!(K3, 3);
+}
+
+#[test]
+fn test_sat_qubo_checked_numeric_boundaries() {
+    let mut matrix = vec![vec![i64::MAX]];
+    assert!(add_coefficient(&mut matrix, 0, 0, 1).is_err());
+    let mut matrix = vec![vec![i64::MIN]];
+    assert!(add_coefficient(&mut matrix, 0, 0, -1).is_err());
+    assert!(build_qubo_matrix(usize::MAX, &[], 1).is_err());
+    // This variable count is legal for the source on both 32- and 64-bit hosts,
+    // but its dense target cannot have an addressable number of entries.
+    let n = usize::MAX / 2;
+    let k2 = KSatisfiability::<K2>::new(n, vec![]);
+    let k3 = KSatisfiability::<K3>::new(n, vec![]);
+    assert!(matches!(
+        ReduceTo::<QUBO<i64>>::reduce_to(&k2),
+        Err(crate::rules::ReductionError::IntegerOverflow { .. })
+    ));
+    assert!(matches!(
+        ReduceTo::<QUBO<i64>>::reduce_to(&k3),
+        Err(crate::rules::ReductionError::IntegerOverflow { .. })
+    ));
+}
+
+#[test]
+fn test_sat_qubo_registered_aggregate_threshold() {
+    use crate::types::Or;
+    macro_rules! check {
+        ($k:ty) => {
+            for (clauses, expected) in [(vec![vec![1]], true), (vec![vec![1], vec![-1]], false)] {
+                let source = KSatisfiability::<$k>::new_allow_less(
+                    1,
+                    clauses.into_iter().map(CNFClause::new).collect(),
+                );
+                let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).unwrap();
+                let mut witness = vec![false; reduction.target.num_vars()];
+                witness[0] = expected;
+                let entries = crate::rules::registry::reduction_entries();
+                let edge = entries
+                    .iter()
+                    .find(|e| {
+                        e.source_name == "KSatisfiability"
+                            && e.target_name == "QUBO"
+                            && (e.source_variant_fn)() == KSatisfiability::<$k>::variant()
+                            && (e.target_variant_fn)() == QUBO::<i64>::variant()
+                    })
+                    .unwrap();
+                let aggregate = (edge.reduce_aggregate_fn.unwrap())(&source).unwrap();
+                assert_eq!(
+                    *aggregate
+                        .extract_value_from_solution_dyn(&witness)
+                        .unwrap()
+                        .downcast::<Or>()
+                        .unwrap(),
+                    Or(expected)
+                );
+            }
+        };
+    }
+    check!(K2);
+    check!(K3);
+}
diff --git a/src/unit_tests/rules/ksatisfiability_registersufficiency.rs b/src/unit_tests/rules/ksatisfiability_registersufficiency.rs
index fdf330cfc..301cf7af3 100644
--- a/src/unit_tests/rules/ksatisfiability_registersufficiency.rs
+++ b/src/unit_tests/rules/ksatisfiability_registersufficiency.rs
@@ -43,9 +43,10 @@ fn positions_from_order(order: &[usize], total_vertices: usize) -> Vec<usize> {
 #[test]
 fn test_ksatisfiability_to_register_sufficiency_structure_issue_example() {
     let source = issue_example();
-    let reduction = ReduceTo::<RegisterSufficiency>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<RegisterSufficiency>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
-    let layout = SethiRegisterLayout::new(source.num_vars(), source.num_clauses());
+    let layout = SethiRegisterLayout::new(source.num_vars(), source.num_clauses()).unwrap();
 
     assert_eq!(target.num_vertices(), 70);
     assert_eq!(target.num_arcs(), 152);
@@ -65,11 +66,12 @@ fn test_ksatisfiability_to_register_sufficiency_structure_issue_example() {
 }
 
 #[test]
-fn test_ksatisfiability_to_register_sufficiency_extract_solution_uses_w_snapshot_and_x_pos_sign() {
+fn test_ksatisfiability_to_register_sufficiency_rejects_invalid_snapshot_order() {
     let source = repeated_positive_literal();
-    let reduction = ReduceTo::<RegisterSufficiency>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<RegisterSufficiency>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
-    let layout = SethiRegisterLayout::new(source.num_vars(), source.num_clauses());
+    let layout = SethiRegisterLayout::new(source.num_vars(), source.num_clauses()).unwrap();
 
     let mut order = Vec::with_capacity(target.num_vertices());
     order.push(layout.z(0));
@@ -88,45 +90,50 @@ fn test_ksatisfiability_to_register_sufficiency_extract_solution_uses_w_snapshot
         }
     }
 
-    let extracted =
-        reduction.extract_solution(&positions_from_order(&order, target.num_vertices()));
-    assert_eq!(extracted, vec![1]);
+    let positions = positions_from_order(&order, target.num_vertices());
+    assert_eq!(target.evaluate(&positions).unwrap(), Or(false));
+    assert!(reduction.extract_solution(&positions).is_err());
 }
 
 #[test]
-fn test_ksatisfiability_to_register_sufficiency_closed_loop_via_exact_solver() {
+fn test_ksatisfiability_to_register_sufficiency_forward_schedule() {
     let source = repeated_positive_literal();
-    let reduction = ReduceTo::<RegisterSufficiency>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<RegisterSufficiency>::reduce_to(&source).expect("reduction should succeed");
 
     let register_schedule = reduction
-        .target_problem()
-        .solve_exact()
-        .expect("satisfiable source formula should yield a feasible register schedule");
+        .layout
+        .as_ref()
+        .unwrap()
+        .schedule_for_assignment(&[true]);
     assert_eq!(
-        reduction.target_problem().evaluate(&register_schedule),
+        reduction
+            .target_problem()
+            .evaluate(&register_schedule)
+            .unwrap(),
         Or(true)
     );
 
-    let extracted = reduction.extract_solution(&register_schedule);
-    assert_eq!(source.evaluate(&extracted), Or(true));
-    assert_eq!(extracted, vec![1]);
+    let extracted = reduction.extract_solution(&register_schedule).unwrap();
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
+    assert_eq!(extracted, vec![true]);
 }
 
 #[test]
 fn test_ksatisfiability_to_register_sufficiency_unsatisfiable_instance() {
-    use crate::solvers::{BruteForce, Solver};
-    use crate::types::Or;
+    use crate::solvers::BruteForce;
 
     let source = contradictory_single_variable();
     // Verify the source is indeed unsatisfiable via brute force
-    assert_eq!(BruteForce::new().solve(&source), Or(false));
+    assert!(BruteForce::new().solve(&source).unwrap().is_none());
 
     // Verify the reduction produces a valid RS instance — we check that
     // the structure is correct (vertex/arc counts match Sethi layout) rather
-    // than solving the 70-vertex RS instance, which would be too slow.
-    let reduction = ReduceTo::<RegisterSufficiency>::reduce_to(&source);
+    // than enumerating all permutations of this 24-vertex RS instance.
+    let reduction =
+        ReduceTo::<RegisterSufficiency>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
-    let layout = SethiRegisterLayout::new(source.num_vars(), source.num_clauses());
+    let layout = SethiRegisterLayout::new(source.num_vars(), source.num_clauses()).unwrap();
     assert_eq!(target.num_vertices(), layout.total_vertices());
 }
 
@@ -139,3 +146,137 @@ fn test_ksatisfiability_to_register_sufficiency_canonical_example_spec() {
         .expect("missing canonical KSatisfiability -> RegisterSufficiency example spec");
     assert_eq!(spec.id, "ksatisfiability_to_registersufficiency");
 }
+
+#[test]
+fn test_ksatisfiability_to_registersufficiency_closed_loop_boundaries() {
+    use crate::solvers::BruteForce;
+    for declared in [0, 5] {
+        let yes = KSatisfiability::<K3>::new(declared, vec![]);
+        let no = KSatisfiability::<K3>::try_new_allow_less(declared, vec![CNFClause::new(vec![])])
+            .unwrap();
+        for (source, feasible) in [(yes, true), (no, false)] {
+            let reduction = ReduceTo::<RegisterSufficiency>::reduce_to(&source).unwrap();
+            let solution = BruteForce::new().solve(reduction.target_problem()).unwrap();
+            assert_eq!(solution.is_some(), feasible);
+            if let Some(solution) = solution {
+                let extracted = reduction.extract_solution(&solution).unwrap();
+                assert_eq!(extracted, vec![false; declared]);
+                assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
+            } else {
+                assert!(reduction.extract_solution(&vec![0]).is_err());
+            }
+        }
+    }
+}
+
+#[test]
+fn test_short_repeated_and_tautological_clauses() {
+    for num_vars in 1..=3 {
+        let literals: Vec<i64> = (1..=num_vars)
+            .flat_map(|i| [i as i64, -(i as i64)])
+            .collect();
+        for width in 1..=3 {
+            for code in 0..literals.len().pow(width) {
+                let mut remaining = code;
+                let clause: Vec<_> = (0..width)
+                    .map(|_| {
+                        let lit = literals[remaining % literals.len()];
+                        remaining /= literals.len();
+                        lit
+                    })
+                    .collect();
+                let source = KSatisfiability::<K3>::try_new_allow_less(
+                    num_vars,
+                    vec![CNFClause::new(clause)],
+                )
+                .unwrap();
+                let reduction = ReduceTo::<RegisterSufficiency>::reduce_to(&source).unwrap();
+                let layout = reduction.layout.as_ref().unwrap();
+                for mask in 0..(1usize << num_vars) {
+                    let original: Vec<_> = (0..num_vars).map(|i| mask & (1 << i) != 0).collect();
+                    let compact: Vec<_> = reduction
+                        .source_variables
+                        .iter()
+                        .map(|&i| original[i])
+                        .collect();
+                    let positions = layout.schedule_for_assignment(&compact);
+                    assert!(reduction
+                        .target_problem()
+                        .simulate_registers(&positions)
+                        .unwrap()
+                        .is_some());
+                    let source_value = source.evaluate(&original).unwrap();
+                    assert_eq!(
+                        reduction.target_problem().evaluate(&positions).unwrap(),
+                        source_value
+                    );
+                    if source_value.0 {
+                        let decoded = reduction.extract_solution(&positions).unwrap();
+                        assert_eq!(source.evaluate(&decoded).unwrap(), Or(true));
+                        for &i in &reduction.source_variables {
+                            assert_eq!(decoded[i], original[i]);
+                        }
+                    } else {
+                        assert!(reduction.extract_solution(&positions).is_err());
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_sparse_original_variables_and_padding_bound() {
+    let source =
+        KSatisfiability::<K3>::try_new_allow_less(17, vec![CNFClause::new(vec![-17, 2])]).unwrap();
+    let reduction = ReduceTo::<RegisterSufficiency>::reduce_to(&source).unwrap();
+    assert_eq!(reduction.source_variables, vec![1, 16]);
+    let layout = reduction.layout.as_ref().unwrap();
+    assert_eq!(layout.num_vars, 2);
+    let positions = layout.schedule_for_assignment(&[true, false]);
+    let decoded = reduction.extract_solution(&positions).unwrap();
+    assert_eq!(decoded.len(), 17);
+    assert!(decoded[1]);
+    assert!(!decoded[16]);
+    assert_eq!(decoded.iter().filter(|&&b| b).count(), 1);
+    let many = KSatisfiability::<K3>::new(1, vec![CNFClause::new(vec![1, 1, 1]); 5]);
+    let reduction = ReduceTo::<RegisterSufficiency>::reduce_to(&many).unwrap();
+    let layout = reduction.layout.as_ref().unwrap();
+    assert_eq!(layout.b_padding, 0);
+    let positions = layout.schedule_for_assignment(&[true]);
+    assert_eq!(
+        reduction.target_problem().evaluate(&positions).unwrap(),
+        Or(true)
+    );
+}
+
+#[test]
+fn test_feasible_snapshot_may_leave_both_literals_uncomputed() {
+    let source = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
+    let reduction = ReduceTo::<RegisterSufficiency>::reduce_to(&source).unwrap();
+    let layout = reduction.layout.as_ref().unwrap();
+    let base = layout.schedule_for_assignment(&[true, false, false]);
+    let mut order: Vec<_> = (0..layout.total_vertices()).collect();
+    order.sort_by_key(|&v| base[v]);
+    let mut delayed = Vec::new();
+    for variable in 1..3 {
+        delayed.extend((0..2 * layout.num_vars - 2 * variable - 1).map(|i| layout.t(variable, i)));
+        delayed.push(layout.x_neg(variable));
+    }
+    order.retain(|v| !delayed.contains(v));
+    let insert = order.iter().position(|&v| v == layout.d()).unwrap() + 1;
+    order.splice(insert..insert, delayed);
+    let positions = positions_from_order(&order, layout.total_vertices());
+    assert_eq!(
+        reduction.target_problem().evaluate(&positions).unwrap(),
+        Or(true)
+    );
+    assert!(
+        positions[layout.x_pos(1)] > positions[layout.w(2)]
+            && positions[layout.x_neg(1)] > positions[layout.w(2)]
+    );
+    assert_eq!(
+        reduction.extract_solution(&positions).unwrap(),
+        vec![true, false, false]
+    );
+}
diff --git a/src/unit_tests/rules/ksatisfiability_simultaneousincongruences.rs b/src/unit_tests/rules/ksatisfiability_simultaneousincongruences.rs
index c2613cdc6..6646e6d14 100644
--- a/src/unit_tests/rules/ksatisfiability_simultaneousincongruences.rs
+++ b/src/unit_tests/rules/ksatisfiability_simultaneousincongruences.rs
@@ -13,7 +13,8 @@ fn test_ksatisfiability_to_simultaneous_incongruences_closed_loop() {
             CNFClause::new(vec![-1, 2, 2]),
         ],
     );
-    let reduction = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source);
+    let reduction = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.lcm_moduli(), 15);
@@ -21,11 +22,12 @@ fn test_ksatisfiability_to_simultaneous_incongruences_closed_loop() {
 
     let solver = BruteForce::new();
     let target_solution = solver
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("target should be satisfiable");
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
-    assert!(source.evaluate(&extracted));
+    assert!(source.evaluate(&extracted).unwrap());
 }
 
 #[test]
@@ -37,10 +39,11 @@ fn test_ksatisfiability_to_simultaneous_incongruences_structure() {
             CNFClause::new(vec![-1, 2, 2]),
         ],
     );
-    let reduction = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source);
+    let reduction = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let pairs: Vec<(u64, u64)> = target.pairs().to_vec();
+    let pairs: Vec<(i64, i64)> = target.pairs().to_vec();
     assert_eq!(
         pairs,
         vec![(3, 3), (5, 5), (3, 5), (4, 5), (2, 15), (7, 15)]
@@ -56,10 +59,11 @@ fn test_ksatisfiability_to_simultaneous_incongruences_unsatisfiable() {
             CNFClause::new(vec![-1, -1, -1]),
         ],
     );
-    let reduction = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source);
+    let reduction = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
 
-    assert_eq!(solver.find_witness(reduction.target_problem()), None);
+    assert_eq!(solver.solve(reduction.target_problem()).unwrap(), None);
 }
 
 #[test]
@@ -71,20 +75,25 @@ fn test_ksatisfiability_to_simultaneous_incongruences_tautological_clause_is_red
             CNFClause::new(vec![2, 2, 2]),
         ],
     );
-    let reduction = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source);
+    let reduction = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
     let target_solution = solver
-        .find_witness(reduction.target_problem())
+        .solve(reduction.target_problem())
+        .unwrap()
         .expect("target should remain satisfiable");
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
-    assert!(source.evaluate(&extracted));
+    assert!(source.evaluate(&extracted).unwrap());
 }
 
 #[test]
-#[should_panic(expected = "3-SAT -> SimultaneousIncongruences requires the variable-prime product")]
 fn test_ksatisfiability_to_simultaneous_incongruences_rejects_large_instances() {
-    let source = KSatisfiability::<K3>::new(7, vec![CNFClause::new(vec![1, 2, 3])]);
+    let source = KSatisfiability::<K3>::new(16, vec![CNFClause::new(vec![1, 2, 3])]);
 
-    let _ = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source);
+    let error = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::rules::ReductionError::InvalidTarget { .. }
+    ));
 }
diff --git a/src/unit_tests/rules/ksatisfiability_subsetsum.rs b/src/unit_tests/rules/ksatisfiability_subsetsum.rs
index 30ffca725..5cacbc628 100644
--- a/src/unit_tests/rules/ksatisfiability_subsetsum.rs
+++ b/src/unit_tests/rules/ksatisfiability_subsetsum.rs
@@ -15,7 +15,7 @@ fn test_ksatisfiability_to_subsetsum_closed_loop() {
             CNFClause::new(vec![-1, -2, 3]), // ¬x1 ∨ ¬x2 ∨ x3
         ],
     );
-    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat);
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Verify structure: 2*3 + 2*2 = 10 elements
@@ -25,14 +25,14 @@ fn test_ksatisfiability_to_subsetsum_closed_loop() {
     assert_eq!(target.target(), &BigUint::from(11144u32));
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(target);
+    let solutions = solver.find_all_witnesses(target).unwrap();
     assert!(!solutions.is_empty());
 
     // Every SubsetSum solution must map back to a satisfying 3-SAT assignment
     for sol in &solutions {
-        let extracted = reduction.extract_solution(sol);
+        let extracted = reduction.extract_solution(sol).unwrap();
         assert_eq!(extracted.len(), 3);
-        assert!(ksat.evaluate(&extracted));
+        assert!(ksat.evaluate(&extracted).unwrap());
     }
 }
 
@@ -49,11 +49,11 @@ fn test_ksatisfiability_to_subsetsum_unsatisfiable() {
             CNFClause::new(vec![1, 1, 1]),
         ],
     );
-    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat);
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let solution = solver.find_witness(target);
+    let solution = solver.solve(target).unwrap();
     assert!(solution.is_none());
 }
 
@@ -61,20 +61,20 @@ fn test_ksatisfiability_to_subsetsum_unsatisfiable() {
 fn test_ksatisfiability_to_subsetsum_single_clause() {
     // Single clause: (x1 ∨ x2 ∨ x3) — 7 out of 8 assignments satisfy it
     let ksat = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat);
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 2*3 + 2*1 = 8 elements
     assert_eq!(target.num_elements(), 8);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(target);
+    let solutions = solver.find_all_witnesses(target).unwrap();
 
     // Each SubsetSum solution maps to a satisfying assignment
     let mut sat_assignments = std::collections::HashSet::new();
     for sol in &solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(ksat.evaluate(&extracted));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ksat.evaluate(&extracted).unwrap());
         sat_assignments.insert(extracted);
     }
     // Should find exactly 7 distinct satisfying assignments
@@ -91,7 +91,7 @@ fn test_ksatisfiability_to_subsetsum_structure() {
             CNFClause::new(vec![-1, -2, 3]), // ¬x1 ∨ ¬x2 ∨ x3
         ],
     );
-    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat);
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat).expect("reduction should succeed");
     let target = reduction.target_problem();
     let sizes = target.sizes();
 
@@ -114,16 +114,16 @@ fn test_ksatisfiability_to_subsetsum_structure() {
 fn test_ksatisfiability_to_subsetsum_all_negated() {
     // All negated: (¬x1 ∨ ¬x2 ∨ ¬x3) — 7 satisfying assignments
     let ksat = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![-1, -2, -3])]);
-    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat);
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(target);
+    let solutions = solver.find_all_witnesses(target).unwrap();
 
     let mut sat_assignments = std::collections::HashSet::new();
     for sol in &solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(ksat.evaluate(&extracted));
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(ksat.evaluate(&extracted).unwrap());
         sat_assignments.insert(extracted);
     }
     assert_eq!(sat_assignments.len(), 7);
@@ -140,7 +140,7 @@ fn test_ksatisfiability_to_subsetsum_extract_solution_example() {
             CNFClause::new(vec![-1, -2, 3]),
         ],
     );
-    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat);
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&ksat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Construct the known subset for x1=T, x2=T, x3=T:
@@ -148,15 +148,15 @@ fn test_ksatisfiability_to_subsetsum_extract_solution_example() {
     // Need clause digits = 44, so slack: C1 needs +1 (g1=10), C2 needs +3 (g2=1, h2=2)
     // Total: 10010 + 01010 + 00111 + 00010 + 00001 + 00002 = 11144
     let specific_config = vec![
-        1, 0, // y1 selected, z1 not
-        1, 0, // y2 selected, z2 not
-        1, 0, // y3 selected, z3 not
-        1, 0, // g1 selected, h1 not
-        1, 1, // g2 selected, h2 selected
+        true, false, // y1 selected, z1 not
+        true, false, // y2 selected, z2 not
+        true, false, // y3 selected, z3 not
+        true, false, // g1 selected, h1 not
+        true, true, // g2 selected, h2 selected
     ];
-    assert!(target.evaluate(&specific_config));
+    assert!(target.evaluate(&specific_config).unwrap());
 
-    let extracted = reduction.extract_solution(&specific_config);
-    assert_eq!(extracted, vec![1, 1, 1]); // x1=T, x2=T, x3=T
-    assert!(ksat.evaluate(&extracted));
+    let extracted = reduction.extract_solution(&specific_config).unwrap();
+    assert_eq!(extracted, vec![true, true, true]); // x1=T, x2=T, x3=T
+    assert!(ksat.evaluate(&extracted).unwrap());
 }
diff --git a/src/unit_tests/rules/ksatisfiability_timetabledesign.rs b/src/unit_tests/rules/ksatisfiability_timetabledesign.rs
index 76363ba44..e9c62c153 100644
--- a/src/unit_tests/rules/ksatisfiability_timetabledesign.rs
+++ b/src/unit_tests/rules/ksatisfiability_timetabledesign.rs
@@ -1,7 +1,7 @@
 use super::*;
+use crate::models::algebraic::ILP;
 use crate::models::formula::CNFClause;
 use crate::models::misc::TimetableDesign;
-#[cfg(feature = "ilp-solver")]
 use crate::solvers::ILPSolver;
 use crate::traits::Problem;
 use crate::variant::K3;
@@ -27,7 +27,8 @@ fn unsatisfiable_instance() -> KSatisfiability<K3> {
 #[test]
 fn test_ksatisfiability_to_timetabledesign_structure() {
     let source = satisfiable_instance();
-    let reduction = ReduceTo::<TimetableDesign>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<TimetableDesign>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_periods(), 12);
@@ -46,57 +47,81 @@ fn test_ksatisfiability_to_timetabledesign_structure() {
 #[test]
 fn test_ksatisfiability_to_timetabledesign_extract_solution_from_constructed_timetable() {
     let source = satisfiable_instance();
-    let reduction = ReduceTo::<TimetableDesign>::reduce_to(&source);
-    let target_solution =
-        construct_timetable_from_assignment(reduction.target_problem(), &[1, 1, 0], &source)
-            .expect("a satisfying 3SAT assignment should lift to a timetable witness");
+    let reduction =
+        ReduceTo::<TimetableDesign>::reduce_to(&source).expect("reduction should succeed");
+    let target_solution = construct_timetable_from_assignment(
+        reduction.target_problem(),
+        &[true, true, false],
+        &source,
+    )
+    .expect("a satisfying 3SAT assignment should lift to a timetable witness");
 
-    assert!(reduction.target_problem().evaluate(&target_solution).0);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap()
+            .0
+    );
 
-    let extracted = reduction.extract_solution(&target_solution);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_ksatisfiability_to_timetabledesign_multi_variable_round_trip() {
     let source = satisfiable_instance();
-    let reduction = ReduceTo::<TimetableDesign>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<TimetableDesign>::reduce_to(&source).expect("reduction should succeed");
 
-    let target_solution =
-        construct_timetable_from_assignment(reduction.target_problem(), &[1, 1, 0], &source)
-            .expect("a satisfying 3SAT assignment should lift to a timetable witness");
+    let target_solution = construct_timetable_from_assignment(
+        reduction.target_problem(),
+        &[true, true, false],
+        &source,
+    )
+    .expect("a satisfying 3SAT assignment should lift to a timetable witness");
 
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![1, 1, 0]);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![true, true, false]);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_ksatisfiability_to_timetabledesign_closed_loop() {
     let source = satisfiable_instance();
-    let reduction = ReduceTo::<TimetableDesign>::reduce_to(&source);
-
-    let target_solution = ILPSolver::new()
-        .solve_reduced(reduction.target_problem())
+    let reduction =
+        ReduceTo::<TimetableDesign>::reduce_to(&source).expect("reduction should succeed");
+    let target_reduction = ReduceTo::<ILP<bool>>::reduce_to(reduction.target_problem())
+        .expect("timetable reduction should succeed");
+    let ilp_solution = ILPSolver::new()
+        .solve(target_reduction.target_problem())
         .expect("satisfiable source instance should produce a feasible timetable");
+    let target_solution = target_reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(reduction.target_problem().evaluate(&target_solution).0);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap()
+            .0
+    );
 
-    let extracted = reduction.extract_solution(&target_solution);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_ksatisfiability_to_timetabledesign_unsatisfiable() {
     let source = unsatisfiable_instance();
-    let reduction = ReduceTo::<TimetableDesign>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<TimetableDesign>::reduce_to(&source).expect("reduction should succeed");
+    let target_reduction = ReduceTo::<ILP<bool>>::reduce_to(reduction.target_problem())
+        .expect("timetable reduction should succeed");
 
     assert!(
         ILPSolver::new()
-            .solve_reduced(reduction.target_problem())
-            .is_none(),
+            .solve(target_reduction.target_problem())
+            .is_err(),
         "unsatisfiable 3SAT instance should produce an infeasible timetable"
     );
 }
diff --git a/src/unit_tests/rules/lengthboundeddisjointpaths_ilp.rs b/src/unit_tests/rules/lengthboundeddisjointpaths_ilp.rs
index 206743262..c9ca738b9 100644
--- a/src/unit_tests/rules/lengthboundeddisjointpaths_ilp.rs
+++ b/src/unit_tests/rules/lengthboundeddisjointpaths_ilp.rs
@@ -1,8 +1,11 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::rules::ReduceTo;
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::SimpleGraph;
+use crate::traits::Problem;
+use crate::types::Max;
 
 #[test]
 fn test_lengthboundeddisjointpaths_to_ilp_closed_loop() {
@@ -13,12 +16,8 @@ fn test_lengthboundeddisjointpaths_to_ilp_closed_loop() {
         3,
         2,
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "LengthBoundedDisjointPaths->ILP closed loop",
-    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
@@ -29,6 +28,91 @@ fn test_lengthboundeddisjointpaths_to_ilp_bf_vs_ilp() {
         3,
         2,
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
+
+#[test]
+fn test_lengthboundeddisjointpaths_to_ilp_triangle_subgraphs() {
+    let edges = [(0, 1), (1, 2), (0, 2)];
+    for mask in 0..8 {
+        for bound in 1..=2 {
+            let graph = SimpleGraph::new(
+                3,
+                edges
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(i, &edge)| (mask & (1 << i) != 0).then_some(edge))
+                    .collect(),
+            );
+            let source = LengthBoundedDisjointPaths::new(graph, 0, 2, bound);
+            let expected = i64::from(mask & 4 != 0) + i64::from(bound == 2 && mask & 3 == 3);
+            let reference = BruteForce::new().solve(&source).unwrap().unwrap();
+            assert_eq!(source.evaluate(&reference).unwrap(), Max(Some(expected)));
+            let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+            let target_solution = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+            let extracted = reduction.extract_solution(&target_solution).unwrap();
+            assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(expected)));
+        }
+    }
+}
+
+#[test]
+fn test_lengthboundeddisjointpaths_to_ilp_preserves_edge_order() {
+    let source = LengthBoundedDisjointPaths::new(
+        SimpleGraph::new(4, vec![(2, 0), (3, 1), (2, 1), (1, 0)]),
+        0,
+        2,
+        2,
+    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    // Reverse orientations of edge 0 (0->2) and edges 3,2 (0->1->2).
+    let mut target_solution = vec![0; 18];
+    for index in [1, 13, 15, 16, 17] {
+        target_solution[index] = 1;
+    }
+    assert!(reduction
+        .target_problem()
+        .is_feasible(&target_solution)
+        .unwrap());
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(
+        extracted,
+        vec![
+            vec![true, false, false, false],
+            vec![false, false, true, true]
+        ]
+    );
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(2)));
+}
+
+#[test]
+fn test_lengthboundeddisjointpaths_to_ilp_extracts_path_from_circulation() {
+    for cycle in [
+        vec![(0, 2), (2, 3), (3, 0)],
+        vec![(1, 2), (2, 3), (3, 1)],
+        vec![(2, 3), (3, 4), (4, 2)],
+    ] {
+        let mut edges = vec![(0, 1)];
+        edges.extend(cycle);
+        let source = LengthBoundedDisjointPaths::new(SimpleGraph::new(5, edges), 0, 1, 4);
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+        let target_solution = vec![1, 0, 1, 0, 1, 0, 1, 0, 1];
+        assert!(reduction
+            .target_problem()
+            .is_feasible(&target_solution)
+            .unwrap());
+        let extracted = reduction.extract_solution(&target_solution).unwrap();
+        assert_eq!(extracted, vec![vec![true, false, false, false]]);
+        assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(1)));
+    }
+}
+
+#[test]
+fn test_lengthboundeddisjointpaths_to_ilp_rejects_invalid_target_solutions() {
+    let source = LengthBoundedDisjointPaths::new(SimpleGraph::new(2, vec![(0, 1)]), 0, 1, 1);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    for solution in [vec![], vec![2, 0, 1], vec![0, 0, 1], vec![1, 0, 0]] {
+        assert!(reduction.extract_solution(&solution).is_err());
+    }
+}
diff --git a/src/unit_tests/rules/longestcircuit_ilp.rs b/src/unit_tests/rules/longestcircuit_ilp.rs
index b0c20b4ad..46f03d612 100644
--- a/src/unit_tests/rules/longestcircuit_ilp.rs
+++ b/src/unit_tests/rules/longestcircuit_ilp.rs
@@ -1,5 +1,5 @@
 use super::*;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -11,11 +11,13 @@ fn test_reduction_creates_valid_ilp() {
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![1, 1, 1],
     );
-    let reduction: ReductionLongestCircuitToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLongestCircuitToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    // m=3, n=3, commodities=2, flow=2*3*2=12, total=3+3+12=18
-    assert_eq!(ilp.num_vars, 18);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    // Three edge, three vertex, three root, and eighteen flow variables.
+    assert_eq!(ilp.num_vars(), 27);
+    assert_eq!(ilp.num_constraints(), 41);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
 }
 
 #[test]
@@ -42,21 +44,27 @@ fn test_longestcircuit_to_ilp_closed_loop() {
     // BruteForce on source to verify feasibility
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute-force should find a solution");
-    assert!(problem.evaluate(&bf_solution).0.is_some());
+    assert!(problem.evaluate(&bf_solution).unwrap().0.is_some());
 
     // Solve via ILP
-    let reduction: ReductionLongestCircuitToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLongestCircuitToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert!(
-        problem.evaluate(&extracted).0.is_some(),
+        problem.evaluate(&extracted).unwrap().0.is_some(),
         "ILP solution should be a valid circuit"
     );
+    assert_eq!(
+        problem.evaluate(&extracted).unwrap(),
+        problem.evaluate(&bf_solution).unwrap()
+    );
 }
 
 #[test]
@@ -66,13 +74,10 @@ fn test_longestcircuit_to_ilp_triangle() {
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![1, 1, 1],
     );
-    let reduction: ReductionLongestCircuitToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLongestCircuitToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_optimization_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "LongestCircuit->ILP triangle",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
@@ -81,13 +86,14 @@ fn test_solution_extraction() {
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (3, 0), (0, 2), (1, 3)]),
         vec![1, 1, 1, 1, 2, 2],
     );
-    let reduction: ReductionLongestCircuitToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLongestCircuitToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted).0.is_some());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap().0.is_some());
 }
 
 #[test]
@@ -96,6 +102,62 @@ fn test_longestcircuit_to_ilp_bf_vs_ilp() {
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![1, 1, 1],
     );
-    let reduction: ReductionLongestCircuitToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLongestCircuitToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
+
+#[test]
+fn test_longestcircuit_to_ilp_cycle_excludes_any_vertex() {
+    // A leaf attached to a triangle; every vertex label can be the leaf.
+    for leaf in 0..4 {
+        let [a, b, c] = [1, 2, 3].map(|offset| (leaf + offset) % 4);
+        let problem = LongestCircuit::new(
+            SimpleGraph::new(4, vec![(leaf, a), (a, b), (b, c), (c, a)]),
+            vec![10, 1, 2, 3],
+        );
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+        let target_solution = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+        let extracted = reduction.extract_solution(&target_solution).unwrap();
+        assert_eq!(extracted, vec![false, true, true, true]);
+    }
+}
+
+#[test]
+fn test_longestcircuit_to_ilp_selects_one_best_cycle() {
+    // The longer triangle excludes vertex 0, with or without a bridge.
+    for connected in [false, true] {
+        let mut edges = vec![(0, 1), (1, 2), (2, 0), (3, 4), (4, 5), (5, 3)];
+        let mut lengths = vec![1, 1, 1, 4, 5, 6];
+        if connected {
+            edges.push((2, 3));
+            lengths.push(20);
+        }
+        let problem = LongestCircuit::new(SimpleGraph::new(6, edges), lengths);
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+        let target_solution = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+        let extracted = reduction.extract_solution(&target_solution).unwrap();
+        assert_eq!(
+            problem.evaluate(&extracted).unwrap(),
+            crate::types::Max(Some(15))
+        );
+    }
+}
+
+#[test]
+fn test_longestcircuit_to_ilp_acyclic_graphs() {
+    for n in 0..4 {
+        let edges: Vec<_> = (1..n).map(|v| (v - 1, v)).collect();
+        let m = edges.len();
+        let problem = LongestCircuit::new(SimpleGraph::new(n, edges), vec![1; m]);
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+        let target = reduction.target_problem();
+        assert_eq!(target.num_vars(), m + 2 * n + 2 * m * n);
+        assert_eq!(target.num_constraints(), 2 + n + 2 * n * n + 2 * m * n);
+        assert!(BruteForce::new().solve(&problem).unwrap().is_none());
+        assert!(matches!(
+            ILPSolver::new().solve(target),
+            Err(crate::solvers::ILPSolveError::Infeasible)
+        ));
+    }
+}
diff --git a/src/unit_tests/rules/longestcommonsubsequence_ilp.rs b/src/unit_tests/rules/longestcommonsubsequence_ilp.rs
index 62ecfcc7a..f920fa554 100644
--- a/src/unit_tests/rules/longestcommonsubsequence_ilp.rs
+++ b/src/unit_tests/rules/longestcommonsubsequence_ilp.rs
@@ -1,25 +1,26 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::solvers::{BruteForce, ILPSolver, Solver};
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Max;
 
 #[test]
 fn test_lcs_to_ilp_yes_instance() {
     let problem = LongestCommonSubsequence::new(3, vec![vec![0, 1, 2], vec![1, 0, 2]]);
-    let reduction: ReductionLCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // num_symbols = 4, max_length = 3
     // symbol_var_count = 12, match vars = 3 * 6 = 18, total = 30
-    assert_eq!(ilp.num_vars, 30);
+    assert_eq!(ilp.num_vars(), 30);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert_eq!(extracted.len(), problem.max_length());
-    let value = problem.evaluate(&extracted);
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(matches!(value, Max(Some(v)) if v >= 1));
 }
 
@@ -28,18 +29,20 @@ fn test_lcs_to_ilp_closed_loop_three_strings() {
     let problem =
         LongestCommonSubsequence::new(2, vec![vec![0, 1, 0], vec![1, 0, 1, 0], vec![0, 0, 1, 0]]);
 
-    let reduction: ReductionLCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let ilp_value = problem.evaluate(&extracted);
+    let ilp_value = problem.evaluate(&extracted).unwrap();
     assert!(matches!(ilp_value, Max(Some(_))));
 
     let brute_force = BruteForce::new();
-    let bf_value = brute_force.solve(&problem);
+    let bf_value_solution = brute_force.solve(&problem).unwrap().unwrap();
+    let bf_value = problem.evaluate(&bf_value_solution).unwrap();
 
     // The ILP should find the same optimal value as brute force.
     assert_eq!(ilp_value, bf_value);
@@ -48,15 +51,16 @@ fn test_lcs_to_ilp_closed_loop_three_strings() {
 #[test]
 fn test_lcs_to_ilp_extracts_valid_witness() {
     let problem = LongestCommonSubsequence::new(2, vec![vec![0, 1, 0], vec![1, 0, 1, 0]]);
-    let reduction: ReductionLCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert_eq!(extracted.len(), problem.max_length());
-    let value = problem.evaluate(&extracted);
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(matches!(value, Max(Some(_))));
 }
 
@@ -64,16 +68,18 @@ fn test_lcs_to_ilp_extracts_valid_witness() {
 fn test_lcs_to_ilp_matches_brute_force() {
     // Verify ILP optimal value matches brute force
     let problem = LongestCommonSubsequence::new(2, vec![vec![0, 1, 0], vec![1, 0, 1]]);
-    let reduction: ReductionLCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     let brute_force = BruteForce::new();
-    let bf_value = brute_force.solve(&problem);
+    let bf_value_solution = brute_force.solve(&problem).unwrap().unwrap();
+    let bf_value = problem.evaluate(&bf_value_solution).unwrap();
 
     assert_eq!(ilp_value, bf_value);
 }
@@ -83,20 +89,22 @@ fn test_lcs_to_ilp_single_position_all_padding() {
     // When no common subsequence exists, the ILP should still find a solution
     // with all padding (length 0).
     let problem = LongestCommonSubsequence::new(2, vec![vec![0, 0, 0], vec![1, 1, 1]]);
-    let reduction: ReductionLCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let value = problem.evaluate(&extracted);
+    let value = problem.evaluate(&extracted).unwrap();
     assert_eq!(value, Max(Some(0)));
 }
 
 #[test]
 fn test_longestcommonsubsequence_to_ilp_bf_vs_ilp() {
     let problem = LongestCommonSubsequence::new(2, vec![vec![0, 1, 0], vec![1, 0, 1]]);
-    let reduction: ReductionLCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionLCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/longestcommonsubsequence_maximumindependentset.rs b/src/unit_tests/rules/longestcommonsubsequence_maximumindependentset.rs
index 16d3ddb91..7daf6a1e0 100644
--- a/src/unit_tests/rules/longestcommonsubsequence_maximumindependentset.rs
+++ b/src/unit_tests/rules/longestcommonsubsequence_maximumindependentset.rs
@@ -14,7 +14,8 @@ fn test_longestcommonsubsequence_to_maximumindependentset_closed_loop() {
             vec![1, 0, 2, 0], // BACA
         ],
     );
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs)
+        .expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &lcs,
         &reduction,
@@ -32,7 +33,8 @@ fn test_lcs_to_mis_graph_structure() {
             vec![1, 0, 2, 0], // BACA
         ],
     );
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.graph().num_vertices(), 6);
@@ -52,12 +54,16 @@ fn test_lcs_to_mis_cross_frequency_product() {
 fn test_lcs_to_mis_optimal_value() {
     // LCS of "ABAC" and "BACA" is "BAC" (length 3)
     let lcs = LongestCommonSubsequence::new(3, vec![vec![0, 1, 0, 2], vec![1, 0, 2, 0]]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(target).expect("should have a solution");
-    let mis_size: usize = witness.iter().sum();
+    let witness = solver
+        .solve(target)
+        .unwrap()
+        .expect("should have a solution");
+    let mis_size: usize = witness.iter().filter(|&&selected| selected).count();
     assert_eq!(mis_size, 3);
 }
 
@@ -65,7 +71,8 @@ fn test_lcs_to_mis_optimal_value() {
 fn test_lcs_to_mis_three_strings() {
     // k=3 strings over binary alphabet
     let lcs = LongestCommonSubsequence::new(2, vec![vec![0, 1, 0], vec![1, 0, 1], vec![0, 1, 1]]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs)
+        .expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &lcs,
         &reduction,
@@ -77,7 +84,8 @@ fn test_lcs_to_mis_three_strings() {
 fn test_lcs_to_mis_single_char_alphabet() {
     // All same character: LCS = min length
     let lcs = LongestCommonSubsequence::new(1, vec![vec![0, 0, 0], vec![0, 0]]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs)
+        .expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &lcs,
         &reduction,
@@ -89,7 +97,8 @@ fn test_lcs_to_mis_single_char_alphabet() {
 fn test_lcs_to_mis_no_common_chars() {
     // No common characters: LCS = 0
     let lcs = LongestCommonSubsequence::new(2, vec![vec![0, 0, 0], vec![1, 1, 1]]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // No match nodes since no character appears in both strings at any position
@@ -107,19 +116,21 @@ fn test_lcs_to_mis_extract_solution() {
             vec![1, 0, 2, 0], // BACA
         ],
     );
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs)
+        .expect("reduction should succeed");
 
     // Vertices: A nodes at indices 0-3, B node at index 4, C node at index 5
     // Actually the ordering depends on implementation: char 0 (A) first, then 1 (B), then 2 (C)
     // Let's verify by solving
     let solver = BruteForce::new();
     let witness = solver
-        .find_witness(reduction.target_problem())
+        .solve(reduction.target_problem())
+        .unwrap()
         .expect("should have a solution");
-    let source_sol = reduction.extract_solution(&witness);
+    let source_sol = reduction.extract_solution(&witness).unwrap();
 
     // The extracted solution should be valid for the source
-    let value = lcs.evaluate(&source_sol);
+    let value = lcs.evaluate(&source_sol).unwrap();
     assert!(value.0.is_some(), "extracted solution should be valid");
     assert_eq!(value.0.unwrap(), 3, "LCS length should be 3");
 }
@@ -129,7 +140,8 @@ fn test_lcs_to_mis_four_strings() {
     // k=4 strings
     let lcs =
         LongestCommonSubsequence::new(2, vec![vec![0, 1], vec![1, 0], vec![0, 1], vec![1, 0]]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&lcs)
+        .expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &lcs,
         &reduction,
diff --git a/src/unit_tests/rules/longestpath_ilp.rs b/src/unit_tests/rules/longestpath_ilp.rs
index 288d5d172..8e23b37be 100644
--- a/src/unit_tests/rules/longestpath_ilp.rs
+++ b/src/unit_tests/rules/longestpath_ilp.rs
@@ -5,7 +5,7 @@ use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Max;
 
-fn issue_problem() -> LongestPath<SimpleGraph, i32> {
+fn issue_problem() -> LongestPath<SimpleGraph, i64> {
     LongestPath::new(
         SimpleGraph::new(
             7,
@@ -28,30 +28,31 @@ fn issue_problem() -> LongestPath<SimpleGraph, i32> {
     )
 }
 
-fn simple_path_problem() -> LongestPath<SimpleGraph, i32> {
+fn simple_path_problem() -> LongestPath<SimpleGraph, i64> {
     LongestPath::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![2, 3], 0, 2)
 }
 
 #[test]
 fn test_reduction_creates_expected_ilp_shape() {
     let problem = simple_path_problem();
-    let reduction: ReductionLongestPathToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionLongestPathToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 7);
-    assert_eq!(ilp.constraints.len(), 23);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.num_vars(), 7);
+    assert_eq!(ilp.constraints().len(), 23);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
 
-    let mut objective = vec![0.0; ilp.num_vars];
-    for &(var, coeff) in &ilp.objective {
+    let mut objective = vec![0; ilp.num_vars()];
+    for &(var, coeff) in ilp.objective() {
         objective[var] = coeff;
     }
 
-    assert_eq!(objective[0], 2.0);
-    assert_eq!(objective[1], 2.0);
-    assert_eq!(objective[2], 3.0);
-    assert_eq!(objective[3], 3.0);
-    assert_eq!(objective[4], 0.0);
+    assert_eq!(objective[0], 2);
+    assert_eq!(objective[1], 2);
+    assert_eq!(objective[2], 3);
+    assert_eq!(objective[3], 3);
+    assert_eq!(objective[4], 0);
 }
 
 #[test]
@@ -59,33 +60,36 @@ fn test_longestpath_to_ilp_closed_loop_on_issue_example() {
     let problem = issue_problem();
     let brute_force = BruteForce::new();
     let best = brute_force
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute-force optimum");
-    let best_value = problem.evaluate(&best);
+    let best_value = problem.evaluate(&best).unwrap();
     assert_eq!(best_value, Max(Some(20)));
 
-    let reduction: ReductionLongestPathToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionLongestPathToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(problem.is_valid_solution(&extracted));
-    assert_eq!(problem.evaluate(&extracted), best_value);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), best_value);
 }
 
 #[test]
 fn test_solution_extraction_from_handcrafted_ilp_assignment() {
     let problem = simple_path_problem();
-    let reduction: ReductionLongestPathToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionLongestPathToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // x_{0->1}, x_{1->0}, x_{1->2}, x_{2->1}, o_0, o_1, o_2
     let target_solution = vec![1, 0, 1, 0, 0, 1, 2];
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
-    assert_eq!(extracted, vec![1, 1]);
-    assert_eq!(problem.evaluate(&extracted), Max(Some(5)));
+    assert_eq!(extracted, vec![true, true]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(5)));
 }
 
 #[test]
@@ -96,20 +100,22 @@ fn test_source_equals_target_uses_empty_path() {
         1,
         1,
     );
-    let reduction: ReductionLongestPathToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionLongestPathToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should solve the trivial empty-path case");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, vec![0, 0, 0]);
-    assert_eq!(problem.evaluate(&extracted), Max(Some(0)));
+    assert_eq!(extracted, vec![false, false, false]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(0)));
 }
 
 #[test]
 fn test_longestpath_to_ilp_bf_vs_ilp() {
     let problem = simple_path_problem();
-    let reduction: ReductionLongestPathToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionLongestPathToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/maxcut_minimumcutintoboundedsets.rs b/src/unit_tests/rules/maxcut_minimumcutintoboundedsets.rs
index 0e2f3c6ac..51c788b17 100644
--- a/src/unit_tests/rules/maxcut_minimumcutintoboundedsets.rs
+++ b/src/unit_tests/rules/maxcut_minimumcutintoboundedsets.rs
@@ -9,9 +9,10 @@ fn test_maxcut_to_minimumcutintoboundedsets_closed_loop() {
     // Triangle K_3 with unit weights: max cut = 2
     let source = MaxCut::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32, 1, 1],
+        vec![1i64, 1, 1],
     );
-    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -22,8 +23,9 @@ fn test_maxcut_to_minimumcutintoboundedsets_closed_loop() {
 #[test]
 fn test_maxcut_to_minimumcutintoboundedsets_single_edge() {
     // Single edge K_2: max cut = 1
-    let source = MaxCut::new(SimpleGraph::new(2, vec![(0, 1)]), vec![1i32]);
-    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i32>>::reduce_to(&source);
+    let source = MaxCut::new(SimpleGraph::new(2, vec![(0, 1)]), vec![1i64]);
+    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -36,9 +38,10 @@ fn test_maxcut_to_minimumcutintoboundedsets_path_p4() {
     // Path P_4: vertices 0-1-2-3, unit weights, max cut = 3 (alternate: 0,1,0,1)
     let source = MaxCut::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32, 1, 1],
+        vec![1i64, 1, 1],
     );
-    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -51,9 +54,10 @@ fn test_maxcut_to_minimumcutintoboundedsets_weighted() {
     // Triangle with weights [1, 2, 3]: max cut = 5 (cut edges with weights 2 and 3)
     let source = MaxCut::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32, 2, 3],
+        vec![1i64, 2, 3],
     );
-    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -66,9 +70,10 @@ fn test_maxcut_to_minimumcutintoboundedsets_target_structure() {
     // Verify the target problem structure for a 3-vertex graph
     let source = MaxCut::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32, 1, 1],
+        vec![1i64, 1, 1],
     );
-    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // n=3, n'=3+1=4, N=8
@@ -87,9 +92,10 @@ fn test_maxcut_to_minimumcutintoboundedsets_even_vertices() {
     // Even number of vertices: n=4, n'=4, N=8
     let source = MaxCut::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (0, 3)]),
-        vec![1i32, 1, 1, 1],
+        vec![1i64, 1, 1, 1],
     );
-    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // n=4, n'=4, N=8
@@ -111,13 +117,14 @@ fn test_maxcut_to_minimumcutintoboundedsets_extract_solution_size() {
     // Verify extract_solution returns only original vertices
     let source = MaxCut::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32, 1, 1],
+        vec![1i64, 1, 1],
     );
-    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     // Target has 8 vertices, extract should return 3
-    let dummy_target_sol = vec![0, 1, 0, 1, 0, 1, 0, 1];
-    let extracted = reduction.extract_solution(&dummy_target_sol);
+    let dummy_target_sol = vec![false, true, false, true, false, true, false, true];
+    let extracted = reduction.extract_solution(&dummy_target_sol).unwrap();
     assert_eq!(extracted.len(), 3);
 }
 
@@ -125,8 +132,9 @@ fn test_maxcut_to_minimumcutintoboundedsets_extract_solution_size() {
 fn test_maxcut_to_minimumcutintoboundedsets_weight_inversion() {
     // Verify weight inversion: original edge gets W_max - w, non-edge gets W_max
     // Use n=2 to keep the target small: n'=2, N=4, K_4 has 6 edges
-    let source = MaxCut::new(SimpleGraph::new(2, vec![(0, 1)]), vec![5i32]);
-    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i32>>::reduce_to(&source);
+    let source = MaxCut::new(SimpleGraph::new(2, vec![(0, 1)]), vec![5i64]);
+    let reduction = ReduceTo::<MinimumCutIntoBoundedSets<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // W_max = 5 + 1 = 6
diff --git a/src/unit_tests/rules/maxcut_minimummatrixcover.rs b/src/unit_tests/rules/maxcut_minimummatrixcover.rs
index fb722d1a5..7e6ef4a1b 100644
--- a/src/unit_tests/rules/maxcut_minimummatrixcover.rs
+++ b/src/unit_tests/rules/maxcut_minimummatrixcover.rs
@@ -3,22 +3,23 @@ use crate::models::algebraic::MinimumMatrixCover;
 use crate::models::graph::MaxCut;
 use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
 use crate::rules::traits::ReduceTo;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::{Max, Min};
 
 /// Brute-force verifies the algebraic identity `Σ a_ij f(i) f(j) = 2W − 4·cut(S)`
 /// for every sign assignment on a small instance.
-fn verify_identity(source: &MaxCut<SimpleGraph, i32>) {
-    let reduction = ReduceTo::<MinimumMatrixCover>::reduce_to(source);
+fn verify_identity(source: &MaxCut<SimpleGraph, i64>) {
+    let reduction =
+        ReduceTo::<MinimumMatrixCover>::reduce_to(source).expect("reduction should succeed");
     let target = reduction.target_problem();
     let matrix = target.matrix();
     let n = source.num_vertices();
-    let total_weight: i64 = source.edge_weights().iter().map(|&w| w as i64).sum();
+    let total_weight: i64 = source.edge_weights().iter().copied().sum();
 
     for bits in 0..(1u32 << n) {
-        let config: Vec<usize> = (0..n).map(|i| ((bits >> i) & 1) as usize).collect();
+        let config: Vec<bool> = (0..n).map(|i| ((bits >> i) & 1) == 1).collect();
 
         // qf(f) = Σ_{i,j} a_ij f(i) f(j)
         let signs: Vec<i64> = config.iter().map(|&x| 2 * x as i64 - 1).collect();
@@ -30,10 +31,10 @@ fn verify_identity(source: &MaxCut<SimpleGraph, i32>) {
         }
 
         // cut(S) from MaxCut.evaluate (Max value)
-        let Max(Some(cut)) = source.evaluate(&config) else {
+        let Max(Some(cut)) = source.evaluate(&config).unwrap() else {
             panic!("MaxCut must yield a finite cut for every config");
         };
-        let cut64 = cut as i64;
+        let cut64 = cut;
 
         assert_eq!(
             qf,
@@ -49,11 +50,12 @@ fn verify_identity(source: &MaxCut<SimpleGraph, i32>) {
 #[test]
 fn test_maxcut_to_minimummatrixcover_closed_loop_c4() {
     // C_4 with unit weights: max cut = 4 (partition {0,2} vs {1,3} cuts all edges).
-    let source = MaxCut::<SimpleGraph, i32>::new(
+    let source = MaxCut::<SimpleGraph, i64>::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (0, 3)]),
         vec![1, 1, 1, 1],
     );
-    let reduction = ReduceTo::<MinimumMatrixCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumMatrixCover>::reduce_to(&source).expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -73,15 +75,21 @@ fn test_maxcut_to_minimummatrixcover_closed_loop_c4() {
 
     // Verify target's minimum value matches 2W - 4*MaxCut: 2*4 - 4*4 = -8.
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(target), Min(Some(-8)));
+    assert_eq!(
+        target
+            .evaluate(&solver.solve(target).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(-8))
+    );
 }
 
 #[test]
 fn test_maxcut_to_minimummatrixcover_closed_loop_p3_weighted() {
     // Path P_3 = 0-1-2 with weights (2, 3): max cut = 5 (split {1} vs {0, 2}).
     let source =
-        MaxCut::<SimpleGraph, i32>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![2, 3]);
-    let reduction = ReduceTo::<MinimumMatrixCover>::reduce_to(&source);
+        MaxCut::<SimpleGraph, i64>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![2, 3]);
+    let reduction =
+        ReduceTo::<MinimumMatrixCover>::reduce_to(&source).expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -91,7 +99,12 @@ fn test_maxcut_to_minimummatrixcover_closed_loop_p3_weighted() {
     let target = reduction.target_problem();
     // W = 5, max cut = 5, so min qf = 2*5 - 4*5 = -10.
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(target), Min(Some(-10)));
+    assert_eq!(
+        target
+            .evaluate(&solver.solve(target).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(-10))
+    );
 
     // Verify the adjacency matrix is symmetric with zero diagonal.
     let expected: Vec<Vec<i64>> = vec![vec![0, 2, 0], vec![2, 0, 3], vec![0, 3, 0]];
@@ -101,11 +114,12 @@ fn test_maxcut_to_minimummatrixcover_closed_loop_p3_weighted() {
 #[test]
 fn test_maxcut_to_minimummatrixcover_closed_loop_triangle() {
     // K_3 (triangle) with unit weights: max cut = 2.
-    let source = MaxCut::<SimpleGraph, i32>::new(
+    let source = MaxCut::<SimpleGraph, i64>::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![1, 1, 1],
     );
-    let reduction = ReduceTo::<MinimumMatrixCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumMatrixCover>::reduce_to(&source).expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -115,17 +129,23 @@ fn test_maxcut_to_minimummatrixcover_closed_loop_triangle() {
     let target = reduction.target_problem();
     // W = 3, max cut = 2, so min qf = 2*3 - 4*2 = -2.
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(target), Min(Some(-2)));
+    assert_eq!(
+        target
+            .evaluate(&solver.solve(target).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(-2))
+    );
 }
 
 #[test]
 fn test_target_structure_matches_adjacency_matrix() {
     // Verify the construction details on an asymmetric weighted graph.
-    let source = MaxCut::<SimpleGraph, i32>::new(
+    let source = MaxCut::<SimpleGraph, i64>::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 3), (1, 2), (2, 3)]),
         vec![5, 7, 2, 3],
     );
-    let reduction = ReduceTo::<MinimumMatrixCover>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumMatrixCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_rows(), 4);
@@ -152,7 +172,7 @@ fn test_target_structure_matches_adjacency_matrix() {
 #[test]
 fn test_algebraic_identity_c4_unit() {
     // The identity Σ a_ij f(i) f(j) = 2W − 4·cut(S) must hold for every f.
-    let source = MaxCut::<SimpleGraph, i32>::new(
+    let source = MaxCut::<SimpleGraph, i64>::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (0, 3)]),
         vec![1, 1, 1, 1],
     );
@@ -162,14 +182,14 @@ fn test_algebraic_identity_c4_unit() {
 #[test]
 fn test_algebraic_identity_p3_weighted() {
     let source =
-        MaxCut::<SimpleGraph, i32>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![2, 3]);
+        MaxCut::<SimpleGraph, i64>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![2, 3]);
     verify_identity(&source);
 }
 
 #[test]
 fn test_algebraic_identity_triangle_weighted() {
     // Triangle with non-uniform weights.
-    let source = MaxCut::<SimpleGraph, i32>::new(
+    let source = MaxCut::<SimpleGraph, i64>::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![4, 1, 2],
     );
@@ -179,17 +199,19 @@ fn test_algebraic_identity_triangle_weighted() {
 #[test]
 fn test_extract_solution_is_identity() {
     let source =
-        MaxCut::<SimpleGraph, i32>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1, 1]);
-    let reduction = ReduceTo::<MinimumMatrixCover>::reduce_to(&source);
-    let target_sol = vec![1, 0, 1];
-    assert_eq!(reduction.extract_solution(&target_sol), target_sol);
+        MaxCut::<SimpleGraph, i64>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1, 1]);
+    let reduction =
+        ReduceTo::<MinimumMatrixCover>::reduce_to(&source).expect("reduction should succeed");
+    let target_sol = vec![true, false, true];
+    assert_eq!(reduction.extract_solution(&target_sol).unwrap(), target_sol);
 }
 
 #[test]
 fn test_empty_graph() {
     // n vertices, zero edges: matrix is all zeros, max cut = 0.
-    let source = MaxCut::<SimpleGraph, i32>::new(SimpleGraph::new(3, vec![]), vec![]);
-    let reduction = ReduceTo::<MinimumMatrixCover>::reduce_to(&source);
+    let source = MaxCut::<SimpleGraph, i64>::new(SimpleGraph::new(3, vec![]), vec![]);
+    let reduction =
+        ReduceTo::<MinimumMatrixCover>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_rows(), 3);
@@ -197,25 +219,34 @@ fn test_empty_graph() {
     assert_eq!(target.matrix(), expected.as_slice());
 
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(target), Min(Some(0)));
+    assert_eq!(
+        target
+            .evaluate(&solver.solve(target).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(0))
+    );
 }
 
 #[test]
 fn test_overhead_num_rows_equals_num_vertices() {
-    // Spot-check the size overhead: target.num_rows == source.num_vertices.
+    // Spot-check the exact parameter relation: target.num_rows == source.num_vertices.
     for n in [1usize, 2, 5, 8] {
         let edges: Vec<(usize, usize)> = (0..n.saturating_sub(1)).map(|i| (i, i + 1)).collect();
-        let weights: Vec<i32> = vec![1; edges.len()];
-        let source = MaxCut::<SimpleGraph, i32>::new(SimpleGraph::new(n, edges), weights);
-        let reduction = ReduceTo::<MinimumMatrixCover>::reduce_to(&source);
+        let weights: Vec<i64> = vec![1; edges.len()];
+        let source = MaxCut::<SimpleGraph, i64>::new(SimpleGraph::new(n, edges), weights);
+        let reduction =
+            ReduceTo::<MinimumMatrixCover>::reduce_to(&source).expect("reduction should succeed");
         assert_eq!(reduction.target_problem().num_rows(), n);
     }
 }
 
 #[test]
-#[should_panic(expected = "nonnegative")]
-fn test_negative_weight_panics() {
+fn test_negative_weight_is_rejected() {
     // The reduction only handles nonnegative weights.
-    let source = MaxCut::<SimpleGraph, i32>::new(SimpleGraph::new(2, vec![(0, 1)]), vec![-1]);
-    let _ = ReduceTo::<MinimumMatrixCover>::reduce_to(&source);
+    let source = MaxCut::<SimpleGraph, i64>::new(SimpleGraph::new(2, vec![(0, 1)]), vec![-1]);
+    let error = ReduceTo::<MinimumMatrixCover>::reduce_to(&source).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::rules::ReductionError::InvalidTarget { .. }
+    ));
 }
diff --git a/src/unit_tests/rules/maximalis_ilp.rs b/src/unit_tests/rules/maximalis_ilp.rs
index 4a977ab58..928156425 100644
--- a/src/unit_tests/rules/maximalis_ilp.rs
+++ b/src/unit_tests/rules/maximalis_ilp.rs
@@ -7,11 +7,12 @@ use crate::traits::Problem;
 fn test_reduction_creates_valid_ilp() {
     // Path P3: 0-1-2
     let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1, 1, 1]);
-    let reduction: ReductionMxISToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMxISToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 3);
-    assert_eq!(ilp.constraints.len(), 5); // 2 edges + 3 maximality
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.num_vars(), 3);
+    assert_eq!(ilp.constraints().len(), 5); // 2 edges + 3 maximality
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
 }
 
 #[test]
@@ -20,18 +21,19 @@ fn test_maximalis_to_ilp_bf_vs_ilp() {
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
         vec![1, 1, 1, 1],
     );
-    let reduction: ReductionMxISToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMxISToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     assert!(ilp_value.is_valid());
@@ -40,21 +42,23 @@ fn test_maximalis_to_ilp_bf_vs_ilp() {
 #[test]
 fn test_solution_extraction() {
     let problem = MaximalIS::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1, 1, 1]);
-    let reduction: ReductionMxISToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMxISToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted).is_valid());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_maximalis_to_ilp_trivial() {
     // Single vertex
     let problem = MaximalIS::new(SimpleGraph::new(1, vec![]), vec![1]);
-    let reduction: ReductionMxISToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMxISToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 1);
-    assert_eq!(ilp.constraints.len(), 1); // 0 edges + 1 maximality
+    assert_eq!(ilp.num_vars(), 1);
+    assert_eq!(ilp.constraints().len(), 1); // 0 edges + 1 maximality
 }
diff --git a/src/unit_tests/rules/maximum2satisfiability_ilp.rs b/src/unit_tests/rules/maximum2satisfiability_ilp.rs
index 52bdf45ac..758a80d6a 100644
--- a/src/unit_tests/rules/maximum2satisfiability_ilp.rs
+++ b/src/unit_tests/rules/maximum2satisfiability_ilp.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::models::algebraic::{Comparison, ObjectiveSense, ILP};
 use crate::models::formula::CNFClause;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 
@@ -23,36 +23,32 @@ fn make_canonical_instance() -> Maximum2Satisfiability {
 #[test]
 fn test_maximum2satisfiability_to_ilp_closed_loop() {
     let problem = make_canonical_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_optimization_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "Maximum2Satisfiability->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     // Optimal: 6 satisfied clauses
-    let value = problem.evaluate(&extracted);
+    let value = problem.evaluate(&extracted).unwrap();
     assert_eq!(value, crate::types::Max(Some(6)));
 }
 
 #[test]
 fn test_maximum2satisfiability_to_ilp_bf_vs_ilp() {
     let problem = make_canonical_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    let bf_solutions = BruteForce::new().find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     assert!(ilp_value.is_valid());
@@ -61,36 +57,36 @@ fn test_maximum2satisfiability_to_ilp_bf_vs_ilp() {
 #[test]
 fn test_maximum2satisfiability_to_ilp_structure() {
     let problem = make_canonical_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 4 truth variables + 7 clause indicators = 11 ILP variables
     assert_eq!(ilp.num_vars(), 11);
     // One constraint per clause
     assert_eq!(ilp.num_constraints(), 7);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
 
     // Objective: maximize sum of z_4..z_10
-    let expected_objective: Vec<(usize, f64)> = (4..11).map(|j| (j, 1.0)).collect();
-    assert_eq!(ilp.objective, expected_objective);
+    let expected_objective: Vec<(usize, i64)> = (4..11).map(|j| (j, 1)).collect();
+    assert_eq!(ilp.objective(), expected_objective);
 
     // Check first constraint: clause (x1 OR x2) -> z_4 - y_0 - y_1 <= 0
-    let c0 = &ilp.constraints[0];
-    assert_eq!(c0.cmp, Comparison::Le);
-    assert_eq!(c0.rhs, 0.0); // 0 negated literals
-    assert_eq!(c0.terms, vec![(4, 1.0), (0, -1.0), (1, -1.0)]);
+    let c0 = &ilp.constraints()[0];
+    assert_eq!(c0.comparison(), Comparison::Le);
+    assert_eq!(c0.rhs(), 0); // 0 negated literals
+    assert_eq!(c0.terms(), vec![(0, -1), (1, -1), (4, 1)]);
 
     // Check constraint for clause (~x1 OR x3) -> z_6 + y_0 - y_2 <= 1
-    let c2 = &ilp.constraints[2];
-    assert_eq!(c2.cmp, Comparison::Le);
-    assert_eq!(c2.rhs, 1.0); // 1 negated literal
-    assert_eq!(c2.terms, vec![(6, 1.0), (0, 1.0), (2, -1.0)]);
+    let c2 = &ilp.constraints()[2];
+    assert_eq!(c2.comparison(), Comparison::Le);
+    assert_eq!(c2.rhs(), 1); // 1 negated literal
+    assert_eq!(c2.terms(), vec![(0, 1), (2, -1), (6, 1)]);
 
     // Check constraint for clause (~x1 OR ~x3) -> z_7 + y_0 + y_2 <= 2
-    let c3 = &ilp.constraints[3];
-    assert_eq!(c3.cmp, Comparison::Le);
-    assert_eq!(c3.rhs, 2.0); // 2 negated literals
-    assert_eq!(c3.terms, vec![(7, 1.0), (0, 1.0), (2, 1.0)]);
+    let c3 = &ilp.constraints()[3];
+    assert_eq!(c3.comparison(), Comparison::Le);
+    assert_eq!(c3.rhs(), 2); // 2 negated literals
+    assert_eq!(c3.terms(), vec![(0, 1), (2, 1), (7, 1)]);
 }
 
 #[test]
@@ -101,13 +97,13 @@ fn test_maximum2satisfiability_to_ilp_all_satisfiable() {
         2,
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![1, -2])],
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     // Both clauses should be satisfiable
     assert_eq!(value, crate::types::Max(Some(2)));
 }
@@ -124,7 +120,13 @@ fn test_maximum2satisfiability_to_ilp_canonical_example_spec() {
     assert_eq!(example.source.problem, "Maximum2Satisfiability");
     assert_eq!(example.target.problem, "ILP");
     assert_eq!(example.source.instance["num_vars"], 4);
-    assert_eq!(example.target.instance["num_vars"], 11);
+    assert_eq!(
+        example.target.instance["variables"]
+            .as_array()
+            .unwrap()
+            .len(),
+        11
+    );
     assert_eq!(
         example.target.instance["constraints"]
             .as_array()
@@ -135,8 +137,8 @@ fn test_maximum2satisfiability_to_ilp_canonical_example_spec() {
     assert_eq!(
         example.solutions,
         vec![crate::export::SolutionPair {
-            source_config: vec![1, 1, 0, 1],
-            target_config: vec![1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1],
+            source_config: serde_json::json!(vec![true, true, false, true]),
+            target_config: serde_json::json!(vec![1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1]),
         }]
     );
 }
diff --git a/src/unit_tests/rules/maximum2satisfiability_maxcut.rs b/src/unit_tests/rules/maximum2satisfiability_maxcut.rs
index 16863af58..17bf8c50f 100644
--- a/src/unit_tests/rules/maximum2satisfiability_maxcut.rs
+++ b/src/unit_tests/rules/maximum2satisfiability_maxcut.rs
@@ -22,7 +22,8 @@ fn make_issue_instance() -> Maximum2Satisfiability {
 #[test]
 fn test_maximum2satisfiability_to_maxcut_closed_loop() {
     let source = make_issue_instance();
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -34,7 +35,8 @@ fn test_maximum2satisfiability_to_maxcut_closed_loop() {
 #[test]
 fn test_maximum2satisfiability_to_maxcut_structure() {
     let source = make_issue_instance();
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 4);
@@ -46,27 +48,28 @@ fn test_maximum2satisfiability_to_maxcut_structure() {
     assert_eq!(target.edge_weight(1, 3), None);
     assert_eq!(target.edge_weight(2, 3), Some(&-1));
 
-    let source_solution = vec![0, 1, 1];
-    let target_solution = vec![0, 1, 0, 0];
-    assert_eq!(source.evaluate(&source_solution), Max(Some(5)));
-    assert_eq!(target.evaluate(&target_solution), Max(Some(2)));
+    let source_solution = vec![false, true, true];
+    let target_solution = vec![false, true, false, false];
+    assert_eq!(source.evaluate(&source_solution).unwrap(), Max(Some(5)));
+    assert_eq!(target.evaluate(&target_solution).unwrap(), Max(Some(2)));
 }
 
 #[test]
 fn test_maximum2satisfiability_to_maxcut_issue_affine_relation_on_all_partitions() {
     let source = make_issue_instance();
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // For this issue instance, every partition satisfies
     // 2 * satisfied_clauses = 8 + cut_weight.
     for mask in 0..(1usize << target.num_vertices()) {
-        let target_solution: Vec<usize> = (0..target.num_vertices())
-            .map(|bit| (mask >> bit) & 1)
+        let target_solution: Vec<bool> = (0..target.num_vertices())
+            .map(|bit| ((mask >> bit) & 1) == 1)
             .collect();
-        let source_solution = reduction.extract_solution(&target_solution);
-        let satisfied = source.evaluate(&source_solution).unwrap() as i32;
-        let cut_weight = target.evaluate(&target_solution).unwrap();
+        let source_solution = reduction.extract_solution(&target_solution).unwrap();
+        let satisfied = source.evaluate(&source_solution).unwrap().unwrap();
+        let cut_weight = target.evaluate(&target_solution).unwrap().unwrap();
 
         assert_eq!(
             2 * satisfied,
@@ -79,12 +82,29 @@ fn test_maximum2satisfiability_to_maxcut_issue_affine_relation_on_all_partitions
 #[test]
 fn test_maximum2satisfiability_to_maxcut_extract_solution_uses_reference_vertex() {
     let source = make_issue_instance();
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).expect("reduction should succeed");
 
-    assert_eq!(reduction.extract_solution(&[0, 1, 0, 0]), vec![0, 1, 1]);
-    assert_eq!(reduction.extract_solution(&[1, 0, 1, 1]), vec![0, 1, 1]);
     assert_eq!(
-        source.evaluate(&reduction.extract_solution(&[1, 0, 1, 1])),
+        reduction
+            .extract_solution(&vec![false, true, false, false])
+            .unwrap(),
+        vec![false, true, true]
+    );
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![true, false, true, true])
+            .unwrap(),
+        vec![false, true, true]
+    );
+    assert_eq!(
+        source
+            .evaluate(
+                &reduction
+                    .extract_solution(&vec![true, false, true, true])
+                    .unwrap()
+            )
+            .unwrap(),
         Max(Some(5))
     );
 }
@@ -99,7 +119,8 @@ fn test_maximum2satisfiability_to_maxcut_handles_duplicate_and_tautological_clau
             CNFClause::new(vec![-2, -2]),
         ],
     );
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 3);
@@ -142,8 +163,8 @@ fn test_maximum2satisfiability_to_maxcut_canonical_example_spec() {
     assert_eq!(
         example.solutions,
         vec![crate::export::SolutionPair {
-            source_config: vec![0, 1, 1],
-            target_config: vec![0, 1, 0, 0],
+            source_config: serde_json::json!(vec![false, true, true]),
+            target_config: serde_json::json!(vec![false, true, false, false]),
         }]
     );
 }
diff --git a/src/unit_tests/rules/maximumclique_ilp.rs b/src/unit_tests/rules/maximumclique_ilp.rs
index 21d24c1ae..4cc94c341 100644
--- a/src/unit_tests/rules/maximumclique_ilp.rs
+++ b/src/unit_tests/rules/maximumclique_ilp.rs
@@ -3,11 +3,11 @@ use crate::solvers::ILPSolver;
 
 /// Check if a configuration represents a valid clique in the graph.
 /// A clique is valid if all selected vertices are pairwise adjacent.
-fn is_valid_clique(problem: &MaximumClique<SimpleGraph, i32>, config: &[usize]) -> bool {
+fn is_valid_clique(problem: &MaximumClique<SimpleGraph, i64>, config: &[bool]) -> bool {
     let selected: Vec<usize> = config
         .iter()
         .enumerate()
-        .filter(|(_, &v)| v == 1)
+        .filter(|(_, &selected)| selected)
         .map(|(i, _)| i)
         .collect();
 
@@ -23,21 +23,21 @@ fn is_valid_clique(problem: &MaximumClique<SimpleGraph, i32>, config: &[usize])
 }
 
 /// Compute the clique size (sum of weights of selected vertices).
-fn clique_size(problem: &MaximumClique<SimpleGraph, i32>, config: &[usize]) -> i32 {
+fn clique_size(problem: &MaximumClique<SimpleGraph, i64>, config: &[bool]) -> i64 {
     config
         .iter()
         .enumerate()
-        .filter(|(_, &v)| v == 1)
+        .filter(|(_, &selected)| selected)
         .map(|(i, _)| problem.weights()[i])
         .sum()
 }
 
 /// Find maximum clique size by brute force enumeration.
-fn brute_force_max_clique(problem: &MaximumClique<SimpleGraph, i32>) -> i32 {
+fn brute_force_max_clique(problem: &MaximumClique<SimpleGraph, i64>) -> i64 {
     let n = problem.graph().num_vertices();
     let mut max_size = 0;
     for mask in 0..(1 << n) {
-        let config: Vec<usize> = (0..n).map(|i| (mask >> i) & 1).collect();
+        let config: Vec<bool> = (0..n).map(|i| ((mask >> i) & 1) != 0).collect();
         if is_valid_clique(problem, &config) {
             let size = clique_size(problem, &config);
             if size > max_size {
@@ -52,65 +52,67 @@ fn brute_force_max_clique(problem: &MaximumClique<SimpleGraph, i32>) -> i32 {
 fn test_reduction_creates_valid_ilp() {
     // Triangle graph: 3 vertices, 3 edges (complete graph K3)
     // All pairs are adjacent, so no constraints should be added
-    let problem: MaximumClique<SimpleGraph, i32> = MaximumClique::new(
+    let problem: MaximumClique<SimpleGraph, i64> = MaximumClique::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![1; 3],
     );
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check ILP structure
-    assert_eq!(ilp.num_vars, 3, "Should have one variable per vertex");
+    assert_eq!(ilp.num_vars(), 3, "Should have one variable per vertex");
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         0,
         "Complete graph has no non-edges, so no constraints"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize, "Should maximize");
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize, "Should maximize");
 }
 
 #[test]
 fn test_reduction_with_non_edges() {
     // Path graph 0-1-2: edges (0,1) and (1,2), non-edge (0,2)
-    let problem: MaximumClique<SimpleGraph, i32> =
+    let problem: MaximumClique<SimpleGraph, i64> =
         MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1; 3]);
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Should have 1 constraint for non-edge (0, 2)
-    assert_eq!(ilp.constraints.len(), 1);
+    assert_eq!(ilp.constraints().len(), 1);
 
     // The constraint should be x_0 + x_2 <= 1
-    let constraint = &ilp.constraints[0];
-    assert_eq!(constraint.terms.len(), 2);
-    assert!((constraint.rhs - 1.0).abs() < 1e-9);
+    let constraint = &ilp.constraints()[0];
+    assert_eq!(constraint.terms().len(), 2);
+    assert_eq!(constraint.rhs(), 1);
 }
 
 #[test]
 fn test_reduction_weighted() {
-    let problem: MaximumClique<SimpleGraph, i32> =
+    let problem: MaximumClique<SimpleGraph, i64> =
         MaximumClique::new(SimpleGraph::new(3, vec![(0, 1)]), vec![5, 10, 15]);
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check that weights are correctly transferred to objective
-    let mut coeffs: Vec<f64> = vec![0.0; 3];
-    for &(var, coef) in &ilp.objective {
+    let mut coeffs: Vec<i64> = vec![0; 3];
+    for &(var, coef) in ilp.objective() {
         coeffs[var] = coef;
     }
-    assert!((coeffs[0] - 5.0).abs() < 1e-9);
-    assert!((coeffs[1] - 10.0).abs() < 1e-9);
-    assert!((coeffs[2] - 15.0).abs() < 1e-9);
+    assert_eq!(coeffs, vec![5, 10, 15]);
 }
 
 #[test]
 fn test_maximumclique_to_ilp_closed_loop() {
     // Triangle graph (K3): max clique = 3 vertices
-    let problem: MaximumClique<SimpleGraph, i32> = MaximumClique::new(
+    let problem: MaximumClique<SimpleGraph, i64> = MaximumClique::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![1; 3],
     );
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
@@ -120,7 +122,7 @@ fn test_maximumclique_to_ilp_closed_loop() {
 
     // Solve via ILP reduction
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Both should find optimal size = 3 (all vertices form a clique)
     let ilp_size = clique_size(&problem, &extracted);
@@ -137,11 +139,12 @@ fn test_maximumclique_to_ilp_closed_loop() {
 #[test]
 fn test_ilp_solution_equals_brute_force_path() {
     // Path graph 0-1-2-3: max clique = 2 (any adjacent pair)
-    let problem: MaximumClique<SimpleGraph, i32> = MaximumClique::new(
+    let problem: MaximumClique<SimpleGraph, i64> = MaximumClique::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
         vec![1; 4],
     );
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
@@ -151,7 +154,7 @@ fn test_ilp_solution_equals_brute_force_path() {
 
     // Solve via ILP
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     let ilp_size = clique_size(&problem, &extracted);
 
     assert_eq!(bf_size, 2);
@@ -167,9 +170,10 @@ fn test_ilp_solution_equals_brute_force_weighted() {
     // Weights: [1, 100, 1]
     // Max clique by weight: {0, 1} (weight 101) or {1, 2} (weight 101), or just {1} (weight 100)
     // Since 0-1 and 1-2 are edges, both {0,1} and {1,2} are valid cliques
-    let problem: MaximumClique<SimpleGraph, i32> =
+    let problem: MaximumClique<SimpleGraph, i64> =
         MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1, 100, 1]);
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
@@ -177,7 +181,7 @@ fn test_ilp_solution_equals_brute_force_weighted() {
     let bf_obj = brute_force_max_clique(&problem);
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     let ilp_obj = clique_size(&problem, &extracted);
 
     assert_eq!(bf_obj, 101);
@@ -189,14 +193,15 @@ fn test_ilp_solution_equals_brute_force_weighted() {
 
 #[test]
 fn test_solution_extraction() {
-    let problem: MaximumClique<SimpleGraph, i32> =
+    let problem: MaximumClique<SimpleGraph, i64> =
         MaximumClique::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1; 4]);
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Test that extraction works correctly (1:1 mapping)
     let ilp_solution = vec![1, 1, 0, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![1, 1, 0, 0]);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![true, true, false, false]);
 
     // Verify this is a valid clique (0 and 1 are adjacent)
     assert!(is_valid_clique(&problem, &extracted));
@@ -204,35 +209,37 @@ fn test_solution_extraction() {
 
 #[test]
 fn test_ilp_structure() {
-    let problem: MaximumClique<SimpleGraph, i32> = MaximumClique::new(
+    let problem: MaximumClique<SimpleGraph, i64> = MaximumClique::new(
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
         vec![1; 5],
     );
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 5);
+    assert_eq!(ilp.num_vars(), 5);
     // Number of non-edges in a path of 5 vertices: C(5,2) - 4 = 10 - 4 = 6
-    assert_eq!(ilp.constraints.len(), 6);
+    assert_eq!(ilp.constraints().len(), 6);
 }
 
 #[test]
 fn test_empty_graph() {
     // Graph with no edges: max clique = 1 (any single vertex)
-    let problem: MaximumClique<SimpleGraph, i32> =
+    let problem: MaximumClique<SimpleGraph, i64> =
         MaximumClique::new(SimpleGraph::new(3, vec![]), vec![1; 3]);
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // All pairs are non-edges, so 3 constraints
-    assert_eq!(ilp.constraints.len(), 3);
+    assert_eq!(ilp.constraints().len(), 3);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Only one vertex should be selected
-    assert_eq!(extracted.iter().sum::<usize>(), 1);
+    assert_eq!(extracted.iter().filter(|&&selected| selected).count(), 1);
 
     assert!(is_valid_clique(&problem, &extracted));
     assert_eq!(clique_size(&problem, &extracted), 1);
@@ -241,22 +248,23 @@ fn test_empty_graph() {
 #[test]
 fn test_complete_graph() {
     // Complete graph K4: max clique = 4 (all vertices)
-    let problem: MaximumClique<SimpleGraph, i32> = MaximumClique::new(
+    let problem: MaximumClique<SimpleGraph, i64> = MaximumClique::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
         vec![1; 4],
     );
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // No non-edges, so no constraints
-    assert_eq!(ilp.constraints.len(), 0);
+    assert_eq!(ilp.constraints().len(), 0);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // All vertices should be selected
-    assert_eq!(extracted, vec![1, 1, 1, 1]);
+    assert_eq!(extracted, vec![true, true, true, true]);
 
     assert!(is_valid_clique(&problem, &extracted));
     assert_eq!(clique_size(&problem, &extracted), 4);
@@ -266,22 +274,23 @@ fn test_complete_graph() {
 fn test_bipartite_graph() {
     // Bipartite graph: 0-2, 0-3, 1-2, 1-3 (two independent sets: {0,1} and {2,3})
     // Max clique = 2 (any edge, e.g., {0, 2})
-    let problem: MaximumClique<SimpleGraph, i32> = MaximumClique::new(
+    let problem: MaximumClique<SimpleGraph, i64> = MaximumClique::new(
         SimpleGraph::new(4, vec![(0, 2), (0, 3), (1, 2), (1, 3)]),
         vec![1; 4],
     );
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(is_valid_clique(&problem, &extracted));
     assert_eq!(clique_size(&problem, &extracted), 2);
 
     // Should select an adjacent pair
-    let sum: usize = extracted.iter().sum();
+    let sum: usize = extracted.iter().filter(|&&selected| selected).count();
     assert_eq!(sum, 2);
 }
 
@@ -289,19 +298,20 @@ fn test_bipartite_graph() {
 fn test_star_graph() {
     // Star graph: center 0 connected to 1, 2, 3
     // Max clique = 2 (center + any leaf)
-    let problem: MaximumClique<SimpleGraph, i32> = MaximumClique::new(
+    let problem: MaximumClique<SimpleGraph, i64> = MaximumClique::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]),
         vec![1; 4],
     );
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Non-edges: (1,2), (1,3), (2,3) = 3 constraints
-    assert_eq!(ilp.constraints.len(), 3);
+    assert_eq!(ilp.constraints().len(), 3);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(is_valid_clique(&problem, &extracted));
     assert_eq!(clique_size(&problem, &extracted), 2);
@@ -309,10 +319,11 @@ fn test_star_graph() {
 
 #[test]
 fn test_maximumclique_to_ilp_bf_vs_ilp() {
-    let problem: MaximumClique<SimpleGraph, i32> = MaximumClique::new(
+    let problem: MaximumClique<SimpleGraph, i64> = MaximumClique::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
         vec![1; 4],
     );
-    let reduction: ReductionCliqueToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionCliqueToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/maximumclique_maximumindependentset.rs b/src/unit_tests/rules/maximumclique_maximumindependentset.rs
index 39ede01a4..2097108cf 100644
--- a/src/unit_tests/rules/maximumclique_maximumindependentset.rs
+++ b/src/unit_tests/rules/maximumclique_maximumindependentset.rs
@@ -12,9 +12,10 @@ fn test_maximumclique_to_maximumindependentset_closed_loop() {
     // Complement has edges {(0,2),(0,3),(1,3)}, MIS of size 2.
     let source = MaximumClique::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Verify complement graph structure
@@ -35,31 +36,33 @@ fn test_maximumclique_to_maximumindependentset_triangle() {
     // MIS on empty graph = all vertices
     let source = MaximumClique::new(
         SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Complement of K3 has no edges
     assert_eq!(target.graph().num_edges(), 0);
 
     let solver = BruteForce::new();
-    let target_solutions = solver.find_all_witnesses(target);
+    let target_solutions = solver.find_all_witnesses(target).unwrap();
 
     // MIS on empty graph is all vertices selected
     assert!(target_solutions
         .iter()
-        .any(|s| s.iter().sum::<usize>() == 3));
+        .any(|s| s.iter().filter(|&&selected| selected).count() == 3));
 
     // Extract solution: should be the full clique {0,1,2}
-    let source_sol = reduction.extract_solution(&target_solutions[0]);
-    assert_eq!(source.evaluate(&source_sol).unwrap(), 3);
+    let source_sol = reduction.extract_solution(&target_solutions[0]).unwrap();
+    assert_eq!(source.evaluate(&source_sol).unwrap().unwrap(), 3);
 }
 
 #[test]
 fn test_maximumclique_to_maximumindependentset_weights_preserved() {
     let source = MaximumClique::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![10, 20, 30]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.weights().to_vec(), vec![10, 20, 30]);
@@ -69,31 +72,33 @@ fn test_maximumclique_to_maximumindependentset_weights_preserved() {
 fn test_maximumclique_to_maximumindependentset_empty_graph() {
     // Empty graph (no edges): complement is complete graph
     // Max clique in empty graph = any single vertex
-    let source = MaximumClique::new(SimpleGraph::new(3, vec![]), vec![1i32; 3]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let source = MaximumClique::new(SimpleGraph::new(3, vec![]), vec![1i64; 3]);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Complement of empty graph is K3
     assert_eq!(target.graph().num_edges(), 3);
 
     let solver = BruteForce::new();
-    let target_solutions = solver.find_all_witnesses(target);
+    let target_solutions = solver.find_all_witnesses(target).unwrap();
 
     // MIS on K3 is any single vertex
     assert!(target_solutions
         .iter()
-        .all(|s| s.iter().sum::<usize>() == 1));
+        .all(|s| s.iter().filter(|&&selected| selected).count() == 1));
 }
 
 #[test]
 fn test_maximumclique_to_maximumindependentset_one_weights_closed_loop() {
-    // Same P4 as the i32 closed-loop test, but with unit weights so the
-    // reduction stays on the <SimpleGraph, One> endpoint (no i32 detour).
+    // Same P4 as the i64 closed-loop test, but with unit weights so the
+    // reduction stays on the <SimpleGraph, One> endpoint (no i64 detour).
     let source = MaximumClique::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
         vec![One; 4],
     );
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.graph().num_vertices(), 4);
@@ -108,12 +113,13 @@ fn test_maximumclique_to_maximumindependentset_one_weights_closed_loop() {
 
 #[test]
 fn test_maximumclique_to_maximumindependentset_overhead() {
-    // Verify overhead formula: complement edges = n*(n-1)/2 - m
+    // Verify exact size formula: complement edges = n*(n-1)/2 - m
     let source = MaximumClique::new(
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
-        vec![1i32; 5],
+        vec![1i64; 5],
     );
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.graph().num_vertices(), 5);
diff --git a/src/unit_tests/rules/maximumcokplex_ilp.rs b/src/unit_tests/rules/maximumcokplex_ilp.rs
index 18e0c8dc9..aa92d32f2 100644
--- a/src/unit_tests/rules/maximumcokplex_ilp.rs
+++ b/src/unit_tests/rules/maximumcokplex_ilp.rs
@@ -1,9 +1,7 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
 use crate::models::graph::MaximumCoKPlex;
-use crate::rules::test_helpers::{
-    assert_bf_vs_ilp, assert_optimization_round_trip_from_optimization_target,
-};
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::ILPSolver;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
@@ -14,78 +12,79 @@ fn c5() -> SimpleGraph {
     SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)])
 }
 
-fn issue_instance() -> MaximumCoKPlex<SimpleGraph, i32, KN> {
-    MaximumCoKPlex::<_, i32, KN>::with_k(c5(), vec![5, 1, 4, 1, 3], 2)
+fn issue_instance() -> MaximumCoKPlex<SimpleGraph, i64, KN> {
+    MaximumCoKPlex::<_, i64, KN>::with_k(c5(), vec![5, 1, 4, 1, 3], 2)
 }
 
 #[test]
 fn test_maximumcokplex_to_ilp_closed_loop() {
     let source = issue_instance();
-    let reduction: ReductionCoKPlexToILP<i32> = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "MaximumCoKPlex -> ILP closed loop",
-    );
+    let reduction: ReductionCoKPlexToILP<i64> =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
 fn test_maximumcokplex_to_ilp_issue_structure() {
     let source = issue_instance();
-    let reduction: ReductionCoKPlexToILP<i32> = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionCoKPlexToILP<i64> =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 5);
-    assert_eq!(ilp.constraints.len(), 5);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.num_vars(), 5);
+    assert_eq!(ilp.constraints().len(), 5);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
     assert_eq!(
-        ilp.objective,
-        vec![(0, 5.0), (1, 1.0), (2, 4.0), (3, 1.0), (4, 3.0)]
+        ilp.objective(),
+        vec![(0, 5), (1, 1), (2, 4), (3, 1), (4, 3)]
     );
 
     let expected_constraints = vec![
-        vec![(0, 2.0), (1, 1.0), (4, 1.0)],
-        vec![(0, 1.0), (1, 2.0), (2, 1.0)],
-        vec![(1, 1.0), (2, 2.0), (3, 1.0)],
-        vec![(2, 1.0), (3, 2.0), (4, 1.0)],
-        vec![(0, 1.0), (3, 1.0), (4, 2.0)],
+        vec![(0, 2), (1, 1), (4, 1)],
+        vec![(0, 1), (1, 2), (2, 1)],
+        vec![(1, 1), (2, 2), (3, 1)],
+        vec![(2, 1), (3, 2), (4, 1)],
+        vec![(0, 1), (3, 1), (4, 2)],
     ];
-    for (constraint, expected_terms) in ilp.constraints.iter().zip(expected_constraints) {
-        let mut terms = constraint.terms.clone();
+    for (constraint, expected_terms) in ilp.constraints().iter().zip(expected_constraints) {
+        let mut terms = constraint.terms().to_vec();
         terms.sort_by_key(|(var, _)| *var);
         assert_eq!(terms, expected_terms);
-        assert!((constraint.rhs - 3.0).abs() < 1e-9);
+        assert_eq!(constraint.rhs(), 3);
     }
 }
 
 #[test]
 fn test_maximumcokplex_to_ilp_bf_vs_ilp() {
     let source = issue_instance();
-    let reduction: ReductionCoKPlexToILP<i32> = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionCoKPlexToILP<i64> =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
 fn test_maximumcokplex_to_ilp_k_equals_1_regression() {
     let source = MaximumCoKPlex::<_, One, KN>::with_k(c5(), vec![One; 5], 1);
-    let reduction: ReductionCoKPlexToILP<One> = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionCoKPlexToILP<One> =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("k=1 instance should be ILP-solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(source.evaluate(&extracted), Max(Some(2)));
-    assert_eq!(extracted.iter().sum::<usize>(), 2);
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(2)));
+    assert_eq!(extracted.iter().filter(|&&selected| selected).count(), 2);
     assert!(source.is_valid_solution(&extracted));
 }
 
 #[test]
 fn test_maximumcokplex_to_ilp_extract_solution_identity() {
     let source = issue_instance();
-    let reduction: ReductionCoKPlexToILP<i32> = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionCoKPlexToILP<i64> =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let target_solution = vec![1, 0, 1, 0, 1];
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
-    assert_eq!(extracted, target_solution);
-    assert_eq!(source.evaluate(&extracted), Max(Some(12)));
+    assert_eq!(extracted, vec![true, false, true, false, true]);
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(12)));
 }
diff --git a/src/unit_tests/rules/maximumcommonedgesubgraph_ilp.rs b/src/unit_tests/rules/maximumcommonedgesubgraph_ilp.rs
index c606ef50c..7d63945d2 100644
--- a/src/unit_tests/rules/maximumcommonedgesubgraph_ilp.rs
+++ b/src/unit_tests/rules/maximumcommonedgesubgraph_ilp.rs
@@ -39,7 +39,8 @@ fn truncated_instance() -> MaximumCommonEdgeSubgraph {
 #[test]
 fn test_maximumcommonedgesubgraph_to_ilp_structure() {
     let source = matched_paths();
-    let reduction: ReductionMCESToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionMCESToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n1 = 3, n2 = 3 → 9 x-variables. Label-compatible arc pairs: (a,0)<->(b,0)
@@ -47,25 +48,26 @@ fn test_maximumcommonedgesubgraph_to_ilp_structure() {
     // incompatible, so y_pairs = 2.
     let num_x = 9;
     let num_y = 2;
-    assert_eq!(ilp.num_vars, num_x + num_y);
+    assert_eq!(ilp.num_vars(), num_x + num_y);
     // 3 row + 3 column + 3 McCormick constraints per y pair.
-    assert_eq!(ilp.constraints.len(), 3 + 3 + 3 * num_y);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.constraints().len(), 3 + 3 + 3 * num_y);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
     // Objective is sum of y variables only.
-    assert_eq!(ilp.objective, vec![(num_x, 1.0), (num_x + 1, 1.0)]);
+    assert_eq!(ilp.objective(), vec![(num_x, 1), (num_x + 1, 1)]);
 }
 
 #[test]
 fn test_maximumcommonedgesubgraph_to_ilp_closed_loop() {
     let source = matched_paths();
-    let reduction: ReductionMCESToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionMCESToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("matched paths ILP must be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(source.is_valid_solution(&extracted));
-    assert_eq!(source.evaluate(&extracted), Max(Some(2)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(2)));
     // Optimal mapping preserves both arcs by aligning 0->0, 1->1, 2->2.
     assert_eq!(extracted, vec![0, 1, 2]);
 }
@@ -73,28 +75,30 @@ fn test_maximumcommonedgesubgraph_to_ilp_closed_loop() {
 #[test]
 fn test_maximumcommonedgesubgraph_to_ilp_bf_vs_ilp() {
     let source = matched_paths();
-    let reduction: ReductionMCESToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionMCESToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
 fn test_maximumcommonedgesubgraph_to_ilp_truncated_target() {
     let source = truncated_instance();
-    let reduction: ReductionMCESToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionMCESToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n1=3, n2=2 → 6 x-vars; only the label-0 arc has a match, so 1 y-var.
-    assert_eq!(ilp.num_vars, 6 + 1);
+    assert_eq!(ilp.num_vars(), 6 + 1);
     // 3 row + 2 column + 3 McCormick.
-    assert_eq!(ilp.constraints.len(), 3 + 2 + 3);
+    assert_eq!(ilp.constraints().len(), 3 + 2 + 3);
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("truncated ILP must be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(source.is_valid_solution(&extracted));
-    assert_eq!(source.evaluate(&extracted), Max(Some(1)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(1)));
 }
 
 #[test]
@@ -105,19 +109,20 @@ fn test_maximumcommonedgesubgraph_to_ilp_empty_graphs() {
         LabelledDigraph::new(2, vec![]),
         LabelledDigraph::new(2, vec![]),
     );
-    let reduction: ReductionMCESToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionMCESToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 2 * 2);
-    assert_eq!(ilp.constraints.len(), 2 + 2);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 2 * 2);
+    assert_eq!(ilp.constraints().len(), 2 + 2);
+    assert!(ilp.objective().is_empty());
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("empty-arc ILP must be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert!(source.is_valid_solution(&extracted));
-    assert_eq!(source.evaluate(&extracted), Max(Some(0)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(0)));
 }
 
 #[test]
@@ -128,13 +133,14 @@ fn test_maximumcommonedgesubgraph_to_ilp_self_loop() {
         LabelledDigraph::new(1, vec![LabelledArc::new(0, 3, 0)]),
         LabelledDigraph::new(2, vec![LabelledArc::new(1, 3, 1)]),
     );
-    let reduction: ReductionMCESToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionMCESToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("self-loop ILP must be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(source.is_valid_solution(&extracted));
-    assert_eq!(source.evaluate(&extracted), Max(Some(1)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(1)));
     assert_eq!(extracted, vec![1]);
 }
diff --git a/src/unit_tests/rules/maximumcontactmapoverlap_ilp.rs b/src/unit_tests/rules/maximumcontactmapoverlap_ilp.rs
index 0636b736e..75b2378ce 100644
--- a/src/unit_tests/rules/maximumcontactmapoverlap_ilp.rs
+++ b/src/unit_tests/rules/maximumcontactmapoverlap_ilp.rs
@@ -17,14 +17,15 @@ fn canonical_instance() -> MaximumContactMapOverlap {
 #[test]
 fn test_maximumcontactmapoverlap_to_ilp_structure() {
     let source = canonical_instance();
-    let reduction: ReductionCMOToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionCMOToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n1=4, n2=5 -> 20 x-variables. |E_1|=2, |E_2|=3 -> 6 y-variables.
     let num_x = 4 * 5;
     let num_y = 2 * 3;
-    assert_eq!(ilp.num_vars, num_x + num_y);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.num_vars(), num_x + num_y);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
 
     // Constraint shape:
     //   4 row + 5 column
@@ -33,25 +34,26 @@ fn test_maximumcontactmapoverlap_to_ilp_structure() {
     // + 2 link constraints per y, so 2 * 6 = 12.
     let order_pairs = (4 * 3 / 2) * (5 * 6 / 2);
     let expected_constraints = 4 + 5 + order_pairs + 2 * num_y;
-    assert_eq!(ilp.constraints.len(), expected_constraints);
+    assert_eq!(ilp.constraints().len(), expected_constraints);
 
     // Objective is the sum of y variables only.
-    let expected_obj: Vec<(usize, f64)> = (0..num_y).map(|s| (num_x + s, 1.0)).collect();
-    assert_eq!(ilp.objective, expected_obj);
+    let expected_obj: Vec<(usize, i64)> = (0..num_y).map(|s| (num_x + s, 1)).collect();
+    assert_eq!(ilp.objective(), expected_obj);
 }
 
 #[test]
 fn test_maximumcontactmapoverlap_to_ilp_closed_loop() {
     let source = canonical_instance();
-    let reduction: ReductionCMOToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionCMOToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("canonical CMO ILP must be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // The optimal alignment preserves both contacts of G_1.
     assert!(source.is_valid_solution(&extracted));
-    assert_eq!(source.evaluate(&extracted), Max(Some(2)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(2)));
 }
 
 #[test]
@@ -59,27 +61,29 @@ fn test_maximumcontactmapoverlap_to_ilp_trivial_no_contacts() {
     // Both contact maps empty: optimum is 0 and the resulting ILP has no
     // y-variables and no link constraints.
     let source = MaximumContactMapOverlap::new(2, vec![], 2, vec![]);
-    let reduction: ReductionCMOToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionCMOToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n1=2, n2=2 -> 4 x-variables, 0 y-variables.
-    assert_eq!(ilp.num_vars, 4);
+    assert_eq!(ilp.num_vars(), 4);
     // 2 row + 2 column + C(2,2)=1 ordered-pair * (2*3/2)=3 = 3 order-pres + 0 link.
-    assert_eq!(ilp.constraints.len(), 2 + 2 + 3);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.constraints().len(), 2 + 2 + 3);
+    assert!(ilp.objective().is_empty());
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("empty-contact ILP must be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert!(source.is_valid_solution(&extracted));
-    assert_eq!(source.evaluate(&extracted), Max(Some(0)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(0)));
 }
 
 #[test]
 fn test_maximumcontactmapoverlap_to_ilp_bf_vs_ilp() {
     let source = canonical_instance();
-    let reduction: ReductionCMOToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionCMOToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     assert_bf_vs_ilp(&source, &reduction);
 }
 
@@ -93,14 +97,15 @@ fn test_maximumcontactmapoverlap_to_ilp_order_preserving_forbidden() {
     // out. The straight alignment 0->0, ?, 2->2 preserves the same contact, so
     // the optimum is still 1.
     let source = MaximumContactMapOverlap::new(3, vec![(0, 2)], 3, vec![(0, 2)]);
-    let reduction: ReductionCMOToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionCMOToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP must be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(source.is_valid_solution(&extracted));
-    assert_eq!(source.evaluate(&extracted), Max(Some(1)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(1)));
     // is_valid_solution checks order-preservation; just additionally verify no
     // crossing was selected.
     let nonzero: Vec<usize> = extracted.iter().copied().filter(|&v| v != 0).collect();
@@ -117,13 +122,14 @@ fn test_maximumcontactmapoverlap_to_ilp_extract_solution_partial() {
     // No contacts -> objective 0 -> ILP solver may pick the zero vector,
     // leaving every residue unmatched.
     let source = MaximumContactMapOverlap::new(2, vec![], 3, vec![]);
-    let reduction: ReductionCMOToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionCMOToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     // Hand-built solution: x_(0,1)=1, x_(1,2)=1, rest zero.
     let n2 = 3;
-    let mut target_sol = vec![0usize; reduction.target_problem().num_vars];
+    let mut target_sol = vec![0_i64; reduction.target_problem().num_vars()];
     target_sol[1] = 1;
     target_sol[n2 + 2] = 1;
-    let extracted = reduction.extract_solution(&target_sol);
+    let extracted = reduction.extract_solution(&target_sol).unwrap();
     // Encoding: vertex j of G_2 is represented as j+1.
     assert_eq!(extracted, vec![2, 3]);
     assert!(source.is_valid_solution(&extracted));
diff --git a/src/unit_tests/rules/maximumdomaticnumber_ilp.rs b/src/unit_tests/rules/maximumdomaticnumber_ilp.rs
index 1c8cb7e4f..54a6e2e1a 100644
--- a/src/unit_tests/rules/maximumdomaticnumber_ilp.rs
+++ b/src/unit_tests/rules/maximumdomaticnumber_ilp.rs
@@ -8,50 +8,52 @@ use crate::types::Max;
 fn test_maximumdomaticnumber_to_ilp_closed_loop() {
     // Path P3: 0-1-2, domatic number = 2
     let problem = MaximumDomaticNumber::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction: ReductionDomaticNumberToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDomaticNumberToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve with brute force on original problem
-    let bf_witness = bf.find_witness(&problem).unwrap();
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_witness = bf.solve(&problem).unwrap().unwrap();
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
 
     // Solve via ILP reduction
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     // Both should find domatic number = 2
     assert_eq!(bf_value, Max(Some(2)));
     assert_eq!(ilp_value, Max(Some(2)));
 
     // Verify the ILP solution is valid for the original problem
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_maximumdomaticnumber_to_ilp_structure() {
     // P3: 3 vertices
     let problem = MaximumDomaticNumber::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction: ReductionDomaticNumberToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDomaticNumberToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=3: n²+n = 12 variables
-    assert_eq!(ilp.num_vars, 12);
+    assert_eq!(ilp.num_vars(), 12);
 
     // Constraints: n + n² + n² = 3 + 9 + 9 = 21
-    assert_eq!(ilp.constraints.len(), 21);
+    assert_eq!(ilp.constraints().len(), 21);
 
     // Objective should be maximize
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
 
     // Objective should have 3 terms (y_0, y_1, y_2)
-    assert_eq!(ilp.objective.len(), 3);
-    for &(var, coef) in &ilp.objective {
+    assert_eq!(ilp.objective().len(), 3);
+    for &(var, coef) in ilp.objective() {
         assert!(var >= 9); // y_i at indices 9, 10, 11
-        assert!((coef - 1.0).abs() < 1e-9);
+        assert_eq!(coef, 1);
     }
 }
 
@@ -59,7 +61,8 @@ fn test_maximumdomaticnumber_to_ilp_structure() {
 fn test_maximumdomaticnumber_to_ilp_bf_vs_ilp() {
     // P3: 3 vertices, domatic number = 2
     let problem = MaximumDomaticNumber::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction: ReductionDomaticNumberToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDomaticNumberToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
@@ -67,13 +70,14 @@ fn test_maximumdomaticnumber_to_ilp_bf_vs_ilp() {
 fn test_maximumdomaticnumber_to_ilp_complete_graph() {
     // K3: domatic number = 3 (each vertex is its own dominating set)
     let problem = MaximumDomaticNumber::new(SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]));
-    let reduction: ReductionDomaticNumberToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDomaticNumberToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(value, Max(Some(3)));
 }
@@ -82,13 +86,14 @@ fn test_maximumdomaticnumber_to_ilp_complete_graph() {
 fn test_maximumdomaticnumber_to_ilp_single_vertex() {
     // Single vertex: domatic number = 1
     let problem = MaximumDomaticNumber::new(SimpleGraph::new(1, vec![]));
-    let reduction: ReductionDomaticNumberToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDomaticNumberToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(value, Max(Some(1)));
 }
@@ -97,7 +102,8 @@ fn test_maximumdomaticnumber_to_ilp_single_vertex() {
 fn test_maximumdomaticnumber_to_ilp_solution_extraction() {
     // P3: 0-1-2
     let problem = MaximumDomaticNumber::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction: ReductionDomaticNumberToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDomaticNumberToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manually construct an ILP solution: vertices 0,2 in set 0, vertex 1 in set 1
     // x_{0,0}=1, x_{0,1}=0, x_{0,2}=0,
@@ -105,10 +111,10 @@ fn test_maximumdomaticnumber_to_ilp_solution_extraction() {
     // x_{2,0}=1, x_{2,1}=0, x_{2,2}=0,
     // y_0=1, y_1=1, y_2=0
     let ilp_solution = vec![1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 1, 0]);
 
     // Verify this is a valid partition with 2 dominating sets
-    let value = problem.evaluate(&extracted);
+    let value = problem.evaluate(&extracted).unwrap();
     assert_eq!(value, Max(Some(2)));
 }
diff --git a/src/unit_tests/rules/maximumedgeweightedkclique_ilp.rs b/src/unit_tests/rules/maximumedgeweightedkclique_ilp.rs
index b6dccc002..aaf58b7ee 100644
--- a/src/unit_tests/rules/maximumedgeweightedkclique_ilp.rs
+++ b/src/unit_tests/rules/maximumedgeweightedkclique_ilp.rs
@@ -1,62 +1,56 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
 use crate::models::graph::MaximumEdgeWeightedKClique;
-use crate::rules::test_helpers::{
-    assert_bf_vs_ilp, assert_optimization_round_trip_from_optimization_target,
-};
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Max;
 
-fn issue_instance() -> MaximumEdgeWeightedKClique<i32> {
+fn issue_instance() -> MaximumEdgeWeightedKClique<i64> {
     // 4 vertices, edges (0,1),(0,2),(1,2),(0,3),(1,3) with weights [5,4,-1,1,0], k=3.
     // Optimum induced weight is 5 + 4 + (-1) = 8 on clique {0, 1, 2}.
-    MaximumEdgeWeightedKClique::<i32>::new(
+    MaximumEdgeWeightedKClique::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)]),
         vec![5, 4, -1, 1, 0],
         3,
     )
+    .unwrap()
 }
 
 #[test]
 fn test_maximumedgeweightedkclique_to_ilp_closed_loop() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "MaximumEdgeWeightedKClique -> ILP closed loop",
-    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
 fn test_maximumedgeweightedkclique_to_ilp_structure() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 4 vertex variables + 5 edge variables = 9.
-    assert_eq!(ilp.num_vars, 9);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.num_vars(), 9);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
     // Objective is on the edge variables (indices 4..9).
-    let weights: Vec<f64> = ilp.objective.iter().map(|(_, w)| *w).collect();
-    assert_eq!(weights, vec![5.0, 4.0, -1.0, 1.0, 0.0]);
+    assert_eq!(ilp.objective(), vec![(4, 5), (5, 4), (6, -1), (7, 1)]);
 }
 
 #[test]
 fn test_maximumedgeweightedkclique_to_ilp_extract_solution_identity() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let target_solution = vec![1, 1, 1, 0, 1, 1, 1, 0, 0];
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![1, 1, 1, 0]);
-    assert_eq!(source.evaluate(&extracted), Max(Some(8)));
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![true, true, true, false]);
+    assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(8)));
 }
 
 #[test]
 fn test_maximumedgeweightedkclique_to_ilp_bf_vs_ilp() {
     let source = issue_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     assert_bf_vs_ilp(&source, &reduction);
 }
 
@@ -66,16 +60,12 @@ fn test_maximumedgeweightedkclique_to_ilp_negative_weight_excluded_via_extra_con
     // size-3 clique exists, and its weight is -3. The McCormick lower bound
     // y >= x_u + x_v - 1 ensures negative-weight y's are forced to 1 when
     // both endpoints are selected.
-    let source = MaximumEdgeWeightedKClique::<i32>::new(
+    let source = MaximumEdgeWeightedKClique::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![-1, -1, -1],
         3,
-    );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "MaximumEdgeWeightedKClique -> ILP negative-weight triangle",
-    );
+    )
+    .unwrap();
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/maximumindependentset_gridgraph.rs b/src/unit_tests/rules/maximumindependentset_gridgraph.rs
index 1c19183d8..7053dde31 100644
--- a/src/unit_tests/rules/maximumindependentset_gridgraph.rs
+++ b/src/unit_tests/rules/maximumindependentset_gridgraph.rs
@@ -8,7 +8,7 @@ use crate::types::One;
 #[test]
 fn test_map_unweighted_produces_uniform_weights() {
     // Triangle graph
-    let result = ksg::map_unweighted(3, &[(0, 1), (1, 2), (0, 2)]);
+    let result = ksg::map_unweighted(3, &[(0, 1), (1, 2), (0, 2)]).unwrap();
     assert!(
         result.node_weights.iter().all(|&w| w == 1),
         "map_unweighted triangle should produce uniform weights, got: {:?}",
@@ -16,7 +16,7 @@ fn test_map_unweighted_produces_uniform_weights() {
     );
 
     // Path graph
-    let result2 = ksg::map_unweighted(3, &[(0, 1), (1, 2)]);
+    let result2 = ksg::map_unweighted(3, &[(0, 1), (1, 2)]).unwrap();
     assert!(
         result2.node_weights.iter().all(|&w| w == 1),
         "map_unweighted path should produce uniform weights, got: {:?}",
@@ -24,7 +24,7 @@ fn test_map_unweighted_produces_uniform_weights() {
     );
 
     // Cycle-5
-    let result3 = ksg::map_unweighted(5, &[(0, 1), (1, 2), (2, 3), (3, 4), (0, 4)]);
+    let result3 = ksg::map_unweighted(5, &[(0, 1), (1, 2), (2, 3), (3, 4), (0, 4)]).unwrap();
     assert!(
         result3.node_weights.iter().all(|&w| w == 1),
         "map_unweighted cycle5 should produce uniform weights, got: {:?}",
@@ -58,12 +58,14 @@ fn test_mis_simple_one_to_kings_one_is_deterministic_on_large_graph() {
 
     let problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![One; n]);
 
-    let first = ReduceTo::<MaximumIndependentSet<KingsSubgraph, One>>::reduce_to(&problem);
+    let first = ReduceTo::<MaximumIndependentSet<KingsSubgraph, One>>::reduce_to(&problem)
+        .expect("reduction should succeed");
     let baseline_atoms = first.target_problem().graph().num_vertices();
     let baseline_edges = first.target_problem().graph().edges().len();
 
     for _ in 0..3 {
-        let again = ReduceTo::<MaximumIndependentSet<KingsSubgraph, One>>::reduce_to(&problem);
+        let again = ReduceTo::<MaximumIndependentSet<KingsSubgraph, One>>::reduce_to(&problem)
+            .expect("reduction should succeed");
         assert_eq!(
             again.target_problem().graph().num_vertices(),
             baseline_atoms,
@@ -79,16 +81,55 @@ fn test_mis_simple_one_to_kings_one_closed_loop() {
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
         vec![One; 5],
     );
-    let result = ReduceTo::<MaximumIndependentSet<KingsSubgraph, One>>::reduce_to(&problem);
+    let result = ReduceTo::<MaximumIndependentSet<KingsSubgraph, One>>::reduce_to(&problem)
+        .expect("reduction should succeed");
     let target = result.target_problem();
     assert!(target.graph().num_vertices() > 5);
 
     let solver = BruteForce::new();
-    let grid_solutions = solver.find_all_witnesses(target);
+    let grid_solutions = solver.find_all_witnesses(target).unwrap();
     assert!(!grid_solutions.is_empty());
 
-    let original_solution = result.extract_solution(&grid_solutions[0]);
+    let original_solution = result.extract_solution(&grid_solutions[0]).unwrap();
     assert_eq!(original_solution.len(), 5);
-    let size: usize = original_solution.iter().sum();
+    let size: usize = original_solution
+        .iter()
+        .filter(|&&selected| selected)
+        .count();
     assert_eq!(size, 3, "Max IS in path of 5 should be 3");
 }
+
+#[test]
+fn test_mis_simple_one_to_kings_one_all_four_vertex_graphs() {
+    use crate::test_unitdiskmapping_algorithms::common::{
+        is_independent_set, solve_mis, solve_mis_config,
+    };
+
+    let possible_edges = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)];
+    for mask in 0..(1_usize << possible_edges.len()) {
+        let edges = possible_edges
+            .iter()
+            .enumerate()
+            .filter(|(index, _)| mask & (1 << index) != 0)
+            .map(|(_, &edge)| edge)
+            .collect::<Vec<_>>();
+        let source = MaximumIndependentSet::new(SimpleGraph::new(4, edges.clone()), vec![One; 4]);
+        let reduction =
+            ReduceTo::<MaximumIndependentSet<KingsSubgraph, One>>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        let target_solution =
+            solve_mis_config(target.graph().num_vertices(), &target.graph().edges());
+        let target_solution = crate::config::config_to_bits(&target_solution);
+        let source_solution = reduction.extract_solution(&target_solution).unwrap();
+
+        assert!(
+            is_independent_set(&edges, &crate::config::bits_to_config(&source_solution),),
+            "graph mask {mask:#08b} extracted a non-independent set"
+        );
+        assert_eq!(
+            source_solution.iter().filter(|&&value| value).count(),
+            solve_mis(4, &edges),
+            "graph mask {mask:#08b} did not preserve the optimum"
+        );
+    }
+}
diff --git a/src/unit_tests/rules/maximumindependentset_ilp.rs b/src/unit_tests/rules/maximumindependentset_ilp.rs
index ce3c165c5..b20f2b265 100644
--- a/src/unit_tests/rules/maximumindependentset_ilp.rs
+++ b/src/unit_tests/rules/maximumindependentset_ilp.rs
@@ -1,29 +1,25 @@
 use crate::models::algebraic::{ObjectiveSense, ILP};
 use crate::models::graph::MaximumIndependentSet;
-use crate::rules::{MinimizeSteps, ReductionChain, ReductionGraph, ReductionPath};
-use crate::solvers::{BruteForce, ILPSolver, Solver};
+use crate::rules::{ReductionChain, ReductionGraph, ReductionPath};
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
-use crate::types::{Max, ProblemSize};
+use crate::types::Max;
 
 fn reduce_mis_to_ilp(
-    problem: &MaximumIndependentSet<SimpleGraph, i32>,
+    problem: &MaximumIndependentSet<SimpleGraph, i64>,
 ) -> (ReductionPath, ReductionChain) {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
     let dst = ReductionGraph::variant_to_map(&ILP::<bool>::variant());
     let path = graph
-        .find_cheapest_path(
-            "MaximumIndependentSet",
-            &src,
-            "ILP",
-            &dst,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .expect("Should find path MaximumIndependentSet -> ILP");
+        .find_all_paths("MaximumIndependentSet", &src, "ILP", &dst)
+        .into_iter()
+        .find(|path| path.type_names() == ["MaximumIndependentSet", "MaximumSetPacking", "ILP"])
+        .expect("expected explicit MaximumSetPacking route");
     let chain = graph
         .reduce_along_path(&path, problem as &dyn std::any::Any)
+        .expect("MaximumIndependentSet -> ILP reduction should not fail")
         .expect("Should reduce MaximumIndependentSet to ILP along path");
     (path, chain)
 }
@@ -32,7 +28,7 @@ fn reduce_mis_to_ilp(
 fn test_maximumindependentset_to_ilp_via_path_structure() {
     let problem = MaximumIndependentSet::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
     let (path, chain) = reduce_mis_to_ilp(&problem);
     let ilp: &ILP<bool> = chain.target_problem();
@@ -48,27 +44,27 @@ fn test_maximumindependentset_to_ilp_via_path_structure() {
         "Expected 2-step path through MaxClique or MaxSetPacking, got {:?}",
         names
     );
-    assert_eq!(ilp.num_vars, 3);
-    assert_eq!(ilp.constraints.len(), 3);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.num_vars(), 3);
+    assert_eq!(ilp.constraints().len(), 3);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
 }
 
 #[test]
 fn test_maximumindependentset_to_ilp_via_path_closed_loop() {
     let problem = MaximumIndependentSet::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let (_, chain) = reduce_mis_to_ilp(&problem);
     let ilp: &ILP<bool> = chain.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = chain.extract_solution(&ilp_solution);
+    let extracted: Vec<bool> = chain.extract_solution(&ilp_solution).unwrap();
 
-    let ilp_size: usize = extracted.iter().sum();
+    let ilp_size = extracted.iter().filter(|&&selected| selected).count();
     assert_eq!(ilp_size, 2);
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
@@ -80,22 +76,23 @@ fn test_maximumindependentset_to_ilp_via_path_weighted() {
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = chain.extract_solution(&ilp_solution);
+    let extracted = chain.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), Max(Some(100)));
-    assert_eq!(extracted, vec![0, 1, 0]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(100)));
+    assert_eq!(extracted, vec![false, true, false]);
 }
 
 #[test]
 fn test_maximumindependentset_to_ilp_bf_vs_ilp() {
     let problem = MaximumIndependentSet::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let (_, chain) = reduce_mis_to_ilp(&problem);
     let ilp: &ILP<bool> = chain.target_problem();
-    let bf_value = BruteForce::new().solve(&problem);
+    let bf_value_solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+    let bf_value = problem.evaluate(&bf_value_solution).unwrap();
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = chain.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), bf_value);
+    let extracted = chain.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), bf_value);
 }
diff --git a/src/unit_tests/rules/maximumindependentset_integralflowbundles.rs b/src/unit_tests/rules/maximumindependentset_integralflowbundles.rs
deleted file mode 100644
index 7ee27a1ac..000000000
--- a/src/unit_tests/rules/maximumindependentset_integralflowbundles.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-use super::*;
-use crate::solvers::BruteForce;
-use crate::traits::Problem;
-
-#[test]
-fn test_maximumindependentset_to_integralflowbundles_closed_loop() {
-    // Path graph: 0-1-2-3-4
-    let source = MaximumIndependentSet::new(
-        SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
-        vec![1i32; 5],
-    );
-    let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    // n + 2 = 7 vertices, 2n = 10 arcs, m + n = 4 + 5 = 9 bundles
-    assert_eq!(target.num_vertices(), 7);
-    assert_eq!(target.num_arcs(), 10);
-    assert_eq!(target.num_bundles(), 9);
-    assert_eq!(target.requirement(), 1);
-
-    // Every feasible flow witness maps back to a valid independent set
-    let solver = BruteForce::new();
-    let witnesses = solver.find_all_witnesses(target);
-    assert!(!witnesses.is_empty());
-    for w in &witnesses {
-        let source_config = reduction.extract_solution(w);
-        let value = source.evaluate(&source_config);
-        assert!(value.is_valid(), "Extracted config should be a valid IS");
-    }
-}
-
-#[test]
-fn test_maximumindependentset_to_integralflowbundles_triangle() {
-    // Triangle: 0-1-2-0, unit weights. Any single vertex is an IS.
-    let source = MaximumIndependentSet::new(
-        SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
-    );
-    let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.num_vertices(), 5);
-    assert_eq!(target.num_arcs(), 6);
-    assert_eq!(target.num_bundles(), 6); // 3 edges + 3 vertices
-    assert_eq!(target.requirement(), 1);
-
-    let solver = BruteForce::new();
-    let witnesses = solver.find_all_witnesses(target);
-    assert!(!witnesses.is_empty());
-    for w in &witnesses {
-        let source_config = reduction.extract_solution(w);
-        let value = source.evaluate(&source_config);
-        assert!(value.is_valid());
-    }
-}
-
-#[test]
-fn test_maximumindependentset_to_integralflowbundles_cycle5() {
-    // C5 (5-cycle): 5 vertices, 5 edges, unit weights.
-    let source = MaximumIndependentSet::new(
-        SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]),
-        vec![1i32; 5],
-    );
-    let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.num_vertices(), 7);
-    assert_eq!(target.num_arcs(), 10);
-    assert_eq!(target.num_bundles(), 10); // 5 edges + 5 vertices
-    assert_eq!(target.requirement(), 1);
-
-    let solver = BruteForce::new();
-    let witnesses = solver.find_all_witnesses(target);
-    assert!(!witnesses.is_empty());
-    for w in &witnesses {
-        let source_config = reduction.extract_solution(w);
-        let value = source.evaluate(&source_config);
-        assert!(value.is_valid());
-    }
-}
-
-#[test]
-fn test_maximumindependentset_to_integralflowbundles_empty_graph() {
-    // Empty graph (no edges): all vertices form an IS.
-    let source = MaximumIndependentSet::new(SimpleGraph::new(3, vec![]), vec![1i32; 3]);
-    let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.num_vertices(), 5);
-    assert_eq!(target.num_arcs(), 6);
-    assert_eq!(target.num_bundles(), 3); // 0 edges + 3 vertices
-    assert_eq!(target.requirement(), 1);
-
-    let solver = BruteForce::new();
-    let witnesses = solver.find_all_witnesses(target);
-    assert!(!witnesses.is_empty());
-    for w in &witnesses {
-        let source_config = reduction.extract_solution(w);
-        let value = source.evaluate(&source_config);
-        assert!(value.is_valid());
-    }
-}
-
-#[test]
-fn test_maximumindependentset_to_integralflowbundles_single_vertex() {
-    // Single vertex, no edges. Optimal MIS = 1.
-    let source = MaximumIndependentSet::new(SimpleGraph::new(1, vec![]), vec![1i32]);
-    let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.num_vertices(), 3);
-    assert_eq!(target.num_arcs(), 2);
-    assert_eq!(target.num_bundles(), 1); // 0 edges + 1 vertex
-    assert_eq!(target.requirement(), 1);
-
-    let solver = BruteForce::new();
-    let witnesses = solver.find_all_witnesses(target);
-    assert!(!witnesses.is_empty());
-    for w in &witnesses {
-        let source_config = reduction.extract_solution(w);
-        let value = source.evaluate(&source_config);
-        assert!(value.is_valid());
-        assert_eq!(value.unwrap(), 1);
-    }
-}
-
-#[test]
-fn test_maximumindependentset_to_integralflowbundles_structure() {
-    // Verify the graph structure of the reduction for K2
-    let source = MaximumIndependentSet::new(SimpleGraph::new(2, vec![(0, 1)]), vec![1i32; 2]);
-    let reduction = ReduceTo::<IntegralFlowBundles>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.num_vertices(), 4);
-    assert_eq!(target.num_arcs(), 4);
-    assert_eq!(target.num_bundles(), 3); // 1 edge + 2 vertex
-    assert_eq!(target.source(), 0);
-    assert_eq!(target.sink(), 3);
-    assert_eq!(target.requirement(), 1);
-
-    let bundles = target.bundles();
-    assert_eq!(bundles[0], vec![1, 3]); // edge bundle
-    assert_eq!(bundles[1], vec![0, 1]); // vertex 0 bundle
-    assert_eq!(bundles[2], vec![2, 3]); // vertex 1 bundle
-
-    let caps = target.bundle_capacities();
-    assert_eq!(caps[0], 1); // edge bundle cap
-    assert_eq!(caps[1], 2); // vertex bundle cap
-    assert_eq!(caps[2], 2); // vertex bundle cap
-}
diff --git a/src/unit_tests/rules/maximumindependentset_maximumclique.rs b/src/unit_tests/rules/maximumindependentset_maximumclique.rs
index 57e94117c..f6e2813b1 100644
--- a/src/unit_tests/rules/maximumindependentset_maximumclique.rs
+++ b/src/unit_tests/rules/maximumindependentset_maximumclique.rs
@@ -9,9 +9,10 @@ fn test_maximumindependentset_to_maximumclique_closed_loop() {
     // Path graph: 0-1-2-3-4
     let source = MaximumIndependentSet::new(
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
-        vec![1i32; 5],
+        vec![1i64; 5],
     );
-    let reduction = ReduceTo::<MaximumClique<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumClique<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Complement of path graph should have n*(n-1)/2 - m = 10 - 4 = 6 edges
@@ -32,7 +33,8 @@ fn test_maximumindependentset_to_maximumclique_weighted() {
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![10, 20, 30],
     );
-    let reduction = ReduceTo::<MaximumClique<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumClique<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Complement of K3 has 0 edges (empty graph)
@@ -42,10 +44,10 @@ fn test_maximumindependentset_to_maximumclique_weighted() {
 
     // In empty graph, max clique is a single vertex. Best is vertex 2 (weight 30).
     let solver = BruteForce::new();
-    let best = solver.find_all_witnesses(target);
+    let best = solver.find_all_witnesses(target).unwrap();
     for sol in &best {
-        let extracted = reduction.extract_solution(sol);
-        let metric = source.evaluate(&extracted);
+        let extracted = reduction.extract_solution(sol).unwrap();
+        let metric = source.evaluate(&extracted).unwrap();
         assert!(metric.is_valid());
     }
 }
@@ -53,8 +55,9 @@ fn test_maximumindependentset_to_maximumclique_weighted() {
 #[test]
 fn test_maximumindependentset_to_maximumclique_empty_graph() {
     // Empty graph (no edges) - complement is complete graph
-    let source = MaximumIndependentSet::new(SimpleGraph::new(4, vec![]), vec![1i32; 4]);
-    let reduction = ReduceTo::<MaximumClique<SimpleGraph, i32>>::reduce_to(&source);
+    let source = MaximumIndependentSet::new(SimpleGraph::new(4, vec![]), vec![1i64; 4]);
+    let reduction = ReduceTo::<MaximumClique<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Complement of empty graph is K4 with 6 edges
@@ -63,8 +66,10 @@ fn test_maximumindependentset_to_maximumclique_empty_graph() {
 
     // All 4 vertices form a clique in complement = all 4 are independent set in source
     let solver = BruteForce::new();
-    let best_target = solver.find_all_witnesses(target);
-    assert!(best_target.iter().all(|s| s.iter().sum::<usize>() == 4));
+    let best_target = solver.find_all_witnesses(target).unwrap();
+    assert!(best_target
+        .iter()
+        .all(|s| s.iter().filter(|&&selected| selected).count() == 4));
 }
 
 #[test]
@@ -74,7 +79,8 @@ fn test_maximumindependentset_to_maximumclique_one_weights_closed_loop() {
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
         vec![One; 5],
     );
-    let reduction = ReduceTo::<MaximumClique<SimpleGraph, One>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumClique<SimpleGraph, One>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 5);
@@ -92,15 +98,18 @@ fn test_maximumindependentset_to_maximumclique_complete_graph() {
     // Complete graph K4 - complement is empty graph
     let source = MaximumIndependentSet::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
-    let reduction = ReduceTo::<MaximumClique<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumClique<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_edges(), 0);
 
     // Max clique in empty graph is single vertex, max IS in K4 is also single vertex
     let solver = BruteForce::new();
-    let best = solver.find_all_witnesses(target);
-    assert!(best.iter().all(|s| s.iter().sum::<usize>() == 1));
+    let best = solver.find_all_witnesses(target).unwrap();
+    assert!(best
+        .iter()
+        .all(|s| s.iter().filter(|&&selected| selected).count() == 1));
 }
diff --git a/src/unit_tests/rules/maximumindependentset_maximumsetpacking.rs b/src/unit_tests/rules/maximumindependentset_maximumsetpacking.rs
index 880265a7d..202b4819b 100644
--- a/src/unit_tests/rules/maximumindependentset_maximumsetpacking.rs
+++ b/src/unit_tests/rules/maximumindependentset_maximumsetpacking.rs
@@ -8,7 +8,8 @@ include!("../jl_helpers.rs");
 fn test_maximumindependentset_to_maximumsetpacking_closed_loop() {
     let is_problem =
         MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![10, 20, 30]);
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&is_problem);
+    let reduction = ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&is_problem)
+        .expect("reduction should succeed");
     let sp_problem = reduction.target_problem();
 
     // Weights should be preserved
@@ -18,27 +19,29 @@ fn test_maximumindependentset_to_maximumsetpacking_closed_loop() {
 #[test]
 fn test_empty_graph() {
     // No edges means all sets are empty (or we need to handle it)
-    let is_problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![]), vec![1i32; 3]);
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&is_problem);
+    let is_problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![]), vec![1i64; 3]);
+    let reduction = ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&is_problem)
+        .expect("reduction should succeed");
     let sp_problem = reduction.target_problem();
 
     // All sets should be empty (no edges to include)
     assert_eq!(sp_problem.num_sets(), 3);
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(sp_problem);
+    let solutions = solver.find_all_witnesses(sp_problem).unwrap();
 
     // With no overlaps, we can select all sets
-    assert_eq!(solutions[0].iter().sum::<usize>(), 3);
+    assert_eq!(solutions[0].iter().filter(|&&selected| selected).count(), 3);
 }
 
 #[test]
 fn test_disjoint_sets() {
     // Completely disjoint sets
     let sets = vec![vec![0], vec![1], vec![2]];
-    let sp_problem = MaximumSetPacking::<i32>::new(sets);
-    let reduction: ReductionSPToIS<i32> =
-        ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&sp_problem);
+    let sp_problem = MaximumSetPacking::new(sets);
+    let reduction: ReductionSPToIS<i64> =
+        ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&sp_problem)
+            .expect("reduction should succeed");
     let is_problem = reduction.target_problem();
 
     // No edges in the intersection graph
@@ -49,8 +52,9 @@ fn test_disjoint_sets() {
 fn test_reduction_structure() {
     // Test IS to SP structure
     let is_problem =
-        MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (1, 2)]), vec![1i32; 4]);
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&is_problem);
+        MaximumIndependentSet::new(SimpleGraph::new(4, vec![(0, 1), (1, 2)]), vec![1i64; 4]);
+    let reduction = ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&is_problem)
+        .expect("reduction should succeed");
     let sp = reduction.target_problem();
 
     // SP should have same number of sets as vertices in IS
@@ -58,9 +62,10 @@ fn test_reduction_structure() {
 
     // Test SP to IS structure
     let sets = vec![vec![0, 1], vec![2, 3]];
-    let sp_problem = MaximumSetPacking::<i32>::new(sets);
-    let reduction2: ReductionSPToIS<i32> =
-        ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&sp_problem);
+    let sp_problem = MaximumSetPacking::new(sets);
+    let reduction2: ReductionSPToIS<i64> =
+        ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&sp_problem)
+            .expect("reduction should succeed");
     let is = reduction2.target_problem();
 
     // IS should have same number of vertices as sets in SP
@@ -78,17 +83,22 @@ fn test_jl_parity_is_to_setpacking() {
     let inst = &is_data["instances"][0]["instance"];
     let nv = inst["num_vertices"].as_u64().unwrap() as usize;
     let source =
-        MaximumIndependentSet::new(SimpleGraph::new(nv, jl_parse_edges(inst)), vec![1i32; nv]);
-    let result = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&source);
+        MaximumIndependentSet::new(SimpleGraph::new(nv, jl_parse_edges(inst)), vec![1i64; nv]);
+    let result =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity MIS->SetPacking",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -101,17 +111,22 @@ fn test_jl_parity_setpacking_to_is() {
     let sp_data: serde_json::Value =
         serde_json::from_str(include_str!("../../../tests/data/jl/setpacking.json")).unwrap();
     let inst = &sp_data["instances"][0]["instance"];
-    let source = MaximumSetPacking::<i32>::new(jl_parse_sets(&inst["sets"]));
-    let result = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&source);
+    let source = MaximumSetPacking::new(jl_parse_sets(&inst["sets"]));
+    let result = ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity SetPacking->MIS",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -126,17 +141,22 @@ fn test_jl_parity_rule_is_to_setpacking() {
     let inst = &jl_find_instance_by_label(&is_data, "doc_4vertex")["instance"];
     let nv = inst["num_vertices"].as_u64().unwrap() as usize;
     let source =
-        MaximumIndependentSet::new(SimpleGraph::new(nv, jl_parse_edges(inst)), vec![1i32; nv]);
-    let result = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&source);
+        MaximumIndependentSet::new(SimpleGraph::new(nv, jl_parse_edges(inst)), vec![1i64; nv]);
+    let result =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity rule MIS->SetPacking",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -152,17 +172,22 @@ fn test_jl_parity_doc_is_to_setpacking() {
     let inst = &is_instance["instance"];
     let nv = inst["num_vertices"].as_u64().unwrap() as usize;
     let source =
-        MaximumIndependentSet::new(SimpleGraph::new(nv, jl_parse_edges(inst)), vec![1i32; nv]);
-    let result = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&source);
+        MaximumIndependentSet::new(SimpleGraph::new(nv, jl_parse_edges(inst)), vec![1i64; nv]);
+    let result =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity doc MIS->SetPacking",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -171,18 +196,22 @@ fn test_maximumindependentset_one_to_maximumsetpacking_closed_loop() {
     // Path graph: 0-1-2 with unit weights (MIS = 2: select vertices 0, 2)
     let is_problem =
         MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![One; 3]);
-    let reduction = ReduceTo::<MaximumSetPacking<One>>::reduce_to(&is_problem);
+    let reduction = ReduceTo::<MaximumSetPacking<One>>::reduce_to(&is_problem)
+        .expect("reduction should succeed");
     let sp_problem = reduction.target_problem();
 
     assert_eq!(sp_problem.num_sets(), 3);
 
     let solver = BruteForce::new();
-    let sp_solutions = solver.find_all_witnesses(sp_problem);
+    let sp_solutions = solver.find_all_witnesses(sp_problem).unwrap();
     assert!(!sp_solutions.is_empty());
 
-    let original_solution = reduction.extract_solution(&sp_solutions[0]);
+    let original_solution = reduction.extract_solution(&sp_solutions[0]).unwrap();
     assert_eq!(original_solution.len(), 3);
-    let size: usize = original_solution.iter().sum();
+    let size: usize = original_solution
+        .iter()
+        .filter(|&&selected| selected)
+        .count();
     assert_eq!(size, 2, "Max IS in path of 3 should be 2");
 }
 
@@ -190,19 +219,23 @@ fn test_maximumindependentset_one_to_maximumsetpacking_closed_loop() {
 fn test_maximumsetpacking_one_to_maximumindependentset_closed_loop() {
     // Disjoint sets: S0={0,1}, S1={1,2}, S2={3,4} — S0 and S1 overlap
     let sets = vec![vec![0, 1], vec![1, 2], vec![3, 4]];
-    let sp_problem = MaximumSetPacking::with_weights(sets, vec![One; 3]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sp_problem);
+    let sp_problem = MaximumSetPacking::with_weights(sets, vec![One; 3]).unwrap();
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sp_problem)
+        .expect("reduction should succeed");
     let is_problem = reduction.target_problem();
 
     assert_eq!(is_problem.graph().num_vertices(), 3);
 
     let solver = BruteForce::new();
-    let is_solutions = solver.find_all_witnesses(is_problem);
+    let is_solutions = solver.find_all_witnesses(is_problem).unwrap();
     assert!(!is_solutions.is_empty());
 
-    let original_solution = reduction.extract_solution(&is_solutions[0]);
+    let original_solution = reduction.extract_solution(&is_solutions[0]).unwrap();
     assert_eq!(original_solution.len(), 3);
-    let size: usize = original_solution.iter().sum();
+    let size: usize = original_solution
+        .iter()
+        .filter(|&&selected| selected)
+        .count();
     assert_eq!(
         size, 2,
         "Max set packing should select 2 non-overlapping sets"
diff --git a/src/unit_tests/rules/maximumindependentset_qubo.rs b/src/unit_tests/rules/maximumindependentset_qubo.rs
index 1e297ba80..99db973b3 100644
--- a/src/unit_tests/rules/maximumindependentset_qubo.rs
+++ b/src/unit_tests/rules/maximumindependentset_qubo.rs
@@ -1,32 +1,26 @@
 use crate::models::algebraic::QUBO;
 use crate::models::graph::MaximumIndependentSet;
-use crate::rules::{Minimize, ReductionChain, ReductionGraph, ReductionPath};
+use crate::rules::{ReductionChain, ReductionGraph, ReductionPath};
 use crate::solvers::BruteForce;
-use crate::topology::{Graph, SimpleGraph};
+use crate::solvers::BruteForceProblem as _;
+use crate::topology::SimpleGraph;
 use crate::traits::Problem;
-use crate::types::{Max, ProblemSize};
+use crate::types::Max;
 
 fn reduce_mis_to_qubo(
-    problem: &MaximumIndependentSet<SimpleGraph, i32>,
+    problem: &MaximumIndependentSet<SimpleGraph, i64>,
 ) -> (ReductionPath, ReductionChain) {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
     let dst = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
     let path = graph
-        .find_cheapest_path(
-            "MaximumIndependentSet",
-            &src,
-            "QUBO",
-            &dst,
-            &ProblemSize::new(vec![
-                ("num_vertices", problem.graph().num_vertices()),
-                ("num_edges", problem.graph().num_edges()),
-            ]),
-            &Minimize("num_vars"),
-        )
-        .expect("Should find path MaximumIndependentSet -> QUBO");
+        .find_all_paths("MaximumIndependentSet", &src, "QUBO", &dst)
+        .into_iter()
+        .find(|path| path.type_names() == ["MaximumIndependentSet", "MaximumSetPacking", "QUBO"])
+        .expect("expected explicit MaximumSetPacking route");
     let chain = graph
         .reduce_along_path(&path, problem as &dyn std::any::Any)
+        .expect("MaximumIndependentSet -> QUBO reduction should not fail")
         .expect("Should reduce MaximumIndependentSet to QUBO along path");
     (path, chain)
 }
@@ -35,7 +29,7 @@ fn reduce_mis_to_qubo(
 fn test_maximumindependentset_to_qubo_via_path_closed_loop() {
     let problem = MaximumIndependentSet::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let (path, chain) = reduce_mis_to_qubo(&problem);
     let qubo: &QUBO<f64> = chain.target_problem();
@@ -51,11 +45,11 @@ fn test_maximumindependentset_to_qubo_via_path_closed_loop() {
     assert_eq!(qubo.num_variables(), 4);
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
     for sol in &qubo_solutions {
-        let extracted = chain.extract_solution(sol);
-        assert!(problem.evaluate(&extracted).is_valid());
-        assert_eq!(extracted.iter().filter(|&&x| x == 1).count(), 2);
+        let extracted = chain.extract_solution(sol).unwrap();
+        assert!(problem.evaluate(&extracted).unwrap().is_valid());
+        assert_eq!(extracted.iter().filter(|&&x| x).count(), 2);
     }
 }
 
@@ -68,26 +62,30 @@ fn test_maximumindependentset_to_qubo_via_path_weighted() {
 
     let solver = BruteForce::new();
     let qubo_solution = solver
-        .find_witness(qubo)
+        .solve(qubo)
+        .unwrap()
         .expect("QUBO should be solvable via path");
-    let extracted = chain.extract_solution(&qubo_solution);
+    let extracted = chain.extract_solution(&qubo_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), Max(Some(100)));
-    assert_eq!(extracted, vec![0, 1, 0]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(100)));
+    assert_eq!(extracted, vec![false, true, false]);
 }
 
 #[test]
 fn test_maximumindependentset_to_qubo_via_path_empty_graph() {
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![]), vec![1i64; 3]);
     let (_, chain) = reduce_mis_to_qubo(&problem);
     let qubo: &QUBO<f64> = chain.target_problem();
 
     assert_eq!(qubo.num_variables(), 3);
 
     let solver = BruteForce::new();
-    let qubo_solution = solver.find_witness(qubo).expect("QUBO should be solvable");
-    let extracted = chain.extract_solution(&qubo_solution);
+    let qubo_solution = solver
+        .solve(qubo)
+        .unwrap()
+        .expect("QUBO should be solvable");
+    let extracted = chain.extract_solution(&qubo_solution).unwrap();
 
-    assert_eq!(extracted, vec![1, 1, 1]);
-    assert_eq!(problem.evaluate(&extracted), Max(Some(3)));
+    assert_eq!(extracted, vec![true, true, true]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(3)));
 }
diff --git a/src/unit_tests/rules/maximumindependentset_triangular.rs b/src/unit_tests/rules/maximumindependentset_triangular.rs
index 428e02ef5..7205ac3f5 100644
--- a/src/unit_tests/rules/maximumindependentset_triangular.rs
+++ b/src/unit_tests/rules/maximumindependentset_triangular.rs
@@ -27,12 +27,14 @@ fn test_mis_simple_one_to_triangular_is_deterministic_on_large_graph() {
     }
 
     let problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![One; n]);
-    let first = ReduceTo::<MaximumIndependentSet<TriangularSubgraph, i32>>::reduce_to(&problem);
+    let first = ReduceTo::<MaximumIndependentSet<TriangularSubgraph, i64>>::reduce_to(&problem)
+        .expect("reduction should succeed");
     let baseline_atoms = first.target_problem().graph().num_vertices();
     let baseline_edges = first.target_problem().graph().edges().len();
 
     for _ in 0..3 {
-        let again = ReduceTo::<MaximumIndependentSet<TriangularSubgraph, i32>>::reduce_to(&problem);
+        let again = ReduceTo::<MaximumIndependentSet<TriangularSubgraph, i64>>::reduce_to(&problem)
+            .expect("reduction should succeed");
         assert_eq!(
             again.target_problem().graph().num_vertices(),
             baseline_atoms,
@@ -46,23 +48,92 @@ fn test_mis_simple_one_to_triangular_closed_loop() {
     // Path graph: 0-1-2
     let problem =
         MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![One; 3]);
-    let result = ReduceTo::<MaximumIndependentSet<TriangularSubgraph, i32>>::reduce_to(&problem);
+    let result = ReduceTo::<MaximumIndependentSet<TriangularSubgraph, i64>>::reduce_to(&problem)
+        .expect("reduction should succeed");
     let target = result.target_problem();
 
     // The triangular graph should have more vertices than the original
     assert!(target.graph().num_vertices() > 3);
 
     // Map a trivial zero solution back to verify dimensions
-    let zero_config = vec![0; target.graph().num_vertices()];
-    let original_solution = result.extract_solution(&zero_config);
+    let zero_config = vec![false; target.graph().num_vertices()];
+    let original_solution = result.extract_solution(&zero_config).unwrap();
     assert_eq!(original_solution.len(), 3);
 }
 
+#[test]
+fn test_mis_simple_one_to_triangular_preserves_optimum_and_witness() {
+    use crate::test_unitdiskmapping_algorithms::common::{
+        is_independent_set, solve_mis, solve_weighted_mis_config,
+    };
+
+    let edges = vec![(0, 1), (1, 2), (2, 3)];
+    let source = MaximumIndependentSet::new(SimpleGraph::new(4, edges.clone()), vec![One; 4]);
+    let reduction =
+        ReduceTo::<MaximumIndependentSet<TriangularSubgraph, i64>>::reduce_to(&source).unwrap();
+    let target = reduction.target_problem();
+    let target_solution = solve_weighted_mis_config(
+        target.graph().num_vertices(),
+        &target.graph().edges(),
+        target.weights(),
+    );
+    let target_solution = crate::config::config_to_bits(&target_solution);
+    let source_solution = reduction.extract_solution(&target_solution).unwrap();
+
+    assert!(is_independent_set(
+        &edges,
+        &crate::config::bits_to_config(&source_solution),
+    ));
+    assert_eq!(
+        source_solution.iter().filter(|&&value| value).count(),
+        solve_mis(4, &edges)
+    );
+}
+
+#[test]
+fn test_mis_simple_one_to_triangular_all_four_vertex_graphs() {
+    use crate::test_unitdiskmapping_algorithms::common::{
+        is_independent_set, solve_mis, solve_weighted_mis_config,
+    };
+
+    let possible_edges = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)];
+    for mask in 0..(1_usize << possible_edges.len()) {
+        let edges = possible_edges
+            .iter()
+            .enumerate()
+            .filter(|(index, _)| mask & (1 << index) != 0)
+            .map(|(_, &edge)| edge)
+            .collect::<Vec<_>>();
+        let source = MaximumIndependentSet::new(SimpleGraph::new(4, edges.clone()), vec![One; 4]);
+        let reduction =
+            ReduceTo::<MaximumIndependentSet<TriangularSubgraph, i64>>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        let target_solution = solve_weighted_mis_config(
+            target.graph().num_vertices(),
+            &target.graph().edges(),
+            target.weights(),
+        );
+        let target_solution = crate::config::config_to_bits(&target_solution);
+        let source_solution = reduction.extract_solution(&target_solution).unwrap();
+
+        assert!(
+            is_independent_set(&edges, &crate::config::bits_to_config(&source_solution),),
+            "graph mask {mask:#08b} extracted a non-independent set"
+        );
+        assert_eq!(
+            source_solution.iter().filter(|&&value| value).count(),
+            solve_mis(4, &edges),
+            "graph mask {mask:#08b} did not preserve the optimum"
+        );
+    }
+}
+
 #[test]
 fn test_mis_simple_one_to_triangular_graph_methods() {
     // Single edge graph: 0-1
     let problem = MaximumIndependentSet::new(SimpleGraph::new(2, vec![(0, 1)]), vec![One; 2]);
-    let result = ReduceTo::<MaximumIndependentSet<TriangularSubgraph, i32>>::reduce_to(&problem);
+    let result = ReduceTo::<MaximumIndependentSet<TriangularSubgraph, i64>>::reduce_to(&problem)
+        .expect("reduction should succeed");
     let target = result.target_problem();
     let graph = target.graph();
 
diff --git a/src/unit_tests/rules/maximumleafspanningtree_ilp.rs b/src/unit_tests/rules/maximumleafspanningtree_ilp.rs
index 159ce297e..be3068b63 100644
--- a/src/unit_tests/rules/maximumleafspanningtree_ilp.rs
+++ b/src/unit_tests/rules/maximumleafspanningtree_ilp.rs
@@ -35,32 +35,32 @@ fn canonical_instance() -> MaximumLeafSpanningTree<SimpleGraph> {
 fn test_reduction_creates_expected_ilp_shape() {
     let problem = small_instance();
     let reduction: ReductionMaximumLeafSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=4, m=4: num_vars = 3*4 + 4 = 16
-    assert_eq!(ilp.num_vars, 16);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.num_vars(), 16);
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
     // Objective should be z_0 + z_1 + z_2 + z_3 (indices 4..8)
-    assert_eq!(ilp.objective, vec![(4, 1.0), (5, 1.0), (6, 1.0), (7, 1.0)]);
+    assert_eq!(ilp.objective(), vec![(4, 1), (5, 1), (6, 1), (7, 1)]);
 }
 
 #[test]
 fn test_maximumleafspanningtree_to_ilp_closed_loop() {
     let problem = small_instance();
     let reduction: ReductionMaximumLeafSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
-    let best_source = bf.find_all_witnesses(&problem);
+    let best_source = bf.find_all_witnesses(&problem).unwrap();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // All brute-force optimal solutions have the same value
-    let bf_value = problem.evaluate(&best_source[0]);
-    let ilp_value = problem.evaluate(&extracted);
+    let bf_value = problem.evaluate(&best_source[0]).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
     assert_eq!(ilp_value, bf_value);
     assert!(problem.is_valid_solution(&extracted));
 }
@@ -69,17 +69,17 @@ fn test_maximumleafspanningtree_to_ilp_closed_loop() {
 fn test_maximumleafspanningtree_to_ilp_canonical_closed_loop() {
     let problem = canonical_instance();
     let reduction: ReductionMaximumLeafSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
-    let best_source = bf.find_all_witnesses(&problem);
+    let best_source = bf.find_all_witnesses(&problem).unwrap();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&best_source[0]), Max(Some(4)));
-    assert_eq!(problem.evaluate(&extracted), Max(Some(4)));
+    assert_eq!(problem.evaluate(&best_source[0]).unwrap(), Max(Some(4)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(4)));
     assert!(problem.is_valid_solution(&extracted));
 }
 
@@ -87,7 +87,7 @@ fn test_maximumleafspanningtree_to_ilp_canonical_closed_loop() {
 fn test_solution_extraction_reads_edge_selector_prefix() {
     let problem = small_instance();
     let reduction: ReductionMaximumLeafSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // 16 variables total, first 4 are edge selectors
     let mut target_solution = vec![0; 16];
@@ -96,8 +96,8 @@ fn test_solution_extraction_reads_edge_selector_prefix() {
     target_solution[2] = 1; // edge (2,3)
 
     assert_eq!(
-        reduction.extract_solution(&target_solution),
-        vec![1, 1, 1, 0]
+        reduction.extract_solution(&target_solution).unwrap(),
+        vec![true, true, true, false]
     );
 }
 
@@ -105,12 +105,12 @@ fn test_solution_extraction_reads_edge_selector_prefix() {
 fn test_reduce_and_solve_via_ilp() {
     let problem = canonical_instance();
     let reduction: ReductionMaximumLeafSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Max(Some(4)));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(4)));
     assert!(problem.is_valid_solution(&extracted));
 }
 
@@ -118,7 +118,7 @@ fn test_reduce_and_solve_via_ilp() {
 fn test_maximumleafspanningtree_to_ilp_bf_vs_ilp() {
     let problem = canonical_instance();
     let reduction: ReductionMaximumLeafSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
@@ -127,12 +127,12 @@ fn test_maximumleafspanningtree_to_ilp_path_graph() {
     // Path P4: 0-1-2-3, only spanning tree is the path itself => 2 leaves
     let problem = MaximumLeafSpanningTree::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
     let reduction: ReductionMaximumLeafSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Max(Some(2)));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(2)));
 }
 
 #[test]
@@ -140,12 +140,12 @@ fn test_maximumleafspanningtree_to_ilp_star_graph() {
     // Star K1,3: center 0, leaves 1,2,3 => 3 leaves
     let problem = MaximumLeafSpanningTree::new(SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]));
     let reduction: ReductionMaximumLeafSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Max(Some(3)));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(3)));
     assert!(problem.is_valid_solution(&extracted));
 }
 
@@ -157,15 +157,15 @@ fn test_maximumleafspanningtree_to_ilp_complete_graph() {
         vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)],
     ));
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let reduction: ReductionMaximumLeafSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), bf_value);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), bf_value);
     assert_eq!(bf_value, Max(Some(3)));
 }
diff --git a/src/unit_tests/rules/maximumlikelihoodranking_ilp.rs b/src/unit_tests/rules/maximumlikelihoodranking_ilp.rs
index f88feec2b..e706c0c43 100644
--- a/src/unit_tests/rules/maximumlikelihoodranking_ilp.rs
+++ b/src/unit_tests/rules/maximumlikelihoodranking_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Min;
@@ -9,27 +9,23 @@ use crate::types::Min;
 fn test_maximumlikelihoodranking_to_ilp_closed_loop() {
     let matrix = vec![vec![0, 3, 2], vec![2, 0, 4], vec![3, 1, 0]];
     let problem = MaximumLikelihoodRanking::new(matrix);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_optimization_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "MaximumLikelihoodRanking->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_maximumlikelihoodranking_to_ilp_structure() {
     let matrix = vec![vec![0, 3, 2], vec![2, 0, 4], vec![3, 1, 0]];
     let problem = MaximumLikelihoodRanking::new(matrix);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 3 items -> C(3,2) = 3 variables
     assert_eq!(ilp.num_vars(), 3);
     // C(3,3) = 1 triple -> 2 constraints
     assert_eq!(ilp.num_constraints(), 2);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -41,16 +37,16 @@ fn test_maximumlikelihoodranking_to_ilp_bf_vs_ilp() {
         vec![0, 2, 1, 0],
     ];
     let problem = MaximumLikelihoodRanking::new(matrix);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    let bf_solutions = BruteForce::new().find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     assert!(ilp_value.is_valid());
@@ -61,12 +57,12 @@ fn test_maximumlikelihoodranking_to_ilp_extraction() {
     // 3 items: simple instance
     let matrix = vec![vec![0, 3, 2], vec![2, 0, 4], vec![3, 1, 0]];
     let problem = MaximumLikelihoodRanking::new(matrix);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Verify the extracted config is a valid permutation
     let n = problem.num_items();
@@ -76,7 +72,7 @@ fn test_maximumlikelihoodranking_to_ilp_extraction() {
     assert_eq!(sorted, (0..n).collect::<Vec<_>>());
 
     // Verify evaluation is valid
-    let value = problem.evaluate(&extracted);
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(value.is_valid());
 }
 
@@ -84,7 +80,7 @@ fn test_maximumlikelihoodranking_to_ilp_extraction() {
 fn test_maximumlikelihoodranking_to_ilp_two_items() {
     let matrix = vec![vec![0, 5], vec![3, 0]];
     let problem = MaximumLikelihoodRanking::new(matrix);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 2 items -> 1 variable, 0 transitivity constraints
@@ -92,8 +88,8 @@ fn test_maximumlikelihoodranking_to_ilp_two_items() {
     assert_eq!(ilp.num_constraints(), 0);
 
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(value.is_valid());
 
     // Optimal: item 0 before item 1 costs matrix[1][0]=3
@@ -105,7 +101,7 @@ fn test_maximumlikelihoodranking_to_ilp_two_items() {
 #[test]
 fn test_maximumlikelihoodranking_to_ilp_single_item() {
     let problem = MaximumLikelihoodRanking::new(vec![vec![0]]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     assert_eq!(ilp.num_vars(), 0);
@@ -114,7 +110,7 @@ fn test_maximumlikelihoodranking_to_ilp_single_item() {
     let ilp_solution = ILPSolver::new()
         .solve(ilp)
         .expect("single-item ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0]);
 }
 
@@ -128,7 +124,7 @@ fn test_maximumlikelihoodranking_to_ilp_larger_instance() {
         vec![0, 2, 1, 0],
     ];
     let problem = MaximumLikelihoodRanking::new(matrix);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 4 items -> C(4,2) = 6 variables
@@ -136,11 +132,7 @@ fn test_maximumlikelihoodranking_to_ilp_larger_instance() {
     // C(4,3) = 4 triples -> 8 constraints
     assert_eq!(ilp.num_constraints(), 8);
 
-    assert_optimization_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "4-item MaximumLikelihoodRanking->ILP",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[cfg(feature = "example-db")]
@@ -154,6 +146,12 @@ fn test_maximumlikelihoodranking_to_ilp_canonical_example_spec() {
 
     assert_eq!(example.source.problem, "MaximumLikelihoodRanking");
     assert_eq!(example.target.problem, "ILP");
-    assert_eq!(example.target.instance["num_vars"], 3);
+    assert_eq!(
+        example.target.instance["variables"]
+            .as_array()
+            .unwrap()
+            .len(),
+        3
+    );
     assert!(!example.solutions.is_empty());
 }
diff --git a/src/unit_tests/rules/maximummatching_ilp.rs b/src/unit_tests/rules/maximummatching_ilp.rs
index 02c9c6061..3dda34bfe 100644
--- a/src/unit_tests/rules/maximummatching_ilp.rs
+++ b/src/unit_tests/rules/maximummatching_ilp.rs
@@ -8,68 +8,70 @@ use crate::types::Max;
 fn test_reduction_creates_valid_ilp() {
     // Triangle graph: 3 vertices, 3 edges
     let problem =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check ILP structure
-    assert_eq!(ilp.num_vars, 3, "Should have one variable per edge");
+    assert_eq!(ilp.num_vars(), 3, "Should have one variable per edge");
     // Each vertex has degree 2, so 3 constraints (one per vertex)
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         3,
         "Should have one constraint per vertex"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize, "Should maximize");
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize, "Should maximize");
 
     // Each constraint should be sum of incident edge vars <= 1
-    for constraint in &ilp.constraints {
-        assert!((constraint.rhs - 1.0).abs() < 1e-9);
+    for constraint in ilp.constraints() {
+        assert_eq!(constraint.rhs(), 1);
     }
 }
 
 #[test]
 fn test_reduction_weighted() {
     let problem = MaximumMatching::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![5, 10]);
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check that weights are correctly transferred to objective
-    let mut coeffs: Vec<f64> = vec![0.0; 2];
-    for &(var, coef) in &ilp.objective {
+    let mut coeffs: Vec<i64> = vec![0; 2];
+    for &(var, coef) in ilp.objective() {
         coeffs[var] = coef;
     }
-    assert!((coeffs[0] - 5.0).abs() < 1e-9);
-    assert!((coeffs[1] - 10.0).abs() < 1e-9);
+    assert_eq!(coeffs, vec![5, 10]);
 }
 
 #[test]
 fn test_maximummatching_to_ilp_closed_loop() {
     // Triangle graph: max matching = 1 edge
     let problem =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve with brute force on original problem
-    let bf_solutions = bf.find_all_witnesses(&problem);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
 
     // Solve via ILP reduction
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Both should find optimal size = 1 (one edge)
-    let bf_size = problem.evaluate(&bf_solutions[0]);
-    let ilp_size = problem.evaluate(&extracted);
+    let bf_size = problem.evaluate(&bf_solutions[0]).unwrap();
+    let ilp_size = problem.evaluate(&extracted).unwrap();
     assert_eq!(bf_size, Max(Some(1)));
     assert_eq!(ilp_size, Max(Some(1)));
 
     // Verify the ILP solution is valid for the original problem
     assert!(
-        problem.evaluate(&extracted).is_valid(),
+        problem.evaluate(&extracted).unwrap().is_valid(),
         "Extracted solution should be valid"
     );
 }
@@ -78,27 +80,28 @@ fn test_maximummatching_to_ilp_closed_loop() {
 fn test_ilp_solution_equals_brute_force_path() {
     // Path graph 0-1-2-3: max matching = 2 (edges {0-1, 2-3})
     let problem =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve with brute force
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_size = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_size = problem.evaluate(&bf_solutions[0]).unwrap();
 
     // Solve via ILP
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_size = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_size = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_size, Max(Some(2)));
     assert_eq!(ilp_size, Max(Some(2)));
 
     // Verify validity
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
@@ -108,93 +111,98 @@ fn test_ilp_solution_equals_brute_force_weighted() {
     // Weights: [100, 1]
     // Max matching by weight: just edge 0-1 (weight 100) beats edge 1-2 (weight 1)
     let problem = MaximumMatching::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![100, 1]);
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_obj = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_obj = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_obj = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_obj = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_obj, Max(Some(100)));
     assert_eq!(ilp_obj, Max(Some(100)));
 
     // Verify the solution selects edge 0 (0-1)
-    assert_eq!(extracted, vec![1, 0]);
+    assert_eq!(extracted, vec![true, false]);
 }
 
 #[test]
 fn test_solution_extraction() {
     let problem =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (2, 3)]));
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (2, 3)]));
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Test that extraction works correctly (1:1 mapping)
     let ilp_solution = vec![1, 1];
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![1, 1]);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![true, true]);
 
     // Verify this is a valid matching (edges 0-1 and 2-3 are disjoint)
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_ilp_structure() {
-    let problem = MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(
         5,
         vec![(0, 1), (1, 2), (2, 3), (3, 4)],
     ));
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 4);
+    assert_eq!(ilp.num_vars(), 4);
     // Constraints: one per vertex with degree >= 1
     // Vertices 0,1,2,3,4 have degrees 1,2,2,2,1 respectively
-    assert_eq!(ilp.constraints.len(), 5);
+    assert_eq!(ilp.constraints().len(), 5);
 }
 
 #[test]
 fn test_empty_graph() {
     // Graph with no edges: empty matching
-    let problem = MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(3, vec![]));
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(3, vec![]));
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 0);
-    assert_eq!(ilp.constraints.len(), 0);
+    assert_eq!(ilp.num_vars(), 0);
+    assert_eq!(ilp.constraints().len(), 0);
 
-    assert!(problem.evaluate(&[]).is_valid());
-    assert_eq!(problem.evaluate(&[]), Max(Some(0)));
+    assert!(problem.evaluate(&vec![]).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Max(Some(0)));
 }
 
 #[test]
 fn test_k4_perfect_matching() {
     // Complete graph K4: can have perfect matching (2 edges covering all 4 vertices)
-    let problem = MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(
         4,
         vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)],
     ));
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 6 edges, 4 vertices with constraints
-    assert_eq!(ilp.num_vars, 6);
-    assert_eq!(ilp.constraints.len(), 4);
+    assert_eq!(ilp.num_vars(), 6);
+    assert_eq!(ilp.constraints().len(), 4);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Max(Some(2))); // Perfect matching has 2 edges
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(2))); // Perfect matching has 2 edges
 
     // Verify all vertices are matched
-    let sum: usize = extracted.iter().sum();
+    let sum: usize = extracted.iter().filter(|&&selected| selected).count();
     assert_eq!(sum, 2);
 }
 
@@ -203,56 +211,58 @@ fn test_star_graph() {
     // Star graph with center vertex 0 connected to 1, 2, 3
     // Max matching = 1 (only one edge can be selected)
     let problem =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]));
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]));
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Max(Some(1)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(1)));
 }
 
 #[test]
 fn test_bipartite_graph() {
     // Bipartite graph: {0,1} and {2,3} with all cross edges
     // Max matching = 2 (one perfect matching)
-    let problem = MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(
         4,
         vec![(0, 2), (0, 3), (1, 2), (1, 3)],
     ));
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Max(Some(2)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(2)));
 }
 
 #[test]
-fn test_solve_reduced() {
-    // Test the ILPSolver::solve_reduced method
+fn test_solve_via_ilp_pipeline() {
     let problem =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
 
     let ilp_solver = ILPSolver::new();
     let solution = ilp_solver
-        .solve_reduced(&problem)
-        .expect("solve_reduced should work");
+        .solve(&problem)
+        .expect("ILP pipeline should solve the problem");
 
-    assert!(problem.evaluate(&solution).is_valid());
-    assert_eq!(problem.evaluate(&solution), Max(Some(2)));
+    assert!(problem.evaluate(&solution).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(2)));
 }
 
 #[test]
 fn test_maximummatching_to_ilp_bf_vs_ilp() {
     let problem =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction: ReductionMatchingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
+    let reduction: ReductionMatchingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/maximummatching_maximumsetpacking.rs b/src/unit_tests/rules/maximummatching_maximumsetpacking.rs
index b72d0ee3e..e2a96c257 100644
--- a/src/unit_tests/rules/maximummatching_maximumsetpacking.rs
+++ b/src/unit_tests/rules/maximummatching_maximumsetpacking.rs
@@ -10,8 +10,9 @@ include!("../jl_helpers.rs");
 fn test_maximummatching_to_maximumsetpacking_closed_loop() {
     // Path graph 0-1-2
     let matching =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&matching);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
+    let reduction =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&matching).expect("reduction should succeed");
     let sp = reduction.target_problem();
 
     // Should have 2 sets (one for each edge)
@@ -30,44 +31,50 @@ fn test_matching_to_setpacking_weighted() {
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 3)]),
         vec![100, 1, 1],
     );
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&matching);
+    let reduction =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&matching).expect("reduction should succeed");
     let sp = reduction.target_problem();
 
     // Weights should be preserved
     assert_eq!(sp.weights_ref(), &vec![100, 1, 1]);
 
     let solver = BruteForce::new();
-    let sp_solutions = solver.find_all_witnesses(sp);
+    let sp_solutions = solver.find_all_witnesses(sp).unwrap();
 
     // Edge 0-1 (weight 100) alone beats edges 0-2 + 1-3 (weight 2)
-    assert!(sp_solutions.contains(&vec![1, 0, 0]));
+    assert!(sp_solutions.contains(&vec![true, false, false]));
 
     // Verify through direct MaximumMatching solution
-    let direct_solutions = solver.find_all_witnesses(&matching);
-    assert_eq!(matching.evaluate(&sp_solutions[0]), Max(Some(100)));
-    assert_eq!(matching.evaluate(&direct_solutions[0]), Max(Some(100)));
+    let direct_solutions = solver.find_all_witnesses(&matching).unwrap();
+    assert_eq!(matching.evaluate(&sp_solutions[0]).unwrap(), Max(Some(100)));
+    assert_eq!(
+        matching.evaluate(&direct_solutions[0]).unwrap(),
+        Max(Some(100))
+    );
 }
 
 #[test]
 fn test_matching_to_setpacking_solution_extraction() {
     let matching =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&matching);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
+    let reduction =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&matching).expect("reduction should succeed");
 
     // Test solution extraction is 1:1
-    let sp_solution = vec![1, 0, 1];
-    let matching_solution = reduction.extract_solution(&sp_solution);
-    assert_eq!(matching_solution, vec![1, 0, 1]);
+    let sp_solution = vec![true, false, true];
+    let matching_solution = reduction.extract_solution(&sp_solution).unwrap();
+    assert_eq!(matching_solution, vec![true, false, true]);
 
     // Verify the extracted solution is valid for original MaximumMatching
-    assert!(matching.evaluate(&matching_solution).is_valid());
+    assert!(matching.evaluate(&matching_solution).unwrap().is_valid());
 }
 
 #[test]
 fn test_matching_to_setpacking_empty() {
     // Graph with no edges
-    let matching = MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(3, vec![]));
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&matching);
+    let matching = MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(3, vec![]));
+    let reduction =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&matching).expect("reduction should succeed");
     let sp = reduction.target_problem();
 
     assert_eq!(sp.num_sets(), 0);
@@ -75,40 +82,43 @@ fn test_matching_to_setpacking_empty() {
 
 #[test]
 fn test_matching_to_setpacking_single_edge() {
-    let matching = MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(2, vec![(0, 1)]));
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&matching);
+    let matching = MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(2, vec![(0, 1)]));
+    let reduction =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&matching).expect("reduction should succeed");
     let sp = reduction.target_problem();
 
     assert_eq!(sp.num_sets(), 1);
     assert_eq!(sp.sets()[0], vec![0, 1]);
 
     let solver = BruteForce::new();
-    let sp_solutions = solver.find_all_witnesses(sp);
+    let sp_solutions = solver.find_all_witnesses(sp).unwrap();
 
     // Should select the only set
-    assert_eq!(sp_solutions, vec![vec![1]]);
+    assert_eq!(sp_solutions, vec![vec![true]]);
 }
 
 #[test]
 fn test_matching_to_setpacking_disjoint_edges() {
     // Two disjoint edges: 0-1 and 2-3
     let matching =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (2, 3)]));
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&matching);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (2, 3)]));
+    let reduction =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&matching).expect("reduction should succeed");
     let sp = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let sp_solutions = solver.find_all_witnesses(sp);
+    let sp_solutions = solver.find_all_witnesses(sp).unwrap();
 
     // Both edges can be selected (they don't share vertices)
-    assert_eq!(sp_solutions, vec![vec![1, 1]]);
+    assert_eq!(sp_solutions, vec![vec![true, true]]);
 }
 
 #[test]
 fn test_reduction_structure() {
     let matching =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&matching);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3)]));
+    let reduction =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&matching).expect("reduction should succeed");
     let sp = reduction.target_problem();
 
     // SP should have same number of sets as edges in matching
@@ -119,16 +129,17 @@ fn test_reduction_structure() {
 fn test_matching_to_setpacking_star() {
     // Star graph: center vertex 0 connected to 1, 2, 3
     let matching =
-        MaximumMatching::<_, i32>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]));
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&matching);
+        MaximumMatching::<_, i64>::unit_weights(SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]));
+    let reduction =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&matching).expect("reduction should succeed");
     let sp = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let sp_solutions = solver.find_all_witnesses(sp);
+    let sp_solutions = solver.find_all_witnesses(sp).unwrap();
 
     // All edges share vertex 0, so max matching = 1
     for sol in &sp_solutions {
-        assert_eq!(sol.iter().sum::<usize>(), 1);
+        assert_eq!(sol.iter().filter(|&&selected| selected).count(), 1);
     }
     // Should have 3 optimal solutions
     assert_eq!(sp_solutions.len(), 3);
@@ -157,15 +168,19 @@ fn test_jl_parity_matching_to_setpacking() {
         let inst = &jl_find_instance_by_label(&match_data, label)["instance"];
         let weighted_edges = jl_parse_weighted_edges(inst);
         let edges: Vec<(usize, usize)> = weighted_edges.iter().map(|&(u, v, _)| (u, v)).collect();
-        let weights: Vec<i32> = weighted_edges.into_iter().map(|(_, _, w)| w).collect();
+        let weights: Vec<i64> = weighted_edges.into_iter().map(|(_, _, w)| w).collect();
         let source = MaximumMatching::new(
             SimpleGraph::new(inst["num_vertices"].as_u64().unwrap() as usize, edges),
             weights,
         );
-        let result = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&source);
+        let result = ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&source)
+            .expect("reduction should succeed");
         let solver = BruteForce::new();
-        let best_source: HashSet<Vec<usize>> =
-            solver.find_all_witnesses(&source).into_iter().collect();
+        let best_source: HashSet<Vec<bool>> = solver
+            .find_all_witnesses(&source)
+            .unwrap()
+            .into_iter()
+            .collect();
         assert_optimization_round_trip_from_optimization_target(
             &source,
             &result,
@@ -174,7 +189,7 @@ fn test_jl_parity_matching_to_setpacking() {
         for case in data["cases"].as_array().unwrap() {
             assert_eq!(
                 best_source,
-                jl_parse_configs_set(&case["best_source"]),
+                jl_parse_bool_configs_set(&case["best_source"]),
                 "Matching->SP [{label}]: best source mismatch"
             );
         }
diff --git a/src/unit_tests/rules/maximumsetpacking_casts.rs b/src/unit_tests/rules/maximumsetpacking_casts.rs
index 7932ba4d1..5c37d5230 100644
--- a/src/unit_tests/rules/maximumsetpacking_casts.rs
+++ b/src/unit_tests/rules/maximumsetpacking_casts.rs
@@ -5,35 +5,39 @@ use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
 #[test]
-fn test_maximumsetpacking_one_to_i32_cast_closed_loop() {
+fn test_maximumsetpacking_one_to_i64_cast_closed_loop() {
     let sp_one =
-        MaximumSetPacking::with_weights(vec![vec![0, 1], vec![1, 2], vec![3, 4]], vec![One; 3]);
+        MaximumSetPacking::with_weights(vec![vec![0, 1], vec![1, 2], vec![3, 4]], vec![One; 3])
+            .unwrap();
 
-    let reduction = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&sp_one);
-    let sp_i32 = reduction.target_problem();
-    assert_eq!(sp_i32.weights_ref(), &vec![1i32, 1, 1]);
+    let reduction =
+        ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&sp_one).expect("reduction should succeed");
+    let sp_i64 = reduction.target_problem();
+    assert_eq!(sp_i64.weights_ref(), &vec![1i64, 1, 1]);
 
     let solver = BruteForce::new();
-    let target_solution = solver.find_witness(sp_i32).unwrap();
-    let source_solution = reduction.extract_solution(&target_solution);
+    let target_solution = solver.solve(sp_i64).unwrap().unwrap();
+    let source_solution = reduction.extract_solution(&target_solution).unwrap();
 
-    let metric = sp_one.evaluate(&source_solution);
+    let metric = sp_one.evaluate(&source_solution).unwrap();
     assert!(metric.is_valid());
 }
 
 #[test]
-fn test_maximumsetpacking_i32_to_f64_cast_closed_loop() {
-    let sp_i32 =
-        MaximumSetPacking::with_weights(vec![vec![0, 1], vec![1, 2], vec![3, 4]], vec![2i32, 3, 5]);
+fn test_maximumsetpacking_i64_to_f64_cast_closed_loop() {
+    let sp_i64 =
+        MaximumSetPacking::with_weights(vec![vec![0, 1], vec![1, 2], vec![3, 4]], vec![2i64, 3, 5])
+            .unwrap();
 
-    let reduction = ReduceTo::<MaximumSetPacking<f64>>::reduce_to(&sp_i32);
+    let reduction =
+        ReduceTo::<MaximumSetPacking<f64>>::reduce_to(&sp_i64).expect("reduction should succeed");
     let sp_f64 = reduction.target_problem();
     assert_eq!(sp_f64.weights_ref(), &vec![2.0f64, 3.0, 5.0]);
 
     let solver = BruteForce::new();
-    let target_solution = solver.find_witness(sp_f64).unwrap();
-    let source_solution = reduction.extract_solution(&target_solution);
+    let target_solution = solver.solve(sp_f64).unwrap().unwrap();
+    let source_solution = reduction.extract_solution(&target_solution).unwrap();
 
-    let metric = sp_i32.evaluate(&source_solution);
+    let metric = sp_i64.evaluate(&source_solution).unwrap();
     assert!(metric.is_valid());
 }
diff --git a/src/unit_tests/rules/maximumsetpacking_ilp.rs b/src/unit_tests/rules/maximumsetpacking_ilp.rs
index 54daaed04..8a7e838e8 100644
--- a/src/unit_tests/rules/maximumsetpacking_ilp.rs
+++ b/src/unit_tests/rules/maximumsetpacking_ilp.rs
@@ -5,59 +5,62 @@ use crate::types::Max;
 
 #[test]
 fn test_reduction_creates_valid_ilp() {
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
-    let reduction: ReductionSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MaximumSetPacking::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
+    let reduction: ReductionSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 3, "Should have one variable per set");
+    assert_eq!(ilp.num_vars(), 3, "Should have one variable per set");
     // Elements 1 and 2 each appear in 2 sets → 2 element constraints
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         2,
         "Should have one constraint per shared element"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize, "Should maximize");
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize, "Should maximize");
 
-    for constraint in &ilp.constraints {
-        assert!(constraint.terms.len() >= 2);
-        assert!((constraint.rhs - 1.0).abs() < 1e-9);
+    for constraint in ilp.constraints() {
+        assert!(constraint.terms().len() >= 2);
+        assert_eq!(constraint.rhs(), 1);
     }
 }
 
 #[test]
 fn test_reduction_weighted() {
-    let problem = MaximumSetPacking::with_weights(vec![vec![0, 1], vec![2, 3]], vec![5, 10]);
-    let reduction: ReductionSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem =
+        MaximumSetPacking::with_weights(vec![vec![0, 1], vec![2, 3]], vec![5, 10]).unwrap();
+    let reduction: ReductionSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    let mut coeffs: Vec<f64> = vec![0.0; 2];
-    for &(var, coef) in &ilp.objective {
+    let mut coeffs: Vec<i64> = vec![0; 2];
+    for &(var, coef) in ilp.objective() {
         coeffs[var] = coef;
     }
-    assert!((coeffs[0] - 5.0).abs() < 1e-9);
-    assert!((coeffs[1] - 10.0).abs() < 1e-9);
+    assert_eq!(coeffs, vec![5, 10]);
 }
 
 #[test]
 fn test_maximumsetpacking_to_ilp_closed_loop() {
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
-    let reduction: ReductionSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MaximumSetPacking::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
+    let reduction: ReductionSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solutions = bf.find_all_witnesses(&problem);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let bf_size: usize = bf_solutions[0].iter().sum();
-    let ilp_size: usize = extracted.iter().sum();
+    let bf_size: usize = bf_solutions[0].iter().filter(|&&selected| selected).count();
+    let ilp_size: usize = extracted.iter().filter(|&&selected| selected).count();
     assert_eq!(bf_size, 2);
     assert_eq!(ilp_size, 2);
 
     assert!(
-        problem.evaluate(&extracted).is_valid(),
+        problem.evaluate(&extracted).unwrap().is_valid(),
         "Extracted solution should be valid"
     );
 }
@@ -67,70 +70,75 @@ fn test_ilp_solution_equals_brute_force_weighted() {
     let problem = MaximumSetPacking::with_weights(
         vec![vec![0, 1, 2, 3], vec![0, 1], vec![2, 3]],
         vec![5, 3, 3],
-    );
-    let reduction: ReductionSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    )
+    .unwrap();
+    let reduction: ReductionSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_obj = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_obj = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_obj = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_obj = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_obj, Max(Some(6)));
     assert_eq!(ilp_obj, Max(Some(6)));
-    assert_eq!(extracted, vec![0, 1, 1]);
+    assert_eq!(extracted, vec![false, true, true]);
 }
 
 #[test]
 fn test_solution_extraction() {
-    let problem =
-        MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![2, 3], vec![4, 5], vec![6, 7]]);
-    let reduction: ReductionSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MaximumSetPacking::new(vec![vec![0, 1], vec![2, 3], vec![4, 5], vec![6, 7]]);
+    let reduction: ReductionSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = vec![1, 0, 1, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![1, 0, 1, 0]);
-    assert!(problem.evaluate(&extracted).is_valid());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![true, false, true, false]);
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_disjoint_sets() {
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0], vec![1], vec![2], vec![3]]);
-    let reduction: ReductionSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MaximumSetPacking::new(vec![vec![0], vec![1], vec![2], vec![3]]);
+    let reduction: ReductionSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.constraints.len(), 0);
+    assert_eq!(ilp.constraints().len(), 0);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, vec![1, 1, 1, 1]);
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Max(Some(4)));
+    assert_eq!(extracted, vec![true, true, true, true]);
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Max(Some(4)));
 }
 
 #[test]
-fn test_solve_reduced() {
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
+fn test_solve_via_ilp_pipeline() {
+    let problem: MaximumSetPacking<i64> =
+        MaximumSetPacking::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
 
     let ilp_solver = ILPSolver::new();
     let solution = ilp_solver
-        .solve_reduced(&problem)
-        .expect("solve_reduced should work");
+        .solve(&problem)
+        .expect("ILP pipeline should solve the problem");
 
-    assert!(problem.evaluate(&solution).is_valid());
-    assert_eq!(problem.evaluate(&solution), Max(Some(2)));
+    assert!(problem.evaluate(&solution).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&solution).unwrap(), Max(Some(2)));
 }
 
 #[test]
 fn test_maximumsetpacking_to_ilp_bf_vs_ilp() {
-    let problem = MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
-    let reduction: ReductionSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MaximumSetPacking::new(vec![vec![0, 1], vec![1, 2], vec![2, 3]]);
+    let reduction: ReductionSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/maximumsetpacking_qubo.rs b/src/unit_tests/rules/maximumsetpacking_qubo.rs
index dfad90aa2..c523def04 100644
--- a/src/unit_tests/rules/maximumsetpacking_qubo.rs
+++ b/src/unit_tests/rules/maximumsetpacking_qubo.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
 #[test]
@@ -8,16 +9,16 @@ fn test_setpacking_to_qubo_closed_loop() {
     // Overlaps: (0,1) share element 2, (0,2) share element 0
     // Max packing: sets 1 and 2 → {1,2} and {0,3} (no overlap)
     let sp = MaximumSetPacking::<f64>::new(vec![vec![0, 2], vec![1, 2], vec![0, 3]]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sp);
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(sp.evaluate(&extracted).is_valid());
-        assert_eq!(extracted.iter().filter(|&&x| x == 1).count(), 2);
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(sp.evaluate(&extracted).unwrap().is_valid());
+        assert_eq!(extracted.iter().filter(|&&x| x).count(), 2);
     }
 }
 
@@ -25,17 +26,17 @@ fn test_setpacking_to_qubo_closed_loop() {
 fn test_setpacking_to_qubo_disjoint() {
     // Disjoint sets: all can be packed
     let sp = MaximumSetPacking::<f64>::new(vec![vec![0, 1], vec![2, 3], vec![4]]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sp);
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(sp.evaluate(&extracted).is_valid());
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(sp.evaluate(&extracted).unwrap().is_valid());
         // All 3 sets should be selected
-        assert_eq!(extracted.iter().filter(|&&x| x == 1).count(), 3);
+        assert_eq!(extracted.iter().filter(|&&x| x).count(), 3);
     }
 }
 
@@ -43,25 +44,93 @@ fn test_setpacking_to_qubo_disjoint() {
 fn test_setpacking_to_qubo_all_overlap() {
     // All sets overlap: only 1 can be selected
     let sp = MaximumSetPacking::<f64>::new(vec![vec![0, 1], vec![0, 2], vec![0, 3]]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sp);
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        assert!(sp.evaluate(&extracted).is_valid());
-        assert_eq!(extracted.iter().filter(|&&x| x == 1).count(), 1);
+        let extracted = reduction.extract_solution(sol).unwrap();
+        assert!(sp.evaluate(&extracted).unwrap().is_valid());
+        assert_eq!(extracted.iter().filter(|&&x| x).count(), 1);
     }
 }
 
 #[test]
 fn test_setpacking_to_qubo_structure() {
     let sp = MaximumSetPacking::<f64>::new(vec![vec![0, 2], vec![1, 2], vec![0, 3]]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sp);
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     // QUBO should have same number of variables as sets
     assert_eq!(qubo.num_variables(), 3);
 }
+
+#[test]
+fn test_setpacking_to_qubo_signed_weights_all_optima() {
+    use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+
+    // Every intersection graph on three sets and every combination of signed,
+    // zero and fractional weights. Edge-specific elements realize each graph.
+    let choices = [-3.0, -0.5, 0.0, 0.5, 4.0];
+    for graph in 0..8 {
+        let mut sets = vec![Vec::new(); 3];
+        for (edge, (i, j)) in [(0, 1), (0, 2), (1, 2)].into_iter().enumerate() {
+            if graph & (1 << edge) != 0 {
+                sets[i].push(edge);
+                sets[j].push(edge);
+            }
+        }
+        for a in choices {
+            for b in choices {
+                for c in choices {
+                    let source =
+                        MaximumSetPacking::with_weights(sets.clone(), vec![a, b, c]).unwrap();
+                    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source).unwrap();
+                    assert_optimization_round_trip_from_optimization_target(
+                        &source,
+                        &reduction,
+                        "signed intersection graph",
+                    );
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_setpacking_to_qubo_penalty_strict_at_large_weights() {
+    // Adding one rounds back to the same weight at this magnitude.
+    let weight = 2.0_f64.powi(54);
+    let source =
+        MaximumSetPacking::with_weights(vec![vec![0], vec![0]], vec![weight, weight]).unwrap();
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source).unwrap();
+    assert!(reduction.target_problem().matrix()[0][1] > weight);
+    crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target(
+        &source,
+        &reduction,
+        "large exactly representable weights",
+    );
+}
+
+#[test]
+fn test_setpacking_to_qubo_empty() {
+    let source = MaximumSetPacking::<f64>::new(vec![]);
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source).unwrap();
+    crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target(
+        &source,
+        &reduction,
+        "empty packing",
+    );
+}
+
+#[test]
+fn test_setpacking_to_qubo_non_finite_penalty_is_typed_error() {
+    let source =
+        MaximumSetPacking::with_weights(vec![vec![0], vec![0]], vec![f64::MAX, 1.0]).unwrap();
+    assert!(matches!(
+        ReduceTo::<QUBO<f64>>::reduce_to(&source),
+        Err(crate::rules::ReductionError::NonFiniteResult { .. })
+    ));
+}
diff --git a/src/unit_tests/rules/minimumcapacitatedspanningtree_ilp.rs b/src/unit_tests/rules/minimumcapacitatedspanningtree_ilp.rs
index 2b03ca508..e3725ece6 100644
--- a/src/unit_tests/rules/minimumcapacitatedspanningtree_ilp.rs
+++ b/src/unit_tests/rules/minimumcapacitatedspanningtree_ilp.rs
@@ -8,7 +8,7 @@ use crate::traits::Problem;
 use crate::types::Min;
 
 /// Small instance: 4 vertices, 5 edges.
-fn small_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
+fn small_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i64> {
     MinimumCapacitatedSpanningTree::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (1, 3), (2, 3)]),
         vec![2, 3, 1, 1, 2], // edge weights
@@ -19,7 +19,7 @@ fn small_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
 }
 
 /// Canonical instance from issue #901: 5 vertices, 8 edges.
-fn canonical_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
+fn canonical_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i64> {
     MinimumCapacitatedSpanningTree::new(
         SimpleGraph::new(
             5,
@@ -45,66 +45,66 @@ fn canonical_instance() -> MinimumCapacitatedSpanningTree<SimpleGraph, i32> {
 fn test_reduction_creates_expected_ilp_shape() {
     let problem = small_instance();
     let reduction: ReductionMinimumCapacitatedSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    // m=5: num_vars = 3*5 = 15
-    assert_eq!(ilp.num_vars, 15);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    // m=5: num_vars = 5*5 = 25
+    assert_eq!(ilp.num_vars(), 25);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_minimumcapacitatedspanningtree_to_ilp_closed_loop() {
     let problem = small_instance();
     let reduction: ReductionMinimumCapacitatedSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
-    let best_source = bf.find_all_witnesses(&problem);
+    let best_source = bf.find_all_witnesses(&problem).unwrap();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let bf_value = problem.evaluate(&best_source[0]);
-    let ilp_value = problem.evaluate(&extracted);
+    let bf_value = problem.evaluate(&best_source[0]).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
     assert_eq!(ilp_value, bf_value);
-    assert!(problem.is_valid_solution(&extracted));
+    assert!(problem.is_valid_solution(&extracted).unwrap());
 }
 
 #[test]
 fn test_minimumcapacitatedspanningtree_to_ilp_canonical_closed_loop() {
     let problem = canonical_instance();
     let reduction: ReductionMinimumCapacitatedSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
-    let best_source = bf.find_all_witnesses(&problem);
+    let best_source = bf.find_all_witnesses(&problem).unwrap();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&best_source[0]), Min(Some(5)));
-    assert_eq!(problem.evaluate(&extracted), Min(Some(5)));
-    assert!(problem.is_valid_solution(&extracted));
+    assert_eq!(problem.evaluate(&best_source[0]).unwrap(), Min(Some(5)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(5)));
+    assert!(problem.is_valid_solution(&extracted).unwrap());
 }
 
 #[test]
 fn test_solution_extraction_reads_edge_selector_prefix() {
     let problem = small_instance();
     let reduction: ReductionMinimumCapacitatedSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
-    // 15 variables total, first 5 are edge selectors
-    let mut target_solution = vec![0; 15];
+    // 25 variables total, first 5 are edge selectors
+    let mut target_solution = vec![0; 25];
     target_solution[0] = 1; // edge (0,1)
     target_solution[1] = 1; // edge (0,2)
     target_solution[3] = 1; // edge (1,3)
 
     assert_eq!(
-        reduction.extract_solution(&target_solution),
-        vec![1, 1, 0, 1, 0]
+        reduction.extract_solution(&target_solution).unwrap(),
+        vec![true, true, false, true, false]
     );
 }
 
@@ -112,7 +112,7 @@ fn test_solution_extraction_reads_edge_selector_prefix() {
 fn test_minimumcapacitatedspanningtree_to_ilp_bf_vs_ilp() {
     let problem = canonical_instance();
     let reduction: ReductionMinimumCapacitatedSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
@@ -128,12 +128,12 @@ fn test_minimumcapacitatedspanningtree_to_ilp_star_tree() {
         1, // capacity = 1 forces star tree
     );
     let reduction: ReductionMinimumCapacitatedSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(3)));
-    assert!(problem.is_valid_solution(&extracted));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(3)));
+    assert!(problem.is_valid_solution(&extracted).unwrap());
 }
 
 #[test]
@@ -148,10 +148,24 @@ fn test_minimumcapacitatedspanningtree_to_ilp_path_graph() {
         3,
     );
     let reduction: ReductionMinimumCapacitatedSpanningTreeToILP =
-        ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(6)));
-    assert!(problem.is_valid_solution(&extracted));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(6)));
+    assert!(problem.is_valid_solution(&extracted).unwrap());
+}
+
+#[test]
+fn test_zero_requirement_vertex_still_must_be_connected() {
+    let problem = MinimumCapacitatedSpanningTree::new(
+        SimpleGraph::new(4, vec![(0, 1), (1, 3), (0, 3)]),
+        vec![1, 1, 1],
+        0,
+        vec![0, 1, 0, 1],
+        2,
+    );
+    let reduction: ReductionMinimumCapacitatedSpanningTreeToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
+    assert!(ILPSolver::new().solve(reduction.target_problem()).is_err());
 }
diff --git a/src/unit_tests/rules/minimumcostmaximumflow_minimumcostcirculation.rs b/src/unit_tests/rules/minimumcostmaximumflow_minimumcostcirculation.rs
index 716580b80..8bdc090ed 100644
--- a/src/unit_tests/rules/minimumcostmaximumflow_minimumcostcirculation.rs
+++ b/src/unit_tests/rules/minimumcostmaximumflow_minimumcostcirculation.rs
@@ -21,7 +21,8 @@ fn canonical_source() -> MinimumCostMaximumFlow {
 #[test]
 fn test_minimumcostmaximumflow_to_minimumcostcirculation_structure() {
     let source = canonical_source();
-    let reduction = ReduceTo::<MinimumCostCirculation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumCostCirculation>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Vertices preserved, arcs gain exactly one return arc.
@@ -48,7 +49,8 @@ fn test_minimumcostmaximumflow_to_minimumcostcirculation_structure() {
 #[test]
 fn test_minimumcostmaximumflow_to_minimumcostcirculation_closed_loop() {
     let source = canonical_source();
-    let reduction = ReduceTo::<MinimumCostCirculation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumCostCirculation>::reduce_to(&source).expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -68,7 +70,8 @@ fn test_minimumcostmaximumflow_to_minimumcostcirculation_bottleneck() {
         vec![1, 1, 1, 1],
         vec![0, 2, 1, 3],
     );
-    let reduction = ReduceTo::<MinimumCostCirculation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumCostCirculation>::reduce_to(&source).expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -78,10 +81,10 @@ fn test_minimumcostmaximumflow_to_minimumcostcirculation_bottleneck() {
     // Brute-force the target and confirm the extracted source flow has
     // value 1 and cost 1 (the cheaper 1->3 path).
     let solver = BruteForce::new();
-    let target_witness = solver.find_witness(reduction.target_problem()).unwrap();
-    let extracted = reduction.extract_solution(&target_witness);
-    assert_eq!(source.flow_value(&extracted), 1);
-    assert_eq!(source.total_cost(&extracted), 1);
+    let target_witness = solver.solve(reduction.target_problem()).unwrap().unwrap();
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
+    assert_eq!(source.flow_value(&extracted).unwrap(), 1);
+    assert_eq!(source.total_cost(&extracted).unwrap(), 1);
 }
 
 #[test]
@@ -95,7 +98,8 @@ fn test_minimumcostmaximumflow_to_minimumcostcirculation_parallel_arcs() {
         vec![1, 1, 1],
         vec![5, 1, 0],
     );
-    let reduction = ReduceTo::<MinimumCostCirculation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumCostCirculation>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // U = cap[(0,1)#1] + cap[(0,1)#2] = 1 + 1 = 2.
@@ -112,10 +116,10 @@ fn test_minimumcostmaximumflow_to_minimumcostcirculation_parallel_arcs() {
     // Max flow value = 1 (limited by arc (1,2) capacity), cheaper
     // parallel arc has cost 1, so optimal source cost = 1.
     let solver = BruteForce::new();
-    let target_witness = solver.find_witness(target).unwrap();
-    let extracted = reduction.extract_solution(&target_witness);
-    assert_eq!(source.flow_value(&extracted), 1);
-    assert_eq!(source.total_cost(&extracted), 1);
+    let target_witness = solver.solve(target).unwrap().unwrap();
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
+    assert_eq!(source.flow_value(&extracted).unwrap(), 1);
+    assert_eq!(source.total_cost(&extracted).unwrap(), 1);
 }
 
 #[test]
@@ -130,7 +134,8 @@ fn test_minimumcostmaximumflow_to_minimumcostcirculation_unused_low_cost_arc() {
         vec![1, 1, 1],
         vec![1, 0, 1],
     );
-    let reduction = ReduceTo::<MinimumCostCirculation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumCostCirculation>::reduce_to(&source).expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -148,7 +153,8 @@ fn test_minimumcostmaximumflow_to_minimumcostcirculation_zero_capacity_arc() {
         vec![1, 1, 0],
         vec![0, 0, 0],
     );
-    let reduction = ReduceTo::<MinimumCostCirculation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumCostCirculation>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
     // Return arc capacity = cap leaving source = 1 + 0 = 1.
     assert_eq!(target.capacities()[source.num_arcs()], 1);
@@ -160,13 +166,40 @@ fn test_minimumcostmaximumflow_to_minimumcostcirculation_zero_capacity_arc() {
     );
 
     let solver = BruteForce::new();
-    let target_witness = solver.find_witness(target).unwrap();
-    let extracted = reduction.extract_solution(&target_witness);
-    assert_eq!(source.flow_value(&extracted), 1);
+    let target_witness = solver.solve(target).unwrap().unwrap();
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
+    assert_eq!(source.flow_value(&extracted).unwrap(), 1);
     // Zero-capacity arc must be 0 in the extracted flow.
     assert_eq!(extracted[2], 0);
 }
 
+#[test]
+fn test_minimumcostmaximumflow_to_minimumcostcirculation_reports_overflow() {
+    let capacity_overflow = MinimumCostMaximumFlow::new(
+        DirectedGraph::new(3, vec![(0, 1), (0, 2)]),
+        0,
+        2,
+        vec![i64::MAX, 1],
+        vec![0, 0],
+    );
+    assert!(matches!(
+        ReduceTo::<MinimumCostCirculation>::reduce_to(&capacity_overflow),
+        Err(crate::rules::ReductionError::IntegerOverflow { .. })
+    ));
+
+    let cost_overflow = MinimumCostMaximumFlow::new(
+        DirectedGraph::new(3, vec![(0, 1), (1, 2)]),
+        0,
+        2,
+        vec![1, 1],
+        vec![i64::MAX, 1],
+    );
+    assert!(matches!(
+        ReduceTo::<MinimumCostCirculation>::reduce_to(&cost_overflow),
+        Err(crate::rules::ReductionError::IntegerOverflow { .. })
+    ));
+}
+
 #[test]
 fn test_minimumcostmaximumflow_to_minimumcostcirculation_value_priority_over_cost() {
     // A cheaper sub-maximum flow exists but must be rejected because
@@ -183,24 +216,29 @@ fn test_minimumcostmaximumflow_to_minimumcostcirculation_value_priority_over_cos
         vec![2, 2],
         vec![0, 10],
     );
-    let reduction = ReduceTo::<MinimumCostCirculation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumCostCirculation>::reduce_to(&source).expect("reduction should succeed");
 
     let solver = BruteForce::new();
-    let target_witness = solver.find_witness(reduction.target_problem()).unwrap();
-    let extracted = reduction.extract_solution(&target_witness);
-    assert_eq!(source.flow_value(&extracted), 2);
-    assert_eq!(source.total_cost(&extracted), 20);
+    let target_witness = solver.solve(reduction.target_problem()).unwrap().unwrap();
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
+    assert_eq!(source.flow_value(&extracted).unwrap(), 2);
+    assert_eq!(source.total_cost(&extracted).unwrap(), 20);
 
     // The target circulation value uses cost 20 + 2*(-B) where
     // B = 1 + 0 + 10 = 11, so optimum = 20 - 22 = -2.
-    let target_value = reduction.target_problem().evaluate(&target_witness);
+    let target_value = reduction
+        .target_problem()
+        .evaluate(&target_witness)
+        .unwrap();
     assert_eq!(target_value, Min(Some(-2)));
 }
 
 #[test]
 fn test_minimumcostmaximumflow_to_minimumcostcirculation_extract_solution_length() {
     let source = canonical_source();
-    let reduction = ReduceTo::<MinimumCostCirculation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumCostCirculation>::reduce_to(&source).expect("reduction should succeed");
     // Provide a dummy target config of the right length; extract_solution
     // must truncate to num_original_arcs.
     let m = source.num_arcs();
@@ -208,7 +246,7 @@ fn test_minimumcostmaximumflow_to_minimumcostcirculation_extract_solution_length
     for (i, v) in padded.iter_mut().enumerate().take(m) {
         *v = i % 2;
     }
-    let extracted = reduction.extract_solution(&padded);
+    let extracted = reduction.extract_solution(&padded).unwrap();
     assert_eq!(extracted.len(), m);
     assert_eq!(extracted, padded[..m].to_vec());
 }
diff --git a/src/unit_tests/rules/minimumcoveringbycliques_ilp.rs b/src/unit_tests/rules/minimumcoveringbycliques_ilp.rs
index d0b65d386..4e322beef 100644
--- a/src/unit_tests/rules/minimumcoveringbycliques_ilp.rs
+++ b/src/unit_tests/rules/minimumcoveringbycliques_ilp.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
 use crate::models::graph::MinimumCoveringByCliques;
-use crate::solvers::{BruteForce, ILPSolver, Solver};
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -10,12 +10,12 @@ use crate::types::Min;
 fn test_reduction_shape_on_path_p3() {
     let source = MinimumCoveringByCliques::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
     let reduction: ReductionMinimumCoveringByCliquesToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&source);
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 12);
-    assert_eq!(ilp.constraints.len(), 22);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 12);
+    assert_eq!(ilp.constraints().len(), 22);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -25,29 +25,34 @@ fn test_minimumcoveringbycliques_to_ilp_closed_loop() {
         vec![(0, 1), (0, 2), (0, 3), (1, 2), (2, 3)],
     ));
     let reduction: ReductionMinimumCoveringByCliquesToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&source);
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
 
-    let bf_value = BruteForce::new().solve(&source);
+    let bf_value_solution = BruteForce::new().solve(&source).unwrap().unwrap();
+
+    let bf_value = source.evaluate(&bf_value_solution).unwrap();
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(source.evaluate(&extracted), Min(Some(2)));
-    assert_eq!(source.evaluate(&extracted), bf_value);
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(2)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), bf_value);
 }
 
 #[test]
 fn test_minimumcoveringbycliques_to_ilp_empty_graph() {
     let source = MinimumCoveringByCliques::new(SimpleGraph::new(3, vec![]));
     let reduction: ReductionMinimumCoveringByCliquesToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&source);
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 0);
-    assert_eq!(ilp.constraints.len(), 0);
-    assert_eq!(reduction.extract_solution(&[]), Vec::<usize>::new());
-    assert_eq!(source.evaluate(&[]), Min(Some(0)));
+    assert_eq!(ilp.num_vars(), 0);
+    assert_eq!(ilp.constraints().len(), 0);
+    assert_eq!(
+        reduction.extract_solution(&vec![]).unwrap(),
+        Vec::<usize>::new()
+    );
+    assert_eq!(source.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -57,6 +62,6 @@ fn test_minimumcoveringbycliques_to_ilp_bf_vs_ilp() {
         vec![(0, 1), (0, 2), (0, 3), (1, 2), (2, 3)],
     ));
     let reduction: ReductionMinimumCoveringByCliquesToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&source);
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/minimumcoveringbycliques_minimumintersectiongraphbasis.rs b/src/unit_tests/rules/minimumcoveringbycliques_minimumintersectiongraphbasis.rs
index 03f6e8987..0737f7f5d 100644
--- a/src/unit_tests/rules/minimumcoveringbycliques_minimumintersectiongraphbasis.rs
+++ b/src/unit_tests/rules/minimumcoveringbycliques_minimumintersectiongraphbasis.rs
@@ -8,7 +8,8 @@ use crate::types::Min;
 fn test_minimumcoveringbycliques_to_minimumintersectiongraphbasis_closed_loop() {
     let source =
         MinimumCoveringByCliques::new(SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (2, 3)]));
-    let reduction = ReduceTo::<MinimumIntersectionGraphBasis<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumIntersectionGraphBasis<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -21,7 +22,8 @@ fn test_minimumcoveringbycliques_to_minimumintersectiongraphbasis_closed_loop()
 fn test_minimumcoveringbycliques_to_minimumintersectiongraphbasis_structure_identity() {
     let source =
         MinimumCoveringByCliques::new(SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (2, 3)]));
-    let reduction = ReduceTo::<MinimumIntersectionGraphBasis<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumIntersectionGraphBasis<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), source.num_vertices());
@@ -33,39 +35,53 @@ fn test_minimumcoveringbycliques_to_minimumintersectiongraphbasis_structure_iden
 fn test_minimumcoveringbycliques_to_minimumintersectiongraphbasis_issue_example_extraction() {
     let source =
         MinimumCoveringByCliques::new(SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (2, 3)]));
-    let reduction = ReduceTo::<MinimumIntersectionGraphBasis<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumIntersectionGraphBasis<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     let target_solution = intersection_basis_config(target.graph(), &[&[0], &[0], &[0, 1], &[1]]);
 
-    assert_eq!(target.evaluate(&target_solution), Min(Some(2)));
+    assert_eq!(target.evaluate(&target_solution).unwrap(), Min(Some(2)));
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
     assert_eq!(extracted, vec![0, 0, 0, 1]);
-    assert_eq!(source.evaluate(&extracted), Min(Some(2)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_minimumcoveringbycliques_to_minimumintersectiongraphbasis_invalid_target_rejected() {
     let source = MinimumCoveringByCliques::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction = ReduceTo::<MinimumIntersectionGraphBasis<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumIntersectionGraphBasis<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
-    let invalid_target_solution = vec![1; 6];
+    let invalid_target_solution = vec![vec![true; 2]; 3];
 
-    assert_eq!(target.evaluate(&invalid_target_solution), Min(None));
-
-    let extracted = reduction.extract_solution(&invalid_target_solution);
+    assert_eq!(
+        target.evaluate(&invalid_target_solution).unwrap(),
+        Min(None)
+    );
 
-    assert_eq!(source.evaluate(&extracted), Min(None));
+    let error = reduction
+        .extract_solution(&invalid_target_solution)
+        .unwrap_err();
+    assert_eq!(
+        error.to_string(),
+        "target configuration is not a valid intersection graph basis"
+    );
 }
 
 #[test]
 fn test_minimumcoveringbycliques_to_minimumintersectiongraphbasis_empty_graph() {
     let source = MinimumCoveringByCliques::new(SimpleGraph::new(3, vec![]));
-    let reduction = ReduceTo::<MinimumIntersectionGraphBasis<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumIntersectionGraphBasis<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    assert_eq!(target.evaluate(&[]), Min(Some(0)));
-    assert_eq!(reduction.extract_solution(&[]), Vec::<usize>::new());
-    assert_eq!(source.evaluate(&[]), Min(Some(0)));
+    let target_solution = vec![vec![], vec![], vec![]];
+    assert_eq!(target.evaluate(&target_solution).unwrap(), Min(Some(0)));
+    assert_eq!(
+        reduction.extract_solution(&target_solution).unwrap(),
+        Vec::<usize>::new()
+    );
+    assert_eq!(source.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
diff --git a/src/unit_tests/rules/minimumcutintoboundedsets_ilp.rs b/src/unit_tests/rules/minimumcutintoboundedsets_ilp.rs
index 1dbe73c45..1f31f58a5 100644
--- a/src/unit_tests/rules/minimumcutintoboundedsets_ilp.rs
+++ b/src/unit_tests/rules/minimumcutintoboundedsets_ilp.rs
@@ -1,12 +1,12 @@
 use super::*;
 use crate::models::algebraic::ILP;
 use crate::models::graph::MinimumCutIntoBoundedSets;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::rules::ReduceTo;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
-fn small_instance() -> MinimumCutIntoBoundedSets<SimpleGraph, i32> {
+fn small_instance() -> MinimumCutIntoBoundedSets<SimpleGraph, i64> {
     // Path graph 0-1-2-3, unit weights, s=0, t=3, B=3
     MinimumCutIntoBoundedSets::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
@@ -20,31 +20,30 @@ fn small_instance() -> MinimumCutIntoBoundedSets<SimpleGraph, i32> {
 #[test]
 fn test_minimumcutintoboundedsets_to_ilp_closed_loop() {
     let source = small_instance();
-    let reduction: ReductionMinCutBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "MinCutBS -> ILP round trip",
-    );
+    let reduction: ReductionMinCutBSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
 fn test_reduction_shape() {
     let source = small_instance();
-    let reduction: ReductionMinCutBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionMinCutBSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // 4 vertex vars + 3 edge vars = 7
-    assert_eq!(ilp.num_vars, 7);
+    assert_eq!(ilp.num_vars(), 7);
 }
 
 #[test]
 fn test_extract_solution() {
     let source = small_instance();
-    let reduction: ReductionMinCutBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionMinCutBSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let target_sol = vec![0, 0, 1, 1, 0, 1, 0];
-    let extracted = reduction.extract_solution(&target_sol);
-    assert_eq!(extracted, vec![0, 0, 1, 1]);
-    assert!(source.evaluate(&extracted).0.is_some());
+    let extracted = reduction.extract_solution(&target_sol).unwrap();
+    assert_eq!(extracted, vec![false, false, true, true]);
+    assert!(source.evaluate(&extracted).unwrap().0.is_some());
 }
 
 #[test]
@@ -59,17 +58,15 @@ fn test_larger_instance() {
         5,
         4,
     );
-    let reduction: ReductionMinCutBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "MinCutBS larger instance",
-    );
+    let reduction: ReductionMinCutBSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
 fn test_minimumcutintoboundedsets_to_ilp_bf_vs_ilp() {
     let source = small_instance();
-    let reduction: ReductionMinCutBSToILP = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction: ReductionMinCutBSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/minimumdiscreteplanarinversekinematics_qubo.rs b/src/unit_tests/rules/minimumdiscreteplanarinversekinematics_qubo.rs
index 711a805bf..fe188e749 100644
--- a/src/unit_tests/rules/minimumdiscreteplanarinversekinematics_qubo.rs
+++ b/src/unit_tests/rules/minimumdiscreteplanarinversekinematics_qubo.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
 use std::f64::consts::{FRAC_PI_2, PI};
@@ -14,12 +14,13 @@ fn worked_example() -> MinimumDiscretePlanarInverseKinematics {
         vec![vec![0.0, FRAC_PI_2], vec![0.0, FRAC_PI_2]],
         vec![vec![(0, 0), (0, 1), (1, 1)]],
     )
+    .unwrap()
 }
 
 #[test]
 fn test_minimumdiscreteplanarinversekinematics_to_qubo_closed_loop() {
     let source = worked_example();
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source).expect("reduction should succeed");
 
     assert_eq!(reduction.target_problem().num_vars(), 4);
     assert_optimization_round_trip_from_optimization_target(
@@ -36,15 +37,21 @@ fn test_minimumdiscreteplanarinversekinematics_to_qubo_single_link() {
         (0.0, 2.0),
         vec![vec![0.0, FRAC_PI_2, PI]],
         vec![],
-    );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(reduction.target_problem());
+    let qubo_solutions = solver
+        .find_all_witnesses(reduction.target_problem())
+        .unwrap();
 
     assert_eq!(reduction.target_problem().num_vars(), 3);
     assert_eq!(qubo_solutions.len(), 1);
-    assert_eq!(reduction.extract_solution(&qubo_solutions[0]), vec![1]);
-    assert!(matches!(source.evaluate(&[1]), Min(Some(v)) if v.abs() < EPS));
+    assert_eq!(
+        reduction.extract_solution(&qubo_solutions[0]).unwrap(),
+        vec![1]
+    );
+    assert!(matches!(source.evaluate(&vec![1]).unwrap(), Min(Some(v)) if v.abs() < EPS));
 }
 
 #[test]
@@ -54,18 +61,21 @@ fn test_minimumdiscreteplanarinversekinematics_to_qubo_single_sample_per_link()
         (0.0, 4.5),
         vec![vec![FRAC_PI_2], vec![FRAC_PI_2], vec![FRAC_PI_2]],
         vec![vec![(0, 0)], vec![(0, 0)]],
-    );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(reduction.target_problem());
+    let qubo_solutions = solver
+        .find_all_witnesses(reduction.target_problem())
+        .unwrap();
 
     assert_eq!(reduction.target_problem().num_vars(), 3);
-    assert_eq!(qubo_solutions, vec![vec![1, 1, 1]]);
+    assert_eq!(qubo_solutions, vec![vec![true, true, true]]);
     assert_eq!(
-        reduction.extract_solution(&qubo_solutions[0]),
+        reduction.extract_solution(&qubo_solutions[0]).unwrap(),
         vec![0, 0, 0]
     );
-    assert!(matches!(source.evaluate(&[0, 0, 0]), Min(Some(v)) if v.abs() < EPS));
+    assert!(matches!(source.evaluate(&vec![0, 0, 0]).unwrap(), Min(Some(v)) if v.abs() < EPS));
 }
 
 #[test]
@@ -75,16 +85,19 @@ fn test_minimumdiscreteplanarinversekinematics_to_qubo_empty_allowed_pairs() {
         (2.0, 0.0),
         vec![vec![0.0, FRAC_PI_2], vec![0.0, FRAC_PI_2]],
         vec![vec![]],
-    );
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(reduction.target_problem());
+    let qubo_solutions = solver
+        .find_all_witnesses(reduction.target_problem())
+        .unwrap();
 
-    assert_eq!(solver.solve(&source), Min(None));
+    assert!(solver.solve(&source).unwrap().is_none());
     assert!(!qubo_solutions.is_empty(), "QUBO solver found no solutions");
     for target_solution in qubo_solutions {
-        let extracted = reduction.extract_solution(&target_solution);
-        assert_eq!(source.evaluate(&extracted), Min(None));
+        let extracted = reduction.extract_solution(&target_solution).unwrap();
+        assert_eq!(source.evaluate(&extracted).unwrap(), Min(None));
     }
 }
 
@@ -103,6 +116,12 @@ fn test_minimumdiscreteplanarinversekinematics_to_qubo_canonical_example_spec()
     );
     assert_eq!(example.target.problem, "QUBO");
     assert_eq!(example.target.instance["num_vars"], 4);
-    assert_eq!(example.solutions[0].source_config, vec![0_usize, 1]);
-    assert_eq!(example.solutions[0].target_config, vec![1_usize, 0, 0, 1]);
+    assert_eq!(
+        example.solutions[0].source_config,
+        serde_json::json!([0, 1])
+    );
+    assert_eq!(
+        example.solutions[0].target_config,
+        serde_json::json!([true, false, false, true])
+    );
 }
diff --git a/src/unit_tests/rules/minimumdominatingset_ilp.rs b/src/unit_tests/rules/minimumdominatingset_ilp.rs
index 42c4f4031..deddfa504 100644
--- a/src/unit_tests/rules/minimumdominatingset_ilp.rs
+++ b/src/unit_tests/rules/minimumdominatingset_ilp.rs
@@ -8,41 +8,41 @@ fn test_reduction_creates_valid_ilp() {
     // Triangle graph: 3 vertices, 3 edges
     let problem = MinimumDominatingSet::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check ILP structure
-    assert_eq!(ilp.num_vars, 3, "Should have one variable per vertex");
+    assert_eq!(ilp.num_vars(), 3, "Should have one variable per vertex");
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         3,
         "Should have one constraint per vertex"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize");
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize, "Should minimize");
 
     // Each constraint should be x_v + sum_{u in N(v)} x_u >= 1
-    for constraint in &ilp.constraints {
-        assert!(!constraint.terms.is_empty());
-        assert!((constraint.rhs - 1.0).abs() < 1e-9);
+    for constraint in ilp.constraints() {
+        assert!(!constraint.terms().is_empty());
+        assert_eq!(constraint.rhs(), 1);
     }
 }
 
 #[test]
 fn test_reduction_weighted() {
     let problem = MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![5, 10, 15]);
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check that weights are correctly transferred to objective
-    let mut coeffs: Vec<f64> = vec![0.0; 3];
-    for &(var, coef) in &ilp.objective {
+    let mut coeffs: Vec<i64> = vec![0; 3];
+    for &(var, coef) in ilp.objective() {
         coeffs[var] = coef;
     }
-    assert!((coeffs[0] - 5.0).abs() < 1e-9);
-    assert!((coeffs[1] - 10.0).abs() < 1e-9);
-    assert!((coeffs[2] - 15.0).abs() < 1e-9);
+    assert_eq!(coeffs, vec![5, 10, 15]);
 }
 
 #[test]
@@ -51,22 +51,23 @@ fn test_minimumdominatingset_to_ilp_closed_loop() {
     // Minimum dominating set is just the center (weight 1)
     let problem = MinimumDominatingSet::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve with brute force on original problem
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_size = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_size = problem.evaluate(&bf_solutions[0]).unwrap();
 
     // Solve via ILP reduction
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_size = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_size = problem.evaluate(&extracted).unwrap();
 
     // Both should find optimal size = 1 (just the center)
     assert_eq!(bf_size, Min(Some(1)));
@@ -74,7 +75,7 @@ fn test_minimumdominatingset_to_ilp_closed_loop() {
 
     // Verify the ILP solution is valid for the original problem
     assert!(
-        problem.evaluate(&extracted).is_valid(),
+        problem.evaluate(&extracted).unwrap().is_valid(),
         "Extracted solution should be valid"
     );
 }
@@ -84,28 +85,29 @@ fn test_ilp_solution_equals_brute_force_path() {
     // Path graph 0-1-2-3-4: min DS = 2 (e.g., vertices 1 and 3)
     let problem = MinimumDominatingSet::new(
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
-        vec![1i32; 5],
+        vec![1i64; 5],
     );
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve with brute force
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_size = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_size = problem.evaluate(&bf_solutions[0]).unwrap();
 
     // Solve via ILP
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_size = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_size = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_size, Min(Some(2)));
     assert_eq!(ilp_size, Min(Some(2)));
 
     // Verify validity
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
@@ -116,69 +118,73 @@ fn test_ilp_solution_equals_brute_force_weighted() {
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]),
         vec![100, 1, 1, 1],
     );
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_obj = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_obj = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_obj = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_obj = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_obj, Min(Some(3)));
     assert_eq!(ilp_obj, Min(Some(3)));
 
     // Verify the solution selects all leaves
-    assert_eq!(extracted, vec![0, 1, 1, 1]);
+    assert_eq!(extracted, vec![false, true, true, true]);
 }
 
 #[test]
 fn test_solution_extraction() {
     let problem =
-        MinimumDominatingSet::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i32; 4]);
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        MinimumDominatingSet::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), vec![1i64; 4]);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Test that extraction works correctly (1:1 mapping)
     let ilp_solution = vec![1, 0, 1, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![1, 0, 1, 0]);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![true, false, true, false]);
 
     // Verify this is a valid DS (0 dominates 0,1 and 2 dominates 2,3)
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_ilp_structure() {
     let problem = MinimumDominatingSet::new(
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
-        vec![1i32; 5],
+        vec![1i64; 5],
     );
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 5);
-    assert_eq!(ilp.constraints.len(), 5); // one per vertex
+    assert_eq!(ilp.num_vars(), 5);
+    assert_eq!(ilp.constraints().len(), 5); // one per vertex
 }
 
 #[test]
 fn test_isolated_vertices() {
     // Graph with isolated vertex 2: it must be in the dominating set
-    let problem = MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Vertex 2 must be selected (isolated)
-    assert_eq!(extracted[2], 1);
+    assert!(extracted[2]);
 
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
@@ -186,34 +192,36 @@ fn test_complete_graph() {
     // Complete graph K4: min DS = 1 (any vertex dominates all)
     let problem = MinimumDominatingSet::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
 
 #[test]
 fn test_single_vertex() {
     // Single vertex with no edges: must be in dominating set
-    let problem = MinimumDominatingSet::new(SimpleGraph::new(1, vec![]), vec![1i32; 1]);
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MinimumDominatingSet::new(SimpleGraph::new(1, vec![]), vec![1i64; 1]);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, vec![1]);
+    assert_eq!(extracted, vec![true]);
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -222,32 +230,34 @@ fn test_cycle_graph() {
     // Minimum dominating set size = 2
     let problem = MinimumDominatingSet::new(
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]),
-        vec![1i32; 5],
+        vec![1i64; 5],
     );
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_size = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_size = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_size = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_size = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_size, ilp_size);
 
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_minimumdominatingset_to_ilp_bf_vs_ilp() {
     let problem = MinimumDominatingSet::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
-    let reduction: ReductionDSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionDSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/minimumedgecostflow_ilp.rs b/src/unit_tests/rules/minimumedgecostflow_ilp.rs
index 080748317..683d75059 100644
--- a/src/unit_tests/rules/minimumedgecostflow_ilp.rs
+++ b/src/unit_tests/rules/minimumedgecostflow_ilp.rs
@@ -46,19 +46,20 @@ fn infeasible_instance() -> MinimumEdgeCostFlow {
 #[test]
 fn test_minimumedgecostflow_to_ilp_structure() {
     let problem = issue_instance();
-    let reduction: ReductionMECFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMECFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 6 arcs → 2*6 = 12 variables
-    assert_eq!(ilp.num_vars, 12);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 12);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
-    // Objective should have 6 terms (one per indicator variable)
-    assert_eq!(ilp.objective.len(), 6);
+    // Zero-priced arcs are omitted by sparse objective normalization.
+    assert_eq!(ilp.objective(), vec![(6, 3), (7, 1), (8, 2)]);
 
     // Constraints: 6 linking + 6 binary + (5-2)=3 conservation + 1 flow req = 16
     // That is 2*6 + 5 - 1 = 16
-    assert_eq!(ilp.constraints.len(), 16);
+    assert_eq!(ilp.constraints().len(), 16);
 }
 
 #[test]
@@ -66,18 +67,20 @@ fn test_minimumedgecostflow_to_ilp_closed_loop() {
     let problem = issue_instance();
     let bf = BruteForce::new();
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("issue instance has optimal");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
     assert_eq!(bf_value, Min(Some(3)));
 
-    let reduction: ReductionMECFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMECFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let ilp_value = problem.evaluate(&extracted);
+    let ilp_value = problem.evaluate(&extracted).unwrap();
     assert_eq!(ilp_value, bf_value);
 }
 
@@ -86,25 +89,28 @@ fn test_minimumedgecostflow_to_ilp_small_closed_loop() {
     let problem = small_instance();
     let bf = BruteForce::new();
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("small instance has optimal");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
     assert_eq!(bf_value, Min(Some(8)));
 
-    let reduction: ReductionMECFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMECFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), bf_value);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), bf_value);
 }
 
 #[test]
 fn test_minimumedgecostflow_to_ilp_infeasible() {
     let problem = infeasible_instance();
-    let reduction: ReductionMECFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMECFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible instance should produce infeasible ILP"
     );
 }
@@ -112,18 +118,20 @@ fn test_minimumedgecostflow_to_ilp_infeasible() {
 #[test]
 fn test_minimumedgecostflow_to_ilp_bf_vs_ilp() {
     let problem = issue_instance();
-    let reduction: ReductionMECFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMECFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_minimumedgecostflow_to_ilp_extract_solution() {
     let problem = issue_instance();
-    let reduction: ReductionMECFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMECFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manually construct a target solution: route 1 via v2, 2 via v3
     // f = [0, 1, 2, 0, 1, 2], y = [0, 1, 1, 0, 1, 1]
-    let mut target_solution = vec![0usize; 12];
+    let mut target_solution = vec![0_i64; 12];
     target_solution[1] = 1; // f on arc (0,2)
     target_solution[2] = 2; // f on arc (0,3)
     target_solution[4] = 1; // f on arc (2,4)
@@ -133,8 +141,8 @@ fn test_minimumedgecostflow_to_ilp_extract_solution() {
     target_solution[10] = 1; // y on arc (2,4)
     target_solution[11] = 1; // y on arc (3,4)
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     assert_eq!(extracted.len(), 6);
     assert_eq!(extracted, vec![0, 1, 2, 0, 1, 2]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(3)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(3)));
 }
diff --git a/src/unit_tests/rules/minimumexternalmacrodatacompression_ilp.rs b/src/unit_tests/rules/minimumexternalmacrodatacompression_ilp.rs
index 48720b069..2892f3b53 100644
--- a/src/unit_tests/rules/minimumexternalmacrodatacompression_ilp.rs
+++ b/src/unit_tests/rules/minimumexternalmacrodatacompression_ilp.rs
@@ -9,13 +9,13 @@ fn test_emdc_to_ilp_closed_loop() {
     // s = "ab" (len 2), alphabet {a,b}, h=2
     // Optimal: uncompressed, cost = 2
     let problem = MinimumExternalMacroDataCompression::new(2, vec![0, 1], 2);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(value.is_valid(), "Extracted solution should be valid");
     assert_eq!(value, Min(Some(2)));
 }
@@ -28,13 +28,13 @@ fn test_emdc_to_ilp_compression_wins() {
     // Uncompressed: 18
     let s: Vec<usize> = (0..6).cycle().take(18).collect();
     let problem = MinimumExternalMacroDataCompression::new(6, s, 2);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(value.is_valid(), "Extracted solution should be valid");
     assert_eq!(value, Min(Some(12)));
 }
@@ -43,7 +43,7 @@ fn test_emdc_to_ilp_compression_wins() {
 fn test_emdc_to_ilp_structure() {
     // s = "ab" (len 2), alphabet {a,b} (k=2), h=2
     let problem = MinimumExternalMacroDataCompression::new(2, vec![0, 1], 2);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let _n = 2;
@@ -53,8 +53,8 @@ fn test_emdc_to_ilp_structure() {
     // lit[i]: 2
     // ptr triples: (0,1,0),(0,1,1),(0,2,0),(1,1,0),(1,1,1) = 5
     // Total = 4 + 2 + 2 + 5 = 13
-    assert_eq!(ilp.num_vars, 13);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 13);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
     // Constraints:
     // one-hot: n = 2
@@ -64,22 +64,22 @@ fn test_emdc_to_ilp_structure() {
     // ptr matching: each ptr triple's matching constraints
     //   (0,1,0): 1, (0,1,1): 1, (0,2,0): 2, (1,1,0): 1, (1,1,1): 1 = 6
     // Total = 2 + 4 + 1 + 3 + 6 = 16
-    assert_eq!(ilp.constraints.len(), 16);
+    assert_eq!(ilp.constraints().len(), 16);
 }
 
 #[test]
 fn test_emdc_to_ilp_empty() {
     // Empty string: cost should be 0
     let problem = MinimumExternalMacroDataCompression::new(2, vec![], 1);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 0);
-    assert!(ilp.constraints.is_empty());
+    assert_eq!(ilp.num_vars(), 0);
+    assert!(ilp.constraints().is_empty());
 
     // For empty ILP, the solution is empty
-    let extracted = reduction.extract_solution(&[]);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&vec![]).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert_eq!(value, Min(Some(0)));
 }
 
@@ -87,7 +87,7 @@ fn test_emdc_to_ilp_empty() {
 fn test_emdc_to_ilp_bf_vs_ilp() {
     // Small instance: s="ab", alphabet {a,b}, h=2
     let problem = MinimumExternalMacroDataCompression::new(2, vec![0, 1], 2);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
@@ -97,13 +97,13 @@ fn test_emdc_to_ilp_single_char() {
     // Uncompressed: cost = 0+1+0 = 1. With D="a"(1), C=ptr(0,1)(1, 1 ptr): cost = 1+1+0 = 2.
     // So uncompressed is optimal.
     let problem = MinimumExternalMacroDataCompression::new(1, vec![0], 1);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(value.is_valid());
     assert_eq!(value, Min(Some(1)));
 }
@@ -116,13 +116,13 @@ fn test_emdc_to_ilp_repeated_string() {
     // D="aa"(2), C=ptr(0,1) ptr(0,2): cost = 2+2+0 = 4.
     // Uncompressed is best at 3.
     let problem = MinimumExternalMacroDataCompression::new(1, vec![0, 0, 0], 1);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(value.is_valid());
     assert_eq!(value, Min(Some(3)));
 }
diff --git a/src/unit_tests/rules/minimumfaultdetectiontestset_ilp.rs b/src/unit_tests/rules/minimumfaultdetectiontestset_ilp.rs
index a831575ce..f2400cdfc 100644
--- a/src/unit_tests/rules/minimumfaultdetectiontestset_ilp.rs
+++ b/src/unit_tests/rules/minimumfaultdetectiontestset_ilp.rs
@@ -27,76 +27,80 @@ fn issue_problem() -> MinimumFaultDetectionTestSet {
 #[test]
 fn test_reduction_creates_covering_ilp() {
     let problem = issue_problem();
-    let reduction: ReductionMFDTSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMFDTSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 4);
-    assert_eq!(ilp.constraints.len(), 3);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert_eq!(ilp.objective, vec![(0, 1.0), (1, 1.0), (2, 1.0), (3, 1.0)]);
+    assert_eq!(ilp.num_vars(), 4);
+    assert_eq!(ilp.constraints().len(), 3);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert_eq!(ilp.objective(), vec![(0, 1), (1, 1), (2, 1), (3, 1)]);
 
-    assert_eq!(ilp.constraints[0].cmp, Comparison::Ge);
-    assert_eq!(ilp.constraints[0].rhs, 1.0);
-    assert_eq!(ilp.constraints[0].terms, vec![(0, 1.0)]);
+    assert_eq!(ilp.constraints()[0].comparison(), Comparison::Ge);
+    assert_eq!(ilp.constraints()[0].rhs(), 1);
+    assert_eq!(ilp.constraints()[0].terms(), vec![(0, 1)]);
 
-    assert_eq!(ilp.constraints[1].cmp, Comparison::Ge);
-    assert_eq!(ilp.constraints[1].rhs, 1.0);
+    assert_eq!(ilp.constraints()[1].comparison(), Comparison::Ge);
+    assert_eq!(ilp.constraints()[1].rhs(), 1);
     assert_eq!(
-        ilp.constraints[1].terms,
-        vec![(0, 1.0), (1, 1.0), (2, 1.0), (3, 1.0)]
+        ilp.constraints()[1].terms(),
+        vec![(0, 1), (1, 1), (2, 1), (3, 1)]
     );
 
-    assert_eq!(ilp.constraints[2].cmp, Comparison::Ge);
-    assert_eq!(ilp.constraints[2].rhs, 1.0);
-    assert_eq!(ilp.constraints[2].terms, vec![(3, 1.0)]);
+    assert_eq!(ilp.constraints()[2].comparison(), Comparison::Ge);
+    assert_eq!(ilp.constraints()[2].rhs(), 1);
+    assert_eq!(ilp.constraints()[2].terms(), vec![(3, 1)]);
 }
 
 #[test]
 fn test_minimumfaultdetectiontestset_to_ilp_closed_loop() {
     let problem = issue_problem();
-    let reduction: ReductionMFDTSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMFDTSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, vec![1, 0, 0, 1]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(2)));
+    assert_eq!(extracted, vec![vec![true, false], vec![false, true]]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(2)));
     assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_reduction_is_infeasible_when_an_internal_vertex_has_no_covering_pair() {
     let problem = MinimumFaultDetectionTestSet::new(3, vec![], vec![0], vec![2]);
-    let reduction: ReductionMFDTSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMFDTSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 1);
-    assert_eq!(ilp.constraints.len(), 1);
-    assert!(ilp.constraints[0].terms.is_empty());
-    assert_eq!(ilp.constraints[0].cmp, Comparison::Ge);
-    assert_eq!(ilp.constraints[0].rhs, 1.0);
+    assert_eq!(ilp.num_vars(), 1);
+    assert_eq!(ilp.constraints().len(), 1);
+    assert!(ilp.constraints()[0].terms().is_empty());
+    assert_eq!(ilp.constraints()[0].comparison(), Comparison::Ge);
+    assert_eq!(ilp.constraints()[0].rhs(), 1);
 
-    assert_eq!(problem.evaluate(&[0]), Min(None));
-    assert_eq!(problem.evaluate(&[1]), Min(None));
-    assert!(ILPSolver::new().solve(ilp).is_none());
+    assert_eq!(problem.evaluate(&vec![vec![false]]).unwrap(), Min(None));
+    assert_eq!(problem.evaluate(&vec![vec![true]]).unwrap(), Min(None));
+    assert!(ILPSolver::new().solve(ilp).is_err());
 }
 
 #[test]
 fn test_reduction_handles_instances_without_internal_vertices() {
     let problem = MinimumFaultDetectionTestSet::new(2, vec![(0, 1)], vec![0], vec![1]);
-    let reduction: ReductionMFDTSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMFDTSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 1);
-    assert!(ilp.constraints.is_empty());
+    assert_eq!(ilp.num_vars(), 1);
+    assert!(ilp.constraints().is_empty());
 
     let ilp_solution = ILPSolver::new()
         .solve(ilp)
         .expect("ILP should be feasible when there are no internal vertices");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, vec![0]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(0)));
+    assert_eq!(extracted, vec![vec![false]]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(0)));
 }
diff --git a/src/unit_tests/rules/minimumfeedbackarcset_ilp.rs b/src/unit_tests/rules/minimumfeedbackarcset_ilp.rs
index 4c2d060aa..09413a71b 100644
--- a/src/unit_tests/rules/minimumfeedbackarcset_ilp.rs
+++ b/src/unit_tests/rules/minimumfeedbackarcset_ilp.rs
@@ -9,15 +9,20 @@ fn test_reduction_creates_valid_ilp() {
     // Simple 3-cycle: 0 -> 1 -> 2 -> 0
     // m=3 arcs, n=3 vertices → 6 variables, m+m+n = 9 constraints
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
-    let reduction: ReductionFASToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
+    let reduction: ReductionFASToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // m + n = 3 + 3 = 6 variables (3 binary y_a + 3 integer o_v)
-    assert_eq!(ilp.num_vars, 6, "Should have m + n variables");
+    assert_eq!(ilp.num_vars(), 6, "Should have m + n variables");
     // m (binary bounds) + n (order bounds) + m (arc constraints) = 3 + 3 + 3 = 9
-    assert_eq!(ilp.constraints.len(), 9, "Should have 2*m + n constraints");
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize");
+    assert_eq!(
+        ilp.constraints().len(),
+        9,
+        "Should have 2*m + n constraints"
+    );
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize, "Should minimize");
 }
 
 #[test]
@@ -25,21 +30,22 @@ fn test_minimumfeedbackarcset_to_ilp_bf_vs_ilp() {
     // Triangle cycle: 0 -> 1 -> 2 -> 0
     // FAS = 1 (remove any single arc to break the cycle)
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
-    let reduction: ReductionFASToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
+    let reduction: ReductionFASToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve with brute force on original problem
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
 
     // Solve via ILP reduction
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     // Both should find optimal value = 1
     assert_eq!(bf_value, Min(Some(1)));
@@ -50,17 +56,18 @@ fn test_minimumfeedbackarcset_to_ilp_bf_vs_ilp() {
 fn test_solution_extraction() {
     // Verify that extraction correctly takes first m arc values
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 3]);
-    let reduction: ReductionFASToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 3]);
+    let reduction: ReductionFASToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Simulate ILP solution: y_0=0, y_1=0, y_2=1, o_0=0, o_1=1, o_2=2
     let ilp_solution = vec![0, 0, 1, 0, 1, 2];
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![0, 0, 1]);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![false, false, true]);
 
     // Verify this is a valid FAS (removing arc 2->0 breaks the 3-cycle)
     assert!(
-        problem.evaluate(&extracted).is_valid(),
+        problem.evaluate(&extracted).unwrap().is_valid(),
         "Extracted solution should be a valid FAS"
     );
 }
@@ -69,19 +76,20 @@ fn test_solution_extraction() {
 fn test_minimumfeedbackarcset_to_ilp_trivial() {
     // DAG: 0 -> 1 -> 2 (no cycles, FAS = 0)
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumFeedbackArcSet::new(graph, vec![1i32; 2]);
-    let reduction: ReductionFASToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackArcSet::new(graph, vec![1i64; 2]);
+    let reduction: ReductionFASToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // m=2, n=3 → 5 variables; 2 + 3 + 2 = 7 constraints
-    assert_eq!(ilp.num_vars, 5);
-    assert_eq!(ilp.constraints.len(), 7);
+    assert_eq!(ilp.num_vars(), 5);
+    assert_eq!(ilp.constraints().len(), 7);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let value = problem.evaluate(&extracted);
+    let value = problem.evaluate(&extracted).unwrap();
     assert_eq!(value, Min(Some(0)), "DAG needs no arc removal");
-    assert_eq!(extracted, vec![0, 0]);
+    assert_eq!(extracted, vec![false, false]);
 }
diff --git a/src/unit_tests/rules/minimumfeedbackarcset_maximumlikelihoodranking.rs b/src/unit_tests/rules/minimumfeedbackarcset_maximumlikelihoodranking.rs
deleted file mode 100644
index c021a9dda..000000000
--- a/src/unit_tests/rules/minimumfeedbackarcset_maximumlikelihoodranking.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-#[cfg(feature = "example-db")]
-use super::canonical_rule_example_specs;
-use super::ReductionFASToMLR;
-use crate::models::graph::MinimumFeedbackArcSet;
-use crate::models::misc::MaximumLikelihoodRanking;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
-use crate::rules::traits::ReductionResult;
-use crate::rules::ReduceTo;
-#[cfg(feature = "example-db")]
-use crate::solvers::BruteForce;
-use crate::topology::DirectedGraph;
-#[cfg(feature = "example-db")]
-use crate::traits::Problem;
-
-fn issue_example_source() -> MinimumFeedbackArcSet<i32> {
-    MinimumFeedbackArcSet::new(
-        DirectedGraph::new(
-            5,
-            vec![(0, 1), (1, 2), (2, 0), (2, 3), (3, 4), (4, 2), (0, 4)],
-        ),
-        vec![1i32; 7],
-    )
-}
-
-fn dag_source() -> MinimumFeedbackArcSet<i32> {
-    MinimumFeedbackArcSet::new(
-        DirectedGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
-        vec![1i32; 6],
-    )
-}
-
-fn bidirectional_source() -> MinimumFeedbackArcSet<i32> {
-    MinimumFeedbackArcSet::new(
-        DirectedGraph::new(3, vec![(0, 1), (1, 0), (1, 2)]),
-        vec![1i32; 3],
-    )
-}
-
-fn weighted_cycle_source() -> MinimumFeedbackArcSet<i32> {
-    MinimumFeedbackArcSet::new(
-        DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]),
-        vec![10i32, 1, 1],
-    )
-}
-
-#[test]
-fn test_minimumfeedbackarcset_to_maximumlikelihoodranking_closed_loop() {
-    let source = issue_example_source();
-    let reduction: ReductionFASToMLR = ReduceTo::<MaximumLikelihoodRanking>::reduce_to(&source);
-
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "MinimumFeedbackArcSet -> MaximumLikelihoodRanking closed loop (issue example)",
-    );
-}
-
-#[test]
-fn test_minimumfeedbackarcset_to_maximumlikelihoodranking_dag_closed_loop() {
-    let source = dag_source();
-    let reduction: ReductionFASToMLR = ReduceTo::<MaximumLikelihoodRanking>::reduce_to(&source);
-
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "MinimumFeedbackArcSet -> MaximumLikelihoodRanking closed loop (DAG)",
-    );
-}
-
-#[test]
-fn test_reduction_matrix_matches_issue_example() {
-    let source = issue_example_source();
-    let reduction: ReductionFASToMLR = ReduceTo::<MaximumLikelihoodRanking>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.num_items(), 5);
-    assert_eq!(target.comparison_count(), 0);
-    assert_eq!(
-        target.matrix(),
-        &vec![
-            vec![0, 1, -1, 0, 1],
-            vec![-1, 0, 1, 0, 0],
-            vec![1, -1, 0, 1, -1],
-            vec![0, 0, -1, 0, 1],
-            vec![-1, 0, 1, -1, 0],
-        ]
-    );
-}
-
-#[test]
-fn test_bidirectional_arcs_map_to_zero_entries() {
-    let source = bidirectional_source();
-    let reduction: ReductionFASToMLR = ReduceTo::<MaximumLikelihoodRanking>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.comparison_count(), 0);
-    assert_eq!(
-        target.matrix(),
-        &vec![vec![0, 0, 0], vec![0, 0, 1], vec![0, -1, 0]]
-    );
-}
-
-#[test]
-fn test_solution_extraction_marks_backward_arcs() {
-    let source = issue_example_source();
-    let reduction: ReductionFASToMLR = ReduceTo::<MaximumLikelihoodRanking>::reduce_to(&source);
-
-    let source_config = reduction.extract_solution(&[0, 1, 2, 3, 4]);
-    assert_eq!(source_config, vec![0, 0, 1, 0, 0, 1, 0]);
-}
-
-#[test]
-#[should_panic(
-    expected = "MinimumFeedbackArcSet -> MaximumLikelihoodRanking requires unit arc weights"
-)]
-fn test_weighted_instances_are_rejected() {
-    let source = weighted_cycle_source();
-    let _ = ReduceTo::<MaximumLikelihoodRanking>::reduce_to(&source);
-}
-
-#[cfg(feature = "example-db")]
-#[test]
-fn test_canonical_rule_example_spec_builds() {
-    let example = (canonical_rule_example_specs()
-        .into_iter()
-        .find(|spec| spec.id == "minimumfeedbackarcset_to_maximumlikelihoodranking")
-        .expect("example spec should be registered")
-        .build)();
-
-    assert_eq!(example.source.problem, "MinimumFeedbackArcSet");
-    assert_eq!(example.target.problem, "MaximumLikelihoodRanking");
-    assert_eq!(example.solutions.len(), 1);
-
-    let source: MinimumFeedbackArcSet<i32> =
-        serde_json::from_value(example.source.instance.clone())
-            .expect("source example deserializes");
-    let target: MaximumLikelihoodRanking = serde_json::from_value(example.target.instance.clone())
-        .expect("target example deserializes");
-    let solution = &example.solutions[0];
-
-    let source_metric = source.evaluate(&solution.source_config);
-    let target_metric = target.evaluate(&solution.target_config);
-    assert!(
-        source_metric.is_valid(),
-        "source witness should be feasible"
-    );
-    assert!(
-        target_metric.is_valid(),
-        "target witness should be feasible"
-    );
-
-    let best_source = BruteForce::new()
-        .find_witness(&source)
-        .expect("source example should have an optimum");
-    let best_target = BruteForce::new()
-        .find_witness(&target)
-        .expect("target example should have an optimum");
-
-    assert_eq!(source_metric, source.evaluate(&best_source));
-    assert_eq!(target_metric, target.evaluate(&best_target));
-}
diff --git a/src/unit_tests/rules/minimumfeedbackvertexset_ilp.rs b/src/unit_tests/rules/minimumfeedbackvertexset_ilp.rs
index 74f12365d..8b47862ae 100644
--- a/src/unit_tests/rules/minimumfeedbackvertexset_ilp.rs
+++ b/src/unit_tests/rules/minimumfeedbackvertexset_ilp.rs
@@ -8,15 +8,16 @@ use crate::types::Min;
 fn test_reduction_creates_valid_ilp() {
     // Simple 3-cycle: 0 -> 1 -> 2 -> 0
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 3]);
-    let reduction: ReductionMFVSToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 3]);
+    let reduction: ReductionMFVSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 2n = 6 variables (3 binary x_i + 3 integer o_i)
-    assert_eq!(ilp.num_vars, 6, "Should have 2n variables");
+    assert_eq!(ilp.num_vars(), 6, "Should have 2n variables");
     // m + 2n = 3 + 6 = 9 constraints
-    assert_eq!(ilp.constraints.len(), 9, "Should have m + 2n constraints");
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize");
+    assert_eq!(ilp.constraints().len(), 9, "Should have m + 2n constraints");
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize, "Should minimize");
 }
 
 #[test]
@@ -24,21 +25,22 @@ fn test_minimumfeedbackvertexset_to_ilp_closed_loop() {
     // Simple 3-cycle: 0 -> 1 -> 2 -> 0
     // FVS = 1 (remove any single vertex)
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 3]);
-    let reduction: ReductionMFVSToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 3]);
+    let reduction: ReductionMFVSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve with brute force on original problem
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_size = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_size = problem.evaluate(&bf_solutions[0]).unwrap();
 
     // Solve via ILP reduction
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_size = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_size = problem.evaluate(&extracted).unwrap();
 
     // Both should find optimal size = 1
     assert_eq!(bf_size, Min(Some(1)));
@@ -46,7 +48,7 @@ fn test_minimumfeedbackvertexset_to_ilp_closed_loop() {
 
     // Verify the ILP solution is valid for the original problem
     assert!(
-        problem.evaluate(&extracted).is_valid(),
+        problem.evaluate(&extracted).unwrap().is_valid(),
         "Extracted solution should be valid"
     );
 }
@@ -72,23 +74,24 @@ fn test_cycle_of_triangles() {
         (8, 2), // more inter-triangle arcs
     ];
     let graph = DirectedGraph::new(9, arcs);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 9]);
-    let reduction: ReductionMFVSToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 9]);
+    let reduction: ReductionMFVSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Verify ILP structure
-    assert_eq!(ilp.num_vars, 18, "Should have 2*9 = 18 variables");
+    assert_eq!(ilp.num_vars(), 18, "Should have 2*9 = 18 variables");
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         15 + 18,
         "Should have 15 arc + 18 bound constraints"
     );
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let size = problem.evaluate(&extracted);
+    let size = problem.evaluate(&extracted).unwrap();
     assert_eq!(size, Min(Some(3)), "FVS should be 3");
 }
 
@@ -96,37 +99,39 @@ fn test_cycle_of_triangles() {
 fn test_dag_no_removal() {
     // DAG: 0 -> 1 -> 2 (no cycles, FVS = 0)
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 3]);
-    let reduction: ReductionMFVSToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 3]);
+    let reduction: ReductionMFVSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let size = problem.evaluate(&extracted);
+    let size = problem.evaluate(&extracted).unwrap();
     assert_eq!(size, Min(Some(0)), "DAG needs no removal");
-    assert_eq!(extracted, vec![0, 0, 0]);
+    assert_eq!(extracted, vec![false, false, false]);
 }
 
 #[test]
 fn test_single_vertex() {
     // Single vertex, no arcs: FVS = 0
     let graph = DirectedGraph::new(1, vec![]);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32]);
-    let reduction: ReductionMFVSToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64]);
+    let reduction: ReductionMFVSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 2);
+    assert_eq!(ilp.num_vars(), 2);
     // 0 arc constraints + 2 bound constraints
-    assert_eq!(ilp.constraints.len(), 2);
+    assert_eq!(ilp.constraints().len(), 2);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, vec![0]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(0)));
+    assert_eq!(extracted, vec![false]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -135,25 +140,24 @@ fn test_weighted() {
     // Weights: v0=10, v1=1, v2=10
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
     let problem = MinimumFeedbackVertexSet::new(graph, vec![10, 1, 10]);
-    let reduction: ReductionMFVSToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMFVSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check that weights are correctly transferred to objective
-    let mut coeffs: Vec<f64> = vec![0.0; ilp.num_vars];
-    for &(var, coef) in &ilp.objective {
+    let mut coeffs: Vec<i64> = vec![0; ilp.num_vars()];
+    for &(var, coef) in ilp.objective() {
         coeffs[var] = coef;
     }
-    assert!((coeffs[0] - 10.0).abs() < 1e-9);
-    assert!((coeffs[1] - 1.0).abs() < 1e-9);
-    assert!((coeffs[2] - 10.0).abs() < 1e-9);
+    assert_eq!(&coeffs[..3], &[10, 1, 10]);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Should remove vertex 1 (cheapest)
-    assert_eq!(extracted[1], 1, "Should remove vertex 1 (cheapest)");
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
+    assert!(extracted[1], "Should remove vertex true (cheapest)");
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -161,18 +165,19 @@ fn test_two_disjoint_cycles() {
     // Two disjoint 2-cycles: 0<->1 and 2<->3
     // Need to remove at least 1 from each cycle, FVS = 2
     let graph = DirectedGraph::new(4, vec![(0, 1), (1, 0), (2, 3), (3, 2)]);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 4]);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 4]);
 
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_size = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_size = problem.evaluate(&bf_solutions[0]).unwrap();
 
-    let reduction: ReductionMFVSToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMFVSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_size = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_size = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_size, Min(Some(2)));
     assert_eq!(ilp_size, Min(Some(2)));
@@ -182,22 +187,24 @@ fn test_two_disjoint_cycles() {
 fn test_solution_extraction() {
     // Verify that extraction correctly takes first n values
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 3]);
-    let reduction: ReductionMFVSToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 3]);
+    let reduction: ReductionMFVSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Simulate ILP solution: x_0=1, x_1=0, x_2=0, o_0=0, o_1=0, o_2=1
     let ilp_solution = vec![1, 0, 0, 0, 0, 1];
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![1, 0, 0]);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![true, false, false]);
 
     // Verify this is a valid FVS (removing vertex 0 breaks the 3-cycle)
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_minimumfeedbackvertexset_to_ilp_bf_vs_ilp() {
     let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]);
-    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i32; 3]);
-    let reduction: ReductionMFVSToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinimumFeedbackVertexSet::new(graph, vec![1i64; 3]);
+    let reduction: ReductionMFVSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters.rs b/src/unit_tests/rules/minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters.rs
index f8a174016..3712e5c42 100644
--- a/src/unit_tests/rules/minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters.rs
+++ b/src/unit_tests/rules/minimumfeedbackvertexset_minimumcodegenerationunlimitedregisters.rs
@@ -7,7 +7,8 @@ use crate::rules::ReduceTo;
 fn test_minimumfeedbackvertexset_to_minimumcodegenerationunlimitedregisters_closed_loop() {
     let source = issue_example_source();
     let reduction: ReductionFVSToCodeGen =
-        ReduceTo::<MinimumCodeGenerationUnlimitedRegisters>::reduce_to(&source);
+        ReduceTo::<MinimumCodeGenerationUnlimitedRegisters>::reduce_to(&source)
+            .expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -15,3 +16,161 @@ fn test_minimumfeedbackvertexset_to_minimumcodegenerationunlimitedregisters_clos
         "MinimumFeedbackVertexSet -> MinimumCodeGenerationUnlimitedRegisters closed loop",
     );
 }
+
+#[test]
+fn test_codegen_rule_is_registered_only_for_unit_weight() {
+    let entries: Vec<_> = crate::rules::registry::reduction_entries()
+        .into_iter()
+        .filter(|e| {
+            e.source_name == "MinimumFeedbackVertexSet"
+                && e.target_name == "MinimumCodeGenerationUnlimitedRegisters"
+        })
+        .collect();
+    assert_eq!(entries.len(), 1);
+    assert_eq!((entries[0].source_variant_fn)(), vec![("weight", "One")]);
+}
+
+#[test]
+fn test_codegen_start_nodes_cover_self_loops_and_parallel_arcs() {
+    use crate::models::graph::MinimumFeedbackVertexSet;
+    use crate::rules::ReductionResult;
+    use crate::topology::DirectedGraph;
+    use crate::traits::Problem;
+    use crate::types::{Min, One};
+    let source = MinimumFeedbackVertexSet::new(
+        DirectedGraph::new(3, vec![(0, 1), (1, 0), (2, 2), (2, 2)]),
+        vec![One; 3],
+    );
+    let reduction =
+        ReduceTo::<MinimumCodeGenerationUnlimitedRegisters>::reduce_to(&source).unwrap();
+    let target = reduction.target_problem();
+    assert_eq!(target.num_vertices(), 11);
+    assert_eq!(target.num_internal(), 7);
+    let config = (0..7).collect();
+    assert_eq!(target.evaluate(&config).unwrap(), Min(Some(9)));
+    let removed = reduction.extract_solution(&config).unwrap();
+    assert_eq!(removed, vec![true, false, true]);
+    assert_eq!(source.evaluate(&removed).unwrap(), Min(Some(2)));
+}
+
+#[test]
+fn test_codegen_empty_graph_and_invalid_orders() {
+    use crate::models::graph::MinimumFeedbackVertexSet;
+    use crate::rules::ReductionResult;
+    use crate::topology::DirectedGraph;
+    use crate::types::One;
+    let empty = MinimumFeedbackVertexSet::<One>::new(DirectedGraph::new(0, vec![]), vec![]);
+    let reduction = ReduceTo::<MinimumCodeGenerationUnlimitedRegisters>::reduce_to(&empty).unwrap();
+    assert_eq!(reduction.target_problem().num_vertices(), 1);
+    assert_eq!(
+        reduction.extract_solution(&vec![]).unwrap(),
+        Vec::<bool>::new()
+    );
+    let source = issue_example_source();
+    let reduction =
+        ReduceTo::<MinimumCodeGenerationUnlimitedRegisters>::reduce_to(&source).unwrap();
+    for config in [vec![], vec![9; 6], vec![0; 6], vec![1, 0, 2, 3, 4, 5]] {
+        assert!(reduction.extract_solution(&config).is_err());
+    }
+}
+
+#[test]
+fn test_codegen_every_small_evaluation_permutation() {
+    use crate::models::graph::MinimumFeedbackVertexSet;
+    use crate::rules::ReductionResult;
+    use crate::solvers::BruteForce;
+    use crate::topology::DirectedGraph;
+    use crate::traits::Problem;
+    use crate::types::{Min, One};
+    fn visit(config: &mut [usize], offset: usize, check: &mut impl FnMut(&[usize])) {
+        if offset == config.len() {
+            check(config);
+        } else {
+            for i in offset..config.len() {
+                config.swap(offset, i);
+                visit(config, offset + 1, check);
+                config.swap(offset, i);
+            }
+        }
+    }
+    // All directed graphs on <=3 vertices with <=3 arcs, including loops.
+    // Every permutation is tested, not just orders grouping whole chains.
+    for n in 0..=3 {
+        let pairs: Vec<_> = (0..n).flat_map(|u| (0..n).map(move |v| (u, v))).collect();
+        for mask in 0u32..(1 << pairs.len()) {
+            if mask.count_ones() > 3 {
+                continue;
+            }
+            let arcs: Vec<_> = pairs
+                .iter()
+                .enumerate()
+                .filter_map(|(i, &arc)| (mask & (1 << i) != 0).then_some(arc))
+                .collect();
+            let source = MinimumFeedbackVertexSet::new(DirectedGraph::new(n, arcs), vec![One; n]);
+            let witness = BruteForce::new().solve(&source).unwrap().unwrap();
+            let Min(Some(optimum)) = source.evaluate(&witness).unwrap() else {
+                unreachable!()
+            };
+            let reduction =
+                ReduceTo::<MinimumCodeGenerationUnlimitedRegisters>::reduce_to(&source).unwrap();
+            let target = reduction.target_problem();
+            let operations = target.num_internal() as i64;
+            let mut best = i64::MAX;
+            visit(
+                &mut (0..target.num_internal()).collect::<Vec<_>>(),
+                0,
+                &mut |p| {
+                    let config = p.to_vec();
+                    if let Min(Some(cost)) = target.evaluate(&config).unwrap() {
+                        let removed = reduction.extract_solution(&config).unwrap();
+                        let Min(Some(size)) = source.evaluate(&removed).unwrap() else {
+                            panic!("every valid target order must extract an FVS");
+                        };
+                        assert_eq!(cost, operations + size);
+                        assert!(size >= optimum);
+                        best = best.min(cost);
+                    }
+                },
+            );
+            assert_eq!(best, operations + optimum);
+        }
+    }
+}
+
+#[test]
+fn test_codegen_vertex_count_representable_boundaries() {
+    use super::code_generation_vertex_count;
+    // Count arithmetic is independent of graph allocation. These maximum-size
+    // cases exercise the actual preallocation calculation without building a graph.
+    let half = usize::MAX / 2;
+    for (n, m, expected) in [
+        (0, 0, 1),
+        (3, 3, 10),
+        (half - 1, 1, usize::MAX - 1),
+        (half, 0, usize::MAX),
+        (1, usize::MAX - 3, usize::MAX),
+    ] {
+        assert_eq!(code_generation_vertex_count(n, m), Ok(expected));
+    }
+}
+
+#[test]
+fn test_codegen_vertex_count_rejects_each_overflow_stage() {
+    use super::code_generation_vertex_count;
+    use crate::rules::ReductionError;
+    let half = usize::MAX / 2;
+    for (n, m) in [
+        (half + 1, 0),       // doubling the source vertex count
+        (1, usize::MAX - 1), // adding the arc count
+        (half, 1),           // adding the dummy leaf
+    ] {
+        assert_eq!(
+            code_generation_vertex_count(n, m),
+            Err(ReductionError::IntegerOverflow {
+                source_problem: "MinimumFeedbackVertexSet",
+                target_problem: "MinimumCodeGenerationUnlimitedRegisters",
+                operation: "counting code-generation start and arc nodes".to_string(),
+            })
+        );
+    }
+}
diff --git a/src/unit_tests/rules/minimumgraphbandwidth_ilp.rs b/src/unit_tests/rules/minimumgraphbandwidth_ilp.rs
index 577295a8c..9eec5a8d3 100644
--- a/src/unit_tests/rules/minimumgraphbandwidth_ilp.rs
+++ b/src/unit_tests/rules/minimumgraphbandwidth_ilp.rs
@@ -7,11 +7,12 @@ use crate::traits::Problem;
 fn test_reduction_creates_valid_ilp() {
     // Star S4: 4 vertices, 3 edges
     let problem = MinimumGraphBandwidth::new(SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]));
-    let reduction: ReductionMGBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMGBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // num_x=16, pos_v=4, B=1, total=21
-    assert_eq!(ilp.num_vars, 21);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 21);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -22,25 +23,27 @@ fn test_minimumgraphbandwidth_to_ilp_closed_loop() {
     // BruteForce on source to verify feasibility
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute-force should find a solution");
-    assert!(problem.evaluate(&bf_solution).0.is_some());
+    assert!(problem.evaluate(&bf_solution).unwrap().0.is_some());
 
     // Solve via ILP
-    let reduction: ReductionMGBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMGBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
     assert!(
         ilp_value.0.is_some(),
         "ILP solution should produce a valid arrangement"
     );
 
     // BF and ILP should agree on optimal value
-    let bf_value = problem.evaluate(&bf_solution);
+    let bf_value = problem.evaluate(&bf_solution).unwrap();
     assert_eq!(
         ilp_value, bf_value,
         "ILP and BF should find same optimal bandwidth"
@@ -52,13 +55,14 @@ fn test_minimumgraphbandwidth_to_ilp_path() {
     // Path P4: 0-1-2-3 (optimal bandwidth = 1)
     let problem = MinimumGraphBandwidth::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
 
-    let reduction: ReductionMGBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMGBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert_eq!(
         value,
         crate::types::Min(Some(1)),
@@ -70,7 +74,8 @@ fn test_minimumgraphbandwidth_to_ilp_path() {
 fn test_minimumgraphbandwidth_to_ilp_bf_vs_ilp() {
     // Star S4
     let problem = MinimumGraphBandwidth::new(SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]));
-    let reduction: ReductionMGBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMGBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
@@ -79,6 +84,7 @@ fn test_minimumgraphbandwidth_to_ilp_cycle() {
     // Cycle C4: 0-1-2-3-0 (optimal bandwidth = 2)
     let problem =
         MinimumGraphBandwidth::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (3, 0)]));
-    let reduction: ReductionMGBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMGBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/minimumhittingset_ilp.rs b/src/unit_tests/rules/minimumhittingset_ilp.rs
index fff92587b..aa15bc9d6 100644
--- a/src/unit_tests/rules/minimumhittingset_ilp.rs
+++ b/src/unit_tests/rules/minimumhittingset_ilp.rs
@@ -5,25 +5,27 @@ use crate::traits::Problem;
 #[test]
 fn test_reduction_creates_valid_ilp() {
     let problem = MinimumHittingSet::new(3, vec![vec![0, 1], vec![1, 2]]);
-    let reduction: ReductionHSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionHSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 3, "one var per universe element");
-    assert_eq!(ilp.constraints.len(), 2, "one constraint per set");
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 3, "one var per universe element");
+    assert_eq!(ilp.constraints().len(), 2, "one constraint per set");
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_minimumhittingset_to_ilp_bf_vs_ilp() {
     let problem = MinimumHittingSet::new(4, vec![vec![0, 1], vec![2, 3], vec![1, 2]]);
-    let reduction: ReductionHSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionHSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
     assert_eq!(bf_value, ilp_value);
     assert!(ilp_value.is_valid());
 }
@@ -31,18 +33,20 @@ fn test_minimumhittingset_to_ilp_bf_vs_ilp() {
 #[test]
 fn test_solution_extraction() {
     let problem = MinimumHittingSet::new(3, vec![vec![0, 1], vec![1, 2]]);
-    let reduction: ReductionHSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionHSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = vec![0, 1, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![0, 1, 0]);
-    assert!(problem.evaluate(&extracted).is_valid());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![false, true, false]);
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_minimumhittingset_to_ilp_trivial() {
     let problem = MinimumHittingSet::new(0, vec![]);
-    let reduction: ReductionHSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionHSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 0);
-    assert_eq!(ilp.constraints.len(), 0);
+    assert_eq!(ilp.num_vars(), 0);
+    assert_eq!(ilp.constraints().len(), 0);
 }
diff --git a/src/unit_tests/rules/minimuminternalmacrodatacompression_ilp.rs b/src/unit_tests/rules/minimuminternalmacrodatacompression_ilp.rs
index 39a642450..09908a2b9 100644
--- a/src/unit_tests/rules/minimuminternalmacrodatacompression_ilp.rs
+++ b/src/unit_tests/rules/minimuminternalmacrodatacompression_ilp.rs
@@ -1,7 +1,7 @@
 use crate::models::algebraic::ILP;
 use crate::models::misc::MinimumInternalMacroDataCompression;
 use crate::rules::traits::{ReduceTo, ReductionResult};
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -10,13 +10,13 @@ fn test_imdc_to_ilp_closed_loop_simple() {
     // s = "ab", alphabet {a,b}, h=2
     // Optimal: uncompressed, cost=2
     let source = MinimumInternalMacroDataCompression::new(2, vec![0, 1], 2);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let solver = BruteForce::new();
-    let target_witness = solver.find_witness(target).expect("ILP should be feasible");
-    let source_config = reduction.extract_solution(&target_witness);
-    let val = source.evaluate(&source_config);
+    let solver = ILPSolver::new();
+    let target_witness = solver.solve(target).expect("ILP should be feasible");
+    let source_config = reduction.extract_solution(&target_witness).unwrap();
+    let val = source.evaluate(&source_config).unwrap();
     assert!(val.0.is_some());
     assert_eq!(val.0.unwrap(), 2);
 }
@@ -26,13 +26,13 @@ fn test_imdc_to_ilp_closed_loop_repeated() {
     // s = "abab", alphabet {a,b}, h=2
     // Optimal: cost=4 (uncompressed or pointer, both cost 4)
     let source = MinimumInternalMacroDataCompression::new(2, vec![0, 1, 0, 1], 2);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let solver = BruteForce::new();
-    let target_witness = solver.find_witness(target).expect("ILP should be feasible");
-    let source_config = reduction.extract_solution(&target_witness);
-    let val = source.evaluate(&source_config);
+    let solver = ILPSolver::new();
+    let target_witness = solver.solve(target).expect("ILP should be feasible");
+    let source_config = reduction.extract_solution(&target_witness).unwrap();
+    let val = source.evaluate(&source_config).unwrap();
     assert!(val.0.is_some());
     assert_eq!(val.0.unwrap(), 4);
 }
@@ -43,27 +43,28 @@ fn test_imdc_to_ilp_closed_loop_low_pointer_cost() {
     // With h=1, pointers cost 0 extra: cost = |C|
     // Optimal with pointer: C=[a,b,ptr(0)], active=3, ptrs=1, cost=3+0=3
     let source = MinimumInternalMacroDataCompression::new(2, vec![0, 1, 0, 1], 1);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let solver = BruteForce::new();
-    let target_witness = solver.find_witness(target).expect("ILP should be feasible");
-    let source_config = reduction.extract_solution(&target_witness);
-    let val = source.evaluate(&source_config);
+    let solver = ILPSolver::new();
+    let target_witness = solver.solve(target).expect("ILP should be feasible");
+    let source_config = reduction.extract_solution(&target_witness).unwrap();
+    let val = source.evaluate(&source_config).unwrap();
     assert!(val.0.is_some());
     // Verify against brute force
-    let bf_val = BruteForce::new().solve(&source);
+    let bf_val_solution = BruteForce::new().solve(&source).unwrap().unwrap();
+    let bf_val = source.evaluate(&bf_val_solution).unwrap();
     assert_eq!(val, bf_val);
 }
 
 #[test]
 fn test_imdc_to_ilp_empty_string() {
     let source = MinimumInternalMacroDataCompression::new(2, vec![], 2);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
     assert_eq!(target.num_variables(), 0);
-    let source_config = reduction.extract_solution(&[]);
-    assert_eq!(source.evaluate(&source_config), Min(Some(0)));
+    let source_config = reduction.extract_solution(&vec![]).unwrap();
+    assert_eq!(source.evaluate(&source_config).unwrap(), Min(Some(0)));
 }
 
 #[test]
@@ -71,25 +72,27 @@ fn test_imdc_to_ilp_single_char() {
     // s = "a", alphabet {a}, h=2
     // Only valid: literal, cost=1
     let source = MinimumInternalMacroDataCompression::new(1, vec![0], 2);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let solver = BruteForce::new();
-    let target_witness = solver.find_witness(target).expect("ILP should be feasible");
-    let source_config = reduction.extract_solution(&target_witness);
-    assert_eq!(source.evaluate(&source_config), Min(Some(1)));
+    let solver = ILPSolver::new();
+    let target_witness = solver.solve(target).expect("ILP should be feasible");
+    let source_config = reduction.extract_solution(&target_witness).unwrap();
+    assert_eq!(source.evaluate(&source_config).unwrap(), Min(Some(1)));
 }
 
 #[test]
 fn test_imdc_to_ilp_structure() {
     // Verify the ILP has the right number of variables
     let source = MinimumInternalMacroDataCompression::new(2, vec![0, 1, 0, 1], 2);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
     // n=4 literals + valid ptr triples
     assert!(target.num_variables() >= 4);
     // Must be a minimization problem
-    assert_eq!(target.dims(), vec![2; target.num_variables()]);
+    assert!(target.variables().iter().all(|variable| {
+        variable.lower_bound() == Some(0) && variable.upper_bound() == Some(1)
+    }));
 }
 
 #[test]
@@ -101,15 +104,17 @@ fn test_imdc_to_ilp_vs_brute_force() {
         (2, vec![0, 0, 1, 1], 1),
     ] {
         let source = MinimumInternalMacroDataCompression::new(k, s.clone(), h);
-        let bf_val = BruteForce::new().solve(&source);
+        let bf_val_solution = BruteForce::new().solve(&source).unwrap().unwrap();
+        let bf_val = source.evaluate(&bf_val_solution).unwrap();
 
-        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+        let reduction =
+            ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
         let target = reduction.target_problem();
-        let target_witness = BruteForce::new()
-            .find_witness(target)
+        let target_witness = ILPSolver::new()
+            .solve(target)
             .expect("ILP should be feasible");
-        let source_config = reduction.extract_solution(&target_witness);
-        let ilp_val = source.evaluate(&source_config);
+        let source_config = reduction.extract_solution(&target_witness).unwrap();
+        let ilp_val = source.evaluate(&source_config).unwrap();
 
         assert_eq!(
             ilp_val, bf_val,
diff --git a/src/unit_tests/rules/minimummatrixcover_ilp.rs b/src/unit_tests/rules/minimummatrixcover_ilp.rs
index 420f2102e..da371feef 100644
--- a/src/unit_tests/rules/minimummatrixcover_ilp.rs
+++ b/src/unit_tests/rules/minimummatrixcover_ilp.rs
@@ -1,8 +1,8 @@
 use super::*;
 use crate::models::algebraic::MinimumMatrixCover;
 use crate::models::algebraic::{ObjectiveSense, ILP};
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
-use crate::solvers::{BruteForce, ILPSolver, Solver};
+use crate::rules::test_helpers::assert_bf_vs_ilp;
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -14,41 +14,37 @@ fn test_minimum_matrix_cover_to_ilp_closed_loop() {
         vec![1, 0, 0, 4],
         vec![0, 2, 4, 0],
     ]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_optimization_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "MinimumMatrixCover->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert_eq!(value, Min(Some(-20)));
 }
 
 #[test]
 fn test_minimum_matrix_cover_to_ilp_structure() {
     let problem = MinimumMatrixCover::new(vec![vec![0, 3], vec![2, 0]]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=2: 2 sign vars + 1 auxiliary = 3 vars
-    assert_eq!(ilp.num_vars, 3);
+    assert_eq!(ilp.num_vars(), 3);
     // 3 constraints per pair, 1 pair
-    assert_eq!(ilp.constraints.len(), 3);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.constraints().len(), 3);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
     // y_{01} coefficient: 4*(a_01 + a_10) = 4*(3+2) = 20
     // x_0 coefficient: -2*(a_01+a_10) = -2*(3+2) = -10
     // x_1 coefficient: -2*(a_10+a_01) = -2*(2+3) = -10
-    let obj_map: std::collections::HashMap<usize, f64> = ilp.objective.iter().copied().collect();
-    assert_eq!(*obj_map.get(&0).unwrap_or(&0.0), -10.0);
-    assert_eq!(*obj_map.get(&1).unwrap_or(&0.0), -10.0);
-    assert_eq!(*obj_map.get(&2).unwrap_or(&0.0), 20.0);
+    let obj_map: std::collections::HashMap<usize, i64> = ilp.objective().iter().copied().collect();
+    assert_eq!(*obj_map.get(&0).unwrap_or(&0), -10);
+    assert_eq!(*obj_map.get(&1).unwrap_or(&0), -10);
+    assert_eq!(*obj_map.get(&2).unwrap_or(&0), 20);
 }
 
 #[test]
@@ -59,15 +55,17 @@ fn test_minimum_matrix_cover_to_ilp_bf_vs_ilp() {
         vec![1, 0, 0, 4],
         vec![0, 2, 4, 0],
     ]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
+
+    let bf_value_solution = BruteForce::new().solve(&problem).unwrap().unwrap();
 
-    let bf_value = BruteForce::new().solve(&problem);
+    let bf_value = problem.evaluate(&bf_value_solution).unwrap();
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
 }
@@ -75,13 +73,13 @@ fn test_minimum_matrix_cover_to_ilp_bf_vs_ilp() {
 #[test]
 fn test_minimum_matrix_cover_to_ilp_2x2() {
     let problem = MinimumMatrixCover::new(vec![vec![0, 3], vec![2, 0]]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     // Optimal: different signs → value = -(3+2) = -5
     assert_eq!(value, Min(Some(-5)));
 }
@@ -89,12 +87,12 @@ fn test_minimum_matrix_cover_to_ilp_2x2() {
 #[test]
 fn test_minimum_matrix_cover_to_ilp_1x1() {
     let problem = MinimumMatrixCover::new(vec![vec![5]]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 1 variable, 0 pairs → 0 auxiliaries
-    assert_eq!(ilp.num_vars, 1);
-    assert_eq!(ilp.constraints.len(), 0);
+    assert_eq!(ilp.num_vars(), 1);
+    assert_eq!(ilp.constraints().len(), 0);
 
     // For 1×1, f(1)²=1, value = 5 regardless. Objective should be constant (no x terms).
     // x_0 coefficient: -2*Σ_{j≠0} (a_0j+a_j0) = 0 (no off-diagonal)
@@ -102,8 +100,8 @@ fn test_minimum_matrix_cover_to_ilp_1x1() {
     let ilp_solution = ILPSolver::new()
         .solve(ilp)
         .expect("1x1 ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(5)));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(5)));
 }
 
 #[test]
@@ -111,29 +109,31 @@ fn test_minimum_matrix_cover_to_ilp_diagonal_matrix() {
     // Diagonal matrix: all off-diagonal entries are 0
     // Value is always Σ a_ii (constant), since f(i)²=1
     let problem = MinimumMatrixCover::new(vec![vec![2, 0, 0], vec![0, 3, 0], vec![0, 0, 1]]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("diagonal ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     // All configs give value 2+3+1 = 6
-    assert_eq!(problem.evaluate(&extracted), Min(Some(6)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(6)));
 }
 
 #[test]
 fn test_minimum_matrix_cover_to_ilp_asymmetric() {
     // Non-symmetric matrix
     let problem = MinimumMatrixCover::new(vec![vec![0, 5], vec![1, 0]]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
+
+    let bf_value_solution = BruteForce::new().solve(&problem).unwrap().unwrap();
 
-    let bf_value = BruteForce::new().solve(&problem);
+    let bf_value = problem.evaluate(&bf_value_solution).unwrap();
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     // Different signs: -(5+1) = -6, same signs: +(5+1) = 6
@@ -155,5 +155,11 @@ fn test_minimum_matrix_cover_to_ilp_canonical_example_spec() {
         example.source.instance["matrix"].as_array().unwrap().len(),
         2
     );
-    assert_eq!(example.target.instance["num_vars"], 3);
+    assert_eq!(
+        example.target.instance["variables"]
+            .as_array()
+            .unwrap()
+            .len(),
+        3
+    );
 }
diff --git a/src/unit_tests/rules/minimummaximalmatching_ilp.rs b/src/unit_tests/rules/minimummaximalmatching_ilp.rs
index 278244d39..342a422fd 100644
--- a/src/unit_tests/rules/minimummaximalmatching_ilp.rs
+++ b/src/unit_tests/rules/minimummaximalmatching_ilp.rs
@@ -8,38 +8,40 @@ use crate::types::Min;
 fn test_reduction_creates_valid_ilp() {
     // Path P4: 4 vertices, 3 edges
     let problem = MinimumMaximalMatching::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction: ReductionMMMToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMMToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // num_vars = num_edges = 3
-    assert_eq!(ilp.num_vars, 3, "Should have one variable per edge");
+    assert_eq!(ilp.num_vars(), 3, "Should have one variable per edge");
     // num_constraints = num_vertices (with degree >= 1) + num_edges
     // Vertices 0,1,2,3 all have degree >= 1 → 4 matching constraints + 3 maximality constraints
-    assert_eq!(ilp.constraints.len(), 7);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize");
+    assert_eq!(ilp.constraints().len(), 7);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize, "Should minimize");
 }
 
 #[test]
 fn test_minimummaximalmatching_to_ilp_closed_loop() {
     // Path P4: optimal minimum maximal matching = 1 edge (center edge (1,2)).
     let problem = MinimumMaximalMatching::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction: ReductionMMMToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMMToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solution = bf.find_witness(&problem).unwrap();
-    let bf_value = problem.evaluate(&bf_solution);
+    let bf_solution = bf.solve(&problem).unwrap().unwrap();
+    let bf_value = problem.evaluate(&bf_solution).unwrap();
 
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, Min(Some(1)));
     assert_eq!(ilp_value, Min(Some(1)));
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
@@ -49,31 +51,33 @@ fn test_minimummaximalmatching_to_ilp_path_p6() {
         6,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
     ));
-    let reduction: ReductionMMMToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMMToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), Min(Some(2)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_minimummaximalmatching_to_ilp_triangle() {
     // Triangle: optimal = 1 (any single edge is maximal).
     let problem = MinimumMaximalMatching::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]));
-    let reduction: ReductionMMMToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMMToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
@@ -82,18 +86,20 @@ fn test_minimummaximalmatching_to_ilp_bf_vs_ilp() {
         6,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
     ));
-    let reduction: ReductionMMMToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMMToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_empty_graph() {
     let problem = MinimumMaximalMatching::new(SimpleGraph::new(3, vec![]));
-    let reduction: ReductionMMMToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMMToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 0);
-    assert_eq!(ilp.constraints.len(), 0);
-    assert!(problem.evaluate(&[]).is_valid());
-    assert_eq!(problem.evaluate(&[]), Min(Some(0)));
+    assert_eq!(ilp.num_vars(), 0);
+    assert_eq!(ilp.constraints().len(), 0);
+    assert!(problem.evaluate(&vec![]).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&vec![]).unwrap(), Min(Some(0)));
 }
diff --git a/src/unit_tests/rules/minimummaximalmatching_maximumachromaticnumber.rs b/src/unit_tests/rules/minimummaximalmatching_maximumachromaticnumber.rs
index baf7ca2c1..3a7f521c6 100644
--- a/src/unit_tests/rules/minimummaximalmatching_maximumachromaticnumber.rs
+++ b/src/unit_tests/rules/minimummaximalmatching_maximumachromaticnumber.rs
@@ -1,6 +1,6 @@
 use crate::models::graph::{MaximumAchromaticNumber, MinimumMaximalMatching};
 use crate::rules::traits::{ReduceTo, ReductionResult};
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::topology::{BipartiteGraph, Graph, SimpleGraph};
 use crate::traits::Problem;
 use crate::types::{Max, Min};
@@ -22,7 +22,8 @@ fn t_tree_bipartite() -> BipartiteGraph {
 #[test]
 fn test_minimummaximalmatching_to_maximumachromaticnumber_closed_loop() {
     let source = MinimumMaximalMatching::new(t_tree_bipartite());
-    let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // |V| = 5, |E(G)| = 4, so |E(H)| = C(5,2) - 4 = 10 - 4 = 6
@@ -33,22 +34,32 @@ fn test_minimummaximalmatching_to_maximumachromaticnumber_closed_loop() {
 
     // Source MMM(T-tree) = 1 (the central edge (v1, v2) is a minimum maximal
     // matching on its own).
-    assert_eq!(solver.solve(&source), Min(Some(1)));
+    assert_eq!(
+        source
+            .evaluate(&solver.solve(&source).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(1))
+    );
 
     // Target achromatic number of complement(G) = |V| - mm(G) = 5 - 1 = 4.
-    assert_eq!(solver.solve(target), Max(Some(4)));
+    assert_eq!(
+        target
+            .evaluate(&solver.solve(target).unwrap().unwrap())
+            .unwrap(),
+        Max(Some(4))
+    );
 
     // Closed-loop: every optimal target witness extracts to a valid maximal
     // matching with size mm(G).
-    let target_witnesses = solver.find_all_witnesses(target);
+    let target_witnesses = solver.find_all_witnesses(target).unwrap();
     assert!(
         !target_witnesses.is_empty(),
         "complement(T-tree) must admit an achromatic 4-coloring"
     );
     for witness in &target_witnesses {
-        let extracted = reduction.extract_solution(witness);
+        let extracted = reduction.extract_solution(witness).unwrap();
         assert_eq!(
-            source.evaluate(&extracted),
+            source.evaluate(&extracted).unwrap(),
             Min(Some(1)),
             "extracted matching must be maximal of size 1"
         );
@@ -58,7 +69,8 @@ fn test_minimummaximalmatching_to_maximumachromaticnumber_closed_loop() {
 #[test]
 fn test_target_complement_structure() {
     let source = MinimumMaximalMatching::new(t_tree_bipartite());
-    let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Source unified edges: (0,3), (1,3), (1,4), (2,3).
@@ -74,16 +86,17 @@ fn test_target_complement_structure() {
 #[test]
 fn test_extract_solution_known_coloring() {
     let source = MinimumMaximalMatching::new(t_tree_bipartite());
-    let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     // Canonical 4-coloring of complement(G) (unified order v0,v2,v4,v1,v3):
     //   v0 -> 1, v2 -> 0, v4 -> 3, v1 -> 0, v3 -> 2.
     // The single size-2 class {v2, v1} is the G-edge (v1, v2) =
     // unified edge (1, 3), source-edge index 1 in the edges list.
     let coloring = vec![1, 0, 3, 0, 2];
-    let extracted = reduction.extract_solution(&coloring);
-    assert_eq!(extracted, vec![0, 1, 0, 0]);
-    assert_eq!(source.evaluate(&extracted), Min(Some(1)));
+    let extracted = reduction.extract_solution(&coloring).unwrap();
+    assert_eq!(extracted, vec![false, true, false, false]);
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -93,7 +106,8 @@ fn test_extract_solution_recovers_suboptimal_matchings() {
     // example. We feed the achromatic colorings induced by these size-2
     // maximal matchings and check the extractor recovers each one.
     let source = MinimumMaximalMatching::new(t_tree_bipartite());
-    let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     // Unified labels: v0=0, v2=1, v4=2, v1=3, v3=4.
     // Suboptimal matching {(v0,v1), (v2,v3)} -> color v0,v1 the same and
@@ -101,16 +115,16 @@ fn test_extract_solution_recovers_suboptimal_matchings() {
     // Source edges in unified order: (0,3), (1,3), (1,4), (2,3).
     // Edge 0 = (v0, v1) selected; edge 2 = (v2, v3) selected.
     let coloring_a = vec![0, 1, 2, 0, 1];
-    let extracted_a = reduction.extract_solution(&coloring_a);
-    assert_eq!(extracted_a, vec![1, 0, 1, 0]);
-    assert_eq!(source.evaluate(&extracted_a), Min(Some(2)));
+    let extracted_a = reduction.extract_solution(&coloring_a).unwrap();
+    assert_eq!(extracted_a, vec![true, false, true, false]);
+    assert_eq!(source.evaluate(&extracted_a).unwrap(), Min(Some(2)));
 
     // Suboptimal matching {(v1, v4), (v2, v3)} -> pair v1 with v4 and v2
     // with v3; v0 takes a singleton color. Edge 2 = (v2, v3); edge 3 = (v1, v4).
     let coloring_b = vec![2, 0, 1, 1, 0];
-    let extracted_b = reduction.extract_solution(&coloring_b);
-    assert_eq!(extracted_b, vec![0, 0, 1, 1]);
-    assert_eq!(source.evaluate(&extracted_b), Min(Some(2)));
+    let extracted_b = reduction.extract_solution(&coloring_b).unwrap();
+    assert_eq!(extracted_b, vec![false, false, true, true]);
+    assert_eq!(source.evaluate(&extracted_b).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -132,16 +146,23 @@ fn test_identity_on_random_bipartite_instances() {
     for graph in instances {
         let n = graph.num_vertices();
         let source = MinimumMaximalMatching::new(graph);
-        let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source);
+        let reduction = ReduceTo::<MaximumAchromaticNumber<SimpleGraph>>::reduce_to(&source)
+            .expect("reduction should succeed");
         let target = reduction.target_problem();
 
-        let Min(Some(mm)) = solver.solve(&source) else {
+        let source_solution = solver.solve(&source).unwrap().unwrap();
+        let Min(Some(mm)) = source.evaluate(&source_solution).unwrap() else {
             panic!("MinimumMaximalMatching always has a feasible optimum");
         };
-        let Max(Some(ach)) = solver.solve(target) else {
+        let target_solution = solver.solve(target).unwrap().unwrap();
+        let Max(Some(ach)) = target.evaluate(&target_solution).unwrap() else {
             panic!("MaximumAchromaticNumber always has a feasible optimum");
         };
 
-        assert_eq!(ach + mm, n, "ach(complement(G)) + mm(G) must equal |V|");
+        assert_eq!(
+            ach + mm,
+            i64::try_from(n).unwrap(),
+            "ach(complement(G)) + mm(G) must equal |V|"
+        );
     }
 }
diff --git a/src/unit_tests/rules/minimummaximalmatching_minimummatrixdomination.rs b/src/unit_tests/rules/minimummaximalmatching_minimummatrixdomination.rs
index ccc6598e9..9d0a6ab52 100644
--- a/src/unit_tests/rules/minimummaximalmatching_minimummatrixdomination.rs
+++ b/src/unit_tests/rules/minimummaximalmatching_minimummatrixdomination.rs
@@ -1,7 +1,7 @@
 use crate::models::algebraic::MinimumMatrixDomination;
 use crate::models::graph::MinimumMaximalMatching;
 use crate::rules::traits::{ReduceTo, ReductionResult};
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::topology::{BipartiteGraph, Graph};
 use crate::traits::Problem;
 use crate::types::Min;
@@ -26,7 +26,8 @@ fn no_bipartite() -> BipartiteGraph {
 #[test]
 fn test_minimummaximalmatching_to_minimummatrixdomination_closed_loop() {
     let source = MinimumMaximalMatching::new(yes_bipartite());
-    let reduction = ReduceTo::<MinimumMatrixDomination>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumMatrixDomination>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // N = m + n = 2 + 3 = 5; |1-entries| = |F| = 5.
@@ -37,22 +38,32 @@ fn test_minimummaximalmatching_to_minimummatrixdomination_closed_loop() {
     let solver = BruteForce::new();
 
     // Source mmm(B) = 2 on this bipartite graph (two-edge maximal matching).
-    assert_eq!(solver.solve(&source), Min(Some(2)));
+    assert_eq!(
+        source
+            .evaluate(&solver.solve(&source).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(2))
+    );
 
     // Target minimum matrix domination = 2 by the Yannakakis-Gavril identity.
-    assert_eq!(solver.solve(target), Min(Some(2)));
+    assert_eq!(
+        target
+            .evaluate(&solver.solve(target).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(2))
+    );
 
     // Closed-loop: every optimal target witness must extract to a valid
     // maximal matching of size mm(B) = 2.
-    let target_witnesses = solver.find_all_witnesses(target);
+    let target_witnesses = solver.find_all_witnesses(target).unwrap();
     assert!(
         !target_witnesses.is_empty(),
         "matrix domination has at least one optimum"
     );
     for witness in &target_witnesses {
-        let extracted = reduction.extract_solution(witness);
+        let extracted = reduction.extract_solution(witness).unwrap();
         assert_eq!(
-            source.evaluate(&extracted),
+            source.evaluate(&extracted).unwrap(),
             Min(Some(2)),
             "extracted matching must be maximal of size 2"
         );
@@ -62,7 +73,8 @@ fn test_minimummaximalmatching_to_minimummatrixdomination_closed_loop() {
 #[test]
 fn test_target_matrix_structure() {
     let source = MinimumMaximalMatching::new(yes_bipartite());
-    let reduction = ReduceTo::<MinimumMatrixDomination>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumMatrixDomination>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Upper-right m x n block is B*. m = 2, n = 3, so 1-entries should be
@@ -93,19 +105,21 @@ fn test_extract_solution_returns_maximal_matching() {
     // Verify that for an arbitrary optimal target witness, extract_solution
     // returns some maximal matching whose value matches mm(B).
     let source = MinimumMaximalMatching::new(yes_bipartite());
-    let reduction = ReduceTo::<MinimumMatrixDomination>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumMatrixDomination>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
     let target_witness = solver
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("matrix domination has an optimum");
-    let extracted = reduction.extract_solution(&target_witness);
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
 
     // The result must be a valid maximal matching of the source graph and
     // realize mm(B) = 2.
     assert!(source.is_valid_maximal_matching(&extracted));
-    let size: usize = extracted.iter().sum();
+    let size: usize = extracted.iter().filter(|&&selected| selected).count();
     assert_eq!(size, 2);
 }
 
@@ -116,16 +130,28 @@ fn test_no_instance_unreachable_threshold() {
     // has 3 pairwise non-attacking 1-entries (different rows and different
     // columns), so its minimum matrix domination is also 3.
     let source = MinimumMaximalMatching::new(no_bipartite());
-    let reduction = ReduceTo::<MinimumMatrixDomination>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumMatrixDomination>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(&source), Min(Some(3)));
-    assert_eq!(solver.solve(target), Min(Some(3)));
+    assert_eq!(
+        source
+            .evaluate(&solver.solve(&source).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(3))
+    );
+    assert_eq!(
+        target
+            .evaluate(&solver.solve(target).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(3))
+    );
 
     // The target value never drops below the source value: in particular, no
     // matrix-domination subset of size 2 exists.
-    let target_value = solver.solve(target);
+    let target_solution = solver.solve(target).unwrap().unwrap();
+    let target_value = target.evaluate(&target_solution).unwrap();
     if let Min(Some(value)) = target_value {
         assert!(value > 2, "matrix domination value must exceed 2");
     } else {
@@ -152,18 +178,19 @@ fn test_extract_solution_yg_transform_on_non_matching_eds() {
     // maximal matching of size <= 2, e.g. {(l0, r0), (l1, r1)} or
     // {(l0, r1), (l1, r2)}.
     let source = MinimumMaximalMatching::new(yes_bipartite());
-    let reduction = ReduceTo::<MinimumMatrixDomination>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumMatrixDomination>::reduce_to(&source).expect("reduction should succeed");
 
     // Construct the non-matching EDS witness explicitly. ones() ordering on
     // this instance is [(0,2),(0,3),(0,4),(1,3),(1,4)]; indices 1 and 2
     // pick (0,3) = source edge (l0, r1) and (0,4) = source edge (l0, r2).
-    let target_witness = vec![0, 1, 1, 0, 0];
+    let target_witness = vec![false, true, true, false, false];
 
     // Sanity-check: this is actually a feasible MMD witness on the target.
     let target = reduction.target_problem();
-    assert_eq!(target.evaluate(&target_witness), Min(Some(2)));
+    assert_eq!(target.evaluate(&target_witness).unwrap(), Min(Some(2)));
 
-    let extracted = reduction.extract_solution(&target_witness);
+    let extracted = reduction.extract_solution(&target_witness).unwrap();
 
     // The extracted configuration must be a valid maximal matching of B of
     // size 2 (= mm(B)). Crucially it cannot be {(l0, r1), (l0, r2)} because
@@ -172,16 +199,16 @@ fn test_extract_solution_yg_transform_on_non_matching_eds() {
         source.is_valid_maximal_matching(&extracted),
         "YG transform must produce a maximal matching, got {extracted:?}"
     );
-    let size: usize = extracted.iter().sum();
+    let size: usize = extracted.iter().filter(|&&selected| selected).count();
     assert_eq!(
         size, 2,
         "extracted matching must have size mm(B) = 2, got size {size}"
     );
     assert!(
-        !(extracted[1] == 1 && extracted[2] == 1),
+        !(extracted[1] && extracted[2]),
         "transform must break the (l0,r1)-(l0,r2) adjacency"
     );
-    assert_eq!(source.evaluate(&extracted), Min(Some(2)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -206,7 +233,8 @@ fn test_identity_on_random_bipartite_instances() {
         let n_right = graph.right_size();
         let num_edges = graph.num_edges();
         let source = MinimumMaximalMatching::new(graph);
-        let reduction = ReduceTo::<MinimumMatrixDomination>::reduce_to(&source);
+        let reduction = ReduceTo::<MinimumMatrixDomination>::reduce_to(&source)
+            .expect("reduction should succeed");
         let target = reduction.target_problem();
 
         // Structural checks: the matrix is square of side m + n and has |F|
@@ -215,10 +243,12 @@ fn test_identity_on_random_bipartite_instances() {
         assert_eq!(target.num_cols(), m_left + n_right);
         assert_eq!(target.num_ones(), num_edges);
 
-        let Min(Some(mm)) = solver.solve(&source) else {
+        let source_solution = solver.solve(&source).unwrap().unwrap();
+        let Min(Some(mm)) = source.evaluate(&source_solution).unwrap() else {
             panic!("MinimumMaximalMatching always has a feasible optimum");
         };
-        let Min(Some(md)) = solver.solve(target) else {
+        let target_solution = solver.solve(target).unwrap().unwrap();
+        let Min(Some(md)) = target.evaluate(&target_solution).unwrap() else {
             panic!("MinimumMatrixDomination always has a feasible optimum");
         };
 
diff --git a/src/unit_tests/rules/minimummetricdimension_ilp.rs b/src/unit_tests/rules/minimummetricdimension_ilp.rs
index c19068eae..431e64235 100644
--- a/src/unit_tests/rules/minimummetricdimension_ilp.rs
+++ b/src/unit_tests/rules/minimummetricdimension_ilp.rs
@@ -10,20 +10,21 @@ fn test_minimummetricdimension_to_ilp_closed_loop() {
         5,
         vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)],
     ));
-    let reduction: ReductionMDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve with brute force on original problem
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_size = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_size = problem.evaluate(&bf_solutions[0]).unwrap();
 
     // Solve via ILP reduction
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_size = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_size = problem.evaluate(&extracted).unwrap();
 
     // Both should find optimal size = 2
     assert_eq!(bf_size, Min(Some(2)));
@@ -31,7 +32,7 @@ fn test_minimummetricdimension_to_ilp_closed_loop() {
 
     // Verify the ILP solution is valid for the original problem
     assert!(
-        problem.evaluate(&extracted).is_valid(),
+        problem.evaluate(&extracted).unwrap().is_valid(),
         "Extracted solution should be valid"
     );
 }
@@ -40,23 +41,24 @@ fn test_minimummetricdimension_to_ilp_closed_loop() {
 fn test_minimummetricdimension_to_ilp_structure() {
     // Path graph P3: 3 vertices
     let problem = MinimumMetricDimension::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction: ReductionMDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check ILP structure
-    assert_eq!(ilp.num_vars, 3, "Should have one variable per vertex");
+    assert_eq!(ilp.num_vars(), 3, "Should have one variable per vertex");
     // C(3,2) = 3 pairs
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         3,
         "Should have one constraint per vertex pair"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize");
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize, "Should minimize");
 
     // Each constraint should have rhs = 1
-    for constraint in &ilp.constraints {
-        assert!(!constraint.terms.is_empty());
-        assert!((constraint.rhs - 1.0).abs() < 1e-9);
+    for constraint in ilp.constraints() {
+        assert!(!constraint.terms().is_empty());
+        assert_eq!(constraint.rhs(), 1);
     }
 }
 
@@ -67,7 +69,8 @@ fn test_minimummetricdimension_to_ilp_bf_vs_ilp() {
         5,
         vec![(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4)],
     ));
-    let reduction: ReductionMDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
@@ -75,15 +78,16 @@ fn test_minimummetricdimension_to_ilp_bf_vs_ilp() {
 fn test_minimummetricdimension_to_ilp_path_graph() {
     // Path P4: 0-1-2-3, metric dimension = 1 (any endpoint resolves)
     let problem = MinimumMetricDimension::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction: ReductionMDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -93,18 +97,19 @@ fn test_minimummetricdimension_to_ilp_complete_graph() {
         4,
         vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)],
     ));
-    let reduction: ReductionMDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_size = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_size = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_size = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_size = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_size, Min(Some(3)));
     assert_eq!(ilp_size, Min(Some(3)));
@@ -113,15 +118,16 @@ fn test_minimummetricdimension_to_ilp_complete_graph() {
 #[test]
 fn test_minimummetricdimension_to_ilp_solution_extraction() {
     let problem = MinimumMetricDimension::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction: ReductionMDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Test that extraction works correctly (1:1 mapping)
     let ilp_solution = vec![1, 0, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![1, 0, 0]);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![true, false, false]);
 
     // Verify this is a valid resolving set
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
@@ -131,13 +137,14 @@ fn test_minimummetricdimension_to_ilp_cycle() {
         5,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)],
     ));
-    let reduction: ReductionMDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Min(Some(2)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(2)));
 }
diff --git a/src/unit_tests/rules/minimummultiwaycut_ilp.rs b/src/unit_tests/rules/minimummultiwaycut_ilp.rs
index 99260a2ab..95d63b69d 100644
--- a/src/unit_tests/rules/minimummultiwaycut_ilp.rs
+++ b/src/unit_tests/rules/minimummultiwaycut_ilp.rs
@@ -6,7 +6,7 @@ use crate::traits::Problem;
 use crate::types::Min;
 
 /// Build the canonical 5-vertex, 3-terminal example from issue #185.
-fn canonical_instance() -> MinimumMultiwayCut<SimpleGraph, i32> {
+fn canonical_instance() -> MinimumMultiwayCut<SimpleGraph, i64> {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (1, 3)]);
     MinimumMultiwayCut::new(graph, vec![0, 2, 4], vec![2, 3, 1, 2, 4, 5])
 }
@@ -14,36 +14,38 @@ fn canonical_instance() -> MinimumMultiwayCut<SimpleGraph, i32> {
 #[test]
 fn test_reduction_creates_valid_ilp() {
     let problem = canonical_instance();
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let k = 3;
     let n = 5;
     let m = 6;
     // kn + m = 21 variables
-    assert_eq!(ilp.num_vars, k * n + m);
+    assert_eq!(ilp.num_vars(), k * n + m);
     // n + 2km + k^2 = 5 + 36 + 9 = 50 constraints
-    assert_eq!(ilp.constraints.len(), n + 2 * k * m + k * k);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.constraints().len(), n + 2 * k * m + k * k);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_minimummultiwaycut_to_ilp_closed_loop() {
     let problem = canonical_instance();
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve original with brute force
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_obj = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_obj = problem.evaluate(&bf_solutions[0]).unwrap();
 
     // Solve via ILP
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_obj = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_obj = problem.evaluate(&extracted).unwrap();
 
     // Optimal cut cost is 8
     assert_eq!(bf_obj, Min(Some(8)));
@@ -58,14 +60,15 @@ fn test_triangle_with_3_terminals() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
     let problem = MinimumMultiwayCut::new(graph, vec![0, 1, 2], vec![1, 2, 3]);
 
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let obj = problem.evaluate(&extracted);
+    let obj = problem.evaluate(&extracted).unwrap();
     assert_eq!(obj, Min(Some(6)));
 }
 
@@ -76,21 +79,23 @@ fn test_two_terminals() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = MinimumMultiwayCut::new(graph, vec![0, 2], vec![1, 2]);
 
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let obj = problem.evaluate(&extracted);
+    let obj = problem.evaluate(&extracted).unwrap();
     assert_eq!(obj, Min(Some(1)));
 }
 
 #[test]
 fn test_solution_extraction() {
     let problem = canonical_instance();
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let k = 3;
     let n = 5;
@@ -100,7 +105,7 @@ fn test_solution_extraction() {
     // Manually construct an ILP solution representing the optimal partition:
     // V_0 = {0}, V_1 = {1, 2, 3}, V_2 = {4}
     // Cut edges: (0,1)=idx 0, (3,4)=idx 3, (0,4)=idx 4
-    let mut ilp_solution = vec![0usize; num_vars];
+    let mut ilp_solution = vec![0_i64; num_vars];
 
     // y_{0,v}: component 0 assignments (indices 0..5)
     ilp_solution[0] = 1; // y_{0,0} = 1 (vertex 0 in component 0)
@@ -118,29 +123,30 @@ fn test_solution_extraction() {
     ilp_solution[15 + 3] = 1; // edge (3,4) cut
     ilp_solution[15 + 4] = 1; // edge (0,4) cut
 
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![1, 0, 0, 1, 1, 0]);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![true, false, false, true, true, false]);
 
-    let obj = problem.evaluate(&extracted);
+    let obj = problem.evaluate(&extracted).unwrap();
     assert_eq!(obj, Min(Some(8)));
 }
 
 #[test]
-fn test_solve_reduced() {
+fn test_solve_via_ilp_pipeline() {
     let problem = canonical_instance();
 
     let ilp_solver = ILPSolver::new();
     let solution = ilp_solver
-        .solve_reduced(&problem)
-        .expect("solve_reduced should work");
+        .solve(&problem)
+        .expect("ILP pipeline should solve the problem");
 
-    assert!(problem.evaluate(&solution).is_valid());
-    assert_eq!(problem.evaluate(&solution), Min(Some(8)));
+    assert!(problem.evaluate(&solution).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(8)));
 }
 
 #[test]
 fn test_minimummultiwaycut_to_ilp_bf_vs_ilp() {
     let problem = canonical_instance();
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/minimummultiwaycut_qubo.rs b/src/unit_tests/rules/minimummultiwaycut_qubo.rs
index 4b42b97c7..b300fa285 100644
--- a/src/unit_tests/rules/minimummultiwaycut_qubo.rs
+++ b/src/unit_tests/rules/minimummultiwaycut_qubo.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -9,18 +10,18 @@ fn test_minimummultiwaycut_to_qubo_closed_loop() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (1, 3)]);
     let source = MinimumMultiwayCut::new(graph, vec![0, 2, 4], vec![2, 3, 1, 2, 4, 5]);
 
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     assert!(!qubo_solutions.is_empty(), "QUBO solver found no solutions");
 
     // All QUBO optimal solutions should extract to valid source solutions with cost 8
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        let metric = source.evaluate(&extracted);
+        let extracted = reduction.extract_solution(sol).unwrap();
+        let metric = source.evaluate(&extracted).unwrap();
         assert_eq!(metric, Min(Some(8)));
     }
 }
@@ -31,18 +32,18 @@ fn test_minimummultiwaycut_to_qubo_small() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let source = MinimumMultiwayCut::new(graph, vec![0, 2], vec![1, 1]);
 
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     assert!(!qubo_solutions.is_empty(), "QUBO solver found no solutions");
 
     // All solutions should extract to valid cuts
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        let metric = source.evaluate(&extracted);
+        let extracted = reduction.extract_solution(sol).unwrap();
+        let metric = source.evaluate(&extracted).unwrap();
         // With 2 terminals and path 0-1-2, minimum cut is 1 (cut either edge)
         assert_eq!(metric, Min(Some(1)));
     }
@@ -54,7 +55,7 @@ fn test_minimummultiwaycut_to_qubo_sizes() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (1, 3)]);
     let source = MinimumMultiwayCut::new(graph, vec![0, 2, 4], vec![2, 3, 1, 2, 4, 5]);
 
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
     assert_eq!(reduction.target_problem().num_variables(), 15);
 }
 
@@ -66,30 +67,28 @@ fn test_minimummultiwaycut_to_qubo_terminal_pinning() {
     let terminals = vec![0, 2, 4];
     let source = MinimumMultiwayCut::new(graph, terminals.clone(), vec![2, 3, 1, 2, 4, 5]);
 
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     let k = terminals.len();
     for sol in &qubo_solutions {
         for (t_pos, &t_vertex) in terminals.iter().enumerate() {
             // Terminal vertex should be assigned to its own position
-            assert_eq!(
+            assert!(
                 sol[t_vertex * k + t_pos],
-                1,
-                "Terminal {} at position {} should be 1",
+                "Terminal {} at position {} should be true",
                 t_vertex,
                 t_pos
             );
             // And not assigned to any other position
             for s in 0..k {
                 if s != t_pos {
-                    assert_eq!(
-                        sol[t_vertex * k + s],
-                        0,
-                        "Terminal {} at position {} should be 0",
+                    assert!(
+                        !sol[t_vertex * k + s],
+                        "Terminal {} at position {} should be false",
                         t_vertex,
                         s
                     );
diff --git a/src/unit_tests/rules/minimumsetcovering_ilp.rs b/src/unit_tests/rules/minimumsetcovering_ilp.rs
index cd16428a2..ab5a48864 100644
--- a/src/unit_tests/rules/minimumsetcovering_ilp.rs
+++ b/src/unit_tests/rules/minimumsetcovering_ilp.rs
@@ -6,67 +6,69 @@ use crate::types::Min;
 #[test]
 fn test_reduction_creates_valid_ilp() {
     // Universe: {0, 1, 2}, Sets: S0={0,1}, S1={1,2}
-    let problem = MinimumSetCovering::<i32>::new(3, vec![vec![0, 1], vec![1, 2]]);
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MinimumSetCovering::new(3, vec![vec![0, 1], vec![1, 2]]);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check ILP structure
-    assert_eq!(ilp.num_vars, 2, "Should have one variable per set");
+    assert_eq!(ilp.num_vars(), 2, "Should have one variable per set");
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         3,
         "Should have one constraint per element"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize");
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize, "Should minimize");
 
     // Each constraint should be sum >= 1
-    for constraint in &ilp.constraints {
-        assert!((constraint.rhs - 1.0).abs() < 1e-9);
+    for constraint in ilp.constraints() {
+        assert_eq!(constraint.rhs(), 1);
     }
 }
 
 #[test]
 fn test_reduction_weighted() {
     let problem = MinimumSetCovering::with_weights(3, vec![vec![0, 1], vec![1, 2]], vec![5, 10]);
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Check that weights are correctly transferred to objective
-    let mut coeffs: Vec<f64> = vec![0.0; 2];
-    for &(var, coef) in &ilp.objective {
+    let mut coeffs: Vec<i64> = vec![0; 2];
+    for &(var, coef) in ilp.objective() {
         coeffs[var] = coef;
     }
-    assert!((coeffs[0] - 5.0).abs() < 1e-9);
-    assert!((coeffs[1] - 10.0).abs() < 1e-9);
+    assert_eq!(coeffs, vec![5, 10]);
 }
 
 #[test]
 fn test_minimumsetcovering_to_ilp_closed_loop() {
     // Universe: {0, 1, 2}, Sets: S0={0,1}, S1={1,2}, S2={0,2}
     // Minimum cover: any 2 sets work
-    let problem = MinimumSetCovering::<i32>::new(3, vec![vec![0, 1], vec![1, 2], vec![0, 2]]);
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MinimumSetCovering::new(3, vec![vec![0, 1], vec![1, 2], vec![0, 2]]);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     // Solve with brute force on original problem
-    let bf_solutions = bf.find_all_witnesses(&problem);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
 
     // Solve via ILP reduction
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Both should find optimal size = 2
-    let bf_size: usize = bf_solutions[0].iter().sum();
-    let ilp_size: usize = extracted.iter().sum();
+    let bf_size: usize = bf_solutions[0].iter().filter(|&&selected| selected).count();
+    let ilp_size: usize = extracted.iter().filter(|&&selected| selected).count();
     assert_eq!(bf_size, 2);
     assert_eq!(ilp_size, 2);
 
     // Verify the ILP solution is valid for the original problem
     assert!(
-        problem.evaluate(&extracted).is_valid(),
+        problem.evaluate(&extracted).unwrap().is_valid(),
         "Extracted solution should be valid"
     );
 }
@@ -82,113 +84,117 @@ fn test_ilp_solution_equals_brute_force_weighted() {
         vec![vec![0, 1, 2], vec![0, 1], vec![2]],
         vec![10, 3, 3],
     );
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_obj = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_obj = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_obj = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_obj = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_obj, Min(Some(6)));
     assert_eq!(ilp_obj, Min(Some(6)));
 
     // Verify the solution selects S1 and S2
-    assert_eq!(extracted, vec![0, 1, 1]);
+    assert_eq!(extracted, vec![false, true, true]);
 }
 
 #[test]
 fn test_solution_extraction() {
-    let problem = MinimumSetCovering::<i32>::new(4, vec![vec![0, 1], vec![2, 3]]);
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MinimumSetCovering::new(4, vec![vec![0, 1], vec![2, 3]]);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Test that extraction works correctly (1:1 mapping)
     let ilp_solution = vec![1, 1];
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![1, 1]);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![true, true]);
 
     // Verify this is a valid set cover
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_ilp_structure() {
-    let problem =
-        MinimumSetCovering::<i32>::new(5, vec![vec![0, 1], vec![1, 2], vec![2, 3], vec![3, 4]]);
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MinimumSetCovering::new(5, vec![vec![0, 1], vec![1, 2], vec![2, 3], vec![3, 4]]);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 4);
-    assert_eq!(ilp.constraints.len(), 5);
+    assert_eq!(ilp.num_vars(), 4);
+    assert_eq!(ilp.constraints().len(), 5);
 }
 
 #[test]
 fn test_single_set_covers_all() {
     // Single set covers entire universe
-    let problem = MinimumSetCovering::<i32>::new(3, vec![vec![0, 1, 2], vec![0], vec![1], vec![2]]);
+    let problem = MinimumSetCovering::new(3, vec![vec![0, 1, 2], vec![0], vec![1], vec![2]]);
 
     let ilp_solver = ILPSolver::new();
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // First set alone covers everything with weight 1
-    assert_eq!(extracted, vec![1, 0, 0, 0]);
+    assert_eq!(extracted, vec![true, false, false, false]);
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
 
 #[test]
 fn test_overlapping_sets() {
     // All sets overlap on element 1
-    let problem = MinimumSetCovering::<i32>::new(3, vec![vec![0, 1], vec![1, 2]]);
+    let problem = MinimumSetCovering::new(3, vec![vec![0, 1], vec![1, 2]]);
 
     let ilp_solver = ILPSolver::new();
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Need both sets to cover all elements
-    assert_eq!(extracted, vec![1, 1]);
+    assert_eq!(extracted, vec![true, true]);
 
-    assert!(problem.evaluate(&extracted).is_valid());
-    assert_eq!(problem.evaluate(&extracted), Min(Some(2)));
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(2)));
 }
 
 #[test]
 fn test_empty_universe() {
     // Empty universe is trivially covered
-    let problem = MinimumSetCovering::<i32>::new(0, vec![]);
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MinimumSetCovering::new(0, vec![]);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 0);
-    assert_eq!(ilp.constraints.len(), 0);
+    assert_eq!(ilp.num_vars(), 0);
+    assert_eq!(ilp.constraints().len(), 0);
 }
 
 #[test]
-fn test_solve_reduced() {
-    // Test the ILPSolver::solve_reduced method
-    let problem =
-        MinimumSetCovering::<i32>::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3], vec![0, 3]]);
+fn test_solve_via_ilp_pipeline() {
+    let problem: MinimumSetCovering<i64> =
+        MinimumSetCovering::new(4, vec![vec![0, 1], vec![1, 2], vec![2, 3], vec![0, 3]]);
 
     let ilp_solver = ILPSolver::new();
     let solution = ilp_solver
-        .solve_reduced(&problem)
-        .expect("solve_reduced should work");
+        .solve(&problem)
+        .expect("ILP pipeline should solve the problem");
 
-    assert!(problem.evaluate(&solution).is_valid());
-    assert_eq!(problem.evaluate(&solution), Min(Some(2)));
+    assert!(problem.evaluate(&solution).unwrap().is_valid());
+    assert_eq!(problem.evaluate(&solution).unwrap(), Min(Some(2)));
 }
 
 #[test]
@@ -198,29 +204,30 @@ fn test_constraint_structure() {
     // Element 0 is in S0, S1 -> constraint: x0 + x1 >= 1
     // Element 1 is in S1, S2 -> constraint: x1 + x2 >= 1
     // Element 2 is in S2 -> constraint: x2 >= 1
-    let problem = MinimumSetCovering::<i32>::new(3, vec![vec![0], vec![0, 1], vec![1, 2]]);
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MinimumSetCovering::new(3, vec![vec![0], vec![0, 1], vec![1, 2]]);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.constraints.len(), 3);
+    assert_eq!(ilp.constraints().len(), 3);
 
     // Check constraint for element 0: should involve sets 0 and 1
-    let c0 = &ilp.constraints[0];
-    let vars0: Vec<usize> = c0.terms.iter().map(|&(v, _)| v).collect();
+    let c0 = &ilp.constraints()[0];
+    let vars0: Vec<usize> = c0.terms().iter().map(|&(v, _)| v).collect();
     assert!(vars0.contains(&0));
     assert!(vars0.contains(&1));
     assert!(!vars0.contains(&2));
 
     // Check constraint for element 1: should involve sets 1 and 2
-    let c1 = &ilp.constraints[1];
-    let vars1: Vec<usize> = c1.terms.iter().map(|&(v, _)| v).collect();
+    let c1 = &ilp.constraints()[1];
+    let vars1: Vec<usize> = c1.terms().iter().map(|&(v, _)| v).collect();
     assert!(!vars1.contains(&0));
     assert!(vars1.contains(&1));
     assert!(vars1.contains(&2));
 
     // Check constraint for element 2: should involve only set 2
-    let c2 = &ilp.constraints[2];
-    let vars2: Vec<usize> = c2.terms.iter().map(|&(v, _)| v).collect();
+    let c2 = &ilp.constraints()[2];
+    let vars2: Vec<usize> = c2.terms().iter().map(|&(v, _)| v).collect();
     assert!(!vars2.contains(&0));
     assert!(!vars2.contains(&1));
     assert!(vars2.contains(&2));
@@ -228,7 +235,8 @@ fn test_constraint_structure() {
 
 #[test]
 fn test_minimumsetcovering_to_ilp_bf_vs_ilp() {
-    let problem = MinimumSetCovering::<i32>::new(3, vec![vec![0, 1], vec![1, 2], vec![0, 2]]);
-    let reduction: ReductionSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MinimumSetCovering::new(3, vec![vec![0, 1], vec![1, 2], vec![0, 2]]);
+    let reduction: ReductionSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/minimumsummulticenter_ilp.rs b/src/unit_tests/rules/minimumsummulticenter_ilp.rs
index 2f9047f6f..a6d254c93 100644
--- a/src/unit_tests/rules/minimumsummulticenter_ilp.rs
+++ b/src/unit_tests/rules/minimumsummulticenter_ilp.rs
@@ -10,22 +10,23 @@ fn test_reduction_creates_valid_ilp() {
     // 3-vertex path: 0 - 1 - 2, unit weights, K=1
     let problem = MinimumSumMulticenter::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-        vec![1i32; 3],
-        vec![1i32; 2],
+        vec![1i64; 3],
+        vec![1i64; 2],
         1,
     );
-    let reduction: ReductionMSMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMSMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // num_vars = n + n^2 = 3 + 9 = 12
-    assert_eq!(ilp.num_vars, 12, "n + n^2 variables");
+    assert_eq!(ilp.num_vars(), 12, "n + n^2 variables");
     // num_constraints = 1 (cardinality) + n (assignment) + n^2 (capacity)
     //                 = 1 + 3 + 9 = 13
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         13,
         "cardinality + assignment + capacity constraints"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -34,28 +35,29 @@ fn test_minimumsummulticenter_to_ilp_bf_vs_ilp() {
     // Optimal: center at vertex 1, total distance = 1+0+1 = 2
     let problem = MinimumSumMulticenter::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-        vec![1i32; 3],
-        vec![1i32; 2],
+        vec![1i64; 3],
+        vec![1i64; 2],
         1,
     );
-    let reduction: ReductionMSMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMSMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_witness = bf.find_witness(&problem).expect("should have a solution");
-    let bf_cost = problem.evaluate(&bf_witness).unwrap();
+    let bf_witness = bf.solve(&problem).unwrap().expect("should have a solution");
+    let bf_cost = problem.evaluate(&bf_witness).unwrap().unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
         extracted.len(),
         3,
         "extracted solution has one entry per vertex"
     );
 
-    let ilp_cost = problem.evaluate(&extracted).unwrap();
+    let ilp_cost = problem.evaluate(&extracted).unwrap().unwrap();
     // Both should find the same optimal cost
     assert_eq!(
         bf_cost, ilp_cost,
@@ -70,27 +72,32 @@ fn test_minimumsummulticenter_to_ilp_respects_weighted_shortest_paths() {
     // the source model must use weighted shortest paths, so center 2 is optimal.
     let problem = MinimumSumMulticenter::new(
         SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]),
-        vec![10i32, 10, 1],
-        vec![100i32, 1, 1],
+        vec![10i64, 10, 1],
+        vec![100i64, 1, 1],
         1,
     );
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should have a solution");
-    assert_eq!(bf_witness, vec![0, 0, 1], "center 2 is uniquely optimal");
-    assert_eq!(problem.evaluate(&bf_witness).unwrap(), 20);
+    let bf_witness = bf.solve(&problem).unwrap().expect("should have a solution");
+    assert_eq!(
+        bf_witness,
+        vec![false, false, true],
+        "center 2 is uniquely optimal"
+    );
+    assert_eq!(problem.evaluate(&bf_witness).unwrap().unwrap(), 20);
 
-    let reduction: ReductionMSMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMSMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert_eq!(
         extracted, bf_witness,
         "ILP reduction must optimize weighted shortest-path distances"
     );
-    assert_eq!(problem.evaluate(&extracted).unwrap(), 20);
+    assert_eq!(problem.evaluate(&extracted).unwrap().unwrap(), 20);
 }
 
 #[test]
@@ -98,11 +105,12 @@ fn test_solution_extraction() {
     // 3-vertex path: center at vertex 1
     let problem = MinimumSumMulticenter::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-        vec![1i32; 3],
-        vec![1i32; 2],
+        vec![1i64; 3],
+        vec![1i64; 2],
         1,
     );
-    let reduction: ReductionMSMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMSMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manually construct a valid ILP solution:
     // x = [0, 1, 0]; each vertex assigned to center 1
@@ -112,26 +120,27 @@ fn test_solution_extraction() {
         0, 1, 0, // y_{1,0}, y_{1,1}, y_{1,2}
         0, 1, 0, // y_{2,0}, y_{2,1}, y_{2,2}
     ];
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![0, 1, 0]);
-    assert_eq!(problem.evaluate(&extracted).unwrap(), 2);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![false, true, false]);
+    assert_eq!(problem.evaluate(&extracted).unwrap().unwrap(), 2);
 }
 
 #[test]
 fn test_minimumsummulticenter_to_ilp_trivial() {
     // Single vertex, K=1: the only vertex must be the center, distance = 0
-    let problem = MinimumSumMulticenter::new(SimpleGraph::new(1, vec![]), vec![5i32], vec![], 1);
-    let reduction: ReductionMSMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let problem = MinimumSumMulticenter::new(SimpleGraph::new(1, vec![]), vec![5i64], vec![], 1);
+    let reduction: ReductionMSMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // num_vars = 1 + 1 = 2
-    assert_eq!(ilp.num_vars, 2);
+    assert_eq!(ilp.num_vars(), 2);
     // num_constraints = 1 (cardinality) + 1 (assignment) + 1 (capacity) = 3
-    assert_eq!(ilp.constraints.len(), 3);
+    assert_eq!(ilp.constraints().len(), 3);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted.len(), 1);
-    assert_eq!(extracted, vec![1]);
-    assert_eq!(problem.evaluate(&extracted).unwrap(), 0);
+    assert_eq!(extracted, vec![true]);
+    assert_eq!(problem.evaluate(&extracted).unwrap().unwrap(), 0);
 }
diff --git a/src/unit_tests/rules/minimumtardinesssequencing_ilp.rs b/src/unit_tests/rules/minimumtardinesssequencing_ilp.rs
index ba211afee..7f8da1782 100644
--- a/src/unit_tests/rules/minimumtardinesssequencing_ilp.rs
+++ b/src/unit_tests/rules/minimumtardinesssequencing_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::One;
@@ -10,29 +10,25 @@ use crate::types::One;
 #[test]
 fn test_minimumtardinesssequencing_to_ilp_closed_loop() {
     let problem = MinimumTardinessSequencing::<One>::new(3, vec![2, 3, 1], vec![(0, 2)]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_optimization_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "MinimumTardinessSequencing->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_minimumtardinesssequencing_to_ilp_bf_vs_ilp() {
     let problem = MinimumTardinessSequencing::<One>::new(4, vec![2, 3, 1, 4], vec![(0, 2)]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     assert!(ilp_value.is_valid());
@@ -41,25 +37,25 @@ fn test_minimumtardinesssequencing_to_ilp_bf_vs_ilp() {
 #[test]
 fn test_minimumtardinesssequencing_to_ilp_no_precedences() {
     let problem = MinimumTardinessSequencing::<One>::new(3, vec![1, 2, 3], vec![]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted).is_valid());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_minimumtardinesssequencing_to_ilp_all_tight() {
     let problem = MinimumTardinessSequencing::<One>::new(3, vec![1, 1, 1], vec![]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(value.is_valid());
     assert_eq!(value.0, Some(2));
 }
@@ -69,34 +65,30 @@ fn test_minimumtardinesssequencing_to_ilp_all_tight() {
 #[test]
 fn test_minimumtardinesssequencing_weighted_to_ilp_closed_loop() {
     let problem =
-        MinimumTardinessSequencing::<i32>::with_lengths(vec![2, 1, 3], vec![3, 4, 5], vec![(0, 2)]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        MinimumTardinessSequencing::<i64>::with_lengths(vec![2, 1, 3], vec![3, 4, 5], vec![(0, 2)]);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_optimization_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "MinimumTardinessSequencing<i32>->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_minimumtardinesssequencing_weighted_to_ilp_vs_brute_force() {
-    let problem = MinimumTardinessSequencing::<i32>::with_lengths(
+    let problem = MinimumTardinessSequencing::<i64>::with_lengths(
         vec![3, 2, 2, 1, 2],
         vec![4, 3, 8, 3, 6],
         vec![(0, 2), (1, 3)],
     );
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should have solution");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_witness = bf.solve(&problem).unwrap().expect("should have solution");
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
 
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     assert_eq!(ilp_value.0, Some(2));
diff --git a/src/unit_tests/rules/minimumvertexcover_comparativecontainment.rs b/src/unit_tests/rules/minimumvertexcover_comparativecontainment.rs
index ecf5c4322..4786f0a13 100644
--- a/src/unit_tests/rules/minimumvertexcover_comparativecontainment.rs
+++ b/src/unit_tests/rules/minimumvertexcover_comparativecontainment.rs
@@ -1,152 +1,156 @@
-use crate::models::decision::Decision;
-use crate::models::graph::MinimumVertexCover;
-use crate::models::set::ComparativeContainment;
+use super::*;
 use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
-use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::solvers::BruteForce;
-use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 
-fn decision_mvc(
-    num_vertices: usize,
-    edges: &[(usize, usize)],
-    k: i32,
-) -> Decision<MinimumVertexCover<SimpleGraph, i32>> {
-    Decision::new(
-        MinimumVertexCover::new(
-            SimpleGraph::new(num_vertices, edges.to_vec()),
-            vec![1i32; num_vertices],
-        ),
-        k,
-    )
-}
-
 #[test]
-fn test_minimumvertexcover_to_comparativecontainment_structure_counts() {
-    // Path P_4: 4 vertices, 3 edges. K=2.
-    let source = decision_mvc(4, &[(0, 1), (1, 2), (2, 3)], 2);
-    let reduction = ReduceTo::<ComparativeContainment<i32>>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.universe_size(), 4);
-    assert_eq!(target.num_r_sets(), 4);
-    // num_s_sets = num_edges + 1 (one budget set).
-    assert_eq!(target.num_s_sets(), 4);
-
-    // Each R set has n - 1 = 3 elements and weight 1.
-    for r in target.r_sets() {
-        assert_eq!(r.len(), 3);
+fn test_minimumvertexcover_to_comparativecontainment_closed_loop() {
+    for bound in [1, 2] {
+        let source = Decision::new(
+            MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![4i64, 2, -1]),
+            bound,
+        );
+        let reduction = ReduceTo::<ComparativeContainment<i64>>::reduce_to(&source).unwrap();
+        assert_satisfaction_round_trip_from_satisfaction_target(
+            &source,
+            &reduction,
+            "signed vertex cover",
+        );
+        let witness = BruteForce::new()
+            .solve(reduction.target_problem())
+            .unwrap()
+            .unwrap();
+        assert!(
+            source
+                .evaluate(&reduction.extract_solution(&witness).unwrap())
+                .unwrap()
+                .0
+        );
     }
-    assert!(target.r_weights().iter().all(|&w| w == 1));
-
-    // Edge S sets have n - 2 = 2 elements and weight n + 1 = 5.
-    for s in target.s_sets().iter().take(3) {
-        assert_eq!(s.len(), 2);
-    }
-    for &w in target.s_weights().iter().take(3) {
-        assert_eq!(w, 5);
-    }
-    // Budget S set is the full universe, weight n - K = 2.
-    assert_eq!(target.s_sets().last().unwrap().len(), 4);
-    assert_eq!(*target.s_weights().last().unwrap(), 2);
-}
-
-#[test]
-fn test_minimumvertexcover_to_comparativecontainment_closed_loop_yes() {
-    // Path P_4: minimum vertex cover {1, 2} has size 2. With K=2 this is YES.
-    let source = decision_mvc(4, &[(0, 1), (1, 2), (2, 3)], 2);
-    let reduction = ReduceTo::<ComparativeContainment<i32>>::reduce_to(&source);
-
-    assert_satisfaction_round_trip_from_satisfaction_target(
-        &source,
-        &reduction,
-        "Decision<MVC>->ComparativeContainment YES instance",
-    );
-}
-
-#[test]
-fn test_minimumvertexcover_to_comparativecontainment_closed_loop_no() {
-    // Triangle: minimum vertex cover has size 2. K=1 is NO.
-    let source = decision_mvc(3, &[(0, 1), (1, 2), (0, 2)], 1);
-    let reduction = ReduceTo::<ComparativeContainment<i32>>::reduce_to(&source);
-
-    // Source is unsatisfiable, target must be too.
-    let target = reduction.target_problem();
-    let witnesses = BruteForce::new().find_all_witnesses(target);
-    assert!(
-        witnesses.is_empty(),
-        "Triangle with K=1 should produce an unsatisfiable target instance"
+    let source = Decision::new(
+        MinimumVertexCover::new(
+            SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
+            vec![4i64, 2, -1],
+        ),
+        0,
     );
-    assert!(!source.evaluate(&[1, 1, 0]).0);
+    let reduction = ReduceTo::<ComparativeContainment<i64>>::reduce_to(&source).unwrap();
+    assert!(BruteForce::new()
+        .solve(reduction.target_problem())
+        .unwrap()
+        .is_none());
 }
 
 #[test]
-fn test_minimumvertexcover_to_comparativecontainment_extracts_cover() {
-    // Triangle with K=2 has cover {0, 1} (and others).
-    let source = decision_mvc(3, &[(0, 1), (1, 2), (0, 2)], 2);
-    let reduction = ReduceTo::<ComparativeContainment<i32>>::reduce_to(&source);
-
-    let witness = BruteForce::new()
-        .find_witness(reduction.target_problem())
-        .expect("triangle with K=2 should be satisfiable");
-    let extracted = reduction.extract_solution(&witness);
-    assert_eq!(extracted.len(), 3);
-    assert!(source.evaluate(&extracted).0);
-}
-
-#[test]
-fn test_minimumvertexcover_to_comparativecontainment_trivial_yes_k_equals_n() {
-    // K = n corner case: bound equals number of vertices. Every cover is feasible.
-    let source = decision_mvc(3, &[(0, 1), (1, 2), (0, 2)], 3);
-    let reduction = ReduceTo::<ComparativeContainment<i32>>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    // Trivial-YES target: empty universe with no sets.
-    assert_eq!(target.universe_size(), 0);
-    assert_eq!(target.num_r_sets(), 0);
-    assert_eq!(target.num_s_sets(), 0);
-
-    // The empty configuration is trivially satisfying.
-    assert!(target.evaluate(&[]).0);
-
-    // Extracted source configuration must be a valid cover with size <= K.
-    let extracted = reduction.extract_solution(&[]);
-    assert_eq!(extracted.len(), 3);
-    assert!(source.evaluate(&extracted).0);
-}
-
-#[test]
-fn test_minimumvertexcover_to_comparativecontainment_trivial_yes_k_greater_than_n() {
-    // K > n: still trivially YES.
-    let source = decision_mvc(2, &[(0, 1)], 5);
-    let reduction = ReduceTo::<ComparativeContainment<i32>>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.universe_size(), 0);
-    let extracted = reduction.extract_solution(&[]);
-    assert!(source.evaluate(&extracted).0);
+fn test_signed_containment_all_small_graphs_and_witnesses() {
+    // Exhaust all graphs through 3 vertices, including loops, and all choices
+    // of negative/zero/positive weights. Check every witness in both directions.
+    for n in 0usize..=3 {
+        let possible: Vec<_> = (0..n).flat_map(|u| (u..n).map(move |v| (u, v))).collect();
+        for edge_mask in 0..(1usize << possible.len()) {
+            let edges: Vec<_> = possible
+                .iter()
+                .enumerate()
+                .filter_map(|(i, &e)| (edge_mask & (1 << i) != 0).then_some(e))
+                .collect();
+            for mut code in 0..3usize.pow(u32::try_from(n).unwrap()) {
+                let weights: Vec<i64> = (0..n)
+                    .map(|_| {
+                        let w = [-2, 0, 3][code % 3];
+                        code /= 3;
+                        w
+                    })
+                    .collect();
+                for bound in [-7, -2, 0, 1, 3, 9, i64::MAX] {
+                    let source = Decision::new(
+                        MinimumVertexCover::new(
+                            SimpleGraph::new(n, edges.clone()),
+                            weights.clone(),
+                        ),
+                        bound,
+                    );
+                    let reduction =
+                        ReduceTo::<ComparativeContainment<i64>>::reduce_to(&source).unwrap();
+                    let target = reduction.target_problem();
+                    assert_eq!(target.universe_size(), n);
+                    assert!(target.num_r_sets() <= n + 1);
+                    assert!(target.num_s_sets() <= n + edges.len() + 1);
+                    assert!(target
+                        .r_weights()
+                        .iter()
+                        .chain(target.s_weights())
+                        .all(|&w| w > 0));
+                    for mask in 0..(1usize << n) {
+                        let witness: Vec<_> = (0..n).map(|v| mask & (1 << v) != 0).collect();
+                        let valid = source.evaluate(&witness).unwrap().0;
+                        assert_eq!(target.evaluate(&witness).unwrap().0, valid);
+                        if valid {
+                            assert_eq!(reduction.extract_solution(&witness).unwrap(), witness);
+                        } else {
+                            assert!(reduction.extract_solution(&witness).is_err());
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
 
 #[test]
-fn test_minimumvertexcover_to_comparativecontainment_negative_bound() {
-    // Negative bound is trivially NO; target must be unsatisfiable.
-    let source = decision_mvc(2, &[(0, 1)], -1);
-    let reduction = ReduceTo::<ComparativeContainment<i32>>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    let witnesses = BruteForce::new().find_all_witnesses(target);
-    assert!(
-        witnesses.is_empty(),
-        "Negative bound should produce an unsatisfiable target"
+fn test_signed_containment_duplicate_edges_and_invalid_length() {
+    let source = Decision::new(
+        MinimumVertexCover::new(
+            SimpleGraph::new(3, vec![(0, 0), (0, 1), (0, 1)]),
+            vec![-3i64, 0, 5],
+        ),
+        -3,
     );
+    let reduction = ReduceTo::<ComparativeContainment<i64>>::reduce_to(&source).unwrap();
+    let witness = vec![true, false, false];
+    assert_eq!(reduction.extract_solution(&witness).unwrap(), witness);
+    for bad in [vec![], vec![true; 4]] {
+        assert!(reduction.extract_solution(&bad).is_err());
+    }
 }
 
 #[test]
-#[should_panic(expected = "unit vertex weights")]
-fn test_minimumvertexcover_to_comparativecontainment_rejects_non_unit_weights() {
-    let source = Decision::new(
-        MinimumVertexCover::new(SimpleGraph::new(2, vec![(0, 1)]), vec![2i32, 1i32]),
-        1,
-    );
-    let _ = ReduceTo::<ComparativeContainment<i32>>::reduce_to(&source);
+fn test_signed_containment_numeric_domain() {
+    // Distinct causes: source positive/negative totals, budget subtraction,
+    // strict penalty, coefficient sign change, and total target-family sum.
+    for (weights, bound, edges) in [
+        (vec![i64::MAX, 1], 0, vec![]),
+        (vec![i64::MIN, -1], 0, vec![]),
+        (vec![1], i64::MIN, vec![]),
+        (vec![i64::MAX], 0, vec![]),
+        (vec![i64::MIN], 0, vec![]),
+        (vec![0], i64::MIN, vec![]),
+        (vec![i64::MAX / 2], 0, vec![(0, 0), (0, 0)]),
+    ] {
+        let source = Decision::new(
+            MinimumVertexCover::new(SimpleGraph::new(weights.len(), edges), weights),
+            bound,
+        );
+        assert!(matches!(
+            ReduceTo::<ComparativeContainment<i64>>::reduce_to(&source),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+    // Large values are accepted when all target arithmetic is representable.
+    for (weight, bound) in [
+        (i64::MAX - 1, i64::MAX),
+        (-(i64::MAX - 1), 0),
+        (0, i64::MIN + 1),
+    ] {
+        let source = Decision::new(
+            MinimumVertexCover::new(SimpleGraph::new(1, vec![]), vec![weight]),
+            bound,
+        );
+        let reduction = ReduceTo::<ComparativeContainment<i64>>::reduce_to(&source).unwrap();
+        for witness in [vec![false], vec![true]] {
+            assert_eq!(
+                source.evaluate(&witness).unwrap().0,
+                reduction.target_problem().evaluate(&witness).unwrap().0
+            );
+        }
+    }
 }
diff --git a/src/unit_tests/rules/minimumvertexcover_ensemblecomputation.rs b/src/unit_tests/rules/minimumvertexcover_ensemblecomputation.rs
index afb8d3af6..b44823425 100644
--- a/src/unit_tests/rules/minimumvertexcover_ensemblecomputation.rs
+++ b/src/unit_tests/rules/minimumvertexcover_ensemblecomputation.rs
@@ -8,9 +8,9 @@ use crate::traits::Problem;
 use crate::types::{Min, One};
 
 /// Verify that a configuration is a valid vertex cover.
-fn is_valid_cover(graph: &SimpleGraph, config: &[usize]) -> bool {
+fn is_valid_cover(graph: &SimpleGraph, config: &[bool]) -> bool {
     for (u, v) in graph.edges() {
-        if config[u] == 0 && config[v] == 0 {
+        if !config[u] && !config[v] {
             return false;
         }
     }
@@ -23,7 +23,8 @@ fn test_minimumvertexcover_to_ensemblecomputation_closed_loop() {
     // K* = 1, optimal EC length = K* + |E| = 2
     let graph = SimpleGraph::new(2, vec![(0, 1)]);
     let source = MinimumVertexCover::new(graph.clone(), vec![One; 2]);
-    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<EnsembleComputation>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Verify target structure
@@ -32,16 +33,17 @@ fn test_minimumvertexcover_to_ensemblecomputation_closed_loop() {
     assert_eq!(target.budget(), 3); // |V| + |E|
 
     // Solve target with brute force — optimal value should be 2 (K*=1 + |E|=1)
-    use crate::solvers::Solver;
     let solver = BruteForce::new();
-    let optimal = solver.solve(target);
+    let optimal_solution = solver.solve(target).unwrap().unwrap();
+    let optimal = target.evaluate(&optimal_solution).unwrap();
     assert_eq!(optimal, Min(Some(2)));
 
     // Every extracted solution must be a valid vertex cover
-    let witnesses = solver.find_all_witnesses(target);
+    let witnesses = solver.find_all_witnesses(target).unwrap();
     for witness in &witnesses {
-        let source_config = reduction.extract_solution(witness);
+        let source_config = reduction.extract_solution(witness).unwrap();
         assert_eq!(source_config.len(), 2);
+        assert_eq!(source.evaluate(&source_config).unwrap(), Min(Some(1)));
         assert!(
             is_valid_cover(&graph, &source_config),
             "Extracted config {:?} is not a valid vertex cover (from target witness {:?})",
@@ -56,7 +58,8 @@ fn test_reduction_structure_triangle() {
     // Triangle K₃: 3 vertices, 3 edges
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
     let source = MinimumVertexCover::new(graph, vec![One; 3]);
-    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<EnsembleComputation>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Verify sizes
@@ -77,7 +80,8 @@ fn test_reduction_structure_path() {
     // Path P₃: 3 vertices {0,1,2}, 2 edges
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let source = MinimumVertexCover::new(graph, vec![One; 3]);
-    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<EnsembleComputation>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.universe_size(), 4);
@@ -90,7 +94,8 @@ fn test_extract_solution_correctness() {
     // Single edge: vertices {0,1}, edge (0,1), a₀ = 2
     let graph = SimpleGraph::new(2, vec![(0, 1)]);
     let source = MinimumVertexCover::new(graph.clone(), vec![One; 2]);
-    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<EnsembleComputation>::reduce_to(&source).expect("reduction should succeed");
 
     // Step 0: {a₀=2} ∪ {0} → z₀ = {0,2}   operands: (2, 0)
     // Step 1: {1} ∪ z₀ → z₁ = {0,1,2}      operands: (1, 3)
@@ -98,10 +103,10 @@ fn test_extract_solution_correctness() {
     let config = vec![2, 0, 1, 3, 2, 1];
 
     let target = reduction.target_problem();
-    assert_eq!(target.evaluate(&config), Min(Some(2)));
+    assert_eq!(target.evaluate(&config).unwrap(), Min(Some(2)));
 
-    let cover = reduction.extract_solution(&config);
-    assert_eq!(cover, vec![1, 1]);
+    let cover = reduction.extract_solution(&config).unwrap();
+    assert_eq!(cover, vec![true, false]);
     assert!(is_valid_cover(&graph, &cover));
 }
 
@@ -109,16 +114,17 @@ fn test_extract_solution_correctness() {
 fn test_extract_from_non_normalized_witness() {
     let graph = SimpleGraph::new(2, vec![(0, 1)]);
     let source = MinimumVertexCover::new(graph.clone(), vec![One; 2]);
-    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<EnsembleComputation>::reduce_to(&source).expect("reduction should succeed");
 
     // Non-normalized: {0} ∪ {1} first, then {a₀} ∪ z₀
     let config = vec![0, 1, 2, 3, 2, 0];
 
     let target = reduction.target_problem();
-    assert_eq!(target.evaluate(&config), Min(Some(2)));
+    assert_eq!(target.evaluate(&config).unwrap(), Min(Some(2)));
 
-    let cover = reduction.extract_solution(&config);
-    assert_eq!(cover, vec![1, 1]);
+    let cover = reduction.extract_solution(&config).unwrap();
+    assert_eq!(cover, vec![true, false]);
     assert!(is_valid_cover(&graph, &cover));
 }
 
@@ -126,7 +132,8 @@ fn test_extract_from_non_normalized_witness() {
 fn test_empty_graph() {
     let graph = SimpleGraph::new(3, vec![]);
     let source = MinimumVertexCover::new(graph.clone(), vec![One; 3]);
-    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<EnsembleComputation>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.universe_size(), 4);
@@ -134,8 +141,144 @@ fn test_empty_graph() {
     assert_eq!(target.budget(), 3);
 
     // No subsets → optimal value is 0
-    use crate::solvers::Solver;
     let solver = BruteForce::new();
-    let optimal = solver.solve(target);
+    let optimal_solution = solver.solve(target).unwrap().unwrap();
+    let optimal = target.evaluate(&optimal_solution).unwrap();
     assert_eq!(optimal, Min(Some(0)));
 }
+
+#[test]
+fn test_minimumvertexcover_to_ensemblecomputation_zero_vertices() {
+    let source = MinimumVertexCover::new(SimpleGraph::new(0, vec![]), vec![]);
+    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source).unwrap();
+    assert_eq!(reduction.target_problem().universe_size(), 1);
+    assert_eq!(reduction.target_problem().budget(), 1);
+    // No targets: even these out-of-range suffix operands have no semantics.
+    assert_eq!(
+        reduction.extract_solution(&vec![usize::MAX; 2]).unwrap(),
+        Vec::<bool>::new()
+    );
+}
+
+#[test]
+fn test_minimumvertexcover_to_ensemblecomputation_rejects_invalid_programs() {
+    let source = MinimumVertexCover::new(SimpleGraph::new(2, vec![(0, 1)]), vec![One; 2]);
+    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source).unwrap();
+    for program in [vec![], vec![0; 6], vec![3, 0, 1, 2, 0, 1]] {
+        assert!(reduction.extract_solution(&program).is_err());
+    }
+}
+
+#[test]
+fn test_minimumvertexcover_to_ensemblecomputation_unused_and_repeated_operations() {
+    let source = MinimumVertexCover::new(SimpleGraph::new(5, vec![(1, 2), (1, 3)]), vec![One; 5]);
+    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source).unwrap();
+    // Two-atom pair, useful pair, duplicate pair, unused four-atom result,
+    // then the required triples. The final suffix is intentionally invalid.
+    let program = vec![0, 4, 1, 5, 1, 5, 6, 7, 2, 7, 3, 7, usize::MAX, usize::MAX];
+    assert_eq!(
+        reduction.target_problem().evaluate(&program).unwrap(),
+        Min(Some(6))
+    );
+    let cover = reduction.extract_solution(&program).unwrap();
+    assert_eq!(cover, vec![true, true, false, false, false]);
+    assert!(is_valid_cover(source.graph(), &cover));
+    assert!(cover.iter().filter(|&&v| v).count() <= 6 - 2);
+}
+
+#[test]
+fn test_minimumvertexcover_to_ensemblecomputation_all_small_pair_families() {
+    // All graphs on four vertices, and all pair families that fit the budget.
+    // A triple necessarily uses one such pair, so these include both normal
+    // and non-normal programs; compare optimum against independent cover search.
+    let pairs: Vec<_> = (0..5)
+        .flat_map(|u| (u + 1..5).map(move |v| (u, v)))
+        .collect();
+    let graph_edges: Vec<_> = pairs.iter().copied().filter(|&(_, v)| v < 4).collect();
+    for graph_mask in 0..(1 << graph_edges.len()) {
+        let edges: Vec<_> = graph_edges
+            .iter()
+            .enumerate()
+            .filter_map(|(i, &edge)| (graph_mask & (1 << i) != 0).then_some(edge))
+            .collect();
+        let source = MinimumVertexCover::new(SimpleGraph::new(4, edges.clone()), vec![One; 4]);
+        let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source).unwrap();
+        let optimum = (0u32..16)
+            .filter(|bits| {
+                edges
+                    .iter()
+                    .all(|&(u, v)| bits & ((1 << u) | (1 << v)) != 0)
+            })
+            .map(u32::count_ones)
+            .min()
+            .unwrap() as usize;
+        for pair_mask in 0u32..(1 << pairs.len()) {
+            if pair_mask.count_ones() > 4 {
+                continue;
+            }
+            let family: Vec<_> = pairs
+                .iter()
+                .enumerate()
+                .filter_map(|(i, &pair)| (pair_mask & (1 << i) != 0).then_some(pair))
+                .collect();
+            let mut program: Vec<_> = family.iter().flat_map(|&(u, v)| [u, v]).collect();
+            let mut supported = true;
+            for &(u, v) in &edges {
+                let triple = [u, v, 4];
+                let Some((i, &(a, b))) = family
+                    .iter()
+                    .enumerate()
+                    .find(|(_, (a, b))| triple.contains(a) && triple.contains(b))
+                else {
+                    supported = false;
+                    break;
+                };
+                let singleton = *triple.iter().find(|&&x| x != a && x != b).unwrap();
+                program.extend([singleton, 5 + i]);
+            }
+            if !supported {
+                continue;
+            }
+            program.resize(2 * reduction.target_problem().budget(), usize::MAX);
+            let Min(Some(length)) = reduction.target_problem().evaluate(&program).unwrap() else {
+                panic!("pair-family program must compute every triple");
+            };
+            let cover = reduction.extract_solution(&program).unwrap();
+            let size = cover.iter().filter(|&&v| v).count();
+            assert!(is_valid_cover(source.graph(), &cover));
+            assert!(size <= length as usize - edges.len());
+            if length as usize == edges.len() + optimum {
+                assert_eq!(size, optimum);
+            }
+        }
+    }
+}
+
+#[test]
+fn test_minimumvertexcover_to_ensemblecomputation_loops_and_parallel_edges() {
+    // SimpleGraph's native constructor permits these representations. Duplicate
+    // required sets need no extra operations; a loop requires its endpoint pair.
+    let source = MinimumVertexCover::new(
+        SimpleGraph::new(3, vec![(0, 0), (0, 1), (1, 0), (1, 2), (1, 2)]),
+        vec![One; 3],
+    );
+    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source).unwrap();
+    let mut program = vec![3, 0, 3, 1, 1, 4, 2, 5];
+    program.resize(2 * reduction.target_problem().budget(), usize::MAX);
+    assert_eq!(
+        reduction.target_problem().evaluate(&program).unwrap(),
+        Min(Some(4))
+    );
+    let cover = reduction.extract_solution(&program).unwrap();
+    assert_eq!(cover, vec![true, true, false]);
+    assert_eq!(source.evaluate(&cover).unwrap(), Min(Some(2)));
+
+    let source = MinimumVertexCover::new(SimpleGraph::new(1, vec![(0, 0)]), vec![One]);
+    let reduction = ReduceTo::<EnsembleComputation>::reduce_to(&source).unwrap();
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![1, 0, usize::MAX, usize::MAX])
+            .unwrap(),
+        vec![true]
+    );
+}
diff --git a/src/unit_tests/rules/minimumvertexcover_ilp.rs b/src/unit_tests/rules/minimumvertexcover_ilp.rs
index 736072a62..371655368 100644
--- a/src/unit_tests/rules/minimumvertexcover_ilp.rs
+++ b/src/unit_tests/rules/minimumvertexcover_ilp.rs
@@ -1,29 +1,25 @@
 use crate::models::algebraic::{ObjectiveSense, ILP};
 use crate::models::graph::MinimumVertexCover;
-use crate::rules::{MinimizeSteps, ReductionChain, ReductionGraph, ReductionPath};
+use crate::rules::{ReductionChain, ReductionGraph, ReductionPath};
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
-use crate::types::{Min, ProblemSize};
+use crate::types::Min;
 
 fn reduce_vc_to_ilp(
-    problem: &MinimumVertexCover<SimpleGraph, i32>,
+    problem: &MinimumVertexCover<SimpleGraph, i64>,
 ) -> (ReductionPath, ReductionChain) {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
     let dst = ReductionGraph::variant_to_map(&ILP::<bool>::variant());
     let path = graph
-        .find_cheapest_path(
-            "MinimumVertexCover",
-            &src,
-            "ILP",
-            &dst,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .expect("Should find path MinimumVertexCover -> ILP");
+        .find_all_paths("MinimumVertexCover", &src, "ILP", &dst)
+        .into_iter()
+        .find(|path| path.type_names() == ["MinimumVertexCover", "MinimumSetCovering", "ILP"])
+        .expect("expected explicit MinimumSetCovering route");
     let chain = graph
         .reduce_along_path(&path, problem as &dyn std::any::Any)
+        .expect("MinimumVertexCover -> ILP reduction should not fail")
         .expect("Should reduce MinimumVertexCover to ILP along path");
     (path, chain)
 }
@@ -32,7 +28,7 @@ fn reduce_vc_to_ilp(
 fn test_minimumvertexcover_to_ilp_via_path_structure() {
     let problem = MinimumVertexCover::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
     let (path, chain) = reduce_vc_to_ilp(&problem);
     let ilp: &ILP<bool> = chain.target_problem();
@@ -45,27 +41,27 @@ fn test_minimumvertexcover_to_ilp_via_path_structure() {
         path.type_names(),
         vec!["MinimumVertexCover", "MinimumSetCovering", "ILP"]
     );
-    assert_eq!(ilp.num_vars, 3);
-    assert_eq!(ilp.constraints.len(), 3);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 3);
+    assert_eq!(ilp.constraints().len(), 3);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_minimumvertexcover_to_ilp_via_path_closed_loop() {
     let problem = MinimumVertexCover::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let (_, chain) = reduce_vc_to_ilp(&problem);
     let ilp: &ILP<bool> = chain.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = chain.extract_solution(&ilp_solution);
+    let extracted: Vec<bool> = chain.extract_solution(&ilp_solution).unwrap();
 
-    let ilp_size: usize = extracted.iter().sum();
+    let ilp_size = extracted.iter().filter(|&&selected| selected).count();
     assert_eq!(ilp_size, 2);
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
@@ -77,23 +73,23 @@ fn test_minimumvertexcover_to_ilp_via_path_weighted() {
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = chain.extract_solution(&ilp_solution);
+    let extracted = chain.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
-    assert_eq!(extracted, vec![0, 1, 0]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
+    assert_eq!(extracted, vec![false, true, false]);
 }
 
 #[test]
 fn test_minimumvertexcover_to_ilp_bf_vs_ilp() {
     let problem = MinimumVertexCover::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let (_, chain) = reduce_vc_to_ilp(&problem);
     let ilp: &ILP<bool> = chain.target_problem();
-    let bf_solutions = BruteForce::new().find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = chain.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), bf_value);
+    let extracted = chain.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), bf_value);
 }
diff --git a/src/unit_tests/rules/minimumvertexcover_longestcommonsubsequence.rs b/src/unit_tests/rules/minimumvertexcover_longestcommonsubsequence.rs
index c2e43dd00..3f371a3af 100644
--- a/src/unit_tests/rules/minimumvertexcover_longestcommonsubsequence.rs
+++ b/src/unit_tests/rules/minimumvertexcover_longestcommonsubsequence.rs
@@ -9,7 +9,8 @@ fn test_minimumvertexcover_to_longestcommonsubsequence_closed_loop() {
         vec![One; 4],
     );
 
-    let reduction = ReduceTo::<LongestCommonSubsequence>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<LongestCommonSubsequence>::reduce_to(&source).expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -24,7 +25,8 @@ fn test_mvc_to_lcs_structure_for_path_p4() {
         vec![One; 4],
     );
 
-    let reduction = ReduceTo::<LongestCommonSubsequence>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<LongestCommonSubsequence>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.alphabet_size(), 4);
@@ -49,7 +51,8 @@ fn test_mvc_to_lcs_triangle_closed_loop() {
         vec![One; 3],
     );
 
-    let reduction = ReduceTo::<LongestCommonSubsequence>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<LongestCommonSubsequence>::reduce_to(&source).expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
@@ -61,7 +64,8 @@ fn test_mvc_to_lcs_triangle_closed_loop() {
 fn test_mvc_to_lcs_empty_graph_closed_loop() {
     let source = MinimumVertexCover::new(SimpleGraph::new(4, vec![]), vec![One; 4]);
 
-    let reduction = ReduceTo::<LongestCommonSubsequence>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<LongestCommonSubsequence>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.alphabet_size(), 4);
@@ -80,7 +84,8 @@ fn test_mvc_to_lcs_empty_graph_closed_loop() {
 fn test_mvc_to_lcs_canonicalizes_edge_orientation() {
     let source = MinimumVertexCover::new(SimpleGraph::new(2, vec![(1, 0)]), vec![One; 2]);
 
-    let reduction = ReduceTo::<LongestCommonSubsequence>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<LongestCommonSubsequence>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.strings(), &[vec![0, 1], vec![1, 0]]);
diff --git a/src/unit_tests/rules/minimumvertexcover_maximumindependentset.rs b/src/unit_tests/rules/minimumvertexcover_maximumindependentset.rs
index 850680ec7..53fd77c03 100644
--- a/src/unit_tests/rules/minimumvertexcover_maximumindependentset.rs
+++ b/src/unit_tests/rules/minimumvertexcover_maximumindependentset.rs
@@ -8,7 +8,8 @@ fn test_minimumvertexcover_to_maximumindependentset_closed_loop() {
     // Test with weighted problems
     let is_problem =
         MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![10, 20, 30]);
-    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&is_problem);
+    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&is_problem)
+        .expect("reduction should succeed");
     let vc_problem = reduction.target_problem();
 
     // Weights should be preserved
@@ -19,9 +20,10 @@ fn test_minimumvertexcover_to_maximumindependentset_closed_loop() {
 fn test_reduction_structure() {
     let is_problem = MaximumIndependentSet::new(
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
-        vec![1i32; 5],
+        vec![1i64; 5],
     );
-    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&is_problem);
+    let reduction = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&is_problem)
+        .expect("reduction should succeed");
     let vc = reduction.target_problem();
 
     // Same number of vertices in both problems
@@ -39,13 +41,18 @@ fn test_jl_parity_is_to_vertexcovering() {
     let inst = &is_data["instances"][0]["instance"];
     let nv = inst["num_vertices"].as_u64().unwrap() as usize;
     let source =
-        MaximumIndependentSet::new(SimpleGraph::new(nv, jl_parse_edges(inst)), vec![1i32; nv]);
-    let result = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&source);
+        MaximumIndependentSet::new(SimpleGraph::new(nv, jl_parse_edges(inst)), vec![1i64; nv]);
+    let result = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(&source, &result, "JL parity MIS->VC");
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -60,16 +67,21 @@ fn test_jl_parity_rule_is_to_vertexcovering() {
     let inst = &jl_find_instance_by_label(&is_data, "doc_4vertex")["instance"];
     let nv = inst["num_vertices"].as_u64().unwrap() as usize;
     let source =
-        MaximumIndependentSet::new(SimpleGraph::new(nv, jl_parse_edges(inst)), vec![1i32; nv]);
-    let result = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&source);
+        MaximumIndependentSet::new(SimpleGraph::new(nv, jl_parse_edges(inst)), vec![1i64; nv]);
+    let result = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity rule MIS->VC",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
diff --git a/src/unit_tests/rules/minimumvertexcover_minimumfeedbackarcset.rs b/src/unit_tests/rules/minimumvertexcover_minimumfeedbackarcset.rs
index 5b6673a24..ef8a2d1fb 100644
--- a/src/unit_tests/rules/minimumvertexcover_minimumfeedbackarcset.rs
+++ b/src/unit_tests/rules/minimumvertexcover_minimumfeedbackarcset.rs
@@ -11,15 +11,15 @@ use crate::topology::{Graph, SimpleGraph};
 #[cfg(feature = "example-db")]
 use crate::traits::Problem;
 
-fn triangle_source() -> MinimumVertexCover<SimpleGraph, i32> {
+fn triangle_source() -> MinimumVertexCover<SimpleGraph, i64> {
     // Triangle: 0-1-2-0, unit weights; MVC = 2
     MinimumVertexCover::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     )
 }
 
-fn weighted_path_source() -> MinimumVertexCover<SimpleGraph, i32> {
+fn weighted_path_source() -> MinimumVertexCover<SimpleGraph, i64> {
     // Path: 0-1-2-3-4, varied weights
     MinimumVertexCover::new(
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
@@ -30,7 +30,8 @@ fn weighted_path_source() -> MinimumVertexCover<SimpleGraph, i32> {
 #[test]
 fn test_minimumvertexcover_to_minimumfeedbackarcset_closed_loop() {
     let source = triangle_source();
-    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i32>>::reduce_to(&source);
+    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -42,7 +43,8 @@ fn test_minimumvertexcover_to_minimumfeedbackarcset_closed_loop() {
 #[test]
 fn test_minimumvertexcover_to_minimumfeedbackarcset_weighted_closed_loop() {
     let source = weighted_path_source();
-    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i32>>::reduce_to(&source);
+    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -54,7 +56,8 @@ fn test_minimumvertexcover_to_minimumfeedbackarcset_weighted_closed_loop() {
 #[test]
 fn test_reduction_structure() {
     let source = triangle_source();
-    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i32>>::reduce_to(&source);
+    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 3 vertices → 6 vertices in target (v^in, v^out for each)
@@ -72,7 +75,8 @@ fn test_reduction_structure() {
 #[test]
 fn test_internal_arcs_layout() {
     let source = triangle_source();
-    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i32>>::reduce_to(&source);
+    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     let arcs = target.graph().arcs();
     let n = source.graph().num_vertices();
@@ -86,10 +90,11 @@ fn test_internal_arcs_layout() {
 #[test]
 fn test_weight_assignment() {
     let source = weighted_path_source();
-    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i32>>::reduce_to(&source);
+    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     let n = source.graph().num_vertices();
-    let big_m: i32 = 1 + source.weights().iter().sum::<i32>();
+    let big_m: i64 = 1 + source.weights().iter().sum::<i64>();
 
     // Internal arc weights match source vertex weights
     for v in 0..n {
@@ -104,12 +109,13 @@ fn test_weight_assignment() {
 #[test]
 fn test_solution_extraction() {
     let source = triangle_source();
-    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i32>>::reduce_to(&source);
+    let reduction: ReductionVCToFAS = ReduceTo::<MinimumFeedbackArcSet<i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     // Target has 9 arcs; first 3 are internal. Extract should take first 3.
-    let target_config = vec![1, 1, 0, 0, 0, 0, 0, 0, 0];
-    let source_config = reduction.extract_solution(&target_config);
-    assert_eq!(source_config, vec![1, 1, 0]);
+    let target_config = vec![true, true, false, false, false, false, false, false, false];
+    let source_config = reduction.extract_solution(&target_config).unwrap();
+    assert_eq!(source_config, vec![true, true, false]);
 }
 
 #[cfg(feature = "example-db")]
@@ -125,16 +131,18 @@ fn test_canonical_rule_example_spec_builds() {
     assert_eq!(example.target.problem, "MinimumFeedbackArcSet");
     assert_eq!(example.solutions.len(), 1);
 
-    let source: MinimumVertexCover<SimpleGraph, i32> =
+    let source: MinimumVertexCover<SimpleGraph, i64> =
         serde_json::from_value(example.source.instance.clone())
             .expect("source example deserializes");
-    let target: MinimumFeedbackArcSet<i32> =
+    let target: MinimumFeedbackArcSet<i64> =
         serde_json::from_value(example.target.instance.clone())
             .expect("target example deserializes");
     let solution = &example.solutions[0];
+    let source_config: Vec<bool> = serde_json::from_value(solution.source_config.clone()).unwrap();
+    let target_config: Vec<bool> = serde_json::from_value(solution.target_config.clone()).unwrap();
 
-    let source_metric = source.evaluate(&solution.source_config);
-    let target_metric = target.evaluate(&solution.target_config);
+    let source_metric = source.evaluate(&source_config).unwrap();
+    let target_metric = target.evaluate(&target_config).unwrap();
     assert!(
         source_metric.is_valid(),
         "source witness should be feasible"
@@ -145,12 +153,14 @@ fn test_canonical_rule_example_spec_builds() {
     );
 
     let best_source = BruteForce::new()
-        .find_witness(&source)
+        .solve(&source)
+        .unwrap()
         .expect("source example should have an optimum");
     let best_target = BruteForce::new()
-        .find_witness(&target)
+        .solve(&target)
+        .unwrap()
         .expect("target example should have an optimum");
 
-    assert_eq!(source_metric, source.evaluate(&best_source));
-    assert_eq!(target_metric, target.evaluate(&best_target));
+    assert_eq!(source_metric, source.evaluate(&best_source).unwrap());
+    assert_eq!(target_metric, target.evaluate(&best_target).unwrap());
 }
diff --git a/src/unit_tests/rules/minimumvertexcover_minimumfeedbackvertexset.rs b/src/unit_tests/rules/minimumvertexcover_minimumfeedbackvertexset.rs
index 4ae5fd263..9230ebe1c 100644
--- a/src/unit_tests/rules/minimumvertexcover_minimumfeedbackvertexset.rs
+++ b/src/unit_tests/rules/minimumvertexcover_minimumfeedbackvertexset.rs
@@ -11,7 +11,7 @@ use crate::topology::{Graph, SimpleGraph};
 #[cfg(feature = "example-db")]
 use crate::traits::Problem;
 
-fn weighted_cycle_cover_source() -> MinimumVertexCover<SimpleGraph, i32> {
+fn weighted_cycle_cover_source() -> MinimumVertexCover<SimpleGraph, i64> {
     MinimumVertexCover::new(
         SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 0), (2, 3), (3, 4)]),
         vec![4, 1, 3, 2, 5],
@@ -21,8 +21,9 @@ fn weighted_cycle_cover_source() -> MinimumVertexCover<SimpleGraph, i32> {
 #[test]
 fn test_minimumvertexcover_to_minimumfeedbackvertexset_closed_loop() {
     let source = weighted_cycle_cover_source();
-    let reduction: ReductionVCToFVS<i32> =
-        ReduceTo::<MinimumFeedbackVertexSet<i32>>::reduce_to(&source);
+    let reduction: ReductionVCToFVS<i64> =
+        ReduceTo::<MinimumFeedbackVertexSet<i64>>::reduce_to(&source)
+            .expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -34,8 +35,9 @@ fn test_minimumvertexcover_to_minimumfeedbackvertexset_closed_loop() {
 #[test]
 fn test_reduction_structure() {
     let source = weighted_cycle_cover_source();
-    let reduction: ReductionVCToFVS<i32> =
-        ReduceTo::<MinimumFeedbackVertexSet<i32>>::reduce_to(&source);
+    let reduction: ReductionVCToFVS<i64> =
+        ReduceTo::<MinimumFeedbackVertexSet<i64>>::reduce_to(&source)
+            .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.graph().num_vertices(), source.graph().num_vertices());
@@ -64,8 +66,9 @@ fn test_reduction_structure() {
 #[test]
 fn test_weight_preservation() {
     let source = weighted_cycle_cover_source();
-    let reduction: ReductionVCToFVS<i32> =
-        ReduceTo::<MinimumFeedbackVertexSet<i32>>::reduce_to(&source);
+    let reduction: ReductionVCToFVS<i64> =
+        ReduceTo::<MinimumFeedbackVertexSet<i64>>::reduce_to(&source)
+            .expect("reduction should succeed");
 
     assert_eq!(reduction.target_problem().weights(), source.weights());
 }
@@ -73,12 +76,15 @@ fn test_weight_preservation() {
 #[test]
 fn test_identity_solution_extraction() {
     let source = weighted_cycle_cover_source();
-    let reduction: ReductionVCToFVS<i32> =
-        ReduceTo::<MinimumFeedbackVertexSet<i32>>::reduce_to(&source);
+    let reduction: ReductionVCToFVS<i64> =
+        ReduceTo::<MinimumFeedbackVertexSet<i64>>::reduce_to(&source)
+            .expect("reduction should succeed");
 
     assert_eq!(
-        reduction.extract_solution(&[1, 0, 1, 0, 1]),
-        vec![1, 0, 1, 0, 1]
+        reduction
+            .extract_solution(&vec![true, false, true, false, true])
+            .unwrap(),
+        vec![true, false, true, false, true]
     );
 }
 
@@ -99,16 +105,18 @@ fn test_canonical_rule_example_spec_builds() {
         example.solutions[0].target_config
     );
 
-    let source: MinimumVertexCover<SimpleGraph, i32> =
+    let source: MinimumVertexCover<SimpleGraph, i64> =
         serde_json::from_value(example.source.instance.clone())
             .expect("source example deserializes");
-    let target: MinimumFeedbackVertexSet<i32> =
+    let target: MinimumFeedbackVertexSet<i64> =
         serde_json::from_value(example.target.instance.clone())
             .expect("target example deserializes");
     let solution = &example.solutions[0];
+    let source_config: Vec<bool> = serde_json::from_value(solution.source_config.clone()).unwrap();
+    let target_config: Vec<bool> = serde_json::from_value(solution.target_config.clone()).unwrap();
 
-    let source_metric = source.evaluate(&solution.source_config);
-    let target_metric = target.evaluate(&solution.target_config);
+    let source_metric = source.evaluate(&source_config).unwrap();
+    let target_metric = target.evaluate(&target_config).unwrap();
     assert!(
         source_metric.is_valid(),
         "source witness should be feasible"
@@ -119,12 +127,14 @@ fn test_canonical_rule_example_spec_builds() {
     );
 
     let best_source = BruteForce::new()
-        .find_witness(&source)
+        .solve(&source)
+        .unwrap()
         .expect("source example should have an optimum");
     let best_target = BruteForce::new()
-        .find_witness(&target)
+        .solve(&target)
+        .unwrap()
         .expect("target example should have an optimum");
 
-    assert_eq!(source_metric, source.evaluate(&best_source));
-    assert_eq!(target_metric, target.evaluate(&best_target));
+    assert_eq!(source_metric, source.evaluate(&best_source).unwrap());
+    assert_eq!(target_metric, target.evaluate(&best_target).unwrap());
 }
diff --git a/src/unit_tests/rules/minimumvertexcover_minimumhittingset.rs b/src/unit_tests/rules/minimumvertexcover_minimumhittingset.rs
index 9e7a7b6a3..e80a1fcd3 100644
--- a/src/unit_tests/rules/minimumvertexcover_minimumhittingset.rs
+++ b/src/unit_tests/rules/minimumvertexcover_minimumhittingset.rs
@@ -23,7 +23,8 @@ fn test_minimumvertexcover_to_minimumhittingset_closed_loop() {
         ),
         vec![One; 6],
     );
-    let reduction = ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem);
+    let reduction =
+        ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem).expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &vc_problem,
@@ -37,7 +38,8 @@ fn test_vc_to_hs_structure() {
     // Path graph 0-1-2 with edges (0,1) and (1,2)
     let vc_problem =
         MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![One; 3]);
-    let reduction = ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem);
+    let reduction =
+        ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem).expect("reduction should succeed");
     let hs_problem = reduction.target_problem();
 
     // Universe size = num_vertices = 3
@@ -57,7 +59,8 @@ fn test_vc_to_hs_triangle() {
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
         vec![One; 3],
     );
-    let reduction = ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem);
+    let reduction =
+        ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem).expect("reduction should succeed");
     let hs_problem = reduction.target_problem();
 
     assert_eq!(hs_problem.universe_size(), 3);
@@ -70,19 +73,20 @@ fn test_vc_to_hs_triangle() {
 
     // Solve both and verify they match
     let solver = BruteForce::new();
-    let vc_solutions = solver.find_all_witnesses(&vc_problem);
-    let hs_solutions = solver.find_all_witnesses(hs_problem);
+    let vc_solutions = solver.find_all_witnesses(&vc_problem).unwrap();
+    let hs_solutions = solver.find_all_witnesses(hs_problem).unwrap();
 
     // Minimum vertex cover of triangle = 2, same for hitting set
-    assert_eq!(vc_solutions[0].iter().filter(|&&x| x == 1).count(), 2);
-    assert_eq!(hs_solutions[0].iter().filter(|&&x| x == 1).count(), 2);
+    assert_eq!(vc_solutions[0].iter().filter(|&&x| x).count(), 2);
+    assert_eq!(hs_solutions[0].iter().filter(|&&x| x).count(), 2);
 }
 
 #[test]
 fn test_vc_to_hs_empty_graph() {
     // Graph with no edges: no sets to hit
     let vc_problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![]), vec![One; 3]);
-    let reduction = ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem);
+    let reduction =
+        ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem).expect("reduction should succeed");
     let hs_problem = reduction.target_problem();
 
     assert_eq!(hs_problem.universe_size(), 3);
@@ -96,7 +100,8 @@ fn test_vc_to_hs_star_graph() {
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]),
         vec![One; 4],
     );
-    let reduction = ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem);
+    let reduction =
+        ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem).expect("reduction should succeed");
     let hs_problem = reduction.target_problem();
 
     assert_eq!(hs_problem.universe_size(), 4);
@@ -111,8 +116,8 @@ fn test_vc_to_hs_star_graph() {
 
     // Minimum cover = just vertex 0
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&vc_problem);
-    assert_eq!(solutions[0], vec![1, 0, 0, 0]);
+    let solutions = solver.find_all_witnesses(&vc_problem).unwrap();
+    assert_eq!(solutions[0], vec![true, false, false, false]);
 }
 
 #[test]
@@ -120,9 +125,10 @@ fn test_vc_to_hs_solution_extraction() {
     // Verify that extract_solution is identity (1:1 correspondence)
     let vc_problem =
         MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![One; 3]);
-    let reduction = ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem);
+    let reduction =
+        ReduceTo::<MinimumHittingSet>::reduce_to(&vc_problem).expect("reduction should succeed");
 
-    let target_solution = vec![0, 1, 0];
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![0, 1, 0]);
+    let target_solution = vec![false, true, false];
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![false, true, false]);
 }
diff --git a/src/unit_tests/rules/minimumvertexcover_minimummaximalmatching.rs b/src/unit_tests/rules/minimumvertexcover_minimummaximalmatching.rs
index 624d75f24..8677416d5 100644
--- a/src/unit_tests/rules/minimumvertexcover_minimummaximalmatching.rs
+++ b/src/unit_tests/rules/minimumvertexcover_minimummaximalmatching.rs
@@ -1,7 +1,8 @@
 use crate::models::graph::{MinimumMaximalMatching, MinimumVertexCover};
 use crate::rules::{ReductionGraph, ReductionMode};
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
+use crate::traits::Problem;
 use crate::types::{Min, One};
 
 fn graph_from_mask(n: usize, mask: usize) -> SimpleGraph {
@@ -25,8 +26,14 @@ fn test_minimumvertexcover_to_minimummaximalmatching_c5_gap() {
     let mmm = MinimumMaximalMatching::new(graph);
     let solver = BruteForce::new();
 
-    assert_eq!(solver.solve(&mvc), Min(Some(3)));
-    assert_eq!(solver.solve(&mmm), Min(Some(2)));
+    assert_eq!(
+        mvc.evaluate(&solver.solve(&mvc).unwrap().unwrap()).unwrap(),
+        Min(Some(3))
+    );
+    assert_eq!(
+        mmm.evaluate(&solver.solve(&mmm).unwrap().unwrap()).unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
@@ -39,8 +46,10 @@ fn test_minimumvertexcover_to_minimummaximalmatching_forward_bound_on_small_grap
             let graph = graph_from_mask(n, mask);
             let mvc = MinimumVertexCover::new(graph.clone(), vec![One; n]);
             let mmm = MinimumMaximalMatching::new(graph);
-            let mvc_value = solver.solve(&mvc);
-            let mmm_value = solver.solve(&mmm);
+            let mvc_value_solution = solver.solve(&mvc).unwrap().unwrap();
+            let mvc_value = mvc.evaluate(&mvc_value_solution).unwrap();
+            let mmm_value_solution = solver.solve(&mmm).unwrap().unwrap();
+            let mmm_value = mmm.evaluate(&mmm_value_solution).unwrap();
 
             let Min(Some(mvc_size)) = mvc_value else {
                 panic!("MinimumVertexCover should always have an optimal solution");
@@ -48,10 +57,6 @@ fn test_minimumvertexcover_to_minimummaximalmatching_forward_bound_on_small_grap
             let Min(Some(mmm_size)) = mmm_value else {
                 panic!("MinimumMaximalMatching should always have an optimal solution");
             };
-            let mvc_size: usize = mvc_size
-                .try_into()
-                .expect("unit-weight MVC optimum should fit into usize");
-
             assert!(
                 mmm_size <= mvc_size,
                 "expected mmm(G) <= mvc(G) for n={n}, mask={mask:#b}, got {mmm_size} > {mvc_size}",
diff --git a/src/unit_tests/rules/minimumvertexcover_minimumsetcovering.rs b/src/unit_tests/rules/minimumvertexcover_minimumsetcovering.rs
index 1214555e9..11accfa1f 100644
--- a/src/unit_tests/rules/minimumvertexcover_minimumsetcovering.rs
+++ b/src/unit_tests/rules/minimumvertexcover_minimumsetcovering.rs
@@ -10,8 +10,9 @@ fn test_minimumvertexcover_to_minimumsetcovering_closed_loop() {
     // Vertex 1 covers edges 0 and 1
     // Vertex 2 covers edge 1
     let vc_problem =
-        MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i32; 3]);
-    let reduction = ReduceTo::<MinimumSetCovering<i32>>::reduce_to(&vc_problem);
+        MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1i64; 3]);
+    let reduction = ReduceTo::<MinimumSetCovering<i64>>::reduce_to(&vc_problem)
+        .expect("reduction should succeed");
     let sc_problem = reduction.target_problem();
 
     // Check the sets are constructed correctly
@@ -32,9 +33,10 @@ fn test_vc_to_sc_triangle() {
     // Edge indices: (0,1)->0, (1,2)->1, (0,2)->2
     let vc_problem = MinimumVertexCover::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
-    let reduction = ReduceTo::<MinimumSetCovering<i32>>::reduce_to(&vc_problem);
+    let reduction = ReduceTo::<MinimumSetCovering<i64>>::reduce_to(&vc_problem)
+        .expect("reduction should succeed");
     let sc_problem = reduction.target_problem();
 
     assert_eq!(sc_problem.universe_size(), 3);
@@ -52,7 +54,8 @@ fn test_vc_to_sc_weighted() {
     // Weighted problem: weights should be preserved
     let vc_problem =
         MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![10, 1, 10]);
-    let reduction = ReduceTo::<MinimumSetCovering<i32>>::reduce_to(&vc_problem);
+    let reduction = ReduceTo::<MinimumSetCovering<i64>>::reduce_to(&vc_problem)
+        .expect("reduction should succeed");
     let sc_problem = reduction.target_problem();
 
     // Weights should be preserved - access via weights_ref method on the problem
@@ -60,19 +63,20 @@ fn test_vc_to_sc_weighted() {
 
     // Solve both ways
     let solver = BruteForce::new();
-    let vc_solutions = solver.find_all_witnesses(&vc_problem);
-    let sc_solutions = solver.find_all_witnesses(sc_problem);
+    let vc_solutions = solver.find_all_witnesses(&vc_problem).unwrap();
+    let sc_solutions = solver.find_all_witnesses(sc_problem).unwrap();
 
     // Both should select vertex 1 (weight 1)
-    assert_eq!(vc_solutions[0], vec![0, 1, 0]);
-    assert_eq!(sc_solutions[0], vec![0, 1, 0]);
+    assert_eq!(vc_solutions[0], vec![false, true, false]);
+    assert_eq!(sc_solutions[0], vec![false, true, false]);
 }
 
 #[test]
 fn test_vc_to_sc_empty_graph() {
     // Graph with no edges
-    let vc_problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![]), vec![1i32; 3]);
-    let reduction = ReduceTo::<MinimumSetCovering<i32>>::reduce_to(&vc_problem);
+    let vc_problem = MinimumVertexCover::new(SimpleGraph::new(3, vec![]), vec![1i64; 3]);
+    let reduction = ReduceTo::<MinimumSetCovering<i64>>::reduce_to(&vc_problem)
+        .expect("reduction should succeed");
     let sc_problem = reduction.target_problem();
 
     assert_eq!(sc_problem.universe_size(), 0);
@@ -90,9 +94,10 @@ fn test_vc_to_sc_star_graph() {
     // Edges: (0,1), (0,2), (0,3)
     let vc_problem = MinimumVertexCover::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
-    let reduction = ReduceTo::<MinimumSetCovering<i32>>::reduce_to(&vc_problem);
+    let reduction = ReduceTo::<MinimumSetCovering<i64>>::reduce_to(&vc_problem)
+        .expect("reduction should succeed");
     let sc_problem = reduction.target_problem();
 
     // Vertex 0 should cover all 3 edges
@@ -104,8 +109,8 @@ fn test_vc_to_sc_star_graph() {
 
     // Minimum cover should be just vertex 0
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(&vc_problem);
-    assert_eq!(solutions[0], vec![1, 0, 0, 0]);
+    let solutions = solver.find_all_witnesses(&vc_problem).unwrap();
+    assert_eq!(solutions[0], vec![true, false, false, false]);
 }
 
 #[test]
@@ -120,18 +125,23 @@ fn test_jl_parity_vc_to_setcovering() {
     let nv = inst["num_vertices"].as_u64().unwrap() as usize;
     let source = MinimumVertexCover::new(
         SimpleGraph::new(nv, jl_parse_edges(inst)),
-        jl_parse_i32_vec(&inst["weights"]),
+        jl_parse_i64_vec(&inst["weights"]),
     );
-    let result = ReduceTo::<MinimumSetCovering<i32>>::reduce_to(&source);
+    let result =
+        ReduceTo::<MinimumSetCovering<i64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity VC->SetCovering",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -147,17 +157,22 @@ fn test_jl_parity_rule_vc_to_setcovering() {
     let nv = inst["num_vertices"].as_u64().unwrap() as usize;
     let source = MinimumVertexCover::new(
         SimpleGraph::new(nv, jl_parse_edges(inst)),
-        jl_parse_i32_vec(&inst["weights"]),
+        jl_parse_i64_vec(&inst["weights"]),
     );
-    let result = ReduceTo::<MinimumSetCovering<i32>>::reduce_to(&source);
+    let result =
+        ReduceTo::<MinimumSetCovering<i64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity rule VC->SetCovering",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
diff --git a/src/unit_tests/rules/minimumvertexcover_minimumweightandorgraph.rs b/src/unit_tests/rules/minimumvertexcover_minimumweightandorgraph.rs
index 641468712..6b93320a5 100644
--- a/src/unit_tests/rules/minimumvertexcover_minimumweightandorgraph.rs
+++ b/src/unit_tests/rules/minimumvertexcover_minimumweightandorgraph.rs
@@ -12,7 +12,7 @@ use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
 
-fn weighted_path_source() -> MinimumVertexCover<SimpleGraph, i32> {
+fn weighted_path_source() -> MinimumVertexCover<SimpleGraph, i64> {
     MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![4, 1, 3])
 }
 
@@ -20,7 +20,7 @@ fn weighted_path_source() -> MinimumVertexCover<SimpleGraph, i32> {
 fn test_minimumvertexcover_to_minimumweightandorgraph_closed_loop() {
     let source = issue_example_source();
     let reduction: ReductionVCToAndOrGraph =
-        ReduceTo::<MinimumWeightAndOrGraph>::reduce_to(&source);
+        ReduceTo::<MinimumWeightAndOrGraph>::reduce_to(&source).expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -33,7 +33,7 @@ fn test_minimumvertexcover_to_minimumweightandorgraph_closed_loop() {
 fn test_reduction_structure() {
     let source = issue_example_source();
     let reduction: ReductionVCToAndOrGraph =
-        ReduceTo::<MinimumWeightAndOrGraph>::reduce_to(&source);
+        ReduceTo::<MinimumWeightAndOrGraph>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 9);
@@ -74,14 +74,20 @@ fn test_reduction_structure() {
 fn test_weighted_vertices_are_charged_on_sink_arcs() {
     let source = weighted_path_source();
     let reduction: ReductionVCToAndOrGraph =
-        ReduceTo::<MinimumWeightAndOrGraph>::reduce_to(&source);
+        ReduceTo::<MinimumWeightAndOrGraph>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let target_solution = vec![1, 1, 0, 1, 1, 0, 0, 1, 0];
-    assert_eq!(source.evaluate(&[0, 1, 0]), Min(Some(1)));
-    assert_eq!(target.evaluate(&target_solution), Min(Some(5)));
+    let target_solution = vec![true, true, false, true, true, false, false, true, false];
+    assert_eq!(
+        source.evaluate(&vec![false, true, false]).unwrap(),
+        Min(Some(1))
+    );
+    assert_eq!(target.evaluate(&target_solution).unwrap(), Min(Some(5)));
     assert_eq!(target.arc_weights(), &[1, 1, 1, 1, 1, 1, 4, 1, 3]);
-    assert_eq!(reduction.extract_solution(&target_solution), vec![0, 1, 0]);
+    assert_eq!(
+        reduction.extract_solution(&target_solution).unwrap(),
+        vec![false, true, false]
+    );
 }
 
 #[cfg(feature = "example-db")]
@@ -97,29 +103,33 @@ fn test_canonical_rule_example_spec_builds() {
     assert_eq!(example.target.problem, "MinimumWeightAndOrGraph");
     assert_eq!(example.solutions.len(), 1);
 
-    let source: MinimumVertexCover<SimpleGraph, i32> =
+    let source: MinimumVertexCover<SimpleGraph, i64> =
         serde_json::from_value(example.source.instance.clone())
             .expect("source example deserializes");
     let target: MinimumWeightAndOrGraph = serde_json::from_value(example.target.instance.clone())
         .expect("target example deserializes");
     let solution = &example.solutions[0];
+    let source_config: Vec<bool> = serde_json::from_value(solution.source_config.clone()).unwrap();
+    let target_config: Vec<bool> = serde_json::from_value(solution.target_config.clone()).unwrap();
 
-    assert_eq!(source.evaluate(&solution.source_config), Min(Some(1)));
-    assert_eq!(target.evaluate(&solution.target_config), Min(Some(5)));
+    assert_eq!(source.evaluate(&source_config).unwrap(), Min(Some(1)));
+    assert_eq!(target.evaluate(&target_config).unwrap(), Min(Some(5)));
 
     let best_source = BruteForce::new()
-        .find_witness(&source)
+        .solve(&source)
+        .unwrap()
         .expect("source example should have an optimum");
     let best_target = BruteForce::new()
-        .find_witness(&target)
+        .solve(&target)
+        .unwrap()
         .expect("target example should have an optimum");
 
     assert_eq!(
-        source.evaluate(&solution.source_config),
-        source.evaluate(&best_source)
+        source.evaluate(&source_config).unwrap(),
+        source.evaluate(&best_source).unwrap()
     );
     assert_eq!(
-        target.evaluate(&solution.target_config),
-        target.evaluate(&best_target)
+        target.evaluate(&target_config).unwrap(),
+        target.evaluate(&best_target).unwrap()
     );
 }
diff --git a/src/unit_tests/rules/minimumvertexcover_qubo.rs b/src/unit_tests/rules/minimumvertexcover_qubo.rs
index 8b4dd1711..98c1d4935 100644
--- a/src/unit_tests/rules/minimumvertexcover_qubo.rs
+++ b/src/unit_tests/rules/minimumvertexcover_qubo.rs
@@ -1,32 +1,34 @@
 use crate::models::algebraic::QUBO;
 use crate::models::graph::MinimumVertexCover;
-use crate::rules::{Minimize, ReductionChain, ReductionGraph, ReductionPath};
+use crate::rules::{ReductionChain, ReductionGraph, ReductionPath};
 use crate::solvers::BruteForce;
-use crate::topology::{Graph, SimpleGraph};
+use crate::solvers::BruteForceProblem as _;
+use crate::topology::SimpleGraph;
 use crate::traits::Problem;
-use crate::types::{Min, ProblemSize};
+use crate::types::Min;
 
 fn reduce_vc_to_qubo(
-    problem: &MinimumVertexCover<SimpleGraph, i32>,
+    problem: &MinimumVertexCover<SimpleGraph, i64>,
 ) -> (ReductionPath, ReductionChain) {
     let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+    let src = ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
     let dst = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
     let path = graph
-        .find_cheapest_path(
-            "MinimumVertexCover",
-            &src,
-            "QUBO",
-            &dst,
-            &ProblemSize::new(vec![
-                ("num_vertices", problem.graph().num_vertices()),
-                ("num_edges", problem.graph().num_edges()),
-            ]),
-            &Minimize("num_vars"),
-        )
-        .expect("Should find path MinimumVertexCover -> QUBO");
+        .find_all_paths("MinimumVertexCover", &src, "QUBO", &dst)
+        .into_iter()
+        .find(|path| {
+            path.type_names()
+                == [
+                    "MinimumVertexCover",
+                    "MaximumIndependentSet",
+                    "MaximumSetPacking",
+                    "QUBO",
+                ]
+        })
+        .expect("expected explicit MaximumIndependentSet route");
     let chain = graph
         .reduce_along_path(&path, problem as &dyn std::any::Any)
+        .expect("MinimumVertexCover -> QUBO reduction should not fail")
         .expect("Should reduce MinimumVertexCover to QUBO along path");
     (path, chain)
 }
@@ -35,7 +37,7 @@ fn reduce_vc_to_qubo(
 fn test_minimumvertexcover_to_qubo_via_path_closed_loop() {
     let problem = MinimumVertexCover::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (0, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let (path, chain) = reduce_vc_to_qubo(&problem);
     let qubo: &QUBO<f64> = chain.target_problem();
@@ -56,11 +58,11 @@ fn test_minimumvertexcover_to_qubo_via_path_closed_loop() {
     assert_eq!(qubo.num_variables(), 4);
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
     for sol in &qubo_solutions {
-        let extracted = chain.extract_solution(sol);
-        assert!(problem.evaluate(&extracted).is_valid());
-        assert_eq!(extracted.iter().filter(|&&x| x == 1).count(), 2);
+        let extracted = chain.extract_solution(sol).unwrap();
+        assert!(problem.evaluate(&extracted).unwrap().is_valid());
+        assert_eq!(extracted.iter().filter(|&&x| x).count(), 2);
     }
 }
 
@@ -73,19 +75,20 @@ fn test_minimumvertexcover_to_qubo_via_path_weighted() {
 
     let solver = BruteForce::new();
     let qubo_solution = solver
-        .find_witness(qubo)
+        .solve(qubo)
+        .unwrap()
         .expect("QUBO should be solvable via path");
-    let extracted = chain.extract_solution(&qubo_solution);
+    let extracted = chain.extract_solution(&qubo_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
-    assert_eq!(extracted, vec![0, 1, 0]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
+    assert_eq!(extracted, vec![false, true, false]);
 }
 
 #[test]
 fn test_minimumvertexcover_to_qubo_via_path_star_graph() {
     let problem = MinimumVertexCover::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]),
-        vec![1i32; 4],
+        vec![1i64; 4],
     );
     let (_, chain) = reduce_vc_to_qubo(&problem);
     let qubo: &QUBO<f64> = chain.target_problem();
@@ -93,9 +96,12 @@ fn test_minimumvertexcover_to_qubo_via_path_star_graph() {
     assert_eq!(qubo.num_variables(), 4);
 
     let solver = BruteForce::new();
-    let qubo_solution = solver.find_witness(qubo).expect("QUBO should be solvable");
-    let extracted = chain.extract_solution(&qubo_solution);
+    let qubo_solution = solver
+        .solve(qubo)
+        .unwrap()
+        .expect("QUBO should be solvable");
+    let extracted = chain.extract_solution(&qubo_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
-    assert_eq!(extracted.iter().filter(|&&x| x == 1).count(), 1);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
+    assert_eq!(extracted.iter().filter(|&&x| x).count(), 1);
 }
diff --git a/src/unit_tests/rules/minimumweightdecoding_ilp.rs b/src/unit_tests/rules/minimumweightdecoding_ilp.rs
index 5f589bf46..09eb28337 100644
--- a/src/unit_tests/rules/minimumweightdecoding_ilp.rs
+++ b/src/unit_tests/rules/minimumweightdecoding_ilp.rs
@@ -34,18 +34,19 @@ fn infeasible_instance() -> MinimumWeightDecoding {
 #[test]
 fn test_minimumweightdecoding_to_ilp_structure() {
     let problem = issue_instance();
-    let reduction: ReductionMinimumWeightDecodingToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMinimumWeightDecodingToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 4 cols + 3 rows = 7 variables
-    assert_eq!(ilp.num_vars, 7);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 7);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
     // Objective: 4 terms (one per x_j)
-    assert_eq!(ilp.objective.len(), 4);
+    assert_eq!(ilp.objective().len(), 4);
 
     // Constraints: 3 equality + 4 binary bounds = 7
-    assert_eq!(ilp.constraints.len(), 7);
+    assert_eq!(ilp.constraints().len(), 7);
 }
 
 #[test]
@@ -53,18 +54,20 @@ fn test_minimumweightdecoding_to_ilp_closed_loop() {
     let problem = issue_instance();
     let bf = BruteForce::new();
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("issue instance has optimal");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
     assert_eq!(bf_value, Min(Some(1)));
 
-    let reduction: ReductionMinimumWeightDecodingToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMinimumWeightDecodingToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let ilp_value = problem.evaluate(&extracted);
+    let ilp_value = problem.evaluate(&extracted).unwrap();
     assert_eq!(ilp_value, bf_value);
 }
 
@@ -73,25 +76,28 @@ fn test_minimumweightdecoding_to_ilp_small_closed_loop() {
     let problem = small_instance();
     let bf = BruteForce::new();
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("small instance has optimal");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
     assert_eq!(bf_value, Min(Some(1)));
 
-    let reduction: ReductionMinimumWeightDecodingToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMinimumWeightDecodingToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), bf_value);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), bf_value);
 }
 
 #[test]
 fn test_minimumweightdecoding_to_ilp_infeasible() {
     let problem = infeasible_instance();
-    let reduction: ReductionMinimumWeightDecodingToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMinimumWeightDecodingToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible instance should produce infeasible ILP"
     );
 }
@@ -99,14 +105,16 @@ fn test_minimumweightdecoding_to_ilp_infeasible() {
 #[test]
 fn test_minimumweightdecoding_to_ilp_bf_vs_ilp() {
     let problem = issue_instance();
-    let reduction: ReductionMinimumWeightDecodingToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMinimumWeightDecodingToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_minimumweightdecoding_to_ilp_extract_solution() {
     let problem = issue_instance();
-    let reduction: ReductionMinimumWeightDecodingToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMinimumWeightDecodingToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manually construct a valid target solution: x=[0,0,1,0], k=[0,0,0]
     // (k_i values are the integer slack from mod-2)
@@ -114,8 +122,8 @@ fn test_minimumweightdecoding_to_ilp_extract_solution() {
     // Row 1: H[1][2]=1 → sum=1, s=1 → 1-1=0 → k_1=0 ✓
     // Row 2: H[2][2]=0 → sum=0, s=0 → 0-0=0 → k_2=0 ✓
     let target_solution = vec![0, 0, 1, 0, 0, 0, 0];
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     assert_eq!(extracted.len(), 4);
-    assert_eq!(extracted, vec![0, 0, 1, 0]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
+    assert_eq!(extracted, vec![false, false, true, false]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
diff --git a/src/unit_tests/rules/minmaxmulticenter_ilp.rs b/src/unit_tests/rules/minmaxmulticenter_ilp.rs
index 0bf3b8787..743658bfb 100644
--- a/src/unit_tests/rules/minmaxmulticenter_ilp.rs
+++ b/src/unit_tests/rules/minmaxmulticenter_ilp.rs
@@ -11,24 +11,25 @@ fn test_reduction_creates_valid_ilp() {
     // 3-vertex path: 0 - 1 - 2, unit weights/lengths, K=1
     let problem = MinMaxMulticenter::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-        vec![1i32; 3],
-        vec![1i32; 2],
+        vec![1i64; 3],
+        vec![1i64; 2],
         1,
     );
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // num_vars = n + n^2 + 1 = 3 + 9 + 1 = 13
-    assert_eq!(ilp.num_vars, 13, "n + n^2 + 1 variables");
+    assert_eq!(ilp.num_vars(), 13, "n + n^2 + 1 variables");
     // num_constraints = 1 (cardinality) + n (assignment) + n^2 (link) + n (x bounds) + n^2 (y bounds) + 1 (z bound) + n (minimax)
     //                 = 1 + 3 + 9 + 3 + 9 + 1 + 3 = 29
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         29,
         "cardinality + assignment + link + binary bounds + z bound + minimax constraints"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
     // Objective should minimize z (last variable)
-    assert_eq!(ilp.objective, vec![(12, 1.0)]);
+    assert_eq!(ilp.objective(), vec![(12, 1)]);
 }
 
 #[test]
@@ -37,27 +38,28 @@ fn test_minmaxmulticenter_to_ilp_bf_vs_ilp() {
     // Optimal: place center at vertex 1, max distance = 1
     let problem = MinMaxMulticenter::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-        vec![1i32; 3],
-        vec![1i32; 2],
+        vec![1i64; 3],
+        vec![1i64; 2],
         1,
     );
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_witness = bf.find_witness(&problem).expect("should have optimal");
-    assert_eq!(problem.evaluate(&bf_witness), Min(Some(1)));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should have optimal");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Min(Some(1)));
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
         extracted.len(),
         3,
         "extracted solution has one entry per vertex"
     );
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -65,11 +67,12 @@ fn test_solution_extraction() {
     // 3-vertex path: center at vertex 1
     let problem = MinMaxMulticenter::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-        vec![1i32; 3],
-        vec![1i32; 2],
+        vec![1i64; 3],
+        vec![1i64; 2],
         1,
     );
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manually construct a valid ILP solution:
     // x = [0, 1, 0]; each vertex assigned to center 1; z = 1
@@ -80,9 +83,9 @@ fn test_solution_extraction() {
         0, 1, 0, // y_{2,0}, y_{2,1}, y_{2,2}
         1, // z
     ];
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![0, 1, 0]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(1)));
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![false, true, false]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(1)));
 }
 
 #[test]
@@ -90,36 +93,38 @@ fn test_minmaxmulticenter_to_ilp_weighted() {
     // Single weighted edge with length 100. With k=1, optimal = 100.
     let problem = MinMaxMulticenter::new(
         SimpleGraph::new(2, vec![(0, 1)]),
-        vec![1i32; 2],
-        vec![100i32],
+        vec![1i64; 2],
+        vec![100i64],
         1,
     );
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should have optimal");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_witness = bf.solve(&problem).unwrap().expect("should have optimal");
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
     assert_eq!(bf_value, Min(Some(100)));
 
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(100)));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(100)));
 }
 
 #[test]
 fn test_minmaxmulticenter_to_ilp_trivial() {
     // Single vertex, K=1: the only vertex is the center, distance = 0
-    let problem = MinMaxMulticenter::new(SimpleGraph::new(1, vec![]), vec![5i32], vec![], 1);
-    let reduction: ReductionMMCToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let problem = MinMaxMulticenter::new(SimpleGraph::new(1, vec![]), vec![5i64], vec![], 1);
+    let reduction: ReductionMMCToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // num_vars = 1 + 1 + 1 = 3
-    assert_eq!(ilp.num_vars, 3);
+    assert_eq!(ilp.num_vars(), 3);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted.len(), 1);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(0)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(0)));
 }
diff --git a/src/unit_tests/rules/mixedchinesepostman_ilp.rs b/src/unit_tests/rules/mixedchinesepostman_ilp.rs
index cda1e1b40..46e5817de 100644
--- a/src/unit_tests/rules/mixedchinesepostman_ilp.rs
+++ b/src/unit_tests/rules/mixedchinesepostman_ilp.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::models::algebraic::ILP;
 use crate::rules::ReduceTo;
-use crate::solvers::{BruteForce, ILPSolver, Solver};
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::MixedGraph;
 use crate::traits::Problem;
 
@@ -14,17 +14,18 @@ fn test_mixedchinesepostman_to_ilp_closed_loop() {
         vec![1, 1],
     );
     let direct = BruteForce::new()
-        .find_witness(&source)
+        .solve(&source)
+        .unwrap()
         .expect("source instance should have an optimal solution");
-    assert!(source.evaluate(&direct).0.is_some());
+    assert!(source.evaluate(&direct).unwrap().0.is_some());
 
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(source.evaluate(&extracted).0.is_some());
+    assert!(source.evaluate(&extracted).unwrap().0.is_some());
 }
 
 #[test]
@@ -36,14 +37,16 @@ fn test_mixedchinesepostman_to_ilp_bf_vs_ilp() {
         vec![1, 1],
     );
 
-    let bf_value = BruteForce::new().solve(&source);
+    let bf_value_solution = BruteForce::new().solve(&source).unwrap().unwrap();
 
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let bf_value = source.evaluate(&bf_value_solution).unwrap();
+
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = source.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = source.evaluate(&extracted).unwrap();
 
     assert_eq!(
         ilp_value, bf_value,
@@ -60,17 +63,37 @@ fn test_mixedchinesepostman_to_ilp_weighted() {
         vec![3, 1],
     );
 
-    let bf_value = BruteForce::new().solve(&source);
+    let bf_value_solution = BruteForce::new().solve(&source).unwrap().unwrap();
+
+    let bf_value = source.evaluate(&bf_value_solution).unwrap();
 
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = source.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = source.evaluate(&extracted).unwrap();
 
     assert_eq!(
         ilp_value, bf_value,
         "ILP solution should match brute-force optimal for weighted instance"
     );
 }
+
+#[test]
+fn test_mixedchinesepostman_to_ilp_with_isolated_vertices() {
+    let source = MixedChinesePostman::new(
+        MixedGraph::new(
+            8,
+            vec![(5, 3), (1, 4), (0, 1), (2, 4), (0, 5)],
+            vec![(4, 2), (0, 4), (0, 2), (1, 3)],
+        ),
+        vec![4, 5, 1, 12, 9],
+        vec![6, 1, 13, 7],
+    );
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+    let ilp_solution = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+
+    assert_eq!(source.evaluate(&extracted).unwrap().0, Some(69));
+}
diff --git a/src/unit_tests/rules/monochromatictriangle_ilp.rs b/src/unit_tests/rules/monochromatictriangle_ilp.rs
index f55c96ee4..0dbd944fd 100644
--- a/src/unit_tests/rules/monochromatictriangle_ilp.rs
+++ b/src/unit_tests/rules/monochromatictriangle_ilp.rs
@@ -15,41 +15,47 @@ fn k4_instance() -> MonochromaticTriangle<SimpleGraph> {
 #[test]
 fn test_monochromatic_triangle_to_ilp_structure() {
     let problem = k4_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 6);
-    assert_eq!(ilp.constraints.len(), 8);
-    assert_eq!(ilp.objective, vec![]);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 6);
+    assert_eq!(ilp.constraints().len(), 8);
+    assert_eq!(ilp.objective(), vec![]);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_monochromatic_triangle_to_ilp_constraint_pairs_on_single_triangle() {
     let problem = MonochromaticTriangle::new(SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 3);
-    assert_eq!(ilp.constraints.len(), 2);
-    assert_eq!(ilp.constraints[0].rhs, 1.0);
-    assert_eq!(ilp.constraints[1].rhs, 2.0);
-    assert_eq!(ilp.constraints[0].terms.len(), 3);
-    assert_eq!(ilp.constraints[1].terms.len(), 3);
+    assert_eq!(ilp.num_vars(), 3);
+    assert_eq!(ilp.constraints().len(), 2);
+    assert_eq!(ilp.constraints()[0].rhs(), 1);
+    assert_eq!(ilp.constraints()[1].rhs(), 2);
+    assert_eq!(ilp.constraints()[0].terms().len(), 3);
+    assert_eq!(ilp.constraints()[1].terms().len(), 3);
 }
 
 #[test]
 fn test_monochromatic_triangle_to_ilp_closed_loop() {
     let problem = k4_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("K4 should admit a monochromatic-triangle-free 2-edge-coloring");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, ilp_solution);
-    assert!(problem.evaluate(&extracted));
+    assert_eq!(
+        extracted,
+        ilp_solution
+            .iter()
+            .map(|&value| value != 0)
+            .collect::<Vec<_>>()
+    );
+    assert!(problem.evaluate(&extracted).unwrap());
 }
 
 #[test]
@@ -61,10 +67,10 @@ fn test_monochromatic_triangle_to_ilp_infeasible_k6() {
         }
     }
     let problem = MonochromaticTriangle::new(SimpleGraph::new(6, edges));
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "K6 should be infeasible by R(3,3)=6"
     );
 }
@@ -72,11 +78,66 @@ fn test_monochromatic_triangle_to_ilp_infeasible_k6() {
 #[test]
 fn test_monochromatic_triangle_to_ilp_extract_solution_identity() {
     let problem = k4_instance();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let coloring = vec![0, 0, 1, 1, 0, 1];
 
-    let extracted = reduction.extract_solution(&coloring);
+    let extracted = reduction.extract_solution(&coloring).unwrap();
+
+    assert_eq!(extracted, vec![false, false, true, true, false, true]);
+    assert!(problem.evaluate(&extracted).unwrap());
+}
+
+#[test]
+fn test_monochromatictriangle_to_ilp_preserves_every_small_coloring() {
+    use crate::traits::Problem;
+    // Every labelled subgraph of K5 and every edge colouring: 3^10 cases.
+    let pairs: Vec<_> = (0..5)
+        .flat_map(|u| (u + 1..5).map(move |v| (u, v)))
+        .collect();
+    for mask in 0..(1 << 10) {
+        let edges: Vec<_> = pairs
+            .iter()
+            .enumerate()
+            .filter_map(|(i, &edge)| (mask & (1 << i) != 0).then_some(edge))
+            .collect();
+        let source = MonochromaticTriangle::new(SimpleGraph::new(5, edges));
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+        for bits in 0..(1 << source.num_edges()) {
+            let coloring: Vec<_> = (0..source.num_edges())
+                .map(|i| bits & (1 << i) != 0)
+                .collect();
+            let assignment = coloring.iter().map(|&value| i64::from(value)).collect();
+            assert_eq!(
+                source.evaluate(&coloring).unwrap().0,
+                reduction
+                    .target_problem()
+                    .evaluate(&assignment)
+                    .unwrap()
+                    .is_valid()
+            );
+        }
+    }
+}
 
-    assert_eq!(extracted, coloring);
-    assert!(problem.evaluate(&extracted));
+#[test]
+fn test_monochromatictriangle_to_ilp_shared_k5_all_colorings() {
+    let mut edges = vec![(0, 1), (2, 3), (4, 5), (4, 6), (5, 6)];
+    edges.extend((0..4).flat_map(|u| (4..7).map(move |v| (u, v))));
+    let source = MonochromaticTriangle::new(SimpleGraph::new(7, edges));
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    assert_eq!(reduction.target_problem().num_constraints(), 49);
+    for bits in 0..(1 << source.num_edges()) {
+        let coloring: Vec<_> = (0..source.num_edges())
+            .map(|i| bits & (1 << i) != 0)
+            .collect();
+        let assignment = coloring.iter().map(|&value| i64::from(value)).collect();
+        assert_eq!(
+            source.evaluate(&coloring).unwrap().0,
+            reduction
+                .target_problem()
+                .evaluate(&assignment)
+                .unwrap()
+                .is_valid()
+        );
+    }
 }
diff --git a/src/unit_tests/rules/multiplechoicebranching_ilp.rs b/src/unit_tests/rules/multiplechoicebranching_ilp.rs
new file mode 100644
index 000000000..6166a1180
--- /dev/null
+++ b/src/unit_tests/rules/multiplechoicebranching_ilp.rs
@@ -0,0 +1,63 @@
+use super::*;
+use crate::solvers::{BruteForce, ILPSolver};
+use crate::topology::DirectedGraph;
+use crate::traits::Problem;
+
+#[test]
+fn test_multiplechoicebranching_to_ilp_closed_loop() {
+    let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0), (0, 2)]);
+    for threshold in -2..=5 {
+        let problem = MultipleChoiceBranching::new(
+            graph.clone(),
+            vec![2, -1, 3, 1],
+            vec![vec![0, 2], vec![1, 3]],
+            threshold,
+        );
+        let expected = BruteForce::new().solve(&problem).unwrap();
+        let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).unwrap();
+        match expected {
+            Some(_) => {
+                let target = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+                let actual = reduction.extract_solution(&target).unwrap();
+                assert!(problem.evaluate(&actual).unwrap().0);
+            }
+            None => assert!(ILPSolver::new().solve(reduction.target_problem()).is_err()),
+        }
+    }
+}
+
+#[test]
+fn test_multiplechoicebranching_to_ilp_rejects_forced_cycle() {
+    let problem = MultipleChoiceBranching::new(
+        DirectedGraph::new(2, vec![(0, 1), (1, 0)]),
+        vec![1, 1],
+        vec![vec![0], vec![1]],
+        2,
+    );
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).unwrap();
+    assert!(ILPSolver::new().solve(reduction.target_problem()).is_err());
+}
+
+#[test]
+fn test_multiplechoicebranching_to_ilp_size() {
+    let problem = MultipleChoiceBranching::new(
+        DirectedGraph::new(3, vec![(0, 1), (1, 2), (0, 2), (2, 2)]),
+        vec![1, 2, 3, 4],
+        vec![vec![0, 1], vec![2, 3]],
+        3,
+    );
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).unwrap();
+    assert_eq!(reduction.target_problem().num_vars(), 7);
+    assert_eq!(reduction.target_problem().num_constraints(), 17);
+}
+
+#[test]
+fn test_multiplechoicebranching_to_ilp_empty_graph() {
+    let problem = MultipleChoiceBranching::new(DirectedGraph::new(0, vec![]), vec![], vec![], 0);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).unwrap();
+    let target = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    assert_eq!(
+        reduction.extract_solution(&target).unwrap(),
+        Vec::<bool>::new()
+    );
+}
diff --git a/src/unit_tests/rules/multiplecopyfileallocation_ilp.rs b/src/unit_tests/rules/multiplecopyfileallocation_ilp.rs
index 7c4cbfcd1..27d7b9ce5 100644
--- a/src/unit_tests/rules/multiplecopyfileallocation_ilp.rs
+++ b/src/unit_tests/rules/multiplecopyfileallocation_ilp.rs
@@ -13,17 +13,18 @@ fn test_reduction_creates_valid_ilp() {
         vec![1, 1, 1],
         vec![5, 5, 5],
     );
-    let reduction: ReductionMCFAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMCFAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // num_vars = n + n^2 = 3 + 9 = 12
-    assert_eq!(ilp.num_vars, 12, "n + n^2 variables");
+    assert_eq!(ilp.num_vars(), 12, "n + n^2 variables");
     // num_constraints = n (assignment) + n^2 (capacity) = 3 + 9 = 12
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         12,
         "assignment + capacity constraints"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -36,23 +37,24 @@ fn test_multiplecopyfileallocation_to_ilp_bf_vs_ilp() {
         vec![1, 1, 1],
         vec![5, 5, 5],
     );
-    let reduction: ReductionMCFAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMCFAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_witness = bf.find_witness(&problem).expect("should have a witness");
-    assert!(problem.evaluate(&bf_witness).0.is_some());
+    let bf_witness = bf.solve(&problem).unwrap().expect("should have a witness");
+    assert!(problem.evaluate(&bf_witness).unwrap().0.is_some());
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
         extracted.len(),
         3,
         "extracted solution has one entry per vertex"
     );
-    assert!(problem.evaluate(&extracted).0.is_some());
+    assert!(problem.evaluate(&extracted).unwrap().0.is_some());
 }
 
 #[test]
@@ -63,7 +65,8 @@ fn test_solution_extraction() {
         vec![1, 1, 1],
         vec![5, 5, 5],
     );
-    let reduction: ReductionMCFAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMCFAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manually construct a valid ILP solution:
     // x = [0, 1, 0]; y_{0,1}=1 y_{1,1}=1 y_{2,1}=1, rest 0
@@ -73,25 +76,45 @@ fn test_solution_extraction() {
         0, 1, 0, // y_{1,0}, y_{1,1}, y_{1,2}
         0, 1, 0, // y_{2,0}, y_{2,1}, y_{2,2}
     ];
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![0, 1, 0]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(7)));
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![false, true, false]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(7)));
 }
 
 #[test]
 fn test_multiplecopyfileallocation_to_ilp_trivial() {
     // Single vertex, copy must be placed at itself, zero access cost.
     let problem = MultipleCopyFileAllocation::new(SimpleGraph::new(1, vec![]), vec![2], vec![3]);
-    let reduction: ReductionMCFAToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMCFAToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // num_vars = 1 + 1 = 2
-    assert_eq!(ilp.num_vars, 2);
+    assert_eq!(ilp.num_vars(), 2);
     // num_constraints = 1 (assignment) + 1 (capacity) = 2
-    assert_eq!(ilp.constraints.len(), 2);
+    assert_eq!(ilp.constraints().len(), 2);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted.len(), 1);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(3)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(3)));
+}
+
+#[test]
+fn test_multiplecopyfileallocation_unreachable_assignments_are_forbidden() {
+    let problem = MultipleCopyFileAllocation::new(
+        SimpleGraph::new(4, vec![(0, 1)]),
+        vec![1, 0, 0, 0],
+        vec![8, 4, 6, 2],
+    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+    let direct = BruteForce::new().solve(&problem).unwrap().unwrap();
+    let target = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    let extracted = reduction.extract_solution(&target).unwrap();
+
+    assert_eq!(
+        problem.evaluate(&extracted).unwrap(),
+        problem.evaluate(&direct).unwrap()
+    );
+    assert!(extracted[2] && extracted[3]);
 }
diff --git a/src/unit_tests/rules/multiprocessorscheduling_ilp.rs b/src/unit_tests/rules/multiprocessorscheduling_ilp.rs
index 311d7dedf..25921170e 100644
--- a/src/unit_tests/rules/multiprocessorscheduling_ilp.rs
+++ b/src/unit_tests/rules/multiprocessorscheduling_ilp.rs
@@ -7,23 +7,25 @@ use crate::types::Or;
 fn test_reduction_creates_valid_ilp() {
     // 3 tasks, 2 processors, deadline 5
     let problem = MultiprocessorScheduling::new(vec![2, 3, 2], 2, 5);
-    let reduction: ReductionMSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // num_vars = 3 tasks * 2 processors = 6
     assert_eq!(
-        ilp.num_vars, 6,
+        ilp.num_vars(),
+        6,
         "Should have 6 variables (3 tasks * 2 processors)"
     );
 
     // num_constraints = 3 assignment + 2 load = 5
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         5,
         "Should have 5 constraints (3 assignment + 2 load)"
     );
     assert_eq!(
-        ilp.sense,
+        ilp.sense(),
         ObjectiveSense::Minimize,
         "Should minimize (feasibility)"
     );
@@ -33,21 +35,23 @@ fn test_reduction_creates_valid_ilp() {
 fn test_multiprocessorscheduling_to_ilp_bf_vs_ilp() {
     // 4 tasks [2, 2, 2, 2], 2 processors, deadline 4 → feasible (2+2 per proc)
     let problem = MultiprocessorScheduling::new(vec![2, 2, 2, 2], 2, 4);
-    let reduction: ReductionMSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("BF should find a solution");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "Extracted ILP solution should be valid"
     );
@@ -57,31 +61,33 @@ fn test_multiprocessorscheduling_to_ilp_bf_vs_ilp() {
 fn test_solution_extraction() {
     // 3 tasks, 2 processors
     let problem = MultiprocessorScheduling::new(vec![1, 2, 3], 2, 5);
-    let reduction: ReductionMSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manually set: task 0 → proc 0, task 1 → proc 1, task 2 → proc 0
     // Variables: x_{0,0}=1, x_{0,1}=0, x_{1,0}=0, x_{1,1}=1, x_{2,0}=1, x_{2,1}=0
     let ilp_solution = vec![1, 0, 0, 1, 1, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 1, 0]);
     // loads: proc 0 = 1+3=4 ≤ 5, proc 1 = 2 ≤ 5
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_multiprocessorscheduling_to_ilp_trivial() {
     // Single task on single processor
     let problem = MultiprocessorScheduling::new(vec![5], 1, 5);
-    let reduction: ReductionMSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionMSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // num_vars = 1 task * 1 processor = 1
-    assert_eq!(ilp.num_vars, 1);
+    assert_eq!(ilp.num_vars(), 1);
     // num_constraints = 1 assignment + 1 load = 2
-    assert_eq!(ilp.constraints.len(), 2);
+    assert_eq!(ilp.constraints().len(), 2);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/naesatisfiability_ilp.rs b/src/unit_tests/rules/naesatisfiability_ilp.rs
index bd2efef04..287d57652 100644
--- a/src/unit_tests/rules/naesatisfiability_ilp.rs
+++ b/src/unit_tests/rules/naesatisfiability_ilp.rs
@@ -8,16 +8,20 @@ fn test_reduction_creates_valid_ilp() {
     // NAE-SAT: (x1 ∨ x2) — two variables, one clause
     use crate::models::formula::CNFClause;
     let problem = NAESatisfiability::new(2, vec![CNFClause::new(vec![1, 2])]);
-    let reduction: ReductionNAESATToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionNAESATToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 2, "one ILP var per Boolean variable");
+    assert_eq!(ilp.num_vars(), 2, "one ILP var per Boolean variable");
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         2,
         "two constraints per clause (ge + le)"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty(), "feasibility: no objective terms");
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(
+        ilp.objective().is_empty(),
+        "feasibility: no objective terms"
+    );
 }
 
 #[test]
@@ -32,20 +36,22 @@ fn test_naesatisfiability_to_ilp_bf_vs_ilp() {
             CNFClause::new(vec![-1, -2, 3]), // ¬x1 ∨ ¬x2 ∨ x3
         ],
     );
-    let reduction: ReductionNAESATToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionNAESATToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("NAE-SAT instance should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -68,13 +74,14 @@ fn test_naesatisfiability_to_ilp_infeasible() {
     // But NAESat requires ≥2 literals per clause, so use (x1, x1):
     use crate::models::formula::CNFClause;
     let problem = NAESatisfiability::new(1, vec![CNFClause::new(vec![1, 1])]);
-    let reduction: ReductionNAESATToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionNAESATToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     // The ILP should be infeasible: x1 ≥ 1 (at least one true) AND x1 ≤ 0 (at least one false)
     assert!(
-        ilp_solver.solve(ilp).is_none(),
+        ilp_solver.solve(ilp).is_err(),
         "ILP should be infeasible for unsatisfiable NAE-SAT"
     );
 }
@@ -88,19 +95,20 @@ fn test_naesatisfiability_to_ilp_negative_literals() {
     // Solution: x1=false, x2=false → ¬x1=T, x2=F — NAE ✓
     use crate::models::formula::CNFClause;
     let problem = NAESatisfiability::new(2, vec![CNFClause::new(vec![-1, 2])]);
-    let reduction: ReductionNAESATToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionNAESATToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 2);
-    assert_eq!(ilp.constraints.len(), 2);
+    assert_eq!(ilp.num_vars(), 2);
+    assert_eq!(ilp.constraints().len(), 2);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(ilp)
         .expect("NAE-SAT with (¬x1 ∨ x2) is feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "extracted solution should satisfy NAE condition"
     );
diff --git a/src/unit_tests/rules/naesatisfiability_maxcut.rs b/src/unit_tests/rules/naesatisfiability_maxcut.rs
index 265df4574..9f07e13f0 100644
--- a/src/unit_tests/rules/naesatisfiability_maxcut.rs
+++ b/src/unit_tests/rules/naesatisfiability_maxcut.rs
@@ -19,7 +19,8 @@ fn test_naesatisfiability_to_maxcut_closed_loop() {
             CNFClause::new(vec![-1, -2, 3]),
         ],
     );
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&naesat);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&naesat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 2*3 = 6 vertices
@@ -38,7 +39,8 @@ fn test_naesatisfiability_to_maxcut_closed_loop() {
 fn test_naesatisfiability_to_maxcut_single_clause() {
     // Single clause: (x1, x2, x3) — NAE-satisfying iff not all same
     let naesat = NAESatisfiability::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&naesat);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&naesat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 6 vertices, 3 variable + 3 clause = 6 edges
@@ -57,7 +59,8 @@ fn test_naesatisfiability_to_maxcut_two_literal_clause() {
     // Clause with 2 literals: (x1, ~x2) — always NAE-satisfying unless x1=T, x2=F or x1=F, x2=T... actually (x1, ~x2) is NAE-unsatisfied when both literals are same: x1=T,~x2=T (x2=F) or x1=F,~x2=F (x2=T).
     // NAE-satisfied when x1 != ~x2, i.e., x1 == x2.
     let naesat = NAESatisfiability::new(2, vec![CNFClause::new(vec![1, -2])]);
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&naesat);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&naesat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 4 vertices, 2 variable + 1 clause = 3 edges
@@ -75,12 +78,13 @@ fn test_naesatisfiability_to_maxcut_two_literal_clause() {
 fn test_naesatisfiability_to_maxcut_four_literal_clause() {
     // Clause with 4 literals: (x1, x2, ~x3, x4)
     let naesat = NAESatisfiability::new(4, vec![CNFClause::new(vec![1, 2, -3, 4])]);
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&naesat);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&naesat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    // 8 vertices, 4 variable + C(4,2)=6 clause = 10 edges
-    assert_eq!(target.num_vertices(), 8);
-    assert_eq!(target.num_edges(), 10);
+    // One auxiliary variable and two triangles: 10 vertices, 5 + 6 edges.
+    assert_eq!(target.num_vertices(), 10);
+    assert_eq!(target.num_edges(), 11);
 
     assert_satisfaction_round_trip_from_optimization_target(
         &naesat,
@@ -99,18 +103,19 @@ fn test_naesatisfiability_to_maxcut_extract_solution() {
             CNFClause::new(vec![-1, 3, 2]),
         ],
     );
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&naesat);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&naesat).expect("reduction should succeed");
 
     // Vertices: x1(0), ~x1(1), x2(2), ~x2(3), x3(4), ~x3(5)
     // x1=T -> vertex 0 in set 1, vertex 1 in set 0
     // x2=F -> vertex 2 in set 0, vertex 3 in set 1
     // x3=T -> vertex 4 in set 1, vertex 5 in set 0
-    let target_config = vec![1, 0, 0, 1, 1, 0];
-    let extracted = reduction.extract_solution(&target_config);
-    assert_eq!(extracted, vec![1, 0, 1]); // x1=T, x2=F, x3=T
+    let target_config = vec![true, false, false, true, true, false];
+    let extracted = reduction.extract_solution(&target_config).unwrap();
+    assert_eq!(extracted, vec![true, false, true]); // x1=T, x2=F, x3=T
 
     // Verify this is a valid NAE-SAT solution
-    assert!(naesat.evaluate(&extracted).0);
+    assert!(naesat.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
@@ -124,7 +129,8 @@ fn test_naesatisfiability_to_maxcut_mixed_clause_sizes() {
             CNFClause::new(vec![-1, -3]),  // 2 literals -> 1 pair
         ],
     );
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&naesat);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&naesat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 6 vertices, 3 variable + (1 + 3 + 1) = 8 edges
@@ -149,16 +155,142 @@ fn test_naesatisfiability_to_maxcut_optimal_cut_value() {
             CNFClause::new(vec![-1, -2, 3]),
         ],
     );
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&naesat);
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&naesat).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let witness = solver.find_witness(target);
+    let witness = solver.solve(target).unwrap();
     assert!(witness.is_some());
 
     let config = witness.unwrap();
-    let cut_value = target.cut_size(&config);
+    let cut_value = target.cut_size(&config).unwrap();
     // n=3, m=2, M=3, k1=3, k2=3
     // Expected: 3*3 + (3-1) + (3-1) = 9 + 2 + 2 = 13
     assert_eq!(cut_value, 13);
 }
+
+fn check_every_cut(source: &NAESatisfiability) {
+    use crate::rules::AggregateReductionResult;
+    let reduction = ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(source).unwrap();
+    let target = AggregateReductionResult::target_problem(&reduction);
+    let mut decoded = vec![false; 1 << source.num_vars()];
+    let mut best = i64::MIN;
+    for mask in 0..(1usize << target.num_vertices()) {
+        let cut = (0..target.num_vertices())
+            .map(|i| mask & (1 << i) != 0)
+            .collect();
+        let value = target.evaluate(&cut).unwrap();
+        best = best.max(value.0.unwrap());
+        let certificate = AggregateReductionResult::extract_value(&reduction, value).0;
+        match reduction.extract_solution(&cut) {
+            Ok(assignment) => {
+                assert!(certificate);
+                assert!(source.evaluate(&assignment).unwrap().0);
+                assert_eq!(
+                    assignment,
+                    (0..source.num_vars())
+                        .map(|i| cut[2 * i])
+                        .collect::<Vec<_>>()
+                );
+                let index = assignment
+                    .iter()
+                    .enumerate()
+                    .fold(0, |index, (i, &bit)| index | (usize::from(bit) << i));
+                decoded[index] = true;
+            }
+            Err(_) => assert!(!certificate),
+        }
+    }
+    for (mask, &has_extension) in decoded.iter().enumerate() {
+        let assignment = (0..source.num_vars())
+            .map(|i| mask & (1 << i) != 0)
+            .collect();
+        assert_eq!(has_extension, source.evaluate(&assignment).unwrap().0);
+    }
+    assert_eq!(
+        AggregateReductionResult::extract_value(&reduction, crate::types::Max(Some(best))).0,
+        decoded.iter().any(|&valid| valid)
+    );
+    assert!(!AggregateReductionResult::extract_value(&reduction, crate::types::Max(None)).0);
+    assert!(reduction
+        .extract_solution(&vec![false; target.num_vertices() + 1])
+        .is_err());
+}
+
+#[test]
+fn test_naesatisfiability_to_maxcut_all_short_clauses_and_cuts() {
+    check_every_cut(&NAESatisfiability::new(0, vec![]));
+    for n in 1..=3 {
+        check_every_cut(&NAESatisfiability::new(n, vec![]));
+        let literals: Vec<_> = (1..=n as i64).flat_map(|i| [i, -i]).collect();
+        for length in 2..=4 {
+            for mut rank in 0..literals.len().pow(length) {
+                let clause = (0..length)
+                    .map(|_| {
+                        let literal = literals[rank % literals.len()];
+                        rank /= literals.len();
+                        literal
+                    })
+                    .collect();
+                check_every_cut(&NAESatisfiability::new(n, vec![CNFClause::new(clause)]));
+            }
+        }
+    }
+}
+
+#[test]
+fn test_naesatisfiability_to_maxcut_long_clause_interactions() {
+    // Former clique reward tied the feasible assignment 0001 with invalid 0011.
+    let source = NAESatisfiability::new(
+        4,
+        vec![
+            CNFClause::new(vec![1, 2, 3, 4]),
+            CNFClause::new(vec![1, -2]),
+            CNFClause::new(vec![2, -3]),
+        ],
+    );
+    check_every_cut(&source);
+    let reduction = ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+    assert_eq!(reduction.feasible_cut, 26);
+    for clauses in [
+        vec![vec![1, 1, 1, 1, 1]],
+        vec![vec![1, 2, 3, 1, 2], vec![1, -2], vec![2, -3]],
+        vec![vec![1, -1, 2, -2, 3, 3]],
+        vec![vec![1, 2], vec![1, -2]],
+    ] {
+        check_every_cut(&NAESatisfiability::new(
+            3,
+            clauses.into_iter().map(CNFClause::new).collect(),
+        ));
+    }
+}
+
+#[test]
+fn test_naesatisfiability_to_maxcut_numeric_limits() {
+    assert_eq!(
+        nae_maxcut_parameters(4, [4, 2, 2].into_iter()).unwrap(),
+        (10, 13, 4, 26)
+    );
+    assert_eq!(
+        nae_maxcut_parameters(0, [].into_iter()).unwrap(),
+        (0, 0, 1, 0)
+    );
+    assert!(matches!(
+        nae_maxcut_parameters(1, (0..usize::MAX).map(|_| 2)),
+        Err(crate::rules::ReductionError::IntegerOverflow { .. })
+    ));
+    for (n, lengths) in [
+        (usize::MAX, vec![4]),
+        (usize::MAX, vec![]),
+        (0, vec![usize::MAX]),
+        (0, vec![usize::MAX / 3, usize::MAX / 3]),
+        (2_147_483_648, vec![]),
+        (1, vec![1_431_655_768]),
+    ] {
+        assert!(matches!(
+            nae_maxcut_parameters(n, lengths.into_iter()),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+}
diff --git a/src/unit_tests/rules/naesatisfiability_partitionintoperfectmatchings.rs b/src/unit_tests/rules/naesatisfiability_partitionintoperfectmatchings.rs
index 412748a98..faf837e52 100644
--- a/src/unit_tests/rules/naesatisfiability_partitionintoperfectmatchings.rs
+++ b/src/unit_tests/rules/naesatisfiability_partitionintoperfectmatchings.rs
@@ -37,7 +37,8 @@ fn no_example_problem() -> NAESatisfiability {
 #[test]
 fn test_naesatisfiability_to_partitionintoperfectmatchings_closed_loop() {
     let source = NAESatisfiability::new(1, vec![]);
-    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_eq!(reduction.target_problem().num_vertices(), 4);
     assert_eq!(reduction.target_problem().num_edges(), 3);
@@ -53,17 +54,20 @@ fn test_naesatisfiability_to_partitionintoperfectmatchings_closed_loop() {
 #[test]
 fn test_naesatisfiability_to_partitionintoperfectmatchings_unsat_small_instance() {
     let source = NAESatisfiability::new(1, vec![CNFClause::new(vec![1, 1])]);
-    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert!(BruteForce::new()
-        .find_witness(reduction.target_problem())
+        .solve(reduction.target_problem())
+        .unwrap()
         .is_none());
 }
 
 #[test]
 fn test_naesatisfiability_to_partitionintoperfectmatchings_yes_example_structure() {
     let source = yes_example_problem();
-    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let mut expected_edges = vec![
@@ -130,7 +134,8 @@ fn test_naesatisfiability_to_partitionintoperfectmatchings_yes_example_structure
 #[test]
 fn test_naesatisfiability_to_partitionintoperfectmatchings_no_example_structure() {
     let source = no_example_problem();
-    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let mut expected_edges = vec![
@@ -239,14 +244,18 @@ fn test_naesatisfiability_to_partitionintoperfectmatchings_no_example_structure(
 #[test]
 fn test_naesatisfiability_to_partitionintoperfectmatchings_constructed_witness_round_trips() {
     let source = yes_example_problem();
-    let source_solution = vec![1, 1, 0];
-    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source);
+    let source_solution = vec![true, true, false];
+    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target_solution = reduction.construct_target_solution(&source_solution);
 
-    assert!(source.evaluate(&source_solution));
-    assert!(reduction.target_problem().evaluate(&target_solution));
+    assert!(source.evaluate(&source_solution).unwrap());
+    assert!(reduction
+        .target_problem()
+        .evaluate(&target_solution)
+        .unwrap());
     assert_eq!(
-        reduction.extract_solution(&target_solution),
+        reduction.extract_solution(&target_solution).unwrap(),
         source_solution
     );
 }
@@ -254,28 +263,31 @@ fn test_naesatisfiability_to_partitionintoperfectmatchings_constructed_witness_r
 #[test]
 fn test_naesatisfiability_to_partitionintoperfectmatchings_two_literal_clause_normalization() {
     let source = NAESatisfiability::new(2, vec![CNFClause::new(vec![1, -2])]);
-    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
-    let source_solution = vec![1, 1];
+    let source_solution = vec![true, true];
     let target_solution = reduction.construct_target_solution(&source_solution);
 
     assert_eq!(target.num_vertices(), 24);
     assert_eq!(target.num_edges(), 27);
     assert_eq!(target.num_matchings(), 2);
-    assert!(target.evaluate(&target_solution));
+    assert!(target.evaluate(&target_solution).unwrap());
     assert_eq!(
-        reduction.extract_solution(&target_solution),
+        reduction.extract_solution(&target_solution).unwrap(),
         source_solution
     );
 }
 
 #[test]
-#[should_panic(
-    expected = "NAESatisfiability -> PartitionIntoPerfectMatchings expects clauses of size 2 or 3"
-)]
 fn test_naesatisfiability_to_partitionintoperfectmatchings_rejects_long_clauses() {
     let source = NAESatisfiability::new(4, vec![CNFClause::new(vec![1, 2, 3, 4])]);
-    let _ = ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source);
+    let error =
+        ReduceTo::<PartitionIntoPerfectMatchings<SimpleGraph>>::reduce_to(&source).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::rules::ReductionError::InvalidTarget { .. }
+    ));
 }
 
 #[cfg(feature = "example-db")]
@@ -290,5 +302,8 @@ fn test_naesatisfiability_to_partitionintoperfectmatchings_canonical_example_spe
     assert_eq!(example.source.problem, "NAESatisfiability");
     assert_eq!(example.target.problem, "PartitionIntoPerfectMatchings");
     assert_eq!(example.solutions.len(), 1);
-    assert_eq!(example.solutions[0].source_config, vec![1, 1, 0]);
+    assert_eq!(
+        example.solutions[0].source_config,
+        serde_json::json!([true, true, false])
+    );
 }
diff --git a/src/unit_tests/rules/naesatisfiability_setsplitting.rs b/src/unit_tests/rules/naesatisfiability_setsplitting.rs
index a52ea2206..522d9bf04 100644
--- a/src/unit_tests/rules/naesatisfiability_setsplitting.rs
+++ b/src/unit_tests/rules/naesatisfiability_setsplitting.rs
@@ -18,7 +18,7 @@ fn rule_example_problem() -> NAESatisfiability {
 #[test]
 fn test_naesatisfiability_to_setsplitting_closed_loop() {
     let source = rule_example_problem();
-    let reduction = ReduceTo::<SetSplitting>::reduce_to(&source);
+    let reduction = ReduceTo::<SetSplitting>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -30,7 +30,7 @@ fn test_naesatisfiability_to_setsplitting_closed_loop() {
 #[test]
 fn test_naesatisfiability_to_setsplitting_structure() {
     let source = rule_example_problem();
-    let reduction = ReduceTo::<SetSplitting>::reduce_to(&source);
+    let reduction = ReduceTo::<SetSplitting>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.universe_size(), 6);
@@ -50,24 +50,26 @@ fn test_naesatisfiability_to_setsplitting_structure() {
 #[test]
 fn test_naesatisfiability_to_setsplitting_extract_solution_uses_positive_literals() {
     let source = rule_example_problem();
-    let reduction = ReduceTo::<SetSplitting>::reduce_to(&source);
+    let reduction = ReduceTo::<SetSplitting>::reduce_to(&source).expect("reduction should succeed");
 
     assert_eq!(
-        reduction.extract_solution(&[1, 0, 1, 0, 1, 0]),
-        vec![1, 0, 1]
+        reduction
+            .extract_solution(&vec![true, false, true, false, true, false])
+            .unwrap(),
+        vec![true, false, true]
     );
 }
 
 #[test]
 fn test_naesatisfiability_to_setsplitting_target_witness_extracts_to_satisfying_assignment() {
     let source = rule_example_problem();
-    let reduction = ReduceTo::<SetSplitting>::reduce_to(&source);
+    let reduction = ReduceTo::<SetSplitting>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
 
-    let target_solution = solver.find_witness(reduction.target_problem()).unwrap();
-    let source_solution = reduction.extract_solution(&target_solution);
+    let target_solution = solver.solve(reduction.target_problem()).unwrap().unwrap();
+    let source_solution = reduction.extract_solution(&target_solution).unwrap();
 
-    assert!(source.evaluate(&source_solution));
+    assert!(source.evaluate(&source_solution).unwrap());
 }
 
 #[cfg(feature = "example-db")]
@@ -82,6 +84,9 @@ fn test_naesatisfiability_to_setsplitting_canonical_example_spec() {
     assert_eq!(example.solutions.len(), 1);
 
     let pair = &example.solutions[0];
-    assert_eq!(pair.source_config, vec![1, 1, 1]);
-    assert_eq!(pair.target_config, vec![1, 1, 1, 0, 0, 0]);
+    assert_eq!(pair.source_config, serde_json::json!([true, true, true]));
+    assert_eq!(
+        pair.target_config,
+        serde_json::json!([true, true, true, false, false, false])
+    );
 }
diff --git a/src/unit_tests/rules/numerical3dimensionalmatching_numericalmatchingwithtargetsums.rs b/src/unit_tests/rules/numerical3dimensionalmatching_numericalmatchingwithtargetsums.rs
index 898e22396..cf2136f51 100644
--- a/src/unit_tests/rules/numerical3dimensionalmatching_numericalmatchingwithtargetsums.rs
+++ b/src/unit_tests/rules/numerical3dimensionalmatching_numericalmatchingwithtargetsums.rs
@@ -11,7 +11,8 @@ fn yes_problem() -> Numerical3DimensionalMatching {
 #[test]
 fn test_n3dm_to_nmts_structure() {
     let source = yes_problem();
-    let reduction = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source);
+    let reduction = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_pairs(), source.num_groups());
@@ -22,62 +23,78 @@ fn test_n3dm_to_nmts_structure() {
 
 #[test]
 fn test_n3dm_to_nmts_closed_loop() {
-    let source = yes_problem();
-    let reduction = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source);
-
-    assert_satisfaction_round_trip_from_satisfaction_target(
-        &source,
-        &reduction,
-        "N3DM -> NMTS closed loop",
-    );
+    for source in [
+        yes_problem(),
+        Numerical3DimensionalMatching::new(vec![1, 2], vec![2, 3], vec![12, 10], 15),
+        Numerical3DimensionalMatching::new(vec![i64::MAX - 2], vec![1], vec![1], i64::MAX),
+    ] {
+        let reduction = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source)
+            .expect("reduction should succeed");
+        assert_satisfaction_round_trip_from_satisfaction_target(
+            &source,
+            &reduction,
+            "N3DM -> NMTS closed loop",
+        );
+    }
 }
 
 #[test]
 fn test_n3dm_to_nmts_extracts_target_witness_into_source_witness() {
     let source =
         Numerical3DimensionalMatching::new(vec![6, 8, 7], vec![6, 7, 8], vec![7, 7, 7], 21);
-    let reduction = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source);
+    let reduction = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target_solution = vec![2, 1, 0];
 
-    assert!(reduction.target_problem().evaluate(&target_solution).0);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap()
+            .0
+    );
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     assert_eq!(extracted, vec![2, 0, 1, 0, 2, 1]);
-    assert!(source.evaluate(&extracted).0);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_n3dm_to_nmts_handles_repeated_targets() {
     let source = Numerical3DimensionalMatching::new(vec![4, 4], vec![4, 5], vec![7, 6], 15);
-    let reduction = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source);
+    let reduction = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target_solution = vec![0, 1];
 
-    assert!(reduction.target_problem().evaluate(&target_solution).0);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap()
+            .0
+    );
 
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     assert_eq!(extracted.len(), 4);
-    assert!(source.evaluate(&extracted).0);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_n3dm_to_nmts_unsatisfiable_maps_to_unsatisfiable() {
-    let source = Numerical3DimensionalMatching::new(vec![4, 6], vec![4, 6], vec![4, 6], 15);
-    let reduction = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source);
-
-    assert!(BruteForce::new().find_witness(&source).is_none());
-    assert!(BruteForce::new()
-        .find_witness(reduction.target_problem())
-        .is_none());
-}
-
-#[test]
-#[should_panic(
-    expected = "Numerical3DimensionalMatching -> NumericalMatchingWithTargetSums requires each complement B - s(w_i) to fit in i64"
-)]
-fn test_n3dm_to_nmts_panics_when_target_sum_exceeds_i64() {
-    let huge = 6_148_914_691_236_517_205_u64;
-    let source = Numerical3DimensionalMatching::new(vec![huge], vec![huge], vec![huge], u64::MAX);
-    let _ = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source);
+    for source in [
+        Numerical3DimensionalMatching::new(vec![4, 6], vec![4, 6], vec![4, 6], 15),
+        // Zero and negative complements remain valid, infeasible NMTS targets.
+        Numerical3DimensionalMatching::new(vec![15, 1], vec![2, 3], vec![4, 5], 15),
+        Numerical3DimensionalMatching::new(vec![16, 1], vec![2, 3], vec![4, 4], 15),
+    ] {
+        let reduction = ReduceTo::<NumericalMatchingWithTargetSums>::reduce_to(&source)
+            .expect("reduction should succeed");
+        assert!(BruteForce::new().solve(&source).unwrap().is_none());
+        assert!(BruteForce::new()
+            .solve(reduction.target_problem())
+            .unwrap()
+            .is_none());
+    }
 }
 
 #[cfg(feature = "example-db")]
diff --git a/src/unit_tests/rules/numericalmatchingwithtargetsums_ilp.rs b/src/unit_tests/rules/numericalmatchingwithtargetsums_ilp.rs
index b6a1dd3ee..697129347 100644
--- a/src/unit_tests/rules/numericalmatchingwithtargetsums_ilp.rs
+++ b/src/unit_tests/rules/numericalmatchingwithtargetsums_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::{Comparison, ObjectiveSense, ILP};
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::ILPSolver;
 use crate::traits::Problem;
 use crate::types::Or;
@@ -9,26 +9,22 @@ use crate::types::Or;
 fn test_numericalmatchingwithtargetsums_to_ilp_closed_loop() {
     let problem =
         NumericalMatchingWithTargetSums::new(vec![1, 4, 7], vec![2, 5, 3], vec![3, 7, 12]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_satisfaction_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "NMTS->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_numericalmatchingwithtargetsums_to_ilp_bf_vs_ilp() {
     let problem =
         NumericalMatchingWithTargetSums::new(vec![1, 4, 7], vec![2, 5, 3], vec![3, 7, 12]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
 
@@ -36,20 +32,20 @@ fn test_numericalmatchingwithtargetsums_to_ilp_bf_vs_ilp() {
 fn test_numericalmatchingwithtargetsums_to_ilp_structure() {
     let problem =
         NumericalMatchingWithTargetSums::new(vec![1, 4, 7], vec![2, 5, 3], vec![3, 7, 12]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Only compatible triples are created as variables
     // Check that we have 3m = 9 constraints (3 for x, 3 for y, 3 for targets)
     assert_eq!(ilp.num_constraints(), 9);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
     // Feasibility: empty objective
-    assert!(ilp.objective.is_empty());
+    assert!(ilp.objective().is_empty());
 
     // All constraints should be equality constraints
-    for c in &ilp.constraints {
-        assert_eq!(c.cmp, Comparison::Eq);
-        assert!((c.rhs - 1.0).abs() < 1e-9);
+    for c in ilp.constraints() {
+        assert_eq!(c.comparison(), Comparison::Eq);
+        assert_eq!(c.rhs(), 1);
     }
 }
 
@@ -57,10 +53,10 @@ fn test_numericalmatchingwithtargetsums_to_ilp_structure() {
 fn test_numericalmatchingwithtargetsums_to_ilp_unsatisfiable() {
     // m=2, no valid matching: sums {1+3,2+4}={4,6} or {1+4,2+3}={5,5}, neither = {10,20}
     let problem = NumericalMatchingWithTargetSums::new(vec![1, 2], vec![3, 4], vec![10, 20]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let result = ILPSolver::new().solve(reduction.target_problem());
     assert!(
-        result.is_none(),
+        result.is_err(),
         "Unsatisfiable instance should have no ILP solution"
     );
 }
@@ -68,7 +64,7 @@ fn test_numericalmatchingwithtargetsums_to_ilp_unsatisfiable() {
 #[test]
 fn test_numericalmatchingwithtargetsums_to_ilp_single_pair() {
     let problem = NumericalMatchingWithTargetSums::new(vec![5], vec![3], vec![8]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 1 compatible triple: (0,0,0) since 5+3=8
@@ -78,9 +74,9 @@ fn test_numericalmatchingwithtargetsums_to_ilp_single_pair() {
     let ilp_solution = ILPSolver::new()
         .solve(ilp)
         .expect("single-pair ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0]);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -92,15 +88,15 @@ fn test_numericalmatchingwithtargetsums_to_ilp_compatible_triples_only() {
     // Wait: (0,1,0): 1+4=5≠4, (1,0,1): 2+3=5≠6 — also not
     // So only 2 variables
     let problem = NumericalMatchingWithTargetSums::new(vec![1, 2], vec![3, 4], vec![4, 6]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     assert_eq!(ilp.num_vars(), 2);
 
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 1]);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[cfg(feature = "example-db")]
diff --git a/src/unit_tests/rules/openshopscheduling_ilp.rs b/src/unit_tests/rules/openshopscheduling_ilp.rs
index cd5528432..904f7fbf2 100644
--- a/src/unit_tests/rules/openshopscheduling_ilp.rs
+++ b/src/unit_tests/rules/openshopscheduling_ilp.rs
@@ -21,7 +21,8 @@ fn medium_instance() -> OpenShopScheduling {
 #[test]
 fn test_openshopscheduling_to_ilp_structure_small() {
     let p = small_instance();
-    let reduction: ReductionOSSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
+    let reduction: ReductionOSSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=2, m=2:
@@ -31,21 +32,22 @@ fn test_openshopscheduling_to_ilp_structure_small() {
     // c_var = 1
     // Total = 2 + 4 + 2 + 1 = 9
     assert_eq!(
-        ilp.num_vars, 9,
+        ilp.num_vars(),
+        9,
         "expected 9 variables, got {}",
-        ilp.num_vars
+        ilp.num_vars()
     );
     // Constraint count: 2 bound_x + 4 s_upper + 1 c_upper + 4 machine_nooverlap
     //                 + 2 bound_y + 4 job_nooverlap + 4 makespan = 21
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         21,
         "expected 21 constraints, got {}",
-        ilp.constraints.len()
+        ilp.constraints().len()
     );
     assert_eq!(
-        ilp.objective,
-        vec![(8, 1.0)],
+        ilp.objective(),
+        vec![(8, 1)],
         "objective should minimize C (index 8)"
     );
 }
@@ -55,13 +57,14 @@ fn test_openshopscheduling_to_ilp_structure_small() {
 #[test]
 fn test_openshopscheduling_to_ilp_closed_loop_small() {
     let p = small_instance();
-    let reduction: ReductionOSSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
+    let reduction: ReductionOSSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
 
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = p.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = p.evaluate(&extracted).unwrap();
     assert!(
         value.0.is_some(),
         "extracted schedule must be valid, got {value:?}"
@@ -73,13 +76,14 @@ fn test_openshopscheduling_to_ilp_closed_loop_small() {
 #[test]
 fn test_openshopscheduling_to_ilp_closed_loop_medium() {
     let p = medium_instance();
-    let reduction: ReductionOSSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
+    let reduction: ReductionOSSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
 
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = p.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = p.evaluate(&extracted).unwrap();
     assert!(
         value.0.is_some(),
         "extracted schedule must be valid, got {value:?}"
@@ -94,22 +98,13 @@ fn test_openshopscheduling_to_ilp_closed_loop_medium() {
 
 #[test]
 fn test_openshopscheduling_to_ilp_extract_solution_respects_start_times() {
-    // For small instance, if we manually craft an ILP solution, extraction should
-    // order jobs on each machine by start time.
     let p = small_instance();
-    let reduction: ReductionOSSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
-
-    // Variable layout: x_{0,1,0}=0, x_{0,1,1}=1, s_{0,0}=1, s_{0,1}=0, s_{1,0}=0, s_{1,1}=2, y_{0,0,1}=0, y_{1,0,1}=1, C=3
-    // => M1: job 1 starts at 0, job 0 starts at 1 → order [1, 0]
-    // => M2: job 0 starts at 0, job 1 starts at 2 → order [0, 1]
-    let target_solution = vec![0, 1, 1, 0, 0, 2, 0, 1, 3];
-    let extracted = reduction.extract_solution(&target_solution);
-    // M1: J1 at t=0, J0 at t=1 → order [1, 0]
-    // M2: J0 at t=0, J1 at t=2 → order [0, 1]
-    assert_eq!(extracted[0..2], [1, 0], "M1 order should be [1, 0]");
-    assert_eq!(extracted[2..4], [0, 1], "M2 order should be [0, 1]");
-    let value = p.evaluate(&extracted);
-    assert!(value.0.is_some(), "extracted config should be valid");
+    let reduction: ReductionOSSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
+    let target_solution = vec![1, 0, 0, 1, 1, 0, 1, 0, 3];
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![0, 1, 1, 0]);
+    assert_eq!(p.evaluate(&extracted).unwrap(), Min(Some(3)));
 }
 
 // ─── single job / single machine ─────────────────────────────────────────────
@@ -118,12 +113,13 @@ fn test_openshopscheduling_to_ilp_extract_solution_respects_start_times() {
 fn test_openshopscheduling_to_ilp_single_job() {
     // 1 job, 2 machines: trivial, makespan = sum of processing times
     let p = OpenShopScheduling::new(2, vec![vec![3, 4]]);
-    let reduction: ReductionOSSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
+    let reduction: ReductionOSSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = p.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = p.evaluate(&extracted).unwrap();
     assert!(value.0.is_some());
     assert_eq!(value, Min(Some(7)));
 }
@@ -132,12 +128,13 @@ fn test_openshopscheduling_to_ilp_single_job() {
 fn test_openshopscheduling_to_ilp_single_machine() {
     // 3 jobs, 1 machine: serial schedule, makespan = sum of all processing times
     let p = OpenShopScheduling::new(1, vec![vec![2], vec![3], vec![1]]);
-    let reduction: ReductionOSSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
+    let reduction: ReductionOSSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = p.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = p.evaluate(&extracted).unwrap();
     assert!(value.0.is_some());
     assert_eq!(value, Min(Some(6)));
 }
diff --git a/src/unit_tests/rules/optimallineararrangement_consecutiveonesmatrixaugmentation.rs b/src/unit_tests/rules/optimallineararrangement_consecutiveonesmatrixaugmentation.rs
index 168d6c825..a081c4de7 100644
--- a/src/unit_tests/rules/optimallineararrangement_consecutiveonesmatrixaugmentation.rs
+++ b/src/unit_tests/rules/optimallineararrangement_consecutiveonesmatrixaugmentation.rs
@@ -15,7 +15,7 @@ fn example_graph() -> SimpleGraph {
     )
 }
 
-fn decision_ola(graph: SimpleGraph, k: usize) -> Decision<OptimalLinearArrangement<SimpleGraph>> {
+fn decision_ola(graph: SimpleGraph, k: i64) -> Decision<OptimalLinearArrangement<SimpleGraph>> {
     Decision::new(OptimalLinearArrangement::new(graph), k)
 }
 
@@ -23,7 +23,8 @@ fn decision_ola(graph: SimpleGraph, k: usize) -> Decision<OptimalLinearArrangeme
 fn test_optimallineararrangement_to_consecutiveonesmatrixaugmentation_structure() {
     // Generic incidence matrix: rows = edges, cols = vertices.
     let source = decision_ola(example_graph(), 11);
-    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source);
+    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_rows(), 7); // num_edges
@@ -47,18 +48,19 @@ fn test_optimallineararrangement_to_consecutiveonesmatrixaugmentation_structure(
 fn test_optimallineararrangement_to_consecutiveonesmatrixaugmentation_closed_loop_yes() {
     // k = 11 >= optimal total length 11 -> source YES, target YES.
     let source = decision_ola(example_graph(), 11);
-    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source);
+    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let witness = BruteForce::new().find_witness(target);
+    let witness = BruteForce::new().solve(target).unwrap();
     assert!(witness.is_some(), "target should be YES at bound 4");
 
     let target_witness = witness.unwrap();
-    assert_eq!(target.evaluate(&target_witness), Or(true));
+    assert_eq!(target.evaluate(&target_witness).unwrap(), Or(true));
 
     // Reconstructed source arrangement must be a valid arrangement of length <= k.
-    let arrangement = reduction.extract_solution(&target_witness);
-    assert_eq!(source.evaluate(&arrangement), Or(true));
+    let arrangement = reduction.extract_solution(&target_witness).unwrap();
+    assert_eq!(source.evaluate(&arrangement).unwrap(), Or(true));
 }
 
 #[test]
@@ -66,45 +68,49 @@ fn test_optimallineararrangement_to_consecutiveonesmatrixaugmentation_closed_loo
     // k = 10 >= m = 7 (generic case), but bound = 3 < optimal cost - m = 4.
     // Target is NO; source is NO (no arrangement of length <= 10).
     let source = decision_ola(example_graph(), 10);
-    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source);
+    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     assert_eq!(target.bound(), 3);
 
     assert!(
-        BruteForce::new().find_witness(target).is_none(),
+        BruteForce::new().solve(target).unwrap().is_none(),
         "target should be NO at bound 3"
     );
     // Source is genuinely NO too.
     assert!(
-        BruteForce::new().find_witness(&source).is_none(),
+        BruteForce::new().solve(&source).unwrap().is_none(),
         "source should be NO at k = 10"
     );
 }
 
 #[test]
 fn test_optimallineararrangement_to_consecutiveonesmatrixaugmentation_edgeless_sentinel() {
-    // Edgeless graph: always YES regardless of bound.
+    // Edgeless graph: YES at bound zero, with one column per vertex.
     let source = decision_ola(SimpleGraph::new(3, vec![]), 0);
-    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source);
+    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    assert_eq!(target.matrix().to_vec(), vec![vec![false]]);
+    assert_eq!(target.matrix().to_vec(), vec![vec![false; 3]]);
     assert_eq!(target.bound(), 0);
 
-    let witness = BruteForce::new().find_witness(target).unwrap();
-    assert_eq!(target.evaluate(&witness), Or(true));
+    let witness = BruteForce::new().solve(target).unwrap().unwrap();
+    assert_eq!(target.evaluate(&witness).unwrap(), Or(true));
 
     // Reconstructed source arrangement covers all 3 vertices and is YES.
-    let arrangement = reduction.extract_solution(&witness);
+    let arrangement = reduction.extract_solution(&witness).unwrap();
     assert_eq!(arrangement.len(), 3);
-    assert_eq!(source.evaluate(&arrangement), Or(true));
+    assert_eq!(source.evaluate(&arrangement).unwrap(), Or(true));
+    assert!(reduction.extract_solution(&vec![]).is_err());
 }
 
 #[test]
 fn test_optimallineararrangement_to_consecutiveonesmatrixaugmentation_negative_bound_sentinel() {
     // P_6 (5 edges) with k = 4 < m = 5 -> genuine NO sentinel.
     let source = decision_ola(SimpleGraph::path(6), 4);
-    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source);
+    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 3x3 cyclic-overlap sentinel with bound 0.
@@ -120,30 +126,85 @@ fn test_optimallineararrangement_to_consecutiveonesmatrixaugmentation_negative_b
 
     // Genuinely NO under every column permutation.
     assert!(
-        BruteForce::new().find_witness(target).is_none(),
+        BruteForce::new().solve(target).unwrap().is_none(),
         "cyclic sentinel must be NO at bound 0"
     );
     // Source is NO (every P_6 arrangement costs >= 5 > 4).
     assert!(
-        BruteForce::new().find_witness(&source).is_none(),
+        BruteForce::new().solve(&source).unwrap().is_none(),
         "P_6 has no arrangement of length <= 4"
     );
+    assert!(reduction.extract_solution(&vec![]).is_err());
 }
 
 #[test]
 fn test_optimallineararrangement_to_consecutiveonesmatrixaugmentation_extract_invalid() {
-    // A non-permutation target solution falls back to the identity arrangement.
     let source = decision_ola(example_graph(), 11);
-    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source);
+    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source)
+        .expect("reduction should succeed");
 
-    // Wrong length.
     assert_eq!(
-        reduction.extract_solution(&[0, 1, 2]),
-        vec![0, 1, 2, 3, 4, 5]
+        reduction
+            .extract_solution(&vec![0, 1, 2])
+            .unwrap_err()
+            .to_string(),
+        "target evaluation failed during extraction: invalid configuration: column ordering length does not match the matrix"
     );
-    // Repeated column.
     assert_eq!(
-        reduction.extract_solution(&[0, 0, 1, 2, 3, 4]),
-        vec![0, 1, 2, 3, 4, 5]
+        reduction
+            .extract_solution(&vec![0, 0, 1, 2, 3, 4])
+            .unwrap_err()
+            .to_string(),
+        "target column order is not a satisfying augmentation certificate"
     );
 }
+
+#[test]
+fn test_optimallineararrangement_to_consecutiveonesmatrixaugmentation_native_domains() {
+    let cases = [
+        (0, vec![], i64::MIN, false),
+        (0, vec![], 0, true),
+        (3, vec![], -1, false),
+        (3, vec![], i64::MAX, true),
+        (1, vec![(0, 0)], 0, true),
+        (2, vec![(0, 0), (0, 1), (0, 1), (1, 1)], 1, false),
+        (2, vec![(0, 0), (0, 1), (0, 1), (1, 1)], 2, true),
+    ];
+    for (n, edges, bound, expected) in cases {
+        let m = edges.len();
+        let source = decision_ola(SimpleGraph::new(n, edges), bound);
+        let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        assert!(target.num_rows() <= m + 3);
+        assert!(target.num_cols() <= n + 3);
+        assert_eq!(
+            BruteForce::new().solve(&source).unwrap().is_some(),
+            expected
+        );
+        let witness = BruteForce::new().solve(target).unwrap();
+        assert_eq!(witness.is_some(), expected);
+        if let Some(witness) = witness {
+            assert_eq!(
+                source
+                    .evaluate(&reduction.extract_solution(&witness).unwrap())
+                    .unwrap(),
+                Or(true)
+            );
+        } else {
+            assert!(reduction
+                .extract_solution(&(0..target.num_cols()).collect())
+                .is_err());
+        }
+    }
+}
+
+#[test]
+fn test_optimallineararrangement_to_consecutiveonesmatrixaugmentation_certificate() {
+    let source = decision_ola(SimpleGraph::new(3, vec![(0, 2)]), 1);
+    let reduction = ReduceTo::<ConsecutiveOnesMatrixAugmentation>::reduce_to(&source).unwrap();
+    assert!(reduction.extract_solution(&vec![0, 1, 2]).is_err());
+    assert!(reduction.extract_solution(&vec![0, 1, 3]).is_err());
+    let arrangement = reduction.extract_solution(&vec![2, 0, 1]).unwrap();
+    assert_eq!(arrangement, vec![1, 2, 0]);
+    assert_eq!(source.evaluate(&arrangement).unwrap(), Or(true));
+}
diff --git a/src/unit_tests/rules/optimallineararrangement_ilp.rs b/src/unit_tests/rules/optimallineararrangement_ilp.rs
index 661b50569..c45f0bf41 100644
--- a/src/unit_tests/rules/optimallineararrangement_ilp.rs
+++ b/src/unit_tests/rules/optimallineararrangement_ilp.rs
@@ -7,11 +7,12 @@ use crate::traits::Problem;
 fn test_reduction_creates_valid_ilp() {
     // Path P4: 0-1-2-3
     let problem = OptimalLinearArrangement::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction: ReductionOLAToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionOLAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // num_x=16, p_v=4, z_e=3, total=23
-    assert_eq!(ilp.num_vars, 23);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 23);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -21,19 +22,21 @@ fn test_optimallineararrangement_to_ilp_closed_loop() {
     // BruteForce on source to verify feasibility
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute-force should find a solution");
-    assert!(problem.evaluate(&bf_solution).0.is_some());
+    assert!(problem.evaluate(&bf_solution).unwrap().0.is_some());
 
     // Solve via ILP
-    let reduction: ReductionOLAToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionOLAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert!(
-        problem.evaluate(&extracted).0.is_some(),
+        problem.evaluate(&extracted).unwrap().0.is_some(),
         "ILP solution should produce a valid arrangement"
     );
 }
@@ -49,35 +52,39 @@ fn test_optimallineararrangement_to_ilp_with_chords() {
     // BruteForce on source
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute-force should find a solution");
-    assert!(problem.evaluate(&bf_solution).0.is_some());
+    assert!(problem.evaluate(&bf_solution).unwrap().0.is_some());
 
     // Solve via ILP
-    let reduction: ReductionOLAToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionOLAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted).0.is_some());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap().0.is_some());
 }
 
 #[test]
 fn test_solution_extraction() {
     let problem = OptimalLinearArrangement::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction: ReductionOLAToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionOLAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted).0.is_some());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap().0.is_some());
 }
 
 #[test]
 fn test_optimallineararrangement_to_ilp_bf_vs_ilp() {
     let problem = OptimalLinearArrangement::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
-    let reduction: ReductionOLAToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionOLAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/optimallineararrangement_sequencingtominimizeweightedcompletiontime.rs b/src/unit_tests/rules/optimallineararrangement_sequencingtominimizeweightedcompletiontime.rs
index f26fdcd03..0347eda91 100644
--- a/src/unit_tests/rules/optimallineararrangement_sequencingtominimizeweightedcompletiontime.rs
+++ b/src/unit_tests/rules/optimallineararrangement_sequencingtominimizeweightedcompletiontime.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -12,23 +12,17 @@ fn reduce_path(
     ReductionOLAToSequencingToMinimizeWeightedCompletionTime,
 ) {
     let source = OptimalLinearArrangement::new(SimpleGraph::path(num_vertices));
-    let reduction = ReduceTo::<SequencingToMinimizeWeightedCompletionTime>::reduce_to(&source);
+    let reduction = ReduceTo::<SequencingToMinimizeWeightedCompletionTime>::reduce_to(&source)
+        .expect("reduction should succeed");
     (source, reduction)
 }
 
 fn solve_target_cost(
     reduction: &ReductionOLAToSequencingToMinimizeWeightedCompletionTime,
-) -> Min<u64> {
-    BruteForce::new().solve(reduction.target_problem())
-}
-
-fn permutation_to_lehmer(perm: &[usize]) -> Vec<usize> {
-    let mut lehmer = Vec::with_capacity(perm.len());
-    for i in 0..perm.len() {
-        let count = (i + 1..perm.len()).filter(|&j| perm[j] < perm[i]).count();
-        lehmer.push(count);
-    }
-    lehmer
+) -> Min<i64> {
+    let target = reduction.target_problem();
+    let solution = BruteForce::new().solve(target).unwrap().unwrap();
+    target.evaluate(&solution).unwrap()
 }
 
 #[test]
@@ -50,14 +44,20 @@ fn test_optimallineararrangement_to_sequencingtominimizeweightedcompletiontime_c
         "OptimalLinearArrangement -> SequencingToMinimizeWeightedCompletionTime P4",
     );
 
-    assert_eq!(BruteForce::new().solve(&source), Min(Some(3)));
+    assert_eq!(
+        source
+            .evaluate(&BruteForce::new().solve(&source).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(3))
+    );
     assert_eq!(solve_target_cost(&reduction), Min(Some(23)));
 }
 
 #[test]
 fn test_optimallineararrangement_to_sequencingtominimizeweightedcompletiontime_closed_loop_k3() {
     let source = OptimalLinearArrangement::new(SimpleGraph::complete(3));
-    let reduction = ReduceTo::<SequencingToMinimizeWeightedCompletionTime>::reduce_to(&source);
+    let reduction = ReduceTo::<SequencingToMinimizeWeightedCompletionTime>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -65,7 +65,12 @@ fn test_optimallineararrangement_to_sequencingtominimizeweightedcompletiontime_c
         "OptimalLinearArrangement -> SequencingToMinimizeWeightedCompletionTime K3",
     );
 
-    assert_eq!(BruteForce::new().solve(&source), Min(Some(4)));
+    assert_eq!(
+        source
+            .evaluate(&BruteForce::new().solve(&source).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(4))
+    );
     assert_eq!(solve_target_cost(&reduction), Min(Some(16)));
 }
 
@@ -79,7 +84,12 @@ fn test_optimallineararrangement_to_sequencingtominimizeweightedcompletiontime_t
         "OptimalLinearArrangement -> SequencingToMinimizeWeightedCompletionTime P2",
     );
 
-    assert_eq!(BruteForce::new().solve(&source), Min(Some(1)));
+    assert_eq!(
+        source
+            .evaluate(&BruteForce::new().solve(&source).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(1))
+    );
     assert_eq!(solve_target_cost(&reduction), Min(Some(4)));
 }
 
@@ -88,9 +98,8 @@ fn test_optimallineararrangement_to_sequencingtominimizeweightedcompletiontime_e
 ) {
     let (source, reduction) = reduce_path(4);
     let schedule = vec![3, 2, 6, 1, 5, 0, 4];
-    let target_solution = permutation_to_lehmer(&schedule);
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&schedule).unwrap();
 
     assert_eq!(extracted, vec![3, 2, 1, 0]);
-    assert_eq!(source.evaluate(&extracted), Min(Some(3)));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(3)));
 }
diff --git a/src/unit_tests/rules/optimumcommunicationspanningtree_ilp.rs b/src/unit_tests/rules/optimumcommunicationspanningtree_ilp.rs
index b0faca24e..4e0f1cf8c 100644
--- a/src/unit_tests/rules/optimumcommunicationspanningtree_ilp.rs
+++ b/src/unit_tests/rules/optimumcommunicationspanningtree_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Min;
@@ -30,25 +30,21 @@ fn k4_problem() -> OptimumCommunicationSpanningTree {
 #[test]
 fn test_ocst_to_ilp_closed_loop_k3() {
     let problem = k3_problem();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_optimization_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "OptimumCommunicationSpanningTree->ILP K3 closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_ocst_to_ilp_structure_k4() {
     let problem = k4_problem();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // K4: n=4, m=6, 6 commodities (all pairs have r>0)
     // num_vars = 6 + 2*6*6 = 78
     assert_eq!(ilp.num_vars(), 78);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
     // Constraints: 1 (tree size) + 4*6 (flow conservation) + 2*6*6 (capacity) = 1+24+72 = 97
     assert_eq!(ilp.num_constraints(), 97);
@@ -57,13 +53,13 @@ fn test_ocst_to_ilp_structure_k4() {
 #[test]
 fn test_ocst_to_ilp_structure_k3() {
     let problem = k3_problem();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // K3: n=3, m=3, 3 commodities (all pairs have r>0)
     // num_vars = 3 + 2*3*3 = 21
     assert_eq!(ilp.num_vars(), 21);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
     // Constraints: 1 (tree size) + 3*3 (flow conservation) + 2*3*3 (capacity) = 1+9+18 = 28
     assert_eq!(ilp.num_constraints(), 28);
@@ -72,16 +68,16 @@ fn test_ocst_to_ilp_structure_k3() {
 #[test]
 fn test_ocst_to_ilp_bf_vs_ilp_k3() {
     let problem = k3_problem();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    let bf_solutions = BruteForce::new().find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     assert!(ilp_value.is_valid());
@@ -91,16 +87,16 @@ fn test_ocst_to_ilp_bf_vs_ilp_k3() {
 #[test]
 fn test_ocst_to_ilp_bf_vs_ilp_k4() {
     let problem = k4_problem();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    let bf_solutions = BruteForce::new().find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = BruteForce::new().find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     assert!(ilp_value.is_valid());
@@ -110,17 +106,17 @@ fn test_ocst_to_ilp_bf_vs_ilp_k4() {
 #[test]
 fn test_ocst_to_ilp_extraction() {
     let problem = k3_problem();
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Should be a valid config with m=3 entries
     assert_eq!(extracted.len(), 3);
     // Should form a valid spanning tree with value 6
-    let value = problem.evaluate(&extracted);
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(value.is_valid());
     assert_eq!(value, Min(Some(6)));
 }
@@ -138,3 +134,26 @@ fn test_ocst_to_ilp_canonical_example_spec() {
     assert_eq!(example.target.problem, "ILP");
     assert!(!example.solutions.is_empty());
 }
+
+#[test]
+fn test_ocst_zero_requirement_pairs_still_enforce_spanning_tree() {
+    let problem = OptimumCommunicationSpanningTree::new(
+        vec![
+            vec![0, 9, 6, 3],
+            vec![9, 0, 7, 8],
+            vec![6, 7, 0, 3],
+            vec![3, 8, 3, 0],
+        ],
+        vec![
+            vec![0, 0, 0, 0],
+            vec![0, 0, 1, 4],
+            vec![0, 1, 0, 4],
+            vec![0, 4, 4, 0],
+        ],
+    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+    let solution = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    let extracted = reduction.extract_solution(&solution).unwrap();
+
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(55)));
+}
diff --git a/src/unit_tests/rules/paintshop_ilp.rs b/src/unit_tests/rules/paintshop_ilp.rs
index b728e0d61..aa721eda1 100644
--- a/src/unit_tests/rules/paintshop_ilp.rs
+++ b/src/unit_tests/rules/paintshop_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 
@@ -8,41 +8,40 @@ use crate::traits::Problem;
 fn test_reduction_creates_valid_ilp() {
     // Sequence: A, B, A, B => 2 cars, 4 positions
     let problem = PaintShop::new(vec!["A", "B", "A", "B"]);
-    let reduction: ReductionPaintShopToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPaintShopToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 2 car vars + 4 k vars + 4 c vars = 10
     assert_eq!(ilp.num_vars(), 10);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_paintshop_to_ilp_closed_loop() {
     let problem = PaintShop::new(vec!["A", "B", "A", "C", "B", "C"]);
-    let reduction: ReductionPaintShopToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPaintShopToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_optimization_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "PaintShop->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_paintshop_to_ilp_bf_vs_ilp() {
     let problem = PaintShop::new(vec!["A", "B", "A", "C", "B", "C"]);
-    let reduction: ReductionPaintShopToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPaintShopToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
 }
@@ -51,13 +50,14 @@ fn test_paintshop_to_ilp_bf_vs_ilp() {
 fn test_solution_extraction() {
     // Minimal: A, A => 1 car
     let problem = PaintShop::new(vec!["A", "A"]);
-    let reduction: ReductionPaintShopToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPaintShopToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted.len(), 1);
     // Either 0 or 1 is valid; coloring is [x, 1-x], switches = 1
-    assert!(problem.evaluate(&extracted).is_valid());
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
diff --git a/src/unit_tests/rules/paintshop_qubo.rs b/src/unit_tests/rules/paintshop_qubo.rs
index 385d60dad..e5b6343f2 100644
--- a/src/unit_tests/rules/paintshop_qubo.rs
+++ b/src/unit_tests/rules/paintshop_qubo.rs
@@ -6,7 +6,7 @@ use crate::solvers::BruteForce;
 fn test_paintshop_to_qubo_closed_loop() {
     // Issue example: Sequence [A, B, C, A, D, B, D, C], 4 cars
     let source = PaintShop::new(vec!["A", "B", "C", "A", "D", "B", "D", "C"]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     // 4 cars -> 4 QUBO variables
@@ -23,7 +23,7 @@ fn test_paintshop_to_qubo_closed_loop() {
 fn test_paintshop_to_qubo_simple() {
     // Simple case: a, b, a, b
     let source = PaintShop::new(vec!["a", "b", "a", "b"]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     assert_eq!(qubo.num_vars(), 2);
@@ -39,16 +39,16 @@ fn test_paintshop_to_qubo_simple() {
 fn test_paintshop_to_qubo_optimal_value() {
     // Issue example verifies optimal QUBO = -1, total switches = -1 + 3 = 2
     let source = PaintShop::new(vec!["A", "B", "C", "A", "D", "B", "D", "C"]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let best_target = solver.find_all_witnesses(qubo);
+    let best_target = solver.find_all_witnesses(qubo).unwrap();
 
     // Extract solutions and verify they are optimal for the source
     for sol in &best_target {
-        let source_sol = reduction.extract_solution(sol);
-        let switches = source.count_switches(&source_sol);
+        let source_sol = reduction.extract_solution(sol).unwrap();
+        let switches = source.count_switches(&source_sol).unwrap();
         // Optimal is 2 switches
         assert_eq!(switches, 2, "Expected 2 switches for optimal solution");
     }
@@ -58,7 +58,7 @@ fn test_paintshop_to_qubo_optimal_value() {
 fn test_paintshop_to_qubo_matrix_structure() {
     // Issue example: verify the Q matrix matches expected values
     let source = PaintShop::new(vec!["A", "B", "C", "A", "D", "B", "D", "C"]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let m = qubo.matrix();
@@ -67,23 +67,23 @@ fn test_paintshop_to_qubo_matrix_structure() {
     //     [  0,   2,  -2,   0 ]
     //     [  0,   0,   1,  -2 ]
     //     [  0,   0,   0,   0 ]
-    assert_eq!(m[0][0], -1.0);
-    assert_eq!(m[0][1], -2.0);
-    assert_eq!(m[0][2], 2.0);
-    assert_eq!(m[0][3], 2.0);
-    assert_eq!(m[1][1], 2.0);
-    assert_eq!(m[1][2], -2.0);
-    assert_eq!(m[1][3], 0.0);
-    assert_eq!(m[2][2], 1.0);
-    assert_eq!(m[2][3], -2.0);
-    assert_eq!(m[3][3], 0.0);
+    assert_eq!(m[0][0], -1);
+    assert_eq!(m[0][1], -2);
+    assert_eq!(m[0][2], 2);
+    assert_eq!(m[0][3], 2);
+    assert_eq!(m[1][1], 2);
+    assert_eq!(m[1][2], -2);
+    assert_eq!(m[1][3], 0);
+    assert_eq!(m[2][2], 1);
+    assert_eq!(m[2][3], -2);
+    assert_eq!(m[3][3], 0);
 }
 
 #[test]
 fn test_paintshop_to_qubo_two_cars() {
     // Two cars, adjacent: a, b, b, a
     let source = PaintShop::new(vec!["a", "b", "b", "a"]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     assert_optimization_round_trip_from_optimization_target(
         &source,
@@ -96,7 +96,7 @@ fn test_paintshop_to_qubo_two_cars() {
 fn test_paintshop_to_qubo_empty_sequence() {
     // Empty PaintShop with 0 cars should not panic
     let source = PaintShop::new(Vec::<&str>::new());
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
     let qubo = reduction.target_problem();
     assert_eq!(qubo.num_vars(), 0);
 }
diff --git a/src/unit_tests/rules/partiallyorderedknapsack_ilp.rs b/src/unit_tests/rules/partiallyorderedknapsack_ilp.rs
index 5553c3831..f907bd954 100644
--- a/src/unit_tests/rules/partiallyorderedknapsack_ilp.rs
+++ b/src/unit_tests/rules/partiallyorderedknapsack_ilp.rs
@@ -6,28 +6,30 @@ use crate::traits::Problem;
 fn test_reduction_creates_valid_ilp() {
     // 3 items, weights [2,3,1], values [3,4,2], capacity 4, precedence (0,1)
     let problem = PartiallyOrderedKnapsack::new(vec![2, 3, 1], vec![3, 4, 2], vec![(0, 1)], 4);
-    let reduction: ReductionPOKToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPOKToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 3);
-    assert_eq!(ilp.constraints.len(), 2); // 1 capacity + 1 precedence
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
+    assert_eq!(ilp.num_vars(), 3);
+    assert_eq!(ilp.constraints().len(), 2); // 1 capacity + 1 precedence
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
 }
 
 #[test]
 fn test_partiallyorderedknapsack_to_ilp_bf_vs_ilp() {
     let problem = PartiallyOrderedKnapsack::new(vec![2, 3, 1], vec![3, 4, 2], vec![(0, 1)], 4);
-    let reduction: ReductionPOKToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPOKToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_value = problem.evaluate(&bf_solutions[0]);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_value = problem.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     assert!(ilp_value.is_valid());
@@ -36,20 +38,22 @@ fn test_partiallyorderedknapsack_to_ilp_bf_vs_ilp() {
 #[test]
 fn test_solution_extraction() {
     let problem = PartiallyOrderedKnapsack::new(vec![2, 3, 1], vec![3, 4, 2], vec![(0, 1)], 4);
-    let reduction: ReductionPOKToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPOKToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted).is_valid());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap().is_valid());
 }
 
 #[test]
 fn test_partiallyorderedknapsack_to_ilp_trivial() {
     let problem = PartiallyOrderedKnapsack::new(vec![], vec![], vec![], 0);
-    let reduction: ReductionPOKToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPOKToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 0);
-    assert_eq!(ilp.constraints.len(), 1); // capacity only
+    assert_eq!(ilp.num_vars(), 0);
+    assert_eq!(ilp.constraints().len(), 1); // capacity only
 }
diff --git a/src/unit_tests/rules/partition_binpacking.rs b/src/unit_tests/rules/partition_binpacking.rs
index c70410722..4d0185802 100644
--- a/src/unit_tests/rules/partition_binpacking.rs
+++ b/src/unit_tests/rules/partition_binpacking.rs
@@ -7,8 +7,9 @@ use crate::types::Min;
 
 #[test]
 fn test_partition_to_binpacking_closed_loop() {
-    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    let reduction = ReduceTo::<BinPacking<i32>>::reduce_to(&source);
+    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    let reduction =
+        ReduceTo::<BinPacking<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -19,8 +20,9 @@ fn test_partition_to_binpacking_closed_loop() {
 
 #[test]
 fn test_partition_to_binpacking_structure() {
-    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    let reduction = ReduceTo::<BinPacking<i32>>::reduce_to(&source);
+    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    let reduction =
+        ReduceTo::<BinPacking<i64>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.sizes(), &[3, 1, 1, 2, 2, 1]);
@@ -32,28 +34,21 @@ fn test_partition_to_binpacking_structure() {
 fn test_partition_to_binpacking_odd_total_is_not_satisfying() {
     // Sizes [2, 4, 5], total = 11 (odd), capacity = 5
     // No balanced partition possible; BinPacking needs >= 3 bins
-    let source = Partition::new(vec![2, 4, 5]);
-    let reduction = ReduceTo::<BinPacking<i32>>::reduce_to(&source);
+    let source = Partition::new(vec![2, 4, 5]).unwrap();
+    let reduction =
+        ReduceTo::<BinPacking<i64>>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("BinPacking target should always have an optimal solution");
 
     // With capacity 5, items [2,4,5]: bin 0 gets [5], bin 1 gets [2,4]=6 > 5,
     // so optimal needs 3 bins
-    let value = target.evaluate(&best);
+    let value = target.evaluate(&best).unwrap();
     assert_eq!(value, Min(Some(3)));
 
-    let extracted = reduction.extract_solution(&best);
-    assert!(!source.evaluate(&extracted));
-}
-
-#[test]
-#[should_panic(
-    expected = "Partition -> BinPacking requires all sizes and total_sum / 2 to fit in i32"
-)]
-fn test_partition_to_binpacking_panics_on_large_coefficients() {
-    let source = Partition::new(vec![(i32::MAX as u64) + 1]);
-    let _ = ReduceTo::<BinPacking<i32>>::reduce_to(&source);
+    let extracted = reduction.extract_solution(&best).unwrap();
+    assert!(!source.evaluate(&extracted).unwrap());
 }
diff --git a/src/unit_tests/rules/partition_cosineproductintegration.rs b/src/unit_tests/rules/partition_cosineproductintegration.rs
index 410a1d9c8..3d84ffddc 100644
--- a/src/unit_tests/rules/partition_cosineproductintegration.rs
+++ b/src/unit_tests/rules/partition_cosineproductintegration.rs
@@ -4,9 +4,10 @@ use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
-fn reduce_partition(sizes: &[u64]) -> (Partition, ReductionPartitionToCPI) {
-    let source = Partition::new(sizes.to_vec());
-    let reduction = ReduceTo::<CosineProductIntegration>::reduce_to(&source);
+fn reduce_partition(sizes: &[i64]) -> (Partition, ReductionPartitionToCPI) {
+    let source = Partition::new(sizes.to_vec()).unwrap();
+    let reduction =
+        ReduceTo::<CosineProductIntegration>::reduce_to(&source).expect("reduction should succeed");
     (source, reduction)
 }
 
@@ -16,8 +17,8 @@ fn assert_satisfiability_matches(
     expected: bool,
 ) {
     let solver = BruteForce::new();
-    assert_eq!(solver.find_witness(source).is_some(), expected);
-    assert_eq!(solver.find_witness(target).is_some(), expected);
+    assert_eq!(solver.solve(source).unwrap().is_some(), expected);
+    assert_eq!(solver.solve(target).unwrap().is_some(), expected);
 }
 
 #[test]
@@ -66,13 +67,13 @@ fn test_partition_to_cosineproductintegration_solution_extraction() {
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let target_solutions = solver.find_all_witnesses(target);
+    let target_solutions = solver.find_all_witnesses(target).unwrap();
 
     for sol in &target_solutions {
-        let extracted = reduction.extract_solution(sol);
+        let extracted = reduction.extract_solution(sol).unwrap();
         assert_eq!(extracted.len(), source.num_elements());
-        let target_valid = target.evaluate(sol);
-        let source_valid = source.evaluate(&extracted);
+        let target_valid = target.evaluate(sol).unwrap();
+        let source_valid = source.evaluate(&extracted).unwrap();
         if target_valid.0 {
             assert!(
                 source_valid.0,
diff --git a/src/unit_tests/rules/partition_integralflowwithmultipliers.rs b/src/unit_tests/rules/partition_integralflowwithmultipliers.rs
index 6149a2d9e..cb72e3e25 100644
--- a/src/unit_tests/rules/partition_integralflowwithmultipliers.rs
+++ b/src/unit_tests/rules/partition_integralflowwithmultipliers.rs
@@ -6,8 +6,9 @@ use crate::solvers::BruteForce;
 
 #[test]
 fn test_partition_to_integralflowwithmultipliers_closed_loop() {
-    let source = Partition::new(vec![1, 2, 3]);
-    let reduction = ReduceTo::<IntegralFlowWithMultipliers>::reduce_to(&source);
+    let source = Partition::new(vec![1, 2, 3]).unwrap();
+    let reduction = ReduceTo::<IntegralFlowWithMultipliers>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -18,8 +19,9 @@ fn test_partition_to_integralflowwithmultipliers_closed_loop() {
 
 #[test]
 fn test_partition_to_integralflowwithmultipliers_structure_even_total() {
-    let source = Partition::new(vec![2, 3, 4, 5, 6, 4]);
-    let reduction = ReduceTo::<IntegralFlowWithMultipliers>::reduce_to(&source);
+    let source = Partition::new(vec![2, 3, 4, 5, 6, 4]).unwrap();
+    let reduction = ReduceTo::<IntegralFlowWithMultipliers>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 9);
@@ -51,18 +53,20 @@ fn test_partition_to_integralflowwithmultipliers_structure_even_total() {
 
 #[test]
 fn test_partition_to_integralflowwithmultipliers_even_no_instance_uses_bottleneck() {
-    let source = Partition::new(vec![3, 5]);
-    let reduction = ReduceTo::<IntegralFlowWithMultipliers>::reduce_to(&source);
+    let source = Partition::new(vec![3, 5]).unwrap();
+    let reduction = ReduceTo::<IntegralFlowWithMultipliers>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.capacities(), &[1, 1, 3, 5, 4]);
-    assert!(BruteForce::new().find_witness(target).is_none());
+    assert!(BruteForce::new().solve(target).unwrap().is_none());
 }
 
 #[test]
 fn test_partition_to_integralflowwithmultipliers_odd_total_is_fixed_no_instance() {
-    let source = Partition::new(vec![1, 2]);
-    let reduction = ReduceTo::<IntegralFlowWithMultipliers>::reduce_to(&source);
+    let source = Partition::new(vec![1, 2]).unwrap();
+    let reduction = ReduceTo::<IntegralFlowWithMultipliers>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 3);
@@ -70,18 +74,24 @@ fn test_partition_to_integralflowwithmultipliers_odd_total_is_fixed_no_instance(
     assert_eq!(target.multipliers(), &[1, 2, 1]);
     assert_eq!(target.capacities(), &[1, 1]);
     assert_eq!(target.requirement(), 1);
-    assert!(BruteForce::new().find_witness(target).is_none());
-    assert_eq!(reduction.extract_solution(&[]), vec![0, 0]);
+    assert!(BruteForce::new().solve(target).unwrap().is_none());
+    assert_eq!(
+        reduction.extract_solution(&vec![]).unwrap_err().to_string(),
+        "the fixed infeasible target instance has no extractable witness"
+    );
 }
 
 #[test]
 fn test_partition_to_integralflowwithmultipliers_extract_solution() {
-    let source = Partition::new(vec![2, 3, 4, 5, 6, 4]);
-    let reduction = ReduceTo::<IntegralFlowWithMultipliers>::reduce_to(&source);
+    let source = Partition::new(vec![2, 3, 4, 5, 6, 4]).unwrap();
+    let reduction = ReduceTo::<IntegralFlowWithMultipliers>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_eq!(
-        reduction.extract_solution(&[1, 0, 1, 0, 1, 0, 2, 0, 4, 0, 6, 0, 12]),
-        vec![1, 0, 1, 0, 1, 0]
+        reduction
+            .extract_solution(&vec![1, 0, 1, 0, 1, 0, 2, 0, 4, 0, 6, 0, 12])
+            .unwrap(),
+        vec![true, false, true, false, true, false]
     );
 }
 
@@ -96,9 +106,12 @@ fn test_partition_to_integralflowwithmultipliers_canonical_example_spec() {
 
     assert_eq!(example.solutions.len(), 1);
     let solution = &example.solutions[0];
-    assert_eq!(solution.source_config, vec![1, 0, 1, 0, 1, 0]);
+    assert_eq!(
+        solution.source_config,
+        serde_json::json!([true, false, true, false, true, false])
+    );
     assert_eq!(
         solution.target_config,
-        vec![1, 0, 1, 0, 1, 0, 2, 0, 4, 0, 6, 0, 12]
+        serde_json::json!([1, 0, 1, 0, 1, 0, 2, 0, 4, 0, 6, 0, 12])
     );
 }
diff --git a/src/unit_tests/rules/partition_knapsack.rs b/src/unit_tests/rules/partition_knapsack.rs
index e308d172c..c4d2274df 100644
--- a/src/unit_tests/rules/partition_knapsack.rs
+++ b/src/unit_tests/rules/partition_knapsack.rs
@@ -7,8 +7,8 @@ use crate::types::Max;
 
 #[test]
 fn test_partition_to_knapsack_closed_loop() {
-    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    let reduction = ReduceTo::<Knapsack>::reduce_to(&source);
+    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    let reduction = ReduceTo::<Knapsack>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -19,8 +19,8 @@ fn test_partition_to_knapsack_closed_loop() {
 
 #[test]
 fn test_partition_to_knapsack_structure() {
-    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    let reduction = ReduceTo::<Knapsack>::reduce_to(&source);
+    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    let reduction = ReduceTo::<Knapsack>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.weights(), &[3, 1, 1, 2, 2, 1]);
@@ -31,24 +31,16 @@ fn test_partition_to_knapsack_structure() {
 
 #[test]
 fn test_partition_to_knapsack_odd_total_is_not_satisfying() {
-    let source = Partition::new(vec![2, 4, 5]);
-    let reduction = ReduceTo::<Knapsack>::reduce_to(&source);
+    let source = Partition::new(vec![2, 4, 5]).unwrap();
+    let reduction = ReduceTo::<Knapsack>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("Knapsack target should always have an optimal solution");
 
-    assert_eq!(target.evaluate(&best), Max(Some(5)));
+    assert_eq!(target.evaluate(&best).unwrap(), Max(Some(5)));
 
-    let extracted = reduction.extract_solution(&best);
-    assert!(!source.evaluate(&extracted));
-}
-
-#[test]
-#[should_panic(
-    expected = "Partition -> Knapsack requires all sizes and total_sum / 2 to fit in i64"
-)]
-fn test_partition_to_knapsack_panics_on_large_coefficients() {
-    let source = Partition::new(vec![(i64::MAX as u64) + 1]);
-    let _ = ReduceTo::<Knapsack>::reduce_to(&source);
+    let extracted = reduction.extract_solution(&best).unwrap();
+    assert!(!source.evaluate(&extracted).unwrap());
 }
diff --git a/src/unit_tests/rules/partition_multiprocessorscheduling.rs b/src/unit_tests/rules/partition_multiprocessorscheduling.rs
index b72884a81..cbec3fcc6 100644
--- a/src/unit_tests/rules/partition_multiprocessorscheduling.rs
+++ b/src/unit_tests/rules/partition_multiprocessorscheduling.rs
@@ -4,9 +4,10 @@ use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction
 use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
-fn reduce_partition(sizes: &[u64]) -> (Partition, ReductionPartitionToMPS) {
-    let source = Partition::new(sizes.to_vec());
-    let reduction = ReduceTo::<MultiprocessorScheduling>::reduce_to(&source);
+fn reduce_partition(sizes: &[i64]) -> (Partition, ReductionPartitionToMPS) {
+    let source = Partition::new(sizes.to_vec()).unwrap();
+    let reduction =
+        ReduceTo::<MultiprocessorScheduling>::reduce_to(&source).expect("reduction should succeed");
     (source, reduction)
 }
 
@@ -16,8 +17,8 @@ fn assert_satisfiability_matches(
     expected: bool,
 ) {
     let solver = BruteForce::new();
-    assert_eq!(solver.find_witness(source).is_some(), expected);
-    assert_eq!(solver.find_witness(target).is_some(), expected);
+    assert_eq!(solver.solve(source).unwrap().is_some(), expected);
+    assert_eq!(solver.solve(target).unwrap().is_some(), expected);
 }
 
 #[test]
@@ -80,15 +81,15 @@ fn test_partition_to_multiprocessorscheduling_solution_extraction() {
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let target_solutions = solver.find_all_witnesses(target);
+    let target_solutions = solver.find_all_witnesses(target).unwrap();
 
     for sol in &target_solutions {
-        let extracted = reduction.extract_solution(sol);
+        let extracted = reduction.extract_solution(sol).unwrap();
         // Solution length should match number of elements
         assert_eq!(extracted.len(), source.num_elements());
         // Extracted solution should satisfy source if target is satisfied
-        let target_valid = target.evaluate(sol);
-        let source_valid = source.evaluate(&extracted);
+        let target_valid = target.evaluate(sol).unwrap();
+        let source_valid = source.evaluate(&extracted).unwrap();
         if target_valid.0 {
             assert!(
                 source_valid.0,
diff --git a/src/unit_tests/rules/partition_openshopscheduling.rs b/src/unit_tests/rules/partition_openshopscheduling.rs
index ff3b42f81..40bc779df 100644
--- a/src/unit_tests/rules/partition_openshopscheduling.rs
+++ b/src/unit_tests/rules/partition_openshopscheduling.rs
@@ -1,26 +1,31 @@
 use super::*;
+use crate::models::algebraic::ILP;
 use crate::models::misc::{OpenShopScheduling, Partition};
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
-use crate::solvers::BruteForce;
+use crate::solvers::ILPSolver;
 use crate::traits::Problem;
-use crate::types::Min;
+
+fn solve_target(target: &OpenShopScheduling) -> Vec<usize> {
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(target).expect("ILP reduction should succeed");
+    let ilp_solution = ILPSolver::new()
+        .solve(reduction.target_problem())
+        .expect("open-shop target should be feasible");
+    reduction.extract_solution(&ilp_solution).unwrap()
+}
 
 #[test]
 fn test_partition_to_open_shop_scheduling_closed_loop() {
-    let source = Partition::new(vec![1, 2, 3]);
-    let reduction = ReduceTo::<OpenShopScheduling>::reduce_to(&source);
-
-    assert_satisfaction_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "Partition -> OpenShopScheduling closed loop",
-    );
+    let source = Partition::new(vec![1, 2, 3]).unwrap();
+    let reduction = ReduceTo::<OpenShopScheduling>::reduce_to(&source).unwrap();
+    let target_solution = solve_target(reduction.target_problem());
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert!(source.evaluate(&extracted).unwrap());
 }
 
 #[test]
 fn test_partition_to_open_shop_scheduling_structure() {
-    let source = Partition::new(vec![1, 2, 3]);
-    let reduction = ReduceTo::<OpenShopScheduling>::reduce_to(&source);
+    let source = Partition::new(vec![1, 2, 3]).unwrap();
+    let reduction =
+        ReduceTo::<OpenShopScheduling>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_jobs(), 4);
@@ -33,32 +38,131 @@ fn test_partition_to_open_shop_scheduling_structure() {
 
 #[test]
 fn test_partition_to_open_shop_scheduling_extract_solution() {
-    let source = Partition::new(vec![1, 2, 3]);
-    let reduction = ReduceTo::<OpenShopScheduling>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    // Use the solver to get a valid optimal target config
-    let target_solution = BruteForce::new()
-        .find_witness(target)
-        .expect("target should have an optimal solution");
-    let extracted = reduction.extract_solution(&target_solution);
-
-    // The extracted solution should be a valid partition decision
+    let source = Partition::new(vec![1, 2, 3]).unwrap();
+    let reduction = ReduceTo::<OpenShopScheduling>::reduce_to(&source).unwrap();
+    let target_solution = solve_target(reduction.target_problem());
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     assert_eq!(extracted.len(), 3);
-    assert!(extracted.iter().all(|&v| v <= 1));
-    // Since total=6 is even, a satisfying partition exists
-    assert!(source.evaluate(&extracted));
+    assert!(source.evaluate(&extracted).unwrap());
 }
 
 #[test]
 fn test_partition_to_open_shop_scheduling_odd_total_is_not_satisfying() {
-    let source = Partition::new(vec![2, 4, 5]);
-    let reduction = ReduceTo::<OpenShopScheduling>::reduce_to(&source);
-    let target = reduction.target_problem();
-    let best = BruteForce::new()
-        .find_witness(target)
-        .expect("open-shop target should always have an optimal solution");
+    let source = Partition::new(vec![2, 4, 5]).unwrap();
+    let reduction = ReduceTo::<OpenShopScheduling>::reduce_to(&source).unwrap();
+    let best = solve_target(reduction.target_problem());
+    assert!(reduction.extract_solution(&best).is_err());
+}
+
+#[test]
+fn test_partition_to_open_shop_scheduling_preserves_construction_overflow() {
+    let source = Partition::new(vec![1_i64 << 61, 1_i64 << 61]).unwrap();
+    let error = ReduceTo::<OpenShopScheduling>::reduce_to(&source).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::rules::ReductionError::Construction {
+            source_problem: "Partition",
+            target_problem: "OpenShopScheduling",
+            cause: crate::registry::ConstructionError::IntegerOverflow(_),
+        }
+    ));
+}
+
+#[test]
+fn test_partition_to_open_shop_all_small_partitions_and_machine_orders() {
+    use crate::rules::AggregateReductionResult;
+    let permutations = [
+        [0, 1, 2],
+        [0, 2, 1],
+        [1, 0, 2],
+        [1, 2, 0],
+        [2, 0, 1],
+        [2, 1, 0],
+    ];
+    for n in 1..=4 {
+        for mut rank in 0..3usize.pow(n as u32) {
+            let sizes: Vec<_> = (0..n)
+                .map(|_| {
+                    let size = (rank % 3 + 1) as i64;
+                    rank /= 3;
+                    size
+                })
+                .collect();
+            let source = Partition::new(sizes.clone()).unwrap();
+            let reduction = ReduceTo::<OpenShopScheduling>::reduce_to(&source).unwrap();
+            let target = AggregateReductionResult::target_problem(&reduction);
+            assert!(
+                !AggregateReductionResult::extract_value(&reduction, crate::types::Min(None)).0
+            );
+            for mask in 0..(1usize << n) {
+                let assignment: Vec<_> = (0..n).map(|i| mask & (1 << i) != 0).collect();
+                if !source.evaluate(&assignment).unwrap().0 {
+                    continue;
+                }
+                let half = usize::try_from(source.total_sum() / 2).unwrap();
+                for machines in permutations {
+                    let mut schedule = vec![0; (n + 1) * 3];
+                    for phase in 0..3 {
+                        schedule[n * 3 + machines[phase]] = phase * half;
+                        for (group, rotation) in [(true, 1), (false, 2)] {
+                            let machine = machines[(phase + rotation) % 3];
+                            let mut time = phase * half;
+                            for job in 0..n {
+                                if assignment[job] == group {
+                                    schedule[job * 3 + machine] = time;
+                                    time += usize::try_from(sizes[job]).unwrap();
+                                }
+                            }
+                            assert_eq!(time, (phase + 1) * half);
+                        }
+                    }
+                    let value = target.evaluate(&schedule).unwrap();
+                    assert_eq!(value, crate::types::Min(Some(3 * half as i64)));
+                    assert!(AggregateReductionResult::extract_value(&reduction, value).0);
+                    assert_eq!(reduction.extract_solution(&schedule).unwrap(), assignment);
+                    let delayed: Vec<_> = schedule.iter().map(|&time| time + 1).collect();
+                    assert!(target.evaluate(&delayed).unwrap().0.is_some());
+                    assert!(reduction.extract_solution(&delayed).is_err());
+                }
+            }
+            assert!(reduction.extract_solution(&vec![0; (n + 1) * 3]).is_err());
+            assert!(reduction
+                .extract_solution(&vec![0; (n + 1) * 3 + 1])
+                .is_err());
+        }
+    }
+}
 
-    assert_eq!(target.evaluate(&best), Min(Some(16)));
-    assert!(!source.evaluate(&reduction.extract_solution(&best)));
+#[test]
+fn test_partition_to_open_shop_odd_singleton_certificate() {
+    use crate::rules::AggregateReductionResult;
+    let source = Partition::new(vec![1]).unwrap();
+    let reduction = ReduceTo::<OpenShopScheduling>::reduce_to(&source).unwrap();
+    let schedule = vec![0, 1, 2, 0, 0, 0];
+    let value = ReductionResult::target_problem(&reduction)
+        .evaluate(&schedule)
+        .unwrap();
+    assert_eq!(value, crate::types::Min(Some(3)));
+    assert!(!AggregateReductionResult::extract_value(&reduction, value).0);
+    assert!(reduction.extract_solution(&schedule).is_err());
+}
+
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn test_partition_to_open_shop_certificate_near_horizon_limit() {
+    let size = i64::MAX / 9;
+    let source = Partition::new(vec![size, size]).unwrap();
+    let reduction = ReduceTo::<OpenShopScheduling>::reduce_to(&source).unwrap();
+    let a = usize::try_from(size).unwrap();
+    let schedule = vec![0, a, 2 * a, 2 * a, 0, a, a, 2 * a, 0];
+    assert_eq!(
+        reduction.target_problem().evaluate(&schedule).unwrap(),
+        crate::types::Min(Some(3 * size))
+    );
+    assert!(
+        source
+            .evaluate(&reduction.extract_solution(&schedule).unwrap())
+            .unwrap()
+            .0
+    );
 }
diff --git a/src/unit_tests/rules/partition_productionplanning.rs b/src/unit_tests/rules/partition_productionplanning.rs
index ceca9105c..83790b2b5 100644
--- a/src/unit_tests/rules/partition_productionplanning.rs
+++ b/src/unit_tests/rules/partition_productionplanning.rs
@@ -5,8 +5,9 @@ use crate::solvers::BruteForce;
 
 #[test]
 fn test_partition_to_productionplanning_closed_loop() {
-    let source = Partition::new(vec![3, 5, 2, 4, 6]);
-    let reduction = ReduceTo::<ProductionPlanning>::reduce_to(&source);
+    let source = Partition::new(vec![3, 5, 2, 4, 6]).unwrap();
+    let reduction =
+        ReduceTo::<ProductionPlanning>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -17,8 +18,9 @@ fn test_partition_to_productionplanning_closed_loop() {
 
 #[test]
 fn test_partition_to_productionplanning_structure_even_total() {
-    let source = Partition::new(vec![3, 5, 2, 4, 6]);
-    let reduction = ReduceTo::<ProductionPlanning>::reduce_to(&source);
+    let source = Partition::new(vec![3, 5, 2, 4, 6]).unwrap();
+    let reduction =
+        ReduceTo::<ProductionPlanning>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.demands(), &[0, 0, 0, 0, 0, 10]);
@@ -31,24 +33,26 @@ fn test_partition_to_productionplanning_structure_even_total() {
 
 #[test]
 fn test_partition_to_productionplanning_odd_total_is_infeasible() {
-    let source = Partition::new(vec![2, 4, 5]);
-    let reduction = ReduceTo::<ProductionPlanning>::reduce_to(&source);
+    let source = Partition::new(vec![2, 4, 5]).unwrap();
+    let reduction =
+        ReduceTo::<ProductionPlanning>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.demands(), &[0, 0, 0, 6]);
     assert_eq!(target.capacities(), &[2, 4, 5, 0]);
     assert_eq!(target.setup_costs(), &[2, 4, 5, 0]);
     assert_eq!(target.cost_bound(), 5);
-    assert!(BruteForce::new().find_witness(target).is_none());
+    assert!(BruteForce::new().solve(target).unwrap().is_none());
 }
 
 #[test]
 fn test_partition_to_productionplanning_extract_solution() {
-    let source = Partition::new(vec![3, 5, 2, 4, 6]);
-    let reduction = ReduceTo::<ProductionPlanning>::reduce_to(&source);
+    let source = Partition::new(vec![3, 5, 2, 4, 6]).unwrap();
+    let reduction =
+        ReduceTo::<ProductionPlanning>::reduce_to(&source).expect("reduction should succeed");
 
     assert_eq!(
-        reduction.extract_solution(&[0, 0, 0, 4, 6, 0]),
-        vec![0, 0, 0, 1, 1]
+        reduction.extract_solution(&vec![0, 0, 0, 4, 6, 0]).unwrap(),
+        vec![false, false, false, true, true]
     );
 }
diff --git a/src/unit_tests/rules/partition_sequencingtominimizetardytaskweight.rs b/src/unit_tests/rules/partition_sequencingtominimizetardytaskweight.rs
index 75749bc3b..8bb870c3e 100644
--- a/src/unit_tests/rules/partition_sequencingtominimizetardytaskweight.rs
+++ b/src/unit_tests/rules/partition_sequencingtominimizetardytaskweight.rs
@@ -10,8 +10,9 @@ use crate::types::Min;
 
 #[test]
 fn test_partition_to_sequencing_to_minimize_tardy_task_weight_closed_loop() {
-    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    let reduction = ReduceTo::<SequencingToMinimizeTardyTaskWeight>::reduce_to(&source);
+    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    let reduction = ReduceTo::<SequencingToMinimizeTardyTaskWeight>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -22,8 +23,9 @@ fn test_partition_to_sequencing_to_minimize_tardy_task_weight_closed_loop() {
 
 #[test]
 fn test_partition_to_sequencing_to_minimize_tardy_task_weight_structure() {
-    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    let reduction = ReduceTo::<SequencingToMinimizeTardyTaskWeight>::reduce_to(&source);
+    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    let reduction = ReduceTo::<SequencingToMinimizeTardyTaskWeight>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.lengths(), &[3, 1, 1, 2, 2, 1]);
@@ -34,26 +36,36 @@ fn test_partition_to_sequencing_to_minimize_tardy_task_weight_structure() {
 
 #[test]
 fn test_partition_to_sequencing_to_minimize_tardy_task_weight_extract_solution() {
-    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    let reduction = ReduceTo::<SequencingToMinimizeTardyTaskWeight>::reduce_to(&source);
+    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    let reduction = ReduceTo::<SequencingToMinimizeTardyTaskWeight>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_eq!(
-        reduction.extract_solution(&[1, 2, 4, 5, 0, 3]),
-        vec![1, 0, 0, 1, 0, 0]
+        reduction.extract_solution(&vec![1, 2, 4, 5, 0, 3]).unwrap(),
+        vec![true, false, false, true, false, false]
     );
 }
 
 #[test]
 fn test_partition_to_sequencing_to_minimize_tardy_task_weight_odd_total_is_unsatisfying() {
-    let source = Partition::new(vec![2, 4, 5]);
-    let reduction = ReduceTo::<SequencingToMinimizeTardyTaskWeight>::reduce_to(&source);
+    let source = Partition::new(vec![2, 4, 5]).unwrap();
+    let reduction = ReduceTo::<SequencingToMinimizeTardyTaskWeight>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     let best = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("target should always have an optimal schedule");
 
-    assert_eq!(target.evaluate(&best), Min(Some(6)));
-    assert!(!source.evaluate(&reduction.extract_solution(&best)));
+    assert_eq!(target.evaluate(&best).unwrap(), Min(Some(6)));
+    assert!(
+        !crate::rules::AggregateReductionResult::extract_value(
+            &reduction,
+            target.evaluate(&best).unwrap()
+        )
+        .0
+    );
+    assert!(reduction.extract_solution(&best).is_err());
 }
 
 #[cfg(feature = "example-db")]
@@ -83,8 +95,14 @@ fn test_partition_to_sequencing_to_minimize_tardy_task_weight_canonical_example_
         serde_json::json!([5, 5, 5, 5, 5, 5])
     );
     assert_eq!(example.solutions.len(), 1);
-    assert_eq!(example.solutions[0].source_config, vec![1, 0, 0, 1, 0, 0]);
-    assert_eq!(example.solutions[0].target_config, vec![1, 2, 4, 5, 0, 3]);
+    assert_eq!(
+        example.solutions[0].source_config,
+        serde_json::json!([true, false, false, true, false, false])
+    );
+    assert_eq!(
+        example.solutions[0].target_config,
+        serde_json::json!([1, 2, 4, 5, 0, 3])
+    );
 
     let source: Partition = serde_json::from_value(example.source.instance.clone())
         .expect("source example deserializes");
@@ -92,10 +110,95 @@ fn test_partition_to_sequencing_to_minimize_tardy_task_weight_canonical_example_
         serde_json::from_value(example.target.instance.clone())
             .expect("target example deserializes");
 
-    assert!(source
-        .evaluate(&example.solutions[0].source_config)
-        .is_valid());
-    assert!(target
-        .evaluate(&example.solutions[0].target_config)
-        .is_valid());
+    let source_config: Vec<bool> =
+        serde_json::from_value(example.solutions[0].source_config.clone()).unwrap();
+    let target_config: Vec<usize> =
+        serde_json::from_value(example.solutions[0].target_config.clone()).unwrap();
+    assert!(source.evaluate(&source_config).unwrap().is_valid());
+    assert!(target.evaluate(&target_config).unwrap().is_valid());
+}
+
+#[test]
+fn test_partition_to_tardy_weight_all_small_configurations() {
+    for n in 1u32..=4 {
+        for mut encoded in 0..3usize.pow(n) {
+            let sizes: Vec<i64> = (0..n)
+                .map(|_| {
+                    let size = (encoded % 3 + 1) as i64;
+                    encoded /= 3;
+                    size
+                })
+                .collect();
+            let source = Partition::new(sizes).unwrap();
+            let reduction =
+                ReduceTo::<SequencingToMinimizeTardyTaskWeight>::reduce_to(&source).unwrap();
+            let target = crate::rules::AggregateReductionResult::target_problem(&reduction);
+            let source_feasible = (0..1usize << n).any(|mask| {
+                let bits = (0..n).map(|i| mask & (1 << i) != 0).collect();
+                source.evaluate(&bits).unwrap().0
+            });
+            let mut optimum = i64::MAX;
+            for mut code in 0..(n as usize).pow(n) {
+                let schedule = (0..n)
+                    .map(|_| {
+                        let task = code % n as usize;
+                        code /= n as usize;
+                        task
+                    })
+                    .collect();
+                let value = target.evaluate(&schedule).unwrap();
+                if let Some(weight) = value.0 {
+                    optimum = optimum.min(weight);
+                }
+                let certified =
+                    crate::rules::AggregateReductionResult::extract_value(&reduction, value).0;
+                let extracted = reduction.extract_solution(&schedule);
+                assert_eq!(extracted.is_ok(), certified);
+                if let Ok(bits) = extracted {
+                    assert!(source.evaluate(&bits).unwrap().0);
+                }
+            }
+            assert_eq!(
+                crate::rules::AggregateReductionResult::extract_value(
+                    &reduction,
+                    Min(Some(optimum)),
+                )
+                .0,
+                source_feasible
+            );
+            assert!(reduction.extract_solution(&vec![]).is_err());
+            assert!(reduction
+                .extract_solution(&vec![n as usize; n as usize])
+                .is_err());
+            assert!(
+                !crate::rules::AggregateReductionResult::extract_value(&reduction, Min(None),).0
+            );
+        }
+    }
+}
+
+#[test]
+fn test_partition_to_tardy_weight_full_i64_domain() {
+    let half = i64::MAX / 2;
+    for (sizes, schedule, expected, balanced) in [
+        (vec![i64::MAX], vec![0], i64::MAX, false),
+        (vec![i64::MAX - 1, 1], vec![1, 0], i64::MAX - 1, false),
+        (vec![half, half], vec![0, 1], half, true),
+        (vec![half - 1, half - 1, 1, 1], vec![0, 2, 1, 3], half, true),
+    ] {
+        let source = Partition::new(sizes).unwrap();
+        let reduction =
+            ReduceTo::<SequencingToMinimizeTardyTaskWeight>::reduce_to(&source).unwrap();
+        let value = reduction.target_problem().evaluate(&schedule).unwrap();
+        assert_eq!(value, Min(Some(expected)));
+        assert_eq!(
+            crate::rules::AggregateReductionResult::extract_value(&reduction, value).0,
+            balanced
+        );
+        let extracted = reduction.extract_solution(&schedule);
+        assert_eq!(extracted.is_ok(), balanced);
+        if let Ok(bits) = extracted {
+            assert!(source.evaluate(&bits).unwrap().0);
+        }
+    }
 }
diff --git a/src/unit_tests/rules/partition_subsetsum.rs b/src/unit_tests/rules/partition_subsetsum.rs
index 9395e8571..2e87577e8 100644
--- a/src/unit_tests/rules/partition_subsetsum.rs
+++ b/src/unit_tests/rules/partition_subsetsum.rs
@@ -1,12 +1,11 @@
 use super::*;
 use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
 use crate::solvers::BruteForce;
-use crate::traits::Problem;
 
 #[test]
 fn test_partition_to_subsetsum_closed_loop() {
-    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    let reduction = ReduceTo::<SubsetSum>::reduce_to(&source);
+    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -17,8 +16,8 @@ fn test_partition_to_subsetsum_closed_loop() {
 
 #[test]
 fn test_partition_to_subsetsum_structure() {
-    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]);
-    let reduction = ReduceTo::<SubsetSum>::reduce_to(&source);
+    let source = Partition::new(vec![3, 1, 1, 2, 2, 1]).unwrap();
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Same number of elements
@@ -36,8 +35,8 @@ fn test_partition_to_subsetsum_structure() {
 #[test]
 fn test_partition_to_subsetsum_odd_total() {
     // Odd total sum: 2 + 4 + 5 = 11, no balanced partition possible
-    let source = Partition::new(vec![2, 4, 5]);
-    let reduction = ReduceTo::<SubsetSum>::reduce_to(&source);
+    let source = Partition::new(vec![2, 4, 5]).unwrap();
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Trivially infeasible: empty sizes, target = 1
@@ -45,21 +44,21 @@ fn test_partition_to_subsetsum_odd_total() {
     assert_eq!(*target.target(), num_bigint::BigUint::from(1u32));
 
     // No witness should exist for the target
-    let witness = BruteForce::new().find_witness(target);
+    let witness = BruteForce::new().solve(target).unwrap();
     assert!(witness.is_none());
 
-    // extract_solution should return all-zeros for the source
-    let extracted = reduction.extract_solution(&[]);
-    assert_eq!(extracted, vec![0, 0, 0]);
-    // The extracted solution should not satisfy the source
-    assert!(!source.evaluate(&extracted));
+    let error = reduction.extract_solution(&vec![]).unwrap_err();
+    assert_eq!(
+        error.to_string(),
+        "expected 3 subset-selection values, got 0"
+    );
 }
 
 #[test]
 fn test_partition_to_subsetsum_equal_elements() {
     // All equal: [2, 2, 2, 2], total = 8, target = 4
-    let source = Partition::new(vec![2, 2, 2, 2]);
-    let reduction = ReduceTo::<SubsetSum>::reduce_to(&source);
+    let source = Partition::new(vec![2, 2, 2, 2]).unwrap();
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -67,3 +66,13 @@ fn test_partition_to_subsetsum_equal_elements() {
         "Partition -> SubsetSum equal elements",
     );
 }
+
+#[test]
+fn test_partition_to_subsetsum_rejects_wrong_solution_length() {
+    let source = Partition::new(vec![1, 1, 2, 2]).unwrap();
+    let reduction = ReduceTo::<SubsetSum>::reduce_to(&source).expect("reduction should succeed");
+
+    assert!(reduction
+        .extract_solution(&vec![false, true, false])
+        .is_err());
+}
diff --git a/src/unit_tests/rules/partition_sumofsquarespartition.rs b/src/unit_tests/rules/partition_sumofsquarespartition.rs
index c1801c296..5f5a46fc6 100644
--- a/src/unit_tests/rules/partition_sumofsquarespartition.rs
+++ b/src/unit_tests/rules/partition_sumofsquarespartition.rs
@@ -1,13 +1,14 @@
 use super::*;
 use crate::models::misc::{Partition, SumOfSquaresPartition};
 use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
 
-fn reduce_partition(sizes: &[u64]) -> (Partition, ReductionPartitionToSumOfSquaresPartition) {
-    let source = Partition::new(sizes.to_vec());
-    let reduction = ReduceTo::<SumOfSquaresPartition>::reduce_to(&source);
+fn reduce_partition(sizes: &[i64]) -> (Partition, ReductionPartitionToSumOfSquaresPartition) {
+    let source = Partition::new(sizes.to_vec()).unwrap();
+    let reduction =
+        ReduceTo::<SumOfSquaresPartition>::reduce_to(&source).expect("reduction should succeed");
     (source, reduction)
 }
 
@@ -27,33 +28,33 @@ fn test_partition_to_sumofsquarespartition_closed_loop() {
     let (source_no_even, reduction_no_even) = reduce_partition(&[1, 1, 1, 5]);
     let target_no_even = reduction_no_even.target_problem();
     let solver = BruteForce::new();
-    let target_witnesses = solver.find_all_witnesses(target_no_even);
+    let target_witnesses = solver.find_all_witnesses(target_no_even).unwrap();
     assert!(!target_witnesses.is_empty());
     for witness in &target_witnesses {
-        let extracted = reduction_no_even.extract_solution(witness);
+        let extracted = reduction_no_even.extract_solution(witness).unwrap();
         assert_eq!(extracted.len(), source_no_even.num_elements());
         assert!(
-            !source_no_even.evaluate(&extracted).0,
+            !source_no_even.evaluate(&extracted).unwrap().0,
             "even-sum but unbalanced NO Partition: extracted witness {extracted:?} should not satisfy source"
         );
     }
     // Confirm the source is genuinely NO via direct solve.
-    let direct_witness = solver.find_witness(&source_no_even);
+    let direct_witness = solver.solve(&source_no_even).unwrap();
     assert!(direct_witness.is_none());
 
     // Odd-sum NO case: sizes [2, 4, 5], S = 11.
     let (source_no_odd, reduction_no_odd) = reduce_partition(&[2, 4, 5]);
     let target_no_odd = reduction_no_odd.target_problem();
-    let target_witnesses_odd = solver.find_all_witnesses(target_no_odd);
+    let target_witnesses_odd = solver.find_all_witnesses(target_no_odd).unwrap();
     assert!(!target_witnesses_odd.is_empty());
     for witness in &target_witnesses_odd {
-        let extracted = reduction_no_odd.extract_solution(witness);
+        let extracted = reduction_no_odd.extract_solution(witness).unwrap();
         assert!(
-            !source_no_odd.evaluate(&extracted).0,
+            !source_no_odd.evaluate(&extracted).unwrap().0,
             "odd-sum NO Partition: extracted witness {extracted:?} should not satisfy source"
         );
     }
-    assert!(solver.find_witness(&source_no_odd).is_none());
+    assert!(solver.solve(&source_no_odd).unwrap().is_none());
 }
 
 #[test]
@@ -72,7 +73,8 @@ fn test_partition_to_sumofsquarespartition_optimal_value_yes() {
     let (_source, reduction) = reduce_partition(&[3, 1, 1, 2, 2, 1]);
     let target = reduction.target_problem();
     let solver = BruteForce::new();
-    let optimal = solver.solve(target);
+    let optimal_solution = solver.solve(target).unwrap().unwrap();
+    let optimal = target.evaluate(&optimal_solution).unwrap();
     assert_eq!(optimal, Min(Some(50)));
 }
 
@@ -82,7 +84,8 @@ fn test_partition_to_sumofsquarespartition_optimal_value_no_even() {
     let (_source, reduction) = reduce_partition(&[1, 1, 1, 5]);
     let target = reduction.target_problem();
     let solver = BruteForce::new();
-    let optimal = solver.solve(target);
+    let optimal_solution = solver.solve(target).unwrap().unwrap();
+    let optimal = target.evaluate(&optimal_solution).unwrap();
     assert_eq!(optimal, Min(Some(34)));
     // Strictly greater than S^2/2 = 32.
     assert!(optimal.0.unwrap() > 32);
@@ -100,21 +103,27 @@ fn test_partition_to_sumofsquarespartition_singleton_sentinel() {
     assert_eq!(target.num_elements(), 2);
 
     let solver = BruteForce::new();
-    let target_witnesses = solver.find_all_witnesses(target);
+    let target_witnesses = solver.find_all_witnesses(target).unwrap();
     assert!(!target_witnesses.is_empty());
 
     for witness in &target_witnesses {
-        let extracted = reduction.extract_solution(witness);
+        let extracted = reduction.extract_solution(witness).unwrap();
         assert_eq!(extracted.len(), source.num_elements());
-        assert_eq!(extracted, vec![0]);
+        assert_eq!(
+            extracted,
+            witness[..source.num_elements()]
+                .iter()
+                .map(|&value| value != 0)
+                .collect::<Vec<_>>()
+        );
         assert!(
-            !source.evaluate(&extracted).0,
+            !source.evaluate(&extracted).unwrap().0,
             "singleton Partition: extracted witness must yield Or(false)"
         );
     }
 
     // Direct solve confirms the source is NO.
-    assert!(solver.find_witness(&source).is_none());
+    assert!(solver.solve(&source).unwrap().is_none());
 }
 
 #[test]
@@ -125,16 +134,24 @@ fn test_partition_to_sumofsquarespartition_solution_extraction_identity() {
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let target_witnesses = solver.find_all_witnesses(target);
-    let source_witnesses: std::collections::HashSet<Vec<usize>> =
-        solver.find_all_witnesses(&source).into_iter().collect();
+    let target_witnesses = solver.find_all_witnesses(target).unwrap();
+    let source_witnesses: std::collections::HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
 
     for witness in &target_witnesses {
-        let extracted = reduction.extract_solution(witness);
-        assert_eq!(extracted, *witness);
+        let extracted = reduction.extract_solution(witness).unwrap();
+        assert_eq!(
+            extracted,
+            witness.iter().map(|&value| value != 0).collect::<Vec<_>>()
+        );
         assert!(
             source_witnesses.contains(&extracted),
             "extracted witness {extracted:?} must be a valid Partition solution"
         );
     }
+
+    assert!(reduction.extract_solution(&vec![0]).is_err());
 }
diff --git a/src/unit_tests/rules/partitionintocliques_ilp.rs b/src/unit_tests/rules/partitionintocliques_ilp.rs
new file mode 100644
index 000000000..564c1af27
--- /dev/null
+++ b/src/unit_tests/rules/partitionintocliques_ilp.rs
@@ -0,0 +1,33 @@
+use super::*;
+use crate::solvers::ILPSolver;
+use crate::traits::Problem;
+use crate::types::Or;
+
+#[test]
+fn test_partitionintocliques_to_ilp_size() {
+    let problem = PartitionIntoCliques::new(SimpleGraph::new(3, vec![(0, 1)]), 2);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+
+    assert_eq!(reduction.target_problem().num_vars(), 6);
+    assert_eq!(reduction.target_problem().constraints().len(), 7);
+}
+
+#[test]
+fn test_partitionintocliques_to_ilp_closed_loop() {
+    let problem = PartitionIntoCliques::new(SimpleGraph::new(4, vec![(0, 1), (2, 3)]), 2);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+    let target_solution = ILPSolver::new()
+        .solve(reduction.target_problem())
+        .expect("two disjoint edges form two cliques");
+    let source_solution = reduction.extract_solution(&target_solution).unwrap();
+
+    assert_eq!(problem.evaluate(&source_solution).unwrap(), Or(true));
+}
+
+#[test]
+fn test_partitionintocliques_to_ilp_preserves_infeasibility() {
+    let problem = PartitionIntoCliques::new(SimpleGraph::new(3, vec![]), 2);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+
+    assert!(ILPSolver::new().solve(reduction.target_problem()).is_err());
+}
diff --git a/src/unit_tests/rules/partitionintocliques_minimumcoveringbycliques.rs b/src/unit_tests/rules/partitionintocliques_minimumcoveringbycliques.rs
index b1b5d9836..c3e5fb245 100644
--- a/src/unit_tests/rules/partitionintocliques_minimumcoveringbycliques.rs
+++ b/src/unit_tests/rules/partitionintocliques_minimumcoveringbycliques.rs
@@ -2,12 +2,45 @@ use super::*;
 use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
 use crate::topology::Graph;
 use crate::traits::Problem;
-use crate::types::{Min, Or};
+use crate::types::Min;
+
+#[test]
+fn test_partitionintocliques_target_bound_rejects_overflow() {
+    assert_eq!(target_clique_bound(1, i64::MAX - 3), Ok(i64::MAX));
+    for (cliques, edges) in [(2, i64::MAX - 3), (1, i64::MAX - 2), (1, i64::MAX)] {
+        assert!(matches!(
+            target_clique_bound(cliques, edges),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+}
+
+#[test]
+fn test_partitionintocliques_aggregate_applies_gadget_offset() {
+    let source = PartitionIntoCliques::new(SimpleGraph::new(3, vec![(0, 1)]), 2);
+    let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source).unwrap();
+    // K + 2m + 2 = 6, including both directed-edge gadgets and the side cliques.
+    for (value, expected) in [
+        (Min(None), false),
+        (Min(Some(5)), true),
+        (Min(Some(6)), true),
+        (Min(Some(7)), false),
+    ] {
+        assert_eq!(
+            crate::rules::AggregateReductionResult::extract_value(&reduction, value),
+            crate::types::Or(expected),
+        );
+    }
+}
 
 #[test]
 fn test_partitionintocliques_to_minimumcoveringbycliques_closed_loop() {
-    let source = PartitionIntoCliques::new(SimpleGraph::new(1, vec![]), 1);
-    let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source);
+    let source: PartitionIntoCliques<SimpleGraph> = serde_json::from_value(serde_json::json!({
+        "graph": {"num_vertices": 0, "edges": []}, "num_cliques": 0
+    }))
+    .unwrap();
+    let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_optimization_target(
         &source,
@@ -19,12 +52,13 @@ fn test_partitionintocliques_to_minimumcoveringbycliques_closed_loop() {
 #[test]
 fn test_partitionintocliques_to_minimumcoveringbycliques_orlin_example_structure() {
     let source = PartitionIntoCliques::new(SimpleGraph::new(3, vec![(0, 1)]), 2);
-    let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     let layout = OrlinLayout::new(source.graph());
 
-    assert_eq!(target.graph().num_vertices(), 12);
-    assert_eq!(target.graph().num_edges(), 41);
+    assert_eq!(target.graph().num_vertices(), 14);
+    assert_eq!(target.graph().num_edges(), 53);
 
     // Left clique on x_0, x_1, x_2, a_(0,1), a_(1,0)
     assert!(target.graph().has_edge(0, 1));
@@ -67,14 +101,18 @@ fn test_partitionintocliques_to_minimumcoveringbycliques_orlin_example_structure
             },
         ],
     );
-    assert_eq!(target.evaluate(&target_solution), Min(Some(6)));
-    assert_eq!(reduction.extract_solution(&target_solution), vec![0, 0, 1]);
+    assert_eq!(target.evaluate(&target_solution).unwrap(), Min(Some(6)));
+    assert_eq!(
+        reduction.extract_solution(&target_solution).unwrap(),
+        vec![0, 0, 1]
+    );
 }
 
 #[test]
 fn test_partitionintocliques_to_minimumcoveringbycliques_unsat_extracts_invalid_source() {
     let source = PartitionIntoCliques::new(SimpleGraph::new(2, vec![]), 1);
-    let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source);
+    let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
     let layout = OrlinLayout::new(source.graph());
 
@@ -95,9 +133,107 @@ fn test_partitionintocliques_to_minimumcoveringbycliques_unsat_extracts_invalid_
             vec![layout.x(1), layout.y(1)],
         ],
     );
-    assert_eq!(target.evaluate(&target_solution), Min(Some(4)));
+    assert_eq!(target.evaluate(&target_solution).unwrap(), Min(Some(4)));
 
-    let extracted = reduction.extract_solution(&target_solution);
+    assert_eq!(
+        reduction
+            .extract_solution(&target_solution)
+            .unwrap_err()
+            .to_string(),
+        "target cover does not certify the source clique bound"
+    );
+}
 
-    assert_eq!(source.evaluate(&extracted), Or(false));
+#[test]
+fn test_partitionintocliques_native_bounds_and_adjacency_semantics() {
+    use crate::rules::AggregateReductionResult;
+    for (n, edges) in [
+        (0, vec![]),
+        (1, vec![(0, 0)]),
+        (2, vec![(0, 0)]),
+        (3, vec![(0, 1), (1, 0), (0, 0)]),
+    ] {
+        for bound in [0, 1, n, n + 1, usize::MAX] {
+            let source: PartitionIntoCliques<SimpleGraph> =
+                serde_json::from_value(serde_json::json!({
+                    "graph": {"num_vertices": n, "edges": edges}, "num_cliques": bound
+                }))
+                .unwrap();
+            let reduction =
+                ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source).unwrap();
+            let target = ReductionResult::target_problem(&reduction);
+            let layout = OrlinLayout::new(source.graph());
+            let mut cliques: Vec<Vec<usize>> =
+                (0..n).map(|i| vec![layout.x(i), layout.y(i)]).collect();
+            for (idx, &(i, j)) in layout.directed_pairs.iter().enumerate() {
+                cliques.push(vec![layout.x(i), layout.a(idx), layout.b(idx), layout.y(j)]);
+            }
+            let mut left = layout.left_vertices();
+            left.push(layout.z_left());
+            cliques.push(left);
+            let mut right = layout.right_vertices();
+            right.push(layout.z_right());
+            cliques.push(right);
+            let witness = edge_labels_from_clique_cover(target.graph(), &cliques);
+            let value = target.evaluate(&witness).unwrap();
+            assert_eq!(
+                value,
+                Min(Some((n + layout.num_directed_pairs() + 2) as i64))
+            );
+            assert_eq!(
+                AggregateReductionResult::extract_value(&reduction, value).0,
+                n <= bound
+            );
+            if n <= bound {
+                let decoded = reduction.extract_solution(&witness).unwrap();
+                assert_eq!(decoded, (0..n).collect::<Vec<_>>());
+                if bound <= n + 1 {
+                    assert!(source.evaluate(&decoded).unwrap().0);
+                }
+            } else {
+                assert!(reduction.extract_solution(&witness).is_err());
+            }
+            assert!(reduction.extract_solution(&vec![0; witness.len()]).is_err());
+            assert!(reduction
+                .extract_solution(&vec![0; witness.len() + 1])
+                .is_err());
+            let q = layout.num_directed_pairs();
+            assert_eq!(target.num_vertices(), 2 * n + 2 * q + 4);
+            assert_eq!(target.num_edges(), (n + q) * (n + q) + 4 * n + 7 * q + 2);
+        }
+    }
+}
+
+#[test]
+fn test_partitionintocliques_layout_dimensions_numeric_domain() {
+    // Dimension arithmetic can be checked without allocating the represented graph.
+    for (n, expected) in [(0, (4, 2)), (1, (6, 7)), (3, (10, 23))] {
+        let layout = OrlinLayout {
+            num_source_vertices: n,
+            directed_pairs: vec![],
+        };
+        assert_eq!(layout.dimensions().unwrap(), expected);
+    }
+    for n in [usize::MAX, usize::MAX / 2, 1usize << (usize::BITS / 2)] {
+        let layout = OrlinLayout {
+            num_source_vertices: n,
+            directed_pairs: vec![],
+        };
+        assert!(matches!(
+            layout.dimensions(),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+    #[cfg(target_pointer_width = "64")]
+    {
+        // Vertex and edge indices fit usize, but not every cover value fits i64.
+        let layout = OrlinLayout {
+            num_source_vertices: 3_037_000_500,
+            directed_pairs: vec![],
+        };
+        assert!(matches!(
+            layout.dimensions(),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
 }
diff --git a/src/unit_tests/rules/partitionintopathsoflength2_boundedcomponentspanningforest.rs b/src/unit_tests/rules/partitionintopathsoflength2_boundedcomponentspanningforest.rs
index 66482bc1e..81b97ac33 100644
--- a/src/unit_tests/rules/partitionintopathsoflength2_boundedcomponentspanningforest.rs
+++ b/src/unit_tests/rules/partitionintopathsoflength2_boundedcomponentspanningforest.rs
@@ -11,7 +11,8 @@ fn test_partitionintopathsoflength2_to_boundedcomponentspanningforest_closed_loo
     // 6-vertex graph with two P3 paths: 0-1-2 and 3-4-5
     let source =
         PartitionIntoPathsOfLength2::new(SimpleGraph::new(6, vec![(0, 1), (1, 2), (3, 4), (4, 5)]));
-    let result = ReduceTo::<BoundedComponentSpanningForest<SimpleGraph, i32>>::reduce_to(&source);
+    let result = ReduceTo::<BoundedComponentSpanningForest<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = result.target_problem();
 
     // Check target structure
@@ -38,9 +39,10 @@ fn test_partitionintopathsoflength2_to_boundedcomponentspanningforest_no_solutio
         6,
         vec![(0, 1), (1, 2), (0, 2)], // triangle on {0,1,2}, no edges on {3,4,5}
     ));
-    let result = ReduceTo::<BoundedComponentSpanningForest<SimpleGraph, i32>>::reduce_to(&source);
+    let result = ReduceTo::<BoundedComponentSpanningForest<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(result.target_problem());
+    let solutions = solver.find_all_witnesses(result.target_problem()).unwrap();
     assert!(
         solutions.is_empty(),
         "No P3-partition exists, so BCSF should have no solution"
@@ -66,7 +68,8 @@ fn test_partitionintopathsoflength2_to_boundedcomponentspanningforest_triangle_p
             (0, 5),
         ],
     ));
-    let result = ReduceTo::<BoundedComponentSpanningForest<SimpleGraph, i32>>::reduce_to(&source);
+    let result = ReduceTo::<BoundedComponentSpanningForest<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = result.target_problem();
 
     assert_eq!(target.num_vertices(), 9);
@@ -85,12 +88,13 @@ fn test_partitionintopathsoflength2_to_boundedcomponentspanningforest_extract_so
     // Verify extract_solution is identity
     let source =
         PartitionIntoPathsOfLength2::new(SimpleGraph::new(6, vec![(0, 1), (1, 2), (3, 4), (4, 5)]));
-    let result = ReduceTo::<BoundedComponentSpanningForest<SimpleGraph, i32>>::reduce_to(&source);
+    let result = ReduceTo::<BoundedComponentSpanningForest<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     let target_config = vec![0, 0, 0, 1, 1, 1];
-    let extracted = result.extract_solution(&target_config);
+    let extracted = result.extract_solution(&target_config).unwrap();
     assert_eq!(extracted, vec![0, 0, 0, 1, 1, 1]);
 
     // Verify the extracted solution is valid in the source
-    assert!(source.evaluate(&extracted).0);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
diff --git a/src/unit_tests/rules/partitionintopathsoflength2_ilp.rs b/src/unit_tests/rules/partitionintopathsoflength2_ilp.rs
index a76085cd5..35544e23d 100644
--- a/src/unit_tests/rules/partitionintopathsoflength2_ilp.rs
+++ b/src/unit_tests/rules/partitionintopathsoflength2_ilp.rs
@@ -9,19 +9,20 @@ fn test_reduction_creates_valid_ilp() {
     // Two P3 paths: 0-1-2 and 3-4-5
     let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (3, 4), (4, 5)]);
     let problem = PartitionIntoPathsOfLength2::new(graph);
-    let reduction: ReductionPIPL2ToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPIPL2ToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=6, q=2, num_edges=4
     // num_vars = 6*2 + 4*2 = 12 + 8 = 20
-    assert_eq!(ilp.num_vars, 20, "Should have 20 variables");
+    assert_eq!(ilp.num_vars(), 20, "Should have 20 variables");
     assert_eq!(
-        ilp.sense,
+        ilp.sense(),
         ObjectiveSense::Minimize,
         "Should minimize (feasibility)"
     );
     // Constraints: 6 assignment + 2 group-size + 4*2*3 McCormick + 2 edge count = 6+2+24+2=34
-    assert_eq!(ilp.constraints.len(), 34, "Should have 34 constraints");
+    assert_eq!(ilp.constraints().len(), 34, "Should have 34 constraints");
 }
 
 #[test]
@@ -29,21 +30,23 @@ fn test_partitionintopathsoflength2_to_ilp_bf_vs_ilp() {
     // Two P3 paths: 0-1-2 and 3-4-5
     let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (3, 4), (4, 5)]);
     let problem = PartitionIntoPathsOfLength2::new(graph);
-    let reduction: ReductionPIPL2ToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPIPL2ToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("BF should find a solution");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "Extracted ILP solution should be valid"
     );
@@ -54,7 +57,8 @@ fn test_solution_extraction() {
     // Two P3 paths: 0-1-2 and 3-4-5
     let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (3, 4), (4, 5)]);
     let problem = PartitionIntoPathsOfLength2::new(graph);
-    let reduction: ReductionPIPL2ToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPIPL2ToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // x vars (12): group 0 gets 0,1,2; group 1 gets 3,4,5
     // x_{0,0}=1,x_{0,1}=0, x_{1,0}=1,x_{1,1}=0, x_{2,0}=1,x_{2,1}=0,
@@ -65,9 +69,9 @@ fn test_solution_extraction() {
         1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, // x vars
         1, 0, 1, 0, 0, 1, 0, 1, // y vars
     ];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 0, 0, 1, 1, 1]);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -75,14 +79,15 @@ fn test_partitionintopathsoflength2_to_ilp_trivial() {
     // Minimal feasible: one P3 path 0-1-2
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = PartitionIntoPathsOfLength2::new(graph);
-    let reduction: ReductionPIPL2ToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPIPL2ToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "Single P3 should be feasible"
     );
diff --git a/src/unit_tests/rules/partitionintotriangles_ilp.rs b/src/unit_tests/rules/partitionintotriangles_ilp.rs
index e66443b53..0173f42b3 100644
--- a/src/unit_tests/rules/partitionintotriangles_ilp.rs
+++ b/src/unit_tests/rules/partitionintotriangles_ilp.rs
@@ -9,19 +9,20 @@ fn test_reduction_creates_valid_ilp() {
     // Single triangle: 3 vertices, 3 edges, q=1 group
     let graph = SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]);
     let problem = PartitionIntoTriangles::new(graph);
-    let reduction: ReductionPITToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPITToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // num_vars = 3 vertices * 1 group = 3
-    assert_eq!(ilp.num_vars, 3, "Should have 3 variables");
+    assert_eq!(ilp.num_vars(), 3, "Should have 3 variables");
     assert_eq!(
-        ilp.sense,
+        ilp.sense(),
         ObjectiveSense::Minimize,
         "Should minimize (feasibility)"
     );
     // Constraints: 3 assignment + 1 group-size = 4
     // Non-edges: none (complete triangle), so no triangle constraints
-    assert_eq!(ilp.constraints.len(), 4, "Should have 4 constraints");
+    assert_eq!(ilp.constraints().len(), 4, "Should have 4 constraints");
 }
 
 #[test]
@@ -29,21 +30,23 @@ fn test_partitionintotriangles_to_ilp_bf_vs_ilp() {
     // Two triangles: vertices {0,1,2} and {3,4,5}
     let graph = SimpleGraph::new(6, vec![(0, 1), (0, 2), (1, 2), (3, 4), (3, 5), (4, 5)]);
     let problem = PartitionIntoTriangles::new(graph);
-    let reduction: ReductionPITToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPITToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("BF should find a solution");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "Extracted ILP solution should be valid"
     );
@@ -54,14 +57,15 @@ fn test_solution_extraction() {
     // Two triangles: 6 vertices, q=2 groups
     let graph = SimpleGraph::new(6, vec![(0, 1), (0, 2), (1, 2), (3, 4), (3, 5), (4, 5)]);
     let problem = PartitionIntoTriangles::new(graph);
-    let reduction: ReductionPITToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPITToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // x_{v,g}: v0g0=1,v0g1=0, v1g0=1,v1g1=0, v2g0=1,v2g1=0,
     //           v3g0=0,v3g1=1, v4g0=0,v4g1=1, v5g0=0,v5g1=1
     let ilp_solution = vec![1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 0, 0, 1, 1, 1]);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -69,11 +73,12 @@ fn test_partitionintotriangles_to_ilp_trivial() {
     // Minimal: single triangle
     let graph = SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]);
     let problem = PartitionIntoTriangles::new(graph);
-    let reduction: ReductionPITToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPITToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/pathconstrainednetworkflow_ilp.rs b/src/unit_tests/rules/pathconstrainednetworkflow_ilp.rs
index a6f971326..ac4111f81 100644
--- a/src/unit_tests/rules/pathconstrainednetworkflow_ilp.rs
+++ b/src/unit_tests/rules/pathconstrainednetworkflow_ilp.rs
@@ -17,17 +17,18 @@ fn test_pathconstrainednetworkflow_to_ilp_closed_loop() {
         2,
     );
     let direct = BruteForce::new()
-        .find_witness(&source)
+        .solve(&source)
+        .unwrap()
         .expect("source instance should be satisfiable");
-    assert!(source.evaluate(&direct));
+    assert!(source.evaluate(&direct).unwrap());
 
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(source.evaluate(&extracted));
+    assert!(source.evaluate(&extracted).unwrap());
 }
 
 #[test]
@@ -40,6 +41,6 @@ fn test_pathconstrainednetworkflow_to_ilp_bf_vs_ilp() {
         vec![vec![0, 1], vec![2]],
         2,
     );
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/precedenceconstrainedscheduling_ilp.rs b/src/unit_tests/rules/precedenceconstrainedscheduling_ilp.rs
index 4f4e3a363..3f54767c4 100644
--- a/src/unit_tests/rules/precedenceconstrainedscheduling_ilp.rs
+++ b/src/unit_tests/rules/precedenceconstrainedscheduling_ilp.rs
@@ -16,16 +16,17 @@ fn infeasible_instance() -> PrecedenceConstrainedScheduling {
 #[test]
 fn test_precedenceconstrainedscheduling_to_ilp_structure() {
     let problem = feasible_instance();
-    let reduction: ReductionPCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=3 tasks, d=2 deadline → 6 variables
-    assert_eq!(ilp.num_vars, 6);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 6);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(ilp.objective().is_empty());
 
     // n one-hot constraints + d capacity constraints + 1 precedence = 3 + 2 + 1 = 6
-    assert_eq!(ilp.constraints.len(), 6);
+    assert_eq!(ilp.constraints().len(), 6);
 }
 
 #[test]
@@ -33,21 +34,23 @@ fn test_precedenceconstrainedscheduling_to_ilp_closed_loop() {
     let problem = feasible_instance();
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("feasible instance should have a witness");
     assert!(
-        problem.evaluate(&bf_solution).0,
+        problem.evaluate(&bf_solution).unwrap().0,
         "brute force solution should be valid"
     );
 
-    let reduction: ReductionPCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible for feasible instance");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "ILP extracted solution should be a valid schedule"
     );
 }
@@ -55,9 +58,10 @@ fn test_precedenceconstrainedscheduling_to_ilp_closed_loop() {
 #[test]
 fn test_precedenceconstrainedscheduling_to_ilp_infeasible() {
     let problem = infeasible_instance();
-    let reduction: ReductionPCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible scheduling instance should produce infeasible ILP"
     );
 }
@@ -65,15 +69,16 @@ fn test_precedenceconstrainedscheduling_to_ilp_infeasible() {
 #[test]
 fn test_precedenceconstrainedscheduling_to_ilp_extract_solution() {
     let problem = feasible_instance();
-    let reduction: ReductionPCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manually: task 0 at slot 0, task 1 at slot 0, task 2 at slot 1
     // x_{0,0}=1, x_{0,1}=0, x_{1,0}=1, x_{1,1}=0, x_{2,0}=0, x_{2,1}=1
     let ilp_solution = vec![1, 0, 1, 0, 0, 1];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 0, 1]);
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "manually constructed solution should be valid"
     );
 }
@@ -81,6 +86,7 @@ fn test_precedenceconstrainedscheduling_to_ilp_extract_solution() {
 #[test]
 fn test_precedenceconstrainedscheduling_to_ilp_bf_vs_ilp() {
     let problem = feasible_instance();
-    let reduction: ReductionPCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionPCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/preemptivescheduling_ilp.rs b/src/unit_tests/rules/preemptivescheduling_ilp.rs
index 95a0258a5..cd0a78b23 100644
--- a/src/unit_tests/rules/preemptivescheduling_ilp.rs
+++ b/src/unit_tests/rules/preemptivescheduling_ilp.rs
@@ -9,13 +9,13 @@ use crate::types::Min;
 /// 2 tasks, lengths [1, 1], 2 processors, precedence (0,1).
 /// D_max = 2.  Optimal makespan = 2.
 fn small_instance() -> PreemptiveScheduling {
-    PreemptiveScheduling::new(vec![1, 1], 2, vec![(0, 1)])
+    PreemptiveScheduling::new(vec![1, 1], 2, vec![(0, 1)]).unwrap()
 }
 
 /// 3 tasks, lengths [2,1,2], 2 processors, precedence (0,2).
 /// D_max = 5.  Feasible with makespan ≤ 5.
 fn medium_instance() -> PreemptiveScheduling {
-    PreemptiveScheduling::new(vec![2, 1, 2], 2, vec![(0, 2)])
+    PreemptiveScheduling::new(vec![2, 1, 2], 2, vec![(0, 2)]).unwrap()
 }
 
 // ─── structure ─────────────────────────────────────────────────────────────
@@ -24,18 +24,19 @@ fn medium_instance() -> PreemptiveScheduling {
 fn test_preemptivescheduling_to_ilp_structure() {
     let p = small_instance();
     // n=2, D_max=2 → 2*2+1 = 5 variables
-    let reduction: ReductionPSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
+    let reduction: ReductionPSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 5, "expected n*D_max+1 = 5 variables");
+    assert_eq!(ilp.num_vars(), 5, "expected n*D_max+1 = 5 variables");
     assert_eq!(
-        ilp.objective,
-        vec![(4, 1.0)],
+        ilp.objective(),
+        vec![(4, 1)],
         "objective: minimize M at index 4"
     );
 
     // Constraints:
     // 2 work + 2 capacity + 1 prec*(D_max=2 slots) + 2*2 makespan + 2*2 binary = 2+2+2+4+4 = 14
-    assert_eq!(ilp.constraints.len(), 14);
+    assert_eq!(ilp.constraints().len(), 14);
 }
 
 // ─── closed-loop ───────────────────────────────────────────────────────────
@@ -43,27 +44,39 @@ fn test_preemptivescheduling_to_ilp_structure() {
 #[test]
 fn test_preemptivescheduling_to_ilp_closed_loop() {
     let p = small_instance();
-    let reduction: ReductionPSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
+    let reduction: ReductionPSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = p.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = p.evaluate(&extracted).unwrap();
     assert!(
         value.0.is_some(),
         "extracted schedule should be valid, got {value:?}"
     );
 }
 
+#[test]
+fn test_solve_via_registered_integer_ilp_pipeline() {
+    let problem = small_instance();
+    let solution = ILPSolver::new()
+        .solve(&problem)
+        .expect("direct ILP<i64> reduction should be solvable");
+
+    assert!(problem.evaluate(&solution).unwrap().0.is_some());
+}
+
 #[test]
 fn test_preemptivescheduling_to_ilp_medium_closed_loop() {
     let p = medium_instance();
-    let reduction: ReductionPSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
+    let reduction: ReductionPSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = p.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = p.evaluate(&extracted).unwrap();
     assert!(
         value.0.is_some(),
         "extracted schedule should be valid, got {value:?}"
@@ -83,11 +96,12 @@ fn test_preemptivescheduling_to_ilp_infeasible() {
     // Actually, let's check that a huge task on 1 tiny processor is fine
     // (it's always feasible; makespan is just larger).
     // Use a cycle-free precedence that is always schedulable.
-    let p = PreemptiveScheduling::new(vec![1, 1], 1, vec![(0, 1)]);
-    let reduction: ReductionPSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
+    let p = PreemptiveScheduling::new(vec![1, 1], 1, vec![(0, 1)]).unwrap();
+    let reduction: ReductionPSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
     let sol = ILPSolver::new().solve(reduction.target_problem());
     // 1 processor, t0 at slot 0, t1 at slot 1 → always feasible
-    assert!(sol.is_some(), "should be feasible");
+    assert!(sol.is_ok(), "should be feasible");
 }
 
 // ─── extract_solution ──────────────────────────────────────────────────────
@@ -97,9 +111,10 @@ fn test_preemptivescheduling_to_ilp_extract_solution() {
     // small_instance: n=2, D_max=2, m_var=4
     // x_{0,0}=1, x_{0,1}=0, x_{1,0}=0, x_{1,1}=1, M=2
     let p = small_instance();
-    let reduction: ReductionPSToILP = ReduceTo::<ILP<i32>>::reduce_to(&p);
+    let reduction: ReductionPSToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&p).expect("reduction should succeed");
     let ilp_solution = vec![1, 0, 0, 1, 2]; // last element is M
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(extracted, vec![1, 0, 0, 1]);
-    assert_eq!(p.evaluate(&extracted), Min(Some(2)));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(extracted, vec![vec![true, false], vec![false, true]]);
+    assert_eq!(p.evaluate(&extracted).unwrap(), Min(Some(2)));
 }
diff --git a/src/unit_tests/rules/prizecollectingsteinerforest_steinertree.rs b/src/unit_tests/rules/prizecollectingsteinerforest_steinertree.rs
index 57001da27..252a965c7 100644
--- a/src/unit_tests/rules/prizecollectingsteinerforest_steinertree.rs
+++ b/src/unit_tests/rules/prizecollectingsteinerforest_steinertree.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
@@ -8,20 +8,22 @@ use crate::types::Min;
 /// Canonical issue-#1027 instance: path 0 - 1 - 2 with c=(10,10), p=(5,1,5),
 /// beta = 1, omega = 1. The PCSF optimum drops vertex 1 because paying
 /// `beta * p(1) = 1` is cheaper than paying any incident edge (cost 10).
-fn canonical_problem() -> PrizeCollectingSteinerForest<SimpleGraph, i32> {
-    PrizeCollectingSteinerForest::<SimpleGraph, i32>::new(
+fn canonical_problem() -> PrizeCollectingSteinerForest<SimpleGraph, i64> {
+    PrizeCollectingSteinerForest::<SimpleGraph, i64>::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
         vec![5, 1, 5],
         vec![10, 10],
         1,
         1,
     )
+    .unwrap()
 }
 
 #[test]
 fn test_prizecollectingsteinerforest_to_steinertree_canonical_closed_loop() {
     let source = canonical_problem();
-    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     // Round-trip the target optimum and confirm the extracted source
     // configuration is itself an optimal PCSF witness.
@@ -33,8 +35,10 @@ fn test_prizecollectingsteinerforest_to_steinertree_canonical_closed_loop() {
 
     // Numeric sanity: both optima must agree, and equal 3 on this instance.
     let target = reduction.target_problem();
-    let source_opt = BruteForce::new().solve(&source);
-    let target_opt = BruteForce::new().solve(target);
+    let source_opt_solution = BruteForce::new().solve(&source).unwrap().unwrap();
+    let source_opt = source.evaluate(&source_opt_solution).unwrap();
+    let target_opt_solution = BruteForce::new().solve(target).unwrap().unwrap();
+    let target_opt = target.evaluate(&target_opt_solution).unwrap();
     assert_eq!(source_opt, Min(Some(3)));
     assert_eq!(target_opt, Min(Some(3)));
 }
@@ -42,10 +46,11 @@ fn test_prizecollectingsteinerforest_to_steinertree_canonical_closed_loop() {
 #[test]
 fn test_prizecollectingsteinerforest_to_steinertree_canonical_target_structure() {
     let source = canonical_problem();
-    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    // Issue overhead: V_H = n + k + 1, E_H = m + n + 2k, T_H = k + 1.
+    // Exact parameter relation: V_H = n + k + 1, E_H = m + n + 2k, T_H = k + 1.
     // n = 3, m = 2, k = 3 -> V_H = 7, E_H = 11, T_H = 4.
     assert_eq!(target.num_vertices(), 7);
     assert_eq!(target.num_edges(), 11);
@@ -59,47 +64,50 @@ fn test_prizecollectingsteinerforest_to_steinertree_canonical_target_structure()
 #[test]
 fn test_prizecollectingsteinerforest_to_steinertree_extract_witness_canonical() {
     let source = canonical_problem();
-    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     let target_witness = BruteForce::new()
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("target SteinerTree must be feasible");
-    let source_witness = reduction.extract_solution(&target_witness);
+    let source_witness = reduction.extract_solution(&target_witness).unwrap();
 
-    // Source layout is `n` vertex-bits then `m` edge-bits.
-    assert_eq!(source_witness.len(), source.num_variables());
+    assert_eq!(source_witness.0.len(), source.num_vertices());
+    assert_eq!(source_witness.1.len(), source.num_edges());
 
     // Extracted witness must be a feasible PCSF forest with the optimal
     // objective value (3 on this instance).
     assert!(source.is_valid_solution(&source_witness));
-    assert_eq!(source.evaluate(&source_witness), Min(Some(3)));
+    assert_eq!(source.evaluate(&source_witness).unwrap(), Min(Some(3)));
 
     // V_F = {0, 2}, E_F = {} on this instance.
-    assert_eq!(source_witness[0], 1, "vertex 0 should be in V_F");
-    assert_eq!(
-        source_witness[1], 0,
+    assert!(source_witness.0[0], "vertex 0 should be in V_F");
+    assert!(
+        !source_witness.0[1],
         "vertex 1 should be omitted at the optimum"
     );
-    assert_eq!(source_witness[2], 1, "vertex 2 should be in V_F");
-    // The edge-selector segment (indices 3..5) must be all zero.
-    assert_eq!(source_witness[3], 0);
-    assert_eq!(source_witness[4], 0);
+    assert!(source_witness.0[2], "vertex 2 should be in V_F");
+    assert!(!source_witness.1[0]);
+    assert!(!source_witness.1[1]);
 }
 
 /// All vertices carry a positive prize, so omitting any vertex pays a large
 /// penalty. The optimum keeps every vertex and uses both edges.
 #[test]
 fn test_prizecollectingsteinerforest_to_steinertree_all_prizes() {
-    let source = PrizeCollectingSteinerForest::<SimpleGraph, i32>::new(
+    let source = PrizeCollectingSteinerForest::<SimpleGraph, i64>::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
         // Large prizes so all three vertices are worth including.
         vec![100, 100, 100],
         vec![1, 1],
         1,
         1,
-    );
-    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i32>>::reduce_to(&source);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // k = 3 prized vertices.
@@ -115,15 +123,17 @@ fn test_prizecollectingsteinerforest_to_steinertree_all_prizes() {
 
     // Direct sanity: optimum is "select everything"
     // V_F = {0,1,2}, E_F = {(0,1),(1,2)}, one component, cost = 0 + 2 + 1 = 3.
-    let source_opt = BruteForce::new().solve(&source);
-    let target_opt = BruteForce::new().solve(target);
+    let source_opt_solution = BruteForce::new().solve(&source).unwrap().unwrap();
+    let source_opt = source.evaluate(&source_opt_solution).unwrap();
+    let target_opt_solution = BruteForce::new().solve(target).unwrap().unwrap();
+    let target_opt = target.evaluate(&target_opt_solution).unwrap();
     assert_eq!(source_opt, Min(Some(3)));
     assert_eq!(target_opt, Min(Some(3)));
 }
 
 /// No vertex carries a positive prize, so no gadget terminals are added.
 /// Only the artificial root remains as a terminal, but SteinerTree requires
-/// at least two terminals — so this corner case is delegated to overhead
+/// at least two terminals — so this corner case is covered by size-contract
 /// inspection plus a degenerate single-vertex source case that still has
 /// the construction proceed when `omega = 0`. We skip the SteinerTree
 /// instantiation when `k = 0` (which would produce a single-terminal
@@ -132,14 +142,16 @@ fn test_prizecollectingsteinerforest_to_steinertree_all_prizes() {
 #[test]
 fn test_prizecollectingsteinerforest_to_steinertree_mixed_zero_prize() {
     // Two-vertex path with one prize-zero vertex.
-    let source = PrizeCollectingSteinerForest::<SimpleGraph, i32>::new(
+    let source = PrizeCollectingSteinerForest::<SimpleGraph, i64>::new(
         SimpleGraph::new(2, vec![(0, 1)]),
         vec![0, 5],
         vec![1],
         1,
         1,
-    );
-    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i32>>::reduce_to(&source);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // k = 1, so V_H = 2 + 1 + 1 = 4, E_H = 1 + 2 + 2*1 = 5, T_H = 1 + 1 = 2.
@@ -161,14 +173,16 @@ fn test_prizecollectingsteinerforest_to_steinertree_path_with_omission() {
     // Path 0 - 1 - 2 - 3 with edge cost 5 everywhere, prizes p = (4, 1, 1, 4).
     // beta = 1, omega = 1. Vertices 1 and 2 are expected to drop because
     // each edge costs 5 but their prize is only 1.
-    let source = PrizeCollectingSteinerForest::<SimpleGraph, i32>::new(
+    let source = PrizeCollectingSteinerForest::<SimpleGraph, i64>::new(
         SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
         vec![4, 1, 1, 4],
         vec![5, 5, 5],
         1,
         1,
-    );
-    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i32>>::reduce_to(&source);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<SteinerTree<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &reduction,
diff --git a/src/unit_tests/rules/quadraticassignment_ilp.rs b/src/unit_tests/rules/quadraticassignment_ilp.rs
index d7a648d0e..c68fd73e1 100644
--- a/src/unit_tests/rules/quadraticassignment_ilp.rs
+++ b/src/unit_tests/rules/quadraticassignment_ilp.rs
@@ -12,11 +12,12 @@ fn small_qap() -> QuadraticAssignment {
 #[test]
 fn test_reduction_creates_valid_ilp() {
     let problem = small_qap();
-    let reduction: ReductionQAPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionQAPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // n=3, m=3: num_x=9, z pairs: 3*2*3*3=54, total=63
-    assert_eq!(ilp.num_vars, 63);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 63);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -24,17 +25,18 @@ fn test_quadraticassignment_to_ilp_closed_loop() {
     let problem = small_qap();
     // BruteForce on source to get optimal value
     let bf = BruteForce::new();
-    let bf_solution = bf.find_witness(&problem).expect("brute-force optimum");
-    let bf_value = problem.evaluate(&bf_solution);
+    let bf_solution = bf.solve(&problem).unwrap().expect("brute-force optimum");
+    let bf_value = problem.evaluate(&bf_solution).unwrap();
 
     // Solve via ILP
-    let reduction: ReductionQAPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionQAPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert!(
         ilp_value.is_valid(),
@@ -52,17 +54,18 @@ fn test_quadraticassignment_to_ilp_2x2() {
         QuadraticAssignment::new(vec![vec![0, 1], vec![1, 0]], vec![vec![0, 2], vec![2, 0]]);
     // BruteForce on source
     let bf = BruteForce::new();
-    let bf_solution = bf.find_witness(&problem).expect("brute-force optimum");
-    let bf_value = problem.evaluate(&bf_solution);
+    let bf_solution = bf.solve(&problem).unwrap().expect("brute-force optimum");
+    let bf_value = problem.evaluate(&bf_solution).unwrap();
 
     // Solve via ILP
-    let reduction: ReductionQAPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionQAPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert!(ilp_value.is_valid());
     assert_eq!(ilp_value, bf_value);
@@ -71,13 +74,14 @@ fn test_quadraticassignment_to_ilp_2x2() {
 #[test]
 fn test_solution_extraction() {
     let problem = small_qap();
-    let reduction: ReductionQAPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionQAPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let metric = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let metric = problem.evaluate(&extracted).unwrap();
     assert!(metric.is_valid());
 }
 
@@ -90,17 +94,18 @@ fn test_quadraticassignment_to_ilp_rectangular() {
     );
     // BruteForce on source
     let bf = BruteForce::new();
-    let bf_solution = bf.find_witness(&problem).expect("brute-force optimum");
-    let bf_value = problem.evaluate(&bf_solution);
+    let bf_solution = bf.solve(&problem).unwrap().expect("brute-force optimum");
+    let bf_value = problem.evaluate(&bf_solution).unwrap();
 
     // Solve via ILP
-    let reduction: ReductionQAPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionQAPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert!(ilp_value.is_valid());
     assert_eq!(ilp_value, bf_value);
@@ -109,6 +114,7 @@ fn test_quadraticassignment_to_ilp_rectangular() {
 #[test]
 fn test_quadraticassignment_to_ilp_bf_vs_ilp() {
     let problem = small_qap();
-    let reduction: ReductionQAPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionQAPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/qubo_casts.rs b/src/unit_tests/rules/qubo_casts.rs
new file mode 100644
index 000000000..9ac1eb48a
--- /dev/null
+++ b/src/unit_tests/rules/qubo_casts.rs
@@ -0,0 +1,33 @@
+use super::*;
+use crate::rules::{ReduceTo, ReductionError, ReductionGraph, ReductionResult};
+use crate::types::MAX_EXACT_F64_INTEGER;
+
+#[test]
+fn test_qubo_i64_to_f64_closed_loop() {
+    let source = QUBO::from_matrix(vec![vec![1_i64, -2], vec![0, 3]]).unwrap();
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&source).unwrap();
+
+    assert_eq!(
+        reduction.target_problem().matrix(),
+        &[vec![1.0, -2.0], vec![0.0, 3.0]]
+    );
+    assert_eq!(
+        reduction.extract_solution(&vec![true, false]).unwrap(),
+        vec![true, false]
+    );
+}
+
+#[test]
+fn test_qubo_i64_to_f64_rejects_inexact_coefficient() {
+    let source = QUBO::from_matrix(vec![vec![MAX_EXACT_F64_INTEGER + 1]]).unwrap();
+
+    assert!(matches!(
+        ReduceTo::<QUBO<f64>>::reduce_to(&source),
+        Err(ReductionError::InexactFloatConversion { .. })
+    ));
+}
+
+#[test]
+fn test_qubo_numeric_variants_are_connected() {
+    assert!(ReductionGraph::new().has_direct_reduction::<QUBO<i64>, QUBO<f64>>());
+}
diff --git a/src/unit_tests/rules/qubo_ilp.rs b/src/unit_tests/rules/qubo_ilp.rs
index 5895e0a4f..db5628fd4 100644
--- a/src/unit_tests/rules/qubo_ilp.rs
+++ b/src/unit_tests/rules/qubo_ilp.rs
@@ -1,6 +1,7 @@
 use super::*;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
+use crate::traits::Problem;
 
 #[test]
 fn test_qubo_to_ilp_closed_loop() {
@@ -8,29 +9,36 @@ fn test_qubo_to_ilp_closed_loop() {
     // Q = [[2, 1], [0, -3]]
     // x=0,0 -> 0, x=1,0 -> 2, x=0,1 -> -3, x=1,1 -> 0
     // Optimal: x = [0, 1] with obj = -3
-    let qubo = QUBO::from_matrix(vec![vec![2.0, 1.0], vec![0.0, -3.0]]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&qubo);
-    assert_optimization_round_trip_from_optimization_target(
-        &qubo,
-        &reduction,
-        "QUBO->ILP closed loop",
+    let qubo = QUBO::from_matrix(vec![vec![2.0, 1.0], vec![0.0, -3.0]]).unwrap();
+    let reduction = ReduceTo::<ILP<bool, f64>>::reduce_to(&qubo).expect("reduction should succeed");
+    assert_bf_vs_ilp(&qubo, &reduction);
+}
+
+#[test]
+fn test_integer_qubo_to_integer_ilp() {
+    let qubo = QUBO::from_matrix(vec![vec![2, 1], vec![0, -3]]).unwrap();
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&qubo).expect("reduction should succeed");
+    assert_bf_vs_ilp(&qubo, &reduction);
+    assert_eq!(
+        reduction.target_problem().objective(),
+        &[(0, 2), (1, -3), (2, 1)]
     );
 }
 
 #[test]
 fn test_qubo_to_ilp_bf_vs_ilp() {
     // QUBO: minimize 2*x0 - 3*x1 + x0*x1
-    let qubo = QUBO::from_matrix(vec![vec![2.0, 1.0], vec![0.0, -3.0]]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&qubo);
+    let qubo = QUBO::from_matrix(vec![vec![2.0, 1.0], vec![0.0, -3.0]]).unwrap();
+    let reduction = ReduceTo::<ILP<bool, f64>>::reduce_to(&qubo).expect("reduction should succeed");
 
-    let bf_solutions = BruteForce::new().find_all_witnesses(&qubo);
-    let bf_value = qubo.evaluate(&bf_solutions[0]);
+    let bf_solutions = BruteForce::new().find_all_witnesses(&qubo).unwrap();
+    let bf_value = qubo.evaluate(&bf_solutions[0]).unwrap();
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = qubo.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = qubo.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
 }
@@ -39,18 +47,17 @@ fn test_qubo_to_ilp_bf_vs_ilp() {
 fn test_qubo_to_ilp_diagonal_only() {
     // No quadratic terms: minimize 3*x0 - 2*x1
     // Optimal: x = [0, 1] with obj = -2
-    let qubo = QUBO::from_matrix(vec![vec![3.0, 0.0], vec![0.0, -2.0]]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&qubo);
+    let qubo = QUBO::from_matrix(vec![vec![3.0, 0.0], vec![0.0, -2.0]]).unwrap();
+    let reduction = ReduceTo::<ILP<bool, f64>>::reduce_to(&qubo).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // No auxiliary variables when no off-diagonal terms
     assert_eq!(ilp.num_variables(), 2);
-    assert!(ilp.constraints.is_empty());
+    assert!(ilp.constraints().is_empty());
 
-    let solver = BruteForce::new();
-    let best = solver.find_all_witnesses(ilp);
-    let extracted = reduction.extract_solution(&best[0]);
-    assert_eq!(extracted, vec![0, 1]);
+    let best = ILPSolver::new().solve(ilp).unwrap();
+    let extracted = reduction.extract_solution(&best).unwrap();
+    assert_eq!(extracted, vec![false, true]);
 }
 
 #[test]
@@ -61,17 +68,17 @@ fn test_qubo_to_ilp_3var() {
         vec![-1.0, 4.0, 0.0],
         vec![0.0, -1.0, 4.0],
         vec![0.0, 0.0, -1.0],
-    ]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&qubo);
+    ])
+    .unwrap();
+    let reduction = ReduceTo::<ILP<bool, f64>>::reduce_to(&qubo).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 3 original + 2 auxiliary (for two off-diagonal terms)
     assert_eq!(ilp.num_variables(), 5);
     // 3 constraints per auxiliary = 6
-    assert_eq!(ilp.constraints.len(), 6);
+    assert_eq!(ilp.constraints().len(), 6);
 
-    let solver = BruteForce::new();
-    let best = solver.find_all_witnesses(ilp);
-    let extracted = reduction.extract_solution(&best[0]);
-    assert_eq!(extracted, vec![1, 0, 1]);
+    let best = ILPSolver::new().solve(ilp).unwrap();
+    let extracted = reduction.extract_solution(&best).unwrap();
+    assert_eq!(extracted, vec![true, false, true]);
 }
diff --git a/src/unit_tests/rules/rectilinearpicturecompression_ilp.rs b/src/unit_tests/rules/rectilinearpicturecompression_ilp.rs
index 9ad9e01be..056c224de 100644
--- a/src/unit_tests/rules/rectilinearpicturecompression_ilp.rs
+++ b/src/unit_tests/rules/rectilinearpicturecompression_ilp.rs
@@ -6,40 +6,43 @@ use crate::types::Or;
 #[test]
 fn test_reduction_creates_valid_ilp() {
     let problem = RectilinearPictureCompression::new(vec![vec![true, true], vec![true, false]], 2);
-    let reduction: ReductionRPCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionRPCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // Number of vars = number of maximal rectangles (precomputed)
-    assert!(ilp.num_vars > 0);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert!(ilp.num_vars() > 0);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_rectilinearpicturecompression_to_ilp_bf_vs_ilp() {
     let problem = RectilinearPictureCompression::new(vec![vec![true, true], vec![true, true]], 1);
-    let reduction: ReductionRPCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionRPCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_witness = bf.find_witness(&problem).expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should be feasible");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_solution_extraction() {
     let problem = RectilinearPictureCompression::new(vec![vec![true, true], vec![true, true]], 2);
-    let reduction: ReductionRPCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionRPCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -47,7 +50,8 @@ fn test_rectilinearpicturecompression_to_ilp_trivial() {
     // All-zero matrix: no 1-cells, trivially feasible
     let problem =
         RectilinearPictureCompression::new(vec![vec![false, false], vec![false, false]], 0);
-    let reduction: ReductionRPCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionRPCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 0); // no maximal rects
+    assert_eq!(ilp.num_vars(), 0); // no maximal rects
 }
diff --git a/src/unit_tests/rules/reduction_path_parity.rs b/src/unit_tests/rules/reduction_path_parity.rs
index 9a7721594..d2011bcd4 100644
--- a/src/unit_tests/rules/reduction_path_parity.rs
+++ b/src/unit_tests/rules/reduction_path_parity.rs
@@ -1,34 +1,29 @@
 //! Reduction path parity tests — mirrors Julia's test/reduction_path.jl.
-//! Verifies that chained reductions via `find_cheapest_path` + `reduce_along_path`
+//! Verifies that explicit chained reductions via `reduce_along_path`
 //! produce correct solutions matching direct source solves.
 
 use crate::models::algebraic::QUBO;
 use crate::models::graph::{MaxCut, SpinGlass};
 use crate::models::misc::Factoring;
 use crate::rules::test_helpers::assert_optimization_round_trip_chain;
-use crate::rules::{MinimizeSteps, MinimizeStepsThenOverhead, ReductionGraph};
+use crate::rules::ReductionGraph;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
-use crate::types::ProblemSize;
 
 /// Julia: paths = reduction_paths(MaxCut, SpinGlass)
 /// Julia: res = reduceto(paths[1], MaxCut(smallgraph(:petersen)))
 #[test]
 fn test_jl_parity_maxcut_to_spinglass_path() {
     let graph = ReductionGraph::new();
-    let src_var = ReductionGraph::variant_to_map(&MaxCut::<SimpleGraph, i32>::variant());
+    let src_var = ReductionGraph::variant_to_map(&MaxCut::<SimpleGraph, i64>::variant());
     let dst_var = ReductionGraph::variant_to_map(&SpinGlass::<SimpleGraph, f64>::variant());
     let rpath = graph
-        .find_cheapest_path(
-            "MaxCut",
-            &src_var,
-            "SpinGlass",
-            &dst_var,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .expect("Should find path MaxCut -> SpinGlass");
+        .find_all_paths("MaxCut", &src_var, "SpinGlass", &dst_var)
+        .into_iter()
+        .find(|path| path.type_names() == ["MaxCut", "SpinGlass"])
+        .expect("direct route");
 
     // Petersen graph: 10 vertices, 15 edges
     let petersen_edges = vec![
@@ -48,9 +43,10 @@ fn test_jl_parity_maxcut_to_spinglass_path() {
         (6, 9),
         (7, 9),
     ];
-    let source = MaxCut::<SimpleGraph, i32>::unweighted(SimpleGraph::new(10, petersen_edges));
+    let source = MaxCut::<SimpleGraph, i64>::unweighted(SimpleGraph::new(10, petersen_edges));
     let chain = graph
         .reduce_along_path(&rpath, &source as &dyn std::any::Any)
+        .expect("MaxCut -> SpinGlass reduction should not fail")
         .expect("Should reduce along path");
     let target: &SpinGlass<SimpleGraph, f64> = chain.target_problem();
 
@@ -58,11 +54,11 @@ fn test_jl_parity_maxcut_to_spinglass_path() {
     assert_eq!(SpinGlass::<SimpleGraph, f64>::NAME, "SpinGlass");
 
     let solver = BruteForce::new();
-    let target_solution = solver.find_witness(target).unwrap();
-    let source_solution = chain.extract_solution(&target_solution);
+    let target_solution = solver.solve(target).unwrap().unwrap();
+    let source_solution = chain.extract_solution(&target_solution).unwrap();
 
     // Source solution should be valid
-    let metric = source.evaluate(&source_solution);
+    let metric = source.evaluate(&source_solution).unwrap();
     assert!(metric.is_valid());
 }
 
@@ -71,19 +67,13 @@ fn test_jl_parity_maxcut_to_spinglass_path() {
 #[test]
 fn test_jl_parity_maxcut_to_qubo_path() {
     let graph = ReductionGraph::new();
-    let src_var = ReductionGraph::variant_to_map(&MaxCut::<SimpleGraph, i32>::variant());
+    let src_var = ReductionGraph::variant_to_map(&MaxCut::<SimpleGraph, i64>::variant());
     let dst_var = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
-    // Use Petersen graph size to pick the path with smallest output
     let rpath = graph
-        .find_cheapest_path(
-            "MaxCut",
-            &src_var,
-            "QUBO",
-            &dst_var,
-            &ProblemSize::new(vec![("num_vertices", 10), ("num_edges", 15)]),
-            &MinimizeStepsThenOverhead,
-        )
-        .expect("Should find path MaxCut -> QUBO");
+        .find_all_paths("MaxCut", &src_var, "QUBO", &dst_var)
+        .into_iter()
+        .find(|path| path.type_names() == ["MaxCut", "SpinGlass", "QUBO"])
+        .expect("explicit SpinGlass route");
 
     // Use a small graph for brute-force feasibility
     let petersen_edges = vec![
@@ -103,11 +93,12 @@ fn test_jl_parity_maxcut_to_qubo_path() {
         (6, 9),
         (7, 9),
     ];
-    let source = MaxCut::<SimpleGraph, i32>::unweighted(SimpleGraph::new(10, petersen_edges));
+    let source = MaxCut::<SimpleGraph, i64>::unweighted(SimpleGraph::new(10, petersen_edges));
     let chain = graph
         .reduce_along_path(&rpath, &source as &dyn std::any::Any)
+        .expect("MaxCut -> QUBO reduction should not fail")
         .expect("Should reduce along path");
-    assert_optimization_round_trip_chain::<MaxCut<SimpleGraph, i32>, QUBO<f64>>(
+    assert_optimization_round_trip_chain::<MaxCut<SimpleGraph, i64>, QUBO<f64>>(
         &source,
         &chain,
         "MaxCut->QUBO path parity",
@@ -117,7 +108,6 @@ fn test_jl_parity_maxcut_to_qubo_path() {
 /// Julia: factoring = Factoring(2, 1, 3)
 /// Julia: paths = reduction_paths(Factoring, SpinGlass)
 /// Julia: all(solution_size.(Ref(factoring), extract_solution.(Ref(res), sol)) .== Ref(valid objective 0))
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_jl_parity_factoring_to_spinglass_path() {
     use crate::solvers::ILPSolver;
@@ -126,20 +116,16 @@ fn test_jl_parity_factoring_to_spinglass_path() {
     let src_var = ReductionGraph::variant_to_map(&Factoring::variant());
     let dst_var = ReductionGraph::variant_to_map(&SpinGlass::<SimpleGraph, f64>::variant());
     let rpath = graph
-        .find_cheapest_path(
-            "Factoring",
-            &src_var,
-            "SpinGlass",
-            &dst_var,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .expect("Should find path Factoring -> SpinGlass");
+        .find_all_paths("Factoring", &src_var, "SpinGlass", &dst_var)
+        .into_iter()
+        .find(|path| path.type_names() == ["Factoring", "CircuitSAT", "SpinGlass"])
+        .expect("explicit CircuitSAT route");
 
-    // Julia: Factoring(2, 1, 3) — factor 3 with 2-bit x 1-bit
-    let factoring = Factoring::new(2, 1, 3);
+    // Canonical factor order uses the smaller width first.
+    let factoring = Factoring::with_factor_bits(3, 1, 2);
     let chain = graph
         .reduce_along_path(&rpath, &factoring as &dyn std::any::Any)
+        .expect("Factoring -> SpinGlass reduction should not fail")
         .expect("Should reduce along path");
     let target: &SpinGlass<SimpleGraph, f64> = chain.target_problem();
 
@@ -153,60 +139,12 @@ fn test_jl_parity_factoring_to_spinglass_path() {
     use crate::models::algebraic::ILP;
     use crate::rules::traits::{ReduceTo, ReductionResult};
     let ilp_solver = ILPSolver::new();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&factoring);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&factoring).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solution = ilp_solver
         .solve(ilp)
         .expect("ILP solver should find factoring solution");
-    let factoring_solution = reduction.extract_solution(&ilp_solution);
-    let metric = factoring.evaluate(&factoring_solution);
-    assert_eq!(
-        metric.unwrap(),
-        0,
-        "Factoring->ILP: ILP solution should yield distance 0"
-    );
-}
-
-/// Test that `find_cheapest_path` works with a concrete `ProblemSize` input,
-/// rather than an empty `ProblemSize::new(vec![])`.
-#[test]
-fn test_find_cheapest_path_with_problem_size() {
-    let graph = ReductionGraph::new();
-    let petersen = SimpleGraph::new(
-        10,
-        vec![
-            (0, 1),
-            (0, 4),
-            (0, 5),
-            (1, 2),
-            (1, 6),
-            (2, 3),
-            (2, 7),
-            (3, 4),
-            (3, 8),
-            (4, 9),
-            (5, 7),
-            (5, 8),
-            (6, 8),
-            (6, 9),
-            (7, 9),
-        ],
-    );
-    let _source = MaxCut::<SimpleGraph, i32>::unweighted(petersen);
-    let src_var = ReductionGraph::variant_to_map(&MaxCut::<SimpleGraph, i32>::variant());
-    let dst_var = ReductionGraph::variant_to_map(&SpinGlass::<SimpleGraph, f64>::variant());
-
-    let input_size = ProblemSize::new(vec![("num_vertices", 10), ("num_edges", 15)]);
-    let rpath = graph
-        .find_cheapest_path(
-            "MaxCut",
-            &src_var,
-            "SpinGlass",
-            &dst_var,
-            &input_size,
-            &MinimizeSteps,
-        )
-        .expect("Should find path MaxCut -> SpinGlass");
-
-    assert!(!rpath.type_names().is_empty());
+    let factoring_solution = reduction.extract_solution(&ilp_solution).unwrap();
+    let metric = factoring.evaluate(&factoring_solution).unwrap();
+    assert!(metric.unwrap(), "Factoring->ILP solution must be valid");
 }
diff --git a/src/unit_tests/rules/registersufficiency_ilp.rs b/src/unit_tests/rules/registersufficiency_ilp.rs
index 8b5e9ec77..beaef71d7 100644
--- a/src/unit_tests/rules/registersufficiency_ilp.rs
+++ b/src/unit_tests/rules/registersufficiency_ilp.rs
@@ -33,26 +33,26 @@ fn canonical_example() -> RegisterSufficiency {
 #[test]
 fn test_register_sufficiency_to_ilp_structure() {
     let source = feasible_example();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 62);
-    assert_eq!(ilp.constraints.len(), 180);
-    assert_eq!(ilp.objective, vec![]);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 62);
+    assert_eq!(ilp.constraints().len(), 180);
+    assert_eq!(ilp.objective(), vec![]);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_register_sufficiency_to_ilp_closed_loop() {
     let source = feasible_example();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("feasible register-sufficiency instance should yield a feasible ILP");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(source.evaluate(&extracted), Or(true));
+    assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
     let mut sorted = extracted.clone();
     sorted.sort_unstable();
     assert_eq!(sorted, vec![0, 1, 2, 3]);
@@ -61,10 +61,10 @@ fn test_register_sufficiency_to_ilp_closed_loop() {
 #[test]
 fn test_register_sufficiency_to_ilp_infeasible() {
     let source = infeasible_example();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
 
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "register-sufficiency instance with bound one should be infeasible"
     );
 }
@@ -72,7 +72,7 @@ fn test_register_sufficiency_to_ilp_infeasible() {
 #[test]
 fn test_register_sufficiency_to_ilp_bf_vs_ilp() {
     let source = feasible_example();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
 
@@ -90,7 +90,13 @@ fn test_register_sufficiency_to_ilp_canonical_example_spec() {
     assert_eq!(example.source.instance["num_vertices"], 7);
     assert_eq!(example.source.instance["bound"], 3);
     assert_eq!(example.source.instance["arcs"].as_array().unwrap().len(), 8);
-    assert_eq!(example.target.instance["num_vars"], 182);
+    assert_eq!(
+        example.target.instance["variables"]
+            .as_array()
+            .unwrap()
+            .len(),
+        182
+    );
     assert_eq!(
         example.target.instance["constraints"]
             .as_array()
@@ -101,11 +107,13 @@ fn test_register_sufficiency_to_ilp_canonical_example_spec() {
     assert_eq!(example.solutions.len(), 1);
 
     let source = canonical_example();
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let solution = &example.solutions[0];
-    assert_eq!(source.evaluate(&solution.source_config), Or(true));
+    let source_config: Vec<usize> = serde_json::from_value(solution.source_config.clone()).unwrap();
+    let target_config: Vec<i64> = serde_json::from_value(solution.target_config.clone()).unwrap();
+    assert_eq!(source.evaluate(&source_config).unwrap(), Or(true));
     assert_eq!(
-        reduction.extract_solution(&solution.target_config),
-        solution.source_config
+        reduction.extract_solution(&target_config).unwrap(),
+        source_config
     );
 }
diff --git a/src/unit_tests/rules/registry.rs b/src/unit_tests/rules/registry.rs
index eeabcf017..b05d19fa9 100644
--- a/src/unit_tests/rules/registry.rs
+++ b/src/unit_tests/rules/registry.rs
@@ -1,494 +1,113 @@
 use super::*;
 use crate::expr::Expr;
-use crate::rules::registry::EdgeCapabilities;
-use std::path::Path;
 
-/// Dummy reduce_fn for unit tests that don't exercise runtime reduction.
-fn dummy_reduce_fn(_: &dyn std::any::Any) -> Box<dyn crate::rules::traits::DynReductionResult> {
-    unimplemented!("dummy reduce_fn for testing")
-}
-
-fn dummy_reduce_aggregate_fn(
-    _: &dyn std::any::Any,
-) -> Box<dyn crate::rules::traits::DynAggregateReductionResult> {
-    unimplemented!("dummy reduce_aggregate_fn for testing")
-}
-
-fn dummy_overhead_eval_fn(_: &dyn std::any::Any) -> ProblemSize {
-    ProblemSize::new(vec![])
-}
-
-fn dummy_source_size_fn(_: &dyn std::any::Any) -> ProblemSize {
-    ProblemSize::new(vec![])
-}
-
-#[test]
-fn test_reduction_overhead_evaluate() {
-    let overhead = ReductionOverhead::new(vec![
-        ("n", Expr::Const(3.0) * Expr::Var("m")),
-        ("m", Expr::pow(Expr::Var("m"), Expr::Const(2.0))),
-    ]);
-
-    let input = ProblemSize::new(vec![("m", 4)]);
-    let output = overhead.evaluate_output_size(&input);
-
-    assert_eq!(output.get("n"), Some(12)); // 3 * 4
-    assert_eq!(output.get("m"), Some(16)); // 4^2
-}
-
-#[test]
-fn test_reduction_overhead_default() {
-    let overhead = ReductionOverhead::default();
-    assert!(overhead.output_size.is_empty());
-}
-
-#[test]
-fn test_reduction_entry_overhead() {
-    let entry = ReductionEntry {
-        source_name: "TestSource",
-        target_name: "TestTarget",
-        source_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "One")],
-        target_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "One")],
-        overhead_fn: || ReductionOverhead::new(vec![("n", Expr::Const(2.0) * Expr::Var("n"))]),
-        module_path: "test::module",
-        reduce_fn: Some(dummy_reduce_fn),
-        reduce_aggregate_fn: None,
-        capabilities: EdgeCapabilities::witness_only(),
-        overhead_eval_fn: dummy_overhead_eval_fn,
-        source_size_fn: dummy_source_size_fn,
-    };
-
-    let overhead = entry.overhead();
-    let input = ProblemSize::new(vec![("n", 5)]);
-    let output = overhead.evaluate_output_size(&input);
-    assert_eq!(output.get("n"), Some(10));
-}
-
-#[test]
-fn test_reduction_entry_debug() {
-    let entry = ReductionEntry {
-        source_name: "A",
-        target_name: "B",
-        source_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "One")],
-        target_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "One")],
-        overhead_fn: || ReductionOverhead::default(),
-        module_path: "test::module",
-        reduce_fn: Some(dummy_reduce_fn),
-        reduce_aggregate_fn: None,
-        capabilities: EdgeCapabilities::witness_only(),
-        overhead_eval_fn: dummy_overhead_eval_fn,
-        source_size_fn: dummy_source_size_fn,
-    };
-
-    let debug_str = format!("{:?}", entry);
-    assert!(debug_str.contains("A"));
-    assert!(debug_str.contains("B"));
-}
-
-#[test]
-fn test_is_base_reduction_unweighted() {
-    let entry = ReductionEntry {
-        source_name: "A",
-        target_name: "B",
-        source_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "One")],
-        target_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "One")],
-        overhead_fn: || ReductionOverhead::default(),
-        module_path: "test::module",
-        reduce_fn: Some(dummy_reduce_fn),
-        reduce_aggregate_fn: None,
-        capabilities: EdgeCapabilities::witness_only(),
-        overhead_eval_fn: dummy_overhead_eval_fn,
-        source_size_fn: dummy_source_size_fn,
-    };
-    assert!(entry.is_base_reduction());
-}
-
-#[test]
-fn test_is_base_reduction_source_weighted() {
-    let entry = ReductionEntry {
-        source_name: "A",
-        target_name: "B",
-        source_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "i32")],
-        target_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "One")],
-        overhead_fn: || ReductionOverhead::default(),
-        module_path: "test::module",
-        reduce_fn: Some(dummy_reduce_fn),
-        reduce_aggregate_fn: None,
-        capabilities: EdgeCapabilities::witness_only(),
-        overhead_eval_fn: dummy_overhead_eval_fn,
-        source_size_fn: dummy_source_size_fn,
-    };
-    assert!(!entry.is_base_reduction());
-}
-
-#[test]
-fn test_is_base_reduction_target_weighted() {
-    let entry = ReductionEntry {
-        source_name: "A",
-        target_name: "B",
-        source_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "One")],
-        target_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "f64")],
-        overhead_fn: || ReductionOverhead::default(),
-        module_path: "test::module",
-        reduce_fn: Some(dummy_reduce_fn),
-        reduce_aggregate_fn: None,
-        capabilities: EdgeCapabilities::witness_only(),
-        overhead_eval_fn: dummy_overhead_eval_fn,
-        source_size_fn: dummy_source_size_fn,
-    };
-    assert!(!entry.is_base_reduction());
-}
-
-#[test]
-fn test_is_base_reduction_both_weighted() {
-    let entry = ReductionEntry {
-        source_name: "A",
-        target_name: "B",
-        source_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "i32")],
-        target_variant_fn: || vec![("graph", "SimpleGraph"), ("weight", "f64")],
-        overhead_fn: || ReductionOverhead::default(),
-        module_path: "test::module",
-        reduce_fn: Some(dummy_reduce_fn),
-        reduce_aggregate_fn: None,
-        capabilities: EdgeCapabilities::witness_only(),
-        overhead_eval_fn: dummy_overhead_eval_fn,
-        source_size_fn: dummy_source_size_fn,
-    };
-    assert!(!entry.is_base_reduction());
-}
-
-#[test]
-fn test_is_base_reduction_no_weight_key() {
-    // If no weight key is present, assume unweighted (base)
-    let entry = ReductionEntry {
-        source_name: "A",
-        target_name: "B",
-        source_variant_fn: || vec![("graph", "SimpleGraph")],
-        target_variant_fn: || vec![("graph", "SimpleGraph")],
-        overhead_fn: || ReductionOverhead::default(),
-        module_path: "test::module",
-        reduce_fn: Some(dummy_reduce_fn),
-        reduce_aggregate_fn: None,
-        capabilities: EdgeCapabilities::witness_only(),
-        overhead_eval_fn: dummy_overhead_eval_fn,
-        source_size_fn: dummy_source_size_fn,
-    };
-    assert!(entry.is_base_reduction());
-}
-
-#[test]
-fn test_reduction_entry_can_store_aggregate_executor() {
-    let entry = ReductionEntry {
-        source_name: "A",
-        target_name: "B",
-        source_variant_fn: || vec![("graph", "SimpleGraph")],
-        target_variant_fn: || vec![("graph", "SimpleGraph")],
-        overhead_fn: || ReductionOverhead::default(),
-        module_path: "test::module",
+fn entry_with(declarations: fn() -> ReductionParameterDeclarations) -> ReductionEntry {
+    ReductionEntry {
+        source_name: "Source",
+        target_name: "Target",
+        source_variant_fn: Vec::new,
+        target_variant_fn: Vec::new,
+        parameter_declarations_fn: declarations,
+        module_path: module_path!(),
         reduce_fn: None,
-        reduce_aggregate_fn: Some(dummy_reduce_aggregate_fn),
-        capabilities: EdgeCapabilities::aggregate_only(),
-        overhead_eval_fn: dummy_overhead_eval_fn,
-        source_size_fn: dummy_source_size_fn,
-    };
-
-    assert!(entry.reduce_fn.is_none());
-    assert!(entry.reduce_aggregate_fn.is_some());
-}
-
-#[test]
-fn test_reduction_entries_registered() {
-    let entries: Vec<_> = inventory::iter::<ReductionEntry>().collect();
-
-    // Should have at least some registered reductions
-    assert!(entries.len() >= 10);
-
-    // Check specific reductions exist
-    assert!(
-        entries
-            .iter()
-            .any(|e| e.source_name == "MaximumIndependentSet"
-                && e.target_name == "MinimumVertexCover")
-    );
-}
-
-/// Build a ProblemSize from an overhead's input variables by calling the eval fn
-/// on the source problem instance and collecting field values via the overhead.
-///
-/// This cross-checks compiled eval (calls getters directly) against symbolic eval
-/// (looks up variables in a ProblemSize hashmap).
-fn cross_check_overhead(entry: &ReductionEntry, src: &dyn std::any::Any, input: &ProblemSize) {
-    let compiled = (entry.overhead_eval_fn)(src);
-    let symbolic = entry.overhead().evaluate_output_size(input);
-
-    for (field, _) in &entry.overhead().output_size {
-        assert_eq!(
-            compiled.get(field),
-            symbolic.get(field),
-            "overhead field '{}' mismatch for {}→{}: compiled={:?}, symbolic={:?}",
-            field,
-            entry.source_name,
-            entry.target_name,
-            compiled.get(field),
-            symbolic.get(field),
-        );
+        reduce_aggregate_fn: None,
+        turing: false,
     }
 }
 
-/// Cross-check complexity_eval_fn against symbolic Expr evaluation.
-fn cross_check_complexity(
-    entry: &crate::registry::VariantEntry,
-    src: &dyn std::any::Any,
-    input: &ProblemSize,
-) {
-    let compiled = (entry.complexity_eval_fn)(src);
-    let parsed = crate::expr::Expr::parse(entry.complexity);
-    let symbolic = parsed.eval(input);
-
-    let diff = (compiled - symbolic).abs();
-    let tol = 1e-6 * symbolic.abs().max(1.0);
-    assert!(
-        diff < tol,
-        "complexity mismatch for {} ({}): compiled={compiled}, symbolic={symbolic}, expr=\"{}\"",
-        entry.name,
-        entry
-            .variant()
-            .iter()
-            .map(|(k, v)| format!("{k}={v}"))
-            .collect::<Vec<_>>()
-            .join(", "),
-        entry.complexity,
-    );
-}
-
-#[test]
-fn test_overhead_eval_fn_cross_check_mis_to_mvc() {
-    use crate::models::graph::MaximumIndependentSet;
-    use crate::topology::SimpleGraph;
-
-    let graph = SimpleGraph::new(6, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (0, 5)]);
-    let problem = MaximumIndependentSet::new(graph, vec![1i32; 6]);
-
-    let entry = inventory::iter::<ReductionEntry>()
-        .find(|e| e.source_name == "MaximumIndependentSet" && e.target_name == "MinimumVertexCover")
-        .unwrap();
-
-    let input = ProblemSize::new(vec![
-        ("num_vertices", problem.num_vertices()),
-        ("num_edges", problem.num_edges()),
-    ]);
-    cross_check_overhead(entry, &problem as &dyn std::any::Any, &input);
-}
-
-#[test]
-fn test_overhead_eval_fn_cross_check_factoring_to_ilp() {
-    use crate::models::misc::Factoring;
-
-    let problem = Factoring::new(3, 4, 42);
-
-    let entry = inventory::iter::<ReductionEntry>()
-        .find(|e| e.source_name == "Factoring" && e.target_name == "ILP")
-        .unwrap();
-
-    let input = ProblemSize::new(vec![
-        ("num_bits_first", problem.num_bits_first()),
-        ("num_bits_second", problem.num_bits_second()),
-    ]);
-    cross_check_overhead(entry, &problem as &dyn std::any::Any, &input);
-}
-
-#[test]
-fn test_complexity_eval_fn_cross_check_mis() {
-    use crate::models::graph::MaximumIndependentSet;
-    use crate::registry::VariantEntry;
-    use crate::topology::SimpleGraph;
-
-    let graph = SimpleGraph::new(10, vec![(0, 1), (1, 2)]);
-    let problem = MaximumIndependentSet::new(graph, vec![1i32; 10]);
-
-    let entry = inventory::iter::<VariantEntry>()
-        .find(|e| {
-            e.name == "MaximumIndependentSet"
-                && e.variant()
-                    .iter()
-                    .any(|(k, v)| *k == "graph" && *v == "SimpleGraph")
-                && e.variant()
-                    .iter()
-                    .any(|(k, v)| *k == "weight" && *v == "i32")
-        })
-        .unwrap();
-
-    let input = ProblemSize::new(vec![("num_vertices", problem.num_vertices())]);
-    cross_check_complexity(entry, &problem as &dyn std::any::Any, &input);
-}
-
 #[test]
-fn test_complexity_eval_fn_cross_check_factoring() {
-    use crate::models::misc::Factoring;
-    use crate::registry::VariantEntry;
-
-    let problem = Factoring::new(8, 8, 100);
-
-    let entry = inventory::iter::<VariantEntry>()
-        .find(|e| e.name == "Factoring")
-        .unwrap();
-
-    let input = ProblemSize::new(vec![("m", problem.m()), ("n", problem.n())]);
-    cross_check_complexity(entry, &problem as &dyn std::any::Any, &input);
-}
-
-type EndpointKey = (String, Vec<(String, String)>, String, Vec<(String, String)>);
-
-fn exact_endpoint_key(entry: &ReductionEntry) -> EndpointKey {
-    let source_variant = entry
-        .source_variant()
-        .into_iter()
-        .map(|(k, v)| (k.to_string(), v.to_string()))
-        .collect();
-    let target_variant = entry
-        .target_variant()
-        .into_iter()
-        .map(|(k, v)| (k.to_string(), v.to_string()))
-        .collect();
-    (
-        entry.source_name.to_string(),
-        source_variant,
-        entry.target_name.to_string(),
-        target_variant,
+fn one_relation_applies_to_the_whole_transform() {
+    let entry = entry_with(|| ReductionParameterDeclarations {
+        relation: Some(crate::parameters::ParameterRelation::Exact),
+        fields: vec![("n", Expr::variable("n"))],
+        unavailable: vec![],
+    });
+    let contract = entry.parameter_contract().unwrap();
+    let transform = contract.transform().unwrap();
+    assert_eq!(
+        transform.relation(),
+        crate::parameters::ParameterRelation::Exact
+    );
+    assert!(transform.get("n").is_some());
+}
+
+#[test]
+fn unavailable_field_cannot_overlap_a_formula() {
+    let entry = entry_with(|| ReductionParameterDeclarations {
+        relation: Some(crate::parameters::ParameterRelation::Exact),
+        fields: vec![("n", Expr::variable("n"))],
+        unavailable: vec![UnavailableParameterField {
+            field: "n",
+            reason: "the construction does not expose this statistic",
+        }],
+    });
+    assert!(matches!(
+        entry.parameter_contract(),
+        Err(ParameterContractError::DuplicateClassification { field, .. }) if field.as_ref() == "n"
+    ));
+}
+
+#[test]
+fn unavailable_field_requires_a_reason() {
+    let entry = entry_with(|| ReductionParameterDeclarations {
+        relation: None,
+        fields: vec![],
+        unavailable: vec![UnavailableParameterField {
+            field: "n",
+            reason: " ",
+        }],
+    });
+    assert!(matches!(
+        entry.parameter_contract(),
+        Err(ParameterContractError::EmptyUnavailableReason { field, .. }) if field.as_ref() == "n"
+    ));
+}
+
+#[test]
+fn parameter_contract_errors_and_entry_debug_are_transparent() {
+    let transform_error = crate::parameters::ParameterTransform::new(
+        "bad exact",
+        crate::parameters::ParameterRelation::Exact,
+        [("x", Expr::variable("n")), ("x", Expr::variable("m"))],
     )
-}
-
-fn walk_rust_files(dir: &Path, files: &mut Vec<std::path::PathBuf>) {
-    for entry in std::fs::read_dir(dir).unwrap() {
-        let entry = entry.unwrap();
-        let path = entry.path();
-        if path.is_dir() {
-            walk_rust_files(&path, files);
-        } else if path.extension().is_some_and(|ext| ext == "rs") {
-            files.push(path);
-        }
+    .unwrap_err();
+    assert!(ParameterContractError::from(transform_error)
+        .to_string()
+        .starts_with("invalid parameter transform:"));
+    assert!(ParameterContractError::DuplicateClassification {
+        edge: "A -> B".into(),
+        field: "x".into(),
     }
-}
-
-fn reduction_attribute_has_extra_top_level_field(path: &Path) -> bool {
-    let contents = std::fs::read_to_string(path).unwrap();
-    let mut in_reduction_attr = false;
-    let mut attr_text = String::new();
-
-    for line in contents.lines() {
-        if !in_reduction_attr
-            && (line.contains("#[reduction(") || line.contains("#[$crate::reduction("))
-        {
-            in_reduction_attr = true;
-            attr_text.clear();
-        }
-        if in_reduction_attr {
-            attr_text.push_str(line.trim());
-            attr_text.push(' ');
-        }
-        if in_reduction_attr && line.contains(")]") {
-            let normalized = attr_text.split_whitespace().collect::<Vec<_>>().join(" ");
-            let body = normalized
-                .strip_prefix("#[reduction(")
-                .or_else(|| normalized.strip_prefix("#[$crate::reduction("))
-                .unwrap_or(&normalized);
-            let body = body.strip_suffix(")]").unwrap_or(body).trim();
-            if !body.starts_with("overhead =") {
-                return true;
-            }
-            in_reduction_attr = false;
-        }
+    .to_string()
+    .contains("classifies target field `x` more than once"));
+    assert!(ParameterContractError::EmptyUnavailableReason {
+        edge: "A -> B".into(),
+        field: "x".into(),
     }
+    .to_string()
+    .contains("unavailable without a reason"));
 
-    false
+    let entry = entry_with(ReductionParameterDeclarations::default);
+    let debug = format!("{entry:?}");
+    assert!(debug.contains("parameter_contract"));
+    assert!(debug.contains("capabilities"));
 }
 
 #[test]
-fn every_registered_reduction_has_unique_exact_endpoints() {
-    let entries = reduction_entries();
-    let mut seen = std::collections::HashMap::new();
-    for entry in &entries {
-        let key = exact_endpoint_key(entry);
-        if let Some(prev) = seen.insert(key.clone(), entry) {
+fn every_registered_contract_validates() {
+    for entry in reduction_entries() {
+        entry.parameter_contract().unwrap_or_else(|error| {
             panic!(
-                "Duplicate exact reduction endpoint {:?}: {} {:?} -> {} {:?} vs {} {:?} -> {} {:?}",
-                key,
-                prev.source_name,
-                prev.source_variant(),
-                prev.target_name,
-                prev.target_variant(),
-                entry.source_name,
-                entry.source_variant(),
-                entry.target_name,
-                entry.target_variant(),
-            );
-        }
+                "{} -> {} has an invalid parameter contract: {error}",
+                entry.source_name, entry.target_name
+            )
+        });
     }
 }
 
 #[test]
-fn every_registered_reduction_has_non_empty_names() {
-    for entry in reduction_entries() {
-        assert!(
-            !entry.source_name.is_empty(),
-            "Empty source_name for reduction targeting {}",
-            entry.target_name,
-        );
-        assert!(
-            !entry.target_name.is_empty(),
-            "Empty target_name for reduction sourced from {}",
-            entry.source_name,
-        );
+fn every_registered_parameter_declaration_uses_problem_owned_parameters() {
+    if let Err(errors) = validate_reduction_parameter_schemas() {
+        panic!("{}", errors.join("\n"));
     }
 }
-
-#[test]
-fn repo_reductions_use_overhead_only_attribute() {
-    let mut rust_files = Vec::new();
-    walk_rust_files(Path::new("src/rules"), &mut rust_files);
-
-    let offenders: Vec<_> = rust_files
-        .into_iter()
-        .filter(|path| reduction_attribute_has_extra_top_level_field(path))
-        .collect();
-
-    assert!(
-        offenders.is_empty(),
-        "extra top-level reduction attribute still present in: {:?}",
-        offenders,
-    );
-}
-
-#[test]
-fn test_edge_capabilities_constructors() {
-    let wo = EdgeCapabilities::witness_only();
-    assert!(wo.witness);
-    assert!(!wo.aggregate);
-
-    let ao = EdgeCapabilities::aggregate_only();
-    assert!(!ao.witness);
-    assert!(ao.aggregate);
-
-    let both = EdgeCapabilities::both();
-    assert!(both.witness);
-    assert!(both.aggregate);
-
-    let none = EdgeCapabilities::none();
-    assert!(!none.witness);
-    assert!(!none.aggregate);
-    assert!(!none.turing);
-}
-
-#[test]
-fn test_edge_capabilities_default_is_witness_only() {
-    let default = EdgeCapabilities::default();
-    assert_eq!(default, EdgeCapabilities::witness_only());
-}
-
-#[test]
-fn test_edge_capabilities_serde_roundtrip() {
-    let caps = EdgeCapabilities::both();
-    let json = serde_json::to_string(&caps).unwrap();
-    let back: EdgeCapabilities = serde_json::from_str(&json).unwrap();
-    assert_eq!(caps, back);
-}
diff --git a/src/unit_tests/rules/resourceconstrainedscheduling_ilp.rs b/src/unit_tests/rules/resourceconstrainedscheduling_ilp.rs
index f29497710..9e811bbd4 100644
--- a/src/unit_tests/rules/resourceconstrainedscheduling_ilp.rs
+++ b/src/unit_tests/rules/resourceconstrainedscheduling_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Or;
@@ -12,14 +12,11 @@ fn test_resourceconstrainedscheduling_to_ilp_closed_loop() {
         vec![20],
         vec![vec![6], vec![7], vec![7], vec![6], vec![8], vec![6]],
         2,
-    );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_satisfaction_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "ResourceConstrainedScheduling->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
@@ -29,19 +26,21 @@ fn test_resourceconstrainedscheduling_to_ilp_bf_vs_ilp() {
         vec![20],
         vec![vec![6], vec![7], vec![7], vec![6], vec![8], vec![6]],
         2,
-    );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    )
+    .unwrap();
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf_witness = BruteForce::new()
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -49,10 +48,10 @@ fn test_resourceconstrainedscheduling_to_ilp_infeasible() {
     // 3 tasks, 1 processor, 1 resource with bound 5, deadline 1
     // Each task requires 6 resource units — can't fit any two in same slot
     let problem =
-        ResourceConstrainedScheduling::new(1, vec![5], vec![vec![6], vec![6], vec![6]], 1);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        ResourceConstrainedScheduling::new(1, vec![5], vec![vec![6], vec![6], vec![6]], 1).unwrap();
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible RCS should produce infeasible ILP"
     );
 }
@@ -60,12 +59,13 @@ fn test_resourceconstrainedscheduling_to_ilp_infeasible() {
 #[test]
 fn test_resourceconstrainedscheduling_to_ilp_structure() {
     let problem =
-        ResourceConstrainedScheduling::new(2, vec![10], vec![vec![3], vec![4], vec![5]], 2);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        ResourceConstrainedScheduling::new(2, vec![10], vec![vec![3], vec![4], vec![5]], 2)
+            .unwrap();
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=3 tasks, D=2 deadline → 6 variables
-    assert_eq!(ilp.num_vars, 6);
+    assert_eq!(ilp.num_vars(), 6);
     // 3 one-hot + 2 capacity + 1*2 resource = 7
-    assert_eq!(ilp.constraints.len(), 7);
+    assert_eq!(ilp.constraints().len(), 7);
 }
diff --git a/src/unit_tests/rules/rootedtreearrangement_rootedtreestorageassignment.rs b/src/unit_tests/rules/rootedtreearrangement_rootedtreestorageassignment.rs
index ec413aeb6..da6346190 100644
--- a/src/unit_tests/rules/rootedtreearrangement_rootedtreestorageassignment.rs
+++ b/src/unit_tests/rules/rootedtreearrangement_rootedtreestorageassignment.rs
@@ -7,7 +7,8 @@ fn test_rootedtreearrangement_to_rootedtreestorageassignment_closed_loop() {
     // Path graph P4: 0-1-2-3, bound K=5
     // Optimal chain tree gives total distance 3 <= 5
     let source = RootedTreeArrangement::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]), 5);
-    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source);
+    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
     assert_satisfaction_round_trip_from_satisfaction_target(&source, &reduction, "P4 path graph");
 }
 
@@ -15,7 +16,8 @@ fn test_rootedtreearrangement_to_rootedtreestorageassignment_closed_loop() {
 fn test_rootedtreearrangement_to_rootedtreestorageassignment_target_structure() {
     // Triangle graph: 3 vertices, 3 edges, bound K=6
     let source = RootedTreeArrangement::new(SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]), 6);
-    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source);
+    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Universe size = num_vertices = 3
@@ -35,7 +37,8 @@ fn test_rootedtreearrangement_to_rootedtreestorageassignment_star_graph() {
     // Star graph K_{1,3}: center=0, leaves=1,2,3
     // Bound K=3 (optimal: root at 0, each leaf distance 1, total=3)
     let source = RootedTreeArrangement::new(SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3)]), 3);
-    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source);
+    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // K' = 3 - 3 = 0 (no extensions needed for a star rooted at center)
@@ -52,7 +55,8 @@ fn test_rootedtreearrangement_to_rootedtreestorageassignment_unsatisfiable() {
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
         7,
     );
-    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source);
+    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // K' = 7 - 6 = 1
@@ -61,11 +65,11 @@ fn test_rootedtreearrangement_to_rootedtreestorageassignment_unsatisfiable() {
     // Both source and target should be unsatisfiable
     let solver = BruteForce::new();
     assert!(
-        solver.find_witness(&source).is_none(),
+        solver.solve(&source).unwrap().is_none(),
         "K4 with K=7 should be unsatisfiable"
     );
     assert!(
-        solver.find_witness(target).is_none(),
+        solver.solve(target).unwrap().is_none(),
         "target should also be unsatisfiable"
     );
 }
@@ -74,7 +78,8 @@ fn test_rootedtreearrangement_to_rootedtreestorageassignment_unsatisfiable() {
 fn test_rootedtreearrangement_to_rootedtreestorageassignment_solution_extraction() {
     // Simple edge: 2 vertices, 1 edge {0,1}, bound K=1
     let source = RootedTreeArrangement::new(SimpleGraph::new(2, vec![(0, 1)]), 1);
-    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source);
+    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Target: universe_size=2, subsets={{0,1}}, bound=0
@@ -83,19 +88,20 @@ fn test_rootedtreearrangement_to_rootedtreestorageassignment_solution_extraction
 
     // Target solution: parent array [0, 0] means tree rooted at 0 with 1->0
     let target_config = vec![0, 0];
-    let source_config = reduction.extract_solution(&target_config);
+    let source_config = reduction.extract_solution(&target_config).unwrap();
 
     // Source config should be [parent_array | identity_mapping] = [0, 0, 0, 1]
     assert_eq!(source_config, vec![0, 0, 0, 1]);
     // Verify it's valid for the source
-    assert!(source.is_valid_solution(&source_config));
+    assert!(source.is_valid_solution(&source_config).unwrap());
 }
 
 #[test]
 fn test_rootedtreearrangement_to_rootedtreestorageassignment_empty_graph() {
     // Graph with no edges
     let source = RootedTreeArrangement::new(SimpleGraph::new(3, vec![]), 0);
-    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source);
+    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.universe_size(), 3);
@@ -110,17 +116,18 @@ fn test_rootedtreearrangement_to_rootedtreestorageassignment_infeasible_underflo
     // K < |E|: bound is too small for a 3-edge path, so source is infeasible.
     // The reduction should return an infeasible gadget rather than panic.
     let source = RootedTreeArrangement::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]), 2);
-    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source);
+    let reduction = ReduceTo::<RootedTreeStorageAssignment>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // Gadget should be infeasible
     let solver = BruteForce::new();
     assert!(
-        solver.find_witness(&source).is_none(),
+        solver.solve(&source).unwrap().is_none(),
         "source with K=2 < |E|=3 should be infeasible"
     );
     assert!(
-        solver.find_witness(target).is_none(),
+        solver.solve(target).unwrap().is_none(),
         "gadget target should also be infeasible"
     );
 }
diff --git a/src/unit_tests/rules/rootedtreestorageassignment_ilp.rs b/src/unit_tests/rules/rootedtreestorageassignment_ilp.rs
index d21d180aa..737aec834 100644
--- a/src/unit_tests/rules/rootedtreestorageassignment_ilp.rs
+++ b/src/unit_tests/rules/rootedtreestorageassignment_ilp.rs
@@ -7,7 +7,8 @@ use crate::types::Or;
 #[test]
 fn test_reduction_creates_valid_ilp() {
     let problem = RootedTreeStorageAssignment::new(3, vec![vec![0, 1], vec![1, 2]], 1);
-    let reduction: ReductionRTSAToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionRTSAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=3, r=2 (both subsets have size 2)
@@ -15,7 +16,7 @@ fn test_reduction_creates_valid_ilp() {
     let r = 2;
     let expected = n * n * n + 2 * n * n + n + r * (n * n + 2 * n + 3);
     assert_eq!(ilp.num_vars(), expected);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -23,24 +24,25 @@ fn test_rootedtreestorageassignment_to_ilp_bf_vs_ilp() {
     let problem = RootedTreeStorageAssignment::new(3, vec![vec![0, 1], vec![1, 2]], 1);
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem);
+    let bf_witness = bf.solve(&problem).unwrap();
     let bf_value = bf_witness
         .as_ref()
-        .map(|w| problem.evaluate(w))
+        .map(|w| problem.evaluate(w).unwrap())
         .unwrap_or(Or(false));
 
-    let reduction: ReductionRTSAToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionRTSAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_result = ilp_solver.solve(reduction.target_problem());
 
     match ilp_result {
-        Some(ilp_solution) => {
-            let extracted = reduction.extract_solution(&ilp_solution);
-            let ilp_value = problem.evaluate(&extracted);
+        Ok(ilp_solution) => {
+            let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+            let ilp_value = problem.evaluate(&extracted).unwrap();
             assert!(ilp_value.0, "ILP solution should be feasible");
             assert!(bf_value.0, "BF should also find feasible solution");
         }
-        None => {
+        Err(_) => {
             assert!(!bf_value.0, "both should agree on infeasibility");
         }
     }
@@ -57,27 +59,26 @@ fn test_rootedtreestorageassignment_to_ilp_infeasible() {
     );
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem);
+    let bf_witness = bf.solve(&problem).unwrap();
 
-    let reduction: ReductionRTSAToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionRTSAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_result = ilp_solver.solve(reduction.target_problem());
     assert!(bf_witness.is_none(), "source should be infeasible");
-    assert!(
-        ilp_result.is_none(),
-        "reduced ILP should also be infeasible"
-    );
+    assert!(ilp_result.is_err(), "reduced ILP should also be infeasible");
 }
 
 #[test]
 fn test_solution_extraction() {
     let problem = RootedTreeStorageAssignment::new(3, vec![vec![0, 1, 2]], 0);
-    let reduction: ReductionRTSAToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionRTSAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted.len(), 3);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/ruralpostman_ilp.rs b/src/unit_tests/rules/ruralpostman_ilp.rs
index 8798cd6ea..ac981b878 100644
--- a/src/unit_tests/rules/ruralpostman_ilp.rs
+++ b/src/unit_tests/rules/ruralpostman_ilp.rs
@@ -14,17 +14,18 @@ fn test_ruralpostman_to_ilp_closed_loop() {
         vec![0],
     );
     let direct = BruteForce::new()
-        .find_witness(&source)
+        .solve(&source)
+        .unwrap()
         .expect("source instance should have an optimal solution");
-    assert!(source.evaluate(&direct).0.is_some());
+    assert!(source.evaluate(&direct).unwrap().0.is_some());
 
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert!(source.evaluate(&extracted).0.is_some());
+    assert!(source.evaluate(&extracted).unwrap().0.is_some());
 }
 
 #[test]
@@ -38,18 +39,19 @@ fn test_ruralpostman_to_ilp_optimization() {
 
     // Brute-force optimal on the source
     let bf_witness = BruteForce::new()
-        .find_witness(&source)
+        .solve(&source)
+        .unwrap()
         .expect("brute-force optimum");
-    let bf_value = source.evaluate(&bf_witness);
+    let bf_value = source.evaluate(&bf_witness).unwrap();
 
     // ILP reduction optimal
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let ilp_value = source.evaluate(&extracted);
+    let ilp_value = source.evaluate(&extracted).unwrap();
     assert!(ilp_value.0.is_some(), "ILP solution must be valid");
     assert_eq!(
         ilp_value, bf_value,
@@ -64,6 +66,21 @@ fn test_ruralpostman_to_ilp_bf_vs_ilp() {
         vec![1, 1, 1],
         vec![0],
     );
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
+
+#[test]
+fn test_ruralpostman_empty_required_set_extracts_zero_multiplicities() {
+    let source = RuralPostman::new(
+        SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
+        vec![4, 7],
+        vec![],
+    );
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&source).unwrap();
+    let target = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+    let extracted = reduction.extract_solution(&target).unwrap();
+
+    assert_eq!(extracted, vec![0, 0]);
+    assert_eq!(source.evaluate(&extracted).unwrap().0, Some(0));
+}
diff --git a/src/unit_tests/rules/sat_circuitsat.rs b/src/unit_tests/rules/sat_circuitsat.rs
index 77b27e20a..259064674 100644
--- a/src/unit_tests/rules/sat_circuitsat.rs
+++ b/src/unit_tests/rules/sat_circuitsat.rs
@@ -1,8 +1,6 @@
 use super::*;
 use crate::models::formula::{CNFClause, CircuitSAT, Satisfiability};
-use crate::rules::test_helpers::{
-    assert_satisfaction_round_trip_from_satisfaction_target, solve_satisfaction_problem,
-};
+use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
 use crate::rules::ReduceTo;
 use crate::solvers::BruteForce;
 
@@ -16,7 +14,7 @@ fn test_sat_to_circuitsat_closed_loop() {
             CNFClause::new(vec![-1, 2, -3]),
         ],
     );
-    let result = ReduceTo::<CircuitSAT>::reduce_to(&sat);
+    let result = ReduceTo::<CircuitSAT>::reduce_to(&sat).expect("reduction should succeed");
     assert_satisfaction_round_trip_from_satisfaction_target(
         &sat,
         &result,
@@ -28,9 +26,9 @@ fn test_sat_to_circuitsat_closed_loop() {
 fn test_sat_to_circuitsat_unsatisfiable() {
     // Unsatisfiable: (x1) & (!x1)
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1]), CNFClause::new(vec![-1])]);
-    let result = ReduceTo::<CircuitSAT>::reduce_to(&sat);
+    let result = ReduceTo::<CircuitSAT>::reduce_to(&sat).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_target = solver.find_all_witnesses(result.target_problem());
+    let best_target = solver.find_all_witnesses(result.target_problem()).unwrap();
     assert!(
         best_target.is_empty(),
         "Unsatisfiable SAT -> CircuitSAT should have no solutions"
@@ -41,7 +39,7 @@ fn test_sat_to_circuitsat_unsatisfiable() {
 fn test_sat_to_circuitsat_single_clause() {
     // Single clause: (x1 v x2)
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1, 2])]);
-    let result = ReduceTo::<CircuitSAT>::reduce_to(&sat);
+    let result = ReduceTo::<CircuitSAT>::reduce_to(&sat).expect("reduction should succeed");
     assert_satisfaction_round_trip_from_satisfaction_target(
         &sat,
         &result,
@@ -53,17 +51,19 @@ fn test_sat_to_circuitsat_single_clause() {
 fn test_sat_to_circuitsat_single_literal_clause() {
     // Single literal clause: (x1) & (x2)
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1]), CNFClause::new(vec![2])]);
-    let result = ReduceTo::<CircuitSAT>::reduce_to(&sat);
+    let result = ReduceTo::<CircuitSAT>::reduce_to(&sat).expect("reduction should succeed");
     assert_satisfaction_round_trip_from_satisfaction_target(
         &sat,
         &result,
         "SAT->CircuitSAT single literal clause",
     );
 
-    let target_solution = solve_satisfaction_problem(result.target_problem())
+    let target_solution = BruteForce::new()
+        .solve(result.target_problem())
+        .unwrap()
         .expect("CircuitSAT should have a satisfying solution");
-    let extracted = result.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![1, 1]);
+    let extracted = result.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![true, true]);
 }
 
 #[test]
@@ -71,7 +71,7 @@ fn test_sat_to_circuitsat_unused_variables() {
     // 5 variables but only x1 and x2 appear in clauses; x3..x5 are unused.
     // Previously panicked because unused variables were missing from CircuitSAT.
     let sat = Satisfiability::new(5, vec![CNFClause::new(vec![1, 2])]);
-    let result = ReduceTo::<CircuitSAT>::reduce_to(&sat);
+    let result = ReduceTo::<CircuitSAT>::reduce_to(&sat).expect("reduction should succeed");
     assert_satisfaction_round_trip_from_satisfaction_target(
         &sat,
         &result,
diff --git a/src/unit_tests/rules/sat_coloring.rs b/src/unit_tests/rules/sat_coloring.rs
index 929bb7651..42fc5e598 100644
--- a/src/unit_tests/rules/sat_coloring.rs
+++ b/src/unit_tests/rules/sat_coloring.rs
@@ -36,7 +36,8 @@ fn test_special_vertex_accessors() {
 fn test_sat_to_coloring_closed_loop() {
     // Simple SAT: (x1) - one clause with one literal
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
     let coloring = reduction.target_problem();
 
     // Should have 2*1 + 3 = 5 base vertices
@@ -53,7 +54,8 @@ fn test_reduction_structure() {
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1, 2])],
     );
 
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
     let coloring = reduction.target_problem();
 
     // Base vertices: 3 (TRUE, FALSE, AUX) + 2*2 (pos and neg for each var) = 7
@@ -70,20 +72,20 @@ fn test_unsatisfiable_formula() {
     // Unsatisfiable: (x1) AND (NOT x1)
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1]), CNFClause::new(vec![-1])]);
 
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
     let coloring = reduction.target_problem();
 
     // Solve the coloring problem - use find_all_witnesses since KColoring is a satisfaction problem
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(coloring);
+    let solutions = solver.find_all_witnesses(coloring).unwrap();
 
     // For an unsatisfiable formula, the coloring should have no valid solutions
     // OR no valid coloring exists that extracts to a satisfying SAT assignment
     let mut found_satisfying = false;
     for sol in &solutions {
-        let sat_sol = reduction.extract_solution(sol);
-        let assignment: Vec<bool> = sat_sol.iter().map(|&v| v == 1).collect();
-        if sat.is_satisfying(&assignment) {
+        let sat_sol = reduction.extract_solution(sol).unwrap();
+        if sat.is_satisfying(&sat_sol) {
             found_satisfying = true;
             break;
         }
@@ -107,7 +109,8 @@ fn test_three_literal_clause_structure() {
     // (x1 OR x2 OR x3)
     let sat = Satisfiability::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
 
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
     let coloring = reduction.target_problem();
 
     // Base vertices: 3 + 2*3 = 9
@@ -126,7 +129,8 @@ fn test_coloring_structure() {
         3,
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1, 3])],
     );
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
     let coloring = reduction.target_problem();
 
     // Verify coloring has expected structure
@@ -138,7 +142,8 @@ fn test_coloring_structure() {
 fn test_extract_solution_basic() {
     // Simple case: one variable, one clause (x1)
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
 
     // Manually construct a valid coloring where x1 has TRUE color
     // Vertices: 0=TRUE, 1=FALSE, 2=AUX, 3=x1, 4=NOT_x1
@@ -170,7 +175,8 @@ fn test_complex_formula_structure() {
         ],
     );
 
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
     let coloring = reduction.target_problem();
 
     // Base vertices: 3 + 2*3 = 9
@@ -186,16 +192,17 @@ fn test_single_literal_clauses() {
     // (x1) AND (x2) - both must be true
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1]), CNFClause::new(vec![2])]);
 
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
     let coloring = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(coloring);
+    let solutions = solver.find_all_witnesses(coloring).unwrap();
 
     let mut found_correct = false;
     for sol in &solutions {
-        let sat_sol = reduction.extract_solution(sol);
-        if sat_sol == vec![1, 1] {
+        let sat_sol = reduction.extract_solution(sol).unwrap();
+        if sat_sol == vec![true, true] {
             found_correct = true;
             break;
         }
@@ -211,7 +218,8 @@ fn test_single_literal_clauses() {
 fn test_empty_sat() {
     // Empty SAT (trivially satisfiable)
     let sat = Satisfiability::new(0, vec![]);
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
 
     assert_eq!(reduction.num_clauses(), 0);
     assert!(reduction.pos_vertices().is_empty());
@@ -228,7 +236,8 @@ fn test_num_clauses_accessor() {
         2,
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1])],
     );
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
     assert_eq!(reduction.num_clauses(), 2);
 }
 
@@ -255,7 +264,8 @@ fn test_manual_coloring_extraction() {
     // Test solution extraction with a manually constructed coloring solution
     // for a simple 1-variable SAT problem: (x1)
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
     let coloring = reduction.target_problem();
 
     // The graph structure for (x1) with set_true:
@@ -272,9 +282,9 @@ fn test_manual_coloring_extraction() {
     let valid_coloring = vec![0, 1, 2, 0, 1];
 
     assert_eq!(coloring.graph().num_vertices(), 5);
-    let extracted = reduction.extract_solution(&valid_coloring);
+    let extracted = reduction.extract_solution(&valid_coloring).unwrap();
     // x1 should be true (1) because vertex 3 has color 0 which equals TRUE vertex's color
-    assert_eq!(extracted, vec![1]);
+    assert_eq!(extracted, vec![true]);
 }
 
 #[test]
@@ -282,20 +292,21 @@ fn test_extraction_with_different_color_assignment() {
     // Test that extraction works with different color assignments
     // (colors may be permuted but semantics preserved)
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
-    let reduction = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&sat).expect("reduction should succeed");
 
     // Different valid coloring: TRUE=2, FALSE=0, AUX=1
     // x1 must have color 2 (TRUE), NOT_x1 must have color 0 (FALSE)
     let coloring_permuted = vec![2, 0, 1, 2, 0];
-    let extracted = reduction.extract_solution(&coloring_permuted);
+    let extracted = reduction.extract_solution(&coloring_permuted).unwrap();
     // x1 should still be true because its color equals TRUE vertex's color
-    assert_eq!(extracted, vec![1]);
+    assert_eq!(extracted, vec![true]);
 
     // Another permutation: TRUE=1, FALSE=2, AUX=0
     // x1 has color 1 (TRUE), NOT_x1 has color 2 (FALSE)
     let coloring_permuted2 = vec![1, 2, 0, 1, 2];
-    let extracted2 = reduction.extract_solution(&coloring_permuted2);
-    assert_eq!(extracted2, vec![1]);
+    let extracted2 = reduction.extract_solution(&coloring_permuted2).unwrap();
+    assert_eq!(extracted2, vec![true]);
 }
 
 #[test]
@@ -317,25 +328,27 @@ fn test_jl_parity_sat_to_coloring() {
         let inst = &jl_find_instance_by_label(&sat_data, label)["instance"];
         let (num_vars, clauses) = jl_parse_sat_clauses(inst);
         let source = Satisfiability::new(num_vars, clauses);
-        let result = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&source);
+        let result = ReduceTo::<KColoring<K3, SimpleGraph>>::reduce_to(&source)
+            .expect("reduction should succeed");
         let ilp_solver = crate::solvers::ILPSolver::new();
         let target = result.target_problem();
         let target_sol = ilp_solver
-            .solve_reduced(target)
+            .solve(target)
             .expect("ILP should find a coloring");
-        let extracted = result.extract_solution(&target_sol);
-        let best_source: HashSet<Vec<usize>> = BruteForce::new()
+        let extracted = result.extract_solution(&target_sol).unwrap();
+        let best_source: HashSet<Vec<bool>> = BruteForce::new()
             .find_all_witnesses(&source)
+            .unwrap()
             .into_iter()
             .collect();
         assert!(
-            source.evaluate(&extracted),
+            source.evaluate(&extracted).unwrap(),
             "SAT->Coloring [{label}]: extracted assignment is not satisfying"
         );
         for case in data["cases"].as_array().unwrap() {
             assert_eq!(
                 best_source,
-                jl_parse_configs_set(&case["best_source"]),
+                jl_parse_bool_configs_set(&case["best_source"]),
                 "SAT->Coloring [{label}]: best source mismatch"
             );
         }
diff --git a/src/unit_tests/rules/sat_helpers.rs b/src/unit_tests/rules/sat_helpers.rs
new file mode 100644
index 000000000..ebfe7ac4c
--- /dev/null
+++ b/src/unit_tests/rules/sat_helpers.rs
@@ -0,0 +1,30 @@
+use super::*;
+
+#[test]
+fn test_sat_variable_allocator_numeric_boundaries() {
+    let mut allocator = SatVariableAllocator::new("test reduction", i64::MAX as usize - 1)
+        .expect("largest valid starting count");
+    assert_eq!(allocator.allocate().unwrap(), i64::MAX);
+    assert_eq!(allocator.num_vars(), i64::MAX as usize);
+
+    let error = allocator.allocate().unwrap_err();
+    let error = error.to_string();
+    assert!(error.contains("test reduction"));
+    assert!(error.contains(&format!("limited to {}", i64::MAX)));
+}
+
+#[test]
+fn test_sat_variable_allocator_batch_numeric_boundaries() {
+    let mut exact = SatVariableAllocator::new("exact batch", i64::MAX as usize - 2).unwrap();
+    assert_eq!(
+        exact.allocate_many(2).unwrap(),
+        vec![i64::MAX - 1, i64::MAX]
+    );
+    assert_eq!(exact.num_vars(), i64::MAX as usize);
+
+    let mut overflow = SatVariableAllocator::new("overflow batch", i64::MAX as usize - 1).unwrap();
+    let error = overflow.allocate_many(2).unwrap_err();
+    let error = error.to_string();
+    assert!(error.contains("cannot allocate 2 auxiliary variables"));
+    assert_eq!(overflow.num_vars(), i64::MAX as usize - 1);
+}
diff --git a/src/unit_tests/rules/sat_ksat.rs b/src/unit_tests/rules/sat_ksat.rs
index 3c20a3c05..4e4cfa7c5 100644
--- a/src/unit_tests/rules/sat_ksat.rs
+++ b/src/unit_tests/rules/sat_ksat.rs
@@ -10,7 +10,8 @@ fn test_sat_to_3sat_exact_size() {
     // Clause already has 3 literals - should remain unchanged
     let sat = Satisfiability::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     assert_eq!(ksat.num_vars(), 3);
@@ -24,7 +25,8 @@ fn test_sat_to_3sat_padding() {
     // (a v b) becomes (a v b v x) AND (a v b v -x)
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1, 2])]);
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     // Should have 2 clauses (positive and negative ancilla)
@@ -41,7 +43,8 @@ fn test_sat_to_3sat_splitting() {
     // (a v b v c v d) becomes (a v b v x) AND (-x v c v d)
     let sat = Satisfiability::new(4, vec![CNFClause::new(vec![1, 2, 3, 4])]);
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     // Should have 2 clauses after splitting
@@ -71,7 +74,8 @@ fn test_sat_to_3sat_large_clause() {
     // (a v b v c v d v e) -> (a v b v x1) AND (-x1 v c v x2) AND (-x2 v d v e)
     let sat = Satisfiability::new(5, vec![CNFClause::new(vec![1, 2, 3, 4, 5])]);
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     // Should have 3 clauses after splitting
@@ -88,7 +92,8 @@ fn test_sat_to_3sat_single_literal() {
     // (a) becomes (a v x v y) where we pad twice
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     // With recursive padding: (a) -> (a v x) AND (a v -x)
@@ -114,14 +119,15 @@ fn test_sat_to_ksat_closed_loop() {
         ],
     );
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     // Solve both problems - use find_all_witnesses for satisfaction problems
     let solver = BruteForce::new();
 
-    let sat_solutions = solver.find_all_witnesses(&sat);
-    let ksat_solutions = solver.find_all_witnesses(ksat);
+    let sat_solutions = solver.find_all_witnesses(&sat).unwrap();
+    let ksat_solutions = solver.find_all_witnesses(ksat).unwrap();
 
     // If SAT is satisfiable, K-SAT should be too
     let sat_satisfiable = !sat_solutions.is_empty();
@@ -143,20 +149,21 @@ fn test_sat_to_ksat_closed_loop() {
 fn test_sat_to_3sat_solution_extraction() {
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1, 2])]);
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     // Solve K-SAT - use find_all_witnesses for satisfaction problems
     let solver = BruteForce::new();
-    let ksat_solutions = solver.find_all_witnesses(ksat);
+    let ksat_solutions = solver.find_all_witnesses(ksat).unwrap();
 
     // Extract and verify solutions
     for ksat_sol in &ksat_solutions {
-        let sat_sol = reduction.extract_solution(ksat_sol);
+        let sat_sol = reduction.extract_solution(ksat_sol).unwrap();
         // Should only have original 2 variables
         assert_eq!(sat_sol.len(), 2);
         // Should satisfy original problem
-        assert!(sat.evaluate(&sat_sol));
+        assert!(sat.evaluate(&sat_sol).unwrap());
     }
 }
 
@@ -170,7 +177,7 @@ fn test_3sat_to_sat() {
         ],
     );
 
-    let reduction = ReduceTo::<Satisfiability>::reduce_to(&ksat);
+    let reduction = ReduceTo::<Satisfiability>::reduce_to(&ksat).expect("reduction should succeed");
     let sat = reduction.target_problem();
 
     assert_eq!(sat.num_vars(), 3);
@@ -185,11 +192,11 @@ fn test_3sat_to_sat() {
 fn test_3sat_to_sat_solution_extraction() {
     let ksat = KSatisfiability::<K3>::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
 
-    let reduction = ReduceTo::<Satisfiability>::reduce_to(&ksat);
+    let reduction = ReduceTo::<Satisfiability>::reduce_to(&ksat).expect("reduction should succeed");
 
-    let sol = vec![1, 0, 1];
-    let extracted = reduction.extract_solution(&sol);
-    assert_eq!(extracted, vec![1, 0, 1]);
+    let sol = vec![true, false, true];
+    let extracted = reduction.extract_solution(&sol).unwrap();
+    assert_eq!(extracted, vec![true, false, true]);
 }
 
 #[test]
@@ -201,19 +208,20 @@ fn test_roundtrip_sat_3sat_sat() {
     );
 
     // SAT -> 3-SAT
-    let to_ksat = ReduceTo::<KSatisfiability<K3>>::reduce_to(&original_sat);
+    let to_ksat = ReduceTo::<KSatisfiability<K3>>::reduce_to(&original_sat)
+        .expect("reduction should succeed");
     let ksat = to_ksat.target_problem();
 
     // 3-SAT -> SAT
-    let to_sat = ReduceTo::<Satisfiability>::reduce_to(ksat);
+    let to_sat = ReduceTo::<Satisfiability>::reduce_to(ksat).expect("reduction should succeed");
     let final_sat = to_sat.target_problem();
 
     // Solve all three - use find_all_witnesses for satisfaction problems
     let solver = BruteForce::new();
 
-    let orig_solutions = solver.find_all_witnesses(&original_sat);
-    let ksat_solutions = solver.find_all_witnesses(ksat);
-    let final_solutions = solver.find_all_witnesses(final_sat);
+    let orig_solutions = solver.find_all_witnesses(&original_sat).unwrap();
+    let ksat_solutions = solver.find_all_witnesses(ksat).unwrap();
+    let final_solutions = solver.find_all_witnesses(final_sat).unwrap();
 
     // All should be satisfiable (have at least one solution)
     assert!(!orig_solutions.is_empty());
@@ -233,7 +241,8 @@ fn test_sat_to_3sat_mixed_clause_types() {
         ],
     );
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     // All clauses should have exactly 3 literals
@@ -244,21 +253,23 @@ fn test_sat_to_3sat_mixed_clause_types() {
 
 #[test]
 fn test_ksat_structure() {
-    let sat = Satisfiability::new(3, vec![CNFClause::new(vec![1, 2, 3, 4])]);
+    let sat = Satisfiability::new(4, vec![CNFClause::new(vec![1, 2, 3, 4])]);
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     // K-SAT should preserve original variables plus auxiliary vars
     // A 4-literal clause requires 1 auxiliary variable for Tseitin
-    assert_eq!(ksat.num_vars(), 3 + 1); // Original vars + 1 auxiliary for Tseitin
+    assert_eq!(ksat.num_vars(), 4 + 1); // Original vars + 1 auxiliary for Tseitin
 }
 
 #[test]
 fn test_empty_sat_to_3sat() {
     let sat = Satisfiability::new(3, vec![]);
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     assert_eq!(ksat.num_clauses(), 0);
@@ -278,7 +289,8 @@ fn test_mixed_clause_sizes() {
         ],
     );
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     // All clauses should have exactly 3 literals
@@ -299,12 +311,17 @@ fn test_unsatisfiable_formula() {
     // (x) AND (-x) is unsatisfiable
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1]), CNFClause::new(vec![-1])]);
 
-    let reduction = ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&sat).expect("reduction should succeed");
     let ksat = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let best_target = solver.find_all_witnesses(ksat);
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&sat).into_iter().collect();
+    let best_target = solver.find_all_witnesses(ksat).unwrap();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&sat)
+        .unwrap()
+        .into_iter()
+        .collect();
 
     // Both should be empty (unsatisfiable)
     assert!(best_source.is_empty());
@@ -322,16 +339,21 @@ fn test_jl_parity_sat_to_ksat() {
     let inst = &sat_data["instances"][0]["instance"];
     let (num_vars, clauses) = jl_parse_sat_clauses(inst);
     let source = Satisfiability::new(num_vars, clauses);
-    let result = ReduceTo::<KSatisfiability<K3>>::reduce_to(&source);
+    let result =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
         &result,
         "JL parity SAT->KSat",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -346,16 +368,20 @@ fn test_jl_parity_ksat_to_sat() {
     let inst = &ksat_data["instances"][0]["instance"];
     let (num_vars, clauses) = jl_parse_sat_clauses(inst);
     let source = KSatisfiability::<K3>::new(num_vars, clauses);
-    let result = ReduceTo::<Satisfiability>::reduce_to(&source);
+    let result = ReduceTo::<Satisfiability>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
         &result,
         "JL parity KSat->SAT",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -370,15 +396,20 @@ fn test_jl_parity_rule_sat_to_ksat() {
     let inst = &jl_find_instance_by_label(&sat_data, "rule_3sat_multi")["instance"];
     let (num_vars, clauses) = jl_parse_sat_clauses(inst);
     let source = Satisfiability::new(num_vars, clauses);
-    let result = ReduceTo::<KSatisfiability<K3>>::reduce_to(&source);
+    let result =
+        ReduceTo::<KSatisfiability<K3>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
         &result,
         "JL parity rule SAT->KSat",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
diff --git a/src/unit_tests/rules/sat_maximumindependentset.rs b/src/unit_tests/rules/sat_maximumindependentset.rs
index 9c2bd8f12..47b23dd0d 100644
--- a/src/unit_tests/rules/sat_maximumindependentset.rs
+++ b/src/unit_tests/rules/sat_maximumindependentset.rs
@@ -1,8 +1,6 @@
 use super::*;
 use crate::models::formula::CNFClause;
-use crate::rules::test_helpers::{
-    assert_satisfaction_round_trip_from_optimization_target, solve_optimization_problem,
-};
+use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
 use crate::solvers::BruteForce;
 use crate::topology::Graph;
 use crate::traits::Problem;
@@ -48,7 +46,8 @@ fn test_boolvar_complement() {
 fn test_sat_to_maximumindependentset_closed_loop() {
     // Simple SAT: (x1) - one clause with one literal
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let is_problem = reduction.target_problem();
 
     // Should have 1 vertex (one literal)
@@ -62,7 +61,8 @@ fn test_two_clause_sat_to_is() {
     // SAT: (x1) AND (NOT x1)
     // This is unsatisfiable
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1]), CNFClause::new(vec![-1])]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let is_problem = reduction.target_problem();
 
     // Should have 2 vertices
@@ -72,9 +72,9 @@ fn test_two_clause_sat_to_is() {
 
     // Maximum IS should have size 1 (can't select both)
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(is_problem);
+    let solutions = solver.find_all_witnesses(is_problem).unwrap();
     for sol in &solutions {
-        assert_eq!(sol.iter().sum::<usize>(), 1);
+        assert_eq!(sol.iter().filter(|&&selected| selected).count(), 1);
     }
 }
 
@@ -82,35 +82,38 @@ fn test_two_clause_sat_to_is() {
 fn test_extract_solution_basic() {
     // Simple case: (x1 OR x2)
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1, 2])]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat)
+        .expect("reduction should succeed");
 
     // Select vertex 0 (literal x1)
-    let is_sol = vec![1, 0];
-    let sat_sol = reduction.extract_solution(&is_sol);
-    assert_eq!(sat_sol, vec![1, 0]); // x1=true, x2=false
+    let is_sol = vec![true, false];
+    let sat_sol = reduction.extract_solution(&is_sol).unwrap();
+    assert_eq!(sat_sol, vec![true, false]); // x1=true, x2=false
 
     // Select vertex 1 (literal x2)
-    let is_sol = vec![0, 1];
-    let sat_sol = reduction.extract_solution(&is_sol);
-    assert_eq!(sat_sol, vec![0, 1]); // x1=false, x2=true
+    let is_sol = vec![false, true];
+    let sat_sol = reduction.extract_solution(&is_sol).unwrap();
+    assert_eq!(sat_sol, vec![false, true]); // x1=false, x2=true
 }
 
 #[test]
 fn test_extract_solution_with_negation() {
     // (NOT x1) - selecting NOT x1 means x1 should be false
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![-1])]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat)
+        .expect("reduction should succeed");
 
-    let is_sol = vec![1];
-    let sat_sol = reduction.extract_solution(&is_sol);
-    assert_eq!(sat_sol, vec![0]); // x1=false (so NOT x1 is true)
+    let is_sol = vec![true];
+    let sat_sol = reduction.extract_solution(&is_sol).unwrap();
+    assert_eq!(sat_sol, vec![false]); // x1=false (so NOT x1 is true)
 }
 
 #[test]
 fn test_clique_edges_in_clause() {
     // A clause with 3 literals should form a clique (3 edges)
     let sat = Satisfiability::new(3, vec![CNFClause::new(vec![1, 2, 3])]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let is_problem = reduction.target_problem();
 
     // 3 vertices, 3 edges (complete graph K3)
@@ -131,7 +134,8 @@ fn test_complement_edges_across_clauses() {
             CNFClause::new(vec![2]),
         ],
     );
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let is_problem = reduction.target_problem();
 
     assert_eq!(is_problem.graph().num_vertices(), 3);
@@ -144,7 +148,8 @@ fn test_is_structure() {
         3,
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1, 3])],
     );
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let is_problem = reduction.target_problem();
 
     // IS should have vertices for literals in clauses
@@ -155,7 +160,8 @@ fn test_is_structure() {
 fn test_empty_sat() {
     // Empty SAT (trivially satisfiable)
     let sat = Satisfiability::new(0, vec![]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let is_problem = reduction.target_problem();
 
     assert_eq!(is_problem.graph().num_vertices(), 0);
@@ -166,7 +172,8 @@ fn test_empty_sat() {
 #[test]
 fn test_literals_accessor() {
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1, -2])]);
-    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&sat)
+        .expect("reduction should succeed");
 
     let literals = reduction.literals();
     assert_eq!(literals.len(), 2);
@@ -209,18 +216,27 @@ fn test_jl_parity_sat_to_independentset() {
         let inst = &jl_find_instance_by_label(&sat_data, label)["instance"];
         let (num_vars, clauses) = jl_parse_sat_clauses(inst);
         let source = Satisfiability::new(num_vars, clauses);
-        let result = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&source);
+        let result = ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&source)
+            .expect("reduction should succeed");
         let solver = BruteForce::new();
-        let sat_solutions: HashSet<Vec<usize>> =
-            solver.find_all_witnesses(&source).into_iter().collect();
+        let sat_solutions: HashSet<Vec<bool>> = solver
+            .find_all_witnesses(&source)
+            .unwrap()
+            .into_iter()
+            .collect();
         for case in data["cases"].as_array().unwrap() {
             if sat_solutions.is_empty() {
-                let target_solution = solve_optimization_problem(result.target_problem())
+                let target_solution = BruteForce::new()
+                    .solve(result.target_problem())
+                    .unwrap()
                     .expect("SAT->IS: target should have an optimal solution");
-                let extracted = result.extract_solution(&target_solution);
-                assert!(
-                    !source.evaluate(&extracted),
-                    "SAT->IS [{label}]: unsatisfiable but extracted satisfies"
+                assert!(result.extract_solution(&target_solution).is_err());
+                assert_eq!(
+                    crate::rules::AggregateReductionResult::extract_value(
+                        &result,
+                        result.target_problem().evaluate(&target_solution).unwrap(),
+                    ),
+                    Or(false),
                 );
             } else {
                 assert_satisfaction_round_trip_from_optimization_target(
@@ -230,10 +246,81 @@ fn test_jl_parity_sat_to_independentset() {
                 );
                 assert_eq!(
                     sat_solutions,
-                    jl_parse_configs_set(&case["best_source"]),
+                    jl_parse_bool_configs_set(&case["best_source"]),
                     "SAT->IS [{label}]: best source mismatch"
                 );
             }
         }
     }
 }
+
+#[test]
+fn test_sat_to_independentset_all_certificates() {
+    let clauses = [
+        vec![],
+        vec![1],
+        vec![-1],
+        vec![1, 1],
+        vec![1, -1],
+        vec![1, 2],
+        vec![-1, -2],
+    ];
+    for first in &clauses {
+        for second in &clauses {
+            let source = Satisfiability::new(
+                2,
+                vec![
+                    CNFClause::new(first.clone()),
+                    CNFClause::new(second.clone()),
+                ],
+            );
+            let reduction =
+                ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&source).unwrap();
+            let target = reduction.target_problem();
+            assert!(std::ptr::eq(
+                target,
+                crate::rules::AggregateReductionResult::target_problem(&reduction)
+            ));
+            let mut accepted = false;
+            for mask in 0..(1usize << target.num_vertices()) {
+                let config: Vec<bool> = (0..target.num_vertices())
+                    .map(|i| mask & (1 << i) != 0)
+                    .collect();
+                let value = target.evaluate(&config).unwrap();
+                let certificate = value == Max(Some(2));
+                assert_eq!(
+                    crate::rules::AggregateReductionResult::extract_value(&reduction, value),
+                    Or(certificate)
+                );
+                match reduction.extract_solution(&config) {
+                    Ok(assignment) => {
+                        assert!(certificate);
+                        assert_eq!(source.evaluate(&assignment).unwrap(), Or(true));
+                        accepted = true;
+                    }
+                    Err(_) => assert!(!certificate),
+                }
+            }
+            assert_eq!(
+                accepted,
+                BruteForce::new().solve(&source).unwrap().is_some()
+            );
+            assert!(reduction
+                .extract_solution(&vec![false; target.num_vertices() + 1])
+                .is_err());
+        }
+    }
+    for num_vars in [0, 3] {
+        let source = Satisfiability::new(num_vars, vec![]);
+        let reduction =
+            ReduceTo::<MaximumIndependentSet<SimpleGraph, One>>::reduce_to(&source).unwrap();
+        assert_eq!(
+            reduction.extract_solution(&vec![]).unwrap(),
+            vec![false; num_vars]
+        );
+        assert_eq!(
+            crate::rules::AggregateReductionResult::extract_value(&reduction, Max(None)),
+            Or(false)
+        );
+    }
+}
diff --git a/src/unit_tests/rules/sat_minimumdominatingset.rs b/src/unit_tests/rules/sat_minimumdominatingset.rs
index a421375b0..c6db9615d 100644
--- a/src/unit_tests/rules/sat_minimumdominatingset.rs
+++ b/src/unit_tests/rules/sat_minimumdominatingset.rs
@@ -1,18 +1,16 @@
 use super::*;
 use crate::models::formula::CNFClause;
-use crate::rules::test_helpers::{
-    assert_satisfaction_round_trip_from_optimization_target, solve_optimization_problem,
-};
+use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
 use crate::solvers::BruteForce;
 use crate::topology::Graph;
-use crate::traits::Problem;
 include!("../jl_helpers.rs");
 
 #[test]
 fn test_sat_to_minimumdominatingset_closed_loop() {
     // Simple SAT: (x1) - one variable, one clause
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let ds_problem = reduction.target_problem();
 
     // Should have 3 vertices (variable gadget) + 1 clause vertex = 4 vertices
@@ -28,7 +26,8 @@ fn test_sat_to_minimumdominatingset_closed_loop() {
 fn test_two_variable_sat_to_ds() {
     // SAT: (x1 OR x2)
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1, 2])]);
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let ds_problem = reduction.target_problem();
 
     // 2 variables * 3 = 6 gadget vertices + 1 clause vertex = 7
@@ -45,40 +44,42 @@ fn test_two_variable_sat_to_ds() {
 fn test_extract_solution_positive_literal() {
     // (x1) - select positive literal
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
 
     // Solution: select vertex 0 (positive literal x1)
     // This dominates vertices 1, 2 (gadget) and vertex 3 (clause)
-    let ds_sol = vec![1, 0, 0, 0];
-    let sat_sol = reduction.extract_solution(&ds_sol);
-    assert_eq!(sat_sol, vec![1]); // x1 = true
+    let ds_sol = vec![true, false, false, false];
+    let sat_sol = reduction.extract_solution(&ds_sol).unwrap();
+    assert_eq!(sat_sol, vec![true]); // x1 = true
 }
 
 #[test]
 fn test_extract_solution_negative_literal() {
     // (NOT x1) - select negative literal
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![-1])]);
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
 
     // Solution: select vertex 1 (negative literal NOT x1)
     // This dominates vertices 0, 2 (gadget) and vertex 3 (clause)
-    let ds_sol = vec![0, 1, 0, 0];
-    let sat_sol = reduction.extract_solution(&ds_sol);
-    assert_eq!(sat_sol, vec![0]); // x1 = false
+    let ds_sol = vec![false, true, false, false];
+    let sat_sol = reduction.extract_solution(&ds_sol).unwrap();
+    assert_eq!(sat_sol, vec![false]); // x1 = false
 }
 
 #[test]
-fn test_extract_solution_dummy() {
-    // (x1 OR x2) where only x1 matters
+fn test_extract_solution_unused_variable() {
+    // The unit clause x1 leaves x2 unused.
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1])]);
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
 
-    // Select: vertex 0 (x1 positive) and vertex 5 (x2 dummy)
-    // Vertex 0 dominates: itself, 1, 2, and clause 6
-    // Vertex 5 dominates: 3, 4, and itself
-    let ds_sol = vec![1, 0, 0, 0, 0, 1, 0];
-    let sat_sol = reduction.extract_solution(&ds_sol);
-    assert_eq!(sat_sol, vec![1, 0]); // x1 = true, x2 = false (from dummy)
+    // Only x1 occurs, so its triangle is the only gadget. The unused x2
+    // remains false in the extracted source assignment.
+    let ds_sol = vec![true, false, false, false];
+    let sat_sol = reduction.extract_solution(&ds_sol).unwrap();
+    assert_eq!(sat_sol, vec![true, false]); // x1 = true, x2 = false (from dummy)
 }
 
 #[test]
@@ -87,7 +88,8 @@ fn test_ds_structure() {
         3,
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1, 3])],
     );
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let ds_problem = reduction.target_problem();
 
     // 3 vars * 3 = 9 gadget vertices + 2 clause vertices = 11
@@ -98,7 +100,8 @@ fn test_ds_structure() {
 fn test_empty_sat() {
     // Empty SAT (trivially satisfiable)
     let sat = Satisfiability::new(0, vec![]);
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let ds_problem = reduction.target_problem();
 
     assert_eq!(ds_problem.graph().num_vertices(), 0);
@@ -111,7 +114,8 @@ fn test_empty_sat() {
 fn test_multiple_literals_same_variable() {
     // Clause with repeated variable: (x1 OR NOT x1) - tautology
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1, -1])]);
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let ds_problem = reduction.target_problem();
 
     // 3 gadget vertices + 1 clause vertex = 4
@@ -126,7 +130,8 @@ fn test_multiple_literals_same_variable() {
 #[test]
 fn test_accessors() {
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1, -2])]);
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
 
     assert_eq!(reduction.num_literals(), 2);
     assert_eq!(reduction.num_clauses(), 1);
@@ -134,22 +139,53 @@ fn test_accessors() {
 
 #[test]
 fn test_extract_solution_too_many_selected() {
-    // Test that extract_solution handles invalid (non-minimal) dominating sets
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
 
-    // Select all 4 vertices (more than num_literals=1)
-    let ds_sol = vec![1, 1, 1, 1];
-    let sat_sol = reduction.extract_solution(&ds_sol);
-    // Should return default (all false)
-    assert_eq!(sat_sol, vec![0]);
+    let ds_sol = vec![true, true, false, false];
+    assert_eq!(
+        reduction.extract_solution(&ds_sol).unwrap_err().to_string(),
+        "target dominating set does not certify satisfiability"
+    );
+}
+
+#[test]
+fn test_extract_solution_rejects_unselected_variable_gadget() {
+    let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
+
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![false, false, false, false])
+            .unwrap_err()
+            .to_string(),
+        "target dominating set does not certify satisfiability"
+    );
+}
+
+#[test]
+fn test_extract_solution_rejects_selected_clause_vertex() {
+    let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
+
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![true, false, false, true])
+            .unwrap_err()
+            .to_string(),
+        "target dominating set does not certify satisfiability"
+    );
 }
 
 #[test]
 fn test_negated_variable_connection() {
     // (NOT x1 OR NOT x2) - both negated
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![-1, -2])]);
-    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&sat);
+    let reduction = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&sat)
+        .expect("reduction should succeed");
     let ds_problem = reduction.target_problem();
 
     // 2 * 3 = 6 gadget vertices + 1 clause = 7
@@ -197,19 +233,21 @@ fn test_jl_parity_sat_to_dominatingset() {
         let inst = &jl_find_instance_by_label(&sat_data, label)["instance"];
         let (num_vars, clauses) = jl_parse_sat_clauses(inst);
         let source = Satisfiability::new(num_vars, clauses);
-        let result = ReduceTo::<MinimumDominatingSet<SimpleGraph, i32>>::reduce_to(&source);
+        let result = ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&source)
+            .expect("reduction should succeed");
         let solver = BruteForce::new();
-        let sat_solutions: HashSet<Vec<usize>> =
-            solver.find_all_witnesses(&source).into_iter().collect();
+        let sat_solutions: HashSet<Vec<bool>> = solver
+            .find_all_witnesses(&source)
+            .unwrap()
+            .into_iter()
+            .collect();
         for case in data["cases"].as_array().unwrap() {
             if sat_solutions.is_empty() {
-                let target_solution = solve_optimization_problem(result.target_problem())
+                let target_solution = BruteForce::new()
+                    .solve(result.target_problem())
+                    .unwrap()
                     .expect("SAT->DS: target should have an optimal solution");
-                let extracted = result.extract_solution(&target_solution);
-                assert!(
-                    !source.evaluate(&extracted),
-                    "SAT->DS [{label}]: unsatisfiable but extracted satisfies"
-                );
+                assert!(result.extract_solution(&target_solution).is_err());
             } else {
                 assert_satisfaction_round_trip_from_optimization_target(
                     &source,
@@ -218,10 +256,96 @@ fn test_jl_parity_sat_to_dominatingset() {
                 );
                 assert_eq!(
                     sat_solutions,
-                    jl_parse_configs_set(&case["best_source"]),
+                    jl_parse_bool_configs_set(&case["best_source"]),
                     "SAT->DS [{label}]: best source mismatch"
                 );
             }
         }
     }
 }
+
+#[test]
+fn test_sat_to_dominatingset_native_certificates() {
+    use crate::traits::Problem;
+    for (n, clauses) in [
+        (0, vec![]),
+        (0, vec![vec![]]),
+        (1, vec![vec![1]]),
+        (1, vec![vec![1], vec![-1]]),
+        (2, vec![vec![2, -2, 2]]),
+        (2, vec![vec![1, 2]]),
+        (3, vec![vec![1, 3], vec![-1, -3]]),
+        (3, vec![vec![1], vec![]]),
+    ] {
+        let source = Satisfiability::new(n, clauses.into_iter().map(CNFClause::new).collect());
+        let result =
+            ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+        let target = result.target_problem();
+        assert!(std::ptr::eq(
+            target,
+            crate::rules::AggregateReductionResult::target_problem(&result)
+        ));
+        let mut accepted = false;
+        for mask in 0..(1usize << target.num_vertices()) {
+            let config: Vec<_> = (0..target.num_vertices())
+                .map(|i| mask & (1 << i) != 0)
+                .collect();
+            let value = target.evaluate(&config).unwrap();
+            let certificate = value == Min(Some(result.target_size));
+            assert_eq!(
+                crate::rules::AggregateReductionResult::extract_value(&result, value),
+                Or(certificate)
+            );
+            match result.extract_solution(&config) {
+                Ok(x) => {
+                    assert!(certificate);
+                    assert_eq!(source.evaluate(&x).unwrap(), Or(true));
+                    accepted = true;
+                }
+                Err(_) => assert!(!certificate),
+            }
+        }
+        assert_eq!(
+            accepted,
+            BruteForce::new().solve(&source).unwrap().is_some()
+        );
+        assert!(result
+            .extract_solution(&vec![false; target.num_vertices() + 1])
+            .is_err());
+    }
+}
+
+#[test]
+fn test_sat_to_dominatingset_sparse_declared_variables() {
+    for clauses in [vec![], vec![CNFClause::new(vec![i64::MAX])]] {
+        let source = Satisfiability::new(i64::MAX as usize, clauses);
+        let result =
+            ReduceTo::<MinimumDominatingSet<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+        assert_eq!(result.num_literals(), i64::MAX as usize);
+        assert!(result.target_problem().num_vertices() <= 4);
+        // Construction is compact. Extracting an i64::MAX-length source vector
+        // is intentionally not attempted in a unit test.
+    }
+}
+
+#[test]
+fn test_sat_to_dominatingset_dimension_boundaries() {
+    assert_eq!(ReductionSATToDS::target_dimensions(0, 0).unwrap(), (0, 0));
+    assert_eq!(ReductionSATToDS::target_dimensions(2, 3).unwrap(), (9, 2));
+    assert!(ReductionSATToDS::target_dimensions(usize::MAX, 0).is_err());
+    assert!(ReductionSATToDS::target_dimensions(1, usize::MAX).is_err());
+    if usize::BITS == 64 {
+        let maximum = i64::MAX as usize;
+        assert_eq!(
+            ReductionSATToDS::target_dimensions(0, maximum).unwrap(),
+            (maximum, 0)
+        );
+        assert!(ReductionSATToDS::target_dimensions(0, maximum + 1).is_err());
+        let variables = maximum / 3;
+        assert_eq!(
+            ReductionSATToDS::target_dimensions(variables, maximum % 3).unwrap(),
+            (maximum, variables as i64)
+        );
+        assert!(ReductionSATToDS::target_dimensions(variables, maximum % 3 + 1).is_err());
+    }
+}
diff --git a/src/unit_tests/rules/satisfiability_integralflowhomologousarcs.rs b/src/unit_tests/rules/satisfiability_integralflowhomologousarcs.rs
index ccbbe362c..28a7a9df2 100644
--- a/src/unit_tests/rules/satisfiability_integralflowhomologousarcs.rs
+++ b/src/unit_tests/rules/satisfiability_integralflowhomologousarcs.rs
@@ -21,20 +21,17 @@ fn issue_example() -> Satisfiability {
     )
 }
 
-fn all_assignments(num_vars: usize) -> Vec<Vec<usize>> {
+fn all_assignments(num_vars: usize) -> Vec<Vec<bool>> {
     (0..(1usize << num_vars))
-        .map(|mask| {
-            (0..num_vars)
-                .map(|bit| usize::from(((mask >> bit) & 1) == 1))
-                .collect()
-        })
+        .map(|mask| (0..num_vars).map(|bit| ((mask >> bit) & 1) == 1).collect())
         .collect()
 }
 
 #[test]
 fn test_satisfiability_to_integralflowhomologousarcs_closed_loop() {
     let source = Satisfiability::new(1, vec![CNFClause::new(vec![1])]);
-    let reduction = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source);
+    let reduction = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -46,7 +43,8 @@ fn test_satisfiability_to_integralflowhomologousarcs_closed_loop() {
 #[test]
 fn test_satisfiability_to_integralflowhomologousarcs_issue_example_structure() {
     let source = issue_example();
-    let reduction = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source);
+    let reduction = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vertices(), 43);
@@ -59,33 +57,35 @@ fn test_satisfiability_to_integralflowhomologousarcs_issue_example_structure() {
 #[test]
 fn test_satisfiability_to_integralflowhomologousarcs_issue_example_assignment_encoding() {
     let source = issue_example();
-    let reduction = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source);
+    let reduction = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    let satisfying_assignment = vec![1, 0, 1];
+    let satisfying_assignment = vec![true, false, true];
     let satisfying_flow = reduction.encode_assignment(&satisfying_assignment);
-    assert!(target.evaluate(&satisfying_flow).0);
+    assert!(target.evaluate(&satisfying_flow).unwrap().0);
     assert_eq!(
-        reduction.extract_solution(&satisfying_flow),
+        reduction.extract_solution(&satisfying_flow).unwrap(),
         satisfying_assignment
     );
 
-    let unsatisfying_assignment = vec![1, 1, 1];
+    let unsatisfying_assignment = vec![true, true, true];
     let unsatisfying_flow = reduction.encode_assignment(&unsatisfying_assignment);
-    assert!(!target.evaluate(&unsatisfying_flow).0);
+    assert!(!target.evaluate(&unsatisfying_flow).unwrap().0);
 }
 
 #[test]
 fn test_satisfiability_to_integralflowhomologousarcs_issue_example_truth_table_matches_flow() {
     let source = issue_example();
-    let reduction = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source);
+    let reduction = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     for assignment in all_assignments(source.num_vars()) {
         let flow = reduction.encode_assignment(&assignment);
         assert_eq!(
-            source.evaluate(&assignment).0,
-            target.evaluate(&flow).0,
+            source.evaluate(&assignment).unwrap().0,
+            target.evaluate(&flow).unwrap().0,
             "assignment {:?} should preserve satisfiability through the encoded flow",
             assignment
         );
@@ -95,10 +95,11 @@ fn test_satisfiability_to_integralflowhomologousarcs_issue_example_truth_table_m
 #[test]
 fn test_satisfiability_to_integralflowhomologousarcs_unsat_source_has_no_target_witness() {
     let source = Satisfiability::new(1, vec![CNFClause::new(vec![1]), CNFClause::new(vec![-1])]);
-    let reduction = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source);
+    let reduction = ReduceTo::<IntegralFlowHomologousArcs>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_eq!(
-        BruteForce::new().find_witness(reduction.target_problem()),
+        BruteForce::new().solve(reduction.target_problem()).unwrap(),
         None
     );
 }
@@ -129,7 +130,10 @@ fn test_satisfiability_to_integralflowhomologousarcs_canonical_example_spec() {
         8
     );
     assert_eq!(example.solutions.len(), 1);
-    assert_eq!(example.solutions[0].source_config, vec![1, 0, 1]);
+    assert_eq!(
+        example.solutions[0].source_config,
+        serde_json::json!([true, false, true])
+    );
 
     let source: Satisfiability = serde_json::from_value(example.source.instance.clone())
         .expect("source example deserializes");
@@ -137,10 +141,10 @@ fn test_satisfiability_to_integralflowhomologousarcs_canonical_example_spec() {
         serde_json::from_value(example.target.instance.clone())
             .expect("target example deserializes");
 
-    assert!(source
-        .evaluate(&example.solutions[0].source_config)
-        .is_valid());
-    assert!(target
-        .evaluate(&example.solutions[0].target_config)
-        .is_valid());
+    let source_config: Vec<bool> =
+        serde_json::from_value(example.solutions[0].source_config.clone()).unwrap();
+    let target_config: Vec<usize> =
+        serde_json::from_value(example.solutions[0].target_config.clone()).unwrap();
+    assert!(source.evaluate(&source_config).unwrap().is_valid());
+    assert!(target.evaluate(&target_config).unwrap().is_valid());
 }
diff --git a/src/unit_tests/rules/satisfiability_maximum2satisfiability.rs b/src/unit_tests/rules/satisfiability_maximum2satisfiability.rs
index 502874a6a..3db2ebc6d 100644
--- a/src/unit_tests/rules/satisfiability_maximum2satisfiability.rs
+++ b/src/unit_tests/rules/satisfiability_maximum2satisfiability.rs
@@ -1,10 +1,8 @@
 use super::*;
 use crate::models::formula::{CNFClause, Maximum2Satisfiability, Satisfiability};
-use crate::rules::test_helpers::{
-    assert_satisfaction_round_trip_from_optimization_target, solve_optimization_problem,
-};
+use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
 use crate::rules::traits::ReduceTo;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
 #[test]
@@ -14,9 +12,13 @@ fn test_satisfiability_to_maximum2satisfiability_structure() {
         vec![CNFClause::new(vec![1, -2, 3]), CNFClause::new(vec![-1, 2])],
     );
 
-    let reduction = ReduceTo::<Maximum2Satisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<Maximum2Satisfiability>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
+    let aggregate_target = crate::rules::AggregateReductionResult::target_problem(&reduction);
+    assert!(std::ptr::eq(target, aggregate_target));
+    assert_eq!(aggregate_target.num_clauses(), 30);
     assert_eq!(target.num_vars(), 7);
     assert_eq!(target.num_clauses(), 30);
     assert_eq!(target.clauses()[0].literals, vec![1, 1]);
@@ -32,7 +34,8 @@ fn test_satisfiability_to_maximum2satisfiability_closed_loop() {
         vec![CNFClause::new(vec![1, -2, 3]), CNFClause::new(vec![-1, 2])],
     );
 
-    let reduction = ReduceTo::<Maximum2Satisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<Maximum2Satisfiability>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_satisfaction_round_trip_from_optimization_target(
@@ -41,32 +44,135 @@ fn test_satisfiability_to_maximum2satisfiability_closed_loop() {
         "SAT -> Maximum2Satisfiability closed loop",
     );
 
-    assert_eq!(BruteForce::new().solve(target).0, Some(21));
+    assert_eq!(
+        target
+            .evaluate(&BruteForce::new().solve(target).unwrap().unwrap())
+            .unwrap()
+            .0,
+        Some(21)
+    );
 }
 
 #[test]
 fn test_satisfiability_to_maximum2satisfiability_unsatisfiable_gap() {
     let source = Satisfiability::new(1, vec![CNFClause::new(vec![1]), CNFClause::new(vec![-1])]);
 
-    let reduction = ReduceTo::<Maximum2Satisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<Maximum2Satisfiability>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
-    assert_eq!(BruteForce::new().solve(target).0, Some(55));
+    assert_eq!(
+        target
+            .evaluate(&BruteForce::new().solve(target).unwrap().unwrap())
+            .unwrap()
+            .0,
+        Some(55)
+    );
 
-    let target_solution =
-        solve_optimization_problem(target).expect("MAX-2-SAT target should always have a witness");
-    let extracted = reduction.extract_solution(&target_solution);
-    assert!(!source.evaluate(&extracted).0);
+    let target_solution = BruteForce::new()
+        .solve(target)
+        .unwrap()
+        .expect("MAX-2-SAT target should always have a witness");
+    assert!(reduction.extract_solution(&target_solution).is_err());
+    assert_eq!(
+        crate::rules::AggregateReductionResult::extract_value(&reduction, Max(Some(55))),
+        Or(false)
+    );
 }
 
 #[test]
 fn test_satisfiability_to_maximum2satisfiability_empty_clause() {
     let source = Satisfiability::new(1, vec![CNFClause::new(vec![])]);
 
-    let reduction = ReduceTo::<Maximum2Satisfiability>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<Maximum2Satisfiability>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vars(), 4);
     assert_eq!(target.num_clauses(), 20);
-    assert_eq!(BruteForce::new().solve(target).0, Some(13));
+    assert_eq!(
+        target
+            .evaluate(&BruteForce::new().solve(target).unwrap().unwrap())
+            .unwrap()
+            .0,
+        Some(13)
+    );
+}
+
+#[test]
+fn test_satisfiability_to_maximum2satisfiability_all_gadget_assignments() {
+    let mut clauses = Vec::new();
+    add_gjs_gadget(&CNFClause::new(vec![1, 2, 3]), 4, &mut clauses);
+    let target = Maximum2Satisfiability::try_new(4, clauses).unwrap();
+    for abc in 0..8 {
+        let mut best = 0;
+        for w in [false, true] {
+            let assignment = vec![abc & 1 != 0, abc & 2 != 0, abc & 4 != 0, w];
+            let score = target.evaluate(&assignment).unwrap().0.unwrap();
+            assert!(score <= 7);
+            if score == 7 {
+                assert!(assignment[..3].iter().any(|&v| v));
+            }
+            best = best.max(score);
+        }
+        assert_eq!(best, if abc == 0 { 6 } else { 7 });
+    }
+}
+
+#[test]
+fn test_satisfiability_to_maximum2satisfiability_every_target_witness() {
+    let mut sources = vec![
+        Satisfiability::new(0, vec![]),
+        Satisfiability::new(0, vec![CNFClause::new(vec![])]),
+    ];
+    for n in 1..=3 {
+        for len in 0..=5 {
+            for pattern in 0..3 {
+                let literals = (0..len)
+                    .map(|i| {
+                        let variable = (i % n + 1) as i64;
+                        if (i + pattern) % 3 == 0 {
+                            -variable
+                        } else {
+                            variable
+                        }
+                    })
+                    .collect();
+                sources.push(Satisfiability::new(n, vec![CNFClause::new(literals)]));
+            }
+        }
+    }
+    for source in sources {
+        let reduction = ReduceTo::<Maximum2Satisfiability>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        let threshold = (target.num_clauses() / 10 * 7) as i64;
+        let mut best = 0;
+        for bits in 0usize..(1 << target.num_vars()) {
+            let assignment = (0..target.num_vars())
+                .map(|i| bits & (1 << i) != 0)
+                .collect();
+            let value = target.evaluate(&assignment).unwrap();
+            best = best.max(value.0.unwrap());
+            let expected = value == Max(Some(threshold));
+            assert_eq!(
+                crate::rules::AggregateReductionResult::extract_value(&reduction, value),
+                Or(expected)
+            );
+            if expected {
+                let decoded = reduction.extract_solution(&assignment).unwrap();
+                assert!(source.evaluate(&decoded).unwrap().0);
+            } else {
+                assert!(reduction.extract_solution(&assignment).is_err());
+            }
+        }
+        let source_yes = BruteForce::new().solve(&source).unwrap().is_some();
+        assert_eq!(best == threshold, source_yes);
+        assert!(reduction
+            .extract_solution(&vec![false; target.num_vars() + 1])
+            .is_err());
+        assert_eq!(
+            crate::rules::AggregateReductionResult::extract_value(&reduction, Max(None)),
+            Or(false)
+        );
+    }
 }
diff --git a/src/unit_tests/rules/satisfiability_naesatisfiability.rs b/src/unit_tests/rules/satisfiability_naesatisfiability.rs
index fbe452648..e1ee71120 100644
--- a/src/unit_tests/rules/satisfiability_naesatisfiability.rs
+++ b/src/unit_tests/rules/satisfiability_naesatisfiability.rs
@@ -15,7 +15,8 @@ fn test_satisfiability_to_naesatisfiability_closed_loop() {
         ],
     );
 
-    let reduction = ReduceTo::<NAESatisfiability>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &sat,
@@ -35,7 +36,8 @@ fn test_reduction_structure() {
         ],
     );
 
-    let reduction = ReduceTo::<NAESatisfiability>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
     let naesat = reduction.target_problem();
 
     // Should have n+1 variables (3 original + 1 sentinel)
@@ -61,11 +63,42 @@ fn test_solution_extraction_sentinel_false() {
     // When sentinel is false, return original variables as-is
     let sat = Satisfiability::new(3, vec![CNFClause::new(vec![1, 2])]);
 
-    let reduction = ReduceTo::<NAESatisfiability>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
 
     // target_solution: [1, 0, 1, 0] means x1=true, x2=false, x3=true, sentinel=false
-    let extracted = reduction.extract_solution(&[1, 0, 1, 0]);
-    assert_eq!(extracted, vec![1, 0, 1]);
+    let extracted = reduction
+        .extract_solution(&vec![true, false, true, false])
+        .unwrap();
+    assert_eq!(extracted, vec![true, false, true]);
+}
+
+#[test]
+fn test_solution_extraction_distinguishes_zero_assignment_from_malformed_input() {
+    let sat = Satisfiability::new(2, vec![CNFClause::new(vec![-1, -2])]);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
+
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![false, false, false])
+            .unwrap(),
+        vec![false, false]
+    );
+
+    let error = reduction.extract_solution(&vec![false, false]).unwrap_err();
+    assert_eq!(
+        error.to_string(),
+        "target evaluation failed during extraction: invalid configuration: assignment length does not match the formula variables"
+    );
+    assert!(reduction
+        .extract_solution(&vec![false, false, false, false])
+        .is_err());
+    assert!(crate::rules::DynReductionResult::target_solution_from_json(
+        &reduction,
+        serde_json::json!([false, 2, false])
+    )
+    .is_err());
 }
 
 #[test]
@@ -73,12 +106,15 @@ fn test_solution_extraction_sentinel_true() {
     // When sentinel is true, return complement of original variables
     let sat = Satisfiability::new(3, vec![CNFClause::new(vec![1, 2])]);
 
-    let reduction = ReduceTo::<NAESatisfiability>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
 
     // target_solution: [0, 1, 0, 1] means x1=false, x2=true, x3=false, sentinel=true
     // Complement: x1=true, x2=false, x3=true
-    let extracted = reduction.extract_solution(&[0, 1, 0, 1]);
-    assert_eq!(extracted, vec![1, 0, 1]);
+    let extracted = reduction
+        .extract_solution(&vec![false, true, false, true])
+        .unwrap();
+    assert_eq!(extracted, vec![true, false, true]);
 }
 
 #[test]
@@ -86,12 +122,13 @@ fn test_unsatisfiable_formula() {
     // (x1) ∧ (¬x1) is unsatisfiable
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![1]), CNFClause::new(vec![-1])]);
 
-    let reduction = ReduceTo::<NAESatisfiability>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
     let naesat = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let sat_solutions = solver.find_all_witnesses(&sat);
-    let naesat_solutions = solver.find_all_witnesses(naesat);
+    let sat_solutions = solver.find_all_witnesses(&sat).unwrap();
+    let naesat_solutions = solver.find_all_witnesses(naesat).unwrap();
 
     // Both should be unsatisfiable
     assert!(sat_solutions.is_empty());
@@ -102,7 +139,8 @@ fn test_unsatisfiable_formula() {
 fn test_single_clause() {
     let sat = Satisfiability::new(2, vec![CNFClause::new(vec![1, -2])]);
 
-    let reduction = ReduceTo::<NAESatisfiability>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &sat,
@@ -116,7 +154,8 @@ fn test_empty_formula() {
     // Empty formula is trivially satisfiable
     let sat = Satisfiability::new(2, vec![]);
 
-    let reduction = ReduceTo::<NAESatisfiability>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
     let naesat = reduction.target_problem();
 
     assert_eq!(naesat.num_vars(), 3);
@@ -124,8 +163,8 @@ fn test_empty_formula() {
 
     // Both should be satisfiable (any assignment works)
     let solver = BruteForce::new();
-    assert!(!solver.find_all_witnesses(&sat).is_empty());
-    assert!(!solver.find_all_witnesses(naesat).is_empty());
+    assert!(!solver.find_all_witnesses(&sat).unwrap().is_empty());
+    assert!(!solver.find_all_witnesses(naesat).unwrap().is_empty());
 }
 
 #[test]
@@ -142,7 +181,8 @@ fn test_larger_instance() {
         ],
     );
 
-    let reduction = ReduceTo::<NAESatisfiability>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
     let naesat = reduction.target_problem();
 
     assert_eq!(naesat.num_vars(), 6);
@@ -163,17 +203,18 @@ fn test_all_satisfying_assignments_map_back() {
         vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1, -2])],
     );
 
-    let reduction = ReduceTo::<NAESatisfiability>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
     let naesat = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let nae_solutions = solver.find_all_witnesses(naesat);
+    let nae_solutions = solver.find_all_witnesses(naesat).unwrap();
 
     for nae_sol in &nae_solutions {
-        let sat_sol = reduction.extract_solution(nae_sol);
+        let sat_sol = reduction.extract_solution(nae_sol).unwrap();
         assert_eq!(sat_sol.len(), 2);
         assert!(
-            sat.evaluate(&sat_sol).0,
+            sat.evaluate(&sat_sol).unwrap().0,
             "Extracted solution {:?} from NAE solution {:?} does not satisfy SAT",
             sat_sol,
             nae_sol
@@ -184,7 +225,8 @@ fn test_all_satisfying_assignments_map_back() {
 #[test]
 fn test_empty_clause_maps_to_unsatisfiable_nae_clause() {
     let sat = Satisfiability::new(1, vec![CNFClause::new(vec![])]);
-    let reduction = ReduceTo::<NAESatisfiability>::reduce_to(&sat);
+    let reduction =
+        ReduceTo::<NAESatisfiability>::reduce_to(&sat).expect("reduction should succeed");
     let naesat = reduction.target_problem();
 
     assert_eq!(naesat.num_vars(), 2);
@@ -193,6 +235,6 @@ fn test_empty_clause_maps_to_unsatisfiable_nae_clause() {
     assert_eq!(naesat.clauses()[0].literals, vec![2, 2]);
 
     let solver = BruteForce::new();
-    assert!(solver.find_witness(&sat).is_none());
-    assert!(solver.find_witness(naesat).is_none());
+    assert!(solver.solve(&sat).unwrap().is_none());
+    assert!(solver.solve(naesat).unwrap().is_none());
 }
diff --git a/src/unit_tests/rules/satisfiability_nontautology.rs b/src/unit_tests/rules/satisfiability_nontautology.rs
index e7a2101e1..ab9608124 100644
--- a/src/unit_tests/rules/satisfiability_nontautology.rs
+++ b/src/unit_tests/rules/satisfiability_nontautology.rs
@@ -10,7 +10,7 @@ fn test_satisfiability_to_non_tautology_structure() {
         vec![CNFClause::new(vec![1, -2]), CNFClause::new(vec![-1, 3])],
     );
 
-    let reduction = ReduceTo::<NonTautology>::reduce_to(&source);
+    let reduction = ReduceTo::<NonTautology>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_vars(), 3);
@@ -29,7 +29,7 @@ fn test_satisfiability_to_non_tautology_closed_loop() {
         ],
     );
 
-    let reduction = ReduceTo::<NonTautology>::reduce_to(&source);
+    let reduction = ReduceTo::<NonTautology>::reduce_to(&source).expect("reduction should succeed");
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
         &reduction,
@@ -41,23 +41,24 @@ fn test_satisfiability_to_non_tautology_closed_loop() {
 fn test_satisfiability_to_non_tautology_unsatisfiable_source_has_no_target_witness() {
     let source = Satisfiability::new(1, vec![CNFClause::new(vec![1]), CNFClause::new(vec![-1])]);
 
-    let reduction = ReduceTo::<NonTautology>::reduce_to(&source);
+    let reduction = ReduceTo::<NonTautology>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
 
-    assert_eq!(solver.find_witness(reduction.target_problem()), None);
+    assert_eq!(solver.solve(reduction.target_problem()).unwrap(), None);
 }
 
 #[test]
 fn test_satisfiability_to_non_tautology_extract_solution_is_identity() {
     let source = Satisfiability::new(2, vec![CNFClause::new(vec![1]), CNFClause::new(vec![2])]);
 
-    let reduction = ReduceTo::<NonTautology>::reduce_to(&source);
+    let reduction = ReduceTo::<NonTautology>::reduce_to(&source).expect("reduction should succeed");
     let target_solution = BruteForce::new()
-        .find_witness(reduction.target_problem())
+        .solve(reduction.target_problem())
+        .unwrap()
         .expect("target should have a witness");
 
     assert_eq!(
-        reduction.extract_solution(&target_solution),
+        reduction.extract_solution(&target_solution).unwrap(),
         target_solution
     );
 }
diff --git a/src/unit_tests/rules/schedulingtominimizeweightedcompletiontime_ilp.rs b/src/unit_tests/rules/schedulingtominimizeweightedcompletiontime_ilp.rs
index b33d2dbf7..eaab98e84 100644
--- a/src/unit_tests/rules/schedulingtominimizeweightedcompletiontime_ilp.rs
+++ b/src/unit_tests/rules/schedulingtominimizeweightedcompletiontime_ilp.rs
@@ -9,38 +9,40 @@ use crate::types::Min;
 fn test_reduction_creates_valid_ilp_structure() {
     // 3 tasks, 2 processors
     let problem = SchedulingToMinimizeWeightedCompletionTime::new(vec![1, 2, 3], vec![4, 2, 1], 2);
-    let reduction: ReductionSMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=3, m=2: x vars = 3*2=6, C vars = 3, y vars = 3*2/2=3, total=12
-    assert_eq!(ilp.num_vars, 12);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 12);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
     // Objective should reference C_t variables with weights
     // C vars are at indices 6, 7, 8
     assert!(ilp
-        .objective
+        .objective()
         .iter()
-        .any(|&(idx, coeff)| idx == 6 && coeff == 4.0));
+        .any(|&(idx, coeff)| idx == 6 && coeff == 4));
     assert!(ilp
-        .objective
+        .objective()
         .iter()
-        .any(|&(idx, coeff)| idx == 7 && coeff == 2.0));
+        .any(|&(idx, coeff)| idx == 7 && coeff == 2));
     assert!(ilp
-        .objective
+        .objective()
         .iter()
-        .any(|&(idx, coeff)| idx == 8 && coeff == 1.0));
+        .any(|&(idx, coeff)| idx == 8 && coeff == 1));
 }
 
 #[test]
 fn test_solution_extraction() {
     let problem = SchedulingToMinimizeWeightedCompletionTime::new(vec![1, 2], vec![3, 1], 2);
-    let reduction: ReductionSMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Build a manual ILP solution:
     // x_{0,0}=1, x_{0,1}=0, x_{1,0}=0, x_{1,1}=1 => task 0 on P0, task 1 on P1
     // C_0=1, C_1=2, y_{0,1}=1
-    let num_vars = reduction.target_problem().num_vars;
+    let num_vars = reduction.target_problem().num_vars();
     let mut sol = vec![0; num_vars];
     // x vars: indices 0..4
     sol[0] = 1; // x_{0,0} = 1
@@ -53,10 +55,10 @@ fn test_solution_extraction() {
                 // y vars: index 6
     sol[6] = 1; // y_{0,1} = 1
 
-    let extracted = reduction.extract_solution(&sol);
+    let extracted = reduction.extract_solution(&sol).unwrap();
     assert_eq!(extracted, vec![0, 1]);
     // Each on separate processor: C(0)=1, C(1)=2, WCT = 1*3 + 2*1 = 5
-    assert_eq!(problem.evaluate(&extracted), Min(Some(5)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(5)));
 }
 
 #[test]
@@ -66,15 +68,17 @@ fn test_ilp_matches_bruteforce_small() {
 
     let bf = BruteForce::new();
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("BF should find a solution");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
 
-    let reduction: ReductionSMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(ilp_value, bf_value);
 }
@@ -88,23 +92,25 @@ fn test_issue_example_closed_loop() {
         2,
     );
 
-    let reduction: ReductionSMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&extracted), Min(Some(47)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(47)));
 }
 
 #[test]
 fn test_single_task_single_processor() {
     let problem = SchedulingToMinimizeWeightedCompletionTime::new(vec![5], vec![3], 1);
-    let reduction: ReductionSMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(15)));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(15)));
 }
 
 #[test]
@@ -115,15 +121,17 @@ fn test_equal_tasks_multiple_processors() {
 
     let bf = BruteForce::new();
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("BF should find a solution");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
 
-    let reduction: ReductionSMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(ilp_value, bf_value);
 }
diff --git a/src/unit_tests/rules/schedulingwithindividualdeadlines_ilp.rs b/src/unit_tests/rules/schedulingwithindividualdeadlines_ilp.rs
index 569da137e..8838a3843 100644
--- a/src/unit_tests/rules/schedulingwithindividualdeadlines_ilp.rs
+++ b/src/unit_tests/rules/schedulingwithindividualdeadlines_ilp.rs
@@ -16,16 +16,43 @@ fn infeasible_instance() -> SchedulingWithIndividualDeadlines {
 #[test]
 fn test_schedulingwithindividualdeadlines_to_ilp_structure() {
     let problem = feasible_instance();
-    let reduction: ReductionSWIDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSWIDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=3, max_deadline=3 → 9 variables
-    assert_eq!(ilp.num_vars, 9);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 9);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(ilp.objective().is_empty());
 
-    // 3 one-hot + 3 capacity + 1 precedence = 7 constraints
-    assert_eq!(ilp.constraints.len(), 7);
+    // 3 one-hot + 1 unused-slot + 3 capacity + 1 precedence = 8 constraints
+    assert_eq!(ilp.constraints().len(), 8);
+}
+
+#[test]
+fn test_schedulingwithindividualdeadlines_to_ilp_fixes_unused_slots() {
+    let problem = SchedulingWithIndividualDeadlines::new(2, 2, vec![1, 2], vec![]);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+    assert!(!reduction
+        .target_problem()
+        .evaluate(&vec![1, 1, 1, 0])
+        .unwrap()
+        .is_valid());
+    let witnesses: Vec<Vec<i64>> = (0..16)
+        .map(|bits| (0..4).map(|bit| i64::from((bits >> bit) & 1)).collect())
+        .filter(|witness| {
+            reduction
+                .target_problem()
+                .evaluate(witness)
+                .unwrap()
+                .is_valid()
+        })
+        .collect();
+    assert_eq!(witnesses.len(), 2);
+    for witness in witnesses {
+        let source_solution = reduction.extract_solution(&witness).unwrap();
+        assert!(problem.evaluate(&source_solution).unwrap());
+    }
 }
 
 #[test]
@@ -33,21 +60,23 @@ fn test_schedulingwithindividualdeadlines_to_ilp_closed_loop() {
     let problem = feasible_instance();
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("feasible instance has a witness");
     assert!(
-        problem.evaluate(&bf_solution).0,
+        problem.evaluate(&bf_solution).unwrap().0,
         "brute force solution is valid"
     );
 
-    let reduction: ReductionSWIDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSWIDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "ILP extracted solution should be a valid schedule"
     );
 }
@@ -55,9 +84,10 @@ fn test_schedulingwithindividualdeadlines_to_ilp_closed_loop() {
 #[test]
 fn test_schedulingwithindividualdeadlines_to_ilp_infeasible() {
     let problem = infeasible_instance();
-    let reduction: ReductionSWIDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSWIDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible instance should yield infeasible ILP"
     );
 }
@@ -65,16 +95,17 @@ fn test_schedulingwithindividualdeadlines_to_ilp_infeasible() {
 #[test]
 fn test_schedulingwithindividualdeadlines_to_ilp_extract_solution() {
     let problem = feasible_instance();
-    let reduction: ReductionSWIDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSWIDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // task 0 at slot 0, task 1 at slot 0, task 2 at slot 1
     // max_deadline=3: x_{j,t} at j*3+t
     // x_{0,0}=1, x_{0,1}=0, x_{0,2}=0, x_{1,0}=1, x_{1,1}=0, x_{1,2}=0, x_{2,0}=0, x_{2,1}=1, x_{2,2}=0
     let ilp_solution = vec![1, 0, 0, 1, 0, 0, 0, 1, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 0, 1]);
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "manually constructed solution is valid"
     );
 }
@@ -82,6 +113,7 @@ fn test_schedulingwithindividualdeadlines_to_ilp_extract_solution() {
 #[test]
 fn test_schedulingwithindividualdeadlines_to_ilp_bf_vs_ilp() {
     let problem = feasible_instance();
-    let reduction: ReductionSWIDToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSWIDToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/sequencingtominimizemaximumcumulativecost_ilp.rs b/src/unit_tests/rules/sequencingtominimizemaximumcumulativecost_ilp.rs
index cd04dcf49..617788d35 100644
--- a/src/unit_tests/rules/sequencingtominimizemaximumcumulativecost_ilp.rs
+++ b/src/unit_tests/rules/sequencingtominimizemaximumcumulativecost_ilp.rs
@@ -7,19 +7,19 @@ use crate::traits::Problem;
 #[test]
 fn test_sequencingtominimizemaximumcumulativecost_to_ilp_closed_loop() {
     let problem = SequencingToMinimizeMaximumCumulativeCost::new(vec![2, -1, 3, -2], vec![(0, 2)]);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Brute-force the source to get the optimal value
     let bf = BruteForce::new();
-    let bf_solution = bf.find_witness(&problem).expect("brute-force optimum");
-    let bf_value = problem.evaluate(&bf_solution);
+    let bf_solution = bf.solve(&problem).unwrap().expect("brute-force optimum");
+    let bf_value = problem.evaluate(&bf_solution).unwrap();
 
     // Solve the ILP target with the ILP solver
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert!(
         ilp_value.0.is_some(),
@@ -34,27 +34,28 @@ fn test_sequencingtominimizemaximumcumulativecost_to_ilp_closed_loop() {
 #[test]
 fn test_sequencingtominimizemaximumcumulativecost_to_ilp_bf_vs_ilp() {
     let problem = SequencingToMinimizeMaximumCumulativeCost::new(vec![2, -1, 3, -2], vec![(0, 2)]);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf_witness = BruteForce::new()
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should be feasible");
-    assert!(problem.evaluate(&bf_witness).0.is_some());
+    assert!(problem.evaluate(&bf_witness).unwrap().0.is_some());
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted).0.is_some());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap().0.is_some());
 }
 
 #[test]
 fn test_sequencingtominimizemaximumcumulativecost_to_ilp_no_precedences() {
     let problem = SequencingToMinimizeMaximumCumulativeCost::new(vec![3, -2, 1], vec![]);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted).0.is_some());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap().0.is_some());
 }
diff --git a/src/unit_tests/rules/sequencingtominimizetardytaskweight_ilp.rs b/src/unit_tests/rules/sequencingtominimizetardytaskweight_ilp.rs
index 71199ad2e..baac86613 100644
--- a/src/unit_tests/rules/sequencingtominimizetardytaskweight_ilp.rs
+++ b/src/unit_tests/rules/sequencingtominimizetardytaskweight_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 
@@ -8,13 +8,9 @@ use crate::traits::Problem;
 fn test_sequencingtominimizetardytaskweight_to_ilp_closed_loop() {
     let problem =
         SequencingToMinimizeTardyTaskWeight::new(vec![3, 2, 1], vec![4, 2, 3], vec![4, 3, 6]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_optimization_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "SequencingToMinimizeTardyTaskWeight->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
@@ -26,15 +22,15 @@ fn test_sequencingtominimizetardytaskweight_to_ilp_bf_vs_ilp() {
     );
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should find a solution");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_witness = bf.solve(&problem).unwrap().expect("should find a solution");
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
 
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_value, ilp_value);
     assert_eq!(ilp_value.0, Some(3));
@@ -44,13 +40,13 @@ fn test_sequencingtominimizetardytaskweight_to_ilp_bf_vs_ilp() {
 fn test_sequencingtominimizetardytaskweight_to_ilp_all_on_time() {
     let problem =
         SequencingToMinimizeTardyTaskWeight::new(vec![1, 1, 1], vec![2, 3, 4], vec![10, 10, 10]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     assert!(value.is_valid());
     assert_eq!(value.0, Some(0));
 }
@@ -68,17 +64,154 @@ fn test_sequencingtominimizetardytaskweight_to_ilp_optimal_ordering() {
     // Minimum is 3 (schedule [0,1,2])
     let problem =
         SequencingToMinimizeTardyTaskWeight::new(vec![4, 1, 2], vec![5, 1, 3], vec![4, 5, 3]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should have solution");
-    let bf_value = problem.evaluate(&bf_witness);
+    let bf_witness = bf.solve(&problem).unwrap().expect("should have solution");
+    let bf_value = problem.evaluate(&bf_witness).unwrap();
 
     assert_eq!(ilp_value, bf_value);
 }
+
+#[test]
+fn test_tardy_ilp_signed_permutations_and_all_indicators() {
+    for n in 0u32..=3 {
+        for mut code in 0..4usize.pow(n) {
+            let lengths: Vec<i64> = (0..n)
+                .map(|_| {
+                    let length = [-2, -1, 1, 2][code % 4];
+                    code /= 4;
+                    length
+                })
+                .collect();
+            for pattern in 0..5 {
+                let weights = (0..n)
+                    .map(|j| if (j + pattern) % 2 == 0 { 3 } else { -2 })
+                    .collect();
+                let deadlines = (0..n)
+                    .map(|j| [-4, -1, 0, 2, 5][(j + pattern) as usize % 5])
+                    .collect();
+                let source =
+                    SequencingToMinimizeTardyTaskWeight::new(lengths.clone(), weights, deadlines);
+                let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+                let target = reduction.target_problem();
+                let count = n as usize;
+                assert_eq!(target.num_vars(), count * count + count);
+                assert_eq!(target.num_constraints(), 2 * count * count + 2 * count);
+                for mut encoded in 0..count.pow(n) {
+                    let schedule: Vec<usize> = (0..n)
+                        .map(|_| {
+                            let job = encoded % count;
+                            encoded /= count;
+                            job
+                        })
+                        .collect();
+                    let source_value = source.evaluate(&schedule).unwrap();
+                    if !source_value.is_valid() {
+                        continue;
+                    }
+                    let mut expected = vec![false; count];
+                    let mut elapsed = 0;
+                    for &job in &schedule {
+                        elapsed += source.lengths()[job];
+                        expected[job] = elapsed > source.deadlines()[job];
+                    }
+                    for mask in 0..1usize << n {
+                        let mut bits = vec![0; count * count + count];
+                        for (position, &job) in schedule.iter().enumerate() {
+                            bits[job * count + position] = 1;
+                        }
+                        for job in 0..count {
+                            bits[count * count + job] = i64::from(mask & (1 << job) != 0);
+                        }
+                        let exact =
+                            (0..count).all(|job| (bits[count * count + job] == 1) == expected[job]);
+                        let value = target.evaluate(&bits).unwrap();
+                        assert_eq!(value.is_valid(), exact);
+                        let extracted = reduction.extract_solution(&bits);
+                        assert_eq!(extracted.is_ok(), exact);
+                        if exact {
+                            assert_eq!(value.value, source_value.0);
+                            assert_eq!(extracted.unwrap(), schedule);
+                        }
+                    }
+                }
+                assert!(reduction
+                    .extract_solution(&vec![0; target.num_vars() + 1])
+                    .is_err());
+                if count > 0 {
+                    assert!(reduction
+                        .extract_solution(&vec![0; target.num_vars()])
+                        .is_err());
+                    assert!(reduction
+                        .extract_solution(&vec![2; target.num_vars()])
+                        .is_err());
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_tardy_ilp_complete_small_binary_target_space() {
+    let source =
+        SequencingToMinimizeTardyTaskWeight::new(vec![-2, 1, 3], vec![-3, 2, -1], vec![-1, 0, 2]);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    let target = reduction.target_problem();
+    let mut feasible = 0;
+    for mask in 0..1usize << target.num_vars() {
+        let bits = (0..target.num_vars())
+            .map(|i| i64::from(mask & (1 << i) != 0))
+            .collect();
+        let value = target.evaluate(&bits).unwrap();
+        let extracted = reduction.extract_solution(&bits);
+        assert_eq!(extracted.is_ok(), value.is_valid());
+        if let Ok(schedule) = extracted {
+            assert_eq!(source.evaluate(&schedule).unwrap().0, value.value);
+            feasible += 1;
+        }
+    }
+    assert_eq!(feasible, 6);
+}
+
+#[test]
+fn test_tardy_ilp_numeric_boundaries_and_representability_errors() {
+    for (length, weight, deadline) in [
+        (i64::MAX, i64::MAX, i64::MAX),
+        (i64::MIN, i64::MIN, i64::MIN),
+        (i64::MAX, i64::MIN, i64::MIN),
+        (i64::MIN, i64::MAX, i64::MAX),
+        (1, -1, 1),
+        (1, 1, -1),
+        (-1, 1, -2),
+    ] {
+        let source =
+            SequencingToMinimizeTardyTaskWeight::new(vec![length], vec![weight], vec![deadline]);
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+        let bits = vec![1, i64::from(length > deadline)];
+        assert_eq!(
+            reduction.target_problem().evaluate(&bits).unwrap().value,
+            source.evaluate(&vec![0]).unwrap().0
+        );
+        assert_eq!(reduction.extract_solution(&bits).unwrap(), vec![0]);
+    }
+    for (lengths, weights, deadlines) in [
+        (vec![i64::MAX, i64::MAX], vec![1, 1], vec![0, 0]),
+        (vec![i64::MIN, i64::MIN], vec![1, 1], vec![0, 0]),
+        (vec![1, 1], vec![i64::MAX, i64::MAX], vec![0, 0]),
+        (vec![1, 1], vec![i64::MIN, i64::MIN], vec![0, 0]),
+        (vec![1, i64::MAX - 1], vec![1, 1], vec![i64::MAX / 2; 2]),
+    ] {
+        let source = SequencingToMinimizeTardyTaskWeight::new(lengths, weights, deadlines);
+        assert!(matches!(
+            ReduceTo::<ILP<bool>>::reduce_to(&source),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
+}
diff --git a/src/unit_tests/rules/sequencingtominimizeweightedcompletiontime_ilp.rs b/src/unit_tests/rules/sequencingtominimizeweightedcompletiontime_ilp.rs
index 5f599cb07..62b7503de 100644
--- a/src/unit_tests/rules/sequencingtominimizeweightedcompletiontime_ilp.rs
+++ b/src/unit_tests/rules/sequencingtominimizeweightedcompletiontime_ilp.rs
@@ -8,25 +8,27 @@ use crate::types::Min;
 #[test]
 fn test_reduction_creates_expected_ilp_shape() {
     let problem = SequencingToMinimizeWeightedCompletionTime::new(vec![2, 1], vec![3, 5], vec![]);
-    let reduction: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSTMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 2 completion variables + 1 pair-order variable.
-    assert_eq!(ilp.num_vars, 3);
+    assert_eq!(ilp.num_vars(), 3);
 
     // 2 lower bounds + 2 upper bounds + 1 binary upper bound + 2 disjunctive constraints.
-    assert_eq!(ilp.constraints.len(), 7);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.constraints().len(), 7);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
     // Objective is w_0 * C_0 + w_1 * C_1.
-    assert_eq!(ilp.objective, vec![(0, 3.0), (1, 5.0)]);
+    assert_eq!(ilp.objective(), vec![(0, 3), (1, 5)]);
 }
 
 #[test]
 fn test_variable_layout_helpers() {
     let problem =
         SequencingToMinimizeWeightedCompletionTime::new(vec![2, 1, 3], vec![3, 5, 1], vec![(0, 2)]);
-    let reduction: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSTMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     assert_eq!(reduction.completion_var(0), 0);
     assert_eq!(reduction.completion_var(2), 2);
@@ -38,13 +40,14 @@ fn test_variable_layout_helpers() {
 #[test]
 fn test_extract_solution_encodes_schedule_as_lehmer_code() {
     let problem = SequencingToMinimizeWeightedCompletionTime::new(vec![2, 1], vec![3, 5], vec![]);
-    let reduction: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSTMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Completion times C0 = 3, C1 = 1 imply schedule [1, 0].
     // y_{0,1} = 0 means task 1 before task 0.
-    let extracted = reduction.extract_solution(&[3, 1, 0]);
+    let extracted = reduction.extract_solution(&vec![3, 1, 0]).unwrap();
     assert_eq!(extracted, vec![1, 0]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(14)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(14)));
 }
 
 #[test]
@@ -54,14 +57,15 @@ fn test_issue_example_closed_loop() {
         vec![3, 5, 1, 4, 2],
         vec![(0, 2), (1, 4)],
     );
-    let reduction: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSTMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, vec![1, 2, 0, 1, 0]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(46)));
+    assert_eq!(extracted, vec![1, 3, 0, 4, 2]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(46)));
 }
 
 #[test]
@@ -74,15 +78,17 @@ fn test_ilp_matches_bruteforce_optimum() {
 
     let brute_force = BruteForce::new();
     let brute_force_solution = brute_force
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute force should find a schedule");
-    let brute_force_metric = problem.evaluate(&brute_force_solution);
+    let brute_force_metric = problem.evaluate(&brute_force_solution).unwrap();
 
-    let reduction: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSTMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solution = ILPSolver::new().solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_metric = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_metric = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(ilp_metric, brute_force_metric);
 }
@@ -94,73 +100,70 @@ fn test_cyclic_precedence_instance_is_infeasible() {
         vec![1, 1],
         vec![(0, 1), (1, 0)],
     );
-    let reduction: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSTMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     assert!(
-        ILPSolver::new().solve(ilp).is_none(),
+        ILPSolver::new().solve(ilp).is_err(),
         "cyclic precedences should make the ILP infeasible"
     );
 }
 
 #[test]
-#[should_panic(expected = "task lengths must fit in ILP<i32> variable bounds")]
-fn test_reduction_panics_when_a_task_length_exceeds_i32_domain() {
-    let problem = SequencingToMinimizeWeightedCompletionTime::new(
-        vec![(i32::MAX as u64) + 1],
-        vec![1],
-        vec![],
-    );
-    let _: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
-}
-
-#[test]
-#[should_panic(expected = "total processing time must fit in ILP<i32> variable bounds")]
-fn test_reduction_panics_when_total_processing_time_exceeds_i32_domain() {
-    let problem = SequencingToMinimizeWeightedCompletionTime::new(
-        vec![i32::MAX as u64, 1],
-        vec![1, 1],
-        vec![],
-    );
-    let _: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+fn test_reduction_rejects_total_processing_time_outside_i64_domain() {
+    let problem =
+        SequencingToMinimizeWeightedCompletionTime::new(vec![i64::MAX, 1], vec![1, 1], vec![]);
+    assert!(matches!(
+        ReduceTo::<ILP<i64>>::reduce_to(&problem),
+        Err(crate::rules::ReductionError::IntegerOverflow { .. })
+    ));
 }
 
 #[test]
-#[should_panic(expected = "weighted completion objective must fit exactly in f64")]
-fn test_reduction_panics_when_a_weight_exceeds_exact_f64_integer_range() {
+fn test_reduction_preserves_a_weight_outside_exact_f64_integer_range() {
     let problem =
-        SequencingToMinimizeWeightedCompletionTime::new(vec![1], vec![(1u64 << 53) + 1], vec![]);
-    let _: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+        SequencingToMinimizeWeightedCompletionTime::new(vec![1], vec![(1i64 << 53) + 1], vec![]);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).unwrap();
+    assert_eq!(
+        reduction.target_problem().objective(),
+        &[(0, (1i64 << 53) + 1)]
+    );
 }
 
 #[test]
-#[should_panic(expected = "weighted completion objective must fit exactly in f64")]
-fn test_reduction_panics_when_weighted_completion_objective_exceeds_exact_f64_range() {
+fn test_reduction_preserves_large_weighted_completion_objective() {
     let problem =
         SequencingToMinimizeWeightedCompletionTime::new(vec![1, 1], vec![1 << 52, 1 << 52], vec![]);
-    let _: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).unwrap();
+    assert_eq!(
+        reduction.target_problem().objective(),
+        &[(0, 1 << 52), (1, 1 << 52)]
+    );
 }
 
 #[test]
-fn test_solve_reduced_matches_source_optimum() {
+fn test_ilp_pipeline_matches_source_optimum() {
     let problem = SequencingToMinimizeWeightedCompletionTime::new(
         vec![2, 1, 3, 1, 2],
         vec![3, 5, 1, 4, 2],
         vec![(0, 2), (1, 4)],
     );
-    let reduction: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSTMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let source_solution = reduction.extract_solution(&ilp_solution);
+    let source_solution = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(source_solution, vec![1, 2, 0, 1, 0]);
-    assert_eq!(problem.evaluate(&source_solution), Min(Some(46)));
+    assert_eq!(source_solution, vec![1, 3, 0, 4, 2]);
+    assert_eq!(problem.evaluate(&source_solution).unwrap(), Min(Some(46)));
 }
 
 #[test]
 fn test_sequencingtominimizeweightedcompletiontime_to_ilp_bf_vs_ilp() {
     let problem = SequencingToMinimizeWeightedCompletionTime::new(vec![2, 1], vec![3, 5], vec![]);
-    let reduction: ReductionSTMWCTToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSTMWCTToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/sequencingtominimizeweightedtardiness_ilp.rs b/src/unit_tests/rules/sequencingtominimizeweightedtardiness_ilp.rs
index 1d68ac783..3768789a1 100644
--- a/src/unit_tests/rules/sequencingtominimizeweightedtardiness_ilp.rs
+++ b/src/unit_tests/rules/sequencingtominimizeweightedtardiness_ilp.rs
@@ -8,32 +8,33 @@ use crate::types::Or;
 fn test_sequencingtominimizeweightedtardiness_to_ilp_closed_loop() {
     let problem =
         SequencingToMinimizeWeightedTardiness::new(vec![3, 4, 2], vec![2, 3, 1], vec![5, 8, 4], 10);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
-    // Use ILPSolver directly (BruteForce cannot enumerate ILP<i32>)
+    // Use ILPSolver directly (BruteForce cannot enumerate `ILP<i64>`)
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_sequencingtominimizeweightedtardiness_to_ilp_bf_vs_ilp() {
     let problem =
         SequencingToMinimizeWeightedTardiness::new(vec![3, 4, 2], vec![2, 3, 1], vec![5, 8, 4], 10);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf_witness = BruteForce::new()
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -41,9 +42,9 @@ fn test_sequencingtominimizeweightedtardiness_to_ilp_infeasible() {
     // All jobs have length 10, deadline 1, weight 1, bound 0: impossible
     let problem =
         SequencingToMinimizeWeightedTardiness::new(vec![10, 10], vec![1, 1], vec![1, 1], 0);
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible STMWT should produce infeasible ILP"
     );
 }
@@ -57,10 +58,10 @@ fn test_sequencingtominimizeweightedtardiness_to_ilp_no_tardiness() {
         vec![10, 10, 10],
         0,
     );
-    let reduction = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/sequencingwithdeadlinesandsetuptimes_ilp.rs b/src/unit_tests/rules/sequencingwithdeadlinesandsetuptimes_ilp.rs
index 23f97a1a8..30a4bcccc 100644
--- a/src/unit_tests/rules/sequencingwithdeadlinesandsetuptimes_ilp.rs
+++ b/src/unit_tests/rules/sequencingwithdeadlinesandsetuptimes_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Or;
@@ -14,13 +14,9 @@ fn test_sequencingwithdeadlinesandsetuptimes_to_ilp_closed_loop() {
         vec![0, 1, 0],
         vec![0, 1],
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_satisfaction_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "SequencingWithDeadlinesAndSetUpTimes->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
@@ -34,16 +30,17 @@ fn test_sequencingwithdeadlinesandsetuptimes_to_ilp_feasible_paper_example() {
 
     let bf = BruteForce::new();
     let bf_witness = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("paper example should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -51,9 +48,9 @@ fn test_sequencingwithdeadlinesandsetuptimes_to_ilp_infeasible() {
     // All tasks have deadline 1 but each takes 2 — clearly impossible.
     let problem =
         SequencingWithDeadlinesAndSetUpTimes::new(vec![2, 2], vec![1, 1], vec![0, 0], vec![0]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible instance should produce infeasible ILP"
     );
 }
@@ -66,12 +63,12 @@ fn test_sequencingwithdeadlinesandsetuptimes_to_ilp_setup_time_respected() {
     // Order [1,0]: elapsed=1≤4 ✓, then switch s=0, elapsed=1+0+1=2≤1 ✗ → infeasible
     let problem =
         SequencingWithDeadlinesAndSetUpTimes::new(vec![1, 1], vec![1, 4], vec![0, 1], vec![0, 2]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -85,20 +82,20 @@ fn test_sequencingwithdeadlinesandsetuptimes_to_ilp_bf_vs_ilp_small() {
     );
 
     let bf = BruteForce::new();
-    let bf_result = bf.find_witness(&problem);
+    let bf_result = bf.solve(&problem).unwrap();
     let bf_feasible = bf_result.is_some();
 
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_result = ILPSolver::new().solve(reduction.target_problem());
-    let ilp_feasible = ilp_result.is_some();
+    let ilp_feasible = ilp_result.is_ok();
 
     assert_eq!(
         bf_feasible, ilp_feasible,
         "BF and ILP should agree on feasibility"
     );
-    if let Some(ilp_solution) = ilp_result {
-        let extracted = reduction.extract_solution(&ilp_solution);
-        assert_eq!(problem.evaluate(&extracted), Or(true));
+    if let Ok(ilp_solution) = ilp_result {
+        let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+        assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
     }
 }
 
@@ -112,10 +109,10 @@ fn test_sequencingwithdeadlinesandsetuptimes_to_ilp_no_setup_same_compiler() {
         vec![0, 0, 0],
         vec![100], // large setup time, but never triggered
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("should be feasible with no switches");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/sequencingwithinintervals_ilp.rs b/src/unit_tests/rules/sequencingwithinintervals_ilp.rs
index fa04ef222..4f4a6c7e6 100644
--- a/src/unit_tests/rules/sequencingwithinintervals_ilp.rs
+++ b/src/unit_tests/rules/sequencingwithinintervals_ilp.rs
@@ -6,7 +6,7 @@ use crate::traits::Problem;
 fn feasible_instance() -> SequencingWithinIntervals {
     // 2 tasks: task 0 [r=0, d=3, l=2] (slots: 0 only), task 1 [r=2, d=5, l=2] (slots: 0,1)
     // Non-overlapping: task 0 at [0,2), task 1 at [2,4) or [3,5) — feasible
-    SequencingWithinIntervals::new(vec![0, 2], vec![3, 5], vec![2, 2])
+    SequencingWithinIntervals::new(vec![0, 2], vec![3, 5], vec![2, 2]).unwrap()
 }
 
 fn infeasible_instance() -> SequencingWithinIntervals {
@@ -14,22 +14,23 @@ fn infeasible_instance() -> SequencingWithinIntervals {
     // task 0 [r=0, d=2, l=2]: only start at offset 0
     // task 1 [r=0, d=2, l=2]: only start at offset 0
     // Both start at 0 → overlap
-    SequencingWithinIntervals::new(vec![0, 0], vec![2, 2], vec![2, 2])
+    SequencingWithinIntervals::new(vec![0, 0], vec![2, 2], vec![2, 2]).unwrap()
 }
 
 #[test]
 fn test_sequencingwithinintervals_to_ilp_structure() {
     let problem = feasible_instance();
-    let reduction: ReductionSWIToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSWIToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // task 0 has 1 start slot (d-r-l+1=3-0-2+1=2, so 2 offsets: 0 or 1... wait)
     // dim for task 0: d[0]-r[0]-l[0]+1 = 3-0-2+1 = 2 offsets
     // dim for task 1: d[1]-r[1]-l[1]+1 = 5-2-2+1 = 2 offsets
     // total vars = 2 + 2 = 4
-    assert_eq!(ilp.num_vars, 4);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 4);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(ilp.objective().is_empty());
 
     // 2 one-hot constraints + overlap constraints
     // task 0 k1=0: [0,2), task 1 k2=0: [2,4) → no overlap
@@ -37,7 +38,7 @@ fn test_sequencingwithinintervals_to_ilp_structure() {
     // task 0 k1=1: [1,3), task 1 k2=0: [2,4) → overlap at [2,3)
     // task 0 k1=1: [1,3), task 1 k2=1: [3,5) → no overlap
     // So 1 non-overlap constraint + 2 one-hot = 3 total
-    assert_eq!(ilp.constraints.len(), 3);
+    assert_eq!(ilp.constraints().len(), 3);
 }
 
 #[test]
@@ -45,21 +46,23 @@ fn test_sequencingwithinintervals_to_ilp_closed_loop() {
     let problem = feasible_instance();
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("feasible instance has a witness");
     assert!(
-        problem.evaluate(&bf_solution).0,
+        problem.evaluate(&bf_solution).unwrap().0,
         "brute force solution is valid"
     );
 
-    let reduction: ReductionSWIToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSWIToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "ILP extracted solution should be a valid schedule"
     );
 }
@@ -67,25 +70,45 @@ fn test_sequencingwithinintervals_to_ilp_closed_loop() {
 #[test]
 fn test_sequencingwithinintervals_to_ilp_infeasible() {
     let problem = infeasible_instance();
-    let reduction: ReductionSWIToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSWIToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible instance (forced overlap) should yield infeasible ILP"
     );
 }
 
+#[test]
+fn test_sequencingwithinintervals_to_ilp_empty_start_domain() {
+    for problem in [
+        SequencingWithinIntervals::new(vec![2], vec![50], vec![49]).unwrap(),
+        SequencingWithinIntervals::new(vec![0, 5], vec![3, 3], vec![2, 2]).unwrap(),
+        SequencingWithinIntervals::new(vec![i64::MAX], vec![0], vec![i64::MAX]).unwrap(),
+    ] {
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).unwrap();
+        let ilp = reduction.target_problem();
+        assert_eq!(ilp.num_vars(), problem.num_start_slots());
+        assert!(BruteForce::new().solve(&problem).unwrap().is_none());
+        assert!(matches!(
+            ILPSolver::new().solve(ilp),
+            Err(crate::solvers::ILPSolveError::Infeasible)
+        ));
+    }
+}
+
 #[test]
 fn test_sequencingwithinintervals_to_ilp_extract_solution() {
     let problem = feasible_instance();
-    let reduction: ReductionSWIToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSWIToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // task 0 at offset 0, task 1 at offset 0
     // vars: x_{0,0}=1, x_{0,1}=0, x_{1,0}=1, x_{1,1}=0
     let ilp_solution = vec![1, 0, 1, 0];
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 0]);
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "manually constructed solution is valid"
     );
 }
@@ -93,6 +116,7 @@ fn test_sequencingwithinintervals_to_ilp_extract_solution() {
 #[test]
 fn test_sequencingwithinintervals_to_ilp_bf_vs_ilp() {
     let problem = feasible_instance();
-    let reduction: ReductionSWIToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSWIToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/sequencingwithreleasetimesanddeadlines_ilp.rs b/src/unit_tests/rules/sequencingwithreleasetimesanddeadlines_ilp.rs
index 4ed4daca9..2598ef274 100644
--- a/src/unit_tests/rules/sequencingwithreleasetimesanddeadlines_ilp.rs
+++ b/src/unit_tests/rules/sequencingwithreleasetimesanddeadlines_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Or;
@@ -9,51 +9,61 @@ use crate::types::Or;
 fn test_sequencingwithreleasetimesanddeadlines_to_ilp_closed_loop() {
     let problem =
         SequencingWithReleaseTimesAndDeadlines::new(vec![1, 2, 1], vec![0, 0, 2], vec![3, 3, 4]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_satisfaction_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "SequencingWithReleaseTimesAndDeadlines->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
 fn test_sequencingwithreleasetimesanddeadlines_to_ilp_bf_vs_ilp() {
     let problem =
         SequencingWithReleaseTimesAndDeadlines::new(vec![1, 2, 1], vec![0, 0, 2], vec![3, 3, 4]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf_witness = BruteForce::new()
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_sequencingwithreleasetimesanddeadlines_to_ilp_infeasible() {
     // Two tasks that can't both fit: both need time 0-1, but overlap
     let problem = SequencingWithReleaseTimesAndDeadlines::new(vec![2, 2], vec![0, 0], vec![2, 2]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible SWRTD should produce infeasible ILP"
     );
 }
 
+#[test]
+fn test_sequencingwithreleasetimesanddeadlines_to_ilp_rejects_empty_start_window() {
+    // Task 0 cannot meet its deadline even when it starts immediately. Its
+    // admissible start-time set is empty, rather than the singleton {0}.
+    let problem = SequencingWithReleaseTimesAndDeadlines::new(vec![14], vec![0], vec![13]);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
+
+    assert!(
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
+        "a task longer than its release-deadline window must make the ILP infeasible"
+    );
+}
+
 #[test]
 fn test_sequencingwithreleasetimesanddeadlines_to_ilp_single_task() {
     let problem = SequencingWithReleaseTimesAndDeadlines::new(vec![3], vec![1], vec![5]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("single-task ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/setsplitting_betweenness.rs b/src/unit_tests/rules/setsplitting_betweenness.rs
index 9177da2ab..b43fa7fb1 100644
--- a/src/unit_tests/rules/setsplitting_betweenness.rs
+++ b/src/unit_tests/rules/setsplitting_betweenness.rs
@@ -22,7 +22,7 @@ fn issue_no_instance() -> SetSplitting {
 #[test]
 fn test_setsplitting_to_betweenness_closed_loop() {
     let source = small_yes_instance();
-    let reduction = ReduceTo::<Betweenness>::reduce_to(&source);
+    let reduction = ReduceTo::<Betweenness>::reduce_to(&source).expect("reduction should succeed");
 
     assert_satisfaction_round_trip_from_satisfaction_target(
         &source,
@@ -34,7 +34,7 @@ fn test_setsplitting_to_betweenness_closed_loop() {
 #[test]
 fn test_setsplitting_to_betweenness_issue_yes_instance_structure() {
     let source = issue_yes_instance();
-    let reduction = ReduceTo::<Betweenness>::reduce_to(&source);
+    let reduction = ReduceTo::<Betweenness>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_elements(), 10);
@@ -52,15 +52,17 @@ fn test_setsplitting_to_betweenness_issue_yes_instance_structure() {
         ],
     );
     assert_eq!(
-        reduction.extract_solution(&[8, 2, 9, 0, 1, 4, 3, 6, 7, 5]),
-        vec![1, 0, 1, 0, 0]
+        reduction
+            .extract_solution(&vec![8, 2, 9, 0, 1, 4, 3, 6, 7, 5])
+            .unwrap(),
+        vec![true, false, true, false, false]
     );
 }
 
 #[test]
 fn test_setsplitting_to_betweenness_normalizes_large_subsets() {
     let source = SetSplitting::new(4, vec![vec![0, 1, 2, 3]]);
-    let reduction = ReduceTo::<Betweenness>::reduce_to(&source);
+    let reduction = ReduceTo::<Betweenness>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.num_elements(), 9);
@@ -73,10 +75,11 @@ fn test_setsplitting_to_betweenness_normalizes_large_subsets() {
 #[test]
 fn test_setsplitting_to_betweenness_issue_no_instance_is_unsat() {
     let source = issue_no_instance();
-    let reduction = ReduceTo::<Betweenness>::reduce_to(&source);
+    let reduction = ReduceTo::<Betweenness>::reduce_to(&source).expect("reduction should succeed");
 
     assert!(BruteForce::new()
-        .find_witness(reduction.target_problem())
+        .solve(reduction.target_problem())
+        .unwrap()
         .is_none());
 }
 
@@ -92,6 +95,12 @@ fn test_setsplitting_to_betweenness_canonical_example_spec() {
     assert_eq!(example.solutions.len(), 1);
 
     let pair = &example.solutions[0];
-    assert_eq!(pair.source_config, vec![1, 0, 1, 0, 0]);
-    assert_eq!(pair.target_config, vec![8, 2, 9, 0, 1, 4, 3, 6, 7, 5]);
+    assert_eq!(
+        pair.source_config,
+        serde_json::json!([true, false, true, false, false])
+    );
+    assert_eq!(
+        pair.target_config,
+        serde_json::json!([8, 2, 9, 0, 1, 4, 3, 6, 7, 5])
+    );
 }
diff --git a/src/unit_tests/rules/setsplitting_ilp.rs b/src/unit_tests/rules/setsplitting_ilp.rs
index b15762c82..c4cb8d97c 100644
--- a/src/unit_tests/rules/setsplitting_ilp.rs
+++ b/src/unit_tests/rules/setsplitting_ilp.rs
@@ -7,29 +7,34 @@ use crate::types::Or;
 fn test_reduction_creates_valid_ilp() {
     // Universe {0,1,2}, subset {0,1,2}
     let problem = SetSplitting::new(3, vec![vec![0, 1, 2]]);
-    let reduction: ReductionSetSplittingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSetSplittingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 3, "one ILP var per universe element");
+    assert_eq!(ilp.num_vars(), 3, "one ILP var per universe element");
     assert_eq!(
-        ilp.constraints.len(),
+        ilp.constraints().len(),
         2,
         "two constraints per subset (ge + le)"
     );
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty(), "feasibility: no objective terms");
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(
+        ilp.objective().is_empty(),
+        "feasibility: no objective terms"
+    );
 }
 
 #[test]
 fn test_reduction_constraint_structure() {
     // Subset {0,1,2}: need sum >= 1 and sum <= 2
     let problem = SetSplitting::new(3, vec![vec![0, 1, 2]]);
-    let reduction: ReductionSetSplittingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSetSplittingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // One ge constraint (rhs=1) and one le constraint (rhs=2)
-    let ge_constraints: Vec<_> = ilp.constraints.iter().filter(|c| c.rhs == 1.0).collect();
-    let le_constraints: Vec<_> = ilp.constraints.iter().filter(|c| c.rhs == 2.0).collect();
+    let ge_constraints: Vec<_> = ilp.constraints().iter().filter(|c| c.rhs() == 1).collect();
+    let le_constraints: Vec<_> = ilp.constraints().iter().filter(|c| c.rhs() == 2).collect();
     assert_eq!(ge_constraints.len(), 1);
     assert_eq!(le_constraints.len(), 1);
 }
@@ -41,15 +46,16 @@ fn test_setsplitting_to_ilp_closed_loop() {
         6,
         vec![vec![0, 1, 2], vec![2, 3, 4], vec![0, 4, 5], vec![1, 3, 5]],
     );
-    let reduction: ReductionSetSplittingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSetSplittingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "extracted solution must split all subsets"
     );
@@ -59,12 +65,13 @@ fn test_setsplitting_to_ilp_closed_loop() {
 fn test_setsplitting_to_ilp_infeasible() {
     // Single-element universe, subset {0,0}: sum(x_0) >= 1 and sum(x_0) <= 0 — contradiction
     let problem = SetSplitting::new(1, vec![vec![0, 0]]);
-    let reduction: ReductionSetSplittingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSetSplittingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     assert!(
-        ilp_solver.solve(ilp).is_none(),
+        ilp_solver.solve(ilp).is_err(),
         "ILP should be infeasible for unsplittable instance"
     );
 }
@@ -75,16 +82,17 @@ fn test_setsplitting_bf_vs_ilp() {
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_witness = bf.find_witness(&problem);
+    let bf_witness = bf.solve(&problem).unwrap();
     assert!(bf_witness.is_some());
-    let bf_result = problem.evaluate(&bf_witness.unwrap());
+    let bf_result = problem.evaluate(&bf_witness.unwrap()).unwrap();
 
-    let reduction: ReductionSetSplittingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSetSplittingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_result = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_result = problem.evaluate(&extracted).unwrap();
 
     assert_eq!(bf_result, ilp_result, "BruteForce and ILP must agree");
     assert_eq!(ilp_result, Or(true));
@@ -94,8 +102,9 @@ fn test_setsplitting_bf_vs_ilp() {
 fn test_overhead_dimensions() {
     // 5 elements, 3 subsets → 5 vars, 6 constraints
     let problem = SetSplitting::new(5, vec![vec![0, 1], vec![2, 3], vec![0, 4]]);
-    let reduction: ReductionSetSplittingToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSetSplittingToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
-    assert_eq!(ilp.num_vars, 5);
-    assert_eq!(ilp.constraints.len(), 6); // 2 per subset
+    assert_eq!(ilp.num_vars(), 5);
+    assert_eq!(ilp.constraints().len(), 6); // 2 per subset
 }
diff --git a/src/unit_tests/rules/shortestcommonsupersequence_ilp.rs b/src/unit_tests/rules/shortestcommonsupersequence_ilp.rs
index 70cc18914..80ed3daef 100644
--- a/src/unit_tests/rules/shortestcommonsupersequence_ilp.rs
+++ b/src/unit_tests/rules/shortestcommonsupersequence_ilp.rs
@@ -8,27 +8,29 @@ fn test_reduction_creates_valid_ilp() {
     // Alphabet {0,1}, strings [0,1] and [1,0]
     // max_length = 2 + 2 = 4, k = 3 (alphabet_size + 1 for padding)
     let problem = ShortestCommonSupersequence::new(2, vec![vec![0, 1], vec![1, 0]]);
-    let reduction: ReductionSCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // x vars: 4 * 3 = 12, m vars: 4 * 4 = 16, total = 28
     assert_eq!(ilp.num_vars(), 28);
-    assert_eq!(ilp.sense, ObjectiveSense::Maximize);
-    assert!(!ilp.objective.is_empty());
+    assert_eq!(ilp.sense(), ObjectiveSense::Maximize);
+    assert!(!ilp.objective().is_empty());
 }
 
 #[test]
 fn test_shortestcommonsupersequence_to_ilp_closed_loop() {
-    use crate::Solver;
     let problem = ShortestCommonSupersequence::new(2, vec![vec![0, 1], vec![1, 0]]);
-    let bf_value = BruteForce::new().solve(&problem);
+    let bf_value_solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+    let bf_value = problem.evaluate(&bf_value_solution).unwrap();
 
-    let reduction: ReductionSCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
     assert_eq!(
         bf_value, ilp_value,
         "BF and ILP should agree on optimal value"
@@ -39,28 +41,30 @@ fn test_shortestcommonsupersequence_to_ilp_closed_loop() {
 fn test_shortestcommonsupersequence_to_ilp_bf_vs_ilp() {
     let problem = ShortestCommonSupersequence::new(3, vec![vec![0, 1, 2], vec![2, 1, 0]]);
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem);
+    let bf_witness = bf.solve(&problem).unwrap();
     assert!(bf_witness.is_some());
 
-    let reduction: ReductionSCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert!(problem.evaluate(&extracted).0.is_some());
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert!(problem.evaluate(&extracted).unwrap().0.is_some());
 }
 
 #[test]
 fn test_solution_extraction() {
     // Single string [0,1]
     let problem = ShortestCommonSupersequence::new(2, vec![vec![0, 1]]);
-    let reduction: ReductionSCSToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSCSToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted.len(), problem.max_length());
-    assert!(problem.evaluate(&extracted).0.is_some());
+    assert!(problem.evaluate(&extracted).unwrap().0.is_some());
 }
diff --git a/src/unit_tests/rules/shortestweightconstrainedpath_ilp.rs b/src/unit_tests/rules/shortestweightconstrainedpath_ilp.rs
index 6584fb275..8fe434aab 100644
--- a/src/unit_tests/rules/shortestweightconstrainedpath_ilp.rs
+++ b/src/unit_tests/rules/shortestweightconstrainedpath_ilp.rs
@@ -1,12 +1,12 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
-use crate::solvers::{BruteForce, ILPSolver, Solver};
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
 
 /// 3-vertex path: 0 -- 1 -- 2, s=0, t=2.
-fn simple_path_problem() -> ShortestWeightConstrainedPath<SimpleGraph, i32> {
+fn simple_path_problem() -> ShortestWeightConstrainedPath<SimpleGraph, i64> {
     ShortestWeightConstrainedPath::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
         vec![2, 3],
@@ -20,16 +20,17 @@ fn simple_path_problem() -> ShortestWeightConstrainedPath<SimpleGraph, i32> {
 #[test]
 fn test_reduction_creates_valid_ilp() {
     let problem = simple_path_problem();
-    let reduction: ReductionSWCPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSWCPToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 2 edges => 4 arc vars + 3 order vars = 7
-    assert_eq!(ilp.num_vars, 7);
+    assert_eq!(ilp.num_vars(), 7);
     // 5*2 + 4*3 + 2 = 10 + 12 + 2 = 24
-    assert_eq!(ilp.constraints.len(), 24);
+    assert_eq!(ilp.constraints().len(), 24);
     // Optimization: minimize total length
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(!ilp.objective.is_empty());
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(!ilp.objective().is_empty());
 }
 
 #[test]
@@ -45,20 +46,22 @@ fn test_shortestweightconstrainedpath_to_ilp_bf_vs_ilp() {
     );
 
     let bf = BruteForce::new();
-    let bf_value = bf.solve(&problem);
+    let bf_value_solution = bf.solve(&problem).unwrap().unwrap();
+    let bf_value = problem.evaluate(&bf_value_solution).unwrap();
 
-    let reduction: ReductionSWCPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSWCPToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_result = ilp_solver.solve(reduction.target_problem());
 
     match ilp_result {
-        Some(ilp_solution) => {
-            let extracted = reduction.extract_solution(&ilp_solution);
-            let ilp_value = problem.evaluate(&extracted);
+        Ok(ilp_solution) => {
+            let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+            let ilp_value = problem.evaluate(&extracted).unwrap();
             // Both should agree on the optimal length
             assert_eq!(ilp_value, bf_value);
         }
-        None => {
+        Err(_) => {
             // ILP found no feasible solution; brute force should agree
             assert_eq!(bf_value, Min(None));
         }
@@ -68,16 +71,17 @@ fn test_shortestweightconstrainedpath_to_ilp_bf_vs_ilp() {
 #[test]
 fn test_solution_extraction() {
     let problem = simple_path_problem();
-    let reduction: ReductionSWCPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSWCPToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Handcrafted ILP solution: path 0->1->2
     // a_{0,fwd}=1, a_{0,rev}=0, a_{1,fwd}=1, a_{1,rev}=0, o_0=0, o_1=1, o_2=2
     let target_solution = vec![1, 0, 1, 0, 0, 1, 2];
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
-    assert_eq!(extracted, vec![1, 1]);
+    assert_eq!(extracted, vec![true, true]);
     // length = 2 + 3 = 5
-    assert_eq!(problem.evaluate(&extracted), Min(Some(5)));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(5)));
 }
 
 #[test]
@@ -91,13 +95,14 @@ fn test_shortestweightconstrainedpath_to_ilp_trivial() {
         1,
         4, // weight_bound
     );
-    let reduction: ReductionSWCPToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionSWCPToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should solve the trivial s==t case");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, vec![0, 0]);
-    assert_eq!(problem.evaluate(&extracted), Min(Some(0)));
+    assert_eq!(extracted, vec![false, false]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(0)));
 }
diff --git a/src/unit_tests/rules/sparsematrixcompression_ilp.rs b/src/unit_tests/rules/sparsematrixcompression_ilp.rs
index d92744b41..ebc2628b0 100644
--- a/src/unit_tests/rules/sparsematrixcompression_ilp.rs
+++ b/src/unit_tests/rules/sparsematrixcompression_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::{ObjectiveSense, ILP};
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::rules::{ReduceTo, ReductionResult};
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
@@ -17,11 +17,12 @@ fn test_smc_to_ilp_structure() {
         ],
         2,
     );
-    let reduction: ReductionSMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // x: 4*2 = 8
-    assert_eq!(ilp.num_vars, 8);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 8);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -35,12 +36,9 @@ fn test_smc_to_ilp_closed_loop() {
         ],
         2,
     );
-    let reduction: ReductionSMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
-    assert_satisfaction_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "SparseMatrixCompression->ILP closed loop",
-    );
+    let reduction: ReductionSMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
@@ -54,26 +52,28 @@ fn test_smc_to_ilp_bf_vs_ilp() {
         ],
         2,
     );
-    let reduction: ReductionSMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem).expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    let bf_witness = bf.solve(&problem).unwrap().expect("should be feasible");
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_smc_to_ilp_trivial() {
     // Single row, K=1
     let problem = SparseMatrixCompression::new(vec![vec![true, false]], 1);
-    let reduction: ReductionSMCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSMCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // x: 1*1 = 1
-    assert_eq!(ilp.num_vars, 1);
+    assert_eq!(ilp.num_vars(), 1);
 }
diff --git a/src/unit_tests/rules/spinglass_maxcut.rs b/src/unit_tests/rules/spinglass_maxcut.rs
index b6dcac86d..75faf6fd8 100644
--- a/src/unit_tests/rules/spinglass_maxcut.rs
+++ b/src/unit_tests/rules/spinglass_maxcut.rs
@@ -6,8 +6,10 @@ include!("../jl_helpers.rs");
 #[test]
 fn test_spinglass_to_maxcut_closed_loop() {
     // SpinGlass without onsite terms
-    let sg = SpinGlass::<SimpleGraph, i32>::new(3, vec![((0, 1), 1), ((1, 2), 1)], vec![0, 0, 0]);
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&sg);
+    let sg = SpinGlass::<SimpleGraph, i64>::new(3, vec![((0, 1), 1), ((1, 2), 1)], vec![0, 0, 0])
+        .unwrap();
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&sg).expect("reduction should succeed");
     let mc = reduction.target_problem();
 
     assert_eq!(mc.graph().num_vertices(), 3); // No ancilla needed
@@ -17,8 +19,9 @@ fn test_spinglass_to_maxcut_closed_loop() {
 #[test]
 fn test_spinglass_to_maxcut_with_onsite() {
     // SpinGlass with onsite terms
-    let sg = SpinGlass::<SimpleGraph, i32>::new(2, vec![((0, 1), 1)], vec![1, 0]);
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&sg);
+    let sg = SpinGlass::<SimpleGraph, i64>::new(2, vec![((0, 1), 1)], vec![1, 0]).unwrap();
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&sg).expect("reduction should succeed");
     let mc = reduction.target_problem();
 
     assert_eq!(mc.graph().num_vertices(), 3); // Ancilla added
@@ -27,34 +30,37 @@ fn test_spinglass_to_maxcut_with_onsite() {
 
 #[test]
 fn test_solution_extraction_no_ancilla() {
-    let sg = SpinGlass::<SimpleGraph, i32>::new(2, vec![((0, 1), 1)], vec![0, 0]);
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&sg);
+    let sg = SpinGlass::<SimpleGraph, i64>::new(2, vec![((0, 1), 1)], vec![0, 0]).unwrap();
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&sg).expect("reduction should succeed");
 
-    let mc_sol = vec![0, 1];
-    let extracted = reduction.extract_solution(&mc_sol);
-    assert_eq!(extracted, vec![0, 1]);
+    let mc_sol = vec![false, true];
+    let extracted = reduction.extract_solution(&mc_sol).unwrap();
+    assert_eq!(extracted, vec![-1, 1]);
 }
 
 #[test]
 fn test_solution_extraction_with_ancilla() {
-    let sg = SpinGlass::<SimpleGraph, i32>::new(2, vec![((0, 1), 1)], vec![1, 0]);
-    let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&sg);
-
-    // If ancilla is 0, don't flip
-    let mc_sol = vec![0, 1, 0];
-    let extracted = reduction.extract_solution(&mc_sol);
-    assert_eq!(extracted, vec![0, 1]);
-
-    // If ancilla is 1, flip all
-    let mc_sol = vec![0, 1, 1];
-    let extracted = reduction.extract_solution(&mc_sol);
-    assert_eq!(extracted, vec![1, 0]); // flipped and ancilla removed
+    let sg = SpinGlass::<SimpleGraph, i64>::new(2, vec![((0, 1), 1)], vec![1, 0]).unwrap();
+    let reduction =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&sg).expect("reduction should succeed");
+
+    // A false ancilla represents spin -1, so flip to normalize it to +1.
+    let mc_sol = vec![false, true, false];
+    let extracted = reduction.extract_solution(&mc_sol).unwrap();
+    assert_eq!(extracted, vec![1, -1]);
+
+    // A true ancilla already represents spin +1.
+    let mc_sol = vec![false, true, true];
+    let extracted = reduction.extract_solution(&mc_sol).unwrap();
+    assert_eq!(extracted, vec![-1, 1]);
 }
 
 #[test]
 fn test_weighted_maxcut() {
     let mc = MaxCut::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![10, 20]);
-    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&mc);
+    let reduction =
+        ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&mc).expect("reduction should succeed");
     let sg = reduction.target_problem();
 
     // Verify interactions have correct weights
@@ -65,16 +71,18 @@ fn test_weighted_maxcut() {
 #[test]
 fn test_reduction_structure() {
     // Test MaxCut to SpinGlass structure
-    let mc = MaxCut::<_, i32>::unweighted(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
-    let reduction = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&mc);
+    let mc = MaxCut::<_, i64>::unweighted(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
+    let reduction =
+        ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&mc).expect("reduction should succeed");
     let sg = reduction.target_problem();
 
     // SpinGlass should have same number of spins as vertices
     assert_eq!(sg.num_spins(), 3);
 
     // Test SpinGlass to MaxCut structure
-    let sg2 = SpinGlass::<SimpleGraph, i32>::new(3, vec![((0, 1), 1)], vec![0, 0, 0]);
-    let reduction2 = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&sg2);
+    let sg2 = SpinGlass::<SimpleGraph, i64>::new(3, vec![((0, 1), 1)], vec![0, 0, 0]).unwrap();
+    let reduction2 =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&sg2).expect("reduction should succeed");
     let mc2 = reduction2.target_problem();
 
     assert_eq!(mc2.graph().num_vertices(), 3);
@@ -91,20 +99,25 @@ fn test_jl_parity_spinglass_to_maxcut() {
     let inst = &sg_data["instances"][0]["instance"];
     let nv = inst["num_vertices"].as_u64().unwrap() as usize;
     let edges = jl_parse_edges(inst);
-    let j_values = jl_parse_i32_vec(&inst["J"]);
-    let h_values = jl_parse_i32_vec(&inst["h"]);
-    let interactions: Vec<((usize, usize), i32)> = edges.into_iter().zip(j_values).collect();
-    let source = SpinGlass::<SimpleGraph, i32>::new(nv, interactions, h_values);
-    let result = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+    let j_values = jl_parse_i64_vec(&inst["J"]);
+    let h_values = jl_parse_i64_vec(&inst["h"]);
+    let interactions: Vec<((usize, usize), i64)> = edges.into_iter().zip(j_values).collect();
+    let source = SpinGlass::<SimpleGraph, i64>::new(nv, interactions, h_values).unwrap();
+    let result =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<i8>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity SpinGlass->MaxCut",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_spin_configs_set(&case["best_source"]));
     }
 }
 
@@ -120,18 +133,23 @@ fn test_jl_parity_maxcut_to_spinglass() {
     let nv = inst["num_vertices"].as_u64().unwrap() as usize;
     let weighted_edges = jl_parse_weighted_edges(inst);
     let edges: Vec<(usize, usize)> = weighted_edges.iter().map(|&(u, v, _)| (u, v)).collect();
-    let weights: Vec<i32> = weighted_edges.into_iter().map(|(_, _, w)| w).collect();
+    let weights: Vec<i64> = weighted_edges.into_iter().map(|(_, _, w)| w).collect();
     let source = MaxCut::new(SimpleGraph::new(nv, edges), weights);
-    let result = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&source);
+    let result = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity MaxCut->SpinGlass",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -146,21 +164,26 @@ fn test_jl_parity_rule_maxcut_to_spinglass() {
     let inst = &jl_find_instance_by_label(&mc_data, "rule_4vertex")["instance"];
     let weighted_edges = jl_parse_weighted_edges(inst);
     let edges: Vec<(usize, usize)> = weighted_edges.iter().map(|&(u, v, _)| (u, v)).collect();
-    let weights: Vec<i32> = weighted_edges.into_iter().map(|(_, _, w)| w).collect();
+    let weights: Vec<i64> = weighted_edges.into_iter().map(|(_, _, w)| w).collect();
     let source = MaxCut::new(
         SimpleGraph::new(inst["num_vertices"].as_u64().unwrap() as usize, edges),
         weights,
     );
-    let result = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&source);
+    let result = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity rule MaxCut->SpinGlass",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -175,19 +198,39 @@ fn test_jl_parity_rule_spinglass_to_maxcut() {
     let inst = &jl_find_instance_by_label(&sg_data, "rule_4vertex")["instance"];
     let nv = inst["num_vertices"].as_u64().unwrap() as usize;
     let edges = jl_parse_edges(inst);
-    let j_values = jl_parse_i32_vec(&inst["J"]);
-    let h_values = jl_parse_i32_vec(&inst["h"]);
-    let interactions: Vec<((usize, usize), i32)> = edges.into_iter().zip(j_values).collect();
-    let source = SpinGlass::<SimpleGraph, i32>::new(nv, interactions, h_values);
-    let result = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+    let j_values = jl_parse_i64_vec(&inst["J"]);
+    let h_values = jl_parse_i64_vec(&inst["h"]);
+    let interactions: Vec<((usize, usize), i64)> = edges.into_iter().zip(j_values).collect();
+    let source = SpinGlass::<SimpleGraph, i64>::new(nv, interactions, h_values).unwrap();
+    let result =
+        ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<i8>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity rule SpinGlass->MaxCut",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_spin_configs_set(&case["best_source"]));
+    }
+}
+
+#[test]
+fn test_spinglass_to_maxcut_fields_corpus_regression() {
+    for fields in [vec![2, 0, -3], vec![-2, 1, 0], vec![1, 2, 3]] {
+        let source =
+            SpinGlass::new(3, vec![((0, 1), 2i64), ((1, 2), -3), ((0, 2), 1)], fields).unwrap();
+        let reduction = ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source).unwrap();
+        // Enumerating every target optimum exercises both complementary cut sides.
+        assert_optimization_round_trip_from_optimization_target(
+            &source,
+            &reduction,
+            "SpinGlass field sign and ancilla orientation",
+        );
     }
 }
diff --git a/src/unit_tests/rules/spinglass_qubo.rs b/src/unit_tests/rules/spinglass_qubo.rs
index dc3494c02..7894a553b 100644
--- a/src/unit_tests/rules/spinglass_qubo.rs
+++ b/src/unit_tests/rules/spinglass_qubo.rs
@@ -1,18 +1,18 @@
 use super::*;
 use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
 use crate::solvers::BruteForce;
-use crate::traits::Problem;
+use crate::solvers::BruteForceProblem as _;
 include!("../jl_helpers.rs");
 
 #[test]
 fn test_spinglass_to_qubo_closed_loop() {
     // Antiferromagnetic: J > 0, prefers anti-aligned spins
-    let sg = SpinGlass::<SimpleGraph, f64>::new(2, vec![((0, 1), 1.0)], vec![0.0, 0.0]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sg);
+    let sg = SpinGlass::<SimpleGraph, f64>::new(2, vec![((0, 1), 1.0)], vec![0.0, 0.0]).unwrap();
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sg).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(qubo);
+    let solutions = solver.find_all_witnesses(qubo).unwrap();
 
     // Anti-ferromagnetic: opposite spins are optimal
     for sol in &solutions {
@@ -23,35 +23,49 @@ fn test_spinglass_to_qubo_closed_loop() {
     }
 }
 
+#[test]
+fn test_integer_spinglass_to_integer_qubo() {
+    let source = SpinGlass::<SimpleGraph, i64>::new(2, vec![((0, 1), 1)], vec![0, 0]).unwrap();
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&source).expect("reduction should succeed");
+
+    assert_optimization_round_trip_from_optimization_target(
+        &source,
+        &reduction,
+        "integer SpinGlass->QUBO",
+    );
+}
+
 #[test]
 fn test_with_onsite_fields() {
     // SpinGlass with only on-site field h_0 = 1
     // Energy = h_0 * s_0 = s_0
     // Minimum at s_0 = -1, i.e., x_0 = 0
-    let sg = SpinGlass::<SimpleGraph, f64>::new(1, vec![], vec![1.0]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sg);
+    let sg = SpinGlass::<SimpleGraph, f64>::new(1, vec![], vec![1.0]).unwrap();
+    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sg).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let solutions = solver.find_all_witnesses(qubo);
+    let solutions = solver.find_all_witnesses(qubo).unwrap();
 
     assert_eq!(solutions.len(), 1);
-    assert_eq!(solutions[0], vec![0], "Should prefer x=0 (s=-1)");
+    assert_eq!(solutions[0], vec![false], "Should prefer x=false (s=-true)");
 }
 
 #[test]
 fn test_reduction_structure() {
     // Test QUBO to SpinGlass structure
-    let qubo = QUBO::from_matrix(vec![vec![1.0, -2.0], vec![0.0, 1.0]]);
-    let reduction = ReduceTo::<SpinGlass<SimpleGraph, f64>>::reduce_to(&qubo);
+    let qubo = QUBO::from_matrix(vec![vec![1.0, -2.0], vec![0.0, 1.0]]).unwrap();
+    let reduction = ReduceTo::<SpinGlass<SimpleGraph, f64>>::reduce_to(&qubo)
+        .expect("reduction should succeed");
     let sg = reduction.target_problem();
 
     // SpinGlass should have same number of spins as QUBO variables
     assert_eq!(sg.num_spins(), 2);
 
     // Test SpinGlass to QUBO structure
-    let sg2 = SpinGlass::<SimpleGraph, f64>::new(3, vec![((0, 1), -1.0)], vec![0.0, 0.0, 0.0]);
-    let reduction2 = ReduceTo::<QUBO<f64>>::reduce_to(&sg2);
+    let sg2 =
+        SpinGlass::<SimpleGraph, f64>::new(3, vec![((0, 1), -1.0)], vec![0.0, 0.0, 0.0]).unwrap();
+    let reduction2 = ReduceTo::<QUBO<f64>>::reduce_to(&sg2).expect("reduction should succeed");
     let qubo2 = reduction2.target_problem();
 
     assert_eq!(qubo2.num_variables(), 3);
@@ -81,17 +95,21 @@ fn test_jl_parity_spinglass_to_qubo() {
         .map(|v| v.as_i64().unwrap() as f64)
         .collect();
     let interactions: Vec<((usize, usize), f64)> = edges.into_iter().zip(j_values).collect();
-    let source = SpinGlass::<SimpleGraph, f64>::new(nv, interactions, h_values);
-    let result = ReduceTo::<QUBO<f64>>::reduce_to(&source);
+    let source = SpinGlass::<SimpleGraph, f64>::new(nv, interactions, h_values).unwrap();
+    let result = ReduceTo::<QUBO<f64>>::reduce_to(&source).expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<i8>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity SpinGlass->QUBO",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_spin_configs_set(&case["best_source"]));
     }
 }
 
@@ -123,17 +141,22 @@ fn test_jl_parity_qubo_to_spinglass() {
             rust_matrix[i][j] = jl_matrix[i][j] + jl_matrix[j][i];
         }
     }
-    let source = QUBO::from_matrix(rust_matrix);
-    let result = ReduceTo::<SpinGlass<SimpleGraph, f64>>::reduce_to(&source);
+    let source = QUBO::from_matrix(rust_matrix).unwrap();
+    let result = ReduceTo::<SpinGlass<SimpleGraph, f64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity QUBO->SpinGlass",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
 
@@ -166,16 +189,21 @@ fn test_jl_parity_rule_qubo_to_spinglass() {
             rust_matrix[i][j] = jl_matrix[i][j] + jl_matrix[j][i];
         }
     }
-    let source = QUBO::from_matrix(rust_matrix);
-    let result = ReduceTo::<SpinGlass<SimpleGraph, f64>>::reduce_to(&source);
+    let source = QUBO::from_matrix(rust_matrix).unwrap();
+    let result = ReduceTo::<SpinGlass<SimpleGraph, f64>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let solver = BruteForce::new();
-    let best_source: HashSet<Vec<usize>> = solver.find_all_witnesses(&source).into_iter().collect();
+    let best_source: HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
     assert_optimization_round_trip_from_optimization_target(
         &source,
         &result,
         "JL parity rule QUBO->SpinGlass",
     );
     for case in data["cases"].as_array().unwrap() {
-        assert_eq!(best_source, jl_parse_configs_set(&case["best_source"]));
+        assert_eq!(best_source, jl_parse_bool_configs_set(&case["best_source"]));
     }
 }
diff --git a/src/unit_tests/rules/stackercrane_ilp.rs b/src/unit_tests/rules/stackercrane_ilp.rs
index d4d6ff22f..849e3339c 100644
--- a/src/unit_tests/rules/stackercrane_ilp.rs
+++ b/src/unit_tests/rules/stackercrane_ilp.rs
@@ -1,23 +1,89 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::rules::ReduceTo;
 
 #[test]
 fn test_stackercrane_to_ilp_closed_loop() {
     // 3 vertices, 2 required arcs, 1 connector edge
     let source = StackerCrane::new(3, vec![(0, 1), (2, 0)], vec![(1, 2)], vec![1, 1], vec![1]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "StackerCrane->ILP closed loop",
-    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
 fn test_stackercrane_to_ilp_bf_vs_ilp() {
     let source = StackerCrane::new(3, vec![(0, 1), (2, 0)], vec![(1, 2)], vec![1, 1], vec![1]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
+
+#[test]
+fn test_stackercrane_to_ilp_unreachable_return() {
+    let source = StackerCrane::new(2, vec![(0, 1)], vec![], vec![1], vec![]);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    assert_eq!(
+        crate::solvers::ILPSolver::new().solve(reduction.target_problem()),
+        Err(crate::solvers::ILPSolveError::Infeasible),
+    );
+}
+
+#[test]
+fn test_stackercrane_to_ilp_all_binary_assignments() {
+    use crate::traits::Problem;
+
+    // Each undirected connector is absent, zero-cost, or positive-cost.
+    // Enumerate every ILP assignment, including malformed one-hot matrices and
+    // false product indicators, rather than just the solver's chosen optimum.
+    for encoding in 0..27 {
+        let mut code = encoding;
+        let mut edges = Vec::new();
+        let mut lengths = Vec::new();
+        for pair in [(0, 1), (0, 2), (1, 2)] {
+            match code % 3 {
+                1 => {
+                    edges.push(pair);
+                    lengths.push(0);
+                }
+                2 => {
+                    edges.push(pair);
+                    lengths.push(2);
+                }
+                _ => {}
+            }
+            code /= 3;
+        }
+        let source = StackerCrane::new(3, vec![(0, 1), (1, 2)], edges, vec![0, 1], lengths);
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+        let target = reduction.target_problem();
+        let mut decoded = std::collections::HashSet::new();
+        for bits in 0..(1 << 12) {
+            let solution = (0..12).map(|i| i64::from(bits & (1 << i) != 0)).collect();
+            if let Some(cost) = target.evaluate(&solution).unwrap().value {
+                let permutation = reduction.extract_solution(&solution).unwrap();
+                assert_eq!(
+                    source.evaluate(&permutation).unwrap(),
+                    crate::types::Min(Some(cost + 1))
+                );
+                decoded.insert(permutation);
+            }
+        }
+        for permutation in [vec![0, 1], vec![1, 0]] {
+            assert_eq!(
+                decoded.contains(&permutation),
+                source.closed_walk_length(&permutation).is_some()
+            );
+        }
+    }
+}
+
+#[test]
+fn test_stackercrane_to_ilp_empty_and_self_loop() {
+    for source in [
+        StackerCrane::new(0, vec![], vec![], vec![], vec![]),
+        StackerCrane::new(1, vec![(0, 0)], vec![], vec![0], vec![]),
+    ] {
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+        assert_bf_vs_ilp(&source, &reduction);
+    }
+}
diff --git a/src/unit_tests/rules/steinertree_ilp.rs b/src/unit_tests/rules/steinertree_ilp.rs
index 7925f7ed4..6b98b506c 100644
--- a/src/unit_tests/rules/steinertree_ilp.rs
+++ b/src/unit_tests/rules/steinertree_ilp.rs
@@ -1,104 +1,153 @@
 use super::*;
-use crate::models::algebraic::{ObjectiveSense, ILP};
-use crate::models::graph::SteinerTree;
-use crate::rules::ReduceTo;
-use crate::solvers::{BruteForce, ILPSolver};
-use crate::topology::SimpleGraph;
+use crate::solvers::ILPSolver;
 use crate::traits::Problem;
 use crate::types::Min;
 
-fn canonical_instance() -> SteinerTree<SimpleGraph, i32> {
-    let graph = SimpleGraph::new(
-        5,
-        vec![(0, 1), (1, 2), (1, 3), (3, 4), (0, 3), (3, 2), (2, 4)],
-    );
-    SteinerTree::new(graph, vec![2, 2, 1, 1, 5, 5, 6], vec![0, 2, 4])
-}
-
-#[test]
-fn test_reduction_creates_expected_ilp_shape() {
-    let problem = canonical_instance();
-    let reduction: ReductionSteinerTreeToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
-    let ilp = reduction.target_problem();
-
-    assert_eq!(ilp.num_vars, 35);
-    assert_eq!(ilp.constraints.len(), 38);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert_eq!(
-        ilp.objective,
-        vec![
-            (0, 2.0),
-            (1, 2.0),
-            (2, 1.0),
-            (3, 1.0),
-            (4, 5.0),
-            (5, 5.0),
-            (6, 6.0),
-        ]
-    );
+// Construct the proof's path witness for a source tree, using only source edges.
+fn lift(source: &SteinerTree<SimpleGraph, i64>, chosen: &[bool]) -> Vec<i64> {
+    let n = source.num_vertices();
+    let m = source.num_edges();
+    let root = source.terminals()[0];
+    let edges = source.graph().edges();
+    let mut witness = vec![0; tree_ilp_sizes(n, m, source.terminals().len()).unwrap().0];
+    let mut adj = vec![vec![]; n];
+    for (e, &(u, v)) in edges.iter().enumerate() {
+        if chosen[e] {
+            witness[e] = 1;
+            witness[m + u] = 1;
+            witness[m + v] = 1;
+            adj[u].push((v, e, 0));
+            adj[v].push((u, e, 1));
+        }
+    }
+    let mut parent = vec![None; n];
+    let mut stack = vec![root];
+    parent[root] = Some((root, 0, 0));
+    while let Some(u) = stack.pop() {
+        for &(v, e, dir) in &adj[u] {
+            if parent[v].is_none() {
+                parent[v] = Some((u, e, dir));
+                stack.push(v);
+            }
+        }
+    }
+    for (commodity, sink) in (0..n).filter(|&v| v != root).enumerate() {
+        if witness[m + sink] == 0 {
+            continue;
+        }
+        let mut v = sink;
+        while v != root {
+            let (u, e, dir) = parent[v].unwrap();
+            witness[m + n + commodity * 2 * m + 2 * e + dir] = 1;
+            v = u;
+        }
+    }
+    witness
 }
 
 #[test]
 fn test_steinertree_to_ilp_closed_loop() {
-    let problem = canonical_instance();
-    let reduction: ReductionSteinerTreeToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
-    let ilp = reduction.target_problem();
-
-    let bf = BruteForce::new();
-    let ilp_solver = ILPSolver::new();
-    let best_source = bf.find_all_witnesses(&problem);
-    let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-
-    assert_eq!(problem.evaluate(&best_source[0]), Min(Some(6)));
-    assert_eq!(problem.evaluate(&extracted), Min(Some(6)));
-    assert!(problem.is_valid_solution(&extracted));
+    for (n, edges, weights, terminals, optimum) in [
+        (
+            3,
+            vec![(0, 1), (1, 2), (0, 2)],
+            vec![-1, -1, -1],
+            vec![0, 1],
+            -2,
+        ),
+        (
+            3,
+            vec![(0, 1), (1, 2), (0, 2)],
+            vec![0, 0, 0],
+            vec![0, 1],
+            0,
+        ),
+        (4, vec![(0, 1), (2, 3)], vec![1, -10], vec![0, 1], 1),
+        (3, vec![(0, 1), (1, 2)], vec![1, -5], vec![0, 1], -4),
+        (3, vec![(0, 1), (1, 2)], vec![2, 3], vec![2, 0], 5),
+    ] {
+        let source = SteinerTree::new(SimpleGraph::new(n, edges), weights, terminals);
+        let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+        let witness = ILPSolver::new().solve(reduction.target_problem()).unwrap();
+        let decoded = reduction.extract_solution(&witness).unwrap();
+        assert_eq!(source.evaluate(&decoded).unwrap(), Min(Some(optimum)));
+        assert_eq!(
+            reduction.target_problem().evaluate(&witness).unwrap().value,
+            Some(optimum)
+        );
+        crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
+    }
+    let source = SteinerTree::new(SimpleGraph::new(3, vec![(0, 1)]), vec![-1], vec![0, 2]);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    assert!(matches!(
+        ILPSolver::new().solve(reduction.target_problem()),
+        Err(crate::solvers::ILPSolveError::Infeasible)
+    ));
 }
 
 #[test]
-fn test_solution_extraction_reads_edge_selector_prefix() {
-    let problem = canonical_instance();
-    let reduction: ReductionSteinerTreeToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
-
-    let target_solution = vec![
-        1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0,
-        0, 0, 0, 0, 0,
-    ];
-
-    assert_eq!(
-        reduction.extract_solution(&target_solution),
-        vec![1, 1, 1, 1, 0, 0, 0]
+fn test_steiner_all_source_trees_lift_and_preserve_objective() {
+    let source = SteinerTree::new(
+        SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
+        vec![-2, 0, 3, -1, 2, 0],
+        vec![2, 0],
     );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    let target = reduction.target_problem();
+    assert_eq!((target.num_vars(), target.constraints().len()), (46, 63));
+    for mask in 0..64 {
+        let selected: Vec<_> = (0..6).map(|e| mask & (1 << e) != 0).collect();
+        if source.is_valid_solution(&selected) {
+            let witness = lift(&source, &selected);
+            assert_eq!(
+                target.evaluate(&witness).unwrap().value,
+                source.evaluate(&selected).unwrap().0
+            );
+            assert_eq!(reduction.extract_solution(&witness).unwrap(), selected);
+        }
+    }
 }
 
 #[test]
-fn test_solve_reduced_uses_new_rule() {
-    let problem = canonical_instance();
-    let solution = ILPSolver::new()
-        .solve_reduced(&problem)
-        .expect("solve_reduced should find the Steiner tree via ILP");
-    assert_eq!(problem.evaluate(&solution), Min(Some(6)));
-}
-
-#[test]
-#[should_panic(expected = "SteinerTree -> ILP requires strictly positive edge weights")]
-fn test_reduction_rejects_negative_weights() {
-    let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
-    let problem = SteinerTree::new(graph, vec![1, -2, 3], vec![0, 1]);
-    let _ = ReduceTo::<ILP<bool>>::reduce_to(&problem);
-}
-
-#[test]
-#[should_panic(expected = "SteinerTree -> ILP requires strictly positive edge weights")]
-fn test_reduction_rejects_zero_weights() {
-    let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
-    let problem = SteinerTree::new(graph, vec![0, 0, 0], vec![0, 1]);
-    let _ = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+fn test_steiner_every_small_raw_target_and_malformed_witness() {
+    let source = SteinerTree::new(SimpleGraph::new(2, vec![(0, 1)]), vec![-3], vec![1, 0]);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).unwrap();
+    let target = reduction.target_problem();
+    let mut feasible_count = 0;
+    for mask in 0..(1 << target.num_vars()) {
+        let witness: Vec<_> = (0..target.num_vars()).map(|v| (mask >> v) & 1).collect();
+        if target.evaluate(&witness).unwrap().is_valid() {
+            feasible_count += 1;
+            let decoded = reduction.extract_solution(&witness).unwrap();
+            assert_eq!(source.evaluate(&decoded).unwrap(), Min(Some(-3)));
+        } else {
+            assert!(reduction.extract_solution(&witness).is_err());
+        }
+    }
+    for bad in [
+        vec![],
+        vec![1; target.num_vars() + 1],
+        vec![2; target.num_vars()],
+    ] {
+        assert!(reduction.extract_solution(&bad).is_err());
+    }
+    assert_eq!(feasible_count, 1);
 }
 
 #[test]
-fn test_steinertree_to_ilp_bf_vs_ilp() {
-    let problem = canonical_instance();
-    let reduction: ReductionSteinerTreeToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
-    crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
+fn test_steiner_count_boundaries() {
+    assert_eq!(tree_ilp_sizes(5, 7, 3).unwrap(), (68, 94));
+    assert_eq!(tree_ilp_sizes(2, 0, 2).unwrap(), (2, 5));
+    for (n, m, k) in [
+        (0, 0, 0),
+        (2, usize::MAX, 2),
+        (usize::MAX, 1, 2),
+        (usize::MAX, 0, 2),
+        (2, 0, usize::MAX),
+    ] {
+        assert!(matches!(
+            tree_ilp_sizes(n, m, k),
+            Err(crate::rules::ReductionError::IntegerOverflow { .. })
+        ));
+    }
 }
diff --git a/src/unit_tests/rules/steinertreeingraphs_ilp.rs b/src/unit_tests/rules/steinertreeingraphs_ilp.rs
index 397b9a48c..d09885b41 100644
--- a/src/unit_tests/rules/steinertreeingraphs_ilp.rs
+++ b/src/unit_tests/rules/steinertreeingraphs_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::rules::ReduceTo;
 use crate::topology::SimpleGraph;
 
@@ -14,12 +14,8 @@ fn test_steinertreeingraphs_to_ilp_closed_loop() {
         vec![0, 2],
         vec![1, 1],
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
-    assert_optimization_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "SteinerTreeInGraphs->ILP closed loop",
-    );
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
+    assert_bf_vs_ilp(&source, &reduction);
 }
 
 #[test]
@@ -29,6 +25,6 @@ fn test_steinertreeingraphs_to_ilp_bf_vs_ilp() {
         vec![0, 2],
         vec![1, 1],
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/stringtostringcorrection_ilp.rs b/src/unit_tests/rules/stringtostringcorrection_ilp.rs
index 3b1983b03..83354d82f 100644
--- a/src/unit_tests/rules/stringtostringcorrection_ilp.rs
+++ b/src/unit_tests/rules/stringtostringcorrection_ilp.rs
@@ -8,12 +8,13 @@ use crate::types::Or;
 fn test_reduction_creates_valid_ilp() {
     // source = [0,1], target = [1], bound = 1 (delete position 0)
     let problem = StringToStringCorrection::new(2, vec![0, 1], vec![1], 1);
-    let reduction: ReductionSTSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSTSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=2, K=1: (K+1)*n*n + (K+1)*n + K*n + K*(n-1) + K = 2*4 + 2*2 + 1*2 + 1*1 + 1 = 16
     assert_eq!(ilp.num_vars(), 16);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -22,30 +23,32 @@ fn test_stringtostringcorrection_to_ilp_bf_vs_ilp() {
     let problem = StringToStringCorrection::new(2, vec![0, 1], vec![1], 1);
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem);
+    let bf_witness = bf.solve(&problem).unwrap();
     assert!(bf_witness.is_some(), "BF should find a solution");
 
-    let reduction: ReductionSTSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSTSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_solution_extraction_delete() {
     // source=[0,1], target=[1], bound=1 => delete at position 0
     let problem = StringToStringCorrection::new(2, vec![0, 1], vec![1], 1);
-    let reduction: ReductionSTSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSTSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted.len(), 1);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -56,13 +59,14 @@ fn test_stringtostringcorrection_to_ilp_infeasible() {
 
     // Verify the source problem is actually infeasible
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem);
+    let bf_witness = bf.solve(&problem).unwrap();
     assert!(bf_witness.is_none(), "source should be infeasible");
 
-    let reduction: ReductionSTSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSTSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     assert!(
-        ilp_solver.solve(reduction.target_problem()).is_none(),
+        ilp_solver.solve(reduction.target_problem()).is_err(),
         "reduced ILP should also be infeasible"
     );
 }
@@ -73,14 +77,15 @@ fn test_stringtostringcorrection_to_ilp_swap() {
     let problem = StringToStringCorrection::new(2, vec![1, 0], vec![0, 1], 1);
 
     let bf = BruteForce::new();
-    let bf_witness = bf.find_witness(&problem);
+    let bf_witness = bf.solve(&problem).unwrap();
     assert!(bf_witness.is_some(), "BF should find a solution");
 
-    let reduction: ReductionSTSCToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSTSCToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/strongconnectivityaugmentation_ilp.rs b/src/unit_tests/rules/strongconnectivityaugmentation_ilp.rs
index 924fcc0ec..0fd893b32 100644
--- a/src/unit_tests/rules/strongconnectivityaugmentation_ilp.rs
+++ b/src/unit_tests/rules/strongconnectivityaugmentation_ilp.rs
@@ -6,7 +6,7 @@ use crate::solvers::{BruteForce, ILPSolver};
 use crate::topology::DirectedGraph;
 use crate::traits::Problem;
 
-fn small_instance() -> StrongConnectivityAugmentation<i32> {
+fn small_instance() -> StrongConnectivityAugmentation<i64> {
     // Path 0->1->2, candidates: (2,0,1),(1,0,2), bound=2
     StrongConnectivityAugmentation::new(
         DirectedGraph::new(3, vec![(0, 1), (1, 2)]),
@@ -18,21 +18,22 @@ fn small_instance() -> StrongConnectivityAugmentation<i32> {
 #[test]
 fn test_strongconnectivityaugmentation_to_ilp_closed_loop() {
     let source = small_instance();
-    let reduction: ReductionSCAToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionSCAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // Solve source with brute force
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&source);
+    let bf_solutions = bf.find_all_witnesses(&source).unwrap();
     assert!(!bf_solutions.is_empty(), "source should be satisfiable");
 
     // Solve ILP
     let ilp_solver = ILPSolver::new();
     let ilp_sol = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
 
     assert!(
-        source.evaluate(&extracted).0,
+        source.evaluate(&extracted).unwrap().0,
         "extracted solution must be valid"
     );
 }
@@ -40,41 +41,44 @@ fn test_strongconnectivityaugmentation_to_ilp_closed_loop() {
 #[test]
 fn test_extract_solution() {
     let source = small_instance();
-    let reduction: ReductionSCAToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionSCAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
     let ilp_sol = solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
     assert_eq!(extracted.len(), 2);
-    assert!(source.evaluate(&extracted).0);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_trivial_single_vertex() {
     let source = StrongConnectivityAugmentation::new(DirectedGraph::new(1, vec![]), vec![], 0);
-    let reduction: ReductionSCAToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionSCAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
     let ilp_sol = solver.solve(ilp).expect("trivial should be solvable");
-    let extracted = reduction.extract_solution(&ilp_sol);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&ilp_sol).unwrap();
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
 fn test_single_vertex_candidate_selection_must_still_respect_budget() {
     let source =
         StrongConnectivityAugmentation::new(DirectedGraph::new(1, vec![]), vec![(0, 0, 1)], 0);
-    let reduction: ReductionSCAToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionSCAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let mut config = vec![0; ilp.num_vars()];
     config[0] = 1;
 
     assert!(
-        !source.evaluate(&[1]).0,
+        !source.evaluate(&vec![true]).unwrap().0,
         "source rejects the over-budget candidate"
     );
     assert!(
-        !ilp.evaluate(&config).is_valid(),
+        !ilp.evaluate(&config).unwrap().is_valid(),
         "reduced ILP must reject the same candidate selection"
     );
 }
@@ -87,15 +91,17 @@ fn test_infeasible_budget() {
         vec![(2, 0, 10)],
         5,
     );
-    let reduction: ReductionSCAToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionSCAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let solver = ILPSolver::new();
-    assert!(solver.solve(ilp).is_none());
+    assert!(solver.solve(ilp).is_err());
 }
 
 #[test]
 fn test_strongconnectivityaugmentation_to_ilp_bf_vs_ilp() {
     let source = small_instance();
-    let reduction: ReductionSCAToILP = ReduceTo::<ILP<i32>>::reduce_to(&source);
+    let reduction: ReductionSCAToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&source).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&source, &reduction);
 }
diff --git a/src/unit_tests/rules/subgraphisomorphism_ilp.rs b/src/unit_tests/rules/subgraphisomorphism_ilp.rs
index a662292f0..cd7fe8f07 100644
--- a/src/unit_tests/rules/subgraphisomorphism_ilp.rs
+++ b/src/unit_tests/rules/subgraphisomorphism_ilp.rs
@@ -10,11 +10,12 @@ fn test_reduction_creates_valid_ilp() {
     let host = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
     let pattern = SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]);
     let problem = SubgraphIsomorphism::new(host, pattern);
-    let reduction: ReductionSubIsoToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSubIsoToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     // n_pat=3, n_host=4: num_vars=12
-    assert_eq!(ilp.num_vars, 12);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 12);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
@@ -27,19 +28,21 @@ fn test_subgraphisomorphism_to_ilp_closed_loop() {
     // BruteForce on source to confirm feasibility
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute-force should find a solution");
-    assert_eq!(problem.evaluate(&bf_solution), Or(true));
+    assert_eq!(problem.evaluate(&bf_solution).unwrap(), Or(true));
 
     // Solve via ILP
-    let reduction: ReductionSubIsoToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSubIsoToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(
-        problem.evaluate(&extracted),
+        problem.evaluate(&extracted).unwrap(),
         Or(true),
         "ILP solution should be a valid subgraph isomorphism"
     );
@@ -55,18 +58,20 @@ fn test_subgraphisomorphism_to_ilp_path_in_cycle() {
     // BruteForce on source
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("brute-force should find a solution");
-    assert_eq!(problem.evaluate(&bf_solution), Or(true));
+    assert_eq!(problem.evaluate(&bf_solution).unwrap(), Or(true));
 
     // Solve via ILP
-    let reduction: ReductionSubIsoToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSubIsoToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -75,10 +80,11 @@ fn test_subgraphisomorphism_to_ilp_infeasible() {
     let host = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let pattern = SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]);
     let problem = SubgraphIsomorphism::new(host, pattern);
-    let reduction: ReductionSubIsoToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSubIsoToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let result = ilp_solver.solve(reduction.target_problem());
-    assert!(result.is_none(), "K3 in path should be infeasible");
+    assert!(result.is_err(), "K3 in path should be infeasible");
 }
 
 #[test]
@@ -86,13 +92,14 @@ fn test_solution_extraction() {
     let host = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
     let pattern = SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]);
     let problem = SubgraphIsomorphism::new(host, pattern);
-    let reduction: ReductionSubIsoToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSubIsoToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver
         .solve(reduction.target_problem())
         .expect("solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
@@ -100,6 +107,7 @@ fn test_subgraphisomorphism_to_ilp_bf_vs_ilp() {
     let host = SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3), (3, 0)]);
     let pattern = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
     let problem = SubgraphIsomorphism::new(host, pattern);
-    let reduction: ReductionSubIsoToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSubIsoToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/subsetsum_closestvectorproblem.rs b/src/unit_tests/rules/subsetsum_closestvectorproblem.rs
index 818038c3a..f6f4b2f9a 100644
--- a/src/unit_tests/rules/subsetsum_closestvectorproblem.rs
+++ b/src/unit_tests/rules/subsetsum_closestvectorproblem.rs
@@ -1,78 +1,177 @@
 use super::*;
-use crate::models::algebraic::{ClosestVectorProblem, VarBounds};
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
-use crate::solvers::BruteForce;
+use crate::models::algebraic::ClosestVectorProblem;
 use crate::traits::Problem;
-use crate::types::Min;
-use std::collections::HashSet;
 
 #[test]
 fn test_subsetsum_to_closestvectorproblem_closed_loop() {
     let source = SubsetSum::new(vec![3u32, 7, 1, 8], 11u32);
-    let reduction = ReduceTo::<ClosestVectorProblem<i32>>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.num_basis_vectors(), 4);
-    assert_eq!(target.ambient_dimension(), 5);
-    assert_eq!(target.bounds(), &[VarBounds::binary(); 4]);
+    let reduction = ReduceTo::<ClosestVectorProblem<i64>>::reduce_to(&source).unwrap();
+    let target_solution =
+        crate::solvers::customized::closest_vector_problem::solve(reduction.target_problem())
+            .unwrap();
+    let source_solution = reduction.extract_solution(&target_solution).unwrap();
 
-    assert_satisfaction_round_trip_from_optimization_target(
-        &source,
-        &reduction,
-        "SubsetSum -> ClosestVectorProblem closed loop",
+    assert!(source.evaluate(&source_solution).unwrap().0);
+    assert_eq!(
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap()
+            .0,
+        Some(2.0)
     );
 }
 
 #[test]
 fn test_subsetsum_to_closestvectorproblem_structure() {
     let source = SubsetSum::new(vec![3u32, 7, 1, 8], 11u32);
-    let reduction = ReduceTo::<ClosestVectorProblem<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ClosestVectorProblem<i64>>::reduce_to(&source).unwrap();
     let target = reduction.target_problem();
 
-    assert_eq!(target.basis()[0], vec![1, 0, 0, 0, 3]);
-    assert_eq!(target.basis()[1], vec![0, 1, 0, 0, 7]);
-    assert_eq!(target.basis()[2], vec![0, 0, 1, 0, 1]);
-    assert_eq!(target.basis()[3], vec![0, 0, 0, 1, 8]);
-    assert_eq!(target.target(), &[0.5, 0.5, 0.5, 0.5, 11.0]);
+    let expected: serde_json::Value = serde_json::json!({"basis": [[1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1], [0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1], [0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1], [0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, -2, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -2, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -2]], "target": [0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1]});
+    assert_eq!(serde_json::to_value(target).unwrap(), expected);
+    assert_eq!(
+        ClosestVectorProblem::<i64>::variant(),
+        vec![("target", "i64")]
+    );
 }
 
 #[test]
-fn test_subsetsum_to_closestvectorproblem_issue_example_minimizers() {
+fn test_subsetsum_to_closestvectorproblem_binary_minimizers() {
     let source = SubsetSum::new(vec![3u32, 7, 1, 8], 11u32);
-    let reduction = ReduceTo::<ClosestVectorProblem<i32>>::reduce_to(&source);
+    let reduction = ReduceTo::<ClosestVectorProblem<i64>>::reduce_to(&source).unwrap();
     let target = reduction.target_problem();
-    let solutions: HashSet<Vec<usize>> = BruteForce::new()
-        .find_all_witnesses(target)
-        .into_iter()
-        .collect();
-
-    let expected: HashSet<Vec<usize>> = [vec![1, 0, 0, 1], vec![1, 1, 1, 0]].into_iter().collect();
-    assert_eq!(solutions, expected);
 
-    for solution in &solutions {
-        assert_eq!(target.evaluate(solution), Min(Some(1.0)));
+    for solution in [vec![1, 0, 0, 1, 0, 0, 0], vec![1, 1, 1, 0, 1, 1, 1]] {
+        assert_eq!(target.evaluate(&solution).unwrap().0, Some(2.0));
+        assert!(
+            source
+                .evaluate(&reduction.extract_solution(&solution).unwrap())
+                .unwrap()
+                .0
+        );
     }
 }
 
 #[test]
 fn test_subsetsum_to_closestvectorproblem_unsatisfiable_instance() {
     let source = SubsetSum::new(vec![2u32, 4, 6], 5u32);
-    let reduction = ReduceTo::<ClosestVectorProblem<i32>>::reduce_to(&source);
-    let target = reduction.target_problem();
-    let best = BruteForce::new()
-        .find_witness(target)
-        .expect("unsatisfiable instance should still have a best CVP assignment");
+    let reduction = ReduceTo::<ClosestVectorProblem<i64>>::reduce_to(&source).unwrap();
+    let solution =
+        crate::solvers::customized::closest_vector_problem::solve(reduction.target_problem())
+            .unwrap();
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&solution)
+            .unwrap()
+            .unwrap()
+            > (source.num_elements() as f64).sqrt()
+    );
+}
+
+#[test]
+fn test_subsetsum_to_closestvectorproblem_large_integers_and_unit_pivots() {
+    use num_bigint::BigUint;
+    let size = BigUint::from(1u32) << 70usize;
+    let source = SubsetSum::new(vec![size.clone()], size);
+    let result = ReduceTo::<ClosestVectorProblem<i64>>::reduce_to(&source).unwrap();
+    let mut witness = vec![0; result.target_problem().num_basis_vectors()];
+    witness[0] = 1;
+    assert_eq!(
+        result.target_problem().evaluate(&witness).unwrap(),
+        Min(Some(1.0))
+    );
+    assert_eq!(result.extract_solution(&witness).unwrap(), vec![true]);
+    assert!(result
+        .target_problem()
+        .basis()
+        .iter()
+        .flatten()
+        .all(|&x| (-2..=1).contains(&x)));
+
+    let source = SubsetSum::new(vec![1u32; 40], 20u32);
+    let result = ReduceTo::<ClosestVectorProblem<i64>>::reduce_to(&source).unwrap();
+    let mut witness = vec![0; result.target_problem().num_basis_vectors()];
+    witness[..20].fill(1);
+    witness[40..].copy_from_slice(&[1, 2, 5, 10]);
+    assert!(
+        source
+            .evaluate(&result.extract_solution(&witness).unwrap())
+            .unwrap()
+            .0
+    );
+}
 
-    let metric = target.evaluate(&best);
-    assert!(metric.is_valid(), "CVP solution should be valid");
-    assert!(metric.unwrap() > (source.num_elements() as f64).sqrt() / 2.0);
+#[test]
+fn test_subsetsum_to_closestvectorproblem_all_small_coefficients() {
+    for (sizes, target_sum) in [
+        (vec![], 0u32),
+        (vec![], 1),
+        (vec![1], 2),
+        (vec![1, 1], 2),
+        (vec![3, 7, 1], 11),
+        (vec![2, 4], 5),
+    ] {
+        let source = SubsetSum::new(sizes, target_sum);
+        let result = ReduceTo::<ClosestVectorProblem<i64>>::reduce_to(&source).unwrap();
+        let target = result.target_problem();
+        assert!(std::ptr::eq(
+            target,
+            crate::rules::AggregateReductionResult::target_problem(&result)
+        ));
+        let dimensions = target.num_basis_vectors();
+        let mut accepted = false;
+        for index in 0..4usize.pow(dimensions as u32) {
+            let mut index = index;
+            let config: Vec<i64> = (0..dimensions)
+                .map(|_| {
+                    let x = (index % 4) as i64 - 1;
+                    index /= 4;
+                    x
+                })
+                .collect();
+            let value = target.evaluate(&config).unwrap();
+            let certificate = value == Min(Some(result.target_distance));
+            assert_eq!(
+                crate::rules::AggregateReductionResult::extract_value(&result, value),
+                Or(certificate)
+            );
+            match result.extract_solution(&config) {
+                Ok(x) => {
+                    assert!(certificate);
+                    assert!(source.evaluate(&x).unwrap().0);
+                    accepted = true;
+                }
+                Err(_) => assert!(!certificate),
+            }
+        }
+        assert_eq!(
+            accepted,
+            crate::solvers::BruteForce::new()
+                .solve(&source)
+                .unwrap()
+                .is_some()
+        );
+        assert!(result.extract_solution(&vec![0; dimensions + 1]).is_err());
+        assert_eq!(
+            crate::rules::AggregateReductionResult::extract_value(&result, Min(None)),
+            Or(false)
+        );
+    }
 }
 
 #[test]
-#[should_panic(
-    expected = "SubsetSum -> ClosestVectorProblem requires all sizes and target to fit in i32"
-)]
-fn test_subsetsum_to_closestvectorproblem_panics_on_large_coefficients() {
-    let source = SubsetSum::new(vec![(i32::MAX as u64) + 1], 1u64);
-    let _ = ReduceTo::<ClosestVectorProblem<i32>>::reduce_to(&source);
+fn test_subsetsum_to_closestvectorproblem_dimension_boundaries() {
+    type R = ReductionSubsetSumToClosestVectorProblem;
+    assert_eq!(R::dimensions(4, 4).unwrap(), (4, 12, 7));
+    assert_eq!(R::dimensions(0, 1).unwrap(), (1, 1, 0));
+    assert!(R::dimensions(0, 0).is_err());
+    assert!(R::dimensions(usize::MAX, 2).is_err());
+    assert!(R::dimensions(usize::MAX, 1).is_err());
+    assert!(R::dimensions(usize::MAX / 2, 1).is_err());
+    if usize::BITS == 64 {
+        assert!(R::dimensions(1usize << 30, 1).is_err());
+        assert!(R::dimensions((1usize << 30) - 1, 1).is_ok());
+    }
 }
diff --git a/src/unit_tests/rules/subsetsum_integerexpressionmembership.rs b/src/unit_tests/rules/subsetsum_integerexpressionmembership.rs
index 87b3fe6a3..9caba9ab6 100644
--- a/src/unit_tests/rules/subsetsum_integerexpressionmembership.rs
+++ b/src/unit_tests/rules/subsetsum_integerexpressionmembership.rs
@@ -13,18 +13,19 @@ fn issue_example_source() -> SubsetSum {
     SubsetSum::new(vec![1u32, 5, 6, 8], 11u32)
 }
 
-fn issue_example_source_config() -> Vec<usize> {
-    vec![0, 1, 1, 0]
+fn issue_example_source_config() -> Vec<bool> {
+    vec![false, true, true, false]
 }
 
-fn issue_example_target_config() -> Vec<usize> {
-    vec![0, 1, 1, 0]
+fn issue_example_target_config() -> Vec<bool> {
+    vec![false, true, true, false]
 }
 
 #[test]
 fn test_subsetsum_to_integerexpressionmembership_closed_loop() {
     let source = issue_example_source();
-    let reduction = ReduceTo::<IntegerExpressionMembership>::reduce_to(&source);
+    let reduction = ReduceTo::<IntegerExpressionMembership>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     // 4 items -> 4 union nodes
@@ -42,23 +43,33 @@ fn test_subsetsum_to_integerexpressionmembership_closed_loop() {
 #[test]
 fn test_subsetsum_to_integerexpressionmembership_extract_solution_matches_choice_bits() {
     let source = issue_example_source();
-    let reduction = ReduceTo::<IntegerExpressionMembership>::reduce_to(&source);
+    let reduction = ReduceTo::<IntegerExpressionMembership>::reduce_to(&source)
+        .expect("reduction should succeed");
 
     assert_eq!(
-        reduction.extract_solution(&issue_example_target_config()),
+        reduction
+            .extract_solution(&issue_example_target_config())
+            .unwrap(),
         issue_example_source_config()
     );
-    assert_eq!(reduction.extract_solution(&[1, 0, 0, 1]), vec![1, 0, 0, 1]);
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![true, false, false, true])
+            .unwrap(),
+        vec![true, false, false, true]
+    );
 }
 
 #[test]
 fn test_subsetsum_to_integerexpressionmembership_unsatisfiable_instance_stays_unsatisfiable() {
     let source = SubsetSum::new(vec![2u32, 4, 6], 5u32);
-    let reduction = ReduceTo::<IntegerExpressionMembership>::reduce_to(&source);
+    let reduction = ReduceTo::<IntegerExpressionMembership>::reduce_to(&source)
+        .expect("reduction should succeed");
 
-    assert!(BruteForce::new().find_witness(&source).is_none());
+    assert!(BruteForce::new().solve(&source).unwrap().is_none());
     assert!(BruteForce::new()
-        .find_witness(reduction.target_problem())
+        .solve(reduction.target_problem())
+        .unwrap()
         .is_none());
 }
 
@@ -77,11 +88,11 @@ fn test_subsetsum_to_integerexpressionmembership_canonical_example_spec() {
     assert!(!example.solutions.is_empty());
     assert_eq!(
         example.solutions[0].source_config,
-        issue_example_source_config()
+        serde_json::json!(issue_example_source_config())
     );
     assert_eq!(
         example.solutions[0].target_config,
-        issue_example_target_config()
+        serde_json::json!(issue_example_target_config())
     );
 
     let source: SubsetSum = serde_json::from_value(example.source.instance.clone())
@@ -90,10 +101,10 @@ fn test_subsetsum_to_integerexpressionmembership_canonical_example_spec() {
         serde_json::from_value(example.target.instance.clone())
             .expect("target example deserializes");
 
-    assert!(source
-        .evaluate(&example.solutions[0].source_config)
-        .is_valid());
-    assert!(target
-        .evaluate(&example.solutions[0].target_config)
-        .is_valid());
+    let source_config: Vec<bool> =
+        serde_json::from_value(example.solutions[0].source_config.clone()).unwrap();
+    let target_config: Vec<bool> =
+        serde_json::from_value(example.solutions[0].target_config.clone()).unwrap();
+    assert!(source.evaluate(&source_config).unwrap().is_valid());
+    assert!(target.evaluate(&target_config).unwrap().is_valid());
 }
diff --git a/src/unit_tests/rules/subsetsum_integerknapsack.rs b/src/unit_tests/rules/subsetsum_integerknapsack.rs
index 82173dbed..15a2978f8 100644
--- a/src/unit_tests/rules/subsetsum_integerknapsack.rs
+++ b/src/unit_tests/rules/subsetsum_integerknapsack.rs
@@ -2,7 +2,7 @@
 use super::canonical_rule_example_specs;
 use crate::models::misc::SubsetSum;
 use crate::models::set::IntegerKnapsack;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Max;
 use num_traits::ToPrimitive;
@@ -31,16 +31,18 @@ fn subset_sum_embedding(source: &SubsetSum) -> IntegerKnapsack {
             .to_i64()
             .expect("test fixture target should fit in i64 for IntegerKnapsack"),
     )
+    .unwrap()
 }
 
 #[test]
 fn test_subsetsum_to_integerknapsack_forward_example() {
     let source = SubsetSum::new(vec![3u32, 7, 1, 8, 5], 16u32);
     let target = subset_sum_embedding(&source);
-    let source_witness = vec![1, 0, 0, 1, 1];
+    let source_witness = vec![true, false, false, true, true];
 
-    assert!(source.evaluate(&source_witness).is_valid());
-    assert_eq!(target.evaluate(&source_witness), Max(Some(16)));
+    assert!(source.evaluate(&source_witness).unwrap().is_valid());
+    let target_witness = source_witness.iter().copied().map(usize::from).collect();
+    assert_eq!(target.evaluate(&target_witness).unwrap(), Max(Some(16)));
 }
 
 #[test]
@@ -49,8 +51,13 @@ fn test_subsetsum_to_integerknapsack_counterexample_demonstrates_gap() {
     let target = subset_sum_embedding(&source);
     let solver = BruteForce::new();
 
-    assert!(solver.find_witness(&source).is_none());
-    assert_eq!(solver.solve(&target), Max(Some(6)));
+    assert!(solver.solve(&source).unwrap().is_none());
+    assert_eq!(
+        target
+            .evaluate(&solver.solve(&target).unwrap().unwrap())
+            .unwrap(),
+        Max(Some(6))
+    );
 }
 
 #[cfg(feature = "example-db")]
@@ -74,19 +81,24 @@ fn test_subsetsum_to_integerknapsack_canonical_example_spec() {
     );
     assert_eq!(example.target.instance["capacity"], 16);
     assert_eq!(example.solutions.len(), 1);
-    assert_eq!(example.solutions[0].source_config, vec![1, 0, 0, 1, 1]);
-    assert_eq!(example.solutions[0].target_config, vec![1, 0, 0, 1, 1]);
+    assert_eq!(
+        example.solutions[0].source_config,
+        serde_json::json!([true, false, false, true, true])
+    );
+    assert_eq!(
+        example.solutions[0].target_config,
+        serde_json::json!([1, 0, 0, 1, 1])
+    );
 
     let source: SubsetSum = serde_json::from_value(example.source.instance.clone())
         .expect("source example deserializes");
     let target: IntegerKnapsack = serde_json::from_value(example.target.instance.clone())
         .expect("target example deserializes");
 
-    assert!(source
-        .evaluate(&example.solutions[0].source_config)
-        .is_valid());
-    assert_eq!(
-        target.evaluate(&example.solutions[0].target_config),
-        Max(Some(16))
-    );
+    let source_config: Vec<bool> =
+        serde_json::from_value(example.solutions[0].source_config.clone()).unwrap();
+    let target_config: Vec<usize> =
+        serde_json::from_value(example.solutions[0].target_config.clone()).unwrap();
+    assert!(source.evaluate(&source_config).unwrap().is_valid());
+    assert_eq!(target.evaluate(&target_config).unwrap(), Max(Some(16)));
 }
diff --git a/src/unit_tests/rules/subsetsum_partition.rs b/src/unit_tests/rules/subsetsum_partition.rs
index cda81b51d..663dbd54e 100644
--- a/src/unit_tests/rules/subsetsum_partition.rs
+++ b/src/unit_tests/rules/subsetsum_partition.rs
@@ -11,7 +11,7 @@ use crate::traits::Problem;
 #[test]
 fn test_subsetsum_to_partition_closed_loop() {
     let source = SubsetSum::new(vec![1u32, 5, 6, 8], 11u32);
-    let reduction = ReduceTo::<Partition>::reduce_to(&source);
+    let reduction = ReduceTo::<Partition>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.sizes(), &[1, 5, 6, 8, 2]);
@@ -27,31 +27,46 @@ fn test_subsetsum_to_partition_closed_loop() {
 #[test]
 fn test_subsetsum_to_partition_sigma_greater_than_two_t_extraction() {
     let source = SubsetSum::new(vec![10u32, 20, 30], 10u32);
-    let reduction = ReduceTo::<Partition>::reduce_to(&source);
+    let reduction = ReduceTo::<Partition>::reduce_to(&source).expect("reduction should succeed");
 
     assert_eq!(reduction.target_problem().sizes(), &[10, 20, 30, 40]);
-    assert_eq!(reduction.extract_solution(&[1, 0, 0, 1]), vec![1, 0, 0]);
-    assert_eq!(reduction.extract_solution(&[0, 1, 1, 0]), vec![1, 0, 0]);
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![true, false, false, true])
+            .unwrap(),
+        vec![true, false, false]
+    );
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![false, true, true, false])
+            .unwrap(),
+        vec![true, false, false]
+    );
 }
 
 #[test]
 fn test_subsetsum_to_partition_sigma_equals_two_t_extraction() {
     let source = SubsetSum::new(vec![3u32, 5, 2, 6], 8u32);
-    let reduction = ReduceTo::<Partition>::reduce_to(&source);
+    let reduction = ReduceTo::<Partition>::reduce_to(&source).expect("reduction should succeed");
 
     assert_eq!(reduction.target_problem().sizes(), &[3, 5, 2, 6]);
-    assert_eq!(reduction.extract_solution(&[1, 1, 0, 0]), vec![1, 1, 0, 0]);
+    assert_eq!(
+        reduction
+            .extract_solution(&vec![true, true, false, false])
+            .unwrap(),
+        vec![true, true, false, false]
+    );
 }
 
 #[test]
 fn test_subsetsum_to_partition_unsatisfiable_instance_stays_unsatisfiable() {
     let source = SubsetSum::new(vec![3u32, 7, 11], 5u32);
-    let reduction = ReduceTo::<Partition>::reduce_to(&source);
+    let reduction = ReduceTo::<Partition>::reduce_to(&source).expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.sizes(), &[3, 7, 11, 11]);
-    assert!(BruteForce::new().find_witness(&source).is_none());
-    assert!(BruteForce::new().find_witness(target).is_none());
+    assert!(BruteForce::new().solve(&source).unwrap().is_none());
+    assert!(BruteForce::new().solve(target).unwrap().is_none());
 }
 
 #[cfg(feature = "example-db")]
@@ -70,18 +85,24 @@ fn test_subsetsum_to_partition_canonical_example_spec() {
         serde_json::json!([1, 5, 6, 8, 2])
     );
     assert_eq!(example.solutions.len(), 1);
-    assert_eq!(example.solutions[0].source_config, vec![0, 1, 1, 0]);
-    assert_eq!(example.solutions[0].target_config, vec![0, 1, 1, 0, 0]);
+    assert_eq!(
+        example.solutions[0].source_config,
+        serde_json::json!([false, true, true, false])
+    );
+    assert_eq!(
+        example.solutions[0].target_config,
+        serde_json::json!([false, true, true, false, false])
+    );
 
     let source: SubsetSum = serde_json::from_value(example.source.instance.clone())
         .expect("source example deserializes");
     let target: Partition = serde_json::from_value(example.target.instance.clone())
         .expect("target example deserializes");
 
-    assert!(source
-        .evaluate(&example.solutions[0].source_config)
-        .is_valid());
-    assert!(target
-        .evaluate(&example.solutions[0].target_config)
-        .is_valid());
+    let source_config: Vec<bool> =
+        serde_json::from_value(example.solutions[0].source_config.clone()).unwrap();
+    let target_config: Vec<bool> =
+        serde_json::from_value(example.solutions[0].target_config.clone()).unwrap();
+    assert!(source.evaluate(&source_config).unwrap().is_valid());
+    assert!(target.evaluate(&target_config).unwrap().is_valid());
 }
diff --git a/src/unit_tests/rules/sumofsquarespartition_ilp.rs b/src/unit_tests/rules/sumofsquarespartition_ilp.rs
index 8fb35803e..5827569bb 100644
--- a/src/unit_tests/rules/sumofsquarespartition_ilp.rs
+++ b/src/unit_tests/rules/sumofsquarespartition_ilp.rs
@@ -1,5 +1,5 @@
 use super::*;
-use crate::solvers::{BruteForce, ILPSolver, Solver};
+use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -7,17 +7,18 @@ use crate::types::Min;
 fn test_reduction_creates_valid_ilp() {
     // 3 elements, 2 groups
     let problem = SumOfSquaresPartition::new(vec![1, 2, 3], 2);
-    let reduction: ReductionSSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=3, K=2: num_vars = 3*2 + 3^2*2 = 6 + 18 = 24
-    assert_eq!(ilp.num_vars, 24, "Should have 24 variables (3*2 + 9*2)");
+    assert_eq!(ilp.num_vars(), 24, "Should have 24 variables (3*2 + 9*2)");
     // num_constraints = 3 assignment + 3*9*2 McCormick = 3 + 54 = 57
-    assert_eq!(ilp.constraints.len(), 57, "Should have 57 constraints");
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize, "Should minimize");
+    assert_eq!(ilp.constraints().len(), 57, "Should have 57 constraints");
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize, "Should minimize");
     // Objective should have non-empty coefficients
     assert!(
-        !ilp.objective.is_empty(),
+        !ilp.objective().is_empty(),
         "Objective should have coefficients"
     );
 }
@@ -30,15 +31,18 @@ fn test_sumofsquarespartition_to_ilp_bf_vs_ilp() {
     let bf = BruteForce::new();
     let ilp_solver = ILPSolver::new();
 
-    let bf_value = bf.solve(&problem);
+    let bf_value_solution = bf.solve(&problem).unwrap().unwrap();
+
+    let bf_value = problem.evaluate(&bf_value_solution).unwrap();
     // Optimal: {1,4}=5, {2,3}=5 -> 25+25=50
     assert_eq!(bf_value, Min(Some(50)));
 
-    let reduction: ReductionSSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let ilp_value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let ilp_value = problem.evaluate(&extracted).unwrap();
     assert_eq!(
         ilp_value, bf_value,
         "ILP solution should match brute-force optimal"
@@ -49,17 +53,18 @@ fn test_sumofsquarespartition_to_ilp_bf_vs_ilp() {
 fn test_solution_extraction() {
     // 4 elements, 2 groups
     let problem = SumOfSquaresPartition::new(vec![1, 2, 3, 4], 2);
-    let reduction: ReductionSSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     // element 0→g0, element 1→g1, element 2→g1, element 3→g0
     // x_{0,0}=1,x_{0,1}=0, x_{1,0}=0,x_{1,1}=1, x_{2,0}=0,x_{2,1}=1, x_{3,0}=1,x_{3,1}=0
     // Set x vars, leave z vars as 0 for extraction test
-    let mut ilp_solution = vec![0usize; 4 * 2 + 4 * 4 * 2];
+    let mut ilp_solution = vec![0_i64; 4 * 2 + 4 * 4 * 2];
     ilp_solution[0] = 1; // x_{0,0}
     ilp_solution[3] = 1; // x_{1,1}
     ilp_solution[5] = 1; // x_{2,1}
     ilp_solution[6] = 1; // x_{3,0}
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
     assert_eq!(extracted, vec![0, 1, 1, 0]);
 }
 
@@ -67,16 +72,30 @@ fn test_solution_extraction() {
 fn test_sumofsquarespartition_to_ilp_trivial() {
     // 2 elements, 2 groups, optimization
     let problem = SumOfSquaresPartition::new(vec![1, 2], 2);
-    let reduction: ReductionSSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionSSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=2, K=2: num_vars = 2*2 + 4*2 = 4+8 = 12
-    assert_eq!(ilp.num_vars, 12);
+    assert_eq!(ilp.num_vars(), 12);
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    let value = problem.evaluate(&extracted);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    let value = problem.evaluate(&extracted).unwrap();
     // Optimal: {1},{2} -> 1+4=5
     assert_eq!(value, Min(Some(5)));
 }
+
+#[test]
+fn test_sumofsquarespartition_to_ilp_requires_exact_mip_optimality() {
+    let problem = SumOfSquaresPartition::new(vec![85, 141, 61, 22, 123, 39], 3);
+    let reduction: ReductionSSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
+    let ilp_solution = ILPSolver::new()
+        .solve(reduction.target_problem())
+        .expect("ILP should prove the exact optimum");
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Min(Some(74129)));
+}
diff --git a/src/unit_tests/rules/threedimensionalmatching_ilp.rs b/src/unit_tests/rules/threedimensionalmatching_ilp.rs
index 0873a4b65..aaec26d1e 100644
--- a/src/unit_tests/rules/threedimensionalmatching_ilp.rs
+++ b/src/unit_tests/rules/threedimensionalmatching_ilp.rs
@@ -2,10 +2,10 @@ use super::*;
 use crate::models::algebraic::{Comparison, ObjectiveSense, ILP};
 use crate::models::misc::{ResourceConstrainedScheduling, ThreePartition};
 use crate::models::set::ThreeDimensionalMatching;
-use crate::rules::{MinimizeSteps, ReduceTo, ReductionGraph, ReductionResult};
-use crate::solvers::{BruteForce, ILPSolver};
+use crate::rules::{ReduceTo, ReductionGraph, ReductionResult};
+use crate::solvers::{BruteForce, ILPSolveError, ILPSolver};
 use crate::traits::Problem;
-use crate::types::{Or, ProblemSize};
+use crate::types::Or;
 
 fn canonical_problem() -> ThreeDimensionalMatching {
     ThreeDimensionalMatching::new(
@@ -18,7 +18,7 @@ fn singleton_problem() -> ThreeDimensionalMatching {
     ThreeDimensionalMatching::new(1, vec![(0, 0, 0)])
 }
 
-fn constraint_signature(constraint: &(Comparison, f64, Vec<(usize, f64)>)) -> String {
+fn constraint_signature(constraint: &(Comparison, i64, Vec<(usize, i64)>)) -> String {
     let cmp = match constraint.0 {
         Comparison::Le => "<=",
         Comparison::Ge => ">=",
@@ -27,47 +27,44 @@ fn constraint_signature(constraint: &(Comparison, f64, Vec<(usize, f64)>)) -> St
     let terms = constraint
         .2
         .iter()
-        .map(|&(var, coeff)| format!("{var}:{}", (coeff * 1_000_000.0).round() as i64))
+        .map(|&(variable, coefficient)| format!("{variable}:{coefficient}"))
         .collect::<Vec<_>>()
         .join(",");
-    format!(
-        "{cmp}|{}|{terms}",
-        (constraint.1 * 1_000_000.0).round() as i64
-    )
+    format!("{cmp}|{}|{terms}", constraint.1)
 }
 
 #[test]
 fn test_threedimensionalmatching_to_ilp_structure() {
     let problem = canonical_problem();
     let reduction: ReductionThreeDimensionalMatchingToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
-    assert_eq!(ilp.num_vars, 5);
-    assert_eq!(ilp.constraints.len(), 9);
-    assert!(ilp.objective.is_empty());
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 5);
+    assert_eq!(ilp.constraints().len(), 9);
+    assert!(ilp.objective().is_empty());
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 
-    type Constraint = (Comparison, f64, Vec<(usize, f64)>);
+    type Constraint = (Comparison, i64, Vec<(usize, i64)>);
     let actual_constraints: Vec<Constraint> = ilp
-        .constraints
+        .constraints()
         .iter()
         .map(|constraint| {
-            let mut terms = constraint.terms.clone();
+            let mut terms = constraint.terms().to_vec();
             terms.sort_by_key(|(var, _)| *var);
-            (constraint.cmp, constraint.rhs, terms)
+            (constraint.comparison(), constraint.rhs(), terms)
         })
         .collect();
     let expected_constraints = vec![
-        (Comparison::Eq, 1.0, vec![(0, 1.0), (3, 1.0)]),
-        (Comparison::Eq, 1.0, vec![(1, 1.0), (4, 1.0)]),
-        (Comparison::Eq, 1.0, vec![(2, 1.0)]),
-        (Comparison::Eq, 1.0, vec![(1, 1.0), (3, 1.0)]),
-        (Comparison::Eq, 1.0, vec![(0, 1.0)]),
-        (Comparison::Eq, 1.0, vec![(2, 1.0), (4, 1.0)]),
-        (Comparison::Eq, 1.0, vec![(2, 1.0), (3, 1.0)]),
-        (Comparison::Eq, 1.0, vec![(1, 1.0)]),
-        (Comparison::Eq, 1.0, vec![(0, 1.0), (4, 1.0)]),
+        (Comparison::Eq, 1, vec![(0, 1), (3, 1)]),
+        (Comparison::Eq, 1, vec![(1, 1), (4, 1)]),
+        (Comparison::Eq, 1, vec![(2, 1)]),
+        (Comparison::Eq, 1, vec![(1, 1), (3, 1)]),
+        (Comparison::Eq, 1, vec![(0, 1)]),
+        (Comparison::Eq, 1, vec![(2, 1), (4, 1)]),
+        (Comparison::Eq, 1, vec![(2, 1), (3, 1)]),
+        (Comparison::Eq, 1, vec![(1, 1)]),
+        (Comparison::Eq, 1, vec![(0, 1), (4, 1)]),
     ];
 
     let mut actual_signatures: Vec<_> = actual_constraints
@@ -88,34 +85,35 @@ fn test_threedimensionalmatching_to_ilp_structure() {
 fn test_threedimensionalmatching_to_ilp_closed_loop() {
     let problem = canonical_problem();
     let reduction: ReductionThreeDimensionalMatchingToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf_witness = BruteForce::new()
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("canonical 3DM instance should be feasible");
-    assert_eq!(bf_witness, vec![1, 1, 1, 0, 0]);
+    assert_eq!(bf_witness, vec![true, true, true, false, false]);
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("direct ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    assert_eq!(extracted, vec![1, 1, 1, 0, 0]);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(extracted, vec![true, true, true, false, false]);
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_threedimensionalmatching_to_ilp_infeasible_instance() {
     let problem = ThreeDimensionalMatching::new(2, vec![(0, 0, 0), (0, 1, 1)]);
     let reduction: ReductionThreeDimensionalMatchingToILP =
-        ReduceTo::<ILP<bool>>::reduce_to(&problem);
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     assert!(
-        BruteForce::new().find_witness(&problem).is_none(),
+        BruteForce::new().solve(&problem).unwrap().is_none(),
         "source instance should be infeasible"
     );
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "reduced ILP should be infeasible"
     );
 }
@@ -123,45 +121,41 @@ fn test_threedimensionalmatching_to_ilp_infeasible_instance() {
 #[test]
 fn test_threedimensionalmatching_to_ilp_direct_path_beats_indirect_chain() {
     let problem = singleton_problem();
-    let direct = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let direct = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    let to_three_partition = ReduceTo::<ThreePartition>::reduce_to(&problem);
+    let to_three_partition =
+        ReduceTo::<ThreePartition>::reduce_to(&problem).expect("reduction should succeed");
     let to_resource_constrained =
-        ReduceTo::<ResourceConstrainedScheduling>::reduce_to(to_three_partition.target_problem());
-    let indirect = ReduceTo::<ILP<bool>>::reduce_to(to_resource_constrained.target_problem());
+        ReduceTo::<ResourceConstrainedScheduling>::reduce_to(to_three_partition.target_problem())
+            .expect("reduction should succeed");
+    let indirect = ReduceTo::<ILP<bool>>::reduce_to(to_resource_constrained.target_problem())
+        .expect("reduction should succeed");
 
     let solver = ILPSolver::new();
     let direct_solution = solver
         .solve(direct.target_problem())
         .expect("direct ILP should solve");
-    let direct_source = direct.extract_solution(&direct_solution);
+    let direct_source = direct.extract_solution(&direct_solution).unwrap();
 
-    assert_eq!(problem.evaluate(&direct_source), Or(true));
+    assert_eq!(problem.evaluate(&direct_source).unwrap(), Or(true));
+    let indirect_solution = solver.solve(indirect.target_problem());
     assert!(
-        solver.solve(indirect.target_problem()).is_some(),
-        "indirect ILP should agree on feasibility"
+        matches!(indirect_solution, Err(ILPSolveError::Extraction(_))),
+        "the numerically unstable indirect ILP should be rejected: {indirect_solution:?}"
     );
-    assert!(direct.target_problem().num_vars < indirect.target_problem().num_vars);
+    assert!(direct.target_problem().num_vars() < indirect.target_problem().num_vars());
     assert!(
-        direct.target_problem().constraints.len() < indirect.target_problem().constraints.len()
+        direct.target_problem().constraints().len() < indirect.target_problem().constraints().len()
     );
 
     let graph = ReductionGraph::new();
     let src = ReductionGraph::variant_to_map(&ThreeDimensionalMatching::variant());
     let dst = ReductionGraph::variant_to_map(&ILP::<bool>::variant());
     let path = graph
-        .find_cheapest_path(
-            "ThreeDimensionalMatching",
-            &src,
-            "ILP",
-            &dst,
-            &ProblemSize::new(vec![
-                ("universe_size", problem.universe_size()),
-                ("num_triples", problem.num_triples()),
-            ]),
-            &MinimizeSteps,
-        )
-        .expect("reduction graph should find a direct 3DM -> ILP path");
+        .find_all_paths("ThreeDimensionalMatching", &src, "ILP", &dst)
+        .into_iter()
+        .find(|path| path.type_names() == ["ThreeDimensionalMatching", "ILP"])
+        .expect("reduction graph should contain the direct 3DM -> ILP path");
 
     assert_eq!(path.type_names(), vec!["ThreeDimensionalMatching", "ILP"]);
 }
diff --git a/src/unit_tests/rules/threedimensionalmatching_minimumweightdecoding.rs b/src/unit_tests/rules/threedimensionalmatching_minimumweightdecoding.rs
index 271cb910c..9b3edb61b 100644
--- a/src/unit_tests/rules/threedimensionalmatching_minimumweightdecoding.rs
+++ b/src/unit_tests/rules/threedimensionalmatching_minimumweightdecoding.rs
@@ -2,7 +2,7 @@ use super::*;
 use crate::models::algebraic::MinimumWeightDecoding;
 use crate::models::set::ThreeDimensionalMatching;
 use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
-use crate::solvers::{BruteForce, Solver};
+use crate::solvers::BruteForce;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -14,7 +14,8 @@ fn reduce_tdm(
     ReductionThreeDimensionalMatchingToMinimumWeightDecoding,
 ) {
     let source = ThreeDimensionalMatching::new(universe_size, triples);
-    let reduction = ReduceTo::<MinimumWeightDecoding>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<MinimumWeightDecoding>::reduce_to(&source).expect("reduction should succeed");
     (source, reduction)
 }
 
@@ -34,9 +35,9 @@ fn test_threedimensionalmatching_to_minimumweightdecoding_closed_loop() {
     let target_no = reduction_no.target_problem();
     let solver = BruteForce::new();
     // Confirm the target is infeasible.
-    assert!(solver.find_witness(target_no).is_none());
+    assert!(solver.solve(target_no).unwrap().is_none());
     // Confirm the source is infeasible.
-    assert!(solver.find_witness(&source_no).is_none());
+    assert!(solver.solve(&source_no).unwrap().is_none());
 
     // YES case: q = 3, exactly one perfect matching among five triples.
     let (source_y, reduction_y) = reduce_tdm(
@@ -84,7 +85,12 @@ fn test_threedimensionalmatching_to_minimumweightdecoding_optimal_value_yes() {
     let (_source, reduction) = reduce_tdm(2, vec![(0, 0, 0), (1, 1, 1), (0, 1, 0), (1, 0, 1)]);
     let target = reduction.target_problem();
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(target), Min(Some(2)));
+    assert_eq!(
+        target
+            .evaluate(&solver.solve(target).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(2))
+    );
 }
 
 #[test]
@@ -93,12 +99,12 @@ fn test_threedimensionalmatching_to_minimumweightdecoding_optimal_value_no() {
     let (_source, reduction) = reduce_tdm(2, vec![(0, 0, 0), (0, 0, 1), (1, 0, 0)]);
     let target = reduction.target_problem();
     let solver = BruteForce::new();
-    assert_eq!(solver.solve(target), Min(None));
+    assert!(solver.solve(target).unwrap().is_none());
 }
 
 #[test]
 fn test_threedimensionalmatching_to_minimumweightdecoding_sentinel_q_zero() {
-    // q = 0, T = []: sentinel target, extracted S = ∅, source.evaluate(∅) = Or(true).
+    // q = 0, T = []: sentinel target, extracted S = ∅, source.evaluate(∅).unwrap() = Or(true).
     let (source, reduction) = reduce_tdm(0, vec![]);
     let target = reduction.target_problem();
     assert_eq!(target.num_rows(), 1);
@@ -106,23 +112,23 @@ fn test_threedimensionalmatching_to_minimumweightdecoding_sentinel_q_zero() {
     assert_eq!(target.target(), &[false]);
 
     let solver = BruteForce::new();
-    let target_witnesses = solver.find_all_witnesses(target);
+    let target_witnesses = solver.find_all_witnesses(target).unwrap();
     assert!(!target_witnesses.is_empty());
     for witness in &target_witnesses {
         // Sentinel codeword is the all-zero vector of length 1.
-        assert_eq!(witness, &vec![0]);
-        let extracted = reduction.extract_solution(witness);
+        assert_eq!(witness, &vec![false]);
+        let extracted = reduction.extract_solution(witness).unwrap();
         // Source has 0 triples → extracted vector has length 0.
         assert_eq!(extracted.len(), source.num_triples());
-        assert_eq!(extracted, Vec::<usize>::new());
+        assert_eq!(extracted, Vec::<bool>::new());
         // Empty matching of empty universe is valid.
-        assert!(source.evaluate(&extracted).0);
+        assert!(source.evaluate(&extracted).unwrap().0);
     }
 }
 
 #[test]
 fn test_threedimensionalmatching_to_minimumweightdecoding_sentinel_no_triples() {
-    // q >= 1, T = []: sentinel target, extracted S = ∅, source.evaluate(∅) = Or(false).
+    // q >= 1, T = []: sentinel target, extracted S = ∅, source.evaluate(∅).unwrap() = Or(false).
     for q in [1, 2, 3] {
         let (source, reduction) = reduce_tdm(q, vec![]);
         let target = reduction.target_problem();
@@ -130,19 +136,19 @@ fn test_threedimensionalmatching_to_minimumweightdecoding_sentinel_no_triples()
         assert_eq!(target.num_cols(), 1);
 
         let solver = BruteForce::new();
-        let target_witnesses = solver.find_all_witnesses(target);
+        let target_witnesses = solver.find_all_witnesses(target).unwrap();
         assert!(!target_witnesses.is_empty());
         for witness in &target_witnesses {
-            let extracted = reduction.extract_solution(witness);
+            let extracted = reduction.extract_solution(witness).unwrap();
             assert_eq!(extracted.len(), source.num_triples());
             // Empty triple set cannot cover non-empty universe.
             assert!(
-                !source.evaluate(&extracted).0,
+                !source.evaluate(&extracted).unwrap().0,
                 "q = {q}, T = []: empty matching must be NO"
             );
         }
         // Direct solve confirms the source is NO.
-        assert!(solver.find_witness(&source).is_none());
+        assert!(solver.solve(&source).unwrap().is_none());
     }
 }
 
@@ -152,17 +158,24 @@ fn test_threedimensionalmatching_to_minimumweightdecoding_solution_extraction_id
     let (source, reduction) = reduce_tdm(2, vec![(0, 0, 0), (1, 1, 1), (0, 1, 0), (1, 0, 1)]);
     let target = reduction.target_problem();
     let solver = BruteForce::new();
-    let target_witnesses = solver.find_all_witnesses(target);
-    let source_witnesses: std::collections::HashSet<Vec<usize>> =
-        solver.find_all_witnesses(&source).into_iter().collect();
+    let target_witnesses = solver.find_all_witnesses(target).unwrap();
+    let source_witnesses: std::collections::HashSet<Vec<bool>> = solver
+        .find_all_witnesses(&source)
+        .unwrap()
+        .into_iter()
+        .collect();
 
     assert!(!target_witnesses.is_empty());
     for witness in &target_witnesses {
-        let extracted = reduction.extract_solution(witness);
+        let extracted = reduction.extract_solution(witness).unwrap();
         assert_eq!(extracted, *witness);
         assert!(
             source_witnesses.contains(&extracted),
             "extracted witness {extracted:?} must be a valid 3DM solution"
         );
     }
+
+    assert!(reduction
+        .extract_solution(&vec![false, true, false])
+        .is_err());
 }
diff --git a/src/unit_tests/rules/threedimensionalmatching_threematroidintersection.rs b/src/unit_tests/rules/threedimensionalmatching_threematroidintersection.rs
deleted file mode 100644
index e88f0b415..000000000
--- a/src/unit_tests/rules/threedimensionalmatching_threematroidintersection.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use crate::models::set::{ThreeDimensionalMatching, ThreeMatroidIntersection};
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
-use crate::rules::{MinimizeSteps, ReduceTo, ReductionGraph, ReductionResult};
-use crate::solvers::BruteForce;
-use crate::traits::Problem;
-use crate::types::ProblemSize;
-
-fn feasible_problem() -> ThreeDimensionalMatching {
-    ThreeDimensionalMatching::new(
-        3,
-        vec![(0, 0, 0), (1, 1, 1), (2, 2, 2), (0, 1, 2), (1, 2, 0)],
-    )
-}
-
-#[test]
-fn test_threedimensionalmatching_to_threematroidintersection_structure() {
-    let source = ThreeDimensionalMatching::new(2, vec![(0, 0, 0), (0, 1, 1), (1, 0, 1), (1, 1, 0)]);
-    let reduction = ReduceTo::<ThreeMatroidIntersection>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.ground_set_size(), source.num_triples());
-    assert_eq!(target.bound(), source.universe_size());
-    assert_eq!(
-        target.partitions(),
-        &[
-            vec![vec![0, 1], vec![2, 3]],
-            vec![vec![0, 2], vec![1, 3]],
-            vec![vec![0, 3], vec![1, 2]],
-        ]
-    );
-    assert_eq!(target.num_groups(), 6);
-}
-
-#[test]
-fn test_threedimensionalmatching_to_threematroidintersection_closed_loop() {
-    let source = feasible_problem();
-    let reduction = ReduceTo::<ThreeMatroidIntersection>::reduce_to(&source);
-
-    assert_satisfaction_round_trip_from_satisfaction_target(
-        &source,
-        &reduction,
-        "ThreeDimensionalMatching -> ThreeMatroidIntersection closed loop",
-    );
-}
-
-#[test]
-fn test_threedimensionalmatching_to_threematroidintersection_issue_no_instance() {
-    let source = ThreeDimensionalMatching::new(2, vec![(0, 0, 0), (0, 1, 1), (1, 0, 1), (1, 1, 0)]);
-    let reduction = ReduceTo::<ThreeMatroidIntersection>::reduce_to(&source);
-
-    assert!(
-        BruteForce::new().find_witness(&source).is_none(),
-        "issue example should have no perfect matching"
-    );
-    assert!(
-        BruteForce::new()
-            .find_witness(reduction.target_problem())
-            .is_none(),
-        "reduced 3-matroid intersection instance should be infeasible"
-    );
-}
-
-#[test]
-fn test_threedimensionalmatching_to_threematroidintersection_missing_coordinate_creates_empty_group(
-) {
-    let source = ThreeDimensionalMatching::new(2, vec![(0, 0, 0), (1, 0, 1)]);
-    let reduction = ReduceTo::<ThreeMatroidIntersection>::reduce_to(&source);
-    let target = reduction.target_problem();
-
-    assert_eq!(target.partitions()[1], vec![vec![0, 1], vec![]]);
-    assert!(
-        BruteForce::new().find_witness(target).is_none(),
-        "an empty coordinate group makes size-q independence impossible"
-    );
-}
-
-#[test]
-fn test_threedimensionalmatching_to_threematroidintersection_direct_path_exists() {
-    let source = feasible_problem();
-    let graph = ReductionGraph::new();
-    let src = ReductionGraph::variant_to_map(&ThreeDimensionalMatching::variant());
-    let dst = ReductionGraph::variant_to_map(&ThreeMatroidIntersection::variant());
-
-    let path = graph
-        .find_cheapest_path(
-            "ThreeDimensionalMatching",
-            &src,
-            "ThreeMatroidIntersection",
-            &dst,
-            &ProblemSize::new(vec![
-                ("universe_size", source.universe_size()),
-                ("num_triples", source.num_triples()),
-            ]),
-            &MinimizeSteps,
-        )
-        .expect("reduction graph should find the direct 3DM -> 3MI edge");
-
-    assert_eq!(
-        path.type_names(),
-        vec!["ThreeDimensionalMatching", "ThreeMatroidIntersection"]
-    );
-}
diff --git a/src/unit_tests/rules/threedimensionalmatching_threepartition.rs b/src/unit_tests/rules/threedimensionalmatching_threepartition.rs
index 3e5cb86b0..f9cb2913b 100644
--- a/src/unit_tests/rules/threedimensionalmatching_threepartition.rs
+++ b/src/unit_tests/rules/threedimensionalmatching_threepartition.rs
@@ -13,7 +13,8 @@ fn reduce(
     ReductionThreeDimensionalMatchingToThreePartition,
 ) {
     let source = ThreeDimensionalMatching::new(universe_size, triples.to_vec());
-    let reduction = ReduceTo::<ThreePartition>::reduce_to(&source);
+    let reduction =
+        ReduceTo::<ThreePartition>::reduce_to(&source).expect("reduction should succeed");
     (source, reduction)
 }
 
@@ -26,13 +27,13 @@ fn test_threedimensionalmatching_to_threepartition_q1_overhead_and_bounds() {
     assert_eq!(target.num_groups(), 7);
     assert_eq!(target.bound(), 42_949_673_924);
 
-    let bound = u128::from(target.bound());
-    let total_sum: u128 = target.sizes().iter().map(|&size| u128::from(size)).sum();
-    assert_eq!(total_sum, bound * target.num_groups() as u128);
+    let bound = i128::from(target.bound());
+    let total_sum: i128 = target.sizes().iter().map(|&size| i128::from(size)).sum();
+    assert_eq!(total_sum, bound * target.num_groups() as i128);
     assert!(target
         .sizes()
         .iter()
-        .all(|&size| 4 * u128::from(size) > bound && 2 * u128::from(size) < bound));
+        .all(|&size| 4 * i128::from(size) > bound && 2 * i128::from(size) < bound));
 }
 
 #[test]
@@ -55,11 +56,17 @@ fn test_threedimensionalmatching_to_threepartition_extracts_manual_q1_witness()
         0, 0, 1, 1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 2, 3, 4, 5, 6,
     ];
 
-    assert!(reduction.target_problem().evaluate(&target_config).0);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_config)
+            .unwrap()
+            .0
+    );
 
-    let extracted = reduction.extract_solution(&target_config);
-    assert_eq!(extracted, vec![1]);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&target_config).unwrap();
+    assert_eq!(extracted, vec![true]);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
@@ -67,10 +74,16 @@ fn test_threedimensionalmatching_to_threepartition_closed_loop_from_known_matchi
     let (source, reduction) = reduce(1, &[(0, 0, 0)]);
     let target_solution = reduction.build_target_witness(&[1]);
 
-    assert!(reduction.target_problem().evaluate(&target_solution).0);
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![1]);
-    assert!(source.evaluate(&extracted).0);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap()
+            .0
+    );
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![true]);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
@@ -78,11 +91,17 @@ fn test_threedimensionalmatching_to_threepartition_round_trip_q2_minimal_matchin
     let (source, reduction) = reduce(2, &[(0, 0, 0), (1, 1, 1)]);
     let target_solution = reduction.build_target_witness(&[1, 1]);
 
-    assert!(reduction.target_problem().evaluate(&target_solution).0);
+    assert!(
+        reduction
+            .target_problem()
+            .evaluate(&target_solution)
+            .unwrap()
+            .0
+    );
 
-    let extracted = reduction.extract_solution(&target_solution);
-    assert_eq!(extracted, vec![1, 1]);
-    assert!(source.evaluate(&extracted).0);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
+    assert_eq!(extracted, vec![true, true]);
+    assert!(source.evaluate(&extracted).unwrap().0);
 }
 
 #[test]
@@ -91,14 +110,15 @@ fn test_threedimensionalmatching_to_threepartition_uncovered_coordinate_maps_to_
     let (source, reduction) = reduce(2, &[(0, 0, 0), (0, 1, 1)]);
 
     assert!(
-        BruteForce::new().find_witness(&source).is_none(),
+        BruteForce::new().solve(&source).unwrap().is_none(),
         "source instance should be infeasible"
     );
     assert_eq!(reduction.target_problem().sizes(), &[6, 6, 6, 6, 7, 9]);
     assert_eq!(reduction.target_problem().bound(), 20);
     assert!(
         BruteForce::new()
-            .find_witness(reduction.target_problem())
+            .solve(reduction.target_problem())
+            .unwrap()
             .is_none(),
         "target instance should be infeasible"
     );
diff --git a/src/unit_tests/rules/threepartition_resourceconstrainedscheduling.rs b/src/unit_tests/rules/threepartition_resourceconstrainedscheduling.rs
index e33249f79..33bac8549 100644
--- a/src/unit_tests/rules/threepartition_resourceconstrainedscheduling.rs
+++ b/src/unit_tests/rules/threepartition_resourceconstrainedscheduling.rs
@@ -5,11 +5,12 @@ use crate::solvers::BruteForce;
 use crate::traits::Problem;
 
 fn reduce_three_partition(
-    sizes: &[u64],
-    bound: u64,
+    sizes: &[i64],
+    bound: i64,
 ) -> (ThreePartition, ReductionThreePartitionToRCS) {
     let source = ThreePartition::new(sizes.to_vec(), bound);
-    let reduction = ReduceTo::<ResourceConstrainedScheduling>::reduce_to(&source);
+    let reduction = ReduceTo::<ResourceConstrainedScheduling>::reduce_to(&source)
+        .expect("reduction should succeed");
     (source, reduction)
 }
 
@@ -19,8 +20,8 @@ fn assert_satisfiability_matches(
     expected: bool,
 ) {
     let solver = BruteForce::new();
-    assert_eq!(solver.find_witness(source).is_some(), expected);
-    assert_eq!(solver.find_witness(target).is_some(), expected);
+    assert_eq!(solver.solve(source).unwrap().is_some(), expected);
+    assert_eq!(solver.solve(target).unwrap().is_some(), expected);
 }
 
 #[test]
@@ -61,13 +62,13 @@ fn test_threepartition_to_resourceconstrainedscheduling_solution_extraction() {
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let target_solutions = solver.find_all_witnesses(target);
+    let target_solutions = solver.find_all_witnesses(target).unwrap();
 
     for sol in &target_solutions {
-        let extracted = reduction.extract_solution(sol);
+        let extracted = reduction.extract_solution(sol).unwrap();
         assert_eq!(extracted.len(), source.num_elements());
-        let target_valid = target.evaluate(sol);
-        let source_valid = source.evaluate(&extracted);
+        let target_valid = target.evaluate(sol).unwrap();
+        let source_valid = source.evaluate(&extracted).unwrap();
         if target_valid.0 {
             assert!(
                 source_valid.0,
diff --git a/src/unit_tests/rules/threepartition_sequencingwithreleasetimesanddeadlines.rs b/src/unit_tests/rules/threepartition_sequencingwithreleasetimesanddeadlines.rs
index 58deb0fa5..c7b85f5c7 100644
--- a/src/unit_tests/rules/threepartition_sequencingwithreleasetimesanddeadlines.rs
+++ b/src/unit_tests/rules/threepartition_sequencingwithreleasetimesanddeadlines.rs
@@ -2,11 +2,13 @@ use super::*;
 use crate::models::misc::{SequencingWithReleaseTimesAndDeadlines, ThreePartition};
 use crate::rules::test_helpers::assert_satisfaction_round_trip_from_satisfaction_target;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 
-fn reduce(sizes: Vec<u64>, bound: u64) -> (ThreePartition, ReductionThreePartitionToSRTD) {
+fn reduce(sizes: Vec<i64>, bound: i64) -> (ThreePartition, ReductionThreePartitionToSRTD) {
     let source = ThreePartition::new(sizes, bound);
-    let reduction = ReduceTo::<SequencingWithReleaseTimesAndDeadlines>::reduce_to(&source);
+    let reduction = ReduceTo::<SequencingWithReleaseTimesAndDeadlines>::reduce_to(&source)
+        .expect("reduction should succeed");
     (source, reduction)
 }
 
@@ -32,7 +34,7 @@ fn test_threepartition_to_sequencingwithreleasetimesanddeadlines_structure() {
     assert_eq!(target.num_tasks(), 7);
     assert_eq!(source.num_elements() + source.num_groups() - 1, 7);
 
-    // Element tasks: lengths match source sizes
+    // Element tasks: lengths match source parameterss
     let lengths = target.lengths();
     assert_eq!(&lengths[..6], &[4, 5, 6, 4, 6, 5]);
     // Filler task has length 1
@@ -59,9 +61,9 @@ fn test_threepartition_to_sequencingwithreleasetimesanddeadlines_satisfiability(
 
     let solver = BruteForce::new();
     // Source is satisfiable
-    assert!(solver.find_witness(&source).is_some());
+    assert!(solver.solve(&source).unwrap().is_some());
     // Target should also be satisfiable
-    assert!(solver.find_witness(target).is_some());
+    assert!(solver.solve(target).unwrap().is_some());
 }
 
 #[test]
@@ -70,12 +72,12 @@ fn test_threepartition_to_sequencingwithreleasetimesanddeadlines_solution_extrac
     let target = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let target_solutions = solver.find_all_witnesses(target);
+    let target_solutions = solver.find_all_witnesses(target).unwrap();
 
     for sol in &target_solutions {
-        let extracted = reduction.extract_solution(sol);
+        let extracted = reduction.extract_solution(sol).unwrap();
         assert_eq!(extracted.len(), source.num_elements());
-        let source_valid = source.evaluate(&extracted);
+        let source_valid = source.evaluate(&extracted).unwrap();
         assert!(
             source_valid.0,
             "Valid schedule should yield valid 3-partition"
@@ -89,6 +91,6 @@ fn test_threepartition_to_sequencingwithreleasetimesanddeadlines_dims() {
     let target = reduction.target_problem();
 
     // 7 tasks -> Lehmer dims [7,6,5,4,3,2,1]
-    let dims = target.dims();
+    let dims = target.dimensions();
     assert_eq!(dims, vec![7, 6, 5, 4, 3, 2, 1]);
 }
diff --git a/src/unit_tests/rules/timetabledesign_ilp.rs b/src/unit_tests/rules/timetabledesign_ilp.rs
index f4cdd9522..14fd854ac 100644
--- a/src/unit_tests/rules/timetabledesign_ilp.rs
+++ b/src/unit_tests/rules/timetabledesign_ilp.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::models::algebraic::ILP;
-use crate::rules::test_helpers::assert_satisfaction_round_trip_from_optimization_target;
+use crate::rules::test_helpers::assert_bf_vs_ilp;
 use crate::solvers::{BruteForce, ILPSolver};
 use crate::traits::Problem;
 use crate::types::Or;
@@ -16,13 +16,9 @@ fn test_timetabledesign_to_ilp_closed_loop() {
         vec![vec![true, true], vec![true, true]],
         vec![vec![1, 0], vec![0, 1]],
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
-    assert_satisfaction_round_trip_from_optimization_target(
-        &problem,
-        &reduction,
-        "TimetableDesign->ILP closed loop",
-    );
+    assert_bf_vs_ilp(&problem, &reduction);
 }
 
 #[test]
@@ -35,27 +31,28 @@ fn test_timetabledesign_to_ilp_bf_vs_ilp() {
         vec![vec![true, true], vec![true, true]],
         vec![vec![1, 0], vec![0, 1]],
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let bf_witness = BruteForce::new()
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("should be feasible");
-    assert_eq!(problem.evaluate(&bf_witness), Or(true));
+    assert_eq!(problem.evaluate(&bf_witness).unwrap(), Or(true));
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
 
 #[test]
 fn test_timetabledesign_to_ilp_infeasible() {
     // Craftsman 0 available only in period 0, but needs 2 periods of work with task 0
     let problem = TimetableDesign::new(1, 1, 1, vec![vec![true]], vec![vec![true]], vec![vec![2]]);
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible TD should produce infeasible ILP"
     );
 }
@@ -70,14 +67,24 @@ fn test_timetabledesign_to_ilp_identity_extraction() {
         vec![vec![true, true], vec![true, true]],
         vec![vec![1, 0], vec![0, 1]],
     );
-    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction = ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
 
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    // Identity extraction: ILP solution == source config
-    assert_eq!(extracted, ilp_solution);
-    assert_eq!(problem.evaluate(&extracted), Or(true));
+    assert_eq!(
+        extracted
+            .iter()
+            .flatten()
+            .flatten()
+            .copied()
+            .collect::<Vec<_>>(),
+        ilp_solution
+            .iter()
+            .map(|&value| value != 0)
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(problem.evaluate(&extracted).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/rules/traits.rs b/src/unit_tests/rules/traits.rs
index a7c1acd69..bfc64c583 100644
--- a/src/unit_tests/rules/traits.rs
+++ b/src/unit_tests/rules/traits.rs
@@ -4,8 +4,8 @@ fn test_traits_compile() {
 }
 
 use crate::rules::traits::{
-    AggregateReductionResult, DynAggregateReductionResult, ReduceTo, ReduceToAggregate,
-    ReductionResult,
+    validate_target_solution, AggregateReductionResult, DynAggregateReductionResult, ReduceTo,
+    ReduceToAggregate, ReductionResult,
 };
 use crate::traits::Problem;
 use crate::types::Sum;
@@ -16,31 +16,65 @@ struct SourceProblem;
 #[derive(Clone)]
 struct TargetProblem;
 
+impl SourceProblem {
+    fn num_variables(&self) -> usize {
+        2
+    }
+}
+
+impl TargetProblem {
+    fn num_variables(&self) -> usize {
+        2
+    }
+}
+
 impl Problem for SourceProblem {
     const NAME: &'static str = "Source";
-    type Value = i32;
-    fn dims(&self) -> Vec<usize> {
-        vec![2, 2]
-    }
-    fn evaluate(&self, config: &[usize]) -> i32 {
-        (config[0] + config[1]) as i32
+    type Solution = Vec<usize>;
+    type Value = i64;
+
+    crate::problem_parameters![("num_variables", num_variables)];
+    fn evaluate(&self, config: &Self::Solution) -> Result<i64, crate::traits::EvaluationError> {
+        if config.len() != 2 || config.iter().any(|&value| value >= 2) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "expected two binary target values".to_string(),
+            ));
+        }
+        Ok((config[0] + config[1]) as i64)
     }
     fn variant() -> Vec<(&'static str, &'static str)> {
-        vec![("graph", "SimpleGraph"), ("weight", "i32")]
+        vec![("graph", "SimpleGraph"), ("weight", "i64")]
     }
 }
 
-impl Problem for TargetProblem {
-    const NAME: &'static str = "Target";
-    type Value = i32;
-    fn dims(&self) -> Vec<usize> {
+impl crate::solvers::BruteForceProblem for SourceProblem {
+    fn dimensions(&self) -> Vec<usize> {
         vec![2, 2]
     }
-    fn evaluate(&self, config: &[usize]) -> i32 {
-        (config[0] + config[1]) as i32
+}
+
+impl Problem for TargetProblem {
+    const NAME: &'static str = "Target";
+    type Solution = Vec<usize>;
+    type Value = i64;
+
+    crate::problem_parameters![("num_variables", num_variables)];
+    fn evaluate(&self, config: &Self::Solution) -> Result<i64, crate::traits::EvaluationError> {
+        if config.len() != 2 || config.iter().any(|&value| value >= 2) {
+            return Err(crate::traits::EvaluationError::InvalidConfiguration(
+                "expected two binary target values".to_string(),
+            ));
+        }
+        Ok((config[0] + config[1]) as i64)
     }
     fn variant() -> Vec<(&'static str, &'static str)> {
-        vec![("graph", "SimpleGraph"), ("weight", "i32")]
+        vec![("graph", "SimpleGraph"), ("weight", "i64")]
+    }
+}
+
+impl crate::solvers::BruteForceProblem for TargetProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2, 2]
     }
 }
 
@@ -55,27 +89,68 @@ impl ReductionResult for TestReduction {
     fn target_problem(&self) -> &TargetProblem {
         &self.target
     }
-    fn extract_solution(&self, target_config: &[usize]) -> Vec<usize> {
-        target_config.to_vec()
+    fn extract_solution(
+        &self,
+        target_config: &<Self::Target as Problem>::Solution,
+    ) -> crate::rules::ExtractionResult<<Self::Source as Problem>::Solution> {
+        Ok(target_config.to_vec())
     }
 }
 
 impl ReduceTo<TargetProblem> for SourceProblem {
     type Result = TestReduction;
-    fn reduce_to(&self) -> TestReduction {
-        TestReduction {
+    fn reduce_to(&self) -> Result<TestReduction, crate::rules::ReductionError> {
+        Ok(TestReduction {
             target: TargetProblem,
-        }
+        })
     }
 }
 
 #[test]
 fn test_reduction() {
     let source = SourceProblem;
-    let result = <SourceProblem as ReduceTo<TargetProblem>>::reduce_to(&source);
+    let result = <SourceProblem as ReduceTo<TargetProblem>>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = result.target_problem();
-    assert_eq!(target.evaluate(&[1, 1]), 2);
-    assert_eq!(result.extract_solution(&[1, 0]), vec![1, 0]);
+    assert_eq!(target.evaluate(&vec![1, 1]).unwrap(), 2);
+    assert_eq!(result.extract_solution(&vec![1, 0]).unwrap(), vec![1, 0]);
+}
+
+#[test]
+fn target_solution_validation_rejects_shape_and_domain_errors() {
+    let target = TargetProblem;
+
+    assert_eq!(validate_target_solution(&target, &vec![1, 0]).unwrap(), 1);
+    assert!(validate_target_solution(&target, &vec![1]).is_err());
+    assert!(validate_target_solution(&target, &vec![1, 0, 0]).is_err());
+    assert!(validate_target_solution(&target, &vec![1, 2]).is_err());
+}
+
+#[test]
+fn aggregate_value_from_solution_keeps_evaluation_errors_distinct_from_false() {
+    use crate::models::decision::Decision;
+    use crate::models::graph::MinimumVertexCover;
+    use crate::rules::ExtractionError;
+    use crate::topology::SimpleGraph;
+    use crate::types::Or;
+
+    let source = Decision::new(
+        MinimumVertexCover::new(SimpleGraph::new(2, vec![(0, 1)]), vec![1i64; 2]),
+        0,
+    );
+    let reduction = source.reduce_to_aggregate().unwrap();
+    let value = reduction
+        .extract_value_from_solution_dyn(&vec![true, false])
+        .unwrap();
+    assert_eq!(value.downcast_ref::<Or>(), Some(&Or(false)));
+    assert!(matches!(
+        reduction.extract_value_from_solution_dyn(&vec![true]),
+        Err(ExtractionError::Evaluation(_))
+    ));
+    assert!(matches!(
+        reduction.extract_value_from_solution_dyn(&vec![1i64, 0]),
+        Err(ExtractionError::InvalidTargetSolution(_))
+    ));
 }
 
 #[derive(Clone)]
@@ -84,16 +159,30 @@ struct AggregateSourceProblem;
 #[derive(Clone)]
 struct AggregateTargetProblem;
 
+impl AggregateSourceProblem {
+    fn num_variables(&self) -> usize {
+        1
+    }
+}
+
+impl AggregateTargetProblem {
+    fn num_variables(&self) -> usize {
+        1
+    }
+}
+
 impl Problem for AggregateSourceProblem {
     const NAME: &'static str = "AggregateSource";
+    type Solution = Vec<usize>;
     type Value = Sum<u64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2]
-    }
+    crate::problem_parameters![("num_variables", num_variables)];
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Sum(config.iter().sum::<usize>() as u64)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok(Sum(config.iter().sum::<usize>() as u64))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -101,16 +190,24 @@ impl Problem for AggregateSourceProblem {
     }
 }
 
+impl crate::solvers::BruteForceProblem for AggregateSourceProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2]
+    }
+}
+
 impl Problem for AggregateTargetProblem {
     const NAME: &'static str = "AggregateTarget";
+    type Solution = Vec<usize>;
     type Value = Sum<u64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2]
-    }
+    crate::problem_parameters![("num_variables", num_variables)];
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Sum(config.iter().sum::<usize>() as u64)
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok(Sum(config.iter().sum::<usize>() as u64))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -118,6 +215,12 @@ impl Problem for AggregateTargetProblem {
     }
 }
 
+impl crate::solvers::BruteForceProblem for AggregateTargetProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2]
+    }
+}
+
 struct TestAggregateReduction {
     target: AggregateTargetProblem,
     offset: u64,
@@ -139,11 +242,11 @@ impl AggregateReductionResult for TestAggregateReduction {
 impl ReduceToAggregate<AggregateTargetProblem> for AggregateSourceProblem {
     type Result = TestAggregateReduction;
 
-    fn reduce_to_aggregate(&self) -> Self::Result {
-        TestAggregateReduction {
+    fn reduce_to_aggregate(&self) -> Result<Self::Result, crate::rules::ReductionError> {
+        Ok(TestAggregateReduction {
             target: AggregateTargetProblem,
             offset: 3,
-        }
+        })
     }
 }
 
@@ -153,7 +256,8 @@ fn test_aggregate_reduction_extracts_value() {
     let result =
         <AggregateSourceProblem as ReduceToAggregate<AggregateTargetProblem>>::reduce_to_aggregate(
             &source,
-        );
+        )
+        .expect("reduction should succeed");
 
     assert_eq!(result.extract_value(Sum(7)), Sum(10));
 }
diff --git a/src/unit_tests/rules/travelingsalesman_ilp.rs b/src/unit_tests/rules/travelingsalesman_ilp.rs
index cb0040030..d7c630715 100644
--- a/src/unit_tests/rules/travelingsalesman_ilp.rs
+++ b/src/unit_tests/rules/travelingsalesman_ilp.rs
@@ -4,7 +4,7 @@ use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::Min;
 
-fn k4_tsp() -> TravelingSalesman<SimpleGraph, i32> {
+fn k4_tsp() -> TravelingSalesman<SimpleGraph, i64> {
     TravelingSalesman::new(
         SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]),
         vec![10, 15, 20, 35, 25, 30],
@@ -14,34 +14,36 @@ fn k4_tsp() -> TravelingSalesman<SimpleGraph, i32> {
 #[test]
 fn test_reduction_creates_valid_ilp_c4() {
     // C4 cycle: 4 vertices, 4 edges. Unique Hamiltonian cycle (the cycle itself).
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         4,
         vec![(0, 1), (1, 2), (2, 3), (3, 0)],
     ));
-    let reduction: ReductionTSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionTSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // n=4, m=4: num_vars = 16 + 2*4*4 = 48
-    assert_eq!(ilp.num_vars, 48);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
+    assert_eq!(ilp.num_vars(), 48);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
 }
 
 #[test]
 fn test_reduction_c4_closed_loop() {
     // C4 cycle with unit weights: optimal tour cost = 4
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         4,
         vec![(0, 1), (1, 2), (2, 3), (3, 0)],
     ));
-    let reduction: ReductionTSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionTSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Verify extracted solution is valid on source problem
-    let metric = problem.evaluate(&extracted);
+    let metric = problem.evaluate(&extracted).unwrap();
     assert!(metric.is_valid(), "Extracted solution must be valid");
     assert_eq!(metric, Min(Some(4)));
 }
@@ -52,17 +54,18 @@ fn test_reduction_k4_weighted_closed_loop() {
     let problem = k4_tsp();
 
     // Solve via ILP reduction
-    let reduction: ReductionTSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionTSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Solve via brute force for cross-check
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    let bf_metric = problem.evaluate(&bf_solutions[0]);
-    let ilp_metric = problem.evaluate(&extracted);
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    let bf_metric = problem.evaluate(&bf_solutions[0]).unwrap();
+    let ilp_metric = problem.evaluate(&extracted).unwrap();
 
     assert!(ilp_metric.is_valid());
     assert_eq!(
@@ -74,18 +77,19 @@ fn test_reduction_k4_weighted_closed_loop() {
 #[test]
 fn test_reduction_c5_unweighted_closed_loop() {
     // C5 cycle with unit weights
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         5,
         vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)],
     ));
 
-    let reduction: ReductionTSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionTSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-    let metric = problem.evaluate(&extracted);
+    let metric = problem.evaluate(&extracted).unwrap();
     assert!(metric.is_valid());
     assert_eq!(metric, Min(Some(5)));
 }
@@ -93,18 +97,19 @@ fn test_reduction_c5_unweighted_closed_loop() {
 #[test]
 fn test_no_hamiltonian_cycle_infeasible() {
     // Path graph 0-1-2-3: no Hamiltonian cycle exists
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         4,
         vec![(0, 1), (1, 2), (2, 3)],
     ));
 
-    let reduction: ReductionTSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionTSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
     let ilp_solver = ILPSolver::new();
     let result = ilp_solver.solve(ilp);
 
     assert!(
-        result.is_none(),
+        result.is_err(),
         "Path graph should have no Hamiltonian cycle (infeasible ILP)"
     );
 }
@@ -112,48 +117,49 @@ fn test_no_hamiltonian_cycle_infeasible() {
 #[test]
 fn test_solution_extraction_structure() {
     // C4 cycle: verify extraction produces correct edge selection format
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         4,
         vec![(0, 1), (1, 2), (2, 3), (3, 0)],
     ));
-    let reduction: ReductionTSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionTSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let ilp_solver = ILPSolver::new();
     let ilp_solution = ilp_solver.solve(ilp).expect("ILP should be solvable");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // Should have one value per edge
     assert_eq!(extracted.len(), 4);
     // All edges should be selected (C4 has unique cycle = all edges)
-    assert_eq!(extracted.iter().sum::<usize>(), 4);
+    assert_eq!(extracted.iter().filter(|&&selected| selected).count(), 4);
 }
 
 #[test]
-fn test_solve_reduced() {
-    // Test via ILPSolver::solve_reduced
+fn test_solve_via_ilp_pipeline() {
     let problem = k4_tsp();
 
     let ilp_solver = ILPSolver::new();
     let solution = ilp_solver
-        .solve_reduced(&problem)
-        .expect("solve_reduced should work");
+        .solve(&problem)
+        .expect("ILP pipeline should solve the problem");
 
-    let metric = problem.evaluate(&solution);
+    let metric = problem.evaluate(&solution).unwrap();
     assert!(metric.is_valid());
 
     // Cross-check with brute force
     let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&problem);
-    assert_eq!(metric, problem.evaluate(&bf_solutions[0]));
+    let bf_solutions = bf.find_all_witnesses(&problem).unwrap();
+    assert_eq!(metric, problem.evaluate(&bf_solutions[0]).unwrap());
 }
 
 #[test]
 fn test_travelingsalesman_to_ilp_bf_vs_ilp() {
-    let problem = TravelingSalesman::<_, i32>::unit_weights(SimpleGraph::new(
+    let problem = TravelingSalesman::<_, i64>::unit_weights(SimpleGraph::new(
         4,
         vec![(0, 1), (1, 2), (2, 3), (3, 0)],
     ));
-    let reduction: ReductionTSPToILP = ReduceTo::<ILP<bool>>::reduce_to(&problem);
+    let reduction: ReductionTSPToILP =
+        ReduceTo::<ILP<bool>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/travelingsalesman_qubo.rs b/src/unit_tests/rules/travelingsalesman_qubo.rs
index 1095a6937..77199d7e3 100644
--- a/src/unit_tests/rules/travelingsalesman_qubo.rs
+++ b/src/unit_tests/rules/travelingsalesman_qubo.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::solvers::BruteForce;
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::Min;
 
@@ -7,17 +8,17 @@ use crate::types::Min;
 fn test_travelingsalesman_to_qubo_closed_loop() {
     // K3 complete graph with weights [1, 2, 3]
     let graph = SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]);
-    let tsp = TravelingSalesman::new(graph, vec![1i32, 2, 3]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&tsp);
+    let tsp = TravelingSalesman::new(graph, vec![1i64, 2, 3]);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&tsp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     // All QUBO solutions should extract to valid TSP solutions
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        let metric = tsp.evaluate(&extracted);
+        let extracted = reduction.extract_solution(sol).unwrap();
+        let metric = tsp.evaluate(&extracted).unwrap();
         assert!(metric.is_valid(), "Extracted solution should be valid");
         // K3 has only one Hamiltonian cycle (all 3 edges), cost = 1+2+3 = 6
         assert_eq!(metric, Min(Some(6)));
@@ -35,17 +36,17 @@ fn test_travelingsalesman_to_qubo_closed_loop() {
 fn test_travelingsalesman_to_qubo_k4() {
     // K4 with unit weights
     let graph = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
-    let tsp = TravelingSalesman::new(graph, vec![1i32; 6]);
-    let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&tsp);
+    let tsp = TravelingSalesman::new(graph, vec![1i64; 6]);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&tsp).expect("reduction should succeed");
     let qubo = reduction.target_problem();
 
     let solver = BruteForce::new();
-    let qubo_solutions = solver.find_all_witnesses(qubo);
+    let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
     // Every Hamiltonian cycle in K4 uses exactly 4 edges, so cost = 4
     for sol in &qubo_solutions {
-        let extracted = reduction.extract_solution(sol);
-        let metric = tsp.evaluate(&extracted);
+        let extracted = reduction.extract_solution(sol).unwrap();
+        let metric = tsp.evaluate(&extracted).unwrap();
         assert!(metric.is_valid(), "Extracted solution should be valid");
         assert_eq!(metric, Min(Some(4)));
     }
@@ -63,13 +64,25 @@ fn test_travelingsalesman_to_qubo_k4() {
 fn test_travelingsalesman_to_qubo_sizes() {
     // K3: n=3, QUBO should have n^2 = 9 variables
     let graph3 = SimpleGraph::new(3, vec![(0, 1), (0, 2), (1, 2)]);
-    let tsp3 = TravelingSalesman::new(graph3, vec![1i32; 3]);
-    let reduction3 = ReduceTo::<QUBO<f64>>::reduce_to(&tsp3);
+    let tsp3 = TravelingSalesman::new(graph3, vec![1i64; 3]);
+    let reduction3 = ReduceTo::<QUBO<i64>>::reduce_to(&tsp3).expect("reduction should succeed");
     assert_eq!(reduction3.target_problem().num_variables(), 9);
 
     // K4: n=4, QUBO should have n^2 = 16 variables
     let graph4 = SimpleGraph::new(4, vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]);
-    let tsp4 = TravelingSalesman::new(graph4, vec![1i32; 6]);
-    let reduction4 = ReduceTo::<QUBO<f64>>::reduce_to(&tsp4);
+    let tsp4 = TravelingSalesman::new(graph4, vec![1i64; 6]);
+    let reduction4 = ReduceTo::<QUBO<i64>>::reduce_to(&tsp4).expect("reduction should succeed");
     assert_eq!(reduction4.target_problem().num_variables(), 16);
 }
+
+#[test]
+fn test_travelingsalesman_to_qubo_weighted_corpus_regression() {
+    // Unequal tour costs expose a transposed vertex/position permutation.
+    let tsp = TravelingSalesman::new(SimpleGraph::complete(4), vec![9i64, 1, 2, 3, 4, 8]);
+    let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&tsp).unwrap();
+    crate::rules::test_helpers::assert_optimization_round_trip_from_optimization_target(
+        &tsp,
+        &reduction,
+        "weighted TSP position encoding",
+    );
+}
diff --git a/src/unit_tests/rules/undirectedflowlowerbounds_ilp.rs b/src/unit_tests/rules/undirectedflowlowerbounds_ilp.rs
index 2969919dd..feb60cb9b 100644
--- a/src/unit_tests/rules/undirectedflowlowerbounds_ilp.rs
+++ b/src/unit_tests/rules/undirectedflowlowerbounds_ilp.rs
@@ -33,13 +33,14 @@ fn infeasible_instance() -> UndirectedFlowLowerBounds {
 #[test]
 fn test_undirectedflowlowerbounds_to_ilp_structure() {
     let problem = feasible_instance();
-    let reduction: ReductionUFLBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionUFLBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 2 edges → 3*2 = 6 variables
-    assert_eq!(ilp.num_vars, 6);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 6);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(ilp.objective().is_empty());
 }
 
 #[test]
@@ -47,23 +48,25 @@ fn test_undirectedflowlowerbounds_to_ilp_closed_loop() {
     let problem = feasible_instance();
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("feasible instance has a witness");
     assert!(
-        problem.evaluate(&bf_solution).0,
+        problem.evaluate(&bf_solution).unwrap().0,
         "brute force solution is valid"
     );
 
-    let reduction: ReductionUFLBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionUFLBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     // extract_solution returns edge orientations z_e
     assert_eq!(extracted.len(), 2);
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "ILP extracted orientation should be a valid flow"
     );
 }
@@ -71,9 +74,10 @@ fn test_undirectedflowlowerbounds_to_ilp_closed_loop() {
 #[test]
 fn test_undirectedflowlowerbounds_to_ilp_infeasible() {
     let problem = infeasible_instance();
-    let reduction: ReductionUFLBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionUFLBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible instance should produce infeasible ILP"
     );
 }
@@ -81,16 +85,17 @@ fn test_undirectedflowlowerbounds_to_ilp_infeasible() {
 #[test]
 fn test_undirectedflowlowerbounds_to_ilp_extract_solution() {
     let problem = feasible_instance();
-    let reduction: ReductionUFLBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionUFLBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // f_{01}=1, f_{10}=0, f_{12}=1, f_{21}=0, z_0=1, z_1=1
     // z_e=1 means u→v direction; model expects config[e]=0 for u→v → extract returns 1-z_e
     let target_solution = vec![1, 0, 1, 0, 1, 1];
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     // z_0=1, z_1=1 → extracted = [1-1, 1-1] = [0, 0] (both u→v = 0→1 and 1→2)
-    assert_eq!(extracted, vec![0, 0]);
+    assert_eq!(extracted, vec![false, false]);
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "manually extracted orientation should be valid"
     );
 }
@@ -98,6 +103,7 @@ fn test_undirectedflowlowerbounds_to_ilp_extract_solution() {
 #[test]
 fn test_undirectedflowlowerbounds_to_ilp_bf_vs_ilp() {
     let problem = feasible_instance();
-    let reduction: ReductionUFLBToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionUFLBToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/undirectedtwocommodityintegralflow_ilp.rs b/src/unit_tests/rules/undirectedtwocommodityintegralflow_ilp.rs
index 398f8c485..1d8d087ed 100644
--- a/src/unit_tests/rules/undirectedtwocommodityintegralflow_ilp.rs
+++ b/src/unit_tests/rules/undirectedtwocommodityintegralflow_ilp.rs
@@ -38,20 +38,22 @@ fn infeasible_instance() -> UndirectedTwoCommodityIntegralFlow {
 #[test]
 fn test_undirectedtwocommodityintegralflow_to_ilp_structure() {
     let problem = feasible_instance();
-    let reduction: ReductionU2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionU2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     // 3 edges → 4 flow vars + 2 direction vars per edge = 18 variables.
-    assert_eq!(ilp.num_vars, 18);
-    assert_eq!(ilp.constraints.len(), 25);
-    assert_eq!(ilp.sense, ObjectiveSense::Minimize);
-    assert!(ilp.objective.is_empty());
+    assert_eq!(ilp.num_vars(), 18);
+    assert_eq!(ilp.constraints().len(), 27);
+    assert_eq!(ilp.sense(), ObjectiveSense::Minimize);
+    assert!(ilp.objective().is_empty());
 }
 
 #[test]
 fn test_undirectedtwocommodityintegralflow_to_ilp_overhead_matches_target() {
     let problem = feasible_instance();
-    let reduction: ReductionU2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionU2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp = reduction.target_problem();
 
     let entry = inventory::iter::<crate::rules::ReductionEntry>()
@@ -61,13 +63,26 @@ fn test_undirectedtwocommodityintegralflow_to_ilp_overhead_matches_target() {
                 && entry
                     .target_variant()
                     .iter()
-                    .any(|(key, value)| *key == "variable" && *value == "i32")
+                    .any(|(key, value)| *key == "variable" && *value == "i64")
         })
-        .expect("U2CIF -> ILP<i32> reduction should be registered");
+        .expect("U2CIF -> ILP<i64> reduction should be registered");
 
-    let overhead = (entry.overhead_eval_fn)(&problem as &dyn std::any::Any);
-    assert_eq!(overhead.get("num_vars"), Some(ilp.num_vars));
-    assert_eq!(overhead.get("num_constraints"), Some(ilp.constraints.len()));
+    let source_size = problem.parameters();
+    let predicted = entry
+        .parameter_contract()
+        .unwrap()
+        .transform()
+        .unwrap()
+        .evaluate(&source_size)
+        .unwrap();
+    assert_eq!(
+        predicted.get("num_vars"),
+        Some(ilp.num_vars().try_into().unwrap())
+    );
+    assert_eq!(
+        predicted.get("num_constraints"),
+        Some(ilp.constraints().len().try_into().unwrap())
+    );
 }
 
 #[test]
@@ -75,21 +90,23 @@ fn test_undirectedtwocommodityintegralflow_to_ilp_closed_loop() {
     let problem = feasible_instance();
     let bf = BruteForce::new();
     let bf_solution = bf
-        .find_witness(&problem)
+        .solve(&problem)
+        .unwrap()
         .expect("feasible instance has a witness");
     assert!(
-        problem.evaluate(&bf_solution).0,
+        problem.evaluate(&bf_solution).unwrap().0,
         "brute force solution is valid"
     );
 
-    let reduction: ReductionU2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionU2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     let ilp_solution = ILPSolver::new()
         .solve(reduction.target_problem())
         .expect("ILP should be feasible");
-    let extracted = reduction.extract_solution(&ilp_solution);
+    let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "ILP extracted solution should be a valid flow"
     );
 }
@@ -97,17 +114,36 @@ fn test_undirectedtwocommodityintegralflow_to_ilp_closed_loop() {
 #[test]
 fn test_undirectedtwocommodityintegralflow_to_ilp_infeasible() {
     let problem = infeasible_instance();
-    let reduction: ReductionU2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionU2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     assert!(
-        ILPSolver::new().solve(reduction.target_problem()).is_none(),
+        ILPSolver::new().solve(reduction.target_problem()).is_err(),
         "infeasible flow instance should yield infeasible ILP"
     );
 }
 
+#[test]
+fn test_other_commodity_source_cannot_create_flow() {
+    let problem = UndirectedTwoCommodityIntegralFlow::new(
+        SimpleGraph::new(4, vec![(1, 3)]),
+        vec![2],
+        0,
+        3,
+        1,
+        3,
+        1,
+        0,
+    );
+    let reduction: ReductionU2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
+    assert!(ILPSolver::new().solve(reduction.target_problem()).is_err());
+}
+
 #[test]
 fn test_undirectedtwocommodityintegralflow_to_ilp_extract_solution() {
     let problem = feasible_instance();
-    let reduction: ReductionU2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionU2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
 
     // Manual solution: edge 0 (0,2): f1_uv=1, f1_vu=0, f2_uv=0, f2_vu=0
     // edge 1 (1,2): f1_uv=0, f1_vu=0, f2_uv=1, f2_vu=0
@@ -121,11 +157,11 @@ fn test_undirectedtwocommodityintegralflow_to_ilp_extract_solution() {
         0, 1, // d1_1=0, d2_1=1
         1, 1, // d1_2=1, d2_2=1
     ];
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
     // extract_solution returns first 4*3=12 flow variables
     assert_eq!(extracted.len(), 12);
     assert!(
-        problem.evaluate(&extracted).0,
+        problem.evaluate(&extracted).unwrap().0,
         "manually extracted solution should be valid"
     );
 }
@@ -133,6 +169,7 @@ fn test_undirectedtwocommodityintegralflow_to_ilp_extract_solution() {
 #[test]
 fn test_undirectedtwocommodityintegralflow_to_ilp_bf_vs_ilp() {
     let problem = feasible_instance();
-    let reduction: ReductionU2CIFToILP = ReduceTo::<ILP<i32>>::reduce_to(&problem);
+    let reduction: ReductionU2CIFToILP =
+        ReduceTo::<ILP<i64>>::reduce_to(&problem).expect("reduction should succeed");
     crate::rules::test_helpers::assert_bf_vs_ilp(&problem, &reduction);
 }
diff --git a/src/unit_tests/rules/unitdiskmapping/alpha_tensor.rs b/src/unit_tests/rules/unitdiskmapping/alpha_tensor.rs
deleted file mode 100644
index d48d99f6e..000000000
--- a/src/unit_tests/rules/unitdiskmapping/alpha_tensor.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-use super::*;
-
-#[test]
-fn test_simple_path_alpha_tensor() {
-    // Path graph: 0-1-2, all weight 1, pins = [0, 2]
-    let edges = vec![(0, 1), (1, 2)];
-    let weights = vec![1, 1, 1];
-    let pins = vec![0, 2];
-
-    let tensor = compute_alpha_tensor(3, &edges, &weights, &pins);
-
-    // Config 0b00: neither pin in IS -> MIS can include vertex 1 -> MIS = 1
-    // Config 0b01: pin 0 (vertex 0) in -> vertex 1 blocked -> MIS = 1
-    // Config 0b10: pin 1 (vertex 2) in -> vertex 1 blocked -> MIS = 1
-    // Config 0b11: both pins in -> vertices 0,2 in IS, vertex 1 blocked -> MIS = 2
-    assert_eq!(tensor, vec![1, 1, 1, 2]);
-}
-
-#[test]
-fn test_triangle_alpha_tensor() {
-    // Triangle: 0-1, 1-2, 0-2, all weight 1, pins = [0, 1, 2]
-    let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let weights = vec![1, 1, 1];
-    let pins = vec![0, 1, 2];
-
-    let tensor = compute_alpha_tensor(3, &edges, &weights, &pins);
-
-    // When all vertices are pins:
-    // 0b000: all pins forced OUT -> no vertices available -> MIS = 0
-    // 0b001: vertex 0 in, others forced out -> MIS = 1
-    // 0b010: vertex 1 in, others forced out -> MIS = 1
-    // 0b011: vertices 0,1 in -> INVALID (adjacent) -> i32::MIN
-    // 0b100: vertex 2 in, others forced out -> MIS = 1
-    // 0b101: vertices 0,2 in -> INVALID (adjacent) -> i32::MIN
-    // 0b110: vertices 1,2 in -> INVALID (adjacent) -> i32::MIN
-    // 0b111: all in -> INVALID (all adjacent) -> i32::MIN
-    assert_eq!(
-        tensor,
-        vec![0, 1, 1, i32::MIN, 1, i32::MIN, i32::MIN, i32::MIN]
-    );
-}
-
-#[test]
-fn test_mis_compactify_simple() {
-    // From path graph test
-    let mut tensor = vec![1, 1, 1, 2];
-    mis_compactify(&mut tensor);
-
-    // Entry 0b00 (val=1): is it dominated?
-    // - By 0b01 (val=1)? (0b01 & 0b00) == 0b00 != 0b01, NO
-    // - By 0b10 (val=1)? (0b10 & 0b00) == 0b00 != 0b10, NO
-    // - By 0b11 (val=2)? (0b11 & 0b00) == 0b00 != 0b11, NO
-    // Entry 0b01 (val=1):
-    // - By 0b11 (val=2)? (0b11 & 0b01) == 0b01, but val=1 <= val=2, YES dominated
-    // Entry 0b10 (val=1):
-    // - By 0b11 (val=2)? (0b11 & 0b10) == 0b10, but val=1 <= val=2, YES dominated
-
-    // After compactify: entries 0b01 and 0b10 should be i32::MIN
-    assert_eq!(tensor[0], 1); // 0b00 not dominated
-    assert_eq!(tensor[1], i32::MIN); // 0b01 dominated by 0b11
-    assert_eq!(tensor[2], i32::MIN); // 0b10 dominated by 0b11
-    assert_eq!(tensor[3], 2); // 0b11 not dominated
-}
-
-#[test]
-fn test_is_diff_by_const() {
-    let t1 = vec![3, i32::MIN, i32::MIN, 5];
-    let t2 = vec![2, i32::MIN, i32::MIN, 4];
-
-    let (is_equiv, diff) = is_diff_by_const(&t1, &t2);
-    assert!(is_equiv);
-    assert_eq!(diff, 1); // 3-2 = 1, 5-4 = 1
-
-    let t3 = vec![3, i32::MIN, i32::MIN, 6];
-    let (is_equiv2, _) = is_diff_by_const(&t1, &t3);
-    assert!(!is_equiv2); // 3-3=0, 5-6=-1, not constant
-}
-
-#[test]
-fn test_weighted_mis_exhaustive() {
-    // Path: 0-1-2, weights [3, 1, 3]
-    let edges = vec![(0, 1), (1, 2)];
-    let weights = vec![3, 1, 3];
-
-    let mis = weighted_mis_exhaustive(3, &edges, &weights);
-    assert_eq!(mis, 6); // Select vertices 0 and 2
-}
-
-#[test]
-fn test_triangular_unit_disk_edges() {
-    // Simple case: two adjacent nodes on triangular lattice
-    // Nodes at (1, 1) and (1, 2) should be connected (distance ~0.866)
-    let locs = vec![(1, 1), (1, 2)];
-    let edges = build_triangular_unit_disk_edges(&locs);
-    assert_eq!(edges.len(), 1);
-    assert_eq!(edges[0], (0, 1));
-
-    // Nodes at (1, 1) and (3, 1) should NOT be connected (distance = 2)
-    let locs2 = vec![(1, 1), (3, 1)];
-    let edges2 = build_triangular_unit_disk_edges(&locs2);
-    assert_eq!(edges2.len(), 0);
-}
-
-#[test]
-fn test_verify_tri_turn() {
-    use super::super::triangular::TriTurn;
-
-    let gadget = TriTurn;
-    let result = verify_triangular_gadget(&gadget);
-    assert!(result.is_ok(), "TriTurn verification failed: {:?}", result);
-}
-
-#[test]
-fn test_verify_tri_cross_false() {
-    use super::super::triangular::TriCross;
-
-    let gadget = TriCross::<false>;
-    let result = verify_triangular_gadget(&gadget);
-    assert!(
-        result.is_ok(),
-        "TriCross<false> verification failed: {:?}",
-        result
-    );
-}
-
-#[test]
-fn test_verify_tri_cross_true() {
-    use super::super::triangular::TriCross;
-
-    let gadget = TriCross::<true>;
-    let result = verify_triangular_gadget(&gadget);
-    assert!(
-        result.is_ok(),
-        "TriCross<true> verification failed: {:?}",
-        result
-    );
-}
-
-#[test]
-fn test_verify_tri_branch() {
-    use super::super::triangular::TriBranch;
-
-    let gadget = TriBranch;
-    let result = verify_triangular_gadget(&gadget);
-    assert!(
-        result.is_ok(),
-        "TriBranch verification failed: {:?}",
-        result
-    );
-}
-
-#[test]
-fn test_verify_tri_tcon_left() {
-    use super::super::triangular::TriTConLeft;
-
-    let gadget = TriTConLeft;
-    let result = verify_triangular_gadget(&gadget);
-    assert!(
-        result.is_ok(),
-        "TriTConLeft verification failed: {:?}",
-        result
-    );
-}
diff --git a/src/unit_tests/rules/unitdiskmapping/copyline.rs b/src/unit_tests/rules/unitdiskmapping/copyline.rs
index 41e15721b..a5a3259b5 100644
--- a/src/unit_tests/rules/unitdiskmapping/copyline.rs
+++ b/src/unit_tests/rules/unitdiskmapping/copyline.rs
@@ -1,11 +1,12 @@
 use super::*;
+use crate::rules::ReductionError;
 
 #[test]
 fn test_create_copylines_path() {
     // Path graph: 0-1-2
     let edges = vec![(0, 1), (1, 2)];
     let order = vec![0, 1, 2];
-    let lines = create_copylines(3, &edges, &order);
+    let lines = create_copylines(3, &edges, &order).unwrap();
 
     assert_eq!(lines.len(), 3);
     // Each vertex gets a copy line
@@ -32,15 +33,35 @@ fn test_copyline_locations() {
 fn test_create_copylines_empty() {
     let edges: Vec<(usize, usize)> = vec![];
     let order: Vec<usize> = vec![];
-    let lines = create_copylines(0, &edges, &order);
+    let lines = create_copylines(0, &edges, &order).unwrap();
     assert!(lines.is_empty());
 }
 
+#[test]
+fn test_create_copylines_rejects_invalid_vertex_order() {
+    let error = create_copylines(2, &[(0, 1)], &[0, 0]).unwrap_err();
+    assert!(matches!(
+        error,
+        ReductionError::InvalidTarget { message, .. }
+            if message == "vertex_order must contain every vertex exactly once"
+    ));
+}
+
+#[test]
+fn test_create_copylines_rejects_invalid_edge_endpoint() {
+    let error = create_copylines(2, &[(0, 2)], &[0, 1]).unwrap_err();
+    assert!(matches!(
+        error,
+        ReductionError::InvalidTarget { message, .. }
+            if message == "edge endpoints must be valid vertices"
+    ));
+}
+
 #[test]
 fn test_create_copylines_single_vertex() {
     let edges: Vec<(usize, usize)> = vec![];
     let order = vec![0];
-    let lines = create_copylines(1, &edges, &order);
+    let lines = create_copylines(1, &edges, &order).unwrap();
 
     assert_eq!(lines.len(), 1);
     assert_eq!(lines[0].vertex, 0);
@@ -52,7 +73,7 @@ fn test_create_copylines_triangle() {
     // Triangle: 0-1, 1-2, 0-2
     let edges = vec![(0, 1), (1, 2), (0, 2)];
     let order = vec![0, 1, 2];
-    let lines = create_copylines(3, &edges, &order);
+    let lines = create_copylines(3, &edges, &order).unwrap();
 
     assert_eq!(lines.len(), 3);
     // Vertex 0 should have hstop reaching to vertex 2's slot
@@ -88,9 +109,19 @@ fn test_mis_overhead_copyline() {
     let spacing = 4;
     let padding = 2;
     let locs = line.copyline_locations(padding, spacing);
-    let overhead = mis_overhead_copyline(&line, spacing, padding);
+    let overhead = mis_overhead_copyline(&line, spacing, padding).unwrap();
     // Julia formula for UnWeighted mode: length(locs) / 2
-    assert_eq!(overhead, locs.len() / 2);
+    assert_eq!(overhead, i64::try_from(locs.len() / 2).unwrap());
+}
+
+#[test]
+fn test_triangular_mis_overhead_reports_overflow() {
+    let line = CopyLine::new(0, 0, usize::MAX, 0, usize::MAX, usize::MAX);
+
+    assert!(matches!(
+        mis_overhead_copyline_triangular(&line, usize::MAX),
+        Err(ReductionError::IntegerOverflow { .. })
+    ));
 }
 
 #[test]
@@ -106,7 +137,7 @@ fn test_create_copylines_star() {
     // Star graph: 0 connected to 1, 2, 3
     let edges = vec![(0, 1), (0, 2), (0, 3)];
     let order = vec![0, 1, 2, 3];
-    let lines = create_copylines(4, &edges, &order);
+    let lines = create_copylines(4, &edges, &order).unwrap();
 
     assert_eq!(lines.len(), 4);
     // Vertex 0 (center) should have hstop reaching the last neighbor
@@ -204,10 +235,10 @@ fn test_mis_overhead_julia_cases() {
     for (vstart, vstop, hstop) in test_cases {
         let line = CopyLine::new(1, 5, 5, vstart, vstop, hstop);
         let locs = line.copyline_locations(padding, spacing);
-        let overhead = mis_overhead_copyline(&line, spacing, padding);
+        let overhead = mis_overhead_copyline(&line, spacing, padding).unwrap();
 
         // UnWeighted formula: length(locs) / 2
-        let expected = locs.len() / 2;
+        let expected = i64::try_from(locs.len() / 2).unwrap();
 
         assert_eq!(
             overhead, expected,
@@ -239,7 +270,7 @@ fn test_create_copylines_petersen() {
     ];
     let order: Vec<usize> = (0..10).collect();
 
-    let lines = create_copylines(10, &edges, &order);
+    let lines = create_copylines(10, &edges, &order).unwrap();
 
     // Verify all lines are created
     assert_eq!(lines.len(), 10);
diff --git a/src/unit_tests/rules/unitdiskmapping/ksg/mapping.rs b/src/unit_tests/rules/unitdiskmapping/ksg/mapping.rs
index 3ff87611e..e97765904 100644
--- a/src/unit_tests/rules/unitdiskmapping/ksg/mapping.rs
+++ b/src/unit_tests/rules/unitdiskmapping/ksg/mapping.rs
@@ -4,10 +4,7 @@ use super::*;
 fn test_embed_graph_path() {
     // Path graph: 0-1-2
     let edges = vec![(0, 1), (1, 2)];
-    let result = embed_graph(3, &edges, &[0, 1, 2]);
-
-    assert!(result.is_some());
-    let grid = result.unwrap();
+    let grid = embed_graph(3, &edges, &[0, 1, 2]).unwrap();
     assert!(!grid.occupied_coords().is_empty());
 }
 
@@ -15,8 +12,7 @@ fn test_embed_graph_path() {
 fn test_map_unweighted_triangle() {
     // Triangle graph
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = map_unweighted(3, &edges);
-
+    let result = map_unweighted(3, &edges).unwrap();
     assert!(!result.positions.is_empty());
     // mis_overhead can be negative due to gadgets, so we just verify the function completes
 }
@@ -25,35 +21,40 @@ fn test_map_unweighted_triangle() {
 fn test_map_weighted_triangle() {
     // Triangle graph
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = map_weighted(3, &edges);
-
+    let result = map_weighted(3, &edges).unwrap();
     assert!(!result.positions.is_empty());
 }
 
 #[test]
 fn test_mapping_result_config_back_unweighted() {
     let edges = vec![(0, 1)];
-    let result = map_unweighted(2, &edges);
-
+    let result = map_unweighted(2, &edges).unwrap();
     // Create a dummy config
     let config: Vec<usize> = vec![0; result.positions.len()];
-    let original = result.map_config_back(&config);
-
+    let original = result.map_config_back(&config).unwrap();
     assert_eq!(original.len(), 2);
 }
 
 #[test]
 fn test_mapping_result_config_back_weighted() {
     let edges = vec![(0, 1)];
-    let result = map_weighted(2, &edges);
-
+    let result = map_weighted(2, &edges).unwrap();
     // Create a dummy config
     let config: Vec<usize> = vec![0; result.positions.len()];
-    let original = result.map_config_back(&config);
-
+    let original = result.map_config_back(&config).unwrap();
     assert_eq!(original.len(), 2);
 }
 
+#[test]
+fn test_mapping_result_config_back_rejects_wrong_length() {
+    let result = map_unweighted(2, &[(0, 1)]).unwrap();
+
+    assert!(matches!(
+        result.map_config_back(&[]),
+        Err(crate::rules::ExtractionError::InvalidTargetSolution(_))
+    ));
+}
+
 #[test]
 fn test_map_config_copyback_simple() {
     // Create a simple copyline
@@ -73,8 +74,7 @@ fn test_map_config_copyback_simple() {
     }
 
     let doubled_cells = HashSet::new();
-    let result = map_config_copyback(&lines, PADDING, SPACING, &config, &doubled_cells);
-
+    let result = map_config_copyback(&lines, PADDING, SPACING, &config, &doubled_cells).unwrap();
     // count = len(locs) (all selected with ci=1), overhead = len/2
     // result = count - overhead = n - n/2 = n/2
     let n = locs.len();
@@ -86,15 +86,13 @@ fn test_map_config_copyback_simple() {
 #[test]
 fn test_map_unweighted_with_method() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = map_unweighted_with_method(3, &edges, PathDecompositionMethod::greedy());
-
+    let result = map_unweighted_with_method(3, &edges, PathDecompositionMethod::greedy()).unwrap();
     assert!(!result.positions.is_empty());
 }
 
 #[test]
 fn test_map_weighted_with_method() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = map_weighted_with_method(3, &edges, PathDecompositionMethod::greedy());
-
+    let result = map_weighted_with_method(3, &edges, PathDecompositionMethod::greedy()).unwrap();
     assert!(!result.positions.is_empty());
 }
diff --git a/src/unit_tests/rules/unitdiskmapping/triangular/mapping.rs b/src/unit_tests/rules/unitdiskmapping/triangular/mapping.rs
index 104aff3ae..12378dbf7 100644
--- a/src/unit_tests/rules/unitdiskmapping/triangular/mapping.rs
+++ b/src/unit_tests/rules/unitdiskmapping/triangular/mapping.rs
@@ -1,10 +1,10 @@
 use super::*;
+use crate::rules::unitdiskmapping::triangular::{map_weights, trace_centers};
 
 #[test]
 fn test_map_weighted_basic() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = map_weighted(3, &edges);
-
+    let result = map_weighted(3, &edges).unwrap();
     assert!(!result.positions.is_empty());
     assert!(matches!(result.kind, GridKind::Triangular));
 }
@@ -12,8 +12,8 @@ fn test_map_weighted_basic() {
 #[test]
 fn test_map_weighted_with_method() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = map_weighted_with_method(3, &edges, PathDecompositionMethod::MinhThiTrick);
-
+    let result =
+        map_weighted_with_method(3, &edges, PathDecompositionMethod::MinhThiTrick).unwrap();
     assert!(!result.positions.is_empty());
 }
 
@@ -21,17 +21,15 @@ fn test_map_weighted_with_method() {
 fn test_map_weighted_with_order() {
     let edges = vec![(0, 1), (1, 2)];
     let vertex_order = vec![0, 1, 2];
-    let result = map_weighted_with_order(3, &edges, &vertex_order);
-
+    let result = map_weighted_with_order(3, &edges, &vertex_order).unwrap();
     assert!(!result.positions.is_empty());
 }
 
 #[test]
 fn test_trace_centers() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = map_weighted(3, &edges);
-
-    let centers = trace_centers(&result);
+    let result = map_weighted(3, &edges).unwrap();
+    let centers = trace_centers(&result).unwrap();
     assert_eq!(centers.len(), 3);
 
     // Centers should be valid grid positions
@@ -44,10 +42,9 @@ fn test_trace_centers() {
 #[test]
 fn test_map_weights() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = map_weighted(3, &edges);
-
+    let result = map_weighted(3, &edges).unwrap();
     let source_weights = vec![0.5, 0.3, 0.7];
-    let grid_weights = map_weights(&result, &source_weights);
+    let grid_weights = map_weights(&result, &source_weights).unwrap();
 
     // Should have same length as grid nodes
     assert_eq!(grid_weights.len(), result.positions.len());
@@ -57,14 +54,20 @@ fn test_map_weights() {
 }
 
 #[test]
-fn test_weighted_ruleset() {
-    let ruleset = weighted_ruleset();
-    assert_eq!(ruleset.len(), 13);
+fn test_map_config_back_rejects_wrong_length() {
+    let result = map_weighted(2, &[(0, 1)]).unwrap();
+
+    assert!(matches!(
+        map_config_back(&result, &[]),
+        Err(crate::rules::ExtractionError::InvalidTargetSolution(_))
+    ));
 }
 
 #[test]
-#[should_panic(expected = "num_vertices must be > 0")]
-fn test_map_weighted_panics_on_zero_vertices() {
+fn test_map_weighted_rejects_zero_vertices() {
     let edges: Vec<(usize, usize)> = vec![];
-    map_weighted(0, &edges);
+    assert!(matches!(
+        map_weighted(0, &edges),
+        Err(crate::rules::ReductionError::InvalidTarget { .. })
+    ));
 }
diff --git a/src/unit_tests/rules/unitdiskmapping/triangular/mod.rs b/src/unit_tests/rules/unitdiskmapping/triangular/mod.rs
deleted file mode 100644
index 8c099061a..000000000
--- a/src/unit_tests/rules/unitdiskmapping/triangular/mod.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-use super::*;
-
-#[test]
-fn test_triangular_cross_gadget() {
-    // Julia: Base.size(::TriCross{true}) = (6, 4)
-    let cross = TriCross::<true>;
-    assert_eq!(cross.size(), (6, 4));
-}
-
-#[test]
-fn test_map_graph_triangular() {
-    let edges = vec![(0, 1), (1, 2)];
-    let result = map_graph_triangular(3, &edges);
-
-    assert!(!result.positions.is_empty());
-    assert!(matches!(result.kind, GridKind::Triangular));
-}
-
-#[test]
-fn test_triangular_cross_connected_gadget() {
-    // Julia: TriCross{true} - size (6,4), cross (2,2), overhead 1
-    let cross = TriCross::<true>;
-    assert_eq!(TriangularGadget::size(&cross), (6, 4));
-    assert_eq!(TriangularGadget::cross_location(&cross), (2, 2));
-    assert!(TriangularGadget::is_connected(&cross));
-    assert_eq!(TriangularGadget::mis_overhead(&cross), 1);
-}
-
-#[test]
-fn test_triangular_cross_disconnected_gadget() {
-    // Julia: TriCross{false} - size (6,6), cross (2,4), overhead 3
-    let cross = TriCross::<false>;
-    assert_eq!(TriangularGadget::size(&cross), (6, 6));
-    assert_eq!(TriangularGadget::cross_location(&cross), (2, 4));
-    assert!(!TriangularGadget::is_connected(&cross));
-    assert_eq!(TriangularGadget::mis_overhead(&cross), 3);
-}
-
-#[test]
-fn test_triangular_turn_gadget() {
-    // Julia: TriTurn - size (3,4), cross (2,2), overhead 0
-    let turn = TriTurn;
-    assert_eq!(TriangularGadget::size(&turn), (3, 4));
-    assert_eq!(TriangularGadget::mis_overhead(&turn), 0);
-    let (_, _, pins) = TriangularGadget::source_graph(&turn);
-    assert_eq!(pins.len(), 2);
-}
-
-#[test]
-fn test_triangular_branch_gadget() {
-    // Julia: TriBranch - size (6,4), cross (2,2), overhead 0
-    let branch = TriBranch;
-    assert_eq!(TriangularGadget::size(&branch), (6, 4));
-    assert_eq!(TriangularGadget::mis_overhead(&branch), 0);
-    let (_, _, pins) = TriangularGadget::source_graph(&branch);
-    assert_eq!(pins.len(), 3);
-}
-
-#[test]
-fn test_map_graph_triangular_with_order() {
-    let edges = vec![(0, 1), (1, 2)];
-    let order = vec![2, 1, 0];
-    let result = map_graph_triangular_with_order(3, &edges, &order);
-
-    assert!(!result.positions.is_empty());
-    assert_eq!(result.spacing, TRIANGULAR_SPACING);
-    assert_eq!(result.padding, TRIANGULAR_PADDING);
-}
-
-#[test]
-fn test_map_graph_triangular_single_vertex() {
-    let edges: Vec<(usize, usize)> = vec![];
-    let result = map_graph_triangular(1, &edges);
-
-    assert!(!result.positions.is_empty());
-}
-
-#[test]
-#[should_panic(expected = "num_vertices must be > 0")]
-fn test_map_graph_triangular_zero_vertices_panics() {
-    let edges: Vec<(usize, usize)> = vec![];
-    map_graph_triangular(0, &edges);
-}
-
-#[test]
-fn test_triangular_gadgets_have_valid_pins() {
-    // Verify pin indices are within bounds for each gadget
-    fn check_gadget<G: TriangularGadget>(gadget: &G, name: &str) {
-        let (source_locs, _, source_pins) = gadget.source_graph();
-        let (mapped_locs, mapped_pins) = gadget.mapped_graph();
-
-        for &pin in &source_pins {
-            assert!(
-                pin < source_locs.len(),
-                "{}: Source pin {} out of bounds (len={})",
-                name,
-                pin,
-                source_locs.len()
-            );
-        }
-
-        for &pin in &mapped_pins {
-            assert!(
-                pin < mapped_locs.len(),
-                "{}: Mapped pin {} out of bounds (len={})",
-                name,
-                pin,
-                mapped_locs.len()
-            );
-        }
-    }
-
-    check_gadget(&TriCross::<true>, "TriCross<true>");
-    check_gadget(&TriCross::<false>, "TriCross<false>");
-    check_gadget(&TriTurn, "TriTurn");
-    check_gadget(&TriBranch, "TriBranch");
-}
diff --git a/src/unit_tests/rules/unitdiskmapping/weighted.rs b/src/unit_tests/rules/unitdiskmapping/weighted.rs
index 4126fe722..7a2101080 100644
--- a/src/unit_tests/rules/unitdiskmapping/weighted.rs
+++ b/src/unit_tests/rules/unitdiskmapping/weighted.rs
@@ -1,129 +1,33 @@
 use super::*;
 
 #[test]
-fn test_triturn_weighted() {
-    let weighted = TriTurn.weighted();
-    assert_eq!(weighted.source_weights, vec![2, 2, 2, 2]);
-    assert_eq!(weighted.mapped_weights, vec![2, 2, 2, 2]);
-}
-
-#[test]
-fn test_tribranch_weighted() {
-    let weighted = TriBranch.weighted();
-    // Julia: sw = [2,2,3,2,2,2,2,2,2], mw = [2,2,2,3,2,2,2,2,2]
-    assert_eq!(weighted.source_weights, vec![2, 2, 3, 2, 2, 2, 2, 2, 2]);
-    assert_eq!(weighted.mapped_weights, vec![2, 2, 2, 3, 2, 2, 2, 2, 2]);
-}
-
-#[test]
-fn test_tricross_true_weighted() {
-    let weighted = TriCross::<true>.weighted();
-    // Julia: sw = [2,2,2,2,2,2,2,2,2,2], mw = [3,2,3,3,2,2,2,2,2,2,2]
-    assert_eq!(weighted.source_weights, vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2]);
-    assert_eq!(
-        weighted.mapped_weights,
-        vec![3, 2, 3, 3, 2, 2, 2, 2, 2, 2, 2]
-    );
-}
-
-#[test]
-fn test_tricross_false_weighted() {
-    let weighted = TriCross::<false>.weighted();
-    // Julia: sw = [2,2,2,2,2,2,2,2,2,2,2,2], mw = [3,3,2,4,2,2,2,4,3,2,2,2,2,2,2,2]
-    assert_eq!(
-        weighted.source_weights,
-        vec![2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
-    );
-    assert_eq!(
-        weighted.mapped_weights,
-        vec![3, 3, 2, 4, 2, 2, 2, 4, 3, 2, 2, 2, 2, 2, 2, 2]
-    );
-}
-
-#[test]
-fn test_all_weighted_gadgets_have_correct_lengths() {
-    use super::super::triangular::TriangularGadget;
-
-    fn check<G: TriangularGadget + Weightable + Clone>(g: G, name: &str) {
-        let weighted = g.clone().weighted();
-        let (src_locs, _, _) = g.source_graph();
-        let (map_locs, _) = g.mapped_graph();
-        assert_eq!(
-            weighted.source_weights.len(),
-            src_locs.len(),
-            "{}: source weights length mismatch",
-            name
-        );
-        assert_eq!(
-            weighted.mapped_weights.len(),
-            map_locs.len(),
-            "{}: mapped weights length mismatch",
-            name
-        );
-    }
+fn trace_centers_returns_one_center_per_source_vertex() {
+    let result =
+        crate::rules::unitdiskmapping::triangular::map_weighted(3, &[(0, 1), (1, 2)]).unwrap();
+    let centers = trace_centers(&result).unwrap();
 
-    check(TriTurn, "TriTurn");
-    check(TriBranch, "TriBranch");
-    check(TriCross::<true>, "TriCross<true>");
-    check(TriCross::<false>, "TriCross<false>");
-    check(TriTConLeft, "TriTConLeft");
-    check(TriTConDown, "TriTConDown");
-    check(TriTConUp, "TriTConUp");
-    check(TriTrivialTurnLeft, "TriTrivialTurnLeft");
-    check(TriTrivialTurnRight, "TriTrivialTurnRight");
-    check(TriEndTurn, "TriEndTurn");
-    check(TriWTurn, "TriWTurn");
-    check(TriBranchFix, "TriBranchFix");
-    check(TriBranchFixB, "TriBranchFixB");
-}
-
-#[test]
-fn test_triangular_weighted_ruleset_has_13_gadgets() {
-    let ruleset = super::triangular_weighted_ruleset();
-    assert_eq!(ruleset.len(), 13);
-}
-
-#[test]
-fn test_trace_centers_basic() {
-    use crate::rules::unitdiskmapping::triangular::map_weighted;
-
-    let edges = vec![(0, 1), (1, 2)];
-    let result = map_weighted(3, &edges);
-
-    let centers = super::trace_centers(&result);
     assert_eq!(centers.len(), 3);
-
-    // Centers should be valid grid positions
-    for (row, col) in &centers {
-        assert!(*row > 0);
-        assert!(*col > 0);
-    }
+    assert!(centers.iter().all(|&(row, column)| row > 0 && column > 0));
 }
 
 #[test]
-fn test_map_weights_basic() {
-    use crate::rules::unitdiskmapping::triangular::map_weighted;
-    let edges = vec![(0, 1), (1, 2)];
-    let result = map_weighted(3, &edges);
+fn map_weights_adds_one_weight_per_source_vertex() {
+    let result =
+        crate::rules::unitdiskmapping::triangular::map_weighted(3, &[(0, 1), (1, 2)]).unwrap();
+    let mapped = map_weights(&result, &[0.5, 0.3, 0.7]).unwrap();
 
-    let source_weights = vec![0.5, 0.3, 0.7];
-    let grid_weights = super::map_weights(&result, &source_weights);
-
-    // Should have same length as grid nodes
-    assert_eq!(grid_weights.len(), result.positions.len());
-
-    // All weights should be positive
-    assert!(grid_weights.iter().all(|&w| w > 0.0));
+    assert_eq!(mapped.len(), result.positions.len());
+    assert!(mapped
+        .iter()
+        .all(|weight| weight.is_finite() && *weight > 0.0));
 }
 
 #[test]
-#[should_panic(expected = "all weights must be in range")]
-fn test_map_weights_rejects_invalid() {
-    use crate::rules::unitdiskmapping::triangular::map_weighted;
-
-    let edges = vec![(0, 1)];
-    let result = map_weighted(2, &edges);
+fn map_weights_rejects_invalid_source_weight() {
+    let result = crate::rules::unitdiskmapping::triangular::map_weighted(2, &[(0, 1)]).unwrap();
 
-    let source_weights = vec![1.5, 0.3]; // Invalid: > 1
-    super::map_weights(&result, &source_weights);
+    assert!(matches!(
+        map_weights(&result, &[1.5, 0.3]),
+        Err(crate::rules::ReductionError::InvalidTarget { .. })
+    ));
 }
diff --git a/src/unit_tests/solvers/brute_force.rs b/src/unit_tests/solvers/brute_force.rs
index 75d31d717..f2b6547d7 100644
--- a/src/unit_tests/solvers/brute_force.rs
+++ b/src/unit_tests/solvers/brute_force.rs
@@ -1,65 +1,86 @@
 use super::*;
-use crate::solvers::Solver;
 use crate::traits::Problem;
-use crate::types::{Max, Min, Or, Sum};
+use crate::types::{AggregationError, Max, Min, Or, Sum};
+use std::cell::Cell;
+use std::rc::Rc;
 
-#[derive(Clone)]
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
 struct MaxSumProblem {
-    weights: Vec<i32>,
+    weights: Vec<i64>,
 }
 
 impl Problem for MaxSumProblem {
     const NAME: &'static str = "MaxSumProblem";
-    type Value = Max<i32>;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.weights.len()]
+    type Solution = Vec<usize>;
+    type Value = Max<i64>;
+
+    crate::problem_parameters![("num_variables", num_variables)];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok({
+            Max(Some(
+                config
+                    .iter()
+                    .zip(&self.weights)
+                    .map(|(&c, &w)| if c == 1 { w } else { 0 })
+                    .sum(),
+            ))
+        })
     }
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Max(Some(
-            config
-                .iter()
-                .zip(&self.weights)
-                .map(|(&c, &w)| if c == 1 { w } else { 0 })
-                .sum(),
-        ))
+    fn variant() -> Vec<(&'static str, &'static str)> {
+        vec![("graph", "SimpleGraph"), ("weight", "i64")]
     }
+}
 
-    fn variant() -> Vec<(&'static str, &'static str)> {
-        vec![("graph", "SimpleGraph"), ("weight", "i32")]
+impl crate::solvers::BruteForceProblem for MaxSumProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.weights.len()]
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
 struct MinSumProblem {
-    weights: Vec<i32>,
+    weights: Vec<i64>,
 }
 
 impl Problem for MinSumProblem {
     const NAME: &'static str = "MinSumProblem";
-    type Value = Min<i32>;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.weights.len()]
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_variables", num_variables)];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok({
+            Min(Some(
+                config
+                    .iter()
+                    .zip(&self.weights)
+                    .map(|(&c, &w)| if c == 1 { w } else { 0 })
+                    .sum(),
+            ))
+        })
     }
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Min(Some(
-            config
-                .iter()
-                .zip(&self.weights)
-                .map(|(&c, &w)| if c == 1 { w } else { 0 })
-                .sum(),
-        ))
+    fn variant() -> Vec<(&'static str, &'static str)> {
+        vec![("graph", "SimpleGraph"), ("weight", "i64")]
     }
+}
 
-    fn variant() -> Vec<(&'static str, &'static str)> {
-        vec![("graph", "SimpleGraph"), ("weight", "i32")]
+impl crate::solvers::BruteForceProblem for MinSumProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.weights.len()]
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
 struct SatProblem {
     num_vars: usize,
     satisfying: Vec<Vec<usize>>,
@@ -67,44 +88,221 @@ struct SatProblem {
 
 impl Problem for SatProblem {
     const NAME: &'static str = "SatProblem";
+    type Solution = Vec<usize>;
     type Value = Or;
 
-    fn dims(&self) -> Vec<usize> {
+    crate::problem_parameters![("num_variables", num_variables)];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok(Or(self.satisfying.iter().any(|s| s == config)))
+    }
+
+    fn variant() -> Vec<(&'static str, &'static str)> {
+        vec![("graph", "SimpleGraph"), ("weight", "bool")]
+    }
+}
+
+impl crate::solvers::BruteForceProblem for SatProblem {
+    fn dimensions(&self) -> Vec<usize> {
         vec![2; self.num_vars]
     }
+}
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Or(self.satisfying.iter().any(|s| s == config))
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
+struct EvaluationFailureProblem;
+
+impl Problem for EvaluationFailureProblem {
+    const NAME: &'static str = "EvaluationFailureProblem";
+    type Solution = Vec<usize>;
+    type Value = Or;
+
+    crate::problem_parameters![("num_variables", num_variables)];
+
+    fn evaluate(&self, config: &Self::Solution) -> Result<Or, crate::traits::EvaluationError> {
+        if config.as_slice() == [1] {
+            Err(crate::traits::EvaluationError::IntegerOverflow(
+                "evaluating test configuration".to_string(),
+            ))
+        } else {
+            Ok(Or(false))
+        }
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
-        vec![("graph", "SimpleGraph"), ("weight", "bool")]
+        vec![]
     }
 }
 
-#[derive(Clone)]
-struct SumProblem {
-    weights: Vec<u64>,
+impl crate::solvers::BruteForceProblem for EvaluationFailureProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2]
+    }
 }
 
-impl Problem for SumProblem {
-    const NAME: &'static str = "SumProblem";
-    type Value = Sum<u64>;
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
+struct AggregationFailureProblem;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.weights.len()]
+impl Problem for AggregationFailureProblem {
+    const NAME: &'static str = "AggregationFailureProblem";
+    type Solution = Vec<usize>;
+    type Value = Max<f64>;
+
+    crate::problem_parameters![("num_variables", num_variables)];
+
+    fn evaluate(&self, _: &Self::Solution) -> Result<Max<f64>, crate::traits::EvaluationError> {
+        Ok(Max(Some(f64::NAN)))
     }
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Sum(config
-            .iter()
-            .zip(&self.weights)
-            .map(|(&c, &w)| if c == 1 { w } else { 0 })
-            .sum())
+    fn variant() -> Vec<(&'static str, &'static str)> {
+        vec![]
+    }
+}
+
+impl crate::solvers::BruteForceProblem for AggregationFailureProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2]
+    }
+}
+
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
+struct CountingSatProblem {
+    #[serde(skip)]
+    evaluations: Rc<Cell<usize>>,
+}
+
+impl Problem for CountingSatProblem {
+    const NAME: &'static str = "CountingSatProblem";
+    type Solution = Vec<usize>;
+    type Value = Or;
+
+    crate::problem_parameters![("num_variables", num_variables)];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok({
+            self.evaluations.set(self.evaluations.get() + 1);
+            Or(config.as_slice() == [0, 0])
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
-        vec![("graph", "SimpleGraph"), ("weight", "u64")]
+        vec![]
+    }
+}
+
+impl crate::solvers::BruteForceProblem for CountingSatProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2, 2]
+    }
+}
+
+crate::declare_variants! {
+    default MaxSumProblem => "2^num_variables",
+    default MinSumProblem => "2^num_variables",
+    default SatProblem => "2^num_variables",
+    default EvaluationFailureProblem => "2^num_variables",
+    default AggregationFailureProblem => "2^num_variables",
+    default CountingSatProblem => "2^num_variables",
+}
+
+crate::register_brute_force! {
+    MaxSumProblem,
+    MinSumProblem,
+    SatProblem,
+    EvaluationFailureProblem,
+    AggregationFailureProblem,
+    CountingSatProblem,
+}
+
+inventory::submit! {
+    crate::registry::ProblemSchemaEntry {
+        name: "MaxSumProblem",
+        display_name: "Maximum Sum Test Problem",
+        aliases: &[],
+        dimensions: &[
+            crate::registry::VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
+            crate::registry::VariantDimension::new("weight", "i64", &["i64"]),
+        ],
+        category: crate::registry::ProblemCategory::Misc,
+        module_path: module_path!(),
+        description: "Test problem for maximum aggregation",
+        fields: &[],
+    }
+}
+
+inventory::submit! {
+    crate::registry::ProblemSchemaEntry {
+        name: "MinSumProblem",
+        display_name: "Minimum Sum Test Problem",
+        aliases: &[],
+        dimensions: &[
+            crate::registry::VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
+            crate::registry::VariantDimension::new("weight", "i64", &["i64"]),
+        ],
+        category: crate::registry::ProblemCategory::Misc,
+        module_path: module_path!(),
+        description: "Test problem for minimum aggregation",
+        fields: &[],
+    }
+}
+
+inventory::submit! {
+    crate::registry::ProblemSchemaEntry {
+        name: "SatProblem",
+        display_name: "Satisfaction Test Problem",
+        aliases: &[],
+        dimensions: &[
+            crate::registry::VariantDimension::new("graph", "SimpleGraph", &["SimpleGraph"]),
+            crate::registry::VariantDimension::new("weight", "bool", &["bool"]),
+        ],
+        category: crate::registry::ProblemCategory::Misc,
+        module_path: module_path!(),
+        description: "Test problem for satisfaction aggregation",
+        fields: &[],
+    }
+}
+
+inventory::submit! {
+    crate::registry::ProblemSchemaEntry {
+        name: "EvaluationFailureProblem",
+        display_name: "Evaluation Failure Test Problem",
+        aliases: &[],
+        dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
+        module_path: module_path!(),
+        description: "Test problem that exposes evaluation failures",
+        fields: &[],
+    }
+}
+
+inventory::submit! {
+    crate::registry::ProblemSchemaEntry {
+        name: "AggregationFailureProblem",
+        display_name: "Aggregation Failure Test Problem",
+        aliases: &[],
+        dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
+        module_path: module_path!(),
+        description: "Test problem that exposes aggregation failures",
+        fields: &[],
+    }
+}
+
+inventory::submit! {
+    crate::registry::ProblemSchemaEntry {
+        name: "CountingSatProblem",
+        display_name: "Counting Satisfaction Test Problem",
+        aliases: &[],
+        dimensions: &[],
+        category: crate::registry::ProblemCategory::Misc,
+        module_path: module_path!(),
+        description: "Test problem that counts reference evaluations",
+        fields: &[],
     }
 }
 
@@ -115,7 +313,12 @@ fn test_solver_solves_max_value() {
     };
     let solver = BruteForce::new();
 
-    assert_eq!(solver.solve(&problem), Max(Some(6)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Max(Some(6))
+    );
 }
 
 #[test]
@@ -125,7 +328,12 @@ fn test_solver_solves_min_value() {
     };
     let solver = BruteForce::new();
 
-    assert_eq!(solver.solve(&problem), Min(Some(0)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Min(Some(0))
+    );
 }
 
 #[test]
@@ -136,40 +344,57 @@ fn test_solver_solves_satisfaction_value() {
     };
     let solver = BruteForce::new();
 
-    assert_eq!(solver.solve(&problem), Or(true));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Or(true)
+    );
 }
 
 #[test]
-fn test_solver_find_witness() {
+fn test_solver_solve() {
     let problem = MaxSumProblem {
         weights: vec![1, 2, 3],
     };
     let solver = BruteForce::new();
 
-    assert_eq!(solver.find_witness(&problem), Some(vec![1, 1, 1]));
+    assert_eq!(solver.solve(&problem).unwrap(), Some(vec![1, 1, 1]));
 }
 
 #[test]
-fn test_solver_find_witness_for_satisfaction_problem() {
+fn test_solver_solve_for_satisfaction_problem() {
     let problem = SatProblem {
         num_vars: 2,
         satisfying: vec![vec![1, 0], vec![0, 1]],
     };
     let solver = BruteForce::new();
 
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     assert!(witness.is_some());
-    assert_eq!(problem.evaluate(&witness.unwrap()), Or(true));
+    assert_eq!(problem.evaluate(&witness.unwrap()).unwrap(), Or(true));
 }
 
 #[test]
-fn test_solver_find_witness_returns_none_for_sum_problem() {
-    let problem = SumProblem {
-        weights: vec![1, 2, 3],
+fn test_solver_solve_stops_after_first_optimal_configuration() {
+    let evaluations = Rc::new(Cell::new(0));
+    let problem = CountingSatProblem {
+        evaluations: Rc::clone(&evaluations),
     };
-    let solver = BruteForce::new();
 
-    assert_eq!(solver.find_witness(&problem), None);
+    assert_eq!(BruteForce::new().solve(&problem).unwrap(), Some(vec![0, 0]));
+    // The absorbing aggregate and the witness pass both stop at the first
+    // satisfying configuration.
+    assert_eq!(evaluations.get(), 2);
+}
+
+#[test]
+fn test_sum_fold_combines_values_without_problem_solving() {
+    let total = [Sum(1_u64), Sum(2), Sum(3)]
+        .into_iter()
+        .try_fold(Sum::identity(), Aggregate::combine)
+        .unwrap();
+    assert_eq!(total, Sum(6));
 }
 
 #[test]
@@ -180,20 +405,19 @@ fn test_solver_find_all_witnesses() {
     };
     let solver = BruteForce::new();
 
-    let witnesses = solver.find_all_witnesses(&problem);
+    let witnesses = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(witnesses.len(), 2);
     assert!(witnesses.contains(&vec![1, 0]));
     assert!(witnesses.contains(&vec![0, 1]));
 }
 
 #[test]
-fn test_solver_find_all_witnesses_returns_empty_for_sum_problem() {
-    let problem = SumProblem {
-        weights: vec![1, 2, 3],
-    };
-    let solver = BruteForce::new();
-
-    assert!(solver.find_all_witnesses(&problem).is_empty());
+fn test_sum_fold_uses_every_input_value() {
+    let total = [Sum(0_u64), Sum(2), Sum(1), Sum(3)]
+        .into_iter()
+        .try_fold(Sum::identity(), Aggregate::combine)
+        .unwrap();
+    assert_eq!(total, Sum(6));
 }
 
 #[test]
@@ -204,15 +428,15 @@ fn test_solver_with_real_mis() {
 
     let problem = MaximumIndependentSet::new(
         SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-        vec![1i32; 3],
+        vec![1i64; 3],
     );
     let solver = BruteForce::new();
 
-    let best = solver.find_all_witnesses(&problem);
+    let best = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(best.len(), 3);
     for sol in &best {
-        assert_eq!(sol.iter().sum::<usize>(), 1);
-        assert!(problem.evaluate(sol).is_valid());
+        assert_eq!(sol.iter().filter(|&&selected| selected).count(), 1);
+        assert!(problem.evaluate(sol).unwrap().is_valid());
     }
 }
 
@@ -227,10 +451,10 @@ fn test_solver_with_real_sat() {
     );
     let solver = BruteForce::new();
 
-    let solutions = solver.find_all_witnesses(&problem);
+    let solutions = solver.find_all_witnesses(&problem).unwrap();
     assert_eq!(solutions.len(), 2);
     for sol in &solutions {
-        assert!(problem.evaluate(sol));
+        assert!(problem.evaluate(sol).unwrap());
     }
 }
 
@@ -241,21 +465,30 @@ fn test_solve_with_witnesses_max() {
     };
     let solver = BruteForce::new();
 
-    let (value, witnesses) = solver.solve_with_witnesses(&problem);
+    let (value, witnesses) = solver.solve_with_witnesses(&problem).unwrap();
     assert_eq!(value, Max(Some(6)));
     assert_eq!(witnesses, vec![vec![1, 1, 1]]);
 }
 
 #[test]
-fn test_solve_with_witnesses_sum_returns_empty() {
-    let problem = SumProblem {
-        weights: vec![1, 2],
+fn test_sum_fold_preserves_zero_identity() {
+    assert_eq!(Sum::<u64>::identity().combine(Sum(6)).unwrap(), Sum(6));
+}
+
+#[test]
+fn solve_with_witnesses_enumerates_only_aggregate_and_witness_passes() {
+    let evaluations = Rc::new(Cell::new(0));
+    let problem = CountingSatProblem {
+        evaluations: Rc::clone(&evaluations),
     };
-    let solver = BruteForce::new();
 
-    let (value, witnesses) = solver.solve_with_witnesses(&problem);
-    assert_eq!(value, Sum(6)); // 0+0 + 0+2 + 1+0 + 1+2 = 6
-    assert!(witnesses.is_empty());
+    let (value, witnesses) = BruteForce::new().solve_with_witnesses(&problem).unwrap();
+
+    assert_eq!(value, Or(true));
+    assert_eq!(witnesses, vec![vec![0, 0]]);
+    // One evaluation reaches the absorbing aggregate; the witness pass then
+    // enumerates all four configurations.
+    assert_eq!(evaluations.get(), 5);
 }
 
 #[test]
@@ -265,5 +498,83 @@ fn test_solver_trait_solve() {
     };
     let solver = BruteForce::new();
 
-    assert_eq!(Solver::solve(&solver, &problem), Max(Some(6)));
+    assert_eq!(
+        problem
+            .evaluate(&solver.solve(&problem).unwrap().unwrap())
+            .unwrap(),
+        Max(Some(6))
+    );
+}
+
+#[test]
+fn test_solver_preserves_evaluation_errors() {
+    let error = BruteForce::new()
+        .solve(&EvaluationFailureProblem)
+        .unwrap_err();
+    assert!(matches!(
+        error,
+        crate::solvers::SolveError::Evaluation(crate::traits::EvaluationError::IntegerOverflow(_))
+    ));
+}
+
+#[test]
+fn test_solver_preserves_aggregation_errors() {
+    let error = BruteForce::new()
+        .solve(&AggregationFailureProblem)
+        .unwrap_err();
+    assert!(matches!(
+        error,
+        crate::solvers::SolveError::Aggregation(AggregationError::UnorderedComparison)
+    ));
+}
+
+#[test]
+fn cartesian_indices_enumerates_mixed_dimensions() {
+    let indices = CartesianIndices::new(vec![2, 3])
+        .unwrap()
+        .collect::<Vec<_>>();
+    assert_eq!(
+        indices,
+        vec![
+            vec![0, 0],
+            vec![0, 1],
+            vec![0, 2],
+            vec![1, 0],
+            vec![1, 1],
+            vec![1, 2],
+        ]
+    );
+}
+
+#[test]
+fn cartesian_indices_empty_dimensions_have_one_candidate() {
+    assert_eq!(
+        CartesianIndices::new(vec![]).unwrap().collect::<Vec<_>>(),
+        vec![Vec::<usize>::new()]
+    );
+}
+
+#[test]
+fn cartesian_indices_zero_dimension_has_no_candidates() {
+    assert!(CartesianIndices::new(vec![2, 0, 3])
+        .unwrap()
+        .next()
+        .is_none());
+}
+
+#[test]
+fn cartesian_indices_is_exact_size() {
+    let mut indices = CartesianIndices::new(vec![2, 3]).unwrap();
+    assert_eq!(indices.len(), 6);
+    indices.next();
+    assert_eq!(indices.len(), 5);
+}
+
+#[test]
+fn cartesian_indices_reports_cardinality_overflow() {
+    assert!(matches!(
+        CartesianIndices::new(vec![usize::MAX, 2]),
+        Err(crate::solvers::SolveError::SearchSpaceOverflow(dimensions))
+            if dimensions == vec![usize::MAX, 2]
+    ));
 }
diff --git a/src/unit_tests/solvers/customized/closest_vector_problem.rs b/src/unit_tests/solvers/customized/closest_vector_problem.rs
new file mode 100644
index 000000000..fe570f3f2
--- /dev/null
+++ b/src/unit_tests/solvers/customized/closest_vector_problem.rs
@@ -0,0 +1,155 @@
+use super::*;
+use crate::models::algebraic::ClosestVectorProblem;
+use crate::solvers::{solver_capabilities, ExactProblemKey};
+use crate::traits::Problem;
+use std::collections::BTreeMap;
+
+#[test]
+fn test_cvp_solver_handles_integer_and_real_targets() {
+    let integer = ClosestVectorProblem::new(vec![vec![1]], vec![12_i64]).unwrap();
+    assert_eq!(solve(&integer).unwrap(), vec![12]);
+
+    let real = ClosestVectorProblem::new(vec![vec![1]], vec![0.6]).unwrap();
+    assert_eq!(solve(&real).unwrap(), vec![1]);
+}
+
+#[test]
+fn test_cvp_solver_handles_nonorthogonal_rectangular_and_negative_coefficients() {
+    let problem =
+        ClosestVectorProblem::new(vec![vec![2, 0, 1], vec![1, 2, 0]], vec![-3_i64, -2, -1])
+            .unwrap();
+    assert_eq!(solve(&problem).unwrap(), vec![-1, -1]);
+}
+
+#[test]
+fn test_cvp_solver_keeps_zero_on_tie_and_handles_empty_basis() {
+    let tied = ClosestVectorProblem::new(vec![vec![1]], vec![0.5]).unwrap();
+    assert_eq!(solve(&tied).unwrap(), vec![0]);
+
+    let empty = ClosestVectorProblem::new(Vec::new(), vec![1_i64, 2]).unwrap();
+    assert!(solve(&empty).unwrap().is_empty());
+}
+
+#[test]
+fn test_cvp_solver_reports_inexact_integer_conversion() {
+    let problem = ClosestVectorProblem::new(
+        vec![vec![crate::types::MAX_EXACT_F64_INTEGER + 1]],
+        vec![0_i64],
+    )
+    .unwrap();
+    assert!(matches!(
+        solve(&problem),
+        Err(crate::solvers::SolveError::InexactFloatConversion(_))
+    ));
+
+    let out_of_range = ClosestVectorProblem::new(vec![vec![1]], vec![1e20]).unwrap();
+    assert!(matches!(
+        solve(&out_of_range),
+        Err(SolveError::IntegerOverflow(_))
+    ));
+    let inexact = ClosestVectorProblem::new(
+        vec![vec![1]],
+        vec![crate::types::MAX_EXACT_F64_INTEGER as f64 + 2.0],
+    )
+    .unwrap();
+    assert!(matches!(
+        solve(&inexact),
+        Err(SolveError::InexactFloatConversion(_))
+    ));
+}
+
+#[test]
+fn test_cvp_solver_is_registered_without_brute_force() {
+    let key = ExactProblemKey::new(
+        ClosestVectorProblem::<i64>::NAME,
+        BTreeMap::from([("target".to_string(), "i64".to_string())]),
+    );
+    let capabilities = solver_capabilities(&key).unwrap();
+    assert_eq!(
+        capabilities.customized.unwrap().implementation,
+        "cvp-sphere-enumeration"
+    );
+    assert!(!capabilities.brute_force);
+}
+
+#[test]
+fn test_cvp_solver_handles_large_translated_targets() {
+    for target in [-1_000_000_000_i64, 1_000_000_000] {
+        let problem = ClosestVectorProblem::new(vec![vec![1]], vec![target]).unwrap();
+        assert_eq!(solve(&problem).unwrap(), vec![target]);
+
+        let rectangular =
+            ClosestVectorProblem::new(vec![vec![2, 0], vec![1, 2]], vec![3 * target, 2 * target])
+                .unwrap();
+        assert_eq!(solve(&rectangular).unwrap(), vec![target, target]);
+
+        let fractional =
+            ClosestVectorProblem::new(vec![vec![2, 0]], vec![2.0 * target as f64 + 0.6, 3.0])
+                .unwrap();
+        assert_eq!(solve(&fractional).unwrap(), vec![target]);
+    }
+}
+
+#[test]
+fn test_cvp_nearest_first_matches_exhaustive_small_lattices() {
+    // For these triangular bases, the zero witness bounds the projected optimal distance
+    // by sqrt(8). Thus |y coefficient| <= 4 and |x coefficient| <= 12.
+    for diagonal in 1..=3_i64 {
+        for skew in -2..=2_i64 {
+            for tx in -4..=4 {
+                for ty in -4..=4 {
+                    let problem = ClosestVectorProblem::new(
+                        vec![vec![diagonal, 0, 0], vec![skew, 1, 0]],
+                        vec![tx as f64 / 2.0, ty as f64 / 2.0, 1.0],
+                    )
+                    .unwrap();
+                    let actual = solve(&problem).unwrap();
+                    let distance = |x: i64, y: i64| {
+                        let dx = (diagonal * x + skew * y) as f64 - tx as f64 / 2.0;
+                        let dy = y as f64 - ty as f64 / 2.0;
+                        dx * dx + dy * dy + 1.0
+                    };
+                    let expected = (-12..=12)
+                        .flat_map(|x| (-4..=4).map(move |y| distance(x, y)))
+                        .fold(f64::INFINITY, f64::min);
+                    assert!((distance(actual[0], actual[1]) - expected).abs() < 1e-9,
+                        "diagonal={diagonal}, skew={skew}, target=({tx}/2,{ty}/2), solution={actual:?}");
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_cvp_enumeration_improves_the_nearest_plane_candidate() {
+    let problem = ClosestVectorProblem::new(vec![vec![2, 0], vec![1, 1]], vec![0.9, 0.49]).unwrap();
+    // Nearest-plane rounding yields [0, 0]; the adjacent branch is closer.
+    assert_eq!(solve(&problem).unwrap(), vec![0, 1]);
+}
+
+#[test]
+fn test_cvp_pruning_preserves_exact_large_translation_optimum() {
+    for coefficient in [-100_000_000_000_000_i64, 100_000_000_000_000] {
+        let basis = vec![vec![3, 1], vec![2, 1]];
+        let target = vec![5 * coefficient, 2 * coefficient];
+        let integer = ClosestVectorProblem::new(basis.clone(), target.clone()).unwrap();
+        let real = ClosestVectorProblem::new(
+            basis,
+            target.into_iter().map(|value| value as f64).collect(),
+        )
+        .unwrap();
+        let expected = vec![coefficient, coefficient];
+        assert_eq!(solve(&integer).unwrap(), expected);
+        assert_eq!(solve(&real).unwrap(), expected);
+        assert_eq!(integer.evaluate(&expected).unwrap().0, Some(0.0));
+    }
+}
+
+#[test]
+fn test_cvp_pruning_handles_nearly_parallel_integer_columns() {
+    let n = 100_000_000_i64;
+    let problem =
+        ClosestVectorProblem::new(vec![vec![n, n + 1], vec![n + 1, n + 2]], vec![1_i64, 0])
+            .unwrap();
+    assert_eq!(solve(&problem).unwrap(), vec![-n - 2, n + 1]);
+}
diff --git a/src/unit_tests/solvers/customized/ensemble_computation.rs b/src/unit_tests/solvers/customized/ensemble_computation.rs
new file mode 100644
index 000000000..44146eb12
--- /dev/null
+++ b/src/unit_tests/solvers/customized/ensemble_computation.rs
@@ -0,0 +1,43 @@
+use super::*;
+use crate::solvers::BruteForce;
+use crate::traits::Problem;
+
+#[test]
+fn test_breadth_first_search_ensemble_computation_matches_brute_force() {
+    let subsets = [
+        vec![],
+        vec![0],
+        vec![1],
+        vec![2],
+        vec![0, 1],
+        vec![0, 2],
+        vec![1, 2],
+        vec![0, 1, 2],
+    ];
+    for first in &subsets {
+        for second in &subsets {
+            let problem = EnsembleComputation::new(3, vec![first.clone(), second.clone()], 2);
+            let expected = BruteForce::new().solve(&problem).unwrap();
+            let actual = solve(&problem);
+            assert_eq!(
+                actual
+                    .as_ref()
+                    .map(|solution| problem.evaluate(solution).unwrap()),
+                expected
+                    .as_ref()
+                    .map(|solution| problem.evaluate(solution).unwrap())
+            );
+        }
+    }
+}
+
+#[test]
+fn test_breadth_first_search_ensemble_computation_reuses_intermediate_sets() {
+    let problem = EnsembleComputation::new(
+        6,
+        vec![vec![0, 1], vec![0, 1, 2, 3], vec![0, 1, 2, 3, 4, 5]],
+        5,
+    );
+    let solution = solve(&problem).unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap().0, Some(5));
+}
diff --git a/src/unit_tests/solvers/customized/grouping_by_swapping.rs b/src/unit_tests/solvers/customized/grouping_by_swapping.rs
new file mode 100644
index 000000000..e3cdfebf4
--- /dev/null
+++ b/src/unit_tests/solvers/customized/grouping_by_swapping.rs
@@ -0,0 +1,43 @@
+use super::*;
+use crate::solvers::BruteForce;
+use crate::traits::Problem;
+use crate::types::Or;
+
+#[test]
+fn test_symbol_block_order_grouping_by_swapping_matches_brute_force() {
+    for alphabet_size in 1usize..=3 {
+        for len in 1..=5 {
+            let count = alphabet_size.pow(len as u32);
+            for encoded in 0..count {
+                let mut value = encoded;
+                let mut string = Vec::with_capacity(len);
+                for _ in 0..len {
+                    string.push(value % alphabet_size);
+                    value /= alphabet_size;
+                }
+                for budget in 0..=4 {
+                    let problem = GroupingBySwapping::new(alphabet_size, string.clone(), budget);
+                    let expected = BruteForce::new().solve(&problem).unwrap().is_some();
+                    let actual = solve(&problem);
+                    assert_eq!(actual.is_some(), expected, "{string:?}, budget={budget}");
+                    if let Some(solution) = actual {
+                        assert_eq!(problem.evaluate(&solution).unwrap(), Or(true));
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_symbol_block_order_grouping_by_swapping_handles_scale() {
+    assert_eq!(
+        solve(&GroupingBySwapping::new(0, Vec::new(), 0)),
+        Some(Vec::new())
+    );
+
+    let problem = GroupingBySwapping::new(4, vec![2, 1, 1, 1, 0, 0, 3, 2], 24);
+    let solution = solve(&problem).expect("the instance is groupable within its budget");
+    assert_eq!(solution.len(), 24);
+    assert_eq!(problem.evaluate(&solution).unwrap(), Or(true));
+}
diff --git a/src/unit_tests/solvers/customized/minimum_cost_circulation.rs b/src/unit_tests/solvers/customized/minimum_cost_circulation.rs
new file mode 100644
index 000000000..7e51c8e35
--- /dev/null
+++ b/src/unit_tests/solvers/customized/minimum_cost_circulation.rs
@@ -0,0 +1,72 @@
+use super::*;
+use crate::solvers::BruteForce;
+use crate::topology::DirectedGraph;
+use crate::traits::Problem;
+
+#[test]
+fn test_negative_cycle_cancellation_minimum_cost_circulation_matches_brute_force() {
+    let graph = DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0), (1, 0)]);
+    for capacity_mask in 0usize..16 {
+        let capacities = (0..4)
+            .map(|arc| ((capacity_mask >> arc) & 1) as i64)
+            .collect::<Vec<_>>();
+        for encoded_costs in 0usize..81 {
+            let mut encoded = encoded_costs;
+            let costs = (0..4)
+                .map(|_| {
+                    let cost = (encoded % 3) as i64 - 1;
+                    encoded /= 3;
+                    cost
+                })
+                .collect::<Vec<_>>();
+            let problem = MinimumCostCirculation::new(graph.clone(), capacities.clone(), costs);
+            let expected = BruteForce::new().solve(&problem).unwrap().unwrap();
+            let actual = solve(&problem).unwrap();
+            assert_eq!(
+                problem.evaluate(&actual).unwrap(),
+                problem.evaluate(&expected).unwrap()
+            );
+        }
+    }
+}
+
+#[test]
+fn test_negative_cycle_cancellation_minimum_cost_circulation_handles_multigraph() {
+    let problem = MinimumCostCirculation::new(
+        DirectedGraph::new(2, vec![(0, 0), (0, 1), (0, 1), (1, 0)]),
+        vec![3, 2, 4, 3],
+        vec![-2, 4, -3, 1],
+    );
+    let solution = solve(&problem).unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap().0, Some(-12));
+}
+
+#[test]
+fn test_circulation_overflow_propagates_through_default_solver() {
+    for (graph, costs, operation) in [
+        (
+            DirectedGraph::new(2, vec![(0, 1), (1, 0)]),
+            vec![-5_000_000_000_000_000_000, 0],
+            "relaxing a circulation residual arc",
+        ),
+        (
+            DirectedGraph::new(1, vec![(0, 0)]),
+            vec![i64::MIN],
+            "negating a circulation residual cost",
+        ),
+    ] {
+        let problem = MinimumCostCirculation::new(graph, vec![1; costs.len()], costs);
+        let reference = BruteForce::new().solve(&problem).unwrap().unwrap();
+        assert!(problem.evaluate(&reference).unwrap().is_valid());
+        let loaded = crate::registry::load_dyn(
+            MinimumCostCirculation::NAME,
+            &std::collections::BTreeMap::new(),
+            serde_json::to_value(problem).unwrap(),
+        )
+        .unwrap();
+        assert!(matches!(
+            crate::solvers::solve(&loaded, crate::solvers::SolverRequest::Default),
+            Err(SolveError::IntegerOverflow(message)) if message == operation
+        ));
+    }
+}
diff --git a/src/unit_tests/solvers/customized/minimum_decision_tree.rs b/src/unit_tests/solvers/customized/minimum_decision_tree.rs
new file mode 100644
index 000000000..6905c543e
--- /dev/null
+++ b/src/unit_tests/solvers/customized/minimum_decision_tree.rs
@@ -0,0 +1,48 @@
+use super::*;
+use crate::solvers::BruteForce;
+use crate::traits::Problem;
+
+#[test]
+fn test_subset_dp_minimum_decision_tree_matches_brute_force() {
+    let rows = [
+        vec![false, false, true],
+        vec![false, true, false],
+        vec![false, true, true],
+        vec![true, false, false],
+        vec![true, false, true],
+        vec![true, true, false],
+    ];
+    for first in 0..rows.len() {
+        for second in (first + 1)..rows.len() {
+            for third in (second + 1)..rows.len() {
+                let matrix = vec![
+                    rows[first].clone(),
+                    rows[second].clone(),
+                    rows[third].clone(),
+                ];
+                if (0..3).any(|a| {
+                    ((a + 1)..3).any(|b| !(0..3).any(|test| matrix[test][a] != matrix[test][b]))
+                }) {
+                    continue;
+                }
+                let problem = MinimumDecisionTree::new(matrix, 3, 3);
+                let expected = BruteForce::new().solve(&problem).unwrap().unwrap();
+                let actual = solve(&problem).unwrap();
+                assert_eq!(
+                    problem.evaluate(&actual).unwrap(),
+                    problem.evaluate(&expected).unwrap()
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn test_subset_dp_minimum_decision_tree_handles_eight_objects() {
+    let matrix = (0..3)
+        .map(|bit| (0..8).map(|object| object & (1 << bit) != 0).collect())
+        .collect();
+    let problem = MinimumDecisionTree::new(matrix, 8, 3);
+    let solution = solve(&problem).unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap().0, Some(24));
+}
diff --git a/src/unit_tests/solvers/customized/minimum_intersection_graph_basis.rs b/src/unit_tests/solvers/customized/minimum_intersection_graph_basis.rs
new file mode 100644
index 000000000..74335d39c
--- /dev/null
+++ b/src/unit_tests/solvers/customized/minimum_intersection_graph_basis.rs
@@ -0,0 +1,57 @@
+use super::*;
+use crate::solvers::BruteForce;
+use crate::traits::Problem;
+
+#[test]
+fn test_clique_cover_dp_minimum_intersection_graph_basis_matches_brute_force() {
+    for edge_mask in 0usize..8 {
+        let all_edges = [(0, 1), (0, 2), (1, 2)];
+        let edges = all_edges
+            .iter()
+            .enumerate()
+            .filter_map(|(edge, pair)| (edge_mask & (1 << edge) != 0).then_some(*pair))
+            .collect();
+        let problem = MinimumIntersectionGraphBasis::new(SimpleGraph::new(3, edges));
+        let expected = BruteForce::new().solve(&problem).unwrap().unwrap();
+        let actual = solve(&problem).unwrap();
+        assert_eq!(
+            problem.evaluate(&actual).unwrap(),
+            problem.evaluate(&expected).unwrap()
+        );
+    }
+}
+
+#[test]
+fn test_clique_cover_dp_minimum_intersection_graph_basis_handles_overlapping_cliques() {
+    let problem = MinimumIntersectionGraphBasis::new(SimpleGraph::new(
+        5,
+        vec![(0, 1), (0, 2), (1, 2), (2, 3), (2, 4), (3, 4)],
+    ));
+    let solution = solve(&problem).unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap().0, Some(2));
+}
+
+#[test]
+fn test_intersection_basis_handles_dense_graphs_beyond_machine_word_edges() {
+    for n in [8, 12] {
+        let edges = (0..n)
+            .flat_map(|u| ((u + 1)..n).map(move |v| (u, v)))
+            .collect();
+        let problem = MinimumIntersectionGraphBasis::new(SimpleGraph::new(n, edges));
+        let solution = solve(&problem).unwrap();
+        assert_eq!(problem.evaluate(&solution).unwrap().0, Some(1));
+    }
+}
+
+#[test]
+fn test_minimum_cover_improves_a_redundant_initial_cover() {
+    let covers = vec![
+        vec![true, true, false],
+        vec![true, false, true],
+        vec![false, true, true],
+    ];
+    let mut best = vec![0, 1, 2];
+    minimum_cover(&covers, &[false; 3], &mut Vec::new(), &mut best);
+    assert_eq!(best.len(), 2);
+    assert!((0..3).all(|edge| best.iter().any(|&clique| covers[clique][edge])));
+}
diff --git a/src/unit_tests/solvers/customized/shortest_common_superstring.rs b/src/unit_tests/solvers/customized/shortest_common_superstring.rs
new file mode 100644
index 000000000..a331c02f7
--- /dev/null
+++ b/src/unit_tests/solvers/customized/shortest_common_superstring.rs
@@ -0,0 +1,40 @@
+use super::*;
+use crate::solvers::BruteForce;
+use crate::traits::Problem;
+
+#[test]
+fn test_subset_dp_shortest_common_superstring_matches_brute_force() {
+    let candidates = [vec![], vec![0], vec![1], vec![0, 0], vec![0, 1], vec![1, 0]];
+    for first in &candidates {
+        for second in &candidates {
+            for third in &candidates {
+                let problem = ShortestCommonSuperstring::new(
+                    2,
+                    vec![first.clone(), second.clone(), third.clone()],
+                );
+                let expected = BruteForce::new().solve(&problem).unwrap().unwrap();
+                let actual = solve(&problem).unwrap();
+                assert_eq!(
+                    problem.evaluate(&actual).unwrap(),
+                    problem.evaluate(&expected).unwrap()
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn test_subset_dp_shortest_common_superstring_handles_containment_and_scale() {
+    let problem = ShortestCommonSuperstring::new(
+        4,
+        vec![
+            vec![0, 1, 2, 3],
+            vec![1, 2],
+            vec![2, 3, 0],
+            vec![3, 0, 1],
+            vec![0, 1],
+        ],
+    );
+    let solution = solve(&problem).unwrap();
+    assert_eq!(problem.evaluate(&solution).unwrap().0, Some(6));
+}
diff --git a/src/unit_tests/solvers/customized/solver.rs b/src/unit_tests/solvers/customized/solver.rs
index 09127b0d5..85294c3e6 100644
--- a/src/unit_tests/solvers/customized/solver.rs
+++ b/src/unit_tests/solvers/customized/solver.rs
@@ -1,9 +1,42 @@
-use crate::config::DimsIterator;
 use crate::models::graph::{PartialFeedbackEdgeSet, RootedTreeArrangement};
-use crate::solvers::CustomizedSolver;
+use crate::solvers::brute_force::CartesianIndices;
+use crate::solvers::registry::solver_capability_registry;
+use crate::solvers::BruteForceProblem as _;
+use crate::solvers::ExactProblemKey;
 use crate::topology::{Graph, SimpleGraph};
 use crate::traits::Problem;
 
+struct CustomizedTestSolver;
+
+impl CustomizedTestSolver {
+    fn new() -> Self {
+        Self
+    }
+
+    fn solve_dyn<P>(&self, problem: &P) -> Option<P::Solution>
+    where
+        P: Problem + 'static,
+        P::Solution: serde::de::DeserializeOwned,
+    {
+        let key = ExactProblemKey::new(
+            P::NAME,
+            P::variant()
+                .into_iter()
+                .map(|(key, value)| (key.to_string(), value.to_string()))
+                .collect(),
+        );
+        let registration = solver_capability_registry()
+            .unwrap()
+            .lookup(&key)
+            .customized?;
+        let solution = (registration.solve_fn)(problem).unwrap()?;
+        Some(
+            serde_json::from_value(solution)
+                .expect("customized solver returned the wrong witness representation"),
+        )
+    }
+}
+
 fn all_simple_graphs(num_vertices: usize) -> impl Iterator<Item = SimpleGraph> {
     let candidate_edges: Vec<(usize, usize)> = (0..num_vertices)
         .flat_map(|u| ((u + 1)..num_vertices).map(move |v| (u, v)))
@@ -26,20 +59,26 @@ fn exact_partial_feedback_edge_set_feasible(
     max_cycle_length: usize,
 ) -> bool {
     let problem = PartialFeedbackEdgeSet::new(graph.clone(), budget, max_cycle_length);
-    DimsIterator::new(problem.dims()).any(|config| problem.evaluate(&config).0)
+    CartesianIndices::new(problem.dimensions())
+        .unwrap()
+        .any(|config| {
+            let solution = crate::config::config_to_bits(&config);
+            problem.evaluate(&solution).unwrap().0
+        })
 }
 
-fn exact_rooted_tree_arrangement_min_stretch(graph: &SimpleGraph) -> Option<usize> {
-    let problem = RootedTreeArrangement::new(graph.clone(), usize::MAX);
-    DimsIterator::new(problem.dims())
-        .filter_map(|config| problem.total_edge_stretch(&config))
+fn exact_rooted_tree_arrangement_min_stretch(graph: &SimpleGraph) -> Option<i64> {
+    let problem = RootedTreeArrangement::new(graph.clone(), i64::MAX);
+    CartesianIndices::new(problem.dimensions())
+        .unwrap()
+        .filter_map(|config| problem.total_edge_stretch(&config).unwrap())
         .min()
 }
 
 #[test]
 fn test_customized_solver_returns_none_for_unsupported_problem() {
     let problem = crate::models::misc::GroupingBySwapping::new(3, vec![0, 1, 2, 0, 1, 2], 2);
-    let solver = CustomizedSolver::new();
+    let solver = CustomizedTestSolver::new();
     assert!(solver.solve_dyn(&problem).is_none());
 }
 
@@ -51,12 +90,12 @@ fn test_customized_solver_matches_bruteforce_for_minimum_cardinality_key() {
         4,
         vec![(vec![0], vec![1]), (vec![1, 2], vec![3])],
     );
-    let brute = crate::solvers::BruteForce::new().find_witness(&problem);
-    let custom = CustomizedSolver::new().solve_dyn(&problem);
+    let brute = crate::solvers::BruteForce::new().solve(&problem).unwrap();
+    let custom = CustomizedTestSolver::new().solve_dyn(&problem);
     assert_eq!(custom.is_some(), brute.is_some());
     if let (Some(bw), Some(cw)) = (&brute, &custom) {
-        let brute_val = problem.evaluate(bw);
-        let custom_val = problem.evaluate(cw);
+        let brute_val = problem.evaluate(bw).unwrap();
+        let custom_val = problem.evaluate(cw).unwrap();
         assert!(custom_val.0.is_some(), "witness must satisfy the problem");
         assert_eq!(
             custom_val, brute_val,
@@ -73,11 +112,14 @@ fn test_customized_solver_matches_bruteforce_for_additional_key() {
         vec![0, 1, 2],
         vec![],
     );
-    let brute = crate::solvers::BruteForce::new().find_witness(&problem);
-    let custom = CustomizedSolver::new().solve_dyn(&problem);
+    let brute = crate::solvers::BruteForce::new().solve(&problem).unwrap();
+    let custom = CustomizedTestSolver::new().solve_dyn(&problem);
     assert_eq!(custom.is_some(), brute.is_some());
     if let Some(w) = &custom {
-        assert!(problem.evaluate(w).0, "witness must satisfy the problem");
+        assert!(
+            problem.evaluate(w).unwrap().0,
+            "witness must satisfy the problem"
+        );
     }
 }
 
@@ -88,11 +130,14 @@ fn test_customized_solver_matches_bruteforce_for_prime_attribute_name() {
         vec![(vec![0, 1], vec![2, 3]), (vec![2], vec![0])],
         0,
     );
-    let brute = crate::solvers::BruteForce::new().find_witness(&problem);
-    let custom = CustomizedSolver::new().solve_dyn(&problem);
+    let brute = crate::solvers::BruteForce::new().solve(&problem).unwrap();
+    let custom = CustomizedTestSolver::new().solve_dyn(&problem);
     assert_eq!(custom.is_some(), brute.is_some());
     if let Some(w) = &custom {
-        assert!(problem.evaluate(w).0, "witness must satisfy the problem");
+        assert!(
+            problem.evaluate(w).unwrap().0,
+            "witness must satisfy the problem"
+        );
     }
 }
 
@@ -103,11 +148,14 @@ fn test_customized_solver_matches_bruteforce_for_bcnf_violation() {
         vec![(vec![0], vec![1]), (vec![2], vec![3])],
         vec![0, 1, 2, 3],
     );
-    let brute = crate::solvers::BruteForce::new().find_witness(&problem);
-    let custom = CustomizedSolver::new().solve_dyn(&problem);
+    let brute = crate::solvers::BruteForce::new().solve(&problem).unwrap();
+    let custom = CustomizedTestSolver::new().solve_dyn(&problem);
     assert_eq!(custom.is_some(), brute.is_some());
     if let Some(w) = &custom {
-        assert!(problem.evaluate(w).0, "witness must satisfy the problem");
+        assert!(
+            problem.evaluate(w).unwrap().0,
+            "witness must satisfy the problem"
+        );
     }
 }
 
@@ -124,10 +172,10 @@ fn test_customized_solver_finds_minimum_cardinality_key_witness() {
             (vec![2, 4], vec![5]),
         ],
     );
-    let witness = CustomizedSolver::new()
+    let witness = CustomizedTestSolver::new()
         .solve_dyn(&problem)
         .expect("expected witness");
-    assert!(problem.evaluate(&witness).0.is_some());
+    assert!(problem.evaluate(&witness).unwrap().0.is_some());
 }
 
 #[test]
@@ -144,10 +192,10 @@ fn test_customized_solver_finds_additional_key_witness() {
         vec![0, 1, 2, 3, 4, 5],
         vec![vec![0, 1], vec![2, 3], vec![4, 5]],
     );
-    let witness = CustomizedSolver::new()
+    let witness = CustomizedTestSolver::new()
         .solve_dyn(&problem)
         .expect("expected witness");
-    assert!(problem.evaluate(&witness).0);
+    assert!(problem.evaluate(&witness).unwrap().0);
 }
 
 #[test]
@@ -161,10 +209,10 @@ fn test_customized_solver_finds_prime_attribute_name_witness() {
         ],
         3,
     );
-    let witness = CustomizedSolver::new()
+    let witness = CustomizedTestSolver::new()
         .solve_dyn(&problem)
         .expect("expected witness");
-    assert!(problem.evaluate(&witness).0);
+    assert!(problem.evaluate(&witness).unwrap().0);
 }
 
 #[test]
@@ -178,10 +226,10 @@ fn test_customized_solver_finds_bcnf_violation_witness() {
         ],
         vec![0, 1, 2, 3, 4, 5],
     );
-    let witness = CustomizedSolver::new()
+    let witness = CustomizedTestSolver::new()
         .solve_dyn(&problem)
         .expect("expected witness");
-    assert!(problem.evaluate(&witness).0);
+    assert!(problem.evaluate(&witness).unwrap().0);
 }
 
 #[test]
@@ -197,7 +245,7 @@ fn test_customized_solver_no_witness_when_no_solution_exists() {
         vec![0, 1, 2],
         vec![vec![0], vec![1], vec![2]],
     );
-    assert!(CustomizedSolver::new().solve_dyn(&problem).is_none());
+    assert!(CustomizedTestSolver::new().solve_dyn(&problem).is_none());
 }
 
 #[test]
@@ -205,13 +253,13 @@ fn test_customized_solver_minimum_cardinality_key_finds_minimum() {
     // All 3 attributes needed as a key (no single-attribute key exists)
     let problem = crate::models::set::MinimumCardinalityKey::new(3, vec![(vec![0, 1], vec![2])]);
     // Both solvers should find a solution (the minimum cardinality key)
-    let brute = crate::solvers::BruteForce::new().find_witness(&problem);
-    let custom = CustomizedSolver::new().solve_dyn(&problem);
+    let brute = crate::solvers::BruteForce::new().solve(&problem).unwrap();
+    let custom = CustomizedTestSolver::new().solve_dyn(&problem);
     assert!(brute.is_some());
     assert!(custom.is_some());
     // Verify optimality: customized solver returns same value as brute force
-    let brute_val = problem.evaluate(brute.as_ref().unwrap());
-    let custom_val = problem.evaluate(custom.as_ref().unwrap());
+    let brute_val = problem.evaluate(brute.as_ref().unwrap()).unwrap();
+    let custom_val = problem.evaluate(custom.as_ref().unwrap()).unwrap();
     assert_eq!(
         custom_val, brute_val,
         "customized solver must find optimal key"
@@ -231,12 +279,12 @@ fn test_customized_solver_minimum_cardinality_key_optimality() {
             (vec![2, 4], vec![5]),
         ],
     );
-    let brute = crate::solvers::BruteForce::new().find_witness(&problem);
-    let custom = CustomizedSolver::new().solve_dyn(&problem);
+    let brute = crate::solvers::BruteForce::new().solve(&problem).unwrap();
+    let custom = CustomizedTestSolver::new().solve_dyn(&problem);
     assert!(brute.is_some());
     assert!(custom.is_some());
-    let brute_val = problem.evaluate(brute.as_ref().unwrap());
-    let custom_val = problem.evaluate(custom.as_ref().unwrap());
+    let brute_val = problem.evaluate(brute.as_ref().unwrap()).unwrap();
+    let custom_val = problem.evaluate(custom.as_ref().unwrap()).unwrap();
     assert_eq!(
         custom_val, brute_val,
         "customized solver must return minimum-cardinality key, not just any minimal key"
@@ -284,7 +332,7 @@ fn test_customized_solver_solves_partial_feedback_edge_set_yes_and_no() {
         4,
     );
 
-    let solver = CustomizedSolver::new();
+    let solver = CustomizedTestSolver::new();
     let yes_result = solver.solve_dyn(&yes);
     assert!(yes_result.is_some(), "expected a solution for yes instance");
     assert!(
@@ -306,11 +354,14 @@ fn test_customized_solver_matches_bruteforce_for_partial_feedback_edge_set() {
         1,
         3,
     );
-    let brute = crate::solvers::BruteForce::new().find_witness(&problem);
-    let custom = CustomizedSolver::new().solve_dyn(&problem);
+    let brute = crate::solvers::BruteForce::new().solve(&problem).unwrap();
+    let custom = CustomizedTestSolver::new().solve_dyn(&problem);
     assert_eq!(custom.is_some(), brute.is_some());
     if let Some(w) = &custom {
-        assert!(problem.evaluate(w).0, "witness must satisfy the problem");
+        assert!(
+            problem.evaluate(w).unwrap().0,
+            "witness must satisfy the problem"
+        );
     }
 }
 
@@ -322,10 +373,10 @@ fn test_customized_solver_partial_feedback_edge_set_no_cycles() {
         0,
         3,
     );
-    let result = CustomizedSolver::new().solve_dyn(&problem);
+    let result = CustomizedTestSolver::new().solve_dyn(&problem);
     assert!(result.is_some());
     // All zeros: no edges removed
-    assert_eq!(result.unwrap(), vec![0, 0, 0]);
+    assert_eq!(result.unwrap(), vec![false, false, false]);
 }
 
 #[test]
@@ -337,7 +388,7 @@ fn test_customized_solver_matches_exhaustive_search_for_small_partial_feedback_e
                 let problem = PartialFeedbackEdgeSet::new(graph.clone(), budget, max_cycle_length);
                 let exact_feasible =
                     exact_partial_feedback_edge_set_feasible(&graph, budget, max_cycle_length);
-                let custom = CustomizedSolver::new().solve_dyn(&problem);
+                let custom = CustomizedTestSolver::new().solve_dyn(&problem);
 
                 assert_eq!(
                     custom.is_some(),
@@ -347,7 +398,7 @@ fn test_customized_solver_matches_exhaustive_search_for_small_partial_feedback_e
                 );
                 if let Some(witness) = custom {
                     assert!(
-                        problem.evaluate(&witness).0,
+                        problem.evaluate(&witness).unwrap().0,
                         "customized witness must satisfy graph={:?}, budget={budget}, max_cycle_length={max_cycle_length}",
                         graph.edges()
                     );
@@ -365,10 +416,13 @@ fn test_customized_solver_finds_rooted_tree_arrangement_witness() {
         crate::topology::SimpleGraph::new(5, vec![(0, 1), (0, 2), (1, 2), (2, 3), (3, 4)]),
         7,
     );
-    let witness = CustomizedSolver::new()
+    let witness = CustomizedTestSolver::new()
         .solve_dyn(&problem)
         .expect("expected arrangement witness");
-    assert!(problem.evaluate(&witness).0, "witness must be valid");
+    assert!(
+        problem.evaluate(&witness).unwrap().0,
+        "witness must be valid"
+    );
 }
 
 #[test]
@@ -378,11 +432,11 @@ fn test_customized_solver_matches_bruteforce_for_rooted_tree_arrangement() {
         crate::topology::SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
         3,
     );
-    let brute = crate::solvers::BruteForce::new().find_witness(&problem);
-    let custom = CustomizedSolver::new().solve_dyn(&problem);
+    let brute = crate::solvers::BruteForce::new().solve(&problem).unwrap();
+    let custom = CustomizedTestSolver::new().solve_dyn(&problem);
     assert_eq!(custom.is_some(), brute.is_some());
     if let Some(w) = &custom {
-        assert!(problem.evaluate(w).0, "witness must be valid");
+        assert!(problem.evaluate(w).unwrap().0, "witness must be valid");
     }
 }
 
@@ -394,8 +448,8 @@ fn test_customized_solver_rooted_tree_arrangement_tight_bound() {
         1,
     );
     // With bound=1, we need total stretch=1, but path 0-1-2 needs at minimum 2
-    let custom = CustomizedSolver::new().solve_dyn(&problem);
-    let brute = crate::solvers::BruteForce::new().find_witness(&problem);
+    let custom = CustomizedTestSolver::new().solve_dyn(&problem);
+    let brute = crate::solvers::BruteForce::new().solve(&problem).unwrap();
     assert_eq!(custom.is_some(), brute.is_some());
 }
 
@@ -406,10 +460,13 @@ fn test_customized_solver_rooted_tree_arrangement_canonical_example() {
         crate::topology::SimpleGraph::new(4, vec![(0, 1), (0, 2), (1, 2), (2, 3)]),
         5,
     );
-    let witness = CustomizedSolver::new()
+    let witness = CustomizedTestSolver::new()
         .solve_dyn(&problem)
         .expect("expected witness");
-    assert!(problem.evaluate(&witness).0, "witness must be valid");
+    assert!(
+        problem.evaluate(&witness).unwrap().0,
+        "witness must be valid"
+    );
 }
 
 #[test]
@@ -421,8 +478,9 @@ fn test_customized_solver_matches_exhaustive_search_for_small_rooted_tree_arrang
             .saturating_mul(graph.num_vertices().saturating_sub(1));
 
         for bound in 0..=max_bound {
+            let bound = i64::try_from(bound).unwrap();
             let problem = RootedTreeArrangement::new(graph.clone(), bound);
-            let custom = CustomizedSolver::new().solve_dyn(&problem);
+            let custom = CustomizedTestSolver::new().solve_dyn(&problem);
             let exact_feasible = exact_min_stretch.is_some_and(|stretch| stretch <= bound);
 
             assert_eq!(
@@ -433,7 +491,7 @@ fn test_customized_solver_matches_exhaustive_search_for_small_rooted_tree_arrang
             );
             if let Some(witness) = custom {
                 assert!(
-                    problem.evaluate(&witness).0,
+                    problem.evaluate(&witness).unwrap().0,
                     "customized witness must satisfy graph={:?}, bound={bound}",
                     graph.edges()
                 );
diff --git a/src/unit_tests/solvers/decision_search.rs b/src/unit_tests/solvers/decision_search.rs
index 78912666a..1a56f00de 100644
--- a/src/unit_tests/solvers/decision_search.rs
+++ b/src/unit_tests/solvers/decision_search.rs
@@ -3,33 +3,33 @@ use crate::models::graph::{MaximumIndependentSet, MinimumVertexCover};
 use crate::solvers::BruteForce;
 use crate::topology::SimpleGraph;
 use crate::types::{Max, Min};
-use crate::Solver;
 
 #[test]
 fn test_decision_search_min() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumVertexCover::new(graph, vec![1i32; 3]);
+    let problem = MinimumVertexCover::new(graph, vec![1i64; 3]);
 
-    assert_eq!(solve_via_decision(&problem, 0, 3), Some(1));
+    assert_eq!(solve_via_decision(&problem, 0, 3).unwrap(), Some(1));
 }
 
 #[test]
 fn test_decision_search_max() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MaximumIndependentSet::new(graph, vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(graph, vec![1i64; 3]);
 
-    assert_eq!(solve_via_decision(&problem, 0, 3), Some(2));
+    assert_eq!(solve_via_decision(&problem, 0, 3).unwrap(), Some(2));
 }
 
 #[test]
 fn test_decision_search_matches_brute_force() {
     let graph = SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]);
-    let problem = MinimumVertexCover::new(graph, vec![1i32; 5]);
+    let problem = MinimumVertexCover::new(graph, vec![1i64; 5]);
 
-    let brute_force_value = BruteForce::new().solve(&problem);
+    let solution = BruteForce::new().solve(&problem).unwrap().unwrap();
+    let brute_force_value = problem.evaluate(&solution).unwrap();
 
     assert_eq!(
-        solve_via_decision(&problem, 0, 5),
+        solve_via_decision(&problem, 0, 5).unwrap(),
         brute_force_value.size().copied()
     );
 }
@@ -37,40 +37,42 @@ fn test_decision_search_matches_brute_force() {
 #[test]
 fn test_decision_search_min_returns_none_when_upper_bound_is_too_small() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MinimumVertexCover::new(graph, vec![1i32; 3]);
+    let problem = MinimumVertexCover::new(graph, vec![1i64; 3]);
 
-    assert_eq!(solve_via_decision(&problem, 0, 0), None);
+    assert_eq!(solve_via_decision(&problem, 0, 0).unwrap(), None);
 }
 
 #[test]
 fn test_decision_search_max_returns_none_when_interval_is_above_optimum() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let problem = MaximumIndependentSet::new(graph, vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(graph, vec![1i64; 3]);
 
-    assert_eq!(solve_via_decision(&problem, 3, 4), None);
+    assert_eq!(solve_via_decision(&problem, 3, 4).unwrap(), None);
 }
 
 #[test]
 fn test_decision_search_invalid_interval_returns_none() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let min_problem = MinimumVertexCover::new(graph.clone(), vec![1i32; 3]);
-    let max_problem = MaximumIndependentSet::new(graph, vec![1i32; 3]);
+    let min_problem = MinimumVertexCover::new(graph.clone(), vec![1i64; 3]);
+    let max_problem = MaximumIndependentSet::new(graph, vec![1i64; 3]);
 
-    assert_eq!(solve_via_decision(&min_problem, 2, 1), None);
-    assert_eq!(solve_via_decision(&max_problem, 2, 1), None);
+    assert_eq!(solve_via_decision(&min_problem, 2, 1).unwrap(), None);
+    assert_eq!(solve_via_decision(&max_problem, 2, 1).unwrap(), None);
 }
 
 #[test]
 fn test_decision_search_preserves_value_direction() {
     let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2)]);
-    let min_problem = MinimumVertexCover::new(graph.clone(), vec![1i32; 3]);
-    let max_problem = MaximumIndependentSet::new(graph, vec![1i32; 3]);
+    let min_problem = MinimumVertexCover::new(graph.clone(), vec![1i64; 3]);
+    let max_problem = MaximumIndependentSet::new(graph, vec![1i64; 3]);
 
-    let min_value = BruteForce::new().solve(&min_problem);
-    let max_value = BruteForce::new().solve(&max_problem);
+    let min_solution = BruteForce::new().solve(&min_problem).unwrap().unwrap();
+    let max_solution = BruteForce::new().solve(&max_problem).unwrap().unwrap();
+    let min_value = min_problem.evaluate(&min_solution).unwrap();
+    let max_value = max_problem.evaluate(&max_solution).unwrap();
 
     assert_eq!(min_value, Min(Some(1)));
     assert_eq!(max_value, Max(Some(2)));
-    assert_eq!(solve_via_decision(&min_problem, 0, 3), Some(1));
-    assert_eq!(solve_via_decision(&max_problem, 0, 3), Some(2));
+    assert_eq!(solve_via_decision(&min_problem, 0, 3).unwrap(), Some(1));
+    assert_eq!(solve_via_decision(&max_problem, 0, 3).unwrap(), Some(2));
 }
diff --git a/src/unit_tests/solvers/ilp/solver.rs b/src/unit_tests/solvers/ilp/solver.rs
index 310ab6fa2..5c193553e 100644
--- a/src/unit_tests/solvers/ilp/solver.rs
+++ b/src/unit_tests/solvers/ilp/solver.rs
@@ -1,390 +1,327 @@
 use super::*;
-use crate::models::algebraic::LinearConstraint;
-use crate::solvers::BruteForce;
+use crate::models::algebraic::{IntegerVariable, LinearConstraint};
 use crate::traits::Problem;
 
+fn binary_ilp(
+    num_vars: usize,
+    constraints: Vec<LinearConstraint>,
+    objective: Vec<(usize, i64)>,
+    sense: ObjectiveSense,
+) -> ILP<bool> {
+    ILP::new(num_vars, constraints, objective, sense).unwrap()
+}
+
 #[test]
 fn test_ilp_solver_basic_maximize() {
-    // Maximize x0 + 2*x1 subject to x0 + x1 <= 1, binary vars
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 2.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1), (1, 2)],
         ObjectiveSense::Maximize,
     );
-
-    let solver = ILPSolver::new();
-    let solution = solver.solve(&ilp);
-
-    assert!(solution.is_some());
-    let sol = solution.unwrap();
-
-    // Solution should be valid
-    let result = ilp.evaluate(&sol);
-    assert!(result.is_valid(), "ILP solution should be valid");
-
-    // Optimal: x1=1, x0=0 => objective = 2
-    assert!((result.unwrap() - 2.0).abs() < 1e-9);
+    let solution = ILPSolver::new().solve(&ilp).unwrap();
+    assert_eq!(solution, vec![0, 1]);
+    assert_eq!(ilp.evaluate_objective(&solution).unwrap(), 2);
 }
 
 #[test]
 fn test_ilp_solver_basic_minimize() {
-    // Minimize x0 + x1 subject to x0 + x1 >= 1, binary vars
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         2,
-        vec![LinearConstraint::ge(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 1.0)],
+        vec![LinearConstraint::ge(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1), (1, 1)],
         ObjectiveSense::Minimize,
     );
-
-    let solver = ILPSolver::new();
-    let solution = solver.solve(&ilp);
-
-    assert!(solution.is_some());
-    let sol = solution.unwrap();
-
-    // Solution should be valid
-    let result = ilp.evaluate(&sol);
-    assert!(result.is_valid(), "ILP solution should be valid");
-
-    // Optimal: one variable = 1, other = 0 => objective = 1
-    assert!((result.unwrap() - 1.0).abs() < 1e-9);
+    let solution = ILPSolver::new().solve(&ilp).unwrap();
+    assert_eq!(ilp.evaluate_objective(&solution).unwrap(), 1);
 }
 
 #[test]
 fn test_ilp_solver_matches_brute_force() {
-    // Maximize x0 + x1 + x2 subject to:
-    //   x0 + x1 <= 1
-    //   x1 + x2 <= 1
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         3,
         vec![
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0),
-            LinearConstraint::le(vec![(1, 1.0), (2, 1.0)], 1.0),
+            LinearConstraint::le(vec![(0, 1), (1, 1)], 1),
+            LinearConstraint::le(vec![(1, 1), (2, 1)], 1),
         ],
-        vec![(0, 1.0), (1, 1.0), (2, 1.0)],
+        vec![(0, 1), (1, 1), (2, 1)],
         ObjectiveSense::Maximize,
     );
-
-    let bf = BruteForce::new();
-    let ilp_solver = ILPSolver::new();
-
-    let bf_solutions = bf.find_all_witnesses(&ilp);
-    let ilp_solution = ilp_solver.solve(&ilp).unwrap();
-
-    // Both should find optimal value (2)
-    let bf_size = ilp.evaluate(&bf_solutions[0]).unwrap();
-    let ilp_size = ilp.evaluate(&ilp_solution).unwrap();
-    assert!(
-        (bf_size - ilp_size).abs() < 1e-9,
-        "ILP should find optimal solution"
-    );
+    let solution = ILPSolver::new().solve(&ilp).unwrap();
+    assert_eq!(ilp.evaluate_objective(&solution).unwrap(), 2);
 }
 
 #[test]
 fn test_ilp_empty_problem() {
-    let ilp = ILP::<bool>::empty();
-    let solver = ILPSolver::new();
-    let solution = solver.solve(&ilp);
-    assert_eq!(solution, Some(vec![]));
+    assert_eq!(ILPSolver::new().solve(&ILP::<bool>::empty()), Ok(vec![]));
 }
 
 #[test]
-fn test_ilp_empty_problem_with_infeasible_constraint_returns_none() {
-    let ilp = ILP::<bool>::new(
+fn test_ilp_empty_problem_with_infeasible_constraint_returns_infeasible() {
+    let ilp = binary_ilp(
         0,
-        vec![LinearConstraint::le(vec![], -1.0)],
+        vec![LinearConstraint::le(vec![], -1)],
         vec![],
         ObjectiveSense::Minimize,
     );
-    let solver = ILPSolver::new();
-    let solution = solver.solve(&ilp);
-    assert_eq!(solution, None);
+    assert_eq!(ILPSolver::new().solve(&ilp), Err(ILPSolveError::Infeasible));
 }
 
 #[test]
-fn test_ilp_equality_constraint() {
-    // Minimize x0 subject to x0 + x1 == 1, binary vars
-    let ilp = ILP::<bool>::new(
-        2,
-        vec![LinearConstraint::eq(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0)],
-        ObjectiveSense::Minimize,
-    );
-
-    let solver = ILPSolver::new();
-    let solution = solver.solve(&ilp).unwrap();
+fn test_ilp_solver_disambiguates_unbounded_model() {
+    let ilp = ILP::<i64>::with_variables(
+        vec![IntegerVariable::free()],
+        vec![LinearConstraint::ge(vec![(0, 1)], 0)],
+        vec![(0, 1)],
+        ObjectiveSense::Maximize,
+    )
+    .unwrap();
 
-    let result = ilp.evaluate(&solution);
-    assert!(result.is_valid());
-    // Optimal: x0=0, x1=1 => objective = 0
-    assert!((result.unwrap() - 0.0).abs() < 1e-9);
+    assert_eq!(ILPSolver::new().solve(&ilp), Err(ILPSolveError::Unbounded));
 }
 
 #[test]
-fn test_ilp_non_binary_bounds() {
-    // Variables with larger ranges
-    // x0 in [0, 3], x1 in [0, 2]
-    // Maximize x0 + x1 subject to x0 + x1 <= 4
-    // Use ILP::<i32> with explicit upper-bound constraints
-    let ilp = ILP::<i32>::new(
-        2,
+fn test_ilp_solver_disambiguates_infeasible_model() {
+    let ilp = ILP::<i64>::with_variables(
+        vec![IntegerVariable::free()],
         vec![
-            LinearConstraint::le(vec![(0, 1.0)], 3.0),
-            LinearConstraint::le(vec![(1, 1.0)], 2.0),
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 4.0),
+            LinearConstraint::ge(vec![(0, 1)], 1),
+            LinearConstraint::le(vec![(0, 1)], 0),
         ],
-        vec![(0, 1.0), (1, 1.0)],
+        vec![(0, 1)],
         ObjectiveSense::Maximize,
-    );
+    )
+    .unwrap();
+
+    assert_eq!(ILPSolver::new().solve(&ilp), Err(ILPSolveError::Infeasible));
+}
+
+#[test]
+fn test_ilp_solver_rejects_inexact_integer_transport() {
+    let value = crate::types::MAX_EXACT_F64_INTEGER + 1;
+    let ilp = ILP::<i64>::with_variables(
+        vec![IntegerVariable::new(Some(value), Some(value)).unwrap()],
+        vec![],
+        vec![],
+        ObjectiveSense::Minimize,
+    )
+    .unwrap();
 
-    let solver = ILPSolver::new();
-    let solution = solver.solve(&ilp).unwrap();
+    assert!(matches!(
+        ILPSolver::new().solve(&ilp),
+        Err(ILPSolveError::InexactTransport(_))
+    ));
+}
 
-    let result = ilp.evaluate(&solution);
-    assert!(result.is_valid());
-    // Optimal: x0=2, x1=2 => 4 <= 4 valid, obj=4
-    // or x0=3, x1=1 => 4 <= 4 valid, obj=4
-    assert!((result.unwrap() - 4.0).abs() < 1e-9);
+#[test]
+fn test_backend_errors_are_classified_without_losing_the_cause() {
+    assert_eq!(
+        classify_backend_error(ResolutionError::Infeasible, None),
+        ILPSolveError::Infeasible,
+    );
+    assert_eq!(
+        classify_backend_error(ResolutionError::Unbounded, None),
+        ILPSolveError::Unbounded,
+    );
+    assert_eq!(
+        classify_backend_error(ResolutionError::Other("NoSolutionFound"), Some(0.1)),
+        ILPSolveError::Timeout,
+    );
+    assert!(matches!(
+        classify_backend_error(ResolutionError::Other("SolveError"), None),
+        ILPSolveError::BackendFailure(message) if message.contains("SolveError")
+    ));
 }
 
 #[test]
-fn test_ilp_integer_upper_bounds() {
-    // Variables with upper bounds (non-negative integers)
-    // x0 in [0, 4], x1 in [0, 2]
-    // Maximize x0 + x1 (with explicit upper-bound constraints)
-    let ilp = ILP::<i32>::new(
-        2,
-        vec![
-            LinearConstraint::le(vec![(0, 1.0)], 4.0),
-            LinearConstraint::le(vec![(1, 1.0)], 2.0),
-        ],
-        vec![(0, 1.0), (1, 1.0)],
+fn test_ilp_rejects_solution_that_is_infeasible_after_rounding() {
+    let ilp = binary_ilp(
+        1,
+        vec![LinearConstraint::le(vec![(0, 1)], 0)],
+        vec![(0, 1)],
         ObjectiveSense::Maximize,
     );
+    let solution = ILPSolver::new().solve(&ilp).unwrap();
+    assert_eq!(solution, vec![0]);
+    assert!(ilp.is_feasible(&solution).unwrap());
+}
 
-    let solver = ILPSolver::new();
-    let solution = solver.solve(&ilp).unwrap();
+#[test]
+fn test_ilp_equality_constraint() {
+    let ilp = binary_ilp(
+        2,
+        vec![LinearConstraint::eq(vec![(0, 1), (1, 1)], 1)],
+        vec![(0, 1)],
+        ObjectiveSense::Minimize,
+    );
+    assert_eq!(ILPSolver::new().solve(&ilp).unwrap(), vec![0, 1]);
+}
 
-    let result = ilp.evaluate(&solution);
-    assert!(result.is_valid());
-    // Optimal: x0=4, x1=2 => objective = 6
-    assert!((result.unwrap() - 6.0).abs() < 1e-9);
+fn bounded_integer_ilp(upper_bounds: &[i64]) -> ILP<i64> {
+    let variables = upper_bounds
+        .iter()
+        .map(|&upper| IntegerVariable::new(Some(0), Some(upper)).unwrap())
+        .collect();
+    ILP::with_variables(
+        variables,
+        vec![],
+        (0..upper_bounds.len()).map(|index| (index, 1)).collect(),
+        ObjectiveSense::Maximize,
+    )
+    .unwrap()
 }
 
 #[test]
-fn test_ilp_config_to_values_roundtrip() {
-    // Ensure the config encoding/decoding works correctly
-    // x0 in [0, 5], x1 in [0, 3], maximize x0 + x1
-    let ilp = ILP::<i32>::new(
-        2,
+fn test_ilp_non_binary_bounds() {
+    let ilp = ILP::<i64>::with_variables(
         vec![
-            LinearConstraint::le(vec![(0, 1.0)], 5.0),
-            LinearConstraint::le(vec![(1, 1.0)], 3.0),
+            IntegerVariable::new(Some(0), Some(3)).unwrap(),
+            IntegerVariable::new(Some(0), Some(2)).unwrap(),
         ],
-        vec![(0, 1.0), (1, 1.0)],
+        vec![LinearConstraint::le(vec![(0, 1), (1, 1)], 4)],
+        vec![(0, 1), (1, 1)],
         ObjectiveSense::Maximize,
-    );
+    )
+    .unwrap();
+    let solution = ILPSolver::new().solve(&ilp).unwrap();
+    assert_eq!(ilp.evaluate_objective(&solution).unwrap(), 4);
+}
 
-    let solver = ILPSolver::new();
-    let solution = solver.solve(&ilp).unwrap();
+#[test]
+fn test_ilp_integer_upper_bounds() {
+    let ilp = bounded_integer_ilp(&[4, 2]);
+    assert_eq!(ILPSolver::new().solve(&ilp).unwrap(), vec![4, 2]);
+}
 
-    // The solution should be valid
-    let result = ilp.evaluate(&solution);
-    assert!(result.is_valid());
-    // Optimal: x0=5, x1=3 => objective = 8
-    assert!((result.unwrap() - 8.0).abs() < 1e-9);
+#[test]
+fn test_ilp_config_to_values_roundtrip() {
+    let ilp = bounded_integer_ilp(&[5, 3]);
+    let solution = ILPSolver::new().solve(&ilp).unwrap();
+    assert_eq!(solution, vec![5, 3]);
+    assert!(ilp.is_feasible(&solution).unwrap());
 }
 
 #[test]
 fn test_ilp_multiple_constraints() {
-    // Maximize 2*x0 + 3*x1 + x2 subject to:
-    //   x0 + x1 + x2 <= 2
-    //   x0 + x1 >= 1
-    // Binary vars
-    let ilp = ILP::<bool>::new(
+    let ilp = binary_ilp(
         3,
         vec![
-            LinearConstraint::le(vec![(0, 1.0), (1, 1.0), (2, 1.0)], 2.0),
-            LinearConstraint::ge(vec![(0, 1.0), (1, 1.0)], 1.0),
+            LinearConstraint::le(vec![(0, 1), (1, 1), (2, 1)], 2),
+            LinearConstraint::ge(vec![(0, 1), (1, 1)], 1),
         ],
-        vec![(0, 2.0), (1, 3.0), (2, 1.0)],
+        vec![(0, 2), (1, 3), (2, 1)],
         ObjectiveSense::Maximize,
     );
-
-    let solver = ILPSolver::new();
-    let solution = solver.solve(&ilp).unwrap();
-
-    let result = ilp.evaluate(&solution);
-    assert!(result.is_valid());
-
-    // Check against brute force
-    let bf = BruteForce::new();
-    let bf_solutions = bf.find_all_witnesses(&ilp);
-    let bf_size = ilp.evaluate(&bf_solutions[0]).unwrap();
-
-    assert!(
-        (bf_size - result.unwrap()).abs() < 1e-9,
-        "ILP should match brute force"
-    );
+    let solution = ILPSolver::new().solve(&ilp).unwrap();
+    assert_eq!(ilp.evaluate_objective(&solution).unwrap(), 5);
 }
 
 #[test]
 fn test_ilp_unconstrained() {
-    // Maximize x0 + x1, no constraints, binary vars
-    let ilp = ILP::<bool>::new(
-        2,
-        vec![],
-        vec![(0, 1.0), (1, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    let solver = ILPSolver::new();
-    let solution = solver.solve(&ilp).unwrap();
-
-    let result = ilp.evaluate(&solution);
-    assert!(result.is_valid());
-    // Optimal: both = 1
-    assert!((result.unwrap() - 2.0).abs() < 1e-9);
+    let ilp = binary_ilp(2, vec![], vec![(0, 1), (1, 1)], ObjectiveSense::Maximize);
+    assert_eq!(ILPSolver::new().solve(&ilp).unwrap(), vec![1, 1]);
 }
 
 #[test]
 fn test_ilp_with_time_limit() {
     let solver = ILPSolver::with_time_limit(10.0);
     assert_eq!(solver.time_limit, Some(10.0));
-
-    // Should still work for simple problems
-    let ilp = ILP::<bool>::new(
-        2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-
-    let solution = solver.solve(&ilp);
-    assert!(solution.is_some());
+    let ilp = binary_ilp(1, vec![], vec![(0, 1)], ObjectiveSense::Maximize);
+    assert!(solver.solve(&ilp).is_ok());
 }
 
 #[test]
-fn test_ilp_solve_via_reduction_success() {
+fn test_registered_ilp_pipeline_success() {
     use crate::models::graph::MaximumIndependentSet;
+    use crate::registry::load_dyn;
+    use crate::solvers::{solve, SolveOutcome, SolverExecution, SolverRequest};
     use crate::topology::SimpleGraph;
     use std::collections::BTreeMap;
 
-    let solver = ILPSolver::new();
-    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]);
+    let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1_i64; 3]);
     let variant = BTreeMap::from([
         ("graph".to_string(), "SimpleGraph".to_string()),
-        ("weight".to_string(), "i32".to_string()),
+        ("weight".to_string(), "i64".to_string()),
     ]);
-    let result = solver.try_solve_via_reduction("MaximumIndependentSet", &variant, &problem);
-    assert!(result.is_ok());
-    let sol = result.unwrap();
-    let eval = problem.evaluate(&sol);
-    assert!(eval.is_valid());
-}
-
-#[test]
-fn test_ilp_solve_via_reduction_no_path() {
-    use std::collections::BTreeMap;
-
-    // Use a problem name that doesn't exist in the graph
-    let solver = ILPSolver::new();
-    let ilp = ILP::<bool>::new(
-        2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-    // solve_via_reduction on an ILP itself should succeed directly
-    let result = solver.try_solve_via_reduction(
-        "ILP",
-        &BTreeMap::from([("type".to_string(), "bool".to_string())]),
-        &ilp,
-    );
-    assert!(result.is_ok());
+    let loaded = load_dyn(
+        "MaximumIndependentSet",
+        &variant,
+        serde_json::to_value(&problem).unwrap(),
+    )
+    .unwrap();
+    let result = solve(&loaded, SolverRequest::Ilp).unwrap();
+    assert!(matches!(result.solver, SolverExecution::Ilp { .. }));
+    let SolveOutcome::Optimal { solution, .. } = result.outcome else {
+        panic!("registered ILP pipeline should return an optimal witness");
+    };
+    let solution: Vec<bool> = serde_json::from_value(solution).unwrap();
+    assert!(problem.evaluate(&solution).unwrap().is_valid());
 }
 
 #[test]
 fn test_ilp_solve_dyn_bool() {
-    let solver = ILPSolver::new();
-    let ilp = ILP::<bool>::new(
-        2,
-        vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
-        vec![(0, 1.0), (1, 2.0)],
-        ObjectiveSense::Maximize,
-    );
-    let result = solver.solve_dyn(&ilp as &dyn std::any::Any);
-    assert!(result.is_some());
-}
-
-#[test]
-fn test_ilp_solve_dyn_i32() {
-    let solver = ILPSolver::new();
-    let ilp = ILP::<i32>::new(
-        2,
-        vec![LinearConstraint::le(vec![(0, 1.0)], 3.0)],
-        vec![(0, 1.0), (1, 1.0)],
-        ObjectiveSense::Maximize,
-    );
-    let result = solver.solve_dyn(&ilp as &dyn std::any::Any);
-    assert!(result.is_some());
+    let ilp = ILP::<bool, f64>::new(1, vec![], vec![(0, 1.0)], ObjectiveSense::Maximize).unwrap();
+    assert!(ILPSolver::new()
+        .solve_dyn(&ilp as &dyn std::any::Any)
+        .is_ok());
 }
 
 #[test]
-fn test_ilp_solve_dyn_unknown_type_returns_none() {
-    let solver = ILPSolver::new();
-    let not_ilp: i32 = 42;
-    let result = solver.solve_dyn(&not_ilp as &dyn std::any::Any);
-    assert!(result.is_none());
+fn test_ilp_solve_dyn_i64() {
+    let ilp = ILP::<i64, f64>::with_variables(
+        vec![
+            IntegerVariable::new(Some(0), Some(3)).unwrap(),
+            IntegerVariable::new(Some(0), Some(3)).unwrap(),
+        ],
+        vec![],
+        vec![],
+        ObjectiveSense::Minimize,
+    )
+    .unwrap();
+    assert!(ILPSolver::new()
+        .solve_dyn(&ilp as &dyn std::any::Any)
+        .is_ok());
 }
 
 #[test]
-fn test_ilp_supports_direct_dyn() {
-    let solver = ILPSolver::new();
-    let ilp_bool = ILP::<bool>::empty();
-    let ilp_i32 = ILP::<i32>::new(1, vec![], vec![], ObjectiveSense::Maximize);
-    let not_ilp: i32 = 42;
-
-    assert!(solver.supports_direct_dyn(&ilp_bool as &dyn std::any::Any));
-    assert!(solver.supports_direct_dyn(&ilp_i32 as &dyn std::any::Any));
-    assert!(!solver.supports_direct_dyn(&not_ilp as &dyn std::any::Any));
+fn test_ilp_solve_dyn_unknown_type_returns_unsupported_problem_type() {
+    let result = ILPSolver::new().solve_dyn(&42_i64 as &dyn std::any::Any);
+    assert_eq!(result, Err(ILPSolveError::UnsupportedProblemType));
 }
 
-#[test]
-fn test_solve_via_reduction_error_display() {
-    use crate::solvers::ilp::SolveViaReductionError;
-
-    let err = SolveViaReductionError::WitnessPathRequired {
-        name: "Foo".to_string(),
-    };
-    assert!(err.to_string().contains("witness-capable"));
-    assert!(err.to_string().contains("Foo"));
-
-    let err = SolveViaReductionError::NoReductionPath {
-        name: "Bar".to_string(),
-    };
-    assert!(err.to_string().contains("No reduction path"));
-    assert!(err.to_string().contains("Bar"));
-
-    let err = SolveViaReductionError::NoSolution {
-        name: "Baz".to_string(),
-    };
-    assert!(err.to_string().contains("no solution"));
-    assert!(err.to_string().contains("Baz"));
-
-    // std::error::Error is implemented
-    let _: &dyn std::error::Error = &err;
+// Test acceptance policy in source-objective units, separate from variable rounding.
+// This allows small absolute numerical differences near zero; it is not a
+// guaranteed objective-error bound derived from HiGHS feasibility tolerances.
+fn objective_close(a: f64, b: f64) -> bool {
+    let abs_tol = 1e-7;
+    let rel_tol = 1e-7;
+    (a - b).abs() <= abs_tol + rel_tol * a.abs().max(b.abs())
 }
 
 #[test]
-fn test_solve_via_reduction_returns_none_for_no_path() {
-    let solver = ILPSolver::new();
-    let not_ilp: i32 = 42;
-    let result = solver.solve_via_reduction(
-        "NonexistentProblem",
-        &std::collections::BTreeMap::new(),
-        &not_ilp as &dyn std::any::Any,
-    );
-    assert!(result.is_none());
+fn test_float_qubo_objective_matches_reference_within_tolerance() {
+    use crate::models::algebraic::QUBO;
+    use crate::solvers::BruteForce;
+
+    for scale in [1e-9, 1.0] {
+        let matrix = vec![
+            vec![1.0, -5.0, 3.0, -8.0],
+            vec![0.0, -7.0, 8.0, -6.0],
+            vec![0.0, 0.0, 2.0, 9.0],
+            vec![0.0, 0.0, 0.0, -8.0],
+        ]
+        .into_iter()
+        .map(|row| row.into_iter().map(|v| v * scale).collect())
+        .collect();
+        let source = QUBO::<f64>::from_matrix(matrix).unwrap();
+        let actual = ILPSolver::new().solve(&source).unwrap();
+        let reference = BruteForce::new().solve(&source).unwrap().unwrap();
+        let actual_value = source.evaluate(&actual).unwrap();
+        let reference_value = source.evaluate(&reference).unwrap();
+        assert!(actual_value.is_valid());
+        assert!(objective_close(
+            actual_value.0.unwrap(),
+            reference_value.0.unwrap()
+        ));
+    }
 }
diff --git a/src/unit_tests/solvers/registry.rs b/src/unit_tests/solvers/registry.rs
new file mode 100644
index 000000000..97c55d085
--- /dev/null
+++ b/src/unit_tests/solvers/registry.rs
@@ -0,0 +1,590 @@
+use super::*;
+use std::collections::BTreeMap;
+
+const BOOL_VARIANT: &[(&str, &str)] = &[("variable", "bool"), ("coefficient", "i64")];
+const FLOAT_BOOL_VARIANT: &[(&str, &str)] = &[("variable", "bool"), ("coefficient", "f64")];
+const FLOAT_I64_VARIANT: &[(&str, &str)] = &[("variable", "i64"), ("coefficient", "f64")];
+const NO_VARIANT: &[(&str, &str)] = &[];
+
+#[test]
+fn generic_decision_ilp_respects_maximization_bounds() {
+    use crate::models::decision::Decision;
+    use crate::models::graph::MaximumIndependentSet;
+    use crate::solvers::BruteForce;
+    use crate::topology::SimpleGraph;
+
+    // Exercise the same generic decision edge without adding a production solver registration.
+    static PIPELINE: IlpPipelineRegistration = IlpPipelineRegistration {
+        path: &[
+            StaticProblemStep {
+                name: "DecisionMaximumIndependentSet",
+                variant: &[("graph", "SimpleGraph"), ("weight", "i64")],
+            },
+            StaticProblemStep {
+                name: "MaximumIndependentSet",
+                variant: &[("graph", "SimpleGraph"), ("weight", "i64")],
+            },
+            StaticProblemStep {
+                name: "MaximumSetPacking",
+                variant: &[("weight", "i64")],
+            },
+            StaticProblemStep {
+                name: "ILP",
+                variant: BOOL_VARIANT,
+            },
+            StaticProblemStep {
+                name: "ILP",
+                variant: FLOAT_BOOL_VARIANT,
+            },
+        ],
+    };
+    let registry = build_registry(
+        &registered_variant_keys(),
+        inventory::iter::<CustomizedSolverRegistration>(),
+        inventory::iter::<IlpPipelineRegistration>().chain([&PIPELINE]),
+        inventory::iter::<crate::solvers::BruteForceRegistration>(),
+        &reduction_entries(),
+    )
+    .unwrap();
+    let source = ExactProblemKey::from_static(&PIPELINE.path[0]);
+    let pipeline = registry.lookup(&source).ilp.unwrap();
+    let inner = MaximumIndependentSet::new(
+        SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
+        vec![1i64; 3],
+    );
+    for bound in [0, 1, 2] {
+        let decision = Decision::new(inner.clone(), bound);
+        let result = pipeline.solve(&decision, &crate::solvers::ILPSolver::new());
+        if bound > 1 {
+            assert!(matches!(
+                result,
+                Err(crate::solvers::ILPSolveError::UnresolvedDecision(_))
+            ));
+            assert!(BruteForce::new().solve(&decision).unwrap().is_none());
+            continue;
+        }
+        let solution: Vec<bool> = serde_json::from_value(result.unwrap()).unwrap();
+        assert_eq!(
+            crate::traits::Problem::evaluate(&decision, &solution).unwrap(),
+            crate::types::Or(true)
+        );
+    }
+}
+
+#[test]
+fn generic_decision_ilp_reports_unresolved_but_preserves_extraction_errors() {
+    use crate::models::decision::Decision;
+    use crate::models::graph::MinimumVertexCover;
+    use crate::rules::{ExtractionError, ReductionResult};
+    use crate::solvers::{ILPSolveError, ILPSolver};
+    use crate::topology::SimpleGraph;
+    use crate::traits::Problem;
+
+    type Inner = MinimumVertexCover<SimpleGraph, i64>;
+    struct BrokenExtractor(Inner);
+    impl ReductionResult for BrokenExtractor {
+        type Source = Decision<Inner>;
+        type Target = Inner;
+
+        fn target_problem(&self) -> &Inner {
+            &self.0
+        }
+
+        fn extract_solution(&self, _: &Vec<bool>) -> crate::rules::ExtractionResult<Vec<bool>> {
+            Err(ExtractionError::invalid("broken witness decoder"))
+        }
+    }
+
+    let source = ExactProblemKey::new(
+        Decision::<Inner>::NAME,
+        Decision::<Inner>::variant()
+            .into_iter()
+            .map(|(k, v)| (k.into(), v.into()))
+            .collect(),
+    );
+    let registry = solver_capability_registry().unwrap();
+    let original = registry.lookup(&source).ilp.unwrap();
+    let mut pipeline = CompiledIlpPipeline {
+        path: original.path.clone(),
+        reducers: original.reducers.clone(),
+    };
+    pipeline.reducers[0].0 = |source| {
+        let source = source.downcast_ref::<Decision<Inner>>().unwrap();
+        Ok(Box::new(BrokenExtractor(source.inner().clone())))
+    };
+    let inner = Inner::new(SimpleGraph::new(2, vec![(0, 1)]), vec![1i64; 2]);
+    assert!(matches!(
+        pipeline.solve(&Decision::new(inner.clone(), 0), &ILPSolver::new()),
+        Err(ILPSolveError::UnresolvedDecision(_))
+    ));
+    assert!(matches!(
+        pipeline.solve(&Decision::new(inner, 1), &ILPSolver::new()),
+        Err(ILPSolveError::Extraction(ExtractionError::Reduction { message, .. }))
+            if message == "broken witness decoder"
+    ));
+}
+
+static DIRECT_BOOL_A: IlpPipelineRegistration = IlpPipelineRegistration {
+    path: &[StaticProblemStep {
+        name: "ILP",
+        variant: FLOAT_BOOL_VARIANT,
+    }],
+};
+static DIRECT_BOOL_B: IlpPipelineRegistration = IlpPipelineRegistration {
+    path: &[StaticProblemStep {
+        name: "ILP",
+        variant: FLOAT_BOOL_VARIANT,
+    }],
+};
+static MISSING_EDGE: IlpPipelineRegistration = IlpPipelineRegistration {
+    path: &[
+        StaticProblemStep {
+            name: "Source",
+            variant: NO_VARIANT,
+        },
+        StaticProblemStep {
+            name: "ILP",
+            variant: FLOAT_BOOL_VARIANT,
+        },
+    ],
+};
+static CONTINUES_AFTER_ILP: IlpPipelineRegistration = IlpPipelineRegistration {
+    path: &[
+        StaticProblemStep {
+            name: "ILP",
+            variant: FLOAT_BOOL_VARIANT,
+        },
+        StaticProblemStep {
+            name: "ILP",
+            variant: FLOAT_I64_VARIANT,
+        },
+    ],
+};
+static EMPTY_PIPELINE: IlpPipelineRegistration = IlpPipelineRegistration { path: &[] };
+static UNSUPPORTED_TARGET: IlpPipelineRegistration = IlpPipelineRegistration {
+    path: &[StaticProblemStep {
+        name: "Source",
+        variant: NO_VARIANT,
+    }],
+};
+
+fn source_variant() -> Vec<(&'static str, &'static str)> {
+    Vec::new()
+}
+
+fn no_solution(
+    _: &dyn std::any::Any,
+) -> Result<Option<serde_json::Value>, crate::solvers::SolveError> {
+    Ok(None)
+}
+
+static CUSTOMIZED_A: CustomizedSolverRegistration = CustomizedSolverRegistration {
+    source_name: "Source",
+    source_variant_fn: source_variant,
+    implementation: "customized-a",
+    solve_fn: no_solution,
+};
+static CUSTOMIZED_B: CustomizedSolverRegistration = CustomizedSolverRegistration {
+    source_name: "Source",
+    source_variant_fn: source_variant,
+    implementation: "customized-b",
+    solve_fn: no_solution,
+};
+
+#[test]
+fn solver_capability_registry_constructs_without_graph_search() {
+    solver_capability_registry().expect("production solver registrations must be valid");
+}
+
+#[test]
+fn exact_problem_key_has_canonical_label() {
+    let key = ExactProblemKey::new(
+        "MaximumIndependentSet",
+        BTreeMap::from([
+            ("graph".to_string(), "SimpleGraph".to_string()),
+            ("weight".to_string(), "One".to_string()),
+        ]),
+    );
+    assert_eq!(key.label(), "MaximumIndependentSet<SimpleGraph, One>");
+}
+
+#[test]
+fn solver_capability_registry_duplicate_ilp_registration_is_rejected_independent_of_order() {
+    let variants = BTreeSet::from([ExactProblemKey::new(
+        "ILP",
+        BTreeMap::from([
+            ("variable".to_string(), "bool".to_string()),
+            ("coefficient".to_string(), "f64".to_string()),
+        ]),
+    )]);
+    for pipelines in [
+        [&DIRECT_BOOL_A, &DIRECT_BOOL_B],
+        [&DIRECT_BOOL_B, &DIRECT_BOOL_A],
+    ] {
+        let error = build_registry(
+            &variants,
+            std::iter::empty(),
+            pipelines,
+            std::iter::empty(),
+            &[],
+        )
+        .unwrap_err();
+        assert!(matches!(error, RegistryBuildError::DuplicateIlp(_)));
+    }
+}
+
+#[test]
+fn solver_capability_registry_duplicate_customized_registration_is_rejected() {
+    let variants = BTreeSet::from([ExactProblemKey::new("Source", BTreeMap::new())]);
+    let error = build_registry(
+        &variants,
+        [&CUSTOMIZED_A, &CUSTOMIZED_B],
+        std::iter::empty(),
+        std::iter::empty(),
+        &[],
+    )
+    .unwrap_err();
+    assert!(matches!(error, RegistryBuildError::DuplicateCustomized(_)));
+}
+
+#[test]
+fn solver_capability_registry_unknown_customized_variant_is_rejected() {
+    let error = build_registry(
+        &BTreeSet::new(),
+        [&CUSTOMIZED_A],
+        std::iter::empty(),
+        std::iter::empty(),
+        &[],
+    )
+    .unwrap_err();
+    assert!(matches!(error, RegistryBuildError::UnknownVariant(label) if label == "Source"));
+}
+
+#[test]
+fn solver_capability_registry_unknown_pipeline_variant_is_rejected() {
+    let variants = BTreeSet::from([ExactProblemKey::new(
+        "ILP",
+        BTreeMap::from([
+            ("variable".to_string(), "bool".to_string()),
+            ("coefficient".to_string(), "i64".to_string()),
+        ]),
+    )]);
+    let error = build_registry(
+        &variants,
+        std::iter::empty(),
+        [&MISSING_EDGE],
+        std::iter::empty(),
+        &[],
+    )
+    .unwrap_err();
+    assert!(matches!(error, RegistryBuildError::UnknownVariant(label) if label == "Source"));
+}
+
+#[test]
+fn solver_capability_registry_empty_pipeline_is_rejected() {
+    let error = build_registry(
+        &BTreeSet::new(),
+        std::iter::empty(),
+        [&EMPTY_PIPELINE],
+        std::iter::empty(),
+        &[],
+    )
+    .unwrap_err();
+    assert!(matches!(error, RegistryBuildError::EmptyPipeline));
+}
+
+#[test]
+fn solver_capability_registry_unsupported_pipeline_target_is_rejected() {
+    let variants = BTreeSet::from([ExactProblemKey::new("Source", BTreeMap::new())]);
+    let error = build_registry(
+        &variants,
+        std::iter::empty(),
+        [&UNSUPPORTED_TARGET],
+        std::iter::empty(),
+        &[],
+    )
+    .unwrap_err();
+    assert!(matches!(error, RegistryBuildError::UnsupportedTarget(label) if label == "Source"));
+}
+
+#[test]
+fn solver_capability_registry_pipeline_with_missing_exact_edge_is_rejected() {
+    let variants = BTreeSet::from([
+        ExactProblemKey::new("Source", BTreeMap::new()),
+        ExactProblemKey::new(
+            "ILP",
+            BTreeMap::from([
+                ("variable".to_string(), "bool".to_string()),
+                ("coefficient".to_string(), "f64".to_string()),
+            ]),
+        ),
+    ]);
+    let error = build_registry(
+        &variants,
+        std::iter::empty(),
+        [&MISSING_EDGE],
+        std::iter::empty(),
+        &[],
+    )
+    .unwrap_err();
+    assert!(matches!(
+        error,
+        RegistryBuildError::InvalidEdge { matches: 0, .. }
+    ));
+}
+
+#[test]
+fn solver_capability_registry_pipeline_must_stop_at_first_supported_ilp_node() {
+    let variants = BTreeSet::from([
+        ExactProblemKey::new(
+            "ILP",
+            BTreeMap::from([
+                ("variable".to_string(), "bool".to_string()),
+                ("coefficient".to_string(), "f64".to_string()),
+            ]),
+        ),
+        ExactProblemKey::new(
+            "ILP",
+            BTreeMap::from([
+                ("variable".to_string(), "i64".to_string()),
+                ("coefficient".to_string(), "f64".to_string()),
+            ]),
+        ),
+    ]);
+    let error = build_registry(
+        &variants,
+        std::iter::empty(),
+        [&CONTINUES_AFTER_ILP],
+        std::iter::empty(),
+        &[],
+    )
+    .unwrap_err();
+    assert!(matches!(error, RegistryBuildError::ContinuesAfterIlp(_)));
+}
+
+#[test]
+fn solver_capability_registry_rejects_variant_without_solver() {
+    let variants = BTreeSet::from([ExactProblemKey::new("Source", BTreeMap::new())]);
+    let error = build_registry(
+        &variants,
+        std::iter::empty(),
+        std::iter::empty(),
+        std::iter::empty(),
+        &[],
+    )
+    .unwrap_err();
+    assert!(matches!(
+        error,
+        RegistryBuildError::MissingSolverCapability(label) if label == "Source"
+    ));
+}
+
+#[test]
+fn solver_capability_registry_exposes_representative_capability_classes() {
+    let key = |name: &str, variant: &[(&str, &str)]| {
+        ExactProblemKey::new(
+            name,
+            variant
+                .iter()
+                .map(|&(key, value)| (key.to_string(), value.to_string()))
+                .collect(),
+        )
+    };
+
+    let customized_only = solver_capabilities(&key("TimetableDesign", &[])).unwrap();
+    assert_eq!(
+        customized_only.customized.unwrap().implementation,
+        "timetable-required-assignments"
+    );
+    assert!(customized_only.ilp.is_none());
+
+    let direct_ilp = solver_capabilities(&key(
+        "MaximumClique",
+        &[("graph", "SimpleGraph"), ("weight", "i64")],
+    ))
+    .unwrap();
+    assert!(direct_ilp.customized.is_none());
+    assert_eq!(
+        direct_ilp.ilp.unwrap().path_labels(),
+        [
+            "MaximumClique<SimpleGraph, i64>",
+            "ILP<i64, bool>",
+            "ILP<f64, bool>"
+        ]
+    );
+
+    let multihop_ilp = solver_capabilities(&key(
+        "MaximumIndependentSet",
+        &[("graph", "SimpleGraph"), ("weight", "One")],
+    ))
+    .unwrap();
+    assert!(multihop_ilp.ilp.unwrap().path_labels().len() > 2);
+
+    let both =
+        solver_capabilities(&key("RootedTreeArrangement", &[("graph", "SimpleGraph")])).unwrap();
+    assert!(both.customized.is_some());
+    assert!(both.ilp.is_some());
+
+    let brute_force_only = solver_capabilities(&key(
+        "MaxCut",
+        &[("graph", "SimpleGraph"), ("weight", "i64")],
+    ))
+    .unwrap();
+    assert!(brute_force_only.customized.is_none());
+    assert!(brute_force_only.ilp.is_none());
+
+    let ilp_itself =
+        solver_capabilities(&key("ILP", &[("variable", "bool"), ("coefficient", "i64")])).unwrap();
+    assert_eq!(
+        ilp_itself.ilp.unwrap().path_labels(),
+        ["ILP<i64, bool>", "ILP<f64, bool>"]
+    );
+}
+
+#[test]
+fn solver_capability_registry_does_not_leak_across_exact_variants() {
+    let registry = solver_capability_registry().unwrap();
+    let key = ExactProblemKey::new(
+        "MinimumCardinalityKey",
+        BTreeMap::from([("unexpected".to_string(), "variant".to_string())]),
+    );
+    let capabilities = registry.lookup(&key);
+    assert!(capabilities.customized.is_none());
+    assert!(capabilities.ilp.is_none());
+}
+
+#[test]
+fn solver_capability_registry_ignores_unrelated_reduction_edges() {
+    let source = ExactProblemKey::new(
+        "MaximumIndependentSet",
+        BTreeMap::from([
+            ("graph".to_string(), "SimpleGraph".to_string()),
+            ("weight".to_string(), "One".to_string()),
+        ]),
+    );
+    let registration = inventory::iter::<IlpPipelineRegistration>
+        .into_iter()
+        .find(|registration| {
+            registration.path.first().map(ExactProblemKey::from_static) == Some(source.clone())
+        })
+        .expect("production MIS<One> pipeline must be registered");
+    let path = registration
+        .path
+        .iter()
+        .map(ExactProblemKey::from_static)
+        .collect::<Vec<_>>();
+    let all_reductions = reduction_entries();
+    let required_reductions = all_reductions
+        .iter()
+        .copied()
+        .filter(|entry| {
+            path.windows(2)
+                .any(|pair| edge_key(entry, true) == pair[0] && edge_key(entry, false) == pair[1])
+        })
+        .collect::<Vec<_>>();
+    let unrelated = all_reductions
+        .iter()
+        .copied()
+        .find(|entry| {
+            !required_reductions
+                .iter()
+                .any(|required| std::ptr::eq(*required, *entry))
+        })
+        .expect("catalog must contain an unrelated reduction edge");
+    let mut with_unrelated = required_reductions.clone();
+    with_unrelated.push(unrelated);
+
+    let variants: BTreeSet<_> = path.iter().cloned().collect();
+    let pipelines = inventory::iter::<IlpPipelineRegistration>
+        .into_iter()
+        .filter(|entry| {
+            entry
+                .path
+                .first()
+                .map(ExactProblemKey::from_static)
+                .is_some_and(|source| variants.contains(&source))
+        })
+        .collect::<Vec<_>>();
+    let brute_force = inventory::iter::<crate::solvers::BruteForceRegistration>
+        .into_iter()
+        .filter(|entry| {
+            variants.contains(&ExactProblemKey::new(
+                entry.source_name,
+                crate::export::variant_to_map((entry.source_variant_fn)()),
+            ))
+        })
+        .collect::<Vec<_>>();
+    let minimal = build_registry(
+        &variants,
+        std::iter::empty(),
+        pipelines.iter().copied(),
+        brute_force.iter().copied(),
+        &required_reductions,
+    )
+    .unwrap();
+    let expanded = build_registry(
+        &variants,
+        std::iter::empty(),
+        pipelines.iter().copied(),
+        brute_force.iter().copied(),
+        &with_unrelated,
+    )
+    .unwrap();
+    let minimal_pipeline = minimal.lookup(&source).ilp.unwrap();
+    let expanded_pipeline = expanded.lookup(&source).ilp.unwrap();
+
+    assert_eq!(minimal_pipeline.path(), expanded_pipeline.path());
+    assert_eq!(
+        minimal_pipeline
+            .reducers
+            .iter()
+            .map(|(reducer, aggregate)| (
+                *reducer as usize,
+                aggregate.map(|reduce| reduce as usize)
+            ))
+            .collect::<Vec<_>>(),
+        expanded_pipeline
+            .reducers
+            .iter()
+            .map(|(reducer, aggregate)| (
+                *reducer as usize,
+                aggregate.map(|reduce| reduce as usize)
+            ))
+            .collect::<Vec<_>>()
+    );
+}
+
+#[test]
+fn solver_capability_registry_ambiguous_exact_edge_is_rejected() {
+    let registration = inventory::iter::<IlpPipelineRegistration>
+        .into_iter()
+        .find(|registration| registration.path.len() == 2)
+        .expect("production catalog must contain a direct ILP pipeline");
+    let path = registration
+        .path
+        .iter()
+        .map(ExactProblemKey::from_static)
+        .collect::<Vec<_>>();
+    let reduction = reduction_entries()
+        .into_iter()
+        .find(|entry| {
+            entry.capabilities().witness
+                && entry.reduce_fn.is_some()
+                && edge_key(entry, true) == path[0]
+                && edge_key(entry, false) == path[1]
+        })
+        .expect("direct pipeline must have one witness reduction");
+    let error = build_registry(
+        &registered_variant_keys(),
+        std::iter::empty(),
+        [registration],
+        std::iter::empty(),
+        &[reduction, reduction],
+    )
+    .unwrap_err();
+
+    assert!(matches!(
+        error,
+        RegistryBuildError::InvalidEdge { matches: 2, .. }
+    ));
+}
diff --git a/src/unit_tests/solvers/resolver.rs b/src/unit_tests/solvers/resolver.rs
new file mode 100644
index 000000000..8cc05f909
--- /dev/null
+++ b/src/unit_tests/solvers/resolver.rs
@@ -0,0 +1,660 @@
+use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
+use crate::registry::load_dyn;
+use crate::solvers::{solve, SolveOutcome, SolverExecution, SolverRequest};
+use crate::traits::Problem;
+use std::collections::BTreeMap;
+
+#[test]
+fn decision_reductions_check_target_optimum_before_extracting_witness() {
+    let variant = BTreeMap::from([("graph".into(), "SimpleGraph".into())]);
+    let cases = [
+        (
+            "HamiltonianCircuit",
+            serde_json::json!({"graph": {"num_vertices": 4, "edges": [[0,1],[1,2],[0,2],[2,3]]}}),
+            false,
+        ),
+        (
+            "HamiltonianCircuit",
+            serde_json::json!({"graph": {"num_vertices": 4, "edges": [[0,1],[1,2],[2,3],[0,3]]}}),
+            true,
+        ),
+        (
+            "HamiltonianCircuit",
+            serde_json::json!({"graph": {"num_vertices": 3, "edges": [[0,1],[1,2]]}}),
+            false,
+        ),
+        (
+            "PartitionIntoCliques",
+            serde_json::json!({"graph": {"num_vertices": 3, "edges": []}, "num_cliques": 2}),
+            false,
+        ),
+        (
+            "PartitionIntoCliques",
+            serde_json::json!({"graph": {"num_vertices": 3, "edges": []}, "num_cliques": 3}),
+            true,
+        ),
+    ];
+    for (name, data, expected) in cases {
+        let problem = load_dyn(name, &variant, data).unwrap();
+        for backend in [
+            SolverRequest::BruteForce,
+            SolverRequest::Ilp,
+            SolverRequest::Default,
+        ] {
+            let result = solve(&problem, backend);
+            if matches!(
+                &result,
+                Err(crate::solvers::SolveError::IlpSolve {
+                    source: crate::solvers::ILPSolveError::UnresolvedDecision(_),
+                    ..
+                })
+            ) {
+                assert!(!expected, "{name}, {backend:?}");
+                continue;
+            }
+            match result.unwrap().outcome {
+                SolveOutcome::Optimal {
+                    solution,
+                    evaluation,
+                } => {
+                    assert!(expected, "{name}, {backend:?}");
+                    assert_eq!(evaluation, "Or(true)");
+                    assert_eq!(problem.evaluate_dyn(&solution).unwrap(), "Or(true)");
+                }
+                SolveOutcome::Infeasible => assert!(!expected, "{name}, {backend:?}"),
+            }
+        }
+    }
+}
+
+#[test]
+fn hamiltonian_ilp_matches_exhaustive_search_on_small_graphs() {
+    let variant = BTreeMap::from([("graph".into(), "SimpleGraph".into())]);
+    let edges = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)];
+    for mask in 0..64 {
+        let selected: Vec<_> = edges
+            .iter()
+            .enumerate()
+            .filter_map(|(i, edge)| (mask & (1 << i) != 0).then_some(edge))
+            .collect();
+        let problem = load_dyn(
+            "HamiltonianCircuit",
+            &variant,
+            serde_json::json!({"graph": {"num_vertices": 4, "edges": selected}}),
+        )
+        .unwrap();
+        let reference = solve(&problem, SolverRequest::BruteForce).unwrap();
+        let actual = solve(&problem, SolverRequest::Ilp);
+        if matches!(
+            &actual,
+            Err(crate::solvers::SolveError::IlpSolve {
+                source: crate::solvers::ILPSolveError::UnresolvedDecision(_),
+                ..
+            })
+        ) {
+            assert!(matches!(reference.outcome, SolveOutcome::Infeasible));
+            continue;
+        }
+        let actual = actual.unwrap();
+        assert_eq!(
+            matches!(actual.outcome, SolveOutcome::Infeasible),
+            matches!(reference.outcome, SolveOutcome::Infeasible),
+            "graph {mask}"
+        );
+        if let SolveOutcome::Optimal { solution, .. } = actual.outcome {
+            assert_eq!(problem.evaluate_dyn(&solution).unwrap(), "Or(true)");
+        }
+    }
+}
+
+#[test]
+fn generic_decision_ilp_compares_inner_optimum_with_bound() {
+    use crate::models::graph::{
+        MinimumDominatingSet, MinimumVertexCover, OptimalLinearArrangement,
+    };
+    use crate::topology::SimpleGraph;
+
+    let graph = SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]);
+    let weighted_variant = BTreeMap::from([
+        ("graph".to_string(), "SimpleGraph".to_string()),
+        ("weight".to_string(), "i64".to_string()),
+    ]);
+    let cases = [
+        (
+            "DecisionMinimumVertexCover",
+            weighted_variant.clone(),
+            serde_json::to_value(MinimumVertexCover::new(graph.clone(), vec![1i64; 3])).unwrap(),
+            2,
+        ),
+        (
+            "DecisionMinimumDominatingSet",
+            weighted_variant,
+            serde_json::to_value(MinimumDominatingSet::new(graph.clone(), vec![1i64; 3])).unwrap(),
+            1,
+        ),
+        (
+            "DecisionOptimalLinearArrangement",
+            BTreeMap::from([("graph".to_string(), "SimpleGraph".to_string())]),
+            serde_json::to_value(OptimalLinearArrangement::new(graph)).unwrap(),
+            4,
+        ),
+    ];
+    for (name, variant, inner, optimum) in cases {
+        for bound in [optimum - 1, optimum, optimum + 1] {
+            let loaded = load_dyn(
+                name,
+                &variant,
+                serde_json::json!({"inner": inner, "bound": bound}),
+            )
+            .unwrap();
+            for backend in [
+                SolverRequest::BruteForce,
+                SolverRequest::Ilp,
+                SolverRequest::Default,
+            ] {
+                let result = solve(&loaded, backend);
+                if bound < optimum && backend != SolverRequest::BruteForce {
+                    assert!(
+                        matches!(
+                            result,
+                            Err(crate::solvers::SolveError::IlpSolve {
+                                source: crate::solvers::ILPSolveError::UnresolvedDecision(_),
+                                ..
+                            })
+                        ),
+                        "{name}, {bound}, {backend:?}"
+                    );
+                    continue;
+                }
+                let result = result.unwrap();
+                if bound < optimum {
+                    assert_eq!(
+                        result.outcome,
+                        SolveOutcome::Infeasible,
+                        "{name}, {bound}, {backend:?}"
+                    );
+                } else {
+                    let SolveOutcome::Optimal {
+                        solution,
+                        evaluation,
+                    } = result.outcome
+                    else {
+                        panic!("expected a witness for {name}, {bound}, {backend:?}");
+                    };
+                    assert_eq!(evaluation, "Or(true)");
+                    assert_eq!(loaded.evaluate_dyn(&solution).unwrap(), "Or(true)");
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn generic_decision_ilp_matches_exhaustive_search_on_small_graphs() {
+    use crate::models::graph::{
+        MinimumDominatingSet, MinimumVertexCover, OptimalLinearArrangement,
+    };
+    use crate::topology::SimpleGraph;
+
+    let weighted = BTreeMap::from([
+        ("graph".to_string(), "SimpleGraph".to_string()),
+        ("weight".to_string(), "i64".to_string()),
+    ]);
+    let unweighted = BTreeMap::from([("graph".to_string(), "SimpleGraph".to_string())]);
+    for mask in 0..8 {
+        let graph = SimpleGraph::new(
+            3,
+            [(0, 1), (0, 2), (1, 2)]
+                .into_iter()
+                .enumerate()
+                .filter_map(|(i, edge)| (mask & (1 << i) != 0).then_some(edge))
+                .collect(),
+        );
+        let models = [
+            (
+                "DecisionMinimumVertexCover",
+                &weighted,
+                serde_json::to_value(MinimumVertexCover::new(graph.clone(), vec![1i64, 2, 3]))
+                    .unwrap(),
+            ),
+            (
+                "DecisionMinimumDominatingSet",
+                &weighted,
+                serde_json::to_value(MinimumDominatingSet::new(graph.clone(), vec![1i64, 2, 3]))
+                    .unwrap(),
+            ),
+            (
+                "DecisionOptimalLinearArrangement",
+                &unweighted,
+                serde_json::to_value(OptimalLinearArrangement::new(graph)).unwrap(),
+            ),
+        ];
+        for (name, variant, inner) in models {
+            for bound in 0..=6 {
+                let loaded = load_dyn(
+                    name,
+                    variant,
+                    serde_json::json!({"inner": inner, "bound": bound}),
+                )
+                .unwrap();
+                let reference = solve(&loaded, SolverRequest::BruteForce).unwrap();
+                let actual = solve(&loaded, SolverRequest::Ilp);
+                if matches!(reference.outcome, SolveOutcome::Infeasible) {
+                    assert!(
+                        matches!(
+                            actual,
+                            Err(crate::solvers::SolveError::IlpSolve {
+                                source: crate::solvers::ILPSolveError::UnresolvedDecision(_),
+                                ..
+                            })
+                        ),
+                        "{name}, graph {mask}, bound {bound}"
+                    );
+                    continue;
+                }
+                let actual = actual.unwrap();
+                assert_eq!(
+                    matches!(actual.outcome, SolveOutcome::Infeasible),
+                    matches!(reference.outcome, SolveOutcome::Infeasible),
+                    "{name}, graph {mask}, bound {bound}"
+                );
+                if let SolveOutcome::Optimal { solution, .. } = actual.outcome {
+                    assert_eq!(loaded.evaluate_dyn(&solution).unwrap(), "Or(true)");
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn deterministic_solver_dispatch_customized_registration_wins_default_dispatch() {
+    use crate::models::set::MinimumCardinalityKey;
+
+    let problem = MinimumCardinalityKey::new(3, vec![(vec![0], vec![1, 2])]);
+    let loaded = crate::registry::load_dyn(
+        MinimumCardinalityKey::NAME,
+        &BTreeMap::new(),
+        serde_json::to_value(problem).unwrap(),
+    )
+    .unwrap();
+
+    let result = solve(&loaded, SolverRequest::Default).unwrap();
+    assert_eq!(
+        result.solver,
+        SolverExecution::Customized {
+            implementation: "fd-minimum-cardinality-key"
+        }
+    );
+
+    let explicit = solve(&loaded, SolverRequest::Customized).unwrap();
+    assert_eq!(explicit, result);
+}
+
+#[test]
+fn deterministic_solver_dispatch_unregistered_customized_override_is_a_capability_error() {
+    use crate::models::graph::MaxCut;
+    use crate::topology::SimpleGraph;
+
+    let problem = MaxCut::new(SimpleGraph::new(2, vec![(0, 1)]), vec![1i64]);
+    let loaded = crate::registry::load_dyn(
+        MaxCut::<SimpleGraph, i64>::NAME,
+        &BTreeMap::from([
+            ("graph".to_string(), "SimpleGraph".to_string()),
+            ("weight".to_string(), "i64".to_string()),
+        ]),
+        serde_json::to_value(problem).unwrap(),
+    )
+    .unwrap();
+
+    let error = solve(&loaded, SolverRequest::Customized).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::solvers::SolveError::MissingCustomizedCapability(_)
+    ));
+}
+
+#[test]
+fn deterministic_solver_dispatch_unregistered_ilp_override_is_a_capability_error_without_fallback()
+{
+    use crate::models::graph::MaxCut;
+    use crate::topology::SimpleGraph;
+
+    // MaxCut<i64> has a discoverable graph route toward ILP, but that route is
+    // partial for valid negative-weight instances and is intentionally not a
+    // registered solver pipeline.
+    let problem = MaxCut::new(SimpleGraph::new(2, vec![(0, 1)]), vec![1i64]);
+    let loaded = crate::registry::load_dyn(
+        MaxCut::<SimpleGraph, i64>::NAME,
+        &BTreeMap::from([
+            ("graph".to_string(), "SimpleGraph".to_string()),
+            ("weight".to_string(), "i64".to_string()),
+        ]),
+        serde_json::to_value(problem).unwrap(),
+    )
+    .unwrap();
+
+    let default = solve(&loaded, SolverRequest::Default).unwrap();
+    assert_eq!(default.solver, SolverExecution::BruteForce);
+    let error = solve(&loaded, SolverRequest::Ilp).unwrap_err();
+    assert!(matches!(
+        error,
+        crate::solvers::SolveError::MissingIlpCapability(_)
+    ));
+}
+
+#[test]
+fn deterministic_solver_dispatch_customized_infeasibility_does_not_fall_back() {
+    use crate::models::misc::AdditionalKey;
+
+    // {0} is the only candidate key and it is already known, so the registered
+    // customized solver has no witness. Brute force can still report the aggregate
+    // infeasibility result, which lets this test distinguish fallback from error.
+    let problem = AdditionalKey::new(3, vec![(vec![0], vec![1, 2])], vec![0, 1, 2], vec![vec![0]]);
+    let loaded = load_dyn(
+        AdditionalKey::NAME,
+        &BTreeMap::new(),
+        serde_json::to_value(problem).unwrap(),
+    )
+    .unwrap();
+
+    let result = solve(&loaded, SolverRequest::Default).unwrap();
+    assert_eq!(result.outcome, SolveOutcome::Infeasible);
+    let brute_force = solve(&loaded, SolverRequest::BruteForce).unwrap();
+    assert_eq!(brute_force.solver, SolverExecution::BruteForce);
+    assert_eq!(brute_force.outcome, SolveOutcome::Infeasible);
+}
+
+#[test]
+fn deterministic_solver_dispatch_integer_ilp_uses_registered_cast_pipeline() {
+    let problem = ILP::<bool>::new(0, vec![], vec![], ObjectiveSense::Minimize).unwrap();
+    let loaded = load_dyn(
+        ILP::<bool>::NAME,
+        &BTreeMap::from([
+            ("variable".to_string(), "bool".to_string()),
+            ("coefficient".to_string(), "i64".to_string()),
+        ]),
+        serde_json::to_value(problem).unwrap(),
+    )
+    .unwrap();
+
+    let result = solve(&loaded, SolverRequest::Default).unwrap();
+    assert_eq!(
+        result.solver,
+        SolverExecution::Ilp {
+            reduction_path: vec!["ILP<i64, bool>".to_string(), "ILP<f64, bool>".to_string()]
+        }
+    );
+    assert!(matches!(
+        result.outcome,
+        SolveOutcome::Optimal {
+            ref solution,
+            ..
+        } if solution.as_array().is_some_and(Vec::is_empty)
+    ));
+}
+
+#[test]
+fn deterministic_solver_dispatch_ilp_infeasibility_does_not_fall_back() {
+    let problem = ILP::<bool>::new(
+        0,
+        vec![LinearConstraint::le(vec![], -1)],
+        vec![],
+        ObjectiveSense::Minimize,
+    )
+    .unwrap();
+    let loaded = load_dyn(
+        ILP::<bool>::NAME,
+        &BTreeMap::from([
+            ("variable".to_string(), "bool".to_string()),
+            ("coefficient".to_string(), "i64".to_string()),
+        ]),
+        serde_json::to_value(problem).unwrap(),
+    )
+    .unwrap();
+
+    let result = solve(&loaded, SolverRequest::Default).unwrap();
+    assert_eq!(result.outcome, SolveOutcome::Infeasible);
+    assert!(matches!(
+        solve(&loaded, SolverRequest::BruteForce),
+        Err(crate::solvers::SolveError::MissingRegistration(_))
+    ));
+}
+
+#[test]
+fn deterministic_solver_execution_has_stable_tagged_json_contract() {
+    assert_eq!(
+        serde_json::to_value(SolverExecution::Customized {
+            implementation: "customized-id"
+        })
+        .unwrap(),
+        serde_json::json!({"kind": "customized", "implementation": "customized-id"})
+    );
+    assert_eq!(
+        serde_json::to_value(SolverExecution::Ilp {
+            reduction_path: vec!["Source".to_string(), "ILP<i64, bool>".to_string()]
+        })
+        .unwrap(),
+        serde_json::json!({
+            "kind": "ilp",
+            "reduction_path": ["Source", "ILP<i64, bool>"]
+        })
+    );
+    assert_eq!(
+        serde_json::to_value(SolverExecution::BruteForce).unwrap(),
+        serde_json::json!({"kind": "brute-force"})
+    );
+}
+
+#[test]
+fn solve_outcome_has_disjoint_json_states() {
+    assert_eq!(
+        serde_json::to_value(SolveOutcome::Optimal {
+            solution: serde_json::json!([1, 0]),
+            evaluation: "Max(1)".to_string(),
+        })
+        .unwrap(),
+        serde_json::json!({
+            "status": "optimal",
+            "solution": [1, 0],
+            "evaluation": "Max(1)"
+        })
+    );
+    assert_eq!(
+        serde_json::to_value(SolveOutcome::Infeasible).unwrap(),
+        serde_json::json!({"status": "infeasible"})
+    );
+}
+
+#[test]
+fn deterministic_solver_dispatch_fixed_multihop_pipeline_is_repeatable() {
+    use crate::models::graph::MaximumIndependentSet;
+    use crate::topology::SimpleGraph;
+
+    let problem = MaximumIndependentSet::new(
+        SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
+        vec![crate::types::One; 3],
+    );
+    let variant = BTreeMap::from([
+        ("graph".to_string(), "SimpleGraph".to_string()),
+        ("weight".to_string(), "One".to_string()),
+    ]);
+    let loaded = load_dyn(
+        MaximumIndependentSet::<SimpleGraph, crate::types::One>::NAME,
+        &variant,
+        serde_json::to_value(problem).unwrap(),
+    )
+    .unwrap();
+
+    let first = solve(&loaded, SolverRequest::Ilp).unwrap();
+    let second = solve(&loaded, SolverRequest::Ilp).unwrap();
+    assert_eq!(first, second);
+    let SolverExecution::Ilp { reduction_path } = first.solver else {
+        panic!("expected ILP execution metadata");
+    };
+    assert_eq!(
+        reduction_path,
+        vec![
+            "MaximumIndependentSet<SimpleGraph, One>",
+            "MaximumIndependentSet<SimpleGraph, i64>",
+            "MaximumSetPacking<i64>",
+            "ILP<i64, bool>",
+            "ILP<f64, bool>",
+        ]
+    );
+}
+
+#[test]
+fn deterministic_solver_dispatch_customized_default_allows_explicit_ilp_override() {
+    use crate::models::graph::RootedTreeArrangement;
+    use crate::topology::SimpleGraph;
+
+    let problem = RootedTreeArrangement::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), 3);
+    let loaded = load_dyn(
+        RootedTreeArrangement::<SimpleGraph>::NAME,
+        &BTreeMap::from([("graph".to_string(), "SimpleGraph".to_string())]),
+        serde_json::to_value(problem).unwrap(),
+    )
+    .unwrap();
+
+    let default = solve(&loaded, SolverRequest::Default).unwrap();
+    assert!(matches!(default.solver, SolverExecution::Customized { .. }));
+
+    let explicit_ilp = solve(&loaded, SolverRequest::Ilp).unwrap();
+    assert!(matches!(explicit_ilp.solver, SolverExecution::Ilp { .. }));
+    let SolveOutcome::Optimal {
+        evaluation: default_evaluation,
+        ..
+    } = default.outcome
+    else {
+        panic!("customized solver should find an optimum");
+    };
+    let SolveOutcome::Optimal {
+        evaluation: ilp_evaluation,
+        ..
+    } = explicit_ilp.outcome
+    else {
+        panic!("ILP solver should find an optimum");
+    };
+    assert_eq!(default_evaluation, ilp_evaluation);
+}
+
+#[test]
+fn deterministic_solver_dispatch_repeats_each_available_solver_class() {
+    use crate::models::graph::RootedTreeArrangement;
+    use crate::topology::SimpleGraph;
+
+    let problem = RootedTreeArrangement::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), 3);
+    let loaded = load_dyn(
+        RootedTreeArrangement::<SimpleGraph>::NAME,
+        &BTreeMap::from([("graph".to_string(), "SimpleGraph".to_string())]),
+        serde_json::to_value(problem).unwrap(),
+    )
+    .unwrap();
+
+    let mut evaluations = Vec::new();
+    for request in [
+        SolverRequest::Default,
+        SolverRequest::Customized,
+        SolverRequest::Ilp,
+        SolverRequest::BruteForce,
+    ] {
+        let first = solve(&loaded, request).unwrap();
+        let second = solve(&loaded, request).unwrap();
+        assert_eq!(first, second, "{request:?} changed its witness");
+        let SolveOutcome::Optimal { evaluation, .. } = first.outcome else {
+            panic!("{request:?} should find an optimum");
+        };
+        evaluations.push(evaluation);
+    }
+    assert!(evaluations.windows(2).all(|pair| pair[0] == pair[1]));
+}
+
+fn check_unit_dominating_decision(num_vertices: usize, edges: &[(usize, usize)], bound: i64) {
+    let variant = BTreeMap::from([
+        ("graph".into(), "SimpleGraph".into()),
+        ("weight".into(), "One".into()),
+    ]);
+    let problem = load_dyn(
+        "DecisionMinimumDominatingSet",
+        &variant,
+        serde_json::json!({
+            "inner": {
+                "graph": {"num_vertices": num_vertices, "edges": edges},
+                "weights": vec![1; num_vertices],
+            },
+            "bound": bound,
+        }),
+    )
+    .unwrap();
+    let reference = solve(&problem, SolverRequest::BruteForce).unwrap();
+    for backend in [SolverRequest::Ilp, SolverRequest::Default] {
+        let actual = solve(&problem, backend);
+        if matches!(reference.outcome, SolveOutcome::Infeasible) {
+            assert!(
+                matches!(
+                    actual,
+                    Err(crate::solvers::SolveError::IlpSolve {
+                        source: crate::solvers::ILPSolveError::UnresolvedDecision(_),
+                        ..
+                    }) | Ok(crate::solvers::SolveResult {
+                        outcome: SolveOutcome::Infeasible,
+                        ..
+                    })
+                ),
+                "n={num_vertices}, edges={edges:?}, bound={bound}"
+            );
+            continue;
+        }
+        let actual = actual.unwrap();
+        let SolverExecution::Ilp { reduction_path } = &actual.solver else {
+            panic!("expected the registered ILP pipeline");
+        };
+        assert!(
+            reduction_path
+                .iter()
+                .any(|node| node.starts_with("MinimumSumMulticenter")),
+            "{reduction_path:?}"
+        );
+        assert_eq!(
+            matches!(actual.outcome, SolveOutcome::Infeasible),
+            matches!(reference.outcome, SolveOutcome::Infeasible),
+            "n={num_vertices}, edges={edges:?}, bound={bound}, backend={backend:?}"
+        );
+        if let SolveOutcome::Optimal {
+            solution,
+            evaluation,
+        } = actual.outcome
+        {
+            assert_eq!(evaluation, "Or(true)");
+            assert_eq!(problem.evaluate_dyn(&solution).unwrap(), "Or(true)");
+        }
+    }
+}
+
+#[test]
+fn unit_dominating_decision_ilp_handles_zero_negative_and_large_bounds() {
+    for (n, edges) in [(0, vec![]), (1, vec![]), (3, vec![(0, 1), (1, 2)])] {
+        for bound in [i64::MIN, -1, 0, 1, 3, i64::MAX] {
+            check_unit_dominating_decision(n, &edges, bound);
+        }
+    }
+}
+
+#[test]
+fn unit_dominating_decision_ilp_rejects_no_instance_with_feasible_multicenter_target() {
+    check_unit_dominating_decision(4, &[(0, 1), (1, 2), (2, 3)], 1);
+}
+
+#[test]
+fn unit_dominating_decision_ilp_matches_all_three_vertex_graphs() {
+    for mask in 0..8 {
+        let edges: Vec<_> = [(0, 1), (0, 2), (1, 2)]
+            .into_iter()
+            .enumerate()
+            .filter_map(|(index, edge)| (mask & (1 << index) != 0).then_some(edge))
+            .collect();
+        for bound in 0..=4 {
+            check_unit_dominating_decision(3, &edges, bound);
+        }
+    }
+}
diff --git a/src/unit_tests/symbolic_parameter_contracts.rs b/src/unit_tests/symbolic_parameter_contracts.rs
new file mode 100644
index 000000000..1ba9b0d78
--- /dev/null
+++ b/src/unit_tests/symbolic_parameter_contracts.rs
@@ -0,0 +1,154 @@
+use crate::models::algebraic::AlgebraicEquationsOverGF2;
+use crate::models::graph::{MaximumClique, MaximumIndependentSet};
+use crate::models::set::ExactCoverBy3Sets;
+use crate::parameters::ParameterRelation;
+use crate::rules::{ReduceTo, ReductionGraph, ReductionResult};
+use crate::topology::SimpleGraph;
+use crate::types::ProblemParameters;
+use crate::Problem;
+
+#[test]
+fn exact_rule_formula_matches_the_constructed_target() {
+    let source = MaximumIndependentSet::<SimpleGraph, i64>::new(
+        SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
+        vec![1; 5],
+    );
+    let reduction = <MaximumIndependentSet<SimpleGraph, i64> as ReduceTo<
+        MaximumClique<SimpleGraph, i64>,
+    >>::reduce_to(&source)
+    .expect("reduction should succeed");
+    let target = reduction.target_problem();
+    let graph = ReductionGraph::new();
+    let source_variant =
+        ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
+    let target_variant =
+        ReductionGraph::variant_to_map(&MaximumClique::<SimpleGraph, i64>::variant());
+    let path = graph
+        .find_all_paths(
+            MaximumIndependentSet::<SimpleGraph, i64>::NAME,
+            &source_variant,
+            MaximumClique::<SimpleGraph, i64>::NAME,
+            &target_variant,
+        )
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("direct reduction is registered");
+
+    let transform = graph
+        .compose_path_parameter_transform(&path)
+        .unwrap()
+        .unwrap();
+    let predicted = transform
+        .evaluate(&ProblemParameters::new(vec![
+            ("num_vertices", 5),
+            ("num_edges", 4),
+        ]))
+        .unwrap();
+    assert_eq!(
+        predicted.get("num_vertices"),
+        Some(u64::try_from(target.num_vertices()).unwrap())
+    );
+    assert_eq!(
+        predicted.get("num_edges"),
+        Some(u64::try_from(target.num_edges()).unwrap())
+    );
+}
+
+#[test]
+fn incoming_rule_measures_every_declared_field_on_a_sink_variant() {
+    let source = ExactCoverBy3Sets::new(3, vec![[0, 1, 2]]);
+    let reduction = <ExactCoverBy3Sets as ReduceTo<AlgebraicEquationsOverGF2>>::reduce_to(&source)
+        .expect("reduction should succeed");
+    let target = reduction.target_problem();
+    let target_variant = ReductionGraph::variant_to_map(&AlgebraicEquationsOverGF2::variant());
+
+    let measured = ReductionGraph::compute_problem_parameters(
+        AlgebraicEquationsOverGF2::NAME,
+        &target_variant,
+        target,
+    );
+
+    assert_eq!(
+        measured.get("num_variables"),
+        Some(u64::try_from(target.num_variables()).unwrap())
+    );
+    assert_eq!(
+        measured.get("num_equations"),
+        Some(u64::try_from(target.num_equations()).unwrap())
+    );
+}
+
+#[test]
+fn every_registered_rule_has_one_valid_parameter_contract() {
+    for entry in crate::rules::registry::reduction_entries() {
+        let contract = entry.parameter_contract().unwrap_or_else(|error| {
+            panic!(
+                "{} -> {} has an invalid parameter contract: {error}",
+                entry.source_name, entry.target_name
+            )
+        });
+        assert!(contract.transform().is_some() || !contract.unavailable().is_empty());
+    }
+}
+
+#[cfg(feature = "example-db")]
+#[test]
+fn canonical_examples_satisfy_upper_bound_parameter_contracts() {
+    for spec in crate::rules::canonical_rule_example_specs() {
+        let example = (spec.build)();
+        let source = crate::registry::load_dyn(
+            &example.source.problem,
+            &example.source.variant,
+            example.source.instance.clone(),
+        )
+        .unwrap();
+        let target = crate::registry::load_dyn(
+            &example.target.problem,
+            &example.target.variant,
+            example.target.instance.clone(),
+        )
+        .unwrap();
+        let graph = ReductionGraph::new();
+        let entry = graph
+            .find_entry(
+                &example.source.problem,
+                &example.source.variant,
+                &example.target.problem,
+                &example.target.variant,
+            )
+            .unwrap_or_else(|| panic!("{} has no registered direct edge", spec.id));
+        let Ok(contract) = entry.parameter_contract else {
+            continue;
+        };
+        let Some(transform) = contract.transform() else {
+            continue;
+        };
+        if transform.relation() != ParameterRelation::UpperBound {
+            continue;
+        }
+        let source_size = ReductionGraph::compute_problem_parameters(
+            &example.source.problem,
+            &example.source.variant,
+            source.as_any(),
+        );
+        let target_size = ReductionGraph::compute_problem_parameters(
+            &example.target.problem,
+            &example.target.variant,
+            target.as_any(),
+        );
+        let predicted = transform
+            .evaluate(&source_size)
+            .unwrap_or_else(|error| panic!("{}: {error}", spec.id));
+
+        for (field, actual) in target_size.components {
+            let Some(predicted_value) = predicted.get(&field) else {
+                continue;
+            };
+            assert!(
+                predicted_value >= actual,
+                "{}: target field {field}: predicted {predicted_value}, actual {actual}",
+                spec.id
+            );
+        }
+    }
+}
diff --git a/src/unit_tests/topology/unit_disk_graph.rs b/src/unit_tests/topology/unit_disk_graph.rs
index 877e28cdc..8eda99d22 100644
--- a/src/unit_tests/topology/unit_disk_graph.rs
+++ b/src/unit_tests/topology/unit_disk_graph.rs
@@ -2,14 +2,14 @@ use super::*;
 
 #[test]
 fn test_udg_basic() {
-    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0), (3.0, 0.0)], 1.0);
+    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0), (3.0, 0.0)], 1.0).unwrap();
     assert_eq!(udg.num_vertices(), 3);
     assert_eq!(udg.num_edges(), 1); // Only 0-1 are within distance 1
 }
 
 #[test]
 fn test_udg_unit() {
-    let udg = UnitDiskGraph::unit(vec![(0.0, 0.0), (0.5, 0.5)]);
+    let udg = UnitDiskGraph::unit(vec![(0.0, 0.0), (0.5, 0.5)]).unwrap();
     assert_eq!(udg.radius(), 1.0);
     // Distance is sqrt(0.5^2 + 0.5^2) ≈ 0.707 < 1, so connected
     assert_eq!(udg.num_edges(), 1);
@@ -17,7 +17,7 @@ fn test_udg_unit() {
 
 #[test]
 fn test_udg_has_edge() {
-    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0), (3.0, 0.0)], 1.0);
+    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0), (3.0, 0.0)], 1.0).unwrap();
     assert!(udg.has_edge(0, 1));
     assert!(udg.has_edge(1, 0)); // Symmetric
     assert!(!udg.has_edge(0, 2));
@@ -26,7 +26,7 @@ fn test_udg_has_edge() {
 
 #[test]
 fn test_udg_neighbors() {
-    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0), (0.5, 0.5)], 1.0);
+    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0), (0.5, 0.5)], 1.0).unwrap();
     let neighbors = udg.neighbors(0);
     // 0 is within 1.0 of both 1 and 2
     assert!(neighbors.contains(&1));
@@ -35,7 +35,8 @@ fn test_udg_neighbors() {
 
 #[test]
 fn test_udg_degree() {
-    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (5.0, 5.0)], 1.5);
+    let udg =
+        UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (5.0, 5.0)], 1.5).unwrap();
     // Vertex 0 is connected to 1 and 2
     assert_eq!(udg.degree(0), 2);
     // Vertex 3 is isolated
@@ -44,14 +45,14 @@ fn test_udg_degree() {
 
 #[test]
 fn test_udg_vertex_distance() {
-    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (3.0, 4.0)], 10.0);
+    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (3.0, 4.0)], 10.0).unwrap();
     let dist = udg.vertex_distance(0, 1);
     assert_eq!(dist, Some(5.0)); // 3-4-5 triangle
 }
 
 #[test]
 fn test_udg_position() {
-    let udg = UnitDiskGraph::new(vec![(1.0, 2.0), (3.0, 4.0)], 1.0);
+    let udg = UnitDiskGraph::new(vec![(1.0, 2.0), (3.0, 4.0)], 1.0).unwrap();
     assert_eq!(udg.position(0), Some((1.0, 2.0)));
     assert_eq!(udg.position(1), Some((3.0, 4.0)));
     assert_eq!(udg.position(2), None);
@@ -59,7 +60,7 @@ fn test_udg_position() {
 
 #[test]
 fn test_udg_bounding_box() {
-    let udg = UnitDiskGraph::new(vec![(1.0, 2.0), (3.0, 4.0), (-1.0, 0.0)], 1.0);
+    let udg = UnitDiskGraph::new(vec![(1.0, 2.0), (3.0, 4.0), (-1.0, 0.0)], 1.0).unwrap();
     let bbox = udg.bounding_box();
     assert!(bbox.is_some());
     let ((min_x, min_y), (max_x, max_y)) = bbox.unwrap();
@@ -71,13 +72,13 @@ fn test_udg_bounding_box() {
 
 #[test]
 fn test_udg_empty_bounding_box() {
-    let udg = UnitDiskGraph::new(vec![], 1.0);
+    let udg = UnitDiskGraph::new(vec![], 1.0).unwrap();
     assert!(udg.bounding_box().is_none());
 }
 
 #[test]
 fn test_udg_grid() {
-    let udg = UnitDiskGraph::grid(2, 3, 1.0, 1.0);
+    let udg = UnitDiskGraph::grid(2, 3, 1.0, 1.0).unwrap();
     assert_eq!(udg.num_vertices(), 6);
     // Grid with spacing 1.0 and radius 1.0: only horizontal/vertical neighbors connected
     // Row 0: 0-1, 1-2
@@ -89,7 +90,7 @@ fn test_udg_grid() {
 #[test]
 fn test_udg_grid_diagonal() {
     // With radius > sqrt(2), diagonals are also connected
-    let udg = UnitDiskGraph::grid(2, 2, 1.0, 1.5);
+    let udg = UnitDiskGraph::grid(2, 2, 1.0, 1.5).unwrap();
     assert_eq!(udg.num_vertices(), 4);
     // All pairs are connected (4 edges: 0-1, 0-2, 0-3, 1-2, 1-3, 2-3)
     // Actually: 0-1 (1.0), 0-2 (1.0), 1-3 (1.0), 2-3 (1.0), 0-3 (sqrt(2)≈1.41), 1-2 (sqrt(2)≈1.41)
@@ -98,7 +99,7 @@ fn test_udg_grid_diagonal() {
 
 #[test]
 fn test_udg_edges_list() {
-    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0)], 1.0);
+    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0)], 1.0).unwrap();
     let edges = udg.edges();
     assert_eq!(edges.len(), 1);
     assert_eq!(edges[0], (0, 1));
@@ -106,7 +107,7 @@ fn test_udg_edges_list() {
 
 #[test]
 fn test_udg_positions() {
-    let udg = UnitDiskGraph::new(vec![(1.0, 2.0), (3.0, 4.0)], 1.0);
+    let udg = UnitDiskGraph::new(vec![(1.0, 2.0), (3.0, 4.0)], 1.0).unwrap();
     let positions = udg.positions();
     assert_eq!(positions.len(), 2);
     assert_eq!(positions[0], (1.0, 2.0));
@@ -115,7 +116,7 @@ fn test_udg_positions() {
 
 #[test]
 fn test_udg_vertex_distance_invalid() {
-    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0)], 1.0);
+    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0)], 1.0).unwrap();
     assert_eq!(udg.vertex_distance(0, 5), None);
     assert_eq!(udg.vertex_distance(5, 0), None);
     assert_eq!(udg.vertex_distance(5, 6), None);
@@ -124,7 +125,7 @@ fn test_udg_vertex_distance_invalid() {
 #[test]
 fn test_udg_graph_trait() {
     // Test the Graph trait implementation
-    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0), (0.5, 0.5)], 1.0);
+    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (1.0, 0.0), (0.5, 0.5)], 1.0).unwrap();
     // Use Graph trait methods
     assert_eq!(Graph::num_vertices(&udg), 3);
     assert!(Graph::num_edges(&udg) > 0);
@@ -134,3 +135,20 @@ fn test_udg_graph_trait() {
     let neighbors = Graph::neighbors(&udg, 0);
     assert!(neighbors.contains(&1));
 }
+
+#[test]
+fn test_udg_rejects_invalid_numeric_fields() {
+    assert!(UnitDiskGraph::new(vec![(f64::NAN, 0.0)], 1.0).is_err());
+    assert!(UnitDiskGraph::new(vec![(0.0, 0.0)], f64::INFINITY).is_err());
+    assert!(UnitDiskGraph::new(vec![(f64::MAX, 0.0), (-f64::MAX, 0.0)], 1.0).is_err());
+}
+
+#[test]
+fn test_udg_deserialization_rejects_inconsistent_edges() {
+    let json = r#"{
+        "positions": [[0.0, 0.0], [1.0, 0.0]],
+        "radius": 1.0,
+        "edges": []
+    }"#;
+    assert!(serde_json::from_str::<UnitDiskGraph>(json).is_err());
+}
diff --git a/src/unit_tests/trait_consistency.rs b/src/unit_tests/trait_consistency.rs
index a8e62e9bd..4f766da84 100644
--- a/src/unit_tests/trait_consistency.rs
+++ b/src/unit_tests/trait_consistency.rs
@@ -1,14 +1,14 @@
+use crate::solvers::BruteForceProblem;
 use crate::models::algebraic::*;
 use crate::models::formula::*;
 use crate::models::graph::*;
 use crate::models::misc::*;
 use crate::models::set::*;
 use crate::topology::{BipartiteGraph, DirectedGraph, SimpleGraph};
-use crate::traits::Problem;
 use crate::variant::K3;
 
-fn check_problem_trait<P: Problem>(problem: &P, name: &str) {
-    let dims = problem.dims();
+fn check_brute_force_problem<P: BruteForceProblem>(problem: &P, name: &str) {
+    let dims = problem.dimensions();
     assert!(
         !dims.is_empty() || name.contains("empty"),
         "{} should have dimensions",
@@ -23,76 +23,79 @@ fn check_problem_trait<P: Problem>(problem: &P, name: &str) {
     }
 }
 #[test]
-fn test_all_problems_implement_trait_correctly() {
-    check_problem_trait(
-        &MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]),
+fn test_all_registered_brute_force_problems_define_dimensions() {
+    check_brute_force_problem(
+        &MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]),
         "MaximumIndependentSet",
     );
-    check_problem_trait(
-        &MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]),
+    check_brute_force_problem(
+        &MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]),
         "MinimumVertexCover",
     );
-    check_problem_trait(
-        &MaxCut::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32]),
+    check_brute_force_problem(
+        &MaxCut::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64]),
         "MaxCut",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1)])),
         "KColoring",
     );
-    check_problem_trait(
-        &MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]),
+    check_brute_force_problem(
+        &MinimumDominatingSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]),
         "MinimumDominatingSet",
     );
-    check_problem_trait(
-        &MaximalIS::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32; 3]),
+    check_brute_force_problem(
+        &MaximalIS::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64; 3]),
         "MaximalIS",
     );
-    check_problem_trait(
-        &MaximumMatching::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i32]),
+    check_brute_force_problem(
+        &MaximumMatching::new(SimpleGraph::new(3, vec![(0, 1)]), vec![1i64]),
         "MaximumMatching",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &BiconnectivityAugmentation::new(SimpleGraph::path(4), vec![(0, 3, 2)], 2),
         "BiconnectivityAugmentation",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &Satisfiability::new(3, vec![CNFClause::new(vec![1])]),
         "SAT",
     );
-    check_problem_trait(
-        &SpinGlass::new(3, vec![((0, 1), 1.0)], vec![0.0; 3]),
+    check_brute_force_problem(
+        &SpinGlass::new(3, vec![((0, 1), 1.0)], vec![0.0; 3]).unwrap(),
         "SpinGlass",
     );
-    check_problem_trait(&QUBO::from_matrix(vec![vec![1.0; 3]; 3]), "QUBO");
-    check_problem_trait(
-        &MinimumSetCovering::<i32>::new(3, vec![vec![0, 1]]),
+    check_brute_force_problem(
+        &QUBO::from_matrix(vec![vec![1.0; 3]; 3]).unwrap(),
+        "QUBO",
+    );
+    check_brute_force_problem(
+        &MinimumSetCovering::new(3, vec![vec![0, 1]]),
         "MinimumSetCovering",
     );
-    check_problem_trait(
-        &MaximumSetPacking::<i32>::new(vec![vec![0, 1]]),
+    check_brute_force_problem(
+        &MaximumSetPacking::new(vec![vec![0, 1]]),
         "MaximumSetPacking",
     );
-    check_problem_trait(&PaintShop::new(vec!["a", "a"]), "PaintShop");
-    check_problem_trait(&BMF::new(vec![vec![true]], 1), "BMF");
-    check_problem_trait(
+    check_brute_force_problem(&PaintShop::new(vec!["a", "a"]), "PaintShop");
+    check_brute_force_problem(&BMF::new(vec![vec![true]], 1), "BMF");
+    check_brute_force_problem(
         &ConsecutiveBlockMinimization::new(vec![vec![true, false], vec![false, true]], 2),
         "ConsecutiveBlockMinimization",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &BicliqueCover::new(BipartiteGraph::new(2, 2, vec![(0, 0)]), 1),
         "BicliqueCover",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &BalancedCompleteBipartiteSubgraph::new(
             BipartiteGraph::new(2, 2, vec![(0, 0), (0, 1), (1, 0), (1, 1)]),
             2,
         ),
         "BalancedCompleteBipartiteSubgraph",
     );
-    check_problem_trait(&Factoring::new(6, 2, 2), "Factoring");
-    check_problem_trait(&Partition::new(vec![3, 1, 1, 2, 2, 1]), "Partition");
-    check_problem_trait(
+    check_brute_force_problem(&Factoring::with_factor_bits(2, 2, 6), "Factoring");
+    check_brute_force_problem(&Partition::new(vec![3, 1, 1, 2, 2, 1]), "Partition").unwrap();
+    check_brute_force_problem(
         &QuadraticAssignment::new(vec![vec![0, 1], vec![1, 0]], vec![vec![0, 1], vec![1, 0]]),
         "QuadraticAssignment",
     );
@@ -101,8 +104,8 @@ fn test_all_problems_implement_trait_correctly() {
         vec!["x".to_string()],
         BooleanExpr::constant(true),
     )]);
-    check_problem_trait(&CircuitSAT::new(circuit), "CircuitSAT");
-    check_problem_trait(
+    check_brute_force_problem(&CircuitSAT::new(circuit), "CircuitSAT");
+    check_brute_force_problem(
         &StrongConnectivityAugmentation::new(
             DirectedGraph::new(3, vec![(0, 1), (1, 2), (2, 0)]),
             vec![(0, 2, 1)],
@@ -110,7 +113,7 @@ fn test_all_problems_implement_trait_correctly() {
         ),
         "StrongConnectivityAugmentation",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &KthBestSpanningTree::new(
             SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
             vec![1, 1, 1],
@@ -119,32 +122,32 @@ fn test_all_problems_implement_trait_correctly() {
         ),
         "KthBestSpanningTree",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &HamiltonianCircuit::new(SimpleGraph::new(3, vec![(0, 1), (1, 2), (2, 0)])),
         "HamiltonianCircuit",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &MinMaxMulticenter::new(
             SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-            vec![1i32; 3],
-            vec![1i32; 2],
+            vec![1i64; 3],
+            vec![1i64; 2],
             1,
         ),
         "MinMaxMulticenter",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &HamiltonianPath::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)])),
         "HamiltonianPath",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &DegreeConstrainedSpanningTree::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), 2),
         "DegreeConstrainedSpanningTree",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &ShortestWeightConstrainedPath::new(
             SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
-            vec![1i32; 2],
-            vec![1i32; 2],
+            vec![1i64; 2],
+            vec![1i64; 2],
             0,
             2,
             2,
@@ -152,7 +155,7 @@ fn test_all_problems_implement_trait_correctly() {
         ),
         "ShortestWeightConstrainedPath",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &MultipleCopyFileAllocation::new(
             SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
             vec![1; 3],
@@ -160,7 +163,7 @@ fn test_all_problems_implement_trait_correctly() {
         ),
         "MultipleCopyFileAllocation",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &UndirectedTwoCommodityIntegralFlow::new(
             SimpleGraph::new(4, vec![(0, 2), (1, 2), (2, 3)]),
             vec![1, 1, 2],
@@ -173,7 +176,7 @@ fn test_all_problems_implement_trait_correctly() {
         ),
         "UndirectedTwoCommodityIntegralFlow",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &LengthBoundedDisjointPaths::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 3), (0, 2), (2, 3)]),
             0,
@@ -183,61 +186,62 @@ fn test_all_problems_implement_trait_correctly() {
         ),
         "LengthBoundedDisjointPaths",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &OptimalLinearArrangement::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)])),
         "OptimalLinearArrangement",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &IsomorphicSpanningTree::new(
             SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
             SimpleGraph::new(3, vec![(0, 1), (1, 2)]),
         ),
         "IsomorphicSpanningTree",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &ShortestCommonSupersequence::new(2, vec![vec![0, 1], vec![1, 0]]),
         "ShortestCommonSupersequence",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &FlowShopScheduling::new(2, vec![vec![1, 2], vec![3, 4]], 10),
         "FlowShopScheduling",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &JobShopScheduling::new(2, vec![vec![(0, 1), (1, 1)], vec![(1, 1), (0, 1)]], 2),
         "JobShopScheduling",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &SequencingToMinimizeWeightedTardiness::new(vec![3, 4, 2], vec![2, 3, 1], vec![5, 8, 4], 4),
         "SequencingToMinimizeWeightedTardiness",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &MinimumTardinessSequencing::<One>::new(3, vec![2, 3, 1], vec![(0, 2)]),
         "MinimumTardinessSequencing",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &PartitionIntoPathsOfLength2::new(SimpleGraph::new(
             6,
             vec![(0, 1), (1, 2), (3, 4), (4, 5)],
         )),
         "PartitionIntoPathsOfLength2",
     );
-    check_problem_trait(
-        &ResourceConstrainedScheduling::new(3, vec![20], vec![vec![6], vec![7], vec![7]], 2),
+    check_brute_force_problem(
+        &ResourceConstrainedScheduling::new(3, vec![20], vec![vec![6], vec![7], vec![7]], 2)
+            .unwrap(),
         "ResourceConstrainedScheduling",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &PartiallyOrderedKnapsack::new(vec![2, 3], vec![3, 2], vec![(0, 1)], 5),
         "PartiallyOrderedKnapsack",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &SequencingWithReleaseTimesAndDeadlines::new(vec![1, 2, 1], vec![0, 0, 2], vec![3, 3, 4]),
         "SequencingWithReleaseTimesAndDeadlines",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &SumOfSquaresPartition::new(vec![5, 3, 8, 2, 7, 1], 3),
         "SumOfSquaresPartition",
     );
-    check_problem_trait(
+    check_brute_force_problem(
         &ConsecutiveOnesSubmatrix::new(vec![vec![true, false], vec![false, true]], 1),
         "ConsecutiveOnesSubmatrix",
     );
diff --git a/src/unit_tests/traits.rs b/src/unit_tests/traits.rs
index cedb4325b..2c6cec82d 100644
--- a/src/unit_tests/traits.rs
+++ b/src/unit_tests/traits.rs
@@ -1,3 +1,4 @@
+use crate::solvers::BruteForceProblem as _;
 use crate::traits::Problem;
 use crate::types::{Max, Min, Or, Sum};
 
@@ -9,14 +10,16 @@ struct TestSatProblem {
 
 impl Problem for TestSatProblem {
     const NAME: &'static str = "TestSat";
+    type Solution = Vec<usize>;
     type Value = Or;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.num_vars]
-    }
+    crate::problem_parameters![("num_variables", num_variables)];
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Or(self.satisfying.iter().any(|s| s == config))
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok(Or(self.satisfying.iter().any(|s| s == config)))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -24,6 +27,12 @@ impl Problem for TestSatProblem {
     }
 }
 
+impl crate::solvers::BruteForceProblem for TestSatProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.num_vars]
+    }
+}
+
 #[test]
 fn test_problem_sat() {
     let p = TestSatProblem {
@@ -31,9 +40,9 @@ fn test_problem_sat() {
         satisfying: vec![vec![1, 0], vec![0, 1]],
     };
 
-    assert_eq!(p.dims(), vec![2, 2]);
-    assert_eq!(p.evaluate(&[1, 0]), Or(true));
-    assert_eq!(p.evaluate(&[0, 0]), Or(false));
+    assert_eq!(p.dimensions(), vec![2, 2]);
+    assert_eq!(p.evaluate(&vec![1, 0]).unwrap(), Or(true));
+    assert_eq!(p.evaluate(&vec![0, 0]).unwrap(), Or(false));
 }
 
 #[test]
@@ -44,7 +53,7 @@ fn test_problem_num_variables() {
     };
 
     assert_eq!(p.num_variables(), 5);
-    assert_eq!(p.dims().len(), 5);
+    assert_eq!(p.dimensions().len(), 5);
 }
 
 #[test]
@@ -55,62 +64,82 @@ fn test_problem_empty() {
     };
 
     assert_eq!(p.num_variables(), 0);
-    assert!(p.dims().is_empty());
+    assert!(p.dimensions().is_empty());
 }
 
 #[derive(Clone)]
 struct TestMaxProblem {
-    weights: Vec<i32>,
+    weights: Vec<i64>,
 }
 
 impl Problem for TestMaxProblem {
     const NAME: &'static str = "TestMax";
-    type Value = Max<i32>;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.weights.len()]
+    type Solution = Vec<usize>;
+    type Value = Max<i64>;
+
+    crate::problem_parameters![("num_variables", num_variables)];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok({
+            Max(Some(
+                config
+                    .iter()
+                    .enumerate()
+                    .map(|(i, &v)| if v == 1 { self.weights[i] } else { 0 })
+                    .sum(),
+            ))
+        })
     }
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Max(Some(
-            config
-                .iter()
-                .enumerate()
-                .map(|(i, &v)| if v == 1 { self.weights[i] } else { 0 })
-                .sum(),
-        ))
+    fn variant() -> Vec<(&'static str, &'static str)> {
+        vec![("graph", "SimpleGraph"), ("weight", "i64")]
     }
+}
 
-    fn variant() -> Vec<(&'static str, &'static str)> {
-        vec![("graph", "SimpleGraph"), ("weight", "i32")]
+impl crate::solvers::BruteForceProblem for TestMaxProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.weights.len()]
     }
 }
 
 #[derive(Clone)]
 struct TestMinProblem {
-    costs: Vec<i32>,
+    costs: Vec<i64>,
 }
 
 impl Problem for TestMinProblem {
     const NAME: &'static str = "TestMin";
-    type Value = Min<i32>;
-
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.costs.len()]
+    type Solution = Vec<usize>;
+    type Value = Min<i64>;
+
+    crate::problem_parameters![("num_variables", num_variables)];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok({
+            Min(Some(
+                config
+                    .iter()
+                    .enumerate()
+                    .map(|(i, &v)| if v == 1 { self.costs[i] } else { 0 })
+                    .sum(),
+            ))
+        })
     }
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Min(Some(
-            config
-                .iter()
-                .enumerate()
-                .map(|(i, &v)| if v == 1 { self.costs[i] } else { 0 })
-                .sum(),
-        ))
+    fn variant() -> Vec<(&'static str, &'static str)> {
+        vec![("graph", "SimpleGraph"), ("weight", "i64")]
     }
+}
 
-    fn variant() -> Vec<(&'static str, &'static str)> {
-        vec![("graph", "SimpleGraph"), ("weight", "i32")]
+impl crate::solvers::BruteForceProblem for TestMinProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.costs.len()]
     }
 }
 
@@ -120,9 +149,9 @@ fn test_problem_max_value() {
         weights: vec![3, 1, 4],
     };
 
-    assert_eq!(p.evaluate(&[1, 0, 1]), Max(Some(7)));
-    assert_eq!(p.evaluate(&[0, 0, 0]), Max(Some(0)));
-    assert_eq!(p.evaluate(&[1, 1, 1]), Max(Some(8)));
+    assert_eq!(p.evaluate(&vec![1, 0, 1]).unwrap(), Max(Some(7)));
+    assert_eq!(p.evaluate(&vec![0, 0, 0]).unwrap(), Max(Some(0)));
+    assert_eq!(p.evaluate(&vec![1, 1, 1]).unwrap(), Max(Some(8)));
 }
 
 #[test]
@@ -131,9 +160,9 @@ fn test_problem_min_value() {
         costs: vec![5, 2, 3],
     };
 
-    assert_eq!(p.evaluate(&[1, 0, 0]), Min(Some(5)));
-    assert_eq!(p.evaluate(&[0, 1, 1]), Min(Some(5)));
-    assert_eq!(p.evaluate(&[0, 0, 0]), Min(Some(0)));
+    assert_eq!(p.evaluate(&vec![1, 0, 0]).unwrap(), Min(Some(5)));
+    assert_eq!(p.evaluate(&vec![0, 1, 1]).unwrap(), Min(Some(5)));
+    assert_eq!(p.evaluate(&vec![0, 0, 0]).unwrap(), Min(Some(0)));
 }
 
 #[derive(Clone)]
@@ -143,18 +172,26 @@ struct MultiDimProblem {
 
 impl Problem for MultiDimProblem {
     const NAME: &'static str = "MultiDim";
-    type Value = Sum<i32>;
+    type Solution = Vec<usize>;
+    type Value = Sum<i64>;
 
-    fn dims(&self) -> Vec<usize> {
-        self.dims.clone()
-    }
+    crate::problem_parameters![("num_variables", num_variables)];
 
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Sum(config.iter().map(|&c| c as i32).sum())
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok(Sum(config.iter().map(|&c| c as i64).sum()))
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
-        vec![("graph", "SimpleGraph"), ("weight", "i32")]
+        vec![("graph", "SimpleGraph"), ("weight", "i64")]
+    }
+}
+
+impl crate::solvers::BruteForceProblem for MultiDimProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        self.dims.clone()
     }
 }
 
@@ -164,10 +201,10 @@ fn test_multi_dim_problem() {
         dims: vec![2, 3, 4],
     };
 
-    assert_eq!(p.dims(), vec![2, 3, 4]);
+    assert_eq!(p.dimensions(), vec![2, 3, 4]);
     assert_eq!(p.num_variables(), 3);
-    assert_eq!(p.evaluate(&[0, 0, 0]), Sum(0));
-    assert_eq!(p.evaluate(&[1, 2, 3]), Sum(6));
+    assert_eq!(p.evaluate(&vec![0, 0, 0]).unwrap(), Sum(0));
+    assert_eq!(p.evaluate(&vec![1, 2, 3]).unwrap(), Sum(6));
 }
 
 #[test]
@@ -185,20 +222,24 @@ struct FloatProblem {
 
 impl Problem for FloatProblem {
     const NAME: &'static str = "FloatProblem";
+    type Solution = Vec<usize>;
     type Value = Max<f64>;
 
-    fn dims(&self) -> Vec<usize> {
-        vec![2; self.weights.len()]
-    }
-
-    fn evaluate(&self, config: &[usize]) -> Self::Value {
-        Max(Some(
-            config
-                .iter()
-                .enumerate()
-                .map(|(i, &v)| if v == 1 { self.weights[i] } else { 0.0 })
-                .sum(),
-        ))
+    crate::problem_parameters![("num_variables", num_variables)];
+
+    fn evaluate(
+        &self,
+        config: &Self::Solution,
+    ) -> Result<Self::Value, crate::traits::EvaluationError> {
+        Ok({
+            Max(Some(
+                config
+                    .iter()
+                    .enumerate()
+                    .map(|(i, &v)| if v == 1 { self.weights[i] } else { 0.0 })
+                    .sum(),
+            ))
+        })
     }
 
     fn variant() -> Vec<(&'static str, &'static str)> {
@@ -206,15 +247,21 @@ impl Problem for FloatProblem {
     }
 }
 
+impl crate::solvers::BruteForceProblem for FloatProblem {
+    fn dimensions(&self) -> Vec<usize> {
+        vec![2; self.weights.len()]
+    }
+}
+
 #[test]
 fn test_float_value_problem() {
     let p = FloatProblem {
         weights: vec![1.5, 2.5, 3.0],
     };
 
-    assert_eq!(p.dims(), vec![2, 2, 2]);
-    assert!((p.evaluate(&[1, 1, 0]).0.unwrap() - 4.0).abs() < 1e-10);
-    assert!((p.evaluate(&[1, 1, 1]).0.unwrap() - 7.0).abs() < 1e-10);
+    assert_eq!(p.dimensions(), vec![2, 2, 2]);
+    assert!((p.evaluate(&vec![1, 1, 0]).unwrap().0.unwrap() - 4.0).abs() < 1e-10);
+    assert!((p.evaluate(&vec![1, 1, 1]).unwrap().0.unwrap() - 7.0).abs() < 1e-10);
 }
 
 #[test]
@@ -222,7 +269,7 @@ fn problem_type_bridge_returns_catalog_entry_for_registered_type() {
     use crate::models::graph::MaximumIndependentSet;
     use crate::topology::SimpleGraph;
 
-    let pt = MaximumIndependentSet::<SimpleGraph, i32>::problem_type();
+    let pt = MaximumIndependentSet::<SimpleGraph, i64>::problem_type();
     assert_eq!(pt.canonical_name, "MaximumIndependentSet");
     assert!(!pt.display_name.is_empty());
     assert!(!pt.dimensions.is_empty());
@@ -236,6 +283,6 @@ fn test_problem_is_clone() {
     };
     let p2 = p1.clone();
 
-    assert_eq!(p2.dims(), vec![2, 2]);
-    assert_eq!(p2.evaluate(&[1, 0]), Or(true));
+    assert_eq!(p2.dimensions(), vec![2, 2]);
+    assert_eq!(p2.evaluate(&vec![1, 0]).unwrap(), Or(true));
 }
diff --git a/src/unit_tests/types.rs b/src/unit_tests/types.rs
index e0f9d01f9..ac53023b0 100644
--- a/src/unit_tests/types.rs
+++ b/src/unit_tests/types.rs
@@ -1,76 +1,120 @@
 use super::*;
-use crate::types::Aggregate;
+use crate::traits::EvaluationError;
+use crate::types::{Aggregate, SolutionAggregate};
 
 #[test]
 fn test_max_identity_and_combine() {
-    assert_eq!(Max::<i32>::identity(), Max(None));
-    assert_eq!(Max(Some(7)).combine(Max(Some(3))), Max(Some(7)));
-    assert_eq!(Max(Some(3)).combine(Max(Some(7))), Max(Some(7)));
-    assert_eq!(Max::<i32>::identity().combine(Max(Some(5))), Max(Some(5)));
+    assert_eq!(Max::<i64>::identity(), Max(None));
+    assert_eq!(Max(Some(7)).combine(Max(Some(3))).unwrap(), Max(Some(7)));
+    assert_eq!(Max(Some(3)).combine(Max(Some(7))).unwrap(), Max(Some(7)));
+    assert_eq!(
+        Max::<i64>::identity().combine(Max(Some(5))).unwrap(),
+        Max(Some(5))
+    );
 }
 
 #[test]
 fn test_min_identity_and_combine() {
-    assert_eq!(Min::<i32>::identity(), Min(None));
-    assert_eq!(Min(Some(3)).combine(Min(Some(7))), Min(Some(3)));
-    assert_eq!(Min(Some(7)).combine(Min(Some(3))), Min(Some(3)));
-    assert_eq!(Min::<i32>::identity().combine(Min(Some(5))), Min(Some(5)));
+    assert_eq!(Min::<i64>::identity(), Min(None));
+    assert_eq!(Min(Some(3)).combine(Min(Some(7))).unwrap(), Min(Some(3)));
+    assert_eq!(Min(Some(7)).combine(Min(Some(3))).unwrap(), Min(Some(3)));
+    assert_eq!(
+        Min::<i64>::identity().combine(Min(Some(5))).unwrap(),
+        Min(Some(5))
+    );
+}
+
+#[test]
+fn test_max_and_min_report_unordered_comparisons() {
+    assert_eq!(
+        Max(Some(f64::NAN)).combine(Max(Some(1.0))),
+        Err(AggregationError::UnorderedComparison)
+    );
+    assert_eq!(
+        Min(Some(1.0)).combine(Min(Some(f64::NAN))),
+        Err(AggregationError::UnorderedComparison)
+    );
 }
 
 #[test]
 fn test_sum_identity_and_combine() {
     assert_eq!(Sum::<u64>::identity(), Sum(0));
-    assert_eq!(Sum(4_u64).combine(Sum(3_u64)), Sum(7));
+    assert_eq!(Sum(4_u64).combine(Sum(3_u64)).unwrap(), Sum(7));
+}
+
+#[test]
+fn test_sum_combine_reports_overflow() {
+    assert_eq!(
+        Sum(u64::MAX).combine(Sum(1)),
+        Err(AggregationError::ArithmeticOverflow)
+    );
+}
+
+#[test]
+fn test_weight_multiplication_reports_integer_overflow() {
+    assert!(matches!(
+        <i64 as WeightElement>::checked_mul_sum(i64::MAX, 2, "test multiplication"),
+        Err(EvaluationError::IntegerOverflow(_))
+    ));
+}
+
+#[test]
+fn test_weight_multiplication_reports_non_finite_float() {
+    assert!(matches!(
+        <f64 as WeightElement>::checked_mul_sum(f64::MAX, 2.0, "test multiplication"),
+        Err(EvaluationError::NonFiniteResult(_))
+    ));
 }
 
 #[test]
 fn test_or_identity_and_combine() {
     assert_eq!(Or::identity(), Or(false));
-    assert_eq!(Or(false).combine(Or(true)), Or(true));
-    assert_eq!(Or(false).combine(Or(false)), Or(false));
+    assert_eq!(Or(false).combine(Or(true)).unwrap(), Or(true));
+    assert_eq!(Or(false).combine(Or(false)).unwrap(), Or(false));
+    assert!(!Or(false).is_absorbing());
+    assert!(Or(true).is_absorbing());
 }
 
 #[test]
 fn test_and_identity_and_combine() {
     assert_eq!(And::identity(), And(true));
-    assert_eq!(And(true).combine(And(false)), And(false));
-    assert_eq!(And(true).combine(And(true)), And(true));
+    assert_eq!(And(true).combine(And(false)).unwrap(), And(false));
+    assert_eq!(And(true).combine(And(true)).unwrap(), And(true));
+    assert!(!And(true).is_absorbing());
+    assert!(And(false).is_absorbing());
 }
 
 #[test]
-fn test_sum_witness_defaults() {
-    assert!(!Sum::<u64>::supports_witnesses());
-    assert!(!Sum::<u64>::contributes_to_witnesses(&Sum(3), &Sum(7)));
+fn test_sum_has_no_absorbing_value() {
+    assert!(!Sum(0_u64).is_absorbing());
+    assert!(!Sum(u64::MAX).is_absorbing());
 }
 
 #[test]
-fn test_and_witness_defaults() {
-    assert!(!And::supports_witnesses());
-    assert!(!And::contributes_to_witnesses(&And(true), &And(true)));
+fn test_and_absorbing_value_is_false() {
+    assert!(!And(true).is_absorbing());
+    assert!(And(false).is_absorbing());
 }
 
 #[test]
-fn test_max_witness_hooks() {
-    assert!(Max::<i32>::supports_witnesses());
-    assert!(Max::contributes_to_witnesses(&Max(Some(7)), &Max(Some(7))));
-    assert!(!Max::contributes_to_witnesses(&Max(Some(3)), &Max(Some(7))));
-    assert!(!Max::contributes_to_witnesses(&Max(None), &Max(Some(7))));
+fn test_max_solution_selection() {
+    assert!(Max::contributes_to_solution(&Max(Some(7)), &Max(Some(7))));
+    assert!(!Max::contributes_to_solution(&Max(Some(3)), &Max(Some(7))));
+    assert!(!Max::contributes_to_solution(&Max(None), &Max(Some(7))));
 }
 
 #[test]
-fn test_min_witness_hooks() {
-    assert!(Min::<i32>::supports_witnesses());
-    assert!(Min::contributes_to_witnesses(&Min(Some(3)), &Min(Some(3))));
-    assert!(!Min::contributes_to_witnesses(&Min(Some(7)), &Min(Some(3))));
-    assert!(!Min::contributes_to_witnesses(&Min(None), &Min(Some(3))));
+fn test_min_solution_selection() {
+    assert!(Min::contributes_to_solution(&Min(Some(3)), &Min(Some(3))));
+    assert!(!Min::contributes_to_solution(&Min(Some(7)), &Min(Some(3))));
+    assert!(!Min::contributes_to_solution(&Min(None), &Min(Some(3))));
 }
 
 #[test]
-fn test_or_witness_hooks() {
-    assert!(Or::supports_witnesses());
-    assert!(Or::contributes_to_witnesses(&Or(true), &Or(true)));
-    assert!(!Or::contributes_to_witnesses(&Or(false), &Or(true)));
-    assert!(!Or::contributes_to_witnesses(&Or(true), &Or(false)));
+fn test_or_solution_selection() {
+    assert!(Or::contributes_to_solution(&Or(true), &Or(true)));
+    assert!(!Or::contributes_to_solution(&Or(false), &Or(true)));
+    assert!(!Or::contributes_to_solution(&Or(true), &Or(false)));
 }
 
 #[test]
@@ -83,7 +127,7 @@ fn test_max_helpers() {
 
 #[test]
 fn test_max_invalid() {
-    let size = Max::<i32>(None);
+    let size = Max::<i64>(None);
     assert!(!size.is_valid());
     assert_eq!(size.size(), None);
 }
@@ -91,7 +135,7 @@ fn test_max_invalid() {
 #[test]
 #[should_panic(expected = "called unwrap on invalid Max value")]
 fn test_max_unwrap_panics() {
-    let invalid = Max::<i32>(None);
+    let invalid = Max::<i64>(None);
     invalid.unwrap();
 }
 
@@ -106,7 +150,7 @@ fn test_min_helpers() {
 #[test]
 #[should_panic(expected = "called unwrap on invalid Min value")]
 fn test_min_unwrap_panics() {
-    let invalid = Min::<i32>(None);
+    let invalid = Min::<i64>(None);
     invalid.unwrap();
 }
 
@@ -122,11 +166,23 @@ fn test_extremum_helpers() {
     assert_eq!(min.size(), Some(&5));
     assert_eq!(min.sense, ExtremumSense::Minimize);
 
-    let invalid = Extremum::<i32>::minimize(None);
+    let invalid = Extremum::<i64>::minimize(None);
     assert!(!invalid.is_valid());
     assert_eq!(invalid.size(), None);
 }
 
+#[test]
+fn test_extremum_reports_invalid_combinations() {
+    assert_eq!(
+        Extremum::maximize(Some(f64::NAN)).combine(Extremum::maximize(Some(1.0))),
+        Err(AggregationError::UnorderedComparison)
+    );
+    assert_eq!(
+        Extremum::maximize(Some(1)).combine(Extremum::minimize(Some(1))),
+        Err(AggregationError::IncompatibleExtremumSense)
+    );
+}
+
 #[test]
 fn test_one() {
     let one = One;
@@ -142,9 +198,7 @@ fn test_one() {
     // Test PartialEq
     assert_eq!(One, One);
 
-    // Test From<i32>
-    let from_int: One = One::from(42);
-    assert_eq!(from_int, One);
+    assert_eq!(One::unit(), One);
 }
 
 #[test]
@@ -157,29 +211,49 @@ fn test_one_json() {
 }
 
 #[test]
-fn test_problem_size() {
-    let ps = ProblemSize::new(vec![("vertices", 10), ("edges", 20)]);
+fn test_problem_parameters() {
+    let ps = ProblemParameters::new(vec![("vertices", 10), ("edges", 20)]);
     assert_eq!(ps.get("vertices"), Some(10));
     assert_eq!(ps.get("edges"), Some(20));
     assert_eq!(ps.get("unknown"), None);
 }
 
 #[test]
-fn test_problem_size_display() {
-    let ps = ProblemSize::new(vec![("vertices", 10), ("edges", 20)]);
-    assert_eq!(format!("{}", ps), "ProblemSize{vertices: 10, edges: 20}");
+#[should_panic(expected = "duplicate problem parameter `vertices`")]
+fn test_problem_parameters_reject_duplicate_names() {
+    ProblemParameters::new(vec![("vertices", 10), ("vertices", 20)]);
+}
+
+#[test]
+fn test_problem_parameters_deserialization_rejects_duplicate_names() {
+    let error = serde_json::from_value::<ProblemParameters>(serde_json::json!({
+        "components": [["vertices", 10], ["vertices", 20]]
+    }))
+    .unwrap_err();
+    assert!(error
+        .to_string()
+        .contains("duplicate problem parameter `vertices`"));
+}
+
+#[test]
+fn test_problem_parameters_display() {
+    let ps = ProblemParameters::new(vec![("vertices", 10), ("edges", 20)]);
+    assert_eq!(
+        format!("{}", ps),
+        "ProblemParameters{vertices: 10, edges: 20}"
+    );
 
-    let empty = ProblemSize::new(vec![]);
-    assert_eq!(format!("{}", empty), "ProblemSize{}");
+    let empty = ProblemParameters::new(vec![]);
+    assert_eq!(format!("{}", empty), "ProblemParameters{}");
 
-    let single = ProblemSize::new(vec![("n", 5)]);
-    assert_eq!(format!("{}", single), "ProblemSize{n: 5}");
+    let single = ProblemParameters::new(vec![("n", 5)]);
+    assert_eq!(format!("{}", single), "ProblemParameters{n: 5}");
 }
 
 #[test]
 fn test_numeric_size_blanket_impl() {
     fn assert_numeric_size<T: NumericSize>() {}
-    assert_numeric_size::<i32>();
+    assert_numeric_size::<i64>();
     assert_numeric_size::<i64>();
     assert_numeric_size::<f64>();
 }
@@ -195,14 +269,14 @@ fn test_weight_element_one() {
 }
 
 #[test]
-fn test_weight_element_i32() {
-    let w: i32 = 42;
+fn test_weight_element_i64() {
+    let w: i64 = 42;
     assert_eq!(w.to_sum(), 42);
 
-    let zero: i32 = 0;
+    let zero: i64 = 0;
     assert_eq!(zero.to_sum(), 0);
 
-    let neg: i32 = -5;
+    let neg: i64 = -5;
     assert_eq!(neg.to_sum(), -5);
 }
 
@@ -221,50 +295,60 @@ fn test_weight_element_f64() {
 #[test]
 fn test_extremum_aggregate_identity_and_combine() {
     // identity is Maximize(None)
-    let id = Extremum::<i32>::identity();
+    let id = Extremum::<i64>::identity();
     assert_eq!(id.sense, ExtremumSense::Maximize);
     assert_eq!(id.value, None);
 
     // None + Some => Some (takes rhs sense)
-    let combined = Extremum::<i32>::identity().combine(Extremum::maximize(Some(5)));
+    let combined = Extremum::<i64>::identity()
+        .combine(Extremum::maximize(Some(5)))
+        .unwrap();
     assert_eq!(combined, Extremum::maximize(Some(5)));
 
     // Some + None => Some (keeps lhs sense)
-    let combined = Extremum::minimize(Some(3)).combine(Extremum::<i32>::identity());
+    let combined = Extremum::minimize(Some(3))
+        .combine(Extremum::<i64>::identity())
+        .unwrap();
     assert_eq!(combined, Extremum::minimize(Some(3)));
 
     // Maximize: keeps the larger
-    let combined = Extremum::maximize(Some(3)).combine(Extremum::maximize(Some(7)));
+    let combined = Extremum::maximize(Some(3))
+        .combine(Extremum::maximize(Some(7)))
+        .unwrap();
     assert_eq!(combined, Extremum::maximize(Some(7)));
-    let combined = Extremum::maximize(Some(7)).combine(Extremum::maximize(Some(3)));
+    let combined = Extremum::maximize(Some(7))
+        .combine(Extremum::maximize(Some(3)))
+        .unwrap();
     assert_eq!(combined, Extremum::maximize(Some(7)));
 
     // Minimize: keeps the smaller
-    let combined = Extremum::minimize(Some(3)).combine(Extremum::minimize(Some(7)));
+    let combined = Extremum::minimize(Some(3))
+        .combine(Extremum::minimize(Some(7)))
+        .unwrap();
     assert_eq!(combined, Extremum::minimize(Some(3)));
-    let combined = Extremum::minimize(Some(7)).combine(Extremum::minimize(Some(3)));
+    let combined = Extremum::minimize(Some(7))
+        .combine(Extremum::minimize(Some(3)))
+        .unwrap();
     assert_eq!(combined, Extremum::minimize(Some(3)));
 }
 
 #[test]
-fn test_extremum_witness_hooks() {
-    assert!(Extremum::<i32>::supports_witnesses());
-
+fn test_extremum_solution_selection() {
     // Matching value and sense -> contributes
-    assert!(Extremum::contributes_to_witnesses(
+    assert!(Extremum::contributes_to_solution(
         &Extremum::maximize(Some(10)),
         &Extremum::maximize(Some(10)),
     ));
 
     // Different value -> does not contribute
-    assert!(!Extremum::contributes_to_witnesses(
+    assert!(!Extremum::contributes_to_solution(
         &Extremum::maximize(Some(5)),
         &Extremum::maximize(Some(10)),
     ));
 
     // None config -> does not contribute
-    assert!(!Extremum::contributes_to_witnesses(
-        &Extremum::<i32>::maximize(None),
+    assert!(!Extremum::contributes_to_solution(
+        &Extremum::<i64>::maximize(None),
         &Extremum::maximize(Some(10)),
     ));
 }
@@ -272,27 +356,27 @@ fn test_extremum_witness_hooks() {
 #[test]
 fn test_extremum_display() {
     assert_eq!(format!("{}", Extremum::maximize(Some(42))), "Max(42)");
-    assert_eq!(format!("{}", Extremum::<i32>::maximize(None)), "Max(None)");
+    assert_eq!(format!("{}", Extremum::<i64>::maximize(None)), "Max(None)");
     assert_eq!(format!("{}", Extremum::minimize(Some(7))), "Min(7)");
-    assert_eq!(format!("{}", Extremum::<i32>::minimize(None)), "Min(None)");
+    assert_eq!(format!("{}", Extremum::<i64>::minimize(None)), "Min(None)");
 }
 
 #[test]
 #[should_panic(expected = "called unwrap on invalid Extremum value")]
 fn test_extremum_unwrap_panics() {
-    Extremum::<i32>::minimize(None).unwrap();
+    Extremum::<i64>::minimize(None).unwrap();
 }
 
 #[test]
 fn test_max_display() {
     assert_eq!(format!("{}", Max(Some(42))), "Max(42)");
-    assert_eq!(format!("{}", Max::<i32>(None)), "Max(None)");
+    assert_eq!(format!("{}", Max::<i64>(None)), "Max(None)");
 }
 
 #[test]
 fn test_min_display() {
     assert_eq!(format!("{}", Min(Some(7))), "Min(7)");
-    assert_eq!(format!("{}", Min::<i32>(None)), "Min(None)");
+    assert_eq!(format!("{}", Min::<i64>(None)), "Min(None)");
 }
 
 #[test]
@@ -311,3 +395,31 @@ fn test_and_display() {
     assert_eq!(format!("{}", And(true)), "And(true)");
     assert_eq!(format!("{}", And(false)), "And(false)");
 }
+
+#[test]
+fn exact_i64_to_f64_accepts_range_endpoints() {
+    assert_eq!(
+        i64_to_exact_f64(MAX_EXACT_F64_INTEGER),
+        Ok(MAX_EXACT_F64_INTEGER as f64)
+    );
+    assert_eq!(
+        i64_to_exact_f64(-MAX_EXACT_F64_INTEGER),
+        Ok(-(MAX_EXACT_F64_INTEGER as f64))
+    );
+}
+
+#[test]
+fn exact_i64_to_f64_rejects_adjacent_integers() {
+    assert_eq!(
+        i64_to_exact_f64(MAX_EXACT_F64_INTEGER + 1),
+        Err(ExactI64ToF64Error {
+            value: MAX_EXACT_F64_INTEGER + 1,
+        })
+    );
+    assert_eq!(
+        i64_to_exact_f64(-MAX_EXACT_F64_INTEGER - 1),
+        Err(ExactI64ToF64Error {
+            value: -MAX_EXACT_F64_INTEGER - 1,
+        })
+    );
+}
diff --git a/src/unit_tests/types_optimization_value.rs b/src/unit_tests/types_optimization_value.rs
index 2c4a69006..774767757 100644
--- a/src/unit_tests/types_optimization_value.rs
+++ b/src/unit_tests/types_optimization_value.rs
@@ -2,40 +2,40 @@ use crate::types::{Max, Min, OptimizationValue};
 
 #[test]
 fn test_min_meets_bound_feasible() {
-    assert!(Min::<i32>::meets_bound(&Min(Some(3)), &5));
+    assert!(Min::<i64>::meets_bound(&Min(Some(3)), &5));
 }
 
 #[test]
 fn test_min_meets_bound_exact() {
-    assert!(Min::<i32>::meets_bound(&Min(Some(5)), &5));
+    assert!(Min::<i64>::meets_bound(&Min(Some(5)), &5));
 }
 
 #[test]
 fn test_min_meets_bound_exceeds() {
-    assert!(!Min::<i32>::meets_bound(&Min(Some(7)), &5));
+    assert!(!Min::<i64>::meets_bound(&Min(Some(7)), &5));
 }
 
 #[test]
 fn test_min_meets_bound_infeasible() {
-    assert!(!Min::<i32>::meets_bound(&Min(None), &5));
+    assert!(!Min::<i64>::meets_bound(&Min(None), &5));
 }
 
 #[test]
 fn test_max_meets_bound_feasible() {
-    assert!(Max::<i32>::meets_bound(&Max(Some(7)), &5));
+    assert!(Max::<i64>::meets_bound(&Max(Some(7)), &5));
 }
 
 #[test]
 fn test_max_meets_bound_exact() {
-    assert!(Max::<i32>::meets_bound(&Max(Some(5)), &5));
+    assert!(Max::<i64>::meets_bound(&Max(Some(5)), &5));
 }
 
 #[test]
 fn test_max_meets_bound_below() {
-    assert!(!Max::<i32>::meets_bound(&Max(Some(3)), &5));
+    assert!(!Max::<i64>::meets_bound(&Max(Some(3)), &5));
 }
 
 #[test]
 fn test_max_meets_bound_infeasible() {
-    assert!(!Max::<i32>::meets_bound(&Max(None), &5));
+    assert!(!Max::<i64>::meets_bound(&Max(None), &5));
 }
diff --git a/src/unit_tests/unitdiskmapping_algorithms/alpha_tensor.rs b/src/unit_tests/unitdiskmapping_algorithms/alpha_tensor.rs
new file mode 100644
index 000000000..39bffd330
--- /dev/null
+++ b/src/unit_tests/unitdiskmapping_algorithms/alpha_tensor.rs
@@ -0,0 +1,215 @@
+//! Compactified alpha-tensor verification for unweighted KSG gadgets.
+//!
+//! Topology and weight mode are independent. This currently covers only KSG
+//! because an unweighted triangular gadget ruleset has not been implemented.
+
+use super::common::ksg_edges;
+use crate::rules::unitdiskmapping::ksg::{
+    KsgBranch, KsgBranchFix, KsgBranchFixB, KsgCross, KsgDanglingLeg, KsgEndTurn,
+    KsgReflectedGadget, KsgRotatedGadget, KsgTCon, KsgTrivialTurn, KsgTurn, KsgWTurn, Mirror,
+};
+use crate::rules::unitdiskmapping::Pattern;
+use std::collections::HashSet;
+
+fn weighted_mis_with_fixed_pins(
+    num_vertices: usize,
+    edges: &[(usize, usize)],
+    weights: &[i64],
+    pins: &[usize],
+    pin_config: usize,
+) -> i64 {
+    let forced_in: HashSet<usize> = pins
+        .iter()
+        .enumerate()
+        .filter_map(|(index, &pin)| ((pin_config >> index) & 1 == 1).then_some(pin))
+        .collect();
+    let forced_out: HashSet<usize> = pins
+        .iter()
+        .enumerate()
+        .filter_map(|(index, &pin)| ((pin_config >> index) & 1 == 0).then_some(pin))
+        .collect();
+
+    if edges
+        .iter()
+        .any(|(u, v)| forced_in.contains(u) && forced_in.contains(v))
+    {
+        return i64::MIN;
+    }
+
+    let blocked: HashSet<usize> = edges
+        .iter()
+        .flat_map(|&(u, v)| {
+            [
+                forced_in.contains(&u).then_some(v),
+                forced_in.contains(&v).then_some(u),
+            ]
+        })
+        .flatten()
+        .collect();
+    let free_vertices: Vec<usize> = (0..num_vertices)
+        .filter(|vertex| {
+            !forced_in.contains(vertex) && !forced_out.contains(vertex) && !blocked.contains(vertex)
+        })
+        .collect();
+    let subset_count = 1usize
+        .checked_shl(u32::try_from(free_vertices.len()).expect("free-vertex count must fit in u32"))
+        .expect("gadget must be small enough for exhaustive MIS verification");
+
+    let free_mis = (0..subset_count)
+        .filter(|subset| {
+            edges.iter().all(|&(u, v)| {
+                let u_selected = free_vertices
+                    .iter()
+                    .position(|&vertex| vertex == u)
+                    .is_some_and(|index| (subset >> index) & 1 == 1);
+                let v_selected = free_vertices
+                    .iter()
+                    .position(|&vertex| vertex == v)
+                    .is_some_and(|index| (subset >> index) & 1 == 1);
+                !u_selected || !v_selected
+            })
+        })
+        .map(|subset| {
+            free_vertices
+                .iter()
+                .enumerate()
+                .filter(|(index, _)| (subset >> index) & 1 == 1)
+                .try_fold(0_i64, |total, (_, &vertex)| {
+                    total.checked_add(weights[vertex])
+                })
+                .expect("gadget MIS weight must fit in i64")
+        })
+        .max()
+        .unwrap_or(0);
+    let forced_weight = forced_in
+        .iter()
+        .try_fold(0_i64, |total, &vertex| total.checked_add(weights[vertex]))
+        .expect("forced pin weight must fit in i64");
+
+    forced_weight
+        .checked_add(free_mis)
+        .expect("gadget MIS weight must fit in i64")
+}
+
+pub(super) fn alpha_tensor(
+    num_vertices: usize,
+    edges: &[(usize, usize)],
+    weights: &[i64],
+    pins: &[usize],
+) -> Vec<i64> {
+    let config_count = 1usize
+        .checked_shl(u32::try_from(pins.len()).expect("pin count must fit in u32"))
+        .expect("gadget must have few enough pins for exhaustive verification");
+
+    (0..config_count)
+        .map(|config| weighted_mis_with_fixed_pins(num_vertices, edges, weights, pins, config))
+        .collect()
+}
+
+fn compactify(tensor: &mut [i64]) {
+    for entry in 0..tensor.len() {
+        if tensor[entry] == i64::MIN {
+            continue;
+        }
+        if (0..tensor.len()).any(|other| {
+            entry != other
+                && tensor[other] != i64::MIN
+                && tensor[entry] <= tensor[other]
+                && (other & entry) == other
+        }) {
+            tensor[entry] = i64::MIN;
+        }
+    }
+}
+
+fn assert_unweighted_alpha_equivalent<G: Pattern>(gadget: G, name: &str) {
+    let (source_locations, source_edges, source_pins) = gadget.source_graph();
+    let (mapped_locations, mapped_pins) = gadget.mapped_graph();
+    let mut source = alpha_tensor(
+        source_locations.len(),
+        &source_edges,
+        &vec![1; source_locations.len()],
+        &source_pins,
+    );
+    let mut mapped = alpha_tensor(
+        mapped_locations.len(),
+        &ksg_edges(&mapped_locations),
+        &vec![1; mapped_locations.len()],
+        &mapped_pins,
+    );
+    compactify(&mut source);
+    compactify(&mut mapped);
+
+    assert_eq!(
+        source.len(),
+        mapped.len(),
+        "{name}: source and mapped gadgets expose different pin counts"
+    );
+    for (configuration, (&source_value, &mapped_value)) in source.iter().zip(&mapped).enumerate() {
+        assert_eq!(
+            source_value == i64::MIN,
+            mapped_value == i64::MIN,
+            "{name}: compactified alpha tensors disagree at pin configuration {configuration:#b}; source={source:?}, mapped={mapped:?}"
+        );
+        if source_value != i64::MIN {
+            assert_eq!(
+                mapped_value
+                    .checked_sub(source_value)
+                    .expect("alpha-tensor difference must fit in i64"),
+                gadget.mis_overhead(),
+                "{name}: alpha-tensor overhead differs at pin configuration {configuration:#b}; source={source:?}, mapped={mapped:?}"
+            );
+        }
+    }
+}
+
+#[test]
+fn test_unweighted_crossing_gadget_alpha_tensors() {
+    assert_unweighted_alpha_equivalent(KsgCross::<false>, "KsgCross<false>");
+    assert_unweighted_alpha_equivalent(KsgTurn, "KsgTurn");
+    assert_unweighted_alpha_equivalent(KsgWTurn, "KsgWTurn");
+    assert_unweighted_alpha_equivalent(KsgBranch, "KsgBranch");
+    assert_unweighted_alpha_equivalent(KsgBranchFix, "KsgBranchFix");
+    assert_unweighted_alpha_equivalent(KsgTCon, "KsgTCon");
+    assert_unweighted_alpha_equivalent(KsgTrivialTurn, "KsgTrivialTurn");
+    assert_unweighted_alpha_equivalent(KsgRotatedGadget::new(KsgTCon, 1), "RotatedKsgTCon");
+    assert_unweighted_alpha_equivalent(
+        KsgReflectedGadget::new(KsgCross::<true>, Mirror::Y),
+        "ReflectedKsgCross<true>",
+    );
+    assert_unweighted_alpha_equivalent(
+        KsgReflectedGadget::new(KsgTrivialTurn, Mirror::Y),
+        "ReflectedKsgTrivialTurn",
+    );
+    assert_unweighted_alpha_equivalent(KsgBranchFixB, "KsgBranchFixB");
+    assert_unweighted_alpha_equivalent(KsgEndTurn, "KsgEndTurn");
+    assert_unweighted_alpha_equivalent(
+        KsgReflectedGadget::new(KsgRotatedGadget::new(KsgTCon, 1), Mirror::Y),
+        "ReflectedRotatedKsgTCon",
+    );
+}
+
+#[test]
+fn test_unweighted_simplifier_gadget_alpha_tensors() {
+    assert_unweighted_alpha_equivalent(KsgDanglingLeg, "KsgDanglingLeg");
+    assert_unweighted_alpha_equivalent(
+        KsgRotatedGadget::new(KsgDanglingLeg, 1),
+        "KsgDanglingLegRot1",
+    );
+    assert_unweighted_alpha_equivalent(
+        KsgRotatedGadget::new(KsgDanglingLeg, 2),
+        "KsgDanglingLegRot2",
+    );
+    assert_unweighted_alpha_equivalent(
+        KsgRotatedGadget::new(KsgDanglingLeg, 3),
+        "KsgDanglingLegRot3",
+    );
+    assert_unweighted_alpha_equivalent(
+        KsgReflectedGadget::new(KsgDanglingLeg, Mirror::X),
+        "KsgDanglingLegMirrorX",
+    );
+    assert_unweighted_alpha_equivalent(
+        KsgReflectedGadget::new(KsgDanglingLeg, Mirror::Y),
+        "KsgDanglingLegMirrorY",
+    );
+}
diff --git a/src/unit_tests/unitdiskmapping_algorithms/common.rs b/src/unit_tests/unitdiskmapping_algorithms/common.rs
index 2a6cd4f5a..f0d44ceea 100644
--- a/src/unit_tests/unitdiskmapping_algorithms/common.rs
+++ b/src/unit_tests/unitdiskmapping_algorithms/common.rs
@@ -4,17 +4,13 @@ use crate::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use crate::rules::unitdiskmapping::MappingResult;
 use crate::solvers::ILPSolver;
 
-fn build_mis_ilp(num_vertices: usize, edges: &[(usize, usize)], weights: &[i32]) -> ILP<bool> {
+fn build_mis_ilp(num_vertices: usize, edges: &[(usize, usize)], weights: &[i64]) -> ILP<bool> {
     let constraints: Vec<LinearConstraint> = edges
         .iter()
-        .map(|&(i, j)| LinearConstraint::le(vec![(i, 1.0), (j, 1.0)], 1.0))
+        .map(|&(i, j)| LinearConstraint::le(vec![(i, 1), (j, 1)], 1))
         .collect();
 
-    let objective: Vec<(usize, f64)> = weights
-        .iter()
-        .enumerate()
-        .map(|(i, &w)| (i, w as f64))
-        .collect();
+    let objective: Vec<(usize, i64)> = weights.iter().enumerate().map(|(i, &w)| (i, w)).collect();
 
     ILP::<bool>::new(
         num_vertices,
@@ -22,12 +18,13 @@ fn build_mis_ilp(num_vertices: usize, edges: &[(usize, usize)], weights: &[i32])
         objective,
         ObjectiveSense::Maximize,
     )
+    .expect("MIS test ILP must be valid")
 }
 
 /// Check if a configuration is a valid independent set.
 pub fn is_independent_set(edges: &[(usize, usize)], config: &[usize]) -> bool {
     for &(u, v) in edges {
-        if config.get(u).copied().unwrap_or(0) > 0 && config.get(v).copied().unwrap_or(0) > 0 {
+        if config[u] > 0 && config[v] > 0 {
             return false;
         }
     }
@@ -40,11 +37,12 @@ pub fn solve_mis(num_vertices: usize, edges: &[(usize, usize)]) -> usize {
     let weights = vec![1; num_vertices];
     let ilp = build_mis_ilp(num_vertices, edges, &weights);
     let solver = ILPSolver::new();
-    if let Some(solution) = solver.solve(&ilp) {
-        solution.iter().filter(|&&x| x > 0).count()
-    } else {
-        0
-    }
+    solver
+        .solve(&ilp)
+        .expect("test MIS solver must return a solution")
+        .iter()
+        .filter(|&&x| x > 0)
+        .count()
 }
 
 /// Solve MIS and return the binary configuration.
@@ -52,14 +50,12 @@ pub fn solve_mis_config(num_vertices: usize, edges: &[(usize, usize)]) -> Vec<us
     let weights = vec![1; num_vertices];
     let ilp = build_mis_ilp(num_vertices, edges, &weights);
     let solver = ILPSolver::new();
-    if let Some(solution) = solver.solve(&ilp) {
-        solution
-            .iter()
-            .map(|&x| if x > 0 { 1 } else { 0 })
-            .collect()
-    } else {
-        vec![0; num_vertices]
-    }
+    solver
+        .solve(&ilp)
+        .expect("test MIS solver must return a solution")
+        .iter()
+        .map(|&x| if x > 0 { 1 } else { 0 })
+        .collect()
 }
 
 /// Solve MIS on a Grid using ILPSolver (unweighted).
@@ -76,27 +72,28 @@ pub fn solve_weighted_grid_mis(result: &MappingResult) -> usize {
     let edges = result.edges();
     let num_vertices = result.positions.len();
 
-    let weights: Vec<i32> = (0..num_vertices)
-        .map(|i| result.node_weights.get(i).copied().unwrap_or(1))
-        .collect();
+    assert_eq!(result.node_weights.len(), num_vertices);
 
-    solve_weighted_mis(num_vertices, &edges, &weights) as usize
+    usize::try_from(solve_weighted_mis(
+        num_vertices,
+        &edges,
+        &result.node_weights,
+    ))
+    .expect("test weighted MIS value must fit in usize")
 }
 
 /// Solve weighted MIS on a graph using ILP.
 /// Returns the maximum weighted independent set value.
-pub fn solve_weighted_mis(num_vertices: usize, edges: &[(usize, usize)], weights: &[i32]) -> i32 {
+pub fn solve_weighted_mis(num_vertices: usize, edges: &[(usize, usize)], weights: &[i64]) -> i64 {
     let ilp = build_mis_ilp(num_vertices, edges, weights);
     let solver = ILPSolver::new();
-    if let Some(solution) = solver.solve(&ilp) {
-        solution
-            .iter()
-            .zip(weights.iter())
-            .map(|(&x, &w)| if x > 0 { w } else { 0 })
-            .sum()
-    } else {
-        0
-    }
+    solver
+        .solve(&ilp)
+        .expect("test weighted MIS solver must return a solution")
+        .iter()
+        .zip(weights.iter())
+        .map(|(&x, &w)| if x > 0 { w } else { 0 })
+        .sum()
 }
 
 /// Solve weighted MIS and return the binary configuration.
@@ -104,19 +101,17 @@ pub fn solve_weighted_mis(num_vertices: usize, edges: &[(usize, usize)], weights
 pub fn solve_weighted_mis_config(
     num_vertices: usize,
     edges: &[(usize, usize)],
-    weights: &[i32],
+    weights: &[i64],
 ) -> Vec<usize> {
     let ilp = build_mis_ilp(num_vertices, edges, weights);
 
     let solver = ILPSolver::new();
-    if let Some(solution) = solver.solve(&ilp) {
-        solution
-            .iter()
-            .map(|&x| if x > 0 { 1 } else { 0 })
-            .collect()
-    } else {
-        vec![0; num_vertices]
-    }
+    solver
+        .solve(&ilp)
+        .expect("test weighted MIS solver must return a solution")
+        .iter()
+        .map(|&x| if x > 0 { 1 } else { 0 })
+        .collect()
 }
 
 /// Generate edges for triangular lattice using proper triangular coordinates.
@@ -143,3 +138,16 @@ pub fn triangular_edges(locs: &[(usize, usize)], radius: f64) -> Vec<(usize, usi
     }
     edges
 }
+
+/// Generate edges for the King's-subgraph topology.
+pub fn ksg_edges(locations: &[(usize, usize)]) -> Vec<(usize, usize)> {
+    let mut edges = Vec::new();
+    for (left, &(left_row, left_column)) in locations.iter().enumerate() {
+        for (right, &(right_row, right_column)) in locations.iter().enumerate().skip(left + 1) {
+            if left_row.abs_diff(right_row) <= 1 && left_column.abs_diff(right_column) <= 1 {
+                edges.push((left, right));
+            }
+        }
+    }
+    edges
+}
diff --git a/src/unit_tests/unitdiskmapping_algorithms/copyline.rs b/src/unit_tests/unitdiskmapping_algorithms/copyline.rs
index e916fc140..179ca77ea 100644
--- a/src/unit_tests/unitdiskmapping_algorithms/copyline.rs
+++ b/src/unit_tests/unitdiskmapping_algorithms/copyline.rs
@@ -12,7 +12,7 @@ fn test_create_copylines_empty_graph() {
     // Test with no edges
     let edges: Vec<(usize, usize)> = vec![];
     let order = vec![0, 1, 2];
-    let copylines = create_copylines(3, &edges, &order);
+    let copylines = create_copylines(3, &edges, &order).unwrap();
 
     assert_eq!(copylines.len(), 3);
 }
@@ -21,7 +21,7 @@ fn test_create_copylines_empty_graph() {
 fn test_create_copylines_single_vertex() {
     let edges: Vec<(usize, usize)> = vec![];
     let order = vec![0];
-    let copylines = create_copylines(1, &edges, &order);
+    let copylines = create_copylines(1, &edges, &order).unwrap();
 
     assert_eq!(copylines.len(), 1);
 }
@@ -46,8 +46,7 @@ fn test_mis_overhead_copyline_zero_hstop() {
 #[test]
 fn test_copylines_have_valid_vertex_ids() {
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     for line in &result.lines {
         assert!(line.vertex < 3, "Vertex ID should be in range");
     }
@@ -56,8 +55,7 @@ fn test_copylines_have_valid_vertex_ids() {
 #[test]
 fn test_copylines_have_positive_slots() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     for line in &result.lines {
         assert!(line.vslot > 0, "vslot should be positive");
         assert!(line.hslot > 0, "hslot should be positive");
@@ -67,8 +65,7 @@ fn test_copylines_have_positive_slots() {
 #[test]
 fn test_copylines_have_valid_ranges() {
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     for line in &result.lines {
         assert!(line.vstart <= line.vstop, "vstart should be <= vstop");
         assert!(line.vstart <= line.hslot, "vstart should be <= hslot");
@@ -145,8 +142,7 @@ fn test_copyline_copyline_locations_triangular() {
 #[test]
 fn test_mapping_result_has_copylines() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     assert_eq!(result.lines.len(), 3);
 
     // Each vertex should have exactly one copy line
@@ -160,16 +156,14 @@ fn test_mapping_result_has_copylines() {
 #[test]
 fn test_triangular_mapping_result_has_copylines() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
+    let result = triangular::map_weighted(3, &edges).unwrap();
     assert_eq!(result.lines.len(), 3);
 }
 
 #[test]
 fn test_copyline_vslot_hslot_ordering() {
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     // vslot is determined by vertex order, should be 1-indexed
     let mut vslots: Vec<usize> = result.lines.iter().map(|l| l.vslot).collect();
     vslots.sort();
@@ -183,8 +177,7 @@ fn test_copyline_vslot_hslot_ordering() {
 #[test]
 fn test_copyline_center_on_grid() {
     let edges = vec![(0, 1)];
-    let result = ksg::map_unweighted(2, &edges);
-
+    let result = ksg::map_unweighted(2, &edges).unwrap();
     // Each copyline's center should correspond to a grid node
     for line in &result.lines {
         let (row, col) = line.center_location(result.padding, result.spacing);
@@ -255,8 +248,7 @@ fn test_copyline_copyline_locations_structure() {
 #[test]
 fn test_copyline_triangular_spacing() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
+    let result = triangular::map_weighted(3, &edges).unwrap();
     // Triangular uses spacing=6
     assert_eq!(result.spacing, 6);
 
@@ -301,10 +293,10 @@ fn test_copyline_center_vs_locations() {
 /// is excluded because Julia's center weight is 0 while Rust's is min 1.
 #[test]
 fn test_copyline_weighted_mis_equals_overhead() {
-    // Test cases: (vstart, vstop, hstop) as i32 for arithmetic
+    // Test cases: (vstart, vstop, hstop) as i64 for arithmetic
     // Note: Excluding (5, 5, 5) which is degenerate - only center node with
     // Julia weight=0 vs Rust weight=1 (Rust uses nline.max(1) for center)
-    let test_cases: [(i32, i32, i32); 7] = [
+    let test_cases: [(i64, i64, i64); 7] = [
         (3, 7, 8),
         (3, 5, 8),
         (5, 9, 8),
@@ -315,7 +307,7 @@ fn test_copyline_weighted_mis_equals_overhead() {
     ];
 
     let padding: usize = 2;
-    let spacing: i32 = 4;
+    let spacing: i64 = 4;
 
     for (vstart, vstop, hstop) in test_cases {
         // Create copyline with vslot=5, hslot=5 (matching Julia's test)
@@ -358,7 +350,7 @@ fn test_copyline_weighted_mis_equals_overhead() {
             }
         }
 
-        let weights: Vec<i32> = locs.iter().map(|&(_, _, w)| w as i32).collect();
+        let weights: Vec<i64> = locs.iter().map(|&(_, _, w)| w as i64).collect();
 
         // Solve weighted MIS
         let weighted_mis = solve_weighted_mis(n, &edges, &weights);
@@ -366,8 +358,8 @@ fn test_copyline_weighted_mis_equals_overhead() {
         // Calculate expected value using Julia's weighted formula:
         // mis_overhead_copyline(Weighted(), line) =
         //   (hslot - vstart) * s + (vstop - hslot) * s + max((hstop - vslot) * s - 2, 0)
-        let hslot: i32 = 5;
-        let vslot: i32 = 5;
+        let hslot: i64 = 5;
+        let vslot: i64 = 5;
         let expected = (hslot - vstart) * spacing
             + (vstop - hslot) * spacing
             + std::cmp::max((hstop - vslot) * spacing - 2, 0);
diff --git a/src/unit_tests/unitdiskmapping_algorithms/gadgets.rs b/src/unit_tests/unitdiskmapping_algorithms/gadgets.rs
index 178544be1..d0bfa0434 100644
--- a/src/unit_tests/unitdiskmapping_algorithms/gadgets.rs
+++ b/src/unit_tests/unitdiskmapping_algorithms/gadgets.rs
@@ -1,6 +1,6 @@
 //! Tests for gadget properties (src/rules/mapping/gadgets.rs and triangular gadgets).
 
-use super::common::{solve_weighted_mis, triangular_edges};
+use super::common::{ksg_edges, solve_weighted_mis, triangular_edges};
 use crate::rules::unitdiskmapping::ksg::{
     KsgBranch, KsgBranchFix, KsgBranchFixB, KsgCross, KsgDanglingLeg, KsgEndTurn,
     KsgReflectedGadget, KsgRotatedGadget, KsgTCon, KsgTrivialTurn, KsgTurn, KsgWTurn, Mirror,
@@ -210,8 +210,8 @@ fn test_triturn_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -241,8 +241,8 @@ fn test_tribranch_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -272,8 +272,8 @@ fn test_tricross_connected_weighted_mis_equivalence() {
     let (source_locs, source_edges, source_pins) = gadget.source_graph();
     let (mapped_locs, mapped_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &source_pins {
         src_weights[p] -= 1;
     }
@@ -303,8 +303,8 @@ fn test_tricross_disconnected_weighted_mis_equivalence() {
     let (source_locs, source_edges, source_pins) = gadget.source_graph();
     let (mapped_locs, mapped_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &source_pins {
         src_weights[p] -= 1;
     }
@@ -335,8 +335,8 @@ fn test_all_triangular_weighted_gadgets_mis_equivalence() {
         let (src_locs, src_edges, src_pins) = gadget.source_graph();
         let (map_locs, map_pins) = gadget.mapped_graph();
 
-        let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-        let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+        let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+        let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
         for &p in &src_pins {
             src_weights[p] -= 1;
         }
@@ -375,33 +375,14 @@ fn test_all_triangular_weighted_gadgets_mis_equivalence() {
 
 // === KSG Weighted Gadget Tests ===
 
-/// Generate King's SubGraph (KSG) edges for square lattice.
-/// KSG includes both axis-aligned and diagonal neighbors within distance sqrt(2).
-fn ksg_edges(locs: &[(usize, usize)]) -> Vec<(usize, usize)> {
-    let mut edges = Vec::new();
-    for (i, &(r1, c1)) in locs.iter().enumerate() {
-        for (j, &(r2, c2)) in locs.iter().enumerate() {
-            if i < j {
-                let dr = (r1 as i32 - r2 as i32).abs();
-                let dc = (c1 as i32 - c2 as i32).abs();
-                // KSG: neighbors at distance <= sqrt(2) => dr,dc each <= 1
-                if dr <= 1 && dc <= 1 {
-                    edges.push((i, j));
-                }
-            }
-        }
-    }
-    edges
-}
-
 #[test]
 fn test_weighted_ksg_cross_connected_mis_equivalence() {
     let gadget = WeightedKsgCross::<true>;
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -430,8 +411,8 @@ fn test_weighted_ksg_cross_disconnected_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -460,8 +441,8 @@ fn test_weighted_ksg_turn_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -490,8 +471,8 @@ fn test_weighted_ksg_wturn_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -520,8 +501,8 @@ fn test_weighted_ksg_branch_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -550,8 +531,8 @@ fn test_weighted_ksg_branchfix_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -580,8 +561,8 @@ fn test_weighted_ksg_tcon_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -610,8 +591,8 @@ fn test_weighted_ksg_trivialturn_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -640,8 +621,8 @@ fn test_weighted_ksg_endturn_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -670,8 +651,8 @@ fn test_weighted_ksg_branchfixb_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -700,8 +681,8 @@ fn test_weighted_ksg_danglinleg_mis_equivalence() {
     let (src_locs, src_edges, src_pins) = gadget.source_graph();
     let (map_locs, map_pins) = gadget.mapped_graph();
 
-    let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-    let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+    let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+    let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
     for &p in &src_pins {
         src_weights[p] -= 1;
     }
@@ -794,8 +775,8 @@ fn test_all_ksg_weighted_gadgets_mis_equivalence() {
         let (src_locs, src_edges, src_pins) = gadget.source_graph();
         let (map_locs, map_pins) = gadget.mapped_graph();
 
-        let mut src_weights: Vec<i32> = gadget.source_weights().to_vec();
-        let mut map_weights: Vec<i32> = gadget.mapped_weights().to_vec();
+        let mut src_weights: Vec<i64> = gadget.source_weights().to_vec();
+        let mut map_weights: Vec<i64> = gadget.mapped_weights().to_vec();
         for &p in &src_pins {
             src_weights[p] -= 1;
         }
@@ -945,40 +926,6 @@ fn test_gadget_connected_nodes() {
     assert!(!weighted_nodes.is_empty());
 }
 
-// === Alpha Tensor Tests ===
-
-#[test]
-fn test_build_standard_unit_disk_edges() {
-    use crate::rules::unitdiskmapping::alpha_tensor::build_standard_unit_disk_edges;
-
-    // Simple test: two adjacent points
-    let locs = vec![(0, 0), (1, 0)];
-    let edges = build_standard_unit_disk_edges(&locs);
-    assert_eq!(edges.len(), 1);
-    assert_eq!(edges[0], (0, 1));
-
-    // Points too far apart
-    let locs = vec![(0, 0), (3, 3)];
-    let edges = build_standard_unit_disk_edges(&locs);
-    assert!(edges.is_empty());
-
-    // Multiple points in a small grid
-    let locs = vec![(0, 0), (1, 0), (0, 1), (1, 1)];
-    let edges = build_standard_unit_disk_edges(&locs);
-    // Should have edges for adjacent and diagonal neighbors
-    assert!(edges.len() > 2);
-}
-
-#[test]
-fn test_build_triangular_unit_disk_edges() {
-    use crate::rules::unitdiskmapping::alpha_tensor::build_triangular_unit_disk_edges;
-
-    let locs = vec![(0, 0), (1, 0), (0, 1)];
-    let edges = build_triangular_unit_disk_edges(&locs);
-    // Should have some edges
-    assert!(!edges.is_empty() || locs.len() < 2);
-}
-
 // === Triangular Gadget Trait Method Tests ===
 
 #[test]
diff --git a/src/unit_tests/unitdiskmapping_algorithms/gadgets_ground_truth.rs b/src/unit_tests/unitdiskmapping_algorithms/gadgets_ground_truth.rs
index 00fdb3a49..e1567c5e5 100644
--- a/src/unit_tests/unitdiskmapping_algorithms/gadgets_ground_truth.rs
+++ b/src/unit_tests/unitdiskmapping_algorithms/gadgets_ground_truth.rs
@@ -24,15 +24,15 @@ struct GadgetData {
     name: String,
     size: Vec<usize>,
     cross_location: Vec<usize>,
-    mis_overhead: i32,
+    mis_overhead: i64,
     source_nodes: usize,
     mapped_nodes: usize,
     source_locs: Vec<Vec<usize>>,
     mapped_locs: Vec<Vec<usize>>,
     #[serde(default)]
-    source_weights: Vec<i32>,
+    source_weights: Vec<i64>,
     #[serde(default)]
-    mapped_weights: Vec<i32>,
+    mapped_weights: Vec<i64>,
     #[serde(default)]
     source_centers: Vec<Vec<usize>>,
     #[serde(default)]
diff --git a/src/unit_tests/unitdiskmapping_algorithms/julia_comparison.rs b/src/unit_tests/unitdiskmapping_algorithms/julia_comparison.rs
index 9157e49b3..973e9ba77 100644
--- a/src/unit_tests/unitdiskmapping_algorithms/julia_comparison.rs
+++ b/src/unit_tests/unitdiskmapping_algorithms/julia_comparison.rs
@@ -5,7 +5,7 @@
 //! - Weighted (square lattice with weights)
 //! - Triangular (triangular lattice with weights)
 
-use crate::rules::unitdiskmapping::{ksg, triangular};
+use crate::rules::unitdiskmapping::{ksg, triangular, MappingResult};
 use serde::Deserialize;
 use std::collections::HashSet;
 use std::fs;
@@ -23,7 +23,7 @@ struct JuliaTrace {
     num_grid_nodes: usize,
     #[serde(default)]
     num_grid_nodes_before_simplifiers: usize,
-    mis_overhead: i32,
+    mis_overhead: i64,
     #[serde(default)]
     original_mis_size: f64,
     #[serde(default)]
@@ -40,32 +40,32 @@ struct JuliaTrace {
 
 /// Grid node in compact format: [row, col, weight]
 #[derive(Debug, Deserialize)]
-#[serde(from = "(i32, i32, i32)")]
+#[serde(from = "(i64, i64, i64)")]
 #[allow(dead_code)]
 struct CompactGridNode {
-    row: i32,
-    col: i32,
-    weight: i32,
+    row: i64,
+    col: i64,
+    weight: i64,
 }
 
-impl From<(i32, i32, i32)> for CompactGridNode {
-    fn from((row, col, weight): (i32, i32, i32)) -> Self {
+impl From<(i64, i64, i64)> for CompactGridNode {
+    fn from((row, col, weight): (i64, i64, i64)) -> Self {
         Self { row, col, weight }
     }
 }
 
 /// Grid node with state in compact format: [row, col, state]
 #[derive(Debug, Deserialize)]
-#[serde(from = "(i32, i32, String)")]
+#[serde(from = "(i64, i64, String)")]
 #[allow(dead_code)]
 struct CompactGridNodeWithState {
-    row: i32,
-    col: i32,
+    row: i64,
+    col: i64,
     state: String,
 }
 
-impl From<(i32, i32, String)> for CompactGridNodeWithState {
-    fn from((row, col, state): (i32, i32, String)) -> Self {
+impl From<(i64, i64, String)> for CompactGridNodeWithState {
+    fn from((row, col, state): (i64, i64, String)) -> Self {
         Self { row, col, state }
     }
 }
@@ -80,22 +80,22 @@ struct CopyLineInfo {
     vstop: usize,
     hstop: usize,
     /// Compact locations format: [[row, col], ...]
-    locs: Vec<(i32, i32)>,
+    locs: Vec<(i64, i64)>,
 }
 
 /// Tape entry in compact format: [row, col, gadget_type, index]
 #[derive(Debug, Deserialize)]
-#[serde(from = "(i32, i32, String, usize)")]
+#[serde(from = "(i64, i64, String, usize)")]
 #[allow(dead_code)]
 struct CompactTapeEntry {
-    row: i32,
-    col: i32,
+    row: i64,
+    col: i64,
     gadget_type: String,
     index: usize,
 }
 
-impl From<(i32, i32, String, usize)> for CompactTapeEntry {
-    fn from((row, col, gadget_type, index): (i32, i32, String, usize)) -> Self {
+impl From<(i64, i64, String, usize)> for CompactTapeEntry {
+    fn from((row, col, gadget_type, index): (i64, i64, String, usize)) -> Self {
         Self {
             row,
             col,
@@ -116,6 +116,24 @@ fn get_graph_edges(julia: &JuliaTrace) -> Vec<(usize, usize)> {
     julia.edges.iter().map(|(u, v)| (u - 1, v - 1)).collect()
 }
 
+fn julia_grid_nodes(julia: &JuliaTrace) -> HashSet<(i64, i64, i64)> {
+    julia
+        .grid_nodes
+        .iter()
+        .map(|node| (node.row - 1, node.col - 1, node.weight))
+        .collect()
+}
+
+fn rust_grid_nodes<T>(result: &MappingResult<T>) -> HashSet<(i64, i64, i64)> {
+    result
+        .positions
+        .iter()
+        .copied()
+        .zip(result.node_weights.iter().copied())
+        .map(|((row, col), weight)| (row, col, weight))
+        .collect()
+}
+
 /// Compare Rust and Julia for square lattice (UnWeighted mode)
 fn compare_square_unweighted(name: &str) {
     let julia = load_julia_trace(name, "unweighted");
@@ -124,21 +142,20 @@ fn compare_square_unweighted(name: &str) {
 
     // Use Julia's vertex order to ensure consistent mapping
     let vertex_order = get_vertex_order(&julia);
-    let rust_result = ksg::map_unweighted_with_order(num_vertices, &edges, &vertex_order);
-
+    let rust_result = ksg::map_unweighted_with_order(num_vertices, &edges, &vertex_order).unwrap();
     // Collect Rust grid nodes from copyline_locations (0-indexed)
-    let rust_nodes: HashSet<(i32, i32)> = rust_result
+    let rust_nodes: HashSet<(i64, i64)> = rust_result
         .lines
         .iter()
         .flat_map(|line| {
             line.copyline_locations(rust_result.padding, rust_result.spacing)
                 .into_iter()
-                .map(|(row, col, _)| (row as i32, col as i32))
+                .map(|(row, col, _)| (row as i64, col as i64))
         })
         .collect();
 
     // Collect Julia copyline nodes (convert from 1-indexed to 0-indexed)
-    let julia_nodes: HashSet<(i32, i32)> = julia
+    let julia_nodes: HashSet<(i64, i64)> = julia
         .copy_lines
         .iter()
         .flat_map(|cl| cl.locs.iter().map(|(row, col)| (row - 1, col - 1)))
@@ -180,13 +197,51 @@ fn compare_square_unweighted(name: &str) {
         "{} square: Node positions don't match",
         name
     );
+    assert_eq!(
+        julia_grid_nodes(&julia),
+        rust_grid_nodes(&rust_result),
+        "{} square: final mapped nodes don't match",
+        name
+    );
+}
+
+fn compare_square_weighted(name: &str) {
+    let julia = load_julia_trace(name, "weighted");
+    let edges = get_graph_edges(&julia);
+    let vertex_order = get_vertex_order(&julia);
+    let rust_result =
+        ksg::map_weighted_with_order(julia.num_vertices, &edges, &vertex_order).unwrap();
+
+    compare_copy_lines(&julia.copy_lines, &rust_result.lines);
+    assert_eq!(
+        julia.grid_size, rust_result.grid_dimensions,
+        "{} weighted square: grid size mismatch",
+        name
+    );
+    assert_eq!(
+        julia.mis_overhead, rust_result.mis_overhead,
+        "{} weighted square: MIS overhead mismatch",
+        name
+    );
+    assert_eq!(
+        julia.tape.len(),
+        rust_result.tape.len(),
+        "{} weighted square: tape length mismatch",
+        name
+    );
+    assert_eq!(
+        julia_grid_nodes(&julia),
+        rust_grid_nodes(&rust_result),
+        "{} weighted square: final mapped nodes don't match",
+        name
+    );
 }
 
 /// Get MIS overhead for a Julia gadget type string (triangular/weighted mode)
 /// Values from Julia's UnitDiskMapping/src/triangular.jl lines 401-413
 /// For simplifiers: Julia uses mis_overhead(w::WeightedGadget) = mis_overhead(w.gadget) * 2
 #[allow(clippy::if_same_then_else)]
-fn julia_gadget_overhead(gadget_type: &str) -> i32 {
+fn julia_gadget_overhead(gadget_type: &str) -> i64 {
     // Order matters - check more specific patterns first
     // Some gadget types have the same overhead but must be checked in order
     if gadget_type.contains("TriCross{true") {
@@ -225,7 +280,7 @@ fn julia_gadget_overhead(gadget_type: &str) -> i32 {
 /// Get MIS overhead for a Rust triangular gadget index (triangular/weighted mode)
 /// Must match Julia's values from triangular.jl
 /// For simplifiers: Julia uses mis_overhead(w::WeightedGadget) = mis_overhead(w.gadget) * 2
-fn rust_triangular_gadget_overhead(idx: usize) -> i32 {
+fn rust_triangular_gadget_overhead(idx: usize) -> i64 {
     match idx {
         0 => 3,                  // TriCross<false>
         1 => 1,                  // TriCross<true>
@@ -249,11 +304,11 @@ fn rust_triangular_gadget_overhead(idx: usize) -> i32 {
 fn copyline_overhead_triangular(
     line: &crate::rules::unitdiskmapping::CopyLine,
     spacing: usize,
-) -> i32 {
-    let s = spacing as i32;
-    let vertical_up = (line.hslot as i32 - line.vstart as i32) * s;
-    let vertical_down = (line.vstop as i32 - line.hslot as i32) * s;
-    let horizontal = ((line.hstop as i32 - line.vslot as i32) * s - 2).max(0);
+) -> i64 {
+    let s = spacing as i64;
+    let vertical_up = (line.hslot as i64 - line.vstart as i64) * s;
+    let vertical_down = (line.vstop as i64 - line.hslot as i64) * s;
+    let horizontal = ((line.hstop as i64 - line.vslot as i64) * s - 2).max(0);
     vertical_up + vertical_down + horizontal
 }
 
@@ -272,21 +327,21 @@ fn compare_triangular(name: &str) {
 
     // Extract Julia's vertex order from copy_lines
     let vertex_order = get_vertex_order(&julia);
-    let rust_result = triangular::map_weighted_with_order(num_vertices, &edges, &vertex_order);
-
+    let rust_result =
+        triangular::map_weighted_with_order(num_vertices, &edges, &vertex_order).unwrap();
     // Collect Rust grid nodes from copyline_locations_triangular (0-indexed)
-    let rust_nodes: HashSet<(i32, i32)> = rust_result
+    let rust_nodes: HashSet<(i64, i64)> = rust_result
         .lines
         .iter()
         .flat_map(|line| {
             line.copyline_locations_triangular(rust_result.padding, rust_result.spacing)
                 .into_iter()
-                .map(|(row, col, _)| (row as i32, col as i32))
+                .map(|(row, col, _)| (row as i64, col as i64))
         })
         .collect();
 
     // Collect Julia copyline nodes (convert from 1-indexed to 0-indexed)
-    let julia_nodes: HashSet<(i32, i32)> = julia
+    let julia_nodes: HashSet<(i64, i64)> = julia
         .copy_lines
         .iter()
         .flat_map(|cl| cl.locs.iter().map(|(row, col)| (row - 1, col - 1)))
@@ -305,31 +360,31 @@ fn compare_triangular(name: &str) {
     compare_copy_lines(&julia.copy_lines, &rust_result.lines);
 
     // Calculate and compare MIS overhead breakdown
-    let julia_copyline_overhead: i32 = julia
+    let julia_copyline_overhead: i64 = julia
         .copy_lines
         .iter()
         .map(|cl| {
-            let s = 6i32;
-            let vert_up = (cl.hslot as i32 - cl.vstart as i32) * s;
-            let vert_down = (cl.vstop as i32 - cl.hslot as i32) * s;
-            let horiz = ((cl.hstop as i32 - cl.vslot as i32) * s - 2).max(0);
+            let s = 6i64;
+            let vert_up = (cl.hslot as i64 - cl.vstart as i64) * s;
+            let vert_down = (cl.vstop as i64 - cl.hslot as i64) * s;
+            let horiz = ((cl.hstop as i64 - cl.vslot as i64) * s - 2).max(0);
             vert_up + vert_down + horiz
         })
         .sum();
 
-    let rust_copyline_overhead: i32 = rust_result
+    let rust_copyline_overhead: i64 = rust_result
         .lines
         .iter()
         .map(|l| copyline_overhead_triangular(l, rust_result.spacing))
         .sum();
 
-    let julia_gadget_overhead_total: i32 = julia
+    let julia_gadget_overhead_total: i64 = julia
         .tape
         .iter()
         .map(|e| julia_gadget_overhead(&e.gadget_type))
         .sum();
 
-    let rust_gadget_overhead_total: i32 = rust_result
+    let rust_gadget_overhead_total: i64 = rust_result
         .tape
         .iter()
         .map(|e| rust_triangular_gadget_overhead(e.pattern_idx))
@@ -362,7 +417,7 @@ fn compare_triangular(name: &str) {
         let j_oh = julia_gadget_overhead(&jt.gadget_type);
         if let Some(rt) = rust_result.tape.get(i) {
             let r_oh = rust_triangular_gadget_overhead(rt.pattern_idx);
-            let pos_match = jt.row == rt.row as i32 && jt.col == rt.col as i32;
+            let pos_match = jt.row - 1 == rt.row as i64 && jt.col - 1 == rt.col as i64;
             println!(
                 "  {:2}. Julia: {} at ({},{}) oh={} | Rust: idx={} at ({},{}) oh={} [{}]",
                 i + 1,
@@ -411,6 +466,20 @@ fn compare_triangular(name: &str) {
         julia.tape.len(),
         rust_result.tape.len()
     );
+    for (julia_entry, rust_entry) in julia.tape.iter().zip(&rust_result.tape) {
+        assert_eq!(
+            (julia_entry.row - 1, julia_entry.col - 1),
+            (rust_entry.row as i64, rust_entry.col as i64),
+            "{} triangular: tape position mismatch",
+            name
+        );
+        assert_eq!(
+            julia_gadget_overhead(&julia_entry.gadget_type),
+            rust_triangular_gadget_overhead(rust_entry.pattern_idx),
+            "{} triangular: tape gadget overhead mismatch",
+            name
+        );
+    }
     assert_eq!(
         julia.mis_overhead, rust_result.mis_overhead,
         "{} triangular: MIS overhead mismatch (Julia={}, Rust={})",
@@ -429,14 +498,20 @@ fn compare_triangular(name: &str) {
         "{} triangular: Node positions don't match",
         name
     );
+    assert_eq!(
+        julia_grid_nodes(&julia),
+        rust_grid_nodes(&rust_result),
+        "{} triangular: final mapped nodes don't match",
+        name
+    );
 }
 
 fn print_comparison(
     julia: &JuliaTrace,
     rust_size: &(usize, usize),
-    rust_overhead: i32,
-    julia_nodes: &HashSet<(i32, i32)>,
-    rust_nodes: &HashSet<(i32, i32)>,
+    rust_overhead: i64,
+    julia_nodes: &HashSet<(i64, i64)>,
+    rust_nodes: &HashSet<(i64, i64)>,
 ) {
     println!(
         "Julia: {} vertices, {} edges",
@@ -534,6 +609,26 @@ fn test_square_unweighted_petersen() {
     compare_square_unweighted("petersen");
 }
 
+#[test]
+fn test_square_weighted_bull() {
+    compare_square_weighted("bull");
+}
+
+#[test]
+fn test_square_weighted_diamond() {
+    compare_square_weighted("diamond");
+}
+
+#[test]
+fn test_square_weighted_house() {
+    compare_square_weighted("house");
+}
+
+#[test]
+fn test_square_weighted_petersen() {
+    compare_square_weighted("petersen");
+}
+
 // ============================================================================
 // Connected Cell Tests - Verify connect() marks cells correctly
 // ============================================================================
@@ -549,7 +644,7 @@ fn compare_connected_cells(name: &str) {
     let num_vertices = julia.num_vertices;
 
     // Get Julia's Connected cell positions (convert 1-indexed to 0-indexed)
-    let julia_connected: HashSet<(i32, i32)> = julia
+    let julia_connected: HashSet<(i64, i64)> = julia
         .grid_nodes_copylines_only
         .iter()
         .filter(|n| n.state == "C")
@@ -558,8 +653,7 @@ fn compare_connected_cells(name: &str) {
 
     // Run Rust mapping with Julia's vertex order
     let vertex_order = get_vertex_order(&julia);
-    let rust_result = ksg::map_unweighted_with_order(num_vertices, &edges, &vertex_order);
-
+    let rust_result = ksg::map_unweighted_with_order(num_vertices, &edges, &vertex_order).unwrap();
     // Re-create the grid with connections to check Connected cell positions
     let mut grid = crate::rules::unitdiskmapping::MappingGrid::with_padding(
         rust_result.grid_dimensions.0,
@@ -572,7 +666,7 @@ fn compare_connected_cells(name: &str) {
     for line in &rust_result.lines {
         for (row, col, weight) in line.copyline_locations(rust_result.padding, rust_result.spacing)
         {
-            grid.add_node(row, col, weight as i32);
+            grid.add_node(row, col, weight as i64);
         }
     }
 
@@ -597,13 +691,13 @@ fn compare_connected_cells(name: &str) {
     }
 
     // Collect Rust's Connected cell positions
-    let rust_connected: HashSet<(i32, i32)> = {
+    let rust_connected: HashSet<(i64, i64)> = {
         let (rows, cols) = grid.size();
         let mut connected = HashSet::new();
         for r in 0..rows {
             for c in 0..cols {
                 if let Some(CellState::Connected { .. }) = grid.get(r, c) {
-                    connected.insert((r as i32, c as i32));
+                    connected.insert((r as i64, c as i64));
                 }
             }
         }
diff --git a/src/unit_tests/unitdiskmapping_algorithms/map_graph.rs b/src/unit_tests/unitdiskmapping_algorithms/map_graph.rs
index 7cf980ead..97751872d 100644
--- a/src/unit_tests/unitdiskmapping_algorithms/map_graph.rs
+++ b/src/unit_tests/unitdiskmapping_algorithms/map_graph.rs
@@ -11,21 +11,19 @@ use crate::topology::smallgraph;
 #[test]
 fn test_map_path_graph() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     assert!(!result.positions.is_empty());
     assert!(result.mis_overhead >= 0);
 
     let config = vec![0; result.positions.len()];
-    let original = result.map_config_back(&config);
+    let original = result.map_config_back(&config).unwrap();
     assert_eq!(original.len(), 3);
 }
 
 #[test]
 fn test_map_triangle_graph() {
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     assert!(result.positions.len() >= 3);
     assert!(result.mis_overhead >= 0);
     assert_eq!(result.lines.len(), 3);
@@ -34,8 +32,7 @@ fn test_map_triangle_graph() {
 #[test]
 fn test_map_star_graph() {
     let edges = vec![(0, 1), (0, 2), (0, 3)];
-    let result = ksg::map_unweighted(4, &edges);
-
+    let result = ksg::map_unweighted(4, &edges).unwrap();
     assert!(result.positions.len() > 4);
     assert_eq!(result.lines.len(), 4);
 }
@@ -43,8 +40,7 @@ fn test_map_star_graph() {
 #[test]
 fn test_map_empty_graph() {
     let edges: Vec<(usize, usize)> = vec![];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     assert!(!result.positions.is_empty());
     assert_eq!(result.lines.len(), 3);
 }
@@ -52,8 +48,7 @@ fn test_map_empty_graph() {
 #[test]
 fn test_map_single_edge() {
     let edges = vec![(0, 1)];
-    let result = ksg::map_unweighted(2, &edges);
-
+    let result = ksg::map_unweighted(2, &edges).unwrap();
     assert_eq!(result.lines.len(), 2);
     assert!(!result.positions.is_empty());
 }
@@ -61,8 +56,7 @@ fn test_map_single_edge() {
 #[test]
 fn test_map_single_vertex() {
     let edges: Vec<(usize, usize)> = vec![];
-    let result = ksg::map_unweighted(1, &edges);
-
+    let result = ksg::map_unweighted(1, &edges).unwrap();
     assert_eq!(result.lines.len(), 1);
     assert!(!result.positions.is_empty());
 }
@@ -70,8 +64,7 @@ fn test_map_single_vertex() {
 #[test]
 fn test_map_complete_k4() {
     let edges = vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)];
-    let result = ksg::map_unweighted(4, &edges);
-
+    let result = ksg::map_unweighted(4, &edges).unwrap();
     assert!(result.positions.len() > 4);
     assert_eq!(result.lines.len(), 4);
 }
@@ -80,8 +73,7 @@ fn test_map_complete_k4() {
 fn test_map_graph_with_custom_order() {
     let edges = vec![(0, 1), (1, 2)];
     let order = vec![2, 1, 0];
-    let result = ksg::map_unweighted_with_order(3, &edges, &order);
-
+    let result = ksg::map_unweighted_with_order(3, &edges, &order).unwrap();
     assert!(!result.positions.is_empty());
     assert_eq!(result.lines.len(), 3);
 }
@@ -89,16 +81,14 @@ fn test_map_graph_with_custom_order() {
 #[test]
 fn test_square_grid_type() {
     let edges = vec![(0, 1)];
-    let result = ksg::map_unweighted(2, &edges);
-
+    let result = ksg::map_unweighted(2, &edges).unwrap();
     assert!(matches!(result.kind, GridKind::Kings));
 }
 
 #[test]
 fn test_mapping_preserves_vertex_count() {
     let edges = vec![(0, 1), (1, 2), (2, 3), (3, 4)];
-    let result = ksg::map_unweighted(5, &edges);
-
+    let result = ksg::map_unweighted(5, &edges).unwrap();
     assert_eq!(result.lines.len(), 5);
 
     let vertices: Vec<usize> = result.lines.iter().map(|l| l.vertex).collect();
@@ -116,8 +106,7 @@ fn test_mapping_preserves_vertex_count() {
 #[test]
 fn test_mapping_result_serialization() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     let json = serde_json::to_string(&result).unwrap();
     let deserialized: MappingResult = serde_json::from_str(&json).unwrap();
 
@@ -128,11 +117,9 @@ fn test_mapping_result_serialization() {
 #[test]
 fn test_mapping_result_config_back_all_zeros() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     let config = vec![0; result.positions.len()];
-    let original = result.map_config_back(&config);
-
+    let original = result.map_config_back(&config).unwrap();
     assert_eq!(original.len(), 3);
     assert!(original.iter().all(|&x| x == 0));
 }
@@ -142,11 +129,9 @@ fn test_mapping_result_config_back_all_zeros() {
 #[test]
 fn test_mapping_result_config_back_returns_correct_length() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     let config = vec![0; result.positions.len()];
-    let original = result.map_config_back(&config);
-
+    let original = result.map_config_back(&config).unwrap();
     assert_eq!(original.len(), 3);
     assert!(original.iter().all(|&x| x == 0));
 }
@@ -154,8 +139,7 @@ fn test_mapping_result_config_back_returns_correct_length() {
 #[test]
 fn test_mapping_result_fields_populated() {
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     assert!(!result.lines.is_empty());
     assert!(!result.positions.is_empty());
     assert!(result.spacing > 0);
@@ -168,8 +152,7 @@ fn test_mapping_result_fields_populated() {
 fn test_disconnected_graph() {
     // Two disconnected edges
     let edges = vec![(0, 1), (2, 3)];
-    let result = ksg::map_unweighted(4, &edges);
-
+    let result = ksg::map_unweighted(4, &edges).unwrap();
     assert_eq!(result.lines.len(), 4);
     assert!(!result.positions.is_empty());
 }
@@ -177,8 +160,7 @@ fn test_disconnected_graph() {
 #[test]
 fn test_linear_chain() {
     let edges = vec![(0, 1), (1, 2), (2, 3), (3, 4)];
-    let result = ksg::map_unweighted(5, &edges);
-
+    let result = ksg::map_unweighted(5, &edges).unwrap();
     assert_eq!(result.lines.len(), 5);
 }
 
@@ -186,8 +168,7 @@ fn test_linear_chain() {
 fn test_cycle_graph() {
     // C5: pentagon
     let edges = vec![(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)];
-    let result = ksg::map_unweighted(5, &edges);
-
+    let result = ksg::map_unweighted(5, &edges).unwrap();
     assert_eq!(result.lines.len(), 5);
 }
 
@@ -195,8 +176,7 @@ fn test_cycle_graph() {
 fn test_bipartite_graph() {
     // K2,3
     let edges = vec![(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4)];
-    let result = ksg::map_unweighted(5, &edges);
-
+    let result = ksg::map_unweighted(5, &edges).unwrap();
     assert_eq!(result.lines.len(), 5);
 }
 
@@ -208,8 +188,7 @@ fn test_map_standard_graphs_square() {
 
     for name in graph_names {
         let (n, edges) = smallgraph(name).unwrap();
-        let result = ksg::map_unweighted(n, &edges);
-
+        let result = ksg::map_unweighted(n, &edges).unwrap();
         assert_eq!(
             result.lines.len(),
             n,
@@ -230,13 +209,11 @@ fn test_map_standard_graphs_square() {
 #[test]
 fn test_map_config_back_returns_valid_is() {
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     let grid_edges = result.edges();
     let grid_config = solve_mis_config(result.positions.len(), &grid_edges);
 
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &original_config),
         "Mapped back config should be a valid IS"
@@ -247,21 +224,17 @@ fn test_map_config_back_returns_valid_is() {
 fn test_mis_overhead_path_graph() {
     let edges = vec![(0, 1), (1, 2)];
     let n = 3;
-    let result = ksg::map_unweighted(n, &edges);
-
-    let original_mis = solve_mis(n, &edges) as i32;
+    let result = ksg::map_unweighted(n, &edges).unwrap();
+    let original_mis = solve_mis(n, &edges) as i64;
     let grid_edges = result.edges();
-    let mapped_mis = solve_mis(result.positions.len(), &grid_edges) as i32;
+    let mapped_mis = solve_mis(result.positions.len(), &grid_edges) as i64;
 
     let expected = original_mis + result.mis_overhead;
 
-    assert!(
-        (mapped_mis - expected).abs() <= 1,
+    assert_eq!(
+        mapped_mis, expected,
         "Path graph: mapped MIS {} should equal original {} + overhead {} = {}",
-        mapped_mis,
-        original_mis,
-        result.mis_overhead,
-        expected
+        mapped_mis, original_mis, result.mis_overhead, expected
     );
 }
 
@@ -269,32 +242,27 @@ fn test_mis_overhead_path_graph() {
 fn test_mis_overhead_triangle() {
     let edges = vec![(0, 1), (1, 2), (0, 2)];
     let n = 3;
-    let result = ksg::map_unweighted(n, &edges);
-
-    let original_mis = solve_mis(n, &edges) as i32;
+    let result = ksg::map_unweighted(n, &edges).unwrap();
+    let original_mis = solve_mis(n, &edges) as i64;
     let grid_edges = result.edges();
-    let mapped_mis = solve_mis(result.positions.len(), &grid_edges) as i32;
+    let mapped_mis = solve_mis(result.positions.len(), &grid_edges) as i64;
 
     let expected = original_mis + result.mis_overhead;
 
-    assert!(
-        (mapped_mis - expected).abs() <= 1,
+    assert_eq!(
+        mapped_mis, expected,
         "Triangle: mapped MIS {} should equal original {} + overhead {} = {}",
-        mapped_mis,
-        original_mis,
-        result.mis_overhead,
-        expected
+        mapped_mis, original_mis, result.mis_overhead, expected
     );
 }
 
 #[test]
 fn test_mis_overhead_cubical() {
     let (n, edges) = smallgraph("cubical").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
-    let original_mis = solve_mis(n, &edges) as i32;
+    let result = ksg::map_unweighted(n, &edges).unwrap();
+    let original_mis = solve_mis(n, &edges) as i64;
     let grid_edges = result.edges();
-    let mapped_mis = solve_mis(result.positions.len(), &grid_edges) as i32;
+    let mapped_mis = solve_mis(result.positions.len(), &grid_edges) as i64;
 
     let expected = original_mis + result.mis_overhead;
 
@@ -309,11 +277,10 @@ fn test_mis_overhead_cubical() {
 #[ignore] // tutte maps to 1232-vertex grid; ILP solving takes ~10s
 fn test_mis_overhead_tutte() {
     let (n, edges) = smallgraph("tutte").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
-    let original_mis = solve_mis(n, &edges) as i32;
+    let result = ksg::map_unweighted(n, &edges).unwrap();
+    let original_mis = solve_mis(n, &edges) as i64;
     let grid_edges = result.edges();
-    let mapped_mis = solve_mis(result.positions.len(), &grid_edges) as i32;
+    let mapped_mis = solve_mis(result.positions.len(), &grid_edges) as i64;
 
     let expected = original_mis + result.mis_overhead;
 
@@ -358,15 +325,13 @@ fn test_map_config_back_standard_graphs() {
 
     for name in graph_names {
         let (n, edges) = smallgraph(name).unwrap();
-        let result = ksg::map_unweighted(n, &edges);
-
+        let result = ksg::map_unweighted(n, &edges).unwrap();
         // Solve MIS on mapped graph
         let grid_edges = result.edges();
         let grid_config = solve_mis_config(result.positions.len(), &grid_edges);
 
         // Extract original config using gadget traceback
-        let original_config = result.map_config_back(&grid_config);
-
+        let original_config = result.map_config_back(&grid_config).unwrap();
         // Verify it's a valid independent set
         assert!(
             is_independent_set(&edges, &original_config),
@@ -385,61 +350,6 @@ fn test_map_config_back_standard_graphs() {
     }
 }
 
-// === map_config_back_via_centers Tests ===
-
-#[test]
-fn test_map_config_back_via_centers_all_zeros() {
-    let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
-    let config = vec![0; result.positions.len()];
-    let original = result.map_config_back_via_centers(&config);
-
-    assert_eq!(original.len(), 3);
-    // All zeros should map back to all zeros
-    assert!(original.iter().all(|&x| x == 0));
-}
-
-#[test]
-fn test_map_config_back_via_centers_triangle() {
-    let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
-    let config = vec![0; result.positions.len()];
-    let original = result.map_config_back_via_centers(&config);
-
-    assert_eq!(original.len(), 3);
-}
-
-#[test]
-fn test_map_config_back_via_centers_star() {
-    let edges = vec![(0, 1), (0, 2), (0, 3)];
-    let result = ksg::map_unweighted(4, &edges);
-
-    // Set all grid nodes to selected
-    let config = vec![1; result.positions.len()];
-    let original = result.map_config_back_via_centers(&config);
-
-    assert_eq!(original.len(), 4);
-}
-
-#[test]
-fn test_map_config_back_consistency() {
-    // Both methods should give reasonable results for the same input
-    let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
-    let config = vec![0; result.positions.len()];
-
-    let via_regions = result.map_config_back(&config);
-    let via_centers = result.map_config_back_via_centers(&config);
-
-    assert_eq!(via_regions.len(), via_centers.len());
-    // Both should return all zeros for zero input
-    assert!(via_regions.iter().all(|&x| x == 0));
-    assert!(via_centers.iter().all(|&x| x == 0));
-}
-
 // === Additional Edge Cases ===
 
 #[test]
@@ -448,8 +358,7 @@ fn test_large_graph_mapping() {
     let edges: Vec<(usize, usize)> = (0..9)
         .flat_map(|i| [(i, (i + 1) % 10), (i, (i + 3) % 10)])
         .collect();
-    let result = ksg::map_unweighted(10, &edges);
-
+    let result = ksg::map_unweighted(10, &edges).unwrap();
     assert_eq!(result.lines.len(), 10);
     assert!(result.positions.len() > 10);
 }
@@ -458,8 +367,7 @@ fn test_large_graph_mapping() {
 fn test_mapping_result_tape_populated() {
     // Triangle graph should generate crossings
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     // Tape may or may not have entries depending on crossings
     // Just verify it's accessible
     let _tape_len = result.tape.len();
@@ -468,8 +376,7 @@ fn test_mapping_result_tape_populated() {
 #[test]
 fn test_grid_graph_edges() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     let grid_edges = result.edges();
     // Grid graph should have edges based on unit disk distance
     // Just verify edges are accessible
@@ -479,8 +386,7 @@ fn test_grid_graph_edges() {
 #[test]
 fn test_grid_graph_nodes_have_weights() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     for &weight in &result.node_weights {
         // All nodes should have positive weights
         assert!(weight > 0, "Node weight should be positive");
@@ -514,7 +420,7 @@ fn test_tape_entry_mis_overhead_crossing_patterns() {
             row: 0,
             col: 0,
         };
-        let overhead = tape_entry_mis_overhead(&entry);
+        let overhead = tape_entry_mis_overhead(&entry).unwrap();
         // All crossing gadgets should have overhead in range [-2, 1]
         assert!(
             (-2..=1).contains(&overhead),
@@ -534,7 +440,7 @@ fn test_tape_entry_mis_overhead_simplifier_patterns() {
             row: 0,
             col: 0,
         };
-        let overhead = tape_entry_mis_overhead(&entry);
+        let overhead = tape_entry_mis_overhead(&entry).unwrap();
         assert_eq!(
             overhead, -1,
             "DanglingLeg pattern {} should have overhead -1",
@@ -550,6 +456,5 @@ fn test_tape_entry_mis_overhead_unknown_pattern() {
         row: 0,
         col: 0,
     };
-    let overhead = tape_entry_mis_overhead(&entry);
-    assert_eq!(overhead, 0, "Unknown pattern should have overhead 0");
+    assert!(tape_entry_mis_overhead(&entry).is_err());
 }
diff --git a/src/unit_tests/unitdiskmapping_algorithms/mapping_result.rs b/src/unit_tests/unitdiskmapping_algorithms/mapping_result.rs
index d7ccea211..037db5bbe 100644
--- a/src/unit_tests/unitdiskmapping_algorithms/mapping_result.rs
+++ b/src/unit_tests/unitdiskmapping_algorithms/mapping_result.rs
@@ -8,8 +8,7 @@ use crate::topology::smallgraph;
 #[test]
 fn test_mapping_result_grid_size() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     let (rows, cols) = result.grid_dimensions;
     assert!(rows > 0, "Grid should have positive rows");
     assert!(cols > 0, "Grid should have positive cols");
@@ -18,16 +17,14 @@ fn test_mapping_result_grid_size() {
 #[test]
 fn test_mapping_result_num_original_vertices() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_unweighted(3, &edges);
-
+    let result = ksg::map_unweighted(3, &edges).unwrap();
     assert_eq!(result.num_original_vertices(), 3);
 }
 
 #[test]
 fn test_mapping_result_format_config() {
     let edges = vec![(0, 1)];
-    let result = ksg::map_unweighted(2, &edges);
-
+    let result = ksg::map_unweighted(2, &edges).unwrap();
     let (rows, cols) = result.grid_dimensions;
     let config: Vec<Vec<usize>> = vec![vec![0; cols]; rows];
 
@@ -45,8 +42,7 @@ fn test_mapping_result_format_config() {
 #[test]
 fn test_mapping_result_format_config_with_selected() {
     let edges = vec![(0, 1)];
-    let result = ksg::map_unweighted(2, &edges);
-
+    let result = ksg::map_unweighted(2, &edges).unwrap();
     let (rows, cols) = result.grid_dimensions;
     let mut config: Vec<Vec<usize>> = vec![vec![0; cols]; rows];
 
@@ -66,8 +62,7 @@ fn test_mapping_result_format_config_with_selected() {
 #[test]
 fn test_mapping_result_format_config_flat() {
     let edges = vec![(0, 1)];
-    let result = ksg::map_unweighted(2, &edges);
-
+    let result = ksg::map_unweighted(2, &edges).unwrap();
     let num_nodes = result.positions.len();
     let config: Vec<usize> = vec![0; num_nodes];
 
@@ -81,8 +76,7 @@ fn test_mapping_result_format_config_flat() {
 #[test]
 fn test_mapping_result_display() {
     let edges = vec![(0, 1)];
-    let result = ksg::map_unweighted(2, &edges);
-
+    let result = ksg::map_unweighted(2, &edges).unwrap();
     let display = format!("{}", result);
     assert!(!display.is_empty(), "Display should not be empty");
 }
@@ -92,8 +86,7 @@ fn test_mapping_result_display() {
 #[test]
 fn test_weighted_mapping_result_grid_size() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_weighted(3, &edges);
-
+    let result = ksg::map_weighted(3, &edges).unwrap();
     let (rows, cols) = result.grid_dimensions;
     assert!(rows > 0, "Grid should have positive rows");
     assert!(cols > 0, "Grid should have positive cols");
@@ -102,16 +95,14 @@ fn test_weighted_mapping_result_grid_size() {
 #[test]
 fn test_weighted_mapping_result_num_original_vertices() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = ksg::map_weighted(3, &edges);
-
+    let result = ksg::map_weighted(3, &edges).unwrap();
     assert_eq!(result.num_original_vertices(), 3);
 }
 
 #[test]
 fn test_weighted_mapping_result_format_config() {
     let edges = vec![(0, 1)];
-    let result = ksg::map_weighted(2, &edges);
-
+    let result = ksg::map_weighted(2, &edges).unwrap();
     let (rows, cols) = result.grid_dimensions;
     let config: Vec<Vec<usize>> = vec![vec![0; cols]; rows];
 
@@ -126,47 +117,75 @@ fn test_weighted_mapping_result_format_config() {
 
 #[test]
 fn test_unapply_gadgets_empty_tape() {
-    use crate::rules::unitdiskmapping::ksg::unapply_gadgets;
+    use crate::rules::unitdiskmapping::ksg::mapping::unapply_gadgets;
 
     let tape = vec![];
     let mut config: Vec<Vec<usize>> = vec![vec![0; 5]; 5];
 
-    unapply_gadgets(&tape, &mut config);
+    unapply_gadgets(&tape, &mut config).unwrap();
     // Should not crash with empty tape
 }
 
 #[test]
 fn test_unapply_weighted_gadgets_empty_tape() {
-    use crate::rules::unitdiskmapping::ksg::unapply_weighted_gadgets;
+    use crate::rules::unitdiskmapping::ksg::mapping::unapply_weighted_gadgets;
 
     let tape = vec![];
     let mut config: Vec<Vec<usize>> = vec![vec![0; 5]; 5];
 
-    unapply_weighted_gadgets(&tape, &mut config);
+    unapply_weighted_gadgets(&tape, &mut config).unwrap();
     // Should not crash with empty tape
 }
 
+#[test]
+fn test_unapply_gadgets_rejects_unknown_tape_entry() {
+    use crate::rules::unitdiskmapping::ksg::mapping::unapply_gadgets;
+    use crate::rules::unitdiskmapping::ksg::KsgTapeEntry;
+
+    let tape = vec![KsgTapeEntry {
+        pattern_idx: 999,
+        row: 0,
+        col: 0,
+    }];
+    let mut config = vec![vec![0; 5]; 5];
+
+    assert!(unapply_gadgets(&tape, &mut config).is_err());
+}
+
+#[test]
+fn test_unapply_weighted_gadgets_rejects_unknown_tape_entry() {
+    use crate::rules::unitdiskmapping::ksg::mapping::unapply_weighted_gadgets;
+    use crate::rules::unitdiskmapping::ksg::WeightedKsgTapeEntry;
+
+    let tape = vec![WeightedKsgTapeEntry {
+        pattern_idx: 999,
+        row: 0,
+        col: 0,
+    }];
+    let mut config = vec![vec![0; 5]; 5];
+
+    assert!(unapply_weighted_gadgets(&tape, &mut config).is_err());
+}
+
 #[test]
 fn test_map_config_back_unweighted() {
     let (n, edges) = smallgraph("diamond").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     let num_nodes = result.positions.len();
     let config: Vec<usize> = vec![0; num_nodes];
 
-    let original_config = result.map_config_back(&config);
+    let original_config = result.map_config_back(&config).unwrap();
     assert_eq!(original_config.len(), n);
 }
 
 #[test]
 fn test_map_config_back_weighted() {
     let (n, edges) = smallgraph("diamond").unwrap();
-    let result = ksg::map_weighted(n, &edges);
-
+    let result = ksg::map_weighted(n, &edges).unwrap();
     let num_nodes = result.positions.len();
     let config: Vec<usize> = vec![0; num_nodes];
 
-    let original_config = result.map_config_back(&config);
+    let original_config = result.map_config_back(&config).unwrap();
     assert_eq!(original_config.len(), n);
 }
 
@@ -180,16 +199,14 @@ fn test_full_pipeline_diamond_unweighted() {
     use super::common::{is_independent_set, solve_mis_config};
 
     let (n, edges) = smallgraph("diamond").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     // Solve MIS on the grid graph
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
     let grid_config = solve_mis_config(num_grid, &grid_edges);
 
     // Map config back to original graph
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     // Verify result is a valid independent set
     assert!(
         is_independent_set(&edges, &original_config),
@@ -202,14 +219,12 @@ fn test_full_pipeline_bull_unweighted() {
     use super::common::{is_independent_set, solve_mis_config};
 
     let (n, edges) = smallgraph("bull").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
     let grid_config = solve_mis_config(num_grid, &grid_edges);
 
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &original_config),
         "Bull: mapped back config should be a valid independent set"
@@ -221,14 +236,12 @@ fn test_full_pipeline_house_unweighted() {
     use super::common::{is_independent_set, solve_mis_config};
 
     let (n, edges) = smallgraph("house").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
     let grid_config = solve_mis_config(num_grid, &grid_edges);
 
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &original_config),
         "House: mapped back config should be a valid independent set"
@@ -240,14 +253,12 @@ fn test_full_pipeline_petersen_unweighted() {
     use super::common::{is_independent_set, solve_mis_config};
 
     let (n, edges) = smallgraph("petersen").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
     let grid_config = solve_mis_config(num_grid, &grid_edges);
 
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &original_config),
         "Petersen: mapped back config should be a valid independent set"
@@ -259,19 +270,17 @@ fn test_full_pipeline_weighted_diamond() {
     use super::common::{is_independent_set, solve_weighted_mis_config};
 
     let (n, edges) = smallgraph("diamond").unwrap();
-    let result = ksg::map_weighted(n, &edges);
-
+    let result = ksg::map_weighted(n, &edges).unwrap();
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
 
     // Get weights from the mapping result
-    let weights: Vec<i32> = (0..num_grid)
+    let weights: Vec<i64> = (0..num_grid)
         .map(|i| result.node_weights.get(i).copied().unwrap_or(1))
         .collect();
 
     let grid_config = solve_weighted_mis_config(num_grid, &grid_edges, &weights);
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &original_config),
         "Weighted diamond: mapped back config should be a valid independent set"
@@ -283,18 +292,16 @@ fn test_full_pipeline_weighted_bull() {
     use super::common::{is_independent_set, solve_weighted_mis_config};
 
     let (n, edges) = smallgraph("bull").unwrap();
-    let result = ksg::map_weighted(n, &edges);
-
+    let result = ksg::map_weighted(n, &edges).unwrap();
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
 
-    let weights: Vec<i32> = (0..num_grid)
+    let weights: Vec<i64> = (0..num_grid)
         .map(|i| result.node_weights.get(i).copied().unwrap_or(1))
         .collect();
 
     let grid_config = solve_weighted_mis_config(num_grid, &grid_edges, &weights);
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &original_config),
         "Weighted bull: mapped back config should be a valid independent set"
@@ -308,8 +315,7 @@ fn test_mis_size_preserved_diamond() {
     use super::common::solve_mis;
 
     let (n, edges) = smallgraph("diamond").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     // Get original MIS size
     let original_mis = solve_mis(n, &edges);
 
@@ -318,9 +324,9 @@ fn test_mis_size_preserved_diamond() {
     let grid_mis = solve_mis(result.positions.len(), &grid_edges);
 
     // Verify the formula: grid_mis = original_mis + overhead
-    let expected_grid_mis = original_mis as i32 + result.mis_overhead;
+    let expected_grid_mis = original_mis as i64 + result.mis_overhead;
     assert_eq!(
-        grid_mis as i32, expected_grid_mis,
+        grid_mis as i64, expected_grid_mis,
         "Grid MIS {} should equal original {} + overhead {} = {}",
         grid_mis, original_mis, result.mis_overhead, expected_grid_mis
     );
@@ -331,14 +337,13 @@ fn test_mis_size_preserved_bull() {
     use super::common::solve_mis;
 
     let (n, edges) = smallgraph("bull").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     let original_mis = solve_mis(n, &edges);
     let grid_edges = result.edges();
     let grid_mis = solve_mis(result.positions.len(), &grid_edges);
 
-    let expected_grid_mis = original_mis as i32 + result.mis_overhead;
-    assert_eq!(grid_mis as i32, expected_grid_mis);
+    let expected_grid_mis = original_mis as i64 + result.mis_overhead;
+    assert_eq!(grid_mis as i64, expected_grid_mis);
 }
 
 #[test]
@@ -346,14 +351,13 @@ fn test_mis_size_preserved_house() {
     use super::common::solve_mis;
 
     let (n, edges) = smallgraph("house").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     let original_mis = solve_mis(n, &edges);
     let grid_edges = result.edges();
     let grid_mis = solve_mis(result.positions.len(), &grid_edges);
 
-    let expected_grid_mis = original_mis as i32 + result.mis_overhead;
-    assert_eq!(grid_mis as i32, expected_grid_mis);
+    let expected_grid_mis = original_mis as i64 + result.mis_overhead;
+    assert_eq!(grid_mis as i64, expected_grid_mis);
 }
 
 // === Triangular Full Pipeline Tests ===
@@ -364,18 +368,16 @@ fn test_full_pipeline_triangular_diamond() {
     use crate::rules::unitdiskmapping::triangular;
 
     let (n, edges) = smallgraph("diamond").unwrap();
-    let result = triangular::map_weighted(n, &edges);
-
+    let result = triangular::map_weighted(n, &edges).unwrap();
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
 
-    let weights: Vec<i32> = (0..num_grid)
+    let weights: Vec<i64> = (0..num_grid)
         .map(|i| result.node_weights.get(i).copied().unwrap_or(1))
         .collect();
 
     let grid_config = solve_weighted_mis_config(num_grid, &grid_edges, &weights);
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &original_config),
         "Triangular diamond: mapped back config should be a valid independent set"
@@ -388,18 +390,16 @@ fn test_full_pipeline_triangular_bull() {
     use crate::rules::unitdiskmapping::triangular;
 
     let (n, edges) = smallgraph("bull").unwrap();
-    let result = triangular::map_weighted(n, &edges);
-
+    let result = triangular::map_weighted(n, &edges).unwrap();
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
 
-    let weights: Vec<i32> = (0..num_grid)
+    let weights: Vec<i64> = (0..num_grid)
         .map(|i| result.node_weights.get(i).copied().unwrap_or(1))
         .collect();
 
     let grid_config = solve_weighted_mis_config(num_grid, &grid_edges, &weights);
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &original_config),
         "Triangular bull: mapped back config should be a valid independent set"
@@ -412,18 +412,16 @@ fn test_full_pipeline_triangular_house() {
     use crate::rules::unitdiskmapping::triangular;
 
     let (n, edges) = smallgraph("house").unwrap();
-    let result = triangular::map_weighted(n, &edges);
-
+    let result = triangular::map_weighted(n, &edges).unwrap();
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
 
-    let weights: Vec<i32> = (0..num_grid)
+    let weights: Vec<i64> = (0..num_grid)
         .map(|i| result.node_weights.get(i).copied().unwrap_or(1))
         .collect();
 
     let grid_config = solve_weighted_mis_config(num_grid, &grid_edges, &weights);
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &original_config),
         "Triangular house: mapped back config should be a valid independent set"
@@ -502,16 +500,14 @@ fn test_extracted_mis_equals_original() {
     use super::common::{solve_mis, solve_mis_config};
 
     let (n, edges) = smallgraph("diamond").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     // Solve MIS on grid
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
     let grid_config = solve_mis_config(num_grid, &grid_edges);
 
     // Map back
-    let original_config = result.map_config_back(&grid_config);
-
+    let original_config = result.map_config_back(&grid_config).unwrap();
     // Count selected vertices
     let extracted_count = original_config.iter().filter(|&&x| x > 0).count();
     let original_mis = solve_mis(n, &edges);
@@ -528,13 +524,12 @@ fn test_extracted_mis_equals_original_bull() {
     use super::common::{solve_mis, solve_mis_config};
 
     let (n, edges) = smallgraph("bull").unwrap();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
     let grid_config = solve_mis_config(num_grid, &grid_edges);
 
-    let original_config = result.map_config_back(&grid_config);
+    let original_config = result.map_config_back(&grid_config).unwrap();
     let extracted_count = original_config.iter().filter(|&&x| x > 0).count();
     let original_mis = solve_mis(n, &edges);
 
@@ -546,8 +541,7 @@ fn test_extracted_mis_equals_original_bull() {
 #[test]
 fn test_grid_graph_format_display() {
     let edges = vec![(0, 1)];
-    let result = ksg::map_unweighted(2, &edges);
-
+    let result = ksg::map_unweighted(2, &edges).unwrap();
     let formatted = format!("{}", result);
     assert!(!formatted.is_empty());
 }
@@ -555,8 +549,7 @@ fn test_grid_graph_format_display() {
 #[test]
 fn test_grid_graph_format_with_some_config() {
     let edges = vec![(0, 1)];
-    let result = ksg::map_unweighted(2, &edges);
-
+    let result = ksg::map_unweighted(2, &edges).unwrap();
     let num_nodes = result.positions.len();
     let config: Vec<usize> = vec![1; num_nodes];
 
@@ -572,12 +565,11 @@ fn test_all_standard_graphs_unapply() {
 
     for name in graph_names {
         let (n, edges) = smallgraph(name).unwrap();
-        let result = ksg::map_unweighted(n, &edges);
-
+        let result = ksg::map_unweighted(n, &edges).unwrap();
         let num_nodes = result.positions.len();
         let config: Vec<usize> = vec![0; num_nodes];
 
-        let original = result.map_config_back(&config);
+        let original = result.map_config_back(&config).unwrap();
         assert_eq!(
             original.len(),
             n,
@@ -593,12 +585,11 @@ fn test_all_standard_graphs_weighted_unapply() {
 
     for name in graph_names {
         let (n, edges) = smallgraph(name).unwrap();
-        let result = ksg::map_weighted(n, &edges);
-
+        let result = ksg::map_weighted(n, &edges).unwrap();
         let num_nodes = result.positions.len();
         let config: Vec<usize> = vec![0; num_nodes];
 
-        let original = result.map_config_back(&config);
+        let original = result.map_config_back(&config).unwrap();
         assert_eq!(
             original.len(),
             n,
@@ -645,8 +636,7 @@ fn test_interface_k23_unweighted() {
     use super::common::{is_independent_set, solve_mis_config};
 
     let (n, edges) = k23_graph();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     // Check MIS size preservation: mis_overhead + original_mis = mapped_mis
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
@@ -664,7 +654,7 @@ fn test_interface_k23_unweighted() {
     );
 
     // Check map_config_back produces valid IS
-    let mapped_back = result.map_config_back(&grid_config);
+    let mapped_back = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &mapped_back),
         "K23: mapped back config should be independent set"
@@ -681,8 +671,7 @@ fn test_interface_empty_graph_unweighted() {
     use super::common::{is_independent_set, solve_mis_config};
 
     let (n, edges) = empty_graph();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     // For empty graph, all vertices can be selected
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
@@ -699,7 +688,7 @@ fn test_interface_empty_graph_unweighted() {
     );
 
     // Check map_config_back
-    let mapped_back = result.map_config_back(&grid_config);
+    let mapped_back = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &mapped_back),
         "Empty graph: mapped back config should be independent set"
@@ -716,8 +705,7 @@ fn test_interface_path_graph_unweighted() {
     use super::common::{is_independent_set, solve_mis_config};
 
     let (n, edges) = path_graph();
-    let result = ksg::map_unweighted(n, &edges);
-
+    let result = ksg::map_unweighted(n, &edges).unwrap();
     // Check MIS size preservation
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
@@ -736,7 +724,7 @@ fn test_interface_path_graph_unweighted() {
     );
 
     // Check map_config_back
-    let mapped_back = result.map_config_back(&grid_config);
+    let mapped_back = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &mapped_back),
         "Path graph: mapped back config should be independent set"
@@ -748,15 +736,14 @@ fn test_interface_k23_weighted() {
     use super::common::{is_independent_set, solve_mis_config};
 
     let (n, edges) = k23_graph();
-    let result = ksg::map_weighted(n, &edges);
-
+    let result = ksg::map_weighted(n, &edges).unwrap();
     // Check MIS size preservation
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
     let grid_config = solve_mis_config(num_grid, &grid_edges);
 
     // Check map_config_back produces valid IS
-    let mapped_back = result.map_config_back(&grid_config);
+    let mapped_back = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &mapped_back),
         "K23 weighted: mapped back config should be independent set"
@@ -768,14 +755,13 @@ fn test_interface_empty_graph_weighted() {
     use super::common::is_independent_set;
 
     let (n, edges) = empty_graph();
-    let result = ksg::map_weighted(n, &edges);
-
+    let result = ksg::map_weighted(n, &edges).unwrap();
     // For empty graph with weighted mapping
     let num_grid = result.positions.len();
     // All zeros config is always valid
     let grid_config: Vec<usize> = vec![0; num_grid];
 
-    let mapped_back = result.map_config_back(&grid_config);
+    let mapped_back = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &mapped_back),
         "Empty graph weighted: mapped back config should be independent set"
@@ -787,14 +773,13 @@ fn test_interface_path_graph_weighted() {
     use super::common::{is_independent_set, solve_mis_config};
 
     let (n, edges) = path_graph();
-    let result = ksg::map_weighted(n, &edges);
-
+    let result = ksg::map_weighted(n, &edges).unwrap();
     // Check map_config_back
     let grid_edges = result.edges();
     let num_grid = result.positions.len();
     let grid_config = solve_mis_config(num_grid, &grid_edges);
 
-    let mapped_back = result.map_config_back(&grid_config);
+    let mapped_back = result.map_config_back(&grid_config).unwrap();
     assert!(
         is_independent_set(&edges, &mapped_back),
         "Path graph weighted: mapped back config should be independent set"
diff --git a/src/unit_tests/unitdiskmapping_algorithms/mod.rs b/src/unit_tests/unitdiskmapping_algorithms/mod.rs
index 6ced4e603..f742168c9 100644
--- a/src/unit_tests/unitdiskmapping_algorithms/mod.rs
+++ b/src/unit_tests/unitdiskmapping_algorithms/mod.rs
@@ -8,7 +8,8 @@
 //! - weighted.rs - tests for weighted mode
 //! - mapping_result.rs - tests for MappingResult utility methods
 
-mod common;
+mod alpha_tensor;
+pub(crate) mod common;
 mod copyline;
 mod gadgets;
 mod gadgets_ground_truth;
@@ -17,3 +18,4 @@ mod map_graph;
 mod mapping_result;
 mod triangular;
 mod weighted;
+mod weighted_gadget;
diff --git a/src/unit_tests/unitdiskmapping_algorithms/triangular.rs b/src/unit_tests/unitdiskmapping_algorithms/triangular.rs
index 3a8d4fea4..9fa9b7499 100644
--- a/src/unit_tests/unitdiskmapping_algorithms/triangular.rs
+++ b/src/unit_tests/unitdiskmapping_algorithms/triangular.rs
@@ -3,15 +3,13 @@
 use super::common::solve_weighted_grid_mis;
 use crate::rules::unitdiskmapping::{trace_centers, triangular, MappingResult};
 use crate::topology::smallgraph;
-use std::collections::HashMap;
 
 // === Basic Triangular Mapping Tests ===
 
 #[test]
 fn test_triangular_path_graph() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
+    let result = triangular::map_weighted(3, &edges).unwrap();
     assert!(!result.positions.is_empty());
     assert!(result.mis_overhead >= 0);
     assert_eq!(result.lines.len(), 3);
@@ -20,8 +18,7 @@ fn test_triangular_path_graph() {
 #[test]
 fn test_triangular_complete_k4() {
     let edges = vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)];
-    let result = triangular::map_weighted(4, &edges);
-
+    let result = triangular::map_weighted(4, &edges).unwrap();
     assert!(result.positions.len() > 4);
     assert_eq!(result.lines.len(), 4);
 }
@@ -29,8 +26,7 @@ fn test_triangular_complete_k4() {
 #[test]
 fn test_triangular_single_vertex() {
     let edges: Vec<(usize, usize)> = vec![];
-    let result = triangular::map_weighted(1, &edges);
-
+    let result = triangular::map_weighted(1, &edges).unwrap();
     assert_eq!(result.lines.len(), 1);
     assert!(!result.positions.is_empty());
 }
@@ -38,8 +34,7 @@ fn test_triangular_single_vertex() {
 #[test]
 fn test_triangular_empty_graph() {
     let edges: Vec<(usize, usize)> = vec![];
-    let result = triangular::map_weighted(3, &edges);
-
+    let result = triangular::map_weighted(3, &edges).unwrap();
     assert!(!result.positions.is_empty());
     assert_eq!(result.lines.len(), 3);
 }
@@ -48,8 +43,7 @@ fn test_triangular_empty_graph() {
 fn test_triangular_with_custom_order() {
     let edges = vec![(0, 1), (1, 2)];
     let order = vec![2, 1, 0];
-    let result = triangular::map_weighted_with_order(3, &edges, &order);
-
+    let result = triangular::map_weighted_with_order(3, &edges, &order).unwrap();
     assert!(!result.positions.is_empty());
     assert_eq!(result.lines.len(), 3);
 }
@@ -57,24 +51,24 @@ fn test_triangular_with_custom_order() {
 #[test]
 fn test_triangular_star_graph() {
     let edges = vec![(0, 1), (0, 2), (0, 3)];
-    let result = triangular::map_weighted(4, &edges);
-
+    let result = triangular::map_weighted(4, &edges).unwrap();
     assert!(result.positions.len() > 4);
     assert_eq!(result.lines.len(), 4);
 }
 
 #[test]
-#[should_panic]
-fn test_triangular_zero_vertices_panics() {
+fn test_triangular_zero_vertices_returns_error() {
     let edges: Vec<(usize, usize)> = vec![];
-    let _ = triangular::map_weighted(0, &edges);
+    assert!(matches!(
+        triangular::map_weighted(0, &edges),
+        Err(crate::rules::ReductionError::InvalidTarget { .. })
+    ));
 }
 
 #[test]
 fn test_triangular_offset_setting() {
     let edges = vec![(0, 1)];
-    let result = triangular::map_weighted(2, &edges);
-
+    let result = triangular::map_weighted(2, &edges).unwrap();
     // Triangular mode uses spacing=6, padding=2
     assert_eq!(result.spacing, 6);
     assert_eq!(result.padding, 2);
@@ -83,8 +77,7 @@ fn test_triangular_offset_setting() {
 #[test]
 fn test_triangular_mapping_result_serialization() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
+    let result = triangular::map_weighted(3, &edges).unwrap();
     let json = serde_json::to_string(&result).unwrap();
     let deserialized: MappingResult = serde_json::from_str(&json).unwrap();
 
@@ -100,8 +93,7 @@ fn test_map_standard_graphs_triangular() {
 
     for name in graph_names {
         let (n, edges) = smallgraph(name).unwrap();
-        let result = triangular::map_weighted(n, &edges);
-
+        let result = triangular::map_weighted(n, &edges).unwrap();
         assert_eq!(
             result.lines.len(),
             n,
@@ -153,8 +145,7 @@ fn verify_mapping_matches_julia(name: &str) -> bool {
 
     // Use Julia's vertex order to ensure consistent mapping
     let vertex_order = get_julia_vertex_order(name).unwrap_or_else(|| (0..n).collect());
-    let result = triangular::map_weighted_with_order(n, &edges, &vertex_order);
-
+    let result = triangular::map_weighted_with_order(n, &edges, &vertex_order).unwrap();
     // Load Julia's trace data
     let julia_path = format!(
         "{}/tests/data/{}_triangular_trace.json",
@@ -183,7 +174,7 @@ fn verify_mapping_matches_julia(name: &str) -> bool {
     }
 
     // Compare overhead
-    let julia_overhead = julia_data["mis_overhead"].as_i64().unwrap() as i32;
+    let julia_overhead = julia_data["mis_overhead"].as_i64().unwrap() as i64;
     if result.mis_overhead != julia_overhead {
         eprintln!(
             "{}: overhead mismatch - Rust={}, Julia={}",
@@ -205,11 +196,11 @@ fn verify_mapping_matches_julia(name: &str) -> bool {
     }
 
     // Compute and compare weighted MIS
-    let mapped_mis = solve_weighted_grid_mis(&result) as i32;
+    let mapped_mis = solve_weighted_grid_mis(&result) as i64;
     let julia_mis = julia_data["mapped_mis_size"]
         .as_f64()
         .or_else(|| julia_data["mapped_mis_size"].as_i64().map(|v| v as f64))
-        .unwrap_or(0.0) as i32;
+        .unwrap_or(0.0) as i64;
 
     // For triangular weighted mode: mapped_mis == overhead
     if mapped_mis != julia_mis {
@@ -235,17 +226,15 @@ fn verify_mapping_matches_julia(name: &str) -> bool {
 fn test_triangular_mis_overhead_path_graph() {
     let edges = vec![(0, 1), (1, 2)];
     let n = 3;
-    let result = triangular::map_weighted(n, &edges);
-
-    let mapped_mis = solve_weighted_grid_mis(&result) as i32;
+    let result = triangular::map_weighted(n, &edges).unwrap();
+    let mapped_mis = solve_weighted_grid_mis(&result) as i64;
 
     // For triangular weighted mode: mapped_weighted_mis == overhead
     // (The overhead represents the entire weighted MIS of the grid graph)
-    assert!(
-        (mapped_mis - result.mis_overhead).abs() <= 1,
+    assert_eq!(
+        mapped_mis, result.mis_overhead,
         "Triangular path: mapped {} should equal overhead {}",
-        mapped_mis,
-        result.mis_overhead
+        mapped_mis, result.mis_overhead
     );
 }
 
@@ -300,18 +289,16 @@ fn test_triangular_mapping_tutte() {
 #[test]
 fn test_trace_centers_single_vertex() {
     let edges: Vec<(usize, usize)> = vec![];
-    let result = triangular::map_weighted(1, &edges);
-
-    let centers = trace_centers(&result);
+    let result = triangular::map_weighted(1, &edges).unwrap();
+    let centers = trace_centers(&result).unwrap();
     assert_eq!(centers.len(), 1);
 }
 
 #[test]
 fn test_trace_centers_path_graph() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
-    let centers = trace_centers(&result);
+    let result = triangular::map_weighted(3, &edges).unwrap();
+    let centers = trace_centers(&result).unwrap();
     assert_eq!(centers.len(), 3);
 
     // Each center should be at a valid grid position
@@ -324,9 +311,8 @@ fn test_trace_centers_path_graph() {
 #[test]
 fn test_trace_centers_triangle() {
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
-    let centers = trace_centers(&result);
+    let result = triangular::map_weighted(3, &edges).unwrap();
+    let centers = trace_centers(&result).unwrap();
     assert_eq!(centers.len(), 3);
 }
 
@@ -372,18 +358,17 @@ fn test_triangular_map_config_back_standard_graphs() {
 
         // Use Julia's vertex order if available
         let vertex_order = get_julia_vertex_order(name).unwrap_or_else(|| (0..n).collect());
-        let result = triangular::map_weighted_with_order(n, &edges, &vertex_order);
-
+        let result = triangular::map_weighted_with_order(n, &edges, &vertex_order).unwrap();
         // Follow Julia's approach: source weights of 0.2 for each vertex
         let source_weights: Vec<f64> = vec![0.2; n];
 
         // map_weights adds source weights at center locations (like Julia)
-        let mapped_weights = map_weights(&result, &source_weights);
+        let mapped_weights = map_weights(&result, &source_weights).unwrap();
 
         // Multiply by 10 and round to get integer weights (like Julia)
-        let weights: Vec<i32> = mapped_weights
+        let weights: Vec<i64> = mapped_weights
             .iter()
-            .map(|&w| (w * 10.0).round() as i32)
+            .map(|&w| (w * 10.0).round() as i64)
             .collect();
 
         let grid_edges = result.edges();
@@ -392,28 +377,7 @@ fn test_triangular_map_config_back_standard_graphs() {
         // Solve weighted MIS on grid
         let grid_config = solve_weighted_mis_config(num_grid, &grid_edges, &weights);
 
-        // Use triangular-specific trace_centers (not the KSG version)
-        // Build position to node index map
-        let mut pos_to_idx: HashMap<(usize, usize), usize> = HashMap::new();
-        for (idx, &(row, col)) in result.positions.iter().enumerate() {
-            if let (Ok(row), Ok(col)) = (usize::try_from(row), usize::try_from(col)) {
-                pos_to_idx.insert((row, col), idx);
-            }
-        }
-
-        // Get traced center locations using triangular-specific trace_centers
-        let centers = trace_centers(&result);
-
-        // Extract config at centers
-        let center_config: Vec<usize> = centers
-            .iter()
-            .map(|&(row, col)| {
-                pos_to_idx
-                    .get(&(row, col))
-                    .and_then(|&idx| grid_config.get(idx).copied())
-                    .unwrap_or(0)
-            })
-            .collect();
+        let center_config = triangular::map_config_back(&result, &grid_config).unwrap();
 
         // Verify it's a valid independent set
         assert!(
diff --git a/src/unit_tests/unitdiskmapping_algorithms/weighted.rs b/src/unit_tests/unitdiskmapping_algorithms/weighted.rs
index 62ec282d4..45c9a617a 100644
--- a/src/unit_tests/unitdiskmapping_algorithms/weighted.rs
+++ b/src/unit_tests/unitdiskmapping_algorithms/weighted.rs
@@ -8,18 +8,16 @@ use crate::rules::unitdiskmapping::{
 #[test]
 fn test_trace_centers_returns_correct_count() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
-    let centers = trace_centers(&result);
+    let result = triangular::map_weighted(3, &edges).unwrap();
+    let centers = trace_centers(&result).unwrap();
     assert_eq!(centers.len(), 3);
 }
 
 #[test]
 fn test_trace_centers_positive_coordinates() {
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
-    let centers = trace_centers(&result);
+    let result = triangular::map_weighted(3, &edges).unwrap();
+    let centers = trace_centers(&result).unwrap();
     for (i, &(row, col)) in centers.iter().enumerate() {
         assert!(row > 0, "Vertex {} center row should be positive", i);
         assert!(col > 0, "Vertex {} center col should be positive", i);
@@ -29,9 +27,8 @@ fn test_trace_centers_positive_coordinates() {
 #[test]
 fn test_trace_centers_single_vertex() {
     let edges: Vec<(usize, usize)> = vec![];
-    let result = triangular::map_weighted(1, &edges);
-
-    let centers = trace_centers(&result);
+    let result = triangular::map_weighted(1, &edges).unwrap();
+    let centers = trace_centers(&result).unwrap();
     assert_eq!(centers.len(), 1);
 }
 
@@ -40,11 +37,10 @@ fn test_trace_centers_single_vertex() {
 #[test]
 fn test_map_weights_uniform() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
+    let result = triangular::map_weighted(3, &edges).unwrap();
     // Use uniform weights (all 0.5)
     let weights = vec![0.5, 0.5, 0.5];
-    let mapped = map_weights(&result, &weights);
+    let mapped = map_weights(&result, &weights).unwrap();
 
     // Mapped weights should be non-negative
     assert!(
@@ -59,10 +55,9 @@ fn test_map_weights_uniform() {
 #[test]
 fn test_map_weights_zero() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
+    let result = triangular::map_weighted(3, &edges).unwrap();
     let weights = vec![0.0, 0.0, 0.0];
-    let mapped = map_weights(&result, &weights);
+    let mapped = map_weights(&result, &weights).unwrap();
 
     // With zero weights, the mapped weights should be positive
     // (because of the overhead structure)
@@ -72,10 +67,9 @@ fn test_map_weights_zero() {
 #[test]
 fn test_map_weights_one() {
     let edges = vec![(0, 1), (1, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
+    let result = triangular::map_weighted(3, &edges).unwrap();
     let weights = vec![1.0, 1.0, 1.0];
-    let mapped = map_weights(&result, &weights);
+    let mapped = map_weights(&result, &weights).unwrap();
 
     // All weights should be positive
     assert!(mapped.iter().all(|&w| w > 0.0));
@@ -98,33 +92,27 @@ fn test_map_weights_one() {
 }
 
 #[test]
-#[should_panic]
 fn test_map_weights_invalid_negative() {
     let edges = vec![(0, 1)];
-    let result = triangular::map_weighted(2, &edges);
-
+    let result = triangular::map_weighted(2, &edges).unwrap();
     let weights = vec![-0.5, 0.5];
-    let _ = map_weights(&result, &weights);
+    assert!(map_weights(&result, &weights).is_err());
 }
 
 #[test]
-#[should_panic]
 fn test_map_weights_invalid_over_one() {
     let edges = vec![(0, 1)];
-    let result = triangular::map_weighted(2, &edges);
-
+    let result = triangular::map_weighted(2, &edges).unwrap();
     let weights = vec![1.5, 0.5];
-    let _ = map_weights(&result, &weights);
+    assert!(map_weights(&result, &weights).is_err());
 }
 
 #[test]
-#[should_panic]
 fn test_map_weights_wrong_length() {
     let edges = vec![(0, 1)];
-    let result = triangular::map_weighted(2, &edges);
-
+    let result = triangular::map_weighted(2, &edges).unwrap();
     let weights = vec![0.5]; // Wrong length
-    let _ = map_weights(&result, &weights);
+    assert!(map_weights(&result, &weights).is_err());
 }
 
 // === Weighted Interface Tests ===
@@ -134,11 +122,10 @@ fn test_triangular_weighted_interface() {
     use crate::topology::smallgraph;
 
     let (n, edges) = smallgraph("bull").unwrap();
-    let result = triangular::map_weighted(n, &edges);
-
+    let result = triangular::map_weighted(n, &edges).unwrap();
     // Test with uniform weights
     let ws = vec![0.5; n];
-    let grid_weights = map_weights(&result, &ws);
+    let grid_weights = map_weights(&result, &ws).unwrap();
 
     // Should produce valid weights for all grid nodes
     assert_eq!(grid_weights.len(), result.positions.len());
@@ -150,22 +137,21 @@ fn test_triangular_interface_full() {
     use crate::topology::smallgraph;
 
     let (n, edges) = smallgraph("diamond").unwrap();
-    let result = triangular::map_weighted(n, &edges);
-
+    let result = triangular::map_weighted(n, &edges).unwrap();
     // Uniform weights in [0, 1]
     let ws = vec![0.3; n];
-    let grid_weights = map_weights(&result, &ws);
+    let grid_weights = map_weights(&result, &ws).unwrap();
 
     assert_eq!(grid_weights.len(), result.positions.len());
     assert!(grid_weights.iter().all(|&w| w >= 0.0));
 
     // Test map_config_back
     let config = vec![0; result.positions.len()];
-    let original_config = result.map_config_back(&config);
+    let original_config = result.map_config_back(&config).unwrap();
     assert_eq!(original_config.len(), n);
 
     // Verify trace_centers
-    let centers = trace_centers(&result);
+    let centers = trace_centers(&result).unwrap();
     assert_eq!(centers.len(), n);
 }
 
@@ -210,49 +196,6 @@ fn test_triangular_copyline_weight_invariant() {
     }
 }
 
-// === Weighted MIS Weight Sum Invariant Tests ===
-
-#[test]
-fn test_weighted_gadgets_weight_conservation() {
-    // For each weighted gadget, verify weight sums are consistent with MIS properties
-    let ruleset = triangular::weighted_ruleset();
-    for gadget in &ruleset {
-        let source_sum: i32 = gadget.source_weights().iter().sum();
-        let mapped_sum: i32 = gadget.mapped_weights().iter().sum();
-        let overhead = gadget.mis_overhead();
-
-        // Both sums should be positive (all gadgets have at least some nodes)
-        assert!(
-            source_sum > 0 && mapped_sum > 0,
-            "Both sums should be positive"
-        );
-
-        // MIS overhead can be negative for gadgets that reduce MIS
-        // The key invariant is: mapped_MIS = source_MIS + overhead
-        // So overhead = mapped_MIS - source_MIS (can be positive, zero, or negative)
-        assert!(
-            overhead.abs() <= source_sum.max(mapped_sum),
-            "Overhead magnitude {} should be bounded by max sum {}",
-            overhead.abs(),
-            source_sum.max(mapped_sum)
-        );
-    }
-}
-
-#[test]
-fn test_weighted_gadgets_positive_weights() {
-    // All individual weights should be positive
-    let ruleset = triangular::weighted_ruleset();
-    for gadget in &ruleset {
-        for &w in gadget.source_weights() {
-            assert!(w > 0, "Source weights should be positive, got {}", w);
-        }
-        for &w in gadget.mapped_weights() {
-            assert!(w > 0, "Mapped weights should be positive, got {}", w);
-        }
-    }
-}
-
 // === Solution Extraction Integration Tests ===
 
 #[test]
@@ -260,12 +203,10 @@ fn test_map_config_back_extracts_valid_is_triangular() {
     use crate::topology::smallgraph;
 
     let (n, edges) = smallgraph("bull").unwrap();
-    let result = triangular::map_weighted(n, &edges);
-
+    let result = triangular::map_weighted(n, &edges).unwrap();
     // Get all zeros config
     let config = vec![0; result.positions.len()];
-    let extracted = result.map_config_back(&config);
-
+    let extracted = triangular::map_config_back(&result, &config).unwrap();
     // All zeros should extract to all zeros
     assert_eq!(extracted.len(), n);
     assert!(extracted.iter().all(|&x| x == 0));
@@ -275,10 +216,9 @@ fn test_map_config_back_extracts_valid_is_triangular() {
 fn test_map_weights_preserves_total_weight() {
     // map_weights should add original weights to base weights
     let edges = vec![(0, 1), (1, 2), (0, 2)];
-    let result = triangular::map_weighted(3, &edges);
-
+    let result = triangular::map_weighted(3, &edges).unwrap();
     let original_weights = vec![0.5, 0.3, 0.7];
-    let mapped = map_weights(&result, &original_weights);
+    let mapped = map_weights(&result, &original_weights).unwrap();
 
     // Sum of mapped weights should be base_sum + original_sum
     let base_sum: f64 = result.node_weights.iter().map(|&w| w as f64).sum();
@@ -301,10 +241,9 @@ fn test_trace_centers_consistency_with_config_back() {
     use crate::topology::smallgraph;
 
     let (n, edges) = smallgraph("diamond").unwrap();
-    let result = triangular::map_weighted(n, &edges);
-
+    let result = triangular::map_weighted(n, &edges).unwrap();
     // Get centers
-    let centers = trace_centers(&result);
+    let centers = trace_centers(&result).unwrap();
     assert_eq!(centers.len(), n);
 
     // Each center should be within grid bounds
@@ -687,19 +626,18 @@ fn test_weighted_map_config_back_standard_graphs() {
 
     for name in graph_names {
         let (n, edges) = smallgraph(name).unwrap();
-        let result = triangular::map_weighted(n, &edges);
-
+        let result = triangular::map_weighted(n, &edges).unwrap();
         // Follow Julia's approach: source weights of 0.2 for each vertex
         let source_weights: Vec<f64> = vec![0.2; n];
 
         // map_weights adds source weights at center locations (like Julia)
-        let mapped_weights = map_weights(&result, &source_weights);
+        let mapped_weights = map_weights(&result, &source_weights).unwrap();
 
         // Solve weighted MIS with ILP
         let grid_edges = result.edges();
         let num_grid = result.positions.len();
 
-        let constraints: Vec<LinearConstraint> = grid_edges
+        let constraints: Vec<LinearConstraint<f64>> = grid_edges
             .iter()
             .map(|&(i, j)| LinearConstraint::le(vec![(i, 1.0), (j, 1.0)], 1.0))
             .collect();
@@ -710,12 +648,13 @@ fn test_weighted_map_config_back_standard_graphs() {
             .map(|(i, &w)| (i, w))
             .collect();
 
-        let ilp = ILP::<bool>::new(num_grid, constraints, objective, ObjectiveSense::Maximize);
+        let ilp = ILP::<bool, f64>::new(num_grid, constraints, objective, ObjectiveSense::Maximize)
+            .expect("weighted mapping test ILP must be valid");
         let solver = ILPSolver::new();
         let grid_config: Vec<usize> = solver
             .solve(&ilp)
             .map(|sol| sol.iter().map(|&x| if x > 0 { 1 } else { 0 }).collect())
-            .unwrap_or_else(|| vec![0; num_grid]);
+            .expect("weighted mapping test solver must return a solution");
 
         // Use triangular-specific trace_centers (not the KSG version)
         // Build position to node index map
@@ -728,7 +667,7 @@ fn test_weighted_map_config_back_standard_graphs() {
         }
 
         // Get traced center locations using triangular-specific trace_centers
-        let centers = trace_centers(&result);
+        let centers = trace_centers(&result).unwrap();
 
         // Extract config at centers
         let center_config: Vec<usize> = centers
@@ -737,7 +676,7 @@ fn test_weighted_map_config_back_standard_graphs() {
                 pos_to_idx
                     .get(&(row, col))
                     .and_then(|&idx| grid_config.get(idx).copied())
-                    .unwrap_or(0)
+                    .expect("every traced center must identify a mapped vertex")
             })
             .collect();
 
diff --git a/src/unit_tests/unitdiskmapping_algorithms/weighted_gadget.rs b/src/unit_tests/unitdiskmapping_algorithms/weighted_gadget.rs
new file mode 100644
index 000000000..b5472f5b6
--- /dev/null
+++ b/src/unit_tests/unitdiskmapping_algorithms/weighted_gadget.rs
@@ -0,0 +1,205 @@
+//! Boundary-optimum verification for weighted gadgets across grid topologies.
+
+use super::alpha_tensor::alpha_tensor;
+use super::common::{ksg_edges, triangular_edges};
+use crate::rules::unitdiskmapping::ksg::{
+    KsgReflectedGadget, KsgRotatedGadget, Mirror, WeightedKsgBranch, WeightedKsgBranchFix,
+    WeightedKsgBranchFixB, WeightedKsgCross, WeightedKsgDanglingLeg, WeightedKsgEndTurn,
+    WeightedKsgTCon, WeightedKsgTrivialTurn, WeightedKsgTurn, WeightedKsgWTurn,
+};
+use crate::rules::unitdiskmapping::triangular::{
+    WeightedTriBranch, WeightedTriBranchFix, WeightedTriBranchFixB, WeightedTriCross,
+    WeightedTriEndTurn, WeightedTriTConDown, WeightedTriTConLeft, WeightedTriTConUp,
+    WeightedTriTrivialTurnLeft, WeightedTriTrivialTurnRight, WeightedTriTurn, WeightedTriWTurn,
+    WeightedTriangularGadget,
+};
+use crate::rules::unitdiskmapping::Pattern;
+
+fn assert_weighted_boundary_equivalent(
+    source: (&[(usize, usize)], &mut [i64], &[usize]),
+    mapped: (&[(usize, usize)], &mut [i64], &[usize]),
+    mis_overhead: i64,
+    name: &str,
+) {
+    let (source_edges, source_weights, source_pins) = source;
+    let (mapped_edges, mapped_weights, mapped_pins) = mapped;
+    for &pin in source_pins {
+        source_weights[pin] = source_weights[pin]
+            .checked_sub(1)
+            .expect("source pin weight adjustment must fit in i64");
+    }
+    for &pin in mapped_pins {
+        mapped_weights[pin] = mapped_weights[pin]
+            .checked_sub(1)
+            .expect("mapped pin weight adjustment must fit in i64");
+    }
+
+    let source = alpha_tensor(
+        source_weights.len(),
+        source_edges,
+        source_weights,
+        source_pins,
+    );
+    let mapped = alpha_tensor(
+        mapped_weights.len(),
+        mapped_edges,
+        mapped_weights,
+        mapped_pins,
+    );
+    let source_max = source
+        .iter()
+        .copied()
+        .filter(|&value| value != i64::MIN)
+        .max()
+        .expect("source boundary tensor must contain a feasible pin configuration");
+    let mapped_max = mapped
+        .iter()
+        .copied()
+        .filter(|&value| value != i64::MIN)
+        .max()
+        .expect("mapped boundary tensor must contain a feasible pin configuration");
+
+    assert_eq!(
+        source
+            .iter()
+            .map(|&value| value == source_max)
+            .collect::<Vec<_>>(),
+        mapped
+            .iter()
+            .map(|&value| value == mapped_max)
+            .collect::<Vec<_>>(),
+        "{name}: maximizing pin configurations differ; source={source:?}, mapped={mapped:?}"
+    );
+    assert_eq!(
+        mapped_max
+            .checked_sub(source_max)
+            .expect("boundary-optimum difference must fit in i64"),
+        mis_overhead,
+        "{name}: weighted gadget MIS overhead differs"
+    );
+}
+
+fn assert_weighted_ksg_gadget_equivalent<G: Pattern>(gadget: G, name: &str) {
+    let (source_locations, source_edges, source_pins) = gadget.source_graph();
+    let (mapped_locations, mapped_pins) = gadget.mapped_graph();
+    let mut source_weights = gadget.source_weights();
+    let mut mapped_weights = gadget.mapped_weights();
+    assert_eq!(source_locations.len(), source_weights.len());
+    assert_eq!(mapped_locations.len(), mapped_weights.len());
+    assert_weighted_boundary_equivalent(
+        (&source_edges, &mut source_weights, &source_pins),
+        (
+            &ksg_edges(&mapped_locations),
+            &mut mapped_weights,
+            &mapped_pins,
+        ),
+        gadget.mis_overhead(),
+        name,
+    );
+}
+
+fn assert_weighted_triangular_gadget_equivalent<G: WeightedTriangularGadget>(
+    gadget: G,
+    name: &str,
+) {
+    let (source_locations, source_edges, source_pins) = gadget.source_graph();
+    let (mapped_locations, mapped_pins) = gadget.mapped_graph();
+    let mut source_weights = gadget.source_weights();
+    let mut mapped_weights = gadget.mapped_weights();
+    assert_eq!(source_locations.len(), source_weights.len());
+    assert_eq!(mapped_locations.len(), mapped_weights.len());
+
+    assert_weighted_boundary_equivalent(
+        (&source_edges, &mut source_weights, &source_pins),
+        (
+            &triangular_edges(&mapped_locations, 1.1),
+            &mut mapped_weights,
+            &mapped_pins,
+        ),
+        gadget.mis_overhead(),
+        name,
+    );
+}
+
+#[test]
+fn test_weighted_ksg_crossing_gadget_equivalence() {
+    assert_weighted_ksg_gadget_equivalent(WeightedKsgCross::<false>, "WeightedKsgCross<false>");
+    assert_weighted_ksg_gadget_equivalent(WeightedKsgTurn, "WeightedKsgTurn");
+    assert_weighted_ksg_gadget_equivalent(WeightedKsgWTurn, "WeightedKsgWTurn");
+    assert_weighted_ksg_gadget_equivalent(WeightedKsgBranch, "WeightedKsgBranch");
+    assert_weighted_ksg_gadget_equivalent(WeightedKsgBranchFix, "WeightedKsgBranchFix");
+    assert_weighted_ksg_gadget_equivalent(WeightedKsgTCon, "WeightedKsgTCon");
+    assert_weighted_ksg_gadget_equivalent(WeightedKsgTrivialTurn, "WeightedKsgTrivialTurn");
+    assert_weighted_ksg_gadget_equivalent(
+        KsgRotatedGadget::new(WeightedKsgTCon, 1),
+        "RotatedWeightedKsgTCon",
+    );
+    assert_weighted_ksg_gadget_equivalent(
+        KsgReflectedGadget::new(WeightedKsgCross::<true>, Mirror::Y),
+        "ReflectedWeightedKsgCross<true>",
+    );
+    assert_weighted_ksg_gadget_equivalent(
+        KsgReflectedGadget::new(WeightedKsgTrivialTurn, Mirror::Y),
+        "ReflectedWeightedKsgTrivialTurn",
+    );
+    assert_weighted_ksg_gadget_equivalent(WeightedKsgBranchFixB, "WeightedKsgBranchFixB");
+    assert_weighted_ksg_gadget_equivalent(WeightedKsgEndTurn, "WeightedKsgEndTurn");
+    assert_weighted_ksg_gadget_equivalent(
+        KsgReflectedGadget::new(KsgRotatedGadget::new(WeightedKsgTCon, 1), Mirror::Y),
+        "ReflectedRotatedWeightedKsgTCon",
+    );
+}
+
+#[test]
+fn test_weighted_ksg_simplifier_gadget_equivalence() {
+    assert_weighted_ksg_gadget_equivalent(WeightedKsgDanglingLeg, "WeightedKsgDanglingLeg");
+    assert_weighted_ksg_gadget_equivalent(
+        KsgRotatedGadget::new(WeightedKsgDanglingLeg, 1),
+        "WeightedKsgDanglingLegRot1",
+    );
+    assert_weighted_ksg_gadget_equivalent(
+        KsgRotatedGadget::new(WeightedKsgDanglingLeg, 2),
+        "WeightedKsgDanglingLegRot2",
+    );
+    assert_weighted_ksg_gadget_equivalent(
+        KsgRotatedGadget::new(WeightedKsgDanglingLeg, 3),
+        "WeightedKsgDanglingLegRot3",
+    );
+    assert_weighted_ksg_gadget_equivalent(
+        KsgReflectedGadget::new(WeightedKsgDanglingLeg, Mirror::X),
+        "WeightedKsgDanglingLegMirrorX",
+    );
+    assert_weighted_ksg_gadget_equivalent(
+        KsgReflectedGadget::new(WeightedKsgDanglingLeg, Mirror::Y),
+        "WeightedKsgDanglingLegMirrorY",
+    );
+}
+
+#[test]
+fn test_weighted_triangular_crossing_gadget_equivalence() {
+    assert_weighted_triangular_gadget_equivalent(
+        WeightedTriCross::<false>,
+        "WeightedTriCross<false>",
+    );
+    assert_weighted_triangular_gadget_equivalent(
+        WeightedTriCross::<true>,
+        "WeightedTriCross<true>",
+    );
+    assert_weighted_triangular_gadget_equivalent(WeightedTriTConLeft, "WeightedTriTConLeft");
+    assert_weighted_triangular_gadget_equivalent(WeightedTriTConUp, "WeightedTriTConUp");
+    assert_weighted_triangular_gadget_equivalent(WeightedTriTConDown, "WeightedTriTConDown");
+    assert_weighted_triangular_gadget_equivalent(
+        WeightedTriTrivialTurnLeft,
+        "WeightedTriTrivialTurnLeft",
+    );
+    assert_weighted_triangular_gadget_equivalent(
+        WeightedTriTrivialTurnRight,
+        "WeightedTriTrivialTurnRight",
+    );
+    assert_weighted_triangular_gadget_equivalent(WeightedTriEndTurn, "WeightedTriEndTurn");
+    assert_weighted_triangular_gadget_equivalent(WeightedTriTurn, "WeightedTriTurn");
+    assert_weighted_triangular_gadget_equivalent(WeightedTriWTurn, "WeightedTriWTurn");
+    assert_weighted_triangular_gadget_equivalent(WeightedTriBranchFix, "WeightedTriBranchFix");
+    assert_weighted_triangular_gadget_equivalent(WeightedTriBranchFixB, "WeightedTriBranchFixB");
+    assert_weighted_triangular_gadget_equivalent(WeightedTriBranch, "WeightedTriBranch");
+}
diff --git a/src/unit_tests/variant.rs b/src/unit_tests/variant.rs
index 7289134e5..ed65d4770 100644
--- a/src/unit_tests/variant.rs
+++ b/src/unit_tests/variant.rs
@@ -1,4 +1,4 @@
-use crate::variant::{CastToParent, KValue, VariantParam};
+use crate::variant::{KValue, VariantParam};
 
 // Test types for the new system
 #[derive(Clone, Debug)]
@@ -7,26 +7,18 @@ struct TestRoot;
 struct TestChild;
 
 impl_variant_param!(TestRoot, "test_cat");
-impl_variant_param!(TestChild, "test_cat", parent: TestRoot, cast: |_| TestRoot);
+impl_variant_param!(TestChild, "test_cat");
 
 #[test]
 fn test_variant_param_root() {
     assert_eq!(TestRoot::CATEGORY, "test_cat");
     assert_eq!(TestRoot::VALUE, "TestRoot");
-    assert_eq!(TestRoot::PARENT_VALUE, None);
 }
 
 #[test]
 fn test_variant_param_child() {
     assert_eq!(TestChild::CATEGORY, "test_cat");
     assert_eq!(TestChild::VALUE, "TestChild");
-    assert_eq!(TestChild::PARENT_VALUE, Some("TestRoot"));
-}
-
-#[test]
-fn test_cast_to_parent() {
-    let child = TestChild;
-    let _parent: TestRoot = child.cast_to_parent();
 }
 
 #[derive(Clone, Debug)]
@@ -35,13 +27,12 @@ struct TestKRoot;
 struct TestKChild;
 
 impl_variant_param!(TestKRoot, "test_k", k: None);
-impl_variant_param!(TestKChild, "test_k", parent: TestKRoot, cast: |_| TestKRoot, k: Some(3));
+impl_variant_param!(TestKChild, "test_k", k: Some(3));
 
 #[test]
 fn test_kvalue_via_macro_root() {
     assert_eq!(TestKRoot::CATEGORY, "test_k");
     assert_eq!(TestKRoot::VALUE, "TestKRoot");
-    assert_eq!(TestKRoot::PARENT_VALUE, None);
     assert_eq!(TestKRoot::K, None);
 }
 
@@ -49,7 +40,6 @@ fn test_kvalue_via_macro_root() {
 fn test_kvalue_via_macro_child() {
     assert_eq!(TestKChild::CATEGORY, "test_k");
     assert_eq!(TestKChild::VALUE, "TestKChild");
-    assert_eq!(TestKChild::PARENT_VALUE, Some("TestKRoot"));
     assert_eq!(TestKChild::K, Some(3));
 }
 
@@ -92,31 +82,31 @@ fn test_variant_for_problems() {
     use crate::traits::Problem;
 
     // Test MaximumIndependentSet variants
-    let v = MaximumIndependentSet::<SimpleGraph, i32>::variant();
+    let v = MaximumIndependentSet::<SimpleGraph, i64>::variant();
     assert_eq!(v.len(), 2);
     assert_eq!(v[0].0, "graph");
     assert_eq!(v[0].1, "SimpleGraph");
     assert_eq!(v[1].0, "weight");
-    assert_eq!(v[1].1, "i32");
+    assert_eq!(v[1].1, "i64");
 
     // Test MinimumVertexCover
-    let v = MinimumVertexCover::<SimpleGraph, i32>::variant();
+    let v = MinimumVertexCover::<SimpleGraph, i64>::variant();
     assert_eq!(v.len(), 2);
     assert_eq!(v[0].1, "SimpleGraph");
-    assert_eq!(v[1].1, "i32");
+    assert_eq!(v[1].1, "i64");
 
     // Test MinimumDominatingSet
-    let v = MinimumDominatingSet::<SimpleGraph, i32>::variant();
+    let v = MinimumDominatingSet::<SimpleGraph, i64>::variant();
     assert_eq!(v.len(), 2);
     assert_eq!(v[0].1, "SimpleGraph");
 
     // Test MaximumMatching
-    let v = MaximumMatching::<SimpleGraph, i32>::variant();
+    let v = MaximumMatching::<SimpleGraph, i64>::variant();
     assert_eq!(v.len(), 2);
     assert_eq!(v[0].1, "SimpleGraph");
 
     // Test MaxCut
-    let v = MaxCut::<SimpleGraph, i32>::variant();
+    let v = MaxCut::<SimpleGraph, i64>::variant();
     assert_eq!(v.len(), 2);
     assert_eq!(v[0].1, "SimpleGraph");
 
@@ -127,12 +117,12 @@ fn test_variant_for_problems() {
     assert_eq!(v[1], ("graph", "SimpleGraph"));
 
     // Test MaximalIS
-    let v = MaximalIS::<SimpleGraph, i32>::variant();
+    let v = MaximalIS::<SimpleGraph, i64>::variant();
     assert_eq!(v.len(), 2);
     assert_eq!(v[0].1, "SimpleGraph");
 
     // Test MaximumClique
-    let v = MaximumClique::<SimpleGraph, i32>::variant();
+    let v = MaximumClique::<SimpleGraph, i64>::variant();
     assert_eq!(v.len(), 2);
     assert_eq!(v[0].1, "SimpleGraph");
 
@@ -146,22 +136,22 @@ fn test_variant_for_problems() {
     assert_eq!(v[0], ("k", "K3"));
 
     // Test MaximumSetPacking (weight parameter only)
-    let v = MaximumSetPacking::<i32>::variant();
+    let v = MaximumSetPacking::<i64>::variant();
     assert_eq!(v.len(), 1);
-    assert_eq!(v[0], ("weight", "i32"));
+    assert_eq!(v[0], ("weight", "i64"));
 
     // Test MinimumSetCovering (weight parameter only)
-    let v = MinimumSetCovering::<i32>::variant();
+    let v = MinimumSetCovering::<i64>::variant();
     assert_eq!(v.len(), 1);
-    assert_eq!(v[0], ("weight", "i32"));
+    assert_eq!(v[0], ("weight", "i64"));
 
     // Test SpinGlass (graph + weight parameters)
     let v = SpinGlass::<SimpleGraph, f64>::variant();
     assert_eq!(v.len(), 2);
     assert_eq!(v[1].1, "f64");
 
-    let v = SpinGlass::<SimpleGraph, i32>::variant();
-    assert_eq!(v[1].1, "i32");
+    let v = SpinGlass::<SimpleGraph, i64>::variant();
+    assert_eq!(v[1].1, "i64");
 
     // Test QUBO (weight parameter only)
     let v = QUBO::<f64>::variant();
@@ -197,7 +187,6 @@ use crate::variant::{K1, K2, K3, K4, K5, KN};
 fn test_kvalue_k1() {
     assert_eq!(K1::CATEGORY, "k");
     assert_eq!(K1::VALUE, "K1");
-    assert_eq!(K1::PARENT_VALUE, Some("KN"));
     assert_eq!(K1::K, Some(1));
 }
 
@@ -205,7 +194,6 @@ fn test_kvalue_k1() {
 fn test_kvalue_k2() {
     assert_eq!(K2::CATEGORY, "k");
     assert_eq!(K2::VALUE, "K2");
-    assert_eq!(K2::PARENT_VALUE, Some("KN"));
     assert_eq!(K2::K, Some(2));
 }
 
@@ -213,7 +201,6 @@ fn test_kvalue_k2() {
 fn test_kvalue_k3() {
     assert_eq!(K3::CATEGORY, "k");
     assert_eq!(K3::VALUE, "K3");
-    assert_eq!(K3::PARENT_VALUE, Some("KN"));
     assert_eq!(K3::K, Some(3));
 }
 
@@ -221,7 +208,6 @@ fn test_kvalue_k3() {
 fn test_kvalue_k4() {
     assert_eq!(K4::CATEGORY, "k");
     assert_eq!(K4::VALUE, "K4");
-    assert_eq!(K4::PARENT_VALUE, Some("KN"));
     assert_eq!(K4::K, Some(4));
 }
 
@@ -229,7 +215,6 @@ fn test_kvalue_k4() {
 fn test_kvalue_k5() {
     assert_eq!(K5::CATEGORY, "k");
     assert_eq!(K5::VALUE, "K5");
-    assert_eq!(K5::PARENT_VALUE, Some("KN"));
     assert_eq!(K5::K, Some(5));
 }
 
@@ -237,50 +222,35 @@ fn test_kvalue_k5() {
 fn test_kvalue_kn() {
     assert_eq!(KN::CATEGORY, "k");
     assert_eq!(KN::VALUE, "KN");
-    assert_eq!(KN::PARENT_VALUE, None);
     assert_eq!(KN::K, None);
 }
 
 // --- Graph type VariantParam tests ---
 
-use crate::topology::{BipartiteGraph, Graph, PlanarGraph, SimpleGraph, UnitDiskGraph};
+use crate::topology::{BipartiteGraph, PlanarGraph, SimpleGraph, UnitDiskGraph};
 
 #[test]
 fn test_simple_graph_variant_param() {
     assert_eq!(SimpleGraph::CATEGORY, "graph");
     assert_eq!(SimpleGraph::VALUE, "SimpleGraph");
-    assert_eq!(SimpleGraph::PARENT_VALUE, None);
 }
 
 #[test]
 fn test_planar_graph_variant_param() {
     assert_eq!(PlanarGraph::CATEGORY, "graph");
     assert_eq!(PlanarGraph::VALUE, "PlanarGraph");
-    assert_eq!(PlanarGraph::PARENT_VALUE, Some("SimpleGraph"));
 }
 
 #[test]
 fn test_bipartite_graph_variant_param() {
     assert_eq!(BipartiteGraph::CATEGORY, "graph");
     assert_eq!(BipartiteGraph::VALUE, "BipartiteGraph");
-    assert_eq!(BipartiteGraph::PARENT_VALUE, Some("SimpleGraph"));
 }
 
 #[test]
 fn test_unit_disk_graph_variant_param() {
     assert_eq!(UnitDiskGraph::CATEGORY, "graph");
     assert_eq!(UnitDiskGraph::VALUE, "UnitDiskGraph");
-    assert_eq!(UnitDiskGraph::PARENT_VALUE, Some("SimpleGraph"));
-}
-
-#[test]
-fn test_udg_cast_to_parent() {
-    let udg = UnitDiskGraph::new(vec![(0.0, 0.0), (0.5, 0.0), (2.0, 0.0)], 1.0);
-    let sg: SimpleGraph = udg.cast_to_parent();
-    assert_eq!(sg.num_vertices(), 3);
-    // Only the first two points are within distance 1.0
-    assert!(sg.has_edge(0, 1));
-    assert!(!sg.has_edge(0, 2));
 }
 
 // --- Weight type VariantParam tests ---
@@ -291,30 +261,18 @@ use crate::types::One;
 fn test_weight_f64_variant_param() {
     assert_eq!(<f64 as VariantParam>::CATEGORY, "weight");
     assert_eq!(<f64 as VariantParam>::VALUE, "f64");
-    assert_eq!(<f64 as VariantParam>::PARENT_VALUE, None);
 }
 
 #[test]
-fn test_weight_i32_variant_param() {
-    assert_eq!(<i32 as VariantParam>::CATEGORY, "weight");
-    assert_eq!(<i32 as VariantParam>::VALUE, "i32");
-    assert_eq!(<i32 as VariantParam>::PARENT_VALUE, Some("f64"));
+fn test_weight_i64_variant_param() {
+    assert_eq!(<i64 as VariantParam>::CATEGORY, "weight");
+    assert_eq!(<i64 as VariantParam>::VALUE, "i64");
 }
 
 #[test]
 fn test_weight_one_variant_param() {
     assert_eq!(One::CATEGORY, "weight");
     assert_eq!(One::VALUE, "One");
-    assert_eq!(One::PARENT_VALUE, Some("i32"));
-}
-
-#[test]
-fn test_weight_cast_chain() {
-    let one = One;
-    let i: i32 = one.cast_to_parent();
-    assert_eq!(i, 1);
-    let f: f64 = i.cast_to_parent();
-    assert_eq!(f, 1.0);
 }
 
 // --- VariantSpec tests ---
@@ -323,12 +281,12 @@ use crate::variant::VariantSpec;
 
 #[test]
 fn variant_spec_basic_construction() {
-    let spec = VariantSpec::try_from_pairs(vec![("graph", "SimpleGraph"), ("weight", "i32")])
+    let spec = VariantSpec::try_from_pairs(vec![("graph", "SimpleGraph"), ("weight", "i64")])
         .expect("valid pairs should succeed");
     let map = spec.as_map();
     assert_eq!(map.len(), 2);
     assert_eq!(map["graph"], "SimpleGraph");
-    assert_eq!(map["weight"], "i32");
+    assert_eq!(map["weight"], "i64");
 }
 
 #[test]
@@ -353,62 +311,17 @@ fn variant_spec_rejects_duplicate_dimensions() {
 #[test]
 fn variant_spec_preserves_btreemap_order() {
     // BTreeMap sorts by key, so insertion order doesn't matter
-    let spec = VariantSpec::try_from_pairs(vec![("weight", "i32"), ("graph", "SimpleGraph")])
+    let spec = VariantSpec::try_from_pairs(vec![("weight", "i64"), ("graph", "SimpleGraph")])
         .expect("valid pairs");
     let keys: Vec<&String> = spec.as_map().keys().collect();
     assert_eq!(keys, vec!["graph", "weight"], "BTreeMap should sort keys");
 }
 
-#[test]
-fn variant_spec_normalizes_empty_graph_to_simple_graph() {
-    // A variant with graph="" should normalize to graph="SimpleGraph"
-    let spec =
-        VariantSpec::try_from_pairs(vec![("graph", ""), ("weight", "i32")]).expect("valid pairs");
-    let normalized = spec.normalize();
-    assert_eq!(
-        normalized.as_map()["graph"],
-        "SimpleGraph",
-        "normalize() should fill in 'SimpleGraph' for empty graph dimension"
-    );
-}
-
-#[test]
-fn variant_spec_normalize_preserves_explicit_values() {
-    // A variant with explicit values should not be changed by normalize
-    let spec = VariantSpec::try_from_pairs(vec![("graph", "PlanarGraph"), ("weight", "f64")])
-        .expect("valid pairs");
-    let normalized = spec.normalize();
-    assert_eq!(normalized.as_map()["graph"], "PlanarGraph");
-    assert_eq!(normalized.as_map()["weight"], "f64");
-}
-
-#[test]
-fn variant_spec_is_default_for_default_values() {
-    // A variant with all default values (SimpleGraph, One) should be the default
-    let spec = VariantSpec::try_from_pairs(vec![("graph", "SimpleGraph"), ("weight", "One")])
-        .expect("valid pairs");
-    assert!(
-        spec.is_default(),
-        "variant with SimpleGraph+One should be the default"
-    );
-}
-
-#[test]
-fn variant_spec_is_not_default_for_non_default_values() {
-    // A variant with non-default values should NOT be the default
-    let spec = VariantSpec::try_from_pairs(vec![("graph", "PlanarGraph"), ("weight", "i32")])
-        .expect("valid pairs");
-    assert!(
-        !spec.is_default(),
-        "variant with PlanarGraph+i32 should not be the default"
-    );
-}
-
 #[test]
 fn variant_spec_try_from_map() {
     let map = std::collections::BTreeMap::from([
         ("graph".to_string(), "SimpleGraph".to_string()),
-        ("weight".to_string(), "i32".to_string()),
+        ("weight".to_string(), "i64".to_string()),
     ]);
     let spec = VariantSpec::try_from_map(map.clone()).expect("should succeed for valid map");
     assert_eq!(spec.as_map(), &map);
@@ -428,9 +341,9 @@ fn variant_spec_into_map_returns_owned() {
 fn variant_spec_update_dimension_adds_new() {
     let mut spec =
         VariantSpec::try_from_pairs(vec![("graph", "SimpleGraph")]).expect("valid pairs");
-    spec.update_dimension("weight", "i32");
+    spec.update_dimension("weight", "i64");
     assert_eq!(spec.as_map().len(), 2);
-    assert_eq!(spec.as_map()["weight"], "i32");
+    assert_eq!(spec.as_map()["weight"], "i64");
 }
 
 #[test]
@@ -440,41 +353,3 @@ fn variant_spec_update_dimension_overwrites_existing() {
     spec.update_dimension("weight", "f64");
     assert_eq!(spec.as_map()["weight"], "f64");
 }
-
-#[test]
-fn variant_spec_normalize_no_graph_dimension_unchanged() {
-    // A variant without a "graph" dimension should not be changed
-    let spec = VariantSpec::try_from_pairs(vec![("weight", "i32")]).expect("valid pairs");
-    let normalized = spec.normalize();
-    assert_eq!(normalized.as_map().len(), 1);
-    assert_eq!(normalized.as_map()["weight"], "i32");
-}
-
-#[test]
-fn variant_spec_is_default_empty_variant() {
-    let spec = VariantSpec::try_from_pairs(Vec::<(&str, &str)>::new())
-        .expect("empty pairs should succeed");
-    assert!(
-        spec.is_default(),
-        "empty variant should be considered default"
-    );
-}
-
-#[test]
-fn variant_spec_is_default_kn() {
-    let spec = VariantSpec::try_from_pairs(vec![("k", "KN")]).expect("valid pairs");
-    assert!(
-        spec.is_default(),
-        "variant with KN should be considered default"
-    );
-}
-
-#[test]
-fn variant_spec_is_not_default_mixed() {
-    let spec = VariantSpec::try_from_pairs(vec![("graph", "SimpleGraph"), ("weight", "i32")])
-        .expect("valid pairs");
-    assert!(
-        !spec.is_default(),
-        "variant with i32 weight should not be default"
-    );
-}
diff --git a/src/variant.rs b/src/variant.rs
index 4acf665cc..f318d5bc7 100644
--- a/src/variant.rs
+++ b/src/variant.rs
@@ -1,28 +1,17 @@
 //! Variant system for type-level problem parameterization.
 //!
-//! Types declare their variant category, value, and parent via `VariantParam`.
+//! Types declare their variant category and value via `VariantParam`.
 //! The `impl_variant_param!` macro registers types with the trait.
 //! The `variant_params!` macro composes `Problem::variant()` bodies from type parameter names.
 
 /// A type that participates in the variant system.
 ///
-/// Declares its category (e.g., `"graph"`), value (e.g., `"SimpleGraph"`),
-/// and optional parent in the subtype hierarchy.
+/// Declares its category (e.g., `"graph"`) and value (e.g., `"SimpleGraph"`).
 pub trait VariantParam: 'static {
     /// Category name (e.g., `"graph"`, `"weight"`, `"k"`).
     const CATEGORY: &'static str;
-    /// Type name within the category (e.g., `"SimpleGraph"`, `"i32"`).
+    /// Type name within the category (e.g., `"SimpleGraph"`, `"i64"`).
     const VALUE: &'static str;
-    /// Parent type name in the subtype hierarchy, or `None` for root types.
-    const PARENT_VALUE: Option<&'static str>;
-}
-
-/// Types that can convert themselves to their parent in the variant hierarchy.
-pub trait CastToParent: VariantParam {
-    /// The parent type.
-    type Parent: VariantParam;
-    /// Convert this value to its parent type.
-    fn cast_to_parent(&self) -> Self::Parent;
 }
 
 /// K-value marker trait for types that represent a const-generic K parameter.
@@ -35,63 +24,34 @@ pub trait KValue: VariantParam + Clone + 'static {
     const K: Option<usize>;
 }
 
-/// Implement `VariantParam` (and optionally `CastToParent` and/or `KValue`) for a type.
+/// Implement `VariantParam` and optionally `KValue` for a type.
 ///
 /// # Usage
 ///
 /// ```text
-/// // Root type (no parent):
+/// // Variant parameter:
 /// impl_variant_param!(SimpleGraph, "graph");
 ///
-/// // Type with parent -- cast closure required:
-/// impl_variant_param!(UnitDiskGraph, "graph", parent: SimpleGraph,
-///     cast: |g| SimpleGraph::new(g.num_vertices(), g.edges()));
-///
-/// // Root K type (no parent, with K value):
+/// // Generic K value:
 /// impl_variant_param!(KN, "k", k: None);
 ///
-/// // K type with parent + cast + K value:
-/// impl_variant_param!(K3, "k", parent: KN, cast: |_| KN, k: Some(3));
+/// // Concrete K value:
+/// impl_variant_param!(K3, "k", k: Some(3));
 /// ```
 #[macro_export]
 macro_rules! impl_variant_param {
-    // Root type (no parent, no cast)
     ($ty:ty, $cat:expr) => {
         impl $crate::variant::VariantParam for $ty {
             const CATEGORY: &'static str = $cat;
             const VALUE: &'static str = stringify!($ty);
-            const PARENT_VALUE: Option<&'static str> = None;
-        }
-    };
-    // Type with parent + cast closure
-    ($ty:ty, $cat:expr, parent: $parent:ty, cast: $cast:expr) => {
-        impl $crate::variant::VariantParam for $ty {
-            const CATEGORY: &'static str = $cat;
-            const VALUE: &'static str = stringify!($ty);
-            const PARENT_VALUE: Option<&'static str> = Some(stringify!($parent));
-        }
-        impl $crate::variant::CastToParent for $ty {
-            type Parent = $parent;
-            fn cast_to_parent(&self) -> $parent {
-                let f: fn(&$ty) -> $parent = $cast;
-                f(self)
-            }
         }
     };
-    // KValue root type (no parent, with k value)
     ($ty:ty, $cat:expr, k: $k:expr) => {
         $crate::impl_variant_param!($ty, $cat);
         impl $crate::variant::KValue for $ty {
             const K: Option<usize> = $k;
         }
     };
-    // KValue type with parent + cast + k value
-    ($ty:ty, $cat:expr, parent: $parent:ty, cast: $cast:expr, k: $k:expr) => {
-        $crate::impl_variant_param!($ty, $cat, parent: $parent, cast: $cast);
-        impl $crate::variant::KValue for $ty {
-            const K: Option<usize> = $k;
-        }
-    };
 }
 
 /// Compose a `Problem::variant()` body from type parameter names.
@@ -140,11 +100,11 @@ pub struct K5;
 pub struct KN;
 
 impl_variant_param!(KN, "k", k: None);
-impl_variant_param!(K5, "k", parent: KN, cast: |_| KN, k: Some(5));
-impl_variant_param!(K4, "k", parent: KN, cast: |_| KN, k: Some(4));
-impl_variant_param!(K3, "k", parent: KN, cast: |_| KN, k: Some(3));
-impl_variant_param!(K2, "k", parent: KN, cast: |_| KN, k: Some(2));
-impl_variant_param!(K1, "k", parent: KN, cast: |_| KN, k: Some(1));
+impl_variant_param!(K5, "k", k: Some(5));
+impl_variant_param!(K4, "k", k: Some(4));
+impl_variant_param!(K3, "k", k: Some(3));
+impl_variant_param!(K2, "k", k: Some(2));
+impl_variant_param!(K1, "k", k: Some(1));
 
 // --- VariantSpec: canonical runtime representation of a problem variant ---
 
@@ -152,22 +112,20 @@ use std::collections::BTreeMap;
 
 /// Canonical runtime representation of a problem variant.
 ///
-/// Used for validated runtime lookups and normalization. Unlike raw
-/// `BTreeMap<String, String>`, a `VariantSpec` validates its dimensions
-/// at construction time and can normalize default values.
+/// Unlike raw `BTreeMap<String, String>`, construction from pairs rejects
+/// duplicate dimensions.
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct VariantSpec {
     dims: BTreeMap<String, String>,
 }
 
-/// Default dimension values used for normalization and default detection.
-const DEFAULT_VALUES: &[&str] = &["SimpleGraph", "One", "KN"];
-
 impl VariantSpec {
     /// Create a `VariantSpec` from key-value pairs, rejecting duplicate dimensions.
     ///
     /// Returns an error if the same dimension key appears more than once.
-    pub fn try_from_pairs<I, K, V>(pairs: I) -> std::result::Result<Self, String>
+    pub fn try_from_pairs<I, K, V>(
+        pairs: I,
+    ) -> std::result::Result<Self, crate::registry::ConstructionError>
     where
         I: IntoIterator<Item = (K, V)>,
         K: Into<String>,
@@ -178,14 +136,16 @@ impl VariantSpec {
             let key = k.into();
             let val = v.into();
             if dims.insert(key.clone(), val).is_some() {
-                return Err(format!("duplicate dimension: {}", key));
+                return Err(format!("duplicate dimension: {}", key).into());
             }
         }
         Ok(Self { dims })
     }
 
     /// Create a `VariantSpec` from an existing `BTreeMap`.
-    pub fn try_from_map(map: BTreeMap<String, String>) -> std::result::Result<Self, String> {
+    pub fn try_from_map(
+        map: BTreeMap<String, String>,
+    ) -> std::result::Result<Self, crate::registry::ConstructionError> {
         Ok(Self { dims: map })
     }
 
@@ -203,32 +163,6 @@ impl VariantSpec {
     pub fn update_dimension(&mut self, key: impl Into<String>, value: impl Into<String>) {
         self.dims.insert(key.into(), value.into());
     }
-
-    /// Normalize the variant by filling in default values for empty dimensions.
-    ///
-    /// If a dimension has an empty string value, it is replaced with its
-    /// canonical default:
-    /// - `"graph"` → `"SimpleGraph"`
-    pub fn normalize(&self) -> Self {
-        let mut dims = self.dims.clone();
-        if let Some(v) = dims.get_mut("graph") {
-            if v.is_empty() {
-                *v = "SimpleGraph".to_string();
-            }
-        }
-        Self { dims }
-    }
-
-    /// Check whether this variant uses only default dimension values.
-    ///
-    /// Returns `true` if every dimension value is one of the recognized
-    /// defaults: `"SimpleGraph"`, `"One"`, `"KN"`. An empty variant
-    /// (no dimensions) is also considered default.
-    pub fn is_default(&self) -> bool {
-        self.dims
-            .values()
-            .all(|v| DEFAULT_VALUES.contains(&v.as_str()))
-    }
 }
 
 #[cfg(test)]
diff --git a/tests/data/qubo/ilp_to_qubo.json b/tests/data/qubo/ilp_to_qubo.json
index a74086007..b24a070af 100644
--- a/tests/data/qubo/ilp_to_qubo.json
+++ b/tests/data/qubo/ilp_to_qubo.json
@@ -1 +1 @@
-{"problem":"ILP","source":{"num_variables":3,"objective":[1.0,2.0,3.0],"constraints_lhs":[[1.0,1.0,0.0],[0.0,1.0,1.0]],"constraints_rhs":[1.0,1.0],"constraint_signs":[-1,-1],"penalty":10.0},"qubo_matrix":[[-11.0,10.0,0.0],[10.0,-22.0,10.0],[0.0,10.0,-13.0]],"qubo_num_vars":3,"qubo_optimal":{"value":-24.0,"configs":[[1,0,1]]}}
\ No newline at end of file
+{"problem":"ILP","source":{"num_variables":3,"objective":[1,2,3],"constraints_lhs":[[1,1,0],[0,1,1]],"constraints_rhs":[1,1],"constraint_signs":[-1,-1],"penalty":10.0},"qubo_matrix":[[-11.0,10.0,0.0],[10.0,-22.0,10.0],[0.0,10.0,-13.0]],"qubo_num_vars":3,"qubo_optimal":{"value":-24.0,"configs":[[1,0,1]]}}
diff --git a/tests/main.rs b/tests/main.rs
index 6f8e4c248..6abe686c5 100644
--- a/tests/main.rs
+++ b/tests/main.rs
@@ -8,9 +8,10 @@ mod integration;
 mod jl_parity;
 #[path = "suites/ksatisfiability_simultaneous_incongruences.rs"]
 mod ksatisfiability_simultaneous_incongruences;
+#[path = "suites/numeric_boundaries.rs"]
+mod numeric_boundaries;
 #[path = "suites/reductions.rs"]
 mod reductions;
-#[cfg(feature = "ilp-solver")]
 #[path = "suites/register_assignment_reductions.rs"]
 mod register_assignment_reductions;
 #[path = "suites/simultaneous_incongruences.rs"]
diff --git a/tests/suites/consecutive_ones_matrix_augmentation.rs b/tests/suites/consecutive_ones_matrix_augmentation.rs
index f14c861ee..276dc3662 100644
--- a/tests/suites/consecutive_ones_matrix_augmentation.rs
+++ b/tests/suites/consecutive_ones_matrix_augmentation.rs
@@ -13,5 +13,5 @@ fn test_consecutive_ones_matrix_augmentation_yes_instance() {
         2,
     );
 
-    assert!(problem.evaluate(&[0, 1, 4, 2, 3]));
+    assert!(problem.evaluate(&vec![0, 1, 4, 2, 3]).unwrap());
 }
diff --git a/tests/suites/examples.rs b/tests/suites/examples.rs
index dacff97ca..bf19f5139 100644
--- a/tests/suites/examples.rs
+++ b/tests/suites/examples.rs
@@ -1,90 +1,78 @@
-// Test remaining example binaries to keep them compiling and correct.
-// Examples with `pub fn run()` are included directly; others are run as subprocesses.
+// Test example behavior directly without spawning nested Cargo builds.
 
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 // --- Chained reduction demo (has pub fn run()) ---
 
-#[cfg(feature = "ilp-solver")]
 #[allow(unused)]
 mod chained_reduction_factoring_to_spinglass {
     include!("../../examples/chained_reduction_factoring_to_spinglass.rs");
 }
 
-#[cfg(feature = "ilp-solver")]
 #[test]
 fn test_chained_reduction_factoring_to_spinglass() {
-    chained_reduction_factoring_to_spinglass::run();
+    chained_reduction_factoring_to_spinglass::run().unwrap();
 }
 
-// --- Subprocess tests for export utilities ---
+#[allow(dead_code)]
+#[path = "../../examples/export_graph.rs"]
+mod export_graph;
 
-fn run_example(name: &str) {
-    let status = std::process::Command::new(env!("CARGO"))
-        .args(["run", "--example", name, "--features", "ilp-highs"])
-        .status()
-        .unwrap_or_else(|e| panic!("Failed to run example {name}: {e}"));
-    assert!(status.success(), "Example {name} failed with {status}");
-}
+#[allow(dead_code)]
+#[path = "../../examples/export_schemas.rs"]
+mod export_schemas;
+
+#[allow(dead_code)]
+#[path = "../../examples/export_petersen_mapping.rs"]
+mod export_petersen_mapping;
 
-fn temp_output_path(name: &str) -> PathBuf {
+fn temp_output_dir(name: &str) -> PathBuf {
     let timestamp = std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
         .expect("Clock must be after UNIX_EPOCH")
         .as_nanos();
     std::env::temp_dir().join(format!(
-        "problemreductions_{name}_{}_{}.json",
+        "problemreductions_{name}_{}_{}",
         std::process::id(),
         timestamp
     ))
 }
 
-fn run_example_with_output(name: &str, output_path: &Path) {
-    let output = output_path
-        .to_str()
-        .unwrap_or_else(|| panic!("Non-UTF-8 temp path for {name}: {output_path:?}"));
-    let status = std::process::Command::new(env!("CARGO"))
-        .args([
-            "run",
-            "--example",
-            name,
-            "--features",
-            "ilp-highs",
-            "--",
-            output,
-        ])
-        .status()
-        .unwrap_or_else(|e| panic!("Failed to run example {name}: {e}"));
-    assert!(status.success(), "Example {name} failed with {status}");
-    assert!(
-        output_path.is_file(),
-        "Example {name} did not create expected output file at {}",
-        output_path.display()
-    );
-}
-
 #[test]
 fn test_export_graph() {
-    let output_path = temp_output_path("export_graph");
-    run_example_with_output("export_graph", &output_path);
-    let _ = std::fs::remove_file(output_path);
+    let output_dir = temp_output_dir("export_graph");
+    let output_path = output_dir.join("reduction_graph.json");
+    export_graph::run(&output_path);
+    assert!(output_path.is_file());
+    std::fs::remove_dir_all(output_dir).unwrap();
 }
 
 #[test]
 fn test_export_schemas() {
-    let output_path = temp_output_path("export_schemas");
-    run_example_with_output("export_schemas", &output_path);
-    let _ = std::fs::remove_file(output_path);
+    let output_dir = temp_output_dir("export_schemas");
+    let output_path = output_dir.join("problem_schemas.json");
+    export_schemas::run(&output_path);
+    assert!(output_path.is_file());
+    std::fs::remove_dir_all(output_dir).unwrap();
 }
 
 #[test]
 fn test_export_petersen_mapping() {
-    run_example("export_petersen_mapping");
+    let output_dir = temp_output_dir("export_petersen_mapping");
+    export_petersen_mapping::run(&output_dir);
+    for filename in [
+        "petersen_source.json",
+        "petersen_square_weighted.json",
+        "petersen_square_unweighted.json",
+        "petersen_triangular.json",
+    ] {
+        assert!(output_dir.join(filename).is_file());
+    }
+    std::fs::remove_dir_all(output_dir).unwrap();
 }
 
 // Note: detect_isolated_problems and detect_unreachable_from_3sat are diagnostic
 // tools that exit(1) when they find issues. They are run via `make` targets
 // (topology-sanity-check), not as part of `cargo test`.
 
-// Note: export_examples requires the `example-db` feature which is not enabled
-// in standard CI test runs. It is exercised via `make examples`.
+// Note: export_examples is exercised by `make paper` with the example-db feature.
diff --git a/tests/suites/integration.rs b/tests/suites/integration.rs
index 52870605a..db976e33f 100644
--- a/tests/suites/integration.rs
+++ b/tests/suites/integration.rs
@@ -20,13 +20,13 @@ mod all_problems_solvable {
     fn test_independent_set_solvable() {
         let problem = MaximumIndependentSet::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-            vec![1i32; 4],
+            vec![1i64; 4],
         );
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
         for sol in &solutions {
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -34,13 +34,13 @@ mod all_problems_solvable {
     fn test_vertex_covering_solvable() {
         let problem = MinimumVertexCover::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-            vec![1i32; 4],
+            vec![1i64; 4],
         );
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
         for sol in &solutions {
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -51,7 +51,7 @@ mod all_problems_solvable {
             vec![1, 2, 1],
         );
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
     }
 
@@ -60,10 +60,10 @@ mod all_problems_solvable {
         let problem = KColoring::<K3, _>::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]));
         let solver = BruteForce::new();
         // KColoring uses the witness-capable `Or` aggregate, so all witnesses are valid colorings.
-        let satisfying = solver.find_all_witnesses(&problem);
+        let satisfying = solver.find_all_witnesses(&problem).unwrap();
         assert!(!satisfying.is_empty());
         for sol in &satisfying {
-            assert!(problem.evaluate(sol));
+            assert!(problem.evaluate(sol).unwrap());
         }
     }
 
@@ -71,13 +71,13 @@ mod all_problems_solvable {
     fn test_dominating_set_solvable() {
         let problem = MinimumDominatingSet::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-            vec![1i32; 4],
+            vec![1i64; 4],
         );
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
         for sol in &solutions {
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -85,13 +85,13 @@ mod all_problems_solvable {
     fn test_maximal_is_solvable() {
         let problem = MaximalIS::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-            vec![1i32; 4],
+            vec![1i64; 4],
         );
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
         for sol in &solutions {
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -102,10 +102,10 @@ mod all_problems_solvable {
             vec![1, 2, 1],
         );
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
         for sol in &solutions {
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -132,9 +132,9 @@ mod all_problems_solvable {
             8,
         );
         let solver = BruteForce::new();
-        let solution = solver.find_witness(&problem);
+        let solution = solver.solve(&problem).unwrap();
         assert!(solution.is_some());
-        assert!(problem.evaluate(&solution.unwrap()).0.is_some());
+        assert!(problem.evaluate(&solution.unwrap()).unwrap().0.is_some());
     }
 
     #[test]
@@ -145,9 +145,11 @@ mod all_problems_solvable {
             2,
         );
         let solver = BruteForce::new();
-        let satisfying = solver.find_all_witnesses(&problem);
-        assert_eq!(satisfying, vec![vec![0, 0, 1]]);
-        assert!(satisfying.iter().all(|config| problem.evaluate(config).0));
+        let satisfying = solver.find_all_witnesses(&problem).unwrap();
+        assert_eq!(satisfying, vec![vec![false, false, true]]);
+        assert!(satisfying
+            .iter()
+            .all(|config| problem.evaluate(config).unwrap().0));
     }
 
     #[test]
@@ -156,25 +158,19 @@ mod all_problems_solvable {
             3,
             vec![CNFClause::new(vec![1, 2]), CNFClause::new(vec![-1, 3])],
         );
-        // Satisfiability uses `Or`, so any config with `evaluate(config).0` is a witness.
-        let dims = problem.dims();
-        let all_configs: Vec<Vec<usize>> =
-            problemreductions::config::DimsIterator::new(dims.clone()).collect();
-        let satisfying: Vec<Vec<usize>> = all_configs
-            .into_iter()
-            .filter(|config| problem.evaluate(config).0)
-            .collect();
+        let satisfying = BruteForce::new().find_all_witnesses(&problem).unwrap();
         assert!(!satisfying.is_empty());
         for sol in &satisfying {
-            assert!(problem.evaluate(sol));
+            assert!(problem.evaluate(sol).unwrap());
         }
     }
 
     #[test]
     fn test_spin_glass_solvable() {
-        let problem = SpinGlass::new(3, vec![((0, 1), -1.0), ((1, 2), 1.0)], vec![0.5, -0.5, 0.0]);
+        let problem =
+            SpinGlass::new(3, vec![((0, 1), -1.0), ((1, 2), 1.0)], vec![0.5, -0.5, 0.0]).unwrap();
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
     }
 
@@ -184,33 +180,34 @@ mod all_problems_solvable {
             vec![1.0, -2.0, 0.0],
             vec![0.0, 1.0, -1.0],
             vec![0.0, 0.0, 1.0],
-        ]);
+        ])
+        .unwrap();
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
     }
 
     #[test]
     fn test_set_covering_solvable() {
         let problem =
-            MinimumSetCovering::<i32>::new(5, vec![vec![0, 1, 2], vec![2, 3, 4], vec![0, 4]]);
+            MinimumSetCovering::<i64>::new(5, vec![vec![0, 1, 2], vec![2, 3, 4], vec![0, 4]]);
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
         for sol in &solutions {
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
     #[test]
     fn test_set_packing_solvable() {
         let problem =
-            MaximumSetPacking::<i32>::new(vec![vec![0, 1], vec![2, 3], vec![1, 2], vec![4]]);
+            MaximumSetPacking::<i64>::new(vec![vec![0, 1], vec![2, 3], vec![1, 2], vec![4]]);
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
         for sol in &solutions {
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -221,28 +218,21 @@ mod all_problems_solvable {
             BooleanExpr::and(vec![BooleanExpr::var("x"), BooleanExpr::var("y")]),
         )]);
         let problem = CircuitSAT::new(circuit);
-        // CircuitSAT also uses `Or`, so witness enumeration lines up with configs where `.0` is true.
-        let dims = problem.dims();
-        let all_configs: Vec<Vec<usize>> =
-            problemreductions::config::DimsIterator::new(dims.clone()).collect();
-        let satisfying: Vec<Vec<usize>> = all_configs
-            .into_iter()
-            .filter(|config| problem.evaluate(config).0)
-            .collect();
+        let satisfying = BruteForce::new().find_all_witnesses(&problem).unwrap();
         assert!(!satisfying.is_empty());
         for sol in &satisfying {
-            assert!(problem.evaluate(sol));
+            assert!(problem.evaluate(sol).unwrap());
         }
     }
 
     #[test]
     fn test_factoring_solvable() {
-        let problem = Factoring::new(15, 2, 2);
+        let problem = Factoring::with_factor_bits(2, 2, 15);
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
         for sol in &solutions {
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -254,15 +244,15 @@ mod all_problems_solvable {
             vec![0, 1, 2],
         );
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
-        assert!(solutions.contains(&vec![1, 0, 0]));
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
+        assert!(solutions.contains(&vec![true, false, false]));
     }
 
     #[test]
     fn test_paintshop_solvable() {
         let problem = PaintShop::new(vec!["a", "b", "a", "b"]);
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
     }
 
@@ -274,10 +264,10 @@ mod all_problems_solvable {
             1,
         );
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
         for sol in &solutions {
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -286,11 +276,11 @@ mod all_problems_solvable {
         // All-ones 2x2 at rank 1 has an exact boolean factorization.
         let problem = BMF::new(vec![vec![true, true], vec![true, true]], 1);
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
         assert!(!solutions.is_empty());
         for sol in &solutions {
             // BMF evaluates to Min(Some(total_factor_size)) only when B*C = A exactly.
-            assert!(problem.is_exact(sol));
+            assert!(problem.is_exact(sol).unwrap());
         }
     }
 }
@@ -307,15 +297,15 @@ mod problem_relationships {
         let n = 4;
 
         let is_problem =
-            MaximumIndependentSet::new(SimpleGraph::new(n, edges.clone()), vec![1i32; n]);
-        let vc_problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i32; n]);
+            MaximumIndependentSet::new(SimpleGraph::new(n, edges.clone()), vec![1i64; n]);
+        let vc_problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i64; n]);
 
         let solver = BruteForce::new();
-        let is_solutions = solver.find_all_witnesses(&is_problem);
-        let vc_solutions = solver.find_all_witnesses(&vc_problem);
+        let is_solutions = solver.find_all_witnesses(&is_problem).unwrap();
+        let vc_solutions = solver.find_all_witnesses(&vc_problem).unwrap();
 
-        let max_is_size = is_solutions[0].iter().sum::<usize>();
-        let min_vc_size = vc_solutions[0].iter().sum::<usize>();
+        let max_is_size = is_solutions[0].iter().filter(|&&selected| selected).count();
+        let min_vc_size = vc_solutions[0].iter().filter(|&&selected| selected).count();
 
         // IS complement is a valid VC and vice versa
         assert_eq!(max_is_size + min_vc_size, n);
@@ -327,15 +317,15 @@ mod problem_relationships {
         let edges = vec![(0, 1), (1, 2), (2, 3)];
         let n = 4;
 
-        let maximal_is = MaximalIS::new(SimpleGraph::new(n, edges.clone()), vec![1i32; n]);
-        let is_problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i32; n]);
+        let maximal_is = MaximalIS::new(SimpleGraph::new(n, edges.clone()), vec![1i64; n]);
+        let is_problem = MaximumIndependentSet::new(SimpleGraph::new(n, edges), vec![1i64; n]);
 
         let solver = BruteForce::new();
-        let maximal_solutions = solver.find_all_witnesses(&maximal_is);
+        let maximal_solutions = solver.find_all_witnesses(&maximal_is).unwrap();
 
         // Every maximal IS is also a valid IS
         for sol in &maximal_solutions {
-            assert!(is_problem.evaluate(sol).is_valid());
+            assert!(is_problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -352,8 +342,8 @@ mod problem_relationships {
         );
 
         // All true should satisfy
-        let all_true = vec![1, 1, 1];
-        assert!(problem.evaluate(&all_true));
+        let all_true = vec![true, true, true];
+        assert!(problem.evaluate(&all_true).unwrap());
     }
 
     /// SpinGlass with all ferromagnetic (negative J) interactions prefers aligned spins.
@@ -364,10 +354,11 @@ mod problem_relationships {
             3,
             vec![((0, 1), -1.0), ((1, 2), -1.0), ((0, 2), -1.0)],
             vec![0.0, 0.0, 0.0],
-        );
+        )
+        .unwrap();
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
 
         // Optimal should be all same spin (all 0 or all 1)
         for sol in &solutions {
@@ -385,18 +376,30 @@ mod problem_relationships {
         // Three disjoint sets covering universe {0,1,2,3,4,5}
         let sets = vec![vec![0, 1], vec![2, 3], vec![4, 5]];
 
-        let covering = MinimumSetCovering::<i32>::new(6, sets.clone());
-        let packing = MaximumSetPacking::<i32>::new(sets);
+        let covering = MinimumSetCovering::<i64>::new(6, sets.clone());
+        let packing = MaximumSetPacking::<i64>::new(sets);
 
         let solver = BruteForce::new();
 
         // All sets needed for cover
-        let cover_solutions = solver.find_all_witnesses(&covering);
-        assert_eq!(cover_solutions[0].iter().sum::<usize>(), 3);
+        let cover_solutions = solver.find_all_witnesses(&covering).unwrap();
+        assert_eq!(
+            cover_solutions[0]
+                .iter()
+                .filter(|&&selected| selected)
+                .count(),
+            3
+        );
 
         // All sets can be packed (no overlap)
-        let pack_solutions = solver.find_all_witnesses(&packing);
-        assert_eq!(pack_solutions[0].iter().sum::<usize>(), 3);
+        let pack_solutions = solver.find_all_witnesses(&packing).unwrap();
+        assert_eq!(
+            pack_solutions[0]
+                .iter()
+                .filter(|&&selected| selected)
+                .count(),
+            3
+        );
     }
 }
 
@@ -406,55 +409,48 @@ mod edge_cases {
 
     #[test]
     fn test_empty_graph_independent_set() {
-        let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![]), vec![1i32; 3]);
+        let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![]), vec![1i64; 3]);
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
 
         // All vertices can be in IS when no edges
-        assert_eq!(solutions[0].iter().sum::<usize>(), 3);
+        assert_eq!(solutions[0].iter().filter(|&&selected| selected).count(), 3);
     }
 
     #[test]
     fn test_complete_graph_independent_set() {
         // K4 - complete graph on 4 vertices
         let edges = vec![(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)];
-        let problem = MaximumIndependentSet::new(SimpleGraph::new(4, edges), vec![1i32; 4]);
+        let problem = MaximumIndependentSet::new(SimpleGraph::new(4, edges), vec![1i64; 4]);
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
 
         // Maximum IS in complete graph is 1
-        assert_eq!(solutions[0].iter().sum::<usize>(), 1);
+        assert_eq!(solutions[0].iter().filter(|&&selected| selected).count(), 1);
     }
 
     #[test]
     fn test_single_clause_sat() {
         let problem = Satisfiability::new(2, vec![CNFClause::new(vec![1, -2])]);
-        // Find satisfying configs
-        let dims = problem.dims();
-        let all_configs: Vec<Vec<usize>> =
-            problemreductions::config::DimsIterator::new(dims.clone()).collect();
-        let satisfying: Vec<Vec<usize>> = all_configs
-            .into_iter()
-            .filter(|config| problem.evaluate(config).0)
-            .collect();
+        let satisfying = BruteForce::new().find_all_witnesses(&problem).unwrap();
 
         // (x1 OR NOT x2) is satisfied by 3 of 4 assignments
         assert!(!satisfying.is_empty());
         for sol in &satisfying {
-            assert!(problem.evaluate(sol));
+            assert!(problem.evaluate(sol).unwrap());
         }
     }
 
     #[test]
     fn test_trivial_factoring() {
         // Factor 4 = 2 * 2
-        let problem = Factoring::new(4, 2, 2);
+        let problem = Factoring::with_factor_bits(2, 2, 4);
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
 
         assert!(!solutions.is_empty());
         for sol in &solutions {
-            assert!(problem.evaluate(sol).is_valid());
+            assert!(problem.evaluate(sol).unwrap().is_valid());
         }
     }
 
@@ -462,10 +458,10 @@ mod edge_cases {
     fn test_single_car_paintshop() {
         let problem = PaintShop::new(vec!["a", "a"]);
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
 
         // Single car always has 1 switch (color must change)
-        assert_eq!(problem.count_switches(&solutions[0]), 1);
+        assert_eq!(problem.count_switches(&solutions[0]).unwrap(), 1);
     }
 }
 
@@ -478,14 +474,14 @@ mod weighted_problems {
         let problem = MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![10, 1, 1]);
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
 
         // Should prefer vertex 0 (weight 10) over vertex 1 (weight 1)
         // Optimal: {0, 2} with weight 11
-        let best_weight: i32 = solutions[0]
+        let best_weight: i64 = solutions[0]
             .iter()
             .enumerate()
-            .map(|(i, &s)| if s == 1 { problem.weights()[i] } else { 0 })
+            .map(|(i, &s)| if s { problem.weights()[i] } else { 0 })
             .sum();
         assert_eq!(best_weight, 11);
     }
@@ -496,13 +492,13 @@ mod weighted_problems {
             MinimumVertexCover::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![1, 10, 1]);
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
 
         // Prefer {0, 2} over {1} because {0,2} has weight 2 vs {1} has weight 10
-        let best_weight: i32 = solutions[0]
+        let best_weight: i64 = solutions[0]
             .iter()
             .enumerate()
-            .map(|(i, &s)| if s == 1 { problem.weights()[i] } else { 0 })
+            .map(|(i, &s)| if s { problem.weights()[i] } else { 0 })
             .sum();
         assert_eq!(best_weight, 2);
     }
@@ -511,10 +507,10 @@ mod weighted_problems {
     fn test_weighted_max_cut() {
         let problem = MaxCut::new(SimpleGraph::new(3, vec![(0, 1), (1, 2)]), vec![10, 1]);
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&problem);
+        let solutions = solver.find_all_witnesses(&problem).unwrap();
 
         // Maximum cut should include the heavy edge (0,1)
-        let cut_value = problem.evaluate(&solutions[0]);
+        let cut_value = problem.evaluate(&solutions[0]).unwrap();
         // cut_value should be >= 10
         assert!(cut_value.is_valid() && cut_value.unwrap() >= 10);
     }
@@ -530,14 +526,7 @@ mod weighted_problems {
             ],
         );
 
-        // Find satisfying configs
-        let dims = problem.dims();
-        let all_configs: Vec<Vec<usize>> =
-            problemreductions::config::DimsIterator::new(dims.clone()).collect();
-        let satisfying: Vec<Vec<usize>> = all_configs
-            .into_iter()
-            .filter(|config| problem.evaluate(config).0)
-            .collect();
+        let satisfying = BruteForce::new().find_all_witnesses(&problem).unwrap();
 
         // Can't satisfy both - no solution satisfies all clauses
         assert!(satisfying.is_empty());
diff --git a/tests/suites/ksatisfiability_simultaneous_incongruences.rs b/tests/suites/ksatisfiability_simultaneous_incongruences.rs
index 73791447a..947f81dab 100644
--- a/tests/suites/ksatisfiability_simultaneous_incongruences.rs
+++ b/tests/suites/ksatisfiability_simultaneous_incongruences.rs
@@ -15,7 +15,8 @@ fn test_ksatisfiability_to_simultaneous_incongruences_closed_loop() {
         ],
     );
 
-    let reduction = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source);
+    let reduction = ReduceTo::<SimultaneousIncongruences>::reduce_to(&source)
+        .expect("reduction should succeed");
     let target = reduction.target_problem();
 
     assert_eq!(target.lcm_moduli(), 105);
@@ -23,9 +24,10 @@ fn test_ksatisfiability_to_simultaneous_incongruences_closed_loop() {
 
     let solver = BruteForce::new();
     let target_solution = solver
-        .find_witness(target)
+        .solve(target)
+        .unwrap()
         .expect("target should be satisfiable");
-    let extracted = reduction.extract_solution(&target_solution);
+    let extracted = reduction.extract_solution(&target_solution).unwrap();
 
-    assert!(source.evaluate(&extracted));
+    assert!(source.evaluate(&extracted).unwrap());
 }
diff --git a/tests/suites/numeric_boundaries.rs b/tests/suites/numeric_boundaries.rs
new file mode 100644
index 000000000..ae98948d3
--- /dev/null
+++ b/tests/suites/numeric_boundaries.rs
@@ -0,0 +1,100 @@
+use problemreductions::models::formula::{
+    CNFClause, KSatisfiability, Maximum2Satisfiability, NAESatisfiability,
+    OneInThreeSatisfiability, Planar3Satisfiability, QuantifiedBooleanFormulas, Quantifier,
+    Satisfiability,
+};
+use problemreductions::models::graph::MinimumDominatingSet;
+use problemreductions::models::set::MinimumSetCovering;
+use problemreductions::rules::ReduceTo;
+use problemreductions::topology::SimpleGraph;
+use problemreductions::variant::K3;
+use problemreductions::Problem;
+
+#[test]
+fn numeric_boundaries_weight_totals_use_i64() {
+    let weight = i64::MAX / 2;
+    let expected = i64::MAX - 1;
+    let dominating = MinimumDominatingSet::new(SimpleGraph::new(2, vec![]), vec![weight, weight]);
+    assert_eq!(
+        dominating.evaluate(&vec![true, true]).unwrap().0,
+        Some(expected)
+    );
+
+    let covering =
+        MinimumSetCovering::with_weights(2, vec![vec![0], vec![1]], vec![weight, weight]);
+    assert_eq!(
+        covering.evaluate(&vec![true, true]).unwrap().0,
+        Some(expected)
+    );
+
+    let ordinary = MinimumSetCovering::with_weights(1, vec![vec![0]], vec![7i64]);
+    assert_eq!(ordinary.evaluate(&vec![true]).unwrap().0, Some(7));
+}
+
+#[test]
+fn numeric_boundaries_all_cnf_models_reject_invalid_literals() {
+    for literal in [0, i64::MIN, 2] {
+        let errors = [
+            Satisfiability::try_new(1, vec![CNFClause::new(vec![literal])]).unwrap_err(),
+            KSatisfiability::<K3>::try_new(1, vec![CNFClause::new(vec![literal, 1, 1])])
+                .unwrap_err(),
+            NAESatisfiability::try_new(1, vec![CNFClause::new(vec![literal, 1])]).unwrap_err(),
+            Maximum2Satisfiability::try_new(1, vec![CNFClause::new(vec![literal, 1])]).unwrap_err(),
+            OneInThreeSatisfiability::try_new(1, vec![CNFClause::new(vec![literal, 1, 1])])
+                .unwrap_err(),
+            Planar3Satisfiability::try_new(1, vec![CNFClause::new(vec![literal, 1, 1])])
+                .unwrap_err(),
+            QuantifiedBooleanFormulas::try_new(
+                1,
+                vec![Quantifier::Exists],
+                vec![CNFClause::new(vec![literal])],
+            )
+            .unwrap_err(),
+        ];
+
+        for error in errors {
+            let error = error.to_string();
+            assert!(error.contains(&literal.to_string()), "{error}");
+            assert!(error.contains("1..=1"), "{error}");
+        }
+    }
+}
+
+#[test]
+fn numeric_boundaries_sat_variable_limit_does_not_allocate() {
+    let max = i64::MAX as usize;
+    let formula = Satisfiability::try_new(max, vec![CNFClause::new(vec![i64::MAX])]).unwrap();
+    assert_eq!(formula.num_vars(), max);
+
+    let error = Satisfiability::try_new(max + 1, vec![]).unwrap_err();
+    let error = error.to_string();
+    assert!(error.contains(&(max + 1).to_string()), "{error}");
+    assert!(error.contains(&i64::MAX.to_string()), "{error}");
+}
+
+#[test]
+fn numeric_boundaries_serde_uses_cnf_validation() {
+    let error =
+        serde_json::from_str::<Satisfiability>(r#"{"num_vars":1,"clauses":[{"literals":[0]}]}"#)
+            .unwrap_err()
+            .to_string();
+    assert!(error.contains("invalid literal 0"), "{error}");
+    assert!(error.contains("1..=1"), "{error}");
+}
+
+#[test]
+fn numeric_boundaries_sat_reduction_rejects_exhausted_variable_ids() {
+    let source = Satisfiability::new(i64::MAX as usize, vec![CNFClause::new(vec![i64::MAX])]);
+    let message = <Satisfiability as ReduceTo<KSatisfiability<K3>>>::reduce_to(&source)
+        .unwrap_err()
+        .to_string();
+    assert!(
+        message.contains("Satisfiability -> KSatisfiability"),
+        "{message}"
+    );
+    assert!(
+        message.contains("allocate 1 auxiliary variable"),
+        "{message}"
+    );
+    assert!(message.contains(&i64::MAX.to_string()), "{message}");
+}
diff --git a/tests/suites/reductions.rs b/tests/suites/reductions.rs
index 3e164ecde..51f4746e4 100644
--- a/tests/suites/reductions.rs
+++ b/tests/suites/reductions.rs
@@ -6,8 +6,8 @@
 use problemreductions::models::algebraic::{LinearConstraint, ObjectiveSense, ILP};
 use problemreductions::models::graph::{MinimumCoveringByCliques, PartitionIntoCliques};
 use problemreductions::prelude::*;
-use problemreductions::rules::{Minimize, ReductionGraph};
-#[cfg(feature = "ilp-solver")]
+use problemreductions::rules::ReductionGraph;
+use problemreductions::solvers::BruteForceProblem as _;
 use problemreductions::solvers::ILPSolver;
 use problemreductions::topology::{Graph, SimpleGraph};
 use problemreductions::types::{Min, Or};
@@ -22,11 +22,12 @@ mod is_vc_reductions {
         // Triangle graph
         let is_problem = MaximumIndependentSet::new(
             SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-            vec![1i32; 3],
+            vec![1i64; 3],
         );
 
         // Reduce IS to VC
-        let result = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&is_problem);
+        let result = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&is_problem)
+            .expect("reduction should succeed");
         let vc_problem = result.target_problem();
 
         // Same graph structure
@@ -35,13 +36,13 @@ mod is_vc_reductions {
 
         // Solve the target VC problem
         let solver = BruteForce::new();
-        let vc_solutions = solver.find_all_witnesses(vc_problem);
+        let vc_solutions = solver.find_all_witnesses(vc_problem).unwrap();
 
         // Extract back to IS solution
-        let is_solution = result.extract_solution(&vc_solutions[0]);
+        let is_solution = result.extract_solution(&vc_solutions[0]).unwrap();
 
         // Solution should be valid for original problem
-        assert!(is_problem.evaluate(&is_solution).is_valid());
+        assert!(is_problem.evaluate(&is_solution).unwrap().is_valid());
     }
 
     #[test]
@@ -49,11 +50,12 @@ mod is_vc_reductions {
         // Path graph
         let vc_problem = MinimumVertexCover::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-            vec![1i32; 4],
+            vec![1i64; 4],
         );
 
         // Reduce VC to IS
-        let result = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&vc_problem);
+        let result = ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&vc_problem)
+            .expect("reduction should succeed");
         let is_problem = result.target_problem();
 
         // Same graph structure
@@ -62,28 +64,30 @@ mod is_vc_reductions {
 
         // Solve the target IS problem
         let solver = BruteForce::new();
-        let is_solutions = solver.find_all_witnesses(is_problem);
+        let is_solutions = solver.find_all_witnesses(is_problem).unwrap();
 
         // Extract back to VC solution
-        let vc_solution = result.extract_solution(&is_solutions[0]);
+        let vc_solution = result.extract_solution(&is_solutions[0]).unwrap();
 
         // Solution should be valid for original problem
-        assert!(vc_problem.evaluate(&vc_solution).is_valid());
+        assert!(vc_problem.evaluate(&vc_solution).unwrap().is_valid());
     }
 
     #[test]
     fn test_is_vc_roundtrip() {
         let original = MaximumIndependentSet::new(
             SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4)]),
-            vec![1i32; 5],
+            vec![1i64; 5],
         );
 
         // IS -> VC
-        let to_vc = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&original);
+        let to_vc = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&original)
+            .expect("reduction should succeed");
         let vc_problem = to_vc.target_problem();
 
         // VC -> IS
-        let back_to_is = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(vc_problem);
+        let back_to_is = ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(vc_problem)
+            .expect("reduction should succeed");
         let final_is = back_to_is.target_problem();
 
         // Should have same structure
@@ -95,14 +99,14 @@ mod is_vc_reductions {
 
         // Solve the final problem
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(final_is);
+        let solutions = solver.find_all_witnesses(final_is).unwrap();
 
         // Extract through the chain
-        let intermediate_sol = back_to_is.extract_solution(&solutions[0]);
-        let original_sol = to_vc.extract_solution(&intermediate_sol);
+        let intermediate_sol = back_to_is.extract_solution(&solutions[0]).unwrap();
+        let original_sol = to_vc.extract_solution(&intermediate_sol).unwrap();
 
         // Should be valid
-        assert!(original.evaluate(&original_sol).is_valid());
+        assert!(original.evaluate(&original_sol).unwrap().is_valid());
     }
 
     #[test]
@@ -110,7 +114,8 @@ mod is_vc_reductions {
         let is_problem =
             MaximumIndependentSet::new(SimpleGraph::new(3, vec![(0, 1)]), vec![10, 1, 5]);
 
-        let result = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&is_problem);
+        let result = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&is_problem)
+            .expect("reduction should succeed");
         let vc_problem = result.target_problem();
 
         // Weights should be preserved
@@ -124,17 +129,17 @@ mod is_vc_reductions {
         let n = 4;
 
         let is_problem =
-            MaximumIndependentSet::new(SimpleGraph::new(n, edges.clone()), vec![1i32; n]);
-        let vc_problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i32; n]);
+            MaximumIndependentSet::new(SimpleGraph::new(n, edges.clone()), vec![1i64; n]);
+        let vc_problem = MinimumVertexCover::new(SimpleGraph::new(n, edges), vec![1i64; n]);
 
         let solver = BruteForce::new();
 
         // Solve IS, reduce to VC solution
-        let is_solutions = solver.find_all_witnesses(&is_problem);
-        let max_is = is_solutions[0].iter().sum::<usize>();
+        let is_solutions = solver.find_all_witnesses(&is_problem).unwrap();
+        let max_is = is_solutions[0].iter().filter(|&&selected| selected).count();
 
-        let vc_solutions = solver.find_all_witnesses(&vc_problem);
-        let min_vc = vc_solutions[0].iter().sum::<usize>();
+        let vc_solutions = solver.find_all_witnesses(&vc_problem).unwrap();
+        let min_vc = vc_solutions[0].iter().filter(|&&selected| selected).count();
 
         assert_eq!(max_is + min_vc, n);
     }
@@ -149,10 +154,11 @@ mod is_sp_reductions {
         // Triangle graph - each vertex's incident edges become a set
         let is_problem = MaximumIndependentSet::new(
             SimpleGraph::new(3, vec![(0, 1), (1, 2), (0, 2)]),
-            vec![1i32; 3],
+            vec![1i64; 3],
         );
 
-        let result = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&is_problem);
+        let result = ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&is_problem)
+            .expect("reduction should succeed");
         let sp_problem = result.target_problem();
 
         // 3 sets (one per vertex)
@@ -160,21 +166,22 @@ mod is_sp_reductions {
 
         // Solve
         let solver = BruteForce::new();
-        let sp_solutions = solver.find_all_witnesses(sp_problem);
+        let sp_solutions = solver.find_all_witnesses(sp_problem).unwrap();
 
         // Extract to IS solution
-        let is_solution = result.extract_solution(&sp_solutions[0]);
+        let is_solution = result.extract_solution(&sp_solutions[0]).unwrap();
 
-        assert!(is_problem.evaluate(&is_solution).is_valid());
+        assert!(is_problem.evaluate(&is_solution).unwrap().is_valid());
     }
 
     #[test]
     fn test_sp_to_is_basic() {
         // Disjoint sets pack perfectly
         let sets = vec![vec![0, 1], vec![2, 3], vec![4]];
-        let sp_problem = MaximumSetPacking::<i32>::new(sets);
+        let sp_problem = MaximumSetPacking::<i64>::new(sets);
 
-        let result = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&sp_problem);
+        let result = ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&sp_problem)
+            .expect("reduction should succeed");
         let is_problem = result.target_problem();
 
         // Should have an edge for each pair of overlapping sets (none here)
@@ -182,41 +189,45 @@ mod is_sp_reductions {
 
         // Solve
         let solver = BruteForce::new();
-        let is_solutions = solver.find_all_witnesses(is_problem);
+        let is_solutions = solver.find_all_witnesses(is_problem).unwrap();
 
         // Extract to SP solution
-        let sp_solution = result.extract_solution(&is_solutions[0]);
+        let sp_solution = result.extract_solution(&is_solutions[0]).unwrap();
 
         // All sets can be packed (disjoint)
-        assert_eq!(sp_solution.iter().sum::<usize>(), 3);
-        assert!(sp_problem.evaluate(&sp_solution).is_valid());
+        assert_eq!(sp_solution.iter().filter(|&&selected| selected).count(), 3);
+        assert!(sp_problem.evaluate(&sp_solution).unwrap().is_valid());
     }
 
     #[test]
     fn test_is_sp_roundtrip() {
         let original = MaximumIndependentSet::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-            vec![1i32; 4],
+            vec![1i64; 4],
         );
 
         // IS -> SP
-        let to_sp = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&original);
+        let to_sp = ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&original)
+            .expect("reduction should succeed");
         let sp_problem = to_sp.target_problem();
 
         // Solve SP
         let solver = BruteForce::new();
-        let sp_solutions = solver.find_all_witnesses(sp_problem);
+        let sp_solutions = solver.find_all_witnesses(sp_problem).unwrap();
 
         // Extract to IS solution
-        let is_solution = to_sp.extract_solution(&sp_solutions[0]);
+        let is_solution = to_sp.extract_solution(&sp_solutions[0]).unwrap();
 
         // Valid for original
-        assert!(original.evaluate(&is_solution).is_valid());
+        assert!(original.evaluate(&is_solution).unwrap().is_valid());
 
         // Should match directly solving IS
-        let direct_solutions = solver.find_all_witnesses(&original);
-        let direct_max = direct_solutions[0].iter().sum::<usize>();
-        let reduced_max = is_solution.iter().sum::<usize>();
+        let direct_solutions = solver.find_all_witnesses(&original).unwrap();
+        let direct_max = direct_solutions[0]
+            .iter()
+            .filter(|&&selected| selected)
+            .count();
+        let reduced_max = is_solution.iter().filter(|&&selected| selected).count();
 
         assert_eq!(direct_max, reduced_max);
     }
@@ -229,38 +240,40 @@ mod sg_qubo_reductions {
     #[test]
     fn test_sg_to_qubo_basic() {
         // Simple 2-spin system
-        let sg = SpinGlass::<SimpleGraph, _>::new(2, vec![((0, 1), -1.0)], vec![0.5, -0.5]);
+        let sg =
+            SpinGlass::<SimpleGraph, _>::new(2, vec![((0, 1), -1.0)], vec![0.5, -0.5]).unwrap();
 
-        let result = ReduceTo::<QUBO>::reduce_to(&sg);
+        let result = ReduceTo::<QUBO<f64>>::reduce_to(&sg).expect("reduction should succeed");
         let qubo = result.target_problem();
 
         assert_eq!(qubo.num_variables(), 2);
 
         // Solve QUBO
         let solver = BruteForce::new();
-        let qubo_solutions = solver.find_all_witnesses(qubo);
+        let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
         // Extract to SG solution
-        let sg_solution = result.extract_solution(&qubo_solutions[0]);
+        let sg_solution = result.extract_solution(&qubo_solutions[0]).unwrap();
         assert_eq!(sg_solution.len(), 2);
     }
 
     #[test]
     fn test_qubo_to_sg_basic() {
         // QUBO::new takes linear terms and quadratic terms separately
-        let qubo = QUBO::new(vec![1.0, -1.0], vec![((0, 1), 0.5)]);
+        let qubo = QUBO::new(vec![1.0, -1.0], vec![((0, 1), 0.5)]).unwrap();
 
-        let result = ReduceTo::<SpinGlass<SimpleGraph, f64>>::reduce_to(&qubo);
+        let result = ReduceTo::<SpinGlass<SimpleGraph, f64>>::reduce_to(&qubo)
+            .expect("reduction should succeed");
         let sg = result.target_problem();
 
         assert_eq!(sg.num_spins(), 2);
 
         // Solve SG
         let solver = BruteForce::new();
-        let sg_solutions = solver.find_all_witnesses(sg);
+        let sg_solutions = solver.find_all_witnesses(sg).unwrap();
 
         // Extract to QUBO solution
-        let qubo_solution = result.extract_solution(&sg_solutions[0]);
+        let qubo_solution = result.extract_solution(&sg_solutions[0]).unwrap();
         assert_eq!(qubo_solution.len(), 2);
     }
 
@@ -271,28 +284,24 @@ mod sg_qubo_reductions {
             3,
             vec![((0, 1), -1.0), ((1, 2), 1.0)],
             vec![0.0, 0.0, 0.0],
-        );
+        )
+        .unwrap();
 
-        let result = ReduceTo::<QUBO>::reduce_to(&sg);
+        let result = ReduceTo::<QUBO<f64>>::reduce_to(&sg).expect("reduction should succeed");
         let qubo = result.target_problem();
 
         // Check that ground states correspond
         let solver = BruteForce::new();
 
-        let sg_solutions = solver.find_all_witnesses(&sg);
-        let qubo_solutions = solver.find_all_witnesses(qubo);
+        let sg_solutions = solver.find_all_witnesses(&sg).unwrap();
+        let qubo_solutions = solver.find_all_witnesses(qubo).unwrap();
 
         // Extract QUBO solution back to SG
-        let extracted = result.extract_solution(&qubo_solutions[0]);
-
-        // Convert solutions to spins for energy computation
-        // SpinGlass::config_to_spins converts 0/1 configs to -1/+1 spins
-        let sg_spins = SpinGlass::<SimpleGraph, f64>::config_to_spins(&sg_solutions[0]);
-        let extracted_spins = SpinGlass::<SimpleGraph, f64>::config_to_spins(&extracted);
+        let extracted = result.extract_solution(&qubo_solutions[0]).unwrap();
 
         // Should be among optimal SG solutions (or equivalent)
-        let sg_energy = sg.compute_energy(&sg_spins);
-        let extracted_energy = sg.compute_energy(&extracted_spins);
+        let sg_energy = sg.compute_energy(&sg_solutions[0]).unwrap();
+        let extracted_energy = sg.compute_energy(&extracted).unwrap();
 
         // Energies should match for optimal solutions
         assert!((sg_energy - extracted_energy).abs() < 1e-10);
@@ -300,7 +309,6 @@ mod sg_qubo_reductions {
 }
 
 /// Tests for MinimumCoveringByCliques -> ILP reductions.
-#[cfg(feature = "ilp-solver")]
 mod minimum_covering_by_cliques_ilp_reductions {
     use super::*;
 
@@ -310,15 +318,16 @@ mod minimum_covering_by_cliques_ilp_reductions {
             MinimumCoveringByCliques::new(SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]));
 
         let reduction =
-            <MinimumCoveringByCliques<SimpleGraph> as ReduceTo<ILP<bool>>>::reduce_to(&source);
+            <MinimumCoveringByCliques<SimpleGraph> as ReduceTo<ILP<bool>>>::reduce_to(&source)
+                .expect("reduction should succeed");
         let ilp = reduction.target_problem();
 
         let ilp_solution = ILPSolver::new()
             .solve(ilp)
             .expect("MinimumCoveringByCliques -> ILP should be solvable");
-        let extracted = reduction.extract_solution(&ilp_solution);
+        let extracted = reduction.extract_solution(&ilp_solution).unwrap();
 
-        assert_eq!(source.evaluate(&extracted), Min(Some(3)));
+        assert_eq!(source.evaluate(&extracted).unwrap(), Min(Some(3)));
     }
 }
 
@@ -328,27 +337,33 @@ mod partition_into_cliques_covering_by_cliques_reductions {
 
     #[test]
     fn test_partition_into_cliques_to_covering_by_cliques_closed_loop() {
-        let source = PartitionIntoCliques::new(SimpleGraph::new(1, vec![]), 1);
+        let source: PartitionIntoCliques<SimpleGraph> = serde_json::from_value(serde_json::json!({
+            "graph": {"num_vertices": 0, "edges": []}, "num_cliques": 0
+        }))
+        .unwrap();
 
-        let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source);
+        let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source)
+            .expect("reduction should succeed");
         let target = reduction.target_problem();
 
         let target_solution = BruteForce::new()
-            .find_witness(target)
+            .solve(target)
+            .unwrap()
             .expect("target should be solvable");
-        let extracted = reduction.extract_solution(&target_solution);
+        let extracted = reduction.extract_solution(&target_solution).unwrap();
 
-        assert_eq!(source.evaluate(&extracted), Or(true));
+        assert_eq!(source.evaluate(&extracted).unwrap(), Or(true));
     }
 
     #[test]
     fn test_partition_into_cliques_to_covering_by_cliques_orlin_issue_counts() {
         let source = PartitionIntoCliques::new(SimpleGraph::new(3, vec![(0, 1)]), 2);
-        let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source);
+        let reduction = ReduceTo::<MinimumCoveringByCliques<SimpleGraph>>::reduce_to(&source)
+            .expect("reduction should succeed");
         let target = reduction.target_problem();
 
-        assert_eq!(target.graph().num_vertices(), 12);
-        assert_eq!(target.graph().num_edges(), 41);
+        assert_eq!(target.graph().num_vertices(), 14);
+        assert_eq!(target.graph().num_edges(), 53);
     }
 }
 
@@ -369,16 +384,17 @@ mod max2sat_maxcut_reductions {
             ],
         );
 
-        let reduction = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&source);
+        let reduction = ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&source)
+            .expect("reduction should succeed");
         let target = reduction.target_problem();
 
         assert_eq!(target.graph().num_vertices(), 4);
 
         let solver = BruteForce::new();
-        let target_solutions = solver.find_all_witnesses(target);
-        let extracted = reduction.extract_solution(&target_solutions[0]);
+        let target_solutions = solver.find_all_witnesses(target).unwrap();
+        let extracted = reduction.extract_solution(&target_solutions[0]).unwrap();
 
-        assert_eq!(source.evaluate(&extracted), Max(Some(5)));
+        assert_eq!(source.evaluate(&extracted).unwrap(), Max(Some(5)));
     }
 }
 
@@ -393,9 +409,11 @@ mod sg_maxcut_reductions {
             3,
             vec![((0, 1), 1), ((1, 2), 1), ((0, 2), 1)],
             vec![0, 0, 0],
-        );
+        )
+        .unwrap();
 
-        let result = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&sg);
+        let result =
+            ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&sg).expect("reduction should succeed");
         let maxcut = result.target_problem();
 
         // Same number of vertices
@@ -403,10 +421,10 @@ mod sg_maxcut_reductions {
 
         // Solve MaxCut
         let solver = BruteForce::new();
-        let maxcut_solutions = solver.find_all_witnesses(maxcut);
+        let maxcut_solutions = solver.find_all_witnesses(maxcut).unwrap();
 
         // Extract to SG solution
-        let sg_solution = result.extract_solution(&maxcut_solutions[0]);
+        let sg_solution = result.extract_solution(&maxcut_solutions[0]).unwrap();
         assert_eq!(sg_solution.len(), 3);
     }
 
@@ -417,7 +435,8 @@ mod sg_maxcut_reductions {
             vec![2, 1, 3],
         );
 
-        let result = ReduceTo::<SpinGlass<SimpleGraph, i32>>::reduce_to(&maxcut);
+        let result = ReduceTo::<SpinGlass<SimpleGraph, i64>>::reduce_to(&maxcut)
+            .expect("reduction should succeed");
         let sg = result.target_problem();
 
         // Same number of spins
@@ -425,10 +444,10 @@ mod sg_maxcut_reductions {
 
         // Solve SG
         let solver = BruteForce::new();
-        let sg_solutions = solver.find_all_witnesses(sg);
+        let sg_solutions = solver.find_all_witnesses(sg).unwrap();
 
         // Extract to MaxCut solution
-        let maxcut_solution = result.extract_solution(&sg_solutions[0]);
+        let maxcut_solution = result.extract_solution(&sg_solutions[0]).unwrap();
         assert_eq!(maxcut_solution.len(), 3);
     }
 
@@ -439,28 +458,25 @@ mod sg_maxcut_reductions {
             4,
             vec![((0, 1), 1), ((1, 2), 1), ((2, 3), 1), ((0, 3), 1)],
             vec![0, 0, 0, 0],
-        );
+        )
+        .unwrap();
 
-        let result = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&sg);
+        let result =
+            ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&sg).expect("reduction should succeed");
         let maxcut = result.target_problem();
 
         let solver = BruteForce::new();
 
         // Solve both
-        let sg_solutions = solver.find_all_witnesses(&sg);
-        let maxcut_solutions = solver.find_all_witnesses(maxcut);
+        let sg_solutions = solver.find_all_witnesses(&sg).unwrap();
+        let maxcut_solutions = solver.find_all_witnesses(maxcut).unwrap();
 
         // Extract MaxCut solution back to SG
-        let extracted = result.extract_solution(&maxcut_solutions[0]);
-
-        // Convert solutions to spins for energy computation
-        // SpinGlass::config_to_spins converts 0/1 configs to -1/+1 spins
-        let direct_spins = SpinGlass::<SimpleGraph, i32>::config_to_spins(&sg_solutions[0]);
-        let extracted_spins = SpinGlass::<SimpleGraph, i32>::config_to_spins(&extracted);
+        let extracted = result.extract_solution(&maxcut_solutions[0]).unwrap();
 
         // Should have same energy as directly solved SG
-        let direct_energy = sg.compute_energy(&direct_spins);
-        let extracted_energy = sg.compute_energy(&extracted_spins);
+        let direct_energy = sg.compute_energy(&sg_solutions[0]).unwrap();
+        let extracted_energy = sg.compute_energy(&extracted).unwrap();
 
         assert_eq!(direct_energy, extracted_energy);
     }
@@ -473,12 +489,12 @@ mod topology_tests {
 
     #[test]
     fn test_setpacking_from_hyperedge_style_input() {
-        let sp = MaximumSetPacking::<i32>::new(vec![vec![0, 1, 2], vec![2, 3], vec![3, 4]]);
+        let sp = MaximumSetPacking::<i64>::new(vec![vec![0, 1, 2], vec![2, 3], vec![3, 4]]);
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&sp);
+        let solutions = solver.find_all_witnesses(&sp).unwrap();
 
-        assert!(sp.evaluate(&solutions[0]).is_valid());
+        assert!(sp.evaluate(&solutions[0]).unwrap().is_valid());
     }
 
     #[test]
@@ -490,18 +506,18 @@ mod topology_tests {
             (2.0, 0.0), // Far from 0 and 1
             (2.5, 0.0), // Close to 2
         ];
-        let udg = UnitDiskGraph::new(positions, 1.0);
+        let udg = UnitDiskGraph::new(positions, 1.0).unwrap();
 
         // Extract edges
         let edges = udg.edges().to_vec();
-        let is_problem = MaximumIndependentSet::new(SimpleGraph::new(4, edges), vec![1i32; 4]);
+        let is_problem = MaximumIndependentSet::new(SimpleGraph::new(4, edges), vec![1i64; 4]);
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(&is_problem);
+        let solutions = solver.find_all_witnesses(&is_problem).unwrap();
 
         // Vertices 0-1 are connected, 2-3 are connected
         // Max IS: {0, 2} or {0, 3} or {1, 2} or {1, 3} = size 2
-        assert_eq!(solutions[0].iter().sum::<usize>(), 2);
+        assert_eq!(solutions[0].iter().filter(|&&selected| selected).count(), 2);
     }
 }
 
@@ -540,43 +556,39 @@ mod qubo_reductions {
         let data: ISToQuboData = serde_json::from_str(&json).unwrap();
 
         let n = data.source.num_vertices;
-        let is = MaximumIndependentSet::new(SimpleGraph::new(n, data.source.edges), vec![1i32; n]);
+        let is = MaximumIndependentSet::new(SimpleGraph::new(n, data.source.edges), vec![1i64; n]);
         let graph = ReductionGraph::new();
         let src =
-            ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i32>::variant());
+            ReductionGraph::variant_to_map(&MaximumIndependentSet::<SimpleGraph, i64>::variant());
         let dst = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
         let path = graph
-            .find_cheapest_path(
-                "MaximumIndependentSet",
-                &src,
-                "QUBO",
-                &dst,
-                &ProblemSize::new(vec![
-                    ("num_vertices", n),
-                    ("num_edges", is.graph().num_edges()),
-                ]),
-                &Minimize("num_vars"),
-            )
-            .expect("Should find path MaximumIndependentSet -> QUBO");
+            .find_all_paths("MaximumIndependentSet", &src, "QUBO", &dst)
+            .into_iter()
+            .find(|path| {
+                path.type_names() == ["MaximumIndependentSet", "MaximumSetPacking", "QUBO"]
+            })
+            .expect("explicit set-packing route");
         let chain = graph
             .reduce_along_path(&path, &is as &dyn std::any::Any)
+            .expect("MaximumIndependentSet -> QUBO reduction should not fail")
             .expect("Should reduce MaximumIndependentSet to QUBO");
         let qubo: &QUBO<f64> = chain.target_problem();
 
         assert_eq!(qubo.num_variables(), data.qubo_num_vars);
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(qubo);
+        let solutions = solver.find_all_witnesses(qubo).unwrap();
 
         // All QUBO optimal solutions should extract to valid IS solutions
         for sol in &solutions {
-            let extracted = chain.extract_solution(sol);
-            assert!(is.evaluate(&extracted).is_valid());
+            let extracted = chain.extract_solution(sol).unwrap();
+            assert!(is.evaluate(&extracted).unwrap().is_valid());
         }
 
         // Optimal IS size should match ground truth
         let gt_is_size: usize = data.qubo_optimal.configs[0].iter().sum();
-        let our_is_size: usize = chain.extract_solution(&solutions[0]).iter().sum();
+        let our_is_solution: Vec<bool> = chain.extract_solution(&solutions[0]).unwrap();
+        let our_is_size = our_is_solution.iter().filter(|&&selected| selected).count();
         assert_eq!(our_is_size, gt_is_size);
     }
 
@@ -605,17 +617,17 @@ mod qubo_reductions {
             data.source.num_vertices,
             data.source.edges,
         ));
-        let reduction = ReduceTo::<QUBO>::reduce_to(&kc);
+        let reduction = ReduceTo::<QUBO>::reduce_to(&kc).expect("reduction should succeed");
         let qubo = reduction.target_problem();
 
         assert_eq!(qubo.num_variables(), data.qubo_num_vars);
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(qubo);
+        let solutions = solver.find_all_witnesses(qubo).unwrap();
 
         for sol in &solutions {
-            let extracted = reduction.extract_solution(sol);
-            assert!(kc.evaluate(&extracted));
+            let extracted = reduction.extract_solution(sol).unwrap();
+            assert!(kc.evaluate(&extracted).unwrap());
         }
 
         // Same number of optimal colorings as ground truth
@@ -641,23 +653,28 @@ mod qubo_reductions {
             std::fs::read_to_string("tests/data/qubo/maximumsetpacking_to_qubo.json").unwrap();
         let data: SPToQuboData = serde_json::from_str(&json).unwrap();
 
-        let sp = MaximumSetPacking::with_weights(data.source.sets, data.source.weights);
-        let reduction = ReduceTo::<QUBO>::reduce_to(&sp);
+        let sp = MaximumSetPacking::with_weights(data.source.sets, data.source.weights).unwrap();
+        let reduction = ReduceTo::<QUBO<f64>>::reduce_to(&sp).expect("reduction should succeed");
         let qubo = reduction.target_problem();
 
         assert_eq!(qubo.num_variables(), data.qubo_num_vars);
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(qubo);
+        let solutions = solver.find_all_witnesses(qubo).unwrap();
 
         for sol in &solutions {
-            let extracted = reduction.extract_solution(sol);
-            assert!(sp.evaluate(&extracted).is_valid());
+            let extracted = reduction.extract_solution(sol).unwrap();
+            assert!(sp.evaluate(&extracted).unwrap().is_valid());
         }
 
         // Optimal packing should match ground truth
         let gt_selected: usize = data.qubo_optimal.configs[0].iter().sum();
-        let our_selected: usize = reduction.extract_solution(&solutions[0]).iter().sum();
+        let our_selected: usize = reduction
+            .extract_solution(&solutions[0])
+            .unwrap()
+            .iter()
+            .filter(|&&selected| selected)
+            .count();
         assert_eq!(our_selected, gt_selected);
     }
 
@@ -691,10 +708,10 @@ mod qubo_reductions {
             .clauses
             .iter()
             .map(|lits| {
-                let signed: Vec<i32> = lits
+                let signed: Vec<i64> = lits
                     .iter()
                     .map(|l| {
-                        let var = (l.variable + 1) as i32; // 0-indexed to 1-indexed
+                        let var = (l.variable + 1) as i64; // 0-indexed to 1-indexed
                         if l.negated {
                             -var
                         } else {
@@ -707,26 +724,31 @@ mod qubo_reductions {
             .collect();
 
         let ksat = KSatisfiability::<K2>::new(data.source.num_variables, clauses);
-        let reduction = ReduceTo::<QUBO>::reduce_to(&ksat);
+        let reduction = ReduceTo::<QUBO>::reduce_to(&ksat).expect("reduction should succeed");
         let qubo = reduction.target_problem();
 
         assert_eq!(qubo.num_variables(), data.qubo_num_vars);
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(qubo);
+        let solutions = solver.find_all_witnesses(qubo).unwrap();
 
         for sol in &solutions {
-            let extracted = reduction.extract_solution(sol);
-            assert!(ksat.evaluate(&extracted));
+            let extracted = reduction.extract_solution(sol).unwrap();
+            assert!(ksat.evaluate(&extracted).unwrap());
         }
 
         // Verify extracted solution matches ground truth assignment
         let gt_config = &data.qubo_optimal.configs[0];
-        let our_config = reduction.extract_solution(&solutions[0]);
-        assert_eq!(&our_config, gt_config);
+        let our_config = reduction.extract_solution(&solutions[0]).unwrap();
+        assert_eq!(
+            our_config,
+            gt_config
+                .iter()
+                .map(|&value| value != 0)
+                .collect::<Vec<_>>()
+        );
     }
 
-    #[cfg(feature = "ilp-solver")]
     #[derive(Deserialize)]
     struct ILPToQuboData {
         source: ILPSource,
@@ -734,17 +756,15 @@ mod qubo_reductions {
         qubo_optimal: QuboOptimal,
     }
 
-    #[cfg(feature = "ilp-solver")]
     #[derive(Deserialize)]
     struct ILPSource {
         num_variables: usize,
-        objective: Vec<f64>,
-        constraints_lhs: Vec<Vec<f64>>,
-        constraints_rhs: Vec<f64>,
-        constraint_signs: Vec<i32>,
+        objective: Vec<i64>,
+        constraints_lhs: Vec<Vec<i64>>,
+        constraints_rhs: Vec<i64>,
+        constraint_signs: Vec<i64>,
     }
 
-    #[cfg(feature = "ilp-solver")]
     #[test]
     fn test_ilp_to_qubo_ground_truth() {
         let json = std::fs::read_to_string("tests/data/qubo/ilp_to_qubo.json").unwrap();
@@ -758,10 +778,10 @@ mod qubo_reductions {
             .zip(data.source.constraints_rhs.iter())
             .zip(data.source.constraint_signs.iter())
             .map(|((row, &rhs), &sign)| {
-                let terms: Vec<(usize, f64)> = row
+                let terms: Vec<(usize, i64)> = row
                     .iter()
                     .enumerate()
-                    .filter(|(_, &c)| c.abs() > 1e-15)
+                    .filter(|(_, &c)| c != 0)
                     .map(|(i, &c)| (i, c))
                     .collect();
                 match sign {
@@ -774,12 +794,12 @@ mod qubo_reductions {
             .collect();
 
         // Build objective (dense to sparse)
-        let objective: Vec<(usize, f64)> = data
+        let objective: Vec<(usize, i64)> = data
             .source
             .objective
             .iter()
             .enumerate()
-            .filter(|(_, &c)| c.abs() > 1e-15)
+            .filter(|(_, &c)| c != 0)
             .map(|(i, &c)| (i, c))
             .collect();
 
@@ -789,25 +809,32 @@ mod qubo_reductions {
             constraints,
             objective,
             ObjectiveSense::Maximize,
-        );
-        let reduction = ReduceTo::<QUBO>::reduce_to(&ilp);
+        )
+        .unwrap();
+        let reduction = ReduceTo::<QUBO<i64>>::reduce_to(&ilp).expect("reduction should succeed");
         let qubo = reduction.target_problem();
 
         // QUBO may have more variables (slack), but original count matches
         assert!(qubo.num_variables() >= data.qubo_num_vars);
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(qubo);
+        let solutions = solver.find_all_witnesses(qubo).unwrap();
 
         for sol in &solutions {
-            let extracted = reduction.extract_solution(sol);
-            assert!(ilp.evaluate(&extracted).is_valid());
+            let extracted = reduction.extract_solution(sol).unwrap();
+            assert!(ilp.evaluate(&extracted).unwrap().is_valid());
         }
 
         // Optimal assignment should match ground truth
         let gt_config = &data.qubo_optimal.configs[0];
-        let our_config = reduction.extract_solution(&solutions[0]);
-        assert_eq!(&our_config, gt_config);
+        let our_config = reduction.extract_solution(&solutions[0]).unwrap();
+        assert_eq!(
+            &our_config,
+            &gt_config
+                .iter()
+                .map(|&value| i64::try_from(value).unwrap())
+                .collect::<Vec<_>>()
+        );
     }
 
     #[derive(Deserialize)]
@@ -829,26 +856,26 @@ mod qubo_reductions {
         let data: VCToQuboData = serde_json::from_str(&json).unwrap();
 
         let n = data.source.num_vertices;
-        let vc = MinimumVertexCover::new(SimpleGraph::new(n, data.source.edges), vec![1i32; n]);
+        let vc = MinimumVertexCover::new(SimpleGraph::new(n, data.source.edges), vec![1i64; n]);
 
         // Find path MVC → ... → QUBO through the reduction graph
         let graph = ReductionGraph::new();
         let src =
-            ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i32>::variant());
+            ReductionGraph::variant_to_map(&MinimumVertexCover::<SimpleGraph, i64>::variant());
         let dst = ReductionGraph::variant_to_map(&QUBO::<f64>::variant());
         let path = graph
-            .find_cheapest_path(
-                "MinimumVertexCover",
-                &src,
-                "QUBO",
-                &dst,
-                &ProblemSize::new(vec![
-                    ("num_vertices", n),
-                    ("num_edges", vc.graph().num_edges()),
-                ]),
-                &Minimize("num_vars"),
-            )
-            .expect("Should find path MVC -> QUBO");
+            .find_all_paths("MinimumVertexCover", &src, "QUBO", &dst)
+            .into_iter()
+            .find(|path| {
+                path.type_names()
+                    == [
+                        "MinimumVertexCover",
+                        "MaximumIndependentSet",
+                        "MaximumSetPacking",
+                        "QUBO",
+                    ]
+            })
+            .expect("explicit MIS route");
         assert_eq!(
             path.type_names(),
             vec![
@@ -861,22 +888,23 @@ mod qubo_reductions {
 
         let chain = graph
             .reduce_along_path(&path, &vc as &dyn std::any::Any)
+            .expect("MinimumVertexCover -> QUBO reduction should not fail")
             .expect("Should reduce MVC to QUBO");
         let qubo: &QUBO<f64> = chain.target_problem();
 
         let solver = BruteForce::new();
-        let solutions = solver.find_all_witnesses(qubo);
+        let solutions = solver.find_all_witnesses(qubo).unwrap();
 
         // Extract back through the full chain to get VC solution
         for sol in &solutions {
-            let vc_sol = chain.extract_solution(sol);
-            assert!(vc.evaluate(&vc_sol).is_valid());
+            let vc_sol = chain.extract_solution(sol).unwrap();
+            assert!(vc.evaluate(&vc_sol).unwrap().is_valid());
         }
 
         // Optimal VC size should match ground truth
-        let vc_sol = chain.extract_solution(&solutions[0]);
+        let vc_sol: Vec<bool> = chain.extract_solution(&solutions[0]).unwrap();
         let gt_vc_size: usize = data.qubo_optimal.configs[0].iter().sum();
-        let our_vc_size: usize = vc_sol.iter().sum();
+        let our_vc_size = vc_sol.iter().filter(|&&selected| selected).count();
         assert_eq!(our_vc_size, gt_vc_size);
     }
 }
@@ -890,14 +918,14 @@ mod io_tests {
     fn test_serialize_reduce_deserialize() {
         let original = MaximumIndependentSet::new(
             SimpleGraph::new(4, vec![(0, 1), (1, 2), (2, 3)]),
-            vec![1i32; 4],
+            vec![1i64; 4],
         );
 
         // Serialize
         let json = to_json(&original).unwrap();
 
         // Deserialize
-        let restored: MaximumIndependentSet<SimpleGraph, i32> = from_json(&json).unwrap();
+        let restored: MaximumIndependentSet<SimpleGraph, i64> = from_json(&json).unwrap();
 
         // Should have same structure
         assert_eq!(
@@ -907,7 +935,8 @@ mod io_tests {
         assert_eq!(restored.graph().num_edges(), original.graph().num_edges());
 
         // Reduce the restored problem
-        let result = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&restored);
+        let result = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&restored)
+            .expect("reduction should succeed");
         let vc = result.target_problem();
 
         assert_eq!(vc.graph().num_vertices(), 4);
@@ -917,16 +946,17 @@ mod io_tests {
     #[test]
     fn test_serialize_qubo_sg_roundtrip() {
         // Use from_matrix for simpler construction
-        let qubo = QUBO::from_matrix(vec![vec![1.0, 0.5], vec![0.0, -1.0]]);
+        let qubo = QUBO::from_matrix(vec![vec![1.0, 0.5], vec![0.0, -1.0]]).unwrap();
 
         // Serialize
         let json = to_json(&qubo).unwrap();
 
         // Deserialize
-        let restored: QUBO = from_json(&json).unwrap();
+        let restored: QUBO<f64> = from_json(&json).unwrap();
 
         // Reduce to SG
-        let result = ReduceTo::<SpinGlass<SimpleGraph, f64>>::reduce_to(&restored);
+        let result = ReduceTo::<SpinGlass<SimpleGraph, f64>>::reduce_to(&restored)
+            .expect("reduction should succeed");
         let sg = result.target_problem();
 
         // Serialize the SG
@@ -948,27 +978,29 @@ mod end_to_end {
         // Start with an MaximumIndependentSet problem
         let is = MaximumIndependentSet::new(
             SimpleGraph::new(5, vec![(0, 1), (1, 2), (2, 3), (3, 4), (0, 4)]),
-            vec![1i32; 5],
+            vec![1i64; 5],
         );
 
         // Solve directly
         let solver = BruteForce::new();
-        let is_solutions = solver.find_all_witnesses(&is);
-        let direct_size = is_solutions[0].iter().sum::<usize>();
+        let is_solutions = solver.find_all_witnesses(&is).unwrap();
+        let direct_size = is_solutions[0].iter().filter(|&&selected| selected).count();
 
         // Reduce to VC and solve
-        let to_vc = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(&is);
+        let to_vc = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(&is)
+            .expect("reduction should succeed");
         let vc = to_vc.target_problem();
-        let vc_solutions = solver.find_all_witnesses(vc);
-        let vc_extracted = to_vc.extract_solution(&vc_solutions[0]);
-        let via_vc_size = vc_extracted.iter().sum::<usize>();
+        let vc_solutions = solver.find_all_witnesses(vc).unwrap();
+        let vc_extracted = to_vc.extract_solution(&vc_solutions[0]).unwrap();
+        let via_vc_size = vc_extracted.iter().filter(|&&selected| selected).count();
 
         // Reduce to MaximumSetPacking and solve
-        let to_sp = ReduceTo::<MaximumSetPacking<i32>>::reduce_to(&is);
+        let to_sp =
+            ReduceTo::<MaximumSetPacking<i64>>::reduce_to(&is).expect("reduction should succeed");
         let sp = to_sp.target_problem();
-        let sp_solutions = solver.find_all_witnesses(sp);
-        let sp_extracted = to_sp.extract_solution(&sp_solutions[0]);
-        let via_sp_size = sp_extracted.iter().sum::<usize>();
+        let sp_solutions = solver.find_all_witnesses(sp).unwrap();
+        let sp_extracted = to_sp.extract_solution(&sp_solutions[0]).unwrap();
+        let via_sp_size = sp_extracted.iter().filter(|&&selected| selected).count();
 
         // All should give same optimal size
         assert_eq!(direct_size, via_vc_size);
@@ -982,25 +1014,23 @@ mod end_to_end {
             4,
             vec![((0, 1), 1), ((1, 2), -1), ((2, 3), 1), ((0, 3), -1)],
             vec![0, 0, 0, 0],
-        );
+        )
+        .unwrap();
 
         // Solve directly
         let solver = BruteForce::new();
-        let sg_solutions = solver.find_all_witnesses(&sg);
+        let sg_solutions = solver.find_all_witnesses(&sg).unwrap();
 
-        // Convert usize solution to i32 spin values for compute_energy
-        let direct_spins: Vec<i32> = sg_solutions[0].iter().map(|&x| x as i32).collect();
-        let direct_energy = sg.compute_energy(&direct_spins);
+        let direct_energy = sg.compute_energy(&sg_solutions[0]).unwrap();
 
         // Reduce to MaxCut and solve
-        let to_maxcut = ReduceTo::<MaxCut<SimpleGraph, i32>>::reduce_to(&sg);
+        let to_maxcut =
+            ReduceTo::<MaxCut<SimpleGraph, i64>>::reduce_to(&sg).expect("reduction should succeed");
         let maxcut = to_maxcut.target_problem();
-        let maxcut_solutions = solver.find_all_witnesses(maxcut);
-        let maxcut_extracted = to_maxcut.extract_solution(&maxcut_solutions[0]);
+        let maxcut_solutions = solver.find_all_witnesses(maxcut).unwrap();
+        let maxcut_extracted = to_maxcut.extract_solution(&maxcut_solutions[0]).unwrap();
 
-        // Convert extracted solution to spins for energy computation
-        let extracted_spins: Vec<i32> = maxcut_extracted.iter().map(|&x| x as i32).collect();
-        let via_maxcut_energy = sg.compute_energy(&extracted_spins);
+        let via_maxcut_energy = sg.compute_energy(&maxcut_extracted).unwrap();
 
         // Should give same optimal energy
         assert_eq!(direct_energy, via_maxcut_energy);
@@ -1010,25 +1040,27 @@ mod end_to_end {
     fn test_chain_reduction_sp_is_vc() {
         // MaximumSetPacking -> MaximumIndependentSet -> MinimumVertexCover
         let sets = vec![vec![0, 1], vec![1, 2], vec![2, 3], vec![3]];
-        let sp = MaximumSetPacking::<i32>::new(sets);
+        let sp = MaximumSetPacking::<i64>::new(sets);
 
         // SP -> IS
-        let sp_to_is = ReduceTo::<MaximumIndependentSet<SimpleGraph, i32>>::reduce_to(&sp);
+        let sp_to_is = ReduceTo::<MaximumIndependentSet<SimpleGraph, i64>>::reduce_to(&sp)
+            .expect("reduction should succeed");
         let is = sp_to_is.target_problem();
 
         // IS -> VC
-        let is_to_vc = ReduceTo::<MinimumVertexCover<SimpleGraph, i32>>::reduce_to(is);
+        let is_to_vc = ReduceTo::<MinimumVertexCover<SimpleGraph, i64>>::reduce_to(is)
+            .expect("reduction should succeed");
         let vc = is_to_vc.target_problem();
 
         // Solve VC
         let solver = BruteForce::new();
-        let vc_solutions = solver.find_all_witnesses(vc);
+        let vc_solutions = solver.find_all_witnesses(vc).unwrap();
 
         // Extract back through chain
-        let is_sol = is_to_vc.extract_solution(&vc_solutions[0]);
-        let sp_sol = sp_to_is.extract_solution(&is_sol);
+        let is_sol = is_to_vc.extract_solution(&vc_solutions[0]).unwrap();
+        let sp_sol = sp_to_is.extract_solution(&is_sol).unwrap();
 
         // Should be valid MaximumSetPacking
-        assert!(sp.evaluate(&sp_sol).is_valid());
+        assert!(sp.evaluate(&sp_sol).unwrap().is_valid());
     }
 }
diff --git a/tests/suites/register_assignment_reductions.rs b/tests/suites/register_assignment_reductions.rs
index a124edb00..04afcc570 100644
--- a/tests/suites/register_assignment_reductions.rs
+++ b/tests/suites/register_assignment_reductions.rs
@@ -2,9 +2,9 @@ use problemreductions::models::algebraic::ILP;
 use problemreductions::models::formula::{CNFClause, KSatisfiability};
 use problemreductions::models::misc::FeasibleRegisterAssignment;
 use problemreductions::prelude::*;
-use problemreductions::rules::{MinimizeSteps, ReductionGraph, ReductionPath};
+use problemreductions::rules::{ReductionGraph, ReductionPath};
 use problemreductions::solvers::ILPSolver;
-use problemreductions::types::{Or, ProblemSize};
+use problemreductions::types::Or;
 use problemreductions::variant::K3;
 
 fn ksat_to_fra_path() -> ReductionPath {
@@ -12,31 +12,21 @@ fn ksat_to_fra_path() -> ReductionPath {
     let src = ReductionGraph::variant_to_map(&KSatisfiability::<K3>::variant());
     let dst = ReductionGraph::variant_to_map(&FeasibleRegisterAssignment::variant());
     graph
-        .find_cheapest_path(
-            "KSatisfiability",
-            &src,
-            "FeasibleRegisterAssignment",
-            &dst,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .expect("expected a direct KSatisfiability<K3> -> FeasibleRegisterAssignment path")
+        .find_all_paths("KSatisfiability", &src, "FeasibleRegisterAssignment", &dst)
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("expected direct route")
 }
 
 fn fra_to_ilp_path() -> ReductionPath {
     let graph = ReductionGraph::new();
     let src = ReductionGraph::variant_to_map(&FeasibleRegisterAssignment::variant());
-    let dst = ReductionGraph::variant_to_map(&ILP::<i32>::variant());
+    let dst = ReductionGraph::variant_to_map(&ILP::<i64>::variant());
     graph
-        .find_cheapest_path(
-            "FeasibleRegisterAssignment",
-            &src,
-            "ILP",
-            &dst,
-            &ProblemSize::new(vec![]),
-            &MinimizeSteps,
-        )
-        .expect("expected a direct FeasibleRegisterAssignment -> ILP<i32> path")
+        .find_all_paths("FeasibleRegisterAssignment", &src, "ILP", &dst)
+        .into_iter()
+        .find(|path| path.len() == 1)
+        .expect("expected direct route")
 }
 
 #[test]
@@ -57,6 +47,7 @@ fn test_ksat_to_fra_structure_and_closed_loop_via_ilp() {
     );
     let ksat_chain = graph
         .reduce_along_path(&ksat_path, &source as &dyn std::any::Any)
+        .expect("KSAT -> FRA reduction should not fail")
         .expect("KSAT -> FRA reduction should execute");
     let fra = ksat_chain.target_problem::<FeasibleRegisterAssignment>();
 
@@ -71,17 +62,18 @@ fn test_ksat_to_fra_structure_and_closed_loop_via_ilp() {
     );
     let fra_chain = graph
         .reduce_along_path(&fra_path, fra as &dyn std::any::Any)
+        .expect("FRA -> ILP reduction should not fail")
         .expect("FRA -> ILP reduction should execute");
-    let ilp = fra_chain.target_problem::<ILP<i32>>();
+    let ilp = fra_chain.target_problem::<ILP<i64>>();
 
     let ilp_solution = ILPSolver::new()
         .solve(ilp)
         .expect("satisfiable FRA instance should reduce to a feasible ILP");
-    let fra_solution = fra_chain.extract_solution(&ilp_solution);
-    assert_eq!(fra.evaluate(&fra_solution), Or(true));
+    let fra_solution = fra_chain.extract_solution(&ilp_solution).unwrap();
+    assert_eq!(fra.evaluate(&fra_solution).unwrap(), Or(true));
 
-    let sat_solution = ksat_chain.extract_solution(&fra_solution);
-    assert_eq!(source.evaluate(&sat_solution), Or(true));
+    let sat_solution = ksat_chain.extract_solution(&fra_solution).unwrap();
+    assert_eq!(source.evaluate(&sat_solution).unwrap(), Or(true));
 }
 
 #[test]
@@ -97,16 +89,18 @@ fn test_unsatisfiable_ksat_stays_infeasible_through_fra_to_ilp() {
     let graph = ReductionGraph::new();
     let ksat_chain = graph
         .reduce_along_path(&ksat_to_fra_path(), &source as &dyn std::any::Any)
+        .expect("KSAT -> FRA reduction should not fail")
         .expect("KSAT -> FRA reduction should execute");
     let fra = ksat_chain.target_problem::<FeasibleRegisterAssignment>();
     let fra_chain = graph
         .reduce_along_path(&fra_to_ilp_path(), fra as &dyn std::any::Any)
+        .expect("FRA -> ILP reduction should not fail")
         .expect("FRA -> ILP reduction should execute");
 
     assert!(
         ILPSolver::new()
-            .solve(fra_chain.target_problem::<ILP<i32>>())
-            .is_none(),
+            .solve(fra_chain.target_problem::<ILP<i64>>())
+            .is_err(),
         "unsatisfiable source instance should yield an infeasible ILP"
     );
 }
diff --git a/tests/suites/simultaneous_incongruences.rs b/tests/suites/simultaneous_incongruences.rs
index 5d1aca63e..6c4aa63c0 100644
--- a/tests/suites/simultaneous_incongruences.rs
+++ b/tests/suites/simultaneous_incongruences.rs
@@ -1,5 +1,6 @@
 use problemreductions::models::algebraic::SimultaneousIncongruences;
 use problemreductions::solvers::BruteForce;
+use problemreductions::solvers::BruteForceProblem as _;
 use problemreductions::traits::Problem;
 
 #[test]
@@ -10,11 +11,11 @@ fn test_simultaneous_incongruences_issue_example() {
     assert_eq!(problem.num_pairs(), 4);
     assert_eq!(problem.pairs(), &[(2, 2), (1, 3), (2, 5), (3, 7)]);
     assert_eq!(problem.lcm_moduli(), 210);
-    assert_eq!(problem.dims(), vec![210]);
+    assert_eq!(problem.dimensions(), vec![210]);
     // x=5: 5%2=1!=0(=2%2), 5%3=2!=1, 5%5=0!=2, 5%7=5!=3 => valid
-    assert!(problem.evaluate(&[5]));
+    assert!(problem.evaluate(&5).unwrap());
     // x=2: 2%2=0=2%2 => invalid (first incongruence violated)
-    assert!(!problem.evaluate(&[2]));
+    assert!(!problem.evaluate(&2).unwrap());
 }
 
 #[test]
@@ -22,10 +23,10 @@ fn test_simultaneous_incongruences_solver_finds_witness() {
     let problem = SimultaneousIncongruences::new(vec![(2, 2), (1, 3), (2, 5), (3, 7)]).unwrap();
     let solver = BruteForce::new();
 
-    let witness = solver.find_witness(&problem);
+    let witness = solver.solve(&problem).unwrap();
     // x=1: 1%2=1!=0, 1%3=1!=1? No, 1%3=1=1 so invalid!
     // x=3: 3%2=1!=0, 3%3=0!=1, 3%5=3!=2, 3%7=3!=3 => valid. First valid.
     assert!(witness.is_some());
     let w = witness.unwrap();
-    assert!(problem.evaluate(&w));
+    assert!(problem.evaluate(&w).unwrap());
 }